netdevice.h 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. INET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * Definitions for the Interfaces handler.
  7. *
  8. * Version: @(#)dev.h 1.0.10 08/12/93
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Corey Minyard <wf-rch!minyard@relay.EU.net>
  13. * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
  14. * Alan Cox, <Alan.Cox@linux.org>
  15. * Bjorn Ekwall. <bj0rn@blox.se>
  16. * Pekka Riikonen <priikone@poseidon.pspt.fi>
  17. *
  18. * This program is free software; you can redistribute it and/or
  19. * modify it under the terms of the GNU General Public License
  20. * as published by the Free Software Foundation; either version
  21. * 2 of the License, or (at your option) any later version.
  22. *
  23. * Moved to /usr/include/linux for NET3
  24. */
  25. #ifndef _LINUX_NETDEVICE_H
  26. #define _LINUX_NETDEVICE_H
  27. #include <linux/if.h>
  28. #include <linux/if_ether.h>
  29. #include <linux/if_packet.h>
  30. #ifdef __KERNEL__
  31. #include <linux/timer.h>
  32. #include <asm/atomic.h>
  33. #include <asm/cache.h>
  34. #include <asm/byteorder.h>
  35. #include <linux/device.h>
  36. #include <linux/percpu.h>
  37. #include <linux/dmaengine.h>
  38. struct vlan_group;
  39. struct ethtool_ops;
  40. struct netpoll_info;
  41. /* 802.11 specific */
  42. struct wireless_dev;
  43. /* source back-compat hooks */
  44. #define SET_ETHTOOL_OPS(netdev,ops) \
  45. ( (netdev)->ethtool_ops = (ops) )
  46. #define HAVE_ALLOC_NETDEV /* feature macro: alloc_xxxdev
  47. functions are available. */
  48. #define HAVE_FREE_NETDEV /* free_netdev() */
  49. #define HAVE_NETDEV_PRIV /* netdev_priv() */
  50. #define NET_XMIT_SUCCESS 0
  51. #define NET_XMIT_DROP 1 /* skb dropped */
  52. #define NET_XMIT_CN 2 /* congestion notification */
  53. #define NET_XMIT_POLICED 3 /* skb is shot by police */
  54. #define NET_XMIT_BYPASS 4 /* packet does not leave via dequeue;
  55. (TC use only - dev_queue_xmit
  56. returns this as NET_XMIT_SUCCESS) */
  57. /* Backlog congestion levels */
  58. #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
  59. #define NET_RX_DROP 1 /* packet dropped */
  60. #define NET_RX_CN_LOW 2 /* storm alert, just in case */
  61. #define NET_RX_CN_MOD 3 /* Storm on its way! */
  62. #define NET_RX_CN_HIGH 4 /* The storm is here */
  63. #define NET_RX_BAD 5 /* packet dropped due to kernel error */
  64. /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
  65. * indicates that the device will soon be dropping packets, or already drops
  66. * some packets of the same priority; prompting us to send less aggressively. */
  67. #define net_xmit_eval(e) ((e) == NET_XMIT_CN? 0 : (e))
  68. #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
  69. #endif
  70. #define MAX_ADDR_LEN 32 /* Largest hardware address length */
  71. /* Driver transmit return codes */
  72. #define NETDEV_TX_OK 0 /* driver took care of packet */
  73. #define NETDEV_TX_BUSY 1 /* driver tx path was busy*/
  74. #define NETDEV_TX_LOCKED -1 /* driver tx lock was already taken */
  75. /*
  76. * Compute the worst case header length according to the protocols
  77. * used.
  78. */
  79. #if !defined(CONFIG_AX25) && !defined(CONFIG_AX25_MODULE) && !defined(CONFIG_TR)
  80. #define LL_MAX_HEADER 32
  81. #else
  82. #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
  83. #define LL_MAX_HEADER 96
  84. #else
  85. #define LL_MAX_HEADER 48
  86. #endif
  87. #endif
  88. #if !defined(CONFIG_NET_IPIP) && !defined(CONFIG_NET_IPIP_MODULE) && \
  89. !defined(CONFIG_NET_IPGRE) && !defined(CONFIG_NET_IPGRE_MODULE) && \
  90. !defined(CONFIG_IPV6_SIT) && !defined(CONFIG_IPV6_SIT_MODULE) && \
  91. !defined(CONFIG_IPV6_TUNNEL) && !defined(CONFIG_IPV6_TUNNEL_MODULE)
  92. #define MAX_HEADER LL_MAX_HEADER
  93. #else
  94. #define MAX_HEADER (LL_MAX_HEADER + 48)
  95. #endif
  96. /*
  97. * Network device statistics. Akin to the 2.0 ether stats but
  98. * with byte counters.
  99. */
  100. struct net_device_stats
  101. {
  102. unsigned long rx_packets; /* total packets received */
  103. unsigned long tx_packets; /* total packets transmitted */
  104. unsigned long rx_bytes; /* total bytes received */
  105. unsigned long tx_bytes; /* total bytes transmitted */
  106. unsigned long rx_errors; /* bad packets received */
  107. unsigned long tx_errors; /* packet transmit problems */
  108. unsigned long rx_dropped; /* no space in linux buffers */
  109. unsigned long tx_dropped; /* no space available in linux */
  110. unsigned long multicast; /* multicast packets received */
  111. unsigned long collisions;
  112. /* detailed rx_errors: */
  113. unsigned long rx_length_errors;
  114. unsigned long rx_over_errors; /* receiver ring buff overflow */
  115. unsigned long rx_crc_errors; /* recved pkt with crc error */
  116. unsigned long rx_frame_errors; /* recv'd frame alignment error */
  117. unsigned long rx_fifo_errors; /* recv'r fifo overrun */
  118. unsigned long rx_missed_errors; /* receiver missed packet */
  119. /* detailed tx_errors */
  120. unsigned long tx_aborted_errors;
  121. unsigned long tx_carrier_errors;
  122. unsigned long tx_fifo_errors;
  123. unsigned long tx_heartbeat_errors;
  124. unsigned long tx_window_errors;
  125. /* for cslip etc */
  126. unsigned long rx_compressed;
  127. unsigned long tx_compressed;
  128. };
  129. /* Media selection options. */
  130. enum {
  131. IF_PORT_UNKNOWN = 0,
  132. IF_PORT_10BASE2,
  133. IF_PORT_10BASET,
  134. IF_PORT_AUI,
  135. IF_PORT_100BASET,
  136. IF_PORT_100BASETX,
  137. IF_PORT_100BASEFX
  138. };
  139. #ifdef __KERNEL__
  140. #include <linux/cache.h>
  141. #include <linux/skbuff.h>
  142. struct neighbour;
  143. struct neigh_parms;
  144. struct sk_buff;
  145. struct netif_rx_stats
  146. {
  147. unsigned total;
  148. unsigned dropped;
  149. unsigned time_squeeze;
  150. unsigned cpu_collision;
  151. };
  152. DECLARE_PER_CPU(struct netif_rx_stats, netdev_rx_stat);
  153. /*
  154. * We tag multicasts with these structures.
  155. */
  156. struct dev_mc_list
  157. {
  158. struct dev_mc_list *next;
  159. __u8 dmi_addr[MAX_ADDR_LEN];
  160. unsigned char dmi_addrlen;
  161. int dmi_users;
  162. int dmi_gusers;
  163. };
  164. struct hh_cache
  165. {
  166. struct hh_cache *hh_next; /* Next entry */
  167. atomic_t hh_refcnt; /* number of users */
  168. /*
  169. * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
  170. * cache line on SMP.
  171. * They are mostly read, but hh_refcnt may be changed quite frequently,
  172. * incurring cache line ping pongs.
  173. */
  174. __be16 hh_type ____cacheline_aligned_in_smp;
  175. /* protocol identifier, f.e ETH_P_IP
  176. * NOTE: For VLANs, this will be the
  177. * encapuslated type. --BLG
  178. */
  179. u16 hh_len; /* length of header */
  180. int (*hh_output)(struct sk_buff *skb);
  181. seqlock_t hh_lock;
  182. /* cached hardware header; allow for machine alignment needs. */
  183. #define HH_DATA_MOD 16
  184. #define HH_DATA_OFF(__len) \
  185. (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
  186. #define HH_DATA_ALIGN(__len) \
  187. (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
  188. unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
  189. };
  190. /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  191. * Alternative is:
  192. * dev->hard_header_len ? (dev->hard_header_len +
  193. * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  194. *
  195. * We could use other alignment values, but we must maintain the
  196. * relationship HH alignment <= LL alignment.
  197. */
  198. #define LL_RESERVED_SPACE(dev) \
  199. (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  200. #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
  201. ((((dev)->hard_header_len+extra)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  202. /* These flag bits are private to the generic network queueing
  203. * layer, they may not be explicitly referenced by any other
  204. * code.
  205. */
  206. enum netdev_state_t
  207. {
  208. __LINK_STATE_XOFF=0,
  209. __LINK_STATE_START,
  210. __LINK_STATE_PRESENT,
  211. __LINK_STATE_SCHED,
  212. __LINK_STATE_NOCARRIER,
  213. __LINK_STATE_RX_SCHED,
  214. __LINK_STATE_LINKWATCH_PENDING,
  215. __LINK_STATE_DORMANT,
  216. __LINK_STATE_QDISC_RUNNING,
  217. };
  218. /*
  219. * This structure holds at boot time configured netdevice settings. They
  220. * are then used in the device probing.
  221. */
  222. struct netdev_boot_setup {
  223. char name[IFNAMSIZ];
  224. struct ifmap map;
  225. };
  226. #define NETDEV_BOOT_SETUP_MAX 8
  227. extern int __init netdev_boot_setup(char *str);
  228. /*
  229. * The DEVICE structure.
  230. * Actually, this whole structure is a big mistake. It mixes I/O
  231. * data with strictly "high-level" data, and it has to know about
  232. * almost every data structure used in the INET module.
  233. *
  234. * FIXME: cleanup struct net_device such that network protocol info
  235. * moves out.
  236. */
  237. struct net_device
  238. {
  239. /*
  240. * This is the first field of the "visible" part of this structure
  241. * (i.e. as seen by users in the "Space.c" file). It is the name
  242. * the interface.
  243. */
  244. char name[IFNAMSIZ];
  245. /* device name hash chain */
  246. struct hlist_node name_hlist;
  247. /*
  248. * I/O specific fields
  249. * FIXME: Merge these and struct ifmap into one
  250. */
  251. unsigned long mem_end; /* shared mem end */
  252. unsigned long mem_start; /* shared mem start */
  253. unsigned long base_addr; /* device I/O address */
  254. unsigned int irq; /* device IRQ number */
  255. /*
  256. * Some hardware also needs these fields, but they are not
  257. * part of the usual set specified in Space.c.
  258. */
  259. unsigned char if_port; /* Selectable AUI, TP,..*/
  260. unsigned char dma; /* DMA channel */
  261. unsigned long state;
  262. struct list_head dev_list;
  263. /* The device initialization function. Called only once. */
  264. int (*init)(struct net_device *dev);
  265. /* ------- Fields preinitialized in Space.c finish here ------- */
  266. /* Net device features */
  267. unsigned long features;
  268. #define NETIF_F_SG 1 /* Scatter/gather IO. */
  269. #define NETIF_F_IP_CSUM 2 /* Can checksum only TCP/UDP over IPv4. */
  270. #define NETIF_F_NO_CSUM 4 /* Does not require checksum. F.e. loopack. */
  271. #define NETIF_F_HW_CSUM 8 /* Can checksum all the packets. */
  272. #define NETIF_F_HIGHDMA 32 /* Can DMA to high memory. */
  273. #define NETIF_F_FRAGLIST 64 /* Scatter/gather IO. */
  274. #define NETIF_F_HW_VLAN_TX 128 /* Transmit VLAN hw acceleration */
  275. #define NETIF_F_HW_VLAN_RX 256 /* Receive VLAN hw acceleration */
  276. #define NETIF_F_HW_VLAN_FILTER 512 /* Receive filtering on VLAN */
  277. #define NETIF_F_VLAN_CHALLENGED 1024 /* Device cannot handle VLAN packets */
  278. #define NETIF_F_GSO 2048 /* Enable software GSO. */
  279. #define NETIF_F_LLTX 4096 /* LockLess TX */
  280. /* Segmentation offload features */
  281. #define NETIF_F_GSO_SHIFT 16
  282. #define NETIF_F_GSO_MASK 0xffff0000
  283. #define NETIF_F_TSO (SKB_GSO_TCPV4 << NETIF_F_GSO_SHIFT)
  284. #define NETIF_F_UFO (SKB_GSO_UDP << NETIF_F_GSO_SHIFT)
  285. #define NETIF_F_GSO_ROBUST (SKB_GSO_DODGY << NETIF_F_GSO_SHIFT)
  286. #define NETIF_F_TSO_ECN (SKB_GSO_TCP_ECN << NETIF_F_GSO_SHIFT)
  287. #define NETIF_F_TSO6 (SKB_GSO_TCPV6 << NETIF_F_GSO_SHIFT)
  288. /* List of features with software fallbacks. */
  289. #define NETIF_F_GSO_SOFTWARE (NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6)
  290. #define NETIF_F_GEN_CSUM (NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
  291. #define NETIF_F_ALL_CSUM (NETIF_F_IP_CSUM | NETIF_F_GEN_CSUM)
  292. struct net_device *next_sched;
  293. /* Interface index. Unique device identifier */
  294. int ifindex;
  295. int iflink;
  296. struct net_device_stats* (*get_stats)(struct net_device *dev);
  297. struct net_device_stats stats;
  298. #ifdef CONFIG_WIRELESS_EXT
  299. /* List of functions to handle Wireless Extensions (instead of ioctl).
  300. * See <net/iw_handler.h> for details. Jean II */
  301. const struct iw_handler_def * wireless_handlers;
  302. /* Instance data managed by the core of Wireless Extensions. */
  303. struct iw_public_data * wireless_data;
  304. #endif
  305. const struct ethtool_ops *ethtool_ops;
  306. /*
  307. * This marks the end of the "visible" part of the structure. All
  308. * fields hereafter are internal to the system, and may change at
  309. * will (read: may be cleaned up at will).
  310. */
  311. unsigned int flags; /* interface flags (a la BSD) */
  312. unsigned short gflags;
  313. unsigned short priv_flags; /* Like 'flags' but invisible to userspace. */
  314. unsigned short padded; /* How much padding added by alloc_netdev() */
  315. unsigned char operstate; /* RFC2863 operstate */
  316. unsigned char link_mode; /* mapping policy to operstate */
  317. unsigned mtu; /* interface MTU value */
  318. unsigned short type; /* interface hardware type */
  319. unsigned short hard_header_len; /* hardware hdr length */
  320. struct net_device *master; /* Pointer to master device of a group,
  321. * which this device is member of.
  322. */
  323. /* Interface address info. */
  324. unsigned char perm_addr[MAX_ADDR_LEN]; /* permanent hw address */
  325. unsigned char addr_len; /* hardware address length */
  326. unsigned short dev_id; /* for shared network cards */
  327. struct dev_mc_list *mc_list; /* Multicast mac addresses */
  328. int mc_count; /* Number of installed mcasts */
  329. int promiscuity;
  330. int allmulti;
  331. /* Protocol specific pointers */
  332. void *atalk_ptr; /* AppleTalk link */
  333. void *ip_ptr; /* IPv4 specific data */
  334. void *dn_ptr; /* DECnet specific data */
  335. void *ip6_ptr; /* IPv6 specific data */
  336. void *ec_ptr; /* Econet specific data */
  337. void *ax25_ptr; /* AX.25 specific data */
  338. struct wireless_dev *ieee80211_ptr; /* IEEE 802.11 specific data,
  339. assign before registering */
  340. /*
  341. * Cache line mostly used on receive path (including eth_type_trans())
  342. */
  343. struct list_head poll_list ____cacheline_aligned_in_smp;
  344. /* Link to poll list */
  345. int (*poll) (struct net_device *dev, int *quota);
  346. int quota;
  347. int weight;
  348. unsigned long last_rx; /* Time of last Rx */
  349. /* Interface address info used in eth_type_trans() */
  350. unsigned char dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast
  351. because most packets are unicast) */
  352. unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
  353. /*
  354. * Cache line mostly used on queue transmit path (qdisc)
  355. */
  356. /* device queue lock */
  357. spinlock_t queue_lock ____cacheline_aligned_in_smp;
  358. struct Qdisc *qdisc;
  359. struct Qdisc *qdisc_sleeping;
  360. struct list_head qdisc_list;
  361. unsigned long tx_queue_len; /* Max frames per queue allowed */
  362. /* Partially transmitted GSO packet. */
  363. struct sk_buff *gso_skb;
  364. /* ingress path synchronizer */
  365. spinlock_t ingress_lock;
  366. struct Qdisc *qdisc_ingress;
  367. /*
  368. * One part is mostly used on xmit path (device)
  369. */
  370. /* hard_start_xmit synchronizer */
  371. spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
  372. /* cpu id of processor entered to hard_start_xmit or -1,
  373. if nobody entered there.
  374. */
  375. int xmit_lock_owner;
  376. void *priv; /* pointer to private data */
  377. int (*hard_start_xmit) (struct sk_buff *skb,
  378. struct net_device *dev);
  379. /* These may be needed for future network-power-down code. */
  380. unsigned long trans_start; /* Time (in jiffies) of last Tx */
  381. int watchdog_timeo; /* used by dev_watchdog() */
  382. struct timer_list watchdog_timer;
  383. /*
  384. * refcnt is a very hot point, so align it on SMP
  385. */
  386. /* Number of references to this device */
  387. atomic_t refcnt ____cacheline_aligned_in_smp;
  388. /* delayed register/unregister */
  389. struct list_head todo_list;
  390. /* device index hash chain */
  391. struct hlist_node index_hlist;
  392. struct net_device *link_watch_next;
  393. /* register/unregister state machine */
  394. enum { NETREG_UNINITIALIZED=0,
  395. NETREG_REGISTERED, /* completed register_netdevice */
  396. NETREG_UNREGISTERING, /* called unregister_netdevice */
  397. NETREG_UNREGISTERED, /* completed unregister todo */
  398. NETREG_RELEASED, /* called free_netdev */
  399. } reg_state;
  400. /* Called after device is detached from network. */
  401. void (*uninit)(struct net_device *dev);
  402. /* Called after last user reference disappears. */
  403. void (*destructor)(struct net_device *dev);
  404. /* Pointers to interface service routines. */
  405. int (*open)(struct net_device *dev);
  406. int (*stop)(struct net_device *dev);
  407. #define HAVE_NETDEV_POLL
  408. int (*hard_header) (struct sk_buff *skb,
  409. struct net_device *dev,
  410. unsigned short type,
  411. void *daddr,
  412. void *saddr,
  413. unsigned len);
  414. int (*rebuild_header)(struct sk_buff *skb);
  415. #define HAVE_MULTICAST
  416. void (*set_multicast_list)(struct net_device *dev);
  417. #define HAVE_SET_MAC_ADDR
  418. int (*set_mac_address)(struct net_device *dev,
  419. void *addr);
  420. #define HAVE_PRIVATE_IOCTL
  421. int (*do_ioctl)(struct net_device *dev,
  422. struct ifreq *ifr, int cmd);
  423. #define HAVE_SET_CONFIG
  424. int (*set_config)(struct net_device *dev,
  425. struct ifmap *map);
  426. #define HAVE_HEADER_CACHE
  427. int (*hard_header_cache)(struct neighbour *neigh,
  428. struct hh_cache *hh);
  429. void (*header_cache_update)(struct hh_cache *hh,
  430. struct net_device *dev,
  431. unsigned char * haddr);
  432. #define HAVE_CHANGE_MTU
  433. int (*change_mtu)(struct net_device *dev, int new_mtu);
  434. #define HAVE_TX_TIMEOUT
  435. void (*tx_timeout) (struct net_device *dev);
  436. void (*vlan_rx_register)(struct net_device *dev,
  437. struct vlan_group *grp);
  438. void (*vlan_rx_add_vid)(struct net_device *dev,
  439. unsigned short vid);
  440. void (*vlan_rx_kill_vid)(struct net_device *dev,
  441. unsigned short vid);
  442. int (*hard_header_parse)(struct sk_buff *skb,
  443. unsigned char *haddr);
  444. int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
  445. #ifdef CONFIG_NETPOLL
  446. struct netpoll_info *npinfo;
  447. #endif
  448. #ifdef CONFIG_NET_POLL_CONTROLLER
  449. void (*poll_controller)(struct net_device *dev);
  450. #endif
  451. /* bridge stuff */
  452. struct net_bridge_port *br_port;
  453. /* class/net/name entry */
  454. struct device dev;
  455. /* space for optional statistics and wireless sysfs groups */
  456. struct attribute_group *sysfs_groups[3];
  457. };
  458. #define to_net_dev(d) container_of(d, struct net_device, dev)
  459. #define NETDEV_ALIGN 32
  460. #define NETDEV_ALIGN_CONST (NETDEV_ALIGN - 1)
  461. static inline void *netdev_priv(struct net_device *dev)
  462. {
  463. return (char *)dev + ((sizeof(struct net_device)
  464. + NETDEV_ALIGN_CONST)
  465. & ~NETDEV_ALIGN_CONST);
  466. }
  467. #define SET_MODULE_OWNER(dev) do { } while (0)
  468. /* Set the sysfs physical device reference for the network logical device
  469. * if set prior to registration will cause a symlink during initialization.
  470. */
  471. #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
  472. struct packet_type {
  473. __be16 type; /* This is really htons(ether_type). */
  474. struct net_device *dev; /* NULL is wildcarded here */
  475. int (*func) (struct sk_buff *,
  476. struct net_device *,
  477. struct packet_type *,
  478. struct net_device *);
  479. struct sk_buff *(*gso_segment)(struct sk_buff *skb,
  480. int features);
  481. int (*gso_send_check)(struct sk_buff *skb);
  482. void *af_packet_priv;
  483. struct list_head list;
  484. };
  485. #include <linux/interrupt.h>
  486. #include <linux/notifier.h>
  487. extern struct net_device loopback_dev; /* The loopback */
  488. extern struct list_head dev_base_head; /* All devices */
  489. extern rwlock_t dev_base_lock; /* Device list lock */
  490. #define for_each_netdev(d) \
  491. list_for_each_entry(d, &dev_base_head, dev_list)
  492. #define for_each_netdev_safe(d, n) \
  493. list_for_each_entry_safe(d, n, &dev_base_head, dev_list)
  494. #define for_each_netdev_continue(d) \
  495. list_for_each_entry_continue(d, &dev_base_head, dev_list)
  496. #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
  497. static inline struct net_device *next_net_device(struct net_device *dev)
  498. {
  499. struct list_head *lh;
  500. lh = dev->dev_list.next;
  501. return lh == &dev_base_head ? NULL : net_device_entry(lh);
  502. }
  503. static inline struct net_device *first_net_device(void)
  504. {
  505. return list_empty(&dev_base_head) ? NULL :
  506. net_device_entry(dev_base_head.next);
  507. }
  508. extern int netdev_boot_setup_check(struct net_device *dev);
  509. extern unsigned long netdev_boot_base(const char *prefix, int unit);
  510. extern struct net_device *dev_getbyhwaddr(unsigned short type, char *hwaddr);
  511. extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
  512. extern struct net_device *__dev_getfirstbyhwtype(unsigned short type);
  513. extern void dev_add_pack(struct packet_type *pt);
  514. extern void dev_remove_pack(struct packet_type *pt);
  515. extern void __dev_remove_pack(struct packet_type *pt);
  516. extern struct net_device *dev_get_by_flags(unsigned short flags,
  517. unsigned short mask);
  518. extern struct net_device *dev_get_by_name(const char *name);
  519. extern struct net_device *__dev_get_by_name(const char *name);
  520. extern int dev_alloc_name(struct net_device *dev, const char *name);
  521. extern int dev_open(struct net_device *dev);
  522. extern int dev_close(struct net_device *dev);
  523. extern int dev_queue_xmit(struct sk_buff *skb);
  524. extern int register_netdevice(struct net_device *dev);
  525. extern void unregister_netdevice(struct net_device *dev);
  526. extern void free_netdev(struct net_device *dev);
  527. extern void synchronize_net(void);
  528. extern int register_netdevice_notifier(struct notifier_block *nb);
  529. extern int unregister_netdevice_notifier(struct notifier_block *nb);
  530. extern int call_netdevice_notifiers(unsigned long val, void *v);
  531. extern struct net_device *dev_get_by_index(int ifindex);
  532. extern struct net_device *__dev_get_by_index(int ifindex);
  533. extern int dev_restart(struct net_device *dev);
  534. #ifdef CONFIG_NETPOLL_TRAP
  535. extern int netpoll_trap(void);
  536. #endif
  537. typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
  538. extern int register_gifconf(unsigned int family, gifconf_func_t * gifconf);
  539. static inline int unregister_gifconf(unsigned int family)
  540. {
  541. return register_gifconf(family, NULL);
  542. }
  543. /*
  544. * Incoming packets are placed on per-cpu queues so that
  545. * no locking is needed.
  546. */
  547. struct softnet_data
  548. {
  549. struct net_device *output_queue;
  550. struct sk_buff_head input_pkt_queue;
  551. struct list_head poll_list;
  552. struct sk_buff *completion_queue;
  553. struct net_device backlog_dev; /* Sorry. 8) */
  554. #ifdef CONFIG_NET_DMA
  555. struct dma_chan *net_dma;
  556. #endif
  557. };
  558. DECLARE_PER_CPU(struct softnet_data,softnet_data);
  559. #define HAVE_NETIF_QUEUE
  560. extern void __netif_schedule(struct net_device *dev);
  561. static inline void netif_schedule(struct net_device *dev)
  562. {
  563. if (!test_bit(__LINK_STATE_XOFF, &dev->state))
  564. __netif_schedule(dev);
  565. }
  566. static inline void netif_start_queue(struct net_device *dev)
  567. {
  568. clear_bit(__LINK_STATE_XOFF, &dev->state);
  569. }
  570. static inline void netif_wake_queue(struct net_device *dev)
  571. {
  572. #ifdef CONFIG_NETPOLL_TRAP
  573. if (netpoll_trap()) {
  574. clear_bit(__LINK_STATE_XOFF, &dev->state);
  575. return;
  576. }
  577. #endif
  578. if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
  579. __netif_schedule(dev);
  580. }
  581. static inline void netif_stop_queue(struct net_device *dev)
  582. {
  583. set_bit(__LINK_STATE_XOFF, &dev->state);
  584. }
  585. static inline int netif_queue_stopped(const struct net_device *dev)
  586. {
  587. return test_bit(__LINK_STATE_XOFF, &dev->state);
  588. }
  589. static inline int netif_running(const struct net_device *dev)
  590. {
  591. return test_bit(__LINK_STATE_START, &dev->state);
  592. }
  593. /* Use this variant when it is known for sure that it
  594. * is executing from interrupt context.
  595. */
  596. static inline void dev_kfree_skb_irq(struct sk_buff *skb)
  597. {
  598. if (atomic_dec_and_test(&skb->users)) {
  599. struct softnet_data *sd;
  600. unsigned long flags;
  601. local_irq_save(flags);
  602. sd = &__get_cpu_var(softnet_data);
  603. skb->next = sd->completion_queue;
  604. sd->completion_queue = skb;
  605. raise_softirq_irqoff(NET_TX_SOFTIRQ);
  606. local_irq_restore(flags);
  607. }
  608. }
  609. /* Use this variant in places where it could be invoked
  610. * either from interrupt or non-interrupt context.
  611. */
  612. extern void dev_kfree_skb_any(struct sk_buff *skb);
  613. #define HAVE_NETIF_RX 1
  614. extern int netif_rx(struct sk_buff *skb);
  615. extern int netif_rx_ni(struct sk_buff *skb);
  616. #define HAVE_NETIF_RECEIVE_SKB 1
  617. extern int netif_receive_skb(struct sk_buff *skb);
  618. extern int dev_valid_name(const char *name);
  619. extern int dev_ioctl(unsigned int cmd, void __user *);
  620. extern int dev_ethtool(struct ifreq *);
  621. extern unsigned dev_get_flags(const struct net_device *);
  622. extern int dev_change_flags(struct net_device *, unsigned);
  623. extern int dev_change_name(struct net_device *, char *);
  624. extern int dev_set_mtu(struct net_device *, int);
  625. extern int dev_set_mac_address(struct net_device *,
  626. struct sockaddr *);
  627. extern int dev_hard_start_xmit(struct sk_buff *skb,
  628. struct net_device *dev);
  629. extern void dev_init(void);
  630. extern int netdev_budget;
  631. /* Called by rtnetlink.c:rtnl_unlock() */
  632. extern void netdev_run_todo(void);
  633. static inline void dev_put(struct net_device *dev)
  634. {
  635. atomic_dec(&dev->refcnt);
  636. }
  637. static inline void dev_hold(struct net_device *dev)
  638. {
  639. atomic_inc(&dev->refcnt);
  640. }
  641. /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  642. * and _off may be called from IRQ context, but it is caller
  643. * who is responsible for serialization of these calls.
  644. *
  645. * The name carrier is inappropriate, these functions should really be
  646. * called netif_lowerlayer_*() because they represent the state of any
  647. * kind of lower layer not just hardware media.
  648. */
  649. extern void linkwatch_fire_event(struct net_device *dev);
  650. static inline int netif_carrier_ok(const struct net_device *dev)
  651. {
  652. return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  653. }
  654. extern void __netdev_watchdog_up(struct net_device *dev);
  655. extern void netif_carrier_on(struct net_device *dev);
  656. extern void netif_carrier_off(struct net_device *dev);
  657. static inline void netif_dormant_on(struct net_device *dev)
  658. {
  659. if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
  660. linkwatch_fire_event(dev);
  661. }
  662. static inline void netif_dormant_off(struct net_device *dev)
  663. {
  664. if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
  665. linkwatch_fire_event(dev);
  666. }
  667. static inline int netif_dormant(const struct net_device *dev)
  668. {
  669. return test_bit(__LINK_STATE_DORMANT, &dev->state);
  670. }
  671. static inline int netif_oper_up(const struct net_device *dev) {
  672. return (dev->operstate == IF_OPER_UP ||
  673. dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
  674. }
  675. /* Hot-plugging. */
  676. static inline int netif_device_present(struct net_device *dev)
  677. {
  678. return test_bit(__LINK_STATE_PRESENT, &dev->state);
  679. }
  680. extern void netif_device_detach(struct net_device *dev);
  681. extern void netif_device_attach(struct net_device *dev);
  682. /*
  683. * Network interface message level settings
  684. */
  685. #define HAVE_NETIF_MSG 1
  686. enum {
  687. NETIF_MSG_DRV = 0x0001,
  688. NETIF_MSG_PROBE = 0x0002,
  689. NETIF_MSG_LINK = 0x0004,
  690. NETIF_MSG_TIMER = 0x0008,
  691. NETIF_MSG_IFDOWN = 0x0010,
  692. NETIF_MSG_IFUP = 0x0020,
  693. NETIF_MSG_RX_ERR = 0x0040,
  694. NETIF_MSG_TX_ERR = 0x0080,
  695. NETIF_MSG_TX_QUEUED = 0x0100,
  696. NETIF_MSG_INTR = 0x0200,
  697. NETIF_MSG_TX_DONE = 0x0400,
  698. NETIF_MSG_RX_STATUS = 0x0800,
  699. NETIF_MSG_PKTDATA = 0x1000,
  700. NETIF_MSG_HW = 0x2000,
  701. NETIF_MSG_WOL = 0x4000,
  702. };
  703. #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
  704. #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
  705. #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
  706. #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
  707. #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
  708. #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
  709. #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
  710. #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
  711. #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
  712. #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
  713. #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
  714. #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
  715. #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
  716. #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
  717. #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
  718. static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
  719. {
  720. /* use default */
  721. if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  722. return default_msg_enable_bits;
  723. if (debug_value == 0) /* no output */
  724. return 0;
  725. /* set low N bits */
  726. return (1 << debug_value) - 1;
  727. }
  728. /* Test if receive needs to be scheduled */
  729. static inline int __netif_rx_schedule_prep(struct net_device *dev)
  730. {
  731. return !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
  732. }
  733. /* Test if receive needs to be scheduled but only if up */
  734. static inline int netif_rx_schedule_prep(struct net_device *dev)
  735. {
  736. return netif_running(dev) && __netif_rx_schedule_prep(dev);
  737. }
  738. /* Add interface to tail of rx poll list. This assumes that _prep has
  739. * already been called and returned 1.
  740. */
  741. extern void __netif_rx_schedule(struct net_device *dev);
  742. /* Try to reschedule poll. Called by irq handler. */
  743. static inline void netif_rx_schedule(struct net_device *dev)
  744. {
  745. if (netif_rx_schedule_prep(dev))
  746. __netif_rx_schedule(dev);
  747. }
  748. /* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().
  749. * Do not inline this?
  750. */
  751. static inline int netif_rx_reschedule(struct net_device *dev, int undo)
  752. {
  753. if (netif_rx_schedule_prep(dev)) {
  754. unsigned long flags;
  755. dev->quota += undo;
  756. local_irq_save(flags);
  757. list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
  758. __raise_softirq_irqoff(NET_RX_SOFTIRQ);
  759. local_irq_restore(flags);
  760. return 1;
  761. }
  762. return 0;
  763. }
  764. /* same as netif_rx_complete, except that local_irq_save(flags)
  765. * has already been issued
  766. */
  767. static inline void __netif_rx_complete(struct net_device *dev)
  768. {
  769. BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
  770. list_del(&dev->poll_list);
  771. smp_mb__before_clear_bit();
  772. clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  773. }
  774. /* Remove interface from poll list: it must be in the poll list
  775. * on current cpu. This primitive is called by dev->poll(), when
  776. * it completes the work. The device cannot be out of poll list at this
  777. * moment, it is BUG().
  778. */
  779. static inline void netif_rx_complete(struct net_device *dev)
  780. {
  781. unsigned long flags;
  782. local_irq_save(flags);
  783. __netif_rx_complete(dev);
  784. local_irq_restore(flags);
  785. }
  786. static inline void netif_poll_disable(struct net_device *dev)
  787. {
  788. while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state))
  789. /* No hurry. */
  790. schedule_timeout_interruptible(1);
  791. }
  792. static inline void netif_poll_enable(struct net_device *dev)
  793. {
  794. smp_mb__before_clear_bit();
  795. clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
  796. }
  797. static inline void netif_tx_lock(struct net_device *dev)
  798. {
  799. spin_lock(&dev->_xmit_lock);
  800. dev->xmit_lock_owner = smp_processor_id();
  801. }
  802. static inline void netif_tx_lock_bh(struct net_device *dev)
  803. {
  804. spin_lock_bh(&dev->_xmit_lock);
  805. dev->xmit_lock_owner = smp_processor_id();
  806. }
  807. static inline int netif_tx_trylock(struct net_device *dev)
  808. {
  809. int ok = spin_trylock(&dev->_xmit_lock);
  810. if (likely(ok))
  811. dev->xmit_lock_owner = smp_processor_id();
  812. return ok;
  813. }
  814. static inline void netif_tx_unlock(struct net_device *dev)
  815. {
  816. dev->xmit_lock_owner = -1;
  817. spin_unlock(&dev->_xmit_lock);
  818. }
  819. static inline void netif_tx_unlock_bh(struct net_device *dev)
  820. {
  821. dev->xmit_lock_owner = -1;
  822. spin_unlock_bh(&dev->_xmit_lock);
  823. }
  824. static inline void netif_tx_disable(struct net_device *dev)
  825. {
  826. netif_tx_lock_bh(dev);
  827. netif_stop_queue(dev);
  828. netif_tx_unlock_bh(dev);
  829. }
  830. /* These functions live elsewhere (drivers/net/net_init.c, but related) */
  831. extern void ether_setup(struct net_device *dev);
  832. /* Support for loadable net-drivers */
  833. extern struct net_device *alloc_netdev(int sizeof_priv, const char *name,
  834. void (*setup)(struct net_device *));
  835. extern int register_netdev(struct net_device *dev);
  836. extern void unregister_netdev(struct net_device *dev);
  837. /* Functions used for multicast support */
  838. extern void dev_mc_upload(struct net_device *dev);
  839. extern int dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
  840. extern int dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
  841. extern void dev_mc_discard(struct net_device *dev);
  842. extern void dev_set_promiscuity(struct net_device *dev, int inc);
  843. extern void dev_set_allmulti(struct net_device *dev, int inc);
  844. extern void netdev_state_change(struct net_device *dev);
  845. extern void netdev_features_change(struct net_device *dev);
  846. /* Load a device via the kmod */
  847. extern void dev_load(const char *name);
  848. extern void dev_mcast_init(void);
  849. extern int netdev_max_backlog;
  850. extern int weight_p;
  851. extern int netdev_set_master(struct net_device *dev, struct net_device *master);
  852. extern int skb_checksum_help(struct sk_buff *skb);
  853. extern struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features);
  854. #ifdef CONFIG_BUG
  855. extern void netdev_rx_csum_fault(struct net_device *dev);
  856. #else
  857. static inline void netdev_rx_csum_fault(struct net_device *dev)
  858. {
  859. }
  860. #endif
  861. /* rx skb timestamps */
  862. extern void net_enable_timestamp(void);
  863. extern void net_disable_timestamp(void);
  864. #ifdef CONFIG_PROC_FS
  865. extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
  866. extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
  867. extern void dev_seq_stop(struct seq_file *seq, void *v);
  868. #endif
  869. extern void linkwatch_run_queue(void);
  870. static inline int net_gso_ok(int features, int gso_type)
  871. {
  872. int feature = gso_type << NETIF_F_GSO_SHIFT;
  873. return (features & feature) == feature;
  874. }
  875. static inline int skb_gso_ok(struct sk_buff *skb, int features)
  876. {
  877. return net_gso_ok(features, skb_shinfo(skb)->gso_type);
  878. }
  879. static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
  880. {
  881. return skb_is_gso(skb) &&
  882. (!skb_gso_ok(skb, dev->features) ||
  883. unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
  884. }
  885. /* On bonding slaves other than the currently active slave, suppress
  886. * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
  887. * ARP on active-backup slaves with arp_validate enabled.
  888. */
  889. static inline int skb_bond_should_drop(struct sk_buff *skb)
  890. {
  891. struct net_device *dev = skb->dev;
  892. struct net_device *master = dev->master;
  893. if (master &&
  894. (dev->priv_flags & IFF_SLAVE_INACTIVE)) {
  895. if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
  896. skb->protocol == __constant_htons(ETH_P_ARP))
  897. return 0;
  898. if (master->priv_flags & IFF_MASTER_ALB) {
  899. if (skb->pkt_type != PACKET_BROADCAST &&
  900. skb->pkt_type != PACKET_MULTICAST)
  901. return 0;
  902. }
  903. if (master->priv_flags & IFF_MASTER_8023AD &&
  904. skb->protocol == __constant_htons(ETH_P_SLOW))
  905. return 0;
  906. return 1;
  907. }
  908. return 0;
  909. }
  910. #endif /* __KERNEL__ */
  911. #endif /* _LINUX_DEV_H */