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

Pull networking fixes from Jakub Kicinski: "Including fixes from netfilter. As Paolo promised we continue to hammer out issues in our selftests. This is not the end but probably the peak. Current release - regressions: - smc: fix incorrect SMC-D link group matching logic Current release - new code bugs: - eth: bnxt: silence WARN() when device skips a timestamp, it happens Previous releases - regressions: - ipmr: fix null-deref when forwarding mcast packets - conntrack: evaluate window negotiation only for packets in the REPLY direction, otherwise SYN retransmissions trigger incorrect window scale negotiation - ipset: fix performance regression in swap operation Previous releases - always broken: - tcp: add sanity checks to types of pages getting into the rx zerocopy path, we only support basic NIC -> user, no page cache pages etc. - ip6_tunnel: make sure to pull inner header in __ip6_tnl_rcv() - nt_tables: more input sanitization changes - dsa: mt7530: fix 10M/100M speed on MediaTek MT7988 switch - bridge: mcast: fix loss of snooping after long uptime, jiffies do wrap on 32bit - xen-netback: properly sync TX responses, protect with locking - phy: mediatek-ge-soc: sync calibration values with MediaTek SDK, increase connection stability - eth: pds: fixes for various teardown, and reset races Misc: - hsr: silence WARN() if we can't alloc supervision frame, it happens" * tag 'net-6.8-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (82 commits) doc/netlink/specs: Add missing attr in rt_link spec idpf: avoid compiler padding in virtchnl2_ptype struct selftests: mptcp: join: stop transfer when check is done (part 2) selftests: mptcp: join: stop transfer when check is done (part 1) selftests: mptcp: allow changing subtests prefix selftests: mptcp: decrease BW in simult flows selftests: mptcp: increase timeout to 30 min selftests: mptcp: add missing kconfig for NF Mangle selftests: mptcp: add missing kconfig for NF Filter in v6 selftests: mptcp: add missing kconfig for NF Filter mptcp: fix data re-injection from stale subflow selftests: net: enable some more knobs selftests: net: add missing config for NF_TARGET_TTL selftests: forwarding: List helper scripts in TEST_FILES Makefile variable selftests: net: List helper scripts in TEST_FILES Makefile variable selftests: net: Remove executable bits from library scripts selftests: bonding: Check initial state selftests: team: Add missing config options hv_netvsc: Fix race condition between netvsc_probe and netvsc_remove xen-netback: properly sync TX responses ...

Linus Torvalds committed 2 years ago

Commit 41b9fb32 parents 91481c9 4e192be90 files · +839 −403Browse files

Unified · Split

90 files

Documentation/ABI/testing/sysfs-class-net-queues +11 −11
Documentation/netlink/specs/rt_link.yaml +10 −0
MAINTAINERS +2 −1
drivers/net/dsa/mt7530.c +1 −2
drivers/net/dsa/mv88e6xxx/chip.c +1 −1
drivers/net/dsa/qca/qca8k-8xxx.c +1 −2
drivers/net/ethernet/amd/pds_core/adminq.c +48 −16
drivers/net/ethernet/amd/pds_core/core.c +36 −10
drivers/net/ethernet/amd/pds_core/core.h +1 −1
drivers/net/ethernet/amd/pds_core/debugfs.c +4 −0
drivers/net/ethernet/amd/pds_core/dev.c +8 −8
drivers/net/ethernet/amd/pds_core/devlink.c +2 −1
drivers/net/ethernet/amd/pds_core/fw.c +3 −0
drivers/net/ethernet/amd/pds_core/main.c +22 −4
drivers/net/ethernet/broadcom/bnxt/bnxt_ptp.c +1 −1
drivers/net/ethernet/google/gve/gve_rx.c +4 −4
drivers/net/ethernet/intel/e1000e/e1000.h +20 −0
drivers/net/ethernet/intel/e1000e/ptp.c +15 −7
drivers/net/ethernet/intel/idpf/virtchnl2.h +1 −1
drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c +2 −1
drivers/net/ethernet/marvell/octeontx2/nic/otx2_ethtool.c +0 −1
drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c +1 −2
drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c +3 −4
drivers/net/ethernet/mediatek/mtk_eth_soc.c +4 −1
drivers/net/ethernet/microchip/lan966x/lan966x_port.c +3 −2
drivers/net/ethernet/netronome/nfp/flower/conntrack.c +43 −3
drivers/net/ethernet/stmicro/stmmac/dwmac-imx.c +4 −0
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +3 −0
drivers/net/hyperv/netvsc.c +4 −1
drivers/net/phy/mediatek-ge-soc.c +81 −66
drivers/net/xen-netback/netback.c +40 −44
include/linux/netfilter/ipset/ip_set.h +4 −0
include/net/af_unix.h +14 −6
include/net/ip.h +1 −1
include/net/netfilter/nf_tables.h +2 −0
net/batman-adv/multicast.c +3 −0
net/bridge/br_multicast.c +15 −5
net/bridge/br_private.h +2 −2
net/devlink/port.c +1 −1
net/hsr/hsr_device.c +2 −2
net/ipv4/ip_output.c +6 −6
net/ipv4/ip_sockglue.c +4 −2
net/ipv4/ipmr.c +1 −1
net/ipv4/raw.c +1 −1
net/ipv4/tcp.c +11 −1
net/ipv4/udp.c +1 −1
net/ipv6/addrconf_core.c +14 −7
net/ipv6/ip6_tunnel.c +18 −3
net/llc/af_llc.c +2 −0
net/mptcp/protocol.c +0 −3
net/netfilter/ipset/ip_set_bitmap_gen.h +11 −3
net/netfilter/ipset/ip_set_core.c +28 −9
net/netfilter/ipset/ip_set_hash_gen.h +12 −3
net/netfilter/ipset/ip_set_list_set.c +10 −3
net/netfilter/nf_conntrack_proto_sctp.c +1 −1
net/netfilter/nf_conntrack_proto_tcp.c +6 −4
net/netfilter/nf_log.c +4 −3
net/netfilter/nf_tables_api.c +9 −5
net/netfilter/nft_ct.c +24 −0
net/netfilter/nft_tunnel.c +1 −0
net/nfc/nci/core.c +4 −0
net/smc/smc_core.c +9 −3
net/unix/af_unix.c +6 −8
net/unix/diag.c +1 −1
tools/testing/selftests/drivers/net/bonding/lag_lib.sh +11 −0
tools/testing/selftests/drivers/net/team/config +3 −1
tools/testing/selftests/net/Makefile +5 −4
tools/testing/selftests/net/config +16 −0
tools/testing/selftests/net/forwarding/Makefile +1 −1
tools/testing/selftests/net/lib.sh +4 −1
tools/testing/selftests/net/mptcp/config +3 −0
tools/testing/selftests/net/mptcp/mptcp_join.sh +11 −16
tools/testing/selftests/net/mptcp/mptcp_lib.sh +1 −1
tools/testing/selftests/net/mptcp/settings +1 −1
tools/testing/selftests/net/mptcp/simult_flows.sh +4 −4
tools/testing/selftests/net/net_helper.sh +0 −0
tools/testing/selftests/net/pmtu.sh +9 −9
tools/testing/selftests/net/setup_loopback.sh +0 −0
tools/testing/selftests/net/setup_veth.sh +1 −1
tools/testing/selftests/net/tcp_ao/config +10 −0
tools/testing/selftests/net/tcp_ao/key-management.c +26 −20
tools/testing/selftests/net/tcp_ao/lib/sock.c +8 −4
tools/testing/selftests/net/tcp_ao/rst.c +90 −48
tools/testing/selftests/net/tcp_ao/settings +1 −0
tools/testing/selftests/net/udpgro.sh +2 −2
tools/testing/selftests/net/udpgro_bench.sh +2 −2
tools/testing/selftests/net/udpgro_frglist.sh +3 −3
tools/testing/selftests/net/udpgro_fwd.sh +5 −3
tools/testing/selftests/net/veth.sh +2 −2
tools/testing/selftests/net/xdp_dummy.c +13 −0

Documentation/ABI/testing/sysfs-class-net-queues+11−11

@@ -1,4 +1,4 @@
1	What: /sys/class/<iface>/queues/rx-<queue>/rps_cpus	1	What: /sys/class/net/<iface>/queues/rx-<queue>/rps_cpus
2	Date: March 2010	2	Date: March 2010
3	KernelVersion: 2.6.35	3	KernelVersion: 2.6.35
4	Contact: netdev@vger.kernel.org	4	Contact: netdev@vger.kernel.org
@@ -8,7 +8,7 @@ Description: · 3 unmodified lines
8	network device queue. Possible values depend on the number	8	network device queue. Possible values depend on the number
9	of available CPU(s) in the system.	9	of available CPU(s) in the system.
10		10
11	What: /sys/class/<iface>/queues/rx-<queue>/rps_flow_cnt	11	What: /sys/class/net/<iface>/queues/rx-<queue>/rps_flow_cnt
12	Date: April 2010	12	Date: April 2010
13	KernelVersion: 2.6.35	13	KernelVersion: 2.6.35
14	Contact: netdev@vger.kernel.org	14	Contact: netdev@vger.kernel.org
@@ -16,7 +16,7 @@ Description: · 1 unmodified line
16	Number of Receive Packet Steering flows being currently	16	Number of Receive Packet Steering flows being currently
17	processed by this particular network device receive queue.	17	processed by this particular network device receive queue.
18		18
19	What: /sys/class/<iface>/queues/tx-<queue>/tx_timeout	19	What: /sys/class/net/<iface>/queues/tx-<queue>/tx_timeout
20	Date: November 2011	20	Date: November 2011
21	KernelVersion: 3.3	21	KernelVersion: 3.3
22	Contact: netdev@vger.kernel.org	22	Contact: netdev@vger.kernel.org
@@ -24,7 +24,7 @@ Description: · 1 unmodified line
24	Indicates the number of transmit timeout events seen by this	24	Indicates the number of transmit timeout events seen by this
25	network interface transmit queue.	25	network interface transmit queue.
26		26
27	What: /sys/class/<iface>/queues/tx-<queue>/tx_maxrate	27	What: /sys/class/net/<iface>/queues/tx-<queue>/tx_maxrate
28	Date: March 2015	28	Date: March 2015
29	KernelVersion: 4.1	29	KernelVersion: 4.1
30	Contact: netdev@vger.kernel.org	30	Contact: netdev@vger.kernel.org
@@ -32,7 +32,7 @@ Description: · 1 unmodified line
32	A Mbps max-rate set for the queue, a value of zero means disabled,	32	A Mbps max-rate set for the queue, a value of zero means disabled,
33	default is disabled.	33	default is disabled.
34		34
35	What: /sys/class/<iface>/queues/tx-<queue>/xps_cpus	35	What: /sys/class/net/<iface>/queues/tx-<queue>/xps_cpus
36	Date: November 2010	36	Date: November 2010
37	KernelVersion: 2.6.38	37	KernelVersion: 2.6.38
38	Contact: netdev@vger.kernel.org	38	Contact: netdev@vger.kernel.org
@@ -42,7 +42,7 @@ Description: · 3 unmodified lines
42	network device transmit queue. Possible values depend on the	42	network device transmit queue. Possible values depend on the
43	number of available CPU(s) in the system.	43	number of available CPU(s) in the system.
44		44
45	What: /sys/class/<iface>/queues/tx-<queue>/xps_rxqs	45	What: /sys/class/net/<iface>/queues/tx-<queue>/xps_rxqs
46	Date: June 2018	46	Date: June 2018
47	KernelVersion: 4.18.0	47	KernelVersion: 4.18.0
48	Contact: netdev@vger.kernel.org	48	Contact: netdev@vger.kernel.org
@@ -53,7 +53,7 @@ Description: · 4 unmodified lines
53	number of available receive queue(s) in the network device.	53	number of available receive queue(s) in the network device.
54	Default is disabled.	54	Default is disabled.
55		55
56	What: /sys/class/<iface>/queues/tx-<queue>/byte_queue_limits/hold_time	56	What: /sys/class/net/<iface>/queues/tx-<queue>/byte_queue_limits/hold_time
57	Date: November 2011	57	Date: November 2011
58	KernelVersion: 3.3	58	KernelVersion: 3.3
59	Contact: netdev@vger.kernel.org	59	Contact: netdev@vger.kernel.org
@@ -62,7 +62,7 @@ Description: · 2 unmodified lines
62	of this particular network device transmit queue.	62	of this particular network device transmit queue.
63	Default value is 1000.	63	Default value is 1000.
64		64
65	What: /sys/class/<iface>/queues/tx-<queue>/byte_queue_limits/inflight	65	What: /sys/class/net/<iface>/queues/tx-<queue>/byte_queue_limits/inflight
66	Date: November 2011	66	Date: November 2011
67	KernelVersion: 3.3	67	KernelVersion: 3.3
68	Contact: netdev@vger.kernel.org	68	Contact: netdev@vger.kernel.org
@@ -70,7 +70,7 @@ Description: · 1 unmodified line
70	Indicates the number of bytes (objects) in flight on this	70	Indicates the number of bytes (objects) in flight on this
71	network device transmit queue.	71	network device transmit queue.
72		72
73	What: /sys/class/<iface>/queues/tx-<queue>/byte_queue_limits/limit	73	What: /sys/class/net/<iface>/queues/tx-<queue>/byte_queue_limits/limit
74	Date: November 2011	74	Date: November 2011
75	KernelVersion: 3.3	75	KernelVersion: 3.3
76	Contact: netdev@vger.kernel.org	76	Contact: netdev@vger.kernel.org
@@ -79,7 +79,7 @@ Description: · 2 unmodified lines
79	on this network device transmit queue. This value is clamped	79	on this network device transmit queue. This value is clamped
80	to be within the bounds defined by limit_max and limit_min.	80	to be within the bounds defined by limit_max and limit_min.
81		81
82	What: /sys/class/<iface>/queues/tx-<queue>/byte_queue_limits/limit_max	82	What: /sys/class/net/<iface>/queues/tx-<queue>/byte_queue_limits/limit_max
83	Date: November 2011	83	Date: November 2011
84	KernelVersion: 3.3	84	KernelVersion: 3.3
85	Contact: netdev@vger.kernel.org	85	Contact: netdev@vger.kernel.org
@@ -88,7 +88,7 @@ Description: · 2 unmodified lines
88	queued on this network device transmit queue. See	88	queued on this network device transmit queue. See
89	include/linux/dynamic_queue_limits.h for the default value.	89	include/linux/dynamic_queue_limits.h for the default value.
90		90
91	What: /sys/class/<iface>/queues/tx-<queue>/byte_queue_limits/limit_min	91	What: /sys/class/net/<iface>/queues/tx-<queue>/byte_queue_limits/limit_min
92	Date: November 2011	92	Date: November 2011
93	KernelVersion: 3.3	93	KernelVersion: 3.3
94	Contact: netdev@vger.kernel.org	94	Contact: netdev@vger.kernel.org

Documentation/netlink/specs/rt_link.yaml+10−0

       -
         name: gro-ipv4-max-size
         type: u32
+      -
+        name: dpll-pin
+        type: nest
+        nested-attributes: link-dpll-pin-attrs
   -
     name: af-spec-attrs
     attributes:
       -
         name: used
         type: u8
+  -
+    name: link-dpll-pin-attrs
+    attributes:
+      -
+        name: id
+        type: u32
 sub-messages:
   -

MAINTAINERS+2−1

@@ -15181,6 +15181,7 @@ F: Documentation/networking/net_cachelines/net_device.rst · 15180 unmodified lines
15181	F: drivers/connector/	15181	F: drivers/connector/
15182	F: drivers/net/	15182	F: drivers/net/
15183	F: include/dt-bindings/net/	15183	F: include/dt-bindings/net/
		15184	F: include/linux/cn_proc.h
15184	F: include/linux/etherdevice.h	15185	F: include/linux/etherdevice.h
15185	F: include/linux/fcdevice.h	15186	F: include/linux/fcdevice.h
15186	F: include/linux/fddidevice.h	15187	F: include/linux/fddidevice.h
@@ -15188,6 +15189,7 @@ F: include/linux/hippidevice.h · 1 unmodified line
15188	F: include/linux/if_*	15189	F: include/linux/if_*
15189	F: include/linux/inetdevice.h	15190	F: include/linux/inetdevice.h
15190	F: include/linux/netdevice.h	15191	F: include/linux/netdevice.h
		15192	F: include/uapi/linux/cn_proc.h
15191	F: include/uapi/linux/if_*	15193	F: include/uapi/linux/if_*
15192	F: include/uapi/linux/netdevice.h	15194	F: include/uapi/linux/netdevice.h
15193	X: drivers/net/wireless/	15195	X: drivers/net/wireless/
@@ -18085,7 +18087,6 @@ F: drivers/net/ethernet/qualcomm/emac/ · 2891 unmodified lines
18085		18087
18086	QUALCOMM ETHQOS ETHERNET DRIVER	18088	QUALCOMM ETHQOS ETHERNET DRIVER
18087	M: Vinod Koul <vkoul@kernel.org>	18089	M: Vinod Koul <vkoul@kernel.org>
18088	R: Bhupesh Sharma <bhupesh.sharma@linaro.org>
18089	L: netdev@vger.kernel.org	18090	L: netdev@vger.kernel.org
18090	L: linux-arm-msm@vger.kernel.org	18091	L: linux-arm-msm@vger.kernel.org
18091	S: Maintained	18092	S: Maintained

drivers/net/dsa/mt7530.c+1−2

 	/* MT753x MAC works in 1G full duplex mode for all up-clocked
 	 * variants.
 	 */
