netdevice.h File Reference

#include <linux/if.h>
#include <linux/if_ether.h>
#include <linux/if_packet.h>
#include <asm/atomic.h>
#include <asm/cache.h>
#include <asm/byteorder.h>
#include <linux/config.h>
#include <linux/cache.h>
#include <linux/skbuff.h>
#include <linux/interrupt.h>
#include <linux/notifier.h>

Go to the source code of this file.

Classes
struct	net_device_stats
struct	netif_rx_stats
struct	dev_mc_list
struct	hh_cache
struct	netdev_boot_setup
struct	net_device
struct	packet_type
struct	softnet_data
Defines
#define	SET_ETHTOOL_OPS(netdev, ops)   ( (netdev)->ethtool_ops = (ops) )
#define	HAVE_ALLOC_NETDEV
#define	HAVE_FREE_NETDEV
#define	NET_XMIT_SUCCESS   0
#define	NET_XMIT_DROP   1
#define	NET_XMIT_CN   2
#define	NET_XMIT_POLICED   3
#define	NET_XMIT_BYPASS   4
#define	NET_RX_SUCCESS   0
#define	NET_RX_DROP   1
#define	NET_RX_CN_LOW   2
#define	NET_RX_CN_MOD   3
#define	NET_RX_CN_HIGH   4
#define	NET_RX_BAD   5
#define	net_xmit_errno(e)   ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
#define	MAX_ADDR_LEN   8
#define	LL_MAX_HEADER   32
#define	MAX_HEADER   LL_MAX_HEADER
#define	HH_DATA_MOD   16
#define	HH_DATA_OFF(__len)   (HH_DATA_MOD - ((__len) & (HH_DATA_MOD - 1)))
#define	HH_DATA_ALIGN(__len)   (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
#define	NETDEV_BOOT_SETUP_MAX   8
#define	NETIF_F_SG   1
#define	NETIF_F_IP_CSUM   2
#define	NETIF_F_NO_CSUM   4
#define	NETIF_F_HW_CSUM   8
#define	NETIF_F_DYNALLOC   16
#define	NETIF_F_HIGHDMA   32
#define	NETIF_F_FRAGLIST   64
#define	NETIF_F_HW_VLAN_TX   128
#define	NETIF_F_HW_VLAN_RX   256
#define	NETIF_F_HW_VLAN_FILTER   512
#define	NETIF_F_VLAN_CHALLENGED   1024
#define	HAVE_NETDEV_POLL
#define	HAVE_MULTICAST
#define	HAVE_SET_MAC_ADDR
#define	HAVE_PRIVATE_IOCTL
#define	HAVE_SET_CONFIG
#define	HAVE_HEADER_CACHE
#define	HAVE_CHANGE_MTU
#define	HAVE_TX_TIMEOUT
#define	HAVE_NETIF_QUEUE
#define	HAVE_NETIF_RX   1
#define	HAVE_NETIF_RECEIVE_SKB   1
#define	__dev_put(dev)   atomic_dec(&(dev)->refcnt)
#define	dev_hold(dev)   atomic_inc(&(dev)->refcnt)
#define	HAVE_NETIF_MSG   1
#define	netif_msg_drv(p)   ((p)->msg_enable & NETIF_MSG_DRV)
#define	netif_msg_probe(p)   ((p)->msg_enable & NETIF_MSG_PROBE)
#define	netif_msg_link(p)   ((p)->msg_enable & NETIF_MSG_LINK)
#define	netif_msg_timer(p)   ((p)->msg_enable & NETIF_MSG_TIMER)
#define	netif_msg_ifdown(p)   ((p)->msg_enable & NETIF_MSG_IFDOWN)
#define	netif_msg_ifup(p)   ((p)->msg_enable & NETIF_MSG_IFUP)
#define	netif_msg_rx_err(p)   ((p)->msg_enable & NETIF_MSG_RX_ERR)
#define	netif_msg_tx_err(p)   ((p)->msg_enable & NETIF_MSG_TX_ERR)
#define	netif_msg_tx_queued(p)   ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
#define	netif_msg_intr(p)   ((p)->msg_enable & NETIF_MSG_INTR)
#define	netif_msg_tx_done(p)   ((p)->msg_enable & NETIF_MSG_TX_DONE)
#define	netif_msg_rx_status(p)   ((p)->msg_enable & NETIF_MSG_RX_STATUS)
#define	netif_msg_pktdata(p)   ((p)->msg_enable & NETIF_MSG_PKTDATA)
#define	netif_msg_hw(p)   ((p)->msg_enable & NETIF_MSG_HW)
#define	netif_msg_wol(p)   ((p)->msg_enable & NETIF_MSG_WOL)
Typedefs
typedef int	gifconf_func_t (struct net_device *dev, char *bufptr, int len)
Enumerations
enum	{   IF_PORT_UNKNOWN = 0, IF_PORT_10BASE2, IF_PORT_10BASET, IF_PORT_AUI,   IF_PORT_100BASET, IF_PORT_100BASETX, IF_PORT_100BASEFX }
enum	netdev_state_t {   __LINK_STATE_XOFF = 0, __LINK_STATE_START, __LINK_STATE_PRESENT, __LINK_STATE_SCHED,   __LINK_STATE_NOCARRIER, __LINK_STATE_RX_SCHED }
enum	{   NETIF_MSG_DRV = 0x0001, NETIF_MSG_PROBE = 0x0002, NETIF_MSG_LINK = 0x0004, NETIF_MSG_TIMER = 0x0008,   NETIF_MSG_IFDOWN = 0x0010, NETIF_MSG_IFUP = 0x0020, NETIF_MSG_RX_ERR = 0x0040, NETIF_MSG_TX_ERR = 0x0080,   NETIF_MSG_TX_QUEUED = 0x0100, NETIF_MSG_INTR = 0x0200, NETIF_MSG_TX_DONE = 0x0400, NETIF_MSG_RX_STATUS = 0x0800,   NETIF_MSG_PKTDATA = 0x1000, NETIF_MSG_HW = 0x2000, NETIF_MSG_WOL = 0x4000 }
Functions
int	netdev_boot_setup_add (char *name, struct ifmap *map)
int	netdev_boot_setup_check (struct net_device *dev)
net_device *	dev_getbyhwaddr (unsigned short type, char *hwaddr)
void	dev_add_pack (struct packet_type *pt)
void	dev_remove_pack (struct packet_type *pt)
int	dev_get (const char *name)
net_device *	dev_get_by_flags (unsigned short flags, unsigned short mask)
net_device *	__dev_get_by_flags (unsigned short flags, unsigned short mask)
net_device *	dev_get_by_name (const char *name)
net_device *	__dev_get_by_name (const char *name)
net_device *	dev_alloc (const char *name, int *err)
int	dev_alloc_name (struct net_device *dev, const char *name)
int	dev_open (struct net_device *dev)
int	dev_close (struct net_device *dev)
int	dev_queue_xmit (struct sk_buff *skb)
int	register_netdevice (struct net_device *dev)
int	unregister_netdevice (struct net_device *dev)
int	register_netdevice_notifier (struct notifier_block *nb)
int	unregister_netdevice_notifier (struct notifier_block *nb)
int	dev_new_index (void)
net_device *	dev_get_by_index (int ifindex)
net_device *	__dev_get_by_index (int ifindex)
int	dev_restart (struct net_device *dev)
int	register_gifconf (unsigned int family, gifconf_func_t *gifconf)
int	unregister_gifconf (unsigned int family)
void	__netif_schedule (struct net_device *dev)
void	netif_schedule (struct net_device *dev)
void	netif_start_queue (struct net_device *dev)
void	netif_wake_queue (struct net_device *dev)
void	netif_stop_queue (struct net_device *dev)
int	netif_queue_stopped (struct net_device *dev)
int	netif_running (struct net_device *dev)
void	dev_kfree_skb_irq (struct sk_buff *skb)
void	dev_kfree_skb_any (struct sk_buff *skb)
int	netif_rx (struct sk_buff *skb)
int	netif_receive_skb (struct sk_buff *skb)
int	dev_ioctl (unsigned int cmd, void *)
int	dev_ethtool (struct ifreq *)
int	dev_change_flags (struct net_device *, unsigned)
void	dev_queue_xmit_nit (struct sk_buff *skb, struct net_device *dev)
void	dev_init (void)
int	netif_rx_ni (struct sk_buff *skb)
void	dev_init_buffers (struct net_device *dev)
int	netdev_finish_unregister (struct net_device *dev)
void	dev_put (struct net_device *dev)
int	netif_carrier_ok (struct net_device *dev)
void	__netdev_watchdog_up (struct net_device *dev)
void	netif_carrier_on (struct net_device *dev)
void	netif_carrier_off (struct net_device *dev)
int	netif_device_present (struct net_device *dev)
void	netif_device_detach (struct net_device *dev)
void	netif_device_attach (struct net_device *dev)
int	netif_rx_schedule_prep (struct net_device *dev)
void	__netif_rx_schedule (struct net_device *dev)
void	netif_rx_schedule (struct net_device *dev)
int	netif_rx_reschedule (struct net_device *dev, int undo)
void	netif_rx_complete (struct net_device *dev)
void	netif_poll_disable (struct net_device *dev)
void	netif_poll_enable (struct net_device *dev)
void	__netif_rx_complete (struct net_device *dev)
void	netif_tx_disable (struct net_device *dev)
void	ether_setup (struct net_device *dev)
void	fddi_setup (struct net_device *dev)
void	tr_setup (struct net_device *dev)
void	fc_setup (struct net_device *dev)
void	fc_freedev (struct net_device *dev)
net_device *	alloc_netdev (int sizeof_priv, const char *name, void(*setup)(struct net_device *))
int	register_netdev (struct net_device *dev)
void	unregister_netdev (struct net_device *dev)
void	dev_mc_upload (struct net_device *dev)
int	dev_mc_delete (struct net_device *dev, void *addr, int alen, int all)
int	dev_mc_add (struct net_device *dev, void *addr, int alen, int newonly)
void	dev_mc_discard (struct net_device *dev)
void	dev_set_promiscuity (struct net_device *dev, int inc)
void	dev_set_allmulti (struct net_device *dev, int inc)
void	netdev_state_change (struct net_device *dev)
void	dev_load (const char *name)
void	dev_mcast_init (void)
int	netdev_register_fc (struct net_device *dev, void(*stimul)(struct net_device *dev))
void	netdev_unregister_fc (int bit)
int	netdev_set_master (struct net_device *dev, struct net_device *master)
sk_buff *	skb_checksum_help (struct sk_buff *skb)
void	free_netdev (struct net_device *dev)
Variables
const char *	if_port_text []
netif_rx_stats	____cacheline_aligned
netif_rx_stats	netdev_rx_stat []
net_device	loopback_dev
net_device *	dev_base
rwlock_t	dev_base_lock
softnet_data	softnet_data [NR_CPUS]
int	netdev_nit
int	netdev_max_backlog
int	weight_p
unsigned long	netdev_fc_xoff
atomic_t	netdev_dropping

