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

+3

.mailmap

··· 215 215 Jens Osterkamp <Jens.Osterkamp@de.ibm.com> 216 216 Jernej Skrabec <jernej.skrabec@gmail.com> <jernej.skrabec@siol.net> 217 217 Jessica Zhang <quic_jesszhan@quicinc.com> <jesszhan@codeaurora.org> 218 + Jiri Pirko <jiri@resnulli.us> <jiri@nvidia.com> 219 + Jiri Pirko <jiri@resnulli.us> <jiri@mellanox.com> 220 + Jiri Pirko <jiri@resnulli.us> <jpirko@redhat.com> 218 221 Jiri Slaby <jirislaby@kernel.org> <jirislaby@gmail.com> 219 222 Jiri Slaby <jirislaby@kernel.org> <jslaby@novell.com> 220 223 Jiri Slaby <jirislaby@kernel.org> <jslaby@suse.com>

+1 -1

Documentation/netlink/genetlink-c.yaml

··· 1 - # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 %YAML 1.2 3 3 --- 4 4 $id: http://kernel.org/schemas/netlink/genetlink-c.yaml#

+1 -1

Documentation/netlink/genetlink-legacy.yaml

··· 1 - # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 %YAML 1.2 3 3 --- 4 4 $id: http://kernel.org/schemas/netlink/genetlink-legacy.yaml#

+1 -1

Documentation/netlink/genetlink.yaml

··· 1 - # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 %YAML 1.2 3 3 --- 4 4 $id: http://kernel.org/schemas/netlink/genetlink-legacy.yaml#

+1 -1

Documentation/netlink/specs/ethtool.yaml

··· 1 - # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 3 3 name: ethtool 4 4

+1 -1

Documentation/netlink/specs/fou.yaml

··· 1 - # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 3 3 name: fou 4 4

+2 -1

Documentation/netlink/specs/netdev.yaml

··· 1 - # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 3 3 name: netdev 4 4 ··· 9 9 - 10 10 type: flags 11 11 name: xdp-act 12 + render-max: true 12 13 entries: 13 14 - 14 15 name: basic

+2 -1

Documentation/userspace-api/netlink/specs.rst

··· 24 24 This document describes details of the schema. 25 25 See :doc:`intro-specs` for a practical starting guide. 26 26 27 - All specs must be licensed under ``GPL-2.0-only OR BSD-3-Clause`` 27 + All specs must be licensed under 28 + ``((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)`` 28 29 to allow for easy adoption in user space code. 29 30 30 31 Compatibility levels

+3 -3

MAINTAINERS

··· 5971 5971 F: include/uapi/linux/dm-*.h 5972 5972 5973 5973 DEVLINK 5974 - M: Jiri Pirko <jiri@nvidia.com> 5974 + M: Jiri Pirko <jiri@resnulli.us> 5975 5975 L: netdev@vger.kernel.org 5976 5976 S: Supported 5977 5977 F: Documentation/networking/devlink ··· 15079 15079 F: drivers/hwmon/nzxt-smart2.c 15080 15080 15081 15081 OBJAGG 15082 - M: Jiri Pirko <jiri@nvidia.com> 15082 + M: Jiri Pirko <jiri@resnulli.us> 15083 15083 L: netdev@vger.kernel.org 15084 15084 S: Supported 15085 15085 F: include/linux/objagg.h ··· 15853 15853 F: include/linux/hp_sdc.h 15854 15854 15855 15855 PARMAN 15856 - M: Jiri Pirko <jiri@nvidia.com> 15856 + M: Jiri Pirko <jiri@resnulli.us> 15857 15857 L: netdev@vger.kernel.org 15858 15858 S: Supported 15859 15859 F: include/linux/parman.h

+16 -7

drivers/net/bonding/bond_main.c

··· 1775 1775 slave_err(bond_dev, slave_dev, "Error: %s\n", errmsg); \ 1776 1776 } while (0) 1777 1777 1778 + /* The bonding driver uses ether_setup() to convert a master bond device 1779 + * to ARPHRD_ETHER, that resets the target netdevice's flags so we always 1780 + * have to restore the IFF_MASTER flag, and only restore IFF_SLAVE if it was set 1781 + */ 1782 + static void bond_ether_setup(struct net_device *bond_dev) 1783 + { 1784 + unsigned int slave_flag = bond_dev->flags & IFF_SLAVE; 1785 + 1786 + ether_setup(bond_dev); 1787 + bond_dev->flags |= IFF_MASTER | slave_flag; 1788 + bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1789 + } 1790 + 1778 1791 /* enslave device <slave> to bond device <master> */ 1779 1792 int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev, 1780 1793 struct netlink_ext_ack *extack) ··· 1879 1866 1880 1867 if (slave_dev->type != ARPHRD_ETHER) 1881 1868 bond_setup_by_slave(bond_dev, slave_dev); 1882 - else { 1883 - ether_setup(bond_dev); 1884 - bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1885 - } 1869 + else 1870 + bond_ether_setup(bond_dev); 1886 1871 1887 1872 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, 1888 1873 bond_dev); ··· 2300 2289 eth_hw_addr_random(bond_dev); 2301 2290 if (bond_dev->type != ARPHRD_ETHER) { 2302 2291 dev_close(bond_dev); 2303 - ether_setup(bond_dev); 2304 - bond_dev->flags |= IFF_MASTER; 2305 - bond_dev->priv_flags &= ~IFF_TX_SKB_SHARING; 2292 + bond_ether_setup(bond_dev); 2306 2293 } 2307 2294 } 2308 2295

+6 -6

drivers/net/can/cc770/cc770_platform.c

··· 93 93 if (priv->can.clock.freq > 8000000) 94 94 priv->cpu_interface |= CPUIF_DMC; 95 95 96 - if (of_get_property(np, "bosch,divide-memory-clock", NULL)) 96 + if (of_property_read_bool(np, "bosch,divide-memory-clock")) 97 97 priv->cpu_interface |= CPUIF_DMC; 98 - if (of_get_property(np, "bosch,iso-low-speed-mux", NULL)) 98 + if (of_property_read_bool(np, "bosch,iso-low-speed-mux")) 99 99 priv->cpu_interface |= CPUIF_MUX; 100 100 101 101 if (!of_get_property(np, "bosch,no-comperator-bypass", NULL)) 102 102 priv->bus_config |= BUSCFG_CBY; 103 - if (of_get_property(np, "bosch,disconnect-rx0-input", NULL)) 103 + if (of_property_read_bool(np, "bosch,disconnect-rx0-input")) 104 104 priv->bus_config |= BUSCFG_DR0; 105 - if (of_get_property(np, "bosch,disconnect-rx1-input", NULL)) 105 + if (of_property_read_bool(np, "bosch,disconnect-rx1-input")) 106 106 priv->bus_config |= BUSCFG_DR1; 107 - if (of_get_property(np, "bosch,disconnect-tx1-output", NULL)) 107 + if (of_property_read_bool(np, "bosch,disconnect-tx1-output")) 108 108 priv->bus_config |= BUSCFG_DT1; 109 - if (of_get_property(np, "bosch,polarity-dominant", NULL)) 109 + if (of_property_read_bool(np, "bosch,polarity-dominant")) 110 110 priv->bus_config |= BUSCFG_POL; 111 111 112 112 prop = of_get_property(np, "bosch,clock-out-frequency", &prop_size);

+1 -1

drivers/net/dsa/microchip/ksz_common.c

··· 319 319 [S_BROADCAST_CTRL] = 0x06, 320 320 [S_MULTICAST_CTRL] = 0x04, 321 321 [P_XMII_CTRL_0] = 0x06, 322 - [P_XMII_CTRL_1] = 0x56, 322 + [P_XMII_CTRL_1] = 0x06, 323 323 }; 324 324 325 325 static const u32 ksz8795_masks[] = {

+29 -29

drivers/net/dsa/mt7530.c

··· 430 430 switch (interface) { 431 431 case PHY_INTERFACE_MODE_RGMII: 432 432 trgint = 0; 433 - /* PLL frequency: 125MHz */ 434 - ncpo1 = 0x0c80; 435 433 break; 436 434 case PHY_INTERFACE_MODE_TRGMII: 437 435 trgint = 1; ··· 460 462 mt7530_rmw(priv, MT7530_P6ECR, P6_INTF_MODE_MASK, 461 463 P6_INTF_MODE(trgint)); 462 464 463 - /* Lower Tx Driving for TRGMII path */ 464 - for (i = 0 ; i < NUM_TRGMII_CTRL ; i++) 465 - mt7530_write(priv, MT7530_TRGMII_TD_ODT(i), 466 - TD_DM_DRVP(8) | TD_DM_DRVN(8)); 465 + if (trgint) { 466 + /* Lower Tx Driving for TRGMII path */ 467 + for (i = 0 ; i < NUM_TRGMII_CTRL ; i++) 468 + mt7530_write(priv, MT7530_TRGMII_TD_ODT(i), 469 + TD_DM_DRVP(8) | TD_DM_DRVN(8)); 467 470 468 - /* Disable MT7530 core and TRGMII Tx clocks */ 469 - core_clear(priv, CORE_TRGMII_GSW_CLK_CG, 470 - REG_GSWCK_EN | REG_TRGMIICK_EN); 471 + /* Disable MT7530 core and TRGMII Tx clocks */ 472 + core_clear(priv, CORE_TRGMII_GSW_CLK_CG, 473 + REG_GSWCK_EN | REG_TRGMIICK_EN); 471 474 472 - /* Setup the MT7530 TRGMII Tx Clock */ 473 - core_write(priv, CORE_PLL_GROUP5, RG_LCDDS_PCW_NCPO1(ncpo1)); 474 - core_write(priv, CORE_PLL_GROUP6, RG_LCDDS_PCW_NCPO0(0)); 475 - core_write(priv, CORE_PLL_GROUP10, RG_LCDDS_SSC_DELTA(ssc_delta)); 476 - core_write(priv, CORE_PLL_GROUP11, RG_LCDDS_SSC_DELTA1(ssc_delta)); 477 - core_write(priv, CORE_PLL_GROUP4, 478 - RG_SYSPLL_DDSFBK_EN | RG_SYSPLL_BIAS_EN | 479 - RG_SYSPLL_BIAS_LPF_EN); 480 - core_write(priv, CORE_PLL_GROUP2, 481 - RG_SYSPLL_EN_NORMAL | RG_SYSPLL_VODEN | 482 - RG_SYSPLL_POSDIV(1)); 483 - core_write(priv, CORE_PLL_GROUP7, 484 - RG_LCDDS_PCW_NCPO_CHG | RG_LCCDS_C(3) | 485 - RG_LCDDS_PWDB | RG_LCDDS_ISO_EN); 475 + /* Setup the MT7530 TRGMII Tx Clock */ 476 + core_write(priv, CORE_PLL_GROUP5, RG_LCDDS_PCW_NCPO1(ncpo1)); 477 + core_write(priv, CORE_PLL_GROUP6, RG_LCDDS_PCW_NCPO0(0)); 478 + core_write(priv, CORE_PLL_GROUP10, RG_LCDDS_SSC_DELTA(ssc_delta)); 479 + core_write(priv, CORE_PLL_GROUP11, RG_LCDDS_SSC_DELTA1(ssc_delta)); 480 + core_write(priv, CORE_PLL_GROUP4, 481 + RG_SYSPLL_DDSFBK_EN | RG_SYSPLL_BIAS_EN | 482 + RG_SYSPLL_BIAS_LPF_EN); 483 + core_write(priv, CORE_PLL_GROUP2, 484 + RG_SYSPLL_EN_NORMAL | RG_SYSPLL_VODEN | 485 + RG_SYSPLL_POSDIV(1)); 486 + core_write(priv, CORE_PLL_GROUP7, 487 + RG_LCDDS_PCW_NCPO_CHG | RG_LCCDS_C(3) | 488 + RG_LCDDS_PWDB | RG_LCDDS_ISO_EN); 486 489 487 - /* Enable MT7530 core and TRGMII Tx clocks */ 488 - core_set(priv, CORE_TRGMII_GSW_CLK_CG, 489 - REG_GSWCK_EN | REG_TRGMIICK_EN); 490 - 491 - if (!trgint) 490 + /* Enable MT7530 core and TRGMII Tx clocks */ 491 + core_set(priv, CORE_TRGMII_GSW_CLK_CG, 492 + REG_GSWCK_EN | REG_TRGMIICK_EN); 493 + } else { 492 494 for (i = 0 ; i < NUM_TRGMII_CTRL; i++) 493 495 mt7530_rmw(priv, MT7530_TRGMII_RD(i), 494 496 RD_TAP_MASK, RD_TAP(16)); 497 + } 498 + 495 499 return 0; 496 500 } 497 501 ··· 2201 2201 2202 2202 mt7530_pll_setup(priv); 2203 2203 2204 - /* Enable Port 6 only; P5 as GMAC5 which currently is not supported */ 2204 + /* Enable port 6 */ 2205 2205 val = mt7530_read(priv, MT7530_MHWTRAP); 2206 2206 val &= ~MHWTRAP_P6_DIS & ~MHWTRAP_PHY_ACCESS; 2207 2207 val |= MHWTRAP_MANUAL;

+12 -4

drivers/net/dsa/mv88e6xxx/chip.c

··· 3549 3549 return 10240 - VLAN_ETH_HLEN - EDSA_HLEN - ETH_FCS_LEN; 3550 3550 else if (chip->info->ops->set_max_frame_size) 3551 3551 return 1632 - VLAN_ETH_HLEN - EDSA_HLEN - ETH_FCS_LEN; 3552 - return 1522 - VLAN_ETH_HLEN - EDSA_HLEN - ETH_FCS_LEN; 3552 + return ETH_DATA_LEN; 3553 3553 } 3554 3554 3555 3555 static int mv88e6xxx_change_mtu(struct dsa_switch *ds, int port, int new_mtu) 3556 3556 { 3557 3557 struct mv88e6xxx_chip *chip = ds->priv; 3558 3558 int ret = 0; 3559 + 3560 + /* For families where we don't know how to alter the MTU, 3561 + * just accept any value up to ETH_DATA_LEN 3562 + */ 3563 + if (!chip->info->ops->port_set_jumbo_size && 3564 + !chip->info->ops->set_max_frame_size) { 3565 + if (new_mtu > ETH_DATA_LEN) 3566 + return -EINVAL; 3567 + 3568 + return 0; 3569 + } 3559 3570 3560 3571 if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port)) 3561 3572 new_mtu += EDSA_HLEN; ··· 3576 3565 ret = chip->info->ops->port_set_jumbo_size(chip, port, new_mtu); 3577 3566 else if (chip->info->ops->set_max_frame_size) 3578 3567 ret = chip->info->ops->set_max_frame_size(chip, new_mtu); 3579 - else 3580 - if (new_mtu > 1522) 3581 - ret = -EINVAL; 3582 3568 mv88e6xxx_reg_unlock(chip); 3583 3569 3584 3570 return ret;

+12 -3

drivers/net/ethernet/amazon/ena/ena_ethtool.c

··· 850 850 struct ena_adapter *adapter = netdev_priv(netdev); 851 851 u32 count = channels->combined_count; 852 852 /* The check for max value is already done in ethtool */ 853 - if (count < ENA_MIN_NUM_IO_QUEUES || 854 - (ena_xdp_present(adapter) && 855 - !ena_xdp_legal_queue_count(adapter, count))) 853 + if (count < ENA_MIN_NUM_IO_QUEUES) 856 854 return -EINVAL; 855 + 856 + if (!ena_xdp_legal_queue_count(adapter, count)) { 857 + if (ena_xdp_present(adapter)) 858 + return -EINVAL; 859 + 860 + xdp_clear_features_flag(netdev); 861 + } else { 862 + xdp_set_features_flag(netdev, 863 + NETDEV_XDP_ACT_BASIC | 864 + NETDEV_XDP_ACT_REDIRECT); 865 + } 857 866 858 867 return ena_update_queue_count(adapter, count); 859 868 }

+4 -2

drivers/net/ethernet/amazon/ena/ena_netdev.c

··· 4105 4105 /* Set offload features */ 4106 4106 ena_set_dev_offloads(feat, netdev); 4107 4107 4108 - netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 4109 - 4110 4108 adapter->max_mtu = feat->dev_attr.max_mtu; 4111 4109 netdev->max_mtu = adapter->max_mtu; 4112 4110 netdev->min_mtu = ENA_MIN_MTU; ··· 4390 4392 } 4391 4393 4392 4394 ena_config_debug_area(adapter); 4395 + 4396 + if (ena_xdp_legal_queue_count(adapter, adapter->num_io_queues)) 4397 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | 4398 + NETDEV_XDP_ACT_REDIRECT; 4393 4399 4394 4400 memcpy(adapter->netdev->perm_addr, adapter->mac_addr, netdev->addr_len); 4395 4401

+21 -7

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

