Merge tag 'net-6.0-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

+1 -1

Documentation/admin-guide/sysctl/net.rst

··· 271 271 netdev_max_backlog 272 272 ------------------ 273 273 274 - Maximum number of packets, queued on the INPUT side, when the interface 274 + Maximum number of packets, queued on the INPUT side, when the interface 275 275 receives packets faster than kernel can process them. 276 276 277 277 netdev_rss_key

+1

MAINTAINERS

··· 3679 3679 F: drivers/net/bonding/ 3680 3680 F: include/net/bond* 3681 3681 F: include/uapi/linux/if_bonding.h 3682 + F: tools/testing/selftests/drivers/net/bonding/ 3682 3683 3683 3684 BOSCH SENSORTEC BMA400 ACCELEROMETER IIO DRIVER 3684 3685 M: Dan Robertson <dan@dlrobertson.com>

+15 -26

drivers/net/bonding/bond_3ad.c

··· 84 84 static const u8 null_mac_addr[ETH_ALEN + 2] __long_aligned = { 85 85 0, 0, 0, 0, 0, 0 86 86 }; 87 - static u16 ad_ticks_per_sec; 87 + 88 + static const u16 ad_ticks_per_sec = 1000 / AD_TIMER_INTERVAL; 88 89 static const int ad_delta_in_ticks = (AD_TIMER_INTERVAL * HZ) / 1000; 89 90 90 91 static const u8 lacpdu_mcast_addr[ETH_ALEN + 2] __long_aligned = ··· 2002 2001 /** 2003 2002 * bond_3ad_initialize - initialize a bond's 802.3ad parameters and structures 2004 2003 * @bond: bonding struct to work on 2005 - * @tick_resolution: tick duration (millisecond resolution) 2006 2004 * 2007 2005 * Can be called only after the mac address of the bond is set. 2008 2006 */ 2009 - void bond_3ad_initialize(struct bonding *bond, u16 tick_resolution) 2007 + void bond_3ad_initialize(struct bonding *bond) 2010 2008 { 2011 - /* check that the bond is not initialized yet */ 2012 - if (!MAC_ADDRESS_EQUAL(&(BOND_AD_INFO(bond).system.sys_mac_addr), 2013 - bond->dev->dev_addr)) { 2009 + BOND_AD_INFO(bond).aggregator_identifier = 0; 2010 + BOND_AD_INFO(bond).system.sys_priority = 2011 + bond->params.ad_actor_sys_prio; 2012 + if (is_zero_ether_addr(bond->params.ad_actor_system)) 2013 + BOND_AD_INFO(bond).system.sys_mac_addr = 2014 + *((struct mac_addr *)bond->dev->dev_addr); 2015 + else 2016 + BOND_AD_INFO(bond).system.sys_mac_addr = 2017 + *((struct mac_addr *)bond->params.ad_actor_system); 2014 2018 2015 - BOND_AD_INFO(bond).aggregator_identifier = 0; 2016 - 2017 - BOND_AD_INFO(bond).system.sys_priority = 2018 - bond->params.ad_actor_sys_prio; 2019 - if (is_zero_ether_addr(bond->params.ad_actor_system)) 2020 - BOND_AD_INFO(bond).system.sys_mac_addr = 2021 - *((struct mac_addr *)bond->dev->dev_addr); 2022 - else 2023 - BOND_AD_INFO(bond).system.sys_mac_addr = 2024 - *((struct mac_addr *)bond->params.ad_actor_system); 2025 - 2026 - /* initialize how many times this module is called in one 2027 - * second (should be about every 100ms) 2028 - */ 2029 - ad_ticks_per_sec = tick_resolution; 2030 - 2031 - bond_3ad_initiate_agg_selection(bond, 2032 - AD_AGGREGATOR_SELECTION_TIMER * 2033 - ad_ticks_per_sec); 2034 - } 2019 + bond_3ad_initiate_agg_selection(bond, 2020 + AD_AGGREGATOR_SELECTION_TIMER * 2021 + ad_ticks_per_sec); 2035 2022 } 2036 2023 2037 2024 /**

+1 -1

drivers/net/bonding/bond_main.c

··· 2081 2081 /* Initialize AD with the number of times that the AD timer is called in 1 second 2082 2082 * can be called only after the mac address of the bond is set 2083 2083 */ 2084 - bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL); 2084 + bond_3ad_initialize(bond); 2085 2085 } else { 2086 2086 SLAVE_AD_INFO(new_slave)->id = 2087 2087 SLAVE_AD_INFO(prev_slave)->id + 1;

+51 -2

drivers/net/dsa/microchip/ksz_common.c

··· 803 803 if (dev->info->supports_rgmii[port]) 804 804 phy_interface_set_rgmii(config->supported_interfaces); 805 805 806 - if (dev->info->internal_phy[port]) 806 + if (dev->info->internal_phy[port]) { 807 807 __set_bit(PHY_INTERFACE_MODE_INTERNAL, 808 808 config->supported_interfaces); 809 + /* Compatibility for phylib's default interface type when the 810 + * phy-mode property is absent 811 + */ 812 + __set_bit(PHY_INTERFACE_MODE_GMII, 813 + config->supported_interfaces); 814 + } 809 815 810 816 if (dev->dev_ops->get_caps) 811 817 dev->dev_ops->get_caps(dev, port, config); ··· 968 962 static int ksz_setup(struct dsa_switch *ds) 969 963 { 970 964 struct ksz_device *dev = ds->priv; 965 + struct ksz_port *p; 971 966 const u16 *regs; 972 967 int ret; 973 968 ··· 1007 1000 if (ret) 1008 1001 return ret; 1009 1002 } 1003 + 1004 + /* Start with learning disabled on standalone user ports, and enabled 1005 + * on the CPU port. In lack of other finer mechanisms, learning on the 1006 + * CPU port will avoid flooding bridge local addresses on the network 1007 + * in some cases. 1008 + */ 1009 + p = &dev->ports[dev->cpu_port]; 1010 + p->learning = true; 1010 1011 1011 1012 /* start switch */ 1012 1013 regmap_update_bits(dev->regmap[0], regs[S_START_CTRL], ··· 1292 1277 ksz_pread8(dev, port, regs[P_STP_CTRL], &data); 1293 1278 data &= ~(PORT_TX_ENABLE | PORT_RX_ENABLE | PORT_LEARN_DISABLE); 1294 1279 1280 + p = &dev->ports[port]; 1281 + 1295 1282 switch (state) { 1296 1283 case BR_STATE_DISABLED: 1297 1284 data |= PORT_LEARN_DISABLE; ··· 1303 1286 break; 1304 1287 case BR_STATE_LEARNING: 1305 1288 data |= PORT_RX_ENABLE; 1289 + if (!p->learning) 1290 + data |= PORT_LEARN_DISABLE; 1306 1291 break; 1307 1292 case BR_STATE_FORWARDING: 1308 1293 data |= (PORT_TX_ENABLE | PORT_RX_ENABLE); 1294 + if (!p->learning) 1295 + data |= PORT_LEARN_DISABLE; 1309 1296 break; 1310 1297 case BR_STATE_BLOCKING: 1311 1298 data |= PORT_LEARN_DISABLE; ··· 1321 1300 1322 1301 ksz_pwrite8(dev, port, regs[P_STP_CTRL], data); 1323 1302 1324 - p = &dev->ports[port]; 1325 1303 p->stp_state = state; 1326 1304 1327 1305 ksz_update_port_member(dev, port); 1306 + } 1307 + 1308 + static int ksz_port_pre_bridge_flags(struct dsa_switch *ds, int port, 1309 + struct switchdev_brport_flags flags, 1310 + struct netlink_ext_ack *extack) 1311 + { 1312 + if (flags.mask & ~BR_LEARNING) 1313 + return -EINVAL; 1314 + 1315 + return 0; 1316 + } 1317 + 1318 + static int ksz_port_bridge_flags(struct dsa_switch *ds, int port, 1319 + struct switchdev_brport_flags flags, 1320 + struct netlink_ext_ack *extack) 1321 + { 1322 + struct ksz_device *dev = ds->priv; 1323 + struct ksz_port *p = &dev->ports[port]; 1324 + 1325 + if (flags.mask & BR_LEARNING) { 1326 + p->learning = !!(flags.val & BR_LEARNING); 1327 + 1328 + /* Make the change take effect immediately */ 1329 + ksz_port_stp_state_set(ds, port, p->stp_state); 1330 + } 1331 + 1332 + return 0; 1328 1333 } 1329 1334 1330 1335 static enum dsa_tag_protocol ksz_get_tag_protocol(struct dsa_switch *ds, ··· 1766 1719 .port_bridge_join = ksz_port_bridge_join, 1767 1720 .port_bridge_leave = ksz_port_bridge_leave, 1768 1721 .port_stp_state_set = ksz_port_stp_state_set, 1722 + .port_pre_bridge_flags = ksz_port_pre_bridge_flags, 1723 + .port_bridge_flags = ksz_port_bridge_flags, 1769 1724 .port_fast_age = ksz_port_fast_age, 1770 1725 .port_vlan_filtering = ksz_port_vlan_filtering, 1771 1726 .port_vlan_add = ksz_port_vlan_add,

+1

drivers/net/dsa/microchip/ksz_common.h

··· 65 65 66 66 struct ksz_port { 67 67 bool remove_tag; /* Remove Tag flag set, for ksz8795 only */ 68 + bool learning; 68 69 int stp_state; 69 70 struct phy_device phydev; 70 71

+1 -4

drivers/net/ethernet/broadcom/bnxt/bnxt.c

··· 11178 11178 if ((features & NETIF_F_NTUPLE) && !bnxt_rfs_capable(bp)) 11179 11179 features &= ~NETIF_F_NTUPLE; 11180 11180 11181 - if (bp->flags & BNXT_FLAG_NO_AGG_RINGS) 11182 - features &= ~(NETIF_F_LRO | NETIF_F_GRO_HW); 11183 - 11184 - if (!(bp->flags & BNXT_FLAG_TPA)) 11181 + if ((bp->flags & BNXT_FLAG_NO_AGG_RINGS) || bp->xdp_prog) 11185 11182 features &= ~(NETIF_F_LRO | NETIF_F_GRO_HW); 11186 11183 11187 11184 if (!(features & NETIF_F_GRO))

+1

drivers/net/ethernet/broadcom/bnxt/bnxt.h

··· 2130 2130 #define BNXT_DUMP_CRASH 1 2131 2131 2132 2132 struct bpf_prog *xdp_prog; 2133 + u8 xdp_has_frags; 2133 2134 2134 2135 struct bnxt_ptp_cfg *ptp_cfg; 2135 2136 u8 ptp_all_rx_tstamp;

+1

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

··· 1306 1306 if (rc) 1307 1307 goto err_dl_port_unreg; 1308 1308 1309 + devlink_set_features(dl, DEVLINK_F_RELOAD); 1309 1310 out: 1310 1311 devlink_register(dl); 1311 1312 return 0;

+1 -1

drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c

··· 623 623 hw_resc->max_stat_ctxs -= le16_to_cpu(req->min_stat_ctx) * n; 624 624 hw_resc->max_vnics -= le16_to_cpu(req->min_vnics) * n; 625 625 if (bp->flags & BNXT_FLAG_CHIP_P5) 626 - hw_resc->max_irqs -= vf_msix * n; 626 + hw_resc->max_nqs -= vf_msix; 627 627 628 628 rc = pf->active_vfs; 629 629 }

+8 -2

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

··· 181 181 struct xdp_buff *xdp) 182 182 { 183 183 struct bnxt_sw_rx_bd *rx_buf; 184 + u32 buflen = PAGE_SIZE; 184 185 struct pci_dev *pdev; 185 186 dma_addr_t mapping; 186 187 u32 offset; ··· 193 192 mapping = rx_buf->mapping - bp->rx_dma_offset; 194 193 dma_sync_single_for_cpu(&pdev->dev, mapping + offset, *len, bp->rx_dir); 195 194 196 - xdp_init_buff(xdp, BNXT_PAGE_MODE_BUF_SIZE + offset, &rxr->xdp_rxq); 195 + if (bp->xdp_has_frags) 196 + buflen = BNXT_PAGE_MODE_BUF_SIZE + offset; 197 + 198 + xdp_init_buff(xdp, buflen, &rxr->xdp_rxq); 197 199 xdp_prepare_buff(xdp, *data_ptr - offset, offset, *len, false); 198 200 } 199 201 ··· 401 397 netdev_warn(dev, "ethtool rx/tx channels must be combined to support XDP.\n"); 402 398 return -EOPNOTSUPP; 403 399 } 404 - if (prog) 400 + if (prog) { 405 401 tx_xdp = bp->rx_nr_rings; 402 + bp->xdp_has_frags = prog->aux->xdp_has_frags; 403 + } 406 404 407 405 tc = netdev_get_num_tc(dev); 408 406 if (!tc)

+5 -1

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c

··· 2886 2886 2887 2887 /* The Aquantia PHYs are capable of performing rate adaptation */ 2888 2888 #define PHY_VEND_AQUANTIA 0x03a1b400 2889 + #define PHY_VEND_AQUANTIA2 0x31c31c00 2889 2890 2890 2891 static int dpaa_phy_init(struct net_device *net_dev) 2891 2892 { ··· 2894 2893 struct mac_device *mac_dev; 2895 2894 struct phy_device *phy_dev; 2896 2895 struct dpaa_priv *priv; 2896 + u32 phy_vendor; 2897 2897 2898 2898 priv = netdev_priv(net_dev); 2899 2899 mac_dev = priv->mac_dev; ··· 2907 2905 return -ENODEV; 2908 2906 } 2909 2907 2908 + phy_vendor = phy_dev->drv->phy_id & GENMASK(31, 10); 2910 2909 /* Unless the PHY is capable of rate adaptation */ 2911 2910 if (mac_dev->phy_if != PHY_INTERFACE_MODE_XGMII || 2912 - ((phy_dev->drv->phy_id & GENMASK(31, 10)) != PHY_VEND_AQUANTIA)) { 2911 + (phy_vendor != PHY_VEND_AQUANTIA && 2912 + phy_vendor != PHY_VEND_AQUANTIA2)) { 2913 2913 /* remove any features not supported by the controller */ 2914 2914 ethtool_convert_legacy_u32_to_link_mode(mask, 2915 2915 mac_dev->if_support);

+10

drivers/net/ethernet/freescale/fec.h

··· 634 634 int pps_enable; 635 635 unsigned int next_counter; 636 636 637 + struct { 638 + struct timespec64 ts_phc; 639 + u64 ns_sys; 640 + u32 at_corr; 641 + u8 at_inc_corr; 642 + } ptp_saved_state; 643 + 637 644 u64 ethtool_stats[]; 638 645 }; 639 646 ··· 650 643 void fec_ptp_disable_hwts(struct net_device *ndev); 651 644 int fec_ptp_set(struct net_device *ndev, struct ifreq *ifr); 652 645 int fec_ptp_get(struct net_device *ndev, struct ifreq *ifr); 646 + 647 + void fec_ptp_save_state(struct fec_enet_private *fep); 648 + int fec_ptp_restore_state(struct fec_enet_private *fep); 653 649 654 650 /****************************************************************************/ 655 651 #endif /* FEC_H */

+38 -4

drivers/net/ethernet/freescale/fec_main.c