---

Define Documentation

#define __dev_put (  dev   )     atomic_dec(&(dev)->refcnt)

Definition at line 644 of file netdevice.h. Referenced by ip_mc_find_dev(), and vif_add().

#define dev_hold (  dev   )     atomic_inc(&(dev)->refcnt)

Definition at line 645 of file netdevice.h. Referenced by __netif_rx_schedule(), alloc_divert_blk(), dev_get_by_flags(), dev_get_by_index(), dev_get_by_name(), dst_dev_event(), fib_check_nh(), inetdev_init(), ip_dev_find(), ip_route_input_mc(), ip_route_input_slow(), ip_route_output_slow(), ip_rt_redirect(), ipgre_fb_tunnel_init(), ipgre_tunnel_locate(), ipip_fb_tunnel_init(), ipip_tunnel_locate(), neigh_create(), net_dev_init(), netdev_set_master(), netif_rx(), nf_queue(), pneigh_enqueue(), register_netdevice(), and vif_add().

#define HAVE_ALLOC_NETDEV

Definition at line 50 of file netdevice.h.

#define HAVE_CHANGE_MTU

Definition at line 421 of file netdevice.h.

#define HAVE_FREE_NETDEV

Definition at line 52 of file netdevice.h.

#define HAVE_HEADER_CACHE

Definition at line 415 of file netdevice.h.

#define HAVE_MULTICAST

Definition at line 404 of file netdevice.h.

#define HAVE_NETDEV_POLL

Definition at line 395 of file netdevice.h.

#define HAVE_NETIF_MSG   1

Definition at line 697 of file netdevice.h.

#define HAVE_NETIF_QUEUE

Definition at line 530 of file netdevice.h.

#define HAVE_NETIF_RECEIVE_SKB   1

Definition at line 609 of file netdevice.h.

#define HAVE_NETIF_RX   1

Definition at line 607 of file netdevice.h.

#define HAVE_PRIVATE_IOCTL

Definition at line 409 of file netdevice.h.

#define HAVE_SET_CONFIG

Definition at line 412 of file netdevice.h.

#define HAVE_SET_MAC_ADDR

Definition at line 406 of file netdevice.h.

#define HAVE_TX_TIMEOUT

Definition at line 424 of file netdevice.h.

#define HH_DATA_ALIGN (  __len   )     (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))

Definition at line 205 of file netdevice.h. Referenced by ip_direct_send(), and ip_finish_output2().

#define HH_DATA_MOD   16

Definition at line 202 of file netdevice.h.

#define HH_DATA_OFF (  __len   )     (HH_DATA_MOD - ((__len) & (HH_DATA_MOD - 1)))

Definition at line 203 of file netdevice.h.

#define LL_MAX_HEADER   32

Definition at line 82 of file netdevice.h. Referenced by ipgre_tunnel_init(), ipgre_tunnel_init_gen(), and ipip_tunnel_init_gen().

#define MAX_ADDR_LEN   8

Definition at line 74 of file netdevice.h. Referenced by dev_ifsioc(), ip_mc_filter_add(), and ip_mc_filter_del().

#define MAX_HEADER   LL_MAX_HEADER

Definition at line 93 of file netdevice.h. Referenced by inet_rtm_getroute().

#define NET_RX_BAD   5

Definition at line 68 of file netdevice.h. Referenced by ip_forward().

#define NET_RX_CN_HIGH   4

Definition at line 67 of file netdevice.h. Referenced by get_sample_stats().

#define NET_RX_CN_LOW   2

Definition at line 65 of file netdevice.h. Referenced by get_sample_stats().

#define NET_RX_CN_MOD   3

Definition at line 66 of file netdevice.h. Referenced by get_sample_stats().

#define NET_RX_DROP   1

Definition at line 64 of file netdevice.h. Referenced by deliver_to_old_ones(), get_sample_stats(), handle_bridge(), ip_forward(), ip_rcv(), ip_rcv_finish(), netif_receive_skb(), netif_rx(), and raw_rcv_skb().

#define NET_RX_SUCCESS   0

Definition at line 63 of file netdevice.h. Referenced by get_sample_stats(), ip_do_nat(), ip_forward(), and raw_rcv_skb().

#define NET_XMIT_BYPASS   4

Definition at line 58 of file netdevice.h. Referenced by dev_queue_xmit().

#define NET_XMIT_CN   2

Definition at line 56 of file netdevice.h. Referenced by tcp_transmit_skb(), and tcp_v4_send_synack().

#define NET_XMIT_DROP   1

Definition at line 55 of file netdevice.h.

#define net_xmit_errno (  e   )     ((e) != NET_XMIT_CN ? -ENOBUFS : 0)

Definition at line 70 of file netdevice.h. Referenced by ip_build_xmit(), and ip_build_xmit_slow().

#define NET_XMIT_POLICED   3

Definition at line 57 of file netdevice.h.

#define NET_XMIT_SUCCESS   0

Definition at line 54 of file netdevice.h. Referenced by dev_queue_xmit().

#define NETDEV_BOOT_SETUP_MAX   8

Definition at line 234 of file netdevice.h. Referenced by netdev_boot_setup_add(), and netdev_boot_setup_check().

#define NETIF_F_DYNALLOC   16

Definition at line 377 of file netdevice.h. Referenced by dst_dev_event(), ipgre_tunnel_locate(), ipip_tunnel_locate(), netdev_finish_unregister(), and unregister_netdevice().

#define NETIF_F_FRAGLIST   64

Definition at line 379 of file netdevice.h. Referenced by dev_queue_xmit().

#define NETIF_F_HIGHDMA   32

Definition at line 378 of file netdevice.h.

#define NETIF_F_HW_CSUM   8

Definition at line 376 of file netdevice.h. Referenced by dev_queue_xmit(), and register_netdevice().

#define NETIF_F_HW_VLAN_FILTER   512

Definition at line 382 of file netdevice.h.

#define NETIF_F_HW_VLAN_RX   256

Definition at line 381 of file netdevice.h.

#define NETIF_F_HW_VLAN_TX   128

Definition at line 380 of file netdevice.h.

#define NETIF_F_IP_CSUM   2

Definition at line 374 of file netdevice.h. Referenced by dev_queue_xmit(), ethtool_op_get_tx_csum(), ethtool_op_set_tx_csum(), and register_netdevice().

#define NETIF_F_NO_CSUM   4

Definition at line 375 of file netdevice.h. Referenced by dev_queue_xmit(), and register_netdevice().

#define NETIF_F_SG   1

Definition at line 373 of file netdevice.h. Referenced by dev_queue_xmit(), ethtool_op_get_sg(), ethtool_op_set_sg(), register_netdevice(), select_size(), tcp_sendmsg(), and tcp_sendpage().

#define NETIF_F_VLAN_CHALLENGED   1024

Definition at line 383 of file netdevice.h.

#define netif_msg_drv (  p   )     ((p)->msg_enable & NETIF_MSG_DRV)

Definition at line 717 of file netdevice.h.

#define netif_msg_hw (  p   )     ((p)->msg_enable & NETIF_MSG_HW)

Definition at line 730 of file netdevice.h.

#define netif_msg_ifdown (  p   )     ((p)->msg_enable & NETIF_MSG_IFDOWN)

Definition at line 721 of file netdevice.h.

#define netif_msg_ifup (  p   )     ((p)->msg_enable & NETIF_MSG_IFUP)

Definition at line 722 of file netdevice.h.

#define netif_msg_intr (  p   )     ((p)->msg_enable & NETIF_MSG_INTR)

Definition at line 726 of file netdevice.h.

#define netif_msg_link (  p   )     ((p)->msg_enable & NETIF_MSG_LINK)

Definition at line 719 of file netdevice.h.

#define netif_msg_pktdata (  p   )     ((p)->msg_enable & NETIF_MSG_PKTDATA)

Definition at line 729 of file netdevice.h.

#define netif_msg_probe (  p   )     ((p)->msg_enable & NETIF_MSG_PROBE)

Definition at line 718 of file netdevice.h.

#define netif_msg_rx_err (  p   )     ((p)->msg_enable & NETIF_MSG_RX_ERR)

Definition at line 723 of file netdevice.h.

#define netif_msg_rx_status (  p   )     ((p)->msg_enable & NETIF_MSG_RX_STATUS)

Definition at line 728 of file netdevice.h.

#define netif_msg_timer (  p   )     ((p)->msg_enable & NETIF_MSG_TIMER)

Definition at line 720 of file netdevice.h.

#define netif_msg_tx_done (  p   )     ((p)->msg_enable & NETIF_MSG_TX_DONE)

Definition at line 727 of file netdevice.h.

#define netif_msg_tx_err (  p   )     ((p)->msg_enable & NETIF_MSG_TX_ERR)

Definition at line 724 of file netdevice.h.

#define netif_msg_tx_queued (  p   )     ((p)->msg_enable & NETIF_MSG_TX_QUEUED)

Definition at line 725 of file netdevice.h.

#define netif_msg_wol (  p   )     ((p)->msg_enable & NETIF_MSG_WOL)

Definition at line 731 of file netdevice.h.

#define SET_ETHTOOL_OPS (  netdev, ops   )     ( (netdev)->ethtool_ops = (ops) )

Definition at line 47 of file netdevice.h.

---

Typedef Documentation

typedef int gifconf_func_t(struct net_device *dev, char *bufptr, int len)

Definition at line 502 of file netdevice.h. Referenced by register_gifconf().

---

Enumeration Type Documentation

anonymous enum

Enumeration values: IF_PORT_UNKNOWN  IF_PORT_10BASE2  IF_PORT_10BASET  IF_PORT_AUI  IF_PORT_100BASET  IF_PORT_100BASETX  IF_PORT_100BASEFX  Definition at line 138 of file netdevice.h. { IF_PORT_UNKNOWN = 0, IF_PORT_10BASE2, IF_PORT_10BASET, IF_PORT_AUI, IF_PORT_100BASET, IF_PORT_100BASETX, IF_PORT_100BASEFX };

anonymous enum

