Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

-7

Documentation/devicetree/bindings/net/adi,adin.yaml

··· 36 36 enum: [ 4, 8, 12, 16, 20, 24 ] 37 37 default: 8 38 38 39 - adi,disable-energy-detect: 40 - description: | 41 - Disables Energy Detect Powerdown Mode (default disabled, i.e energy detect 42 - is enabled if this property is unspecified) 43 - type: boolean 44 - 45 39 examples: 46 40 - | 47 41 ethernet { ··· 62 68 reg = <1>; 63 69 64 70 adi,fifo-depth-bits = <16>; 65 - adi,disable-energy-detect; 66 71 }; 67 72 };

+30 -2

Documentation/devicetree/bindings/net/micrel-ksz90x1.txt

··· 12 12 KSZ9021: 13 13 14 14 All skew control options are specified in picoseconds. The minimum 15 - value is 0, the maximum value is 3000, and it is incremented by 200ps 16 - steps. 15 + value is 0, the maximum value is 3000, and it can be specified in 200ps 16 + steps, *but* these values are in not fact what you get because this chip's 17 + skew values actually increase in 120ps steps, starting from -840ps. The 18 + incorrect values came from an error in the original KSZ9021 datasheet 19 + before it was corrected in revision 1.2 (Feb 2014), but it is too late to 20 + change the driver now because of the many existing device trees that have 21 + been created using values that go up in increments of 200. 22 + 23 + The following table shows the actual skew delay you will get for each of the 24 + possible devicetree values, and the number that will be programmed into the 25 + corresponding pad skew register: 26 + 27 + Device Tree Value Delay Pad Skew Register Value 28 + ----------------------------------------------------- 29 + 0 -840ps 0000 30 + 200 -720ps 0001 31 + 400 -600ps 0010 32 + 600 -480ps 0011 33 + 800 -360ps 0100 34 + 1000 -240ps 0101 35 + 1200 -120ps 0110 36 + 1400 0ps 0111 37 + 1600 120ps 1000 38 + 1800 240ps 1001 39 + 2000 360ps 1010 40 + 2200 480ps 1011 41 + 2400 600ps 1100 42 + 2600 720ps 1101 43 + 2800 840ps 1110 44 + 3000 960ps 1111 17 45 18 46 Optional properties: 19 47

+1

Documentation/devicetree/bindings/net/renesas,ravb.txt

··· 18 18 R-Car Gen2 and RZ/G1 devices. 19 19 20 20 - "renesas,etheravb-r8a774a1" for the R8A774A1 SoC. 21 + - "renesas,etheravb-r8a774b1" for the R8A774B1 SoC. 21 22 - "renesas,etheravb-r8a774c0" for the R8A774C0 SoC. 22 23 - "renesas,etheravb-r8a7795" for the R8A7795 SoC. 23 24 - "renesas,etheravb-r8a7796" for the R8A7796 SoC.

+1 -1

Documentation/devicetree/bindings/net/snps,dwmac.yaml

··· 113 113 const: stmmaceth 114 114 115 115 mac-mode: 116 - maxItems: 1 116 + $ref: ethernet-controller.yaml#/properties/phy-connection-type 117 117 description: 118 118 The property is identical to 'phy-mode', and assumes that there is mode 119 119 converter in-between the MAC & PHY (e.g. GMII-to-RGMII). This converter

+2 -1

Documentation/networking/devlink-trap.rst

··· 143 143 * - ``port_list_is_empty`` 144 144 - ``drop`` 145 145 - Traps packets that the device decided to drop in case they need to be 146 - flooded and the flood list is empty 146 + flooded (e.g., unknown unicast, unregistered multicast) and there are 147 + no ports the packets should be flooded to 147 148 * - ``port_loopback_filter`` 148 149 - ``drop`` 149 150 - Traps packets that the device decided to drop in case after layer 2

+1

MAINTAINERS

··· 643 643 644 644 FORCEDETH GIGABIT ETHERNET DRIVER 645 645 M: Rain River <rain.1986.08.12@gmail.com> 646 + M: Zhu Yanjun <yanjun.zhu@oracle.com> 646 647 L: netdev@vger.kernel.org 647 648 S: Maintained 648 649 F: drivers/net/ethernet/nvidia/*

+1 -1

drivers/atm/he.c

··· 1690 1690 1691 1691 if (RBRQ_HBUF_ERR(he_dev->rbrq_head)) { 1692 1692 hprintk("HBUF_ERR! (cid 0x%x)\n", cid); 1693 - atomic_inc(&vcc->stats->rx_drop); 1693 + atomic_inc(&vcc->stats->rx_drop); 1694 1694 goto return_host_buffers; 1695 1695 } 1696 1696

+1 -1

drivers/infiniband/core/addr.c

··· 352 352 353 353 if (family == AF_INET) { 354 354 rt = container_of(dst, struct rtable, dst); 355 - return rt->rt_gw_family == AF_INET; 355 + return rt->rt_uses_gateway; 356 356 } 357 357 358 358 rt6 = container_of(dst, struct rt6_info, dst);

+2

drivers/isdn/mISDN/socket.c

··· 754 754 755 755 if (sock->type != SOCK_RAW) 756 756 return -ESOCKTNOSUPPORT; 757 + if (!capable(CAP_NET_RAW)) 758 + return -EPERM; 757 759 758 760 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern); 759 761 if (!sk)

+1 -1

drivers/net/Kconfig

··· 487 487 depends on ACPI 488 488 help 489 489 This driver provides support for Extended Socket network device 490 - on Extended Partitioning of FUJITSU PRIMEQUEST 2000 E2 series. 490 + on Extended Partitioning of FUJITSU PRIMEQUEST 2000 E2 series. 491 491 492 492 config THUNDERBOLT_NET 493 493 tristate "Networking over Thunderbolt cable"

+11 -11

drivers/net/arcnet/Kconfig

··· 56 56 tristate "Enable CAP mode packet interface" 57 57 help 58 58 ARCnet "cap mode" packet encapsulation. Used to get the hardware 59 - acknowledge back to userspace. After the initial protocol byte every 60 - packet is stuffed with an extra 4 byte "cookie" which doesn't 61 - actually appear on the network. After transmit the driver will send 62 - back a packet with protocol byte 0 containing the status of the 63 - transmission: 64 - 0=no hardware acknowledge 65 - 1=excessive nak 66 - 2=transmission accepted by the receiver hardware 59 + acknowledge back to userspace. After the initial protocol byte every 60 + packet is stuffed with an extra 4 byte "cookie" which doesn't 61 + actually appear on the network. After transmit the driver will send 62 + back a packet with protocol byte 0 containing the status of the 63 + transmission: 64 + 0=no hardware acknowledge 65 + 1=excessive nak 66 + 2=transmission accepted by the receiver hardware 67 67 68 - Received packets are also stuffed with the extra 4 bytes but it will 69 - be random data. 68 + Received packets are also stuffed with the extra 4 bytes but it will 69 + be random data. 70 70 71 - Cap only listens to protocol 1-8. 71 + Cap only listens to protocol 1-8. 72 72 73 73 config ARCNET_COM90xx 74 74 tristate "ARCnet COM90xx (normal) chipset driver"

+17 -14

drivers/net/arcnet/arcnet.c

··· 1063 1063 static void arcnet_rx(struct net_device *dev, int bufnum) 1064 1064 { 1065 1065 struct arcnet_local *lp = netdev_priv(dev); 1066 - struct archdr pkt; 1066 + union { 1067 + struct archdr pkt; 1068 + char buf[512]; 1069 + } rxdata; 1067 1070 struct arc_rfc1201 *soft; 1068 1071 int length, ofs; 1069 1072 1070 - soft = &pkt.soft.rfc1201; 1073 + soft = &rxdata.pkt.soft.rfc1201; 1071 1074 1072 - lp->hw.copy_from_card(dev, bufnum, 0, &pkt, ARC_HDR_SIZE); 1073 - if (pkt.hard.offset[0]) { 1074 - ofs = pkt.hard.offset[0]; 1075 + lp->hw.copy_from_card(dev, bufnum, 0, &rxdata.pkt, ARC_HDR_SIZE); 1076 + if (rxdata.pkt.hard.offset[0]) { 1077 + ofs = rxdata.pkt.hard.offset[0]; 1075 1078 length = 256 - ofs; 1076 1079 } else { 1077 - ofs = pkt.hard.offset[1]; 1080 + ofs = rxdata.pkt.hard.offset[1]; 1078 1081 length = 512 - ofs; 1079 1082 } 1080 1083 1081 1084 /* get the full header, if possible */ 1082 - if (sizeof(pkt.soft) <= length) { 1083 - lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(pkt.soft)); 1085 + if (sizeof(rxdata.pkt.soft) <= length) { 1086 + lp->hw.copy_from_card(dev, bufnum, ofs, soft, sizeof(rxdata.pkt.soft)); 1084 1087 } else { 1085 - memset(&pkt.soft, 0, sizeof(pkt.soft)); 1088 + memset(&rxdata.pkt.soft, 0, sizeof(rxdata.pkt.soft)); 1086 1089 lp->hw.copy_from_card(dev, bufnum, ofs, soft, length); 1087 1090 } 1088 1091 1089 1092 arc_printk(D_DURING, dev, "Buffer #%d: received packet from %02Xh to %02Xh (%d+4 bytes)\n", 1090 - bufnum, pkt.hard.source, pkt.hard.dest, length); 1093 + bufnum, rxdata.pkt.hard.source, rxdata.pkt.hard.dest, length); 1091 1094 1092 1095 dev->stats.rx_packets++; 1093 1096 dev->stats.rx_bytes += length + ARC_HDR_SIZE; ··· 1099 1096 if (arc_proto_map[soft->proto]->is_ip) { 1100 1097 if (BUGLVL(D_PROTO)) { 1101 1098 struct ArcProto 1102 - *oldp = arc_proto_map[lp->default_proto[pkt.hard.source]], 1099 + *oldp = arc_proto_map[lp->default_proto[rxdata.pkt.hard.source]], 1103 1100 *newp = arc_proto_map[soft->proto]; 1104 1101 1105 1102 if (oldp != newp) { 1106 1103 arc_printk(D_PROTO, dev, 1107 1104 "got protocol %02Xh; encap for host %02Xh is now '%c' (was '%c')\n", 1108 - soft->proto, pkt.hard.source, 1105 + soft->proto, rxdata.pkt.hard.source, 1109 1106 newp->suffix, oldp->suffix); 1110 1107 } 1111 1108 } ··· 1114 1111 lp->default_proto[0] = soft->proto; 1115 1112 1116 1113 /* in striking contrast, the following isn't a hack. */ 1117 - lp->default_proto[pkt.hard.source] = soft->proto; 1114 + lp->default_proto[rxdata.pkt.hard.source] = soft->proto; 1118 1115 } 1119 1116 /* call the protocol-specific receiver. */ 1120 - arc_proto_map[soft->proto]->rx(dev, bufnum, &pkt, length); 1117 + arc_proto_map[soft->proto]->rx(dev, bufnum, &rxdata.pkt, length); 1121 1118 } 1122 1119 1123 1120 static void null_rx(struct net_device *dev, int bufnum,

+4 -4

drivers/net/can/usb/Kconfig

··· 15 15 from EMS Dr. Thomas Wuensche (http://www.ems-wuensche.de). 16 16 17 17 config CAN_ESD_USB2 18 - tristate "ESD USB/2 CAN/USB interface" 19 - ---help--- 20 - This driver supports the CAN-USB/2 interface 21 - from esd electronic system design gmbh (http://www.esd.eu). 18 + tristate "ESD USB/2 CAN/USB interface" 19 + ---help--- 20 + This driver supports the CAN-USB/2 interface 21 + from esd electronic system design gmbh (http://www.esd.eu). 22 22 23 23 config CAN_GS_USB 24 24 tristate "Geschwister Schneider UG interfaces"

+2 -2

drivers/net/dsa/b53/b53_serdes.h

··· 1 - /* SPDX-License-Identifier: GPL-2.0 or BSD-3-Clause 2 - * 1 + /* SPDX-License-Identifier: GPL-2.0 or BSD-3-Clause */ 2 + /* 3 3 * Northstar Plus switch SerDes/SGMII PHY definitions 4 4 * 5 5 * Copyright (C) 2018 Florian Fainelli <f.fainelli@gmail.com>

+1 -1

drivers/net/dsa/lantiq_pce.h

··· 1 - // SPDX-License-Identifier: GPL-2.0 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 2 /* 3 3 * PCE microcode extracted from UGW 7.1.1 switch api 4 4 *

+1 -1

drivers/net/dsa/microchip/ksz_common.h

··· 303 303 { \ 304 304 .name = #width, \ 305 305 .val_bits = (width), \ 306 - .reg_stride = (width) / 8, \ 306 + .reg_stride = 1, \ 307 307 .reg_bits = (regbits) + (regalign), \ 308 308 .pad_bits = (regpad), \ 309 309 .max_register = BIT(regbits) - 1, \

+3

drivers/net/dsa/qca8k.c

··· 936 936 { 937 937 struct qca8k_priv *priv = (struct qca8k_priv *)ds->priv; 938 938 939 + if (!dsa_is_user_port(ds, port)) 940 + return 0; 941 + 939 942 qca8k_port_set_status(priv, port, 1); 940 943 priv->port_sts[port].enabled = 1; 941 944

+1

drivers/net/dsa/sja1105/Kconfig

··· 27 27 config NET_DSA_SJA1105_TAS 28 28 bool "Support for the Time-Aware Scheduler on NXP SJA1105" 29 29 depends on NET_DSA_SJA1105 30 + depends on NET_SCH_TAPRIO 30 31 help 31 32 This enables support for the TTEthernet-based egress scheduling 32 33 engine in the SJA1105 DSA driver, which is controlled using a

-11

drivers/net/ethernet/Kconfig

··· 140 140 source "drivers/net/ethernet/netronome/Kconfig" 141 141 source "drivers/net/ethernet/ni/Kconfig" 142 142 source "drivers/net/ethernet/8390/Kconfig" 143 - 144 - config NET_NETX 145 - tristate "NetX Ethernet support" 146 - select MII 147 - depends on ARCH_NETX 148 - ---help--- 149 - This is support for the Hilscher netX builtin Ethernet ports 150 - 151 - To compile this driver as a module, choose M here. The module 152 - will be called netx-eth. 153 - 154 143 source "drivers/net/ethernet/nvidia/Kconfig" 155 144 source "drivers/net/ethernet/nxp/Kconfig" 156 145 source "drivers/net/ethernet/oki-semi/Kconfig"

-1

drivers/net/ethernet/Makefile

··· 64 64 obj-$(CONFIG_NET_VENDOR_NETERION) += neterion/ 65 65 obj-$(CONFIG_NET_VENDOR_NETRONOME) += netronome/ 66 66 obj-$(CONFIG_NET_VENDOR_NI) += ni/ 67 - obj-$(CONFIG_NET_NETX) += netx-eth.o 68 67 obj-$(CONFIG_NET_VENDOR_NVIDIA) += nvidia/ 69 68 obj-$(CONFIG_LPC_ENET) += nxp/ 70 69 obj-$(CONFIG_NET_VENDOR_OKI) += oki-semi/

+5 -5

drivers/net/ethernet/allwinner/Kconfig

··· 21 21 if NET_VENDOR_ALLWINNER 22 22 23 23 config SUN4I_EMAC 24 - tristate "Allwinner A10 EMAC support" 24 + tristate "Allwinner A10 EMAC support" 25 25 depends on ARCH_SUNXI 26 26 depends on OF 27 27 select CRC32 28 28 select MII 29 29 select PHYLIB 30 30 select MDIO_SUN4I 31 - ---help--- 32 - Support for Allwinner A10 EMAC ethernet driver. 31 + ---help--- 32 + Support for Allwinner A10 EMAC ethernet driver. 33 33 34 - To compile this driver as a module, choose M here. The module 35 - will be called sun4i-emac. 34 + To compile this driver as a module, choose M here. The module 35 + will be called sun4i-emac. 36 36 37 37 endif # NET_VENDOR_ALLWINNER

+1

drivers/net/ethernet/amazon/Kconfig

··· 19 19 config ENA_ETHERNET 20 20 tristate "Elastic Network Adapter (ENA) support" 21 21 depends on PCI_MSI && !CPU_BIG_ENDIAN 22 + select DIMLIB 22 23 ---help--- 23 24 This driver supports Elastic Network Adapter (ENA)" 24 25

+2 -2

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

··· 211 211 212 212 pkt_ctrl->curr_bounce_buf = 213 213 ena_com_get_next_bounce_buffer(&io_sq->bounce_buf_ctrl); 214 - memset(io_sq->llq_buf_ctrl.curr_bounce_buf, 215 - 0x0, llq_info->desc_list_entry_size); 214 + memset(io_sq->llq_buf_ctrl.curr_bounce_buf, 215 + 0x0, llq_info->desc_list_entry_size); 216 216 217 217 pkt_ctrl->idx = 0; 218 218 if (unlikely(llq_info->desc_stride_ctrl == ENA_ADMIN_SINGLE_DESC_PER_ENTRY))

+6 -9

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

··· 306 306 { 307 307 struct aq_vec_s *self = private; 308 308 u64 irq_mask = 0U; 309 - irqreturn_t err = 0; 309 + int err; 310 310 311 - if (!self) { 312 - err = -EINVAL; 313 - goto err_exit; 314 - } 311 + if (!self) 312 + return IRQ_NONE; 315 313 err = self->aq_hw_ops->hw_irq_read(self->aq_hw, &irq_mask); 316 314 if (err < 0) 317 - goto err_exit; 315 + return IRQ_NONE; 318 316 319 317 if (irq_mask) { 320 318 self->aq_hw_ops->hw_irq_disable(self->aq_hw, ··· 320 322 napi_schedule(&self->napi); 321 323 } else { 322 324 self->aq_hw_ops->hw_irq_enable(self->aq_hw, 1U); 323 - err = IRQ_NONE; 325 + return IRQ_NONE; 324 326 } 325 327 326 - err_exit: 327 - return err >= 0 ? IRQ_HANDLED : IRQ_NONE; 328 + return IRQ_HANDLED; 328 329 } 329 330 330 331 cpumask_t *aq_vec_get_affinity_mask(struct aq_vec_s *self)

+1 -1

drivers/net/ethernet/broadcom/bcmsysport.c

··· 2481 2481 2482 2482 priv->phy_interface = of_get_phy_mode(dn); 2483 2483 /* Default to GMII interface mode */ 2484 - if (priv->phy_interface < 0) 2484 + if ((int)priv->phy_interface < 0) 2485 2485 priv->phy_interface = PHY_INTERFACE_MODE_GMII; 2486 2486 2487 2487 /* In the case of a fixed PHY, the DT node associated

+2 -3

drivers/net/ethernet/cadence/macb_main.c

··· 165 165 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT 166 166 static struct macb_dma_desc_64 *macb_64b_desc(struct macb *bp, struct macb_dma_desc *desc) 167 167 { 168 - if (bp->hw_dma_cap & HW_DMA_CAP_64B) 169 - return (struct macb_dma_desc_64 *)((void *)desc + sizeof(struct macb_dma_desc)); 170 - return NULL; 168 + return (struct macb_dma_desc_64 *)((void *)desc 169 + + sizeof(struct macb_dma_desc)); 171 170 } 172 171 #endif 173 172

+1 -1

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

··· 5701 5701 whoami = t4_read_reg(adapter, PL_WHOAMI_A); 5702 5702 pci_read_config_word(pdev, PCI_DEVICE_ID, &device_id); 5703 5703 chip = t4_get_chip_type(adapter, CHELSIO_PCI_ID_VER(device_id)); 5704 - if (chip < 0) { 5704 + if ((int)chip < 0) { 5705 5705 dev_err(&pdev->dev, "Device %d is not supported\n", device_id); 5706 5706 err = chip; 5707 5707 goto out_free_adapter;

+1 -1

drivers/net/ethernet/emulex/benet/Kconfig

··· 48 48 chipsets. (e.g. OneConnect OCe14xxx) 49 49 50 50 comment "WARNING: be2net is useless without any enabled chip" 51 - depends on BE2NET_BE2=n && BE2NET_BE3=n && BE2NET_LANCER=n && \ 51 + depends on BE2NET_BE2=n && BE2NET_BE3=n && BE2NET_LANCER=n && \ 52 52 BE2NET_SKYHAWK=n && BE2NET

+1 -1

drivers/net/ethernet/freescale/enetc/enetc_pf.c

··· 785 785 } 786 786 787 787 priv->if_mode = of_get_phy_mode(np); 788 - if (priv->if_mode < 0) { 788 + if ((int)priv->if_mode < 0) { 789 789 dev_err(priv->dev, "missing phy type\n"); 790 790 of_node_put(priv->phy_node); 791 791 if (of_phy_is_fixed_link(np))

+1 -1

drivers/net/ethernet/freescale/gianfar.c

··· 2067 2067 return 0; 2068 2068 } 2069 2069 2070 - void reset_gfar(struct net_device *ndev) 2070 + static void reset_gfar(struct net_device *ndev) 2071 2071 { 2072 2072 struct gfar_private *priv = netdev_priv(ndev); 2073 2073

+1 -1

drivers/net/ethernet/hisilicon/hix5hd2_gmac.c

··· 1194 1194 goto err_free_mdio; 1195 1195 1196 1196 priv->phy_mode = of_get_phy_mode(node); 1197 - if (priv->phy_mode < 0) { 1197 + if ((int)priv->phy_mode < 0) { 1198 1198 netdev_err(ndev, "not find phy-mode\n"); 1199 1199 ret = -EINVAL; 1200 1200 goto err_mdiobus;

+190 -81

drivers/net/ethernet/ibm/ibmvnic.c

··· 1207 1207 struct ibmvnic_adapter *adapter = netdev_priv(netdev); 1208 1208 1209 1209 /* ensure that transmissions are stopped if called by do_reset */ 1210 - if (adapter->resetting) 1210 + if (test_bit(0, &adapter->resetting)) 1211 1211 netif_tx_disable(netdev); 1212 1212 else 1213 1213 netif_tx_stop_all_queues(netdev); ··· 1428 1428 u8 proto = 0; 1429 1429 netdev_tx_t ret = NETDEV_TX_OK; 1430 1430 1431 - if (adapter->resetting) { 1431 + if (test_bit(0, &adapter->resetting)) { 1432 1432 if (!netif_subqueue_stopped(netdev, skb)) 1433 1433 netif_stop_subqueue(netdev, queue_num); 1434 1434 dev_kfree_skb_any(skb); ··· 1724 1724 } 1725 1725 1726 1726 /** 1727 + * do_change_param_reset returns zero if we are able to keep processing reset 1728 + * events, or non-zero if we hit a fatal error and must halt. 1729 + */ 1730 + static int do_change_param_reset(struct ibmvnic_adapter *adapter, 1731 + struct ibmvnic_rwi *rwi, 1732 + u32 reset_state) 1733 + { 1734 + struct net_device *netdev = adapter->netdev; 1735 + int i, rc; 1736 + 1737 + netdev_dbg(adapter->netdev, "Change param resetting driver (%d)\n", 1738 + rwi->reset_reason); 1739 + 1740 + netif_carrier_off(netdev); 1741 + adapter->reset_reason = rwi->reset_reason; 1742 + 1743 + ibmvnic_cleanup(netdev); 1744 + 1745 + if (reset_state == VNIC_OPEN) { 1746 + rc = __ibmvnic_close(netdev); 1747 + if (rc) 1748 + return rc; 1749 + } 1750 + 1751 + release_resources(adapter); 1752 + release_sub_crqs(adapter, 1); 1753 + release_crq_queue(adapter); 1754 + 1755 + adapter->state = VNIC_PROBED; 1756 + 1757 + rc = init_crq_queue(adapter); 1758 + 1759 + if (rc) { 1760 + netdev_err(adapter->netdev, 1761 + "Couldn't initialize crq. rc=%d\n", rc); 1762 + return rc; 1763 + } 1764 + 1765 + rc = ibmvnic_reset_init(adapter); 1766 + if (rc) 1767 + return IBMVNIC_INIT_FAILED; 1768 + 1769 + /* If the adapter was in PROBE state prior to the reset, 1770 + * exit here. 1771 + */ 1772 + if (reset_state == VNIC_PROBED) 1773 + return 0; 1774 + 1775 + rc = ibmvnic_login(netdev); 1776 + if (rc) { 1777 + adapter->state = reset_state; 1778 + return rc; 1779 + } 1780 + 1781 + rc = init_resources(adapter); 1782 + if (rc) 1783 + return rc; 1784 + 1785 + ibmvnic_disable_irqs(adapter); 1786 + 1787 + adapter->state = VNIC_CLOSED; 1788 + 1789 + if (reset_state == VNIC_CLOSED) 1790 + return 0; 1791 + 1792 + rc = __ibmvnic_open(netdev); 1793 + if (rc) 1794 + return IBMVNIC_OPEN_FAILED; 1795 + 1796 + /* refresh device's multicast list */ 1797 + ibmvnic_set_multi(netdev); 1798 + 1799 + /* kick napi */ 1800 + for (i = 0; i < adapter->req_rx_queues; i++) 1801 + napi_schedule(&adapter->napi[i]); 1802 + 1803 + return 0; 1804 + } 1805 + 1806 + /** 1727 1807 * do_reset returns zero if we are able to keep processing reset events, or 1728 1808 * non-zero if we hit a fatal error and must halt. 1729 1809 */ ··· 1818 1738 netdev_dbg(adapter->netdev, "Re-setting driver (%d)\n", 1819 1739 rwi->reset_reason); 1820 1740 1741 + rtnl_lock(); 1742 + 1821 1743 netif_carrier_off(netdev); 1822 1744 adapter->reset_reason = rwi->reset_reason; 1823 1745 ··· 1833 1751 if (reset_state == VNIC_OPEN && 1834 1752 adapter->reset_reason != VNIC_RESET_MOBILITY && 1835 1753 adapter->reset_reason != VNIC_RESET_FAILOVER) { 1836 - rc = __ibmvnic_close(netdev); 1837 - if (rc) 1838 - return rc; 1839 - } 1754 + adapter->state = VNIC_CLOSING; 1840 1755 1841 - if (adapter->reset_reason == VNIC_RESET_CHANGE_PARAM || 1842 - adapter->wait_for_reset) { 1843 - release_resources(adapter); 1844 - release_sub_crqs(adapter, 1); 1845 - release_crq_queue(adapter); 1756 + /* Release the RTNL lock before link state change and 1757 + * re-acquire after the link state change to allow 1758 + * linkwatch_event to grab the RTNL lock and run during 1759 + * a reset. 1760 + */ 1761 + rtnl_unlock(); 1762 + rc = set_link_state(adapter, IBMVNIC_LOGICAL_LNK_DN); 1763 + rtnl_lock(); 1764 + if (rc) 1765 + goto out; 1766 + 1767 + if (adapter->state != VNIC_CLOSING) { 1768 + rc = -1; 1769 + goto out; 1770 + } 1771 + 1772 + adapter->state = VNIC_CLOSED; 1846 1773 } 1847 1774 1848 1775 if (adapter->reset_reason != VNIC_RESET_NON_FATAL) { ··· 1860 1769 */ 1861 1770 adapter->state = VNIC_PROBED; 1862 1771 1863 - if (adapter->wait_for_reset) { 1864 - rc = init_crq_queue(adapter); 1865 - } else if (adapter->reset_reason == VNIC_RESET_MOBILITY) { 1772 + if (adapter->reset_reason == VNIC_RESET_MOBILITY) { 1866 1773 rc = ibmvnic_reenable_crq_queue(adapter); 1867 1774 release_sub_crqs(adapter, 1); 1868 1775 } else { ··· 1872 1783 if (rc) { 1873 1784 netdev_err(adapter->netdev, 1874 1785 "Couldn't initialize crq. rc=%d\n", rc); 1875 - return rc; 1786 + goto out; 1876 1787 } 1877 1788 1878 1789 rc = ibmvnic_reset_init(adapter); 1879 - if (rc) 1880 - return IBMVNIC_INIT_FAILED; 1790 + if (rc) { 1791 + rc = IBMVNIC_INIT_FAILED; 1792 + goto out; 1793 + } 1881 1794 1882 1795 /* If the adapter was in PROBE state prior to the reset, 1883 1796 * exit here. 1884 1797 */ 1885 - if (reset_state == VNIC_PROBED) 1886 - return 0; 1798 + if (reset_state == VNIC_PROBED) { 1799 + rc = 0; 1800 + goto out; 1801 + } 1887 1802 1888 1803 rc = ibmvnic_login(netdev); 1889 1804 if (rc) { 1890 1805 adapter->state = reset_state; 1891 - return rc; 1806 + goto out; 1892 1807 } 1893 1808 1894 - if (adapter->reset_reason == VNIC_RESET_CHANGE_PARAM || 1895 - adapter->wait_for_reset) { 1896 - rc = init_resources(adapter); 1897 - if (rc) 1898 - return rc; 1899 - } else if (adapter->req_rx_queues != old_num_rx_queues || 1900 - adapter->req_tx_queues != old_num_tx_queues || 1901 - adapter->req_rx_add_entries_per_subcrq != 1902 - old_num_rx_slots || 1903 - adapter->req_tx_entries_per_subcrq != 1904 - old_num_tx_slots) { 1809 + if (adapter->req_rx_queues != old_num_rx_queues || 1810 + adapter->req_tx_queues != old_num_tx_queues || 1811 + adapter->req_rx_add_entries_per_subcrq != 1812 + old_num_rx_slots || 1813 + adapter->req_tx_entries_per_subcrq != 1814 + old_num_tx_slots) { 1905 1815 release_rx_pools(adapter); 1906 1816 release_tx_pools(adapter); 1907 1817 release_napi(adapter); ··· 1908 1820 1909 1821 rc = init_resources(adapter); 1910 1822 if (rc) 1911 - return rc; 1823 + goto out; 1912 1824 1913 1825 } else { 1914 1826 rc = reset_tx_pools(adapter); 1915 1827 if (rc) 1916 - return rc; 1828 + goto out; 1917 1829 1918 1830 rc = reset_rx_pools(adapter); 1919 1831 if (rc) 1920 - return rc; 1832 + goto out; 1921 1833 } 1922 1834 ibmvnic_disable_irqs(adapter); 1923 1835 } 1924 1836 adapter->state = VNIC_CLOSED; 1925 1837 1926 - if (reset_state == VNIC_CLOSED) 1927 - return 0; 1838 + if (reset_state == VNIC_CLOSED) { 1839 + rc = 0; 1840 + goto out; 1841 + } 1928 1842 1929 1843 rc = __ibmvnic_open(netdev); 1930 1844 if (rc) { 1931 - if (list_empty(&adapter->rwi_list)) 1932 - adapter->state = VNIC_CLOSED; 1933 - else 1934 - adapter->state = reset_state; 1935 - 1936 - return 0; 1845 + rc = IBMVNIC_OPEN_FAILED; 1846 + goto out; 1937 1847 } 1938 1848 1939 1849 /* refresh device's multicast list */ ··· 1941 1855 for (i = 0; i < adapter->req_rx_queues; i++) 1942 1856 napi_schedule(&adapter->napi[i]); 1943 1857 1944 - if (adapter->reset_reason != VNIC_RESET_FAILOVER && 1945 - adapter->reset_reason != VNIC_RESET_CHANGE_PARAM) 1858 + if (adapter->reset_reason != VNIC_RESET_FAILOVER) 1946 1859 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, netdev); 1947 1860 1948 - return 0; 1861 + rc = 0; 1862 + 1863 + out: 1864 + rtnl_unlock(); 1865 + 1866 + return rc; 1949 1867 } 1950 1868 1951 1869 static int do_hard_reset(struct ibmvnic_adapter *adapter, ··· 2009 1919 return 0; 2010 1920 2011 1921 rc = __ibmvnic_open(netdev); 2012 - if (rc) { 2013 - if (list_empty(&adapter->rwi_list)) 2014 - adapter->state = VNIC_CLOSED; 2015 - else 2016 - adapter->state = reset_state; 2017 - 2018 - return 0; 2019 - } 1922 + if (rc) 1923 + return IBMVNIC_OPEN_FAILED; 2020 1924 2021 1925 return 0; 2022 1926 } ··· 2049 1965 { 2050 1966 struct ibmvnic_rwi *rwi; 2051 1967 struct ibmvnic_adapter *adapter; 2052 - bool we_lock_rtnl = false; 2053 1968 u32 reset_state; 2054 1969 int rc = 0; 2055 1970 2056 1971 adapter = container_of(work, struct ibmvnic_adapter, ibmvnic_reset); 2057 1972 2058 - /* netif_set_real_num_xx_queues needs to take rtnl lock here 2059 - * unless wait_for_reset is set, in which case the rtnl lock 2060 - * has already been taken before initializing the reset 2061 - */ 2062 - if (!adapter->wait_for_reset) { 2063 - rtnl_lock(); 2064 - we_lock_rtnl = true; 1973 + if (test_and_set_bit_lock(0, &adapter->resetting)) { 1974 + schedule_delayed_work(&adapter->ibmvnic_delayed_reset, 1975 + IBMVNIC_RESET_DELAY); 1976 + return; 2065 1977 } 1978 + 2066 1979 reset_state = adapter->state; 2067 1980 2068 1981 rwi = get_next_rwi(adapter); ··· 2071 1990 break; 2072 1991 } 2073 1992 2074 - if (adapter->force_reset_recovery) { 2075 - adapter->force_reset_recovery = false; 2076 - rc = do_hard_reset(adapter, rwi, reset_state); 1993 + if (rwi->reset_reason == VNIC_RESET_CHANGE_PARAM) { 1994 + /* CHANGE_PARAM requestor holds rtnl_lock */ 1995 + rc = do_change_param_reset(adapter, rwi, reset_state); 1996 + } else if (adapter->force_reset_recovery) { 1997 + /* Transport event occurred during previous reset */ 1998 + if (adapter->wait_for_reset) { 1999 + /* Previous was CHANGE_PARAM; caller locked */ 2000 + adapter->force_reset_recovery = false; 2001 + rc = do_hard_reset(adapter, rwi, reset_state); 2002 + } else { 2003 + rtnl_lock(); 2004 + adapter->force_reset_recovery = false; 2005 + rc = do_hard_reset(adapter, rwi, reset_state); 2006 + rtnl_unlock(); 2007 + } 2077 2008 } else { 2078 2009 rc = do_reset(adapter, rwi, reset_state); 2079 2010 } 2080 2011 kfree(rwi); 2081 - if (rc && rc != IBMVNIC_INIT_FAILED && 2012 + if (rc == IBMVNIC_OPEN_FAILED) { 2013 + if (list_empty(&adapter->rwi_list)) 2014 + adapter->state = VNIC_CLOSED; 2015 + else 2016 + adapter->state = reset_state; 2017 + rc = 0; 2018 + } else if (rc && rc != IBMVNIC_INIT_FAILED && 2082 2019 !adapter->force_reset_recovery) 2083 2020 break; 2084 2021 2085 2022 rwi = get_next_rwi(adapter); 2023 + 2024 + if (rwi && (rwi->reset_reason == VNIC_RESET_FAILOVER || 2025 + rwi->reset_reason == VNIC_RESET_MOBILITY)) 2026 + adapter->force_reset_recovery = true; 2086 2027 } 2087 2028 2088 2029 if (adapter->wait_for_reset) { 2089 - adapter->wait_for_reset = false; 2090 2030 adapter->reset_done_rc = rc; 2091 2031 complete(&adapter->reset_done); 2092 2032 } ··· 2117 2015 free_all_rwi(adapter); 2118 2016 } 2119 2017 2120 - adapter->resetting = false; 2121 - if (we_lock_rtnl) 2122 - rtnl_unlock(); 2018 + clear_bit_unlock(0, &adapter->resetting); 2019 + } 2020 + 2021 + static void __ibmvnic_delayed_reset(struct work_struct *work) 2022 + { 2023 + struct ibmvnic_adapter *adapter; 2024 + 2025 + adapter = container_of(work, struct ibmvnic_adapter, 2026 + ibmvnic_delayed_reset.work); 2027 + __ibmvnic_reset(&adapter->ibmvnic_reset); 2123 2028 } 2124 2029 2125 2030 static int ibmvnic_reset(struct ibmvnic_adapter *adapter, ··· 2181 2072 rwi->reset_reason = reason; 2182 2073 list_add_tail(&rwi->list, &adapter->rwi_list); 2183 2074 spin_unlock_irqrestore(&adapter->rwi_lock, flags); 2184 - adapter->resetting = true; 2185 2075 netdev_dbg(adapter->netdev, "Scheduling reset (reason %d)\n", reason); 2186 2076 schedule_work(&adapter->ibmvnic_reset); 2187 2077 2188 2078 return 0; 2189 2079 err: 2190 - if (adapter->wait_for_reset) 2191 - adapter->wait_for_reset = false; 2192 2080 return -ret; 2193 2081 } 2194 2082 ··· 2225 2119 u16 offset; 2226 2120 u8 flags = 0; 2227 2121 2228 - if (unlikely(adapter->resetting && 2122 + if (unlikely(test_bit(0, &adapter->resetting) && 2229 2123 adapter->reset_reason != VNIC_RESET_NON_FATAL)) { 2230 2124 enable_scrq_irq(adapter, adapter->rx_scrq[scrq_num]); 2231 2125 napi_complete_done(napi, frames_processed); ··· 2876 2770 return 1; 2877 2771 } 2878 2772 2879 - if (adapter->resetting && 2773 + if (test_bit(0, &adapter->resetting) && 2880 2774 adapter->reset_reason == VNIC_RESET_MOBILITY) { 2881 2775 u64 val = (0xff000000) | scrq->hw_irq; 2882 2776 ··· 3426 3320 if (rc) { 3427 3321 if (rc == H_CLOSED) { 3428 3322 dev_warn(dev, "CRQ Queue closed\n"); 3429 - if (adapter->resetting) 3323 + if (test_bit(0, &adapter->resetting)) 3430 3324 ibmvnic_reset(adapter, VNIC_RESET_FATAL); 3431 3325 } 3432 3326 ··· 4418 4312 { 4419 4313 struct net_device *netdev = adapter->netdev; 4420 4314 int rc; 4315 + __be32 rspeed = cpu_to_be32(crq->query_phys_parms_rsp.speed); 4421 4316 4422 4317 rc = crq->query_phys_parms_rsp.rc.code; 4423 4318 if (rc) { 4424 4319 netdev_err(netdev, "Error %d in QUERY_PHYS_PARMS\n", rc); 4425 4320 return rc; 4426 4321 } 4427 - switch (cpu_to_be32(crq->query_phys_parms_rsp.speed)) { 4322 + switch (rspeed) { 4428 4323 case IBMVNIC_10MBPS: 4429 4324 adapter->speed = SPEED_10; 4430 4325 break; ··· 4451 4344 adapter->speed = SPEED_100000; 4452 4345 break; 4453 4346 default: 4454 - netdev_warn(netdev, "Unknown speed 0x%08x\n", 4455 - cpu_to_be32(crq->query_phys_parms_rsp.speed)); 4347 + if (netif_carrier_ok(netdev)) 4348 + netdev_warn(netdev, "Unknown speed 0x%08x\n", rspeed); 4456 4349 adapter->speed = SPEED_UNKNOWN; 4457 4350 } 4458 4351 if (crq->query_phys_parms_rsp.flags1 & IBMVNIC_FULL_DUPLEX) ··· 4502 4395 case IBMVNIC_CRQ_XPORT_EVENT: 4503 4396 netif_carrier_off(netdev); 4504 4397 adapter->crq.active = false; 4505 - if (adapter->resetting) 4398 + if (test_bit(0, &adapter->resetting)) 4506 4399 adapter->force_reset_recovery = true; 4507 4400 if (gen_crq->cmd == IBMVNIC_PARTITION_MIGRATED) { 4508 4401 dev_info(dev, "Migrated, re-enabling adapter\n"); ··· 4840 4733 return -1; 4841 4734 } 4842 4735 4843 - if (adapter->resetting && !adapter->wait_for_reset && 4736 + if (test_bit(0, &adapter->resetting) && !adapter->wait_for_reset && 4844 4737 adapter->reset_reason != VNIC_RESET_MOBILITY) { 4845 4738 if (adapter->req_rx_queues != old_num_rx_queues || 4846 4739 adapter->req_tx_queues != old_num_tx_queues) { ··· 4952 4845 spin_lock_init(&adapter->stats_lock); 4953 4846 4954 4847 INIT_WORK(&adapter->ibmvnic_reset, __ibmvnic_reset); 4848 + INIT_DELAYED_WORK(&adapter->ibmvnic_delayed_reset, 4849 + __ibmvnic_delayed_reset); 4955 4850 INIT_LIST_HEAD(&adapter->rwi_list); 4956 4851 spin_lock_init(&adapter->rwi_lock); 4957 4852 init_completion(&adapter->init_done); 4958 - adapter->resetting = false; 4853 + clear_bit(0, &adapter->resetting); 4959 4854 4960 4855 do { 4961 4856 rc = init_crq_queue(adapter);

+5 -1

drivers/net/ethernet/ibm/ibmvnic.h

··· 20 20 #define IBMVNIC_INVALID_MAP -1 21 21 #define IBMVNIC_STATS_TIMEOUT 1 22 22 #define IBMVNIC_INIT_FAILED 2 23 + #define IBMVNIC_OPEN_FAILED 3 23 24 24 25 /* basic structures plus 100 2k buffers */ 25 26 #define IBMVNIC_IO_ENTITLEMENT_DEFAULT 610305 ··· 38 37 39 38 #define IBMVNIC_MAX_LTB_SIZE ((1 << (MAX_ORDER - 1)) * PAGE_SIZE) 40 39 #define IBMVNIC_BUFFER_HLEN 500 40 + 41 + #define IBMVNIC_RESET_DELAY 100 41 42 42 43 static const char ibmvnic_priv_flags[][ETH_GSTRING_LEN] = { 43 44 #define IBMVNIC_USE_SERVER_MAXES 0x1 ··· 1079 1076 spinlock_t rwi_lock; 1080 1077 struct list_head rwi_list; 1081 1078 struct work_struct ibmvnic_reset; 1082 - bool resetting; 1079 + struct delayed_work ibmvnic_delayed_reset; 1080 + unsigned long resetting; 1083 1081 bool napi_enabled, from_passive_init; 1084 1082 1085 1083 bool failover_pending;

+1 -1

drivers/net/ethernet/marvell/skge.c

··· 3108 3108 skb_put(skb, len); 3109 3109 3110 3110 if (dev->features & NETIF_F_RXCSUM) { 3111 - skb->csum = csum; 3111 + skb->csum = le16_to_cpu(csum); 3112 3112 skb->ip_summed = CHECKSUM_COMPLETE; 3113 3113 } 3114 3114

+18 -18

drivers/net/ethernet/mellanox/mlx5/core/Kconfig

··· 20 20 bool 21 21 22 22 config MLX5_FPGA 23 - bool "Mellanox Technologies Innova support" 24 - depends on MLX5_CORE 23 + bool "Mellanox Technologies Innova support" 24 + depends on MLX5_CORE 25 25 select MLX5_ACCEL 26 - ---help--- 27 - Build support for the Innova family of network cards by Mellanox 28 - Technologies. Innova network cards are comprised of a ConnectX chip 29 - and an FPGA chip on one board. If you select this option, the 30 - mlx5_core driver will include the Innova FPGA core and allow building 31 - sandbox-specific client drivers. 26 + ---help--- 27 + Build support for the Innova family of network cards by Mellanox 28 + Technologies. Innova network cards are comprised of a ConnectX chip 29 + and an FPGA chip on one board. If you select this option, the 30 + mlx5_core driver will include the Innova FPGA core and allow building 31 + sandbox-specific client drivers. 32 32 33 33 config MLX5_CORE_EN 34 34 bool "Mellanox 5th generation network adapters (ConnectX series) Ethernet support" ··· 58 58 API. 59 59 60 60 config MLX5_MPFS 61 - bool "Mellanox Technologies MLX5 MPFS support" 62 - depends on MLX5_CORE_EN 61 + bool "Mellanox Technologies MLX5 MPFS support" 62 + depends on MLX5_CORE_EN 63 63 default y 64 - ---help--- 64 + ---help--- 65 65 Mellanox Technologies Ethernet Multi-Physical Function Switch (MPFS) 66 - support in ConnectX NIC. MPFs is required for when multi-PF configuration 67 - is enabled to allow passing user configured unicast MAC addresses to the 68 - requesting PF. 66 + support in ConnectX NIC. MPFs is required for when multi-PF configuration 67 + is enabled to allow passing user configured unicast MAC addresses to the 68 + requesting PF. 69 69 70 70 config MLX5_ESWITCH 71 71 bool "Mellanox Technologies MLX5 SRIOV E-Switch support" ··· 73 73 default y 74 74 ---help--- 75 75 Mellanox Technologies Ethernet SRIOV E-Switch support in ConnectX NIC. 76 - E-Switch provides internal SRIOV packet steering and switching for the 77 - enabled VFs and PF in two available modes: 78 - Legacy SRIOV mode (L2 mac vlan steering based). 79 - Switchdev mode (eswitch offloads). 76 + E-Switch provides internal SRIOV packet steering and switching for the 77 + enabled VFs and PF in two available modes: 78 + Legacy SRIOV mode (L2 mac vlan steering based). 79 + Switchdev mode (eswitch offloads). 80 80 81 81 config MLX5_CORE_EN_DCB 82 82 bool "Data Center Bridging (DCB) Support"

+2 -2

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

··· 399 399 struct mlx5_flow_table *ft, 400 400 struct ethtool_rx_flow_spec *fs) 401 401 { 402 + struct mlx5_flow_act flow_act = { .flags = FLOW_ACT_NO_APPEND }; 402 403 struct mlx5_flow_destination *dst = NULL; 403 - struct mlx5_flow_act flow_act = {0}; 404 - struct mlx5_flow_spec *spec; 405 404 struct mlx5_flow_handle *rule; 405 + struct mlx5_flow_spec *spec; 406 406 int err = 0; 407 407 408 408 spec = kvzalloc(sizeof(*spec), GFP_KERNEL);

+51 -34

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

··· 1664 1664 return err; 1665 1665 } 1666 1666 1667 - if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS)) { 1668 - struct flow_match_ipv4_addrs match; 1667 + if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_CONTROL)) { 1668 + struct flow_match_control match; 1669 + u16 addr_type; 1669 1670 1670 - flow_rule_match_enc_ipv4_addrs(rule, &match); 1671 - MLX5_SET(fte_match_set_lyr_2_4, headers_c, 1672 - src_ipv4_src_ipv6.ipv4_layout.ipv4, 1673 - ntohl(match.mask->src)); 1674 - MLX5_SET(fte_match_set_lyr_2_4, headers_v, 1675 - src_ipv4_src_ipv6.ipv4_layout.ipv4, 1676 - ntohl(match.key->src)); 1671 + flow_rule_match_enc_control(rule, &match); 1672 + addr_type = match.key->addr_type; 1677 1673 1678 - MLX5_SET(fte_match_set_lyr_2_4, headers_c, 1679 - dst_ipv4_dst_ipv6.ipv4_layout.ipv4, 1680 - ntohl(match.mask->dst)); 1681 - MLX5_SET(fte_match_set_lyr_2_4, headers_v, 1682 - dst_ipv4_dst_ipv6.ipv4_layout.ipv4, 1683 - ntohl(match.key->dst)); 1674 + /* For tunnel addr_type used same key id`s as for non-tunnel */ 1675 + if (addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) { 1676 + struct flow_match_ipv4_addrs match; 1684 1677 1685 - MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, headers_c, ethertype); 1686 - MLX5_SET(fte_match_set_lyr_2_4, headers_v, ethertype, ETH_P_IP); 1687 - } else if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS)) { 1688 - struct flow_match_ipv6_addrs match; 1678 + flow_rule_match_enc_ipv4_addrs(rule, &match); 1679 + MLX5_SET(fte_match_set_lyr_2_4, headers_c, 1680 + src_ipv4_src_ipv6.ipv4_layout.ipv4, 1681 + ntohl(match.mask->src)); 1682 + MLX5_SET(fte_match_set_lyr_2_4, headers_v, 1683 + src_ipv4_src_ipv6.ipv4_layout.ipv4, 1684 + ntohl(match.key->src)); 1689 1685 1690 - flow_rule_match_enc_ipv6_addrs(rule, &match); 1691 - memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c, 1692 - src_ipv4_src_ipv6.ipv6_layout.ipv6), 1693 - &match.mask->src, MLX5_FLD_SZ_BYTES(ipv6_layout, ipv6)); 1694 - memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v, 1695 - src_ipv4_src_ipv6.ipv6_layout.ipv6), 1696 - &match.key->src, MLX5_FLD_SZ_BYTES(ipv6_layout, ipv6)); 1686 + MLX5_SET(fte_match_set_lyr_2_4, headers_c, 1687 + dst_ipv4_dst_ipv6.ipv4_layout.ipv4, 1688 + ntohl(match.mask->dst)); 1689 + MLX5_SET(fte_match_set_lyr_2_4, headers_v, 1690 + dst_ipv4_dst_ipv6.ipv4_layout.ipv4, 1691 + ntohl(match.key->dst)); 1697 1692 1698 - memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c, 1699 - dst_ipv4_dst_ipv6.ipv6_layout.ipv6), 1700 - &match.mask->dst, MLX5_FLD_SZ_BYTES(ipv6_layout, ipv6)); 1701 - memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v, 1702 - dst_ipv4_dst_ipv6.ipv6_layout.ipv6), 1703 - &match.key->dst, MLX5_FLD_SZ_BYTES(ipv6_layout, ipv6)); 1693 + MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, headers_c, 1694 + ethertype); 1695 + MLX5_SET(fte_match_set_lyr_2_4, headers_v, ethertype, 1696 + ETH_P_IP); 1697 + } else if (addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) { 1698 + struct flow_match_ipv6_addrs match; 1704 1699 1705 - MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, headers_c, ethertype); 1706 - MLX5_SET(fte_match_set_lyr_2_4, headers_v, ethertype, ETH_P_IPV6); 1700 + flow_rule_match_enc_ipv6_addrs(rule, &match); 1701 + memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c, 1702 + src_ipv4_src_ipv6.ipv6_layout.ipv6), 1703 + &match.mask->src, MLX5_FLD_SZ_BYTES(ipv6_layout, 1704 + ipv6)); 1705 + memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v, 1706 + src_ipv4_src_ipv6.ipv6_layout.ipv6), 1707 + &match.key->src, MLX5_FLD_SZ_BYTES(ipv6_layout, 1708 + ipv6)); 1709 + 1710 + memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c, 1711 + dst_ipv4_dst_ipv6.ipv6_layout.ipv6), 1712 + &match.mask->dst, MLX5_FLD_SZ_BYTES(ipv6_layout, 1713 + ipv6)); 1714 + memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v, 1715 + dst_ipv4_dst_ipv6.ipv6_layout.ipv6), 1716 + &match.key->dst, MLX5_FLD_SZ_BYTES(ipv6_layout, 1717 + ipv6)); 1718 + 1719 + MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, headers_c, 1720 + ethertype); 1721 + MLX5_SET(fte_match_set_lyr_2_4, headers_v, ethertype, 1722 + ETH_P_IPV6); 1723 + } 1707 1724 } 1708 1725 1709 1726 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_IP)) {

+1

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

··· 1568 1568 { PCI_VDEVICE(MELLANOX, 0x101e), MLX5_PCI_DEV_IS_VF}, /* ConnectX Family mlx5Gen Virtual Function */ 1569 1569 { PCI_VDEVICE(MELLANOX, 0xa2d2) }, /* BlueField integrated ConnectX-5 network controller */ 1570 1570 { PCI_VDEVICE(MELLANOX, 0xa2d3), MLX5_PCI_DEV_IS_VF}, /* BlueField integrated ConnectX-5 network controller VF */ 1571 + { PCI_VDEVICE(MELLANOX, 0xa2d6) }, /* BlueField-2 integrated ConnectX-6 Dx network controller */ 1571 1572 { 0, } 1572 1573 }; 1573 1574