-	if (interface == PHY_INTERFACE_MODE_INTERNAL ||
+	if (interface == PHY_INTERFACE_MODE_TRGMII ||
-	    interface == PHY_INTERFACE_MODE_TRGMII ||
 	    (phy_interface_mode_is_8023z(interface))) {
 		speed = SPEED_1000;
 		duplex = DUPLEX_FULL;

drivers/net/dsa/mv88e6xxx/chip.c+1−1

@@ -3659,7 +3659,7 @@ static int mv88e6xxx_mdio_read_c45(struct mii_bus *bus, int phy, int devad, · 3658 unmodified lines
3659	int err;	3659	int err;
3660		3660
3661	if (!chip->info->ops->phy_read_c45)	3661	if (!chip->info->ops->phy_read_c45)
3662	return -EOPNOTSUPP;	3662	return 0xffff;
3663		3663
3664	mv88e6xxx_reg_lock(chip);	3664	mv88e6xxx_reg_lock(chip);
3665	err = chip->info->ops->phy_read_c45(chip, bus, phy, devad, reg, &val);	3665	err = chip->info->ops->phy_read_c45(chip, bus, phy, devad, reg, &val);

drivers/net/dsa/qca/qca8k-8xxx.c+1−2

 	priv->info = of_device_get_match_data(priv->dev);
 	priv->reset_gpio = devm_gpiod_get_optional(priv->dev, "reset",
-						   GPIOD_ASIS);
+						   GPIOD_OUT_HIGH);
 	if (IS_ERR(priv->reset_gpio))
 		return PTR_ERR(priv->reset_gpio);
 	if (priv->reset_gpio) {
-		gpiod_set_value_cansleep(priv->reset_gpio, 1);
 		/* The active low duration must be greater than 10 ms
 		 * and checkpatch.pl wants 20 ms.
 		 */

drivers/net/ethernet/amd/pds_core/adminq.c+48−16

@@ -63,6 +63,15 @@ static int pdsc_process_notifyq(struct pdsc_qcq *qcq) · 62 unmodified lines
63	return nq_work;	63	return nq_work;
64	}	64	}
65		65
		66	static bool pdsc_adminq_inc_if_up(struct pdsc *pdsc)
		67	{
		68	if (pdsc->state & BIT_ULL(PDSC_S_STOPPING_DRIVER) \|\|
		69	pdsc->state & BIT_ULL(PDSC_S_FW_DEAD))
		70	return false;
		71
		72	return refcount_inc_not_zero(&pdsc->adminq_refcnt);
		73	}
		74
66	void pdsc_process_adminq(struct pdsc_qcq *qcq)	75	void pdsc_process_adminq(struct pdsc_qcq *qcq)
67	{	76	{
68	union pds_core_adminq_comp *comp;	77	union pds_core_adminq_comp *comp;
@@ -75,9 +84,9 @@ void pdsc_process_adminq(struct pdsc_qcq *qcq) · 6 unmodified lines
75	int aq_work = 0;	84	int aq_work = 0;
76	int credits;	85	int credits;
77		86
78	/* Don't process AdminQ when shutting down */	87	/* Don't process AdminQ when it's not up */
79	if (pdsc->state & BIT_ULL(PDSC_S_STOPPING_DRIVER)) {	88	if (!pdsc_adminq_inc_if_up(pdsc)) {
80	dev_err(pdsc->dev, "%s: called while PDSC_S_STOPPING_DRIVER\n",	89	dev_err(pdsc->dev, "%s: called while adminq is unavailable\n",
81	__func__);	90	__func__);
82	return;	91	return;
83	}	92	}
@@ -124,6 +133,7 @@ credits: · 40 unmodified lines
124	pds_core_intr_credits(&pdsc->intr_ctrl[qcq->intx],	133	pds_core_intr_credits(&pdsc->intr_ctrl[qcq->intx],
125	credits,	134	credits,
126	PDS_CORE_INTR_CRED_REARM);	135	PDS_CORE_INTR_CRED_REARM);
		136	refcount_dec(&pdsc->adminq_refcnt);
127	}	137	}
128		138
129	void pdsc_work_thread(struct work_struct *work)	139	void pdsc_work_thread(struct work_struct *work)
@@ -135,18 +145,20 @@ void pdsc_work_thread(struct work_struct *work) · 5 unmodified lines
135		145
136	irqreturn_t pdsc_adminq_isr(int irq, void *data)	146	irqreturn_t pdsc_adminq_isr(int irq, void *data)
137	{	147	{
138	struct pdsc_qcq *qcq = data;	148	struct pdsc *pdsc = data;
139	struct pdsc *pdsc = qcq->pdsc;	149	struct pdsc_qcq *qcq;
140		150
141	/* Don't process AdminQ when shutting down */	151	/* Don't process AdminQ when it's not up */
142	if (pdsc->state & BIT_ULL(PDSC_S_STOPPING_DRIVER)) {	152	if (!pdsc_adminq_inc_if_up(pdsc)) {
143	dev_err(pdsc->dev, "%s: called while PDSC_S_STOPPING_DRIVER\n",	153	dev_err(pdsc->dev, "%s: called while adminq is unavailable\n",
144	__func__);	154	__func__);
145	return IRQ_HANDLED;	155	return IRQ_HANDLED;
146	}	156	}
147		157
		158	qcq = &pdsc->adminqcq;
148	queue_work(pdsc->wq, &qcq->work);	159	queue_work(pdsc->wq, &qcq->work);
149	pds_core_intr_mask(&pdsc->intr_ctrl[qcq->intx], PDS_CORE_INTR_MASK_CLEAR);	160	pds_core_intr_mask(&pdsc->intr_ctrl[qcq->intx], PDS_CORE_INTR_MASK_CLEAR);
		161	refcount_dec(&pdsc->adminq_refcnt);
150		162
151	return IRQ_HANDLED;	163	return IRQ_HANDLED;
152	}	164	}
@@ -179,10 +191,16 @@ static int __pdsc_adminq_post(struct pdsc *pdsc, · 26 unmodified lines
179		191
180	/* Check that the FW is running */	192	/* Check that the FW is running */
181	if (!pdsc_is_fw_running(pdsc)) {	193	if (!pdsc_is_fw_running(pdsc)) {
182	u8 fw_status = ioread8(&pdsc->info_regs->fw_status);	194	if (pdsc->info_regs) {
183		195	u8 fw_status =
184	dev_info(pdsc->dev, "%s: post failed - fw not running %#02x:\n",	196	ioread8(&pdsc->info_regs->fw_status);
185	__func__, fw_status);	197
		198	dev_info(pdsc->dev, "%s: post failed - fw not running %#02x:\n",
		199	__func__, fw_status);
		200	} else {
		201	dev_info(pdsc->dev, "%s: post failed - BARs not setup\n",
		202	__func__);
		203	}
186	ret = -ENXIO;	204	ret = -ENXIO;
187		205
188	goto err_out_unlock;	206	goto err_out_unlock;
@@ -230,6 +248,12 @@ int pdsc_adminq_post(struct pdsc *pdsc, · 41 unmodified lines
230	int err = 0;	248	int err = 0;
231	int index;	249	int index;
232		250
		251	if (!pdsc_adminq_inc_if_up(pdsc)) {
		252	dev_dbg(pdsc->dev, "%s: preventing adminq cmd %u\n",
		253	__func__, cmd->opcode);
		254	return -ENXIO;
		255	}
		256
233	wc.qcq = &pdsc->adminqcq;	257	wc.qcq = &pdsc->adminqcq;
234	index = __pdsc_adminq_post(pdsc, &pdsc->adminqcq, cmd, comp, &wc);	258	index = __pdsc_adminq_post(pdsc, &pdsc->adminqcq, cmd, comp, &wc);
235	if (index < 0) {	259	if (index < 0) {
@@ -248,10 +272,16 @@ int pdsc_adminq_post(struct pdsc *pdsc, · 12 unmodified lines
248	break;	272	break;
249		273
250	if (!pdsc_is_fw_running(pdsc)) {	274	if (!pdsc_is_fw_running(pdsc)) {
251	u8 fw_status = ioread8(&pdsc->info_regs->fw_status);	275	if (pdsc->info_regs) {
252		276	u8 fw_status =
253	dev_dbg(pdsc->dev, "%s: post wait failed - fw not running %#02x:\n",	277	ioread8(&pdsc->info_regs->fw_status);
254	__func__, fw_status);	278
		279	dev_dbg(pdsc->dev, "%s: post wait failed - fw not running %#02x:\n",
		280	__func__, fw_status);
		281	} else {
		282	dev_dbg(pdsc->dev, "%s: post wait failed - BARs not setup\n",
		283	__func__);
		284	}
255	err = -ENXIO;	285	err = -ENXIO;
256	break;	286	break;
257	}	287	}
@@ -285,6 +315,8 @@ err_out: · 27 unmodified lines
285	queue_work(pdsc->wq, &pdsc->health_work);	315	queue_work(pdsc->wq, &pdsc->health_work);
286	}	316	}
287		317
		318	refcount_dec(&pdsc->adminq_refcnt);
		319
288	return err;	320	return err;
289	}	321	}
290	EXPORT_SYMBOL_GPL(pdsc_adminq_post);	322	EXPORT_SYMBOL_GPL(pdsc_adminq_post);

drivers/net/ethernet/amd/pds_core/core.c+36−10

 	snprintf(name, sizeof(name), "%s-%d-%s",
 		 PDS_CORE_DRV_NAME, pdsc->pdev->bus->number, qcq->q.name);
-	index = pdsc_intr_alloc(pdsc, name, pdsc_adminq_isr, qcq);
+	index = pdsc_intr_alloc(pdsc, name, pdsc_adminq_isr, pdsc);
 	if (index < 0)
 		return index;
 	qcq->intx = index;
 	int numdescs;
 	int err;
-	if (init)
+	err = pdsc_dev_init(pdsc);
-		err = pdsc_dev_init(pdsc);
-	else
-		err = pdsc_dev_reinit(pdsc);
 	if (err)
 		return err;
 		pdsc_debugfs_add_viftype(pdsc);
 	}
+	refcount_set(&pdsc->adminq_refcnt, 1);
 	clear_bit(PDSC_S_FW_DEAD, &pdsc->state);
 	return 0;
 	if (!pdsc->pdev->is_virtfn)
 		pdsc_devcmd_reset(pdsc);
+	if (pdsc->adminqcq.work.func)
+		cancel_work_sync(&pdsc->adminqcq.work);
 	pdsc_qcq_free(pdsc, &pdsc->notifyqcq);
 	pdsc_qcq_free(pdsc, &pdsc->adminqcq);
 		for (i = 0; i < pdsc->nintrs; i++)
 			pdsc_intr_free(pdsc, i);
-		if (removing) {
+		kfree(pdsc->intr_info);
-			kfree(pdsc->intr_info);
+		pdsc->intr_info = NULL;
-			pdsc->intr_info = NULL;
+		pdsc->nintrs = 0;
-		}
 	}
 	if (pdsc->kern_dbpage) {
 		pdsc->kern_dbpage = NULL;
 	}
+	pci_free_irq_vectors(pdsc->pdev);
 	set_bit(PDSC_S_FW_DEAD, &pdsc->state);
 }
 					   PDS_CORE_INTR_MASK_SET);
 }