Enumeration values: NETIF_MSG_DRV  NETIF_MSG_PROBE  NETIF_MSG_LINK  NETIF_MSG_TIMER  NETIF_MSG_IFDOWN  NETIF_MSG_IFUP  NETIF_MSG_RX_ERR  NETIF_MSG_TX_ERR  NETIF_MSG_TX_QUEUED  NETIF_MSG_INTR  NETIF_MSG_TX_DONE  NETIF_MSG_RX_STATUS  NETIF_MSG_PKTDATA  NETIF_MSG_HW  NETIF_MSG_WOL  Definition at line 699 of file netdevice.h. { NETIF_MSG_DRV = 0x0001, NETIF_MSG_PROBE = 0x0002, NETIF_MSG_LINK = 0x0004, NETIF_MSG_TIMER = 0x0008, NETIF_MSG_IFDOWN = 0x0010, NETIF_MSG_IFUP = 0x0020, NETIF_MSG_RX_ERR = 0x0040, NETIF_MSG_TX_ERR = 0x0080, NETIF_MSG_TX_QUEUED = 0x0100, NETIF_MSG_INTR = 0x0200, NETIF_MSG_TX_DONE = 0x0400, NETIF_MSG_RX_STATUS = 0x0800, NETIF_MSG_PKTDATA = 0x1000, NETIF_MSG_HW = 0x2000, NETIF_MSG_WOL = 0x4000, };

enum netdev_state_t

Enumeration values: __LINK_STATE_XOFF  __LINK_STATE_START  __LINK_STATE_PRESENT  __LINK_STATE_SCHED  __LINK_STATE_NOCARRIER  __LINK_STATE_RX_SCHED  Definition at line 215 of file netdevice.h. { __LINK_STATE_XOFF=0, __LINK_STATE_START, __LINK_STATE_PRESENT, __LINK_STATE_SCHED, __LINK_STATE_NOCARRIER, __LINK_STATE_RX_SCHED };

---

Function Documentation

struct net_device* __dev_get_by_flags (  unsigned short  flags, unsigned short  mask )

Definition at line 582 of file dev.c. References dev_base, and net_device::next. Referenced by dev_get_by_flags(). { struct net_device *dev; for (dev = dev_base; dev != NULL; dev = dev->next) { if (((dev->flags ^ if_flags) & mask) == 0) return dev; } return NULL; }

struct net_device* __dev_get_by_index (  int  ifindex  )

Definition at line 487 of file dev.c. References dev_base, and net_device::next. Referenced by dev_get_by_index(), dev_ifname(), dev_new_index(), fib_check_nh(), inet_rtm_getroute(), inet_rtm_newaddr(), inetdev_by_index(), ip_setsockopt(), ipgre_tunnel_init(), and ipip_tunnel_init(). { struct net_device *dev; for (dev = dev_base; dev != NULL; dev = dev->next) { if (dev->ifindex == ifindex) return dev; } return NULL; }

struct net_device* __dev_get_by_name (  const char *  name  )

Definition at line 412 of file dev.c. References dev_base, and net_device::next. Referenced by arp_ioctl(), bind_mcastif_addr(), dev_alloc_name(), dev_ethtool(), dev_get(), dev_get_by_name(), dev_ifsioc(), devinet_ioctl(), fib_convert_rtentry(), inet_rtm_newrule(), ipgre_tunnel_locate(), ipip_tunnel_locate(), ipmr_new_tunnel(), join_mcast_group(), set_mcast_if(), setup_inject(), and wireless_process_ioctl(). { struct net_device *dev; for (dev = dev_base; dev != NULL; dev = dev->next) { if (strncmp(dev->name, name, IFNAMSIZ) == 0) return dev; } return NULL; }

void __netdev_watchdog_up (  struct net_device *  dev  )

Referenced by netif_carrier_on(), and netif_device_attach().

void __netif_rx_complete (  struct net_device *  dev  )  [inline, static]

Definition at line 823 of file netdevice.h. References __LINK_STATE_RX_SCHED, net_device::poll_list, and net_device::state. { if (!test_bit(__LINK_STATE_RX_SCHED, &dev->state)) BUG(); list_del(&dev->poll_list); smp_mb__before_clear_bit(); clear_bit(__LINK_STATE_RX_SCHED, &dev->state); }

void __netif_rx_schedule (  struct net_device *  dev  )  [inline, static]

Definition at line 745 of file netdevice.h. References dev_hold, softnet_data::poll_list, net_device::poll_list, net_device::quota, softnet_data, and net_device::weight. Referenced by netif_rx_schedule(). { unsigned long flags; int cpu = smp_processor_id(); local_irq_save(flags); dev_hold(dev); list_add_tail(&dev->poll_list, &softnet_data[cpu].poll_list); if (dev->quota < 0) dev->quota += dev->weight; else dev->quota = dev->weight; __cpu_raise_softirq(cpu, NET_RX_SOFTIRQ); local_irq_restore(flags); }

void __netif_schedule (  struct net_device *  dev  )  [inline, static]

Definition at line 532 of file netdevice.h. References __LINK_STATE_SCHED, net_device::next_sched, softnet_data::output_queue, softnet_data, and net_device::state. Referenced by netif_schedule(), and netif_wake_queue(). { if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) { unsigned long flags; int cpu = smp_processor_id(); local_irq_save(flags); dev->next_sched = softnet_data[cpu].output_queue; softnet_data[cpu].output_queue = dev; cpu_raise_softirq(cpu, NET_TX_SOFTIRQ); local_irq_restore(flags); } }

struct net_device* alloc_netdev (  int  sizeof_priv, const char *  name, void(*  setup)(struct net_device *) )

void dev_add_pack (  struct packet_type *  pt  )

Definition at line 234 of file dev.c. References packet_type::data, packet_type::dev, netdev_nit, packet_type::next, ptype_all, ptype_base, and packet_type::type. Referenced by arp_init(), and ip_init(). { int hash; br_write_lock_bh(BR_NETPROTO_LOCK); #ifdef CONFIG_NET_FASTROUTE /* Hack to detect packet socket */ if ((pt->data) && ((int)(pt->data)!=1)) { netdev_fastroute_obstacles++; dev_clear_fastroute(pt->dev); } #endif if (pt->type == htons(ETH_P_ALL)) { netdev_nit++; pt->next=ptype_all; ptype_all=pt; } else { hash=ntohs(pt->type)&15; pt->next = ptype_base[hash]; ptype_base[hash] = pt; } br_write_unlock_bh(BR_NETPROTO_LOCK); }

struct net_device* dev_alloc (  const char *  name, int *  err )

Definition at line 649 of file dev.c. References dev_alloc_name(). { struct net_device *dev=kmalloc(sizeof(struct net_device), GFP_KERNEL); if (dev == NULL) { *err = -ENOBUFS; return NULL; } memset(dev, 0, sizeof(struct net_device)); *err = dev_alloc_name(dev, name); if (*err < 0) { kfree(dev); return NULL; } return dev; }

int dev_alloc_name (  struct net_device *  dev, const char *  name )

Definition at line 605 of file dev.c. References __dev_get_by_name(), and net_device::name. Referenced by dev_alloc(), and net_dev_init(). { int i; char buf[32]; char *p; /* * Verify the string as this thing may have come from * the user. There must be either one "%d" and no other "%" * characters, or no "%" characters at all. */ p = strchr(name, '%'); if (p && (p[1] != 'd' || strchr(p+2, '%'))) return -EINVAL; /* * If you need over 100 please also fix the algorithm... */ for (i = 0; i < 100; i++) { snprintf(buf,sizeof(buf),name,i); if (__dev_get_by_name(buf) == NULL) { strcpy(dev->name, buf); return i; } } return -ENFILE; /* Over 100 of the things .. bail out! */ }

int dev_change_flags (  struct net_device *  , unsigned  )

Definition at line 1987 of file dev.c. References dev_close(), dev_mc_upload(), dev_open(), dev_set_allmulti(), dev_set_promiscuity(), net_device::flags, net_device::gflags, netdev_chain, and rtmsg_ifinfo(). Referenced by dev_ifsioc(), devinet_ioctl(), ic_close_devs(), and ic_open_devs(). { int ret; int old_flags = dev->flags; /* * Set the flags on our device. */ dev->flags = (flags & (IFF_DEBUG|IFF_NOTRAILERS|IFF_NOARP|IFF_DYNAMIC| IFF_MULTICAST|IFF_PORTSEL|IFF_AUTOMEDIA)) | (dev->flags & (IFF_UP|IFF_VOLATILE|IFF_PROMISC|IFF_ALLMULTI)); /* * Load in the correct multicast list now the flags have changed. */ dev_mc_upload(dev); /* * Have we downed the interface. We handle IFF_UP ourselves * according to user attempts to set it, rather than blindly * setting it. */ ret = 0; if ((old_flags^flags)&IFF_UP) /* Bit is different ? */ { ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev); if (ret == 0) dev_mc_upload(dev); } if (dev->flags&IFF_UP && ((old_flags^dev->flags)&~(IFF_UP|IFF_PROMISC|IFF_ALLMULTI|IFF_VOLATILE))) notifier_call_chain(&netdev_chain, NETDEV_CHANGE, dev); if ((flags^dev->gflags)&IFF_PROMISC) { int inc = (flags&IFF_PROMISC) ? +1 : -1; dev->gflags ^= IFF_PROMISC; dev_set_promiscuity(dev, inc); } /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI is important. Some (broken) drivers set IFF_PROMISC, when IFF_ALLMULTI is requested not asking us and not reporting. */ if ((flags^dev->gflags)&IFF_ALLMULTI) { int inc = (flags&IFF_ALLMULTI) ? +1 : -1; dev->gflags ^= IFF_ALLMULTI; dev_set_allmulti(dev, inc); } if (old_flags^dev->flags) rtmsg_ifinfo(RTM_NEWLINK, dev, old_flags^dev->flags); return ret; }

int dev_close (  struct net_device *  dev  )

Definition at line 832 of file dev.c. References __LINK_STATE_RX_SCHED, __LINK_STATE_START, dev_deactivate(), net_device::flags, netdev_chain, net_device::owner, net_device::state, and net_device::stop. Referenced by dev_change_flags(), and unregister_netdevice(). { if (!(dev->flags&IFF_UP)) return 0; /* * Tell people we are going down, so that they can * prepare to death, when device is still operating. */ notifier_call_chain(&netdev_chain, NETDEV_GOING_DOWN, dev); dev_deactivate(dev); clear_bit(__LINK_STATE_START, &dev->state); /* Synchronize to scheduled poll. We cannot touch poll list, * it can be even on different cpu. So just clear netif_running(), * and wait when poll really will happen. Actually, the best place * for this is inside dev->stop() after device stopped its irq * engine, but this requires more changes in devices. */ smp_mb__after_clear_bit(); /* Commit netif_running(). */ while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) { /* No hurry. */ current->state = TASK_INTERRUPTIBLE; schedule_timeout(1); } /* * Call the device specific close. This cannot fail. * Only if device is UP * * We allow it to be called even after a DETACH hot-plug * event. */ if (dev->stop) dev->stop(dev); /* * Device is now down. */ dev->flags &= ~IFF_UP; #ifdef CONFIG_NET_FASTROUTE dev_clear_fastroute(dev); #endif /* * Tell people we are down */ notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev); /* * Drop the module refcount */ if (dev->owner) __MOD_DEC_USE_COUNT(dev->owner); return(0); }

