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

Pull networking fixes from Jakub Kicinski: "Including fixes from CAN, netfilter, wireguard and IPsec. I'd like to highlight [ lowlight? - Linus ] Florian W stepping down as a netfilter maintainer due to constant stream of bug reports. Not sure what we can do but IIUC this is not the first such case. Current release - regressions: - rxrpc: fix use of page_frag_alloc_align(), it changed semantics and we added a new caller in a different subtree - xfrm: allow UDP encapsulation only in offload modes Current release - new code bugs: - tcp: fix refcnt handling in __inet_hash_connect() - Revert "net: Re-use and set mono_delivery_time bit for userspace tstamp packets", conflicted with some expectations in BPF uAPI Previous releases - regressions: - ipv4: raw: fix sending packets from raw sockets via IPsec tunnels - devlink: fix devlink's parallel command processing - veth: do not manipulate GRO when using XDP - esp: fix bad handling of pages from page_pool Previous releases - always broken: - report RCU QS for busy network kthreads (with Paul McK's blessing) - tcp/rds: fix use-after-free on netns with kernel TCP reqsk - virt: vmxnet3: fix missing reserved tailroom with XDP Misc: - couple of build fixes for Documentation" * tag 'net-6.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (59 commits) selftests: forwarding: Fix ping failure due to short timeout MAINTAINERS: step down as netfilter maintainer netfilter: nf_tables: Fix a memory leak in nf_tables_updchain net: dsa: mt7530: fix handling of all link-local frames net: dsa: mt7530: fix link-local frames that ingress vlan filtering ports bpf: report RCU QS in cpumap kthread net: report RCU QS on threaded NAPI repolling rcu: add a helper to report consolidated flavor QS ionic: update documentation for XDP support lib/bitmap: Fix bitmap_scatter() and bitmap_gather() kernel doc netfilter: nf_tables: do not compare internal table flags on updates netfilter: nft_set_pipapo: release elements in clone only from destroy path octeontx2-af: Use separate handlers for interrupts octeontx2-pf: Send UP messages to VF only when VF is up. octeontx2-pf: Use default max_active works instead of one octeontx2-pf: Wait till detach_resources msg is complete octeontx2: Detect the mbox up or down message via register devlink: fix port new reply cmd type tcp: Clear req->syncookie in reqsk_alloc(). net/bnx2x: Prevent access to a freed page in page_pool ...

Linus Torvalds committed 2 years ago

Commit cba9ffd2 parents 1d35aae f99c5f571 files · +610 −346Browse files

Unified · Split

71 files

Documentation/networking/device_drivers/ethernet/pensando/ionic.rst +22 −0
Documentation/networking/multi-pf-netdev.rst +29 −29
Documentation/networking/net_cachelines/net_device.rst +1 −1
MAINTAINERS +0 −1
drivers/net/can/kvaser_pciefd.c +2 −2
drivers/net/dsa/mt7530.c +48 −18
drivers/net/dsa/mt7530.h +21 −1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h +3 −3
drivers/net/ethernet/marvell/octeontx2/af/cgx.c +1 −1
drivers/net/ethernet/marvell/octeontx2/af/mbox.c +41 −2
drivers/net/ethernet/marvell/octeontx2/af/mbox.h +6 −0
drivers/net/ethernet/marvell/octeontx2/af/mcs_rvu_if.c +11 −6
drivers/net/ethernet/marvell/octeontx2/af/rvu.c +25 −6
drivers/net/ethernet/marvell/octeontx2/af/rvu.h +2 −0
drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c +13 −7
drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.c +1 −1
drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h +1 −1
drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c +82 −37
drivers/net/ethernet/marvell/octeontx2/nic/otx2_vf.c +43 −28
drivers/net/ethernet/mediatek/mtk_eth_soc.c +3 −4
drivers/net/ethernet/mediatek/mtk_ppe.c +11 −7
drivers/net/ethernet/wangxun/txgbe/txgbe_phy.c +1 −1
drivers/net/phy/phy_device.c +2 −2
drivers/net/veth.c +0 −18
drivers/net/vmxnet3/vmxnet3_xdp.c +3 −3
drivers/net/wan/fsl_qmc_hdlc.c +1 −1
drivers/net/wireguard/device.c +2 −9
drivers/net/wireguard/netlink.c +5 −5
drivers/net/wireguard/receive.c +3 −3
drivers/soc/fsl/qbman/qman.c +14 −11
include/linux/bitmap.h +23 −21
include/linux/netdevice.h +1 −1
include/linux/rcupdate.h +31 −0
include/linux/skbuff.h +13 −3
include/linux/socket.h +0 −7
include/net/request_sock.h +6 −1
kernel/bpf/cpumap.c +3 −0
net/core/dev.c +6 −2
net/devlink/netlink.c +7 −6
net/devlink/port.c +1 −1
net/hsr/hsr_framereg.c +4 −0
net/hsr/hsr_main.c +11 −4
net/ipv4/esp4.c +4 −4
net/ipv4/inet_hashtables.c +1 −1
net/ipv4/inet_timewait_sock.c +19 −22
net/ipv4/ip_output.c +0 −1
net/ipv4/raw.c +1 −1
net/ipv4/syncookies.c +3 −0
net/ipv4/tcp_minisocks.c +0 −4
net/ipv6/esp6.c +4 −4
net/ipv6/ip6_output.c +1 −1
net/ipv6/raw.c +1 −1
net/ipv6/syncookies.c +3 −0
net/netfilter/nf_tables_api.c +15 −14
net/netfilter/nft_set_pipapo.c +1 −4
net/packet/af_packet.c +3 −5
net/rds/send.c +2 −3
net/rxrpc/sendmsg.c +2 −2
net/rxrpc/txbuf.c +2 −2
net/sched/sch_fq_pie.c +2 −0
net/sched/sch_taprio.c +2 −1
net/socket.c +7 −7
net/xfrm/xfrm_device.c +2 −1
tools/net/ynl/Makefile.deps +1 −0
tools/perf/trace/beauty/include/linux/socket.h +0 −7
tools/testing/selftests/net/forwarding/vxlan_bridge_1d_ipv6.sh +2 −2
tools/testing/selftests/net/forwarding/vxlan_bridge_1q_ipv6.sh +2 −2
tools/testing/selftests/net/udpgro_fwd.sh +4 −0
tools/testing/selftests/net/veth.sh +21 −3
tools/testing/selftests/wireguard/qemu/arch/riscv32.config +1 −0
tools/testing/selftests/wireguard/qemu/arch/riscv64.config +1 −0

Documentation/networking/device_drivers/ethernet/pensando/ionic.rst+22−0

 the sysfs 'sriov_numvfs' value, if supported by your particular firmware
 configuration.
+XDP
+---
+Support for XDP includes the basics, plus Jumbo frames, Redirect and
+ndo_xmit.  There is no current support for zero-copy sockets or HW offload.
 Statistics
 ==========
      rx_csum_none: 0
      rx_csum_complete: 3
      rx_csum_error: 0
+     xdp_drop: 0
+     xdp_aborted: 0
+     xdp_pass: 0
+     xdp_tx: 0
+     xdp_redirect: 0
+     xdp_frames: 0
 Driver queue specific::
      tx_0_frags: 0
      tx_0_tso: 0
      tx_0_tso_bytes: 0
+     tx_0_hwstamp_valid: 0
+     tx_0_hwstamp_invalid: 0
      tx_0_csum_none: 3
      tx_0_csum: 0
      tx_0_vlan_inserted: 0
+     tx_0_xdp_frames: 0
      rx_0_pkts: 2
      rx_0_bytes: 120
      rx_0_dma_map_err: 0
      rx_0_csum_none: 0
      rx_0_csum_complete: 0
      rx_0_csum_error: 0
+     rx_0_hwstamp_valid: 0
+     rx_0_hwstamp_invalid: 0
      rx_0_dropped: 0
      rx_0_vlan_stripped: 0
+     rx_0_xdp_drop: 0
+     rx_0_xdp_aborted: 0
+     rx_0_xdp_pass: 0
+     rx_0_xdp_tx: 0
+     rx_0_xdp_redirect: 0
 Firmware port specific::

Documentation/networking/multi-pf-netdev.rst+29−29

Documentation/networking/net_cachelines/net_device.rst+1−1

@@ -13,7 +13,7 @@ struct_dev_ifalias* ifalias · 12 unmodified lines
13	unsigned_long mem_end	13	unsigned_long mem_end
14	unsigned_long mem_start	14	unsigned_long mem_start
15	unsigned_long base_addr	15	unsigned_long base_addr
16	unsigned_long state	16	unsigned_long state read_mostly read_mostly netif_running(dev)
17	struct_list_head dev_list	17	struct_list_head dev_list
18	struct_list_head napi_list	18	struct_list_head napi_list
19	struct_list_head unreg_list	19	struct_list_head unreg_list

MAINTAINERS+0−1

@@ -15237,7 +15237,6 @@ F: drivers/net/ethernet/neterion/ · 15236 unmodified lines
15237	NETFILTER	15237	NETFILTER
15238	M: Pablo Neira Ayuso <pablo@netfilter.org>	15238	M: Pablo Neira Ayuso <pablo@netfilter.org>
15239	M: Jozsef Kadlecsik <kadlec@netfilter.org>	15239	M: Jozsef Kadlecsik <kadlec@netfilter.org>
15240	M: Florian Westphal <fw@strlen.de>
15241	L: netfilter-devel@vger.kernel.org	15240	L: netfilter-devel@vger.kernel.org
15242	L: coreteam@netfilter.org	15241	L: coreteam@netfilter.org
15243	S: Maintained	15242	S: Maintained

drivers/net/can/kvaser_pciefd.c+2−2

@@ -370,8 +370,8 @@ static const struct kvaser_pciefd_irq_mask kvaser_pciefd_sf2_irq_mask = { · 369 unmodified lines
370		370
371	static const struct kvaser_pciefd_irq_mask kvaser_pciefd_xilinx_irq_mask = {	371	static const struct kvaser_pciefd_irq_mask kvaser_pciefd_xilinx_irq_mask = {
372	.kcan_rx0 = BIT(4),	372	.kcan_rx0 = BIT(4),
373	.kcan_tx = { BIT(16), BIT(17), BIT(18), BIT(19) },	373	.kcan_tx = { BIT(16), BIT(17), BIT(18), BIT(19), BIT(20), BIT(21), BIT(22), BIT(23) },
374	.all = GENMASK(19, 16) \| BIT(4),	374	.all = GENMASK(23, 16) \| BIT(4),
375	};	375	};
376		376
377	static const struct kvaser_pciefd_dev_ops kvaser_pciefd_altera_dev_ops = {	377	static const struct kvaser_pciefd_dev_ops kvaser_pciefd_altera_dev_ops = {

drivers/net/dsa/mt7530.c+48−18

 	mutex_unlock(&priv->reg_mutex);
 }
+/* On page 205, section "8.6.3 Frame filtering" of the active standard, IEEE Std
+ * 802.1Q™-2022, it is stated that frames with 01:80:C2:00:00:00-0F as MAC DA
+ * must only be propagated to C-VLAN and MAC Bridge components. That means
+ * VLAN-aware and VLAN-unaware bridges. On the switch designs with CPU ports,
+ * these frames are supposed to be processed by the CPU (software). So we make
+ * the switch only forward them to the CPU port. And if received from a CPU
+ * port, forward to a single port. The software is responsible of making the
+ * switch conform to the latter by setting a single port as destination port on
+ * the special tag.
+ *
+ * This switch intellectual property cannot conform to this part of the standard
+ * fully. Whilst the REV_UN frame tag covers the remaining :04-0D and :0F MAC
+ * DAs, it also includes :22-FF which the scope of propagation is not supposed
+ * to be restricted for these MAC DAs.
+ */
 static void
 mt753x_trap_frames(struct mt7530_priv *priv)
 {
-	/* Trap BPDUs to the CPU port(s) */
+	/* Trap 802.1X PAE frames and BPDUs to the CPU port(s) and egress them
-	mt7530_rmw(priv, MT753X_BPC, MT753X_BPDU_PORT_FW_MASK,
+	 * VLAN-untagged.
+	 */
+	mt7530_rmw(priv, MT753X_BPC, MT753X_PAE_EG_TAG_MASK |
+		   MT753X_PAE_PORT_FW_MASK | MT753X_BPDU_EG_TAG_MASK |
+		   MT753X_BPDU_PORT_FW_MASK,
+		   MT753X_PAE_EG_TAG(MT7530_VLAN_EG_UNTAGGED) |
+		   MT753X_PAE_PORT_FW(MT753X_BPDU_CPU_ONLY) |
+		   MT753X_BPDU_EG_TAG(MT7530_VLAN_EG_UNTAGGED) |
 		   MT753X_BPDU_CPU_ONLY);
-	/* Trap 802.1X PAE frames to the CPU port(s) */
+	/* Trap frames with :01 and :02 MAC DAs to the CPU port(s) and egress
-	mt7530_rmw(priv, MT753X_BPC, MT753X_PAE_PORT_FW_MASK,
+	 * them VLAN-untagged.
-		   MT753X_PAE_PORT_FW(MT753X_BPDU_CPU_ONLY));
+	 */
+	mt7530_rmw(priv, MT753X_RGAC1, MT753X_R02_EG_TAG_MASK |
+		   MT753X_R02_PORT_FW_MASK | MT753X_R01_EG_TAG_MASK |
+		   MT753X_R01_PORT_FW_MASK,
+		   MT753X_R02_EG_TAG(MT7530_VLAN_EG_UNTAGGED) |
+		   MT753X_R02_PORT_FW(MT753X_BPDU_CPU_ONLY) |
+		   MT753X_R01_EG_TAG(MT7530_VLAN_EG_UNTAGGED) |
+		   MT753X_BPDU_CPU_ONLY);
-	/* Trap LLDP frames with :0E MAC DA to the CPU port(s) */
+	/* Trap frames with :03 and :0E MAC DAs to the CPU port(s) and egress
-	mt7530_rmw(priv, MT753X_RGAC2, MT753X_R0E_PORT_FW_MASK,
+	 * them VLAN-untagged.
-		   MT753X_R0E_PORT_FW(MT753X_BPDU_CPU_ONLY));
+	 */
+	mt7530_rmw(priv, MT753X_RGAC2, MT753X_R0E_EG_TAG_MASK |
+		   MT753X_R0E_PORT_FW_MASK | MT753X_R03_EG_TAG_MASK |
+		   MT753X_R03_PORT_FW_MASK,
+		   MT753X_R0E_EG_TAG(MT7530_VLAN_EG_UNTAGGED) |
+		   MT753X_R0E_PORT_FW(MT753X_BPDU_CPU_ONLY) |
+		   MT753X_R03_EG_TAG(MT7530_VLAN_EG_UNTAGGED) |
+		   MT753X_BPDU_CPU_ONLY);
 }
 static void
 		}
 	}
-	/* Disable LEDs before reset to prevent the MT7530 sampling a
-	 * potentially incorrect HT_XTAL_FSEL value.
-	 */
-	mt7530_write(priv, MT7530_LED_EN, 0);
-	usleep_range(1000, 1100);
 	/* Reset whole chip through gpio pin or memory-mapped registers for
 	 * different type of hardware
 	 */
 	if (priv->mcm) {
 		reset_control_assert(priv->rstc);
-		usleep_range(1000, 1100);
+		usleep_range(5000, 5100);
 		reset_control_deassert(priv->rstc);
 	} else {
 		gpiod_set_value_cansleep(priv->reset, 0);
-		usleep_range(1000, 1100);
+		usleep_range(5000, 5100);
 		gpiod_set_value_cansleep(priv->reset, 1);
 	}
 	 */
 	if (priv->mcm) {
 		reset_control_assert(priv->rstc);
-		usleep_range(1000, 1100);
+		usleep_range(5000, 5100);
 		reset_control_deassert(priv->rstc);
 	} else {
 		gpiod_set_value_cansleep(priv->reset, 0);
-		usleep_range(1000, 1100);
+		usleep_range(5000, 5100);
 		gpiod_set_value_cansleep(priv->reset, 1);
 	}

