lael-labs/linux

Documentation/bpf/ringbuf.rst+1−4

Documentation/networking/ethtool-netlink.rst+3−0

   ``ETHTOOL_MSG_TSINFO_GET``		get timestamping info
   ``ETHTOOL_MSG_CABLE_TEST_ACT``        action start cable test
   ``ETHTOOL_MSG_CABLE_TEST_TDR_ACT``    action start raw TDR cable test
+  ``ETHTOOL_MSG_TUNNEL_INFO_GET``       get tunnel offload info
   ===================================== ================================
 Kernel to userspace:
   ``ETHTOOL_MSG_TSINFO_GET_REPLY``	timestamping info
   ``ETHTOOL_MSG_CABLE_TEST_NTF``        Cable test results
   ``ETHTOOL_MSG_CABLE_TEST_TDR_NTF``    Cable test TDR results
+  ``ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY`` tunnel offload info
   ===================================== =================================
 ``GET`` requests are sent by userspace applications to retrieve device
   ``ETHTOOL_SFECPARAM``               n/a
   n/a                                 ''ETHTOOL_MSG_CABLE_TEST_ACT''
   n/a                                 ''ETHTOOL_MSG_CABLE_TEST_TDR_ACT''
+  n/a                                 ``ETHTOOL_MSG_TUNNEL_INFO_GET``
   =================================== =====================================

MAINTAINERS+6−9

@@ -4408,12 +4408,6 @@ T: git git://git.infradead.org/users/hch/configfs.git · 4407 unmodified lines
4408	F: fs/configfs/	4408	F: fs/configfs/
4409	F: include/linux/configfs.h	4409	F: include/linux/configfs.h
4410		4410
4411	CONNECTOR
4412	M: Evgeniy Polyakov <zbr@ioremap.net>
4413	L: netdev@vger.kernel.org
4414	S: Maintained
4415	F: drivers/connector/
4416
4417	CONSOLE SUBSYSTEM	4411	CONSOLE SUBSYSTEM
4418	M: Greg Kroah-Hartman <gregkh@linuxfoundation.org>	4412	M: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
4419	S: Supported	4413	S: Supported
@@ -8329,8 +8323,9 @@ S: Supported · 3909 unmodified lines
8329	F: drivers/pci/hotplug/rpaphp*	8323	F: drivers/pci/hotplug/rpaphp*
8330		8324
8331	IBM Power SRIOV Virtual NIC Device Driver	8325	IBM Power SRIOV Virtual NIC Device Driver
8332	M: Thomas Falcon <tlfalcon@linux.ibm.com>	8326	M: Dany Madden <drt@linux.ibm.com>
8333	M: John Allen <jallen@linux.ibm.com>	8327	M: Lijun Pan <ljp@linux.ibm.com>
		8328	M: Sukadev Bhattiprolu <sukadev@linux.ibm.com>
8334	L: netdev@vger.kernel.org	8329	L: netdev@vger.kernel.org
8335	S: Supported	8330	S: Supported
8336	F: drivers/net/ethernet/ibm/ibmvnic.*	8331	F: drivers/net/ethernet/ibm/ibmvnic.*
@@ -8344,7 +8339,7 @@ F: arch/powerpc/platforms/powernv/copy-paste.h · 7 unmodified lines
8344	F: arch/powerpc/platforms/powernv/vas*	8339	F: arch/powerpc/platforms/powernv/vas*
8345		8340
8346	IBM Power Virtual Ethernet Device Driver	8341	IBM Power Virtual Ethernet Device Driver
8347	M: Thomas Falcon <tlfalcon@linux.ibm.com>	8342	M: Cristobal Forno <cforno12@linux.ibm.com>
8348	L: netdev@vger.kernel.org	8343	L: netdev@vger.kernel.org
8349	S: Supported	8344	S: Supported
8350	F: drivers/net/ethernet/ibm/ibmveth.*	8345	F: drivers/net/ethernet/ibm/ibmveth.*
@@ -11042,6 +11037,7 @@ F: drivers/char/hw_random/mtk-rng.c · 2691 unmodified lines
11042		11037
11043	MEDIATEK SWITCH DRIVER	11038	MEDIATEK SWITCH DRIVER
11044	M: Sean Wang <sean.wang@mediatek.com>	11039	M: Sean Wang <sean.wang@mediatek.com>
		11040	M: Landen Chao <Landen.Chao@mediatek.com>
11045	L: netdev@vger.kernel.org	11041	L: netdev@vger.kernel.org
11046	S: Maintained	11042	S: Maintained
11047	F: drivers/net/dsa/mt7530.*	11043	F: drivers/net/dsa/mt7530.*
@@ -12055,6 +12051,7 @@ Q: http://patchwork.ozlabs.org/project/netdev/list/ · 1007 unmodified lines
12055	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git	12051	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
12056	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git	12052	T: git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
12057	F: Documentation/devicetree/bindings/net/	12053	F: Documentation/devicetree/bindings/net/
		12054	F: drivers/connector/
12058	F: drivers/net/	12055	F: drivers/net/
12059	F: include/linux/etherdevice.h	12056	F: include/linux/etherdevice.h
12060	F: include/linux/fcdevice.h	12057	F: include/linux/fcdevice.h

arch/arm/boot/dts/at91-sama5d2_icp.dts+1−1

 		switch0: ksz8563@0 {
 			compatible = "microchip,ksz8563";
 			reg = <0>;
-			phy-mode = "mii";
 			reset-gpios = <&pioA PIN_PD4 GPIO_ACTIVE_LOW>;
 			spi-max-frequency = <500000>;
 					reg = <2>;
 					label = "cpu";
 					ethernet = <&macb0>;
+					phy-mode = "mii";
 					fixed-link {
 						speed = <100>;
 						full-duplex;

drivers/atm/eni.c+1−1

@@ -2224,7 +2224,7 @@ static int eni_init_one(struct pci_dev *pci_dev, · 2223 unmodified lines
2224		2224
2225	rc = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32));	2225	rc = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32));
2226	if (rc < 0)	2226	if (rc < 0)
2227	goto out;	2227	goto err_disable;
2228		2228
2229	rc = -ENOMEM;	2229	rc = -ENOMEM;
2230	eni_dev = kmalloc(sizeof(struct eni_dev), GFP_KERNEL);	2230	eni_dev = kmalloc(sizeof(struct eni_dev), GFP_KERNEL);

