20 files changed, 174 insertions, 88 deletions

diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index b70cc99962fc..06b901152d44 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -399,9 +399,11 @@ static int bnx2_unregister_cnic(struct net_device *dev)
         struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
         struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
 
+        mutex_lock(&bp->cnic_lock);
         cp->drv_state = 0;
         bnapi->cnic_present = 0;
         rcu_assign_pointer(bp->cnic_ops, NULL);
+        mutex_unlock(&bp->cnic_lock);
         synchronize_rcu();
         return 0;
 }
@@ -429,13 +431,13 @@ bnx2_cnic_stop(struct bnx2 *bp)
         struct cnic_ops *c_ops;
         struct cnic_ctl_info info;
 
-        rcu_read_lock();
-        c_ops = rcu_dereference(bp->cnic_ops);
+        mutex_lock(&bp->cnic_lock);
+        c_ops = bp->cnic_ops;
         if (c_ops) {
                 info.cmd = CNIC_CTL_STOP_CMD;
                 c_ops->cnic_ctl(bp->cnic_data, &info);
         }
-        rcu_read_unlock();
+        mutex_unlock(&bp->cnic_lock);
 }
 
 static void
@@ -444,8 +446,8 @@ bnx2_cnic_start(struct bnx2 *bp)
         struct cnic_ops *c_ops;
         struct cnic_ctl_info info;
 
-        rcu_read_lock();
-        c_ops = rcu_dereference(bp->cnic_ops);
+        mutex_lock(&bp->cnic_lock);
+        c_ops = bp->cnic_ops;
         if (c_ops) {
                 if (!(bp->flags & BNX2_FLAG_USING_MSIX)) {
                         struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
@@ -455,7 +457,7 @@ bnx2_cnic_start(struct bnx2 *bp)
                 info.cmd = CNIC_CTL_START_CMD;
                 c_ops->cnic_ctl(bp->cnic_data, &info);
         }
-        rcu_read_unlock();
+        mutex_unlock(&bp->cnic_lock);
 }
 
 #else
@@ -7663,6 +7665,9 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
 
         spin_lock_init(&bp->phy_lock);
         spin_lock_init(&bp->indirect_lock);
+#ifdef BCM_CNIC
+        mutex_init(&bp->cnic_lock);
+#endif
         INIT_WORK(&bp->reset_task, bnx2_reset_task);
 
         dev->base_addr = dev->mem_start = pci_resource_start(pdev, 0);
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h
index f1edfaa9e56a..a4f12fd0ecd2 100644
--- a/drivers/net/bnx2.h
+++ b/drivers/net/bnx2.h
@@ -6902,6 +6902,7 @@ struct bnx2 {
         u32                     idle_chk_status_idx;
 
 #ifdef BCM_CNIC
+        struct mutex            cnic_lock;
         struct cnic_eth_dev     cnic_eth_dev;
 #endif
 
diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index 4869d77cbe91..74c342959b7b 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -138,6 +138,16 @@ static struct cnic_dev *cnic_from_netdev(struct net_device *netdev)
         return NULL;
 }
 
+static inline void ulp_get(struct cnic_ulp_ops *ulp_ops)
+{
+        atomic_inc(&ulp_ops->ref_count);
+}
+
+static inline void ulp_put(struct cnic_ulp_ops *ulp_ops)
+{
+        atomic_dec(&ulp_ops->ref_count);
+}
+
 static void cnic_ctx_wr(struct cnic_dev *dev, u32 cid_addr, u32 off, u32 val)
 {
         struct cnic_local *cp = dev->cnic_priv;
@@ -358,6 +368,7 @@ int cnic_register_driver(int ulp_type, struct cnic_ulp_ops *ulp_ops)
         }
         read_unlock(&cnic_dev_lock);
 
+        atomic_set(&ulp_ops->ref_count, 0);
         rcu_assign_pointer(cnic_ulp_tbl[ulp_type], ulp_ops);
         mutex_unlock(&cnic_lock);
 