··· 412 412 return num_frames - drop; 413 413 } 414 414 415 + static struct sk_buff *aq_xdp_build_skb(struct xdp_buff *xdp, 416 + struct net_device *dev, 417 + struct aq_ring_buff_s *buff) 418 + { 419 + struct xdp_frame *xdpf; 420 + struct sk_buff *skb; 421 + 422 + xdpf = xdp_convert_buff_to_frame(xdp); 423 + if (unlikely(!xdpf)) 424 + return NULL; 425 + 426 + skb = xdp_build_skb_from_frame(xdpf, dev); 427 + if (!skb) 428 + return NULL; 429 + 430 + aq_get_rxpages_xdp(buff, xdp); 431 + return skb; 432 + } 433 + 415 434 static struct sk_buff *aq_xdp_run_prog(struct aq_nic_s *aq_nic, 416 435 struct xdp_buff *xdp, 417 436 struct aq_ring_s *rx_ring, ··· 450 431 451 432 prog = READ_ONCE(rx_ring->xdp_prog); 452 433 if (!prog) 453 - goto pass; 434 + return aq_xdp_build_skb(xdp, aq_nic->ndev, buff); 454 435 455 436 prefetchw(xdp->data_hard_start); /* xdp_frame write */ 456 437 ··· 461 442 act = bpf_prog_run_xdp(prog, xdp); 462 443 switch (act) { 463 444 case XDP_PASS: 464 - pass: 465 - xdpf = xdp_convert_buff_to_frame(xdp); 466 - if (unlikely(!xdpf)) 467 - goto out_aborted; 468 - skb = xdp_build_skb_from_frame(xdpf, aq_nic->ndev); 445 + skb = aq_xdp_build_skb(xdp, aq_nic->ndev, buff); 469 446 if (!skb) 470 447 goto out_aborted; 471 448 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 472 449 ++rx_ring->stats.rx.xdp_pass; 473 450 u64_stats_update_end(&rx_ring->stats.rx.syncp); 474 - aq_get_rxpages_xdp(buff, xdp); 475 451 return skb; 476 452 case XDP_TX: 477 453 xdpf = xdp_convert_buff_to_frame(xdp);

+2 -4

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

··· 6990 6990 if (flags & FUNC_QCFG_RESP_FLAGS_FW_DCBX_AGENT_ENABLED) 6991 6991 bp->fw_cap |= BNXT_FW_CAP_DCBX_AGENT; 6992 6992 } 6993 - if (BNXT_PF(bp) && (flags & FUNC_QCFG_RESP_FLAGS_MULTI_HOST)) { 6993 + if (BNXT_PF(bp) && (flags & FUNC_QCFG_RESP_FLAGS_MULTI_HOST)) 6994 6994 bp->flags |= BNXT_FLAG_MULTI_HOST; 6995 - if (bp->fw_cap & BNXT_FW_CAP_PTP_RTC) 6996 - bp->fw_cap &= ~BNXT_FW_CAP_PTP_RTC; 6997 - } 6995 + 6998 6996 if (flags & FUNC_QCFG_RESP_FLAGS_RING_MONITOR_ENABLED) 6999 6997 bp->fw_cap |= BNXT_FW_CAP_RING_MONITOR; 7000 6998

+2

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

··· 2000 2000 u32 fw_dbg_cap; 2001 2001 2002 2002 #define BNXT_NEW_RM(bp) ((bp)->fw_cap & BNXT_FW_CAP_NEW_RM) 2003 + #define BNXT_PTP_USE_RTC(bp) (!BNXT_MH(bp) && \ 2004 + ((bp)->fw_cap & BNXT_FW_CAP_PTP_RTC)) 2003 2005 u32 hwrm_spec_code; 2004 2006 u16 hwrm_cmd_seq; 2005 2007 u16 hwrm_cmd_kong_seq;

+31 -25

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

··· 63 63 ptp_info); 64 64 u64 ns = timespec64_to_ns(ts); 65 65 66 - if (ptp->bp->fw_cap & BNXT_FW_CAP_PTP_RTC) 66 + if (BNXT_PTP_USE_RTC(ptp->bp)) 67 67 return bnxt_ptp_cfg_settime(ptp->bp, ns); 68 68 69 69 spin_lock_bh(&ptp->ptp_lock); ··· 196 196 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg, 197 197 ptp_info); 198 198 199 - if (ptp->bp->fw_cap & BNXT_FW_CAP_PTP_RTC) 199 + if (BNXT_PTP_USE_RTC(ptp->bp)) 200 200 return bnxt_ptp_adjphc(ptp, delta); 201 201 202 202 spin_lock_bh(&ptp->ptp_lock); ··· 205 205 return 0; 206 206 } 207 207 208 + static int bnxt_ptp_adjfine_rtc(struct bnxt *bp, long scaled_ppm) 209 + { 210 + s32 ppb = scaled_ppm_to_ppb(scaled_ppm); 211 + struct hwrm_port_mac_cfg_input *req; 212 + int rc; 213 + 214 + rc = hwrm_req_init(bp, req, HWRM_PORT_MAC_CFG); 215 + if (rc) 216 + return rc; 217 + 218 + req->ptp_freq_adj_ppb = cpu_to_le32(ppb); 219 + req->enables = cpu_to_le32(PORT_MAC_CFG_REQ_ENABLES_PTP_FREQ_ADJ_PPB); 220 + rc = hwrm_req_send(bp, req); 221 + if (rc) 222 + netdev_err(bp->dev, 223 + "ptp adjfine failed. rc = %d\n", rc); 224 + return rc; 225 + } 226 + 208 227 static int bnxt_ptp_adjfine(struct ptp_clock_info *ptp_info, long scaled_ppm) 209 228 { 210 229 struct bnxt_ptp_cfg *ptp = container_of(ptp_info, struct bnxt_ptp_cfg, 211 230 ptp_info); 212 - struct hwrm_port_mac_cfg_input *req; 213 231 struct bnxt *bp = ptp->bp; 214 - int rc = 0; 215 232 216 - if (!(ptp->bp->fw_cap & BNXT_FW_CAP_PTP_RTC)) { 217 - spin_lock_bh(&ptp->ptp_lock); 218 - timecounter_read(&ptp->tc); 219 - ptp->cc.mult = adjust_by_scaled_ppm(ptp->cmult, scaled_ppm); 220 - spin_unlock_bh(&ptp->ptp_lock); 221 - } else { 222 - s32 ppb = scaled_ppm_to_ppb(scaled_ppm); 233 + if (BNXT_PTP_USE_RTC(bp)) 234 + return bnxt_ptp_adjfine_rtc(bp, scaled_ppm); 223 235 224 - rc = hwrm_req_init(bp, req, HWRM_PORT_MAC_CFG); 225 - if (rc) 226 - return rc; 227 - 228 - req->ptp_freq_adj_ppb = cpu_to_le32(ppb); 229 - req->enables = cpu_to_le32(PORT_MAC_CFG_REQ_ENABLES_PTP_FREQ_ADJ_PPB); 230 - rc = hwrm_req_send(ptp->bp, req); 231 - if (rc) 232 - netdev_err(ptp->bp->dev, 233 - "ptp adjfine failed. rc = %d\n", rc); 234 - } 235 - return rc; 236 + spin_lock_bh(&ptp->ptp_lock); 237 + timecounter_read(&ptp->tc); 238 + ptp->cc.mult = adjust_by_scaled_ppm(ptp->cmult, scaled_ppm); 239 + spin_unlock_bh(&ptp->ptp_lock); 240 + return 0; 236 241 } 237 242 238 243 void bnxt_ptp_pps_event(struct bnxt *bp, u32 data1, u32 data2) ··· 884 879 u64 ns; 885 880 int rc; 886 881 887 - if (!bp->ptp_cfg || !(bp->fw_cap & BNXT_FW_CAP_PTP_RTC)) 882 + if (!bp->ptp_cfg || !BNXT_PTP_USE_RTC(bp)) 888 883 return -ENODEV; 889 884 890 885 if (!phc_cfg) { ··· 937 932 atomic_set(&ptp->tx_avail, BNXT_MAX_TX_TS); 938 933 spin_lock_init(&ptp->ptp_lock); 939 934 940 - if (bp->fw_cap & BNXT_FW_CAP_PTP_RTC) { 935 + if (BNXT_PTP_USE_RTC(bp)) { 941 936 bnxt_ptp_timecounter_init(bp, false); 942 937 rc = bnxt_ptp_init_rtc(bp, phc_cfg); 943 938 if (rc) 944 939 goto out; 945 940 } else { 946 941 bnxt_ptp_timecounter_init(bp, true); 942 + bnxt_ptp_adjfine_rtc(bp, 0); 947 943 } 948 944 949 945 ptp->ptp_info = bnxt_ptp_caps;

+1 -1

drivers/net/ethernet/cadence/macb_main.c

··· 4990 4990 bp->jumbo_max_len = macb_config->jumbo_max_len; 4991 4991 4992 4992 bp->wol = 0; 4993 - if (of_get_property(np, "magic-packet", NULL)) 4993 + if (of_property_read_bool(np, "magic-packet")) 4994 4994 bp->wol |= MACB_WOL_HAS_MAGIC_PACKET; 4995 4995 device_set_wakeup_capable(&pdev->dev, bp->wol & MACB_WOL_HAS_MAGIC_PACKET); 4996 4996

+11 -6

drivers/net/ethernet/cavium/thunder/nicvf_ethtool.c

··· 735 735 if (channel->tx_count > nic->max_queues) 736 736 return -EINVAL; 737 737 738 - if (nic->xdp_prog && 739 - ((channel->tx_count + channel->rx_count) > nic->max_queues)) { 740 - netdev_err(nic->netdev, 741 - "XDP mode, RXQs + TXQs > Max %d\n", 742 - nic->max_queues); 743 - return -EINVAL; 738 + if (channel->tx_count + channel->rx_count > nic->max_queues) { 739 + if (nic->xdp_prog) { 740 + netdev_err(nic->netdev, 741 + "XDP mode, RXQs + TXQs > Max %d\n", 742 + nic->max_queues); 743 + return -EINVAL; 744 + } 745 + 746 + xdp_clear_features_flag(nic->netdev); 747 + } else if (!pass1_silicon(nic->pdev)) { 748 + xdp_set_features_flag(dev, NETDEV_XDP_ACT_BASIC); 744 749 } 745 750 746 751 if (if_up)

+3 -1

drivers/net/ethernet/cavium/thunder/nicvf_main.c

··· 2218 2218 netdev->netdev_ops = &nicvf_netdev_ops; 2219 2219 netdev->watchdog_timeo = NICVF_TX_TIMEOUT; 2220 2220 2221 - netdev->xdp_features = NETDEV_XDP_ACT_BASIC; 2221 + if (!pass1_silicon(nic->pdev) && 2222 + nic->rx_queues + nic->tx_queues <= nic->max_queues) 2223 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC; 2222 2224 2223 2225 /* MTU range: 64 - 9200 */ 2224 2226 netdev->min_mtu = NIC_HW_MIN_FRS;

+2 -2

drivers/net/ethernet/davicom/dm9000.c

··· 1393 1393 if (!pdata) 1394 1394 return ERR_PTR(-ENOMEM); 1395 1395 1396 - if (of_find_property(np, "davicom,ext-phy", NULL)) 1396 + if (of_property_read_bool(np, "davicom,ext-phy")) 1397 1397 pdata->flags |= DM9000_PLATF_EXT_PHY; 1398 - if (of_find_property(np, "davicom,no-eeprom", NULL)) 1398 + if (of_property_read_bool(np, "davicom,no-eeprom")) 1399 1399 pdata->flags |= DM9000_PLATF_NO_EEPROM; 1400 1400 1401 1401 ret = of_get_mac_address(np, pdata->dev_addr);

+1 -1

drivers/net/ethernet/freescale/fec_main.c

··· 4251 4251 if (ret) 4252 4252 goto failed_ipc_init; 4253 4253 4254 - if (of_get_property(np, "fsl,magic-packet", NULL)) 4254 + if (of_property_read_bool(np, "fsl,magic-packet")) 4255 4255 fep->wol_flag |= FEC_WOL_HAS_MAGIC_PACKET; 4256 4256 4257 4257 ret = fec_enet_init_stop_mode(fep, np);

+1 -1

drivers/net/ethernet/freescale/fec_mpc52xx.c

··· 937 937 priv->phy_node = of_parse_phandle(np, "phy-handle", 0); 938 938 939 939 /* the 7-wire property means don't use MII mode */ 940 - if (of_find_property(np, "fsl,7-wire-mode", NULL)) { 940 + if (of_property_read_bool(np, "fsl,7-wire-mode")) { 941 941 priv->seven_wire_mode = 1; 942 942 dev_info(&ndev->dev, "using 7-wire PHY mode\n"); 943 943 }

+2 -2

drivers/net/ethernet/freescale/gianfar.c

··· 787 787 else 788 788 priv->interface = gfar_get_interface(dev); 789 789 790 - if (of_find_property(np, "fsl,magic-packet", NULL)) 790 + if (of_property_read_bool(np, "fsl,magic-packet")) 791 791 priv->device_flags |= FSL_GIANFAR_DEV_HAS_MAGIC_PACKET; 792 792 793 - if (of_get_property(np, "fsl,wake-on-filer", NULL)) 793 + if (of_property_read_bool(np, "fsl,wake-on-filer")) 794 794 priv->device_flags |= FSL_GIANFAR_DEV_HAS_WAKE_ON_FILER; 795 795 796 796 priv->phy_node = of_parse_phandle(np, "phy-handle", 0);

+8 -6

drivers/net/ethernet/i825xx/sni_82596.c

··· 78 78 void __iomem *mpu_addr; 79 79 void __iomem *ca_addr; 80 80 u8 __iomem *eth_addr; 81 + u8 mac[ETH_ALEN]; 81 82 82 83 res = platform_get_resource(dev, IORESOURCE_MEM, 0); 83 84 ca = platform_get_resource(dev, IORESOURCE_MEM, 1); ··· 110 109 goto probe_failed; 111 110 112 111 /* someone seems to like messed up stuff */ 113 - netdevice->dev_addr[0] = readb(eth_addr + 0x0b); 114 - netdevice->dev_addr[1] = readb(eth_addr + 0x0a); 115 - netdevice->dev_addr[2] = readb(eth_addr + 0x09); 116 - netdevice->dev_addr[3] = readb(eth_addr + 0x08); 117 - netdevice->dev_addr[4] = readb(eth_addr + 0x07); 118 - netdevice->dev_addr[5] = readb(eth_addr + 0x06); 112 + mac[0] = readb(eth_addr + 0x0b); 113 + mac[1] = readb(eth_addr + 0x0a); 114 + mac[2] = readb(eth_addr + 0x09); 115 + mac[3] = readb(eth_addr + 0x08); 116 + mac[4] = readb(eth_addr + 0x07); 117 + mac[5] = readb(eth_addr + 0x06); 118 + eth_hw_addr_set(netdevice, mac); 119 119 iounmap(eth_addr); 120 120 121 121 if (netdevice->irq < 0) {

+4 -4

drivers/net/ethernet/ibm/emac/core.c

··· 2939 2939 } 2940 2940 2941 2941 /* Fixup some feature bits based on the device tree */ 2942 - if (of_get_property(np, "has-inverted-stacr-oc", NULL)) 2942 + if (of_property_read_bool(np, "has-inverted-stacr-oc")) 2943 2943 dev->features |= EMAC_FTR_STACR_OC_INVERT; 2944 - if (of_get_property(np, "has-new-stacr-staopc", NULL)) 2944 + if (of_property_read_bool(np, "has-new-stacr-staopc")) 2945 2945 dev->features |= EMAC_FTR_HAS_NEW_STACR; 2946 2946 2947 2947 /* CAB lacks the appropriate properties */ ··· 3042 3042 * property here for now, but new flat device trees should set a 3043 3043 * status property to "disabled" instead. 3044 3044 */ 3045 - if (of_get_property(np, "unused", NULL) || !of_device_is_available(np)) 3045 + if (of_property_read_bool(np, "unused") || !of_device_is_available(np)) 3046 3046 return -ENODEV; 3047 3047 3048 3048 /* Find ourselves in the bootlist if we are there */ ··· 3333 3333 3334 3334 if (of_match_node(emac_match, np) == NULL) 3335 3335 continue; 3336 - if (of_get_property(np, "unused", NULL)) 3336 + if (of_property_read_bool(np, "unused")) 3337 3337 continue; 3338 3338 idx = of_get_property(np, "cell-index", NULL); 3339 3339 if (idx == NULL)

+1 -1

drivers/net/ethernet/ibm/emac/rgmii.c

··· 242 242 } 243 243 244 244 /* Check for RGMII flags */ 245 - if (of_get_property(ofdev->dev.of_node, "has-mdio", NULL)) 245 + if (of_property_read_bool(ofdev->dev.of_node, "has-mdio")) 246 246 dev->flags |= EMAC_RGMII_FLAG_HAS_MDIO; 247 247 248 248 /* CAB lacks the right properties, fix this up */

+1

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

··· 15525 15525 int err; 15526 15526 int v_idx; 15527 15527 15528 + pci_set_drvdata(pf->pdev, pf); 15528 15529 pci_save_state(pf->pdev); 15529 15530 15530 15531 /* set up periodic task facility */

+5 -9

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

··· 509 509 ICE_FLAG_VF_VLAN_PRUNING, 510 510 ICE_FLAG_LINK_LENIENT_MODE_ENA, 511 511 ICE_FLAG_PLUG_AUX_DEV, 512 + ICE_FLAG_UNPLUG_AUX_DEV, 512 513 ICE_FLAG_MTU_CHANGED, 513 514 ICE_FLAG_GNSS, /* GNSS successfully initialized */ 514 515 ICE_PF_FLAGS_NBITS /* must be last */ ··· 956 955 */ 957 956 static inline void ice_clear_rdma_cap(struct ice_pf *pf) 958 957 { 959 - /* We can directly unplug aux device here only if the flag bit 960 - * ICE_FLAG_PLUG_AUX_DEV is not set because ice_unplug_aux_dev() 961 - * could race with ice_plug_aux_dev() called from 962 - * ice_service_task(). In this case we only clear that bit now and 963 - * aux device will be unplugged later once ice_plug_aux_device() 964 - * called from ice_service_task() finishes (see ice_service_task()). 958 + /* defer unplug to service task to avoid RTNL lock and 959 + * clear PLUG bit so that pending plugs don't interfere 965 960 */ 966 - if (!test_and_clear_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags)) 967 - ice_unplug_aux_dev(pf); 968 - 961 + clear_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags); 962 + set_bit(ICE_FLAG_UNPLUG_AUX_DEV, pf->flags); 969 963 clear_bit(ICE_FLAG_RDMA_ENA, pf->flags); 970 964 } 971 965 #endif /* _ICE_H_ */

+8 -11

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

··· 2316 2316 } 2317 2317 } 2318 2318 2319 - if (test_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags)) { 2320 - /* Plug aux device per request */ 2321 - ice_plug_aux_dev(pf); 2319 + /* unplug aux dev per request, if an unplug request came in 2320 + * while processing a plug request, this will handle it 2321 + */ 2322 + if (test_and_clear_bit(ICE_FLAG_UNPLUG_AUX_DEV, pf->flags)) 2323 + ice_unplug_aux_dev(pf); 2322 2324 2323 - /* Mark plugging as done but check whether unplug was 2324 - * requested during ice_plug_aux_dev() call 2325 - * (e.g. from ice_clear_rdma_cap()) and if so then 2326 - * plug aux device. 2327 - */ 2328 - if (!test_and_clear_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags)) 2329 - ice_unplug_aux_dev(pf); 2330 - } 2325 + /* Plug aux device per request */ 2326 + if (test_and_clear_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags)) 2327 + ice_plug_aux_dev(pf); 2331 2328 2332 2329 if (test_and_clear_bit(ICE_FLAG_MTU_CHANGED, pf->flags)) { 2333 2330 struct iidc_event *event;

+2 -3

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

··· 184 184 } 185 185 netif_tx_stop_queue(netdev_get_tx_queue(vsi->netdev, q_idx)); 186 186 187 - ice_qvec_dis_irq(vsi, rx_ring, q_vector); 188 - 189 187 ice_fill_txq_meta(vsi, tx_ring, &txq_meta); 190 188 err = ice_vsi_stop_tx_ring(vsi, ICE_NO_RESET, 0, tx_ring, &txq_meta); 191 189 if (err) ··· 198 200 if (err) 199 201 return err; 200 202 } 203 + ice_qvec_dis_irq(vsi, rx_ring, q_vector); 204 + 201 205 err = ice_vsi_ctrl_one_rx_ring(vsi, false, q_idx, true); 202 206 if (err) 203 207 return err; 204 - ice_clean_rx_ring(rx_ring); 205 208 206 209 ice_qvec_toggle_napi(vsi, q_vector, false); 207 210 ice_qp_clean_rings(vsi, q_idx);

+12 -3

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

··· 4996 4996 4997 4997 for (i = 0; i < priv->port_count; i++) { 4998 4998 port = priv->port_list[i]; 4999 + if (percpu && port->ntxqs >= num_possible_cpus() * 2) 5000 + xdp_set_features_flag(port->dev, 5001 + NETDEV_XDP_ACT_BASIC | 5002 + NETDEV_XDP_ACT_REDIRECT | 5003 + NETDEV_XDP_ACT_NDO_XMIT); 5004 + else 5005 + xdp_clear_features_flag(port->dev); 5006 + 4999 5007 mvpp2_swf_bm_pool_init(port); 5000 5008 if (status[i]) 5001 5009 mvpp2_open(port->dev); ··· 6871 6863 6872 6864 if (!port->priv->percpu_pools) 6873 6865 mvpp2_set_hw_csum(port, port->pool_long->id); 6866 + else if (port->ntxqs >= num_possible_cpus() * 2) 6867 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | 6868 + NETDEV_XDP_ACT_REDIRECT | 6869 + NETDEV_XDP_ACT_NDO_XMIT; 6874 6870 6875 6871 dev->vlan_features |= features; 6876 6872 netif_set_tso_max_segs(dev, MVPP2_MAX_TSO_SEGS); 6877 - 6878 - dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 6879 - NETDEV_XDP_ACT_NDO_XMIT; 6880 6873 6881 6874 dev->priv_flags |= IFF_UNICAST_FLT; 6882 6875

+4

drivers/net/ethernet/mediatek/mtk_eth_soc.h

··· 542 542 #define SGMII_SEND_AN_ERROR_EN BIT(11) 543 543 #define SGMII_IF_MODE_MASK GENMASK(5, 1) 544 544 545 + /* Register to reset SGMII design */ 546 + #define SGMII_RESERVED_0 0x34 547 + #define SGMII_SW_RESET BIT(0) 548 + 545 549 /* Register to set SGMII speed, ANA RG_ Control Signals III*/ 546 550 #define SGMSYS_ANA_RG_CS3 0x2028 547 551 #define RG_PHY_SPEED_MASK (BIT(2) | BIT(3))

+16 -12

drivers/net/ethernet/mediatek/mtk_sgmii.c

··· 38 38 const unsigned long *advertising, 39 39 bool permit_pause_to_mac) 40 40 { 41 + bool mode_changed = false, changed, use_an; 41 42 struct mtk_pcs *mpcs = pcs_to_mtk_pcs(pcs); 42 43 unsigned int rgc3, sgm_mode, bmcr; 43 44 int advertise, link_timer; 44 - bool changed, use_an; 45 45 46 46 advertise = phylink_mii_c22_pcs_encode_advertisement(interface, 47 47 advertising); 48 48 if (advertise < 0) 49 49 return advertise; 50 - 51 - link_timer = phylink_get_link_timer_ns(interface); 52 - if (link_timer < 0) 53 - return link_timer; 54 50 55 51 /* Clearing IF_MODE_BIT0 switches the PCS to BASE-X mode, and 56 52 * we assume that fixes it's speed at bitrate = line rate (in ··· 73 77 } 74 78 75 79 if (use_an) { 76 - /* FIXME: Do we need to set AN_RESTART here? */ 77 - bmcr = SGMII_AN_RESTART | SGMII_AN_ENABLE; 80 + bmcr = SGMII_AN_ENABLE; 78 81 } else { 79 82 bmcr = 0; 80 83 } 81 84 82 85 if (mpcs->interface != interface) { 86 + link_timer = phylink_get_link_timer_ns(interface); 87 + if (link_timer < 0) 88 + return link_timer; 89 + 83 90 /* PHYA power down */ 84 91 regmap_update_bits(mpcs->regmap, SGMSYS_QPHY_PWR_STATE_CTRL, 85 92 SGMII_PHYA_PWD, SGMII_PHYA_PWD); 93 + 94 + /* Reset SGMII PCS state */ 95 + regmap_update_bits(mpcs->regmap, SGMII_RESERVED_0, 96 + SGMII_SW_RESET, SGMII_SW_RESET); 86 97 87 98 if (interface == PHY_INTERFACE_MODE_2500BASEX) 88 99 rgc3 = RG_PHY_SPEED_3_125G; ··· 100 97 regmap_update_bits(mpcs->regmap, mpcs->ana_rgc3, 101 98 RG_PHY_SPEED_3_125G, rgc3); 102 99 100 + /* Setup the link timer */ 101 + regmap_write(mpcs->regmap, SGMSYS_PCS_LINK_TIMER, link_timer / 2 / 8); 102 + 103 103 mpcs->interface = interface; 104 + mode_changed = true; 104 105 } 105 106 106 107 /* Update the advertisement, noting whether it has changed */ 107 108 regmap_update_bits_check(mpcs->regmap, SGMSYS_PCS_ADVERTISE, 108 109 SGMII_ADVERTISE, advertise, &changed); 109 - 110 - /* Setup the link timer and QPHY power up inside SGMIISYS */ 111 - regmap_write(mpcs->regmap, SGMSYS_PCS_LINK_TIMER, link_timer / 2 / 8); 112 110 113 111 /* Update the sgmsys mode register */ 114 112 regmap_update_bits(mpcs->regmap, SGMSYS_SGMII_MODE, ··· 118 114 119 115 /* Update the BMCR */ 120 116 regmap_update_bits(mpcs->regmap, SGMSYS_PCS_CONTROL_1, 121 - SGMII_AN_RESTART | SGMII_AN_ENABLE, bmcr); 117 + SGMII_AN_ENABLE, bmcr); 122 118 123 119 /* Release PHYA power down state 124 120 * Only removing bit SGMII_PHYA_PWD isn't enough. ··· 132 128 usleep_range(50, 100); 133 129 regmap_write(mpcs->regmap, SGMSYS_QPHY_PWR_STATE_CTRL, 0); 134 130 135 - return changed; 131 + return changed || mode_changed; 136 132 } 137 133 138 134 static void mtk_pcs_restart_an(struct phylink_pcs *pcs)

+1 -1

drivers/net/ethernet/mellanox/mlx5/core/en.h

··· 313 313 } channel; 314 314 } mqprio; 315 315 bool rx_cqe_compress_def; 316 - bool tunneled_offload_en; 317 316 struct dim_cq_moder rx_cq_moderation; 318 317 struct dim_cq_moder tx_cq_moderation; 319 318 struct mlx5e_packet_merge_param packet_merge; ··· 1242 1243 void mlx5e_rx_dim_work(struct work_struct *work); 1243 1244 void mlx5e_tx_dim_work(struct work_struct *work); 1244 1245 1246 + void mlx5e_set_xdp_feature(struct net_device *netdev); 1245 1247 netdev_features_t mlx5e_features_check(struct sk_buff *skb, 1246 1248 struct net_device *netdev, 1247 1249 netdev_features_t features);

-1

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

··· 178 178 meter = mlx5e_tc_meter_get(priv->mdev, &params); 179 179 if (IS_ERR(meter)) { 180 180 NL_SET_ERR_MSG_MOD(fl_act->extack, "Failed to get flow meter"); 181 - mlx5_core_err(priv->mdev, "Failed to get flow meter %d\n", params.index); 182 181 return PTR_ERR(meter); 183 182 } 184 183

+5

drivers/net/ethernet/mellanox/mlx5/core/en/tc/act_stats.c

··· 64 64 { 65 65 struct mlx5e_tc_act_stats *act_stats, *old_act_stats; 66 66 struct rhashtable *ht = &handle->ht; 67 + u64 lastused; 67 68 int err = 0; 68 69 69 70 act_stats = kvzalloc(sizeof(*act_stats), GFP_KERNEL); ··· 73 72 74 73 act_stats->tc_act_cookie = act_cookie; 75 74 act_stats->counter = counter; 75 + 76 + mlx5_fc_query_cached_raw(counter, 77 + &act_stats->lastbytes, 78 + &act_stats->lastpackets, &lastused); 76 79 77 80 rcu_read_lock(); 78 81 old_act_stats = rhashtable_lookup_get_insert_fast(ht,

+13 -11

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

··· 621 621 if (unlikely(!priv_rx)) 622 622 return -ENOMEM; 623 623 624 - dek = mlx5_ktls_create_key(priv->tls->dek_pool, crypto_info); 625 - if (IS_ERR(dek)) { 626 - err = PTR_ERR(dek); 627 - goto err_create_key; 628 - } 629 - priv_rx->dek = dek; 630 - 631 - INIT_LIST_HEAD(&priv_rx->list); 632 - spin_lock_init(&priv_rx->lock); 633 624 switch (crypto_info->cipher_type) { 634 625 case TLS_CIPHER_AES_GCM_128: 635 626 priv_rx->crypto_info.crypto_info_128 = ··· 633 642 default: 634 643 WARN_ONCE(1, "Unsupported cipher type %u\n", 635 644 crypto_info->cipher_type); 636 - return -EOPNOTSUPP; 645 + err = -EOPNOTSUPP; 646 + goto err_cipher_type; 637 647 } 648 + 649 + dek = mlx5_ktls_create_key(priv->tls->dek_pool, crypto_info); 650 + if (IS_ERR(dek)) { 651 + err = PTR_ERR(dek); 652 + goto err_cipher_type; 653 + } 654 + priv_rx->dek = dek; 655 + 656 + INIT_LIST_HEAD(&priv_rx->list); 657 + spin_lock_init(&priv_rx->lock); 638 658 639 659 rxq = mlx5e_ktls_sk_get_rxq(sk); 640 660 priv_rx->rxq = rxq; ··· 679 677 mlx5e_tir_destroy(&priv_rx->tir); 680 678 err_create_tir: 681 679 mlx5_ktls_destroy_key(priv->tls->dek_pool, priv_rx->dek); 682 - err_create_key: 680 + err_cipher_type: 683 681 kfree(priv_rx); 684 682 return err; 685 683 }

+12 -10

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

··· 469 469 if (IS_ERR(priv_tx)) 470 470 return PTR_ERR(priv_tx); 471 471 472 - dek = mlx5_ktls_create_key(priv->tls->dek_pool, crypto_info); 473 - if (IS_ERR(dek)) { 474 - err = PTR_ERR(dek); 475 - goto err_create_key; 476 - } 477 - priv_tx->dek = dek; 478 - 479 - priv_tx->expected_seq = start_offload_tcp_sn; 480 472 switch (crypto_info->cipher_type) { 481 473 case TLS_CIPHER_AES_GCM_128: 482 474 priv_tx->crypto_info.crypto_info_128 = ··· 481 489 default: 482 490 WARN_ONCE(1, "Unsupported cipher type %u\n", 483 491 crypto_info->cipher_type); 484 - return -EOPNOTSUPP; 492 + err = -EOPNOTSUPP; 493 + goto err_pool_push; 485 494 } 495 + 496 + dek = mlx5_ktls_create_key(priv->tls->dek_pool, crypto_info); 497 + if (IS_ERR(dek)) { 498 + err = PTR_ERR(dek); 499 + goto err_pool_push; 500 + } 501 + 502 + priv_tx->dek = dek; 503 + priv_tx->expected_seq = start_offload_tcp_sn; 486 504 priv_tx->tx_ctx = tls_offload_ctx_tx(tls_ctx); 487 505 488 506 mlx5e_set_ktls_tx_priv_ctx(tls_ctx, priv_tx); ··· 502 500 503 501 return 0; 504 502 505 - err_create_key: 503 + err_pool_push: 506 504 pool_push(pool, priv_tx); 507 505 return err; 508 506 }

+1 -1

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

··· 89 89 }; 90 90 91 91 struct mlx5e_macsec_umr { 92 + u8 __aligned(64) ctx[MLX5_ST_SZ_BYTES(macsec_aso)]; 92 93 dma_addr_t dma_addr; 93 - u8 ctx[MLX5_ST_SZ_BYTES(macsec_aso)]; 94 94 u32 mkey; 95 95 }; 96 96

+9 -1

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

··· 1985 1985 struct mlx5e_priv *priv = netdev_priv(netdev); 1986 1986 struct mlx5_core_dev *mdev = priv->mdev; 1987 1987 struct mlx5e_params new_params; 1988 + int err; 1988 1989 1989 1990 if (enable) { 1990 1991 /* Checking the regular RQ here; mlx5e_validate_xsk_param called ··· 2006 2005 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_RX_STRIDING_RQ, enable); 2007 2006 mlx5e_set_rq_type(mdev, &new_params); 2008 2007 2009 - return mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, true); 2008 + err = mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, true); 2009 + if (err) 2010 + return err; 2011 + 2012 + /* update XDP supported features */ 2013 + mlx5e_set_xdp_feature(netdev); 2014 + 2015 + return 0; 2010 2016 } 2011 2017 2012 2018 static int set_pflag_rx_no_csum_complete(struct net_device *netdev, bool enable)

