netdevice.h 46 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. INET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * Definitions for the Interfaces handler.
  7. *
  8. * Version: @(#)dev.h 1.0.10 08/12/93
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Corey Minyard <wf-rch!minyard@relay.EU.net>
  13. * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
  14. * Alan Cox, <Alan.Cox@linux.org>
  15. * Bjorn Ekwall. <bj0rn@blox.se>
  16. * Pekka Riikonen <priikone@poseidon.pspt.fi>
  17. *
  18. * This program is free software; you can redistribute it and/or
  19. * modify it under the terms of the GNU General Public License
  20. * as published by the Free Software Foundation; either version
  21. * 2 of the License, or (at your option) any later version.
  22. *
  23. * Moved to /usr/include/linux for NET3
  24. */
  25. #ifndef _LINUX_NETDEVICE_H
  26. #define _LINUX_NETDEVICE_H
  27. #include <linux/if.h>
  28. #include <linux/if_ether.h>
  29. #include <linux/if_packet.h>
  30. #ifdef __KERNEL__
  31. #include <linux/timer.h>
  32. #include <linux/delay.h>
  33. #include <asm/atomic.h>
  34. #include <asm/cache.h>
  35. #include <asm/byteorder.h>
  36. #include <linux/device.h>
  37. #include <linux/percpu.h>
  38. #include <linux/dmaengine.h>
  39. #include <linux/workqueue.h>
  40. #include <net/net_namespace.h>
  41. struct vlan_group;
  42. struct ethtool_ops;
  43. struct netpoll_info;
  44. /* 802.11 specific */
  45. struct wireless_dev;
  46. /* source back-compat hooks */
  47. #define SET_ETHTOOL_OPS(netdev,ops) \
  48. ( (netdev)->ethtool_ops = (ops) )
  49. #define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev
  50. functions are available. */
  51. #define HAVE_FREE_NETDEV /* free_netdev() */
  52. #define HAVE_NETDEV_PRIV /* netdev_priv() */
  53. #define NET_XMIT_SUCCESS 0
  54. #define NET_XMIT_DROP 1 /* skb dropped */
  55. #define NET_XMIT_CN 2 /* congestion notification */
  56. #define NET_XMIT_POLICED 3 /* skb is shot by police */
  57. #define NET_XMIT_BYPASS 4 /* packet does not leave via dequeue;
  58. (TC use only - dev_queue_xmit
  59. returns this as NET_XMIT_SUCCESS) */
  60. /* Backlog congestion levels */
  61. #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
  62. #define NET_RX_DROP 1 /* packet dropped */
  63. #define NET_RX_CN_LOW 2 /* storm alert, just in case */
  64. #define NET_RX_CN_MOD 3 /* Storm on its way! */
  65. #define NET_RX_CN_HIGH 4 /* The storm is here */
  66. #define NET_RX_BAD 5 /* packet dropped due to kernel error */
  67. /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
  68. * indicates that the device will soon be dropping packets, or already drops
  69. * some packets of the same priority; prompting us to send less aggressively. */
  70. #define net_xmit_eval(e) ((e) == NET_XMIT_CN? 0 : (e))
  71. #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
  72. #endif
  73. #define MAX_ADDR_LEN 32 /* Largest hardware address length */
  74. /* Driver transmit return codes */
  75. #define NETDEV_TX_OK 0 /* driver took care of packet */
  76. #define NETDEV_TX_BUSY 1 /* driver tx path was busy*/
  77. #define NETDEV_TX_LOCKED -1 /* driver tx lock was already taken */
  78. /*
  79. * Compute the worst case header length according to the protocols
  80. * used.
  81. */
  82. #if defined(CONFIG_WLAN_80211) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  83. # if defined(CONFIG_MAC80211_MESH)
  84. # define LL_MAX_HEADER 128
  85. # else
  86. # define LL_MAX_HEADER 96
  87. # endif
  88. #elif defined(CONFIG_TR)
  89. # define LL_MAX_HEADER 48
  90. #else
  91. # define LL_MAX_HEADER 32
  92. #endif
  93. #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
  94. !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
  95. !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
  96. !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
  97. #define MAX_HEADER LL_MAX_HEADER
  98. #else
  99. #define MAX_HEADER (LL_MAX_HEADER + 48)
  100. #endif
  101. struct net_device_subqueue
  102. {
  103. /* Give a control state for each queue. This struct may contain
  104. * per-queue locks in the future.
  105. */
  106. unsigned long state;
  107. };
  108. /*
  109. * Network device statistics. Akin to the 2.0 ether stats but
  110. * with byte counters.
  111. */
  112. struct net_device_stats
  113. {
  114. unsigned long rx_packets; /* total packets received */
  115. unsigned long tx_packets; /* total packets transmitted */
  116. unsigned long rx_bytes; /* total bytes received */
  117. unsigned long tx_bytes; /* total bytes transmitted */
  118. unsigned long rx_errors; /* bad packets received */
  119. unsigned long tx_errors; /* packet transmit problems */
  120. unsigned long rx_dropped; /* no space in linux buffers */
  121. unsigned long tx_dropped; /* no space available in linux */
  122. unsigned long multicast; /* multicast packets received */
  123. unsigned long collisions;
  124. /* detailed rx_errors: */
  125. unsigned long rx_length_errors;
  126. unsigned long rx_over_errors; /* receiver ring buff overflow */
  127. unsigned long rx_crc_errors; /* recved pkt with crc error */
  128. unsigned long rx_frame_errors; /* recv'd frame alignment error */
  129. unsigned long rx_fifo_errors; /* recv'r fifo overrun */
  130. unsigned long rx_missed_errors; /* receiver missed packet */
  131. /* detailed tx_errors */
  132. unsigned long tx_aborted_errors;
  133. unsigned long tx_carrier_errors;
  134. unsigned long tx_fifo_errors;
  135. unsigned long tx_heartbeat_errors;
  136. unsigned long tx_window_errors;
  137. /* for cslip etc */
  138. unsigned long rx_compressed;
  139. unsigned long tx_compressed;
  140. };
  141. /* Media selection options. */
  142. enum {
  143. IF_PORT_UNKNOWN = 0,
  144. IF_PORT_10BASE2,
  145. IF_PORT_10BASET,
  146. IF_PORT_AUI,
  147. IF_PORT_100BASET,
  148. IF_PORT_100BASETX,
  149. IF_PORT_100BASEFX
  150. };
  151. #ifdef __KERNEL__
  152. #include <linux/cache.h>
  153. #include <linux/skbuff.h>
  154. struct neighbour;
  155. struct neigh_parms;
  156. struct sk_buff;
  157. struct netif_rx_stats
  158. {
  159. unsigned total;
  160. unsigned dropped;
  161. unsigned time_squeeze;
  162. unsigned cpu_collision;
  163. };
  164. DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
  165. struct dev_addr_list
  166. {
  167. struct dev_addr_list *next;
  168. u8 da_addr[MAX_ADDR_LEN];
  169. u8 da_addrlen;
  170. u8 da_synced;
  171. int da_users;
  172. int da_gusers;
  173. };
  174. /*
  175. * We tag multicasts with these structures.
  176. */
  177. #define dev_mc_list dev_addr_list
  178. #define dmi_addr da_addr
  179. #define dmi_addrlen da_addrlen
  180. #define dmi_users da_users
  181. #define dmi_gusers da_gusers
  182. struct hh_cache
  183. {
  184. struct hh_cache *hh_next; /* Next entry */
  185. atomic_t hh_refcnt; /* number of users */
  186. /*
  187. * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
  188. * cache line on SMP.
  189. * They are mostly read, but hh_refcnt may be changed quite frequently,
  190. * incurring cache line ping pongs.
  191. */
  192. __be16 hh_type ____cacheline_aligned_in_smp;
  193. /* protocol identifier, f.e ETH_P_IP
  194. * NOTE: For VLANs, this will be the
  195. * encapuslated type. --BLG
  196. */
  197. u16 hh_len; /* length of header */
  198. int (*hh_output)(struct sk_buff *skb);
  199. seqlock_t hh_lock;
  200. /* cached hardware header; allow for machine alignment needs. */
  201. #define HH_DATA_MOD 16
  202. #define HH_DATA_OFF(__len) \
  203. (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
  204. #define HH_DATA_ALIGN(__len) \
  205. (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
  206. unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
  207. };
  208. /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  209. * Alternative is:
  210. * dev->hard_header_len ? (dev->hard_header_len +
  211. * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  212. *
  213. * We could use other alignment values, but we must maintain the
  214. * relationship HH alignment <= LL alignment.
  215. *
  216. * LL_ALLOCATED_SPACE also takes into account the tailroom the device
  217. * may need.
  218. */
  219. #define LL_RESERVED_SPACE(dev) \
  220. ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  221. #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
  222. ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  223. #define LL_ALLOCATED_SPACE(dev) \
  224. ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  225. struct header_ops {
  226. int (*create) (struct sk_buff *skb, struct net_device *dev,
  227. unsigned short type, const void *daddr,
  228. const void *saddr, unsigned len);
  229. int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
  230. int (*rebuild)(struct sk_buff *skb);
  231. #define HAVE_HEADER_CACHE
  232. int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
  233. void (*cache_update)(struct hh_cache *hh,
  234. const struct net_device *dev,
  235. const unsigned char *haddr);
  236. };
  237. /* These flag bits are private to the generic network queueing
  238. * layer, they may not be explicitly referenced by any other
  239. * code.
  240. */
  241. enum netdev_state_t
  242. {
  243. __LINK_STATE_XOFF=0,
  244. __LINK_STATE_START,
  245. __LINK_STATE_PRESENT,
  246. __LINK_STATE_SCHED,
  247. __LINK_STATE_NOCARRIER,
  248. __LINK_STATE_LINKWATCH_PENDING,
  249. __LINK_STATE_DORMANT,
  250. __LINK_STATE_QDISC_RUNNING,
  251. };
  252. /*
  253. * This structure holds at boot time configured netdevice settings. They
  254. * are then used in the device probing.
  255. */
  256. struct netdev_boot_setup {
  257. char name[IFNAMSIZ];
  258. struct ifmap map;
  259. };
  260. #define NETDEV_BOOT_SETUP_MAX 8
  261. extern int __init netdev_boot_setup(char *str);
  262. /*
  263. * Structure for NAPI scheduling similar to tasklet but with weighting
  264. */
  265. struct napi_struct {
  266. /* The poll_list must only be managed by the entity which
  267. * changes the state of the NAPI_STATE_SCHED bit. This means
  268. * whoever atomically sets that bit can add this napi_struct
  269. * to the per-cpu poll_list, and whoever clears that bit
  270. * can remove from the list right before clearing the bit.
  271. */
  272. struct list_head poll_list;
  273. unsigned long state;
  274. int weight;
  275. int (*poll)(struct napi_struct *, int);
  276. #ifdef CONFIG_NETPOLL
  277. spinlock_t poll_lock;
  278. int poll_owner;
  279. struct net_device *dev;
  280. struct list_head dev_list;
  281. #endif
  282. };
  283. enum
  284. {
  285. NAPI_STATE_SCHED, /* Poll is scheduled */
  286. NAPI_STATE_DISABLE, /* Disable pending */
  287. };
  288. extern void __napi_schedule(struct napi_struct *n);
  289. static inline int napi_disable_pending(struct napi_struct *n)
  290. {
  291. return test_bit(NAPI_STATE_DISABLE, &n->state);
  292. }
  293. /**
  294. * napi_schedule_prep - check if napi can be scheduled
  295. * @n: napi context
  296. *
  297. * Test if NAPI routine is already running, and if not mark
  298. * it as running. This is used as a condition variable
  299. * insure only one NAPI poll instance runs. We also make
  300. * sure there is no pending NAPI disable.
  301. */
  302. static inline int napi_schedule_prep(struct napi_struct *n)
  303. {
  304. return !napi_disable_pending(n) &&
  305. !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
  306. }
  307. /**
  308. * napi_schedule - schedule NAPI poll
  309. * @n: napi context
  310. *
  311. * Schedule NAPI poll routine to be called if it is not already
  312. * running.
  313. */
  314. static inline void napi_schedule(struct napi_struct *n)
  315. {
  316. if (napi_schedule_prep(n))
  317. __napi_schedule(n);
  318. }
  319. /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
  320. static inline int napi_reschedule(struct napi_struct *napi)
  321. {
  322. if (napi_schedule_prep(napi)) {
  323. __napi_schedule(napi);
  324. return 1;
  325. }
  326. return 0;
  327. }
  328. /**
  329. * napi_complete - NAPI processing complete
  330. * @n: napi context
  331. *
  332. * Mark NAPI processing as complete.
  333. */
  334. static inline void __napi_complete(struct napi_struct *n)
  335. {
  336. BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
  337. list_del(&n->poll_list);
  338. smp_mb__before_clear_bit();
  339. clear_bit(NAPI_STATE_SCHED, &n->state);
  340. }
  341. static inline void napi_complete(struct napi_struct *n)
  342. {
  343. unsigned long flags;
  344. local_irq_save(flags);
  345. __napi_complete(n);
  346. local_irq_restore(flags);
  347. }
  348. /**
  349. * napi_disable - prevent NAPI from scheduling
  350. * @n: napi context
  351. *
  352. * Stop NAPI from being scheduled on this context.
  353. * Waits till any outstanding processing completes.
  354. */
  355. static inline void napi_disable(struct napi_struct *n)
  356. {
  357. set_bit(NAPI_STATE_DISABLE, &n->state);
  358. while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
  359. msleep(1);
  360. clear_bit(NAPI_STATE_DISABLE, &n->state);
  361. }
  362. /**
  363. * napi_enable - enable NAPI scheduling
  364. * @n: napi context
  365. *
  366. * Resume NAPI from being scheduled on this context.
  367. * Must be paired with napi_disable.
  368. */
  369. static inline void napi_enable(struct napi_struct *n)
  370. {
  371. BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
  372. smp_mb__before_clear_bit();
  373. clear_bit(NAPI_STATE_SCHED, &n->state);
  374. }
  375. #ifdef CONFIG_SMP
  376. /**
  377. * napi_synchronize - wait until NAPI is not running
  378. * @n: napi context
  379. *
  380. * Wait until NAPI is done being scheduled on this context.
  381. * Waits till any outstanding processing completes but
  382. * does not disable future activations.
  383. */
  384. static inline void napi_synchronize(const struct napi_struct *n)
  385. {
  386. while (test_bit(NAPI_STATE_SCHED, &n->state))
  387. msleep(1);
  388. }
  389. #else
  390. # define napi_synchronize(n) barrier()
  391. #endif
  392. /*
  393. * The DEVICE structure.
  394. * Actually, this whole structure is a big mistake. It mixes I/O
  395. * data with strictly "high-level" data, and it has to know about
  396. * almost every data structure used in the INET module.
  397. *
  398. * FIXME: cleanup struct net_device such that network protocol info
  399. * moves out.
  400. */
  401. struct net_device
  402. {
  403. /*
  404. * This is the first field of the "visible" part of this structure
  405. * (i.e. as seen by users in the "Space.c" file). It is the name
  406. * the interface.
  407. */
  408. char name[IFNAMSIZ];
  409. /* device name hash chain */
  410. struct hlist_node name_hlist;
  411. /*
  412. * I/O specific fields
  413. * FIXME: Merge these and struct ifmap into one
  414. */
  415. unsigned long mem_end; /* shared mem end */
  416. unsigned long mem_start; /* shared mem start */
  417. unsigned long base_addr; /* device I/O address */
  418. unsigned int irq; /* device IRQ number */
  419. /*
  420. * Some hardware also needs these fields, but they are not
  421. * part of the usual set specified in Space.c.
  422. */
  423. unsigned char if_port; /* Selectable AUI, TP,..*/
  424. unsigned char dma; /* DMA channel */
  425. unsigned long state;
  426. struct list_head dev_list;
  427. #ifdef CONFIG_NETPOLL
  428. struct list_head napi_list;
  429. #endif
  430. /* The device initialization function. Called only once. */
  431. int (*init)(struct net_device *dev);
  432. /* ------- Fields preinitialized in Space.c finish here ------- */
  433. /* Net device features */
  434. unsigned long features;
  435. #define NETIF_F_SG 1 /* Scatter/gather IO. */
  436. #define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
  437. #define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
  438. #define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
  439. #define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
  440. #define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
  441. #define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
  442. #define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
  443. #define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
  444. #define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
  445. #define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
  446. #define NETIF_F_GSO 2048 /* Enable software GSO. */
  447. #define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
  448. /* do not use LLTX in new drivers */
  449. #define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
  450. #define NETIF_F_MULTI_QUEUE 16384 /* Has multiple TX/RX queues */
  451. #define NETIF_F_LRO 32768 /* large receive offload */
  452. /* Segmentation offload features */
  453. #define NETIF_F_GSO_SHIFT 16
  454. #define NETIF_F_GSO_MASK 0xffff0000
  455. #define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
  456. #define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
  457. #define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
  458. #define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
  459. #define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
  460. /* List of features with software fallbacks. */
  461. #define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
  462. #define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
  463. #define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
  464. #define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
  465. #define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
  466. struct net_device *next_sched;
  467. /* Interface index. Unique device identifier */
  468. int ifindex;
  469. int iflink;
  470. struct net_device_stats* (*get_stats)(struct net_device *dev);
  471. struct net_device_stats stats;
  472. #ifdef CONFIG_WIRELESS_EXT
  473. /* List of functions to handle Wireless Extensions (instead of ioctl).
  474. * See <net/iw_handler.h> for details. Jean II */
  475. const struct iw_handler_def * wireless_handlers;
  476. /* Instance data managed by the core of Wireless Extensions. */
  477. struct iw_public_data * wireless_data;
  478. #endif
  479. const struct ethtool_ops *ethtool_ops;
  480. /* Hardware header description */
  481. const struct header_ops *header_ops;
  482. /*
  483. * This marks the end of the "visible" part of the structure. All
  484. * fields hereafter are internal to the system, and may change at
  485. * will (read: may be cleaned up at will).
  486. */
  487. unsigned int flags; /* interface flags (a la BSD) */
  488. unsigned short gflags;
  489. unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */
  490. unsigned short padded; /* How much padding added by alloc_netdev() */
  491. unsigned char operstate; /* RFC2863 operstate */
  492. unsigned char link_mode; /* mapping policy to operstate */
  493. unsigned mtu; /* interface MTU value */
  494. unsigned short type; /* interface hardware type */
  495. unsigned short hard_header_len; /* hardware hdr length */
  496. /* extra head- and tailroom the hardware may need, but not in all cases
  497. * can this be guaranteed, especially tailroom. Some cases also use
  498. * LL_MAX_HEADER instead to allocate the skb.
  499. */
  500. unsigned short needed_headroom;
  501. unsigned short needed_tailroom;
  502. struct net_device *master; /* Pointer to master device of a group,
  503. * which this device is member of.
  504. */
  505. /* Interface address info. */
  506. unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
  507. unsigned char addr_len; /* hardware address length */
  508. unsigned short dev_id; /* for shared network cards */
  509. struct dev_addr_list *uc_list; /* Secondary unicast mac addresses */
  510. int uc_count; /* Number of installed ucasts */
  511. int uc_promisc;
  512. struct dev_addr_list *mc_list; /* Multicast mac addresses */
  513. int mc_count; /* Number of installed mcasts */
  514. int promiscuity;
  515. int allmulti;
  516. /* Protocol specific pointers */
  517. void *atalk_ptr; /* AppleTalk link */
  518. void *ip_ptr; /* IPv4 specific data */
  519. void *dn_ptr; /* DECnet specific data */
  520. void *ip6_ptr; /* IPv6 specific data */
  521. void *ec_ptr; /* Econet specific data */
  522. void *ax25_ptr; /* AX.25 specific data */
  523. struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
  524. assign before registering */
  525. /*
  526. * Cache line mostly used on receive path (including eth_type_trans())
  527. */
  528. unsigned long last_rx; /* Time of last Rx */
  529. /* Interface address info used in eth_type_trans() */
  530. unsigned char dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast
  531. because most packets are unicast) */
  532. unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
  533. /* ingress path synchronizer */
  534. spinlock_t ingress_lock;
  535. struct Qdisc *qdisc_ingress;
  536. /*
  537. * Cache line mostly used on queue transmit path (qdisc)
  538. */
  539. /* device queue lock */
  540. spinlock_t queue_lock ____cacheline_aligned_in_smp;
  541. struct Qdisc *qdisc;
  542. struct Qdisc *qdisc_sleeping;
  543. struct list_head qdisc_list;
  544. unsigned long tx_queue_len; /* Max frames per queue allowed */
  545. /* Partially transmitted GSO packet. */
  546. struct sk_buff *gso_skb;
  547. /*
  548. * One part is mostly used on xmit path (device)
  549. */
  550. /* hard_start_xmit synchronizer */
  551. spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
  552. /* cpu id of processor entered to hard_start_xmit or -1,
  553. if nobody entered there.
  554. */
  555. int xmit_lock_owner;
  556. void *priv; /* pointer to private data */
  557. int (*hard_start_xmit) (struct sk_buff *skb,
  558. struct net_device *dev);
  559. /* These may be needed for future network-power-down code. */
  560. unsigned long trans_start; /* Time (in jiffies) of last Tx */
  561. int watchdog_timeo; /* used by dev_watchdog() */
  562. struct timer_list watchdog_timer;
  563. /*
  564. * refcnt is a very hot point, so align it on SMP
  565. */
  566. /* Number of references to this device */
  567. atomic_t refcnt ____cacheline_aligned_in_smp;
  568. /* delayed register/unregister */
  569. struct list_head todo_list;
  570. /* device index hash chain */
  571. struct hlist_node index_hlist;
  572. struct net_device *link_watch_next;
  573. /* register/unregister state machine */
  574. enum { NETREG_UNINITIALIZED=0,
  575. NETREG_REGISTERED, /* completed register_netdevice */
  576. NETREG_UNREGISTERING, /* called unregister_netdevice */
  577. NETREG_UNREGISTERED, /* completed unregister todo */
  578. NETREG_RELEASED, /* called free_netdev */
  579. } reg_state;
  580. /* Called after device is detached from network. */
  581. void (*uninit)(struct net_device *dev);
  582. /* Called after last user reference disappears. */
  583. void (*destructor)(struct net_device *dev);
  584. /* Pointers to interface service routines. */
  585. int (*open)(struct net_device *dev);
  586. int (*stop)(struct net_device *dev);
  587. #define HAVE_NETDEV_POLL
  588. #define HAVE_CHANGE_RX_FLAGS
  589. void (*change_rx_flags)(struct net_device *dev,
  590. int flags);
  591. #define HAVE_SET_RX_MODE
  592. void (*set_rx_mode)(struct net_device *dev);
  593. #define HAVE_MULTICAST
  594. void (*set_multicast_list)(struct net_device *dev);
  595. #define HAVE_SET_MAC_ADDR
  596. int (*set_mac_address)(struct net_device *dev,
  597. void *addr);
  598. #define HAVE_VALIDATE_ADDR
  599. int (*validate_addr)(struct net_device *dev);
  600. #define HAVE_PRIVATE_IOCTL
  601. int (*do_ioctl)(struct net_device *dev,
  602. struct ifreq *ifr, int cmd);
  603. #define HAVE_SET_CONFIG
  604. int (*set_config)(struct net_device *dev,
  605. struct ifmap *map);
  606. #define HAVE_CHANGE_MTU
  607. int (*change_mtu)(struct net_device *dev, int new_mtu);
  608. #define HAVE_TX_TIMEOUT
  609. void (*tx_timeout) (struct net_device *dev);
  610. void (*vlan_rx_register)(struct net_device *dev,
  611. struct vlan_group *grp);
  612. void (*vlan_rx_add_vid)(struct net_device *dev,
  613. unsigned short vid);
  614. void (*vlan_rx_kill_vid)(struct net_device *dev,
  615. unsigned short vid);
  616. int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
  617. #ifdef CONFIG_NETPOLL
  618. struct netpoll_info *npinfo;
  619. #endif
  620. #ifdef CONFIG_NET_POLL_CONTROLLER
  621. void (*poll_controller)(struct net_device *dev);
  622. #endif
  623. #ifdef CONFIG_NET_NS
  624. /* Network namespace this network device is inside */
  625. struct net *nd_net;
  626. #endif
  627. /* mid-layer private */
  628. void *ml_priv;
  629. /* bridge stuff */
  630. struct net_bridge_port *br_port;
  631. /* macvlan */
  632. struct macvlan_port *macvlan_port;
  633. /* class/net/name entry */
  634. struct device dev;
  635. /* space for optional statistics and wireless sysfs groups */
  636. struct attribute_group *sysfs_groups[3];
  637. /* rtnetlink link ops */
  638. const struct rtnl_link_ops *rtnl_link_ops;
  639. /* for setting kernel sock attribute on TCP connection setup */
  640. #define GSO_MAX_SIZE 65536
  641. unsigned int gso_max_size;
  642. /* The TX queue control structures */
  643. unsigned int egress_subqueue_count;
  644. struct net_device_subqueue egress_subqueue[1];
  645. };
  646. #define to_net_dev(d) container_of(d, struct net_device, dev)
  647. #define NETDEV_ALIGN 32
  648. #define NETDEV_ALIGN_CONST (NETDEV_ALIGN - 1)
  649. /*
  650. * Net namespace inlines
  651. */
  652. static inline
  653. struct net *dev_net(const struct net_device *dev)
  654. {
  655. #ifdef CONFIG_NET_NS
  656. return dev->nd_net;
  657. #else
  658. return &init_net;
  659. #endif
  660. }
  661. static inline
  662. void dev_net_set(struct net_device *dev, struct net *net)
  663. {
  664. #ifdef CONFIG_NET_NS
  665. release_net(dev->nd_net);
  666. dev->nd_net = hold_net(net);
  667. #endif
  668. }
  669. /**
  670. * netdev_priv - access network device private data
  671. * @dev: network device
  672. *
  673. * Get network device private data
  674. */
  675. static inline void *netdev_priv(const struct net_device *dev)
  676. {
  677. return dev->priv;
  678. }
  679. /* Set the sysfs physical device reference for the network logical device
  680. * if set prior to registration will cause a symlink during initialization.
  681. */
  682. #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
  683. /**
  684. * netif_napi_add - initialize a napi context
  685. * @dev: network device
  686. * @napi: napi context
  687. * @poll: polling function
  688. * @weight: default weight
  689. *
  690. * netif_napi_add() must be used to initialize a napi context prior to calling
  691. * *any* of the other napi related functions.
  692. */
  693. static inline void netif_napi_add(struct net_device *dev,
  694. struct napi_struct *napi,
  695. int (*poll)(struct napi_struct *, int),
  696. int weight)
  697. {
  698. INIT_LIST_HEAD(&napi->poll_list);
  699. napi->poll = poll;
  700. napi->weight = weight;
  701. #ifdef CONFIG_NETPOLL
  702. napi->dev = dev;
  703. list_add(&napi->dev_list, &dev->napi_list);
  704. spin_lock_init(&napi->poll_lock);
  705. napi->poll_owner = -1;
  706. #endif
  707. set_bit(NAPI_STATE_SCHED, &napi->state);
  708. }
  709. struct packet_type {
  710. __be16 type; /* This is really htons(ether_type). */
  711. struct net_device *dev; /* NULL is wildcarded here */
  712. int (*func) (struct sk_buff *,
  713. struct net_device *,
  714. struct packet_type *,
  715. struct net_device *);
  716. struct sk_buff *(*gso_segment)(struct sk_buff *skb,
  717. int features);
  718. int (*gso_send_check)(struct sk_buff *skb);
  719. void *af_packet_priv;
  720. struct list_head list;
  721. };
  722. #include <linux/interrupt.h>
  723. #include <linux/notifier.h>
  724. extern rwlock_t dev_base_lock; /* Device list lock */
  725. #define for_each_netdev(net, d) \
  726. list_for_each_entry(d, &(net)->dev_base_head, dev_list)
  727. #define for_each_netdev_safe(net, d, n) \
  728. list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
  729. #define for_each_netdev_continue(net, d) \
  730. list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
  731. #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
  732. static inline struct net_device *next_net_device(struct net_device *dev)
  733. {
  734. struct list_head *lh;
  735. struct net *net;
  736. net = dev_net(dev);
  737. lh = dev->dev_list.next;
  738. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  739. }
  740. static inline struct net_device *first_net_device(struct net *net)
  741. {
  742. return list_empty(&net->dev_base_head) ? NULL :
  743. net_device_entry(net->dev_base_head.next);
  744. }
  745. extern int netdev_boot_setup_check(struct net_device *dev);
  746. extern unsigned long netdev_boot_base(const char *prefix, int unit);
  747. extern struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);
  748. extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
  749. extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
  750. extern void dev_add_pack(struct packet_type *pt);
  751. extern void dev_remove_pack(struct packet_type *pt);
  752. extern void __dev_remove_pack(struct packet_type *pt);
  753. extern struct net_device *dev_get_by_flags(struct net *net, unsigned short flags,
  754. unsigned short mask);
  755. extern struct net_device *dev_get_by_name(struct net *net, const char *name);
  756. extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
  757. extern int dev_alloc_name(struct net_device *dev, const char *name);
  758. extern int dev_open(struct net_device *dev);
  759. extern int dev_close(struct net_device *dev);
  760. extern int dev_queue_xmit(struct sk_buff *skb);
  761. extern int register_netdevice(struct net_device *dev);
  762. extern void unregister_netdevice(struct net_device *dev);
  763. extern void free_netdev(struct net_device *dev);
  764. extern void synchronize_net(void);
  765. extern int register_netdevice_notifier(struct notifier_block *nb);
  766. extern int unregister_netdevice_notifier(struct notifier_block *nb);
  767. extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
  768. extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
  769. extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
  770. extern int dev_restart(struct net_device *dev);
  771. #ifdef CONFIG_NETPOLL_TRAP
  772. extern int netpoll_trap(void);
  773. #endif
  774. static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
  775. unsigned short type,
  776. const void *daddr, const void *saddr,
  777. unsigned len)
  778. {
  779. if (!dev->header_ops || !dev->header_ops->create)
  780. return 0;
  781. return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
  782. }
  783. static inline int dev_parse_header(const struct sk_buff *skb,
  784. unsigned char *haddr)
  785. {
  786. const struct net_device *dev = skb->dev;
  787. if (!dev->header_ops || !dev->header_ops->parse)
  788. return 0;
  789. return dev->header_ops->parse(skb, haddr);
  790. }
  791. typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
  792. extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
  793. static inline int unregister_gifconf(unsigned int family)
  794. {
  795. return register_gifconf(family, NULL);
  796. }
  797. /*
  798. * Incoming packets are placed on per-cpu queues so that
  799. * no locking is needed.
  800. */
  801. struct softnet_data
  802. {
  803. struct net_device *output_queue;
  804. struct sk_buff_head input_pkt_queue;
  805. struct list_head poll_list;
  806. struct sk_buff *completion_queue;
  807. struct napi_struct backlog;
  808. #ifdef CONFIG_NET_DMA
  809. struct dma_chan *net_dma;
  810. #endif
  811. };
  812. DECLARE_PER_CPU(struct softnet_data,softnet_data);
  813. #define HAVE_NETIF_QUEUE
  814. extern void __netif_schedule(struct net_device *dev);
  815. static inline void netif_schedule(struct net_device *dev)
  816. {
  817. if (!test_bit(__LINK_STATE_XOFF, &dev->state))
  818. __netif_schedule(dev);
  819. }
  820. /**
  821. * netif_start_queue - allow transmit
  822. * @dev: network device
  823. *
  824. * Allow upper layers to call the device hard_start_xmit routine.
  825. */
  826. static inline void netif_start_queue(struct net_device *dev)
  827. {
  828. clear_bit(__LINK_STATE_XOFF, &dev->state);
  829. }
  830. /**
  831. * netif_wake_queue - restart transmit
  832. * @dev: network device
  833. *
  834. * Allow upper layers to call the device hard_start_xmit routine.
  835. * Used for flow control when transmit resources are available.
  836. */
  837. static inline void netif_wake_queue(struct net_device *dev)
  838. {
  839. #ifdef CONFIG_NETPOLL_TRAP
  840. if (netpoll_trap()) {
  841. clear_bit(__LINK_STATE_XOFF, &dev->state);
  842. return;
  843. }
  844. #endif
  845. if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
  846. __netif_schedule(dev);
  847. }
  848. /**
  849. * netif_stop_queue - stop transmitted packets
  850. * @dev: network device
  851. *
  852. * Stop upper layers calling the device hard_start_xmit routine.
  853. * Used for flow control when transmit resources are unavailable.
  854. */
  855. static inline void netif_stop_queue(struct net_device *dev)
  856. {
  857. set_bit(__LINK_STATE_XOFF, &dev->state);
  858. }
  859. /**
  860. * netif_queue_stopped - test if transmit queue is flowblocked
  861. * @dev: network device
  862. *
  863. * Test if transmit queue on device is currently unable to send.
  864. */
  865. static inline int netif_queue_stopped(const struct net_device *dev)
  866. {
  867. return test_bit(__LINK_STATE_XOFF, &dev->state);
  868. }
  869. /**
  870. * netif_running - test if up
  871. * @dev: network device
  872. *
  873. * Test if the device has been brought up.
  874. */
  875. static inline int netif_running(const struct net_device *dev)
  876. {
  877. return test_bit(__LINK_STATE_START, &dev->state);
  878. }
  879. /*
  880. * Routines to manage the subqueues on a device. We only need start
  881. * stop, and a check if it's stopped. All other device management is
  882. * done at the overall netdevice level.
  883. * Also test the device if we're multiqueue.
  884. */
  885. /**
  886. * netif_start_subqueue - allow sending packets on subqueue
  887. * @dev: network device
  888. * @queue_index: sub queue index
  889. *
  890. * Start individual transmit queue of a device with multiple transmit queues.
  891. */
  892. static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
  893. {
  894. #ifdef CONFIG_NETDEVICES_MULTIQUEUE
  895. clear_bit(__LINK_STATE_XOFF, &dev->egress_subqueue[queue_index].state);
  896. #endif
  897. }
  898. /**
  899. * netif_stop_subqueue - stop sending packets on subqueue
  900. * @dev: network device
  901. * @queue_index: sub queue index
  902. *
  903. * Stop individual transmit queue of a device with multiple transmit queues.
  904. */
  905. static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
  906. {
  907. #ifdef CONFIG_NETDEVICES_MULTIQUEUE
  908. #ifdef CONFIG_NETPOLL_TRAP
  909. if (netpoll_trap())
  910. return;
  911. #endif
  912. set_bit(__LINK_STATE_XOFF, &dev->egress_subqueue[queue_index].state);
  913. #endif
  914. }
  915. /**
  916. * netif_subqueue_stopped - test status of subqueue
  917. * @dev: network device
  918. * @queue_index: sub queue index
  919. *
  920. * Check individual transmit queue of a device with multiple transmit queues.
  921. */
  922. static inline int __netif_subqueue_stopped(const struct net_device *dev,
  923. u16 queue_index)
  924. {
  925. #ifdef CONFIG_NETDEVICES_MULTIQUEUE
  926. return test_bit(__LINK_STATE_XOFF,
  927. &dev->egress_subqueue[queue_index].state);
  928. #else
  929. return 0;
  930. #endif
  931. }
  932. static inline int netif_subqueue_stopped(const struct net_device *dev,
  933. struct sk_buff *skb)
  934. {
  935. return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
  936. }
  937. /**
  938. * netif_wake_subqueue - allow sending packets on subqueue
  939. * @dev: network device
  940. * @queue_index: sub queue index
  941. *
  942. * Resume individual transmit queue of a device with multiple transmit queues.
  943. */
  944. static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
  945. {
  946. #ifdef CONFIG_NETDEVICES_MULTIQUEUE
  947. #ifdef CONFIG_NETPOLL_TRAP
  948. if (netpoll_trap())
  949. return;
  950. #endif
  951. if (test_and_clear_bit(__LINK_STATE_XOFF,
  952. &dev->egress_subqueue[queue_index].state))
  953. __netif_schedule(dev);
  954. #endif
  955. }
  956. /**
  957. * netif_is_multiqueue - test if device has multiple transmit queues
  958. * @dev: network device
  959. *
  960. * Check if device has multiple transmit queues
  961. * Always falls if NETDEVICE_MULTIQUEUE is not configured
  962. */
  963. static inline int netif_is_multiqueue(const struct net_device *dev)
  964. {
  965. #ifdef CONFIG_NETDEVICES_MULTIQUEUE
  966. return (!!(NETIF_F_MULTI_QUEUE & dev->features));
  967. #else
  968. return 0;
  969. #endif
  970. }
  971. /* Use this variant when it is known for sure that it
  972. * is executing from hardware interrupt context or with hardware interrupts
  973. * disabled.
  974. */
  975. extern void dev_kfree_skb_irq(struct sk_buff *skb);
  976. /* Use this variant in places where it could be invoked
  977. * from either hardware interrupt or other context, with hardware interrupts
  978. * either disabled or enabled.
  979. */
  980. extern void dev_kfree_skb_any(struct sk_buff *skb);
  981. #define HAVE_NETIF_RX 1
  982. extern int netif_rx(struct sk_buff *skb);
  983. extern int netif_rx_ni(struct sk_buff *skb);
  984. #define HAVE_NETIF_RECEIVE_SKB 1
  985. extern int netif_receive_skb(struct sk_buff *skb);
  986. extern int dev_valid_name(const char *name);
  987. extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
  988. extern int dev_ethtool(struct net *net, struct ifreq *);
  989. extern unsigned dev_get_flags(const struct net_device *);
  990. extern int dev_change_flags(struct net_device *, unsigned);
  991. extern int dev_change_name(struct net_device *, char *);
  992. extern int dev_change_net_namespace(struct net_device *,
  993. struct net *, const char *);
  994. extern int dev_set_mtu(struct net_device *, int);
  995. extern int dev_set_mac_address(struct net_device *,
  996. struct sockaddr *);
  997. extern int dev_hard_start_xmit(struct sk_buff *skb,
  998. struct net_device *dev);
  999. extern int netdev_budget;
  1000. /* Called by rtnetlink.c:rtnl_unlock() */
  1001. extern void netdev_run_todo(void);
  1002. /**
  1003. * dev_put - release reference to device
  1004. * @dev: network device
  1005. *
  1006. * Release reference to device to allow it to be freed.
  1007. */
  1008. static inline void dev_put(struct net_device *dev)
  1009. {
  1010. atomic_dec(&dev->refcnt);
  1011. }
  1012. /**
  1013. * dev_hold - get reference to device
  1014. * @dev: network device
  1015. *
  1016. * Hold reference to device to keep it from being freed.
  1017. */
  1018. static inline void dev_hold(struct net_device *dev)
  1019. {
  1020. atomic_inc(&dev->refcnt);
  1021. }
  1022. /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  1023. * and _off may be called from IRQ context, but it is caller
  1024. * who is responsible for serialization of these calls.
  1025. *
  1026. * The name carrier is inappropriate, these functions should really be
  1027. * called netif_lowerlayer_*() because they represent the state of any
  1028. * kind of lower layer not just hardware media.
  1029. */
  1030. extern void linkwatch_fire_event(struct net_device *dev);
  1031. /**
  1032. * netif_carrier_ok - test if carrier present
  1033. * @dev: network device
  1034. *
  1035. * Check if carrier is present on device
  1036. */
  1037. static inline int netif_carrier_ok(const struct net_device *dev)
  1038. {
  1039. return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  1040. }
  1041. extern void __netdev_watchdog_up(struct net_device *dev);
  1042. extern void netif_carrier_on(struct net_device *dev);
  1043. extern void netif_carrier_off(struct net_device *dev);
  1044. /**
  1045. * netif_dormant_on - mark device as dormant.
  1046. * @dev: network device
  1047. *
  1048. * Mark device as dormant (as per RFC2863).
  1049. *
  1050. * The dormant state indicates that the relevant interface is not
  1051. * actually in a condition to pass packets (i.e., it is not 'up') but is
  1052. * in a "pending" state, waiting for some external event. For "on-
  1053. * demand" interfaces, this new state identifies the situation where the
  1054. * interface is waiting for events to place it in the up state.
  1055. *
  1056. */
  1057. static inline void netif_dormant_on(struct net_device *dev)
  1058. {
  1059. if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
  1060. linkwatch_fire_event(dev);
  1061. }
  1062. /**
  1063. * netif_dormant_off - set device as not dormant.
  1064. * @dev: network device
  1065. *
  1066. * Device is not in dormant state.
  1067. */
  1068. static inline void netif_dormant_off(struct net_device *dev)
  1069. {
  1070. if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
  1071. linkwatch_fire_event(dev);
  1072. }
  1073. /**
  1074. * netif_dormant - test if carrier present
  1075. * @dev: network device
  1076. *
  1077. * Check if carrier is present on device
  1078. */
  1079. static inline int netif_dormant(const struct net_device *dev)
  1080. {
  1081. return test_bit(__LINK_STATE_DORMANT, &dev->state);
  1082. }
  1083. /**
  1084. * netif_oper_up - test if device is operational
  1085. * @dev: network device
  1086. *
  1087. * Check if carrier is operational
  1088. */
  1089. static inline int netif_oper_up(const struct net_device *dev) {
  1090. return (dev->operstate == IF_OPER_UP ||
  1091. dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
  1092. }
  1093. /**
  1094. * netif_device_present - is device available or removed
  1095. * @dev: network device
  1096. *
  1097. * Check if device has not been removed from system.
  1098. */
  1099. static inline int netif_device_present(struct net_device *dev)
  1100. {
  1101. return test_bit(__LINK_STATE_PRESENT, &dev->state);
  1102. }
  1103. extern void netif_device_detach(struct net_device *dev);
  1104. extern void netif_device_attach(struct net_device *dev);
  1105. /*
  1106. * Network interface message level settings
  1107. */
  1108. #define HAVE_NETIF_MSG 1
  1109. enum {
  1110. NETIF_MSG_DRV = 0x0001,
  1111. NETIF_MSG_PROBE = 0x0002,
  1112. NETIF_MSG_LINK = 0x0004,
  1113. NETIF_MSG_TIMER = 0x0008,
  1114. NETIF_MSG_IFDOWN = 0x0010,
  1115. NETIF_MSG_IFUP = 0x0020,
  1116. NETIF_MSG_RX_ERR = 0x0040,
  1117. NETIF_MSG_TX_ERR = 0x0080,
  1118. NETIF_MSG_TX_QUEUED = 0x0100,
  1119. NETIF_MSG_INTR = 0x0200,
  1120. NETIF_MSG_TX_DONE = 0x0400,
  1121. NETIF_MSG_RX_STATUS = 0x0800,
  1122. NETIF_MSG_PKTDATA = 0x1000,
  1123. NETIF_MSG_HW = 0x2000,
  1124. NETIF_MSG_WOL = 0x4000,
  1125. };
  1126. #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
  1127. #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
  1128. #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
  1129. #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
  1130. #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
  1131. #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
  1132. #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
  1133. #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
  1134. #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
  1135. #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
  1136. #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
  1137. #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
  1138. #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
  1139. #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
  1140. #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
  1141. static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
  1142. {
  1143. /* use default */
  1144. if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  1145. return default_msg_enable_bits;
  1146. if (debug_value == 0) /* no output */
  1147. return 0;
  1148. /* set low N bits */
  1149. return (1 << debug_value) - 1;
  1150. }
  1151. /* Test if receive needs to be scheduled but only if up */
  1152. static inline int netif_rx_schedule_prep(struct net_device *dev,
  1153. struct napi_struct *napi)
  1154. {
  1155. return napi_schedule_prep(napi);
  1156. }
  1157. /* Add interface to tail of rx poll list. This assumes that _prep has
  1158. * already been called and returned 1.
  1159. */
  1160. static inline void __netif_rx_schedule(struct net_device *dev,
  1161. struct napi_struct *napi)
  1162. {
  1163. __napi_schedule(napi);
  1164. }
  1165. /* Try to reschedule poll. Called by irq handler. */
  1166. static inline void netif_rx_schedule(struct net_device *dev,
  1167. struct napi_struct *napi)
  1168. {
  1169. if (netif_rx_schedule_prep(dev, napi))
  1170. __netif_rx_schedule(dev, napi);
  1171. }
  1172. /* Try to reschedule poll. Called by dev->poll() after netif_rx_complete(). */
  1173. static inline int netif_rx_reschedule(struct net_device *dev,
  1174. struct napi_struct *napi)
  1175. {
  1176. if (napi_schedule_prep(napi)) {
  1177. __netif_rx_schedule(dev, napi);
  1178. return 1;
  1179. }
  1180. return 0;
  1181. }
  1182. /* same as netif_rx_complete, except that local_irq_save(flags)
  1183. * has already been issued
  1184. */
  1185. static inline void __netif_rx_complete(struct net_device *dev,
  1186. struct napi_struct *napi)
  1187. {
  1188. __napi_complete(napi);
  1189. }
  1190. /* Remove interface from poll list: it must be in the poll list
  1191. * on current cpu. This primitive is called by dev->poll(), when
  1192. * it completes the work. The device cannot be out of poll list at this
  1193. * moment, it is BUG().
  1194. */
  1195. static inline void netif_rx_complete(struct net_device *dev,
  1196. struct napi_struct *napi)
  1197. {
  1198. unsigned long flags;
  1199. local_irq_save(flags);
  1200. __netif_rx_complete(dev, napi);
  1201. local_irq_restore(flags);
  1202. }
  1203. /**
  1204. * netif_tx_lock - grab network device transmit lock
  1205. * @dev: network device
  1206. * @cpu: cpu number of lock owner
  1207. *
  1208. * Get network device transmit lock
  1209. */
  1210. static inline void __netif_tx_lock(struct net_device *dev, int cpu)
  1211. {
  1212. spin_lock(&dev->_xmit_lock);
  1213. dev->xmit_lock_owner = cpu;
  1214. }
  1215. static inline void netif_tx_lock(struct net_device *dev)
  1216. {
  1217. __netif_tx_lock(dev, smp_processor_id());
  1218. }
  1219. static inline void netif_tx_lock_bh(struct net_device *dev)
  1220. {
  1221. spin_lock_bh(&dev->_xmit_lock);
  1222. dev->xmit_lock_owner = smp_processor_id();
  1223. }
  1224. static inline int netif_tx_trylock(struct net_device *dev)
  1225. {
  1226. int ok = spin_trylock(&dev->_xmit_lock);
  1227. if (likely(ok))
  1228. dev->xmit_lock_owner = smp_processor_id();
  1229. return ok;
  1230. }
  1231. static inline void netif_tx_unlock(struct net_device *dev)
  1232. {
  1233. dev->xmit_lock_owner = -1;
  1234. spin_unlock(&dev->_xmit_lock);
  1235. }
  1236. static inline void netif_tx_unlock_bh(struct net_device *dev)
  1237. {
  1238. dev->xmit_lock_owner = -1;
  1239. spin_unlock_bh(&dev->_xmit_lock);
  1240. }
  1241. #define HARD_TX_LOCK(dev, cpu) { \
  1242. if ((dev->features & NETIF_F_LLTX) == 0) { \
  1243. __netif_tx_lock(dev, cpu); \
  1244. } \
  1245. }
  1246. #define HARD_TX_UNLOCK(dev) { \
  1247. if ((dev->features & NETIF_F_LLTX) == 0) { \
  1248. netif_tx_unlock(dev); \
  1249. } \
  1250. }
  1251. static inline void netif_tx_disable(struct net_device *dev)
  1252. {
  1253. netif_tx_lock_bh(dev);
  1254. netif_stop_queue(dev);
  1255. netif_tx_unlock_bh(dev);
  1256. }
  1257. /* These functions live elsewhere (drivers/net/net_init.c, but related) */
  1258. extern void ether_setup(struct net_device *dev);
  1259. /* Support for loadable net-drivers */
  1260. extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
  1261. void (*setup)(struct net_device *),
  1262. unsigned int queue_count);
  1263. #define alloc_netdev(sizeof_priv, name, setup) \
  1264. alloc_netdev_mq(sizeof_priv, name, setup, 1)
  1265. extern int register_netdev(struct net_device *dev);
  1266. extern void unregister_netdev(struct net_device *dev);
  1267. /* Functions used for secondary unicast and multicast support */
  1268. extern void dev_set_rx_mode(struct net_device *dev);
  1269. extern void __dev_set_rx_mode(struct net_device *dev);
  1270. extern int dev_unicast_delete(struct net_device *dev, void *addr, int alen);
  1271. extern int dev_unicast_add(struct net_device *dev, void *addr, int alen);
  1272. extern int dev_unicast_sync(struct net_device *to, struct net_device *from);
  1273. extern void dev_unicast_unsync(struct net_device *to, struct net_device *from);
  1274. extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
  1275. extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
  1276. extern int dev_mc_sync(struct net_device *to, struct net_device *from);
  1277. extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
  1278. extern int __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
  1279. extern int __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
  1280. extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
  1281. extern void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count);
  1282. extern void dev_set_promiscuity(struct net_device *dev, int inc);
  1283. extern void dev_set_allmulti(struct net_device *dev, int inc);
  1284. extern void netdev_state_change(struct net_device *dev);
  1285. extern void netdev_features_change(struct net_device *dev);
  1286. /* Load a device via the kmod */
  1287. extern void dev_load(struct net *net, const char *name);
  1288. extern void dev_mcast_init(void);
  1289. extern int netdev_max_backlog;
  1290. extern int weight_p;
  1291. extern int netdev_set_master(struct net_device *dev, struct net_device *master);
  1292. extern int skb_checksum_help(struct sk_buff *skb);
  1293. extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
  1294. #ifdef CONFIG_BUG
  1295. extern void netdev_rx_csum_fault(struct net_device *dev);
  1296. #else
  1297. static inline void netdev_rx_csum_fault(struct net_device *dev)
  1298. {
  1299. }
  1300. #endif
  1301. /* rx skb timestamps */
  1302. extern void net_enable_timestamp(void);
  1303. extern void net_disable_timestamp(void);
  1304. #ifdef CONFIG_PROC_FS
  1305. extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
  1306. extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
  1307. extern void dev_seq_stop(struct seq_file *seq, void *v);
  1308. #endif
  1309. extern void linkwatch_run_queue(void);
  1310. extern int netdev_compute_features(unsigned long all, unsigned long one);
  1311. static inline int net_gso_ok(int features, int gso_type)
  1312. {
  1313. int feature = gso_type << NETIF_F_GSO_SHIFT;
  1314. return (features & feature) == feature;
  1315. }
  1316. static inline int skb_gso_ok(struct sk_buff *skb, int features)
  1317. {
  1318. return net_gso_ok(features, skb_shinfo(skb)->gso_type);
  1319. }
  1320. static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
  1321. {
  1322. return skb_is_gso(skb) &&
  1323. (!skb_gso_ok(skb, dev->features) ||
  1324. unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
  1325. }
  1326. static inline void netif_set_gso_max_size(struct net_device *dev,
  1327. unsigned int size)
  1328. {
  1329. dev->gso_max_size = size;
  1330. }
  1331. /* On bonding slaves other than the currently active slave, suppress
  1332. * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
  1333. * ARP on active-backup slaves with arp_validate enabled.
  1334. */
  1335. static inline int skb_bond_should_drop(struct sk_buff *skb)
  1336. {
  1337. struct net_device *dev = skb->dev;
  1338. struct net_device *master = dev->master;
  1339. if (master &&
  1340. (dev->priv_flags & IFF_SLAVE_INACTIVE)) {
  1341. if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
  1342. skb->protocol == __constant_htons(ETH_P_ARP))
  1343. return 0;
  1344. if (master->priv_flags & IFF_MASTER_ALB) {
  1345. if (skb->pkt_type != PACKET_BROADCAST &&
  1346. skb->pkt_type != PACKET_MULTICAST)
  1347. return 0;
  1348. }
  1349. if (master->priv_flags & IFF_MASTER_8023AD &&
  1350. skb->protocol == __constant_htons(ETH_P_SLOW))
  1351. return 0;
  1352. return 1;
  1353. }
  1354. return 0;
  1355. }
  1356. #endif /* __KERNEL__ */
  1357. #endif /* _LINUX_DEV_H */