Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: (28 commits)
  ipheth: remove incorrect devtype to WWAN
  MAINTAINERS: Add CAIF
  sctp: fix test for end of loop
  KS8851: Correct RX packet allocation
  udp: add rehash on connect()
  net: blackhole route should always be recalculated
  ipv4: Suppress lockdep-RCU false positive in FIB trie (3)
  niu: Fix kernel buffer overflow for ETHTOOL_GRXCLSRLALL
  ipvs: fix active FTP
  gro: Re-fix different skb headrooms
  via-velocity: Turn scatter-gather support back off.
  ipv4: Fix reverse path filtering with multipath routing.
  UNIX: Do not loop forever at unix_autobind().
  PATCH: b44 Handle RX FIFO overflow better (simplified)
  irda: off by one
  3c59x: Fix deadlock in vortex_error()
  netfilter: discard overlapping IPv6 fragment
  ipv6: discard overlapping fragment
  net: fix tx queue selection for bridged devices implementing select_queue
  bonding: Fix jiffies overflow problems (again)
  ...

Fix up trivial conflicts due to the same cgroup API thinko fix going
through both Andrew and the networking tree.  However, there were small
differences between the two, with Andrew's version generally being the
nicer one, and the one I merged first. So pick that one.

Conflicts in: include/linux/cgroup.h and kernel/cgroup.c

15 files changed, 176 insertions, 118 deletions

diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index a045559c81cf..85671adae455 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -1994,10 +1994,9 @@ vortex_error(struct net_device *dev, int status)
                 }
         }
 
-        if (status & RxEarly) {                         /* Rx early is unused. */
-                vortex_rx(dev);
+        if (status & RxEarly)                           /* Rx early is unused. */
                 iowrite16(AckIntr | RxEarly, ioaddr + EL3_CMD);
-        }
+
         if (status & StatsFull) {                       /* Empty statistics. */
                 static int DoneDidThat;
                 if (vortex_debug > 4)
@@ -2298,7 +2297,12 @@ vortex_interrupt(int irq, void *dev_id)
                 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq)) {
                         if (status == 0xffff)
                                 break;
+                        if (status & RxEarly)
+                                vortex_rx(dev);
+                        spin_unlock(&vp->window_lock);
                         vortex_error(dev, status);
+                        spin_lock(&vp->window_lock);
+                        window_set(vp, 7);
                 }
 
                 if (--work_done < 0) {
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 37617abc1647..1e620e287ae0 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -848,6 +848,15 @@ static int b44_poll(struct napi_struct *napi, int budget)
                 b44_tx(bp);
                 /* spin_unlock(&bp->tx_lock); */
         }