+static void pdsc_adminq_wait_and_dec_once_unused(struct pdsc *pdsc)
+{
+	/* The driver initializes the adminq_refcnt to 1 when the adminq is
+	 * allocated and ready for use. Other users/requesters will increment
+	 * the refcnt while in use. If the refcnt is down to 1 then the adminq
+	 * is not in use and the refcnt can be cleared and adminq freed. Before
+	 * calling this function the driver will set PDSC_S_FW_DEAD, which
+	 * prevent subsequent attempts to use the adminq and increment the
+	 * refcnt to fail. This guarantees that this function will eventually
+	 * exit.
+	 */
+	while (!refcount_dec_if_one(&pdsc->adminq_refcnt)) {
+		dev_dbg_ratelimited(pdsc->dev, "%s: adminq in use\n",
+				    __func__);
+		cpu_relax();
+	}
+}
 void pdsc_fw_down(struct pdsc *pdsc)
 {
 	union pds_core_notifyq_comp reset_event = {
 	if (pdsc->pdev->is_virtfn)
 		return;
+	pdsc_adminq_wait_and_dec_once_unused(pdsc);
 	/* Notify clients of fw_down */
 	if (pdsc->fw_reporter)
 		devlink_health_report(pdsc->fw_reporter, "FW down reported", pdsc);
 static void pdsc_check_pci_health(struct pdsc *pdsc)
 {
-	u8 fw_status = ioread8(&pdsc->info_regs->fw_status);
+	u8 fw_status;
+	/* some sort of teardown already in progress */
+	if (!pdsc->info_regs)
+		return;
+	fw_status = ioread8(&pdsc->info_regs->fw_status);
 	/* is PCI broken? */
 	if (fw_status != PDS_RC_BAD_PCI)

drivers/net/ethernet/amd/pds_core/core.h+1−1

 	struct mutex devcmd_lock;	/* lock for dev_cmd operations */
 	struct mutex config_lock;	/* lock for configuration operations */
 	spinlock_t adminq_lock;		/* lock for adminq operations */
+	refcount_t adminq_refcnt;
 	struct pds_core_dev_info_regs __iomem *info_regs;
 	struct pds_core_dev_cmd_regs __iomem *cmd_regs;
 	struct pds_core_intr __iomem *intr_ctrl;
 		       union pds_core_dev_comp *comp, int max_seconds);
 int pdsc_devcmd_init(struct pdsc *pdsc);
 int pdsc_devcmd_reset(struct pdsc *pdsc);
-int pdsc_dev_reinit(struct pdsc *pdsc);
 int pdsc_dev_init(struct pdsc *pdsc);
 void pdsc_reset_prepare(struct pci_dev *pdev);

drivers/net/ethernet/amd/pds_core/debugfs.c+4−0

 void pdsc_debugfs_add_ident(struct pdsc *pdsc)
 {
+	/* This file will already exist in the reset flow */
+	if (debugfs_lookup("identity", pdsc->dentry))
+		return;
 	debugfs_create_file("identity", 0400, pdsc->dentry,
 			    pdsc, &identity_fops);
 }

drivers/net/ethernet/amd/pds_core/dev.c+8−8

 bool pdsc_is_fw_running(struct pdsc *pdsc)
 {
+	if (!pdsc->info_regs)
+		return false;
 	pdsc->fw_status = ioread8(&pdsc->info_regs->fw_status);
 	pdsc->last_fw_time = jiffies;
 	pdsc->last_hb = ioread32(&pdsc->info_regs->fw_heartbeat);
 {
 	int err;
+	if (!pdsc->cmd_regs)
+		return -ENXIO;
 	memcpy_toio(&pdsc->cmd_regs->cmd, cmd, sizeof(*cmd));
 	pdsc_devcmd_dbell(pdsc);
 	err = pdsc_devcmd_wait(pdsc, cmd->opcode, max_seconds);
-	memcpy_fromio(comp, &pdsc->cmd_regs->comp, sizeof(*comp));
 	if ((err == -ENXIO || err == -ETIMEDOUT) && pdsc->wq)
 		queue_work(pdsc->wq, &pdsc->health_work);
+	else
+		memcpy_fromio(comp, &pdsc->cmd_regs->comp, sizeof(*comp));
 	return err;
 }
 	return 0;
 }
-int pdsc_dev_reinit(struct pdsc *pdsc)
-{
-	pdsc_init_devinfo(pdsc);
-	return pdsc_identify(pdsc);
-}
 int pdsc_dev_init(struct pdsc *pdsc)
 {
 	unsigned int nintrs;

drivers/net/ethernet/amd/pds_core/devlink.c+2−1

@@ -111,7 +111,8 @@ int pdsc_dl_info_get(struct devlink dl, struct devlink_info_req req, · 110 unmodified lines
111		111
112	mutex_lock(&pdsc->devcmd_lock);	112	mutex_lock(&pdsc->devcmd_lock);
113	err = pdsc_devcmd_locked(pdsc, &cmd, &comp, pdsc->devcmd_timeout * 2);	113	err = pdsc_devcmd_locked(pdsc, &cmd, &comp, pdsc->devcmd_timeout * 2);
114	memcpy_fromio(&fw_list, pdsc->cmd_regs->data, sizeof(fw_list));	114	if (!err)
		115	memcpy_fromio(&fw_list, pdsc->cmd_regs->data, sizeof(fw_list));
115	mutex_unlock(&pdsc->devcmd_lock);	116	mutex_unlock(&pdsc->devcmd_lock);
116	if (err && err != -EIO)	117	if (err && err != -EIO)
117	return err;	118	return err;

drivers/net/ethernet/amd/pds_core/fw.c+3−0

@@ -107,6 +107,9 @@ int pdsc_firmware_update(struct pdsc pdsc, const struct firmware fw, · 106 unmodified lines
107		107
108	dev_info(pdsc->dev, "Installing firmware\n");	108	dev_info(pdsc->dev, "Installing firmware\n");
109		109
		110	if (!pdsc->cmd_regs)
		111	return -ENXIO;
		112
110	dl = priv_to_devlink(pdsc);	113	dl = priv_to_devlink(pdsc);
111	devlink_flash_update_status_notify(dl, "Preparing to flash",	114	devlink_flash_update_status_notify(dl, "Preparing to flash",
112	NULL, 0, 0);	115	NULL, 0, 0);

drivers/net/ethernet/amd/pds_core/main.c+22−4

 	struct pdsc_dev_bar *bars = pdsc->bars;
 	unsigned int i;
+	pdsc->info_regs = NULL;
+	pdsc->cmd_regs = NULL;
+	pdsc->intr_status = NULL;
+	pdsc->intr_ctrl = NULL;
 	for (i = 0; i < PDS_CORE_BARS_MAX; i++) {
 		if (bars[i].vaddr)
 			pci_iounmap(pdsc->pdev, bars[i].vaddr);
 err_out_teardown:
 	pdsc_teardown(pdsc, PDSC_TEARDOWN_REMOVING);
 err_out_unmap_bars:
-	del_timer_sync(&pdsc->wdtimer);
+	timer_shutdown_sync(&pdsc->wdtimer);
 	if (pdsc->wq)
 		destroy_workqueue(pdsc->wq);
 	mutex_destroy(&pdsc->config_lock);
 		 */
 		pdsc_sriov_configure(pdev, 0);
-		del_timer_sync(&pdsc->wdtimer);
+		timer_shutdown_sync(&pdsc->wdtimer);
 		if (pdsc->wq)
 			destroy_workqueue(pdsc->wq);
 		mutex_destroy(&pdsc->config_lock);
 		mutex_destroy(&pdsc->devcmd_lock);
-		pci_free_irq_vectors(pdev);
 		pdsc_unmap_bars(pdsc);
 		pci_release_regions(pdev);
 	}
 	devlink_free(dl);
 }
+static void pdsc_stop_health_thread(struct pdsc *pdsc)
+{
+	timer_shutdown_sync(&pdsc->wdtimer);
+	if (pdsc->health_work.func)
+		cancel_work_sync(&pdsc->health_work);
+}
+static void pdsc_restart_health_thread(struct pdsc *pdsc)
+{
+	timer_setup(&pdsc->wdtimer, pdsc_wdtimer_cb, 0);
+	mod_timer(&pdsc->wdtimer, jiffies + 1);
+}
 void pdsc_reset_prepare(struct pci_dev *pdev)
 {
 	struct pdsc *pdsc = pci_get_drvdata(pdev);
+	pdsc_stop_health_thread(pdsc);
 	pdsc_fw_down(pdsc);
-	pci_free_irq_vectors(pdev);
 	pdsc_unmap_bars(pdsc);
 	pci_release_regions(pdev);
 	pci_disable_device(pdev);
 	}
 	pdsc_fw_up(pdsc);
+	pdsc_restart_health_thread(pdsc);
 }
 static const struct pci_error_handlers pdsc_err_handler = {

drivers/net/ethernet/broadcom/bnxt/bnxt_ptp.c+1−1

@@ -684,7 +684,7 @@ static void bnxt_stamp_tx_skb(struct bnxt bp, struct sk_buff skb) · 683 unmodified lines
684	timestamp.hwtstamp = ns_to_ktime(ns);	684	timestamp.hwtstamp = ns_to_ktime(ns);
685	skb_tstamp_tx(ptp->tx_skb, &timestamp);	685	skb_tstamp_tx(ptp->tx_skb, &timestamp);
686	} else {	686	} else {
687	netdev_WARN_ONCE(bp->dev,	687	netdev_warn_once(bp->dev,
688	"TS query for TX timer failed rc = %x\n", rc);	688	"TS query for TX timer failed rc = %x\n", rc);
689	}	689	}
690		690

drivers/net/ethernet/google/gve/gve_rx.c+4−4

@@ -356,7 +356,7 @@ static enum pkt_hash_types gve_rss_type(__be16 pkt_flags) · 355 unmodified lines
356		356
357	static struct sk_buff gve_rx_add_frags(struct napi_struct napi,	357	static struct sk_buff gve_rx_add_frags(struct napi_struct napi,
358	struct gve_rx_slot_page_info *page_info,	358	struct gve_rx_slot_page_info *page_info,
359	u16 packet_buffer_size, u16 len,	359	unsigned int truesize, u16 len,
360	struct gve_rx_ctx *ctx)	360	struct gve_rx_ctx *ctx)
361	{	361	{
362	u32 offset = page_info->page_offset + page_info->pad;	362	u32 offset = page_info->page_offset + page_info->pad;
@@ -389,10 +389,10 @@ static struct sk_buff gve_rx_add_frags(struct napi_struct napi, · 26 unmodified lines
389	if (skb != ctx->skb_head) {	389	if (skb != ctx->skb_head) {
390	ctx->skb_head->len += len;	390	ctx->skb_head->len += len;
391	ctx->skb_head->data_len += len;	391	ctx->skb_head->data_len += len;
392	ctx->skb_head->truesize += packet_buffer_size;	392	ctx->skb_head->truesize += truesize;
393	}	393	}
394	skb_add_rx_frag(skb, num_frags, page_info->page,	394	skb_add_rx_frag(skb, num_frags, page_info->page,
395	offset, len, packet_buffer_size);	395	offset, len, truesize);
396		396
397	return ctx->skb_head;	397	return ctx->skb_head;
398	}	398	}
@@ -486,7 +486,7 @@ static struct sk_buff gve_rx_copy_to_pool(struct gve_rx_ring rx, · 87 unmodified lines
486		486
487	memcpy(alloc_page_info.page_address, src, page_info->pad + len);	487	memcpy(alloc_page_info.page_address, src, page_info->pad + len);
488	skb = gve_rx_add_frags(napi, &alloc_page_info,	488	skb = gve_rx_add_frags(napi, &alloc_page_info,
489	rx->packet_buffer_size,	489	PAGE_SIZE,
490	len, ctx);	490	len, ctx);
491		491
492	u64_stats_update_begin(&rx->statss);	492	u64_stats_update_begin(&rx->statss);

drivers/net/ethernet/intel/e1000e/e1000.h+20−0

  * As a result, a shift of INCVALUE_SHIFT_n is used to fit a value of
  * INCVALUE_n into the TIMINCA register allowing 32+8+(24-INCVALUE_SHIFT_n)
  * bits to count nanoseconds leaving the rest for fractional nonseconds.
+ *
+ * Any given INCVALUE also has an associated maximum adjustment value. This
+ * maximum adjustment value is the largest increase (or decrease) which can be
+ * safely applied without overflowing the INCVALUE. Since INCVALUE has
+ * a maximum range of 24 bits, its largest value is 0xFFFFFF.
+ *
+ * To understand where the maximum value comes from, consider the following
+ * equation:
+ *
+ *   new_incval = base_incval + (base_incval * adjustment) / 1billion
+ *
+ * To avoid overflow that means:
+ *   max_incval = base_incval + (base_incval * max_adj) / billion
+ *
+ * Re-arranging:
+ *   max_adj = floor(((max_incval - base_incval) * 1billion) / 1billion)
  */
 #define INCVALUE_96MHZ		125
 #define INCVALUE_SHIFT_96MHZ	17
 #define INCPERIOD_SHIFT_96MHZ	2
 #define INCPERIOD_96MHZ		(12 >> INCPERIOD_SHIFT_96MHZ)
+#define MAX_PPB_96MHZ		23999900 /* 23,999,900 ppb */
 #define INCVALUE_25MHZ		40
 #define INCVALUE_SHIFT_25MHZ	18
 #define INCPERIOD_25MHZ		1
+#define MAX_PPB_25MHZ		599999900 /* 599,999,900 ppb */
 #define INCVALUE_24MHZ		125
 #define INCVALUE_SHIFT_24MHZ	14
 #define INCPERIOD_24MHZ		3
+#define MAX_PPB_24MHZ		999999999 /* 999,999,999 ppb */
 #define INCVALUE_38400KHZ	26
 #define INCVALUE_SHIFT_38400KHZ	19
 #define INCPERIOD_38400KHZ	1
+#define MAX_PPB_38400KHZ	230769100 /* 230,769,100 ppb */
 /* Another drawback of scaling the incvalue by a large factor is the
  * 64-bit SYSTIM register overflows more quickly.  This is dealt with

drivers/net/ethernet/intel/e1000e/ptp.c+15−7

 	switch (hw->mac.type) {
 	case e1000_pch2lan:
+		adapter->ptp_clock_info.max_adj = MAX_PPB_96MHZ;
+		break;
 	case e1000_pch_lpt:
+		if (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)
+			adapter->ptp_clock_info.max_adj = MAX_PPB_96MHZ;
+		else
+			adapter->ptp_clock_info.max_adj = MAX_PPB_25MHZ;
+		break;
 	case e1000_pch_spt:
+		adapter->ptp_clock_info.max_adj = MAX_PPB_24MHZ;
+		break;
 	case e1000_pch_cnp:
 	case e1000_pch_tgp:
 	case e1000_pch_adp:
 	case e1000_pch_lnp:
 	case e1000_pch_ptp:
 	case e1000_pch_nvp:
-		if ((hw->mac.type < e1000_pch_lpt) ||
+		if (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)
-		    (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)) {
+			adapter->ptp_clock_info.max_adj = MAX_PPB_24MHZ;
-			adapter->ptp_clock_info.max_adj = 24000000 - 1;
+		else
-			break;
+			adapter->ptp_clock_info.max_adj = MAX_PPB_38400KHZ;
-		}
+		break;
-		fallthrough;
 	case e1000_82574:
 	case e1000_82583:
-		adapter->ptp_clock_info.max_adj = 600000000 - 1;
+		adapter->ptp_clock_info.max_adj = MAX_PPB_25MHZ;
 		break;
 	default:
 		break;

drivers/net/ethernet/intel/idpf/virtchnl2.h+1−1

@@ -978,7 +978,7 @@ struct virtchnl2_ptype { · 977 unmodified lines
978	u8 proto_id_count;	978	u8 proto_id_count;
979	__le16 pad;	979	__le16 pad;
980	__le16 proto_id[];	980	__le16 proto_id[];
981	};	981	} __packed __aligned(2);
982	VIRTCHNL2_CHECK_STRUCT_LEN(6, virtchnl2_ptype);	982	VIRTCHNL2_CHECK_STRUCT_LEN(6, virtchnl2_ptype);
983		983
984	/**	984	/**

drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c+2−1

@@ -716,7 +716,8 @@ static s32 ixgbe_read_iosf_sb_reg_x550(struct ixgbe_hw *hw, u32 reg_addr, · 715 unmodified lines
716	if ((command & IXGBE_SB_IOSF_CTRL_RESP_STAT_MASK) != 0) {	716	if ((command & IXGBE_SB_IOSF_CTRL_RESP_STAT_MASK) != 0) {
717	error = FIELD_GET(IXGBE_SB_IOSF_CTRL_CMPL_ERR_MASK, command);	717	error = FIELD_GET(IXGBE_SB_IOSF_CTRL_CMPL_ERR_MASK, command);
718	hw_dbg(hw, "Failed to read, error %x\n", error);	718	hw_dbg(hw, "Failed to read, error %x\n", error);
719	return -EIO;	719	ret = -EIO;
		720	goto out;
720	}	721	}
721		722
722	if (!ret)	723	if (!ret)

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

@@ -314,7 +314,6 @@ static int otx2_set_channels(struct net_device *dev, · 313 unmodified lines
314	pfvf->hw.tx_queues = channel->tx_count;	314	pfvf->hw.tx_queues = channel->tx_count;
315	if (pfvf->xdp_prog)	315	if (pfvf->xdp_prog)
316	pfvf->hw.xdp_queues = channel->rx_count;	316	pfvf->hw.xdp_queues = channel->rx_count;
317	pfvf->hw.non_qos_queues = pfvf->hw.tx_queues + pfvf->hw.xdp_queues;
318		317
319	if (if_up)	318	if (if_up)
320	err = dev->netdev_ops->ndo_open(dev);	319	err = dev->netdev_ops->ndo_open(dev);

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

 	/* RQ and SQs are mapped to different CQs,
 	 * so find out max CQ IRQs (i.e CINTs) needed.
 	 */
+	pf->hw.non_qos_queues =  pf->hw.tx_queues + pf->hw.xdp_queues;
 	pf->hw.cint_cnt = max3(pf->hw.rx_queues, pf->hw.tx_queues,
 			       pf->hw.tc_tx_queues);
 		xdp_features_clear_redirect_target(dev);
 	}
-	pf->hw.non_qos_queues += pf->hw.xdp_queues;
 	if (if_up)
 		otx2_open(pf->netdev);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c+3−4

 				     struct otx2_cq_queue *cq,
 				     bool *need_xdp_flush)
 {
-	unsigned char *hard_start, *data;
+	unsigned char *hard_start;
 	int qidx = cq->cq_idx;
 	struct xdp_buff xdp;
 	struct page *page;
 	xdp_init_buff(&xdp, pfvf->rbsize, &cq->xdp_rxq);
-	data = (unsigned char *)phys_to_virt(pa);
+	hard_start = (unsigned char *)phys_to_virt(pa);
-	hard_start = page_address(page);
+	xdp_prepare_buff(&xdp, hard_start, OTX2_HEAD_ROOM,
-	xdp_prepare_buff(&xdp, hard_start, data - hard_start,
 			 cqe->sg.seg_size, false);
 	act = bpf_prog_run_xdp(prog, &xdp);

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

 	}
 	if (MTK_HAS_CAPS(eth->soc->caps, MTK_36BIT_DMA)) {
-		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(36));
+		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(36));
+		if (!err)
+			err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
 		if (err) {
 			dev_err(&pdev->dev, "Wrong DMA config\n");
 			return -EINVAL;

drivers/net/ethernet/microchip/lan966x/lan966x_port.c+3−2

 	lan966x_taprio_speed_set(port, config->speed);
 	/* Also the GIGA_MODE_ENA(1) needs to be set regardless of the
-	 * port speed for QSGMII ports.
+	 * port speed for QSGMII or SGMII ports.
 	 */
-	if (phy_interface_num_ports(config->portmode) == 4)
+	if (phy_interface_num_ports(config->portmode) == 4 ||
+	    config->portmode == PHY_INTERFACE_MODE_SGMII)
 		mode = DEV_MAC_MODE_CFG_GIGA_MODE_ENA_SET(1);
 	lan_wr(config->duplex | mode,

drivers/net/ethernet/netronome/nfp/flower/conntrack.c+43−3

@@ -1424,10 +1424,30 @@ static void nfp_nft_ct_translate_mangle_action(struct flow_action_entry *mangle_ · 1423 unmodified lines
1424	mangle_action->mangle.mask = (__force u32)cpu_to_be32(mangle_action->mangle.mask);	1424	mangle_action->mangle.mask = (__force u32)cpu_to_be32(mangle_action->mangle.mask);
1425	return;	1425	return;
1426		1426
		1427	/* Both struct tcphdr and struct udphdr start with
		1428	* __be16 source;
		1429	* __be16 dest;
		1430	* so we can use the same code for both.
		1431	*/
1427	case FLOW_ACT_MANGLE_HDR_TYPE_TCP:	1432	case FLOW_ACT_MANGLE_HDR_TYPE_TCP:
1428	case FLOW_ACT_MANGLE_HDR_TYPE_UDP:	1433	case FLOW_ACT_MANGLE_HDR_TYPE_UDP:
1429	mangle_action->mangle.val = (__force u16)cpu_to_be16(mangle_action->mangle.val);	1434	if (mangle_action->mangle.offset == offsetof(struct tcphdr, source)) {
1430	mangle_action->mangle.mask = (__force u16)cpu_to_be16(mangle_action->mangle.mask);	1435	mangle_action->mangle.val =
		1436	(__force u32)cpu_to_be32(mangle_action->mangle.val << 16);
		1437	/* The mask of mangle action is inverse mask,
		1438	* so clear the dest tp port with 0xFFFF to
		1439	* instead of rotate-left operation.
		1440	*/
		1441	mangle_action->mangle.mask =
		1442	(__force u32)cpu_to_be32(mangle_action->mangle.mask << 16 \| 0xFFFF);
		1443	}
		1444	if (mangle_action->mangle.offset == offsetof(struct tcphdr, dest)) {
		1445	mangle_action->mangle.offset = 0;
		1446	mangle_action->mangle.val =
		1447	(__force u32)cpu_to_be32(mangle_action->mangle.val);
		1448	mangle_action->mangle.mask =
		1449	(__force u32)cpu_to_be32(mangle_action->mangle.mask);
		1450	}
1431	return;	1451	return;
1432		1452
1433	default:	1453	default:
@@ -1864,10 +1884,30 @@ int nfp_fl_ct_handle_post_ct(struct nfp_flower_priv *priv, · 430 unmodified lines
1864	{	1884	{
1865	struct flow_rule *rule = flow_cls_offload_flow_rule(flow);	1885	struct flow_rule *rule = flow_cls_offload_flow_rule(flow);
1866	struct nfp_fl_ct_flow_entry *ct_entry;	1886	struct nfp_fl_ct_flow_entry *ct_entry;
		1887	struct flow_action_entry *ct_goto;
1867	struct nfp_fl_ct_zone_entry *zt;	1888	struct nfp_fl_ct_zone_entry *zt;
		1889	struct flow_action_entry *act;
1868	bool wildcarded = false;	1890	bool wildcarded = false;
1869	struct flow_match_ct ct;	1891	struct flow_match_ct ct;
1870	struct flow_action_entry *ct_goto;	1892	int i;
		1893
		1894	flow_action_for_each(i, act, &rule->action) {
		1895	switch (act->id) {
		1896	case FLOW_ACTION_REDIRECT:
		1897	case FLOW_ACTION_REDIRECT_INGRESS:
		1898	case FLOW_ACTION_MIRRED:
		1899	case FLOW_ACTION_MIRRED_INGRESS:
		1900	if (act->dev->rtnl_link_ops &&
		1901	!strcmp(act->dev->rtnl_link_ops->kind, "openvswitch")) {
		1902	NL_SET_ERR_MSG_MOD(extack,
		1903	"unsupported offload: out port is openvswitch internal port");
		1904	return -EOPNOTSUPP;
		1905	}
		1906	break;
		1907	default:
		1908	break;
		1909	}
		1910	}
1871		1911
1872	flow_rule_match_ct(rule, &ct);	1912	flow_rule_match_ct(rule, &ct);
1873	if (!ct.mask->ct_zone) {	1913	if (!ct.mask->ct_zone) {

drivers/net/ethernet/stmicro/stmmac/dwmac-imx.c+4−0

 	if (data->flags & STMMAC_FLAG_HWTSTAMP_CORRECT_LATENCY)
 		plat_dat->flags |= STMMAC_FLAG_HWTSTAMP_CORRECT_LATENCY;
+	/* Default TX Q0 to use TSO and rest TXQ for TBS */
+	for (int i = 1; i < plat_dat->tx_queues_to_use; i++)
+		plat_dat->tx_queues_cfg[i].tbs_en = 1;
 	plat_dat->host_dma_width = dwmac->ops->addr_width;
 	plat_dat->init = imx_dwmac_init;
 	plat_dat->exit = imx_dwmac_exit;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+3−0

@@ -3932,6 +3932,9 @@ static int __stmmac_open(struct net_device *dev, · 3931 unmodified lines
3932	priv->rx_copybreak = STMMAC_RX_COPYBREAK;	3932	priv->rx_copybreak = STMMAC_RX_COPYBREAK;
3933		3933
3934	buf_sz = dma_conf->dma_buf_sz;	3934	buf_sz = dma_conf->dma_buf_sz;
		3935	for (int i = 0; i < MTL_MAX_TX_QUEUES; i++)
		3936	if (priv->dma_conf.tx_queue[i].tbs & STMMAC_TBS_EN)
		3937	dma_conf->tx_queue[i].tbs = priv->dma_conf.tx_queue[i].tbs;
3935	memcpy(&priv->dma_conf, dma_conf, sizeof(*dma_conf));	3938	memcpy(&priv->dma_conf, dma_conf, sizeof(*dma_conf));
3936		3939
3937	stmmac_reset_queues_param(priv);	3940	stmmac_reset_queues_param(priv);

drivers/net/hyperv/netvsc.c+4−1

 	/* Disable NAPI and disassociate its context from the device. */
 	for (i = 0; i < net_device->num_chn; i++) {
 		/* See also vmbus_reset_channel_cb(). */
-		napi_disable(&net_device->chan_table[i].napi);
+		/* only disable enabled NAPI channel */
+		if (i < ndev->real_num_rx_queues)
+			napi_disable(&net_device->chan_table[i].napi);
 		netif_napi_del(&net_device->chan_table[i].napi);
 	}

drivers/net/phy/mediatek-ge-soc.c+81−66

 	u16 reg, val;
 	if (phydev->drv->phy_id == MTK_GPHY_ID_MT7988)
-		bias = -2;
+		bias = -1;
 	val = clamp_val(bias + tx_r50_cal_val, 0, 63);
 static void mt798x_phy_common_finetune(struct phy_device *phydev)
 {
 	phy_select_page(phydev, MTK_PHY_PAGE_EXTENDED_52B5);
+	/* SlvDSPreadyTime = 24, MasDSPreadyTime = 24 */
+	__phy_write(phydev, 0x11, 0xc71);
+	__phy_write(phydev, 0x12, 0xc);
+	__phy_write(phydev, 0x10, 0x8fae);
 	/* EnabRandUpdTrig = 1 */
 	__phy_write(phydev, 0x11, 0x2f00);
 	__phy_write(phydev, 0x12, 0xe);
 	__phy_write(phydev, 0x12, 0x0);
 	__phy_write(phydev, 0x10, 0x83aa);
-	/* TrFreeze = 0 */
+	/* FfeUpdGainForce = 1(Enable), FfeUpdGainForceVal = 4 */
+	__phy_write(phydev, 0x11, 0x240);
+	__phy_write(phydev, 0x12, 0x0);
+	__phy_write(phydev, 0x10, 0x9680);
+	/* TrFreeze = 0 (mt7988 default) */
 	__phy_write(phydev, 0x11, 0x0);
 	__phy_write(phydev, 0x12, 0x0);
 	__phy_write(phydev, 0x10, 0x9686);
+	/* SSTrKp100 = 5 */
+	/* SSTrKf100 = 6 */
+	/* SSTrKp1000Mas = 5 */
+	/* SSTrKf1000Mas = 6 */
 	/* SSTrKp1000Slv = 5 */
+	/* SSTrKf1000Slv = 6 */
 	__phy_write(phydev, 0x11, 0xbaef);
 	__phy_write(phydev, 0x12, 0x2e);
 	__phy_write(phydev, 0x10, 0x968c);
+	phy_restore_page(phydev, MTK_PHY_PAGE_STANDARD, 0);
+}
+static void mt7981_phy_finetune(struct phy_device *phydev)
+{
+	u16 val[8] = { 0x01ce, 0x01c1,
+		       0x020f, 0x0202,
+		       0x03d0, 0x03c0,
+		       0x0013, 0x0005 };
+	int i, k;
+	/* 100M eye finetune:
+	 * Keep middle level of TX MLT3 shapper as default.
+	 * Only change TX MLT3 overshoot level here.
+	 */
+	for (k = 0, i = 1; i < 12; i++) {
+		if (i % 3 == 0)
+			continue;
+		phy_write_mmd(phydev, MDIO_MMD_VEND1, i, val[k++]);
+	}
+	phy_select_page(phydev, MTK_PHY_PAGE_EXTENDED_52B5);
+	/* ResetSyncOffset = 6 */
+	__phy_write(phydev, 0x11, 0x600);
+	__phy_write(phydev, 0x12, 0x0);
+	__phy_write(phydev, 0x10, 0x8fc0);
+	/* VgaDecRate = 1 */
+	__phy_write(phydev, 0x11, 0x4c2a);
+	__phy_write(phydev, 0x12, 0x3e);
+	__phy_write(phydev, 0x10, 0x8fa4);
 	/* MrvlTrFix100Kp = 3, MrvlTrFix100Kf = 2,
 	 * MrvlTrFix1000Kp = 3, MrvlTrFix1000Kf = 2
 	__phy_write(phydev, 0x10, 0x8ec0);
 	phy_restore_page(phydev, MTK_PHY_PAGE_STANDARD, 0);
-	/* TR_OPEN_LOOP_EN = 1, lpf_x_average = 9*/
+	/* TR_OPEN_LOOP_EN = 1, lpf_x_average = 9 */
 	phy_modify_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RG_DEV1E_REG234,
 		       MTK_PHY_TR_OPEN_LOOP_EN_MASK | MTK_PHY_LPF_X_AVERAGE_MASK,
 		       BIT(0) | FIELD_PREP(MTK_PHY_LPF_X_AVERAGE_MASK, 0x9));
 	phy_write_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_LDO_OUTPUT_V, 0x2222);
 }
-static void mt7981_phy_finetune(struct phy_device *phydev)
-{
-	u16 val[8] = { 0x01ce, 0x01c1,
-		       0x020f, 0x0202,
-		       0x03d0, 0x03c0,
-		       0x0013, 0x0005 };
-	int i, k;
-	/* 100M eye finetune:
-	 * Keep middle level of TX MLT3 shapper as default.
-	 * Only change TX MLT3 overshoot level here.
-	 */
-	for (k = 0, i = 1; i < 12; i++) {
-		if (i % 3 == 0)
-			continue;
-		phy_write_mmd(phydev, MDIO_MMD_VEND1, i, val[k++]);
-	}
-	phy_select_page(phydev, MTK_PHY_PAGE_EXTENDED_52B5);
-	/* SlvDSPreadyTime = 24, MasDSPreadyTime = 24 */
-	__phy_write(phydev, 0x11, 0xc71);
-	__phy_write(phydev, 0x12, 0xc);
-	__phy_write(phydev, 0x10, 0x8fae);
-	/* ResetSyncOffset = 6 */
-	__phy_write(phydev, 0x11, 0x600);
-	__phy_write(phydev, 0x12, 0x0);
-	__phy_write(phydev, 0x10, 0x8fc0);
-	/* VgaDecRate = 1 */
-	__phy_write(phydev, 0x11, 0x4c2a);
-	__phy_write(phydev, 0x12, 0x3e);
-	__phy_write(phydev, 0x10, 0x8fa4);
-	/* FfeUpdGainForce = 4 */
-	__phy_write(phydev, 0x11, 0x240);
-	__phy_write(phydev, 0x12, 0x0);
-	__phy_write(phydev, 0x10, 0x9680);
-	phy_restore_page(phydev, MTK_PHY_PAGE_STANDARD, 0);
-}
 static void mt7988_phy_finetune(struct phy_device *phydev)
 {
 	u16 val[12] = { 0x0187, 0x01cd, 0x01c8, 0x0182,
 	/* TCT finetune */
 	phy_write_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RG_TX_FILTER, 0x5);
-	/* Disable TX power saving */
-	phy_modify_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RXADC_CTRL_RG7,
-		       MTK_PHY_DA_AD_BUF_BIAS_LP_MASK, 0x3 << 8);
 	phy_select_page(phydev, MTK_PHY_PAGE_EXTENDED_52B5);
-	/* SlvDSPreadyTime = 24, MasDSPreadyTime = 12 */
-	__phy_write(phydev, 0x11, 0x671);
-	__phy_write(phydev, 0x12, 0xc);
-	__phy_write(phydev, 0x10, 0x8fae);
 	/* ResetSyncOffset = 5 */
 	__phy_write(phydev, 0x11, 0x500);
 	__phy_write(phydev, 0x12, 0x0);
 	/* VgaDecRate is 1 at default on mt7988 */
-	phy_restore_page(phydev, MTK_PHY_PAGE_STANDARD, 0);
+	/* MrvlTrFix100Kp = 6, MrvlTrFix100Kf = 7,
+	 * MrvlTrFix1000Kp = 6, MrvlTrFix1000Kf = 7
+	 */
+	__phy_write(phydev, 0x11, 0xb90a);
+	__phy_write(phydev, 0x12, 0x6f);
+	__phy_write(phydev, 0x10, 0x8f82);
+	/* RemAckCntLimitCtrl = 1 */
+	__phy_write(phydev, 0x11, 0xfbba);
+	__phy_write(phydev, 0x12, 0xc3);
+	__phy_write(phydev, 0x10, 0x87f8);
-	phy_select_page(phydev, MTK_PHY_PAGE_EXTENDED_2A30);
-	/* TxClkOffset = 2 */
-	__phy_modify(phydev, MTK_PHY_ANARG_RG, MTK_PHY_TCLKOFFSET_MASK,
-		     FIELD_PREP(MTK_PHY_TCLKOFFSET_MASK, 0x2));
 	phy_restore_page(phydev, MTK_PHY_PAGE_STANDARD, 0);
+	/* TR_OPEN_LOOP_EN = 1, lpf_x_average = 10 */
+	phy_modify_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RG_DEV1E_REG234,
+		       MTK_PHY_TR_OPEN_LOOP_EN_MASK | MTK_PHY_LPF_X_AVERAGE_MASK,
+		       BIT(0) | FIELD_PREP(MTK_PHY_LPF_X_AVERAGE_MASK, 0xa));
+	/* rg_tr_lpf_cnt_val = 1023 */
+	phy_write_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RG_LPF_CNT_VAL, 0x3ff);
 }
 static void mt798x_phy_eee(struct phy_device *phydev)
 		       MTK_PHY_LPI_SLV_SEND_TX_EN,
 		       FIELD_PREP(MTK_PHY_LPI_SLV_SEND_TX_TIMER_MASK, 0x120));
-	phy_modify_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RG_DEV1E_REG239,
+	/* Keep MTK_PHY_LPI_SEND_LOC_TIMER as 375 */
-		       MTK_PHY_LPI_SEND_LOC_TIMER_MASK |
+	phy_clear_bits_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RG_DEV1E_REG239,
-		       MTK_PHY_LPI_TXPCS_LOC_RCV,
+			   MTK_PHY_LPI_TXPCS_LOC_RCV);
-		       FIELD_PREP(MTK_PHY_LPI_SEND_LOC_TIMER_MASK, 0x117));
+	/* This also fixes some IoT issues, such as CH340 */
 	phy_modify_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RG_DEV1E_REG2C7,
 		       MTK_PHY_MAX_GAIN_MASK | MTK_PHY_MIN_GAIN_MASK,
 		       FIELD_PREP(MTK_PHY_MAX_GAIN_MASK, 0x8) |
 	__phy_write(phydev, 0x12, 0x0);
 	__phy_write(phydev, 0x10, 0x9690);
-	/* REG_EEE_st2TrKf1000 = 3 */
+	/* REG_EEE_st2TrKf1000 = 2 */
 	__phy_write(phydev, 0x11, 0x114f);
 	__phy_write(phydev, 0x12, 0x2);
 	__phy_write(phydev, 0x10, 0x969a);
 	__phy_write(phydev, 0x12, 0x0);
 	__phy_write(phydev, 0x10, 0x96b8);
-	/* REGEEE_wake_slv_tr_wait_dfesigdet_en = 1 */
+	/* REGEEE_wake_slv_tr_wait_dfesigdet_en = 0 */
 	__phy_write(phydev, 0x11, 0x1463);
 	__phy_write(phydev, 0x12, 0x0);
 	__phy_write(phydev, 0x10, 0x96ca);
 	if (err)
 		return err;
+	/* Disable TX power saving at probing to:
+	 * 1. Meet common mode compliance test criteria
+	 * 2. Make sure that TX-VCM calibration works fine
+	 */
+	phy_modify_mmd(phydev, MDIO_MMD_VEND1, MTK_PHY_RXADC_CTRL_RG7,
+		       MTK_PHY_DA_AD_BUF_BIAS_LP_MASK, 0x3 << 8);
 	return mt798x_phy_calibration(phydev);
 }

drivers/net/xen-netback/netback.c+40−44

 module_param(provides_xdp_headroom, bool, 0644);
 static void xenvif_idx_release(struct xenvif_queue *queue, u16 pending_idx,
-			       u8 status);
+			       s8 status);
 static void make_tx_response(struct xenvif_queue *queue,
-			     struct xen_netif_tx_request *txp,
+			     const struct xen_netif_tx_request *txp,
 			     unsigned int extra_count,
-			     s8       st);
+			     s8 status);
-static void push_tx_responses(struct xenvif_queue *queue);
 static void xenvif_idx_unmap(struct xenvif_queue *queue, u16 pending_idx);
 			  unsigned int extra_count, RING_IDX end)
 {
 	RING_IDX cons = queue->tx.req_cons;
-	unsigned long flags;
 	do {
-		spin_lock_irqsave(&queue->response_lock, flags);
 		make_tx_response(queue, txp, extra_count, XEN_NETIF_RSP_ERROR);
-		push_tx_responses(queue);
-		spin_unlock_irqrestore(&queue->response_lock, flags);
 		if (cons == end)
 			break;
 		RING_COPY_REQUEST(&queue->tx, cons++, txp);
 	for (shinfo->nr_frags = 0; nr_slots > 0 && shinfo->nr_frags < MAX_SKB_FRAGS;
 	     nr_slots--) {
 		if (unlikely(!txp->size)) {
-			unsigned long flags;
-			spin_lock_irqsave(&queue->response_lock, flags);
 			make_tx_response(queue, txp, 0, XEN_NETIF_RSP_OKAY);
-			push_tx_responses(queue);
-			spin_unlock_irqrestore(&queue->response_lock, flags);
 			++txp;
 			continue;
 		}
 		for (shinfo->nr_frags = 0; shinfo->nr_frags < nr_slots; ++txp) {
 			if (unlikely(!txp->size)) {
-				unsigned long flags;
-				spin_lock_irqsave(&queue->response_lock, flags);
 				make_tx_response(queue, txp, 0,
 						 XEN_NETIF_RSP_OKAY);
-				push_tx_responses(queue);
-				spin_unlock_irqrestore(&queue->response_lock,
-						       flags);
 				continue;
 			}
 					 (ret == 0) ?
 					 XEN_NETIF_RSP_OKAY :
 					 XEN_NETIF_RSP_ERROR);
-			push_tx_responses(queue);
 			continue;
 		}
 			make_tx_response(queue, &txreq, extra_count,
 					 XEN_NETIF_RSP_OKAY);
-			push_tx_responses(queue);
 			continue;
 		}
 	return work_done;
 }