@@ -379,6 +390,8 @@ int cnic_register_driver(int ulp_type, struct cnic_ulp_ops *ulp_ops)
 int cnic_unregister_driver(int ulp_type)
 {
         struct cnic_dev *dev;
+        struct cnic_ulp_ops *ulp_ops;
+        int i = 0;
 
         if (ulp_type >= MAX_CNIC_ULP_TYPE) {
                 printk(KERN_ERR PFX "cnic_unregister_driver: Bad type %d\n",
@@ -386,7 +399,8 @@ int cnic_unregister_driver(int ulp_type)
                 return -EINVAL;
         }
         mutex_lock(&cnic_lock);
-        if (!cnic_ulp_tbl[ulp_type]) {
+        ulp_ops = cnic_ulp_tbl[ulp_type];
+        if (!ulp_ops) {
                 printk(KERN_ERR PFX "cnic_unregister_driver: Type %d has not "
                                     "been registered\n", ulp_type);
                 goto out_unlock;
@@ -411,6 +425,14 @@ int cnic_unregister_driver(int ulp_type)
 
         mutex_unlock(&cnic_lock);
         synchronize_rcu();
+        while ((atomic_read(&ulp_ops->ref_count) != 0) && (i < 20)) {
+                msleep(100);
+                i++;
+        }
+
+        if (atomic_read(&ulp_ops->ref_count) != 0)
+                printk(KERN_WARNING PFX "%s: Failed waiting for ref count to go"
+                                        " to zero.\n", dev->netdev->name);
         return 0;
 
 out_unlock:
@@ -466,6 +488,7 @@ EXPORT_SYMBOL(cnic_register_driver);
 static int cnic_unregister_device(struct cnic_dev *dev, int ulp_type)
 {
         struct cnic_local *cp = dev->cnic_priv;
+        int i = 0;
 
         if (ulp_type >= MAX_CNIC_ULP_TYPE) {
                 printk(KERN_ERR PFX "cnic_unregister_device: Bad type %d\n",
@@ -486,6 +509,15 @@ static int cnic_unregister_device(struct cnic_dev *dev, int ulp_type)
 
         synchronize_rcu();
 
+        while (test_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[ulp_type]) &&
+               i < 20) {
+                msleep(100);
+                i++;
+        }
+        if (test_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[ulp_type]))
+                printk(KERN_WARNING PFX "%s: Failed waiting for ULP up call"
+                                        " to complete.\n", dev->netdev->name);
+
         return 0;
 }
 EXPORT_SYMBOL(cnic_unregister_driver);
@@ -1076,18 +1108,23 @@ static void cnic_ulp_stop(struct cnic_dev *dev)
         if (cp->cnic_uinfo)
                 cnic_send_nlmsg(cp, ISCSI_KEVENT_IF_DOWN, NULL);
 
-        rcu_read_lock();
         for (if_type = 0; if_type < MAX_CNIC_ULP_TYPE; if_type++) {
                 struct cnic_ulp_ops *ulp_ops;
 
-                ulp_ops = rcu_dereference(cp->ulp_ops[if_type]);
-                if (!ulp_ops)
+                mutex_lock(&cnic_lock);
+                ulp_ops = cp->ulp_ops[if_type];
+                if (!ulp_ops) {
+                        mutex_unlock(&cnic_lock);
                         continue;
+                }
+                set_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
+                mutex_unlock(&cnic_lock);
 
                 if (test_and_clear_bit(ULP_F_START, &cp->ulp_flags[if_type]))
                         ulp_ops->cnic_stop(cp->ulp_handle[if_type]);
+
+                clear_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
         }
-        rcu_read_unlock();
 }
 
 static void cnic_ulp_start(struct cnic_dev *dev)
@@ -1095,18 +1132,23 @@ static void cnic_ulp_start(struct cnic_dev *dev)
         struct cnic_local *cp = dev->cnic_priv;
         int if_type;
 
-        rcu_read_lock();
         for (if_type = 0; if_type < MAX_CNIC_ULP_TYPE; if_type++) {
                 struct cnic_ulp_ops *ulp_ops;
 
-                ulp_ops = rcu_dereference(cp->ulp_ops[if_type]);
-                if (!ulp_ops || !ulp_ops->cnic_start)
+                mutex_lock(&cnic_lock);
+                ulp_ops = cp->ulp_ops[if_type];
+                if (!ulp_ops || !ulp_ops->cnic_start) {
+                        mutex_unlock(&cnic_lock);
                         continue;
+                }
+                set_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
+                mutex_unlock(&cnic_lock);
 
                 if (!test_and_set_bit(ULP_F_START, &cp->ulp_flags[if_type]))
                         ulp_ops->cnic_start(cp->ulp_handle[if_type]);
+
+                clear_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
         }
-        rcu_read_unlock();
 }
 
 static int cnic_ctl(void *data, struct cnic_ctl_info *info)
@@ -1116,22 +1158,18 @@ static int cnic_ctl(void *data, struct cnic_ctl_info *info)
         switch (info->cmd) {
         case CNIC_CTL_STOP_CMD:
                 cnic_hold(dev);
-                mutex_lock(&cnic_lock);
 
                 cnic_ulp_stop(dev);
                 cnic_stop_hw(dev);
 
-                mutex_unlock(&cnic_lock);
                 cnic_put(dev);
                 break;
         case CNIC_CTL_START_CMD:
                 cnic_hold(dev);
-                mutex_lock(&cnic_lock);
 
                 if (!cnic_start_hw(dev))
                         cnic_ulp_start(dev);
 
-                mutex_unlock(&cnic_lock);
                 cnic_put(dev);
                 break;
         default:
@@ -1145,19 +1183,23 @@ static void cnic_ulp_init(struct cnic_dev *dev)
         int i;
         struct cnic_local *cp = dev->cnic_priv;
 
-        rcu_read_lock();
         for (i = 0; i < MAX_CNIC_ULP_TYPE_EXT; i++) {
                 struct cnic_ulp_ops *ulp_ops;
 
-                ulp_ops = rcu_dereference(cnic_ulp_tbl[i]);
-                if (!ulp_ops || !ulp_ops->cnic_init)
+                mutex_lock(&cnic_lock);
+                ulp_ops = cnic_ulp_tbl[i];
+                if (!ulp_ops || !ulp_ops->cnic_init) {
+                        mutex_unlock(&cnic_lock);
                         continue;
+                }
+                ulp_get(ulp_ops);
+                mutex_unlock(&cnic_lock);
 
                 if (!test_and_set_bit(ULP_F_INIT, &cp->ulp_flags[i]))
                         ulp_ops->cnic_init(dev);
 
+                ulp_put(ulp_ops);
         }
-        rcu_read_unlock();
 }
 
 static void cnic_ulp_exit(struct cnic_dev *dev)
@@ -1165,19 +1207,23 @@ static void cnic_ulp_exit(struct cnic_dev *dev)
         int i;
         struct cnic_local *cp = dev->cnic_priv;
 
-        rcu_read_lock();
         for (i = 0; i < MAX_CNIC_ULP_TYPE_EXT; i++) {
                 struct cnic_ulp_ops *ulp_ops;
 
-                ulp_ops = rcu_dereference(cnic_ulp_tbl[i]);
-                if (!ulp_ops || !ulp_ops->cnic_exit)
+                mutex_lock(&cnic_lock);
+                ulp_ops = cnic_ulp_tbl[i];
+                if (!ulp_ops || !ulp_ops->cnic_exit) {
+                        mutex_unlock(&cnic_lock);
                         continue;
+                }
+                ulp_get(ulp_ops);
+                mutex_unlock(&cnic_lock);
 
                 if (test_and_clear_bit(ULP_F_INIT, &cp->ulp_flags[i]))
                         ulp_ops->cnic_exit(dev);
 
+                ulp_put(ulp_ops);
         }
-        rcu_read_unlock();
 }
 
 static int cnic_cm_offload_pg(struct cnic_sock *csk)
@@ -2393,21 +2439,45 @@ static int cnic_start_bnx2_hw(struct cnic_dev *dev)
         return 0;
 }
 
