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

+67 -1

Documentation/netlink/specs/rt-link.yaml

··· 1685 1685 - 1686 1686 name: iflags 1687 1687 type: u16 1688 + byte-order: big-endian 1688 1689 - 1689 1690 name: oflags 1690 1691 type: u16 1692 + byte-order: big-endian 1691 1693 - 1692 1694 name: ikey 1693 1695 type: u32 1696 + byte-order: big-endian 1694 1697 - 1695 1698 name: okey 1696 1699 type: u32 1700 + byte-order: big-endian 1697 1701 - 1698 1702 name: local 1699 1703 type: binary ··· 1717 1713 type: u8 1718 1714 - 1719 1715 name: encap-limit 1720 - type: u32 1716 + type: u8 1721 1717 - 1722 1718 name: flowinfo 1723 1719 type: u32 1720 + byte-order: big-endian 1724 1721 - 1725 1722 name: flags 1726 1723 type: u32 ··· 1734 1729 - 1735 1730 name: encap-sport 1736 1731 type: u16 1732 + byte-order: big-endian 1737 1733 - 1738 1734 name: encap-dport 1739 1735 type: u16 1736 + byte-order: big-endian 1740 1737 - 1741 1738 name: collect-metadata 1742 1739 type: flag ··· 1761 1754 name: erspan-hwid 1762 1755 type: u16 1763 1756 - 1757 + name: linkinfo-gre6-attrs 1758 + subset-of: linkinfo-gre-attrs 1759 + attributes: 1760 + - 1761 + name: link 1762 + - 1763 + name: iflags 1764 + - 1765 + name: oflags 1766 + - 1767 + name: ikey 1768 + - 1769 + name: okey 1770 + - 1771 + name: local 1772 + display-hint: ipv6 1773 + - 1774 + name: remote 1775 + display-hint: ipv6 1776 + - 1777 + name: ttl 1778 + - 1779 + name: encap-limit 1780 + - 1781 + name: flowinfo 1782 + - 1783 + name: flags 1784 + - 1785 + name: encap-type 1786 + - 1787 + name: encap-flags 1788 + - 1789 + name: encap-sport 1790 + - 1791 + name: encap-dport 1792 + - 1793 + name: collect-metadata 1794 + - 1795 + name: fwmark 1796 + - 1797 + name: erspan-index 1798 + - 1799 + name: erspan-ver 1800 + - 1801 + name: erspan-dir 1802 + - 1803 + name: erspan-hwid 1804 + - 1764 1805 name: linkinfo-vti-attrs 1765 1806 name-prefix: ifla-vti- 1766 1807 header: linux/if_tunnel.h ··· 1819 1764 - 1820 1765 name: ikey 1821 1766 type: u32 1767 + byte-order: big-endian 1822 1768 - 1823 1769 name: okey 1824 1770 type: u32 1771 + byte-order: big-endian 1825 1772 - 1826 1773 name: local 1827 1774 type: binary ··· 1873 1816 - 1874 1817 name: port 1875 1818 type: u16 1819 + byte-order: big-endian 1876 1820 - 1877 1821 name: collect-metadata 1878 1822 type: flag ··· 1893 1835 - 1894 1836 name: label 1895 1837 type: u32 1838 + byte-order: big-endian 1896 1839 - 1897 1840 name: ttl-inherit 1898 1841 type: u8 ··· 1934 1875 - 1935 1876 name: flowinfo 1936 1877 type: u32 1878 + byte-order: big-endian 1937 1879 - 1938 1880 name: flags 1939 1881 type: u16 1882 + byte-order: big-endian 1940 1883 - 1941 1884 name: proto 1942 1885 type: u8 ··· 1968 1907 - 1969 1908 name: encap-sport 1970 1909 type: u16 1910 + byte-order: big-endian 1971 1911 - 1972 1912 name: encap-dport 1973 1913 type: u16 1914 + byte-order: big-endian 1974 1915 - 1975 1916 name: collect-metadata 1976 1917 type: flag ··· 2287 2224 - 2288 2225 value: gretap 2289 2226 attribute-set: linkinfo-gre-attrs 2227 + - 2228 + value: ip6gre 2229 + attribute-set: linkinfo-gre6-attrs 2290 2230 - 2291 2231 value: geneve 2292 2232 attribute-set: linkinfo-geneve-attrs

+2

drivers/bluetooth/btnxpuart.c

··· 533 533 ps_host_wakeup_irq_handler, 534 534 IRQF_ONESHOT | IRQF_TRIGGER_FALLING, 535 535 dev_name(&serdev->dev), nxpdev); 536 + if (ret) 537 + bt_dev_info(hdev, "error setting wakeup IRQ handler, ignoring\n"); 536 538 disable_irq(psdata->irq_handler); 537 539 device_init_wakeup(&serdev->dev, true); 538 540 }

+7 -7

drivers/bluetooth/hci_qca.c

··· 2415 2415 2416 2416 qcadev->bt_en = devm_gpiod_get_optional(&serdev->dev, "enable", 2417 2417 GPIOD_OUT_LOW); 2418 - if (IS_ERR(qcadev->bt_en) && 2419 - (data->soc_type == QCA_WCN6750 || 2420 - data->soc_type == QCA_WCN6855)) { 2421 - dev_err(&serdev->dev, "failed to acquire BT_EN gpio\n"); 2422 - return PTR_ERR(qcadev->bt_en); 2423 - } 2418 + if (IS_ERR(qcadev->bt_en)) 2419 + return dev_err_probe(&serdev->dev, 2420 + PTR_ERR(qcadev->bt_en), 2421 + "failed to acquire BT_EN gpio\n"); 2424 2422 2425 - if (!qcadev->bt_en) 2423 + if (!qcadev->bt_en && 2424 + (data->soc_type == QCA_WCN6750 || 2425 + data->soc_type == QCA_WCN6855)) 2426 2426 power_ctrl_enabled = false; 2427 2427 2428 2428 qcadev->sw_ctrl = devm_gpiod_get_optional(&serdev->dev, "swctrl",

+1 -2

drivers/net/can/kvaser_pciefd.c

··· 966 966 u32 status, tx_nr_packets_max; 967 967 968 968 netdev = alloc_candev(sizeof(struct kvaser_pciefd_can), 969 - KVASER_PCIEFD_CAN_TX_MAX_COUNT); 969 + roundup_pow_of_two(KVASER_PCIEFD_CAN_TX_MAX_COUNT)); 970 970 if (!netdev) 971 971 return -ENOMEM; 972 972 ··· 995 995 can->tx_max_count = min(KVASER_PCIEFD_CAN_TX_MAX_COUNT, tx_nr_packets_max - 1); 996 996 997 997 can->can.clock.freq = pcie->freq; 998 - can->can.echo_skb_max = roundup_pow_of_two(can->tx_max_count); 999 998 spin_lock_init(&can->lock); 1000 999 1001 1000 can->can.bittiming_const = &kvaser_pciefd_bittiming_const;

+22 -36

drivers/net/dsa/b53/b53_common.c

··· 22 22 #include <linux/gpio.h> 23 23 #include <linux/kernel.h> 24 24 #include <linux/math.h> 25 + #include <linux/minmax.h> 25 26 #include <linux/module.h> 26 27 #include <linux/platform_data/b53.h> 27 28 #include <linux/phy.h> ··· 1323 1322 phy_interface_t interface) 1324 1323 { 1325 1324 struct b53_device *dev = ds->priv; 1326 - u8 rgmii_ctrl = 0, off; 1325 + u8 rgmii_ctrl = 0; 1327 1326 1328 - if (port == dev->imp_port) 1329 - off = B53_RGMII_CTRL_IMP; 1330 - else 1331 - off = B53_RGMII_CTRL_P(port); 1327 + b53_read8(dev, B53_CTRL_PAGE, B53_RGMII_CTRL_P(port), &rgmii_ctrl); 1328 + rgmii_ctrl &= ~(RGMII_CTRL_DLL_RXC | RGMII_CTRL_DLL_TXC); 1332 1329 1333 - b53_read8(dev, B53_CTRL_PAGE, off, &rgmii_ctrl); 1330 + if (is63268(dev)) 1331 + rgmii_ctrl |= RGMII_CTRL_MII_OVERRIDE; 1334 1332 1335 - switch (interface) { 1336 - case PHY_INTERFACE_MODE_RGMII_ID: 1337 - rgmii_ctrl |= (RGMII_CTRL_DLL_RXC | RGMII_CTRL_DLL_TXC); 1338 - break; 1339 - case PHY_INTERFACE_MODE_RGMII_RXID: 1340 - rgmii_ctrl &= ~(RGMII_CTRL_DLL_TXC); 1341 - rgmii_ctrl |= RGMII_CTRL_DLL_RXC; 1342 - break; 1343 - case PHY_INTERFACE_MODE_RGMII_TXID: 1344 - rgmii_ctrl &= ~(RGMII_CTRL_DLL_RXC); 1345 - rgmii_ctrl |= RGMII_CTRL_DLL_TXC; 1346 - break; 1347 - case PHY_INTERFACE_MODE_RGMII: 1348 - default: 1349 - rgmii_ctrl &= ~(RGMII_CTRL_DLL_RXC | RGMII_CTRL_DLL_TXC); 1350 - break; 1351 - } 1333 + rgmii_ctrl |= RGMII_CTRL_ENABLE_GMII; 1352 1334 1353 - if (port != dev->imp_port) { 1354 - if (is63268(dev)) 1355 - rgmii_ctrl |= RGMII_CTRL_MII_OVERRIDE; 1356 - 1357 - rgmii_ctrl |= RGMII_CTRL_ENABLE_GMII; 1358 - } 1359 - 1360 - b53_write8(dev, B53_CTRL_PAGE, off, rgmii_ctrl); 1335 + b53_write8(dev, B53_CTRL_PAGE, B53_RGMII_CTRL_P(port), rgmii_ctrl); 1361 1336 1362 1337 dev_dbg(ds->dev, "Configured port %d for %s\n", port, 1363 1338 phy_modes(interface)); ··· 1354 1377 * tx_clk aligned timing (restoring to reset defaults) 1355 1378 */ 1356 1379 b53_read8(dev, B53_CTRL_PAGE, off, &rgmii_ctrl); 1357 - rgmii_ctrl &= ~(RGMII_CTRL_DLL_RXC | RGMII_CTRL_DLL_TXC | 1358 - RGMII_CTRL_TIMING_SEL); 1380 + rgmii_ctrl &= ~(RGMII_CTRL_DLL_RXC | RGMII_CTRL_DLL_TXC); 1359 1381 1360 1382 /* PHY_INTERFACE_MODE_RGMII_TXID means TX internal delay, make 1361 1383 * sure that we enable the port TX clock internal delay to ··· 1374 1398 rgmii_ctrl |= RGMII_CTRL_DLL_TXC; 1375 1399 if (interface == PHY_INTERFACE_MODE_RGMII) 1376 1400 rgmii_ctrl |= RGMII_CTRL_DLL_TXC | RGMII_CTRL_DLL_RXC; 1377 - rgmii_ctrl |= RGMII_CTRL_TIMING_SEL; 1401 + 1402 + if (dev->chip_id != BCM53115_DEVICE_ID) 1403 + rgmii_ctrl |= RGMII_CTRL_TIMING_SEL; 1404 + 1378 1405 b53_write8(dev, B53_CTRL_PAGE, off, rgmii_ctrl); 1379 1406 1380 1407 dev_info(ds->dev, "Configured port %d for %s\n", port, ··· 1441 1462 __set_bit(PHY_INTERFACE_MODE_MII, config->supported_interfaces); 1442 1463 __set_bit(PHY_INTERFACE_MODE_REVMII, config->supported_interfaces); 1443 1464 1465 + /* BCM63xx RGMII ports support RGMII */ 1466 + if (is63xx(dev) && in_range(port, B53_63XX_RGMII0, 4)) 1467 + phy_interface_set_rgmii(config->supported_interfaces); 1468 + 1444 1469 config->mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE | 1445 1470 MAC_10 | MAC_100; 1446 1471 ··· 1484 1501 struct b53_device *dev = ds->priv; 1485 1502 int port = dp->index; 1486 1503 1487 - if (is63xx(dev) && port >= B53_63XX_RGMII0) 1504 + if (is63xx(dev) && in_range(port, B53_63XX_RGMII0, 4)) 1488 1505 b53_adjust_63xx_rgmii(ds, port, interface); 1489 1506 1490 1507 if (mode == MLO_AN_FIXED) { ··· 2336 2353 { 2337 2354 int ret; 2338 2355 2356 + if (!b53_support_eee(ds, port)) 2357 + return 0; 2358 + 2339 2359 ret = phy_init_eee(phy, false); 2340 2360 if (ret) 2341 2361 return 0; ··· 2353 2367 { 2354 2368 struct b53_device *dev = ds->priv; 2355 2369 2356 - return !is5325(dev) && !is5365(dev); 2370 + return !is5325(dev) && !is5365(dev) && !is63xx(dev); 2357 2371 } 2358 2372 EXPORT_SYMBOL(b53_support_eee); 2359 2373

+2

drivers/net/ethernet/airoha/airoha_eth.c

··· 84 84 val = (addr[3] << 16) | (addr[4] << 8) | addr[5]; 85 85 airoha_fe_wr(eth, REG_FE_MAC_LMIN(reg), val); 86 86 airoha_fe_wr(eth, REG_FE_MAC_LMAX(reg), val); 87 + 88 + airoha_ppe_init_upd_mem(port); 87 89 } 88 90 89 91 static void airoha_set_gdm_port_fwd_cfg(struct airoha_eth *eth, u32 addr,

+1

drivers/net/ethernet/airoha/airoha_eth.h

··· 614 614 int airoha_ppe_setup_tc_block_cb(struct net_device *dev, void *type_data); 615 615 int airoha_ppe_init(struct airoha_eth *eth); 616 616 void airoha_ppe_deinit(struct airoha_eth *eth); 617 + void airoha_ppe_init_upd_mem(struct airoha_gdm_port *port); 617 618 struct airoha_foe_entry *airoha_ppe_foe_get_entry(struct airoha_ppe *ppe, 618 619 u32 hash); 619 620 void airoha_ppe_foe_entry_get_stats(struct airoha_ppe *ppe, u32 hash,

+41 -11

drivers/net/ethernet/airoha/airoha_ppe.c

··· 223 223 int dsa_port = airoha_get_dsa_port(&dev); 224 224 struct airoha_foe_mac_info_common *l2; 225 225 u32 qdata, ports_pad, val; 226 + u8 smac_id = 0xf; 226 227 227 228 memset(hwe, 0, sizeof(*hwe)); 228 229 ··· 258 257 */ 259 258 if (airhoa_is_lan_gdm_port(port)) 260 259 val |= AIROHA_FOE_IB2_FAST_PATH; 260 + 261 + smac_id = port->id; 261 262 } 262 263 263 264 if (is_multicast_ether_addr(data->eth.h_dest)) ··· 294 291 hwe->ipv4.l2.src_mac_lo = 295 292 get_unaligned_be16(data->eth.h_source + 4); 296 293 } else { 297 - l2->src_mac_hi = FIELD_PREP(AIROHA_FOE_MAC_SMAC_ID, 0xf); 294 + l2->src_mac_hi = FIELD_PREP(AIROHA_FOE_MAC_SMAC_ID, smac_id); 298 295 } 299 296 300 297 if (data->vlan.num) { ··· 639 636 u32 mask = AIROHA_FOE_IB1_BIND_PACKET_TYPE | AIROHA_FOE_IB1_BIND_UDP; 640 637 struct airoha_foe_entry *hwe_p, hwe; 641 638 struct airoha_flow_table_entry *f; 642 - struct airoha_foe_mac_info *l2; 643 639 int type; 644 640 645 641 hwe_p = airoha_ppe_foe_get_entry(ppe, hash); ··· 655 653 656 654 memcpy(&hwe, hwe_p, sizeof(*hwe_p)); 657 655 hwe.ib1 = (hwe.ib1 & mask) | (e->data.ib1 & ~mask); 658 - l2 = &hwe.bridge.l2; 659 - memcpy(l2, &e->data.bridge.l2, sizeof(*l2)); 660 656 661 657 type = FIELD_GET(AIROHA_FOE_IB1_BIND_PACKET_TYPE, hwe.ib1); 662 - if (type == PPE_PKT_TYPE_IPV4_HNAPT) 663 - memcpy(&hwe.ipv4.new_tuple, &hwe.ipv4.orig_tuple, 664 - sizeof(hwe.ipv4.new_tuple)); 665 - else if (type >= PPE_PKT_TYPE_IPV6_ROUTE_3T && 666 - l2->common.etype == ETH_P_IP) 667 - l2->common.etype = ETH_P_IPV6; 658 + if (type >= PPE_PKT_TYPE_IPV6_ROUTE_3T) { 659 + memcpy(&hwe.ipv6.l2, &e->data.bridge.l2, sizeof(hwe.ipv6.l2)); 660 + hwe.ipv6.ib2 = e->data.bridge.ib2; 661 + /* setting smac_id to 0xf instruct the hw to keep original 662 + * source mac address 663 + */ 664 + hwe.ipv6.l2.src_mac_hi = FIELD_PREP(AIROHA_FOE_MAC_SMAC_ID, 665 + 0xf); 666 + } else { 667 + memcpy(&hwe.bridge.l2, &e->data.bridge.l2, 668 + sizeof(hwe.bridge.l2)); 669 + hwe.bridge.ib2 = e->data.bridge.ib2; 670 + if (type == PPE_PKT_TYPE_IPV4_HNAPT) 671 + memcpy(&hwe.ipv4.new_tuple, &hwe.ipv4.orig_tuple, 672 + sizeof(hwe.ipv4.new_tuple)); 673 + } 668 674 669 - hwe.bridge.ib2 = e->data.bridge.ib2; 670 675 hwe.bridge.data = e->data.bridge.data; 671 676 airoha_ppe_foe_commit_entry(ppe, &hwe, hash); 672 677 ··· 1245 1236 1246 1237 ppe->foe_check_time[hash] = now; 1247 1238 airoha_ppe_foe_insert_entry(ppe, skb, hash); 1239 + } 1240 + 1241 + void airoha_ppe_init_upd_mem(struct airoha_gdm_port *port) 1242 + { 1243 + struct airoha_eth *eth = port->qdma->eth; 1244 + struct net_device *dev = port->dev; 1245 + const u8 *addr = dev->dev_addr; 1246 + u32 val; 1247 + 1248 + val = (addr[2] << 24) | (addr[3] << 16) | (addr[4] << 8) | addr[5]; 1249 + airoha_fe_wr(eth, REG_UPDMEM_DATA(0), val); 1250 + airoha_fe_wr(eth, REG_UPDMEM_CTRL(0), 1251 + FIELD_PREP(PPE_UPDMEM_ADDR_MASK, port->id) | 1252 + PPE_UPDMEM_WR_MASK | PPE_UPDMEM_REQ_MASK); 1253 + 1254 + val = (addr[0] << 8) | addr[1]; 1255 + airoha_fe_wr(eth, REG_UPDMEM_DATA(0), val); 1256 + airoha_fe_wr(eth, REG_UPDMEM_CTRL(0), 1257 + FIELD_PREP(PPE_UPDMEM_ADDR_MASK, port->id) | 1258 + FIELD_PREP(PPE_UPDMEM_OFFSET_MASK, 1) | 1259 + PPE_UPDMEM_WR_MASK | PPE_UPDMEM_REQ_MASK); 1248 1260 } 1249 1261 1250 1262 int airoha_ppe_init(struct airoha_eth *eth)

+10

drivers/net/ethernet/airoha/airoha_regs.h

··· 313 313 #define REG_PPE_RAM_BASE(_n) (((_n) ? PPE2_BASE : PPE1_BASE) + 0x320) 314 314 #define REG_PPE_RAM_ENTRY(_m, _n) (REG_PPE_RAM_BASE(_m) + ((_n) << 2)) 315 315 316 + #define REG_UPDMEM_CTRL(_n) (((_n) ? PPE2_BASE : PPE1_BASE) + 0x370) 317 + #define PPE_UPDMEM_ACK_MASK BIT(31) 318 + #define PPE_UPDMEM_ADDR_MASK GENMASK(11, 8) 319 + #define PPE_UPDMEM_OFFSET_MASK GENMASK(7, 4) 320 + #define PPE_UPDMEM_SEL_MASK GENMASK(3, 2) 321 + #define PPE_UPDMEM_WR_MASK BIT(1) 322 + #define PPE_UPDMEM_REQ_MASK BIT(0) 323 + 324 + #define REG_UPDMEM_DATA(_n) (((_n) ? PPE2_BASE : PPE1_BASE) + 0x374) 325 + 316 326 #define REG_FE_GDM_TX_OK_PKT_CNT_H(_n) (GDM_BASE(_n) + 0x280) 317 327 #define REG_FE_GDM_TX_OK_BYTE_CNT_H(_n) (GDM_BASE(_n) + 0x284) 318 328 #define REG_FE_GDM_TX_ETH_PKT_CNT_H(_n) (GDM_BASE(_n) + 0x288)

