1 files changed, 267 insertions, 146 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index b715a55cccc4..308a7d0c277f 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1090,7 +1090,7 @@ int dev_open(struct net_device *dev)
                 /*
                  *      Enable NET_DMA
                  */
-                dmaengine_get();
+                net_dmaengine_get();
 
                 /*
                  *      Initialize multicasting status
@@ -1172,7 +1172,7 @@ int dev_close(struct net_device *dev)
         /*
          *      Shutdown NET_DMA
          */
-        dmaengine_put();
+        net_dmaengine_put();
 
         return 0;
 }
@@ -1336,7 +1336,12 @@ static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
 {
         struct packet_type *ptype;
 
+#ifdef CONFIG_NET_CLS_ACT
+        if (!(skb->tstamp.tv64 && (G_TC_FROM(skb->tc_verd) & AT_INGRESS)))
+                net_timestamp(skb);
+#else
         net_timestamp(skb);
+#endif
 
         rcu_read_lock();
         list_for_each_entry_rcu(ptype, &ptype_all, list) {
@@ -1430,7 +1435,7 @@ void netif_device_detach(struct net_device *dev)
 {
         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
             netif_running(dev)) {
-                netif_stop_queue(dev);
+                netif_tx_stop_all_queues(dev);
         }
 }
 EXPORT_SYMBOL(netif_device_detach);
@@ -1445,7 +1450,7 @@ void netif_device_attach(struct net_device *dev)
 {
         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
             netif_running(dev)) {
-                netif_wake_queue(dev);
+                netif_tx_wake_all_queues(dev);
                 __netdev_watchdog_up(dev);
         }
 }
@@ -1457,7 +1462,9 @@ static bool can_checksum_protocol(unsigned long features, __be16 protocol)
                 ((features & NETIF_F_IP_CSUM) &&
                  protocol == htons(ETH_P_IP)) ||
                 ((features & NETIF_F_IPV6_CSUM) &&
-                 protocol == htons(ETH_P_IPV6)));
+                 protocol == htons(ETH_P_IPV6)) ||
+                ((features & NETIF_F_FCOE_CRC) &&
+                 protocol == htons(ETH_P_FCOE)));
 }
 
 static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
@@ -1534,7 +1541,19 @@ struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
         skb->mac_len = skb->network_header - skb->mac_header;
         __skb_pull(skb, skb->mac_len);
 
-        if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
+        if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
+                struct net_device *dev = skb->dev;
+                struct ethtool_drvinfo info = {};
+
+                if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
+                        dev->ethtool_ops->get_drvinfo(dev, &info);
+
+                WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d "
+                        "ip_summed=%d",
+                     info.driver, dev ? dev->features : 0L,
+                     skb->sk ? skb->sk->sk_route_caps : 0L,
+                     skb->len, skb->data_len, skb->ip_summed);
+
                 if (skb_header_cloned(skb) &&
                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
                         return ERR_PTR(err);
@@ -1656,8 +1675,8 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                         struct netdev_queue *txq)
 {
         const struct net_device_ops *ops = dev->netdev_ops;
+        int rc;
 
-        prefetch(&dev->netdev_ops->ndo_start_xmit);
         if (likely(!skb->next)) {
                 if (!list_empty(&ptype_all))
                         dev_queue_xmit_nit(skb, dev);
@@ -1669,13 +1688,27 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                                 goto gso;
                 }
 
-                return ops->ndo_start_xmit(skb, dev);
+                rc = ops->ndo_start_xmit(skb, dev);
+                /*
+                 * TODO: if skb_orphan() was called by
+                 * dev->hard_start_xmit() (for example, the unmodified
+                 * igb driver does that; bnx2 doesn't), then
+                 * skb_tx_software_timestamp() will be unable to send
+                 * back the time stamp.
+                 *
+                 * How can this be prevented? Always create another
+                 * reference to the socket before calling
+                 * dev->hard_start_xmit()? Prevent that skb_orphan()
+                 * does anything in dev->hard_start_xmit() by clearing
+                 * the skb destructor before the call and restoring it
+                 * afterwards, then doing the skb_orphan() ourselves?
+                 */
+                return rc;
         }
 
 gso:
         do {
                 struct sk_buff *nskb = skb->next;
-                int rc;
 
                 skb->next = nskb->next;
                 nskb->next = NULL;
@@ -1696,59 +1729,24 @@ out_kfree_skb:
         return 0;
 }
 