+2 -2

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_action.c

··· 615 615 * that recalculates the CS and forwards to the vport. 616 616 */ 617 617 ret = mlx5dr_domain_cache_get_recalc_cs_ft_addr(dest_action->vport.dmn, 618 - dest_action->vport.num, 618 + dest_action->vport.caps->num, 619 619 final_icm_addr); 620 620 if (ret) { 621 621 mlx5dr_err(dmn, "Failed to get FW cs recalc flow table\n"); ··· 744 744 dest_action = action; 745 745 if (rx_rule) { 746 746 /* Loopback on WIRE vport is not supported */ 747 - if (action->vport.num == WIRE_PORT) 747 + if (action->vport.caps->num == WIRE_PORT) 748 748 goto out_invalid_arg; 749 749 750 750 attr.final_icm_addr = action->vport.caps->icm_address_rx;

+5 -8

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_matcher.c

··· 230 230 (dmn->type == MLX5DR_DOMAIN_TYPE_FDB || 231 231 dmn->type == MLX5DR_DOMAIN_TYPE_NIC_RX)) { 232 232 ret = mlx5dr_ste_build_src_gvmi_qpn(&sb[idx++], &mask, 233 - &dmn->info.caps, 234 - inner, rx); 233 + dmn, inner, rx); 235 234 if (ret) 236 235 return ret; 237 236 } ··· 457 458 458 459 prev_matcher = NULL; 459 460 if (next_matcher && !first) 460 - prev_matcher = list_entry(next_matcher->matcher_list.prev, 461 - struct mlx5dr_matcher, 462 - matcher_list); 461 + prev_matcher = list_prev_entry(next_matcher, matcher_list); 463 462 else if (!first) 464 - prev_matcher = list_entry(tbl->matcher_list.prev, 465 - struct mlx5dr_matcher, 466 - matcher_list); 463 + prev_matcher = list_last_entry(&tbl->matcher_list, 464 + struct mlx5dr_matcher, 465 + matcher_list); 467 466 468 467 if (dmn->type == MLX5DR_DOMAIN_TYPE_FDB || 469 468 dmn->type == MLX5DR_DOMAIN_TYPE_NIC_RX) {

+1 -1

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_rule.c

··· 18 18 struct mlx5dr_ste *last_ste; 19 19 20 20 /* The new entry will be inserted after the last */ 21 - last_ste = list_entry(miss_list->prev, struct mlx5dr_ste, miss_list_node); 21 + last_ste = list_last_entry(miss_list, struct mlx5dr_ste, miss_list_node); 22 22 WARN_ON(!last_ste); 23 23 24 24 ste_info_last = kzalloc(sizeof(*ste_info_last), GFP_KERNEL);

+37 -13

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste.c

··· 429 429 struct mlx5dr_ste *prev_ste; 430 430 u64 miss_addr; 431 431 432 - prev_ste = list_entry(mlx5dr_ste_get_miss_list(ste)->prev, struct mlx5dr_ste, 433 - miss_list_node); 434 - if (!prev_ste) { 435 - WARN_ON(true); 432 + prev_ste = list_prev_entry(ste, miss_list_node); 433 + if (WARN_ON(!prev_ste)) 436 434 return; 437 - } 438 435 439 436 miss_addr = mlx5dr_ste_get_miss_addr(ste->hw_ste); 440 437 mlx5dr_ste_set_miss_addr(prev_ste->hw_ste, miss_addr); ··· 458 461 struct mlx5dr_ste_htbl *stats_tbl; 459 462 LIST_HEAD(send_ste_list); 460 463 461 - first_ste = list_entry(mlx5dr_ste_get_miss_list(ste)->next, 462 - struct mlx5dr_ste, miss_list_node); 464 + first_ste = list_first_entry(mlx5dr_ste_get_miss_list(ste), 465 + struct mlx5dr_ste, miss_list_node); 463 466 stats_tbl = first_ste->htbl; 464 467 465 468 /* Two options: ··· 476 479 if (last_ste == first_ste) 477 480 next_ste = NULL; 478 481 else 479 - next_ste = list_entry(ste->miss_list_node.next, 480 - struct mlx5dr_ste, miss_list_node); 482 + next_ste = list_next_entry(ste, miss_list_node); 481 483 482 484 if (!next_ste) { 483 485 /* One and only entry in the list */ ··· 837 841 spec->source_sqn = MLX5_GET(fte_match_set_misc, mask, source_sqn); 838 842 839 843 spec->source_port = MLX5_GET(fte_match_set_misc, mask, source_port); 844 + spec->source_eswitch_owner_vhca_id = MLX5_GET(fte_match_set_misc, mask, 845 + source_eswitch_owner_vhca_id); 840 846 841 847 spec->outer_second_prio = MLX5_GET(fte_match_set_misc, mask, outer_second_prio); 842 848 spec->outer_second_cfi = MLX5_GET(fte_match_set_misc, mask, outer_second_cfi); ··· 2252 2254 { 2253 2255 struct mlx5dr_match_misc *misc_mask = &value->misc; 2254 2256 2255 - if (misc_mask->source_port != 0xffff) 2257 + /* Partial misc source_port is not supported */ 2258 + if (misc_mask->source_port && misc_mask->source_port != 0xffff) 2259 + return -EINVAL; 2260 + 2261 + /* Partial misc source_eswitch_owner_vhca_id is not supported */ 2262 + if (misc_mask->source_eswitch_owner_vhca_id && 2263 + misc_mask->source_eswitch_owner_vhca_id != 0xffff) 2256 2264 return -EINVAL; 2257 2265 2258 2266 DR_STE_SET_MASK(src_gvmi_qp, bit_mask, source_gvmi, misc_mask, source_port); 2259 2267 DR_STE_SET_MASK(src_gvmi_qp, bit_mask, source_qp, misc_mask, source_sqn); 2268 + misc_mask->source_eswitch_owner_vhca_id = 0; 2260 2269 2261 2270 return 0; 2262 2271 } ··· 2275 2270 struct dr_hw_ste_format *hw_ste = (struct dr_hw_ste_format *)hw_ste_p; 2276 2271 struct mlx5dr_match_misc *misc = &value->misc; 2277 2272 struct mlx5dr_cmd_vport_cap *vport_cap; 2273 + struct mlx5dr_domain *dmn = sb->dmn; 2274 + struct mlx5dr_cmd_caps *caps; 2278 2275 u8 *tag = hw_ste->tag; 2279 2276 2280 2277 DR_STE_SET_TAG(src_gvmi_qp, tag, source_qp, misc, source_sqn); 2281 2278 2282 - vport_cap = mlx5dr_get_vport_cap(sb->caps, misc->source_port); 2279 + if (sb->vhca_id_valid) { 2280 + /* Find port GVMI based on the eswitch_owner_vhca_id */ 2281 + if (misc->source_eswitch_owner_vhca_id == dmn->info.caps.gvmi) 2282 + caps = &dmn->info.caps; 2283 + else if (dmn->peer_dmn && (misc->source_eswitch_owner_vhca_id == 2284 + dmn->peer_dmn->info.caps.gvmi)) 2285 + caps = &dmn->peer_dmn->info.caps; 2286 + else 2287 + return -EINVAL; 2288 + } else { 2289 + caps = &dmn->info.caps; 2290 + } 2291 + 2292 + vport_cap = mlx5dr_get_vport_cap(caps, misc->source_port); 2283 2293 if (!vport_cap) 2284 2294 return -EINVAL; 2285 2295 2286 2296 if (vport_cap->vport_gvmi) 2287 2297 MLX5_SET(ste_src_gvmi_qp, tag, source_gvmi, vport_cap->vport_gvmi); 2288 2298 2299 + misc->source_eswitch_owner_vhca_id = 0; 2289 2300 misc->source_port = 0; 2290 2301 2291 2302 return 0; ··· 2309 2288 2310 2289 int mlx5dr_ste_build_src_gvmi_qpn(struct mlx5dr_ste_build *sb, 2311 2290 struct mlx5dr_match_param *mask, 2312 - struct mlx5dr_cmd_caps *caps, 2291 + struct mlx5dr_domain *dmn, 2313 2292 bool inner, bool rx) 2314 2293 { 2315 2294 int ret; 2295 + 2296 + /* Set vhca_id_valid before we reset source_eswitch_owner_vhca_id */ 2297 + sb->vhca_id_valid = mask->misc.source_eswitch_owner_vhca_id; 2316 2298 2317 2299 ret = dr_ste_build_src_gvmi_qpn_bit_mask(mask, sb->bit_mask); 2318 2300 if (ret) 2319 2301 return ret; 2320 2302 2321 2303 sb->rx = rx; 2322 - sb->caps = caps; 2304 + sb->dmn = dmn; 2323 2305 sb->inner = inner; 2324 2306 sb->lu_type = MLX5DR_STE_LU_TYPE_SRC_GVMI_AND_QP; 2325 2307 sb->byte_mask = dr_ste_conv_bit_to_byte_mask(sb->bit_mask);

+4 -3

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_types.h

··· 180 180 struct mlx5dr_ste_build { 181 181 u8 inner:1; 182 182 u8 rx:1; 183 + u8 vhca_id_valid:1; 184 + struct mlx5dr_domain *dmn; 183 185 struct mlx5dr_cmd_caps *caps; 184 186 u8 lu_type; 185 187 u16 byte_mask; ··· 333 331 bool inner, bool rx); 334 332 int mlx5dr_ste_build_src_gvmi_qpn(struct mlx5dr_ste_build *sb, 335 333 struct mlx5dr_match_param *mask, 336 - struct mlx5dr_cmd_caps *caps, 334 + struct mlx5dr_domain *dmn, 337 335 bool inner, bool rx); 338 336 void mlx5dr_ste_build_empty_always_hit(struct mlx5dr_ste_build *sb, bool rx); 339 337 ··· 455 453 u32 gre_c_present:1; 456 454 /* Source port.;0xffff determines wire port */ 457 455 u32 source_port:16; 458 - u32 reserved_auto2:16; 456 + u32 source_eswitch_owner_vhca_id:16; 459 457 /* VLAN ID of first VLAN tag the inner header of the incoming packet. 460 458 * Valid only when inner_second_cvlan_tag ==1 or inner_second_svlan_tag ==1 461 459 */ ··· 747 745 struct { 748 746 struct mlx5dr_domain *dmn; 749 747 struct mlx5dr_cmd_vport_cap *caps; 750 - u32 num; 751 748 } vport; 752 749 struct { 753 750 u32 vlan_hdr; /* tpid_pcp_dei_vid */

+9

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

··· 3771 3771 goto err_port_qdiscs_init; 3772 3772 } 3773 3773 3774 + err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, 0, VLAN_N_VID - 1, false, 3775 + false); 3776 + if (err) { 3777 + dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to clear VLAN filter\n", 3778 + mlxsw_sp_port->local_port); 3779 + goto err_port_vlan_clear; 3780 + } 3781 + 3774 3782 err = mlxsw_sp_port_nve_init(mlxsw_sp_port); 3775 3783 if (err) { 3776 3784 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to initialize NVE\n", ··· 3826 3818 err_port_pvid_set: 3827 3819 mlxsw_sp_port_nve_fini(mlxsw_sp_port); 3828 3820 err_port_nve_init: 3821 + err_port_vlan_clear: 3829 3822 mlxsw_sp_tc_qdisc_fini(mlxsw_sp_port); 3830 3823 err_port_qdiscs_init: 3831 3824 mlxsw_sp_port_fids_fini(mlxsw_sp_port);

+6

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

··· 21 21 struct netlink_ext_ack *extack) 22 22 { 23 23 const struct flow_action_entry *act; 24 + int mirror_act_count = 0; 24 25 int err, i; 25 26 26 27 if (!flow_action_has_entries(flow_action)) ··· 105 104 break; 106 105 case FLOW_ACTION_MIRRED: { 107 106 struct net_device *out_dev = act->dev; 107 + 108 + if (mirror_act_count++) { 109 + NL_SET_ERR_MSG_MOD(extack, "Multiple mirror actions per rule are not supported"); 110 + return -EOPNOTSUPP; 111 + } 108 112 109 113 err = mlxsw_sp_acl_rulei_act_mirror(mlxsw_sp, rulei, 110 114 block, out_dev,

+10 -4

drivers/net/ethernet/netronome/nfp/abm/cls.c

··· 176 176 u8 mask, val; 177 177 int err; 178 178 179 - if (!nfp_abm_u32_check_knode(alink->abm, knode, proto, extack)) 179 + if (!nfp_abm_u32_check_knode(alink->abm, knode, proto, extack)) { 180 + err = -EOPNOTSUPP; 180 181 goto err_delete; 182 + } 181 183 182 184 tos_off = proto == htons(ETH_P_IP) ? 16 : 20; 183 185 ··· 200 198 if ((iter->val & cmask) == (val & cmask) && 201 199 iter->band != knode->res->classid) { 202 200 NL_SET_ERR_MSG_MOD(extack, "conflict with already offloaded filter"); 201 + err = -EOPNOTSUPP; 203 202 goto err_delete; 204 203 } 205 204 } 206 205 207 206 if (!match) { 208 207 match = kzalloc(sizeof(*match), GFP_KERNEL); 209 - if (!match) 210 - return -ENOMEM; 208 + if (!match) { 209 + err = -ENOMEM; 210 + goto err_delete; 211 + } 212 + 211 213 list_add(&match->list, &alink->dscp_map); 212 214 } 213 215 match->handle = knode->handle; ··· 227 221 228 222 err_delete: 229 223 nfp_abm_u32_knode_delete(alink, knode); 230 - return -EOPNOTSUPP; 224 + return err; 231 225 } 232 226 233 227 static int nfp_abm_setup_tc_block_cb(enum tc_setup_type type,

+7

drivers/net/ethernet/netronome/nfp/flower/main.c

··· 400 400 repr_priv = kzalloc(sizeof(*repr_priv), GFP_KERNEL); 401 401 if (!repr_priv) { 402 402 err = -ENOMEM; 403 + nfp_repr_free(repr); 403 404 goto err_reprs_clean; 404 405 } 405 406 ··· 414 413 port = nfp_port_alloc(app, port_type, repr); 415 414 if (IS_ERR(port)) { 416 415 err = PTR_ERR(port); 416 + kfree(repr_priv); 417 417 nfp_repr_free(repr); 418 418 goto err_reprs_clean; 419 419 } ··· 435 433 err = nfp_repr_init(app, repr, 436 434 port_id, port, priv->nn->dp.netdev); 437 435 if (err) { 436 + kfree(repr_priv); 438 437 nfp_port_free(port); 439 438 nfp_repr_free(repr); 440 439 goto err_reprs_clean; ··· 518 515 repr_priv = kzalloc(sizeof(*repr_priv), GFP_KERNEL); 519 516 if (!repr_priv) { 520 517 err = -ENOMEM; 518 + nfp_repr_free(repr); 521 519 goto err_reprs_clean; 522 520 } 523 521 ··· 529 525 port = nfp_port_alloc(app, NFP_PORT_PHYS_PORT, repr); 530 526 if (IS_ERR(port)) { 531 527 err = PTR_ERR(port); 528 + kfree(repr_priv); 532 529 nfp_repr_free(repr); 533 530 goto err_reprs_clean; 534 531 } 535 532 err = nfp_port_init_phy_port(app->pf, app, port, i); 536 533 if (err) { 534 + kfree(repr_priv); 537 535 nfp_port_free(port); 538 536 nfp_repr_free(repr); 539 537 goto err_reprs_clean; ··· 548 542 err = nfp_repr_init(app, repr, 549 543 cmsg_port_id, port, priv->nn->dp.netdev); 550 544 if (err) { 545 + kfree(repr_priv); 551 546 nfp_port_free(port); 552 547 nfp_repr_free(repr); 553 548 goto err_reprs_clean;

-497

drivers/net/ethernet/netx-eth.c

··· 1 - // SPDX-License-Identifier: GPL-2.0-only 2 - /* 3 - * drivers/net/ethernet/netx-eth.c 4 - * 5 - * Copyright (c) 2005 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix 6 - */ 7 - 8 - #include <linux/init.h> 9 - #include <linux/interrupt.h> 10 - #include <linux/module.h> 11 - #include <linux/kernel.h> 12 - #include <linux/delay.h> 13 - 14 - #include <linux/netdevice.h> 15 - #include <linux/platform_device.h> 16 - #include <linux/etherdevice.h> 17 - #include <linux/skbuff.h> 18 - #include <linux/mii.h> 19 - 20 - #include <asm/io.h> 21 - #include <mach/hardware.h> 22 - #include <mach/netx-regs.h> 23 - #include <mach/pfifo.h> 24 - #include <mach/xc.h> 25 - #include <linux/platform_data/eth-netx.h> 26 - 27 - /* XC Fifo Offsets */ 28 - #define EMPTY_PTR_FIFO(xcno) (0 + ((xcno) << 3)) /* Index of the empty pointer FIFO */ 29 - #define IND_FIFO_PORT_HI(xcno) (1 + ((xcno) << 3)) /* Index of the FIFO where received */ 30 - /* Data packages are indicated by XC */ 31 - #define IND_FIFO_PORT_LO(xcno) (2 + ((xcno) << 3)) /* Index of the FIFO where received */ 32 - /* Data packages are indicated by XC */ 33 - #define REQ_FIFO_PORT_HI(xcno) (3 + ((xcno) << 3)) /* Index of the FIFO where Data packages */ 34 - /* have to be indicated by ARM which */ 35 - /* shall be sent */ 36 - #define REQ_FIFO_PORT_LO(xcno) (4 + ((xcno) << 3)) /* Index of the FIFO where Data packages */ 37 - /* have to be indicated by ARM which shall */ 38 - /* be sent */ 39 - #define CON_FIFO_PORT_HI(xcno) (5 + ((xcno) << 3)) /* Index of the FIFO where sent Data packages */ 40 - /* are confirmed */ 41 - #define CON_FIFO_PORT_LO(xcno) (6 + ((xcno) << 3)) /* Index of the FIFO where sent Data */ 42 - /* packages are confirmed */ 43 - #define PFIFO_MASK(xcno) (0x7f << (xcno*8)) 44 - 45 - #define FIFO_PTR_FRAMELEN_SHIFT 0 46 - #define FIFO_PTR_FRAMELEN_MASK (0x7ff << 0) 47 - #define FIFO_PTR_FRAMELEN(len) (((len) << 0) & FIFO_PTR_FRAMELEN_MASK) 48 - #define FIFO_PTR_TIMETRIG (1<<11) 49 - #define FIFO_PTR_MULTI_REQ 50 - #define FIFO_PTR_ORIGIN (1<<14) 51 - #define FIFO_PTR_VLAN (1<<15) 52 - #define FIFO_PTR_FRAMENO_SHIFT 16 53 - #define FIFO_PTR_FRAMENO_MASK (0x3f << 16) 54 - #define FIFO_PTR_FRAMENO(no) (((no) << 16) & FIFO_PTR_FRAMENO_MASK) 55 - #define FIFO_PTR_SEGMENT_SHIFT 22 56 - #define FIFO_PTR_SEGMENT_MASK (0xf << 22) 57 - #define FIFO_PTR_SEGMENT(seg) (((seg) & 0xf) << 22) 58 - #define FIFO_PTR_ERROR_SHIFT 28 59 - #define FIFO_PTR_ERROR_MASK (0xf << 28) 60 - 61 - #define ISR_LINK_STATUS_CHANGE (1<<4) 62 - #define ISR_IND_LO (1<<3) 63 - #define ISR_CON_LO (1<<2) 64 - #define ISR_IND_HI (1<<1) 65 - #define ISR_CON_HI (1<<0) 66 - 67 - #define ETH_MAC_LOCAL_CONFIG 0x1560 68 - #define ETH_MAC_4321 0x1564 69 - #define ETH_MAC_65 0x1568 70 - 71 - #define MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT 16 72 - #define MAC_TRAFFIC_CLASS_ARRANGEMENT_MASK (0xf<<MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT) 73 - #define MAC_TRAFFIC_CLASS_ARRANGEMENT(x) (((x)<<MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT) & MAC_TRAFFIC_CLASS_ARRANGEMENT_MASK) 74 - #define LOCAL_CONFIG_LINK_STATUS_IRQ_EN (1<<24) 75 - #define LOCAL_CONFIG_CON_LO_IRQ_EN (1<<23) 76 - #define LOCAL_CONFIG_CON_HI_IRQ_EN (1<<22) 77 - #define LOCAL_CONFIG_IND_LO_IRQ_EN (1<<21) 78 - #define LOCAL_CONFIG_IND_HI_IRQ_EN (1<<20) 79 - 80 - #define CARDNAME "netx-eth" 81 - 82 - /* LSB must be zero */ 83 - #define INTERNAL_PHY_ADR 0x1c 84 - 85 - struct netx_eth_priv { 86 - void __iomem *sram_base, *xpec_base, *xmac_base; 87 - int id; 88 - struct mii_if_info mii; 89 - u32 msg_enable; 90 - struct xc *xc; 91 - spinlock_t lock; 92 - }; 93 - 94 - static void netx_eth_set_multicast_list(struct net_device *ndev) 95 - { 96 - /* implement me */ 97 - } 98 - 99 - static int 100 - netx_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev) 101 - { 102 - struct netx_eth_priv *priv = netdev_priv(ndev); 103 - unsigned char *buf = skb->data; 104 - unsigned int len = skb->len; 105 - 106 - spin_lock_irq(&priv->lock); 107 - memcpy_toio(priv->sram_base + 1560, (void *)buf, len); 108 - if (len < 60) { 109 - memset_io(priv->sram_base + 1560 + len, 0, 60 - len); 110 - len = 60; 111 - } 112 - 113 - pfifo_push(REQ_FIFO_PORT_LO(priv->id), 114 - FIFO_PTR_SEGMENT(priv->id) | 115 - FIFO_PTR_FRAMENO(1) | 116 - FIFO_PTR_FRAMELEN(len)); 117 - 118 - ndev->stats.tx_packets++; 119 - ndev->stats.tx_bytes += skb->len; 120 - 121 - netif_stop_queue(ndev); 122 - spin_unlock_irq(&priv->lock); 123 - dev_kfree_skb(skb); 124 - 125 - return NETDEV_TX_OK; 126 - } 127 - 128 - static void netx_eth_receive(struct net_device *ndev) 129 - { 130 - struct netx_eth_priv *priv = netdev_priv(ndev); 131 - unsigned int val, frameno, seg, len; 132 - unsigned char *data; 133 - struct sk_buff *skb; 134 - 135 - val = pfifo_pop(IND_FIFO_PORT_LO(priv->id)); 136 - 137 - frameno = (val & FIFO_PTR_FRAMENO_MASK) >> FIFO_PTR_FRAMENO_SHIFT; 138 - seg = (val & FIFO_PTR_SEGMENT_MASK) >> FIFO_PTR_SEGMENT_SHIFT; 139 - len = (val & FIFO_PTR_FRAMELEN_MASK) >> FIFO_PTR_FRAMELEN_SHIFT; 140 - 141 - skb = netdev_alloc_skb(ndev, len); 142 - if (unlikely(skb == NULL)) { 143 - ndev->stats.rx_dropped++; 144 - return; 145 - } 146 - 147 - data = skb_put(skb, len); 148 - 149 - memcpy_fromio(data, priv->sram_base + frameno * 1560, len); 150 - 151 - pfifo_push(EMPTY_PTR_FIFO(priv->id), 152 - FIFO_PTR_SEGMENT(seg) | FIFO_PTR_FRAMENO(frameno)); 153 - 154 - skb->protocol = eth_type_trans(skb, ndev); 155 - netif_rx(skb); 156 - ndev->stats.rx_packets++; 157 - ndev->stats.rx_bytes += len; 158 - } 159 - 160 - static irqreturn_t 161 - netx_eth_interrupt(int irq, void *dev_id) 162 - { 163 - struct net_device *ndev = dev_id; 164 - struct netx_eth_priv *priv = netdev_priv(ndev); 165 - int status; 166 - unsigned long flags; 167 - 168 - spin_lock_irqsave(&priv->lock, flags); 169 - 170 - status = readl(NETX_PFIFO_XPEC_ISR(priv->id)); 171 - while (status) { 172 - int fill_level; 173 - writel(status, NETX_PFIFO_XPEC_ISR(priv->id)); 174 - 175 - if ((status & ISR_CON_HI) || (status & ISR_IND_HI)) 176 - printk("%s: unexpected status: 0x%08x\n", 177 - __func__, status); 178 - 179 - fill_level = 180 - readl(NETX_PFIFO_FILL_LEVEL(IND_FIFO_PORT_LO(priv->id))); 181 - while (fill_level--) 182 - netx_eth_receive(ndev); 183 - 184 - if (status & ISR_CON_LO) 185 - netif_wake_queue(ndev); 186 - 187 - if (status & ISR_LINK_STATUS_CHANGE) 188 - mii_check_media(&priv->mii, netif_msg_link(priv), 1); 189 - 190 - status = readl(NETX_PFIFO_XPEC_ISR(priv->id)); 191 - } 192 - spin_unlock_irqrestore(&priv->lock, flags); 193 - return IRQ_HANDLED; 194 - } 195 - 196 - static int netx_eth_open(struct net_device *ndev) 197 - { 198 - struct netx_eth_priv *priv = netdev_priv(ndev); 199 - 200 - if (request_irq 201 - (ndev->irq, netx_eth_interrupt, IRQF_SHARED, ndev->name, ndev)) 202 - return -EAGAIN; 203 - 204 - writel(ndev->dev_addr[0] | 205 - ndev->dev_addr[1]<<8 | 206 - ndev->dev_addr[2]<<16 | 207 - ndev->dev_addr[3]<<24, 208 - priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_4321); 209 - writel(ndev->dev_addr[4] | 210 - ndev->dev_addr[5]<<8, 211 - priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_65); 212 - 213 - writel(LOCAL_CONFIG_LINK_STATUS_IRQ_EN | 214 - LOCAL_CONFIG_CON_LO_IRQ_EN | 215 - LOCAL_CONFIG_CON_HI_IRQ_EN | 216 - LOCAL_CONFIG_IND_LO_IRQ_EN | 217 - LOCAL_CONFIG_IND_HI_IRQ_EN, 218 - priv->xpec_base + NETX_XPEC_RAM_START_OFS + 219 - ETH_MAC_LOCAL_CONFIG); 220 - 221 - mii_check_media(&priv->mii, netif_msg_link(priv), 1); 222 - netif_start_queue(ndev); 223 - 224 - return 0; 225 - } 226 - 227 - static int netx_eth_close(struct net_device *ndev) 228 - { 229 - struct netx_eth_priv *priv = netdev_priv(ndev); 230 - 231 - netif_stop_queue(ndev); 232 - 233 - writel(0, 234 - priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_LOCAL_CONFIG); 235 - 236 - free_irq(ndev->irq, ndev); 237 - 238 - return 0; 239 - } 240 - 241 - static void netx_eth_timeout(struct net_device *ndev) 242 - { 243 - struct netx_eth_priv *priv = netdev_priv(ndev); 244 - int i; 245 - 246 - printk(KERN_ERR "%s: transmit timed out, resetting\n", ndev->name); 247 - 248 - spin_lock_irq(&priv->lock); 249 - 250 - xc_reset(priv->xc); 251 - xc_start(priv->xc); 252 - 253 - for (i=2; i<=18; i++) 254 - pfifo_push(EMPTY_PTR_FIFO(priv->id), 255 - FIFO_PTR_FRAMENO(i) | FIFO_PTR_SEGMENT(priv->id)); 256 - 257 - spin_unlock_irq(&priv->lock); 258 - 259 - netif_wake_queue(ndev); 260 - } 261 - 262 - static int 263 - netx_eth_phy_read(struct net_device *ndev, int phy_id, int reg) 264 - { 265 - unsigned int val; 266 - 267 - val = MIIMU_SNRDY | MIIMU_PREAMBLE | MIIMU_PHYADDR(phy_id) | 268 - MIIMU_REGADDR(reg) | MIIMU_PHY_NRES; 269 - 270 - writel(val, NETX_MIIMU); 271 - while (readl(NETX_MIIMU) & MIIMU_SNRDY); 272 - 273 - return readl(NETX_MIIMU) >> 16; 274 - 275 - } 276 - 277 - static void 278 - netx_eth_phy_write(struct net_device *ndev, int phy_id, int reg, int value) 279 - { 280 - unsigned int val; 281 - 282 - val = MIIMU_SNRDY | MIIMU_PREAMBLE | MIIMU_PHYADDR(phy_id) | 283 - MIIMU_REGADDR(reg) | MIIMU_PHY_NRES | MIIMU_OPMODE_WRITE | 284 - MIIMU_DATA(value); 285 - 286 - writel(val, NETX_MIIMU); 287 - while (readl(NETX_MIIMU) & MIIMU_SNRDY); 288 - } 289 - 290 - static const struct net_device_ops netx_eth_netdev_ops = { 291 - .ndo_open = netx_eth_open, 292 - .ndo_stop = netx_eth_close, 293 - .ndo_start_xmit = netx_eth_hard_start_xmit, 294 - .ndo_tx_timeout = netx_eth_timeout, 295 - .ndo_set_rx_mode = netx_eth_set_multicast_list, 296 - .ndo_validate_addr = eth_validate_addr, 297 - .ndo_set_mac_address = eth_mac_addr, 298 - }; 299 - 300 - static int netx_eth_enable(struct net_device *ndev) 301 - { 302 - struct netx_eth_priv *priv = netdev_priv(ndev); 303 - unsigned int mac4321, mac65; 304 - int running, i, ret; 305 - bool inv_mac_addr = false; 306 - 307 - ndev->netdev_ops = &netx_eth_netdev_ops; 308 - ndev->watchdog_timeo = msecs_to_jiffies(5000); 309 - 310 - priv->msg_enable = NETIF_MSG_LINK; 311 - priv->mii.phy_id_mask = 0x1f; 312 - priv->mii.reg_num_mask = 0x1f; 313 - priv->mii.force_media = 0; 314 - priv->mii.full_duplex = 0; 315 - priv->mii.dev = ndev; 316 - priv->mii.mdio_read = netx_eth_phy_read; 317 - priv->mii.mdio_write = netx_eth_phy_write; 318 - priv->mii.phy_id = INTERNAL_PHY_ADR + priv->id; 319 - 320 - running = xc_running(priv->xc); 321 - xc_stop(priv->xc); 322 - 323 - /* if the xc engine is already running, assume the bootloader has 324 - * loaded the firmware for us 325 - */ 326 - if (running) { 327 - /* get Node Address from hardware */ 328 - mac4321 = readl(priv->xpec_base + 329 - NETX_XPEC_RAM_START_OFS + ETH_MAC_4321); 330 - mac65 = readl(priv->xpec_base + 331 - NETX_XPEC_RAM_START_OFS + ETH_MAC_65); 332 - 333 - ndev->dev_addr[0] = mac4321 & 0xff; 334 - ndev->dev_addr[1] = (mac4321 >> 8) & 0xff; 335 - ndev->dev_addr[2] = (mac4321 >> 16) & 0xff; 336 - ndev->dev_addr[3] = (mac4321 >> 24) & 0xff; 337 - ndev->dev_addr[4] = mac65 & 0xff; 338 - ndev->dev_addr[5] = (mac65 >> 8) & 0xff; 339 - } else { 340 - if (xc_request_firmware(priv->xc)) { 341 - printk(CARDNAME ": requesting firmware failed\n"); 342 - return -ENODEV; 343 - } 344 - } 345 - 346 - xc_reset(priv->xc); 347 - xc_start(priv->xc); 348 - 349 - if (!is_valid_ether_addr(ndev->dev_addr)) 350 - inv_mac_addr = true; 351 - 352 - for (i=2; i<=18; i++) 353 - pfifo_push(EMPTY_PTR_FIFO(priv->id), 354 - FIFO_PTR_FRAMENO(i) | FIFO_PTR_SEGMENT(priv->id)); 355 - 356 - ret = register_netdev(ndev); 357 - if (inv_mac_addr) 358 - printk("%s: Invalid ethernet MAC address. Please set using ip\n", 359 - ndev->name); 360 - 361 - return ret; 362 - } 363 - 364 - static int netx_eth_drv_probe(struct platform_device *pdev) 365 - { 366 - struct netx_eth_priv *priv; 367 - struct net_device *ndev; 368 - struct netxeth_platform_data *pdata; 369 - int ret; 370 - 371 - ndev = alloc_etherdev(sizeof (struct netx_eth_priv)); 372 - if (!ndev) { 373 - ret = -ENOMEM; 374 - goto exit; 375 - } 376 - SET_NETDEV_DEV(ndev, &pdev->dev); 377 - 378 - platform_set_drvdata(pdev, ndev); 379 - 380 - priv = netdev_priv(ndev); 381 - 382 - pdata = dev_get_platdata(&pdev->dev); 383 - priv->xc = request_xc(pdata->xcno, &pdev->dev); 384 - if (!priv->xc) { 385 - dev_err(&pdev->dev, "unable to request xc engine\n"); 386 - ret = -ENODEV; 387 - goto exit_free_netdev; 388 - } 389 - 390 - ndev->irq = priv->xc->irq; 391 - priv->id = pdev->id; 392 - priv->xpec_base = priv->xc->xpec_base; 393 - priv->xmac_base = priv->xc->xmac_base; 394 - priv->sram_base = priv->xc->sram_base; 395 - 396 - spin_lock_init(&priv->lock); 397 - 398 - ret = pfifo_request(PFIFO_MASK(priv->id)); 399 - if (ret) { 400 - printk("unable to request PFIFO\n"); 401 - goto exit_free_xc; 402 - } 403 - 404 - ret = netx_eth_enable(ndev); 405 - if (ret) 406 - goto exit_free_pfifo; 407 - 408 - return 0; 409 - exit_free_pfifo: 410 - pfifo_free(PFIFO_MASK(priv->id)); 411 - exit_free_xc: 412 - free_xc(priv->xc); 413 - exit_free_netdev: 414 - free_netdev(ndev); 415 - exit: 416 - return ret; 417 - } 418 - 419 - static int netx_eth_drv_remove(struct platform_device *pdev) 420 - { 421 - struct net_device *ndev = platform_get_drvdata(pdev); 422 - struct netx_eth_priv *priv = netdev_priv(ndev); 423 - 424 - unregister_netdev(ndev); 425 - xc_stop(priv->xc); 426 - free_xc(priv->xc); 427 - free_netdev(ndev); 428 - pfifo_free(PFIFO_MASK(priv->id)); 429 - 430 - return 0; 431 - } 432 - 433 - static int netx_eth_drv_suspend(struct platform_device *pdev, pm_message_t state) 434 - { 435 - dev_err(&pdev->dev, "suspend not implemented\n"); 436 - return 0; 437 - } 438 - 439 - static int netx_eth_drv_resume(struct platform_device *pdev) 440 - { 441 - dev_err(&pdev->dev, "resume not implemented\n"); 442 - return 0; 443 - } 444 - 445 - static struct platform_driver netx_eth_driver = { 446 - .probe = netx_eth_drv_probe, 447 - .remove = netx_eth_drv_remove, 448 - .suspend = netx_eth_drv_suspend, 449 - .resume = netx_eth_drv_resume, 450 - .driver = { 451 - .name = CARDNAME, 452 - }, 453 - }; 454 - 455 - static int __init netx_eth_init(void) 456 - { 457 - unsigned int phy_control, val; 458 - 459 - printk("NetX Ethernet driver\n"); 460 - 461 - phy_control = PHY_CONTROL_PHY_ADDRESS(INTERNAL_PHY_ADR>>1) | 462 - PHY_CONTROL_PHY1_MODE(PHY_MODE_ALL) | 463 - PHY_CONTROL_PHY1_AUTOMDIX | 464 - PHY_CONTROL_PHY1_EN | 465 - PHY_CONTROL_PHY0_MODE(PHY_MODE_ALL) | 466 - PHY_CONTROL_PHY0_AUTOMDIX | 467 - PHY_CONTROL_PHY0_EN | 468 - PHY_CONTROL_CLK_XLATIN; 469 - 470 - val = readl(NETX_SYSTEM_IOC_ACCESS_KEY); 471 - writel(val, NETX_SYSTEM_IOC_ACCESS_KEY); 472 - 473 - writel(phy_control | PHY_CONTROL_RESET, NETX_SYSTEM_PHY_CONTROL); 474 - udelay(100); 475 - 476 - val = readl(NETX_SYSTEM_IOC_ACCESS_KEY); 477 - writel(val, NETX_SYSTEM_IOC_ACCESS_KEY); 478 - 479 - writel(phy_control, NETX_SYSTEM_PHY_CONTROL); 480 - 481 - return platform_driver_register(&netx_eth_driver); 482 - } 483 - 484 - static void __exit netx_eth_cleanup(void) 485 - { 486 - platform_driver_unregister(&netx_eth_driver); 487 - } 488 - 489 - module_init(netx_eth_init); 490 - module_exit(netx_eth_cleanup); 491 - 492 - MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 493 - MODULE_LICENSE("GPL"); 494 - MODULE_ALIAS("platform:" CARDNAME); 495 - MODULE_FIRMWARE("xc0.bin"); 496 - MODULE_FIRMWARE("xc1.bin"); 497 - MODULE_FIRMWARE("xc2.bin");

+1 -1

drivers/net/ethernet/ni/nixge.c

··· 1347 1347 } 1348 1348 1349 1349 priv->phy_mode = of_get_phy_mode(pdev->dev.of_node); 1350 - if (priv->phy_mode < 0) { 1350 + if ((int)priv->phy_mode < 0) { 1351 1351 netdev_err(ndev, "not find \"phy-mode\" property\n"); 1352 1352 err = -EINVAL; 1353 1353 goto unregister_mdio;

+4 -4

drivers/net/ethernet/nxp/Kconfig

··· 1 1 # SPDX-License-Identifier: GPL-2.0-only 2 2 config LPC_ENET 3 - tristate "NXP ethernet MAC on LPC devices" 4 - depends on ARCH_LPC32XX || COMPILE_TEST 5 - select PHYLIB 6 - help 3 + tristate "NXP ethernet MAC on LPC devices" 4 + depends on ARCH_LPC32XX || COMPILE_TEST 5 + select PHYLIB 6 + help 7 7 Say Y or M here if you want to use the NXP ethernet MAC included on 8 8 some NXP LPC devices. You can safely enable this option for LPC32xx 9 9 SoC. Also available as a module.

+2 -2

drivers/net/ethernet/pensando/Kconfig

··· 26 26 found in 27 27 <file:Documentation/networking/device_drivers/pensando/ionic.rst>. 28 28 29 - To compile this driver as a module, choose M here. The module 30 - will be called ionic. 29 + To compile this driver as a module, choose M here. The module 30 + will be called ionic. 31 31 32 32 endif # NET_VENDOR_PENSANDO

+1 -1

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

··· 57 57 void ionic_debugfs_add_ident(struct ionic *ionic) 58 58 { 59 59 debugfs_create_file("identity", 0400, ionic->dentry, 60 - ionic, &identity_fops) ? 0 : -EOPNOTSUPP; 60 + ionic, &identity_fops); 61 61 } 62 62 63 63 void ionic_debugfs_add_sizes(struct ionic *ionic)

+1

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

··· 1704 1704 GFP_KERNEL); 1705 1705 1706 1706 if (!lif->rss_ind_tbl) { 1707 + err = -ENOMEM; 1707 1708 dev_err(dev, "Failed to allocate rss indirection table, aborting\n"); 1708 1709 goto err_out_free_qcqs; 1709 1710 }

+1 -2

drivers/net/ethernet/qlogic/qede/qede_fp.c

··· 779 779 return NULL; 780 780 781 781 skb_reserve(skb, pad); 782 - memcpy(skb_put(skb, len), 783 - page_address(bd->data) + offset, len); 782 + skb_put_data(skb, page_address(bd->data) + offset, len); 784 783 qede_reuse_page(rxq, bd); 785 784 goto out; 786 785 }

+1 -1

drivers/net/ethernet/socionext/netsec.c

··· 2007 2007 NETIF_MSG_LINK | NETIF_MSG_PROBE; 2008 2008 2009 2009 priv->phy_interface = device_get_phy_mode(&pdev->dev); 2010 - if (priv->phy_interface < 0) { 2010 + if ((int)priv->phy_interface < 0) { 2011 2011 dev_err(&pdev->dev, "missing required property 'phy-mode'\n"); 2012 2012 ret = -ENODEV; 2013 2013 goto free_ndev;

+4 -4

drivers/net/ethernet/socionext/sni_ave.c

··· 1566 1566 1567 1567 np = dev->of_node; 1568 1568 phy_mode = of_get_phy_mode(np); 1569 - if (phy_mode < 0) { 1569 + if ((int)phy_mode < 0) { 1570 1570 dev_err(dev, "phy-mode not found\n"); 1571 1571 return -EINVAL; 1572 1572 } ··· 1662 1662 "socionext,syscon-phy-mode", 1663 1663 1, 0, &args); 1664 1664 if (ret) { 1665 - netdev_err(ndev, "can't get syscon-phy-mode property\n"); 1665 + dev_err(dev, "can't get syscon-phy-mode property\n"); 1666 1666 goto out_free_netdev; 1667 1667 } 1668 1668 priv->regmap = syscon_node_to_regmap(args.np); 1669 1669 of_node_put(args.np); 1670 1670 if (IS_ERR(priv->regmap)) { 1671 - netdev_err(ndev, "can't map syscon-phy-mode\n"); 1671 + dev_err(dev, "can't map syscon-phy-mode\n"); 1672 1672 ret = PTR_ERR(priv->regmap); 1673 1673 goto out_free_netdev; 1674 1674 } 1675 1675 ret = priv->data->get_pinmode(priv, phy_mode, args.args[0]); 1676 1676 if (ret) { 1677 - netdev_err(ndev, "invalid phy-mode setting\n"); 1677 + dev_err(dev, "invalid phy-mode setting\n"); 1678 1678 goto out_free_netdev; 1679 1679 } 1680 1680

+1 -1

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

··· 191 191 struct device *dev = &gmac->pdev->dev; 192 192 193 193 gmac->phy_mode = of_get_phy_mode(dev->of_node); 194 - if (gmac->phy_mode < 0) { 194 + if ((int)gmac->phy_mode < 0) { 195 195 dev_err(dev, "missing phy mode property\n"); 196 196 return -EINVAL; 197 197 }

+1 -1

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

··· 339 339 340 340 dwmac->dev = &pdev->dev; 341 341 dwmac->phy_mode = of_get_phy_mode(pdev->dev.of_node); 342 - if (dwmac->phy_mode < 0) { 342 + if ((int)dwmac->phy_mode < 0) { 343 343 dev_err(&pdev->dev, "missing phy-mode property\n"); 344 344 ret = -EINVAL; 345 345 goto err_remove_config_dt;

+2 -3

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

··· 523 523 struct stmmac_rss *cfg, u32 num_rxq) 524 524 { 525 525 void __iomem *ioaddr = hw->pcsr; 526 - u32 *key = (u32 *)cfg->key; 527 526 int i, ret; 528 527 u32 value; 529 528 530 529 value = readl(ioaddr + XGMAC_RSS_CTRL); 531 - if (!cfg->enable) { 530 + if (!cfg || !cfg->enable) { 532 531 value &= ~XGMAC_RSSE; 533 532 writel(value, ioaddr + XGMAC_RSS_CTRL); 534 533 return 0; 535 534 } 536 535 537 536 for (i = 0; i < (sizeof(cfg->key) / sizeof(u32)); i++) { 538 - ret = dwxgmac2_rss_write_reg(ioaddr, true, i, *key++); 537 + ret = dwxgmac2_rss_write_reg(ioaddr, true, i, cfg->key[i]); 539 538 if (ret) 540 539 return ret; 541 540 }

+3 -1

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

··· 1557 1557 for (queue = 0; queue < rx_count; queue++) { 1558 1558 struct stmmac_rx_queue *rx_q = &priv->rx_queue[queue]; 1559 1559 struct page_pool_params pp_params = { 0 }; 1560 + unsigned int num_pages; 1560 1561 1561 1562 rx_q->queue_index = queue; 1562 1563 rx_q->priv_data = priv; 1563 1564 1564 1565 pp_params.flags = PP_FLAG_DMA_MAP; 1565 1566 pp_params.pool_size = DMA_RX_SIZE; 1566 - pp_params.order = DIV_ROUND_UP(priv->dma_buf_sz, PAGE_SIZE); 1567 + num_pages = DIV_ROUND_UP(priv->dma_buf_sz, PAGE_SIZE); 1568 + pp_params.order = ilog2(num_pages); 1567 1569 pp_params.nid = dev_to_node(priv->device); 1568 1570 pp_params.dev = priv->device; 1569 1571 pp_params.dma_dir = DMA_FROM_DEVICE;

+5 -11

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

··· 670 670 unsigned int pkt_count; 671 671 int i, ret = 0; 672 672 673 - if (!phydev || !phydev->pause) 673 + if (!phydev || (!phydev->pause && !phydev->asym_pause)) 674 674 return -EOPNOTSUPP; 675 675 676 676 tpriv = kzalloc(sizeof(*tpriv), GFP_KERNEL); ··· 1233 1233 return -EOPNOTSUPP; 1234 1234 if (!priv->dma_cap.l3l4fnum) 1235 1235 return -EOPNOTSUPP; 1236 - if (priv->rss.enable) { 1237 - struct stmmac_rss rss = { .enable = false, }; 1238 - 1239 - stmmac_rss_configure(priv, priv->hw, &rss, 1236 + if (priv->rss.enable) 1237 + stmmac_rss_configure(priv, priv->hw, NULL, 1240 1238 priv->plat->rx_queues_to_use); 1241 - } 1242 1239 1243 1240 dissector = kzalloc(sizeof(*dissector), GFP_KERNEL); 1244 1241 if (!dissector) { ··· 1354 1357 return -EOPNOTSUPP; 1355 1358 if (!priv->dma_cap.l3l4fnum) 1356 1359 return -EOPNOTSUPP; 1357 - if (priv->rss.enable) { 1358 - struct stmmac_rss rss = { .enable = false, }; 1359 - 1360 - stmmac_rss_configure(priv, priv->hw, &rss, 1360 + if (priv->rss.enable) 1361 + stmmac_rss_configure(priv, priv->hw, NULL, 1361 1362 priv->plat->rx_queues_to_use); 1362 - } 1363 1363 1364 1364 dissector = kzalloc(sizeof(*dissector), GFP_KERNEL); 1365 1365 if (!dissector) {

+1 -1

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

··· 1762 1762 } 1763 1763 } else { 1764 1764 lp->phy_mode = of_get_phy_mode(pdev->dev.of_node); 1765 - if (lp->phy_mode < 0) { 1765 + if ((int)lp->phy_mode < 0) { 1766 1766 ret = -EINVAL; 1767 1767 goto free_netdev; 1768 1768 }

+1

drivers/net/macsec.c

··· 1235 1235 macsec_rxsa_put(rx_sa); 1236 1236 macsec_rxsc_put(rx_sc); 1237 1237 1238 + skb_orphan(skb); 1238 1239 ret = gro_cells_receive(&macsec->gro_cells, skb); 1239 1240 if (ret == NET_RX_SUCCESS) 1240 1241 count_rx(dev, skb->len);

+3 -3

drivers/net/phy/Kconfig

··· 460 460 Supports the Renesas PHYs uPD60620 and uPD60620A. 461 461 462 462 config ROCKCHIP_PHY 463 - tristate "Driver for Rockchip Ethernet PHYs" 464 - ---help--- 465 - Currently supports the integrated Ethernet PHY. 463 + tristate "Driver for Rockchip Ethernet PHYs" 464 + ---help--- 465 + Currently supports the integrated Ethernet PHY. 466 466 467 467 config SMSC_PHY 468 468 tristate "SMSC PHYs"

+3

drivers/net/phy/micrel.c

··· 763 763 * Whenever the device's Asymmetric Pause capability is set to 1, 764 764 * link-up may fail after a link-up to link-down transition. 765 765 * 766 + * The Errata Sheet is for ksz9031, but ksz9021 has the same issue 767 + * 766 768 * Workaround: 767 769 * Do not enable the Asymmetric Pause capability bit. 768 770 */ ··· 1078 1076 /* PHY_GBIT_FEATURES */ 1079 1077 .driver_data = &ksz9021_type, 1080 1078 .probe = kszphy_probe, 1079 + .get_features = ksz9031_get_features, 1081 1080 .config_init = ksz9021_config_init, 1082 1081 .ack_interrupt = kszphy_ack_interrupt, 1083 1082 .config_intr = kszphy_config_intr,

+6 -3

drivers/net/phy/national.c

··· 105 105 106 106 static void ns_10_base_t_hdx_loopack(struct phy_device *phydev, int disable) 107 107 { 108 + u16 lb_dis = BIT(1); 109 + 108 110 if (disable) 109 - ns_exp_write(phydev, 0x1c0, ns_exp_read(phydev, 0x1c0) | 1); 111 + ns_exp_write(phydev, 0x1c0, 112 + ns_exp_read(phydev, 0x1c0) | lb_dis); 110 113 else 111 114 ns_exp_write(phydev, 0x1c0, 112 - ns_exp_read(phydev, 0x1c0) & 0xfffe); 115 + ns_exp_read(phydev, 0x1c0) & ~lb_dis); 113 116 114 117 pr_debug("10BASE-T HDX loopback %s\n", 115 - (ns_exp_read(phydev, 0x1c0) & 0x0001) ? "off" : "on"); 118 + (ns_exp_read(phydev, 0x1c0) & lb_dis) ? "off" : "on"); 116 119 } 117 120 118 121 static int ns_config_init(struct phy_device *phydev)

+2

drivers/net/ppp/ppp_generic.c

··· 1415 1415 netif_wake_queue(ppp->dev); 1416 1416 else 1417 1417 netif_stop_queue(ppp->dev); 1418 + } else { 1419 + kfree_skb(skb); 1418 1420 } 1419 1421 ppp_xmit_unlock(ppp); 1420 1422 }

+1 -1

drivers/net/tap.c

··· 1200 1200 kfree_skb(skb); 1201 1201 err: 1202 1202 rcu_read_lock(); 1203 - tap = rcu_dereference(q->tap); 1203 + tap = rcu_dereference(q->tap); 1204 1204 if (tap && tap->count_tx_dropped) 1205 1205 tap->count_tx_dropped(tap); 1206 1206 rcu_read_unlock();

+5 -1

drivers/net/usb/cdc_ncm.c

··· 681 681 u8 ep; 682 682 683 683 for (ep = 0; ep < intf->cur_altsetting->desc.bNumEndpoints; ep++) { 684 - 685 684 e = intf->cur_altsetting->endpoint + ep; 685 + 686 + /* ignore endpoints which cannot transfer data */ 687 + if (!usb_endpoint_maxp(&e->desc)) 688 + continue; 689 + 686 690 switch (e->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { 687 691 case USB_ENDPOINT_XFER_INT: 688 692 if (usb_endpoint_dir_in(&e->desc)) {

+8

drivers/net/usb/usbnet.c

··· 100 100 int intr = 0; 101 101 102 102 e = alt->endpoint + ep; 103 + 104 + /* ignore endpoints which cannot transfer data */ 105 + if (!usb_endpoint_maxp(&e->desc)) 106 + continue; 107 + 103 108 switch (e->desc.bmAttributes) { 104 109 case USB_ENDPOINT_XFER_INT: 105 110 if (!usb_endpoint_dir_in(&e->desc)) ··· 344 339 { 345 340 enum usb_device_speed speed = dev->udev->speed; 346 341 342 + if (!dev->rx_urb_size || !dev->hard_mtu) 343 + goto insanity; 347 344 switch (speed) { 348 345 case USB_SPEED_HIGH: 349 346 dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size; ··· 362 355 dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu; 363 356 break; 364 357 default: 358 + insanity: 365 359 dev->rx_qlen = dev->tx_qlen = 4; 366 360 } 367 361 }

+2 -1

drivers/net/vrf.c

··· 1154 1154 struct sk_buff *skb; 1155 1155 int err; 1156 1156 1157 - if (family == AF_INET6 && !ipv6_mod_enabled()) 1157 + if ((family == AF_INET6 || family == RTNL_FAMILY_IP6MR) && 1158 + !ipv6_mod_enabled()) 1158 1159 return 0; 1159 1160 1160 1161 skb = nlmsg_new(vrf_fib_rule_nl_size(), GFP_KERNEL);

+1 -1

drivers/net/wireless/ath/Kconfig

··· 34 34 depends on ATH_DEBUG 35 35 depends on EVENT_TRACING 36 36 ---help--- 37 - This option enables tracepoints for atheros wireless drivers. 37 + This option enables tracepoints for atheros wireless drivers. 38 38 Currently, ath9k makes use of this facility. 39 39 40 40 config ATH_REG_DYNAMIC_USER_REG_HINTS

+2 -2

drivers/net/wireless/ath/ar5523/Kconfig

··· 5 5 select ATH_COMMON 6 6 select FW_LOADER 7 7 ---help--- 8 - This module add support for AR5523 based USB dongles such as D-Link 9 - DWL-G132, Netgear WPN111 and many more. 8 + This module add support for AR5523 based USB dongles such as D-Link 9 + DWL-G132, Netgear WPN111 and many more.

+1 -1

drivers/net/wireless/ath/ath6kl/Kconfig

··· 2 2 config ATH6KL 3 3 tristate "Atheros mobile chipsets support" 4 4 depends on CFG80211 5 - ---help--- 5 + ---help--- 6 6 This module adds core support for wireless adapters based on 7 7 Atheros AR6003 and AR6004 chipsets. You still need separate 8 8 bus drivers for USB and SDIO to be able to use real devices.

+1 -1

drivers/net/wireless/ath/ath9k/Kconfig

··· 148 148 depends on ATH9K 149 149 default n 150 150 ---help--- 151 - This option enables channel context support in ath9k, which is needed 151 + This option enables channel context support in ath9k, which is needed 152 152 for multi-channel concurrency. Enable this if P2P PowerSave support 153 153 is required. 154 154

+3 -3

drivers/net/wireless/ath/carl9170/Kconfig

··· 41 41 default y 42 42 43 43 config CARL9170_HWRNG 44 - bool "Random number generator" 45 - depends on CARL9170 && (HW_RANDOM = y || HW_RANDOM = CARL9170) 46 - default n 44 + bool "Random number generator" 45 + depends on CARL9170 && (HW_RANDOM = y || HW_RANDOM = CARL9170) 46 + default n 47 47 help 48 48 Provides a hardware random number generator to the kernel. 49 49

+1 -1

drivers/net/wireless/ath/wil6210/txrx.c

··· 1012 1012 skb_orphan(skb); 1013 1013 1014 1014 if (security && (wil->txrx_ops.rx_crypto_check(wil, skb) != 0)) { 1015 + wil_dbg_txrx(wil, "Rx drop %d bytes\n", skb->len); 1015 1016 dev_kfree_skb(skb); 1016 1017 ndev->stats.rx_dropped++; 1017 1018 stats->rx_replay++; 1018 1019 stats->rx_dropped++; 1019 - wil_dbg_txrx(wil, "Rx drop %d bytes\n", skb->len); 1020 1020 return; 1021 1021 } 1022 1022

+16 -16

drivers/net/wireless/atmel/Kconfig

··· 20 20 select FW_LOADER 21 21 select CRC32 22 22 ---help--- 23 - A driver 802.11b wireless cards based on the Atmel fast-vnet 24 - chips. This driver supports standard Linux wireless extensions. 23 + A driver 802.11b wireless cards based on the Atmel fast-vnet 24 + chips. This driver supports standard Linux wireless extensions. 25 25 26 - Many cards based on this chipset do not have flash memory 27 - and need their firmware loaded at start-up. If yours is 28 - one of these, you will need to provide a firmware image 29 - to be loaded into the card by the driver. The Atmel 30 - firmware package can be downloaded from 31 - <http://www.thekelleys.org.uk/atmel> 26 + Many cards based on this chipset do not have flash memory 27 + and need their firmware loaded at start-up. If yours is 28 + one of these, you will need to provide a firmware image 29 + to be loaded into the card by the driver. The Atmel 30 + firmware package can be downloaded from 31 + <http://www.thekelleys.org.uk/atmel> 32 32 33 33 config PCI_ATMEL 34 34 tristate "Atmel at76c506 PCI cards" 35 35 depends on ATMEL && PCI 36 36 ---help--- 37 - Enable support for PCI and mini-PCI cards containing the 38 - Atmel at76c506 chip. 37 + Enable support for PCI and mini-PCI cards containing the 38 + Atmel at76c506 chip. 39 39 40 40 config PCMCIA_ATMEL 41 41 tristate "Atmel at76c502/at76c504 PCMCIA cards" ··· 48 48 Atmel at76c502 and at76c504 chips. 49 49 50 50 config AT76C50X_USB 51 - tristate "Atmel at76c503/at76c505/at76c505a USB cards" 52 - depends on MAC80211 && USB 53 - select FW_LOADER 54 - ---help--- 55 - Enable support for USB Wireless devices using Atmel at76c503, 56 - at76c505 or at76c505a chips. 51 + tristate "Atmel at76c503/at76c505/at76c505a USB cards" 52 + depends on MAC80211 && USB 53 + select FW_LOADER 54 + ---help--- 55 + Enable support for USB Wireless devices using Atmel at76c503, 56 + at76c505 or at76c505a chips. 57 57 58 58 endif # WLAN_VENDOR_ATMEL

+58 -58

drivers/net/wireless/intel/ipw2x00/Kconfig

··· 13 13 select LIB80211 14 14 select LIBIPW 15 15 ---help--- 16 - A driver for the Intel PRO/Wireless 2100 Network 16 + A driver for the Intel PRO/Wireless 2100 Network 17 17 Connection 802.11b wireless network adapter. 18 18 19 - See <file:Documentation/networking/device_drivers/intel/ipw2100.txt> 19 + See <file:Documentation/networking/device_drivers/intel/ipw2100.txt> 20 20 for information on the capabilities currently enabled in this driver 21 21 and for tips for debugging issues and problems. 22 22 23 23 In order to use this driver, you will need a firmware image for it. 24 - You can obtain the firmware from 25 - <http://ipw2100.sf.net/>. Once you have the firmware image, you 24 + You can obtain the firmware from 25 + <http://ipw2100.sf.net/>. Once you have the firmware image, you 26 26 will need to place it in /lib/firmware. 27 27 28 - You will also very likely need the Wireless Tools in order to 29 - configure your card: 28 + You will also very likely need the Wireless Tools in order to 29 + configure your card: 30 30 31 - <http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/Tools.html>. 31 + <http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/Tools.html>. 32 32 33 - It is recommended that you compile this driver as a module (M) 34 - rather than built-in (Y). This driver requires firmware at device 35 - initialization time, and when built-in this typically happens 36 - before the filesystem is accessible (hence firmware will be 37 - unavailable and initialization will fail). If you do choose to build 38 - this driver into your kernel image, you can avoid this problem by 39 - including the firmware and a firmware loader in an initramfs. 40 - 33 + It is recommended that you compile this driver as a module (M) 34 + rather than built-in (Y). This driver requires firmware at device 35 + initialization time, and when built-in this typically happens 36 + before the filesystem is accessible (hence firmware will be 37 + unavailable and initialization will fail). If you do choose to build 38 + this driver into your kernel image, you can avoid this problem by 39 + including the firmware and a firmware loader in an initramfs. 40 + 41 41 config IPW2100_MONITOR 42 - bool "Enable promiscuous mode" 43 - depends on IPW2100 44 - ---help--- 42 + bool "Enable promiscuous mode" 43 + depends on IPW2100 44 + ---help--- 45 45 Enables promiscuous/monitor mode support for the ipw2100 driver. 46 - With this feature compiled into the driver, you can switch to 46 + With this feature compiled into the driver, you can switch to 47 47 promiscuous mode via the Wireless Tool's Monitor mode. While in this 48 48 mode, no packets can be sent. 49 49 ··· 51 51 bool "Enable full debugging output in IPW2100 module." 52 52 depends on IPW2100 53 53 ---help--- 54 - This option will enable debug tracing output for the IPW2100. 54 + This option will enable debug tracing output for the IPW2100. 55 55 56 - This will result in the kernel module being ~60k larger. You can 57 - control which debug output is sent to the kernel log by setting the 58 - value in 56 + This will result in the kernel module being ~60k larger. You can 57 + control which debug output is sent to the kernel log by setting the 58 + value in 59 59 60 60 /sys/bus/pci/drivers/ipw2100/debug_level 61 61 62 62 This entry will only exist if this option is enabled. 63 63 64 - If you are not trying to debug or develop the IPW2100 driver, you 64 + If you are not trying to debug or develop the IPW2100 driver, you 65 65 most likely want to say N here. 66 66 67 67 config IPW2200 ··· 75 75 select LIB80211 76 76 select LIBIPW 77 77 ---help--- 78 - A driver for the Intel PRO/Wireless 2200BG and 2915ABG Network 79 - Connection adapters. 78 + A driver for the Intel PRO/Wireless 2200BG and 2915ABG Network 79 + Connection adapters. 80 80 81 - See <file:Documentation/networking/device_drivers/intel/ipw2200.txt> 81 + See <file:Documentation/networking/device_drivers/intel/ipw2200.txt> 82 82 for information on the capabilities currently enabled in this 83 83 driver and for tips for debugging issues and problems. 84 84 85 85 In order to use this driver, you will need a firmware image for it. 86 - You can obtain the firmware from 87 - <http://ipw2200.sf.net/>. See the above referenced README.ipw2200 86 + You can obtain the firmware from 87 + <http://ipw2200.sf.net/>. See the above referenced README.ipw2200 88 88 for information on where to install the firmware images. 89 89 90 - You will also very likely need the Wireless Tools in order to 91 - configure your card: 90 + You will also very likely need the Wireless Tools in order to 91 + configure your card: 92 92 93 - <http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/Tools.html>. 93 + <http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/Tools.html>. 94 94 95 - It is recommended that you compile this driver as a module (M) 96 - rather than built-in (Y). This driver requires firmware at device 97 - initialization time, and when built-in this typically happens 98 - before the filesystem is accessible (hence firmware will be 99 - unavailable and initialization will fail). If you do choose to build 100 - this driver into your kernel image, you can avoid this problem by 101 - including the firmware and a firmware loader in an initramfs. 95 + It is recommended that you compile this driver as a module (M) 96 + rather than built-in (Y). This driver requires firmware at device 97 + initialization time, and when built-in this typically happens 98 + before the filesystem is accessible (hence firmware will be 99 + unavailable and initialization will fail). If you do choose to build 100 + this driver into your kernel image, you can avoid this problem by 101 + including the firmware and a firmware loader in an initramfs. 102 102 103 103 config IPW2200_MONITOR 104 - bool "Enable promiscuous mode" 105 - depends on IPW2200 106 - ---help--- 104 + bool "Enable promiscuous mode" 105 + depends on IPW2200 106 + ---help--- 107 107 Enables promiscuous/monitor mode support for the ipw2200 driver. 108 - With this feature compiled into the driver, you can switch to 108 + With this feature compiled into the driver, you can switch to 109 109 promiscuous mode via the Wireless Tool's Monitor mode. While in this 110 110 mode, no packets can be sent. 111 111 ··· 118 118 depends on IPW2200_MONITOR 119 119 select IPW2200_RADIOTAP 120 120 ---help--- 121 - Enables the creation of a second interface prefixed 'rtap'. 122 - This second interface will provide every received in radiotap 121 + Enables the creation of a second interface prefixed 'rtap'. 122 + This second interface will provide every received in radiotap 123 123 format. 124 124 125 - This is useful for performing wireless network analysis while 126 - maintaining an active association. 125 + This is useful for performing wireless network analysis while 126 + maintaining an active association. 127 127 128 - Example usage: 128 + Example usage: 129 129 130 - % modprobe ipw2200 rtap_iface=1 131 - % ifconfig rtap0 up 132 - % tethereal -i rtap0 130 + % modprobe ipw2200 rtap_iface=1 131 + % ifconfig rtap0 up 132 + % tethereal -i rtap0 133 133 134 - If you do not specify 'rtap_iface=1' as a module parameter then 135 - the rtap interface will not be created and you will need to turn 136 - it on via sysfs: 137 - 138 - % echo 1 > /sys/bus/pci/drivers/ipw2200/*/rtap_iface 134 + If you do not specify 'rtap_iface=1' as a module parameter then 135 + the rtap interface will not be created and you will need to turn 136 + it on via sysfs: 137 + 138 + % echo 1 > /sys/bus/pci/drivers/ipw2200/*/rtap_iface 139 139 140 140 config IPW2200_QOS 141 - bool "Enable QoS support" 142 - depends on IPW2200 141 + bool "Enable QoS support" 142 + depends on IPW2200 143 143 144 144 config IPW2200_DEBUG 145 145 bool "Enable full debugging output in IPW2200 module."

+3 -3

drivers/net/wireless/intel/iwlegacy/Kconfig

··· 91 91 any problems you may encounter. 92 92 93 93 config IWLEGACY_DEBUGFS 94 - bool "iwlegacy (iwl 3945/4965) debugfs support" 95 - depends on IWLEGACY && MAC80211_DEBUGFS 96 - ---help--- 94 + bool "iwlegacy (iwl 3945/4965) debugfs support" 95 + depends on IWLEGACY && MAC80211_DEBUGFS 96 + ---help--- 97 97 Enable creation of debugfs files for the iwlegacy drivers. This 98 98 is a low-impact option that allows getting insight into the 99 99 driver's state at runtime.

+3 -3

drivers/net/wireless/intel/iwlwifi/Kconfig

··· 119 119 any problems you may encounter. 120 120 121 121 config IWLWIFI_DEBUGFS 122 - bool "iwlwifi debugfs support" 123 - depends on MAC80211_DEBUGFS 124 - ---help--- 122 + bool "iwlwifi debugfs support" 123 + depends on MAC80211_DEBUGFS 124 + ---help--- 125 125 Enable creation of debugfs files for the iwlwifi drivers. This 126 126 is a low-impact option that allows getting insight into the 127 127 driver's state at runtime.

+5 -3

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

··· 889 889 * firmware versions. Unfortunately, we don't have a TLV API 890 890 * flag to rely on, so rely on the major version which is in 891 891 * the first byte of ucode_ver. This was implemented 892 - * initially on version 38 and then backported to 36, 29 and 893 - * 17. 892 + * initially on version 38 and then backported to29 and 17. 893 + * The intention was to have it in 36 as well, but not all 894 + * 8000 family got this feature enabled. The 8000 family is 895 + * the only one using version 36, so skip this version 896 + * entirely. 894 897 */ 895 898 return IWL_UCODE_SERIAL(mvm->fw->ucode_ver) >= 38 || 896 - IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 36 || 897 899 IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 29 || 898 900 IWL_UCODE_SERIAL(mvm->fw->ucode_ver) == 17; 899 901 }

+7 -2

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

··· 555 555 return ((s16)le16_to_cpu(*(__le16 *)a) - 556 556 (s16)le16_to_cpu(*(__le16 *)b)); 557 557 } 558 + #endif 558 559 559 560 int iwl_mvm_send_temp_report_ths_cmd(struct iwl_mvm *mvm) 560 561 { 561 562 struct temp_report_ths_cmd cmd = {0}; 562 - int ret, i, j, idx = 0; 563 + int ret; 564 + #ifdef CONFIG_THERMAL 565 + int i, j, idx = 0; 563 566 564 567 lockdep_assert_held(&mvm->mutex); 565 568 566 569 if (!mvm->tz_device.tzone) 567 - return -EINVAL; 570 + goto send; 568 571 569 572 /* The driver holds array of temperature trips that are unsorted 570 573 * and uncompressed, the FW should get it compressed and sorted ··· 600 597 } 601 598 602 599 send: 600 + #endif 603 601 ret = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(PHY_OPS_GROUP, 604 602 TEMP_REPORTING_THRESHOLDS_CMD), 605 603 0, sizeof(cmd), &cmd); ··· 611 607 return ret; 612 608 } 613 609 610 + #ifdef CONFIG_THERMAL 614 611 static int iwl_mvm_tzone_get_temp(struct thermal_zone_device *device, 615 612 int *temperature) 616 613 {

+4 -7

drivers/net/wireless/mediatek/mt76/mt7615/mcu.c

··· 333 333 334 334 static int mt7615_load_patch(struct mt7615_dev *dev) 335 335 { 336 - const char *firmware = MT7615_ROM_PATCH; 337 336 const struct mt7615_patch_hdr *hdr; 338 337 const struct firmware *fw = NULL; 339 338 int len, ret, sem; ··· 348 349 return -EAGAIN; 349 350 } 350 351 351 - ret = request_firmware(&fw, firmware, dev->mt76.dev); 352 + ret = request_firmware(&fw, MT7615_ROM_PATCH, dev->mt76.dev); 352 353 if (ret) 353 354 goto out; 354 355 ··· 446 447 447 448 static int mt7615_load_ram(struct mt7615_dev *dev) 448 449 { 449 - const struct firmware *fw; 450 450 const struct mt7615_fw_trailer *hdr; 451 - const char *n9_firmware = MT7615_FIRMWARE_N9; 452 - const char *cr4_firmware = MT7615_FIRMWARE_CR4; 451 + const struct firmware *fw; 453 452 int ret; 454 453 455 - ret = request_firmware(&fw, n9_firmware, dev->mt76.dev); 454 + ret = request_firmware(&fw, MT7615_FIRMWARE_N9, dev->mt76.dev); 456 455 if (ret) 457 456 return ret; 458 457 ··· 479 482 480 483 release_firmware(fw); 481 484 482 - ret = request_firmware(&fw, cr4_firmware, dev->mt76.dev); 485 + ret = request_firmware(&fw, MT7615_FIRMWARE_CR4, dev->mt76.dev); 483 486 if (ret) 484 487 return ret; 485 488

+3 -3

drivers/net/wireless/mediatek/mt76/mt7615/mt7615.h

··· 26 26 #define MT7615_RX_RING_SIZE 1024 27 27 #define MT7615_RX_MCU_RING_SIZE 512 28 28 29 - #define MT7615_FIRMWARE_CR4 "mt7615_cr4.bin" 30 - #define MT7615_FIRMWARE_N9 "mt7615_n9.bin" 31 - #define MT7615_ROM_PATCH "mt7615_rom_patch.bin" 29 + #define MT7615_FIRMWARE_CR4 "mediatek/mt7615_cr4.bin" 30 + #define MT7615_FIRMWARE_N9 "mediatek/mt7615_n9.bin" 31 + #define MT7615_ROM_PATCH "mediatek/mt7615_rom_patch.bin" 32 32 33 33 #define MT7615_EEPROM_SIZE 1024 34 34 #define MT7615_TOKEN_SIZE 4096

+12 -12

drivers/net/wireless/ralink/rt2x00/Kconfig

··· 98 98 bool "rt2800pci - Include support for rt53xx devices (EXPERIMENTAL)" 99 99 default y 100 100 ---help--- 101 - This adds support for rt53xx wireless chipset family to the 102 - rt2800pci driver. 103 - Supported chips: RT5390 101 + This adds support for rt53xx wireless chipset family to the 102 + rt2800pci driver. 103 + Supported chips: RT5390 104 104 105 105 config RT2800PCI_RT3290 106 106 bool "rt2800pci - Include support for rt3290 devices (EXPERIMENTAL)" 107 107 default y 108 108 ---help--- 109 - This adds support for rt3290 wireless chipset family to the 110 - rt2800pci driver. 111 - Supported chips: RT3290 109 + This adds support for rt3290 wireless chipset family to the 110 + rt2800pci driver. 111 + Supported chips: RT3290 112 112 endif 113 113 114 114 config RT2500USB ··· 176 176 config RT2800USB_RT53XX 177 177 bool "rt2800usb - Include support for rt53xx devices (EXPERIMENTAL)" 178 178 ---help--- 179 - This adds support for rt53xx wireless chipset family to the 180 - rt2800usb driver. 181 - Supported chips: RT5370 179 + This adds support for rt53xx wireless chipset family to the 180 + rt2800usb driver. 181 + Supported chips: RT5370 182 182 183 183 config RT2800USB_RT55XX 184 184 bool "rt2800usb - Include support for rt55xx devices (EXPERIMENTAL)" 185 185 ---help--- 186 - This adds support for rt55xx wireless chipset family to the 187 - rt2800usb driver. 188 - Supported chips: RT5572 186 + This adds support for rt55xx wireless chipset family to the 187 + rt2800usb driver. 188 + Supported chips: RT5572 189 189 190 190 config RT2800USB_UNKNOWN 191 191 bool "rt2800usb - Include support for unknown (USB) devices"

-3

drivers/net/wireless/realtek/rtw88/mac.c

··· 707 707 rtwdev->h2c.last_box_num = 0; 708 708 rtwdev->h2c.seq = 0; 709 709 710 - rtw_fw_send_general_info(rtwdev); 711 - rtw_fw_send_phydm_info(rtwdev); 712 - 713 710 rtw_flag_set(rtwdev, RTW_FLAG_FW_RUNNING); 714 711 715 712 return 0;

+4

drivers/net/wireless/realtek/rtw88/main.c

··· 704 704 goto err_off; 705 705 } 706 706 707 + /* send H2C after HCI has started */ 708 + rtw_fw_send_general_info(rtwdev); 709 + rtw_fw_send_phydm_info(rtwdev); 710 + 707 711 wifi_only = !rtwdev->efuse.btcoex; 708 712 rtw_coex_power_on_setting(rtwdev); 709 713 rtw_coex_init_hw_config(rtwdev, wifi_only);

+38 -10

drivers/net/wireless/realtek/rtw88/pci.c

··· 90 90 return tx_ring->r.head + offset; 91 91 } 92 92 93 - static void rtw_pci_free_tx_ring(struct rtw_dev *rtwdev, 94 - struct rtw_pci_tx_ring *tx_ring) 93 + static void rtw_pci_free_tx_ring_skbs(struct rtw_dev *rtwdev, 94 + struct rtw_pci_tx_ring *tx_ring) 95 95 { 96 96 struct pci_dev *pdev = to_pci_dev(rtwdev->dev); 97 97 struct rtw_pci_tx_data *tx_data; 98 98 struct sk_buff *skb, *tmp; 99 99 dma_addr_t dma; 100 - u8 *head = tx_ring->r.head; 101 - u32 len = tx_ring->r.len; 102 - int ring_sz = len * tx_ring->r.desc_size; 103 100 104 101 /* free every skb remained in tx list */ 105 102 skb_queue_walk_safe(&tx_ring->queue, skb, tmp) { ··· 107 110 pci_unmap_single(pdev, dma, skb->len, PCI_DMA_TODEVICE); 108 111 dev_kfree_skb_any(skb); 109 112 } 113 + } 114 + 115 + static void rtw_pci_free_tx_ring(struct rtw_dev *rtwdev, 116 + struct rtw_pci_tx_ring *tx_ring) 117 + { 118 + struct pci_dev *pdev = to_pci_dev(rtwdev->dev); 119 + u8 *head = tx_ring->r.head; 120 + u32 len = tx_ring->r.len; 121 + int ring_sz = len * tx_ring->r.desc_size; 122 + 123 + rtw_pci_free_tx_ring_skbs(rtwdev, tx_ring); 110 124 111 125 /* free the ring itself */ 112 126 pci_free_consistent(pdev, ring_sz, head, tx_ring->r.dma); 113 127 tx_ring->r.head = NULL; 114 128 } 115 129 116 - static void rtw_pci_free_rx_ring(struct rtw_dev *rtwdev, 117 - struct rtw_pci_rx_ring *rx_ring) 130 + static void rtw_pci_free_rx_ring_skbs(struct rtw_dev *rtwdev, 131 + struct rtw_pci_rx_ring *rx_ring) 118 132 { 119 133 struct pci_dev *pdev = to_pci_dev(rtwdev->dev); 120 134 struct sk_buff *skb; 121 - dma_addr_t dma; 122 - u8 *head = rx_ring->r.head; 123 135 int buf_sz = RTK_PCI_RX_BUF_SIZE; 124 - int ring_sz = rx_ring->r.desc_size * rx_ring->r.len; 136 + dma_addr_t dma; 125 137 int i; 126 138 127 139 for (i = 0; i < rx_ring->r.len; i++) { ··· 143 137 dev_kfree_skb(skb); 144 138 rx_ring->buf[i] = NULL; 145 139 } 140 + } 141 + 142 + static void rtw_pci_free_rx_ring(struct rtw_dev *rtwdev, 143 + struct rtw_pci_rx_ring *rx_ring) 144 + { 145 + struct pci_dev *pdev = to_pci_dev(rtwdev->dev); 146 + u8 *head = rx_ring->r.head; 147 + int ring_sz = rx_ring->r.desc_size * rx_ring->r.len; 148 + 149 + rtw_pci_free_rx_ring_skbs(rtwdev, rx_ring); 146 150 147 151 pci_free_consistent(pdev, ring_sz, head, rx_ring->r.dma); 148 152 } ··· 500 484 rtwpci->rx_tag = 0; 501 485 } 502 486 487 + static void rtw_pci_dma_release(struct rtw_dev *rtwdev, struct rtw_pci *rtwpci) 488 + { 489 + struct rtw_pci_tx_ring *tx_ring; 490 + u8 queue; 491 + 492 + for (queue = 0; queue < RTK_MAX_TX_QUEUE_NUM; queue++) { 493 + tx_ring = &rtwpci->tx_rings[queue]; 494 + rtw_pci_free_tx_ring_skbs(rtwdev, tx_ring); 495 + } 496 + } 497 + 503 498 static int rtw_pci_start(struct rtw_dev *rtwdev) 504 499 { 505 500 struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv; ··· 532 505 533 506 spin_lock_irqsave(&rtwpci->irq_lock, flags); 534 507 rtw_pci_disable_interrupt(rtwdev, rtwpci); 508 + rtw_pci_dma_release(rtwdev, rtwpci); 535 509 spin_unlock_irqrestore(&rtwpci->irq_lock, flags); 536 510 } 537 511

+1 -1

drivers/net/wireless/zydas/zd1211rw/zd_usb.c

··· 1633 1633 */ 1634 1634 if (rr->length < struct_size(regs, regs, count)) { 1635 1635 dev_dbg_f(zd_usb_dev(usb), 1636 - "error: actual length %d less than expected %ld\n", 1636 + "error: actual length %d less than expected %zu\n", 1637 1637 rr->length, struct_size(regs, regs, count)); 1638 1638 return false; 1639 1639 }

+1 -1

drivers/nfc/st95hf/core.c

··· 661 661 result = -ETIMEDOUT; 662 662 else 663 663 result = -EIO; 664 - return result; 664 + return result; 665 665 } 666 666 667 667 /* Check for CRC err only if CRC is present in the tag response */

+1 -1

drivers/of/of_mdio.c

··· 362 362 int ret; 363 363 364 364 iface = of_get_phy_mode(np); 365 - if (iface < 0) 365 + if ((int)iface < 0) 366 366 return NULL; 367 367 if (of_phy_is_fixed_link(np)) { 368 368 ret = of_phy_register_fixed_link(np);

+2 -2

drivers/ptp/ptp_chardev.c

··· 155 155 err = -EINVAL; 156 156 break; 157 157 } else if (cmd == PTP_EXTTS_REQUEST) { 158 - req.extts.flags &= ~PTP_EXTTS_VALID_FLAGS; 158 + req.extts.flags &= PTP_EXTTS_V1_VALID_FLAGS; 159 159 req.extts.rsv[0] = 0; 160 160 req.extts.rsv[1] = 0; 161 161 } ··· 184 184 err = -EINVAL; 185 185 break; 186 186 } else if (cmd == PTP_PEROUT_REQUEST) { 187 - req.perout.flags &= ~PTP_PEROUT_VALID_FLAGS; 187 + req.perout.flags &= PTP_PEROUT_V1_VALID_FLAGS; 188 188 req.perout.rsv[0] = 0; 189 189 req.perout.rsv[1] = 0; 190 190 req.perout.rsv[2] = 0;

+14 -14

include/linux/mlx5/mlx5_ifc.h

··· 282 282 MLX5_CMD_OP_ALLOC_MODIFY_HEADER_CONTEXT = 0x940, 283 283 MLX5_CMD_OP_DEALLOC_MODIFY_HEADER_CONTEXT = 0x941, 284 284 MLX5_CMD_OP_QUERY_MODIFY_HEADER_CONTEXT = 0x942, 285 - MLX5_CMD_OP_SYNC_STEERING = 0xb00, 286 285 MLX5_CMD_OP_FPGA_CREATE_QP = 0x960, 287 286 MLX5_CMD_OP_FPGA_MODIFY_QP = 0x961, 288 287 MLX5_CMD_OP_FPGA_QUERY_QP = 0x962, ··· 295 296 MLX5_CMD_OP_DESTROY_UCTX = 0xa06, 296 297 MLX5_CMD_OP_CREATE_UMEM = 0xa08, 297 298 MLX5_CMD_OP_DESTROY_UMEM = 0xa0a, 299 + MLX5_CMD_OP_SYNC_STEERING = 0xb00, 298 300 MLX5_CMD_OP_MAX 299 301 }; 300 302 ··· 487 487 488 488 struct mlx5_ifc_fte_match_set_misc_bits { 489 489 u8 gre_c_present[0x1]; 490 - u8 reserved_auto1[0x1]; 490 + u8 reserved_at_1[0x1]; 491 491 u8 gre_k_present[0x1]; 492 492 u8 gre_s_present[0x1]; 493 493 u8 source_vhca_port[0x4]; ··· 5054 5054 5055 5055 struct mlx5_ifc_other_hca_cap_bits { 5056 5056 u8 roce[0x1]; 5057 - u8 reserved_0[0x27f]; 5057 + u8 reserved_at_1[0x27f]; 5058 5058 }; 5059 5059 5060 5060 struct mlx5_ifc_query_other_hca_cap_out_bits { 5061 5061 u8 status[0x8]; 5062 - u8 reserved_0[0x18]; 5062 + u8 reserved_at_8[0x18]; 5063 5063 5064 5064 u8 syndrome[0x20]; 5065 5065 5066 - u8 reserved_1[0x40]; 5066 + u8 reserved_at_40[0x40]; 5067 5067 5068 5068 struct mlx5_ifc_other_hca_cap_bits other_capability; 5069 5069 }; 5070 5070 5071 5071 struct mlx5_ifc_query_other_hca_cap_in_bits { 5072 5072 u8 opcode[0x10]; 5073 - u8 reserved_0[0x10]; 5073 + u8 reserved_at_10[0x10]; 5074 5074 5075 - u8 reserved_1[0x10]; 5075 + u8 reserved_at_20[0x10]; 5076 5076 u8 op_mod[0x10]; 5077 5077 5078 - u8 reserved_2[0x10]; 5078 + u8 reserved_at_40[0x10]; 5079 5079 u8 function_id[0x10]; 5080 5080 5081 - u8 reserved_3[0x20]; 5081 + u8 reserved_at_60[0x20]; 5082 5082 }; 5083 5083 5084 5084 struct mlx5_ifc_modify_other_hca_cap_out_bits { 5085 5085 u8 status[0x8]; 5086 - u8 reserved_0[0x18]; 5086 + u8 reserved_at_8[0x18]; 5087 5087 5088 5088 u8 syndrome[0x20]; 5089 5089 5090 - u8 reserved_1[0x40]; 5090 + u8 reserved_at_40[0x40]; 5091 5091 }; 5092 5092 5093 5093 struct mlx5_ifc_modify_other_hca_cap_in_bits { 5094 5094 u8 opcode[0x10]; 5095 - u8 reserved_0[0x10]; 5095 + u8 reserved_at_10[0x10]; 5096 5096 5097 - u8 reserved_1[0x10]; 5097 + u8 reserved_at_20[0x10]; 5098 5098 u8 op_mod[0x10]; 5099 5099 5100 - u8 reserved_2[0x10]; 5100 + u8 reserved_at_40[0x10]; 5101 5101 u8 function_id[0x10]; 5102 5102 u8 field_select[0x20]; 5103 5103

-13

include/linux/platform_data/eth-netx.h

··· 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 - /* 3 - * Copyright (c) 2005 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix 4 - */ 5 - 6 - #ifndef __ETH_NETX_H 7 - #define __ETH_NETX_H 8 - 9 - struct netxeth_platform_data { 10 - unsigned int xcno; /* number of xmac/xpec engine this eth uses */ 11 - }; 12 - 13 - #endif

+9

include/linux/skbuff.h

··· 4144 4144 4145 4145 return NULL; 4146 4146 } 4147 + 4148 + static inline void skb_ext_reset(struct sk_buff *skb) 4149 + { 4150 + if (unlikely(skb->active_extensions)) { 4151 + __skb_ext_put(skb->extensions); 4152 + skb->active_extensions = 0; 4153 + } 4154 + } 4147 4155 #else 4148 4156 static inline void skb_ext_put(struct sk_buff *skb) {} 4157 + static inline void skb_ext_reset(struct sk_buff *skb) {} 4149 4158 static inline void skb_ext_del(struct sk_buff *skb, int unused) {} 4150 4159 static inline void __skb_ext_copy(struct sk_buff *d, const struct sk_buff *s) {} 4151 4160 static inline void skb_ext_copy(struct sk_buff *dst, const struct sk_buff *s) {}

+1

include/net/inet_timewait_sock.h

··· 71 71 tw_pad : 2, /* 2 bits hole */ 72 72 tw_tos : 8; 73 73 u32 tw_txhash; 74 + u32 tw_priority; 74 75 struct timer_list tw_timer; 75 76 struct inet_bind_bucket *tw_tb; 76 77 };

+1 -1

include/net/ipv6.h

··· 981 981 * upper-layer output functions 982 982 */ 983 983 int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6, 984 - __u32 mark, struct ipv6_txoptions *opt, int tclass); 984 + __u32 mark, struct ipv6_txoptions *opt, int tclass, u32 priority); 985 985 986 986 int ip6_find_1stfragopt(struct sk_buff *skb, u8 **nexthdr); 987 987

+6

include/net/netfilter/nf_tables.h

··· 889 889 NFT_CHAIN_HW_OFFLOAD = 0x2, 890 890 }; 891 891 892 + #define NFT_CHAIN_POLICY_UNSET U8_MAX 893 + 892 894 /** 893 895 * struct nft_chain - nf_tables chain 894 896 * ··· 1182 1180 struct nft_flowtable *nft_flowtable_lookup(const struct nft_table *table, 1183 1181 const struct nlattr *nla, 1184 1182 u8 genmask); 1183 + 1184 + void nf_tables_deactivate_flowtable(const struct nft_ctx *ctx, 1185 + struct nft_flowtable *flowtable, 1186 + enum nft_trans_phase phase); 1185 1187 1186 1188 void nft_register_flowtable_type(struct nf_flowtable_type *type); 1187 1189 void nft_unregister_flowtable_type(struct nf_flowtable_type *type);

+2 -1

include/net/route.h

··· 53 53 unsigned int rt_flags; 54 54 __u16 rt_type; 55 55 __u8 rt_is_input; 56 - u8 rt_gw_family; 56 + __u8 rt_uses_gateway; 57 57 58 58 int rt_iif; 59 59 60 + u8 rt_gw_family; 60 61 /* Info on neighbour */ 61 62 union { 62 63 __be32 rt_gw4;

+5

include/net/sch_generic.h

··· 494 494 return q; 495 495 } 496 496 497 + static inline struct Qdisc *qdisc_root_bh(const struct Qdisc *qdisc) 498 + { 499 + return rcu_dereference_bh(qdisc->dev_queue->qdisc); 500 + } 501 + 497 502 static inline struct Qdisc *qdisc_root_sleeping(const struct Qdisc *qdisc) 498 503 { 499 504 return qdisc->dev_queue->qdisc_sleeping;

+2 -2

include/uapi/linux/btf.h

··· 22 22 }; 23 23 24 24 /* Max # of type identifier */ 25 - #define BTF_MAX_TYPE 0x0000ffff 25 + #define BTF_MAX_TYPE 0x000fffff 26 26 /* Max offset into the string section */ 27 - #define BTF_MAX_NAME_OFFSET 0x0000ffff 27 + #define BTF_MAX_NAME_OFFSET 0x00ffffff 28 28 /* Max # of struct/union/enum members or func args */ 29 29 #define BTF_MAX_VLEN 0xffff 30 30

+3 -3

include/uapi/linux/netfilter_bridge/ebtables.h

··· 123 123 union { 124 124 struct { 125 125 char name[EBT_EXTENSION_MAXNAMELEN]; 126 - uint8_t revision; 126 + __u8 revision; 127 127 }; 128 128 struct xt_match *match; 129 129 } u; ··· 136 136 union { 137 137 struct { 138 138 char name[EBT_EXTENSION_MAXNAMELEN]; 139 - uint8_t revision; 139 + __u8 revision; 140 140 }; 141 141 struct xt_target *watcher; 142 142 } u; ··· 149 149 union { 150 150 struct { 151 151 char name[EBT_EXTENSION_MAXNAMELEN]; 152 - uint8_t revision; 152 + __u8 revision; 153 153 }; 154 154 struct xt_target *target; 155 155 } u;

+22

include/uapi/linux/ptp_clock.h

··· 31 31 #define PTP_ENABLE_FEATURE (1<<0) 32 32 #define PTP_RISING_EDGE (1<<1) 33 33 #define PTP_FALLING_EDGE (1<<2) 34 + 35 + /* 36 + * flag fields valid for the new PTP_EXTTS_REQUEST2 ioctl. 37 + */ 34 38 #define PTP_EXTTS_VALID_FLAGS (PTP_ENABLE_FEATURE | \ 35 39 PTP_RISING_EDGE | \ 36 40 PTP_FALLING_EDGE) 37 41 38 42 /* 43 + * flag fields valid for the original PTP_EXTTS_REQUEST ioctl. 44 + * DO NOT ADD NEW FLAGS HERE. 45 + */ 46 + #define PTP_EXTTS_V1_VALID_FLAGS (PTP_ENABLE_FEATURE | \ 47 + PTP_RISING_EDGE | \ 48 + PTP_FALLING_EDGE) 49 + 50 + /* 39 51 * Bits of the ptp_perout_request.flags field: 40 52 */ 41 53 #define PTP_PEROUT_ONE_SHOT (1<<0) 54 + 55 + /* 56 + * flag fields valid for the new PTP_PEROUT_REQUEST2 ioctl. 57 + */ 42 58 #define PTP_PEROUT_VALID_FLAGS (PTP_PEROUT_ONE_SHOT) 59 + 60 + /* 61 + * No flags are valid for the original PTP_PEROUT_REQUEST ioctl 62 + */ 63 + #define PTP_PEROUT_V1_VALID_FLAGS (0) 64 + 43 65 /* 44 66 * struct ptp_clock_time - represents a time value 45 67 *

+3 -4

kernel/bpf/btf.c

··· 2332 2332 if (BITS_PER_BYTE_MASKED(struct_bits_off)) { 2333 2333 btf_verifier_log_member(env, struct_type, member, 2334 2334 "Member is not byte aligned"); 2335 - return -EINVAL; 2335 + return -EINVAL; 2336 2336 } 2337 2337 2338 2338 nr_bits = int_bitsize; ··· 2377 2377 return -EINVAL; 2378 2378 } 2379 2379 2380 - if (t->size != sizeof(int)) { 2381 - btf_verifier_log_type(env, t, "Expected size:%zu", 2382 - sizeof(int)); 2380 + if (t->size > 8 || !is_power_of_2(t->size)) { 2381 + btf_verifier_log_type(env, t, "Unexpected size"); 2383 2382 return -EINVAL; 2384 2383 } 2385 2384

+1 -1

kernel/bpf/xskmap.c

··· 37 37 38 38 node = kzalloc(sizeof(*node), GFP_ATOMIC | __GFP_NOWARN); 39 39 if (!node) 40 - return NULL; 40 + return ERR_PTR(-ENOMEM); 41 41 42 42 err = xsk_map_inc(map); 43 43 if (err) {

+21 -5

kernel/trace/bpf_trace.c

··· 505 505 .arg5_type = ARG_CONST_SIZE_OR_ZERO, 506 506 }; 507 507 508 - static DEFINE_PER_CPU(struct pt_regs, bpf_pt_regs); 509 - static DEFINE_PER_CPU(struct perf_sample_data, bpf_misc_sd); 508 + static DEFINE_PER_CPU(int, bpf_event_output_nest_level); 509 + struct bpf_nested_pt_regs { 510 + struct pt_regs regs[3]; 511 + }; 512 + static DEFINE_PER_CPU(struct bpf_nested_pt_regs, bpf_pt_regs); 513 + static DEFINE_PER_CPU(struct bpf_trace_sample_data, bpf_misc_sds); 510 514 511 515 u64 bpf_event_output(struct bpf_map *map, u64 flags, void *meta, u64 meta_size, 512 516 void *ctx, u64 ctx_size, bpf_ctx_copy_t ctx_copy) 513 517 { 514 - struct perf_sample_data *sd = this_cpu_ptr(&bpf_misc_sd); 515 - struct pt_regs *regs = this_cpu_ptr(&bpf_pt_regs); 518 + int nest_level = this_cpu_inc_return(bpf_event_output_nest_level); 516 519 struct perf_raw_frag frag = { 517 520 .copy = ctx_copy, 518 521 .size = ctx_size, ··· 530 527 .data = meta, 531 528 }, 532 529 }; 530 + struct perf_sample_data *sd; 531 + struct pt_regs *regs; 532 + u64 ret; 533 + 534 + if (WARN_ON_ONCE(nest_level > ARRAY_SIZE(bpf_misc_sds.sds))) { 535 + ret = -EBUSY; 536 + goto out; 537 + } 538 + sd = this_cpu_ptr(&bpf_misc_sds.sds[nest_level - 1]); 539 + regs = this_cpu_ptr(&bpf_pt_regs.regs[nest_level - 1]); 533 540 534 541 perf_fetch_caller_regs(regs); 535 542 perf_sample_data_init(sd, 0, 0); 536 543 sd->raw = &raw; 537 544 538 - return __bpf_perf_event_output(regs, map, flags, sd); 545 + ret = __bpf_perf_event_output(regs, map, flags, sd); 546 + out: 547 + this_cpu_dec(bpf_event_output_nest_level); 548 + return ret; 539 549 } 540 550 541 551 BPF_CALL_0(bpf_get_current_task)

+2 -3

lib/Kconfig

··· 555 555 Implementation is done using GnuPG MPI library 556 556 557 557 config DIMLIB 558 - bool "DIM library" 559 - default y 558 + bool 560 559 help 561 560 Dynamic Interrupt Moderation library. 562 - Implements an algorithm for dynamically change CQ modertion values 561 + Implements an algorithm for dynamically changing CQ moderation values 563 562 according to run time performance. 564 563 565 564 #

+5

net/appletalk/ddp.c

··· 1023 1023 */ 1024 1024 if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM) 1025 1025 goto out; 1026 + 1027 + rc = -EPERM; 1028 + if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW)) 1029 + goto out; 1030 + 1026 1031 rc = -ENOMEM; 1027 1032 sk = sk_alloc(net, PF_APPLETALK, GFP_KERNEL, &ddp_proto, kern); 1028 1033 if (!sk)

+2

net/ax25/af_ax25.c

··· 855 855 break; 856 856 857 857 case SOCK_RAW: 858 + if (!capable(CAP_NET_RAW)) 859 + return -EPERM; 858 860 break; 859 861 default: 860 862 return -ESOCKTNOSUPPORT;

+5 -5

net/batman-adv/Kconfig

··· 12 12 depends on NET 13 13 select LIBCRC32C 14 14 help 15 - B.A.T.M.A.N. (better approach to mobile ad-hoc networking) is 16 - a routing protocol for multi-hop ad-hoc mesh networks. The 17 - networks may be wired or wireless. See 18 - https://www.open-mesh.org/ for more information and user space 19 - tools. 15 + B.A.T.M.A.N. (better approach to mobile ad-hoc networking) is 16 + a routing protocol for multi-hop ad-hoc mesh networks. The 17 + networks may be wired or wireless. See 18 + https://www.open-mesh.org/ for more information and user space 19 + tools. 20 20 21 21 config BATMAN_ADV_BATMAN_V 22 22 bool "B.A.T.M.A.N. V protocol"

+2 -2

net/core/dev.c

··· 5666 5666 static void napi_skb_free_stolen_head(struct sk_buff *skb) 5667 5667 { 5668 5668 skb_dst_drop(skb); 5669 - secpath_reset(skb); 5669 + skb_ext_put(skb); 5670 5670 kmem_cache_free(skbuff_head_cache, skb); 5671 5671 } 5672 5672 ··· 5733 5733 skb->encapsulation = 0; 5734 5734 skb_shinfo(skb)->gso_type = 0; 5735 5735 skb->truesize = SKB_TRUESIZE(skb_end_offset(skb)); 5736 - secpath_reset(skb); 5736 + skb_ext_reset(skb); 5737 5737 5738 5738 napi->skb = skb; 5739 5739 }

+2 -2

net/core/dst.c

··· 172 172 int newrefcnt; 173 173 174 174 newrefcnt = atomic_dec_return(&dst->__refcnt); 175 - if (unlikely(newrefcnt < 0)) 175 + if (WARN_ONCE(newrefcnt < 0, "dst_release underflow")) 176 176 net_warn_ratelimited("%s: dst:%p refcnt:%d\n", 177 177 __func__, dst, newrefcnt); 178 178 if (!newrefcnt) ··· 187 187 int newrefcnt; 188 188 189 189 newrefcnt = atomic_dec_return(&dst->__refcnt); 190 - if (unlikely(newrefcnt < 0)) 190 + if (WARN_ONCE(newrefcnt < 0, "dst_release_immediate underflow")) 191 191 net_warn_ratelimited("%s: dst:%p refcnt:%d\n", 192 192 __func__, dst, newrefcnt); 193 193 if (!newrefcnt)

+1 -1

net/core/skbuff.c

··· 5119 5119 skb->skb_iif = 0; 5120 5120 skb->ignore_df = 0; 5121 5121 skb_dst_drop(skb); 5122 - secpath_reset(skb); 5122 + skb_ext_reset(skb); 5123 5123 nf_reset(skb); 5124 5124 nf_reset_trace(skb); 5125 5125

+3 -2

net/dccp/ipv6.c

··· 230 230 opt = ireq->ipv6_opt; 231 231 if (!opt) 232 232 opt = rcu_dereference(np->opt); 233 - err = ip6_xmit(sk, skb, &fl6, sk->sk_mark, opt, np->tclass); 233 + err = ip6_xmit(sk, skb, &fl6, sk->sk_mark, opt, np->tclass, 234 + sk->sk_priority); 234 235 rcu_read_unlock(); 235 236 err = net_xmit_eval(err); 236 237 } ··· 285 284 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL); 286 285 if (!IS_ERR(dst)) { 287 286 skb_dst_set(skb, dst); 288 - ip6_xmit(ctl_sk, skb, &fl6, 0, NULL, 0); 287 + ip6_xmit(ctl_sk, skb, &fl6, 0, NULL, 0, 0); 289 288 DCCP_INC_STATS(DCCP_MIB_OUTSEGS); 290 289 DCCP_INC_STATS(DCCP_MIB_OUTRSTS); 291 290 return;

+3

net/ieee802154/socket.c

··· 1008 1008 1009 1009 switch (sock->type) { 1010 1010 case SOCK_RAW: 1011 + rc = -EPERM; 1012 + if (!capable(CAP_NET_RAW)) 1013 + goto out; 1011 1014 proto = &ieee802154_raw_prot; 1012 1015 ops = &ieee802154_raw_ops; 1013 1016 break;

+1 -1

net/ife/Kconfig

··· 5 5 6 6 menuconfig NET_IFE 7 7 depends on NET 8 - tristate "Inter-FE based on IETF ForCES InterFE LFB" 8 + tristate "Inter-FE based on IETF ForCES InterFE LFB" 9 9 default n 10 10 help 11 11 Say Y here to add support of IFE encapsulation protocol

+2 -2

net/ipv4/Kconfig

··· 492 492 wired networks and throughput over wireless links. 493 493 494 494 config TCP_CONG_HTCP 495 - tristate "H-TCP" 496 - default m 495 + tristate "H-TCP" 496 + default m 497 497 ---help--- 498 498 H-TCP is a send-side only modifications of the TCP Reno 499 499 protocol stack that optimizes the performance of TCP

+2 -2

net/ipv4/inet_connection_sock.c

··· 560 560 rt = ip_route_output_flow(net, fl4, sk); 561 561 if (IS_ERR(rt)) 562 562 goto no_route; 563 - if (opt && opt->opt.is_strictroute && rt->rt_gw_family) 563 + if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway) 564 564 goto route_err; 565 565 rcu_read_unlock(); 566 566 return &rt->dst; ··· 598 598 rt = ip_route_output_flow(net, fl4, sk); 599 599 if (IS_ERR(rt)) 600 600 goto no_route; 601 - if (opt && opt->opt.is_strictroute && rt->rt_gw_family) 601 + if (opt && opt->opt.is_strictroute && rt->rt_uses_gateway) 602 602 goto route_err; 603 603 return &rt->dst; 604 604

+1 -1

net/ipv4/ip_forward.c

··· 123 123 124 124 rt = skb_rtable(skb); 125 125 126 - if (opt->is_strictroute && rt->rt_gw_family) 126 + if (opt->is_strictroute && rt->rt_uses_gateway) 127 127 goto sr_failed; 128 128 129 129 IPCB(skb)->flags |= IPSKB_FORWARDED;

+1 -2

net/ipv4/ip_output.c

··· 499 499 skb_dst_set_noref(skb, &rt->dst); 500 500 501 501 packet_routed: 502 - if (inet_opt && inet_opt->opt.is_strictroute && rt->rt_gw_family) 502 + if (inet_opt && inet_opt->opt.is_strictroute && rt->rt_uses_gateway) 503 503 goto no_route; 504 504 505 505 /* OK, we know where to send it, allocate and build IP header. */ ··· 1694 1694 1695 1695 inet_sk(sk)->tos = arg->tos; 1696 1696 1697 - sk->sk_priority = skb->priority; 1698 1697 sk->sk_protocol = ip_hdr(skb)->protocol; 1699 1698 sk->sk_bound_dev_if = arg->bound_dev_if; 1700 1699 sk->sk_sndbuf = sysctl_wmem_default;

+20 -14

net/ipv4/route.c

··· 635 635 636 636 if (fnhe->fnhe_gw) { 637 637 rt->rt_flags |= RTCF_REDIRECTED; 638 + rt->rt_uses_gateway = 1; 638 639 rt->rt_gw_family = AF_INET; 639 640 rt->rt_gw4 = fnhe->fnhe_gw; 640 641 } ··· 1314 1313 mtu = READ_ONCE(dst->dev->mtu); 1315 1314 1316 1315 if (unlikely(ip_mtu_locked(dst))) { 1317 - if (rt->rt_gw_family && mtu > 576) 1316 + if (rt->rt_uses_gateway && mtu > 576) 1318 1317 mtu = 576; 1319 1318 } 1320 1319 ··· 1570 1569 struct fib_nh_common *nhc = FIB_RES_NHC(*res); 1571 1570 1572 1571 if (nhc->nhc_gw_family && nhc->nhc_scope == RT_SCOPE_LINK) { 1572 + rt->rt_uses_gateway = 1; 1573 1573 rt->rt_gw_family = nhc->nhc_gw_family; 1574 1574 /* only INET and INET6 are supported */ 1575 1575 if (likely(nhc->nhc_gw_family == AF_INET)) ··· 1636 1634 rt->rt_iif = 0; 1637 1635 rt->rt_pmtu = 0; 1638 1636 rt->rt_mtu_locked = 0; 1637 + rt->rt_uses_gateway = 0; 1639 1638 rt->rt_gw_family = 0; 1640 1639 rt->rt_gw4 = 0; 1641 1640 INIT_LIST_HEAD(&rt->rt_uncached); ··· 2697 2694 rt->rt_genid = rt_genid_ipv4(net); 2698 2695 rt->rt_flags = ort->rt_flags; 2699 2696 rt->rt_type = ort->rt_type; 2697 + rt->rt_uses_gateway = ort->rt_uses_gateway; 2700 2698 rt->rt_gw_family = ort->rt_gw_family; 2701 2699 if (rt->rt_gw_family == AF_INET) 2702 2700 rt->rt_gw4 = ort->rt_gw4; ··· 2782 2778 if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr)) 2783 2779 goto nla_put_failure; 2784 2780 } 2785 - if (rt->rt_gw_family == AF_INET && 2786 - nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gw4)) { 2787 - goto nla_put_failure; 2788 - } else if (rt->rt_gw_family == AF_INET6) { 2789 - int alen = sizeof(struct in6_addr); 2790 - struct nlattr *nla; 2791 - struct rtvia *via; 2792 - 2793 - nla = nla_reserve(skb, RTA_VIA, alen + 2); 2794 - if (!nla) 2781 + if (rt->rt_uses_gateway) { 2782 + if (rt->rt_gw_family == AF_INET && 2783 + nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gw4)) { 2795 2784 goto nla_put_failure; 2785 + } else if (rt->rt_gw_family == AF_INET6) { 2786 + int alen = sizeof(struct in6_addr); 2787 + struct nlattr *nla; 2788 + struct rtvia *via; 2796 2789 2797 - via = nla_data(nla); 2798 - via->rtvia_family = AF_INET6; 2799 - memcpy(via->rtvia_addr, &rt->rt_gw6, alen); 2790 + nla = nla_reserve(skb, RTA_VIA, alen + 2); 2791 + if (!nla) 2792 + goto nla_put_failure; 2793 + 2794 + via = nla_data(nla); 2795 + via->rtvia_family = AF_INET6; 2796 + memcpy(via->rtvia_addr, &rt->rt_gw6, alen); 2797 + } 2800 2798 } 2801 2799 2802 2800 expires = rt->dst.expires;