int dev_ethtool (  struct ifreq *   )

Definition at line 607 of file ethtool.c. References __dev_get_by_name(), ethtool_get_coalesce(), ethtool_get_drvinfo(), ethtool_get_eeprom(), ethtool_get_link(), ethtool_get_msglevel(), ethtool_get_pauseparam(), ethtool_get_regs(), ethtool_get_ringparam(), ethtool_get_rx_csum(), ethtool_get_settings(), ethtool_get_sg(), ethtool_get_stats(), ethtool_get_strings(), ethtool_get_tx_csum(), ethtool_get_wol(), ethtool_nway_reset(), ethtool_phys_id(), ethtool_self_test(), ethtool_set_coalesce(), ethtool_set_eeprom(), ethtool_set_msglevel(), ethtool_set_pauseparam(), ethtool_set_ringparam(), ethtool_set_rx_csum(), ethtool_set_settings(), ethtool_set_sg(), ethtool_set_tx_csum(), ethtool_set_wol(), and netif_device_present(). Referenced by dev_ioctl(). { struct net_device *dev = __dev_get_by_name(ifr->ifr_name); void *useraddr = (void *) ifr->ifr_data; u32 ethcmd; /* * XXX: This can be pushed down into the ethtool_* handlers that * need it. Keep existing behaviour for the moment. */ if (!capable(CAP_NET_ADMIN)) return -EPERM; if (!dev || !netif_device_present(dev)) return -ENODEV; if (!dev->ethtool_ops) goto ioctl; if (copy_from_user(&ethcmd, useraddr, sizeof (ethcmd))) return -EFAULT; switch (ethcmd) { case ETHTOOL_GSET: return ethtool_get_settings(dev, useraddr); case ETHTOOL_SSET: return ethtool_set_settings(dev, useraddr); case ETHTOOL_GDRVINFO: return ethtool_get_drvinfo(dev, useraddr); case ETHTOOL_GREGS: return ethtool_get_regs(dev, useraddr); case ETHTOOL_GWOL: return ethtool_get_wol(dev, useraddr); case ETHTOOL_SWOL: return ethtool_set_wol(dev, useraddr); case ETHTOOL_GMSGLVL: return ethtool_get_msglevel(dev, useraddr); case ETHTOOL_SMSGLVL: return ethtool_set_msglevel(dev, useraddr); case ETHTOOL_NWAY_RST: return ethtool_nway_reset(dev); case ETHTOOL_GLINK: return ethtool_get_link(dev, useraddr); case ETHTOOL_GEEPROM: return ethtool_get_eeprom(dev, useraddr); case ETHTOOL_SEEPROM: return ethtool_set_eeprom(dev, useraddr); case ETHTOOL_GCOALESCE: return ethtool_get_coalesce(dev, useraddr); case ETHTOOL_SCOALESCE: return ethtool_set_coalesce(dev, useraddr); case ETHTOOL_GRINGPARAM: return ethtool_get_ringparam(dev, useraddr); case ETHTOOL_SRINGPARAM: return ethtool_set_ringparam(dev, useraddr); case ETHTOOL_GPAUSEPARAM: return ethtool_get_pauseparam(dev, useraddr); case ETHTOOL_SPAUSEPARAM: return ethtool_set_pauseparam(dev, useraddr); case ETHTOOL_GRXCSUM: return ethtool_get_rx_csum(dev, useraddr); case ETHTOOL_SRXCSUM: return ethtool_set_rx_csum(dev, useraddr); case ETHTOOL_GTXCSUM: return ethtool_get_tx_csum(dev, useraddr); case ETHTOOL_STXCSUM: return ethtool_set_tx_csum(dev, useraddr); case ETHTOOL_GSG: return ethtool_get_sg(dev, useraddr); case ETHTOOL_SSG: return ethtool_set_sg(dev, useraddr); case ETHTOOL_TEST: return ethtool_self_test(dev, useraddr); case ETHTOOL_GSTRINGS: return ethtool_get_strings(dev, useraddr); case ETHTOOL_PHYS_ID: return ethtool_phys_id(dev, useraddr); case ETHTOOL_GSTATS: return ethtool_get_stats(dev, useraddr); default: return -EOPNOTSUPP; } ioctl: if (dev->do_ioctl) return dev->do_ioctl(dev, ifr, SIOCETHTOOL); return -EOPNOTSUPP; }

int dev_get (  const char *  name  )

Definition at line 466 of file dev.c. References __dev_get_by_name(), and dev_base_lock. { struct net_device *dev; read_lock(&dev_base_lock); dev = __dev_get_by_name(name); read_unlock(&dev_base_lock); return dev != NULL; }

struct net_device* dev_get_by_flags (  unsigned short  flags, unsigned short  mask )

Definition at line 560 of file dev.c. References __dev_get_by_flags(), dev_base_lock, and dev_hold. { struct net_device *dev; read_lock(&dev_base_lock); dev = __dev_get_by_flags(if_flags, mask); if (dev) dev_hold(dev); read_unlock(&dev_base_lock); return dev; }

struct net_device* dev_get_by_index (  int  ifindex  )

Definition at line 509 of file dev.c. References __dev_get_by_index(), dev_base_lock, and dev_hold. Referenced by fib_create_info(), ip_expire(), ip_route_output_slow(), neigh_add(), and neigh_delete(). { struct net_device *dev; read_lock(&dev_base_lock); dev = __dev_get_by_index(ifindex); if (dev) dev_hold(dev); read_unlock(&dev_base_lock); return dev; }

struct net_device* dev_get_by_name (  const char *  name  )

Definition at line 434 of file dev.c. References __dev_get_by_name(), dev_base_lock, and dev_hold. Referenced by append_to_chain(), check_args(), insert_in_chain(), ip_fw_ctl(), and sock_setsockopt(). { struct net_device *dev; read_lock(&dev_base_lock); dev = __dev_get_by_name(name); if (dev) dev_hold(dev); read_unlock(&dev_base_lock); return dev; }

struct net_device* dev_getbyhwaddr (  unsigned short  type, char *  hwaddr )

Definition at line 535 of file dev.c. References dev_base, and net_device::next. Referenced by arp_req_set(). { struct net_device *dev; ASSERT_RTNL(); for (dev = dev_base; dev != NULL; dev = dev->next) { if (dev->type == type && memcmp(dev->dev_addr, ha, dev->addr_len) == 0) return dev; } return NULL; }

void dev_init (  void   )

void dev_init_buffers (  struct net_device *  dev  )  [inline, static]

Definition at line 631 of file netdevice.h. { /* WILL BE REMOVED IN 2.5.0 */ }

int dev_ioctl (  unsigned int  cmd, void *  )