-static u32 simple_tx_hashrnd;
-static int simple_tx_hashrnd_initialized = 0;
+static u32 skb_tx_hashrnd;
 
-static u16 simple_tx_hash(struct net_device *dev, struct sk_buff *skb)
+u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
 {
-        u32 addr1, addr2, ports;
-        u32 hash, ihl;
-        u8 ip_proto = 0;
-
-        if (unlikely(!simple_tx_hashrnd_initialized)) {
-                get_random_bytes(&simple_tx_hashrnd, 4);
-                simple_tx_hashrnd_initialized = 1;
-        }
-
-        switch (skb->protocol) {
-        case htons(ETH_P_IP):
-                if (!(ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET)))
-                        ip_proto = ip_hdr(skb)->protocol;
-                addr1 = ip_hdr(skb)->saddr;
-                addr2 = ip_hdr(skb)->daddr;
-                ihl = ip_hdr(skb)->ihl;
-                break;
-        case htons(ETH_P_IPV6):
-                ip_proto = ipv6_hdr(skb)->nexthdr;
-                addr1 = ipv6_hdr(skb)->saddr.s6_addr32[3];
-                addr2 = ipv6_hdr(skb)->daddr.s6_addr32[3];
-                ihl = (40 >> 2);
-                break;
-        default:
-                return 0;
-        }
+        u32 hash;
 
+        if (skb_rx_queue_recorded(skb)) {
+                hash = skb_get_rx_queue(skb);
+        } else if (skb->sk && skb->sk->sk_hash) {
+                hash = skb->sk->sk_hash;
+        } else
+                hash = skb->protocol;
 
-        switch (ip_proto) {
-        case IPPROTO_TCP:
-        case IPPROTO_UDP:
-        case IPPROTO_DCCP:
-        case IPPROTO_ESP:
-        case IPPROTO_AH:
-        case IPPROTO_SCTP:
-        case IPPROTO_UDPLITE:
-                ports = *((u32 *) (skb_network_header(skb) + (ihl * 4)));
-                break;
-
-        default:
-                ports = 0;
-                break;
-        }
-
-        hash = jhash_3words(addr1, addr2, ports, simple_tx_hashrnd);
+        hash = jhash_1word(hash, skb_tx_hashrnd);
 
         return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
 }
+EXPORT_SYMBOL(skb_tx_hash);
 
 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
                                         struct sk_buff *skb)
@@ -1759,7 +1757,7 @@ static struct netdev_queue *dev_pick_tx(struct net_device *dev,
         if (ops->ndo_select_queue)
                 queue_index = ops->ndo_select_queue(dev, skb);
         else if (dev->real_num_tx_queues > 1)
-                queue_index = simple_tx_hash(dev, skb);
+                queue_index = skb_tx_hash(dev, skb);
 
         skb_set_queue_mapping(skb, queue_index);
         return netdev_get_tx_queue(dev, queue_index);
@@ -2255,12 +2253,6 @@ int netif_receive_skb(struct sk_buff *skb)
 
         rcu_read_lock();
 
-        /* Don't receive packets in an exiting network namespace */
-        if (!net_alive(dev_net(skb->dev))) {
-                kfree_skb(skb);
-                goto out;
-        }
-
 #ifdef CONFIG_NET_CLS_ACT
         if (skb->tc_verd & TC_NCLS) {
                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
@@ -2291,6 +2283,8 @@ ncls:
         if (!skb)
                 goto out;
 
+        skb_orphan(skb);
+
         type = skb->protocol;
         list_for_each_entry_rcu(ptype,
                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
@@ -2339,8 +2333,10 @@ static int napi_gro_complete(struct sk_buff *skb)
         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
         int err = -ENOENT;
 
-        if (NAPI_GRO_CB(skb)->count == 1)
+        if (NAPI_GRO_CB(skb)->count == 1) {
+                skb_shinfo(skb)->gso_size = 0;
                 goto out;
+        }
 
         rcu_read_lock();
         list_for_each_entry_rcu(ptype, head, list) {
@@ -2359,8 +2355,6 @@ static int napi_gro_complete(struct sk_buff *skb)
         }
 
 out:
-        skb_shinfo(skb)->gso_size = 0;
-        __skb_push(skb, -skb_network_offset(skb));
         return netif_receive_skb(skb);
 }
 
@@ -2374,50 +2368,59 @@ void napi_gro_flush(struct napi_struct *napi)
                 napi_gro_complete(skb);
         }
 
+        napi->gro_count = 0;
         napi->gro_list = NULL;
 }
 EXPORT_SYMBOL(napi_gro_flush);
 