+4 -4

net/ipv4/tcp_bbr.c

··· 388 388 * which allows 2 outstanding 2-packet sequences, to try to keep pipe 389 389 * full even with ACK-every-other-packet delayed ACKs. 390 390 */ 391 - static u32 bbr_quantization_budget(struct sock *sk, u32 cwnd, int gain) 391 + static u32 bbr_quantization_budget(struct sock *sk, u32 cwnd) 392 392 { 393 393 struct bbr *bbr = inet_csk_ca(sk); 394 394 ··· 399 399 cwnd = (cwnd + 1) & ~1U; 400 400 401 401 /* Ensure gain cycling gets inflight above BDP even for small BDPs. */ 402 - if (bbr->mode == BBR_PROBE_BW && gain > BBR_UNIT) 402 + if (bbr->mode == BBR_PROBE_BW && bbr->cycle_idx == 0) 403 403 cwnd += 2; 404 404 405 405 return cwnd; ··· 411 411 u32 inflight; 412 412 413 413 inflight = bbr_bdp(sk, bw, gain); 414 - inflight = bbr_quantization_budget(sk, inflight, gain); 414 + inflight = bbr_quantization_budget(sk, inflight); 415 415 416 416 return inflight; 417 417 } ··· 531 531 * due to aggregation (of data and/or ACKs) visible in the ACK stream. 532 532 */ 533 533 target_cwnd += bbr_ack_aggregation_cwnd(sk); 534 - target_cwnd = bbr_quantization_budget(sk, target_cwnd, gain); 534 + target_cwnd = bbr_quantization_budget(sk, target_cwnd); 535 535 536 536 /* If we're below target cwnd, slow start cwnd toward target cwnd. */ 537 537 if (bbr_full_bw_reached(sk)) /* only cut cwnd if we filled the pipe */