+34 -17

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

··· 4004 4004 return 0; 4005 4005 } 4006 4006 4007 + void mlx5e_set_xdp_feature(struct net_device *netdev) 4008 + { 4009 + struct mlx5e_priv *priv = netdev_priv(netdev); 4010 + struct mlx5e_params *params = &priv->channels.params; 4011 + xdp_features_t val; 4012 + 4013 + if (params->packet_merge.type != MLX5E_PACKET_MERGE_NONE) { 4014 + xdp_clear_features_flag(netdev); 4015 + return; 4016 + } 4017 + 4018 + val = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 4019 + NETDEV_XDP_ACT_XSK_ZEROCOPY | 4020 + NETDEV_XDP_ACT_NDO_XMIT; 4021 + if (params->rq_wq_type == MLX5_WQ_TYPE_CYCLIC) 4022 + val |= NETDEV_XDP_ACT_RX_SG; 4023 + xdp_set_features_flag(netdev, val); 4024 + } 4025 + 4007 4026 int mlx5e_set_features(struct net_device *netdev, netdev_features_t features) 4008 4027 { 4009 4028 netdev_features_t oper_features = features; ··· 4048 4029 netdev->features = oper_features; 4049 4030 return -EINVAL; 4050 4031 } 4032 + 4033 + /* update XDP supported features */ 4034 + mlx5e_set_xdp_feature(netdev); 4051 4035 4052 4036 return 0; 4053 4037 } ··· 4169 4147 struct xsk_buff_pool *xsk_pool = 4170 4148 mlx5e_xsk_get_pool(&chs->params, chs->params.xsk, ix); 4171 4149 struct mlx5e_xsk_param xsk; 4150 + int max_xdp_mtu; 4172 4151 4173 4152 if (!xsk_pool) 4174 4153 continue; 4175 4154 4176 4155 mlx5e_build_xsk_param(xsk_pool, &xsk); 4156 + max_xdp_mtu = mlx5e_xdp_max_mtu(new_params, &xsk); 4177 4157 4178 - if (!mlx5e_validate_xsk_param(new_params, &xsk, mdev)) { 4158 + /* Validate XSK params and XDP MTU in advance */ 4159 + if (!mlx5e_validate_xsk_param(new_params, &xsk, mdev) || 4160 + new_params->sw_mtu > max_xdp_mtu) { 4179 4161 u32 hr = mlx5e_get_linear_rq_headroom(new_params, &xsk); 4180 4162 int max_mtu_frame, max_mtu_page, max_mtu; 4181 4163 ··· 4189 4163 */ 4190 4164 max_mtu_frame = MLX5E_HW2SW_MTU(new_params, xsk.chunk_size - hr); 4191 4165 max_mtu_page = MLX5E_HW2SW_MTU(new_params, SKB_MAX_HEAD(0)); 4192 - max_mtu = min(max_mtu_frame, max_mtu_page); 4166 + max_mtu = min3(max_mtu_frame, max_mtu_page, max_xdp_mtu); 4193 4167 4194 - netdev_err(netdev, "MTU %d is too big for an XSK running on channel %u. Try MTU <= %d\n", 4168 + netdev_err(netdev, "MTU %d is too big for an XSK running on channel %u or its redirection XDP program. Try MTU <= %d\n", 4195 4169 new_params->sw_mtu, ix, max_mtu); 4196 4170 return false; 4197 4171 } ··· 4787 4761 if (old_prog) 4788 4762 bpf_prog_put(old_prog); 4789 4763 4790 - if (reset) { 4791 - if (prog) 4792 - xdp_features_set_redirect_target(netdev, true); 4793 - else 4794 - xdp_features_clear_redirect_target(netdev); 4795 - } 4796 - 4797 4764 if (!test_bit(MLX5E_STATE_OPENED, &priv->state) || reset) 4798 4765 goto unlock; 4799 4766 ··· 4982 4963 4983 4964 /* TX inline */ 4984 4965 mlx5_query_min_inline(mdev, &params->tx_min_inline_mode); 4985 - 4986 - params->tunneled_offload_en = mlx5_tunnel_inner_ft_supported(mdev); 4987 4966 4988 4967 /* AF_XDP */ 4989 4968 params->xsk = xsk; ··· 5180 5163 netdev->features |= NETIF_F_HIGHDMA; 5181 5164 netdev->features |= NETIF_F_HW_VLAN_STAG_FILTER; 5182 5165 5183 - netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 5184 - NETDEV_XDP_ACT_XSK_ZEROCOPY | 5185 - NETDEV_XDP_ACT_RX_SG; 5186 - 5187 5166 netdev->priv_flags |= IFF_UNICAST_FLT; 5188 5167 5189 5168 netif_set_tso_max_size(netdev, GSO_MAX_SIZE); 5169 + mlx5e_set_xdp_feature(netdev); 5190 5170 mlx5e_set_netdev_dev_addr(netdev); 5191 5171 mlx5e_macsec_build_netdev(priv); 5192 5172 mlx5e_ipsec_build_netdev(priv); ··· 5255 5241 mlx5_core_err(mdev, "TLS initialization failed, %d\n", err); 5256 5242 5257 5243 mlx5e_health_create_reporters(priv); 5244 + /* update XDP supported features */ 5245 + mlx5e_set_xdp_feature(netdev); 5246 + 5258 5247 return 0; 5259 5248 } 5260 5249 ··· 5287 5270 } 5288 5271 5289 5272 features = MLX5E_RX_RES_FEATURE_PTP; 5290 - if (priv->channels.params.tunneled_offload_en) 5273 + if (mlx5_tunnel_inner_ft_supported(mdev)) 5291 5274 features |= MLX5E_RX_RES_FEATURE_INNER_FT; 5292 5275 err = mlx5e_rx_res_init(priv->rx_res, priv->mdev, features, 5293 5276 priv->max_nch, priv->drop_rq.rqn,

+3 -1

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

··· 747 747 /* RQ */ 748 748 mlx5e_build_rq_params(mdev, params); 749 749 750 + /* update XDP supported features */ 751 + mlx5e_set_xdp_feature(netdev); 752 + 750 753 /* CQ moderation params */ 751 754 params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation); 752 755 mlx5e_set_rx_cq_mode_params(params, cq_period_mode); 753 756 754 757 params->mqprio.num_tc = 1; 755 - params->tunneled_offload_en = false; 756 758 if (rep->vport != MLX5_VPORT_UPLINK) 757 759 params->vlan_strip_disable = true; 758 760

+18 -3

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

