netdevice.h 46 KB

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