Definition at line 2234 of file dev.c. References dev_base_lock, dev_ethtool(), dev_ifconf(), dev_ifname(), dev_ifsioc(), dev_load(), rtnl_lock(), rtnl_unlock(), and wireless_process_ioctl(). Referenced by inet_ioctl(). { struct ifreq ifr; int ret; char *colon; /* One special case: SIOCGIFCONF takes ifconf argument and requires shared lock, because it sleeps writing to user space. */ if (cmd == SIOCGIFCONF) { rtnl_shlock(); ret = dev_ifconf((char *) arg); rtnl_shunlock(); return ret; } if (cmd == SIOCGIFNAME) { return dev_ifname((struct ifreq *)arg); } if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) return -EFAULT; ifr.ifr_name[IFNAMSIZ-1] = 0; colon = strchr(ifr.ifr_name, ':'); if (colon) *colon = 0; /* * See which interface the caller is talking about. */ switch(cmd) { /* * These ioctl calls: * - can be done by all. * - atomic and do not require locking. * - return a value */ case SIOCGIFFLAGS: case SIOCGIFMETRIC: case SIOCGIFMTU: case SIOCGIFHWADDR: case SIOCGIFSLAVE: case SIOCGIFMAP: case SIOCGIFINDEX: case SIOCGIFTXQLEN: dev_load(ifr.ifr_name); read_lock(&dev_base_lock); ret = dev_ifsioc(&ifr, cmd); read_unlock(&dev_base_lock); if (!ret) { if (colon) *colon = ':'; if (copy_to_user(arg, &ifr, sizeof(struct ifreq))) return -EFAULT; } return ret; case SIOCETHTOOL: dev_load(ifr.ifr_name); rtnl_lock(); ret = dev_ethtool(&ifr); rtnl_unlock(); if (!ret) { if (colon) *colon = ':'; if (copy_to_user(arg, &ifr, sizeof(struct ifreq))) ret = -EFAULT; } return ret; /* * These ioctl calls: * - require superuser power. * - require strict serialization. * - return a value */ case SIOCGMIIPHY: case SIOCGMIIREG: if (!capable(CAP_NET_ADMIN)) return -EPERM; dev_load(ifr.ifr_name); dev_probe_lock(); rtnl_lock(); ret = dev_ifsioc(&ifr, cmd); rtnl_unlock(); dev_probe_unlock(); if (!ret) { if (colon) *colon = ':'; if (copy_to_user(arg, &ifr, sizeof(struct ifreq))) return -EFAULT; } return ret; /* * These ioctl calls: * - require superuser power. * - require strict serialization. * - do not return a value */ case SIOCSIFFLAGS: case SIOCSIFMETRIC: case SIOCSIFMTU: case SIOCSIFMAP: case SIOCSIFHWADDR: case SIOCSIFSLAVE: case SIOCADDMULTI: case SIOCDELMULTI: case SIOCSIFHWBROADCAST: case SIOCSIFTXQLEN: case SIOCSIFNAME: case SIOCSMIIREG: case SIOCBONDENSLAVE: case SIOCBONDRELEASE: case SIOCBONDSETHWADDR: case SIOCBONDSLAVEINFOQUERY: case SIOCBONDINFOQUERY: case SIOCBONDCHANGEACTIVE: if (!capable(CAP_NET_ADMIN)) return -EPERM; dev_load(ifr.ifr_name); dev_probe_lock(); rtnl_lock(); ret = dev_ifsioc(&ifr, cmd); rtnl_unlock(); dev_probe_unlock(); return ret; case SIOCGIFMEM: /* Get the per device memory space. We can add this but currently do not support it */ case SIOCSIFMEM: /* Set the per device memory buffer space. Not applicable in our case */ case SIOCSIFLINK: return -EINVAL; /* * Unknown or private ioctl. */ default: if (cmd == SIOCWANDEV || (cmd >= SIOCDEVPRIVATE && cmd <= SIOCDEVPRIVATE + 15)) { dev_load(ifr.ifr_name); dev_probe_lock(); rtnl_lock(); ret = dev_ifsioc(&ifr, cmd); rtnl_unlock(); dev_probe_unlock(); if (!ret && copy_to_user(arg, &ifr, sizeof(struct ifreq))) return -EFAULT; return ret; } #ifdef WIRELESS_EXT /* Take care of Wireless Extensions */ if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { /* If command is `set a parameter', or * `get the encoding parameters', check if * the user has the right to do it */ if (IW_IS_SET(cmd) || (cmd == SIOCGIWENCODE)) { if(!capable(CAP_NET_ADMIN)) return -EPERM; } dev_load(ifr.ifr_name); rtnl_lock(); /* Follow me in net/core/wireless.c */ ret = wireless_process_ioctl(&ifr, cmd); rtnl_unlock(); if (!ret && IW_IS_GET(cmd) && copy_to_user(arg, &ifr, sizeof(struct ifreq))) return -EFAULT; return ret; } #endif /* WIRELESS_EXT */ return -EINVAL; } }

void dev_kfree_skb_any (  struct sk_buff *  skb  )  [inline, static]

Definition at line 599 of file netdevice.h. References dev_kfree_skb, and dev_kfree_skb_irq(). { if (in_irq()) dev_kfree_skb_irq(skb); else dev_kfree_skb(skb); }

void dev_kfree_skb_irq (  struct sk_buff *  skb  )  [inline, static]

Definition at line 582 of file netdevice.h. References softnet_data::completion_queue, sk_buff::next, softnet_data, and sk_buff::users. Referenced by dev_kfree_skb_any(). { if (atomic_dec_and_test(&skb->users)) { int cpu =smp_processor_id(); unsigned long flags; local_irq_save(flags); skb->next = softnet_data[cpu].completion_queue; softnet_data[cpu].completion_queue = skb; cpu_raise_softirq(cpu, NET_TX_SOFTIRQ); local_irq_restore(flags); } }

void dev_load (  const char *  name  )  [inline]

Definition at line 702 of file dev.c. Referenced by dev_ioctl(), and devinet_ioctl(). {;}

int dev_mc_add (  struct net_device *  dev, void *  addr, int  alen, int  newonly )

Definition at line 154 of file dev_mcast.c. References __dev_mc_upload(), dev_mc_list::dmi_users, net_device::mc_count, net_device::mc_list, dev_mc_list::next, and net_device::xmit_lock. Referenced by dev_ifsioc(), and ip_mc_filter_add(). { int err = 0; struct dev_mc_list *dmi, *dmi1; dmi1 = (struct dev_mc_list *)kmalloc(sizeof(*dmi), GFP_ATOMIC); spin_lock_bh(&dev->xmit_lock); for (dmi = dev->mc_list; dmi != NULL; dmi = dmi->next) { if (memcmp(dmi->dmi_addr, addr, dmi->dmi_addrlen) == 0 && dmi->dmi_addrlen == alen) { if (glbl) { int old_glbl = dmi->dmi_gusers; dmi->dmi_gusers = 1; if (old_glbl) goto done; } dmi->dmi_users++; goto done; } } if ((dmi = dmi1) == NULL) { spin_unlock_bh(&dev->xmit_lock); return -ENOMEM; } memcpy(dmi->dmi_addr, addr, alen); dmi->dmi_addrlen = alen; dmi->next = dev->mc_list; dmi->dmi_users = 1; dmi->dmi_gusers = glbl ? 1 : 0; dev->mc_list = dmi; dev->mc_count++; __dev_mc_upload(dev); spin_unlock_bh(&dev->xmit_lock); return 0; done: spin_unlock_bh(&dev->xmit_lock); if (dmi1) kfree(dmi1); return err; }

int dev_mc_delete (  struct net_device *  dev, void *  addr, int  alen, int  all )

Definition at line 103 of file dev_mcast.c. References __dev_mc_upload(), net_device::mc_count, net_device::mc_list, dev_mc_list::next, and net_device::xmit_lock. Referenced by dev_ifsioc(), and ip_mc_filter_del(). { int err = 0; struct dev_mc_list *dmi, **dmip; spin_lock_bh(&dev->xmit_lock); for (dmip = &dev->mc_list; (dmi = *dmip) != NULL; dmip = &dmi->next) { /* * Find the entry we want to delete. The device could * have variable length entries so check these too. */ if (memcmp(dmi->dmi_addr, addr, dmi->dmi_addrlen) == 0 && alen == dmi->dmi_addrlen) { if (glbl) { int old_glbl = dmi->dmi_gusers; dmi->dmi_gusers = 0; if (old_glbl == 0) break; } if (--dmi->dmi_users) goto done; /* * Last user. So delete the entry. */ *dmip = dmi->next; dev->mc_count--; kfree(dmi); /* * We have altered the list, so the card * loaded filter is now wrong. Fix it */ __dev_mc_upload(dev); spin_unlock_bh(&dev->xmit_lock); return 0; } } err = -ENOENT; done: spin_unlock_bh(&dev->xmit_lock); return err; }

void dev_mc_discard (  struct net_device *  dev  )

Definition at line 204 of file dev_mcast.c. References net_device::mc_count, net_device::mc_list, dev_mc_list::next, and net_device::xmit_lock. Referenced by unregister_netdevice(). { spin_lock_bh(&dev->xmit_lock); while (dev->mc_list != NULL) { struct dev_mc_list *tmp = dev->mc_list; dev->mc_list = tmp->next; if (tmp->dmi_users > tmp->dmi_gusers) printk("dev_mc_discard: multicast leakage! dmi_users=%d\n", tmp->dmi_users); kfree(tmp); } dev->mc_count = 0; spin_unlock_bh(&dev->xmit_lock); }

void dev_mc_upload (  struct net_device *  dev  )

Definition at line 92 of file dev_mcast.c. References __dev_mc_upload(), and net_device::xmit_lock. Referenced by dev_change_flags(), dev_open(), dev_set_allmulti(), and dev_set_promiscuity(). { spin_lock_bh(&dev->xmit_lock); __dev_mc_upload(dev); spin_unlock_bh(&dev->xmit_lock); }

void dev_mcast_init (  void   )

Definition at line 269 of file dev_mcast.c. Referenced by net_dev_init(). { #ifdef CONFIG_PROC_FS create_proc_read_entry("net/dev_mcast", 0, 0, dev_mc_read_proc, NULL); #endif }

int dev_new_index (  void   )

Definition at line 2431 of file dev.c. References __dev_get_by_index(). Referenced by net_dev_init(), and register_netdevice(). { static int ifindex; for (;;) { if (++ifindex <= 0) ifindex=1; if (__dev_get_by_index(ifindex) == NULL) return ifindex; } }

int dev_open (  struct net_device *  dev  )

Definition at line 726 of file dev.c. References __LINK_STATE_START, dev_activate(), dev_mc_upload(), net_device::flags, netdev_chain, netif_device_present(), net_device::open, net_device::owner, and net_device::state. Referenced by dev_change_flags(), and ipmr_new_tunnel(). { int ret = 0; /* * Is it already up? */ if (dev->flags&IFF_UP) return 0; /* * Is it even present? */ if (!netif_device_present(dev)) return -ENODEV; /* * Call device private open method */ if (try_inc_mod_count(dev->owner)) { set_bit(__LINK_STATE_START, &dev->state); if (dev->open) { ret = dev->open(dev); if (ret != 0) { clear_bit(__LINK_STATE_START, &dev->state); if (dev->owner) __MOD_DEC_USE_COUNT(dev->owner); } } } else { ret = -ENODEV; } /* * If it went open OK then: */ if (ret == 0) { /* * Set the flags. */ dev->flags |= IFF_UP; /* * Initialize multicasting status */ dev_mc_upload(dev); /* * Wakeup transmit queue engine */ dev_activate(dev); /* * ... and announce new interface. */ notifier_call_chain(&netdev_chain, NETDEV_UP, dev); } return(ret); }

void dev_put (  struct net_device *  dev  )  [inline, static]

Definition at line 638 of file netdevice.h. References netdev_finish_unregister(), and net_device::refcnt. Referenced by check_args(), dst_destroy(), dst_dev_event(), free_divert_blk(), free_fib_info(), in_dev_finish_destroy(), inject(), ip_expire(), ip_route_output_slow(), ip_setsockopt(), ipgre_tunnel_uninit(), ipip_tunnel_uninit(), neigh_add(), neigh_delete(), neigh_destroy(), neigh_proxy_process(), net_dev_init(), net_rx_action(), netdev_set_master(), nf_queue(), nf_reinject(), pneigh_queue_purge(), process_backlog(), sock_setsockopt(), unregister_netdevice(), and vif_delete(). { if (atomic_dec_and_test(&dev->refcnt)) netdev_finish_unregister(dev); }

int dev_queue_xmit (  struct sk_buff *  skb  )

Definition at line 1035 of file dev.c. References CHECKSUM_HW, sk_buff::dev, dev_queue_xmit_nit(), illegal_highdma, sk_buff::ip_summed, kfree_skb(), net_ratelimit(), NET_XMIT_BYPASS, NET_XMIT_SUCCESS, netdev_nit, NETIF_F_FRAGLIST, NETIF_F_HW_CSUM, NETIF_F_IP_CSUM, NETIF_F_NO_CSUM, NETIF_F_SG, netif_queue_stopped(), sk_buff::protocol, qdisc_run(), skb_checksum_help(), skb_linearize(), and skb_shinfo. Referenced by arp_send(), dn_rt_send(), neigh_compat_output(), net_dev_init(), netif_receive_skb(), and rt_cache_get_info(). { struct net_device *dev = skb->dev; struct Qdisc *q; if (skb_shinfo(skb)->frag_list && !(dev->features&NETIF_F_FRAGLIST) && skb_linearize(skb, GFP_ATOMIC) != 0) { kfree_skb(skb); return -ENOMEM; } /* Fragmented skb is linearized if device does not support SG, * or if at least one of fragments is in highmem and device * does not support DMA from it. */ if (skb_shinfo(skb)->nr_frags && (!(dev->features&NETIF_F_SG) || illegal_highdma(dev, skb)) && skb_linearize(skb, GFP_ATOMIC) != 0) { kfree_skb(skb); return -ENOMEM; } /* If packet is not checksummed and device does not support * checksumming for this protocol, complete checksumming here. */ if (skb->ip_summed == CHECKSUM_HW && (!(dev->features&(NETIF_F_HW_CSUM|NETIF_F_NO_CSUM)) && (!(dev->features&NETIF_F_IP_CSUM) || skb->protocol != htons(ETH_P_IP)))) { if ((skb = skb_checksum_help(skb)) == NULL) return -ENOMEM; } /* Grab device queue */ spin_lock_bh(&dev->queue_lock); q = dev->qdisc; if (q->enqueue) { int ret = q->enqueue(skb, q); qdisc_run(dev); spin_unlock_bh(&dev->queue_lock); return ret == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : ret; } /* The device has no queue. Common case for software devices: loopback, all the sorts of tunnels... Really, it is unlikely that xmit_lock protection is necessary here. (f.e. loopback and IP tunnels are clean ignoring statistics counters.) However, it is possible, that they rely on protection made by us here. Check this and shot the lock. It is not prone from deadlocks. Either shot noqueue qdisc, it is even simpler 8) */ if (dev->flags&IFF_UP) { int cpu = smp_processor_id(); if (dev->xmit_lock_owner != cpu) { spin_unlock(&dev->queue_lock); spin_lock(&dev->xmit_lock); dev->xmit_lock_owner = cpu; if (!netif_queue_stopped(dev)) { if (netdev_nit) dev_queue_xmit_nit(skb,dev); if (dev->hard_start_xmit(skb, dev) == 0) { dev->xmit_lock_owner = -1; spin_unlock_bh(&dev->xmit_lock); return 0; } } dev->xmit_lock_owner = -1; spin_unlock_bh(&dev->xmit_lock); if (net_ratelimit()) printk(KERN_CRIT "Virtual device %s asks to queue packet!\n", dev->name); kfree_skb(skb); return -ENETDOWN; } else { /* Recursion is detected! It is possible, unfortunately */ if (net_ratelimit()) printk(KERN_CRIT "Dead loop on virtual device %s, fix it urgently!\n", dev->name); } } spin_unlock_bh(&dev->queue_lock); kfree_skb(skb); return -ENETDOWN; }

void dev_queue_xmit_nit (  struct sk_buff *  skb, struct net_device *  dev )

Definition at line 935 of file dev.c. References sk_buff::dev, net_device::name, net_ratelimit(), packet_type::next, ptype_all, sk_buff::sk, skb_clone(), and sk_buff::stamp. Referenced by dev_queue_xmit(). { struct packet_type *ptype; do_gettimeofday(&skb->stamp); br_read_lock(BR_NETPROTO_LOCK); for (ptype = ptype_all; ptype!=NULL; ptype = ptype->next) { /* Never send packets back to the socket * they originated from - MvS (miquels@drinkel.ow.org) */ if ((ptype->dev == dev || !ptype->dev) && ((struct sock *)ptype->data != skb->sk)) { struct sk_buff *skb2; if ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL) break; /* skb->nh should be correctly set by sender, so that the second statement is just protection against buggy protocols. */ skb2->mac.raw = skb2->data; if (skb2->nh.raw < skb2->data || skb2->nh.raw > skb2->tail) { if (net_ratelimit()) printk(KERN_CRIT "protocol %04x is buggy, dev %s\n", skb2->protocol, dev->name); skb2->nh.raw = skb2->data; } skb2->h.raw = skb2->nh.raw; skb2->pkt_type = PACKET_OUTGOING; ptype->func(skb2, skb->dev, ptype); } } br_read_unlock(BR_NETPROTO_LOCK); }

void dev_remove_pack (  struct packet_type *  pt  )

Definition at line 270 of file dev.c. References packet_type::data, netdev_nit, packet_type::next, ptype_all, ptype_base, and packet_type::type. { struct packet_type **pt1; br_write_lock_bh(BR_NETPROTO_LOCK); if (pt->type == htons(ETH_P_ALL)) { netdev_nit--; pt1=&ptype_all; } else { pt1=&ptype_base[ntohs(pt->type)&15]; } for (; (*pt1) != NULL; pt1 = &((*pt1)->next)) { if (pt == (*pt1)) { *pt1 = pt->next; #ifdef CONFIG_NET_FASTROUTE if (pt->data) netdev_fastroute_obstacles--; #endif br_write_unlock_bh(BR_NETPROTO_LOCK); return; } } br_write_unlock_bh(BR_NETPROTO_LOCK); printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt); }

int dev_restart (  struct net_device *  dev  )

void dev_set_allmulti (  struct net_device *  dev, int  inc )

Definition at line 1976 of file dev.c. References net_device::allmulti, dev_mc_upload(), and net_device::flags. Referenced by dev_change_flags(), vif_add(), and vif_delete(). { unsigned short old_flags = dev->flags; dev->flags |= IFF_ALLMULTI; if ((dev->allmulti += inc) == 0) dev->flags &= ~IFF_ALLMULTI; if (dev->flags^old_flags) dev_mc_upload(dev); }

void dev_set_promiscuity (  struct net_device *  dev, int  inc )

Definition at line 1943 of file dev.c. References dev_mc_upload(), net_device::flags, net_device::name, and net_device::promiscuity. Referenced by dev_change_flags(). { unsigned short old_flags = dev->flags; dev->flags |= IFF_PROMISC; if ((dev->promiscuity += inc) == 0) dev->flags &= ~IFF_PROMISC; if (dev->flags^old_flags) { #ifdef CONFIG_NET_FASTROUTE if (dev->flags&IFF_PROMISC) { netdev_fastroute_obstacles++; dev_clear_fastroute(dev); } else netdev_fastroute_obstacles--; #endif dev_mc_upload(dev); printk(KERN_INFO "device %s %s promiscuous mode\n", dev->name, (dev->flags&IFF_PROMISC) ? "entered" : "left"); } }

void ether_setup (  struct net_device *  dev  )

void fc_freedev (  struct net_device *  dev  )

void fc_setup (  struct net_device *  dev  )

void fddi_setup (  struct net_device *  dev  )

void free_netdev (  struct net_device *  dev  )  [inline, static]

Definition at line 875 of file netdevice.h. { kfree(dev); }

int netdev_boot_setup_add (  char *  name, struct ifmap *  map )

Definition at line 316 of file dev.c. References dev_boot_setup, and NETDEV_BOOT_SETUP_MAX. Referenced by netdev_boot_setup(). { struct netdev_boot_setup *s; int i; s = dev_boot_setup; for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) { if (s[i].name[0] == '\0' || s[i].name[0] == ' ') { memset(s[i].name, 0, sizeof(s[i].name)); strcpy(s[i].name, name); memcpy(&s[i].map, map, sizeof(s[i].map)); break; } } if (i >= NETDEV_BOOT_SETUP_MAX) return 0; return 1; }

int netdev_boot_setup_check (  struct net_device *  dev  )

Definition at line 346 of file dev.c. References net_device::base_addr, dev_boot_setup, net_device::irq, net_device::mem_end, net_device::mem_start, net_device::name, and NETDEV_BOOT_SETUP_MAX. Referenced by net_dev_init(). { struct netdev_boot_setup *s; int i; s = dev_boot_setup; for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) { if (s[i].name[0] != '\0' && s[i].name[0] != ' ' && !strncmp(dev->name, s[i].name, strlen(s[i].name))) { dev->irq = s[i].map.irq; dev->base_addr = s[i].map.base_addr; dev->mem_start = s[i].map.mem_start; dev->mem_end = s[i].map.mem_end; return 1; } } return 0; }

int netdev_finish_unregister (  struct net_device *  dev  )

Definition at line 2560 of file dev.c. References net_device::deadbeaf, net_device::destructor, net_device::dn_ptr, net_device::features, net_device::ip6_ptr, net_device::ip_ptr, net_device::name, and NETIF_F_DYNALLOC. Referenced by dev_put(). { BUG_TRAP(dev->ip_ptr==NULL); BUG_TRAP(dev->ip6_ptr==NULL); BUG_TRAP(dev->dn_ptr==NULL); if (!dev->deadbeaf) { printk(KERN_ERR "Freeing alive device %p, %s\n", dev, dev->name); return 0; } #ifdef NET_REFCNT_DEBUG printk(KERN_DEBUG "netdev_finish_unregister: %s%s.\n", dev->name, (dev->features & NETIF_F_DYNALLOC)?"":", old style"); #endif if (dev->destructor) dev->destructor(dev); if (dev->features & NETIF_F_DYNALLOC) kfree(dev); return 0; }

int netdev_register_fc (  struct net_device *  dev, void(*  stimul)(struct net_device *dev) )

int netdev_set_master (  struct net_device *  dev, struct net_device *  master )

Definition at line 1904 of file dev.c. References dev_hold, dev_put(), net_device::flags, net_device::master, and rtmsg_ifinfo(). { struct net_device *old = slave->master; ASSERT_RTNL(); if (master) { if (old) return -EBUSY; dev_hold(master); } br_write_lock_bh(BR_NETPROTO_LOCK); slave->master = master; br_write_unlock_bh(BR_NETPROTO_LOCK); if (old) dev_put(old); if (master) slave->flags |= IFF_SLAVE; else slave->flags &= ~IFF_SLAVE; rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE); return 0; }

void netdev_state_change (  struct net_device *  dev  )

Definition at line 674 of file dev.c. References net_device::flags, netdev_chain, and rtmsg_ifinfo(). Referenced by ipgre_tunnel_ioctl(), and ipip_tunnel_ioctl(). { if (dev->flags&IFF_UP) { notifier_call_chain(&netdev_chain, NETDEV_CHANGE, dev); rtmsg_ifinfo(RTM_NEWLINK, dev, 0); } }

void netdev_unregister_fc (  int  bit  )

void netif_carrier_off (  struct net_device *  dev  )  [inline, static]

Definition at line 666 of file netdevice.h. References __LINK_STATE_NOCARRIER, and net_device::state. { set_bit(__LINK_STATE_NOCARRIER, &dev->state); }

int netif_carrier_ok (  struct net_device *  dev  )  [inline, static]

Definition at line 652 of file netdevice.h. References __LINK_STATE_NOCARRIER, and net_device::state. Referenced by dev_ifsioc(), ethtool_op_get_link(), and rtnetlink_fill_ifinfo(). { return !test_bit(__LINK_STATE_NOCARRIER, &dev->state); }

void netif_carrier_on (  struct net_device *  dev  )  [inline, static]

Definition at line 659 of file netdevice.h. References __LINK_STATE_NOCARRIER, __netdev_watchdog_up(), netif_running(), and net_device::state. { clear_bit(__LINK_STATE_NOCARRIER, &dev->state); if (netif_running(dev)) __netdev_watchdog_up(dev); }

void netif_device_attach (  struct net_device *  dev  )  [inline, static]

Definition at line 685 of file netdevice.h. References __LINK_STATE_PRESENT, __netdev_watchdog_up(), netif_running(), netif_wake_queue(), and net_device::state. { if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) && netif_running(dev)) { netif_wake_queue(dev); __netdev_watchdog_up(dev); } }

void netif_device_detach (  struct net_device *  dev  )  [inline, static]

Definition at line 677 of file netdevice.h. References __LINK_STATE_PRESENT, netif_running(), netif_stop_queue(), and net_device::state. { if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) && netif_running(dev)) { netif_stop_queue(dev); } }