+        if (bp->istat & ISTAT_RFO) {    /* fast recovery, in ~20msec */
+                bp->istat &= ~ISTAT_RFO;
+                b44_disable_ints(bp);
+                ssb_device_enable(bp->sdev, 0); /* resets ISTAT_RFO */
+                b44_init_rings(bp);
+                b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
+                netif_wake_queue(bp->dev);
+        }
+
         spin_unlock_irqrestore(&bp->lock, flags);
 
         work_done = 0;
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 99197bd54da5..53306bf3f401 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -181,6 +181,7 @@ struct be_drvr_stats {
         u64 be_rx_bytes_prev;
         u64 be_rx_pkts;
         u32 be_rx_rate;
+        u32 be_rx_mcast_pkt;
         /* number of non ether type II frames dropped where
          * frame len > length field of Mac Hdr */
         u32 be_802_3_dropped_frames;
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index 3d305494a606..34abcc9403d6 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -140,10 +140,8 @@ int be_process_mcc(struct be_adapter *adapter, int *status)
         while ((compl = be_mcc_compl_get(adapter))) {
                 if (compl->flags & CQE_FLAGS_ASYNC_MASK) {
                         /* Interpret flags as an async trailer */
-                        BUG_ON(!is_link_state_evt(compl->flags));
-
-                        /* Interpret compl as a async link evt */
-                        be_async_link_state_process(adapter,
+                        if (is_link_state_evt(compl->flags))
+                                be_async_link_state_process(adapter,
                                 (struct be_async_event_link_state *) compl);
                 } else if (compl->flags & CQE_FLAGS_COMPLETED_MASK) {
                                 *status = be_mcc_compl_process(adapter, compl);
@@ -207,7 +205,7 @@ static int be_mbox_db_ready_wait(struct be_adapter *adapter, void __iomem *db)
 
                 if (msecs > 4000) {
                         dev_err(&adapter->pdev->dev, "mbox poll timed out\n");
-                        be_dump_ue(adapter);
+                        be_detect_dump_ue(adapter);
                         return -1;
                 }
 
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h
index bdc10a28cfda..ad1e6fac60c5 100644
--- a/drivers/net/benet/be_cmds.h
+++ b/drivers/net/benet/be_cmds.h
@@ -992,5 +992,5 @@ extern int be_cmd_set_loopback(struct be_adapter *adapter, u8 port_num,
 extern int be_cmd_get_phy_info(struct be_adapter *adapter,
                 struct be_dma_mem *cmd);
 extern int be_cmd_set_qos(struct be_adapter *adapter, u32 bps, u32 domain);
-extern void be_dump_ue(struct be_adapter *adapter);
+extern void be_detect_dump_ue(struct be_adapter *adapter);
 
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c
index cd16243c7c36..13f0abbc5205 100644
--- a/drivers/net/benet/be_ethtool.c
+++ b/drivers/net/benet/be_ethtool.c
@@ -60,6 +60,7 @@ static const struct be_ethtool_stat et_stats[] = {
         {DRVSTAT_INFO(be_rx_events)},
         {DRVSTAT_INFO(be_tx_compl)},
         {DRVSTAT_INFO(be_rx_compl)},
+        {DRVSTAT_INFO(be_rx_mcast_pkt)},
         {DRVSTAT_INFO(be_ethrx_post_fail)},
         {DRVSTAT_INFO(be_802_3_dropped_frames)},
         {DRVSTAT_INFO(be_802_3_malformed_frames)},
diff --git a/drivers/net/benet/be_hw.h b/drivers/net/benet/be_hw.h
index 5d38046402b2..a2ec5df0d733 100644
--- a/drivers/net/benet/be_hw.h
+++ b/drivers/net/benet/be_hw.h
@@ -167,8 +167,11 @@
 #define FLASH_FCoE_BIOS_START_g3           (13631488)
 #define FLASH_REDBOOT_START_g3             (262144)
 
-
-
+/************* Rx Packet Type Encoding **************/
+#define BE_UNICAST_PACKET               0
+#define BE_MULTICAST_PACKET             1
+#define BE_BROADCAST_PACKET             2
+#define BE_RSVD_PACKET                  3
 
 /*
  * BE descriptors: host memory data structures whose formats
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 74e146f470c6..6eda7a022256 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -247,6 +247,7 @@ void netdev_stats_update(struct be_adapter *adapter)
         dev_stats->tx_packets = drvr_stats(adapter)->be_tx_pkts;
         dev_stats->rx_bytes = drvr_stats(adapter)->be_rx_bytes;
         dev_stats->tx_bytes = drvr_stats(adapter)->be_tx_bytes;
+        dev_stats->multicast = drvr_stats(adapter)->be_rx_mcast_pkt;
 
         /* bad pkts received */
         dev_stats->rx_errors = port_stats->rx_crc_errors +
@@ -294,7 +295,6 @@ void netdev_stats_update(struct be_adapter *adapter)
         /* no space available in linux */
         dev_stats->tx_dropped = 0;
 
-        dev_stats->multicast = port_stats->rx_multicast_frames;
         dev_stats->collisions = 0;
 
         /* detailed tx_errors */
@@ -848,7 +848,7 @@ static void be_rx_rate_update(struct be_adapter *adapter)
 }
 
 static void be_rx_stats_update(struct be_adapter *adapter,
-                u32 pktsize, u16 numfrags)
+                u32 pktsize, u16 numfrags, u8 pkt_type)
 {
         struct be_drvr_stats *stats = drvr_stats(adapter);
 
@@ -856,6 +856,9 @@ static void be_rx_stats_update(struct be_adapter *adapter,
         stats->be_rx_frags += numfrags;
         stats->be_rx_bytes += pktsize;
         stats->be_rx_pkts++;
+
+        if (pkt_type == BE_MULTICAST_PACKET)
+                stats->be_rx_mcast_pkt++;
 }
 
 static inline bool do_pkt_csum(struct be_eth_rx_compl *rxcp, bool cso)
@@ -925,9 +928,11 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
         u16 rxq_idx, i, j;
         u32 pktsize, hdr_len, curr_frag_len, size;
         u8 *start;
+        u8 pkt_type;
 
         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
         pktsize = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
+        pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
 
         page_info = get_rx_page_info(adapter, rxq_idx);
 
@@ -993,7 +998,7 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
         BUG_ON(j > MAX_SKB_FRAGS);
 
 done:
-        be_rx_stats_update(adapter, pktsize, num_rcvd);
+        be_rx_stats_update(adapter, pktsize, num_rcvd, pkt_type);
 }
 
 /* Process the RX completion indicated by rxcp when GRO is disabled */
@@ -1060,6 +1065,7 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
         u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len;
         u16 i, rxq_idx = 0, vid, j;
         u8 vtm;
+        u8 pkt_type;
 
         num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
         /* Is it a flush compl that has no data */
@@ -1070,6 +1076,7 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
         vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
         vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
+        pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
 
         /* vlanf could be wrongly set in some cards.
          * ignore if vtm is not set */
@@ -1125,7 +1132,7 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
                 vlan_gro_frags(&eq_obj->napi, adapter->vlan_grp, vid);
         }
 
-        be_rx_stats_update(adapter, pkt_size, num_rcvd);
+        be_rx_stats_update(adapter, pkt_size, num_rcvd, pkt_type);
 }
 
 static struct be_eth_rx_compl *be_rx_compl_get(struct be_adapter *adapter)
@@ -1743,26 +1750,7 @@ static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
         return 1;
 }
 
-static inline bool be_detect_ue(struct be_adapter *adapter)
-{
-        u32 online0 = 0, online1 = 0;
-
-        pci_read_config_dword(adapter->pdev, PCICFG_ONLINE0, &online0);
-
-        pci_read_config_dword(adapter->pdev, PCICFG_ONLINE1, &online1);
-
-        if (!online0 || !online1) {
-                adapter->ue_detected = true;
-                dev_err(&adapter->pdev->dev,
-                        "UE Detected!! online0=%d online1=%d\n",
-                        online0, online1);
-                return true;
-        }
-
-        return false;
-}
-
-void be_dump_ue(struct be_adapter *adapter)
+void be_detect_dump_ue(struct be_adapter *adapter)
 {
         u32 ue_status_lo, ue_status_hi, ue_status_lo_mask, ue_status_hi_mask;
         u32 i;
@@ -1779,6 +1767,11 @@ void be_dump_ue(struct be_adapter *adapter)
         ue_status_lo = (ue_status_lo & (~ue_status_lo_mask));
         ue_status_hi = (ue_status_hi & (~ue_status_hi_mask));
 
+        if (ue_status_lo || ue_status_hi) {
+                adapter->ue_detected = true;
+                dev_err(&adapter->pdev->dev, "UE Detected!!\n");
+        }
+
         if (ue_status_lo) {
                 for (i = 0; ue_status_lo; ue_status_lo >>= 1, i++) {
                         if (ue_status_lo & 1)
@@ -1814,10 +1807,8 @@ static void be_worker(struct work_struct *work)
                 adapter->rx_post_starved = false;
                 be_post_rx_frags(adapter);
         }
-        if (!adapter->ue_detected) {
-                if (be_detect_ue(adapter))
-                        be_dump_ue(adapter);
-        }
+        if (!adapter->ue_detected)
+                be_detect_dump_ue(adapter);
 
         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
 }
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 2cc4cfc31892..3b16f62d5606 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -2797,9 +2797,15 @@ void bond_loadbalance_arp_mon(struct work_struct *work)
          *       so it can wait
          */
         bond_for_each_slave(bond, slave, i) {
+                unsigned long trans_start = dev_trans_start(slave->dev);
+
                 if (slave->link != BOND_LINK_UP) {
-                        if (time_before_eq(jiffies, dev_trans_start(slave->dev) + delta_in_ticks) &&
-                            time_before_eq(jiffies, slave->dev->last_rx + delta_in_ticks)) {
+                        if (time_in_range(jiffies,
+                                trans_start - delta_in_ticks,
+                                trans_start + delta_in_ticks) &&
+                            time_in_range(jiffies,
+                                slave->dev->last_rx - delta_in_ticks,
+                                slave->dev->last_rx + delta_in_ticks)) {
 
                                 slave->link  = BOND_LINK_UP;
                                 slave->state = BOND_STATE_ACTIVE;
@@ -2827,8 +2833,12 @@ void bond_loadbalance_arp_mon(struct work_struct *work)
                          * when the source ip is 0, so don't take the link down
                          * if we don't know our ip yet
                          */
-                        if (time_after_eq(jiffies, dev_trans_start(slave->dev) + 2*delta_in_ticks) ||
-                            (time_after_eq(jiffies, slave->dev->last_rx + 2*delta_in_ticks))) {
+                        if (!time_in_range(jiffies,
+                                trans_start - delta_in_ticks,
+                                trans_start + 2 * delta_in_ticks) ||
+                            !time_in_range(jiffies,
+                                slave->dev->last_rx - delta_in_ticks,
+                                slave->dev->last_rx + 2 * delta_in_ticks)) {
 
                                 slave->link  = BOND_LINK_DOWN;
                                 slave->state = BOND_STATE_BACKUP;
@@ -2883,13 +2893,16 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
 {
         struct slave *slave;
         int i, commit = 0;
+        unsigned long trans_start;
 
         bond_for_each_slave(bond, slave, i) {
                 slave->new_link = BOND_LINK_NOCHANGE;
 
                 if (slave->link != BOND_LINK_UP) {
-                        if (time_before_eq(jiffies, slave_last_rx(bond, slave) +
-                                           delta_in_ticks)) {
+                        if (time_in_range(jiffies,
+                                slave_last_rx(bond, slave) - delta_in_ticks,
+                                slave_last_rx(bond, slave) + delta_in_ticks)) {
+
                                 slave->new_link = BOND_LINK_UP;
                                 commit++;
                         }
@@ -2902,8 +2915,9 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
                  * active.  This avoids bouncing, as the last receive
                  * times need a full ARP monitor cycle to be updated.
                  */
-                if (!time_after_eq(jiffies, slave->jiffies +
-                                   2 * delta_in_ticks))
+                if (time_in_range(jiffies,
+                                  slave->jiffies - delta_in_ticks,
+                                  slave->jiffies + 2 * delta_in_ticks))
                         continue;
 
                 /*
@@ -2921,8 +2935,10 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
                  */
                 if (slave->state == BOND_STATE_BACKUP &&
                     !bond->current_arp_slave &&
-                    time_after(jiffies, slave_last_rx(bond, slave) +
-                               3 * delta_in_ticks)) {
+                    !time_in_range(jiffies,
+                        slave_last_rx(bond, slave) - delta_in_ticks,
+                        slave_last_rx(bond, slave) + 3 * delta_in_ticks)) {
+
                         slave->new_link = BOND_LINK_DOWN;
                         commit++;
                 }
@@ -2933,11 +2949,15 @@ static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks)
                  * - (more than 2*delta since receive AND
                  *    the bond has an IP address)
                  */
+                trans_start = dev_trans_start(slave->dev);
                 if ((slave->state == BOND_STATE_ACTIVE) &&
-                    (time_after_eq(jiffies, dev_trans_start(slave->dev) +
-                                    2 * delta_in_ticks) ||
-                      (time_after_eq(jiffies, slave_last_rx(bond, slave)
-                                     + 2 * delta_in_ticks)))) {
+                    (!time_in_range(jiffies,
+                        trans_start - delta_in_ticks,
+                        trans_start + 2 * delta_in_ticks) ||
+                     !time_in_range(jiffies,
+                        slave_last_rx(bond, slave) - delta_in_ticks,
+                        slave_last_rx(bond, slave) + 2 * delta_in_ticks))) {
+
                         slave->new_link = BOND_LINK_DOWN;
                         commit++;
                 }
@@ -2956,6 +2976,7 @@ static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks)
 {
         struct slave *slave;
         int i;
+        unsigned long trans_start;
 
         bond_for_each_slave(bond, slave, i) {
                 switch (slave->new_link) {
@@ -2963,10 +2984,11 @@ static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks)
                         continue;
 
                 case BOND_LINK_UP:
+                        trans_start = dev_trans_start(slave->dev);
                         if ((!bond->curr_active_slave &&
-                             time_before_eq(jiffies,
-                                            dev_trans_start(slave->dev) +
-                                            delta_in_ticks)) ||
+                             time_in_range(jiffies,
+                                           trans_start - delta_in_ticks,
+                                           trans_start + delta_in_ticks)) ||
                             bond->curr_active_slave != slave) {
                                 slave->link = BOND_LINK_UP;
                                 bond->current_arp_slave = NULL;
diff --git a/drivers/net/ks8851.c b/drivers/net/ks8851.c
index b4fb07a6f13f..51919fcd50c2 100644
--- a/drivers/net/ks8851.c
+++ b/drivers/net/ks8851.c
@@ -503,30 +503,33 @@ static void ks8851_rx_pkts(struct ks8851_net *ks)
                 ks8851_wrreg16(ks, KS_RXQCR,
                                ks->rc_rxqcr | RXQCR_SDA | RXQCR_ADRFE);
 
-                if (rxlen > 0) {
-                        skb = netdev_alloc_skb(ks->netdev, rxlen + 2 + 8);
-                        if (!skb) {
-                                /* todo - dump frame and move on */
-                        }
+                if (rxlen > 4) {
+                        unsigned int rxalign;
+
+                        rxlen -= 4;
+                        rxalign = ALIGN(rxlen, 4);
+                        skb = netdev_alloc_skb_ip_align(ks->netdev, rxalign);
+                        if (skb) {
 
-                        /* two bytes to ensure ip is aligned, and four bytes
-                         * for the status header and 4 bytes of garbage */
-                        skb_reserve(skb, 2 + 4 + 4);
+                                /* 4 bytes of status header + 4 bytes of
+                                 * garbage: we put them before ethernet
+                                 * header, so that they are copied,
+                                 * but ignored.
+                                 */
 
-                        rxpkt = skb_put(skb, rxlen - 4) - 8;
+                                rxpkt = skb_put(skb, rxlen) - 8;
 
-                        /* align the packet length to 4 bytes, and add 4 bytes
-                         * as we're getting the rx status header as well */
-                        ks8851_rdfifo(ks, rxpkt, ALIGN(rxlen, 4) + 8);
+                                ks8851_rdfifo(ks, rxpkt, rxalign + 8);
 
-                        if (netif_msg_pktdata(ks))
-                                ks8851_dbg_dumpkkt(ks, rxpkt);
+                                if (netif_msg_pktdata(ks))
+                                        ks8851_dbg_dumpkkt(ks, rxpkt);
 
-                        skb->protocol = eth_type_trans(skb, ks->netdev);
-                        netif_rx(skb);
+                                skb->protocol = eth_type_trans(skb, ks->netdev);
+                                netif_rx(skb);
 
-                        ks->netdev->stats.rx_packets++;
-                        ks->netdev->stats.rx_bytes += rxlen - 4;
+                                ks->netdev->stats.rx_packets++;
+                                ks->netdev->stats.rx_bytes += rxlen;
+                        }
                 }
 
                 ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index bc695d53cdcc..fe6983af6918 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -7269,32 +7269,28 @@ static int niu_get_ethtool_tcam_all(struct niu *np,
         struct niu_parent *parent = np->parent;
         struct niu_tcam_entry *tp;
         int i, idx, cnt;
-        u16 n_entries;
         unsigned long flags;
-
+        int ret = 0;
 
         /* put the tcam size here */
         nfc->data = tcam_get_size(np);
 
         niu_lock_parent(np, flags);
-        n_entries = nfc->rule_cnt;
         for (cnt = 0, i = 0; i < nfc->data; i++) {
                 idx = tcam_get_index(np, i);
                 tp = &parent->tcam[idx];
                 if (!tp->valid)
                         continue;
+                if (cnt == nfc->rule_cnt) {
+                        ret = -EMSGSIZE;
+                        break;
+                }
                 rule_locs[cnt] = i;
                 cnt++;
         }
         niu_unlock_parent(np, flags);
 
-        if (n_entries != cnt) {
-                /* print warning, this should not happen */
-                netdev_info(np->dev, "niu%d: In %s(): n_entries[%d] != cnt[%d]!!!\n",
-                            np->parent->index, __func__, n_entries, cnt);
-        }
-
-        return 0;
+        return ret;
 }
 
 static int niu_get_nfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
diff --git a/drivers/net/stmmac/stmmac_main.c b/drivers/net/stmmac/stmmac_main.c
index bbb7951b9c4c..ea0461eb2dbe 100644
--- a/drivers/net/stmmac/stmmac_main.c
+++ b/drivers/net/stmmac/stmmac_main.c
@@ -1865,15 +1865,15 @@ static int stmmac_resume(struct platform_device *pdev)
         if (!netif_running(dev))
                 return 0;
 
-        spin_lock(&priv->lock);
-
         if (priv->shutdown) {
                 /* Re-open the interface and re-init the MAC/DMA
-                   and the rings. */
+                   and the rings (i.e. on hibernation stage) */
                 stmmac_open(dev);
-                goto out_resume;
+                return 0;
         }
 
+        spin_lock(&priv->lock);
+
         /* Power Down bit, into the PM register, is cleared
          * automatically as soon as a magic packet or a Wake-up frame
          * is received. Anyway, it's better to manually clear
@@ -1901,7 +1901,6 @@ static int stmmac_resume(struct platform_device *pdev)
 
         netif_start_queue(dev);
 
-out_resume:
         spin_unlock(&priv->lock);
         return 0;
 }
diff --git a/drivers/net/usb/ipheth.c b/drivers/net/usb/ipheth.c
index 8ed30fa35d0a..b2bcf99e6f08 100644
--- a/drivers/net/usb/ipheth.c
+++ b/drivers/net/usb/ipheth.c
@@ -429,10 +429,6 @@ static const struct net_device_ops ipheth_netdev_ops = {
         .ndo_get_stats = &ipheth_stats,
 };
 
-static struct device_type ipheth_type = {
-        .name   = "wwan",
-};
-
 static int ipheth_probe(struct usb_interface *intf,
                         const struct usb_device_id *id)
 {
@@ -450,7 +446,7 @@ static int ipheth_probe(struct usb_interface *intf,
 
         netdev->netdev_ops = &ipheth_netdev_ops;
         netdev->watchdog_timeo = IPHETH_TX_TIMEOUT;
-        strcpy(netdev->name, "wwan%d");
+        strcpy(netdev->name, "eth%d");
 
         dev = netdev_priv(netdev);
         dev->udev = udev;
@@ -500,7 +496,6 @@ static int ipheth_probe(struct usb_interface *intf,
 
         SET_NETDEV_DEV(netdev, &intf->dev);
         SET_ETHTOOL_OPS(netdev, &ops);
-        SET_NETDEV_DEVTYPE(netdev, &ipheth_type);
 
         retval = register_netdev(netdev);
         if (retval) {
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index fd69095ef6e3..f53412368ce1 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -2824,7 +2824,7 @@ static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_devi
         netif_napi_add(dev, &vptr->napi, velocity_poll, VELOCITY_NAPI_WEIGHT);
 
         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
-                NETIF_F_HW_VLAN_RX | NETIF_F_IP_CSUM | NETIF_F_SG;
+                NETIF_F_HW_VLAN_RX | NETIF_F_IP_CSUM;
 
         ret = register_netdev(dev);
         if (ret < 0)
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index 4b99117f3ecd..c579dcc9200c 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -60,22 +60,25 @@ static int vhost_poll_wakeup(wait_queue_t *wait, unsigned mode, int sync,
         return 0;
 }
 
+static void vhost_work_init(struct vhost_work *work, vhost_work_fn_t fn)
+{
+        INIT_LIST_HEAD(&work->node);
+        work->fn = fn;
+        init_waitqueue_head(&work->done);
+        work->flushing = 0;
+        work->queue_seq = work->done_seq = 0;
+}
+
 /* Init poll structure */
 void vhost_poll_init(struct vhost_poll *poll, vhost_work_fn_t fn,
                      unsigned long mask, struct vhost_dev *dev)
 {
-        struct vhost_work *work = &poll->work;
-
         init_waitqueue_func_entry(&poll->wait, vhost_poll_wakeup);
         init_poll_funcptr(&poll->table, vhost_poll_func);
         poll->mask = mask;
         poll->dev = dev;
 
-        INIT_LIST_HEAD(&work->node);
-        work->fn = fn;
-        init_waitqueue_head(&work->done);
-        work->flushing = 0;
-        work->queue_seq = work->done_seq = 0;
+        vhost_work_init(&poll->work, fn);
 }
 
 /* Start polling a file. We add ourselves to file's wait queue. The caller must
@@ -95,35 +98,38 @@ void vhost_poll_stop(struct vhost_poll *poll)
         remove_wait_queue(poll->wqh, &poll->wait);
 }
 
-/* Flush any work that has been scheduled. When calling this, don't hold any
- * locks that are also used by the callback. */
-void vhost_poll_flush(struct vhost_poll *poll)
+static void vhost_work_flush(struct vhost_dev *dev, struct vhost_work *work)
 {
-        struct vhost_work *work = &poll->work;
         unsigned seq;
         int left;
         int flushing;
 
-        spin_lock_irq(&poll->dev->work_lock);
+        spin_lock_irq(&dev->work_lock);
         seq = work->queue_seq;
         work->flushing++;
-        spin_unlock_irq(&poll->dev->work_lock);
+        spin_unlock_irq(&dev->work_lock);
         wait_event(work->done, ({
-                   spin_lock_irq(&poll->dev->work_lock);
+                   spin_lock_irq(&dev->work_lock);
                    left = seq - work->done_seq <= 0;
-                   spin_unlock_irq(&poll->dev->work_lock);
+                   spin_unlock_irq(&dev->work_lock);
                    left;
         }));
-        spin_lock_irq(&poll->dev->work_lock);
+        spin_lock_irq(&dev->work_lock);
         flushing = --work->flushing;
-        spin_unlock_irq(&poll->dev->work_lock);
+        spin_unlock_irq(&dev->work_lock);
         BUG_ON(flushing < 0);
 }
 
-void vhost_poll_queue(struct vhost_poll *poll)
+/* Flush any work that has been scheduled. When calling this, don't hold any
+ * locks that are also used by the callback. */
+void vhost_poll_flush(struct vhost_poll *poll)
+{
+        vhost_work_flush(poll->dev, &poll->work);
+}
+
+static inline void vhost_work_queue(struct vhost_dev *dev,
+                                    struct vhost_work *work)
 {
-        struct vhost_dev *dev = poll->dev;
-        struct vhost_work *work = &poll->work;
         unsigned long flags;
 
         spin_lock_irqsave(&dev->work_lock, flags);
@@ -135,6 +141,11 @@ void vhost_poll_queue(struct vhost_poll *poll)
         spin_unlock_irqrestore(&dev->work_lock, flags);
 }
 
+void vhost_poll_queue(struct vhost_poll *poll)
+{
+        vhost_work_queue(poll->dev, &poll->work);
+}
+
 static void vhost_vq_reset(struct vhost_dev *dev,
                            struct vhost_virtqueue *vq)
 {
@@ -236,6 +247,29 @@ long vhost_dev_check_owner(struct vhost_dev *dev)
         return dev->mm == current->mm ? 0 : -EPERM;
 }
 
+struct vhost_attach_cgroups_struct {
+        struct vhost_work work;
+        struct task_struct *owner;
+        int ret;
+};
+
+static void vhost_attach_cgroups_work(struct vhost_work *work)
+{
+        struct vhost_attach_cgroups_struct *s;
+        s = container_of(work, struct vhost_attach_cgroups_struct, work);
+        s->ret = cgroup_attach_task_all(s->owner, current);
+}
+
+static int vhost_attach_cgroups(struct vhost_dev *dev)
+{
+        struct vhost_attach_cgroups_struct attach;
+        attach.owner = current;
+        vhost_work_init(&attach.work, vhost_attach_cgroups_work);
+        vhost_work_queue(dev, &attach.work);
+        vhost_work_flush(dev, &attach.work);
+        return attach.ret;
+}
+
 /* Caller should have device mutex */
 static long vhost_dev_set_owner(struct vhost_dev *dev)
 {
@@ -255,14 +289,16 @@ static long vhost_dev_set_owner(struct vhost_dev *dev)
         }
 
         dev->worker = worker;
-        err = cgroup_attach_task_current_cg(worker);
+        wake_up_process(worker);        /* avoid contributing to loadavg */
+
+        err = vhost_attach_cgroups(dev);
         if (err)
                 goto err_cgroup;
-        wake_up_process(worker);        /* avoid contributing to loadavg */
 
         return 0;
 err_cgroup:
         kthread_stop(worker);
+        dev->worker = NULL;
 err_worker:
         if (dev->mm)
                 mmput(dev->mm);