+static void _make_tx_response(struct xenvif_queue *queue,
+			     const struct xen_netif_tx_request *txp,
+			     unsigned int extra_count,
+			     s8 status)
+{
+	RING_IDX i = queue->tx.rsp_prod_pvt;
+	struct xen_netif_tx_response *resp;
+	resp = RING_GET_RESPONSE(&queue->tx, i);
+	resp->id     = txp->id;
+	resp->status = status;
+	while (extra_count-- != 0)
+		RING_GET_RESPONSE(&queue->tx, ++i)->status = XEN_NETIF_RSP_NULL;
+	queue->tx.rsp_prod_pvt = ++i;
+}
+static void push_tx_responses(struct xenvif_queue *queue)
+{
+	int notify;
+	RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->tx, notify);
+	if (notify)
+		notify_remote_via_irq(queue->tx_irq);
+}
 static void xenvif_idx_release(struct xenvif_queue *queue, u16 pending_idx,
-			       u8 status)
+			       s8 status)
 {
 	struct pending_tx_info *pending_tx_info;
 	pending_ring_idx_t index;
 	spin_lock_irqsave(&queue->response_lock, flags);
-	make_tx_response(queue, &pending_tx_info->req,
+	_make_tx_response(queue, &pending_tx_info->req,
-			 pending_tx_info->extra_count, status);
+			  pending_tx_info->extra_count, status);
 	/* Release the pending index before pusing the Tx response so
 	 * its available before a new Tx request is pushed by the
 	spin_unlock_irqrestore(&queue->response_lock, flags);
 }
 static void make_tx_response(struct xenvif_queue *queue,
-			     struct xen_netif_tx_request *txp,
+			     const struct xen_netif_tx_request *txp,
 			     unsigned int extra_count,
-			     s8       st)
+			     s8 status)
 {
-	RING_IDX i = queue->tx.rsp_prod_pvt;
+	unsigned long flags;
-	struct xen_netif_tx_response *resp;
-	resp = RING_GET_RESPONSE(&queue->tx, i);
-	resp->id     = txp->id;
-	resp->status = st;
-	while (extra_count-- != 0)
-		RING_GET_RESPONSE(&queue->tx, ++i)->status = XEN_NETIF_RSP_NULL;
-	queue->tx.rsp_prod_pvt = ++i;
+	spin_lock_irqsave(&queue->response_lock, flags);
-}
-static void push_tx_responses(struct xenvif_queue *queue)
+	_make_tx_response(queue, txp, extra_count, status);
-{
+	push_tx_responses(queue);
-	int notify;
-	RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&queue->tx, notify);
+	spin_unlock_irqrestore(&queue->response_lock, flags);
-	if (notify)
-		notify_remote_via_irq(queue->tx_irq);
 }
 static void xenvif_idx_unmap(struct xenvif_queue *queue, u16 pending_idx)

include/linux/netfilter/ipset/ip_set.h+4−0

 	/* Return true if "b" set is the same as "a"
 	 * according to the create set parameters */
 	bool (*same_set)(const struct ip_set *a, const struct ip_set *b);
+	/* Cancel ongoing garbage collectors before destroying the set*/
+	void (*cancel_gc)(struct ip_set *set);
 	/* Region-locking is used */
 	bool region_lock;
 };
 /* A generic IP set */
 struct ip_set {
+	/* For call_cru in destroy */
+	struct rcu_head rcu;
 	/* The name of the set */
 	char name[IPSET_MAXNAMELEN];
 	/* Lock protecting the set data */

include/net/af_unix.h+14−6

 #define UNIXCB(skb)	(*(struct unix_skb_parms *)&((skb)->cb))
-#define unix_state_lock(s)	spin_lock(&unix_sk(s)->lock)
-#define unix_state_unlock(s)	spin_unlock(&unix_sk(s)->lock)
-#define unix_state_lock_nested(s) \
-				spin_lock_nested(&unix_sk(s)->lock, \
-				SINGLE_DEPTH_NESTING)
 /* The AF_UNIX socket */
 struct unix_sock {
 	/* WARNING: sk has to be the first member */
 #define unix_sk(ptr) container_of_const(ptr, struct unix_sock, sk)
 #define unix_peer(sk) (unix_sk(sk)->peer)
+#define unix_state_lock(s)	spin_lock(&unix_sk(s)->lock)
+#define unix_state_unlock(s)	spin_unlock(&unix_sk(s)->lock)
+enum unix_socket_lock_class {
+	U_LOCK_NORMAL,
+	U_LOCK_SECOND,	/* for double locking, see unix_state_double_lock(). */
+	U_LOCK_DIAG, /* used while dumping icons, see sk_diag_dump_icons(). */
+};
+static inline void unix_state_lock_nested(struct sock *sk,
+				   enum unix_socket_lock_class subclass)
+{
+	spin_lock_nested(&unix_sk(sk)->lock, subclass);
+}
 #define peer_wait peer_wq.wait
 long unix_inq_len(struct sock *sk);

include/net/ip.h+1−1

@@ -767,7 +767,7 @@ int ip_options_rcv_srr(struct sk_buff skb, struct net_device dev); · 766 unmodified lines
767	* Functions provided by ip_sockglue.c	767	* Functions provided by ip_sockglue.c
768	*/	768	*/
769		769
770	void ipv4_pktinfo_prepare(const struct sock sk, struct sk_buff skb);	770	void ipv4_pktinfo_prepare(const struct sock sk, struct sk_buff skb, bool drop_dst);
771	void ip_cmsg_recv_offset(struct msghdr msg, struct sock sk,	771	void ip_cmsg_recv_offset(struct msghdr msg, struct sock sk,
772	struct sk_buff *skb, int tlen, int offset);	772	struct sk_buff *skb, int tlen, int offset);
773	int ip_cmsg_send(struct sock sk, struct msghdr msg,	773	int ip_cmsg_send(struct sock sk, struct msghdr msg,

include/net/netfilter/nf_tables.h+2−0

  *	@type: stateful object numeric type
  *	@owner: module owner
  *	@maxattr: maximum netlink attribute
+ *	@family: address family for AF-specific object types
  *	@policy: netlink attribute policy
  */
 struct nft_object_type {
 	struct list_head		list;
 	u32				type;
 	unsigned int                    maxattr;
+	u8				family;
 	struct module			*owner;
 	const struct nla_policy		*policy;
 };

net/batman-adv/multicast.c+3−0

 	cancel_delayed_work_sync(&bat_priv->mcast.work);
 	batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_MCAST, 2);
+	batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_MCAST_TRACKER, 1);
 	batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_MCAST, 2);
 	/* safely calling outside of worker, as worker was canceled above */
 				      BATADV_MCAST_WANT_NO_RTR4);
 	batadv_mcast_want_rtr6_update(bat_priv, orig,
 				      BATADV_MCAST_WANT_NO_RTR6);
+	batadv_mcast_have_mc_ptype_update(bat_priv, orig,
+					  BATADV_MCAST_HAVE_MC_PTYPE_CAPA);
 	spin_unlock_bh(&orig->mcast_handler_lock);
 }

net/bridge/br_multicast.c+15−5

 }
 #endif
+static void br_multicast_query_delay_expired(struct timer_list *t)
+{
+}
 static void br_multicast_select_own_querier(struct net_bridge_mcast *brmctx,
 					    struct br_ip *ip,
 					    struct sk_buff *skb)
 				unsigned long max_delay)
 {
 	if (!timer_pending(&query->timer))
-		query->delay_time = jiffies + max_delay;
+		mod_timer(&query->delay_timer, jiffies + max_delay);
 	mod_timer(&query->timer, jiffies + brmctx->multicast_querier_interval);
 }
 	brmctx->multicast_querier_interval = 255 * HZ;
 	brmctx->multicast_membership_interval = 260 * HZ;
-	brmctx->ip4_other_query.delay_time = 0;
 	brmctx->ip4_querier.port_ifidx = 0;
 	seqcount_spinlock_init(&brmctx->ip4_querier.seq, &br->multicast_lock);
 	brmctx->multicast_igmp_version = 2;
 #if IS_ENABLED(CONFIG_IPV6)
 	brmctx->multicast_mld_version = 1;
-	brmctx->ip6_other_query.delay_time = 0;
 	brmctx->ip6_querier.port_ifidx = 0;
 	seqcount_spinlock_init(&brmctx->ip6_querier.seq, &br->multicast_lock);
 #endif
 		    br_ip4_multicast_local_router_expired, 0);
 	timer_setup(&brmctx->ip4_other_query.timer,
 		    br_ip4_multicast_querier_expired, 0);
+	timer_setup(&brmctx->ip4_other_query.delay_timer,
+		    br_multicast_query_delay_expired, 0);
 	timer_setup(&brmctx->ip4_own_query.timer,
 		    br_ip4_multicast_query_expired, 0);
 #if IS_ENABLED(CONFIG_IPV6)
 		    br_ip6_multicast_local_router_expired, 0);
 	timer_setup(&brmctx->ip6_other_query.timer,
 		    br_ip6_multicast_querier_expired, 0);
