netdevice.h 32 KB

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