netdevice.h 72 KB

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