netdevice.h 51 KB

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