+4

net/ipv4/tcp_ipv4.c

··· 771 771 if (sk) { 772 772 ctl_sk->sk_mark = (sk->sk_state == TCP_TIME_WAIT) ? 773 773 inet_twsk(sk)->tw_mark : sk->sk_mark; 774 + ctl_sk->sk_priority = (sk->sk_state == TCP_TIME_WAIT) ? 775 + inet_twsk(sk)->tw_priority : sk->sk_priority; 774 776 transmit_time = tcp_transmit_time(sk); 775 777 } 776 778 ip_send_unicast_reply(ctl_sk, ··· 868 866 ctl_sk = this_cpu_read(*net->ipv4.tcp_sk); 869 867 ctl_sk->sk_mark = (sk->sk_state == TCP_TIME_WAIT) ? 870 868 inet_twsk(sk)->tw_mark : sk->sk_mark; 869 + ctl_sk->sk_priority = (sk->sk_state == TCP_TIME_WAIT) ? 870 + inet_twsk(sk)->tw_priority : sk->sk_priority; 871 871 transmit_time = tcp_transmit_time(sk); 872 872 ip_send_unicast_reply(ctl_sk, 873 873 skb, &TCP_SKB_CB(skb)->header.h4.opt,

+1

net/ipv4/tcp_minisocks.c

··· 266 266 267 267 tw->tw_transparent = inet->transparent; 268 268 tw->tw_mark = sk->sk_mark; 269 + tw->tw_priority = sk->sk_priority; 269 270 tw->tw_rcv_wscale = tp->rx_opt.rcv_wscale; 270 271 tcptw->tw_rcv_nxt = tp->rcv_nxt; 271 272 tcptw->tw_snd_nxt = tp->snd_nxt;

+3 -2

net/ipv4/tcp_timer.c

··· 210 210 struct inet_connection_sock *icsk = inet_csk(sk); 211 211 struct tcp_sock *tp = tcp_sk(sk); 212 212 struct net *net = sock_net(sk); 213 - bool expired, do_reset; 213 + bool expired = false, do_reset; 214 214 int retry_until; 215 215 216 216 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) { ··· 242 242 if (tcp_out_of_resources(sk, do_reset)) 243 243 return 1; 244 244 } 245 + } 246 + if (!expired) 245 247 expired = retransmits_timed_out(sk, retry_until, 246 248 icsk->icsk_user_timeout); 247 - } 248 249 tcp_fastopen_active_detect_blackhole(sk, expired); 249 250 250 251 if (BPF_SOCK_OPS_TEST_FLAG(tp, BPF_SOCK_OPS_RTO_CB_FLAG))