··· 3752 3752 parse_attr->filter_dev = attr->parse_attr->filter_dev; 3753 3753 attr2->action = 0; 3754 3754 attr2->counter = NULL; 3755 - attr->tc_act_cookies_count = 0; 3755 + attr2->tc_act_cookies_count = 0; 3756 3756 attr2->flags = 0; 3757 3757 attr2->parse_attr = parse_attr; 3758 3758 attr2->dest_chain = 0; ··· 4304 4304 4305 4305 esw_attr->dest_int_port = dest_int_port; 4306 4306 esw_attr->dests[out_index].flags |= MLX5_ESW_DEST_CHAIN_WITH_SRC_PORT_CHANGE; 4307 + esw_attr->split_count = out_index; 4307 4308 4308 4309 /* Forward to root fdb for matching against the new source vport */ 4309 4310 attr->dest_chain = 0; ··· 5305 5304 mlx5e_tc_debugfs_init(tc, mlx5e_fs_get_debugfs_root(priv->fs)); 5306 5305 5307 5306 tc->action_stats_handle = mlx5e_tc_act_stats_create(); 5308 - if (IS_ERR(tc->action_stats_handle)) 5307 + if (IS_ERR(tc->action_stats_handle)) { 5308 + err = PTR_ERR(tc->action_stats_handle); 5309 5309 goto err_act_stats; 5310 + } 5310 5311 5311 5312 return 0; 5312 5313 ··· 5443 5440 } 5444 5441 5445 5442 uplink_priv->action_stats_handle = mlx5e_tc_act_stats_create(); 5446 - if (IS_ERR(uplink_priv->action_stats_handle)) 5443 + if (IS_ERR(uplink_priv->action_stats_handle)) { 5444 + err = PTR_ERR(uplink_priv->action_stats_handle); 5447 5445 goto err_action_counter; 5446 + } 5448 5447 5449 5448 return 0; 5450 5449 ··· 5468 5463 5469 5464 void mlx5e_tc_esw_cleanup(struct mlx5_rep_uplink_priv *uplink_priv) 5470 5465 { 5466 + struct mlx5e_rep_priv *rpriv; 5467 + struct mlx5_eswitch *esw; 5468 + struct mlx5e_priv *priv; 5469 + 5470 + rpriv = container_of(uplink_priv, struct mlx5e_rep_priv, uplink_priv); 5471 + priv = netdev_priv(rpriv->netdev); 5472 + esw = priv->mdev->priv.eswitch; 5473 + 5474 + mlx5e_tc_clean_fdb_peer_flows(esw); 5475 + 5471 5476 mlx5e_tc_tun_cleanup(uplink_priv->encap); 5472 5477 5473 5478 mapping_destroy(uplink_priv->tunnel_enc_opts_mapping);

+5 -5

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

··· 723 723 724 724 flow_act.action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST; 725 725 for (i = 0; i < esw_attr->split_count; i++) { 726 - if (esw_is_indir_table(esw, attr)) 727 - err = esw_setup_indir_table(dest, &flow_act, esw, attr, false, &i); 728 - else if (esw_is_chain_src_port_rewrite(esw, esw_attr)) 729 - err = esw_setup_chain_src_port_rewrite(dest, &flow_act, esw, chains, attr, 730 - &i); 726 + if (esw_attr->dests[i].flags & MLX5_ESW_DEST_CHAIN_WITH_SRC_PORT_CHANGE) 727 + /* Source port rewrite (forward to ovs internal port or statck device) isn't 728 + * supported in the rule of split action. 729 + */ 730 + err = -EOPNOTSUPP; 731 731 else 732 732 esw_setup_vport_dest(dest, &flow_act, esw, esw_attr, i, i, false); 733 733

-1

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

··· 70 70 71 71 params->packet_merge.type = MLX5E_PACKET_MERGE_NONE; 72 72 params->hard_mtu = MLX5_IB_GRH_BYTES + MLX5_IPOIB_HARD_LEN; 73 - params->tunneled_offload_en = false; 74 73 75 74 /* CQE compression is not supported for IPoIB */ 76 75 params->rx_cqe_compress_def = false;

+2 -2

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

··· 1364 1364 { 1365 1365 mlx5_devlink_traps_unregister(priv_to_devlink(dev)); 1366 1366 mlx5_sf_dev_table_destroy(dev); 1367 - mlx5_sriov_detach(dev); 1368 1367 mlx5_eswitch_disable(dev->priv.eswitch); 1368 + mlx5_sriov_detach(dev); 1369 1369 mlx5_lag_remove_mdev(dev); 1370 1370 mlx5_ec_cleanup(dev); 1371 1371 mlx5_sf_hw_table_destroy(dev); ··· 1789 1789 struct mlx5_core_dev *dev = pci_get_drvdata(pdev); 1790 1790 struct devlink *devlink = priv_to_devlink(dev); 1791 1791 1792 + set_bit(MLX5_BREAK_FW_WAIT, &dev->intf_state); 1792 1793 /* mlx5_drain_fw_reset() is using devlink APIs. Hence, we must drain 1793 1794 * fw_reset before unregistering the devlink. 1794 1795 */ 1795 1796 mlx5_drain_fw_reset(dev); 1796 - set_bit(MLX5_BREAK_FW_WAIT, &dev->intf_state); 1797 1797 devlink_unregister(devlink); 1798 1798 mlx5_sriov_disable(pdev); 1799 1799 mlx5_crdump_disable(dev);

+17 -5

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

··· 82 82 return func_id <= mlx5_core_max_vfs(dev) ? MLX5_VF : MLX5_SF; 83 83 } 84 84 85 + static u32 mlx5_get_ec_function(u32 function) 86 + { 87 + return function >> 16; 88 + } 89 + 90 + static u32 mlx5_get_func_id(u32 function) 91 + { 92 + return function & 0xffff; 93 + } 94 + 85 95 static struct rb_root *page_root_per_function(struct mlx5_core_dev *dev, u32 function) 86 96 { 87 97 struct rb_root *root; ··· 675 665 } 676 666 677 667 static int mlx5_reclaim_root_pages(struct mlx5_core_dev *dev, 678 - struct rb_root *root, u16 func_id) 668 + struct rb_root *root, u32 function) 679 669 { 680 670 u64 recl_pages_to_jiffies = msecs_to_jiffies(mlx5_tout_ms(dev, RECLAIM_PAGES)); 681 671 unsigned long end = jiffies + recl_pages_to_jiffies; 682 672 683 673 while (!RB_EMPTY_ROOT(root)) { 674 + u32 ec_function = mlx5_get_ec_function(function); 675 + u32 function_id = mlx5_get_func_id(function); 684 676 int nclaimed; 685 677 int err; 686 678 687 - err = reclaim_pages(dev, func_id, optimal_reclaimed_pages(), 688 - &nclaimed, false, mlx5_core_is_ecpf(dev)); 679 + err = reclaim_pages(dev, function_id, optimal_reclaimed_pages(), 680 + &nclaimed, false, ec_function); 689 681 if (err) { 690 - mlx5_core_warn(dev, "failed reclaiming pages (%d) for func id 0x%x\n", 691 - err, func_id); 682 + mlx5_core_warn(dev, "reclaim_pages err (%d) func_id=0x%x ec_func=0x%x\n", 683 + err, function_id, ec_function); 692 684 return err; 693 685 } 694 686

+2

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

··· 2937 2937 2938 2938 static void mlxsw_sp_parsing_init(struct mlxsw_sp *mlxsw_sp) 2939 2939 { 2940 + refcount_set(&mlxsw_sp->parsing.parsing_depth_ref, 0); 2940 2941 mlxsw_sp->parsing.parsing_depth = MLXSW_SP_DEFAULT_PARSING_DEPTH; 2941 2942 mlxsw_sp->parsing.vxlan_udp_dport = MLXSW_SP_DEFAULT_VXLAN_UDP_DPORT; 2942 2943 mutex_init(&mlxsw_sp->parsing.lock); ··· 2946 2945 static void mlxsw_sp_parsing_fini(struct mlxsw_sp *mlxsw_sp) 2947 2946 { 2948 2947 mutex_destroy(&mlxsw_sp->parsing.lock); 2948 + WARN_ON_ONCE(refcount_read(&mlxsw_sp->parsing.parsing_depth_ref)); 2949 2949 } 2950 2950 2951 2951 struct mlxsw_sp_ipv6_addr_node {

+14

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

··· 10381 10381 old_inc_parsing_depth); 10382 10382 return err; 10383 10383 } 10384 + 10385 + static void mlxsw_sp_mp_hash_fini(struct mlxsw_sp *mlxsw_sp) 10386 + { 10387 + bool old_inc_parsing_depth = mlxsw_sp->router->inc_parsing_depth; 10388 + 10389 + mlxsw_sp_mp_hash_parsing_depth_adjust(mlxsw_sp, old_inc_parsing_depth, 10390 + false); 10391 + } 10384 10392 #else 10385 10393 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp) 10386 10394 { 10387 10395 return 0; 10396 + } 10397 + 10398 + static void mlxsw_sp_mp_hash_fini(struct mlxsw_sp *mlxsw_sp) 10399 + { 10388 10400 } 10389 10401 #endif 10390 10402 ··· 10627 10615 err_register_inetaddr_notifier: 10628 10616 mlxsw_core_flush_owq(); 10629 10617 err_dscp_init: 10618 + mlxsw_sp_mp_hash_fini(mlxsw_sp); 10630 10619 err_mp_hash_init: 10631 10620 mlxsw_sp_neigh_fini(mlxsw_sp); 10632 10621 err_neigh_init: ··· 10668 10655 unregister_inet6addr_notifier(&mlxsw_sp->router->inet6addr_nb); 10669 10656 unregister_inetaddr_notifier(&mlxsw_sp->router->inetaddr_nb); 10670 10657 mlxsw_core_flush_owq(); 10658 + mlxsw_sp_mp_hash_fini(mlxsw_sp); 10671 10659 mlxsw_sp_neigh_fini(mlxsw_sp); 10672 10660 mlxsw_sp_lb_rif_fini(mlxsw_sp); 10673 10661 mlxsw_sp_vrs_fini(mlxsw_sp);

+5

drivers/net/ethernet/qlogic/qed/qed_dev.c

··· 5083 5083 5084 5084 num_vports = p_hwfn->qm_info.num_vports; 5085 5085 5086 + if (num_vports < 2) { 5087 + DP_NOTICE(p_hwfn, "Unexpected num_vports: %d\n", num_vports); 5088 + return -EINVAL; 5089 + } 5090 + 5086 5091 /* Accounting for the vports which are configured for WFQ explicitly */ 5087 5092 for (i = 0; i < num_vports; i++) { 5088 5093 u32 tmp_speed;

+1 -1

drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c

··· 422 422 if (p_time->hour > 23) 423 423 p_time->hour = 0; 424 424 if (p_time->min > 59) 425 - p_time->hour = 0; 425 + p_time->min = 0; 426 426 if (p_time->msec > 999) 427 427 p_time->msec = 0; 428 428 if (p_time->usec > 999)

+10 -2

drivers/net/ethernet/renesas/ravb_main.c

··· 1455 1455 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_100baseT_Half_BIT); 1456 1456 } 1457 1457 1458 - /* Indicate that the MAC is responsible for managing PHY PM */ 1459 - phydev->mac_managed_pm = true; 1460 1458 phy_attached_info(phydev); 1461 1459 1462 1460 return 0; ··· 2377 2379 { 2378 2380 struct platform_device *pdev = priv->pdev; 2379 2381 struct device *dev = &pdev->dev; 2382 + struct phy_device *phydev; 2383 + struct device_node *pn; 2380 2384 int error; 2381 2385 2382 2386 /* Bitbang init */ ··· 2399 2399 error = of_mdiobus_register(priv->mii_bus, dev->of_node); 2400 2400 if (error) 2401 2401 goto out_free_bus; 2402 + 2403 + pn = of_parse_phandle(dev->of_node, "phy-handle", 0); 2404 + phydev = of_phy_find_device(pn); 2405 + if (phydev) { 2406 + phydev->mac_managed_pm = true; 2407 + put_device(&phydev->mdio.dev); 2408 + } 2409 + of_node_put(pn); 2402 2410 2403 2411 return 0; 2404 2412

+14 -5

drivers/net/ethernet/renesas/rswitch.c

··· 702 702 u16 pkt_len; 703 703 u32 get_ts; 704 704 705 + if (*quota <= 0) 706 + return true; 707 + 705 708 boguscnt = min_t(int, gq->ring_size, *quota); 706 709 limit = boguscnt; 707 710 708 711 desc = &gq->rx_ring[gq->cur]; 709 712 while ((desc->desc.die_dt & DT_MASK) != DT_FEMPTY) { 710 - if (--boguscnt < 0) 711 - break; 712 713 dma_rmb(); 713 714 pkt_len = le16_to_cpu(desc->desc.info_ds) & RX_DS; 714 715 skb = gq->skbs[gq->cur]; ··· 735 734 736 735 gq->cur = rswitch_next_queue_index(gq, true, 1); 737 736 desc = &gq->rx_ring[gq->cur]; 737 + 738 + if (--boguscnt <= 0) 739 + break; 738 740 } 739 741 740 742 num = rswitch_get_num_cur_queues(gq); ··· 749 745 goto err; 750 746 gq->dirty = rswitch_next_queue_index(gq, false, num); 751 747 752 - *quota -= limit - (++boguscnt); 748 + *quota -= limit - boguscnt; 753 749 754 750 return boguscnt <= 0; 755 751 ··· 1441 1437 rswitch_enadis_data_irq(rdev->priv, rdev->tx_queue->index, true); 1442 1438 rswitch_enadis_data_irq(rdev->priv, rdev->rx_queue->index, true); 1443 1439 1444 - iowrite32(GWCA_TS_IRQ_BIT, rdev->priv->addr + GWTSDIE); 1440 + if (bitmap_empty(rdev->priv->opened_ports, RSWITCH_NUM_PORTS)) 1441 + iowrite32(GWCA_TS_IRQ_BIT, rdev->priv->addr + GWTSDIE); 1442 + 1443 + bitmap_set(rdev->priv->opened_ports, rdev->port, 1); 1445 1444 1446 1445 return 0; 1447 1446 }; ··· 1455 1448 struct rswitch_gwca_ts_info *ts_info, *ts_info2; 1456 1449 1457 1450 netif_tx_stop_all_queues(ndev); 1451 + bitmap_clear(rdev->priv->opened_ports, rdev->port, 1); 1458 1452 1459 - iowrite32(GWCA_TS_IRQ_BIT, rdev->priv->addr + GWTSDID); 1453 + if (bitmap_empty(rdev->priv->opened_ports, RSWITCH_NUM_PORTS)) 1454 + iowrite32(GWCA_TS_IRQ_BIT, rdev->priv->addr + GWTSDID); 1460 1455 1461 1456 list_for_each_entry_safe(ts_info, ts_info2, &rdev->priv->gwca.ts_info_list, list) { 1462 1457 if (ts_info->port != rdev->port)

+1

drivers/net/ethernet/renesas/rswitch.h

··· 998 998 struct rcar_gen4_ptp_private *ptp_priv; 999 999 1000 1000 struct rswitch_device *rdev[RSWITCH_NUM_PORTS]; 1001 + DECLARE_BITMAP(opened_ports, RSWITCH_NUM_PORTS); 1001 1002 1002 1003 struct rswitch_gwca gwca; 1003 1004 struct rswitch_etha etha[RSWITCH_NUM_PORTS];

+10 -2

drivers/net/ethernet/renesas/sh_eth.c

··· 2029 2029 if (mdp->cd->register_type != SH_ETH_REG_GIGABIT) 2030 2030 phy_set_max_speed(phydev, SPEED_100); 2031 2031 2032 - /* Indicate that the MAC is responsible for managing PHY PM */ 2033 - phydev->mac_managed_pm = true; 2034 2032 phy_attached_info(phydev); 2035 2033 2036 2034 return 0; ··· 3095 3097 struct bb_info *bitbang; 3096 3098 struct platform_device *pdev = mdp->pdev; 3097 3099 struct device *dev = &mdp->pdev->dev; 3100 + struct phy_device *phydev; 3101 + struct device_node *pn; 3098 3102 3099 3103 /* create bit control struct for PHY */ 3100 3104 bitbang = devm_kzalloc(dev, sizeof(struct bb_info), GFP_KERNEL); ··· 3132 3132 ret = of_mdiobus_register(mdp->mii_bus, dev->of_node); 3133 3133 if (ret) 3134 3134 goto out_free_bus; 3135 + 3136 + pn = of_parse_phandle(dev->of_node, "phy-handle", 0); 3137 + phydev = of_phy_find_device(pn); 3138 + if (phydev) { 3139 + phydev->mac_managed_pm = true; 3140 + put_device(&phydev->mdio.dev); 3141 + } 3142 + of_node_put(pn); 3135 3143 3136 3144 return 0; 3137 3145

+1 -2

drivers/net/ethernet/stmicro/stmmac/dwmac-imx.c

··· 213 213 struct device_node *np = dev->of_node; 214 214 int err = 0; 215 215 216 - if (of_get_property(np, "snps,rmii_refclk_ext", NULL)) 217 - dwmac->rmii_refclk_ext = true; 216 + dwmac->rmii_refclk_ext = of_property_read_bool(np, "snps,rmii_refclk_ext"); 218 217 219 218 dwmac->clk_tx = devm_clk_get(dev, "tx"); 220 219 if (IS_ERR(dwmac->clk_tx)) {

+3

drivers/net/ethernet/sun/ldmvsw.c

··· 287 287 288 288 hp = mdesc_grab(); 289 289 290 + if (!hp) 291 + return -ENODEV; 292 + 290 293 rmac = mdesc_get_property(hp, vdev->mp, remote_macaddr_prop, &len); 291 294 err = -ENODEV; 292 295 if (!rmac) {

+1 -1

drivers/net/ethernet/sun/niu.c

··· 9271 9271 if (model) 9272 9272 strcpy(np->vpd.model, model); 9273 9273 9274 - if (of_find_property(dp, "hot-swappable-phy", NULL)) { 9274 + if (of_property_read_bool(dp, "hot-swappable-phy")) { 9275 9275 np->flags |= (NIU_FLAGS_10G | NIU_FLAGS_FIBER | 9276 9276 NIU_FLAGS_HOTPLUG_PHY); 9277 9277 }

+3

drivers/net/ethernet/sun/sunvnet.c

··· 433 433 434 434 hp = mdesc_grab(); 435 435 436 + if (!hp) 437 + return -ENODEV; 438 + 436 439 vp = vnet_find_parent(hp, vdev->mp, vdev); 437 440 if (IS_ERR(vp)) { 438 441 pr_err("Cannot find port parent vnet\n");

+1 -2

drivers/net/ethernet/ti/cpsw-phy-sel.c

··· 226 226 if (IS_ERR(priv->gmii_sel)) 227 227 return PTR_ERR(priv->gmii_sel); 228 228 229 - if (of_find_property(pdev->dev.of_node, "rmii-clock-ext", NULL)) 230 - priv->rmii_clock_external = true; 229 + priv->rmii_clock_external = of_property_read_bool(pdev->dev.of_node, "rmii-clock-ext"); 231 230 232 231 dev_set_drvdata(&pdev->dev, priv); 233 232

+3 -5

drivers/net/ethernet/ti/netcp_ethss.c

··· 3583 3583 /* init the hw stats lock */ 3584 3584 spin_lock_init(&gbe_dev->hw_stats_lock); 3585 3585 3586 - if (of_find_property(node, "enable-ale", NULL)) { 3587 - gbe_dev->enable_ale = true; 3586 + gbe_dev->enable_ale = of_property_read_bool(node, "enable-ale"); 3587 + if (gbe_dev->enable_ale) 3588 3588 dev_info(dev, "ALE enabled\n"); 3589 - } else { 3590 - gbe_dev->enable_ale = false; 3589 + else 3591 3590 dev_dbg(dev, "ALE bypass enabled*\n"); 3592 - } 3593 3591 3594 3592 ret = of_property_read_u32(node, "tx-queue", 3595 3593 &gbe_dev->tx_queue_id);

+1 -2

drivers/net/ethernet/via/via-velocity.c

··· 2709 2709 struct resource res; 2710 2710 int ret; 2711 2711 2712 - if (of_get_property(vptr->dev->of_node, "no-eeprom", NULL)) 2713 - vptr->no_eeprom = 1; 2712 + vptr->no_eeprom = of_property_read_bool(vptr->dev->of_node, "no-eeprom"); 2714 2713 2715 2714 ret = of_address_to_resource(vptr->dev->of_node, 0, &res); 2716 2715 if (ret) {

+1 -1

drivers/net/ethernet/via/via-velocity.h

··· 1383 1383 struct device *dev; 1384 1384 struct pci_dev *pdev; 1385 1385 struct net_device *netdev; 1386 - int no_eeprom; 1386 + bool no_eeprom; 1387 1387 1388 1388 unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)]; 1389 1389 u8 ip_addr[4];

+4 -5

drivers/net/ethernet/xilinx/ll_temac_main.c

··· 1455 1455 * endianness mode. Default for OF devices is big-endian. 1456 1456 */ 1457 1457 little_endian = false; 1458 - if (temac_np) { 1459 - if (of_get_property(temac_np, "little-endian", NULL)) 1460 - little_endian = true; 1461 - } else if (pdata) { 1458 + if (temac_np) 1459 + little_endian = of_property_read_bool(temac_np, "little-endian"); 1460 + else if (pdata) 1462 1461 little_endian = pdata->reg_little_endian; 1463 - } 1462 + 1464 1463 if (little_endian) { 1465 1464 lp->temac_ior = _temac_ior_le; 1466 1465 lp->temac_iow = _temac_iow_le;

+8 -1

drivers/net/ipa/gsi_reg.c

··· 15 15 switch (reg_id) { 16 16 case INTER_EE_SRC_CH_IRQ_MSK: 17 17 case INTER_EE_SRC_EV_CH_IRQ_MSK: 18 + return gsi->version >= IPA_VERSION_3_5; 19 + 20 + case HW_PARAM_2: 21 + return gsi->version >= IPA_VERSION_3_5_1; 22 + 23 + case HW_PARAM_4: 24 + return gsi->version >= IPA_VERSION_5_0; 25 + 18 26 case CH_C_CNTXT_0: 19 27 case CH_C_CNTXT_1: 20 28 case CH_C_CNTXT_2: ··· 51 43 case CH_CMD: 52 44 case EV_CH_CMD: 53 45 case GENERIC_CMD: 54 - case HW_PARAM_2: 55 46 case CNTXT_TYPE_IRQ: 56 47 case CNTXT_TYPE_IRQ_MSK: 57 48 case CNTXT_SRC_CH_IRQ:

+4

drivers/net/ipa/gsi_reg.h

··· 10 10 11 11 #include <linux/bits.h> 12 12 13 + struct platform_device; 14 + 15 + struct gsi; 16 + 13 17 /** 14 18 * DOC: GSI Registers 15 19 *

+18 -10

drivers/net/ipa/ipa_reg.c

··· 1 1 // SPDX-License-Identifier: GPL-2.0 2 2 3 3 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. 4 - * Copyright (C) 2019-2022 Linaro Ltd. 4 + * Copyright (C) 2019-2023 Linaro Ltd. 5 5 */ 6 6 7 7 #include <linux/io.h> ··· 15 15 enum ipa_version version = ipa->version; 16 16 17 17 switch (reg_id) { 18 + case FILT_ROUT_HASH_EN: 19 + return version == IPA_VERSION_4_2; 20 + 21 + case FILT_ROUT_HASH_FLUSH: 22 + return version < IPA_VERSION_5_0 && version != IPA_VERSION_4_2; 23 + 24 + case FILT_ROUT_CACHE_FLUSH: 25 + case ENDP_FILTER_CACHE_CFG: 26 + case ENDP_ROUTER_CACHE_CFG: 27 + return version >= IPA_VERSION_5_0; 28 + 18 29 case IPA_BCR: 19 30 case COUNTER_CFG: 20 31 return version < IPA_VERSION_4_5; ··· 43 32 case SRC_RSRC_GRP_45_RSRC_TYPE: 44 33 case DST_RSRC_GRP_45_RSRC_TYPE: 45 34 return version <= IPA_VERSION_3_1 || 46 - version == IPA_VERSION_4_5; 35 + version == IPA_VERSION_4_5 || 36 + version == IPA_VERSION_5_0; 47 37 48 38 case SRC_RSRC_GRP_67_RSRC_TYPE: 49 39 case DST_RSRC_GRP_67_RSRC_TYPE: 50 - return version <= IPA_VERSION_3_1; 40 + return version <= IPA_VERSION_3_1 || 41 + version == IPA_VERSION_5_0; 51 42 52 43 case ENDP_FILTER_ROUTER_HSH_CFG: 53 - return version != IPA_VERSION_4_2; 44 + return version < IPA_VERSION_5_0 && 45 + version != IPA_VERSION_4_2; 54 46 55 47 case IRQ_SUSPEND_EN: 56 48 case IRQ_SUSPEND_CLR: ··· 65 51 case SHARED_MEM_SIZE: 66 52 case QSB_MAX_WRITES: 67 53 case QSB_MAX_READS: 68 - case FILT_ROUT_HASH_EN: 69 - case FILT_ROUT_CACHE_CFG: 70 - case FILT_ROUT_HASH_FLUSH: 71 - case FILT_ROUT_CACHE_FLUSH: 72 54 case STATE_AGGR_ACTIVE: 73 55 case LOCAL_PKT_PROC_CNTXT: 74 56 case AGGR_FORCE_CLOSE: ··· 86 76 case ENDP_INIT_RSRC_GRP: 87 77 case ENDP_INIT_SEQ: 88 78 case ENDP_STATUS: 89 - case ENDP_FILTER_CACHE_CFG: 90 - case ENDP_ROUTER_CACHE_CFG: 91 79 case IPA_IRQ_STTS: 92 80 case IPA_IRQ_EN: 93 81 case IPA_IRQ_CLR:

+6 -15

drivers/net/ipa/ipa_reg.h

··· 60 60 SHARED_MEM_SIZE, 61 61 QSB_MAX_WRITES, 62 62 QSB_MAX_READS, 63 - FILT_ROUT_HASH_EN, /* Not IPA v5.0+ */ 64 - FILT_ROUT_CACHE_CFG, /* IPA v5.0+ */ 65 - FILT_ROUT_HASH_FLUSH, /* Not IPA v5.0+ */ 63 + FILT_ROUT_HASH_EN, /* IPA v4.2 */ 64 + FILT_ROUT_HASH_FLUSH, /* Not IPA v4.2 nor IPA v5.0+ */ 66 65 FILT_ROUT_CACHE_FLUSH, /* IPA v5.0+ */ 67 66 STATE_AGGR_ACTIVE, 68 67 IPA_BCR, /* Not IPA v4.5+ */ ··· 76 77 TIMERS_PULSE_GRAN_CFG, /* IPA v4.5+ */ 77 78 SRC_RSRC_GRP_01_RSRC_TYPE, 78 79 SRC_RSRC_GRP_23_RSRC_TYPE, 79 - SRC_RSRC_GRP_45_RSRC_TYPE, /* Not IPA v3.5+, IPA v4.5 */ 80 - SRC_RSRC_GRP_67_RSRC_TYPE, /* Not IPA v3.5+ */ 80 + SRC_RSRC_GRP_45_RSRC_TYPE, /* Not IPA v3.5+; IPA v4.5, IPA v5.0 */ 81 + SRC_RSRC_GRP_67_RSRC_TYPE, /* Not IPA v3.5+; IPA v5.0 */ 81 82 DST_RSRC_GRP_01_RSRC_TYPE, 82 83 DST_RSRC_GRP_23_RSRC_TYPE, 83 - DST_RSRC_GRP_45_RSRC_TYPE, /* Not IPA v3.5+, IPA v4.5 */ 84 - DST_RSRC_GRP_67_RSRC_TYPE, /* Not IPA v3.5+ */ 84 + DST_RSRC_GRP_45_RSRC_TYPE, /* Not IPA v3.5+; IPA v4.5, IPA v5.0 */ 85 + DST_RSRC_GRP_67_RSRC_TYPE, /* Not IPA v3.5+; IPA v5.0 */ 85 86 ENDP_INIT_CTRL, /* Not IPA v4.2+ for TX, not IPA v4.0+ for RX */ 86 87 ENDP_INIT_CFG, 87 88 ENDP_INIT_NAT, /* TX only */ ··· 203 204 GEN_QMB_1_MAX_READS, 204 205 GEN_QMB_0_MAX_READS_BEATS, /* IPA v4.0+ */ 205 206 GEN_QMB_1_MAX_READS_BEATS, /* IPA v4.0+ */ 206 - }; 207 - 208 - /* FILT_ROUT_CACHE_CFG register */ 209 - enum ipa_reg_filt_rout_cache_cfg_field_id { 210 - ROUTER_CACHE_EN, 211 - FILTER_CACHE_EN, 212 - LOW_PRI_HASH_HIT_DISABLE, 213 - LRU_EVICTION_THRESHOLD, 214 207 }; 215 208 216 209 /* FILT_ROUT_HASH_EN and FILT_ROUT_HASH_FLUSH registers */

+2 -1

drivers/net/ipa/reg.h

··· 6 6 #define _REG_H_ 7 7 8 8 #include <linux/types.h> 9 - #include <linux/bits.h> 9 + #include <linux/log2.h> 10 + #include <linux/bug.h> 10 11 11 12 /** 12 13 * struct reg - A register descriptor

+28 -28

drivers/net/ipa/reg/gsi_reg-v4.5.c

··· 137 137 0x0001004c + 0x4000 * GSI_EE_AP, 0x80); 138 138 139 139 REG_STRIDE(CH_C_DOORBELL_0, ch_c_doorbell_0, 140 - 0x0001e000 + 0x4000 * GSI_EE_AP, 0x08); 140 + 0x00011000 + 0x4000 * GSI_EE_AP, 0x08); 141 141 142 142 REG_STRIDE(EV_CH_E_DOORBELL_0, ev_ch_e_doorbell_0, 143 - 0x0001e100 + 0x4000 * GSI_EE_AP, 0x08); 143 + 0x00011100 + 0x4000 * GSI_EE_AP, 0x08); 144 144 145 145 static const u32 reg_gsi_status_fmask[] = { 146 146 [ENABLED] = BIT(0), 147 147 /* Bits 1-31 reserved */ 148 148 }; 149 149 150 - REG_FIELDS(GSI_STATUS, gsi_status, 0x0001f000 + 0x4000 * GSI_EE_AP); 150 + REG_FIELDS(GSI_STATUS, gsi_status, 0x00012000 + 0x4000 * GSI_EE_AP); 151 151 152 152 static const u32 reg_ch_cmd_fmask[] = { 153 153 [CH_CHID] = GENMASK(7, 0), ··· 155 155 [CH_OPCODE] = GENMASK(31, 24), 156 156 }; 157 157 158 - REG_FIELDS(CH_CMD, ch_cmd, 0x0001f008 + 0x4000 * GSI_EE_AP); 158 + REG_FIELDS(CH_CMD, ch_cmd, 0x00012008 + 0x4000 * GSI_EE_AP); 159 159 160 160 static const u32 reg_ev_ch_cmd_fmask[] = { 161 161 [EV_CHID] = GENMASK(7, 0), ··· 163 163 [EV_OPCODE] = GENMASK(31, 24), 164 164 }; 165 165 166 - REG_FIELDS(EV_CH_CMD, ev_ch_cmd, 0x0001f010 + 0x4000 * GSI_EE_AP); 166 + REG_FIELDS(EV_CH_CMD, ev_ch_cmd, 0x00012010 + 0x4000 * GSI_EE_AP); 167 167 168 168 static const u32 reg_generic_cmd_fmask[] = { 169 169 [GENERIC_OPCODE] = GENMASK(4, 0), ··· 172 172 /* Bits 14-31 reserved */ 173 173 }; 174 174 175 - REG_FIELDS(GENERIC_CMD, generic_cmd, 0x0001f018 + 0x4000 * GSI_EE_AP); 175 + REG_FIELDS(GENERIC_CMD, generic_cmd, 0x00012018 + 0x4000 * GSI_EE_AP); 176 176 177 177 static const u32 reg_hw_param_2_fmask[] = { 178 178 [IRAM_SIZE] = GENMASK(2, 0), ··· 188 188 [GSI_USE_INTER_EE] = BIT(31), 189 189 }; 190 190 191 - REG_FIELDS(HW_PARAM_2, hw_param_2, 0x0001f040 + 0x4000 * GSI_EE_AP); 191 + REG_FIELDS(HW_PARAM_2, hw_param_2, 0x00012040 + 0x4000 * GSI_EE_AP); 192 192 193 - REG(CNTXT_TYPE_IRQ, cntxt_type_irq, 0x0001f080 + 0x4000 * GSI_EE_AP); 193 + REG(CNTXT_TYPE_IRQ, cntxt_type_irq, 0x00012080 + 0x4000 * GSI_EE_AP); 194 194 195 - REG(CNTXT_TYPE_IRQ_MSK, cntxt_type_irq_msk, 0x0001f088 + 0x4000 * GSI_EE_AP); 195 + REG(CNTXT_TYPE_IRQ_MSK, cntxt_type_irq_msk, 0x00012088 + 0x4000 * GSI_EE_AP); 196 196 197 - REG(CNTXT_SRC_CH_IRQ, cntxt_src_ch_irq, 0x0001f090 + 0x4000 * GSI_EE_AP); 197 + REG(CNTXT_SRC_CH_IRQ, cntxt_src_ch_irq, 0x00012090 + 0x4000 * GSI_EE_AP); 198 198 199 - REG(CNTXT_SRC_EV_CH_IRQ, cntxt_src_ev_ch_irq, 0x0001f094 + 0x4000 * GSI_EE_AP); 199 + REG(CNTXT_SRC_EV_CH_IRQ, cntxt_src_ev_ch_irq, 0x00012094 + 0x4000 * GSI_EE_AP); 200 200 201 201 REG(CNTXT_SRC_CH_IRQ_MSK, cntxt_src_ch_irq_msk, 202 - 0x0001f098 + 0x4000 * GSI_EE_AP); 202 + 0x00012098 + 0x4000 * GSI_EE_AP); 203 203 204 204 REG(CNTXT_SRC_EV_CH_IRQ_MSK, cntxt_src_ev_ch_irq_msk, 205 - 0x0001f09c + 0x4000 * GSI_EE_AP); 205 + 0x0001209c + 0x4000 * GSI_EE_AP); 206 206 207 207 REG(CNTXT_SRC_CH_IRQ_CLR, cntxt_src_ch_irq_clr, 208 - 0x0001f0a0 + 0x4000 * GSI_EE_AP); 208 + 0x000120a0 + 0x4000 * GSI_EE_AP); 209 209 210 210 REG(CNTXT_SRC_EV_CH_IRQ_CLR, cntxt_src_ev_ch_irq_clr, 211 - 0x0001f0a4 + 0x4000 * GSI_EE_AP); 211 + 0x000120a4 + 0x4000 * GSI_EE_AP); 212 212 213 - REG(CNTXT_SRC_IEOB_IRQ, cntxt_src_ieob_irq, 0x0001f0b0 + 0x4000 * GSI_EE_AP); 213 + REG(CNTXT_SRC_IEOB_IRQ, cntxt_src_ieob_irq, 0x000120b0 + 0x4000 * GSI_EE_AP); 214 214 215 215 REG(CNTXT_SRC_IEOB_IRQ_MSK, cntxt_src_ieob_irq_msk, 216 - 0x0001f0b8 + 0x4000 * GSI_EE_AP); 216 + 0x000120b8 + 0x4000 * GSI_EE_AP); 217 217 218 218 REG(CNTXT_SRC_IEOB_IRQ_CLR, cntxt_src_ieob_irq_clr, 219 - 0x0001f0c0 + 0x4000 * GSI_EE_AP); 219 + 0x000120c0 + 0x4000 * GSI_EE_AP); 220 220 221 - REG(CNTXT_GLOB_IRQ_STTS, cntxt_glob_irq_stts, 0x0001f100 + 0x4000 * GSI_EE_AP); 221 + REG(CNTXT_GLOB_IRQ_STTS, cntxt_glob_irq_stts, 0x00012100 + 0x4000 * GSI_EE_AP); 222 222 223 - REG(CNTXT_GLOB_IRQ_EN, cntxt_glob_irq_en, 0x0001f108 + 0x4000 * GSI_EE_AP); 223 + REG(CNTXT_GLOB_IRQ_EN, cntxt_glob_irq_en, 0x00012108 + 0x4000 * GSI_EE_AP); 224 224 225 - REG(CNTXT_GLOB_IRQ_CLR, cntxt_glob_irq_clr, 0x0001f110 + 0x4000 * GSI_EE_AP); 225 + REG(CNTXT_GLOB_IRQ_CLR, cntxt_glob_irq_clr, 0x00012110 + 0x4000 * GSI_EE_AP); 226 226 227 - REG(CNTXT_GSI_IRQ_STTS, cntxt_gsi_irq_stts, 0x0001f118 + 0x4000 * GSI_EE_AP); 227 + REG(CNTXT_GSI_IRQ_STTS, cntxt_gsi_irq_stts, 0x00012118 + 0x4000 * GSI_EE_AP); 228 228 229 - REG(CNTXT_GSI_IRQ_EN, cntxt_gsi_irq_en, 0x0001f120 + 0x4000 * GSI_EE_AP); 229 + REG(CNTXT_GSI_IRQ_EN, cntxt_gsi_irq_en, 0x00012120 + 0x4000 * GSI_EE_AP); 230 230 231 - REG(CNTXT_GSI_IRQ_CLR, cntxt_gsi_irq_clr, 0x0001f128 + 0x4000 * GSI_EE_AP); 231 + REG(CNTXT_GSI_IRQ_CLR, cntxt_gsi_irq_clr, 0x00012128 + 0x4000 * GSI_EE_AP); 232 232 233 233 static const u32 reg_cntxt_intset_fmask[] = { 234 234 [INTYPE] = BIT(0) 235 235 /* Bits 1-31 reserved */ 236 236 }; 237 237 238 - REG_FIELDS(CNTXT_INTSET, cntxt_intset, 0x0001f180 + 0x4000 * GSI_EE_AP); 238 + REG_FIELDS(CNTXT_INTSET, cntxt_intset, 0x00012180 + 0x4000 * GSI_EE_AP); 239 239 240 - REG_FIELDS(ERROR_LOG, error_log, 0x0001f200 + 0x4000 * GSI_EE_AP); 240 + REG_FIELDS(ERROR_LOG, error_log, 0x00012200 + 0x4000 * GSI_EE_AP); 241 241 242 - REG(ERROR_LOG_CLR, error_log_clr, 0x0001f210 + 0x4000 * GSI_EE_AP); 242 + REG(ERROR_LOG_CLR, error_log_clr, 0x00012210 + 0x4000 * GSI_EE_AP); 243 243 244 244 static const u32 reg_cntxt_scratch_0_fmask[] = { 245 245 [INTER_EE_RESULT] = GENMASK(2, 0), ··· 248 248 /* Bits 8-31 reserved */ 249 249 }; 250 250 251 - REG_FIELDS(CNTXT_SCRATCH_0, cntxt_scratch_0, 0x0001f400 + 0x4000 * GSI_EE_AP); 251 + REG_FIELDS(CNTXT_SCRATCH_0, cntxt_scratch_0, 0x00012400 + 0x4000 * GSI_EE_AP); 252 252 253 253 static const struct reg *reg_array[] = { 254 254 [INTER_EE_SRC_CH_IRQ_MSK] = &reg_inter_ee_src_ch_irq_msk,

+22 -22

drivers/net/ipa/reg/gsi_reg-v4.9.c

··· 27 27 }; 28 28 29 29 REG_STRIDE_FIELDS(CH_C_CNTXT_0, ch_c_cntxt_0, 30 - 0x0001c000 + 0x4000 * GSI_EE_AP, 0x80); 30 + 0x0000f000 + 0x4000 * GSI_EE_AP, 0x80); 31 31 32 32 static const u32 reg_ch_c_cntxt_1_fmask[] = { 33 33 [CH_R_LENGTH] = GENMASK(19, 0), ··· 35 35 }; 36 36 37 37 REG_STRIDE_FIELDS(CH_C_CNTXT_1, ch_c_cntxt_1, 38 - 0x0001c004 + 0x4000 * GSI_EE_AP, 0x80); 38 + 0x0000f004 + 0x4000 * GSI_EE_AP, 0x80); 39 39 40 - REG_STRIDE(CH_C_CNTXT_2, ch_c_cntxt_2, 0x0001c008 + 0x4000 * GSI_EE_AP, 0x80); 40 + REG_STRIDE(CH_C_CNTXT_2, ch_c_cntxt_2, 0x0000f008 + 0x4000 * GSI_EE_AP, 0x80); 41 41 42 - REG_STRIDE(CH_C_CNTXT_3, ch_c_cntxt_3, 0x0001c00c + 0x4000 * GSI_EE_AP, 0x80); 42 + REG_STRIDE(CH_C_CNTXT_3, ch_c_cntxt_3, 0x0000f00c + 0x4000 * GSI_EE_AP, 0x80); 43 43 44 44 static const u32 reg_ch_c_qos_fmask[] = { 45 45 [WRR_WEIGHT] = GENMASK(3, 0), ··· 53 53 /* Bits 25-31 reserved */ 54 54 }; 55 55 56 - REG_STRIDE_FIELDS(CH_C_QOS, ch_c_qos, 0x0001c05c + 0x4000 * GSI_EE_AP, 0x80); 56 + REG_STRIDE_FIELDS(CH_C_QOS, ch_c_qos, 0x0000f05c + 0x4000 * GSI_EE_AP, 0x80); 57 57 58 58 static const u32 reg_error_log_fmask[] = { 59 59 [ERR_ARG3] = GENMASK(3, 0), ··· 67 67 }; 68 68 69 69 REG_STRIDE(CH_C_SCRATCH_0, ch_c_scratch_0, 70 - 0x0001c060 + 0x4000 * GSI_EE_AP, 0x80); 70 + 0x0000f060 + 0x4000 * GSI_EE_AP, 0x80); 71 71 72 72 REG_STRIDE(CH_C_SCRATCH_1, ch_c_scratch_1, 73 - 0x0001c064 + 0x4000 * GSI_EE_AP, 0x80); 73 + 0x0000f064 + 0x4000 * GSI_EE_AP, 0x80); 74 74 75 75 REG_STRIDE(CH_C_SCRATCH_2, ch_c_scratch_2, 76 - 0x0001c068 + 0x4000 * GSI_EE_AP, 0x80); 76 + 0x0000f068 + 0x4000 * GSI_EE_AP, 0x80); 77 77 78 78 REG_STRIDE(CH_C_SCRATCH_3, ch_c_scratch_3, 79 - 0x0001c06c + 0x4000 * GSI_EE_AP, 0x80); 79 + 0x0000f06c + 0x4000 * GSI_EE_AP, 0x80); 80 80 81 81 static const u32 reg_ev_ch_e_cntxt_0_fmask[] = { 82 82 [EV_CHTYPE] = GENMASK(3, 0), ··· 89 89 }; 90 90 91 91 REG_STRIDE_FIELDS(EV_CH_E_CNTXT_0, ev_ch_e_cntxt_0, 92 - 0x0001d000 + 0x4000 * GSI_EE_AP, 0x80); 92 + 0x00010000 + 0x4000 * GSI_EE_AP, 0x80); 93 93 94 94 static const u32 reg_ev_ch_e_cntxt_1_fmask[] = { 95 95 [R_LENGTH] = GENMASK(15, 0), 96 96 }; 97 97 98 98 REG_STRIDE_FIELDS(EV_CH_E_CNTXT_1, ev_ch_e_cntxt_1, 99 - 0x0001d004 + 0x4000 * GSI_EE_AP, 0x80); 99 + 0x00010004 + 0x4000 * GSI_EE_AP, 0x80); 100 100 101 101 REG_STRIDE(EV_CH_E_CNTXT_2, ev_ch_e_cntxt_2, 102 - 0x0001d008 + 0x4000 * GSI_EE_AP, 0x80); 102 + 0x00010008 + 0x4000 * GSI_EE_AP, 0x80); 103 103 104 104 REG_STRIDE(EV_CH_E_CNTXT_3, ev_ch_e_cntxt_3, 105 - 0x0001d00c + 0x4000 * GSI_EE_AP, 0x80); 105 + 0x0001000c + 0x4000 * GSI_EE_AP, 0x80); 106 106 107 107 REG_STRIDE(EV_CH_E_CNTXT_4, ev_ch_e_cntxt_4, 108 - 0x0001d010 + 0x4000 * GSI_EE_AP, 0x80); 108 + 0x00010010 + 0x4000 * GSI_EE_AP, 0x80); 109 109 110 110 static const u32 reg_ev_ch_e_cntxt_8_fmask[] = { 111 111 [EV_MODT] = GENMASK(15, 0), ··· 114 114 }; 115 115 116 116 REG_STRIDE_FIELDS(EV_CH_E_CNTXT_8, ev_ch_e_cntxt_8, 117 - 0x0001d020 + 0x4000 * GSI_EE_AP, 0x80); 117 + 0x00010020 + 0x4000 * GSI_EE_AP, 0x80); 118 118 119 119 REG_STRIDE(EV_CH_E_CNTXT_9, ev_ch_e_cntxt_9, 120 - 0x0001d024 + 0x4000 * GSI_EE_AP, 0x80); 120 + 0x00010024 + 0x4000 * GSI_EE_AP, 0x80); 121 121 122 122 REG_STRIDE(EV_CH_E_CNTXT_10, ev_ch_e_cntxt_10, 123 - 0x0001d028 + 0x4000 * GSI_EE_AP, 0x80); 123 + 0x00010028 + 0x4000 * GSI_EE_AP, 0x80); 124 124 125 125 REG_STRIDE(EV_CH_E_CNTXT_11, ev_ch_e_cntxt_11, 126 - 0x0001d02c + 0x4000 * GSI_EE_AP, 0x80); 126 + 0x0001002c + 0x4000 * GSI_EE_AP, 0x80); 127 127 128 128 REG_STRIDE(EV_CH_E_CNTXT_12, ev_ch_e_cntxt_12, 129 - 0x0001d030 + 0x4000 * GSI_EE_AP, 0x80); 129 + 0x00010030 + 0x4000 * GSI_EE_AP, 0x80); 130 130 131 131 REG_STRIDE(EV_CH_E_CNTXT_13, ev_ch_e_cntxt_13, 132 - 0x0001d034 + 0x4000 * GSI_EE_AP, 0x80); 132 + 0x00010034 + 0x4000 * GSI_EE_AP, 0x80); 133 133 134 134 REG_STRIDE(EV_CH_E_SCRATCH_0, ev_ch_e_scratch_0, 135 - 0x0001d048 + 0x4000 * GSI_EE_AP, 0x80); 135 + 0x00010048 + 0x4000 * GSI_EE_AP, 0x80); 136 136 137 137 REG_STRIDE(EV_CH_E_SCRATCH_1, ev_ch_e_scratch_1, 138 - 0x0001d04c + 0x4000 * GSI_EE_AP, 0x80); 138 + 0x0001004c + 0x4000 * GSI_EE_AP, 0x80); 139 139 140 140 REG_STRIDE(CH_C_DOORBELL_0, ch_c_doorbell_0, 141 141 0x00011000 + 0x4000 * GSI_EE_AP, 0x08);