drivers/net/dsa/mt7530.h+21−1

 /* Registers for BPDU and PAE frame control*/
 #define MT753X_BPC			0x24
-#define  MT753X_BPDU_PORT_FW_MASK	GENMASK(2, 0)
+#define  MT753X_PAE_EG_TAG_MASK		GENMASK(24, 22)
+#define  MT753X_PAE_EG_TAG(x)		FIELD_PREP(MT753X_PAE_EG_TAG_MASK, x)
 #define  MT753X_PAE_PORT_FW_MASK	GENMASK(18, 16)
 #define  MT753X_PAE_PORT_FW(x)		FIELD_PREP(MT753X_PAE_PORT_FW_MASK, x)
+#define  MT753X_BPDU_EG_TAG_MASK	GENMASK(8, 6)
+#define  MT753X_BPDU_EG_TAG(x)		FIELD_PREP(MT753X_BPDU_EG_TAG_MASK, x)
+#define  MT753X_BPDU_PORT_FW_MASK	GENMASK(2, 0)
+/* Register for :01 and :02 MAC DA frame control */
+#define MT753X_RGAC1			0x28
+#define  MT753X_R02_EG_TAG_MASK		GENMASK(24, 22)
+#define  MT753X_R02_EG_TAG(x)		FIELD_PREP(MT753X_R02_EG_TAG_MASK, x)
+#define  MT753X_R02_PORT_FW_MASK	GENMASK(18, 16)
+#define  MT753X_R02_PORT_FW(x)		FIELD_PREP(MT753X_R02_PORT_FW_MASK, x)
+#define  MT753X_R01_EG_TAG_MASK		GENMASK(8, 6)
+#define  MT753X_R01_EG_TAG(x)		FIELD_PREP(MT753X_R01_EG_TAG_MASK, x)
+#define  MT753X_R01_PORT_FW_MASK	GENMASK(2, 0)
 /* Register for :03 and :0E MAC DA frame control */
 #define MT753X_RGAC2			0x2c
+#define  MT753X_R0E_EG_TAG_MASK		GENMASK(24, 22)
+#define  MT753X_R0E_EG_TAG(x)		FIELD_PREP(MT753X_R0E_EG_TAG_MASK, x)
 #define  MT753X_R0E_PORT_FW_MASK	GENMASK(18, 16)
 #define  MT753X_R0E_PORT_FW(x)		FIELD_PREP(MT753X_R0E_PORT_FW_MASK, x)
+#define  MT753X_R03_EG_TAG_MASK		GENMASK(8, 6)
+#define  MT753X_R03_EG_TAG(x)		FIELD_PREP(MT753X_R03_EG_TAG_MASK, x)
+#define  MT753X_R03_PORT_FW_MASK	GENMASK(2, 0)
 enum mt753x_bpdu_port_fw {
 	MT753X_BPDU_FOLLOW_MFC,
 enum mt7530_vlan_port_eg_tag {
 	MT7530_VLAN_EG_DISABLED = 0,
 	MT7530_VLAN_EG_CONSISTENT = 1,
+	MT7530_VLAN_EG_UNTAGGED = 4,
 };
 enum mt7530_vlan_port_attr {

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h+3−3

 static inline void bnx2x_free_rx_mem_pool(struct bnx2x *bp,
 					  struct bnx2x_alloc_pool *pool)
 {
-	if (!pool->page)
-		return;
 	put_page(pool->page);
 	pool->page = NULL;
 {
 	int i;
+	if (!fp->page_pool.page)
+		return;
 	if (fp->mode == TPA_MODE_DISABLED)
 		return;

drivers/net/ethernet/marvell/octeontx2/af/cgx.c+1−1

@@ -1338,7 +1338,7 @@ static irqreturn_t cgx_fwi_event_handler(int irq, void *data) · 1337 unmodified lines
1338		1338
1339	/* Release thread waiting for completion */	1339	/* Release thread waiting for completion */
1340	lmac->cmd_pend = false;	1340	lmac->cmd_pend = false;
1341	wake_up_interruptible(&lmac->wq_cmd_cmplt);	1341	wake_up(&lmac->wq_cmd_cmplt);
1342	break;	1342	break;
1343	case CGX_EVT_ASYNC:	1343	case CGX_EVT_ASYNC:
1344	if (cgx_event_is_linkevent(event))	1344	if (cgx_event_is_linkevent(event))

drivers/net/ethernet/marvell/octeontx2/af/mbox.c+41−2

@@ -214,11 +214,12 @@ int otx2_mbox_busy_poll_for_rsp(struct otx2_mbox *mbox, int devid) · 213 unmodified lines
214	}	214	}
215	EXPORT_SYMBOL(otx2_mbox_busy_poll_for_rsp);	215	EXPORT_SYMBOL(otx2_mbox_busy_poll_for_rsp);
216		216
217	void otx2_mbox_msg_send(struct otx2_mbox *mbox, int devid)	217	static void otx2_mbox_msg_send_data(struct otx2_mbox *mbox, int devid, u64 data)
218	{	218	{
219	struct otx2_mbox_dev *mdev = &mbox->dev[devid];	219	struct otx2_mbox_dev *mdev = &mbox->dev[devid];
220	struct mbox_hdr tx_hdr, rx_hdr;	220	struct mbox_hdr tx_hdr, rx_hdr;
221	void *hw_mbase = mdev->hwbase;	221	void *hw_mbase = mdev->hwbase;
		222	u64 intr_val;
222		223
223	tx_hdr = hw_mbase + mbox->tx_start;	224	tx_hdr = hw_mbase + mbox->tx_start;
224	rx_hdr = hw_mbase + mbox->rx_start;	225	rx_hdr = hw_mbase + mbox->rx_start;
@@ -254,14 +255,52 @@ void otx2_mbox_msg_send(struct otx2_mbox *mbox, int devid) · 29 unmodified lines
254		255
255	spin_unlock(&mdev->mbox_lock);	256	spin_unlock(&mdev->mbox_lock);
256		257
		258	/* Check if interrupt pending */
		259	intr_val = readq((void __iomem *)mbox->reg_base +
		260	(mbox->trigger \| (devid << mbox->tr_shift)));
		261
		262	intr_val \|= data;
257	/* The interrupt should be fired after num_msgs is written	263	/* The interrupt should be fired after num_msgs is written
258	* to the shared memory	264	* to the shared memory
259	*/	265	*/
260	writeq(1, (void __iomem *)mbox->reg_base +	266	writeq(intr_val, (void __iomem *)mbox->reg_base +
261	(mbox->trigger \| (devid << mbox->tr_shift)));	267	(mbox->trigger \| (devid << mbox->tr_shift)));
262	}	268	}
		269
		270	void otx2_mbox_msg_send(struct otx2_mbox *mbox, int devid)
		271	{
		272	otx2_mbox_msg_send_data(mbox, devid, MBOX_DOWN_MSG);
		273	}
263	EXPORT_SYMBOL(otx2_mbox_msg_send);	274	EXPORT_SYMBOL(otx2_mbox_msg_send);
264		275
		276	void otx2_mbox_msg_send_up(struct otx2_mbox *mbox, int devid)
		277	{
		278	otx2_mbox_msg_send_data(mbox, devid, MBOX_UP_MSG);
		279	}
		280	EXPORT_SYMBOL(otx2_mbox_msg_send_up);
		281
		282	bool otx2_mbox_wait_for_zero(struct otx2_mbox *mbox, int devid)
		283	{
		284	u64 data;
		285
		286	data = readq((void __iomem *)mbox->reg_base +
		287	(mbox->trigger \| (devid << mbox->tr_shift)));
		288
		289	/* If data is non-zero wait for ~1ms and return to caller
		290	* whether data has changed to zero or not after the wait.
		291	*/
		292	if (!data)
		293	return true;
		294
		295	usleep_range(950, 1000);
		296
		297	data = readq((void __iomem *)mbox->reg_base +
		298	(mbox->trigger \| (devid << mbox->tr_shift)));
		299
		300	return data == 0;
		301	}
		302	EXPORT_SYMBOL(otx2_mbox_wait_for_zero);
		303
265	struct mbox_msghdr otx2_mbox_alloc_msg_rsp(struct otx2_mbox mbox, int devid,	304	struct mbox_msghdr otx2_mbox_alloc_msg_rsp(struct otx2_mbox mbox, int devid,
266	int size, int size_rsp)	305	int size, int size_rsp)
267	{	306	{

drivers/net/ethernet/marvell/octeontx2/af/mbox.h+6−0

 #define MBOX_SIZE		SZ_64K
+#define MBOX_DOWN_MSG		1
+#define MBOX_UP_MSG		2
 /* AF/PF: PF initiated, PF/VF VF initiated */
 #define MBOX_DOWN_RX_START	0
 #define MBOX_DOWN_RX_SIZE	(46 * SZ_1K)
 			   struct pci_dev *pdev, void __force *reg_base,
 			   int direction, int ndevs, unsigned long *bmap);
 void otx2_mbox_msg_send(struct otx2_mbox *mbox, int devid);
+void otx2_mbox_msg_send_up(struct otx2_mbox *mbox, int devid);
 int otx2_mbox_wait_for_rsp(struct otx2_mbox *mbox, int devid);
 int otx2_mbox_busy_poll_for_rsp(struct otx2_mbox *mbox, int devid);
 struct mbox_msghdr *otx2_mbox_alloc_msg_rsp(struct otx2_mbox *mbox, int devid,
 	return otx2_mbox_alloc_msg_rsp(mbox, devid, size, 0);
 }
+bool otx2_mbox_wait_for_zero(struct otx2_mbox *mbox, int devid);
 /* Mailbox message types */
 #define MBOX_MSG_MASK				0xFFFF
 #define MBOX_MSG_INVALID			0xFFFE

drivers/net/ethernet/marvell/octeontx2/af/mcs_rvu_if.c+11−6

@@ -121,13 +121,17 @@ int mcs_add_intr_wq_entry(struct mcs mcs, struct mcs_intr_event event) · 120 unmodified lines
121	static int mcs_notify_pfvf(struct mcs_intr_event event, struct rvu rvu)	121	static int mcs_notify_pfvf(struct mcs_intr_event event, struct rvu rvu)
122	{	122	{
123	struct mcs_intr_info *req;	123	struct mcs_intr_info *req;
124	int err, pf;	124	int pf;
125		125
126	pf = rvu_get_pf(event->pcifunc);	126	pf = rvu_get_pf(event->pcifunc);
127		127
		128	mutex_lock(&rvu->mbox_lock);
		129
128	req = otx2_mbox_alloc_msg_mcs_intr_notify(rvu, pf);	130	req = otx2_mbox_alloc_msg_mcs_intr_notify(rvu, pf);
129	if (!req)	131	if (!req) {
		132	mutex_unlock(&rvu->mbox_lock);
130	return -ENOMEM;	133	return -ENOMEM;
		134	}
131		135
132	req->mcs_id = event->mcs_id;	136	req->mcs_id = event->mcs_id;
133	req->intr_mask = event->intr_mask;	137	req->intr_mask = event->intr_mask;
@@ -135,10 +139,11 @@ static int mcs_notify_pfvf(struct mcs_intr_event event, struct rvu rvu) · 1 unmodified line
135	req->hdr.pcifunc = event->pcifunc;	139	req->hdr.pcifunc = event->pcifunc;
136	req->lmac_id = event->lmac_id;	140	req->lmac_id = event->lmac_id;
137		141
138	otx2_mbox_msg_send(&rvu->afpf_wq_info.mbox_up, pf);	142	otx2_mbox_wait_for_zero(&rvu->afpf_wq_info.mbox_up, pf);
139	err = otx2_mbox_wait_for_rsp(&rvu->afpf_wq_info.mbox_up, pf);	143
140	if (err)	144	otx2_mbox_msg_send_up(&rvu->afpf_wq_info.mbox_up, pf);
141	dev_warn(rvu->dev, "MCS notification to pf %d failed\n", pf);	145
		146	mutex_unlock(&rvu->mbox_lock);
142		147
143	return 0;	148	return 0;
144	}	149	}

drivers/net/ethernet/marvell/octeontx2/af/rvu.c+25−6

 	}
 }
-static void __rvu_mbox_handler(struct rvu_work *mwork, int type)
+static void __rvu_mbox_handler(struct rvu_work *mwork, int type, bool poll)
 {
 	struct rvu *rvu = mwork->rvu;
 	int offset, err, id, devid;
 	}
 	mw->mbox_wrk[devid].num_msgs = 0;
+	if (poll)
+		otx2_mbox_wait_for_zero(mbox, devid);
 	/* Send mbox responses to VF/PF */
 	otx2_mbox_msg_send(mbox, devid);
 }
 static inline void rvu_afpf_mbox_handler(struct work_struct *work)
 {
 	struct rvu_work *mwork = container_of(work, struct rvu_work, work);
+	struct rvu *rvu = mwork->rvu;
-	__rvu_mbox_handler(mwork, TYPE_AFPF);
+	mutex_lock(&rvu->mbox_lock);
+	__rvu_mbox_handler(mwork, TYPE_AFPF, true);
+	mutex_unlock(&rvu->mbox_lock);
 }
 static inline void rvu_afvf_mbox_handler(struct work_struct *work)
 {
 	struct rvu_work *mwork = container_of(work, struct rvu_work, work);
-	__rvu_mbox_handler(mwork, TYPE_AFVF);
+	__rvu_mbox_handler(mwork, TYPE_AFVF, false);
 }
 static void __rvu_mbox_up_handler(struct rvu_work *mwork, int type)
 		}
 	}
+	mutex_init(&rvu->mbox_lock);
 	mbox_regions = kcalloc(num, sizeof(void *), GFP_KERNEL);
 	if (!mbox_regions) {
 		err = -ENOMEM;
 	}
 }
-static irqreturn_t rvu_mbox_intr_handler(int irq, void *rvu_irq)
+static irqreturn_t rvu_mbox_pf_intr_handler(int irq, void *rvu_irq)
 {
 	struct rvu *rvu = (struct rvu *)rvu_irq;
-	int vfs = rvu->vfs;
 	u64 intr;
 	intr = rvu_read64(rvu, BLKADDR_RVUM, RVU_AF_PFAF_MBOX_INT);
 	rvu_queue_work(&rvu->afpf_wq_info, 0, rvu->hw->total_pfs, intr);
+	return IRQ_HANDLED;
+}
+static irqreturn_t rvu_mbox_intr_handler(int irq, void *rvu_irq)
+{
+	struct rvu *rvu = (struct rvu *)rvu_irq;
+	int vfs = rvu->vfs;
+	u64 intr;
+	/* Sync with mbox memory region */
+	rmb();
 	/* Handle VF interrupts */
 	if (vfs > 64) {
 		intr = rvupf_read64(rvu, RVU_PF_VFPF_MBOX_INTX(1));
 	/* Register mailbox interrupt handler */
 	sprintf(&rvu->irq_name[RVU_AF_INT_VEC_MBOX * NAME_SIZE], "RVUAF Mbox");
 	ret = request_irq(pci_irq_vector(rvu->pdev, RVU_AF_INT_VEC_MBOX),
-			  rvu_mbox_intr_handler, 0,
+			  rvu_mbox_pf_intr_handler, 0,
 			  &rvu->irq_name[RVU_AF_INT_VEC_MBOX * NAME_SIZE], rvu);
 	if (ret) {
 		dev_err(rvu->dev,

drivers/net/ethernet/marvell/octeontx2/af/rvu.h+2−0

@@ -591,6 +591,8 @@ struct rvu { · 590 unmodified lines
591	spinlock_t mcs_intrq_lock;	591	spinlock_t mcs_intrq_lock;
592	/* CPT interrupt lock */	592	/* CPT interrupt lock */
593	spinlock_t cpt_intr_lock;	593	spinlock_t cpt_intr_lock;
		594
		595	struct mutex mbox_lock; /* Serialize mbox up and down msgs */
594	};	596	};
595		597
596	static inline void rvu_write64(struct rvu *rvu, u64 block, u64 offset, u64 val)	598	static inline void rvu_write64(struct rvu *rvu, u64 block, u64 offset, u64 val)

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c+13−7

@@ -232,7 +232,7 @@ static void cgx_notify_pfs(struct cgx_link_event event, struct rvu rvu) · 231 unmodified lines
232	struct cgx_link_user_info *linfo;	232	struct cgx_link_user_info *linfo;
233	struct cgx_link_info_msg *msg;	233	struct cgx_link_info_msg *msg;
234	unsigned long pfmap;	234	unsigned long pfmap;
235	int err, pfid;	235	int pfid;
236		236
237	linfo = &event->link_uinfo;	237	linfo = &event->link_uinfo;
238	pfmap = cgxlmac_to_pfmap(rvu, event->cgx_id, event->lmac_id);	238	pfmap = cgxlmac_to_pfmap(rvu, event->cgx_id, event->lmac_id);
@@ -255,16 +255,22 @@ static void cgx_notify_pfs(struct cgx_link_event event, struct rvu rvu) · 16 unmodified lines
255	continue;	255	continue;
256	}	256	}
257		257
		258	mutex_lock(&rvu->mbox_lock);
		259
258	/* Send mbox message to PF */	260	/* Send mbox message to PF */
259	msg = otx2_mbox_alloc_msg_cgx_link_event(rvu, pfid);	261	msg = otx2_mbox_alloc_msg_cgx_link_event(rvu, pfid);
260	if (!msg)	262	if (!msg) {
		263	mutex_unlock(&rvu->mbox_lock);
261	continue;	264	continue;
		265	}
		266
262	msg->link_info = *linfo;	267	msg->link_info = *linfo;
263	otx2_mbox_msg_send(&rvu->afpf_wq_info.mbox_up, pfid);	268
264	err = otx2_mbox_wait_for_rsp(&rvu->afpf_wq_info.mbox_up, pfid);	269	otx2_mbox_wait_for_zero(&rvu->afpf_wq_info.mbox_up, pfid);
265	if (err)	270
266	dev_warn(rvu->dev, "notification to pf %d failed\n",	271	otx2_mbox_msg_send_up(&rvu->afpf_wq_info.mbox_up, pfid);
267	pfid);	272
		273	mutex_unlock(&rvu->mbox_lock);
268	} while (pfmap);	274	} while (pfmap);
269	}	275	}
270		276

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.c+1−1