+1

net/ipv4/xfrm4_policy.c

··· 85 85 xdst->u.rt.rt_flags = rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST | 86 86 RTCF_LOCAL); 87 87 xdst->u.rt.rt_type = rt->rt_type; 88 + xdst->u.rt.rt_uses_gateway = rt->rt_uses_gateway; 88 89 xdst->u.rt.rt_gw_family = rt->rt_gw_family; 89 90 if (rt->rt_gw_family == AF_INET) 90 91 xdst->u.rt.rt_gw4 = rt->rt_gw4;

+2 -1

net/ipv6/fib6_rules.c

··· 287 287 return false; 288 288 289 289 suppress_route: 290 - ip6_rt_put(rt); 290 + if (!(arg->flags & FIB_LOOKUP_NOREF)) 291 + ip6_rt_put(rt); 291 292 return true; 292 293 } 293 294

+1 -1

net/ipv6/inet6_connection_sock.c

··· 133 133 fl6.daddr = sk->sk_v6_daddr; 134 134 135 135 res = ip6_xmit(sk, skb, &fl6, sk->sk_mark, rcu_dereference(np->opt), 136 - np->tclass); 136 + np->tclass, sk->sk_priority); 137 137 rcu_read_unlock(); 138 138 return res; 139 139 }

+1 -1