··· 285 285 #define FEC_MMFR_TA (2 << 16) 286 286 #define FEC_MMFR_DATA(v) (v & 0xffff) 287 287 /* FEC ECR bits definition */ 288 - #define FEC_ECR_MAGICEN (1 << 2) 289 - #define FEC_ECR_SLEEP (1 << 3) 288 + #define FEC_ECR_RESET BIT(0) 289 + #define FEC_ECR_ETHEREN BIT(1) 290 + #define FEC_ECR_MAGICEN BIT(2) 291 + #define FEC_ECR_SLEEP BIT(3) 292 + #define FEC_ECR_EN1588 BIT(4) 290 293 291 294 #define FEC_MII_TIMEOUT 30000 /* us */ 292 295 ··· 985 982 u32 temp_mac[2]; 986 983 u32 rcntl = OPT_FRAME_SIZE | 0x04; 987 984 u32 ecntl = 0x2; /* ETHEREN */ 985 + struct ptp_clock_request ptp_rq = { .type = PTP_CLK_REQ_PPS }; 986 + 987 + fec_ptp_save_state(fep); 988 988 989 989 /* Whack a reset. We should wait for this. 990 990 * For i.MX6SX SOC, enet use AXI bus, we use disable MAC ··· 1141 1135 } 1142 1136 1143 1137 if (fep->bufdesc_ex) 1144 - ecntl |= (1 << 4); 1138 + ecntl |= FEC_ECR_EN1588; 1145 1139 1146 1140 if (fep->quirks & FEC_QUIRK_DELAYED_CLKS_SUPPORT && 1147 1141 fep->rgmii_txc_dly) ··· 1161 1155 1162 1156 if (fep->bufdesc_ex) 1163 1157 fec_ptp_start_cyclecounter(ndev); 1158 + 1159 + /* Restart PPS if needed */ 1160 + if (fep->pps_enable) { 1161 + /* Clear flag so fec_ptp_enable_pps() doesn't return immediately */ 1162 + fep->pps_enable = 0; 1163 + fec_ptp_restore_state(fep); 1164 + fep->ptp_caps.enable(&fep->ptp_caps, &ptp_rq, 1); 1165 + } 1164 1166 1165 1167 /* Enable interrupts we wish to service */ 1166 1168 if (fep->link) ··· 1220 1206 struct fec_enet_private *fep = netdev_priv(ndev); 1221 1207 u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8); 1222 1208 u32 val; 1209 + struct ptp_clock_request ptp_rq = { .type = PTP_CLK_REQ_PPS }; 1210 + u32 ecntl = 0; 1223 1211 1224 1212 /* We cannot expect a graceful transmit stop without link !!! */ 1225 1213 if (fep->link) { ··· 1230 1214 if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA)) 1231 1215 netdev_err(ndev, "Graceful transmit stop did not complete!\n"); 1232 1216 } 1217 + 1218 + fec_ptp_save_state(fep); 1233 1219 1234 1220 /* Whack a reset. We should wait for this. 1235 1221 * For i.MX6SX SOC, enet use AXI bus, we use disable MAC ··· 1252 1234 writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED); 1253 1235 writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK); 1254 1236 1237 + if (fep->bufdesc_ex) 1238 + ecntl |= FEC_ECR_EN1588; 1239 + 1255 1240 /* We have to keep ENET enabled to have MII interrupt stay working */ 1256 1241 if (fep->quirks & FEC_QUIRK_ENET_MAC && 1257 1242 !(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) { 1258 - writel(2, fep->hwp + FEC_ECNTRL); 1243 + ecntl |= FEC_ECR_ETHEREN; 1259 1244 writel(rmii_mode, fep->hwp + FEC_R_CNTRL); 1245 + } 1246 + 1247 + writel(ecntl, fep->hwp + FEC_ECNTRL); 1248 + 1249 + if (fep->bufdesc_ex) 1250 + fec_ptp_start_cyclecounter(ndev); 1251 + 1252 + /* Restart PPS if needed */ 1253 + if (fep->pps_enable) { 1254 + /* Clear flag so fec_ptp_enable_pps() doesn't return immediately */ 1255 + fep->pps_enable = 0; 1256 + fec_ptp_restore_state(fep); 1257 + fep->ptp_caps.enable(&fep->ptp_caps, &ptp_rq, 1); 1260 1258 } 1261 1259 } 1262 1260

+29

drivers/net/ethernet/freescale/fec_ptp.c

··· 633 633 struct net_device *ndev = platform_get_drvdata(pdev); 634 634 struct fec_enet_private *fep = netdev_priv(ndev); 635 635 636 + if (fep->pps_enable) 637 + fec_ptp_enable_pps(fep, 0); 638 + 636 639 cancel_delayed_work_sync(&fep->time_keep); 637 640 if (fep->ptp_clock) 638 641 ptp_clock_unregister(fep->ptp_clock); 642 + } 643 + 644 + void fec_ptp_save_state(struct fec_enet_private *fep) 645 + { 646 + u32 atime_inc_corr; 647 + 648 + fec_ptp_gettime(&fep->ptp_caps, &fep->ptp_saved_state.ts_phc); 649 + fep->ptp_saved_state.ns_sys = ktime_get_ns(); 650 + 651 + fep->ptp_saved_state.at_corr = readl(fep->hwp + FEC_ATIME_CORR); 652 + atime_inc_corr = readl(fep->hwp + FEC_ATIME_INC) & FEC_T_INC_CORR_MASK; 653 + fep->ptp_saved_state.at_inc_corr = (u8)(atime_inc_corr >> FEC_T_INC_CORR_OFFSET); 654 + } 655 + 656 + int fec_ptp_restore_state(struct fec_enet_private *fep) 657 + { 658 + u32 atime_inc = readl(fep->hwp + FEC_ATIME_INC) & FEC_T_INC_MASK; 659 + u64 ns_sys; 660 + 661 + writel(fep->ptp_saved_state.at_corr, fep->hwp + FEC_ATIME_CORR); 662 + atime_inc |= ((u32)fep->ptp_saved_state.at_inc_corr) << FEC_T_INC_CORR_OFFSET; 663 + writel(atime_inc, fep->hwp + FEC_ATIME_INC); 664 + 665 + ns_sys = ktime_get_ns() - fep->ptp_saved_state.ns_sys; 666 + timespec64_add_ns(&fep->ptp_saved_state.ts_phc, ns_sys); 667 + return fec_ptp_settime(&fep->ptp_caps, &fep->ptp_saved_state.ts_phc); 639 668 }

+1 -1

drivers/net/ethernet/intel/i40e/i40e_ethtool.c

··· 4485 4485 (struct in6_addr *)&ipv6_full_mask)) 4486 4486 new_mask |= I40E_L3_V6_DST_MASK; 4487 4487 else if (ipv6_addr_any((struct in6_addr *) 4488 - &usr_ip6_spec->ip6src)) 4488 + &usr_ip6_spec->ip6dst)) 4489 4489 new_mask &= ~I40E_L3_V6_DST_MASK; 4490 4490 else 4491 4491 return -EOPNOTSUPP;

+23 -13

drivers/net/ethernet/intel/ice/ice.h

··· 684 684 * ice_xsk_pool - get XSK buffer pool bound to a ring 685 685 * @ring: Rx ring to use 686 686 * 687 - * Returns a pointer to xdp_umem structure if there is a buffer pool present, 688 - * NULL otherwise. 687 + * Returns a pointer to xsk_buff_pool structure if there is a buffer pool 688 + * present, NULL otherwise. 689 689 */ 690 690 static inline struct xsk_buff_pool *ice_xsk_pool(struct ice_rx_ring *ring) 691 691 { ··· 699 699 } 700 700 701 701 /** 702 - * ice_tx_xsk_pool - get XSK buffer pool bound to a ring 703 - * @ring: Tx ring to use 702 + * ice_tx_xsk_pool - assign XSK buff pool to XDP ring 703 + * @vsi: pointer to VSI 704 + * @qid: index of a queue to look at XSK buff pool presence 704 705 * 705 - * Returns a pointer to xdp_umem structure if there is a buffer pool present, 706 - * NULL otherwise. Tx equivalent of ice_xsk_pool. 706 + * Sets XSK buff pool pointer on XDP ring. 707 + * 708 + * XDP ring is picked from Rx ring, whereas Rx ring is picked based on provided 709 + * queue id. Reason for doing so is that queue vectors might have assigned more 710 + * than one XDP ring, e.g. when user reduced the queue count on netdev; Rx ring 711 + * carries a pointer to one of these XDP rings for its own purposes, such as 712 + * handling XDP_TX action, therefore we can piggyback here on the 713 + * rx_ring->xdp_ring assignment that was done during XDP rings initialization. 707 714 */ 708 - static inline struct xsk_buff_pool *ice_tx_xsk_pool(struct ice_tx_ring *ring) 715 + static inline void ice_tx_xsk_pool(struct ice_vsi *vsi, u16 qid) 709 716 { 710 - struct ice_vsi *vsi = ring->vsi; 711 - u16 qid; 717 + struct ice_tx_ring *ring; 712 718 713 - qid = ring->q_index - vsi->alloc_txq; 719 + ring = vsi->rx_rings[qid]->xdp_ring; 720 + if (!ring) 721 + return; 714 722 715 - if (!ice_is_xdp_ena_vsi(vsi) || !test_bit(qid, vsi->af_xdp_zc_qps)) 716 - return NULL; 723 + if (!ice_is_xdp_ena_vsi(vsi) || !test_bit(qid, vsi->af_xdp_zc_qps)) { 724 + ring->xsk_pool = NULL; 725 + return; 726 + } 717 727 718 - return xsk_get_pool_from_qid(vsi->netdev, qid); 728 + ring->xsk_pool = xsk_get_pool_from_qid(vsi->netdev, qid); 719 729 } 720 730 721 731 /**

+2 -2

drivers/net/ethernet/intel/ice/ice_lib.c

··· 1986 1986 if (ret) 1987 1987 return ret; 1988 1988 1989 - ice_for_each_xdp_txq(vsi, i) 1990 - vsi->xdp_rings[i]->xsk_pool = ice_tx_xsk_pool(vsi->xdp_rings[i]); 1989 + ice_for_each_rxq(vsi, i) 1990 + ice_tx_xsk_pool(vsi, i); 1991 1991 1992 1992 return ret; 1993 1993 }

+17 -8

drivers/net/ethernet/intel/ice/ice_main.c

··· 2581 2581 if (ice_setup_tx_ring(xdp_ring)) 2582 2582 goto free_xdp_rings; 2583 2583 ice_set_ring_xdp(xdp_ring); 2584 - xdp_ring->xsk_pool = ice_tx_xsk_pool(xdp_ring); 2585 2584 spin_lock_init(&xdp_ring->tx_lock); 2586 2585 for (j = 0; j < xdp_ring->count; j++) { 2587 2586 tx_desc = ICE_TX_DESC(xdp_ring, j); 2588 2587 tx_desc->cmd_type_offset_bsz = 0; 2589 2588 } 2590 - } 2591 - 2592 - ice_for_each_rxq(vsi, i) { 2593 - if (static_key_enabled(&ice_xdp_locking_key)) 2594 - vsi->rx_rings[i]->xdp_ring = vsi->xdp_rings[i % vsi->num_xdp_txq]; 2595 - else 2596 - vsi->rx_rings[i]->xdp_ring = vsi->xdp_rings[i]; 2597 2589 } 2598 2590 2599 2591 return 0; ··· 2675 2683 q_vector->tx.tx_ring = xdp_ring; 2676 2684 } 2677 2685 xdp_rings_rem -= xdp_rings_per_v; 2686 + } 2687 + 2688 + ice_for_each_rxq(vsi, i) { 2689 + if (static_key_enabled(&ice_xdp_locking_key)) { 2690 + vsi->rx_rings[i]->xdp_ring = vsi->xdp_rings[i % vsi->num_xdp_txq]; 2691 + } else { 2692 + struct ice_q_vector *q_vector = vsi->rx_rings[i]->q_vector; 2693 + struct ice_tx_ring *ring; 2694 + 2695 + ice_for_each_tx_ring(ring, q_vector->tx) { 2696 + if (ice_ring_is_xdp(ring)) { 2697 + vsi->rx_rings[i]->xdp_ring = ring; 2698 + break; 2699 + } 2700 + } 2701 + } 2702 + ice_tx_xsk_pool(vsi, i); 2678 2703 } 2679 2704 2680 2705 /* omit the scheduler update if in reset path; XDP queues will be

+12 -6

drivers/net/ethernet/intel/ice/ice_xsk.c

··· 243 243 if (err) 244 244 goto free_buf; 245 245 ice_set_ring_xdp(xdp_ring); 246 - xdp_ring->xsk_pool = ice_tx_xsk_pool(xdp_ring); 246 + ice_tx_xsk_pool(vsi, q_idx); 247 247 } 248 248 249 249 err = ice_vsi_cfg_rxq(rx_ring); ··· 329 329 bool if_running, pool_present = !!pool; 330 330 int ret = 0, pool_failure = 0; 331 331 332 + if (qid >= vsi->num_rxq || qid >= vsi->num_txq) { 333 + netdev_err(vsi->netdev, "Please use queue id in scope of combined queues count\n"); 334 + pool_failure = -EINVAL; 335 + goto failure; 336 + } 337 + 332 338 if (!is_power_of_2(vsi->rx_rings[qid]->count) || 333 339 !is_power_of_2(vsi->tx_rings[qid]->count)) { 334 340 netdev_err(vsi->netdev, "Please align ring sizes to power of 2\n"); ··· 359 353 if (if_running) { 360 354 ret = ice_qp_ena(vsi, qid); 361 355 if (!ret && pool_present) 362 - napi_schedule(&vsi->xdp_rings[qid]->q_vector->napi); 356 + napi_schedule(&vsi->rx_rings[qid]->xdp_ring->q_vector->napi); 363 357 else if (ret) 364 358 netdev_err(vsi->netdev, "ice_qp_ena error = %d\n", ret); 365 359 } ··· 950 944 if (!ice_is_xdp_ena_vsi(vsi)) 951 945 return -EINVAL; 952 946 953 - if (queue_id >= vsi->num_txq) 947 + if (queue_id >= vsi->num_txq || queue_id >= vsi->num_rxq) 954 948 return -EINVAL; 955 949 956 - if (!vsi->xdp_rings[queue_id]->xsk_pool) 957 - return -EINVAL; 950 + ring = vsi->rx_rings[queue_id]->xdp_ring; 958 951 959 - ring = vsi->xdp_rings[queue_id]; 952 + if (!ring->xsk_pool) 953 + return -EINVAL; 960 954 961 955 /* The idea here is that if NAPI is running, mark a miss, so 962 956 * it will run again. If not, trigger an interrupt and

+46 -13

drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c

··· 1214 1214 struct cyclecounter cc; 1215 1215 unsigned long flags; 1216 1216 u32 incval = 0; 1217 - u32 tsauxc = 0; 1218 1217 u32 fuse0 = 0; 1219 1218 1220 1219 /* For some of the boards below this mask is technically incorrect. ··· 1248 1249 case ixgbe_mac_x550em_a: 1249 1250 case ixgbe_mac_X550: 1250 1251 cc.read = ixgbe_ptp_read_X550; 1251 - 1252 - /* enable SYSTIME counter */ 1253 - IXGBE_WRITE_REG(hw, IXGBE_SYSTIMR, 0); 1254 - IXGBE_WRITE_REG(hw, IXGBE_SYSTIML, 0); 1255 - IXGBE_WRITE_REG(hw, IXGBE_SYSTIMH, 0); 1256 - tsauxc = IXGBE_READ_REG(hw, IXGBE_TSAUXC); 1257 - IXGBE_WRITE_REG(hw, IXGBE_TSAUXC, 1258 - tsauxc & ~IXGBE_TSAUXC_DISABLE_SYSTIME); 1259 - IXGBE_WRITE_REG(hw, IXGBE_TSIM, IXGBE_TSIM_TXTS); 1260 - IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_TIMESYNC); 1261 - 1262 - IXGBE_WRITE_FLUSH(hw); 1263 1252 break; 1264 1253 case ixgbe_mac_X540: 1265 1254 cc.read = ixgbe_ptp_read_82599; ··· 1280 1293 } 1281 1294 1282 1295 /** 1296 + * ixgbe_ptp_init_systime - Initialize SYSTIME registers 1297 + * @adapter: the ixgbe private board structure 1298 + * 1299 + * Initialize and start the SYSTIME registers. 1300 + */ 1301 + static void ixgbe_ptp_init_systime(struct ixgbe_adapter *adapter) 1302 + { 1303 + struct ixgbe_hw *hw = &adapter->hw; 1304 + u32 tsauxc; 1305 + 1306 + switch (hw->mac.type) { 1307 + case ixgbe_mac_X550EM_x: 1308 + case ixgbe_mac_x550em_a: 1309 + case ixgbe_mac_X550: 1310 + tsauxc = IXGBE_READ_REG(hw, IXGBE_TSAUXC); 1311 + 1312 + /* Reset SYSTIME registers to 0 */ 1313 + IXGBE_WRITE_REG(hw, IXGBE_SYSTIMR, 0); 1314 + IXGBE_WRITE_REG(hw, IXGBE_SYSTIML, 0); 1315 + IXGBE_WRITE_REG(hw, IXGBE_SYSTIMH, 0); 1316 + 1317 + /* Reset interrupt settings */ 1318 + IXGBE_WRITE_REG(hw, IXGBE_TSIM, IXGBE_TSIM_TXTS); 1319 + IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_TIMESYNC); 1320 + 1321 + /* Activate the SYSTIME counter */ 1322 + IXGBE_WRITE_REG(hw, IXGBE_TSAUXC, 1323 + tsauxc & ~IXGBE_TSAUXC_DISABLE_SYSTIME); 1324 + break; 1325 + case ixgbe_mac_X540: 1326 + case ixgbe_mac_82599EB: 1327 + /* Reset SYSTIME registers to 0 */ 1328 + IXGBE_WRITE_REG(hw, IXGBE_SYSTIML, 0); 1329 + IXGBE_WRITE_REG(hw, IXGBE_SYSTIMH, 0); 1330 + break; 1331 + default: 1332 + /* Other devices aren't supported */ 1333 + return; 1334 + }; 1335 + 1336 + IXGBE_WRITE_FLUSH(hw); 1337 + } 1338 + 1339 + /** 1283 1340 * ixgbe_ptp_reset 1284 1341 * @adapter: the ixgbe private board structure 1285 1342 * ··· 1348 1317 return; 1349 1318 1350 1319 ixgbe_ptp_start_cyclecounter(adapter); 1320 + 1321 + ixgbe_ptp_init_systime(adapter); 1351 1322 1352 1323 spin_lock_irqsave(&adapter->tmreg_lock, flags); 1353 1324 timecounter_init(&adapter->hw_tc, &adapter->hw_cc,

+8 -1

drivers/net/ethernet/lantiq_xrx200.c

··· 193 193 194 194 ch->rx_buff[ch->dma.desc] = alloc(priv->rx_skb_size); 195 195 if (!ch->rx_buff[ch->dma.desc]) { 196 + ch->rx_buff[ch->dma.desc] = buf; 196 197 ret = -ENOMEM; 197 198 goto skip; 198 199 } ··· 240 239 } 241 240 242 241 skb = build_skb(buf, priv->rx_skb_size); 242 + if (!skb) { 243 + skb_free_frag(buf); 244 + net_dev->stats.rx_dropped++; 245 + return -ENOMEM; 246 + } 247 + 243 248 skb_reserve(skb, NET_SKB_PAD); 244 249 skb_put(skb, len); 245 250 ··· 295 288 if (ret == XRX200_DMA_PACKET_IN_PROGRESS) 296 289 continue; 297 290 if (ret != XRX200_DMA_PACKET_COMPLETE) 298 - return ret; 291 + break; 299 292 rx++; 300 293 } else { 301 294 break;

+12 -10

drivers/net/ethernet/mediatek/mtk_eth_soc.c

··· 1891 1891 skb->dev = netdev; 1892 1892 bytes += skb->len; 1893 1893 1894 - if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) 1894 + if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) { 1895 + hash = trxd.rxd5 & MTK_RXD5_FOE_ENTRY; 1896 + if (hash != MTK_RXD5_FOE_ENTRY) 1897 + skb_set_hash(skb, jhash_1word(hash, 0), 1898 + PKT_HASH_TYPE_L4); 1895 1899 rxdcsum = &trxd.rxd3; 1896 - else 1900 + } else { 1901 + hash = trxd.rxd4 & MTK_RXD4_FOE_ENTRY; 1902 + if (hash != MTK_RXD4_FOE_ENTRY) 1903 + skb_set_hash(skb, jhash_1word(hash, 0), 1904 + PKT_HASH_TYPE_L4); 1897 1905 rxdcsum = &trxd.rxd4; 1906 + } 1898 1907 1899 1908 if (*rxdcsum & eth->soc->txrx.rx_dma_l4_valid) 1900 1909 skb->ip_summed = CHECKSUM_UNNECESSARY; ··· 1911 1902 skb_checksum_none_assert(skb); 1912 1903 skb->protocol = eth_type_trans(skb, netdev); 1913 1904 1914 - hash = trxd.rxd4 & MTK_RXD4_FOE_ENTRY; 1915 - if (hash != MTK_RXD4_FOE_ENTRY) { 1916 - hash = jhash_1word(hash, 0); 1917 - skb_set_hash(skb, hash, PKT_HASH_TYPE_L4); 1918 - } 1919 - 1920 1905 reason = FIELD_GET(MTK_RXD4_PPE_CPU_REASON, trxd.rxd4); 1921 1906 if (reason == MTK_PPE_CPU_REASON_HIT_UNBIND_RATE_REACHED) 1922 - mtk_ppe_check_skb(eth->ppe, skb, 1923 - trxd.rxd4 & MTK_RXD4_FOE_ENTRY); 1907 + mtk_ppe_check_skb(eth->ppe, skb, hash); 1924 1908 1925 1909 if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX) { 1926 1910 if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {

+5

drivers/net/ethernet/mediatek/mtk_eth_soc.h

··· 314 314 #define RX_DMA_L4_VALID_PDMA BIT(30) /* when PDMA is used */ 315 315 #define RX_DMA_SPECIAL_TAG BIT(22) 316 316 317 + /* PDMA descriptor rxd5 */ 318 + #define MTK_RXD5_FOE_ENTRY GENMASK(14, 0) 319 + #define MTK_RXD5_PPE_CPU_REASON GENMASK(22, 18) 320 + #define MTK_RXD5_SRC_PORT GENMASK(29, 26) 321 + 317 322 #define RX_DMA_GET_SPORT(x) (((x) >> 19) & 0xf) 318 323 #define RX_DMA_GET_SPORT_V2(x) (((x) >> 26) & 0x7) 319 324