+1 -1

drivers/net/ethernet/google/gve/gve_main.c

··· 2153 2153 }; 2154 2154 stats[stats_idx++] = (struct stats) { 2155 2155 .stat_name = cpu_to_be32(RX_BUFFERS_POSTED), 2156 - .value = cpu_to_be64(priv->rx[0].fill_cnt), 2156 + .value = cpu_to_be64(priv->rx[idx].fill_cnt), 2157 2157 .queue_id = cpu_to_be32(idx), 2158 2158 }; 2159 2159 }

+3

drivers/net/ethernet/google/gve/gve_tx_dqo.c

··· 764 764 s16 completion_tag; 765 765 766 766 pkt = gve_alloc_pending_packet(tx); 767 + if (!pkt) 768 + return -ENOMEM; 769 + 767 770 pkt->skb = skb; 768 771 completion_tag = pkt - tx->dqo.pending_packets; 769 772

-2

drivers/net/ethernet/huawei/hinic3/hinic3_main.c

··· 324 324 { 325 325 int err; 326 326 327 - pr_info("%s: %s\n", HINIC3_NIC_DRV_NAME, HINIC3_NIC_DRV_DESC); 328 - 329 327 err = hinic3_lld_init(); 330 328 if (err) 331 329 return err;

-1

drivers/net/ethernet/intel/iavf/iavf.h

··· 268 268 struct list_head vlan_filter_list; 269 269 int num_vlan_filters; 270 270 struct list_head mac_filter_list; 271 - struct mutex crit_lock; 272 271 /* Lock to protect accesses to MAC and VLAN lists */ 273 272 spinlock_t mac_vlan_list_lock; 274 273 char misc_vector_name[IFNAMSIZ + 9];

+7 -22

drivers/net/ethernet/intel/iavf/iavf_ethtool.c

··· 4 4 #include <linux/bitfield.h> 5 5 #include <linux/uaccess.h> 6 6 7 + #include <net/netdev_lock.h> 8 + 7 9 /* ethtool support for iavf */ 8 10 #include "iavf.h" 9 11 ··· 1258 1256 { 1259 1257 struct ethtool_rx_flow_spec *fsp = &cmd->fs; 1260 1258 struct iavf_fdir_fltr *fltr; 1261 - int count = 50; 1262 1259 int err; 1260 + 1261 + netdev_assert_locked(adapter->netdev); 1263 1262 1264 1263 if (!(adapter->flags & IAVF_FLAG_FDIR_ENABLED)) 1265 1264 return -EOPNOTSUPP; ··· 1280 1277 if (!fltr) 1281 1278 return -ENOMEM; 1282 1279 1283 - while (!mutex_trylock(&adapter->crit_lock)) { 1284 - if (--count == 0) { 1285 - kfree(fltr); 1286 - return -EINVAL; 1287 - } 1288 - udelay(1); 1289 - } 1290 - 1291 1280 err = iavf_add_fdir_fltr_info(adapter, fsp, fltr); 1292 1281 if (!err) 1293 1282 err = iavf_fdir_add_fltr(adapter, fltr); ··· 1287 1292 if (err) 1288 1293 kfree(fltr); 1289 1294 1290 - mutex_unlock(&adapter->crit_lock); 1291 1295 return err; 1292 1296 } 1293 1297 ··· 1429 1435 { 1430 1436 struct iavf_adv_rss *rss_old, *rss_new; 1431 1437 bool rss_new_add = false; 1432 - int count = 50, err = 0; 1433 1438 bool symm = false; 1434 1439 u64 hash_flds; 1440 + int err = 0; 1435 1441 u32 hdrs; 1442 + 1443 + netdev_assert_locked(adapter->netdev); 1436 1444 1437 1445 if (!ADV_RSS_SUPPORT(adapter)) 1438 1446 return -EOPNOTSUPP; ··· 1457 1461 symm)) { 1458 1462 kfree(rss_new); 1459 1463 return -EINVAL; 1460 - } 1461 - 1462 - while (!mutex_trylock(&adapter->crit_lock)) { 1463 - if (--count == 0) { 1464 - kfree(rss_new); 1465 - return -EINVAL; 1466 - } 1467 - 1468 - udelay(1); 1469 1464 } 1470 1465 1471 1466 spin_lock_bh(&adapter->adv_rss_lock); ··· 1486 1499 1487 1500 if (!err) 1488 1501 iavf_schedule_aq_request(adapter, IAVF_FLAG_AQ_ADD_ADV_RSS_CFG); 1489 - 1490 - mutex_unlock(&adapter->crit_lock); 1491 1502 1492 1503 if (!rss_new_add) 1493 1504 kfree(rss_new);

+90 -201

drivers/net/ethernet/intel/iavf/iavf_main.c

··· 1287 1287 /** 1288 1288 * iavf_up_complete - Finish the last steps of bringing up a connection 1289 1289 * @adapter: board private structure 1290 - * 1291 - * Expects to be called while holding crit_lock. 1292 - **/ 1290 + */ 1293 1291 static void iavf_up_complete(struct iavf_adapter *adapter) 1294 1292 { 1293 + netdev_assert_locked(adapter->netdev); 1294 + 1295 1295 iavf_change_state(adapter, __IAVF_RUNNING); 1296 1296 clear_bit(__IAVF_VSI_DOWN, adapter->vsi.state); 1297 1297 ··· 1410 1410 /** 1411 1411 * iavf_down - Shutdown the connection processing 1412 1412 * @adapter: board private structure 1413 - * 1414 - * Expects to be called while holding crit_lock. 1415 - **/ 1413 + */ 1416 1414 void iavf_down(struct iavf_adapter *adapter) 1417 1415 { 1418 1416 struct net_device *netdev = adapter->netdev; 1417 + 1418 + netdev_assert_locked(netdev); 1419 1419 1420 1420 if (adapter->state <= __IAVF_DOWN_PENDING) 1421 1421 return; ··· 2025 2025 * iavf_finish_config - do all netdev work that needs RTNL 2026 2026 * @work: our work_struct 2027 2027 * 2028 - * Do work that needs both RTNL and crit_lock. 2029 - **/ 2028 + * Do work that needs RTNL. 2029 + */ 2030 2030 static void iavf_finish_config(struct work_struct *work) 2031 2031 { 2032 2032 struct iavf_adapter *adapter; 2033 - bool locks_released = false; 2033 + bool netdev_released = false; 2034 2034 int pairs, err; 2035 2035 2036 2036 adapter = container_of(work, struct iavf_adapter, finish_config); 2037 2037 2038 2038 /* Always take RTNL first to prevent circular lock dependency; 2039 - * The dev->lock is needed to update the queue number 2039 + * the dev->lock (== netdev lock) is needed to update the queue number. 2040 2040 */ 2041 2041 rtnl_lock(); 2042 2042 netdev_lock(adapter->netdev); 2043 - mutex_lock(&adapter->crit_lock); 2044 2043 2045 2044 if ((adapter->flags & IAVF_FLAG_SETUP_NETDEV_FEATURES) && 2046 2045 adapter->netdev->reg_state == NETREG_REGISTERED && ··· 2058 2059 netif_set_real_num_tx_queues(adapter->netdev, pairs); 2059 2060 2060 2061 if (adapter->netdev->reg_state != NETREG_REGISTERED) { 2061 - mutex_unlock(&adapter->crit_lock); 2062 2062 netdev_unlock(adapter->netdev); 2063 - locks_released = true; 2063 + netdev_released = true; 2064 2064 err = register_netdevice(adapter->netdev); 2065 2065 if (err) { 2066 2066 dev_err(&adapter->pdev->dev, "Unable to register netdev (%d)\n", 2067 2067 err); 2068 2068 2069 2069 /* go back and try again.*/ 2070 - mutex_lock(&adapter->crit_lock); 2070 + netdev_lock(adapter->netdev); 2071 2071 iavf_free_rss(adapter); 2072 2072 iavf_free_misc_irq(adapter); 2073 2073 iavf_reset_interrupt_capability(adapter); 2074 2074 iavf_change_state(adapter, 2075 2075 __IAVF_INIT_CONFIG_ADAPTER); 2076 - mutex_unlock(&adapter->crit_lock); 2076 + netdev_unlock(adapter->netdev); 2077 2077 goto out; 2078 2078 } 2079 2079 } ··· 2088 2090 } 2089 2091 2090 2092 out: 2091 - if (!locks_released) { 2092 - mutex_unlock(&adapter->crit_lock); 2093 + if (!netdev_released) 2093 2094 netdev_unlock(adapter->netdev); 2094 - } 2095 2095 rtnl_unlock(); 2096 2096 } 2097 2097 ··· 2907 2911 iavf_change_state(adapter, __IAVF_INIT_FAILED); 2908 2912 } 2909 2913 2910 - /** 2911 - * iavf_watchdog_task - Periodic call-back task 2912 - * @work: pointer to work_struct 2913 - **/ 2914 - static void iavf_watchdog_task(struct work_struct *work) 2914 + static const int IAVF_NO_RESCHED = -1; 2915 + 2916 + /* return: msec delay for requeueing itself */ 2917 + static int iavf_watchdog_step(struct iavf_adapter *adapter) 2915 2918 { 2916 - struct iavf_adapter *adapter = container_of(work, 2917 - struct iavf_adapter, 2918 - watchdog_task.work); 2919 - struct net_device *netdev = adapter->netdev; 2920 2919 struct iavf_hw *hw = &adapter->hw; 2921 2920 u32 reg_val; 2922 2921 2923 - netdev_lock(netdev); 2924 - if (!mutex_trylock(&adapter->crit_lock)) { 2925 - if (adapter->state == __IAVF_REMOVE) { 2926 - netdev_unlock(netdev); 2927 - return; 2928 - } 2929 - 2930 - goto restart_watchdog; 2931 - } 2922 + netdev_assert_locked(adapter->netdev); 2932 2923 2933 2924 if (adapter->flags & IAVF_FLAG_PF_COMMS_FAILED) 2934 2925 iavf_change_state(adapter, __IAVF_COMM_FAILED); ··· 2923 2940 switch (adapter->state) { 2924 2941 case __IAVF_STARTUP: 2925 2942 iavf_startup(adapter); 2926 - mutex_unlock(&adapter->crit_lock); 2927 - netdev_unlock(netdev); 2928 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, 2929 - msecs_to_jiffies(30)); 2930 - return; 2943 + return 30; 2931 2944 case __IAVF_INIT_VERSION_CHECK: 2932 2945 iavf_init_version_check(adapter); 2933 - mutex_unlock(&adapter->crit_lock); 2934 - netdev_unlock(netdev); 2935 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, 2936 - msecs_to_jiffies(30)); 2937 - return; 2946 + return 30; 2938 2947 case __IAVF_INIT_GET_RESOURCES: 2939 2948 iavf_init_get_resources(adapter); 2940 - mutex_unlock(&adapter->crit_lock); 2941 - netdev_unlock(netdev); 2942 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, 2943 - msecs_to_jiffies(1)); 2944 - return; 2949 + return 1; 2945 2950 case __IAVF_INIT_EXTENDED_CAPS: 2946 2951 iavf_init_process_extended_caps(adapter); 2947 - mutex_unlock(&adapter->crit_lock); 2948 - netdev_unlock(netdev); 2949 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, 2950 - msecs_to_jiffies(1)); 2951 - return; 2952 + return 1; 2952 2953 case __IAVF_INIT_CONFIG_ADAPTER: 2953 2954 iavf_init_config_adapter(adapter); 2954 - mutex_unlock(&adapter->crit_lock); 2955 - netdev_unlock(netdev); 2956 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, 2957 - msecs_to_jiffies(1)); 2958 - return; 2955 + return 1; 2959 2956 case __IAVF_INIT_FAILED: 2960 2957 if (test_bit(__IAVF_IN_REMOVE_TASK, 2961 2958 &adapter->crit_section)) { ··· 2943 2980 * watchdog task, iavf_remove should handle this state 2944 2981 * as it can loop forever 2945 2982 */ 2946 - mutex_unlock(&adapter->crit_lock); 2947 - netdev_unlock(netdev); 2948 - return; 2983 + return IAVF_NO_RESCHED; 2949 2984 } 2950 2985 if (++adapter->aq_wait_count > IAVF_AQ_MAX_ERR) { 2951 2986 dev_err(&adapter->pdev->dev, 2952 2987 "Failed to communicate with PF; waiting before retry\n"); 2953 2988 adapter->flags |= IAVF_FLAG_PF_COMMS_FAILED; 2954 2989 iavf_shutdown_adminq(hw); 2955 - mutex_unlock(&adapter->crit_lock); 2956 - netdev_unlock(netdev); 2957 - queue_delayed_work(adapter->wq, 2958 - &adapter->watchdog_task, (5 * HZ)); 2959 - return; 2990 + return 5000; 2960 2991 } 2961 2992 /* Try again from failed step*/ 2962 2993 iavf_change_state(adapter, adapter->last_state); 2963 - mutex_unlock(&adapter->crit_lock); 2964 - netdev_unlock(netdev); 2965 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, HZ); 2966 - return; 2994 + return 1000; 2967 2995 case __IAVF_COMM_FAILED: 2968 2996 if (test_bit(__IAVF_IN_REMOVE_TASK, 2969 2997 &adapter->crit_section)) { ··· 2964 3010 */ 2965 3011 iavf_change_state(adapter, __IAVF_INIT_FAILED); 2966 3012 adapter->flags &= ~IAVF_FLAG_PF_COMMS_FAILED; 2967 - mutex_unlock(&adapter->crit_lock); 2968 - netdev_unlock(netdev); 2969 - return; 3013 + return IAVF_NO_RESCHED; 2970 3014 } 2971 3015 reg_val = rd32(hw, IAVF_VFGEN_RSTAT) & 2972 3016 IAVF_VFGEN_RSTAT_VFR_STATE_MASK; ··· 2982 3030 } 2983 3031 adapter->aq_required = 0; 2984 3032 adapter->current_op = VIRTCHNL_OP_UNKNOWN; 2985 - mutex_unlock(&adapter->crit_lock); 2986 - netdev_unlock(netdev); 2987 - queue_delayed_work(adapter->wq, 2988 - &adapter->watchdog_task, 2989 - msecs_to_jiffies(10)); 2990 - return; 3033 + return 10; 2991 3034 case __IAVF_RESETTING: 2992 - mutex_unlock(&adapter->crit_lock); 2993 - netdev_unlock(netdev); 2994 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, 2995 - HZ * 2); 2996 - return; 3035 + return 2000; 2997 3036 case __IAVF_DOWN: 2998 3037 case __IAVF_DOWN_PENDING: 2999 3038 case __IAVF_TESTING: ··· 3011 3068 break; 3012 3069 case __IAVF_REMOVE: 3013 3070 default: 3014 - mutex_unlock(&adapter->crit_lock); 3015 - netdev_unlock(netdev); 3016 - return; 3071 + return IAVF_NO_RESCHED; 3017 3072 } 3018 3073 3019 3074 /* check for hw reset */ ··· 3021 3080 adapter->current_op = VIRTCHNL_OP_UNKNOWN; 3022 3081 dev_err(&adapter->pdev->dev, "Hardware reset detected\n"); 3023 3082 iavf_schedule_reset(adapter, IAVF_FLAG_RESET_PENDING); 3024 - mutex_unlock(&adapter->crit_lock); 3025 - netdev_unlock(netdev); 3026 - queue_delayed_work(adapter->wq, 3027 - &adapter->watchdog_task, HZ * 2); 3028 - return; 3029 3083 } 3030 3084 3031 - mutex_unlock(&adapter->crit_lock); 3032 - restart_watchdog: 3033 - netdev_unlock(netdev); 3085 + return adapter->aq_required ? 20 : 2000; 3086 + } 3087 + 3088 + static void iavf_watchdog_task(struct work_struct *work) 3089 + { 3090 + struct iavf_adapter *adapter = container_of(work, 3091 + struct iavf_adapter, 3092 + watchdog_task.work); 3093 + struct net_device *netdev = adapter->netdev; 3094 + int msec_delay; 3095 + 3096 + netdev_lock(netdev); 3097 + msec_delay = iavf_watchdog_step(adapter); 3098 + /* note that we schedule a different task */ 3034 3099 if (adapter->state >= __IAVF_DOWN) 3035 3100 queue_work(adapter->wq, &adapter->adminq_task); 3036 - if (adapter->aq_required) 3101 + 3102 + if (msec_delay != IAVF_NO_RESCHED) 3037 3103 queue_delayed_work(adapter->wq, &adapter->watchdog_task, 3038 - msecs_to_jiffies(20)); 3039 - else 3040 - queue_delayed_work(adapter->wq, &adapter->watchdog_task, 3041 - HZ * 2); 3104 + msecs_to_jiffies(msec_delay)); 3105 + netdev_unlock(netdev); 3042 3106 } 3043 3107 3044 3108 /** ··· 3051 3105 * @adapter: board private structure 3052 3106 * 3053 3107 * Set communication failed flag and free all resources. 3054 - * NOTE: This function is expected to be called with crit_lock being held. 3055 - **/ 3108 + */ 3056 3109 static void iavf_disable_vf(struct iavf_adapter *adapter) 3057 3110 { 3058 3111 struct iavf_mac_filter *f, *ftmp; 3059 3112 struct iavf_vlan_filter *fv, *fvtmp; 3060 3113 struct iavf_cloud_filter *cf, *cftmp; 3114 + 3115 + netdev_assert_locked(adapter->netdev); 3061 3116 3062 3117 adapter->flags |= IAVF_FLAG_PF_COMMS_FAILED; 3063 3118 ··· 3159 3212 int i = 0, err; 3160 3213 bool running; 3161 3214 3162 - /* When device is being removed it doesn't make sense to run the reset 3163 - * task, just return in such a case. 3164 - */ 3165 3215 netdev_lock(netdev); 3166 - if (!mutex_trylock(&adapter->crit_lock)) { 3167 - if (adapter->state != __IAVF_REMOVE) 3168 - queue_work(adapter->wq, &adapter->reset_task); 3169 - 3170 - netdev_unlock(netdev); 3171 - return; 3172 - } 3173 3216 3174 3217 iavf_misc_irq_disable(adapter); 3175 3218 if (adapter->flags & IAVF_FLAG_RESET_NEEDED) { ··· 3204 3267 dev_err(&adapter->pdev->dev, "Reset never finished (%x)\n", 3205 3268 reg_val); 3206 3269 iavf_disable_vf(adapter); 3207 - mutex_unlock(&adapter->crit_lock); 3208 3270 netdev_unlock(netdev); 3209 3271 return; /* Do not attempt to reinit. It's dead, Jim. */ 3210 3272 } ··· 3347 3411 adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED; 3348 3412 3349 3413 wake_up(&adapter->reset_waitqueue); 3350 - mutex_unlock(&adapter->crit_lock); 3351 3414 netdev_unlock(netdev); 3352 3415 3353 3416 return; ··· 3357 3422 } 3358 3423 iavf_disable_vf(adapter); 3359 3424 3360 - mutex_unlock(&adapter->crit_lock); 3361 3425 netdev_unlock(netdev); 3362 3426 dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n"); 3363 3427 } ··· 3369 3435 { 3370 3436 struct iavf_adapter *adapter = 3371 3437 container_of(work, struct iavf_adapter, adminq_task); 3438 + struct net_device *netdev = adapter->netdev; 3372 3439 struct iavf_hw *hw = &adapter->hw; 3373 3440 struct iavf_arq_event_info event; 3374 3441 enum virtchnl_ops v_op; ··· 3377 3442 u32 val, oldval; 3378 3443 u16 pending; 3379 3444 3380 - if (!mutex_trylock(&adapter->crit_lock)) { 3381 - if (adapter->state == __IAVF_REMOVE) 3382 - return; 3383 - 3384 - queue_work(adapter->wq, &adapter->adminq_task); 3385 - goto out; 3386 - } 3445 + netdev_lock(netdev); 3387 3446 3388 3447 if (adapter->flags & IAVF_FLAG_PF_COMMS_FAILED) 3389 3448 goto unlock; ··· 3444 3515 freedom: 3445 3516 kfree(event.msg_buf); 3446 3517 unlock: 3447 - mutex_unlock(&adapter->crit_lock); 3448 - out: 3518 + netdev_unlock(netdev); 3449 3519 /* re-enable Admin queue interrupt cause */ 3450 3520 iavf_misc_irq_enable(adapter); 3451 3521 } ··· 4137 4209 struct flow_cls_offload *cls_flower) 4138 4210 { 4139 4211 int tc = tc_classid_to_hwtc(adapter->netdev, cls_flower->classid); 4140 - struct iavf_cloud_filter *filter = NULL; 4141 - int err = -EINVAL, count = 50; 4212 + struct iavf_cloud_filter *filter; 4213 + int err; 4142 4214 4143 4215 if (tc < 0) { 4144 4216 dev_err(&adapter->pdev->dev, "Invalid traffic class\n"); ··· 4148 4220 filter = kzalloc(sizeof(*filter), GFP_KERNEL); 4149 4221 if (!filter) 4150 4222 return -ENOMEM; 4151 - 4152 - while (!mutex_trylock(&adapter->crit_lock)) { 4153 - if (--count == 0) { 4154 - kfree(filter); 4155 - return err; 4156 - } 4157 - udelay(1); 4158 - } 4159 - 4160 4223 filter->cookie = cls_flower->cookie; 4224 + 4225 + netdev_lock(adapter->netdev); 4161 4226 4162 4227 /* bail out here if filter already exists */ 4163 4228 spin_lock_bh(&adapter->cloud_filter_list_lock); ··· 4185 4264 if (err) 4186 4265 kfree(filter); 4187 4266 4188 - mutex_unlock(&adapter->crit_lock); 4267 + netdev_unlock(adapter->netdev); 4189 4268 return err; 4190 4269 } 4191 4270 ··· 4489 4568 return -EIO; 4490 4569 } 4491 4570 4492 - while (!mutex_trylock(&adapter->crit_lock)) { 4493 - /* If we are in __IAVF_INIT_CONFIG_ADAPTER state the crit_lock 4494 - * is already taken and iavf_open is called from an upper 4495 - * device's notifier reacting on NETDEV_REGISTER event. 4496 - * We have to leave here to avoid dead lock. 4497 - */ 4498 - if (adapter->state == __IAVF_INIT_CONFIG_ADAPTER) 4499 - return -EBUSY; 4500 - 4501 - usleep_range(500, 1000); 4502 - } 4503 - 4504 - if (adapter->state != __IAVF_DOWN) { 4505 - err = -EBUSY; 4506 - goto err_unlock; 4507 - } 4571 + if (adapter->state != __IAVF_DOWN) 4572 + return -EBUSY; 4508 4573 4509 4574 if (adapter->state == __IAVF_RUNNING && 4510 4575 !test_bit(__IAVF_VSI_DOWN, adapter->vsi.state)) { 4511 4576 dev_dbg(&adapter->pdev->dev, "VF is already open.\n"); 4512 - err = 0; 4513 - goto err_unlock; 4577 + return 0; 4514 4578 } 4515 4579 4516 4580 /* allocate transmit descriptors */ ··· 4514 4608 goto err_req_irq; 4515 4609 4516 4610 spin_lock_bh(&adapter->mac_vlan_list_lock); 4517 - 4518 4611 iavf_add_filter(adapter, adapter->hw.mac.addr); 4519 - 4520 4612 spin_unlock_bh(&adapter->mac_vlan_list_lock); 4521 4613 4522 4614 /* Restore filters that were removed with IFF_DOWN */ ··· 4527 4623 4528 4624 iavf_irq_enable(adapter, true); 4529 4625 4530 - mutex_unlock(&adapter->crit_lock); 4531 - 4532 4626 return 0; 4533 4627 4534 4628 err_req_irq: ··· 4536 4634 iavf_free_all_rx_resources(adapter); 4537 4635 err_setup_tx: 4538 4636 iavf_free_all_tx_resources(adapter); 4539 - err_unlock: 4540 - mutex_unlock(&adapter->crit_lock); 4541 4637 4542 4638 return err; 4543 4639 } ··· 4559 4659 4560 4660 netdev_assert_locked(netdev); 4561 4661 4562 - mutex_lock(&adapter->crit_lock); 4563 - 4564 - if (adapter->state <= __IAVF_DOWN_PENDING) { 4565 - mutex_unlock(&adapter->crit_lock); 4662 + if (adapter->state <= __IAVF_DOWN_PENDING) 4566 4663 return 0; 4567 - } 4568 4664 4569 4665 set_bit(__IAVF_VSI_DOWN, adapter->vsi.state); 4570 4666 /* We cannot send IAVF_FLAG_AQ_GET_OFFLOAD_VLAN_V2_CAPS before ··· 4591 4695 iavf_change_state(adapter, __IAVF_DOWN_PENDING); 4592 4696 iavf_free_traffic_irqs(adapter); 4593 4697 4594 - mutex_unlock(&adapter->crit_lock); 4595 4698 netdev_unlock(netdev); 4596 4699 4597 4700 /* We explicitly don't free resources here because the hardware is ··· 4609 4714 msecs_to_jiffies(500)); 4610 4715 if (!status) 4611 4716 netdev_warn(netdev, "Device resources not yet released\n"); 4612 - 4613 4717 netdev_lock(netdev); 4614 - mutex_lock(&adapter->crit_lock); 4718 + 4615 4719 adapter->aq_required |= aq_to_restore; 4616 - mutex_unlock(&adapter->crit_lock); 4720 + 4617 4721 return 0; 4618 4722 } 4619 4723 ··· 5121 5227 struct iavf_adapter *adapter = netdev_priv(binding->netdev); 5122 5228 const struct net_shaper_handle *handle = &shaper->handle; 5123 5229 struct iavf_ring *tx_ring; 5124 - int ret = 0; 5230 + int ret; 5125 5231 5126 - mutex_lock(&adapter->crit_lock); 5232 + netdev_assert_locked(adapter->netdev); 5233 + 5127 5234 if (handle->id >= adapter->num_active_queues) 5128 - goto unlock; 5235 + return 0; 5129 5236 5130 5237 ret = iavf_verify_shaper(binding, shaper, extack); 5131 5238 if (ret) 5132 - goto unlock; 5239 + return ret; 5133 5240 5134 5241 tx_ring = &adapter->tx_rings[handle->id]; 5135 5242 ··· 5140 5245 5141 5246 adapter->aq_required |= IAVF_FLAG_AQ_CONFIGURE_QUEUES_BW; 5142 5247 5143 - unlock: 5144 - mutex_unlock(&adapter->crit_lock); 5145 - return ret; 5248 + return 0; 5146 5249 } 5147 5250 5148 5251 static int iavf_shaper_del(struct net_shaper_binding *binding, ··· 5150 5257 struct iavf_adapter *adapter = netdev_priv(binding->netdev); 5151 5258 struct iavf_ring *tx_ring; 5152 5259 5153 - mutex_lock(&adapter->crit_lock); 5260 + netdev_assert_locked(adapter->netdev); 5261 + 5154 5262 if (handle->id >= adapter->num_active_queues) 5155 - goto unlock; 5263 + return 0; 5156 5264 5157 5265 tx_ring = &adapter->tx_rings[handle->id]; 5158 5266 tx_ring->q_shaper.bw_min = 0; ··· 5162 5268 5163 5269 adapter->aq_required |= IAVF_FLAG_AQ_CONFIGURE_QUEUES_BW; 5164 5270 5165 - unlock: 5166 - mutex_unlock(&adapter->crit_lock); 5167 5271 return 0; 5168 5272 } 5169 5273 ··· 5422 5530 goto err_alloc_qos_cap; 5423 5531 } 5424 5532 5425 - /* set up the locks for the AQ, do this only once in probe 5426 - * and destroy them only once in remove 5427 - */ 5428 - mutex_init(&adapter->crit_lock); 5429 5533 mutex_init(&hw->aq.asq_mutex); 5430 5534 mutex_init(&hw->aq.arq_mutex); 5431 5535 ··· 5484 5596 { 5485 5597 struct net_device *netdev = dev_get_drvdata(dev_d); 5486 5598 struct iavf_adapter *adapter = netdev_priv(netdev); 5599 + bool running; 5487 5600 5488 5601 netif_device_detach(netdev); 5489 5602 5490 - netdev_lock(netdev); 5491 - mutex_lock(&adapter->crit_lock); 5492 - 5493 - if (netif_running(netdev)) { 5603 + running = netif_running(netdev); 5604 + if (running) 5494 5605 rtnl_lock(); 5606 + netdev_lock(netdev); 5607 + 5608 + if (running) 5495 5609 iavf_down(adapter); 5496 - rtnl_unlock(); 5497 - } 5610 + 5498 5611 iavf_free_misc_irq(adapter); 5499 5612 iavf_reset_interrupt_capability(adapter); 5500 5613 5501 - mutex_unlock(&adapter->crit_lock); 5502 5614 netdev_unlock(netdev); 5615 + if (running) 5616 + rtnl_unlock(); 5503 5617 5504 5618 return 0; 5505 5619 } ··· 5578 5688 * There are flows where register/unregister netdev may race. 5579 5689 */ 5580 5690 while (1) { 5581 - mutex_lock(&adapter->crit_lock); 5691 + netdev_lock(netdev); 5582 5692 if (adapter->state == __IAVF_RUNNING || 5583 5693 adapter->state == __IAVF_DOWN || 5584 5694 adapter->state == __IAVF_INIT_FAILED) { 5585 - mutex_unlock(&adapter->crit_lock); 5695 + netdev_unlock(netdev); 5586 5696 break; 5587 5697 } 5588 5698 /* Simply return if we already went through iavf_shutdown */ 5589 5699 if (adapter->state == __IAVF_REMOVE) { 5590 - mutex_unlock(&adapter->crit_lock); 5700 + netdev_unlock(netdev); 5591 5701 return; 5592 5702 } 5593 5703 5594 - mutex_unlock(&adapter->crit_lock); 5704 + netdev_unlock(netdev); 5595 5705 usleep_range(500, 1000); 5596 5706 } 5597 5707 cancel_delayed_work_sync(&adapter->watchdog_task); ··· 5601 5711 unregister_netdev(netdev); 5602 5712 5603 5713 netdev_lock(netdev); 5604 - mutex_lock(&adapter->crit_lock); 5605 5714 dev_info(&adapter->pdev->dev, "Removing device\n"); 5606 5715 iavf_change_state(adapter, __IAVF_REMOVE); 5607 5716 ··· 5616 5727 5617 5728 iavf_misc_irq_disable(adapter); 5618 5729 /* Shut down all the garbage mashers on the detention level */ 5730 + netdev_unlock(netdev); 5619 5731 cancel_work_sync(&adapter->reset_task); 5620 5732 cancel_delayed_work_sync(&adapter->watchdog_task); 5621 5733 cancel_work_sync(&adapter->adminq_task); 5734 + netdev_lock(netdev); 5622 5735 5623 5736 adapter->aq_required = 0; 5624 5737 adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED; ··· 5638 5747 /* destroy the locks only once, here */ 5639 5748 mutex_destroy(&hw->aq.arq_mutex); 5640 5749 mutex_destroy(&hw->aq.asq_mutex); 5641 - mutex_unlock(&adapter->crit_lock); 5642 - mutex_destroy(&adapter->crit_lock); 5643 5750 netdev_unlock(netdev); 5644 5751 5645 5752 iounmap(hw->hw_addr);