+void *skb_gro_header(struct sk_buff *skb, unsigned int hlen)
+{
+        unsigned int offset = skb_gro_offset(skb);
+
+        hlen += offset;
+        if (hlen <= skb_headlen(skb))
+                return skb->data + offset;
+
+        if (unlikely(!skb_shinfo(skb)->nr_frags ||
+                     skb_shinfo(skb)->frags[0].size <=
+                     hlen - skb_headlen(skb) ||
+                     PageHighMem(skb_shinfo(skb)->frags[0].page)))
+                return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
+
+        return page_address(skb_shinfo(skb)->frags[0].page) +
+               skb_shinfo(skb)->frags[0].page_offset +
+               offset - skb_headlen(skb);
+}
+EXPORT_SYMBOL(skb_gro_header);
+
 int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
         struct sk_buff **pp = NULL;
         struct packet_type *ptype;
         __be16 type = skb->protocol;
         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
-        int count = 0;
         int same_flow;
         int mac_len;
-        int free;
+        int ret;
 
         if (!(skb->dev->features & NETIF_F_GRO))
                 goto normal;
 
+        if (skb_is_gso(skb) || skb_shinfo(skb)->frag_list)
+                goto normal;
+
         rcu_read_lock();
         list_for_each_entry_rcu(ptype, head, list) {
-                struct sk_buff *p;
-
                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
                         continue;
 
-                skb_reset_network_header(skb);
+                skb_set_network_header(skb, skb_gro_offset(skb));
                 mac_len = skb->network_header - skb->mac_header;
                 skb->mac_len = mac_len;
                 NAPI_GRO_CB(skb)->same_flow = 0;
                 NAPI_GRO_CB(skb)->flush = 0;
                 NAPI_GRO_CB(skb)->free = 0;
 
-                for (p = napi->gro_list; p; p = p->next) {
-                        count++;
-
-                        if (!NAPI_GRO_CB(p)->same_flow)
-                                continue;
-
-                        if (p->mac_len != mac_len ||
-                            memcmp(skb_mac_header(p), skb_mac_header(skb),
-                                   mac_len))
-                                NAPI_GRO_CB(p)->same_flow = 0;
-                }
-
                 pp = ptype->gro_receive(&napi->gro_list, skb);
                 break;
         }
@@ -2427,7 +2430,7 @@ int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
                 goto normal;
 
         same_flow = NAPI_GRO_CB(skb)->same_flow;
-        free = NAPI_GRO_CB(skb)->free;
+        ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
 
         if (pp) {
                 struct sk_buff *nskb = *pp;
@@ -2435,27 +2438,35 @@ int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
                 *pp = nskb->next;
                 nskb->next = NULL;
                 napi_gro_complete(nskb);
-                count--;
+                napi->gro_count--;
         }
 
         if (same_flow)
                 goto ok;
 
-        if (NAPI_GRO_CB(skb)->flush || count >= MAX_GRO_SKBS) {
-                __skb_push(skb, -skb_network_offset(skb));
+        if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
                 goto normal;
-        }
 
+        napi->gro_count++;
         NAPI_GRO_CB(skb)->count = 1;
-        skb_shinfo(skb)->gso_size = skb->len;
+        skb_shinfo(skb)->gso_size = skb_gro_len(skb);
         skb->next = napi->gro_list;
         napi->gro_list = skb;
+        ret = GRO_HELD;
+
+pull:
+        if (unlikely(!pskb_may_pull(skb, skb_gro_offset(skb)))) {
+                if (napi->gro_list == skb)
+                        napi->gro_list = skb->next;
+                ret = GRO_DROP;
+        }
 
 ok:
-        return free;
+        return ret;
 
 normal:
-        return -1;
+        ret = GRO_NORMAL;
+        goto pull;
 }
 EXPORT_SYMBOL(dev_gro_receive);
 
@@ -2463,37 +2474,50 @@ static int __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
         struct sk_buff *p;
 