@@ -1592,7 +1592,7 @@ int otx2_detach_resources(struct mbox *mbox) · 1591 unmodified lines
1592	detach->partial = false;	1592	detach->partial = false;
1593		1593
1594	/* Send detach request to AF */	1594	/* Send detach request to AF */
1595	otx2_mbox_msg_send(&mbox->mbox, 0);	1595	otx2_sync_mbox_msg(mbox);
1596	mutex_unlock(&mbox->lock);	1596	mutex_unlock(&mbox->lock);
1597	return 0;	1597	return 0;
1598	}	1598	}

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.h+1−1

@@ -815,7 +815,7 @@ static inline int otx2_sync_mbox_up_msg(struct mbox *mbox, int devid) · 814 unmodified lines
815		815
816	if (!otx2_mbox_nonempty(&mbox->mbox_up, devid))	816	if (!otx2_mbox_nonempty(&mbox->mbox_up, devid))
817	return 0;	817	return 0;
818	otx2_mbox_msg_send(&mbox->mbox_up, devid);	818	otx2_mbox_msg_send_up(&mbox->mbox_up, devid);
819	err = otx2_mbox_wait_for_rsp(&mbox->mbox_up, devid);	819	err = otx2_mbox_wait_for_rsp(&mbox->mbox_up, devid);
820	if (err)	820	if (err)
821	return err;	821	return err;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c+82−37

 	return 0;
 }
-static void otx2_queue_work(struct mbox *mw, struct workqueue_struct *mbox_wq,
+static void otx2_queue_vf_work(struct mbox *mw, struct workqueue_struct *mbox_wq,
-			    int first, int mdevs, u64 intr, int type)
+			       int first, int mdevs, u64 intr)
 {
 	struct otx2_mbox_dev *mdev;
 	struct otx2_mbox *mbox;
 		mbox = &mw->mbox;
 		mdev = &mbox->dev[i];
-		if (type == TYPE_PFAF)
-			otx2_sync_mbox_bbuf(mbox, i);
 		hdr = mdev->mbase + mbox->rx_start;
 		/* The hdr->num_msgs is set to zero immediately in the interrupt
-		 * handler to  ensure that it holds a correct value next time
+		 * handler to ensure that it holds a correct value next time
-		 * when the interrupt handler is called.
+		 * when the interrupt handler is called. pf->mw[i].num_msgs
-		 * pf->mbox.num_msgs holds the data for use in pfaf_mbox_handler
+		 * holds the data for use in otx2_pfvf_mbox_handler and
-		 * pf>mbox.up_num_msgs holds the data for use in
+		 * pf->mw[i].up_num_msgs holds the data for use in
-		 * pfaf_mbox_up_handler.
+		 * otx2_pfvf_mbox_up_handler.
 		 */
 		if (hdr->num_msgs) {
 			mw[i].num_msgs = hdr->num_msgs;
 			hdr->num_msgs = 0;
-			if (type == TYPE_PFAF)
-				memset(mbox->hwbase + mbox->rx_start, 0,
-				       ALIGN(sizeof(struct mbox_hdr),
-					     sizeof(u64)));
 			queue_work(mbox_wq, &mw[i].mbox_wrk);
 		}
 		mbox = &mw->mbox_up;
 		mdev = &mbox->dev[i];
-		if (type == TYPE_PFAF)
-			otx2_sync_mbox_bbuf(mbox, i);
 		hdr = mdev->mbase + mbox->rx_start;
 		if (hdr->num_msgs) {
 			mw[i].up_num_msgs = hdr->num_msgs;
 			hdr->num_msgs = 0;
-			if (type == TYPE_PFAF)
-				memset(mbox->hwbase + mbox->rx_start, 0,
-				       ALIGN(sizeof(struct mbox_hdr),
-					     sizeof(u64)));
 			queue_work(mbox_wq, &mw[i].mbox_up_wrk);
 		}
 	}
 	/* Msgs are already copied, trigger VF's mbox irq */
 	smp_wmb();
+	otx2_mbox_wait_for_zero(pfvf_mbox, devid);
 	offset = pfvf_mbox->trigger | (devid << pfvf_mbox->tr_shift);
-	writeq(1, (void __iomem *)pfvf_mbox->reg_base + offset);
+	writeq(MBOX_DOWN_MSG, (void __iomem *)pfvf_mbox->reg_base + offset);
 	/* Restore VF's mbox bounce buffer region address */
 	src_mdev->mbase = bbuf_base;
 end:
 		offset = mbox->rx_start + msg->next_msgoff;
 		if (mdev->msgs_acked == (vf_mbox->up_num_msgs - 1))
-			__otx2_mbox_reset(mbox, 0);
+			__otx2_mbox_reset(mbox, vf_idx);
 		mdev->msgs_acked++;
 	}
 }
 	if (vfs > 64) {
 		intr = otx2_read64(pf, RVU_PF_VFPF_MBOX_INTX(1));
 		otx2_write64(pf, RVU_PF_VFPF_MBOX_INTX(1), intr);
-		otx2_queue_work(mbox, pf->mbox_pfvf_wq, 64, vfs, intr,
+		otx2_queue_vf_work(mbox, pf->mbox_pfvf_wq, 64, vfs, intr);
-				TYPE_PFVF);
 		if (intr)
 			trace_otx2_msg_interrupt(mbox->mbox.pdev, "VF(s) to PF", intr);
 		vfs = 64;
 	intr = otx2_read64(pf, RVU_PF_VFPF_MBOX_INTX(0));
 	otx2_write64(pf, RVU_PF_VFPF_MBOX_INTX(0), intr);
-	otx2_queue_work(mbox, pf->mbox_pfvf_wq, 0, vfs, intr, TYPE_PFVF);
+	otx2_queue_vf_work(mbox, pf->mbox_pfvf_wq, 0, vfs, intr);
 	if (intr)
 		trace_otx2_msg_interrupt(mbox->mbox.pdev, "VF(s) to PF", intr);
 	if (!pf->mbox_pfvf)
 		return -ENOMEM;
-	pf->mbox_pfvf_wq = alloc_ordered_workqueue("otx2_pfvf_mailbox",
+	pf->mbox_pfvf_wq = alloc_workqueue("otx2_pfvf_mailbox",
-						   WQ_HIGHPRI | WQ_MEM_RECLAIM);
+					   WQ_UNBOUND | WQ_HIGHPRI |
+					   WQ_MEM_RECLAIM, 0);
 	if (!pf->mbox_pfvf_wq)
 		return -ENOMEM;
 	struct mbox *af_mbox;
 	struct otx2_nic *pf;
 	int offset, id;
+	u16 num_msgs;
 	af_mbox = container_of(work, struct mbox, mbox_wrk);
 	mbox = &af_mbox->mbox;
 	mdev = &mbox->dev[0];
 	rsp_hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
+	num_msgs = rsp_hdr->num_msgs;
 	offset = mbox->rx_start + ALIGN(sizeof(*rsp_hdr), MBOX_MSG_ALIGN);
 	pf = af_mbox->pfvf;
-	for (id = 0; id < af_mbox->num_msgs; id++) {
+	for (id = 0; id < num_msgs; id++) {
 		msg = (struct mbox_msghdr *)(mdev->mbase + offset);
 		otx2_process_pfaf_mbox_msg(pf, msg);
 		offset = mbox->rx_start + msg->next_msgoff;
-		if (mdev->msgs_acked == (af_mbox->num_msgs - 1))
+		if (mdev->msgs_acked == (num_msgs - 1))
 			__otx2_mbox_reset(mbox, 0);
 		mdev->msgs_acked++;
 	}
 	int offset, id, devid = 0;
 	struct mbox_hdr *rsp_hdr;
 	struct mbox_msghdr *msg;
+	u16 num_msgs;
 	rsp_hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
+	num_msgs = rsp_hdr->num_msgs;
 	offset = mbox->rx_start + ALIGN(sizeof(*rsp_hdr), MBOX_MSG_ALIGN);
-	for (id = 0; id < af_mbox->up_num_msgs; id++) {
+	for (id = 0; id < num_msgs; id++) {
 		msg = (struct mbox_msghdr *)(mdev->mbase + offset);
 		devid = msg->pcifunc & RVU_PFVF_FUNC_MASK;
 			otx2_process_mbox_msg_up(pf, msg);
 		offset = mbox->rx_start + msg->next_msgoff;
 	}
-	if (devid) {
+	/* Forward to VF iff VFs are really present */
+	if (devid && pci_num_vf(pf->pdev)) {
 		otx2_forward_vf_mbox_msgs(pf, &pf->mbox.mbox_up,
 					  MBOX_DIR_PFVF_UP, devid - 1,
-					  af_mbox->up_num_msgs);
+					  num_msgs);
 		return;
 	}
 static irqreturn_t otx2_pfaf_mbox_intr_handler(int irq, void *pf_irq)
 {
 	struct otx2_nic *pf = (struct otx2_nic *)pf_irq;
-	struct mbox *mbox;
+	struct mbox *mw = &pf->mbox;
+	struct otx2_mbox_dev *mdev;
+	struct otx2_mbox *mbox;
+	struct mbox_hdr *hdr;
+	u64 mbox_data;
 	/* Clear the IRQ */
 	otx2_write64(pf, RVU_PF_INT, BIT_ULL(0));
-	mbox = &pf->mbox;
-	trace_otx2_msg_interrupt(mbox->mbox.pdev, "AF to PF", BIT_ULL(0));
+	mbox_data = otx2_read64(pf, RVU_PF_PFAF_MBOX0);
+	if (mbox_data & MBOX_UP_MSG) {
+		mbox_data &= ~MBOX_UP_MSG;
+		otx2_write64(pf, RVU_PF_PFAF_MBOX0, mbox_data);
+		mbox = &mw->mbox_up;
+		mdev = &mbox->dev[0];
+		otx2_sync_mbox_bbuf(mbox, 0);
+		hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
+		if (hdr->num_msgs)
+			queue_work(pf->mbox_wq, &mw->mbox_up_wrk);
+		trace_otx2_msg_interrupt(pf->pdev, "UP message from AF to PF",
+					 BIT_ULL(0));
+	}
+	if (mbox_data & MBOX_DOWN_MSG) {
+		mbox_data &= ~MBOX_DOWN_MSG;
+		otx2_write64(pf, RVU_PF_PFAF_MBOX0, mbox_data);
+		mbox = &mw->mbox;
+		mdev = &mbox->dev[0];
+		otx2_sync_mbox_bbuf(mbox, 0);
+		hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
+		if (hdr->num_msgs)
+			queue_work(pf->mbox_wq, &mw->mbox_wrk);
-	otx2_queue_work(mbox, pf->mbox_wq, 0, 1, 1, TYPE_PFAF);
+		trace_otx2_msg_interrupt(pf->pdev, "DOWN reply from AF to PF",
+					 BIT_ULL(0));
+	}
 	return IRQ_HANDLED;
 }
 	struct otx2_vf_config *config;
 	struct cgx_link_info_msg *req;
 	struct mbox_msghdr *msghdr;
+	struct delayed_work *dwork;
 	struct otx2_nic *pf;
 	int vf_idx;
 	vf_idx = config - config->pf->vf_configs;
 	pf = config->pf;
+	if (config->intf_down)
+		return;
+	mutex_lock(&pf->mbox.lock);
+	dwork = &config->link_event_work;
+	if (!otx2_mbox_wait_for_zero(&pf->mbox_pfvf[0].mbox_up, vf_idx)) {
+		schedule_delayed_work(dwork, msecs_to_jiffies(100));
+		mutex_unlock(&pf->mbox.lock);
+		return;
+	}
 	msghdr = otx2_mbox_alloc_msg_rsp(&pf->mbox_pfvf[0].mbox_up, vf_idx,
 					 sizeof(*req), sizeof(struct msg_rsp));
 	if (!msghdr) {
 		dev_err(pf->dev, "Failed to create VF%d link event\n", vf_idx);
+		mutex_unlock(&pf->mbox.lock);
 		return;
 	}
 	req->hdr.sig = OTX2_MBOX_REQ_SIG;
 	memcpy(&req->link_info, &pf->linfo, sizeof(req->link_info));
+	otx2_mbox_wait_for_zero(&pf->mbox_pfvf[0].mbox_up, vf_idx);
 	otx2_sync_mbox_up_msg(&pf->mbox_pfvf[0], vf_idx);
+	mutex_unlock(&pf->mbox.lock);
 }
 static int otx2_sriov_enable(struct pci_dev *pdev, int numvfs)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_vf.c+43−28

@@ -89,16 +89,20 @@ static void otx2vf_vfaf_mbox_handler(struct work_struct *work) · 88 unmodified lines
89	struct otx2_mbox *mbox;	89	struct otx2_mbox *mbox;
90	struct mbox *af_mbox;	90	struct mbox *af_mbox;
91	int offset, id;	91	int offset, id;
		92	u16 num_msgs;
92		93
93	af_mbox = container_of(work, struct mbox, mbox_wrk);	94	af_mbox = container_of(work, struct mbox, mbox_wrk);
94	mbox = &af_mbox->mbox;	95	mbox = &af_mbox->mbox;
95	mdev = &mbox->dev[0];	96	mdev = &mbox->dev[0];
96	rsp_hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);	97	rsp_hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
97	if (af_mbox->num_msgs == 0)	98	num_msgs = rsp_hdr->num_msgs;
		99
		100	if (num_msgs == 0)
98	return;	101	return;
		102
99	offset = mbox->rx_start + ALIGN(sizeof(*rsp_hdr), MBOX_MSG_ALIGN);	103	offset = mbox->rx_start + ALIGN(sizeof(*rsp_hdr), MBOX_MSG_ALIGN);
100		104
101	for (id = 0; id < af_mbox->num_msgs; id++) {	105	for (id = 0; id < num_msgs; id++) {
102	msg = (struct mbox_msghdr *)(mdev->mbase + offset);	106	msg = (struct mbox_msghdr *)(mdev->mbase + offset);
103	otx2vf_process_vfaf_mbox_msg(af_mbox->pfvf, msg);	107	otx2vf_process_vfaf_mbox_msg(af_mbox->pfvf, msg);
104	offset = mbox->rx_start + msg->next_msgoff;	108	offset = mbox->rx_start + msg->next_msgoff;
@@ -151,6 +155,7 @@ static void otx2vf_vfaf_mbox_up_handler(struct work_struct *work) · 46 unmodified lines
151	struct mbox *vf_mbox;	155	struct mbox *vf_mbox;
152	struct otx2_nic *vf;	156	struct otx2_nic *vf;
153	int offset, id;	157	int offset, id;
		158	u16 num_msgs;
154		159
155	vf_mbox = container_of(work, struct mbox, mbox_up_wrk);	160	vf_mbox = container_of(work, struct mbox, mbox_up_wrk);
156	vf = vf_mbox->pfvf;	161	vf = vf_mbox->pfvf;
@@ -158,12 +163,14 @@ static void otx2vf_vfaf_mbox_up_handler(struct work_struct *work) · 1 unmodified line
158	mdev = &mbox->dev[0];	163	mdev = &mbox->dev[0];
159		164
160	rsp_hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);	165	rsp_hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
161	if (vf_mbox->up_num_msgs == 0)	166	num_msgs = rsp_hdr->num_msgs;
		167
		168	if (num_msgs == 0)
162	return;	169	return;
163		170
164	offset = mbox->rx_start + ALIGN(sizeof(*rsp_hdr), MBOX_MSG_ALIGN);	171	offset = mbox->rx_start + ALIGN(sizeof(*rsp_hdr), MBOX_MSG_ALIGN);
165		172
166	for (id = 0; id < vf_mbox->up_num_msgs; id++) {	173	for (id = 0; id < num_msgs; id++) {
167	msg = (struct mbox_msghdr *)(mdev->mbase + offset);	174	msg = (struct mbox_msghdr *)(mdev->mbase + offset);
168	otx2vf_process_mbox_msg_up(vf, msg);	175	otx2vf_process_mbox_msg_up(vf, msg);
169	offset = mbox->rx_start + msg->next_msgoff;	176	offset = mbox->rx_start + msg->next_msgoff;
@@ -178,40 +185,48 @@ static irqreturn_t otx2vf_vfaf_mbox_intr_handler(int irq, void *vf_irq) · 8 unmodified lines
178	struct otx2_mbox_dev *mdev;	185	struct otx2_mbox_dev *mdev;
179	struct otx2_mbox *mbox;	186	struct otx2_mbox *mbox;
180	struct mbox_hdr *hdr;	187	struct mbox_hdr *hdr;
		188	u64 mbox_data;
181		189
182	/* Clear the IRQ */	190	/* Clear the IRQ */
183	otx2_write64(vf, RVU_VF_INT, BIT_ULL(0));	191	otx2_write64(vf, RVU_VF_INT, BIT_ULL(0));
184		192
		193	mbox_data = otx2_read64(vf, RVU_VF_VFPF_MBOX0);
		194
185	/* Read latest mbox data */	195	/* Read latest mbox data */
186	smp_rmb();	196	smp_rmb();
187		197
188	/* Check for PF => VF response messages */	198	if (mbox_data & MBOX_DOWN_MSG) {
189	mbox = &vf->mbox.mbox;	199	mbox_data &= ~MBOX_DOWN_MSG;
190	mdev = &mbox->dev[0];	200	otx2_write64(vf, RVU_VF_VFPF_MBOX0, mbox_data);
191	otx2_sync_mbox_bbuf(mbox, 0);	201
		202	/* Check for PF => VF response messages */
		203	mbox = &vf->mbox.mbox;
		204	mdev = &mbox->dev[0];
		205	otx2_sync_mbox_bbuf(mbox, 0);
192		206
193	trace_otx2_msg_interrupt(mbox->pdev, "PF to VF", BIT_ULL(0));	207	hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
		208	if (hdr->num_msgs)
		209	queue_work(vf->mbox_wq, &vf->mbox.mbox_wrk);
194		210
195	hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);	211	trace_otx2_msg_interrupt(mbox->pdev, "DOWN reply from PF to VF",
196	if (hdr->num_msgs) {	212	BIT_ULL(0));
197	vf->mbox.num_msgs = hdr->num_msgs;
198	hdr->num_msgs = 0;
199	memset(mbox->hwbase + mbox->rx_start, 0,
200	ALIGN(sizeof(struct mbox_hdr), sizeof(u64)));
201	queue_work(vf->mbox_wq, &vf->mbox.mbox_wrk);
202	}	213	}
203	/* Check for PF => VF notification messages */
204	mbox = &vf->mbox.mbox_up;
205	mdev = &mbox->dev[0];
206	otx2_sync_mbox_bbuf(mbox, 0);
207		214
208	hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);	215	if (mbox_data & MBOX_UP_MSG) {
209	if (hdr->num_msgs) {	216	mbox_data &= ~MBOX_UP_MSG;
210	vf->mbox.up_num_msgs = hdr->num_msgs;	217	otx2_write64(vf, RVU_VF_VFPF_MBOX0, mbox_data);
211	hdr->num_msgs = 0;	218
212	memset(mbox->hwbase + mbox->rx_start, 0,	219	/* Check for PF => VF notification messages */
213	ALIGN(sizeof(struct mbox_hdr), sizeof(u64)));	220	mbox = &vf->mbox.mbox_up;
214	queue_work(vf->mbox_wq, &vf->mbox.mbox_up_wrk);	221	mdev = &mbox->dev[0];
		222	otx2_sync_mbox_bbuf(mbox, 0);
		223
		224	hdr = (struct mbox_hdr *)(mdev->mbase + mbox->rx_start);
		225	if (hdr->num_msgs)
		226	queue_work(vf->mbox_wq, &vf->mbox.mbox_up_wrk);
		227
		228	trace_otx2_msg_interrupt(mbox->pdev, "UP message from PF to VF",
		229	BIT_ULL(0));
215	}	230	}
216		231
217	return IRQ_HANDLED;	232	return IRQ_HANDLED;
@@ -760,8 +775,8 @@ static void otx2vf_remove(struct pci_dev *pdev) · 542 unmodified lines
760	otx2_mcam_flow_del(vf);	775	otx2_mcam_flow_del(vf);
761	otx2_shutdown_tc(vf);	776	otx2_shutdown_tc(vf);
762	otx2_shutdown_qos(vf);	777	otx2_shutdown_qos(vf);
763	otx2vf_disable_mbox_intr(vf);
764	otx2_detach_resources(&vf->mbox);	778	otx2_detach_resources(&vf->mbox);
		779	otx2vf_disable_mbox_intr(vf);
765	free_percpu(vf->hw.lmt_info);	780	free_percpu(vf->hw.lmt_info);
766	if (test_bit(CN10K_LMTST, &vf->hw.cap_flag))	781	if (test_bit(CN10K_LMTST, &vf->hw.cap_flag))
767	qmem_free(vf->dev, vf->dync_lmt);	782	qmem_free(vf->dev, vf->dync_lmt);

drivers/net/ethernet/mediatek/mtk_eth_soc.c+3−4

 	mcr_cur = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
 	mcr_new = mcr_cur;
 	mcr_new |= MAC_MCR_IPG_CFG | MAC_MCR_FORCE_MODE |
-		   MAC_MCR_BACKOFF_EN | MAC_MCR_BACKPR_EN | MAC_MCR_FORCE_LINK |
+		   MAC_MCR_BACKOFF_EN | MAC_MCR_BACKPR_EN | MAC_MCR_RX_FIFO_CLR_DIS;
-		   MAC_MCR_RX_FIFO_CLR_DIS;
 	/* Only update control register when needed! */
 	if (mcr_new != mcr_cur)
 					   phylink_config);
 	u32 mcr = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
-	mcr &= ~(MAC_MCR_TX_EN | MAC_MCR_RX_EN);
+	mcr &= ~(MAC_MCR_TX_EN | MAC_MCR_RX_EN | MAC_MCR_FORCE_LINK);
 	mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id));
 }
 	if (rx_pause)
 		mcr |= MAC_MCR_FORCE_RX_FC;