+	timer_setup(&brmctx->ip6_other_query.delay_timer,
+		    br_multicast_query_delay_expired, 0);
 	timer_setup(&brmctx->ip6_own_query.timer,
 		    br_ip6_multicast_query_expired, 0);
 #endif
 {
 	del_timer_sync(&brmctx->ip4_mc_router_timer);
 	del_timer_sync(&brmctx->ip4_other_query.timer);
+	del_timer_sync(&brmctx->ip4_other_query.delay_timer);
 	del_timer_sync(&brmctx->ip4_own_query.timer);
 #if IS_ENABLED(CONFIG_IPV6)
 	del_timer_sync(&brmctx->ip6_mc_router_timer);
 	del_timer_sync(&brmctx->ip6_other_query.timer);
+	del_timer_sync(&brmctx->ip6_other_query.delay_timer);
 	del_timer_sync(&brmctx->ip6_own_query.timer);
 #endif
 }
 	max_delay = brmctx->multicast_query_response_interval;
 	if (!timer_pending(&brmctx->ip4_other_query.timer))
-		brmctx->ip4_other_query.delay_time = jiffies + max_delay;
+		mod_timer(&brmctx->ip4_other_query.delay_timer,
+			  jiffies + max_delay);
 	br_multicast_start_querier(brmctx, &brmctx->ip4_own_query);
 #if IS_ENABLED(CONFIG_IPV6)
 	if (!timer_pending(&brmctx->ip6_other_query.timer))
-		brmctx->ip6_other_query.delay_time = jiffies + max_delay;
+		mod_timer(&brmctx->ip6_other_query.delay_timer,
+			  jiffies + max_delay);
 	br_multicast_start_querier(brmctx, &brmctx->ip6_own_query);
 #endif

net/bridge/br_private.h+2−2

@@ -78,7 +78,7 @@ struct bridge_mcast_own_query { · 77 unmodified lines
78	/* other querier */	78	/* other querier */
79	struct bridge_mcast_other_query {	79	struct bridge_mcast_other_query {
80	struct timer_list timer;	80	struct timer_list timer;
81	unsigned long delay_time;	81	struct timer_list delay_timer;
82	};	82	};
83		83
84	/* selected querier */	84	/* selected querier */
@@ -1159,7 +1159,7 @@ __br_multicast_querier_exists(struct net_bridge_mcast *brmctx, · 1074 unmodified lines
1159	own_querier_enabled = false;	1159	own_querier_enabled = false;
1160	}	1160	}
1161		1161
1162	return time_is_before_jiffies(querier->delay_time) &&	1162	return !timer_pending(&querier->delay_timer) &&
1163	(own_querier_enabled \|\| timer_pending(&querier->timer));	1163	(own_querier_enabled \|\| timer_pending(&querier->timer));
1164	}	1164	}
1165		1165

net/devlink/port.c+1−1

@@ -674,7 +674,7 @@ static int devlink_port_function_validate(struct devlink_port *devlink_port, · 673 unmodified lines
674	return -EOPNOTSUPP;	674	return -EOPNOTSUPP;
675	}	675	}
676	if (tb[DEVLINK_PORT_FN_ATTR_STATE] && !ops->port_fn_state_set) {	676	if (tb[DEVLINK_PORT_FN_ATTR_STATE] && !ops->port_fn_state_set) {
677	NL_SET_ERR_MSG_ATTR(extack, tb[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR],	677	NL_SET_ERR_MSG_ATTR(extack, tb[DEVLINK_PORT_FN_ATTR_STATE],
678	"Function does not support state setting");	678	"Function does not support state setting");
679	return -EOPNOTSUPP;	679	return -EOPNOTSUPP;
680	}	680	}

net/hsr/hsr_device.c+2−2

@@ -308,7 +308,7 @@ static void send_hsr_supervision_frame(struct hsr_port *master, · 307 unmodified lines
308		308
309	skb = hsr_init_skb(master);	309	skb = hsr_init_skb(master);
310	if (!skb) {	310	if (!skb) {
311	WARN_ONCE(1, "HSR: Could not send supervision frame\n");	311	netdev_warn_once(master->dev, "HSR: Could not send supervision frame\n");
312	return;	312	return;
313	}	313	}
314		314
@@ -355,7 +355,7 @@ static void send_prp_supervision_frame(struct hsr_port *master, · 40 unmodified lines
355		355
356	skb = hsr_init_skb(master);	356	skb = hsr_init_skb(master);
357	if (!skb) {	357	if (!skb) {
358	WARN_ONCE(1, "PRP: Could not send supervision frame\n");	358	netdev_warn_once(master->dev, "PRP: Could not send supervision frame\n");
359	return;	359	return;
360	}	360	}
361		361

net/ipv4/ip_output.c+6−6

 	if (unlikely(!rt))
 		return -EFAULT;
+	cork->fragsize = ip_sk_use_pmtu(sk) ?
+			 dst_mtu(&rt->dst) : READ_ONCE(rt->dst.dev->mtu);
+	if (!inetdev_valid_mtu(cork->fragsize))
+		return -ENETUNREACH;
 	/*
 	 * setup for corking.
 	 */
 		cork->addr = ipc->addr;
 	}
-	cork->fragsize = ip_sk_use_pmtu(sk) ?
-			 dst_mtu(&rt->dst) : READ_ONCE(rt->dst.dev->mtu);
-	if (!inetdev_valid_mtu(cork->fragsize))
-		return -ENETUNREACH;
 	cork->gso_size = ipc->gso_size;
 	cork->dst = &rt->dst;

net/ipv4/ip_sockglue.c+4−2

  * ipv4_pktinfo_prepare - transfer some info from rtable to skb
  * @sk: socket
  * @skb: buffer
+ * @drop_dst: if true, drops skb dst
  *
  * To support IP_CMSG_PKTINFO option, we store rt_iif and specific
  * destination in skb->cb[] before dst drop.
  * This way, receiver doesn't make cache line misses to read rtable.
  */
-void ipv4_pktinfo_prepare(const struct sock *sk, struct sk_buff *skb)
+void ipv4_pktinfo_prepare(const struct sock *sk, struct sk_buff *skb, bool drop_dst)
 {
 	struct in_pktinfo *pktinfo = PKTINFO_SKB_CB(skb);
 	bool prepare = inet_test_bit(PKTINFO, sk) ||
 		pktinfo->ipi_ifindex = 0;
 		pktinfo->ipi_spec_dst.s_addr = 0;
 	}
-	skb_dst_drop(skb);
+	if (drop_dst)
+		skb_dst_drop(skb);
 }
 int ip_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,

net/ipv4/ipmr.c+1−1

@@ -1073,7 +1073,7 @@ static int ipmr_cache_report(const struct mr_table *mrt, · 1072 unmodified lines
1073	msg = (struct igmpmsg *)skb_network_header(skb);	1073	msg = (struct igmpmsg *)skb_network_header(skb);
1074	msg->im_vif = vifi;	1074	msg->im_vif = vifi;
1075	msg->im_vif_hi = vifi >> 8;	1075	msg->im_vif_hi = vifi >> 8;
1076	ipv4_pktinfo_prepare(mroute_sk, pkt);	1076	ipv4_pktinfo_prepare(mroute_sk, pkt, false);
1077	memcpy(skb->cb, pkt->cb, sizeof(skb->cb));	1077	memcpy(skb->cb, pkt->cb, sizeof(skb->cb));
1078	/* Add our header */	1078	/* Add our header */
1079	igmp = skb_put(skb, sizeof(struct igmphdr));	1079	igmp = skb_put(skb, sizeof(struct igmphdr));

net/ipv4/raw.c+1−1

@@ -292,7 +292,7 @@ static int raw_rcv_skb(struct sock sk, struct sk_buff skb) · 291 unmodified lines
292		292
293	/* Charge it to the socket. */	293	/* Charge it to the socket. */
294		294
295	ipv4_pktinfo_prepare(sk, skb);	295	ipv4_pktinfo_prepare(sk, skb, true);
296	if (sock_queue_rcv_skb_reason(sk, skb, &reason) < 0) {	296	if (sock_queue_rcv_skb_reason(sk, skb, &reason) < 0) {
297	kfree_skb_reason(skb, reason);	297	kfree_skb_reason(skb, reason);
298	return NET_RX_DROP;	298	return NET_RX_DROP;

net/ipv4/tcp.c+11−1

@@ -1786,7 +1786,17 @@ static skb_frag_t skb_advance_to_frag(struct sk_buff skb, u32 offset_skb, · 1785 unmodified lines
1786		1786
1787	static bool can_map_frag(const skb_frag_t *frag)	1787	static bool can_map_frag(const skb_frag_t *frag)
1788	{	1788	{
1789	return skb_frag_size(frag) == PAGE_SIZE && !skb_frag_off(frag);	1789	struct page *page;
		1790
		1791	if (skb_frag_size(frag) != PAGE_SIZE \|\| skb_frag_off(frag))
		1792	return false;
		1793
		1794	page = skb_frag_page(frag);
		1795
		1796	if (PageCompound(page) \|\| page->mapping)
		1797	return false;
		1798
		1799	return true;
1790	}	1800	}
1791		1801
1792	static int find_next_mappable_frag(const skb_frag_t *frag,	1802	static int find_next_mappable_frag(const skb_frag_t *frag,

net/ipv4/udp.c+1−1

@@ -2169,7 +2169,7 @@ static int udp_queue_rcv_one_skb(struct sock sk, struct sk_buff skb) · 2168 unmodified lines
2169		2169
2170	udp_csum_pull_header(skb);	2170	udp_csum_pull_header(skb);
2171		2171
2172	ipv4_pktinfo_prepare(sk, skb);	2172	ipv4_pktinfo_prepare(sk, skb, true);
2173	return __udp_queue_rcv_skb(sk, skb);	2173	return __udp_queue_rcv_skb(sk, skb);
2174		2174
2175	csum_error:	2175	csum_error:

net/ipv6/addrconf_core.c+14−7

 EXPORT_SYMBOL_GPL(ipv6_stub);
 /* IPv6 Wildcard Address and Loopback Address defined by RFC2553 */
-const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
+const struct in6_addr in6addr_loopback __aligned(BITS_PER_LONG/8)
+	= IN6ADDR_LOOPBACK_INIT;
 EXPORT_SYMBOL(in6addr_loopback);
-const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
+const struct in6_addr in6addr_any __aligned(BITS_PER_LONG/8)
+	= IN6ADDR_ANY_INIT;
 EXPORT_SYMBOL(in6addr_any);
-const struct in6_addr in6addr_linklocal_allnodes = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
+const struct in6_addr in6addr_linklocal_allnodes __aligned(BITS_PER_LONG/8)
+	= IN6ADDR_LINKLOCAL_ALLNODES_INIT;
 EXPORT_SYMBOL(in6addr_linklocal_allnodes);
-const struct in6_addr in6addr_linklocal_allrouters = IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
+const struct in6_addr in6addr_linklocal_allrouters __aligned(BITS_PER_LONG/8)
+	= IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
 EXPORT_SYMBOL(in6addr_linklocal_allrouters);
-const struct in6_addr in6addr_interfacelocal_allnodes = IN6ADDR_INTERFACELOCAL_ALLNODES_INIT;
+const struct in6_addr in6addr_interfacelocal_allnodes __aligned(BITS_PER_LONG/8)
+	= IN6ADDR_INTERFACELOCAL_ALLNODES_INIT;
 EXPORT_SYMBOL(in6addr_interfacelocal_allnodes);
-const struct in6_addr in6addr_interfacelocal_allrouters = IN6ADDR_INTERFACELOCAL_ALLROUTERS_INIT;
+const struct in6_addr in6addr_interfacelocal_allrouters __aligned(BITS_PER_LONG/8)
+	= IN6ADDR_INTERFACELOCAL_ALLROUTERS_INIT;
 EXPORT_SYMBOL(in6addr_interfacelocal_allrouters);
-const struct in6_addr in6addr_sitelocal_allrouters = IN6ADDR_SITELOCAL_ALLROUTERS_INIT;
+const struct in6_addr in6addr_sitelocal_allrouters __aligned(BITS_PER_LONG/8)
+	= IN6ADDR_SITELOCAL_ALLROUTERS_INIT;
 EXPORT_SYMBOL(in6addr_sitelocal_allrouters);
 static void snmp6_free_dev(struct inet6_dev *idev)

net/ipv6/ip6_tunnel.c+18−3

 						struct sk_buff *skb),
 			 bool log_ecn_err)
 {
-	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
+	const struct ipv6hdr *ipv6h;
-	int err;
+	int nh, err;
 	if ((!(tpi->flags & TUNNEL_CSUM) &&
 	     (tunnel->parms.i_flags & TUNNEL_CSUM)) ||
 			goto drop;
 		}
-		ipv6h = ipv6_hdr(skb);
 		skb->protocol = eth_type_trans(skb, tunnel->dev);
 		skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
 	} else {
 		skb_reset_mac_header(skb);
 	}
+	/* Save offset of outer header relative to skb->head,
+	 * because we are going to reset the network header to the inner header
+	 * and might change skb->head.
+	 */
+	nh = skb_network_header(skb) - skb->head;
 	skb_reset_network_header(skb);
+	if (!pskb_inet_may_pull(skb)) {
+		DEV_STATS_INC(tunnel->dev, rx_length_errors);
+		DEV_STATS_INC(tunnel->dev, rx_errors);
+		goto drop;
+	}
+	/* Get the outer header. */
+	ipv6h = (struct ipv6hdr *)(skb->head + nh);
 	memset(skb->cb, 0, sizeof(struct inet6_skb_parm));
 	__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);

net/llc/af_llc.c+2−0

 	}
 	netdev_put(llc->dev, &llc->dev_tracker);
 	sock_put(sk);
+	sock_orphan(sk);
+	sock->sk = NULL;
 	llc_sk_free(sk);
 out:
 	return 0;

net/mptcp/protocol.c+0−3

@@ -2314,9 +2314,6 @@ bool __mptcp_retransmit_pending_data(struct sock *sk) · 2313 unmodified lines
2314	if (__mptcp_check_fallback(msk))	2314	if (__mptcp_check_fallback(msk))
2315	return false;	2315	return false;
2316		2316
2317	if (tcp_rtx_and_write_queues_empty(sk))
2318	return false;
2319
2320	/* the closing socket has some data untransmitted and/or unacked:	2317	/* the closing socket has some data untransmitted and/or unacked:
2321	* some data in the mptcp rtx queue has not really xmitted yet.	2318	* some data in the mptcp rtx queue has not really xmitted yet.
2322	* keep it simple and re-inject the whole mptcp level rtx queue	2319	* keep it simple and re-inject the whole mptcp level rtx queue

net/netfilter/ipset/ip_set_bitmap_gen.h+11−3

 #define mtype_del		IPSET_TOKEN(MTYPE, _del)
 #define mtype_list		IPSET_TOKEN(MTYPE, _list)
 #define mtype_gc		IPSET_TOKEN(MTYPE, _gc)
+#define mtype_cancel_gc		IPSET_TOKEN(MTYPE, _cancel_gc)
 #define mtype			MTYPE
 #define get_ext(set, map, id)	((map)->extensions + ((set)->dsize * (id)))
 {
 	struct mtype *map = set->data;
-	if (SET_WITH_TIMEOUT(set))
-		del_timer_sync(&map->gc);
 	if (set->dsize && set->extensions & IPSET_EXT_DESTROY)
 		mtype_ext_cleanup(set);
 	ip_set_free(map->members);
 	add_timer(&map->gc);
 }
+static void
+mtype_cancel_gc(struct ip_set *set)
+{
+	struct mtype *map = set->data;
+	if (SET_WITH_TIMEOUT(set))
+		del_timer_sync(&map->gc);
+}
 static const struct ip_set_type_variant mtype = {
 	.kadt	= mtype_kadt,
 	.uadt	= mtype_uadt,
 	.head	= mtype_head,
 	.list	= mtype_list,
 	.same_set = mtype_same_set,
+	.cancel_gc = mtype_cancel_gc,
 };
 #endif /* __IP_SET_BITMAP_IP_GEN_H */

net/netfilter/ipset/ip_set_core.c+28−9

@@ -1182,6 +1182,14 @@ ip_set_destroy_set(struct ip_set *set) · 1181 unmodified lines
1182	kfree(set);	1182	kfree(set);
1183	}	1183	}
1184		1184
		1185	static void
		1186	ip_set_destroy_set_rcu(struct rcu_head *head)
		1187	{
		1188	struct ip_set *set = container_of(head, struct ip_set, rcu);
		1189
		1190	ip_set_destroy_set(set);
		1191	}
		1192