+4

drivers/net/ethernet/mellanox/mlx5/core/en/tc/act/police.c

··· 79 79 struct mlx5e_flow_meter_handle *meter; 80 80 int err = 0; 81 81 82 + err = mlx5e_policer_validate(&fl_act->action, act, fl_act->extack); 83 + if (err) 84 + return err; 85 + 82 86 err = fill_meter_params_from_act(act, &params); 83 87 if (err) 84 88 return err;

+2 -2

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

··· 246 246 static void mlx5e_tls_priv_tx_list_cleanup(struct mlx5_core_dev *mdev, 247 247 struct list_head *list, int size) 248 248 { 249 - struct mlx5e_ktls_offload_context_tx *obj; 249 + struct mlx5e_ktls_offload_context_tx *obj, *n; 250 250 struct mlx5e_async_ctx *bulk_async; 251 251 int i; 252 252 ··· 255 255 return; 256 256 257 257 i = 0; 258 - list_for_each_entry(obj, list, list_node) { 258 + list_for_each_entry_safe(obj, n, list, list_node) { 259 259 mlx5e_tls_priv_tx_cleanup(obj, &bulk_async[i]); 260 260 i++; 261 261 }

+3 -2

drivers/net/ethernet/mellanox/mlx5/core/en_fs.c

··· 1395 1395 } 1396 1396 1397 1397 return fs; 1398 - err_free_fs: 1399 - kvfree(fs); 1398 + 1400 1399 err_free_vlan: 1401 1400 mlx5e_fs_vlan_free(fs); 1401 + err_free_fs: 1402 + kvfree(fs); 1402 1403 err: 1403 1404 return NULL; 1404 1405 }

+3 -9

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

··· 3682 3682 int err = 0; 3683 3683 3684 3684 #if IS_ENABLED(CONFIG_MLX5_CLS_ACT) 3685 - if (!enable && mlx5e_tc_num_filters(priv, MLX5_TC_FLAG(NIC_OFFLOAD))) { 3685 + int tc_flag = mlx5e_is_uplink_rep(priv) ? MLX5_TC_FLAG(ESW_OFFLOAD) : 3686 + MLX5_TC_FLAG(NIC_OFFLOAD); 3687 + if (!enable && mlx5e_tc_num_filters(priv, tc_flag)) { 3686 3688 netdev_err(netdev, 3687 3689 "Active offloaded tc filters, can't turn hw_tc_offload off\n"); 3688 3690 return -EINVAL; ··· 4771 4769 /* RQ */ 4772 4770 mlx5e_build_rq_params(mdev, params); 4773 4771 4774 - /* HW LRO */ 4775 - if (MLX5_CAP_ETH(mdev, lro_cap) && 4776 - params->rq_wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ) { 4777 - /* No XSK params: checking the availability of striding RQ in general. */ 4778 - if (!mlx5e_rx_mpwqe_is_linear_skb(mdev, params, NULL)) 4779 - params->packet_merge.type = slow_pci_heuristic(mdev) ? 4780 - MLX5E_PACKET_MERGE_NONE : MLX5E_PACKET_MERGE_LRO; 4781 - } 4782 4772 params->packet_merge.timeout = mlx5e_choose_lro_timeout(mdev, MLX5E_DEFAULT_LRO_TIMEOUT); 4783 4773 4784 4774 /* CQ moderation params */

+2

drivers/net/ethernet/mellanox/mlx5/core/en_rep.c

··· 662 662 663 663 params->mqprio.num_tc = 1; 664 664 params->tunneled_offload_en = false; 665 + if (rep->vport != MLX5_VPORT_UPLINK) 666 + params->vlan_strip_disable = true; 665 667 666 668 mlx5_query_min_inline(mdev, &params->tx_min_inline_mode); 667 669 }

+5 -2

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c

··· 427 427 dest[dest_idx].vport.vhca_id = 428 428 MLX5_CAP_GEN(esw_attr->dests[attr_idx].mdev, vhca_id); 429 429 dest[dest_idx].vport.flags |= MLX5_FLOW_DEST_VPORT_VHCA_ID; 430 - if (mlx5_lag_mpesw_is_activated(esw->dev)) 430 + if (dest[dest_idx].vport.num == MLX5_VPORT_UPLINK && 431 + mlx5_lag_mpesw_is_activated(esw->dev)) 431 432 dest[dest_idx].type = MLX5_FLOW_DESTINATION_TYPE_UPLINK; 432 433 } 433 434 if (esw_attr->dests[attr_idx].flags & MLX5_ESW_DEST_ENCAP) { ··· 3116 3115 3117 3116 err = mlx5_eswitch_load_vf_vports(esw, new_num_vfs, 3118 3117 MLX5_VPORT_UC_ADDR_CHANGE); 3119 - if (err) 3118 + if (err) { 3119 + devl_unlock(devlink); 3120 3120 return; 3121 + } 3121 3122 } 3122 3123 esw->esw_funcs.num_vfs = new_num_vfs; 3123 3124 devl_unlock(devlink);

+34 -23

drivers/net/ethernet/mellanox/mlx5/core/lag/lag.c

··· 1067 1067 struct net_device *netdev) 1068 1068 { 1069 1069 unsigned int fn = mlx5_get_dev_index(dev); 1070 + unsigned long flags; 1070 1071 1071 1072 if (fn >= ldev->ports) 1072 1073 return; 1073 1074 1074 - spin_lock(&lag_lock); 1075 + spin_lock_irqsave(&lag_lock, flags); 1075 1076 ldev->pf[fn].netdev = netdev; 1076 1077 ldev->tracker.netdev_state[fn].link_up = 0; 1077 1078 ldev->tracker.netdev_state[fn].tx_enabled = 0; 1078 - spin_unlock(&lag_lock); 1079 + spin_unlock_irqrestore(&lag_lock, flags); 1079 1080 } 1080 1081 1081 1082 static void mlx5_ldev_remove_netdev(struct mlx5_lag *ldev, 1082 1083 struct net_device *netdev) 1083 1084 { 1085 + unsigned long flags; 1084 1086 int i; 1085 1087 1086 - spin_lock(&lag_lock); 1088 + spin_lock_irqsave(&lag_lock, flags); 1087 1089 for (i = 0; i < ldev->ports; i++) { 1088 1090 if (ldev->pf[i].netdev == netdev) { 1089 1091 ldev->pf[i].netdev = NULL; 1090 1092 break; 1091 1093 } 1092 1094 } 1093 - spin_unlock(&lag_lock); 1095 + spin_unlock_irqrestore(&lag_lock, flags); 1094 1096 } 1095 1097 1096 1098 static void mlx5_ldev_add_mdev(struct mlx5_lag *ldev, ··· 1236 1234 mlx5_ldev_add_netdev(ldev, dev, netdev); 1237 1235 1238 1236 for (i = 0; i < ldev->ports; i++) 1239 - if (!ldev->pf[i].dev) 1237 + if (!ldev->pf[i].netdev) 1240 1238 break; 1241 1239 1242 1240 if (i >= ldev->ports) ··· 1248 1246 bool mlx5_lag_is_roce(struct mlx5_core_dev *dev) 1249 1247 { 1250 1248 struct mlx5_lag *ldev; 1249 + unsigned long flags; 1251 1250 bool res; 1252 1251 1253 - spin_lock(&lag_lock); 1252 + spin_lock_irqsave(&lag_lock, flags); 1254 1253 ldev = mlx5_lag_dev(dev); 1255 1254 res = ldev && __mlx5_lag_is_roce(ldev); 1256 - spin_unlock(&lag_lock); 1255 + spin_unlock_irqrestore(&lag_lock, flags); 1257 1256 1258 1257 return res; 1259 1258 } ··· 1263 1260 bool mlx5_lag_is_active(struct mlx5_core_dev *dev) 1264 1261 { 1265 1262 struct mlx5_lag *ldev; 1263 + unsigned long flags; 1266 1264 bool res; 1267 1265 1268 - spin_lock(&lag_lock); 1266 + spin_lock_irqsave(&lag_lock, flags); 1269 1267 ldev = mlx5_lag_dev(dev); 1270 1268 res = ldev && __mlx5_lag_is_active(ldev); 1271 - spin_unlock(&lag_lock); 1269 + spin_unlock_irqrestore(&lag_lock, flags); 1272 1270 1273 1271 return res; 1274 1272 } ··· 1278 1274 bool mlx5_lag_is_master(struct mlx5_core_dev *dev) 1279 1275 { 1280 1276 struct mlx5_lag *ldev; 1277 + unsigned long flags; 1281 1278 bool res; 1282 1279 1283 - spin_lock(&lag_lock); 1280 + spin_lock_irqsave(&lag_lock, flags); 1284 1281 ldev = mlx5_lag_dev(dev); 1285 1282 res = ldev && __mlx5_lag_is_active(ldev) && 1286 1283 dev == ldev->pf[MLX5_LAG_P1].dev; 1287 - spin_unlock(&lag_lock); 1284 + spin_unlock_irqrestore(&lag_lock, flags); 1288 1285 1289 1286 return res; 1290 1287 } ··· 1294 1289 bool mlx5_lag_is_sriov(struct mlx5_core_dev *dev) 1295 1290 { 1296 1291 struct mlx5_lag *ldev; 1292 + unsigned long flags; 1297 1293 bool res; 1298 1294 1299 - spin_lock(&lag_lock); 1295 + spin_lock_irqsave(&lag_lock, flags); 1300 1296 ldev = mlx5_lag_dev(dev); 1301 1297 res = ldev && __mlx5_lag_is_sriov(ldev); 1302 - spin_unlock(&lag_lock); 1298 + spin_unlock_irqrestore(&lag_lock, flags); 1303 1299 1304 1300 return res; 1305 1301 } ··· 1309 1303 bool mlx5_lag_is_shared_fdb(struct mlx5_core_dev *dev) 1310 1304 { 1311 1305 struct mlx5_lag *ldev; 1306 + unsigned long flags; 1312 1307 bool res; 1313 1308 1314 - spin_lock(&lag_lock); 1309 + spin_lock_irqsave(&lag_lock, flags); 1315 1310 ldev = mlx5_lag_dev(dev); 1316 1311 res = ldev && __mlx5_lag_is_sriov(ldev) && 1317 1312 test_bit(MLX5_LAG_MODE_FLAG_SHARED_FDB, &ldev->mode_flags); 1318 - spin_unlock(&lag_lock); 1313 + spin_unlock_irqrestore(&lag_lock, flags); 1319 1314 1320 1315 return res; 1321 1316 } ··· 1359 1352 { 1360 1353 struct net_device *ndev = NULL; 1361 1354 struct mlx5_lag *ldev; 1355 + unsigned long flags; 1362 1356 int i; 1363 1357 1364 - spin_lock(&lag_lock); 1358 + spin_lock_irqsave(&lag_lock, flags); 1365 1359 ldev = mlx5_lag_dev(dev); 1366 1360 1367 1361 if (!(ldev && __mlx5_lag_is_roce(ldev))) ··· 1381 1373 dev_hold(ndev); 1382 1374 1383 1375 unlock: 1384 - spin_unlock(&lag_lock); 1376 + spin_unlock_irqrestore(&lag_lock, flags); 1385 1377 1386 1378 return ndev; 1387 1379 } ··· 1391 1383 struct net_device *slave) 1392 1384 { 1393 1385 struct mlx5_lag *ldev; 1386 + unsigned long flags; 1394 1387 u8 port = 0; 1395 1388 int i; 1396 1389 1397 - spin_lock(&lag_lock); 1390 + spin_lock_irqsave(&lag_lock, flags); 1398 1391 ldev = mlx5_lag_dev(dev); 1399 1392 if (!(ldev && __mlx5_lag_is_roce(ldev))) 1400 1393 goto unlock; ··· 1410 1401 port = ldev->v2p_map[port * ldev->buckets]; 1411 1402 1412 1403 unlock: 1413 - spin_unlock(&lag_lock); 1404 + spin_unlock_irqrestore(&lag_lock, flags); 1414 1405 return port; 1415 1406 } 1416 1407 EXPORT_SYMBOL(mlx5_lag_get_slave_port); ··· 1431 1422 { 1432 1423 struct mlx5_core_dev *peer_dev = NULL; 1433 1424 struct mlx5_lag *ldev; 1425 + unsigned long flags; 1434 1426 1435 - spin_lock(&lag_lock); 1427 + spin_lock_irqsave(&lag_lock, flags); 1436 1428 ldev = mlx5_lag_dev(dev); 1437 1429 if (!ldev) 1438 1430 goto unlock; ··· 1443 1433 ldev->pf[MLX5_LAG_P1].dev; 1444 1434 1445 1435 unlock: 1446 - spin_unlock(&lag_lock); 1436 + spin_unlock_irqrestore(&lag_lock, flags); 1447 1437 return peer_dev; 1448 1438 } 1449 1439 EXPORT_SYMBOL(mlx5_lag_get_peer_mdev); ··· 1456 1446 int outlen = MLX5_ST_SZ_BYTES(query_cong_statistics_out); 1457 1447 struct mlx5_core_dev **mdev; 1458 1448 struct mlx5_lag *ldev; 1449 + unsigned long flags; 1459 1450 int num_ports; 1460 1451 int ret, i, j; 1461 1452 void *out; ··· 1473 1462 1474 1463 memset(values, 0, sizeof(*values) * num_counters); 1475 1464 1476 - spin_lock(&lag_lock); 1465 + spin_lock_irqsave(&lag_lock, flags); 1477 1466 ldev = mlx5_lag_dev(dev); 1478 1467 if (ldev && __mlx5_lag_is_active(ldev)) { 1479 1468 num_ports = ldev->ports; ··· 1483 1472 num_ports = 1; 1484 1473 mdev[MLX5_LAG_P1] = dev; 1485 1474 } 1486 - spin_unlock(&lag_lock); 1475 + spin_unlock_irqrestore(&lag_lock, flags); 1487 1476 1488 1477 for (i = 0; i < num_ports; ++i) { 1489 1478 u32 in[MLX5_ST_SZ_DW(query_cong_statistics_in)] = {};

+4

drivers/net/ethernet/mellanox/mlx5/core/main.c

··· 1530 1530 memcpy(&dev->profile, &profile[profile_idx], sizeof(dev->profile)); 1531 1531 INIT_LIST_HEAD(&priv->ctx_list); 1532 1532 spin_lock_init(&priv->ctx_lock); 1533 + lockdep_register_key(&dev->lock_key); 1533 1534 mutex_init(&dev->intf_state_mutex); 1535 + lockdep_set_class(&dev->intf_state_mutex, &dev->lock_key); 1534 1536 1535 1537 mutex_init(&priv->bfregs.reg_head.lock); 1536 1538 mutex_init(&priv->bfregs.wc_head.lock); ··· 1599 1597 mutex_destroy(&priv->bfregs.wc_head.lock); 1600 1598 mutex_destroy(&priv->bfregs.reg_head.lock); 1601 1599 mutex_destroy(&dev->intf_state_mutex); 1600 + lockdep_unregister_key(&dev->lock_key); 1602 1601 return err; 1603 1602 } 1604 1603 ··· 1621 1618 mutex_destroy(&priv->bfregs.wc_head.lock); 1622 1619 mutex_destroy(&priv->bfregs.reg_head.lock); 1623 1620 mutex_destroy(&dev->intf_state_mutex); 1621 + lockdep_unregister_key(&dev->lock_key); 1624 1622 } 1625 1623 1626 1624 static int probe_one(struct pci_dev *pdev, const struct pci_device_id *id)

