netdevice.h 59 KB

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