+        if (netpoll_rx_on(skb))
+                return GRO_NORMAL;
+
         for (p = napi->gro_list; p; p = p->next) {
-                NAPI_GRO_CB(p)->same_flow = 1;
+                NAPI_GRO_CB(p)->same_flow = (p->dev == skb->dev)
+                        && !compare_ether_header(skb_mac_header(p),
+                                                 skb_gro_mac_header(skb));
                 NAPI_GRO_CB(p)->flush = 0;
         }
 
         return dev_gro_receive(napi, skb);
 }
 
-int napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
+int napi_skb_finish(int ret, struct sk_buff *skb)
 {
-        switch (__napi_gro_receive(napi, skb)) {
-        case -1:
+        int err = NET_RX_SUCCESS;
+
+        switch (ret) {
+        case GRO_NORMAL:
                 return netif_receive_skb(skb);
 
-        case 1:
+        case GRO_DROP:
+                err = NET_RX_DROP;
+                /* fall through */
+
+        case GRO_MERGED_FREE:
                 kfree_skb(skb);
                 break;
         }
 
-        return NET_RX_SUCCESS;
+        return err;
 }
-EXPORT_SYMBOL(napi_gro_receive);
+EXPORT_SYMBOL(napi_skb_finish);
 
-void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
+int napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
-        skb_shinfo(skb)->nr_frags = 0;
+        skb_gro_reset_offset(skb);
 
-        skb->len -= skb->data_len;
-        skb->truesize -= skb->data_len;
-        skb->data_len = 0;
+        return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
+}
+EXPORT_SYMBOL(napi_gro_receive);
 
+void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
+{
         __skb_pull(skb, skb_headlen(skb));
         skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb));
 
@@ -2506,6 +2530,9 @@ struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
 {
         struct net_device *dev = napi->dev;
         struct sk_buff *skb = napi->skb;
+        struct ethhdr *eth;
+        skb_frag_t *frag;
+        int i;
 
         napi->skb = NULL;
 
@@ -2518,19 +2545,36 @@ struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
         }
 
         BUG_ON(info->nr_frags > MAX_SKB_FRAGS);
+        frag = info->frags;
+
+        for (i = 0; i < info->nr_frags; i++) {
+                skb_fill_page_desc(skb, i, frag->page, frag->page_offset,
+                                   frag->size);
+                frag++;
+        }
         skb_shinfo(skb)->nr_frags = info->nr_frags;
-        memcpy(skb_shinfo(skb)->frags, info->frags, sizeof(info->frags));
 
         skb->data_len = info->len;
         skb->len += info->len;
         skb->truesize += info->len;
 
-        if (!pskb_may_pull(skb, ETH_HLEN)) {
+        skb_reset_mac_header(skb);
+        skb_gro_reset_offset(skb);
+
+        eth = skb_gro_header(skb, sizeof(*eth));
+        if (!eth) {
                 napi_reuse_skb(napi, skb);
+                skb = NULL;
                 goto out;
         }
 
-        skb->protocol = eth_type_trans(skb, dev);
+        skb_gro_pull(skb, sizeof(*eth));
+
+        /*
+         * This works because the only protocols we care about don't require
+         * special handling.  We'll fix it up properly at the end.
+         */
+        skb->protocol = eth->h_proto;
 
         skb->ip_summed = info->ip_summed;
         skb->csum = info->csum;
@@ -2540,29 +2584,43 @@ out:
 }
 EXPORT_SYMBOL(napi_fraginfo_skb);
 
-int napi_gro_frags(struct napi_struct *napi, struct napi_gro_fraginfo *info)
+int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
 {
-        struct sk_buff *skb = napi_fraginfo_skb(napi, info);
-        int err = NET_RX_DROP;
+        int err = NET_RX_SUCCESS;
 
-        if (!skb)
-                goto out;
+        switch (ret) {
+        case GRO_NORMAL:
+        case GRO_HELD:
+                skb->protocol = eth_type_trans(skb, napi->dev);
 
-        err = NET_RX_SUCCESS;
+                if (ret == GRO_NORMAL)
+                        return netif_receive_skb(skb);
 
-        switch (__napi_gro_receive(napi, skb)) {
-        case -1:
-                return netif_receive_skb(skb);
+                skb_gro_pull(skb, -ETH_HLEN);
+                break;
 
-        case 0:
-                goto out;
-        }
+        case GRO_DROP:
+                err = NET_RX_DROP;
+                /* fall through */
 
-        napi_reuse_skb(napi, skb);
+        case GRO_MERGED_FREE:
+                napi_reuse_skb(napi, skb);
+                break;
+        }
 
-out:
         return err;
 }