1185	static int ip_set_destroy(struct sk_buff skb, const struct nfnl_info info,	1193	static int ip_set_destroy(struct sk_buff skb, const struct nfnl_info info,
1186	const struct nlattr * const attr[])	1194	const struct nlattr * const attr[])
1187	{	1195	{
@@ -1193,8 +1201,6 @@ static int ip_set_destroy(struct sk_buff skb, const struct nfnl_info info, · 5 unmodified lines
1193	if (unlikely(protocol_min_failed(attr)))	1201	if (unlikely(protocol_min_failed(attr)))
1194	return -IPSET_ERR_PROTOCOL;	1202	return -IPSET_ERR_PROTOCOL;
1195		1203
1196	/* Must wait for flush to be really finished in list:set */
1197	rcu_barrier();
1198		1204
1199	/* Commands are serialized and references are	1205	/* Commands are serialized and references are
1200	* protected by the ip_set_ref_lock.	1206	* protected by the ip_set_ref_lock.
@@ -1206,8 +1212,10 @@ static int ip_set_destroy(struct sk_buff skb, const struct nfnl_info info, · 5 unmodified lines
1206	* counter, so if it's already zero, we can proceed	1212	* counter, so if it's already zero, we can proceed
1207	* without holding the lock.	1213	* without holding the lock.
1208	*/	1214	*/
1209	read_lock_bh(&ip_set_ref_lock);
1210	if (!attr[IPSET_ATTR_SETNAME]) {	1215	if (!attr[IPSET_ATTR_SETNAME]) {
		1216	/* Must wait for flush to be really finished in list:set */
		1217	rcu_barrier();
		1218	read_lock_bh(&ip_set_ref_lock);
1211	for (i = 0; i < inst->ip_set_max; i++) {	1219	for (i = 0; i < inst->ip_set_max; i++) {
1212	s = ip_set(inst, i);	1220	s = ip_set(inst, i);
1213	if (s && (s->ref \|\| s->ref_netlink)) {	1221	if (s && (s->ref \|\| s->ref_netlink)) {
@@ -1221,6 +1229,8 @@ static int ip_set_destroy(struct sk_buff skb, const struct nfnl_info info, · 7 unmodified lines
1221	s = ip_set(inst, i);	1229	s = ip_set(inst, i);
1222	if (s) {	1230	if (s) {
1223	ip_set(inst, i) = NULL;	1231	ip_set(inst, i) = NULL;
		1232	/* Must cancel garbage collectors */
		1233	s->variant->cancel_gc(s);
1224	ip_set_destroy_set(s);	1234	ip_set_destroy_set(s);
1225	}	1235	}
1226	}	1236	}
@@ -1228,6 +1238,9 @@ static int ip_set_destroy(struct sk_buff skb, const struct nfnl_info info, · 1 unmodified line
1228	inst->is_destroyed = false;	1238	inst->is_destroyed = false;
1229	} else {	1239	} else {
1230	u32 flags = flag_exist(info->nlh);	1240	u32 flags = flag_exist(info->nlh);
		1241	u16 features = 0;
		1242
		1243	read_lock_bh(&ip_set_ref_lock);
1231	s = find_set_and_id(inst, nla_data(attr[IPSET_ATTR_SETNAME]),	1244	s = find_set_and_id(inst, nla_data(attr[IPSET_ATTR_SETNAME]),
1232	&i);	1245	&i);
1233	if (!s) {	1246	if (!s) {
@@ -1238,10 +1251,16 @@ static int ip_set_destroy(struct sk_buff skb, const struct nfnl_info info, · 4 unmodified lines
1238	ret = -IPSET_ERR_BUSY;	1251	ret = -IPSET_ERR_BUSY;
1239	goto out;	1252	goto out;
1240	}	1253	}
		1254	features = s->type->features;
1241	ip_set(inst, i) = NULL;	1255	ip_set(inst, i) = NULL;
1242	read_unlock_bh(&ip_set_ref_lock);	1256	read_unlock_bh(&ip_set_ref_lock);
1243		1257	if (features & IPSET_TYPE_NAME) {
1244	ip_set_destroy_set(s);	1258	/* Must wait for flush to be really finished */
		1259	rcu_barrier();
		1260	}
		1261	/* Must cancel garbage collectors */
		1262	s->variant->cancel_gc(s);
		1263	call_rcu(&s->rcu, ip_set_destroy_set_rcu);
1245	}	1264	}
1246	return 0;	1265	return 0;
1247	out:	1266	out:
@@ -1394,9 +1413,6 @@ static int ip_set_swap(struct sk_buff skb, const struct nfnl_info info, · 146 unmodified lines
1394	ip_set(inst, to_id) = from;	1413	ip_set(inst, to_id) = from;
1395	write_unlock_bh(&ip_set_ref_lock);	1414	write_unlock_bh(&ip_set_ref_lock);
1396		1415
1397	/* Make sure all readers of the old set pointers are completed. */
1398	synchronize_rcu();
1399
1400	return 0;	1416	return 0;
1401	}	1417	}
1402		1418
@@ -2409,8 +2425,11 @@ ip_set_fini(void) · 1006 unmodified lines
2409	{	2425	{
2410	nf_unregister_sockopt(&so_set);	2426	nf_unregister_sockopt(&so_set);
2411	nfnetlink_subsys_unregister(&ip_set_netlink_subsys);	2427	nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
2412
2413	unregister_pernet_subsys(&ip_set_net_ops);	2428	unregister_pernet_subsys(&ip_set_net_ops);
		2429
		2430	/* Wait for call_rcu() in destroy */
		2431	rcu_barrier();
		2432
2414	pr_debug("these are the famous last words\n");	2433	pr_debug("these are the famous last words\n");
2415	}	2434	}
2416		2435

net/netfilter/ipset/ip_set_hash_gen.h+12−3

 #undef mtype_gc_do
 #undef mtype_gc
 #undef mtype_gc_init
+#undef mtype_cancel_gc
 #undef mtype_variant
 #undef mtype_data_match
 #define mtype_gc_do		IPSET_TOKEN(MTYPE, _gc_do)
 #define mtype_gc		IPSET_TOKEN(MTYPE, _gc)
 #define mtype_gc_init		IPSET_TOKEN(MTYPE, _gc_init)
+#define mtype_cancel_gc		IPSET_TOKEN(MTYPE, _cancel_gc)
 #define mtype_variant		IPSET_TOKEN(MTYPE, _variant)
 #define mtype_data_match	IPSET_TOKEN(MTYPE, _data_match)
 	struct htype *h = set->data;
 	struct list_head *l, *lt;
-	if (SET_WITH_TIMEOUT(set))
-		cancel_delayed_work_sync(&h->gc.dwork);
 	mtype_ahash_destroy(set, ipset_dereference_nfnl(h->table), true);
 	list_for_each_safe(l, lt, &h->ad) {
 		list_del(l);
 	queue_delayed_work(system_power_efficient_wq, &gc->dwork, HZ);
 }
+static void
+mtype_cancel_gc(struct ip_set *set)
+{
+	struct htype *h = set->data;
+	if (SET_WITH_TIMEOUT(set))
+		cancel_delayed_work_sync(&h->gc.dwork);
+}
 static int
 mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 	  struct ip_set_ext *mext, u32 flags);
 	.uref	= mtype_uref,
 	.resize	= mtype_resize,
 	.same_set = mtype_same_set,
+	.cancel_gc = mtype_cancel_gc,
 	.region_lock = true,
 };

net/netfilter/ipset/ip_set_list_set.c+10−3

 	struct list_set *map = set->data;
 	struct set_elem *e, *n;
-	if (SET_WITH_TIMEOUT(set))
-		timer_shutdown_sync(&map->gc);
 	list_for_each_entry_safe(e, n, &map->members, list) {
 		list_del(&e->list);
 		ip_set_put_byindex(map->net, e->id);
 	       a->extensions == b->extensions;
 }
+static void
+list_set_cancel_gc(struct ip_set *set)
+{
+	struct list_set *map = set->data;
+	if (SET_WITH_TIMEOUT(set))
+		timer_shutdown_sync(&map->gc);
+}
 static const struct ip_set_type_variant set_variant = {
 	.kadt	= list_set_kadt,
 	.uadt	= list_set_uadt,
 	.head	= list_set_head,
 	.list	= list_set_list,
 	.same_set = list_set_same_set,
+	.cancel_gc = list_set_cancel_gc,
 };
 static void

net/netfilter/nf_conntrack_proto_sctp.c+1−1

@@ -283,7 +283,7 @@ sctp_new(struct nf_conn ct, const struct sk_buff skb, · 282 unmodified lines
283	pr_debug("Setting vtag %x for secondary conntrack\n",	283	pr_debug("Setting vtag %x for secondary conntrack\n",
284	sh->vtag);	284	sh->vtag);
285	ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL] = sh->vtag;	285	ct->proto.sctp.vtag[IP_CT_DIR_ORIGINAL] = sh->vtag;
286	} else {	286	} else if (sch->type == SCTP_CID_SHUTDOWN_ACK) {
287	/* If it is a shutdown ack OOTB packet, we expect a return	287	/* If it is a shutdown ack OOTB packet, we expect a return
288	shutdown complete, otherwise an ABORT Sec 8.4 (5) and (8) */	288	shutdown complete, otherwise an ABORT Sec 8.4 (5) and (8) */
289	pr_debug("Setting vtag %x for new conn OOTB\n",	289	pr_debug("Setting vtag %x for new conn OOTB\n",

net/netfilter/nf_conntrack_proto_tcp.c+6−4

 			    const struct sk_buff *skb,
 			    unsigned int dataoff,
 			    const struct tcphdr *tcph,
-			    u32 end, u32 win)
+			    u32 end, u32 win,
+			    enum ip_conntrack_dir dir)
 {
 	/* SYN-ACK in reply to a SYN
 	 * or SYN from reply direction in simultaneous open.
 	 * Both sides must send the Window Scale option
 	 * to enable window scaling in either direction.
 	 */
-	if (!(sender->flags & IP_CT_TCP_FLAG_WINDOW_SCALE &&
+	if (dir == IP_CT_DIR_REPLY &&
+	    !(sender->flags & IP_CT_TCP_FLAG_WINDOW_SCALE &&
 	      receiver->flags & IP_CT_TCP_FLAG_WINDOW_SCALE)) {
 		sender->td_scale = 0;
 		receiver->td_scale = 0;
 		if (tcph->syn) {
 			tcp_init_sender(sender, receiver,
 					skb, dataoff, tcph,
-					end, win);
+					end, win, dir);
 			if (!tcph->ack)
 				/* Simultaneous open */
 				return NFCT_TCP_ACCEPT;
 		 */
 		tcp_init_sender(sender, receiver,
 				skb, dataoff, tcph,
-				end, win);
+				end, win, dir);
 		if (dir == IP_CT_DIR_REPLY && !tcph->ack)
 			return NFCT_TCP_ACCEPT;

net/netfilter/nf_log.c+4−3

 		return;
 	}
-	BUG_ON(loggers[pf][type] == NULL);
 	rcu_read_lock();
 	logger = rcu_dereference(loggers[pf][type]);
-	module_put(logger->me);
+	if (!logger)
+		WARN_ON_ONCE(1);
+	else
+		module_put(logger->me);
 	rcu_read_unlock();
 }
 EXPORT_SYMBOL_GPL(nf_logger_put);

net/netfilter/nf_tables_api.c+9−5

 	return -1;
 }
-static const struct nft_object_type *__nft_obj_type_get(u32 objtype)
+static const struct nft_object_type *__nft_obj_type_get(u32 objtype, u8 family)
 {
 	const struct nft_object_type *type;
 	list_for_each_entry(type, &nf_tables_objects, list) {
+		if (type->family != NFPROTO_UNSPEC &&
+		    type->family != family)
+			continue;
 		if (objtype == type->type)
 			return type;
 	}
 }
 static const struct nft_object_type *
-nft_obj_type_get(struct net *net, u32 objtype)
+nft_obj_type_get(struct net *net, u32 objtype, u8 family)
 {
 	const struct nft_object_type *type;
-	type = __nft_obj_type_get(objtype);
+	type = __nft_obj_type_get(objtype, family);
 	if (type != NULL && try_module_get(type->owner))
 		return type;
 		if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
 			return -EOPNOTSUPP;
-		type = __nft_obj_type_get(objtype);
+		type = __nft_obj_type_get(objtype, family);
 		if (WARN_ON_ONCE(!type))
 			return -ENOENT;
 	if (!nft_use_inc(&table->use))
 		return -EMFILE;
-	type = nft_obj_type_get(net, objtype);
+	type = nft_obj_type_get(net, objtype, family);
 	if (IS_ERR(type)) {
 		err = PTR_ERR(type);
 		goto err_type;

net/netfilter/nft_ct.c+24−0

@@ -1250,7 +1250,31 @@ static int nft_ct_expect_obj_init(const struct nft_ctx *ctx, · 1249 unmodified lines
1250	if (tb[NFTA_CT_EXPECT_L3PROTO])	1250	if (tb[NFTA_CT_EXPECT_L3PROTO])
1251	priv->l3num = ntohs(nla_get_be16(tb[NFTA_CT_EXPECT_L3PROTO]));	1251	priv->l3num = ntohs(nla_get_be16(tb[NFTA_CT_EXPECT_L3PROTO]));
1252		1252
		1253	switch (priv->l3num) {
		1254	case NFPROTO_IPV4:
		1255	case NFPROTO_IPV6:
		1256	if (priv->l3num != ctx->family)
		1257	return -EINVAL;
		1258
		1259	fallthrough;
		1260	case NFPROTO_INET:
		1261	break;
		1262	default:
		1263	return -EOPNOTSUPP;
		1264	}
		1265
1253	priv->l4proto = nla_get_u8(tb[NFTA_CT_EXPECT_L4PROTO]);	1266	priv->l4proto = nla_get_u8(tb[NFTA_CT_EXPECT_L4PROTO]);
		1267	switch (priv->l4proto) {
		1268	case IPPROTO_TCP:
		1269	case IPPROTO_UDP:
		1270	case IPPROTO_UDPLITE:
		1271	case IPPROTO_DCCP:
		1272	case IPPROTO_SCTP:
		1273	break;
		1274	default:
		1275	return -EOPNOTSUPP;
		1276	}
		1277
1254	priv->dport = nla_get_be16(tb[NFTA_CT_EXPECT_DPORT]);	1278	priv->dport = nla_get_be16(tb[NFTA_CT_EXPECT_DPORT]);
1255	priv->timeout = nla_get_u32(tb[NFTA_CT_EXPECT_TIMEOUT]);	1279	priv->timeout = nla_get_u32(tb[NFTA_CT_EXPECT_TIMEOUT]);
1256	priv->size = nla_get_u8(tb[NFTA_CT_EXPECT_SIZE]);	1280	priv->size = nla_get_u8(tb[NFTA_CT_EXPECT_SIZE]);

net/netfilter/nft_tunnel.c+1−0

@@ -713,6 +713,7 @@ static const struct nft_object_ops nft_tunnel_obj_ops = { · 712 unmodified lines
713		713
714	static struct nft_object_type nft_tunnel_obj_type __read_mostly = {	714	static struct nft_object_type nft_tunnel_obj_type __read_mostly = {
715	.type = NFT_OBJECT_TUNNEL,	715	.type = NFT_OBJECT_TUNNEL,
		716	.family = NFPROTO_NETDEV,
716	.ops = &nft_tunnel_obj_ops,	717	.ops = &nft_tunnel_obj_ops,
717	.maxattr = NFTA_TUNNEL_KEY_MAX,	718	.maxattr = NFTA_TUNNEL_KEY_MAX,
718	.policy = nft_tunnel_key_policy,	719	.policy = nft_tunnel_key_policy,

net/nfc/nci/core.c+4−0

 {
 	nfc_free_device(ndev->nfc_dev);
 	nci_hci_deallocate(ndev);
+	/* drop partial rx data packet if present */
+	if (ndev->rx_data_reassembly)
+		kfree_skb(ndev->rx_data_reassembly);
 	kfree(ndev);
 }
 EXPORT_SYMBOL(nci_free_device);

net/smc/smc_core.c+9−3

 			   struct smcd_dev *smcismdev,
 			   struct smcd_gid *peer_gid)
 {
-	return lgr->peer_gid.gid == peer_gid->gid && lgr->smcd == smcismdev &&
+	if (lgr->peer_gid.gid != peer_gid->gid ||
-		smc_ism_is_virtual(smcismdev) ?
+	    lgr->smcd != smcismdev)
-		(lgr->peer_gid.gid_ext == peer_gid->gid_ext) : 1;
+		return false;
+	if (smc_ism_is_virtual(smcismdev) &&
+	    lgr->peer_gid.gid_ext != peer_gid->gid_ext)
+		return false;
+	return true;
 }
 /* create a new SMC connection (and a new link group if necessary) */

net/unix/af_unix.c+6−8

@@ -1344,13 +1344,11 @@ static void unix_state_double_lock(struct sock sk1, struct sock sk2) · 1343 unmodified lines
1344	unix_state_lock(sk1);	1344	unix_state_lock(sk1);
1345	return;	1345	return;
1346	}	1346	}
1347	if (sk1 < sk2) {	1347	if (sk1 > sk2)
1348	unix_state_lock(sk1);	1348	swap(sk1, sk2);
1349	unix_state_lock_nested(sk2);	1349
1350	} else {	1350	unix_state_lock(sk1);
1351	unix_state_lock(sk2);	1351	unix_state_lock_nested(sk2, U_LOCK_SECOND);
1352	unix_state_lock_nested(sk1);
1353	}
1354	}	1352	}
1355		1353
1356	static void unix_state_double_unlock(struct sock sk1, struct sock sk2)	1354	static void unix_state_double_unlock(struct sock sk1, struct sock sk2)
@@ -1591,7 +1589,7 @@ restart: · 234 unmodified lines
1591	goto out_unlock;	1589	goto out_unlock;
1592	}	1590	}
1593		1591
1594	unix_state_lock_nested(sk);	1592	unix_state_lock_nested(sk, U_LOCK_SECOND);
1595		1593
1596	if (sk->sk_state != st) {	1594	if (sk->sk_state != st) {
1597	unix_state_unlock(sk);	1595	unix_state_unlock(sk);

net/unix/diag.c+1−1

@@ -84,7 +84,7 @@ static int sk_diag_dump_icons(struct sock sk, struct sk_buff nlskb) · 83 unmodified lines
84	* queue lock. With the other's queue locked it's	84	* queue lock. With the other's queue locked it's
85	* OK to lock the state.	85	* OK to lock the state.
86	*/	86	*/
87	unix_state_lock_nested(req);	87	unix_state_lock_nested(req, U_LOCK_DIAG);
88	peer = unix_sk(req)->peer;	88	peer = unix_sk(req)->peer;
89	buf[i++] = (peer ? sock_i_ino(peer) : 0);	89	buf[i++] = (peer ? sock_i_ino(peer) : 0);
90	unix_state_unlock(req);	90	unix_state_unlock(req);

tools/testing/selftests/drivers/net/bonding/lag_lib.sh+11−0

@@ -48,6 +48,17 @@ test_LAG_cleanup() · 47 unmodified lines
48	ip link add mv0 link "$name" up address "$ucaddr" type macvlan	48	ip link add mv0 link "$name" up address "$ucaddr" type macvlan
49	# Used to test dev->mc handling	49	# Used to test dev->mc handling
50	ip address add "$addr6" dev "$name"	50	ip address add "$addr6" dev "$name"
		51
		52	# Check that addresses were added as expected
		53	(grep_bridge_fdb "$ucaddr" bridge fdb show dev dummy1 \|\|
		54	grep_bridge_fdb "$ucaddr" bridge fdb show dev dummy2) >/dev/null
		55	check_err $? "macvlan unicast address not found on a slave"
		56
		57	# mcaddr is added asynchronously by addrconf_dad_work(), use busywait
		58	(busywait 10000 grep_bridge_fdb "$mcaddr" bridge fdb show dev dummy1 \|\|
		59	grep_bridge_fdb "$mcaddr" bridge fdb show dev dummy2) >/dev/null
		60	check_err $? "IPv6 solicited-node multicast mac address not found on a slave"
		61
51	ip link set dev "$name" down	62	ip link set dev "$name" down
52	ip link del "$name"	63	ip link del "$name"
53		64

tools/testing/selftests/drivers/net/team/config+3−1

@@ -1,3 +1,5 @@
		1	CONFIG_DUMMY=y
		2	CONFIG_IPV6=y
		3	CONFIG_MACVLAN=y
1	CONFIG_NET_TEAM=y	4	CONFIG_NET_TEAM=y
2	CONFIG_NET_TEAM_MODE_LOADBALANCE=y	5	CONFIG_NET_TEAM_MODE_LOADBALANCE=y
3	CONFIG_MACVLAN=y

tools/testing/selftests/net/Makefile+5−4

 TEST_PROGS += ip_local_port_range.sh
 TEST_PROGS += rps_default_mask.sh
 TEST_PROGS += big_tcp.sh
-TEST_PROGS_EXTENDED := in_netns.sh setup_loopback.sh setup_veth.sh
+TEST_PROGS_EXTENDED := toeplitz_client.sh toeplitz.sh
-TEST_PROGS_EXTENDED += toeplitz_client.sh toeplitz.sh lib.sh
 TEST_GEN_FILES =  socket nettest
 TEST_GEN_FILES += psock_fanout psock_tpacket msg_zerocopy reuseport_addr_any
 TEST_GEN_FILES += tcp_mmap tcp_inq psock_snd txring_overwrite
 TEST_GEN_FILES += sctp_hello
 TEST_GEN_FILES += csum
 TEST_GEN_FILES += nat6to4.o
+TEST_GEN_FILES += xdp_dummy.o
 TEST_GEN_FILES += ip_local_port_range
 TEST_GEN_FILES += bind_wildcard
 TEST_PROGS += test_vxlan_mdb.sh
 TEST_PROGS += vlan_hw_filter.sh
 TEST_FILES := settings
+TEST_FILES += in_netns.sh lib.sh net_helper.sh setup_loopback.sh setup_veth.sh
 include ../lib.mk
 $(OUTPUT)/bind_bhash: LDLIBS += -lpthread
 $(OUTPUT)/io_uring_zerocopy_tx: CFLAGS += -I../../../include/
-# Rules to generate bpf obj nat6to4.o
+# Rules to generate bpf objs
 CLANG ?= clang
 SCRATCH_DIR := $(OUTPUT)/tools
 BUILD_DIR := $(SCRATCH_DIR)/build
 CLANG_SYS_INCLUDES = $(call get_sys_includes,$(CLANG),$(CLANG_TARGET_ARCH))
-$(OUTPUT)/nat6to4.o: nat6to4.c $(BPFOBJ) | $(MAKE_DIRS)
+$(OUTPUT)/nat6to4.o $(OUTPUT)/xdp_dummy.o: $(OUTPUT)/%.o : %.c $(BPFOBJ) | $(MAKE_DIRS)
 	$(CLANG) -O2 --target=bpf -c $< $(CCINCLUDE) $(CLANG_SYS_INCLUDES) -o $@
 $(BPFOBJ): $(wildcard $(BPFDIR)/*.[ch] $(BPFDIR)/Makefile)		       \

tools/testing/selftests/net/config+16−0

 CONFIG_BRIDGE=y
 CONFIG_CRYPTO_CHACHA20POLY1305=m
 CONFIG_VLAN_8021Q=y
+CONFIG_GENEVE=m
 CONFIG_IFB=y
 CONFIG_INET_DIAG=y
+CONFIG_INET_ESP=y
+CONFIG_INET_ESP_OFFLOAD=y
 CONFIG_IP_GRE=m
 CONFIG_NETFILTER=y
 CONFIG_NETFILTER_ADVANCED=y
 CONFIG_IP6_NF_IPTABLES=m
 CONFIG_IP_NF_IPTABLES=m
 CONFIG_IP6_NF_NAT=m
+CONFIG_IP6_NF_RAW=m
 CONFIG_IP_NF_NAT=m
+CONFIG_IP_NF_RAW=m
+CONFIG_IP_NF_TARGET_TTL=m
 CONFIG_IPV6_GRE=m
 CONFIG_IPV6_SEG6_LWTUNNEL=y
 CONFIG_L2TP_ETH=m
 CONFIG_NF_TABLES_IPV6=y
 CONFIG_NF_TABLES_IPV4=y
 CONFIG_NFT_NAT=m
+CONFIG_NETFILTER_XT_MATCH_LENGTH=m
+CONFIG_NET_ACT_CSUM=m
+CONFIG_NET_ACT_CT=m
 CONFIG_NET_ACT_GACT=m
+CONFIG_NET_ACT_PEDIT=m
 CONFIG_NET_CLS_BASIC=m
+CONFIG_NET_CLS_BPF=m
+CONFIG_NET_CLS_MATCHALL=m
 CONFIG_NET_CLS_U32=m
 CONFIG_NET_IPGRE_DEMUX=m
 CONFIG_NET_IPGRE=m
 CONFIG_NET_SCH_FQ=m
 CONFIG_NET_SCH_ETF=m
 CONFIG_NET_SCH_NETEM=y
+CONFIG_NET_SCH_PRIO=m
+CONFIG_NFT_COMPAT=m
+CONFIG_NF_FLOW_TABLE=m
 CONFIG_PSAMPLE=m
 CONFIG_TCP_MD5SIG=y
 CONFIG_TEST_BLACKHOLE_DEV=m
 CONFIG_NETFILTER_XT_MATCH_POLICY=m
 CONFIG_CRYPTO_ARIA=y
 CONFIG_XFRM_INTERFACE=m
+CONFIG_XFRM_USER=m

tools/testing/selftests/net/forwarding/Makefile+1−1

@@ -112,7 +112,7 @@ TEST_PROGS = bridge_fdb_learning_limit.sh \ · 111 unmodified lines
112	vxlan_symmetric_ipv6.sh \	112	vxlan_symmetric_ipv6.sh \
113	vxlan_symmetric.sh	113	vxlan_symmetric.sh
114		114
115	TEST_PROGS_EXTENDED := devlink_lib.sh \	115	TEST_FILES := devlink_lib.sh \
116	ethtool_lib.sh \	116	ethtool_lib.sh \
117	fib_offload_lib.sh \	117	fib_offload_lib.sh \
118	forwarding.config.sample \	118	forwarding.config.sample \

tools/testing/selftests/net/lib.sh+4−1

 ##############################################################################
 # Defines
+WAIT_TIMEOUT=${WAIT_TIMEOUT:=20}
+BUSYWAIT_TIMEOUT=$((WAIT_TIMEOUT * 1000)) # ms
 # Kselftest framework requirement - SKIP code is 4.
 ksft_skip=4
 # namespace list created by setup_ns
 	for ns in "$@"; do
 		ip netns delete "${ns}" &> /dev/null
-		if ! busywait 2 ip netns list \| grep -vq "^$ns$" &> /dev/null; then
+		if ! busywait $BUSYWAIT_TIMEOUT ip netns list \| grep -vq "^$ns$" &> /dev/null; then
 			echo "Warn: Failed to remove namespace $ns"
 			ret=1
 		fi

tools/testing/selftests/net/mptcp/config+3−0

 CONFIG_NFT_SOCKET=m
 CONFIG_IP_ADVANCED_ROUTER=y
 CONFIG_IP_MULTIPLE_TABLES=y
+CONFIG_IP_NF_FILTER=m
+CONFIG_IP_NF_MANGLE=m
 CONFIG_IP_NF_TARGET_REJECT=m
 CONFIG_IPV6_MULTIPLE_TABLES=y
+CONFIG_IP6_NF_FILTER=m
 CONFIG_NET_ACT_CSUM=m
 CONFIG_NET_ACT_PEDIT=m
 CONFIG_NET_CLS_ACT=y

tools/testing/selftests/net/mptcp/mptcp_join.sh+11−16

 	mptcp_lib_kill_wait $evts_ns2_pid
 }
-kill_tests_wait()
-{
-	#shellcheck disable=SC2046
-	kill -SIGUSR1 $(ip netns pids $ns2) $(ip netns pids $ns1)
-	wait
-}
 pm_nl_set_limits()
 {
 	local ns=$1
 		chk_mptcp_info subflows 0 subflows 0
 		chk_subflows_total 1 1
 		kill_events_pids
-		wait $tests_pid
+		mptcp_lib_kill_wait $tests_pid
 	fi
 	# userspace pm create destroy subflow
 		chk_mptcp_info subflows 0 subflows 0
 		chk_subflows_total 1 1
 		kill_events_pids
-		wait $tests_pid
+		mptcp_lib_kill_wait $tests_pid
 	fi
 	# userspace pm create id 0 subflow
 		chk_mptcp_info subflows 1 subflows 1
 		chk_subflows_total 2 2
 		kill_events_pids
-		wait $tests_pid
+		mptcp_lib_kill_wait $tests_pid
 	fi
 	# userspace pm remove initial subflow
 		chk_mptcp_info subflows 1 subflows 1
 		chk_subflows_total 1 1
 		kill_events_pids
-		wait $tests_pid
+		mptcp_lib_kill_wait $tests_pid
 	fi
 	# userspace pm send RM_ADDR for ID 0
 		chk_mptcp_info subflows 1 subflows 1
 		chk_subflows_total 1 1
 		kill_events_pids
-		wait $tests_pid
+		mptcp_lib_kill_wait $tests_pid
 	fi
 }
 		pm_nl_set_limits $ns2 2 2
 		pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
 		speed=slow \
-			run_tests $ns1 $ns2 10.0.1.1 2>/dev/null &
+			run_tests $ns1 $ns2 10.0.1.1 &
+		local tests_pid=$!
 		wait_mpj $ns1
 		pm_nl_check_endpoint "creation" \
 		pm_nl_add_endpoint $ns2 10.0.2.2 flags signal
 		pm_nl_check_endpoint "modif is allowed" \
 			$ns2 10.0.2.2 id 1 flags signal
-		kill_tests_wait
+		mptcp_lib_kill_wait $tests_pid
 	fi
 	if reset "delete and re-add" &&
 		pm_nl_set_limits $ns2 1 1
 		pm_nl_add_endpoint $ns2 10.0.2.2 id 2 dev ns2eth2 flags subflow
 		test_linkfail=4 speed=20 \
-			run_tests $ns1 $ns2 10.0.1.1 2>/dev/null &
+			run_tests $ns1 $ns2 10.0.1.1 &
+		local tests_pid=$!
 		wait_mpj $ns2
 		chk_subflow_nr "before delete" 2
 		wait_mpj $ns2
 		chk_subflow_nr "after re-add" 2
 		chk_mptcp_info subflows 1 subflows 1
-		kill_tests_wait
+		mptcp_lib_kill_wait $tests_pid
 	fi
 }

tools/testing/selftests/net/mptcp/mptcp_lib.sh+1−1

@@ -6,7 +6,7 @@ readonly KSFT_FAIL=1 · 5 unmodified lines
6	readonly KSFT_SKIP=4	6	readonly KSFT_SKIP=4
7		7
8	# shellcheck disable=SC2155 # declare and assign separately	8	# shellcheck disable=SC2155 # declare and assign separately
9	readonly KSFT_TEST=$(basename "${0}" \| sed 's/\.sh$//g')	9	readonly KSFT_TEST="${MPTCP_LIB_KSFT_TEST:-$(basename "${0}" .sh)}"
10		10
11	MPTCP_LIB_SUBTESTS=()	11	MPTCP_LIB_SUBTESTS=()
12		12

tools/testing/selftests/net/mptcp/settings+1−1

@@ -1 +1 @@
1	timeout=1200	1	timeout=1800

tools/testing/selftests/net/mptcp/simult_flows.sh+4−4

@@ -284,12 +284,12 @@ done · 283 unmodified lines
284		284
285	setup	285	setup
286	run_test 10 10 0 0 "balanced bwidth"	286	run_test 10 10 0 0 "balanced bwidth"
287	run_test 10 10 1 50 "balanced bwidth with unbalanced delay"	287	run_test 10 10 1 25 "balanced bwidth with unbalanced delay"
288		288
289	# we still need some additional infrastructure to pass the following test-cases	289	# we still need some additional infrastructure to pass the following test-cases
290	run_test 30 10 0 0 "unbalanced bwidth"	290	run_test 10 3 0 0 "unbalanced bwidth"
291	run_test 30 10 1 50 "unbalanced bwidth with unbalanced delay"	291	run_test 10 3 1 25 "unbalanced bwidth with unbalanced delay"
292	run_test 30 10 50 1 "unbalanced bwidth with opposed, unbalanced delay"	292	run_test 10 3 25 1 "unbalanced bwidth with opposed, unbalanced delay"
293		293
294	mptcp_lib_result_print_all_tap	294	mptcp_lib_result_print_all_tap
295	exit $ret	295	exit $ret

tools/testing/selftests/net/net_helper.sh+0−0

File mode changed from 100755 to 100644.

tools/testing/selftests/net/pmtu.sh+9−9

@@ -707,23 +707,23 @@ setup_xfrm6() { · 706 unmodified lines
707	}	707	}
708		708
709	setup_xfrm4udp() {	709	setup_xfrm4udp() {
710	setup_xfrm 4 ${veth4_a_addr} ${veth4_b_addr} "encap espinudp 4500 4500 0.0.0.0"	710	setup_xfrm 4 ${veth4_a_addr} ${veth4_b_addr} "encap espinudp 4500 4500 0.0.0.0" && \
711	setup_nettest_xfrm 4 4500	711	setup_nettest_xfrm 4 4500
712	}	712	}
713		713
714	setup_xfrm6udp() {	714	setup_xfrm6udp() {
715	setup_xfrm 6 ${veth6_a_addr} ${veth6_b_addr} "encap espinudp 4500 4500 0.0.0.0"	715	setup_xfrm 6 ${veth6_a_addr} ${veth6_b_addr} "encap espinudp 4500 4500 0.0.0.0" && \
716	setup_nettest_xfrm 6 4500	716	setup_nettest_xfrm 6 4500
717	}	717	}
718		718
719	setup_xfrm4udprouted() {	719	setup_xfrm4udprouted() {
720	setup_xfrm 4 ${prefix4}.${a_r1}.1 ${prefix4}.${b_r1}.1 "encap espinudp 4500 4500 0.0.0.0"	720	setup_xfrm 4 ${prefix4}.${a_r1}.1 ${prefix4}.${b_r1}.1 "encap espinudp 4500 4500 0.0.0.0" && \
721	setup_nettest_xfrm 4 4500	721	setup_nettest_xfrm 4 4500
722	}	722	}
723		723
724	setup_xfrm6udprouted() {	724	setup_xfrm6udprouted() {
725	setup_xfrm 6 ${prefix6}:${a_r1}::1 ${prefix6}:${b_r1}::1 "encap espinudp 4500 4500 0.0.0.0"	725	setup_xfrm 6 ${prefix6}:${a_r1}::1 ${prefix6}:${b_r1}::1 "encap espinudp 4500 4500 0.0.0.0" && \
726	setup_nettest_xfrm 6 4500	726	setup_nettest_xfrm 6 4500
727	}	727	}
728		728
729	setup_routing_old() {	729	setup_routing_old() {
@@ -1339,7 +1339,7 @@ test_pmtu_ipvX_over_bridged_vxlanY_or_geneveY_exception() { · 609 unmodified lines
1339		1339
1340	sleep 1	1340	sleep 1
1341		1341
1342	dd if=/dev/zero of=/dev/stdout status=none bs=1M count=1 \| ${target} socat -T 3 -u STDIN $TCPDST,connect-timeout=3	1342	dd if=/dev/zero status=none bs=1M count=1 \| ${target} socat -T 3 -u STDIN $TCPDST,connect-timeout=3
1343		1343
1344	size=$(du -sb $tmpoutfile)	1344	size=$(du -sb $tmpoutfile)
1345	size=${size%%/tmp/*}	1345	size=${size%%/tmp/*}

tools/testing/selftests/net/setup_loopback.sh+0−0

File mode changed from 100755 to 100644.

tools/testing/selftests/net/setup_veth.sh+1−1

@@ -11,7 +11,7 @@ setup_veth_ns() { · 10 unmodified lines
11	local -r ns_mac="$4"	11	local -r ns_mac="$4"
12		12
13	[[ -e /var/run/netns/"${ns_name}" ]] \|\| ip netns add "${ns_name}"	13	[[ -e /var/run/netns/"${ns_name}" ]] \|\| ip netns add "${ns_name}"
14	echo 100000 > "/sys/class/net/${ns_dev}/gro_flush_timeout"	14	echo 1000000 > "/sys/class/net/${ns_dev}/gro_flush_timeout"
15	ip link set dev "${ns_dev}" netns "${ns_name}" mtu 65535	15	ip link set dev "${ns_dev}" netns "${ns_name}" mtu 65535
16	ip -netns "${ns_name}" link set dev "${ns_dev}" up	16	ip -netns "${ns_name}" link set dev "${ns_dev}" up
17		17

tools/testing/selftests/net/tcp_ao/config+10−0

@@ -0,0 +1,10 @@
	1	CONFIG_CRYPTO_HMAC=y
	2	CONFIG_CRYPTO_RMD160=y
	3	CONFIG_CRYPTO_SHA1=y
	4	CONFIG_IPV6_MULTIPLE_TABLES=y
	5	CONFIG_IPV6=y
	6	CONFIG_NET_L3_MASTER_DEV=y
	7	CONFIG_NET_VRF=y
	8	CONFIG_TCP_AO=y
	9	CONFIG_TCP_MD5SIG=y
	10	CONFIG_VETH=m

tools/testing/selftests/net/tcp_ao/key-management.c+26−20

 		matches_vrf		: 1,
 		is_current		: 1,
 		is_rnext		: 1,
-		used_on_handshake	: 1,
+		used_on_server_tx	: 1,
-		used_after_accept	: 1,
+		used_on_client_tx	: 1,
-		used_on_client		: 1;
+		skip_counters_checks	: 1;
 };
 struct key_collection {
 				addr = &this_ip_dest;
 			sndid = key->client_keyid;
 			rcvid = key->server_keyid;
-			set_current = key->is_current;
+			key->used_on_client_tx = set_current = key->is_current;
-			set_rnext = key->is_rnext;
+			key->used_on_server_tx = set_rnext = key->is_rnext;
 		}
 		if (test_add_key_cr(sk, key->password, key->len,
 				    *addr, vrf, sndid, rcvid, key->maclen,
 				    key->alg, set_current, set_rnext))
 			test_key_error("setsockopt(TCP_AO_ADD_KEY)", key);
-		if (set_current || set_rnext)
-			key->used_on_handshake = 1;
 #ifdef DEBUG
 		test_print("%s [%u/%u] key: { %s, %u:%u, %u, %u:%u:%u:%u (%u)}",
 			   server ? "server" : "client", i, collection.nr_keys,
 	for (i = 0; i < collection.nr_keys; i++) {
 		struct test_key *key = &collection.keys[i];
 		uint8_t sndid, rcvid;
-		bool was_used;
+		bool rx_cnt_expected;
+		if (key->skip_counters_checks)
+			continue;
 		if (server) {
 			sndid = key->server_keyid;
 			rcvid = key->client_keyid;
-			if (is_listen_sk)
+			rx_cnt_expected = key->used_on_client_tx;
-				was_used = key->used_on_handshake;
-			else
-				was_used = key->used_after_accept;
 		} else {
 			sndid = key->client_keyid;
 			rcvid = key->server_keyid;
-			was_used = key->used_on_client;
+			rx_cnt_expected = key->used_on_server_tx;
 		}
-		test_tcp_ao_key_counters_cmp(tst_name, a, b, was_used,
+		test_tcp_ao_key_counters_cmp(tst_name, a, b,
+					     rx_cnt_expected ? TEST_CNT_KEY_GOOD : 0,
 					     sndid, rcvid);
 	}
 	test_tcp_ao_counters_free(a);
 	synchronize_threads(); /* 4: verified => closed */
 	close(sk);
-	verify_counters(tst_name, true, false, begin, &end);
+	verify_counters(tst_name, false, true, begin, &end);
 	synchronize_threads(); /* 5: counters */
 }
 		current_index = nr_keys - 1;
 	if (rnext_index < 0)
 		rnext_index = nr_keys - 1;
-	collection.keys[current_index].used_on_handshake = 1;
+	collection.keys[current_index].used_on_client_tx = 1;
-	collection.keys[rnext_index].used_after_accept = 1;
+	collection.keys[rnext_index].used_on_server_tx = 1;
-	collection.keys[rnext_index].used_on_client = 1;
 	synchronize_threads(); /* 3: accepted => send data */
 	if (test_client_verify(sk, msg_sz, msg_nr, TEST_TIMEOUT_SEC)) {
 		test_error("Can't change the current key");
 	if (test_client_verify(sk, msg_len, nr_packets, TEST_TIMEOUT_SEC))
 		test_fail("verify failed");
-	collection.keys[rotate_to_index].used_after_accept = 1;
+	/* There is a race here: between setting the current_key with
+	 * setsockopt(TCP_AO_INFO) and starting to send some data - there
+	 * might have been a segment received with the desired
+	 * RNext_key set. In turn that would mean that the first outgoing
+	 * segment will have the desired current_key (flipped back).
+	 * Which is what the user/test wants. As it's racy, skip checking
+	 * the counters, yet check what are the resulting current/rnext
+	 * keys on both sides.
+	 */
+	collection.keys[rotate_to_index].skip_counters_checks = 1;
 	end_client(tst_name, sk, nr_keys, current_index, rnext_index, &tmp);
 }
 		}
 		verify_current_rnext(tst_name, sk, -1,
 				     collection.keys[i].server_keyid);
-		collection.keys[i].used_on_client = 1;
+		collection.keys[i].used_on_server_tx = 1;
 		synchronize_threads(); /* verify current/rnext */
 	}
 	end_client(tst_name, sk, nr_keys, current_index, rnext_index, &tmp);

tools/testing/selftests/net/tcp_ao/lib/sock.c+8−4

 		return -ETIMEDOUT;
 	}
-	if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &ret, &slen) || ret)
+	if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &ret, &slen))
+		return -errno;
+	if (ret)
 		return -ret;
 	return 0;
 }
 {
 	size_t buf_sz = msg_len * nr;
 	char *buf = alloca(buf_sz);
+	ssize_t ret;
 	randomize_buffer(buf, buf_sz);
-	if (test_client_loop(sk, buf, buf_sz, msg_len, timeout_sec) != buf_sz)
+	ret = test_client_loop(sk, buf, buf_sz, msg_len, timeout_sec);
-		return -1;
+	if (ret < 0)
-	return 0;
+		return (int)ret;
+	return ret != buf_sz ? -1 : 0;
 }

