netdevice.h 84 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755
  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. #include <linux/if_link.h>
  31. #ifdef __KERNEL__
  32. #include <linux/pm_qos_params.h>
  33. #include <linux/timer.h>
  34. #include <linux/delay.h>
  35. #include <linux/mm.h>
  36. #include <asm/atomic.h>
  37. #include <asm/cache.h>
  38. #include <asm/byteorder.h>
  39. #include <linux/device.h>
  40. #include <linux/percpu.h>
  41. #include <linux/rculist.h>
  42. #include <linux/dmaengine.h>
  43. #include <linux/workqueue.h>
  44. #include <linux/ethtool.h>
  45. #include <net/net_namespace.h>
  46. #include <net/dsa.h>
  47. #ifdef CONFIG_DCB
  48. #include <net/dcbnl.h>
  49. #endif
  50. struct vlan_group;
  51. struct netpoll_info;
  52. struct phy_device;
  53. /* 802.11 specific */
  54. struct wireless_dev;
  55. /* source back-compat hooks */
  56. #define SET_ETHTOOL_OPS(netdev,ops) \
  57. ( (netdev)->ethtool_ops = (ops) )
  58. #define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev
  59. functions are available. */
  60. #define HAVE_FREE_NETDEV /* free_netdev() */
  61. #define HAVE_NETDEV_PRIV /* netdev_priv() */
  62. /* hardware address assignment types */
  63. #define NET_ADDR_PERM 0 /* address is permanent (default) */
  64. #define NET_ADDR_RANDOM 1 /* address is generated randomly */
  65. #define NET_ADDR_STOLEN 2 /* address is stolen from other device */
  66. /* Backlog congestion levels */
  67. #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
  68. #define NET_RX_DROP 1 /* packet dropped */
  69. /*
  70. * Transmit return codes: transmit return codes originate from three different
  71. * namespaces:
  72. *
  73. * - qdisc return codes
  74. * - driver transmit return codes
  75. * - errno values
  76. *
  77. * Drivers are allowed to return any one of those in their hard_start_xmit()
  78. * function. Real network devices commonly used with qdiscs should only return
  79. * the driver transmit return codes though - when qdiscs are used, the actual
  80. * transmission happens asynchronously, so the value is not propagated to
  81. * higher layers. Virtual network devices transmit synchronously, in this case
  82. * the driver transmit return codes are consumed by dev_queue_xmit(), all
  83. * others are propagated to higher layers.
  84. */
  85. /* qdisc ->enqueue() return codes. */
  86. #define NET_XMIT_SUCCESS 0x00
  87. #define NET_XMIT_DROP 0x01 /* skb dropped */
  88. #define NET_XMIT_CN 0x02 /* congestion notification */
  89. #define NET_XMIT_POLICED 0x03 /* skb is shot by police */
  90. #define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
  91. /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
  92. * indicates that the device will soon be dropping packets, or already drops
  93. * some packets of the same priority; prompting us to send less aggressively. */
  94. #define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
  95. #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
  96. /* Driver transmit return codes */
  97. #define NETDEV_TX_MASK 0xf0
  98. enum netdev_tx {
  99. __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
  100. NETDEV_TX_OK = 0x00, /* driver took care of packet */
  101. NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
  102. NETDEV_TX_LOCKED = 0x20, /* driver tx lock was already taken */
  103. };
  104. typedef enum netdev_tx netdev_tx_t;
  105. /*
  106. * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
  107. * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
  108. */
  109. static inline bool dev_xmit_complete(int rc)
  110. {
  111. /*
  112. * Positive cases with an skb consumed by a driver:
  113. * - successful transmission (rc == NETDEV_TX_OK)
  114. * - error while transmitting (rc < 0)
  115. * - error while queueing to a different device (rc & NET_XMIT_MASK)
  116. */
  117. if (likely(rc < NET_XMIT_MASK))
  118. return true;
  119. return false;
  120. }
  121. #endif
  122. #define MAX_ADDR_LEN 32 /* Largest hardware address length */
  123. /* Initial net device group. All devices belong to group 0 by default. */
  124. #define INIT_NETDEV_GROUP 0
  125. #ifdef __KERNEL__
  126. /*
  127. * Compute the worst case header length according to the protocols
  128. * used.
  129. */
  130. #if defined(CONFIG_WLAN) || defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  131. # if defined(CONFIG_MAC80211_MESH)
  132. # define LL_MAX_HEADER 128
  133. # else
  134. # define LL_MAX_HEADER 96
  135. # endif
  136. #elif defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
  137. # define LL_MAX_HEADER 48
  138. #else
  139. # define LL_MAX_HEADER 32
  140. #endif
  141. #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
  142. !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
  143. !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
  144. !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
  145. #define MAX_HEADER LL_MAX_HEADER
  146. #else
  147. #define MAX_HEADER (LL_MAX_HEADER + 48)
  148. #endif
  149. /*
  150. * Old network device statistics. Fields are native words
  151. * (unsigned long) so they can be read and written atomically.
  152. */
  153. struct net_device_stats {
  154. unsigned long rx_packets;
  155. unsigned long tx_packets;
  156. unsigned long rx_bytes;
  157. unsigned long tx_bytes;
  158. unsigned long rx_errors;
  159. unsigned long tx_errors;
  160. unsigned long rx_dropped;
  161. unsigned long tx_dropped;
  162. unsigned long multicast;
  163. unsigned long collisions;
  164. unsigned long rx_length_errors;
  165. unsigned long rx_over_errors;
  166. unsigned long rx_crc_errors;
  167. unsigned long rx_frame_errors;
  168. unsigned long rx_fifo_errors;
  169. unsigned long rx_missed_errors;
  170. unsigned long tx_aborted_errors;
  171. unsigned long tx_carrier_errors;
  172. unsigned long tx_fifo_errors;
  173. unsigned long tx_heartbeat_errors;
  174. unsigned long tx_window_errors;
  175. unsigned long rx_compressed;
  176. unsigned long tx_compressed;
  177. };
  178. #endif /* __KERNEL__ */
  179. /* Media selection options. */
  180. enum {
  181. IF_PORT_UNKNOWN = 0,
  182. IF_PORT_10BASE2,
  183. IF_PORT_10BASET,
  184. IF_PORT_AUI,
  185. IF_PORT_100BASET,
  186. IF_PORT_100BASETX,
  187. IF_PORT_100BASEFX
  188. };
  189. #ifdef __KERNEL__
  190. #include <linux/cache.h>
  191. #include <linux/skbuff.h>
  192. struct neighbour;
  193. struct neigh_parms;
  194. struct sk_buff;
  195. struct netdev_hw_addr {
  196. struct list_head list;
  197. unsigned char addr[MAX_ADDR_LEN];
  198. unsigned char type;
  199. #define NETDEV_HW_ADDR_T_LAN 1
  200. #define NETDEV_HW_ADDR_T_SAN 2
  201. #define NETDEV_HW_ADDR_T_SLAVE 3
  202. #define NETDEV_HW_ADDR_T_UNICAST 4
  203. #define NETDEV_HW_ADDR_T_MULTICAST 5
  204. bool synced;
  205. bool global_use;
  206. int refcount;
  207. struct rcu_head rcu_head;
  208. };
  209. struct netdev_hw_addr_list {
  210. struct list_head list;
  211. int count;
  212. };
  213. #define netdev_hw_addr_list_count(l) ((l)->count)
  214. #define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
  215. #define netdev_hw_addr_list_for_each(ha, l) \
  216. list_for_each_entry(ha, &(l)->list, list)
  217. #define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
  218. #define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
  219. #define netdev_for_each_uc_addr(ha, dev) \
  220. netdev_hw_addr_list_for_each(ha, &(dev)->uc)
  221. #define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
  222. #define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
  223. #define netdev_for_each_mc_addr(ha, dev) \
  224. netdev_hw_addr_list_for_each(ha, &(dev)->mc)
  225. struct hh_cache {
  226. struct hh_cache *hh_next; /* Next entry */
  227. atomic_t hh_refcnt; /* number of users */
  228. /*
  229. * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
  230. * cache line on SMP.
  231. * They are mostly read, but hh_refcnt may be changed quite frequently,
  232. * incurring cache line ping pongs.
  233. */
  234. __be16 hh_type ____cacheline_aligned_in_smp;
  235. /* protocol identifier, f.e ETH_P_IP
  236. * NOTE: For VLANs, this will be the
  237. * encapuslated type. --BLG
  238. */
  239. u16 hh_len; /* length of header */
  240. int (*hh_output)(struct sk_buff *skb);
  241. seqlock_t hh_lock;
  242. /* cached hardware header; allow for machine alignment needs. */
  243. #define HH_DATA_MOD 16
  244. #define HH_DATA_OFF(__len) \
  245. (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
  246. #define HH_DATA_ALIGN(__len) \
  247. (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
  248. unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
  249. };
  250. static inline void hh_cache_put(struct hh_cache *hh)
  251. {
  252. if (atomic_dec_and_test(&hh->hh_refcnt))
  253. kfree(hh);
  254. }
  255. /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  256. * Alternative is:
  257. * dev->hard_header_len ? (dev->hard_header_len +
  258. * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  259. *
  260. * We could use other alignment values, but we must maintain the
  261. * relationship HH alignment <= LL alignment.
  262. *
  263. * LL_ALLOCATED_SPACE also takes into account the tailroom the device
  264. * may need.
  265. */
  266. #define LL_RESERVED_SPACE(dev) \
  267. ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  268. #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
  269. ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  270. #define LL_ALLOCATED_SPACE(dev) \
  271. ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  272. struct header_ops {
  273. int (*create) (struct sk_buff *skb, struct net_device *dev,
  274. unsigned short type, const void *daddr,
  275. const void *saddr, unsigned len);
  276. int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
  277. int (*rebuild)(struct sk_buff *skb);
  278. #define HAVE_HEADER_CACHE
  279. int (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
  280. void (*cache_update)(struct hh_cache *hh,
  281. const struct net_device *dev,
  282. const unsigned char *haddr);
  283. };
  284. /* These flag bits are private to the generic network queueing
  285. * layer, they may not be explicitly referenced by any other
  286. * code.
  287. */
  288. enum netdev_state_t {
  289. __LINK_STATE_START,
  290. __LINK_STATE_PRESENT,
  291. __LINK_STATE_NOCARRIER,
  292. __LINK_STATE_LINKWATCH_PENDING,
  293. __LINK_STATE_DORMANT,
  294. };
  295. /*
  296. * This structure holds at boot time configured netdevice settings. They
  297. * are then used in the device probing.
  298. */
  299. struct netdev_boot_setup {
  300. char name[IFNAMSIZ];
  301. struct ifmap map;
  302. };
  303. #define NETDEV_BOOT_SETUP_MAX 8
  304. extern int __init netdev_boot_setup(char *str);
  305. /*
  306. * Structure for NAPI scheduling similar to tasklet but with weighting
  307. */
  308. struct napi_struct {
  309. /* The poll_list must only be managed by the entity which
  310. * changes the state of the NAPI_STATE_SCHED bit. This means
  311. * whoever atomically sets that bit can add this napi_struct
  312. * to the per-cpu poll_list, and whoever clears that bit
  313. * can remove from the list right before clearing the bit.
  314. */
  315. struct list_head poll_list;
  316. unsigned long state;
  317. int weight;
  318. int (*poll)(struct napi_struct *, int);
  319. #ifdef CONFIG_NETPOLL
  320. spinlock_t poll_lock;
  321. int poll_owner;
  322. #endif
  323. unsigned int gro_count;
  324. struct net_device *dev;
  325. struct list_head dev_list;
  326. struct sk_buff *gro_list;
  327. struct sk_buff *skb;
  328. };
  329. enum {
  330. NAPI_STATE_SCHED, /* Poll is scheduled */
  331. NAPI_STATE_DISABLE, /* Disable pending */
  332. NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
  333. };
  334. enum gro_result {
  335. GRO_MERGED,
  336. GRO_MERGED_FREE,
  337. GRO_HELD,
  338. GRO_NORMAL,
  339. GRO_DROP,
  340. };
  341. typedef enum gro_result gro_result_t;
  342. /*
  343. * enum rx_handler_result - Possible return values for rx_handlers.
  344. * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
  345. * further.
  346. * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
  347. * case skb->dev was changed by rx_handler.
  348. * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
  349. * @RX_HANDLER_PASS: Do nothing, passe the skb as if no rx_handler was called.
  350. *
  351. * rx_handlers are functions called from inside __netif_receive_skb(), to do
  352. * special processing of the skb, prior to delivery to protocol handlers.
  353. *
  354. * Currently, a net_device can only have a single rx_handler registered. Trying
  355. * to register a second rx_handler will return -EBUSY.
  356. *
  357. * To register a rx_handler on a net_device, use netdev_rx_handler_register().
  358. * To unregister a rx_handler on a net_device, use
  359. * netdev_rx_handler_unregister().
  360. *
  361. * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
  362. * do with the skb.
  363. *
  364. * If the rx_handler consumed to skb in some way, it should return
  365. * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
  366. * the skb to be delivered in some other ways.
  367. *
  368. * If the rx_handler changed skb->dev, to divert the skb to another
  369. * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
  370. * new device will be called if it exists.
  371. *
  372. * If the rx_handler consider the skb should be ignored, it should return
  373. * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
  374. * are registred on exact device (ptype->dev == skb->dev).
  375. *
  376. * If the rx_handler didn't changed skb->dev, but want the skb to be normally
  377. * delivered, it should return RX_HANDLER_PASS.
  378. *
  379. * A device without a registered rx_handler will behave as if rx_handler
  380. * returned RX_HANDLER_PASS.
  381. */
  382. enum rx_handler_result {
  383. RX_HANDLER_CONSUMED,
  384. RX_HANDLER_ANOTHER,
  385. RX_HANDLER_EXACT,
  386. RX_HANDLER_PASS,
  387. };
  388. typedef enum rx_handler_result rx_handler_result_t;
  389. typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
  390. extern void __napi_schedule(struct napi_struct *n);
  391. static inline int napi_disable_pending(struct napi_struct *n)
  392. {
  393. return test_bit(NAPI_STATE_DISABLE, &n->state);
  394. }
  395. /**
  396. * napi_schedule_prep - check if napi can be scheduled
  397. * @n: napi context
  398. *
  399. * Test if NAPI routine is already running, and if not mark
  400. * it as running. This is used as a condition variable
  401. * insure only one NAPI poll instance runs. We also make
  402. * sure there is no pending NAPI disable.
  403. */
  404. static inline int napi_schedule_prep(struct napi_struct *n)
  405. {
  406. return !napi_disable_pending(n) &&
  407. !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
  408. }
  409. /**
  410. * napi_schedule - schedule NAPI poll
  411. * @n: napi context
  412. *
  413. * Schedule NAPI poll routine to be called if it is not already
  414. * running.
  415. */
  416. static inline void napi_schedule(struct napi_struct *n)
  417. {
  418. if (napi_schedule_prep(n))
  419. __napi_schedule(n);
  420. }
  421. /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
  422. static inline int napi_reschedule(struct napi_struct *napi)
  423. {
  424. if (napi_schedule_prep(napi)) {
  425. __napi_schedule(napi);
  426. return 1;
  427. }
  428. return 0;
  429. }
  430. /**
  431. * napi_complete - NAPI processing complete
  432. * @n: napi context
  433. *
  434. * Mark NAPI processing as complete.
  435. */
  436. extern void __napi_complete(struct napi_struct *n);
  437. extern void napi_complete(struct napi_struct *n);
  438. /**
  439. * napi_disable - prevent NAPI from scheduling
  440. * @n: napi context
  441. *
  442. * Stop NAPI from being scheduled on this context.
  443. * Waits till any outstanding processing completes.
  444. */
  445. static inline void napi_disable(struct napi_struct *n)
  446. {
  447. set_bit(NAPI_STATE_DISABLE, &n->state);
  448. while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
  449. msleep(1);
  450. clear_bit(NAPI_STATE_DISABLE, &n->state);
  451. }
  452. /**
  453. * napi_enable - enable NAPI scheduling
  454. * @n: napi context
  455. *
  456. * Resume NAPI from being scheduled on this context.
  457. * Must be paired with napi_disable.
  458. */
  459. static inline void napi_enable(struct napi_struct *n)
  460. {
  461. BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
  462. smp_mb__before_clear_bit();
  463. clear_bit(NAPI_STATE_SCHED, &n->state);
  464. }
  465. #ifdef CONFIG_SMP
  466. /**
  467. * napi_synchronize - wait until NAPI is not running
  468. * @n: napi context
  469. *
  470. * Wait until NAPI is done being scheduled on this context.
  471. * Waits till any outstanding processing completes but
  472. * does not disable future activations.
  473. */
  474. static inline void napi_synchronize(const struct napi_struct *n)
  475. {
  476. while (test_bit(NAPI_STATE_SCHED, &n->state))
  477. msleep(1);
  478. }
  479. #else
  480. # define napi_synchronize(n) barrier()
  481. #endif
  482. enum netdev_queue_state_t {
  483. __QUEUE_STATE_XOFF,
  484. __QUEUE_STATE_FROZEN,
  485. #define QUEUE_STATE_XOFF_OR_FROZEN ((1 << __QUEUE_STATE_XOFF) | \
  486. (1 << __QUEUE_STATE_FROZEN))
  487. };
  488. struct netdev_queue {
  489. /*
  490. * read mostly part
  491. */
  492. struct net_device *dev;
  493. struct Qdisc *qdisc;
  494. unsigned long state;
  495. struct Qdisc *qdisc_sleeping;
  496. #ifdef CONFIG_RPS
  497. struct kobject kobj;
  498. #endif
  499. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  500. int numa_node;
  501. #endif
  502. /*
  503. * write mostly part
  504. */
  505. spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
  506. int xmit_lock_owner;
  507. /*
  508. * please use this field instead of dev->trans_start
  509. */
  510. unsigned long trans_start;
  511. } ____cacheline_aligned_in_smp;
  512. static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
  513. {
  514. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  515. return q->numa_node;
  516. #else
  517. return NUMA_NO_NODE;
  518. #endif
  519. }
  520. static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
  521. {
  522. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  523. q->numa_node = node;
  524. #endif
  525. }
  526. #ifdef CONFIG_RPS
  527. /*
  528. * This structure holds an RPS map which can be of variable length. The
  529. * map is an array of CPUs.
  530. */
  531. struct rps_map {
  532. unsigned int len;
  533. struct rcu_head rcu;
  534. u16 cpus[0];
  535. };
  536. #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + (_num * sizeof(u16)))
  537. /*
  538. * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
  539. * tail pointer for that CPU's input queue at the time of last enqueue, and
  540. * a hardware filter index.
  541. */
  542. struct rps_dev_flow {
  543. u16 cpu;
  544. u16 filter;
  545. unsigned int last_qtail;
  546. };
  547. #define RPS_NO_FILTER 0xffff
  548. /*
  549. * The rps_dev_flow_table structure contains a table of flow mappings.
  550. */
  551. struct rps_dev_flow_table {
  552. unsigned int mask;
  553. struct rcu_head rcu;
  554. struct work_struct free_work;
  555. struct rps_dev_flow flows[0];
  556. };
  557. #define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
  558. (_num * sizeof(struct rps_dev_flow)))
  559. /*
  560. * The rps_sock_flow_table contains mappings of flows to the last CPU
  561. * on which they were processed by the application (set in recvmsg).
  562. */
  563. struct rps_sock_flow_table {
  564. unsigned int mask;
  565. u16 ents[0];
  566. };
  567. #define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
  568. (_num * sizeof(u16)))
  569. #define RPS_NO_CPU 0xffff
  570. static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
  571. u32 hash)
  572. {
  573. if (table && hash) {
  574. unsigned int cpu, index = hash & table->mask;
  575. /* We only give a hint, preemption can change cpu under us */
  576. cpu = raw_smp_processor_id();
  577. if (table->ents[index] != cpu)
  578. table->ents[index] = cpu;
  579. }
  580. }
  581. static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
  582. u32 hash)
  583. {
  584. if (table && hash)
  585. table->ents[hash & table->mask] = RPS_NO_CPU;
  586. }
  587. extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
  588. #ifdef CONFIG_RFS_ACCEL
  589. extern bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
  590. u32 flow_id, u16 filter_id);
  591. #endif
  592. /* This structure contains an instance of an RX queue. */
  593. struct netdev_rx_queue {
  594. struct rps_map __rcu *rps_map;
  595. struct rps_dev_flow_table __rcu *rps_flow_table;
  596. struct kobject kobj;
  597. struct net_device *dev;
  598. } ____cacheline_aligned_in_smp;
  599. #endif /* CONFIG_RPS */
  600. #ifdef CONFIG_XPS
  601. /*
  602. * This structure holds an XPS map which can be of variable length. The
  603. * map is an array of queues.
  604. */
  605. struct xps_map {
  606. unsigned int len;
  607. unsigned int alloc_len;
  608. struct rcu_head rcu;
  609. u16 queues[0];
  610. };
  611. #define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + (_num * sizeof(u16)))
  612. #define XPS_MIN_MAP_ALLOC ((L1_CACHE_BYTES - sizeof(struct xps_map)) \
  613. / sizeof(u16))
  614. /*
  615. * This structure holds all XPS maps for device. Maps are indexed by CPU.
  616. */
  617. struct xps_dev_maps {
  618. struct rcu_head rcu;
  619. struct xps_map __rcu *cpu_map[0];
  620. };
  621. #define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \
  622. (nr_cpu_ids * sizeof(struct xps_map *)))
  623. #endif /* CONFIG_XPS */
  624. #define TC_MAX_QUEUE 16
  625. #define TC_BITMASK 15
  626. /* HW offloaded queuing disciplines txq count and offset maps */
  627. struct netdev_tc_txq {
  628. u16 count;
  629. u16 offset;
  630. };
  631. /*
  632. * This structure defines the management hooks for network devices.
  633. * The following hooks can be defined; unless noted otherwise, they are
  634. * optional and can be filled with a null pointer.
  635. *
  636. * int (*ndo_init)(struct net_device *dev);
  637. * This function is called once when network device is registered.
  638. * The network device can use this to any late stage initializaton
  639. * or semantic validattion. It can fail with an error code which will
  640. * be propogated back to register_netdev
  641. *
  642. * void (*ndo_uninit)(struct net_device *dev);
  643. * This function is called when device is unregistered or when registration
  644. * fails. It is not called if init fails.
  645. *
  646. * int (*ndo_open)(struct net_device *dev);
  647. * This function is called when network device transistions to the up
  648. * state.
  649. *
  650. * int (*ndo_stop)(struct net_device *dev);
  651. * This function is called when network device transistions to the down
  652. * state.
  653. *
  654. * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
  655. * struct net_device *dev);
  656. * Called when a packet needs to be transmitted.
  657. * Must return NETDEV_TX_OK , NETDEV_TX_BUSY.
  658. * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX)
  659. * Required can not be NULL.
  660. *
  661. * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb);
  662. * Called to decide which queue to when device supports multiple
  663. * transmit queues.
  664. *
  665. * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
  666. * This function is called to allow device receiver to make
  667. * changes to configuration when multicast or promiscious is enabled.
  668. *
  669. * void (*ndo_set_rx_mode)(struct net_device *dev);
  670. * This function is called device changes address list filtering.
  671. *
  672. * void (*ndo_set_multicast_list)(struct net_device *dev);
  673. * This function is called when the multicast address list changes.
  674. *
  675. * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
  676. * This function is called when the Media Access Control address
  677. * needs to be changed. If this interface is not defined, the
  678. * mac address can not be changed.
  679. *
  680. * int (*ndo_validate_addr)(struct net_device *dev);
  681. * Test if Media Access Control address is valid for the device.
  682. *
  683. * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
  684. * Called when a user request an ioctl which can't be handled by
  685. * the generic interface code. If not defined ioctl's return
  686. * not supported error code.
  687. *
  688. * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
  689. * Used to set network devices bus interface parameters. This interface
  690. * is retained for legacy reason, new devices should use the bus
  691. * interface (PCI) for low level management.
  692. *
  693. * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
  694. * Called when a user wants to change the Maximum Transfer Unit
  695. * of a device. If not defined, any request to change MTU will
  696. * will return an error.
  697. *
  698. * void (*ndo_tx_timeout)(struct net_device *dev);
  699. * Callback uses when the transmitter has not made any progress
  700. * for dev->watchdog ticks.
  701. *
  702. * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
  703. * struct rtnl_link_stats64 *storage);
  704. * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  705. * Called when a user wants to get the network device usage
  706. * statistics. Drivers must do one of the following:
  707. * 1. Define @ndo_get_stats64 to fill in a zero-initialised
  708. * rtnl_link_stats64 structure passed by the caller.
  709. * 2. Define @ndo_get_stats to update a net_device_stats structure
  710. * (which should normally be dev->stats) and return a pointer to
  711. * it. The structure may be changed asynchronously only if each
  712. * field is written atomically.
  713. * 3. Update dev->stats asynchronously and atomically, and define
  714. * neither operation.
  715. *
  716. * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
  717. * If device support VLAN receive acceleration
  718. * (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
  719. * when vlan groups for the device changes. Note: grp is NULL
  720. * if no vlan's groups are being used.
  721. *
  722. * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
  723. * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  724. * this function is called when a VLAN id is registered.
  725. *
  726. * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
  727. * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  728. * this function is called when a VLAN id is unregistered.
  729. *
  730. * void (*ndo_poll_controller)(struct net_device *dev);
  731. *
  732. * SR-IOV management functions.
  733. * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
  734. * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
  735. * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
  736. * int (*ndo_get_vf_config)(struct net_device *dev,
  737. * int vf, struct ifla_vf_info *ivf);
  738. * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
  739. * struct nlattr *port[]);
  740. * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
  741. * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
  742. * Called to setup 'tc' number of traffic classes in the net device. This
  743. * is always called from the stack with the rtnl lock held and netif tx
  744. * queues stopped. This allows the netdevice to perform queue management
  745. * safely.
  746. *
  747. * Fiber Channel over Ethernet (FCoE) offload functions.
  748. * int (*ndo_fcoe_enable)(struct net_device *dev);
  749. * Called when the FCoE protocol stack wants to start using LLD for FCoE
  750. * so the underlying device can perform whatever needed configuration or
  751. * initialization to support acceleration of FCoE traffic.
  752. *
  753. * int (*ndo_fcoe_disable)(struct net_device *dev);
  754. * Called when the FCoE protocol stack wants to stop using LLD for FCoE
  755. * so the underlying device can perform whatever needed clean-ups to
  756. * stop supporting acceleration of FCoE traffic.
  757. *
  758. * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
  759. * struct scatterlist *sgl, unsigned int sgc);
  760. * Called when the FCoE Initiator wants to initialize an I/O that
  761. * is a possible candidate for Direct Data Placement (DDP). The LLD can
  762. * perform necessary setup and returns 1 to indicate the device is set up
  763. * successfully to perform DDP on this I/O, otherwise this returns 0.
  764. *
  765. * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
  766. * Called when the FCoE Initiator/Target is done with the DDPed I/O as
  767. * indicated by the FC exchange id 'xid', so the underlying device can
  768. * clean up and reuse resources for later DDP requests.
  769. *
  770. * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
  771. * struct scatterlist *sgl, unsigned int sgc);
  772. * Called when the FCoE Target wants to initialize an I/O that
  773. * is a possible candidate for Direct Data Placement (DDP). The LLD can
  774. * perform necessary setup and returns 1 to indicate the device is set up
  775. * successfully to perform DDP on this I/O, otherwise this returns 0.
  776. *
  777. * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
  778. * Called when the underlying device wants to override default World Wide
  779. * Name (WWN) generation mechanism in FCoE protocol stack to pass its own
  780. * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
  781. * protocol stack to use.
  782. *
  783. * RFS acceleration.
  784. * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
  785. * u16 rxq_index, u32 flow_id);
  786. * Set hardware filter for RFS. rxq_index is the target queue index;
  787. * flow_id is a flow ID to be passed to rps_may_expire_flow() later.
  788. * Return the filter ID on success, or a negative error code.
  789. *
  790. * Slave management functions (for bridge, bonding, etc). User should
  791. * call netdev_set_master() to set dev->master properly.
  792. * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
  793. * Called to make another netdev an underling.
  794. *
  795. * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
  796. * Called to release previously enslaved netdev.
  797. *
  798. * Feature/offload setting functions.
  799. * u32 (*ndo_fix_features)(struct net_device *dev, u32 features);
  800. * Adjusts the requested feature flags according to device-specific
  801. * constraints, and returns the resulting flags. Must not modify
  802. * the device state.
  803. *
  804. * int (*ndo_set_features)(struct net_device *dev, u32 features);
  805. * Called to update device configuration to new features. Passed
  806. * feature set might be less than what was returned by ndo_fix_features()).
  807. * Must return >0 or -errno if it changed dev->features itself.
  808. *
  809. */
  810. #define HAVE_NET_DEVICE_OPS
  811. struct net_device_ops {
  812. int (*ndo_init)(struct net_device *dev);
  813. void (*ndo_uninit)(struct net_device *dev);
  814. int (*ndo_open)(struct net_device *dev);
  815. int (*ndo_stop)(struct net_device *dev);
  816. netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb,
  817. struct net_device *dev);
  818. u16 (*ndo_select_queue)(struct net_device *dev,
  819. struct sk_buff *skb);
  820. void (*ndo_change_rx_flags)(struct net_device *dev,
  821. int flags);
  822. void (*ndo_set_rx_mode)(struct net_device *dev);
  823. void (*ndo_set_multicast_list)(struct net_device *dev);
  824. int (*ndo_set_mac_address)(struct net_device *dev,
  825. void *addr);
  826. int (*ndo_validate_addr)(struct net_device *dev);
  827. int (*ndo_do_ioctl)(struct net_device *dev,
  828. struct ifreq *ifr, int cmd);
  829. int (*ndo_set_config)(struct net_device *dev,
  830. struct ifmap *map);
  831. int (*ndo_change_mtu)(struct net_device *dev,
  832. int new_mtu);
  833. int (*ndo_neigh_setup)(struct net_device *dev,
  834. struct neigh_parms *);
  835. void (*ndo_tx_timeout) (struct net_device *dev);
  836. struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
  837. struct rtnl_link_stats64 *storage);
  838. struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  839. void (*ndo_vlan_rx_register)(struct net_device *dev,
  840. struct vlan_group *grp);
  841. void (*ndo_vlan_rx_add_vid)(struct net_device *dev,
  842. unsigned short vid);
  843. void (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
  844. unsigned short vid);
  845. #ifdef CONFIG_NET_POLL_CONTROLLER
  846. void (*ndo_poll_controller)(struct net_device *dev);
  847. int (*ndo_netpoll_setup)(struct net_device *dev,
  848. struct netpoll_info *info);
  849. void (*ndo_netpoll_cleanup)(struct net_device *dev);
  850. #endif
  851. int (*ndo_set_vf_mac)(struct net_device *dev,
  852. int queue, u8 *mac);
  853. int (*ndo_set_vf_vlan)(struct net_device *dev,
  854. int queue, u16 vlan, u8 qos);
  855. int (*ndo_set_vf_tx_rate)(struct net_device *dev,
  856. int vf, int rate);
  857. int (*ndo_get_vf_config)(struct net_device *dev,
  858. int vf,
  859. struct ifla_vf_info *ivf);
  860. int (*ndo_set_vf_port)(struct net_device *dev,
  861. int vf,
  862. struct nlattr *port[]);
  863. int (*ndo_get_vf_port)(struct net_device *dev,
  864. int vf, struct sk_buff *skb);
  865. int (*ndo_setup_tc)(struct net_device *dev, u8 tc);
  866. #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
  867. int (*ndo_fcoe_enable)(struct net_device *dev);
  868. int (*ndo_fcoe_disable)(struct net_device *dev);
  869. int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
  870. u16 xid,
  871. struct scatterlist *sgl,
  872. unsigned int sgc);
  873. int (*ndo_fcoe_ddp_done)(struct net_device *dev,
  874. u16 xid);
  875. int (*ndo_fcoe_ddp_target)(struct net_device *dev,
  876. u16 xid,
  877. struct scatterlist *sgl,
  878. unsigned int sgc);
  879. #define NETDEV_FCOE_WWNN 0
  880. #define NETDEV_FCOE_WWPN 1
  881. int (*ndo_fcoe_get_wwn)(struct net_device *dev,
  882. u64 *wwn, int type);
  883. #endif
  884. #ifdef CONFIG_RFS_ACCEL
  885. int (*ndo_rx_flow_steer)(struct net_device *dev,
  886. const struct sk_buff *skb,
  887. u16 rxq_index,
  888. u32 flow_id);
  889. #endif
  890. int (*ndo_add_slave)(struct net_device *dev,
  891. struct net_device *slave_dev);
  892. int (*ndo_del_slave)(struct net_device *dev,
  893. struct net_device *slave_dev);
  894. u32 (*ndo_fix_features)(struct net_device *dev,
  895. u32 features);
  896. int (*ndo_set_features)(struct net_device *dev,
  897. u32 features);
  898. };
  899. /*
  900. * The DEVICE structure.
  901. * Actually, this whole structure is a big mistake. It mixes I/O
  902. * data with strictly "high-level" data, and it has to know about
  903. * almost every data structure used in the INET module.
  904. *
  905. * FIXME: cleanup struct net_device such that network protocol info
  906. * moves out.
  907. */
  908. struct net_device {
  909. /*
  910. * This is the first field of the "visible" part of this structure
  911. * (i.e. as seen by users in the "Space.c" file). It is the name
  912. * of the interface.
  913. */
  914. char name[IFNAMSIZ];
  915. struct pm_qos_request_list pm_qos_req;
  916. /* device name hash chain */
  917. struct hlist_node name_hlist;
  918. /* snmp alias */
  919. char *ifalias;
  920. /*
  921. * I/O specific fields
  922. * FIXME: Merge these and struct ifmap into one
  923. */
  924. unsigned long mem_end; /* shared mem end */
  925. unsigned long mem_start; /* shared mem start */
  926. unsigned long base_addr; /* device I/O address */
  927. unsigned int irq; /* device IRQ number */
  928. /*
  929. * Some hardware also needs these fields, but they are not
  930. * part of the usual set specified in Space.c.
  931. */
  932. unsigned long state;
  933. struct list_head dev_list;
  934. struct list_head napi_list;
  935. struct list_head unreg_list;
  936. /* currently active device features */
  937. u32 features;
  938. /* user-changeable features */
  939. u32 hw_features;
  940. /* user-requested features */
  941. u32 wanted_features;
  942. /* mask of features inheritable by VLAN devices */
  943. u32 vlan_features;
  944. /* Net device feature bits; if you change something,
  945. * also update netdev_features_strings[] in ethtool.c */
  946. #define NETIF_F_SG 1 /* Scatter/gather IO. */
  947. #define NETIF_F_IP_CSUM 2 /* Can checksum TCP/UDP over IPv4. */
  948. #define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
  949. #define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
  950. #define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */
  951. #define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
  952. #define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
  953. #define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
  954. #define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
  955. #define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
  956. #define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
  957. #define NETIF_F_GSO 2048 /* Enable software GSO. */
  958. #define NETIF_F_LLTX 4096 /* LockLess TX - deprecated. Please */
  959. /* do not use LLTX in new drivers */
  960. #define NETIF_F_NETNS_LOCAL 8192 /* Does not change network namespaces */
  961. #define NETIF_F_GRO 16384 /* Generic receive offload */
  962. #define NETIF_F_LRO 32768 /* large receive offload */
  963. /* the GSO_MASK reserves bits 16 through 23 */
  964. #define NETIF_F_FCOE_CRC (1 << 24) /* FCoE CRC32 */
  965. #define NETIF_F_SCTP_CSUM (1 << 25) /* SCTP checksum offload */
  966. #define NETIF_F_FCOE_MTU (1 << 26) /* Supports max FCoE MTU, 2158 bytes*/
  967. #define NETIF_F_NTUPLE (1 << 27) /* N-tuple filters supported */
  968. #define NETIF_F_RXHASH (1 << 28) /* Receive hashing offload */
  969. #define NETIF_F_RXCSUM (1 << 29) /* Receive checksumming offload */
  970. #define NETIF_F_NOCACHE_COPY (1 << 30) /* Use no-cache copyfromuser */
  971. #define NETIF_F_LOOPBACK (1 << 31) /* Enable loopback */
  972. /* Segmentation offload features */
  973. #define NETIF_F_GSO_SHIFT 16
  974. #define NETIF_F_GSO_MASK 0x00ff0000
  975. #define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
  976. #define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
  977. #define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
  978. #define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
  979. #define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
  980. #define NETIF_F_FSO (SKB_GSO_FCOE << NETIF_F_GSO_SHIFT)
  981. /* Features valid for ethtool to change */
  982. /* = all defined minus driver/device-class-related */
  983. #define NETIF_F_NEVER_CHANGE (NETIF_F_VLAN_CHALLENGED | \
  984. NETIF_F_LLTX | NETIF_F_NETNS_LOCAL)
  985. #define NETIF_F_ETHTOOL_BITS (0xff3fffff & ~NETIF_F_NEVER_CHANGE)
  986. /* List of features with software fallbacks. */
  987. #define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | \
  988. NETIF_F_TSO6 | NETIF_F_UFO)
  989. #define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
  990. #define NETIF_F_V4_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IP_CSUM)
  991. #define NETIF_F_V6_CSUM (NETIF_F_GEN_CSUM | NETIF_F_IPV6_CSUM)
  992. #define NETIF_F_ALL_CSUM (NETIF_F_V4_CSUM | NETIF_F_V6_CSUM)
  993. #define NETIF_F_ALL_TSO (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
  994. #define NETIF_F_ALL_FCOE (NETIF_F_FCOE_CRC | NETIF_F_FCOE_MTU | \
  995. NETIF_F_FSO)
  996. #define NETIF_F_ALL_TX_OFFLOADS (NETIF_F_ALL_CSUM | NETIF_F_SG | \
  997. NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
  998. NETIF_F_HIGHDMA | \
  999. NETIF_F_SCTP_CSUM | \
  1000. NETIF_F_ALL_FCOE)
  1001. /*
  1002. * If one device supports one of these features, then enable them
  1003. * for all in netdev_increment_features.
  1004. */
  1005. #define NETIF_F_ONE_FOR_ALL (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
  1006. NETIF_F_SG | NETIF_F_HIGHDMA | \
  1007. NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
  1008. /*
  1009. * If one device doesn't support one of these features, then disable it
  1010. * for all in netdev_increment_features.
  1011. */
  1012. #define NETIF_F_ALL_FOR_ALL (NETIF_F_NOCACHE_COPY | NETIF_F_FSO)
  1013. /* changeable features with no special hardware requirements */
  1014. #define NETIF_F_SOFT_FEATURES (NETIF_F_GSO | NETIF_F_GRO)
  1015. /* Interface index. Unique device identifier */
  1016. int ifindex;
  1017. int iflink;
  1018. struct net_device_stats stats;
  1019. atomic_long_t rx_dropped; /* dropped packets by core network
  1020. * Do not use this in drivers.
  1021. */
  1022. #ifdef CONFIG_WIRELESS_EXT
  1023. /* List of functions to handle Wireless Extensions (instead of ioctl).
  1024. * See <net/iw_handler.h> for details. Jean II */
  1025. const struct iw_handler_def * wireless_handlers;
  1026. /* Instance data managed by the core of Wireless Extensions. */
  1027. struct iw_public_data * wireless_data;
  1028. #endif
  1029. /* Management operations */
  1030. const struct net_device_ops *netdev_ops;
  1031. const struct ethtool_ops *ethtool_ops;
  1032. /* Hardware header description */
  1033. const struct header_ops *header_ops;
  1034. unsigned int flags; /* interface flags (a la BSD) */
  1035. unsigned int priv_flags; /* Like 'flags' but invisible to userspace. */
  1036. unsigned short gflags;
  1037. unsigned short padded; /* How much padding added by alloc_netdev() */
  1038. unsigned char operstate; /* RFC2863 operstate */
  1039. unsigned char link_mode; /* mapping policy to operstate */
  1040. unsigned char if_port; /* Selectable AUI, TP,..*/
  1041. unsigned char dma; /* DMA channel */
  1042. unsigned int mtu; /* interface MTU value */
  1043. unsigned short type; /* interface hardware type */
  1044. unsigned short hard_header_len; /* hardware hdr length */
  1045. /* extra head- and tailroom the hardware may need, but not in all cases
  1046. * can this be guaranteed, especially tailroom. Some cases also use
  1047. * LL_MAX_HEADER instead to allocate the skb.
  1048. */
  1049. unsigned short needed_headroom;
  1050. unsigned short needed_tailroom;
  1051. /* Interface address info. */
  1052. unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
  1053. unsigned char addr_assign_type; /* hw address assignment type */
  1054. unsigned char addr_len; /* hardware address length */
  1055. unsigned short dev_id; /* for shared network cards */
  1056. spinlock_t addr_list_lock;
  1057. struct netdev_hw_addr_list uc; /* Unicast mac addresses */
  1058. struct netdev_hw_addr_list mc; /* Multicast mac addresses */
  1059. int uc_promisc;
  1060. unsigned int promiscuity;
  1061. unsigned int allmulti;
  1062. /* Protocol specific pointers */
  1063. #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
  1064. struct vlan_group __rcu *vlgrp; /* VLAN group */
  1065. #endif
  1066. #ifdef CONFIG_NET_DSA
  1067. void *dsa_ptr; /* dsa specific data */
  1068. #endif
  1069. void *atalk_ptr; /* AppleTalk link */
  1070. struct in_device __rcu *ip_ptr; /* IPv4 specific data */
  1071. struct dn_dev __rcu *dn_ptr; /* DECnet specific data */
  1072. struct inet6_dev __rcu *ip6_ptr; /* IPv6 specific data */
  1073. void *ec_ptr; /* Econet specific data */
  1074. void *ax25_ptr; /* AX.25 specific data */
  1075. struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
  1076. assign before registering */
  1077. /*
  1078. * Cache lines mostly used on receive path (including eth_type_trans())
  1079. */
  1080. unsigned long last_rx; /* Time of last Rx
  1081. * This should not be set in
  1082. * drivers, unless really needed,
  1083. * because network stack (bonding)
  1084. * use it if/when necessary, to
  1085. * avoid dirtying this cache line.
  1086. */
  1087. struct net_device *master; /* Pointer to master device of a group,
  1088. * which this device is member of.
  1089. */
  1090. /* Interface address info used in eth_type_trans() */
  1091. unsigned char *dev_addr; /* hw address, (before bcast
  1092. because most packets are
  1093. unicast) */
  1094. struct netdev_hw_addr_list dev_addrs; /* list of device
  1095. hw addresses */
  1096. unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
  1097. #ifdef CONFIG_RPS
  1098. struct kset *queues_kset;
  1099. struct netdev_rx_queue *_rx;
  1100. /* Number of RX queues allocated at register_netdev() time */
  1101. unsigned int num_rx_queues;
  1102. /* Number of RX queues currently active in device */
  1103. unsigned int real_num_rx_queues;
  1104. #ifdef CONFIG_RFS_ACCEL
  1105. /* CPU reverse-mapping for RX completion interrupts, indexed
  1106. * by RX queue number. Assigned by driver. This must only be
  1107. * set if the ndo_rx_flow_steer operation is defined. */
  1108. struct cpu_rmap *rx_cpu_rmap;
  1109. #endif
  1110. #endif
  1111. rx_handler_func_t __rcu *rx_handler;
  1112. void __rcu *rx_handler_data;
  1113. struct netdev_queue __rcu *ingress_queue;
  1114. /*
  1115. * Cache lines mostly used on transmit path
  1116. */
  1117. struct netdev_queue *_tx ____cacheline_aligned_in_smp;
  1118. /* Number of TX queues allocated at alloc_netdev_mq() time */
  1119. unsigned int num_tx_queues;
  1120. /* Number of TX queues currently active in device */
  1121. unsigned int real_num_tx_queues;
  1122. /* root qdisc from userspace point of view */
  1123. struct Qdisc *qdisc;
  1124. unsigned long tx_queue_len; /* Max frames per queue allowed */
  1125. spinlock_t tx_global_lock;
  1126. #ifdef CONFIG_XPS
  1127. struct xps_dev_maps __rcu *xps_maps;
  1128. #endif
  1129. /* These may be needed for future network-power-down code. */
  1130. /*
  1131. * trans_start here is expensive for high speed devices on SMP,
  1132. * please use netdev_queue->trans_start instead.
  1133. */
  1134. unsigned long trans_start; /* Time (in jiffies) of last Tx */
  1135. int watchdog_timeo; /* used by dev_watchdog() */
  1136. struct timer_list watchdog_timer;
  1137. /* Number of references to this device */
  1138. int __percpu *pcpu_refcnt;
  1139. /* delayed register/unregister */
  1140. struct list_head todo_list;
  1141. /* device index hash chain */
  1142. struct hlist_node index_hlist;
  1143. struct list_head link_watch_list;
  1144. /* register/unregister state machine */
  1145. enum { NETREG_UNINITIALIZED=0,
  1146. NETREG_REGISTERED, /* completed register_netdevice */
  1147. NETREG_UNREGISTERING, /* called unregister_netdevice */
  1148. NETREG_UNREGISTERED, /* completed unregister todo */
  1149. NETREG_RELEASED, /* called free_netdev */
  1150. NETREG_DUMMY, /* dummy device for NAPI poll */
  1151. } reg_state:8;
  1152. bool dismantle; /* device is going do be freed */
  1153. enum {
  1154. RTNL_LINK_INITIALIZED,
  1155. RTNL_LINK_INITIALIZING,
  1156. } rtnl_link_state:16;
  1157. /* Called from unregister, can be used to call free_netdev */
  1158. void (*destructor)(struct net_device *dev);
  1159. #ifdef CONFIG_NETPOLL
  1160. struct netpoll_info *npinfo;
  1161. #endif
  1162. #ifdef CONFIG_NET_NS
  1163. /* Network namespace this network device is inside */
  1164. struct net *nd_net;
  1165. #endif
  1166. /* mid-layer private */
  1167. union {
  1168. void *ml_priv;
  1169. struct pcpu_lstats __percpu *lstats; /* loopback stats */
  1170. struct pcpu_tstats __percpu *tstats; /* tunnel stats */
  1171. struct pcpu_dstats __percpu *dstats; /* dummy stats */
  1172. };
  1173. /* GARP */
  1174. struct garp_port __rcu *garp_port;
  1175. /* class/net/name entry */
  1176. struct device dev;
  1177. /* space for optional device, statistics, and wireless sysfs groups */
  1178. const struct attribute_group *sysfs_groups[4];
  1179. /* rtnetlink link ops */
  1180. const struct rtnl_link_ops *rtnl_link_ops;
  1181. /* for setting kernel sock attribute on TCP connection setup */
  1182. #define GSO_MAX_SIZE 65536
  1183. unsigned int gso_max_size;
  1184. #ifdef CONFIG_DCB
  1185. /* Data Center Bridging netlink ops */
  1186. const struct dcbnl_rtnl_ops *dcbnl_ops;
  1187. #endif
  1188. u8 num_tc;
  1189. struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
  1190. u8 prio_tc_map[TC_BITMASK + 1];
  1191. #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
  1192. /* max exchange id for FCoE LRO by ddp */
  1193. unsigned int fcoe_ddp_xid;
  1194. #endif
  1195. /* phy device may attach itself for hardware timestamping */
  1196. struct phy_device *phydev;
  1197. /* group the device belongs to */
  1198. int group;
  1199. };
  1200. #define to_net_dev(d) container_of(d, struct net_device, dev)
  1201. #define NETDEV_ALIGN 32
  1202. static inline
  1203. int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
  1204. {
  1205. return dev->prio_tc_map[prio & TC_BITMASK];
  1206. }
  1207. static inline
  1208. int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
  1209. {
  1210. if (tc >= dev->num_tc)
  1211. return -EINVAL;
  1212. dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
  1213. return 0;
  1214. }
  1215. static inline
  1216. void netdev_reset_tc(struct net_device *dev)
  1217. {
  1218. dev->num_tc = 0;
  1219. memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
  1220. memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
  1221. }
  1222. static inline
  1223. int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
  1224. {
  1225. if (tc >= dev->num_tc)
  1226. return -EINVAL;
  1227. dev->tc_to_txq[tc].count = count;
  1228. dev->tc_to_txq[tc].offset = offset;
  1229. return 0;
  1230. }
  1231. static inline
  1232. int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
  1233. {
  1234. if (num_tc > TC_MAX_QUEUE)
  1235. return -EINVAL;
  1236. dev->num_tc = num_tc;
  1237. return 0;
  1238. }
  1239. static inline
  1240. int netdev_get_num_tc(struct net_device *dev)
  1241. {
  1242. return dev->num_tc;
  1243. }
  1244. static inline
  1245. struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
  1246. unsigned int index)
  1247. {
  1248. return &dev->_tx[index];
  1249. }
  1250. static inline void netdev_for_each_tx_queue(struct net_device *dev,
  1251. void (*f)(struct net_device *,
  1252. struct netdev_queue *,
  1253. void *),
  1254. void *arg)
  1255. {
  1256. unsigned int i;
  1257. for (i = 0; i < dev->num_tx_queues; i++)
  1258. f(dev, &dev->_tx[i], arg);
  1259. }
  1260. /*
  1261. * Net namespace inlines
  1262. */
  1263. static inline
  1264. struct net *dev_net(const struct net_device *dev)
  1265. {
  1266. return read_pnet(&dev->nd_net);
  1267. }
  1268. static inline
  1269. void dev_net_set(struct net_device *dev, struct net *net)
  1270. {
  1271. #ifdef CONFIG_NET_NS
  1272. release_net(dev->nd_net);
  1273. dev->nd_net = hold_net(net);
  1274. #endif
  1275. }
  1276. static inline bool netdev_uses_dsa_tags(struct net_device *dev)
  1277. {
  1278. #ifdef CONFIG_NET_DSA_TAG_DSA
  1279. if (dev->dsa_ptr != NULL)
  1280. return dsa_uses_dsa_tags(dev->dsa_ptr);
  1281. #endif
  1282. return 0;
  1283. }
  1284. #ifndef CONFIG_NET_NS
  1285. static inline void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
  1286. {
  1287. skb->dev = dev;
  1288. }
  1289. #else /* CONFIG_NET_NS */
  1290. void skb_set_dev(struct sk_buff *skb, struct net_device *dev);
  1291. #endif
  1292. static inline bool netdev_uses_trailer_tags(struct net_device *dev)
  1293. {
  1294. #ifdef CONFIG_NET_DSA_TAG_TRAILER
  1295. if (dev->dsa_ptr != NULL)
  1296. return dsa_uses_trailer_tags(dev->dsa_ptr);
  1297. #endif
  1298. return 0;
  1299. }
  1300. /**
  1301. * netdev_priv - access network device private data
  1302. * @dev: network device
  1303. *
  1304. * Get network device private data
  1305. */
  1306. static inline void *netdev_priv(const struct net_device *dev)
  1307. {
  1308. return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
  1309. }
  1310. /* Set the sysfs physical device reference for the network logical device
  1311. * if set prior to registration will cause a symlink during initialization.
  1312. */
  1313. #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
  1314. /* Set the sysfs device type for the network logical device to allow
  1315. * fin grained indentification of different network device types. For
  1316. * example Ethernet, Wirelss LAN, Bluetooth, WiMAX etc.
  1317. */
  1318. #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
  1319. /**
  1320. * netif_napi_add - initialize a napi context
  1321. * @dev: network device
  1322. * @napi: napi context
  1323. * @poll: polling function
  1324. * @weight: default weight
  1325. *
  1326. * netif_napi_add() must be used to initialize a napi context prior to calling
  1327. * *any* of the other napi related functions.
  1328. */
  1329. void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
  1330. int (*poll)(struct napi_struct *, int), int weight);
  1331. /**
  1332. * netif_napi_del - remove a napi context
  1333. * @napi: napi context
  1334. *
  1335. * netif_napi_del() removes a napi context from the network device napi list
  1336. */
  1337. void netif_napi_del(struct napi_struct *napi);
  1338. struct napi_gro_cb {
  1339. /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
  1340. void *frag0;
  1341. /* Length of frag0. */
  1342. unsigned int frag0_len;
  1343. /* This indicates where we are processing relative to skb->data. */
  1344. int data_offset;
  1345. /* This is non-zero if the packet may be of the same flow. */
  1346. int same_flow;
  1347. /* This is non-zero if the packet cannot be merged with the new skb. */
  1348. int flush;
  1349. /* Number of segments aggregated. */
  1350. int count;
  1351. /* Free the skb? */
  1352. int free;
  1353. };
  1354. #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
  1355. struct packet_type {
  1356. __be16 type; /* This is really htons(ether_type). */
  1357. struct net_device *dev; /* NULL is wildcarded here */
  1358. int (*func) (struct sk_buff *,
  1359. struct net_device *,
  1360. struct packet_type *,
  1361. struct net_device *);
  1362. struct sk_buff *(*gso_segment)(struct sk_buff *skb,
  1363. u32 features);
  1364. int (*gso_send_check)(struct sk_buff *skb);
  1365. struct sk_buff **(*gro_receive)(struct sk_buff **head,
  1366. struct sk_buff *skb);
  1367. int (*gro_complete)(struct sk_buff *skb);
  1368. void *af_packet_priv;
  1369. struct list_head list;
  1370. };
  1371. #include <linux/notifier.h>
  1372. extern rwlock_t dev_base_lock; /* Device list lock */
  1373. #define for_each_netdev(net, d) \
  1374. list_for_each_entry(d, &(net)->dev_base_head, dev_list)
  1375. #define for_each_netdev_reverse(net, d) \
  1376. list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
  1377. #define for_each_netdev_rcu(net, d) \
  1378. list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
  1379. #define for_each_netdev_safe(net, d, n) \
  1380. list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
  1381. #define for_each_netdev_continue(net, d) \
  1382. list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
  1383. #define for_each_netdev_continue_rcu(net, d) \
  1384. list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
  1385. #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
  1386. static inline struct net_device *next_net_device(struct net_device *dev)
  1387. {
  1388. struct list_head *lh;
  1389. struct net *net;
  1390. net = dev_net(dev);
  1391. lh = dev->dev_list.next;
  1392. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  1393. }
  1394. static inline struct net_device *next_net_device_rcu(struct net_device *dev)
  1395. {
  1396. struct list_head *lh;
  1397. struct net *net;
  1398. net = dev_net(dev);
  1399. lh = rcu_dereference(list_next_rcu(&dev->dev_list));
  1400. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  1401. }
  1402. static inline struct net_device *first_net_device(struct net *net)
  1403. {
  1404. return list_empty(&net->dev_base_head) ? NULL :
  1405. net_device_entry(net->dev_base_head.next);
  1406. }
  1407. static inline struct net_device *first_net_device_rcu(struct net *net)
  1408. {
  1409. struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
  1410. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  1411. }
  1412. extern int netdev_boot_setup_check(struct net_device *dev);
  1413. extern unsigned long netdev_boot_base(const char *prefix, int unit);
  1414. extern struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
  1415. const char *hwaddr);
  1416. extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
  1417. extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
  1418. extern void dev_add_pack(struct packet_type *pt);
  1419. extern void dev_remove_pack(struct packet_type *pt);
  1420. extern void __dev_remove_pack(struct packet_type *pt);
  1421. extern struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags,
  1422. unsigned short mask);
  1423. extern struct net_device *dev_get_by_name(struct net *net, const char *name);
  1424. extern struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
  1425. extern struct net_device *__dev_get_by_name(struct net *net, const char *name);
  1426. extern int dev_alloc_name(struct net_device *dev, const char *name);
  1427. extern int dev_open(struct net_device *dev);
  1428. extern int dev_close(struct net_device *dev);
  1429. extern void dev_disable_lro(struct net_device *dev);
  1430. extern int dev_queue_xmit(struct sk_buff *skb);
  1431. extern int register_netdevice(struct net_device *dev);
  1432. extern void unregister_netdevice_queue(struct net_device *dev,
  1433. struct list_head *head);
  1434. extern void unregister_netdevice_many(struct list_head *head);
  1435. static inline void unregister_netdevice(struct net_device *dev)
  1436. {
  1437. unregister_netdevice_queue(dev, NULL);
  1438. }
  1439. extern int netdev_refcnt_read(const struct net_device *dev);
  1440. extern void free_netdev(struct net_device *dev);
  1441. extern void synchronize_net(void);
  1442. extern int register_netdevice_notifier(struct notifier_block *nb);
  1443. extern int unregister_netdevice_notifier(struct notifier_block *nb);
  1444. extern int init_dummy_netdev(struct net_device *dev);
  1445. extern void netdev_resync_ops(struct net_device *dev);
  1446. extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
  1447. extern struct net_device *dev_get_by_index(struct net *net, int ifindex);
  1448. extern struct net_device *__dev_get_by_index(struct net *net, int ifindex);
  1449. extern struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
  1450. extern int dev_restart(struct net_device *dev);
  1451. #ifdef CONFIG_NETPOLL_TRAP
  1452. extern int netpoll_trap(void);
  1453. #endif
  1454. extern int skb_gro_receive(struct sk_buff **head,
  1455. struct sk_buff *skb);
  1456. extern void skb_gro_reset_offset(struct sk_buff *skb);
  1457. static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
  1458. {
  1459. return NAPI_GRO_CB(skb)->data_offset;
  1460. }
  1461. static inline unsigned int skb_gro_len(const struct sk_buff *skb)
  1462. {
  1463. return skb->len - NAPI_GRO_CB(skb)->data_offset;
  1464. }
  1465. static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
  1466. {
  1467. NAPI_GRO_CB(skb)->data_offset += len;
  1468. }
  1469. static inline void *skb_gro_header_fast(struct sk_buff *skb,
  1470. unsigned int offset)
  1471. {
  1472. return NAPI_GRO_CB(skb)->frag0 + offset;
  1473. }
  1474. static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
  1475. {
  1476. return NAPI_GRO_CB(skb)->frag0_len < hlen;
  1477. }
  1478. static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
  1479. unsigned int offset)
  1480. {
  1481. NAPI_GRO_CB(skb)->frag0 = NULL;
  1482. NAPI_GRO_CB(skb)->frag0_len = 0;
  1483. return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
  1484. }
  1485. static inline void *skb_gro_mac_header(struct sk_buff *skb)
  1486. {
  1487. return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
  1488. }
  1489. static inline void *skb_gro_network_header(struct sk_buff *skb)
  1490. {
  1491. return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
  1492. skb_network_offset(skb);
  1493. }
  1494. static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
  1495. unsigned short type,
  1496. const void *daddr, const void *saddr,
  1497. unsigned len)
  1498. {
  1499. if (!dev->header_ops || !dev->header_ops->create)
  1500. return 0;
  1501. return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
  1502. }
  1503. static inline int dev_parse_header(const struct sk_buff *skb,
  1504. unsigned char *haddr)
  1505. {
  1506. const struct net_device *dev = skb->dev;
  1507. if (!dev->header_ops || !dev->header_ops->parse)
  1508. return 0;
  1509. return dev->header_ops->parse(skb, haddr);
  1510. }
  1511. typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
  1512. extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
  1513. static inline int unregister_gifconf(unsigned int family)
  1514. {
  1515. return register_gifconf(family, NULL);
  1516. }
  1517. /*
  1518. * Incoming packets are placed on per-cpu queues
  1519. */
  1520. struct softnet_data {
  1521. struct Qdisc *output_queue;
  1522. struct Qdisc **output_queue_tailp;
  1523. struct list_head poll_list;
  1524. struct sk_buff *completion_queue;
  1525. struct sk_buff_head process_queue;
  1526. /* stats */
  1527. unsigned int processed;
  1528. unsigned int time_squeeze;
  1529. unsigned int cpu_collision;
  1530. unsigned int received_rps;
  1531. #ifdef CONFIG_RPS
  1532. struct softnet_data *rps_ipi_list;
  1533. /* Elements below can be accessed between CPUs for RPS */
  1534. struct call_single_data csd ____cacheline_aligned_in_smp;
  1535. struct softnet_data *rps_ipi_next;
  1536. unsigned int cpu;
  1537. unsigned int input_queue_head;
  1538. unsigned int input_queue_tail;
  1539. #endif
  1540. unsigned dropped;
  1541. struct sk_buff_head input_pkt_queue;
  1542. struct napi_struct backlog;
  1543. };
  1544. static inline void input_queue_head_incr(struct softnet_data *sd)
  1545. {
  1546. #ifdef CONFIG_RPS
  1547. sd->input_queue_head++;
  1548. #endif
  1549. }
  1550. static inline void input_queue_tail_incr_save(struct softnet_data *sd,
  1551. unsigned int *qtail)
  1552. {
  1553. #ifdef CONFIG_RPS
  1554. *qtail = ++sd->input_queue_tail;
  1555. #endif
  1556. }
  1557. DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
  1558. #define HAVE_NETIF_QUEUE
  1559. extern void __netif_schedule(struct Qdisc *q);
  1560. static inline void netif_schedule_queue(struct netdev_queue *txq)
  1561. {
  1562. if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
  1563. __netif_schedule(txq->qdisc);
  1564. }
  1565. static inline void netif_tx_schedule_all(struct net_device *dev)
  1566. {
  1567. unsigned int i;
  1568. for (i = 0; i < dev->num_tx_queues; i++)
  1569. netif_schedule_queue(netdev_get_tx_queue(dev, i));
  1570. }
  1571. static inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
  1572. {
  1573. clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
  1574. }
  1575. /**
  1576. * netif_start_queue - allow transmit
  1577. * @dev: network device
  1578. *
  1579. * Allow upper layers to call the device hard_start_xmit routine.
  1580. */
  1581. static inline void netif_start_queue(struct net_device *dev)
  1582. {
  1583. netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
  1584. }
  1585. static inline void netif_tx_start_all_queues(struct net_device *dev)
  1586. {
  1587. unsigned int i;
  1588. for (i = 0; i < dev->num_tx_queues; i++) {
  1589. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  1590. netif_tx_start_queue(txq);
  1591. }
  1592. }
  1593. static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
  1594. {
  1595. #ifdef CONFIG_NETPOLL_TRAP
  1596. if (netpoll_trap()) {
  1597. netif_tx_start_queue(dev_queue);
  1598. return;
  1599. }
  1600. #endif
  1601. if (test_and_clear_bit(__QUEUE_STATE_XOFF, &dev_queue->state))
  1602. __netif_schedule(dev_queue->qdisc);
  1603. }
  1604. /**
  1605. * netif_wake_queue - restart transmit
  1606. * @dev: network device
  1607. *
  1608. * Allow upper layers to call the device hard_start_xmit routine.
  1609. * Used for flow control when transmit resources are available.
  1610. */
  1611. static inline void netif_wake_queue(struct net_device *dev)
  1612. {
  1613. netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
  1614. }
  1615. static inline void netif_tx_wake_all_queues(struct net_device *dev)
  1616. {
  1617. unsigned int i;
  1618. for (i = 0; i < dev->num_tx_queues; i++) {
  1619. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  1620. netif_tx_wake_queue(txq);
  1621. }
  1622. }
  1623. static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
  1624. {
  1625. if (WARN_ON(!dev_queue)) {
  1626. pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
  1627. return;
  1628. }
  1629. set_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
  1630. }
  1631. /**
  1632. * netif_stop_queue - stop transmitted packets
  1633. * @dev: network device
  1634. *
  1635. * Stop upper layers calling the device hard_start_xmit routine.
  1636. * Used for flow control when transmit resources are unavailable.
  1637. */
  1638. static inline void netif_stop_queue(struct net_device *dev)
  1639. {
  1640. netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
  1641. }
  1642. static inline void netif_tx_stop_all_queues(struct net_device *dev)
  1643. {
  1644. unsigned int i;
  1645. for (i = 0; i < dev->num_tx_queues; i++) {
  1646. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  1647. netif_tx_stop_queue(txq);
  1648. }
  1649. }
  1650. static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
  1651. {
  1652. return test_bit(__QUEUE_STATE_XOFF, &dev_queue->state);
  1653. }
  1654. /**
  1655. * netif_queue_stopped - test if transmit queue is flowblocked
  1656. * @dev: network device
  1657. *
  1658. * Test if transmit queue on device is currently unable to send.
  1659. */
  1660. static inline int netif_queue_stopped(const struct net_device *dev)
  1661. {
  1662. return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
  1663. }
  1664. static inline int netif_tx_queue_frozen_or_stopped(const struct netdev_queue *dev_queue)
  1665. {
  1666. return dev_queue->state & QUEUE_STATE_XOFF_OR_FROZEN;
  1667. }
  1668. /**
  1669. * netif_running - test if up
  1670. * @dev: network device
  1671. *
  1672. * Test if the device has been brought up.
  1673. */
  1674. static inline int netif_running(const struct net_device *dev)
  1675. {
  1676. return test_bit(__LINK_STATE_START, &dev->state);
  1677. }
  1678. /*
  1679. * Routines to manage the subqueues on a device. We only need start
  1680. * stop, and a check if it's stopped. All other device management is
  1681. * done at the overall netdevice level.
  1682. * Also test the device if we're multiqueue.
  1683. */
  1684. /**
  1685. * netif_start_subqueue - allow sending packets on subqueue
  1686. * @dev: network device
  1687. * @queue_index: sub queue index
  1688. *
  1689. * Start individual transmit queue of a device with multiple transmit queues.
  1690. */
  1691. static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
  1692. {
  1693. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  1694. netif_tx_start_queue(txq);
  1695. }
  1696. /**
  1697. * netif_stop_subqueue - stop sending packets on subqueue
  1698. * @dev: network device
  1699. * @queue_index: sub queue index
  1700. *
  1701. * Stop individual transmit queue of a device with multiple transmit queues.
  1702. */
  1703. static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
  1704. {
  1705. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  1706. #ifdef CONFIG_NETPOLL_TRAP
  1707. if (netpoll_trap())
  1708. return;
  1709. #endif
  1710. netif_tx_stop_queue(txq);
  1711. }
  1712. /**
  1713. * netif_subqueue_stopped - test status of subqueue
  1714. * @dev: network device
  1715. * @queue_index: sub queue index
  1716. *
  1717. * Check individual transmit queue of a device with multiple transmit queues.
  1718. */
  1719. static inline int __netif_subqueue_stopped(const struct net_device *dev,
  1720. u16 queue_index)
  1721. {
  1722. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  1723. return netif_tx_queue_stopped(txq);
  1724. }
  1725. static inline int netif_subqueue_stopped(const struct net_device *dev,
  1726. struct sk_buff *skb)
  1727. {
  1728. return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
  1729. }
  1730. /**
  1731. * netif_wake_subqueue - allow sending packets on subqueue
  1732. * @dev: network device
  1733. * @queue_index: sub queue index
  1734. *
  1735. * Resume individual transmit queue of a device with multiple transmit queues.
  1736. */
  1737. static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
  1738. {
  1739. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  1740. #ifdef CONFIG_NETPOLL_TRAP
  1741. if (netpoll_trap())
  1742. return;
  1743. #endif
  1744. if (test_and_clear_bit(__QUEUE_STATE_XOFF, &txq->state))
  1745. __netif_schedule(txq->qdisc);
  1746. }
  1747. /*
  1748. * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
  1749. * as a distribution range limit for the returned value.
  1750. */
  1751. static inline u16 skb_tx_hash(const struct net_device *dev,
  1752. const struct sk_buff *skb)
  1753. {
  1754. return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
  1755. }
  1756. /**
  1757. * netif_is_multiqueue - test if device has multiple transmit queues
  1758. * @dev: network device
  1759. *
  1760. * Check if device has multiple transmit queues
  1761. */
  1762. static inline int netif_is_multiqueue(const struct net_device *dev)
  1763. {
  1764. return dev->num_tx_queues > 1;
  1765. }
  1766. extern int netif_set_real_num_tx_queues(struct net_device *dev,
  1767. unsigned int txq);
  1768. #ifdef CONFIG_RPS
  1769. extern int netif_set_real_num_rx_queues(struct net_device *dev,
  1770. unsigned int rxq);
  1771. #else
  1772. static inline int netif_set_real_num_rx_queues(struct net_device *dev,
  1773. unsigned int rxq)
  1774. {
  1775. return 0;
  1776. }
  1777. #endif
  1778. static inline int netif_copy_real_num_queues(struct net_device *to_dev,
  1779. const struct net_device *from_dev)
  1780. {
  1781. netif_set_real_num_tx_queues(to_dev, from_dev->real_num_tx_queues);
  1782. #ifdef CONFIG_RPS
  1783. return netif_set_real_num_rx_queues(to_dev,
  1784. from_dev->real_num_rx_queues);
  1785. #else
  1786. return 0;
  1787. #endif
  1788. }
  1789. /* Use this variant when it is known for sure that it
  1790. * is executing from hardware interrupt context or with hardware interrupts
  1791. * disabled.
  1792. */
  1793. extern void dev_kfree_skb_irq(struct sk_buff *skb);
  1794. /* Use this variant in places where it could be invoked
  1795. * from either hardware interrupt or other context, with hardware interrupts
  1796. * either disabled or enabled.
  1797. */
  1798. extern void dev_kfree_skb_any(struct sk_buff *skb);
  1799. #define HAVE_NETIF_RX 1
  1800. extern int netif_rx(struct sk_buff *skb);
  1801. extern int netif_rx_ni(struct sk_buff *skb);
  1802. #define HAVE_NETIF_RECEIVE_SKB 1
  1803. extern int netif_receive_skb(struct sk_buff *skb);
  1804. extern gro_result_t dev_gro_receive(struct napi_struct *napi,
  1805. struct sk_buff *skb);
  1806. extern gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb);
  1807. extern gro_result_t napi_gro_receive(struct napi_struct *napi,
  1808. struct sk_buff *skb);
  1809. extern void napi_gro_flush(struct napi_struct *napi);
  1810. extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
  1811. extern gro_result_t napi_frags_finish(struct napi_struct *napi,
  1812. struct sk_buff *skb,
  1813. gro_result_t ret);
  1814. extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
  1815. extern gro_result_t napi_gro_frags(struct napi_struct *napi);
  1816. static inline void napi_free_frags(struct napi_struct *napi)
  1817. {
  1818. kfree_skb(napi->skb);
  1819. napi->skb = NULL;
  1820. }
  1821. extern int netdev_rx_handler_register(struct net_device *dev,
  1822. rx_handler_func_t *rx_handler,
  1823. void *rx_handler_data);
  1824. extern void netdev_rx_handler_unregister(struct net_device *dev);
  1825. extern int dev_valid_name(const char *name);
  1826. extern int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
  1827. extern int dev_ethtool(struct net *net, struct ifreq *);
  1828. extern unsigned dev_get_flags(const struct net_device *);
  1829. extern int __dev_change_flags(struct net_device *, unsigned int flags);
  1830. extern int dev_change_flags(struct net_device *, unsigned);
  1831. extern void __dev_notify_flags(struct net_device *, unsigned int old_flags);
  1832. extern int dev_change_name(struct net_device *, const char *);
  1833. extern int dev_set_alias(struct net_device *, const char *, size_t);
  1834. extern int dev_change_net_namespace(struct net_device *,
  1835. struct net *, const char *);
  1836. extern int dev_set_mtu(struct net_device *, int);
  1837. extern void dev_set_group(struct net_device *, int);
  1838. extern int dev_set_mac_address(struct net_device *,
  1839. struct sockaddr *);
  1840. extern int dev_hard_start_xmit(struct sk_buff *skb,
  1841. struct net_device *dev,
  1842. struct netdev_queue *txq);
  1843. extern int dev_forward_skb(struct net_device *dev,
  1844. struct sk_buff *skb);
  1845. extern int netdev_budget;
  1846. /* Called by rtnetlink.c:rtnl_unlock() */
  1847. extern void netdev_run_todo(void);
  1848. /**
  1849. * dev_put - release reference to device
  1850. * @dev: network device
  1851. *
  1852. * Release reference to device to allow it to be freed.
  1853. */
  1854. static inline void dev_put(struct net_device *dev)
  1855. {
  1856. irqsafe_cpu_dec(*dev->pcpu_refcnt);
  1857. }
  1858. /**
  1859. * dev_hold - get reference to device
  1860. * @dev: network device
  1861. *
  1862. * Hold reference to device to keep it from being freed.
  1863. */
  1864. static inline void dev_hold(struct net_device *dev)
  1865. {
  1866. irqsafe_cpu_inc(*dev->pcpu_refcnt);
  1867. }
  1868. /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  1869. * and _off may be called from IRQ context, but it is caller
  1870. * who is responsible for serialization of these calls.
  1871. *
  1872. * The name carrier is inappropriate, these functions should really be
  1873. * called netif_lowerlayer_*() because they represent the state of any
  1874. * kind of lower layer not just hardware media.
  1875. */
  1876. extern void linkwatch_fire_event(struct net_device *dev);
  1877. extern void linkwatch_forget_dev(struct net_device *dev);
  1878. /**
  1879. * netif_carrier_ok - test if carrier present
  1880. * @dev: network device
  1881. *
  1882. * Check if carrier is present on device
  1883. */
  1884. static inline int netif_carrier_ok(const struct net_device *dev)
  1885. {
  1886. return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  1887. }
  1888. extern unsigned long dev_trans_start(struct net_device *dev);
  1889. extern void __netdev_watchdog_up(struct net_device *dev);
  1890. extern void netif_carrier_on(struct net_device *dev);
  1891. extern void netif_carrier_off(struct net_device *dev);
  1892. extern void netif_notify_peers(struct net_device *dev);
  1893. /**
  1894. * netif_dormant_on - mark device as dormant.
  1895. * @dev: network device
  1896. *
  1897. * Mark device as dormant (as per RFC2863).
  1898. *
  1899. * The dormant state indicates that the relevant interface is not
  1900. * actually in a condition to pass packets (i.e., it is not 'up') but is
  1901. * in a "pending" state, waiting for some external event. For "on-
  1902. * demand" interfaces, this new state identifies the situation where the
  1903. * interface is waiting for events to place it in the up state.
  1904. *
  1905. */
  1906. static inline void netif_dormant_on(struct net_device *dev)
  1907. {
  1908. if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
  1909. linkwatch_fire_event(dev);
  1910. }
  1911. /**
  1912. * netif_dormant_off - set device as not dormant.
  1913. * @dev: network device
  1914. *
  1915. * Device is not in dormant state.
  1916. */
  1917. static inline void netif_dormant_off(struct net_device *dev)
  1918. {
  1919. if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
  1920. linkwatch_fire_event(dev);
  1921. }
  1922. /**
  1923. * netif_dormant - test if carrier present
  1924. * @dev: network device
  1925. *
  1926. * Check if carrier is present on device
  1927. */
  1928. static inline int netif_dormant(const struct net_device *dev)
  1929. {
  1930. return test_bit(__LINK_STATE_DORMANT, &dev->state);
  1931. }
  1932. /**
  1933. * netif_oper_up - test if device is operational
  1934. * @dev: network device
  1935. *
  1936. * Check if carrier is operational
  1937. */
  1938. static inline int netif_oper_up(const struct net_device *dev)
  1939. {
  1940. return (dev->operstate == IF_OPER_UP ||
  1941. dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
  1942. }
  1943. /**
  1944. * netif_device_present - is device available or removed
  1945. * @dev: network device
  1946. *
  1947. * Check if device has not been removed from system.
  1948. */
  1949. static inline int netif_device_present(struct net_device *dev)
  1950. {
  1951. return test_bit(__LINK_STATE_PRESENT, &dev->state);
  1952. }
  1953. extern void netif_device_detach(struct net_device *dev);
  1954. extern void netif_device_attach(struct net_device *dev);
  1955. /*
  1956. * Network interface message level settings
  1957. */
  1958. #define HAVE_NETIF_MSG 1
  1959. enum {
  1960. NETIF_MSG_DRV = 0x0001,
  1961. NETIF_MSG_PROBE = 0x0002,
  1962. NETIF_MSG_LINK = 0x0004,
  1963. NETIF_MSG_TIMER = 0x0008,
  1964. NETIF_MSG_IFDOWN = 0x0010,
  1965. NETIF_MSG_IFUP = 0x0020,
  1966. NETIF_MSG_RX_ERR = 0x0040,
  1967. NETIF_MSG_TX_ERR = 0x0080,
  1968. NETIF_MSG_TX_QUEUED = 0x0100,
  1969. NETIF_MSG_INTR = 0x0200,
  1970. NETIF_MSG_TX_DONE = 0x0400,
  1971. NETIF_MSG_RX_STATUS = 0x0800,
  1972. NETIF_MSG_PKTDATA = 0x1000,
  1973. NETIF_MSG_HW = 0x2000,
  1974. NETIF_MSG_WOL = 0x4000,
  1975. };
  1976. #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
  1977. #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
  1978. #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
  1979. #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
  1980. #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
  1981. #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
  1982. #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
  1983. #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
  1984. #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
  1985. #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
  1986. #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
  1987. #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
  1988. #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
  1989. #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
  1990. #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
  1991. static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
  1992. {
  1993. /* use default */
  1994. if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  1995. return default_msg_enable_bits;
  1996. if (debug_value == 0) /* no output */
  1997. return 0;
  1998. /* set low N bits */
  1999. return (1 << debug_value) - 1;
  2000. }
  2001. static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
  2002. {
  2003. spin_lock(&txq->_xmit_lock);
  2004. txq->xmit_lock_owner = cpu;
  2005. }
  2006. static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
  2007. {
  2008. spin_lock_bh(&txq->_xmit_lock);
  2009. txq->xmit_lock_owner = smp_processor_id();
  2010. }
  2011. static inline int __netif_tx_trylock(struct netdev_queue *txq)
  2012. {
  2013. int ok = spin_trylock(&txq->_xmit_lock);
  2014. if (likely(ok))
  2015. txq->xmit_lock_owner = smp_processor_id();
  2016. return ok;
  2017. }
  2018. static inline void __netif_tx_unlock(struct netdev_queue *txq)
  2019. {
  2020. txq->xmit_lock_owner = -1;
  2021. spin_unlock(&txq->_xmit_lock);
  2022. }
  2023. static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
  2024. {
  2025. txq->xmit_lock_owner = -1;
  2026. spin_unlock_bh(&txq->_xmit_lock);
  2027. }
  2028. static inline void txq_trans_update(struct netdev_queue *txq)
  2029. {
  2030. if (txq->xmit_lock_owner != -1)
  2031. txq->trans_start = jiffies;
  2032. }
  2033. /**
  2034. * netif_tx_lock - grab network device transmit lock
  2035. * @dev: network device
  2036. *
  2037. * Get network device transmit lock
  2038. */
  2039. static inline void netif_tx_lock(struct net_device *dev)
  2040. {
  2041. unsigned int i;
  2042. int cpu;
  2043. spin_lock(&dev->tx_global_lock);
  2044. cpu = smp_processor_id();
  2045. for (i = 0; i < dev->num_tx_queues; i++) {
  2046. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  2047. /* We are the only thread of execution doing a
  2048. * freeze, but we have to grab the _xmit_lock in
  2049. * order to synchronize with threads which are in
  2050. * the ->hard_start_xmit() handler and already
  2051. * checked the frozen bit.
  2052. */
  2053. __netif_tx_lock(txq, cpu);
  2054. set_bit(__QUEUE_STATE_FROZEN, &txq->state);
  2055. __netif_tx_unlock(txq);
  2056. }
  2057. }
  2058. static inline void netif_tx_lock_bh(struct net_device *dev)
  2059. {
  2060. local_bh_disable();
  2061. netif_tx_lock(dev);
  2062. }
  2063. static inline void netif_tx_unlock(struct net_device *dev)
  2064. {
  2065. unsigned int i;
  2066. for (i = 0; i < dev->num_tx_queues; i++) {
  2067. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  2068. /* No need to grab the _xmit_lock here. If the
  2069. * queue is not stopped for another reason, we
  2070. * force a schedule.
  2071. */
  2072. clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
  2073. netif_schedule_queue(txq);
  2074. }
  2075. spin_unlock(&dev->tx_global_lock);
  2076. }
  2077. static inline void netif_tx_unlock_bh(struct net_device *dev)
  2078. {
  2079. netif_tx_unlock(dev);
  2080. local_bh_enable();
  2081. }
  2082. #define HARD_TX_LOCK(dev, txq, cpu) { \
  2083. if ((dev->features & NETIF_F_LLTX) == 0) { \
  2084. __netif_tx_lock(txq, cpu); \
  2085. } \
  2086. }
  2087. #define HARD_TX_UNLOCK(dev, txq) { \
  2088. if ((dev->features & NETIF_F_LLTX) == 0) { \
  2089. __netif_tx_unlock(txq); \
  2090. } \
  2091. }
  2092. static inline void netif_tx_disable(struct net_device *dev)
  2093. {
  2094. unsigned int i;
  2095. int cpu;
  2096. local_bh_disable();
  2097. cpu = smp_processor_id();
  2098. for (i = 0; i < dev->num_tx_queues; i++) {
  2099. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  2100. __netif_tx_lock(txq, cpu);
  2101. netif_tx_stop_queue(txq);
  2102. __netif_tx_unlock(txq);
  2103. }
  2104. local_bh_enable();
  2105. }
  2106. static inline void netif_addr_lock(struct net_device *dev)
  2107. {
  2108. spin_lock(&dev->addr_list_lock);
  2109. }
  2110. static inline void netif_addr_lock_bh(struct net_device *dev)
  2111. {
  2112. spin_lock_bh(&dev->addr_list_lock);
  2113. }
  2114. static inline void netif_addr_unlock(struct net_device *dev)
  2115. {
  2116. spin_unlock(&dev->addr_list_lock);
  2117. }
  2118. static inline void netif_addr_unlock_bh(struct net_device *dev)
  2119. {
  2120. spin_unlock_bh(&dev->addr_list_lock);
  2121. }
  2122. /*
  2123. * dev_addrs walker. Should be used only for read access. Call with
  2124. * rcu_read_lock held.
  2125. */
  2126. #define for_each_dev_addr(dev, ha) \
  2127. list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
  2128. /* These functions live elsewhere (drivers/net/net_init.c, but related) */
  2129. extern void ether_setup(struct net_device *dev);
  2130. /* Support for loadable net-drivers */
  2131. extern struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
  2132. void (*setup)(struct net_device *),
  2133. unsigned int txqs, unsigned int rxqs);
  2134. #define alloc_netdev(sizeof_priv, name, setup) \
  2135. alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1)
  2136. #define alloc_netdev_mq(sizeof_priv, name, setup, count) \
  2137. alloc_netdev_mqs(sizeof_priv, name, setup, count, count)
  2138. extern int register_netdev(struct net_device *dev);
  2139. extern void unregister_netdev(struct net_device *dev);
  2140. /* General hardware address lists handling functions */
  2141. extern int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
  2142. struct netdev_hw_addr_list *from_list,
  2143. int addr_len, unsigned char addr_type);
  2144. extern void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
  2145. struct netdev_hw_addr_list *from_list,
  2146. int addr_len, unsigned char addr_type);
  2147. extern int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
  2148. struct netdev_hw_addr_list *from_list,
  2149. int addr_len);
  2150. extern void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
  2151. struct netdev_hw_addr_list *from_list,
  2152. int addr_len);
  2153. extern void __hw_addr_flush(struct netdev_hw_addr_list *list);
  2154. extern void __hw_addr_init(struct netdev_hw_addr_list *list);
  2155. /* Functions used for device addresses handling */
  2156. extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
  2157. unsigned char addr_type);
  2158. extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
  2159. unsigned char addr_type);
  2160. extern int dev_addr_add_multiple(struct net_device *to_dev,
  2161. struct net_device *from_dev,
  2162. unsigned char addr_type);
  2163. extern int dev_addr_del_multiple(struct net_device *to_dev,
  2164. struct net_device *from_dev,
  2165. unsigned char addr_type);
  2166. extern void dev_addr_flush(struct net_device *dev);
  2167. extern int dev_addr_init(struct net_device *dev);
  2168. /* Functions used for unicast addresses handling */
  2169. extern int dev_uc_add(struct net_device *dev, unsigned char *addr);
  2170. extern int dev_uc_del(struct net_device *dev, unsigned char *addr);
  2171. extern int dev_uc_sync(struct net_device *to, struct net_device *from);
  2172. extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
  2173. extern void dev_uc_flush(struct net_device *dev);
  2174. extern void dev_uc_init(struct net_device *dev);
  2175. /* Functions used for multicast addresses handling */
  2176. extern int dev_mc_add(struct net_device *dev, unsigned char *addr);
  2177. extern int dev_mc_add_global(struct net_device *dev, unsigned char *addr);
  2178. extern int dev_mc_del(struct net_device *dev, unsigned char *addr);
  2179. extern int dev_mc_del_global(struct net_device *dev, unsigned char *addr);
  2180. extern int dev_mc_sync(struct net_device *to, struct net_device *from);
  2181. extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
  2182. extern void dev_mc_flush(struct net_device *dev);
  2183. extern void dev_mc_init(struct net_device *dev);
  2184. /* Functions used for secondary unicast and multicast support */
  2185. extern void dev_set_rx_mode(struct net_device *dev);
  2186. extern void __dev_set_rx_mode(struct net_device *dev);
  2187. extern int dev_set_promiscuity(struct net_device *dev, int inc);
  2188. extern int dev_set_allmulti(struct net_device *dev, int inc);
  2189. extern void netdev_state_change(struct net_device *dev);
  2190. extern int netdev_bonding_change(struct net_device *dev,
  2191. unsigned long event);
  2192. extern void netdev_features_change(struct net_device *dev);
  2193. /* Load a device via the kmod */
  2194. extern void dev_load(struct net *net, const char *name);
  2195. extern void dev_mcast_init(void);
  2196. extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
  2197. struct rtnl_link_stats64 *storage);
  2198. extern int netdev_max_backlog;
  2199. extern int netdev_tstamp_prequeue;
  2200. extern int weight_p;
  2201. extern int bpf_jit_enable;
  2202. extern int netdev_set_master(struct net_device *dev, struct net_device *master);
  2203. extern int netdev_set_bond_master(struct net_device *dev,
  2204. struct net_device *master);
  2205. extern int skb_checksum_help(struct sk_buff *skb);
  2206. extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features);
  2207. #ifdef CONFIG_BUG
  2208. extern void netdev_rx_csum_fault(struct net_device *dev);
  2209. #else
  2210. static inline void netdev_rx_csum_fault(struct net_device *dev)
  2211. {
  2212. }
  2213. #endif
  2214. /* rx skb timestamps */
  2215. extern void net_enable_timestamp(void);
  2216. extern void net_disable_timestamp(void);
  2217. #ifdef CONFIG_PROC_FS
  2218. extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
  2219. extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
  2220. extern void dev_seq_stop(struct seq_file *seq, void *v);
  2221. #endif
  2222. extern int netdev_class_create_file(struct class_attribute *class_attr);
  2223. extern void netdev_class_remove_file(struct class_attribute *class_attr);
  2224. extern struct kobj_ns_type_operations net_ns_type_operations;
  2225. extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
  2226. extern void linkwatch_run_queue(void);
  2227. static inline u32 netdev_get_wanted_features(struct net_device *dev)
  2228. {
  2229. return (dev->features & ~dev->hw_features) | dev->wanted_features;
  2230. }
  2231. u32 netdev_increment_features(u32 all, u32 one, u32 mask);
  2232. u32 netdev_fix_features(struct net_device *dev, u32 features);
  2233. int __netdev_update_features(struct net_device *dev);
  2234. void netdev_update_features(struct net_device *dev);
  2235. void netdev_change_features(struct net_device *dev);
  2236. void netif_stacked_transfer_operstate(const struct net_device *rootdev,
  2237. struct net_device *dev);
  2238. u32 netif_skb_features(struct sk_buff *skb);
  2239. static inline int net_gso_ok(u32 features, int gso_type)
  2240. {
  2241. int feature = gso_type << NETIF_F_GSO_SHIFT;
  2242. return (features & feature) == feature;
  2243. }
  2244. static inline int skb_gso_ok(struct sk_buff *skb, u32 features)
  2245. {
  2246. return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
  2247. (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
  2248. }
  2249. static inline int netif_needs_gso(struct sk_buff *skb, int features)
  2250. {
  2251. return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
  2252. unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
  2253. }
  2254. static inline void netif_set_gso_max_size(struct net_device *dev,
  2255. unsigned int size)
  2256. {
  2257. dev->gso_max_size = size;
  2258. }
  2259. static inline int netif_is_bond_slave(struct net_device *dev)
  2260. {
  2261. return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
  2262. }
  2263. extern struct pernet_operations __net_initdata loopback_net_ops;
  2264. int dev_ethtool_get_settings(struct net_device *dev,
  2265. struct ethtool_cmd *cmd);
  2266. static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
  2267. {
  2268. if (dev->features & NETIF_F_RXCSUM)
  2269. return 1;
  2270. if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
  2271. return 0;
  2272. return dev->ethtool_ops->get_rx_csum(dev);
  2273. }
  2274. static inline u32 dev_ethtool_get_flags(struct net_device *dev)
  2275. {
  2276. if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
  2277. return 0;
  2278. return dev->ethtool_ops->get_flags(dev);
  2279. }
  2280. /* Logging, debugging and troubleshooting/diagnostic helpers. */
  2281. /* netdev_printk helpers, similar to dev_printk */
  2282. static inline const char *netdev_name(const struct net_device *dev)
  2283. {
  2284. if (dev->reg_state != NETREG_REGISTERED)
  2285. return "(unregistered net_device)";
  2286. return dev->name;
  2287. }
  2288. extern int netdev_printk(const char *level, const struct net_device *dev,
  2289. const char *format, ...)
  2290. __attribute__ ((format (printf, 3, 4)));
  2291. extern int netdev_emerg(const struct net_device *dev, const char *format, ...)
  2292. __attribute__ ((format (printf, 2, 3)));
  2293. extern int netdev_alert(const struct net_device *dev, const char *format, ...)
  2294. __attribute__ ((format (printf, 2, 3)));
  2295. extern int netdev_crit(const struct net_device *dev, const char *format, ...)
  2296. __attribute__ ((format (printf, 2, 3)));
  2297. extern int netdev_err(const struct net_device *dev, const char *format, ...)
  2298. __attribute__ ((format (printf, 2, 3)));
  2299. extern int netdev_warn(const struct net_device *dev, const char *format, ...)
  2300. __attribute__ ((format (printf, 2, 3)));
  2301. extern int netdev_notice(const struct net_device *dev, const char *format, ...)
  2302. __attribute__ ((format (printf, 2, 3)));
  2303. extern int netdev_info(const struct net_device *dev, const char *format, ...)
  2304. __attribute__ ((format (printf, 2, 3)));
  2305. #define MODULE_ALIAS_NETDEV(device) \
  2306. MODULE_ALIAS("netdev-" device)
  2307. #if defined(DEBUG)
  2308. #define netdev_dbg(__dev, format, args...) \
  2309. netdev_printk(KERN_DEBUG, __dev, format, ##args)
  2310. #elif defined(CONFIG_DYNAMIC_DEBUG)
  2311. #define netdev_dbg(__dev, format, args...) \
  2312. do { \
  2313. dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \
  2314. netdev_name(__dev), ##args); \
  2315. } while (0)
  2316. #else
  2317. #define netdev_dbg(__dev, format, args...) \
  2318. ({ \
  2319. if (0) \
  2320. netdev_printk(KERN_DEBUG, __dev, format, ##args); \
  2321. 0; \
  2322. })
  2323. #endif
  2324. #if defined(VERBOSE_DEBUG)
  2325. #define netdev_vdbg netdev_dbg
  2326. #else
  2327. #define netdev_vdbg(dev, format, args...) \
  2328. ({ \
  2329. if (0) \
  2330. netdev_printk(KERN_DEBUG, dev, format, ##args); \
  2331. 0; \
  2332. })
  2333. #endif
  2334. /*
  2335. * netdev_WARN() acts like dev_printk(), but with the key difference
  2336. * of using a WARN/WARN_ON to get the message out, including the
  2337. * file/line information and a backtrace.
  2338. */
  2339. #define netdev_WARN(dev, format, args...) \
  2340. WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
  2341. /* netif printk helpers, similar to netdev_printk */
  2342. #define netif_printk(priv, type, level, dev, fmt, args...) \
  2343. do { \
  2344. if (netif_msg_##type(priv)) \
  2345. netdev_printk(level, (dev), fmt, ##args); \
  2346. } while (0)
  2347. #define netif_level(level, priv, type, dev, fmt, args...) \
  2348. do { \
  2349. if (netif_msg_##type(priv)) \
  2350. netdev_##level(dev, fmt, ##args); \
  2351. } while (0)
  2352. #define netif_emerg(priv, type, dev, fmt, args...) \
  2353. netif_level(emerg, priv, type, dev, fmt, ##args)
  2354. #define netif_alert(priv, type, dev, fmt, args...) \
  2355. netif_level(alert, priv, type, dev, fmt, ##args)
  2356. #define netif_crit(priv, type, dev, fmt, args...) \
  2357. netif_level(crit, priv, type, dev, fmt, ##args)
  2358. #define netif_err(priv, type, dev, fmt, args...) \
  2359. netif_level(err, priv, type, dev, fmt, ##args)
  2360. #define netif_warn(priv, type, dev, fmt, args...) \
  2361. netif_level(warn, priv, type, dev, fmt, ##args)
  2362. #define netif_notice(priv, type, dev, fmt, args...) \
  2363. netif_level(notice, priv, type, dev, fmt, ##args)
  2364. #define netif_info(priv, type, dev, fmt, args...) \
  2365. netif_level(info, priv, type, dev, fmt, ##args)
  2366. #if defined(DEBUG)
  2367. #define netif_dbg(priv, type, dev, format, args...) \
  2368. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
  2369. #elif defined(CONFIG_DYNAMIC_DEBUG)
  2370. #define netif_dbg(priv, type, netdev, format, args...) \
  2371. do { \
  2372. if (netif_msg_##type(priv)) \
  2373. dynamic_dev_dbg((netdev)->dev.parent, \
  2374. "%s: " format, \
  2375. netdev_name(netdev), ##args); \
  2376. } while (0)
  2377. #else
  2378. #define netif_dbg(priv, type, dev, format, args...) \
  2379. ({ \
  2380. if (0) \
  2381. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
  2382. 0; \
  2383. })
  2384. #endif
  2385. #if defined(VERBOSE_DEBUG)
  2386. #define netif_vdbg netif_dbg
  2387. #else
  2388. #define netif_vdbg(priv, type, dev, format, args...) \
  2389. ({ \
  2390. if (0) \
  2391. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
  2392. 0; \
  2393. })
  2394. #endif
  2395. #endif /* __KERNEL__ */
  2396. #endif /* _LINUX_NETDEVICE_H */