int netif_device_present (  struct net_device *  dev  )  [inline, static]

Definition at line 672 of file netdevice.h. References __LINK_STATE_PRESENT, and net_device::state. Referenced by __dev_mc_upload(), dev_ethtool(), dev_ifsioc(), dev_open(), and wireless_process_ioctl(). { return test_bit(__LINK_STATE_PRESENT, &dev->state); }

void netif_poll_disable (  struct net_device *  dev  )  [inline, static]

Definition at line 806 of file netdevice.h. References __LINK_STATE_RX_SCHED, and net_device::state. { while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state)) { /* No hurry. */ current->state = TASK_INTERRUPTIBLE; schedule_timeout(1); } }

void netif_poll_enable (  struct net_device *  dev  )  [inline, static]

Definition at line 815 of file netdevice.h. References __LINK_STATE_RX_SCHED, and net_device::state. Referenced by process_backlog(). { clear_bit(__LINK_STATE_RX_SCHED, &dev->state); }

int netif_queue_stopped (  struct net_device *  dev  )  [inline, static]

Definition at line 568 of file netdevice.h. References __LINK_STATE_XOFF, and net_device::state. Referenced by dev_queue_xmit(), inject(), and qdisc_run(). { return test_bit(__LINK_STATE_XOFF, &dev->state); }