tools/testing/selftests/net/tcp_ao/rst.c+90−48

@@ -1,10 +1,33 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/* Author: Dmitry Safonov <dima@arista.com> */	2	/*
		3	* The test checks that both active and passive reset have correct TCP-AO
		4	* signature. An "active" reset (abort) here is procured from closing
		5	* listen() socket with non-accepted connections in the queue:
		6	* inet_csk_listen_stop() => inet_child_forget() =>
		7	* => tcp_disconnect() => tcp_send_active_reset()
		8	*
		9	* The passive reset is quite hard to get on established TCP connections.
		10	* It could be procured from non-established states, but the synchronization
		11	* part from userspace in order to reliably get RST seems uneasy.
		12	* So, instead it's procured by corrupting SEQ number on TIMED-WAIT state.
		13	*
		14	* It's important to test both passive and active RST as they go through
		15	* different code-paths:
		16	* - tcp_send_active_reset() makes no-data skb, sends it with tcp_transmit_skb()
		17	* - tcp_v*_send_reset() create their reply skbs and send them with
		18	* ip_send_unicast_reply()
		19	*
		20	* In both cases TCP-AO signatures have to be correct, which is verified by
		21	* (1) checking that the TCP-AO connection was reset and (2) TCP-AO counters.
		22	*
		23	* Author: Dmitry Safonov <dima@arista.com>
		24	*/