-	mcr |= MAC_MCR_TX_EN | MAC_MCR_RX_EN;
+	mcr |= MAC_MCR_TX_EN | MAC_MCR_RX_EN | MAC_MCR_FORCE_LINK;
 	mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id));
 }

drivers/net/ethernet/mediatek/mtk_ppe.c+11−7

 			 MTK_PPE_KEEPALIVE_DISABLE) |
 	      FIELD_PREP(MTK_PPE_TB_CFG_HASH_MODE, 1) |
 	      FIELD_PREP(MTK_PPE_TB_CFG_SCAN_MODE,
-			 MTK_PPE_SCAN_MODE_KEEPALIVE_AGE) |
+			 MTK_PPE_SCAN_MODE_CHECK_AGE) |
 	      FIELD_PREP(MTK_PPE_TB_CFG_ENTRY_NUM,
 			 MTK_PPE_ENTRIES_SHIFT);
 	if (mtk_is_netsys_v2_or_greater(ppe->eth))
 	mtk_ppe_cache_enable(ppe, false);
-	/* disable offload engine */
-	ppe_clear(ppe, MTK_PPE_GLO_CFG, MTK_PPE_GLO_CFG_EN);
-	ppe_w32(ppe, MTK_PPE_FLOW_CFG, 0);
 	/* disable aging */
 	val = MTK_PPE_TB_CFG_AGE_NON_L4 |
 	      MTK_PPE_TB_CFG_AGE_UNBIND |
 	      MTK_PPE_TB_CFG_AGE_TCP |
 	      MTK_PPE_TB_CFG_AGE_UDP |
-	      MTK_PPE_TB_CFG_AGE_TCP_FIN;
+	      MTK_PPE_TB_CFG_AGE_TCP_FIN |
+		  MTK_PPE_TB_CFG_SCAN_MODE;
 	ppe_clear(ppe, MTK_PPE_TB_CFG, val);
-	return mtk_ppe_wait_busy(ppe);
+	if (mtk_ppe_wait_busy(ppe))
+		return -ETIMEDOUT;
+	/* disable offload engine */
+	ppe_clear(ppe, MTK_PPE_GLO_CFG, MTK_PPE_GLO_CFG_EN);
+	ppe_w32(ppe, MTK_PPE_FLOW_CFG, 0);
+	return 0;
 }

drivers/net/ethernet/wangxun/txgbe/txgbe_phy.c+1−1

@@ -571,7 +571,7 @@ static int txgbe_clock_register(struct txgbe *txgbe) · 570 unmodified lines
571	char clk_name[32];	571	char clk_name[32];
572	struct clk *clk;	572	struct clk *clk;
573		573
574	snprintf(clk_name, sizeof(clk_name), "i2c_designware.%d",	574	snprintf(clk_name, sizeof(clk_name), "i2c_dw.%d",
575	pci_dev_id(pdev));	575	pci_dev_id(pdev));
576		576
577	clk = clk_register_fixed_rate(NULL, clk_name, NULL, 0, 156250000);	577	clk = clk_register_fixed_rate(NULL, clk_name, NULL, 0, 156250000);

drivers/net/phy/phy_device.c+2−2

@@ -2831,8 +2831,8 @@ EXPORT_SYMBOL(genphy_resume); · 2830 unmodified lines
2831	int genphy_loopback(struct phy_device *phydev, bool enable)	2831	int genphy_loopback(struct phy_device *phydev, bool enable)
2832	{	2832	{
2833	if (enable) {	2833	if (enable) {
2834	u16 val, ctl = BMCR_LOOPBACK;	2834	u16 ctl = BMCR_LOOPBACK;
2835	int ret;	2835	int ret, val;
2836		2836
2837	ctl \|= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);	2837	ctl \|= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2838		2838

drivers/net/veth.c+0−18

 		if (peer_priv->_xdp_prog)
 			features &= ~NETIF_F_GSO_SOFTWARE;
 	}
-	if (priv->_xdp_prog)
-		features |= NETIF_F_GRO;
 	return features;
 }
 		}
 		if (!old_prog) {
-			if (!veth_gro_requested(dev)) {
-				/* user-space did not require GRO, but adding
-				 * XDP is supposed to get GRO working
-				 */
-				dev->features |= NETIF_F_GRO;
-				netdev_features_change(dev);
-			}
 			peer->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 			peer->max_mtu = max_mtu;
 		}
 			if (dev->flags & IFF_UP)
 				veth_disable_xdp(dev);