net/ipv6/ip6_fib.c

··· 318 318 if (rt->dst.error == -EAGAIN) { 319 319 ip6_rt_put_flags(rt, flags); 320 320 rt = net->ipv6.ip6_null_entry; 321 - if (!(flags | RT6_LOOKUP_F_DST_NOREF)) 321 + if (!(flags & RT6_LOOKUP_F_DST_NOREF)) 322 322 dst_hold(&rt->dst); 323 323 } 324 324

+2 -2

net/ipv6/ip6_output.c

··· 193 193 * which are using proper atomic operations or spinlocks. 194 194 */ 195 195 int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6, 196 - __u32 mark, struct ipv6_txoptions *opt, int tclass) 196 + __u32 mark, struct ipv6_txoptions *opt, int tclass, u32 priority) 197 197 { 198 198 struct net *net = sock_net(sk); 199 199 const struct ipv6_pinfo *np = inet6_sk(sk); ··· 258 258 hdr->daddr = *first_hop; 259 259 260 260 skb->protocol = htons(ETH_P_IPV6); 261 - skb->priority = sk->sk_priority; 261 + skb->priority = priority; 262 262 skb->mark = mark; 263 263 264 264 mtu = dst_mtu(dst);

+8 -8

net/ipv6/netfilter/Kconfig

··· 170 170 To compile it as a module, choose M here. If unsure, say N. 171 171 172 172 config IP6_NF_MATCH_SRH 173 - tristate '"srh" Segment Routing header match support' 174 - depends on NETFILTER_ADVANCED 175 - help 176 - srh matching allows you to match packets based on the segment 173 + tristate '"srh" Segment Routing header match support' 174 + depends on NETFILTER_ADVANCED 175 + help 176 + srh matching allows you to match packets based on the segment 177 177 routing header of the packet. 178 178 179 - To compile it as a module, choose M here. If unsure, say N. 179 + To compile it as a module, choose M here. If unsure, say N. 180 180 181 181 # The targets 182 182 config IP6_NF_TARGET_HL ··· 249 249 depends on SECURITY 250 250 depends on NETFILTER_ADVANCED 251 251 help 252 - This option adds a `security' table to iptables, for use 253 - with Mandatory Access Control (MAC) policy. 252 + This option adds a `security' table to iptables, for use 253 + with Mandatory Access Control (MAC) policy. 254 254 255 - If unsure, say N. 255 + If unsure, say N. 256 256 257 257 config IP6_NF_NAT 258 258 tristate "ip6tables NAT support"

+15 -9

net/ipv6/tcp_ipv6.c

··· 512 512 opt = ireq->ipv6_opt; 513 513 if (!opt) 514 514 opt = rcu_dereference(np->opt); 515 - err = ip6_xmit(sk, skb, fl6, sk->sk_mark, opt, np->tclass); 515 + err = ip6_xmit(sk, skb, fl6, sk->sk_mark, opt, np->tclass, 516 + sk->sk_priority); 516 517 rcu_read_unlock(); 517 518 err = net_xmit_eval(err); 518 519 } ··· 804 803 static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 seq, 805 804 u32 ack, u32 win, u32 tsval, u32 tsecr, 806 805 int oif, struct tcp_md5sig_key *key, int rst, 807 - u8 tclass, __be32 label) 806 + u8 tclass, __be32 label, u32 priority) 808 807 { 809 808 const struct tcphdr *th = tcp_hdr(skb); 810 809 struct tcphdr *t1; ··· 908 907 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL); 909 908 if (!IS_ERR(dst)) { 910 909 skb_dst_set(buff, dst); 911 - ip6_xmit(ctl_sk, buff, &fl6, fl6.flowi6_mark, NULL, tclass); 910 + ip6_xmit(ctl_sk, buff, &fl6, fl6.flowi6_mark, NULL, tclass, 911 + priority); 912 912 TCP_INC_STATS(net, TCP_MIB_OUTSEGS); 913 913 if (rst) 914 914 TCP_INC_STATS(net, TCP_MIB_OUTRSTS); ··· 932 930 struct sock *sk1 = NULL; 933 931 #endif 934 932 __be32 label = 0; 933 + u32 priority = 0; 935 934 struct net *net; 936 935 int oif = 0; 937 936 ··· 993 990 trace_tcp_send_reset(sk, skb); 994 991 if (np->repflow) 995 992 label = ip6_flowlabel(ipv6h); 993 + priority = sk->sk_priority; 996 994 } 997 - if (sk->sk_state == TCP_TIME_WAIT) 995 + if (sk->sk_state == TCP_TIME_WAIT) { 998 996 label = cpu_to_be32(inet_twsk(sk)->tw_flowlabel); 997 + priority = inet_twsk(sk)->tw_priority; 998 + } 999 999 } else { 1000 1000 if (net->ipv6.sysctl.flowlabel_reflect & FLOWLABEL_REFLECT_TCP_RESET) 1001 1001 label = ip6_flowlabel(ipv6h); 1002 1002 } 1003 1003 1004 1004 tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 1005 - label); 1005 + label, priority); 1006 1006 1007 1007 #ifdef CONFIG_TCP_MD5SIG 1008 1008 out: ··· 1016 1010 static void tcp_v6_send_ack(const struct sock *sk, struct sk_buff *skb, u32 seq, 1017 1011 u32 ack, u32 win, u32 tsval, u32 tsecr, int oif, 1018 1012 struct tcp_md5sig_key *key, u8 tclass, 1019 - __be32 label) 1013 + __be32 label, u32 priority) 1020 1014 { 1021 1015 tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0, 1022 - tclass, label); 1016 + tclass, label, priority); 1023 1017 } 1024 1018 1025 1019 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb) ··· 1031 1025 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, 1032 1026 tcp_time_stamp_raw() + tcptw->tw_ts_offset, 1033 1027 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw), 1034 - tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel)); 1028 + tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel), tw->tw_priority); 1035 1029 1036 1030 inet_twsk_put(tw); 1037 1031 } ··· 1054 1048 tcp_time_stamp_raw() + tcp_rsk(req)->ts_off, 1055 1049 req->ts_recent, sk->sk_bound_dev_if, 1056 1050 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->saddr), 1057 - 0, 0); 1051 + 0, 0, sk->sk_priority); 1058 1052 } 1059 1053 1060 1054

+5 -1

net/kcm/kcmsock.c

··· 378 378 { 379 379 struct kcm_psock *psock = container_of(strp, struct kcm_psock, strp); 380 380 struct bpf_prog *prog = psock->bpf_prog; 381 + int res; 381 382 382 - return BPF_PROG_RUN(prog, skb); 383 + preempt_disable(); 384 + res = BPF_PROG_RUN(prog, skb); 385 + preempt_enable(); 386 + return res; 383 387 } 384 388 385 389 static int kcm_read_sock_done(struct strparser *strp, int err)

+1 -6

net/ncsi/internal.h

··· 264 264 ncsi_dev_state_config_ev, 265 265 ncsi_dev_state_config_sma, 266 266 ncsi_dev_state_config_ebf, 267 - #if IS_ENABLED(CONFIG_IPV6) 268 - ncsi_dev_state_config_egmf, 269 - #endif 267 + ncsi_dev_state_config_dgmf, 270 268 ncsi_dev_state_config_ecnt, 271 269 ncsi_dev_state_config_ec, 272 270 ncsi_dev_state_config_ae, ··· 293 295 #define NCSI_DEV_RESET 8 /* Reset state of NC */ 294 296 unsigned int gma_flag; /* OEM GMA flag */ 295 297 spinlock_t lock; /* Protect the NCSI device */ 296 - #if IS_ENABLED(CONFIG_IPV6) 297 - unsigned int inet6_addr_num; /* Number of IPv6 addresses */ 298 - #endif 299 298 unsigned int package_probe_id;/* Current ID during probe */ 300 299 unsigned int package_num; /* Number of packages */ 301 300 struct list_head packages; /* List of packages */

+14 -90

net/ncsi/ncsi-manage.c

··· 14 14 #include <net/sock.h> 15 15 #include <net/addrconf.h> 16 16 #include <net/ipv6.h> 17 - #include <net/if_inet6.h> 18 17 #include <net/genetlink.h> 19 18 20 19 #include "internal.h" ··· 977 978 case ncsi_dev_state_config_ev: 978 979 case ncsi_dev_state_config_sma: 979 980 case ncsi_dev_state_config_ebf: 980 - #if IS_ENABLED(CONFIG_IPV6) 981 - case ncsi_dev_state_config_egmf: 982 - #endif 981 + case ncsi_dev_state_config_dgmf: 983 982 case ncsi_dev_state_config_ecnt: 984 983 case ncsi_dev_state_config_ec: 985 984 case ncsi_dev_state_config_ae: ··· 1030 1033 } else if (nd->state == ncsi_dev_state_config_ebf) { 1031 1034 nca.type = NCSI_PKT_CMD_EBF; 1032 1035 nca.dwords[0] = nc->caps[NCSI_CAP_BC].cap; 1036 + /* if multicast global filtering is supported then 1037 + * disable it so that all multicast packet will be 1038 + * forwarded to management controller 1039 + */ 1040 + if (nc->caps[NCSI_CAP_GENERIC].cap & 1041 + NCSI_CAP_GENERIC_MC) 1042 + nd->state = ncsi_dev_state_config_dgmf; 1043 + else if (ncsi_channel_is_tx(ndp, nc)) 1044 + nd->state = ncsi_dev_state_config_ecnt; 1045 + else 1046 + nd->state = ncsi_dev_state_config_ec; 1047 + } else if (nd->state == ncsi_dev_state_config_dgmf) { 1048 + nca.type = NCSI_PKT_CMD_DGMF; 1033 1049 if (ncsi_channel_is_tx(ndp, nc)) 1034 1050 nd->state = ncsi_dev_state_config_ecnt; 1035 1051 else 1036 1052 nd->state = ncsi_dev_state_config_ec; 1037 - #if IS_ENABLED(CONFIG_IPV6) 1038 - if (ndp->inet6_addr_num > 0 && 1039 - (nc->caps[NCSI_CAP_GENERIC].cap & 1040 - NCSI_CAP_GENERIC_MC)) 1041 - nd->state = ncsi_dev_state_config_egmf; 1042 - } else if (nd->state == ncsi_dev_state_config_egmf) { 1043 - nca.type = NCSI_PKT_CMD_EGMF; 1044 - nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap; 1045 - if (ncsi_channel_is_tx(ndp, nc)) 1046 - nd->state = ncsi_dev_state_config_ecnt; 1047 - else 1048 - nd->state = ncsi_dev_state_config_ec; 1049 - #endif /* CONFIG_IPV6 */ 1050 1053 } else if (nd->state == ncsi_dev_state_config_ecnt) { 1051 1054 if (np->preferred_channel && 1052 1055 nc != np->preferred_channel) ··· 1480 1483 return -ENODEV; 1481 1484 } 1482 1485 1483 - #if IS_ENABLED(CONFIG_IPV6) 1484 - static int ncsi_inet6addr_event(struct notifier_block *this, 1485 - unsigned long event, void *data) 1486 - { 1487 - struct inet6_ifaddr *ifa = data; 1488 - struct net_device *dev = ifa->idev->dev; 1489 - struct ncsi_dev *nd = ncsi_find_dev(dev); 1490 - struct ncsi_dev_priv *ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL; 1491 - struct ncsi_package *np; 1492 - struct ncsi_channel *nc; 1493 - struct ncsi_cmd_arg nca; 1494 - bool action; 1495 - int ret; 1496 - 1497 - if (!ndp || (ipv6_addr_type(&ifa->addr) & 1498 - (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK))) 1499 - return NOTIFY_OK; 1500 - 1501 - switch (event) { 1502 - case NETDEV_UP: 1503 - action = (++ndp->inet6_addr_num) == 1; 1504 - nca.type = NCSI_PKT_CMD_EGMF; 1505 - break; 1506 - case NETDEV_DOWN: 1507 - action = (--ndp->inet6_addr_num == 0); 1508 - nca.type = NCSI_PKT_CMD_DGMF; 1509 - break; 1510 - default: 1511 - return NOTIFY_OK; 1512 - } 1513 - 1514 - /* We might not have active channel or packages. The IPv6 1515 - * required multicast will be enabled when active channel 1516 - * or packages are chosen. 1517 - */ 1518 - np = ndp->active_package; 1519 - nc = ndp->active_channel; 1520 - if (!action || !np || !nc) 1521 - return NOTIFY_OK; 1522 - 1523 - /* We needn't enable or disable it if the function isn't supported */ 1524 - if (!(nc->caps[NCSI_CAP_GENERIC].cap & NCSI_CAP_GENERIC_MC)) 1525 - return NOTIFY_OK; 1526 - 1527 - nca.ndp = ndp; 1528 - nca.req_flags = 0; 1529 - nca.package = np->id; 1530 - nca.channel = nc->id; 1531 - nca.dwords[0] = nc->caps[NCSI_CAP_MC].cap; 1532 - ret = ncsi_xmit_cmd(&nca); 1533 - if (ret) { 1534 - netdev_warn(dev, "Fail to %s global multicast filter (%d)\n", 1535 - (event == NETDEV_UP) ? "enable" : "disable", ret); 1536 - return NOTIFY_DONE; 1537 - } 1538 - 1539 - return NOTIFY_OK; 1540 - } 1541 - 1542 - static struct notifier_block ncsi_inet6addr_notifier = { 1543 - .notifier_call = ncsi_inet6addr_event, 1544 - }; 1545 - #endif /* CONFIG_IPV6 */ 1546 - 1547 1486 static int ncsi_kick_channels(struct ncsi_dev_priv *ndp) 1548 1487 { 1549 1488 struct ncsi_dev *nd = &ndp->ndev; ··· 1658 1725 } 1659 1726 1660 1727 spin_lock_irqsave(&ncsi_dev_lock, flags); 1661 - #if IS_ENABLED(CONFIG_IPV6) 1662 - ndp->inet6_addr_num = 0; 1663 - if (list_empty(&ncsi_dev_list)) 1664 - register_inet6addr_notifier(&ncsi_inet6addr_notifier); 1665 - #endif 1666 1728 list_add_tail_rcu(&ndp->node, &ncsi_dev_list); 1667 1729 spin_unlock_irqrestore(&ncsi_dev_lock, flags); 1668 1730 ··· 1824 1896 1825 1897 spin_lock_irqsave(&ncsi_dev_lock, flags); 1826 1898 list_del_rcu(&ndp->node); 1827 - #if IS_ENABLED(CONFIG_IPV6) 1828 - if (list_empty(&ncsi_dev_list)) 1829 - unregister_inet6addr_notifier(&ncsi_inet6addr_notifier); 1830 - #endif 1831 1899 spin_unlock_irqrestore(&ncsi_dev_lock, flags); 1832 1900 1833 1901 ncsi_unregister_netlink(nd->dev);

+1 -1

net/netfilter/Kconfig

··· 697 697 tristate "Netfilter flow table mixed IPv4/IPv6 module" 698 698 depends on NF_FLOW_TABLE 699 699 help 700 - This option adds the flow table mixed IPv4/IPv6 support. 700 + This option adds the flow table mixed IPv4/IPv6 support. 701 701 702 702 To compile it as a module, choose M here. 703 703

+3 -3

net/netfilter/ipvs/Kconfig

··· 135 135 module, choose M here. If unsure, say N. 136 136 137 137 config IP_VS_LC 138 - tristate "least-connection scheduling" 138 + tristate "least-connection scheduling" 139 139 ---help--- 140 140 The least-connection scheduling algorithm directs network 141 141 connections to the server with the least number of active ··· 145 145 module, choose M here. If unsure, say N. 146 146 147 147 config IP_VS_WLC 148 - tristate "weighted least-connection scheduling" 148 + tristate "weighted least-connection scheduling" 149 149 ---help--- 150 150 The weighted least-connection scheduling algorithm directs network 151 151 connections to the server with the least active connections ··· 333 333 334 334 config IP_VS_PE_SIP 335 335 tristate "SIP persistence engine" 336 - depends on IP_VS_PROTO_UDP 336 + depends on IP_VS_PROTO_UDP 337 337 depends on NF_CONNTRACK_SIP 338 338 ---help--- 339 339 Allow persistence based on the SIP Call-ID

+22 -3

net/netfilter/nf_tables_api.c

··· 1715 1715 goto err2; 1716 1716 } 1717 1717 1718 - nft_trans_chain_policy(trans) = -1; 1718 + nft_trans_chain_policy(trans) = NFT_CHAIN_POLICY_UNSET; 1719 1719 if (nft_is_base_chain(chain)) 1720 1720 nft_trans_chain_policy(trans) = policy; 1721 1721 ··· 3562 3562 NFT_SET_OBJECT)) 3563 3563 return -EINVAL; 3564 3564 /* Only one of these operations is supported */ 3565 - if ((flags & (NFT_SET_MAP | NFT_SET_EVAL | NFT_SET_OBJECT)) == 3566 - (NFT_SET_MAP | NFT_SET_EVAL | NFT_SET_OBJECT)) 3565 + if ((flags & (NFT_SET_MAP | NFT_SET_OBJECT)) == 3566 + (NFT_SET_MAP | NFT_SET_OBJECT)) 3567 + return -EOPNOTSUPP; 3568 + if ((flags & (NFT_SET_EVAL | NFT_SET_OBJECT)) == 3569 + (NFT_SET_EVAL | NFT_SET_OBJECT)) 3567 3570 return -EOPNOTSUPP; 3568 3571 } 3569 3572 ··· 5597 5594 return ERR_PTR(-ENOENT); 5598 5595 } 5599 5596 EXPORT_SYMBOL_GPL(nft_flowtable_lookup); 5597 + 5598 + void nf_tables_deactivate_flowtable(const struct nft_ctx *ctx, 5599 + struct nft_flowtable *flowtable, 5600 + enum nft_trans_phase phase) 5601 + { 5602 + switch (phase) { 5603 + case NFT_TRANS_PREPARE: 5604 + case NFT_TRANS_ABORT: 5605 + case NFT_TRANS_RELEASE: 5606 + flowtable->use--; 5607 + /* fall through */ 5608 + default: 5609 + return; 5610 + } 5611 + } 5612 + EXPORT_SYMBOL_GPL(nf_tables_deactivate_flowtable); 5600 5613 5601 5614 static struct nft_flowtable * 5602 5615 nft_flowtable_lookup_byhandle(const struct nft_table *table,

+1 -1

net/netfilter/nf_tables_offload.c

··· 313 313 policy = ppolicy ? *ppolicy : basechain->policy; 314 314 315 315 /* Only default policy to accept is supported for now. */ 316 - if (cmd == FLOW_BLOCK_BIND && policy != -1 && policy != NF_ACCEPT) 316 + if (cmd == FLOW_BLOCK_BIND && policy == NF_DROP) 317 317 return -EOPNOTSUPP; 318 318 319 319 if (dev->netdev_ops->ndo_setup_tc)

+19

net/netfilter/nft_flow_offload.c

··· 177 177 return nf_ct_netns_get(ctx->net, ctx->family); 178 178 } 179 179 180 + static void nft_flow_offload_deactivate(const struct nft_ctx *ctx, 181 + const struct nft_expr *expr, 182 + enum nft_trans_phase phase) 183 + { 184 + struct nft_flow_offload *priv = nft_expr_priv(expr); 185 + 186 + nf_tables_deactivate_flowtable(ctx, priv->flowtable, phase); 187 + } 188 + 189 + static void nft_flow_offload_activate(const struct nft_ctx *ctx, 190 + const struct nft_expr *expr) 191 + { 192 + struct nft_flow_offload *priv = nft_expr_priv(expr); 193 + 194 + priv->flowtable->use++; 195 + } 196 + 180 197 static void nft_flow_offload_destroy(const struct nft_ctx *ctx, 181 198 const struct nft_expr *expr) 182 199 { ··· 222 205 .size = NFT_EXPR_SIZE(sizeof(struct nft_flow_offload)), 223 206 .eval = nft_flow_offload_eval, 224 207 .init = nft_flow_offload_init, 208 + .activate = nft_flow_offload_activate, 209 + .deactivate = nft_flow_offload_deactivate, 225 210 .destroy = nft_flow_offload_destroy, 226 211 .validate = nft_flow_offload_validate, 227 212 .dump = nft_flow_offload_dump,

-3

net/netfilter/nft_lookup.c

··· 73 73 if (IS_ERR(set)) 74 74 return PTR_ERR(set); 75 75 76 - if (set->flags & NFT_SET_EVAL) 77 - return -EOPNOTSUPP; 78 - 79 76 priv->sreg = nft_parse_register(tb[NFTA_LOOKUP_SREG]); 80 77 err = nft_validate_register_load(priv->sreg, set->klen); 81 78 if (err < 0)

+5 -2

net/nfc/llcp_sock.c

··· 1004 1004 sock->type != SOCK_RAW) 1005 1005 return -ESOCKTNOSUPPORT; 1006 1006 1007 - if (sock->type == SOCK_RAW) 1007 + if (sock->type == SOCK_RAW) { 1008 + if (!capable(CAP_NET_RAW)) 1009 + return -EPERM; 1008 1010 sock->ops = &llcp_rawsock_ops; 1009 - else 1011 + } else { 1010 1012 sock->ops = &llcp_sock_ops; 1013 + } 1011 1014 1012 1015 sk = nfc_llcp_sock_alloc(sock, sock->type, GFP_ATOMIC, kern); 1013 1016 if (sk == NULL)