3	#include <inttypes.h>	25	#include <inttypes.h>
4	#include "../../../../include/linux/kernel.h"	26	#include "../../../../include/linux/kernel.h"
5	#include "aolib.h"	27	#include "aolib.h"
6		28
7	const size_t quota = 1000;	29	const size_t quota = 1000;
		30	const size_t packet_sz = 100;
8	/*	31	/*
9	* Backlog == 0 means 1 connection in queue, see:	32	* Backlog == 0 means 1 connection in queue, see:
10	* commit 64a146513f8f ("[NET]: Revert incorrect accept queue...")	33	* commit 64a146513f8f ("[NET]: Revert incorrect accept queue...")
@@ -59,26 +82,6 @@ static void close_forced(int sk) · 48 unmodified lines
59	close(sk);	82	close(sk);
60	}	83	}
61		84
62	static int test_wait_for_exception(int sk, time_t sec)
63	{
64	struct timeval tv = { .tv_sec = sec };
65	struct timeval *ptv = NULL;
66	fd_set efds;
67	int ret;
68
69	FD_ZERO(&efds);
70	FD_SET(sk, &efds);
71
72	if (sec)
73	ptv = &tv;
74
75	errno = 0;
76	ret = select(sk + 1, NULL, NULL, &efds, ptv);
77	if (ret < 0)
78	return -errno;
79	return ret ? sk : 0;
80	}
81
82	static void test_server_active_rst(unsigned int port)	85	static void test_server_active_rst(unsigned int port)
83	{	86	{
84	struct tcp_ao_counters cnt1, cnt2;	87	struct tcp_ao_counters cnt1, cnt2;
@@ -155,17 +158,16 @@ static void test_server_passive_rst(unsigned int port) · 70 unmodified lines
155	test_fail("server returned %zd", bytes);	158	test_fail("server returned %zd", bytes);
156	}	159	}
157		160
158	synchronize_threads(); /* 3: chekpoint/restore the connection */	161	synchronize_threads(); /* 3: checkpoint the client */
		162	synchronize_threads(); /* 4: close the server, creating twsk */
159	if (test_get_tcp_ao_counters(sk, &ao2))	163	if (test_get_tcp_ao_counters(sk, &ao2))
160	test_error("test_get_tcp_ao_counters()");	164	test_error("test_get_tcp_ao_counters()");
161
162	synchronize_threads(); /* 4: terminate server + send more on client */
163	bytes = test_server_run(sk, quota, TEST_RETRANSMIT_SEC);
164	close(sk);	165	close(sk);
		166
		167	synchronize_threads(); /* 5: restore the socket, send more data */
165	test_tcp_ao_counters_cmp("passive RST server", &ao1, &ao2, TEST_CNT_GOOD);	168	test_tcp_ao_counters_cmp("passive RST server", &ao1, &ao2, TEST_CNT_GOOD);
166		169
167	synchronize_threads(); /* 5: verified => closed */	170	synchronize_threads(); /* 6: server exits */
168	close(sk);
169	}	171	}
170		172
171	static void server_fn(void arg)	173	static void server_fn(void arg)
@@ -284,7 +286,7 @@ static void test_client_active_rst(unsigned int port) · 112 unmodified lines
284	test_error("test_wait_fds(): %d", err);	286	test_error("test_wait_fds(): %d", err);
285		287
286	synchronize_threads(); /* 3: close listen socket */	288	synchronize_threads(); /* 3: close listen socket */
287	if (test_client_verify(sk[0], 100, quota / 100, TEST_TIMEOUT_SEC))	289	if (test_client_verify(sk[0], packet_sz, quota / packet_sz, TEST_TIMEOUT_SEC))
288	test_fail("Failed to send data on connected socket");	290	test_fail("Failed to send data on connected socket");
289	else	291	else
290	test_ok("Verified established tcp connection");	292	test_ok("Verified established tcp connection");
@@ -323,7 +325,6 @@ static void test_client_passive_rst(unsigned int port) · 32 unmodified lines
323	struct tcp_sock_state img;	325	struct tcp_sock_state img;
324	sockaddr_af saddr;	326	sockaddr_af saddr;
325	int sk, err;	327	int sk, err;
326	socklen_t slen = sizeof(err);
327		328
328	sk = socket(test_family, SOCK_STREAM, IPPROTO_TCP);	329	sk = socket(test_family, SOCK_STREAM, IPPROTO_TCP);
329	if (sk < 0)	330	if (sk < 0)
@@ -337,18 +338,51 @@ static void test_client_passive_rst(unsigned int port) · 7 unmodified lines
337	test_error("failed to connect()");	338	test_error("failed to connect()");
338		339
339	synchronize_threads(); /* 2: accepted => send data */	340	synchronize_threads(); /* 2: accepted => send data */
340	if (test_client_verify(sk, 100, quota / 100, TEST_TIMEOUT_SEC))	341	if (test_client_verify(sk, packet_sz, quota / packet_sz, TEST_TIMEOUT_SEC))
341	test_fail("Failed to send data on connected socket");	342	test_fail("Failed to send data on connected socket");
342	else	343	else
343	test_ok("Verified established tcp connection");	344	test_ok("Verified established tcp connection");
344		345
345	synchronize_threads(); /* 3: chekpoint/restore the connection */	346	synchronize_threads(); /* 3: checkpoint the client */
346	test_enable_repair(sk);	347	test_enable_repair(sk);
347	test_sock_checkpoint(sk, &img, &saddr);	348	test_sock_checkpoint(sk, &img, &saddr);
348	test_ao_checkpoint(sk, &ao_img);	349	test_ao_checkpoint(sk, &ao_img);
349	test_kill_sk(sk);	350	test_disable_repair(sk);
350		351
351	img.out.seq += quota;	352	synchronize_threads(); /* 4: close the server, creating twsk */
		353
		354	/*
		355	* The "corruption" in SEQ has to be small enough to fit into TCP
		356	* window, see tcp_timewait_state_process() for out-of-window
		357	* segments.
		358	*/
		359	img.out.seq += 5; /* 5 is more noticeable in tcpdump than 1 */
		360
		361	/*
		362	* FIXME: This is kind-of ugly and dirty, but it works.
		363	*
		364	* At this moment, the server has close'ed(sk).
		365	* The passive RST that is being targeted here is new data after
		366	* half-duplex close, see tcp_timewait_state_process() => TCP_TW_RST
		367	*
		368	* What is needed here is:
		369	* (1) wait for FIN from the server
		370	* (2) make sure that the ACK from the client went out
		371	* (3) make sure that the ACK was received and processed by the server
		372	*
		373	* Otherwise, the data that will be sent from "repaired" socket
		374	* post SEQ corruption may get to the server before it's in
		375	* TCP_FIN_WAIT2.
		376	*
		377	* (1) is easy with select()/poll()
		378	* (2) is possible by polling tcpi_state from TCP_INFO
		379	* (3) is quite complex: as server's socket was already closed,
		380	* probably the way to do it would be tcp-diag.
		381	*/
		382	sleep(TEST_RETRANSMIT_SEC);
		383
		384	synchronize_threads(); /* 5: restore the socket, send more data */
		385	test_kill_sk(sk);
352		386
353	sk = socket(test_family, SOCK_STREAM, IPPROTO_TCP);	387	sk = socket(test_family, SOCK_STREAM, IPPROTO_TCP);
354	if (sk < 0)	388	if (sk < 0)
@@ -366,25 +400,33 @@ static void test_client_passive_rst(unsigned int port) · 11 unmodified lines
366	test_disable_repair(sk);	400	test_disable_repair(sk);
367	test_sock_state_free(&img);	401	test_sock_state_free(&img);
368		402
369	synchronize_threads(); /* 4: terminate server + send more on client */	403	/*
370	if (test_client_verify(sk, 100, quota / 100, 2 * TEST_TIMEOUT_SEC))	404	* This is how "passive reset" is acquired in this test from TCP_TW_RST:
371	test_ok("client connection broken post-seq-adjust");	405	*
372	else	406	* IP 10.0.254.1.7011 > 10.0.1.1.59772: Flags [P.], seq 901:1001, ack 1001, win 249,
373	test_fail("client connection still works post-seq-adjust");	407	* options [tcp-ao keyid 100 rnextkeyid 100 mac 0x10217d6c36a22379086ef3b1], length 100
374		408	* IP 10.0.254.1.7011 > 10.0.1.1.59772: Flags [F.], seq 1001, ack 1001, win 249,
375	test_wait_for_exception(sk, TEST_TIMEOUT_SEC);	409	* options [tcp-ao keyid 100 rnextkeyid 100 mac 0x104ffc99b98c10a5298cc268], length 0
376		410	* IP 10.0.1.1.59772 > 10.0.254.1.7011: Flags [.], ack 1002, win 251,
377	if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &err, &slen))	411	* options [tcp-ao keyid 100 rnextkeyid 100 mac 0xe496dd4f7f5a8a66873c6f93,nop,nop,sack 1 {1001:1002}], length 0
378	test_error("getsockopt()");	412	* IP 10.0.1.1.59772 > 10.0.254.1.7011: Flags [P.], seq 1006:1106, ack 1001, win 251,
379	if (err != ECONNRESET && err != EPIPE)	413	* options [tcp-ao keyid 100 rnextkeyid 100 mac 0x1b5f3330fb23fbcd0c77d0ca], length 100
380	test_fail("client connection was not reset: %d", err);	414	* IP 10.0.254.1.7011 > 10.0.1.1.59772: Flags [R], seq 3215596252, win 0,
		415	* options [tcp-ao keyid 100 rnextkeyid 100 mac 0x0bcfbbf497bce844312304b2], length 0
		416	*/
		417	err = test_client_verify(sk, packet_sz, quota / packet_sz, 2 * TEST_TIMEOUT_SEC);
		418	/* Make sure that the connection was reset, not timeouted */
		419	if (err && err == -ECONNRESET)
		420	test_ok("client sock was passively reset post-seq-adjust");
		421	else if (err)
		422	test_fail("client sock was not reset post-seq-adjust: %d", err);
381	else	423	else
382	test_ok("client connection was reset");	424	test_fail("client sock is yet connected post-seq-adjust");
383		425
384	if (test_get_tcp_ao_counters(sk, &ao2))	426	if (test_get_tcp_ao_counters(sk, &ao2))
385	test_error("test_get_tcp_ao_counters()");	427	test_error("test_get_tcp_ao_counters()");
386		428
387	synchronize_threads(); /* 5: verified => closed */	429	synchronize_threads(); /* 6: server exits */
388	close(sk);	430	close(sk);
389	test_tcp_ao_counters_cmp("client passive RST", &ao1, &ao2, TEST_CNT_GOOD);	431	test_tcp_ao_counters_cmp("client passive RST", &ao1, &ao2, TEST_CNT_GOOD);
390	}	432	}
@@ -410,6 +452,6 @@ static void client_fn(void arg) · 19 unmodified lines
410		452
411	int main(int argc, char *argv[])	453	int main(int argc, char *argv[])
412	{	454	{
413	test_init(15, server_fn, client_fn);	455	test_init(14, server_fn, client_fn);
414	return 0;	456	return 0;
415	}	457	}

tools/testing/selftests/net/tcp_ao/settings+1−0

@@ -0,0 +1 @@
		1	timeout=120

tools/testing/selftests/net/udpgro.sh+2−2

@@ -7,7 +7,7 @@ source net_helper.sh · 6 unmodified lines
7		7
8	readonly PEER_NS="ns-peer-$(mktemp -u XXXXXX)"	8	readonly PEER_NS="ns-peer-$(mktemp -u XXXXXX)"
9		9
10	BPF_FILE="../bpf/xdp_dummy.bpf.o"	10	BPF_FILE="xdp_dummy.o"
11		11
12	# set global exit status, but never reset nonzero one.	12	# set global exit status, but never reset nonzero one.
13	check_err()	13	check_err()
@@ -197,7 +197,7 @@ run_all() { · 183 unmodified lines
197	}	197	}
198		198
199	if [ ! -f ${BPF_FILE} ]; then	199	if [ ! -f ${BPF_FILE} ]; then
200	echo "Missing ${BPF_FILE}. Build bpf selftest first"	200	echo "Missing ${BPF_FILE}. Run 'make' first"
201	exit -1	201	exit -1
202	fi	202	fi
203		203

tools/testing/selftests/net/udpgro_bench.sh+2−2

@@ -7,7 +7,7 @@ source net_helper.sh · 6 unmodified lines
7		7
8	readonly PEER_NS="ns-peer-$(mktemp -u XXXXXX)"	8	readonly PEER_NS="ns-peer-$(mktemp -u XXXXXX)"
9		9
10	BPF_FILE="../bpf/xdp_dummy.bpf.o"	10	BPF_FILE="xdp_dummy.o"
11		11
12	cleanup() {	12	cleanup() {
13	local -r jobs="$(jobs -p)"	13	local -r jobs="$(jobs -p)"
@@ -84,7 +84,7 @@ run_all() { · 70 unmodified lines
84	}	84	}
85		85
86	if [ ! -f ${BPF_FILE} ]; then	86	if [ ! -f ${BPF_FILE} ]; then
87	echo "Missing ${BPF_FILE}. Build bpf selftest first"	87	echo "Missing ${BPF_FILE}. Run 'make' first"
88	exit -1	88	exit -1
89	fi	89	fi
90		90

tools/testing/selftests/net/udpgro_frglist.sh+3−3

@@ -7,7 +7,7 @@ source net_helper.sh · 6 unmodified lines
7		7
8	readonly PEER_NS="ns-peer-$(mktemp -u XXXXXX)"	8	readonly PEER_NS="ns-peer-$(mktemp -u XXXXXX)"
9		9
10	BPF_FILE="../bpf/xdp_dummy.bpf.o"	10	BPF_FILE="xdp_dummy.o"
11		11
12	cleanup() {	12	cleanup() {
13	local -r jobs="$(jobs -p)"	13	local -r jobs="$(jobs -p)"
@@ -85,12 +85,12 @@ run_all() { · 71 unmodified lines
85	}	85	}
86		86
87	if [ ! -f ${BPF_FILE} ]; then	87	if [ ! -f ${BPF_FILE} ]; then
88	echo "Missing ${BPF_FILE}. Build bpf selftest first"	88	echo "Missing ${BPF_FILE}. Run 'make' first"
89	exit -1	89	exit -1
90	fi	90	fi
91		91
92	if [ ! -f nat6to4.o ]; then	92	if [ ! -f nat6to4.o ]; then
93	echo "Missing nat6to4 helper. Build bpf nat6to4.o selftest first"	93	echo "Missing nat6to4 helper. Run 'make' first"
94	exit -1	94	exit -1
95	fi	95	fi
96		96

tools/testing/selftests/net/udpgro_fwd.sh+5−3

 #!/bin/bash
 # SPDX-License-Identifier: GPL-2.0
-BPF_FILE="../bpf/xdp_dummy.bpf.o"
+source net_helper.sh
+BPF_FILE="xdp_dummy.o"
 readonly BASE="ns-$(mktemp -u XXXXXX)"
 readonly SRC=2
 readonly DST=1
 	ip netns exec $NS_DST $ipt -A INPUT -p udp --dport 8000
 	ip netns exec $NS_DST ./udpgso_bench_rx -C 1000 -R 10 -n 10 -l 1300 $rx_args &
 	local spid=$!
-	sleep 0.1
+	wait_local_port_listen "$NS_DST" 8000 udp
 	ip netns exec $NS_SRC ./udpgso_bench_tx $family -M 1 -s 13000 -S 1300 -D $dst
 	local retc=$?
 	wait $spid
 	ip netns exec $NS_DST bash -c "echo 2 > /sys/class/net/veth$DST/queues/rx-0/rps_cpus"
 	ip netns exec $NS_DST taskset 0x2 ./udpgso_bench_rx -C 1000 -R 10  &
 	local spid=$!
-	sleep 0.1
+	wait_local_port_listen "$NS_DST" 8000 udp
 	ip netns exec $NS_SRC taskset 0x1 ./udpgso_bench_tx $family -l 3 -S 1300 -D $dst
 	local retc=$?
 	wait $spid

tools/testing/selftests/net/veth.sh+2−2

@@ -1,7 +1,7 @@
1	#!/bin/sh	1	#!/bin/sh
2	# SPDX-License-Identifier: GPL-2.0	2	# SPDX-License-Identifier: GPL-2.0
3		3
4	BPF_FILE="../bpf/xdp_dummy.bpf.o"	4	BPF_FILE="xdp_dummy.o"
5	readonly STATS="$(mktemp -p /tmp ns-XXXXXX)"	5	readonly STATS="$(mktemp -p /tmp ns-XXXXXX)"
6	readonly BASE=`basename $STATS`	6	readonly BASE=`basename $STATS`
7	readonly SRC=2	7	readonly SRC=2
@@ -218,7 +218,7 @@ while getopts "hs:" option; do · 210 unmodified lines
218	done	218	done
219		219
220	if [ ! -f ${BPF_FILE} ]; then	220	if [ ! -f ${BPF_FILE} ]; then
221	echo "Missing ${BPF_FILE}. Build bpf selftest first"	221	echo "Missing ${BPF_FILE}. Run 'make' first"
222	exit 1	222	exit 1
223	fi	223	fi
224		224

tools/testing/selftests/net/xdp_dummy.c+13−0

@@ -0,0 +1,13 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#define KBUILD_MODNAME "xdp_dummy"
	4	#include <linux/bpf.h>
	5	#include <bpf/bpf_helpers.h>
	6
	7	SEC("xdp")
	8	int xdp_dummy_prog(struct xdp_md *ctx)
	9	{
	10	return XDP_PASS;
	11	}
	12
	13	char _license[] SEC("license") = "GPL";

Merge tag 'net-6.8-rc3' 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