+6 -3

drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c

··· 376 376 goto out_dropped; 377 377 } 378 378 } 379 + err = mlx5_cmd_check(dev, err, in, out); 379 380 if (err) { 380 - err = mlx5_cmd_check(dev, err, in, out); 381 381 mlx5_core_warn(dev, "func_id 0x%x, npages %d, err %d\n", 382 382 func_id, npages, err); 383 383 goto out_dropped; ··· 524 524 dev->priv.reclaim_pages_discard += npages; 525 525 } 526 526 /* if triggered by FW event and failed by FW then ignore */ 527 - if (event && err == -EREMOTEIO) 527 + if (event && err == -EREMOTEIO) { 528 528 err = 0; 529 + goto out_free; 530 + } 531 + 532 + err = mlx5_cmd_check(dev, err, in, out); 529 533 if (err) { 530 - err = mlx5_cmd_check(dev, err, in, out); 531 534 mlx5_core_err(dev, "failed reclaiming pages: err %d\n", err); 532 535 goto out_free; 533 536 }

+1 -1

drivers/net/ethernet/mellanox/mlx5/core/sriov.c

··· 159 159 160 160 devl_lock(devlink); 161 161 err = mlx5_device_enable_sriov(dev, num_vfs); 162 + devl_unlock(devlink); 162 163 if (err) { 163 164 mlx5_core_warn(dev, "mlx5_device_enable_sriov failed : %d\n", err); 164 165 return err; 165 166 } 166 - devl_unlock(devlink); 167 167 168 168 err = pci_enable_sriov(pdev, num_vfs); 169 169 if (err) {

+6 -5

drivers/net/ethernet/moxa/moxart_ether.c

··· 71 71 static void moxart_mac_free_memory(struct net_device *ndev) 72 72 { 73 73 struct moxart_mac_priv_t *priv = netdev_priv(ndev); 74 - int i; 75 - 76 - for (i = 0; i < RX_DESC_NUM; i++) 77 - dma_unmap_single(&priv->pdev->dev, priv->rx_mapping[i], 78 - priv->rx_buf_size, DMA_FROM_DEVICE); 79 74 80 75 if (priv->tx_desc_base) 81 76 dma_free_coherent(&priv->pdev->dev, ··· 182 187 static int moxart_mac_stop(struct net_device *ndev) 183 188 { 184 189 struct moxart_mac_priv_t *priv = netdev_priv(ndev); 190 + int i; 185 191 186 192 napi_disable(&priv->napi); 187 193 ··· 193 197 194 198 /* disable all functions */ 195 199 writel(0, priv->base + REG_MAC_CTRL); 200 + 201 + /* unmap areas mapped in moxart_mac_setup_desc_ring() */ 202 + for (i = 0; i < RX_DESC_NUM; i++) 203 + dma_unmap_single(&priv->pdev->dev, priv->rx_mapping[i], 204 + priv->rx_buf_size, DMA_FROM_DEVICE); 196 205 197 206 return 0; 198 207 }

+90 -5

drivers/net/ethernet/pensando/ionic/ionic_lif.c

··· 1564 1564 return err; 1565 1565 } 1566 1566 1567 + static int ionic_set_attr_mac(struct ionic_lif *lif, u8 *mac) 1568 + { 1569 + struct ionic_admin_ctx ctx = { 1570 + .work = COMPLETION_INITIALIZER_ONSTACK(ctx.work), 1571 + .cmd.lif_setattr = { 1572 + .opcode = IONIC_CMD_LIF_SETATTR, 1573 + .index = cpu_to_le16(lif->index), 1574 + .attr = IONIC_LIF_ATTR_MAC, 1575 + }, 1576 + }; 1577 + 1578 + ether_addr_copy(ctx.cmd.lif_setattr.mac, mac); 1579 + return ionic_adminq_post_wait(lif, &ctx); 1580 + } 1581 + 1582 + static int ionic_get_attr_mac(struct ionic_lif *lif, u8 *mac_addr) 1583 + { 1584 + struct ionic_admin_ctx ctx = { 1585 + .work = COMPLETION_INITIALIZER_ONSTACK(ctx.work), 1586 + .cmd.lif_getattr = { 1587 + .opcode = IONIC_CMD_LIF_GETATTR, 1588 + .index = cpu_to_le16(lif->index), 1589 + .attr = IONIC_LIF_ATTR_MAC, 1590 + }, 1591 + }; 1592 + int err; 1593 + 1594 + err = ionic_adminq_post_wait(lif, &ctx); 1595 + if (err) 1596 + return err; 1597 + 1598 + ether_addr_copy(mac_addr, ctx.comp.lif_getattr.mac); 1599 + return 0; 1600 + } 1601 + 1602 + static int ionic_program_mac(struct ionic_lif *lif, u8 *mac) 1603 + { 1604 + u8 get_mac[ETH_ALEN]; 1605 + int err; 1606 + 1607 + err = ionic_set_attr_mac(lif, mac); 1608 + if (err) 1609 + return err; 1610 + 1611 + err = ionic_get_attr_mac(lif, get_mac); 1612 + if (err) 1613 + return err; 1614 + 1615 + /* To deal with older firmware that silently ignores the set attr mac: 1616 + * doesn't actually change the mac and doesn't return an error, so we 1617 + * do the get attr to verify whether or not the set actually happened 1618 + */ 1619 + if (!ether_addr_equal(get_mac, mac)) 1620 + return 1; 1621 + 1622 + return 0; 1623 + } 1624 + 1567 1625 static int ionic_set_mac_address(struct net_device *netdev, void *sa) 1568 1626 { 1627 + struct ionic_lif *lif = netdev_priv(netdev); 1569 1628 struct sockaddr *addr = sa; 1570 1629 u8 *mac; 1571 1630 int err; ··· 1632 1573 mac = (u8 *)addr->sa_data; 1633 1574 if (ether_addr_equal(netdev->dev_addr, mac)) 1634 1575 return 0; 1576 + 1577 + err = ionic_program_mac(lif, mac); 1578 + if (err < 0) 1579 + return err; 1580 + 1581 + if (err > 0) 1582 + netdev_dbg(netdev, "%s: SET and GET ATTR Mac are not equal-due to old FW running\n", 1583 + __func__); 1635 1584 1636 1585 err = eth_prepare_mac_addr_change(netdev, addr); 1637 1586 if (err) ··· 3030 2963 3031 2964 mutex_lock(&lif->queue_lock); 3032 2965 2966 + if (test_and_clear_bit(IONIC_LIF_F_BROKEN, lif->state)) 2967 + dev_info(ionic->dev, "FW Up: clearing broken state\n"); 2968 + 3033 2969 err = ionic_qcqs_alloc(lif); 3034 2970 if (err) 3035 2971 goto err_unlock; ··· 3239 3169 .attr = IONIC_LIF_ATTR_MAC, 3240 3170 }, 3241 3171 }; 3172 + u8 mac_address[ETH_ALEN]; 3242 3173 struct sockaddr addr; 3243 3174 int err; 3244 3175 ··· 3248 3177 return err; 3249 3178 netdev_dbg(lif->netdev, "found initial MAC addr %pM\n", 3250 3179 ctx.comp.lif_getattr.mac); 3251 - if (is_zero_ether_addr(ctx.comp.lif_getattr.mac)) 3252 - return 0; 3180 + ether_addr_copy(mac_address, ctx.comp.lif_getattr.mac); 3181 + 3182 + if (is_zero_ether_addr(mac_address)) { 3183 + eth_hw_addr_random(netdev); 3184 + netdev_dbg(netdev, "Random Mac generated: %pM\n", netdev->dev_addr); 3185 + ether_addr_copy(mac_address, netdev->dev_addr); 3186 + 3187 + err = ionic_program_mac(lif, mac_address); 3188 + if (err < 0) 3189 + return err; 3190 + 3191 + if (err > 0) { 3192 + netdev_dbg(netdev, "%s:SET/GET ATTR Mac are not same-due to old FW running\n", 3193 + __func__); 3194 + return 0; 3195 + } 3196 + } 3253 3197 3254 3198 if (!is_zero_ether_addr(netdev->dev_addr)) { 3255 3199 /* If the netdev mac is non-zero and doesn't match the default ··· 3272 3186 * likely here again after a fw-upgrade reset. We need to be 3273 3187 * sure the netdev mac is in our filter list. 3274 3188 */ 3275 - if (!ether_addr_equal(ctx.comp.lif_getattr.mac, 3276 - netdev->dev_addr)) 3189 + if (!ether_addr_equal(mac_address, netdev->dev_addr)) 3277 3190 ionic_lif_addr_add(lif, netdev->dev_addr); 3278 3191 } else { 3279 3192 /* Update the netdev mac with the device's mac */ 3280 - memcpy(addr.sa_data, ctx.comp.lif_getattr.mac, netdev->addr_len); 3193 + ether_addr_copy(addr.sa_data, mac_address); 3281 3194 addr.sa_family = AF_INET; 3282 3195 err = eth_prepare_mac_addr_change(netdev, &addr); 3283 3196 if (err) {

+3 -1

drivers/net/ethernet/pensando/ionic/ionic_main.c

··· 474 474 ionic_opcode_to_str(opcode), opcode, 475 475 ionic_error_to_str(err), err); 476 476 477 - msleep(1000); 478 477 iowrite32(0, &idev->dev_cmd_regs->done); 478 + msleep(1000); 479 479 iowrite32(1, &idev->dev_cmd_regs->doorbell); 480 480 goto try_again; 481 481 } ··· 487 487 488 488 return ionic_error_to_errno(err); 489 489 } 490 + 491 + ionic_dev_cmd_clean(ionic); 490 492 491 493 return 0; 492 494 }

+6 -2

drivers/net/ethernet/stmicro/stmmac/dwmac_lib.c