+EXPORT_SYMBOL(napi_frags_finish);
+
+int napi_gro_frags(struct napi_struct *napi, struct napi_gro_fraginfo *info)
+{
+        struct sk_buff *skb = napi_fraginfo_skb(napi, info);
+
+        if (!skb)
+                return NET_RX_DROP;
+
+        return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
+}
 EXPORT_SYMBOL(napi_gro_frags);
 
 static int process_backlog(struct napi_struct *napi, int quota)
@@ -2584,11 +2642,9 @@ static int process_backlog(struct napi_struct *napi, int quota)
                 }
                 local_irq_enable();
 
-                napi_gro_receive(napi, skb);
+                netif_receive_skb(skb);
         } while (++work < quota && jiffies == start_time);
 
-        napi_gro_flush(napi);
-
         return work;
 }
 
@@ -2642,6 +2698,7 @@ 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->gro_count = 0;
         napi->gro_list = NULL;
         napi->skb = NULL;
         napi->poll = poll;
@@ -2661,7 +2718,7 @@ void netif_napi_del(struct napi_struct *napi)
         struct sk_buff *skb, *next;
 
         list_del_init(&napi->dev_list);
-        kfree(napi->skb);
+        kfree_skb(napi->skb);
 
         for (skb = napi->gro_list; skb; skb = next) {
                 next = skb->next;
@@ -2670,6 +2727,7 @@ void netif_napi_del(struct napi_struct *napi)
         }
 
         napi->gro_list = NULL;
+        napi->gro_count = 0;
 }
 EXPORT_SYMBOL(netif_napi_del);
 
@@ -3938,6 +3996,7 @@ static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
                             cmd == SIOCSMIIREG ||
                             cmd == SIOCBRADDIF ||
                             cmd == SIOCBRDELIF ||