-static int cnic_start_hw(struct cnic_dev *dev)
+static int cnic_register_netdev(struct cnic_dev *dev)
 {
         struct cnic_local *cp = dev->cnic_priv;
         struct cnic_eth_dev *ethdev = cp->ethdev;
         int err;
 
-        if (test_bit(CNIC_F_CNIC_UP, &dev->flags))
-                return -EALREADY;
+        if (!ethdev)
+                return -ENODEV;
+
+        if (ethdev->drv_state & CNIC_DRV_STATE_REGD)
+                return 0;
 
         err = ethdev->drv_register_cnic(dev->netdev, cp->cnic_ops, dev);
-        if (err) {
+        if (err)
                 printk(KERN_ERR PFX "%s: register_cnic failed\n",
                        dev->netdev->name);
-                goto err2;
-        }
+
+        return err;
+}
+
+static void cnic_unregister_netdev(struct cnic_dev *dev)
+{
+        struct cnic_local *cp = dev->cnic_priv;
+        struct cnic_eth_dev *ethdev = cp->ethdev;
+
+        if (!ethdev)
+                return;
+
+        ethdev->drv_unregister_cnic(dev->netdev);
+}
+
+static int cnic_start_hw(struct cnic_dev *dev)
+{
+        struct cnic_local *cp = dev->cnic_priv;
+        struct cnic_eth_dev *ethdev = cp->ethdev;
+        int err;
+
+        if (test_bit(CNIC_F_CNIC_UP, &dev->flags))
+                return -EALREADY;
 
         dev->regview = ethdev->io_base;
         cp->chip_id = ethdev->chip_id;
@@ -2438,18 +2508,13 @@ static int cnic_start_hw(struct cnic_dev *dev)
         return 0;
 
 err1:
-        ethdev->drv_unregister_cnic(dev->netdev);
         cp->free_resc(dev);
         pci_dev_put(dev->pcidev);
-err2:
         return err;
 }
 
 static void cnic_stop_bnx2_hw(struct cnic_dev *dev)
 {
-        struct cnic_local *cp = dev->cnic_priv;
-        struct cnic_eth_dev *ethdev = cp->ethdev;
-
         cnic_disable_bnx2_int_sync(dev);
 
         cnic_reg_wr_ind(dev, BNX2_CP_SCRATCH + 0x20, 0);
@@ -2461,8 +2526,6 @@ static void cnic_stop_bnx2_hw(struct cnic_dev *dev)
         cnic_setup_5709_context(dev, 0);
         cnic_free_irq(dev);
 
-        ethdev->drv_unregister_cnic(dev->netdev);
-
         cnic_free_resc(dev);
 }
 