+1

drivers/net/ipvlan/ipvlan_l3s.c

··· 101 101 goto out; 102 102 103 103 skb->dev = addr->master->dev; 104 + skb->skb_iif = skb->dev->ifindex; 104 105 len = skb->len + ETH_HLEN; 105 106 ipvlan_count_rx(addr->master, len, true, false); 106 107 out:

+8 -16

drivers/net/phy/mscc/mscc_main.c

··· 280 280 u16 pwd[3] = {0, 0, 0}; 281 281 struct ethtool_wolinfo *wol_conf = wol; 282 282 283 - mutex_lock(&phydev->lock); 284 283 rc = phy_select_page(phydev, MSCC_PHY_PAGE_EXTENDED_2); 285 - if (rc < 0) { 286 - rc = phy_restore_page(phydev, rc, rc); 287 - goto out_unlock; 288 - } 284 + if (rc < 0) 285 + return phy_restore_page(phydev, rc, rc); 289 286 290 287 if (wol->wolopts & WAKE_MAGIC) { 291 288 /* Store the device address for the magic packet */ ··· 320 323 321 324 rc = phy_restore_page(phydev, rc, rc > 0 ? 0 : rc); 322 325 if (rc < 0) 323 - goto out_unlock; 326 + return rc; 324 327 325 328 if (wol->wolopts & WAKE_MAGIC) { 326 329 /* Enable the WOL interrupt */ ··· 328 331 reg_val |= MII_VSC85XX_INT_MASK_WOL; 329 332 rc = phy_write(phydev, MII_VSC85XX_INT_MASK, reg_val); 330 333 if (rc) 331 - goto out_unlock; 334 + return rc; 332 335 } else { 333 336 /* Disable the WOL interrupt */ 334 337 reg_val = phy_read(phydev, MII_VSC85XX_INT_MASK); 335 338 reg_val &= (~MII_VSC85XX_INT_MASK_WOL); 336 339 rc = phy_write(phydev, MII_VSC85XX_INT_MASK, reg_val); 337 340 if (rc) 338 - goto out_unlock; 341 + return rc; 339 342 } 340 343 /* Clear WOL iterrupt status */ 341 344 reg_val = phy_read(phydev, MII_VSC85XX_INT_STATUS); 342 345 343 - out_unlock: 344 - mutex_unlock(&phydev->lock); 345 - 346 - return rc; 346 + return 0; 347 347 } 348 348 349 349 static void vsc85xx_wol_get(struct phy_device *phydev, ··· 352 358 u16 pwd[3] = {0, 0, 0}; 353 359 struct ethtool_wolinfo *wol_conf = wol; 354 360 355 - mutex_lock(&phydev->lock); 356 361 rc = phy_select_page(phydev, MSCC_PHY_PAGE_EXTENDED_2); 357 362 if (rc < 0) 358 - goto out_unlock; 363 + goto out_restore_page; 359 364 360 365 reg_val = __phy_read(phydev, MSCC_PHY_WOL_MAC_CONTROL); 361 366 if (reg_val & SECURE_ON_ENABLE) ··· 370 377 } 371 378 } 372 379 373 - out_unlock: 380 + out_restore_page: 374 381 phy_restore_page(phydev, rc, rc > 0 ? 0 : rc); 375 - mutex_unlock(&phydev->lock); 376 382 } 377 383 378 384 #if IS_ENABLED(CONFIG_OF_MDIO)

+1 -1

drivers/net/phy/nxp-c45-tja11xx.c

··· 79 79 #define SGMII_ABILITY BIT(0) 80 80 81 81 #define VEND1_MII_BASIC_CONFIG 0xAFC6 82 - #define MII_BASIC_CONFIG_REV BIT(8) 82 + #define MII_BASIC_CONFIG_REV BIT(4) 83 83 #define MII_BASIC_CONFIG_SGMII 0x9 84 84 #define MII_BASIC_CONFIG_RGMII 0x7 85 85 #define MII_BASIC_CONFIG_RMII 0x5

+4 -1

drivers/net/phy/smsc.c