+                            cmd == SIOCSHWTSTAMP ||
                             cmd == SIOCWANDEV) {
                                 err = -EOPNOTSUPP;
                                 if (ops->ndo_do_ioctl) {
@@ -4092,6 +4151,7 @@ int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
                 case SIOCBONDCHANGEACTIVE:
                 case SIOCBRADDIF:
                 case SIOCBRDELIF:
+                case SIOCSHWTSTAMP:
                         if (!capable(CAP_NET_ADMIN))
                                 return -EPERM;
                         /* fall through */
@@ -4272,6 +4332,39 @@ unsigned long netdev_fix_features(unsigned long features, const char *name)
 }
 EXPORT_SYMBOL(netdev_fix_features);
 
+/* Some devices need to (re-)set their netdev_ops inside
+ * ->init() or similar.  If that happens, we have to setup
+ * the compat pointers again.
+ */
+void netdev_resync_ops(struct net_device *dev)
+{
+#ifdef CONFIG_COMPAT_NET_DEV_OPS
+        const struct net_device_ops *ops = dev->netdev_ops;
+
+        dev->init = ops->ndo_init;
+        dev->uninit = ops->ndo_uninit;
+        dev->open = ops->ndo_open;
+        dev->change_rx_flags = ops->ndo_change_rx_flags;
+        dev->set_rx_mode = ops->ndo_set_rx_mode;
+        dev->set_multicast_list = ops->ndo_set_multicast_list;
+        dev->set_mac_address = ops->ndo_set_mac_address;
+        dev->validate_addr = ops->ndo_validate_addr;
+        dev->do_ioctl = ops->ndo_do_ioctl;
+        dev->set_config = ops->ndo_set_config;
+        dev->change_mtu = ops->ndo_change_mtu;
+        dev->neigh_setup = ops->ndo_neigh_setup;
+        dev->tx_timeout = ops->ndo_tx_timeout;
+        dev->get_stats = ops->ndo_get_stats;
+        dev->vlan_rx_register = ops->ndo_vlan_rx_register;
+        dev->vlan_rx_add_vid = ops->ndo_vlan_rx_add_vid;
+        dev->vlan_rx_kill_vid = ops->ndo_vlan_rx_kill_vid;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        dev->poll_controller = ops->ndo_poll_controller;
+#endif
+#endif
+}
+EXPORT_SYMBOL(netdev_resync_ops);
+
 /**
  *      register_netdevice      - register a network device
  *      @dev: device to register
@@ -4312,38 +4405,18 @@ int register_netdevice(struct net_device *dev)
         dev->iflink = -1;
 
 #ifdef CONFIG_COMPAT_NET_DEV_OPS
-        /* Netdevice_ops API compatiability support.
+        /* Netdevice_ops API compatibility support.
          * This is temporary until all network devices are converted.
          */
         if (dev->netdev_ops) {
-                const struct net_device_ops *ops = dev->netdev_ops;
-
-                dev->init = ops->ndo_init;
-                dev->uninit = ops->ndo_uninit;
-                dev->open = ops->ndo_open;
-                dev->change_rx_flags = ops->ndo_change_rx_flags;
-                dev->set_rx_mode = ops->ndo_set_rx_mode;
-                dev->set_multicast_list = ops->ndo_set_multicast_list;
-                dev->set_mac_address = ops->ndo_set_mac_address;
-                dev->validate_addr = ops->ndo_validate_addr;
-                dev->do_ioctl = ops->ndo_do_ioctl;
-                dev->set_config = ops->ndo_set_config;
-                dev->change_mtu = ops->ndo_change_mtu;
-                dev->tx_timeout = ops->ndo_tx_timeout;
-                dev->get_stats = ops->ndo_get_stats;
-                dev->vlan_rx_register = ops->ndo_vlan_rx_register;
-                dev->vlan_rx_add_vid = ops->ndo_vlan_rx_add_vid;
-                dev->vlan_rx_kill_vid = ops->ndo_vlan_rx_kill_vid;
-#ifdef CONFIG_NET_POLL_CONTROLLER
-                dev->poll_controller = ops->ndo_poll_controller;
-#endif
+                netdev_resync_ops(dev);
         } else {
                 char drivername[64];
                 pr_info("%s (%s): not using net_device_ops yet\n",
                         dev->name, netdev_drivername(dev, drivername, 64));
 
                 /* This works only because net_device_ops and the
-                   compatiablity structure are the same. */
+                   compatibility structure are the same. */
                 dev->netdev_ops = (void *) &(dev->init);
         }
 #endif
@@ -4434,6 +4507,45 @@ err_uninit:
 }
 
 /**
+ *      init_dummy_netdev       - init a dummy network device for NAPI
+ *      @dev: device to init
+ *
+ *      This takes a network device structure and initialize the minimum
+ *      amount of fields so it can be used to schedule NAPI polls without
+ *      registering a full blown interface. This is to be used by drivers
+ *      that need to tie several hardware interfaces to a single NAPI
+ *      poll scheduler due to HW limitations.
+ */
+int init_dummy_netdev(struct net_device *dev)
+{
+        /* Clear everything. Note we don't initialize spinlocks
+         * are they aren't supposed to be taken by any of the
+         * NAPI code and this dummy netdev is supposed to be
+         * only ever used for NAPI polls
+         */
+        memset(dev, 0, sizeof(struct net_device));
+
+        /* make sure we BUG if trying to hit standard
+         * register/unregister code path
+         */
+        dev->reg_state = NETREG_DUMMY;
+
+        /* initialize the ref count */
+        atomic_set(&dev->refcnt, 1);
+
+        /* NAPI wants this */
+        INIT_LIST_HEAD(&dev->napi_list);
+
+        /* a dummy interface is started by default */
+        set_bit(__LINK_STATE_PRESENT, &dev->state);
+        set_bit(__LINK_STATE_START, &dev->state);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(init_dummy_netdev);
+
+
+/**
  *      register_netdev - register a network device
  *      @dev: device to register
  *
@@ -5136,6 +5248,7 @@ static int __init net_dev_init(void)
                 queue->backlog.poll = process_backlog;
                 queue->backlog.weight = weight_p;
                 queue->backlog.gro_list = NULL;
+                queue->backlog.gro_count = 0;
         }
 
         dev_boot_phase = 0;
@@ -5168,6 +5281,14 @@ out:
 
 subsys_initcall(net_dev_init);
 
+static int __init initialize_hashrnd(void)
+{
+        get_random_bytes(&skb_tx_hashrnd, sizeof(skb_tx_hashrnd));
+        return 0;
+}
+
+late_initcall_sync(initialize_hashrnd);
+
 EXPORT_SYMBOL(__dev_get_by_index);
 EXPORT_SYMBOL(__dev_get_by_name);
 EXPORT_SYMBOL(__dev_remove_pack);