-			/* if user-space did not require GRO, since adding XDP
-			 * enabled it, clear it now
-			 */
-			if (!veth_gro_requested(dev)) {
-				dev->features &= ~NETIF_F_GRO;
-				netdev_features_change(dev);
-			}
 			if (peer) {
 				peer->hw_features |= NETIF_F_GSO_SOFTWARE;
 				peer->max_mtu = ETH_MAX_MTU;

drivers/net/vmxnet3/vmxnet3_xdp.c+3−3

@@ -382,12 +382,12 @@ vmxnet3_process_xdp(struct vmxnet3_adapter *adapter, · 381 unmodified lines
382	page = rbi->page;	382	page = rbi->page;
383	dma_sync_single_for_cpu(&adapter->pdev->dev,	383	dma_sync_single_for_cpu(&adapter->pdev->dev,
384	page_pool_get_dma_addr(page) +	384	page_pool_get_dma_addr(page) +
385	rq->page_pool->p.offset, rcd->len,	385	rq->page_pool->p.offset, rbi->len,
386	page_pool_get_dma_dir(rq->page_pool));	386	page_pool_get_dma_dir(rq->page_pool));
387		387
388	xdp_init_buff(&xdp, rbi->len, &rq->xdp_rxq);	388	xdp_init_buff(&xdp, PAGE_SIZE, &rq->xdp_rxq);
389	xdp_prepare_buff(&xdp, page_address(page), rq->page_pool->p.offset,	389	xdp_prepare_buff(&xdp, page_address(page), rq->page_pool->p.offset,
390	rcd->len, false);	390	rbi->len, false);
391	xdp_buff_clear_frags_flag(&xdp);	391	xdp_buff_clear_frags_flag(&xdp);
392		392
393	xdp_prog = rcu_dereference(rq->adapter->xdp_bpf_prog);	393	xdp_prog = rcu_dereference(rq->adapter->xdp_bpf_prog);

drivers/net/wan/fsl_qmc_hdlc.c+1−1

@@ -780,7 +780,7 @@ static const struct of_device_id qmc_hdlc_id_table[] = { · 779 unmodified lines
780	{ .compatible = "fsl,qmc-hdlc" },	780	{ .compatible = "fsl,qmc-hdlc" },
781	{} /* sentinel */	781	{} /* sentinel */
782	};	782	};
783	MODULE_DEVICE_TABLE(of, qmc_hdlc_driver);	783	MODULE_DEVICE_TABLE(of, qmc_hdlc_id_table);
784		784
785	static struct platform_driver qmc_hdlc_driver = {	785	static struct platform_driver qmc_hdlc_driver = {
786	.driver = {	786	.driver = {

drivers/net/wireguard/device.c+2−9

 	.ndo_open		= wg_open,
 	.ndo_stop		= wg_stop,
 	.ndo_start_xmit		= wg_xmit,
-	.ndo_get_stats64	= dev_get_tstats64
 };
 static void wg_destruct(struct net_device *dev)
 	rcu_barrier(); /* Wait for all the peers to be actually freed. */
 	wg_ratelimiter_uninit();
 	memzero_explicit(&wg->static_identity, sizeof(wg->static_identity));
-	free_percpu(dev->tstats);
 	kvfree(wg->index_hashtable);
 	kvfree(wg->peer_hashtable);
 	mutex_unlock(&wg->device_update_lock);
 	dev->hw_enc_features |= WG_NETDEV_FEATURES;
 	dev->mtu = ETH_DATA_LEN - overhead;
 	dev->max_mtu = round_down(INT_MAX, MESSAGE_PADDING_MULTIPLE) - overhead;
+	dev->pcpu_stat_type = NETDEV_PCPU_STAT_TSTATS;
 	SET_NETDEV_DEVTYPE(dev, &device_type);
 	if (!wg->index_hashtable)
 		goto err_free_peer_hashtable;
-	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
-	if (!dev->tstats)
-		goto err_free_index_hashtable;
 	wg->handshake_receive_wq = alloc_workqueue("wg-kex-%s",
 			WQ_CPU_INTENSIVE | WQ_FREEZABLE, 0, dev->name);
 	if (!wg->handshake_receive_wq)
-		goto err_free_tstats;
+		goto err_free_index_hashtable;
 	wg->handshake_send_wq = alloc_workqueue("wg-kex-%s",
 			WQ_UNBOUND | WQ_FREEZABLE, 0, dev->name);
 	destroy_workqueue(wg->handshake_send_wq);
 err_destroy_handshake_receive:
 	destroy_workqueue(wg->handshake_receive_wq);
-err_free_tstats:
-	free_percpu(dev->tstats);
 err_free_index_hashtable:
 	kvfree(wg->index_hashtable);
 err_free_peer_hashtable:

drivers/net/wireguard/netlink.c+5−5

 	if (!allowedips_node)
 		goto no_allowedips;
 	if (!ctx->allowedips_seq)
-		ctx->allowedips_seq = peer->device->peer_allowedips.seq;
+		ctx->allowedips_seq = ctx->wg->peer_allowedips.seq;
-	else if (ctx->allowedips_seq != peer->device->peer_allowedips.seq)
+	else if (ctx->allowedips_seq != ctx->wg->peer_allowedips.seq)
 		goto no_allowedips;
 	allowedips_nest = nla_nest_start(skb, WGPEER_A_ALLOWEDIPS);
 	if (!peers_nest)
 		goto out;
 	ret = 0;
-	/* If the last cursor was removed via list_del_init in peer_remove, then
+	lockdep_assert_held(&wg->device_update_lock);
+	/* If the last cursor was removed in peer_remove or peer_remove_all, then
 	 * we just treat this the same as there being no more peers left. The
 	 * reason is that seq_nr should indicate to userspace that this isn't a
 	 * coherent dump anyway, so they'll try again.
 	 */
 	if (list_empty(&wg->peer_list) ||
-	    (ctx->next_peer && list_empty(&ctx->next_peer->peer_list))) {
+	    (ctx->next_peer && ctx->next_peer->is_dead)) {
 		nla_nest_cancel(skb, peers_nest);
 		goto out;
 	}
-	lockdep_assert_held(&wg->device_update_lock);
 	peer = list_prepare_entry(ctx->next_peer, &wg->peer_list, peer_list);
 	list_for_each_entry_continue(peer, &wg->peer_list, peer_list) {
 		if (get_peer(peer, skb, ctx)) {

drivers/net/wireguard/receive.c+3−3

@@ -251,7 +251,7 @@ static bool decrypt_packet(struct sk_buff skb, struct noise_keypair keypair) · 250 unmodified lines
251		251
252	if (unlikely(!READ_ONCE(keypair->receiving.is_valid) \|\|	252	if (unlikely(!READ_ONCE(keypair->receiving.is_valid) \|\|
253	wg_birthdate_has_expired(keypair->receiving.birthdate, REJECT_AFTER_TIME) \|\|	253	wg_birthdate_has_expired(keypair->receiving.birthdate, REJECT_AFTER_TIME) \|\|
254	keypair->receiving_counter.counter >= REJECT_AFTER_MESSAGES)) {	254	READ_ONCE(keypair->receiving_counter.counter) >= REJECT_AFTER_MESSAGES)) {
255	WRITE_ONCE(keypair->receiving.is_valid, false);	255	WRITE_ONCE(keypair->receiving.is_valid, false);
256	return false;	256	return false;
257	}	257	}
@@ -318,7 +318,7 @@ static bool counter_validate(struct noise_replay_counter *counter, u64 their_cou · 60 unmodified lines
318	for (i = 1; i <= top; ++i)	318	for (i = 1; i <= top; ++i)
319	counter->backtrack[(i + index_current) &	319	counter->backtrack[(i + index_current) &
320	((COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1)] = 0;	320	((COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1)] = 0;
321	counter->counter = their_counter;	321	WRITE_ONCE(counter->counter, their_counter);
322	}	322	}
323		323
324	index &= (COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1;	324	index &= (COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1;
@@ -463,7 +463,7 @@ int wg_packet_rx_poll(struct napi_struct *napi, int budget) · 138 unmodified lines
463	net_dbg_ratelimited("%s: Packet has invalid nonce %llu (max %llu)\n",	463	net_dbg_ratelimited("%s: Packet has invalid nonce %llu (max %llu)\n",
464	peer->device->dev->name,	464	peer->device->dev->name,
465	PACKET_CB(skb)->nonce,	465	PACKET_CB(skb)->nonce,
466	keypair->receiving_counter.counter);	466	READ_ONCE(keypair->receiving_counter.counter));
467	goto next;	467	goto next;
468	}	468	}
469		469

drivers/soc/fsl/qbman/qman.c+14−11

 	/* linked-list of CSCN handlers. */
 	struct list_head cgr_cbs;
 	/* list lock */
-	spinlock_t cgr_lock;
+	raw_spinlock_t cgr_lock;
 	struct work_struct congestion_work;
 	struct work_struct mr_work;
 	char irqname[MAX_IRQNAME];
 		/* if the given mask is NULL, assume all CGRs can be seen */
 		qman_cgrs_fill(&portal->cgrs[0]);
 	INIT_LIST_HEAD(&portal->cgr_cbs);
-	spin_lock_init(&portal->cgr_lock);
+	raw_spin_lock_init(&portal->cgr_lock);
 	INIT_WORK(&portal->congestion_work, qm_congestion_task);
 	INIT_WORK(&portal->mr_work, qm_mr_process_task);
 	portal->bits = 0;
 	union qm_mc_result *mcr;
 	struct qman_cgr *cgr;
-	spin_lock(&p->cgr_lock);
+	/*
+	 * FIXME: QM_MCR_TIMEOUT is 10ms, which is too long for a raw spinlock!
+	 */
+	raw_spin_lock_irq(&p->cgr_lock);
 	qm_mc_start(&p->p);
 	qm_mc_commit(&p->p, QM_MCC_VERB_QUERYCONGESTION);
 	if (!qm_mc_result_timeout(&p->p, &mcr)) {
-		spin_unlock(&p->cgr_lock);
+		raw_spin_unlock_irq(&p->cgr_lock);
 		dev_crit(p->config->dev, "QUERYCONGESTION timeout\n");
 		qman_p_irqsource_add(p, QM_PIRQ_CSCI);
 		return;
 	list_for_each_entry(cgr, &p->cgr_cbs, node)
 		if (cgr->cb && qman_cgrs_get(&c, cgr->cgrid))
 			cgr->cb(p, cgr, qman_cgrs_get(&rr, cgr->cgrid));
-	spin_unlock(&p->cgr_lock);
+	raw_spin_unlock_irq(&p->cgr_lock);
 	qman_p_irqsource_add(p, QM_PIRQ_CSCI);
 }
 	preempt_enable();
 	cgr->chan = p->config->channel;
-	spin_lock(&p->cgr_lock);
+	raw_spin_lock_irq(&p->cgr_lock);
 	if (opts) {
 		struct qm_mcc_initcgr local_opts = *opts;
 	    qman_cgrs_get(&p->cgrs[1], cgr->cgrid))
 		cgr->cb(p, cgr, 1);
 out:
-	spin_unlock(&p->cgr_lock);
+	raw_spin_unlock_irq(&p->cgr_lock);
 	put_affine_portal();
 	return ret;
 }
 		return -EINVAL;
 	memset(&local_opts, 0, sizeof(struct qm_mcc_initcgr));
-	spin_lock_irqsave(&p->cgr_lock, irqflags);
+	raw_spin_lock_irqsave(&p->cgr_lock, irqflags);
 	list_del(&cgr->node);
 	/*
 	 * If there are no other CGR objects for this CGRID in the list,
 		/* add back to the list */
 		list_add(&cgr->node, &p->cgr_cbs);
 release_lock:
-	spin_unlock_irqrestore(&p->cgr_lock, irqflags);
+	raw_spin_unlock_irqrestore(&p->cgr_lock, irqflags);
 	put_affine_portal();
 	return ret;
 }
 	if (!p)
 		return -EINVAL;
-	spin_lock_irqsave(&p->cgr_lock, irqflags);
+	raw_spin_lock_irqsave(&p->cgr_lock, irqflags);
 	ret = qm_modify_cgr(cgr, 0, opts);
-	spin_unlock_irqrestore(&p->cgr_lock, irqflags);
+	raw_spin_unlock_irqrestore(&p->cgr_lock, irqflags);
 	put_affine_portal();
 	return ret;
 }

include/linux/bitmap.h+23−21

@@ -522,17 +522,18 @@ static inline void bitmap_replace(unsigned long *dst, · 521 unmodified lines
522	*	522	*
523	* (Bits 0, 1, 2, 3, 4, 5 are copied to the bits 0, 1, 4, 8, 9, 12)	523	* (Bits 0, 1, 2, 3, 4, 5 are copied to the bits 0, 1, 4, 8, 9, 12)
524	*	524	*
525	* A more 'visual' description of the operation:	525	* A more 'visual' description of the operation::
526	* src: 0000000001011010	526	*
527	* \|\|\|\|\|\|	527	* src: 0000000001011010
528	* +------+\|\|\|\|\|	528	* \|\|\|\|\|\|
529	* \| +----+\|\|\|\|	529	* +------+\|\|\|\|\|
530	* \| \|+----+\|\|\|	530	* \| +----+\|\|\|\|
531	* \| \|\| +-+\|\|	531	* \| \|+----+\|\|\|
532	* \| \|\| \| \|\|	532	* \| \|\| +-+\|\|
533	* mask: ...v..vv...v..vv	533	* \| \|\| \| \|\|
534	* ...0..11...0..10	534	* mask: ...v..vv...v..vv
535	* dst: 0000001100000010	535	* ...0..11...0..10
		536	* dst: 0000001100000010
536	*	537	*
537	* A relationship exists between bitmap_scatter() and bitmap_gather().	538	* A relationship exists between bitmap_scatter() and bitmap_gather().
538	* bitmap_gather() can be seen as the 'reverse' bitmap_scatter() operation.	539	* bitmap_gather() can be seen as the 'reverse' bitmap_scatter() operation.
@@ -568,16 +569,17 @@ static inline void bitmap_scatter(unsigned long dst, const unsigned long src, · 29 unmodified lines
568	*	569	*
569	* (Bits 0, 1, 4, 8, 9, 12 are copied to the bits 0, 1, 2, 3, 4, 5)	570	* (Bits 0, 1, 4, 8, 9, 12 are copied to the bits 0, 1, 2, 3, 4, 5)
570	*	571	*
571	* A more 'visual' description of the operation:	572	* A more 'visual' description of the operation::
572	* mask: ...v..vv...v..vv	573	*
573	* src: 0000001100000010	574	* mask: ...v..vv...v..vv
574	* ^ ^^ ^ 0	575	* src: 0000001100000010
575	* \| \|\| \| 10	576	* ^ ^^ ^ 0
576	* \| \|\| > 010	577	* \| \|\| \| 10
577	* \| \|+--> 1010	578	* \| \|\| > 010
578	* \| +--> 11010	579	* \| \|+--> 1010
579	* +----> 011010	580	* \| +--> 11010
580	* dst: 0000000000011010	581	* +----> 011010
		582	* dst: 0000000000011010
581	*	583	*
582	* A relationship exists between bitmap_gather() and bitmap_scatter(). See	584	* A relationship exists between bitmap_gather() and bitmap_scatter(). See
583	* bitmap_scatter() for the bitmap scatter detailed operations.	585	* bitmap_scatter() for the bitmap scatter detailed operations.

include/linux/netdevice.h+1−1

 		struct pcpu_sw_netstats __percpu	*tstats;
 		struct pcpu_dstats __percpu		*dstats;
 	};
+	unsigned long		state;
 	unsigned int		flags;
 	unsigned short		hard_header_len;
 	netdev_features_t	features;
 	 *	part of the usual set specified in Space.c.
 	 */
-	unsigned long		state;
 	struct list_head	dev_list;
 	struct list_head	napi_list;

include/linux/rcupdate.h+31−0

@@ -247,6 +247,37 @@ do { \ · 246 unmodified lines
247	cond_resched(); \	247	cond_resched(); \
248	} while (0)	248	} while (0)
249		249
		250	/**
		251	* rcu_softirq_qs_periodic - Report RCU and RCU-Tasks quiescent states
		252	* @old_ts: jiffies at start of processing.
		253	*
		254	* This helper is for long-running softirq handlers, such as NAPI threads in
		255	* networking. The caller should initialize the variable passed in as @old_ts
		256	* at the beginning of the softirq handler. When invoked frequently, this macro
		257	* will invoke rcu_softirq_qs() every 100 milliseconds thereafter, which will
		258	* provide both RCU and RCU-Tasks quiescent states. Note that this macro
		259	* modifies its old_ts argument.
		260	*
		261	* Because regions of code that have disabled softirq act as RCU read-side
		262	* critical sections, this macro should be invoked with softirq (and
		263	* preemption) enabled.
		264	*
		265	* The macro is not needed when CONFIG_PREEMPT_RT is defined. RT kernels would
		266	* have more chance to invoke schedule() calls and provide necessary quiescent
		267	* states. As a contrast, calling cond_resched() only won't achieve the same
		268	* effect because cond_resched() does not provide RCU-Tasks quiescent states.
		269	*/
		270	#define rcu_softirq_qs_periodic(old_ts) \
		271	do { \
		272	if (!IS_ENABLED(CONFIG_PREEMPT_RT) && \
		273	time_after(jiffies, (old_ts) + HZ / 10)) { \
		274	preempt_disable(); \
		275	rcu_softirq_qs(); \
		276	preempt_enable(); \
		277	(old_ts) = jiffies; \
		278	} \
		279	} while (0)
		280
250	/*	281	/*
251	* Infrastructure to implement the synchronize_() primitives in	282	* Infrastructure to implement the synchronize_() primitives in
252	* TREE_RCU and rcu_barrier_() primitives in TINY_RCU.	283	* TREE_RCU and rcu_barrier_() primitives in TINY_RCU.

include/linux/skbuff.h+13−3

  *	@decrypted: Decrypted SKB
  *	@slow_gro: state present at GRO time, slower prepare step required
  *	@mono_delivery_time: When set, skb->tstamp has the
- *		delivery_time in mono clock base (i.e., EDT) or a clock base chosen
+ *		delivery_time in mono clock base (i.e. EDT).  Otherwise, the
- *		by SO_TXTIME. If zero, skb->tstamp has the (rcv) timestamp at
+ *		skb->tstamp has the (rcv) timestamp at ingress and
- *		ingress.
+ *		delivery_time at egress.
  *	@napi_id: id of the NAPI struct this skb came from
  *	@sender_cpu: (aka @napi_id) source CPU in XPS
  *	@alloc_cpu: CPU which did the skb allocation.
 			 struct bpf_prog *prog);
 bool napi_pp_put_page(struct page *page, bool napi_safe);
+static inline void
+skb_page_unref(const struct sk_buff *skb, struct page *page, bool napi_safe)
+{
+#ifdef CONFIG_PAGE_POOL
+	if (skb->pp_recycle && napi_pp_put_page(page, napi_safe))
+		return;
+#endif
+	put_page(page);
+}
 static inline void
 napi_frag_unref(skb_frag_t *frag, bool recycle, bool napi_safe)
 {

include/linux/socket.h+0−7

@@ -422,13 +422,6 @@ extern long __sys_recvmsg_sock(struct socket sock, struct msghdr msg, · 421 unmodified lines
422	struct user_msghdr __user *umsg,	422	struct user_msghdr __user *umsg,
423	struct sockaddr __user *uaddr,	423	struct sockaddr __user *uaddr,
424	unsigned int flags);	424	unsigned int flags);
425	extern int sendmsg_copy_msghdr(struct msghdr *msg,
426	struct user_msghdr __user *umsg, unsigned flags,
427	struct iovec **iov);
428	extern int recvmsg_copy_msghdr(struct msghdr *msg,
429	struct user_msghdr __user *umsg, unsigned flags,
430	struct sockaddr __user **uaddr,
431	struct iovec **iov);
432	extern int __copy_msghdr(struct msghdr *kmsg,	425	extern int __copy_msghdr(struct msghdr *kmsg,
433	struct user_msghdr *umsg,	426	struct user_msghdr *umsg,
434	struct sockaddr __user **save_addr);	427	struct sockaddr __user **save_addr);

include/net/request_sock.h+6−1

 	struct request_sock		*dl_next;
 	u16				mss;
 	u8				num_retrans; /* number of retransmits */
-	u8				syncookie:1; /* syncookie: encode tcpopts in timestamp */
+	u8				syncookie:1; /* True if
+						      * 1) tcpopts needs to be encoded in
+						      *    TS of SYN+ACK
+						      * 2) ACK is validated by BPF kfunc.
+						      */
 	u8				num_timeout:7; /* number of timeouts */
 	u32				ts_recent;
 	struct timer_list		rsk_timer;
 	sk_node_init(&req_to_sk(req)->sk_node);
 	sk_tx_queue_clear(req_to_sk(req));
 	req->saved_syn = NULL;
+	req->syncookie = 0;
 	req->timeout = 0;
 	req->num_timeout = 0;
 	req->num_retrans = 0;

kernel/bpf/cpumap.c+3−0

 static int cpu_map_kthread_run(void *data)
 {
 	struct bpf_cpu_map_entry *rcpu = data;
+	unsigned long last_qs = jiffies;
 	complete(&rcpu->kthread_running);
 	set_current_state(TASK_INTERRUPTIBLE);
 			if (__ptr_ring_empty(rcpu->queue)) {
 				schedule();
 				sched = 1;
+				last_qs = jiffies;
 			} else {
 				__set_current_state(TASK_RUNNING);
 			}
 		} else {
+			rcu_softirq_qs_periodic(last_qs);
 			sched = cond_resched();
 		}

net/core/dev.c+6−2

 	rcu_read_lock();
 again:
 	list_for_each_entry_rcu(ptype, ptype_list, list) {
-		if (ptype->ignore_outgoing)
+		if (READ_ONCE(ptype->ignore_outgoing))
 			continue;
 		/* Never send packets back to the socket
 	void *have;
 	while (!napi_thread_wait(napi)) {
+		unsigned long last_qs = jiffies;
 		for (;;) {
 			bool repoll = false;
 			if (!repoll)
 				break;
+			rcu_softirq_qs_periodic(last_qs);
 			cond_resched();
 		}
 	}
 	/* TXRX read-mostly hotpath */
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, lstats);
+	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, state);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, flags);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, hard_header_len);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, features);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, ip6_ptr);
-	CACHELINE_ASSERT_GROUP_SIZE(struct net_device, net_device_read_txrx, 38);
+	CACHELINE_ASSERT_GROUP_SIZE(struct net_device, net_device_read_txrx, 46);
 	/* RX read-mostly hotpath */
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_rx, ptype_specific);