··· 199 199 static int lan87xx_read_status(struct phy_device *phydev) 200 200 { 201 201 struct smsc_phy_priv *priv = phydev->priv; 202 + int err; 202 203 203 - int err = genphy_read_status(phydev); 204 + err = genphy_read_status(phydev); 205 + if (err) 206 + return err; 204 207 205 208 if (!phydev->link && priv->energy_enable && phydev->irq == PHY_POLL) { 206 209 /* Disable EDPD to wake up PHY */

+7

drivers/net/usb/smsc75xx.c

··· 2200 2200 size = (rx_cmd_a & RX_CMD_A_LEN) - RXW_PADDING; 2201 2201 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4; 2202 2202 2203 + if (unlikely(size > skb->len)) { 2204 + netif_dbg(dev, rx_err, dev->net, 2205 + "size err rx_cmd_a=0x%08x\n", 2206 + rx_cmd_a); 2207 + return 0; 2208 + } 2209 + 2203 2210 if (unlikely(rx_cmd_a & RX_CMD_A_RED)) { 2204 2211 netif_dbg(dev, rx_err, dev->net, 2205 2212 "Error rx_cmd_a=0x%08x\n", rx_cmd_a);

+40 -8

drivers/net/veth.c

··· 708 708 u32 frame_sz; 709 709 710 710 if (skb_shared(skb) || skb_head_is_locked(skb) || 711 - skb_shinfo(skb)->nr_frags) { 711 + skb_shinfo(skb)->nr_frags || 712 + skb_headroom(skb) < XDP_PACKET_HEADROOM) { 712 713 u32 size, len, max_head_size, off; 713 714 struct sk_buff *nskb; 714 715 struct page *page; ··· 774 773 775 774 consume_skb(skb); 776 775 skb = nskb; 777 - } else if (skb_headroom(skb) < XDP_PACKET_HEADROOM && 778 - pskb_expand_head(skb, VETH_XDP_HEADROOM, 0, GFP_ATOMIC)) { 779 - goto drop; 780 776 } 781 777 782 778 /* SKB "head" area always have tailroom for skb_shared_info */ ··· 1255 1257 return 0; 1256 1258 } 1257 1259 1260 + static void veth_set_xdp_features(struct net_device *dev) 1261 + { 1262 + struct veth_priv *priv = netdev_priv(dev); 1263 + struct net_device *peer; 1264 + 1265 + peer = rtnl_dereference(priv->peer); 1266 + if (peer && peer->real_num_tx_queues <= dev->real_num_rx_queues) { 1267 + xdp_features_t val = NETDEV_XDP_ACT_BASIC | 1268 + NETDEV_XDP_ACT_REDIRECT | 1269 + NETDEV_XDP_ACT_RX_SG; 1270 + 1271 + if (priv->_xdp_prog || veth_gro_requested(dev)) 1272 + val |= NETDEV_XDP_ACT_NDO_XMIT | 1273 + NETDEV_XDP_ACT_NDO_XMIT_SG; 1274 + xdp_set_features_flag(dev, val); 1275 + } else { 1276 + xdp_clear_features_flag(dev); 1277 + } 1278 + } 1279 + 1258 1280 static int veth_set_channels(struct net_device *dev, 1259 1281 struct ethtool_channels *ch) 1260 1282 { ··· 1341 1323 if (peer) 1342 1324 netif_carrier_on(peer); 1343 1325 } 1326 + 1327 + /* update XDP supported features */ 1328 + veth_set_xdp_features(dev); 1329 + if (peer) 1330 + veth_set_xdp_features(peer); 1331 + 1344 1332 return err; 1345 1333 1346 1334 revert: ··· 1513 1489 err = veth_napi_enable(dev); 1514 1490 if (err) 1515 1491 return err; 1492 + 1493 + xdp_features_set_redirect_target(dev, true); 1516 1494 } else { 1495 + xdp_features_clear_redirect_target(dev); 1517 1496 veth_napi_del(dev); 1518 1497 } 1519 1498 return 0; ··· 1597 1570 peer->hw_features &= ~NETIF_F_GSO_SOFTWARE; 1598 1571 peer->max_mtu = max_mtu; 1599 1572 } 1573 + 1574 + xdp_features_set_redirect_target(dev, true); 1600 1575 } 1601 1576 1602 1577 if (old_prog) { 1603 1578 if (!prog) { 1579 + if (!veth_gro_requested(dev)) 1580 + xdp_features_clear_redirect_target(dev); 1581 + 1604 1582 if (dev->flags & IFF_UP) 1605 1583 veth_disable_xdp(dev); 1606 1584 ··· 1718 1686 dev->hw_enc_features = VETH_FEATURES; 1719 1687 dev->mpls_features = NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE; 1720 1688 netif_set_tso_max_size(dev, GSO_MAX_SIZE); 1721 - 1722 - dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 1723 - NETDEV_XDP_ACT_NDO_XMIT | NETDEV_XDP_ACT_RX_SG | 1724 - NETDEV_XDP_ACT_NDO_XMIT_SG; 1725 1689 } 1726 1690 1727 1691 /* ··· 1885 1857 goto err_queues; 1886 1858 1887 1859 veth_disable_gro(dev); 1860 + /* update XDP supported features */ 1861 + veth_set_xdp_features(dev); 1862 + veth_set_xdp_features(peer); 1863 + 1888 1864 return 0; 1889 1865 1890 1866 err_queues:

+95 -76

drivers/net/virtio_net.c

··· 446 446 static struct sk_buff *page_to_skb(struct virtnet_info *vi, 447 447 struct receive_queue *rq, 448 448 struct page *page, unsigned int offset, 449 - unsigned int len, unsigned int truesize) 449 + unsigned int len, unsigned int truesize, 450 + unsigned int headroom) 450 451 { 451 452 struct sk_buff *skb; 452 453 struct virtio_net_hdr_mrg_rxbuf *hdr; ··· 465 464 else 466 465 hdr_padded_len = sizeof(struct padded_vnet_hdr); 467 466 468 - buf = p; 467 + buf = p - headroom; 469 468 len -= hdr_len; 470 469 offset += hdr_padded_len; 471 470 p += hdr_padded_len; 472 - tailroom = truesize - hdr_padded_len - len; 471 + tailroom = truesize - headroom - hdr_padded_len - len; 473 472 474 473 shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); 475 474 ··· 544 543 put_page(page_to_free); 545 544 546 545 return skb; 546 + } 547 + 548 + static void free_old_xmit_skbs(struct send_queue *sq, bool in_napi) 549 + { 550 + unsigned int len; 551 + unsigned int packets = 0; 552 + unsigned int bytes = 0; 553 + void *ptr; 554 + 555 + while ((ptr = virtqueue_get_buf(sq->vq, &len)) != NULL) { 556 + if (likely(!is_xdp_frame(ptr))) { 557 + struct sk_buff *skb = ptr; 558 + 559 + pr_debug("Sent skb %p\n", skb); 560 + 561 + bytes += skb->len; 562 + napi_consume_skb(skb, in_napi); 563 + } else { 564 + struct xdp_frame *frame = ptr_to_xdp(ptr); 565 + 566 + bytes += xdp_get_frame_len(frame); 567 + xdp_return_frame(frame); 568 + } 569 + packets++; 570 + } 571 + 572 + /* Avoid overhead when no packets have been processed 573 + * happens when called speculatively from start_xmit. 574 + */ 575 + if (!packets) 576 + return; 577 + 578 + u64_stats_update_begin(&sq->stats.syncp); 579 + sq->stats.bytes += bytes; 580 + sq->stats.packets += packets; 581 + u64_stats_update_end(&sq->stats.syncp); 582 + } 583 + 584 + static bool is_xdp_raw_buffer_queue(struct virtnet_info *vi, int q) 585 + { 586 + if (q < (vi->curr_queue_pairs - vi->xdp_queue_pairs)) 587 + return false; 588 + else if (q < vi->curr_queue_pairs) 589 + return true; 590 + else 591 + return false; 592 + } 593 + 594 + static void check_sq_full_and_disable(struct virtnet_info *vi, 595 + struct net_device *dev, 596 + struct send_queue *sq) 597 + { 598 + bool use_napi = sq->napi.weight; 599 + int qnum; 600 + 601 + qnum = sq - vi->sq; 602 + 603 + /* If running out of space, stop queue to avoid getting packets that we 604 + * are then unable to transmit. 605 + * An alternative would be to force queuing layer to requeue the skb by 606 + * returning NETDEV_TX_BUSY. However, NETDEV_TX_BUSY should not be 607 + * returned in a normal path of operation: it means that driver is not 608 + * maintaining the TX queue stop/start state properly, and causes 609 + * the stack to do a non-trivial amount of useless work. 610 + * Since most packets only take 1 or 2 ring slots, stopping the queue 611 + * early means 16 slots are typically wasted. 612 + */ 613 + if (sq->vq->num_free < 2+MAX_SKB_FRAGS) { 614 + netif_stop_subqueue(dev, qnum); 615 + if (use_napi) { 616 + if (unlikely(!virtqueue_enable_cb_delayed(sq->vq))) 617 + virtqueue_napi_schedule(&sq->napi, sq->vq); 618 + } else if (unlikely(!virtqueue_enable_cb_delayed(sq->vq))) { 619 + /* More just got used, free them then recheck. */ 620 + free_old_xmit_skbs(sq, false); 621 + if (sq->vq->num_free >= 2+MAX_SKB_FRAGS) { 622 + netif_start_subqueue(dev, qnum); 623 + virtqueue_disable_cb(sq->vq); 624 + } 625 + } 626 + } 547 627 } 548 628 549 629 static int __virtnet_xdp_xmit_one(struct virtnet_info *vi, ··· 767 685 nxmit++; 768 686 } 769 687 ret = nxmit; 688 + 689 + if (!is_xdp_raw_buffer_queue(vi, sq - vi->sq)) 690 + check_sq_full_and_disable(vi, dev, sq); 770 691 771 692 if (flags & XDP_XMIT_FLUSH) { 772 693 if (virtqueue_kick_prepare(sq->vq) && virtqueue_notify(sq->vq)) ··· 1010 925 { 1011 926 struct page *page = buf; 1012 927 struct sk_buff *skb = 1013 - page_to_skb(vi, rq, page, 0, len, PAGE_SIZE); 928 + page_to_skb(vi, rq, page, 0, len, PAGE_SIZE, 0); 1014 929 1015 930 stats->bytes += len - vi->hdr_len; 1016 931 if (unlikely(!skb)) ··· 1273 1188 1274 1189 switch (act) { 1275 1190 case XDP_PASS: 1191 + head_skb = build_skb_from_xdp_buff(dev, vi, &xdp, xdp_frags_truesz); 1192 + if (unlikely(!head_skb)) 1193 + goto err_xdp_frags; 1194 + 1276 1195 if (unlikely(xdp_page != page)) 1277 1196 put_page(page); 1278 - head_skb = build_skb_from_xdp_buff(dev, vi, &xdp, xdp_frags_truesz); 1279 1197 rcu_read_unlock(); 1280 1198 return head_skb; 1281 1199 case XDP_TX: ··· 1336 1248 rcu_read_unlock(); 1337 1249 1338 1250 skip_xdp: 1339 - head_skb = page_to_skb(vi, rq, page, offset, len, truesize); 1251 + head_skb = page_to_skb(vi, rq, page, offset, len, truesize, headroom); 1340 1252 curr_skb = head_skb; 1341 1253 1342 1254 if (unlikely(!curr_skb)) ··· 1802 1714 return stats.packets; 1803 1715 } 1804 1716 1805 - static void free_old_xmit_skbs(struct send_queue *sq, bool in_napi) 1806 - { 1807 - unsigned int len; 1808 - unsigned int packets = 0; 1809 - unsigned int bytes = 0; 1810 - void *ptr; 1811 - 1812 - while ((ptr = virtqueue_get_buf(sq->vq, &len)) != NULL) { 1813 - if (likely(!is_xdp_frame(ptr))) { 1814 - struct sk_buff *skb = ptr; 1815 - 1816 - pr_debug("Sent skb %p\n", skb); 1817 - 1818 - bytes += skb->len; 1819 - napi_consume_skb(skb, in_napi); 1820 - } else { 1821 - struct xdp_frame *frame = ptr_to_xdp(ptr); 1822 - 1823 - bytes += xdp_get_frame_len(frame); 1824 - xdp_return_frame(frame); 1825 - } 1826 - packets++; 1827 - } 1828 - 1829 - /* Avoid overhead when no packets have been processed 1830 - * happens when called speculatively from start_xmit. 1831 - */ 1832 - if (!packets) 1833 - return; 1834 - 1835 - u64_stats_update_begin(&sq->stats.syncp); 1836 - sq->stats.bytes += bytes; 1837 - sq->stats.packets += packets; 1838 - u64_stats_update_end(&sq->stats.syncp); 1839 - } 1840 - 1841 - static bool is_xdp_raw_buffer_queue(struct virtnet_info *vi, int q) 1842 - { 1843 - if (q < (vi->curr_queue_pairs - vi->xdp_queue_pairs)) 1844 - return false; 1845 - else if (q < vi->curr_queue_pairs) 1846 - return true; 1847 - else 1848 - return false; 1849 - } 1850 - 1851 1717 static void virtnet_poll_cleantx(struct receive_queue *rq) 1852 1718 { 1853 1719 struct virtnet_info *vi = rq->vq->vdev->priv; ··· 2031 1989 nf_reset_ct(skb); 2032 1990 } 2033 1991 2034 - /* If running out of space, stop queue to avoid getting packets that we 2035 - * are then unable to transmit. 2036 - * An alternative would be to force queuing layer to requeue the skb by 2037 - * returning NETDEV_TX_BUSY. However, NETDEV_TX_BUSY should not be 2038 - * returned in a normal path of operation: it means that driver is not 2039 - * maintaining the TX queue stop/start state properly, and causes 2040 - * the stack to do a non-trivial amount of useless work. 2041 - * Since most packets only take 1 or 2 ring slots, stopping the queue 2042 - * early means 16 slots are typically wasted. 2043 - */ 2044 - if (sq->vq->num_free < 2+MAX_SKB_FRAGS) { 2045 - netif_stop_subqueue(dev, qnum); 2046 - if (use_napi) { 2047 - if (unlikely(!virtqueue_enable_cb_delayed(sq->vq))) 2048 - virtqueue_napi_schedule(&sq->napi, sq->vq); 2049 - } else if (unlikely(!virtqueue_enable_cb_delayed(sq->vq))) { 2050 - /* More just got used, free them then recheck. */ 2051 - free_old_xmit_skbs(sq, false); 2052 - if (sq->vq->num_free >= 2+MAX_SKB_FRAGS) { 2053 - netif_start_subqueue(dev, qnum); 2054 - virtqueue_disable_cb(sq->vq); 2055 - } 2056 - } 2057 - } 1992 + check_sq_full_and_disable(vi, dev, sq); 2058 1993 2059 1994 if (kick || netif_xmit_stopped(txq)) { 2060 1995 if (virtqueue_kick_prepare(sq->vq) && virtqueue_notify(sq->vq)) {

+3 -8

drivers/net/wan/fsl_ucc_hdlc.c

··· 1177 1177 uhdlc_priv->dev = &pdev->dev; 1178 1178 uhdlc_priv->ut_info = ut_info; 1179 1179 1180 - if (of_get_property(np, "fsl,tdm-interface", NULL)) 1181 - uhdlc_priv->tsa = 1; 1182 - 1183 - if (of_get_property(np, "fsl,ucc-internal-loopback", NULL)) 1184 - uhdlc_priv->loopback = 1; 1185 - 1186 - if (of_get_property(np, "fsl,hdlc-bus", NULL)) 1187 - uhdlc_priv->hdlc_bus = 1; 1180 + uhdlc_priv->tsa = of_property_read_bool(np, "fsl,tdm-interface"); 1181 + uhdlc_priv->loopback = of_property_read_bool(np, "fsl,ucc-internal-loopback"); 1182 + uhdlc_priv->hdlc_bus = of_property_read_bool(np, "fsl,hdlc-bus"); 1188 1183 1189 1184 if (uhdlc_priv->tsa == 1) { 1190 1185 utdm = kzalloc(sizeof(*utdm), GFP_KERNEL);

+1 -2

drivers/net/wireless/ti/wlcore/spi.c

··· 447 447 dev_info(&spi->dev, "selected chip family is %s\n", 448 448 pdev_data->family->name); 449 449 450 - if (of_find_property(dt_node, "clock-xtal", NULL)) 451 - pdev_data->ref_clock_xtal = true; 450 + pdev_data->ref_clock_xtal = of_property_read_bool(dt_node, "clock-xtal"); 452 451 453 452 /* optional clock frequency params */ 454 453 of_property_read_u32(dt_node, "ref-clock-frequency",

+1

drivers/nfc/pn533/usb.c

··· 175 175 print_hex_dump_debug("PN533 TX: ", DUMP_PREFIX_NONE, 16, 1, 176 176 out->data, out->len, false); 177 177 178 + arg.phy = phy; 178 179 init_completion(&arg.done); 179 180 cntx = phy->out_urb->context; 180 181 phy->out_urb->context = &arg;

+4 -2

drivers/nfc/st-nci/ndlc.c

··· 282 282 283 283 void ndlc_remove(struct llt_ndlc *ndlc) 284 284 { 285 - st_nci_remove(ndlc->ndev); 286 - 287 285 /* cancel timers */ 288 286 del_timer_sync(&ndlc->t1_timer); 289 287 del_timer_sync(&ndlc->t2_timer); 290 288 ndlc->t2_active = false; 291 289 ndlc->t1_active = false; 290 + /* cancel work */ 291 + cancel_work_sync(&ndlc->sm_work); 292 + 293 + st_nci_remove(ndlc->ndev); 292 294 293 295 skb_queue_purge(&ndlc->rcv_q); 294 296 skb_queue_purge(&ndlc->send_q);

+4 -2

include/linux/netdevice.h

··· 297 297 * relationship HH alignment <= LL alignment. 298 298 */ 299 299 #define LL_RESERVED_SPACE(dev) \ 300 - ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 300 + ((((dev)->hard_header_len + READ_ONCE((dev)->needed_headroom)) \ 301 + & ~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 301 302 #define LL_RESERVED_SPACE_EXTRA(dev,extra) \ 302 - ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 303 + ((((dev)->hard_header_len + READ_ONCE((dev)->needed_headroom) + (extra)) \ 304 + & ~(HH_DATA_MOD - 1)) + HH_DATA_MOD) 303 305 304 306 struct header_ops { 305 307 int (*create) (struct sk_buff *skb, struct net_device *dev,

+11

include/net/xdp.h

··· 428 428 #ifdef CONFIG_NET 429 429 u32 bpf_xdp_metadata_kfunc_id(int id); 430 430 bool bpf_dev_bound_kfunc_id(u32 btf_id); 431 + void xdp_set_features_flag(struct net_device *dev, xdp_features_t val); 431 432 void xdp_features_set_redirect_target(struct net_device *dev, bool support_sg); 432 433 void xdp_features_clear_redirect_target(struct net_device *dev); 433 434 #else 434 435 static inline u32 bpf_xdp_metadata_kfunc_id(int id) { return 0; } 435 436 static inline bool bpf_dev_bound_kfunc_id(u32 btf_id) { return false; } 437 + 438 + static inline void 439 + xdp_set_features_flag(struct net_device *dev, xdp_features_t val) 440 + { 441 + } 436 442 437 443 static inline void 438 444 xdp_features_set_redirect_target(struct net_device *dev, bool support_sg) ··· 450 444 { 451 445 } 452 446 #endif 447 + 448 + static inline void xdp_clear_features_flag(struct net_device *dev) 449 + { 450 + xdp_set_features_flag(dev, 0); 451 + } 453 452 454 453 #endif /* __LINUX_NET_XDP_H__ */

+1 -1

include/uapi/linux/fou.h

··· 1 - /* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ 1 + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ 2 2 /* Do not edit directly, auto-generated from: */ 3 3 /* Documentation/netlink/specs/fou.yaml */ 4 4 /* YNL-GEN uapi header */

+3 -1

include/uapi/linux/netdev.h

··· 1 - /* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ 1 + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ 2 2 /* Do not edit directly, auto-generated from: */ 3 3 /* Documentation/netlink/specs/netdev.yaml */ 4 4 /* YNL-GEN uapi header */ ··· 33 33 NETDEV_XDP_ACT_HW_OFFLOAD = 16, 34 34 NETDEV_XDP_ACT_RX_SG = 32, 35 35 NETDEV_XDP_ACT_NDO_XMIT_SG = 64, 36 + 37 + NETDEV_XDP_ACT_MASK = 127, 36 38 }; 37 39 38 40 enum {

+1

include/uapi/linux/rtnetlink.h

··· 789 789 TCA_ROOT_FLAGS, 790 790 TCA_ROOT_COUNT, 791 791 TCA_ROOT_TIME_DELTA, /* in msecs */ 792 + TCA_ROOT_EXT_WARN_MSG, 792 793 __TCA_ROOT_MAX, 793 794 #define TCA_ROOT_MAX (__TCA_ROOT_MAX - 1) 794 795 };

+1 -1

net/core/netdev-genl-gen.c

··· 1 - // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + // SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 /* Do not edit directly, auto-generated from: */ 3 3 /* Documentation/netlink/specs/netdev.yaml */ 4 4 /* YNL-GEN kernel source */

+1 -1

net/core/netdev-genl-gen.h

··· 1 - /* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ 1 + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ 2 2 /* Do not edit directly, auto-generated from: */ 3 3 /* Documentation/netlink/specs/netdev.yaml */ 4 4 /* YNL-GEN kernel header */

+21 -7

net/core/xdp.c

··· 774 774 } 775 775 late_initcall(xdp_metadata_init); 776 776 777 + void xdp_set_features_flag(struct net_device *dev, xdp_features_t val) 778 + { 779 + val &= NETDEV_XDP_ACT_MASK; 780 + if (dev->xdp_features == val) 781 + return; 782 + 783 + dev->xdp_features = val; 784 + 785 + if (dev->reg_state == NETREG_REGISTERED) 786 + call_netdevice_notifiers(NETDEV_XDP_FEAT_CHANGE, dev); 787 + } 788 + EXPORT_SYMBOL_GPL(xdp_set_features_flag); 789 + 777 790 void xdp_features_set_redirect_target(struct net_device *dev, bool support_sg) 778 791 { 779 - dev->xdp_features |= NETDEV_XDP_ACT_NDO_XMIT; 780 - if (support_sg) 781 - dev->xdp_features |= NETDEV_XDP_ACT_NDO_XMIT_SG; 792 + xdp_features_t val = (dev->xdp_features | NETDEV_XDP_ACT_NDO_XMIT); 782 793 783 - call_netdevice_notifiers(NETDEV_XDP_FEAT_CHANGE, dev); 794 + if (support_sg) 795 + val |= NETDEV_XDP_ACT_NDO_XMIT_SG; 796 + xdp_set_features_flag(dev, val); 784 797 } 785 798 EXPORT_SYMBOL_GPL(xdp_features_set_redirect_target); 786 799 787 800 void xdp_features_clear_redirect_target(struct net_device *dev) 788 801 { 789 - dev->xdp_features &= ~(NETDEV_XDP_ACT_NDO_XMIT | 790 - NETDEV_XDP_ACT_NDO_XMIT_SG); 791 - call_netdevice_notifiers(NETDEV_XDP_FEAT_CHANGE, dev); 802 + xdp_features_t val = dev->xdp_features; 803 + 804 + val &= ~(NETDEV_XDP_ACT_NDO_XMIT | NETDEV_XDP_ACT_NDO_XMIT_SG); 805 + xdp_set_features_flag(dev, val); 792 806 } 793 807 EXPORT_SYMBOL_GPL(xdp_features_clear_redirect_target);

+5 -4

net/dsa/slave.c

··· 1933 1933 int new_master_mtu; 1934 1934 int old_master_mtu; 1935 1935 int mtu_limit; 1936 + int overhead; 1936 1937 int cpu_mtu; 1937 1938 int err; 1938 1939 ··· 1962 1961 largest_mtu = slave_mtu; 1963 1962 } 1964 1963 1965 - mtu_limit = min_t(int, master->max_mtu, dev->max_mtu); 1964 + overhead = dsa_tag_protocol_overhead(cpu_dp->tag_ops); 1965 + mtu_limit = min_t(int, master->max_mtu, dev->max_mtu + overhead); 1966 1966 old_master_mtu = master->mtu; 1967 - new_master_mtu = largest_mtu + dsa_tag_protocol_overhead(cpu_dp->tag_ops); 1967 + new_master_mtu = largest_mtu + overhead; 1968 1968 if (new_master_mtu > mtu_limit) 1969 1969 return -ERANGE; 1970 1970 ··· 2000 1998 2001 1999 out_port_failed: 2002 2000 if (new_master_mtu != old_master_mtu) 2003 - dsa_port_mtu_change(cpu_dp, old_master_mtu - 2004 - dsa_tag_protocol_overhead(cpu_dp->tag_ops)); 2001 + dsa_port_mtu_change(cpu_dp, old_master_mtu - overhead); 2005 2002 out_cpu_failed: 2006 2003 if (new_master_mtu != old_master_mtu) 2007 2004 dev_set_mtu(master, old_master_mtu);

+1 -1

net/hsr/hsr_framereg.c

··· 415 415 node_dst = find_node_by_addr_A(&port->hsr->node_db, 416 416 eth_hdr(skb)->h_dest); 417 417 if (!node_dst) { 418 - if (net_ratelimit()) 418 + if (port->hsr->prot_version != PRP_V1 && net_ratelimit()) 419 419 netdev_err(skb->dev, "%s: Unknown node\n", __func__); 420 420 return; 421 421 }

+3

net/ipv4/fib_frontend.c

··· 576 576 cfg->fc_scope = RT_SCOPE_UNIVERSE; 577 577 } 578 578 579 + if (!cfg->fc_table) 580 + cfg->fc_table = RT_TABLE_MAIN; 581 + 579 582 if (cmd == SIOCDELRT) 580 583 return 0; 581 584

+1 -1

net/ipv4/fou_nl.c

··· 1 - // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 1 + // SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 2 2 /* Do not edit directly, auto-generated from: */ 3 3 /* Documentation/netlink/specs/fou.yaml */ 4 4 /* YNL-GEN kernel source */

+1 -1

net/ipv4/fou_nl.h

··· 1 - /* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ 1 + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ 2 2 /* Do not edit directly, auto-generated from: */ 3 3 /* Documentation/netlink/specs/fou.yaml */ 4 4 /* YNL-GEN kernel header */

+7 -1

net/ipv4/inet_hashtables.c

··· 828 828 #if IS_ENABLED(CONFIG_IPV6) 829 829 struct in6_addr addr_any = {}; 830 830 831 - if (sk->sk_family != tb->family) 831 + if (sk->sk_family != tb->family) { 832 + if (sk->sk_family == AF_INET) 833 + return net_eq(ib2_net(tb), net) && tb->port == port && 834 + tb->l3mdev == l3mdev && 835 + ipv6_addr_equal(&tb->v6_rcv_saddr, &addr_any); 836 + 832 837 return false; 838 + } 833 839 834 840 if (sk->sk_family == AF_INET6) 835 841 return net_eq(ib2_net(tb), net) && tb->port == port &&

+6 -6

net/ipv4/ip_tunnel.c

··· 614 614 } 615 615 616 616 headroom += LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len; 617 - if (headroom > dev->needed_headroom) 618 - dev->needed_headroom = headroom; 617 + if (headroom > READ_ONCE(dev->needed_headroom)) 618 + WRITE_ONCE(dev->needed_headroom, headroom); 619 619 620 - if (skb_cow_head(skb, dev->needed_headroom)) { 620 + if (skb_cow_head(skb, READ_ONCE(dev->needed_headroom))) { 621 621 ip_rt_put(rt); 622 622 goto tx_dropped; 623 623 } ··· 800 800 801 801 max_headroom = LL_RESERVED_SPACE(rt->dst.dev) + sizeof(struct iphdr) 802 802 + rt->dst.header_len + ip_encap_hlen(&tunnel->encap); 803 - if (max_headroom > dev->needed_headroom) 804 - dev->needed_headroom = max_headroom; 803 + if (max_headroom > READ_ONCE(dev->needed_headroom)) 804 + WRITE_ONCE(dev->needed_headroom, max_headroom); 805 805 806 - if (skb_cow_head(skb, dev->needed_headroom)) { 806 + if (skb_cow_head(skb, READ_ONCE(dev->needed_headroom))) { 807 807 ip_rt_put(rt); 808 808 DEV_STATS_INC(dev, tx_dropped); 809 809 kfree_skb(skb);

+1 -1

net/ipv4/tcp_output.c

··· 3605 3605 th->window = htons(min(req->rsk_rcv_wnd, 65535U)); 3606 3606 tcp_options_write(th, NULL, &opts); 3607 3607 th->doff = (tcp_header_size >> 2); 3608 - __TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS); 3608 + TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS); 3609 3609 3610 3610 #ifdef CONFIG_TCP_MD5SIG 3611 3611 /* Okay, we have all we need - do the md5 hash if needed */

+2 -2

net/ipv6/ip6_tunnel.c

··· 1240 1240 */ 1241 1241 max_headroom = LL_RESERVED_SPACE(dst->dev) + sizeof(struct ipv6hdr) 1242 1242 + dst->header_len + t->hlen; 1243 - if (max_headroom > dev->needed_headroom) 1244 - dev->needed_headroom = max_headroom; 1243 + if (max_headroom > READ_ONCE(dev->needed_headroom)) 1244 + WRITE_ONCE(dev->needed_headroom, max_headroom); 1245 1245 1246 1246 err = ip6_tnl_encap(skb, t, &proto, fl6); 1247 1247 if (err)

+1 -1

net/iucv/iucv.c

··· 83 83 u16 ippathid; 84 84 u8 ipflags1; 85 85 u8 iptype; 86 - u32 res2[8]; 86 + u32 res2[9]; 87 87 }; 88 88 89 89 struct iucv_irq_list {

+11 -10

net/mac80211/cfg.c

··· 2611 2611 if (!sband) 2612 2612 return -EINVAL; 2613 2613 2614 + if (params->basic_rates) { 2615 + if (!ieee80211_parse_bitrates(link->conf->chandef.width, 2616 + wiphy->bands[sband->band], 2617 + params->basic_rates, 2618 + params->basic_rates_len, 2619 + &link->conf->basic_rates)) 2620 + return -EINVAL; 2621 + changed |= BSS_CHANGED_BASIC_RATES; 2622 + ieee80211_check_rate_mask(link); 2623 + } 2624 + 2614 2625 if (params->use_cts_prot >= 0) { 2615 2626 link->conf->use_cts_prot = params->use_cts_prot; 2616 2627 changed |= BSS_CHANGED_ERP_CTS_PROT; ··· 2641 2630 if (params->use_short_slot_time >= 0) { 2642 2631 link->conf->use_short_slot = params->use_short_slot_time; 2643 2632 changed |= BSS_CHANGED_ERP_SLOT; 2644 - } 2645 - 2646 - if (params->basic_rates) { 2647 - ieee80211_parse_bitrates(link->conf->chandef.width, 2648 - wiphy->bands[sband->band], 2649 - params->basic_rates, 2650 - params->basic_rates_len, 2651 - &link->conf->basic_rates); 2652 - changed |= BSS_CHANGED_BASIC_RATES; 2653 - ieee80211_check_rate_mask(link); 2654 2633 } 2655 2634 2656 2635 if (params->ap_isolate >= 0) {

+16

net/mptcp/pm_netlink.c

··· 997 997 return ret; 998 998 } 999 999 1000 + static struct lock_class_key mptcp_slock_keys[2]; 1001 + static struct lock_class_key mptcp_keys[2]; 1002 + 1000 1003 static int mptcp_pm_nl_create_listen_socket(struct sock *sk, 1001 1004 struct mptcp_pm_addr_entry *entry) 1002 1005 { 1006 + bool is_ipv6 = sk->sk_family == AF_INET6; 1003 1007 int addrlen = sizeof(struct sockaddr_in); 1004 1008 struct sockaddr_storage addr; 1005 1009 struct socket *ssock; ··· 1019 1015 newsk = entry->lsk->sk; 1020 1016 if (!newsk) 1021 1017 return -EINVAL; 1018 + 1019 + /* The subflow socket lock is acquired in a nested to the msk one 1020 + * in several places, even by the TCP stack, and this msk is a kernel 1021 + * socket: lockdep complains. Instead of propagating the _nested 1022 + * modifiers in several places, re-init the lock class for the msk 1023 + * socket to an mptcp specific one. 1024 + */ 1025 + sock_lock_init_class_and_name(newsk, 1026 + is_ipv6 ? "mlock-AF_INET6" : "mlock-AF_INET", 1027 + &mptcp_slock_keys[is_ipv6], 1028 + is_ipv6 ? "msk_lock-AF_INET6" : "msk_lock-AF_INET", 1029 + &mptcp_keys[is_ipv6]); 1022 1030 1023 1031 lock_sock(newsk); 1024 1032 ssock = __mptcp_nmpc_socket(mptcp_sk(newsk));

+32 -32

net/mptcp/protocol.c

··· 825 825 if (sk->sk_socket && !ssk->sk_socket) 826 826 mptcp_sock_graft(ssk, sk->sk_socket); 827 827 828 - mptcp_propagate_sndbuf((struct sock *)msk, ssk); 829 828 mptcp_sockopt_sync_locked(msk, ssk); 830 829 return true; 831 830 } ··· 2342 2343 goto out; 2343 2344 } 2344 2345 2345 - sock_orphan(ssk); 2346 2346 subflow->disposable = 1; 2347 2347 2348 2348 /* if ssk hit tcp_done(), tcp_cleanup_ulp() cleared the related ops ··· 2349 2351 * reference owned by msk; 2350 2352 */ 2351 2353 if (!inet_csk(ssk)->icsk_ulp_ops) { 2354 + WARN_ON_ONCE(!sock_flag(ssk, SOCK_DEAD)); 2352 2355 kfree_rcu(subflow, rcu); 2356 + } else if (msk->in_accept_queue && msk->first == ssk) { 2357 + /* if the first subflow moved to a close state, e.g. due to 2358 + * incoming reset and we reach here before inet_child_forget() 2359 + * the TCP stack could later try to close it via 2360 + * inet_csk_listen_stop(), or deliver it to the user space via 2361 + * accept(). 2362 + * We can't delete the subflow - or risk a double free - nor let 2363 + * the msk survive - or will be leaked in the non accept scenario: 2364 + * fallback and let TCP cope with the subflow cleanup. 2365 + */ 2366 + WARN_ON_ONCE(sock_flag(ssk, SOCK_DEAD)); 2367 + mptcp_subflow_drop_ctx(ssk); 2353 2368 } else { 2354 2369 /* otherwise tcp will dispose of the ssk and subflow ctx */ 2355 - if (ssk->sk_state == TCP_LISTEN) { 2356 - tcp_set_state(ssk, TCP_CLOSE); 2357 - mptcp_subflow_queue_clean(sk, ssk); 2358 - inet_csk_listen_stop(ssk); 2370 + if (ssk->sk_state == TCP_LISTEN) 2359 2371 mptcp_event_pm_listener(ssk, MPTCP_EVENT_LISTENER_CLOSED); 2360 - } 2372 + 2361 2373 __tcp_close(ssk, 0); 2362 2374 2363 2375 /* close acquired an extra ref */ ··· 2407 2399 return 0; 2408 2400 } 2409 2401 2410 - static void __mptcp_close_subflow(struct mptcp_sock *msk) 2402 + static void __mptcp_close_subflow(struct sock *sk) 2411 2403 { 2412 2404 struct mptcp_subflow_context *subflow, *tmp; 2405 + struct mptcp_sock *msk = mptcp_sk(sk); 2413 2406 2414 2407 might_sleep(); 2415 2408 ··· 2424 2415 if (!skb_queue_empty_lockless(&ssk->sk_receive_queue)) 2425 2416 continue; 2426 2417 2427 - mptcp_close_ssk((struct sock *)msk, ssk, subflow); 2418 + mptcp_close_ssk(sk, ssk, subflow); 2419 + } 2420 + 2421 + /* if the MPC subflow has been closed before the msk is accepted, 2422 + * msk will never be accept-ed, close it now 2423 + */ 2424 + if (!msk->first && msk->in_accept_queue) { 2425 + sock_set_flag(sk, SOCK_DEAD); 2426 + inet_sk_state_store(sk, TCP_CLOSE); 2428 2427 } 2429 2428 } 2430 2429 ··· 2641 2624 __mptcp_check_send_data_fin(sk); 2642 2625 mptcp_check_data_fin(sk); 2643 2626 2627 + if (test_and_clear_bit(MPTCP_WORK_CLOSE_SUBFLOW, &msk->flags)) 2628 + __mptcp_close_subflow(sk); 2629 + 2644 2630 /* There is no point in keeping around an orphaned sk timedout or 2645 2631 * closed, but we need the msk around to reply to incoming DATA_FIN, 2646 2632 * even if it is orphaned and in FIN_WAIT2 state ··· 2658 2638 goto unlock; 2659 2639 } 2660 2640 } 2661 - 2662 - if (test_and_clear_bit(MPTCP_WORK_CLOSE_SUBFLOW, &msk->flags)) 2663 - __mptcp_close_subflow(msk); 2664 2641 2665 2642 if (test_and_clear_bit(MPTCP_WORK_RTX, &msk->flags)) 2666 2643 __mptcp_retrans(sk); ··· 3096 3079 msk->local_key = subflow_req->local_key; 3097 3080 msk->token = subflow_req->token; 3098 3081 msk->subflow = NULL; 3082 + msk->in_accept_queue = 1; 3099 3083 WRITE_ONCE(msk->fully_established, false); 3100 3084 if (mp_opt->suboptions & OPTION_MPTCP_CSUMREQD) 3101 3085 WRITE_ONCE(msk->csum_enabled, true); ··· 3114 3096 security_inet_csk_clone(nsk, req); 3115 3097 bh_unlock_sock(nsk); 3116 3098 3117 - /* keep a single reference */ 3118 - __sock_put(nsk); 3099 + /* note: the newly allocated socket refcount is 2 now */ 3119 3100 return nsk; 3120 3101 } 3121 3102 ··· 3170 3153 goto out; 3171 3154 } 3172 3155 3173 - /* acquire the 2nd reference for the owning socket */ 3174 - sock_hold(new_mptcp_sock); 3175 3156 newsk = new_mptcp_sock; 3176 3157 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPCAPABLEPASSIVEACK); 3177 3158 } else { ··· 3720 3705 struct sock *newsk = newsock->sk; 3721 3706 3722 3707 set_bit(SOCK_CUSTOM_SOCKOPT, &newsock->flags); 3708 + msk->in_accept_queue = 0; 3723 3709 3724 3710 lock_sock(newsk); 3725 - 3726 - /* PM/worker can now acquire the first subflow socket 3727 - * lock without racing with listener queue cleanup, 3728 - * we can notify it, if needed. 3729 - * 3730 - * Even if remote has reset the initial subflow by now 3731 - * the refcnt is still at least one. 3732 - */ 3733 - subflow = mptcp_subflow_ctx(msk->first); 3734 - list_add(&subflow->node, &msk->conn_list); 3735 - sock_hold(msk->first); 3736 - if (mptcp_is_fully_established(newsk)) 3737 - mptcp_pm_fully_established(msk, msk->first, GFP_KERNEL); 3738 - 3739 - mptcp_rcv_space_init(msk, msk->first); 3740 - mptcp_propagate_sndbuf(newsk, msk->first); 3741 3711 3742 3712 /* set ssk->sk_socket of accept()ed flows to mptcp socket. 3743 3713 * This is needed so NOSPACE flag can be set from tcp stack.

+4 -2

net/mptcp/protocol.h

··· 295 295 u8 recvmsg_inq:1, 296 296 cork:1, 297 297 nodelay:1, 298 - fastopening:1; 298 + fastopening:1, 299 + in_accept_queue:1; 299 300 int connect_flags; 300 301 struct work_struct work; 301 302 struct sk_buff *ooo_last_skb; ··· 629 628 struct mptcp_subflow_context *subflow); 630 629 void __mptcp_subflow_send_ack(struct sock *ssk); 631 630 void mptcp_subflow_reset(struct sock *ssk); 632 - void mptcp_subflow_queue_clean(struct sock *sk, struct sock *ssk); 633 631 void mptcp_sock_graft(struct sock *sk, struct socket *parent); 634 632 struct socket *__mptcp_nmpc_socket(const struct mptcp_sock *msk); 635 633 bool __mptcp_close(struct sock *sk, long timeout); ··· 665 665 void mptcp_subflow_set_active(struct mptcp_subflow_context *subflow); 666 666 667 667 bool mptcp_subflow_active(struct mptcp_subflow_context *subflow); 668 + 669 + void mptcp_subflow_drop_ctx(struct sock *ssk); 668 670 669 671 static inline void mptcp_subflow_tcp_fallback(struct sock *sk, 670 672 struct mptcp_subflow_context *ctx)

+42 -86

net/mptcp/subflow.c

··· 397 397 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk); 398 398 struct sock *sk = subflow->conn; 399 399 400 + /* mptcp_mp_fail_no_response() can reach here on an already closed 401 + * socket 402 + */ 403 + if (ssk->sk_state == TCP_CLOSE) 404 + return; 405 + 400 406 /* must hold: tcp_done() could drop last reference on parent */ 401 407 sock_hold(sk); 402 408 403 - tcp_set_state(ssk, TCP_CLOSE); 404 409 tcp_send_active_reset(ssk, GFP_ATOMIC); 405 410 tcp_done(ssk); 406 411 if (!test_and_set_bit(MPTCP_WORK_CLOSE_SUBFLOW, &mptcp_sk(sk)->flags) && ··· 627 622 static struct tcp_request_sock_ops subflow_request_sock_ipv6_ops __ro_after_init; 628 623 static struct inet_connection_sock_af_ops subflow_v6_specific __ro_after_init; 629 624 static struct inet_connection_sock_af_ops subflow_v6m_specific __ro_after_init; 630 - static struct proto tcpv6_prot_override; 625 + static struct proto tcpv6_prot_override __ro_after_init; 631 626 632 627 static int subflow_v6_conn_request(struct sock *sk, struct sk_buff *skb) 633 628 { ··· 698 693 699 694 static void mptcp_force_close(struct sock *sk) 700 695 { 701 - /* the msk is not yet exposed to user-space */ 696 + /* the msk is not yet exposed to user-space, and refcount is 2 */ 702 697 inet_sk_state_store(sk, TCP_CLOSE); 703 698 sk_common_release(sk); 699 + sock_put(sk); 704 700 } 705 701 706 702 static void subflow_ulp_fallback(struct sock *sk, ··· 717 711 mptcp_subflow_ops_undo_override(sk); 718 712 } 719 713 720 - static void subflow_drop_ctx(struct sock *ssk) 714 + void mptcp_subflow_drop_ctx(struct sock *ssk) 721 715 { 722 716 struct mptcp_subflow_context *ctx = mptcp_subflow_ctx(ssk); 723 717 ··· 756 750 struct mptcp_options_received mp_opt; 757 751 bool fallback, fallback_is_fatal; 758 752 struct sock *new_msk = NULL; 753 + struct mptcp_sock *owner; 759 754 struct sock *child; 760 755 761 756 pr_debug("listener=%p, req=%p, conn=%p", listener, req, listener->conn); ··· 823 816 824 817 if (new_msk) 825 818 mptcp_copy_inaddrs(new_msk, child); 826 - subflow_drop_ctx(child); 819 + mptcp_subflow_drop_ctx(child); 827 820 goto out; 828 821 } 829 822 ··· 831 824 ctx->setsockopt_seq = listener->setsockopt_seq; 832 825 833 826 if (ctx->mp_capable) { 827 + owner = mptcp_sk(new_msk); 828 + 834 829 /* this can't race with mptcp_close(), as the msk is 835 830 * not yet exposted to user-space 836 831 */ ··· 841 832 /* record the newly created socket as the first msk 842 833 * subflow, but don't link it yet into conn_list 843 834 */ 844 - WRITE_ONCE(mptcp_sk(new_msk)->first, child); 835 + WRITE_ONCE(owner->first, child); 845 836 846 837 /* new mpc subflow takes ownership of the newly 847 838 * created mptcp socket 848 839 */ 849 840 mptcp_sk(new_msk)->setsockopt_seq = ctx->setsockopt_seq; 850 - mptcp_pm_new_connection(mptcp_sk(new_msk), child, 1); 851 - mptcp_token_accept(subflow_req, mptcp_sk(new_msk)); 841 + mptcp_pm_new_connection(owner, child, 1); 842 + mptcp_token_accept(subflow_req, owner); 852 843 ctx->conn = new_msk; 853 844 new_msk = NULL; 854 845 ··· 856 847 * uses the correct data 857 848 */ 858 849 mptcp_copy_inaddrs(ctx->conn, child); 850 + mptcp_propagate_sndbuf(ctx->conn, child); 851 + 852 + mptcp_rcv_space_init(owner, child); 853 + list_add(&ctx->node, &owner->conn_list); 854 + sock_hold(child); 859 855 860 856 /* with OoO packets we can reach here without ingress 861 857 * mpc option 862 858 */ 863 - if (mp_opt.suboptions & OPTION_MPTCP_MPC_ACK) 859 + if (mp_opt.suboptions & OPTION_MPTCP_MPC_ACK) { 864 860 mptcp_subflow_fully_established(ctx, &mp_opt); 861 + mptcp_pm_fully_established(owner, child, GFP_ATOMIC); 862 + ctx->pm_notified = 1; 863 + } 865 864 } else if (ctx->mp_join) { 866 - struct mptcp_sock *owner; 867 - 868 865 owner = subflow_req->msk; 869 866 if (!owner) { 870 867 subflow_add_reset_reason(skb, MPTCP_RST_EPROHIBIT); ··· 914 899 return child; 915 900 916 901 dispose_child: 917 - subflow_drop_ctx(child); 902 + mptcp_subflow_drop_ctx(child); 918 903 tcp_rsk(req)->drop_req = true; 919 904 inet_csk_prepare_for_destroy_sock(child); 920 905 tcp_done(child); ··· 925 910 } 926 911 927 912 static struct inet_connection_sock_af_ops subflow_specific __ro_after_init; 928 - static struct proto tcp_prot_override; 913 + static struct proto tcp_prot_override __ro_after_init; 929 914 930 915 enum mapping_status { 931 916 MAPPING_OK, ··· 1447 1432 { 1448 1433 struct sock *sk = mptcp_subflow_ctx(ssk)->conn; 1449 1434 1435 + /* bail early if this is a no-op, so that we avoid introducing a 1436 + * problematic lockdep dependency between TCP accept queue lock 1437 + * and msk socket spinlock 1438 + */ 1439 + if (!sk->sk_socket) 1440 + return; 1441 + 1450 1442 mptcp_data_lock(sk); 1451 1443 if (!sock_owned_by_user(sk)) 1452 1444 __mptcp_error_report(sk); ··· 1825 1803 } 1826 1804 } 1827 1805 1828 - void mptcp_subflow_queue_clean(struct sock *listener_sk, struct sock *listener_ssk) 1829 - { 1830 - struct request_sock_queue *queue = &inet_csk(listener_ssk)->icsk_accept_queue; 1831 - struct mptcp_sock *msk, *next, *head = NULL; 1832 - struct request_sock *req; 1833 - 1834 - /* build a list of all unaccepted mptcp sockets */ 1835 - spin_lock_bh(&queue->rskq_lock); 1836 - for (req = queue->rskq_accept_head; req; req = req->dl_next) { 1837 - struct mptcp_subflow_context *subflow; 1838 - struct sock *ssk = req->sk; 1839 - struct mptcp_sock *msk; 1840 - 1841 - if (!sk_is_mptcp(ssk)) 1842 - continue; 1843 - 1844 - subflow = mptcp_subflow_ctx(ssk); 1845 - if (!subflow || !subflow->conn) 1846 - continue; 1847 - 1848 - /* skip if already in list */ 1849 - msk = mptcp_sk(subflow->conn); 1850 - if (msk->dl_next || msk == head) 1851 - continue; 1852 - 1853 - msk->dl_next = head; 1854 - head = msk; 1855 - } 1856 - spin_unlock_bh(&queue->rskq_lock); 1857 - if (!head) 1858 - return; 1859 - 1860 - /* can't acquire the msk socket lock under the subflow one, 1861 - * or will cause ABBA deadlock 1862 - */ 1863 - release_sock(listener_ssk); 1864 - 1865 - for (msk = head; msk; msk = next) { 1866 - struct sock *sk = (struct sock *)msk; 1867 - bool do_cancel_work; 1868 - 1869 - sock_hold(sk); 1870 - lock_sock_nested(sk, SINGLE_DEPTH_NESTING); 1871 - next = msk->dl_next; 1872 - msk->first = NULL; 1873 - msk->dl_next = NULL; 1874 - 1875 - do_cancel_work = __mptcp_close(sk, 0); 1876 - release_sock(sk); 1877 - if (do_cancel_work) { 1878 - /* lockdep will report a false positive ABBA deadlock 1879 - * between cancel_work_sync and the listener socket. 1880 - * The involved locks belong to different sockets WRT 1881 - * the existing AB chain. 1882 - * Using a per socket key is problematic as key 1883 - * deregistration requires process context and must be 1884 - * performed at socket disposal time, in atomic 1885 - * context. 1886 - * Just tell lockdep to consider the listener socket 1887 - * released here. 1888 - */ 1889 - mutex_release(&listener_sk->sk_lock.dep_map, _RET_IP_); 1890 - mptcp_cancel_work(sk); 1891 - mutex_acquire(&listener_sk->sk_lock.dep_map, 1892 - SINGLE_DEPTH_NESTING, 0, _RET_IP_); 1893 - } 1894 - sock_put(sk); 1895 - } 1896 - 1897 - /* we are still under the listener msk socket lock */ 1898 - lock_sock_nested(listener_ssk, SINGLE_DEPTH_NESTING); 1899 - } 1900 - 1901 1806 static int subflow_ulp_init(struct sock *sk) 1902 1807 { 1903 1808 struct inet_connection_sock *icsk = inet_csk(sk); ··· 1881 1932 * when the subflow is still unaccepted 1882 1933 */ 1883 1934 release = ctx->disposable || list_empty(&ctx->node); 1935 + 1936 + /* inet_child_forget() does not call sk_state_change(), 1937 + * explicitly trigger the socket close machinery 1938 + */ 1939 + if (!release && !test_and_set_bit(MPTCP_WORK_CLOSE_SUBFLOW, 1940 + &mptcp_sk(sk)->flags)) 1941 + mptcp_schedule_work(sk); 1884 1942 sock_put(sk); 1885 1943 } 1886 1944

+2 -2

net/ncsi/ncsi-manage.c

··· 1803 1803 pdev = to_platform_device(dev->dev.parent); 1804 1804 if (pdev) { 1805 1805 np = pdev->dev.of_node; 1806 - if (np && (of_get_property(np, "mellanox,multi-host", NULL) || 1807 - of_get_property(np, "mlx,multi-host", NULL))) 1806 + if (np && (of_property_read_bool(np, "mellanox,multi-host") || 1807 + of_property_read_bool(np, "mlx,multi-host"))) 1808 1808 ndp->mlx_multi_host = true; 1809 1809 } 1810 1810

+1 -1

net/netfilter/nft_masq.c

··· 43 43 const struct nft_expr *expr, 44 44 const struct nlattr * const tb[]) 45 45 { 46 - u32 plen = sizeof_field(struct nf_nat_range, min_addr.all); 46 + u32 plen = sizeof_field(struct nf_nat_range, min_proto.all); 47 47 struct nft_masq *priv = nft_expr_priv(expr); 48 48 int err; 49 49

+1 -1

net/netfilter/nft_nat.c

··· 226 226 priv->flags |= NF_NAT_RANGE_MAP_IPS; 227 227 } 228 228 229 - plen = sizeof_field(struct nf_nat_range, min_addr.all); 229 + plen = sizeof_field(struct nf_nat_range, min_proto.all); 230 230 if (tb[NFTA_NAT_REG_PROTO_MIN]) { 231 231 err = nft_parse_register_load(tb[NFTA_NAT_REG_PROTO_MIN], 232 232 &priv->sreg_proto_min, plen);

+2 -2

net/netfilter/nft_redir.c

··· 48 48 unsigned int plen; 49 49 int err; 50 50 51 - plen = sizeof_field(struct nf_nat_range, min_addr.all); 51 + plen = sizeof_field(struct nf_nat_range, min_proto.all); 52 52 if (tb[NFTA_REDIR_REG_PROTO_MIN]) { 53 53 err = nft_parse_register_load(tb[NFTA_REDIR_REG_PROTO_MIN], 54 54 &priv->sreg_proto_min, plen); ··· 236 236 .name = "redir", 237 237 .ops = &nft_redir_inet_ops, 238 238 .policy = nft_redir_policy, 239 - .maxattr = NFTA_MASQ_MAX, 239 + .maxattr = NFTA_REDIR_MAX, 240 240 .owner = THIS_MODULE, 241 241 }; 242 242

+4 -4

net/sched/act_api.c

··· 1589 1589 t->tca__pad1 = 0; 1590 1590 t->tca__pad2 = 0; 1591 1591 1592 + if (extack && extack->_msg && 1593 + nla_put_string(skb, TCA_ROOT_EXT_WARN_MSG, extack->_msg)) 1594 + goto out_nlmsg_trim; 1595 + 1592 1596 nest = nla_nest_start_noflag(skb, TCA_ACT_TAB); 1593 1597 if (!nest) 1594 1598 goto out_nlmsg_trim; 1595 1599 1596 1600 if (tcf_action_dump(skb, actions, bind, ref, false) < 0) 1597 - goto out_nlmsg_trim; 1598 - 1599 - if (extack && extack->_msg && 1600 - nla_put_string(skb, TCA_EXT_WARN_MSG, extack->_msg)) 1601 1601 goto out_nlmsg_trim; 1602 1602 1603 1603 nla_nest_end(skb, nest);

+1

net/smc/af_smc.c

··· 3501 3501 out_nl: 3502 3502 smc_nl_exit(); 3503 3503 out_ism: 3504 + smc_clc_exit(); 3504 3505 smc_ism_exit(); 3505 3506 out_pernet_subsys_stat: 3506 3507 unregister_pernet_subsys(&smc_net_stat_ops);

+3

net/smc/smc_cdc.c

··· 114 114 union smc_host_cursor cfed; 115 115 int rc; 116 116 117 + if (unlikely(!READ_ONCE(conn->sndbuf_desc))) 118 + return -ENOBUFS; 119 + 117 120 smc_cdc_add_pending_send(conn, pend); 118 121 119 122 conn->tx_cdc_seq++;

+1 -1

net/smc/smc_core.c

··· 1464 1464 if (lgr->terminating) 1465 1465 return; /* lgr already terminating */ 1466 1466 /* cancel free_work sync, will terminate when lgr->freeing is set */ 1467 - cancel_delayed_work_sync(&lgr->free_work); 1467 + cancel_delayed_work(&lgr->free_work); 1468 1468 lgr->terminating = 1; 1469 1469 1470 1470 /* kill remaining link group connections */

+13 -16

net/vmw_vsock/virtio_transport_common.c

··· 241 241 } 242 242 243 243 static bool virtio_transport_inc_rx_pkt(struct virtio_vsock_sock *vvs, 244 - struct sk_buff *skb) 244 + u32 len) 245 245 { 246 - if (vvs->rx_bytes + skb->len > vvs->buf_alloc) 246 + if (vvs->rx_bytes + len > vvs->buf_alloc) 247 247 return false; 248 248 249 - vvs->rx_bytes += skb->len; 249 + vvs->rx_bytes += len; 250 250 return true; 251 251 } 252 252 253 253 static void virtio_transport_dec_rx_pkt(struct virtio_vsock_sock *vvs, 254 - struct sk_buff *skb) 254 + u32 len) 255 255 { 256 - int len; 257 - 258 - len = skb_headroom(skb) - sizeof(struct virtio_vsock_hdr) - skb->len; 259 256 vvs->rx_bytes -= len; 260 257 vvs->fwd_cnt += len; 261 258 } ··· 364 367 365 368 spin_lock_bh(&vvs->rx_lock); 366 369 while (total < len && !skb_queue_empty(&vvs->rx_queue)) { 367 - skb = __skb_dequeue(&vvs->rx_queue); 370 + skb = skb_peek(&vvs->rx_queue); 368 371 369 372 bytes = len - total; 370 373 if (bytes > skb->len) ··· 385 388 skb_pull(skb, bytes); 386 389 387 390 if (skb->len == 0) { 388 - virtio_transport_dec_rx_pkt(vvs, skb); 391 + u32 pkt_len = le32_to_cpu(virtio_vsock_hdr(skb)->len); 392 + 393 + virtio_transport_dec_rx_pkt(vvs, pkt_len); 394 + __skb_unlink(skb, &vvs->rx_queue); 389 395 consume_skb(skb); 390 - } else { 391 - __skb_queue_head(&vvs->rx_queue, skb); 392 396 } 393 397 } 394 398 ··· 435 437 436 438 while (!msg_ready) { 437 439 struct virtio_vsock_hdr *hdr; 440 + size_t pkt_len; 438 441 439 442 skb = __skb_dequeue(&vvs->rx_queue); 440 443 if (!skb) 441 444 break; 442 445 hdr = virtio_vsock_hdr(skb); 446 + pkt_len = (size_t)le32_to_cpu(hdr->len); 443 447 444 448 if (dequeued_len >= 0) { 445 - size_t pkt_len; 446 449 size_t bytes_to_copy; 447 450 448 - pkt_len = (size_t)le32_to_cpu(hdr->len); 449 451 bytes_to_copy = min(user_buf_len, pkt_len); 450 452 451 453 if (bytes_to_copy) { ··· 464 466 dequeued_len = err; 465 467 } else { 466 468 user_buf_len -= bytes_to_copy; 467 - skb_pull(skb, bytes_to_copy); 468 469 } 469 470 470 471 spin_lock_bh(&vvs->rx_lock); ··· 481 484 msg->msg_flags |= MSG_EOR; 482 485 } 483 486 484 - virtio_transport_dec_rx_pkt(vvs, skb); 487 + virtio_transport_dec_rx_pkt(vvs, pkt_len); 485 488 kfree_skb(skb); 486 489 } 487 490 ··· 1037 1040 1038 1041 spin_lock_bh(&vvs->rx_lock); 1039 1042 1040 - can_enqueue = virtio_transport_inc_rx_pkt(vvs, skb); 1043 + can_enqueue = virtio_transport_inc_rx_pkt(vvs, len); 1041 1044 if (!can_enqueue) { 1042 1045 free_pkt = true; 1043 1046 goto out;

+15 -11

net/wireless/nl80211.c

··· 462 462 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 }, 463 463 }; 464 464 465 + static struct netlink_range_validation nl80211_punct_bitmap_range = { 466 + .min = 0, 467 + .max = 0xffff, 468 + }; 469 + 465 470 static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = { 466 471 [0] = { .strict_start_type = NL80211_ATTR_HE_OBSS_PD }, 467 472 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 }, ··· 810 805 [NL80211_ATTR_MLD_ADDR] = NLA_POLICY_EXACT_LEN(ETH_ALEN), 811 806 [NL80211_ATTR_MLO_SUPPORT] = { .type = NLA_FLAG }, 812 807 [NL80211_ATTR_MAX_NUM_AKM_SUITES] = { .type = NLA_REJECT }, 813 - [NL80211_ATTR_PUNCT_BITMAP] = NLA_POLICY_RANGE(NLA_U8, 0, 0xffff), 808 + [NL80211_ATTR_PUNCT_BITMAP] = 809 + NLA_POLICY_FULL_RANGE(NLA_U32, &nl80211_punct_bitmap_range), 814 810 }; 815 811 816 812 /* policy for the key attributes */ ··· 8907 8901 struct cfg80211_chan_def *chandef; 8908 8902 8909 8903 chandef = wdev_chandef(wdev, link_id); 8910 - if (!chandef) 8904 + if (!chandef || !chandef->chan) 8911 8905 continue; 8912 8906 8913 8907 /* ··· 10799 10793 10800 10794 static struct cfg80211_bss *nl80211_assoc_bss(struct cfg80211_registered_device *rdev, 10801 10795 const u8 *ssid, int ssid_len, 10802 - struct nlattr **attrs, 10803 - const u8 **bssid_out) 10796 + struct nlattr **attrs) 10804 10797 { 10805 10798 struct ieee80211_channel *chan; 10806 10799 struct cfg80211_bss *bss; ··· 10826 10821 if (!bss) 10827 10822 return ERR_PTR(-ENOENT); 10828 10823 10829 - *bssid_out = bssid; 10830 10824 return bss; 10831 10825 } 10832 10826 ··· 10835 10831 struct net_device *dev = info->user_ptr[1]; 10836 10832 struct cfg80211_assoc_request req = {}; 10837 10833 struct nlattr **attrs = NULL; 10838 - const u8 *bssid, *ssid; 10834 + const u8 *ap_addr, *ssid; 10839 10835 unsigned int link_id; 10840 10836 int err, ssid_len; 10841 10837 ··· 10972 10968 return -EINVAL; 10973 10969 10974 10970 req.ap_mld_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]); 10971 + ap_addr = req.ap_mld_addr; 10975 10972 10976 10973 attrs = kzalloc(attrsize, GFP_KERNEL); 10977 10974 if (!attrs) ··· 10998 10993 goto free; 10999 10994 } 11000 10995 req.links[link_id].bss = 11001 - nl80211_assoc_bss(rdev, ssid, ssid_len, attrs, 11002 - &bssid); 10996 + nl80211_assoc_bss(rdev, ssid, ssid_len, attrs); 11003 10997 if (IS_ERR(req.links[link_id].bss)) { 11004 10998 err = PTR_ERR(req.links[link_id].bss); 11005 10999 req.links[link_id].bss = NULL; ··· 11049 11045 if (req.link_id >= 0) 11050 11046 return -EINVAL; 11051 11047 11052 - req.bss = nl80211_assoc_bss(rdev, ssid, ssid_len, info->attrs, 11053 - &bssid); 11048 + req.bss = nl80211_assoc_bss(rdev, ssid, ssid_len, info->attrs); 11054 11049 if (IS_ERR(req.bss)) 11055 11050 return PTR_ERR(req.bss); 11051 + ap_addr = req.bss->bssid; 11056 11052 } 11057 11053 11058 11054 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1); ··· 11065 11061 dev->ieee80211_ptr->conn_owner_nlportid = 11066 11062 info->snd_portid; 11067 11063 memcpy(dev->ieee80211_ptr->disconnect_bssid, 11068 - bssid, ETH_ALEN); 11064 + ap_addr, ETH_ALEN); 11069 11065 } 11070 11066 11071 11067 wdev_unlock(dev->ieee80211_ptr);

-5

net/xfrm/xfrm_state.c

··· 2815 2815 goto error; 2816 2816 } 2817 2817 2818 - if (!(inner_mode->flags & XFRM_MODE_FLAG_TUNNEL)) { 2819 - NL_SET_ERR_MSG(extack, "Only tunnel modes can accommodate an AF_UNSPEC selector"); 2820 - goto error; 2821 - } 2822 - 2823 2818 x->inner_mode = *inner_mode; 2824 2819 2825 2820 if (x->props.family == AF_INET)

+41 -4

net/xfrm/xfrm_user.c

··· 1012 1012 return -EMSGSIZE; 1013 1013 1014 1014 ap = nla_data(nla); 1015 - memcpy(ap, aead, sizeof(*aead)); 1015 + strscpy_pad(ap->alg_name, aead->alg_name, sizeof(ap->alg_name)); 1016 + ap->alg_key_len = aead->alg_key_len; 1017 + ap->alg_icv_len = aead->alg_icv_len; 1016 1018 1017 1019 if (redact_secret && aead->alg_key_len) 1018 1020 memset(ap->alg_key, 0, (aead->alg_key_len + 7) / 8); ··· 1034 1032 return -EMSGSIZE; 1035 1033 1036 1034 ap = nla_data(nla); 1037 - memcpy(ap, ealg, sizeof(*ealg)); 1035 + strscpy_pad(ap->alg_name, ealg->alg_name, sizeof(ap->alg_name)); 1036 + ap->alg_key_len = ealg->alg_key_len; 1038 1037 1039 1038 if (redact_secret && ealg->alg_key_len) 1040 1039 memset(ap->alg_key, 0, (ealg->alg_key_len + 7) / 8); 1041 1040 else 1042 1041 memcpy(ap->alg_key, ealg->alg_key, 1043 1042 (ealg->alg_key_len + 7) / 8); 1043 + 1044 + return 0; 1045 + } 1046 + 1047 + static int copy_to_user_calg(struct xfrm_algo *calg, struct sk_buff *skb) 1048 + { 1049 + struct nlattr *nla = nla_reserve(skb, XFRMA_ALG_COMP, sizeof(*calg)); 1050 + struct xfrm_algo *ap; 1051 + 1052 + if (!nla) 1053 + return -EMSGSIZE; 1054 + 1055 + ap = nla_data(nla); 1056 + strscpy_pad(ap->alg_name, calg->alg_name, sizeof(ap->alg_name)); 1057 + ap->alg_key_len = 0; 1058 + 1059 + return 0; 1060 + } 1061 + 1062 + static int copy_to_user_encap(struct xfrm_encap_tmpl *ep, struct sk_buff *skb) 1063 + { 1064 + struct nlattr *nla = nla_reserve(skb, XFRMA_ENCAP, sizeof(*ep)); 1065 + struct xfrm_encap_tmpl *uep; 1066 + 1067 + if (!nla) 1068 + return -EMSGSIZE; 1069 + 1070 + uep = nla_data(nla); 1071 + memset(uep, 0, sizeof(*uep)); 1072 + 1073 + uep->encap_type = ep->encap_type; 1074 + uep->encap_sport = ep->encap_sport; 1075 + uep->encap_dport = ep->encap_dport; 1076 + uep->encap_oa = ep->encap_oa; 1044 1077 1045 1078 return 0; 1046 1079 } ··· 1135 1098 goto out; 1136 1099 } 1137 1100 if (x->calg) { 1138 - ret = nla_put(skb, XFRMA_ALG_COMP, sizeof(*(x->calg)), x->calg); 1101 + ret = copy_to_user_calg(x->calg, skb); 1139 1102 if (ret) 1140 1103 goto out; 1141 1104 } 1142 1105 if (x->encap) { 1143 - ret = nla_put(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap); 1106 + ret = copy_to_user_encap(x->encap, skb); 1144 1107 if (ret) 1145 1108 goto out; 1146 1109 }

+3 -1

tools/include/uapi/linux/netdev.h

··· 1 - /* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ 1 + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ 2 2 /* Do not edit directly, auto-generated from: */ 3 3 /* Documentation/netlink/specs/netdev.yaml */ 4 4 /* YNL-GEN uapi header */ ··· 33 33 NETDEV_XDP_ACT_HW_OFFLOAD = 16, 34 34 NETDEV_XDP_ACT_RX_SG = 32, 35 35 NETDEV_XDP_ACT_NDO_XMIT_SG = 64, 36 + 37 + NETDEV_XDP_ACT_MASK = 127, 36 38 }; 37 39 38 40 enum {

+12 -5

tools/net/ynl/lib/nlspec.py

··· 138 138 139 139 def get_mask(self): 140 140 mask = 0 141 - idx = self.yaml.get('value-start', 0) 142 - for _ in self.entries.values(): 143 - mask |= 1 << idx 144 - idx += 1 141 + for e in self.entries.values(): 142 + mask += e.user_value() 145 143 return mask 146 144 147 145 ··· 274 276 275 277 Attributes: 276 278 proto protocol type (e.g. genetlink) 279 + license spec license (loaded from an SPDX tag on the spec) 277 280 278 281 attr_sets dict of attribute sets 279 282 msgs dict of all messages (index by name) ··· 284 285 """ 285 286 def __init__(self, spec_path, schema_path=None): 286 287 with open(spec_path, "r") as stream: 288 + prefix = '# SPDX-License-Identifier: ' 289 + first = stream.readline().strip() 290 + if not first.startswith(prefix): 291 + raise Exception('SPDX license tag required in the spec') 292 + self.license = first[len(prefix):] 293 + 294 + stream.seek(0) 287 295 spec = yaml.safe_load(stream) 288 296 289 297 self._resolution_list = [] ··· 395 389 def resolve(self): 396 390 self.resolve_up(super()) 397 391 398 - for elem in self.yaml['definitions']: 392 + definitions = self.yaml.get('definitions', []) 393 + for elem in definitions: 399 394 if elem['type'] == 'enum' or elem['type'] == 'flags': 400 395 self.consts[elem['name']] = self.new_enum(elem) 401 396 else:

+16 -10

tools/net/ynl/ynl-gen-c.py

··· 1 1 #!/usr/bin/env python3 2 - # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 + # SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 3 3 4 4 import argparse 5 5 import collections ··· 1931 1931 1932 1932 if const.get('render-max', False): 1933 1933 cw.nl() 1934 - max_name = c_upper(name_pfx + 'max') 1935 - cw.p('__' + max_name + ',') 1936 - cw.p(max_name + ' = (__' + max_name + ' - 1)') 1934 + if const['type'] == 'flags': 1935 + max_name = c_upper(name_pfx + 'mask') 1936 + max_val = f' = {enum.get_mask()},' 1937 + cw.p(max_name + max_val) 1938 + else: 1939 + max_name = c_upper(name_pfx + 'max') 1940 + cw.p('__' + max_name + ',') 1941 + cw.p(max_name + ' = (__' + max_name + ' - 1)') 1937 1942 cw.block_end(line=';') 1938 1943 cw.nl() 1939 1944 elif const['type'] == 'const': ··· 2059 2054 2060 2055 try: 2061 2056 parsed = Family(args.spec) 2057 + if parsed.license != '((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)': 2058 + print('Spec license:', parsed.license) 2059 + print('License must be: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)') 2060 + os.sys.exit(1) 2062 2061 except yaml.YAMLError as exc: 2063 2062 print(exc) 2064 2063 os.sys.exit(1) ··· 2071 2062 cw = CodeWriter(BaseNlLib(), out_file) 2072 2063 2073 2064 _, spec_kernel = find_kernel_root(args.spec) 2074 - if args.mode == 'uapi': 2075 - cw.p('/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */') 2065 + if args.mode == 'uapi' or args.header: 2066 + cw.p(f'/* SPDX-License-Identifier: {parsed.license} */') 2076 2067 else: 2077 - if args.header: 2078 - cw.p('/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */') 2079 - else: 2080 - cw.p('// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause') 2068 + cw.p(f'// SPDX-License-Identifier: {parsed.license}') 2081 2069 cw.p("/* Do not edit directly, auto-generated from: */") 2082 2070 cw.p(f"/*\t{spec_kernel} */") 2083 2071 cw.p(f"/* YNL-GEN {args.mode} {'header' if args.header else 'source'} */")

+2 -1

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

··· 8 8 dev_addr_lists.sh \ 9 9 mode-1-recovery-updelay.sh \ 10 10 mode-2-recovery-updelay.sh \ 11 - option_prio.sh 11 + option_prio.sh \ 12 + bond-eth-type-change.sh 12 13 13 14 TEST_FILES := \ 14 15 lag_lib.sh \

+85

tools/testing/selftests/drivers/net/bonding/bond-eth-type-change.sh

··· 1 + #!/bin/bash 2 + # SPDX-License-Identifier: GPL-2.0 3 + # 4 + # Test bond device ether type changing 5 + # 6 + 7 + ALL_TESTS=" 8 + bond_test_unsuccessful_enslave_type_change 9 + bond_test_successful_enslave_type_change 10 + " 11 + REQUIRE_MZ=no 12 + NUM_NETIFS=0 13 + lib_dir=$(dirname "$0") 14 + source "$lib_dir"/net_forwarding_lib.sh 15 + 16 + bond_check_flags() 17 + { 18 + local bonddev=$1 19 + 20 + ip -d l sh dev "$bonddev" | grep -q "MASTER" 21 + check_err $? "MASTER flag is missing from the bond device" 22 + 23 + ip -d l sh dev "$bonddev" | grep -q "SLAVE" 24 + check_err $? "SLAVE flag is missing from the bond device" 25 + } 26 + 27 + # test enslaved bond dev type change from ARPHRD_ETHER and back 28 + # this allows us to test both MASTER and SLAVE flags at once 29 + bond_test_enslave_type_change() 30 + { 31 + local test_success=$1 32 + local devbond0="test-bond0" 33 + local devbond1="test-bond1" 34 + local devbond2="test-bond2" 35 + local nonethdev="test-noneth0" 36 + 37 + # create a non-ARPHRD_ETHER device for testing (e.g. nlmon type) 38 + ip link add name "$nonethdev" type nlmon 39 + check_err $? "could not create a non-ARPHRD_ETHER device (nlmon)" 40 + ip link add name "$devbond0" type bond 41 + if [ $test_success -eq 1 ]; then 42 + # we need devbond0 in active-backup mode to successfully enslave nonethdev 43 + ip link set dev "$devbond0" type bond mode active-backup 44 + check_err $? "could not change bond mode to active-backup" 45 + fi 46 + ip link add name "$devbond1" type bond 47 + ip link add name "$devbond2" type bond 48 + ip link set dev "$devbond0" master "$devbond1" 49 + check_err $? "could not enslave $devbond0 to $devbond1" 50 + # change bond type to non-ARPHRD_ETHER 51 + ip link set dev "$nonethdev" master "$devbond0" 1>/dev/null 2>/dev/null 52 + ip link set dev "$nonethdev" nomaster 1>/dev/null 2>/dev/null 53 + # restore ARPHRD_ETHER type by enslaving such device 54 + ip link set dev "$devbond2" master "$devbond0" 55 + check_err $? "could not enslave $devbond2 to $devbond0" 56 + ip link set dev "$devbond1" nomaster 57 + 58 + bond_check_flags "$devbond0" 59 + 60 + # clean up 61 + ip link del dev "$devbond0" 62 + ip link del dev "$devbond1" 63 + ip link del dev "$devbond2" 64 + ip link del dev "$nonethdev" 65 + } 66 + 67 + bond_test_unsuccessful_enslave_type_change() 68 + { 69 + RET=0 70 + 71 + bond_test_enslave_type_change 0 72 + log_test "Change ether type of an enslaved bond device with unsuccessful enslave" 73 + } 74 + 75 + bond_test_successful_enslave_type_change() 76 + { 77 + RET=0 78 + 79 + bond_test_enslave_type_change 1 80 + log_test "Change ether type of an enslaved bond device with successful enslave" 81 + } 82 + 83 + tests_run 84 + 85 + exit "$EXIT_STATUS"

+1

tools/testing/selftests/net/.gitignore

··· 1 1 # SPDX-License-Identifier: GPL-2.0-only 2 2 bind_bhash 3 3 bind_timewait 4 + bind_wildcard 4 5 csum 5 6 cmsg_sender 6 7 diag_uid

+1

tools/testing/selftests/net/Makefile

··· 80 80 TEST_GEN_FILES += csum 81 81 TEST_GEN_FILES += nat6to4.o 82 82 TEST_GEN_FILES += ip_local_port_range 83 + TEST_GEN_FILES += bind_wildcard 83 84 84 85 TEST_FILES := settings 85 86

+114

tools/testing/selftests/net/bind_wildcard.c

··· 1 + // SPDX-License-Identifier: GPL-2.0 2 + /* Copyright Amazon.com Inc. or its affiliates. */ 3 + 4 + #include <sys/socket.h> 5 + #include <netinet/in.h> 6 + 7 + #include "../kselftest_harness.h" 8 + 9 + FIXTURE(bind_wildcard) 10 + { 11 + struct sockaddr_in addr4; 12 + struct sockaddr_in6 addr6; 13 + int expected_errno; 14 + }; 15 + 16 + FIXTURE_VARIANT(bind_wildcard) 17 + { 18 + const __u32 addr4_const; 19 + const struct in6_addr *addr6_const; 20 + }; 21 + 22 + FIXTURE_VARIANT_ADD(bind_wildcard, v4_any_v6_any) 23 + { 24 + .addr4_const = INADDR_ANY, 25 + .addr6_const = &in6addr_any, 26 + }; 27 + 28 + FIXTURE_VARIANT_ADD(bind_wildcard, v4_any_v6_local) 29 + { 30 + .addr4_const = INADDR_ANY, 31 + .addr6_const = &in6addr_loopback, 32 + }; 33 + 34 + FIXTURE_VARIANT_ADD(bind_wildcard, v4_local_v6_any) 35 + { 36 + .addr4_const = INADDR_LOOPBACK, 37 + .addr6_const = &in6addr_any, 38 + }; 39 + 40 + FIXTURE_VARIANT_ADD(bind_wildcard, v4_local_v6_local) 41 + { 42 + .addr4_const = INADDR_LOOPBACK, 43 + .addr6_const = &in6addr_loopback, 44 + }; 45 + 46 + FIXTURE_SETUP(bind_wildcard) 47 + { 48 + self->addr4.sin_family = AF_INET; 49 + self->addr4.sin_port = htons(0); 50 + self->addr4.sin_addr.s_addr = htonl(variant->addr4_const); 51 + 52 + self->addr6.sin6_family = AF_INET6; 53 + self->addr6.sin6_port = htons(0); 54 + self->addr6.sin6_addr = *variant->addr6_const; 55 + 56 + if (variant->addr6_const == &in6addr_any) 57 + self->expected_errno = EADDRINUSE; 58 + else 59 + self->expected_errno = 0; 60 + } 61 + 62 + FIXTURE_TEARDOWN(bind_wildcard) 63 + { 64 + } 65 + 66 + void bind_sockets(struct __test_metadata *_metadata, 67 + FIXTURE_DATA(bind_wildcard) *self, 68 + struct sockaddr *addr1, socklen_t addrlen1, 69 + struct sockaddr *addr2, socklen_t addrlen2) 70 + { 71 + int fd[2]; 72 + int ret; 73 + 74 + fd[0] = socket(addr1->sa_family, SOCK_STREAM, 0); 75 + ASSERT_GT(fd[0], 0); 76 + 77 + ret = bind(fd[0], addr1, addrlen1); 78 + ASSERT_EQ(ret, 0); 79 + 80 + ret = getsockname(fd[0], addr1, &addrlen1); 81 + ASSERT_EQ(ret, 0); 82 + 83 + ((struct sockaddr_in *)addr2)->sin_port = ((struct sockaddr_in *)addr1)->sin_port; 84 + 85 + fd[1] = socket(addr2->sa_family, SOCK_STREAM, 0); 86 + ASSERT_GT(fd[1], 0); 87 + 88 + ret = bind(fd[1], addr2, addrlen2); 89 + if (self->expected_errno) { 90 + ASSERT_EQ(ret, -1); 91 + ASSERT_EQ(errno, self->expected_errno); 92 + } else { 93 + ASSERT_EQ(ret, 0); 94 + } 95 + 96 + close(fd[1]); 97 + close(fd[0]); 98 + } 99 + 100 + TEST_F(bind_wildcard, v4_v6) 101 + { 102 + bind_sockets(_metadata, self, 103 + (struct sockaddr *)&self->addr4, sizeof(self->addr6), 104 + (struct sockaddr *)&self->addr6, sizeof(self->addr6)); 105 + } 106 + 107 + TEST_F(bind_wildcard, v6_v4) 108 + { 109 + bind_sockets(_metadata, self, 110 + (struct sockaddr *)&self->addr6, sizeof(self->addr6), 111 + (struct sockaddr *)&self->addr4, sizeof(self->addr4)); 112 + } 113 + 114 + TEST_HARNESS_MAIN

+31 -5

tools/testing/selftests/net/devlink_port_split.py

··· 59 59 assert stderr == "" 60 60 ports = json.loads(stdout)['port'] 61 61 62 + validate_devlink_output(ports, 'flavour') 63 + 62 64 for port in ports: 63 65 if dev in port: 64 66 if ports[port]['flavour'] == 'physical': ··· 222 220 unsplit(port.bus_info) 223 221 224 222 223 + def validate_devlink_output(devlink_data, target_property=None): 224 + """ 225 + Determine if test should be skipped by checking: 226 + 1. devlink_data contains values 227 + 2. The target_property exist in devlink_data 228 + """ 229 + skip_reason = None 230 + if any(devlink_data.values()): 231 + if target_property: 232 + skip_reason = "{} not found in devlink output, test skipped".format(target_property) 233 + for key in devlink_data: 234 + if target_property in devlink_data[key]: 235 + skip_reason = None 236 + else: 237 + skip_reason = 'devlink output is empty, test skipped' 238 + 239 + if skip_reason: 240 + print(skip_reason) 241 + sys.exit(KSFT_SKIP) 242 + 243 + 225 244 def make_parser(): 226 245 parser = argparse.ArgumentParser(description='A test for port splitting.') 227 246 parser.add_argument('--dev', ··· 263 240 stdout, stderr = run_command(cmd) 264 241 assert stderr == "" 265 242 243 + validate_devlink_output(json.loads(stdout)) 266 244 devs = json.loads(stdout)['dev'] 267 - if devs: 268 - dev = list(devs.keys())[0] 269 - else: 270 - print("no devlink device was found, test skipped") 271 - sys.exit(KSFT_SKIP) 245 + dev = list(devs.keys())[0] 272 246 273 247 cmd = "devlink dev show %s" % dev 274 248 stdout, stderr = run_command(cmd) ··· 275 255 276 256 ports = devlink_ports(dev) 277 257 258 + found_max_lanes = False 278 259 for port in ports.if_names: 279 260 max_lanes = get_max_lanes(port.name) 280 261 ··· 298 277 split_splittable_port(port, lane, max_lanes, dev) 299 278 300 279 lane //= 2 280 + found_max_lanes = True 281 + 282 + if not found_max_lanes: 283 + print(f"Test not started, no port of device {dev} reports max_lanes") 284 + sys.exit(KSFT_SKIP) 301 285 302 286 303 287 if __name__ == "__main__":

+1 -1

tools/testing/selftests/net/mptcp/userspace_pm.sh

··· 240 240 fi 241 241 242 242 stdbuf -o0 -e0 printf "\tExpected value for '%s': '%s', got '%s'.\n" \ 243 - "${var}" "${!var}" "${!exp}" 243 + "${var}" "${!exp}" "${!var}" 244 244 return 1 245 245 } 246 246

+118

tools/testing/vsock/vsock_test.c

··· 860 860 close(fd); 861 861 } 862 862 863 + #define INV_BUF_TEST_DATA_LEN 512 864 + 865 + static void test_inv_buf_client(const struct test_opts *opts, bool stream) 866 + { 867 + unsigned char data[INV_BUF_TEST_DATA_LEN] = {0}; 868 + ssize_t ret; 869 + int fd; 870 + 871 + if (stream) 872 + fd = vsock_stream_connect(opts->peer_cid, 1234); 873 + else 874 + fd = vsock_seqpacket_connect(opts->peer_cid, 1234); 875 + 876 + if (fd < 0) { 877 + perror("connect"); 878 + exit(EXIT_FAILURE); 879 + } 880 + 881 + control_expectln("SENDDONE"); 882 + 883 + /* Use invalid buffer here. */ 884 + ret = recv(fd, NULL, sizeof(data), 0); 885 + if (ret != -1) { 886 + fprintf(stderr, "expected recv(2) failure, got %zi\n", ret); 887 + exit(EXIT_FAILURE); 888 + } 889 + 890 + if (errno != ENOMEM) { 891 + fprintf(stderr, "unexpected recv(2) errno %d\n", errno); 892 + exit(EXIT_FAILURE); 893 + } 894 + 895 + ret = recv(fd, data, sizeof(data), MSG_DONTWAIT); 896 + 897 + if (stream) { 898 + /* For SOCK_STREAM we must continue reading. */ 899 + if (ret != sizeof(data)) { 900 + fprintf(stderr, "expected recv(2) success, got %zi\n", ret); 901 + exit(EXIT_FAILURE); 902 + } 903 + /* Don't check errno in case of success. */ 904 + } else { 905 + /* For SOCK_SEQPACKET socket's queue must be empty. */ 906 + if (ret != -1) { 907 + fprintf(stderr, "expected recv(2) failure, got %zi\n", ret); 908 + exit(EXIT_FAILURE); 909 + } 910 + 911 + if (errno != EAGAIN) { 912 + fprintf(stderr, "unexpected recv(2) errno %d\n", errno); 913 + exit(EXIT_FAILURE); 914 + } 915 + } 916 + 917 + control_writeln("DONE"); 918 + 919 + close(fd); 920 + } 921 + 922 + static void test_inv_buf_server(const struct test_opts *opts, bool stream) 923 + { 924 + unsigned char data[INV_BUF_TEST_DATA_LEN] = {0}; 925 + ssize_t res; 926 + int fd; 927 + 928 + if (stream) 929 + fd = vsock_stream_accept(VMADDR_CID_ANY, 1234, NULL); 930 + else 931 + fd = vsock_seqpacket_accept(VMADDR_CID_ANY, 1234, NULL); 932 + 933 + if (fd < 0) { 934 + perror("accept"); 935 + exit(EXIT_FAILURE); 936 + } 937 + 938 + res = send(fd, data, sizeof(data), 0); 939 + if (res != sizeof(data)) { 940 + fprintf(stderr, "unexpected send(2) result %zi\n", res); 941 + exit(EXIT_FAILURE); 942 + } 943 + 944 + control_writeln("SENDDONE"); 945 + 946 + control_expectln("DONE"); 947 + 948 + close(fd); 949 + } 950 + 951 + static void test_stream_inv_buf_client(const struct test_opts *opts) 952 + { 953 + test_inv_buf_client(opts, true); 954 + } 955 + 956 + static void test_stream_inv_buf_server(const struct test_opts *opts) 957 + { 958 + test_inv_buf_server(opts, true); 959 + } 960 + 961 + static void test_seqpacket_inv_buf_client(const struct test_opts *opts) 962 + { 963 + test_inv_buf_client(opts, false); 964 + } 965 + 966 + static void test_seqpacket_inv_buf_server(const struct test_opts *opts) 967 + { 968 + test_inv_buf_server(opts, false); 969 + } 970 + 863 971 static struct test_case test_cases[] = { 864 972 { 865 973 .name = "SOCK_STREAM connection reset", ··· 1027 919 .name = "SOCK_SEQPACKET big message", 1028 920 .run_client = test_seqpacket_bigmsg_client, 1029 921 .run_server = test_seqpacket_bigmsg_server, 922 + }, 923 + { 924 + .name = "SOCK_STREAM test invalid buffer", 925 + .run_client = test_stream_inv_buf_client, 926 + .run_server = test_stream_inv_buf_server, 927 + }, 928 + { 929 + .name = "SOCK_SEQPACKET test invalid buffer", 930 + .run_client = test_seqpacket_inv_buf_client, 931 + .run_server = test_seqpacket_inv_buf_server, 1030 932 }, 1031 933 {}, 1032 934 };

Configure Feed

Configure Feed