··· 258 258 /* Enable disable MAC RX/TX */ 259 259 void stmmac_set_mac(void __iomem *ioaddr, bool enable) 260 260 { 261 - u32 value = readl(ioaddr + MAC_CTRL_REG); 261 + u32 old_val, value; 262 + 263 + old_val = readl(ioaddr + MAC_CTRL_REG); 264 + value = old_val; 262 265 263 266 if (enable) 264 267 value |= MAC_ENABLE_RX | MAC_ENABLE_TX; 265 268 else 266 269 value &= ~(MAC_ENABLE_TX | MAC_ENABLE_RX); 267 270 268 - writel(value, ioaddr + MAC_CTRL_REG); 271 + if (value != old_val) 272 + writel(value, ioaddr + MAC_CTRL_REG); 269 273 } 270 274 271 275 void stmmac_get_mac_addr(void __iomem *ioaddr, unsigned char *addr,

+5 -4

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

··· 986 986 bool tx_pause, bool rx_pause) 987 987 { 988 988 struct stmmac_priv *priv = netdev_priv(to_net_dev(config->dev)); 989 - u32 ctrl; 989 + u32 old_ctrl, ctrl; 990 990 991 - ctrl = readl(priv->ioaddr + MAC_CTRL_REG); 992 - ctrl &= ~priv->hw->link.speed_mask; 991 + old_ctrl = readl(priv->ioaddr + MAC_CTRL_REG); 992 + ctrl = old_ctrl & ~priv->hw->link.speed_mask; 993 993 994 994 if (interface == PHY_INTERFACE_MODE_USXGMII) { 995 995 switch (speed) { ··· 1064 1064 if (tx_pause && rx_pause) 1065 1065 stmmac_mac_flow_ctrl(priv, duplex); 1066 1066 1067 - writel(ctrl, priv->ioaddr + MAC_CTRL_REG); 1067 + if (ctrl != old_ctrl) 1068 + writel(ctrl, priv->ioaddr + MAC_CTRL_REG); 1068 1069 1069 1070 stmmac_mac_set(priv, priv->ioaddr, true); 1070 1071 if (phy && priv->dma_cap.eee) {

+1 -1

drivers/net/ipa/ipa_mem.c

··· 568 568 } 569 569 570 570 /* Align the address down and the size up to a page boundary */ 571 - addr = qcom_smem_virt_to_phys(virt) & PAGE_MASK; 571 + addr = qcom_smem_virt_to_phys(virt); 572 572 phys = addr & PAGE_MASK; 573 573 size = PAGE_ALIGN(size + addr - phys); 574 574 iova = phys; /* We just want a direct mapping */

+2 -2

drivers/net/ipvlan/ipvtap.c

··· 194 194 .notifier_call = ipvtap_device_event, 195 195 }; 196 196 197 - static int ipvtap_init(void) 197 + static int __init ipvtap_init(void) 198 198 { 199 199 int err; 200 200 ··· 228 228 } 229 229 module_init(ipvtap_init); 230 230 231 - static void ipvtap_exit(void) 231 + static void __exit ipvtap_exit(void) 232 232 { 233 233 rtnl_link_unregister(&ipvtap_link_ops); 234 234 unregister_netdevice_notifier(&ipvtap_notifier_block);

+5 -6

drivers/net/macsec.c

··· 462 462 return (struct macsec_eth_header *)skb_mac_header(skb); 463 463 } 464 464 465 - static sci_t dev_to_sci(struct net_device *dev, __be16 port) 466 - { 467 - return make_sci(dev->dev_addr, port); 468 - } 469 - 470 465 static void __macsec_pn_wrapped(struct macsec_secy *secy, 471 466 struct macsec_tx_sa *tx_sa) 472 467 { ··· 3656 3661 3657 3662 out: 3658 3663 eth_hw_addr_set(dev, addr->sa_data); 3659 - macsec->secy.sci = dev_to_sci(dev, MACSEC_PORT_ES); 3660 3664 3661 3665 /* If h/w offloading is available, propagate to the device */ 3662 3666 if (macsec_is_offloaded(macsec)) { ··· 3992 3998 } 3993 3999 3994 4000 return false; 4001 + } 4002 + 4003 + static sci_t dev_to_sci(struct net_device *dev, __be16 port) 4004 + { 4005 + return make_sci(dev->dev_addr, port); 3995 4006 } 3996 4007 3997 4008 static int macsec_add_dev(struct net_device *dev, sci_t sci, u8 icv_len)

+4 -4

drivers/net/phy/phy_device.c

··· 316 316 317 317 phydev->suspended_by_mdio_bus = 0; 318 318 319 - /* If we managed to get here with the PHY state machine in a state other 320 - * than PHY_HALTED this is an indication that something went wrong and 321 - * we should most likely be using MAC managed PM and we are not. 319 + /* If we manged to get here with the PHY state machine in a state neither 320 + * PHY_HALTED nor PHY_READY this is an indication that something went wrong 321 + * and we should most likely be using MAC managed PM and we are not. 322 322 */ 323 - WARN_ON(phydev->state != PHY_HALTED && !phydev->mac_managed_pm); 323 + WARN_ON(phydev->state != PHY_HALTED && phydev->state != PHY_READY); 324 324 325 325 ret = phy_init_hw(phydev); 326 326 if (ret < 0)

+12 -15

drivers/net/usb/r8152.c

··· 5906 5906 ocp_data &= ~NOW_IS_OOB; 5907 5907 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data); 5908 5908 5909 + /* RX FIFO settings for OOB */ 5910 + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_OOB); 5911 + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_OOB); 5912 + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_OOB); 5913 + 5909 5914 rtl_disable(tp); 5910 5915 rtl_reset_bmu(tp); 5911 5916 ··· 6436 6431 u32 pause_on = tp->fc_pause_on ? tp->fc_pause_on : fc_pause_on_auto(tp); 6437 6432 u32 pause_off = tp->fc_pause_off ? tp->fc_pause_off : fc_pause_off_auto(tp); 6438 6433 6439 - switch (tp->version) { 6440 - case RTL_VER_10: 6441 - case RTL_VER_11: 6442 - ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_FULL, pause_on / 8); 6443 - ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_EMPTY, pause_off / 8); 6444 - break; 6445 - case RTL_VER_12: 6446 - case RTL_VER_13: 6447 - case RTL_VER_15: 6448 - ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_FULL, pause_on / 16); 6449 - ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_EMPTY, pause_off / 16); 6450 - break; 6451 - default: 6452 - break; 6453 - } 6434 + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_FULL, pause_on / 16); 6435 + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_EMPTY, pause_off / 16); 6454 6436 } 6455 6437 6456 6438 static void rtl8156_change_mtu(struct r8152 *tp) ··· 6548 6556 ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL); 6549 6557 ocp_data &= ~NOW_IS_OOB; 6550 6558 ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data); 6559 + 6560 + /* RX FIFO settings for OOB */ 6561 + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_FULL, 64 / 16); 6562 + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_FULL, 1024 / 16); 6563 + ocp_write_word(tp, MCU_TYPE_PLA, PLA_RX_FIFO_EMPTY, 4096 / 16); 6551 6564 6552 6565 rtl_disable(tp); 6553 6566 rtl_reset_bmu(tp);

+1

drivers/nfc/pn533/uart.c

··· 310 310 pn53x_unregister_nfc(pn532->priv); 311 311 serdev_device_close(serdev); 312 312 pn53x_common_clean(pn532->priv); 313 + del_timer_sync(&pn532->cmd_timeout); 313 314 kfree_skb(pn532->recv_skb); 314 315 kfree(pn532); 315 316 }

+1

include/linux/mlx5/driver.h

··· 779 779 enum mlx5_device_state state; 780 780 /* sync interface state */ 781 781 struct mutex intf_state_mutex; 782 + struct lock_class_key lock_key; 782 783 unsigned long intf_state; 783 784 struct mlx5_priv priv; 784 785 struct mlx5_profile profile;

+17 -3

include/linux/netdevice.h

··· 640 640 */ 641 641 static inline bool net_has_fallback_tunnels(const struct net *net) 642 642 { 643 - return !IS_ENABLED(CONFIG_SYSCTL) || 644 - !sysctl_fb_tunnels_only_for_init_net || 645 - (net == &init_net && sysctl_fb_tunnels_only_for_init_net == 1); 643 + #if IS_ENABLED(CONFIG_SYSCTL) 644 + int fb_tunnels_only_for_init_net = READ_ONCE(sysctl_fb_tunnels_only_for_init_net); 645 + 646 + return !fb_tunnels_only_for_init_net || 647 + (net_eq(net, &init_net) && fb_tunnels_only_for_init_net == 1); 648 + #else 649 + return true; 650 + #endif 651 + } 652 + 653 + static inline int net_inherit_devconf(void) 654 + { 655 + #if IS_ENABLED(CONFIG_SYSCTL) 656 + return READ_ONCE(sysctl_devconf_inherit_init_net); 657 + #else 658 + return 0; 659 + #endif 646 660 } 647 661 648 662 static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)

-4

include/linux/netfilter_bridge/ebtables.h

··· 94 94 struct ebt_replace_kernel *table; 95 95 unsigned int valid_hooks; 96 96 rwlock_t lock; 97 - /* e.g. could be the table explicitly only allows certain 98 - * matches, targets, ... 0 == let it in */ 99 - int (*check)(const struct ebt_table_info *info, 100 - unsigned int valid_hooks); 101 97 /* the data used by the kernel */ 102 98 struct ebt_table_info *private; 103 99 struct nf_hook_ops *ops;

+1 -1

include/net/bond_3ad.h

··· 290 290 } 291 291 292 292 /* ========== AD Exported functions to the main bonding code ========== */ 293 - void bond_3ad_initialize(struct bonding *bond, u16 tick_resolution); 293 + void bond_3ad_initialize(struct bonding *bond); 294 294 void bond_3ad_bind_slave(struct slave *slave); 295 295 void bond_3ad_unbind_slave(struct slave *slave); 296 296 void bond_3ad_state_machine_handler(struct work_struct *);

+1 -1

include/net/busy_poll.h

··· 33 33 34 34 static inline bool net_busy_loop_on(void) 35 35 { 36 - return sysctl_net_busy_poll; 36 + return READ_ONCE(sysctl_net_busy_poll); 37 37 } 38 38 39 39 static inline bool sk_can_busy_loop(const struct sock *sk)

+1 -1

include/net/gro.h

··· 439 439 { 440 440 list_add_tail(&skb->list, &napi->rx_list); 441 441 napi->rx_count += segs; 442 - if (napi->rx_count >= gro_normal_batch) 442 + if (napi->rx_count >= READ_ONCE(gro_normal_batch)) 443 443 gro_normal_list(napi); 444 444 } 445 445

+3

include/net/netfilter/nf_flow_table.h

··· 270 270 271 271 struct flow_offload_tuple_rhash *flow_offload_lookup(struct nf_flowtable *flow_table, 272 272 struct flow_offload_tuple *tuple); 273 + void nf_flow_table_gc_run(struct nf_flowtable *flow_table); 273 274 void nf_flow_table_gc_cleanup(struct nf_flowtable *flowtable, 274 275 struct net_device *dev); 275 276 void nf_flow_table_cleanup(struct net_device *dev); ··· 307 306 struct flow_offload *flow); 308 307 309 308 void nf_flow_table_offload_flush(struct nf_flowtable *flowtable); 309 + void nf_flow_table_offload_flush_cleanup(struct nf_flowtable *flowtable); 310 + 310 311 int nf_flow_table_offload_setup(struct nf_flowtable *flowtable, 311 312 struct net_device *dev, 312 313 enum flow_block_command cmd);

+1

include/net/netfilter/nf_tables.h

··· 1652 1652 struct list_head module_list; 1653 1653 struct list_head notify_list; 1654 1654 struct mutex commit_mutex; 1655 + u64 table_handle; 1655 1656 unsigned int base_seq; 1656 1657 u8 validate_state; 1657 1658 };

+1 -1

include/uapi/linux/xfrm.h

··· 296 296 XFRMA_ETIMER_THRESH, 297 297 XFRMA_SRCADDR, /* xfrm_address_t */ 298 298 XFRMA_COADDR, /* xfrm_address_t */ 299 - XFRMA_LASTUSED, /* unsigned long */ 299 + XFRMA_LASTUSED, /* __u64 */ 300 300 XFRMA_POLICY_TYPE, /* struct xfrm_userpolicy_type */ 301 301 XFRMA_MIGRATE, 302 302 XFRMA_ALG_AEAD, /* struct xfrm_algo_aead */

+9 -3

lib/ratelimit.c