net/devlink/netlink.c+7−6

@@ -193,12 +193,13 @@ devlink_get_from_attrs_lock(struct net net, struct nlattr *attrs, · 192 unmodified lines
193	devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);	193	devname = nla_data(attrs[DEVLINK_ATTR_DEV_NAME]);
194		194
195	devlinks_xa_for_each_registered_get(net, index, devlink) {	195	devlinks_xa_for_each_registered_get(net, index, devlink) {
196	devl_dev_lock(devlink, dev_lock);	196	if (strcmp(devlink->dev->bus->name, busname) == 0 &&
197	if (devl_is_registered(devlink) &&	197	strcmp(dev_name(devlink->dev), devname) == 0) {
198	strcmp(devlink->dev->bus->name, busname) == 0 &&	198	devl_dev_lock(devlink, dev_lock);
199	strcmp(dev_name(devlink->dev), devname) == 0)	199	if (devl_is_registered(devlink))
200	return devlink;	200	return devlink;
201	devl_dev_unlock(devlink, dev_lock);	201	devl_dev_unlock(devlink, dev_lock);
		202	}
202	devlink_put(devlink);	203	devlink_put(devlink);
203	}	204	}
204		205

net/devlink/port.c+1−1

@@ -889,7 +889,7 @@ int devlink_nl_port_new_doit(struct sk_buff skb, struct genl_info info) · 888 unmodified lines
889	err = -ENOMEM;	889	err = -ENOMEM;
890	goto err_out_port_del;	890	goto err_out_port_del;
891	}	891	}
892	err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_NEW,	892	err = devlink_nl_port_fill(msg, devlink_port, DEVLINK_CMD_PORT_NEW,
893	info->snd_portid, info->snd_seq, 0, NULL);	893	info->snd_portid, info->snd_seq, 0, NULL);
894	if (WARN_ON_ONCE(err))	894	if (WARN_ON_ONCE(err))
895	goto err_out_msg_free;	895	goto err_out_msg_free;

net/hsr/hsr_framereg.c+4−0

 	 */
 	if (ethhdr->h_proto == htons(ETH_P_PRP) ||
 	    ethhdr->h_proto == htons(ETH_P_HSR)) {
+		/* Check if skb contains hsr_ethhdr */
+		if (skb->mac_len < sizeof(struct hsr_ethhdr))
+			return NULL;
 		/* Use the existing sequence_nr from the tag as starting point
 		 * for filtering duplicate frames.
 		 */

net/hsr/hsr_main.c+11−4

 static int __init hsr_init(void)
 {
-	int res;
+	int err;
 	BUILD_BUG_ON(sizeof(struct hsr_tag) != HSR_HLEN);
-	register_netdevice_notifier(&hsr_nb);
+	err = register_netdevice_notifier(&hsr_nb);
-	res = hsr_netlink_init();
+	if (err)
+		return err;
+	err = hsr_netlink_init();
+	if (err) {
+		unregister_netdevice_notifier(&hsr_nb);
+		return err;
+	}
-	return res;
+	return 0;
 }
 static void __exit hsr_exit(void)

net/ipv4/esp4.c+4−4

@@ -95,7 +95,7 @@ static inline struct scatterlist esp_req_sg(struct crypto_aead aead, · 94 unmodified lines
95	__alignof__(struct scatterlist));	95	__alignof__(struct scatterlist));
96	}	96	}
97		97
98	static void esp_ssg_unref(struct xfrm_state x, void tmp)	98	static void esp_ssg_unref(struct xfrm_state x, void tmp, struct sk_buff *skb)
99	{	99	{
100	struct crypto_aead *aead = x->data;	100	struct crypto_aead *aead = x->data;
101	int extralen = 0;	101	int extralen = 0;
@@ -114,7 +114,7 @@ static void esp_ssg_unref(struct xfrm_state x, void tmp) · 12 unmodified lines
114	*/	114	*/
115	if (req->src != req->dst)	115	if (req->src != req->dst)
116	for (sg = sg_next(req->src); sg; sg = sg_next(sg))	116	for (sg = sg_next(req->src); sg; sg = sg_next(sg))
117	put_page(sg_page(sg));	117	skb_page_unref(skb, sg_page(sg), false);
118	}	118	}
119		119
120	#ifdef CONFIG_INET_ESPINTCP	120	#ifdef CONFIG_INET_ESPINTCP
@@ -260,7 +260,7 @@ static void esp_output_done(void *data, int err) · 139 unmodified lines
260	}	260	}
261		261
262	tmp = ESP_SKB_CB(skb)->tmp;	262	tmp = ESP_SKB_CB(skb)->tmp;
263	esp_ssg_unref(x, tmp);	263	esp_ssg_unref(x, tmp, skb);
264	kfree(tmp);	264	kfree(tmp);
265		265
266	if (xo && (xo->flags & XFRM_DEV_RESUME)) {	266	if (xo && (xo->flags & XFRM_DEV_RESUME)) {
@@ -639,7 +639,7 @@ int esp_output_tail(struct xfrm_state x, struct sk_buff skb, struct esp_info * · 372 unmodified lines
639	}	639	}
640		640
641	if (sg != dsg)	641	if (sg != dsg)
642	esp_ssg_unref(x, tmp);	642	esp_ssg_unref(x, tmp, skb);
643		643
644	if (!err && x->encap && x->encap->encap_type == TCP_ENCAP_ESPINTCP)	644	if (!err && x->encap && x->encap->encap_type == TCP_ENCAP_ESPINTCP)
645	err = esp_output_tail_tcp(x, skb);	645	err = esp_output_tail_tcp(x, skb);

net/ipv4/inet_hashtables.c+1−1

@@ -1135,7 +1135,7 @@ error: · 1134 unmodified lines
1135	sock_prot_inuse_add(net, sk->sk_prot, -1);	1135	sock_prot_inuse_add(net, sk->sk_prot, -1);
1136		1136
1137	spin_lock(lock);	1137	spin_lock(lock);
1138	sk_nulls_del_node_init_rcu(sk);	1138	__sk_nulls_del_node_init_rcu(sk);
1139	spin_unlock(lock);	1139	spin_unlock(lock);
1140		1140
1141	sk->sk_hash = 0;	1141	sk->sk_hash = 0;

net/ipv4/inet_timewait_sock.c+19−22

 }
 EXPORT_SYMBOL_GPL(__inet_twsk_schedule);
+/* Remove all non full sockets (TIME_WAIT and NEW_SYN_RECV) for dead netns */
 void inet_twsk_purge(struct inet_hashinfo *hashinfo, int family)
 {
-	struct inet_timewait_sock *tw;
-	struct sock *sk;
 	struct hlist_nulls_node *node;
 	unsigned int slot;
+	struct sock *sk;
 	for (slot = 0; slot <= hashinfo->ehash_mask; slot++) {
 		struct inet_ehash_bucket *head = &hashinfo->ehash[slot];
 		rcu_read_lock();
 restart:
 		sk_nulls_for_each_rcu(sk, node, &head->chain) {
-			if (sk->sk_state != TCP_TIME_WAIT) {
+			int state = inet_sk_state_load(sk);
-				/* A kernel listener socket might not hold refcnt for net,
-				 * so reqsk_timer_handler() could be fired after net is
-				 * freed.  Userspace listener and reqsk never exist here.
-				 */
-				if (unlikely(sk->sk_state == TCP_NEW_SYN_RECV &&
-					     hashinfo->pernet)) {
-					struct request_sock *req = inet_reqsk(sk);
-					inet_csk_reqsk_queue_drop_and_put(req->rsk_listener, req);
-				}
+			if ((1 << state) & ~(TCPF_TIME_WAIT |
+					     TCPF_NEW_SYN_RECV))
 				continue;
-			}
-			tw = inet_twsk(sk);
+			if (sk->sk_family != family ||
-			if ((tw->tw_family != family) ||
+			    refcount_read(&sock_net(sk)->ns.count))
-				refcount_read(&twsk_net(tw)->ns.count))
 				continue;
-			if (unlikely(!refcount_inc_not_zero(&tw->tw_refcnt)))
+			if (unlikely(!refcount_inc_not_zero(&sk->sk_refcnt)))
 				continue;
-			if (unlikely((tw->tw_family != family) ||
+			if (unlikely(sk->sk_family != family ||
-				     refcount_read(&twsk_net(tw)->ns.count))) {
+				     refcount_read(&sock_net(sk)->ns.count))) {
-				inet_twsk_put(tw);
+				sock_gen_put(sk);
 				goto restart;
 			}
 			rcu_read_unlock();
 			local_bh_disable();
-			inet_twsk_deschedule_put(tw);
+			if (state == TCP_TIME_WAIT) {
+				inet_twsk_deschedule_put(inet_twsk(sk));
+			} else {
+				struct request_sock *req = inet_reqsk(sk);
+				inet_csk_reqsk_queue_drop_and_put(req->rsk_listener,
+								  req);
+			}
 			local_bh_enable();
 			goto restart_rcu;
 		}

net/ipv4/ip_output.c+0−1

@@ -1458,7 +1458,6 @@ struct sk_buff __ip_make_skb(struct sock sk, · 1457 unmodified lines
1458	skb->priority = (cork->tos != -1) ? cork->priority: READ_ONCE(sk->sk_priority);	1458	skb->priority = (cork->tos != -1) ? cork->priority: READ_ONCE(sk->sk_priority);
1459	skb->mark = cork->mark;	1459	skb->mark = cork->mark;
1460	skb->tstamp = cork->transmit_time;	1460	skb->tstamp = cork->transmit_time;
1461	skb->mono_delivery_time = !!skb->tstamp;
1462	/*	1461	/*
1463	* Steal rt from cork.dst to avoid a pair of atomic_inc/atomic_dec	1462	* Steal rt from cork.dst to avoid a pair of atomic_inc/atomic_dec
1464	* on dst refcount	1463	* on dst refcount

net/ipv4/raw.c+1−1

 		goto error;
 	skb_reserve(skb, hlen);
+	skb->protocol = htons(ETH_P_IP);
 	skb->priority = READ_ONCE(sk->sk_priority);
 	skb->mark = sockc->mark;
 	skb->tstamp = sockc->transmit_time;
-	skb->mono_delivery_time = !!skb->tstamp;
 	skb_dst_set(skb, &rt->dst);
 	*rtp = NULL;

net/ipv4/syncookies.c+3−0

 				  ireq->wscale_ok, &rcv_wscale,
 				  dst_metric(&rt->dst, RTAX_INITRWND));
+	/* req->syncookie is set true only if ACK is validated
+	 * by BPF kfunc, then, rcv_wscale is already configured.
+	 */
 	if (!req->syncookie)
 		ireq->rcv_wscale = rcv_wscale;
 	ireq->ecn_ok &= cookie_ecn_ok(net, &rt->dst);

net/ipv4/tcp_minisocks.c+0−4

 			/* Even if tw_refcount == 1, we must clean up kernel reqsk */
 			inet_twsk_purge(net->ipv4.tcp_death_row.hashinfo, family);
 		} else if (!purged_once) {
-			/* The last refcount is decremented in tcp_sk_exit_batch() */
-			if (refcount_read(&net->ipv4.tcp_death_row.tw_refcount) == 1)
-				continue;
 			inet_twsk_purge(&tcp_hashinfo, family);
 			purged_once = true;
 		}

net/ipv6/esp6.c+4−4

@@ -112,7 +112,7 @@ static inline struct scatterlist esp_req_sg(struct crypto_aead aead, · 111 unmodified lines
112	__alignof__(struct scatterlist));	112	__alignof__(struct scatterlist));
113	}	113	}
114		114
115	static void esp_ssg_unref(struct xfrm_state x, void tmp)	115	static void esp_ssg_unref(struct xfrm_state x, void tmp, struct sk_buff *skb)
116	{	116	{
117	struct crypto_aead *aead = x->data;	117	struct crypto_aead *aead = x->data;
118	int extralen = 0;	118	int extralen = 0;
@@ -131,7 +131,7 @@ static void esp_ssg_unref(struct xfrm_state x, void tmp) · 12 unmodified lines
131	*/	131	*/
132	if (req->src != req->dst)	132	if (req->src != req->dst)
133	for (sg = sg_next(req->src); sg; sg = sg_next(sg))	133	for (sg = sg_next(req->src); sg; sg = sg_next(sg))
134	put_page(sg_page(sg));	134	skb_page_unref(skb, sg_page(sg), false);
135	}	135	}
136		136
137	#ifdef CONFIG_INET6_ESPINTCP	137	#ifdef CONFIG_INET6_ESPINTCP
@@ -294,7 +294,7 @@ static void esp_output_done(void *data, int err) · 156 unmodified lines
294	}	294	}
295		295
296	tmp = ESP_SKB_CB(skb)->tmp;	296	tmp = ESP_SKB_CB(skb)->tmp;
297	esp_ssg_unref(x, tmp);	297	esp_ssg_unref(x, tmp, skb);
298	kfree(tmp);	298	kfree(tmp);
299		299
300	esp_output_encap_csum(skb);	300	esp_output_encap_csum(skb);
@@ -677,7 +677,7 @@ int esp6_output_tail(struct xfrm_state x, struct sk_buff skb, struct esp_info · 376 unmodified lines
677	}	677	}
678		678
679	if (sg != dsg)	679	if (sg != dsg)
680	esp_ssg_unref(x, tmp);	680	esp_ssg_unref(x, tmp, skb);
681		681
682	if (!err && x->encap && x->encap->encap_type == TCP_ENCAP_ESPINTCP)	682	if (!err && x->encap && x->encap->encap_type == TCP_ENCAP_ESPINTCP)
683	err = esp_output_tail_tcp(x, skb);	683	err = esp_output_tail_tcp(x, skb);