int netif_receive_skb (  struct sk_buff *  skb  )

Definition at line 1461 of file dev.c. References net_device::br_port, sk_buff::data, deliver_to_old_ones(), sk_buff::dev, dev_queue_xmit(), netif_rx_stats::fastroute_deferred_out, sk_buff::h, handle_bridge(), kfree_skb(), NET_RX_DROP, netdev_rx_stat, packet_type::next, sk_buff::nh, sk_buff::pkt_type, sk_buff::protocol, ptype_all, ptype_base, skb_bond(), sk_buff::stamp, netif_rx_stats::total, and sk_buff::users. Referenced by process_backlog(). { struct packet_type *ptype, *pt_prev; int ret = NET_RX_DROP; unsigned short type = skb->protocol; if (skb->stamp.tv_sec == 0) do_gettimeofday(&skb->stamp); skb_bond(skb); netdev_rx_stat[smp_processor_id()].total++; #ifdef CONFIG_NET_FASTROUTE if (skb->pkt_type == PACKET_FASTROUTE) { netdev_rx_stat[smp_processor_id()].fastroute_deferred_out++; return dev_queue_xmit(skb); } #endif skb->h.raw = skb->nh.raw = skb->data; pt_prev = NULL; for (ptype = ptype_all; ptype; ptype = ptype->next) { if (!ptype->dev || ptype->dev == skb->dev) { if (pt_prev) { if (!pt_prev->data) { ret = deliver_to_old_ones(pt_prev, skb, 0); } else { atomic_inc(&skb->users); ret = pt_prev->func(skb, skb->dev, pt_prev); } } pt_prev = ptype; } } #ifdef CONFIG_NET_DIVERT if (skb->dev->divert && skb->dev->divert->divert) ret = handle_diverter(skb); #endif /* CONFIG_NET_DIVERT */ #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) if (skb->dev->br_port != NULL && br_handle_frame_hook != NULL) { return handle_bridge(skb, pt_prev); } #endif for (ptype=ptype_base[ntohs(type)&15];ptype;ptype=ptype->next) { if (ptype->type == type && (!ptype->dev || ptype->dev == skb->dev)) { if (pt_prev) { if (!pt_prev->data) { ret = deliver_to_old_ones(pt_prev, skb, 0); } else { atomic_inc(&skb->users); ret = pt_prev->func(skb, skb->dev, pt_prev); } } pt_prev = ptype; } } if (pt_prev) { if (!pt_prev->data) { ret = deliver_to_old_ones(pt_prev, skb, 1); } else { ret = pt_prev->func(skb, skb->dev, pt_prev); } } else { kfree_skb(skb); /* Jamal, now you will not able to escape explaining * me how you were going to use this. :-) */ ret = NET_RX_DROP; } return ret; }

int netif_running (  struct net_device *  dev  )  [inline, static]

Definition at line 573 of file netdevice.h. References __LINK_STATE_START, and net_device::state. Referenced by call_commit_handler(), dev_ifsioc(), inject(), neigh_proxy_process(), netif_carrier_on(), netif_device_attach(), netif_device_detach(), netif_rx_schedule_prep(), rtnetlink_fill_ifinfo(), and setup_inject(). { return test_bit(__LINK_STATE_START, &dev->state); }

int netif_rx (  struct sk_buff *  skb  )

Definition at line 1275 of file dev.c. References __skb_queue_tail(), sk_buff::dev, dev_hold, netif_rx_stats::dropped, get_sample_stats(), kfree_skb(), NET_RX_DROP, netdev_dropping, netdev_max_backlog, netdev_rx_stat, netif_rx_schedule(), softnet_data, sk_buff::stamp, netif_rx_stats::throttled, and netif_rx_stats::total. Referenced by ip_dev_loopback_xmit(), ipgre_rcv(), ipip_rcv(), and netif_rx_ni(). { int this_cpu = smp_processor_id(); struct softnet_data *queue; unsigned long flags; if (skb->stamp.tv_sec == 0) do_gettimeofday(&skb->stamp); /* The code is rearranged so that the path is the most short when CPU is congested, but is still operating. */ queue = &softnet_data[this_cpu]; local_irq_save(flags); netdev_rx_stat[this_cpu].total++; if (queue->input_pkt_queue.qlen <= netdev_max_backlog) { if (queue->input_pkt_queue.qlen) { if (queue->throttle) goto drop; enqueue: dev_hold(skb->dev); __skb_queue_tail(&queue->input_pkt_queue,skb); local_irq_restore(flags); #ifndef OFFLINE_SAMPLE get_sample_stats(this_cpu); #endif return queue->cng_level; } if (queue->throttle) { queue->throttle = 0; #ifdef CONFIG_NET_HW_FLOWCONTROL if (atomic_dec_and_test(&netdev_dropping)) netdev_wakeup(); #endif } netif_rx_schedule(&queue->blog_dev); goto enqueue; } if (queue->throttle == 0) { queue->throttle = 1; netdev_rx_stat[this_cpu].throttled++; #ifdef CONFIG_NET_HW_FLOWCONTROL atomic_inc(&netdev_dropping); #endif } drop: netdev_rx_stat[this_cpu].dropped++; local_irq_restore(flags); kfree_skb(skb); return NET_RX_DROP; }

void netif_rx_complete (  struct net_device *  dev  )  [inline, static]

Definition at line 794 of file netdevice.h. References __LINK_STATE_RX_SCHED, net_device::poll_list, and net_device::state. { unsigned long flags; local_irq_save(flags); if (!test_bit(__LINK_STATE_RX_SCHED, &dev->state)) BUG(); list_del(&dev->poll_list); smp_mb__before_clear_bit(); clear_bit(__LINK_STATE_RX_SCHED, &dev->state); local_irq_restore(flags); }

int netif_rx_ni (  struct sk_buff *  skb  )  [inline, static]

Definition at line 623 of file netdevice.h. References netif_rx(). { int err = netif_rx(skb); if (softirq_pending(smp_processor_id())) do_softirq(); return err; }

int netif_rx_reschedule (  struct net_device *  dev, int  undo )  [inline, static]

Definition at line 772 of file netdevice.h. References netif_rx_schedule_prep(), softnet_data::poll_list, net_device::poll_list, net_device::quota, and softnet_data. { if (netif_rx_schedule_prep(dev)) { unsigned long flags; int cpu = smp_processor_id(); dev->quota += undo; local_irq_save(flags); list_add_tail(&dev->poll_list, &softnet_data[cpu].poll_list); __cpu_raise_softirq(cpu, NET_RX_SOFTIRQ); local_irq_restore(flags); return 1; } return 0; }

void netif_rx_schedule (  struct net_device *  dev  )  [inline, static]

Definition at line 763 of file netdevice.h. References __netif_rx_schedule(), and netif_rx_schedule_prep(). Referenced by netif_rx(). { if (netif_rx_schedule_prep(dev)) __netif_rx_schedule(dev); }

int netif_rx_schedule_prep (  struct net_device *  dev  )  [inline, static]

Definition at line 735 of file netdevice.h. References __LINK_STATE_RX_SCHED, netif_running(), and net_device::state. Referenced by netif_rx_reschedule(), and netif_rx_schedule(). { return netif_running(dev) && !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state); }

void netif_schedule (  struct net_device *  dev  )  [inline, static]

Definition at line 546 of file netdevice.h. References __LINK_STATE_XOFF, __netif_schedule(), and net_device::state. Referenced by net_tx_action(). { if (!test_bit(__LINK_STATE_XOFF, &dev->state)) __netif_schedule(dev); }

void netif_start_queue (  struct net_device *  dev  )  [inline, static]

Definition at line 552 of file netdevice.h. References __LINK_STATE_XOFF, and net_device::state. { clear_bit(__LINK_STATE_XOFF, &dev->state); }

void netif_stop_queue (  struct net_device *  dev  )  [inline, static]

Definition at line 563 of file netdevice.h. References __LINK_STATE_XOFF, and net_device::state. Referenced by netif_device_detach(), and netif_tx_disable(). { set_bit(__LINK_STATE_XOFF, &dev->state); }

void netif_tx_disable (  struct net_device *  dev  )  [inline, static]

Definition at line 831 of file netdevice.h. References netif_stop_queue(), and net_device::xmit_lock. { spin_lock_bh(&dev->xmit_lock); netif_stop_queue(dev); spin_unlock_bh(&dev->xmit_lock); }

void netif_wake_queue (  struct net_device *  dev  )  [inline, static]

Definition at line 557 of file netdevice.h. References __LINK_STATE_XOFF, __netif_schedule(), and net_device::state. Referenced by netif_device_attach(). { if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state)) __netif_schedule(dev); }

int register_gifconf (  unsigned int  family, gifconf_func_t *  gifconf )

Definition at line 1663 of file dev.c. References gifconf_func_t, gifconf_list, and NPROTO. Referenced by devinet_init(), and unregister_gifconf(). { if (family>=NPROTO) return -EINVAL; gifconf_list[family] = gifconf; return 0; }

int register_netdev (  struct net_device *  dev  )

Referenced by ipgre_init(), and ipip_init().

int register_netdevice (  struct net_device *  dev  )

Definition at line 2464 of file dev.c. References __LINK_STATE_PRESENT, alloc_divert_blk(), default_rebuild_header(), dev_base, dev_base_lock, dev_boot_phase, dev_hold, dev_init_scheduler(), dev_new_index(), net_device::features, free_divert_blk(), net_device::ifindex, net_device::iflink, net_device::init, net_device::name, net_dev_init(), net_run_sbin_hotplug, netdev_chain, NETIF_F_HW_CSUM, NETIF_F_IP_CSUM, NETIF_F_NO_CSUM, NETIF_F_SG, net_device::next, net_device::queue_lock, net_device::rebuild_header, net_device::state, net_device::xmit_lock, and net_device::xmit_lock_owner. Referenced by ipgre_tunnel_locate(), and ipip_tunnel_locate(). { struct net_device *d, **dp; #ifdef CONFIG_NET_DIVERT int ret; #endif spin_lock_init(&dev->queue_lock); spin_lock_init(&dev->xmit_lock); dev->xmit_lock_owner = -1; #ifdef CONFIG_NET_FASTROUTE dev->fastpath_lock=RW_LOCK_UNLOCKED; #endif if (dev_boot_phase) net_dev_init(); #ifdef CONFIG_NET_DIVERT ret = alloc_divert_blk(dev); if (ret) return ret; #endif /* CONFIG_NET_DIVERT */ dev->iflink = -1; /* Init, if this function is available */ if (dev->init && dev->init(dev) != 0) { #ifdef CONFIG_NET_DIVERT free_divert_blk(dev); #endif return -EIO; } dev->ifindex = dev_new_index(); if (dev->iflink == -1) dev->iflink = dev->ifindex; /* Check for existence, and append to tail of chain */ for (dp=&dev_base; (d=*dp) != NULL; dp=&d->next) { if (d == dev || strcmp(d->name, dev->name) == 0) { #ifdef CONFIG_NET_DIVERT free_divert_blk(dev); #endif return -EEXIST; } } /* Fix illegal SG+CSUM combinations. */ if ((dev->features & NETIF_F_SG) && !(dev->features & (NETIF_F_IP_CSUM | NETIF_F_NO_CSUM | NETIF_F_HW_CSUM))) { printk("%s: Dropping NETIF_F_SG since no checksum feature.\n", dev->name); dev->features &= ~NETIF_F_SG; } /* * nil rebuild_header routine, * that should be never called and used as just bug trap. */ if (dev->rebuild_header == NULL) dev->rebuild_header = default_rebuild_header; /* * Default initial state at registry is that the * device is present. */ set_bit(__LINK_STATE_PRESENT, &dev->state); dev->next = NULL; dev_init_scheduler(dev); write_lock_bh(&dev_base_lock); *dp = dev; dev_hold(dev); dev->deadbeaf = 0; write_unlock_bh(&dev_base_lock); /* Notify protocols, that a new device appeared. */ notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev); net_run_sbin_hotplug(dev, "register"); return 0; }

int register_netdevice_notifier (  struct notifier_block *  nb  )

Definition at line 910 of file dev.c. References netdev_chain. Referenced by arp_init(), devinet_init(), dst_init(), fib_rules_init(), init(), init_or_cleanup(), ip_fib_init(), ip_mr_init(), ipfw_init_or_cleanup(), and rtnetlink_init(). { return notifier_chain_register(&netdev_chain, nb); }

struct sk_buff* skb_checksum_help (  struct sk_buff *  skb  )

Definition at line 977 of file dev.c. References CHECKSUM_NONE, sk_buff::csum, csum_fold(), sk_buff::data, sk_buff::h, sk_buff::ip_summed, sk_buff::len, skb_checksum(), and sk_buff::tail. Referenced by dev_queue_xmit(), ip_queue_xmit2(), and nf_hook_slow(). { int offset; unsigned int csum; offset = skb->h.raw - skb->data; if (offset > (int)skb->len) BUG(); csum = skb_checksum(skb, offset, skb->len-offset, 0); offset = skb->tail - skb->h.raw; if (offset <= 0) BUG(); if (skb->csum+2 > offset) BUG(); *(u16*)(skb->h.raw + skb->csum) = csum_fold(csum); skb->ip_summed = CHECKSUM_NONE; return skb; }

void tr_setup (  struct net_device *  dev  )

int unregister_gifconf (  unsigned int  family  )  [inline, static]

Definition at line 504 of file netdevice.h. References register_gifconf(). { return register_gifconf(family, 0); }

void unregister_netdev (  struct net_device *  dev  )

Referenced by ipip_fini().

int unregister_netdevice (  struct net_device *  dev  )

Definition at line 2594 of file dev.c. References net_device::deadbeaf, dev_base, dev_base_lock, dev_boot_phase, dev_close(), dev_mc_discard(), dev_put(), dev_shutdown(), net_device::features, net_device::flags, free_divert_blk(), net_device::master, net_device::name, net_run_sbin_hotplug, netdev_chain, NETIF_F_DYNALLOC, net_device::next, net_device::refcnt, and net_device::uninit. Referenced by ipgre_tunnel_ioctl(), ipip_tunnel_ioctl(), ipmr_new_tunnel(), and vif_delete(). { unsigned long now, warning_time; struct net_device *d, **dp; /* If device is running, close it first. */ if (dev->flags & IFF_UP) dev_close(dev); BUG_TRAP(dev->deadbeaf==0); dev->deadbeaf = 1; /* And unlink it from device chain. */ for (dp = &dev_base; (d=*dp) != NULL; dp=&d->next) { if (d == dev) { write_lock_bh(&dev_base_lock); *dp = d->next; write_unlock_bh(&dev_base_lock); break; } } if (d == NULL) { printk(KERN_DEBUG "unregister_netdevice: device %s/%p never was registered\n", dev->name, dev); return -ENODEV; } /* Synchronize to net_rx_action. */ br_write_lock_bh(BR_NETPROTO_LOCK); br_write_unlock_bh(BR_NETPROTO_LOCK); if (dev_boot_phase == 0) { #ifdef CONFIG_NET_FASTROUTE dev_clear_fastroute(dev); #endif /* Shutdown queueing discipline. */ dev_shutdown(dev); net_run_sbin_hotplug(dev, "unregister"); /* Notify protocols, that we are about to destroy this device. They should clean all the things. */ notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev); /* * Flush the multicast chain */ dev_mc_discard(dev); } if (dev->uninit) dev->uninit(dev); /* Notifier chain MUST detach us from master device. */ BUG_TRAP(dev->master==NULL); #ifdef CONFIG_NET_DIVERT free_divert_blk(dev); #endif if (dev->features & NETIF_F_DYNALLOC) { #ifdef NET_REFCNT_DEBUG if (atomic_read(&dev->refcnt) != 1) printk(KERN_DEBUG "unregister_netdevice: holding %s refcnt=%d\n", dev->name, atomic_read(&dev->refcnt)-1); #endif dev_put(dev); return 0; } /* Last reference is our one */ if (atomic_read(&dev->refcnt) == 1) { dev_put(dev); return 0; } #ifdef NET_REFCNT_DEBUG printk("unregister_netdevice: waiting %s refcnt=%d\n", dev->name, atomic_read(&dev->refcnt)); #endif /* EXPLANATION. If dev->refcnt is not now 1 (our own reference) it means that someone in the kernel still has a reference to this device and we cannot release it. "New style" devices have destructors, hence we can return from this function and destructor will do all the work later. As of kernel 2.4.0 there are very few "New Style" devices. "Old style" devices expect that the device is free of any references upon exit from this function. We cannot return from this function until all such references have fallen away. This is because the caller of this function will probably immediately kfree(*dev) and then be unloaded via sys_delete_module. So, we linger until all references fall away. The duration of the linger is basically unbounded! It is driven by, for example, the current setting of sysctl_ipfrag_time. After 1 second, we start to rebroadcast unregister notifications in hope that careless clients will release the device. */ now = warning_time = jiffies; while (atomic_read(&dev->refcnt) != 1) { if ((jiffies - now) > 1*HZ) { /* Rebroadcast unregister notification */ notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev); } current->state = TASK_INTERRUPTIBLE; schedule_timeout(HZ/4); current->state = TASK_RUNNING; if ((jiffies - warning_time) > 10*HZ) { printk(KERN_EMERG "unregister_netdevice: waiting for %s to " "become free. Usage count = %d\n", dev->name, atomic_read(&dev->refcnt)); warning_time = jiffies; } } dev_put(dev); return 0; }

int unregister_netdevice_notifier (  struct notifier_block *  nb  )

Definition at line 925 of file dev.c. References netdev_chain. Referenced by fini(), init_or_cleanup(), and ipfw_init_or_cleanup(). { return notifier_chain_unregister(&netdev_chain,nb); }

---

Variable Documentation

struct linux_mib ____cacheline_aligned

struct net_device* dev_base

Referenced by __dev_get_by_flags(), __dev_get_by_index(), __dev_get_by_name(), dev_getbyhwaddr(), dev_ifconf(), ic_open_devs(), inet_dump_ifaddr(), inet_select_addr(), ip_mc_procinfo(), ip_mcf_procinfo(), net_dev_init(), register_netdevice(), rtnetlink_dump_ifinfo(), and unregister_netdevice().

rwlock_t dev_base_lock

Referenced by dev_get(), dev_get_by_flags(), dev_get_by_index(), dev_get_by_name(), dev_ifname(), dev_ioctl(), inet_dump_ifaddr(), inet_select_addr(), inetdev_by_index(), ip_mc_procinfo(), ip_mcf_procinfo(), net_dev_init(), register_netdevice(), rtnetlink_dump_ifinfo(), and unregister_netdevice().

const char* if_port_text[]

Definition at line 127 of file dev.c.

struct net_device loopback_dev

Referenced by dst_dev_event(), inetdev_event(), ip_route_input_mc(), ip_route_input_slow(), ip_route_output_slow(), and ip_vs_in().

atomic_t netdev_dropping

Referenced by netif_rx(), and process_backlog().

unsigned long netdev_fc_xoff

int netdev_max_backlog

Definition at line 1133 of file dev.c. Referenced by get_sample_stats(), net_rx_action(), and netif_rx().

int netdev_nit

Definition at line 207 of file dev.c. Referenced by dev_add_pack(), dev_queue_xmit(), and dev_remove_pack().

struct netif_rx_stats netdev_rx_stat[]

Definition at line 1144 of file dev.c. Referenced by net_rx_action(), netif_receive_skb(), and netif_rx().

struct softnet_data softnet_data[NR_CPUS]

Referenced by __netif_rx_schedule(), __netif_schedule(), dev_kfree_skb_irq(), get_sample_stats(), net_dev_init(), net_rx_action(), net_tx_action(), netif_rx(), netif_rx_reschedule(), and process_backlog().

int weight_p

Definition at line 1134 of file dev.c. Referenced by net_dev_init().

---