+1 -1

net/openvswitch/datapath.c

··· 2294 2294 [OVS_VPORT_ATTR_STATS] = { .len = sizeof(struct ovs_vport_stats) }, 2295 2295 [OVS_VPORT_ATTR_PORT_NO] = { .type = NLA_U32 }, 2296 2296 [OVS_VPORT_ATTR_TYPE] = { .type = NLA_U32 }, 2297 - [OVS_VPORT_ATTR_UPCALL_PID] = { .type = NLA_U32 }, 2297 + [OVS_VPORT_ATTR_UPCALL_PID] = { .type = NLA_UNSPEC }, 2298 2298 [OVS_VPORT_ATTR_OPTIONS] = { .type = NLA_NESTED }, 2299 2299 [OVS_VPORT_ATTR_IFINDEX] = { .type = NLA_U32 }, 2300 2300 [OVS_VPORT_ATTR_NETNSID] = { .type = NLA_S32 },

+1

net/qrtr/qrtr.c

··· 150 150 list_del(&node->item); 151 151 mutex_unlock(&qrtr_node_lock); 152 152 153 + cancel_work_sync(&node->work); 153 154 skb_queue_purge(&node->rx_queue); 154 155 kfree(node); 155 156 }

+2 -2

net/rds/Kconfig

··· 23 23 This transport does not support RDMA operations. 24 24 25 25 config RDS_DEBUG 26 - bool "RDS debugging messages" 26 + bool "RDS debugging messages" 27 27 depends on RDS 28 - default n 28 + default n

+4 -1

net/rds/bind.c