+33 -14

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

··· 2741 2741 } 2742 2742 2743 2743 /** 2744 + * ice_unmap_xdp_rings - Unmap XDP rings from interrupt vectors 2745 + * @vsi: the VSI with XDP rings being unmapped 2746 + */ 2747 + static void ice_unmap_xdp_rings(struct ice_vsi *vsi) 2748 + { 2749 + int v_idx; 2750 + 2751 + ice_for_each_q_vector(vsi, v_idx) { 2752 + struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2753 + struct ice_tx_ring *ring; 2754 + 2755 + ice_for_each_tx_ring(ring, q_vector->tx) 2756 + if (!ring->tx_buf || !ice_ring_is_xdp(ring)) 2757 + break; 2758 + 2759 + /* restore the value of last node prior to XDP setup */ 2760 + q_vector->tx.tx_ring = ring; 2761 + } 2762 + } 2763 + 2764 + /** 2744 2765 * ice_prepare_xdp_rings - Allocate, configure and setup Tx rings for XDP 2745 2766 * @vsi: VSI to bring up Tx rings used by XDP 2746 2767 * @prog: bpf program that will be assigned to VSI ··· 2824 2803 if (status) { 2825 2804 dev_err(dev, "Failed VSI LAN queue config for XDP, error: %d\n", 2826 2805 status); 2827 - goto clear_xdp_rings; 2806 + goto unmap_xdp_rings; 2828 2807 } 2829 2808 2830 2809 /* assign the prog only when it's not already present on VSI; ··· 2840 2819 ice_vsi_assign_bpf_prog(vsi, prog); 2841 2820 2842 2821 return 0; 2822 + unmap_xdp_rings: 2823 + ice_unmap_xdp_rings(vsi); 2843 2824 clear_xdp_rings: 2844 2825 ice_for_each_xdp_txq(vsi, i) 2845 2826 if (vsi->xdp_rings[i]) { ··· 2858 2835 mutex_unlock(&pf->avail_q_mutex); 2859 2836 2860 2837 devm_kfree(dev, vsi->xdp_rings); 2838 + vsi->xdp_rings = NULL; 2839 + 2861 2840 return -ENOMEM; 2862 2841 } 2863 2842 ··· 2875 2850 { 2876 2851 u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 2877 2852 struct ice_pf *pf = vsi->back; 2878 - int i, v_idx; 2853 + int i; 2879 2854 2880 2855 /* q_vectors are freed in reset path so there's no point in detaching 2881 2856 * rings ··· 2883 2858 if (cfg_type == ICE_XDP_CFG_PART) 2884 2859 goto free_qmap; 2885 2860 2886 - ice_for_each_q_vector(vsi, v_idx) { 2887 - struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; 2888 - struct ice_tx_ring *ring; 2889 - 2890 - ice_for_each_tx_ring(ring, q_vector->tx) 2891 - if (!ring->tx_buf || !ice_ring_is_xdp(ring)) 2892 - break; 2893 - 2894 - /* restore the value of last node prior to XDP setup */ 2895 - q_vector->tx.tx_ring = ring; 2896 - } 2861 + ice_unmap_xdp_rings(vsi); 2897 2862 2898 2863 free_qmap: 2899 2864 mutex_lock(&pf->avail_q_mutex); ··· 3028 3013 xdp_ring_err = ice_vsi_determine_xdp_res(vsi); 3029 3014 if (xdp_ring_err) { 3030 3015 NL_SET_ERR_MSG_MOD(extack, "Not enough Tx resources for XDP"); 3016 + goto resume_if; 3031 3017 } else { 3032 3018 xdp_ring_err = ice_prepare_xdp_rings(vsi, prog, 3033 3019 ICE_XDP_CFG_FULL); 3034 - if (xdp_ring_err) 3020 + if (xdp_ring_err) { 3035 3021 NL_SET_ERR_MSG_MOD(extack, "Setting up XDP Tx resources failed"); 3022 + goto resume_if; 3023 + } 3036 3024 } 3037 3025 xdp_features_set_redirect_target(vsi->netdev, true); 3038 3026 /* reallocate Rx queues that are used for zero-copy */ ··· 3053 3035 NL_SET_ERR_MSG_MOD(extack, "Freeing XDP Rx resources failed"); 3054 3036 } 3055 3037 3038 + resume_if: 3056 3039 if (if_running) 3057 3040 ret = ice_up(vsi); 3058 3041

+148 -33

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

··· 85 85 } 86 86 87 87 /** 88 + * ice_sched_find_next_vsi_node - find the next node for a given VSI 89 + * @vsi_node: VSI support node to start search with 90 + * 91 + * Return: Next VSI support node, or NULL. 92 + * 93 + * The function returns a pointer to the next node from the VSI layer 94 + * assigned to the given VSI, or NULL if there is no such a node. 95 + */ 96 + static struct ice_sched_node * 97 + ice_sched_find_next_vsi_node(struct ice_sched_node *vsi_node) 98 + { 99 + unsigned int vsi_handle = vsi_node->vsi_handle; 100 + 101 + while ((vsi_node = vsi_node->sibling) != NULL) 102 + if (vsi_node->vsi_handle == vsi_handle) 103 + break; 104 + 105 + return vsi_node; 106 + } 107 + 108 + /** 88 109 * ice_aqc_send_sched_elem_cmd - send scheduling elements cmd 89 110 * @hw: pointer to the HW struct 90 111 * @cmd_opc: cmd opcode ··· 1105 1084 if (parent->num_children < max_child_nodes) { 1106 1085 new_num_nodes = max_child_nodes - parent->num_children; 1107 1086 } else { 1108 - /* This parent is full, try the next sibling */ 1109 - parent = parent->sibling; 1087 + /* This parent is full, 1088 + * try the next available sibling. 1089 + */ 1090 + parent = ice_sched_find_next_vsi_node(parent); 1110 1091 /* Don't modify the first node TEID memory if the 1111 1092 * first node was added already in the above call. 1112 1093 * Instead send some temp memory for all other ··· 1551 1528 /* get the first queue group node from VSI sub-tree */ 1552 1529 qgrp_node = ice_sched_get_first_node(pi, vsi_node, qgrp_layer); 1553 1530 while (qgrp_node) { 1531 + struct ice_sched_node *next_vsi_node; 1532 + 1554 1533 /* make sure the qgroup node is part of the VSI subtree */ 1555 1534 if (ice_sched_find_node_in_subtree(pi->hw, vsi_node, qgrp_node)) 1556 1535 if (qgrp_node->num_children < max_children && 1557 1536 qgrp_node->owner == owner) 1558 1537 break; 1559 1538 qgrp_node = qgrp_node->sibling; 1539 + if (qgrp_node) 1540 + continue; 1541 + 1542 + next_vsi_node = ice_sched_find_next_vsi_node(vsi_node); 1543 + if (!next_vsi_node) 1544 + break; 1545 + 1546 + vsi_node = next_vsi_node; 1547 + qgrp_node = ice_sched_get_first_node(pi, vsi_node, qgrp_layer); 1560 1548 } 1561 1549 1562 1550 /* Select the best queue group */ ··· 1638 1604 /** 1639 1605 * ice_sched_calc_vsi_child_nodes - calculate number of VSI child nodes 1640 1606 * @hw: pointer to the HW struct 1641 - * @num_qs: number of queues 1607 + * @num_new_qs: number of new queues that will be added to the tree 1642 1608 * @num_nodes: num nodes array 1643 1609 * 1644 1610 * This function calculates the number of VSI child nodes based on the 1645 1611 * number of queues. 1646 1612 */ 1647 1613 static void 1648 - ice_sched_calc_vsi_child_nodes(struct ice_hw *hw, u16 num_qs, u16 *num_nodes) 1614 + ice_sched_calc_vsi_child_nodes(struct ice_hw *hw, u16 num_new_qs, u16 *num_nodes) 1649 1615 { 1650 - u16 num = num_qs; 1616 + u16 num = num_new_qs; 1651 1617 u8 i, qgl, vsil; 1652 1618 1653 1619 qgl = ice_sched_get_qgrp_layer(hw); ··· 1813 1779 if (!parent) 1814 1780 return -EIO; 1815 1781 1816 - if (i == vsil) 1782 + /* Do not modify the VSI handle for already existing VSI nodes, 1783 + * (if no new VSI node was added to the tree). 1784 + * Assign the VSI handle only to newly added VSI nodes. 1785 + */ 1786 + if (i == vsil && num_added) 1817 1787 parent->vsi_handle = vsi_handle; 1818 1788 } 1819 1789 ··· 1848 1810 /* add VSI supported nodes to TC subtree */ 1849 1811 return ice_sched_add_vsi_support_nodes(pi, vsi_handle, tc_node, 1850 1812 num_nodes); 1813 + } 1814 + 1815 + /** 1816 + * ice_sched_recalc_vsi_support_nodes - recalculate VSI support nodes count 1817 + * @hw: pointer to the HW struct 1818 + * @vsi_node: pointer to the leftmost VSI node that needs to be extended 1819 + * @new_numqs: new number of queues that has to be handled by the VSI 1820 + * @new_num_nodes: pointer to nodes count table to modify the VSI layer entry 1821 + * 1822 + * This function recalculates the number of supported nodes that need to 1823 + * be added after adding more Tx queues for a given VSI. 1824 + * The number of new VSI support nodes that shall be added will be saved 1825 + * to the @new_num_nodes table for the VSI layer. 1826 + */ 1827 + static void 1828 + ice_sched_recalc_vsi_support_nodes(struct ice_hw *hw, 1829 + struct ice_sched_node *vsi_node, 1830 + unsigned int new_numqs, u16 *new_num_nodes) 1831 + { 1832 + u32 vsi_nodes_cnt = 1; 1833 + u32 max_queue_cnt = 1; 1834 + u32 qgl, vsil; 1835 + 1836 + qgl = ice_sched_get_qgrp_layer(hw); 1837 + vsil = ice_sched_get_vsi_layer(hw); 1838 + 1839 + for (u32 i = vsil; i <= qgl; i++) 1840 + max_queue_cnt *= hw->max_children[i]; 1841 + 1842 + while ((vsi_node = ice_sched_find_next_vsi_node(vsi_node)) != NULL) 1843 + vsi_nodes_cnt++; 1844 + 1845 + if (new_numqs > (max_queue_cnt * vsi_nodes_cnt)) 1846 + new_num_nodes[vsil] = DIV_ROUND_UP(new_numqs, max_queue_cnt) - 1847 + vsi_nodes_cnt; 1851 1848 } 1852 1849 1853 1850 /** ··· 1936 1863 return status; 1937 1864 } 1938 1865 1939 - if (new_numqs) 1940 - ice_sched_calc_vsi_child_nodes(hw, new_numqs, new_num_nodes); 1941 - /* Keep the max number of queue configuration all the time. Update the 1942 - * tree only if number of queues > previous number of queues. This may 1866 + ice_sched_recalc_vsi_support_nodes(hw, vsi_node, 1867 + new_numqs, new_num_nodes); 1868 + ice_sched_calc_vsi_child_nodes(hw, new_numqs - prev_numqs, 1869 + new_num_nodes); 1870 + 1871 + /* Never decrease the number of queues in the tree. Update the tree 1872 + * only if number of queues > previous number of queues. This may 1943 1873 * leave some extra nodes in the tree if number of queues < previous 1944 1874 * number but that wouldn't harm anything. Removing those extra nodes 1945 1875 * may complicate the code if those nodes are part of SRL or 1946 1876 * individually rate limited. 1877 + * Also, add the required VSI support nodes if the existing ones cannot 1878 + * handle the requested new number of queues. 1947 1879 */ 1880 + status = ice_sched_add_vsi_support_nodes(pi, vsi_handle, tc_node, 1881 + new_num_nodes); 1882 + if (status) 1883 + return status; 1884 + 1948 1885 status = ice_sched_add_vsi_child_nodes(pi, vsi_handle, tc_node, 1949 1886 new_num_nodes, owner); 1950 1887 if (status) ··· 2096 2013 } 2097 2014 2098 2015 /** 2016 + * ice_sched_rm_vsi_subtree - remove all nodes assigned to a given VSI 2017 + * @pi: port information structure 2018 + * @vsi_node: pointer to the leftmost node of the VSI to be removed 2019 + * @owner: LAN or RDMA 2020 + * @tc: TC number 2021 + * 2022 + * Return: Zero in case of success, or -EBUSY if the VSI has leaf nodes in TC. 2023 + * 2024 + * This function removes all the VSI support nodes associated with a given VSI 2025 + * and its LAN or RDMA children nodes from the scheduler tree. 2026 + */ 2027 + static int 2028 + ice_sched_rm_vsi_subtree(struct ice_port_info *pi, 2029 + struct ice_sched_node *vsi_node, u8 owner, u8 tc) 2030 + { 2031 + u16 vsi_handle = vsi_node->vsi_handle; 2032 + bool all_vsi_nodes_removed = true; 2033 + int j = 0; 2034 + 2035 + while (vsi_node) { 2036 + struct ice_sched_node *next_vsi_node; 2037 + 2038 + if (ice_sched_is_leaf_node_present(vsi_node)) { 2039 + ice_debug(pi->hw, ICE_DBG_SCHED, "VSI has leaf nodes in TC %d\n", tc); 2040 + return -EBUSY; 2041 + } 2042 + while (j < vsi_node->num_children) { 2043 + if (vsi_node->children[j]->owner == owner) 2044 + ice_free_sched_node(pi, vsi_node->children[j]); 2045 + else 2046 + j++; 2047 + } 2048 + 2049 + next_vsi_node = ice_sched_find_next_vsi_node(vsi_node); 2050 + 2051 + /* remove the VSI if it has no children */ 2052 + if (!vsi_node->num_children) 2053 + ice_free_sched_node(pi, vsi_node); 2054 + else 2055 + all_vsi_nodes_removed = false; 2056 + 2057 + vsi_node = next_vsi_node; 2058 + } 2059 + 2060 + /* clean up aggregator related VSI info if any */ 2061 + if (all_vsi_nodes_removed) 2062 + ice_sched_rm_agg_vsi_info(pi, vsi_handle); 2063 + 2064 + return 0; 2065 + } 2066 + 2067 + /** 2099 2068 * ice_sched_rm_vsi_cfg - remove the VSI and its children nodes 2100 2069 * @pi: port information structure 2101 2070 * @vsi_handle: software VSI handle ··· 2173 2038 2174 2039 ice_for_each_traffic_class(i) { 2175 2040 struct ice_sched_node *vsi_node, *tc_node; 2176 - u8 j = 0; 2177 2041 2178 2042 tc_node = ice_sched_get_tc_node(pi, i); 2179 2043 if (!tc_node) ··· 2182 2048 if (!vsi_node) 2183 2049 continue; 2184 2050 2185 - if (ice_sched_is_leaf_node_present(vsi_node)) { 2186 - ice_debug(pi->hw, ICE_DBG_SCHED, "VSI has leaf nodes in TC %d\n", i); 2187 - status = -EBUSY; 2051 + status = ice_sched_rm_vsi_subtree(pi, vsi_node, owner, i); 2052 + if (status) 2188 2053 goto exit_sched_rm_vsi_cfg; 2189 - } 2190 - while (j < vsi_node->num_children) { 2191 - if (vsi_node->children[j]->owner == owner) { 2192 - ice_free_sched_node(pi, vsi_node->children[j]); 2193 2054 2194 - /* reset the counter again since the num 2195 - * children will be updated after node removal 2196 - */ 2197 - j = 0; 2198 - } else { 2199 - j++; 2200 - } 2201 - } 2202 - /* remove the VSI if it has no children */ 2203 - if (!vsi_node->num_children) { 2204 - ice_free_sched_node(pi, vsi_node); 2205 - vsi_ctx->sched.vsi_node[i] = NULL; 2055 + vsi_ctx->sched.vsi_node[i] = NULL; 2206 2056 2207 - /* clean up aggregator related VSI info if any */ 2208 - ice_sched_rm_agg_vsi_info(pi, vsi_handle); 2209 - } 2210 2057 if (owner == ICE_SCHED_NODE_OWNER_LAN) 2211 2058 vsi_ctx->sched.max_lanq[i] = 0; 2212 2059 else

