Currently, the driver sets default feature for netdev->features, netdev->hw_features, netdev->vlan_features and netdev->hw_enc_features separately. It's fussy, because most of the feature bits are same. So refine it by copy value from netdev->features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ethernet/hisilicon/hns3/hns3_enet.c | 62 +++++++------------------ 1 file changed, 16 insertions(+), 46 deletions(-)

diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c index fcbeb1f..8072644 100644 --- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c +++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c @@ -3127,11 +3127,6 @@ static void hns3_set_default_feature(struct net_device *netdev)

netdev->priv_flags |= IFF_UNICAST_FLT;

- netdev->hw_enc_features |= NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_GSO | - NETIF_F_GRO | NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_GSO_GRE | - NETIF_F_GSO_GRE_CSUM | NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_SCTP_CRC | NETIF_F_TSO_MANGLEID | NETIF_F_FRAGLIST; - netdev->gso_partial_features |= NETIF_F_GSO_GRE_CSUM;

netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | @@ -3141,62 +3136,37 @@ static void hns3_set_default_feature(struct net_device *netdev) NETIF_F_GSO_GRE_CSUM | NETIF_F_GSO_UDP_TUNNEL | NETIF_F_SCTP_CRC | NETIF_F_FRAGLIST;

- netdev->vlan_features |= NETIF_F_RXCSUM | - NETIF_F_SG | NETIF_F_GSO | NETIF_F_GRO | - NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_GSO_GRE | - NETIF_F_GSO_GRE_CSUM | NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_SCTP_CRC | NETIF_F_FRAGLIST; - - netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_GSO | - NETIF_F_GRO | NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_GSO_GRE | - NETIF_F_GSO_GRE_CSUM | NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_SCTP_CRC | NETIF_F_FRAGLIST; - if (ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V2) { - netdev->hw_features |= NETIF_F_GRO_HW; netdev->features |= NETIF_F_GRO_HW;

- if (!(h->flags & HNAE3_SUPPORT_VF)) { - netdev->hw_features |= NETIF_F_NTUPLE; + if (!(h->flags & HNAE3_SUPPORT_VF)) netdev->features |= NETIF_F_NTUPLE; - } }

- if (test_bit(HNAE3_DEV_SUPPORT_UDP_GSO_B, ae_dev->caps)) { - netdev->hw_features |= NETIF_F_GSO_UDP_L4; + if (test_bit(HNAE3_DEV_SUPPORT_UDP_GSO_B, ae_dev->caps)) netdev->features |= NETIF_F_GSO_UDP_L4; - netdev->vlan_features |= NETIF_F_GSO_UDP_L4; - netdev->hw_enc_features |= NETIF_F_GSO_UDP_L4; - }

- if (test_bit(HNAE3_DEV_SUPPORT_HW_TX_CSUM_B, ae_dev->caps)) { - netdev->hw_features |= NETIF_F_HW_CSUM; + if (test_bit(HNAE3_DEV_SUPPORT_HW_TX_CSUM_B, ae_dev->caps)) netdev->features |= NETIF_F_HW_CSUM; - netdev->vlan_features |= NETIF_F_HW_CSUM; - netdev->hw_enc_features |= NETIF_F_HW_CSUM; - } else { - netdev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; + else netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; - netdev->vlan_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; - netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; - }

- if (test_bit(HNAE3_DEV_SUPPORT_UDP_TUNNEL_CSUM_B, ae_dev->caps)) { - netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM; + if (test_bit(HNAE3_DEV_SUPPORT_UDP_TUNNEL_CSUM_B, ae_dev->caps)) netdev->features |= NETIF_F_GSO_UDP_TUNNEL_CSUM; - netdev->vlan_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM; - netdev->hw_enc_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM; - }

- if (test_bit(HNAE3_DEV_SUPPORT_FD_FORWARD_TC_B, ae_dev->caps)) { - netdev->hw_features |= NETIF_F_HW_TC; + if (test_bit(HNAE3_DEV_SUPPORT_FD_FORWARD_TC_B, ae_dev->caps)) netdev->features |= NETIF_F_HW_TC; - }

- if (test_bit(HNAE3_DEV_SUPPORT_VLAN_FLTR_MDF_B, ae_dev->caps)) - netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER; + netdev->hw_features |= netdev->features; + if (!test_bit(HNAE3_DEV_SUPPORT_VLAN_FLTR_MDF_B, ae_dev->caps)) + netdev->hw_features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; + + netdev->vlan_features |= netdev->features & + ~(NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_GRO_HW | NETIF_F_NTUPLE | + NETIF_F_HW_TC); + + netdev->hw_enc_features |= netdev->vlan_features | NETIF_F_TSO_MANGLEID; }

static int hns3_alloc_buffer(struct hns3_enet_ring *ring,

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of netdev_get_wanted_features for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- include/linux/netdevice.h | 6 +++--- net/core/dev.c | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index f96e31a..efea2d6 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -5004,10 +5004,10 @@ static inline void netdev_intersect_features(netdev_features_t *ret, *ret = f1 & f2; }

-static inline netdev_features_t netdev_get_wanted_features( - struct net_device *dev) +static inline void netdev_get_wanted_features(struct net_device *dev, + netdev_features_t *wanted) { - return (dev->features & ~dev->hw_features) | dev->wanted_features; + *wanted = (dev->features & ~dev->hw_features) | dev->wanted_features; } netdev_features_t netdev_increment_features(netdev_features_t all, netdev_features_t one, netdev_features_t mask); diff --git a/net/core/dev.c b/net/core/dev.c index dfd5fa9..abc6fb7 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -9927,7 +9927,7 @@ int __netdev_update_features(struct net_device *dev)

ASSERT_RTNL();

- features = netdev_get_wanted_features(dev); + netdev_get_wanted_features(dev, &features);

if (dev->netdev_ops->ndo_fix_features) features = dev->netdev_ops->ndo_fix_features(dev, features);

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of harmonize_features for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/core/dev.c | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/net/core/dev.c b/net/core/dev.c index 487204d..9dd7421 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -3455,22 +3455,19 @@ static void net_mpls_features(struct sk_buff *skb, netdev_features_t *features, } #endif

-static netdev_features_t harmonize_features(struct sk_buff *skb, - netdev_features_t features) +static void harmonize_features(struct sk_buff *skb, netdev_features_t *features) { __be16 type;

type = skb_network_protocol(skb, NULL); - net_mpls_features(skb, &features, type); + net_mpls_features(skb, features, type);

if (skb->ip_summed != CHECKSUM_NONE && - !can_checksum_protocol(features, type)) { - features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + !can_checksum_protocol(*features, type)) { + *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); } if (illegal_highdma(skb->dev, skb)) - features &= ~NETIF_F_SG; - - return features; + *features &= ~NETIF_F_SG; }

netdev_features_t passthru_features_check(struct sk_buff *skb, @@ -3552,7 +3549,8 @@ netdev_features_t netif_skb_features(struct sk_buff *skb) else features &= dflt_features_check(skb, dev, features);

- return harmonize_features(skb, features); + harmonize_features(skb, &features); + return features; } EXPORT_SYMBOL(netif_skb_features);

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of vlan_features_check for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ethernet/amd/xgbe/xgbe-drv.c | 2 +- drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c | 2 +- drivers/net/ethernet/broadcom/bnxt/bnxt.c | 2 +- drivers/net/ethernet/emulex/benet/be_main.c | 2 +- drivers/net/ethernet/mellanox/mlx4/en_netdev.c | 2 +- drivers/net/ethernet/mellanox/mlx5/core/en_main.c | 2 +- drivers/net/ethernet/netronome/nfp/nfp_net_common.c | 2 +- drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c | 2 +- drivers/net/ethernet/realtek/8139cp.c | 3 ++- drivers/net/ethernet/realtek/r8169_main.c | 3 ++- drivers/net/usb/lan78xx.c | 2 +- drivers/s390/net/qeth_core_main.c | 3 ++- include/linux/if_vlan.h | 12 +++++------- net/core/dev.c | 3 ++- 14 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c index 17a585a..3fb15f6 100644 --- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c +++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c @@ -2271,7 +2271,7 @@ static netdev_features_t xgbe_features_check(struct sk_buff *skb, struct net_device *netdev, netdev_features_t features) { - features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); features = vxlan_features_check(skb, features);

return features; diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c index 6d98134..5f67a9a 100644 --- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c +++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c @@ -12907,7 +12907,7 @@ static netdev_features_t bnx2x_features_check(struct sk_buff *skb, !skb_gso_validate_mac_len(skb, 9700))) features &= ~NETIF_F_GSO_MASK;

- features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); return vxlan_features_check(skb, features); }

diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c index 865fcb8..af6bddf 100644 --- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c +++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c @@ -11114,7 +11114,7 @@ static netdev_features_t bnxt_features_check(struct sk_buff *skb, struct bnxt *bp = netdev_priv(dev); u8 *l4_proto;

- features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); switch (vlan_get_protocol(skb)) { case htons(ETH_P_IP): if (!skb->encapsulation) diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c index 361c1c8..556242d 100644 --- a/drivers/net/ethernet/emulex/benet/be_main.c +++ b/drivers/net/ethernet/emulex/benet/be_main.c @@ -5092,7 +5092,7 @@ static netdev_features_t be_features_check(struct sk_buff *skb, * Q-in-Q packets. * Offload features for normal (non tunnel) packets are unchanged. */ - features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); if (!skb->encapsulation || !(adapter->flags & BE_FLAGS_VXLAN_OFFLOADS)) return features; diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c index a2f61a8..c51bd5d 100644 --- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c +++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c @@ -2664,7 +2664,7 @@ static netdev_features_t mlx4_en_features_check(struct sk_buff *skb, struct net_device *dev, netdev_features_t features) { - features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); features = vxlan_features_check(skb, features);

/* The ConnectX-3 doesn't support outer IPv6 checksums but it does diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c index ccc569c..6c0fc8d 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c @@ -3820,7 +3820,7 @@ netdev_features_t mlx5e_features_check(struct sk_buff *skb, { struct mlx5e_priv *priv = netdev_priv(netdev);

- features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); features = vxlan_features_check(skb, features);

/* Validate if the tunneled packet is being offloaded by HW */ diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c index 5bfa22a..58e7d98 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c @@ -3605,7 +3605,7 @@ nfp_net_features_check(struct sk_buff *skb, struct net_device *dev, u8 l4_hdr;

/* We can't do TSO over double tagged packets (802.1AD) */ - features &= vlan_features_check(skb, features); + vlan_features_check(skb, &features);

if (!skb->encapsulation) return features; diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c index a4fa5079..4b13db3 100644 --- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c +++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c @@ -496,7 +496,7 @@ static netdev_features_t qlcnic_features_check(struct sk_buff *skb, struct net_device *dev, netdev_features_t features) { - features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); return vxlan_features_check(skb, features); }

diff --git a/drivers/net/ethernet/realtek/8139cp.c b/drivers/net/ethernet/realtek/8139cp.c index edc6190..276a158 100644 --- a/drivers/net/ethernet/realtek/8139cp.c +++ b/drivers/net/ethernet/realtek/8139cp.c @@ -1860,7 +1860,8 @@ static netdev_features_t cp_features_check(struct sk_buff *skb, if (skb_shinfo(skb)->gso_size > MSSMask) features &= ~NETIF_F_TSO;

- return vlan_features_check(skb, features); + vlan_features_check(skb, &features); + return features; } static const struct net_device_ops cp_netdev_ops = { .ndo_open = cp_open, diff --git a/drivers/net/ethernet/realtek/r8169_main.c b/drivers/net/ethernet/realtek/r8169_main.c index fa2dab6..d48e589 100644 --- a/drivers/net/ethernet/realtek/r8169_main.c +++ b/drivers/net/ethernet/realtek/r8169_main.c @@ -4379,7 +4379,8 @@ static netdev_features_t rtl8169_features_check(struct sk_buff *skb, features &= ~NETIF_F_CSUM_MASK; }

- return vlan_features_check(skb, features); + vlan_features_check(skb, &features); + return features; }

static void rtl8169_pcierr_interrupt(struct net_device *dev) diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c index 4e8d3c2..e536d96 100644 --- a/drivers/net/usb/lan78xx.c +++ b/drivers/net/usb/lan78xx.c @@ -3595,7 +3595,7 @@ static netdev_features_t lan78xx_features_check(struct sk_buff *skb, if (skb->len + TX_OVERHEAD > MAX_SINGLE_PACKET_SIZE) features &= ~NETIF_F_GSO_MASK;

- features = vlan_features_check(skb, features); + vlan_features_check(skb, &features); features = vxlan_features_check(skb, features);

return features; diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c index 5b973f3..1a7bb6f 100644 --- a/drivers/s390/net/qeth_core_main.c +++ b/drivers/s390/net/qeth_core_main.c @@ -7006,7 +7006,8 @@ netdev_features_t qeth_features_check(struct sk_buff *skb, features &= ~NETIF_F_SG; }

- return vlan_features_check(skb, features); + vlan_features_check(skb, &features); + return features; } EXPORT_SYMBOL_GPL(qeth_features_check);

diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h index 41a5183..2337538 100644 --- a/include/linux/if_vlan.h +++ b/include/linux/if_vlan.h @@ -727,8 +727,8 @@ static inline bool skb_vlan_tagged_multi(struct sk_buff *skb) * * Returns features without unsafe ones if the skb has multiple tags. */ -static inline netdev_features_t vlan_features_check(struct sk_buff *skb, - netdev_features_t features) +static inline void vlan_features_check(struct sk_buff *skb, + netdev_features_t *features) { if (skb_vlan_tagged_multi(skb)) { /* In the case of multi-tagged packets, use a direct mask @@ -736,12 +736,10 @@ static inline netdev_features_t vlan_features_check(struct sk_buff *skb, * sure that only devices supporting NETIF_F_HW_CSUM will * have checksum offloading support. */ - features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | - NETIF_F_FRAGLIST | NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_STAG_TX; + *features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | + NETIF_F_FRAGLIST | NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_STAG_TX; } - - return features; }

/** diff --git a/net/core/dev.c b/net/core/dev.c index 4e553d4..78466c8 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -3482,7 +3482,8 @@ static netdev_features_t dflt_features_check(struct sk_buff *skb, struct net_device *dev, netdev_features_t features) { - return vlan_features_check(skb, features); + vlan_features_check(skb, &features); + return features; }

static void gso_features_check(const struct sk_buff *skb,

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of dflt_features_check for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/core/dev.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/net/core/dev.c b/net/core/dev.c index 78466c8..31ab16b 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -3478,12 +3478,11 @@ netdev_features_t passthru_features_check(struct sk_buff *skb, } EXPORT_SYMBOL(passthru_features_check);

-static netdev_features_t dflt_features_check(struct sk_buff *skb, - struct net_device *dev, - netdev_features_t features) +static void dflt_features_check(struct sk_buff *skb, + struct net_device *dev, + netdev_features_t *features) { - vlan_features_check(skb, &features); - return features; + vlan_features_check(skb, features); }

static void gso_features_check(const struct sk_buff *skb, @@ -3549,7 +3548,7 @@ netdev_features_t netif_skb_features(struct sk_buff *skb) features &= dev->netdev_ops->ndo_features_check(skb, dev, features); else - features &= dflt_features_check(skb, dev, features); + dflt_features_check(skb, dev, &features);

harmonize_features(skb, &features); return features;

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of netif_skb_features for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/xen-netfront.c | 9 +++++++-- include/linux/netdevice.h | 2 +- net/core/dev.c | 20 ++++++++++---------- net/core/netpoll.c | 2 +- net/ipv4/ip_output.c | 2 +- net/ipv6/ip6_output.c | 2 +- net/sched/sch_cake.c | 3 ++- net/sched/sch_netem.c | 3 ++- net/sched/sch_taprio.c | 3 ++- net/sched/sch_tbf.c | 3 ++- 10 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c index 4427590..a8c2d41 100644 --- a/drivers/net/xen-netfront.c +++ b/drivers/net/xen-netfront.c @@ -648,6 +648,7 @@ static netdev_tx_t xennet_start_xmit(struct sk_buff *skb, struct net_device *dev unsigned long flags; struct netfront_queue *queue = NULL; unsigned int num_queues = dev->real_num_tx_queues; + netdev_features_t features; u16 queue_index; struct sk_buff *nskb;

@@ -697,8 +698,12 @@ static netdev_tx_t xennet_start_xmit(struct sk_buff *skb, struct net_device *dev spin_lock_irqsave(&queue->tx_lock, flags);

if (unlikely(!netif_carrier_ok(dev) || - (slots > 1 && !xennet_can_sg(dev)) || - netif_needs_gso(skb, netif_skb_features(skb)))) { + (slots > 1 && !xennet_can_sg(dev)))) { + spin_unlock_irqrestore(&queue->tx_lock, flags); + goto drop; + } + netif_skb_features(skb, &features); + if (unlikely(netif_needs_gso(skb, features))) { spin_unlock_irqrestore(&queue->tx_lock, flags); goto drop; } diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index aa3ca93..842b29ee 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -5031,7 +5031,7 @@ void netif_stacked_transfer_operstate(const struct net_device *rootdev,

void passthru_features_check(struct sk_buff *skb, struct net_device *dev, netdev_features_t *features); -netdev_features_t netif_skb_features(struct sk_buff *skb); +void netif_skb_features(struct sk_buff *skb, netdev_features_t *features);

static inline bool net_gso_ok(netdev_features_t features, int gso_type) { diff --git a/net/core/dev.c b/net/core/dev.c index a084a19..e7719c2 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -3521,34 +3521,34 @@ static void gso_features_check(const struct sk_buff *skb, } }

-netdev_features_t netif_skb_features(struct sk_buff *skb) +void netif_skb_features(struct sk_buff *skb, netdev_features_t *features) { struct net_device *dev = skb->dev; - netdev_features_t features = dev->features; + + *features = dev->features;

if (skb_is_gso(skb)) - gso_features_check(skb, dev, &features); + gso_features_check(skb, dev, features);

/* If encapsulation offload request, verify we are testing * hardware encapsulation features instead of standard * features for the netdev */ if (skb->encapsulation) - features &= dev->hw_enc_features; + *features &= dev->hw_enc_features;

if (skb_vlan_tagged(skb)) - netdev_intersect_features(&features, features, + netdev_intersect_features(features, *features, dev->vlan_features | NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX);

if (dev->netdev_ops->ndo_features_check) - dev->netdev_ops->ndo_features_check(skb, dev, &features); + dev->netdev_ops->ndo_features_check(skb, dev, features); else - dflt_features_check(skb, dev, &features); + dflt_features_check(skb, dev, features);

- harmonize_features(skb, &features); - return features; + harmonize_features(skb, features); } EXPORT_SYMBOL(netif_skb_features);

@@ -3633,7 +3633,7 @@ static struct sk_buff *validate_xmit_skb(struct sk_buff *skb, struct net_device { netdev_features_t features;

- features = netif_skb_features(skb); + netif_skb_features(skb, &features); skb = validate_xmit_vlan(skb, features); if (unlikely(!skb)) goto out_null; diff --git a/net/core/netpoll.c b/net/core/netpoll.c index edfc0f8..d2fc92b 100644 --- a/net/core/netpoll.c +++ b/net/core/netpoll.c @@ -77,7 +77,7 @@ static netdev_tx_t netpoll_start_xmit(struct sk_buff *skb, netdev_tx_t status = NETDEV_TX_OK; netdev_features_t features;

- features = netif_skb_features(skb); + netif_skb_features(skb, &features);

if (skb_vlan_tag_present(skb) && !vlan_hw_offload_capable(features, skb->vlan_proto)) { diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c index 6b04a88..e458f1f 100644 --- a/net/ipv4/ip_output.c +++ b/net/ipv4/ip_output.c @@ -255,7 +255,7 @@ static int ip_finish_output_gso(struct net *net, struct sock *sk, * bridged to a NETIF_F_TSO tunnel stacked over an interface with an * insufficient MTU. */ - features = netif_skb_features(skb); + netif_skb_features(skb, &features); BUILD_BUG_ON(sizeof(*IPCB(skb)) > SKB_GSO_CB_OFFSET); segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); if (IS_ERR_OR_NULL(segs)) { diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c index 12f985f..46a0867 100644 --- a/net/ipv6/ip6_output.c +++ b/net/ipv6/ip6_output.c @@ -146,7 +146,7 @@ ip6_finish_output_gso_slowpath_drop(struct net *net, struct sock *sk, * describing the cases where GSO segment length exceeds the * egress MTU. */ - features = netif_skb_features(skb); + netif_skb_features(skb, &features); segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); if (IS_ERR_OR_NULL(segs)) { kfree_skb(skb); diff --git a/net/sched/sch_cake.c b/net/sched/sch_cake.c index ecc5c4d..0808569 100644 --- a/net/sched/sch_cake.c +++ b/net/sched/sch_cake.c @@ -1740,9 +1740,10 @@ static s32 cake_enqueue(struct sk_buff *skb, struct Qdisc *sch,

if (skb_is_gso(skb) && q->rate_flags & CAKE_FLAG_SPLIT_GSO) { struct sk_buff *segs, *nskb; - netdev_features_t features = netif_skb_features(skb); + netdev_features_t features; unsigned int slen = 0, numsegs = 0;

+ netif_skb_features(skb, &features); segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); if (IS_ERR_OR_NULL(segs)) return qdisc_drop(skb, sch, to_free); diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c index 0c345e4..414d57e 100644 --- a/net/sched/sch_netem.c +++ b/net/sched/sch_netem.c @@ -413,8 +413,9 @@ static struct sk_buff *netem_segment(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free) { struct sk_buff *segs; - netdev_features_t features = netif_skb_features(skb); + netdev_features_t features;

+ netif_skb_features(skb, &features); segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK);

if (IS_ERR_OR_NULL(segs)) { diff --git a/net/sched/sch_taprio.c b/net/sched/sch_taprio.c index 9c79374..a4073c4 100644 --- a/net/sched/sch_taprio.c +++ b/net/sched/sch_taprio.c @@ -453,10 +453,11 @@ static int taprio_enqueue(struct sk_buff *skb, struct Qdisc *sch, */ if (skb_is_gso(skb) && !FULL_OFFLOAD_IS_ENABLED(q->flags)) { unsigned int slen = 0, numsegs = 0, len = qdisc_pkt_len(skb); - netdev_features_t features = netif_skb_features(skb); + netdev_features_t features; struct sk_buff *segs, *nskb; int ret;

+ netif_skb_features(skb, &features); segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); if (IS_ERR_OR_NULL(segs)) return qdisc_drop(skb, sch, to_free); diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c index 78e7902..99e6d726 100644 --- a/net/sched/sch_tbf.c +++ b/net/sched/sch_tbf.c @@ -192,10 +192,11 @@ static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch, { struct tbf_sched_data *q = qdisc_priv(sch); struct sk_buff *segs, *nskb; - netdev_features_t features = netif_skb_features(skb); + netdev_features_t features; unsigned int len = 0, prev_len = qdisc_pkt_len(skb); int ret, nb;

+ netif_skb_features(skb, &features); segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK);

if (IS_ERR_OR_NULL(segs))

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of netdev_fix_features for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/core/dev.c | 78 ++++++++++++++++++++++++++++------------------------------ 1 file changed, 38 insertions(+), 40 deletions(-)

diff --git a/net/core/dev.c b/net/core/dev.c index ac1ab4b..fe0524d 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -9814,99 +9814,97 @@ static void netdev_sync_lower_features(struct net_device *upper, } }

-static netdev_features_t netdev_fix_features(struct net_device *dev, - netdev_features_t features) +static void netdev_fix_features(struct net_device *dev, + netdev_features_t *features) { /* Fix illegal checksum combinations */ - if ((features & NETIF_F_HW_CSUM) && - (features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) { + if ((*features & NETIF_F_HW_CSUM) && + (*features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM))) { netdev_warn(dev, "mixed HW and IP checksum settings.\n"); - features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM); + *features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM); }

/* TSO requires that SG is present as well. */ - if ((features & NETIF_F_ALL_TSO) && !(features & NETIF_F_SG)) { + if ((*features & NETIF_F_ALL_TSO) && !(*features & NETIF_F_SG)) { netdev_dbg(dev, "Dropping TSO features since no SG feature.\n"); - features &= ~NETIF_F_ALL_TSO; + *features &= ~NETIF_F_ALL_TSO; }

- if ((features & NETIF_F_TSO) && !(features & NETIF_F_HW_CSUM) && - !(features & NETIF_F_IP_CSUM)) { + if ((*features & NETIF_F_TSO) && !(*features & NETIF_F_HW_CSUM) && + !(*features & NETIF_F_IP_CSUM)) { netdev_dbg(dev, "Dropping TSO features since no CSUM feature.\n"); - features &= ~NETIF_F_TSO; - features &= ~NETIF_F_TSO_ECN; + *features &= ~NETIF_F_TSO; + *features &= ~NETIF_F_TSO_ECN; }

- if ((features & NETIF_F_TSO6) && !(features & NETIF_F_HW_CSUM) && - !(features & NETIF_F_IPV6_CSUM)) { + if ((*features & NETIF_F_TSO6) && !(*features & NETIF_F_HW_CSUM) && + !(*features & NETIF_F_IPV6_CSUM)) { netdev_dbg(dev, "Dropping TSO6 features since no CSUM feature.\n"); - features &= ~NETIF_F_TSO6; + *features &= ~NETIF_F_TSO6; }

/* TSO with IPv4 ID mangling requires IPv4 TSO be enabled */ - if ((features & NETIF_F_TSO_MANGLEID) && !(features & NETIF_F_TSO)) - features &= ~NETIF_F_TSO_MANGLEID; + if ((*features & NETIF_F_TSO_MANGLEID) && !(*features & NETIF_F_TSO)) + *features &= ~NETIF_F_TSO_MANGLEID;

/* TSO ECN requires that TSO is present as well. */ - if ((features & NETIF_F_ALL_TSO) == NETIF_F_TSO_ECN) - features &= ~NETIF_F_TSO_ECN; + if ((*features & NETIF_F_ALL_TSO) == NETIF_F_TSO_ECN) + *features &= ~NETIF_F_TSO_ECN;

/* Software GSO depends on SG. */ - if ((features & NETIF_F_GSO) && !(features & NETIF_F_SG)) { + if ((*features & NETIF_F_GSO) && !(*features & NETIF_F_SG)) { netdev_dbg(dev, "Dropping NETIF_F_GSO since no SG feature.\n"); - features &= ~NETIF_F_GSO; + *features &= ~NETIF_F_GSO; }

/* GSO partial features require GSO partial be set */ - if ((features & dev->gso_partial_features) && - !(features & NETIF_F_GSO_PARTIAL)) { + if ((*features & dev->gso_partial_features) && + !(*features & NETIF_F_GSO_PARTIAL)) { netdev_dbg(dev, "Dropping partially supported GSO features since no GSO partial.\n"); - features &= ~dev->gso_partial_features; + *features &= ~dev->gso_partial_features; }

- if (!(features & NETIF_F_RXCSUM)) { + if (!(*features & NETIF_F_RXCSUM)) { /* NETIF_F_GRO_HW implies doing RXCSUM since every packet * successfully merged by hardware must also have the * checksum verified by hardware. If the user does not * want to enable RXCSUM, logically, we should disable GRO_HW. */ - if (features & NETIF_F_GRO_HW) { + if (*features & NETIF_F_GRO_HW) { netdev_dbg(dev, "Dropping NETIF_F_GRO_HW since no RXCSUM feature.\n"); - features &= ~NETIF_F_GRO_HW; + *features &= ~NETIF_F_GRO_HW; } }

/* LRO/HW-GRO features cannot be combined with RX-FCS */ - if (features & NETIF_F_RXFCS) { - if (features & NETIF_F_LRO) { + if (*features & NETIF_F_RXFCS) { + if (*features & NETIF_F_LRO) { netdev_dbg(dev, "Dropping LRO feature since RX-FCS is requested.\n"); - features &= ~NETIF_F_LRO; + *features &= ~NETIF_F_LRO; }

- if (features & NETIF_F_GRO_HW) { + if (*features & NETIF_F_GRO_HW) { netdev_dbg(dev, "Dropping HW-GRO feature since RX-FCS is requested.\n"); - features &= ~NETIF_F_GRO_HW; + *features &= ~NETIF_F_GRO_HW; } }

- if (features & NETIF_F_HW_TLS_TX) { - bool ip_csum = (features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)) == + if (*features & NETIF_F_HW_TLS_TX) { + bool ip_csum = (*features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)) == (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM); - bool hw_csum = features & NETIF_F_HW_CSUM; + bool hw_csum = *features & NETIF_F_HW_CSUM;

if (!ip_csum && !hw_csum) { netdev_dbg(dev, "Dropping TLS TX HW offload feature since no CSUM feature.\n"); - features &= ~NETIF_F_HW_TLS_TX; + *features &= ~NETIF_F_HW_TLS_TX; } }

- if ((features & NETIF_F_HW_TLS_RX) && !(features & NETIF_F_RXCSUM)) { + if ((*features & NETIF_F_HW_TLS_RX) && !(*features & NETIF_F_RXCSUM)) { netdev_dbg(dev, "Dropping TLS RX HW offload feature since no RXCSUM feature.\n"); - features &= ~NETIF_F_HW_TLS_RX; + *features &= ~NETIF_F_HW_TLS_RX; } - - return features; }

int __netdev_update_features(struct net_device *dev) @@ -9924,7 +9922,7 @@ int __netdev_update_features(struct net_device *dev) dev->netdev_ops->ndo_fix_features(dev, &features);

/* driver might be less strict about feature dependencies */ - features = netdev_fix_features(dev, features); + netdev_fix_features(dev, &features);

/* some features can't be enabled if they're off on an upper device */ netdev_for_each_upper_dev_rcu(dev, upper, iter)

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of br_features_recompute for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/bridge/br_device.c | 2 +- net/bridge/br_if.c | 17 +++++++---------- net/bridge/br_private.h | 3 +-- 3 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/net/bridge/br_device.c b/net/bridge/br_device.c index 622559a..fc508b9 100644 --- a/net/bridge/br_device.c +++ b/net/bridge/br_device.c @@ -292,7 +292,7 @@ static void br_fix_features(struct net_device *dev, netdev_features_t *features) { struct net_bridge *br = netdev_priv(dev);

- *features = br_features_recompute(br, *features); + br_features_recompute(br, features); }

#ifdef CONFIG_NET_POLL_CONTROLLER diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c index 67c60240..321e2b4 100644 --- a/net/bridge/br_if.c +++ b/net/bridge/br_if.c @@ -532,25 +532,22 @@ static void br_set_gso_limits(struct net_bridge *br) /* * Recomputes features using slave's features */ -netdev_features_t br_features_recompute(struct net_bridge *br, - netdev_features_t features) +void br_features_recompute(struct net_bridge *br, netdev_features_t *features) { struct net_bridge_port *p; netdev_features_t mask;

if (list_empty(&br->port_list)) - return features; + return;

- mask = features; - features &= ~NETIF_F_ONE_FOR_ALL; + mask = *features; + *features &= ~NETIF_F_ONE_FOR_ALL;

list_for_each_entry(p, &br->port_list, list) { - features = netdev_increment_features(features, - p->dev->features, mask); + *features = netdev_increment_features(*features, + p->dev->features, mask); } - features = netdev_add_tso_features(features, mask); - - return features; + *features = netdev_add_tso_features(*features, mask); }

/* called with RTNL */ diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h index 51991f1..241361c 100644 --- a/net/bridge/br_private.h +++ b/net/bridge/br_private.h @@ -809,8 +809,7 @@ int br_add_if(struct net_bridge *br, struct net_device *dev, struct netlink_ext_ack *extack); int br_del_if(struct net_bridge *br, struct net_device *dev); void br_mtu_auto_adjust(struct net_bridge *br); -netdev_features_t br_features_recompute(struct net_bridge *br, - netdev_features_t features); +void br_features_recompute(struct net_bridge *br, netdev_features_t *features); void br_port_flags_change(struct net_bridge_port *port, unsigned long mask); void br_manage_promisc(struct net_bridge *br); int nbp_backup_change(struct net_bridge_port *p, struct net_device *backup_dev);

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of netdev_increment_features for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/bonding/bond_main.c | 28 ++++++++++++++-------------- drivers/net/ipvlan/ipvlan_main.c | 4 ++-- drivers/net/macvlan.c | 2 +- drivers/net/net_failover.c | 28 ++++++++++++---------------- drivers/net/team/team.c | 19 ++++++++----------- include/linux/netdevice.h | 6 +++--- net/bridge/br_if.c | 4 ++-- net/core/dev.c | 7 ++++--- net/hsr/hsr_device.c | 5 ++--- 9 files changed, 48 insertions(+), 55 deletions(-)

diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c index 6999a8c..3f1554c 100644 --- a/drivers/net/bonding/bond_main.c +++ b/drivers/net/bonding/bond_main.c @@ -1376,9 +1376,8 @@ static void bond_fix_features(struct net_device *dev, *features |= NETIF_F_ALL_FOR_ALL;

bond_for_each_slave(bond, slave, iter) { - *features = netdev_increment_features(*features, - slave->dev->features, - mask); + netdev_increment_features(features, *features, + slave->dev->features, mask); } netdev_add_tso_features(features, mask); } @@ -1417,22 +1416,23 @@ static void bond_compute_features(struct bonding *bond) mpls_features &= NETIF_F_ALL_FOR_ALL;

bond_for_each_slave(bond, slave, iter) { - vlan_features = netdev_increment_features(vlan_features, - slave->dev->vlan_features, BOND_VLAN_FEATURES); + netdev_increment_features(&vlan_features, vlan_features, + slave->dev->vlan_features, + BOND_VLAN_FEATURES);

- enc_features = netdev_increment_features(enc_features, - slave->dev->hw_enc_features, - BOND_ENC_FEATURES); + netdev_increment_features(&enc_features, enc_features, + slave->dev->hw_enc_features, + BOND_ENC_FEATURES);

#ifdef CONFIG_XFRM_OFFLOAD - xfrm_features = netdev_increment_features(xfrm_features, - slave->dev->hw_enc_features, - BOND_XFRM_FEATURES); + netdev_increment_features(&xfrm_features, xfrm_features, + slave->dev->hw_enc_features, + BOND_XFRM_FEATURES); #endif /* CONFIG_XFRM_OFFLOAD */

- mpls_features = netdev_increment_features(mpls_features, - slave->dev->mpls_features, - BOND_MPLS_FEATURES); + netdev_increment_features(&mpls_features, mpls_features, + slave->dev->mpls_features, + BOND_MPLS_FEATURES);

dst_release_flag &= slave->dev->priv_flags; if (slave->dev->hard_header_len > max_hard_header_len) diff --git a/drivers/net/ipvlan/ipvlan_main.c b/drivers/net/ipvlan/ipvlan_main.c index 8fcc91c..6a0b7bd 100644 --- a/drivers/net/ipvlan/ipvlan_main.c +++ b/drivers/net/ipvlan/ipvlan_main.c @@ -242,8 +242,8 @@ static void ipvlan_fix_features(struct net_device *dev,

*features |= NETIF_F_ALL_FOR_ALL; *features &= (ipvlan->sfeatures | ~IPVLAN_FEATURES); - *features = netdev_increment_features(ipvlan->phy_dev->features, - *features, *features); + netdev_increment_features(features, ipvlan->phy_dev->features, + *features, *features); *features |= IPVLAN_ALWAYS_ON; *features &= (IPVLAN_FEATURES | IPVLAN_ALWAYS_ON); } diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c index 27cd9c0..3c408653 100644 --- a/drivers/net/macvlan.c +++ b/drivers/net/macvlan.c @@ -1079,7 +1079,7 @@ static void macvlan_fix_features(struct net_device *dev, mask = *features;

lowerdev_features &= (*features | ~NETIF_F_LRO); - *features = netdev_increment_features(lowerdev_features, *features, mask); + netdev_increment_features(features, lowerdev_features, *features, mask); *features |= ALWAYS_ON_FEATURES; *features &= (ALWAYS_ON_FEATURES | MACVLAN_FEATURES); } diff --git a/drivers/net/net_failover.c b/drivers/net/net_failover.c index 2a48924..878cad2 100644 --- a/drivers/net/net_failover.c +++ b/drivers/net/net_failover.c @@ -390,14 +390,12 @@ static void net_failover_compute_features(struct net_device *dev)

primary_dev = rcu_dereference(nfo_info->primary_dev); if (primary_dev) { - vlan_features = - netdev_increment_features(vlan_features, - primary_dev->vlan_features, - FAILOVER_VLAN_FEATURES); - enc_features = - netdev_increment_features(enc_features, - primary_dev->hw_enc_features, - FAILOVER_ENC_FEATURES); + netdev_increment_features(&vlan_features, vlan_features, + primary_dev->vlan_features, + FAILOVER_VLAN_FEATURES); + netdev_increment_features(&enc_features, enc_features, + primary_dev->hw_enc_features, + FAILOVER_ENC_FEATURES);

dst_release_flag &= primary_dev->priv_flags; if (primary_dev->hard_header_len > max_hard_header_len) @@ -406,14 +404,12 @@ static void net_failover_compute_features(struct net_device *dev)

standby_dev = rcu_dereference(nfo_info->standby_dev); if (standby_dev) { - vlan_features = - netdev_increment_features(vlan_features, - standby_dev->vlan_features, - FAILOVER_VLAN_FEATURES); - enc_features = - netdev_increment_features(enc_features, - standby_dev->hw_enc_features, - FAILOVER_ENC_FEATURES); + netdev_increment_features(&vlan_features, vlan_features, + standby_dev->vlan_features, + FAILOVER_VLAN_FEATURES); + netdev_increment_features(&enc_features, enc_features, + standby_dev->hw_enc_features, + FAILOVER_ENC_FEATURES);

dst_release_flag &= standby_dev->priv_flags; if (standby_dev->hard_header_len > max_hard_header_len) diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c index 706572b..fa96ee6 100644 --- a/drivers/net/team/team.c +++ b/drivers/net/team/team.c @@ -994,14 +994,12 @@ static void __team_compute_features(struct team *team)

rcu_read_lock(); list_for_each_entry_rcu(port, &team->port_list, list) { - vlan_features = netdev_increment_features(vlan_features, - port->dev->vlan_features, - TEAM_VLAN_FEATURES); - enc_features = - netdev_increment_features(enc_features, - port->dev->hw_enc_features, - TEAM_ENC_FEATURES); - + netdev_increment_features(&vlan_features, vlan_features, + port->dev->vlan_features, + TEAM_VLAN_FEATURES); + netdev_increment_features(&enc_features, enc_features, + port->dev->hw_enc_features, + TEAM_ENC_FEATURES);

dst_release_flag &= port->dev->priv_flags; if (port->dev->hard_header_len > max_hard_header_len) @@ -2008,9 +2006,8 @@ static void team_fix_features(struct net_device *dev,

rcu_read_lock(); list_for_each_entry_rcu(port, &team->port_list, list) { - *features = netdev_increment_features(*features, - port->dev->features, - mask); + netdev_increment_features(features, *features, + port->dev->features, mask); } rcu_read_unlock();

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index 355526f..a82fc87 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -5009,8 +5009,8 @@ static inline void netdev_get_wanted_features(struct net_device *dev, { *wanted = (dev->features & ~dev->hw_features) | dev->wanted_features; } -netdev_features_t netdev_increment_features(netdev_features_t all, - netdev_features_t one, netdev_features_t mask); +void netdev_increment_features(netdev_features_t *ret, netdev_features_t all, + netdev_features_t one, netdev_features_t mask);

/* Allow TSO being used on stacked device : * Performing the GSO segmentation before last device @@ -5019,7 +5019,7 @@ netdev_features_t netdev_increment_features(netdev_features_t all, static inline void netdev_add_tso_features(netdev_features_t *features, netdev_features_t mask) { - *features = netdev_increment_features(*features, NETIF_F_ALL_TSO, mask); + netdev_increment_features(features, *features, NETIF_F_ALL_TSO, mask); }

int __netdev_update_features(struct net_device *dev); diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c index 7f9d65a..be64802 100644 --- a/net/bridge/br_if.c +++ b/net/bridge/br_if.c @@ -544,8 +544,8 @@ void br_features_recompute(struct net_bridge *br, netdev_features_t *features) *features &= ~NETIF_F_ONE_FOR_ALL;

list_for_each_entry(p, &br->port_list, list) { - *features = netdev_increment_features(*features, - p->dev->features, mask); + netdev_increment_features(features, *features, p->dev->features, + mask); } netdev_add_tso_features(features, mask); } diff --git a/net/core/dev.c b/net/core/dev.c index b7632f0..7f08594 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -11299,6 +11299,7 @@ static int dev_cpu_dead(unsigned int oldcpu)

/** * netdev_increment_features - increment feature set by one + * @ret: result feature set * @all: current feature set * @one: new feature set * @mask: mask feature set @@ -11307,8 +11308,8 @@ static int dev_cpu_dead(unsigned int oldcpu) * @one to the master device with current feature set @all. Will not * enable anything that is off in @mask. Returns the new feature set. */ -netdev_features_t netdev_increment_features(netdev_features_t all, - netdev_features_t one, netdev_features_t mask) +void netdev_increment_features(netdev_features_t *ret, netdev_features_t all, + netdev_features_t one, netdev_features_t mask) { if (mask & NETIF_F_HW_CSUM) mask |= NETIF_F_CSUM_MASK; @@ -11321,7 +11322,7 @@ netdev_features_t netdev_increment_features(netdev_features_t all, if (all & NETIF_F_HW_CSUM) all &= ~(NETIF_F_CSUM_MASK & ~NETIF_F_HW_CSUM);

- return all; + *ret = all; } EXPORT_SYMBOL(netdev_increment_features);

diff --git a/net/hsr/hsr_device.c b/net/hsr/hsr_device.c index acaf48a..16e0efd 100644 --- a/net/hsr/hsr_device.c +++ b/net/hsr/hsr_device.c @@ -194,9 +194,8 @@ static netdev_features_t hsr_features_recompute(struct hsr_priv *hsr, */ features &= ~NETIF_F_ONE_FOR_ALL; hsr_for_each_port(hsr, port) - features = netdev_increment_features(features, - port->dev->features, - mask); + netdev_increment_features(&features, features, + port->dev->features, mask);

return features; }

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of mlx5e_tunnel_features_check, mlx5e_ipsec_feature_check and mlx5e_fix_uplink_rep_features for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- .../mellanox/mlx5/core/en_accel/ipsec_rxtx.h | 15 +++++----- drivers/net/ethernet/mellanox/mlx5/core/en_main.c | 34 ++++++++++------------ 2 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h index 5120a59..62ab97c 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h @@ -93,8 +93,8 @@ static inline bool mlx5e_ipsec_eseg_meta(struct mlx5_wqe_eth_seg *eseg) void mlx5e_ipsec_tx_build_eseg(struct mlx5e_priv *priv, struct sk_buff *skb, struct mlx5_wqe_eth_seg *eseg);

-static inline netdev_features_t -mlx5e_ipsec_feature_check(struct sk_buff *skb, netdev_features_t features) +static inline void +mlx5e_ipsec_feature_check(struct sk_buff *skb, netdev_features_t *features) { struct xfrm_offload *xo = xfrm_offload(skb); struct sec_path *sp = skb_sec_path(skb); @@ -118,13 +118,12 @@ mlx5e_ipsec_feature_check(struct sk_buff *skb, netdev_features_t features) goto out_disable; }

- return features; - + return; }

/* Disable CSUM and GSO for software IPsec */ out_disable: - return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); }

#else @@ -140,9 +139,9 @@ static inline bool mlx5e_ipsec_eseg_meta(struct mlx5_wqe_eth_seg *eseg) }

static inline bool mlx5_ipsec_is_rx_flow(struct mlx5_cqe64 *cqe) { return false; } -static inline netdev_features_t -mlx5e_ipsec_feature_check(struct sk_buff *skb, netdev_features_t features) -{ return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); } +static inline void +mlx5e_ipsec_feature_check(struct sk_buff *skb, netdev_features_t *features) +{ *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); } #endif /* CONFIG_MLX5_EN_IPSEC */

#endif /* __MLX5E_IPSEC_RXTX_H__ */ diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c index d8c82d3..e70e8c5 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c @@ -3289,22 +3289,20 @@ int mlx5e_set_features(struct net_device *netdev, netdev_features_t features) return 0; }

-static netdev_features_t mlx5e_fix_uplink_rep_features(struct net_device *netdev, - netdev_features_t features) +static void mlx5e_fix_uplink_rep_features(struct net_device *netdev, + netdev_features_t *features) { - features &= ~NETIF_F_HW_TLS_RX; + *features &= ~NETIF_F_HW_TLS_RX; if (netdev->features & NETIF_F_HW_TLS_RX) netdev_warn(netdev, "Disabling hw_tls_rx, not supported in switchdev mode\n");

- features &= ~NETIF_F_HW_TLS_TX; + *features &= ~NETIF_F_HW_TLS_TX; if (netdev->features & NETIF_F_HW_TLS_TX) netdev_warn(netdev, "Disabling hw_tls_tx, not supported in switchdev mode\n");

- features &= ~NETIF_F_NTUPLE; + *features &= ~NETIF_F_NTUPLE; if (netdev->features & NETIF_F_NTUPLE) netdev_warn(netdev, "Disabling ntuple, not supported in switchdev mode\n"); - - return features; }

static void mlx5e_fix_features(struct net_device *netdev, @@ -3339,7 +3337,7 @@ static void mlx5e_fix_features(struct net_device *netdev, }

if (mlx5e_is_uplink_rep(priv)) - features = mlx5e_fix_uplink_rep_features(netdev, features); + mlx5e_fix_uplink_rep_features(netdev, &features);

mutex_unlock(&priv->state_lock); } @@ -3757,9 +3755,9 @@ static bool mlx5e_gre_tunnel_inner_proto_offload_supported(struct mlx5_core_dev return false; }

-static netdev_features_t mlx5e_tunnel_features_check(struct mlx5e_priv *priv, - struct sk_buff *skb, - netdev_features_t features) +static void mlx5e_tunnel_features_check(struct mlx5e_priv *priv, + struct sk_buff *skb, + netdev_features_t *features) { unsigned int offset = 0; struct udphdr *udph; @@ -3780,12 +3778,12 @@ static netdev_features_t mlx5e_tunnel_features_check(struct mlx5e_priv *priv, switch (proto) { case IPPROTO_GRE: if (mlx5e_gre_tunnel_inner_proto_offload_supported(priv->mdev, skb)) - return features; + return; break; case IPPROTO_IPIP: case IPPROTO_IPV6: if (mlx5e_tunnel_proto_supported_tx(priv->mdev, IPPROTO_IPIP)) - return features; + return; break; case IPPROTO_UDP: udph = udp_hdr(skb); @@ -3793,23 +3791,23 @@ static netdev_features_t mlx5e_tunnel_features_check(struct mlx5e_priv *priv,

/* Verify if UDP port is being offloaded by HW */ if (mlx5_vxlan_lookup_port(priv->mdev->vxlan, port)) - return features; + return;

#if IS_ENABLED(CONFIG_GENEVE) /* Support Geneve offload for default UDP port */ if (port == GENEVE_UDP_PORT && mlx5_geneve_tx_allowed(priv->mdev)) - return features; + return; #endif break; #ifdef CONFIG_MLX5_EN_IPSEC case IPPROTO_ESP: - return mlx5e_ipsec_feature_check(skb, features); + mlx5e_ipsec_feature_check(skb, *features); #endif }

out: /* Disable CSUM and GSO if the udp dport is not offloaded by HW */ - return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); }

void mlx5e_features_check(struct sk_buff *skb, struct net_device *netdev, @@ -3823,7 +3821,7 @@ void mlx5e_features_check(struct sk_buff *skb, struct net_device *netdev, /* Validate if the tunneled packet is being offloaded by HW */ if (skb->encapsulation && (*features & NETIF_F_CSUM_MASK || *features & NETIF_F_GSO_MASK)) - *features = mlx5e_tunnel_features_check(priv, skb, *features); + mlx5e_tunnel_features_check(priv, skb, features); }

static void mlx5e_tx_timeout_work(struct work_struct *work)

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of qlcnic_process_flags for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c index e6ed7f8..2367923 100644 --- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c +++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c @@ -1020,37 +1020,35 @@ int qlcnic_change_mtu(struct net_device *netdev, int mtu) return rc; }

-static netdev_features_t qlcnic_process_flags(struct qlcnic_adapter *adapter, - netdev_features_t features) +static void qlcnic_process_flags(struct qlcnic_adapter *adapter, + netdev_features_t *features) { u32 offload_flags = adapter->offload_flags;

if (offload_flags & BIT_0) { - features |= NETIF_F_RXCSUM | NETIF_F_IP_CSUM | - NETIF_F_IPV6_CSUM; + *features |= NETIF_F_RXCSUM | NETIF_F_IP_CSUM | + NETIF_F_IPV6_CSUM; adapter->rx_csum = 1; if (QLCNIC_IS_TSO_CAPABLE(adapter)) { if (!(offload_flags & BIT_1)) - features &= ~NETIF_F_TSO; + *features &= ~NETIF_F_TSO; else - features |= NETIF_F_TSO; + *features |= NETIF_F_TSO;

if (!(offload_flags & BIT_2)) - features &= ~NETIF_F_TSO6; + *features &= ~NETIF_F_TSO6; else - features |= NETIF_F_TSO6; + *features |= NETIF_F_TSO6; } } else { - features &= ~(NETIF_F_RXCSUM | + *features &= ~(NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);

if (QLCNIC_IS_TSO_CAPABLE(adapter)) - features &= ~(NETIF_F_TSO | NETIF_F_TSO6); + *features &= ~(NETIF_F_TSO | NETIF_F_TSO6); adapter->rx_csum = 0; } - - return features; }

void qlcnic_fix_features(struct net_device *netdev, netdev_features_t *features) @@ -1061,7 +1059,7 @@ void qlcnic_fix_features(struct net_device *netdev, netdev_features_t *features) if (qlcnic_82xx_check(adapter) && (adapter->flags & QLCNIC_ESWITCH_ENABLED)) { if (adapter->flags & QLCNIC_APP_CHANGED_FLAGS) { - *features = qlcnic_process_flags(adapter, *features); + qlcnic_process_flags(adapter, features); } else { changed = *features ^ netdev->features; *features ^= changed & (NETIF_F_RXCSUM |

For the origin type for netdev_features_t would be changed to be unsigned long * from u64, so changes the prototype of ethtool_get_feature_mask for adaption.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/ethtool/ioctl.c | 34 ++++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/net/ethtool/ioctl.c b/net/ethtool/ioctl.c index 81fa36a..dcfe8b3 100644 --- a/net/ethtool/ioctl.c +++ b/net/ethtool/ioctl.c @@ -194,30 +194,35 @@ static void __ethtool_get_strings(struct net_device *dev, ops->get_strings(dev, stringset, data); }

-static netdev_features_t ethtool_get_feature_mask(u32 eth_cmd) +static void ethtool_get_feature_mask(u32 eth_cmd, netdev_features_t *mask) { /* feature masks of legacy discrete ethtool ops */

switch (eth_cmd) { case ETHTOOL_GTXCSUM: case ETHTOOL_STXCSUM: - return NETIF_F_CSUM_MASK | NETIF_F_FCOE_CRC | - NETIF_F_SCTP_CRC; + *mask = NETIF_F_CSUM_MASK | NETIF_F_FCOE_CRC | NETIF_F_SCTP_CRC; + break; case ETHTOOL_GRXCSUM: case ETHTOOL_SRXCSUM: - return NETIF_F_RXCSUM; + *mask = NETIF_F_RXCSUM; + break; case ETHTOOL_GSG: case ETHTOOL_SSG: - return NETIF_F_SG | NETIF_F_FRAGLIST; + *mask = NETIF_F_SG | NETIF_F_FRAGLIST; + break; case ETHTOOL_GTSO: case ETHTOOL_STSO: - return NETIF_F_ALL_TSO; + *mask = NETIF_F_ALL_TSO; + break; case ETHTOOL_GGSO: case ETHTOOL_SGSO: - return NETIF_F_GSO; + *mask = NETIF_F_GSO; + break; case ETHTOOL_GGRO: case ETHTOOL_SGRO: - return NETIF_F_GRO; + *mask = NETIF_F_GRO; + break; default: BUG(); } @@ -226,11 +231,12 @@ static netdev_features_t ethtool_get_feature_mask(u32 eth_cmd) static int ethtool_get_one_feature(struct net_device *dev, char __user *useraddr, u32 ethcmd) { - netdev_features_t mask = ethtool_get_feature_mask(ethcmd); - struct ethtool_value edata = { - .cmd = ethcmd, - .data = !!(dev->features & mask), - }; + struct ethtool_value edata; + netdev_features_t mask; + + ethtool_get_feature_mask(ethcmd, &mask); + edata.cmd = ethcmd; + edata.data = !!(dev->features & mask);

if (copy_to_user(useraddr, &edata, sizeof(edata))) return -EFAULT; @@ -246,7 +252,7 @@ static int ethtool_set_one_feature(struct net_device *dev, if (copy_from_user(&edata, useraddr, sizeof(edata))) return -EFAULT;

- mask = ethtool_get_feature_mask(ethcmd); + ethtool_get_feature_mask(ethcmd, &mask); mask &= dev->hw_features; if (!mask) return -EOPNOTSUPP;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- include/linux/netdevice.h | 78 +++++++----- net/core/dev.c | 315 +++++++++++++++++++++++++++------------------- 2 files changed, 236 insertions(+), 157 deletions(-)

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index a82fc87..51fdb9f 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -2266,7 +2266,8 @@ struct net_device {

static inline bool netif_elide_gro(const struct net_device *dev) { - if (!(dev->features & NETIF_F_GRO) || dev->xdp_prog) + if (!netdev_feature_test_bit(NETIF_F_GRO_BIT, dev->features) || + dev->xdp_prog) return true; return false; } @@ -4506,25 +4507,28 @@ static inline void netif_tx_unlock_bh(struct net_device *dev) local_bh_enable(); }

-#define HARD_TX_LOCK(dev, txq, cpu) { \ - if ((dev->features & NETIF_F_LLTX) == 0) { \ - __netif_tx_lock(txq, cpu); \ - } else { \ - __netif_tx_acquire(txq); \ - } \ +#define HARD_TX_LOCK(dev, txq, cpu) { \ + if (!netdev_feature_test_bit(NETIF_F_LLTX_BIT, \ + dev->features)) { \ + __netif_tx_lock(txq, cpu); \ + } else { \ + __netif_tx_acquire(txq); \ + } \ }

-#define HARD_TX_TRYLOCK(dev, txq) \ - (((dev->features & NETIF_F_LLTX) == 0) ? \ - __netif_tx_trylock(txq) : \ +#define HARD_TX_TRYLOCK(dev, txq) \ + (!netdev_feature_test_bit(NETIF_F_LLTX_BIT, \ + dev->features) ? \ + __netif_tx_trylock(txq) : \ __netif_tx_acquire(txq))

-#define HARD_TX_UNLOCK(dev, txq) { \ - if ((dev->features & NETIF_F_LLTX) == 0) { \ - __netif_tx_unlock(txq); \ - } else { \ - __netif_tx_release(txq); \ - } \ +#define HARD_TX_UNLOCK(dev, txq) { \ + if (!netdev_feature_test_bit(NETIF_F_LLTX_BIT, \ + dev->features)) { \ + __netif_tx_unlock(txq); \ + } else { \ + __netif_tx_release(txq); \ + } \ }

static inline void netif_tx_disable(struct net_device *dev) @@ -4916,20 +4920,20 @@ static inline bool can_checksum_protocol(netdev_features_t features, __be16 protocol) { if (protocol == htons(ETH_P_FCOE)) - return !!(features & NETIF_F_FCOE_CRC); + return netdev_feature_test_bit(NETIF_F_FCOE_CRC_BIT, features);

/* Assume this is an IP checksum (not SCTP CRC) */

- if (features & NETIF_F_HW_CSUM) { + if (netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, features)) { /* Can checksum everything */ return true; }

switch (protocol) { case htons(ETH_P_IP): - return !!(features & NETIF_F_IP_CSUM); + return netdev_feature_test_bit(NETIF_F_IP_CSUM_BIT, features); case htons(ETH_P_IPV6): - return !!(features & NETIF_F_IPV6_CSUM); + return netdev_feature_test_bit(NETIF_F_IPV6_CSUM_BIT, features); default: return false; } @@ -4994,21 +4998,26 @@ static inline void netdev_intersect_features(netdev_features_t *ret, netdev_features_t f1, netdev_features_t f2) { - if ((f1 ^ f2) & NETIF_F_HW_CSUM) { - if (f1 & NETIF_F_HW_CSUM) - f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM); + if (netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, f1) != + netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, f2)) { + if (netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, f1)) + netdev_feature_set_bits(NETIF_F_IP_CSUM | + NETIF_F_IPV6_CSUM, &f1); else - f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM); + netdev_feature_set_bits(NETIF_F_IP_CSUM | + NETIF_F_IPV6_CSUM, &f2); }

- *ret = f1 & f2; + netdev_feature_and(ret, f1, f2); }

static inline void netdev_get_wanted_features(struct net_device *dev, netdev_features_t *wanted) { - *wanted = (dev->features & ~dev->hw_features) | dev->wanted_features; + netdev_feature_andnot(wanted, dev->features, dev->hw_features); + netdev_feature_or(wanted, *wanted, dev->wanted_features); } + void netdev_increment_features(netdev_features_t *ret, netdev_features_t all, netdev_features_t one, netdev_features_t mask);

@@ -5019,7 +5028,11 @@ void netdev_increment_features(netdev_features_t *ret, netdev_features_t all, static inline void netdev_add_tso_features(netdev_features_t *features, netdev_features_t mask) { - netdev_increment_features(features, *features, NETIF_F_ALL_TSO, mask); + netdev_features_t one; + + netdev_feature_zero(&one); + netdev_feature_set_bits(NETIF_F_ALL_TSO, &one); + netdev_increment_features(features, *features, one, mask); }

int __netdev_update_features(struct net_device *dev); @@ -5035,7 +5048,7 @@ void netif_skb_features(struct sk_buff *skb, netdev_features_t *features);

static inline bool net_gso_ok(netdev_features_t features, int gso_type) { - netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT; + netdev_features_t feature;

/* check flags correspondence */ BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT)); @@ -5058,13 +5071,18 @@ static inline bool net_gso_ok(netdev_features_t features, int gso_type) BUILD_BUG_ON(SKB_GSO_UDP_L4 != (NETIF_F_GSO_UDP_L4 >> NETIF_F_GSO_SHIFT)); BUILD_BUG_ON(SKB_GSO_FRAGLIST != (NETIF_F_GSO_FRAGLIST >> NETIF_F_GSO_SHIFT));

- return (features & feature) == feature; + netdev_feature_zero(&feature); + netdev_feature_set_bit((u64)gso_type << NETIF_F_GSO_SHIFT, &feature); + + return netdev_feature_subset(features, feature); + }

static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features) { return net_gso_ok(features, skb_shinfo(skb)->gso_type) && - (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST)); + (!skb_has_frag_list(skb) || + netdev_feature_test_bit(NETIF_F_FRAGLIST_BIT, features)); }

static inline bool netif_needs_gso(struct sk_buff *skb, diff --git a/net/core/dev.c b/net/core/dev.c index 7f08594..a71d35d 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -1636,10 +1636,10 @@ void dev_disable_lro(struct net_device *dev) struct net_device *lower_dev; struct list_head *iter;

- dev->wanted_features &= ~NETIF_F_LRO; + netdev_feature_clear_bit(NETIF_F_LRO_BIT, &dev->wanted_features); netdev_update_features(dev);

- if (unlikely(dev->features & NETIF_F_LRO)) + if (unlikely(netdev_feature_test_bit(NETIF_F_LRO_BIT, dev->features))) netdev_WARN(dev, "failed to disable LRO!\n");

netdev_for_each_lower_dev(dev, lower_dev, iter) @@ -1657,10 +1657,12 @@ EXPORT_SYMBOL(dev_disable_lro); */ static void dev_disable_gro_hw(struct net_device *dev) { - dev->wanted_features &= ~NETIF_F_GRO_HW; + netdev_feature_clear_bit(NETIF_F_GRO_HW_BIT, &dev->wanted_features); netdev_update_features(dev);

- if (unlikely(dev->features & NETIF_F_GRO_HW)) + if (unlikely(netdev_feature_test_bit(NETIF_F_GRO_HW_BIT, + dev->features))) + netdev_WARN(dev, "failed to disable GRO_HW!\n"); }

@@ -3377,13 +3379,19 @@ struct sk_buff *__skb_gso_segment(struct sk_buff *skb, * support segmentation on this frame without needing additional * work. */ - if (features & NETIF_F_GSO_PARTIAL) { - netdev_features_t partial_features = NETIF_F_GSO_ROBUST; + if (netdev_feature_test_bit(NETIF_F_GSO_PARTIAL_BIT, features)) { + netdev_features_t partial_features; struct net_device *dev = skb->dev;

- partial_features |= dev->features & dev->gso_partial_features; - if (!skb_gso_ok(skb, features | partial_features)) - features &= ~NETIF_F_GSO_PARTIAL; + netdev_feature_and(&partial_features, dev->features, + dev->gso_partial_features); + netdev_feature_set_bit(NETIF_F_GSO_ROBUST_BIT, + &partial_features); + netdev_feature_or(&partial_features, partial_features, + features); + if (!skb_gso_ok(skb, partial_features)) + netdev_feature_clear_bit(NETIF_F_GSO_PARTIAL_BIT, + &features); }

BUILD_BUG_ON(SKB_GSO_CB_OFFSET + @@ -3426,7 +3434,7 @@ static int illegal_highdma(struct net_device *dev, struct sk_buff *skb) #ifdef CONFIG_HIGHMEM int i;

- if (!(dev->features & NETIF_F_HIGHDMA)) { + if (!netdev_feature_test_bit(NETIF_F_HIGHDMA_BIT, dev->features)) { for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { skb_frag_t *frag = &skb_shinfo(skb)->frags[i];

@@ -3446,7 +3454,8 @@ static void net_mpls_features(struct sk_buff *skb, netdev_features_t *features, __be16 type) { if (eth_p_mpls(type)) - *features &= skb->dev->mpls_features; + netdev_feature_and(features, *features, + skb->dev->mpls_features); } #else static void net_mpls_features(struct sk_buff *skb, netdev_features_t *features, @@ -3464,10 +3473,11 @@ static void harmonize_features(struct sk_buff *skb, netdev_features_t *features)

if (skb->ip_summed != CHECKSUM_NONE && !can_checksum_protocol(*features, type)) { - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); } if (illegal_highdma(skb->dev, skb)) - *features &= ~NETIF_F_SG; + netdev_feature_clear_bit(NETIF_F_SG_BIT, features); }

void passthru_features_check(struct sk_buff *skb, struct net_device *dev, @@ -3490,13 +3500,13 @@ static void gso_features_check(const struct sk_buff *skb, u16 gso_segs = skb_shinfo(skb)->gso_segs;

if (gso_segs > dev->gso_max_segs) { - *features &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, features); return; }

if (!skb_shinfo(skb)->gso_type) { skb_warn_bad_offload(skb); - *features &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, features); return; }

@@ -3507,7 +3517,8 @@ static void gso_features_check(const struct sk_buff *skb, * segmented the frame. */ if (!(skb_shinfo(skb)->gso_type & SKB_GSO_PARTIAL)) - *features &= ~dev->gso_partial_features; + netdev_feature_andnot(features, *features, + dev->gso_partial_features);

/* Make sure to clear the IPv4 ID mangling feature if the * IPv4 header has the potential to be fragmented. @@ -3517,7 +3528,8 @@ static void gso_features_check(const struct sk_buff *skb, inner_ip_hdr(skb) : ip_hdr(skb);

if (!(iph->frag_off & htons(IP_DF))) - *features &= ~NETIF_F_TSO_MANGLEID; + netdev_feature_clear_bit(NETIF_F_TSO_MANGLEID_BIT, + features); } }

@@ -3525,7 +3537,7 @@ void netif_skb_features(struct sk_buff *skb, netdev_features_t *features) { struct net_device *dev = skb->dev;

- *features = dev->features; + netdev_feature_copy(features, dev->features);

if (skb_is_gso(skb)) gso_features_check(skb, dev, features); @@ -3535,13 +3547,16 @@ void netif_skb_features(struct sk_buff *skb, netdev_features_t *features) * features for the netdev */ if (skb->encapsulation) - *features &= dev->hw_enc_features; + netdev_feature_and(features, *features, dev->hw_enc_features); + + if (skb_vlan_tagged(skb)) { + netdev_features_t tmp;

- if (skb_vlan_tagged(skb)) - netdev_intersect_features(features, *features, - dev->vlan_features | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_STAG_TX); + netdev_feature_copy(&tmp, dev->vlan_features); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_TX_BIT | + NETIF_F_HW_VLAN_STAG_TX_BIT, &tmp); + netdev_intersect_features(features, *features, tmp); + }

if (dev->netdev_ops->ndo_features_check) dev->netdev_ops->ndo_features_check(skb, dev, features); @@ -3611,13 +3626,14 @@ int skb_csum_hwoffload_help(struct sk_buff *skb, const netdev_features_t features) { if (unlikely(skb_csum_is_sctp(skb))) - return !!(features & NETIF_F_SCTP_CRC) ? 0 : - skb_crc32c_csum_help(skb); + return netdev_feature_test_bit(NETIF_F_SCTP_CRC_BIT, features) ? + 0 : skb_crc32c_csum_help(skb);

- if (features & NETIF_F_HW_CSUM) + if (netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, features)) return 0;

- if (features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)) { + if (netdev_feature_test_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM, + features)) { switch (skb->csum_offset) { case offsetof(struct tcphdr, check): case offsetof(struct udphdr, check): @@ -4349,7 +4365,8 @@ set_rps_cpu(struct net_device *dev, struct sk_buff *skb,

/* Should we steer this flow to a different hardware queue? */ if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap || - !(dev->features & NETIF_F_NTUPLE)) + !netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, + dev->features)) goto out; rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu); if (rxq_index == skb_get_rx_queue(skb)) @@ -9774,17 +9791,19 @@ static void netdev_sync_upper_features(struct net_device *lower, struct net_device *upper, netdev_features_t *features) { - netdev_features_t upper_disables = NETIF_F_UPPER_DISABLES; - netdev_features_t feature; + netdev_features_t upper_disables; int feature_bit;

+ netdev_feature_zero(&upper_disables); + netdev_feature_set_bits(NETIF_F_UPPER_DISABLES, &upper_disables); + for_each_netdev_feature(upper_disables, feature_bit) { - feature = __NETIF_F_BIT(feature_bit); - if (!(upper->wanted_features & feature) && - (*features & feature)) { - netdev_dbg(lower, "Dropping feature %pNF, upper dev %s has it off.\n", - &feature, upper->name); - *features &= ~feature; + if (!netdev_feature_test_bit(feature_bit, + upper->wanted_features) && + netdev_feature_test_bit(feature_bit, *features)) { + netdev_dbg(lower, "Dropping feature bit %d, upper dev %s has it off.\n", + feature_bit, upper->name); + netdev_feature_clear_bit(feature_bit, features); } } } @@ -9792,21 +9811,25 @@ static void netdev_sync_upper_features(struct net_device *lower, static void netdev_sync_lower_features(struct net_device *upper, struct net_device *lower, netdev_features_t features) { - netdev_features_t upper_disables = NETIF_F_UPPER_DISABLES; - netdev_features_t feature; + netdev_features_t upper_disables; int feature_bit;

+ netdev_feature_zero(&upper_disables); + netdev_feature_set_bits(NETIF_F_UPPER_DISABLES, &upper_disables); + for_each_netdev_feature(upper_disables, feature_bit) { - feature = __NETIF_F_BIT(feature_bit); - if (!(features & feature) && (lower->features & feature)) { - netdev_dbg(upper, "Disabling feature %pNF on lower dev %s.\n", - &feature, lower->name); - lower->wanted_features &= ~feature; + if (!netdev_feature_test_bit(feature_bit, features) && + netdev_feature_test_bit(feature_bit, lower->features)) { + netdev_dbg(upper, "Disabling feature bit %d on lower dev %s.\n", + feature_bit, lower->name); + netdev_feature_clear_bit(feature_bit, + &lower->wanted_features); __netdev_update_features(lower);

- if (unlikely(lower->features & feature)) - netdev_WARN(upper, "failed to disable %pNF on %s!\n", - &feature, lower->name); + if (unlikely(netdev_feature_test_bit(feature_bit, + lower->features))) + netdev_WARN(upper, "failed to disable feature bit %d on %s!\n", + feature_bit, lower->name); else netdev_features_change(lower); } @@ -9817,92 +9840,102 @@ static void netdev_fix_features(struct net_device *dev, netdev_features_t *features) { /* Fix illegal checksum combinations */ - if ((*features & NETIF_F_HW_CSUM) && - (*features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM))) { + if (netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, *features) && + (netdev_feature_test_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM, + *features))) { netdev_warn(dev, "mixed HW and IP checksum settings.\n"); - *features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM); + netdev_feature_clear_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM, + features); }

/* TSO requires that SG is present as well. */ - if ((*features & NETIF_F_ALL_TSO) && !(*features & NETIF_F_SG)) { + if (netdev_feature_test_bits(NETIF_F_ALL_TSO, *features) && + !netdev_feature_test_bit(NETIF_F_SG_BIT, *features)) { netdev_dbg(dev, "Dropping TSO features since no SG feature.\n"); - *features &= ~NETIF_F_ALL_TSO; + netdev_feature_clear_bits(NETIF_F_ALL_TSO, features); }

- if ((*features & NETIF_F_TSO) && !(*features & NETIF_F_HW_CSUM) && - !(*features & NETIF_F_IP_CSUM)) { + if (netdev_feature_test_bit(NETIF_F_TSO_BIT, *features) && + !netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, *features) && + !netdev_feature_test_bit(NETIF_F_IP_CSUM_BIT, *features)) { netdev_dbg(dev, "Dropping TSO features since no CSUM feature.\n"); - *features &= ~NETIF_F_TSO; - *features &= ~NETIF_F_TSO_ECN; + netdev_feature_clear_bit(NETIF_F_TSO_BIT, features); + netdev_feature_clear_bit(NETIF_F_TSO_ECN_BIT, features); }

- if ((*features & NETIF_F_TSO6) && !(*features & NETIF_F_HW_CSUM) && - !(*features & NETIF_F_IPV6_CSUM)) { + if (netdev_feature_test_bit(NETIF_F_TSO6_BIT, *features) && + !netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, *features) && + !netdev_feature_test_bit(NETIF_F_IPV6_CSUM_BIT, *features)) { netdev_dbg(dev, "Dropping TSO6 features since no CSUM feature.\n"); - *features &= ~NETIF_F_TSO6; + netdev_feature_clear_bit(NETIF_F_TSO6_BIT, features); }

/* TSO with IPv4 ID mangling requires IPv4 TSO be enabled */ - if ((*features & NETIF_F_TSO_MANGLEID) && !(*features & NETIF_F_TSO)) - *features &= ~NETIF_F_TSO_MANGLEID; + if (netdev_feature_test_bit(NETIF_F_TSO_MANGLEID_BIT, *features) && + !netdev_feature_test_bit(NETIF_F_TSO_BIT, *features)) + netdev_feature_clear_bit(NETIF_F_TSO_MANGLEID_BIT, features);

/* TSO ECN requires that TSO is present as well. */ - if ((*features & NETIF_F_ALL_TSO) == NETIF_F_TSO_ECN) - *features &= ~NETIF_F_TSO_ECN; + if (netdev_feature_test_bit(NETIF_F_TSO_ECN_BIT, *features) && + !netdev_feature_test_bits(NETIF_F_ALL_TSO & ~NETIF_F_TSO_ECN, + *features)) + netdev_feature_clear_bit(NETIF_F_TSO_ECN_BIT, features);

/* Software GSO depends on SG. */ - if ((*features & NETIF_F_GSO) && !(*features & NETIF_F_SG)) { + if (netdev_feature_test_bit(NETIF_F_GSO_BIT, *features) && + !netdev_feature_test_bit(NETIF_F_SG_BIT, *features)) { netdev_dbg(dev, "Dropping NETIF_F_GSO since no SG feature.\n"); - *features &= ~NETIF_F_GSO; + netdev_feature_clear_bit(NETIF_F_GSO_BIT, features); }

/* GSO partial features require GSO partial be set */ - if ((*features & dev->gso_partial_features) && - !(*features & NETIF_F_GSO_PARTIAL)) { + if (netdev_feature_intersects(*features, dev->gso_partial_features) && + !netdev_feature_test_bit(NETIF_F_GSO_PARTIAL_BIT, *features)) { netdev_dbg(dev, "Dropping partially supported GSO features since no GSO partial.\n"); - *features &= ~dev->gso_partial_features; + netdev_feature_andnot(features, *features, + dev->gso_partial_features); }

- if (!(*features & NETIF_F_RXCSUM)) { + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, *features)) { /* NETIF_F_GRO_HW implies doing RXCSUM since every packet * successfully merged by hardware must also have the * checksum verified by hardware. If the user does not * want to enable RXCSUM, logically, we should disable GRO_HW. */ - if (*features & NETIF_F_GRO_HW) { + if (netdev_feature_test_bit(NETIF_F_GRO_HW_BIT, *features)) { netdev_dbg(dev, "Dropping NETIF_F_GRO_HW since no RXCSUM feature.\n"); - *features &= ~NETIF_F_GRO_HW; + netdev_feature_clear_bit(NETIF_F_GRO_HW_BIT, features); } }

/* LRO/HW-GRO features cannot be combined with RX-FCS */ - if (*features & NETIF_F_RXFCS) { - if (*features & NETIF_F_LRO) { + if (netdev_feature_test_bit(NETIF_F_RXFCS_BIT, *features)) { + if (netdev_feature_test_bit(NETIF_F_LRO_BIT, *features)) { netdev_dbg(dev, "Dropping LRO feature since RX-FCS is requested.\n"); - *features &= ~NETIF_F_LRO; + netdev_feature_clear_bit(NETIF_F_LRO_BIT, features); }

- if (*features & NETIF_F_GRO_HW) { + if (netdev_feature_test_bit(NETIF_F_GRO_HW_BIT, *features)) { netdev_dbg(dev, "Dropping HW-GRO feature since RX-FCS is requested.\n"); - *features &= ~NETIF_F_GRO_HW; + netdev_feature_clear_bit(NETIF_F_GRO_HW_BIT, features); } }

- if (*features & NETIF_F_HW_TLS_TX) { - bool ip_csum = (*features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)) == - (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM); - bool hw_csum = *features & NETIF_F_HW_CSUM; - - if (!ip_csum && !hw_csum) { + if (netdev_feature_test_bit(NETIF_F_HW_TLS_TX_BIT, *features)) { + if (!netdev_feature_test_bit(NETIF_F_IP_CSUM_BIT, *features) || + !netdev_feature_test_bit(NETIF_F_IPV6_CSUM_BIT, *features) || + !netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, *features)) { netdev_dbg(dev, "Dropping TLS TX HW offload feature since no CSUM feature.\n"); - *features &= ~NETIF_F_HW_TLS_TX; + netdev_feature_clear_bit(NETIF_F_HW_TLS_TX_BIT, + features); } }

- if ((*features & NETIF_F_HW_TLS_RX) && !(*features & NETIF_F_RXCSUM)) { + if (netdev_feature_test_bit(NETIF_F_HW_TLS_RX_BIT, *features) && + !netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, *features)) { netdev_dbg(dev, "Dropping TLS RX HW offload feature since no RXCSUM feature.\n"); - *features &= ~NETIF_F_HW_TLS_RX; + netdev_feature_clear_bit(NETIF_F_HW_TLS_RX_BIT, features); } }

@@ -9927,7 +9960,7 @@ int __netdev_update_features(struct net_device *dev) netdev_for_each_upper_dev_rcu(dev, upper, iter) netdev_sync_upper_features(dev, upper, &features);

- if (dev->features == features) + if (netdev_feature_equal(dev->features, features)) goto sync_lower;

netdev_dbg(dev, "Features changed: %pNF -> %pNF\n", @@ -9956,9 +9989,11 @@ int __netdev_update_features(struct net_device *dev) netdev_sync_lower_features(dev, lower, features);

if (!err) { - netdev_features_t diff = features ^ dev->features; + netdev_features_t diff; + + netdev_feature_xor(&diff, features, dev->features);

- if (diff & NETIF_F_RX_UDP_TUNNEL_PORT) { + if (netdev_feature_test_bit(NETIF_F_RX_UDP_TUNNEL_PORT_BIT, diff)) { /* udp_tunnel_{get,drop}_rx_info both need * NETIF_F_RX_UDP_TUNNEL_PORT enabled on the * device, or they won't do anything. @@ -9966,33 +10001,36 @@ int __netdev_update_features(struct net_device *dev) * *before* calling udp_tunnel_get_rx_info, * but *after* calling udp_tunnel_drop_rx_info. */ - if (features & NETIF_F_RX_UDP_TUNNEL_PORT) { - dev->features = features; + if (netdev_feature_test_bit(NETIF_F_RX_UDP_TUNNEL_PORT_BIT, + features)) { + netdev_feature_copy(&dev->features, features); udp_tunnel_get_rx_info(dev); } else { udp_tunnel_drop_rx_info(dev); } }

- if (diff & NETIF_F_HW_VLAN_CTAG_FILTER) { - if (features & NETIF_F_HW_VLAN_CTAG_FILTER) { - dev->features = features; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, diff)) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + features)) { + netdev_feature_copy(&dev->features, features); err |= vlan_get_rx_ctag_filter_info(dev); } else { vlan_drop_rx_ctag_filter_info(dev); } }

- if (diff & NETIF_F_HW_VLAN_STAG_FILTER) { - if (features & NETIF_F_HW_VLAN_STAG_FILTER) { - dev->features = features; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_STAG_FILTER_BIT, diff)) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_STAG_FILTER_BIT, + features)) { + netdev_feature_copy(&dev->features, features); err |= vlan_get_rx_stag_filter_info(dev); } else { vlan_drop_rx_stag_filter_info(dev); } }

- dev->features = features; + netdev_feature_copy(&dev->features, features); }

return err < 0 ? 0 : 1; @@ -10218,8 +10256,10 @@ int register_netdevice(struct net_device *dev) } }

- if (((dev->hw_features | dev->features) & - NETIF_F_HW_VLAN_CTAG_FILTER) && + if ((netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + dev->hw_features) || + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + dev->features)) && (!dev->netdev_ops->ndo_vlan_rx_add_vid || !dev->netdev_ops->ndo_vlan_rx_kill_vid)) { netdev_WARN(dev, "Buggy VLAN acceleration in driver!\n"); @@ -10236,44 +10276,54 @@ int register_netdevice(struct net_device *dev) /* Transfer changeable features to wanted_features and enable * software offloads (GSO and GRO). */ - dev->hw_features |= (NETIF_F_SOFT_FEATURES | NETIF_F_SOFT_FEATURES_OFF); - dev->features |= NETIF_F_SOFT_FEATURES; + netdev_feature_set_bits(NETIF_F_SOFT_FEATURES | NETIF_F_SOFT_FEATURES_OFF, + &dev->hw_features); + netdev_feature_set_bits(NETIF_F_SOFT_FEATURES, &dev->features);

if (dev->udp_tunnel_nic_info) { - dev->features |= NETIF_F_RX_UDP_TUNNEL_PORT; - dev->hw_features |= NETIF_F_RX_UDP_TUNNEL_PORT; + netdev_feature_set_bit(NETIF_F_RX_UDP_TUNNEL_PORT_BIT, + &dev->features); + netdev_feature_set_bit(NETIF_F_RX_UDP_TUNNEL_PORT_BIT, + &dev->hw_features); }

- dev->wanted_features = dev->features & dev->hw_features; + netdev_feature_and(&dev->wanted_features, dev->features, + dev->hw_features);

if (!(dev->flags & IFF_LOOPBACK)) - dev->hw_features |= NETIF_F_NOCACHE_COPY; + netdev_feature_set_bit(NETIF_F_NOCACHE_COPY_BIT, + &dev->hw_features);

/* If IPv4 TCP segmentation offload is supported we should also * allow the device to enable segmenting the frame with the option * of ignoring a static IP ID value. This doesn't enable the * feature itself but allows the user to enable it later. */ - if (dev->hw_features & NETIF_F_TSO) - dev->hw_features |= NETIF_F_TSO_MANGLEID; - if (dev->vlan_features & NETIF_F_TSO) - dev->vlan_features |= NETIF_F_TSO_MANGLEID; - if (dev->mpls_features & NETIF_F_TSO) - dev->mpls_features |= NETIF_F_TSO_MANGLEID; - if (dev->hw_enc_features & NETIF_F_TSO) - dev->hw_enc_features |= NETIF_F_TSO_MANGLEID; + if (netdev_feature_test_bit(NETIF_F_TSO_BIT, dev->hw_features)) + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &dev->hw_features); + if (netdev_feature_test_bit(NETIF_F_TSO_BIT, dev->vlan_features)) + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &dev->vlan_features); + if (netdev_feature_test_bit(NETIF_F_TSO_BIT, dev->mpls_features)) + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &dev->mpls_features); + if (netdev_feature_test_bit(NETIF_F_TSO_BIT, dev->hw_enc_features)) + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &dev->hw_enc_features);

/* Make NETIF_F_HIGHDMA inheritable to VLAN devices. */ - dev->vlan_features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &dev->vlan_features);

/* Make NETIF_F_SG inheritable to tunnel devices. */ - dev->hw_enc_features |= NETIF_F_SG | NETIF_F_GSO_PARTIAL; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_GSO_PARTIAL, + &dev->hw_enc_features);

/* Make NETIF_F_SG inheritable to MPLS. */ - dev->mpls_features |= NETIF_F_SG; + netdev_feature_set_bit(NETIF_F_SG_BIT, &dev->mpls_features);

ret = call_netdevice_notifiers(NETDEV_POST_INIT, dev); ret = notifier_to_errno(ret); @@ -11114,7 +11164,7 @@ int __dev_change_net_namespace(struct net_device *dev, struct net *net,

/* Don't allow namespace local devices to be moved. */ err = -EINVAL; - if (dev->features & NETIF_F_NETNS_LOCAL) + if (netdev_feature_test_bit(NETIF_F_NETNS_LOCAL_BIT, dev->features)) goto out;

/* Ensure the device has been registrered */ @@ -11311,18 +11361,28 @@ static int dev_cpu_dead(unsigned int oldcpu) void netdev_increment_features(netdev_features_t *ret, netdev_features_t all, netdev_features_t one, netdev_features_t mask) { - if (mask & NETIF_F_HW_CSUM) - mask |= NETIF_F_CSUM_MASK; - mask |= NETIF_F_VLAN_CHALLENGED; + netdev_features_t tmp;

- all |= one & (NETIF_F_ONE_FOR_ALL | NETIF_F_CSUM_MASK) & mask; - all &= one | ~NETIF_F_ALL_FOR_ALL; + if (netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, mask)) + netdev_feature_set_bits(NETIF_F_CSUM_MASK, &mask); + netdev_feature_set_bit(NETIF_F_VLAN_CHALLENGED_BIT, &mask);

- /* If one device supports hw checksumming, set for all. */ - if (all & NETIF_F_HW_CSUM) - all &= ~(NETIF_F_CSUM_MASK & ~NETIF_F_HW_CSUM); + netdev_feature_copy(ret, all); + netdev_feature_zero(&tmp); + netdev_feature_set_bits(NETIF_F_ONE_FOR_ALL | NETIF_F_CSUM_MASK, &tmp); + netdev_feature_and(&tmp, tmp, one); + netdev_feature_and(&tmp, tmp, mask); + netdev_feature_or(ret, *ret, tmp);

- *ret = all; + netdev_feature_fill(&tmp); + netdev_feature_clear_bits(NETIF_F_ALL_FOR_ALL, &tmp); + netdev_feature_or(&tmp, tmp, one); + netdev_feature_and(ret, *ret, tmp); + + /* If one device supports hw checksumming, set for all. */ + if (netdev_feature_test_bit(NETIF_F_HW_CSUM_BIT, *ret)) + netdev_feature_clear_bits(NETIF_F_CSUM_MASK & ~NETIF_F_HW_CSUM, + ret); } EXPORT_SYMBOL(netdev_increment_features);

@@ -11475,7 +11535,8 @@ static void __net_exit default_device_exit(struct net *net) char fb_name[IFNAMSIZ];

/* Ignore unmoveable devices (i.e. loopback) */ - if (dev->features & NETIF_F_NETNS_LOCAL) + if (netdev_feature_test_bit(NETIF_F_NETNS_LOCAL_BIT, + dev->features)) continue;

/* Leave virtual devices for the generic cleanup */

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- include/linux/if_vlan.h | 16 ++++++++++------ net/8021q/vlan.c | 11 +++++++---- net/8021q/vlan.h | 22 ++++++++++++---------- net/8021q/vlan_core.c | 6 ++++-- net/8021q/vlan_dev.c | 47 ++++++++++++++++++++++++++++------------------- 5 files changed, 61 insertions(+), 41 deletions(-)

diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h index 2337538..9696e7a 100644 --- a/include/linux/if_vlan.h +++ b/include/linux/if_vlan.h @@ -313,9 +313,11 @@ static inline bool eth_type_vlan(__be16 ethertype) static inline bool vlan_hw_offload_capable(netdev_features_t features, __be16 proto) { - if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX) + if (proto == htons(ETH_P_8021Q) && + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features)) return true; - if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX) + if (proto == htons(ETH_P_8021AD) && + netdev_feature_test_bit(NETIF_F_HW_VLAN_STAG_TX_BIT, features)) return true; return false; } @@ -563,7 +565,8 @@ static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, */ static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) { - if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + skb->dev->features)) { return __vlan_hwaccel_get_tag(skb, vlan_tci); } else { return __vlan_get_tag(skb, vlan_tci); @@ -736,9 +739,10 @@ static inline void vlan_features_check(struct sk_buff *skb, * sure that only devices supporting NETIF_F_HW_CSUM will * have checksum offloading support. */ - *features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | - NETIF_F_FRAGLIST | NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_STAG_TX; + netdev_feature_clear_bits(NETIF_F_SG | NETIF_F_HIGHDMA | + NETIF_F_HW_CSUM | NETIF_F_FRAGLIST | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_STAG_TX, features); } }

diff --git a/net/8021q/vlan.c b/net/8021q/vlan.c index 55275ef..8a50def 100644 --- a/net/8021q/vlan.c +++ b/net/8021q/vlan.c @@ -134,7 +134,8 @@ int vlan_check_real_dev(struct net_device *real_dev, { const char *name = real_dev->name;

- if (real_dev->features & NETIF_F_VLAN_CHALLENGED) { + if (netdev_feature_test_bit(NETIF_F_VLAN_CHALLENGED_BIT, + real_dev->features)) { pr_info("VLANs not supported on %s\n", name); NL_SET_ERR_MSG_MOD(extack, "VLANs not supported on device"); return -EOPNOTSUPP; @@ -339,7 +340,7 @@ static void vlan_transfer_features(struct net_device *dev,

vlandev->priv_flags &= ~IFF_XMIT_DST_RELEASE; vlandev->priv_flags |= (vlan->real_dev->priv_flags & IFF_XMIT_DST_RELEASE); - vlandev->hw_enc_features = vlan_tnl_features(vlan->real_dev); + vlan_tnl_features(vlan->real_dev, &vlandev->hw_enc_features);

netdev_update_features(vlandev); } @@ -386,13 +387,15 @@ static int vlan_device_event(struct notifier_block *unused, unsigned long event, }

if ((event == NETDEV_UP) && - (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) { + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + dev->features)) { pr_info("adding VLAN 0 to HW filter on device %s\n", dev->name); vlan_vid_add(dev, htons(ETH_P_8021Q), 0); } if (event == NETDEV_DOWN && - (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + dev->features)) vlan_vid_del(dev, htons(ETH_P_8021Q), 0);

vlan_info = rtnl_dereference(dev->vlan_info); diff --git a/net/8021q/vlan.h b/net/8021q/vlan.h index 1a705a4..10b792e 100644 --- a/net/8021q/vlan.h +++ b/net/8021q/vlan.h @@ -103,17 +103,19 @@ static inline struct net_device *vlan_find_dev(struct net_device *real_dev, return NULL; }

-static inline netdev_features_t vlan_tnl_features(struct net_device *real_dev) +static inline void vlan_tnl_features(struct net_device *real_dev, + netdev_features_t *tnl) { - netdev_features_t ret; - - ret = real_dev->hw_enc_features & - (NETIF_F_CSUM_MASK | NETIF_F_GSO_SOFTWARE | - NETIF_F_GSO_ENCAP_ALL); - - if ((ret & NETIF_F_GSO_ENCAP_ALL) && (ret & NETIF_F_CSUM_MASK)) - return (ret & ~NETIF_F_CSUM_MASK) | NETIF_F_HW_CSUM; - return 0; + netdev_feature_zero(tnl); + netdev_feature_set_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_SOFTWARE | + NETIF_F_GSO_ENCAP_ALL, tnl); + netdev_feature_and(tnl, *tnl, real_dev->hw_enc_features); + + if (netdev_feature_test_bits(NETIF_F_GSO_ENCAP_ALL, *tnl) && + netdev_feature_test_bits(NETIF_F_CSUM_MASK, *tnl)) { + netdev_feature_clear_bits(NETIF_F_CSUM_MASK, tnl); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, tnl); + } }

#define vlan_group_for_each_dev(grp, i, dev) \ diff --git a/net/8021q/vlan_core.c b/net/8021q/vlan_core.c index 59bc13b..757b2f1 100644 --- a/net/8021q/vlan_core.c +++ b/net/8021q/vlan_core.c @@ -169,10 +169,12 @@ struct vlan_vid_info { static bool vlan_hw_filter_capable(const struct net_device *dev, __be16 proto) { if (proto == htons(ETH_P_8021Q) && - dev->features & NETIF_F_HW_VLAN_CTAG_FILTER) + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + dev->features)) return true; if (proto == htons(ETH_P_8021AD) && - dev->features & NETIF_F_HW_VLAN_STAG_FILTER) + netdev_feature_test_bit(NETIF_F_HW_VLAN_STAG_FILTER_BIT, + dev->features)) return true; return false; } diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c index 9f90a58..a010612 100644 --- a/net/8021q/vlan_dev.c +++ b/net/8021q/vlan_dev.c @@ -566,21 +566,24 @@ static int vlan_dev_init(struct net_device *dev) if (vlan->flags & VLAN_FLAG_BRIDGE_BINDING) dev->state |= (1 << __LINK_STATE_NOCARRIER);

- dev->hw_features = NETIF_F_HW_CSUM | NETIF_F_SG | - NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE | - NETIF_F_GSO_ENCAP_ALL | - NETIF_F_HIGHDMA | NETIF_F_SCTP_CRC | - NETIF_F_ALL_FCOE; - - dev->features |= dev->hw_features | NETIF_F_LLTX; + netdev_feature_zero(&dev->hw_features); + netdev_feature_set_bits(NETIF_F_HW_CSUM | NETIF_F_SG | + NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE | + NETIF_F_GSO_ENCAP_ALL | + NETIF_F_HIGHDMA | NETIF_F_SCTP_CRC | + NETIF_F_ALL_FCOE, &dev->hw_features); + + netdev_feature_or(&dev->features, dev->features, dev->hw_features); + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &dev->features); dev->gso_max_size = real_dev->gso_max_size; dev->gso_max_segs = real_dev->gso_max_segs; - if (dev->features & NETIF_F_VLAN_FEATURES) + if (netdev_feature_test_bits(NETIF_F_VLAN_FEATURES, dev->features)) netdev_warn(real_dev, "VLAN features are set incorrectly. Q-in-Q configurations may not work correctly.\n");

- dev->vlan_features = real_dev->vlan_features & ~NETIF_F_ALL_FCOE; - dev->hw_enc_features = vlan_tnl_features(real_dev); - dev->mpls_features = real_dev->mpls_features; + netdev_feature_copy(&dev->vlan_features, real_dev->vlan_features); + netdev_feature_clear_bits(NETIF_F_ALL_FCOE, &dev->vlan_features); + vlan_tnl_features(real_dev, &dev->hw_enc_features); + netdev_feature_copy(&dev->mpls_features, real_dev->mpls_features);

/* ipv6 shared card related stuff */ dev->dev_id = real_dev->dev_id; @@ -637,21 +640,27 @@ static void vlan_dev_fix_features(struct net_device *dev, netdev_features_t *features) { struct net_device *real_dev = vlan_dev_priv(dev)->real_dev; - netdev_features_t old_features = *features; netdev_features_t lower_features; + netdev_features_t old_features; + netdev_features_t tmp;

- netdev_intersect_features(&lower_features, - (real_dev->vlan_features | NETIF_F_RXCSUM), - real_dev->features); + netdev_feature_copy(&tmp, real_dev->vlan_features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &tmp); + netdev_feature_copy(&old_features, *features); + netdev_intersect_features(&lower_features, tmp, real_dev->features);

/* Add HW_CSUM setting to preserve user ability to control * checksum offload on the vlan device. */ - if (lower_features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM)) - lower_features |= NETIF_F_HW_CSUM; + if (netdev_feature_test_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM, + lower_features)) + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &lower_features); netdev_intersect_features(features, *features, lower_features); - *features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_GSO_SOFTWARE); - *features |= NETIF_F_LLTX; + + netdev_feature_and_bits(NETIF_F_SOFT_FEATURES | NETIF_F_GSO_SOFTWARE, + &old_features); + netdev_feature_or(features, *features, old_features); + netdev_feature_set_bit(NETIF_F_LLTX_BIT, features); }

static int vlan_ethtool_get_link_ksettings(struct net_device *dev,

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ipvlan/ipvlan_main.c | 28 ++++++++++++++++++---------- drivers/net/ipvlan/ipvtap.c | 4 ++-- 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/drivers/net/ipvlan/ipvlan_main.c b/drivers/net/ipvlan/ipvlan_main.c index 6a0b7bd..84ad786a 100644 --- a/drivers/net/ipvlan/ipvlan_main.c +++ b/drivers/net/ipvlan/ipvlan_main.c @@ -135,11 +135,14 @@ static int ipvlan_init(struct net_device *dev)

dev->state = (dev->state & ~IPVLAN_STATE_MASK) | (phy_dev->state & IPVLAN_STATE_MASK); - dev->features = phy_dev->features & IPVLAN_FEATURES; - dev->features |= IPVLAN_ALWAYS_ON; - dev->vlan_features = phy_dev->vlan_features & IPVLAN_FEATURES; - dev->vlan_features |= IPVLAN_ALWAYS_ON_OFLOADS; - dev->hw_enc_features |= dev->features; + netdev_feature_copy(&dev->features, phy_dev->features); + netdev_feature_and_bits(IPVLAN_FEATURES, &dev->features); + netdev_feature_set_bits(IPVLAN_ALWAYS_ON, &dev->features); + netdev_feature_copy(&dev->vlan_features, phy_dev->vlan_features); + netdev_feature_and_bits(IPVLAN_FEATURES, &dev->vlan_features); + netdev_feature_set_bits(IPVLAN_ALWAYS_ON_OFLOADS, &dev->vlan_features); + netdev_feature_or(&dev->hw_enc_features, dev->hw_enc_features, + dev->features); dev->gso_max_size = phy_dev->gso_max_size; dev->gso_max_segs = phy_dev->gso_max_segs; dev->hard_header_len = phy_dev->hard_header_len; @@ -239,13 +242,17 @@ static void ipvlan_fix_features(struct net_device *dev, netdev_features_t *features) { struct ipvl_dev *ipvlan = netdev_priv(dev); + netdev_features_t tmp;

- *features |= NETIF_F_ALL_FOR_ALL; - *features &= (ipvlan->sfeatures | ~IPVLAN_FEATURES); + netdev_feature_set_bits(NETIF_F_ALL_FOR_ALL, features); + netdev_feature_fill(&tmp); + netdev_feature_clear_bits(IPVLAN_FEATURES, &tmp); + netdev_feature_or(&tmp, tmp, ipvlan->sfeatures); + netdev_feature_and(features, *features, tmp); netdev_increment_features(features, ipvlan->phy_dev->features, *features, *features); - *features |= IPVLAN_ALWAYS_ON; - *features &= (IPVLAN_FEATURES | IPVLAN_ALWAYS_ON); + netdev_feature_set_bits(IPVLAN_ALWAYS_ON, features); + netdev_feature_and_bits(IPVLAN_FEATURES | IPVLAN_ALWAYS_ON, features); }

static void ipvlan_change_rx_flags(struct net_device *dev, int change) @@ -567,7 +574,8 @@ int ipvlan_link_new(struct net *src_net, struct net_device *dev,

ipvlan->phy_dev = phy_dev; ipvlan->dev = dev; - ipvlan->sfeatures = IPVLAN_FEATURES; + netdev_feature_zero(&ipvlan->sfeatures); + netdev_feature_set_bits(IPVLAN_FEATURES, &ipvlan->sfeatures); if (!tb[IFLA_MTU]) ipvlan_adjust_mtu(ipvlan, phy_dev); INIT_LIST_HEAD(&ipvlan->addrs); diff --git a/drivers/net/ipvlan/ipvtap.c b/drivers/net/ipvlan/ipvtap.c index 1cedb63..e7fb343 100644 --- a/drivers/net/ipvlan/ipvtap.c +++ b/drivers/net/ipvlan/ipvtap.c @@ -70,7 +70,7 @@ static void ipvtap_update_features(struct tap_dev *tap, struct ipvtap_dev *vlantap = container_of(tap, struct ipvtap_dev, tap); struct ipvl_dev *vlan = &vlantap->vlan;

- vlan->sfeatures = features; + netdev_feature_copy(&vlan->sfeatures, features); netdev_update_features(vlan->dev); }

@@ -86,7 +86,7 @@ static int ipvtap_newlink(struct net *src_net, struct net_device *dev, /* Since macvlan supports all offloads by default, make * tap support all offloads also. */ - vlantap->tap.tap_features = TUN_OFFLOADS; + netdev_feature_set_bits(TUN_OFFLOADS, &vlantap->tap.tap_features); vlantap->tap.count_tx_dropped = ipvtap_count_tx_dropped; vlantap->tap.update_features = ipvtap_update_features; vlantap->tap.count_rx_dropped = ipvtap_count_rx_dropped;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/bonding/bond_main.c | 107 ++++++++++++++++++++++++------------- drivers/net/bonding/bond_options.c | 12 +++-- 2 files changed, 77 insertions(+), 42 deletions(-)

diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c index 3f1554c..785b12c 100644 --- a/drivers/net/bonding/bond_main.c +++ b/drivers/net/bonding/bond_main.c @@ -1365,15 +1365,15 @@ static void bond_fix_features(struct net_device *dev,

#if IS_ENABLED(CONFIG_TLS_DEVICE) if (bond_sk_check(bond)) - *features |= BOND_TLS_FEATURES; + netdev_feature_set_bits(BOND_TLS_FEATURES, features); else - *features &= ~BOND_TLS_FEATURES; + netdev_feature_clear_bits(BOND_TLS_FEATURES, features); #endif

- mask = *features; + netdev_feature_copy(&mask, *features);

- *features &= ~NETIF_F_ONE_FOR_ALL; - *features |= NETIF_F_ALL_FOR_ALL; + netdev_feature_clear_bits(NETIF_F_ONE_FOR_ALL, features); + netdev_feature_set_bits(NETIF_F_ALL_FOR_ALL, features);

bond_for_each_slave(bond, slave, iter) { netdev_increment_features(features, *features, @@ -1397,12 +1397,16 @@ static void bond_compute_features(struct bonding *bond) { unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM; - netdev_features_t vlan_features = BOND_VLAN_FEATURES; - netdev_features_t enc_features = BOND_ENC_FEATURES; + netdev_features_t vlan_features; + netdev_features_t enc_features; + netdev_features_t vlan_mask; + netdev_features_t enc_mask; #ifdef CONFIG_XFRM_OFFLOAD - netdev_features_t xfrm_features = BOND_XFRM_FEATURES; + netdev_features_t xfrm_features; + netdev_features_t xfrm_mask; #endif /* CONFIG_XFRM_OFFLOAD */ - netdev_features_t mpls_features = BOND_MPLS_FEATURES; + netdev_features_t mpls_features; + netdev_features_t mpls_mask; struct net_device *bond_dev = bond->dev; struct list_head *iter; struct slave *slave; @@ -1410,29 +1414,44 @@ static void bond_compute_features(struct bonding *bond) unsigned int gso_max_size = GSO_MAX_SIZE; u16 gso_max_segs = GSO_MAX_SEGS;

+ netdev_feature_zero(&vlan_features); + netdev_feature_set_bits(BOND_VLAN_FEATURES, &vlan_features); + netdev_feature_copy(&vlan_mask, vlan_features); + netdev_feature_zero(&enc_features); + netdev_feature_set_bits(BOND_ENC_FEATURES, &enc_features); + netdev_feature_copy(&enc_mask, enc_features); +#ifdef CONFIG_XFRM_OFFLOAD + netdev_feature_zero(&xfrm_features); + netdev_feature_set_bits(BOND_XFRM_FEATURES, &xfrm_features); + netdev_feature_copy(&xfrm_mask, xfrm_features); +#endif /* CONFIG_XFRM_OFFLOAD */ + netdev_feature_zero(&mpls_features); + netdev_feature_set_bits(BOND_MPLS_FEATURES, &mpls_features); + netdev_feature_copy(&mpls_mask, mpls_features); + if (!bond_has_slaves(bond)) goto done; - vlan_features &= NETIF_F_ALL_FOR_ALL; - mpls_features &= NETIF_F_ALL_FOR_ALL; + netdev_feature_clear_bits(NETIF_F_ALL_FOR_ALL, &vlan_features); + netdev_feature_clear_bits(NETIF_F_ALL_FOR_ALL, &mpls_features);

bond_for_each_slave(bond, slave, iter) { netdev_increment_features(&vlan_features, vlan_features, slave->dev->vlan_features, - BOND_VLAN_FEATURES); + vlan_mask);

netdev_increment_features(&enc_features, enc_features, slave->dev->hw_enc_features, - BOND_ENC_FEATURES); + enc_mask);

#ifdef CONFIG_XFRM_OFFLOAD netdev_increment_features(&xfrm_features, xfrm_features, slave->dev->hw_enc_features, - BOND_XFRM_FEATURES); + xfrm_features); #endif /* CONFIG_XFRM_OFFLOAD */

netdev_increment_features(&mpls_features, mpls_features, slave->dev->mpls_features, - BOND_MPLS_FEATURES); + mpls_mask);

dst_release_flag &= slave->dev->priv_flags; if (slave->dev->hard_header_len > max_hard_header_len) @@ -1444,14 +1463,16 @@ static void bond_compute_features(struct bonding *bond) bond_dev->hard_header_len = max_hard_header_len;

done: - bond_dev->vlan_features = vlan_features; - bond_dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_STAG_TX; + netdev_feature_copy(&bond_dev->vlan_features, vlan_features); + netdev_feature_copy(&bond_dev->hw_enc_features, enc_features); + netdev_feature_set_bits(NETIF_F_GSO_ENCAP_ALL | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_STAG_TX, &mpls_features); #ifdef CONFIG_XFRM_OFFLOAD - bond_dev->hw_enc_features |= xfrm_features; + netdev_feature_or(&bond_dev->vlan_features, bond_dev->vlan_features, + xfrm_features); #endif /* CONFIG_XFRM_OFFLOAD */ - bond_dev->mpls_features = mpls_features; + netdev_feature_copy(&bond_dev->mpls_features, mpls_features); bond_dev->gso_max_segs = gso_max_segs; netif_set_gso_max_size(bond_dev, gso_max_size);

@@ -1764,7 +1785,8 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev,

/* vlan challenged mutual exclusion */ /* no need to lock since we're protected by rtnl_lock */ - if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) { + if (netdev_feature_test_bit(NETIF_F_VLAN_CHALLENGED_BIT, + slave_dev->features)) { slave_dbg(bond_dev, slave_dev, "is NETIF_F_VLAN_CHALLENGED\n"); if (vlan_uses_dev(bond_dev)) { NL_SET_ERR_MSG(extack, "Can not enslave VLAN challenged device to VLAN enabled bond"); @@ -1777,7 +1799,7 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev, slave_dbg(bond_dev, slave_dev, "is !NETIF_F_VLAN_CHALLENGED\n"); }

- if (slave_dev->features & NETIF_F_HW_ESP) + if (netdev_feature_test_bit(NETIF_F_HW_ESP_BIT, slave_dev->features)) slave_dbg(bond_dev, slave_dev, "is esp-hw-offload capable\n");

/* Old ifenslave binaries are no longer supported. These can @@ -2072,7 +2094,7 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev, } #endif

- if (!(bond_dev->features & NETIF_F_LRO)) + if (!netdev_feature_test_bit(NETIF_F_LRO_BIT, bond_dev->features)) dev_disable_lro(slave_dev);

res = netdev_rx_handler_register(slave_dev, bond_handle_frame, @@ -2272,8 +2294,9 @@ static int __bond_release_one(struct net_device *bond_dev, struct slave *slave, *oldcurrent; struct sockaddr_storage ss; int old_flags = bond_dev->flags; - netdev_features_t old_features = bond_dev->features; + netdev_features_t old_features;

+ netdev_feature_copy(&old_features, bond_dev->features); /* slave is not a slave or master is not master of this slave */ if (!(slave_dev->flags & IFF_SLAVE) || !netdev_has_upper_dev(slave_dev, bond_dev)) { @@ -2377,8 +2400,10 @@ static int __bond_release_one(struct net_device *bond_dev, }

bond_compute_features(bond); - if (!(bond_dev->features & NETIF_F_VLAN_CHALLENGED) && - (old_features & NETIF_F_VLAN_CHALLENGED)) + if (!netdev_feature_test_bit(NETIF_F_VLAN_CHALLENGED_BIT, + bond_dev->features) && + netdev_feature_test_bit(NETIF_F_VLAN_CHALLENGED_BIT, + old_features)) slave_info(bond_dev, slave_dev, "last VLAN challenged slave left bond - VLAN blocking is removed\n");

vlan_vids_del_by_dev(slave_dev, bond_dev); @@ -5398,7 +5423,7 @@ void bond_setup(struct net_device *bond_dev) #endif /* CONFIG_XFRM_OFFLOAD */

/* don't acquire bond device's netif_tx_lock when transmitting */ - bond_dev->features |= NETIF_F_LLTX; + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &bond_dev->features);

/* By default, we declare the bond to be fully * VLAN hardware accelerated capable. Special @@ -5408,24 +5433,30 @@ void bond_setup(struct net_device *bond_dev) */

/* Don't allow bond devices to change network namespaces. */ - bond_dev->features |= NETIF_F_NETNS_LOCAL; + netdev_feature_set_bit(NETIF_F_NETNS_LOCAL_BIT, &bond_dev->features);

- bond_dev->hw_features = BOND_VLAN_FEATURES | + netdev_feature_zero(&bond_dev->hw_features); + netdev_feature_set_bits(BOND_VLAN_FEATURES | NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_FILTER; - - bond_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL; - bond_dev->features |= bond_dev->hw_features; - bond_dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX; + NETIF_F_HW_VLAN_CTAG_FILTER, + &bond_dev->hw_features); + + netdev_feature_set_bits(NETIF_F_GSO_ENCAP_ALL, &bond_dev->hw_features); + netdev_feature_or(&bond_dev->features, bond_dev->features, + bond_dev->hw_features); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_STAG_TX, + &bond_dev->features); #ifdef CONFIG_XFRM_OFFLOAD - bond_dev->hw_features |= BOND_XFRM_FEATURES; + netdev_feature_set_bits(BOND_XFRM_FEATURES, &bond_dev->hw_features); /* Only enable XFRM features if this is an active-backup config */ if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) - bond_dev->features |= BOND_XFRM_FEATURES; + netdev_feature_set_bits(BOND_XFRM_FEATURES, + &bond_dev->features); #endif /* CONFIG_XFRM_OFFLOAD */ #if IS_ENABLED(CONFIG_TLS_DEVICE) if (bond_sk_check(bond)) - bond_dev->features |= BOND_TLS_FEATURES; + netdev_feature_set_bits(BOND_TLS_FEATURES, &bond_dev->features); #endif }

diff --git a/drivers/net/bonding/bond_options.c b/drivers/net/bonding/bond_options.c index a8fde3b..b0c3a28 100644 --- a/drivers/net/bonding/bond_options.c +++ b/drivers/net/bonding/bond_options.c @@ -778,9 +778,11 @@ static bool bond_set_xfrm_features(struct bonding *bond) return false;

if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP) - bond->dev->wanted_features |= BOND_XFRM_FEATURES; + netdev_feature_set_bits(BOND_XFRM_FEATURES, + &bond->dev->wanted_features); else - bond->dev->wanted_features &= ~BOND_XFRM_FEATURES; + netdev_feature_clear_bits(BOND_XFRM_FEATURES, + &bond->dev->wanted_features);

return true; } @@ -791,9 +793,11 @@ static bool bond_set_tls_features(struct bonding *bond) return false;

if (bond_sk_check(bond)) - bond->dev->wanted_features |= BOND_TLS_FEATURES; + netdev_feature_set_bits(BOND_TLS_FEATURES, + &bond->dev->wanted_features); else - bond->dev->wanted_features &= ~BOND_TLS_FEATURES; + netdev_feature_clear_bits(BOND_TLS_FEATURES, + &bond->dev->wanted_features);

return true; }

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/tap.c | 36 ++++++++++++++++++++++-------------- 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/drivers/net/tap.c b/drivers/net/tap.c index 8e3a28b..03158fa 100644 --- a/drivers/net/tap.c +++ b/drivers/net/tap.c @@ -321,7 +321,10 @@ rx_handler_result_t tap_handle_frame(struct sk_buff **pskb) struct net_device *dev = skb->dev; struct tap_dev *tap; struct tap_queue *q; - netdev_features_t features = TAP_FEATURES; + netdev_features_t features; + + netdev_feature_zero(&features); + netdev_feature_set_bits(TAP_FEATURES, &features);

tap = tap_dev_get_rcu(dev); if (!tap) @@ -338,7 +341,7 @@ rx_handler_result_t tap_handle_frame(struct sk_buff **pskb) * enabled. */ if (q->flags & IFF_VNET_HDR) - features |= tap->tap_features; + netdev_feature_or(&features, features, tap->tap_features); if (netif_needs_gso(skb, features)) { struct sk_buff *segs = __skb_gso_segment(skb, features, false); struct sk_buff *next; @@ -368,7 +371,7 @@ rx_handler_result_t tap_handle_frame(struct sk_buff **pskb) * check, we either support them all or none. */ if (skb->ip_summed == CHECKSUM_PARTIAL && - !(features & NETIF_F_CSUM_MASK) && + !netdev_feature_test_bits(NETIF_F_CSUM_MASK, features) && skb_checksum_help(skb)) goto drop; if (ptr_ring_produce(&q->ring, skb)) @@ -536,7 +539,8 @@ static int tap_open(struct inode *inode, struct file *file) * The macvlan supports zerocopy iff the lower device supports zero * copy so we don't have to look at the lower device directly. */ - if ((tap->dev->features & NETIF_F_HIGHDMA) && (tap->dev->features & NETIF_F_SG)) + if (netdev_feature_test_bit(NETIF_F_HIGHDMA_BIT, tap->dev->features) && + netdev_feature_test_bit(NETIF_F_SG_BIT, tap->dev->features)) sock_set_flag(&q->sk, SOCK_ZEROCOPY);

err = tap_set_queue(tap, file, q); @@ -921,24 +925,28 @@ static int set_offload(struct tap_queue *q, unsigned long arg) { struct tap_dev *tap; netdev_features_t features; - netdev_features_t feature_mask = 0; + netdev_features_t feature_mask;

tap = rtnl_dereference(q->tap); if (!tap) return -ENOLINK;

- features = tap->dev->features; + netdev_feature_zero(&feature_mask); + netdev_feature_copy(&features, tap->dev->features);

if (arg & TUN_F_CSUM) { - feature_mask = NETIF_F_HW_CSUM; + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &feature_mask);

if (arg & (TUN_F_TSO4 | TUN_F_TSO6)) { if (arg & TUN_F_TSO_ECN) - feature_mask |= NETIF_F_TSO_ECN; + netdev_feature_set_bit(NETIF_F_TSO_ECN_BIT, + &feature_mask); if (arg & TUN_F_TSO4) - feature_mask |= NETIF_F_TSO; + netdev_feature_set_bit(NETIF_F_TSO_BIT, + &feature_mask); if (arg & TUN_F_TSO6) - feature_mask |= NETIF_F_TSO6; + netdev_feature_set_bit(NETIF_F_TSO6_BIT, + &feature_mask); } }

@@ -950,15 +958,15 @@ static int set_offload(struct tap_queue *q, unsigned long arg) * When user space turns off TSO, we turn off GSO/LRO so that * user-space will not receive TSO frames. */ - if (feature_mask & (NETIF_F_TSO | NETIF_F_TSO6)) - features |= RX_OFFLOADS; + if (netdev_feature_test_bits(NETIF_F_TSO | NETIF_F_TSO6, feature_mask)) + netdev_feature_set_bits(RX_OFFLOADS, &features); else - features &= ~RX_OFFLOADS; + netdev_feature_clear_bits(RX_OFFLOADS, &features);

/* tap_features are the same as features on tun/tap and * reflect user expectations. */ - tap->tap_features = feature_mask; + netdev_feature_copy(&tap->tap_features, feature_mask); if (tap->update_features) tap->update_features(tap, features);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/hyperv/netvsc_bpf.c | 2 +- drivers/net/hyperv/netvsc_drv.c | 38 ++++++++++++++++++++++---------------- drivers/net/hyperv/rndis_filter.c | 30 +++++++++++++++++++----------- 3 files changed, 42 insertions(+), 28 deletions(-)

diff --git a/drivers/net/hyperv/netvsc_bpf.c b/drivers/net/hyperv/netvsc_bpf.c index aa877da..058a9269 100644 --- a/drivers/net/hyperv/netvsc_bpf.c +++ b/drivers/net/hyperv/netvsc_bpf.c @@ -114,7 +114,7 @@ int netvsc_xdp_set(struct net_device *dev, struct bpf_prog *prog, return -EOPNOTSUPP; }

- if (prog && (dev->features & NETIF_F_LRO)) { + if (prog && netdev_feature_test_bit(NETIF_F_LRO_BIT, dev->features)) { netdev_err(dev, "XDP: not support LRO\n"); NL_SET_ERR_MSG_MOD(extack, "XDP: not support LRO");

diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c index 5371328..22875a7 100644 --- a/drivers/net/hyperv/netvsc_drv.c +++ b/drivers/net/hyperv/netvsc_drv.c @@ -892,13 +892,15 @@ static struct sk_buff *netvsc_alloc_recv_skb(struct net_device *net, }

/* Do L4 checksum offload if enabled and present. */ - if ((ppi_flags & NVSC_RSC_CSUM_INFO) && (net->features & NETIF_F_RXCSUM)) { + if ((ppi_flags & NVSC_RSC_CSUM_INFO) && + netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, net->features)) { if (csum_info->receive.tcp_checksum_succeeded || csum_info->receive.udp_checksum_succeeded) skb->ip_summed = CHECKSUM_UNNECESSARY; }

- if ((ppi_flags & NVSC_RSC_HASH_INFO) && (net->features & NETIF_F_RXHASH)) + if ((ppi_flags & NVSC_RSC_HASH_INFO) && + netdev_feature_test_bit(NETIF_F_RXHASH_BIT, net->features)) skb_set_hash(skb, *hash_info, PKT_HASH_TYPE_L4);

if (ppi_flags & NVSC_RSC_VLAN) { @@ -1205,7 +1207,8 @@ static void netvsc_init_settings(struct net_device *dev) ndc->speed = SPEED_UNKNOWN; ndc->duplex = DUPLEX_FULL;

- dev->features = NETIF_F_LRO; + netdev_feature_zero(&dev->features); + netdev_feature_set_bit(NETIF_F_LRO_BIT, &dev->features); }

static int netvsc_get_link_ksettings(struct net_device *dev, @@ -1928,8 +1931,9 @@ static void netvsc_fix_features(struct net_device *ndev, if (!nvdev || nvdev->destroy) return;

- if ((*features & NETIF_F_LRO) && netvsc_xdp_get(nvdev)) { - *features ^= NETIF_F_LRO; + if (netdev_feature_test_bit(NETIF_F_LRO_BIT, *features) && + netvsc_xdp_get(nvdev)) { + netdev_feature_change_bit(NETIF_F_LRO_BIT, features); netdev_info(ndev, "Skip LRO - unsupported with XDP\n"); } } @@ -1937,22 +1941,24 @@ static void netvsc_fix_features(struct net_device *ndev, static int netvsc_set_features(struct net_device *ndev, netdev_features_t features) { - netdev_features_t change = features ^ ndev->features; struct net_device_context *ndevctx = netdev_priv(ndev); struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev); struct net_device *vf_netdev = rtnl_dereference(ndevctx->vf_netdev); struct ndis_offload_params offloads; + netdev_features_t change; int ret = 0;

if (!nvdev || nvdev->destroy) return -ENODEV;

- if (!(change & NETIF_F_LRO)) + netdev_feature_xor(&change, features, ndev->features); + + if (!netdev_feature_test_bit(NETIF_F_LRO_BIT, change)) goto syncvf;

memset(&offloads, 0, sizeof(struct ndis_offload_params));

- if (features & NETIF_F_LRO) { + if (netdev_feature_test_bit(NETIF_F_LRO_BIT, features)) { offloads.rsc_ip_v4 = NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED; offloads.rsc_ip_v6 = NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED; } else { @@ -1963,15 +1969,15 @@ static int netvsc_set_features(struct net_device *ndev, ret = rndis_filter_set_offload_params(ndev, nvdev, &offloads);

if (ret) { - features ^= NETIF_F_LRO; - ndev->features = features; + netdev_feature_change_bit(NETIF_F_LRO_BIT, &features); + netdev_feature_copy(&ndev->features, features); }

syncvf: if (!vf_netdev) return ret;

- vf_netdev->wanted_features = features; + netdev_feature_copy(&vf_netdev->wanted_features, features); netdev_update_features(vf_netdev);

return ret; @@ -2385,7 +2391,7 @@ static int netvsc_register_vf(struct net_device *vf_netdev) if (ndev->needed_headroom < vf_netdev->needed_headroom) ndev->needed_headroom = vf_netdev->needed_headroom;

- vf_netdev->wanted_features = ndev->features; + netdev_feature_copy(&vf_netdev->wanted_features, ndev->features); netdev_update_features(vf_netdev);

prog = netvsc_xdp_get(netvsc_dev); @@ -2550,10 +2556,10 @@ static int netvsc_probe(struct hv_device *dev, schedule_work(&nvdev->subchan_work);

/* hw_features computed in rndis_netdev_set_hwcaps() */ - net->features = net->hw_features | - NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX; - net->vlan_features = net->features; + netdev_feature_copy(&net->features, net->hw_features); + netdev_feature_set_bits(NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, &net->features); + netdev_feature_copy(&net->vlan_features, net->features);

netdev_lockdep_set_classes(net);

diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c index f6c9c2a..115ebe0 100644 --- a/drivers/net/hyperv/rndis_filter.c +++ b/drivers/net/hyperv/rndis_filter.c @@ -1348,6 +1348,7 @@ static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device, struct ndis_offload hwcaps; struct ndis_offload_params offloads; unsigned int gso_max_size = GSO_MAX_SIZE; + netdev_features_t tmp; int ret;

/* Find HW offload capabilities */ @@ -1362,24 +1363,26 @@ static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device, offloads.ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_DISABLED;

/* Reset previously set hw_features flags */ - net->hw_features &= ~NETVSC_SUPPORTED_HW_FEATURES; + netdev_feature_clear_bits(NETVSC_SUPPORTED_HW_FEATURES, + &net->hw_features); net_device_ctx->tx_checksum_mask = 0;

/* Compute tx offload settings based on hw capabilities */ - net->hw_features |= NETIF_F_RXCSUM; - net->hw_features |= NETIF_F_SG; - net->hw_features |= NETIF_F_RXHASH; + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &net->hw_features); + netdev_feature_set_bit(NETIF_F_SG_BIT, &net->hw_features); + netdev_feature_set_bit(NETIF_F_RXHASH_BIT, &net->hw_features);

if ((hwcaps.csum.ip4_txcsum & NDIS_TXCSUM_ALL_TCP4) == NDIS_TXCSUM_ALL_TCP4) { /* Can checksum TCP */ - net->hw_features |= NETIF_F_IP_CSUM; + netdev_feature_set_bit(NETIF_F_IP_CSUM_BIT, &net->hw_features); net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV4_TCP;

offloads.tcp_ip_v4_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED;

if (hwcaps.lsov2.ip4_encap & NDIS_OFFLOAD_ENCAP_8023) { offloads.lso_v2_ipv4 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED; - net->hw_features |= NETIF_F_TSO; + netdev_feature_set_bit(NETIF_F_TSO_BIT, + &net->hw_features);

if (hwcaps.lsov2.ip4_maxsz < gso_max_size) gso_max_size = hwcaps.lsov2.ip4_maxsz; @@ -1392,7 +1395,8 @@ static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device, }

if ((hwcaps.csum.ip6_txcsum & NDIS_TXCSUM_ALL_TCP6) == NDIS_TXCSUM_ALL_TCP6) { - net->hw_features |= NETIF_F_IPV6_CSUM; + netdev_feature_set_bit(NETIF_F_IPV6_CSUM_BIT, + &net->hw_features);

offloads.tcp_ip_v6_csum = NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED; net_device_ctx->tx_checksum_mask |= TRANSPORT_INFO_IPV6_TCP; @@ -1400,7 +1404,8 @@ static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device, if ((hwcaps.lsov2.ip6_encap & NDIS_OFFLOAD_ENCAP_8023) && (hwcaps.lsov2.ip6_opts & NDIS_LSOV2_CAP_IP6) == NDIS_LSOV2_CAP_IP6) { offloads.lso_v2_ipv6 = NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED; - net->hw_features |= NETIF_F_TSO6; + netdev_feature_set_bit(NETIF_F_TSO6_BIT, + &net->hw_features);

if (hwcaps.lsov2.ip6_maxsz < gso_max_size) gso_max_size = hwcaps.lsov2.ip6_maxsz; @@ -1413,9 +1418,9 @@ static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device, }

if (hwcaps.rsc.ip4 && hwcaps.rsc.ip6) { - net->hw_features |= NETIF_F_LRO; + netdev_feature_set_bit(NETIF_F_LRO_BIT, &net->hw_features);

- if (net->features & NETIF_F_LRO) { + if (netdev_feature_test_bit(NETIF_F_LRO_BIT, net->features)) { offloads.rsc_ip_v4 = NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED; offloads.rsc_ip_v6 = NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED; } else { @@ -1427,7 +1432,10 @@ static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device, /* In case some hw_features disappeared we need to remove them from * net->features list as they're no longer supported. */ - net->features &= ~NETVSC_SUPPORTED_HW_FEATURES | net->hw_features; + netdev_feature_fill(&tmp); + netdev_feature_clear_bits(NETVSC_SUPPORTED_HW_FEATURES, &tmp); + netdev_feature_or(&tmp, tmp, net->hw_features); + netdev_feature_and(&net->features, net->features, tmp);

netif_set_gso_max_size(net, gso_max_size);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/macsec.c | 39 ++++++++++++++++++++++++--------------- 1 file changed, 24 insertions(+), 15 deletions(-)

diff --git a/drivers/net/macsec.c b/drivers/net/macsec.c index 601b833..5526d54 100644 --- a/drivers/net/macsec.c +++ b/drivers/net/macsec.c @@ -347,7 +347,8 @@ static bool macsec_check_offload(enum macsec_offload offload, return macsec->real_dev->phydev && macsec->real_dev->phydev->macsec_ops; else if (offload == MACSEC_OFFLOAD_MAC) - return macsec->real_dev->features & NETIF_F_HW_MACSEC && + return netdev_feature_test_bit(NETIF_F_HW_MACSEC_BIT, + macsec->real_dev->features) && macsec->real_dev->macsec_ops;

return false; @@ -3419,13 +3420,6 @@ static netdev_tx_t macsec_start_xmit(struct sk_buff *skb, #define SW_MACSEC_FEATURES \ (NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST)

-/* If h/w offloading is enabled, use real device features save for - * VLAN_FEATURES - they require additional ops - * HW_MACSEC - no reason to report it - */ -#define REAL_DEV_FEATURES(dev) \ - ((dev)->features & ~(NETIF_F_VLAN_FEATURES | NETIF_F_HW_MACSEC)) - static int macsec_dev_init(struct net_device *dev) { struct macsec_dev *macsec = macsec_priv(dev); @@ -3443,10 +3437,19 @@ static int macsec_dev_init(struct net_device *dev) }

if (macsec_is_offloaded(macsec)) { - dev->features = REAL_DEV_FEATURES(real_dev); + /* If h/w offloading is enabled, use real device features save for + * VLAN_FEATURES - they require additional ops + * HW_MACSEC - no reason to report it + */ + netdev_feature_copy(&dev->features, real_dev->features); + netdev_feature_clear_bits(NETIF_F_VLAN_FEATURES | + NETIF_F_HW_MACSEC, + &dev->features); } else { - dev->features = real_dev->features & SW_MACSEC_FEATURES; - dev->features |= NETIF_F_LLTX | NETIF_F_GSO_SOFTWARE; + netdev_feature_copy(&dev->features, real_dev->features); + netdev_feature_and_bits(SW_MACSEC_FEATURES, &dev->features); + netdev_feature_set_bits(NETIF_F_LLTX | NETIF_F_GSO_SOFTWARE, + &dev->features); }

dev->needed_headroom = real_dev->needed_headroom + @@ -3475,15 +3478,21 @@ static void macsec_fix_features(struct net_device *dev, { struct macsec_dev *macsec = macsec_priv(dev); struct net_device *real_dev = macsec->real_dev; + netdev_features_t tmp;

if (macsec_is_offloaded(macsec)) { - *features = REAL_DEV_FEATURES(real_dev); + netdev_feature_copy(features, real_dev->features); + netdev_feature_clear_bits(NETIF_F_VLAN_FEATURES | + NETIF_F_HW_MACSEC, features); return; }

- *features &= (real_dev->features & SW_MACSEC_FEATURES) | - NETIF_F_GSO_SOFTWARE | NETIF_F_SOFT_FEATURES; - *features |= NETIF_F_LLTX; + netdev_feature_copy(&tmp, real_dev->features); + netdev_feature_and_bits(SW_MACSEC_FEATURES, &tmp); + netdev_feature_set_bits(NETIF_F_GSO_SOFTWARE | NETIF_F_SOFT_FEATURES, + &tmp); + netdev_feature_and(features, *features, tmp); + netdev_feature_set_bit(NETIF_F_LLTX_BIT, features); }

static int macsec_dev_open(struct net_device *dev)

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/dsa/xrs700x/xrs700x.c | 6 ++++-- net/dsa/slave.c | 15 +++++++++------ 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/drivers/net/dsa/xrs700x/xrs700x.c b/drivers/net/dsa/xrs700x/xrs700x.c index 130abb0..898426c 100644 --- a/drivers/net/dsa/xrs700x/xrs700x.c +++ b/drivers/net/dsa/xrs700x/xrs700x.c @@ -639,7 +639,8 @@ static int xrs700x_hsr_join(struct dsa_switch *ds, int port, hsr_pair[1] = partner->index; for (i = 0; i < ARRAY_SIZE(hsr_pair); i++) { slave = dsa_to_port(ds, hsr_pair[i])->slave; - slave->features |= XRS7000X_SUPPORTED_HSR_FEATURES; + netdev_feature_set_bits(XRS7000X_SUPPORTED_HSR_FEATURES, + &slave->features); }

return 0; @@ -693,7 +694,8 @@ static int xrs700x_hsr_leave(struct dsa_switch *ds, int port, hsr_pair[1] = partner->index; for (i = 0; i < ARRAY_SIZE(hsr_pair); i++) { slave = dsa_to_port(ds, hsr_pair[i])->slave; - slave->features &= ~XRS7000X_SUPPORTED_HSR_FEATURES; + netdev_feature_clear_bits(XRS7000X_SUPPORTED_HSR_FEATURES, + &slave->features); }

return 0; diff --git a/net/dsa/slave.c b/net/dsa/slave.c index acf73db..8ddfed4 100644 --- a/net/dsa/slave.c +++ b/net/dsa/slave.c @@ -1815,13 +1815,16 @@ void dsa_slave_setup_tagger(struct net_device *slave)

p->xmit = cpu_dp->tag_ops->xmit;

- slave->features = master->vlan_features | NETIF_F_HW_TC; + netdev_feature_copy(&slave->features, master->vlan_features); + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &slave->features); if (ds->ops->port_vlan_add && ds->ops->port_vlan_del) - slave->features |= NETIF_F_HW_VLAN_CTAG_FILTER; - slave->hw_features |= NETIF_F_HW_TC; - slave->features |= NETIF_F_LLTX; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &slave->features); + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &slave->hw_features); + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &slave->features); if (slave->needed_tailroom) - slave->features &= ~(NETIF_F_SG | NETIF_F_FRAGLIST); + netdev_feature_clear_bits(NETIF_F_SG | NETIF_F_FRAGLIST, + &slave->features); }

static struct lock_class_key dsa_slave_netdev_xmit_lock_key; @@ -1900,7 +1903,7 @@ int dsa_slave_create(struct dsa_port *port)

SET_NETDEV_DEV(slave_dev, port->ds->dev); slave_dev->dev.of_node = port->dn; - slave_dev->vlan_features = master->vlan_features; + netdev_feature_copy(&slave_dev->features, master->vlan_features);

p = netdev_priv(slave_dev); slave_dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/team/team.c | 69 ++++++++++++++++++++++++++++++------------------- 1 file changed, 42 insertions(+), 27 deletions(-)

diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c index fa96ee6..207771e 100644 --- a/drivers/net/team/team.c +++ b/drivers/net/team/team.c @@ -985,21 +985,30 @@ static void team_port_disable(struct team *team, static void __team_compute_features(struct team *team) { struct team_port *port; - netdev_features_t vlan_features = TEAM_VLAN_FEATURES & - NETIF_F_ALL_FOR_ALL; - netdev_features_t enc_features = TEAM_ENC_FEATURES; unsigned short max_hard_header_len = ETH_HLEN; unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM; + netdev_features_t vlan_features; + netdev_features_t enc_features; + netdev_features_t mask_vlan; + netdev_features_t mask_enc; + + netdev_feature_zero(&vlan_features); + netdev_feature_set_bits(TEAM_VLAN_FEATURES & NETIF_F_ALL_FOR_ALL, + &vlan_features); + netdev_feature_zero(&enc_features); + netdev_feature_set_bits(TEAM_ENC_FEATURES, &enc_features); + netdev_feature_zero(&mask_vlan); + netdev_feature_set_bits(TEAM_VLAN_FEATURES, &mask_vlan); + netdev_feature_zero(&mask_enc); + netdev_feature_set_bits(TEAM_ENC_FEATURES, &mask_enc);

rcu_read_lock(); list_for_each_entry_rcu(port, &team->port_list, list) { netdev_increment_features(&vlan_features, vlan_features, - port->dev->vlan_features, - TEAM_VLAN_FEATURES); + port->dev->vlan_features, mask_vlan); netdev_increment_features(&enc_features, enc_features, - port->dev->hw_enc_features, - TEAM_ENC_FEATURES); + port->dev->hw_enc_features, mask_enc);

dst_release_flag &= port->dev->priv_flags; if (port->dev->hard_header_len > max_hard_header_len) @@ -1007,10 +1016,12 @@ static void __team_compute_features(struct team *team) } rcu_read_unlock();

- team->dev->vlan_features = vlan_features; - team->dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_STAG_TX; + netdev_feature_copy(&team->dev->vlan_features, vlan_features); + netdev_feature_copy(&team->dev->hw_enc_features, enc_features); + netdev_feature_set_bits(NETIF_F_GSO_ENCAP_ALL | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_STAG_TX, + &team->dev->hw_enc_features); team->dev->hard_header_len = max_hard_header_len;

team->dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; @@ -1161,7 +1172,8 @@ static int team_port_add(struct team *team, struct net_device *port_dev, return -EBUSY; }

- if (port_dev->features & NETIF_F_VLAN_CHALLENGED && + if (netdev_feature_test_bit(NETIF_F_VLAN_CHALLENGED_BIT, + port_dev->features) && vlan_uses_dev(dev)) { NL_SET_ERR_MSG(extack, "Device is VLAN challenged and team device has VLAN set up"); netdev_err(dev, "Device %s is VLAN challenged and team device has VLAN set up\n", @@ -1226,7 +1238,7 @@ static int team_port_add(struct team *team, struct net_device *port_dev, goto err_enable_netpoll; }

- if (!(dev->features & NETIF_F_LRO)) + if (!netdev_feature_test_bit(NETIF_F_LRO_BIT, dev->features)) dev_disable_lro(port_dev);

err = netdev_rx_handler_register(port_dev, team_handle_frame, @@ -2000,9 +2012,9 @@ static void team_fix_features(struct net_device *dev, struct team *team = netdev_priv(dev); netdev_features_t mask;

- mask = *features; - *features &= ~NETIF_F_ONE_FOR_ALL; - *features |= NETIF_F_ALL_FOR_ALL; + netdev_feature_copy(&mask, *features); + netdev_feature_clear_bits(NETIF_F_ONE_FOR_ALL, features); + netdev_feature_set_bits(NETIF_F_ALL_FOR_ALL, features);

rcu_read_lock(); list_for_each_entry_rcu(port, &team->port_list, list) { @@ -2160,19 +2172,22 @@ static void team_setup(struct net_device *dev) */ dev->priv_flags |= IFF_UNICAST_FLT | IFF_LIVE_ADDR_CHANGE;

- dev->features |= NETIF_F_LLTX; - dev->features |= NETIF_F_GRO; + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &dev->features); + netdev_feature_set_bit(NETIF_F_GRO_BIT, &dev->features);

/* Don't allow team devices to change network namespaces. */ - dev->features |= NETIF_F_NETNS_LOCAL; - - dev->hw_features = TEAM_VLAN_FEATURES | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_FILTER; - - dev->hw_features |= NETIF_F_GSO_ENCAP_ALL; - dev->features |= dev->hw_features; - dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX; + netdev_feature_set_bit(NETIF_F_NETNS_LOCAL_BIT, &dev->features); + + netdev_feature_set_bits(TEAM_VLAN_FEATURES | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_FILTER, + &dev->hw_features); + + netdev_feature_set_bits(NETIF_F_GSO_ENCAP_ALL, &dev->hw_features); + netdev_feature_or(&dev->features, dev->features, dev->hw_features); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_STAG_TX, + &dev->features); }

static int team_newlink(struct net *src_net, struct net_device *dev,

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/net_failover.c | 57 ++++++++++++++++++++++++++++++---------------- 1 file changed, 37 insertions(+), 20 deletions(-)

diff --git a/drivers/net/net_failover.c b/drivers/net/net_failover.c index 878cad2..704e691 100644 --- a/drivers/net/net_failover.c +++ b/drivers/net/net_failover.c @@ -379,23 +379,33 @@ static rx_handler_result_t net_failover_handle_frame(struct sk_buff **pskb)

static void net_failover_compute_features(struct net_device *dev) { - netdev_features_t vlan_features = FAILOVER_VLAN_FEATURES & - NETIF_F_ALL_FOR_ALL; - netdev_features_t enc_features = FAILOVER_ENC_FEATURES; unsigned short max_hard_header_len = ETH_HLEN; unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM; struct net_failover_info *nfo_info = netdev_priv(dev); struct net_device *primary_dev, *standby_dev; + netdev_features_t vlan_features; + netdev_features_t enc_features; + netdev_features_t vlan_mask; + netdev_features_t enc_mask; + + netdev_feature_zero(&vlan_features); + netdev_feature_set_bits(FAILOVER_VLAN_FEATURES & NETIF_F_ALL_FOR_ALL, + &vlan_features); + netdev_feature_zero(&enc_features); + netdev_feature_set_bits(FAILOVER_ENC_FEATURES, &enc_features); + netdev_feature_zero(&vlan_mask); + netdev_feature_set_bits(FAILOVER_VLAN_FEATURES, &vlan_mask); + netdev_feature_copy(&enc_mask, enc_features);

primary_dev = rcu_dereference(nfo_info->primary_dev); if (primary_dev) { netdev_increment_features(&vlan_features, vlan_features, primary_dev->vlan_features, - FAILOVER_VLAN_FEATURES); + vlan_mask); netdev_increment_features(&enc_features, enc_features, primary_dev->hw_enc_features, - FAILOVER_ENC_FEATURES); + enc_features);

dst_release_flag &= primary_dev->priv_flags; if (primary_dev->hard_header_len > max_hard_header_len) @@ -406,18 +416,19 @@ static void net_failover_compute_features(struct net_device *dev) if (standby_dev) { netdev_increment_features(&vlan_features, vlan_features, standby_dev->vlan_features, - FAILOVER_VLAN_FEATURES); + vlan_mask); netdev_increment_features(&enc_features, enc_features, standby_dev->hw_enc_features, - FAILOVER_ENC_FEATURES); + enc_features);

dst_release_flag &= standby_dev->priv_flags; if (standby_dev->hard_header_len > max_hard_header_len) max_hard_header_len = standby_dev->hard_header_len; }

- dev->vlan_features = vlan_features; - dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL; + netdev_feature_copy(&dev->vlan_features, vlan_features); + netdev_feature_copy(&dev->hw_enc_features, enc_features); + netdev_feature_set_bits(NETIF_F_GSO_ENCAP_ALL, &dev->hw_enc_features); dev->hard_header_len = max_hard_header_len;

dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; @@ -481,7 +492,8 @@ static int net_failover_slave_pre_register(struct net_device *slave_dev, !dev_is_pci(slave_dev->dev.parent))) return -EINVAL;

- if (failover_dev->features & NETIF_F_VLAN_CHALLENGED && + if (netdev_feature_test_bit(NETIF_F_VLAN_CHALLENGED_BIT, + failover_dev->features) && vlan_uses_dev(failover_dev)) { netdev_err(failover_dev, "Device %s is VLAN challenged and failover device has VLAN set up\n", failover_dev->name); @@ -731,18 +743,23 @@ struct failover *net_failover_create(struct net_device *standby_dev) IFF_TX_SKB_SHARING);

/* don't acquire failover netdev's netif_tx_lock when transmitting */ - failover_dev->features |= NETIF_F_LLTX; + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &failover_dev->features);

/* Don't allow failover devices to change network namespaces. */ - failover_dev->features |= NETIF_F_NETNS_LOCAL; - - failover_dev->hw_features = FAILOVER_VLAN_FEATURES | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_FILTER; - - failover_dev->hw_features |= NETIF_F_GSO_ENCAP_ALL; - failover_dev->features |= failover_dev->hw_features; + netdev_feature_set_bit(NETIF_F_NETNS_LOCAL_BIT, + &failover_dev->features); + + netdev_feature_zero(&failover_dev->hw_features); + netdev_feature_set_bits(FAILOVER_VLAN_FEATURES | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_FILTER, + &failover_dev->hw_features); + + netdev_feature_set_bits(NETIF_F_GSO_ENCAP_ALL, + &failover_dev->hw_features); + netdev_feature_or(&failover_dev->features, failover_dev->features, + failover_dev->hw_features);

memcpy(failover_dev->dev_addr, standby_dev->dev_addr, failover_dev->addr_len);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- include/net/pkt_cls.h | 2 +- net/sched/sch_cake.c | 1 + net/sched/sch_netem.c | 3 ++- net/sched/sch_taprio.c | 3 ++- net/sched/sch_tbf.c | 3 ++- 5 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h index 8fb47fc..bf9787e 100644 --- a/include/net/pkt_cls.h +++ b/include/net/pkt_cls.h @@ -636,7 +636,7 @@ struct tc_cls_u32_offload {

static inline bool tc_can_offload(const struct net_device *dev) { - return dev->features & NETIF_F_HW_TC; + return netdev_feature_test_bit(NETIF_F_HW_TC_BIT, dev->features); }

static inline bool tc_can_offload_extack(const struct net_device *dev, diff --git a/net/sched/sch_cake.c b/net/sched/sch_cake.c index 0808569..2324b5a 100644 --- a/net/sched/sch_cake.c +++ b/net/sched/sch_cake.c @@ -1744,6 +1744,7 @@ static s32 cake_enqueue(struct sk_buff *skb, struct Qdisc *sch, unsigned int slen = 0, numsegs = 0;

netif_skb_features(skb, &features); + netdev_feature_clear_bits(NETIF_F_GSO_MASK, &features); segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); if (IS_ERR_OR_NULL(segs)) return qdisc_drop(skb, sch, to_free); diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c index 414d57e..4aabeb20 100644 --- a/net/sched/sch_netem.c +++ b/net/sched/sch_netem.c @@ -416,7 +416,8 @@ static struct sk_buff *netem_segment(struct sk_buff *skb, struct Qdisc *sch, netdev_features_t features;

netif_skb_features(skb, &features); - segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_GSO_MASK, &features); + segs = skb_gso_segment(skb, features);

if (IS_ERR_OR_NULL(segs)) { qdisc_drop(skb, sch, to_free); diff --git a/net/sched/sch_taprio.c b/net/sched/sch_taprio.c index a4073c4..c5114a7 100644 --- a/net/sched/sch_taprio.c +++ b/net/sched/sch_taprio.c @@ -458,7 +458,8 @@ static int taprio_enqueue(struct sk_buff *skb, struct Qdisc *sch, int ret;

netif_skb_features(skb, &features); - segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_GSO_MASK, &features); + segs = skb_gso_segment(skb, features); if (IS_ERR_OR_NULL(segs)) return qdisc_drop(skb, sch, to_free);

diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c index 99e6d726..8ac786f 100644 --- a/net/sched/sch_tbf.c +++ b/net/sched/sch_tbf.c @@ -197,7 +197,8 @@ static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch, int ret, nb;

netif_skb_features(skb, &features); - segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_GSO_MASK, &features); + segs = skb_gso_segment(skb, features);

if (IS_ERR_OR_NULL(segs)) return qdisc_drop(skb, sch, to_free);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/virtio_net.c | 51 +++++++++++++++++++++++++++++++----------------- 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c index 2e42210..5859f8f 100644 --- a/drivers/net/virtio_net.c +++ b/drivers/net/virtio_net.c @@ -2635,11 +2635,12 @@ static int virtnet_set_features(struct net_device *dev, u64 offloads; int err;

- if ((dev->features ^ features) & NETIF_F_LRO) { + if (netdev_feature_test_bit(NETIF_F_LRO_BIT, dev->features) != + netdev_feature_test_bit(NETIF_F_LRO_BIT, features)) { if (vi->xdp_enabled) return -EBUSY;

- if (features & NETIF_F_LRO) + if (netdev_feature_test_bit(NETIF_F_LRO_BIT, features)) offloads = vi->guest_offloads_capable; else offloads = vi->guest_offloads_capable & @@ -2878,7 +2879,8 @@ static int virtnet_find_vqs(struct virtnet_info *vi) if (vi->has_cvq) { vi->cvq = vqs[total_vqs - 1]; if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VLAN)) - vi->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &vi->dev->features); }

for (i = 0; i < vi->max_queue_pairs; i++) { @@ -3089,7 +3091,8 @@ static int virtnet_probe(struct virtio_device *vdev) dev->priv_flags |= IFF_UNICAST_FLT | IFF_LIVE_ADDR_CHANGE | IFF_TX_SKB_NO_LINEAR; dev->netdev_ops = &virtnet_netdev; - dev->features = NETIF_F_HIGHDMA; + netdev_feature_zero(&dev->features); + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &dev->features);

dev->ethtool_ops = &virtnet_ethtool_ops; SET_NETDEV_DEV(dev, &vdev->dev); @@ -3097,37 +3100,49 @@ static int virtnet_probe(struct virtio_device *vdev) /* Do we support "hardware" checksums? */ if (virtio_has_feature(vdev, VIRTIO_NET_F_CSUM)) { /* This opens up the world of extra features. */ - dev->hw_features |= NETIF_F_HW_CSUM | NETIF_F_SG; + netdev_feature_set_bits(NETIF_F_HW_CSUM | NETIF_F_SG, + &dev->hw_features); if (csum) - dev->features |= NETIF_F_HW_CSUM | NETIF_F_SG; + netdev_feature_set_bits(NETIF_F_HW_CSUM | NETIF_F_SG, + &dev->features);

if (virtio_has_feature(vdev, VIRTIO_NET_F_GSO)) { - dev->hw_features |= NETIF_F_TSO - | NETIF_F_TSO_ECN | NETIF_F_TSO6; + netdev_feature_set_bits(NETIF_F_TSO | NETIF_F_TSO_ECN | + NETIF_F_TSO6, + &dev->hw_features); } /* Individual feature bits: what can host handle? */ if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4)) - dev->hw_features |= NETIF_F_TSO; + netdev_feature_set_bit(NETIF_F_TSO_BIT, + &dev->hw_features); if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO6)) - dev->hw_features |= NETIF_F_TSO6; + netdev_feature_set_bit(NETIF_F_TSO6_BIT, + &dev->hw_features); if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_ECN)) - dev->hw_features |= NETIF_F_TSO_ECN; + netdev_feature_set_bit(NETIF_F_TSO_ECN_BIT, + &dev->hw_features);

- dev->features |= NETIF_F_GSO_ROBUST; + netdev_feature_set_bit(NETIF_F_GSO_ROBUST_BIT, &dev->features);

- if (gso) - dev->features |= dev->hw_features & NETIF_F_ALL_TSO; + if (gso) { + netdev_features_t tmp; + + netdev_feature_zero(&tmp); + netdev_feature_set_bits(NETIF_F_ALL_TSO, &tmp); + netdev_feature_and(&dev->features, dev->hw_features, + tmp); + } /* (!csum && gso) case will be fixed by register_netdev() */ } if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_CSUM)) - dev->features |= NETIF_F_RXCSUM; + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->features); if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4) || virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6)) - dev->features |= NETIF_F_LRO; + netdev_feature_set_bit(NETIF_F_LRO_BIT, &dev->features); if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) - dev->hw_features |= NETIF_F_LRO; + netdev_feature_set_bit(NETIF_F_LRO_BIT, &dev->hw_features);

- dev->vlan_features = dev->features; + netdev_feature_copy(&dev->vlan_features, dev->features);

/* MTU range: 68 - 65535 */ dev->min_mtu = MIN_MTU;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/ipv6/esp6_offload.c | 19 +++++++++++-------- net/ipv6/ip6_gre.c | 17 ++++++++++------- net/ipv6/ip6_offload.c | 3 ++- net/ipv6/ip6_output.c | 18 ++++++++++++------ net/ipv6/ip6_tunnel.c | 9 +++++---- net/ipv6/ip6mr.c | 2 +- net/ipv6/sit.c | 9 +++++---- net/ipv6/udp_offload.c | 2 +- 8 files changed, 47 insertions(+), 32 deletions(-)

diff --git a/net/ipv6/esp6_offload.c b/net/ipv6/esp6_offload.c index a349d47..5c2e0da 100644 --- a/net/ipv6/esp6_offload.c +++ b/net/ipv6/esp6_offload.c @@ -228,8 +228,8 @@ static struct sk_buff *esp6_gso_segment(struct sk_buff *skb, struct xfrm_state *x; struct ip_esp_hdr *esph; struct crypto_aead *aead; - netdev_features_t esp_features = features; struct xfrm_offload *xo = xfrm_offload(skb); + netdev_features_t esp_features; struct sec_path *sp;

if (!xo) @@ -253,12 +253,14 @@ static struct sk_buff *esp6_gso_segment(struct sk_buff *skb,

skb->encap_hdr_csum = 1;

- if (!(features & NETIF_F_HW_ESP) || x->xso.dev != skb->dev) - esp_features = features & ~(NETIF_F_SG | NETIF_F_CSUM_MASK | - NETIF_F_SCTP_CRC); - else if (!(features & NETIF_F_HW_ESP_TX_CSUM)) - esp_features = features & ~(NETIF_F_CSUM_MASK | - NETIF_F_SCTP_CRC); + netdev_feature_copy(&esp_features, features); + if (!netdev_feature_test_bit(NETIF_F_HW_ESP_BIT, features) || + x->xso.dev != skb->dev) + netdev_feature_clear_bits(NETIF_F_SG | NETIF_F_CSUM_MASK | + NETIF_F_SCTP_CRC, &esp_features); + else if (!netdev_feature_test_bit(NETIF_F_HW_ESP_TX_CSUM_BIT, features)) + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_SCTP_CRC, + &esp_features);

xo->flags |= XFRM_GSO_SEGMENT;

@@ -298,7 +300,8 @@ static int esp6_xmit(struct xfrm_state *x, struct sk_buff *skb, netdev_features if (!xo) return -EINVAL;

- if (!(features & NETIF_F_HW_ESP) || x->xso.dev != skb->dev) { + if (!netdev_feature_test_bit(NETIF_F_HW_ESP_BIT, features) || + x->xso.dev != skb->dev) { xo->flags |= CRYPTO_FALLBACK; hw_offload = false; } diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c index 3ad201d..336ddf0 100644 --- a/net/ipv6/ip6_gre.c +++ b/net/ipv6/ip6_gre.c @@ -385,7 +385,7 @@ static struct ip6_tnl *ip6gre_tunnel_locate(struct net *net,

/* Can use a lockless transmit, unless we generate output sequences */ if (!(nt->parms.o_flags & TUNNEL_SEQ)) - dev->features |= NETIF_F_LLTX; + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &dev->features);

ip6gre_tunnel_link(ign, nt); return nt; @@ -1439,8 +1439,8 @@ static void ip6gre_tnl_init_features(struct net_device *dev) { struct ip6_tnl *nt = netdev_priv(dev);

- dev->features |= GRE6_FEATURES; - dev->hw_features |= GRE6_FEATURES; + netdev_feature_set_bits(GRE6_FEATURES, &dev->features); + netdev_feature_set_bits(GRE6_FEATURES, &dev->hw_features);

if (!(nt->parms.o_flags & TUNNEL_SEQ)) { /* TCP offload with GRE SEQ is not supported, nor @@ -1449,14 +1449,16 @@ static void ip6gre_tnl_init_features(struct net_device *dev) */ if (!(nt->parms.o_flags & TUNNEL_CSUM) || nt->encap.type == TUNNEL_ENCAP_NONE) { - dev->features |= NETIF_F_GSO_SOFTWARE; - dev->hw_features |= NETIF_F_GSO_SOFTWARE; + netdev_feature_set_bits(NETIF_F_GSO_SOFTWARE, + &dev->features); + netdev_feature_set_bits(NETIF_F_GSO_SOFTWARE, + &dev->hw_features); }

/* Can use a lockless transmit, unless we generate * output sequences */ - dev->features |= NETIF_F_LLTX; + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &dev->features); } }

@@ -1598,7 +1600,8 @@ static int __net_init ip6gre_init_net(struct net *net) /* FB netdevice is special: we have one, and only one per netns. * Allowing to move it to another netns is clearly unsafe. */ - ign->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL; + netdev_feature_set_bit(NETIF_F_NETNS_LOCAL_BIT, + &ign->fb_tunnel_dev->features);

ip6gre_fb_tunnel_init(ign->fb_tunnel_dev); diff --git a/net/ipv6/ip6_offload.c b/net/ipv6/ip6_offload.c index 1b9827f..4c3ba4b 100644 --- a/net/ipv6/ip6_offload.c +++ b/net/ipv6/ip6_offload.c @@ -93,7 +93,8 @@ static struct sk_buff *ipv6_gso_segment(struct sk_buff *skb,

encap = SKB_GSO_CB(skb)->encap_level > 0; if (encap) - features &= skb->dev->hw_enc_features; + netdev_feature_and(&features, features, + skb->dev->hw_enc_features); SKB_GSO_CB(skb)->encap_level += sizeof(*ipv6h);

ipv6h = ipv6_hdr(skb); diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c index 46a0867..78e01d4 100644 --- a/net/ipv6/ip6_output.c +++ b/net/ipv6/ip6_output.c @@ -147,7 +147,8 @@ ip6_finish_output_gso_slowpath_drop(struct net *net, struct sock *sk, * egress MTU. */ netif_skb_features(skb, &features); - segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_GSO_MASK, &features); + segs = skb_gso_segment(skb, features); if (IS_ERR_OR_NULL(segs)) { kfree_skb(skb); return -ENOMEM; @@ -1512,7 +1513,8 @@ static int __ip6_append_data(struct sock *sk, headersize == sizeof(struct ipv6hdr) && length <= mtu - headersize && (!(flags & MSG_MORE) || cork->gso_size) && - rt->dst.dev->features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM)) + netdev_feature_test_bits(NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM, + rt->dst.dev->features)) csummode = CHECKSUM_PARTIAL;

if (flags & MSG_ZEROCOPY && length && sock_flag(sk, SOCK_ZEROCOPY)) { @@ -1520,7 +1522,8 @@ static int __ip6_append_data(struct sock *sk, if (!uarg) return -ENOBUFS; extra_uref = !skb_zcopy(skb); /* only ref on new uarg */ - if (rt->dst.dev->features & NETIF_F_SG && + if (netdev_feature_test_bit(NETIF_F_SG_BIT, + rt->dst.dev->features) && csummode == CHECKSUM_PARTIAL) { paged = true; } else { @@ -1598,11 +1601,13 @@ static int __ip6_append_data(struct sock *sk, alloc_extra += sizeof(struct frag_hdr);

if ((flags & MSG_MORE) && - !(rt->dst.dev->features&NETIF_F_SG)) + !netdev_feature_test_bit(NETIF_F_SG_BIT, + rt->dst.dev->features)) alloclen = mtu; else if (!paged && (fraglen + alloc_extra < SKB_MAX_ALLOC || - !(rt->dst.dev->features & NETIF_F_SG))) + !netdev_feature_test_bit(NETIF_F_SG_BIT, + rt->dst.dev->features))) alloclen = fraglen; else { alloclen = min_t(int, fraglen, MAX_HEADER); @@ -1705,7 +1710,8 @@ static int __ip6_append_data(struct sock *sk, if (copy > length) copy = length;

- if (!(rt->dst.dev->features&NETIF_F_SG) && + if (!netdev_feature_test_bit(NETIF_F_SG_BIT, + rt->dst.dev->features) && skb_tailroom(skb) >= copy) { unsigned int off;

diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c index 20a67ef..72add9a 100644 --- a/net/ipv6/ip6_tunnel.c +++ b/net/ipv6/ip6_tunnel.c @@ -1833,11 +1833,11 @@ static void ip6_tnl_dev_setup(struct net_device *dev) dev->type = ARPHRD_TUNNEL6; dev->flags |= IFF_NOARP; dev->addr_len = sizeof(struct in6_addr); - dev->features |= NETIF_F_LLTX; + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &dev->features); netif_keep_dst(dev);

- dev->features |= IPXIPX_FEATURES; - dev->hw_features |= IPXIPX_FEATURES; + netdev_feature_set_bits(IPXIPX_FEATURES, &dev->features); + netdev_feature_set_bits(IPXIPX_FEATURES, &dev->hw_features);

/* This perm addr will be used as interface identifier by IPv6 */ dev->addr_assign_type = NET_ADDR_RANDOM; @@ -2279,7 +2279,8 @@ static int __net_init ip6_tnl_init_net(struct net *net) /* FB netdevice is special: we have one, and only one per netns. * Allowing to move it to another netns is clearly unsafe. */ - ip6n->fb_tnl_dev->features |= NETIF_F_NETNS_LOCAL; + netdev_feature_set_bits(NETIF_F_NETNS_LOCAL_BIT, + &ip6n->fb_tnl_dev->features);

err = ip6_fb_tnl_dev_init(ip6n->fb_tnl_dev); if (err < 0) diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c index 36ed9ef..daf2a4b 100644 --- a/net/ipv6/ip6mr.c +++ b/net/ipv6/ip6mr.c @@ -636,7 +636,7 @@ static void reg_vif_setup(struct net_device *dev) dev->flags = IFF_NOARP; dev->netdev_ops = &reg_vif_netdev_ops; dev->needs_free_netdev = true; - dev->features |= NETIF_F_NETNS_LOCAL; + netdev_feature_set_bit(NETIF_F_NETNS_LOCAL_BIT, &dev->features); }

static struct net_device *ip6mr_reg_vif(struct net *net, struct mr_table *mrt) diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c index ef0c7a7..58aa232 100644 --- a/net/ipv6/sit.c +++ b/net/ipv6/sit.c @@ -1438,9 +1438,9 @@ static void ipip6_tunnel_setup(struct net_device *dev) dev->flags = IFF_NOARP; netif_keep_dst(dev); dev->addr_len = 4; - dev->features |= NETIF_F_LLTX; - dev->features |= SIT_FEATURES; - dev->hw_features |= SIT_FEATURES; + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &dev->features); + netdev_feature_set_bits(SIT_FEATURES, &dev->features); + netdev_feature_set_bits(SIT_FEATURES, &dev->hw_features); }

static int ipip6_tunnel_init(struct net_device *dev) @@ -1918,7 +1918,8 @@ static int __net_init sit_init_net(struct net *net) /* FB netdevice is special: we have one, and only one per netns. * Allowing to move it to another netns is clearly unsafe. */ - sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL; + netdev_feature_set_bit(NETIF_F_NETNS_LOCAL_BIT, + &sitn->fb_tunnel_dev->features);

err = register_netdev(sitn->fb_tunnel_dev); if (err) diff --git a/net/ipv6/udp_offload.c b/net/ipv6/udp_offload.c index b3d9ed9..5911c60 100644 --- a/net/ipv6/udp_offload.c +++ b/net/ipv6/udp_offload.c @@ -69,7 +69,7 @@ static struct sk_buff *udp6_ufo_fragment(struct sk_buff *skb, * software prior to segmenting the frame. */ if (!skb->encap_hdr_csum) - features |= NETIF_F_HW_CSUM; + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &features);

/* Check if there is enough headroom to insert fragment header. */ tnl_hlen = skb_tnl_header_len(skb);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/nsh/nsh.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/net/nsh/nsh.c b/net/nsh/nsh.c index e9ca007..a337412 100644 --- a/net/nsh/nsh.c +++ b/net/nsh/nsh.c @@ -104,7 +104,7 @@ static struct sk_buff *nsh_gso_segment(struct sk_buff *skb, skb->mac_len = proto == htons(ETH_P_TEB) ? ETH_HLEN : 0; skb->protocol = proto;

- features &= NETIF_F_SG; + netdev_feature_clear_bit(NETIF_F_SG_BIT, &features); segs = skb_mac_gso_segment(skb, features); if (IS_ERR_OR_NULL(segs)) { skb_gso_error_unwind(skb, htons(ETH_P_NSH), nsh_len,

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/xen-netback/interface.c | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c index f964f0a..8acfc1f 100644 --- a/drivers/net/xen-netback/interface.c +++ b/drivers/net/xen-netback/interface.c @@ -380,15 +380,15 @@ static void xenvif_fix_features(struct net_device *dev, struct xenvif *vif = netdev_priv(dev);

if (!vif->can_sg) - *features &= ~NETIF_F_SG; + netdev_feature_clear_bit(NETIF_F_SG_BIT, features); if (~(vif->gso_mask) & GSO_BIT(TCPV4)) - *features &= ~NETIF_F_TSO; + netdev_feature_clear_bit(NETIF_F_TSO_BIT, features); if (~(vif->gso_mask) & GSO_BIT(TCPV6)) - *features &= ~NETIF_F_TSO6; + netdev_feature_clear_bit(NETIF_F_TSO6_BIT, features); if (!vif->ip_csum) - *features &= ~NETIF_F_IP_CSUM; + netdev_feature_clear_bit(NETIF_F_IP_CSUM_BIT, features); if (!vif->ipv6_csum) - *features &= ~NETIF_F_IPV6_CSUM; + netdev_feature_clear_bit(NETIF_F_IPV6_CSUM_BIT, features); }

static const struct xenvif_stat { @@ -532,10 +532,13 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, INIT_LIST_HEAD(&vif->fe_mcast_addr);

dev->netdev_ops = &xenvif_netdev_ops; - dev->hw_features = NETIF_F_SG | - NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_FRAGLIST; - dev->features = dev->hw_features | NETIF_F_RXCSUM; + netdev_feature_zero(&dev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_FRAGLIST, + &dev->hw_features); + netdev_feature_copy(&dev->features, dev->hw_features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->features); dev->ethtool_ops = &xenvif_ethtool_ops;

dev->tx_queue_len = XENVIF_QUEUE_LENGTH;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- include/net/sock.h | 7 ++++--- net/core/skmsg.c | 3 ++- net/core/sock.c | 17 +++++++++++------ net/ipv4/af_inet.c | 2 +- net/ipv4/tcp.c | 10 ++++++---- net/ipv4/tcp_ipv4.c | 2 +- net/ipv6/af_inet6.c | 2 +- net/ipv6/inet6_connection_sock.c | 2 +- net/ipv6/tcp_ipv6.c | 2 +- 9 files changed, 28 insertions(+), 19 deletions(-)

diff --git a/include/net/sock.h b/include/net/sock.h index 6e76145..01f38c5 100644 --- a/include/net/sock.h +++ b/include/net/sock.h @@ -2061,8 +2061,8 @@ void sk_setup_caps(struct sock *sk, struct dst_entry *dst);

static inline void sk_nocaps_add(struct sock *sk, netdev_features_t flags) { - sk->sk_route_nocaps |= flags; - sk->sk_route_caps &= ~flags; + netdev_feature_or(&sk->sk_route_nocaps, sk->sk_route_nocaps, flags); + netdev_feature_andnot(&sk->sk_route_caps, sk->sk_route_caps, flags); }

static inline int skb_do_copy_data_nocache(struct sock *sk, struct sk_buff *skb, @@ -2074,7 +2074,8 @@ static inline int skb_do_copy_data_nocache(struct sock *sk, struct sk_buff *skb, if (!csum_and_copy_from_iter_full(to, copy, &csum, from)) return -EFAULT; skb->csum = csum_block_add(skb->csum, csum, offset); - } else if (sk->sk_route_caps & NETIF_F_NOCACHE_COPY) { + } else if (netdev_feature_test_bit(NETIF_F_NOCACHE_COPY_BIT, + sk->sk_route_caps)) { if (!copy_from_iter_full_nocache(to, copy, from)) return -EFAULT; } else if (!copy_from_iter_full(to, copy, from)) diff --git a/net/core/skmsg.c b/net/core/skmsg.c index 2d6249b..2ff4a64 100644 --- a/net/core/skmsg.c +++ b/net/core/skmsg.c @@ -379,7 +379,8 @@ int sk_msg_memcopy_from_iter(struct sock *sk, struct iov_iter *from, copy = (buf_size > bytes) ? bytes : buf_size; to = sg_virt(sge) + msg->sg.copybreak; msg->sg.copybreak += copy; - if (sk->sk_route_caps & NETIF_F_NOCACHE_COPY) + if (netdev_feature_test_bit(NETIF_F_NOCACHE_COPY_BIT, + sk->sk_route_caps)) ret = copy_from_iter_nocache(to, copy, from); else ret = copy_from_iter(to, copy, from); diff --git a/net/core/sock.c b/net/core/sock.c index aada649..11c04a6 100644 --- a/net/core/sock.c +++ b/net/core/sock.c @@ -2146,15 +2146,20 @@ void sk_setup_caps(struct sock *sk, struct dst_entry *dst) u32 max_segs = 1;

sk_dst_set(sk, dst); - sk->sk_route_caps = dst->dev->features | sk->sk_route_forced_caps; - if (sk->sk_route_caps & NETIF_F_GSO) - sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE; - sk->sk_route_caps &= ~sk->sk_route_nocaps; + netdev_feature_or(&sk->sk_route_caps, dst->dev->features, + sk->sk_route_forced_caps); + if (netdev_feature_test_bit(NETIF_F_GSO_BIT, sk->sk_route_caps)) + netdev_feature_set_bits(NETIF_F_GSO_SOFTWARE, + &sk->sk_route_caps); + netdev_feature_andnot(&sk->sk_route_caps, sk->sk_route_caps, + sk->sk_route_nocaps); if (sk_can_gso(sk)) { if (dst->header_len && !xfrm_dst_offload_ok(dst)) { - sk->sk_route_caps &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, + &sk->sk_route_caps); } else { - sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_HW_CSUM, + &sk->sk_route_caps); sk->sk_gso_max_size = dst->dev->gso_max_size; max_segs = max_t(u32, dst->dev->gso_max_segs, 1); } diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c index 2932eba..80c62ed 100644 --- a/net/ipv4/af_inet.c +++ b/net/ipv4/af_inet.c @@ -1299,7 +1299,7 @@ int inet_sk_rebuild_header(struct sock *sk) err = PTR_ERR(rt);

/* Routing failed... */ - sk->sk_route_caps = 0; + netdev_feature_zero(&sk->sk_route_caps); /* * Other protocols have to map its equivalent state to TCP_SYN_SENT. * DCCP maps its DCCP_REQUESTING state to TCP_SYN_SENT. -acme diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c index f931def..cdcafd5 100644 --- a/net/ipv4/tcp.c +++ b/net/ipv4/tcp.c @@ -462,7 +462,8 @@ void tcp_init_sock(struct sock *sk) WRITE_ONCE(sk->sk_rcvbuf, sock_net(sk)->ipv4.sysctl_tcp_rmem[1]);

sk_sockets_allocated_inc(sk); - sk->sk_route_forced_caps = NETIF_F_GSO; + netdev_feature_zero(&sk->sk_route_forced_caps); + netdev_feature_set_bit(NETIF_F_GSO_BIT, &sk->sk_route_forced_caps); } EXPORT_SYMBOL(tcp_init_sock);

@@ -1123,7 +1124,7 @@ EXPORT_SYMBOL_GPL(do_tcp_sendpages); int tcp_sendpage_locked(struct sock *sk, struct page *page, int offset, size_t size, int flags) { - if (!(sk->sk_route_caps & NETIF_F_SG)) + if (!netdev_feature_test_bit(NETIF_F_SG_BIT, sk->sk_route_caps)) return sock_no_sendpage_locked(sk, page, offset, size, flags);

tcp_rate_check_app_limited(sk); /* is sending application-limited? */ @@ -1183,7 +1184,7 @@ static int tcp_sendmsg_fastopen(struct sock *sk, struct msghdr *msg, if (err) { tcp_set_state(sk, TCP_CLOSE); inet->inet_dport = 0; - sk->sk_route_caps = 0; + netdev_feature_zero(&sk->sk_route_caps); } } flags = (msg->msg_flags & MSG_DONTWAIT) ? O_NONBLOCK : 0; @@ -1222,7 +1223,8 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size) goto out_err; }

- zc = sk->sk_route_caps & NETIF_F_SG; + zc = netdev_feature_test_bit(NETIF_F_SG_BIT, + sk->sk_route_caps); if (!zc) uarg->zerocopy = 0; } diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c index 2e62e0d..60f9ef0 100644 --- a/net/ipv4/tcp_ipv4.c +++ b/net/ipv4/tcp_ipv4.c @@ -323,7 +323,7 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) */ tcp_set_state(sk, TCP_CLOSE); ip_rt_put(rt); - sk->sk_route_caps = 0; + netdev_feature_zero(&sk->sk_route_caps); inet->inet_dport = 0; return err; } diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c index d92c90d..7b8eb28 100644 --- a/net/ipv6/af_inet6.c +++ b/net/ipv6/af_inet6.c @@ -833,7 +833,7 @@ int inet6_sk_rebuild_header(struct sock *sk)

dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p); if (IS_ERR(dst)) { - sk->sk_route_caps = 0; + netdev_feature_zero(&sk->sk_route_caps); sk->sk_err_soft = -PTR_ERR(dst); return PTR_ERR(dst); } diff --git a/net/ipv6/inet6_connection_sock.c b/net/ipv6/inet6_connection_sock.c index 5a9f4d7..6d83148 100644 --- a/net/ipv6/inet6_connection_sock.c +++ b/net/ipv6/inet6_connection_sock.c @@ -121,7 +121,7 @@ int inet6_csk_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl_unused dst = inet6_csk_route_socket(sk, &fl6); if (IS_ERR(dst)) { sk->sk_err_soft = -PTR_ERR(dst); - sk->sk_route_caps = 0; + netdev_feature_zero(&sk->sk_route_caps); kfree_skb(skb); return PTR_ERR(dst); } diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c index 0ce52d4..642d640 100644 --- a/net/ipv6/tcp_ipv6.c +++ b/net/ipv6/tcp_ipv6.c @@ -341,7 +341,7 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, tcp_set_state(sk, TCP_CLOSE); failure: inet->inet_dport = 0; - sk->sk_route_caps = 0; + netdev_feature_zero(&sk->sk_route_caps); return err; }

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/loopback.c | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c index a1c77cc..23cad64 100644 --- a/drivers/net/loopback.c +++ b/drivers/net/loopback.c @@ -174,17 +174,15 @@ static void gen_lo_setup(struct net_device *dev, dev->flags = IFF_LOOPBACK; dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE; netif_keep_dst(dev); - dev->hw_features = NETIF_F_GSO_SOFTWARE; - dev->features = NETIF_F_SG | NETIF_F_FRAGLIST - | NETIF_F_GSO_SOFTWARE - | NETIF_F_HW_CSUM - | NETIF_F_RXCSUM - | NETIF_F_SCTP_CRC - | NETIF_F_HIGHDMA - | NETIF_F_LLTX - | NETIF_F_NETNS_LOCAL - | NETIF_F_VLAN_CHALLENGED - | NETIF_F_LOOPBACK; + netdev_feature_zero(&dev->hw_features); + netdev_feature_set_bits(NETIF_F_GSO_SOFTWARE, &dev->hw_features); + netdev_feature_zero(&dev->features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_FRAGLIST | + NETIF_F_GSO_SOFTWARE | NETIF_F_HW_CSUM | + NETIF_F_RXCSUM | NETIF_F_SCTP_CRC | + NETIF_F_HIGHDMA | NETIF_F_LLTX | + NETIF_F_NETNS_LOCAL | NETIF_F_VLAN_CHALLENGED | + NETIF_F_LOOPBACK, &dev->hw_features); dev->ethtool_ops = eth_ops; dev->header_ops = hdr_ops; dev->netdev_ops = dev_ops;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- net/mac80211/iface.c | 10 +++++++--- net/mac80211/main.c | 5 ++++- 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c index 1e5e9fc..784f87a 100644 --- a/net/mac80211/iface.c +++ b/net/mac80211/iface.c @@ -1991,13 +1991,17 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name, ieee80211_setup_sdata(sdata, type);

if (ndev) { + netdev_features_t tmp; + ndev->ieee80211_ptr->use_4addr = params->use_4addr; if (type == NL80211_IFTYPE_STATION) sdata->u.mgd.use_4addr = params->use_4addr;

- ndev->features |= local->hw.netdev_features; - ndev->hw_features |= ndev->features & - MAC80211_SUPPORTED_FEATURES_TX; + netdev_feature_or(&ndev->features, ndev->features, + local->hw.netdev_features); + netdev_feature_copy(&tmp, ndev->features); + netdev_feature_and_bits(MAC80211_SUPPORTED_FEATURES_TX, &tmp); + netdev_feature_or(&ndev->hw_features, ndev->hw_features, tmp);

netdev_set_default_ethtool_ops(ndev, &ieee80211_ethtool_ops);

diff --git a/net/mac80211/main.c b/net/mac80211/main.c index 05f4c3c..9b69e53 100644 --- a/net/mac80211/main.c +++ b/net/mac80211/main.c @@ -909,6 +909,7 @@ int ieee80211_register_hw(struct ieee80211_hw *hw) int channels, max_bitrates; bool supp_ht, supp_vht, supp_he; struct cfg80211_chan_def dflt_chandef = {}; + netdev_features_t tmp;

if (ieee80211_hw_check(hw, QUEUE_CONTROL) && (local->hw.offchannel_tx_hw_queue == IEEE80211_INVAL_HW_QUEUE || @@ -958,7 +959,9 @@ int ieee80211_register_hw(struct ieee80211_hw *hw) }

/* Only HW csum features are currently compatible with mac80211 */ - if (WARN_ON(hw->netdev_features & ~MAC80211_SUPPORTED_FEATURES)) + netdev_feature_copy(&tmp, hw->netdev_features); + netdev_feature_clear_bits(MAC80211_SUPPORTED_FEATURES, &tmp); + if (WARN_ON(!netdev_feature_empty(tmp))) return -EINVAL;

if (hw->max_report_rates == 0)

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/bareudp.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/drivers/net/bareudp.c b/drivers/net/bareudp.c index a7ee0af..30d47c8 100644 --- a/drivers/net/bareudp.c +++ b/drivers/net/bareudp.c @@ -528,13 +528,15 @@ static void bareudp_setup(struct net_device *dev) dev->netdev_ops = &bareudp_netdev_ops; dev->needs_free_netdev = true; SET_NETDEV_DEVTYPE(dev, &bareudp_type); - dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST; - dev->features |= NETIF_F_RXCSUM; - dev->features |= NETIF_F_LLTX; - dev->features |= NETIF_F_GSO_SOFTWARE; - dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST; - dev->hw_features |= NETIF_F_RXCSUM; - dev->hw_features |= NETIF_F_GSO_SOFTWARE; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST, + &dev->features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->features); + netdev_feature_set_bit(NETIF_F_LLTX_BIT, &dev->features); + netdev_feature_set_bits(NETIF_F_GSO_SOFTWARE, &dev->features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST, + &dev->hw_features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->hw_features); + netdev_feature_set_bits(NETIF_F_GSO_SOFTWARE, &dev->hw_features); dev->hard_header_len = 0; dev->addr_len = 0; dev->mtu = ETH_DATA_LEN;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/nlmon.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/drivers/net/nlmon.c b/drivers/net/nlmon.c index 5e19a68..66af978 100644 --- a/drivers/net/nlmon.c +++ b/drivers/net/nlmon.c @@ -89,8 +89,9 @@ static void nlmon_setup(struct net_device *dev) dev->ethtool_ops = &nlmon_ethtool_ops; dev->needs_free_netdev = true;

- dev->features = NETIF_F_SG | NETIF_F_FRAGLIST | - NETIF_F_HIGHDMA | NETIF_F_LLTX; + netdev_feature_zero(&dev->features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_FRAGLIST | + NETIF_F_HIGHDMA | NETIF_F_LLTX, &dev->features); dev->flags = IFF_NOARP;

/* That's rather a softlimit here, which, of course,

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/can/dev/dev.c | 3 ++- drivers/net/can/slcan.c | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/can/dev/dev.c b/drivers/net/can/dev/dev.c index 311d856..45c7d48 100644 --- a/drivers/net/can/dev/dev.c +++ b/drivers/net/can/dev/dev.c @@ -232,7 +232,8 @@ void can_setup(struct net_device *dev)

/* New-style flags. */ dev->flags = IFF_NOARP; - dev->features = NETIF_F_HW_CSUM; + netdev_feature_zero(&dev->features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &dev->features); }

/* Allocate and setup space for the CAN network device */ diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c index d42ec7d..8af2cf0 100644 --- a/drivers/net/can/slcan.c +++ b/drivers/net/can/slcan.c @@ -450,7 +450,8 @@ static void slc_setup(struct net_device *dev)

/* New-style flags. */ dev->flags = IFF_NOARP; - dev->features = NETIF_F_HW_CSUM; + netdev_feature_zero(&dev->features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &dev->features); }

/******************************************

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ipa/ipa_modem.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/ipa/ipa_modem.c b/drivers/net/ipa/ipa_modem.c index ad4019e..f0ce8d6 100644 --- a/drivers/net/ipa/ipa_modem.c +++ b/drivers/net/ipa/ipa_modem.c @@ -165,7 +165,8 @@ static void ipa_modem_netdev_setup(struct net_device *netdev) netdev->needed_headroom = sizeof(struct rmnet_map_header); netdev->needed_tailroom = IPA_NETDEV_TAILROOM; netdev->watchdog_timeo = IPA_NETDEV_TIMEOUT * HZ; - netdev->hw_features = NETIF_F_SG; + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bit(NETIF_F_SG_BIT, &netdev->hw_features); }

/** ipa_modem_suspend() - suspend callback

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/usb/aqc111.c | 42 +++++++++++++++------------ drivers/net/usb/ax88179_178a.c | 26 +++++++++-------- drivers/net/usb/cdc-phonet.c | 2 +- drivers/net/usb/cdc_mbim.c | 4 ++- drivers/net/usb/lan78xx.c | 34 +++++++++++++--------- drivers/net/usb/r8152.c | 64 ++++++++++++++++++++++++++---------------- drivers/net/usb/smsc75xx.c | 14 +++++---- drivers/net/usb/smsc95xx.c | 18 +++++++----- 8 files changed, 121 insertions(+), 83 deletions(-)

diff --git a/drivers/net/usb/aqc111.c b/drivers/net/usb/aqc111.c index 73b97f4..1363f64 100644 --- a/drivers/net/usb/aqc111.c +++ b/drivers/net/usb/aqc111.c @@ -567,27 +567,28 @@ static int aqc111_set_features(struct net_device *net, { struct usbnet *dev = netdev_priv(net); struct aqc111_data *aqc111_data = dev->driver_priv; - netdev_features_t changed = net->features ^ features; + netdev_features_t changed; u16 reg16 = 0; u8 reg8 = 0;

- if (changed & NETIF_F_IP_CSUM) { + netdev_feature_xor(&changed, net->features, features); + if (netdev_feature_test_bit(NETIF_F_IP_CSUM_BIT, changed)) { aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8); reg8 ^= SFR_TXCOE_TCP | SFR_TXCOE_UDP; aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8); }

- if (changed & NETIF_F_IPV6_CSUM) { + if (netdev_feature_test_bit(NETIF_F_IPV6_CSUM_BIT, changed)) { aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8); reg8 ^= SFR_TXCOE_TCPV6 | SFR_TXCOE_UDPV6; aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8); }

- if (changed & NETIF_F_RXCSUM) { + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, changed)) { aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_RXCOE_CTL, 1, 1, &reg8); - if (features & NETIF_F_RXCSUM) { + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) { aqc111_data->rx_checksum = 1; reg8 &= ~(SFR_RXCOE_IP | SFR_RXCOE_TCP | SFR_RXCOE_UDP | SFR_RXCOE_TCPV6 | SFR_RXCOE_UDPV6); @@ -600,8 +601,9 @@ static int aqc111_set_features(struct net_device *net, aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RXCOE_CTL, 1, 1, &reg8); } - if (changed & NETIF_F_HW_VLAN_CTAG_FILTER) { - if (features & NETIF_F_HW_VLAN_CTAG_FILTER) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, changed)) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + features)) { u16 i = 0;

for (i = 0; i < 256; i++) { @@ -731,9 +733,10 @@ static int aqc111_bind(struct usbnet *dev, struct usb_interface *intf) if (usb_device_no_sg_constraint(dev->udev)) dev->can_dma_sg = 1;

- dev->net->hw_features |= AQ_SUPPORT_HW_FEATURE; - dev->net->features |= AQ_SUPPORT_FEATURE; - dev->net->vlan_features |= AQ_SUPPORT_VLAN_FEATURE; + netdev_feature_set_bits(AQ_SUPPORT_HW_FEATURE, &dev->net->hw_features); + netdev_feature_set_bits(AQ_SUPPORT_FEATURE, &dev->net->features); + netdev_feature_set_bits(AQ_SUPPORT_VLAN_FEATURE, + &dev->net->vlan_features);

netif_set_gso_max_size(dev->net, 65535);

@@ -881,17 +884,17 @@ static void aqc111_configure_csum_offload(struct usbnet *dev) { u8 reg8 = 0;

- if (dev->net->features & NETIF_F_RXCSUM) { + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, dev->net->features)) { reg8 |= SFR_RXCOE_IP | SFR_RXCOE_TCP | SFR_RXCOE_UDP | SFR_RXCOE_TCPV6 | SFR_RXCOE_UDPV6; } aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RXCOE_CTL, 1, 1, &reg8);

reg8 = 0; - if (dev->net->features & NETIF_F_IP_CSUM) + if (netdev_feature_test_bit(NETIF_F_IP_CSUM_BIT, dev->net->features)) reg8 |= SFR_TXCOE_IP | SFR_TXCOE_TCP | SFR_TXCOE_UDP;

- if (dev->net->features & NETIF_F_IPV6_CSUM) + if (netdev_feature_test_bit(NETIF_F_IPV6_CSUM_BIT, dev->net->features)) reg8 |= SFR_TXCOE_TCPV6 | SFR_TXCOE_UDPV6;

aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8); @@ -908,7 +911,8 @@ static int aqc111_link_reset(struct usbnet *dev)

/* Vlan Tag Filter */ reg8 = SFR_VLAN_CONTROL_VSO; - if (dev->net->features & NETIF_F_HW_VLAN_CTAG_FILTER) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + dev->net->features)) reg8 |= SFR_VLAN_CONTROL_VFE;

aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, @@ -996,9 +1000,10 @@ static int aqc111_reset(struct usbnet *dev) if (usb_device_no_sg_constraint(dev->udev)) dev->can_dma_sg = 1;

- dev->net->hw_features |= AQ_SUPPORT_HW_FEATURE; - dev->net->features |= AQ_SUPPORT_FEATURE; - dev->net->vlan_features |= AQ_SUPPORT_VLAN_FEATURE; + netdev_feature_set_bits(AQ_SUPPORT_HW_FEATURE, &dev->net->hw_features); + netdev_feature_set_bits(AQ_SUPPORT_FEATURE, &dev->net->features); + netdev_feature_set_bits(AQ_SUPPORT_VLAN_FEATURE, + &dev->net->vlan_features);

/* Power up ethernet PHY */ aqc111_data->phy_cfg = AQ_PHY_POWER_EN; @@ -1209,7 +1214,8 @@ static struct sk_buff *aqc111_tx_fixup(struct usbnet *dev, struct sk_buff *skb, AQ_TX_DESC_VLAN_SHIFT; }

- if (!dev->can_dma_sg && (dev->net->features & NETIF_F_SG) && + if (!dev->can_dma_sg && + netdev_feature_test_bit(NETIF_F_SG_BIT, dev->net->features) && skb_linearize(skb)) return NULL;

diff --git a/drivers/net/usb/ax88179_178a.c b/drivers/net/usb/ax88179_178a.c index f25448a..0099d55f 100644 --- a/drivers/net/usb/ax88179_178a.c +++ b/drivers/net/usb/ax88179_178a.c @@ -952,21 +952,23 @@ ax88179_set_features(struct net_device *net, netdev_features_t features) { u8 tmp; struct usbnet *dev = netdev_priv(net); - netdev_features_t changed = net->features ^ features; + netdev_features_t changed;

- if (changed & NETIF_F_IP_CSUM) { + netdev_feature_xor(&changed, net->features, features); + + if (netdev_feature_test_bit(NETIF_F_IP_CSUM_BIT, changed)) { ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp); tmp ^= AX_TXCOE_TCP | AX_TXCOE_UDP; ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp); }

- if (changed & NETIF_F_IPV6_CSUM) { + if (netdev_feature_test_bit(NETIF_F_IPV6_CSUM_BIT, changed)) { ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp); tmp ^= AX_TXCOE_TCPV6 | AX_TXCOE_UDPV6; ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp); }

- if (changed & NETIF_F_RXCSUM) { + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, changed)) { ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, &tmp); tmp ^= AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP | AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6; @@ -1377,11 +1379,11 @@ static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf) dev->mii.phy_id = 0x03; dev->mii.supports_gmii = 1;

- dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM, &dev->net->features);

- dev->net->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM, &dev->net->hw_features);

/* Enable checksum offload */ *tmp = AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP | @@ -1664,11 +1666,11 @@ static int ax88179_reset(struct usbnet *dev) ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_HIGH, 1, 1, tmp);

- dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM, &dev->net->features);

- dev->net->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM, &dev->net->hw_features);

/* Enable checksum offload */ *tmp = AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP | diff --git a/drivers/net/usb/cdc-phonet.c b/drivers/net/usb/cdc-phonet.c index e1da910..a65be62 100644 --- a/drivers/net/usb/cdc-phonet.c +++ b/drivers/net/usb/cdc-phonet.c @@ -275,7 +275,7 @@ static const struct net_device_ops usbpn_ops = {

static void usbpn_setup(struct net_device *dev) { - dev->features = 0; + netdev_feature_zero(&dev->features); dev->netdev_ops = &usbpn_ops; dev->header_ops = &phonet_header_ops; dev->type = ARPHRD_PHONET; diff --git a/drivers/net/usb/cdc_mbim.c b/drivers/net/usb/cdc_mbim.c index 4c4ab7b..100fe6c 100644 --- a/drivers/net/usb/cdc_mbim.c +++ b/drivers/net/usb/cdc_mbim.c @@ -184,7 +184,9 @@ static int cdc_mbim_bind(struct usbnet *dev, struct usb_interface *intf) dev->net->flags |= IFF_NOARP;

/* no need to put the VLAN tci in the packet headers */ - dev->net->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_FILTER, + &dev->net->features);

/* monitor VLAN additions and removals */ dev->net->netdev_ops = &cdc_mbim_netdev_ops; diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c index fe5c0d4..65a9892 100644 --- a/drivers/net/usb/lan78xx.c +++ b/drivers/net/usb/lan78xx.c @@ -2331,7 +2331,7 @@ static int lan78xx_set_features(struct net_device *netdev,

spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);

- if (features & NETIF_F_RXCSUM) { + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) { pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_; pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_; } else { @@ -2339,12 +2339,12 @@ static int lan78xx_set_features(struct net_device *netdev, pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_); }

- if (features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features)) pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_; else pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;

- if (features & NETIF_F_HW_VLAN_CTAG_FILTER) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, features)) pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_; else pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_; @@ -2879,24 +2879,28 @@ static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)

INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);

- dev->net->features = 0; + netdev_feature_zero(&dev->net->features);

if (DEFAULT_TX_CSUM_ENABLE) - dev->net->features |= NETIF_F_HW_CSUM; + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, + &dev->net->features);

if (DEFAULT_RX_CSUM_ENABLE) - dev->net->features |= NETIF_F_RXCSUM; + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->net->features);

if (DEFAULT_TSO_CSUM_ENABLE) - dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG; + netdev_feature_set_bits(NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG, + &dev->net->features);

if (DEFAULT_VLAN_RX_OFFLOAD) - dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &dev->net->features);

if (DEFAULT_VLAN_FILTER_ENABLE) - dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &dev->net->features);

- dev->net->hw_features = dev->net->features; + netdev_feature_copy(&dev->net->hw_features, dev->net->features);

ret = lan78xx_setup_irq_domain(dev); if (ret < 0) { @@ -2963,10 +2967,11 @@ static void lan78xx_rx_csum_offload(struct lan78xx_net *dev, /* HW Checksum offload appears to be flawed if used when not stripping * VLAN headers. Drop back to S/W checksums under these conditions. */ - if (!(dev->net->features & NETIF_F_RXCSUM) || + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, dev->net->features) || unlikely(rx_cmd_a & RX_CMD_A_ICSM_) || ((rx_cmd_a & RX_CMD_A_FVTG_) && - !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) { + !netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->net->features))) { skb->ip_summed = CHECKSUM_NONE; } else { skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_)); @@ -2978,7 +2983,8 @@ static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev, struct sk_buff *skb, u32 rx_cmd_a, u32 rx_cmd_b) { - if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) && + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->net->features) && (rx_cmd_a & RX_CMD_A_FVTG_)) __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), (rx_cmd_b & 0xffff)); @@ -3593,7 +3599,7 @@ static void lan78xx_features_check(struct sk_buff *skb, netdev_features_t *features) { if (skb->len + TX_OVERHEAD > MAX_SINGLE_PACKET_SIZE) - *features &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, features);

vlan_features_check(skb, features); vxlan_features_check(skb, features); diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c index e4fa71c..ce74862 100644 --- a/drivers/net/usb/r8152.c +++ b/drivers/net/usb/r8152.c @@ -2092,11 +2092,13 @@ static void r8152_csum_workaround(struct r8152 *tp, struct sk_buff *skb, struct sk_buff_head *list) { if (skb_shinfo(skb)->gso_size) { - netdev_features_t features = tp->netdev->features; struct sk_buff *segs, *seg, *next; struct sk_buff_head seg_list; + netdev_features_t features;

- features &= ~(NETIF_F_SG | NETIF_F_IPV6_CSUM | NETIF_F_TSO6); + netdev_feature_copy(&features, tp->netdev->features); + netdev_feature_clear_bits(NETIF_F_SG | NETIF_F_IPV6_CSUM | + NETIF_F_TSO6, &features); segs = skb_gso_segment(skb, features); if (IS_ERR(segs) || !segs) goto drop; @@ -2333,7 +2335,7 @@ static u8 r8152_rx_csum(struct r8152 *tp, struct rx_desc *rx_desc) u8 checksum = CHECKSUM_NONE; u32 opts2, opts3;

- if (!(tp->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, tp->netdev->features)) goto return_result;

opts2 = le32_to_cpu(rx_desc->opts2); @@ -2749,9 +2751,10 @@ static void rtl8152_features_check(struct sk_buff *skb, struct net_device *dev, int offset = skb_transport_offset(skb);

if ((mss || skb->ip_summed == CHECKSUM_PARTIAL) && offset > max_offset) - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); else if ((skb->len + sizeof(struct tx_desc)) > agg_buf_sz) - *features &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, features); }

static netdev_tx_t rtl8152_start_xmit(struct sk_buff *skb, @@ -3230,18 +3233,21 @@ static void rtl_rx_vlan_en(struct r8152 *tp, bool enable) static int rtl8152_set_features(struct net_device *dev, netdev_features_t features) { - netdev_features_t changed = features ^ dev->features; struct r8152 *tp = netdev_priv(dev); + netdev_features_t changed; int ret;

ret = usb_autopm_get_interface(tp->intf); if (ret < 0) goto out;

+ netdev_feature_xor(&changed, dev->features, features); + mutex_lock(&tp->control);

- if (changed & NETIF_F_HW_VLAN_CTAG_RX) { - if (features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, changed)) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features)) rtl_rx_vlan_en(tp, true); else rtl_rx_vlan_en(tp, false); @@ -5388,7 +5394,8 @@ static void r8152b_exit_oob(struct r8152 *tp) ocp_write_dword(tp, MCU_TYPE_USB, USB_TX_DMA, TEST_MODE_DISABLE | TX_SIZE_ADJUST1);

- rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX); + rtl_rx_vlan_en(tp, netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + tp->netdev->features));

ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8152_RMS);

@@ -5833,7 +5840,8 @@ static void r8153_first_init(struct r8152 *tp)

wait_oob_link_list_ready(tp);

- rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX); + rtl_rx_vlan_en(tp, netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + tp->netdev->features));

rtl8153_change_mtu(tp);

@@ -6334,7 +6342,8 @@ static void rtl8153c_up(struct r8152 *tp)

wait_oob_link_list_ready(tp);

- rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX); + rtl_rx_vlan_en(tp, netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + tp->netdev->features));

rtl8153c_change_mtu(tp);

@@ -6439,7 +6448,8 @@ static void rtl8156_up(struct r8152 *tp) ocp_data &= ~MCU_BORW_EN; ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);

- rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX); + rtl_rx_vlan_en(tp, netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + tp->netdev->features));

rtl8156_change_mtu(tp);

@@ -9548,21 +9558,27 @@ static int rtl8152_probe(struct usb_interface *intf, netdev->netdev_ops = &rtl8152_netdev_ops; netdev->watchdog_timeo = RTL8152_TX_TIMEOUT;

- netdev->features |= NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG | - NETIF_F_TSO | NETIF_F_FRAGLIST | NETIF_F_IPV6_CSUM | - NETIF_F_TSO6 | NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX; - netdev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG | - NETIF_F_TSO | NETIF_F_FRAGLIST | - NETIF_F_IPV6_CSUM | NETIF_F_TSO6 | - NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_TX; - netdev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | + netdev_feature_set_bits(NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG | + NETIF_F_TSO | NETIF_F_FRAGLIST | + NETIF_F_IPV6_CSUM | NETIF_F_TSO6 | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX, &netdev->features); + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bits(NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG | + NETIF_F_TSO | NETIF_F_FRAGLIST | + NETIF_F_IPV6_CSUM | NETIF_F_TSO6 | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX, &netdev->hw_features); + netdev_feature_zero(&netdev->vlan_features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | - NETIF_F_IPV6_CSUM | NETIF_F_TSO6; + NETIF_F_IPV6_CSUM | NETIF_F_TSO6, + &netdev->vlan_features);

if (tp->version == RTL_VER_01) { - netdev->features &= ~NETIF_F_RXCSUM; - netdev->hw_features &= ~NETIF_F_RXCSUM; + netdev_feature_clear_bit(NETIF_F_RXCSUM_BIT, &netdev->features); + netdev_feature_clear_bit(NETIF_F_RXCSUM_BIT, + &netdev->hw_features); }

if (le16_to_cpu(udev->descriptor.idVendor) == VENDOR_ID_LENOVO) { diff --git a/drivers/net/usb/smsc75xx.c b/drivers/net/usb/smsc75xx.c index 76f7af1..87ad300 100644 --- a/drivers/net/usb/smsc75xx.c +++ b/drivers/net/usb/smsc75xx.c @@ -942,7 +942,7 @@ static int smsc75xx_set_features(struct net_device *netdev,

spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);

- if (features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) pdata->rfe_ctl |= RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM; else pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM); @@ -1472,13 +1472,15 @@ static int smsc75xx_bind(struct usbnet *dev, struct usb_interface *intf) INIT_WORK(&pdata->set_multicast, smsc75xx_deferred_multicast_write);

if (DEFAULT_TX_CSUM_ENABLE) - dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM, + &dev->net->features);

if (DEFAULT_RX_CSUM_ENABLE) - dev->net->features |= NETIF_F_RXCSUM; + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->net->features);

- dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM, + &dev->net->hw_features);

ret = smsc75xx_wait_ready(dev, 0); if (ret < 0) { @@ -2167,7 +2169,7 @@ static int smsc75xx_resume(struct usb_interface *intf) static void smsc75xx_rx_csum_offload(struct usbnet *dev, struct sk_buff *skb, u32 rx_cmd_a, u32 rx_cmd_b) { - if (!(dev->net->features & NETIF_F_RXCSUM) || + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, dev->net->features) || unlikely(rx_cmd_a & RX_CMD_A_LCSM)) { skb->ip_summed = CHECKSUM_NONE; } else { diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c index 7d95397..d6c5293 100644 --- a/drivers/net/usb/smsc95xx.c +++ b/drivers/net/usb/smsc95xx.c @@ -615,12 +615,12 @@ static int smsc95xx_set_features(struct net_device *netdev, if (ret < 0) return ret;

- if (features & NETIF_F_IP_CSUM) + if (netdev_feature_test_bit(NETIF_F_IP_CSUM_BIT, features)) read_buf |= Tx_COE_EN_; else read_buf &= ~Tx_COE_EN_;

- if (features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) read_buf |= Rx_COE_EN_; else read_buf &= ~Rx_COE_EN_; @@ -1080,11 +1080,13 @@ static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf) * for ipv4 packets. */ if (DEFAULT_TX_CSUM_ENABLE) - dev->net->features |= NETIF_F_IP_CSUM; + netdev_feature_set_bit(NETIF_F_IP_CSUM_BIT, + &dev->net->features); if (DEFAULT_RX_CSUM_ENABLE) - dev->net->features |= NETIF_F_RXCSUM; + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->net->features);

- dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_RXCSUM, + &dev->net->hw_features); set_bit(EVENT_NO_IP_ALIGN, &dev->flags);

smsc95xx_init_mac_address(dev); @@ -1824,7 +1826,8 @@ static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)

/* last frame in this batch */ if (skb->len == size) { - if (dev->net->features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + dev->net->features)) smsc95xx_rx_csum_offload(skb); skb_trim(skb, skb->len - 4); /* remove fcs */ skb->truesize = size + sizeof(struct sk_buff); @@ -1842,7 +1845,8 @@ static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb) ax_skb->data = packet; skb_set_tail_pointer(ax_skb, size);

- if (dev->net->features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + dev->net->features)) smsc95xx_rx_csum_offload(ax_skb); skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */ ax_skb->truesize = size + sizeof(struct sk_buff);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ethernet/realtek/8139cp.c | 29 +++++++------- drivers/net/ethernet/realtek/8139too.c | 28 +++++++------ drivers/net/ethernet/realtek/r8169_main.c | 65 ++++++++++++++++++------------- 3 files changed, 72 insertions(+), 50 deletions(-)

diff --git a/drivers/net/ethernet/realtek/8139cp.c b/drivers/net/ethernet/realtek/8139cp.c index dc06c3e..626b3f2 100644 --- a/drivers/net/ethernet/realtek/8139cp.c +++ b/drivers/net/ethernet/realtek/8139cp.c @@ -1461,17 +1461,18 @@ static int cp_set_features(struct net_device *dev, netdev_features_t features) struct cp_private *cp = netdev_priv(dev); unsigned long flags;

- if (!((dev->features ^ features) & NETIF_F_RXCSUM)) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, dev->features) != + netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) return 0;

spin_lock_irqsave(&cp->lock, flags);

- if (features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) cp->cpcmd |= RxChkSum; else cp->cpcmd &= ~RxChkSum;

- if (features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features)) cp->cpcmd |= RxVlanOn; else cp->cpcmd &= ~RxVlanOn; @@ -1857,7 +1858,7 @@ static void cp_features_check(struct sk_buff *skb, struct net_device *dev, netdev_features_t *features) { if (skb_shinfo(skb)->gso_size > MSSMask) - *features &= ~NETIF_F_TSO; + netdev_feature_clear_bit(NETIF_F_TSO_BIT, features);

vlan_features_check(skb, features); } @@ -1967,8 +1968,8 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent) cp->cpcmd = (pci_using_dac ? PCIDAC : 0) | PCIMulRW | RxChkSum | CpRxOn | CpTxOn;

- dev->features |= NETIF_F_RXCSUM; - dev->hw_features |= NETIF_F_RXCSUM; + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &dev->hw_features);

regs = ioremap(pciaddr, CP_REGS_SIZE); if (!regs) { @@ -1993,16 +1994,18 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent) dev->ethtool_ops = &cp_ethtool_ops; dev->watchdog_timeo = TX_TIMEOUT;

- dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | - NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, &dev->features);

if (pci_using_dac) - dev->features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &dev->features);

- dev->hw_features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | - NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX; - dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | - NETIF_F_HIGHDMA; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, &dev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | + NETIF_F_HIGHDMA, &dev->vlan_features);

/* MTU range: 60 - 4096 */ dev->min_mtu = CP_MIN_MTU; diff --git a/drivers/net/ethernet/realtek/8139too.c b/drivers/net/ethernet/realtek/8139too.c index 2e6923cc..59b5a95 100644 --- a/drivers/net/ethernet/realtek/8139too.c +++ b/drivers/net/ethernet/realtek/8139too.c @@ -900,18 +900,21 @@ static struct net_device *rtl8139_init_board(struct pci_dev *pdev) static int rtl8139_set_features(struct net_device *dev, netdev_features_t features) { struct rtl8139_private *tp = netdev_priv(dev); + netdev_features_t changed; unsigned long flags; - netdev_features_t changed = features ^ dev->features; void __iomem *ioaddr = tp->mmio_addr;

- if (!(changed & (NETIF_F_RXALL))) + netdev_feature_xor(&changed, features, dev->features); + + if (!netdev_feature_test_bit(NETIF_F_RXALL_BIT, changed)) return 0;

spin_lock_irqsave(&tp->lock, flags);

- if (changed & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, changed)) { int rx_mode = tp->rx_config; - if (features & NETIF_F_RXALL) + + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, features)) rx_mode |= (AcceptErr | AcceptRunt); else rx_mode &= ~(AcceptErr | AcceptRunt); @@ -1007,11 +1010,12 @@ static int rtl8139_init_one(struct pci_dev *pdev, * through the use of skb_copy_and_csum_dev we enable these * features */ - dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA; - dev->vlan_features = dev->features; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA, + &dev->features); + netdev_feature_copy(&dev->vlan_features, dev->features);

- dev->hw_features |= NETIF_F_RXALL; - dev->hw_features |= NETIF_F_RXFCS; + netdev_feature_set_bit(NETIF_F_RXALL_BIT, &dev->hw_features); + netdev_feature_set_bit(NETIF_F_RXFCS_BIT, &dev->hw_features);

/* MTU range: 68 - 1770 */ dev->min_mtu = ETH_MIN_MTU; @@ -1968,7 +1972,8 @@ static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp, /* read size+status of next frame from DMA ring buffer */ rx_status = le32_to_cpu (*(__le32 *) (rx_ring + ring_offset)); rx_size = rx_status >> 16; - if (likely(!(dev->features & NETIF_F_RXFCS))) + if (likely(!netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + dev->features))) pkt_size = rx_size - 4; else pkt_size = rx_size; @@ -2009,7 +2014,8 @@ static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp, if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) || (rx_size < 8) || (!(rx_status & RxStatusOK)))) { - if ((dev->features & NETIF_F_RXALL) && + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, + dev->features) && (rx_size <= (MAX_ETH_FRAME_SIZE + 4)) && (rx_size >= 8) && (!(rx_status & RxStatusOK))) { @@ -2580,7 +2586,7 @@ static void __set_rx_mode (struct net_device *dev) } }

- if (dev->features & NETIF_F_RXALL) + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, dev->features)) rx_mode |= (AcceptErr | AcceptRunt);

/* We can safely update without stopping the chip. */ diff --git a/drivers/net/ethernet/realtek/r8169_main.c b/drivers/net/ethernet/realtek/r8169_main.c index 584b3bb..e1bdc34 100644 --- a/drivers/net/ethernet/realtek/r8169_main.c +++ b/drivers/net/ethernet/realtek/r8169_main.c @@ -1471,11 +1471,12 @@ static void rtl8169_fix_features(struct net_device *dev, struct rtl8169_private *tp = netdev_priv(dev);

if (dev->mtu > TD_MSS_MAX) - *features &= ~NETIF_F_ALL_TSO; + netdev_feature_clear_bits(NETIF_F_ALL_TSO, features);

if (dev->mtu > ETH_DATA_LEN && tp->mac_version > RTL_GIGA_MAC_VER_06) - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_ALL_TSO); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_ALL_TSO, + features); }

static void rtl_set_rx_config_features(struct rtl8169_private *tp, @@ -1483,13 +1484,14 @@ static void rtl_set_rx_config_features(struct rtl8169_private *tp, { u32 rx_config = RTL_R32(tp, RxConfig);

- if (features & NETIF_F_RXALL) + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, features)) rx_config |= RX_CONFIG_ACCEPT_ERR_MASK; else rx_config &= ~RX_CONFIG_ACCEPT_ERR_MASK;

if (rtl_is_8125(tp)) { - if (features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features)) rx_config |= RX_VLAN_8125; else rx_config &= ~RX_VLAN_8125; @@ -1505,13 +1507,14 @@ static int rtl8169_set_features(struct net_device *dev,

rtl_set_rx_config_features(tp, features);

- if (features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) tp->cp_cmd |= RxChkSum; else tp->cp_cmd &= ~RxChkSum;

if (!rtl_is_8125(tp)) { - if (features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features)) tp->cp_cmd |= RxVlan; else tp->cp_cmd &= ~RxVlan; @@ -4336,15 +4339,15 @@ static void rtl8168evl_fix_tso(struct sk_buff *skb, netdev_features_t *features) /* IPv4 header has options field */ if (vlan_get_protocol(skb) == htons(ETH_P_IP) && ip_hdrlen(skb) > sizeof(struct iphdr)) - *features &= ~NETIF_F_ALL_TSO; + netdev_feature_clear_bits(NETIF_F_ALL_TSO, features);

/* IPv4 TCP header has options field */ else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4 && tcp_hdrlen(skb) > sizeof(struct tcphdr)) - *features &= ~NETIF_F_ALL_TSO; + netdev_feature_clear_bits(NETIF_F_ALL_TSO, features);

else if (rtl_last_frag_len(skb) <= 6) - *features &= ~NETIF_F_ALL_TSO; + netdev_feature_clear_bits(NETIF_F_ALL_TSO, features); }

static void rtl8169_features_check(struct sk_buff *skb, struct net_device *dev, @@ -4359,18 +4362,18 @@ static void rtl8169_features_check(struct sk_buff *skb, struct net_device *dev,

if (transport_offset > GTTCPHO_MAX && rtl_chip_supports_csum_v2(tp)) - *features &= ~NETIF_F_ALL_TSO; + netdev_feature_clear_bits(NETIF_F_ALL_TSO, features); } else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* work around hw bug on some chip versions */ if (skb->len < ETH_ZLEN) - *features &= ~NETIF_F_CSUM_MASK; + netdev_feature_clear_bits(NETIF_F_CSUM_MASK, features);

if (rtl_quirk_packet_padto(tp, skb)) - *features &= ~NETIF_F_CSUM_MASK; + netdev_feature_clear_bits(NETIF_F_CSUM_MASK, features);

if (transport_offset > TCPHO_MAX && rtl_chip_supports_csum_v2(tp)) - *features &= ~NETIF_F_CSUM_MASK; + netdev_feature_clear_bits(NETIF_F_CSUM_MASK, features); }

vlan_features_check(skb, features); @@ -4496,14 +4499,16 @@ static int rtl_rx(struct net_device *dev, struct rtl8169_private *tp, int budget if (status & RxCRC) dev->stats.rx_crc_errors++;

- if (!(dev->features & NETIF_F_RXALL)) + if (!netdev_feature_test_bit(NETIF_F_RXALL_BIT, + dev->features)) goto release_descriptor; else if (status & RxRWT || !(status & (RxRUNT | RxCRC))) goto release_descriptor; }

pkt_size = status & GENMASK(13, 0); - if (likely(!(dev->features & NETIF_F_RXFCS))) + if (likely(!netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + dev->features))) pkt_size -= ETH_FCS_LEN;

/* The driver does not support incoming fragmented frames. @@ -5323,7 +5328,7 @@ static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)

if (sizeof(dma_addr_t) > 4 && tp->mac_version >= RTL_GIGA_MAC_VER_18 && !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) - dev->features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &dev->features);

rtl_init_rxcfg(tp);

@@ -5347,9 +5352,13 @@ static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)

netif_napi_add(dev, &tp->napi, rtl8169_poll, NAPI_POLL_WEIGHT);

- dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM | - NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX; - dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO; + netdev_feature_zero(&dev->hw_features); + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_RXCSUM | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, &dev->hw_features); + netdev_feature_zero(&dev->vlan_features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO, + &dev->vlan_features); dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;

/* @@ -5358,12 +5367,14 @@ static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) */ if (tp->mac_version == RTL_GIGA_MAC_VER_05) /* Disallow toggling */ - dev->hw_features &= ~NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &dev->hw_features);

if (rtl_chip_supports_csum_v2(tp)) - dev->hw_features |= NETIF_F_IPV6_CSUM; + netdev_feature_set_bit(NETIF_F_IPV6_CSUM_BIT, + &dev->hw_features);

- dev->features |= dev->hw_features; + netdev_feature_or(&dev->features, dev->features, dev->hw_features);

/* There has been a number of reports that using SG/TSO results in * tx timeouts. However for a lot of people SG/TSO works fine. @@ -5371,17 +5382,19 @@ static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) * enable them. Use at own risk! */ if (rtl_chip_supports_csum_v2(tp)) { - dev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6, + &dev->hw_features); dev->gso_max_size = RTL_GSO_MAX_SIZE_V2; dev->gso_max_segs = RTL_GSO_MAX_SEGS_V2; } else { - dev->hw_features |= NETIF_F_SG | NETIF_F_TSO; + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_TSO, + &dev->hw_features); dev->gso_max_size = RTL_GSO_MAX_SIZE_V1; dev->gso_max_segs = RTL_GSO_MAX_SEGS_V1; }

- dev->hw_features |= NETIF_F_RXALL; - dev->hw_features |= NETIF_F_RXFCS; + netdev_feature_set_bit(NETIF_F_RXALL_BIT, &dev->hw_features); + netdev_feature_set_bit(NETIF_F_RXFCS_BIT, &dev->hw_features);

/* configure chip for default features */ rtl8169_set_features(dev, dev->features);

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ethernet/intel/e100.c | 26 +-- drivers/net/ethernet/intel/e1000/e1000_main.c | 76 +++++---- drivers/net/ethernet/intel/e1000e/netdev.c | 123 ++++++++------ drivers/net/ethernet/intel/fm10k/fm10k_main.c | 9 +- drivers/net/ethernet/intel/fm10k/fm10k_netdev.c | 57 ++++--- drivers/net/ethernet/intel/fm10k/fm10k_pci.c | 11 +- drivers/net/ethernet/intel/i40e/i40e_main.c | 109 +++++++----- drivers/net/ethernet/intel/i40e/i40e_txrx.c | 9 +- drivers/net/ethernet/intel/iavf/iavf_main.c | 134 +++++++++------ drivers/net/ethernet/intel/iavf/iavf_txrx.c | 12 +- drivers/net/ethernet/intel/ice/ice_main.c | 158 +++++++++++------- drivers/net/ethernet/intel/ice/ice_txrx_lib.c | 9 +- drivers/net/ethernet/intel/igb/igb_ethtool.c | 2 +- drivers/net/ethernet/intel/igb/igb_main.c | 129 ++++++++------ drivers/net/ethernet/intel/igbvf/netdev.c | 71 ++++---- drivers/net/ethernet/intel/igc/igc_ethtool.c | 3 +- drivers/net/ethernet/intel/igc/igc_main.c | 101 ++++++----- drivers/net/ethernet/intel/ixgb/ixgb_main.c | 43 +++-- drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c | 3 +- drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c | 2 +- drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c | 7 +- drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c | 3 +- drivers/net/ethernet/intel/ixgbe/ixgbe_main.c | 194 +++++++++++++--------- drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c | 6 +- drivers/net/ethernet/intel/ixgbevf/ipsec.c | 9 +- drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c | 90 ++++++---- 26 files changed, 845 insertions(+), 551 deletions(-)

diff --git a/drivers/net/ethernet/intel/e100.c b/drivers/net/ethernet/intel/e100.c index 373eb02..abec49f 100644 --- a/drivers/net/ethernet/intel/e100.c +++ b/drivers/net/ethernet/intel/e100.c @@ -1114,7 +1114,8 @@ static int e100_configure(struct nic *nic, struct cb *cb, struct sk_buff *skb) config->promiscuous_mode = 0x1; /* 1=on, 0=off */ }

- if (unlikely(netdev->features & NETIF_F_RXFCS)) + if (unlikely(netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + netdev->features))) config->rx_crc_transfer = 0x1; /* 1=save, 0=discard */

if (nic->flags & multicast_all) @@ -1141,7 +1142,7 @@ static int e100_configure(struct nic *nic, struct cb *cb, struct sk_buff *skb) } }

- if (netdev->features & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, netdev->features)) { config->rx_save_overruns = 0x1; /* 1=save, 0=discard */ config->rx_save_bad_frames = 0x1; /* 1=save, 0=discard */ config->rx_discard_short_frames = 0x0; /* 1=discard, 0=save */ @@ -1990,7 +1991,8 @@ static int e100_rx_indicate(struct nic *nic, struct rx *rx, }

/* Get actual data size */ - if (unlikely(dev->features & NETIF_F_RXFCS)) + if (unlikely(netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + dev->features))) fcs_pad = 4; actual_size = le16_to_cpu(rfd->actual_size) & 0x3FFF; if (unlikely(actual_size > RFD_BUF_LEN - sizeof(struct rfd))) @@ -2021,7 +2023,8 @@ static int e100_rx_indicate(struct nic *nic, struct rx *rx, /* If we are receiving all frames, then don't bother * checking for errors. */ - if (unlikely(dev->features & NETIF_F_RXALL)) { + if (unlikely(netdev_feature_test_bit(NETIF_F_RXALL_BIT, + dev->features))) { if (actual_size > ETH_DATA_LEN + VLAN_ETH_HLEN + fcs_pad) /* Received oversized frame, but keep it. */ nic->rx_over_length_errors++; @@ -2792,12 +2795,14 @@ static int e100_set_features(struct net_device *netdev, netdev_features_t features) { struct nic *nic = netdev_priv(netdev); - netdev_features_t changed = features ^ netdev->features; + netdev_features_t changed;

- if (!(changed & (NETIF_F_RXFCS | NETIF_F_RXALL))) + netdev_feature_xor(&changed, features, netdev->features); + + if (!netdev_feature_test_bits(NETIF_F_RXFCS | NETIF_F_RXALL, changed)) return 0;

- netdev->features = features; + netdev_feature_copy(&netdev->features, features); e100_exec_cb(nic, NULL, e100_configure); return 1; } @@ -2826,9 +2831,9 @@ static int e100_probe(struct pci_dev *pdev, const struct pci_device_id *ent) if (!(netdev = alloc_etherdev(sizeof(struct nic)))) return -ENOMEM;

- netdev->hw_features |= NETIF_F_RXFCS; + netdev_feature_set_bit(NETIF_F_RXFCS_BIT, &netdev->hw_features); netdev->priv_flags |= IFF_SUPP_NOFCS; - netdev->hw_features |= NETIF_F_RXALL; + netdev_feature_set_bit(NETIF_F_RXALL_BIT, &netdev->hw_features);

netdev->netdev_ops = &e100_netdev_ops; netdev->ethtool_ops = &e100_ethtool_ops; @@ -2885,7 +2890,8 @@ static int e100_probe(struct pci_dev *pdev, const struct pci_device_id *ent)

/* D100 MAC doesn't allow rx of vlan packets with normal MTU */ if (nic->mac < mac_82558_D101_A4) - netdev->features |= NETIF_F_VLAN_CHALLENGED; + netdev_feature_set_bit(NETIF_F_VLAN_CHALLENGED_BIT, + &netdev->features);

/* locks must be initialized before calling hw_reset */ spin_lock_init(&nic->cb_lock); diff --git a/drivers/net/ethernet/intel/e1000/e1000_main.c b/drivers/net/ethernet/intel/e1000/e1000_main.c index e333ca1..f17057a 100644 --- a/drivers/net/ethernet/intel/e1000/e1000_main.c +++ b/drivers/net/ethernet/intel/e1000/e1000_main.c @@ -793,26 +793,30 @@ static void e1000_fix_features(struct net_device *netdev, /* Since there is no support for separate Rx/Tx vlan accel * enable/disable make sure Tx flag is always in same state as Rx. */ - if (*features & NETIF_F_HW_VLAN_CTAG_RX) - *features |= NETIF_F_HW_VLAN_CTAG_TX; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features); else - *features &= ~NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features); }

static int e1000_set_features(struct net_device *netdev, netdev_features_t features) { struct e1000_adapter *adapter = netdev_priv(netdev); - netdev_features_t changed = features ^ netdev->features; + netdev_features_t changed;

- if (changed & NETIF_F_HW_VLAN_CTAG_RX) + netdev_feature_xor(&changed, features, netdev->features); + + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, changed)) e1000_vlan_mode(netdev, features);

- if (!(changed & (NETIF_F_RXCSUM | NETIF_F_RXALL))) + if (!netdev_feature_test_bits(NETIF_F_RXCSUM | NETIF_F_RXALL, changed)) return 0;

- netdev->features = features; - adapter->rx_csum = !!(features & NETIF_F_RXCSUM); + netdev_feature_copy(&netdev->features, features); + adapter->rx_csum = netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + features);

if (netif_running(netdev)) e1000_reinit_locked(adapter); @@ -1033,32 +1037,40 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent) }

if (hw->mac_type >= e1000_82543) { - netdev->hw_features = NETIF_F_SG | - NETIF_F_HW_CSUM | - NETIF_F_HW_VLAN_CTAG_RX; - netdev->features = NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_HW_CSUM | + NETIF_F_HW_VLAN_CTAG_RX, + &netdev->hw_features); + netdev_feature_zero(&netdev->features); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_FILTER, + &netdev->features); }

if ((hw->mac_type >= e1000_82544) && (hw->mac_type != e1000_82547)) - netdev->hw_features |= NETIF_F_TSO; + netdev_feature_set_bit(NETIF_F_TSO_BIT, &netdev->hw_features);

netdev->priv_flags |= IFF_SUPP_NOFCS;

- netdev->features |= netdev->hw_features; - netdev->hw_features |= (NETIF_F_RXCSUM | + netdev_feature_or(&netdev->features, netdev->features, + netdev->hw_features); + netdev_feature_set_bits(NETIF_F_RXCSUM | NETIF_F_RXALL | - NETIF_F_RXFCS); + NETIF_F_RXFCS, + &netdev->hw_features);

if (pci_using_dac) { - netdev->features |= NETIF_F_HIGHDMA; - netdev->vlan_features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, + &netdev->vlan_features); }

- netdev->vlan_features |= (NETIF_F_TSO | - NETIF_F_HW_CSUM | - NETIF_F_SG); + netdev_feature_set_bits(NETIF_F_TSO | + NETIF_F_TSO | + NETIF_F_SG, + &netdev->vlan_features);

/* Do not set IFF_UNICAST_FLT for VMWare's 82545EM */ if (hw->device_id != E1000_DEV_ID_82545EM_COPPER || @@ -1822,7 +1834,8 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter) }

/* This is useful for sniffing bad packets. */ - if (adapter->netdev->features & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, + adapter->netdev->features)) { /* UPE and MPE will be handled by normal PROMISC logic * in e1000e_set_rx_mode */ @@ -4176,7 +4189,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, rx_desc->errors, length, mapped)) { length--; - } else if (netdev->features & NETIF_F_RXALL) { + } else if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features)) { goto process_skb; } else { /* an error means any chain goes out the window @@ -4227,7 +4241,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, if (length <= copybreak) { u8 *vaddr;

- if (likely(!(netdev->features & NETIF_F_RXFCS))) + if (likely(!netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + netdev->features))) length -= 4; skb = e1000_alloc_rx_skb(adapter, length); @@ -4273,7 +4288,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, le16_to_cpu(rx_desc->csum), skb);

total_rx_bytes += (skb->len - 4); /* don't count FCS */ - if (likely(!(netdev->features & NETIF_F_RXFCS))) + if (likely(!netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + netdev->features))) pskb_trim(skb, skb->len - 4); total_rx_packets++;

@@ -4428,7 +4444,8 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, rx_desc->errors, length, data)) { length--; - } else if (netdev->features & NETIF_F_RXALL) { + } else if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features)) { goto process_skb; } else { dev_kfree_skb(skb); @@ -4440,7 +4457,8 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, total_rx_bytes += (length - 4); /* don't count FCS */ total_rx_packets++;

- if (likely(!(netdev->features & NETIF_F_RXFCS))) + if (likely(!netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + netdev->features))) /* adjust length to remove Ethernet CRC, this must be * done after the TBI_ACCEPT workaround above */ @@ -4888,7 +4906,7 @@ static void __e1000_vlan_mode(struct e1000_adapter *adapter, u32 ctrl;

ctrl = er32(CTRL); - if (features & NETIF_F_HW_VLAN_CTAG_RX) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features)) { /* enable VLAN tag insert/strip */ ctrl |= E1000_CTRL_VME; } else { diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c index 5dd183e..a299f27 100644 --- a/drivers/net/ethernet/intel/e1000e/netdev.c +++ b/drivers/net/ethernet/intel/e1000e/netdev.c @@ -576,7 +576,8 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err, skb_checksum_none_assert(skb);

/* Rx checksum disabled */ - if (!(adapter->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + adapter->netdev->features)) return;

/* Ignore Checksum bit is set */ @@ -894,7 +895,7 @@ static void e1000_alloc_jumbo_rx_buffers(struct e1000_ring *rx_ring, static inline void e1000_rx_hash(struct net_device *netdev, __le32 rss, struct sk_buff *skb) { - if (netdev->features & NETIF_F_RXHASH) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features)) skb_set_hash(skb, le32_to_cpu(rss), PKT_HASH_TYPE_L3); }

@@ -976,7 +977,8 @@ static bool e1000_clean_rx_irq(struct e1000_ring *rx_ring, int *work_done, }

if (unlikely((staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) && - !(netdev->features & NETIF_F_RXALL))) { + !netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features))) { /* recycle */ buffer_info->skb = skb; goto next_desc; @@ -988,7 +990,8 @@ static bool e1000_clean_rx_irq(struct e1000_ring *rx_ring, int *work_done, * but keep the FCS bytes out of the total_rx_bytes * counter */ - if (netdev->features & NETIF_F_RXFCS) + if (netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + netdev->features)) total_rx_bytes -= 4; else length -= 4; @@ -1362,7 +1365,8 @@ static bool e1000_clean_rx_irq_ps(struct e1000_ring *rx_ring, int *work_done, }

if (unlikely((staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) && - !(netdev->features & NETIF_F_RXALL))) { + !netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features))) { dev_kfree_skb_irq(skb); goto next_desc; } @@ -1413,7 +1417,8 @@ static bool e1000_clean_rx_irq_ps(struct e1000_ring *rx_ring, int *work_done,

/* remove the CRC */ if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) { - if (!(netdev->features & NETIF_F_RXFCS)) + if (!netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + netdev->features)) l1 -= 4; }

@@ -1442,7 +1447,8 @@ static bool e1000_clean_rx_irq_ps(struct e1000_ring *rx_ring, int *work_done, * this whole operation can get a little cpu intensive */ if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) { - if (!(netdev->features & NETIF_F_RXFCS)) + if (!netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + netdev->features)) pskb_trim(skb, skb->len - 4); }

@@ -1557,7 +1563,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done, /* errors is only valid for DD + EOP descriptors */ if (unlikely((staterr & E1000_RXD_STAT_EOP) && ((staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) && - !(netdev->features & NETIF_F_RXALL)))) { + !netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features)))) { /* recycle both page and skb */ buffer_info->skb = skb; /* an error means any chain goes out the window too */ @@ -3165,7 +3172,8 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter) }

/* This is useful for sniffing bad packets. */ - if (adapter->netdev->features & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, + adapter->netdev->features)) { /* UPE and MPE will be handled by normal PROMISC logic * in e1000e_set_rx_mode */ @@ -3270,7 +3278,8 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)

/* Enable Receive Checksum Offload for TCP and UDP */ rxcsum = er32(RXCSUM); - if (adapter->netdev->features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + adapter->netdev->features)) rxcsum |= E1000_RXCSUM_TUOFL; else rxcsum &= ~E1000_RXCSUM_TUOFL; @@ -3451,7 +3460,8 @@ static void e1000e_set_rx_mode(struct net_device *netdev)

ew32(RCTL, rctl);

- if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + netdev->features)) e1000e_vlan_strip_enable(adapter); else e1000e_vlan_strip_disable(adapter); @@ -3765,7 +3775,8 @@ static void e1000_configure(struct e1000_adapter *adapter)

e1000_configure_tx(adapter);

- if (adapter->netdev->features & NETIF_F_RXHASH) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + adapter->netdev->features)) e1000e_setup_rss_hash(adapter); e1000_setup_rctl(adapter); e1000_configure_rx(adapter); @@ -5304,20 +5315,26 @@ static void e1000_watchdog_task(struct work_struct *work) case SPEED_10: case SPEED_100: e_info("10/100 speed: disabling TSO\n"); - netdev->features &= ~NETIF_F_TSO; - netdev->features &= ~NETIF_F_TSO6; + netdev_feature_clear_bit(NETIF_F_TSO_BIT, + &netdev->features); + netdev_feature_clear_bit(NETIF_F_TSO6_BIT, + &netdev->features); break; case SPEED_1000: - netdev->features |= NETIF_F_TSO; - netdev->features |= NETIF_F_TSO6; + netdev_feature_clear_bit(NETIF_F_TSO_BIT, + &netdev->features); + netdev_feature_clear_bit(NETIF_F_TSO6_BIT, + &netdev->features); break; default: /* oops */ break; } if (hw->mac.type == e1000_pch_spt) { - netdev->features &= ~NETIF_F_TSO; - netdev->features &= ~NETIF_F_TSO6; + netdev_feature_clear_bit(NETIF_F_TSO_BIT, + &netdev->features); + netdev_feature_clear_bit(NETIF_F_TSO6_BIT, + &netdev->features); } }

@@ -7295,33 +7312,38 @@ static void e1000_fix_features(struct net_device *netdev,

/* Jumbo frame workaround on 82579 and newer requires CRC be stripped */ if ((hw->mac.type >= e1000_pch2lan) && (netdev->mtu > ETH_DATA_LEN)) - *features &= ~NETIF_F_RXFCS; + netdev_feature_clear_bit(NETIF_F_RXFCS_BIT, features);

/* Since there is no support for separate Rx/Tx vlan accel * enable/disable make sure Tx flag is always in same state as Rx. */ - if (*features & NETIF_F_HW_VLAN_CTAG_RX) - *features |= NETIF_F_HW_VLAN_CTAG_TX; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features); else - *features &= ~NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features); }

static int e1000_set_features(struct net_device *netdev, netdev_features_t features) { struct e1000_adapter *adapter = netdev_priv(netdev); - netdev_features_t changed = features ^ netdev->features; + netdev_features_t changed;

- if (changed & (NETIF_F_TSO | NETIF_F_TSO6)) + netdev_feature_xor(&changed, features, netdev->features); + + if (netdev_feature_test_bits(NETIF_F_TSO | NETIF_F_TSO6, changed)) adapter->flags |= FLAG_TSO_FORCE;

- if (!(changed & (NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_RXCSUM | NETIF_F_RXHASH | NETIF_F_RXFCS | - NETIF_F_RXALL))) + if (!netdev_feature_test_bits(NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_RXCSUM | + NETIF_F_RXHASH | NETIF_F_RXFCS | + NETIF_F_RXALL | NETIF_F_HW_VLAN_CTAG_RX, + changed)) return 0;

- if (changed & NETIF_F_RXFCS) { - if (features & NETIF_F_RXFCS) { + if (netdev_feature_test_bit(NETIF_F_RXFCS_BIT, changed)) { + if (netdev_feature_test_bit(NETIF_F_RXFCS_BIT, features)) { adapter->flags2 &= ~FLAG2_CRC_STRIPPING; } else { /* We need to take it back to defaults, which might mean @@ -7334,7 +7356,7 @@ static int e1000_set_features(struct net_device *netdev, } }

- netdev->features = features; + netdev_feature_copy(&netdev->features, features);

if (netif_running(netdev)) e1000e_reinit_locked(adapter); @@ -7524,34 +7546,39 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent) "PHY reset is blocked due to SOL/IDER session.\n");

/* Set initial default active device features */ - netdev->features = (NETIF_F_SG | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_RXHASH | - NETIF_F_RXCSUM | - NETIF_F_HW_CSUM); + netdev_feature_zero(&netdev->features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_RXHASH | + NETIF_F_RXCSUM | + NETIF_F_HW_CSUM, + &netdev->features);

/* Set user-changeable features (subset of all device features) */ - netdev->hw_features = netdev->features; - netdev->hw_features |= NETIF_F_RXFCS; + netdev_feature_copy(&netdev->hw_features, netdev->features); + netdev_feature_set_bit(NETIF_F_RXFCS_BIT, &netdev->hw_features); netdev->priv_flags |= IFF_SUPP_NOFCS; - netdev->hw_features |= NETIF_F_RXALL; + netdev_feature_set_bit(NETIF_F_RXALL_BIT, &netdev->hw_features);

if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) - netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &netdev->features);

- netdev->vlan_features |= (NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_HW_CSUM); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_HW_CSUM, + &netdev->vlan_features);

netdev->priv_flags |= IFF_UNICAST_FLT;

if (pci_using_dac) { - netdev->features |= NETIF_F_HIGHDMA; - netdev->vlan_features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, + &netdev->vlan_features); }

/* MTU range: 68 - max_hw_frame_size */ diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_main.c b/drivers/net/ethernet/intel/fm10k/fm10k_main.c index 3362f26..ed2871d 100644 --- a/drivers/net/ethernet/intel/fm10k/fm10k_main.c +++ b/drivers/net/ethernet/intel/fm10k/fm10k_main.c @@ -352,7 +352,8 @@ static inline void fm10k_rx_checksum(struct fm10k_ring *ring, skb_checksum_none_assert(skb);

/* Rx checksum disabled via ethtool */ - if (!(ring->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + ring->netdev->features)) return;

/* TCP/UDP checksum error bit is set */ @@ -388,7 +389,8 @@ static inline void fm10k_rx_hash(struct fm10k_ring *ring, { u16 rss_type;

- if (!(ring->netdev->features & NETIF_F_RXHASH)) + if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) return;

rss_type = le16_to_cpu(rx_desc->w.pkt_info) & FM10K_RXD_RSSTYPE_MASK; @@ -772,7 +774,8 @@ static int fm10k_tso(struct fm10k_ring *tx_ring, return 1;

err_vxlan: - tx_ring->netdev->features &= ~NETIF_F_GSO_UDP_TUNNEL; + netdev_feature_clear_bit(NETIF_F_GSO_UDP_TUNNEL_BIT, + &tx_ring->netdev->features); if (net_ratelimit()) netdev_err(tx_ring->netdev, "TSO requested for unsupported tunnel, disabling offload\n"); diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c b/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c index a311bcd..e3747f3 100644 --- a/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c +++ b/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c @@ -1510,7 +1510,8 @@ static void fm10k_features_check(struct sk_buff *skb, struct net_device *dev, if (!skb->encapsulation || fm10k_tx_encap_offload(skb)) return;

- *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); }

static const struct net_device_ops fm10k_netdev_ops = { @@ -1556,50 +1557,56 @@ struct net_device *fm10k_alloc_netdev(const struct fm10k_info *info) interface->msg_enable = BIT(DEFAULT_DEBUG_LEVEL_SHIFT) - 1;

/* configure default features */ - dev->features |= NETIF_F_IP_CSUM | - NETIF_F_IPV6_CSUM | - NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_TSO_ECN | - NETIF_F_RXHASH | - NETIF_F_RXCSUM; + netdev_feature_set_bits(NETIF_F_IP_CSUM | + NETIF_F_IPV6_CSUM | + NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_TSO_ECN | + NETIF_F_RXHASH | + NETIF_F_RXCSUM, + &dev->features);

/* Only the PF can support VXLAN and NVGRE tunnel offloads */ if (info->mac == fm10k_mac_pf) { - dev->hw_enc_features = NETIF_F_IP_CSUM | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_TSO_ECN | - NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_IPV6_CSUM | - NETIF_F_SG; - - dev->features |= NETIF_F_GSO_UDP_TUNNEL; + netdev_feature_set_bits(NETIF_F_IP_CSUM | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_TSO_ECN | + NETIF_F_GSO_UDP_TUNNEL | + NETIF_F_IPV6_CSUM | + NETIF_F_SG, + &dev->hw_enc_features); + + netdev_feature_set_bit(NETIF_F_GSO_UDP_TUNNEL_BIT, + &dev->features);

dev->udp_tunnel_nic_info = &fm10k_udp_tunnels; }

/* all features defined to this point should be changeable */ - hw_features = dev->features; + netdev_feature_copy(&hw_features, dev->features);

/* allow user to enable L2 forwarding acceleration */ - hw_features |= NETIF_F_HW_L2FW_DOFFLOAD; + netdev_feature_set_bit(NETIF_F_HW_L2FW_DOFFLOAD_BIT, &hw_features);

/* configure VLAN features */ - dev->vlan_features |= dev->features; + netdev_feature_or(&dev->vlan_features, dev->vlan_features, + dev->features);

/* we want to leave these both on as we cannot disable VLAN tag * insertion or stripping on the hardware since it is contained * in the FTAG and not in the frame itself. */ - dev->features |= NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_FILTER, + &dev->features);

dev->priv_flags |= IFF_UNICAST_FLT;

- dev->hw_features |= hw_features; + netdev_feature_or(&dev->hw_features, dev->hw_features, + hw_features);

/* MTU range: 68 - 15342 */ dev->min_mtu = ETH_MIN_MTU; diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c index adfa276..48c1206 100644 --- a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c +++ b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c @@ -305,9 +305,11 @@ static int fm10k_handle_reset(struct fm10k_intfc *interface) }

if (hw->mac.vlan_override) - netdev->features &= ~NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &netdev->features); else - netdev->features |= NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &netdev->features); }

err = netif_running(netdev) ? fm10k_open(netdev) : 0; @@ -2010,8 +2012,9 @@ static int fm10k_sw_init(struct fm10k_intfc *interface,

/* update netdev with DMA restrictions */ if (dma_get_mask(&pdev->dev) > DMA_BIT_MASK(32)) { - netdev->features |= NETIF_F_HIGHDMA; - netdev->vlan_features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, + &netdev->vlan_features); }

/* reset and initialize the hardware so it is in a known state */ diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c index e493c5a..fd81fd0 100644 --- a/drivers/net/ethernet/intel/i40e/i40e_main.c +++ b/drivers/net/ethernet/intel/i40e/i40e_main.c @@ -2962,7 +2962,8 @@ static void i40e_restore_vlan(struct i40e_vsi *vsi) if (!vsi->netdev) return;

- if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + vsi->netdev->features)) i40e_vlan_stripping_enable(vsi); else i40e_vlan_stripping_disable(vsi); @@ -12541,7 +12542,7 @@ bool i40e_set_ntuple(struct i40e_pf *pf, netdev_features_t features) /* Check if Flow Director n-tuple support was enabled or disabled. If * the state changed, we need to reset. */ - if (features & NETIF_F_NTUPLE) { + if (netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, features)) { /* Enable filters and mark for reset */ if (!(pf->flags & I40E_FLAG_FD_SB_ENABLED)) need_reset = true; @@ -12610,24 +12611,27 @@ static int i40e_set_features(struct net_device *netdev, struct i40e_pf *pf = vsi->back; bool need_reset;

- if (features & NETIF_F_RXHASH && !(netdev->features & NETIF_F_RXHASH)) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, features) && + !netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features)) i40e_pf_config_rss(pf); - else if (!(features & NETIF_F_RXHASH) && - netdev->features & NETIF_F_RXHASH) + else if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, features) && + netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features)) i40e_clear_rss_lut(vsi);

- if (features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features)) i40e_vlan_stripping_enable(vsi); else i40e_vlan_stripping_disable(vsi);

- if (!(features & NETIF_F_HW_TC) && pf->num_cloud_filters) { + if (!netdev_feature_test_bit(NETIF_F_HW_TC_BIT, features) && + pf->num_cloud_filters) { dev_err(&pf->pdev->dev, "Offloaded tc filters active, can't turn hw_tc_offload off"); return -EINVAL; }

- if (!(features & NETIF_F_HW_L2FW_DOFFLOAD) && vsi->macvlan_cnt) + if (!netdev_feature_test_bit(NETIF_F_HW_L2FW_DOFFLOAD_BIT, features) && + vsi->macvlan_cnt) i40e_del_all_macvlans(vsi);

need_reset = i40e_set_ntuple(pf, features); @@ -12889,7 +12893,7 @@ static void i40e_features_check(struct sk_buff *skb, struct net_device *dev, * 64 bytes. If it is then we need to drop support for GSO. */ if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_size < 64)) - *features &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, features);

/* MACLEN can support at most 63 words */ len = skb_network_header(skb) - skb->data; @@ -12921,7 +12925,8 @@ static void i40e_features_check(struct sk_buff *skb, struct net_device *dev,

return; out_err: - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); }

/** @@ -13324,53 +13329,71 @@ static int i40e_config_netdev(struct i40e_vsi *vsi) np = netdev_priv(netdev); np->vsi = vsi;

- hw_enc_features = NETIF_F_SG | - NETIF_F_IP_CSUM | - NETIF_F_IPV6_CSUM | - NETIF_F_HIGHDMA | - NETIF_F_SOFT_FEATURES | - NETIF_F_TSO | - NETIF_F_TSO_ECN | - NETIF_F_TSO6 | - NETIF_F_GSO_GRE | - NETIF_F_GSO_GRE_CSUM | - NETIF_F_GSO_PARTIAL | - NETIF_F_GSO_IPXIP4 | - NETIF_F_GSO_IPXIP6 | - NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_GSO_UDP_TUNNEL_CSUM | - NETIF_F_GSO_UDP_L4 | - NETIF_F_SCTP_CRC | - NETIF_F_RXHASH | - NETIF_F_RXCSUM | - 0; + netdev_feature_zero(&hw_enc_features); + netdev_feature_set_bits(NETIF_F_SG_BIT | + NETIF_F_IP_CSUM_BIT | + NETIF_F_IPV6_CSUM_BIT | + NETIF_F_HIGHDMA_BIT | + NETIF_F_GSO_BIT | + NETIF_F_GRO_BIT | + NETIF_F_TSO_BIT | + NETIF_F_TSO_ECN_BIT | + NETIF_F_TSO6_BIT | + NETIF_F_GSO_GRE_BIT | + NETIF_F_GSO_GRE_CSUM_BIT | + NETIF_F_GSO_PARTIAL_BIT | + NETIF_F_GSO_IPXIP4_BIT | + NETIF_F_GSO_IPXIP6_BIT | + NETIF_F_GSO_UDP_TUNNEL_BIT | + NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT | + NETIF_F_GSO_UDP_L4_BIT | + NETIF_F_SCTP_CRC_BIT | + NETIF_F_RXHASH_BIT | + NETIF_F_RXCSUM_BIT, + &hw_enc_features);

if (!(pf->hw_features & I40E_HW_OUTER_UDP_CSUM_CAPABLE)) - netdev->gso_partial_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM; + netdev_feature_set_bit(NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT, + &netdev->gso_partial_features);

netdev->udp_tunnel_nic_info = &pf->udp_tunnel_nic;

- netdev->gso_partial_features |= NETIF_F_GSO_GRE_CSUM; + netdev_feature_set_bit(NETIF_F_GSO_GRE_CSUM_BIT, + &netdev->gso_partial_features);

- netdev->hw_enc_features |= hw_enc_features; + netdev_feature_or(&netdev->hw_enc_features, netdev->hw_enc_features, + hw_enc_features);

/* record features VLANs can make use of */ - netdev->vlan_features |= hw_enc_features | NETIF_F_TSO_MANGLEID; + netdev_feature_or(&netdev->vlan_features, netdev->vlan_features, + hw_enc_features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->vlan_features);

/* enable macvlan offloads */ - netdev->hw_features |= NETIF_F_HW_L2FW_DOFFLOAD; + netdev_feature_set_bit(NETIF_F_HW_L2FW_DOFFLOAD_BIT, + &netdev->hw_features);

- hw_features = hw_enc_features | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_copy(&hw_features, hw_enc_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + &hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &hw_features);

- if (!(pf->flags & I40E_FLAG_MFP_ENABLED)) - hw_features |= NETIF_F_NTUPLE | NETIF_F_HW_TC; + if (!(pf->flags & I40E_FLAG_MFP_ENABLED)) { + netdev_feature_set_bit(NETIF_F_NTUPLE_BIT, &hw_features); + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &hw_features); + }

- netdev->hw_features |= hw_features; + netdev_feature_or(&netdev->hw_features, netdev->hw_features, + hw_features);

- netdev->features |= hw_features | NETIF_F_HW_VLAN_CTAG_FILTER; - netdev->hw_enc_features |= NETIF_F_TSO_MANGLEID; + netdev_feature_or(&netdev->features, netdev->features, + hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &netdev->features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->hw_enc_features);

if (vsi->type == I40E_VSI_MAIN) { SET_NETDEV_DEV(netdev, &pf->pdev->dev); diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c index 3f25bd8..ee5fbd5 100644 --- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c +++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c @@ -1793,7 +1793,8 @@ static inline void i40e_rx_checksum(struct i40e_vsi *vsi, skb_checksum_none_assert(skb);

/* Rx csum enabled and ip headers found? */ - if (!(vsi->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + vsi->netdev->features)) return;

/* did the hardware decode the packet and checksum? */ @@ -1895,7 +1896,8 @@ static inline void i40e_rx_hash(struct i40e_ring *ring, cpu_to_le64((u64)I40E_RX_DESC_FLTSTAT_RSS_HASH << I40E_RX_DESC_STATUS_FLTSTAT_SHIFT);

- if (!(ring->netdev->features & NETIF_F_RXHASH)) + if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) return;

if ((rx_desc->wb.qword1.status_error_len & rss_mask) == rss_mask) { @@ -2944,7 +2946,8 @@ static inline int i40e_tx_prepare_vlan_flags(struct sk_buff *skb, u32 tx_flags = 0;

if (protocol == htons(ETH_P_8021Q) && - !(tx_ring->netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) { + !netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + tx_ring->netdev->features)) { /* When HW VLAN acceleration is turned off by the user the * stack sets the protocol to 8021q so that the driver * can take any steps required to support the SW only diff --git a/drivers/net/ethernet/intel/iavf/iavf_main.c b/drivers/net/ethernet/intel/iavf/iavf_main.c index e46395a0..f4d89e6 100644 --- a/drivers/net/ethernet/intel/iavf/iavf_main.c +++ b/drivers/net/ethernet/intel/iavf/iavf_main.c @@ -1897,7 +1897,7 @@ static int iavf_init_get_resources(struct iavf_adapter *adapter) err); } dev_info(&pdev->dev, "MAC address: %pM\n", adapter->hw.mac.addr); - if (netdev->features & NETIF_F_GRO) + if (netdev_feature_test_bit( NETIF_F_GRO_BIT, netdev->features)) dev_info(&pdev->dev, "GRO is enabled\n");

adapter->state = __IAVF_DOWN; @@ -3359,15 +3359,20 @@ static int iavf_set_features(struct net_device *netdev, netdev_features_t features) { struct iavf_adapter *adapter = netdev_priv(netdev); + netdev_features_t changed;

+ netdev_feature_xor(&changed, netdev->features, features); /* Don't allow changing VLAN_RX flag when adapter is not capable * of VLAN offload */ if (!VLAN_ALLOWED(adapter)) { - if ((netdev->features ^ features) & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + changed)) return -EINVAL; - } else if ((netdev->features ^ features) & NETIF_F_HW_VLAN_CTAG_RX) { - if (features & NETIF_F_HW_VLAN_CTAG_RX) + } else if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + changed)) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features)) adapter->aq_required |= IAVF_FLAG_AQ_ENABLE_VLAN_STRIPPING; else @@ -3400,7 +3405,7 @@ static void iavf_features_check(struct sk_buff *skb, struct net_device *dev, * 64 bytes. If it is then we need to drop support for GSO. */ if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_size < 64)) - *features &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, features);

/* MACLEN can support at most 63 words */ len = skb_network_header(skb) - skb->data; @@ -3432,7 +3437,8 @@ static void iavf_features_check(struct sk_buff *skb, struct net_device *dev,

return; out_err: - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); }

/** @@ -3448,9 +3454,10 @@ static void iavf_fix_features(struct net_device *netdev, struct iavf_adapter *adapter = netdev_priv(netdev);

if (!(adapter->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_VLAN)) - *features &= ~(NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_FILTER); + netdev_feature_clear_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_FILTER, + features); }

static const struct net_device_ops iavf_netdev_ops = { @@ -3535,84 +3542,103 @@ int iavf_process_config(struct iavf_adapter *adapter) } adapter->num_req_queues = 0;

- hw_enc_features = NETIF_F_SG | - NETIF_F_IP_CSUM | - NETIF_F_IPV6_CSUM | - NETIF_F_HIGHDMA | - NETIF_F_SOFT_FEATURES | - NETIF_F_TSO | - NETIF_F_TSO_ECN | - NETIF_F_TSO6 | - NETIF_F_SCTP_CRC | - NETIF_F_RXHASH | - NETIF_F_RXCSUM | - 0; + netdev_feature_zero(&hw_enc_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_IP_CSUM | + NETIF_F_IPV6_CSUM | + NETIF_F_HIGHDMA | + NETIF_F_SOFT_FEATURES | + NETIF_F_TSO | + NETIF_F_TSO_ECN | + NETIF_F_TSO6 | + NETIF_F_SCTP_CRC | + NETIF_F_RXHASH | + NETIF_F_RXCSUM, + &hw_enc_features);

/* advertise to stack only if offloads for encapsulated packets is * supported */ if (vfres->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ENCAP) { - hw_enc_features |= NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_GSO_GRE | - NETIF_F_GSO_GRE_CSUM | - NETIF_F_GSO_IPXIP4 | - NETIF_F_GSO_IPXIP6 | - NETIF_F_GSO_UDP_TUNNEL_CSUM | - NETIF_F_GSO_PARTIAL | - 0; + netdev_feature_set_bits(NETIF_F_GSO_UDP_TUNNEL | + NETIF_F_GSO_GRE | + NETIF_F_GSO_GRE_CSUM | + NETIF_F_GSO_IPXIP4 | + NETIF_F_GSO_IPXIP6 | + NETIF_F_GSO_UDP_TUNNEL_CSUM | + NETIF_F_GSO_PARTIAL, + &hw_enc_features);

if (!(vfres->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM)) - netdev->gso_partial_features |= - NETIF_F_GSO_UDP_TUNNEL_CSUM; + netdev_feature_set_bit(NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT, + &netdev->gso_partial_features);

- netdev->gso_partial_features |= NETIF_F_GSO_GRE_CSUM; - netdev->hw_enc_features |= NETIF_F_TSO_MANGLEID; - netdev->hw_enc_features |= hw_enc_features; + netdev_feature_set_bit(NETIF_F_GSO_GRE_CSUM_BIT, + &netdev->gso_partial_features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->hw_enc_features); + netdev_feature_or(&netdev->hw_enc_features, + netdev->hw_enc_features, hw_enc_features); } /* record features VLANs can make use of */ - netdev->vlan_features |= hw_enc_features | NETIF_F_TSO_MANGLEID; + netdev_feature_or(&netdev->vlan_features, + netdev->vlan_features, hw_enc_features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->vlan_features);

/* Write features and hw_features separately to avoid polluting * with, or dropping, features that are set when we registered. */ - hw_features = hw_enc_features; + netdev_feature_copy(&hw_features, hw_enc_features);

/* Enable VLAN features if supported */ if (vfres->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_VLAN) - hw_features |= (NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, &hw_features); /* Enable cloud filter if ADQ is supported */ if (vfres->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ADQ) - hw_features |= NETIF_F_HW_TC; + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &hw_features); if (vfres->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_USO) - hw_features |= NETIF_F_GSO_UDP_L4; + netdev_feature_set_bit(NETIF_F_GSO_UDP_L4_BIT, &hw_features);

- netdev->hw_features |= hw_features; + netdev_feature_or(&netdev->hw_features, netdev->hw_features, + hw_features);

- netdev->features |= hw_features; + netdev_feature_or(&netdev->features, netdev->features, hw_features);

if (vfres->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_VLAN) - netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &netdev->features);

netdev->priv_flags |= IFF_UNICAST_FLT;

/* Do not turn on offloads when they are requested to be turned off. * TSO needs minimum 576 bytes to work correctly. */ - if (netdev->wanted_features) { - if (!(netdev->wanted_features & NETIF_F_TSO) || + if (!netdev_feature_empty(netdev->wanted_features)) { + if (!netdev_feature_test_bit(NETIF_F_TSO_BIT, + netdev->wanted_features) || netdev->mtu < 576) - netdev->features &= ~NETIF_F_TSO; - if (!(netdev->wanted_features & NETIF_F_TSO6) || + netdev_feature_clear_bit(NETIF_F_TSO_BIT, + &netdev->features); + if (!netdev_feature_test_bit(NETIF_F_TSO6_BIT, + netdev->wanted_features) || netdev->mtu < 576) - netdev->features &= ~NETIF_F_TSO6; - if (!(netdev->wanted_features & NETIF_F_TSO_ECN)) - netdev->features &= ~NETIF_F_TSO_ECN; - if (!(netdev->wanted_features & NETIF_F_GRO)) - netdev->features &= ~NETIF_F_GRO; - if (!(netdev->wanted_features & NETIF_F_GSO)) - netdev->features &= ~NETIF_F_GSO; + netdev_feature_clear_bit(NETIF_F_TSO6_BIT, + &netdev->features); + if (!netdev_feature_test_bit(NETIF_F_TSO_ECN_BIT, + netdev->wanted_features)) + netdev_feature_clear_bit(NETIF_F_TSO_ECN_BIT, + &netdev->features); + if (!netdev_feature_test_bit(NETIF_F_GRO_BIT, + netdev->wanted_features)) + netdev_feature_clear_bit(NETIF_F_GRO_BIT, + &netdev->features); + if (!netdev_feature_test_bit(NETIF_F_GSO_BIT, + netdev->wanted_features)) + netdev_feature_clear_bit(NETIF_F_GSO_BIT, + &netdev->features); }

adapter->vsi.id = adapter->vsi_res->vsi_id; diff --git a/drivers/net/ethernet/intel/iavf/iavf_txrx.c b/drivers/net/ethernet/intel/iavf/iavf_txrx.c index 3525eab..2293ad26 100644 --- a/drivers/net/ethernet/intel/iavf/iavf_txrx.c +++ b/drivers/net/ethernet/intel/iavf/iavf_txrx.c @@ -862,7 +862,8 @@ static void iavf_receive_skb(struct iavf_ring *rx_ring, { struct iavf_q_vector *q_vector = rx_ring->q_vector;

- if ((rx_ring->netdev->features & NETIF_F_HW_VLAN_CTAG_RX) && + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + rx_ring->netdev->features) && (vlan_tag & VLAN_VID_MASK)) __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);

@@ -963,7 +964,8 @@ static inline void iavf_rx_checksum(struct iavf_vsi *vsi, skb_checksum_none_assert(skb);

/* Rx csum enabled and ip headers found? */ - if (!(vsi->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + vsi->netdev->features)) return;

/* did the hardware decode the packet and checksum? */ @@ -1058,7 +1060,8 @@ static inline void iavf_rx_hash(struct iavf_ring *ring, cpu_to_le64((u64)IAVF_RX_DESC_FLTSTAT_RSS_HASH << IAVF_RX_DESC_STATUS_FLTSTAT_SHIFT);

- if (ring->netdev->features & NETIF_F_RXHASH) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) return;

if ((rx_desc->wb.qword1.status_error_len & rss_mask) == rss_mask) { @@ -1789,7 +1792,8 @@ static inline int iavf_tx_prepare_vlan_flags(struct sk_buff *skb, u32 tx_flags = 0;

if (protocol == htons(ETH_P_8021Q) && - !(tx_ring->netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) { + !netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + tx_ring->netdev->features)) { /* When HW VLAN acceleration is turned off by the user the * stack sets the protocol to 8021q so that the driver * can take any steps required to support the SW only diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c index 54cb9af..dd9332a 100644 --- a/drivers/net/ethernet/intel/ice/ice_main.c +++ b/drivers/net/ethernet/intel/ice/ice_main.c @@ -3053,53 +3053,74 @@ static void ice_set_netdev_features(struct net_device *netdev)

if (ice_is_safe_mode(pf)) { /* safe mode */ - netdev->features = NETIF_F_SG | NETIF_F_HIGHDMA; - netdev->hw_features = netdev->features; + netdev_feature_zero(&netdev->features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_HIGHDMA, + &netdev->features); + netdev_feature_copy(&netdev->hw_features, netdev->features); return; }

- dflt_features = NETIF_F_SG | - NETIF_F_HIGHDMA | - NETIF_F_NTUPLE | - NETIF_F_RXHASH; - - csumo_features = NETIF_F_RXCSUM | - NETIF_F_IP_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_IPV6_CSUM; - - vlano_features = NETIF_F_HW_VLAN_CTAG_FILTER | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX; - - tso_features = NETIF_F_TSO | - NETIF_F_TSO_ECN | - NETIF_F_TSO6 | - NETIF_F_GSO_GRE | - NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_GSO_GRE_CSUM | - NETIF_F_GSO_UDP_TUNNEL_CSUM | - NETIF_F_GSO_PARTIAL | - NETIF_F_GSO_IPXIP4 | - NETIF_F_GSO_IPXIP6 | - NETIF_F_GSO_UDP_L4; - - netdev->gso_partial_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM | - NETIF_F_GSO_GRE_CSUM; + netdev_feature_zero(&dflt_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_HIGHDMA | + NETIF_F_NTUPLE | + NETIF_F_RXHASH, + &dflt_features); + + netdev_feature_zero(&csumo_features); + netdev_feature_set_bits(NETIF_F_RXCSUM | + NETIF_F_IP_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_IPV6_CSUM, + &csumo_features); + + netdev_feature_zero(&vlano_features); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_FILTER | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, + &vlano_features); + + netdev_feature_zero(&tso_features); + netdev_feature_set_bits(NETIF_F_TSO | + NETIF_F_TSO_ECN | + NETIF_F_TSO6 | + NETIF_F_GSO_GRE | + NETIF_F_GSO_UDP_TUNNEL | + NETIF_F_GSO_GRE_CSUM | + NETIF_F_GSO_UDP_TUNNEL_CSUM | + NETIF_F_GSO_PARTIAL | + NETIF_F_GSO_IPXIP4 | + NETIF_F_GSO_IPXIP6 | + NETIF_F_GSO_UDP_L4, + &tso_features); + + netdev_feature_set_bits(NETIF_F_GSO_UDP_TUNNEL_CSUM | + NETIF_F_GSO_GRE_CSUM, + &netdev->gso_partial_features); /* set features that user can change */ - netdev->hw_features = dflt_features | csumo_features | - vlano_features | tso_features; + netdev_feature_or(&netdev->hw_features, dflt_features, + csumo_features); + netdev_feature_or(&netdev->hw_features, netdev->hw_features, + vlano_features); + netdev_feature_or(&netdev->hw_features, netdev->hw_features, + tso_features);

/* add support for HW_CSUM on packets with MPLS header */ - netdev->mpls_features = NETIF_F_HW_CSUM; + netdev_feature_zero(&netdev->mpls_features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &netdev->mpls_features);

/* enable features */ - netdev->features |= netdev->hw_features; + netdev_feature_or(&netdev->features, netdev->features, + netdev->hw_features); /* encap and VLAN devices inherit default, csumo and tso features */ - netdev->hw_enc_features |= dflt_features | csumo_features | - tso_features; - netdev->vlan_features |= dflt_features | csumo_features | - tso_features; + netdev_feature_or(&netdev->hw_enc_features, dflt_features, + csumo_features); + netdev_feature_or(&netdev->hw_enc_features, netdev->hw_enc_features, + tso_features); + netdev_feature_or(&netdev->vlan_features, dflt_features, + csumo_features); + netdev_feature_or(&netdev->vlan_features, netdev->vlan_features, + tso_features); }

/** @@ -5341,39 +5362,51 @@ ice_set_features(struct net_device *netdev, netdev_features_t features) /* Multiple features can be changed in one call so keep features in * separate if/else statements to guarantee each feature is checked */ - if (features & NETIF_F_RXHASH && !(netdev->features & NETIF_F_RXHASH)) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, features) && + !netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features)) ice_vsi_manage_rss_lut(vsi, true); - else if (!(features & NETIF_F_RXHASH) && - netdev->features & NETIF_F_RXHASH) + else if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, features) && + netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features)) ice_vsi_manage_rss_lut(vsi, false);

- if ((features & NETIF_F_HW_VLAN_CTAG_RX) && - !(netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features) && + !netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + netdev->features)) ret = ice_vsi_manage_vlan_stripping(vsi, true); - else if (!(features & NETIF_F_HW_VLAN_CTAG_RX) && - (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) + else if (!netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features) && + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + netdev->features)) ret = ice_vsi_manage_vlan_stripping(vsi, false);

- if ((features & NETIF_F_HW_VLAN_CTAG_TX) && - !(netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features) && + !netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + netdev->features)) ret = ice_vsi_manage_vlan_insertion(vsi); - else if (!(features & NETIF_F_HW_VLAN_CTAG_TX) && - (netdev->features & NETIF_F_HW_VLAN_CTAG_TX)) + else if (!netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features) && + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + netdev->features)) ret = ice_vsi_manage_vlan_insertion(vsi);

- if ((features & NETIF_F_HW_VLAN_CTAG_FILTER) && - !(netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + features) && + !netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + netdev->features)) ret = ice_cfg_vlan_pruning(vsi, true, false); - else if (!(features & NETIF_F_HW_VLAN_CTAG_FILTER) && - (netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) + else if (!netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + features) && + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + netdev->features)) ret = ice_cfg_vlan_pruning(vsi, false, false);

- if ((features & NETIF_F_NTUPLE) && - !(netdev->features & NETIF_F_NTUPLE)) { + if (netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, features) && + !netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, netdev->features)) { ice_vsi_manage_fdir(vsi, true); ice_init_arfs(vsi); - } else if (!(features & NETIF_F_NTUPLE) && - (netdev->features & NETIF_F_NTUPLE)) { + } else if (!netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, features) && + netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, + netdev->features)) { ice_vsi_manage_fdir(vsi, false); ice_clear_arfs(vsi); } @@ -5389,9 +5422,11 @@ static int ice_vsi_vlan_setup(struct ice_vsi *vsi) { int ret = 0;

- if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + vsi->netdev->features)) ret = ice_vsi_manage_vlan_stripping(vsi, true); - if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_TX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + vsi->netdev->features)) ret = ice_vsi_manage_vlan_insertion(vsi);

return ret; @@ -7179,7 +7214,7 @@ static void ice_features_check(struct sk_buff *skb, * 64 bytes. If it is then we need to drop support for GSO. */ if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_size < 64)) - *features &= ~NETIF_F_GSO_MASK; + netdev_feature_clear_bits(NETIF_F_GSO_MASK, features);

len = skb_network_header(skb) - skb->data; if (len > ICE_TXD_MACLEN_MAX || len & 0x1) @@ -7202,7 +7237,8 @@ static void ice_features_check(struct sk_buff *skb,

return; out_rm_features: - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); }

static const struct net_device_ops ice_netdev_safe_mode_ops = { diff --git a/drivers/net/ethernet/intel/ice/ice_txrx_lib.c b/drivers/net/ethernet/intel/ice/ice_txrx_lib.c index 171397d..6ab2c65 100644 --- a/drivers/net/ethernet/intel/ice/ice_txrx_lib.c +++ b/drivers/net/ethernet/intel/ice/ice_txrx_lib.c @@ -72,7 +72,8 @@ ice_rx_hash(struct ice_ring *rx_ring, union ice_32b_rx_flex_desc *rx_desc, struct ice_32b_rx_flex_desc_nic *nic_mdid; u32 hash;

- if (!(rx_ring->netdev->features & NETIF_F_RXHASH)) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + rx_ring->netdev->features)) return;

if (rx_desc->wb.rxdid != ICE_RXDID_FLEX_NIC) @@ -110,7 +111,8 @@ ice_rx_csum(struct ice_ring *ring, struct sk_buff *skb, skb_checksum_none_assert(skb);

/* check if Rx checksum is enabled */ - if (!(ring->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) return;

/* check if HW has decoded the packet and checksum */ @@ -205,7 +207,8 @@ ice_process_skb_fields(struct ice_ring *rx_ring, void ice_receive_skb(struct ice_ring *rx_ring, struct sk_buff *skb, u16 vlan_tag) { - if ((rx_ring->netdev->features & NETIF_F_HW_VLAN_CTAG_RX) && + if (!netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + rx_ring->netdev->features) && (vlan_tag & VLAN_VID_MASK)) __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag); napi_gro_receive(&rx_ring->q_vector->napi, skb); diff --git a/drivers/net/ethernet/intel/igb/igb_ethtool.c b/drivers/net/ethernet/intel/igb/igb_ethtool.c index 17f5c00..898f246 100644 --- a/drivers/net/ethernet/intel/igb/igb_ethtool.c +++ b/drivers/net/ethernet/intel/igb/igb_ethtool.c @@ -2897,7 +2897,7 @@ static int igb_add_ethtool_nfc_entry(struct igb_adapter *adapter, struct igb_nfc_filter *input, *rule; int err = 0;

- if (!(netdev->hw_features & NETIF_F_NTUPLE)) + if (!netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, netdev->hw_features)) return -EOPNOTSUPP;

/* Don't allow programming if the action is a queue greater than diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c index 2e4a53c..1f764d4 100644 --- a/drivers/net/ethernet/intel/igb/igb_main.c +++ b/drivers/net/ethernet/intel/igb/igb_main.c @@ -2439,25 +2439,28 @@ static void igb_fix_features(struct net_device *netdev, /* Since there is no support for separate Rx/Tx vlan accel * enable/disable make sure Tx flag is always in same state as Rx. */ - if (*features & NETIF_F_HW_VLAN_CTAG_RX) - *features |= NETIF_F_HW_VLAN_CTAG_TX; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features); else - *features &= ~NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features); }

static int igb_set_features(struct net_device *netdev, netdev_features_t features) { - netdev_features_t changed = netdev->features ^ features; struct igb_adapter *adapter = netdev_priv(netdev); + netdev_features_t changed;

- if (changed & NETIF_F_HW_VLAN_CTAG_RX) + netdev_feature_xor(&changed, netdev->features, features); + + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, changed)) igb_vlan_mode(netdev, features);

- if (!(changed & (NETIF_F_RXALL | NETIF_F_NTUPLE))) + if (!netdev_feature_test_bits(NETIF_F_RXALL | NETIF_F_NTUPLE, changed)) return 0;

- if (!(features & NETIF_F_NTUPLE)) { + if (!netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, features)) { struct hlist_node *node2; struct igb_nfc_filter *rule;

@@ -2472,7 +2475,7 @@ static int igb_set_features(struct net_device *netdev, adapter->nfc_filter_count = 0; }

- netdev->features = features; + netdev_feature_copy(&netdev->features, features);

if (netif_running(netdev)) igb_reinit_locked(adapter); @@ -2511,30 +2514,33 @@ static void igb_features_check(struct sk_buff *skb, struct net_device *dev, /* Make certain the headers can be described by a context descriptor */ mac_hdr_len = skb_network_header(skb) - skb->data; if (unlikely(mac_hdr_len > IGB_MAX_MAC_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_GSO_UDP_L4 | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_GSO_UDP_L4 | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

network_hdr_len = skb_checksum_start(skb) - skb_network_header(skb); if (unlikely(network_hdr_len > IGB_MAX_NETWORK_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_GSO_UDP_L4 | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_GSO_UDP_L4 | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

/* We can only support IPV4 TSO in tunnels if we can mangle the * inner IP ID field, so strip TSO if MANGLEID is not supported. */ - if (skb->encapsulation && !(*features & NETIF_F_TSO_MANGLEID)) - *features &= ~NETIF_F_TSO; + if (skb->encapsulation && + !netdev_feature_test_bit(NETIF_F_TSO_MANGLEID_BIT, *features)) + netdev_feature_clear_bit(NETIF_F_TSO_BIT, features); }

static void igb_offload_apply(struct igb_adapter *adapter, s32 queue) @@ -3266,18 +3272,20 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) * set by igb_sw_init so we should use an or instead of an * assignment. */ - netdev->features |= NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_RXHASH | - NETIF_F_RXCSUM | - NETIF_F_HW_CSUM; + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_RXHASH | + NETIF_F_RXCSUM | + NETIF_F_HW_CSUM, + &netdev->features);

if (hw->mac.type >= e1000_82576) - netdev->features |= NETIF_F_SCTP_CRC | NETIF_F_GSO_UDP_L4; + netdev_feature_set_bits(NETIF_F_SCTP_CRC | NETIF_F_GSO_UDP_L4, + &netdev->features);

if (hw->mac.type >= e1000_i350) - netdev->features |= NETIF_F_HW_TC; + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &netdev->features);

#define IGB_GSO_PARTIAL_FEATURES (NETIF_F_GSO_GRE | \ NETIF_F_GSO_GRE_CSUM | \ @@ -3286,29 +3294,41 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) NETIF_F_GSO_UDP_TUNNEL | \ NETIF_F_GSO_UDP_TUNNEL_CSUM)

- netdev->gso_partial_features = IGB_GSO_PARTIAL_FEATURES; - netdev->features |= NETIF_F_GSO_PARTIAL | IGB_GSO_PARTIAL_FEATURES; + netdev_feature_zero(&netdev->gso_partial_features); + netdev_feature_set_bits(IGB_GSO_PARTIAL_FEATURES, + &netdev->gso_partial_features); + netdev_feature_set_bits(NETIF_F_GSO_PARTIAL | + IGB_GSO_PARTIAL_FEATURES, + &netdev->features);

/* copy netdev features into list of user selectable features */ - netdev->hw_features |= netdev->features | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_RXALL; + netdev_feature_or(&netdev->hw_features, netdev->hw_features, + netdev->features); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_RXALL, + &netdev->hw_features);

if (hw->mac.type >= e1000_i350) - netdev->hw_features |= NETIF_F_NTUPLE; + netdev_feature_set_bit(NETIF_F_NTUPLE_BIT, + &netdev->hw_features);

if (pci_using_dac) - netdev->features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features);

- netdev->vlan_features |= netdev->features | NETIF_F_TSO_MANGLEID; - netdev->mpls_features |= NETIF_F_HW_CSUM; - netdev->hw_enc_features |= netdev->vlan_features; + netdev_feature_or(&netdev->vlan_features, netdev->vlan_features, + netdev->features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &netdev->mpls_features); + netdev_feature_or(&netdev->hw_enc_features, netdev->hw_enc_features, + netdev->vlan_features);

/* set this bit last since it cannot be part of vlan_features */ - netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_FILTER | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX, + &netdev->features);

netdev->priv_flags |= IFF_SUPP_NOFCS;

@@ -4539,7 +4559,8 @@ void igb_setup_rctl(struct igb_adapter *adapter) }

/* This is useful for sniffing bad packets. */ - if (adapter->netdev->features & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, + adapter->netdev->features)) { /* UPE and MPE will be handled by normal PROMISC logic * in e1000e_set_rx_mode */ @@ -5045,7 +5066,8 @@ static int igb_vlan_promisc_enable(struct igb_adapter *adapter) case e1000_i211: case e1000_i350: /* VLAN filtering needed for VLAN prio filter */ - if (adapter->netdev->features & NETIF_F_NTUPLE) + if (netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, + adapter->netdev->features)) break; fallthrough; case e1000_82576: @@ -5217,7 +5239,7 @@ static void igb_set_rx_mode(struct net_device *netdev)

/* disable VLAN filtering for modes that require it */ if ((netdev->flags & IFF_PROMISC) || - (netdev->features & NETIF_F_RXALL)) { + netdev_feature_test_bit(NETIF_F_RXALL_BIT, netdev->features)) { /* if we fail to set all rules then just clear VFE */ if (igb_vlan_promisc_enable(adapter)) rctl &= ~E1000_RCTL_VFE; @@ -8467,7 +8489,8 @@ static inline void igb_rx_checksum(struct igb_ring *ring, return;

/* Rx checksum disabled via ethtool */ - if (!(ring->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + ring->netdev->features)) return;

/* TCP/UDP checksum error bit is set */ @@ -8500,7 +8523,8 @@ static inline void igb_rx_hash(struct igb_ring *ring, union e1000_adv_rx_desc *rx_desc, struct sk_buff *skb) { - if (ring->netdev->features & NETIF_F_RXHASH) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) skb_set_hash(skb, le32_to_cpu(rx_desc->wb.lower.hi_dword.rss), PKT_HASH_TYPE_L3); @@ -8558,7 +8582,8 @@ static bool igb_cleanup_headers(struct igb_ring *rx_ring, if (unlikely((igb_test_staterr(rx_desc, E1000_RXDEXT_ERR_FRAME_ERR_MASK)))) { struct net_device *netdev = rx_ring->netdev; - if (!(netdev->features & NETIF_F_RXALL)) { + if (!netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features)) { dev_kfree_skb_any(skb); return true; } @@ -8595,7 +8620,8 @@ static void igb_process_skb_fields(struct igb_ring *rx_ring, !igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP)) igb_ptp_rx_rgtstamp(rx_ring->q_vector, skb);

- if ((dev->features & NETIF_F_HW_VLAN_CTAG_RX) && + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->features) && igb_test_staterr(rx_desc, E1000_RXD_STAT_VP)) { u16 vid;

@@ -9018,7 +9044,8 @@ static void igb_vlan_mode(struct net_device *netdev, netdev_features_t features) struct igb_adapter *adapter = netdev_priv(netdev); struct e1000_hw *hw = &adapter->hw; u32 ctrl, rctl; - bool enable = !!(features & NETIF_F_HW_VLAN_CTAG_RX); + bool enable = netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features);

if (enable) { /* enable VLAN tag insert/strip */ diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c index 92a46ac..2cad7a2 100644 --- a/drivers/net/ethernet/intel/igbvf/netdev.c +++ b/drivers/net/ethernet/intel/igbvf/netdev.c @@ -2608,7 +2608,7 @@ static int igbvf_set_features(struct net_device *netdev, { struct igbvf_adapter *adapter = netdev_priv(netdev);

- if (features & NETIF_F_RXCSUM) + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, features)) adapter->flags &= ~IGBVF_FLAG_RX_CSUM_DISABLED; else adapter->flags |= IGBVF_FLAG_RX_CSUM_DISABLED; @@ -2627,28 +2627,31 @@ static void igbvf_features_check(struct sk_buff *skb, struct net_device *dev, /* Make certain the headers can be described by a context descriptor */ mac_hdr_len = skb_network_header(skb) - skb->data; if (unlikely(mac_hdr_len > IGBVF_MAX_MAC_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

network_hdr_len = skb_checksum_start(skb) - skb_network_header(skb); if (unlikely(network_hdr_len > IGBVF_MAX_NETWORK_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

/* We can only support IPV4 TSO in tunnels if we can mangle the * inner IP ID field, so strip TSO if MANGLEID is not supported. */ - if (skb->encapsulation && !(*features & NETIF_F_TSO_MANGLEID)) - *features &= ~NETIF_F_TSO; + if (skb->encapsulation && + !netdev_feature_test_bit(NETIF_F_TSO_MANGLEID_BIT, *features)) + netdev_feature_clear_bit(NETIF_F_TSO_BIT, features); }

static const struct net_device_ops igbvf_netdev_ops = { @@ -2767,12 +2770,14 @@ static int igbvf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)

adapter->bd_number = cards_found++;

- netdev->hw_features = NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_RXCSUM | - NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC; + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_RXCSUM | + NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC, + &netdev->hw_features);

#define IGBVF_GSO_PARTIAL_FEATURES (NETIF_F_GSO_GRE | \ NETIF_F_GSO_GRE_CSUM | \ @@ -2781,23 +2786,31 @@ static int igbvf_probe(struct pci_dev *pdev, const struct pci_device_id *ent) NETIF_F_GSO_UDP_TUNNEL | \ NETIF_F_GSO_UDP_TUNNEL_CSUM)

- netdev->gso_partial_features = IGBVF_GSO_PARTIAL_FEATURES; - netdev->hw_features |= NETIF_F_GSO_PARTIAL | - IGBVF_GSO_PARTIAL_FEATURES; + netdev_feature_zero(&netdev->gso_partial_features); + netdev_feature_set_bits(IGBVF_GSO_PARTIAL_FEATURES, + &netdev->gso_partial_features); + netdev_feature_set_bits(NETIF_F_GSO_PARTIAL | + IGBVF_GSO_PARTIAL_FEATURES, + &netdev->hw_features);

- netdev->features = netdev->hw_features; + netdev_feature_copy(&netdev->features, netdev->hw_features);

if (pci_using_dac) - netdev->features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features);

- netdev->vlan_features |= netdev->features | NETIF_F_TSO_MANGLEID; - netdev->mpls_features |= NETIF_F_HW_CSUM; - netdev->hw_enc_features |= netdev->vlan_features; + netdev_feature_or(&netdev->vlan_features, netdev->vlan_features, + netdev->features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &netdev->mpls_features); + netdev_feature_or(&netdev->hw_enc_features, netdev->hw_enc_features, + netdev->vlan_features);

/* set this bit last since it cannot be part of vlan_features */ - netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_FILTER | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX, + &netdev->features);

/* MTU range: 68 - 9216 */ netdev->min_mtu = ETH_MIN_MTU; diff --git a/drivers/net/ethernet/intel/igc/igc_ethtool.c b/drivers/net/ethernet/intel/igc/igc_ethtool.c index d3e8441..93fbe53 100644 --- a/drivers/net/ethernet/intel/igc/igc_ethtool.c +++ b/drivers/net/ethernet/intel/igc/igc_ethtool.c @@ -1295,7 +1295,8 @@ static int igc_ethtool_add_nfc_rule(struct igc_adapter *adapter, struct igc_nfc_rule *rule, *old_rule; int err;

- if (!(netdev->hw_features & NETIF_F_NTUPLE)) { + if (!netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, + netdev->hw_features)) { netdev_dbg(netdev, "N-tuple filters disabled\n"); return -EOPNOTSUPP; } diff --git a/drivers/net/ethernet/intel/igc/igc_main.c b/drivers/net/ethernet/intel/igc/igc_main.c index f7545a6..a384796 100644 --- a/drivers/net/ethernet/intel/igc/igc_main.c +++ b/drivers/net/ethernet/intel/igc/igc_main.c @@ -816,7 +816,8 @@ static void igc_setup_rctl(struct igc_adapter *adapter) wr32(IGC_RXDCTL(0), 0);

/* This is useful for sniffing bad packets. */ - if (adapter->netdev->features & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, + adapter->netdev->features)) { /* UPE and MPE will be handled by normal PROMISC logic * in set_rx_mode */ @@ -1521,7 +1522,8 @@ static void igc_rx_checksum(struct igc_ring *ring, return;

/* Rx checksum disabled via ethtool */ - if (!(ring->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + ring->netdev->features)) return;

/* TCP/UDP checksum error bit is set */ @@ -1554,7 +1556,8 @@ static inline void igc_rx_hash(struct igc_ring *ring, union igc_adv_rx_desc *rx_desc, struct sk_buff *skb) { - if (ring->netdev->features & NETIF_F_RXHASH) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) skb_set_hash(skb, le32_to_cpu(rx_desc->wb.lower.hi_dword.rss), PKT_HASH_TYPE_L3); @@ -1567,7 +1570,8 @@ static void igc_rx_vlan(struct igc_ring *rx_ring, struct net_device *dev = rx_ring->netdev; u16 vid;

- if ((dev->features & NETIF_F_HW_VLAN_CTAG_RX) && + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->features) && igc_test_staterr(rx_desc, IGC_RXD_STAT_VP)) { if (igc_test_staterr(rx_desc, IGC_RXDEXT_STATERR_LB) && test_bit(IGC_RING_FLAG_RX_LB_VLAN_BSWAP, &rx_ring->flags)) @@ -1606,7 +1610,8 @@ static void igc_process_skb_fields(struct igc_ring *rx_ring,

static void igc_vlan_mode(struct net_device *netdev, netdev_features_t features) { - bool enable = !!(features & NETIF_F_HW_VLAN_CTAG_RX); + bool enable = netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features); struct igc_adapter *adapter = netdev_priv(netdev); struct igc_hw *hw = &adapter->hw; u32 ctrl; @@ -1894,7 +1899,8 @@ static bool igc_cleanup_headers(struct igc_ring *rx_ring, if (unlikely(igc_test_staterr(rx_desc, IGC_RXDEXT_STATERR_RXE))) { struct net_device *netdev = rx_ring->netdev;

- if (!(netdev->features & NETIF_F_RXALL)) { + if (!netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features)) { dev_kfree_skb_any(skb); return true; } @@ -4913,29 +4919,32 @@ static void igc_fix_features(struct net_device *netdev, /* Since there is no support for separate Rx/Tx vlan accel * enable/disable make sure Tx flag is always in same state as Rx. */ - if (*features & NETIF_F_HW_VLAN_CTAG_RX) - *features |= NETIF_F_HW_VLAN_CTAG_TX; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features); else - *features &= ~NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features); }

static int igc_set_features(struct net_device *netdev, netdev_features_t features) { - netdev_features_t changed = netdev->features ^ features; struct igc_adapter *adapter = netdev_priv(netdev); + netdev_features_t changed;

- if (changed & NETIF_F_HW_VLAN_CTAG_RX) + netdev_feature_xor(&changed, netdev->features, features); + + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, changed)) igc_vlan_mode(netdev, features);

/* Add VLAN support */ - if (!(changed & (NETIF_F_RXALL | NETIF_F_NTUPLE))) + if (!netdev_feature_test_bits(NETIF_F_RXALL | NETIF_F_NTUPLE, changed)) return 0;

- if (!(features & NETIF_F_NTUPLE)) + if (!netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, features)) igc_flush_nfc_rules(adapter);

- netdev->features = features; + netdev_feature_copy(&netdev->features, features);

if (netif_running(netdev)) igc_reinit_locked(adapter); @@ -4953,28 +4962,31 @@ static void igc_features_check(struct sk_buff *skb, struct net_device *dev, /* Make certain the headers can be described by a context descriptor */ mac_hdr_len = skb_network_header(skb) - skb->data; if (unlikely(mac_hdr_len > IGC_MAX_MAC_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

network_hdr_len = skb_checksum_start(skb) - skb_network_header(skb); if (unlikely(network_hdr_len > IGC_MAX_NETWORK_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

/* We can only support IPv4 TSO in tunnels if we can mangle the * inner IP ID field, so strip TSO if MANGLEID is not supported. */ - if (skb->encapsulation && !(*features & NETIF_F_TSO_MANGLEID)) - *features &= ~NETIF_F_TSO; + if (skb->encapsulation && + !netdev_feature_test_bit(NETIF_F_TSO_MANGLEID_BIT, *features)) + netdev_feature_clear_bits(NETIF_F_TSO_BIT, features); }

static void igc_tsync_interrupt(struct igc_adapter *adapter) @@ -6230,14 +6242,14 @@ static int igc_probe(struct pci_dev *pdev, goto err_sw_init;

/* Add supported features to the features list*/ - netdev->features |= NETIF_F_SG; - netdev->features |= NETIF_F_TSO; - netdev->features |= NETIF_F_TSO6; - netdev->features |= NETIF_F_TSO_ECN; - netdev->features |= NETIF_F_RXCSUM; - netdev->features |= NETIF_F_HW_CSUM; - netdev->features |= NETIF_F_SCTP_CRC; - netdev->features |= NETIF_F_HW_TC; + netdev_feature_set_bit(NETIF_F_SG_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_TSO_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_TSO6_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_TSO_ECN_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_SCTP_CRC_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &netdev->features);

#define IGC_GSO_PARTIAL_FEATURES (NETIF_F_GSO_GRE | \ NETIF_F_GSO_GRE_CSUM | \ @@ -6246,8 +6258,11 @@ static int igc_probe(struct pci_dev *pdev, NETIF_F_GSO_UDP_TUNNEL | \ NETIF_F_GSO_UDP_TUNNEL_CSUM)

- netdev->gso_partial_features = IGC_GSO_PARTIAL_FEATURES; - netdev->features |= NETIF_F_GSO_PARTIAL | IGC_GSO_PARTIAL_FEATURES; + netdev_feature_zero(&netdev->gso_partial_features); + netdev_feature_set_bits(IGC_GSO_PARTIAL_FEATURES, + &netdev->gso_partial_features); + netdev_feature_set_bits(NETIF_F_GSO_PARTIAL | IGC_GSO_PARTIAL_FEATURES, + &netdev->features);

/* setup the private structure */ err = igc_sw_init(adapter); @@ -6255,15 +6270,19 @@ static int igc_probe(struct pci_dev *pdev, goto err_sw_init;

/* copy netdev features into list of user selectable features */ - netdev->hw_features |= NETIF_F_NTUPLE; - netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX; - netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX; - netdev->hw_features |= netdev->features; + netdev_feature_set_bit(NETIF_F_NTUPLE_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &netdev->hw_features); + netdev_feature_or(&netdev->hw_features, netdev->hw_features, + netdev->features);

if (pci_using_dac) - netdev->features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features);

- netdev->vlan_features |= netdev->features; + netdev_feature_or(&netdev->vlan_features, netdev->vlan_features, + netdev->features);

/* MTU range: 68 - 9216 */ netdev->min_mtu = ETH_MIN_MTU; diff --git a/drivers/net/ethernet/intel/ixgb/ixgb_main.c b/drivers/net/ethernet/intel/ixgb/ixgb_main.c index 34c1bfc..c56ac31 100644 --- a/drivers/net/ethernet/intel/ixgb/ixgb_main.c +++ b/drivers/net/ethernet/intel/ixgb/ixgb_main.c @@ -300,20 +300,26 @@ static void ixgb_fix_features(struct net_device *netdev, * Tx VLAN insertion does not work per HW design when Rx stripping is * disabled. */ - if (!(*features & NETIF_F_HW_VLAN_CTAG_RX)) - *features &= ~NETIF_F_HW_VLAN_CTAG_TX; + if (!netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features)) + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features); }

static int ixgb_set_features(struct net_device *netdev, netdev_features_t features) { struct ixgb_adapter *adapter = netdev_priv(netdev); - netdev_features_t changed = features ^ netdev->features; + netdev_features_t changed;

- if (!(changed & (NETIF_F_RXCSUM|NETIF_F_HW_VLAN_CTAG_RX))) + netdev_feature_xor(&changed, features, netdev->features); + + if (!netdev_feature_test_bits(NETIF_F_RXCSUM | + NETIF_F_HW_VLAN_CTAG_RX, + changed)) return 0;

- adapter->rx_csum = !!(features & NETIF_F_RXCSUM); + adapter->rx_csum = netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + features);

if (netif_running(netdev)) { ixgb_down(adapter, true); @@ -432,18 +438,22 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) if (err) goto err_sw_init;

- netdev->hw_features = NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_HW_CSUM | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX; - netdev->features = netdev->hw_features | - NETIF_F_HW_VLAN_CTAG_FILTER; - netdev->hw_features |= NETIF_F_RXCSUM; + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_HW_CSUM | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, + &netdev->hw_features); + netdev_feature_copy(&netdev->features, netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &netdev->features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &netdev->hw_features);

if (pci_using_dac) { - netdev->features |= NETIF_F_HIGHDMA; - netdev->vlan_features |= NETIF_F_HIGHDMA; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, + &netdev->vlan_features); }

/* MTU range: 68 - 16114 */ @@ -1098,7 +1108,8 @@ ixgb_set_multi(struct net_device *netdev) }

alloc_failed: - if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + netdev->features)) ixgb_vlan_strip_enable(adapter); else ixgb_vlan_strip_disable(adapter); diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c index 72e6ebf..5516574 100644 --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c @@ -319,7 +319,8 @@ static u8 ixgbe_dcbnl_set_all(struct net_device *netdev) int max_frame = adapter->netdev->mtu + ETH_HLEN + ETH_FCS_LEN;

#ifdef IXGBE_FCOE - if (adapter->netdev->features & NETIF_F_FCOE_MTU) + if (netdev_feature_test_bit(NETIF_F_FCOE_MTU_BIT, + adapter->netdev->features)) max_frame = max(max_frame, IXGBE_FCOE_JUMBO_FRAME_SIZE); #endif

diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c index 4ceaca0..fa681c6 100644 --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c @@ -2391,7 +2391,7 @@ static bool ixgbe_update_rsc(struct ixgbe_adapter *adapter)

/* nothing to do if LRO or RSC are not enabled */ if (!(adapter->flags2 & IXGBE_FLAG2_RSC_CAPABLE) || - !(netdev->features & NETIF_F_LRO)) + !netdev_feature_test_bit(NETIF_F_LRO_BIT, netdev->features)) return false;

/* check the feature flag value and enable RSC if necessary */ diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c index 0fcd820..57009d1 100644 --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c @@ -644,7 +644,8 @@ void ixgbe_configure_fcoe(struct ixgbe_adapter *adapter) u32 etqf;

/* Minimal functionality for FCoE requires at least CRC offloads */ - if (!(adapter->netdev->features & NETIF_F_FCOE_CRC)) + if (!netdev_feature_test_bit(NETIF_F_FCOE_CRC_BIT, + adapter->netdev->features)) return;

/* Enable L2 EtherType filter for FCoE, needed for FCoE CRC and DDP */ @@ -858,7 +859,7 @@ int ixgbe_fcoe_enable(struct net_device *netdev)

/* enable FCoE and notify stack */ adapter->flags |= IXGBE_FLAG_FCOE_ENABLED; - netdev->features |= NETIF_F_FCOE_MTU; + netdev_feature_set_bit(NETIF_F_FCOE_MTU_BIT, &netdev->features); netdev_features_change(netdev);

/* release existing queues and reallocate them */ @@ -898,7 +899,7 @@ int ixgbe_fcoe_disable(struct net_device *netdev)

/* disable FCoE and notify stack */ adapter->flags &= ~IXGBE_FLAG_FCOE_ENABLED; - netdev->features &= ~NETIF_F_FCOE_MTU; + netdev_feature_clear_bit(NETIF_F_FCOE_MTU_BIT, &netdev->features);

netdev_features_change(netdev);

diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c index 0218f6c..38fe6323 100644 --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c @@ -978,7 +978,8 @@ static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter, set_bit(__IXGBE_RX_CSUM_UDP_ZERO_ERR, &ring->state);

#ifdef IXGBE_FCOE - if (adapter->netdev->features & NETIF_F_FCOE_MTU) { + if (netdev_feature_test_bit(NETIF_F_FCOE_MTU_BIT, + adapter->netdev->features)) { struct ixgbe_ring_feature *f; f = &adapter->ring_feature[RING_F_FCOE]; if ((rxr_idx >= f->offset) && diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c index c43c99a..742947f 100644 --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c @@ -1423,7 +1423,8 @@ static inline void ixgbe_rx_hash(struct ixgbe_ring *ring, { u16 rss_type;

- if (!(ring->netdev->features & NETIF_F_RXHASH)) + if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) return;

rss_type = le16_to_cpu(rx_desc->wb.lower.lo_dword.hs_rss.pkt_info) & @@ -1473,7 +1474,8 @@ static inline void ixgbe_rx_checksum(struct ixgbe_ring *ring, skb_checksum_none_assert(skb);

/* Rx csum disabled */ - if (!(ring->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + ring->netdev->features)) return;

/* check for VXLAN and Geneve packets */ @@ -1692,7 +1694,8 @@ void ixgbe_process_skb_fields(struct ixgbe_ring *rx_ring, if (unlikely(flags & IXGBE_FLAG_RX_HWTSTAMP_ENABLED)) ixgbe_ptp_rx_hwtstamp(rx_ring, rx_desc, skb);

- if ((dev->features & NETIF_F_HW_VLAN_CTAG_RX) && + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->features) && ixgbe_test_staterr(rx_desc, IXGBE_RXD_STAT_VP)) { u16 vid = le16_to_cpu(rx_desc->wb.upper.vlan); __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid); @@ -1890,7 +1893,8 @@ bool ixgbe_cleanup_headers(struct ixgbe_ring *rx_ring, if (!netdev || (unlikely(ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_ERR_FRAME_ERR_MASK) && - !(netdev->features & NETIF_F_RXALL)))) { + !netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features)))) { dev_kfree_skb_any(skb); return true; } @@ -4897,9 +4901,11 @@ void ixgbe_set_rx_mode(struct net_device *netdev) struct ixgbe_adapter *adapter = netdev_priv(netdev); struct ixgbe_hw *hw = &adapter->hw; u32 fctrl, vmolr = IXGBE_VMOLR_BAM | IXGBE_VMOLR_AUPE; - netdev_features_t features = netdev->features; + netdev_features_t features; int count;

+ netdev_feature_copy(&features, netdev->features); + /* Check for Promiscuous and All Multicast modes */ fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);

@@ -4915,7 +4921,8 @@ void ixgbe_set_rx_mode(struct net_device *netdev) hw->addr_ctrl.user_set_promisc = true; fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE); vmolr |= IXGBE_VMOLR_MPE; - features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &features); } else { if (netdev->flags & IFF_ALLMULTI) { fctrl |= IXGBE_FCTRL_MPE; @@ -4954,7 +4961,7 @@ void ixgbe_set_rx_mode(struct net_device *netdev) }

/* This is useful for sniffing bad packets. */ - if (features & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, features)) { /* UPE and MPE will be handled by normal PROMISC logic * in e1000e_set_rx_mode */ fctrl |= (IXGBE_FCTRL_SBP | /* Receive bad packets */ @@ -4967,12 +4974,12 @@ void ixgbe_set_rx_mode(struct net_device *netdev)

IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);

- if (features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features)) ixgbe_vlan_strip_enable(adapter); else ixgbe_vlan_strip_disable(adapter);

- if (features & NETIF_F_HW_VLAN_CTAG_FILTER) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, features)) ixgbe_vlan_promisc_disable(adapter); else ixgbe_vlan_promisc_enable(adapter); @@ -5054,7 +5061,8 @@ static void ixgbe_configure_dcb(struct ixgbe_adapter *adapter) netif_set_gso_max_size(adapter->netdev, 32768);

#ifdef IXGBE_FCOE - if (adapter->netdev->features & NETIF_F_FCOE_MTU) + if (netdev_feature_test_bit(NETIF_F_FCOE_MTU_BIT, + adapter->netdev->features)) max_frame = max(max_frame, IXGBE_FCOE_JUMBO_FRAME_SIZE); #endif

@@ -5111,7 +5119,7 @@ static int ixgbe_hpbthresh(struct ixgbe_adapter *adapter, int pb)

#ifdef IXGBE_FCOE /* FCoE traffic class uses FCOE jumbo frames */ - if ((dev->features & NETIF_F_FCOE_MTU) && + if (netdev_feature_test_bit(NETIF_F_FCOE_MTU_BIT, dev->features) && (tc < IXGBE_FCOE_JUMBO_FRAME_SIZE) && (pb == ixgbe_fcoe_get_tc(adapter))) tc = IXGBE_FCOE_JUMBO_FRAME_SIZE; @@ -5172,7 +5180,7 @@ static int ixgbe_lpbthresh(struct ixgbe_adapter *adapter, int pb)

#ifdef IXGBE_FCOE /* FCoE traffic class uses FCOE jumbo frames */ - if ((dev->features & NETIF_F_FCOE_MTU) && + if (netdev_feature_test_bit(NETIF_F_FCOE_MTU_BIT, dev->features) && (tc < IXGBE_FCOE_JUMBO_FRAME_SIZE) && (pb == netdev_get_prio_tc_map(dev, adapter->fcoe.up))) tc = IXGBE_FCOE_JUMBO_FRAME_SIZE; @@ -8698,7 +8706,8 @@ netdev_tx_t ixgbe_xmit_frame_ring(struct sk_buff *skb, #ifdef IXGBE_FCOE /* setup tx offload for FCoE */ if ((protocol == htons(ETH_P_FCOE)) && - (tx_ring->netdev->features & (NETIF_F_FSO | NETIF_F_FCOE_CRC))) { + netdev_feature_test_bits(NETIF_F_FSO | NETIF_F_FCOE_CRC, + tx_ring->netdev->features)) { tso = ixgbe_fso(tx_ring, first, &hdr_len); if (tso < 0) goto out_drop; @@ -9688,16 +9697,17 @@ static void ixgbe_fix_features(struct net_device *netdev, struct ixgbe_adapter *adapter = netdev_priv(netdev);

/* If Rx checksum is disabled, then RSC/LRO should also be disabled */ - if (!(*features & NETIF_F_RXCSUM)) - *features &= ~NETIF_F_LRO; + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, *features)) + netdev_feature_clear_bit(NETIF_F_LRO_BIT, features);

/* Turn off LRO if not RSC capable */ if (!(adapter->flags2 & IXGBE_FLAG2_RSC_CAPABLE)) - *features &= ~NETIF_F_LRO; + netdev_feature_clear_bit(NETIF_F_LRO_BIT, features);

- if (adapter->xdp_prog && (*features & NETIF_F_LRO)) { + if (adapter->xdp_prog && + netdev_feature_test_bit(NETIF_F_LRO_BIT, *features)) { e_dev_err("LRO is not supported with XDP\n"); - *features &= ~NETIF_F_LRO; + netdev_feature_clear_bit(NETIF_F_LRO_BIT, features); } }

@@ -9721,11 +9731,13 @@ static int ixgbe_set_features(struct net_device *netdev, netdev_features_t features) { struct ixgbe_adapter *adapter = netdev_priv(netdev); - netdev_features_t changed = netdev->features ^ features; + netdev_features_t changed; bool need_reset = false;

+ netdev_feature_xor(&changed, netdev->features, features); + /* Make sure RSC matches LRO, reset if change */ - if (!(features & NETIF_F_LRO)) { + if (!netdev_feature_test_bit(NETIF_F_LRO_BIT, features)) { if (adapter->flags2 & IXGBE_FLAG2_RSC_ENABLED) need_reset = true; adapter->flags2 &= ~IXGBE_FLAG2_RSC_ENABLED; @@ -9735,7 +9747,8 @@ static int ixgbe_set_features(struct net_device *netdev, adapter->rx_itr_setting > IXGBE_MIN_RSC_ITR) { adapter->flags2 |= IXGBE_FLAG2_RSC_ENABLED; need_reset = true; - } else if ((changed ^ features) & NETIF_F_LRO) { + } else if (!netdev_feature_test_bit(NETIF_F_LRO_BIT, + changed)) { e_info(probe, "rx-usecs set too low, " "disabling RSC\n"); } @@ -9745,7 +9758,8 @@ static int ixgbe_set_features(struct net_device *netdev, * Check if Flow Director n-tuple support or hw_tc support was * enabled or disabled. If the state changed, we need to reset. */ - if ((features & NETIF_F_NTUPLE) || (features & NETIF_F_HW_TC)) { + if (netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, features) || + netdev_feature_test_bit(NETIF_F_HW_TC_BIT, features)) { /* turn off ATR, enable perfect filters and reset */ if (!(adapter->flags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE)) need_reset = true; @@ -9772,17 +9786,19 @@ static int ixgbe_set_features(struct net_device *netdev, adapter->flags |= IXGBE_FLAG_FDIR_HASH_CAPABLE; }

- if (changed & NETIF_F_RXALL) + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, changed)) need_reset = true;

- netdev->features = features; + netdev_feature_copy(&netdev->features, features);

- if ((changed & NETIF_F_HW_L2FW_DOFFLOAD) && adapter->num_rx_pools > 1) + if (netdev_feature_test_bit(NETIF_F_HW_L2FW_DOFFLOAD_BIT, changed) && + adapter->num_rx_pools > 1) ixgbe_reset_l2fw_offload(adapter); else if (need_reset) ixgbe_do_reset(netdev); - else if (changed & (NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_FILTER)) + else if (netdev_feature_test_bits(NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_FILTER, + changed)) ixgbe_set_rx_mode(netdev);

return 1; @@ -10073,22 +10089,24 @@ static void ixgbe_features_check(struct sk_buff *skb, struct net_device *dev, /* Make certain the headers can be described by a context descriptor */ mac_hdr_len = skb_network_header(skb) - skb->data; if (unlikely(mac_hdr_len > IXGBE_MAX_MAC_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_GSO_UDP_L4 | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_GSO_UDP_L4 | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

network_hdr_len = skb_checksum_start(skb) - skb_network_header(skb); if (unlikely(network_hdr_len > IXGBE_MAX_NETWORK_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_GSO_UDP_L4 | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_GSO_UDP_L4 | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

@@ -10097,11 +10115,12 @@ static void ixgbe_features_check(struct sk_buff *skb, struct net_device *dev, * IPsec offoad sets skb->encapsulation but still can handle * the TSO, so it's the exception. */ - if (skb->encapsulation && !(*features & NETIF_F_TSO_MANGLEID)) { + if (skb->encapsulation && + !netdev_feature_test_bit(NETIF_F_TSO_MANGLEID_BIT, *features)) { #ifdef CONFIG_IXGBE_IPSEC if (!secpath_exists(skb)) #endif - *features &= ~NETIF_F_TSO; + netdev_feature_clear_bit(NETIF_F_TSO_BIT, features); } }

@@ -10787,12 +10806,14 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent) skip_sriov:

#endif - netdev->features = NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_RXHASH | - NETIF_F_RXCSUM | - NETIF_F_HW_CSUM; + netdev_feature_zero(&netdev->features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_RXHASH | + NETIF_F_RXCSUM | + NETIF_F_HW_CSUM, + &netdev->features);

#define IXGBE_GSO_PARTIAL_FEATURES (NETIF_F_GSO_GRE | \ NETIF_F_GSO_GRE_CSUM | \ @@ -10801,12 +10822,17 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent) NETIF_F_GSO_UDP_TUNNEL | \ NETIF_F_GSO_UDP_TUNNEL_CSUM)

- netdev->gso_partial_features = IXGBE_GSO_PARTIAL_FEATURES; - netdev->features |= NETIF_F_GSO_PARTIAL | - IXGBE_GSO_PARTIAL_FEATURES; + netdev_feature_zero(&netdev->gso_partial_features); + netdev_feature_set_bits(IXGBE_GSO_PARTIAL_FEATURES, + &netdev->gso_partial_features); + netdev_feature_set_bits(NETIF_F_GSO_PARTIAL | + IXGBE_GSO_PARTIAL_FEATURES, + &netdev->features);

if (hw->mac.type >= ixgbe_mac_82599EB) - netdev->features |= NETIF_F_SCTP_CRC | NETIF_F_GSO_UDP_L4; + netdev_feature_set_bits(NETIF_F_SCTP_CRC | + NETIF_F_GSO_UDP_L4, + &netdev->features);

#ifdef CONFIG_IXGBE_IPSEC #define IXGBE_ESP_FEATURES (NETIF_F_HW_ESP | \ @@ -10814,35 +10840,45 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent) NETIF_F_GSO_ESP)

if (adapter->ipsec) - netdev->features |= IXGBE_ESP_FEATURES; + netdev_feature_set_bits(IXGBE_ESP_FEATURES, &netdev->features); #endif /* copy netdev features into list of user selectable features */ - netdev->hw_features |= netdev->features | - NETIF_F_HW_VLAN_CTAG_FILTER | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_RXALL | - NETIF_F_HW_L2FW_DOFFLOAD; + netdev_feature_or(&netdev->hw_features, netdev->hw_features, + netdev->features); + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_FILTER | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_RXALL | + NETIF_F_HW_L2FW_DOFFLOAD, + &netdev->hw_features);

if (hw->mac.type >= ixgbe_mac_82599EB) - netdev->hw_features |= NETIF_F_NTUPLE | - NETIF_F_HW_TC; + netdev_feature_set_bits(NETIF_F_NTUPLE | + NETIF_F_HW_TC, + &netdev->hw_features);

if (pci_using_dac) - netdev->features |= NETIF_F_HIGHDMA; - - netdev->vlan_features |= netdev->features | NETIF_F_TSO_MANGLEID; - netdev->hw_enc_features |= netdev->vlan_features; - netdev->mpls_features |= NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_HW_CSUM; - netdev->mpls_features |= IXGBE_GSO_PARTIAL_FEATURES; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features); + + netdev_feature_or(&netdev->vlan_features, netdev->vlan_features, + netdev->features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->vlan_features); + netdev_feature_or(&netdev->hw_enc_features, netdev->hw_enc_features, + netdev->vlan_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_HW_CSUM, + &netdev->mpls_features); + netdev_feature_set_bits(IXGBE_GSO_PARTIAL_FEATURES, + &netdev->mpls_features);

/* set this bit last since it cannot be part of vlan_features */ - netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_FILTER | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX, + &netdev->features);

netdev->priv_flags |= IFF_UNICAST_FLT; netdev->priv_flags |= IFF_SUPP_NOFCS; @@ -10870,18 +10906,20 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent) fcoe_l = min_t(int, IXGBE_FCRETA_SIZE, num_online_cpus()); adapter->ring_feature[RING_F_FCOE].limit = fcoe_l;

- netdev->features |= NETIF_F_FSO | - NETIF_F_FCOE_CRC; + netdev_feature_set_bits(NETIF_F_FSO | + NETIF_F_FCOE_CRC, + &netdev->features);

- netdev->vlan_features |= NETIF_F_FSO | - NETIF_F_FCOE_CRC | - NETIF_F_FCOE_MTU; + netdev_feature_set_bits(NETIF_F_FSO | + NETIF_F_FCOE_CRC | + NETIF_F_FCOE_MTU, + &netdev->vlan_features); } #endif /* IXGBE_FCOE */ if (adapter->flags2 & IXGBE_FLAG2_RSC_CAPABLE) - netdev->hw_features |= NETIF_F_LRO; + netdev_feature_set_bit(NETIF_F_LRO_BIT, &netdev->hw_features); if (adapter->flags2 & IXGBE_FLAG2_RSC_ENABLED) - netdev->features |= NETIF_F_LRO; + netdev_feature_set_bit(NETIF_F_LRO_BIT, &netdev->features);

if (ixgbe_check_fw_error(adapter)) { err = -EIO; diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c index 214a38d..7a89d8e 100644 --- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c +++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c @@ -491,7 +491,8 @@ static int ixgbe_set_vf_lpe(struct ixgbe_adapter *adapter, u32 max_frame, u32 vf s32 err = 0;

#ifdef CONFIG_FCOE - if (dev->features & NETIF_F_FCOE_MTU) + if (netdev_feature_test_bit(NETIF_F_FCOE_MTU_BIT, + dev->features)) pf_max_frame = max_t(int, pf_max_frame, IXGBE_FCOE_JUMBO_FRAME_SIZE);

@@ -869,7 +870,8 @@ static int ixgbe_vf_reset_msg(struct ixgbe_adapter *adapter, u32 vf) int pf_max_frame = dev->mtu + ETH_HLEN;

#ifdef CONFIG_FCOE - if (dev->features & NETIF_F_FCOE_MTU) + if (netdev_feature_test_bit(NETIF_F_FCOE_MTU_BIT, + dev->features)) pf_max_frame = max_t(int, pf_max_frame, IXGBE_FCOE_JUMBO_FRAME_SIZE);

diff --git a/drivers/net/ethernet/intel/ixgbevf/ipsec.c b/drivers/net/ethernet/intel/ixgbevf/ipsec.c index e3e4676..60288ef 100644 --- a/drivers/net/ethernet/intel/ixgbevf/ipsec.c +++ b/drivers/net/ethernet/intel/ixgbevf/ipsec.c @@ -104,7 +104,8 @@ void ixgbevf_ipsec_restore(struct ixgbevf_adapter *adapter) struct net_device *netdev = adapter->netdev; int i;

- if (!(adapter->netdev->features & NETIF_F_HW_ESP)) + if (!netdev_feature_test_bit(NETIF_F_HW_ESP_BIT, + adapter->netdev->features)) return;

/* reload the Rx and Tx keys */ @@ -654,8 +655,10 @@ void ixgbevf_init_ipsec_offload(struct ixgbevf_adapter *adapter) NETIF_F_HW_ESP_TX_CSUM | \ NETIF_F_GSO_ESP)

- adapter->netdev->features |= IXGBEVF_ESP_FEATURES; - adapter->netdev->hw_enc_features |= IXGBEVF_ESP_FEATURES; + netdev_feature_set_bits(IXGBEVF_ESP_FEATURES, + &adapter->netdev->features); + netdev_feature_set_bits(IXGBEVF_ESP_FEATURES, + &adapter->netdev->hw_enc_features);

return;

diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c index f2f6d00..f3d7e74 100644 --- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c +++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c @@ -444,7 +444,8 @@ static inline void ixgbevf_rx_hash(struct ixgbevf_ring *ring, { u16 rss_type;

- if (!(ring->netdev->features & NETIF_F_RXHASH)) + if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, + ring->netdev->features)) return;

rss_type = le16_to_cpu(rx_desc->wb.lower.lo_dword.hs_rss.pkt_info) & @@ -471,7 +472,8 @@ static inline void ixgbevf_rx_checksum(struct ixgbevf_ring *ring, skb_checksum_none_assert(skb);

/* Rx csum disabled */ - if (!(ring->netdev->features & NETIF_F_RXCSUM)) + if (!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + ring->netdev->features)) return;

/* if IP and error */ @@ -742,7 +744,8 @@ static bool ixgbevf_cleanup_headers(struct ixgbevf_ring *rx_ring, IXGBE_RXDADV_ERR_FRAME_ERR_MASK))) { struct net_device *netdev = rx_ring->netdev;

- if (!(netdev->features & NETIF_F_RXALL)) { + if (!netdev_feature_test_bit(NETIF_F_RXALL_BIT, + netdev->features)) { dev_kfree_skb_any(skb); return true; } @@ -4389,28 +4392,31 @@ static void ixgbevf_features_check(struct sk_buff *skb, struct net_device *dev, /* Make certain the headers can be described by a context descriptor */ mac_hdr_len = skb_network_header(skb) - skb->data; if (unlikely(mac_hdr_len > IXGBEVF_MAX_MAC_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

network_hdr_len = skb_checksum_start(skb) - skb_network_header(skb); if (unlikely(network_hdr_len > IXGBEVF_MAX_NETWORK_HDR_LEN)) { - *features &= ~(NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC | - NETIF_F_TSO | - NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC | + NETIF_F_TSO | + NETIF_F_TSO6, + features); return; }

/* We can only support IPV4 TSO in tunnels if we can mangle the * inner IP ID field, so strip TSO if MANGLEID is not supported. */ - if (skb->encapsulation && !(*features & NETIF_F_TSO_MANGLEID)) - *features &= ~NETIF_F_TSO; + if (skb->encapsulation && + !netdev_feature_test_bit(NETIF_F_TSO_MANGLEID_BIT, *features)) + netdev_feature_clear_bit(NETIF_F_TSO_BIT, features); }

static int ixgbevf_xdp_setup(struct net_device *dev, struct bpf_prog *prog) @@ -4581,12 +4587,14 @@ static int ixgbevf_probe(struct pci_dev *pdev, const struct pci_device_id *ent) goto err_sw_init; }

- netdev->hw_features = NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_RXCSUM | - NETIF_F_HW_CSUM | - NETIF_F_SCTP_CRC; + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_RXCSUM | + NETIF_F_HW_CSUM | + NETIF_F_SCTP_CRC, + &netdev->hw_features);

#define IXGBEVF_GSO_PARTIAL_FEATURES (NETIF_F_GSO_GRE | \ NETIF_F_GSO_GRE_CSUM | \ @@ -4595,27 +4603,37 @@ static int ixgbevf_probe(struct pci_dev *pdev, const struct pci_device_id *ent) NETIF_F_GSO_UDP_TUNNEL | \ NETIF_F_GSO_UDP_TUNNEL_CSUM)

- netdev->gso_partial_features = IXGBEVF_GSO_PARTIAL_FEATURES; - netdev->hw_features |= NETIF_F_GSO_PARTIAL | - IXGBEVF_GSO_PARTIAL_FEATURES; + netdev_feature_zero(&netdev->gso_partial_features); + netdev_feature_set_bits(IXGBEVF_GSO_PARTIAL_FEATURES, + &netdev->gso_partial_features); + netdev_feature_set_bits(NETIF_F_GSO_PARTIAL | + IXGBEVF_GSO_PARTIAL_FEATURES, + &netdev->hw_features);

- netdev->features = netdev->hw_features; + netdev_feature_copy(&netdev->features, netdev->hw_features);

if (pci_using_dac) - netdev->features |= NETIF_F_HIGHDMA; - - netdev->vlan_features |= netdev->features | NETIF_F_TSO_MANGLEID; - netdev->mpls_features |= NETIF_F_SG | - NETIF_F_TSO | - NETIF_F_TSO6 | - NETIF_F_HW_CSUM; - netdev->mpls_features |= IXGBEVF_GSO_PARTIAL_FEATURES; - netdev->hw_enc_features |= netdev->vlan_features; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features); + + netdev_feature_or(&netdev->vlan_features, netdev->vlan_features, + netdev->features); + netdev_feature_set_bit(NETIF_F_TSO_MANGLEID_BIT, + &netdev->vlan_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_TSO | + NETIF_F_TSO6 | + NETIF_F_HW_CSUM, + &netdev->mpls_features); + netdev_feature_set_bits(IXGBEVF_GSO_PARTIAL_FEATURES, + &netdev->mpls_features); + netdev_feature_or(&netdev->hw_enc_features, netdev->hw_enc_features, + netdev->vlan_features);

/* set this bit last since it cannot be part of vlan_features */ - netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_set_bits(NETIF_F_HW_VLAN_CTAG_FILTER | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_TX, + &netdev->features);

netdev->priv_flags |= IFF_UNICAST_FLT;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ethernet/mellanox/mlx4/en_ethtool.c | 4 +- drivers/net/ethernet/mellanox/mlx4/en_main.c | 8 +- drivers/net/ethernet/mellanox/mlx4/en_netdev.c | 181 +++++++++++------- drivers/net/ethernet/mellanox/mlx4/en_resources.c | 4 +- drivers/net/ethernet/mellanox/mlx4/en_rx.c | 19 +- drivers/net/ethernet/mellanox/mlx4/mlx4_en.h | 5 +- .../ethernet/mellanox/mlx5/core/en_accel/ipsec.c | 18 +- .../mellanox/mlx5/core/en_accel/ipsec_rxtx.h | 8 +- .../ethernet/mellanox/mlx5/core/en_accel/ktls.c | 15 +- .../net/ethernet/mellanox/mlx5/core/en_accel/tls.c | 16 +- drivers/net/ethernet/mellanox/mlx5/core/en_arfs.c | 6 +- .../net/ethernet/mellanox/mlx5/core/en_ethtool.c | 3 +- drivers/net/ethernet/mellanox/mlx5/core/en_fs.c | 3 +- drivers/net/ethernet/mellanox/mlx5/core/en_main.c | 205 ++++++++++++--------- drivers/net/ethernet/mellanox/mlx5/core/en_rep.c | 25 +-- drivers/net/ethernet/mellanox/mlx5/core/en_rx.c | 9 +- drivers/net/ethernet/mellanox/mlx5/core/en_tc.c | 2 +- .../net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c | 19 +- drivers/net/ethernet/mellanox/mlxsw/spectrum.c | 36 ++-- 19 files changed, 344 insertions(+), 242 deletions(-)

diff --git a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c index 3616b77..56de7d3 100644 --- a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c +++ b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c @@ -1233,13 +1233,13 @@ static int mlx4_en_check_rxfh_func(struct net_device *dev, u8 hfunc) if (hfunc == ETH_RSS_HASH_TOP) { if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RSS_TOP)) return -EINVAL; - if (!(dev->features & NETIF_F_RXHASH)) + if (!netdev_feature_test_bit(NETIF_F_RXHASH_BIT, dev->features)) en_warn(priv, "Toeplitz hash function should be used in conjunction with RX hashing for optimal performance\n"); return 0; } else if (hfunc == ETH_RSS_HASH_XOR) { if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RSS_XOR)) return -EINVAL; - if (dev->features & NETIF_F_RXHASH) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, dev->features)) en_warn(priv, "Enabling both XOR Hash function and RX Hashing can limit RPS functionality\n"); return 0; } diff --git a/drivers/net/ethernet/mellanox/mlx4/en_main.c b/drivers/net/ethernet/mellanox/mlx4/en_main.c index 109472d..6762fff 100644 --- a/drivers/net/ethernet/mellanox/mlx4/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx4/en_main.c @@ -103,7 +103,7 @@ void mlx4_en_update_loopback_state(struct net_device *dev, { struct mlx4_en_priv *priv = netdev_priv(dev);

- if (features & NETIF_F_LOOPBACK) + if (netdev_feature_test_bit(NETIF_F_LOOPBACK_BIT, features)) priv->ctrl_flags |= cpu_to_be32(MLX4_WQE_CTRL_FORCE_LOOPBACK); else priv->ctrl_flags &= cpu_to_be32(~MLX4_WQE_CTRL_FORCE_LOOPBACK); @@ -115,7 +115,8 @@ void mlx4_en_update_loopback_state(struct net_device *dev, * and not performing the selftest or flb disabled */ if (mlx4_is_mfunc(priv->mdev->dev) && - !(features & NETIF_F_LOOPBACK) && !priv->validate_loopback) + !netdev_feature_test_bit(NETIF_F_LOOPBACK_BIT, features) && + !priv->validate_loopback) priv->flags |= MLX4_EN_FLAG_RX_FILTER_NEEDED;

/* Set dmac in Tx WQE if we are in SRIOV mode or if loopback selftest @@ -130,7 +131,8 @@ void mlx4_en_update_loopback_state(struct net_device *dev, priv->rss_map.indir_qp && priv->rss_map.indir_qp->qpn) { int i; int err = 0; - int loopback = !!(features & NETIF_F_LOOPBACK); + int loopback = netdev_feature_test_bit(NETIF_F_LOOPBACK_BIT, + features);

for (i = 0; i < priv->rx_ring_num; i++) { int ret; diff --git a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c index 06bc81d..f0bb981 100644 --- a/drivers/net/ethernet/mellanox/mlx4/en_netdev.c +++ b/drivers/net/ethernet/mellanox/mlx4/en_netdev.c @@ -2489,11 +2489,11 @@ static void mlx4_en_fix_features(struct net_device *netdev, * enable/disable make sure S-TAG flag is always in same state as * C-TAG. */ - if (*features & NETIF_F_HW_VLAN_CTAG_RX && + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features) && !(mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_SKIP_OUTER_VLAN)) - *features |= NETIF_F_HW_VLAN_STAG_RX; + netdev_feature_set_bit(NETIF_F_HW_VLAN_STAG_RX_BIT, features); else - *features &= ~NETIF_F_HW_VLAN_STAG_RX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_STAG_RX_BIT, features); }

static int mlx4_en_set_features(struct net_device *netdev, @@ -2503,14 +2503,16 @@ static int mlx4_en_set_features(struct net_device *netdev, bool reset = false; int ret = 0;

- if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_RXFCS)) { + if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_RXFCS_BIT)) { en_info(priv, "Turn %s RX-FCS\n", - (features & NETIF_F_RXFCS) ? "ON" : "OFF"); + netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + features) ? "ON" : "OFF"); reset = true; }

- if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_RXALL)) { - u8 ignore_fcs_value = (features & NETIF_F_RXALL) ? 1 : 0; + if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_RXALL_BIT)) { + u8 ignore_fcs_value = netdev_feature_test_bit(NETIF_F_RXALL_BIT, + features) ? 1 : 0;

en_info(priv, "Turn %s RX-ALL\n", ignore_fcs_value ? "ON" : "OFF"); @@ -2520,23 +2522,27 @@ static int mlx4_en_set_features(struct net_device *netdev, return ret; }

- if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_CTAG_RX)) { + if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_CTAG_RX_BIT)) { en_info(priv, "Turn %s RX vlan strip offload\n", - (features & NETIF_F_HW_VLAN_CTAG_RX) ? "ON" : "OFF"); + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features) ? "ON" : "OFF"); reset = true; }

- if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_CTAG_TX)) + if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_CTAG_TX_BIT)) en_info(priv, "Turn %s TX vlan strip offload\n", - (features & NETIF_F_HW_VLAN_CTAG_TX) ? "ON" : "OFF"); + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features) ? "ON" : "OFF");

- if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_STAG_TX)) + if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_HW_VLAN_STAG_TX_BIT)) en_info(priv, "Turn %s TX S-VLAN strip offload\n", - (features & NETIF_F_HW_VLAN_STAG_TX) ? "ON" : "OFF"); + netdev_feature_test_bit(NETIF_F_HW_VLAN_STAG_TX_BIT, + features) ? "ON" : "OFF");

- if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_LOOPBACK)) { + if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_LOOPBACK_BIT)) { en_info(priv, "Turn %s loopback\n", - (features & NETIF_F_LOOPBACK) ? "ON" : "OFF"); + netdev_feature_test_bit(NETIF_F_LOOPBACK_BIT, + features) ? "ON" : "OFF"); mlx4_en_update_loopback_state(netdev, features); }

@@ -2675,7 +2681,8 @@ static void mlx4_en_features_check(struct sk_buff *skb, struct net_device *dev, if (!priv->vxlan_port || (ip_hdr(skb)->version != 4) || (udp_hdr(skb)->dest != priv->vxlan_port)) - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | + NETIF_F_GSO_MASK, features); } }

@@ -3301,42 +3308,59 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, /* * Set driver features */ - dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; + netdev_feature_zero(&dev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_IP_CSUM | + NETIF_F_IPV6_CSUM, &dev->hw_features); if (mdev->LSO_support) - dev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6; + netdev_feature_set_bits(NETIF_F_TSO | NETIF_F_TSO6, + &dev->hw_features);

if (mdev->dev->caps.tunnel_offload_mode == MLX4_TUNNEL_OFFLOAD_MODE_VXLAN) { - dev->hw_features |= NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_GSO_UDP_TUNNEL_CSUM | - NETIF_F_GSO_PARTIAL; - dev->features |= NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_GSO_UDP_TUNNEL_CSUM | - NETIF_F_GSO_PARTIAL; - dev->gso_partial_features = NETIF_F_GSO_UDP_TUNNEL_CSUM; - dev->hw_enc_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | - NETIF_F_RXCSUM | - NETIF_F_TSO | NETIF_F_TSO6 | - NETIF_F_GSO_UDP_TUNNEL | - NETIF_F_GSO_UDP_TUNNEL_CSUM | - NETIF_F_GSO_PARTIAL; + netdev_feature_set_bits(NETIF_F_GSO_UDP_TUNNEL | + NETIF_F_GSO_UDP_TUNNEL_CSUM | + NETIF_F_GSO_PARTIAL, + &dev->hw_features); + netdev_feature_set_bits(NETIF_F_GSO_UDP_TUNNEL | + NETIF_F_GSO_UDP_TUNNEL_CSUM | + NETIF_F_GSO_PARTIAL, + &dev->features); + netdev_feature_zero(&dev->gso_partial_features); + netdev_feature_set_bit(NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT, + &dev->gso_partial_features); + netdev_feature_zero(&dev->hw_enc_features); + netdev_feature_set_bits(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | + NETIF_F_RXCSUM | + NETIF_F_TSO | NETIF_F_TSO6 | + NETIF_F_GSO_UDP_TUNNEL | + NETIF_F_GSO_UDP_TUNNEL_CSUM | + NETIF_F_GSO_PARTIAL, + &dev->hw_enc_features);

dev->udp_tunnel_nic_info = &mlx4_udp_tunnels; }

- dev->vlan_features = dev->hw_features; + netdev_feature_copy(&dev->vlan_features, dev->hw_features);

- dev->hw_features |= NETIF_F_RXCSUM | NETIF_F_RXHASH; - dev->features = dev->hw_features | NETIF_F_HIGHDMA | - NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_CTAG_FILTER; - dev->hw_features |= NETIF_F_LOOPBACK | - NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_set_bits(NETIF_F_RXCSUM | NETIF_F_RXHASH, + &dev->hw_features); + netdev_feature_copy(&dev->features, dev->hw_features); + netdev_feature_set_bits(NETIF_F_HIGHDMA | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_CTAG_FILTER, + &dev->features); + netdev_feature_set_bits(NETIF_F_LOOPBACK | + NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX, + &dev->hw_features);

if (!(mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_SKIP_OUTER_VLAN)) { - dev->features |= NETIF_F_HW_VLAN_STAG_RX | - NETIF_F_HW_VLAN_STAG_FILTER; - dev->hw_features |= NETIF_F_HW_VLAN_STAG_RX; + netdev_feature_set_bits(NETIF_F_HW_VLAN_STAG_RX | + NETIF_F_HW_VLAN_STAG_FILTER, + &dev->features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_STAG_RX_BIT, + &dev->hw_features); }

if (mlx4_is_slave(mdev->dev)) { @@ -3345,38 +3369,43 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,

err = get_phv_bit(mdev->dev, port, &phv); if (!err && phv) { - dev->hw_features |= NETIF_F_HW_VLAN_STAG_TX; + netdev_feature_set_bit(NETIF_F_HW_VLAN_STAG_TX_BIT, + &dev->hw_features); priv->pflags |= MLX4_EN_PRIV_FLAGS_PHV; } err = mlx4_get_is_vlan_offload_disabled(mdev->dev, port, &vlan_offload_disabled); if (!err && vlan_offload_disabled) { - dev->hw_features &= ~(NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_STAG_TX | - NETIF_F_HW_VLAN_STAG_RX); - dev->features &= ~(NETIF_F_HW_VLAN_CTAG_TX | - NETIF_F_HW_VLAN_CTAG_RX | - NETIF_F_HW_VLAN_STAG_TX | - NETIF_F_HW_VLAN_STAG_RX); + netdev_feature_clear_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_STAG_TX | + NETIF_F_HW_VLAN_STAG_RX | + NETIF_F_HW_VLAN_STAG_FILTER, + &dev->hw_features); + netdev_feature_clear_bits(NETIF_F_HW_VLAN_CTAG_TX | + NETIF_F_HW_VLAN_CTAG_RX | + NETIF_F_HW_VLAN_STAG_TX | + NETIF_F_HW_VLAN_STAG_RX, + &dev->features); } } else { if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_PHV_EN && !(mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_SKIP_OUTER_VLAN)) - dev->hw_features |= NETIF_F_HW_VLAN_STAG_TX; + netdev_feature_set_bit(NETIF_F_HW_VLAN_STAG_TX_BIT, + &dev->hw_features); }

if (mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_FCS_KEEP) - dev->hw_features |= NETIF_F_RXFCS; + netdev_feature_set_bit(NETIF_F_RXFCS_BIT, &dev->hw_features);

if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_IGNORE_FCS) - dev->hw_features |= NETIF_F_RXALL; + netdev_feature_set_bit(NETIF_F_RXALL_BIT, &dev->hw_features);

if (mdev->dev->caps.steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED && mdev->dev->caps.dmfs_high_steer_mode != MLX4_STEERING_DMFS_A0_STATIC) - dev->hw_features |= NETIF_F_NTUPLE; + netdev_feature_set_bit(NETIF_F_NTUPLE_BIT, &dev->hw_features);

if (mdev->dev->caps.steering_mode != MLX4_STEERING_MODE_A0) dev->priv_flags |= IFF_UNICAST_FLT; @@ -3480,12 +3509,12 @@ int mlx4_en_reset_config(struct net_device *dev,

if (priv->hwtstamp_config.tx_type == ts_config.tx_type && priv->hwtstamp_config.rx_filter == ts_config.rx_filter && - !DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX) && - !DEV_FEATURE_CHANGED(dev, features, NETIF_F_RXFCS)) + !DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX_BIT) && + !DEV_FEATURE_CHANGED(dev, features, NETIF_F_RXFCS_BIT)) return 0; /* Nothing to change */

- if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX) && - (features & NETIF_F_HW_VLAN_CTAG_RX) && + if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX_BIT) && + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features) && (priv->hwtstamp_config.rx_filter != HWTSTAMP_FILTER_NONE)) { en_warn(priv, "Can't turn ON rx vlan offload while time-stamping rx filter is ON\n"); return -EINVAL; @@ -3511,26 +3540,34 @@ int mlx4_en_reset_config(struct net_device *dev,

mlx4_en_safe_replace_resources(priv, tmp);

- if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX)) { - if (features & NETIF_F_HW_VLAN_CTAG_RX) - dev->features |= NETIF_F_HW_VLAN_CTAG_RX; + if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX_BIT)) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &dev->features); else - dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &dev->features); } else if (ts_config.rx_filter == HWTSTAMP_FILTER_NONE) { /* RX time-stamping is OFF, update the RX vlan offload * to the latest wanted state */ - if (dev->wanted_features & NETIF_F_HW_VLAN_CTAG_RX) - dev->features |= NETIF_F_HW_VLAN_CTAG_RX; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->wanted_features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &dev->features); else - dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &dev->features); }

- if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_RXFCS)) { - if (features & NETIF_F_RXFCS) - dev->features |= NETIF_F_RXFCS; + if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_RXFCS_BIT)) { + if (netdev_feature_test_bit(NETIF_F_RXFCS_BIT, features)) + netdev_feature_set_bit(NETIF_F_RXFCS_BIT, + &dev->features); else - dev->features &= ~NETIF_F_RXFCS; + netdev_feature_clear_bit(NETIF_F_RXFCS_BIT, + &dev->features); }

/* RX vlan offload and RX time-stamping can't co-exist ! @@ -3538,9 +3575,11 @@ int mlx4_en_reset_config(struct net_device *dev, * Turn Off RX vlan offload in case of time-stamping is ON */ if (ts_config.rx_filter != HWTSTAMP_FILTER_NONE) { - if (dev->features & NETIF_F_HW_VLAN_CTAG_RX) + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->features)) en_warn(priv, "Turning off RX vlan offload since RX time-stamping is ON\n"); - dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &dev->features); }

if (port_up) { diff --git a/drivers/net/ethernet/mellanox/mlx4/en_resources.c b/drivers/net/ethernet/mellanox/mlx4/en_resources.c index 6883ac7..8539d39 100644 --- a/drivers/net/ethernet/mellanox/mlx4/en_resources.c +++ b/drivers/net/ethernet/mellanox/mlx4/en_resources.c @@ -76,12 +76,12 @@ void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride, context->pri_path.counter_index != MLX4_SINK_COUNTER_INDEX(mdev->dev)) { /* disable multicast loopback to qp with same counter */ - if (!(dev->features & NETIF_F_LOOPBACK)) + if (!netdev_feature_test_bit(NETIF_F_LOOPBACK_BIT, dev->features)) context->pri_path.fl |= MLX4_FL_ETH_SRC_CHECK_MC_LB; context->pri_path.control |= MLX4_CTRL_ETH_SRC_CHECK_IF_COUNTER; } context->db_rec_addr = cpu_to_be64(priv->res.db.dma << 2); - if (!(dev->features & NETIF_F_HW_VLAN_CTAG_RX)) + if (!netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, dev->features)) context->param3 |= cpu_to_be32(1 << 30);

if (!is_tx && !rss && diff --git a/drivers/net/ethernet/mellanox/mlx4/en_rx.c b/drivers/net/ethernet/mellanox/mlx4/en_rx.c index 442991d..3b50063 100644 --- a/drivers/net/ethernet/mellanox/mlx4/en_rx.c +++ b/drivers/net/ethernet/mellanox/mlx4/en_rx.c @@ -643,7 +643,8 @@ static int check_csum(struct mlx4_cqe *cqe, struct sk_buff *skb, void *va, hw_checksum = csum_unfold((__force __sum16)cqe->checksum);

if (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_CVLAN_PRESENT_MASK) && - !(dev_features & NETIF_F_HW_VLAN_CTAG_RX)) { + !netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev_features)) { hw_checksum = get_fixed_vlan_csum(hw_checksum, hdr); hdr += sizeof(struct vlan_hdr); } @@ -827,7 +828,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud } skb_record_rx_queue(skb, cq_ring);

- if (likely(dev->features & NETIF_F_RXCSUM)) { + if (likely(netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, dev->features))) { /* TODO: For IP non TCP/UDP packets when csum complete is * not an option (not supported or any other reason) we can * actually check cqe IPOK status bit and report @@ -839,7 +840,8 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud cqe->checksum == cpu_to_be16(0xffff)) { bool l2_tunnel;

- l2_tunnel = (dev->hw_enc_features & NETIF_F_RXCSUM) && + l2_tunnel = netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + dev->hw_enc_features) && (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_L2_TUNNEL)); ip_summed = CHECKSUM_UNNECESSARY; hash_type = PKT_HASH_TYPE_L4; @@ -863,19 +865,21 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud ring->csum_none++; } skb->ip_summed = ip_summed; - if (dev->features & NETIF_F_RXHASH) + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, dev->features)) skb_set_hash(skb, be32_to_cpu(cqe->immed_rss_invalid), hash_type);

if ((cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_CVLAN_PRESENT_MASK)) && - (dev->features & NETIF_F_HW_VLAN_CTAG_RX)) + netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + dev->features)) __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), be16_to_cpu(cqe->sl_vid)); else if ((cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_SVLAN_PRESENT_MASK)) && - (dev->features & NETIF_F_HW_VLAN_STAG_RX)) + netdev_feature_test_bit(NETIF_F_HW_VLAN_STAG_RX_BIT, + dev->features)) __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021AD), be16_to_cpu(cqe->sl_vid));

@@ -1071,7 +1075,8 @@ static int mlx4_en_config_rss_qp(struct mlx4_en_priv *priv, int qpn, /* Cancel FCS removal if FW allows */ if (mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_FCS_KEEP) { context->param3 |= cpu_to_be32(1 << 29); - if (priv->dev->features & NETIF_F_RXFCS) + if (netdev_feature_test_bit(NETIF_F_RXFCS_BIT, + priv->dev->features)) ring->fcs_del = 0; else ring->fcs_del = ETH_FCS_LEN; diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h index f3d1a20..5569f77 100644 --- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h +++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h @@ -772,8 +772,9 @@ void mlx4_en_cleanup_filters(struct mlx4_en_priv *priv); void mlx4_en_ex_selftest(struct net_device *dev, u32 *flags, u64 *buf); void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev);

-#define DEV_FEATURE_CHANGED(dev, new_features, feature) \ - ((dev->features & feature) ^ (new_features & feature)) +#define DEV_FEATURE_CHANGED(dev, new_features, feature_bit) \ + (netdev_feature_test_bit(feature_bit, (dev)->features) != \ + netdev_feature_test_bit(feature_bit, new_features))

int mlx4_en_moderation_update(struct mlx4_en_priv *priv); int mlx4_en_reset_config(struct net_device *dev, diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c index 7cab08a..b703ea3 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec.c @@ -540,16 +540,17 @@ void mlx5e_ipsec_build_netdev(struct mlx5e_priv *priv)

mlx5_core_info(mdev, "mlx5e: IPSec ESP acceleration enabled\n"); netdev->xfrmdev_ops = &mlx5e_ipsec_xfrmdev_ops; - netdev->features |= NETIF_F_HW_ESP; - netdev->hw_enc_features |= NETIF_F_HW_ESP; + netdev_feature_set_bit(NETIF_F_HW_ESP_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HW_ESP_BIT, &netdev->hw_enc_features);

if (!MLX5_CAP_ETH(mdev, swp_csum)) { mlx5_core_dbg(mdev, "mlx5e: SWP checksum not supported\n"); return; }

- netdev->features |= NETIF_F_HW_ESP_TX_CSUM; - netdev->hw_enc_features |= NETIF_F_HW_ESP_TX_CSUM; + netdev_feature_set_bit(NETIF_F_HW_ESP_TX_CSUM_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HW_ESP_TX_CSUM_BIT, + &netdev->hw_enc_features);

if (!(mlx5_accel_ipsec_device_caps(mdev) & MLX5_ACCEL_IPSEC_CAP_LSO) || !MLX5_CAP_ETH(mdev, swp_lso)) { @@ -558,10 +559,11 @@ void mlx5e_ipsec_build_netdev(struct mlx5e_priv *priv) }

if (mlx5_is_ipsec_device(mdev)) - netdev->gso_partial_features |= NETIF_F_GSO_ESP; + netdev_feature_set_bit(NETIF_F_GSO_ESP_BIT, + &netdev->gso_partial_features);

mlx5_core_dbg(mdev, "mlx5e: ESP GSO capability turned on\n"); - netdev->features |= NETIF_F_GSO_ESP; - netdev->hw_features |= NETIF_F_GSO_ESP; - netdev->hw_enc_features |= NETIF_F_GSO_ESP; + netdev_feature_set_bit(NETIF_F_GSO_ESP_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_GSO_ESP_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_GSO_ESP_BIT, &netdev->hw_enc_features); } diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h index 62ab97c..b0e92a7 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_rxtx.h @@ -123,7 +123,8 @@ mlx5e_ipsec_feature_check(struct sk_buff *skb, netdev_features_t *features)

/* Disable CSUM and GSO for software IPsec */ out_disable: - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); }

#else @@ -141,7 +142,10 @@ static inline bool mlx5e_ipsec_eseg_meta(struct mlx5_wqe_eth_seg *eseg) static inline bool mlx5_ipsec_is_rx_flow(struct mlx5_cqe64 *cqe) { return false; } static inline void mlx5e_ipsec_feature_check(struct sk_buff *skb, netdev_features_t *features) -{ *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); } +{ + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); +} #endif /* CONFIG_MLX5_EN_IPSEC */

#endif /* __MLX5E_IPSEC_RXTX_H__ */ diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.c b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.c index d93aadb..fcac1a2 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.c @@ -63,12 +63,15 @@ void mlx5e_ktls_build_netdev(struct mlx5e_priv *priv) return;

if (mlx5e_accel_is_ktls_tx(mdev)) { - netdev->hw_features |= NETIF_F_HW_TLS_TX; - netdev->features |= NETIF_F_HW_TLS_TX; + netdev_feature_set_bit(NETIF_F_HW_TLS_TX_BIT, + &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_TLS_TX_BIT, + &netdev->features); }

if (mlx5e_accel_is_ktls_rx(mdev)) - netdev->hw_features |= NETIF_F_HW_TLS_RX; + netdev_feature_set_bit(NETIF_F_HW_TLS_RX_BIT, + &netdev->hw_features);

netdev->tlsdev_ops = &mlx5e_ktls_ops; } @@ -99,7 +102,8 @@ int mlx5e_ktls_init_rx(struct mlx5e_priv *priv) if (!priv->tls->rx_wq) return -ENOMEM;

- if (priv->netdev->features & NETIF_F_HW_TLS_RX) { + if (netdev_feature_set_bit(NETIF_F_HW_TLS_RX_BIT, + &priv->netdev->features)) { err = mlx5e_accel_fs_tcp_create(priv); if (err) { destroy_workqueue(priv->tls->rx_wq); @@ -115,7 +119,8 @@ void mlx5e_ktls_cleanup_rx(struct mlx5e_priv *priv) if (!mlx5e_accel_is_ktls_rx(priv->mdev)) return;

- if (priv->netdev->features & NETIF_F_HW_TLS_RX) + if (netdev_feature_set_bit(NETIF_F_HW_TLS_RX_BIT, + &priv->netdev->features)) mlx5e_accel_fs_tcp_destroy(priv);

destroy_workqueue(priv->tls->rx_wq); diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/tls.c b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/tls.c index b8fc863..bd29987 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/tls.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/tls.c @@ -203,18 +203,22 @@ void mlx5e_tls_build_netdev(struct mlx5e_priv *priv)

caps = mlx5_accel_tls_device_caps(priv->mdev); if (caps & MLX5_ACCEL_TLS_TX) { - netdev->features |= NETIF_F_HW_TLS_TX; - netdev->hw_features |= NETIF_F_HW_TLS_TX; + netdev_feature_set_bit(NETIF_F_HW_TLS_TX_BIT, + &netdev->features); + netdev_feature_set_bit(NETIF_F_HW_TLS_TX_BIT, + &netdev->hw_features); }

if (caps & MLX5_ACCEL_TLS_RX) { - netdev->features |= NETIF_F_HW_TLS_RX; - netdev->hw_features |= NETIF_F_HW_TLS_RX; + netdev_feature_set_bit(NETIF_F_HW_TLS_RX_BIT, + &netdev->features); + netdev_feature_set_bit(NETIF_F_HW_TLS_RX_BIT, + &netdev->hw_features); }

if (!(caps & MLX5_ACCEL_TLS_LRO)) { - netdev->features &= ~NETIF_F_LRO; - netdev->hw_features &= ~NETIF_F_LRO; + netdev_feature_clear_bit(NETIF_F_LRO_BIT, &netdev->features); + netdev_feature_clear_bit(NETIF_F_LRO_BIT, &netdev->hw_features); }

netdev->tlsdev_ops = &mlx5e_tls_ops; diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_arfs.c b/drivers/net/ethernet/mellanox/mlx5/core/en_arfs.c index fe5d82f..ce62ed5 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_arfs.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_arfs.c @@ -181,7 +181,8 @@ static void _mlx5e_cleanup_tables(struct mlx5e_priv *priv)

void mlx5e_arfs_destroy_tables(struct mlx5e_priv *priv) { - if (!(priv->netdev->hw_features & NETIF_F_NTUPLE)) + if (!netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, + priv->netdev->hw_features)) return;

_mlx5e_cleanup_tables(priv); @@ -358,7 +359,8 @@ int mlx5e_arfs_create_tables(struct mlx5e_priv *priv) int err = -ENOMEM; int i;

- if (!(priv->netdev->hw_features & NETIF_F_NTUPLE)) + if (!netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, + priv->netdev->hw_features)) return 0;

priv->fs.arfs = kvzalloc(sizeof(*priv->fs.arfs), GFP_KERNEL); diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c index 2cf59bb..03b7fad5 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c @@ -460,7 +460,8 @@ int mlx5e_ethtool_set_channels(struct mlx5e_priv *priv,

opened = test_bit(MLX5E_STATE_OPENED, &priv->state);

- arfs_enabled = opened && (priv->netdev->features & NETIF_F_NTUPLE); + arfs_enabled = opened && netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, + priv->netdev->features); if (arfs_enabled) mlx5e_arfs_disable(priv);

diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c b/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c index 5c754e9..2cdab59 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_fs.c @@ -1286,7 +1286,8 @@ int mlx5e_create_flow_steering(struct mlx5e_priv *priv) if (err) { netdev_err(priv->netdev, "Failed to create arfs tables, err=%d\n", err); - priv->netdev->hw_features &= ~NETIF_F_NTUPLE; + netdev_feature_clear_bit(NETIF_F_NTUPLE_BIT, + &priv->netdev->hw_features); }

err = mlx5e_create_inner_ttc_table(priv); diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c index e70e8c5..4d0158e 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c @@ -3093,12 +3093,12 @@ static int mlx5e_set_mac(struct net_device *netdev, void *addr) return 0; }

-#define MLX5E_SET_FEATURE(features, feature, enable) \ - do { \ - if (enable) \ - *features |= feature; \ - else \ - *features &= ~feature; \ +#define MLX5E_SET_FEATURE(features, feature, enable) \ + do { \ + if (enable) \ + netdev_feature_set_bit(feature, features); \ + else \ + netdev_feature_clear_bit(feature, features); \ } while (0)

typedef int (*mlx5e_feature_handler)(struct net_device *netdev, bool enable); @@ -3240,49 +3240,56 @@ static int set_feature_arfs(struct net_device *netdev, bool enable) static int mlx5e_handle_feature(struct net_device *netdev, netdev_features_t *features, netdev_features_t wanted_features, - netdev_features_t feature, + u32 feature_bit, mlx5e_feature_handler feature_handler) { - netdev_features_t changes = wanted_features ^ netdev->features; - bool enable = !!(wanted_features & feature); + netdev_features_t changes; + bool enable; int err;

- if (!(changes & feature)) + netdev_feature_xor(&changes, wanted_features, netdev->features); + enable = netdev_feature_test_bit(feature_bit, wanted_features); + + if (!netdev_feature_test_bit(feature_bit, changes)) return 0;

err = feature_handler(netdev, enable); if (err) { - netdev_err(netdev, "%s feature %pNF failed, err %d\n", - enable ? "Enable" : "Disable", &feature, err); + netdev_err(netdev, "%s feature bit %u failed, err %d\n", + enable ? "Enable" : "Disable", feature_bit, err); return err; }

- MLX5E_SET_FEATURE(features, feature, enable); + MLX5E_SET_FEATURE(features, feature_bit, enable); return 0; }

int mlx5e_set_features(struct net_device *netdev, netdev_features_t features) { - netdev_features_t oper_features = netdev->features; + netdev_features_t oper_features; int err = 0;

+ netdev_feature_copy(&oper_features, netdev->features); + #define MLX5E_HANDLE_FEATURE(feature, handler) \ mlx5e_handle_feature(netdev, &oper_features, features, feature, handler)

- err |= MLX5E_HANDLE_FEATURE(NETIF_F_LRO, set_feature_lro); - err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_VLAN_CTAG_FILTER, + err |= MLX5E_HANDLE_FEATURE(NETIF_F_LRO_BIT, set_feature_lro); + err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, set_feature_cvlan_filter); - err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_TC, set_feature_hw_tc); - err |= MLX5E_HANDLE_FEATURE(NETIF_F_RXALL, set_feature_rx_all); - err |= MLX5E_HANDLE_FEATURE(NETIF_F_RXFCS, set_feature_rx_fcs); - err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_VLAN_CTAG_RX, set_feature_rx_vlan); + err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_TC_BIT, set_feature_hw_tc); + err |= MLX5E_HANDLE_FEATURE(NETIF_F_RXALL_BIT, set_feature_rx_all); + err |= MLX5E_HANDLE_FEATURE(NETIF_F_RXFCS_BIT, set_feature_rx_fcs); + err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_VLAN_CTAG_RX_BIT, + set_feature_rx_vlan); #ifdef CONFIG_MLX5_EN_ARFS - err |= MLX5E_HANDLE_FEATURE(NETIF_F_NTUPLE, set_feature_arfs); + err |= MLX5E_HANDLE_FEATURE(NETIF_F_NTUPLE_BIT, set_feature_arfs); #endif - err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_TLS_RX, mlx5e_ktls_set_feature_rx); + err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_TLS_RX_BIT, + mlx5e_ktls_set_feature_rx);

if (err) { - netdev->features = oper_features; + netdev_feature_copy(&netdev->features, oper_features); return -EINVAL; }

@@ -3292,16 +3299,16 @@ int mlx5e_set_features(struct net_device *netdev, netdev_features_t features) static void mlx5e_fix_uplink_rep_features(struct net_device *netdev, netdev_features_t *features) { - *features &= ~NETIF_F_HW_TLS_RX; - if (netdev->features & NETIF_F_HW_TLS_RX) + netdev_feature_clear_bit(NETIF_F_HW_TLS_RX_BIT, features); + if (netdev_feature_test_bit(NETIF_F_HW_TLS_RX_BIT, netdev->features)) netdev_warn(netdev, "Disabling hw_tls_rx, not supported in switchdev mode\n");

- *features &= ~NETIF_F_HW_TLS_TX; - if (netdev->features & NETIF_F_HW_TLS_TX) + netdev_feature_clear_bit(NETIF_F_HW_TLS_TX_BIT, features); + if (netdev_feature_test_bit(NETIF_F_HW_TLS_TX_BIT, netdev->features)) netdev_warn(netdev, "Disabling hw_tls_tx, not supported in switchdev mode\n");

- *features &= ~NETIF_F_NTUPLE; - if (netdev->features & NETIF_F_NTUPLE) + netdev_feature_clear_bit(NETIF_F_NTUPLE_BIT, features); + if (netdev_feature_test_bit(NETIF_F_NTUPLE_BIT, netdev->features)) netdev_warn(netdev, "Disabling ntuple, not supported in switchdev mode\n"); }

@@ -3318,26 +3325,26 @@ static void mlx5e_fix_features(struct net_device *netdev, /* HW strips the outer C-tag header, this is a problem * for S-tag traffic. */ - *features &= ~NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features); if (!params->vlan_strip_disable) netdev_warn(netdev, "Dropping C-tag vlan stripping offload due to S-tag vlan\n"); }

if (!MLX5E_GET_PFLAG(params, MLX5E_PFLAG_RX_STRIDING_RQ)) { - if (*features & NETIF_F_LRO) { + if (netdev_feature_test_bit(NETIF_F_LRO_BIT, *features)) { netdev_warn(netdev, "Disabling LRO, not supported in legacy RQ\n"); - *features &= ~NETIF_F_LRO; + netdev_feature_clear_bit(NETIF_F_LRO_BIT, features); } }

if (MLX5E_GET_PFLAG(params, MLX5E_PFLAG_RX_CQE_COMPRESS)) { - *features &= ~NETIF_F_RXHASH; - if (netdev->features & NETIF_F_RXHASH) + netdev_feature_clear_bit(NETIF_F_RXHASH_BIT, features); + if (netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features)) netdev_warn(netdev, "Disabling rxhash, not supported when CQE compress is active\n"); }

if (mlx5e_is_uplink_rep(priv)) - mlx5e_fix_uplink_rep_features(netdev, &features); + mlx5e_fix_uplink_rep_features(netdev, features);

mutex_unlock(&priv->state_lock); } @@ -3807,7 +3814,8 @@ static void mlx5e_tunnel_features_check(struct mlx5e_priv *priv,

out: /* Disable CSUM and GSO if the udp dport is not offloaded by HW */ - *features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); + netdev_feature_clear_bits(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK, + features); }

void mlx5e_features_check(struct sk_buff *skb, struct net_device *netdev, @@ -3820,7 +3828,8 @@ void mlx5e_features_check(struct sk_buff *skb, struct net_device *netdev,

/* Validate if the tunneled packet is being offloaded by HW */ if (skb->encapsulation && - (*features & NETIF_F_CSUM_MASK || *features & NETIF_F_GSO_MASK)) + (netdev_feature_test_bits(NETIF_F_CSUM_MASK, *features) || + netdev_feature_test_bits(NETIF_F_GSO_MASK, *features))) mlx5e_tunnel_features_check(priv, skb, features); }

@@ -4228,21 +4237,23 @@ static void mlx5e_build_nic_netdev(struct net_device *netdev)

netdev->ethtool_ops = &mlx5e_ethtool_ops;

- netdev->vlan_features |= NETIF_F_SG; - netdev->vlan_features |= NETIF_F_HW_CSUM; - netdev->vlan_features |= NETIF_F_GRO; - netdev->vlan_features |= NETIF_F_TSO; - netdev->vlan_features |= NETIF_F_TSO6; - netdev->vlan_features |= NETIF_F_RXCSUM; - netdev->vlan_features |= NETIF_F_RXHASH; + netdev_feature_set_bit(NETIF_F_SG_BIT, &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_GRO_BIT, &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_TSO_BIT, &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_TSO6_BIT, &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_RXHASH_BIT, &netdev->vlan_features);

- netdev->mpls_features |= NETIF_F_SG; - netdev->mpls_features |= NETIF_F_HW_CSUM; - netdev->mpls_features |= NETIF_F_TSO; - netdev->mpls_features |= NETIF_F_TSO6; + netdev_feature_set_bit(NETIF_F_SG_BIT, &netdev->mpls_features); + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, &netdev->mpls_features); + netdev_feature_set_bit(NETIF_F_TSO_BIT, &netdev->mpls_features); + netdev_feature_set_bit(NETIF_F_TSO6_BIT, &netdev->mpls_features);

- netdev->hw_enc_features |= NETIF_F_HW_VLAN_CTAG_TX; - netdev->hw_enc_features |= NETIF_F_HW_VLAN_CTAG_RX; + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + &netdev->hw_enc_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &netdev->hw_enc_features);

/* Tunneled LRO is not supported in the driver, and the same RQs are * shared between inner and outer TIRs, so the driver can't disable LRO @@ -4253,65 +4264,83 @@ static void mlx5e_build_nic_netdev(struct net_device *netdev) !MLX5_CAP_ETH(mdev, tunnel_lro_vxlan) && !MLX5_CAP_ETH(mdev, tunnel_lro_gre) && mlx5e_check_fragmented_striding_rq_cap(mdev)) - netdev->vlan_features |= NETIF_F_LRO; - - netdev->hw_features = netdev->vlan_features; - netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX; - netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX; - netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER; - netdev->hw_features |= NETIF_F_HW_VLAN_STAG_TX; + netdev_feature_set_bit(NETIF_F_LRO_BIT, &netdev->vlan_features); + + netdev_feature_copy(&netdev->hw_features, netdev->vlan_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, + &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_FILTER_BIT, + &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_STAG_TX_BIT, + &netdev->hw_features);

if (mlx5e_tunnel_any_tx_proto_supported(mdev)) { - netdev->hw_enc_features |= NETIF_F_HW_CSUM; - netdev->hw_enc_features |= NETIF_F_TSO; - netdev->hw_enc_features |= NETIF_F_TSO6; - netdev->hw_enc_features |= NETIF_F_GSO_PARTIAL; + netdev_feature_set_bit(NETIF_F_HW_CSUM_BIT, + &netdev->hw_enc_features); + netdev_feature_set_bit(NETIF_F_TSO_BIT, + &netdev->hw_enc_features); + netdev_feature_set_bit(NETIF_F_TSO6_BIT, + &netdev->hw_enc_features); + netdev_feature_set_bit(NETIF_F_GSO_PARTIAL_BIT, + &netdev->hw_enc_features); }

if (mlx5_vxlan_allowed(mdev->vxlan) || mlx5_geneve_tx_allowed(mdev)) { - netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL; - netdev->hw_enc_features |= NETIF_F_GSO_UDP_TUNNEL; - netdev->vlan_features |= NETIF_F_GSO_UDP_TUNNEL; + netdev_feature_set_bit(NETIF_F_GSO_UDP_TUNNEL_BIT, + &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_GSO_UDP_TUNNEL_BIT, + &netdev->hw_enc_features); + netdev_feature_set_bit(NETIF_F_GSO_UDP_TUNNEL_BIT, + &netdev->vlan_features); }

if (mlx5e_tunnel_proto_supported_tx(mdev, IPPROTO_GRE)) { - netdev->hw_features |= NETIF_F_GSO_GRE; - netdev->hw_enc_features |= NETIF_F_GSO_GRE; - netdev->gso_partial_features |= NETIF_F_GSO_GRE; + netdev_feature_set_bit(NETIF_F_GSO_GRE_BIT, + &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_GSO_GRE_BIT, + &netdev->hw_enc_features); + netdev_feature_set_bit(NETIF_F_GSO_GRE_BIT, + &netdev->gso_partial_features); }

if (mlx5e_tunnel_proto_supported_tx(mdev, IPPROTO_IPIP)) { - netdev->hw_features |= NETIF_F_GSO_IPXIP4 | - NETIF_F_GSO_IPXIP6; - netdev->hw_enc_features |= NETIF_F_GSO_IPXIP4 | - NETIF_F_GSO_IPXIP6; - netdev->gso_partial_features |= NETIF_F_GSO_IPXIP4 | - NETIF_F_GSO_IPXIP6; + netdev_feature_set_bits(NETIF_F_GSO_IPXIP4 | + NETIF_F_GSO_IPXIP6, + &netdev->hw_features); + netdev_feature_set_bits(NETIF_F_GSO_IPXIP4 | + NETIF_F_GSO_IPXIP6, + &netdev->hw_enc_features); + netdev_feature_set_bits(NETIF_F_GSO_IPXIP4 | + NETIF_F_GSO_IPXIP6, + &netdev->gso_partial_features); }

- netdev->hw_features |= NETIF_F_GSO_PARTIAL; - netdev->gso_partial_features |= NETIF_F_GSO_UDP_L4; - netdev->hw_features |= NETIF_F_GSO_UDP_L4; - netdev->features |= NETIF_F_GSO_UDP_L4; + netdev_feature_set_bit(NETIF_F_GSO_PARTIAL_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_GSO_UDP_L4_BIT, + &netdev->gso_partial_features); + netdev_feature_set_bit(NETIF_F_GSO_UDP_L4_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_GSO_UDP_L4_BIT, &netdev->features);

mlx5_query_port_fcs(mdev, &fcs_supported, &fcs_enabled);

if (fcs_supported) - netdev->hw_features |= NETIF_F_RXALL; + netdev_feature_set_bit(NETIF_F_RXALL_BIT, &netdev->hw_features);

if (MLX5_CAP_ETH(mdev, scatter_fcs)) - netdev->hw_features |= NETIF_F_RXFCS; + netdev_feature_set_bit(NETIF_F_RXFCS_BIT, &netdev->hw_features);

if (mlx5_qos_is_supported(mdev)) - netdev->hw_features |= NETIF_F_HW_TC; + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &netdev->features);

- netdev->features = netdev->hw_features; + netdev_feature_copy(&netdev->features, netdev->hw_features);

/* Defaults */ if (fcs_enabled) - netdev->features &= ~NETIF_F_RXALL; - netdev->features &= ~NETIF_F_LRO; - netdev->features &= ~NETIF_F_RXFCS; + netdev_feature_clear_bit(NETIF_F_RXALL_BIT, &netdev->features); + netdev_feature_clear_bit(NETIF_F_LRO_BIT, &netdev->features); + netdev_feature_clear_bit(NETIF_F_RXFCS_BIT, &netdev->features);

#define FT_CAP(f) MLX5_CAP_FLOWTABLE(mdev, flow_table_properties_nic_receive.f) if (FT_CAP(flow_modify_en) && @@ -4319,15 +4348,15 @@ static void mlx5e_build_nic_netdev(struct net_device *netdev) FT_CAP(identified_miss_table_mode) && FT_CAP(flow_table_modify)) { #if IS_ENABLED(CONFIG_MLX5_CLS_ACT) - netdev->hw_features |= NETIF_F_HW_TC; + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &netdev->hw_features); #endif #ifdef CONFIG_MLX5_EN_ARFS - netdev->hw_features |= NETIF_F_NTUPLE; + netdev_feature_set_bit(NETIF_F_NTUPLE_BIT, &netdev->hw_features); #endif }

- netdev->features |= NETIF_F_HIGHDMA; - netdev->features |= NETIF_F_HW_VLAN_STAG_FILTER; + netdev_feature_set_bit(NETIF_F_HIGHDMA_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_STAG_FILTER_BIT, &netdev->features);

netdev->priv_flags |= IFF_UNICAST_FLT;

diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c index c54aaef..e1bd3b6 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c @@ -628,19 +628,20 @@ static void mlx5e_build_rep_netdev(struct net_device *netdev, netdev->watchdog_timeo = 15 * HZ;

#if IS_ENABLED(CONFIG_MLX5_CLS_ACT) - netdev->hw_features |= NETIF_F_HW_TC; + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &netdev->hw_features); #endif - netdev->hw_features |= NETIF_F_SG; - netdev->hw_features |= NETIF_F_IP_CSUM; - netdev->hw_features |= NETIF_F_IPV6_CSUM; - netdev->hw_features |= NETIF_F_GRO; - netdev->hw_features |= NETIF_F_TSO; - netdev->hw_features |= NETIF_F_TSO6; - netdev->hw_features |= NETIF_F_RXCSUM; + netdev_feature_set_bit(NETIF_F_SG_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_IP_CSUM_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_IPV6_CSUM_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_GRO_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_TSO_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_TSO6_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &netdev->hw_features);

- netdev->features |= netdev->hw_features; - netdev->features |= NETIF_F_VLAN_CHALLENGED; - netdev->features |= NETIF_F_NETNS_LOCAL; + netdev_feature_or(&netdev->features, netdev->features, + netdev->hw_features); + netdev_feature_set_bit(NETIF_F_VLAN_CHALLENGED_BIT, &netdev->features); + netdev_feature_set_bit(NETIF_F_NETNS_LOCAL_BIT, &netdev->features); }

static int mlx5e_init_rep(struct mlx5_core_dev *mdev, @@ -1004,7 +1005,7 @@ static void mlx5e_uplink_rep_enable(struct mlx5e_priv *priv) mlx5e_rep_neigh_init(rpriv); mlx5e_rep_bridge_init(priv);

- netdev->wanted_features |= NETIF_F_HW_TC; + netdev_feature_set_bit(NETIF_F_HW_TC_BIT, &netdev->wanted_features);

rtnl_lock(); if (netif_running(netdev)) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c index 3c65fd0..f869d50 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c @@ -976,7 +976,8 @@ static inline void mlx5e_handle_csum(struct net_device *netdev, int network_depth = 0; __be16 proto;

- if (unlikely(!(netdev->features & NETIF_F_RXCSUM))) + if (unlikely(!netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + netdev->features))) goto csum_none;

if (lro) { @@ -1073,7 +1074,7 @@ static inline void mlx5e_build_rx_skb(struct mlx5_cqe64 *cqe, rq->clock, get_cqe_ts(cqe)); skb_record_rx_queue(skb, rq->ix);

- if (likely(netdev->features & NETIF_F_RXHASH)) + if (likely(netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features))) mlx5e_skb_set_hash(cqe, skb);

if (cqe_has_vlan(cqe)) { @@ -1662,7 +1663,7 @@ static inline void mlx5i_complete_rx_cqe(struct mlx5e_rq *rq,

skb->protocol = *((__be16 *)(skb->data));

- if (netdev->features & NETIF_F_RXCSUM) { + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, netdev->features)) { skb->ip_summed = CHECKSUM_COMPLETE; skb->csum = csum_unfold((__force __sum16)cqe->check_sum); stats->csum_complete++; @@ -1676,7 +1677,7 @@ static inline void mlx5i_complete_rx_cqe(struct mlx5e_rq *rq, rq->clock, get_cqe_ts(cqe)); skb_record_rx_queue(skb, rq->ix);

- if (likely(netdev->features & NETIF_F_RXHASH)) + if (likely(netdev_feature_test_bit(NETIF_F_RXHASH_BIT, netdev->features))) mlx5e_skb_set_hash(cqe, skb);

/* 20 bytes of ipoib header and 4 for encap existing */ diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c index e5c4344..223192f 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_tc.c @@ -4821,7 +4821,7 @@ static int mlx5e_tc_netdev_event(struct notifier_block *this, priv = container_of(fs, struct mlx5e_priv, fs); peer_priv = netdev_priv(ndev); if (priv == peer_priv || - !(priv->netdev->features & NETIF_F_HW_TC)) + !netdev_feature_test_bit(NETIF_F_HW_TC_BIT, priv->netdev->features)) return NOTIFY_DONE;

mlx5e_tc_hairpin_update_dead_peer(priv, peer_priv); diff --git a/drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c b/drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c index 67571e5..b06c5fa 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c @@ -87,14 +87,14 @@ int mlx5i_init(struct mlx5_core_dev *mdev, struct net_device *netdev) mlx5e_timestamp_init(priv);

/* netdev init */ - netdev->hw_features |= NETIF_F_SG; - netdev->hw_features |= NETIF_F_IP_CSUM; - netdev->hw_features |= NETIF_F_IPV6_CSUM; - netdev->hw_features |= NETIF_F_GRO; - netdev->hw_features |= NETIF_F_TSO; - netdev->hw_features |= NETIF_F_TSO6; - netdev->hw_features |= NETIF_F_RXCSUM; - netdev->hw_features |= NETIF_F_RXHASH; + netdev_feature_set_bit(NETIF_F_SG_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_IP_CSUM_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_IPV6_CSUM_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_GRO_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_TSO_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_TSO6_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_RXCSUM_BIT, &netdev->hw_features); + netdev_feature_set_bit(NETIF_F_RXHASH_BIT, &netdev->hw_features);

netdev->netdev_ops = &mlx5i_netdev_ops; netdev->ethtool_ops = &mlx5i_ethtool_ops; @@ -326,7 +326,8 @@ static int mlx5i_create_flow_steering(struct mlx5e_priv *priv) if (err) { netdev_err(priv->netdev, "Failed to create arfs tables, err=%d\n", err); - priv->netdev->hw_features &= ~NETIF_F_NTUPLE; + netdev_feature_clear_bit(NETIF_F_NTUPLE_BIT, + &priv->netdev->hw_features); }

err = mlx5e_create_ttc_table(priv); diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c index 081408e..0654b174 100644 --- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c +++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c @@ -1080,43 +1080,45 @@ typedef int (*mlxsw_sp_feature_handler)(struct net_device *dev, bool enable);

static int mlxsw_sp_handle_feature(struct net_device *dev, netdev_features_t wanted_features, - netdev_features_t feature, + u32 feature_bit, mlxsw_sp_feature_handler feature_handler) { - netdev_features_t changes = wanted_features ^ dev->features; - bool enable = !!(wanted_features & feature); + bool enable = netdev_feature_test_bit(feature_bit, wanted_features); + netdev_features_t changes; int err;

- if (!(changes & feature)) + netdev_feature_xor(&changes, wanted_features, dev->features); + + if (!netdev_feature_test_bit(feature_bit, changes)) return 0;

err = feature_handler(dev, enable); if (err) { - netdev_err(dev, "%s feature %pNF failed, err %d\n", - enable ? "Enable" : "Disable", &feature, err); + netdev_err(dev, "%s feature bit %u failed, err %d\n", + enable ? "Enable" : "Disable", feature_bit, err); return err; }

if (enable) - dev->features |= feature; + netdev_feature_set_bit(feature_bit, &dev->features); else - dev->features &= ~feature; - + netdev_feature_clear_bit(feature_bit, &dev->features); return 0; } static int mlxsw_sp_set_features(struct net_device *dev, netdev_features_t features) { - netdev_features_t oper_features = dev->features; + netdev_features_t oper_features; int err = 0;

- err |= mlxsw_sp_handle_feature(dev, features, NETIF_F_HW_TC, + netdev_feature_copy(&oper_features, dev->features); + err |= mlxsw_sp_handle_feature(dev, features, NETIF_F_HW_TC_BIT, mlxsw_sp_feature_hw_tc); - err |= mlxsw_sp_handle_feature(dev, features, NETIF_F_LOOPBACK, + err |= mlxsw_sp_handle_feature(dev, features, NETIF_F_LOOPBACK_BIT, mlxsw_sp_feature_loopback);

if (err) { - dev->features = oper_features; + netdev_feature_copy(&dev->features, oper_features); return -EINVAL; }

@@ -1521,9 +1523,11 @@ static int mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,

netif_carrier_off(dev);

- dev->features |= NETIF_F_NETNS_LOCAL | NETIF_F_LLTX | NETIF_F_SG | - NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_TC; - dev->hw_features |= NETIF_F_HW_TC | NETIF_F_LOOPBACK; + netdev_feature_set_bits(NETIF_F_NETNS_LOCAL | NETIF_F_LLTX | + NETIF_F_SG | NETIF_F_HW_VLAN_CTAG_FILTER | + NETIF_F_HW_TC, &dev->features); + netdev_feature_set_bits(NETIF_F_HW_TC | NETIF_F_LOOPBACK, + &dev->hw_features);

dev->min_mtu = 0; dev->max_mtu = ETH_MAX_MTU;

Use netdev_feature_xxx helpers to replace the logical operation for netdev features.

Signed-off-by: Jian Shen shenjian15@huawei.com --- drivers/net/ethernet/atheros/alx/main.c | 17 ++++++----- drivers/net/ethernet/atheros/atl1c/atl1c_main.c | 27 +++++++++++------- drivers/net/ethernet/atheros/atl1e/atl1e_main.c | 38 ++++++++++++++----------- drivers/net/ethernet/atheros/atlx/atl1.c | 15 ++++++---- drivers/net/ethernet/atheros/atlx/atl2.c | 21 ++++++++------ drivers/net/ethernet/atheros/atlx/atlx.c | 14 +++++---- 6 files changed, 78 insertions(+), 54 deletions(-)

diff --git a/drivers/net/ethernet/atheros/alx/main.c b/drivers/net/ethernet/atheros/alx/main.c index 922c600..2f79aa6 100644 --- a/drivers/net/ethernet/atheros/alx/main.c +++ b/drivers/net/ethernet/atheros/alx/main.c @@ -261,7 +261,8 @@ static int alx_clean_rx_irq(struct alx_rx_queue *rxq, int budget) skb->protocol = eth_type_trans(skb, rxq->netdev);

skb_checksum_none_assert(skb); - if (alx->dev->features & NETIF_F_RXCSUM && + if (netdev_feature_test_bit(NETIF_F_RXCSUM_BIT, + alx->dev->features) && !(rrd->word3 & (cpu_to_le32(1 << RRD_ERR_L4_SHIFT) | cpu_to_le32(1 << RRD_ERR_IPV4_SHIFT)))) { switch (ALX_GET_FIELD(le32_to_cpu(rrd->word2), @@ -1101,7 +1102,8 @@ static void alx_fix_features(struct net_device *netdev, netdev_features_t *features) { if (netdev->mtu > ALX_MAX_TSO_PKT_SIZE) - *features &= ~(NETIF_F_TSO | NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_TSO | NETIF_F_TSO6, + features); }

static void alx_netif_stop(struct alx_priv *alx) @@ -1816,11 +1818,12 @@ static int alx_probe(struct pci_dev *pdev, const struct pci_device_id *ent) } }

- netdev->hw_features = NETIF_F_SG | - NETIF_F_HW_CSUM | - NETIF_F_RXCSUM | - NETIF_F_TSO | - NETIF_F_TSO6; + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | + NETIF_F_HW_CSUM | + NETIF_F_RXCSUM | + NETIF_F_TSO | + NETIF_F_TSO6, &netdev->hw_features);

if (alx_get_perm_macaddr(hw, hw->perm_addr)) { dev_warn(&pdev->dev, diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c index f01a39f..db6784c 100644 --- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c +++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c @@ -429,7 +429,7 @@ static void atl1c_set_multi(struct net_device *netdev)

static void __atl1c_vlan_mode(netdev_features_t features, u32 *mac_ctrl_data) { - if (features & NETIF_F_HW_VLAN_CTAG_RX) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features)) { /* enable VLAN tag insert/strip */ *mac_ctrl_data |= MAC_CTRL_RMV_VLAN; } else { @@ -514,23 +514,27 @@ static void atl1c_fix_features(struct net_device *netdev, * Since there is no support for separate rx/tx vlan accel * enable/disable make sure tx flag is always in same state as rx. */ - if (*features & NETIF_F_HW_VLAN_CTAG_RX) - *features |= NETIF_F_HW_VLAN_CTAG_TX; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features); else - *features &= ~NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features);

if (hw->nic_type != athr_mt) { if (netdev->mtu > MAX_TSO_FRAME_SIZE) - *features &= ~(NETIF_F_TSO | NETIF_F_TSO6); + netdev_feature_clear_bits(NETIF_F_TSO | NETIF_F_TSO6, + features); } }

static int atl1c_set_features(struct net_device *netdev, netdev_features_t features) { - netdev_features_t changed = netdev->features ^ features; + netdev_features_t changed;

- if (changed & NETIF_F_HW_VLAN_CTAG_RX) + netdev_feature_xor(&changed, netdev->features, features); + + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, changed)) atl1c_vlan_mode(netdev, features);

return 0; @@ -2626,13 +2630,14 @@ static int atl1c_init_netdev(struct net_device *netdev, struct pci_dev *pdev) atl1c_set_ethtool_ops(netdev);

/* TODO: add when ready */ - netdev->hw_features = NETIF_F_SG | + netdev_feature_zero(&netdev->hw_features); + netdev_feature_set_bits(NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_TSO | - NETIF_F_TSO6; - netdev->features = netdev->hw_features | - NETIF_F_HW_VLAN_CTAG_TX; + NETIF_F_TSO6, &netdev->hw_features); + netdev_feature_copy(&netdev->features, netdev->hw_features); + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, &netdev->features); return 0; }

diff --git a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c index 3f66110..a37d08c 100644 --- a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c +++ b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c @@ -299,7 +299,7 @@ static void atl1e_set_multi(struct net_device *netdev) static void __atl1e_rx_mode(netdev_features_t features, u32 *mac_ctrl_data) {

- if (features & NETIF_F_RXALL) { + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, features)) { /* enable RX of ALL frames */ *mac_ctrl_data |= MAC_CTRL_DBG; } else { @@ -326,7 +326,7 @@ static void atl1e_rx_mode(struct net_device *netdev,

static void __atl1e_vlan_mode(netdev_features_t features, u32 *mac_ctrl_data) { - if (features & NETIF_F_HW_VLAN_CTAG_RX) { + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, features)) { /* enable VLAN tag insert/strip */ *mac_ctrl_data |= MAC_CTRL_RMV_VLAN; } else { @@ -389,24 +389,25 @@ static void atl1e_fix_features(struct net_device *netdev, * Since there is no support for separate rx/tx vlan accel * enable/disable make sure tx flag is always in same state as rx. */ - if (*features & NETIF_F_HW_VLAN_CTAG_RX) - *features |= NETIF_F_HW_VLAN_CTAG_TX; + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, *features)) + netdev_feature_set_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, features); else - *features &= ~NETIF_F_HW_VLAN_CTAG_TX; + netdev_feature_clear_bit(NETIF_F_HW_VLAN_CTAG_TX_BIT, + features); }

static int atl1e_set_features(struct net_device *netdev, netdev_features_t features) { - netdev_features_t changed = netdev->features ^ features; + netdev_features_t changed;

- if (changed & NETIF_F_HW_VLAN_CTAG_RX) + netdev_feature_xor(&changed, netdev->features, features); + if (netdev_feature_test_bit(NETIF_F_HW_VLAN_CTAG_RX_BIT, changed)) atl1e_vlan_mode(netdev, features);

- if (changed & NETIF_F_RXALL) + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, changed)) atl1e_rx_mode(netdev, features);

- return 0; }

@@ -1065,7 +1066,7 @@ static void atl1e_setup_mac_ctrl(struct atl1e_adapter *adapter) value |= MAC_CTRL_PROMIS_EN; if (netdev->flags & IFF_ALLMULTI) value |= MAC_CTRL_MC_ALL_EN; - if (netdev->features & NETIF_F_RXALL) + if (netdev_feature_test_bit(NETIF_F_RXALL_BIT, netdev->features)) value |= MAC_CTRL_DBG; AT_WRITE_REG(hw, REG_MAC_CTRL, value); } @@ -1427,7 +1428,8 @@ static void atl1e_clean_rx_irq(struct atl1e_adapter *adapter, u8 que,

/* error packet */ if ((prrs->pkt_flag & RRS_IS_ERR_FRAME) && - !(netdev->features & NETIF_F_RXALL)) { + !netdev_fea