1 files changed, 391 insertions, 115 deletions

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index da7a13c97eb8..5a11f889e56a 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -31,6 +31,7 @@
 
 #ifdef __KERNEL__
 #include <linux/timer.h>
+#include <linux/delay.h>
 #include <asm/atomic.h>
 #include <asm/cache.h>
 #include <asm/byteorder.h>
@@ -38,6 +39,9 @@
 #include <linux/device.h>
 #include <linux/percpu.h>
 #include <linux/dmaengine.h>
+#include <linux/workqueue.h>
+
+#include <net/net_namespace.h>
 
 struct vlan_group;
 struct ethtool_ops;
@@ -246,6 +250,19 @@ struct hh_cache
 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
         ((((dev)->hard_header_len+extra)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
 
+struct header_ops {
+        int     (*create) (struct sk_buff *skb, struct net_device *dev,
+                           unsigned short type, const void *daddr,
+                           const void *saddr, unsigned len);
+        int     (*parse)(const struct sk_buff *skb, unsigned char *haddr);
+        int     (*rebuild)(struct sk_buff *skb);
+#define HAVE_HEADER_CACHE
+        int     (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
+        void    (*cache_update)(struct hh_cache *hh,
+                                const struct net_device *dev,
+                                const unsigned char *haddr);
+};
+
 /* These flag bits are private to the generic network queueing
  * layer, they may not be explicitly referenced by any other
  * code.
@@ -258,7 +275,6 @@ enum netdev_state_t
         __LINK_STATE_PRESENT,
         __LINK_STATE_SCHED,
         __LINK_STATE_NOCARRIER,
-        __LINK_STATE_RX_SCHED,
         __LINK_STATE_LINKWATCH_PENDING,
         __LINK_STATE_DORMANT,
         __LINK_STATE_QDISC_RUNNING,
@@ -278,6 +294,120 @@ struct netdev_boot_setup {
 extern int __init netdev_boot_setup(char *str);
 
 /*
+ * Structure for NAPI scheduling similar to tasklet but with weighting
+ */
+struct napi_struct {
+        /* The poll_list must only be managed by the entity which
+         * changes the state of the NAPI_STATE_SCHED bit.  This means
+         * whoever atomically sets that bit can add this napi_struct
+         * to the per-cpu poll_list, and whoever clears that bit
+         * can remove from the list right before clearing the bit.
+         */
+        struct list_head        poll_list;
+
+        unsigned long           state;
+        int                     weight;
+        int                     (*poll)(struct napi_struct *, int);
+#ifdef CONFIG_NETPOLL
+        spinlock_t              poll_lock;
+        int                     poll_owner;
+        struct net_device       *dev;
+        struct list_head        dev_list;
+#endif
+};
+
+enum
+{
+        NAPI_STATE_SCHED,       /* Poll is scheduled */
+};
+
+extern void FASTCALL(__napi_schedule(struct napi_struct *n));
+
+/**
+ *      napi_schedule_prep - check if napi can be scheduled
+ *      @n: napi context
+ *
+ * Test if NAPI routine is already running, and if not mark
+ * it as running.  This is used as a condition variable
+ * insure only one NAPI poll instance runs
+ */
+static inline int napi_schedule_prep(struct napi_struct *n)
+{
+        return !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
+}
+
+/**
+ *      napi_schedule - schedule NAPI poll
+ *      @n: napi context
+ *
+ * Schedule NAPI poll routine to be called if it is not already
+ * running.
+ */
+static inline void napi_schedule(struct napi_struct *n)
+{
+        if (napi_schedule_prep(n))
+                __napi_schedule(n);
+}
+
+/* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
+static inline int napi_reschedule(struct napi_struct *napi)
+{
+        if (napi_schedule_prep(napi)) {
+                __napi_schedule(napi);
+                return 1;
+        }
+        return 0;
+}
+
+/**
+ *      napi_complete - NAPI processing complete
+ *      @n: napi context
+ *
+ * Mark NAPI processing as complete.
+ */
+static inline void __napi_complete(struct napi_struct *n)
+{
+        BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
+        list_del(&n->poll_list);
+        smp_mb__before_clear_bit();
+        clear_bit(NAPI_STATE_SCHED, &n->state);
+}
+
+static inline void napi_complete(struct napi_struct *n)
+{
+        local_irq_disable();
+        __napi_complete(n);
+        local_irq_enable();
+}
+
+/**
+ *      napi_disable - prevent NAPI from scheduling
+ *      @n: napi context
+ *
+ * Stop NAPI from being scheduled on this context.
+ * Waits till any outstanding processing completes.
+ */
+static inline void napi_disable(struct napi_struct *n)
+{
+        while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
+                msleep_interruptible(1);
+}
+
+/**
+ *      napi_enable - enable NAPI scheduling
+ *      @n: napi context
+ *
+ * Resume NAPI from being scheduled on this context.
+ * Must be paired with napi_disable.
+ */
+static inline void napi_enable(struct napi_struct *n)
+{
+        BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
+        smp_mb__before_clear_bit();
+        clear_bit(NAPI_STATE_SCHED, &n->state);
+}
+
+/*
  *      The DEVICE structure.
  *      Actually, this whole structure is a big mistake.  It mixes I/O
  *      data with strictly "high-level" data, and it has to know about
@@ -319,6 +449,9 @@ struct net_device
         unsigned long           state;
 
         struct list_head        dev_list;
+#ifdef CONFIG_NETPOLL
+        struct list_head        napi_list;
+#endif
         
         /* The device initialization function. Called only once. */
         int                     (*init)(struct net_device *dev);
@@ -339,8 +472,11 @@ struct net_device
 #define NETIF_F_HW_VLAN_FILTER  512     /* Receive filtering on VLAN */
 #define NETIF_F_VLAN_CHALLENGED 1024    /* Device cannot handle VLAN packets */
 #define NETIF_F_GSO             2048    /* Enable software GSO. */
-#define NETIF_F_LLTX            4096    /* LockLess TX */
+#define NETIF_F_LLTX            4096    /* LockLess TX - deprecated. Please */
+                                        /* do not use LLTX in new drivers */
+#define NETIF_F_NETNS_LOCAL     8192    /* Does not change network namespaces */
 #define NETIF_F_MULTI_QUEUE     16384   /* Has multiple TX/RX queues */
+#define NETIF_F_LRO             32768   /* large receive offload */
 
         /* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT       16
@@ -379,6 +515,9 @@ struct net_device
 #endif
         const struct ethtool_ops *ethtool_ops;
 
+        /* Hardware header description */
+        const struct header_ops *header_ops;
+
         /*
          * This marks the end of the "visible" part of the structure. All
          * fields hereafter are internal to the system, and may change at
@@ -430,12 +569,6 @@ struct net_device
 /*
  * Cache line mostly used on receive path (including eth_type_trans())
  */
-        struct list_head        poll_list ____cacheline_aligned_in_smp;
-                                        /* Link to poll list    */
-
-        int                     (*poll) (struct net_device *dev, int *quota);
-        int                     quota;
-        int                     weight;
         unsigned long           last_rx;        /* Time of last Rx      */
         /* Interface address info used in eth_type_trans() */
         unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast 
@@ -508,13 +641,6 @@ struct net_device
         int                     (*open)(struct net_device *dev);
         int                     (*stop)(struct net_device *dev);
 #define HAVE_NETDEV_POLL
-        int                     (*hard_header) (struct sk_buff *skb,
-                                                struct net_device *dev,
-                                                unsigned short type,
-                                                void *daddr,
-                                                void *saddr,
-                                                unsigned len);
-        int                     (*rebuild_header)(struct sk_buff *skb);
 #define HAVE_CHANGE_RX_FLAGS
         void                    (*change_rx_flags)(struct net_device *dev,
                                                    int flags);
@@ -531,12 +657,6 @@ struct net_device
 #define HAVE_SET_CONFIG
         int                     (*set_config)(struct net_device *dev,
                                               struct ifmap *map);
-#define HAVE_HEADER_CACHE
-        int                     (*hard_header_cache)(struct neighbour *neigh,
-                                                     struct hh_cache *hh);
-        void                    (*header_cache_update)(struct hh_cache *hh,
-                                                       struct net_device *dev,
-                                                       unsigned char *  haddr);
 #define HAVE_CHANGE_MTU
         int                     (*change_mtu)(struct net_device *dev, int new_mtu);
 
@@ -550,8 +670,6 @@ struct net_device
         void                    (*vlan_rx_kill_vid)(struct net_device *dev,
                                                     unsigned short vid);
 
-        int                     (*hard_header_parse)(struct sk_buff *skb,
-                                                     unsigned char *haddr);
         int                     (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
 #ifdef CONFIG_NETPOLL
         struct netpoll_info     *npinfo;
@@ -560,6 +678,9 @@ struct net_device
         void                    (*poll_controller)(struct net_device *dev);
 #endif
 
+        /* Network namespace this network device is inside */
+        struct net              *nd_net;
+
         /* bridge stuff */
         struct net_bridge_port  *br_port;
         /* macvlan */
@@ -575,24 +696,46 @@ struct net_device
 
         /* The TX queue control structures */
         unsigned int                    egress_subqueue_count;
-        struct net_device_subqueue      egress_subqueue[0];
+        struct net_device_subqueue      egress_subqueue[1];
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 
 #define NETDEV_ALIGN            32
 #define NETDEV_ALIGN_CONST      (NETDEV_ALIGN - 1)
 
+/**
+ *      netdev_priv - access network device private data
+ *      @dev: network device
+ *
+ * Get network device private data
+ */
 static inline void *netdev_priv(const struct net_device *dev)
 {
         return dev->priv;
 }
 
-#define SET_MODULE_OWNER(dev) do { } while (0)
 /* Set the sysfs physical device reference for the network logical device
  * if set prior to registration will cause a symlink during initialization.
  */
 #define SET_NETDEV_DEV(net, pdev)       ((net)->dev.parent = (pdev))
 
+static inline void netif_napi_add(struct net_device *dev,
+                                  struct napi_struct *napi,
+                                  int (*poll)(struct napi_struct *, int),
+                                  int weight)
+{
+        INIT_LIST_HEAD(&napi->poll_list);
+        napi->poll = poll;
+        napi->weight = weight;
+#ifdef CONFIG_NETPOLL
+        napi->dev = dev;
+        list_add(&napi->dev_list, &dev->napi_list);
+        spin_lock_init(&napi->poll_lock);
+        napi->poll_owner = -1;
+#endif
+        set_bit(NAPI_STATE_SCHED, &napi->state);
+}
+
 struct packet_type {
         __be16                  type;   /* This is really htons(ether_type). */
         struct net_device       *dev;   /* NULL is wildcarded here           */
@@ -610,45 +753,46 @@ struct packet_type {
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 
-extern struct net_device                loopback_dev;           /* The loopback */
-extern struct list_head                 dev_base_head;          /* All devices */
 extern rwlock_t                         dev_base_lock;          /* Device list lock */
 
-#define for_each_netdev(d)              \
-                list_for_each_entry(d, &dev_base_head, dev_list)
-#define for_each_netdev_safe(d, n)      \
-                list_for_each_entry_safe(d, n, &dev_base_head, dev_list)
-#define for_each_netdev_continue(d)             \
-                list_for_each_entry_continue(d, &dev_base_head, dev_list)
+
+#define for_each_netdev(net, d)         \
+                list_for_each_entry(d, &(net)->dev_base_head, dev_list)
+#define for_each_netdev_safe(net, d, n) \
+                list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
+#define for_each_netdev_continue(net, d)                \
+                list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
 #define net_device_entry(lh)    list_entry(lh, struct net_device, dev_list)
 
 static inline struct net_device *next_net_device(struct net_device *dev)
 {
         struct list_head *lh;
+        struct net *net;
 
+        net = dev->nd_net;
         lh = dev->dev_list.next;
-        return lh == &dev_base_head ? NULL : net_device_entry(lh);
+        return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
 }
 
-static inline struct net_device *first_net_device(void)
+static inline struct net_device *first_net_device(struct net *net)
 {
-        return list_empty(&dev_base_head) ? NULL :
-                net_device_entry(dev_base_head.next);
+        return list_empty(&net->dev_base_head) ? NULL :
+                net_device_entry(net->dev_base_head.next);
 }
 
 extern int                      netdev_boot_setup_check(struct net_device *dev);
 extern unsigned long            netdev_boot_base(const char *prefix, int unit);
-extern struct net_device    *dev_getbyhwaddr(unsigned short type, char *hwaddr);
-extern struct net_device *dev_getfirstbyhwtype(unsigned short type);
-extern struct net_device *__dev_getfirstbyhwtype(unsigned short type);
+extern struct net_device    *dev_getbyhwaddr(struct net *net, unsigned short type, char *hwaddr);
+extern struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
+extern struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
 extern void             dev_add_pack(struct packet_type *pt);
 extern void             dev_remove_pack(struct packet_type *pt);
 extern void             __dev_remove_pack(struct packet_type *pt);
 
-extern struct net_device        *dev_get_by_flags(unsigned short flags,
+extern struct net_device        *dev_get_by_flags(struct net *net, unsigned short flags,
                                                   unsigned short mask);
-extern struct net_device        *dev_get_by_name(const char *name);
-extern struct net_device        *__dev_get_by_name(const char *name);
+extern struct net_device        *dev_get_by_name(struct net *net, const char *name);
+extern struct net_device        *__dev_get_by_name(struct net *net, const char *name);
 extern int              dev_alloc_name(struct net_device *dev, const char *name);
 extern int              dev_open(struct net_device *dev);
 extern int              dev_close(struct net_device *dev);
@@ -659,14 +803,35 @@ extern void		free_netdev(struct net_device *dev);
 extern void             synchronize_net(void);
 extern int              register_netdevice_notifier(struct notifier_block *nb);
 extern int              unregister_netdevice_notifier(struct notifier_block *nb);
-extern int              call_netdevice_notifiers(unsigned long val, void *v);
-extern struct net_device        *dev_get_by_index(int ifindex);
-extern struct net_device        *__dev_get_by_index(int ifindex);
+extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
+extern struct net_device        *dev_get_by_index(struct net *net, int ifindex);
+extern struct net_device        *__dev_get_by_index(struct net *net, int ifindex);
 extern int              dev_restart(struct net_device *dev);
 #ifdef CONFIG_NETPOLL_TRAP
 extern int              netpoll_trap(void);
 #endif
 
+static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
+                                  unsigned short type,
+                                  const void *daddr, const void *saddr,
+                                  unsigned len)
+{
+        if (!dev->header_ops)
+                return 0;
+
+        return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
+}
+
+static inline int dev_parse_header(const struct sk_buff *skb,
+                                   unsigned char *haddr)
+{
+        const struct net_device *dev = skb->dev;
+
+        if (!dev->header_ops->parse)
+                return 0;
+        return dev->header_ops->parse(skb, haddr);
+}
+
 typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
 extern int              register_gifconf(unsigned int family, gifconf_func_t * gifconf);
 static inline int unregister_gifconf(unsigned int family)
@@ -678,7 +843,6 @@ static inline int unregister_gifconf(unsigned int family)
  * Incoming packets are placed on per-cpu queues so that
  * no locking is needed.
  */
-
 struct softnet_data
 {
         struct net_device       *output_queue;
@@ -686,7 +850,7 @@ struct softnet_data
         struct list_head        poll_list;
         struct sk_buff          *completion_queue;
 
-        struct net_device       backlog_dev;    /* Sorry. 8) */
+        struct napi_struct      backlog;
 #ifdef CONFIG_NET_DMA
         struct dma_chan         *net_dma;
 #endif
@@ -704,11 +868,24 @@ static inline void netif_schedule(struct net_device *dev)
                 __netif_schedule(dev);
 }
 
+/**
+ *      netif_start_queue - allow transmit
+ *      @dev: network device
+ *
+ *      Allow upper layers to call the device hard_start_xmit routine.
+ */
 static inline void netif_start_queue(struct net_device *dev)
 {
         clear_bit(__LINK_STATE_XOFF, &dev->state);
 }
 
+/**
+ *      netif_wake_queue - restart transmit
+ *      @dev: network device
+ *
+ *      Allow upper layers to call the device hard_start_xmit routine.
+ *      Used for flow control when transmit resources are available.
+ */
 static inline void netif_wake_queue(struct net_device *dev)
 {
 #ifdef CONFIG_NETPOLL_TRAP
@@ -721,16 +898,35 @@ static inline void netif_wake_queue(struct net_device *dev)
                 __netif_schedule(dev);
 }
 
+/**
+ *      netif_stop_queue - stop transmitted packets
+ *      @dev: network device
+ *
+ *      Stop upper layers calling the device hard_start_xmit routine.
+ *      Used for flow control when transmit resources are unavailable.
+ */
 static inline void netif_stop_queue(struct net_device *dev)
 {
         set_bit(__LINK_STATE_XOFF, &dev->state);
 }
 
+/**
+ *      netif_queue_stopped - test if transmit queue is flowblocked
+ *      @dev: network device
+ *
+ *      Test if transmit queue on device is currently unable to send.
+ */
 static inline int netif_queue_stopped(const struct net_device *dev)
 {
         return test_bit(__LINK_STATE_XOFF, &dev->state);
 }
 
+/**
+ *      netif_running - test if up
+ *      @dev: network device
+ *
+ *      Test if the device has been brought up.
+ */
 static inline int netif_running(const struct net_device *dev)
 {
         return test_bit(__LINK_STATE_START, &dev->state);
@@ -742,6 +938,14 @@ static inline int netif_running(const struct net_device *dev)
  * done at the overall netdevice level.
  * Also test the device if we're multiqueue.
  */
+
+/**
+ *      netif_start_subqueue - allow sending packets on subqueue
+ *      @dev: network device
+ *      @queue_index: sub queue index
+ *
+ * Start individual transmit queue of a device with multiple transmit queues.
+ */
 static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
 {
 #ifdef CONFIG_NETDEVICES_MULTIQUEUE
@@ -749,6 +953,13 @@ static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
 #endif
 }
 
+/**
+ *      netif_stop_subqueue - stop sending packets on subqueue
+ *      @dev: network device
+ *      @queue_index: sub queue index
+ *
+ * Stop individual transmit queue of a device with multiple transmit queues.
+ */
 static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
 {
 #ifdef CONFIG_NETDEVICES_MULTIQUEUE
@@ -760,6 +971,13 @@ static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
 #endif
 }
 
+/**
+ *      netif_subqueue_stopped - test status of subqueue
+ *      @dev: network device
+ *      @queue_index: sub queue index
+ *
+ * Check individual transmit queue of a device with multiple transmit queues.
+ */
 static inline int netif_subqueue_stopped(const struct net_device *dev,
                                          u16 queue_index)
 {
@@ -771,6 +989,14 @@ static inline int netif_subqueue_stopped(const struct net_device *dev,
 #endif
 }
 
+
+/**
+ *      netif_wake_subqueue - allow sending packets on subqueue
+ *      @dev: network device
+ *      @queue_index: sub queue index
+ *
+ * Resume individual transmit queue of a device with multiple transmit queues.
+ */
 static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
 {
 #ifdef CONFIG_NETDEVICES_MULTIQUEUE
@@ -784,6 +1010,13 @@ static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
 #endif
 }
 
+/**
+ *      netif_is_multiqueue - test if device has multiple transmit queues
+ *      @dev: network device
+ *
+ * Check if device has multiple transmit queues
+ * Always falls if NETDEVICE_MULTIQUEUE is not configured
+ */
 static inline int netif_is_multiqueue(const struct net_device *dev)
 {
 #ifdef CONFIG_NETDEVICES_MULTIQUEUE
@@ -796,20 +1029,7 @@ static inline int netif_is_multiqueue(const struct net_device *dev)
 /* Use this variant when it is known for sure that it
  * is executing from interrupt context.
  */
-static inline void dev_kfree_skb_irq(struct sk_buff *skb)
-{
-        if (atomic_dec_and_test(&skb->users)) {
-                struct softnet_data *sd;
-                unsigned long flags;
-
-                local_irq_save(flags);
-                sd = &__get_cpu_var(softnet_data);
-                skb->next = sd->completion_queue;
-                sd->completion_queue = skb;
-                raise_softirq_irqoff(NET_TX_SOFTIRQ);
-                local_irq_restore(flags);
-        }
-}
+extern void dev_kfree_skb_irq(struct sk_buff *skb);
 
 /* Use this variant in places where it could be invoked
  * either from interrupt or non-interrupt context.
@@ -822,29 +1042,41 @@ extern int		netif_rx_ni(struct sk_buff *skb);
 #define HAVE_NETIF_RECEIVE_SKB 1
 extern int              netif_receive_skb(struct sk_buff *skb);
 extern int              dev_valid_name(const char *name);
-extern int              dev_ioctl(unsigned int cmd, void __user *);
-extern int              dev_ethtool(struct ifreq *);
+extern int              dev_ioctl(struct net *net, unsigned int cmd, void __user *);
+extern int              dev_ethtool(struct net *net, struct ifreq *);
 extern unsigned         dev_get_flags(const struct net_device *);
 extern int              dev_change_flags(struct net_device *, unsigned);
 extern int              dev_change_name(struct net_device *, char *);
+extern int              dev_change_net_namespace(struct net_device *,
+                                                 struct net *, const char *);
 extern int              dev_set_mtu(struct net_device *, int);
 extern int              dev_set_mac_address(struct net_device *,
                                             struct sockaddr *);
 extern int              dev_hard_start_xmit(struct sk_buff *skb,
                                             struct net_device *dev);
 
-extern void             dev_init(void);
-
 extern int              netdev_budget;
 
 /* Called by rtnetlink.c:rtnl_unlock() */
 extern void netdev_run_todo(void);
 
+/**
+ *      dev_put - release reference to device
+ *      @dev: network device
+ *
+ * Release reference to device to allow it to be freed.
+ */
 static inline void dev_put(struct net_device *dev)
 {
         atomic_dec(&dev->refcnt);
 }
 
+/**
+ *      dev_hold - get reference to device
+ *      @dev: network device
+ *
+ * Hold reference to device to keep it from being freed.
+ */
 static inline void dev_hold(struct net_device *dev)
 {
         atomic_inc(&dev->refcnt);
@@ -861,6 +1093,12 @@ static inline void dev_hold(struct net_device *dev)
 
 extern void linkwatch_fire_event(struct net_device *dev);
 
+/**
+ *      netif_carrier_ok - test if carrier present
+ *      @dev: network device
+ *
+ * Check if carrier is present on device
+ */
 static inline int netif_carrier_ok(const struct net_device *dev)
 {
         return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
@@ -872,30 +1110,66 @@ extern void netif_carrier_on(struct net_device *dev);
 
 extern void netif_carrier_off(struct net_device *dev);
 
+/**
+ *      netif_dormant_on - mark device as dormant.
+ *      @dev: network device
+ *
+ * Mark device as dormant (as per RFC2863).
+ *
+ * The dormant state indicates that the relevant interface is not
+ * actually in a condition to pass packets (i.e., it is not 'up') but is
+ * in a "pending" state, waiting for some external event.  For "on-
+ * demand" interfaces, this new state identifies the situation where the
+ * interface is waiting for events to place it in the up state.
+ *
+ */
 static inline void netif_dormant_on(struct net_device *dev)
 {
         if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
                 linkwatch_fire_event(dev);
 }
 
+/**
+ *      netif_dormant_off - set device as not dormant.
+ *      @dev: network device
+ *
+ * Device is not in dormant state.
+ */
 static inline void netif_dormant_off(struct net_device *dev)
 {
         if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
                 linkwatch_fire_event(dev);
 }
 
+/**
+ *      netif_dormant - test if carrier present
+ *      @dev: network device
+ *
+ * Check if carrier is present on device
+ */
 static inline int netif_dormant(const struct net_device *dev)
 {
         return test_bit(__LINK_STATE_DORMANT, &dev->state);
 }
 
 
+/**
+ *      netif_oper_up - test if device is operational
+ *      @dev: network device
+ *
+ * Check if carrier is operational
+ */
 static inline int netif_oper_up(const struct net_device *dev) {
         return (dev->operstate == IF_OPER_UP ||
                 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
 }
 
-/* Hot-plugging. */
+/**
+ *      netif_device_present - is device available or removed
+ *      @dev: network device
+ *
+ * Check if device has not been removed from system.
+ */
 static inline int netif_device_present(struct net_device *dev)
 {
         return test_bit(__LINK_STATE_PRESENT, &dev->state);
@@ -955,46 +1229,38 @@ static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
         return (1 << debug_value) - 1;
 }
 
-/* Test if receive needs to be scheduled */
-static inline int __netif_rx_schedule_prep(struct net_device *dev)
-{
-        return !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state);
-}
-
 /* Test if receive needs to be scheduled but only if up */
-static inline int netif_rx_schedule_prep(struct net_device *dev)
+static inline int netif_rx_schedule_prep(struct net_device *dev,
+                                         struct napi_struct *napi)
 {
-        return netif_running(dev) && __netif_rx_schedule_prep(dev);
+        return netif_running(dev) && napi_schedule_prep(napi);
 }
 
 /* Add interface to tail of rx poll list. This assumes that _prep has
  * already been called and returned 1.
  */
-
-extern void __netif_rx_schedule(struct net_device *dev);
+static inline void __netif_rx_schedule(struct net_device *dev,
+                                       struct napi_struct *napi)
+{
+        dev_hold(dev);
+        __napi_schedule(napi);
+}
 
 /* Try to reschedule poll. Called by irq handler. */
 
-static inline void netif_rx_schedule(struct net_device *dev)
+static inline void netif_rx_schedule(struct net_device *dev,
+                                     struct napi_struct *napi)
 {
-        if (netif_rx_schedule_prep(dev))
-                __netif_rx_schedule(dev);
+        if (netif_rx_schedule_prep(dev, napi))
+                __netif_rx_schedule(dev, napi);
 }
 
-/* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().
- * Do not inline this?
- */
-static inline int netif_rx_reschedule(struct net_device *dev, int undo)
+/* Try to reschedule poll. Called by dev->poll() after netif_rx_complete().  */
+static inline int netif_rx_reschedule(struct net_device *dev,
+                                      struct napi_struct *napi)
 {
-        if (netif_rx_schedule_prep(dev)) {
-                unsigned long flags;
-
-                dev->quota += undo;
-
-                local_irq_save(flags);
-                list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
-                __raise_softirq_irqoff(NET_RX_SOFTIRQ);
-                local_irq_restore(flags);
+        if (napi_schedule_prep(napi)) {
+                __netif_rx_schedule(dev, napi);
                 return 1;
         }
         return 0;
@@ -1003,12 +1269,11 @@ static inline int netif_rx_reschedule(struct net_device *dev, int undo)
 /* same as netif_rx_complete, except that local_irq_save(flags)
  * has already been issued
  */
-static inline void __netif_rx_complete(struct net_device *dev)
+static inline void __netif_rx_complete(struct net_device *dev,
+                                       struct napi_struct *napi)
 {
-        BUG_ON(!test_bit(__LINK_STATE_RX_SCHED, &dev->state));
-        list_del(&dev->poll_list);
-        smp_mb__before_clear_bit();
-        clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
+        __napi_complete(napi);
+        dev_put(dev);
 }
 
 /* Remove interface from poll list: it must be in the poll list
@@ -1016,32 +1281,31 @@ static inline void __netif_rx_complete(struct net_device *dev)
  * it completes the work. The device cannot be out of poll list at this
  * moment, it is BUG().
  */
-static inline void netif_rx_complete(struct net_device *dev)
+static inline void netif_rx_complete(struct net_device *dev,
+                                     struct napi_struct *napi)
 {
         unsigned long flags;
 
         local_irq_save(flags);
-        __netif_rx_complete(dev);
+        __netif_rx_complete(dev, napi);
         local_irq_restore(flags);
 }
 
-static inline void netif_poll_disable(struct net_device *dev)
-{
-        while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state))
-                /* No hurry. */
-                schedule_timeout_interruptible(1);
-}
-
-static inline void netif_poll_enable(struct net_device *dev)
+/**
+ *      netif_tx_lock - grab network device transmit lock
+ *      @dev: network device
+ *
+ * Get network device transmit lock
+ */
+static inline void __netif_tx_lock(struct net_device *dev, int cpu)
 {
-        smp_mb__before_clear_bit();
-        clear_bit(__LINK_STATE_RX_SCHED, &dev->state);
+        spin_lock(&dev->_xmit_lock);
+        dev->xmit_lock_owner = cpu;
 }
 
 static inline void netif_tx_lock(struct net_device *dev)
 {
-        spin_lock(&dev->_xmit_lock);
-        dev->xmit_lock_owner = smp_processor_id();
+        __netif_tx_lock(dev, smp_processor_id());
 }
 
 static inline void netif_tx_lock_bh(struct net_device *dev)
@@ -1070,6 +1334,18 @@ static inline void netif_tx_unlock_bh(struct net_device *dev)
         spin_unlock_bh(&dev->_xmit_lock);
 }
 
+#define HARD_TX_LOCK(dev, cpu) {                        \
+        if ((dev->features & NETIF_F_LLTX) == 0) {      \
+                __netif_tx_lock(dev, cpu);                      \
+        }                                               \
+}
+
+#define HARD_TX_UNLOCK(dev) {                           \
+        if ((dev->features & NETIF_F_LLTX) == 0) {      \
+                netif_tx_unlock(dev);                   \
+        }                                               \
+}
+
 static inline void netif_tx_disable(struct net_device *dev)
 {
         netif_tx_lock_bh(dev);
@@ -1098,16 +1374,14 @@ extern int 		dev_mc_delete(struct net_device *dev, void *addr, int alen, int all
 extern int              dev_mc_add(struct net_device *dev, void *addr, int alen, int newonly);
 extern int              dev_mc_sync(struct net_device *to, struct net_device *from);
 extern void             dev_mc_unsync(struct net_device *to, struct net_device *from);
-extern void             dev_mc_discard(struct net_device *dev);
 extern int              __dev_addr_delete(struct dev_addr_list **list, int *count, void *addr, int alen, int all);
 extern int              __dev_addr_add(struct dev_addr_list **list, int *count, void *addr, int alen, int newonly);
-extern void             __dev_addr_discard(struct dev_addr_list **list);
 extern void             dev_set_promiscuity(struct net_device *dev, int inc);
 extern void             dev_set_allmulti(struct net_device *dev, int inc);
 extern void             netdev_state_change(struct net_device *dev);
 extern void             netdev_features_change(struct net_device *dev);
 /* Load a device via the kmod */
-extern void             dev_load(const char *name);
+extern void             dev_load(struct net *net, const char *name);
 extern void             dev_mcast_init(void);
 extern int              netdev_max_backlog;
 extern int              weight_p;
@@ -1133,6 +1407,8 @@ extern void dev_seq_stop(struct seq_file *seq, void *v);
 
 extern void linkwatch_run_queue(void);
 
+extern int netdev_compute_features(unsigned long all, unsigned long one);
+
 static inline int net_gso_ok(int features, int gso_type)
 {
         int feature = gso_type << NETIF_F_GSO_SHIFT;