+13 -5

drivers/net/ethernet/intel/idpf/idpf_lib.c

··· 1801 1801 if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) 1802 1802 return; 1803 1803 1804 - if (test_bit(IDPF_HR_FUNC_RESET, adapter->flags) || 1805 - test_bit(IDPF_HR_DRV_LOAD, adapter->flags)) { 1806 - set_bit(IDPF_HR_RESET_IN_PROG, adapter->flags); 1807 - idpf_init_hard_reset(adapter); 1808 - } 1804 + if (test_bit(IDPF_HR_FUNC_RESET, adapter->flags)) 1805 + goto func_reset; 1806 + 1807 + if (test_bit(IDPF_HR_DRV_LOAD, adapter->flags)) 1808 + goto drv_load; 1809 + 1810 + return; 1811 + 1812 + func_reset: 1813 + idpf_vc_xn_shutdown(adapter->vcxn_mngr); 1814 + drv_load: 1815 + set_bit(IDPF_HR_RESET_IN_PROG, adapter->flags); 1816 + idpf_init_hard_reset(adapter); 1809 1817 } 1810 1818 1811 1819 /**

+5 -4

drivers/net/ethernet/intel/idpf/idpf_singleq_txrx.c

··· 362 362 { 363 363 struct idpf_tx_offload_params offload = { }; 364 364 struct idpf_tx_buf *first; 365 + int csum, tso, needed; 365 366 unsigned int count; 366 367 __be16 protocol; 367 - int csum, tso; 368 368 369 369 count = idpf_tx_desc_count_required(tx_q, skb); 370 370 if (unlikely(!count)) 371 371 return idpf_tx_drop_skb(tx_q, skb); 372 372 373 - if (idpf_tx_maybe_stop_common(tx_q, 374 - count + IDPF_TX_DESCS_PER_CACHE_LINE + 375 - IDPF_TX_DESCS_FOR_CTX)) { 373 + needed = count + IDPF_TX_DESCS_PER_CACHE_LINE + IDPF_TX_DESCS_FOR_CTX; 374 + if (!netif_subqueue_maybe_stop(tx_q->netdev, tx_q->idx, 375 + IDPF_DESC_UNUSED(tx_q), 376 + needed, needed)) { 376 377 idpf_tx_buf_hw_update(tx_q, tx_q->next_to_use, false); 377 378 378 379 u64_stats_update_begin(&tx_q->stats_sync);

+17 -28

drivers/net/ethernet/intel/idpf/idpf_txrx.c

··· 2184 2184 desc->flow.qw1.compl_tag = cpu_to_le16(params->compl_tag); 2185 2185 } 2186 2186 2187 + /* Global conditions to tell whether the txq (and related resources) 2188 + * has room to allow the use of "size" descriptors. 2189 + */ 2190 + static int idpf_txq_has_room(struct idpf_tx_queue *tx_q, u32 size) 2191 + { 2192 + if (IDPF_DESC_UNUSED(tx_q) < size || 2193 + IDPF_TX_COMPLQ_PENDING(tx_q->txq_grp) > 2194 + IDPF_TX_COMPLQ_OVERFLOW_THRESH(tx_q->txq_grp->complq) || 2195 + IDPF_TX_BUF_RSV_LOW(tx_q)) 2196 + return 0; 2197 + return 1; 2198 + } 2199 + 2187 2200 /** 2188 2201 * idpf_tx_maybe_stop_splitq - 1st level check for Tx splitq stop conditions 2189 2202 * @tx_q: the queue to be checked ··· 2207 2194 static int idpf_tx_maybe_stop_splitq(struct idpf_tx_queue *tx_q, 2208 2195 unsigned int descs_needed) 2209 2196 { 2210 - if (idpf_tx_maybe_stop_common(tx_q, descs_needed)) 2211 - goto out; 2197 + if (netif_subqueue_maybe_stop(tx_q->netdev, tx_q->idx, 2198 + idpf_txq_has_room(tx_q, descs_needed), 2199 + 1, 1)) 2200 + return 0; 2212 2201 2213 - /* If there are too many outstanding completions expected on the 2214 - * completion queue, stop the TX queue to give the device some time to 2215 - * catch up 2216 - */ 2217 - if (unlikely(IDPF_TX_COMPLQ_PENDING(tx_q->txq_grp) > 2218 - IDPF_TX_COMPLQ_OVERFLOW_THRESH(tx_q->txq_grp->complq))) 2219 - goto splitq_stop; 2220 - 2221 - /* Also check for available book keeping buffers; if we are low, stop 2222 - * the queue to wait for more completions 2223 - */ 2224 - if (unlikely(IDPF_TX_BUF_RSV_LOW(tx_q))) 2225 - goto splitq_stop; 2226 - 2227 - return 0; 2228 - 2229 - splitq_stop: 2230 - netif_stop_subqueue(tx_q->netdev, tx_q->idx); 2231 - 2232 - out: 2233 2202 u64_stats_update_begin(&tx_q->stats_sync); 2234 2203 u64_stats_inc(&tx_q->q_stats.q_busy); 2235 2204 u64_stats_update_end(&tx_q->stats_sync); ··· 2236 2241 2237 2242 nq = netdev_get_tx_queue(tx_q->netdev, tx_q->idx); 2238 2243 tx_q->next_to_use = val; 2239 - 2240 - if (idpf_tx_maybe_stop_common(tx_q, IDPF_TX_DESC_NEEDED)) { 2241 - u64_stats_update_begin(&tx_q->stats_sync); 2242 - u64_stats_inc(&tx_q->q_stats.q_busy); 2243 - u64_stats_update_end(&tx_q->stats_sync); 2244 - } 2245 2244 2246 2245 /* Force memory writes to complete before letting h/w 2247 2246 * know there are new descriptors to fetch. (Only

-8

drivers/net/ethernet/intel/idpf/idpf_txrx.h

··· 1049 1049 u16 cleaned_count); 1050 1050 int idpf_tso(struct sk_buff *skb, struct idpf_tx_offload_params *off); 1051 1051 1052 - static inline bool idpf_tx_maybe_stop_common(struct idpf_tx_queue *tx_q, 1053 - u32 needed) 1054 - { 1055 - return !netif_subqueue_maybe_stop(tx_q->netdev, tx_q->idx, 1056 - IDPF_DESC_UNUSED(tx_q), 1057 - needed, needed); 1058 - } 1059 - 1060 1052 #endif /* !_IDPF_TXRX_H_ */

+1 -1

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

··· 347 347 * All waiting threads will be woken-up and their transaction aborted. Further 348 348 * operations on that object will fail. 349 349 */ 350 - static void idpf_vc_xn_shutdown(struct idpf_vc_xn_manager *vcxn_mngr) 350 + void idpf_vc_xn_shutdown(struct idpf_vc_xn_manager *vcxn_mngr) 351 351 { 352 352 int i; 353 353

+1

drivers/net/ethernet/intel/idpf/idpf_virtchnl.h

··· 150 150 int idpf_send_set_sriov_vfs_msg(struct idpf_adapter *adapter, u16 num_vfs); 151 151 int idpf_send_get_set_rss_key_msg(struct idpf_vport *vport, bool get); 152 152 int idpf_send_get_set_rss_lut_msg(struct idpf_vport *vport, bool get); 153 + void idpf_vc_xn_shutdown(struct idpf_vc_xn_manager *vcxn_mngr); 153 154 154 155 #endif /* _IDPF_VIRTCHNL_H_ */

+4

drivers/net/ethernet/mediatek/mtk_star_emac.c

··· 1463 1463 if (netif_running(ndev)) 1464 1464 mtk_star_disable(ndev); 1465 1465 1466 + netif_device_detach(ndev); 1467 + 1466 1468 clk_bulk_disable_unprepare(MTK_STAR_NCLKS, priv->clks); 1467 1469 1468 1470 return 0; ··· 1488 1486 if (ret) 1489 1487 clk_bulk_disable_unprepare(MTK_STAR_NCLKS, priv->clks); 1490 1488 } 1489 + 1490 + netif_device_attach(ndev); 1491 1491 1492 1492 return ret; 1493 1493 }

+1 -1

drivers/net/ethernet/mellanox/mlx4/en_clock.c

··· 249 249 static u32 freq_to_shift(u16 freq) 250 250 { 251 251 u32 freq_khz = freq * 1000; 252 - u64 max_val_cycles = freq_khz * 1000 * MLX4_EN_WRAP_AROUND_SEC; 252 + u64 max_val_cycles = freq_khz * 1000ULL * MLX4_EN_WRAP_AROUND_SEC; 253 253 u64 max_val_cycles_rounded = 1ULL << fls64(max_val_cycles - 1); 254 254 /* calculate max possible multiplier in order to fit in 64bit */ 255 255 u64 max_mul = div64_u64(ULLONG_MAX, max_val_cycles_rounded);

+1

drivers/net/ethernet/microchip/lan966x/lan966x_main.c

··· 879 879 lan966x_vlan_port_set_vlan_aware(port, 0); 880 880 lan966x_vlan_port_set_vid(port, HOST_PVID, false, false); 881 881 lan966x_vlan_port_apply(port); 882 + lan966x_vlan_port_rew_host(port); 882 883 883 884 return 0; 884 885 }

+1

drivers/net/ethernet/microchip/lan966x/lan966x_main.h

··· 497 497 bool lan966x_vlan_cpu_member_cpu_vlan_mask(struct lan966x *lan966x, u16 vid); 498 498 void lan966x_vlan_port_set_vlan_aware(struct lan966x_port *port, 499 499 bool vlan_aware); 500 + void lan966x_vlan_port_rew_host(struct lan966x_port *port); 500 501 int lan966x_vlan_port_set_vid(struct lan966x_port *port, 501 502 u16 vid, 502 503 bool pvid,

+1

drivers/net/ethernet/microchip/lan966x/lan966x_switchdev.c

··· 297 297 lan966x_vlan_port_set_vlan_aware(port, false); 298 298 lan966x_vlan_port_set_vid(port, HOST_PVID, false, false); 299 299 lan966x_vlan_port_apply(port); 300 + lan966x_vlan_port_rew_host(port); 300 301 } 301 302 302 303 int lan966x_port_changeupper(struct net_device *dev,

+21

drivers/net/ethernet/microchip/lan966x/lan966x_vlan.c

··· 149 149 port->vlan_aware = vlan_aware; 150 150 } 151 151 152 + /* When the interface is in host mode, the interface should not be vlan aware 153 + * but it should insert all the tags that it gets from the network stack. 154 + * The tags are not in the data of the frame but actually in the skb and the ifh 155 + * is configured already to get this tag. So what we need to do is to update the 156 + * rewriter to insert the vlan tag for all frames which have a vlan tag 157 + * different than 0. 158 + */ 159 + void lan966x_vlan_port_rew_host(struct lan966x_port *port) 160 + { 161 + struct lan966x *lan966x = port->lan966x; 162 + u32 val; 163 + 164 + /* Tag all frames except when VID=0*/ 165 + val = REW_TAG_CFG_TAG_CFG_SET(2); 166 + 167 + /* Update only some bits in the register */ 168 + lan_rmw(val, 169 + REW_TAG_CFG_TAG_CFG, 170 + lan966x, REW_TAG_CFG(port->chip_port)); 171 + } 172 + 152 173 void lan966x_vlan_port_apply(struct lan966x_port *port) 153 174 { 154 175 struct lan966x *lan966x = port->lan966x;

+5

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

··· 32 32 int i, ret = 0; 33 33 u32 ctrl; 34 34 35 + if (!ptp_rate) { 36 + netdev_warn(priv->dev, "Invalid PTP rate"); 37 + return -EINVAL; 38 + } 39 + 35 40 ret |= est_write(est_addr, EST_BTR_LOW, cfg->btr[0], false); 36 41 ret |= est_write(est_addr, EST_BTR_HIGH, cfg->btr[1], false); 37 42 ret |= est_write(est_addr, EST_TER, cfg->ter, false);

+5

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

··· 805 805 if (!(priv->dma_cap.time_stamp || priv->dma_cap.atime_stamp)) 806 806 return -EOPNOTSUPP; 807 807 808 + if (!priv->plat->clk_ptp_rate) { 809 + netdev_err(priv->dev, "Invalid PTP clock rate"); 810 + return -EINVAL; 811 + } 812 + 808 813 stmmac_config_hw_tstamping(priv, priv->ptpaddr, systime_flags); 809 814 priv->systime_flags = systime_flags; 810 815

+9 -2

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

··· 430 430 struct device_node *np = pdev->dev.of_node; 431 431 struct plat_stmmacenet_data *plat; 432 432 struct stmmac_dma_cfg *dma_cfg; 433 + static int bus_id = -ENODEV; 433 434 int phy_mode; 434 435 void *ret; 435 436 int rc; ··· 466 465 of_property_read_u32(np, "max-speed", &plat->max_speed); 467 466 468 467 plat->bus_id = of_alias_get_id(np, "ethernet"); 469 - if (plat->bus_id < 0) 470 - plat->bus_id = 0; 468 + if (plat->bus_id < 0) { 469 + if (bus_id < 0) 470 + bus_id = of_alias_get_highest_id("ethernet"); 471 + /* No ethernet alias found, init at -1 so first bus_id is 0 */ 472 + if (bus_id < 0) 473 + bus_id = -1; 474 + plat->bus_id = ++bus_id; 475 + } 471 476 472 477 /* Default to phy auto-detection */ 473 478 plat->phy_addr = -1;

+1 -1

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

··· 317 317 318 318 /* Calculate the clock domain crossing (CDC) error if necessary */ 319 319 priv->plat->cdc_error_adj = 0; 320 - if (priv->plat->has_gmac4 && priv->plat->clk_ptp_rate) 320 + if (priv->plat->has_gmac4) 321 321 priv->plat->cdc_error_adj = (2 * NSEC_PER_SEC) / priv->plat->clk_ptp_rate; 322 322 323 323 /* Update the ptp clock parameters based on feature discovery, when

+8

drivers/net/ethernet/ti/icssg/icssg_stats.c

··· 28 28 spin_lock(&prueth->stats_lock); 29 29 30 30 for (i = 0; i < ARRAY_SIZE(icssg_all_miig_stats); i++) { 31 + /* In MII mode TX lines are swapped inside ICSSG, so read Tx stats 32 + * from slice1 for port0 and slice0 for port1 to get accurate Tx 33 + * stats for a given port 34 + */ 35 + if (emac->phy_if == PHY_INTERFACE_MODE_MII && 36 + icssg_all_miig_stats[i].offset >= ICSSG_TX_PACKET_OFFSET && 37 + icssg_all_miig_stats[i].offset <= ICSSG_TX_BYTE_OFFSET) 38 + base = stats_base[slice ^ 1]; 31 39 regmap_read(prueth->miig_rt, 32 40 base + icssg_all_miig_stats[i].offset, 33 41 &val);

+1 -1

drivers/net/hyperv/netvsc_bpf.c

··· 183 183 xdp.command = XDP_SETUP_PROG; 184 184 xdp.prog = prog; 185 185 186 - ret = dev_xdp_propagate(vf_netdev, &xdp); 186 + ret = netif_xdp_propagate(vf_netdev, &xdp); 187 187 188 188 if (ret && prog) 189 189 bpf_prog_put(prog);

+2 -2

drivers/net/hyperv/netvsc_drv.c

··· 2462 2462 2463 2463 netdev_info(ndev, "VF unregistering: %s\n", vf_netdev->name); 2464 2464 2465 - netvsc_vf_setxdp(vf_netdev, NULL); 2466 - 2467 2465 reinit_completion(&net_device_ctx->vf_add); 2468 2466 netdev_rx_handler_unregister(vf_netdev); 2469 2467 netdev_upper_dev_unlink(vf_netdev, ndev); ··· 2629 2631 continue; 2630 2632 2631 2633 netvsc_prepare_bonding(vf_netdev); 2634 + netdev_lock_ops(vf_netdev); 2632 2635 netvsc_register_vf(vf_netdev, VF_REG_IN_PROBE); 2636 + netdev_unlock_ops(vf_netdev); 2633 2637 __netvsc_vf_setup(net, vf_netdev); 2634 2638 break; 2635 2639 }