drivers/net/dsa/microchip/ksz8795.c+14−6

 	ksz_port_cfg(dev, port, P_PRIO_CTRL, PORT_802_1P_ENABLE, true);
 	if (cpu_port) {
+		if (!p->interface && dev->compat_interface) {
+			dev_warn(dev->dev,
+				 "Using legacy switch \"phy-mode\" property, because it is missing on port %d node. "
+				 "Please update your device tree.\n",
+				 port);
+			p->interface = dev->compat_interface;
+		}
 		/* Configure MII interface for proper network communication. */
 		ksz_read8(dev, REG_PORT_5_CTRL_6, &data8);
 		data8 &= ~PORT_INTERFACE_TYPE;
 		data8 &= ~PORT_GMII_1GPS_MODE;
-		switch (dev->interface) {
+		switch (p->interface) {
 		case PHY_INTERFACE_MODE_MII:
 			p->phydev.speed = SPEED_100;
 			break;
 		default:
 			data8 &= ~PORT_RGMII_ID_IN_ENABLE;
 			data8 &= ~PORT_RGMII_ID_OUT_ENABLE;
-			if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
+			if (p->interface == PHY_INTERFACE_MODE_RGMII_ID ||
-			    dev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
+			    p->interface == PHY_INTERFACE_MODE_RGMII_RXID)
 				data8 |= PORT_RGMII_ID_IN_ENABLE;
-			if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
+			if (p->interface == PHY_INTERFACE_MODE_RGMII_ID ||
-			    dev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
+			    p->interface == PHY_INTERFACE_MODE_RGMII_TXID)
 				data8 |= PORT_RGMII_ID_OUT_ENABLE;
 			data8 |= PORT_GMII_1GPS_MODE;
 			data8 |= PORT_INTERFACE_RGMII;
 	}
 	/* set the real number of ports */
-	dev->ds->num_ports = dev->port_cnt;
+	dev->ds->num_ports = dev->port_cnt + 1;
 	return 0;
 }

drivers/net/dsa/microchip/ksz9477.c+19−10

 		/* configure MAC to 1G & RGMII mode */
 		ksz_pread8(dev, port, REG_PORT_XMII_CTRL_1, &data8);
-		switch (dev->interface) {
+		switch (p->interface) {
 		case PHY_INTERFACE_MODE_MII:
 			ksz9477_set_xmii(dev, 0, &data8);
 			ksz9477_set_gbit(dev, false, &data8);
 			ksz9477_set_gbit(dev, true, &data8);
 			data8 &= ~PORT_RGMII_ID_IG_ENABLE;
 			data8 &= ~PORT_RGMII_ID_EG_ENABLE;
-			if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
+			if (p->interface == PHY_INTERFACE_MODE_RGMII_ID ||
-			    dev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
+			    p->interface == PHY_INTERFACE_MODE_RGMII_RXID)
 				data8 |= PORT_RGMII_ID_IG_ENABLE;
-			if (dev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
+			if (p->interface == PHY_INTERFACE_MODE_RGMII_ID ||
-			    dev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
+			    p->interface == PHY_INTERFACE_MODE_RGMII_TXID)
 				data8 |= PORT_RGMII_ID_EG_ENABLE;
 			p->phydev.speed = SPEED_1000;
 			break;
 			dev->cpu_port = i;
 			dev->host_mask = (1 << dev->cpu_port);
 			dev->port_mask |= dev->host_mask;
+			p = &dev->ports[i];
 			/* Read from XMII register to determine host port
 			 * interface.  If set specifically in device tree
 			 * note the difference to help debugging.
 			 */
 			interface = ksz9477_get_interface(dev, i);
-			if (!dev->interface)
+			if (!p->interface) {
-				dev->interface = interface;
+				if (dev->compat_interface) {
-			if (interface && interface != dev->interface)
+					dev_warn(dev->dev,
+						 "Using legacy switch \"phy-mode\" property, because it is missing on port %d node. "
+						 "Please update your device tree.\n",
+						 i);
+					p->interface = dev->compat_interface;
+				} else {
+					p->interface = interface;
+				}
+			}
+			if (interface && interface != p->interface)
 				dev_info(dev->dev,
 					 "use %s instead of %s\n",
-					  phy_modes(dev->interface),
+					  phy_modes(p->interface),
 					  phy_modes(interface));
 			/* enable cpu port */
 			ksz9477_port_setup(dev, i, true);
-			p = &dev->ports[dev->cpu_port];
 			p->vid_member = dev->port_mask;
 			p->on = 1;
 		}

drivers/net/dsa/microchip/ksz_common.c+12−1

 			const struct ksz_dev_ops *ops)
 {
 	phy_interface_t interface;
+	struct device_node *port;
+	unsigned int port_num;
 	int ret;
 	if (dev->pdata)
 	/* Host port interface will be self detected, or specifically set in
 	 * device tree.
 	 */
+	for (port_num = 0; port_num < dev->port_cnt; ++port_num)
+		dev->ports[port_num].interface = PHY_INTERFACE_MODE_NA;
 	if (dev->dev->of_node) {
 		ret = of_get_phy_mode(dev->dev->of_node, &interface);
 		if (ret == 0)
-			dev->interface = interface;
+			dev->compat_interface = interface;
+		for_each_available_child_of_node(dev->dev->of_node, port) {
+			if (of_property_read_u32(port, "reg", &port_num))
+				continue;
+			if (port_num >= dev->port_cnt)
+				return -EINVAL;
+			of_get_phy_mode(port, &dev->ports[port_num].interface);
+		}
 		dev->synclko_125 = of_property_read_bool(dev->dev->of_node,
 							 "microchip,synclko-125");
 	}

drivers/net/dsa/microchip/ksz_common.h+2−1

 	u32 freeze:1;			/* MIB counter freeze is enabled */
 	struct ksz_port_mib mib;
+	phy_interface_t interface;
 };
 struct ksz_device {
 	int mib_cnt;
 	int mib_port_cnt;
 	int last_port;			/* ports after that not used */
-	phy_interface_t interface;
+	phy_interface_t compat_interface;
 	u32 regs_size;
 	bool phy_errata_9477;
 	bool synclko_125;

drivers/net/dsa/ocelot/felix.c+7−1

 	if (err)
 		return err;
-	ocelot_init(ocelot);
+	err = ocelot_init(ocelot);
+	if (err)
+		return err;
 	if (ocelot->ptp) {
 		err = ocelot_init_timestamp(ocelot, &ocelot_ptp_clock_info);
 		if (err) {
 {
 	struct ocelot *ocelot = ds->priv;
 	struct felix *felix = ocelot_to_felix(ocelot);
+	int port;
 	if (felix->info->mdio_bus_free)
 		felix->info->mdio_bus_free(ocelot);
+	for (port = 0; port < ocelot->num_phys_ports; port++)
+		ocelot_deinit_port(ocelot, port);
 	ocelot_deinit_timestamp(ocelot);
 	/* stop workqueue thread */
 	ocelot_deinit(ocelot);

drivers/net/dsa/ocelot/felix_vsc9959.c+8−8

@@ -645,17 +645,17 @@ static struct vcap_field vsc9959_vcap_is2_keys[] = { · 644 unmodified lines
645	[VCAP_IS2_HK_DIP_EQ_SIP] = {118, 1},	645	[VCAP_IS2_HK_DIP_EQ_SIP] = {118, 1},
646	/* IP4_TCP_UDP (TYPE=100) */	646	/* IP4_TCP_UDP (TYPE=100) */
647	[VCAP_IS2_HK_TCP] = {119, 1},	647	[VCAP_IS2_HK_TCP] = {119, 1},
648	[VCAP_IS2_HK_L4_SPORT] = {120, 16},	648	[VCAP_IS2_HK_L4_DPORT] = {120, 16},
649	[VCAP_IS2_HK_L4_DPORT] = {136, 16},	649	[VCAP_IS2_HK_L4_SPORT] = {136, 16},
650	[VCAP_IS2_HK_L4_RNG] = {152, 8},	650	[VCAP_IS2_HK_L4_RNG] = {152, 8},
651	[VCAP_IS2_HK_L4_SPORT_EQ_DPORT] = {160, 1},	651	[VCAP_IS2_HK_L4_SPORT_EQ_DPORT] = {160, 1},
652	[VCAP_IS2_HK_L4_SEQUENCE_EQ0] = {161, 1},	652	[VCAP_IS2_HK_L4_SEQUENCE_EQ0] = {161, 1},
653	[VCAP_IS2_HK_L4_URG] = {162, 1},	653	[VCAP_IS2_HK_L4_FIN] = {162, 1},
654	[VCAP_IS2_HK_L4_ACK] = {163, 1},	654	[VCAP_IS2_HK_L4_SYN] = {163, 1},
655	[VCAP_IS2_HK_L4_PSH] = {164, 1},	655	[VCAP_IS2_HK_L4_RST] = {164, 1},
656	[VCAP_IS2_HK_L4_RST] = {165, 1},	656	[VCAP_IS2_HK_L4_PSH] = {165, 1},
657	[VCAP_IS2_HK_L4_SYN] = {166, 1},	657	[VCAP_IS2_HK_L4_ACK] = {166, 1},
658	[VCAP_IS2_HK_L4_FIN] = {167, 1},	658	[VCAP_IS2_HK_L4_URG] = {167, 1},
659	[VCAP_IS2_HK_L4_1588_DOM] = {168, 8},	659	[VCAP_IS2_HK_L4_1588_DOM] = {168, 8},
660	[VCAP_IS2_HK_L4_1588_VER] = {176, 4},	660	[VCAP_IS2_HK_L4_1588_VER] = {176, 4},
661	/* IP4_OTHER (TYPE=101) */	661	/* IP4_OTHER (TYPE=101) */

drivers/net/dsa/ocelot/seville_vsc9953.c+9−9

@@ -659,17 +659,17 @@ static struct vcap_field vsc9953_vcap_is2_keys[] = { · 658 unmodified lines
659	[VCAP_IS2_HK_DIP_EQ_SIP] = {122, 1},	659	[VCAP_IS2_HK_DIP_EQ_SIP] = {122, 1},
660	/* IP4_TCP_UDP (TYPE=100) */	660	/* IP4_TCP_UDP (TYPE=100) */
661	[VCAP_IS2_HK_TCP] = {123, 1},	661	[VCAP_IS2_HK_TCP] = {123, 1},
662	[VCAP_IS2_HK_L4_SPORT] = {124, 16},	662	[VCAP_IS2_HK_L4_DPORT] = {124, 16},
663	[VCAP_IS2_HK_L4_DPORT] = {140, 16},	663	[VCAP_IS2_HK_L4_SPORT] = {140, 16},
664	[VCAP_IS2_HK_L4_RNG] = {156, 8},	664	[VCAP_IS2_HK_L4_RNG] = {156, 8},
665	[VCAP_IS2_HK_L4_SPORT_EQ_DPORT] = {164, 1},	665	[VCAP_IS2_HK_L4_SPORT_EQ_DPORT] = {164, 1},
666	[VCAP_IS2_HK_L4_SEQUENCE_EQ0] = {165, 1},	666	[VCAP_IS2_HK_L4_SEQUENCE_EQ0] = {165, 1},
667	[VCAP_IS2_HK_L4_URG] = {166, 1},	667	[VCAP_IS2_HK_L4_FIN] = {166, 1},
668	[VCAP_IS2_HK_L4_ACK] = {167, 1},	668	[VCAP_IS2_HK_L4_SYN] = {167, 1},
669	[VCAP_IS2_HK_L4_PSH] = {168, 1},	669	[VCAP_IS2_HK_L4_RST] = {168, 1},
670	[VCAP_IS2_HK_L4_RST] = {169, 1},	670	[VCAP_IS2_HK_L4_PSH] = {169, 1},
671	[VCAP_IS2_HK_L4_SYN] = {170, 1},	671	[VCAP_IS2_HK_L4_ACK] = {170, 1},
672	[VCAP_IS2_HK_L4_FIN] = {171, 1},	672	[VCAP_IS2_HK_L4_URG] = {171, 1},
673	/* IP4_OTHER (TYPE=101) */	673	/* IP4_OTHER (TYPE=101) */
674	[VCAP_IS2_HK_IP4_L3_PROTO] = {123, 8},	674	[VCAP_IS2_HK_IP4_L3_PROTO] = {123, 8},
675	[VCAP_IS2_HK_L3_PAYLOAD] = {131, 56},	675	[VCAP_IS2_HK_L3_PAYLOAD] = {131, 56},
@@ -1008,7 +1008,7 @@ static const struct felix_info seville_info_vsc9953 = { · 332 unmodified lines
1008	.vcap_is2_keys = vsc9953_vcap_is2_keys,	1008	.vcap_is2_keys = vsc9953_vcap_is2_keys,
1009	.vcap_is2_actions = vsc9953_vcap_is2_actions,	1009	.vcap_is2_actions = vsc9953_vcap_is2_actions,
1010	.vcap = vsc9953_vcap_props,	1010	.vcap = vsc9953_vcap_props,
1011	.shared_queue_sz = 128 * 1024,	1011	.shared_queue_sz = 2048 * 1024,
1012	.num_mact_rows = 2048,	1012	.num_mact_rows = 2048,
1013	.num_ports = 10,	1013	.num_ports = 10,
1014	.mdio_bus_alloc = vsc9953_mdio_bus_alloc,	1014	.mdio_bus_alloc = vsc9953_mdio_bus_alloc,

drivers/net/dsa/rtl8366.c+13−7

@@ -452,13 +452,19 @@ int rtl8366_vlan_del(struct dsa_switch *ds, int port, · 451 unmodified lines
452	return ret;	452	return ret;
453		453
454	if (vid == vlanmc.vid) {	454	if (vid == vlanmc.vid) {
455	/* clear VLAN member configurations */	455	/* Remove this port from the VLAN */
456	vlanmc.vid = 0;	456	vlanmc.member &= ~BIT(port);
457	vlanmc.priority = 0;	457	vlanmc.untag &= ~BIT(port);
458	vlanmc.member = 0;	458	/*
459	vlanmc.untag = 0;	459	* If no ports are members of this VLAN
460	vlanmc.fid = 0;	460	* anymore then clear the whole member
461		461	* config so it can be reused.
		462	*/
		463	if (!vlanmc.member && vlanmc.untag) {
		464	vlanmc.vid = 0;
		465	vlanmc.priority = 0;
		466	vlanmc.fid = 0;
		467	}
462	ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);	468	ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);
463	if (ret) {	469	if (ret) {
464	dev_err(smi->dev,	470	dev_err(smi->dev,

drivers/net/ethernet/broadcom/bnxt/bnxt.c+27−16

@@ -3782,6 +3782,7 @@ static int bnxt_hwrm_func_qstat_ext(struct bnxt *bp, · 3781 unmodified lines
3782	return -EOPNOTSUPP;	3782	return -EOPNOTSUPP;
3783		3783
3784	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_QSTATS_EXT, -1, -1);	3784	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_QSTATS_EXT, -1, -1);
		3785	req.fid = cpu_to_le16(0xffff);
3785	req.flags = FUNC_QSTATS_EXT_REQ_FLAGS_COUNTER_MASK;	3786	req.flags = FUNC_QSTATS_EXT_REQ_FLAGS_COUNTER_MASK;
3786	mutex_lock(&bp->hwrm_cmd_lock);	3787	mutex_lock(&bp->hwrm_cmd_lock);
3787	rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);	3788	rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
@@ -3852,7 +3853,7 @@ static void bnxt_init_stats(struct bnxt *bp) · 64 unmodified lines
3852	tx_masks = stats->hw_masks;	3853	tx_masks = stats->hw_masks;
3853	tx_count = sizeof(struct tx_port_stats_ext) / 8;	3854	tx_count = sizeof(struct tx_port_stats_ext) / 8;
3854		3855
3855	flags = FUNC_QSTATS_EXT_REQ_FLAGS_COUNTER_MASK;	3856	flags = PORT_QSTATS_EXT_REQ_FLAGS_COUNTER_MASK;
3856	rc = bnxt_hwrm_port_qstats_ext(bp, flags);	3857	rc = bnxt_hwrm_port_qstats_ext(bp, flags);
3857	if (rc) {	3858	if (rc) {
3858	mask = (1ULL << 40) - 1;	3859	mask = (1ULL << 40) - 1;
@@ -4305,7 +4306,7 @@ static int bnxt_hwrm_do_send_msg(struct bnxt bp, void msg, u32 msg_len, · 446 unmodified lines
4305	u32 bar_offset = BNXT_GRCPF_REG_CHIMP_COMM;	4306	u32 bar_offset = BNXT_GRCPF_REG_CHIMP_COMM;
4306	u16 dst = BNXT_HWRM_CHNL_CHIMP;	4307	u16 dst = BNXT_HWRM_CHNL_CHIMP;
4307		4308
4308	if (test_bit(BNXT_STATE_FW_FATAL_COND, &bp->state))	4309	if (BNXT_NO_FW_ACCESS(bp))
4309	return -EBUSY;	4310	return -EBUSY;
4310		4311
4311	if (msg_len > BNXT_HWRM_MAX_REQ_LEN) {	4312	if (msg_len > BNXT_HWRM_MAX_REQ_LEN) {
@@ -5723,7 +5724,7 @@ static int hwrm_ring_free_send_msg(struct bnxt *bp, · 1411 unmodified lines
5723	struct hwrm_ring_free_output *resp = bp->hwrm_cmd_resp_addr;	5724	struct hwrm_ring_free_output *resp = bp->hwrm_cmd_resp_addr;
5724	u16 error_code;	5725	u16 error_code;
5725		5726
5726	if (test_bit(BNXT_STATE_FW_FATAL_COND, &bp->state))	5727	if (BNXT_NO_FW_ACCESS(bp))
5727	return 0;	5728	return 0;
5728		5729
5729	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_RING_FREE, cmpl_ring_id, -1);	5730	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_RING_FREE, cmpl_ring_id, -1);
@@ -7817,7 +7818,7 @@ static int bnxt_set_tpa(struct bnxt *bp, bool set_tpa) · 2087 unmodified lines
7817		7818
7818	if (set_tpa)	7819	if (set_tpa)
7819	tpa_flags = bp->flags & BNXT_FLAG_TPA;	7820	tpa_flags = bp->flags & BNXT_FLAG_TPA;
7820	else if (test_bit(BNXT_STATE_FW_FATAL_COND, &bp->state))	7821	else if (BNXT_NO_FW_ACCESS(bp))
7821	return 0;	7822	return 0;
7822	for (i = 0; i < bp->nr_vnics; i++) {	7823	for (i = 0; i < bp->nr_vnics; i++) {
7823	rc = bnxt_hwrm_vnic_set_tpa(bp, i, tpa_flags);	7824	rc = bnxt_hwrm_vnic_set_tpa(bp, i, tpa_flags);
@@ -9311,18 +9312,16 @@ static ssize_t bnxt_show_temp(struct device *dev, · 1487 unmodified lines
9311	struct hwrm_temp_monitor_query_output *resp;	9312	struct hwrm_temp_monitor_query_output *resp;
9312	struct bnxt *bp = dev_get_drvdata(dev);	9313	struct bnxt *bp = dev_get_drvdata(dev);
9313	u32 len = 0;	9314	u32 len = 0;
		9315	int rc;
9314		9316
9315	resp = bp->hwrm_cmd_resp_addr;	9317	resp = bp->hwrm_cmd_resp_addr;
9316	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_TEMP_MONITOR_QUERY, -1, -1);	9318	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_TEMP_MONITOR_QUERY, -1, -1);
9317	mutex_lock(&bp->hwrm_cmd_lock);	9319	mutex_lock(&bp->hwrm_cmd_lock);
9318	if (!_hwrm_send_message_silent(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT))	9320	rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
		9321	if (!rc)
9319	len = sprintf(buf, "%u\n", resp->temp * 1000); /* display millidegree */	9322	len = sprintf(buf, "%u\n", resp->temp * 1000); /* display millidegree */
9320	mutex_unlock(&bp->hwrm_cmd_lock);	9323	mutex_unlock(&bp->hwrm_cmd_lock);
9321		9324	return rc ?: len;
9322	if (len)
9323	return len;
9324
9325	return sprintf(buf, "unknown\n");
9326	}	9325	}
9327	static SENSOR_DEVICE_ATTR(temp1_input, 0444, bnxt_show_temp, NULL, 0);	9326	static SENSOR_DEVICE_ATTR(temp1_input, 0444, bnxt_show_temp, NULL, 0);
9328		9327
@@ -9342,7 +9341,16 @@ static void bnxt_hwmon_close(struct bnxt *bp) · 13 unmodified lines
9342		9341
9343	static void bnxt_hwmon_open(struct bnxt *bp)	9342	static void bnxt_hwmon_open(struct bnxt *bp)
9344	{	9343	{
		9344	struct hwrm_temp_monitor_query_input req = {0};
9345	struct pci_dev *pdev = bp->pdev;	9345	struct pci_dev *pdev = bp->pdev;
		9346	int rc;
		9347
		9348	bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_TEMP_MONITOR_QUERY, -1, -1);
		9349	rc = hwrm_send_message_silent(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
		9350	if (rc == -EACCES \|\| rc == -EOPNOTSUPP) {
		9351	bnxt_hwmon_close(bp);
		9352	return;
		9353	}
9346		9354
9347	if (bp->hwmon_dev)	9355	if (bp->hwmon_dev)
9348	return;	9356	return;
@@ -11779,6 +11787,10 @@ static void bnxt_remove_one(struct pci_dev *pdev) · 2430 unmodified lines
11779	if (BNXT_PF(bp))	11787	if (BNXT_PF(bp))
11780	bnxt_sriov_disable(bp);	11788	bnxt_sriov_disable(bp);
11781		11789
		11790	clear_bit(BNXT_STATE_IN_FW_RESET, &bp->state);
		11791	bnxt_cancel_sp_work(bp);
		11792	bp->sp_event = 0;
		11793
11782	bnxt_dl_fw_reporters_destroy(bp, true);	11794	bnxt_dl_fw_reporters_destroy(bp, true);
11783	if (BNXT_PF(bp))	11795	if (BNXT_PF(bp))
11784	devlink_port_type_clear(&bp->dl_port);	11796	devlink_port_type_clear(&bp->dl_port);
@@ -11786,9 +11798,6 @@ static void bnxt_remove_one(struct pci_dev *pdev) · 1 unmodified line
11786	unregister_netdev(dev);	11798	unregister_netdev(dev);
11787	bnxt_dl_unregister(bp);	11799	bnxt_dl_unregister(bp);
11788	bnxt_shutdown_tc(bp);	11800	bnxt_shutdown_tc(bp);
11789	clear_bit(BNXT_STATE_IN_FW_RESET, &bp->state);
11790	bnxt_cancel_sp_work(bp);
11791	bp->sp_event = 0;
11792		11801
11793	bnxt_clear_int_mode(bp);	11802	bnxt_clear_int_mode(bp);
11794	bnxt_hwrm_func_drv_unrgtr(bp);	11803	bnxt_hwrm_func_drv_unrgtr(bp);
@@ -12089,7 +12098,7 @@ static int bnxt_init_mac_addr(struct bnxt *bp) · 294 unmodified lines
12089	static void bnxt_vpd_read_info(struct bnxt *bp)	12098	static void bnxt_vpd_read_info(struct bnxt *bp)
12090	{	12099	{
12091	struct pci_dev *pdev = bp->pdev;	12100	struct pci_dev *pdev = bp->pdev;
12092	int i, len, pos, ro_size;	12101	int i, len, pos, ro_size, size;
12093	ssize_t vpd_size;	12102	ssize_t vpd_size;
12094	u8 *vpd_data;	12103	u8 *vpd_data;
12095		12104
@@ -12124,7 +12133,8 @@ static void bnxt_vpd_read_info(struct bnxt *bp) · 28 unmodified lines
12124	if (len + pos > vpd_size)	12133	if (len + pos > vpd_size)
12125	goto read_sn;	12134	goto read_sn;
12126		12135
12127	strlcpy(bp->board_partno, &vpd_data[pos], min(len, BNXT_VPD_FLD_LEN));	12136	size = min(len, BNXT_VPD_FLD_LEN - 1);
		12137	memcpy(bp->board_partno, &vpd_data[pos], size);
12128		12138
12129	read_sn:	12139	read_sn:
12130	pos = pci_vpd_find_info_keyword(vpd_data, i, ro_size,	12140	pos = pci_vpd_find_info_keyword(vpd_data, i, ro_size,
@@ -12137,7 +12147,8 @@ read_sn: · 6 unmodified lines
12137	if (len + pos > vpd_size)	12147	if (len + pos > vpd_size)
12138	goto exit;	12148	goto exit;
12139		12149
12140	strlcpy(bp->board_serialno, &vpd_data[pos], min(len, BNXT_VPD_FLD_LEN));	12150	size = min(len, BNXT_VPD_FLD_LEN - 1);
		12151	memcpy(bp->board_serialno, &vpd_data[pos], size);
12141	exit:	12152	exit:
12142	kfree(vpd_data);	12153	kfree(vpd_data);
12143	}	12154	}

drivers/net/ethernet/broadcom/bnxt/bnxt.h+4−0

 #define BNXT_STATE_FW_FATAL_COND	6
 #define BNXT_STATE_DRV_REGISTERED	7
+#define BNXT_NO_FW_ACCESS(bp)					\
+	(test_bit(BNXT_STATE_FW_FATAL_COND, &(bp)->state) ||	\
+	 pci_channel_offline((bp)->pdev))
 	struct bnxt_irq	*irq_tbl;
 	int			total_irqs;
 	u8			mac_addr[ETH_ALEN];

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c+23−11

@@ -1322,6 +1322,9 @@ static int bnxt_get_regs_len(struct net_device *dev) · 1321 unmodified lines
1322	struct bnxt *bp = netdev_priv(dev);	1322	struct bnxt *bp = netdev_priv(dev);
1323	int reg_len;	1323	int reg_len;
1324		1324
		1325	if (!BNXT_PF(bp))
		1326	return -EOPNOTSUPP;
		1327
1325	reg_len = BNXT_PXP_REG_LEN;	1328	reg_len = BNXT_PXP_REG_LEN;
1326		1329
1327	if (bp->fw_cap & BNXT_FW_CAP_PCIE_STATS_SUPPORTED)	1330	if (bp->fw_cap & BNXT_FW_CAP_PCIE_STATS_SUPPORTED)
@@ -1788,9 +1791,12 @@ static int bnxt_set_pauseparam(struct net_device *dev, · 460 unmodified lines
1788	if (!BNXT_PHY_CFG_ABLE(bp))	1791	if (!BNXT_PHY_CFG_ABLE(bp))
1789	return -EOPNOTSUPP;	1792	return -EOPNOTSUPP;
1790		1793
		1794	mutex_lock(&bp->link_lock);
1791	if (epause->autoneg) {	1795	if (epause->autoneg) {
1792	if (!(link_info->autoneg & BNXT_AUTONEG_SPEED))	1796	if (!(link_info->autoneg & BNXT_AUTONEG_SPEED)) {
1793	return -EINVAL;	1797	rc = -EINVAL;
		1798	goto pause_exit;
		1799	}
1794		1800
1795	link_info->autoneg \|= BNXT_AUTONEG_FLOW_CTRL;	1801	link_info->autoneg \|= BNXT_AUTONEG_FLOW_CTRL;
1796	if (bp->hwrm_spec_code >= 0x10201)	1802	if (bp->hwrm_spec_code >= 0x10201)
@@ -1811,11 +1817,11 @@ static int bnxt_set_pauseparam(struct net_device *dev, · 14 unmodified lines
1811	if (epause->tx_pause)	1817	if (epause->tx_pause)
1812	link_info->req_flow_ctrl \|= BNXT_LINK_PAUSE_TX;	1818	link_info->req_flow_ctrl \|= BNXT_LINK_PAUSE_TX;
1813		1819
1814	if (netif_running(dev)) {	1820	if (netif_running(dev))
1815	mutex_lock(&bp->link_lock);
1816	rc = bnxt_hwrm_set_pause(bp);	1821	rc = bnxt_hwrm_set_pause(bp);
1817	mutex_unlock(&bp->link_lock);	1822
1818	}	1823	pause_exit:
		1824	mutex_unlock(&bp->link_lock);
1819	return rc;	1825	return rc;
1820	}	1826	}
1821		1827
@@ -2552,8 +2558,7 @@ static int bnxt_set_eee(struct net_device dev, struct ethtool_eee edata) · 730 unmodified lines
2552	struct bnxt *bp = netdev_priv(dev);	2558	struct bnxt *bp = netdev_priv(dev);
2553	struct ethtool_eee *eee = &bp->eee;	2559	struct ethtool_eee *eee = &bp->eee;
2554	struct bnxt_link_info *link_info = &bp->link_info;	2560	struct bnxt_link_info *link_info = &bp->link_info;
2555	u32 advertising =	2561	u32 advertising;
2556	_bnxt_fw_to_ethtool_adv_spds(link_info->advertising, 0);
2557	int rc = 0;	2562	int rc = 0;
2558		2563
2559	if (!BNXT_PHY_CFG_ABLE(bp))	2564	if (!BNXT_PHY_CFG_ABLE(bp))
@@ -2562,19 +2567,23 @@ static int bnxt_set_eee(struct net_device dev, struct ethtool_eee edata) · 2 unmodified lines
2562	if (!(bp->flags & BNXT_FLAG_EEE_CAP))	2567	if (!(bp->flags & BNXT_FLAG_EEE_CAP))
2563	return -EOPNOTSUPP;	2568	return -EOPNOTSUPP;
2564		2569
		2570	mutex_lock(&bp->link_lock);
		2571	advertising = _bnxt_fw_to_ethtool_adv_spds(link_info->advertising, 0);
2565	if (!edata->eee_enabled)	2572	if (!edata->eee_enabled)
2566	goto eee_ok;	2573	goto eee_ok;
2567		2574
2568	if (!(link_info->autoneg & BNXT_AUTONEG_SPEED)) {	2575	if (!(link_info->autoneg & BNXT_AUTONEG_SPEED)) {
2569	netdev_warn(dev, "EEE requires autoneg\n");	2576	netdev_warn(dev, "EEE requires autoneg\n");
2570	return -EINVAL;	2577	rc = -EINVAL;
		2578	goto eee_exit;
2571	}	2579	}
2572	if (edata->tx_lpi_enabled) {	2580	if (edata->tx_lpi_enabled) {
2573	if (bp->lpi_tmr_hi && (edata->tx_lpi_timer > bp->lpi_tmr_hi \|\|	2581	if (bp->lpi_tmr_hi && (edata->tx_lpi_timer > bp->lpi_tmr_hi \|\|
2574	edata->tx_lpi_timer < bp->lpi_tmr_lo)) {	2582	edata->tx_lpi_timer < bp->lpi_tmr_lo)) {
2575	netdev_warn(dev, "Valid LPI timer range is %d and %d microsecs\n",	2583	netdev_warn(dev, "Valid LPI timer range is %d and %d microsecs\n",
2576	bp->lpi_tmr_lo, bp->lpi_tmr_hi);	2584	bp->lpi_tmr_lo, bp->lpi_tmr_hi);
2577	return -EINVAL;	2585	rc = -EINVAL;
		2586	goto eee_exit;
2578	} else if (!bp->lpi_tmr_hi) {	2587	} else if (!bp->lpi_tmr_hi) {
2579	edata->tx_lpi_timer = eee->tx_lpi_timer;	2588	edata->tx_lpi_timer = eee->tx_lpi_timer;
2580	}	2589	}
@@ -2584,7 +2593,8 @@ static int bnxt_set_eee(struct net_device dev, struct ethtool_eee edata) · 3 unmodified lines
2584	} else if (edata->advertised & ~advertising) {	2593	} else if (edata->advertised & ~advertising) {
2585	netdev_warn(dev, "EEE advertised %x must be a subset of autoneg advertised speeds %x\n",	2594	netdev_warn(dev, "EEE advertised %x must be a subset of autoneg advertised speeds %x\n",
2586	edata->advertised, advertising);	2595	edata->advertised, advertising);
2587	return -EINVAL;	2596	rc = -EINVAL;
		2597	goto eee_exit;
2588	}	2598	}
2589		2599
2590	eee->advertised = edata->advertised;	2600	eee->advertised = edata->advertised;
@@ -2596,6 +2606,8 @@ eee_ok: · 5 unmodified lines
2596	if (netif_running(dev))	2606	if (netif_running(dev))
2597	rc = bnxt_hwrm_set_link_setting(bp, false, true);	2607	rc = bnxt_hwrm_set_link_setting(bp, false, true);
2598		2608
		2609	eee_exit:
		2610	mutex_unlock(&bp->link_lock);
2599	return rc;	2611	return rc;
2600	}	2612	}
2601		2613

drivers/net/ethernet/cadence/macb_main.c+1−2

@@ -647,8 +647,7 @@ static void macb_mac_link_up(struct phylink_config *config, · 646 unmodified lines
647	ctrl \|= GEM_BIT(GBE);	647	ctrl \|= GEM_BIT(GBE);
648	}	648	}
649		649
650	/* We do not support MLO_PAUSE_RX yet */	650	if (rx_pause)
651	if (tx_pause)
652	ctrl \|= MACB_BIT(PAE);	651	ctrl \|= MACB_BIT(PAE);
653		652
654	macb_set_tx_clk(bp->tx_clk, speed, ndev);	653	macb_set_tx_clk(bp->tx_clk, speed, ndev);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c+6−3

 static int configure_filter_tcb(struct adapter *adap, unsigned int tid,
 				struct filter_entry *f)
 {
-	if (f->fs.hitcnts)
+	if (f->fs.hitcnts) {
 		set_tcb_field(adap, f, tid, TCB_TIMESTAMP_W,
-			      TCB_TIMESTAMP_V(TCB_TIMESTAMP_M) |
+			      TCB_TIMESTAMP_V(TCB_TIMESTAMP_M),
+			      TCB_TIMESTAMP_V(0ULL),
+			      1);
+		set_tcb_field(adap, f, tid, TCB_RTT_TS_RECENT_AGE_W,
 			      TCB_RTT_TS_RECENT_AGE_V(TCB_RTT_TS_RECENT_AGE_M),
-			      TCB_TIMESTAMP_V(0ULL) |
 			      TCB_RTT_TS_RECENT_AGE_V(0ULL),
 			      1);
+	}
 	if (f->fs.newdmac)
 		set_tcb_tflag(adap, f, tid, TF_CCTRL_ECE_S, 1,

drivers/net/ethernet/chelsio/cxgb4/cxgb4_mps.c+1−1

@@ -229,7 +229,7 @@ void cxgb4_free_mps_ref_entries(struct adapter *adap) · 228 unmodified lines
229	{	229	{
230	struct mps_entries_ref mps_entry, tmp;	230	struct mps_entries_ref mps_entry, tmp;
231		231
232	if (!list_empty(&adap->mps_ref))	232	if (list_empty(&adap->mps_ref))
233	return;	233	return;
234		234
235	spin_lock(&adap->mps_ref_lock);	235	spin_lock(&adap->mps_ref_lock);

drivers/net/ethernet/dec/tulip/de2104x.c+1−1

@@ -85,7 +85,7 @@ MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copi · 84 unmodified lines
85	#define DSL CONFIG_DE2104X_DSL	85	#define DSL CONFIG_DE2104X_DSL
86	#endif	86	#endif
87		87
88	#define DE_RX_RING_SIZE 64	88	#define DE_RX_RING_SIZE 128
89	#define DE_TX_RING_SIZE 64	89	#define DE_TX_RING_SIZE 64
90	#define DE_RING_BYTES \	90	#define DE_RING_BYTES \
91	((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \	91	((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \

drivers/net/ethernet/freescale/dpaa2/dpmac-cmd.h+2−2

@@ -66,8 +66,8 @@ struct dpmac_cmd_get_counter { · 65 unmodified lines
66	};	66	};
67		67
68	struct dpmac_rsp_get_counter {	68	struct dpmac_rsp_get_counter {
69	u64 pad;	69	__le64 pad;
70	u64 counter;	70	__le64 counter;
71	};	71	};
72		72
73	#endif /* _FSL_DPMAC_CMD_H */	73	#endif /* _FSL_DPMAC_CMD_H */

drivers/net/ethernet/freescale/enetc/enetc_pf.c+1−1

 err_reg_netdev:
 	enetc_teardown_serdes(priv);
-	enetc_mdio_remove(pf);
 	enetc_free_msix(priv);
 err_alloc_msix:
 	enetc_free_si_resources(priv);
 	si->ndev = NULL;
 	free_netdev(ndev);
 err_alloc_netdev:
+	enetc_mdio_remove(pf);
 	enetc_of_put_phy(pf);
 err_map_pf_space:
 	enetc_pci_remove(pdev);

drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c+2−2

@@ -334,7 +334,7 @@ static void hns_dsaf_xge_srst_by_port_acpi(struct dsaf_device *dsaf_dev, · 333 unmodified lines
334	* bit6-11 for ppe0-5	334	* bit6-11 for ppe0-5
335	* bit12-17 for roce0-5	335	* bit12-17 for roce0-5
336	* bit18-19 for com/dfx	336	* bit18-19 for com/dfx
337	* @enable: false - request reset , true - drop reset	337	* @dereset: false - request reset , true - drop reset
338	*/	338	*/
339	static void	339	static void
340	hns_dsaf_srst_chns(struct dsaf_device *dsaf_dev, u32 msk, bool dereset)	340	hns_dsaf_srst_chns(struct dsaf_device *dsaf_dev, u32 msk, bool dereset)
@@ -357,7 +357,7 @@ hns_dsaf_srst_chns(struct dsaf_device *dsaf_dev, u32 msk, bool dereset) · 16 unmodified lines
357	* bit6-11 for ppe0-5	357	* bit6-11 for ppe0-5
358	* bit12-17 for roce0-5	358	* bit12-17 for roce0-5
359	* bit18-19 for com/dfx	359	* bit18-19 for com/dfx
360	* @enable: false - request reset , true - drop reset	360	* @dereset: false - request reset , true - drop reset
361	*/	361	*/
362	static void	362	static void
363	hns_dsaf_srst_chns_acpi(struct dsaf_device *dsaf_dev, u32 msk, bool dereset)	363	hns_dsaf_srst_chns_acpi(struct dsaf_device *dsaf_dev, u32 msk, bool dereset)

drivers/net/ethernet/hisilicon/hns/hns_ethtool.c+20−20

@@ -463,8 +463,8 @@ static int __lb_clean_rings(struct hns_nic_priv *priv, · 462 unmodified lines
463		463
464	/**	464	/**
465	* nic_run_loopback_test - run loopback test	465	* nic_run_loopback_test - run loopback test
466	* @nic_dev: net device	466	* @ndev: net device
467	* @loopback_type: loopback type	467	* @loop_mode: loopback mode
468	*/	468	*/
469	static int __lb_run_test(struct net_device *ndev,	469	static int __lb_run_test(struct net_device *ndev,
470	enum hnae_loop loop_mode)	470	enum hnae_loop loop_mode)
@@ -572,7 +572,7 @@ static int __lb_down(struct net_device *ndev, enum hnae_loop loop) · 101 unmodified lines
572		572
573	/**	573	/**
574	* hns_nic_self_test - self test	574	* hns_nic_self_test - self test
575	* @dev: net device	575	* @ndev: net device
576	* @eth_test: test cmd	576	* @eth_test: test cmd
577	* @data: test result	577	* @data: test result
578	*/	578	*/
@@ -633,7 +633,7 @@ static void hns_nic_self_test(struct net_device *ndev, · 54 unmodified lines
633		633
634	/**	634	/**
635	* hns_nic_get_drvinfo - get net driver info	635	* hns_nic_get_drvinfo - get net driver info
636	* @dev: net device	636	* @net_dev: net device
637	* @drvinfo: driver info	637	* @drvinfo: driver info
638	*/	638	*/
639	static void hns_nic_get_drvinfo(struct net_device *net_dev,	639	static void hns_nic_get_drvinfo(struct net_device *net_dev,
@@ -658,7 +658,7 @@ static void hns_nic_get_drvinfo(struct net_device *net_dev, · 18 unmodified lines
658		658
659	/**	659	/**
660	* hns_get_ringparam - get ring parameter	660	* hns_get_ringparam - get ring parameter
661	* @dev: net device	661	* @net_dev: net device
662	* @param: ethtool parameter	662	* @param: ethtool parameter
663	*/	663	*/
664	static void hns_get_ringparam(struct net_device *net_dev,	664	static void hns_get_ringparam(struct net_device *net_dev,
@@ -683,7 +683,7 @@ static void hns_get_ringparam(struct net_device *net_dev, · 18 unmodified lines
683		683
684	/**	684	/**
685	* hns_get_pauseparam - get pause parameter	685	* hns_get_pauseparam - get pause parameter
686	* @dev: net device	686	* @net_dev: net device
687	* @param: pause parameter	687	* @param: pause parameter
688	*/	688	*/
689	static void hns_get_pauseparam(struct net_device *net_dev,	689	static void hns_get_pauseparam(struct net_device *net_dev,
@@ -701,7 +701,7 @@ static void hns_get_pauseparam(struct net_device *net_dev, · 11 unmodified lines
701		701
702	/**	702	/**
703	* hns_set_pauseparam - set pause parameter	703	* hns_set_pauseparam - set pause parameter
704	* @dev: net device	704	* @net_dev: net device
705	* @param: pause parameter	705	* @param: pause parameter
706	*	706	*
707	* Return 0 on success, negative on failure	707	* Return 0 on success, negative on failure
@@ -725,7 +725,7 @@ static int hns_set_pauseparam(struct net_device *net_dev, · 17 unmodified lines
725		725
726	/**	726	/**
727	* hns_get_coalesce - get coalesce info.	727	* hns_get_coalesce - get coalesce info.
728	* @dev: net device	728	* @net_dev: net device
729	* @ec: coalesce info.	729	* @ec: coalesce info.
730	*	730	*
731	* Return 0 on success, negative on failure.	731	* Return 0 on success, negative on failure.
@@ -769,7 +769,7 @@ static int hns_get_coalesce(struct net_device *net_dev, · 37 unmodified lines
769		769
770	/**	770	/**
771	* hns_set_coalesce - set coalesce info.	771	* hns_set_coalesce - set coalesce info.
772	* @dev: net device	772	* @net_dev: net device
773	* @ec: coalesce info.	773	* @ec: coalesce info.
774	*	774	*
775	* Return 0 on success, negative on failure.	775	* Return 0 on success, negative on failure.
@@ -808,7 +808,7 @@ static int hns_set_coalesce(struct net_device *net_dev, · 32 unmodified lines
808		808
809	/**	809	/**
810	* hns_get_channels - get channel info.	810	* hns_get_channels - get channel info.
811	* @dev: net device	811	* @net_dev: net device
812	* @ch: channel info.	812	* @ch: channel info.
813	*/	813	*/
814	static void	814	static void
@@ -825,7 +825,7 @@ hns_get_channels(struct net_device net_dev, struct ethtool_channels ch) · 10 unmodified lines
825		825
826	/**	826	/**
827	* get_ethtool_stats - get detail statistics.	827	* get_ethtool_stats - get detail statistics.
828	* @dev: net device	828	* @netdev: net device
829	* @stats: statistics info.	829	* @stats: statistics info.
830	* @data: statistics data.	830	* @data: statistics data.
831	*/	831	*/
@@ -883,8 +883,8 @@ static void hns_get_ethtool_stats(struct net_device *netdev, · 51 unmodified lines
883		883
884	/**	884	/**
885	* get_strings: Return a set of strings that describe the requested objects	885	* get_strings: Return a set of strings that describe the requested objects
886	* @dev: net device	886	* @netdev: net device
887	* @stats: string set ID.	887	* @stringset: string set ID.
888	* @data: objects data.	888	* @data: objects data.
889	*/	889	*/
890	static void hns_get_strings(struct net_device netdev, u32 stringset, u8 data)	890	static void hns_get_strings(struct net_device netdev, u32 stringset, u8 data)
@@ -972,7 +972,7 @@ static void hns_get_strings(struct net_device netdev, u32 stringset, u8 data) · 81 unmodified lines
972		972
973	/**	973	/**
974	* nic_get_sset_count - get string set count witch returned by nic_get_strings.	974	* nic_get_sset_count - get string set count witch returned by nic_get_strings.
975	* @dev: net device	975	* @netdev: net device
976	* @stringset: string set index, 0: self test string; 1: statistics string.	976	* @stringset: string set index, 0: self test string; 1: statistics string.
977	*	977	*
978	* Return string set count.	978	* Return string set count.
@@ -1006,7 +1006,7 @@ static int hns_get_sset_count(struct net_device *netdev, int stringset) · 27 unmodified lines
1006		1006
1007	/**	1007	/**
1008	* hns_phy_led_set - set phy LED status.	1008	* hns_phy_led_set - set phy LED status.
1009	* @dev: net device	1009	* @netdev: net device
1010	* @value: LED state.	1010	* @value: LED state.
1011	*	1011	*
1012	* Return 0 on success, negative on failure.	1012	* Return 0 on success, negative on failure.
@@ -1028,7 +1028,7 @@ static int hns_phy_led_set(struct net_device *netdev, int value) · 15 unmodified lines
1028		1028
1029	/**	1029	/**
1030	* nic_set_phys_id - set phy identify LED.	1030	* nic_set_phys_id - set phy identify LED.
1031	* @dev: net device	1031	* @netdev: net device
1032	* @state: LED state.	1032	* @state: LED state.
1033	*	1033	*
1034	* Return 0 on success, negative on failure.	1034	* Return 0 on success, negative on failure.
@@ -1104,9 +1104,9 @@ hns_set_phys_id(struct net_device *netdev, enum ethtool_phys_id_state state) · 69 unmodified lines
1104		1104
1105	/**	1105	/**
1106	* hns_get_regs - get net device register	1106	* hns_get_regs - get net device register
1107	* @dev: net device	1107	* @net_dev: net device
1108	* @cmd: ethtool cmd	1108	* @cmd: ethtool cmd
1109	* @date: register data	1109	* @data: register data
1110	*/	1110	*/
1111	static void hns_get_regs(struct net_device net_dev, struct ethtool_regs cmd,	1111	static void hns_get_regs(struct net_device net_dev, struct ethtool_regs cmd,
1112	void *data)	1112	void *data)
@@ -1126,7 +1126,7 @@ static void hns_get_regs(struct net_device net_dev, struct ethtool_regs cmd, · 13 unmodified lines
1126		1126
1127	/**	1127	/**
1128	* nic_get_regs_len - get total register len.	1128	* nic_get_regs_len - get total register len.
1129	* @dev: net device	1129	* @net_dev: net device
1130	*	1130	*
1131	* Return total register len.	1131	* Return total register len.
1132	*/	1132	*/
@@ -1151,7 +1151,7 @@ static int hns_get_regs_len(struct net_device *net_dev) · 18 unmodified lines
1151		1151
1152	/**	1152	/**
1153	* hns_nic_nway_reset - nway reset	1153	* hns_nic_nway_reset - nway reset
1154	* @dev: net device	1154	* @netdev: net device
1155	*	1155	*
1156	* Return 0 on success, negative on failure	1156	* Return 0 on success, negative on failure
1157	*/	1157	*/

drivers/net/ethernet/huawei/hinic/hinic_ethtool.c+4−0

 	}
 	netif_carrier_off(netdev);
+	netif_tx_disable(netdev);
 	err = do_lp_test(nic_dev, eth_test->flags, LP_DEFAULT_TIME,
 			 &test_index);
 		data[test_index] = 1;
 	}
+	netif_tx_wake_all_queues(netdev);
 	err = hinic_port_link_state(nic_dev, &link_state);
 	if (!err && link_state == HINIC_LINK_STATE_UP)
 		netif_carrier_on(netdev);
 }
 static int hinic_set_phys_id(struct net_device *netdev,

drivers/net/ethernet/huawei/hinic/hinic_hw_mgmt.c+15−5

 #define MGMT_MSG_TIMEOUT                5000
+#define SET_FUNC_PORT_MBOX_TIMEOUT	30000
 #define SET_FUNC_PORT_MGMT_TIMEOUT	25000
+#define UPDATE_FW_MGMT_TIMEOUT		20000
 #define mgmt_to_pfhwdev(pf_mgmt)        \
 		container_of(pf_mgmt, struct hinic_pfhwdev, pf_to_mgmt)
 		return -EINVAL;
 	}
-	if (cmd == HINIC_PORT_CMD_SET_FUNC_STATE)
+	if (HINIC_IS_VF(hwif)) {
-		timeout = SET_FUNC_PORT_MGMT_TIMEOUT;
+		if (cmd == HINIC_PORT_CMD_SET_FUNC_STATE)
+			timeout = SET_FUNC_PORT_MBOX_TIMEOUT;
-	if (HINIC_IS_VF(hwif))
 		return hinic_mbox_to_pf(pf_to_mgmt->hwdev, mod, cmd, buf_in,
-					in_size, buf_out, out_size, 0);
+					in_size, buf_out, out_size, timeout);
-	else
+	} else {
+		if (cmd == HINIC_PORT_CMD_SET_FUNC_STATE)
+			timeout = SET_FUNC_PORT_MGMT_TIMEOUT;
+		else if (cmd == HINIC_PORT_CMD_UPDATE_FW)
+			timeout = UPDATE_FW_MGMT_TIMEOUT;
 		return msg_to_mgmt_sync(pf_to_mgmt, mod, cmd, buf_in, in_size,
 				buf_out, out_size, MGMT_DIRECT_SEND,
 				MSG_NOT_RESP, timeout);
+	}
 }
 static void recv_mgmt_msg_work_handler(struct work_struct *work)

drivers/net/ethernet/huawei/hinic/hinic_main.c+24−0

 	return err;
 }
+static void enable_txqs_napi(struct hinic_dev *nic_dev)
+{
+	int num_txqs = hinic_hwdev_num_qps(nic_dev->hwdev);
+	int i;
+	for (i = 0; i < num_txqs; i++)
+		napi_enable(&nic_dev->txqs[i].napi);
+}
+static void disable_txqs_napi(struct hinic_dev *nic_dev)
+{
+	int num_txqs = hinic_hwdev_num_qps(nic_dev->hwdev);
+	int i;
+	for (i = 0; i < num_txqs; i++)
+		napi_disable(&nic_dev->txqs[i].napi);
+}
 /**
  * free_txqs - Free the Logical Tx Queues of specific NIC device
  * @nic_dev: the specific NIC device
 		goto err_create_txqs;
 	}
+	enable_txqs_napi(nic_dev);
 	err = create_rxqs(nic_dev);
 	if (err) {
 		netif_err(nic_dev, drv, netdev,
 	}
 err_create_rxqs:
+	disable_txqs_napi(nic_dev);
 	free_txqs(nic_dev);
 err_create_txqs:
 	struct hinic_dev *nic_dev = netdev_priv(netdev);
 	unsigned int flags;
+	/* Disable txq napi firstly to aviod rewaking txq in free_tx_poll */
+	disable_txqs_napi(nic_dev);
 	down(&nic_dev->mgmt_lock);
 	flags = nic_dev->flags;

drivers/net/ethernet/huawei/hinic/hinic_rx.c+14−7

 	if (err) {
 		netif_err(nic_dev, drv, rxq->netdev,
 			  "Failed to set RX interrupt coalescing attribute\n");
-		rx_del_napi(rxq);
+		goto err_req_irq;
-		return err;
 	}
 	err = request_irq(rq->irq, rx_irq, 0, rxq->irq_name, rxq);
-	if (err) {
+	if (err)
-		rx_del_napi(rxq);
+		goto err_req_irq;
-		return err;
-	}
 	cpumask_set_cpu(qp->q_id % num_online_cpus(), &rq->affinity_mask);
-	return irq_set_affinity_hint(rq->irq, &rq->affinity_mask);
+	err = irq_set_affinity_hint(rq->irq, &rq->affinity_mask);
+	if (err)
+		goto err_irq_affinity;
+	return 0;
+err_irq_affinity:
+	free_irq(rq->irq, rxq);
+err_req_irq:
+	rx_del_napi(rxq);
+	return err;
 }
 static void rx_free_irq(struct hinic_rxq *rxq)

drivers/net/ethernet/huawei/hinic/hinic_tx.c+6−18

@@ -717,8 +717,8 @@ static int free_tx_poll(struct napi_struct *napi, int budget) · 716 unmodified lines
717	netdev_txq = netdev_get_tx_queue(txq->netdev, qp->q_id);	717	netdev_txq = netdev_get_tx_queue(txq->netdev, qp->q_id);
718		718
719	__netif_tx_lock(netdev_txq, smp_processor_id());	719	__netif_tx_lock(netdev_txq, smp_processor_id());
720		720	if (!netif_testing(nic_dev->netdev))
721	netif_wake_subqueue(nic_dev->netdev, qp->q_id);	721	netif_wake_subqueue(nic_dev->netdev, qp->q_id);
722		722
723	__netif_tx_unlock(netdev_txq);	723	__netif_tx_unlock(netdev_txq);
724		724
@@ -745,18 +745,6 @@ static int free_tx_poll(struct napi_struct *napi, int budget) · 20 unmodified lines
745	return budget;	745	return budget;
746	}	746	}
747		747
748	static void tx_napi_add(struct hinic_txq *txq, int weight)
749	{
750	netif_napi_add(txq->netdev, &txq->napi, free_tx_poll, weight);
751	napi_enable(&txq->napi);
752	}
753
754	static void tx_napi_del(struct hinic_txq *txq)
755	{
756	napi_disable(&txq->napi);
757	netif_napi_del(&txq->napi);
758	}
759
760	static irqreturn_t tx_irq(int irq, void *data)	748	static irqreturn_t tx_irq(int irq, void *data)
761	{	749	{
762	struct hinic_txq *txq = data;	750	struct hinic_txq *txq = data;
@@ -790,7 +778,7 @@ static int tx_request_irq(struct hinic_txq *txq) · 27 unmodified lines
790		778
791	qp = container_of(sq, struct hinic_qp, sq);	779	qp = container_of(sq, struct hinic_qp, sq);
792		780
793	tx_napi_add(txq, nic_dev->tx_weight);	781	netif_napi_add(txq->netdev, &txq->napi, free_tx_poll, nic_dev->tx_weight);
794		782
795	hinic_hwdev_msix_set(nic_dev->hwdev, sq->msix_entry,	783	hinic_hwdev_msix_set(nic_dev->hwdev, sq->msix_entry,
796	TX_IRQ_NO_PENDING, TX_IRQ_NO_COALESC,	784	TX_IRQ_NO_PENDING, TX_IRQ_NO_COALESC,
@@ -807,14 +795,14 @@ static int tx_request_irq(struct hinic_txq *txq) · 10 unmodified lines
807	if (err) {	795	if (err) {
808	netif_err(nic_dev, drv, txq->netdev,	796	netif_err(nic_dev, drv, txq->netdev,
809	"Failed to set TX interrupt coalescing attribute\n");	797	"Failed to set TX interrupt coalescing attribute\n");
810	tx_napi_del(txq);	798	netif_napi_del(&txq->napi);
811	return err;	799	return err;
812	}	800	}
813		801
814	err = request_irq(sq->irq, tx_irq, 0, txq->irq_name, txq);	802	err = request_irq(sq->irq, tx_irq, 0, txq->irq_name, txq);
815	if (err) {	803	if (err) {
816	dev_err(&pdev->dev, "Failed to request Tx irq\n");	804	dev_err(&pdev->dev, "Failed to request Tx irq\n");
817	tx_napi_del(txq);	805	netif_napi_del(&txq->napi);
818	return err;	806	return err;
819	}	807	}
820		808
@@ -826,7 +814,7 @@ static void tx_free_irq(struct hinic_txq *txq) · 5 unmodified lines
826	struct hinic_sq *sq = txq->sq;	814	struct hinic_sq *sq = txq->sq;
827		815
828	free_irq(sq->irq, txq);	816	free_irq(sq->irq, txq);
829	tx_napi_del(txq);	817	netif_napi_del(&txq->napi);
830	}	818	}
831		819
832	/**	820	/**

drivers/net/ethernet/ibm/ibmvnic.c+4−2

 		} else {
 			rc = reset_tx_pools(adapter);
-			if (rc)
+			if (rc) {
 				netdev_dbg(adapter->netdev, "reset tx pools failed (%d)\n",
 						rc);
 				goto out;
+			}
 			rc = reset_rx_pools(adapter);
-			if (rc)
+			if (rc) {
 				netdev_dbg(adapter->netdev, "reset rx pools failed (%d)\n",
 						rc);
 				goto out;
+			}
 		}
 		ibmvnic_disable_irqs(adapter);
 	}

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c+16−6

 static int i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi *vsi)
 {
 	struct i40e_mac_filter *f;
-	int num_vlans = 0, bkt;
+	u16 num_vlans = 0, bkt;
 	hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) {
 		if (f->vlan >= 0 && f->vlan <= I40E_MAX_VLANID)
  *
  * Called to get number of VLANs and VLAN list present in mac_filter_hash.
  **/
-static void i40e_get_vlan_list_sync(struct i40e_vsi *vsi, int *num_vlans,
+static void i40e_get_vlan_list_sync(struct i40e_vsi *vsi, u16 *num_vlans,
-					   s16 **vlan_list)
+				    s16 **vlan_list)
 {
 	struct i40e_mac_filter *f;
 	int i = 0;
  **/
 static i40e_status
 i40e_set_vsi_promisc(struct i40e_vf *vf, u16 seid, bool multi_enable,
-		     bool unicast_enable, s16 *vl, int num_vlans)
+		     bool unicast_enable, s16 *vl, u16 num_vlans)
 {
+	i40e_status aq_ret, aq_tmp = 0;
 	struct i40e_pf *pf = vf->pf;
 	struct i40e_hw *hw = &pf->hw;
-	i40e_status aq_ret;
 	int i;
 	/* No VLAN to set promisc on, set on VSI */
 				vf->vf_id,
 				i40e_stat_str(&pf->hw, aq_ret),
 				i40e_aq_str(&pf->hw, aq_err));
+			if (!aq_tmp)
+				aq_tmp = aq_ret;
 		}
 		aq_ret = i40e_aq_set_vsi_uc_promisc_on_vlan(hw, seid,
 				vf->vf_id,
 				i40e_stat_str(&pf->hw, aq_ret),
 				i40e_aq_str(&pf->hw, aq_err));
+			if (!aq_tmp)
+				aq_tmp = aq_ret;
 		}
 	}
+	if (aq_tmp)
+		aq_ret = aq_tmp;
 	return aq_ret;
 }
 	i40e_status aq_ret = I40E_SUCCESS;
 	struct i40e_pf *pf = vf->pf;
 	struct i40e_vsi *vsi;
-	int num_vlans;
+	u16 num_vlans;
 	s16 *vl;
 	vsi = i40e_find_vsi_from_id(pf, vsi_id);

drivers/net/ethernet/intel/igc/igc.h+8−12

@@ -299,18 +299,14 @@ extern char igc_driver_name[]; · 298 unmodified lines
299	#define IGC_RX_HDR_LEN IGC_RXBUFFER_256	299	#define IGC_RX_HDR_LEN IGC_RXBUFFER_256
300		300
301	/* Transmit and receive latency (for PTP timestamps) */	301	/* Transmit and receive latency (for PTP timestamps) */
302	/* FIXME: These values were estimated using the ones that i225 has as	302	#define IGC_I225_TX_LATENCY_10 240
303	* basis, they seem to provide good numbers with ptp4l/phc2sys, but we	303	#define IGC_I225_TX_LATENCY_100 58
304	* need to confirm them.	304	#define IGC_I225_TX_LATENCY_1000 80
305	*/	305	#define IGC_I225_TX_LATENCY_2500 1325
306	#define IGC_I225_TX_LATENCY_10 9542	306	#define IGC_I225_RX_LATENCY_10 6450
307	#define IGC_I225_TX_LATENCY_100 1024	307	#define IGC_I225_RX_LATENCY_100 185
308	#define IGC_I225_TX_LATENCY_1000 178	308	#define IGC_I225_RX_LATENCY_1000 300
309	#define IGC_I225_TX_LATENCY_2500 64	309	#define IGC_I225_RX_LATENCY_2500 1485
310	#define IGC_I225_RX_LATENCY_10 20662
311	#define IGC_I225_RX_LATENCY_100 2213
312	#define IGC_I225_RX_LATENCY_1000 448
313	#define IGC_I225_RX_LATENCY_2500 160
314		310
315	/* RX and TX descriptor control thresholds.	311	/* RX and TX descriptor control thresholds.
316	* PTHRESH - MAC will consider prefetch if it has fewer than this number of	312	* PTHRESH - MAC will consider prefetch if it has fewer than this number of

drivers/net/ethernet/intel/igc/igc_ptp.c+19−0

@@ -364,6 +364,7 @@ static void igc_ptp_tx_hwtstamp(struct igc_adapter *adapter) · 363 unmodified lines
364	struct sk_buff *skb = adapter->ptp_tx_skb;	364	struct sk_buff *skb = adapter->ptp_tx_skb;
365	struct skb_shared_hwtstamps shhwtstamps;	365	struct skb_shared_hwtstamps shhwtstamps;
366	struct igc_hw *hw = &adapter->hw;	366	struct igc_hw *hw = &adapter->hw;
		367	int adjust = 0;
367	u64 regval;	368	u64 regval;
368		369
369	if (WARN_ON_ONCE(!skb))	370	if (WARN_ON_ONCE(!skb))
@@ -373,6 +374,24 @@ static void igc_ptp_tx_hwtstamp(struct igc_adapter *adapter) · 3 unmodified lines
373	regval \|= (u64)rd32(IGC_TXSTMPH) << 32;	374	regval \|= (u64)rd32(IGC_TXSTMPH) << 32;
374	igc_ptp_systim_to_hwtstamp(adapter, &shhwtstamps, regval);	375	igc_ptp_systim_to_hwtstamp(adapter, &shhwtstamps, regval);
375		376
		377	switch (adapter->link_speed) {
		378	case SPEED_10:
		379	adjust = IGC_I225_TX_LATENCY_10;
		380	break;
		381	case SPEED_100:
		382	adjust = IGC_I225_TX_LATENCY_100;
		383	break;
		384	case SPEED_1000:
		385	adjust = IGC_I225_TX_LATENCY_1000;
		386	break;
		387	case SPEED_2500:
		388	adjust = IGC_I225_TX_LATENCY_2500;
		389	break;
		390	}
		391
		392	shhwtstamps.hwtstamp =
		393	ktime_add_ns(shhwtstamps.hwtstamp, adjust);
		394
376	/* Clear the lock early before calling skb_tstamp_tx so that	395	/* Clear the lock early before calling skb_tstamp_tx so that
377	* applications are not woken up before the lock bit is clear. We use	396	* applications are not woken up before the lock bit is clear. We use
378	* a copy of the skb pointer to ensure other threads can't change it	397	* a copy of the skb pointer to ensure other threads can't change it

drivers/net/ethernet/lantiq_xrx200.c+13−8

 	}
 	if (rx < budget) {
-		napi_complete(&ch->napi);
+		if (napi_complete_done(&ch->napi, rx))
-		ltq_dma_enable_irq(&ch->dma);
+			ltq_dma_enable_irq(&ch->dma);
 	}
 	return rx;
 	net_dev->stats.tx_bytes += bytes;
 	netdev_completed_queue(ch->priv->net_dev, pkts, bytes);
+	if (netif_queue_stopped(net_dev))
+		netif_wake_queue(net_dev);
 	if (pkts < budget) {
-		napi_complete(&ch->napi);
+		if (napi_complete_done(&ch->napi, pkts))
-		ltq_dma_enable_irq(&ch->dma);
+			ltq_dma_enable_irq(&ch->dma);
 	}
 	return pkts;
 {
 	struct xrx200_chan *ch = ptr;
-	ltq_dma_disable_irq(&ch->dma);
+	if (napi_schedule_prep(&ch->napi)) {
-	ltq_dma_ack_irq(&ch->dma);
+		__napi_schedule(&ch->napi);
+		ltq_dma_disable_irq(&ch->dma);
+	}
-	napi_schedule(&ch->napi);
+	ltq_dma_ack_irq(&ch->dma);
 	return IRQ_HANDLED;
 }
 	/* setup NAPI */
 	netif_napi_add(net_dev, &priv->chan_rx.napi, xrx200_poll_rx, 32);
-	netif_napi_add(net_dev, &priv->chan_tx.napi, xrx200_tx_housekeeping, 32);
+	netif_tx_napi_add(net_dev, &priv->chan_tx.napi, xrx200_tx_housekeeping, 32);
 	platform_set_drvdata(pdev, priv);

drivers/net/ethernet/marvell/mvneta.c+7−3

 	struct skb_shared_info *sinfo = xdp_get_shared_info_from_buff(xdp);
 	int i;
-	page_pool_put_page(rxq->page_pool, virt_to_head_page(xdp->data),
-			   sync_len, napi);
 	for (i = 0; i < sinfo->nr_frags; i++)
 		page_pool_put_full_page(rxq->page_pool,
 					skb_frag_page(&sinfo->frags[i]), napi);
+	page_pool_put_page(rxq->page_pool, virt_to_head_page(xdp->data),
+			   sync_len, napi);
 }
 static int
 			mvneta_swbm_rx_frame(pp, rx_desc, rxq, &xdp_buf,
 					     &size, page, &ps);
 		} else {
-			if (unlikely(!xdp_buf.data_hard_start))
+			if (unlikely(!xdp_buf.data_hard_start)) {
+				rx_desc->buf_phys_addr = 0;
+				page_pool_put_full_page(rxq->page_pool, page,
+							true);
 				continue;
+			}
 			mvneta_swbm_add_rx_fragment(pp, rx_desc, rxq, &xdp_buf,
 						    &size, page);

drivers/net/ethernet/mellanox/mlx5/core/en.h+1−2

 	struct dim         dim; /* Dynamic Interrupt Moderation */
 	/* XDP */
-	struct bpf_prog       *xdp_prog;
+	struct bpf_prog __rcu *xdp_prog;
 	struct mlx5e_xdpsq    *xdpsq;
 	DECLARE_BITMAP(flags, 8);
 	struct page_pool      *page_pool;
 void mlx5e_update_carrier(struct mlx5e_priv *priv);
 int mlx5e_close(struct net_device *netdev);
 int mlx5e_open(struct net_device *netdev);
-void mlx5e_update_ndo_stats(struct mlx5e_priv *priv);
 void mlx5e_queue_update_stats(struct mlx5e_priv *priv);
 int mlx5e_bits_invert(unsigned long a, int size);

drivers/net/ethernet/mellanox/mlx5/core/en/monitor_stats.c+1−1

@@ -51,7 +51,7 @@ static void mlx5e_monitor_counters_work(struct work_struct *work) · 50 unmodified lines
51	monitor_counters_work);	51	monitor_counters_work);
52		52
53	mutex_lock(&priv->state_lock);	53	mutex_lock(&priv->state_lock);
54	mlx5e_update_ndo_stats(priv);	54	mlx5e_stats_update_ndo_stats(priv);
55	mutex_unlock(&priv->state_lock);	55	mutex_unlock(&priv->state_lock);
56	mlx5e_monitor_counter_arm(priv);	56	mlx5e_monitor_counter_arm(priv);
57	}	57	}

drivers/net/ethernet/mellanox/mlx5/core/en/port.c+2−5

 	int err;
 	int i;
-	if (!MLX5_CAP_GEN(dev, pcam_reg))
+	if (!MLX5_CAP_GEN(dev, pcam_reg) || !MLX5_CAP_PCAM_REG(dev, pplm))
-		return -EOPNOTSUPP;
+		return false;
-	if (!MLX5_CAP_PCAM_REG(dev, pplm))
-		return -EOPNOTSUPP;
 	MLX5_SET(pplm_reg, in, local_port, 1);
 	err =  mlx5_core_access_reg(dev, in, sz, out, sz, MLX5_REG_PPLM, 0, 0);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c+16−5

 err_rule:
 	mlx5e_mod_hdr_detach(ct_priv->esw->dev,
 			     &esw->offloads.mod_hdr, zone_rule->mh);
+	mapping_remove(ct_priv->labels_mapping, attr->ct_attr.ct_labels_id);
 err_mod_hdr:
 	kfree(spec);
 	return err;
 	return 0;
 }
+void mlx5_tc_ct_match_del(struct mlx5e_priv *priv, struct mlx5_ct_attr *ct_attr)
+{
+	struct mlx5_tc_ct_priv *ct_priv = mlx5_tc_ct_get_ct_priv(priv);
+	if (!ct_priv || !ct_attr->ct_labels_id)
+		return;
+	mapping_remove(ct_priv->labels_mapping, ct_attr->ct_labels_id);
+}
 int
-mlx5_tc_ct_parse_match(struct mlx5e_priv *priv,
+mlx5_tc_ct_match_add(struct mlx5e_priv *priv,
-		       struct mlx5_flow_spec *spec,
+		     struct mlx5_flow_spec *spec,
-		       struct flow_cls_offload *f,
+		     struct flow_cls_offload *f,
-		       struct mlx5_ct_attr *ct_attr,
+		     struct mlx5_ct_attr *ct_attr,
-		       struct netlink_ext_ack *extack)
+		     struct netlink_ext_ack *extack)
 {
 	struct mlx5_tc_ct_priv *ct_priv = mlx5_tc_ct_get_ct_priv(priv);
 	struct flow_rule *rule = flow_cls_offload_flow_rule(f);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.h+16−10

 void
 mlx5_tc_ct_clean(struct mlx5_rep_uplink_priv *uplink_priv);
+void
+mlx5_tc_ct_match_del(struct mlx5e_priv *priv, struct mlx5_ct_attr *ct_attr);
 int
-mlx5_tc_ct_parse_match(struct mlx5e_priv *priv,
+mlx5_tc_ct_match_add(struct mlx5e_priv *priv,
-		       struct mlx5_flow_spec *spec,
+		     struct mlx5_flow_spec *spec,
-		       struct flow_cls_offload *f,
+		     struct flow_cls_offload *f,
-		       struct mlx5_ct_attr *ct_attr,
+		     struct mlx5_ct_attr *ct_attr,
-		       struct netlink_ext_ack *extack);
+		     struct netlink_ext_ack *extack);
 int
 mlx5_tc_ct_add_no_trk_match(struct mlx5e_priv *priv,
 			    struct mlx5_flow_spec *spec);
 {
 }
+static inline void
+mlx5_tc_ct_match_del(struct mlx5e_priv *priv, struct mlx5_ct_attr *ct_attr) {}
 static inline int
-mlx5_tc_ct_parse_match(struct mlx5e_priv *priv,
+mlx5_tc_ct_match_add(struct mlx5e_priv *priv,
-		       struct mlx5_flow_spec *spec,
+		     struct mlx5_flow_spec *spec,
-		       struct flow_cls_offload *f,
+		     struct flow_cls_offload *f,
-		       struct mlx5_ct_attr *ct_attr,
+		     struct mlx5_ct_attr *ct_attr,
-		       struct netlink_ext_ack *extack)
+		     struct netlink_ext_ack *extack)
 {
 	struct flow_rule *rule = flow_cls_offload_flow_rule(f);

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h+5−0

 };
 /* General */
+static inline bool mlx5e_skb_is_multicast(struct sk_buff *skb)
+{
+	return skb->pkt_type == PACKET_MULTICAST || skb->pkt_type == PACKET_BROADCAST;
+}
 void mlx5e_trigger_irq(struct mlx5e_icosq *sq);
 void mlx5e_completion_event(struct mlx5_core_cq *mcq, struct mlx5_eqe *eqe);
 void mlx5e_cq_error_event(struct mlx5_core_cq *mcq, enum mlx5_event event);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c+1−1

@@ -122,7 +122,7 @@ mlx5e_xmit_xdp_buff(struct mlx5e_xdpsq sq, struct mlx5e_rq rq, · 121 unmodified lines
122	bool mlx5e_xdp_handle(struct mlx5e_rq rq, struct mlx5e_dma_info di,	122	bool mlx5e_xdp_handle(struct mlx5e_rq rq, struct mlx5e_dma_info di,
123	u32 len, struct xdp_buff xdp)	123	u32 len, struct xdp_buff xdp)
124	{	124	{
125	struct bpf_prog *prog = READ_ONCE(rq->xdp_prog);	125	struct bpf_prog *prog = rcu_dereference(rq->xdp_prog);
126	u32 act;	126	u32 act;
127	int err;	127	int err;
128		128

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/rx.c+2−12

 {
 	struct xdp_buff *xdp = wi->umr.dma_info[page_idx].xsk;
 	u32 cqe_bcnt32 = cqe_bcnt;
-	bool consumed;
 	/* Check packet size. Note LRO doesn't use linear SKB */
 	if (unlikely(cqe_bcnt > rq->hw_mtu)) {
 	xsk_buff_dma_sync_for_cpu(xdp);
 	prefetch(xdp->data);
-	rcu_read_lock();
-	consumed = mlx5e_xdp_handle(rq, NULL, &cqe_bcnt32, xdp);
-	rcu_read_unlock();
 	/* Possible flows:
 	 * - XDP_REDIRECT to XSKMAP:
 	 *   The page is owned by the userspace from now.
 	 * allocated first from the Reuse Ring, so it has enough space.
 	 */
-	if (likely(consumed)) {
+	if (likely(mlx5e_xdp_handle(rq, NULL, &cqe_bcnt32, xdp))) {
 		if (likely(__test_and_clear_bit(MLX5E_RQ_FLAG_XDP_XMIT, rq->flags)))
 			__set_bit(page_idx, wi->xdp_xmit_bitmap); /* non-atomic */
 		return NULL; /* page/packet was consumed by XDP */
 					      u32 cqe_bcnt)
 {
 	struct xdp_buff *xdp = wi->di->xsk;
-	bool consumed;
 	/* wi->offset is not used in this function, because xdp->data and the
 	 * DMA address point directly to the necessary place. Furthermore, the
 		return NULL;
 	}
-	rcu_read_lock();
+	if (likely(mlx5e_xdp_handle(rq, NULL, &cqe_bcnt, xdp)))
-	consumed = mlx5e_xdp_handle(rq, NULL, &cqe_bcnt, xdp);
-	rcu_read_unlock();
-	if (likely(consumed))
 		return NULL; /* page/packet was consumed by XDP */
 	/* XDP_PASS: copy the data from the UMEM to a new SKB. The frame reuse

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/setup.c+1−2

@@ -106,8 +106,7 @@ err_free_cparam: · 105 unmodified lines
106	void mlx5e_close_xsk(struct mlx5e_channel *c)	106	void mlx5e_close_xsk(struct mlx5e_channel *c)
107	{	107	{
108	clear_bit(MLX5E_CHANNEL_STATE_XSK, c->state);	108	clear_bit(MLX5E_CHANNEL_STATE_XSK, c->state);
109	napi_synchronize(&c->napi);	109	synchronize_rcu(); /* Sync with the XSK wakeup and with NAPI. */
110	synchronize_rcu(); /* Sync with the XSK wakeup. */
111		110
112	mlx5e_close_rq(&c->xskrq);	111	mlx5e_close_rq(&c->xskrq);
113	mlx5e_close_cq(&c->xskrq.cq);	112	mlx5e_close_cq(&c->xskrq.cq);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_rx.c+22−21

@@ -234,7 +234,7 @@ mlx5e_get_ktls_rx_priv_ctx(struct tls_context *tls_ctx) · 233 unmodified lines
234		234
235	/* Re-sync */	235	/* Re-sync */
236	/* Runs in work context */	236	/* Runs in work context */
237	static struct mlx5_wqe_ctrl_seg *	237	static int
238	resync_post_get_progress_params(struct mlx5e_icosq *sq,	238	resync_post_get_progress_params(struct mlx5e_icosq *sq,
239	struct mlx5e_ktls_offload_context_rx *priv_rx)	239	struct mlx5e_ktls_offload_context_rx *priv_rx)
240	{	240	{
@@ -258,15 +258,19 @@ resync_post_get_progress_params(struct mlx5e_icosq *sq, · 17 unmodified lines
258	PROGRESS_PARAMS_PADDED_SIZE, DMA_FROM_DEVICE);	258	PROGRESS_PARAMS_PADDED_SIZE, DMA_FROM_DEVICE);
259	if (unlikely(dma_mapping_error(pdev, buf->dma_addr))) {	259	if (unlikely(dma_mapping_error(pdev, buf->dma_addr))) {
260	err = -ENOMEM;	260	err = -ENOMEM;
261	goto err_out;	261	goto err_free;
262	}	262	}
263		263
264	buf->priv_rx = priv_rx;	264	buf->priv_rx = priv_rx;
265		265
266	BUILD_BUG_ON(MLX5E_KTLS_GET_PROGRESS_WQEBBS != 1);	266	BUILD_BUG_ON(MLX5E_KTLS_GET_PROGRESS_WQEBBS != 1);
		267
		268	spin_lock(&sq->channel->async_icosq_lock);
		269
267	if (unlikely(!mlx5e_wqc_has_room_for(&sq->wq, sq->cc, sq->pc, 1))) {	270	if (unlikely(!mlx5e_wqc_has_room_for(&sq->wq, sq->cc, sq->pc, 1))) {
		271	spin_unlock(&sq->channel->async_icosq_lock);
268	err = -ENOSPC;	272	err = -ENOSPC;
269	goto err_out;	273	goto err_dma_unmap;
270	}	274	}
271		275
272	pi = mlx5e_icosq_get_next_pi(sq, 1);	276	pi = mlx5e_icosq_get_next_pi(sq, 1);
@@ -294,12 +298,18 @@ resync_post_get_progress_params(struct mlx5e_icosq *sq, · 21 unmodified lines
294	};	298	};
295	icosq_fill_wi(sq, pi, &wi);	299	icosq_fill_wi(sq, pi, &wi);
296	sq->pc++;	300	sq->pc++;
		301	mlx5e_notify_hw(&sq->wq, sq->pc, sq->uar_map, cseg);
		302	spin_unlock(&sq->channel->async_icosq_lock);
297		303
298	return cseg;	304	return 0;
299		305
		306	err_dma_unmap:
		307	dma_unmap_single(pdev, buf->dma_addr, PROGRESS_PARAMS_PADDED_SIZE, DMA_FROM_DEVICE);
		308	err_free:
		309	kfree(buf);
300	err_out:	310	err_out:
301	priv_rx->stats->tls_resync_req_skip++;	311	priv_rx->stats->tls_resync_req_skip++;
302	return ERR_PTR(err);	312	return err;
303	}	313	}
304		314
305	/* Function is called with elevated refcount.	315	/* Function is called with elevated refcount.
@@ -309,10 +319,8 @@ static void resync_handle_work(struct work_struct *work) · 3 unmodified lines
309	{	319	{
310	struct mlx5e_ktls_offload_context_rx *priv_rx;	320	struct mlx5e_ktls_offload_context_rx *priv_rx;
311	struct mlx5e_ktls_rx_resync_ctx *resync;	321	struct mlx5e_ktls_rx_resync_ctx *resync;
312	struct mlx5_wqe_ctrl_seg *cseg;
313	struct mlx5e_channel *c;	322	struct mlx5e_channel *c;
314	struct mlx5e_icosq *sq;	323	struct mlx5e_icosq *sq;
315	struct mlx5_wq_cyc *wq;
316		324
317	resync = container_of(work, struct mlx5e_ktls_rx_resync_ctx, work);	325	resync = container_of(work, struct mlx5e_ktls_rx_resync_ctx, work);
318	priv_rx = container_of(resync, struct mlx5e_ktls_offload_context_rx, resync);	326	priv_rx = container_of(resync, struct mlx5e_ktls_offload_context_rx, resync);
@@ -324,18 +332,9 @@ static void resync_handle_work(struct work_struct *work) · 5 unmodified lines
324		332
325	c = resync->priv->channels.c[priv_rx->rxq];	333	c = resync->priv->channels.c[priv_rx->rxq];
326	sq = &c->async_icosq;	334	sq = &c->async_icosq;
327	wq = &sq->wq;
328
329	spin_lock(&c->async_icosq_lock);
330		335
331	cseg = resync_post_get_progress_params(sq, priv_rx);	336	if (resync_post_get_progress_params(sq, priv_rx))
332	if (IS_ERR(cseg)) {
333	refcount_dec(&resync->refcnt);	337	refcount_dec(&resync->refcnt);
334	goto unlock;
335	}
336	mlx5e_notify_hw(wq, sq->pc, sq->uar_map, cseg);
337	unlock:
338	spin_unlock(&c->async_icosq_lock);
339	}	338	}
340		339
341	static void resync_init(struct mlx5e_ktls_rx_resync_ctx *resync,	340	static void resync_init(struct mlx5e_ktls_rx_resync_ctx *resync,
@@ -386,16 +385,17 @@ void mlx5e_ktls_handle_get_psv_completion(struct mlx5e_icosq_wqe_info *wi, · 44 unmodified lines
386	struct mlx5e_ktls_offload_context_rx *priv_rx;	385	struct mlx5e_ktls_offload_context_rx *priv_rx;
387	struct mlx5e_ktls_rx_resync_ctx *resync;	386	struct mlx5e_ktls_rx_resync_ctx *resync;
388	u8 tracker_state, auth_state, *ctx;	387	u8 tracker_state, auth_state, *ctx;
		388	struct device *dev;
389	u32 hw_seq;	389	u32 hw_seq;
390		390
391	priv_rx = buf->priv_rx;	391	priv_rx = buf->priv_rx;
392	resync = &priv_rx->resync;	392	resync = &priv_rx->resync;
393		393	dev = resync->priv->mdev->device;
394	if (unlikely(test_bit(MLX5E_PRIV_RX_FLAG_DELETING, priv_rx->flags)))	394	if (unlikely(test_bit(MLX5E_PRIV_RX_FLAG_DELETING, priv_rx->flags)))
395	goto out;	395	goto out;
396		396
397	dma_sync_single_for_cpu(resync->priv->mdev->device, buf->dma_addr,	397	dma_sync_single_for_cpu(dev, buf->dma_addr, PROGRESS_PARAMS_PADDED_SIZE,
398	PROGRESS_PARAMS_PADDED_SIZE, DMA_FROM_DEVICE);	398	DMA_FROM_DEVICE);
399		399
400	ctx = buf->progress.ctx;	400	ctx = buf->progress.ctx;
401	tracker_state = MLX5_GET(tls_progress_params, ctx, record_tracker_state);	401	tracker_state = MLX5_GET(tls_progress_params, ctx, record_tracker_state);
@@ -411,6 +411,7 @@ void mlx5e_ktls_handle_get_psv_completion(struct mlx5e_icosq_wqe_info *wi, · 9 unmodified lines
411	priv_rx->stats->tls_resync_req_end++;	411	priv_rx->stats->tls_resync_req_end++;
412	out:	412	out:
413	refcount_dec(&resync->refcnt);	413	refcount_dec(&resync->refcnt);
		414	dma_unmap_single(dev, buf->dma_addr, PROGRESS_PARAMS_PADDED_SIZE, DMA_FROM_DEVICE);
414	kfree(buf);	415	kfree(buf);
415	}	416	}
416		417
@@ -659,7 +660,7 @@ void mlx5e_ktls_del_rx(struct net_device netdev, struct tls_context tls_ctx) · 242 unmodified lines
659	priv_rx = mlx5e_get_ktls_rx_priv_ctx(tls_ctx);	660	priv_rx = mlx5e_get_ktls_rx_priv_ctx(tls_ctx);
660	set_bit(MLX5E_PRIV_RX_FLAG_DELETING, priv_rx->flags);	661	set_bit(MLX5E_PRIV_RX_FLAG_DELETING, priv_rx->flags);
661	mlx5e_set_ktls_rx_priv_ctx(tls_ctx, NULL);	662	mlx5e_set_ktls_rx_priv_ctx(tls_ctx, NULL);
662	napi_synchronize(&priv->channels.c[priv_rx->rxq]->napi);	663	synchronize_rcu(); /* Sync with NAPI */
663	if (!cancel_work_sync(&priv_rx->rule.work))	664	if (!cancel_work_sync(&priv_rx->rule.work))
664	/* completion is needed, as the priv_rx in the add flow	665	/* completion is needed, as the priv_rx in the add flow
665	* is maintained on the wqe info (wi), not on the socket.	666	* is maintained on the wqe info (wi), not on the socket.

drivers/net/ethernet/mellanox/mlx5/core/en_accel/tls_stats.c+8−4

 #include <net/sock.h>
 #include "en.h"
-#include "accel/tls.h"
 #include "fpga/sdk.h"
 #include "en_accel/tls.h"
 #define NUM_TLS_SW_COUNTERS ARRAY_SIZE(mlx5e_tls_sw_stats_desc)
+static bool is_tls_atomic_stats(struct mlx5e_priv *priv)
+{
+	return priv->tls && !mlx5_accel_is_ktls_device(priv->mdev);
+}
 int mlx5e_tls_get_count(struct mlx5e_priv *priv)
 {
-	if (!priv->tls)
+	if (!is_tls_atomic_stats(priv))
 		return 0;
 	return NUM_TLS_SW_COUNTERS;
 {
 	unsigned int i, idx = 0;
-	if (!priv->tls)
+	if (!is_tls_atomic_stats(priv))
 		return 0;
 	for (i = 0; i < NUM_TLS_SW_COUNTERS; i++)
 {
 	int i, idx = 0;
-	if (!priv->tls)
+	if (!is_tls_atomic_stats(priv))
 		return 0;
 	for (i = 0; i < NUM_TLS_SW_COUNTERS; i++)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+31−54

 	mutex_unlock(&priv->state_lock);
 }
-void mlx5e_update_ndo_stats(struct mlx5e_priv *priv)
-{
-	int i;
-	for (i = mlx5e_nic_stats_grps_num(priv) - 1; i >= 0; i--)
-		if (mlx5e_nic_stats_grps[i]->update_stats_mask &
-		    MLX5E_NDO_UPDATE_STATS)
-			mlx5e_nic_stats_grps[i]->update_stats(priv);
-}
 static void mlx5e_update_stats_work(struct work_struct *work)
 {
 	struct mlx5e_priv *priv = container_of(work, struct mlx5e_priv,
 	if (params->xdp_prog)
 		bpf_prog_inc(params->xdp_prog);
-	rq->xdp_prog = params->xdp_prog;
+	RCU_INIT_POINTER(rq->xdp_prog, params->xdp_prog);
 	rq_xdp_ix = rq->ix;
 	if (xsk)
 	if (err < 0)
 		goto err_rq_wq_destroy;
-	rq->buff.map_dir = rq->xdp_prog ? DMA_BIDIRECTIONAL : DMA_FROM_DEVICE;
+	rq->buff.map_dir = params->xdp_prog ? DMA_BIDIRECTIONAL : DMA_FROM_DEVICE;
 	rq->buff.headroom = mlx5e_get_rq_headroom(mdev, params, xsk);
 	pool_size = 1 << params->log_rq_mtu_frames;
 	}
 err_rq_wq_destroy:
-	if (rq->xdp_prog)
+	if (params->xdp_prog)
-		bpf_prog_put(rq->xdp_prog);
+		bpf_prog_put(params->xdp_prog);
 	xdp_rxq_info_unreg(&rq->xdp_rxq);
 	page_pool_destroy(rq->page_pool);
 	mlx5_wq_destroy(&rq->wq_ctrl);
 static void mlx5e_free_rq(struct mlx5e_rq *rq)
 {
+	struct mlx5e_channel *c = rq->channel;
+	struct bpf_prog *old_prog = NULL;
 	int i;
-	if (rq->xdp_prog)
+	/* drop_rq has neither channel nor xdp_prog. */
-		bpf_prog_put(rq->xdp_prog);
+	if (c)
+		old_prog = rcu_dereference_protected(rq->xdp_prog,
+						     lockdep_is_held(&c->priv->state_lock));
+	if (old_prog)
+		bpf_prog_put(old_prog);
 	switch (rq->wq_type) {
 	case MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ:
 void mlx5e_deactivate_rq(struct mlx5e_rq *rq)
 {
 	clear_bit(MLX5E_RQ_STATE_ENABLED, &rq->state);
-	napi_synchronize(&rq->channel->napi); /* prevent mlx5e_post_rx_wqes */
+	synchronize_rcu(); /* Sync with NAPI to prevent mlx5e_post_rx_wqes. */
 }
 void mlx5e_close_rq(struct mlx5e_rq *rq)
 static void mlx5e_deactivate_txqsq(struct mlx5e_txqsq *sq)
 {
-	struct mlx5e_channel *c = sq->channel;
 	struct mlx5_wq_cyc *wq = &sq->wq;
 	clear_bit(MLX5E_SQ_STATE_ENABLED, &sq->state);
-	/* prevent netif_tx_wake_queue */
+	synchronize_rcu(); /* Sync with NAPI to prevent netif_tx_wake_queue. */
-	napi_synchronize(&c->napi);
 	mlx5e_tx_disable_queue(sq->txq);
 void mlx5e_deactivate_icosq(struct mlx5e_icosq *icosq)
 {
-	struct mlx5e_channel *c = icosq->channel;
 	clear_bit(MLX5E_SQ_STATE_ENABLED, &icosq->state);
-	napi_synchronize(&c->napi);
+	synchronize_rcu(); /* Sync with NAPI. */
 }
 void mlx5e_close_icosq(struct mlx5e_icosq *sq)
 	struct mlx5e_channel *c = sq->channel;
 	clear_bit(MLX5E_SQ_STATE_ENABLED, &sq->state);
-	napi_synchronize(&c->napi);
+	synchronize_rcu(); /* Sync with NAPI. */
 	mlx5e_destroy_sq(c->mdev, sq->sqn);
 	mlx5e_free_xdpsq_descs(sq);
 		s->rx_packets   += rq_stats->packets + xskrq_stats->packets;
 		s->rx_bytes     += rq_stats->bytes + xskrq_stats->bytes;
+		s->multicast    += rq_stats->mcast_packets + xskrq_stats->mcast_packets;
 		for (j = 0; j < priv->max_opened_tc; j++) {
 			struct mlx5e_sq_stats *sq_stats = &channel_stats->sq[j];
 mlx5e_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats)
 {
 	struct mlx5e_priv *priv = netdev_priv(dev);
-	struct mlx5e_vport_stats *vstats = &priv->stats.vport;
 	struct mlx5e_pport_stats *pstats = &priv->stats.pport;
 	/* In switchdev mode, monitor counters doesn't monitor
 	stats->rx_errors = stats->rx_length_errors + stats->rx_crc_errors +
 			   stats->rx_frame_errors;
 	stats->tx_errors = stats->tx_aborted_errors + stats->tx_carrier_errors;
-	/* vport multicast also counts packets that are dropped due to steering
-	 * or rx out of buffer
-	 */
-	stats->multicast =
-		VPORT_COUNTER_GET(vstats, received_eth_multicast.packets);
 }
 static void mlx5e_set_rx_mode(struct net_device *dev)
 	return 0;
 }
+static void mlx5e_rq_replace_xdp_prog(struct mlx5e_rq *rq, struct bpf_prog *prog)
+{
+	struct bpf_prog *old_prog;
+	old_prog = rcu_replace_pointer(rq->xdp_prog, prog,
+				       lockdep_is_held(&rq->channel->priv->state_lock));
+	if (old_prog)
+		bpf_prog_put(old_prog);
+}
 static int mlx5e_xdp_set(struct net_device *netdev, struct bpf_prog *prog)
 {
 	struct mlx5e_priv *priv = netdev_priv(netdev);
 	 */
 	for (i = 0; i < priv->channels.num; i++) {
 		struct mlx5e_channel *c = priv->channels.c[i];
-		bool xsk_open = test_bit(MLX5E_CHANNEL_STATE_XSK, c->state);
-		clear_bit(MLX5E_RQ_STATE_ENABLED, &c->rq.state);
-		if (xsk_open)
-			clear_bit(MLX5E_RQ_STATE_ENABLED, &c->xskrq.state);
-		napi_synchronize(&c->napi);
-		/* prevent mlx5e_poll_rx_cq from accessing rq->xdp_prog */
-		old_prog = xchg(&c->rq.xdp_prog, prog);
-		if (old_prog)
-			bpf_prog_put(old_prog);
-		if (xsk_open) {
-			old_prog = xchg(&c->xskrq.xdp_prog, prog);
-			if (old_prog)
-				bpf_prog_put(old_prog);
-		}
-		set_bit(MLX5E_RQ_STATE_ENABLED, &c->rq.state);
+		mlx5e_rq_replace_xdp_prog(&c->rq, prog);
-		if (xsk_open)
+		if (test_bit(MLX5E_CHANNEL_STATE_XSK, c->state))
-			set_bit(MLX5E_RQ_STATE_ENABLED, &c->xskrq.state);
+			mlx5e_rq_replace_xdp_prog(&c->xskrq, prog);
-		/* napi_schedule in case we have missed anything */
-		napi_schedule(&c->napi);
 	}
 unlock:
 	.enable		   = mlx5e_nic_enable,
 	.disable	   = mlx5e_nic_disable,
 	.update_rx	   = mlx5e_update_nic_rx,
-	.update_stats	   = mlx5e_update_ndo_stats,
+	.update_stats	   = mlx5e_stats_update_ndo_stats,
 	.update_carrier	   = mlx5e_update_carrier,
 	.rx_handlers       = &mlx5e_rx_handlers_nic,
 	.max_tc		   = MLX5E_MAX_NUM_TC,

drivers/net/ethernet/mellanox/mlx5/core/en_rep.c+2−2

@@ -1171,7 +1171,7 @@ static const struct mlx5e_profile mlx5e_rep_profile = { · 1170 unmodified lines
1171	.cleanup_tx = mlx5e_cleanup_rep_tx,	1171	.cleanup_tx = mlx5e_cleanup_rep_tx,
1172	.enable = mlx5e_rep_enable,	1172	.enable = mlx5e_rep_enable,
1173	.update_rx = mlx5e_update_rep_rx,	1173	.update_rx = mlx5e_update_rep_rx,
1174	.update_stats = mlx5e_update_ndo_stats,	1174	.update_stats = mlx5e_stats_update_ndo_stats,
1175	.rx_handlers = &mlx5e_rx_handlers_rep,	1175	.rx_handlers = &mlx5e_rx_handlers_rep,
1176	.max_tc = 1,	1176	.max_tc = 1,
1177	.rq_groups = MLX5E_NUM_RQ_GROUPS(REGULAR),	1177	.rq_groups = MLX5E_NUM_RQ_GROUPS(REGULAR),
@@ -1189,7 +1189,7 @@ static const struct mlx5e_profile mlx5e_uplink_rep_profile = { · 11 unmodified lines
1189	.enable = mlx5e_uplink_rep_enable,	1189	.enable = mlx5e_uplink_rep_enable,
1190	.disable = mlx5e_uplink_rep_disable,	1190	.disable = mlx5e_uplink_rep_disable,
1191	.update_rx = mlx5e_update_rep_rx,	1191	.update_rx = mlx5e_update_rep_rx,
1192	.update_stats = mlx5e_update_ndo_stats,	1192	.update_stats = mlx5e_stats_update_ndo_stats,
1193	.update_carrier = mlx5e_update_carrier,	1193	.update_carrier = mlx5e_update_carrier,
1194	.rx_handlers = &mlx5e_rx_handlers_rep,	1194	.rx_handlers = &mlx5e_rx_handlers_rep,
1195	.max_tc = MLX5E_MAX_NUM_TC,	1195	.max_tc = MLX5E_MAX_NUM_TC,

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c+6−10

 #include "en/xsk/rx.h"
 #include "en/health.h"
 #include "en/params.h"
+#include "en/txrx.h"
 static struct sk_buff *
 mlx5e_skb_from_cqe_mpwrq_linear(struct mlx5e_rq *rq, struct mlx5e_mpw_info *wi,
 		mlx5e_enable_ecn(rq, skb);
 	skb->protocol = eth_type_trans(skb, netdev);
+	if (unlikely(mlx5e_skb_is_multicast(skb)))
+		stats->mcast_packets++;
 }
 static inline void mlx5e_complete_rx_cqe(struct mlx5e_rq *rq,
 	struct xdp_buff xdp;
 	struct sk_buff *skb;
 	void *va, *data;
-	bool consumed;
 	u32 frag_size;
 	va             = page_address(di->page) + wi->offset;
 	prefetchw(va); /* xdp_frame data area */
 	prefetch(data);
-	rcu_read_lock();
 	mlx5e_fill_xdp_buff(rq, va, rx_headroom, cqe_bcnt, &xdp);
-	consumed = mlx5e_xdp_handle(rq, di, &cqe_bcnt, &xdp);
+	if (mlx5e_xdp_handle(rq, di, &cqe_bcnt, &xdp))
-	rcu_read_unlock();
-	if (consumed)
 		return NULL; /* page/packet was consumed by XDP */
 	rx_headroom = xdp.data - xdp.data_hard_start;
 	struct sk_buff *skb;
 	void *va, *data;
 	u32 frag_size;
-	bool consumed;
 	/* Check packet size. Note LRO doesn't use linear SKB */
 	if (unlikely(cqe_bcnt > rq->hw_mtu)) {
 	prefetchw(va); /* xdp_frame data area */
 	prefetch(data);
-	rcu_read_lock();
 	mlx5e_fill_xdp_buff(rq, va, rx_headroom, cqe_bcnt32, &xdp);
-	consumed = mlx5e_xdp_handle(rq, di, &cqe_bcnt32, &xdp);
+	if (mlx5e_xdp_handle(rq, di, &cqe_bcnt32, &xdp)) {
-	rcu_read_unlock();
-	if (consumed) {
 		if (__test_and_clear_bit(MLX5E_RQ_FLAG_XDP_XMIT, rq->flags))
 			__set_bit(page_idx, wi->xdp_xmit_bitmap); /* non-atomic */
 		return NULL; /* page/packet was consumed by XDP */

drivers/net/ethernet/mellanox/mlx5/core/en_stats.c+12−0

@@ -54,6 +54,18 @@ unsigned int mlx5e_stats_total_num(struct mlx5e_priv *priv) · 53 unmodified lines
54	return total;	54	return total;
55	}	55	}
56		56
		57	void mlx5e_stats_update_ndo_stats(struct mlx5e_priv *priv)
		58	{
		59	mlx5e_stats_grp_t *stats_grps = priv->profile->stats_grps;
		60	const unsigned int num_stats_grps = stats_grps_num(priv);
		61	int i;
		62
		63	for (i = num_stats_grps - 1; i >= 0; i--)
		64	if (stats_grps[i]->update_stats &&
		65	stats_grps[i]->update_stats_mask & MLX5E_NDO_UPDATE_STATS)
		66	stats_grps[i]->update_stats(priv);
		67	}
		68
57	void mlx5e_stats_update(struct mlx5e_priv *priv)	69	void mlx5e_stats_update(struct mlx5e_priv *priv)
58	{	70	{
59	mlx5e_stats_grp_t *stats_grps = priv->profile->stats_grps;	71	mlx5e_stats_grp_t *stats_grps = priv->profile->stats_grps;

drivers/net/ethernet/mellanox/mlx5/core/en_stats.h+3−0

 void mlx5e_stats_update(struct mlx5e_priv *priv);
 void mlx5e_stats_fill(struct mlx5e_priv *priv, u64 *data, int idx);
 void mlx5e_stats_fill_strings(struct mlx5e_priv *priv, u8 *data);
+void mlx5e_stats_update_ndo_stats(struct mlx5e_priv *priv);
 /* Concrete NIC Stats */
 	u64 tx_nop;
 	u64 rx_lro_packets;
 	u64 rx_lro_bytes;
+	u64 rx_mcast_packets;
 	u64 rx_ecn_mark;
 	u64 rx_removed_vlan_packets;
 	u64 rx_csum_unnecessary;
 	u64 csum_none;
 	u64 lro_packets;
 	u64 lro_bytes;
+	u64 mcast_packets;
 	u64 ecn_mark;
 	u64 removed_vlan_packets;
 	u64 xdp_drop;

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+26−19

 	mlx5e_put_flow_tunnel_id(flow);
-	if (flow_flag_test(flow, NOT_READY)) {
+	if (flow_flag_test(flow, NOT_READY))
 		remove_unready_flow(flow);
-		kvfree(attr->parse_attr);
-		return;
-	}
 	if (mlx5e_is_offloaded_flow(flow)) {
 		if (flow_flag_test(flow, SLOW))
 		}
 	kvfree(attr->parse_attr);
+	mlx5_tc_ct_match_del(priv, &flow->esw_attr->ct_attr);
 	if (attr->action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)
 		mlx5e_detach_mod_hdr(priv, flow);
 	OFFLOAD(UDP_DPORT, 16, U16_MAX, udp.dest,   0, udp_dport),
 };
+static unsigned long mask_to_le(unsigned long mask, int size)
+{
+	__be32 mask_be32;
+	__be16 mask_be16;
+	if (size == 32) {
+		mask_be32 = (__force __be32)(mask);
+		mask = (__force unsigned long)cpu_to_le32(be32_to_cpu(mask_be32));
+	} else if (size == 16) {
+		mask_be32 = (__force __be32)(mask);
+		mask_be16 = *(__be16 *)&mask_be32;
+		mask = (__force unsigned long)cpu_to_le16(be16_to_cpu(mask_be16));
+	}
+	return mask;
+}
 static int offload_pedit_fields(struct mlx5e_priv *priv,
 				int namespace,
 				struct pedit_headers_action *hdrs,
 	u32 *s_masks_p, *a_masks_p, s_mask, a_mask;
 	struct mlx5e_tc_mod_hdr_acts *mod_acts;
 	struct mlx5_fields *f;
-	unsigned long mask;
+	unsigned long mask, field_mask;
-	__be32 mask_be32;
-	__be16 mask_be16;
 	int err;
 	u8 cmd;
 		if (skip)
 			continue;
-		if (f->field_bsize == 32) {
+		mask = mask_to_le(mask, f->field_bsize);
-			mask_be32 = (__force __be32)(mask);
-			mask = (__force unsigned long)cpu_to_le32(be32_to_cpu(mask_be32));
-		} else if (f->field_bsize == 16) {
-			mask_be32 = (__force __be32)(mask);
-			mask_be16 = *(__be16 *)&mask_be32;
-			mask = (__force unsigned long)cpu_to_le16(be16_to_cpu(mask_be16));
-		}
 		first = find_first_bit(&mask, f->field_bsize);
 		next_z = find_next_zero_bit(&mask, f->field_bsize, first);
 		if (cmd == MLX5_ACTION_TYPE_SET) {
 			int start;
+			field_mask = mask_to_le(f->field_mask, f->field_bsize);
 			/* if field is bit sized it can start not from first bit */
-			start = find_first_bit((unsigned long *)&f->field_mask,
+			start = find_first_bit(&field_mask, f->field_bsize);
-					       f->field_bsize);
 			MLX5_SET(set_action_in, action, offset, first - start);
 			/* length is num of bits to be written, zero means length of 32 */
 		goto err_free;
 	/* actions validation depends on parsing the ct matches first */
-	err = mlx5_tc_ct_parse_match(priv, &parse_attr->spec, f,
+	err = mlx5_tc_ct_match_add(priv, &parse_attr->spec, f,
-				     &flow->esw_attr->ct_attr, extack);
+				   &flow->esw_attr->ct_attr, extack);
 	if (err)
 		goto err_free;

drivers/net/ethernet/mellanox/mlx5/core/en_txrx.c+13−4

 	struct mlx5e_xdpsq *xsksq = &c->xsksq;
 	struct mlx5e_rq *xskrq = &c->xskrq;
 	struct mlx5e_rq *rq = &c->rq;
-	bool xsk_open = test_bit(MLX5E_CHANNEL_STATE_XSK, c->state);
 	bool aff_change = false;
 	bool busy_xsk = false;
 	bool busy = false;
 	int work_done = 0;
+	bool xsk_open;
 	int i;
+	rcu_read_lock();
+	xsk_open = test_bit(MLX5E_CHANNEL_STATE_XSK, c->state);
 	ch_stats->poll++;
 	for (i = 0; i < c->num_tc; i++)
 	busy |= busy_xsk;
 	if (busy) {
-		if (likely(mlx5e_channel_no_affinity_change(c)))
+		if (likely(mlx5e_channel_no_affinity_change(c))) {
-			return budget;
+			work_done = budget;
+			goto out;
+		}
 		ch_stats->aff_change++;
 		aff_change = true;
 		if (budget && work_done == budget)
 	}
 	if (unlikely(!napi_complete_done(napi, work_done)))
-		return work_done;
+		goto out;
 	ch_stats->arm++;
 		ch_stats->force_irq++;
 	}
+out:
+	rcu_read_unlock();
 	return work_done;
 }

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+28−24

@@ -1219,35 +1219,37 @@ static int esw_create_offloads_fdb_tables(struct mlx5_eswitch *esw) · 1218 unmodified lines
1219	}	1219	}
1220	esw->fdb_table.offloads.send_to_vport_grp = g;	1220	esw->fdb_table.offloads.send_to_vport_grp = g;
1221		1221
1222	/* create peer esw miss group */	1222	if (MLX5_CAP_ESW(esw->dev, merged_eswitch)) {
1223	memset(flow_group_in, 0, inlen);	1223	/* create peer esw miss group */
		1224	memset(flow_group_in, 0, inlen);
1224		1225
1225	esw_set_flow_group_source_port(esw, flow_group_in);	1226	esw_set_flow_group_source_port(esw, flow_group_in);
1226		1227
1227	if (!mlx5_eswitch_vport_match_metadata_enabled(esw)) {	1228	if (!mlx5_eswitch_vport_match_metadata_enabled(esw)) {
1228	match_criteria = MLX5_ADDR_OF(create_flow_group_in,	1229	match_criteria = MLX5_ADDR_OF(create_flow_group_in,
1229	flow_group_in,	1230	flow_group_in,
1230	match_criteria);	1231	match_criteria);
1231		1232
1232	MLX5_SET_TO_ONES(fte_match_param, match_criteria,	1233	MLX5_SET_TO_ONES(fte_match_param, match_criteria,
1233	misc_parameters.source_eswitch_owner_vhca_id);	1234	misc_parameters.source_eswitch_owner_vhca_id);
1234		1235
1235	MLX5_SET(create_flow_group_in, flow_group_in,	1236	MLX5_SET(create_flow_group_in, flow_group_in,
1236	source_eswitch_owner_vhca_id_valid, 1);	1237	source_eswitch_owner_vhca_id_valid, 1);
1237	}	1238	}
1238		1239
1239	MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, ix);	1240	MLX5_SET(create_flow_group_in, flow_group_in, start_flow_index, ix);
1240	MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index,	1241	MLX5_SET(create_flow_group_in, flow_group_in, end_flow_index,
1241	ix + esw->total_vports - 1);	1242	ix + esw->total_vports - 1);
1242	ix += esw->total_vports;	1243	ix += esw->total_vports;
1243		1244
1244	g = mlx5_create_flow_group(fdb, flow_group_in);	1245	g = mlx5_create_flow_group(fdb, flow_group_in);
1245	if (IS_ERR(g)) {	1246	if (IS_ERR(g)) {
1246	err = PTR_ERR(g);	1247	err = PTR_ERR(g);
1247	esw_warn(dev, "Failed to create peer miss flow group err(%d)\n", err);	1248	esw_warn(dev, "Failed to create peer miss flow group err(%d)\n", err);
1248	goto peer_miss_err;	1249	goto peer_miss_err;
		1250	}
		1251	esw->fdb_table.offloads.peer_miss_grp = g;
1249	}	1252	}
1250	esw->fdb_table.offloads.peer_miss_grp = g;
1251		1253
1252	/* create miss group */	1254	/* create miss group */
1253	memset(flow_group_in, 0, inlen);	1255	memset(flow_group_in, 0, inlen);
@@ -1281,7 +1283,8 @@ static int esw_create_offloads_fdb_tables(struct mlx5_eswitch *esw) · 27 unmodified lines
1281	miss_rule_err:	1283	miss_rule_err:
1282	mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);	1284	mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);
1283	miss_err:	1285	miss_err:
1284	mlx5_destroy_flow_group(esw->fdb_table.offloads.peer_miss_grp);	1286	if (MLX5_CAP_ESW(esw->dev, merged_eswitch))
		1287	mlx5_destroy_flow_group(esw->fdb_table.offloads.peer_miss_grp);
1285	peer_miss_err:	1288	peer_miss_err:
1286	mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);	1289	mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);
1287	send_vport_err:	1290	send_vport_err:
@@ -1305,7 +1308,8 @@ static void esw_destroy_offloads_fdb_tables(struct mlx5_eswitch *esw) · 17 unmodified lines
1305	mlx5_del_flow_rules(esw->fdb_table.offloads.miss_rule_multi);	1308	mlx5_del_flow_rules(esw->fdb_table.offloads.miss_rule_multi);
1306	mlx5_del_flow_rules(esw->fdb_table.offloads.miss_rule_uni);	1309	mlx5_del_flow_rules(esw->fdb_table.offloads.miss_rule_uni);
1307	mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);	1310	mlx5_destroy_flow_group(esw->fdb_table.offloads.send_to_vport_grp);
1308	mlx5_destroy_flow_group(esw->fdb_table.offloads.peer_miss_grp);	1311	if (MLX5_CAP_ESW(esw->dev, merged_eswitch))
		1312	mlx5_destroy_flow_group(esw->fdb_table.offloads.peer_miss_grp);
1309	mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);	1313	mlx5_destroy_flow_group(esw->fdb_table.offloads.miss_grp);
1310		1314
1311	mlx5_esw_chains_destroy(esw);	1315	mlx5_esw_chains_destroy(esw);

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c+4−4

 	fte->action = *flow_act;
 	fte->flow_context = spec->flow_context;
-	tree_init_node(&fte->node, NULL, del_sw_fte);
+	tree_init_node(&fte->node, del_hw_fte, del_sw_fte);
 	return fte;
 }
 		up_write_ref_node(&g->node, false);
 		rule = add_rule_fg(g, spec, flow_act, dest, dest_num, fte);
 		up_write_ref_node(&fte->node, false);
-		tree_put_node(&fte->node, false);
 		return rule;
 	}
 	rule = ERR_PTR(-ENOENT);
 	up_write_ref_node(&g->node, false);
 	rule = add_rule_fg(g, spec, flow_act, dest, dest_num, fte);
 	up_write_ref_node(&fte->node, false);
-	tree_put_node(&fte->node, false);
 	tree_put_node(&g->node, false);
 	return rule;
 		up_write_ref_node(&fte->node, false);
 	} else {
 		del_hw_fte(&fte->node);
-		up_write(&fte->node.lock);
+		/* Avoid double call to del_hw_fte */
+		fte->node.del_hw_func = NULL;
+		up_write_ref_node(&fte->node, false);
 		tree_put_node(&fte->node, false);
 	}
 	kfree(handle);

drivers/net/ethernet/mscc/ocelot.c+15−9

 	if (ocelot->ptp && shinfo->tx_flags & SKBTX_HW_TSTAMP &&
 	    ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
+		spin_lock(&ocelot_port->ts_id_lock);
 		shinfo->tx_flags |= SKBTX_IN_PROGRESS;
 		/* Store timestamp ID in cb[0] of sk_buff */
-		skb->cb[0] = ocelot_port->ts_id % 4;
+		skb->cb[0] = ocelot_port->ts_id;
+		ocelot_port->ts_id = (ocelot_port->ts_id + 1) % 4;
 		skb_queue_tail(&ocelot_port->tx_skbs, skb);
+		spin_unlock(&ocelot_port->ts_id_lock);
 		return 0;
 	}
 	return -ENODATA;
 	struct ocelot_port *ocelot_port = ocelot->ports[port];
 	skb_queue_head_init(&ocelot_port->tx_skbs);
+	spin_lock_init(&ocelot_port->ts_id_lock);
 	/* Basic L2 initialization */
 void ocelot_deinit(struct ocelot *ocelot)
 {
-	struct ocelot_port *port;
-	int i;
 	cancel_delayed_work(&ocelot->stats_work);
 	destroy_workqueue(ocelot->stats_queue);
 	mutex_destroy(&ocelot->stats_lock);
-	for (i = 0; i < ocelot->num_phys_ports; i++) {
-		port = ocelot->ports[i];
-		skb_queue_purge(&port->tx_skbs);
-	}
 }
 EXPORT_SYMBOL(ocelot_deinit);
+void ocelot_deinit_port(struct ocelot *ocelot, int port)
+{
+	struct ocelot_port *ocelot_port = ocelot->ports[port];
+	skb_queue_purge(&ocelot_port->tx_skbs);
+}
+EXPORT_SYMBOL(ocelot_deinit_port);
 MODULE_LICENSE("Dual MIT/GPL");

drivers/net/ethernet/mscc/ocelot_net.c+6−6

 	u8 grp = 0; /* Send everything on CPU group 0 */
 	unsigned int i, count, last;
 	int port = priv->chip_port;
+	bool do_tstamp;
 	val = ocelot_read(ocelot, QS_INJ_STATUS);
 	if (!(val & QS_INJ_STATUS_FIFO_RDY(BIT(grp))) ||
 	info.vid = skb_vlan_tag_get(skb);
 	/* Check if timestamping is needed */
+	do_tstamp = (ocelot_port_add_txtstamp_skb(ocelot_port, skb) == 0);
 	if (ocelot->ptp && shinfo->tx_flags & SKBTX_HW_TSTAMP) {
 		info.rew_op = ocelot_port->ptp_cmd;
 		if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
-			info.rew_op |= (ocelot_port->ts_id  % 4) << 3;
+			info.rew_op |= skb->cb[0] << 3;
 	}
 	ocelot_gen_ifh(ifh, &info);
 	dev->stats.tx_packets++;
 	dev->stats.tx_bytes += skb->len;
-	if (!ocelot_port_add_txtstamp_skb(ocelot_port, skb)) {
+	if (!do_tstamp)
-		ocelot_port->ts_id++;
+		dev_kfree_skb_any(skb);
-		return NETDEV_TX_OK;
-	}
-	dev_kfree_skb_any(skb);
 	return NETDEV_TX_OK;
 }

drivers/net/ethernet/mscc/ocelot_vsc7514.c+145−104

 	[VCAP_IS2_HK_DIP_EQ_SIP]		= {123,   1},
 	/* IP4_TCP_UDP (TYPE=100) */
 	[VCAP_IS2_HK_TCP]			= {124,   1},
-	[VCAP_IS2_HK_L4_SPORT]			= {125,  16},
+	[VCAP_IS2_HK_L4_DPORT]			= {125,  16},
-	[VCAP_IS2_HK_L4_DPORT]			= {141,  16},
+	[VCAP_IS2_HK_L4_SPORT]			= {141,  16},
 	[VCAP_IS2_HK_L4_RNG]			= {157,   8},
 	[VCAP_IS2_HK_L4_SPORT_EQ_DPORT]		= {165,   1},
 	[VCAP_IS2_HK_L4_SEQUENCE_EQ0]		= {166,   1},
-	[VCAP_IS2_HK_L4_URG]			= {167,   1},
+	[VCAP_IS2_HK_L4_FIN]			= {167,   1},
-	[VCAP_IS2_HK_L4_ACK]			= {168,   1},
+	[VCAP_IS2_HK_L4_SYN]			= {168,   1},
-	[VCAP_IS2_HK_L4_PSH]			= {169,   1},
+	[VCAP_IS2_HK_L4_RST]			= {169,   1},
-	[VCAP_IS2_HK_L4_RST]			= {170,   1},
+	[VCAP_IS2_HK_L4_PSH]			= {170,   1},
-	[VCAP_IS2_HK_L4_SYN]			= {171,   1},
+	[VCAP_IS2_HK_L4_ACK]			= {171,   1},
-	[VCAP_IS2_HK_L4_FIN]			= {172,   1},
+	[VCAP_IS2_HK_L4_URG]			= {172,   1},
 	[VCAP_IS2_HK_L4_1588_DOM]		= {173,   8},
 	[VCAP_IS2_HK_L4_1588_VER]		= {181,   4},
 	/* IP4_OTHER (TYPE=101) */
 	.enable		= ocelot_ptp_enable,
 };
+static void mscc_ocelot_release_ports(struct ocelot *ocelot)
+{
+	int port;
+	for (port = 0; port < ocelot->num_phys_ports; port++) {
+		struct ocelot_port_private *priv;
+		struct ocelot_port *ocelot_port;
+		ocelot_port = ocelot->ports[port];
+		if (!ocelot_port)
+			continue;
+		ocelot_deinit_port(ocelot, port);
+		priv = container_of(ocelot_port, struct ocelot_port_private,
+				    port);
+		unregister_netdev(priv->dev);
+		free_netdev(priv->dev);
+	}
+}
+static int mscc_ocelot_init_ports(struct platform_device *pdev,
+				  struct device_node *ports)
+{
+	struct ocelot *ocelot = platform_get_drvdata(pdev);
+	struct device_node *portnp;
+	int err;
+	ocelot->ports = devm_kcalloc(ocelot->dev, ocelot->num_phys_ports,
+				     sizeof(struct ocelot_port *), GFP_KERNEL);
+	if (!ocelot->ports)
+		return -ENOMEM;
+	/* No NPI port */
+	ocelot_configure_cpu(ocelot, -1, OCELOT_TAG_PREFIX_NONE,
+			     OCELOT_TAG_PREFIX_NONE);
+	for_each_available_child_of_node(ports, portnp) {
+		struct ocelot_port_private *priv;
+		struct ocelot_port *ocelot_port;
+		struct device_node *phy_node;
+		phy_interface_t phy_mode;
+		struct phy_device *phy;
+		struct regmap *target;
+		struct resource *res;
+		struct phy *serdes;
+		char res_name[8];
+		u32 port;
+		if (of_property_read_u32(portnp, "reg", &port))
+			continue;
+		snprintf(res_name, sizeof(res_name), "port%d", port);
+		res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
+						   res_name);
+		target = ocelot_regmap_init(ocelot, res);
+		if (IS_ERR(target))
+			continue;
+		phy_node = of_parse_phandle(portnp, "phy-handle", 0);
+		if (!phy_node)
+			continue;
+		phy = of_phy_find_device(phy_node);
+		of_node_put(phy_node);
+		if (!phy)
+			continue;
+		err = ocelot_probe_port(ocelot, port, target, phy);
+		if (err) {
+			of_node_put(portnp);
+			return err;
+		}
+		ocelot_port = ocelot->ports[port];
+		priv = container_of(ocelot_port, struct ocelot_port_private,
+				    port);
+		of_get_phy_mode(portnp, &phy_mode);
+		ocelot_port->phy_mode = phy_mode;
+		switch (ocelot_port->phy_mode) {
+		case PHY_INTERFACE_MODE_NA:
+			continue;
+		case PHY_INTERFACE_MODE_SGMII:
+			break;
+		case PHY_INTERFACE_MODE_QSGMII:
+			/* Ensure clock signals and speed is set on all
+			 * QSGMII links
+			 */
+			ocelot_port_writel(ocelot_port,
+					   DEV_CLOCK_CFG_LINK_SPEED
+					   (OCELOT_SPEED_1000),
+					   DEV_CLOCK_CFG);
+			break;
+		default:
+			dev_err(ocelot->dev,
+				"invalid phy mode for port%d, (Q)SGMII only\n",
+				port);
+			of_node_put(portnp);
+			return -EINVAL;
+		}
+		serdes = devm_of_phy_get(ocelot->dev, portnp, NULL);
+		if (IS_ERR(serdes)) {
+			err = PTR_ERR(serdes);
+			if (err == -EPROBE_DEFER)
+				dev_dbg(ocelot->dev, "deferring probe\n");
+			else
+				dev_err(ocelot->dev,
+					"missing SerDes phys for port%d\n",
+					port);
+			of_node_put(portnp);
+			return err;
+		}
+		priv->serdes = serdes;
+	}
+	return 0;
+}
 static int mscc_ocelot_probe(struct platform_device *pdev)
 {
 	struct device_node *np = pdev->dev.of_node;
-	struct device_node *ports, *portnp;
 	int err, irq_xtr, irq_ptp_rdy;
+	struct device_node *ports;
 	struct ocelot *ocelot;
 	struct regmap *hsio;
 	unsigned int i;
 	ports = of_get_child_by_name(np, "ethernet-ports");
 	if (!ports) {
-		dev_err(&pdev->dev, "no ethernet-ports child node found\n");
+		dev_err(ocelot->dev, "no ethernet-ports child node found\n");
 		return -ENODEV;
 	}
 	ocelot->num_phys_ports = of_get_child_count(ports);
-	ocelot->ports = devm_kcalloc(&pdev->dev, ocelot->num_phys_ports,
-				     sizeof(struct ocelot_port *), GFP_KERNEL);
 	ocelot->vcap_is2_keys = vsc7514_vcap_is2_keys;
 	ocelot->vcap_is2_actions = vsc7514_vcap_is2_actions;
 	ocelot->vcap = vsc7514_vcap_props;
-	ocelot_init(ocelot);
+	err = ocelot_init(ocelot);
+	if (err)
+		goto out_put_ports;
+	err = mscc_ocelot_init_ports(pdev, ports);
+	if (err)
+		goto out_put_ports;
 	if (ocelot->ptp) {
 		err = ocelot_init_timestamp(ocelot, &ocelot_ptp_clock_info);
 		if (err) {
 		}
 	}
-	/* No NPI port */
-	ocelot_configure_cpu(ocelot, -1, OCELOT_TAG_PREFIX_NONE,
-			     OCELOT_TAG_PREFIX_NONE);
-	for_each_available_child_of_node(ports, portnp) {
-		struct ocelot_port_private *priv;
-		struct ocelot_port *ocelot_port;
-		struct device_node *phy_node;
-		phy_interface_t phy_mode;
-		struct phy_device *phy;
-		struct regmap *target;
-		struct resource *res;
-		struct phy *serdes;
-		char res_name[8];
-		u32 port;
-		if (of_property_read_u32(portnp, "reg", &port))
-			continue;
-		snprintf(res_name, sizeof(res_name), "port%d", port);
-		res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-						   res_name);
-		target = ocelot_regmap_init(ocelot, res);
-		if (IS_ERR(target))
-			continue;
-		phy_node = of_parse_phandle(portnp, "phy-handle", 0);
-		if (!phy_node)
-			continue;
-		phy = of_phy_find_device(phy_node);
-		of_node_put(phy_node);
-		if (!phy)
-			continue;
-		err = ocelot_probe_port(ocelot, port, target, phy);
-		if (err) {
-			of_node_put(portnp);
-			goto out_put_ports;
-		}
-		ocelot_port = ocelot->ports[port];
-		priv = container_of(ocelot_port, struct ocelot_port_private,
-				    port);
-		of_get_phy_mode(portnp, &phy_mode);
-		ocelot_port->phy_mode = phy_mode;
-		switch (ocelot_port->phy_mode) {
-		case PHY_INTERFACE_MODE_NA:
-			continue;
-		case PHY_INTERFACE_MODE_SGMII:
-			break;
-		case PHY_INTERFACE_MODE_QSGMII:
-			/* Ensure clock signals and speed is set on all
-			 * QSGMII links
-			 */
-			ocelot_port_writel(ocelot_port,
-					   DEV_CLOCK_CFG_LINK_SPEED
-					   (OCELOT_SPEED_1000),
-					   DEV_CLOCK_CFG);
-			break;
-		default:
-			dev_err(ocelot->dev,
-				"invalid phy mode for port%d, (Q)SGMII only\n",
-				port);
-			of_node_put(portnp);
-			err = -EINVAL;
-			goto out_put_ports;
-		}
-		serdes = devm_of_phy_get(ocelot->dev, portnp, NULL);
-		if (IS_ERR(serdes)) {
-			err = PTR_ERR(serdes);
-			if (err == -EPROBE_DEFER)
-				dev_dbg(ocelot->dev, "deferring probe\n");
-			else
-				dev_err(ocelot->dev,
-					"missing SerDes phys for port%d\n",
-					port);
-			of_node_put(portnp);
-			goto out_put_ports;
-		}
-		priv->serdes = serdes;
-	}
 	register_netdevice_notifier(&ocelot_netdevice_nb);
 	register_switchdev_notifier(&ocelot_switchdev_nb);
 	register_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);
 	struct ocelot *ocelot = platform_get_drvdata(pdev);
 	ocelot_deinit_timestamp(ocelot);
+	mscc_ocelot_release_ports(ocelot);
 	ocelot_deinit(ocelot);
 	unregister_switchdev_blocking_notifier(&ocelot_switchdev_blocking_nb);
 	unregister_switchdev_notifier(&ocelot_switchdev_nb);

drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c+2−2

@@ -829,8 +829,8 @@ nfp_port_get_fecparam(struct net_device *netdev, · 828 unmodified lines
829	struct nfp_eth_table_port *eth_port;	829	struct nfp_eth_table_port *eth_port;
830	struct nfp_port *port;	830	struct nfp_port *port;
831		831
832	param->active_fec = ETHTOOL_FEC_NONE_BIT;	832	param->active_fec = ETHTOOL_FEC_NONE;
833	param->fec = ETHTOOL_FEC_NONE_BIT;	833	param->fec = ETHTOOL_FEC_NONE;
834		834
835	port = nfp_port_from_netdev(netdev);	835	port = nfp_port_from_netdev(netdev);
836	eth_port = nfp_port_get_eth_port(port);	836	eth_port = nfp_port_get_eth_port(port);

drivers/net/ethernet/qlogic/qed/qed_dev.c+10−1

 			cdev->mf_bits = BIT(QED_MF_LLH_MAC_CLSS) |
 					BIT(QED_MF_LLH_PROTO_CLSS) |
 					BIT(QED_MF_LL2_NON_UNICAST) |
-					BIT(QED_MF_INTER_PF_SWITCH);
+					BIT(QED_MF_INTER_PF_SWITCH) |
+					BIT(QED_MF_DISABLE_ARFS);
 			break;
 		case NVM_CFG1_GLOB_MF_MODE_DEFAULT:
 			cdev->mf_bits = BIT(QED_MF_LLH_MAC_CLSS) |
 		DP_INFO(p_hwfn, "Multi function mode is 0x%lx\n",
 			cdev->mf_bits);
+		/* In CMT the PF is unknown when the GFS block processes the
+		 * packet. Therefore cannot use searcher as it has a per PF
+		 * database, and thus ARFS must be disabled.
+		 *
+		 */
+		if (QED_IS_CMT(cdev))
+			cdev->mf_bits |= BIT(QED_MF_DISABLE_ARFS);
 	}
 	DP_INFO(p_hwfn, "Multi function mode is 0x%lx\n",

drivers/net/ethernet/qlogic/qed/qed_l2.c+3−0

 			     struct qed_ptt *p_ptt,
 			     struct qed_arfs_config_params *p_cfg_params)
 {
+	if (test_bit(QED_MF_DISABLE_ARFS, &p_hwfn->cdev->mf_bits))
+		return;
 	if (p_cfg_params->mode != QED_FILTER_CONFIG_MODE_DISABLE) {
 		qed_gft_config(p_hwfn, p_ptt, p_hwfn->rel_pf_id,
 			       p_cfg_params->tcp,

drivers/net/ethernet/qlogic/qed/qed_main.c+2−0

@@ -444,6 +444,8 @@ int qed_fill_dev_info(struct qed_dev *cdev, · 443 unmodified lines
444	dev_info->fw_eng = FW_ENGINEERING_VERSION;	444	dev_info->fw_eng = FW_ENGINEERING_VERSION;
445	dev_info->b_inter_pf_switch = test_bit(QED_MF_INTER_PF_SWITCH,	445	dev_info->b_inter_pf_switch = test_bit(QED_MF_INTER_PF_SWITCH,
446	&cdev->mf_bits);	446	&cdev->mf_bits);
		447	if (!test_bit(QED_MF_DISABLE_ARFS, &cdev->mf_bits))
		448	dev_info->b_arfs_capable = true;
447	dev_info->tx_switching = true;	449	dev_info->tx_switching = true;
448		450
449	if (hw_info->b_wol_support == QED_WOL_SUPPORT_PME)	451	if (hw_info->b_wol_support == QED_WOL_SUPPORT_PME)

drivers/net/ethernet/qlogic/qed/qed_sriov.c+1−0

@@ -71,6 +71,7 @@ static int qed_sp_vf_start(struct qed_hwfn p_hwfn, struct qed_vf_info p_vf) · 70 unmodified lines
71	p_ramrod->personality = PERSONALITY_ETH;	71	p_ramrod->personality = PERSONALITY_ETH;
72	break;	72	break;
73	case QED_PCI_ETH_ROCE:	73	case QED_PCI_ETH_ROCE:
		74	case QED_PCI_ETH_IWARP:
74	p_ramrod->personality = PERSONALITY_RDMA_AND_ETH;	75	p_ramrod->personality = PERSONALITY_RDMA_AND_ETH;
75	break;	76	break;
76	default:	77	default:

drivers/net/ethernet/qlogic/qede/qede_filter.c+3−0

@@ -311,6 +311,9 @@ int qede_alloc_arfs(struct qede_dev *edev) · 310 unmodified lines
311	{	311	{
312	int i;	312	int i;
313		313
		314	if (!edev->dev_info.common.b_arfs_capable)
		315	return -EINVAL;
		316
314	edev->arfs = vzalloc(sizeof(*edev->arfs));	317	edev->arfs = vzalloc(sizeof(*edev->arfs));
315	if (!edev->arfs)	318	if (!edev->arfs)
316	return -ENOMEM;	319	return -ENOMEM;

drivers/net/ethernet/qlogic/qede/qede_main.c+5−6

 		      NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
 		      NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_HW_TC;
-	if (!IS_VF(edev) && edev->dev_info.common.num_hwfns == 1)
+	if (edev->dev_info.common.b_arfs_capable)
 		hw_features |= NETIF_F_NTUPLE;
 	if (edev->dev_info.common.vxlan_enable ||
 	qede_vlan_mark_nonconfigured(edev);
 	edev->ops->fastpath_stop(edev->cdev);
-	if (!IS_VF(edev) && edev->dev_info.common.num_hwfns == 1) {
+	if (edev->dev_info.common.b_arfs_capable) {
 		qede_poll_for_freeing_arfs_filters(edev);
 		qede_free_arfs(edev);
 	}
 	if (rc)
 		goto err2;
-	if (!IS_VF(edev) && edev->dev_info.common.num_hwfns == 1) {
+	if (qede_alloc_arfs(edev)) {
-		rc = qede_alloc_arfs(edev);
+		edev->ndev->features &= ~NETIF_F_NTUPLE;
-		if (rc)
+		edev->dev_info.common.b_arfs_capable = false;
-			DP_NOTICE(edev, "aRFS memory allocation failed\n");
 	}
 	qede_napi_add_enable(edev);

drivers/net/ethernet/sfc/ef100.c+1−0

@@ -490,6 +490,7 @@ static int ef100_pci_probe(struct pci_dev *pci_dev, · 489 unmodified lines
490	if (fcw.offset > pci_resource_len(efx->pci_dev, fcw.bar) - ESE_GZ_FCW_LEN) {	490	if (fcw.offset > pci_resource_len(efx->pci_dev, fcw.bar) - ESE_GZ_FCW_LEN) {
491	netif_err(efx, probe, efx->net_dev,	491	netif_err(efx, probe, efx->net_dev,
492	"Func control window overruns BAR\n");	492	"Func control window overruns BAR\n");
		493	rc = -EIO;
493	goto fail;	494	goto fail;
494	}	495	}
495		496

drivers/net/ethernet/ti/cpsw_new.c+53−0

@@ -17,6 +17,7 @@ · 16 unmodified lines
17	#include <linux/phy.h>	17	#include <linux/phy.h>
18	#include <linux/phy/phy.h>	18	#include <linux/phy/phy.h>
19	#include <linux/delay.h>	19	#include <linux/delay.h>
		20	#include <linux/pinctrl/consumer.h>
20	#include <linux/pm_runtime.h>	21	#include <linux/pm_runtime.h>
21	#include <linux/gpio/consumer.h>	22	#include <linux/gpio/consumer.h>
22	#include <linux/of.h>	23	#include <linux/of.h>
@@ -2070,9 +2071,61 @@ static int cpsw_remove(struct platform_device *pdev) · 2047 unmodified lines
2070	return 0;	2071	return 0;
2071	}	2072	}
2072		2073
		2074	static int __maybe_unused cpsw_suspend(struct device *dev)
		2075	{
		2076	struct cpsw_common *cpsw = dev_get_drvdata(dev);
		2077	int i;
		2078
		2079	rtnl_lock();
		2080
		2081	for (i = 0; i < cpsw->data.slaves; i++) {
		2082	struct net_device *ndev = cpsw->slaves[i].ndev;
		2083
		2084	if (!(ndev && netif_running(ndev)))
		2085	continue;
		2086
		2087	cpsw_ndo_stop(ndev);
		2088	}
		2089
		2090	rtnl_unlock();
		2091
		2092	/* Select sleep pin state */
		2093	pinctrl_pm_select_sleep_state(dev);
		2094
		2095	return 0;
		2096	}
		2097
		2098	static int __maybe_unused cpsw_resume(struct device *dev)
		2099	{
		2100	struct cpsw_common *cpsw = dev_get_drvdata(dev);
		2101	int i;
		2102
		2103	/* Select default pin state */
		2104	pinctrl_pm_select_default_state(dev);
		2105
		2106	/* shut up ASSERT_RTNL() warning in netif_set_real_num_tx/rx_queues */
		2107	rtnl_lock();
		2108
		2109	for (i = 0; i < cpsw->data.slaves; i++) {
		2110	struct net_device *ndev = cpsw->slaves[i].ndev;
		2111
		2112	if (!(ndev && netif_running(ndev)))
		2113	continue;
		2114
		2115	cpsw_ndo_open(ndev);
		2116	}
		2117
		2118	rtnl_unlock();
		2119
		2120	return 0;
		2121	}
		2122
		2123	static SIMPLE_DEV_PM_OPS(cpsw_pm_ops, cpsw_suspend, cpsw_resume);
		2124
2073	static struct platform_driver cpsw_driver = {	2125	static struct platform_driver cpsw_driver = {
2074	.driver = {	2126	.driver = {
2075	.name = "cpsw-switch",	2127	.name = "cpsw-switch",
		2128	.pm = &cpsw_pm_ops,
2076	.of_match_table = cpsw_of_mtable,	2129	.of_match_table = cpsw_of_mtable,
2077	},	2130	},
2078	.probe = cpsw_probe,	2131	.probe = cpsw_probe,

drivers/net/geneve.c+27−10

 				       struct net_device *dev,
 				       struct geneve_sock *gs4,
 				       struct flowi4 *fl4,
-				       const struct ip_tunnel_info *info)
+				       const struct ip_tunnel_info *info,
+				       __be16 dport, __be16 sport)
 {
 	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
 	struct geneve_dev *geneve = netdev_priv(dev);
 	fl4->flowi4_proto = IPPROTO_UDP;
 	fl4->daddr = info->key.u.ipv4.dst;
 	fl4->saddr = info->key.u.ipv4.src;
+	fl4->fl4_dport = dport;
+	fl4->fl4_sport = sport;
 	tos = info->key.tos;
 	if ((tos == 1) && !geneve->cfg.collect_md) {
 					   struct net_device *dev,
 					   struct geneve_sock *gs6,
 					   struct flowi6 *fl6,
-					   const struct ip_tunnel_info *info)
+					   const struct ip_tunnel_info *info,
+					   __be16 dport, __be16 sport)
 {
 	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
 	struct geneve_dev *geneve = netdev_priv(dev);
 	fl6->flowi6_proto = IPPROTO_UDP;
 	fl6->daddr = info->key.u.ipv6.dst;
 	fl6->saddr = info->key.u.ipv6.src;
+	fl6->fl6_dport = dport;
+	fl6->fl6_sport = sport;
 	prio = info->key.tos;
 	if ((prio == 1) && !geneve->cfg.collect_md) {
 		prio = ip_tunnel_get_dsfield(ip_hdr(skb), skb);
 	__be16 sport;
 	int err;
-	rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info);
+	sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
+	rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info,
+			      geneve->cfg.info.key.tp_dst, sport);
 	if (IS_ERR(rt))
 		return PTR_ERR(rt);
 		return -EMSGSIZE;
 	}
-	sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
 	if (geneve->cfg.collect_md) {
 		tos = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
 		ttl = key->ttl;
 	__be16 sport;
 	int err;
-	dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info);
+	sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
+	dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info,
+				geneve->cfg.info.key.tp_dst, sport);
 	if (IS_ERR(dst))
 		return PTR_ERR(dst);
 		return -EMSGSIZE;
 	}
-	sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
 	if (geneve->cfg.collect_md) {
 		prio = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
 		ttl = key->ttl;
 {
 	struct ip_tunnel_info *info = skb_tunnel_info(skb);
 	struct geneve_dev *geneve = netdev_priv(dev);
+	__be16 sport;
 	if (ip_tunnel_info_af(info) == AF_INET) {
 		struct rtable *rt;
 		struct flowi4 fl4;
 		struct geneve_sock *gs4 = rcu_dereference(geneve->sock4);
+		sport = udp_flow_src_port(geneve->net, skb,
+					  1, USHRT_MAX, true);
-		rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info);
+		rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info,
+				      geneve->cfg.info.key.tp_dst, sport);
 		if (IS_ERR(rt))
 			return PTR_ERR(rt);
 	} else if (ip_tunnel_info_af(info) == AF_INET6) {
 		struct dst_entry *dst;
 		struct flowi6 fl6;
 		struct geneve_sock *gs6 = rcu_dereference(geneve->sock6);
+		sport = udp_flow_src_port(geneve->net, skb,
+					  1, USHRT_MAX, true);
-		dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info);
+		dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info,
+					geneve->cfg.info.key.tp_dst, sport);
 		if (IS_ERR(dst))
 			return PTR_ERR(dst);
 		return -EINVAL;
 	}
-	info->key.tp_src = udp_flow_src_port(geneve->net, skb,
+	info->key.tp_src = sport;
-					     1, USHRT_MAX, true);
 	info->key.tp_dst = geneve->cfg.info.key.tp_dst;
 	return 0;
 }

drivers/net/hyperv/hyperv_net.h+7−0

 #define NETVSC_XDP_HDRM 256
+#define NETVSC_XFER_HEADER_SIZE(rng_cnt) \
+		(offsetof(struct vmtransfer_page_packet_header, ranges) + \
+		(rng_cnt) * sizeof(struct vmtransfer_page_range))
 struct multi_send_data {
 	struct sk_buff *skb; /* skb containing the pkt */
 	struct hv_netvsc_packet *pkt; /* netvsc pkt pending */
 	/* Serial number of the VF to team with */
 	u32 vf_serial;
+	/* Is the current data path through the VF NIC? */
+	bool  data_path_is_vf;
 	/* Used to temporarily save the config info across hibernation */
 	struct netvsc_device_info *saved_netvsc_dev_info;
 };

drivers/net/hyperv/netvsc.c+111−13

 	net_device->recv_section_size = resp->sections[0].sub_alloc_size;
 	net_device->recv_section_cnt = resp->sections[0].num_sub_allocs;
+	/* Ensure buffer will not overflow */
+	if (net_device->recv_section_size < NETVSC_MTU_MIN || (u64)net_device->recv_section_size *
+	    (u64)net_device->recv_section_cnt > (u64)buf_size) {
+		netdev_err(ndev, "invalid recv_section_size %u\n",
+			   net_device->recv_section_size);
+		ret = -EINVAL;
+		goto cleanup;
+	}
 	/* Setup receive completion ring.
 	 * Add 1 to the recv_section_cnt because at least one entry in a
 	 * ring buffer has to be empty.
 	/* Parse the response */
 	net_device->send_section_size = init_packet->msg.
 				v1_msg.send_send_buf_complete.section_size;
+	if (net_device->send_section_size < NETVSC_MTU_MIN) {
+		netdev_err(ndev, "invalid send_section_size %u\n",
+			   net_device->send_section_size);
+		ret = -EINVAL;
+		goto cleanup;
+	}
 	/* Section count is simply the size divided by the section size. */
 	net_device->send_section_cnt = buf_size / net_device->send_section_size;
 				   int budget)
 {
 	const struct nvsp_message *nvsp_packet = hv_pkt_data(desc);
+	u32 msglen = hv_pkt_datalen(desc);
+	/* Ensure packet is big enough to read header fields */
+	if (msglen < sizeof(struct nvsp_message_header)) {
+		netdev_err(ndev, "nvsp_message length too small: %u\n", msglen);
+		return;
+	}
 	switch (nvsp_packet->hdr.msg_type) {
 	case NVSP_MSG_TYPE_INIT_COMPLETE:
+		if (msglen < sizeof(struct nvsp_message_header) +
+				sizeof(struct nvsp_message_init_complete)) {
+			netdev_err(ndev, "nvsp_msg length too small: %u\n",
+				   msglen);
+			return;
+		}
+		fallthrough;
 	case NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE:
+		if (msglen < sizeof(struct nvsp_message_header) +
+				sizeof(struct nvsp_1_message_send_receive_buffer_complete)) {
+			netdev_err(ndev, "nvsp_msg1 length too small: %u\n",
+				   msglen);
+			return;
+		}
+		fallthrough;
 	case NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE:
+		if (msglen < sizeof(struct nvsp_message_header) +
+				sizeof(struct nvsp_1_message_send_send_buffer_complete)) {
+			netdev_err(ndev, "nvsp_msg1 length too small: %u\n",
+				   msglen);
+			return;
+		}
+		fallthrough;
 	case NVSP_MSG5_TYPE_SUBCHANNEL:
+		if (msglen < sizeof(struct nvsp_message_header) +
+				sizeof(struct nvsp_5_subchannel_complete)) {
+			netdev_err(ndev, "nvsp_msg5 length too small: %u\n",
+				   msglen);
+			return;
+		}
 		/* Copy the response back */
 		memcpy(&net_device->channel_init_pkt, nvsp_packet,
 		       sizeof(struct nvsp_message));
 static int netvsc_receive(struct net_device *ndev,
 			  struct netvsc_device *net_device,
 			  struct netvsc_channel *nvchan,
-			  const struct vmpacket_descriptor *desc,
+			  const struct vmpacket_descriptor *desc)
-			  const struct nvsp_message *nvsp)
 {
 	struct net_device_context *net_device_ctx = netdev_priv(ndev);
 	struct vmbus_channel *channel = nvchan->channel;
 	const struct vmtransfer_page_packet_header *vmxferpage_packet
 		= container_of(desc, const struct vmtransfer_page_packet_header, d);
+	const struct nvsp_message *nvsp = hv_pkt_data(desc);
+	u32 msglen = hv_pkt_datalen(desc);
 	u16 q_idx = channel->offermsg.offer.sub_channel_index;
 	char *recv_buf = net_device->recv_buf;
 	u32 status = NVSP_STAT_SUCCESS;
 	int i;
 	int count = 0;
+	/* Ensure packet is big enough to read header fields */
+	if (msglen < sizeof(struct nvsp_message_header)) {
+		netif_err(net_device_ctx, rx_err, ndev,
+			  "invalid nvsp header, length too small: %u\n",
+			  msglen);
+		return 0;
+	}
 	/* Make sure this is a valid nvsp packet */
 	if (unlikely(nvsp->hdr.msg_type != NVSP_MSG1_TYPE_SEND_RNDIS_PKT)) {
 		netif_err(net_device_ctx, rx_err, ndev,
 		return 0;
 	}
+	/* Validate xfer page pkt header */
+	if ((desc->offset8 << 3) < sizeof(struct vmtransfer_page_packet_header)) {
+		netif_err(net_device_ctx, rx_err, ndev,
+			  "Invalid xfer page pkt, offset too small: %u\n",
+			  desc->offset8 << 3);
+		return 0;
+	}
 	if (unlikely(vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID)) {
 		netif_err(net_device_ctx, rx_err, ndev,
 			  "Invalid xfer page set id - expecting %x got %x\n",
 	count = vmxferpage_packet->range_cnt;
+	/* Check count for a valid value */
+	if (NETVSC_XFER_HEADER_SIZE(count) > desc->offset8 << 3) {
+		netif_err(net_device_ctx, rx_err, ndev,
+			  "Range count is not valid: %d\n",
+			  count);
+		return 0;
+	}
 	/* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
 	for (i = 0; i < count; i++) {
 		u32 offset = vmxferpage_packet->ranges[i].byte_offset;
 		void *data;
 		int ret;
-		if (unlikely(offset + buflen > net_device->recv_buf_size)) {
+		if (unlikely(offset > net_device->recv_buf_size ||
+			     buflen > net_device->recv_buf_size - offset)) {
 			nvchan->rsc.cnt = 0;
 			status = NVSP_STAT_FAIL;
 			netif_err(net_device_ctx, rx_err, ndev,
 	u32 count, offset, *tab;
 	int i;
+	/* Ensure packet is big enough to read send_table fields */
+	if (msglen < sizeof(struct nvsp_message_header) +
+		     sizeof(struct nvsp_5_send_indirect_table)) {
+		netdev_err(ndev, "nvsp_v5_msg length too small: %u\n", msglen);
+		return;
+	}
 	count = nvmsg->msg.v5_msg.send_table.count;
 	offset = nvmsg->msg.v5_msg.send_table.offset;
 }
 static void netvsc_send_vf(struct net_device *ndev,
-			   const struct nvsp_message *nvmsg)
+			   const struct nvsp_message *nvmsg,
+			   u32 msglen)
 {
 	struct net_device_context *net_device_ctx = netdev_priv(ndev);
+	/* Ensure packet is big enough to read its fields */
+	if (msglen < sizeof(struct nvsp_message_header) +
+		     sizeof(struct nvsp_4_send_vf_association)) {
+		netdev_err(ndev, "nvsp_v4_msg length too small: %u\n", msglen);
+		return;
+	}
 	net_device_ctx->vf_alloc = nvmsg->msg.v4_msg.vf_assoc.allocated;
 	net_device_ctx->vf_serial = nvmsg->msg.v4_msg.vf_assoc.serial;
 	netdev_info(ndev, "VF slot %u %s\n",
 static void netvsc_receive_inband(struct net_device *ndev,
 				  struct netvsc_device *nvscdev,
-				  const struct nvsp_message *nvmsg,
+				  const struct vmpacket_descriptor *desc)
-				  u32 msglen)
 {
+	const struct nvsp_message *nvmsg = hv_pkt_data(desc);
+	u32 msglen = hv_pkt_datalen(desc);
+	/* Ensure packet is big enough to read header fields */
+	if (msglen < sizeof(struct nvsp_message_header)) {
+		netdev_err(ndev, "inband nvsp_message length too small: %u\n", msglen);
+		return;
+	}
 	switch (nvmsg->hdr.msg_type) {
 	case NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE:
 		netvsc_send_table(ndev, nvscdev, nvmsg, msglen);
 		break;
 	case NVSP_MSG4_TYPE_SEND_VF_ASSOCIATION:
-		netvsc_send_vf(ndev, nvmsg);
+		netvsc_send_vf(ndev, nvmsg, msglen);
 		break;
 	}
 }
 {
 	struct vmbus_channel *channel = nvchan->channel;
 	const struct nvsp_message *nvmsg = hv_pkt_data(desc);
-	u32 msglen = hv_pkt_datalen(desc);
 	trace_nvsp_recv(ndev, channel, nvmsg);
 	switch (desc->type) {
 	case VM_PKT_COMP:
-		netvsc_send_completion(ndev, net_device, channel,
+		netvsc_send_completion(ndev, net_device, channel, desc, budget);
-				       desc, budget);
 		break;
 	case VM_PKT_DATA_USING_XFER_PAGES:
-		return netvsc_receive(ndev, net_device, nvchan,
+		return netvsc_receive(ndev, net_device, nvchan, desc);
-				      desc, nvmsg);
 		break;
 	case VM_PKT_DATA_INBAND:
-		netvsc_receive_inband(ndev, net_device, nvmsg, msglen);
+		netvsc_receive_inband(ndev, net_device, desc);
 		break;
 	default:

drivers/net/hyperv/netvsc_drv.c+29−6

 	struct netvsc_reconfig *event;
 	unsigned long flags;
+	/* Ensure the packet is big enough to access its fields */
+	if (resp->msg_len - RNDIS_HEADER_SIZE < sizeof(struct rndis_indicate_status)) {
+		netdev_err(net, "invalid rndis_indicate_status packet, len: %u\n",
+			   resp->msg_len);
+		return;
+	}
 	/* Update the physical link speed when changing to another vSwitch */
 	if (indicate->status == RNDIS_STATUS_LINK_SPEED_CHANGE) {
 		u32 speed;
 	return NOTIFY_OK;
 }
-/* VF up/down change detected, schedule to change data path */
+/* Change the data path when VF UP/DOWN/CHANGE are detected.
+ *
+ * Typically a UP or DOWN event is followed by a CHANGE event, so
+ * net_device_ctx->data_path_is_vf is used to cache the current data path
+ * to avoid the duplicate call of netvsc_switch_datapath() and the duplicate
+ * message.
+ *
+ * During hibernation, if a VF NIC driver (e.g. mlx5) preserves the network
+ * interface, there is only the CHANGE event and no UP or DOWN event.
+ */
 static int netvsc_vf_changed(struct net_device *vf_netdev)
 {
 	struct net_device_context *net_device_ctx;
 	if (!netvsc_dev)
 		return NOTIFY_DONE;
+	if (net_device_ctx->data_path_is_vf == vf_is_up)
+		return NOTIFY_OK;
+	net_device_ctx->data_path_is_vf = vf_is_up;
 	netvsc_switch_datapath(ndev, vf_is_up);
 	netdev_info(ndev, "Data path switched %s VF: %s\n",
 		    vf_is_up ? "to" : "from", vf_netdev->name);
 static int netvsc_suspend(struct hv_device *dev)
 {
 	struct net_device_context *ndev_ctx;
-	struct net_device *vf_netdev, *net;
 	struct netvsc_device *nvdev;
+	struct net_device *net;
 	int ret;
 	net = hv_get_drvdata(dev);
 		goto out;
 	}
-	vf_netdev = rtnl_dereference(ndev_ctx->vf_netdev);
-	if (vf_netdev)
-		netvsc_unregister_vf(vf_netdev);
 	/* Save the current config info */
 	ndev_ctx->saved_netvsc_dev_info = netvsc_devinfo_get(nvdev);
 	rtnl_lock();
 	net_device_ctx = netdev_priv(net);
+	/* Reset the data path to the netvsc NIC before re-opening the vmbus
+	 * channel. Later netvsc_netdev_event() will switch the data path to
+	 * the VF upon the UP or CHANGE event.
+	 */
+	net_device_ctx->data_path_is_vf = false;
 	device_info = net_device_ctx->saved_netvsc_dev_info;
 	ret = netvsc_attach(net, device_info);
 		return netvsc_unregister_vf(event_dev);
 	case NETDEV_UP:
 	case NETDEV_DOWN:
+	case NETDEV_CHANGE:
 		return netvsc_vf_changed(event_dev);
 	default:
 		return NOTIFY_DONE;

drivers/net/hyperv/rndis_filter.c+66−7

@@ -275,6 +275,16 @@ static void rndis_filter_receive_response(struct net_device *ndev, · 274 unmodified lines
275	return;	275	return;
276	}	276	}
277		277
		278	/* Ensure the packet is big enough to read req_id. Req_id is the 1st
		279	* field in any request/response message, so the payload should have at
		280	* least sizeof(u32) bytes
		281	*/
		282	if (resp->msg_len - RNDIS_HEADER_SIZE < sizeof(u32)) {
		283	netdev_err(ndev, "rndis msg_len too small: %u\n",
		284	resp->msg_len);
		285	return;
		286	}
		287
278	spin_lock_irqsave(&dev->request_lock, flags);	288	spin_lock_irqsave(&dev->request_lock, flags);
279	list_for_each_entry(request, &dev->req_list, list_ent) {	289	list_for_each_entry(request, &dev->req_list, list_ent) {
280	/*	290	/*
@@ -331,8 +341,9 @@ static void rndis_filter_receive_response(struct net_device *ndev, · 50 unmodified lines
331	* Get the Per-Packet-Info with the specified type	341	* Get the Per-Packet-Info with the specified type
332	* return NULL if not found.	342	* return NULL if not found.
333	*/	343	*/
334	static inline void rndis_get_ppi(struct rndis_packet rpkt,	344	static inline void rndis_get_ppi(struct net_device ndev,
335	u32 type, u8 internal)	345	struct rndis_packet *rpkt,
		346	u32 rpkt_len, u32 type, u8 internal)
336	{	347	{
337	struct rndis_per_packet_info *ppi;	348	struct rndis_per_packet_info *ppi;
338	int len;	349	int len;
@@ -340,11 +351,36 @@ static inline void rndis_get_ppi(struct rndis_packet rpkt, · 1 unmodified line
340	if (rpkt->per_pkt_info_offset == 0)	351	if (rpkt->per_pkt_info_offset == 0)
341	return NULL;	352	return NULL;
342		353
		354	/* Validate info_offset and info_len */
		355	if (rpkt->per_pkt_info_offset < sizeof(struct rndis_packet) \|\|
		356	rpkt->per_pkt_info_offset > rpkt_len) {
		357	netdev_err(ndev, "Invalid per_pkt_info_offset: %u\n",
		358	rpkt->per_pkt_info_offset);
		359	return NULL;
		360	}
		361
		362	if (rpkt->per_pkt_info_len > rpkt_len - rpkt->per_pkt_info_offset) {
		363	netdev_err(ndev, "Invalid per_pkt_info_len: %u\n",
		364	rpkt->per_pkt_info_len);
		365	return NULL;
		366	}
		367
343	ppi = (struct rndis_per_packet_info *)((ulong)rpkt +	368	ppi = (struct rndis_per_packet_info *)((ulong)rpkt +
344	rpkt->per_pkt_info_offset);	369	rpkt->per_pkt_info_offset);
345	len = rpkt->per_pkt_info_len;	370	len = rpkt->per_pkt_info_len;
346		371
347	while (len > 0) {	372	while (len > 0) {
		373	/* Validate ppi_offset and ppi_size */
		374	if (ppi->size > len) {
		375	netdev_err(ndev, "Invalid ppi size: %u\n", ppi->size);
		376	continue;
		377	}
		378
		379	if (ppi->ppi_offset >= ppi->size) {
		380	netdev_err(ndev, "Invalid ppi_offset: %u\n", ppi->ppi_offset);
		381	continue;
		382	}
		383
348	if (ppi->type == type && ppi->internal == internal)	384	if (ppi->type == type && ppi->internal == internal)
349	return (void *)((ulong)ppi + ppi->ppi_offset);	385	return (void *)((ulong)ppi + ppi->ppi_offset);
350	len -= ppi->size;	386	len -= ppi->size;
@@ -388,14 +424,29 @@ static int rndis_filter_receive_data(struct net_device *ndev, · 37 unmodified lines
388	const struct ndis_pkt_8021q_info *vlan;	424	const struct ndis_pkt_8021q_info *vlan;
389	const struct rndis_pktinfo_id *pktinfo_id;	425	const struct rndis_pktinfo_id *pktinfo_id;
390	const u32 *hash_info;	426	const u32 *hash_info;
391	u32 data_offset;	427	u32 data_offset, rpkt_len;
392	void *data;	428	void *data;
393	bool rsc_more = false;	429	bool rsc_more = false;
394	int ret;	430	int ret;
395		431
		432	/* Ensure data_buflen is big enough to read header fields */
		433	if (data_buflen < RNDIS_HEADER_SIZE + sizeof(struct rndis_packet)) {
		434	netdev_err(ndev, "invalid rndis pkt, data_buflen too small: %u\n",
		435	data_buflen);
		436	return NVSP_STAT_FAIL;
		437	}
		438
		439	/* Validate rndis_pkt offset */
		440	if (rndis_pkt->data_offset >= data_buflen - RNDIS_HEADER_SIZE) {
		441	netdev_err(ndev, "invalid rndis packet offset: %u\n",
		442	rndis_pkt->data_offset);
		443	return NVSP_STAT_FAIL;
		444	}
		445
396	/* Remove the rndis header and pass it back up the stack */	446	/* Remove the rndis header and pass it back up the stack */
397	data_offset = RNDIS_HEADER_SIZE + rndis_pkt->data_offset;	447	data_offset = RNDIS_HEADER_SIZE + rndis_pkt->data_offset;
398		448
		449	rpkt_len = data_buflen - RNDIS_HEADER_SIZE;
399	data_buflen -= data_offset;	450	data_buflen -= data_offset;
400		451
401	/*	452	/*
@@ -410,13 +461,13 @@ static int rndis_filter_receive_data(struct net_device *ndev, · 8 unmodified lines
410	return NVSP_STAT_FAIL;	461	return NVSP_STAT_FAIL;
411	}	462	}
412		463
413	vlan = rndis_get_ppi(rndis_pkt, IEEE_8021Q_INFO, 0);	464	vlan = rndis_get_ppi(ndev, rndis_pkt, rpkt_len, IEEE_8021Q_INFO, 0);
414		465
415	csum_info = rndis_get_ppi(rndis_pkt, TCPIP_CHKSUM_PKTINFO, 0);	466	csum_info = rndis_get_ppi(ndev, rndis_pkt, rpkt_len, TCPIP_CHKSUM_PKTINFO, 0);
416		467
417	hash_info = rndis_get_ppi(rndis_pkt, NBL_HASH_VALUE, 0);	468	hash_info = rndis_get_ppi(ndev, rndis_pkt, rpkt_len, NBL_HASH_VALUE, 0);
418		469
419	pktinfo_id = rndis_get_ppi(rndis_pkt, RNDIS_PKTINFO_ID, 1);	470	pktinfo_id = rndis_get_ppi(ndev, rndis_pkt, rpkt_len, RNDIS_PKTINFO_ID, 1);
420		471
421	data = (void *)msg + data_offset;	472	data = (void *)msg + data_offset;
422		473
@@ -474,6 +525,14 @@ int rndis_filter_receive(struct net_device *ndev, · 51 unmodified lines
474	if (netif_msg_rx_status(net_device_ctx))	525	if (netif_msg_rx_status(net_device_ctx))
475	dump_rndis_message(ndev, rndis_msg);	526	dump_rndis_message(ndev, rndis_msg);
476		527
		528	/* Validate incoming rndis_message packet */
		529	if (buflen < RNDIS_HEADER_SIZE \|\| rndis_msg->msg_len < RNDIS_HEADER_SIZE \|\|
		530	buflen < rndis_msg->msg_len) {
		531	netdev_err(ndev, "Invalid rndis_msg (buflen: %u, msg_len: %u)\n",
		532	buflen, rndis_msg->msg_len);
		533	return NVSP_STAT_FAIL;
		534	}
		535
477	switch (rndis_msg->ndis_msg_type) {	536	switch (rndis_msg->ndis_msg_type) {
478	case RNDIS_MSG_PACKET:	537	case RNDIS_MSG_PACKET:
479	return rndis_filter_receive_data(ndev, net_dev, nvchan,	538	return rndis_filter_receive_data(ndev, net_dev, nvchan,

drivers/net/ieee802154/adf7242.c+3−1

@@ -882,7 +882,9 @@ static int adf7242_rx(struct adf7242_local *lp) · 881 unmodified lines
882	int ret;	882	int ret;
883	u8 lqi, len_u8, *data;	883	u8 lqi, len_u8, *data;
884		884
885	adf7242_read_reg(lp, 0, &len_u8);	885	ret = adf7242_read_reg(lp, 0, &len_u8);
		886	if (ret)
		887	return ret;
886		888
887	len = len_u8;	889	len = len_u8;
888		890

drivers/net/ieee802154/ca8210.c+1−0

@@ -2925,6 +2925,7 @@ static int ca8210_dev_com_init(struct ca8210_priv *priv) · 2924 unmodified lines
2925	);	2925	);
2926	if (!priv->irq_workqueue) {	2926	if (!priv->irq_workqueue) {
2927	dev_crit(&priv->spi->dev, "alloc of irq_workqueue failed!\n");	2927	dev_crit(&priv->spi->dev, "alloc of irq_workqueue failed!\n");
		2928	destroy_workqueue(priv->mlme_workqueue);
2928	return -ENOMEM;	2929	return -ENOMEM;
2929	}	2930	}
2930		2931

drivers/net/ipa/ipa_table.c+2−2

@@ -521,7 +521,7 @@ static void ipa_filter_tuple_zero(struct ipa_endpoint *endpoint) · 520 unmodified lines
521	val = ioread32(endpoint->ipa->reg_virt + offset);	521	val = ioread32(endpoint->ipa->reg_virt + offset);
522		522
523	/* Zero all filter-related fields, preserving the rest */	523	/* Zero all filter-related fields, preserving the rest */
524	u32_replace_bits(val, 0, IPA_REG_ENDP_FILTER_HASH_MSK_ALL);	524	u32p_replace_bits(&val, 0, IPA_REG_ENDP_FILTER_HASH_MSK_ALL);
525		525
526	iowrite32(val, endpoint->ipa->reg_virt + offset);	526	iowrite32(val, endpoint->ipa->reg_virt + offset);
527	}	527	}
@@ -573,7 +573,7 @@ static void ipa_route_tuple_zero(struct ipa *ipa, u32 route_id) · 45 unmodified lines
573	val = ioread32(ipa->reg_virt + offset);	573	val = ioread32(ipa->reg_virt + offset);
574		574
575	/* Zero all route-related fields, preserving the rest */	575	/* Zero all route-related fields, preserving the rest */
576	u32_replace_bits(val, 0, IPA_REG_ENDP_ROUTER_HASH_MSK_ALL);	576	u32p_replace_bits(&val, 0, IPA_REG_ENDP_ROUTER_HASH_MSK_ALL);
577		577
578	iowrite32(val, ipa->reg_virt + offset);	578	iowrite32(val, ipa->reg_virt + offset);
579	}	579	}

drivers/net/phy/phy.c+1−1

@@ -996,7 +996,7 @@ void phy_stop(struct phy_device *phydev) · 995 unmodified lines
996	{	996	{
997	struct net_device *dev = phydev->attached_dev;	997	struct net_device *dev = phydev->attached_dev;
998		998
999	if (!phy_is_started(phydev)) {	999	if (!phy_is_started(phydev) && phydev->state != PHY_DOWN) {
1000	WARN(1, "called from state %s\n",	1000	WARN(1, "called from state %s\n",
1001	phy_state_to_str(phydev->state));	1001	phy_state_to_str(phydev->state));
1002	return;	1002	return;

drivers/net/phy/phy_device.c+6−5

 	if (ret < 0)
 		return ret;
-	ret = phy_disable_interrupts(phydev);
-	if (ret)
-		return ret;
 	if (phydev->drv->config_init)
 		ret = phydev->drv->config_init(phydev);
 	if (err)
 		goto error;
+	err = phy_disable_interrupts(phydev);
+	if (err)
+		return err;
 	phy_resume(phydev);
 	phy_led_triggers_register(phydev);
 	phy_led_triggers_unregister(phydev);
-	module_put(phydev->mdio.dev.driver->owner);
+	if (phydev->mdio.dev.driver)
+		module_put(phydev->mdio.dev.driver->owner);
 	/* If the device had no specific driver before (i.e. - it
 	 * was using the generic driver), we unbind the device

drivers/net/usb/rndis_host.c+1−1

@@ -201,7 +201,7 @@ int rndis_command(struct usbnet dev, struct rndis_msg_hdr buf, int buflen) · 200 unmodified lines
201	dev_dbg(&info->control->dev,	201	dev_dbg(&info->control->dev,
202	"rndis response error, code %d\n", retval);	202	"rndis response error, code %d\n", retval);
203	}	203	}
204	msleep(20);	204	msleep(40);
205	}	205	}
206	dev_dbg(&info->control->dev, "rndis response timeout\n");	206	dev_dbg(&info->control->dev, "rndis response timeout\n");
207	return -ETIMEDOUT;	207	return -ETIMEDOUT;

drivers/net/wan/hdlc_cisco.c+1−0

@@ -118,6 +118,7 @@ static void cisco_keepalive_send(struct net_device *dev, u32 type, · 117 unmodified lines
118	skb_put(skb, sizeof(struct cisco_packet));	118	skb_put(skb, sizeof(struct cisco_packet));
119	skb->priority = TC_PRIO_CONTROL;	119	skb->priority = TC_PRIO_CONTROL;
120	skb->dev = dev;	120	skb->dev = dev;
		121	skb->protocol = htons(ETH_P_HDLC);
121	skb_reset_network_header(skb);	122	skb_reset_network_header(skb);
122		123
123	dev_queue_xmit(skb);	124	dev_queue_xmit(skb);

drivers/net/wan/hdlc_fr.c+5−1

 			if (pvc->state.fecn) /* TX Congestion counter */
 				dev->stats.tx_compressed++;
 			skb->dev = pvc->frad;
+			skb->protocol = htons(ETH_P_HDLC);
+			skb_reset_network_header(skb);
 			dev_queue_xmit(skb);
 			return NETDEV_TX_OK;
 		}
 	skb_put(skb, i);
 	skb->priority = TC_PRIO_CONTROL;
 	skb->dev = dev;
+	skb->protocol = htons(ETH_P_HDLC);
 	skb_reset_network_header(skb);
 	dev_queue_xmit(skb);
 {
 	dev->type = ARPHRD_DLCI;
 	dev->flags = IFF_POINTOPOINT;
-	dev->hard_header_len = 10;
+	dev->hard_header_len = 0;
 	dev->addr_len = 2;
 	netif_keep_dst(dev);
 }
 	dev->mtu = HDLC_MAX_MTU;
 	dev->min_mtu = 68;
 	dev->max_mtu = HDLC_MAX_MTU;
+	dev->needed_headroom = 10;
 	dev->priv_flags |= IFF_NO_QUEUE;
 	dev->ml_priv = pvc;

drivers/net/wan/hdlc_ppp.c+12−5

 	skb->priority = TC_PRIO_CONTROL;
 	skb->dev = dev;
+	skb->protocol = htons(ETH_P_HDLC);
 	skb_reset_network_header(skb);
 	skb_queue_tail(&tx_queue, skb);
 }
 	}
 	for (opt = data; len; len -= opt[1], opt += opt[1]) {
-		if (len < 2 || len < opt[1]) {
+		if (len < 2 || opt[1] < 2 || len < opt[1])
-			dev->stats.rx_errors++;
+			goto err_out;
-			kfree(out);
-			return; /* bad packet, drop silently */
-		}
 		if (pid == PID_LCP)
 			switch (opt[0]) {
 				continue; /* MRU always OK and > 1500 bytes? */
 			case LCP_OPTION_ACCM: /* async control character map */
+				if (opt[1] < sizeof(valid_accm))
+					goto err_out;
 				if (!memcmp(opt, valid_accm,
 					    sizeof(valid_accm)))
 					continue;
 				}
 				break;
 			case LCP_OPTION_MAGIC:
+				if (len < 6)
+					goto err_out;
 				if (opt[1] != 6 || (!opt[2] && !opt[3] &&
 						    !opt[4] && !opt[5]))
 					break; /* reject invalid magic number */
 		ppp_cp_event(dev, pid, RCR_GOOD, CP_CONF_ACK, id, req_len, data);
 	kfree(out);
+	return;
+err_out:
+	dev->stats.rx_errors++;
+	kfree(out);
 }
 static int ppp_rx(struct sk_buff *skb)

drivers/net/wan/lapbether.c+2−2

 	struct net_device *dev;
 	int size = skb->len;
-	skb->protocol = htons(ETH_P_X25);
 	ptr = skb_push(skb, 2);
 	*ptr++ = size % 256;
 	skb->dev = dev = lapbeth->ethdev;
+	skb->protocol = htons(ETH_P_DEC);
 	skb_reset_network_header(skb);
 	dev_hard_header(skb, dev, ETH_P_DEC, bcast_addr, NULL, 0);

drivers/net/wireguard/noise.c+1−4

 void wg_noise_handshake_clear(struct noise_handshake *handshake)
 {
+	down_write(&handshake->lock);
 	wg_index_hashtable_remove(
 			handshake->entry.peer->device->index_hashtable,
 			&handshake->entry);
-	down_write(&handshake->lock);
 	handshake_zero(handshake);
 	up_write(&handshake->lock);
-	wg_index_hashtable_remove(
-			handshake->entry.peer->device->index_hashtable,
-			&handshake->entry);
 }
 static struct noise_keypair *keypair_create(struct wg_peer *peer)

drivers/net/wireguard/peerlookup.c+8−3

@@ -167,9 +167,13 @@ bool wg_index_hashtable_replace(struct index_hashtable *table, · 166 unmodified lines
167	struct index_hashtable_entry *old,	167	struct index_hashtable_entry *old,
168	struct index_hashtable_entry *new)	168	struct index_hashtable_entry *new)
169	{	169	{
170	if (unlikely(hlist_unhashed(&old->index_hash)))	170	bool ret;
171	return false;	171
172	spin_lock_bh(&table->lock);	172	spin_lock_bh(&table->lock);
		173	ret = !hlist_unhashed(&old->index_hash);
		174	if (unlikely(!ret))
		175	goto out;
		176
173	new->index = old->index;	177	new->index = old->index;
174	hlist_replace_rcu(&old->index_hash, &new->index_hash);	178	hlist_replace_rcu(&old->index_hash, &new->index_hash);
175		179
@@ -180,8 +184,9 @@ bool wg_index_hashtable_replace(struct index_hashtable *table, · 4 unmodified lines
180	* simply gets dropped, which isn't terrible.	184	* simply gets dropped, which isn't terrible.
181	*/	185	*/
182	INIT_HLIST_NODE(&old->index_hash);	186	INIT_HLIST_NODE(&old->index_hash);
		187	out:
183	spin_unlock_bh(&table->lock);	188	spin_unlock_bh(&table->lock);
184	return true;	189	return ret;
185	}	190	}
186		191
187	void wg_index_hashtable_remove(struct index_hashtable *table,	192	void wg_index_hashtable_remove(struct index_hashtable *table,

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c+9−3

@@ -664,9 +664,15 @@ static void pkt_align(struct sk_buff *p, int len, int align) · 663 unmodified lines
664	/* To check if there's window offered */	664	/* To check if there's window offered */
665	static bool data_ok(struct brcmf_sdio *bus)	665	static bool data_ok(struct brcmf_sdio *bus)
666	{	666	{
667	/* Reserve TXCTL_CREDITS credits for txctl */	667	u8 tx_rsv = 0;
668	return (bus->tx_max - bus->tx_seq) > TXCTL_CREDITS &&	668
669	((bus->tx_max - bus->tx_seq) & 0x80) == 0;	669	/* Reserve TXCTL_CREDITS credits for txctl when it is ready to send */
		670	if (bus->ctrl_frame_stat)
		671	tx_rsv = TXCTL_CREDITS;
		672
		673	return (bus->tx_max - bus->tx_seq - tx_rsv) != 0 &&
		674	((bus->tx_max - bus->tx_seq - tx_rsv) & 0x80) == 0;
		675
670	}	676	}
671		677
672	/* To check if there's window offered */	678	/* To check if there's window offered */

drivers/net/wireless/marvell/mwifiex/fw.h+1−1

@@ -954,7 +954,7 @@ struct mwifiex_tkip_param { · 953 unmodified lines
954	struct mwifiex_aes_param {	954	struct mwifiex_aes_param {
955	u8 pn[WPA_PN_SIZE];	955	u8 pn[WPA_PN_SIZE];
956	__le16 key_len;	956	__le16 key_len;
957	u8 key[WLAN_KEY_LEN_CCMP];	957	u8 key[WLAN_KEY_LEN_CCMP_256];
958	} __packed;	958	} __packed;
959		959
960	struct mwifiex_wapi_param {	960	struct mwifiex_wapi_param {

drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c+2−2

@@ -619,7 +619,7 @@ static int mwifiex_ret_802_11_key_material_v2(struct mwifiex_private *priv, · 618 unmodified lines
619	key_v2 = &resp->params.key_material_v2;	619	key_v2 = &resp->params.key_material_v2;
620		620
621	len = le16_to_cpu(key_v2->key_param_set.key_params.aes.key_len);	621	len = le16_to_cpu(key_v2->key_param_set.key_params.aes.key_len);
622	if (len > WLAN_KEY_LEN_CCMP)	622	if (len > sizeof(key_v2->key_param_set.key_params.aes.key))
623	return -EINVAL;	623	return -EINVAL;
624		624
625	if (le16_to_cpu(key_v2->action) == HostCmd_ACT_GEN_SET) {	625	if (le16_to_cpu(key_v2->action) == HostCmd_ACT_GEN_SET) {
@@ -635,7 +635,7 @@ static int mwifiex_ret_802_11_key_material_v2(struct mwifiex_private *priv, · 9 unmodified lines
635	return 0;	635	return 0;
636		636
637	memset(priv->aes_key_v2.key_param_set.key_params.aes.key, 0,	637	memset(priv->aes_key_v2.key_param_set.key_params.aes.key, 0,
638	WLAN_KEY_LEN_CCMP);	638	sizeof(key_v2->key_param_set.key_params.aes.key));
639	priv->aes_key_v2.key_param_set.key_params.aes.key_len =	639	priv->aes_key_v2.key_param_set.key_params.aes.key_len =
640	cpu_to_le16(len);	640	cpu_to_le16(len);
641	memcpy(priv->aes_key_v2.key_param_set.key_params.aes.key,	641	memcpy(priv->aes_key_v2.key_param_set.key_params.aes.key,

drivers/net/wireless/mediatek/mt76/mt7615/mcu.c+2−1

@@ -2128,7 +2128,8 @@ static int mt7615_load_n9(struct mt7615_dev dev, const char name) · 2127 unmodified lines
2128	sizeof(dev->mt76.hw->wiphy->fw_version),	2128	sizeof(dev->mt76.hw->wiphy->fw_version),
2129	"%.10s-%.15s", hdr->fw_ver, hdr->build_date);	2129	"%.10s-%.15s", hdr->fw_ver, hdr->build_date);
2130		2130
2131	if (!strncmp(hdr->fw_ver, "2.0", sizeof(hdr->fw_ver))) {	2131	if (!is_mt7615(&dev->mt76) &&
		2132	!strncmp(hdr->fw_ver, "2.0", sizeof(hdr->fw_ver))) {
2132	dev->fw_ver = MT7615_FIRMWARE_V2;	2133	dev->fw_ver = MT7615_FIRMWARE_V2;
2133	dev->mcu_ops = &sta_update_ops;	2134	dev->mcu_ops = &sta_update_ops;
2134	} else {	2135	} else {

drivers/net/wireless/mediatek/mt76/mt7915/init.c+6−2

 	spin_lock_bh(&dev->token_lock);
 	idr_for_each_entry(&dev->token, txwi, id) {
 		mt7915_txp_skb_unmap(&dev->mt76, txwi);
-		if (txwi->skb)
+		if (txwi->skb) {
-			dev_kfree_skb_any(txwi->skb);
+			struct ieee80211_hw *hw;
+			hw = mt76_tx_status_get_hw(&dev->mt76, txwi->skb);
+			ieee80211_free_txskb(hw, txwi->skb);
+		}
 		mt76_put_txwi(&dev->mt76, txwi);
 	}
 	spin_unlock_bh(&dev->token_lock);

drivers/net/wireless/mediatek/mt76/mt7915/mac.c+1−1

@@ -841,7 +841,7 @@ mt7915_tx_complete_status(struct mt76_dev mdev, struct sk_buff skb, · 840 unmodified lines
841	if (sta \|\| !(info->flags & IEEE80211_TX_CTL_NO_ACK))	841	if (sta \|\| !(info->flags & IEEE80211_TX_CTL_NO_ACK))
842	mt7915_tx_status(sta, hw, info, NULL);	842	mt7915_tx_status(sta, hw, info, NULL);
843		843
844	dev_kfree_skb(skb);	844	ieee80211_free_txskb(hw, skb);
845	}	845	}
846		846
847	void mt7915_txp_skb_unmap(struct mt76_dev *dev,	847	void mt7915_txp_skb_unmap(struct mt76_dev *dev,

drivers/net/wireless/ti/wlcore/cmd.h+0−1

@@ -458,7 +458,6 @@ enum wl1271_cmd_key_type { · 457 unmodified lines
458	KEY_TKIP = 2,	458	KEY_TKIP = 2,
459	KEY_AES = 3,	459	KEY_AES = 3,
460	KEY_GEM = 4,	460	KEY_GEM = 4,
461	KEY_IGTK = 5,
462	};	461	};
463		462
464	struct wl1271_cmd_set_keys {	463	struct wl1271_cmd_set_keys {

drivers/net/wireless/ti/wlcore/main.c+0−4

 	case WL1271_CIPHER_SUITE_GEM:
 		key_type = KEY_GEM;
 		break;
-	case WLAN_CIPHER_SUITE_AES_CMAC:
-		key_type = KEY_IGTK;
-		break;
 	default:
 		wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
 		WLAN_CIPHER_SUITE_TKIP,
 		WLAN_CIPHER_SUITE_CCMP,
 		WL1271_CIPHER_SUITE_GEM,
-		WLAN_CIPHER_SUITE_AES_CMAC,
 	};
 	/* The tx descriptor buffer */

drivers/s390/net/qeth_l2_main.c+1−1

 	if (card->state == CARD_STATE_SOFTSETUP) {
 		qeth_clear_ipacmd_list(card);
-		qeth_drain_output_queues(card);
 		card->state = CARD_STATE_DOWN;
 	}
 	qeth_qdio_clear_card(card, 0);
+	qeth_drain_output_queues(card);
 	qeth_clear_working_pool_list(card);
 	flush_workqueue(card->event_wq);
 	qeth_flush_local_addrs(card);

drivers/s390/net/qeth_l3_main.c+1−1

 	if (card->state == CARD_STATE_SOFTSETUP) {
 		qeth_l3_clear_ip_htable(card, 1);
 		qeth_clear_ipacmd_list(card);
-		qeth_drain_output_queues(card);
 		card->state = CARD_STATE_DOWN;
 	}
 	qeth_qdio_clear_card(card, 0);
+	qeth_drain_output_queues(card);
 	qeth_clear_working_pool_list(card);
 	flush_workqueue(card->event_wq);
 	qeth_flush_local_addrs(card);

include/linux/netdev_features.h+1−1

@@ -193,7 +193,7 @@ static inline int find_next_netdev_feature(u64 feature, unsigned long start) · 192 unmodified lines
193	#define NETIF_F_GSO_MASK (__NETIF_F_BIT(NETIF_F_GSO_LAST + 1) - \	193	#define NETIF_F_GSO_MASK (__NETIF_F_BIT(NETIF_F_GSO_LAST + 1) - \
194	__NETIF_F_BIT(NETIF_F_GSO_SHIFT))	194	__NETIF_F_BIT(NETIF_F_GSO_SHIFT))
195		195
196	/* List of IP checksum features. Note that NETIF_F_ HW_CSUM should not be	196	/* List of IP checksum features. Note that NETIF_F_HW_CSUM should not be
197	* set in features when NETIF_F_IP_CSUM or NETIF_F_IPV6_CSUM are set--	197	* set in features when NETIF_F_IP_CSUM or NETIF_F_IPV6_CSUM are set--
198	* this would be contradictory	198	* this would be contradictory
199	*/	199	*/

include/linux/netdevice.h+2−0

  *				the watchdog (see dev_watchdog())
  *	@watchdog_timer:	List of timers
  *
+ *	@proto_down_reason:	reason a netdev interface is held down
  *	@pcpu_refcnt:		Number of references to this device
  *	@todo_list:		Delayed register/unregister
  *	@link_watch_list:	XXX: need comments on this one
  *	@udp_tunnel_nic_info:	static structure describing the UDP tunnel
  *				offload capabilities of the device
  *	@udp_tunnel_nic:	UDP tunnel offload state
+ *	@xdp_state:		stores info on attached XDP BPF programs
  *
  *	FIXME: cleanup struct net_device such that network protocol info
  *	moves out.

include/linux/qed/qed_if.h+1−0

@@ -623,6 +623,7 @@ struct qed_dev_info { · 622 unmodified lines
623	#define QED_MFW_VERSION_3_OFFSET 24	623	#define QED_MFW_VERSION_3_OFFSET 24
624		624
625	u32 flash_size;	625	u32 flash_size;
		626	bool b_arfs_capable;
626	bool b_inter_pf_switch;	627	bool b_inter_pf_switch;
627	bool tx_switching;	628	bool tx_switching;
628	bool rdma_supported;	629	bool rdma_supported;

include/linux/skbuff.h+4−3

  *	is untouched. Otherwise it is extended. Returns zero on
  *	success. The skb is freed on error if @free_on_error is true.
  */
-static inline int __skb_put_padto(struct sk_buff *skb, unsigned int len,
+static inline int __must_check __skb_put_padto(struct sk_buff *skb,
-				  bool free_on_error)
+					       unsigned int len,
+					       bool free_on_error)
 {
 	unsigned int size = skb->len;
  *	is untouched. Otherwise it is extended. Returns zero on
  *	success. The skb is freed on error.
  */
-static inline int skb_put_padto(struct sk_buff *skb, unsigned int len)
+static inline int __must_check skb_put_padto(struct sk_buff *skb, unsigned int len)
 {
 	return __skb_put_padto(skb, len, true);
 }

include/net/flow.h+1−0

@@ -116,6 +116,7 @@ static inline void flowi4_init_output(struct flowi4 *fl4, int oif, · 115 unmodified lines
116	fl4->saddr = saddr;	116	fl4->saddr = saddr;
117	fl4->fl4_dport = dport;	117	fl4->fl4_dport = dport;
118	fl4->fl4_sport = sport;	118	fl4->fl4_sport = sport;
		119	fl4->flowi4_multipath_hash = 0;
119	}	120	}
120		121
121	/* Reset some input parameters after previous lookup */	122	/* Reset some input parameters after previous lookup */

include/net/netlink.h+0−2

  * @hdrlen: length of family specific header
  * @tb: destination array with maxtype+1 elements
  * @maxtype: maximum attribute type to be expected
- * @validate: validation strictness
  * @extack: extended ACK report struct
  *
  * See nla_parse()
  * @len: length of attribute stream
  * @maxtype: maximum attribute type to be expected
  * @policy: validation policy
- * @validate: validation strictness
  * @extack: extended ACK report struct
  *
  * Validates all attributes in the specified attribute stream against the

include/net/netns/nftables.h+1−0

@@ -8,6 +8,7 @@ struct netns_nftables { · 7 unmodified lines
8	struct list_head tables;	8	struct list_head tables;
9	struct list_head commit_list;	9	struct list_head commit_list;
10	struct list_head module_list;	10	struct list_head module_list;
		11	struct list_head notify_list;
11	struct mutex commit_mutex;	12	struct mutex commit_mutex;
12	unsigned int base_seq;	13	unsigned int base_seq;
13	u8 gencursor;	14	u8 gencursor;

include/net/sctp/structs.h+5−3

 		data_ready_signalled:1;
 	atomic_t pd_mode;
+	/* Fields after this point will be skipped on copies, like on accept
+	 * and peeloff operations
+	 */
 	/* Receive to here while partial delivery is in effect. */
 	struct sk_buff_head pd_lobby;
-	/* These must be the last fields, as they will skipped on copies,
-	 * like on accept and peeloff operations
-	 */
 	struct list_head auto_asconf_list;
 	int do_auto_asconf;
 };

include/net/vxlan.h+3−0

@@ -121,6 +121,9 @@ struct vxlanhdr_gbp { · 120 unmodified lines
121	#define VXLAN_GBP_POLICY_APPLIED (BIT(3) << 16)	121	#define VXLAN_GBP_POLICY_APPLIED (BIT(3) << 16)
122	#define VXLAN_GBP_ID_MASK (0xFFFF)	122	#define VXLAN_GBP_ID_MASK (0xFFFF)
123		123
		124	#define VXLAN_GBP_MASK (VXLAN_GBP_DONT_LEARN \| VXLAN_GBP_POLICY_APPLIED \| \
		125	VXLAN_GBP_ID_MASK)
		126
124	/*	127	/*
125	* VXLAN Generic Protocol Extension (VXLAN_F_GPE):	128	* VXLAN Generic Protocol Extension (VXLAN_F_GPE):
126	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	129	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

include/soc/mscc/ocelot.h+2−0

 	u8				ptp_cmd;
 	struct sk_buff_head		tx_skbs;
 	u8				ts_id;
+	spinlock_t			ts_id_lock;
 	phy_interface_t			phy_mode;
 int ocelot_init(struct ocelot *ocelot);
 void ocelot_deinit(struct ocelot *ocelot);
 void ocelot_init_port(struct ocelot *ocelot, int port);
+void ocelot_deinit_port(struct ocelot *ocelot, int port);
 /* DSA callbacks */
 void ocelot_port_enable(struct ocelot *ocelot, int port,

include/uapi/linux/ethtool_netlink.h+1−0

@@ -79,6 +79,7 @@ enum { · 78 unmodified lines
79	ETHTOOL_MSG_TSINFO_GET_REPLY,	79	ETHTOOL_MSG_TSINFO_GET_REPLY,
80	ETHTOOL_MSG_CABLE_TEST_NTF,	80	ETHTOOL_MSG_CABLE_TEST_NTF,
81	ETHTOOL_MSG_CABLE_TEST_TDR_NTF,	81	ETHTOOL_MSG_CABLE_TEST_TDR_NTF,
		82	ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY,
82		83
83	/* add new constants above here */	84	/* add new constants above here */
84	__ETHTOOL_MSG_KERNEL_CNT,	85	__ETHTOOL_MSG_KERNEL_CNT,

kernel/bpf/hashtab.c+4−11

 	struct bpf_map *map;
 	struct bpf_htab *htab;
 	void *percpu_value_buf; // non-zero means percpu hash
-	unsigned long flags;
 	u32 bucket_id;
 	u32 skip_elems;
 };
 			   struct htab_elem *prev_elem)
 {
 	const struct bpf_htab *htab = info->htab;
-	unsigned long flags = info->flags;
 	u32 skip_elems = info->skip_elems;
 	u32 bucket_id = info->bucket_id;
 	struct hlist_nulls_head *head;
 		/* not found, unlock and go to the next bucket */
 		b = &htab->buckets[bucket_id++];
-		htab_unlock_bucket(htab, b, flags);
+		rcu_read_unlock();
 		skip_elems = 0;
 	}
 	for (i = bucket_id; i < htab->n_buckets; i++) {
 		b = &htab->buckets[i];
-		flags = htab_lock_bucket(htab, b);
+		rcu_read_lock();
 		count = 0;
 		head = &b->head;
 		hlist_nulls_for_each_entry_rcu(elem, n, head, hash_node) {
 			if (count >= skip_elems) {
-				info->flags = flags;
 				info->bucket_id = i;
 				info->skip_elems = count;
 				return elem;
 			count++;
 		}
-		htab_unlock_bucket(htab, b, flags);
+		rcu_read_unlock();
 		skip_elems = 0;
 	}
 static void bpf_hash_map_seq_stop(struct seq_file *seq, void *v)
 {
-	struct bpf_iter_seq_hash_map_info *info = seq->private;
 	if (!v)
 		(void)__bpf_hash_map_seq_show(seq, NULL);
 	else
-		htab_unlock_bucket(info->htab,
+		rcu_read_unlock();
-				   &info->htab->buckets[info->bucket_id],
-				   info->flags);
 }
 static int bpf_iter_init_hash_map(void *priv_data,

kernel/bpf/inode.c+3−1

 	else
 		prev_key = key;
+	rcu_read_lock();
 	if (map->ops->map_get_next_key(map, prev_key, key)) {
 		map_iter(m)->done = true;
-		return NULL;
+		key = NULL;
 	}
+	rcu_read_unlock();
 	return key;
 }

lib/test_rhashtable.c+1−1

@@ -434,7 +434,7 @@ static int __init test_rhltable(unsigned int entries) · 433 unmodified lines
434	} else {	434	} else {
435	if (WARN(err != -ENOENT, "removed non-existent element, error %d not %d",	435	if (WARN(err != -ENOENT, "removed non-existent element, error %d not %d",
436	err, -ENOENT))	436	err, -ENOENT))
437	continue;	437	continue;
438	}	438	}
439	}	439	}
440		440

net/batman-adv/bridge_loop_avoidance.c+117−28

@@ -25,6 +25,7 @@ · 24 unmodified lines
25	#include <linux/lockdep.h>	25	#include <linux/lockdep.h>
26	#include <linux/netdevice.h>	26	#include <linux/netdevice.h>
27	#include <linux/netlink.h>	27	#include <linux/netlink.h>
		28	#include <linux/preempt.h>
28	#include <linux/rculist.h>	29	#include <linux/rculist.h>
29	#include <linux/rcupdate.h>	30	#include <linux/rcupdate.h>
30	#include <linux/seq_file.h>	31	#include <linux/seq_file.h>
@@ -83,11 +84,12 @@ static inline u32 batadv_choose_claim(const void *data, u32 size) · 52 unmodified lines
83	*/	84	*/
84	static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)	85	static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
85	{	86	{
86	const struct batadv_bla_claim claim = (struct batadv_bla_claim )data;	87	const struct batadv_bla_backbone_gw *gw;
87	u32 hash = 0;	88	u32 hash = 0;
88		89
89	hash = jhash(&claim->addr, sizeof(claim->addr), hash);	90	gw = (struct batadv_bla_backbone_gw *)data;
90	hash = jhash(&claim->vid, sizeof(claim->vid), hash);	91	hash = jhash(&gw->orig, sizeof(gw->orig), hash);
		92	hash = jhash(&gw->vid, sizeof(gw->vid), hash);
91		93
92	return hash % size;	94	return hash % size;
93	}	95	}
@@ -1579,13 +1581,16 @@ int batadv_bla_init(struct batadv_priv *bat_priv) · 1485 unmodified lines
1579	}	1581	}
1580		1582
1581	/**	1583	/**
1582	* batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.	1584	* batadv_bla_check_duplist() - Check if a frame is in the broadcast dup.
1583	* @bat_priv: the bat priv with all the soft interface information	1585	* @bat_priv: the bat priv with all the soft interface information
1584	* @skb: contains the bcast_packet to be checked	1586	* @skb: contains the multicast packet to be checked
		1587	* @payload_ptr: pointer to position inside the head buffer of the skb
		1588	* marking the start of the data to be CRC'ed
		1589	* @orig: originator mac address, NULL if unknown
1585	*	1590	*
1586	* check if it is on our broadcast list. Another gateway might	1591	* Check if it is on our broadcast list. Another gateway might have sent the
1587	* have sent the same packet because it is connected to the same backbone,	1592	* same packet because it is connected to the same backbone, so we have to
1588	* so we have to remove this duplicate.	1593	* remove this duplicate.
1589	*	1594	*
1590	* This is performed by checking the CRC, which will tell us	1595	* This is performed by checking the CRC, which will tell us
1591	* with a good chance that it is the same packet. If it is furthermore	1596	* with a good chance that it is the same packet. If it is furthermore
@@ -1594,19 +1599,17 @@ int batadv_bla_init(struct batadv_priv *bat_priv) · 2 unmodified lines
1594	*	1599	*
1595	* Return: true if a packet is in the duplicate list, false otherwise.	1600	* Return: true if a packet is in the duplicate list, false otherwise.
1596	*/	1601	*/
1597	bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,	1602	static bool batadv_bla_check_duplist(struct batadv_priv *bat_priv,
1598	struct sk_buff *skb)	1603	struct sk_buff skb, u8 payload_ptr,
		1604	const u8 *orig)
1599	{	1605	{
1600	int i, curr;
1601	__be32 crc;
1602	struct batadv_bcast_packet *bcast_packet;
1603	struct batadv_bcast_duplist_entry *entry;	1606	struct batadv_bcast_duplist_entry *entry;
1604	bool ret = false;	1607	bool ret = false;
1605		1608	int i, curr;
1606	bcast_packet = (struct batadv_bcast_packet *)skb->data;	1609	__be32 crc;
1607		1610
1608	/* calculate the crc ... */	1611	/* calculate the crc ... */
1609	crc = batadv_skb_crc32(skb, (u8 *)(bcast_packet + 1));	1612	crc = batadv_skb_crc32(skb, payload_ptr);
1610		1613
1611	spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);	1614	spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1612		1615
@@ -1625,8 +1628,21 @@ bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv, · 12 unmodified lines
1625	if (entry->crc != crc)	1628	if (entry->crc != crc)
1626	continue;	1629	continue;
1627		1630
1628	if (batadv_compare_eth(entry->orig, bcast_packet->orig))	1631	/* are the originators both known and not anonymous? */
1629	continue;	1632	if (orig && !is_zero_ether_addr(orig) &&
		1633	!is_zero_ether_addr(entry->orig)) {
		1634	/* If known, check if the new frame came from
		1635	* the same originator:
		1636	* We are safe to take identical frames from the
		1637	* same orig, if known, as multiplications in
		1638	* the mesh are detected via the (orig, seqno) pair.
		1639	* So we can be a bit more liberal here and allow
		1640	* identical frames from the same orig which the source
		1641	* host might have sent multiple times on purpose.
		1642	*/
		1643	if (batadv_compare_eth(entry->orig, orig))
		1644	continue;
		1645	}
1630		1646
1631	/* this entry seems to match: same crc, not too old,	1647	/* this entry seems to match: same crc, not too old,
1632	* and from another gw. therefore return true to forbid it.	1648	* and from another gw. therefore return true to forbid it.
@@ -1642,7 +1658,14 @@ bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv, · 9 unmodified lines
1642	entry = &bat_priv->bla.bcast_duplist[curr];	1658	entry = &bat_priv->bla.bcast_duplist[curr];
1643	entry->crc = crc;	1659	entry->crc = crc;
1644	entry->entrytime = jiffies;	1660	entry->entrytime = jiffies;
1645	ether_addr_copy(entry->orig, bcast_packet->orig);	1661
		1662	/* known originator */
		1663	if (orig)
		1664	ether_addr_copy(entry->orig, orig);
		1665	/* anonymous originator */
		1666	else
		1667	eth_zero_addr(entry->orig);
		1668
1646	bat_priv->bla.bcast_duplist_curr = curr;	1669	bat_priv->bla.bcast_duplist_curr = curr;
1647		1670
1648	out:	1671	out:
@@ -1651,6 +1674,48 @@ out: · 2 unmodified lines
1651	return ret;	1674	return ret;
1652	}	1675	}
1653		1676
		1677	/**
		1678	* batadv_bla_check_ucast_duplist() - Check if a frame is in the broadcast dup.
		1679	* @bat_priv: the bat priv with all the soft interface information
		1680	* @skb: contains the multicast packet to be checked, decapsulated from a
		1681	* unicast_packet
		1682	*
		1683	* Check if it is on our broadcast list. Another gateway might have sent the
		1684	* same packet because it is connected to the same backbone, so we have to
		1685	* remove this duplicate.
		1686	*
		1687	* Return: true if a packet is in the duplicate list, false otherwise.
		1688	*/
		1689	static bool batadv_bla_check_ucast_duplist(struct batadv_priv *bat_priv,
		1690	struct sk_buff *skb)
		1691	{
		1692	return batadv_bla_check_duplist(bat_priv, skb, (u8 *)skb->data, NULL);
		1693	}
		1694
		1695	/**
		1696	* batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.
		1697	* @bat_priv: the bat priv with all the soft interface information
		1698	* @skb: contains the bcast_packet to be checked
		1699	*
		1700	* Check if it is on our broadcast list. Another gateway might have sent the
		1701	* same packet because it is connected to the same backbone, so we have to
		1702	* remove this duplicate.
		1703	*
		1704	* Return: true if a packet is in the duplicate list, false otherwise.
		1705	*/
		1706	bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
		1707	struct sk_buff *skb)
		1708	{
		1709	struct batadv_bcast_packet *bcast_packet;
		1710	u8 *payload_ptr;
		1711
		1712	bcast_packet = (struct batadv_bcast_packet *)skb->data;
		1713	payload_ptr = (u8 *)(bcast_packet + 1);
		1714
		1715	return batadv_bla_check_duplist(bat_priv, skb, payload_ptr,
		1716	bcast_packet->orig);
		1717	}
		1718
1654	/**	1719	/**
1655	* batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for	1720	* batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for
1656	* the VLAN identified by vid.	1721	* the VLAN identified by vid.
@@ -1812,7 +1877,7 @@ batadv_bla_loopdetect_check(struct batadv_priv bat_priv, struct sk_buff skb, · 155 unmodified lines
1812	* @bat_priv: the bat priv with all the soft interface information	1877	* @bat_priv: the bat priv with all the soft interface information
1813	* @skb: the frame to be checked	1878	* @skb: the frame to be checked
1814	* @vid: the VLAN ID of the frame	1879	* @vid: the VLAN ID of the frame
1815	* @is_bcast: the packet came in a broadcast packet type.	1880	* @packet_type: the batman packet type this frame came in
1816	*	1881	*
1817	* batadv_bla_rx avoidance checks if:	1882	* batadv_bla_rx avoidance checks if:
1818	* * we have to race for a claim	1883	* * we have to race for a claim
@@ -1824,7 +1889,7 @@ batadv_bla_loopdetect_check(struct batadv_priv bat_priv, struct sk_buff skb, · 5 unmodified lines
1824	* further process the skb.	1889	* further process the skb.
1825	*/	1890	*/
1826	bool batadv_bla_rx(struct batadv_priv bat_priv, struct sk_buff skb,	1891	bool batadv_bla_rx(struct batadv_priv bat_priv, struct sk_buff skb,
1827	unsigned short vid, bool is_bcast)	1892	unsigned short vid, int packet_type)
1828	{	1893	{
1829	struct batadv_bla_backbone_gw *backbone_gw;	1894	struct batadv_bla_backbone_gw *backbone_gw;
1830	struct ethhdr *ethhdr;	1895	struct ethhdr *ethhdr;
@@ -1846,9 +1911,32 @@ bool batadv_bla_rx(struct batadv_priv bat_priv, struct sk_buff skb, · 15 unmodified lines
1846	goto handled;	1911	goto handled;
1847		1912
1848	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))	1913	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1849	/* don't allow broadcasts while requests are in flight */	1914	/* don't allow multicast packets while requests are in flight */
1850	if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast)	1915	if (is_multicast_ether_addr(ethhdr->h_dest))
1851	goto handled;	1916	/* Both broadcast flooding or multicast-via-unicasts
		1917	* delivery might send to multiple backbone gateways
		1918	* sharing the same LAN and therefore need to coordinate
		1919	* which backbone gateway forwards into the LAN,
		1920	* by claiming the payload source address.
		1921	*
		1922	* Broadcast flooding and multicast-via-unicasts
		1923	* delivery use the following two batman packet types.
		1924	* Note: explicitly exclude BATADV_UNICAST_4ADDR,
		1925	* as the DHCP gateway feature will send explicitly
		1926	* to only one BLA gateway, so the claiming process
		1927	* should be avoided there.
		1928	*/
		1929	if (packet_type == BATADV_BCAST \|\|
		1930	packet_type == BATADV_UNICAST)
		1931	goto handled;
		1932
		1933	/* potential duplicates from foreign BLA backbone gateways via
		1934	* multicast-in-unicast packets
		1935	*/
		1936	if (is_multicast_ether_addr(ethhdr->h_dest) &&
		1937	packet_type == BATADV_UNICAST &&
		1938	batadv_bla_check_ucast_duplist(bat_priv, skb))
		1939	goto handled;
1852		1940
1853	ether_addr_copy(search_claim.addr, ethhdr->h_source);	1941	ether_addr_copy(search_claim.addr, ethhdr->h_source);
1854	search_claim.vid = vid;	1942	search_claim.vid = vid;
@@ -1883,13 +1971,14 @@ bool batadv_bla_rx(struct batadv_priv bat_priv, struct sk_buff skb, · 28 unmodified lines
1883	goto allow;	1971	goto allow;
1884	}	1972	}
1885		1973
1886	/* if it is a broadcast ... */	1974	/* if it is a multicast ... */
1887	if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast) {	1975	if (is_multicast_ether_addr(ethhdr->h_dest) &&
		1976	(packet_type == BATADV_BCAST \|\| packet_type == BATADV_UNICAST)) {
1888	/* ... drop it. the responsible gateway is in charge.	1977	/* ... drop it. the responsible gateway is in charge.
1889	*	1978	*
1890	* We need to check is_bcast because with the gateway	1979	* We need to check packet type because with the gateway
1891	* feature, broadcasts (like DHCP requests) may be sent	1980	* feature, broadcasts (like DHCP requests) may be sent
1892	* using a unicast packet type.	1981	* using a unicast 4 address packet type. See comment above.
1893	*/	1982	*/
1894	goto handled;	1983	goto handled;
1895	} else {	1984	} else {

net/batman-adv/bridge_loop_avoidance.h+2−2

@@ -35,7 +35,7 @@ static inline bool batadv_bla_is_loopdetect_mac(const uint8_t *mac) · 34 unmodified lines
35		35
36	#ifdef CONFIG_BATMAN_ADV_BLA	36	#ifdef CONFIG_BATMAN_ADV_BLA
37	bool batadv_bla_rx(struct batadv_priv bat_priv, struct sk_buff skb,	37	bool batadv_bla_rx(struct batadv_priv bat_priv, struct sk_buff skb,
38	unsigned short vid, bool is_bcast);	38	unsigned short vid, int packet_type);
39	bool batadv_bla_tx(struct batadv_priv bat_priv, struct sk_buff skb,	39	bool batadv_bla_tx(struct batadv_priv bat_priv, struct sk_buff skb,
40	unsigned short vid);	40	unsigned short vid);
41	bool batadv_bla_is_backbone_gw(struct sk_buff *skb,	41	bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
@@ -66,7 +66,7 @@ bool batadv_bla_check_claim(struct batadv_priv bat_priv, u8 addr, · 24 unmodified lines
66		66
67	static inline bool batadv_bla_rx(struct batadv_priv *bat_priv,	67	static inline bool batadv_bla_rx(struct batadv_priv *bat_priv,
68	struct sk_buff *skb, unsigned short vid,	68	struct sk_buff *skb, unsigned short vid,
69	bool is_bcast)	69	int packet_type)
70	{	70	{
71	return false;	71	return false;
72	}	72	}

net/batman-adv/multicast.c+36−10

 #include <uapi/linux/batadv_packet.h>
 #include <uapi/linux/batman_adv.h>
+#include "bridge_loop_avoidance.h"
 #include "hard-interface.h"
 #include "hash.h"
 #include "log.h"
 	return BATADV_FORW_ALL;
 }
+/**
+ * batadv_mcast_forw_send_orig() - send a multicast packet to an originator
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: the multicast packet to send
+ * @vid: the vlan identifier
+ * @orig_node: the originator to send the packet to
+ *
+ * Return: NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
+ */
+int batadv_mcast_forw_send_orig(struct batadv_priv *bat_priv,
+				struct sk_buff *skb,
+				unsigned short vid,
+				struct batadv_orig_node *orig_node)
+{
+	/* Avoid sending multicast-in-unicast packets to other BLA
+	 * gateways - they already got the frame from the LAN side
+	 * we share with them.
+	 * TODO: Refactor to take BLA into account earlier, to avoid
+	 * reducing the mcast_fanout count.
+	 */
+	if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid)) {
+		dev_kfree_skb(skb);
+		return NET_XMIT_SUCCESS;
+	}
+	return batadv_send_skb_unicast(bat_priv, skb, BATADV_UNICAST, 0,
+				       orig_node, vid);
+}
 /**
  * batadv_mcast_forw_tt() - forwards a packet to multicast listeners
  * @bat_priv: the bat priv with all the soft interface information
 			break;
 		}
-		batadv_send_skb_unicast(bat_priv, newskb, BATADV_UNICAST, 0,
+		batadv_mcast_forw_send_orig(bat_priv, newskb, vid,
-					orig_entry->orig_node, vid);
+					    orig_entry->orig_node);
 	}
 	rcu_read_unlock();
 			break;
 		}
-		batadv_send_skb_unicast(bat_priv, newskb, BATADV_UNICAST, 0,
+		batadv_mcast_forw_send_orig(bat_priv, newskb, vid, orig_node);
-					orig_node, vid);
 	}
 	rcu_read_unlock();
 	return ret;
 			break;
 		}
-		batadv_send_skb_unicast(bat_priv, newskb, BATADV_UNICAST, 0,
+		batadv_mcast_forw_send_orig(bat_priv, newskb, vid, orig_node);
-					orig_node, vid);
 	}
 	rcu_read_unlock();
 	return ret;
 			break;
 		}
-		batadv_send_skb_unicast(bat_priv, newskb, BATADV_UNICAST, 0,
+		batadv_mcast_forw_send_orig(bat_priv, newskb, vid, orig_node);
-					orig_node, vid);
 	}
 	rcu_read_unlock();
 	return ret;
 			break;
 		}
-		batadv_send_skb_unicast(bat_priv, newskb, BATADV_UNICAST, 0,
+		batadv_mcast_forw_send_orig(bat_priv, newskb, vid, orig_node);
-					orig_node, vid);
 	}
 	rcu_read_unlock();
 	return ret;

net/batman-adv/multicast.h+15−0

@@ -46,6 +46,11 @@ enum batadv_forw_mode · 45 unmodified lines
46	batadv_mcast_forw_mode(struct batadv_priv bat_priv, struct sk_buff skb,	46	batadv_mcast_forw_mode(struct batadv_priv bat_priv, struct sk_buff skb,
47	struct batadv_orig_node **mcast_single_orig);	47	struct batadv_orig_node **mcast_single_orig);
48		48
		49	int batadv_mcast_forw_send_orig(struct batadv_priv *bat_priv,
		50	struct sk_buff *skb,
		51	unsigned short vid,
		52	struct batadv_orig_node *orig_node);
		53
49	int batadv_mcast_forw_send(struct batadv_priv bat_priv, struct sk_buff skb,	54	int batadv_mcast_forw_send(struct batadv_priv bat_priv, struct sk_buff skb,
50	unsigned short vid);	55	unsigned short vid);
51		56
@@ -71,6 +76,16 @@ batadv_mcast_forw_mode(struct batadv_priv bat_priv, struct sk_buff skb, · 19 unmodified lines
71	return BATADV_FORW_ALL;	76	return BATADV_FORW_ALL;
72	}	77	}
73		78
		79	static inline int
		80	batadv_mcast_forw_send_orig(struct batadv_priv *bat_priv,
		81	struct sk_buff *skb,
		82	unsigned short vid,
		83	struct batadv_orig_node *orig_node)
		84	{
		85	kfree_skb(skb);
		86	return NET_XMIT_DROP;
		87	}
		88
74	static inline int	89	static inline int
75	batadv_mcast_forw_send(struct batadv_priv bat_priv, struct sk_buff skb,	90	batadv_mcast_forw_send(struct batadv_priv bat_priv, struct sk_buff skb,
76	unsigned short vid)	91	unsigned short vid)

net/batman-adv/routing.c+4−0

 	vid = batadv_get_vid(skb, hdr_len);
 	ethhdr = (struct ethhdr *)(skb->data + hdr_len);
+	/* do not reroute multicast frames in a unicast header */
+	if (is_multicast_ether_addr(ethhdr->h_dest))
+		return true;
 	/* check if the destination client was served by this node and it is now
 	 * roaming. In this case, it means that the node has got a ROAM_ADV
 	 * message and that it knows the new destination in the mesh to re-route

net/batman-adv/soft-interface.c+5−6

 				goto dropped;
 			ret = batadv_send_skb_via_gw(bat_priv, skb, vid);
 		} else if (mcast_single_orig) {
-			ret = batadv_send_skb_unicast(bat_priv, skb,
+			ret = batadv_mcast_forw_send_orig(bat_priv, skb, vid,
-						      BATADV_UNICAST, 0,
+							  mcast_single_orig);
-						      mcast_single_orig, vid);
 		} else if (forw_mode == BATADV_FORW_SOME) {
 			ret = batadv_mcast_forw_send(bat_priv, skb, vid);
 		} else {
 	struct vlan_ethhdr *vhdr;
 	struct ethhdr *ethhdr;
 	unsigned short vid;
-	bool is_bcast;
+	int packet_type;
 	batadv_bcast_packet = (struct batadv_bcast_packet *)skb->data;
-	is_bcast = (batadv_bcast_packet->packet_type == BATADV_BCAST);
+	packet_type = batadv_bcast_packet->packet_type;
 	skb_pull_rcsum(skb, hdr_size);
 	skb_reset_mac_header(skb);
 	/* Let the bridge loop avoidance check the packet. If will
 	 * not handle it, we can safely push it up.
 	 */
-	if (batadv_bla_rx(bat_priv, skb, vid, is_bcast))
+	if (batadv_bla_rx(bat_priv, skb, vid, packet_type))
 		goto out;
 	if (orig_node)

net/bridge/br_vlan.c+17−10

 	}
 }
-static int __br_vlan_get_pvid(const struct net_device *dev,
+int br_vlan_get_pvid(const struct net_device *dev, u16 *p_pvid)
-			      struct net_bridge_port *p, u16 *p_pvid)
 {
 	struct net_bridge_vlan_group *vg;
+	struct net_bridge_port *p;
+	ASSERT_RTNL();
+	p = br_port_get_check_rtnl(dev);
 	if (p)
 		vg = nbp_vlan_group(p);
 	else if (netif_is_bridge_master(dev))
 	*p_pvid = br_get_pvid(vg);
 	return 0;
 }
-int br_vlan_get_pvid(const struct net_device *dev, u16 *p_pvid)
-{
-	ASSERT_RTNL();
-	return __br_vlan_get_pvid(dev, br_port_get_check_rtnl(dev), p_pvid);
-}
 EXPORT_SYMBOL_GPL(br_vlan_get_pvid);
 int br_vlan_get_pvid_rcu(const struct net_device *dev, u16 *p_pvid)
 {
-	return __br_vlan_get_pvid(dev, br_port_get_check_rcu(dev), p_pvid);
+	struct net_bridge_vlan_group *vg;
+	struct net_bridge_port *p;
+	p = br_port_get_check_rcu(dev);
+	if (p)
+		vg = nbp_vlan_group_rcu(p);
+	else if (netif_is_bridge_master(dev))
+		vg = br_vlan_group_rcu(netdev_priv(dev));
+	else
+		return -EINVAL;
+	*p_pvid = br_get_pvid(vg);
+	return 0;
 }
 EXPORT_SYMBOL_GPL(br_vlan_get_pvid_rcu);

net/core/dev.c+1−1

@@ -8647,7 +8647,7 @@ int dev_get_port_parent_id(struct net_device *dev, · 8646 unmodified lines
8647	if (!first.id_len)	8647	if (!first.id_len)
8648	first = *ppid;	8648	first = *ppid;
8649	else if (memcmp(&first, ppid, sizeof(*ppid)))	8649	else if (memcmp(&first, ppid, sizeof(*ppid)))
8650	return -ENODATA;	8650	return -EOPNOTSUPP;
8651	}	8651	}
8652		8652
8653	return err;	8653	return err;

net/core/dst.c+1−1

@@ -144,7 +144,7 @@ static void dst_destroy_rcu(struct rcu_head *head) · 143 unmodified lines
144		144
145	/* Operations to mark dst as DEAD and clean up the net device referenced	145	/* Operations to mark dst as DEAD and clean up the net device referenced
146	* by dst:	146	* by dst:
147	* 1. put the dst under loopback interface and discard all tx/rx packets	147	* 1. put the dst under blackhole interface and discard all tx/rx packets
148	* on this route.	148	* on this route.
149	* 2. release the net_device	149	* 2. release the net_device
150	* This function should be called when removing routes from the fib tree	150	* This function should be called when removing routes from the fib tree

net/core/fib_rules.c+1−1

@@ -16,7 +16,7 @@ · 15 unmodified lines
16	#include <net/ip_tunnels.h>	16	#include <net/ip_tunnels.h>
17	#include <linux/indirect_call_wrapper.h>	17	#include <linux/indirect_call_wrapper.h>
18		18
19	#ifdef CONFIG_IPV6_MULTIPLE_TABLES	19	#if defined(CONFIG_IPV6) && defined(CONFIG_IPV6_MULTIPLE_TABLES)
20	#ifdef CONFIG_IP_MULTIPLE_TABLES	20	#ifdef CONFIG_IP_MULTIPLE_TABLES
21	#define INDIRECT_CALL_MT(f, f2, f1, ...) \	21	#define INDIRECT_CALL_MT(f, f2, f1, ...) \
22	INDIRECT_CALL_INET(f, f2, f1, __VA_ARGS__)	22	INDIRECT_CALL_INET(f, f2, f1, __VA_ARGS__)

net/core/filter.c+10−9

 	fl4.saddr = params->ipv4_src;
 	fl4.fl4_sport = params->sport;
 	fl4.fl4_dport = params->dport;
+	fl4.flowi4_multipath_hash = 0;
 	if (flags & BPF_FIB_LOOKUP_DIRECT) {
 		u32 tbid = l3mdev_fib_table_rcu(dev) ? : RT_TABLE_MAIN;
 	bool indirect = BPF_MODE(orig->code) == BPF_IND;
 	struct bpf_insn *insn = insn_buf;
-	/* We're guaranteed here that CTX is in R6. */
-	*insn++ = BPF_MOV64_REG(BPF_REG_1, BPF_REG_CTX);
 	if (!indirect) {
 		*insn++ = BPF_MOV64_IMM(BPF_REG_2, orig->imm);
 	} else {
 		if (orig->imm)
 			*insn++ = BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, orig->imm);
 	}
+	/* We're guaranteed here that CTX is in R6. */
+	*insn++ = BPF_MOV64_REG(BPF_REG_1, BPF_REG_CTX);
 	switch (BPF_SIZE(orig->code)) {
 	case BPF_B:
 	 * trigger an explicit type generation here.
 	 */
 	BTF_TYPE_EMIT(struct tcp6_sock);
-	if (sk_fullsock(sk) && sk->sk_protocol == IPPROTO_TCP &&
+	if (sk && sk_fullsock(sk) && sk->sk_protocol == IPPROTO_TCP &&
 	    sk->sk_family == AF_INET6)
 		return (unsigned long)sk;
 BPF_CALL_1(bpf_skc_to_tcp_sock, struct sock *, sk)
 {
-	if (sk_fullsock(sk) && sk->sk_protocol == IPPROTO_TCP)
+	if (sk && sk_fullsock(sk) && sk->sk_protocol == IPPROTO_TCP)
 		return (unsigned long)sk;
 	return (unsigned long)NULL;
 BPF_CALL_1(bpf_skc_to_tcp_timewait_sock, struct sock *, sk)
 {
 #ifdef CONFIG_INET
-	if (sk->sk_prot == &tcp_prot && sk->sk_state == TCP_TIME_WAIT)
+	if (sk && sk->sk_prot == &tcp_prot && sk->sk_state == TCP_TIME_WAIT)
 		return (unsigned long)sk;
 #endif
 #if IS_BUILTIN(CONFIG_IPV6)
-	if (sk->sk_prot == &tcpv6_prot && sk->sk_state == TCP_TIME_WAIT)
+	if (sk && sk->sk_prot == &tcpv6_prot && sk->sk_state == TCP_TIME_WAIT)
 		return (unsigned long)sk;
 #endif
 BPF_CALL_1(bpf_skc_to_tcp_request_sock, struct sock *, sk)
 {
 #ifdef CONFIG_INET
-	if (sk->sk_prot == &tcp_prot  && sk->sk_state == TCP_NEW_SYN_RECV)
+	if (sk && sk->sk_prot == &tcp_prot && sk->sk_state == TCP_NEW_SYN_RECV)
 		return (unsigned long)sk;
 #endif
 #if IS_BUILTIN(CONFIG_IPV6)
-	if (sk->sk_prot == &tcpv6_prot && sk->sk_state == TCP_NEW_SYN_RECV)
+	if (sk && sk->sk_prot == &tcpv6_prot && sk->sk_state == TCP_NEW_SYN_RECV)
 		return (unsigned long)sk;
 #endif
 	 * trigger an explicit type generation here.
 	 */
 	BTF_TYPE_EMIT(struct udp6_sock);
-	if (sk_fullsock(sk) && sk->sk_protocol == IPPROTO_UDP &&
+	if (sk && sk_fullsock(sk) && sk->sk_protocol == IPPROTO_UDP &&
 	    sk->sk_type == SOCK_DGRAM && sk->sk_family == AF_INET6)
 		return (unsigned long)sk;

net/core/net_namespace.c+11−11

@@ -251,10 +251,10 @@ int peernet2id_alloc(struct net net, struct net peer, gfp_t gfp) · 250 unmodified lines
251	if (refcount_read(&net->count) == 0)	251	if (refcount_read(&net->count) == 0)
252	return NETNSA_NSID_NOT_ASSIGNED;	252	return NETNSA_NSID_NOT_ASSIGNED;
253		253
254	spin_lock(&net->nsid_lock);	254	spin_lock_bh(&net->nsid_lock);
255	id = __peernet2id(net, peer);	255	id = __peernet2id(net, peer);
256	if (id >= 0) {	256	if (id >= 0) {
257	spin_unlock(&net->nsid_lock);	257	spin_unlock_bh(&net->nsid_lock);
258	return id;	258	return id;
259	}	259	}
260		260
@@ -264,12 +264,12 @@ int peernet2id_alloc(struct net net, struct net peer, gfp_t gfp) · 3 unmodified lines
264	* just been idr_remove()'d from there in cleanup_net().	264	* just been idr_remove()'d from there in cleanup_net().
265	*/	265	*/
266	if (!maybe_get_net(peer)) {	266	if (!maybe_get_net(peer)) {
267	spin_unlock(&net->nsid_lock);	267	spin_unlock_bh(&net->nsid_lock);
268	return NETNSA_NSID_NOT_ASSIGNED;	268	return NETNSA_NSID_NOT_ASSIGNED;
269	}	269	}
270		270
271	id = alloc_netid(net, peer, -1);	271	id = alloc_netid(net, peer, -1);
272	spin_unlock(&net->nsid_lock);	272	spin_unlock_bh(&net->nsid_lock);
273		273
274	put_net(peer);	274	put_net(peer);
275	if (id < 0)	275	if (id < 0)
@@ -534,20 +534,20 @@ static void unhash_nsid(struct net net, struct net last) · 258 unmodified lines
534	for_each_net(tmp) {	534	for_each_net(tmp) {
535	int id;	535	int id;
536		536
537	spin_lock(&tmp->nsid_lock);	537	spin_lock_bh(&tmp->nsid_lock);
538	id = __peernet2id(tmp, net);	538	id = __peernet2id(tmp, net);
539	if (id >= 0)	539	if (id >= 0)
540	idr_remove(&tmp->netns_ids, id);	540	idr_remove(&tmp->netns_ids, id);
541	spin_unlock(&tmp->nsid_lock);	541	spin_unlock_bh(&tmp->nsid_lock);
542	if (id >= 0)	542	if (id >= 0)
543	rtnl_net_notifyid(tmp, RTM_DELNSID, id, 0, NULL,	543	rtnl_net_notifyid(tmp, RTM_DELNSID, id, 0, NULL,
544	GFP_KERNEL);	544	GFP_KERNEL);
545	if (tmp == last)	545	if (tmp == last)
546	break;	546	break;
547	}	547	}
548	spin_lock(&net->nsid_lock);	548	spin_lock_bh(&net->nsid_lock);
549	idr_destroy(&net->netns_ids);	549	idr_destroy(&net->netns_ids);
550	spin_unlock(&net->nsid_lock);	550	spin_unlock_bh(&net->nsid_lock);
551	}	551	}
552		552
553	static LLIST_HEAD(cleanup_list);	553	static LLIST_HEAD(cleanup_list);
@@ -760,9 +760,9 @@ static int rtnl_net_newid(struct sk_buff skb, struct nlmsghdr nlh, · 206 unmodified lines
760	return PTR_ERR(peer);	760	return PTR_ERR(peer);
761	}	761	}
762		762
763	spin_lock(&net->nsid_lock);	763	spin_lock_bh(&net->nsid_lock);
764	if (__peernet2id(net, peer) >= 0) {	764	if (__peernet2id(net, peer) >= 0) {
765	spin_unlock(&net->nsid_lock);	765	spin_unlock_bh(&net->nsid_lock);
766	err = -EEXIST;	766	err = -EEXIST;
767	NL_SET_BAD_ATTR(extack, nla);	767	NL_SET_BAD_ATTR(extack, nla);
768	NL_SET_ERR_MSG(extack,	768	NL_SET_ERR_MSG(extack,
@@ -771,7 +771,7 @@ static int rtnl_net_newid(struct sk_buff skb, struct nlmsghdr nlh, · 2 unmodified lines
771	}	771	}
772		772
773	err = alloc_netid(net, peer, nsid);	773	err = alloc_netid(net, peer, nsid);
774	spin_unlock(&net->nsid_lock);	774	spin_unlock_bh(&net->nsid_lock);
775	if (err >= 0) {	775	if (err >= 0) {
776	rtnl_net_notifyid(net, RTM_NEWNSID, err, NETLINK_CB(skb).portid,	776	rtnl_net_notifyid(net, RTM_NEWNSID, err, NETLINK_CB(skb).portid,
777	nlh, GFP_KERNEL);	777	nlh, GFP_KERNEL);

net/dcb/dcbnl.c+8−0

 {
 	const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
 	struct nlattr *ieee[DCB_ATTR_IEEE_MAX + 1];
+	int prio;
 	int err;
 	if (!ops)
 		struct dcbnl_buffer *buffer =
 			nla_data(ieee[DCB_ATTR_DCB_BUFFER]);
+		for (prio = 0; prio < ARRAY_SIZE(buffer->prio2buffer); prio++) {
+			if (buffer->prio2buffer[prio] >= DCBX_MAX_BUFFERS) {
+				err = -EINVAL;
+				goto err;
+			}
+		}
 		err = ops->dcbnl_setbuffer(netdev, buffer);
 		if (err)
 			goto err;

net/dsa/slave.c+16−2

 	dsa_slave_notify(slave_dev, DSA_PORT_REGISTER);
-	ret = register_netdev(slave_dev);
+	rtnl_lock();
+	ret = register_netdevice(slave_dev);
 	if (ret) {
 		netdev_err(master, "error %d registering interface %s\n",
 			   ret, slave_dev->name);
+		rtnl_unlock();
 		goto out_phy;
 	}
+	ret = netdev_upper_dev_link(master, slave_dev, NULL);
+	rtnl_unlock();
+	if (ret)
+		goto out_unregister;
 	return 0;
+out_unregister:
+	unregister_netdev(slave_dev);
 out_phy:
 	rtnl_lock();
 	phylink_disconnect_phy(p->dp->pl);
 void dsa_slave_destroy(struct net_device *slave_dev)
 {
+	struct net_device *master = dsa_slave_to_master(slave_dev);
 	struct dsa_port *dp = dsa_slave_to_port(slave_dev);
 	struct dsa_slave_priv *p = netdev_priv(slave_dev);
 	netif_carrier_off(slave_dev);
 	rtnl_lock();
+	netdev_upper_dev_unlink(master, slave_dev);
+	unregister_netdevice(slave_dev);
 	phylink_disconnect_phy(dp->pl);
 	rtnl_unlock();
 	dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);
-	unregister_netdev(slave_dev);
 	phylink_destroy(dp->pl);
 	gro_cells_destroy(&p->gcells);
 	free_percpu(p->stats64);

net/dsa/tag_ocelot.c+7−4

 	packing(injection, &qos_class, 19,  17, OCELOT_TAG_LEN, PACK, 0);
 	if (ocelot->ptp && (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) {
+		struct sk_buff *clone = DSA_SKB_CB(skb)->clone;
 		rew_op = ocelot_port->ptp_cmd;
-		if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
+		/* Retrieve timestamp ID populated inside skb->cb[0] of the
-			rew_op |= (ocelot_port->ts_id  % 4) << 3;
+		 * clone by ocelot_port_add_txtstamp_skb
-			ocelot_port->ts_id++;
+		 */
-		}
+		if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP)
+			rew_op |= clone->cb[0] << 3;
 		packing(injection, &rew_op, 125, 117, OCELOT_TAG_LEN, PACK, 0);
 	}

net/ethtool/tunnels.c+2−2

@@ -200,7 +200,7 @@ int ethnl_tunnel_info_doit(struct sk_buff skb, struct genl_info info) · 199 unmodified lines
200	reply_len = ret + ethnl_reply_header_size();	200	reply_len = ret + ethnl_reply_header_size();
201		201
202	rskb = ethnl_reply_init(reply_len, req_info.dev,	202	rskb = ethnl_reply_init(reply_len, req_info.dev,
203	ETHTOOL_MSG_TUNNEL_INFO_GET,	203	ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY,
204	ETHTOOL_A_TUNNEL_INFO_HEADER,	204	ETHTOOL_A_TUNNEL_INFO_HEADER,
205	info, &reply_payload);	205	info, &reply_payload);
206	if (!rskb) {	206	if (!rskb) {
@@ -273,7 +273,7 @@ int ethnl_tunnel_info_dumpit(struct sk_buff skb, struct netlink_callback cb) · 66 unmodified lines
273	goto cont;	273	goto cont;
274		274
275	ehdr = ethnl_dump_put(skb, cb,	275	ehdr = ethnl_dump_put(skb, cb,
276	ETHTOOL_MSG_TUNNEL_INFO_GET);	276	ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY);
277	if (!ehdr) {	277	if (!ehdr) {
278	ret = -EMSGSIZE;	278	ret = -EMSGSIZE;
279	goto out;	279	goto out;

net/hsr/hsr_netlink.c+3−3

@@ -76,7 +76,7 @@ static int hsr_newlink(struct net src_net, struct net_device dev, · 75 unmodified lines
76	proto = nla_get_u8(data[IFLA_HSR_PROTOCOL]);	76	proto = nla_get_u8(data[IFLA_HSR_PROTOCOL]);
77		77
78	if (proto >= HSR_PROTOCOL_MAX) {	78	if (proto >= HSR_PROTOCOL_MAX) {
79	NL_SET_ERR_MSG_MOD(extack, "Unsupported protocol\n");	79	NL_SET_ERR_MSG_MOD(extack, "Unsupported protocol");
80	return -EINVAL;	80	return -EINVAL;
81	}	81	}
82		82
@@ -84,14 +84,14 @@ static int hsr_newlink(struct net src_net, struct net_device dev, · 1 unmodified line
84	proto_version = HSR_V0;	84	proto_version = HSR_V0;
85	} else {	85	} else {
86	if (proto == HSR_PROTOCOL_PRP) {	86	if (proto == HSR_PROTOCOL_PRP) {
87	NL_SET_ERR_MSG_MOD(extack, "PRP version unsupported\n");	87	NL_SET_ERR_MSG_MOD(extack, "PRP version unsupported");
88	return -EINVAL;	88	return -EINVAL;
89	}	89	}
90		90
91	proto_version = nla_get_u8(data[IFLA_HSR_VERSION]);	91	proto_version = nla_get_u8(data[IFLA_HSR_VERSION]);
92	if (proto_version > HSR_V1) {	92	if (proto_version > HSR_V1) {
93	NL_SET_ERR_MSG_MOD(extack,	93	NL_SET_ERR_MSG_MOD(extack,
94	"Only HSR version 0/1 supported\n");	94	"Only HSR version 0/1 supported");
95	return -EINVAL;	95	return -EINVAL;
96	}	96	}
97	}	97	}

net/ipv4/fib_frontend.c+1−0

@@ -362,6 +362,7 @@ static int __fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst, · 361 unmodified lines
362	fl4.flowi4_tun_key.tun_id = 0;	362	fl4.flowi4_tun_key.tun_id = 0;
363	fl4.flowi4_flags = 0;	363	fl4.flowi4_flags = 0;
364	fl4.flowi4_uid = sock_net_uid(net, NULL);	364	fl4.flowi4_uid = sock_net_uid(net, NULL);
		365	fl4.flowi4_multipath_hash = 0;
365		366
366	no_addr = idev->ifa_list == NULL;	367	no_addr = idev->ifa_list == NULL;
367		368

net/ipv4/inet_diag.c+15−5

@@ -186,8 +186,8 @@ errout: · 185 unmodified lines
186	}	186	}
187	EXPORT_SYMBOL_GPL(inet_diag_msg_attrs_fill);	187	EXPORT_SYMBOL_GPL(inet_diag_msg_attrs_fill);
188		188
189	static void inet_diag_parse_attrs(const struct nlmsghdr *nlh, int hdrlen,	189	static int inet_diag_parse_attrs(const struct nlmsghdr *nlh, int hdrlen,
190	struct nlattr **req_nlas)	190	struct nlattr **req_nlas)
191	{	191	{
192	struct nlattr *nla;	192	struct nlattr *nla;
193	int remaining;	193	int remaining;
@@ -195,9 +195,13 @@ static void inet_diag_parse_attrs(const struct nlmsghdr *nlh, int hdrlen, · 1 unmodified line
195	nlmsg_for_each_attr(nla, nlh, hdrlen, remaining) {	195	nlmsg_for_each_attr(nla, nlh, hdrlen, remaining) {
196	int type = nla_type(nla);	196	int type = nla_type(nla);
197		197
		198	if (type == INET_DIAG_REQ_PROTOCOL && nla_len(nla) != sizeof(u32))
		199	return -EINVAL;
		200
198	if (type < __INET_DIAG_REQ_MAX)	201	if (type < __INET_DIAG_REQ_MAX)
199	req_nlas[type] = nla;	202	req_nlas[type] = nla;
200	}	203	}
		204	return 0;
201	}	205	}
202		206
203	static int inet_diag_get_protocol(const struct inet_diag_req_v2 *req,	207	static int inet_diag_get_protocol(const struct inet_diag_req_v2 *req,
@@ -574,7 +578,10 @@ static int inet_diag_cmd_exact(int cmd, struct sk_buff *in_skb, · 370 unmodified lines
574	int err, protocol;	578	int err, protocol;
575		579
576	memset(&dump_data, 0, sizeof(dump_data));	580	memset(&dump_data, 0, sizeof(dump_data));
577	inet_diag_parse_attrs(nlh, hdrlen, dump_data.req_nlas);	581	err = inet_diag_parse_attrs(nlh, hdrlen, dump_data.req_nlas);
		582	if (err)
		583	return err;
		584
578	protocol = inet_diag_get_protocol(req, &dump_data);	585	protocol = inet_diag_get_protocol(req, &dump_data);
579		586
580	handler = inet_diag_lock_handler(protocol);	587	handler = inet_diag_lock_handler(protocol);
@@ -1180,8 +1187,11 @@ static int __inet_diag_dump_start(struct netlink_callback *cb, int hdrlen) · 599 unmodified lines
1180	if (!cb_data)	1187	if (!cb_data)
1181	return -ENOMEM;	1188	return -ENOMEM;
1182		1189
1183	inet_diag_parse_attrs(nlh, hdrlen, cb_data->req_nlas);	1190	err = inet_diag_parse_attrs(nlh, hdrlen, cb_data->req_nlas);
1184		1191	if (err) {
		1192	kfree(cb_data);
		1193	return err;
		1194	}
1185	nla = cb_data->inet_diag_nla_bc;	1195	nla = cb_data->inet_diag_nla_bc;
1186	if (nla) {	1196	if (nla) {
1187	err = inet_diag_bc_audit(nla, skb);	1197	err = inet_diag_bc_audit(nla, skb);

net/ipv4/ip_output.c+2−1

 #include <net/icmp.h>
 #include <net/checksum.h>
 #include <net/inetpeer.h>
+#include <net/inet_ecn.h>
 #include <net/lwtunnel.h>
 #include <linux/bpf-cgroup.h>
 #include <linux/igmp.h>
 	if (IS_ERR(rt))
 		return;
-	inet_sk(sk)->tos = arg->tos;
+	inet_sk(sk)->tos = arg->tos & ~INET_ECN_MASK;
 	sk->sk_protocol = ip_hdr(skb)->protocol;
 	sk->sk_bound_dev_if = arg->bound_dev_if;

net/ipv4/ip_tunnel_core.c+1−0

@@ -554,6 +554,7 @@ static int ip_tun_parse_opts_vxlan(struct nlattr *attr, · 553 unmodified lines
554		554
555	attr = tb[LWTUNNEL_IP_OPT_VXLAN_GBP];	555	attr = tb[LWTUNNEL_IP_OPT_VXLAN_GBP];
556	md->gbp = nla_get_u32(attr);	556	md->gbp = nla_get_u32(attr);
		557	md->gbp &= VXLAN_GBP_MASK;
557	info->key.tun_flags \|= TUNNEL_VXLAN_OPT;	558	info->key.tun_flags \|= TUNNEL_VXLAN_OPT;
558	}	559	}
559		560

net/ipv4/route.c+9−5

 			neigh_event_send(n, NULL);
 		} else {
 			if (fib_lookup(net, fl4, &res, 0) == 0) {
-				struct fib_nh_common *nhc = FIB_RES_NHC(res);
+				struct fib_nh_common *nhc;
+				fib_select_path(net, &res, fl4, skb);
+				nhc = FIB_RES_NHC(res);
 				update_or_create_fnhe(nhc, fl4->daddr, new_gw,
 						0, false,
 						jiffies + ip_rt_gc_timeout);
 static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
 {
 	struct dst_entry *dst = &rt->dst;
+	struct net *net = dev_net(dst->dev);
 	u32 old_mtu = ipv4_mtu(dst);
 	struct fib_result res;
 	bool lock = false;
 		return;
 	rcu_read_lock();
-	if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
+	if (fib_lookup(net, fl4, &res, 0) == 0) {
-		struct fib_nh_common *nhc = FIB_RES_NHC(res);
+		struct fib_nh_common *nhc;
+		fib_select_path(net, &res, fl4, NULL);
+		nhc = FIB_RES_NHC(res);
 		update_or_create_fnhe(nhc, fl4->daddr, 0, mtu, lock,
 				      jiffies + ip_rt_mtu_expires);
 	}
 	fl4.daddr = daddr;
 	fl4.saddr = saddr;
 	fl4.flowi4_uid = sock_net_uid(net, NULL);
+	fl4.flowi4_multipath_hash = 0;
 	if (fib4_rules_early_flow_dissect(net, skb, &fl4, &_flkeys)) {
 		flkeys = &_flkeys;
 	fib_select_path(net, res, fl4, skb);
 	dev_out = FIB_RES_DEV(*res);
-	fl4->flowi4_oif = dev_out->ifindex;
 make_route:
 	rth = __mkroute_output(res, fl4, orig_oif, dev_out, flags);

net/ipv6/Kconfig+1−0

@@ -303,6 +303,7 @@ config IPV6_SEG6_LWTUNNEL · 302 unmodified lines
303	config IPV6_SEG6_HMAC	303	config IPV6_SEG6_HMAC
304	bool "IPv6: Segment Routing HMAC support"	304	bool "IPv6: Segment Routing HMAC support"
305	depends on IPV6	305	depends on IPV6
		306	select CRYPTO
306	select CRYPTO_HMAC	307	select CRYPTO_HMAC
307	select CRYPTO_SHA1	308	select CRYPTO_SHA1
308	select CRYPTO_SHA256	309	select CRYPTO_SHA256

net/ipv6/ip6_fib.c+9−4

 /* Need to own table->tb6_lock */
 int fib6_del(struct fib6_info *rt, struct nl_info *info)
 {
-	struct fib6_node *fn = rcu_dereference_protected(rt->fib6_node,
-				    lockdep_is_held(&rt->fib6_table->tb6_lock));
-	struct fib6_table *table = rt->fib6_table;
 	struct net *net = info->nl_net;
 	struct fib6_info __rcu **rtp;
 	struct fib6_info __rcu **rtp_next;
+	struct fib6_table *table;
+	struct fib6_node *fn;
+	if (rt == net->ipv6.fib6_null_entry)
+		return -ENOENT;
-	if (!fn || rt == net->ipv6.fib6_null_entry)
+	table = rt->fib6_table;
+	fn = rcu_dereference_protected(rt->fib6_node,
+				       lockdep_is_held(&table->tb6_lock));
+	if (!fn)
 		return -ENOENT;
 	WARN_ON(!(fn->fn_flags & RTN_RTINFO));

net/ipv6/route.c+1−1

@@ -4202,7 +4202,7 @@ static struct fib6_info rt6_add_route_info(struct net net, · 4201 unmodified lines
4202	.fc_nlinfo.nl_net = net,	4202	.fc_nlinfo.nl_net = net,
4203	};	4203	};
4204		4204
4205	cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,	4205	cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
4206	cfg.fc_dst = *prefix;	4206	cfg.fc_dst = *prefix;
4207	cfg.fc_gateway = *gwaddr;	4207	cfg.fc_gateway = *gwaddr;
4208		4208

net/mac80211/airtime.c+14−6

 	if (rate->idx < 0 || !rate->count)
 		return -1;
-	if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
+	if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
+		stat->bw = RATE_INFO_BW_160;
+	else if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
 		stat->bw = RATE_INFO_BW_80;
 	else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
 		stat->bw = RATE_INFO_BW_40;
 		 * This will not be very accurate, but much better than simply
 		 * assuming un-aggregated tx in all cases.
 		 */
-		if (duration > 400) /* <= VHT20 MCS2 1S */
+		if (duration > 400 * 1024) /* <= VHT20 MCS2 1S */
 			agg_shift = 1;
-		else if (duration > 250) /* <= VHT20 MCS3 1S or MCS1 2S */
+		else if (duration > 250 * 1024) /* <= VHT20 MCS3 1S or MCS1 2S */
 			agg_shift = 2;
-		else if (duration > 150) /* <= VHT20 MCS5 1S or MCS3 2S */
+		else if (duration > 150 * 1024) /* <= VHT20 MCS5 1S or MCS2 2S */
 			agg_shift = 3;
-		else
+		else if (duration > 70 * 1024) /* <= VHT20 MCS5 2S */
 			agg_shift = 4;
+		else if (stat.encoding != RX_ENC_HE ||
+			 duration > 20 * 1024) /* <= HE40 MCS6 2S */
+			agg_shift = 5;
+		else
+			agg_shift = 6;
 		duration *= len;
 		duration /= AVG_PKT_SIZE;
 		duration /= 1024;
+		duration += (overhead >> agg_shift);
-		return duration + (overhead >> agg_shift);
+		return max_t(u32, duration, 4);
 	}
 	if (!conf)

net/mac80211/mlme.c+2−1

 	struct ieee80211_supported_band *sband;
 	struct cfg80211_chan_def chandef;
 	bool is_6ghz = cbss->channel->band == NL80211_BAND_6GHZ;
+	bool is_5ghz = cbss->channel->band == NL80211_BAND_5GHZ;
 	struct ieee80211_bss *bss = (void *)cbss->priv;
 	int ret;
 	u32 i;
 		ifmgd->flags |= IEEE80211_STA_DISABLE_HE;
 	}
-	if (!sband->vht_cap.vht_supported && !is_6ghz) {
+	if (!sband->vht_cap.vht_supported && is_5ghz) {
 		ifmgd->flags |= IEEE80211_STA_DISABLE_VHT;
 		ifmgd->flags |= IEEE80211_STA_DISABLE_HE;
 	}

net/mac80211/rx.c+2−1

@@ -451,7 +451,8 @@ ieee80211_add_rx_radiotap_header(struct ieee80211_local *local, · 450 unmodified lines
451	else if (status->bw == RATE_INFO_BW_5)	451	else if (status->bw == RATE_INFO_BW_5)
452	channel_flags \|= IEEE80211_CHAN_QUARTER;	452	channel_flags \|= IEEE80211_CHAN_QUARTER;
453		453
454	if (status->band == NL80211_BAND_5GHZ)	454	if (status->band == NL80211_BAND_5GHZ \|\|
		455	status->band == NL80211_BAND_6GHZ)
455	channel_flags \|= IEEE80211_CHAN_OFDM \| IEEE80211_CHAN_5GHZ;	456	channel_flags \|= IEEE80211_CHAN_OFDM \| IEEE80211_CHAN_5GHZ;
456	else if (status->encoding != RX_ENC_LEGACY)	457	else if (status->encoding != RX_ENC_LEGACY)
457	channel_flags \|= IEEE80211_CHAN_DYN \| IEEE80211_CHAN_2GHZ;	458	channel_flags \|= IEEE80211_CHAN_DYN \| IEEE80211_CHAN_2GHZ;

net/mac80211/util.c+4−3

 		he_chandef.center_freq1 =
 			ieee80211_channel_to_frequency(he_6ghz_oper->ccfs0,
 						       NL80211_BAND_6GHZ);
-		he_chandef.center_freq2 =
+		if (support_80_80 || support_160)
-			ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
+			he_chandef.center_freq2 =
-						       NL80211_BAND_6GHZ);
+				ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
+							       NL80211_BAND_6GHZ);
 	}
 	if (!cfg80211_chandef_valid(&he_chandef)) {

net/mac80211/vht.c+4−4

 	/* take some capabilities as-is */
 	cap_info = le32_to_cpu(vht_cap_ie->vht_cap_info);
 	vht_cap->cap = cap_info;
-	vht_cap->cap &= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895 |
+	vht_cap->cap &= IEEE80211_VHT_CAP_RXLDPC |
-			IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991 |
-			IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
-			IEEE80211_VHT_CAP_RXLDPC |
 			IEEE80211_VHT_CAP_VHT_TXOP_PS |
 			IEEE80211_VHT_CAP_HTC_VHT |
 			IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK |
 			IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
 			IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
+	vht_cap->cap |= min_t(u32, cap_info & IEEE80211_VHT_CAP_MAX_MPDU_MASK,
+			      own_cap.cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK);
 	/* and some based on our own capabilities */
 	switch (own_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
 	case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:

net/mac802154/tx.c+5−3

 	if (res)
 		goto err_tx;
-	ieee802154_xmit_complete(&local->hw, skb, false);
 	dev->stats.tx_packets++;
 	dev->stats.tx_bytes += skb->len;
+	ieee802154_xmit_complete(&local->hw, skb, false);
 	return;
 err_tx:
 	/* async is priority, otherwise sync is fallback */
 	if (local->ops->xmit_async) {
+		unsigned int len = skb->len;
 		ret = drv_xmit_async(local, skb);
 		if (ret) {
 			ieee802154_wake_queue(&local->hw);
 		}
 		dev->stats.tx_packets++;
-		dev->stats.tx_bytes += skb->len;
+		dev->stats.tx_bytes += len;
 	} else {
 		local->tx_skb = skb;
 		queue_work(local->workqueue, &local->tx_work);

net/mptcp/pm_netlink.c+16−3

 	return a->port == b->port;
 }
+static bool address_zero(const struct mptcp_addr_info *addr)
+{
+	struct mptcp_addr_info zero;
+	memset(&zero, 0, sizeof(zero));
+	zero.family = addr->family;
+	return addresses_equal(addr, &zero, false);
+}
 static void local_address(const struct sock_common *skc,
 			  struct mptcp_addr_info *addr)
 {
 static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk)
 {
+	struct mptcp_addr_info remote = { 0 };
 	struct sock *sk = (struct sock *)msk;
 	struct mptcp_pm_addr_entry *local;
-	struct mptcp_addr_info remote;
 	struct pm_nl_pernet *pernet;
 	pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
 	 * addr
 	 */
 	local_address((struct sock_common *)msk, &msk_local);
-	local_address((struct sock_common *)msk, &skc_local);
+	local_address((struct sock_common *)skc, &skc_local);
 	if (addresses_equal(&msk_local, &skc_local, false))
 		return 0;
+	if (address_zero(&skc_local))
+		return 0;
 	pernet = net_generic(sock_net((struct sock *)msk), pm_nl_pernet_id);
 	rcu_read_lock();
 		return ret;
 	/* address not found, add to local list */
-	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+	entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
 	if (!entry)
 		return -ENOMEM;

net/mptcp/subflow.c+5−2

 	struct mptcp_sock *msk = mptcp_sk(sk);
 	struct mptcp_subflow_context *subflow;
 	struct sockaddr_storage addr;
+	int remote_id = remote->id;
 	int local_id = loc->id;
 	struct socket *sf;
 	struct sock *ssk;
 		goto failed;
 	mptcp_crypto_key_sha(subflow->remote_key, &remote_token, NULL);
-	pr_debug("msk=%p remote_token=%u local_id=%d", msk, remote_token,
+	pr_debug("msk=%p remote_token=%u local_id=%d remote_id=%d", msk,
-		 local_id);
+		 remote_token, local_id, remote_id);
 	subflow->remote_token = remote_token;
 	subflow->local_id = local_id;
+	subflow->remote_id = remote_id;
 	subflow->request_join = 1;
 	subflow->request_bkup = 1;
 	mptcp_info2sockaddr(remote, &addr);
 		new_ctx->fully_established = 1;
 		new_ctx->backup = subflow_req->backup;
 		new_ctx->local_id = subflow_req->local_id;
+		new_ctx->remote_id = subflow_req->remote_id;
 		new_ctx->token = subflow_req->token;
 		new_ctx->thmac = subflow_req->thmac;
 	}

net/netfilter/nf_conntrack_netlink.c+5−17

@@ -851,7 +851,6 @@ static int ctnetlink_done(struct netlink_callback *cb) · 850 unmodified lines
851	}	851	}
852		852
853	struct ctnetlink_filter {	853	struct ctnetlink_filter {
854	u_int32_t cta_flags;
855	u8 family;	854	u8 family;
856		855
857	u_int32_t orig_flags;	856	u_int32_t orig_flags;
@@ -906,10 +905,6 @@ static int ctnetlink_parse_tuple_filter(const struct nlattr * const cda[], · 48 unmodified lines
906	struct nf_conntrack_zone *zone,	905	struct nf_conntrack_zone *zone,
907	u_int32_t flags);	906	u_int32_t flags);
908		907
909	/* applied on filters */
910	#define CTA_FILTER_F_CTA_MARK (1 << 0)
911	#define CTA_FILTER_F_CTA_MARK_MASK (1 << 1)
912
913	static struct ctnetlink_filter *	908	static struct ctnetlink_filter *
914	ctnetlink_alloc_filter(const struct nlattr * const cda[], u8 family)	909	ctnetlink_alloc_filter(const struct nlattr * const cda[], u8 family)
915	{	910	{
@@ -930,14 +925,10 @@ ctnetlink_alloc_filter(const struct nlattr * const cda[], u8 family) · 14 unmodified lines
930	#ifdef CONFIG_NF_CONNTRACK_MARK	925	#ifdef CONFIG_NF_CONNTRACK_MARK
931	if (cda[CTA_MARK]) {	926	if (cda[CTA_MARK]) {
932	filter->mark.val = ntohl(nla_get_be32(cda[CTA_MARK]));	927	filter->mark.val = ntohl(nla_get_be32(cda[CTA_MARK]));
933	filter->cta_flags \|= CTA_FILTER_FLAG(CTA_MARK);	928	if (cda[CTA_MARK_MASK])
934
935	if (cda[CTA_MARK_MASK]) {
936	filter->mark.mask = ntohl(nla_get_be32(cda[CTA_MARK_MASK]));	929	filter->mark.mask = ntohl(nla_get_be32(cda[CTA_MARK_MASK]));
937	filter->cta_flags \|= CTA_FILTER_FLAG(CTA_MARK_MASK);	930	else
938	} else {
939	filter->mark.mask = 0xffffffff;	931	filter->mark.mask = 0xffffffff;
940	}
941	} else if (cda[CTA_MARK_MASK]) {	932	} else if (cda[CTA_MARK_MASK]) {
942	err = -EINVAL;	933	err = -EINVAL;
943	goto err_filter;	934	goto err_filter;
@@ -1117,11 +1108,7 @@ static int ctnetlink_filter_match(struct nf_conn ct, void data) · 173 unmodified lines
1117	}	1108	}
1118		1109
1119	#ifdef CONFIG_NF_CONNTRACK_MARK	1110	#ifdef CONFIG_NF_CONNTRACK_MARK
1120	if ((filter->cta_flags & CTA_FILTER_FLAG(CTA_MARK_MASK)) &&	1111	if ((ct->mark & filter->mark.mask) != filter->mark.val)
1121	(ct->mark & filter->mark.mask) != filter->mark.val)
1122	goto ignore_entry;
1123	else if ((filter->cta_flags & CTA_FILTER_FLAG(CTA_MARK)) &&
1124	ct->mark != filter->mark.val)
1125	goto ignore_entry;	1112	goto ignore_entry;
1126	#endif	1113	#endif
1127		1114
@@ -1404,7 +1391,8 @@ ctnetlink_parse_tuple_filter(const struct nlattr * const cda[], · 276 unmodified lines
1404	if (err < 0)	1391	if (err < 0)
1405	return err;	1392	return err;
1406		1393
1407		1394	if (l3num != NFPROTO_IPV4 && l3num != NFPROTO_IPV6)
		1395	return -EOPNOTSUPP;
1408	tuple->src.l3num = l3num;	1396	tuple->src.l3num = l3num;
1409		1397
1410	if (flags & CTA_FILTER_FLAG(CTA_IP_DST) \|\|	1398	if (flags & CTA_FILTER_FLAG(CTA_IP_DST) \|\|

net/netfilter/nf_conntrack_proto.c+2−0

 	int err;
 	err = nf_ct_netns_do_get(net, NFPROTO_IPV4);
+#if IS_ENABLED(CONFIG_IPV6)
 	if (err < 0)
 		goto err1;
 	err = nf_ct_netns_do_get(net, NFPROTO_IPV6);
 err2:
 	nf_ct_netns_put(net, NFPROTO_IPV4);
 err1:
+#endif
 	return err;
 }

net/netfilter/nf_tables_api.c+57−13

 	return -1;
 }
+struct nftnl_skb_parms {
+	bool report;
+};
+#define NFT_CB(skb)	(*(struct nftnl_skb_parms*)&((skb)->cb))
+static void nft_notify_enqueue(struct sk_buff *skb, bool report,
+			       struct list_head *notify_list)
+{
+	NFT_CB(skb).report = report;
+	list_add_tail(&skb->list, notify_list);
+}
 static void nf_tables_table_notify(const struct nft_ctx *ctx, int event)
 {
 	struct sk_buff *skb;
 		goto err;
 	}
-	nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
+	nft_notify_enqueue(skb, ctx->report, &ctx->net->nft.notify_list);
-		       ctx->report, GFP_KERNEL);
 	return;
 err:
 	nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
 		goto err;
 	}
-	nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
+	nft_notify_enqueue(skb, ctx->report, &ctx->net->nft.notify_list);
-		       ctx->report, GFP_KERNEL);
 	return;
 err:
 	nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
 		goto err;
 	}
-	nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
+	nft_notify_enqueue(skb, ctx->report, &ctx->net->nft.notify_list);
-		       ctx->report, GFP_KERNEL);
 	return;
 err:
 	nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
 		goto err;
 	}
-	nfnetlink_send(skb, ctx->net, portid, NFNLGRP_NFTABLES, ctx->report,
+	nft_notify_enqueue(skb, ctx->report, &ctx->net->nft.notify_list);
-		       gfp_flags);
 	return;
 err:
 	nfnetlink_set_err(ctx->net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
 		goto err;
 	}
-	nfnetlink_send(skb, net, portid, NFNLGRP_NFTABLES, ctx->report,
+	nft_notify_enqueue(skb, ctx->report, &ctx->net->nft.notify_list);
-		       GFP_KERNEL);
 	return;
 err:
 	nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
 		goto err;
 	}
-	nfnetlink_send(skb, net, portid, NFNLGRP_NFTABLES, report, gfp);
+	nft_notify_enqueue(skb, report, &net->nft.notify_list);
 	return;
 err:
 	nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
 		goto err;
 	}
-	nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
+	nft_notify_enqueue(skb, ctx->report, &ctx->net->nft.notify_list);
-		       ctx->report, GFP_KERNEL);
 	return;
 err:
 	nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
 	mutex_unlock(&net->nft.commit_mutex);
 }
+static void nft_commit_notify(struct net *net, u32 portid)
+{
+	struct sk_buff *batch_skb = NULL, *nskb, *skb;
+	unsigned char *data;
+	int len;
+	list_for_each_entry_safe(skb, nskb, &net->nft.notify_list, list) {
+		if (!batch_skb) {
+new_batch:
+			batch_skb = skb;
+			len = NLMSG_GOODSIZE - skb->len;
+			list_del(&skb->list);
+			continue;
+		}
+		len -= skb->len;
+		if (len > 0 && NFT_CB(skb).report == NFT_CB(batch_skb).report) {
+			data = skb_put(batch_skb, skb->len);
+			memcpy(data, skb->data, skb->len);
+			list_del(&skb->list);
+			kfree_skb(skb);
+			continue;
+		}
+		nfnetlink_send(batch_skb, net, portid, NFNLGRP_NFTABLES,
+			       NFT_CB(batch_skb).report, GFP_KERNEL);
+		goto new_batch;
+	}
+	if (batch_skb) {
+		nfnetlink_send(batch_skb, net, portid, NFNLGRP_NFTABLES,
+			       NFT_CB(batch_skb).report, GFP_KERNEL);
+	}
+	WARN_ON_ONCE(!list_empty(&net->nft.notify_list));
+}
 static int nf_tables_commit(struct net *net, struct sk_buff *skb)
 {
 	struct nft_trans *trans, *next;
 		}
 	}
+	nft_commit_notify(net, NETLINK_CB(skb).portid);
 	nf_tables_gen_notify(net, skb, NFT_MSG_NEWGEN);
 	nf_tables_commit_release(net);
 	INIT_LIST_HEAD(&net->nft.tables);
 	INIT_LIST_HEAD(&net->nft.commit_list);
 	INIT_LIST_HEAD(&net->nft.module_list);
+	INIT_LIST_HEAD(&net->nft.notify_list);
 	mutex_init(&net->nft.commit_mutex);
 	net->nft.base_seq = 1;
 	net->nft.validate_state = NFT_VALIDATE_SKIP;
 	mutex_unlock(&net->nft.commit_mutex);
 	WARN_ON_ONCE(!list_empty(&net->nft.tables));
 	WARN_ON_ONCE(!list_empty(&net->nft.module_list));
+	WARN_ON_ONCE(!list_empty(&net->nft.notify_list));
 }
 static struct pernet_operations nf_tables_net_ops = {

net/netfilter/nft_meta.c+2−2

@@ -147,11 +147,11 @@ nft_meta_get_eval_skugid(enum nft_meta_keys key, · 146 unmodified lines
147		147
148	switch (key) {	148	switch (key) {
149	case NFT_META_SKUID:	149	case NFT_META_SKUID:
150	*dest = from_kuid_munged(&init_user_ns,	150	*dest = from_kuid_munged(sock_net(sk)->user_ns,
151	sock->file->f_cred->fsuid);	151	sock->file->f_cred->fsuid);
152	break;	152	break;
153	case NFT_META_SKGID:	153	case NFT_META_SKGID:
154	*dest = from_kgid_munged(&init_user_ns,	154	*dest = from_kgid_munged(sock_net(sk)->user_ns,
155	sock->file->f_cred->fsgid);	155	sock->file->f_cred->fsgid);
156	break;	156	break;
157	default:	157	default:

net/qrtr/qrtr.c+11−10

 {
 	struct qrtr_hdr_v1 *hdr;
 	size_t len = skb->len;
-	int rc = -ENODEV;
+	int rc, confirm_rx;
-	int confirm_rx;
 	confirm_rx = qrtr_tx_wait(node, to->sq_node, to->sq_port, type);
 	if (confirm_rx < 0) {
 	hdr->size = cpu_to_le32(len);
 	hdr->confirm_rx = !!confirm_rx;
-	skb_put_padto(skb, ALIGN(len, 4) + sizeof(*hdr));
+	rc = skb_put_padto(skb, ALIGN(len, 4) + sizeof(*hdr));
-	mutex_lock(&node->ep_lock);
-	if (node->ep)
-		rc = node->ep->xmit(node->ep, skb);
-	else
-		kfree_skb(skb);
-	mutex_unlock(&node->ep_lock);
+	if (!rc) {
+		mutex_lock(&node->ep_lock);
+		rc = -ENODEV;
+		if (node->ep)
+			rc = node->ep->xmit(node->ep, skb);
+		else
+			kfree_skb(skb);
+		mutex_unlock(&node->ep_lock);
+	}
 	/* Need to ensure that a subsequent message carries the otherwise lost
 	 * confirm_rx flag if we dropped this one */
 	if (rc && confirm_rx)

net/sched/act_ife.c+34−10

 		kfree_rcu(p, rcu);
 }
+static int load_metalist(struct nlattr **tb, bool rtnl_held)
+{
+	int i;
+	for (i = 1; i < max_metacnt; i++) {
+		if (tb[i]) {
+			void *val = nla_data(tb[i]);
+			int len = nla_len(tb[i]);
+			int rc;
+			rc = load_metaops_and_vet(i, val, len, rtnl_held);
+			if (rc != 0)
+				return rc;
+		}
+	}
+	return 0;
+}
 static int populate_metalist(struct tcf_ife_info *ife, struct nlattr **tb,
 			     bool exists, bool rtnl_held)
 {
 			val = nla_data(tb[i]);
 			len = nla_len(tb[i]);
-			rc = load_metaops_and_vet(i, val, len, rtnl_held);
-			if (rc != 0)
-				return rc;
 			rc = add_metainfo(ife, i, val, len, exists);
 			if (rc)
 				return rc;
 	if (!p)
 		return -ENOMEM;
+	if (tb[TCA_IFE_METALST]) {
+		err = nla_parse_nested_deprecated(tb2, IFE_META_MAX,
+						  tb[TCA_IFE_METALST], NULL,
+						  NULL);
+		if (err) {
+			kfree(p);
+			return err;
+		}
+		err = load_metalist(tb2, rtnl_held);
+		if (err) {
+			kfree(p);
+			return err;
+		}
+	}
 	index = parm->index;
 	err = tcf_idr_check_alloc(tn, &index, a, bind);
 	if (err < 0) {
 	}
 	if (tb[TCA_IFE_METALST]) {
-		err = nla_parse_nested_deprecated(tb2, IFE_META_MAX,
-						  tb[TCA_IFE_METALST], NULL,
-						  NULL);
-		if (err)
-			goto metadata_parse_err;
 		err = populate_metalist(ife, tb2, exists, rtnl_held);
 		if (err)
 			goto metadata_parse_err;
 	} else {
 		/* if no passed metadata allow list or passed allow-all
 		 * then here we process by adding as many supported metadatum

net/sched/act_tunnel_key.c+1−0

@@ -156,6 +156,7 @@ tunnel_key_copy_vxlan_opt(const struct nlattr nla, void dst, int dst_len, · 155 unmodified lines
156	struct vxlan_metadata *md = dst;	156	struct vxlan_metadata *md = dst;
157		157
158	md->gbp = nla_get_u32(tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP]);	158	md->gbp = nla_get_u32(tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP]);
		159	md->gbp &= VXLAN_GBP_MASK;
159	}	160	}
160		161
161	return sizeof(struct vxlan_metadata);	162	return sizeof(struct vxlan_metadata);

net/sched/cls_flower.c+4−1

 		return -EINVAL;
 	}
-	if (tb[TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP])
+	if (tb[TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP]) {
 		md->gbp = nla_get_u32(tb[TCA_FLOWER_KEY_ENC_OPT_VXLAN_GBP]);
+		md->gbp &= VXLAN_GBP_MASK;
+	}
 	return sizeof(*md);
 }
 		}
 		if (tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX]) {
 			nla = tb[TCA_FLOWER_KEY_ENC_OPT_ERSPAN_INDEX];
+			memset(&md->u, 0x00, sizeof(md->u));
 			md->u.index = nla_get_be32(nla);
 		}
 	} else if (md->version == 2) {

net/sched/sch_generic.c+33−15

 static void qdisc_deactivate(struct Qdisc *qdisc)
 {
-	bool nolock = qdisc->flags & TCQ_F_NOLOCK;
 	if (qdisc->flags & TCQ_F_BUILTIN)
 		return;
-	if (test_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state))
-		return;
-	if (nolock)
-		spin_lock_bh(&qdisc->seqlock);
-	spin_lock_bh(qdisc_lock(qdisc));
 	set_bit(__QDISC_STATE_DEACTIVATED, &qdisc->state);
-	qdisc_reset(qdisc);
-	spin_unlock_bh(qdisc_lock(qdisc));
-	if (nolock)
-		spin_unlock_bh(&qdisc->seqlock);
 }
 static void dev_deactivate_queue(struct net_device *dev,
 	}
 }
+static void dev_reset_queue(struct net_device *dev,
+			    struct netdev_queue *dev_queue,
+			    void *_unused)
+{
+	struct Qdisc *qdisc;
+	bool nolock;
+	qdisc = dev_queue->qdisc_sleeping;
+	if (!qdisc)
+		return;
+	nolock = qdisc->flags & TCQ_F_NOLOCK;
+	if (nolock)
+		spin_lock_bh(&qdisc->seqlock);
+	spin_lock_bh(qdisc_lock(qdisc));
+	qdisc_reset(qdisc);
+	spin_unlock_bh(qdisc_lock(qdisc));
+	if (nolock)
+		spin_unlock_bh(&qdisc->seqlock);
+}
 static bool some_qdisc_is_busy(struct net_device *dev)
 {
 	unsigned int i;
 		dev_watchdog_down(dev);
 	}
-	/* Wait for outstanding qdisc-less dev_queue_xmit calls.
+	/* Wait for outstanding qdisc-less dev_queue_xmit calls or
+	 * outstanding qdisc enqueuing calls.
 	 * This is avoided if all devices are in dismantle phase :
 	 * Caller will call synchronize_net() for us
 	 */
 	synchronize_net();
+	list_for_each_entry(dev, head, close_list) {
+		netdev_for_each_tx_queue(dev, dev_reset_queue, NULL);
+		if (dev_ingress_queue(dev))
+			dev_reset_queue(dev, dev_ingress_queue(dev), NULL);
+	}
 	/* Wait for outstanding qdisc_run calls. */
 	list_for_each_entry(dev, head, close_list) {
 		while (some_qdisc_is_busy(dev)) {

net/sched/sch_taprio.c+17−11

 	[TCA_TAPRIO_ATTR_TXTIME_DELAY]		     = { .type = NLA_U32 },
 };
-static int fill_sched_entry(struct nlattr **tb, struct sched_entry *entry,
+static int fill_sched_entry(struct taprio_sched *q, struct nlattr **tb,
+			    struct sched_entry *entry,
 			    struct netlink_ext_ack *extack)
 {
+	int min_duration = length_to_duration(q, ETH_ZLEN);
 	u32 interval = 0;
 	if (tb[TCA_TAPRIO_SCHED_ENTRY_CMD])
 		interval = nla_get_u32(
 			tb[TCA_TAPRIO_SCHED_ENTRY_INTERVAL]);
-	if (interval == 0) {
+	/* The interval should allow at least the minimum ethernet
+	 * frame to go out.
+	 */
+	if (interval < min_duration) {
 		NL_SET_ERR_MSG(extack, "Invalid interval for schedule entry");
 		return -EINVAL;
 	}
 	return 0;
 }
-static int parse_sched_entry(struct nlattr *n, struct sched_entry *entry,
+static int parse_sched_entry(struct taprio_sched *q, struct nlattr *n,
-			     int index, struct netlink_ext_ack *extack)
+			     struct sched_entry *entry, int index,
+			     struct netlink_ext_ack *extack)
 {
 	struct nlattr *tb[TCA_TAPRIO_SCHED_ENTRY_MAX + 1] = { };
 	int err;
 	entry->index = index;
-	return fill_sched_entry(tb, entry, extack);
+	return fill_sched_entry(q, tb, entry, extack);
 }
-static int parse_sched_list(struct nlattr *list,
+static int parse_sched_list(struct taprio_sched *q, struct nlattr *list,
 			    struct sched_gate_list *sched,
 			    struct netlink_ext_ack *extack)
 {
 			return -ENOMEM;
 		}
-		err = parse_sched_entry(n, entry, i, extack);
+		err = parse_sched_entry(q, n, entry, i, extack);
 		if (err < 0) {
 			kfree(entry);
 			return err;
 	return i;
 }
-static int parse_taprio_schedule(struct nlattr **tb,
+static int parse_taprio_schedule(struct taprio_sched *q, struct nlattr **tb,
 				 struct sched_gate_list *new,
 				 struct netlink_ext_ack *extack)
 {
 		new->cycle_time = nla_get_s64(tb[TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME]);
 	if (tb[TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST])
-		err = parse_sched_list(
+		err = parse_sched_list(q, tb[TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST],
-			tb[TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST], new, extack);
+				       new, extack);
 	if (err < 0)
 		return err;
 		goto free_sched;
 	}
-	err = parse_taprio_schedule(tb, new_admin, extack);
+	err = parse_taprio_schedule(q, tb, new_admin, extack);
 	if (err < 0)
 		goto free_sched;

net/sctp/socket.c+3−6

 static inline void sctp_copy_descendant(struct sock *sk_to,
 					const struct sock *sk_from)
 {
-	int ancestor_size = sizeof(struct inet_sock) +
+	size_t ancestor_size = sizeof(struct inet_sock);
-			    sizeof(struct sctp_sock) -
-			    offsetof(struct sctp_sock, pd_lobby);
-	if (sk_from->sk_family == PF_INET6)
-		ancestor_size += sizeof(struct ipv6_pinfo);
+	ancestor_size += sk_from->sk_prot->obj_size;
+	ancestor_size -= offsetof(struct sctp_sock, pd_lobby);
 	__inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
 }

net/tipc/group.c+10−4

 	return NULL;
 }
-static void tipc_group_add_to_tree(struct tipc_group *grp,
+static int tipc_group_add_to_tree(struct tipc_group *grp,
-				   struct tipc_member *m)
+				  struct tipc_member *m)
 {
 	u64 nkey, key = (u64)m->node << 32 | m->port;
 	struct rb_node **n, *parent = NULL;
 		else if (key > nkey)
 			n = &(*n)->rb_right;
 		else
-			return;
+			return -EEXIST;
 	}
 	rb_link_node(&m->tree_node, parent, n);
 	rb_insert_color(&m->tree_node, &grp->members);
+	return 0;
 }
 static struct tipc_member *tipc_group_create_member(struct tipc_group *grp,
 						    u32 instance, int state)
 {
 	struct tipc_member *m;
+	int ret;
 	m = kzalloc(sizeof(*m), GFP_ATOMIC);
 	if (!m)
 	m->port = port;
 	m->instance = instance;
 	m->bc_acked = grp->bc_snd_nxt - 1;
+	ret = tipc_group_add_to_tree(grp, m);
+	if (ret < 0) {
+		kfree(m);
+		return NULL;
+	}
 	grp->member_cnt++;
-	tipc_group_add_to_tree(grp, m);
 	tipc_nlist_add(&grp->dests, m->node);
 	m->state = state;
 	return m;

net/tipc/link.c+2−1

  * tipc_link_bc_create - create new link to be used for broadcast
  * @net: pointer to associated network namespace
  * @mtu: mtu to be used initially if no peers
- * @window: send window to be used
+ * @min_win: minimal send window to be used by link
+ * @max_win: maximal send window to be used by link
  * @inputq: queue to put messages ready for delivery
  * @namedq: queue to put binding table update messages ready for delivery
  * @link: return value, pointer to put the created link

net/tipc/msg.c+2−1

 	if (fragid == FIRST_FRAGMENT) {
 		if (unlikely(head))
 			goto err;
-		if (unlikely(skb_unclone(frag, GFP_ATOMIC)))
+		frag = skb_unshare(frag, GFP_ATOMIC);
+		if (unlikely(!frag))
 			goto err;
 		head = *headbuf = frag;
 		*buf = NULL;

net/tipc/socket.c+1−4

 	trace_tipc_sk_shutdown(sk, NULL, TIPC_DUMP_ALL, " ");
 	__tipc_shutdown(sock, TIPC_CONN_SHUTDOWN);
-	if (tipc_sk_type_connectionless(sk))
+	sk->sk_shutdown = SHUTDOWN_MASK;
-		sk->sk_shutdown = SHUTDOWN_MASK;
-	else
-		sk->sk_shutdown = SEND_SHUTDOWN;
 	if (sk->sk_state == TIPC_DISCONNECTING) {
 		/* Discard any unreceived messages */

net/wireless/Kconfig+1−0

@@ -217,6 +217,7 @@ config LIB80211_CRYPT_WEP · 216 unmodified lines
217		217
218	config LIB80211_CRYPT_CCMP	218	config LIB80211_CRYPT_CCMP
219	tristate	219	tristate
		220	select CRYPTO
220	select CRYPTO_AES	221	select CRYPTO_AES
221	select CRYPTO_CCM	222	select CRYPTO_CCM
222		223

net/wireless/util.c+1−1

@@ -95,7 +95,7 @@ u32 ieee80211_channel_to_freq_khz(int chan, enum nl80211_band band) · 94 unmodified lines
95	/* see 802.11ax D6.1 27.3.23.2 */	95	/* see 802.11ax D6.1 27.3.23.2 */
96	if (chan == 2)	96	if (chan == 2)
97	return MHZ_TO_KHZ(5935);	97	return MHZ_TO_KHZ(5935);
98	if (chan <= 253)	98	if (chan <= 233)
99	return MHZ_TO_KHZ(5950 + chan * 5);	99	return MHZ_TO_KHZ(5950 + chan * 5);
100	break;	100	break;
101	case NL80211_BAND_60GHZ:	101	case NL80211_BAND_60GHZ:

net/xdp/xdp_umem.c+8−9

 static int xdp_umem_reg(struct xdp_umem *umem, struct xdp_umem_reg *mr)
 {
+	u32 npgs_rem, chunk_size = mr->chunk_size, headroom = mr->headroom;
 	bool unaligned_chunks = mr->flags & XDP_UMEM_UNALIGNED_CHUNK_FLAG;
-	u32 chunk_size = mr->chunk_size, headroom = mr->headroom;
 	u64 npgs, addr = mr->addr, size = mr->len;
-	unsigned int chunks, chunks_per_page;
+	unsigned int chunks, chunks_rem;
 	int err;
 	if (chunk_size < XDP_UMEM_MIN_CHUNK_SIZE || chunk_size > PAGE_SIZE) {
 	if ((addr + size) < addr)
 		return -EINVAL;
-	npgs = size >> PAGE_SHIFT;
+	npgs = div_u64_rem(size, PAGE_SIZE, &npgs_rem);
+	if (npgs_rem)
+		npgs++;
 	if (npgs > U32_MAX)
 		return -EINVAL;
-	chunks = (unsigned int)div_u64(size, chunk_size);
+	chunks = (unsigned int)div_u64_rem(size, chunk_size, &chunks_rem);
 	if (chunks == 0)
 		return -EINVAL;
-	if (!unaligned_chunks) {
+	if (!unaligned_chunks && chunks_rem)
-		chunks_per_page = PAGE_SIZE / chunk_size;
+		return -EINVAL;
-		if (chunks < chunks_per_page || chunks % chunks_per_page)
-			return -EINVAL;
-	}
 	if (headroom >= chunk_size - XDP_PACKET_HEADROOM)
 		return -EINVAL;

tools/bpf/Makefile+2−2

@@ -38,7 +38,7 @@ FEATURE_TESTS = libbfd disassembler-four-args · 37 unmodified lines
38	FEATURE_DISPLAY = libbfd disassembler-four-args	38	FEATURE_DISPLAY = libbfd disassembler-four-args
39		39
40	check_feat := 1	40	check_feat := 1
41	NON_CHECK_FEAT_TARGETS := clean bpftool_clean runqslower_clean	41	NON_CHECK_FEAT_TARGETS := clean bpftool_clean runqslower_clean resolve_btfids_clean
42	ifdef MAKECMDGOALS	42	ifdef MAKECMDGOALS
43	ifeq ($(filter-out $(NON_CHECK_FEAT_TARGETS),$(MAKECMDGOALS)),)	43	ifeq ($(filter-out $(NON_CHECK_FEAT_TARGETS),$(MAKECMDGOALS)),)
44	check_feat := 0	44	check_feat := 0
@@ -89,7 +89,7 @@ $(OUTPUT)bpf_exp.lex.c: $(OUTPUT)bpf_exp.yacc.c · 44 unmodified lines
89	$(OUTPUT)bpf_exp.yacc.o: $(OUTPUT)bpf_exp.yacc.c	89	$(OUTPUT)bpf_exp.yacc.o: $(OUTPUT)bpf_exp.yacc.c
90	$(OUTPUT)bpf_exp.lex.o: $(OUTPUT)bpf_exp.lex.c	90	$(OUTPUT)bpf_exp.lex.o: $(OUTPUT)bpf_exp.lex.c
91		91
92	clean: bpftool_clean runqslower_clean	92	clean: bpftool_clean runqslower_clean resolve_btfids_clean
93	$(call QUIET_CLEAN, bpf-progs)	93	$(call QUIET_CLEAN, bpf-progs)
94	$(Q)$(RM) -r -- $(OUTPUT)*.o $(OUTPUT)bpf_jit_disasm $(OUTPUT)bpf_dbg \	94	$(Q)$(RM) -r -- $(OUTPUT)*.o $(OUTPUT)bpf_jit_disasm $(OUTPUT)bpf_dbg \
95	$(OUTPUT)bpf_asm $(OUTPUT)bpf_exp.yacc.* $(OUTPUT)bpf_exp.lex.*	95	$(OUTPUT)bpf_asm $(OUTPUT)bpf_exp.yacc.* $(OUTPUT)bpf_exp.lex.*

tools/bpf/resolve_btfids/Makefile+1−0

@@ -80,6 +80,7 @@ libbpf-clean: · 79 unmodified lines
80	clean: libsubcmd-clean libbpf-clean fixdep-clean	80	clean: libsubcmd-clean libbpf-clean fixdep-clean
81	$(call msg,CLEAN,$(BINARY))	81	$(call msg,CLEAN,$(BINARY))
82	$(Q)$(RM) -f $(BINARY); \	82	$(Q)$(RM) -f $(BINARY); \
		83	$(RM) -rf $(if $(OUTPUT),$(OUTPUT),.)/feature; \
83	find $(if $(OUTPUT),$(OUTPUT),.) -name \.o -or -name \.o.cmd -or -name \*.o.d \| xargs $(RM)	84	find $(if $(OUTPUT),$(OUTPUT),.) -name \.o -or -name \.o.cmd -or -name \*.o.d \| xargs $(RM)
84		85
85	tags:	86	tags:

tools/lib/bpf/Makefile+3−1

 FEATURE_TESTS = libelf libelf-mmap zlib bpf reallocarray
 FEATURE_DISPLAY = libelf zlib bpf
-INCLUDES = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(ARCH)/include/uapi -I$(srctree)/tools/include/uapi
+INCLUDES = -I. -I$(srctree)/tools/include -I$(srctree)/tools/include/uapi
 FEATURE_CHECK_CFLAGS-bpf = $(INCLUDES)
 check_feat := 1
 			   awk '/GLOBAL/ && /DEFAULT/ && !/UND/ {print $$NF}' | \
 			   sort -u | wc -l)
 VERSIONED_SYM_COUNT = $(shell readelf --dyn-syms --wide $(OUTPUT)libbpf.so | \
+			      awk '/GLOBAL/ && /DEFAULT/ && !/UND/ {print $$NF}' | \
 			      grep -Eo '[^ ]+@LIBBPF_' | cut -d@ -f1 | sort -u | wc -l)
 CMD_TARGETS = $(LIB_TARGET) $(PC_FILE)
 		    awk '/GLOBAL/ && /DEFAULT/ && !/UND/ {print $$NF}'|  \
 		    sort -u > $(OUTPUT)libbpf_global_syms.tmp;		 \
 		readelf --dyn-syms --wide $(OUTPUT)libbpf.so |		 \
+		    awk '/GLOBAL/ && /DEFAULT/ && !/UND/ {print $$NF}'|  \
 		    grep -Eo '[^ ]+@LIBBPF_' | cut -d@ -f1 |		 \
 		    sort -u > $(OUTPUT)libbpf_versioned_syms.tmp; 	 \
 		diff -u $(OUTPUT)libbpf_global_syms.tmp			 \

tools/lib/bpf/libbpf.c+1−1

 	int i, j, nrels, new_sz;
 	const struct btf_var_secinfo *vi = NULL;
 	const struct btf_type *sec, *var, *def;
+	struct bpf_map *map = NULL, *targ_map;
 	const struct btf_member *member;
-	struct bpf_map *map, *targ_map;
 	const char *name, *mname;
 	Elf_Data *symbols;
 	unsigned int moff;

tools/testing/selftests/bpf/progs/bpf_iter_bpf_hash_map.c+15−0

@@ -47,7 +47,10 @@ int dump_bpf_hash_map(struct bpf_iter__bpf_map_elem *ctx) · 46 unmodified lines
47	__u32 seq_num = ctx->meta->seq_num;	47	__u32 seq_num = ctx->meta->seq_num;
48	struct bpf_map *map = ctx->map;	48	struct bpf_map *map = ctx->map;
49	struct key_t *key = ctx->key;	49	struct key_t *key = ctx->key;
		50	struct key_t tmp_key;
50	__u64 *val = ctx->value;	51	__u64 *val = ctx->value;
		52	__u64 tmp_val = 0;
		53	int ret;
51		54
52	if (in_test_mode) {	55	if (in_test_mode) {
53	/* test mode is used by selftests to	56	/* test mode is used by selftests to
@@ -61,6 +64,18 @@ int dump_bpf_hash_map(struct bpf_iter__bpf_map_elem *ctx) · 7 unmodified lines
61	if (key == (void )0 \|\| val == (void )0)	64	if (key == (void )0 \|\| val == (void )0)
62	return 0;	65	return 0;
63		66
		67	/* update the value and then delete the <key, value> pair.
		68	* it should not impact the existing 'val' which is still
		69	* accessible under rcu.
		70	*/
		71	__builtin_memcpy(&tmp_key, key, sizeof(struct key_t));
		72	ret = bpf_map_update_elem(&hashmap1, &tmp_key, &tmp_val, 0);
		73	if (ret)
		74	return 0;
		75	ret = bpf_map_delete_elem(&hashmap1, &tmp_key);
		76	if (ret)
		77	return 0;
		78
64	key_sum_a += key->a;	79	key_sum_a += key->a;
65	key_sum_b += key->b;	80	key_sum_b += key->b;
66	key_sum_c += key->c;	81	key_sum_c += key->c;

tools/testing/selftests/net/rtnetlink.sh+47−0

@@ -1175,6 +1175,51 @@ kci_test_neigh_get() · 1174 unmodified lines
1175	echo "PASS: neigh get"	1175	echo "PASS: neigh get"
1176	}	1176	}
1177		1177
		1178	kci_test_bridge_parent_id()
		1179	{
		1180	local ret=0
		1181	sysfsnet=/sys/bus/netdevsim/devices/netdevsim
		1182	probed=false
		1183
		1184	if [ ! -w /sys/bus/netdevsim/new_device ] ; then
		1185	modprobe -q netdevsim
		1186	check_err $?
		1187	if [ $ret -ne 0 ]; then
		1188	echo "SKIP: bridge_parent_id can't load netdevsim"
		1189	return $ksft_skip
		1190	fi
		1191	probed=true
		1192	fi
		1193
		1194	echo "10 1" > /sys/bus/netdevsim/new_device
		1195	while [ ! -d ${sysfsnet}10 ] ; do :; done
		1196	echo "20 1" > /sys/bus/netdevsim/new_device
		1197	while [ ! -d ${sysfsnet}20 ] ; do :; done
		1198	udevadm settle
		1199	dev10=`ls ${sysfsnet}10/net/`
		1200	dev20=`ls ${sysfsnet}20/net/`
		1201
		1202	ip link add name test-bond0 type bond mode 802.3ad
		1203	ip link set dev $dev10 master test-bond0
		1204	ip link set dev $dev20 master test-bond0
		1205	ip link add name test-br0 type bridge
		1206	ip link set dev test-bond0 master test-br0
		1207	check_err $?
		1208
		1209	# clean up any leftovers
		1210	ip link del dev test-br0
		1211	ip link del dev test-bond0
		1212	echo 20 > /sys/bus/netdevsim/del_device
		1213	echo 10 > /sys/bus/netdevsim/del_device
		1214	$probed && rmmod netdevsim
		1215
		1216	if [ $ret -ne 0 ]; then
		1217	echo "FAIL: bridge_parent_id"
		1218	return 1
		1219	fi
		1220	echo "PASS: bridge_parent_id"
		1221	}
		1222
1178	kci_test_rtnl()	1223	kci_test_rtnl()
1179	{	1224	{
1180	local ret=0	1225	local ret=0
@@ -1224,6 +1269,8 @@ kci_test_rtnl() · 43 unmodified lines
1224	check_err $?	1269	check_err $?
1225	kci_test_neigh_get	1270	kci_test_neigh_get
1226	check_err $?	1271	check_err $?
		1272	kci_test_bridge_parent_id
		1273	check_err $?
1227		1274
1228	kci_del_dummy	1275	kci_del_dummy
1229	return $ret	1276	return $ret

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -182,9 +182,6 @@ in the order of reservations, but only after all previous records where · 181 unmodified lines
182	already committed. It is thus possible for slow producers to temporarily hold	182	already committed. It is thus possible for slow producers to temporarily hold
183	off submitted records, that were reserved later.	183	off submitted records, that were reserved later.
184		184
185	Reservation/commit/consumer protocol is verified by litmus tests in
186	Documentation/litmus_tests/bpf-rb/_.
187
188	One interesting implementation bit, that significantly simplifies (and thus	185	One interesting implementation bit, that significantly simplifies (and thus
189	speeds up as well) implementation of both producers and consumers is how data	186	speeds up as well) implementation of both producers and consumers is how data
190	area is mapped twice contiguously back-to-back in the virtual memory. This	187	area is mapped twice contiguously back-to-back in the virtual memory. This
@@ -200,7 +197,7 @@ a self-pacing notifications of new data being availability. · 9 unmodified lines
200	being available after commit only if consumer has already caught up right up to	197	being available after commit only if consumer has already caught up right up to
201	the record being committed. If not, consumer still has to catch up and thus	198	the record being committed. If not, consumer still has to catch up and thus
202	will see new data anyways without needing an extra poll notification.	199	will see new data anyways without needing an extra poll notification.
203	Benchmarks (see tools/testing/selftests/bpf/benchs/bench_ringbuf.c_) show that	200	Benchmarks (see tools/testing/selftests/bpf/benchs/bench_ringbufs.c) show that
204	this allows to achieve a very high throughput without having to resort to	201	this allows to achieve a very high throughput without having to resort to
205	tricks like "notify only every Nth sample", which are necessary with perf	202	tricks like "notify only every Nth sample", which are necessary with perf
206	buffer. For extreme cases, when BPF program wants more manual control of	203	buffer. For extreme cases, when BPF program wants more manual control of