net/ipv6/ip6_output.c+1−1

@@ -1925,7 +1925,7 @@ struct sk_buff __ip6_make_skb(struct sock sk, · 1924 unmodified lines
1925	skb->priority = READ_ONCE(sk->sk_priority);	1925	skb->priority = READ_ONCE(sk->sk_priority);
1926	skb->mark = cork->base.mark;	1926	skb->mark = cork->base.mark;
1927	skb->tstamp = cork->base.transmit_time;	1927	skb->tstamp = cork->base.transmit_time;
1928	skb->mono_delivery_time = !!skb->tstamp;	1928
1929	ip6_cork_steal_dst(skb, cork);	1929	ip6_cork_steal_dst(skb, cork);
1930	IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTREQUESTS);	1930	IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTREQUESTS);
1931	if (proto == IPPROTO_ICMPV6) {	1931	if (proto == IPPROTO_ICMPV6) {

net/ipv6/raw.c+1−1

@@ -622,7 +622,7 @@ static int rawv6_send_hdrinc(struct sock sk, struct msghdr msg, int length, · 621 unmodified lines
622	skb->priority = READ_ONCE(sk->sk_priority);	622	skb->priority = READ_ONCE(sk->sk_priority);
623	skb->mark = sockc->mark;	623	skb->mark = sockc->mark;
624	skb->tstamp = sockc->transmit_time;	624	skb->tstamp = sockc->transmit_time;
625	skb->mono_delivery_time = !!skb->tstamp;	625
626	skb_put(skb, length);	626	skb_put(skb, length);
627	skb_reset_network_header(skb);	627	skb_reset_network_header(skb);
628	iph = ipv6_hdr(skb);	628	iph = ipv6_hdr(skb);

net/ipv6/syncookies.c+3−0

 				  ireq->wscale_ok, &rcv_wscale,
 				  dst_metric(dst, RTAX_INITRWND));
+	/* req->syncookie is set true only if ACK is validated
+	 * by BPF kfunc, then, rcv_wscale is already configured.
+	 */
 	if (!req->syncookie)
 		ireq->rcv_wscale = rcv_wscale;
 	ireq->ecn_ok &= cookie_ecn_ok(net, dst);

net/netfilter/nf_tables_api.c+15−14

 	if (flags & ~NFT_TABLE_F_MASK)
 		return -EOPNOTSUPP;
-	if (flags == ctx->table->flags)
+	if (flags == (ctx->table->flags & NFT_TABLE_F_MASK))
 		return 0;
 	if ((nft_table_has_owner(ctx->table) &&
 		}
 	}
-	if (nla[NFTA_CHAIN_COUNTERS]) {
-		if (!nft_is_base_chain(chain)) {
-			err = -EOPNOTSUPP;
-			goto err_hooks;
-		}
-		stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
-		if (IS_ERR(stats)) {
-			err = PTR_ERR(stats);
-			goto err_hooks;
-		}
-	}
 	if (!(table->flags & NFT_TABLE_F_DORMANT) &&
 	    nft_is_base_chain(chain) &&
 	    !list_empty(&hook.list)) {
 	}
 	unregister = true;
+	if (nla[NFTA_CHAIN_COUNTERS]) {
+		if (!nft_is_base_chain(chain)) {
+			err = -EOPNOTSUPP;
+			goto err_hooks;
+		}
+		stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
+		if (IS_ERR(stats)) {
+			err = PTR_ERR(stats);
+			goto err_hooks;
+		}
+	}
 	err = -ENOMEM;
 	trans = nft_trans_alloc(ctx, NFT_MSG_NEWCHAIN,
 				sizeof(struct nft_trans_chain));

net/netfilter/nft_set_pipapo.c+1−4

 	if (m) {
 		rcu_barrier();
-		nft_set_pipapo_match_destroy(ctx, set, m);
 		for_each_possible_cpu(cpu)
 			pipapo_free_scratch(m, cpu);
 		free_percpu(m->scratch);
 	if (priv->clone) {
 		m = priv->clone;
-		if (priv->dirty)
+		nft_set_pipapo_match_destroy(ctx, set, m);
-			nft_set_pipapo_match_destroy(ctx, set, m);
 		for_each_possible_cpu(cpu)
 			pipapo_free_scratch(priv->clone, cpu);

net/packet/af_packet.c+3−5

@@ -2057,7 +2057,7 @@ retry: · 2056 unmodified lines
2057	skb->priority = READ_ONCE(sk->sk_priority);	2057	skb->priority = READ_ONCE(sk->sk_priority);
2058	skb->mark = READ_ONCE(sk->sk_mark);	2058	skb->mark = READ_ONCE(sk->sk_mark);
2059	skb->tstamp = sockc.transmit_time;	2059	skb->tstamp = sockc.transmit_time;
2060	skb->mono_delivery_time = !!skb->tstamp;	2060
2061	skb_setup_tx_timestamp(skb, sockc.tsflags);	2061	skb_setup_tx_timestamp(skb, sockc.tsflags);
2062		2062
2063	if (unlikely(extra_len == 4))	2063	if (unlikely(extra_len == 4))
@@ -2586,7 +2586,6 @@ static int tpacket_fill_skb(struct packet_sock po, struct sk_buff skb, · 522 unmodified lines
2586	skb->priority = READ_ONCE(po->sk.sk_priority);	2586	skb->priority = READ_ONCE(po->sk.sk_priority);
2587	skb->mark = READ_ONCE(po->sk.sk_mark);	2587	skb->mark = READ_ONCE(po->sk.sk_mark);
2588	skb->tstamp = sockc->transmit_time;	2588	skb->tstamp = sockc->transmit_time;
2589	skb->mono_delivery_time = !!skb->tstamp;
2590	skb_setup_tx_timestamp(skb, sockc->tsflags);	2589	skb_setup_tx_timestamp(skb, sockc->tsflags);
2591	skb_zcopy_set_nouarg(skb, ph.raw);	2590	skb_zcopy_set_nouarg(skb, ph.raw);
2592		2591
@@ -3065,7 +3064,6 @@ static int packet_snd(struct socket sock, struct msghdr msg, size_t len) · 472 unmodified lines
3065	skb->priority = READ_ONCE(sk->sk_priority);	3064	skb->priority = READ_ONCE(sk->sk_priority);
3066	skb->mark = sockc.mark;	3065	skb->mark = sockc.mark;
3067	skb->tstamp = sockc.transmit_time;	3066	skb->tstamp = sockc.transmit_time;
3068	skb->mono_delivery_time = !!skb->tstamp;
3069		3067
3070	if (unlikely(extra_len == 4))	3068	if (unlikely(extra_len == 4))
3071	skb->no_fcs = 1;	3069	skb->no_fcs = 1;
@@ -4000,7 +3998,7 @@ packet_setsockopt(struct socket *sock, int level, int optname, sockptr_t optval, · 928 unmodified lines
4000	if (val < 0 \|\| val > 1)	3998	if (val < 0 \|\| val > 1)
4001	return -EINVAL;	3999	return -EINVAL;
4002		4000
4003	po->prot_hook.ignore_outgoing = !!val;	4001	WRITE_ONCE(po->prot_hook.ignore_outgoing, !!val);
4004	return 0;	4002	return 0;
4005	}	4003	}
4006	case PACKET_TX_HAS_OFF:	4004	case PACKET_TX_HAS_OFF:
@@ -4134,7 +4132,7 @@ static int packet_getsockopt(struct socket *sock, int level, int optname, · 127 unmodified lines
4134	0);	4132	0);
4135	break;	4133	break;
4136	case PACKET_IGNORE_OUTGOING:	4134	case PACKET_IGNORE_OUTGOING:
4137	val = po->prot_hook.ignore_outgoing;	4135	val = READ_ONCE(po->prot_hook.ignore_outgoing);
4138	break;	4136	break;
4139	case PACKET_ROLLOVER_STATS:	4137	case PACKET_ROLLOVER_STATS:
4140	if (!po->rollover)	4138	if (!po->rollover)

net/rds/send.c+2−3

 static int acquire_in_xmit(struct rds_conn_path *cp)
 {
-	return test_and_set_bit(RDS_IN_XMIT, &cp->cp_flags) == 0;
+	return test_and_set_bit_lock(RDS_IN_XMIT, &cp->cp_flags) == 0;
 }
 static void release_in_xmit(struct rds_conn_path *cp)
 {
-	clear_bit(RDS_IN_XMIT, &cp->cp_flags);
+	clear_bit_unlock(RDS_IN_XMIT, &cp->cp_flags);
-	smp_mb__after_atomic();
 	/*
 	 * We don't use wait_on_bit()/wake_up_bit() because our waking is in a
 	 * hot path and finding waiters is very rare.  We don't want to walk

net/rxrpc/sendmsg.c+2−2

@@ -349,8 +349,8 @@ reload: · 348 unmodified lines
349	*/	349	*/
350	remain = more ? INT_MAX : msg_data_left(msg);	350	remain = more ? INT_MAX : msg_data_left(msg);
351	txb = call->conn->security->alloc_txbuf(call, remain, sk->sk_allocation);	351	txb = call->conn->security->alloc_txbuf(call, remain, sk->sk_allocation);
352	if (IS_ERR(txb)) {	352	if (!txb) {
353	ret = PTR_ERR(txb);	353	ret = -ENOMEM;
354	goto maybe_error;	354	goto maybe_error;
355	}	355	}
356	}	356	}

net/rxrpc/txbuf.c+2−2

@@ -33,8 +33,8 @@ struct rxrpc_txbuf rxrpc_alloc_data_txbuf(struct rxrpc_call call, size_t data_ · 32 unmodified lines
33	total = hoff + sizeof(*whdr) + data_size;	33	total = hoff + sizeof(*whdr) + data_size;
34		34
35	mutex_lock(&call->conn->tx_data_alloc_lock);	35	mutex_lock(&call->conn->tx_data_alloc_lock);
36	buf = page_frag_alloc_align(&call->conn->tx_data_alloc, total, gfp,	36	buf = __page_frag_alloc_align(&call->conn->tx_data_alloc, total, gfp,
37	~(data_align - 1) & ~(L1_CACHE_BYTES - 1));	37	~(data_align - 1) & ~(L1_CACHE_BYTES - 1));
38	mutex_unlock(&call->conn->tx_data_alloc_lock);	38	mutex_unlock(&call->conn->tx_data_alloc_lock);
39	if (!buf) {	39	if (!buf) {
40	kfree(txb);	40	kfree(txb);

net/sched/sch_fq_pie.c+2−0

  */
 #include <linux/jhash.h>
+#include <linux/module.h>
 #include <linux/sizes.h>
 #include <linux/vmalloc.h>
 #include <net/pkt_cls.h>
 	.dump_stats	= fq_pie_dump_stats,
 	.owner		= THIS_MODULE,
 };
+MODULE_ALIAS_NET_SCH("fq_pie");
 static int __init fq_pie_module_init(void)
 {

net/sched/sch_taprio.c+2−1

@@ -997,7 +997,8 @@ static const struct nla_policy entry_policy[TCA_TAPRIO_SCHED_ENTRY_MAX + 1] = { · 996 unmodified lines
997	};	997	};
998		998
999	static const struct nla_policy taprio_tc_policy[TCA_TAPRIO_TC_ENTRY_MAX + 1] = {	999	static const struct nla_policy taprio_tc_policy[TCA_TAPRIO_TC_ENTRY_MAX + 1] = {
1000	[TCA_TAPRIO_TC_ENTRY_INDEX] = { .type = NLA_U32 },	1000	[TCA_TAPRIO_TC_ENTRY_INDEX] = NLA_POLICY_MAX(NLA_U32,
		1001	TC_QOPT_MAX_QUEUE),
1001	[TCA_TAPRIO_TC_ENTRY_MAX_SDU] = { .type = NLA_U32 },	1002	[TCA_TAPRIO_TC_ENTRY_MAX_SDU] = { .type = NLA_U32 },
1002	[TCA_TAPRIO_TC_ENTRY_FP] = NLA_POLICY_RANGE(NLA_U32,	1003	[TCA_TAPRIO_TC_ENTRY_FP] = NLA_POLICY_RANGE(NLA_U32,
1003	TC_FP_EXPRESS,	1004	TC_FP_EXPRESS,

net/socket.c+7−7

@@ -2600,9 +2600,9 @@ out: · 2599 unmodified lines
2600	return err;	2600	return err;
2601	}	2601	}
2602		2602
2603	int sendmsg_copy_msghdr(struct msghdr *msg,	2603	static int sendmsg_copy_msghdr(struct msghdr *msg,
2604	struct user_msghdr __user *umsg, unsigned flags,	2604	struct user_msghdr __user *umsg, unsigned flags,
2605	struct iovec **iov)	2605	struct iovec **iov)
2606	{	2606	{
2607	int err;	2607	int err;
2608		2608
@@ -2753,10 +2753,10 @@ SYSCALL_DEFINE4(sendmmsg, int, fd, struct mmsghdr __user *, mmsg, · 144 unmodified lines
2753	return __sys_sendmmsg(fd, mmsg, vlen, flags, true);	2753	return __sys_sendmmsg(fd, mmsg, vlen, flags, true);
2754	}	2754	}
2755		2755
2756	int recvmsg_copy_msghdr(struct msghdr *msg,	2756	static int recvmsg_copy_msghdr(struct msghdr *msg,
2757	struct user_msghdr __user *umsg, unsigned flags,	2757	struct user_msghdr __user *umsg, unsigned flags,
2758	struct sockaddr __user **uaddr,	2758	struct sockaddr __user **uaddr,
2759	struct iovec **iov)	2759	struct iovec **iov)
2760	{	2760	{
2761	ssize_t err;	2761	ssize_t err;
2762		2762

net/xfrm/xfrm_device.c+2−1

@@ -407,7 +407,8 @@ bool xfrm_dev_offload_ok(struct sk_buff skb, struct xfrm_state x) · 406 unmodified lines
407	struct xfrm_dst xdst = (struct xfrm_dst )dst;	407	struct xfrm_dst xdst = (struct xfrm_dst )dst;
408	struct net_device *dev = x->xso.dev;	408	struct net_device *dev = x->xso.dev;
409		409
410	if (!x->type_offload)	410	if (!x->type_offload \|\|
		411	(x->xso.type == XFRM_DEV_OFFLOAD_UNSPECIFIED && x->encap))
411	return false;	412	return false;
412		413
413	if (x->xso.type == XFRM_DEV_OFFLOAD_PACKET \|\|	414	if (x->xso.type == XFRM_DEV_OFFLOAD_PACKET \|\|

tools/net/ynl/Makefile.deps+1−0

@@ -20,6 +20,7 @@ CFLAGS_ethtool:=$(call get_hdr_inc,_LINUX_ETHTOOL_NETLINK_H_,ethtool_netlink.h) · 19 unmodified lines
20	CFLAGS_handshake:=$(call get_hdr_inc,_LINUX_HANDSHAKE_H,handshake.h)	20	CFLAGS_handshake:=$(call get_hdr_inc,_LINUX_HANDSHAKE_H,handshake.h)
21	CFLAGS_mptcp_pm:=$(call get_hdr_inc,_LINUX_MPTCP_PM_H,mptcp_pm.h)	21	CFLAGS_mptcp_pm:=$(call get_hdr_inc,_LINUX_MPTCP_PM_H,mptcp_pm.h)
22	CFLAGS_netdev:=$(call get_hdr_inc,_LINUX_NETDEV_H,netdev.h)	22	CFLAGS_netdev:=$(call get_hdr_inc,_LINUX_NETDEV_H,netdev.h)
		23	CFLAGS_nlctrl:=$(call get_hdr_inc,__LINUX_GENERIC_NETLINK_H,genetlink.h)
23	CFLAGS_nfsd:=$(call get_hdr_inc,_LINUX_NFSD_NETLINK_H,nfsd_netlink.h)	24	CFLAGS_nfsd:=$(call get_hdr_inc,_LINUX_NFSD_NETLINK_H,nfsd_netlink.h)
24	CFLAGS_ovs_datapath:=$(call get_hdr_inc,__LINUX_OPENVSWITCH_H,openvswitch.h)	25	CFLAGS_ovs_datapath:=$(call get_hdr_inc,__LINUX_OPENVSWITCH_H,openvswitch.h)
25	CFLAGS_ovs_flow:=$(call get_hdr_inc,__LINUX_OPENVSWITCH_H,openvswitch.h)	26	CFLAGS_ovs_flow:=$(call get_hdr_inc,__LINUX_OPENVSWITCH_H,openvswitch.h)

tools/perf/trace/beauty/include/linux/socket.h+0−7

@@ -422,13 +422,6 @@ extern long __sys_recvmsg_sock(struct socket sock, struct msghdr msg, · 421 unmodified lines
422	struct user_msghdr __user *umsg,	422	struct user_msghdr __user *umsg,
423	struct sockaddr __user *uaddr,	423	struct sockaddr __user *uaddr,
424	unsigned int flags);	424	unsigned int flags);
425	extern int sendmsg_copy_msghdr(struct msghdr *msg,
426	struct user_msghdr __user *umsg, unsigned flags,
427	struct iovec **iov);
428	extern int recvmsg_copy_msghdr(struct msghdr *msg,
429	struct user_msghdr __user *umsg, unsigned flags,
430	struct sockaddr __user **uaddr,
431	struct iovec **iov);
432	extern int __copy_msghdr(struct msghdr *kmsg,	425	extern int __copy_msghdr(struct msghdr *kmsg,
433	struct user_msghdr *umsg,	426	struct user_msghdr *umsg,
434	struct sockaddr __user **save_addr);	427	struct sockaddr __user **save_addr);

tools/testing/selftests/net/forwarding/vxlan_bridge_1d_ipv6.sh+2−2

@@ -354,7 +354,7 @@ __ping_ipv4() · 353 unmodified lines
354		354
355	# Send 100 packets and verify that at least 100 packets hit the rule,	355	# Send 100 packets and verify that at least 100 packets hit the rule,
356	# to overcome ARP noise.	356	# to overcome ARP noise.
357	PING_COUNT=100 PING_TIMEOUT=11 ping_do $dev $dst_ip	357	PING_COUNT=100 PING_TIMEOUT=20 ping_do $dev $dst_ip
358	check_err $? "Ping failed"	358	check_err $? "Ping failed"
359		359
360	tc_check_at_least_x_packets "dev $rp1 egress" 101 10 100	360	tc_check_at_least_x_packets "dev $rp1 egress" 101 10 100
@@ -410,7 +410,7 @@ __ping_ipv6() · 49 unmodified lines
410		410
411	# Send 100 packets and verify that at least 100 packets hit the rule,	411	# Send 100 packets and verify that at least 100 packets hit the rule,
412	# to overcome neighbor discovery noise.	412	# to overcome neighbor discovery noise.
413	PING_COUNT=100 PING_TIMEOUT=11 ping6_do $dev $dst_ip	413	PING_COUNT=100 PING_TIMEOUT=20 ping6_do $dev $dst_ip
414	check_err $? "Ping failed"	414	check_err $? "Ping failed"
415		415
416	tc_check_at_least_x_packets "dev $rp1 egress" 101 100	416	tc_check_at_least_x_packets "dev $rp1 egress" 101 100

tools/testing/selftests/net/forwarding/vxlan_bridge_1q_ipv6.sh+2−2

@@ -457,7 +457,7 @@ __ping_ipv4() · 456 unmodified lines
457		457
458	# Send 100 packets and verify that at least 100 packets hit the rule,	458	# Send 100 packets and verify that at least 100 packets hit the rule,
459	# to overcome ARP noise.	459	# to overcome ARP noise.
460	PING_COUNT=100 PING_TIMEOUT=11 ping_do $dev $dst_ip	460	PING_COUNT=100 PING_TIMEOUT=20 ping_do $dev $dst_ip
461	check_err $? "Ping failed"	461	check_err $? "Ping failed"
462		462
463	tc_check_at_least_x_packets "dev $rp1 egress" 101 10 100	463	tc_check_at_least_x_packets "dev $rp1 egress" 101 10 100
@@ -522,7 +522,7 @@ __ping_ipv6() · 58 unmodified lines
522		522
523	# Send 100 packets and verify that at least 100 packets hit the rule,	523	# Send 100 packets and verify that at least 100 packets hit the rule,
524	# to overcome neighbor discovery noise.	524	# to overcome neighbor discovery noise.
525	PING_COUNT=100 PING_TIMEOUT=11 ping6_do $dev $dst_ip	525	PING_COUNT=100 PING_TIMEOUT=20 ping6_do $dev $dst_ip
526	check_err $? "Ping failed"	526	check_err $? "Ping failed"
527		527
528	tc_check_at_least_x_packets "dev $rp1 egress" 101 100	528	tc_check_at_least_x_packets "dev $rp1 egress" 101 100

tools/testing/selftests/net/udpgro_fwd.sh+4−0

 	cleanup
 	create_ns
+	ip netns exec $NS_DST ethtool -K veth$DST generic-receive-offload on
 	ip netns exec $NS_DST ethtool -K veth$DST rx-gro-list on
 	run_test "GRO frag list" $BM_NET$DST 1 0
 	cleanup
 	# use NAT to circumvent GRO FWD check
 	create_ns
 	ip -n $NS_DST addr add dev veth$DST $BM_NET$DST_NAT/$SUFFIX
+	ip netns exec $NS_DST ethtool -K veth$DST generic-receive-offload on
 	ip netns exec $NS_DST ethtool -K veth$DST rx-udp-gro-forwarding on
 	ip netns exec $NS_DST $IPT -t nat -I PREROUTING -d $BM_NET$DST_NAT \
 					-j DNAT --to-destination $BM_NET$DST
 	cleanup
 	create_vxlan_pair
+	ip netns exec $NS_DST ethtool -K veth$DST generic-receive-offload on
 	ip netns exec $NS_DST ethtool -K veth$DST rx-gro-list on
 	run_test "GRO frag list over UDP tunnel" $OL_NET$DST 1 1
 	cleanup
 	# use NAT to circumvent GRO FWD check
 	create_vxlan_pair
 	ip -n $NS_DST addr add dev $VXDEV$DST $OL_NET$DST_NAT/$SUFFIX
+	ip netns exec $NS_DST ethtool -K veth$DST generic-receive-offload on
 	ip netns exec $NS_DST ethtool -K veth$DST rx-udp-gro-forwarding on
 	ip netns exec $NS_DST $IPT -t nat -I PREROUTING -d $OL_NET$DST_NAT \
 					-j DNAT --to-destination $OL_NET$DST

tools/testing/selftests/net/veth.sh+21−3

 create_ns
 ip -n $NS_DST link set dev veth$DST up
 ip -n $NS_DST link set dev veth$DST xdp object ${BPF_FILE} section xdp
-chk_gro_flag "gro vs xdp while down - gro flag on" $DST on
+chk_gro_flag "gro vs xdp while down - gro flag off" $DST off
 ip -n $NS_DST link set dev veth$DST down
-chk_gro_flag "                      - after down" $DST on
+chk_gro_flag "                      - after down" $DST off
 ip -n $NS_DST link set dev veth$DST xdp off
 chk_gro_flag "                      - after xdp off" $DST off
 ip -n $NS_DST link set dev veth$DST up
 chk_gro_flag "                      - after peer xdp" $DST off
 cleanup
+create_ns
+ip -n $NS_DST link set dev veth$DST up
+ip -n $NS_DST link set dev veth$DST xdp object ${BPF_FILE} section xdp
+ip netns exec $NS_DST ethtool -K veth$DST generic-receive-offload on
+chk_gro_flag "gro vs xdp while down - gro flag on" $DST on
+ip -n $NS_DST link set dev veth$DST down
+chk_gro_flag "                      - after down" $DST on
+ip -n $NS_DST link set dev veth$DST xdp off
+chk_gro_flag "                      - after xdp off" $DST on
+ip -n $NS_DST link set dev veth$DST up
+chk_gro_flag "                      - after up" $DST on
+ip -n $NS_SRC link set dev veth$SRC xdp object ${BPF_FILE} section xdp
+chk_gro_flag "                      - after peer xdp" $DST on
+cleanup
 create_ns
 chk_channels "default channels" $DST 1 1
 fi
 ip -n $NS_DST link set dev veth$DST xdp object ${BPF_FILE} section xdp 2>/dev/null
-chk_gro_flag "with xdp attached - gro flag" $DST on
+chk_gro_flag "with xdp attached - gro flag" $DST off
 chk_gro_flag "        - peer gro flag" $SRC off
 chk_tso_flag "        - tso flag" $SRC off
 chk_tso_flag "        - peer tso flag" $DST on
 ip netns exec $NS_DST ethtool -K veth$DST rx-udp-gro-forwarding on
+chk_gro "        - no aggregation" 10
+ip netns exec $NS_DST ethtool -K veth$DST generic-receive-offload on
+chk_gro_flag "        - gro flag with GRO on" $DST on
 chk_gro "        - aggregation" 1

tools/testing/selftests/wireguard/qemu/arch/riscv32.config+1−0

@@ -3,6 +3,7 @@ CONFIG_ARCH_RV32I=y · 2 unmodified lines
3	CONFIG_MMU=y	3	CONFIG_MMU=y
4	CONFIG_FPU=y	4	CONFIG_FPU=y
5	CONFIG_SOC_VIRT=y	5	CONFIG_SOC_VIRT=y
		6	CONFIG_RISCV_ISA_FALLBACK=y
6	CONFIG_SERIAL_8250=y	7	CONFIG_SERIAL_8250=y
7	CONFIG_SERIAL_8250_CONSOLE=y	8	CONFIG_SERIAL_8250_CONSOLE=y
8	CONFIG_SERIAL_OF_PLATFORM=y	9	CONFIG_SERIAL_OF_PLATFORM=y

tools/testing/selftests/wireguard/qemu/arch/riscv64.config+1−0

@@ -2,6 +2,7 @@ CONFIG_ARCH_RV64I=y · 1 unmodified line
2	CONFIG_MMU=y	2	CONFIG_MMU=y
3	CONFIG_FPU=y	3	CONFIG_FPU=y
4	CONFIG_SOC_VIRT=y	4	CONFIG_SOC_VIRT=y
		5	CONFIG_RISCV_ISA_FALLBACK=y
5	CONFIG_SERIAL_8250=y	6	CONFIG_SERIAL_8250=y
6	CONFIG_SERIAL_8250_CONSOLE=y	7	CONFIG_SERIAL_8250_CONSOLE=y
7	CONFIG_SERIAL_OF_PLATFORM=y	8	CONFIG_SERIAL_OF_PLATFORM=y

Merge tag 'net-6.9-rc1' of 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

@@ -87,35 +87,35 @@ all using the same instance under "priv->mdev". · 86 unmodified lines
87		87
88	Observability	88	Observability
89	=============	89	=============
90	The relation between PF, irq, napi, and queue can be observed via netlink spec:	90	The relation between PF, irq, napi, and queue can be observed via netlink spec::
91		91
92	$ ./tools/net/ynl/cli.py --spec Documentation/netlink/specs/netdev.yaml --dump queue-get --json='{"ifindex": 13}'	92	$ ./tools/net/ynl/cli.py --spec Documentation/netlink/specs/netdev.yaml --dump queue-get --json='{"ifindex": 13}'
93	[{'id': 0, 'ifindex': 13, 'napi-id': 539, 'type': 'rx'},	93	[{'id': 0, 'ifindex': 13, 'napi-id': 539, 'type': 'rx'},
94	{'id': 1, 'ifindex': 13, 'napi-id': 540, 'type': 'rx'},	94	{'id': 1, 'ifindex': 13, 'napi-id': 540, 'type': 'rx'},
95	{'id': 2, 'ifindex': 13, 'napi-id': 541, 'type': 'rx'},	95	{'id': 2, 'ifindex': 13, 'napi-id': 541, 'type': 'rx'},
96	{'id': 3, 'ifindex': 13, 'napi-id': 542, 'type': 'rx'},	96	{'id': 3, 'ifindex': 13, 'napi-id': 542, 'type': 'rx'},
97	{'id': 4, 'ifindex': 13, 'napi-id': 543, 'type': 'rx'},	97	{'id': 4, 'ifindex': 13, 'napi-id': 543, 'type': 'rx'},
98	{'id': 0, 'ifindex': 13, 'napi-id': 539, 'type': 'tx'},	98	{'id': 0, 'ifindex': 13, 'napi-id': 539, 'type': 'tx'},
99	{'id': 1, 'ifindex': 13, 'napi-id': 540, 'type': 'tx'},	99	{'id': 1, 'ifindex': 13, 'napi-id': 540, 'type': 'tx'},
100	{'id': 2, 'ifindex': 13, 'napi-id': 541, 'type': 'tx'},	100	{'id': 2, 'ifindex': 13, 'napi-id': 541, 'type': 'tx'},
101	{'id': 3, 'ifindex': 13, 'napi-id': 542, 'type': 'tx'},	101	{'id': 3, 'ifindex': 13, 'napi-id': 542, 'type': 'tx'},
102	{'id': 4, 'ifindex': 13, 'napi-id': 543, 'type': 'tx'}]	102	{'id': 4, 'ifindex': 13, 'napi-id': 543, 'type': 'tx'}]
103		103
104	$ ./tools/net/ynl/cli.py --spec Documentation/netlink/specs/netdev.yaml --dump napi-get --json='{"ifindex": 13}'	104	$ ./tools/net/ynl/cli.py --spec Documentation/netlink/specs/netdev.yaml --dump napi-get --json='{"ifindex": 13}'
105	[{'id': 543, 'ifindex': 13, 'irq': 42},	105	[{'id': 543, 'ifindex': 13, 'irq': 42},
106	{'id': 542, 'ifindex': 13, 'irq': 41},	106	{'id': 542, 'ifindex': 13, 'irq': 41},
107	{'id': 541, 'ifindex': 13, 'irq': 40},	107	{'id': 541, 'ifindex': 13, 'irq': 40},
108	{'id': 540, 'ifindex': 13, 'irq': 39},	108	{'id': 540, 'ifindex': 13, 'irq': 39},
109	{'id': 539, 'ifindex': 13, 'irq': 36}]	109	{'id': 539, 'ifindex': 13, 'irq': 36}]
110		110
111	Here you can clearly observe our channels distribution policy:	111	Here you can clearly observe our channels distribution policy::
112		112
113	$ ls /proc/irq/{36,39,40,41,42}/mlx5* -d -1	113	$ ls /proc/irq/{36,39,40,41,42}/mlx5* -d -1
114	/proc/irq/36/mlx5_comp1@pci:0000:08:00.0	114	/proc/irq/36/mlx5_comp1@pci:0000:08:00.0
115	/proc/irq/39/mlx5_comp1@pci:0000:09:00.0	115	/proc/irq/39/mlx5_comp1@pci:0000:09:00.0
116	/proc/irq/40/mlx5_comp2@pci:0000:08:00.0	116	/proc/irq/40/mlx5_comp2@pci:0000:08:00.0
117	/proc/irq/41/mlx5_comp2@pci:0000:09:00.0	117	/proc/irq/41/mlx5_comp2@pci:0000:09:00.0
118	/proc/irq/42/mlx5_comp3@pci:0000:08:00.0	118	/proc/irq/42/mlx5_comp3@pci:0000:08:00.0
119		119
120	Steering	120	Steering
121	========	121	========