+4 -4

drivers/net/ovpn/io.c

··· 134 134 135 135 rcu_read_lock(); 136 136 sock = rcu_dereference(peer->sock); 137 - if (sock && sock->sock->sk->sk_protocol == IPPROTO_UDP) 137 + if (sock && sock->sk->sk_protocol == IPPROTO_UDP) 138 138 /* check if this peer changed local or remote endpoint */ 139 139 ovpn_peer_endpoints_update(peer, skb); 140 140 rcu_read_unlock(); ··· 270 270 if (unlikely(!sock)) 271 271 goto err_unlock; 272 272 273 - switch (sock->sock->sk->sk_protocol) { 273 + switch (sock->sk->sk_protocol) { 274 274 case IPPROTO_UDP: 275 - ovpn_udp_send_skb(peer, sock->sock, skb); 275 + ovpn_udp_send_skb(peer, sock->sk, skb); 276 276 break; 277 277 case IPPROTO_TCP: 278 - ovpn_tcp_send_skb(peer, sock->sock, skb); 278 + ovpn_tcp_send_skb(peer, sock->sk, skb); 279 279 break; 280 280 default: 281 281 /* no transport configured yet */

+8 -8

drivers/net/ovpn/netlink.c

··· 501 501 /* when using a TCP socket the remote IP is not expected */ 502 502 rcu_read_lock(); 503 503 sock = rcu_dereference(peer->sock); 504 - if (sock && sock->sock->sk->sk_protocol == IPPROTO_TCP && 504 + if (sock && sock->sk->sk_protocol == IPPROTO_TCP && 505 505 (attrs[OVPN_A_PEER_REMOTE_IPV4] || 506 506 attrs[OVPN_A_PEER_REMOTE_IPV6])) { 507 507 rcu_read_unlock(); ··· 559 559 goto err_unlock; 560 560 } 561 561 562 - if (!net_eq(genl_info_net(info), sock_net(sock->sock->sk))) { 562 + if (!net_eq(genl_info_net(info), sock_net(sock->sk))) { 563 563 id = peernet2id_alloc(genl_info_net(info), 564 - sock_net(sock->sock->sk), 564 + sock_net(sock->sk), 565 565 GFP_ATOMIC); 566 566 if (nla_put_s32(skb, OVPN_A_PEER_SOCKET_NETNSID, id)) 567 567 goto err_unlock; 568 568 } 569 - local_port = inet_sk(sock->sock->sk)->inet_sport; 569 + local_port = inet_sk(sock->sk)->inet_sport; 570 570 rcu_read_unlock(); 571 571 572 572 if (nla_put_u32(skb, OVPN_A_PEER_ID, peer->id)) ··· 1153 1153 ret = -EINVAL; 1154 1154 goto err_unlock; 1155 1155 } 1156 - genlmsg_multicast_netns(&ovpn_nl_family, sock_net(sock->sock->sk), 1157 - msg, 0, OVPN_NLGRP_PEERS, GFP_ATOMIC); 1156 + genlmsg_multicast_netns(&ovpn_nl_family, sock_net(sock->sk), msg, 0, 1157 + OVPN_NLGRP_PEERS, GFP_ATOMIC); 1158 1158 rcu_read_unlock(); 1159 1159 1160 1160 return 0; ··· 1218 1218 ret = -EINVAL; 1219 1219 goto err_unlock; 1220 1220 } 1221 - genlmsg_multicast_netns(&ovpn_nl_family, sock_net(sock->sock->sk), 1222 - msg, 0, OVPN_NLGRP_PEERS, GFP_ATOMIC); 1221 + genlmsg_multicast_netns(&ovpn_nl_family, sock_net(sock->sk), msg, 0, 1222 + OVPN_NLGRP_PEERS, GFP_ATOMIC); 1223 1223 rcu_read_unlock(); 1224 1224 1225 1225 return 0;

+2 -2

drivers/net/ovpn/peer.c

··· 1145 1145 1146 1146 if (sk) { 1147 1147 ovpn_sock = rcu_access_pointer(peer->sock); 1148 - if (!ovpn_sock || ovpn_sock->sock->sk != sk) { 1148 + if (!ovpn_sock || ovpn_sock->sk != sk) { 1149 1149 spin_unlock_bh(&ovpn->lock); 1150 1150 ovpn_peer_put(peer); 1151 1151 return; ··· 1175 1175 if (sk) { 1176 1176 rcu_read_lock(); 1177 1177 ovpn_sock = rcu_dereference(peer->sock); 1178 - remove = ovpn_sock && ovpn_sock->sock->sk == sk; 1178 + remove = ovpn_sock && ovpn_sock->sk == sk; 1179 1179 rcu_read_unlock(); 1180 1180 } 1181 1181

+38 -30

drivers/net/ovpn/socket.c

··· 24 24 struct ovpn_socket *sock = container_of(kref, struct ovpn_socket, 25 25 refcount); 26 26 27 - if (sock->sock->sk->sk_protocol == IPPROTO_UDP) 27 + if (sock->sk->sk_protocol == IPPROTO_UDP) 28 28 ovpn_udp_socket_detach(sock); 29 - else if (sock->sock->sk->sk_protocol == IPPROTO_TCP) 29 + else if (sock->sk->sk_protocol == IPPROTO_TCP) 30 30 ovpn_tcp_socket_detach(sock); 31 31 } 32 32 ··· 75 75 if (!sock) 76 76 return; 77 77 78 - /* sanity check: we should not end up here if the socket 79 - * was already closed 80 - */ 81 - if (!sock->sock->sk) { 82 - DEBUG_NET_WARN_ON_ONCE(1); 83 - return; 84 - } 85 - 86 78 /* Drop the reference while holding the sock lock to avoid 87 79 * concurrent ovpn_socket_new call to mess up with a partially 88 80 * detached socket. ··· 82 90 * Holding the lock ensures that a socket with refcnt 0 is fully 83 91 * detached before it can be picked by a concurrent reader. 84 92 */ 85 - lock_sock(sock->sock->sk); 93 + lock_sock(sock->sk); 86 94 released = ovpn_socket_put(peer, sock); 87 - release_sock(sock->sock->sk); 95 + release_sock(sock->sk); 88 96 89 97 /* align all readers with sk_user_data being NULL */ 90 98 synchronize_rcu(); 91 99 92 100 /* following cleanup should happen with lock released */ 93 101 if (released) { 94 - if (sock->sock->sk->sk_protocol == IPPROTO_UDP) { 102 + if (sock->sk->sk_protocol == IPPROTO_UDP) { 95 103 netdev_put(sock->ovpn->dev, &sock->dev_tracker); 96 - } else if (sock->sock->sk->sk_protocol == IPPROTO_TCP) { 104 + } else if (sock->sk->sk_protocol == IPPROTO_TCP) { 97 105 /* wait for TCP jobs to terminate */ 98 106 ovpn_tcp_socket_wait_finish(sock); 99 107 ovpn_peer_put(sock->peer); 100 108 } 109 + /* drop reference acquired in ovpn_socket_new() */ 110 + sock_put(sock->sk); 101 111 /* we can call plain kfree() because we already waited one RCU 102 112 * period due to synchronize_rcu() 103 113 */ ··· 112 118 return kref_get_unless_zero(&sock->refcount); 113 119 } 114 120 115 - static int ovpn_socket_attach(struct ovpn_socket *sock, struct ovpn_peer *peer) 121 + static int ovpn_socket_attach(struct ovpn_socket *ovpn_sock, 122 + struct socket *sock, 123 + struct ovpn_peer *peer) 116 124 { 117 - if (sock->sock->sk->sk_protocol == IPPROTO_UDP) 118 - return ovpn_udp_socket_attach(sock, peer->ovpn); 119 - else if (sock->sock->sk->sk_protocol == IPPROTO_TCP) 120 - return ovpn_tcp_socket_attach(sock, peer); 125 + if (sock->sk->sk_protocol == IPPROTO_UDP) 126 + return ovpn_udp_socket_attach(ovpn_sock, sock, peer->ovpn); 127 + else if (sock->sk->sk_protocol == IPPROTO_TCP) 128 + return ovpn_tcp_socket_attach(ovpn_sock, peer); 121 129 122 130 return -EOPNOTSUPP; 123 131 } ··· 134 138 struct ovpn_socket *ovpn_socket_new(struct socket *sock, struct ovpn_peer *peer) 135 139 { 136 140 struct ovpn_socket *ovpn_sock; 141 + struct sock *sk = sock->sk; 137 142 int ret; 138 143 139 - lock_sock(sock->sk); 144 + lock_sock(sk); 140 145 141 146 /* a TCP socket can only be owned by a single peer, therefore there 142 147 * can't be any other user 143 148 */ 144 - if (sock->sk->sk_protocol == IPPROTO_TCP && sock->sk->sk_user_data) { 149 + if (sk->sk_protocol == IPPROTO_TCP && sk->sk_user_data) { 145 150 ovpn_sock = ERR_PTR(-EBUSY); 146 151 goto sock_release; 147 152 } ··· 150 153 /* a UDP socket can be shared across multiple peers, but we must make 151 154 * sure it is not owned by something else 152 155 */ 153 - if (sock->sk->sk_protocol == IPPROTO_UDP) { 154 - u8 type = READ_ONCE(udp_sk(sock->sk)->encap_type); 156 + if (sk->sk_protocol == IPPROTO_UDP) { 157 + u8 type = READ_ONCE(udp_sk(sk)->encap_type); 155 158 156 159 /* socket owned by other encapsulation module */ 157 160 if (type && type != UDP_ENCAP_OVPNINUDP) { ··· 160 163 } 161 164 162 165 rcu_read_lock(); 163 - ovpn_sock = rcu_dereference_sk_user_data(sock->sk); 166 + ovpn_sock = rcu_dereference_sk_user_data(sk); 164 167 if (ovpn_sock) { 165 168 /* socket owned by another ovpn instance, we can't use it */ 166 169 if (ovpn_sock->ovpn != peer->ovpn) { ··· 197 200 goto sock_release; 198 201 } 199 202 200 - ovpn_sock->sock = sock; 203 + ovpn_sock->sk = sk; 201 204 kref_init(&ovpn_sock->refcount); 202 205 203 - ret = ovpn_socket_attach(ovpn_sock, peer); 206 + /* the newly created ovpn_socket is holding reference to sk, 207 + * therefore we increase its refcounter. 208 + * 209 + * This ovpn_socket instance is referenced by all peers 210 + * using the same socket. 211 + * 212 + * ovpn_socket_release() will take care of dropping the reference. 213 + */ 214 + sock_hold(sk); 215 + 216 + ret = ovpn_socket_attach(ovpn_sock, sock, peer); 204 217 if (ret < 0) { 218 + sock_put(sk); 205 219 kfree(ovpn_sock); 206 220 ovpn_sock = ERR_PTR(ret); 207 221 goto sock_release; ··· 221 213 /* TCP sockets are per-peer, therefore they are linked to their unique 222 214 * peer 223 215 */ 224 - if (sock->sk->sk_protocol == IPPROTO_TCP) { 216 + if (sk->sk_protocol == IPPROTO_TCP) { 225 217 INIT_WORK(&ovpn_sock->tcp_tx_work, ovpn_tcp_tx_work); 226 218 ovpn_sock->peer = peer; 227 219 ovpn_peer_hold(peer); 228 - } else if (sock->sk->sk_protocol == IPPROTO_UDP) { 220 + } else if (sk->sk_protocol == IPPROTO_UDP) { 229 221 /* in UDP we only link the ovpn instance since the socket is 230 222 * shared among multiple peers 231 223 */ ··· 234 226 GFP_KERNEL); 235 227 } 236 228 237 - rcu_assign_sk_user_data(sock->sk, ovpn_sock); 229 + rcu_assign_sk_user_data(sk, ovpn_sock); 238 230 sock_release: 239 - release_sock(sock->sk); 231 + release_sock(sk); 240 232 return ovpn_sock; 241 233 }

+2 -2

drivers/net/ovpn/socket.h

··· 22 22 * @ovpn: ovpn instance owning this socket (UDP only) 23 23 * @dev_tracker: reference tracker for associated dev (UDP only) 24 24 * @peer: unique peer transmitting over this socket (TCP only) 25 - * @sock: the low level sock object 25 + * @sk: the low level sock object 26 26 * @refcount: amount of contexts currently referencing this object 27 27 * @work: member used to schedule release routine (it may block) 28 28 * @tcp_tx_work: work for deferring outgoing packet processing (TCP only) ··· 36 36 struct ovpn_peer *peer; 37 37 }; 38 38 39 - struct socket *sock; 39 + struct sock *sk; 40 40 struct kref refcount; 41 41 struct work_struct work; 42 42 struct work_struct tcp_tx_work;

+38 -35

drivers/net/ovpn/tcp.c

··· 124 124 * this peer, therefore ovpn_peer_hold() is not expected to fail 125 125 */ 126 126 if (WARN_ON(!ovpn_peer_hold(peer))) 127 - goto err; 127 + goto err_nopeer; 128 128 129 129 ovpn_recv(peer, skb); 130 130 return; 131 131 err: 132 + /* take reference for deferred peer deletion. should never fail */ 133 + if (WARN_ON(!ovpn_peer_hold(peer))) 134 + goto err_nopeer; 135 + schedule_work(&peer->tcp.defer_del_work); 132 136 dev_dstats_rx_dropped(peer->ovpn->dev); 137 + err_nopeer: 133 138 kfree_skb(skb); 134 - ovpn_peer_del(peer, OVPN_DEL_PEER_REASON_TRANSPORT_ERROR); 135 139 } 136 140 137 141 static int ovpn_tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, ··· 190 186 void ovpn_tcp_socket_detach(struct ovpn_socket *ovpn_sock) 191 187 { 192 188 struct ovpn_peer *peer = ovpn_sock->peer; 193 - struct socket *sock = ovpn_sock->sock; 189 + struct sock *sk = ovpn_sock->sk; 194 190 195 191 strp_stop(&peer->tcp.strp); 196 192 skb_queue_purge(&peer->tcp.user_queue); 197 193 198 194 /* restore CBs that were saved in ovpn_sock_set_tcp_cb() */ 199 - sock->sk->sk_data_ready = peer->tcp.sk_cb.sk_data_ready; 200 - sock->sk->sk_write_space = peer->tcp.sk_cb.sk_write_space; 201 - sock->sk->sk_prot = peer->tcp.sk_cb.prot; 202 - sock->sk->sk_socket->ops = peer->tcp.sk_cb.ops; 195 + sk->sk_data_ready = peer->tcp.sk_cb.sk_data_ready; 196 + sk->sk_write_space = peer->tcp.sk_cb.sk_write_space; 197 + sk->sk_prot = peer->tcp.sk_cb.prot; 198 + sk->sk_socket->ops = peer->tcp.sk_cb.ops; 203 199 204 - rcu_assign_sk_user_data(sock->sk, NULL); 200 + rcu_assign_sk_user_data(sk, NULL); 205 201 } 206 202 207 203 void ovpn_tcp_socket_wait_finish(struct ovpn_socket *sock) ··· 287 283 288 284 sock = container_of(work, struct ovpn_socket, tcp_tx_work); 289 285 290 - lock_sock(sock->sock->sk); 286 + lock_sock(sock->sk); 291 287 if (sock->peer) 292 - ovpn_tcp_send_sock(sock->peer, sock->sock->sk); 293 - release_sock(sock->sock->sk); 288 + ovpn_tcp_send_sock(sock->peer, sock->sk); 289 + release_sock(sock->sk); 294 290 } 295 291 296 292 static void ovpn_tcp_send_sock_skb(struct ovpn_peer *peer, struct sock *sk, ··· 311 307 ovpn_tcp_send_sock(peer, sk); 312 308 } 313 309 314 - void ovpn_tcp_send_skb(struct ovpn_peer *peer, struct socket *sock, 310 + void ovpn_tcp_send_skb(struct ovpn_peer *peer, struct sock *sk, 315 311 struct sk_buff *skb) 316 312 { 317 313 u16 len = skb->len; 318 314 319 315 *(__be16 *)__skb_push(skb, sizeof(u16)) = htons(len); 320 316 321 - spin_lock_nested(&sock->sk->sk_lock.slock, OVPN_TCP_DEPTH_NESTING); 322 - if (sock_owned_by_user(sock->sk)) { 317 + spin_lock_nested(&sk->sk_lock.slock, OVPN_TCP_DEPTH_NESTING); 318 + if (sock_owned_by_user(sk)) { 323 319 if (skb_queue_len(&peer->tcp.out_queue) >= 324 320 READ_ONCE(net_hotdata.max_backlog)) { 325 321 dev_dstats_tx_dropped(peer->ovpn->dev); ··· 328 324 } 329 325 __skb_queue_tail(&peer->tcp.out_queue, skb); 330 326 } else { 331 - ovpn_tcp_send_sock_skb(peer, sock->sk, skb); 327 + ovpn_tcp_send_sock_skb(peer, sk, skb); 332 328 } 333 329 unlock: 334 - spin_unlock(&sock->sk->sk_lock.slock); 330 + spin_unlock(&sk->sk_lock.slock); 335 331 } 336 332 337 333 static void ovpn_tcp_release(struct sock *sk) ··· 478 474 int ovpn_tcp_socket_attach(struct ovpn_socket *ovpn_sock, 479 475 struct ovpn_peer *peer) 480 476 { 481 - struct socket *sock = ovpn_sock->sock; 482 477 struct strp_callbacks cb = { 483 478 .rcv_msg = ovpn_tcp_rcv, 484 479 .parse_msg = ovpn_tcp_parse, ··· 485 482 int ret; 486 483 487 484 /* make sure no pre-existing encapsulation handler exists */ 488 - if (sock->sk->sk_user_data) 485 + if (ovpn_sock->sk->sk_user_data) 489 486 return -EBUSY; 490 487 491 488 /* only a fully connected socket is expected. Connection should be 492 489 * handled in userspace 493 490 */ 494 - if (sock->sk->sk_state != TCP_ESTABLISHED) { 491 + if (ovpn_sock->sk->sk_state != TCP_ESTABLISHED) { 495 492 net_err_ratelimited("%s: provided TCP socket is not in ESTABLISHED state: %d\n", 496 493 netdev_name(peer->ovpn->dev), 497 - sock->sk->sk_state); 494 + ovpn_sock->sk->sk_state); 498 495 return -EINVAL; 499 496 } 500 497 501 - ret = strp_init(&peer->tcp.strp, sock->sk, &cb); 498 + ret = strp_init(&peer->tcp.strp, ovpn_sock->sk, &cb); 502 499 if (ret < 0) { 503 500 DEBUG_NET_WARN_ON_ONCE(1); 504 501 return ret; ··· 506 503 507 504 INIT_WORK(&peer->tcp.defer_del_work, ovpn_tcp_peer_del_work); 508 505 509 - __sk_dst_reset(sock->sk); 506 + __sk_dst_reset(ovpn_sock->sk); 510 507 skb_queue_head_init(&peer->tcp.user_queue); 511 508 skb_queue_head_init(&peer->tcp.out_queue); 512 509 513 510 /* save current CBs so that they can be restored upon socket release */ 514 - peer->tcp.sk_cb.sk_data_ready = sock->sk->sk_data_ready; 515 - peer->tcp.sk_cb.sk_write_space = sock->sk->sk_write_space; 516 - peer->tcp.sk_cb.prot = sock->sk->sk_prot; 517 - peer->tcp.sk_cb.ops = sock->sk->sk_socket->ops; 511 + peer->tcp.sk_cb.sk_data_ready = ovpn_sock->sk->sk_data_ready; 512 + peer->tcp.sk_cb.sk_write_space = ovpn_sock->sk->sk_write_space; 513 + peer->tcp.sk_cb.prot = ovpn_sock->sk->sk_prot; 514 + peer->tcp.sk_cb.ops = ovpn_sock->sk->sk_socket->ops; 518 515 519 516 /* assign our static CBs and prot/ops */ 520 - sock->sk->sk_data_ready = ovpn_tcp_data_ready; 521 - sock->sk->sk_write_space = ovpn_tcp_write_space; 517 + ovpn_sock->sk->sk_data_ready = ovpn_tcp_data_ready; 518 + ovpn_sock->sk->sk_write_space = ovpn_tcp_write_space; 522 519 523 - if (sock->sk->sk_family == AF_INET) { 524 - sock->sk->sk_prot = &ovpn_tcp_prot; 525 - sock->sk->sk_socket->ops = &ovpn_tcp_ops; 520 + if (ovpn_sock->sk->sk_family == AF_INET) { 521 + ovpn_sock->sk->sk_prot = &ovpn_tcp_prot; 522 + ovpn_sock->sk->sk_socket->ops = &ovpn_tcp_ops; 526 523 } else { 527 - sock->sk->sk_prot = &ovpn_tcp6_prot; 528 - sock->sk->sk_socket->ops = &ovpn_tcp6_ops; 524 + ovpn_sock->sk->sk_prot = &ovpn_tcp6_prot; 525 + ovpn_sock->sk->sk_socket->ops = &ovpn_tcp6_ops; 529 526 } 530 527 531 528 /* avoid using task_frag */ 532 - sock->sk->sk_allocation = GFP_ATOMIC; 533 - sock->sk->sk_use_task_frag = false; 529 + ovpn_sock->sk->sk_allocation = GFP_ATOMIC; 530 + ovpn_sock->sk->sk_use_task_frag = false; 534 531 535 532 /* enqueue the RX worker */ 536 533 strp_check_rcv(&peer->tcp.strp);

+2 -1

drivers/net/ovpn/tcp.h

··· 30 30 * Required by the OpenVPN protocol in order to extract packets from 31 31 * the TCP stream on the receiver side. 32 32 */ 33 - void ovpn_tcp_send_skb(struct ovpn_peer *peer, struct socket *sock, struct sk_buff *skb); 33 + void ovpn_tcp_send_skb(struct ovpn_peer *peer, struct sock *sk, 34 + struct sk_buff *skb); 34 35 void ovpn_tcp_tx_work(struct work_struct *work); 35 36 36 37 #endif /* _NET_OVPN_TCP_H_ */

+22 -24

drivers/net/ovpn/udp.c

··· 43 43 return NULL; 44 44 45 45 /* make sure that sk matches our stored transport socket */ 46 - if (unlikely(!ovpn_sock->sock || sk != ovpn_sock->sock->sk)) 46 + if (unlikely(!ovpn_sock->sk || sk != ovpn_sock->sk)) 47 47 return NULL; 48 48 49 49 return ovpn_sock; ··· 335 335 /** 336 336 * ovpn_udp_send_skb - prepare skb and send it over via UDP 337 337 * @peer: the destination peer 338 - * @sock: the RCU protected peer socket 338 + * @sk: peer socket 339 339 * @skb: the packet to send 340 340 */ 341 - void ovpn_udp_send_skb(struct ovpn_peer *peer, struct socket *sock, 341 + void ovpn_udp_send_skb(struct ovpn_peer *peer, struct sock *sk, 342 342 struct sk_buff *skb) 343 343 { 344 - int ret = -1; 344 + int ret; 345 345 346 346 skb->dev = peer->ovpn->dev; 347 347 /* no checksum performed at this layer */ 348 348 skb->ip_summed = CHECKSUM_NONE; 349 349 350 - /* get socket info */ 351 - if (unlikely(!sock)) { 352 - net_warn_ratelimited("%s: no sock for remote peer %u\n", 353 - netdev_name(peer->ovpn->dev), peer->id); 354 - goto out; 355 - } 356 - 357 350 /* crypto layer -> transport (UDP) */ 358 - ret = ovpn_udp_output(peer, &peer->dst_cache, sock->sk, skb); 359 - out: 360 - if (unlikely(ret < 0)) { 351 + ret = ovpn_udp_output(peer, &peer->dst_cache, sk, skb); 352 + if (unlikely(ret < 0)) 361 353 kfree_skb(skb); 362 - return; 363 - } 364 354 } 365 355 366 356 static void ovpn_udp_encap_destroy(struct sock *sk) ··· 373 383 /** 374 384 * ovpn_udp_socket_attach - set udp-tunnel CBs on socket and link it to ovpn 375 385 * @ovpn_sock: socket to configure 386 + * @sock: the socket container to be passed to setup_udp_tunnel_sock() 376 387 * @ovpn: the openvp instance to link 377 388 * 378 389 * After invoking this function, the sock will be controlled by ovpn so that ··· 381 390 * 382 391 * Return: 0 on success or a negative error code otherwise 383 392 */ 384 - int ovpn_udp_socket_attach(struct ovpn_socket *ovpn_sock, 393 + int ovpn_udp_socket_attach(struct ovpn_socket *ovpn_sock, struct socket *sock, 385 394 struct ovpn_priv *ovpn) 386 395 { 387 396 struct udp_tunnel_sock_cfg cfg = { ··· 389 398 .encap_rcv = ovpn_udp_encap_recv, 390 399 .encap_destroy = ovpn_udp_encap_destroy, 391 400 }; 392 - struct socket *sock = ovpn_sock->sock; 393 401 struct ovpn_socket *old_data; 394 402 int ret; 395 403 396 404 /* make sure no pre-existing encapsulation handler exists */ 397 405 rcu_read_lock(); 398 - old_data = rcu_dereference_sk_user_data(sock->sk); 406 + old_data = rcu_dereference_sk_user_data(ovpn_sock->sk); 399 407 if (!old_data) { 400 408 /* socket is currently unused - we can take it */ 401 409 rcu_read_unlock(); 402 - setup_udp_tunnel_sock(sock_net(sock->sk), sock, &cfg); 410 + setup_udp_tunnel_sock(sock_net(ovpn_sock->sk), sock, &cfg); 403 411 return 0; 404 412 } 405 413 ··· 411 421 * Unlikely TCP, a single UDP socket can be used to talk to many remote 412 422 * hosts and therefore openvpn instantiates one only for all its peers 413 423 */ 414 - if ((READ_ONCE(udp_sk(sock->sk)->encap_type) == UDP_ENCAP_OVPNINUDP) && 424 + if ((READ_ONCE(udp_sk(ovpn_sock->sk)->encap_type) == UDP_ENCAP_OVPNINUDP) && 415 425 old_data->ovpn == ovpn) { 416 426 netdev_dbg(ovpn->dev, 417 427 "provided socket already owned by this interface\n"); ··· 432 442 */ 433 443 void ovpn_udp_socket_detach(struct ovpn_socket *ovpn_sock) 434 444 { 435 - struct udp_tunnel_sock_cfg cfg = { }; 445 + struct sock *sk = ovpn_sock->sk; 436 446 437 - setup_udp_tunnel_sock(sock_net(ovpn_sock->sock->sk), ovpn_sock->sock, 438 - &cfg); 447 + /* Re-enable multicast loopback */ 448 + inet_set_bit(MC_LOOP, sk); 449 + /* Disable CHECKSUM_UNNECESSARY to CHECKSUM_COMPLETE conversion */ 450 + inet_dec_convert_csum(sk); 451 + 452 + WRITE_ONCE(udp_sk(sk)->encap_type, 0); 453 + WRITE_ONCE(udp_sk(sk)->encap_rcv, NULL); 454 + WRITE_ONCE(udp_sk(sk)->encap_destroy, NULL); 455 + 456 + rcu_assign_sk_user_data(sk, NULL); 439 457 }

+2 -2

drivers/net/ovpn/udp.h

··· 15 15 struct ovpn_priv; 16 16 struct socket; 17 17 18 - int ovpn_udp_socket_attach(struct ovpn_socket *ovpn_sock, 18 + int ovpn_udp_socket_attach(struct ovpn_socket *ovpn_sock, struct socket *sock, 19 19 struct ovpn_priv *ovpn); 20 20 void ovpn_udp_socket_detach(struct ovpn_socket *ovpn_sock); 21 21 22 - void ovpn_udp_send_skb(struct ovpn_peer *peer, struct socket *sock, 22 + void ovpn_udp_send_skb(struct ovpn_peer *peer, struct sock *sk, 23 23 struct sk_buff *skb); 24 24 25 25 #endif /* _NET_OVPN_UDP_H_ */

+4 -4

drivers/net/usb/aqc111.c

··· 31 31 USB_RECIP_DEVICE, value, index, data, size); 32 32 33 33 if (unlikely(ret < size)) { 34 - ret = ret < 0 ? ret : -ENODATA; 35 - 36 34 netdev_warn(dev->net, 37 35 "Failed to read(0x%x) reg index 0x%04x: %d\n", 38 36 cmd, index, ret); 37 + 38 + ret = ret < 0 ? ret : -ENODATA; 39 39 } 40 40 41 41 return ret; ··· 50 50 USB_RECIP_DEVICE, value, index, data, size); 51 51 52 52 if (unlikely(ret < size)) { 53 - ret = ret < 0 ? ret : -ENODATA; 54 - 55 53 netdev_warn(dev->net, 56 54 "Failed to read(0x%x) reg index 0x%04x: %d\n", 57 55 cmd, index, ret); 56 + 57 + ret = ret < 0 ? ret : -ENODATA; 58 58 } 59 59 60 60 return ret;

+5 -2

drivers/net/usb/ch9200.c

··· 178 178 { 179 179 struct usbnet *dev = netdev_priv(netdev); 180 180 unsigned char buff[2]; 181 + int ret; 181 182 182 183 netdev_dbg(netdev, "%s phy_id:%02x loc:%02x\n", 183 184 __func__, phy_id, loc); ··· 186 185 if (phy_id != 0) 187 186 return -ENODEV; 188 187 189 - control_read(dev, REQUEST_READ, 0, loc * 2, buff, 0x02, 190 - CONTROL_TIMEOUT_MS); 188 + ret = control_read(dev, REQUEST_READ, 0, loc * 2, buff, 0x02, 189 + CONTROL_TIMEOUT_MS); 190 + if (ret < 0) 191 + return ret; 191 192 192 193 return (buff[0] | buff[1] << 8); 193 194 }

+26

drivers/net/vmxnet3/vmxnet3_drv.c

··· 1572 1572 return (hlen + (hdr.tcp->doff << 2)); 1573 1573 } 1574 1574 1575 + static void 1576 + vmxnet3_lro_tunnel(struct sk_buff *skb, __be16 ip_proto) 1577 + { 1578 + struct udphdr *uh = NULL; 1579 + 1580 + if (ip_proto == htons(ETH_P_IP)) { 1581 + struct iphdr *iph = (struct iphdr *)skb->data; 1582 + 1583 + if (iph->protocol == IPPROTO_UDP) 1584 + uh = (struct udphdr *)(iph + 1); 1585 + } else { 1586 + struct ipv6hdr *iph = (struct ipv6hdr *)skb->data; 1587 + 1588 + if (iph->nexthdr == IPPROTO_UDP) 1589 + uh = (struct udphdr *)(iph + 1); 1590 + } 1591 + if (uh) { 1592 + if (uh->check) 1593 + skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM; 1594 + else 1595 + skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL; 1596 + } 1597 + } 1598 + 1575 1599 static int 1576 1600 vmxnet3_rq_rx_complete(struct vmxnet3_rx_queue *rq, 1577 1601 struct vmxnet3_adapter *adapter, int quota) ··· 1909 1885 if (segCnt != 0 && mss != 0) { 1910 1886 skb_shinfo(skb)->gso_type = rcd->v4 ? 1911 1887 SKB_GSO_TCPV4 : SKB_GSO_TCPV6; 1888 + if (encap_lro) 1889 + vmxnet3_lro_tunnel(skb, skb->protocol); 1912 1890 skb_shinfo(skb)->gso_size = mss; 1913 1891 skb_shinfo(skb)->gso_segs = segCnt; 1914 1892 } else if ((segCnt != 0 || skb->len > mtu) && !encap_lro) {

+1

drivers/net/wireguard/device.c

··· 366 366 if (ret < 0) 367 367 goto err_free_handshake_queue; 368 368 369 + dev_set_threaded(dev, true); 369 370 ret = register_netdevice(dev); 370 371 if (ret < 0) 371 372 goto err_uninit_ratelimiter;

+4 -4

drivers/net/wireless/intel/iwlwifi/mld/fw.c

··· 349 349 if (ret) 350 350 goto err; 351 351 352 - ret = iwl_mld_init_mcc(mld); 353 - if (ret) 354 - goto err; 355 - 356 352 mld->fw_status.running = true; 357 353 358 354 return 0; ··· 539 543 IWL_DEBUG_INFO(mld, "uCode started.\n"); 540 544 541 545 ret = iwl_mld_config_fw(mld); 546 + if (ret) 547 + goto error; 548 + 549 + ret = iwl_mld_init_mcc(mld); 542 550 if (ret) 543 551 goto error; 544 552

+2 -1

drivers/net/wireless/intel/iwlwifi/mld/mld.c

··· 653 653 * It might not actually be true that we'll restart, but the 654 654 * setting doesn't matter if we're going to be unbound either. 655 655 */ 656 - if (type != IWL_ERR_TYPE_RESET_HS_TIMEOUT) 656 + if (type != IWL_ERR_TYPE_RESET_HS_TIMEOUT && 657 + mld->fw_status.running) 657 658 mld->fw_status.in_hw_restart = true; 658 659 } 659 660

+2 -2

drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c

··· 6360 6360 (struct iwl_mvm_internal_rxq_notif *)cmd->payload; 6361 6361 struct iwl_host_cmd hcmd = { 6362 6362 .id = WIDE_ID(DATA_PATH_GROUP, TRIGGER_RX_QUEUES_NOTIF_CMD), 6363 - .data[0] = &cmd, 6364 - .len[0] = sizeof(cmd), 6363 + .data[0] = cmd, 6364 + .len[0] = __struct_size(cmd), 6365 6365 .data[1] = data, 6366 6366 .len[1] = size, 6367 6367 .flags = CMD_SEND_IN_RFKILL | (sync ? 0 : CMD_ASYNC),

+1 -1

drivers/net/wireless/intel/iwlwifi/pcie/trans-gen2.c

··· 125 125 reset_done = 126 126 inta_hw & MSIX_HW_INT_CAUSES_REG_RESET_DONE; 127 127 } else { 128 - inta_hw = iwl_read32(trans, CSR_INT_MASK); 128 + inta_hw = iwl_read32(trans, CSR_INT); 129 129 reset_done = inta_hw & CSR_INT_BIT_RESET_DONE; 130 130 } 131 131

+3 -6

drivers/net/wwan/mhi_wwan_mbim.c

··· 550 550 struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev); 551 551 struct mhi_mbim_context *mbim = ctxt; 552 552 553 - link->session = if_id; 554 553 link->mbim = mbim; 554 + link->session = mhi_mbim_get_link_mux_id(link->mbim->mdev->mhi_cntrl) + if_id; 555 555 link->ndev = ndev; 556 556 u64_stats_init(&link->rx_syncp); 557 557 u64_stats_init(&link->tx_syncp); ··· 607 607 { 608 608 struct mhi_controller *cntrl = mhi_dev->mhi_cntrl; 609 609 struct mhi_mbim_context *mbim; 610 - int err, link_id; 610 + int err; 611 611 612 612 mbim = devm_kzalloc(&mhi_dev->dev, sizeof(*mbim), GFP_KERNEL); 613 613 if (!mbim) ··· 628 628 /* Number of transfer descriptors determines size of the queue */ 629 629 mbim->rx_queue_sz = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE); 630 630 631 - /* Get the corresponding mux_id from mhi */ 632 - link_id = mhi_mbim_get_link_mux_id(cntrl); 633 - 634 631 /* Register wwan link ops with MHI controller representing WWAN instance */ 635 - return wwan_register_ops(&cntrl->mhi_dev->dev, &mhi_mbim_wwan_ops, mbim, link_id); 632 + return wwan_register_ops(&cntrl->mhi_dev->dev, &mhi_mbim_wwan_ops, mbim, 0); 636 633 } 637 634 638 635 static void mhi_mbim_remove(struct mhi_device *mhi_dev)

+6 -5

drivers/net/wwan/t7xx/t7xx_netdev.c

··· 302 302 ccmni->ctlb = ctlb; 303 303 ccmni->dev = dev; 304 304 atomic_set(&ccmni->usage, 0); 305 - ctlb->ccmni_inst[if_id] = ccmni; 305 + WRITE_ONCE(ctlb->ccmni_inst[if_id], ccmni); 306 306 307 307 ret = register_netdevice(dev); 308 308 if (ret) ··· 324 324 if (WARN_ON(ctlb->ccmni_inst[if_id] != ccmni)) 325 325 return; 326 326 327 + WRITE_ONCE(ctlb->ccmni_inst[if_id], NULL); 327 328 unregister_netdevice(dev); 328 329 } 329 330 ··· 420 419 421 420 skb_cb = T7XX_SKB_CB(skb); 422 421 netif_id = skb_cb->netif_idx; 423 - ccmni = ccmni_ctlb->ccmni_inst[netif_id]; 422 + ccmni = READ_ONCE(ccmni_ctlb->ccmni_inst[netif_id]); 424 423 if (!ccmni) { 425 424 dev_kfree_skb(skb); 426 425 return; ··· 442 441 443 442 static void t7xx_ccmni_queue_tx_irq_notify(struct t7xx_ccmni_ctrl *ctlb, int qno) 444 443 { 445 - struct t7xx_ccmni *ccmni = ctlb->ccmni_inst[0]; 444 + struct t7xx_ccmni *ccmni = READ_ONCE(ctlb->ccmni_inst[0]); 446 445 struct netdev_queue *net_queue; 447 446 448 447 if (netif_running(ccmni->dev) && atomic_read(&ccmni->usage) > 0) { ··· 454 453 455 454 static void t7xx_ccmni_queue_tx_full_notify(struct t7xx_ccmni_ctrl *ctlb, int qno) 456 455 { 457 - struct t7xx_ccmni *ccmni = ctlb->ccmni_inst[0]; 456 + struct t7xx_ccmni *ccmni = READ_ONCE(ctlb->ccmni_inst[0]); 458 457 struct netdev_queue *net_queue; 459 458 460 459 if (atomic_read(&ccmni->usage) > 0) { ··· 472 471 if (ctlb->md_sta != MD_STATE_READY) 473 472 return; 474 473 475 - if (!ctlb->ccmni_inst[0]) { 474 + if (!READ_ONCE(ctlb->ccmni_inst[0])) { 476 475 dev_warn(&t7xx_dev->pdev->dev, "No netdev registered yet\n"); 477 476 return; 478 477 }

+69 -10

include/linux/ieee80211.h

··· 111 111 112 112 /* bits unique to S1G beacon */ 113 113 #define IEEE80211_S1G_BCN_NEXT_TBTT 0x100 114 + #define IEEE80211_S1G_BCN_CSSID 0x200 115 + #define IEEE80211_S1G_BCN_ANO 0x400 114 116 115 117 /* see 802.11ah-2016 9.9 NDP CMAC frames */ 116 118 #define IEEE80211_S1G_1MHZ_NDP_BITS 25 ··· 154 152 #define IEEE80211_NDP_2M_PREQ_RTYPE_S 36 155 153 156 154 #define IEEE80211_ANO_NETTYPE_WILD 15 157 - 158 - /* bits unique to S1G beacon */ 159 - #define IEEE80211_S1G_BCN_NEXT_TBTT 0x100 160 155 161 156 /* control extension - for IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTL_EXT */ 162 157 #define IEEE80211_CTL_EXT_POLL 0x2000 ··· 624 625 return (fc & cpu_to_le16(IEEE80211_FCTL_FTYPE | 625 626 IEEE80211_FCTL_STYPE)) == 626 627 cpu_to_le16(IEEE80211_FTYPE_EXT | IEEE80211_STYPE_S1G_BEACON); 628 + } 629 + 630 + /** 631 + * ieee80211_s1g_has_next_tbtt - check if IEEE80211_S1G_BCN_NEXT_TBTT 632 + * @fc: frame control bytes in little-endian byteorder 633 + * Return: whether or not the frame contains the variable-length 634 + * next TBTT field 635 + */ 636 + static inline bool ieee80211_s1g_has_next_tbtt(__le16 fc) 637 + { 638 + return ieee80211_is_s1g_beacon(fc) && 639 + (fc & cpu_to_le16(IEEE80211_S1G_BCN_NEXT_TBTT)); 640 + } 641 + 642 + /** 643 + * ieee80211_s1g_has_ano - check if IEEE80211_S1G_BCN_ANO 644 + * @fc: frame control bytes in little-endian byteorder 645 + * Return: whether or not the frame contains the variable-length 646 + * ANO field 647 + */ 648 + static inline bool ieee80211_s1g_has_ano(__le16 fc) 649 + { 650 + return ieee80211_is_s1g_beacon(fc) && 651 + (fc & cpu_to_le16(IEEE80211_S1G_BCN_ANO)); 652 + } 653 + 654 + /** 655 + * ieee80211_s1g_has_cssid - check if IEEE80211_S1G_BCN_CSSID 656 + * @fc: frame control bytes in little-endian byteorder 657 + * Return: whether or not the frame contains the variable-length 658 + * compressed SSID field 659 + */ 660 + static inline bool ieee80211_s1g_has_cssid(__le16 fc) 661 + { 662 + return ieee80211_is_s1g_beacon(fc) && 663 + (fc & cpu_to_le16(IEEE80211_S1G_BCN_CSSID)); 627 664 } 628 665 629 666 /** ··· 1280 1245 u8 change_seq; 1281 1246 u8 variable[0]; 1282 1247 } __packed s1g_beacon; 1283 - struct { 1284 - u8 sa[ETH_ALEN]; 1285 - __le32 timestamp; 1286 - u8 change_seq; 1287 - u8 next_tbtt[3]; 1288 - u8 variable[0]; 1289 - } __packed s1g_short_beacon; 1290 1248 } u; 1291 1249 } __packed __aligned(2); 1250 + 1251 + /** 1252 + * ieee80211_s1g_optional_len - determine length of optional S1G beacon fields 1253 + * @fc: frame control bytes in little-endian byteorder 1254 + * Return: total length in bytes of the optional fixed-length fields 1255 + * 1256 + * S1G beacons may contain up to three optional fixed-length fields that 1257 + * precede the variable-length elements. Whether these fields are present 1258 + * is indicated by flags in the frame control field. 1259 + * 1260 + * From IEEE 802.11-2024 section 9.3.4.3: 1261 + * - Next TBTT field may be 0 or 3 bytes 1262 + * - Short SSID field may be 0 or 4 bytes 1263 + * - Access Network Options (ANO) field may be 0 or 1 byte 1264 + */ 1265 + static inline size_t 1266 + ieee80211_s1g_optional_len(__le16 fc) 1267 + { 1268 + size_t len = 0; 1269 + 1270 + if (ieee80211_s1g_has_next_tbtt(fc)) 1271 + len += 3; 1272 + 1273 + if (ieee80211_s1g_has_cssid(fc)) 1274 + len += 4; 1275 + 1276 + if (ieee80211_s1g_has_ano(fc)) 1277 + len += 1; 1278 + 1279 + return len; 1280 + } 1292 1281 1293 1282 #define IEEE80211_TWT_CONTROL_NDP BIT(0) 1294 1283 #define IEEE80211_TWT_CONTROL_RESP_MODE BIT(1)

+1 -1

include/net/checksum.h

··· 152 152 const __be32 *from, const __be32 *to, 153 153 bool pseudohdr); 154 154 void inet_proto_csum_replace_by_diff(__sum16 *sum, struct sk_buff *skb, 155 - __wsum diff, bool pseudohdr); 155 + __wsum diff, bool pseudohdr, bool ipv6); 156 156 157 157 static __always_inline 158 158 void inet_proto_csum_replace2(__sum16 *sum, struct sk_buff *skb,

+2

include/uapi/linux/bpf.h

··· 2056 2056 * for updates resulting in a null checksum the value is set to 2057 2057 * **CSUM_MANGLED_0** instead. Flag **BPF_F_PSEUDO_HDR** indicates 2058 2058 * that the modified header field is part of the pseudo-header. 2059 + * Flag **BPF_F_IPV6** should be set for IPv6 packets. 2059 2060 * 2060 2061 * This helper works in combination with **bpf_csum_diff**\ (), 2061 2062 * which does not update the checksum in-place, but offers more ··· 6073 6072 BPF_F_PSEUDO_HDR = (1ULL << 4), 6074 6073 BPF_F_MARK_MANGLED_0 = (1ULL << 5), 6075 6074 BPF_F_MARK_ENFORCE = (1ULL << 6), 6075 + BPF_F_IPV6 = (1ULL << 7), 6076 6076 }; 6077 6077 6078 6078 /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */

+2 -1

net/bluetooth/l2cap_core.c

··· 4870 4870 4871 4871 if (!smp_sufficient_security(conn->hcon, pchan->sec_level, 4872 4872 SMP_ALLOW_STK)) { 4873 - result = L2CAP_CR_LE_AUTHENTICATION; 4873 + result = pchan->sec_level == BT_SECURITY_MEDIUM ? 4874 + L2CAP_CR_LE_ENCRYPTION : L2CAP_CR_LE_AUTHENTICATION; 4874 4875 chan = NULL; 4875 4876 goto response_unlock; 4876 4877 }

+2 -1

net/bluetooth/mgmt.c

··· 2566 2566 struct mgmt_pending_cmd *cmd; 2567 2567 int err; 2568 2568 2569 - if (len < sizeof(*cp)) 2569 + if (len != (offsetof(struct mgmt_cp_hci_cmd_sync, params) + 2570 + le16_to_cpu(cp->params_len))) 2570 2571 return mgmt_cmd_status(sk, hdev->id, MGMT_OP_HCI_CMD_SYNC, 2571 2572 MGMT_STATUS_INVALID_PARAMS); 2572 2573

+2 -1

net/core/dev.c

··· 9968 9968 9969 9969 return dev->netdev_ops->ndo_bpf(dev, bpf); 9970 9970 } 9971 + EXPORT_SYMBOL_GPL(netif_xdp_propagate); 9971 9972 9972 9973 u32 dev_xdp_prog_id(struct net_device *dev, enum bpf_xdp_mode mode) 9973 9974 { ··· 10499 10498 static bool from_cleanup_net(void) 10500 10499 { 10501 10500 #ifdef CONFIG_NET_NS 10502 - return current == cleanup_net_task; 10501 + return current == READ_ONCE(cleanup_net_task); 10503 10502 #else 10504 10503 return false; 10505 10504 #endif

+2 -1

net/core/devmem.h

··· 170 170 } 171 171 172 172 static inline struct net_devmem_dmabuf_binding * 173 - net_devmem_bind_dmabuf(struct net_device *dev, unsigned int dmabuf_fd, 173 + net_devmem_bind_dmabuf(struct net_device *dev, 174 174 enum dma_data_direction direction, 175 + unsigned int dmabuf_fd, 175 176 struct netdev_nl_sock *priv, 176 177 struct netlink_ext_ack *extack) 177 178 {

+3 -2

net/core/filter.c

··· 1968 1968 bool is_pseudo = flags & BPF_F_PSEUDO_HDR; 1969 1969 bool is_mmzero = flags & BPF_F_MARK_MANGLED_0; 1970 1970 bool do_mforce = flags & BPF_F_MARK_ENFORCE; 1971 + bool is_ipv6 = flags & BPF_F_IPV6; 1971 1972 __sum16 *ptr; 1972 1973 1973 1974 if (unlikely(flags & ~(BPF_F_MARK_MANGLED_0 | BPF_F_MARK_ENFORCE | 1974 - BPF_F_PSEUDO_HDR | BPF_F_HDR_FIELD_MASK))) 1975 + BPF_F_PSEUDO_HDR | BPF_F_HDR_FIELD_MASK | BPF_F_IPV6))) 1975 1976 return -EINVAL; 1976 1977 if (unlikely(offset > 0xffff || offset & 1)) 1977 1978 return -EFAULT; ··· 1988 1987 if (unlikely(from != 0)) 1989 1988 return -EINVAL; 1990 1989 1991 - inet_proto_csum_replace_by_diff(ptr, skb, to, is_pseudo); 1990 + inet_proto_csum_replace_by_diff(ptr, skb, to, is_pseudo, is_ipv6); 1992 1991 break; 1993 1992 case 2: 1994 1993 inet_proto_csum_replace2(ptr, skb, from, to, is_pseudo);

+2 -2

net/core/net_namespace.c

··· 654 654 struct net *net, *tmp, *last; 655 655 LIST_HEAD(net_exit_list); 656 656 657 - cleanup_net_task = current; 657 + WRITE_ONCE(cleanup_net_task, current); 658 658 659 659 /* Atomically snapshot the list of namespaces to cleanup */ 660 660 net_kill_list = llist_del_all(&cleanup_list); ··· 704 704 put_user_ns(net->user_ns); 705 705 net_passive_dec(net); 706 706 } 707 - cleanup_net_task = NULL; 707 + WRITE_ONCE(cleanup_net_task, NULL); 708 708 } 709 709 710 710 /**

+14 -13

net/core/page_pool.c

··· 153 153 EXPORT_SYMBOL(page_pool_ethtool_stats_get); 154 154 155 155 #else 156 - #define alloc_stat_inc(pool, __stat) 157 - #define recycle_stat_inc(pool, __stat) 158 - #define recycle_stat_add(pool, __stat, val) 156 + #define alloc_stat_inc(...) do { } while (0) 157 + #define recycle_stat_inc(...) do { } while (0) 158 + #define recycle_stat_add(...) do { } while (0) 159 159 #endif 160 160 161 161 static bool page_pool_producer_lock(struct page_pool *pool) ··· 741 741 742 742 static bool page_pool_recycle_in_ring(struct page_pool *pool, netmem_ref netmem) 743 743 { 744 - int ret; 744 + bool in_softirq, ret; 745 + 745 746 /* BH protection not needed if current is softirq */ 746 - if (in_softirq()) 747 - ret = ptr_ring_produce(&pool->ring, (__force void *)netmem); 748 - else 749 - ret = ptr_ring_produce_bh(&pool->ring, (__force void *)netmem); 750 - 751 - if (!ret) { 747 + in_softirq = page_pool_producer_lock(pool); 748 + ret = !__ptr_ring_produce(&pool->ring, (__force void *)netmem); 749 + if (ret) 752 750 recycle_stat_inc(pool, ring); 753 - return true; 754 - } 751 + page_pool_producer_unlock(pool, in_softirq); 755 752 756 - return false; 753 + return ret; 757 754 } 758 755 759 756 /* Only allow direct recycling in special circumstances, into the ··· 1147 1150 1148 1151 static int page_pool_release(struct page_pool *pool) 1149 1152 { 1153 + bool in_softirq; 1150 1154 int inflight; 1151 1155 1152 1156 page_pool_scrub(pool); 1153 1157 inflight = page_pool_inflight(pool, true); 1158 + /* Acquire producer lock to make sure producers have exited. */ 1159 + in_softirq = page_pool_producer_lock(pool); 1160 + page_pool_producer_unlock(pool, in_softirq); 1154 1161 if (!inflight) 1155 1162 __page_pool_destroy(pool); 1156 1163

+1 -1

net/core/rtnetlink.c

··· 3671 3671 if (tb[IFLA_LINKMODE]) 3672 3672 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]); 3673 3673 if (tb[IFLA_GROUP]) 3674 - dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 3674 + netif_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 3675 3675 if (tb[IFLA_GSO_MAX_SIZE]) 3676 3676 netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE])); 3677 3677 if (tb[IFLA_GSO_MAX_SEGS])

+4 -4

net/core/sock.c

··· 3284 3284 { 3285 3285 struct mem_cgroup *memcg = mem_cgroup_sockets_enabled ? sk->sk_memcg : NULL; 3286 3286 struct proto *prot = sk->sk_prot; 3287 - bool charged = false; 3287 + bool charged = true; 3288 3288 long allocated; 3289 3289 3290 3290 sk_memory_allocated_add(sk, amt); 3291 3291 allocated = sk_memory_allocated(sk); 3292 3292 3293 3293 if (memcg) { 3294 - if (!mem_cgroup_charge_skmem(memcg, amt, gfp_memcg_charge())) 3294 + charged = mem_cgroup_charge_skmem(memcg, amt, gfp_memcg_charge()); 3295 + if (!charged) 3295 3296 goto suppress_allocation; 3296 - charged = true; 3297 3297 } 3298 3298 3299 3299 /* Under limit. */ ··· 3378 3378 3379 3379 sk_memory_allocated_sub(sk, amt); 3380 3380 3381 - if (charged) 3381 + if (memcg && charged) 3382 3382 mem_cgroup_uncharge_skmem(memcg, amt); 3383 3383 3384 3384 return 0;

+2 -2

net/core/utils.c

··· 473 473 EXPORT_SYMBOL(inet_proto_csum_replace16); 474 474 475 475 void inet_proto_csum_replace_by_diff(__sum16 *sum, struct sk_buff *skb, 476 - __wsum diff, bool pseudohdr) 476 + __wsum diff, bool pseudohdr, bool ipv6) 477 477 { 478 478 if (skb->ip_summed != CHECKSUM_PARTIAL) { 479 479 csum_replace_by_diff(sum, diff); 480 - if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr) 480 + if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr && !ipv6) 481 481 skb->csum = ~csum_sub(diff, skb->csum); 482 482 } else if (pseudohdr) { 483 483 *sum = ~csum_fold(csum_add(diff, csum_unfold(*sum)));

+1 -1

net/dsa/tag_brcm.c

··· 257 257 int source_port; 258 258 u8 *brcm_tag; 259 259 260 - if (unlikely(!pskb_may_pull(skb, BRCM_LEG_PORT_ID))) 260 + if (unlikely(!pskb_may_pull(skb, BRCM_LEG_TAG_LEN + VLAN_HLEN))) 261 261 return NULL; 262 262 263 263 brcm_tag = dsa_etype_header_pos_rx(skb);

+5

net/ipv4/udp_offload.c

··· 495 495 bool copy_dtor; 496 496 __sum16 check; 497 497 __be16 newlen; 498 + int ret = 0; 498 499 499 500 mss = skb_shinfo(gso_skb)->gso_size; 500 501 if (gso_skb->len <= sizeof(*uh) + mss) ··· 523 522 /* Detect modified geometry and pass those to skb_segment. */ 524 523 if (skb_pagelen(gso_skb) - sizeof(*uh) == skb_shinfo(gso_skb)->gso_size) 525 524 return __udp_gso_segment_list(gso_skb, features, is_ipv6); 525 + 526 + ret = __skb_linearize(gso_skb); 527 + if (ret) 528 + return ERR_PTR(ret); 526 529 527 530 /* Setup csum, as fraglist skips this in udp4_gro_receive. */ 528 531 gso_skb->csum_start = skb_transport_header(gso_skb) - gso_skb->head;

+3 -3

net/ipv6/ila/ila_common.c

··· 86 86 87 87 diff = get_csum_diff(ip6h, p); 88 88 inet_proto_csum_replace_by_diff(&th->check, skb, 89 - diff, true); 89 + diff, true, true); 90 90 } 91 91 break; 92 92 case NEXTHDR_UDP: ··· 97 97 if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) { 98 98 diff = get_csum_diff(ip6h, p); 99 99 inet_proto_csum_replace_by_diff(&uh->check, skb, 100 - diff, true); 100 + diff, true, true); 101 101 if (!uh->check) 102 102 uh->check = CSUM_MANGLED_0; 103 103 } ··· 111 111 112 112 diff = get_csum_diff(ip6h, p); 113 113 inet_proto_csum_replace_by_diff(&ih->icmp6_cksum, skb, 114 - diff, true); 114 + diff, true, true); 115 115 } 116 116 break; 117 117 }

+2 -4

net/ipv6/seg6_local.c

··· 1644 1644 [SEG6_LOCAL_SRH] = { .type = NLA_BINARY }, 1645 1645 [SEG6_LOCAL_TABLE] = { .type = NLA_U32 }, 1646 1646 [SEG6_LOCAL_VRFTABLE] = { .type = NLA_U32 }, 1647 - [SEG6_LOCAL_NH4] = { .type = NLA_BINARY, 1648 - .len = sizeof(struct in_addr) }, 1649 - [SEG6_LOCAL_NH6] = { .type = NLA_BINARY, 1650 - .len = sizeof(struct in6_addr) }, 1647 + [SEG6_LOCAL_NH4] = NLA_POLICY_EXACT_LEN(sizeof(struct in_addr)), 1648 + [SEG6_LOCAL_NH6] = NLA_POLICY_EXACT_LEN(sizeof(struct in6_addr)), 1651 1649 [SEG6_LOCAL_IIF] = { .type = NLA_U32 }, 1652 1650 [SEG6_LOCAL_OIF] = { .type = NLA_U32 }, 1653 1651 [SEG6_LOCAL_BPF] = { .type = NLA_NESTED },

+2 -5

net/mac80211/mlme.c

··· 7220 7220 bssid = ieee80211_get_bssid(hdr, len, sdata->vif.type); 7221 7221 if (ieee80211_is_s1g_beacon(mgmt->frame_control)) { 7222 7222 struct ieee80211_ext *ext = (void *) mgmt; 7223 - 7224 - if (ieee80211_is_s1g_short_beacon(ext->frame_control)) 7225 - variable = ext->u.s1g_short_beacon.variable; 7226 - else 7227 - variable = ext->u.s1g_beacon.variable; 7223 + variable = ext->u.s1g_beacon.variable + 7224 + ieee80211_s1g_optional_len(ext->frame_control); 7228 7225 } 7229 7226 7230 7227 baselen = (u8 *) variable - (u8 *) mgmt;

+5 -6

net/mac80211/scan.c

··· 276 276 struct ieee80211_mgmt *mgmt = (void *)skb->data; 277 277 struct ieee80211_bss *bss; 278 278 struct ieee80211_channel *channel; 279 + struct ieee80211_ext *ext; 279 280 size_t min_hdr_len = offsetof(struct ieee80211_mgmt, 280 281 u.probe_resp.variable); 281 282 ··· 286 285 return; 287 286 288 287 if (ieee80211_is_s1g_beacon(mgmt->frame_control)) { 289 - if (ieee80211_is_s1g_short_beacon(mgmt->frame_control)) 290 - min_hdr_len = offsetof(struct ieee80211_ext, 291 - u.s1g_short_beacon.variable); 292 - else 293 - min_hdr_len = offsetof(struct ieee80211_ext, 294 - u.s1g_beacon); 288 + ext = (struct ieee80211_ext *)mgmt; 289 + min_hdr_len = 290 + offsetof(struct ieee80211_ext, u.s1g_beacon.variable) + 291 + ieee80211_s1g_optional_len(ext->frame_control); 295 292 } 296 293 297 294 if (skb->len < min_hdr_len)

+9 -3

net/netfilter/nf_nat_core.c

··· 248 248 nf_nat_used_tuple_new(const struct nf_conntrack_tuple *tuple, 249 249 const struct nf_conn *ignored_ct) 250 250 { 251 - static const unsigned long uses_nat = IPS_NAT_MASK | IPS_SEQ_ADJUST_BIT; 251 + static const unsigned long uses_nat = IPS_NAT_MASK | IPS_SEQ_ADJUST; 252 252 const struct nf_conntrack_tuple_hash *thash; 253 253 const struct nf_conntrack_zone *zone; 254 254 struct nf_conn *ct; ··· 287 287 zone = nf_ct_zone(ignored_ct); 288 288 289 289 thash = nf_conntrack_find_get(net, zone, tuple); 290 - if (unlikely(!thash)) /* clashing entry went away */ 291 - return false; 290 + if (unlikely(!thash)) { 291 + struct nf_conntrack_tuple reply; 292 + 293 + nf_ct_invert_tuple(&reply, tuple); 294 + thash = nf_conntrack_find_get(net, zone, &reply); 295 + if (!thash) /* clashing entry went away */ 296 + return false; 297 + } 292 298 293 299 ct = nf_ct_tuplehash_to_ctrack(thash); 294 300

+20 -1

net/netfilter/nft_set_pipapo_avx2.c

··· 1114 1114 } 1115 1115 1116 1116 /** 1117 + * pipapo_resmap_init_avx2() - Initialise result map before first use 1118 + * @m: Matching data, including mapping table 1119 + * @res_map: Result map 1120 + * 1121 + * Like pipapo_resmap_init() but do not set start map bits covered by the first field. 1122 + */ 1123 + static inline void pipapo_resmap_init_avx2(const struct nft_pipapo_match *m, unsigned long *res_map) 1124 + { 1125 + const struct nft_pipapo_field *f = m->f; 1126 + int i; 1127 + 1128 + /* Starting map doesn't need to be set to all-ones for this implementation, 1129 + * but we do need to zero the remaining bits, if any. 1130 + */ 1131 + for (i = f->bsize; i < m->bsize_max; i++) 1132 + res_map[i] = 0ul; 1133 + } 1134 + 1135 + /** 1117 1136 * nft_pipapo_avx2_lookup() - Lookup function for AVX2 implementation 1118 1137 * @net: Network namespace 1119 1138 * @set: nftables API set representation ··· 1190 1171 res = scratch->map + (map_index ? m->bsize_max : 0); 1191 1172 fill = scratch->map + (map_index ? 0 : m->bsize_max); 1192 1173 1193 - /* Starting map doesn't need to be set for this implementation */ 1174 + pipapo_resmap_init_avx2(m, res); 1194 1175 1195 1176 nft_pipapo_avx2_prepare(); 1196 1177

+4 -2

net/netlabel/netlabel_kapi.c

··· 1165 1165 break; 1166 1166 #if IS_ENABLED(CONFIG_IPV6) 1167 1167 case AF_INET6: 1168 - if (sk->sk_family != AF_INET6) 1169 - return -EAFNOSUPPORT; 1168 + if (sk->sk_family != AF_INET6) { 1169 + ret_val = -EAFNOSUPPORT; 1170 + goto conn_setattr_return; 1171 + } 1170 1172 1171 1173 addr6 = (struct sockaddr_in6 *)addr; 1172 1174 entry = netlbl_domhsh_getentry_af6(secattr->domain,

+3 -2

net/rxrpc/insecure.c

··· 45 45 static bool none_validate_challenge(struct rxrpc_connection *conn, 46 46 struct sk_buff *skb) 47 47 { 48 - return rxrpc_abort_conn(conn, skb, RX_PROTOCOL_ERROR, -EPROTO, 49 - rxrpc_eproto_rxnull_challenge); 48 + rxrpc_abort_conn(conn, skb, RX_PROTOCOL_ERROR, -EPROTO, 49 + rxrpc_eproto_rxnull_challenge); 50 + return true; 50 51 } 51 52 52 53 static int none_sendmsg_respond_to_challenge(struct sk_buff *challenge,

+5 -1

net/tipc/crypto.c

··· 818 818 } 819 819 820 820 /* Get net to avoid freed tipc_crypto when delete namespace */ 821 - get_net(aead->crypto->net); 821 + if (!maybe_get_net(aead->crypto->net)) { 822 + tipc_bearer_put(b); 823 + rc = -ENODEV; 824 + goto exit; 825 + } 822 826 823 827 /* Now, do encrypt */ 824 828 rc = crypto_aead_encrypt(req);

+7 -11

net/wireless/scan.c

··· 3250 3250 const u8 *ie; 3251 3251 size_t ielen; 3252 3252 u64 tsf; 3253 + size_t s1g_optional_len; 3253 3254 3254 3255 if (WARN_ON(!mgmt)) 3255 3256 return NULL; ··· 3265 3264 3266 3265 if (ieee80211_is_s1g_beacon(mgmt->frame_control)) { 3267 3266 ext = (void *) mgmt; 3268 - if (ieee80211_is_s1g_short_beacon(mgmt->frame_control)) 3269 - min_hdr_len = offsetof(struct ieee80211_ext, 3270 - u.s1g_short_beacon.variable); 3271 - else 3272 - min_hdr_len = offsetof(struct ieee80211_ext, 3273 - u.s1g_beacon.variable); 3267 + s1g_optional_len = 3268 + ieee80211_s1g_optional_len(ext->frame_control); 3269 + min_hdr_len = 3270 + offsetof(struct ieee80211_ext, u.s1g_beacon.variable) + 3271 + s1g_optional_len; 3274 3272 } else { 3275 3273 /* same for beacons */ 3276 3274 min_hdr_len = offsetof(struct ieee80211_mgmt, ··· 3285 3285 const struct ieee80211_s1g_bcn_compat_ie *compat; 3286 3286 const struct element *elem; 3287 3287 3288 - if (ieee80211_is_s1g_short_beacon(mgmt->frame_control)) 3289 - ie = ext->u.s1g_short_beacon.variable; 3290 - else 3291 - ie = ext->u.s1g_beacon.variable; 3292 - 3288 + ie = ext->u.s1g_beacon.variable + s1g_optional_len; 3293 3289 elem = cfg80211_find_elem(WLAN_EID_S1G_BCN_COMPAT, ie, ielen); 3294 3290 if (!elem) 3295 3291 return NULL;

+2

tools/include/uapi/linux/bpf.h

··· 2056 2056 * for updates resulting in a null checksum the value is set to 2057 2057 * **CSUM_MANGLED_0** instead. Flag **BPF_F_PSEUDO_HDR** indicates 2058 2058 * that the modified header field is part of the pseudo-header. 2059 + * Flag **BPF_F_IPV6** should be set for IPv6 packets. 2059 2060 * 2060 2061 * This helper works in combination with **bpf_csum_diff**\ (), 2061 2062 * which does not update the checksum in-place, but offers more ··· 6073 6072 BPF_F_PSEUDO_HDR = (1ULL << 4), 6074 6073 BPF_F_MARK_MANGLED_0 = (1ULL << 5), 6075 6074 BPF_F_MARK_ENFORCE = (1ULL << 6), 6075 + BPF_F_IPV6 = (1ULL << 7), 6076 6076 }; 6077 6077 6078 6078 /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */

-1

tools/testing/kunit/configs/all_tests.config

··· 10 10 CONFIG_KUNIT_ALL_TESTS=y 11 11 12 12 CONFIG_FORTIFY_SOURCE=y 13 - CONFIG_INIT_STACK_ALL_PATTERN=y 14 13 15 14 CONFIG_IIO=y 16 15

+1 -1

tools/testing/selftests/Makefile

··· 205 205 206 206 all: 207 207 @ret=1; \ 208 - for TARGET in $(TARGETS); do \ 208 + for TARGET in $(TARGETS) $(INSTALL_DEP_TARGETS); do \ 209 209 BUILD_TARGET=$$BUILD/$$TARGET; \ 210 210 mkdir $$BUILD_TARGET -p; \ 211 211 $(MAKE) OUTPUT=$$BUILD_TARGET -C $$TARGET \

+5

tools/testing/selftests/drivers/net/hw/config

··· 1 + CONFIG_IPV6=y 2 + CONFIG_IPV6_GRE=y 3 + CONFIG_NET_IPGRE=y 4 + CONFIG_NET_IPGRE_DEMUX=y 5 + CONFIG_VXLAN=y

+2 -2

tools/testing/selftests/drivers/net/hw/tso.py

··· 39 39 port = rand_port() 40 40 listen_cmd = f"socat -{ipver} -t 2 -u TCP-LISTEN:{port},reuseport /dev/null,ignoreeof" 41 41 42 - with bkg(listen_cmd, host=cfg.remote) as nc: 42 + with bkg(listen_cmd, host=cfg.remote, exit_wait=True) as nc: 43 43 wait_port_listen(port, host=cfg.remote) 44 44 45 45 if ipver == "4": ··· 216 216 ("", "6", "tx-tcp6-segmentation", None), 217 217 ("vxlan", "", "tx-udp_tnl-segmentation", ("vxlan", True, "id 100 dstport 4789 noudpcsum")), 218 218 ("vxlan_csum", "", "tx-udp_tnl-csum-segmentation", ("vxlan", False, "id 100 dstport 4789 udpcsum")), 219 - ("gre", "4", "tx-gre-segmentation", ("ipgre", False, "")), 219 + ("gre", "4", "tx-gre-segmentation", ("gre", False, "")), 220 220 ("gre", "6", "tx-gre-segmentation", ("ip6gre", False, "")), 221 221 ) 222 222

+88 -14

tools/testing/selftests/net/netfilter/nft_concat_range.sh

··· 378 378 type_spec ipv4_addr . inet_service . inet_proto 379 379 chain_spec ip daddr . udp dport . meta l4proto 380 380 dst addr4 port proto 381 - src 381 + src 382 382 start 1 383 383 count 9 384 384 src_delta 9 ··· 419 419 420 420 set test { 421 421 type ${type_spec} 422 + counter 422 423 flags interval,timeout 423 424 } 424 425 ··· 1159 1158 fi 1160 1159 } 1161 1160 1162 - # Return packet count from 'test' counter in 'inet filter' table 1161 + # Return packet count for elem $1 from 'test' counter in 'inet filter' table 1163 1162 count_packets() { 1163 + found=0 1164 + for token in $(nft reset element inet filter test "${1}" ); do 1165 + [ ${found} -eq 1 ] && echo "${token}" && return 1166 + [ "${token}" = "packets" ] && found=1 1167 + done 1168 + } 1169 + 1170 + # Return packet count from 'test' counter in 'inet filter' table 1171 + count_packets_nomatch() { 1164 1172 found=0 1165 1173 for token in $(nft list counter inet filter test); do 1166 1174 [ ${found} -eq 1 ] && echo "${token}" && return ··· 1216 1206 1217 1207 # Set MAC addresses, send single packet, check that it matches, reset counter 1218 1208 send_match() { 1209 + local elem="$1" 1210 + 1211 + shift 1212 + 1219 1213 ip link set veth_a address "$(format_mac "${1}")" 1220 1214 ip -n B link set veth_b address "$(format_mac "${2}")" 1221 1215 ··· 1230 1216 eval src_"$f"=\$$format_\$f "${2}"$ 1231 1217 done 1232 1218 eval send_\$proto 1233 - if [ "$(count_packets)" != "1" ]; then 1219 + if [ "$(count_packets "$elem")" != "1" ]; then 1234 1220 err "${proto} packet to:" 1235 1221 err " $(for f in ${dst}; do 1236 1222 eval format_\$f "${1}"; printf ' '; done)" ··· 1256 1242 eval src_"$f"=\$$format_\$f "${2}"$ 1257 1243 done 1258 1244 eval send_\$proto 1259 - if [ "$(count_packets)" != "0" ]; then 1245 + if [ "$(count_packets_nomatch)" != "0" ]; then 1260 1246 err "${proto} packet to:" 1261 1247 err " $(for f in ${dst}; do 1262 1248 eval format_\$f "${1}"; printf ' '; done)" ··· 1269 1255 fi 1270 1256 } 1271 1257 1258 + maybe_send_nomatch() { 1259 + local elem="$1" 1260 + local what="$4" 1261 + 1262 + [ $((RANDOM%20)) -gt 0 ] && return 1263 + 1264 + dst_addr4="$2" 1265 + dst_port="$3" 1266 + send_udp 1267 + 1268 + if [ "$(count_packets_nomatch)" != "0" ]; then 1269 + err "Packet to $dst_addr4:$dst_port did match $what" 1270 + err "$(nft -a list ruleset)" 1271 + return 1 1272 + fi 1273 + } 1274 + 1275 + maybe_send_match() { 1276 + local elem="$1" 1277 + local what="$4" 1278 + 1279 + [ $((RANDOM%20)) -gt 0 ] && return 1280 + 1281 + dst_addr4="$2" 1282 + dst_port="$3" 1283 + send_udp 1284 + 1285 + if [ "$(count_packets "{ $elem }")" != "1" ]; then 1286 + err "Packet to $dst_addr4:$dst_port did not match $what" 1287 + err "$(nft -a list ruleset)" 1288 + return 1 1289 + fi 1290 + nft reset counter inet filter test >/dev/null 1291 + nft reset element inet filter test "{ $elem }" >/dev/null 1292 + } 1293 + 1272 1294 # Correctness test template: 1273 1295 # - add ranged element, check that packets match it 1274 1296 # - check that packets outside range don't match it ··· 1312 1262 test_correctness_main() { 1313 1263 range_size=1 1314 1264 for i in $(seq "${start}" $((start + count))); do 1265 + local elem="" 1266 + 1315 1267 end=$((start + range_size)) 1316 1268 1317 1269 # Avoid negative or zero-sized port ranges ··· 1324 1272 srcstart=$((start + src_delta)) 1325 1273 srcend=$((end + src_delta)) 1326 1274 1327 - add "$(format)" || return 1 1275 + elem="$(format)" 1276 + add "$elem" || return 1 1328 1277 for j in $(seq "$start" $((range_size / 2 + 1)) ${end}); do 1329 - send_match "${j}" $((j + src_delta)) || return 1 1278 + send_match "$elem" "${j}" $((j + src_delta)) || return 1 1330 1279 done 1331 1280 send_nomatch $((end + 1)) $((end + 1 + src_delta)) || return 1 1332 1281 1333 1282 # Delete elements now and then 1334 1283 if [ $((i % 3)) -eq 0 ]; then 1335 - del "$(format)" || return 1 1284 + del "$elem" || return 1 1336 1285 for j in $(seq "$start" \ 1337 1286 $((range_size / 2 + 1)) ${end}); do 1338 1287 send_nomatch "${j}" $((j + src_delta)) \ ··· 1625 1572 1626 1573 range_size=1 1627 1574 for i in $(seq "$start" $((start + count))); do 1575 + local elem="" 1576 + 1628 1577 end=$((start + range_size)) 1629 1578 srcstart=$((start + src_delta)) 1630 1579 srcend=$((end + src_delta)) 1631 1580 1632 - add "$(format)" || return 1 1581 + elem="$(format)" 1582 + add "$elem" || return 1 1633 1583 1634 1584 for j in $(seq "$start" $((range_size / 2 + 1)) ${end}); do 1635 - send_match "${j}" $((j + src_delta)) || return 1 1585 + send_match "$elem" "${j}" $((j + src_delta)) || return 1 1636 1586 done 1637 1587 1638 1588 range_size=$((range_size + 1)) ··· 1793 1737 srcend=$((end + src_delta)) 1794 1738 1795 1739 for j in $(seq "$start" $((range_size / 2 + 1)) ${end}); do 1796 - send_match "${j}" $((j + src_delta)) || return 1 1740 + send_match "$(format)" "${j}" $((j + src_delta)) || return 1 1797 1741 done 1798 1742 1799 1743 range_size=$((range_size + 1)) ··· 1812 1756 range_size=1 1813 1757 for i in $(seq 1 10); do 1814 1758 for j in $(seq 1 20) ; do 1815 - elem=$(printf "10.%d.%d.0/24 . %d1-%d0 . 6-17 " ${i} ${j} ${i} "$((i+1))") 1759 + local dport=$j 1760 + 1761 + elem=$(printf "10.%d.%d.0/24 . %d-%d0 . 6-17 " ${i} ${j} ${dport} "$((dport+1))") 1762 + 1763 + # too slow, do not test all addresses 1764 + maybe_send_nomatch "$elem" $(printf "10.%d.%d.1" $i $j) $(printf "%d1" $((dport+1))) "before add" || return 1 1816 1765 1817 1766 nft "add element inet filter test { $elem }" || return 1 1767 + 1768 + maybe_send_match "$elem" $(printf "10.%d.%d.1" $i $j) $(printf "%d" $dport) "after add" || return 1 1769 + 1818 1770 nft "get element inet filter test { $elem }" | grep -q "$elem" 1819 1771 if [ $? -ne 0 ];then 1820 1772 local got=$(nft "get element inet filter test { $elem }") 1821 1773 err "post-add: should have returned $elem but got $got" 1822 1774 return 1 1823 1775 fi 1776 + 1777 + maybe_send_nomatch "$elem" $(printf "10.%d.%d.1" $i $j) $(printf "%d1" $((dport+1))) "out-of-range" || return 1 1824 1778 done 1825 1779 done 1826 1780 1827 1781 # recheck after set was filled 1828 1782 for i in $(seq 1 10); do 1829 1783 for j in $(seq 1 20) ; do 1830 - elem=$(printf "10.%d.%d.0/24 . %d1-%d0 . 6-17 " ${i} ${j} ${i} "$((i+1))") 1784 + local dport=$j 1785 + 1786 + elem=$(printf "10.%d.%d.0/24 . %d-%d0 . 6-17 " ${i} ${j} ${dport} "$((dport+1))") 1831 1787 1832 1788 nft "get element inet filter test { $elem }" | grep -q "$elem" 1833 1789 if [ $? -ne 0 ];then ··· 1847 1779 err "post-fill: should have returned $elem but got $got" 1848 1780 return 1 1849 1781 fi 1782 + 1783 + maybe_send_match "$elem" $(printf "10.%d.%d.1" $i $j) $(printf "%d" $dport) "recheck" || return 1 1784 + maybe_send_nomatch "$elem" $(printf "10.%d.%d.1" $i $j) $(printf "%d1" $((dport+1))) "recheck out-of-range" || return 1 1850 1785 done 1851 1786 done 1852 1787 ··· 1857 1786 for i in $(seq 1 10); do 1858 1787 for j in $(seq 1 20) ; do 1859 1788 local rnd=$((RANDOM%10)) 1789 + local dport=$j 1860 1790 local got="" 1861 1791 1862 - elem=$(printf "10.%d.%d.0/24 . %d1-%d0 . 6-17 " ${i} ${j} ${i} "$((i+1))") 1792 + elem=$(printf "10.%d.%d.0/24 . %d-%d0 . 6-17 " ${i} ${j} ${dport} "$((dport+1))") 1863 1793 if [ $rnd -gt 0 ];then 1864 1794 continue 1865 1795 fi ··· 1871 1799 err "post-delete: query for $elem returned $got instead of error." 1872 1800 return 1 1873 1801 fi 1802 + 1803 + maybe_send_nomatch "$elem" $(printf "10.%d.%d.1" $i $j) $(printf "%d" $dport) "match after deletion" || return 1 1874 1804 done 1875 1805 done 1876 1806 ··· 1891 1817 dst_addr6="$a2" 1892 1818 send_icmp6 1893 1819 1894 - if [ "$(count_packets)" -gt "0" ]; then 1820 + if [ "$(count_packets "{ icmpv6 . $a1 }")" -gt "0" ]; then 1895 1821 err "False match for $a2" 1896 1822 return 1 1897 1823 fi

+76 -5

tools/testing/selftests/net/netfilter/nft_nat.sh

··· 866 866 ip netns exec "$ns0" nft delete table $family nat 867 867 } 868 868 869 + file_cmp() 870 + { 871 + local infile="$1" 872 + local outfile="$2" 873 + 874 + if ! cmp "$infile" "$outfile";then 875 + echo -n "Infile " 876 + ls -l "$infile" 877 + echo -n "Outfile " 878 + ls -l "$outfile" 879 + echo "ERROR: in and output file mismatch when checking $msg" 1>&1 880 + ret=1 881 + return 1 882 + fi 883 + 884 + return 0 885 + } 886 + 869 887 test_stateless_nat_ip() 870 888 { 871 889 local lret=0 ··· 984 966 985 967 wait 986 968 987 - if ! cmp "$INFILE" "$OUTFILE";then 988 - ls -l "$INFILE" "$OUTFILE" 989 - echo "ERROR: in and output file mismatch when checking udp with stateless nat" 1>&2 990 - lret=1 991 - fi 969 + file_cmp "$INFILE" "$OUTFILE" "udp with stateless nat" || lret=1 992 970 993 971 :> "$OUTFILE" 994 972 ··· 1001 987 fi 1002 988 1003 989 test $lret -eq 0 && echo "PASS: IP statless for $ns2" 990 + 991 + return $lret 992 + } 993 + 994 + test_dnat_clash() 995 + { 996 + local lret=0 997 + 998 + if ! socat -h > /dev/null 2>&1;then 999 + echo "SKIP: Could not run dnat clash test without socat tool" 1000 + [ $ret -eq 0 ] && ret=$ksft_skip 1001 + return $ksft_skip 1002 + fi 1003 + 1004 + ip netns exec "$ns0" nft -f /dev/stdin <<EOF 1005 + flush ruleset 1006 + table ip dnat-test { 1007 + chain prerouting { 1008 + type nat hook prerouting priority dstnat; policy accept; 1009 + ip daddr 10.0.2.1 udp dport 1234 counter dnat to 10.0.1.1:1234 1010 + } 1011 + } 1012 + EOF 1013 + if [ $? -ne 0 ]; then 1014 + echo "SKIP: Could not add dnat rules" 1015 + [ $ret -eq 0 ] && ret=$ksft_skip 1016 + return $ksft_skip 1017 + fi 1018 + 1019 + local udpdaddr="10.0.2.1" 1020 + for i in 1 2;do 1021 + echo "PING $udpdaddr" > "$INFILE" 1022 + echo "PONG 10.0.1.1 step $i" | ip netns exec "$ns0" timeout 3 socat STDIO UDP4-LISTEN:1234,bind=10.0.1.1 > "$OUTFILE" 2>/dev/null & 1023 + local lpid=$! 1024 + 1025 + busywait $BUSYWAIT_TIMEOUT listener_ready "$ns0" 1234 "-u" 1026 + 1027 + result=$(ip netns exec "$ns1" timeout 3 socat STDIO UDP4-SENDTO:"$udpdaddr:1234,sourceport=4321" < "$INFILE") 1028 + udpdaddr="10.0.1.1" 1029 + 1030 + if [ "$result" != "PONG 10.0.1.1 step $i" ] ; then 1031 + echo "ERROR: failed to test udp $ns1 to $ns2 with dnat rule step $i, result: \"$result\"" 1>&2 1032 + lret=1 1033 + ret=1 1034 + fi 1035 + 1036 + wait 1037 + 1038 + file_cmp "$INFILE" "$OUTFILE" "udp dnat step $i" || lret=1 1039 + 1040 + :> "$OUTFILE" 1041 + done 1042 + 1043 + test $lret -eq 0 && echo "PASS: IP dnat clash $ns1:$ns2" 1044 + 1045 + ip netns exec "$ns0" nft flush ruleset 1004 1046 1005 1047 return $lret 1006 1048 } ··· 1217 1147 1218 1148 test_port_shadowing 1219 1149 test_stateless_nat_ip 1150 + test_dnat_clash 1220 1151 1221 1152 if [ $ret -ne 0 ];then 1222 1153 echo -n "FAIL: "

+1

tools/testing/selftests/net/ovpn/ovpn-cli.c

··· 2166 2166 2167 2167 ovpn->peers_file = argv[4]; 2168 2168 2169 + ovpn->sa_family = AF_INET; 2169 2170 if (argc > 5 && !strcmp(argv[5], "ipv6")) 2170 2171 ovpn->sa_family = AF_INET6; 2171 2172 break;

+9

tools/testing/selftests/net/ovpn/test-large-mtu.sh

Configure Feed

Configure Feed