··· 26 26 */ 27 27 int ___ratelimit(struct ratelimit_state *rs, const char *func) 28 28 { 29 + /* Paired with WRITE_ONCE() in .proc_handler(). 30 + * Changing two values seperately could be inconsistent 31 + * and some message could be lost. (See: net_ratelimit_state). 32 + */ 33 + int interval = READ_ONCE(rs->interval); 34 + int burst = READ_ONCE(rs->burst); 29 35 unsigned long flags; 30 36 int ret; 31 37 32 - if (!rs->interval) 38 + if (!interval) 33 39 return 1; 34 40 35 41 /* ··· 50 44 if (!rs->begin) 51 45 rs->begin = jiffies; 52 46 53 - if (time_is_before_jiffies(rs->begin + rs->interval)) { 47 + if (time_is_before_jiffies(rs->begin + interval)) { 54 48 if (rs->missed) { 55 49 if (!(rs->flags & RATELIMIT_MSG_ON_RELEASE)) { 56 50 printk_deferred(KERN_WARNING ··· 62 56 rs->begin = jiffies; 63 57 rs->printed = 0; 64 58 } 65 - if (rs->burst && rs->burst > rs->printed) { 59 + if (burst && burst > rs->printed) { 66 60 rs->printed++; 67 61 ret = 1; 68 62 } else {

-8

net/bridge/netfilter/ebtable_broute.c

··· 36 36 .entries = (char *)&initial_chain, 37 37 }; 38 38 39 - static int check(const struct ebt_table_info *info, unsigned int valid_hooks) 40 - { 41 - if (valid_hooks & ~(1 << NF_BR_BROUTING)) 42 - return -EINVAL; 43 - return 0; 44 - } 45 - 46 39 static const struct ebt_table broute_table = { 47 40 .name = "broute", 48 41 .table = &initial_table, 49 42 .valid_hooks = 1 << NF_BR_BROUTING, 50 - .check = check, 51 43 .me = THIS_MODULE, 52 44 }; 53 45

-8

net/bridge/netfilter/ebtable_filter.c

··· 43 43 .entries = (char *)initial_chains, 44 44 }; 45 45 46 - static int check(const struct ebt_table_info *info, unsigned int valid_hooks) 47 - { 48 - if (valid_hooks & ~FILTER_VALID_HOOKS) 49 - return -EINVAL; 50 - return 0; 51 - } 52 - 53 46 static const struct ebt_table frame_filter = { 54 47 .name = "filter", 55 48 .table = &initial_table, 56 49 .valid_hooks = FILTER_VALID_HOOKS, 57 - .check = check, 58 50 .me = THIS_MODULE, 59 51 }; 60 52

-8

net/bridge/netfilter/ebtable_nat.c

··· 43 43 .entries = (char *)initial_chains, 44 44 }; 45 45 46 - static int check(const struct ebt_table_info *info, unsigned int valid_hooks) 47 - { 48 - if (valid_hooks & ~NAT_VALID_HOOKS) 49 - return -EINVAL; 50 - return 0; 51 - } 52 - 53 46 static const struct ebt_table frame_nat = { 54 47 .name = "nat", 55 48 .table = &initial_table, 56 49 .valid_hooks = NAT_VALID_HOOKS, 57 - .check = check, 58 50 .me = THIS_MODULE, 59 51 }; 60 52

+1 -7

net/bridge/netfilter/ebtables.c

··· 1040 1040 goto free_iterate; 1041 1041 } 1042 1042 1043 - /* the table doesn't like it */ 1044 - if (t->check && (ret = t->check(newinfo, repl->valid_hooks))) 1043 + if (repl->valid_hooks != t->valid_hooks) 1045 1044 goto free_unlock; 1046 1045 1047 1046 if (repl->num_counters && repl->num_counters != t->private->nentries) { ··· 1229 1230 ret = translate_table(net, repl->name, newinfo); 1230 1231 if (ret != 0) 1231 1232 goto free_chainstack; 1232 - 1233 - if (table->check && table->check(newinfo, table->valid_hooks)) { 1234 - ret = -EINVAL; 1235 - goto free_chainstack; 1236 - } 1237 1233 1238 1234 table->private = newinfo; 1239 1235 rwlock_init(&table->lock);

+3 -2

net/core/bpf_sk_storage.c

··· 310 310 static int bpf_sk_storage_charge(struct bpf_local_storage_map *smap, 311 311 void *owner, u32 size) 312 312 { 313 + int optmem_max = READ_ONCE(sysctl_optmem_max); 313 314 struct sock *sk = (struct sock *)owner; 314 315 315 316 /* same check as in sock_kmalloc() */ 316 - if (size <= sysctl_optmem_max && 317 - atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) { 317 + if (size <= optmem_max && 318 + atomic_read(&sk->sk_omem_alloc) + size < optmem_max) { 318 319 atomic_add(size, &sk->sk_omem_alloc); 319 320 return 0; 320 321 }

+10 -10

net/core/dev.c

··· 4624 4624 struct softnet_data *sd; 4625 4625 unsigned int old_flow, new_flow; 4626 4626 4627 - if (qlen < (netdev_max_backlog >> 1)) 4627 + if (qlen < (READ_ONCE(netdev_max_backlog) >> 1)) 4628 4628 return false; 4629 4629 4630 4630 sd = this_cpu_ptr(&softnet_data); ··· 4672 4672 if (!netif_running(skb->dev)) 4673 4673 goto drop; 4674 4674 qlen = skb_queue_len(&sd->input_pkt_queue); 4675 - if (qlen <= netdev_max_backlog && !skb_flow_limit(skb, qlen)) { 4675 + if (qlen <= READ_ONCE(netdev_max_backlog) && !skb_flow_limit(skb, qlen)) { 4676 4676 if (qlen) { 4677 4677 enqueue: 4678 4678 __skb_queue_tail(&sd->input_pkt_queue, skb); ··· 4928 4928 { 4929 4929 int ret; 4930 4930 4931 - net_timestamp_check(netdev_tstamp_prequeue, skb); 4931 + net_timestamp_check(READ_ONCE(netdev_tstamp_prequeue), skb); 4932 4932 4933 4933 trace_netif_rx(skb); 4934 4934 ··· 5281 5281 int ret = NET_RX_DROP; 5282 5282 __be16 type; 5283 5283 5284 - net_timestamp_check(!netdev_tstamp_prequeue, skb); 5284 + net_timestamp_check(!READ_ONCE(netdev_tstamp_prequeue), skb); 5285 5285 5286 5286 trace_netif_receive_skb(skb); 5287 5287 ··· 5664 5664 { 5665 5665 int ret; 5666 5666 5667 - net_timestamp_check(netdev_tstamp_prequeue, skb); 5667 + net_timestamp_check(READ_ONCE(netdev_tstamp_prequeue), skb); 5668 5668 5669 5669 if (skb_defer_rx_timestamp(skb)) 5670 5670 return NET_RX_SUCCESS; ··· 5694 5694 5695 5695 INIT_LIST_HEAD(&sublist); 5696 5696 list_for_each_entry_safe(skb, next, head, list) { 5697 - net_timestamp_check(netdev_tstamp_prequeue, skb); 5697 + net_timestamp_check(READ_ONCE(netdev_tstamp_prequeue), skb); 5698 5698 skb_list_del_init(skb); 5699 5699 if (!skb_defer_rx_timestamp(skb)) 5700 5700 list_add_tail(&skb->list, &sublist); ··· 5918 5918 net_rps_action_and_irq_enable(sd); 5919 5919 } 5920 5920 5921 - napi->weight = dev_rx_weight; 5921 + napi->weight = READ_ONCE(dev_rx_weight); 5922 5922 while (again) { 5923 5923 struct sk_buff *skb; 5924 5924 ··· 6665 6665 { 6666 6666 struct softnet_data *sd = this_cpu_ptr(&softnet_data); 6667 6667 unsigned long time_limit = jiffies + 6668 - usecs_to_jiffies(netdev_budget_usecs); 6669 - int budget = netdev_budget; 6668 + usecs_to_jiffies(READ_ONCE(netdev_budget_usecs)); 6669 + int budget = READ_ONCE(netdev_budget); 6670 6670 LIST_HEAD(list); 6671 6671 LIST_HEAD(repoll); 6672 6672 ··· 10284 10284 return dev; 10285 10285 10286 10286 if (time_after(jiffies, warning_time + 10287 - netdev_unregister_timeout_secs * HZ)) { 10287 + READ_ONCE(netdev_unregister_timeout_secs) * HZ)) { 10288 10288 list_for_each_entry(dev, list, todo_list) { 10289 10289 pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n", 10290 10290 dev->name, netdev_refcnt_read(dev));

+7 -6

net/core/filter.c

··· 1214 1214 static bool __sk_filter_charge(struct sock *sk, struct sk_filter *fp) 1215 1215 { 1216 1216 u32 filter_size = bpf_prog_size(fp->prog->len); 1217 + int optmem_max = READ_ONCE(sysctl_optmem_max); 1217 1218 1218 1219 /* same check as in sock_kmalloc() */ 1219 - if (filter_size <= sysctl_optmem_max && 1220 - atomic_read(&sk->sk_omem_alloc) + filter_size < sysctl_optmem_max) { 1220 + if (filter_size <= optmem_max && 1221 + atomic_read(&sk->sk_omem_alloc) + filter_size < optmem_max) { 1221 1222 atomic_add(filter_size, &sk->sk_omem_alloc); 1222 1223 return true; 1223 1224 } ··· 1549 1548 if (IS_ERR(prog)) 1550 1549 return PTR_ERR(prog); 1551 1550 1552 - if (bpf_prog_size(prog->len) > sysctl_optmem_max) 1551 + if (bpf_prog_size(prog->len) > READ_ONCE(sysctl_optmem_max)) 1553 1552 err = -ENOMEM; 1554 1553 else 1555 1554 err = reuseport_attach_prog(sk, prog); ··· 1616 1615 } 1617 1616 } else { 1618 1617 /* BPF_PROG_TYPE_SOCKET_FILTER */ 1619 - if (bpf_prog_size(prog->len) > sysctl_optmem_max) { 1618 + if (bpf_prog_size(prog->len) > READ_ONCE(sysctl_optmem_max)) { 1620 1619 err = -ENOMEM; 1621 1620 goto err_prog_put; 1622 1621 } ··· 5035 5034 /* Only some socketops are supported */ 5036 5035 switch (optname) { 5037 5036 case SO_RCVBUF: 5038 - val = min_t(u32, val, sysctl_rmem_max); 5037 + val = min_t(u32, val, READ_ONCE(sysctl_rmem_max)); 5039 5038 val = min_t(int, val, INT_MAX / 2); 5040 5039 sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5041 5040 WRITE_ONCE(sk->sk_rcvbuf, 5042 5041 max_t(int, val * 2, SOCK_MIN_RCVBUF)); 5043 5042 break; 5044 5043 case SO_SNDBUF: 5045 - val = min_t(u32, val, sysctl_wmem_max); 5044 + val = min_t(u32, val, READ_ONCE(sysctl_wmem_max)); 5046 5045 val = min_t(int, val, INT_MAX / 2); 5047 5046 sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5048 5047 WRITE_ONCE(sk->sk_sndbuf,

+1 -1

net/core/gro_cells.c

··· 26 26 27 27 cell = this_cpu_ptr(gcells->cells); 28 28 29 - if (skb_queue_len(&cell->napi_skbs) > netdev_max_backlog) { 29 + if (skb_queue_len(&cell->napi_skbs) > READ_ONCE(netdev_max_backlog)) { 30 30 drop: 31 31 dev_core_stats_rx_dropped_inc(dev); 32 32 kfree_skb(skb);

+9 -3

net/core/neighbour.c

··· 309 309 310 310 static void pneigh_queue_purge(struct sk_buff_head *list, struct net *net) 311 311 { 312 + struct sk_buff_head tmp; 312 313 unsigned long flags; 313 314 struct sk_buff *skb; 314 315 316 + skb_queue_head_init(&tmp); 315 317 spin_lock_irqsave(&list->lock, flags); 316 318 skb = skb_peek(list); 317 319 while (skb != NULL) { 318 320 struct sk_buff *skb_next = skb_peek_next(skb, list); 319 321 struct net_device *dev = skb->dev; 322 + 320 323 if (net == NULL || net_eq(dev_net(dev), net)) { 321 324 struct in_device *in_dev; 322 325 ··· 329 326 in_dev->arp_parms->qlen--; 330 327 rcu_read_unlock(); 331 328 __skb_unlink(skb, list); 332 - 333 - dev_put(dev); 334 - kfree_skb(skb); 329 + __skb_queue_tail(&tmp, skb); 335 330 } 336 331 skb = skb_next; 337 332 } 338 333 spin_unlock_irqrestore(&list->lock, flags); 334 + 335 + while ((skb = __skb_dequeue(&tmp))) { 336 + dev_put(skb->dev); 337 + kfree_skb(skb); 338 + } 339 339 } 340 340 341 341 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev,

+3 -4

net/core/skbuff.c

··· 4205 4205 SKB_GSO_CB(nskb)->csum_start = 4206 4206 skb_headroom(nskb) + doffset; 4207 4207 } else { 4208 - skb_copy_bits(head_skb, offset, 4209 - skb_put(nskb, len), 4210 - len); 4208 + if (skb_copy_bits(head_skb, offset, skb_put(nskb, len), len)) 4209 + goto err; 4211 4210 } 4212 4211 continue; 4213 4212 } ··· 4797 4798 { 4798 4799 bool ret; 4799 4800 4800 - if (likely(sysctl_tstamp_allow_data || tsonly)) 4801 + if (likely(READ_ONCE(sysctl_tstamp_allow_data) || tsonly)) 4801 4802 return true; 4802 4803 4803 4804 read_lock_bh(&sk->sk_callback_lock);

+10 -8

net/core/sock.c

··· 1101 1101 * play 'guess the biggest size' games. RCVBUF/SNDBUF 1102 1102 * are treated in BSD as hints 1103 1103 */ 1104 - val = min_t(u32, val, sysctl_wmem_max); 1104 + val = min_t(u32, val, READ_ONCE(sysctl_wmem_max)); 1105 1105 set_sndbuf: 1106 1106 /* Ensure val * 2 fits into an int, to prevent max_t() 1107 1107 * from treating it as a negative value. ··· 1133 1133 * play 'guess the biggest size' games. RCVBUF/SNDBUF 1134 1134 * are treated in BSD as hints 1135 1135 */ 1136 - __sock_set_rcvbuf(sk, min_t(u32, val, sysctl_rmem_max)); 1136 + __sock_set_rcvbuf(sk, min_t(u32, val, READ_ONCE(sysctl_rmem_max))); 1137 1137 break; 1138 1138 1139 1139 case SO_RCVBUFFORCE: ··· 2536 2536 2537 2537 /* small safe race: SKB_TRUESIZE may differ from final skb->truesize */ 2538 2538 if (atomic_read(&sk->sk_omem_alloc) + SKB_TRUESIZE(size) > 2539 - sysctl_optmem_max) 2539 + READ_ONCE(sysctl_optmem_max)) 2540 2540 return NULL; 2541 2541 2542 2542 skb = alloc_skb(size, priority); ··· 2554 2554 */ 2555 2555 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority) 2556 2556 { 2557 - if ((unsigned int)size <= sysctl_optmem_max && 2558 - atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) { 2557 + int optmem_max = READ_ONCE(sysctl_optmem_max); 2558 + 2559 + if ((unsigned int)size <= optmem_max && 2560 + atomic_read(&sk->sk_omem_alloc) + size < optmem_max) { 2559 2561 void *mem; 2560 2562 /* First do the add, to avoid the race if kmalloc 2561 2563 * might sleep. ··· 3311 3309 timer_setup(&sk->sk_timer, NULL, 0); 3312 3310 3313 3311 sk->sk_allocation = GFP_KERNEL; 3314 - sk->sk_rcvbuf = sysctl_rmem_default; 3315 - sk->sk_sndbuf = sysctl_wmem_default; 3312 + sk->sk_rcvbuf = READ_ONCE(sysctl_rmem_default); 3313 + sk->sk_sndbuf = READ_ONCE(sysctl_wmem_default); 3316 3314 sk->sk_state = TCP_CLOSE; 3317 3315 sk_set_socket(sk, sock); 3318 3316 ··· 3367 3365 3368 3366 #ifdef CONFIG_NET_RX_BUSY_POLL 3369 3367 sk->sk_napi_id = 0; 3370 - sk->sk_ll_usec = sysctl_net_busy_read; 3368 + sk->sk_ll_usec = READ_ONCE(sysctl_net_busy_read); 3371 3369 #endif 3372 3370 3373 3371 sk->sk_max_pacing_rate = ~0UL;

+9 -6

net/core/sysctl_net_core.c

··· 234 234 static int proc_do_dev_weight(struct ctl_table *table, int write, 235 235 void *buffer, size_t *lenp, loff_t *ppos) 236 236 { 237 - int ret; 237 + static DEFINE_MUTEX(dev_weight_mutex); 238 + int ret, weight; 238 239 240 + mutex_lock(&dev_weight_mutex); 239 241 ret = proc_dointvec(table, write, buffer, lenp, ppos); 240 - if (ret != 0) 241 - return ret; 242 - 243 - dev_rx_weight = weight_p * dev_weight_rx_bias; 244 - dev_tx_weight = weight_p * dev_weight_tx_bias; 242 + if (!ret && write) { 243 + weight = READ_ONCE(weight_p); 244 + WRITE_ONCE(dev_rx_weight, weight * dev_weight_rx_bias); 245 + WRITE_ONCE(dev_tx_weight, weight * dev_weight_tx_bias); 246 + } 247 + mutex_unlock(&dev_weight_mutex); 245 248 246 249 return ret; 247 250 }

+1 -1

net/dsa/slave.c

··· 2484 2484 if (!err) 2485 2485 dsa_bridge_mtu_normalization(dp); 2486 2486 if (err == -EOPNOTSUPP) { 2487 - if (!extack->_msg) 2487 + if (extack && !extack->_msg) 2488 2488 NL_SET_ERR_MSG_MOD(extack, 2489 2489 "Offloading not supported"); 2490 2490 err = 0;

+10 -6

net/ipv4/devinet.c

··· 2682 2682 #endif 2683 2683 2684 2684 if (!net_eq(net, &init_net)) { 2685 - if (IS_ENABLED(CONFIG_SYSCTL) && 2686 - sysctl_devconf_inherit_init_net == 3) { 2685 + switch (net_inherit_devconf()) { 2686 + case 3: 2687 2687 /* copy from the current netns */ 2688 2688 memcpy(all, current->nsproxy->net_ns->ipv4.devconf_all, 2689 2689 sizeof(ipv4_devconf)); 2690 2690 memcpy(dflt, 2691 2691 current->nsproxy->net_ns->ipv4.devconf_dflt, 2692 2692 sizeof(ipv4_devconf_dflt)); 2693 - } else if (!IS_ENABLED(CONFIG_SYSCTL) || 2694 - sysctl_devconf_inherit_init_net != 2) { 2695 - /* inherit == 0 or 1: copy from init_net */ 2693 + break; 2694 + case 0: 2695 + case 1: 2696 + /* copy from init_net */ 2696 2697 memcpy(all, init_net.ipv4.devconf_all, 2697 2698 sizeof(ipv4_devconf)); 2698 2699 memcpy(dflt, init_net.ipv4.devconf_dflt, 2699 2700 sizeof(ipv4_devconf_dflt)); 2701 + break; 2702 + case 2: 2703 + /* use compiled values */ 2704 + break; 2700 2705 } 2701 - /* else inherit == 2: use compiled values */ 2702 2706 } 2703 2707 2704 2708 #ifdef CONFIG_SYSCTL

+1 -1

net/ipv4/ip_output.c

··· 1730 1730 1731 1731 sk->sk_protocol = ip_hdr(skb)->protocol; 1732 1732 sk->sk_bound_dev_if = arg->bound_dev_if; 1733 - sk->sk_sndbuf = sysctl_wmem_default; 1733 + sk->sk_sndbuf = READ_ONCE(sysctl_wmem_default); 1734 1734 ipc.sockc.mark = fl4.flowi4_mark; 1735 1735 err = ip_append_data(sk, &fl4, ip_reply_glue_bits, arg->iov->iov_base, 1736 1736 len, 0, &ipc, &rt, MSG_DONTWAIT);

+3 -3

net/ipv4/ip_sockglue.c

··· 772 772 773 773 if (optlen < GROUP_FILTER_SIZE(0)) 774 774 return -EINVAL; 775 - if (optlen > sysctl_optmem_max) 775 + if (optlen > READ_ONCE(sysctl_optmem_max)) 776 776 return -ENOBUFS; 777 777 778 778 gsf = memdup_sockptr(optval, optlen); ··· 808 808 809 809 if (optlen < size0) 810 810 return -EINVAL; 811 - if (optlen > sysctl_optmem_max - 4) 811 + if (optlen > READ_ONCE(sysctl_optmem_max) - 4) 812 812 return -ENOBUFS; 813 813 814 814 p = kmalloc(optlen + 4, GFP_KERNEL); ··· 1233 1233 1234 1234 if (optlen < IP_MSFILTER_SIZE(0)) 1235 1235 goto e_inval; 1236 - if (optlen > sysctl_optmem_max) { 1236 + if (optlen > READ_ONCE(sysctl_optmem_max)) { 1237 1237 err = -ENOBUFS; 1238 1238 break; 1239 1239 }

+2 -2

net/ipv4/tcp.c

··· 1000 1000 1001 1001 i = skb_shinfo(skb)->nr_frags; 1002 1002 can_coalesce = skb_can_coalesce(skb, i, page, offset); 1003 - if (!can_coalesce && i >= sysctl_max_skb_frags) { 1003 + if (!can_coalesce && i >= READ_ONCE(sysctl_max_skb_frags)) { 1004 1004 tcp_mark_push(tp, skb); 1005 1005 goto new_segment; 1006 1006 } ··· 1354 1354 1355 1355 if (!skb_can_coalesce(skb, i, pfrag->page, 1356 1356 pfrag->offset)) { 1357 - if (i >= sysctl_max_skb_frags) { 1357 + if (i >= READ_ONCE(sysctl_max_skb_frags)) { 1358 1358 tcp_mark_push(tp, skb); 1359 1359 goto new_segment; 1360 1360 }

+1 -1

net/ipv4/tcp_output.c

··· 239 239 if (wscale_ok) { 240 240 /* Set window scaling on max possible window */ 241 241 space = max_t(u32, space, READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[2])); 242 - space = max_t(u32, space, sysctl_rmem_max); 242 + space = max_t(u32, space, READ_ONCE(sysctl_rmem_max)); 243 243 space = min_t(u32, space, *window_clamp); 244 244 *rcv_wscale = clamp_t(int, ilog2(space) - 15, 245 245 0, TCP_MAX_WSCALE);

+2 -3

net/ipv6/addrconf.c

··· 7162 7162 if (!dflt) 7163 7163 goto err_alloc_dflt; 7164 7164 7165 - if (IS_ENABLED(CONFIG_SYSCTL) && 7166 - !net_eq(net, &init_net)) { 7167 - switch (sysctl_devconf_inherit_init_net) { 7165 + if (!net_eq(net, &init_net)) { 7166 + switch (net_inherit_devconf()) { 7168 7167 case 1: /* copy from init_net */ 7169 7168 memcpy(all, init_net.ipv6.devconf_all, 7170 7169 sizeof(ipv6_devconf));

+2 -2

net/ipv6/ipv6_sockglue.c

··· 210 210 211 211 if (optlen < GROUP_FILTER_SIZE(0)) 212 212 return -EINVAL; 213 - if (optlen > sysctl_optmem_max) 213 + if (optlen > READ_ONCE(sysctl_optmem_max)) 214 214 return -ENOBUFS; 215 215 216 216 gsf = memdup_sockptr(optval, optlen); ··· 244 244 245 245 if (optlen < size0) 246 246 return -EINVAL; 247 - if (optlen > sysctl_optmem_max - 4) 247 + if (optlen > READ_ONCE(sysctl_optmem_max) - 4) 248 248 return -ENOBUFS; 249 249 250 250 p = kmalloc(optlen + 4, GFP_KERNEL);

-1

net/ipv6/netfilter/nf_conntrack_reasm.c

··· 86 86 table[1].extra2 = &nf_frag->fqdir->high_thresh; 87 87 table[2].data = &nf_frag->fqdir->high_thresh; 88 88 table[2].extra1 = &nf_frag->fqdir->low_thresh; 89 - table[2].extra2 = &nf_frag->fqdir->high_thresh; 90 89 91 90 hdr = register_net_sysctl(net, "net/netfilter", table); 92 91 if (hdr == NULL)

+3

net/key/af_key.c

··· 1697 1697 pfk->registered |= (1<<hdr->sadb_msg_satype); 1698 1698 } 1699 1699 1700 + mutex_lock(&pfkey_mutex); 1700 1701 xfrm_probe_algs(); 1701 1702 1702 1703 supp_skb = compose_sadb_supported(hdr, GFP_KERNEL | __GFP_ZERO); 1704 + mutex_unlock(&pfkey_mutex); 1705 + 1703 1706 if (!supp_skb) { 1704 1707 if (hdr->sadb_msg_satype != SADB_SATYPE_UNSPEC) 1705 1708 pfk->registered &= ~(1<<hdr->sadb_msg_satype);

+1 -1

net/mptcp/protocol.c

··· 1263 1263 1264 1264 i = skb_shinfo(skb)->nr_frags; 1265 1265 can_coalesce = skb_can_coalesce(skb, i, dfrag->page, offset); 1266 - if (!can_coalesce && i >= sysctl_max_skb_frags) { 1266 + if (!can_coalesce && i >= READ_ONCE(sysctl_max_skb_frags)) { 1267 1267 tcp_mark_push(tcp_sk(ssk), skb); 1268 1268 goto alloc_skb; 1269 1269 }

+2 -2

net/netfilter/ipvs/ip_vs_sync.c

··· 1280 1280 lock_sock(sk); 1281 1281 if (mode) { 1282 1282 val = clamp_t(int, val, (SOCK_MIN_SNDBUF + 1) / 2, 1283 - sysctl_wmem_max); 1283 + READ_ONCE(sysctl_wmem_max)); 1284 1284 sk->sk_sndbuf = val * 2; 1285 1285 sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 1286 1286 } else { 1287 1287 val = clamp_t(int, val, (SOCK_MIN_RCVBUF + 1) / 2, 1288 - sysctl_rmem_max); 1288 + READ_ONCE(sysctl_rmem_max)); 1289 1289 sk->sk_rcvbuf = val * 2; 1290 1290 sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 1291 1291 }

+31

net/netfilter/nf_conntrack_proto_tcp.c

··· 655 655 tn->tcp_be_liberal) 656 656 res = true; 657 657 if (!res) { 658 + bool seq_ok = before(seq, sender->td_maxend + 1); 659 + 660 + if (!seq_ok) { 661 + u32 overshot = end - sender->td_maxend + 1; 662 + bool ack_ok; 663 + 664 + ack_ok = after(sack, receiver->td_end - MAXACKWINDOW(sender) - 1); 665 + 666 + if (in_recv_win && 667 + ack_ok && 668 + overshot <= receiver->td_maxwin && 669 + before(sack, receiver->td_end + 1)) { 670 + /* Work around TCPs that send more bytes than allowed by 671 + * the receive window. 672 + * 673 + * If the (marked as invalid) packet is allowed to pass by 674 + * the ruleset and the peer acks this data, then its possible 675 + * all future packets will trigger 'ACK is over upper bound' check. 676 + * 677 + * Thus if only the sequence check fails then do update td_end so 678 + * possible ACK for this data can update internal state. 679 + */ 680 + sender->td_end = end; 681 + sender->flags |= IP_CT_TCP_FLAG_DATA_UNACKNOWLEDGED; 682 + 683 + nf_ct_l4proto_log_invalid(skb, ct, hook_state, 684 + "%u bytes more than expected", overshot); 685 + return res; 686 + } 687 + } 688 + 658 689 nf_ct_l4proto_log_invalid(skb, ct, hook_state, 659 690 "%s", 660 691 before(seq, sender->td_maxend + 1) ?

+10 -5

net/netfilter/nf_flow_table_core.c

··· 437 437 } 438 438 } 439 439 440 + void nf_flow_table_gc_run(struct nf_flowtable *flow_table) 441 + { 442 + nf_flow_table_iterate(flow_table, nf_flow_offload_gc_step, NULL); 443 + } 444 + 440 445 static void nf_flow_offload_work_gc(struct work_struct *work) 441 446 { 442 447 struct nf_flowtable *flow_table; 443 448 444 449 flow_table = container_of(work, struct nf_flowtable, gc_work.work); 445 - nf_flow_table_iterate(flow_table, nf_flow_offload_gc_step, NULL); 450 + nf_flow_table_gc_run(flow_table); 446 451 queue_delayed_work(system_power_efficient_wq, &flow_table->gc_work, HZ); 447 452 } 448 453 ··· 605 600 mutex_unlock(&flowtable_lock); 606 601 607 602 cancel_delayed_work_sync(&flow_table->gc_work); 608 - nf_flow_table_iterate(flow_table, nf_flow_table_do_cleanup, NULL); 609 - nf_flow_table_iterate(flow_table, nf_flow_offload_gc_step, NULL); 610 603 nf_flow_table_offload_flush(flow_table); 611 - if (nf_flowtable_hw_offload(flow_table)) 612 - nf_flow_table_iterate(flow_table, nf_flow_offload_gc_step, NULL); 604 + /* ... no more pending work after this stage ... */ 605 + nf_flow_table_iterate(flow_table, nf_flow_table_do_cleanup, NULL); 606 + nf_flow_table_gc_run(flow_table); 607 + nf_flow_table_offload_flush_cleanup(flow_table); 613 608 rhashtable_destroy(&flow_table->rhashtable); 614 609 } 615 610 EXPORT_SYMBOL_GPL(nf_flow_table_free);

+8

net/netfilter/nf_flow_table_offload.c

··· 1074 1074 flow_offload_queue_work(offload); 1075 1075 } 1076 1076 1077 + void nf_flow_table_offload_flush_cleanup(struct nf_flowtable *flowtable) 1078 + { 1079 + if (nf_flowtable_hw_offload(flowtable)) { 1080 + flush_workqueue(nf_flow_offload_del_wq); 1081 + nf_flow_table_gc_run(flowtable); 1082 + } 1083 + } 1084 + 1077 1085 void nf_flow_table_offload_flush(struct nf_flowtable *flowtable) 1078 1086 { 1079 1087 if (nf_flowtable_hw_offload(flowtable)) {

+10 -4

net/netfilter/nf_tables_api.c

··· 32 32 static LIST_HEAD(nf_tables_flowtables); 33 33 static LIST_HEAD(nf_tables_destroy_list); 34 34 static DEFINE_SPINLOCK(nf_tables_destroy_list_lock); 35 - static u64 table_handle; 36 35 37 36 enum { 38 37 NFT_VALIDATE_SKIP = 0, ··· 1234 1235 INIT_LIST_HEAD(&table->flowtables); 1235 1236 table->family = family; 1236 1237 table->flags = flags; 1237 - table->handle = ++table_handle; 1238 + table->handle = ++nft_net->table_handle; 1238 1239 if (table->flags & NFT_TABLE_F_OWNER) 1239 1240 table->nlpid = NETLINK_CB(skb).portid; 1240 1241 ··· 2195 2196 struct netlink_ext_ack *extack) 2196 2197 { 2197 2198 const struct nlattr * const *nla = ctx->nla; 2199 + struct nft_stats __percpu *stats = NULL; 2198 2200 struct nft_table *table = ctx->table; 2199 2201 struct nft_base_chain *basechain; 2200 - struct nft_stats __percpu *stats; 2201 2202 struct net *net = ctx->net; 2202 2203 char name[NFT_NAME_MAXLEN]; 2203 2204 struct nft_rule_blob *blob; ··· 2235 2236 return PTR_ERR(stats); 2236 2237 } 2237 2238 rcu_assign_pointer(basechain->stats, stats); 2238 - static_branch_inc(&nft_counters_enabled); 2239 2239 } 2240 2240 2241 2241 err = nft_basechain_init(basechain, family, &hook, flags); ··· 2316 2318 nft_trans_destroy(trans); 2317 2319 goto err_unregister_hook; 2318 2320 } 2321 + 2322 + if (stats) 2323 + static_branch_inc(&nft_counters_enabled); 2319 2324 2320 2325 table->use++; 2321 2326 ··· 2575 2574 nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla); 2576 2575 2577 2576 if (chain != NULL) { 2577 + if (chain->flags & NFT_CHAIN_BINDING) 2578 + return -EINVAL; 2579 + 2578 2580 if (info->nlh->nlmsg_flags & NLM_F_EXCL) { 2579 2581 NL_SET_BAD_ATTR(extack, attr); 2580 2582 return -EEXIST; ··· 9711 9707 return PTR_ERR(chain); 9712 9708 if (nft_is_base_chain(chain)) 9713 9709 return -EOPNOTSUPP; 9710 + if (nft_chain_is_bound(chain)) 9711 + return -EINVAL; 9714 9712 if (desc->flags & NFT_DATA_DESC_SETELEM && 9715 9713 chain->flags & NFT_CHAIN_BINDING) 9716 9714 return -EINVAL;

+15 -3

net/netfilter/nft_osf.c

··· 115 115 const struct nft_expr *expr, 116 116 const struct nft_data **data) 117 117 { 118 - return nft_chain_validate_hooks(ctx->chain, (1 << NF_INET_LOCAL_IN) | 119 - (1 << NF_INET_PRE_ROUTING) | 120 - (1 << NF_INET_FORWARD)); 118 + unsigned int hooks; 119 + 120 + switch (ctx->family) { 121 + case NFPROTO_IPV4: 122 + case NFPROTO_IPV6: 123 + case NFPROTO_INET: 124 + hooks = (1 << NF_INET_LOCAL_IN) | 125 + (1 << NF_INET_PRE_ROUTING) | 126 + (1 << NF_INET_FORWARD); 127 + break; 128 + default: 129 + return -EOPNOTSUPP; 130 + } 131 + 132 + return nft_chain_validate_hooks(ctx->chain, hooks); 121 133 } 122 134 123 135 static bool nft_osf_reduce(struct nft_regs_track *track,

+21 -8

net/netfilter/nft_payload.c

··· 740 740 const struct nlattr * const tb[]) 741 741 { 742 742 struct nft_payload_set *priv = nft_expr_priv(expr); 743 + u32 csum_offset, csum_type = NFT_PAYLOAD_CSUM_NONE; 744 + int err; 743 745 744 746 priv->base = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_BASE])); 745 747 priv->offset = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_OFFSET])); 746 748 priv->len = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_LEN])); 747 749 748 750 if (tb[NFTA_PAYLOAD_CSUM_TYPE]) 749 - priv->csum_type = 750 - ntohl(nla_get_be32(tb[NFTA_PAYLOAD_CSUM_TYPE])); 751 - if (tb[NFTA_PAYLOAD_CSUM_OFFSET]) 752 - priv->csum_offset = 753 - ntohl(nla_get_be32(tb[NFTA_PAYLOAD_CSUM_OFFSET])); 751 + csum_type = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_CSUM_TYPE])); 752 + if (tb[NFTA_PAYLOAD_CSUM_OFFSET]) { 753 + err = nft_parse_u32_check(tb[NFTA_PAYLOAD_CSUM_OFFSET], U8_MAX, 754 + &csum_offset); 755 + if (err < 0) 756 + return err; 757 + 758 + priv->csum_offset = csum_offset; 759 + } 754 760 if (tb[NFTA_PAYLOAD_CSUM_FLAGS]) { 755 761 u32 flags; 756 762 ··· 767 761 priv->csum_flags = flags; 768 762 } 769 763 770 - switch (priv->csum_type) { 764 + switch (csum_type) { 771 765 case NFT_PAYLOAD_CSUM_NONE: 772 766 case NFT_PAYLOAD_CSUM_INET: 773 767 break; ··· 781 775 default: 782 776 return -EOPNOTSUPP; 783 777 } 778 + priv->csum_type = csum_type; 784 779 785 780 return nft_parse_register_load(tb[NFTA_PAYLOAD_SREG], &priv->sreg, 786 781 priv->len); ··· 840 833 { 841 834 enum nft_payload_bases base; 842 835 unsigned int offset, len; 836 + int err; 843 837 844 838 if (tb[NFTA_PAYLOAD_BASE] == NULL || 845 839 tb[NFTA_PAYLOAD_OFFSET] == NULL || ··· 867 859 if (tb[NFTA_PAYLOAD_DREG] == NULL) 868 860 return ERR_PTR(-EINVAL); 869 861 870 - offset = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_OFFSET])); 871 - len = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_LEN])); 862 + err = nft_parse_u32_check(tb[NFTA_PAYLOAD_OFFSET], U8_MAX, &offset); 863 + if (err < 0) 864 + return ERR_PTR(err); 865 + 866 + err = nft_parse_u32_check(tb[NFTA_PAYLOAD_LEN], U8_MAX, &len); 867 + if (err < 0) 868 + return ERR_PTR(err); 872 869 873 870 if (len <= 4 && is_power_of_2(len) && IS_ALIGNED(offset, len) && 874 871 base != NFT_PAYLOAD_LL_HEADER && base != NFT_PAYLOAD_INNER_HEADER)

+8

net/netfilter/nft_tproxy.c

··· 312 312 return 0; 313 313 } 314 314 315 + static int nft_tproxy_validate(const struct nft_ctx *ctx, 316 + const struct nft_expr *expr, 317 + const struct nft_data **data) 318 + { 319 + return nft_chain_validate_hooks(ctx->chain, 1 << NF_INET_PRE_ROUTING); 320 + } 321 + 315 322 static struct nft_expr_type nft_tproxy_type; 316 323 static const struct nft_expr_ops nft_tproxy_ops = { 317 324 .type = &nft_tproxy_type, ··· 328 321 .destroy = nft_tproxy_destroy, 329 322 .dump = nft_tproxy_dump, 330 323 .reduce = NFT_REDUCE_READONLY, 324 + .validate = nft_tproxy_validate, 331 325 }; 332 326 333 327 static struct nft_expr_type nft_tproxy_type __read_mostly = {

+1

net/netfilter/nft_tunnel.c

··· 161 161 162 162 static struct nft_expr_type nft_tunnel_type __read_mostly = { 163 163 .name = "tunnel", 164 + .family = NFPROTO_NETDEV, 164 165 .ops = &nft_tunnel_get_ops, 165 166 .policy = nft_tunnel_policy, 166 167 .maxattr = NFTA_TUNNEL_MAX,

+2 -1

net/rose/rose_loopback.c

··· 96 96 } 97 97 98 98 if (frametype == ROSE_CALL_REQUEST) { 99 - if (!rose_loopback_neigh->dev) { 99 + if (!rose_loopback_neigh->dev && 100 + !rose_loopback_neigh->loopback) { 100 101 kfree_skb(skb); 101 102 continue; 102 103 }

+3 -1

net/rxrpc/call_object.c

··· 285 285 _enter("%p,%lx", rx, p->user_call_ID); 286 286 287 287 limiter = rxrpc_get_call_slot(p, gfp); 288 - if (!limiter) 288 + if (!limiter) { 289 + release_sock(&rx->sk); 289 290 return ERR_PTR(-ERESTARTSYS); 291 + } 290 292 291 293 call = rxrpc_alloc_client_call(rx, srx, gfp, debug_id); 292 294 if (IS_ERR(call)) {

+53 -37

net/rxrpc/sendmsg.c

··· 51 51 return sock_intr_errno(*timeo); 52 52 53 53 trace_rxrpc_transmit(call, rxrpc_transmit_wait); 54 - mutex_unlock(&call->user_mutex); 55 54 *timeo = schedule_timeout(*timeo); 56 - if (mutex_lock_interruptible(&call->user_mutex) < 0) 57 - return sock_intr_errno(*timeo); 58 55 } 59 56 } 60 57 ··· 287 290 static int rxrpc_send_data(struct rxrpc_sock *rx, 288 291 struct rxrpc_call *call, 289 292 struct msghdr *msg, size_t len, 290 - rxrpc_notify_end_tx_t notify_end_tx) 293 + rxrpc_notify_end_tx_t notify_end_tx, 294 + bool *_dropped_lock) 291 295 { 292 296 struct rxrpc_skb_priv *sp; 293 297 struct sk_buff *skb; 294 298 struct sock *sk = &rx->sk; 299 + enum rxrpc_call_state state; 295 300 long timeo; 296 - bool more; 297 - int ret, copied; 301 + bool more = msg->msg_flags & MSG_MORE; 302 + int ret, copied = 0; 298 303 299 304 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT); 300 305 301 306 /* this should be in poll */ 302 307 sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk); 303 308 309 + reload: 310 + ret = -EPIPE; 304 311 if (sk->sk_shutdown & SEND_SHUTDOWN) 305 - return -EPIPE; 312 + goto maybe_error; 313 + state = READ_ONCE(call->state); 314 + ret = -ESHUTDOWN; 315 + if (state >= RXRPC_CALL_COMPLETE) 316 + goto maybe_error; 317 + ret = -EPROTO; 318 + if (state != RXRPC_CALL_CLIENT_SEND_REQUEST && 319 + state != RXRPC_CALL_SERVER_ACK_REQUEST && 320 + state != RXRPC_CALL_SERVER_SEND_REPLY) 321 + goto maybe_error; 306 322 307 - more = msg->msg_flags & MSG_MORE; 308 - 323 + ret = -EMSGSIZE; 309 324 if (call->tx_total_len != -1) { 310 - if (len > call->tx_total_len) 311 - return -EMSGSIZE; 312 - if (!more && len != call->tx_total_len) 313 - return -EMSGSIZE; 325 + if (len - copied > call->tx_total_len) 326 + goto maybe_error; 327 + if (!more && len - copied != call->tx_total_len) 328 + goto maybe_error; 314 329 } 315 330 316 331 skb = call->tx_pending; 317 332 call->tx_pending = NULL; 318 333 rxrpc_see_skb(skb, rxrpc_skb_seen); 319 334 320 - copied = 0; 321 335 do { 322 336 /* Check to see if there's a ping ACK to reply to. */ 323 337 if (call->ackr_reason == RXRPC_ACK_PING_RESPONSE) ··· 339 331 340 332 _debug("alloc"); 341 333 342 - if (!rxrpc_check_tx_space(call, NULL)) { 343 - ret = -EAGAIN; 344 - if (msg->msg_flags & MSG_DONTWAIT) 345 - goto maybe_error; 346 - ret = rxrpc_wait_for_tx_window(rx, call, 347 - &timeo, 348 - msg->msg_flags & MSG_WAITALL); 349 - if (ret < 0) 350 - goto maybe_error; 351 - } 334 + if (!rxrpc_check_tx_space(call, NULL)) 335 + goto wait_for_space; 352 336 353 337 /* Work out the maximum size of a packet. Assume that 354 338 * the security header is going to be in the padded ··· 468 468 efault: 469 469 ret = -EFAULT; 470 470 goto out; 471 + 472 + wait_for_space: 473 + ret = -EAGAIN; 474 + if (msg->msg_flags & MSG_DONTWAIT) 475 + goto maybe_error; 476 + mutex_unlock(&call->user_mutex); 477 + *_dropped_lock = true; 478 + ret = rxrpc_wait_for_tx_window(rx, call, &timeo, 479 + msg->msg_flags & MSG_WAITALL); 480 + if (ret < 0) 481 + goto maybe_error; 482 + if (call->interruptibility == RXRPC_INTERRUPTIBLE) { 483 + if (mutex_lock_interruptible(&call->user_mutex) < 0) { 484 + ret = sock_intr_errno(timeo); 485 + goto maybe_error; 486 + } 487 + } else { 488 + mutex_lock(&call->user_mutex); 489 + } 490 + *_dropped_lock = false; 491 + goto reload; 471 492 } 472 493 473 494 /* ··· 650 629 enum rxrpc_call_state state; 651 630 struct rxrpc_call *call; 652 631 unsigned long now, j; 632 + bool dropped_lock = false; 653 633 int ret; 654 634 655 635 struct rxrpc_send_params p = { ··· 759 737 ret = rxrpc_send_abort_packet(call); 760 738 } else if (p.command != RXRPC_CMD_SEND_DATA) { 761 739 ret = -EINVAL; 762 - } else if (rxrpc_is_client_call(call) && 763 - state != RXRPC_CALL_CLIENT_SEND_REQUEST) { 764 - /* request phase complete for this client call */ 765 - ret = -EPROTO; 766 - } else if (rxrpc_is_service_call(call) && 767 - state != RXRPC_CALL_SERVER_ACK_REQUEST && 768 - state != RXRPC_CALL_SERVER_SEND_REPLY) { 769 - /* Reply phase not begun or not complete for service call. */ 770 - ret = -EPROTO; 771 740 } else { 772 - ret = rxrpc_send_data(rx, call, msg, len, NULL); 741 + ret = rxrpc_send_data(rx, call, msg, len, NULL, &dropped_lock); 773 742 } 774 743 775 744 out_put_unlock: 776 - mutex_unlock(&call->user_mutex); 745 + if (!dropped_lock) 746 + mutex_unlock(&call->user_mutex); 777 747 error_put: 778 748 rxrpc_put_call(call, rxrpc_call_put); 779 749 _leave(" = %d", ret); ··· 793 779 struct msghdr *msg, size_t len, 794 780 rxrpc_notify_end_tx_t notify_end_tx) 795 781 { 782 + bool dropped_lock = false; 796 783 int ret; 797 784 798 785 _enter("{%d,%s},", call->debug_id, rxrpc_call_states[call->state]); ··· 811 796 case RXRPC_CALL_SERVER_ACK_REQUEST: 812 797 case RXRPC_CALL_SERVER_SEND_REPLY: 813 798 ret = rxrpc_send_data(rxrpc_sk(sock->sk), call, msg, len, 814 - notify_end_tx); 799 + notify_end_tx, &dropped_lock); 815 800 break; 816 801 case RXRPC_CALL_COMPLETE: 817 802 read_lock_bh(&call->state_lock); ··· 825 810 break; 826 811 } 827 812 828 - mutex_unlock(&call->user_mutex); 813 + if (!dropped_lock) 814 + mutex_unlock(&call->user_mutex); 829 815 _leave(" = %d", ret); 830 816 return ret; 831 817 }

+1 -1

net/sched/sch_generic.c

··· 409 409 410 410 void __qdisc_run(struct Qdisc *q) 411 411 { 412 - int quota = dev_tx_weight; 412 + int quota = READ_ONCE(dev_tx_weight); 413 413 int packets; 414 414 415 415 while (qdisc_restart(q, &packets)) {

+1 -1

net/socket.c

··· 1801 1801 1802 1802 sock = sockfd_lookup_light(fd, &err, &fput_needed); 1803 1803 if (sock) { 1804 - somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn; 1804 + somaxconn = READ_ONCE(sock_net(sock->sk)->core.sysctl_somaxconn); 1805 1805 if ((unsigned int)backlog > somaxconn) 1806 1806 backlog = somaxconn; 1807 1807

+1 -1

net/xfrm/espintcp.c

··· 168 168 { 169 169 struct espintcp_ctx *ctx = espintcp_getctx(sk); 170 170 171 - if (skb_queue_len(&ctx->out_queue) >= netdev_max_backlog) 171 + if (skb_queue_len(&ctx->out_queue) >= READ_ONCE(netdev_max_backlog)) 172 172 return -ENOBUFS; 173 173 174 174 __skb_queue_tail(&ctx->out_queue, skb);

+1 -2

net/xfrm/xfrm_input.c

··· 669 669 670 670 x->curlft.bytes += skb->len; 671 671 x->curlft.packets++; 672 - x->curlft.use_time = ktime_get_real_seconds(); 673 672 674 673 spin_unlock(&x->lock); 675 674 ··· 782 783 783 784 trans = this_cpu_ptr(&xfrm_trans_tasklet); 784 785 785 - if (skb_queue_len(&trans->queue) >= netdev_max_backlog) 786 + if (skb_queue_len(&trans->queue) >= READ_ONCE(netdev_max_backlog)) 786 787 return -ENOBUFS; 787 788 788 789 BUILD_BUG_ON(sizeof(struct xfrm_trans_cb) > sizeof(skb->cb));

-1

net/xfrm/xfrm_output.c

··· 534 534 535 535 x->curlft.bytes += skb->len; 536 536 x->curlft.packets++; 537 - x->curlft.use_time = ktime_get_real_seconds(); 538 537 539 538 spin_unlock_bh(&x->lock); 540 539

+2 -1

net/xfrm/xfrm_policy.c

··· 3162 3162 return dst; 3163 3163 3164 3164 nopol: 3165 - if (!(dst_orig->dev->flags & IFF_LOOPBACK) && 3165 + if ((!dst_orig->dev || !(dst_orig->dev->flags & IFF_LOOPBACK)) && 3166 3166 net->xfrm.policy_default[dir] == XFRM_USERPOLICY_BLOCK) { 3167 3167 err = -EPERM; 3168 3168 goto error; ··· 3599 3599 if (pols[1]) { 3600 3600 if (IS_ERR(pols[1])) { 3601 3601 XFRM_INC_STATS(net, LINUX_MIB_XFRMINPOLERROR); 3602 + xfrm_pol_put(pols[0]); 3602 3603 return 0; 3603 3604 } 3604 3605 pols[1]->curlft.use_time = ktime_get_real_seconds();

+1

net/xfrm/xfrm_state.c

··· 1592 1592 x->replay = orig->replay; 1593 1593 x->preplay = orig->preplay; 1594 1594 x->mapping_maxage = orig->mapping_maxage; 1595 + x->lastused = orig->lastused; 1595 1596 x->new_mapping = 0; 1596 1597 x->new_mapping_sport = 0; 1597 1598

+1

tools/testing/selftests/Makefile

··· 12 12 TARGETS += damon 13 13 TARGETS += drivers/dma-buf 14 14 TARGETS += drivers/s390x/uvdevice 15 + TARGETS += drivers/net/bonding 15 16 TARGETS += efivarfs 16 17 TARGETS += exec 17 18 TARGETS += filesystems

+6

tools/testing/selftests/drivers/net/bonding/Makefile

··· 1 + # SPDX-License-Identifier: GPL-2.0 2 + # Makefile for net selftests 3 + 4 + TEST_PROGS := bond-break-lacpdu-tx.sh 5 + 6 + include ../../../lib.mk

+81

tools/testing/selftests/drivers/net/bonding/bond-break-lacpdu-tx.sh

··· 1 + #!/bin/sh 2 + # SPDX-License-Identifier: GPL-2.0 3 + 4 + # Regression Test: 5 + # Verify LACPDUs get transmitted after setting the MAC address of 6 + # the bond. 7 + # 8 + # https://bugzilla.redhat.com/show_bug.cgi?id=2020773 9 + # 10 + # +---------+ 11 + # | fab-br0 | 12 + # +---------+ 13 + # | 14 + # +---------+ 15 + # | fbond | 16 + # +---------+ 17 + # | | 18 + # +------+ +------+ 19 + # |veth1 | |veth2 | 20 + # +------+ +------+ 21 + # 22 + # We use veths instead of physical interfaces 23 + 24 + set -e 25 + tmp=$(mktemp -q dump.XXXXXX) 26 + cleanup() { 27 + ip link del fab-br0 >/dev/null 2>&1 || : 28 + ip link del fbond >/dev/null 2>&1 || : 29 + ip link del veth1-bond >/dev/null 2>&1 || : 30 + ip link del veth2-bond >/dev/null 2>&1 || : 31 + modprobe -r bonding >/dev/null 2>&1 || : 32 + rm -f -- ${tmp} 33 + } 34 + 35 + trap cleanup 0 1 2 36 + cleanup 37 + sleep 1 38 + 39 + # create the bridge 40 + ip link add fab-br0 address 52:54:00:3B:7C:A6 mtu 1500 type bridge \ 41 + forward_delay 15 42 + 43 + # create the bond 44 + ip link add fbond type bond mode 4 miimon 200 xmit_hash_policy 1 \ 45 + ad_actor_sys_prio 65535 lacp_rate fast 46 + 47 + # set bond address 48 + ip link set fbond address 52:54:00:3B:7C:A6 49 + ip link set fbond up 50 + 51 + # set again bond sysfs parameters 52 + ip link set fbond type bond ad_actor_sys_prio 65535 53 + 54 + # create veths 55 + ip link add name veth1-bond type veth peer name veth1-end 56 + ip link add name veth2-bond type veth peer name veth2-end 57 + 58 + # add ports 59 + ip link set fbond master fab-br0 60 + ip link set veth1-bond down master fbond 61 + ip link set veth2-bond down master fbond 62 + 63 + # bring up 64 + ip link set veth1-end up 65 + ip link set veth2-end up 66 + ip link set fab-br0 up 67 + ip link set fbond up 68 + ip addr add dev fab-br0 10.0.0.3 69 + 70 + tcpdump -n -i veth1-end -e ether proto 0x8809 >${tmp} 2>&1 & 71 + sleep 15 72 + pkill tcpdump >/dev/null 2>&1 73 + rc=0 74 + num=$(grep "packets captured" ${tmp} | awk '{print $1}') 75 + if test "$num" -gt 0; then 76 + echo "PASS, captured ${num}" 77 + else 78 + echo "FAIL" 79 + rc=1 80 + fi 81 + exit $rc

+1

tools/testing/selftests/drivers/net/bonding/config

··· 1 + CONFIG_BONDING=y

+1

tools/testing/selftests/drivers/net/bonding/settings

··· 1 + timeout=60

Configure Feed

Configure Feed