@@ -2543,7 +2606,7 @@ static struct cnic_dev *init_bnx2_cnic(struct net_device *dev)
         probe = symbol_get(bnx2_cnic_probe);
         if (probe) {
                 ethdev = (*probe)(dev);
-                symbol_put_addr(probe);
+                symbol_put(bnx2_cnic_probe);
         }
         if (!ethdev)
                 return NULL;
@@ -2646,10 +2709,12 @@ static int cnic_netdev_event(struct notifier_block *this, unsigned long event,
                 else if (event == NETDEV_UNREGISTER)
                         cnic_ulp_exit(dev);
                 else if (event == NETDEV_UP) {
-                        mutex_lock(&cnic_lock);
+                        if (cnic_register_netdev(dev) != 0) {
+                                cnic_put(dev);
+                                goto done;
+                        }
                         if (!cnic_start_hw(dev))
                                 cnic_ulp_start(dev);
-                        mutex_unlock(&cnic_lock);
                 }
 
                 rcu_read_lock();
@@ -2668,10 +2733,9 @@ static int cnic_netdev_event(struct notifier_block *this, unsigned long event,
                 rcu_read_unlock();
 
                 if (event == NETDEV_GOING_DOWN) {
-                        mutex_lock(&cnic_lock);
                         cnic_ulp_stop(dev);
                         cnic_stop_hw(dev);
-                        mutex_unlock(&cnic_lock);
+                        cnic_unregister_netdev(dev);
                 } else if (event == NETDEV_UNREGISTER) {
                         write_lock(&cnic_dev_lock);
                         list_del_init(&dev->list);
@@ -2703,6 +2767,7 @@ static void cnic_release(void)
                 }
 
                 cnic_ulp_exit(dev);
+                cnic_unregister_netdev(dev);
                 list_del_init(&dev->list);
                 cnic_free_dev(dev);
         }
diff --git a/drivers/net/cnic.h b/drivers/net/cnic.h
index 5192d4a9df5a..a94b302bb464 100644
--- a/drivers/net/cnic.h
+++ b/drivers/net/cnic.h
@@ -176,6 +176,7 @@ struct cnic_local {
         unsigned long ulp_flags[MAX_CNIC_ULP_TYPE];
 #define ULP_F_INIT      0
 #define ULP_F_START     1
+#define ULP_F_CALL_PENDING      2
         struct cnic_ulp_ops *ulp_ops[MAX_CNIC_ULP_TYPE];
 
         /* protected by ulp_lock */
diff --git a/drivers/net/cnic_if.h b/drivers/net/cnic_if.h
index d1bce27ee99e..a49235739eef 100644
--- a/drivers/net/cnic_if.h
+++ b/drivers/net/cnic_if.h
@@ -290,6 +290,7 @@ struct cnic_ulp_ops {
         void (*iscsi_nl_send_msg)(struct cnic_dev *dev, u32 msg_type,
                                   char *data, u16 data_size);
         struct module *owner;
+        atomic_t ref_count;
 };
 
 extern int cnic_register_driver(int ulp_type, struct cnic_ulp_ops *ulp_ops);
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 63415bb6f48f..fa92a683aefd 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -4538,8 +4538,7 @@ static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
                 /* Allow time for pending master requests to run */
                 e1000e_disable_pcie_master(&adapter->hw);
 
-                if ((adapter->flags2 & FLAG2_HAS_PHY_WAKEUP) &&
-                    !(hw->mac.ops.check_mng_mode(hw))) {
+                if (adapter->flags2 & FLAG2_HAS_PHY_WAKEUP) {
                         /* enable wakeup by the PHY */
                         retval = e1000_init_phy_wakeup(adapter, wufc);
                         if (retval)
@@ -4557,7 +4556,8 @@ static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
         *enable_wake = !!wufc;
 
         /* make sure adapter isn't asleep if manageability is enabled */
-        if (adapter->flags & FLAG_MNG_PT_ENABLED)
+        if ((adapter->flags & FLAG_MNG_PT_ENABLED) ||
+            (hw->mac.ops.check_mng_mode(hw)))
                 *enable_wake = true;
 
         if (adapter->hw.phy.type == e1000_phy_igp_3)
@@ -4670,14 +4670,6 @@ static int e1000_resume(struct pci_dev *pdev)
                 return err;
         }
 
-        /* AER (Advanced Error Reporting) hooks */
-        err = pci_enable_pcie_error_reporting(pdev);
-        if (err) {
-                dev_err(&pdev->dev, "pci_enable_pcie_error_reporting failed "
-                                    "0x%x\n", err);
-                /* non-fatal, continue */
-        }
-
         pci_set_master(pdev);
 
         pci_enable_wake(pdev, PCI_D3hot, 0);
@@ -4990,6 +4982,14 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
         if (err)
                 goto err_pci_reg;
 
+        /* AER (Advanced Error Reporting) hooks */
+        err = pci_enable_pcie_error_reporting(pdev);
+        if (err) {
+                dev_err(&pdev->dev, "pci_enable_pcie_error_reporting failed "
+                        "0x%x\n", err);
+                /* non-fatal, continue */
+        }
+
         pci_set_master(pdev);
         /* PCI config space info */
         err = pci_save_state(pdev);
diff --git a/include/linux/gen_stats.h b/include/linux/gen_stats.h
index 0ffa41df0ee8..710e901085d0 100644
--- a/include/linux/gen_stats.h
+++ b/include/linux/gen_stats.h
@@ -22,6 +22,11 @@ struct gnet_stats_basic
 {
         __u64   bytes;
         __u32   packets;
+};
+struct gnet_stats_basic_packed
+{
+        __u64   bytes;
+        __u32   packets;
 } __attribute__ ((packed));
 
 /**
diff --git a/include/net/act_api.h b/include/net/act_api.h
index 565eed8fe496..c05fd717c588 100644
--- a/include/net/act_api.h
+++ b/include/net/act_api.h
@@ -16,7 +16,7 @@ struct tcf_common {
         u32                             tcfc_capab;
         int                             tcfc_action;
         struct tcf_t                    tcfc_tm;
-        struct gnet_stats_basic         tcfc_bstats;
+        struct gnet_stats_basic_packed  tcfc_bstats;
         struct gnet_stats_queue         tcfc_qstats;
         struct gnet_stats_rate_est      tcfc_rate_est;
         spinlock_t                      tcfc_lock;
diff --git a/include/net/gen_stats.h b/include/net/gen_stats.h
index d136b5240ef2..c1488553e349 100644
--- a/include/net/gen_stats.h
+++ b/include/net/gen_stats.h
@@ -28,7 +28,7 @@ extern int gnet_stats_start_copy_compat(struct sk_buff *skb, int type,
                                         spinlock_t *lock, struct gnet_dump *d);
 
 extern int gnet_stats_copy_basic(struct gnet_dump *d,
-                                 struct gnet_stats_basic *b);
+                                 struct gnet_stats_basic_packed *b);
 extern int gnet_stats_copy_rate_est(struct gnet_dump *d,
                                     struct gnet_stats_rate_est *r);
 extern int gnet_stats_copy_queue(struct gnet_dump *d,
@@ -37,14 +37,14 @@ extern int gnet_stats_copy_app(struct gnet_dump *d, void *st, int len);
 
 extern int gnet_stats_finish_copy(struct gnet_dump *d);
 
-extern int gen_new_estimator(struct gnet_stats_basic *bstats,
+extern int gen_new_estimator(struct gnet_stats_basic_packed *bstats,
                              struct gnet_stats_rate_est *rate_est,
                              spinlock_t *stats_lock, struct nlattr *opt);
-extern void gen_kill_estimator(struct gnet_stats_basic *bstats,
+extern void gen_kill_estimator(struct gnet_stats_basic_packed *bstats,
                                struct gnet_stats_rate_est *rate_est);
-extern int gen_replace_estimator(struct gnet_stats_basic *bstats,
+extern int gen_replace_estimator(struct gnet_stats_basic_packed *bstats,
                                  struct gnet_stats_rate_est *rate_est,
                                  spinlock_t *stats_lock, struct nlattr *opt);
-extern bool gen_estimator_active(const struct gnet_stats_basic *bstats,
+extern bool gen_estimator_active(const struct gnet_stats_basic_packed *bstats,
                                  const struct gnet_stats_rate_est *rate_est);
 #endif
diff --git a/include/net/netfilter/xt_rateest.h b/include/net/netfilter/xt_rateest.h
index 65d594dffbff..ddbf37e19616 100644
--- a/include/net/netfilter/xt_rateest.h
+++ b/include/net/netfilter/xt_rateest.h
@@ -8,7 +8,7 @@ struct xt_rateest {
         spinlock_t                      lock;
         struct gnet_estimator           params;
         struct gnet_stats_rate_est      rstats;
-        struct gnet_stats_basic         bstats;
+        struct gnet_stats_basic_packed  bstats;
 };
 
 extern struct xt_rateest *xt_rateest_lookup(const char *name);
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 964ffa0d8815..5482e9582f55 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -72,7 +72,7 @@ struct Qdisc
          */
         unsigned long           state;
         struct sk_buff_head     q;
-        struct gnet_stats_basic bstats;
+        struct gnet_stats_basic_packed bstats;
         struct gnet_stats_queue qstats;
 };
 
diff --git a/net/core/gen_estimator.c b/net/core/gen_estimator.c
index 78e5bfc454ae..493775f4f2f1 100644
--- a/net/core/gen_estimator.c
+++ b/net/core/gen_estimator.c
@@ -81,7 +81,7 @@
 struct gen_estimator
 {
         struct list_head        list;
-        struct gnet_stats_basic *bstats;
+        struct gnet_stats_basic_packed  *bstats;
         struct gnet_stats_rate_est      *rate_est;
         spinlock_t              *stats_lock;
         int                     ewma_log;
@@ -165,7 +165,7 @@ static void gen_add_node(struct gen_estimator *est)
 }
 
 static
-struct gen_estimator *gen_find_node(const struct gnet_stats_basic *bstats,
+struct gen_estimator *gen_find_node(const struct gnet_stats_basic_packed *bstats,
                                     const struct gnet_stats_rate_est *rate_est)
 {
         struct rb_node *p = est_root.rb_node;
@@ -202,7 +202,7 @@ struct gen_estimator *gen_find_node(const struct gnet_stats_basic *bstats,
  *
  * NOTE: Called under rtnl_mutex
  */
-int gen_new_estimator(struct gnet_stats_basic *bstats,
+int gen_new_estimator(struct gnet_stats_basic_packed *bstats,
                       struct gnet_stats_rate_est *rate_est,
                       spinlock_t *stats_lock,
                       struct nlattr *opt)
@@ -262,7 +262,7 @@ static void __gen_kill_estimator(struct rcu_head *head)
  *
  * NOTE: Called under rtnl_mutex
  */
-void gen_kill_estimator(struct gnet_stats_basic *bstats,
+void gen_kill_estimator(struct gnet_stats_basic_packed *bstats,
                         struct gnet_stats_rate_est *rate_est)
 {
         struct gen_estimator *e;
@@ -292,7 +292,7 @@ EXPORT_SYMBOL(gen_kill_estimator);
  *
  * Returns 0 on success or a negative error code.
  */
-int gen_replace_estimator(struct gnet_stats_basic *bstats,
+int gen_replace_estimator(struct gnet_stats_basic_packed *bstats,
                           struct gnet_stats_rate_est *rate_est,
                           spinlock_t *stats_lock, struct nlattr *opt)
 {
@@ -308,7 +308,7 @@ EXPORT_SYMBOL(gen_replace_estimator);
  *
  * Returns true if estimator is active, and false if not.
  */
-bool gen_estimator_active(const struct gnet_stats_basic *bstats,
+bool gen_estimator_active(const struct gnet_stats_basic_packed *bstats,
                           const struct gnet_stats_rate_est *rate_est)
 {
         ASSERT_RTNL();
diff --git a/net/core/gen_stats.c b/net/core/gen_stats.c
index c3d0ffeac243..8569310268ab 100644
--- a/net/core/gen_stats.c
+++ b/net/core/gen_stats.c
@@ -106,16 +106,21 @@ gnet_stats_start_copy(struct sk_buff *skb, int type, spinlock_t *lock,
  * if the room in the socket buffer was not sufficient.
  */
 int
-gnet_stats_copy_basic(struct gnet_dump *d, struct gnet_stats_basic *b)
+gnet_stats_copy_basic(struct gnet_dump *d, struct gnet_stats_basic_packed *b)
 {
         if (d->compat_tc_stats) {
                 d->tc_stats.bytes = b->bytes;
                 d->tc_stats.packets = b->packets;
         }
 
-        if (d->tail)
-                return gnet_stats_copy(d, TCA_STATS_BASIC, b, sizeof(*b));
+        if (d->tail) {
+                struct gnet_stats_basic sb;
 
+                memset(&sb, 0, sizeof(sb));
+                sb.bytes = b->bytes;
+                sb.packets = b->packets;
+                return gnet_stats_copy(d, TCA_STATS_BASIC, &sb, sizeof(sb));
+        }
         return 0;
 }
 
diff --git a/net/netfilter/xt_RATEEST.c b/net/netfilter/xt_RATEEST.c
index 43f5676b1af4..d80b8192e0d4 100644
--- a/net/netfilter/xt_RATEEST.c
+++ b/net/netfilter/xt_RATEEST.c
@@ -74,7 +74,7 @@ static unsigned int
 xt_rateest_tg(struct sk_buff *skb, const struct xt_target_param *par)
 {
         const struct xt_rateest_target_info *info = par->targinfo;
-        struct gnet_stats_basic *stats = &info->est->bstats;
+        struct gnet_stats_basic_packed *stats = &info->est->bstats;
 
         spin_lock_bh(&info->est->lock);
         stats->bytes += skb->len;
diff --git a/net/netrom/nr_route.c b/net/netrom/nr_route.c
index e943c16552a2..4eb1ac9a7679 100644
--- a/net/netrom/nr_route.c
+++ b/net/netrom/nr_route.c
@@ -630,23 +630,23 @@ out:
         return dev;
 }
 
-static ax25_digi *nr_call_to_digi(int ndigis, ax25_address *digipeaters)
+static ax25_digi *nr_call_to_digi(ax25_digi *digi, int ndigis,
+        ax25_address *digipeaters)
 {
-        static ax25_digi ax25_digi;
         int i;
 
         if (ndigis == 0)
                 return NULL;
 
         for (i = 0; i < ndigis; i++) {
-                ax25_digi.calls[i]    = digipeaters[i];
-                ax25_digi.repeated[i] = 0;
+                digi->calls[i]    = digipeaters[i];
+                digi->repeated[i] = 0;
         }
 
-        ax25_digi.ndigi      = ndigis;
-        ax25_digi.lastrepeat = -1;
+        digi->ndigi      = ndigis;
+        digi->lastrepeat = -1;
 
-        return &ax25_digi;
+        return digi;
 }
 
 /*
@@ -656,6 +656,7 @@ int nr_rt_ioctl(unsigned int cmd, void __user *arg)
 {
         struct nr_route_struct nr_route;
         struct net_device *dev;
+        ax25_digi digi;
         int ret;
 
         switch (cmd) {
@@ -673,13 +674,15 @@ int nr_rt_ioctl(unsigned int cmd, void __user *arg)
                         ret = nr_add_node(&nr_route.callsign,
                                 nr_route.mnemonic,
                                 &nr_route.neighbour,
-                                nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
+                                nr_call_to_digi(&digi, nr_route.ndigis,
+                                                nr_route.digipeaters),
                                 dev, nr_route.quality,
                                 nr_route.obs_count);
                         break;
                 case NETROM_NEIGH:
                         ret = nr_add_neigh(&nr_route.callsign,
-                                nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
+                                nr_call_to_digi(&digi, nr_route.ndigis,
+                                                nr_route.digipeaters),
                                 dev, nr_route.quality);
                         break;
                 default:
diff --git a/net/sched/sch_atm.c b/net/sched/sch_atm.c
index 2a8b83af7c47..ab82f145f689 100644
--- a/net/sched/sch_atm.c
+++ b/net/sched/sch_atm.c
@@ -49,7 +49,7 @@ struct atm_flow_data {
         struct socket           *sock;          /* for closing */
         u32                     classid;        /* x:y type ID */
         int                     ref;            /* reference count */
-        struct gnet_stats_basic bstats;
+        struct gnet_stats_basic_packed  bstats;
         struct gnet_stats_queue qstats;
         struct atm_flow_data    *next;
         struct atm_flow_data    *excess;        /* flow for excess traffic;
diff --git a/net/sched/sch_cbq.c b/net/sched/sch_cbq.c
index 23a167670fd5..d5798e17a832 100644
--- a/net/sched/sch_cbq.c
+++ b/net/sched/sch_cbq.c
@@ -128,7 +128,7 @@ struct cbq_class
         long                    avgidle;
         long                    deficit;        /* Saved deficit for WRR */
         psched_time_t           penalized;
-        struct gnet_stats_basic bstats;
+        struct gnet_stats_basic_packed bstats;
         struct gnet_stats_queue qstats;
         struct gnet_stats_rate_est rate_est;
         struct tc_cbq_xstats    xstats;
diff --git a/net/sched/sch_drr.c b/net/sched/sch_drr.c
index 7597fe146866..12b2fb04b29b 100644
--- a/net/sched/sch_drr.c
+++ b/net/sched/sch_drr.c
@@ -22,7 +22,7 @@ struct drr_class {
         unsigned int                    refcnt;
         unsigned int                    filter_cnt;
 
-        struct gnet_stats_basic         bstats;
+        struct gnet_stats_basic_packed          bstats;
         struct gnet_stats_queue         qstats;
         struct gnet_stats_rate_est      rate_est;
         struct list_head                alist;
diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 362c2811b2df..dad0144423da 100644
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -116,7 +116,7 @@ struct hfsc_class
         struct Qdisc_class_common cl_common;
         unsigned int    refcnt;         /* usage count */
 
-        struct gnet_stats_basic bstats;
+        struct gnet_stats_basic_packed bstats;
         struct gnet_stats_queue qstats;
         struct gnet_stats_rate_est rate_est;
         unsigned int    level;          /* class level in hierarchy */
diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index 88cd02626621..ec4d46399d59 100644
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -74,7 +74,7 @@ enum htb_cmode {
 struct htb_class {
         struct Qdisc_class_common common;
         /* general class parameters */
-        struct gnet_stats_basic bstats;
+        struct gnet_stats_basic_packed bstats;
         struct gnet_stats_queue qstats;
         struct gnet_stats_rate_est rate_est;
         struct tc_htb_xstats xstats;    /* our special stats */