Changeset 32622


Ignore:
Timestamp:
Jul 9, 2017, 11:03:10 AM (11 days ago)
Author:
brainslayer
Message:

disable gro for foreighn mac addresses

Location:
src/linux/universal
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-3.18/include/linux/netdevice.h

    r31168 r32622  
    15641564        struct netdev_hw_addr_list      dev_addrs;
    15651565
     1566        unsigned char           local_addr_mask[MAX_ADDR_LEN];
     1567
    15661568#ifdef CONFIG_SYSFS
    15671569        struct kset             *queues_kset;
  • src/linux/universal/linux-3.18/include/linux/skbuff.h

    r31296 r32622  
    609609        __u8                    ipvs_property:1;
    610610        __u8                    inner_protocol_type:1;
    611         /* 4 or 6 bit hole */
     611        __u8                    gro_skip:1;
     612        /* 3 or 5 bit hole */
    612613
    613614#ifdef CONFIG_NET_SCHED
  • src/linux/universal/linux-3.18/net/core/dev.c

    r32569 r32622  
    40214021        int grow;
    40224022
     4023        if (skb->gro_skip)
     4024                goto normal;
     4025
    40234026        if (!(skb->dev->features & NETIF_F_GRO))
    40244027                goto normal;
     
    50935096}
    50945097
     5098static void __netdev_addr_mask(unsigned char *mask, const unsigned char *addr,
     5099                               struct net_device *dev)
     5100{
     5101        int i;
     5102
     5103        for (i = 0; i < dev->addr_len; i++)
     5104                mask[i] |= addr[i] ^ dev->dev_addr[i];
     5105}
     5106
     5107static void __netdev_upper_mask(unsigned char *mask, struct net_device *dev,
     5108                                struct net_device *lower)
     5109{
     5110        struct net_device *cur;
     5111        struct list_head *iter;
     5112
     5113        netdev_for_each_upper_dev_rcu(dev, cur, iter) {
     5114                __netdev_addr_mask(mask, cur->dev_addr, lower);
     5115                __netdev_upper_mask(mask, cur, lower);
     5116        }
     5117}
     5118
     5119static void __netdev_update_addr_mask(struct net_device *dev)
     5120{
     5121        unsigned char mask[MAX_ADDR_LEN];
     5122        struct net_device *cur;
     5123        struct list_head *iter;
     5124
     5125        memset(mask, 0, sizeof(mask));
     5126        __netdev_upper_mask(mask, dev, dev);
     5127        memcpy(dev->local_addr_mask, mask, dev->addr_len);
     5128
     5129        netdev_for_each_lower_dev(dev, cur, iter)
     5130                __netdev_update_addr_mask(cur);
     5131}
     5132
     5133static void netdev_update_addr_mask(struct net_device *dev)
     5134{
     5135        rcu_read_lock();
     5136        __netdev_update_addr_mask(dev);
     5137        rcu_read_unlock();
     5138}
     5139
    50955140static int __netdev_upper_dev_link(struct net_device *dev,
    50965141                                   struct net_device *upper_dev, bool master,
     
    51535198        }
    51545199
     5200        netdev_update_addr_mask(dev);
    51555201        call_netdevice_notifiers(NETDEV_CHANGEUPPER, dev);
    51565202        return 0;
     
    52705316                __netdev_adjacent_dev_unlink(dev, i->dev, i->ref_nr);
    52715317
     5318        netdev_update_addr_mask(dev);
    52725319        call_netdevice_notifiers(NETDEV_CHANGEUPPER, dev);
    52735320}
     
    57895836                return err;
    57905837        dev->addr_assign_type = NET_ADDR_SET;
     5838        netdev_update_addr_mask(dev);
    57915839        call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
    57925840        add_device_randomness(dev->dev_addr, dev->addr_len);
  • src/linux/universal/linux-3.18/net/ethernet/eth.c

    r25370 r32622  
    173173EXPORT_SYMBOL(eth_get_headlen);
    174174
     175static inline bool
     176eth_check_local_mask(const void *addr1, const void *addr2, const void *mask)
     177{
     178        const u16 *a1 = addr1;
     179        const u16 *a2 = addr2;
     180        const u16 *m = mask;
     181
     182        return (((a1[0] ^ a2[0]) & ~m[0]) |
     183                ((a1[1] ^ a2[1]) & ~m[1]) |
     184                ((a1[2] ^ a2[2]) & ~m[2]));
     185}
     186
    175187/**
    176188 * eth_type_trans - determine the packet's protocol ID.
     
    206218        }
    207219        else if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
    208                                                    dev->dev_addr)))
     220                                                   dev->dev_addr))) {
    209221                skb->pkt_type = PACKET_OTHERHOST;
     222                if (eth_check_local_mask(eth->h_dest, dev->dev_addr,
     223                                         dev->local_addr_mask))
     224                        skb->gro_skip = 1;
     225        }
    210226
    211227        /*
  • src/linux/universal/linux-4.4/include/linux/netdevice.h

    r31421 r32622  
    16471647        struct netdev_hw_addr_list      dev_addrs;
    16481648
     1649        unsigned char           local_addr_mask[MAX_ADDR_LEN];
     1650
    16491651#ifdef CONFIG_SYSFS
    16501652        struct kset             *queues_kset;
  • src/linux/universal/linux-4.4/include/linux/skbuff.h

    r32316 r32622  
    653653        __u8                    inner_protocol_type:1;
    654654        __u8                    remcsum_offload:1;
    655         /* 3 or 5 bit hole */
     655        __u8                    gro_skip:1;
     656        /* 2 or 4 bit hole */
    656657
    657658#ifdef CONFIG_NET_SCHED
  • src/linux/universal/linux-4.4/net/core/dev.c

    r32569 r32622  
    42734273        int grow;
    42744274
     4275        if (skb->gro_skip)
     4276                goto normal;
     4277
    42754278        if (!(skb->dev->features & NETIF_F_GRO))
    42764279                goto normal;
     
    54305433}
    54315434
     5435static void __netdev_addr_mask(unsigned char *mask, const unsigned char *addr,
     5436                               struct net_device *dev)
     5437{
     5438        int i;
     5439
     5440        for (i = 0; i < dev->addr_len; i++)
     5441                mask[i] |= addr[i] ^ dev->dev_addr[i];
     5442}
     5443
     5444static void __netdev_upper_mask(unsigned char *mask, struct net_device *dev,
     5445                                struct net_device *lower)
     5446{
     5447        struct net_device *cur;
     5448        struct list_head *iter;
     5449
     5450        netdev_for_each_upper_dev_rcu(dev, cur, iter) {
     5451                __netdev_addr_mask(mask, cur->dev_addr, lower);
     5452                __netdev_upper_mask(mask, cur, lower);
     5453        }
     5454}
     5455
     5456static void __netdev_update_addr_mask(struct net_device *dev)
     5457{
     5458        unsigned char mask[MAX_ADDR_LEN];
     5459        struct net_device *cur;
     5460        struct list_head *iter;
     5461
     5462        memset(mask, 0, sizeof(mask));
     5463        __netdev_upper_mask(mask, dev, dev);
     5464        memcpy(dev->local_addr_mask, mask, dev->addr_len);
     5465
     5466        netdev_for_each_lower_dev(dev, cur, iter)
     5467                __netdev_update_addr_mask(cur);
     5468}
     5469
     5470static void netdev_update_addr_mask(struct net_device *dev)
     5471{
     5472        rcu_read_lock();
     5473        __netdev_update_addr_mask(dev);
     5474        rcu_read_unlock();
     5475}
     5476
    54325477static int __netdev_upper_dev_link(struct net_device *dev,
    54335478                                   struct net_device *upper_dev, bool master,
     
    55015546        }
    55025547
     5548        netdev_update_addr_mask(dev);
    55035549        call_netdevice_notifiers_info(NETDEV_CHANGEUPPER, dev,
    55045550                                      &changeupper_info.info);
     
    56275673                __netdev_adjacent_dev_unlink(dev, i->dev, i->ref_nr);
    56285674
     5675        netdev_update_addr_mask(dev);
    56295676        call_netdevice_notifiers_info(NETDEV_CHANGEUPPER, dev,
    56305677                                      &changeupper_info.info);
     
    61676214                return err;
    61686215        dev->addr_assign_type = NET_ADDR_SET;
     6216        netdev_update_addr_mask(dev);
    61696217        call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
    61706218        add_device_randomness(dev->dev_addr, dev->addr_len);
  • src/linux/universal/linux-4.4/net/ethernet/eth.c

    r31421 r32622  
    141141EXPORT_SYMBOL(eth_get_headlen);
    142142
     143static inline bool
     144eth_check_local_mask(const void *addr1, const void *addr2, const void *mask)
     145{
     146        const u16 *a1 = addr1;
     147        const u16 *a2 = addr2;
     148        const u16 *m = mask;
     149
     150        return (((a1[0] ^ a2[0]) & ~m[0]) |
     151                ((a1[1] ^ a2[1]) & ~m[1]) |
     152                ((a1[2] ^ a2[2]) & ~m[2]));
     153}
     154
    143155/**
    144156 * eth_type_trans - determine the packet's protocol ID.
     
    175187        }
    176188        else if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
    177                                                    dev->dev_addr)))
     189                                                   dev->dev_addr))) {
    178190                skb->pkt_type = PACKET_OTHERHOST;
     191                if (eth_check_local_mask(eth->h_dest, dev->dev_addr,
     192                                         dev->local_addr_mask))
     193                        skb->gro_skip = 1;
     194        }
    179195
    180196        /*
  • src/linux/universal/linux-4.9/include/linux/netdevice.h

    r32407 r32622  
    17571757        struct netdev_hw_addr_list      dev_addrs;
    17581758
     1759        unsigned char           local_addr_mask[MAX_ADDR_LEN];
     1760
    17591761#ifdef CONFIG_SYSFS
    17601762        struct kset             *queues_kset;
  • src/linux/universal/linux-4.9/include/linux/skbuff.h

    r31587 r32622  
    754754        __u8                    offload_fwd_mark:1;
    755755#endif
    756         /* 2, 4 or 5 bit hole */
    757756#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
    758757        __u8                    imq_flags:IMQ_F_BITS;
    759758#endif
    760 
     759        __u8                    gro_skip:1;
     760        /* 1, 3 or 4 bit hole */
    761761#ifdef CONFIG_NET_SCHED
    762762        __u16                   tc_index;       /* traffic control index */
  • src/linux/universal/linux-4.9/net/core/dev.c

    r32569 r32622  
    45384538        int grow;
    45394539
     4540        if (skb->gro_skip)
     4541                goto normal;
     4542
    45404543        if (!(skb->dev->features & NETIF_F_GRO))
    45414544                goto normal;
     
    58165819}
    58175820
     5821static void __netdev_addr_mask(unsigned char *mask, const unsigned char *addr,
     5822                               struct net_device *dev)
     5823{
     5824        int i;
     5825
     5826        for (i = 0; i < dev->addr_len; i++)
     5827                mask[i] |= addr[i] ^ dev->dev_addr[i];
     5828}
     5829
     5830static void __netdev_upper_mask(unsigned char *mask, struct net_device *dev,
     5831                                struct net_device *lower)
     5832{
     5833        struct net_device *cur;
     5834        struct list_head *iter;
     5835
     5836        netdev_for_each_upper_dev_rcu(dev, cur, iter) {
     5837                __netdev_addr_mask(mask, cur->dev_addr, lower);
     5838                __netdev_upper_mask(mask, cur, lower);
     5839        }
     5840}
     5841
     5842static void __netdev_update_addr_mask(struct net_device *dev)
     5843{
     5844        unsigned char mask[MAX_ADDR_LEN];
     5845        struct net_device *cur;
     5846        struct list_head *iter;
     5847
     5848        memset(mask, 0, sizeof(mask));
     5849        __netdev_upper_mask(mask, dev, dev);
     5850        memcpy(dev->local_addr_mask, mask, dev->addr_len);
     5851
     5852        netdev_for_each_lower_dev(dev, cur, iter)
     5853                __netdev_update_addr_mask(cur);
     5854}
     5855
     5856static void netdev_update_addr_mask(struct net_device *dev)
     5857{
     5858        rcu_read_lock();
     5859        __netdev_update_addr_mask(dev);
     5860        rcu_read_unlock();
     5861}
     5862
    58185863static int __netdev_upper_dev_link(struct net_device *dev,
    58195864                                   struct net_device *upper_dev, bool master,
     
    60146059                __netdev_adjacent_dev_unlink(dev, i->dev, i->ref_nr);
    60156060
     6061        netdev_update_addr_mask(dev);
     6062        netdev_update_addr_mask(dev);
    60166063        call_netdevice_notifiers_info(NETDEV_CHANGEUPPER, dev,
    60176064                                      &changeupper_info.info);
     
    66146661                return err;
    66156662        dev->addr_assign_type = NET_ADDR_SET;
     6663        netdev_update_addr_mask(dev);
    66166664        call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
    66176665        add_device_randomness(dev->dev_addr, dev->addr_len);
  • src/linux/universal/linux-4.9/net/ethernet/eth.c

    r31574 r32622  
    144144EXPORT_SYMBOL(eth_get_headlen);
    145145
     146static inline bool
     147eth_check_local_mask(const void *addr1, const void *addr2, const void *mask)
     148{
     149        const u16 *a1 = addr1;
     150        const u16 *a2 = addr2;
     151        const u16 *m = mask;
     152
     153        return (((a1[0] ^ a2[0]) & ~m[0]) |
     154                ((a1[1] ^ a2[1]) & ~m[1]) |
     155                ((a1[2] ^ a2[2]) & ~m[2]));
     156}
     157
    146158/**
    147159 * eth_type_trans - determine the packet's protocol ID.
     
    178190        }
    179191        else if (unlikely(!ether_addr_equal_64bits(eth->h_dest,
    180                                                    dev->dev_addr)))
     192                                                   dev->dev_addr))) {
    181193                skb->pkt_type = PACKET_OTHERHOST;
     194                if (eth_check_local_mask(eth->h_dest, dev->dev_addr,
     195                                         dev->local_addr_mask))
     196                        skb->gro_skip = 1;
     197        }
    182198
    183199        /*
Note: See TracChangeset for help on using the changeset viewer.