··· 244 244 */ 245 245 if (rs->rs_transport) { 246 246 trans = rs->rs_transport; 247 - if (trans->laddr_check(sock_net(sock->sk), 247 + if (!trans->laddr_check || 248 + trans->laddr_check(sock_net(sock->sk), 248 249 binding_addr, scope_id) != 0) { 249 250 ret = -ENOPROTOOPT; 250 251 goto out; ··· 264 263 265 264 sock_set_flag(sk, SOCK_RCU_FREE); 266 265 ret = rds_add_bound(rs, binding_addr, &port, scope_id); 266 + if (ret) 267 + rs->rs_transport = NULL; 267 268 268 269 out: 269 270 release_sock(sk);

+72 -73

net/sched/Kconfig

··· 324 324 tristate "Common Applications Kept Enhanced (CAKE)" 325 325 help 326 326 Say Y here if you want to use the Common Applications Kept Enhanced 327 - (CAKE) queue management algorithm. 327 + (CAKE) queue management algorithm. 328 328 329 329 To compile this driver as a module, choose M here: the module 330 330 will be called sch_cake. ··· 730 730 731 731 config NET_ACT_POLICE 732 732 tristate "Traffic Policing" 733 - depends on NET_CLS_ACT 734 - ---help--- 733 + depends on NET_CLS_ACT 734 + ---help--- 735 735 Say Y here if you want to do traffic policing, i.e. strict 736 736 bandwidth limiting. This action replaces the existing policing 737 737 module. ··· 740 740 module will be called act_police. 741 741 742 742 config NET_ACT_GACT 743 - tristate "Generic actions" 744 - depends on NET_CLS_ACT 745 - ---help--- 743 + tristate "Generic actions" 744 + depends on NET_CLS_ACT 745 + ---help--- 746 746 Say Y here to take generic actions such as dropping and 747 747 accepting packets. 748 748 ··· 750 750 module will be called act_gact. 751 751 752 752 config GACT_PROB 753 - bool "Probability support" 754 - depends on NET_ACT_GACT 755 - ---help--- 753 + bool "Probability support" 754 + depends on NET_ACT_GACT 755 + ---help--- 756 756 Say Y here to use the generic action randomly or deterministically. 757 757 758 758 config NET_ACT_MIRRED 759 - tristate "Redirecting and Mirroring" 760 - depends on NET_CLS_ACT 761 - ---help--- 759 + tristate "Redirecting and Mirroring" 760 + depends on NET_CLS_ACT 761 + ---help--- 762 762 Say Y here to allow packets to be mirrored or redirected to 763 763 other devices. 764 764 ··· 766 766 module will be called act_mirred. 767 767 768 768 config NET_ACT_SAMPLE 769 - tristate "Traffic Sampling" 770 - depends on NET_CLS_ACT 771 - select PSAMPLE 772 - ---help--- 769 + tristate "Traffic Sampling" 770 + depends on NET_CLS_ACT 771 + select PSAMPLE 772 + ---help--- 773 773 Say Y here to allow packet sampling tc action. The packet sample 774 774 action consists of statistically choosing packets and sampling 775 775 them using the psample module. ··· 778 778 module will be called act_sample. 779 779 780 780 config NET_ACT_IPT 781 - tristate "IPtables targets" 782 - depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES 783 - ---help--- 781 + tristate "IPtables targets" 782 + depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES 783 + ---help--- 784 784 Say Y here to be able to invoke iptables targets after successful 785 785 classification. 786 786 ··· 788 788 module will be called act_ipt. 789 789 790 790 config NET_ACT_NAT 791 - tristate "Stateless NAT" 792 - depends on NET_CLS_ACT 793 - ---help--- 791 + tristate "Stateless NAT" 792 + depends on NET_CLS_ACT 793 + ---help--- 794 794 Say Y here to do stateless NAT on IPv4 packets. You should use 795 795 netfilter for NAT unless you know what you are doing. 796 796 ··· 798 798 module will be called act_nat. 799 799 800 800 config NET_ACT_PEDIT 801 - tristate "Packet Editing" 802 - depends on NET_CLS_ACT 803 - ---help--- 801 + tristate "Packet Editing" 802 + depends on NET_CLS_ACT 803 + ---help--- 804 804 Say Y here if you want to mangle the content of packets. 805 805 806 806 To compile this code as a module, choose M here: the 807 807 module will be called act_pedit. 808 808 809 809 config NET_ACT_SIMP 810 - tristate "Simple Example (Debug)" 811 - depends on NET_CLS_ACT 812 - ---help--- 810 + tristate "Simple Example (Debug)" 811 + depends on NET_CLS_ACT 812 + ---help--- 813 813 Say Y here to add a simple action for demonstration purposes. 814 814 It is meant as an example and for debugging purposes. It will 815 815 print a configured policy string followed by the packet count ··· 821 821 module will be called act_simple. 822 822 823 823 config NET_ACT_SKBEDIT 824 - tristate "SKB Editing" 825 - depends on NET_CLS_ACT 826 - ---help--- 824 + tristate "SKB Editing" 825 + depends on NET_CLS_ACT 826 + ---help--- 827 827 Say Y here to change skb priority or queue_mapping settings. 828 828 829 829 If unsure, say N. ··· 832 832 module will be called act_skbedit. 833 833 834 834 config NET_ACT_CSUM 835 - tristate "Checksum Updating" 836 - depends on NET_CLS_ACT && INET 837 - select LIBCRC32C 838 - ---help--- 835 + tristate "Checksum Updating" 836 + depends on NET_CLS_ACT && INET 837 + select LIBCRC32C 838 + ---help--- 839 839 Say Y here to update some common checksum after some direct 840 840 packet alterations. 841 841 ··· 854 854 module will be called act_mpls. 855 855 856 856 config NET_ACT_VLAN 857 - tristate "Vlan manipulation" 858 - depends on NET_CLS_ACT 859 - ---help--- 857 + tristate "Vlan manipulation" 858 + depends on NET_CLS_ACT 859 + ---help--- 860 860 Say Y here to push or pop vlan headers. 861 861 862 862 If unsure, say N. ··· 865 865 module will be called act_vlan. 866 866 867 867 config NET_ACT_BPF 868 - tristate "BPF based action" 869 - depends on NET_CLS_ACT 870 - ---help--- 868 + tristate "BPF based action" 869 + depends on NET_CLS_ACT 870 + ---help--- 871 871 Say Y here to execute BPF code on packets. The BPF code will decide 872 872 if the packet should be dropped or not. 873 873 ··· 877 877 module will be called act_bpf. 878 878 879 879 config NET_ACT_CONNMARK 880 - tristate "Netfilter Connection Mark Retriever" 881 - depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES 882 - depends on NF_CONNTRACK && NF_CONNTRACK_MARK 883 - ---help--- 880 + tristate "Netfilter Connection Mark Retriever" 881 + depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES 882 + depends on NF_CONNTRACK && NF_CONNTRACK_MARK 883 + ---help--- 884 884 Say Y here to allow retrieving of conn mark 885 885 886 886 If unsure, say N. ··· 889 889 module will be called act_connmark. 890 890 891 891 config NET_ACT_CTINFO 892 - tristate "Netfilter Connection Mark Actions" 893 - depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES 894 - depends on NF_CONNTRACK && NF_CONNTRACK_MARK 895 - help 892 + tristate "Netfilter Connection Mark Actions" 893 + depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES 894 + depends on NF_CONNTRACK && NF_CONNTRACK_MARK 895 + help 896 896 Say Y here to allow transfer of a connmark stored information. 897 897 Current actions transfer connmark stored DSCP into 898 898 ipv4/v6 diffserv and/or to transfer connmark to packet ··· 906 906 module will be called act_ctinfo. 907 907 908 908 config NET_ACT_SKBMOD 909 - tristate "skb data modification action" 910 - depends on NET_CLS_ACT 911 - ---help--- 912 - Say Y here to allow modification of skb data 909 + tristate "skb data modification action" 910 + depends on NET_CLS_ACT 911 + ---help--- 912 + Say Y here to allow modification of skb data 913 913 914 - If unsure, say N. 914 + If unsure, say N. 915 915 916 - To compile this code as a module, choose M here: the 917 - module will be called act_skbmod. 916 + To compile this code as a module, choose M here: the 917 + module will be called act_skbmod. 918 918 919 919 config NET_ACT_IFE 920 - tristate "Inter-FE action based on IETF ForCES InterFE LFB" 921 - depends on NET_CLS_ACT 922 - select NET_IFE 923 - ---help--- 920 + tristate "Inter-FE action based on IETF ForCES InterFE LFB" 921 + depends on NET_CLS_ACT 922 + select NET_IFE 923 + ---help--- 924 924 Say Y here to allow for sourcing and terminating metadata 925 925 For details refer to netdev01 paper: 926 926 "Distributing Linux Traffic Control Classifier-Action Subsystem" ··· 930 930 module will be called act_ife. 931 931 932 932 config NET_ACT_TUNNEL_KEY 933 - tristate "IP tunnel metadata manipulation" 934 - depends on NET_CLS_ACT 935 - ---help--- 933 + tristate "IP tunnel metadata manipulation" 934 + depends on NET_CLS_ACT 935 + ---help--- 936 936 Say Y here to set/release ip tunnel metadata. 937 937 938 938 If unsure, say N. ··· 941 941 module will be called act_tunnel_key. 942 942 943 943 config NET_ACT_CT 944 - tristate "connection tracking tc action" 945 - depends on NET_CLS_ACT && NF_CONNTRACK && NF_NAT 946 - help 944 + tristate "connection tracking tc action" 945 + depends on NET_CLS_ACT && NF_CONNTRACK && NF_NAT 946 + help 947 947 Say Y here to allow sending the packets to conntrack module. 948 948 949 949 If unsure, say N. ··· 952 952 module will be called act_ct. 953 953 954 954 config NET_IFE_SKBMARK 955 - tristate "Support to encoding decoding skb mark on IFE action" 956 - depends on NET_ACT_IFE 955 + tristate "Support to encoding decoding skb mark on IFE action" 956 + depends on NET_ACT_IFE 957 957 958 958 config NET_IFE_SKBPRIO 959 - tristate "Support to encoding decoding skb prio on IFE action" 960 - depends on NET_ACT_IFE 959 + tristate "Support to encoding decoding skb prio on IFE action" 960 + depends on NET_ACT_IFE 961 961 962 962 config NET_IFE_SKBTCINDEX 963 - tristate "Support to encoding decoding skb tcindex on IFE action" 964 - depends on NET_ACT_IFE 963 + tristate "Support to encoding decoding skb tcindex on IFE action" 964 + depends on NET_ACT_IFE 965 965 966 966 config NET_TC_SKB_EXT 967 967 bool "TC recirculation support" 968 968 depends on NET_CLS_ACT 969 - default y if NET_CLS_ACT 970 969 select SKB_EXTENSIONS 971 970 972 971 help

+18 -16

net/sched/act_api.c

··· 831 831 return c; 832 832 } 833 833 834 + static const struct nla_policy tcf_action_policy[TCA_ACT_MAX + 1] = { 835 + [TCA_ACT_KIND] = { .type = NLA_NUL_STRING, 836 + .len = IFNAMSIZ - 1 }, 837 + [TCA_ACT_INDEX] = { .type = NLA_U32 }, 838 + [TCA_ACT_COOKIE] = { .type = NLA_BINARY, 839 + .len = TC_COOKIE_MAX_SIZE }, 840 + [TCA_ACT_OPTIONS] = { .type = NLA_NESTED }, 841 + }; 842 + 834 843 struct tc_action *tcf_action_init_1(struct net *net, struct tcf_proto *tp, 835 844 struct nlattr *nla, struct nlattr *est, 836 845 char *name, int ovr, int bind, ··· 855 846 int err; 856 847 857 848 if (name == NULL) { 858 - err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, NULL, 859 - extack); 849 + err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, 850 + tcf_action_policy, extack); 860 851 if (err < 0) 861 852 goto err_out; 862 853 err = -EINVAL; ··· 865 856 NL_SET_ERR_MSG(extack, "TC action kind must be specified"); 866 857 goto err_out; 867 858 } 868 - if (nla_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ) { 869 - NL_SET_ERR_MSG(extack, "TC action name too long"); 870 - goto err_out; 871 - } 859 + nla_strlcpy(act_name, kind, IFNAMSIZ); 860 + 872 861 if (tb[TCA_ACT_COOKIE]) { 873 - int cklen = nla_len(tb[TCA_ACT_COOKIE]); 874 - 875 - if (cklen > TC_COOKIE_MAX_SIZE) { 876 - NL_SET_ERR_MSG(extack, "TC cookie size above the maximum"); 877 - goto err_out; 878 - } 879 - 880 862 cookie = nla_memdup_cookie(tb); 881 863 if (!cookie) { 882 864 NL_SET_ERR_MSG(extack, "No memory to generate TC cookie"); ··· 1098 1098 int index; 1099 1099 int err; 1100 1100 1101 - err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, NULL, extack); 1101 + err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, 1102 + tcf_action_policy, extack); 1102 1103 if (err < 0) 1103 1104 goto err_out; 1104 1105 ··· 1153 1152 1154 1153 b = skb_tail_pointer(skb); 1155 1154 1156 - err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, NULL, extack); 1155 + err = nla_parse_nested_deprecated(tb, TCA_ACT_MAX, nla, 1156 + tcf_action_policy, extack); 1157 1157 if (err < 0) 1158 1158 goto err_out; 1159 1159 ··· 1442 1440 1443 1441 if (tb[1] == NULL) 1444 1442 return NULL; 1445 - if (nla_parse_nested_deprecated(tb2, TCA_ACT_MAX, tb[1], NULL, NULL) < 0) 1443 + if (nla_parse_nested_deprecated(tb2, TCA_ACT_MAX, tb[1], tcf_action_policy, NULL) < 0) 1446 1444 return NULL; 1447 1445 kind = tb2[TCA_ACT_KIND]; 1448 1446

+1

net/sched/act_sample.c

··· 146 146 case ARPHRD_TUNNEL6: 147 147 case ARPHRD_SIT: 148 148 case ARPHRD_IPGRE: 149 + case ARPHRD_IP6GRE: 149 150 case ARPHRD_VOID: 150 151 case ARPHRD_NONE: 151 152 return false;

+4 -2

net/sched/cls_api.c

··· 2894 2894 void tcf_exts_destroy(struct tcf_exts *exts) 2895 2895 { 2896 2896 #ifdef CONFIG_NET_CLS_ACT 2897 - tcf_action_destroy(exts->actions, TCA_ACT_UNBIND); 2898 - kfree(exts->actions); 2897 + if (exts->actions) { 2898 + tcf_action_destroy(exts->actions, TCA_ACT_UNBIND); 2899 + kfree(exts->actions); 2900 + } 2899 2901 exts->nr_actions = 0; 2900 2902 #endif 2901 2903 }

+2 -1

net/sched/sch_api.c

··· 1390 1390 } 1391 1391 1392 1392 const struct nla_policy rtm_tca_policy[TCA_MAX + 1] = { 1393 - [TCA_KIND] = { .type = NLA_STRING }, 1393 + [TCA_KIND] = { .type = NLA_NUL_STRING, 1394 + .len = IFNAMSIZ - 1 }, 1394 1395 [TCA_RATE] = { .type = NLA_BINARY, 1395 1396 .len = sizeof(struct tc_estimator) }, 1396 1397 [TCA_STAB] = { .type = NLA_NESTED },

+13 -17

net/sched/sch_cbs.c

··· 392 392 { 393 393 struct cbs_sched_data *q = qdisc_priv(sch); 394 394 struct net_device *dev = qdisc_dev(sch); 395 - int err; 396 395 397 396 if (!opt) { 398 397 NL_SET_ERR_MSG(extack, "Missing CBS qdisc options which are mandatory"); ··· 403 404 if (!q->qdisc) 404 405 return -ENOMEM; 405 406 407 + spin_lock(&cbs_list_lock); 408 + list_add(&q->cbs_list, &cbs_list); 409 + spin_unlock(&cbs_list_lock); 410 + 406 411 qdisc_hash_add(q->qdisc, false); 407 412 408 413 q->queue = sch->dev_queue - netdev_get_tx_queue(dev, 0); ··· 416 413 417 414 qdisc_watchdog_init(&q->watchdog, sch); 418 415 419 - err = cbs_change(sch, opt, extack); 420 - if (err) 421 - return err; 422 - 423 - if (!q->offload) { 424 - spin_lock(&cbs_list_lock); 425 - list_add(&q->cbs_list, &cbs_list); 426 - spin_unlock(&cbs_list_lock); 427 - } 428 - 429 - return 0; 416 + return cbs_change(sch, opt, extack); 430 417 } 431 418 432 419 static void cbs_destroy(struct Qdisc *sch) ··· 424 431 struct cbs_sched_data *q = qdisc_priv(sch); 425 432 struct net_device *dev = qdisc_dev(sch); 426 433 427 - spin_lock(&cbs_list_lock); 428 - list_del(&q->cbs_list); 429 - spin_unlock(&cbs_list_lock); 434 + /* Nothing to do if we couldn't create the underlying qdisc */ 435 + if (!q->qdisc) 436 + return; 430 437 431 438 qdisc_watchdog_cancel(&q->watchdog); 432 439 cbs_disable_offload(dev, q); 433 440 434 - if (q->qdisc) 435 - qdisc_put(q->qdisc); 441 + spin_lock(&cbs_list_lock); 442 + list_del(&q->cbs_list); 443 + spin_unlock(&cbs_list_lock); 444 + 445 + qdisc_put(q->qdisc); 436 446 } 437 447 438 448 static int cbs_dump(struct Qdisc *sch, struct sk_buff *skb)

+3 -1

net/sched/sch_htb.c

··· 1302 1302 struct htb_class *cl = (struct htb_class *)*arg, *parent; 1303 1303 struct nlattr *opt = tca[TCA_OPTIONS]; 1304 1304 struct nlattr *tb[TCA_HTB_MAX + 1]; 1305 + struct Qdisc *parent_qdisc = NULL; 1305 1306 struct tc_htb_opt *hopt; 1306 1307 u64 rate64, ceil64; 1307 1308 int warn = 0; ··· 1402 1401 if (parent && !parent->level) { 1403 1402 /* turn parent into inner node */ 1404 1403 qdisc_purge_queue(parent->leaf.q); 1405 - qdisc_put(parent->leaf.q); 1404 + parent_qdisc = parent->leaf.q; 1406 1405 if (parent->prio_activity) 1407 1406 htb_deactivate(q, parent); 1408 1407 ··· 1481 1480 cl->cbuffer = PSCHED_TICKS2NS(hopt->cbuffer); 1482 1481 1483 1482 sch_tree_unlock(sch); 1483 + qdisc_put(parent_qdisc); 1484 1484 1485 1485 if (warn) 1486 1486 pr_warn("HTB: quantum of class %X is %s. Consider r2q change.\n",

+16 -7

net/sched/sch_multiq.c

··· 174 174 { 175 175 struct multiq_sched_data *q = qdisc_priv(sch); 176 176 struct tc_multiq_qopt *qopt; 177 - int i; 177 + struct Qdisc **removed; 178 + int i, n_removed = 0; 178 179 179 180 if (!netif_is_multiqueue(qdisc_dev(sch))) 180 181 return -EOPNOTSUPP; ··· 186 185 187 186 qopt->bands = qdisc_dev(sch)->real_num_tx_queues; 188 187 188 + removed = kmalloc(sizeof(*removed) * (q->max_bands - q->bands), 189 + GFP_KERNEL); 190 + if (!removed) 191 + return -ENOMEM; 192 + 189 193 sch_tree_lock(sch); 190 194 q->bands = qopt->bands; 191 195 for (i = q->bands; i < q->max_bands; i++) { ··· 198 192 struct Qdisc *child = q->queues[i]; 199 193 200 194 q->queues[i] = &noop_qdisc; 201 - qdisc_tree_flush_backlog(child); 202 - qdisc_put(child); 195 + qdisc_purge_queue(child); 196 + removed[n_removed++] = child; 203 197 } 204 198 } 205 199 206 200 sch_tree_unlock(sch); 201 + 202 + for (i = 0; i < n_removed; i++) 203 + qdisc_put(removed[i]); 204 + kfree(removed); 207 205 208 206 for (i = 0; i < q->bands; i++) { 209 207 if (q->queues[i] == &noop_qdisc) { ··· 223 213 if (child != &noop_qdisc) 224 214 qdisc_hash_add(child, true); 225 215 226 - if (old != &noop_qdisc) { 227 - qdisc_tree_flush_backlog(old); 228 - qdisc_put(old); 229 - } 216 + if (old != &noop_qdisc) 217 + qdisc_purge_queue(old); 230 218 sch_tree_unlock(sch); 219 + qdisc_put(old); 231 220 } 232 221 } 233 222 }

+2 -2

net/sched/sch_netem.c

··· 476 476 * skb will be queued. 477 477 */ 478 478 if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) { 479 - struct Qdisc *rootq = qdisc_root(sch); 479 + struct Qdisc *rootq = qdisc_root_bh(sch); 480 480 u32 dupsave = q->duplicate; /* prevent duplicating a dup... */ 481 481 482 482 q->duplicate = 0; ··· 777 777 struct disttable *d; 778 778 int i; 779 779 780 - if (n > NETEM_DIST_MAX) 780 + if (!n || n > NETEM_DIST_MAX) 781 781 return -EINVAL; 782 782 783 783 d = kvmalloc(sizeof(struct disttable) + n * sizeof(s16), GFP_KERNEL);

+4 -3

net/sched/sch_sfb.c

··· 488 488 struct netlink_ext_ack *extack) 489 489 { 490 490 struct sfb_sched_data *q = qdisc_priv(sch); 491 - struct Qdisc *child; 491 + struct Qdisc *child, *old; 492 492 struct nlattr *tb[TCA_SFB_MAX + 1]; 493 493 const struct tc_sfb_qopt *ctl = &sfb_default_ops; 494 494 u32 limit; ··· 518 518 qdisc_hash_add(child, true); 519 519 sch_tree_lock(sch); 520 520 521 - qdisc_tree_flush_backlog(q->qdisc); 522 - qdisc_put(q->qdisc); 521 + qdisc_purge_queue(q->qdisc); 522 + old = q->qdisc; 523 523 q->qdisc = child; 524 524 525 525 q->rehash_interval = msecs_to_jiffies(ctl->rehash_interval); ··· 542 542 sfb_init_perturbation(1, q); 543 543 544 544 sch_tree_unlock(sch); 545 + qdisc_put(old); 545 546 546 547 return 0; 547 548 }

+1 -1

net/sctp/ipv6.c

··· 215 215 216 216 rcu_read_lock(); 217 217 res = ip6_xmit(sk, skb, fl6, sk->sk_mark, rcu_dereference(np->opt), 218 - tclass); 218 + tclass, sk->sk_priority); 219 219 rcu_read_unlock(); 220 220 return res; 221 221 }

-2

net/xdp/xdp_umem.c

··· 376 376 return -EINVAL; 377 377 } 378 378 379 - headroom = ALIGN(headroom, 64); 380 - 381 379 size_chk = chunk_size - headroom - XDP_PACKET_HEADROOM; 382 380 if (size_chk < 0) 383 381 return -EINVAL;

+88 -6

tools/lib/bpf/btf_dump.c

··· 48 48 __u8 fwd_emitted: 1; 49 49 /* whether unique non-duplicate name was already assigned */ 50 50 __u8 name_resolved: 1; 51 + /* whether type is referenced from any other type */ 52 + __u8 referenced: 1; 51 53 }; 52 54 53 55 struct btf_dump { ··· 175 173 free(d); 176 174 } 177 175 176 + static int btf_dump_mark_referenced(struct btf_dump *d); 178 177 static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr); 179 178 static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id); 180 179 ··· 216 213 /* VOID is special */ 217 214 d->type_states[0].order_state = ORDERED; 218 215 d->type_states[0].emit_state = EMITTED; 216 + 217 + /* eagerly determine referenced types for anon enums */ 218 + err = btf_dump_mark_referenced(d); 219 + if (err) 220 + return err; 219 221 } 220 222 221 223 d->emit_queue_cnt = 0; ··· 234 226 return 0; 235 227 } 236 228 229 + /* 230 + * Mark all types that are referenced from any other type. This is used to 231 + * determine top-level anonymous enums that need to be emitted as an 232 + * independent type declarations. 233 + * Anonymous enums come in two flavors: either embedded in a struct's field 234 + * definition, in which case they have to be declared inline as part of field 235 + * type declaration; or as a top-level anonymous enum, typically used for 236 + * declaring global constants. It's impossible to distinguish between two 237 + * without knowning whether given enum type was referenced from other type: 238 + * top-level anonymous enum won't be referenced by anything, while embedded 239 + * one will. 240 + */ 241 + static int btf_dump_mark_referenced(struct btf_dump *d) 242 + { 243 + int i, j, n = btf__get_nr_types(d->btf); 244 + const struct btf_type *t; 245 + __u16 vlen; 246 + 247 + for (i = 1; i <= n; i++) { 248 + t = btf__type_by_id(d->btf, i); 249 + vlen = btf_vlen(t); 250 + 251 + switch (btf_kind(t)) { 252 + case BTF_KIND_INT: 253 + case BTF_KIND_ENUM: 254 + case BTF_KIND_FWD: 255 + break; 256 + 257 + case BTF_KIND_VOLATILE: 258 + case BTF_KIND_CONST: 259 + case BTF_KIND_RESTRICT: 260 + case BTF_KIND_PTR: 261 + case BTF_KIND_TYPEDEF: 262 + case BTF_KIND_FUNC: 263 + case BTF_KIND_VAR: 264 + d->type_states[t->type].referenced = 1; 265 + break; 266 + 267 + case BTF_KIND_ARRAY: { 268 + const struct btf_array *a = btf_array(t); 269 + 270 + d->type_states[a->index_type].referenced = 1; 271 + d->type_states[a->type].referenced = 1; 272 + break; 273 + } 274 + case BTF_KIND_STRUCT: 275 + case BTF_KIND_UNION: { 276 + const struct btf_member *m = btf_members(t); 277 + 278 + for (j = 0; j < vlen; j++, m++) 279 + d->type_states[m->type].referenced = 1; 280 + break; 281 + } 282 + case BTF_KIND_FUNC_PROTO: { 283 + const struct btf_param *p = btf_params(t); 284 + 285 + for (j = 0; j < vlen; j++, p++) 286 + d->type_states[p->type].referenced = 1; 287 + break; 288 + } 289 + case BTF_KIND_DATASEC: { 290 + const struct btf_var_secinfo *v = btf_var_secinfos(t); 291 + 292 + for (j = 0; j < vlen; j++, v++) 293 + d->type_states[v->type].referenced = 1; 294 + break; 295 + } 296 + default: 297 + return -EINVAL; 298 + } 299 + } 300 + return 0; 301 + } 237 302 static int btf_dump_add_emit_queue_id(struct btf_dump *d, __u32 id) 238 303 { 239 304 __u32 *new_queue; ··· 476 395 } 477 396 case BTF_KIND_ENUM: 478 397 case BTF_KIND_FWD: 479 - if (t->name_off != 0) { 398 + /* 399 + * non-anonymous or non-referenced enums are top-level 400 + * declarations and should be emitted. Same logic can be 401 + * applied to FWDs, it won't hurt anyways. 402 + */ 403 + if (t->name_off != 0 || !tstate->referenced) { 480 404 err = btf_dump_add_emit_queue_id(d, id); 481 405 if (err) 482 406 return err; ··· 621 535 622 536 t = btf__type_by_id(d->btf, id); 623 537 kind = btf_kind(t); 624 - 625 - if (top_level_def && t->name_off == 0) { 626 - pr_warning("unexpected nameless definition, id:[%u]\n", id); 627 - return; 628 - } 629 538 630 539 if (tstate->emit_state == EMITTING) { 631 540 if (tstate->fwd_emitted) ··· 1248 1167 return; 1249 1168 } 1250 1169 1170 + next_id = decls->ids[decls->cnt - 1]; 1251 1171 next_t = btf__type_by_id(d->btf, next_id); 1252 1172 multidim = btf_is_array(next_t); 1253 1173 /* we need space if we have named non-pointer */

-11

tools/lib/bpf/xsk.c

··· 65 65 int xsks_map_fd; 66 66 __u32 queue_id; 67 67 char ifname[IFNAMSIZ]; 68 - bool zc; 69 68 }; 70 69 71 70 struct xsk_nl_info { ··· 490 491 void *rx_map = NULL, *tx_map = NULL; 491 492 struct sockaddr_xdp sxdp = {}; 492 493 struct xdp_mmap_offsets off; 493 - struct xdp_options opts; 494 494 struct xsk_socket *xsk; 495 495 socklen_t optlen; 496 496 int err; ··· 608 610 } 609 611 610 612 xsk->prog_fd = -1; 611 - 612 - optlen = sizeof(opts); 613 - err = getsockopt(xsk->fd, SOL_XDP, XDP_OPTIONS, &opts, &optlen); 614 - if (err) { 615 - err = -errno; 616 - goto out_mmap_tx; 617 - } 618 - 619 - xsk->zc = opts.flags & XDP_OPTIONS_ZEROCOPY; 620 613 621 614 if (!(xsk->config.libbpf_flags & XSK_LIBBPF_FLAGS__INHIBIT_PROG_LOAD)) { 622 615 err = xsk_setup_xdp_prog(xsk);

+19 -2

tools/testing/selftests/bpf/prog_tests/tcp_rtt.c

··· 203 203 return fd; 204 204 } 205 205 206 + static pthread_mutex_t server_started_mtx = PTHREAD_MUTEX_INITIALIZER; 207 + static pthread_cond_t server_started = PTHREAD_COND_INITIALIZER; 208 + 206 209 static void *server_thread(void *arg) 207 210 { 208 211 struct sockaddr_storage addr; 209 212 socklen_t len = sizeof(addr); 210 213 int fd = *(int *)arg; 211 214 int client_fd; 215 + int err; 212 216 213 - if (CHECK_FAIL(listen(fd, 1)) < 0) { 217 + err = listen(fd, 1); 218 + 219 + pthread_mutex_lock(&server_started_mtx); 220 + pthread_cond_signal(&server_started); 221 + pthread_mutex_unlock(&server_started_mtx); 222 + 223 + if (CHECK_FAIL(err < 0)) { 214 224 perror("Failed to listed on socket"); 215 225 return NULL; 216 226 } ··· 258 248 if (CHECK_FAIL(server_fd < 0)) 259 249 goto close_cgroup_fd; 260 250 261 - pthread_create(&tid, NULL, server_thread, (void *)&server_fd); 251 + if (CHECK_FAIL(pthread_create(&tid, NULL, server_thread, 252 + (void *)&server_fd))) 253 + goto close_cgroup_fd; 254 + 255 + pthread_mutex_lock(&server_started_mtx); 256 + pthread_cond_wait(&server_started, &server_started_mtx); 257 + pthread_mutex_unlock(&server_started_mtx); 258 + 262 259 CHECK_FAIL(run_test(cgroup_fd, server_fd)); 263 260 close(server_fd); 264 261 close_cgroup_fd:

+4 -1

tools/testing/selftests/bpf/progs/strobemeta.h

··· 413 413 #else 414 414 #pragma unroll 415 415 #endif 416 - for (int i = 0; i < STROBE_MAX_MAP_ENTRIES && i < map.cnt; ++i) { 416 + for (int i = 0; i < STROBE_MAX_MAP_ENTRIES; ++i) { 417 + if (i >= map.cnt) 418 + break; 419 + 417 420 descr->key_lens[i] = 0; 418 421 len = bpf_probe_read_str(payload, STROBE_MAX_STR_LEN, 419 422 map.entries[i].key);

-1

tools/testing/selftests/bpf/test_sysctl.c

··· 1385 1385 uint8_t raw[sizeof(uint64_t)]; 1386 1386 uint64_t num; 1387 1387 } value = {}; 1388 - uint8_t c, i; 1389 1388 1390 1389 if (buf_len > sizeof(value)) { 1391 1390 log_err("Value is too big (%zd) to use in fixup", buf_len);

-7

tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l2_drops.sh

··· 224 224 local vid=10 225 225 226 226 bridge vlan add vid $vid dev $swp2 master 227 - # During initialization the firmware enables all the VLAN filters and 228 - # the driver does not turn them off since the traffic will be discarded 229 - # by the STP filter whose default is DISCARD state. Add the VID on the 230 - # ingress bridge port and then remove it to make sure it is not member 231 - # in the VLAN. 232 - bridge vlan add vid $vid dev $swp1 master 233 - bridge vlan del vid $vid dev $swp1 master 234 227 235 228 RET=0 236 229

+4 -2

tools/testing/selftests/net/fib_nexthop_multiprefix.sh

··· 15 15 PAUSE_ON_FAIL=no 16 16 VERBOSE=0 17 17 18 + which ping6 > /dev/null 2>&1 && ping6=$(which ping6) || ping6=$(which ping) 19 + 18 20 ################################################################################ 19 21 # helpers 20 22 ··· 202 200 local rc 203 201 204 202 if [ ${ping_sz} != "0" ]; then 205 - run_cmd ip netns exec h0 ping6 -s ${ping_sz} -c5 -w5 ${dst} 203 + run_cmd ip netns exec h0 ${ping6} -s ${ping_sz} -c5 -w5 ${dst} 206 204 fi 207 205 208 206 if [ "$VERBOSE" = "1" ]; then ··· 245 243 run_cmd taskset -c ${c} ip netns exec h0 ping -c1 -w1 172.16.10${i}.1 246 244 [ $? -ne 0 ] && printf "\nERROR: ping to h${i} failed\n" && ret=1 247 245 248 - run_cmd taskset -c ${c} ip netns exec h0 ping6 -c1 -w1 2001:db8:10${i}::1 246 + run_cmd taskset -c ${c} ip netns exec h0 ${ping6} -c1 -w1 2001:db8:10${i}::1 249 247 [ $? -ne 0 ] && printf "\nERROR: ping6 to h${i} failed\n" && ret=1 250 248 251 249 [ $ret -ne 0 ] && break

+14

tools/testing/selftests/net/fib_nexthops.sh

··· 940 940 run_cmd "$IP nexthop add id 104 group 1 dev veth1" 941 941 log_test $? 2 "Nexthop group and device" 942 942 943 + # Tests to ensure that flushing works as expected. 944 + run_cmd "$IP nexthop add id 105 blackhole proto 99" 945 + run_cmd "$IP nexthop add id 106 blackhole proto 100" 946 + run_cmd "$IP nexthop add id 107 blackhole proto 99" 947 + run_cmd "$IP nexthop flush proto 99" 948 + check_nexthop "id 105" "" 949 + check_nexthop "id 106" "id 106 blackhole proto 100" 950 + check_nexthop "id 107" "" 951 + run_cmd "$IP nexthop flush proto 100" 952 + check_nexthop "id 106" "" 953 + 954 + run_cmd "$IP nexthop flush proto 100" 955 + log_test $? 0 "Test proto flush" 956 + 943 957 run_cmd "$IP nexthop add id 104 group 1 blackhole" 944 958 log_test $? 2 "Nexthop group and blackhole" 945 959

+19 -2

tools/testing/selftests/net/fib_tests.sh

··· 9 9 ksft_skip=4 10 10 11 11 # all tests in this script. Can be overridden with -t option 12 - TESTS="unregister down carrier nexthop ipv6_rt ipv4_rt ipv6_addr_metric ipv4_addr_metric ipv6_route_metrics ipv4_route_metrics ipv4_route_v6_gw rp_filter" 12 + TESTS="unregister down carrier nexthop suppress ipv6_rt ipv4_rt ipv6_addr_metric ipv4_addr_metric ipv6_route_metrics ipv4_route_metrics ipv4_route_v6_gw rp_filter" 13 13 14 14 VERBOSE=0 15 15 PAUSE_ON_FAIL=no 16 16 PAUSE=no 17 17 IP="ip -netns ns1" 18 18 NS_EXEC="ip netns exec ns1" 19 + 20 + which ping6 > /dev/null 2>&1 && ping6=$(which ping6) || ping6=$(which ping) 19 21 20 22 log_test() 21 23 { ··· 616 614 cleanup 617 615 } 618 616 617 + fib_suppress_test() 618 + { 619 + $IP link add dummy1 type dummy 620 + $IP link set dummy1 up 621 + $IP -6 route add default dev dummy1 622 + $IP -6 rule add table main suppress_prefixlength 0 623 + ping -f -c 1000 -W 1 1234::1 || true 624 + $IP -6 rule del table main suppress_prefixlength 0 625 + $IP link del dummy1 626 + 627 + # If we got here without crashing, we're good. 628 + return 0 629 + } 630 + 619 631 ################################################################################ 620 632 # Tests on route add and replace 621 633 ··· 1102 1086 log_test $rc 0 "Multipath route with mtu metric" 1103 1087 1104 1088 $IP -6 ro add 2001:db8:104::/64 via 2001:db8:101::2 mtu 1300 1105 - run_cmd "ip netns exec ns1 ping6 -w1 -c1 -s 1500 2001:db8:104::1" 1089 + run_cmd "ip netns exec ns1 ${ping6} -w1 -c1 -s 1500 2001:db8:104::1" 1106 1090 log_test $? 0 "Using route with mtu metric" 1107 1091 1108 1092 run_cmd "$IP -6 ro add 2001:db8:114::/64 via 2001:db8:101::2 congctl lock foo" ··· 1607 1591 fib_carrier_test|carrier) fib_carrier_test;; 1608 1592 fib_rp_filter_test|rp_filter) fib_rp_filter_test;; 1609 1593 fib_nexthop_test|nexthop) fib_nexthop_test;; 1594 + fib_suppress_test|suppress) fib_suppress_test;; 1610 1595 ipv6_route_test|ipv6_rt) ipv6_route_test;; 1611 1596 ipv4_route_test|ipv4_rt) ipv4_route_test;; 1612 1597 ipv6_addr_metric) ipv6_addr_metric_test;;

-1

usr/include/Makefile

··· 38 38 header-test- += linux/jffs2.h 39 39 header-test- += linux/kexec.h 40 40 header-test- += linux/matroxfb.h 41 - header-test- += linux/netfilter_bridge/ebtables.h 42 41 header-test- += linux/netfilter_ipv4/ipt_LOG.h 43 42 header-test- += linux/netfilter_ipv6/ip6t_LOG.h 44 43 header-test- += linux/nfc.h

Configure Feed

Configure Feed