lael-labs/linux

.mailmap+5−4

 Gao Xiang <xiang@kernel.org> <hsiangkao@aol.com>
 Gao Xiang <xiang@kernel.org> <hsiangkao@linux.alibaba.com>
 Gao Xiang <xiang@kernel.org> <hsiangkao@redhat.com>
-Geliang Tang <geliang.tang@linux.dev> <geliang.tang@suse.com>
+Geliang Tang <geliang@kernel.org> <geliang.tang@linux.dev>
-Geliang Tang <geliang.tang@linux.dev> <geliangtang@xiaomi.com>
+Geliang Tang <geliang@kernel.org> <geliang.tang@suse.com>
-Geliang Tang <geliang.tang@linux.dev> <geliangtang@gmail.com>
+Geliang Tang <geliang@kernel.org> <geliangtang@xiaomi.com>
-Geliang Tang <geliang.tang@linux.dev> <geliangtang@163.com>
+Geliang Tang <geliang@kernel.org> <geliangtang@gmail.com>
+Geliang Tang <geliang@kernel.org> <geliangtang@163.com>
 Georgi Djakov <djakov@kernel.org> <georgi.djakov@linaro.org>
 Gerald Schaefer <gerald.schaefer@linux.ibm.com> <geraldsc@de.ibm.com>
 Gerald Schaefer <gerald.schaefer@linux.ibm.com> <gerald.schaefer@de.ibm.com>

Documentation/ABI/testing/sysfs-class-net-statistics+24−24

@@ -1,4 +1,4 @@
1	What: /sys/class/<iface>/statistics/collisions	1	What: /sys/class/net/<iface>/statistics/collisions
2	Date: April 2005	2	Date: April 2005
3	KernelVersion: 2.6.12	3	KernelVersion: 2.6.12
4	Contact: netdev@vger.kernel.org	4	Contact: netdev@vger.kernel.org
@@ -6,7 +6,7 @@ Description: · 1 unmodified line
6	Indicates the number of collisions seen by this network device.	6	Indicates the number of collisions seen by this network device.
7	This value might not be relevant with all MAC layers.	7	This value might not be relevant with all MAC layers.
8		8
9	What: /sys/class/<iface>/statistics/multicast	9	What: /sys/class/net/<iface>/statistics/multicast
10	Date: April 2005	10	Date: April 2005
11	KernelVersion: 2.6.12	11	KernelVersion: 2.6.12
12	Contact: netdev@vger.kernel.org	12	Contact: netdev@vger.kernel.org
@@ -14,7 +14,7 @@ Description: · 1 unmodified line
14	Indicates the number of multicast packets received by this	14	Indicates the number of multicast packets received by this
15	network device.	15	network device.
16		16
17	What: /sys/class/<iface>/statistics/rx_bytes	17	What: /sys/class/net/<iface>/statistics/rx_bytes
18	Date: April 2005	18	Date: April 2005
19	KernelVersion: 2.6.12	19	KernelVersion: 2.6.12
20	Contact: netdev@vger.kernel.org	20	Contact: netdev@vger.kernel.org
@@ -23,7 +23,7 @@ Description: · 2 unmodified lines
23	See the network driver for the exact meaning of when this	23	See the network driver for the exact meaning of when this
24	value is incremented.	24	value is incremented.
25		25
26	What: /sys/class/<iface>/statistics/rx_compressed	26	What: /sys/class/net/<iface>/statistics/rx_compressed
27	Date: April 2005	27	Date: April 2005
28	KernelVersion: 2.6.12	28	KernelVersion: 2.6.12
29	Contact: netdev@vger.kernel.org	29	Contact: netdev@vger.kernel.org
@@ -32,7 +32,7 @@ Description: · 2 unmodified lines
32	network device. This value might only be relevant for interfaces	32	network device. This value might only be relevant for interfaces
33	that support packet compression (e.g: PPP).	33	that support packet compression (e.g: PPP).
34		34
35	What: /sys/class/<iface>/statistics/rx_crc_errors	35	What: /sys/class/net/<iface>/statistics/rx_crc_errors
36	Date: April 2005	36	Date: April 2005
37	KernelVersion: 2.6.12	37	KernelVersion: 2.6.12
38	Contact: netdev@vger.kernel.org	38	Contact: netdev@vger.kernel.org
@@ -41,7 +41,7 @@ Description: · 2 unmodified lines
41	by this network device. Note that the specific meaning might	41	by this network device. Note that the specific meaning might
42	depend on the MAC layer used by the interface.	42	depend on the MAC layer used by the interface.
43		43
44	What: /sys/class/<iface>/statistics/rx_dropped	44	What: /sys/class/net/<iface>/statistics/rx_dropped
45	Date: April 2005	45	Date: April 2005
46	KernelVersion: 2.6.12	46	KernelVersion: 2.6.12
47	Contact: netdev@vger.kernel.org	47	Contact: netdev@vger.kernel.org
@@ -51,7 +51,7 @@ Description: · 3 unmodified lines
51	packet processing. See the network driver for the exact	51	packet processing. See the network driver for the exact
52	meaning of this value.	52	meaning of this value.
53		53
54	What: /sys/class/<iface>/statistics/rx_errors	54	What: /sys/class/net/<iface>/statistics/rx_errors
55	Date: April 2005	55	Date: April 2005
56	KernelVersion: 2.6.12	56	KernelVersion: 2.6.12
57	Contact: netdev@vger.kernel.org	57	Contact: netdev@vger.kernel.org
@@ -59,7 +59,7 @@ Description: · 1 unmodified line
59	Indicates the number of receive errors on this network device.	59	Indicates the number of receive errors on this network device.
60	See the network driver for the exact meaning of this value.	60	See the network driver for the exact meaning of this value.
61		61
62	What: /sys/class/<iface>/statistics/rx_fifo_errors	62	What: /sys/class/net/<iface>/statistics/rx_fifo_errors
63	Date: April 2005	63	Date: April 2005
64	KernelVersion: 2.6.12	64	KernelVersion: 2.6.12
65	Contact: netdev@vger.kernel.org	65	Contact: netdev@vger.kernel.org
@@ -68,7 +68,7 @@ Description: · 2 unmodified lines
68	network device. See the network driver for the exact	68	network device. See the network driver for the exact
69	meaning of this value.	69	meaning of this value.
70		70
71	What: /sys/class/<iface>/statistics/rx_frame_errors	71	What: /sys/class/net/<iface>/statistics/rx_frame_errors
72	Date: April 2005	72	Date: April 2005
73	KernelVersion: 2.6.12	73	KernelVersion: 2.6.12
74	Contact: netdev@vger.kernel.org	74	Contact: netdev@vger.kernel.org
@@ -78,7 +78,7 @@ Description: · 3 unmodified lines
78	on the MAC layer protocol used. See the network driver for	78	on the MAC layer protocol used. See the network driver for
79	the exact meaning of this value.	79	the exact meaning of this value.
80		80
81	What: /sys/class/<iface>/statistics/rx_length_errors	81	What: /sys/class/net/<iface>/statistics/rx_length_errors
82	Date: April 2005	82	Date: April 2005
83	KernelVersion: 2.6.12	83	KernelVersion: 2.6.12
84	Contact: netdev@vger.kernel.org	84	Contact: netdev@vger.kernel.org
@@ -87,7 +87,7 @@ Description: · 2 unmodified lines
87	error, oversized or undersized. See the network driver for the	87	error, oversized or undersized. See the network driver for the
88	exact meaning of this value.	88	exact meaning of this value.
89		89
90	What: /sys/class/<iface>/statistics/rx_missed_errors	90	What: /sys/class/net/<iface>/statistics/rx_missed_errors
91	Date: April 2005	91	Date: April 2005
92	KernelVersion: 2.6.12	92	KernelVersion: 2.6.12
93	Contact: netdev@vger.kernel.org	93	Contact: netdev@vger.kernel.org
@@ -96,7 +96,7 @@ Description: · 2 unmodified lines
96	due to lack of capacity in the receive side. See the network	96	due to lack of capacity in the receive side. See the network
97	driver for the exact meaning of this value.	97	driver for the exact meaning of this value.
98		98
99	What: /sys/class/<iface>/statistics/rx_nohandler	99	What: /sys/class/net/<iface>/statistics/rx_nohandler
100	Date: February 2016	100	Date: February 2016
101	KernelVersion: 4.6	101	KernelVersion: 4.6
102	Contact: netdev@vger.kernel.org	102	Contact: netdev@vger.kernel.org
@@ -104,7 +104,7 @@ Description: · 1 unmodified line
104	Indicates the number of received packets that were dropped on	104	Indicates the number of received packets that were dropped on
105	an inactive device by the network core.	105	an inactive device by the network core.
106		106
107	What: /sys/class/<iface>/statistics/rx_over_errors	107	What: /sys/class/net/<iface>/statistics/rx_over_errors
108	Date: April 2005	108	Date: April 2005
109	KernelVersion: 2.6.12	109	KernelVersion: 2.6.12
110	Contact: netdev@vger.kernel.org	110	Contact: netdev@vger.kernel.org
@@ -114,7 +114,7 @@ Description: · 3 unmodified lines
114	(e.g: larger than MTU). See the network driver for the exact	114	(e.g: larger than MTU). See the network driver for the exact
115	meaning of this value.	115	meaning of this value.
116		116
117	What: /sys/class/<iface>/statistics/rx_packets	117	What: /sys/class/net/<iface>/statistics/rx_packets
118	Date: April 2005	118	Date: April 2005
119	KernelVersion: 2.6.12	119	KernelVersion: 2.6.12
120	Contact: netdev@vger.kernel.org	120	Contact: netdev@vger.kernel.org
@@ -122,7 +122,7 @@ Description: · 1 unmodified line
122	Indicates the total number of good packets received by this	122	Indicates the total number of good packets received by this
123	network device.	123	network device.
124		124
125	What: /sys/class/<iface>/statistics/tx_aborted_errors	125	What: /sys/class/net/<iface>/statistics/tx_aborted_errors
126	Date: April 2005	126	Date: April 2005
127	KernelVersion: 2.6.12	127	KernelVersion: 2.6.12
128	Contact: netdev@vger.kernel.org	128	Contact: netdev@vger.kernel.org
@@ -132,7 +132,7 @@ Description: · 3 unmodified lines
132	a medium collision). See the network driver for the exact	132	a medium collision). See the network driver for the exact
133	meaning of this value.	133	meaning of this value.
134		134
135	What: /sys/class/<iface>/statistics/tx_bytes	135	What: /sys/class/net/<iface>/statistics/tx_bytes
136	Date: April 2005	136	Date: April 2005
137	KernelVersion: 2.6.12	137	KernelVersion: 2.6.12
138	Contact: netdev@vger.kernel.org	138	Contact: netdev@vger.kernel.org
@@ -143,7 +143,7 @@ Description: · 4 unmodified lines
143	transmitted packets or all packets that have been queued for	143	transmitted packets or all packets that have been queued for
144	transmission.	144	transmission.
145		145
146	What: /sys/class/<iface>/statistics/tx_carrier_errors	146	What: /sys/class/net/<iface>/statistics/tx_carrier_errors
147	Date: April 2005	147	Date: April 2005
148	KernelVersion: 2.6.12	148	KernelVersion: 2.6.12
149	Contact: netdev@vger.kernel.org	149	Contact: netdev@vger.kernel.org
@@ -152,7 +152,7 @@ Description: · 2 unmodified lines
152	because of carrier errors (e.g: physical link down). See the	152	because of carrier errors (e.g: physical link down). See the
153	network driver for the exact meaning of this value.	153	network driver for the exact meaning of this value.
154		154
155	What: /sys/class/<iface>/statistics/tx_compressed	155	What: /sys/class/net/<iface>/statistics/tx_compressed
156	Date: April 2005	156	Date: April 2005
157	KernelVersion: 2.6.12	157	KernelVersion: 2.6.12
158	Contact: netdev@vger.kernel.org	158	Contact: netdev@vger.kernel.org
@@ -161,7 +161,7 @@ Description: · 2 unmodified lines
161	this might only be relevant for devices that support	161	this might only be relevant for devices that support
162	compression (e.g: PPP).	162	compression (e.g: PPP).
163		163
164	What: /sys/class/<iface>/statistics/tx_dropped	164	What: /sys/class/net/<iface>/statistics/tx_dropped
165	Date: April 2005	165	Date: April 2005
166	KernelVersion: 2.6.12	166	KernelVersion: 2.6.12
167	Contact: netdev@vger.kernel.org	167	Contact: netdev@vger.kernel.org
@@ -170,7 +170,7 @@ Description: · 2 unmodified lines
170	See the driver for the exact reasons as to why the packets were	170	See the driver for the exact reasons as to why the packets were
171	dropped.	171	dropped.
172		172
173	What: /sys/class/<iface>/statistics/tx_errors	173	What: /sys/class/net/<iface>/statistics/tx_errors
174	Date: April 2005	174	Date: April 2005
175	KernelVersion: 2.6.12	175	KernelVersion: 2.6.12
176	Contact: netdev@vger.kernel.org	176	Contact: netdev@vger.kernel.org
@@ -179,7 +179,7 @@ Description: · 2 unmodified lines
179	a network device. See the driver for the exact reasons as to	179	a network device. See the driver for the exact reasons as to
180	why the packets were dropped.	180	why the packets were dropped.
181		181
182	What: /sys/class/<iface>/statistics/tx_fifo_errors	182	What: /sys/class/net/<iface>/statistics/tx_fifo_errors
183	Date: April 2005	183	Date: April 2005
184	KernelVersion: 2.6.12	184	KernelVersion: 2.6.12
185	Contact: netdev@vger.kernel.org	185	Contact: netdev@vger.kernel.org
@@ -188,7 +188,7 @@ Description: · 2 unmodified lines
188	FIFO error. See the driver for the exact reasons as to why the	188	FIFO error. See the driver for the exact reasons as to why the
189	packets were dropped.	189	packets were dropped.
190		190
191	What: /sys/class/<iface>/statistics/tx_heartbeat_errors	191	What: /sys/class/net/<iface>/statistics/tx_heartbeat_errors
192	Date: April 2005	192	Date: April 2005
193	KernelVersion: 2.6.12	193	KernelVersion: 2.6.12
194	Contact: netdev@vger.kernel.org	194	Contact: netdev@vger.kernel.org
@@ -197,7 +197,7 @@ Description: · 2 unmodified lines
197	reported as heartbeat errors. See the driver for the exact	197	reported as heartbeat errors. See the driver for the exact
198	reasons as to why the packets were dropped.	198	reasons as to why the packets were dropped.
199		199
200	What: /sys/class/<iface>/statistics/tx_packets	200	What: /sys/class/net/<iface>/statistics/tx_packets
201	Date: April 2005	201	Date: April 2005
202	KernelVersion: 2.6.12	202	KernelVersion: 2.6.12
203	Contact: netdev@vger.kernel.org	203	Contact: netdev@vger.kernel.org
@@ -206,7 +206,7 @@ Description: · 2 unmodified lines
206	device. See the driver for whether this reports the number of all	206	device. See the driver for whether this reports the number of all
207	attempted or successful transmissions.	207	attempted or successful transmissions.
208		208
209	What: /sys/class/<iface>/statistics/tx_window_errors	209	What: /sys/class/net/<iface>/statistics/tx_window_errors
210	Date: April 2005	210	Date: April 2005
211	KernelVersion: 2.6.12	211	KernelVersion: 2.6.12
212	Contact: netdev@vger.kernel.org	212	Contact: netdev@vger.kernel.org

Documentation/netlink/specs/dpll.yaml+0−4

             - type
       dump:
-        pre: dpll-lock-dumpit
-        post: dpll-unlock-dumpit
         reply: *dev-attrs
     -
             - fractional-frequency-offset
       dump:
-        pre: dpll-lock-dumpit
-        post: dpll-unlock-dumpit
         request:
           attributes:
             - id

Documentation/networking/devlink/devlink-port.rst+1−1

@@ -126,7 +126,7 @@ Users may also set the RoCE capability of the function using · 125 unmodified lines
126	`devlink port function set roce` command.	126	`devlink port function set roce` command.
127		127
128	Users may also set the function as migratable using	128	Users may also set the function as migratable using
129	'devlink port function set migratable' command.	129	`devlink port function set migratable` command.
130		130
131	Users may also set the IPsec crypto capability of the function using	131	Users may also set the IPsec crypto capability of the function using
132	`devlink port function set ipsec_crypto` command.	132	`devlink port function set ipsec_crypto` command.

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

@@ -136,8 +136,8 @@ struct_netpoll_info* npinfo - · 135 unmodified lines
136	possible_net_t nd_net - read_mostly (dev_net)napi_busy_loop,tcp_v(4/6)_rcv,ip(v6)_rcv,ip(6)_input,ip(6)_input_finish	136	possible_net_t nd_net - read_mostly (dev_net)napi_busy_loop,tcp_v(4/6)_rcv,ip(v6)_rcv,ip(6)_input,ip(6)_input_finish
137	void* ml_priv	137	void* ml_priv
138	enum_netdev_ml_priv_type ml_priv_type	138	enum_netdev_ml_priv_type ml_priv_type
139	struct_pcpu_lstats__percpu* lstats	139	struct_pcpu_lstats__percpu* lstats read_mostly dev_lstats_add()
140	struct_pcpu_sw_netstats__percpu* tstats	140	struct_pcpu_sw_netstats__percpu* tstats read_mostly dev_sw_netstats_tx_add()
141	struct_pcpu_dstats__percpu* dstats	141	struct_pcpu_dstats__percpu* dstats
142	struct_garp_port* garp_port	142	struct_garp_port* garp_port
143	struct_mrp_port* mrp_port	143	struct_mrp_port* mrp_port

Documentation/networking/net_cachelines/tcp_sock.rst+2−2

@@ -38,13 +38,13 @@ u32 max_window read_mostly - · 37 unmodified lines
38	u32 mss_cache read_mostly read_mostly tcp_rate_check_app_limited,tcp_current_mss,tcp_sync_mss,tcp_sndbuf_expand,tcp_tso_should_defer(tx);tcp_update_pacing_rate,tcp_clean_rtx_queue(rx)	38	u32 mss_cache read_mostly read_mostly tcp_rate_check_app_limited,tcp_current_mss,tcp_sync_mss,tcp_sndbuf_expand,tcp_tso_should_defer(tx);tcp_update_pacing_rate,tcp_clean_rtx_queue(rx)
39	u32 window_clamp read_mostly read_write tcp_rcv_space_adjust,__tcp_select_window	39	u32 window_clamp read_mostly read_write tcp_rcv_space_adjust,__tcp_select_window
40	u32 rcv_ssthresh read_mostly - __tcp_select_window	40	u32 rcv_ssthresh read_mostly - __tcp_select_window
41	u82 scaling_ratio	41	u8 scaling_ratio read_mostly read_mostly tcp_win_from_space
42	struct tcp_rack	42	struct tcp_rack
43	u16 advmss - read_mostly tcp_rcv_space_adjust	43	u16 advmss - read_mostly tcp_rcv_space_adjust
44	u8 compressed_ack	44	u8 compressed_ack
45	u8:2 dup_ack_counter	45	u8:2 dup_ack_counter
46	u8:1 tlp_retrans	46	u8:1 tlp_retrans
47	u8:1 tcp_usec_ts	47	u8:1 tcp_usec_ts read_mostly read_mostly
48	u32 chrono_start read_write - tcp_chrono_start/stop(tcp_write_xmit,tcp_cwnd_validate,tcp_send_syn_data)	48	u32 chrono_start read_write - tcp_chrono_start/stop(tcp_write_xmit,tcp_cwnd_validate,tcp_send_syn_data)
49	u32[3] chrono_stat read_write - tcp_chrono_start/stop(tcp_write_xmit,tcp_cwnd_validate,tcp_send_syn_data)	49	u32[3] chrono_stat read_write - tcp_chrono_start/stop(tcp_write_xmit,tcp_cwnd_validate,tcp_send_syn_data)
50	u8:2 chrono_type read_write - tcp_chrono_start/stop(tcp_write_xmit,tcp_cwnd_validate,tcp_send_syn_data)	50	u8:2 chrono_type read_write - tcp_chrono_start/stop(tcp_write_xmit,tcp_cwnd_validate,tcp_send_syn_data)

MAINTAINERS+1−1

@@ -15324,7 +15324,7 @@ K: \bmdo_ · 15323 unmodified lines
15324	NETWORKING [MPTCP]	15324	NETWORKING [MPTCP]
15325	M: Matthieu Baerts <matttbe@kernel.org>	15325	M: Matthieu Baerts <matttbe@kernel.org>
15326	M: Mat Martineau <martineau@kernel.org>	15326	M: Mat Martineau <martineau@kernel.org>
15327	R: Geliang Tang <geliang.tang@linux.dev>	15327	R: Geliang Tang <geliang@kernel.org>
15328	L: netdev@vger.kernel.org	15328	L: netdev@vger.kernel.org
15329	L: mptcp@lists.linux.dev	15329	L: mptcp@lists.linux.dev
15330	S: Maintained	15330	S: Maintained

drivers/connector/cn_proc.c+2−3

@@ -108,9 +108,8 @@ static inline void send_msg(struct cn_msg *msg) · 107 unmodified lines
108	filter_data[1] = 0;	108	filter_data[1] = 0;
109	}	109	}
110		110
111	if (cn_netlink_send_mult(msg, msg->len, 0, CN_IDX_PROC, GFP_NOWAIT,	111	cn_netlink_send_mult(msg, msg->len, 0, CN_IDX_PROC, GFP_NOWAIT,
112	cn_filter, (void *)filter_data) == -ESRCH)	112	cn_filter, (void *)filter_data);
113	atomic_set(&proc_event_num_listeners, 0);
114		113
115	local_unlock(&local_event.lock);	114	local_unlock(&local_event.lock);
116	}	115	}

drivers/dpll/dpll_netlink.c+6−14

 	unsigned long i;
 	int ret = 0;
+	mutex_lock(&dpll_lock);
 	xa_for_each_marked_start(&dpll_pin_xa, i, pin, DPLL_REGISTERED,
 				 ctx->idx) {
 		if (!dpll_pin_available(pin))
 		}
 		genlmsg_end(skb, hdr);
 	}
+	mutex_unlock(&dpll_lock);
 	if (ret == -EMSGSIZE) {
 		ctx->idx = i;
 		return skb->len;
 	unsigned long i;
 	int ret = 0;
+	mutex_lock(&dpll_lock);
 	xa_for_each_marked_start(&dpll_device_xa, i, dpll, DPLL_REGISTERED,
 				 ctx->idx) {
 		hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
 		}
 		genlmsg_end(skb, hdr);
 	}
+	mutex_unlock(&dpll_lock);
 	if (ret == -EMSGSIZE) {
 		ctx->idx = i;
 		return skb->len;
 	mutex_unlock(&dpll_lock);
 }
-int dpll_lock_dumpit(struct netlink_callback *cb)
-{
-	mutex_lock(&dpll_lock);
-	return 0;
-}
-int dpll_unlock_dumpit(struct netlink_callback *cb)
-{
-	mutex_unlock(&dpll_lock);
-	return 0;
-}
 int dpll_pin_pre_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
 		      struct genl_info *info)
 {

drivers/dpll/dpll_nl.c+0−4

 	},
 	{
 		.cmd	= DPLL_CMD_DEVICE_GET,
-		.start	= dpll_lock_dumpit,
 		.dumpit	= dpll_nl_device_get_dumpit,
-		.done	= dpll_unlock_dumpit,
 		.flags	= GENL_ADMIN_PERM | GENL_CMD_CAP_DUMP,
 	},
 	{
 	},
 	{
 		.cmd		= DPLL_CMD_PIN_GET,
-		.start		= dpll_lock_dumpit,
 		.dumpit		= dpll_nl_pin_get_dumpit,
-		.done		= dpll_unlock_dumpit,
 		.policy		= dpll_pin_get_dump_nl_policy,
 		.maxattr	= DPLL_A_PIN_ID,
 		.flags		= GENL_ADMIN_PERM | GENL_CMD_CAP_DUMP,

drivers/dpll/dpll_nl.h+0−2

@@ -30,8 +30,6 @@ dpll_post_doit(const struct genl_split_ops ops, struct sk_buff skb, · 29 unmodified lines
30	void	30	void
31	dpll_pin_post_doit(const struct genl_split_ops ops, struct sk_buff skb,	31	dpll_pin_post_doit(const struct genl_split_ops ops, struct sk_buff skb,
32	struct genl_info *info);	32	struct genl_info *info);
33	int dpll_lock_dumpit(struct netlink_callback *cb);
34	int dpll_unlock_dumpit(struct netlink_callback *cb);
35		33
36	int dpll_nl_device_id_get_doit(struct sk_buff skb, struct genl_info info);	34	int dpll_nl_device_id_get_doit(struct sk_buff skb, struct genl_info info);
37	int dpll_nl_device_get_doit(struct sk_buff skb, struct genl_info info);	35	int dpll_nl_device_get_doit(struct sk_buff skb, struct genl_info info);

drivers/net/arcnet/arc-rawmode.c+1−0

@@ -186,4 +186,5 @@ static void __exit arcnet_raw_exit(void) · 185 unmodified lines
186	module_init(arcnet_raw_init);	186	module_init(arcnet_raw_init);
187	module_exit(arcnet_raw_exit);	187	module_exit(arcnet_raw_exit);
188		188
		189	MODULE_DESCRIPTION("ARCnet raw mode packet interface module");
189	MODULE_LICENSE("GPL");	190	MODULE_LICENSE("GPL");

drivers/net/arcnet/arc-rimi.c+1−0

@@ -312,6 +312,7 @@ module_param(node, int, 0); · 311 unmodified lines
312	module_param(io, int, 0);	312	module_param(io, int, 0);
313	module_param(irq, int, 0);	313	module_param(irq, int, 0);
314	module_param_string(device, device, sizeof(device), 0);	314	module_param_string(device, device, sizeof(device), 0);
		315	MODULE_DESCRIPTION("ARCnet COM90xx RIM I chipset driver");
315	MODULE_LICENSE("GPL");	316	MODULE_LICENSE("GPL");
316		317
317	static struct net_device *my_dev;	318	static struct net_device *my_dev;

drivers/net/arcnet/capmode.c+1−0

@@ -265,4 +265,5 @@ static void __exit capmode_module_exit(void) · 264 unmodified lines
265	module_init(capmode_module_init);	265	module_init(capmode_module_init);
266	module_exit(capmode_module_exit);	266	module_exit(capmode_module_exit);
267		267
		268	MODULE_DESCRIPTION("ARCnet CAP mode packet interface module");
268	MODULE_LICENSE("GPL");	269	MODULE_LICENSE("GPL");

drivers/net/arcnet/com20020-pci.c+1−0

@@ -61,6 +61,7 @@ module_param(timeout, int, 0); · 60 unmodified lines
61	module_param(backplane, int, 0);	61	module_param(backplane, int, 0);
62	module_param(clockp, int, 0);	62	module_param(clockp, int, 0);
63	module_param(clockm, int, 0);	63	module_param(clockm, int, 0);
		64	MODULE_DESCRIPTION("ARCnet COM20020 chipset PCI driver");
64	MODULE_LICENSE("GPL");	65	MODULE_LICENSE("GPL");
65		66
66	static void led_tx_set(struct led_classdev *led_cdev,	67	static void led_tx_set(struct led_classdev *led_cdev,

drivers/net/arcnet/com20020.c+1−0

@@ -399,6 +399,7 @@ EXPORT_SYMBOL(com20020_found); · 398 unmodified lines
399	EXPORT_SYMBOL(com20020_netdev_ops);	399	EXPORT_SYMBOL(com20020_netdev_ops);
400	#endif	400	#endif
401		401
		402	MODULE_DESCRIPTION("ARCnet COM20020 chipset core driver");
402	MODULE_LICENSE("GPL");	403	MODULE_LICENSE("GPL");
403		404
404	#ifdef MODULE	405	#ifdef MODULE

drivers/net/arcnet/com20020_cs.c+1−0

@@ -97,6 +97,7 @@ module_param(backplane, int, 0); · 96 unmodified lines
97	module_param(clockp, int, 0);	97	module_param(clockp, int, 0);
98	module_param(clockm, int, 0);	98	module_param(clockm, int, 0);
99		99
		100	MODULE_DESCRIPTION("ARCnet COM20020 chipset PCMCIA driver");
100	MODULE_LICENSE("GPL");	101	MODULE_LICENSE("GPL");
101		102
102	/====================================================================/	103	/====================================================================/

drivers/net/arcnet/com90io.c+1−0

@@ -350,6 +350,7 @@ static char device[9]; /* use eg. device=arc1 to change name */ · 349 unmodified lines
350	module_param_hw(io, int, ioport, 0);	350	module_param_hw(io, int, ioport, 0);
351	module_param_hw(irq, int, irq, 0);	351	module_param_hw(irq, int, irq, 0);
352	module_param_string(device, device, sizeof(device), 0);	352	module_param_string(device, device, sizeof(device), 0);
		353	MODULE_DESCRIPTION("ARCnet COM90xx IO mapped chipset driver");
353	MODULE_LICENSE("GPL");	354	MODULE_LICENSE("GPL");
354		355
355	#ifndef MODULE	356	#ifndef MODULE

drivers/net/arcnet/com90xx.c+1−0

@@ -645,6 +645,7 @@ static void com90xx_copy_from_card(struct net_device *dev, int bufnum, · 644 unmodified lines
645	TIME(dev, "memcpy_fromio", count, memcpy_fromio(buf, memaddr, count));	645	TIME(dev, "memcpy_fromio", count, memcpy_fromio(buf, memaddr, count));
646	}	646	}
647		647
		648	MODULE_DESCRIPTION("ARCnet COM90xx normal chipset driver");
648	MODULE_LICENSE("GPL");	649	MODULE_LICENSE("GPL");
649		650
650	static int __init com90xx_init(void)	651	static int __init com90xx_init(void)

drivers/net/arcnet/rfc1051.c+1−0

@@ -78,6 +78,7 @@ static void __exit arcnet_rfc1051_exit(void) · 77 unmodified lines
78	module_init(arcnet_rfc1051_init);	78	module_init(arcnet_rfc1051_init);
79	module_exit(arcnet_rfc1051_exit);	79	module_exit(arcnet_rfc1051_exit);
80		80
		81	MODULE_DESCRIPTION("ARCNet packet format (RFC 1051) module");
81	MODULE_LICENSE("GPL");	82	MODULE_LICENSE("GPL");
82		83
83	/* Determine a packet's protocol ID.	84	/* Determine a packet's protocol ID.

drivers/net/arcnet/rfc1201.c+1−0

@@ -35,6 +35,7 @@ · 34 unmodified lines
35		35
36	#include "arcdevice.h"	36	#include "arcdevice.h"
37		37
		38	MODULE_DESCRIPTION("ARCNet packet format (RFC 1201) module");
38	MODULE_LICENSE("GPL");	39	MODULE_LICENSE("GPL");
39		40
40	static __be16 type_trans(struct sk_buff skb, struct net_device dev);	41	static __be16 type_trans(struct sk_buff skb, struct net_device dev);

drivers/net/bonding/bond_main.c+2−3

 	bond_for_each_slave(bond, slave, iter)
 		val &= slave->dev->xdp_features;
+	val &= ~NETDEV_XDP_ACT_XSK_ZEROCOPY;
 	xdp_set_features_flag(bond_dev, val);
 }
 	if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP)
 		bond_dev->features |= BOND_XFRM_FEATURES;
 #endif /* CONFIG_XFRM_OFFLOAD */
-	if (bond_xdp_check(bond))
-		bond_dev->xdp_features = NETDEV_XDP_ACT_MASK;
 }
 /* Destroy a bonding device.

drivers/net/can/dev/netlink.c+1−1

@@ -346,7 +346,7 @@ static int can_changelink(struct net_device dev, struct nlattr tb[], · 345 unmodified lines
346	/* Neither of TDC parameters nor TDC flags are	346	/* Neither of TDC parameters nor TDC flags are
347	* provided: do calculation	347	* provided: do calculation
348	*/	348	*/
349	can_calc_tdco(&priv->tdc, priv->tdc_const, &priv->data_bittiming,	349	can_calc_tdco(&priv->tdc, priv->tdc_const, &dbt,
350	&priv->ctrlmode, priv->ctrlmode_supported);	350	&priv->ctrlmode, priv->ctrlmode_supported);
351	} /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly	351	} /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly
352	* turned off. TDC is disabled: do nothing	352	* turned off. TDC is disabled: do nothing

drivers/net/dsa/dsa_loop_bdinfo.c+1−0

@@ -32,4 +32,5 @@ static int __init dsa_loop_bdinfo_init(void) · 31 unmodified lines
32	}	32	}
33	arch_initcall(dsa_loop_bdinfo_init)	33	arch_initcall(dsa_loop_bdinfo_init)
34		34
		35	MODULE_DESCRIPTION("DSA mock-up switch driver");
35	MODULE_LICENSE("GPL");	36	MODULE_LICENSE("GPL");

drivers/net/ethernet/amd/pds_core/main.c+6−0

 static void pdsc_stop_health_thread(struct pdsc *pdsc)
 {
+	if (pdsc->pdev->is_virtfn)
+		return;
 	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)
 {
+	if (pdsc->pdev->is_virtfn)
+		return;
 	timer_setup(&pdsc->wdtimer, pdsc_wdtimer_cb, 0);
 	mod_timer(&pdsc->wdtimer, jiffies + 1);
 }

drivers/net/ethernet/broadcom/asp2/bcmasp_intf.c+3−0

 	intf->rx_buf_order = get_order(RING_BUFFER_SIZE);
 	buffer_pg = alloc_pages(GFP_KERNEL, intf->rx_buf_order);
+	if (!buffer_pg)
+		return -ENOMEM;
 	dma = dma_map_page(kdev, buffer_pg, 0, RING_BUFFER_SIZE,
 			   DMA_FROM_DEVICE);
 	return 0;
 err_reclaim_tx:
+	netif_napi_del(&intf->tx_napi);
 	bcmasp_reclaim_free_all_tx(intf);
 err_phy_disconnect:
 	if (phydev)

drivers/net/ethernet/brocade/bna/bnad.c+5−7

  * Free all TxQs buffers and then notify TX_E_CLEANUP_DONE to Tx fsm.
  */
 static void
-bnad_tx_cleanup(struct delayed_work *work)
+bnad_tx_cleanup(struct work_struct *work)
 {
 	struct bnad_tx_info *tx_info =
-		container_of(work, struct bnad_tx_info, tx_cleanup_work);
+		container_of(work, struct bnad_tx_info, tx_cleanup_work.work);
 	struct bnad *bnad = NULL;
 	struct bna_tcb *tcb;
 	unsigned long flags;
  * Free all RxQs buffers and then notify RX_E_CLEANUP_DONE to Rx fsm.
  */
 static void
-bnad_rx_cleanup(void *work)
+bnad_rx_cleanup(struct work_struct *work)
 {
 	struct bnad_rx_info *rx_info =
 		container_of(work, struct bnad_rx_info, rx_cleanup_work);
 	}
 	tx_info->tx = tx;
-	INIT_DELAYED_WORK(&tx_info->tx_cleanup_work,
+	INIT_DELAYED_WORK(&tx_info->tx_cleanup_work, bnad_tx_cleanup);
-			(work_func_t)bnad_tx_cleanup);
 	/* Register ISR for the Tx object */
 	if (intr_info->intr_type == BNA_INTR_T_MSIX) {
 	rx_info->rx = rx;
 	spin_unlock_irqrestore(&bnad->bna_lock, flags);
-	INIT_WORK(&rx_info->rx_cleanup_work,
+	INIT_WORK(&rx_info->rx_cleanup_work, bnad_rx_cleanup);
-			(work_func_t)(bnad_rx_cleanup));
 	/*
 	 * Init NAPI, so that state is set to NAPI_STATE_SCHED,

drivers/net/ethernet/intel/i40e/i40e_dcb.c+1−1

@@ -1523,7 +1523,7 @@ void i40e_dcb_hw_rx_ets_bw_config(struct i40e_hw hw, u8 bw_share, · 1522 unmodified lines
1523	reg = rd32(hw, I40E_PRTDCB_RETSTCC(i));	1523	reg = rd32(hw, I40E_PRTDCB_RETSTCC(i));
1524	reg &= ~(I40E_PRTDCB_RETSTCC_BWSHARE_MASK \|	1524	reg &= ~(I40E_PRTDCB_RETSTCC_BWSHARE_MASK \|
1525	I40E_PRTDCB_RETSTCC_UPINTC_MODE_MASK \|	1525	I40E_PRTDCB_RETSTCC_UPINTC_MODE_MASK \|
1526	I40E_PRTDCB_RETSTCC_ETSTC_SHIFT);	1526	I40E_PRTDCB_RETSTCC_ETSTC_MASK);
1527	reg \|= FIELD_PREP(I40E_PRTDCB_RETSTCC_BWSHARE_MASK,	1527	reg \|= FIELD_PREP(I40E_PRTDCB_RETSTCC_BWSHARE_MASK,
1528	bw_share[i]);	1528	bw_share[i]);
1529	reg \|= FIELD_PREP(I40E_PRTDCB_RETSTCC_UPINTC_MODE_MASK,	1529	reg \|= FIELD_PREP(I40E_PRTDCB_RETSTCC_UPINTC_MODE_MASK,

drivers/net/ethernet/intel/i40e/i40e_main.c+10−14

 void i40e_vsi_stop_rings(struct i40e_vsi *vsi)
 {
 	struct i40e_pf *pf = vsi->back;
-	int pf_q, err, q_end;
+	u32 pf_q, tx_q_end, rx_q_end;
 	/* When port TX is suspended, don't wait */
 	if (test_bit(__I40E_PORT_SUSPENDED, vsi->back->state))
 		return i40e_vsi_stop_rings_no_wait(vsi);
-	q_end = vsi->base_queue + vsi->num_queue_pairs;
+	tx_q_end = vsi->base_queue +
-	for (pf_q = vsi->base_queue; pf_q < q_end; pf_q++)
+		vsi->alloc_queue_pairs * (i40e_enabled_xdp_vsi(vsi) ? 2 : 1);
-		i40e_pre_tx_queue_cfg(&pf->hw, (u32)pf_q, false);
+	for (pf_q = vsi->base_queue; pf_q < tx_q_end; pf_q++)
+		i40e_pre_tx_queue_cfg(&pf->hw, pf_q, false);
-	for (pf_q = vsi->base_queue; pf_q < q_end; pf_q++) {
+	rx_q_end = vsi->base_queue + vsi->num_queue_pairs;
-		err = i40e_control_wait_rx_q(pf, pf_q, false);
+	for (pf_q = vsi->base_queue; pf_q < rx_q_end; pf_q++)
-		if (err)
+		i40e_control_rx_q(pf, pf_q, false);
-			dev_info(&pf->pdev->dev,
-				 "VSI seid %d Rx ring %d disable timeout\n",
-				 vsi->seid, pf_q);
-	}
 	msleep(I40E_DISABLE_TX_GAP_MSEC);
-	pf_q = vsi->base_queue;
+	for (pf_q = vsi->base_queue; pf_q < tx_q_end; pf_q++)
-	for (pf_q = vsi->base_queue; pf_q < q_end; pf_q++)
 		wr32(&pf->hw, I40E_QTX_ENA(pf_q), 0);
 	i40e_vsi_wait_queues_disabled(vsi);
 {
 	int v, ret = 0;
-	for (v = 0; v < pf->hw.func_caps.num_vsis; v++) {
+	for (v = 0; v < pf->num_alloc_vsi; v++) {
 		if (pf->vsi[v]) {
 			ret = i40e_vsi_wait_queues_disabled(pf->vsi[v]);
 			if (ret)

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c+33−5

 				      (u8 *)&stats, sizeof(stats));
 }
+/**
+ * i40e_can_vf_change_mac
+ * @vf: pointer to the VF info
+ *
+ * Return true if the VF is allowed to change its MAC filters, false otherwise
+ */
+static bool i40e_can_vf_change_mac(struct i40e_vf *vf)
+{
+	/* If the VF MAC address has been set administratively (via the
+	 * ndo_set_vf_mac command), then deny permission to the VF to
+	 * add/delete unicast MAC addresses, unless the VF is trusted
+	 */
+	if (vf->pf_set_mac && !vf->trusted)
+		return false;
+	return true;
+}
 #define I40E_MAX_MACVLAN_PER_HW 3072
 #define I40E_MAX_MACVLAN_PER_PF(num_ports) (I40E_MAX_MACVLAN_PER_HW /	\
 	(num_ports))
 		 * The VF may request to set the MAC address filter already
 		 * assigned to it so do not return an error in that case.
 		 */
-		if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps) &&
+		if (!i40e_can_vf_change_mac(vf) &&
-		    !is_multicast_ether_addr(addr) && vf->pf_set_mac &&
+		    !is_multicast_ether_addr(addr) &&
 		    !ether_addr_equal(addr, vf->default_lan_addr.addr)) {
 			dev_err(&pf->pdev->dev,
 				"VF attempting to override administratively set MAC address, bring down and up the VF interface to resume normal operation\n");
 			ret = -EINVAL;
 			goto error_param;
 		}
-		if (ether_addr_equal(al->list[i].addr, vf->default_lan_addr.addr))
-			was_unimac_deleted = true;
 	}
 	vsi = pf->vsi[vf->lan_vsi_idx];
 	spin_lock_bh(&vsi->mac_filter_hash_lock);
 	/* delete addresses from the list */
-	for (i = 0; i < al->num_elements; i++)
+	for (i = 0; i < al->num_elements; i++) {
+		const u8 *addr = al->list[i].addr;
+		/* Allow to delete VF primary MAC only if it was not set
+		 * administratively by PF or if VF is trusted.
+		 */
+		if (ether_addr_equal(addr, vf->default_lan_addr.addr) &&
+		    i40e_can_vf_change_mac(vf))
+			was_unimac_deleted = true;
+		else
+			continue;
 		if (i40e_del_mac_filter(vsi, al->list[i].addr)) {
 			ret = -EINVAL;
 			spin_unlock_bh(&vsi->mac_filter_hash_lock);
 			goto error_param;
 		}
+	}
 	spin_unlock_bh(&vsi->mac_filter_hash_lock);

drivers/net/ethernet/intel/ice/ice_lag.c+23−2

@@ -151,6 +151,27 @@ ice_lag_find_hw_by_lport(struct ice_lag *lag, u8 lport) · 150 unmodified lines
151	return NULL;	151	return NULL;
152	}	152	}
153		153
		154	/**
		155	* ice_pkg_has_lport_extract - check if lport extraction supported
		156	* @hw: HW struct
		157	*/
		158	static bool ice_pkg_has_lport_extract(struct ice_hw *hw)
		159	{
		160	int i;
		161
		162	for (i = 0; i < hw->blk[ICE_BLK_SW].es.count; i++) {
		163	u16 offset;
		164	u8 fv_prot;
		165
		166	ice_find_prot_off(hw, ICE_BLK_SW, ICE_SW_DEFAULT_PROFILE, i,
		167	&fv_prot, &offset);
		168	if (fv_prot == ICE_FV_PROT_MDID &&
		169	offset == ICE_LP_EXT_BUF_OFFSET)
		170	return true;
		171	}
		172	return false;
		173	}
		174
154	/**	175	/**
155	* ice_lag_find_primary - returns pointer to primary interfaces lag struct	176	* ice_lag_find_primary - returns pointer to primary interfaces lag struct
156	* @lag: local interfaces lag struct	177	* @lag: local interfaces lag struct
@@ -1206,7 +1227,7 @@ static void ice_lag_del_prune_list(struct ice_lag lag, struct ice_pf event_pf) · 1049 unmodified lines
1206	}	1227	}
1207		1228
1208	/**	1229	/**
1209	* ice_lag_init_feature_support_flag - Check for NVM support for LAG	1230	* ice_lag_init_feature_support_flag - Check for package and NVM support for LAG
1210	* @pf: PF struct	1231	* @pf: PF struct
1211	*/	1232	*/
1212	static void ice_lag_init_feature_support_flag(struct ice_pf *pf)	1233	static void ice_lag_init_feature_support_flag(struct ice_pf *pf)
@@ -1219,7 +1240,7 @@ static void ice_lag_init_feature_support_flag(struct ice_pf *pf) · 6 unmodified lines
1219	else	1240	else
1220	ice_clear_feature_support(pf, ICE_F_ROCE_LAG);	1241	ice_clear_feature_support(pf, ICE_F_ROCE_LAG);
1221		1242
1222	if (caps->sriov_lag)	1243	if (caps->sriov_lag && ice_pkg_has_lport_extract(&pf->hw))
1223	ice_set_feature_support(pf, ICE_F_SRIOV_LAG);	1244	ice_set_feature_support(pf, ICE_F_SRIOV_LAG);
1224	else	1245	else
1225	ice_clear_feature_support(pf, ICE_F_SRIOV_LAG);	1246	ice_clear_feature_support(pf, ICE_F_SRIOV_LAG);

drivers/net/ethernet/intel/ice/ice_lag.h+3−0

@@ -17,6 +17,9 @@ enum ice_lag_role { · 16 unmodified lines
17	#define ICE_LAG_INVALID_PORT 0xFF	17	#define ICE_LAG_INVALID_PORT 0xFF
18		18
19	#define ICE_LAG_RESET_RETRIES 5	19	#define ICE_LAG_RESET_RETRIES 5
		20	#define ICE_SW_DEFAULT_PROFILE 0
		21	#define ICE_FV_PROT_MDID 255
		22	#define ICE_LP_EXT_BUF_OFFSET 32
20		23
21	struct ice_pf;	24	struct ice_pf;
22	struct ice_vf;	25	struct ice_vf;

drivers/net/ethernet/intel/igb/igb.h+1−1

@@ -637,7 +637,7 @@ struct igb_adapter { · 636 unmodified lines
637	struct timespec64 period;	637	struct timespec64 period;
638	} perout[IGB_N_PEROUT];	638	} perout[IGB_N_PEROUT];
639		639
640	char fw_version[32];	640	char fw_version[48];
641	#ifdef CONFIG_IGB_HWMON	641	#ifdef CONFIG_IGB_HWMON
642	struct hwmon_buff *igb_hwmon_buff;	642	struct hwmon_buff *igb_hwmon_buff;
643	bool ets;	643	bool ets;

drivers/net/ethernet/intel/igb/igb_main.c+18−17

 {
 	struct e1000_hw *hw = &adapter->hw;
 	struct e1000_fw_version fw;
-	char *lbuf;
 	igb_get_fw_version(hw, &fw);
 	case e1000_i210:
 	case e1000_i211:
 		if (!(igb_get_flash_presence_i210(hw))) {
-			lbuf = kasprintf(GFP_KERNEL, "%2d.%2d-%d",
+			snprintf(adapter->fw_version,
-					 fw.invm_major, fw.invm_minor,
+				 sizeof(adapter->fw_version),
-					 fw.invm_img_type);
+				 "%2d.%2d-%d",
+				 fw.invm_major, fw.invm_minor,
+				 fw.invm_img_type);
 			break;
 		}
 		fallthrough;
 	default:
 		/* if option rom is valid, display its version too */
 		if (fw.or_valid) {
-			lbuf = kasprintf(GFP_KERNEL, "%d.%d, 0x%08x, %d.%d.%d",
+			snprintf(adapter->fw_version,
-					 fw.eep_major, fw.eep_minor,
+				 sizeof(adapter->fw_version),
-					 fw.etrack_id, fw.or_major, fw.or_build,
+				 "%d.%d, 0x%08x, %d.%d.%d",
-					 fw.or_patch);
+				 fw.eep_major, fw.eep_minor, fw.etrack_id,
+				 fw.or_major, fw.or_build, fw.or_patch);
 		/* no option rom */
 		} else if (fw.etrack_id != 0X0000) {
-			lbuf = kasprintf(GFP_KERNEL, "%d.%d, 0x%08x",
+			snprintf(adapter->fw_version,
-					 fw.eep_major, fw.eep_minor,
+				 sizeof(adapter->fw_version),
-					 fw.etrack_id);
+				 "%d.%d, 0x%08x",
+				 fw.eep_major, fw.eep_minor, fw.etrack_id);
 		} else {
-			lbuf = kasprintf(GFP_KERNEL, "%d.%d.%d", fw.eep_major,
+			snprintf(adapter->fw_version,
-					 fw.eep_minor, fw.eep_build);
+				 sizeof(adapter->fw_version),
+				 "%d.%d.%d",
+				 fw.eep_major, fw.eep_minor, fw.eep_build);
 		}
 		break;
 	}
-	/* the truncate happens here if it doesn't fit */
-	strscpy(adapter->fw_version, lbuf, sizeof(adapter->fw_version));
-	kfree(lbuf);
 }
 /**

drivers/net/ethernet/intel/igc/igc_phy.c+1−5

@@ -130,11 +130,7 @@ void igc_power_down_phy_copper(struct igc_hw *hw) · 129 unmodified lines
130	/* The PHY will retain its settings across a power down/up cycle */	130	/* The PHY will retain its settings across a power down/up cycle */
131	hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);	131	hw->phy.ops.read_reg(hw, PHY_CONTROL, &mii_reg);
132	mii_reg \|= MII_CR_POWER_DOWN;	132	mii_reg \|= MII_CR_POWER_DOWN;
133		133	hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg);
134	/* Temporary workaround - should be removed when PHY will implement
135	* IEEE registers as properly
136	*/
137	/* hw->phy.ops.write_reg(hw, PHY_CONTROL, mii_reg);*/
138	usleep_range(1000, 2000);	134	usleep_range(1000, 2000);
139	}	135	}
140		136

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc.c+0−32

@@ -61,28 +61,6 @@ int rvu_npc_get_tx_nibble_cfg(struct rvu *rvu, u64 nibble_ena) · 60 unmodified lines
61	return 0;	61	return 0;
62	}	62	}
63		63
64	static int npc_mcam_verify_pf_func(struct rvu *rvu,
65	struct mcam_entry *entry_data, u8 intf,
66	u16 pcifunc)
67	{
68	u16 pf_func, pf_func_mask;
69
70	if (is_npc_intf_rx(intf))
71	return 0;
72
73	pf_func_mask = (entry_data->kw_mask[0] >> 32) &
74	NPC_KEX_PF_FUNC_MASK;
75	pf_func = (entry_data->kw[0] >> 32) & NPC_KEX_PF_FUNC_MASK;
76
77	pf_func = be16_to_cpu((__force __be16)pf_func);
78	if (pf_func_mask != NPC_KEX_PF_FUNC_MASK \|\|
79	((pf_func & ~RVU_PFVF_FUNC_MASK) !=
80	(pcifunc & ~RVU_PFVF_FUNC_MASK)))
81	return -EINVAL;
82
83	return 0;
84	}
85
86	void rvu_npc_set_pkind(struct rvu rvu, int pkind, struct rvu_pfvf pfvf)	64	void rvu_npc_set_pkind(struct rvu rvu, int pkind, struct rvu_pfvf pfvf)
87	{	65	{
88	int blkaddr;	66	int blkaddr;
@@ -2851,12 +2829,6 @@ int rvu_mbox_handler_npc_mcam_write_entry(struct rvu *rvu, · 2762 unmodified lines
2851	else	2829	else
2852	nix_intf = pfvf->nix_rx_intf;	2830	nix_intf = pfvf->nix_rx_intf;
2853		2831
2854	if (!is_pffunc_af(pcifunc) &&
2855	npc_mcam_verify_pf_func(rvu, &req->entry_data, req->intf, pcifunc)) {
2856	rc = NPC_MCAM_INVALID_REQ;
2857	goto exit;
2858	}
2859
2860	/* For AF installed rules, the nix_intf should be set to target NIX */	2832	/* For AF installed rules, the nix_intf should be set to target NIX */
2861	if (is_pffunc_af(req->hdr.pcifunc))	2833	if (is_pffunc_af(req->hdr.pcifunc))
2862	nix_intf = req->intf;	2834	nix_intf = req->intf;
@@ -3208,10 +3180,6 @@ int rvu_mbox_handler_npc_mcam_alloc_and_write_entry(struct rvu *rvu, · 345 unmodified lines
3208	if (!is_npc_interface_valid(rvu, req->intf))	3180	if (!is_npc_interface_valid(rvu, req->intf))
3209	return NPC_MCAM_INVALID_REQ;	3181	return NPC_MCAM_INVALID_REQ;
3210		3182
3211	if (npc_mcam_verify_pf_func(rvu, &req->entry_data, req->intf,
3212	req->hdr.pcifunc))
3213	return NPC_MCAM_INVALID_REQ;
3214
3215	/* Try to allocate a MCAM entry */	3183	/* Try to allocate a MCAM entry */
3216	entry_req.hdr.pcifunc = req->hdr.pcifunc;	3184	entry_req.hdr.pcifunc = req->hdr.pcifunc;
3217	entry_req.contig = true;	3185	entry_req.contig = true;

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

@@ -389,7 +389,7 @@ static void mlx5_dpll_remove(struct auxiliary_device *adev) · 388 unmodified lines
389	struct mlx5_dpll *mdpll = auxiliary_get_drvdata(adev);	389	struct mlx5_dpll *mdpll = auxiliary_get_drvdata(adev);
390	struct mlx5_core_dev *mdev = mdpll->mdev;	390	struct mlx5_core_dev *mdev = mdpll->mdev;
391		391
392	cancel_delayed_work(&mdpll->work);	392	cancel_delayed_work_sync(&mdpll->work);
393	mlx5_dpll_mdev_netdev_untrack(mdpll, mdev);	393	mlx5_dpll_mdev_netdev_untrack(mdpll, mdev);
394	destroy_workqueue(mdpll->wq);	394	destroy_workqueue(mdpll->wq);
395	dpll_pin_unregister(mdpll->dpll, mdpll->dpll_pin,	395	dpll_pin_unregister(mdpll->dpll, mdpll->dpll_pin,

drivers/net/ethernet/microchip/lan966x/lan966x_lag.c+7−2

 	/* Now, set PGIDs for each active LAG */
 	for (lag = 0; lag < lan966x->num_phys_ports; ++lag) {
-		struct net_device *bond = lan966x->ports[lag]->bond;
+		struct lan966x_port *port = lan966x->ports[lag];
 		int num_active_ports = 0;
+		struct net_device *bond;
 		unsigned long bond_mask;
 		u8 aggr_idx[16];
-		if (!bond || (visited & BIT(lag)))
+		if (!port || !port->bond || (visited & BIT(lag)))
 			continue;
+		bond = port->bond;
 		bond_mask = lan966x_lag_get_mask(lan966x, bond);
 		for_each_set_bit(p, &bond_mask, lan966x->num_phys_ports) {
 			struct lan966x_port *port = lan966x->ports[p];
+			if (!port)
+				continue;
 			lan_wr(ANA_PGID_PGID_SET(bond_mask),
 			       lan966x, ANA_PGID(p));
 			if (port->lag_tx_active)

drivers/net/ethernet/pensando/ionic/ionic_txrx.c+9−0

 	work_done = ionic_cq_service(cq, budget,
 				     ionic_tx_service, NULL, NULL);
+	if (unlikely(!budget))
+		return budget;
 	if (work_done < budget && napi_complete_done(napi, work_done)) {
 		ionic_dim_update(qcq, IONIC_LIF_F_TX_DIM_INTR);
 		flags |= IONIC_INTR_CRED_UNMASK;
 	u32 work_done = 0;
 	u32 flags = 0;
+	if (unlikely(!budget))
+		return budget;
 	lif = cq->bound_q->lif;
 	idev = &lif->ionic->idev;
 	tx_work_done = ionic_cq_service(txcq, IONIC_TX_BUDGET_DEFAULT,
 					ionic_tx_service, NULL, NULL);
+	if (unlikely(!budget))
+		return budget;
 	rx_work_done = ionic_cq_service(rxcq, budget,
 					ionic_rx_service, NULL, NULL);

drivers/net/ethernet/renesas/ravb_main.c+9−13

@@ -772,29 +772,25 @@ static bool ravb_rx_gbeth(struct net_device ndev, int quota, int q) · 771 unmodified lines
772	struct ravb_rx_desc *desc;	772	struct ravb_rx_desc *desc;
773	struct sk_buff *skb;	773	struct sk_buff *skb;
774	dma_addr_t dma_addr;	774	dma_addr_t dma_addr;
		775	int rx_packets = 0;
775	u8 desc_status;	776	u8 desc_status;
776	int boguscnt;
777	u16 pkt_len;	777	u16 pkt_len;
778	u8 die_dt;	778	u8 die_dt;
779	int entry;	779	int entry;
780	int limit;	780	int limit;
		781	int i;
781		782
782	entry = priv->cur_rx[q] % priv->num_rx_ring[q];	783	entry = priv->cur_rx[q] % priv->num_rx_ring[q];
783	boguscnt = priv->dirty_rx[q] + priv->num_rx_ring[q] - priv->cur_rx[q];	784	limit = priv->dirty_rx[q] + priv->num_rx_ring[q] - priv->cur_rx[q];
784	stats = &priv->stats[q];	785	stats = &priv->stats[q];
785		786
786	boguscnt = min(boguscnt, *quota);
787	limit = boguscnt;
788	desc = &priv->gbeth_rx_ring[entry];	787	desc = &priv->gbeth_rx_ring[entry];
789	while (desc->die_dt != DT_FEMPTY) {	788	for (i = 0; i < limit && rx_packets < *quota && desc->die_dt != DT_FEMPTY; i++) {
790	/* Descriptor type must be checked before all other reads */	789	/* Descriptor type must be checked before all other reads */
791	dma_rmb();	790	dma_rmb();
792	desc_status = desc->msc;	791	desc_status = desc->msc;
793	pkt_len = le16_to_cpu(desc->ds_cc) & RX_DS;	792	pkt_len = le16_to_cpu(desc->ds_cc) & RX_DS;
794		793
795	if (--boguscnt < 0)
796	break;
797
798	/* We use 0-byte descriptors to mark the DMA mapping errors */	794	/* We use 0-byte descriptors to mark the DMA mapping errors */
799	if (!pkt_len)	795	if (!pkt_len)
800	continue;	796	continue;
@@ -820,7 +816,7 @@ static bool ravb_rx_gbeth(struct net_device ndev, int quota, int q) · 19 unmodified lines
820	skb_put(skb, pkt_len);	816	skb_put(skb, pkt_len);
821	skb->protocol = eth_type_trans(skb, ndev);	817	skb->protocol = eth_type_trans(skb, ndev);
822	napi_gro_receive(&priv->napi[q], skb);	818	napi_gro_receive(&priv->napi[q], skb);
823	stats->rx_packets++;	819	rx_packets++;
824	stats->rx_bytes += pkt_len;	820	stats->rx_bytes += pkt_len;
825	break;	821	break;
826	case DT_FSTART:	822	case DT_FSTART:
@@ -848,7 +844,7 @@ static bool ravb_rx_gbeth(struct net_device ndev, int quota, int q) · 21 unmodified lines
848	eth_type_trans(priv->rx_1st_skb, ndev);	844	eth_type_trans(priv->rx_1st_skb, ndev);
849	napi_gro_receive(&priv->napi[q],	845	napi_gro_receive(&priv->napi[q],
850	priv->rx_1st_skb);	846	priv->rx_1st_skb);
851	stats->rx_packets++;	847	rx_packets++;
852	stats->rx_bytes += pkt_len;	848	stats->rx_bytes += pkt_len;
853	break;	849	break;
854	}	850	}
@@ -887,9 +883,9 @@ static bool ravb_rx_gbeth(struct net_device ndev, int quota, int q) · 32 unmodified lines
887	desc->die_dt = DT_FEMPTY;	883	desc->die_dt = DT_FEMPTY;
888	}	884	}
889		885
890	*quota -= limit - (++boguscnt);	886	stats->rx_packets += rx_packets;
891		887	*quota -= rx_packets;
892	return boguscnt <= 0;	888	return *quota == 0;
893	}	889	}
894		890
895	/* Packet receive function for Ethernet AVB */	891	/* Packet receive function for Ethernet AVB */

drivers/net/ethernet/stmicro/stmmac/dwxgmac2_core.c+35−34

@@ -830,41 +830,42 @@ static const struct dwxgmac3_error_desc dwxgmac3_dma_errors[32]= { · 829 unmodified lines
830	{ false, "UNKNOWN", "Unknown Error" }, /* 31 */	830	{ false, "UNKNOWN", "Unknown Error" }, /* 31 */
831	};	831	};
832		832
833	static const char * const dpp_rx_err = "Read Rx Descriptor Parity checker Error";	833	#define DPP_RX_ERR "Read Rx Descriptor Parity checker Error"
834	static const char * const dpp_tx_err = "Read Tx Descriptor Parity checker Error";	834	#define DPP_TX_ERR "Read Tx Descriptor Parity checker Error"
		835
835	static const struct dwxgmac3_error_desc dwxgmac3_dma_dpp_errors[32] = {	836	static const struct dwxgmac3_error_desc dwxgmac3_dma_dpp_errors[32] = {
836	{ true, "TDPES0", dpp_tx_err },	837	{ true, "TDPES0", DPP_TX_ERR },
837	{ true, "TDPES1", dpp_tx_err },	838	{ true, "TDPES1", DPP_TX_ERR },
838	{ true, "TDPES2", dpp_tx_err },	839	{ true, "TDPES2", DPP_TX_ERR },
839	{ true, "TDPES3", dpp_tx_err },	840	{ true, "TDPES3", DPP_TX_ERR },
840	{ true, "TDPES4", dpp_tx_err },	841	{ true, "TDPES4", DPP_TX_ERR },
841	{ true, "TDPES5", dpp_tx_err },	842	{ true, "TDPES5", DPP_TX_ERR },
842	{ true, "TDPES6", dpp_tx_err },	843	{ true, "TDPES6", DPP_TX_ERR },
843	{ true, "TDPES7", dpp_tx_err },	844	{ true, "TDPES7", DPP_TX_ERR },
844	{ true, "TDPES8", dpp_tx_err },	845	{ true, "TDPES8", DPP_TX_ERR },
845	{ true, "TDPES9", dpp_tx_err },	846	{ true, "TDPES9", DPP_TX_ERR },
846	{ true, "TDPES10", dpp_tx_err },	847	{ true, "TDPES10", DPP_TX_ERR },
847	{ true, "TDPES11", dpp_tx_err },	848	{ true, "TDPES11", DPP_TX_ERR },
848	{ true, "TDPES12", dpp_tx_err },	849	{ true, "TDPES12", DPP_TX_ERR },
849	{ true, "TDPES13", dpp_tx_err },	850	{ true, "TDPES13", DPP_TX_ERR },
850	{ true, "TDPES14", dpp_tx_err },	851	{ true, "TDPES14", DPP_TX_ERR },
851	{ true, "TDPES15", dpp_tx_err },	852	{ true, "TDPES15", DPP_TX_ERR },
852	{ true, "RDPES0", dpp_rx_err },	853	{ true, "RDPES0", DPP_RX_ERR },
853	{ true, "RDPES1", dpp_rx_err },	854	{ true, "RDPES1", DPP_RX_ERR },
854	{ true, "RDPES2", dpp_rx_err },	855	{ true, "RDPES2", DPP_RX_ERR },
855	{ true, "RDPES3", dpp_rx_err },	856	{ true, "RDPES3", DPP_RX_ERR },
856	{ true, "RDPES4", dpp_rx_err },	857	{ true, "RDPES4", DPP_RX_ERR },
857	{ true, "RDPES5", dpp_rx_err },	858	{ true, "RDPES5", DPP_RX_ERR },
858	{ true, "RDPES6", dpp_rx_err },	859	{ true, "RDPES6", DPP_RX_ERR },
859	{ true, "RDPES7", dpp_rx_err },	860	{ true, "RDPES7", DPP_RX_ERR },
860	{ true, "RDPES8", dpp_rx_err },	861	{ true, "RDPES8", DPP_RX_ERR },
861	{ true, "RDPES9", dpp_rx_err },	862	{ true, "RDPES9", DPP_RX_ERR },
862	{ true, "RDPES10", dpp_rx_err },	863	{ true, "RDPES10", DPP_RX_ERR },
863	{ true, "RDPES11", dpp_rx_err },	864	{ true, "RDPES11", DPP_RX_ERR },
864	{ true, "RDPES12", dpp_rx_err },	865	{ true, "RDPES12", DPP_RX_ERR },
865	{ true, "RDPES13", dpp_rx_err },	866	{ true, "RDPES13", DPP_RX_ERR },
866	{ true, "RDPES14", dpp_rx_err },	867	{ true, "RDPES14", DPP_RX_ERR },
867	{ true, "RDPES15", dpp_rx_err },	868	{ true, "RDPES15", DPP_RX_ERR },
868	};	869	};
869		870
870	static void dwxgmac3_handle_dma_err(struct net_device *ndev,	871	static void dwxgmac3_handle_dma_err(struct net_device *ndev,

drivers/net/ethernet/ti/Kconfig+1−0

@@ -189,6 +189,7 @@ config TI_ICSSG_PRUETH · 188 unmodified lines
189	select TI_K3_CPPI_DESC_POOL	189	select TI_K3_CPPI_DESC_POOL
190	depends on PRU_REMOTEPROC	190	depends on PRU_REMOTEPROC
191	depends on ARCH_K3 && OF && TI_K3_UDMA_GLUE_LAYER	191	depends on ARCH_K3 && OF && TI_K3_UDMA_GLUE_LAYER
		192	depends on PTP_1588_CLOCK_OPTIONAL
192	help	193	help
193	Support dual Gigabit Ethernet ports over the ICSSG PRU Subsystem.	194	Support dual Gigabit Ethernet ports over the ICSSG PRU Subsystem.
194	This subsystem is available starting with the AM65 platform.	195	This subsystem is available starting with the AM65 platform.

drivers/net/ethernet/ti/cpts.c+12−5

 		 freq, cpts->cc.mult, cpts->cc.shift, (ns - NSEC_PER_SEC));
 }
+static void cpts_clk_unregister(void *clk)
+{
+	clk_hw_unregister_mux(clk);
+}
+static void cpts_clk_del_provider(void *np)
+{
+	of_clk_del_provider(np);
+}
 static int cpts_of_mux_clk_setup(struct cpts *cpts, struct device_node *node)
 {
 	struct device_node *refclk_np;
 		goto mux_fail;
 	}
-	ret = devm_add_action_or_reset(cpts->dev,
+	ret = devm_add_action_or_reset(cpts->dev, cpts_clk_unregister, clk_hw);
-				       (void(*)(void *))clk_hw_unregister_mux,
-				       clk_hw);
 	if (ret) {
 		dev_err(cpts->dev, "add clkmux unreg action %d", ret);
 		goto mux_fail;
 	if (ret)
 		goto mux_fail;
-	ret = devm_add_action_or_reset(cpts->dev,
+	ret = devm_add_action_or_reset(cpts->dev, cpts_clk_del_provider,
-				       (void(*)(void *))of_clk_del_provider,
 				       refclk_np);
 	if (ret) {
 		dev_err(cpts->dev, "add clkmux provider unreg action %d", ret);

drivers/net/fddi/skfp/skfddi.c+1−0

@@ -153,6 +153,7 @@ static const struct pci_device_id skfddi_pci_tbl[] = { · 152 unmodified lines
153	{ } /* Terminating entry */	153	{ } /* Terminating entry */
154	};	154	};
155	MODULE_DEVICE_TABLE(pci, skfddi_pci_tbl);	155	MODULE_DEVICE_TABLE(pci, skfddi_pci_tbl);
		156	MODULE_DESCRIPTION("SysKonnect FDDI PCI driver");
156	MODULE_LICENSE("GPL");	157	MODULE_LICENSE("GPL");
157	MODULE_AUTHOR("Mirko Lindner <mlindner@syskonnect.de>");	158	MODULE_AUTHOR("Mirko Lindner <mlindner@syskonnect.de>");
158		159

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

@@ -259,4 +259,5 @@ static __exit void fake_remove_module(void) · 258 unmodified lines
259		259
260	module_init(fakelb_init_module);	260	module_init(fakelb_init_module);
261	module_exit(fake_remove_module);	261	module_exit(fake_remove_module);
		262	MODULE_DESCRIPTION("IEEE 802.15.4 loopback driver");
262	MODULE_LICENSE("GPL");	263	MODULE_LICENSE("GPL");

drivers/net/ipvlan/ipvtap.c+1−0

@@ -237,4 +237,5 @@ static void __exit ipvtap_exit(void) · 236 unmodified lines
237	module_exit(ipvtap_exit);	237	module_exit(ipvtap_exit);
238	MODULE_ALIAS_RTNL_LINK("ipvtap");	238	MODULE_ALIAS_RTNL_LINK("ipvtap");
239	MODULE_AUTHOR("Sainath Grandhi <sainath.grandhi@intel.com>");	239	MODULE_AUTHOR("Sainath Grandhi <sainath.grandhi@intel.com>");
		240	MODULE_DESCRIPTION("IP-VLAN based tap driver");
240	MODULE_LICENSE("GPL");	241	MODULE_LICENSE("GPL");

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

@@ -131,4 +131,5 @@ int __devm_of_mdiobus_register(struct device dev, struct mii_bus mdio, · 130 unmodified lines
131	EXPORT_SYMBOL(__devm_of_mdiobus_register);	131	EXPORT_SYMBOL(__devm_of_mdiobus_register);
132	#endif /* CONFIG_OF_MDIO */	132	#endif /* CONFIG_OF_MDIO */
133		133
		134	MODULE_DESCRIPTION("Network MDIO bus devres helpers");
134	MODULE_LICENSE("GPL");	135	MODULE_LICENSE("GPL");

drivers/net/plip/plip.c+1−0

@@ -1437,4 +1437,5 @@ static int __init plip_init (void) · 1436 unmodified lines
1437		1437
1438	module_init(plip_init);	1438	module_init(plip_init);
1439	module_exit(plip_cleanup_module);	1439	module_exit(plip_cleanup_module);
		1440	MODULE_DESCRIPTION("PLIP (parallel port) network module");
1440	MODULE_LICENSE("GPL");	1441	MODULE_LICENSE("GPL");

drivers/net/ppp/bsd_comp.c+1−0

@@ -1166,5 +1166,6 @@ static void __exit bsdcomp_cleanup(void) · 1165 unmodified lines
1166		1166
1167	module_init(bsdcomp_init);	1167	module_init(bsdcomp_init);
1168	module_exit(bsdcomp_cleanup);	1168	module_exit(bsdcomp_cleanup);
		1169	MODULE_DESCRIPTION("PPP BSD-Compress compression module");
1169	MODULE_LICENSE("Dual BSD/GPL");	1170	MODULE_LICENSE("Dual BSD/GPL");
1170	MODULE_ALIAS("ppp-compress-" __stringify(CI_BSD_COMPRESS));	1171	MODULE_ALIAS("ppp-compress-" __stringify(CI_BSD_COMPRESS));

drivers/net/ppp/ppp_async.c+1−0

@@ -87,6 +87,7 @@ struct asyncppp { · 86 unmodified lines
87	static int flag_time = HZ;	87	static int flag_time = HZ;
88	module_param(flag_time, int, 0);	88	module_param(flag_time, int, 0);
89	MODULE_PARM_DESC(flag_time, "ppp_async: interval between flagged packets (in clock ticks)");	89	MODULE_PARM_DESC(flag_time, "ppp_async: interval between flagged packets (in clock ticks)");
		90	MODULE_DESCRIPTION("PPP async serial channel module");
90	MODULE_LICENSE("GPL");	91	MODULE_LICENSE("GPL");
91	MODULE_ALIAS_LDISC(N_PPP);	92	MODULE_ALIAS_LDISC(N_PPP);
92		93

drivers/net/ppp/ppp_deflate.c+1−0

@@ -630,6 +630,7 @@ static void __exit deflate_cleanup(void) · 629 unmodified lines
630		630
631	module_init(deflate_init);	631	module_init(deflate_init);
632	module_exit(deflate_cleanup);	632	module_exit(deflate_cleanup);
		633	MODULE_DESCRIPTION("PPP Deflate compression module");
633	MODULE_LICENSE("Dual BSD/GPL");	634	MODULE_LICENSE("Dual BSD/GPL");
634	MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE));	635	MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE));
635	MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE_DRAFT));	636	MODULE_ALIAS("ppp-compress-" __stringify(CI_DEFLATE_DRAFT));

drivers/net/ppp/ppp_generic.c+1−0

@@ -3604,6 +3604,7 @@ EXPORT_SYMBOL(ppp_input_error); · 3603 unmodified lines
3604	EXPORT_SYMBOL(ppp_output_wakeup);	3604	EXPORT_SYMBOL(ppp_output_wakeup);
3605	EXPORT_SYMBOL(ppp_register_compressor);	3605	EXPORT_SYMBOL(ppp_register_compressor);
3606	EXPORT_SYMBOL(ppp_unregister_compressor);	3606	EXPORT_SYMBOL(ppp_unregister_compressor);
		3607	MODULE_DESCRIPTION("Generic PPP layer driver");
3607	MODULE_LICENSE("GPL");	3608	MODULE_LICENSE("GPL");
3608	MODULE_ALIAS_CHARDEV(PPP_MAJOR, 0);	3609	MODULE_ALIAS_CHARDEV(PPP_MAJOR, 0);
3609	MODULE_ALIAS_RTNL_LINK("ppp");	3610	MODULE_ALIAS_RTNL_LINK("ppp");

drivers/net/ppp/ppp_synctty.c+1−0

@@ -724,5 +724,6 @@ ppp_sync_cleanup(void) · 723 unmodified lines
724		724
725	module_init(ppp_sync_init);	725	module_init(ppp_sync_init);
726	module_exit(ppp_sync_cleanup);	726	module_exit(ppp_sync_cleanup);
		727	MODULE_DESCRIPTION("PPP synchronous TTY channel module");
727	MODULE_LICENSE("GPL");	728	MODULE_LICENSE("GPL");
728	MODULE_ALIAS_LDISC(N_SYNC_PPP);	729	MODULE_ALIAS_LDISC(N_SYNC_PPP);

drivers/net/ppp/pppoe.c+9−14

@@ -1007,26 +1007,21 @@ static int pppoe_recvmsg(struct socket sock, struct msghdr m, · 1006 unmodified lines
1007	struct sk_buff *skb;	1007	struct sk_buff *skb;
1008	int error = 0;	1008	int error = 0;
1009		1009
1010	if (sk->sk_state & PPPOX_BOUND) {	1010	if (sk->sk_state & PPPOX_BOUND)
1011	error = -EIO;	1011	return -EIO;
1012	goto end;
1013	}
1014		1012
1015	skb = skb_recv_datagram(sk, flags, &error);	1013	skb = skb_recv_datagram(sk, flags, &error);
1016	if (error < 0)	1014	if (!skb)
1017	goto end;	1015	return error;
1018		1016
1019	if (skb) {	1017	total_len = min_t(size_t, total_len, skb->len);
1020	total_len = min_t(size_t, total_len, skb->len);	1018	error = skb_copy_datagram_msg(skb, 0, m, total_len);
1021	error = skb_copy_datagram_msg(skb, 0, m, total_len);	1019	if (error == 0) {
1022	if (error == 0) {	1020	consume_skb(skb);
1023	consume_skb(skb);	1021	return total_len;
1024	return total_len;
1025	}
1026	}	1022	}
1027		1023
1028	kfree_skb(skb);	1024	kfree_skb(skb);
1029	end:
1030	return error;	1025	return error;
1031	}	1026	}
1032		1027

drivers/net/wireless/intel/iwlwifi/fw/acpi.c+9−6

 					 &tbl_rev);
 	if (!IS_ERR(wifi_pkg)) {
 		if (tbl_rev != 2) {
-			ret = PTR_ERR(wifi_pkg);
+			ret = -EINVAL;
 			goto out_free;
 		}
 					 &tbl_rev);
 	if (!IS_ERR(wifi_pkg)) {
 		if (tbl_rev != 1) {
-			ret = PTR_ERR(wifi_pkg);
+			ret = -EINVAL;
 			goto out_free;
 		}
 					 &tbl_rev);
 	if (!IS_ERR(wifi_pkg)) {
 		if (tbl_rev != 0) {
-			ret = PTR_ERR(wifi_pkg);
+			ret = -EINVAL;
 			goto out_free;
 		}
 					 &tbl_rev);
 	if (!IS_ERR(wifi_pkg)) {
 		if (tbl_rev != 2) {
-			ret = PTR_ERR(wifi_pkg);
+			ret = -EINVAL;
 			goto out_free;
 		}
 					 &tbl_rev);
 	if (!IS_ERR(wifi_pkg)) {
 		if (tbl_rev != 1) {
-			ret = PTR_ERR(wifi_pkg);
+			ret = -EINVAL;
 			goto out_free;
 		}
 					 &tbl_rev);
 	if (!IS_ERR(wifi_pkg)) {
 		if (tbl_rev != 0) {
-			ret = PTR_ERR(wifi_pkg);
+			ret = -EINVAL;
 			goto out_free;
 		}
 		goto read_table;
 	}
+	ret = PTR_ERR(wifi_pkg);
+	goto out_free;
 read_table:
 	fwrt->ppag_ver = tbl_rev;
 	flags = &wifi_pkg->package.elements[1];

drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c+3−0

@@ -3687,6 +3687,9 @@ iwl_mvm_sta_state_notexist_to_none(struct iwl_mvm *mvm, · 3686 unmodified lines
3687	NL80211_TDLS_SETUP);	3687	NL80211_TDLS_SETUP);
3688	}	3688	}
3689		3689
		3690	if (ret)
		3691	return ret;
		3692
3690	for_each_sta_active_link(vif, sta, link_sta, i)	3693	for_each_sta_active_link(vif, sta, link_sta, i)
3691	link_sta->agg.max_rc_amsdu_len = 1;	3694	link_sta->agg.max_rc_amsdu_len = 1;
3692		3695

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c+4−0

@@ -505,6 +505,10 @@ static bool iwl_mvm_is_dup(struct ieee80211_sta *sta, int queue, · 504 unmodified lines
505	return false;	505	return false;
506		506
507	mvm_sta = iwl_mvm_sta_from_mac80211(sta);	507	mvm_sta = iwl_mvm_sta_from_mac80211(sta);
		508
		509	if (WARN_ON_ONCE(!mvm_sta->dup_data))
		510	return false;
		511
508	dup_data = &mvm_sta->dup_data[queue];	512	dup_data = &mvm_sta->dup_data[queue];
509		513
510	/*	514	/*

drivers/net/wireless/intel/iwlwifi/mvm/time-event.c+2−1

 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
 /*
- * Copyright (C) 2012-2014, 2018-2023 Intel Corporation
+ * Copyright (C) 2012-2014, 2018-2024 Intel Corporation
  * Copyright (C) 2013-2015 Intel Mobile Communications GmbH
  * Copyright (C) 2017 Intel Deutschland GmbH
  */
 	if (!le32_to_cpu(notif->status) || !le32_to_cpu(notif->start)) {
 		/* End TE, notify mac80211 */
 		mvmvif->time_event_data.id = SESSION_PROTECT_CONF_MAX_ID;
+		mvmvif->time_event_data.link_id = -1;
 		iwl_mvm_p2p_roc_finished(mvm);
 		ieee80211_remain_on_channel_expired(mvm->hw);
 	} else if (le32_to_cpu(notif->start)) {

drivers/net/wireless/intel/iwlwifi/mvm/tx.c+59−10

 	}
 }
+static void iwl_mvm_copy_hdr(void *cmd, const void *hdr, int hdrlen,
+			     const u8 *addr3_override)
+{
+	struct ieee80211_hdr *out_hdr = cmd;
+	memcpy(cmd, hdr, hdrlen);
+	if (addr3_override)
+		memcpy(out_hdr->addr3, addr3_override, ETH_ALEN);
+}
 /*
  * Allocates and sets the Tx cmd the driver data pointers in the skb
  */
 static struct iwl_device_tx_cmd *
 iwl_mvm_set_tx_params(struct iwl_mvm *mvm, struct sk_buff *skb,
 		      struct ieee80211_tx_info *info, int hdrlen,
-		      struct ieee80211_sta *sta, u8 sta_id)
+		      struct ieee80211_sta *sta, u8 sta_id,
+		      const u8 *addr3_override)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	struct iwl_device_tx_cmd *dev_cmd;
 			cmd->len = cpu_to_le16((u16)skb->len);
 			/* Copy MAC header from skb into command buffer */
-			memcpy(cmd->hdr, hdr, hdrlen);
+			iwl_mvm_copy_hdr(cmd->hdr, hdr, hdrlen, addr3_override);
 			cmd->flags = cpu_to_le16(flags);
 			cmd->rate_n_flags = cpu_to_le32(rate_n_flags);
 			cmd->len = cpu_to_le16((u16)skb->len);
 			/* Copy MAC header from skb into command buffer */
-			memcpy(cmd->hdr, hdr, hdrlen);
+			iwl_mvm_copy_hdr(cmd->hdr, hdr, hdrlen, addr3_override);
 			cmd->flags = cpu_to_le32(flags);
 			cmd->rate_n_flags = cpu_to_le32(rate_n_flags);
 	iwl_mvm_set_tx_cmd_rate(mvm, tx_cmd, info, sta, hdr->frame_control);
 	/* Copy MAC header from skb into command buffer */
-	memcpy(tx_cmd->hdr, hdr, hdrlen);
+	iwl_mvm_copy_hdr(tx_cmd->hdr, hdr, hdrlen, addr3_override);
 out:
 	return dev_cmd;
 	IWL_DEBUG_TX(mvm, "station Id %d, queue=%d\n", sta_id, queue);
-	dev_cmd = iwl_mvm_set_tx_params(mvm, skb, &info, hdrlen, NULL, sta_id);
+	dev_cmd = iwl_mvm_set_tx_params(mvm, skb, &info, hdrlen, NULL, sta_id,
+					NULL);
 	if (!dev_cmd)
 		return -1;
  */
 static int iwl_mvm_tx_mpdu(struct iwl_mvm *mvm, struct sk_buff *skb,
 			   struct ieee80211_tx_info *info,
-			   struct ieee80211_sta *sta)
+			   struct ieee80211_sta *sta,
+			   const u8 *addr3_override)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	struct iwl_mvm_sta *mvmsta;
 		iwl_mvm_probe_resp_set_noa(mvm, skb);
 	dev_cmd = iwl_mvm_set_tx_params(mvm, skb, info, hdrlen,
-					sta, mvmsta->deflink.sta_id);
+					sta, mvmsta->deflink.sta_id,
+					addr3_override);
 	if (!dev_cmd)
 		goto drop;
 	struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 	struct ieee80211_tx_info info;
 	struct sk_buff_head mpdus_skbs;
+	struct ieee80211_vif *vif;
 	unsigned int payload_len;
 	int ret;
 	struct sk_buff *orig_skb = skb;
+	const u8 *addr3;
 	if (WARN_ON_ONCE(!mvmsta))
 		return -1;
 	memcpy(&info, skb->cb, sizeof(info));
 	if (!skb_is_gso(skb))
-		return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
+		return iwl_mvm_tx_mpdu(mvm, skb, &info, sta, NULL);
 	payload_len = skb_tail_pointer(skb) - skb_transport_header(skb) -
 		tcp_hdrlen(skb) + skb->data_len;
 	if (payload_len <= skb_shinfo(skb)->gso_size)
-		return iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
+		return iwl_mvm_tx_mpdu(mvm, skb, &info, sta, NULL);
 	__skb_queue_head_init(&mpdus_skbs);
+	vif = info.control.vif;
+	if (!vif)
+		return -1;
 	ret = iwl_mvm_tx_tso(mvm, skb, &info, sta, &mpdus_skbs);
 	if (ret)
 		return ret;
 	WARN_ON(skb_queue_empty(&mpdus_skbs));
+	/*
+	 * As described in IEEE sta 802.11-2020, table 9-30 (Address
+	 * field contents), A-MSDU address 3 should contain the BSSID
+	 * address.
+	 * Pass address 3 down to iwl_mvm_tx_mpdu() and further to set it
+	 * in the command header. We need to preserve the original
+	 * address 3 in the skb header to correctly create all the
+	 * A-MSDU subframe headers from it.
+	 */
+	switch (vif->type) {
+	case NL80211_IFTYPE_STATION:
+		addr3 = vif->cfg.ap_addr;
+		break;
+	case NL80211_IFTYPE_AP:
+		addr3 = vif->addr;
+		break;
+	default:
+		addr3 = NULL;
+		break;
+	}
 	while (!skb_queue_empty(&mpdus_skbs)) {
+		struct ieee80211_hdr *hdr;
+		bool amsdu;
 		skb = __skb_dequeue(&mpdus_skbs);
+		hdr = (void *)skb->data;
+		amsdu = ieee80211_is_data_qos(hdr->frame_control) &&
+			(*ieee80211_get_qos_ctl(hdr) &
+			 IEEE80211_QOS_CTL_A_MSDU_PRESENT);
-		ret = iwl_mvm_tx_mpdu(mvm, skb, &info, sta);
+		ret = iwl_mvm_tx_mpdu(mvm, skb, &info, sta,
+				      amsdu ? addr3 : NULL);
 		if (ret) {
 			/* Free skbs created as part of TSO logic that have not yet been dequeued */
 			__skb_queue_purge(&mpdus_skbs);

drivers/net/xen-netback/netback.c+1−0

@@ -1778,5 +1778,6 @@ static void __exit netback_fini(void) · 1777 unmodified lines
1778	}	1778	}
1779	module_exit(netback_fini);	1779	module_exit(netback_fini);
1780		1780
		1781	MODULE_DESCRIPTION("Xen backend network device module");
1781	MODULE_LICENSE("Dual BSD/GPL");	1782	MODULE_LICENSE("Dual BSD/GPL");
1782	MODULE_ALIAS("xen-backend:vif");	1783	MODULE_ALIAS("xen-backend:vif");

include/linux/netdevice.h+5−5

 	/* TXRX read-mostly hotpath */
 	__cacheline_group_begin(net_device_read_txrx);
+	union {
+		struct pcpu_lstats __percpu		*lstats;
+		struct pcpu_sw_netstats __percpu	*tstats;
+		struct pcpu_dstats __percpu		*dstats;
+	};
 	unsigned int		flags;
 	unsigned short		hard_header_len;
 	netdev_features_t	features;
 	enum netdev_ml_priv_type	ml_priv_type;
 	enum netdev_stat_type		pcpu_stat_type:8;
-	union {
-		struct pcpu_lstats __percpu		*lstats;
-		struct pcpu_sw_netstats __percpu	*tstats;
-		struct pcpu_dstats __percpu		*dstats;
-	};
 #if IS_ENABLED(CONFIG_GARP)
 	struct garp_port __rcu	*garp_port;

include/linux/tcp.h+3−3

 	u32	lost_out;	/* Lost packets			*/
 	u32	sacked_out;	/* SACK'd packets			*/
 	u16	tcp_header_len;	/* Bytes of tcp header to send		*/
+	u8	scaling_ratio;	/* see tcp_win_from_space() */
 	u8	chrono_type : 2,	/* current chronograph type */
 		repair      : 1,
+		tcp_usec_ts : 1, /* TSval values in usec */
 		is_sack_reneg:1,    /* in recovery from loss with SACK reneg? */
 		is_cwnd_limited:1;/* forward progress limited by snd_cwnd? */
 	__cacheline_group_end(tcp_sock_read_txrx);
 	u32	compressed_ack_rcv_nxt;
 	struct list_head tsq_node; /* anchor in tsq_tasklet.head list */
-	u8	scaling_ratio;	/* see tcp_win_from_space() */
 	/* Information of the most recently (s)acked skb */
 	struct tcp_rack {
 		u64 mstamp; /* (Re)sent time of the skb */
 	u8	compressed_ack;
 	u8	dup_ack_counter:2,
 		tlp_retrans:1,	/* TLP is a retransmission */
-		tcp_usec_ts:1, /* TSval values in usec */
+		unused:5;
-		unused:4;
 	u8	thin_lto    : 1,/* Use linear timeouts for thin streams */
 		recvmsg_inq : 1,/* Indicate # of bytes in queue upon recvmsg */
 		fastopen_connect:1, /* FASTOPEN_CONNECT sockopt */

include/net/tls.h+0−5

 	struct tls_rec *open_rec;
 	struct list_head tx_list;
 	atomic_t encrypt_pending;
-	/* protect crypto_wait with encrypt_pending */
-	spinlock_t encrypt_compl_lock;
-	int async_notify;
 	u8 async_capable:1;
 #define BIT_TX_SCHEDULED	0
 	struct tls_strparser strp;
 	atomic_t decrypt_pending;
-	/* protect crypto_wait with decrypt_pending*/
-	spinlock_t decrypt_compl_lock;
 	struct sk_buff_head async_hold;
 	struct wait_queue_head wq;
 };

net/6lowpan/core.c+1−0

@@ -179,4 +179,5 @@ static void __exit lowpan_module_exit(void) · 178 unmodified lines
179	module_init(lowpan_module_init);	179	module_init(lowpan_module_init);
180	module_exit(lowpan_module_exit);	180	module_exit(lowpan_module_exit);
181		181
		182	MODULE_DESCRIPTION("IPv6 over Low-Power Wireless Personal Area Network core module");
182	MODULE_LICENSE("GPL");	183	MODULE_LICENSE("GPL");

net/atm/mpc.c+1−0

@@ -1532,4 +1532,5 @@ static void __exit atm_mpoa_cleanup(void) · 1531 unmodified lines
1532	module_init(atm_mpoa_init);	1532	module_init(atm_mpoa_init);
1533	module_exit(atm_mpoa_cleanup);	1533	module_exit(atm_mpoa_cleanup);
1534		1534
		1535	MODULE_DESCRIPTION("Multi-Protocol Over ATM (MPOA) driver");
1535	MODULE_LICENSE("GPL");	1536	MODULE_LICENSE("GPL");

net/can/j1939/j1939-priv.h+2−1

 	unsigned int tp_max_packet_size;
 	/* lock for j1939_socks list */
-	spinlock_t j1939_socks_lock;
+	rwlock_t j1939_socks_lock;
 	struct list_head j1939_socks;
 	struct kref rx_kref;
 	int ifindex;
 	struct j1939_addr addr;
+	spinlock_t filters_lock;
 	struct j1939_filter *filters;
 	int nfilters;
 	pgn_t pgn_rx_filter;

net/can/j1939/main.c+1−1

@@ -274,7 +274,7 @@ struct j1939_priv j1939_netdev_start(struct net_device ndev) · 273 unmodified lines
274	return ERR_PTR(-ENOMEM);	274	return ERR_PTR(-ENOMEM);
275		275
276	j1939_tp_init(priv);	276	j1939_tp_init(priv);
277	spin_lock_init(&priv->j1939_socks_lock);	277	rwlock_init(&priv->j1939_socks_lock);
278	INIT_LIST_HEAD(&priv->j1939_socks);	278	INIT_LIST_HEAD(&priv->j1939_socks);
279		279
280	mutex_lock(&j1939_netdev_lock);	280	mutex_lock(&j1939_netdev_lock);

net/can/j1939/socket.c+30−16

 	jsk->state |= J1939_SOCK_BOUND;
 	j1939_priv_get(priv);
-	spin_lock_bh(&priv->j1939_socks_lock);
+	write_lock_bh(&priv->j1939_socks_lock);
 	list_add_tail(&jsk->list, &priv->j1939_socks);
-	spin_unlock_bh(&priv->j1939_socks_lock);
+	write_unlock_bh(&priv->j1939_socks_lock);
 }
 static void j1939_jsk_del(struct j1939_priv *priv, struct j1939_sock *jsk)
 {
-	spin_lock_bh(&priv->j1939_socks_lock);
+	write_lock_bh(&priv->j1939_socks_lock);
 	list_del_init(&jsk->list);
-	spin_unlock_bh(&priv->j1939_socks_lock);
+	write_unlock_bh(&priv->j1939_socks_lock);
 	j1939_priv_put(priv);
 	jsk->state &= ~J1939_SOCK_BOUND;
 static bool j1939_sk_match_filter(struct j1939_sock *jsk,
 				  const struct j1939_sk_buff_cb *skcb)
 {
-	const struct j1939_filter *f = jsk->filters;
+	const struct j1939_filter *f;
-	int nfilter = jsk->nfilters;
+	int nfilter;
+	spin_lock_bh(&jsk->filters_lock);
+	f = jsk->filters;
+	nfilter = jsk->nfilters;
 	if (!nfilter)
 		/* receive all when no filters are assigned */
-		return true;
+		goto filter_match_found;
 	for (; nfilter; ++f, --nfilter) {
 		if ((skcb->addr.pgn & f->pgn_mask) != f->pgn)
 			continue;
 		if ((skcb->addr.src_name & f->name_mask) != f->name)
 			continue;
-		return true;
+		goto filter_match_found;
 	}
+	spin_unlock_bh(&jsk->filters_lock);
 	return false;
+filter_match_found:
+	spin_unlock_bh(&jsk->filters_lock);
+	return true;
 }
 static bool j1939_sk_recv_match_one(struct j1939_sock *jsk,
 	struct j1939_sock *jsk;
 	bool match = false;
-	spin_lock_bh(&priv->j1939_socks_lock);
+	read_lock_bh(&priv->j1939_socks_lock);
 	list_for_each_entry(jsk, &priv->j1939_socks, list) {
 		match = j1939_sk_recv_match_one(jsk, skcb);
 		if (match)
 			break;
 	}
-	spin_unlock_bh(&priv->j1939_socks_lock);
+	read_unlock_bh(&priv->j1939_socks_lock);
 	return match;
 }
 {
 	struct j1939_sock *jsk;
-	spin_lock_bh(&priv->j1939_socks_lock);
+	read_lock_bh(&priv->j1939_socks_lock);
 	list_for_each_entry(jsk, &priv->j1939_socks, list) {
 		j1939_sk_recv_one(jsk, skb);
 	}
-	spin_unlock_bh(&priv->j1939_socks_lock);
+	read_unlock_bh(&priv->j1939_socks_lock);
 }
 static void j1939_sk_sock_destruct(struct sock *sk)
 	atomic_set(&jsk->skb_pending, 0);
 	spin_lock_init(&jsk->sk_session_queue_lock);
 	INIT_LIST_HEAD(&jsk->sk_session_queue);
+	spin_lock_init(&jsk->filters_lock);
 	/* j1939_sk_sock_destruct() depends on SOCK_RCU_FREE flag */
 	sock_set_flag(sk, SOCK_RCU_FREE);
 		}
 		lock_sock(&jsk->sk);
+		spin_lock_bh(&jsk->filters_lock);
 		ofilters = jsk->filters;
 		jsk->filters = filters;
 		jsk->nfilters = count;
+		spin_unlock_bh(&jsk->filters_lock);
 		release_sock(&jsk->sk);
 		kfree(ofilters);
 		return 0;
 	}
 	/* spread RX notifications to all sockets subscribed to this session */
-	spin_lock_bh(&priv->j1939_socks_lock);
+	read_lock_bh(&priv->j1939_socks_lock);
 	list_for_each_entry(jsk, &priv->j1939_socks, list) {
 		if (j1939_sk_recv_match_one(jsk, &session->skcb))
 			__j1939_sk_errqueue(session, &jsk->sk, type);
 	}
-	spin_unlock_bh(&priv->j1939_socks_lock);
+	read_unlock_bh(&priv->j1939_socks_lock);
 };
 void j1939_sk_send_loop_abort(struct sock *sk, int err)
 	struct j1939_sock *jsk;
 	int error_code = ENETDOWN;
-	spin_lock_bh(&priv->j1939_socks_lock);
+	read_lock_bh(&priv->j1939_socks_lock);
 	list_for_each_entry(jsk, &priv->j1939_socks, list) {
 		jsk->sk.sk_err = error_code;
 		if (!sock_flag(&jsk->sk, SOCK_DEAD))
 		j1939_sk_queue_drop_all(priv, jsk, error_code);
 	}
-	spin_unlock_bh(&priv->j1939_socks_lock);
+	read_unlock_bh(&priv->j1939_socks_lock);
 }
 static int j1939_sk_no_ioctlcmd(struct socket *sock, unsigned int cmd,

net/core/dev.c+3−2

 		return -ENOMEM;
 	netdev_name_node_add(net, name_node);
 	/* The node that holds dev->name acts as a head of per-device list. */
-	list_add_tail(&name_node->list, &dev->name_node->list);
+	list_add_tail_rcu(&name_node->list, &dev->name_node->list);
 	return 0;
 }
 	CACHELINE_ASSERT_GROUP_SIZE(struct net_device, net_device_read_tx, 160);
 	/* TXRX read-mostly hotpath */
+	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, lstats);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, flags);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, hard_header_len);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, features);
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_txrx, ip6_ptr);
-	CACHELINE_ASSERT_GROUP_SIZE(struct net_device, net_device_read_txrx, 30);
+	CACHELINE_ASSERT_GROUP_SIZE(struct net_device, net_device_read_txrx, 38);
 	/* RX read-mostly hotpath */
 	CACHELINE_ASSERT_GROUP_MEMBER(struct net_device, net_device_read_rx, ptype_specific);

net/core/rtnetlink.c+9−6

@@ -1020,14 +1020,17 @@ static size_t rtnl_xdp_size(void) · 1019 unmodified lines
1020	static size_t rtnl_prop_list_size(const struct net_device *dev)	1020	static size_t rtnl_prop_list_size(const struct net_device *dev)
1021	{	1021	{
1022	struct netdev_name_node *name_node;	1022	struct netdev_name_node *name_node;
1023	size_t size;	1023	unsigned int cnt = 0;
		1024
		1025	rcu_read_lock();
		1026	list_for_each_entry_rcu(name_node, &dev->name_node->list, list)
		1027	cnt++;
		1028	rcu_read_unlock();
1024		1029
1025	if (list_empty(&dev->name_node->list))	1030	if (!cnt)
1026	return 0;	1031	return 0;
1027	size = nla_total_size(0);	1032
1028	list_for_each_entry(name_node, &dev->name_node->list, list)	1033	return nla_total_size(0) + cnt * nla_total_size(ALTIFNAMSIZ);
1029	size += nla_total_size(ALTIFNAMSIZ);
1030	return size;
1031	}	1034	}
1032		1035
1033	static size_t rtnl_proto_down_size(const struct net_device *dev)	1036	static size_t rtnl_proto_down_size(const struct net_device *dev)

net/handshake/handshake-test.c+4−1

 	handshake_req_cancel(sock->sk);
 	/* Act */
-	fput(filp);
+	/* Ensure the close/release/put process has run to
+	 * completion before checking the result.
+	 */
+	__fput_sync(filp);
 	/* Assert */
 	KUNIT_EXPECT_PTR_EQ(test, handshake_req_destroy_test, req);

net/ipv4/ah4.c+1−0

@@ -597,5 +597,6 @@ static void __exit ah4_fini(void) · 596 unmodified lines
597		597
598	module_init(ah4_init);	598	module_init(ah4_init);
599	module_exit(ah4_fini);	599	module_exit(ah4_fini);
		600	MODULE_DESCRIPTION("IPv4 AH transformation library");
600	MODULE_LICENSE("GPL");	601	MODULE_LICENSE("GPL");
601	MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_AH);	602	MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_AH);

net/ipv4/esp4.c+1−0

@@ -1247,5 +1247,6 @@ static void __exit esp4_fini(void) · 1246 unmodified lines
1247		1247
1248	module_init(esp4_init);	1248	module_init(esp4_init);
1249	module_exit(esp4_fini);	1249	module_exit(esp4_fini);
		1250	MODULE_DESCRIPTION("IPv4 ESP transformation library");
1250	MODULE_LICENSE("GPL");	1251	MODULE_LICENSE("GPL");
1251	MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_ESP);	1252	MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_ESP);

net/ipv4/ip_gre.c+1−0

@@ -1793,6 +1793,7 @@ static void __exit ipgre_fini(void) · 1792 unmodified lines
1793		1793
1794	module_init(ipgre_init);	1794	module_init(ipgre_init);
1795	module_exit(ipgre_fini);	1795	module_exit(ipgre_fini);
		1796	MODULE_DESCRIPTION("IPv4 GRE tunnels over IP library");
1796	MODULE_LICENSE("GPL");	1797	MODULE_LICENSE("GPL");
1797	MODULE_ALIAS_RTNL_LINK("gre");	1798	MODULE_ALIAS_RTNL_LINK("gre");
1798	MODULE_ALIAS_RTNL_LINK("gretap");	1799	MODULE_ALIAS_RTNL_LINK("gretap");

net/ipv4/ip_output.c+8−5

 	unsigned int maxfraglen, fragheaderlen, maxnonfragsize;
 	int csummode = CHECKSUM_NONE;
 	struct rtable *rt = (struct rtable *)cork->dst;
+	bool paged, hold_tskey, extra_uref = false;
 	unsigned int wmem_alloc_delta = 0;
-	bool paged, extra_uref = false;
 	u32 tskey = 0;
 	skb = skb_peek_tail(queue);
 	mtu = cork->gso_size ? IP_MAX_MTU : cork->fragsize;
 	paged = !!cork->gso_size;
-	if (cork->tx_flags & SKBTX_ANY_TSTAMP &&
-	    READ_ONCE(sk->sk_tsflags) & SOF_TIMESTAMPING_OPT_ID)
-		tskey = atomic_inc_return(&sk->sk_tskey) - 1;
 	hh_len = LL_RESERVED_SPACE(rt->dst.dev);
 	fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
 	cork->length += length;
+	hold_tskey = cork->tx_flags & SKBTX_ANY_TSTAMP &&
+		     READ_ONCE(sk->sk_tsflags) & SOF_TIMESTAMPING_OPT_ID;
+	if (hold_tskey)
+		tskey = atomic_inc_return(&sk->sk_tskey) - 1;
 	/* So, what's going on in the loop below?
 	 *
 	 * We use calculated fragment length to generate chained skb,
 	cork->length -= length;
 	IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
 	refcount_add(wmem_alloc_delta, &sk->sk_wmem_alloc);
+	if (hold_tskey)
+		atomic_dec(&sk->sk_tskey);
 	return err;
 }

net/ipv4/ip_tunnel.c+1−0

@@ -1298,4 +1298,5 @@ void ip_tunnel_setup(struct net_device *dev, unsigned int net_id) · 1297 unmodified lines
1298	}	1298	}
1299	EXPORT_SYMBOL_GPL(ip_tunnel_setup);	1299	EXPORT_SYMBOL_GPL(ip_tunnel_setup);
1300		1300
		1301	MODULE_DESCRIPTION("IPv4 tunnel implementation library");
1301	MODULE_LICENSE("GPL");	1302	MODULE_LICENSE("GPL");

net/ipv4/ip_vti.c+1−0

@@ -721,6 +721,7 @@ static void __exit vti_fini(void) · 720 unmodified lines
721		721
722	module_init(vti_init);	722	module_init(vti_init);
723	module_exit(vti_fini);	723	module_exit(vti_fini);
		724	MODULE_DESCRIPTION("Virtual (secure) IP tunneling library");
724	MODULE_LICENSE("GPL");	725	MODULE_LICENSE("GPL");
725	MODULE_ALIAS_RTNL_LINK("vti");	726	MODULE_ALIAS_RTNL_LINK("vti");
726	MODULE_ALIAS_NETDEV("ip_vti0");	727	MODULE_ALIAS_NETDEV("ip_vti0");

net/ipv4/ipip.c+1−0

@@ -658,6 +658,7 @@ static void __exit ipip_fini(void) · 657 unmodified lines
658		658
659	module_init(ipip_init);	659	module_init(ipip_init);
660	module_exit(ipip_fini);	660	module_exit(ipip_fini);
		661	MODULE_DESCRIPTION("IP/IP protocol decoder library");
661	MODULE_LICENSE("GPL");	662	MODULE_LICENSE("GPL");
662	MODULE_ALIAS_RTNL_LINK("ipip");	663	MODULE_ALIAS_RTNL_LINK("ipip");
663	MODULE_ALIAS_NETDEV("tunl0");	664	MODULE_ALIAS_NETDEV("tunl0");

net/ipv4/tcp.c+2−1

@@ -4615,7 +4615,8 @@ static void __init tcp_struct_check(void) · 4614 unmodified lines
4615	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_txrx, prr_out);	4615	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_txrx, prr_out);
4616	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_txrx, lost_out);	4616	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_txrx, lost_out);
4617	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_txrx, sacked_out);	4617	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_txrx, sacked_out);
4618	CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_read_txrx, 31);	4618	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_txrx, scaling_ratio);
		4619	CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_read_txrx, 32);
4619		4620
4620	/* RX read-mostly hotpath cache lines */	4621	/* RX read-mostly hotpath cache lines */
4621	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_rx, copied_seq);	4622	CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_read_rx, copied_seq);

net/ipv4/tunnel4.c+1−0

@@ -294,4 +294,5 @@ static void __exit tunnel4_fini(void) · 293 unmodified lines
294		294
295	module_init(tunnel4_init);	295	module_init(tunnel4_init);
296	module_exit(tunnel4_fini);	296	module_exit(tunnel4_fini);
		297	MODULE_DESCRIPTION("IPv4 XFRM tunnel library");
297	MODULE_LICENSE("GPL");	298	MODULE_LICENSE("GPL");

net/ipv4/udp_tunnel_core.c+1−0

@@ -253,4 +253,5 @@ struct rtable udp_tunnel_dst_lookup(struct sk_buff skb, · 252 unmodified lines
253	}	253	}
254	EXPORT_SYMBOL_GPL(udp_tunnel_dst_lookup);	254	EXPORT_SYMBOL_GPL(udp_tunnel_dst_lookup);
255		255
		256	MODULE_DESCRIPTION("IPv4 Foo over UDP tunnel driver");
256	MODULE_LICENSE("GPL");	257	MODULE_LICENSE("GPL");

net/ipv4/xfrm4_tunnel.c+1−0

@@ -114,5 +114,6 @@ static void __exit ipip_fini(void) · 113 unmodified lines
114		114
115	module_init(ipip_init);	115	module_init(ipip_init);
116	module_exit(ipip_fini);	116	module_exit(ipip_fini);
		117	MODULE_DESCRIPTION("IPv4 XFRM tunnel driver");
117	MODULE_LICENSE("GPL");	118	MODULE_LICENSE("GPL");
118	MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_IPIP);	119	MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_IPIP);

net/ipv6/ah6.c+1−0

@@ -800,5 +800,6 @@ static void __exit ah6_fini(void) · 799 unmodified lines
800	module_init(ah6_init);	800	module_init(ah6_init);
801	module_exit(ah6_fini);	801	module_exit(ah6_fini);
802		802
		803	MODULE_DESCRIPTION("IPv6 AH transformation helpers");
803	MODULE_LICENSE("GPL");	804	MODULE_LICENSE("GPL");
804	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_AH);	805	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_AH);

net/ipv6/esp6.c+1−0

@@ -1301,5 +1301,6 @@ static void __exit esp6_fini(void) · 1300 unmodified lines
1301	module_init(esp6_init);	1301	module_init(esp6_init);
1302	module_exit(esp6_fini);	1302	module_exit(esp6_fini);
1303		1303
		1304	MODULE_DESCRIPTION("IPv6 ESP transformation helpers");
1304	MODULE_LICENSE("GPL");	1305	MODULE_LICENSE("GPL");
1305	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ESP);	1306	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ESP);

net/ipv6/ip6_output.c+8−5

 	bool zc = false;
 	u32 tskey = 0;
 	struct rt6_info *rt = (struct rt6_info *)cork->dst;
+	bool paged, hold_tskey, extra_uref = false;
 	struct ipv6_txoptions *opt = v6_cork->opt;
 	int csummode = CHECKSUM_NONE;
 	unsigned int maxnonfragsize, headersize;
 	unsigned int wmem_alloc_delta = 0;
-	bool paged, extra_uref = false;
 	skb = skb_peek_tail(queue);
 	if (!skb) {
 	mtu = cork->gso_size ? IP6_MAX_MTU : cork->fragsize;
 	orig_mtu = mtu;
-	if (cork->tx_flags & SKBTX_ANY_TSTAMP &&
-	    READ_ONCE(sk->sk_tsflags) & SOF_TIMESTAMPING_OPT_ID)
-		tskey = atomic_inc_return(&sk->sk_tskey) - 1;
 	hh_len = LL_RESERVED_SPACE(rt->dst.dev);
 	fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len +
 			flags &= ~MSG_SPLICE_PAGES;
 	}
+	hold_tskey = cork->tx_flags & SKBTX_ANY_TSTAMP &&
+		     READ_ONCE(sk->sk_tsflags) & SOF_TIMESTAMPING_OPT_ID;
+	if (hold_tskey)
+		tskey = atomic_inc_return(&sk->sk_tskey) - 1;
 	/*
 	 * Let's try using as much space as possible.
 	 * Use MTU if total length of the message fits into the MTU.
 	cork->length -= length;
 	IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
 	refcount_add(wmem_alloc_delta, &sk->sk_wmem_alloc);
+	if (hold_tskey)
+		atomic_dec(&sk->sk_tskey);
 	return err;
 }

net/ipv6/ip6_udp_tunnel.c+1−0

@@ -182,4 +182,5 @@ struct dst_entry udp_tunnel6_dst_lookup(struct sk_buff skb, · 181 unmodified lines
182	}	182	}
183	EXPORT_SYMBOL_GPL(udp_tunnel6_dst_lookup);	183	EXPORT_SYMBOL_GPL(udp_tunnel6_dst_lookup);
184		184
		185	MODULE_DESCRIPTION("IPv6 Foo over UDP tunnel driver");
185	MODULE_LICENSE("GPL");	186	MODULE_LICENSE("GPL");

net/ipv6/mip6.c+1−0

@@ -405,6 +405,7 @@ static void __exit mip6_fini(void) · 404 unmodified lines
405	module_init(mip6_init);	405	module_init(mip6_init);
406	module_exit(mip6_fini);	406	module_exit(mip6_fini);
407		407
		408	MODULE_DESCRIPTION("IPv6 Mobility driver");
408	MODULE_LICENSE("GPL");	409	MODULE_LICENSE("GPL");
409	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_DSTOPTS);	410	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_DSTOPTS);
410	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ROUTING);	411	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ROUTING);

net/ipv6/sit.c+1−0

@@ -1956,6 +1956,7 @@ xfrm_tunnel_failed: · 1955 unmodified lines
1956		1956
1957	module_init(sit_init);	1957	module_init(sit_init);
1958	module_exit(sit_cleanup);	1958	module_exit(sit_cleanup);
		1959	MODULE_DESCRIPTION("IPv6-in-IPv4 tunnel SIT driver");
1959	MODULE_LICENSE("GPL");	1960	MODULE_LICENSE("GPL");
1960	MODULE_ALIAS_RTNL_LINK("sit");	1961	MODULE_ALIAS_RTNL_LINK("sit");
1961	MODULE_ALIAS_NETDEV("sit0");	1962	MODULE_ALIAS_NETDEV("sit0");

net/ipv6/tunnel6.c+1−0

@@ -302,4 +302,5 @@ static void __exit tunnel6_fini(void) · 301 unmodified lines
302		302
303	module_init(tunnel6_init);	303	module_init(tunnel6_init);
304	module_exit(tunnel6_fini);	304	module_exit(tunnel6_fini);
		305	MODULE_DESCRIPTION("IP-in-IPv6 tunnel driver");
305	MODULE_LICENSE("GPL");	306	MODULE_LICENSE("GPL");

net/ipv6/xfrm6_tunnel.c+1−0

@@ -401,5 +401,6 @@ static void __exit xfrm6_tunnel_fini(void) · 400 unmodified lines
401		401
402	module_init(xfrm6_tunnel_init);	402	module_init(xfrm6_tunnel_init);
403	module_exit(xfrm6_tunnel_fini);	403	module_exit(xfrm6_tunnel_fini);
		404	MODULE_DESCRIPTION("IPv6 XFRM tunnel driver");
404	MODULE_LICENSE("GPL");	405	MODULE_LICENSE("GPL");
405	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_IPV6);	406	MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_IPV6);

net/key/af_key.c+1−0

@@ -3924,5 +3924,6 @@ out_unregister_key_proto: · 3923 unmodified lines
3924		3924
3925	module_init(ipsec_pfkey_init);	3925	module_init(ipsec_pfkey_init);
3926	module_exit(ipsec_pfkey_exit);	3926	module_exit(ipsec_pfkey_exit);
		3927	MODULE_DESCRIPTION("PF_KEY socket helpers");
3927	MODULE_LICENSE("GPL");	3928	MODULE_LICENSE("GPL");
3928	MODULE_ALIAS_NETPROTO(PF_KEY);	3929	MODULE_ALIAS_NETPROTO(PF_KEY);

net/mac80211/tx.c+3−2

  * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
  * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
  * Copyright 2013-2014  Intel Mobile Communications GmbH
- * Copyright (C) 2018-2022 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * Transmit and frame generation functions.
  */
 			goto begin;
 		skb = __skb_dequeue(&tx.skbs);
+		info = IEEE80211_SKB_CB(skb);
 		if (!skb_queue_empty(&tx.skbs)) {
 			spin_lock_bh(&fq->lock);
 	}
 encap_out:
-	IEEE80211_SKB_CB(skb)->control.vif = vif;
+	info->control.vif = vif;
 	if (tx.sta &&
 	    wiphy_ext_feature_isset(local->hw.wiphy, NL80211_EXT_FEATURE_AQL)) {

net/mptcp/fastopen.c+2−4

 	mptcp_data_unlock(sk);
 }
-void mptcp_fastopen_gen_msk_ackseq(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
+void __mptcp_fastopen_gen_msk_ackseq(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
-				   const struct mptcp_options_received *mp_opt)
+				     const struct mptcp_options_received *mp_opt)
 {
 	struct sock *sk = (struct sock *)msk;
 	struct sk_buff *skb;
-	mptcp_data_lock(sk);
 	skb = skb_peek_tail(&sk->sk_receive_queue);
 	if (skb) {
 		WARN_ON_ONCE(MPTCP_SKB_CB(skb)->end_seq);
 	}
 	pr_debug("msk=%p ack_seq=%llx", msk, msk->ack_seq);
-	mptcp_data_unlock(sk);
 }

net/mptcp/options.c+5−4

@@ -962,9 +962,7 @@ static bool check_fully_established(struct mptcp_sock msk, struct sock ssk, · 961 unmodified lines
962	/* subflows are fully established as soon as we get any	962	/* subflows are fully established as soon as we get any
963	* additional ack, including ADD_ADDR.	963	* additional ack, including ADD_ADDR.
964	*/	964	*/
965	subflow->fully_established = 1;	965	goto set_fully_established;
966	WRITE_ONCE(msk->fully_established, true);
967	goto check_notify;
968	}	966	}
969		967
970	/* If the first established packet does not contain MP_CAPABLE + data	968	/* If the first established packet does not contain MP_CAPABLE + data
@@ -986,7 +984,10 @@ static bool check_fully_established(struct mptcp_sock msk, struct sock ssk, · 15 unmodified lines
986	set_fully_established:	984	set_fully_established:
987	if (unlikely(!READ_ONCE(msk->pm.server_side)))	985	if (unlikely(!READ_ONCE(msk->pm.server_side)))
988	pr_warn_once("bogus mpc option on established client sk");	986	pr_warn_once("bogus mpc option on established client sk");
989	mptcp_subflow_fully_established(subflow, mp_opt);	987
		988	mptcp_data_lock((struct sock *)msk);
		989	__mptcp_subflow_fully_established(msk, subflow, mp_opt);
		990	mptcp_data_unlock((struct sock *)msk);
990		991
991	check_notify:	992	check_notify:
992	/* if the subflow is not already linked into the conn_list, we can't	993	/* if the subflow is not already linked into the conn_list, we can't

net/mptcp/pm_userspace.c+12−1

@@ -130,10 +130,21 @@ int mptcp_userspace_pm_get_flags_and_ifindex_by_id(struct mptcp_sock *msk, · 129 unmodified lines
130	int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,	130	int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,
131	struct mptcp_addr_info *skc)	131	struct mptcp_addr_info *skc)
132	{	132	{
133	struct mptcp_pm_addr_entry new_entry;	133	struct mptcp_pm_addr_entry entry = NULL, e, new_entry;
134	__be16 msk_sport = ((struct inet_sock *)	134	__be16 msk_sport = ((struct inet_sock *)
135	inet_sk((struct sock *)msk))->inet_sport;	135	inet_sk((struct sock *)msk))->inet_sport;
136		136
		137	spin_lock_bh(&msk->pm.lock);
		138	list_for_each_entry(e, &msk->pm.userspace_pm_local_addr_list, list) {
		139	if (mptcp_addresses_equal(&e->addr, skc, false)) {
		140	entry = e;
		141	break;
		142	}
		143	}
		144	spin_unlock_bh(&msk->pm.lock);
		145	if (entry)
		146	return entry->addr.id;
		147
137	memset(&new_entry, 0, sizeof(struct mptcp_pm_addr_entry));	148	memset(&new_entry, 0, sizeof(struct mptcp_pm_addr_entry));
138	new_entry.addr = *skc;	149	new_entry.addr = *skc;
139	new_entry.addr.id = 0;	150	new_entry.addr.id = 0;

net/mptcp/protocol.c+17−14

 void mptcp_check_and_set_pending(struct sock *sk)
 {
-	if (mptcp_send_head(sk))
+	if (mptcp_send_head(sk)) {
-		mptcp_sk(sk)->push_pending |= BIT(MPTCP_PUSH_PENDING);
+		mptcp_data_lock(sk);
+		mptcp_sk(sk)->cb_flags |= BIT(MPTCP_PUSH_PENDING);
+		mptcp_data_unlock(sk);
+	}
 }
 static int __subflow_push_pending(struct sock *sk, struct sock *ssk,
 	if (copied <= 0)
 		return;
+	if (!msk->rcvspace_init)
+		mptcp_rcv_space_init(msk, msk->first);
 	msk->rcvq_space.copied += copied;
 	mstamp = div_u64(tcp_clock_ns(), NSEC_PER_USEC);
 	mptcp_destroy_common(msk, MPTCP_CF_FASTCLOSE);
 	WRITE_ONCE(msk->flags, 0);
 	msk->cb_flags = 0;
-	msk->push_pending = 0;
 	msk->recovery = false;
 	msk->can_ack = false;
 	msk->fully_established = false;
 	msk->bytes_received = 0;
 	msk->bytes_sent = 0;
 	msk->bytes_retrans = 0;
+	msk->rcvspace_init = 0;
 	WRITE_ONCE(sk->sk_shutdown, 0);
 	sk_error_report(sk);
 {
 	struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
 	struct sock *nsk = sk_clone_lock(sk, GFP_ATOMIC);
+	struct mptcp_subflow_context *subflow;
 	struct mptcp_sock *msk;
 	if (!nsk)
 	/* The msk maintain a ref to each subflow in the connections list */
 	WRITE_ONCE(msk->first, ssk);
-	list_add(&mptcp_subflow_ctx(ssk)->node, &msk->conn_list);
+	subflow = mptcp_subflow_ctx(ssk);
+	list_add(&subflow->node, &msk->conn_list);
 	sock_hold(ssk);
 	/* new mpc subflow takes ownership of the newly
 	__mptcp_propagate_sndbuf(nsk, ssk);
 	mptcp_rcv_space_init(msk, ssk);
+	if (mp_opt->suboptions & OPTION_MPTCP_MPC_ACK)
+		__mptcp_subflow_fully_established(msk, subflow, mp_opt);
 	bh_unlock_sock(nsk);
 	/* note: the newly allocated socket refcount is 2 now */
 {
 	const struct tcp_sock *tp = tcp_sk(ssk);
+	msk->rcvspace_init = 1;
 	msk->rcvq_space.copied = 0;
 	msk->rcvq_space.rtt_us = 0;
 				      TCP_INIT_CWND * tp->advmss);
 	if (msk->rcvq_space.space == 0)
 		msk->rcvq_space.space = TCP_INIT_CWND * TCP_MSS_DEFAULT;
-	WRITE_ONCE(msk->wnd_end, msk->snd_nxt + tcp_sk(ssk)->snd_wnd);
 }
 void mptcp_destroy_common(struct mptcp_sock *msk, unsigned int flags)
 	struct mptcp_sock *msk = mptcp_sk(sk);
 	for (;;) {
-		unsigned long flags = (msk->cb_flags & MPTCP_FLAGS_PROCESS_CTX_NEED) |
+		unsigned long flags = (msk->cb_flags & MPTCP_FLAGS_PROCESS_CTX_NEED);
-				      msk->push_pending;
 		struct list_head join_list;
 		if (!flags)
 		 *    datapath acquires the msk socket spinlock while helding
 		 *    the subflow socket lock
 		 */
-		msk->push_pending = 0;
 		msk->cb_flags &= ~flags;
 		spin_unlock_bh(&sk->sk_lock.slock);
 	 * accessing the field below
 	 */
 	WRITE_ONCE(msk->local_key, subflow->local_key);
-	WRITE_ONCE(msk->write_seq, subflow->idsn + 1);
-	WRITE_ONCE(msk->snd_nxt, msk->write_seq);
-	WRITE_ONCE(msk->snd_una, msk->write_seq);
 	mptcp_pm_new_connection(msk, ssk, 0);
-	mptcp_rcv_space_init(msk, ssk);
 }
 void mptcp_sock_graft(struct sock *sk, struct socket *parent)

net/mptcp/protocol.h+9−7

 	int		rmem_released;
 	unsigned long	flags;
 	unsigned long	cb_flags;
-	unsigned long	push_pending;
 	bool		recovery;		/* closing subflow write queue reinjected */
 	bool		can_ack;
 	bool		fully_established;
 			nodelay:1,
 			fastopening:1,
 			in_accept_queue:1,
-			free_first:1;
+			free_first:1,
+			rcvspace_init:1;
 	struct work_struct work;
 	struct sk_buff  *ooo_last_skb;
 	struct rb_root  out_of_order_queue;
 unsigned int mptcp_close_timeout(const struct sock *sk);
 int mptcp_get_pm_type(const struct net *net);
 const char *mptcp_get_scheduler(const struct net *net);
-void mptcp_subflow_fully_established(struct mptcp_subflow_context *subflow,
+void __mptcp_subflow_fully_established(struct mptcp_sock *msk,
-				     const struct mptcp_options_received *mp_opt);
+				       struct mptcp_subflow_context *subflow,
+				       const struct mptcp_options_received *mp_opt);
 bool __mptcp_retransmit_pending_data(struct sock *sk);
 void mptcp_check_and_set_pending(struct sock *sk);
 void __mptcp_push_pending(struct sock *sk, unsigned int flags);
 			     enum mptcp_event_type event);
 bool mptcp_userspace_pm_active(const struct mptcp_sock *msk);
-void mptcp_fastopen_gen_msk_ackseq(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
+void __mptcp_fastopen_gen_msk_ackseq(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow,
-				   const struct mptcp_options_received *mp_opt);
+				     const struct mptcp_options_received *mp_opt);
 void mptcp_fastopen_subflow_synack_set_params(struct mptcp_subflow_context *subflow,
 					      struct request_sock *req);
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
-	return (1 << sk->sk_state) & (TCPF_ESTABLISHED | TCPF_FIN_WAIT1) &&
+	return (1 << sk->sk_state) &
+	       (TCPF_ESTABLISHED | TCPF_FIN_WAIT1 | TCPF_FIN_WAIT2 | TCPF_CLOSING) &&
 	       is_active_ssk(subflow) &&
 	       !subflow->conn_finished;
 }

net/mptcp/subflow.c+44−27

 void __mptcp_sync_state(struct sock *sk, int state)
 {
+	struct mptcp_subflow_context *subflow;
 	struct mptcp_sock *msk = mptcp_sk(sk);
+	struct sock *ssk = msk->first;
+	subflow = mptcp_subflow_ctx(ssk);
+	__mptcp_propagate_sndbuf(sk, ssk);
+	if (!msk->rcvspace_init)
+		mptcp_rcv_space_init(msk, ssk);
-	__mptcp_propagate_sndbuf(sk, msk->first);
 	if (sk->sk_state == TCP_SYN_SENT) {
+		/* subflow->idsn is always available is TCP_SYN_SENT state,
+		 * even for the FASTOPEN scenarios
+		 */
+		WRITE_ONCE(msk->write_seq, subflow->idsn + 1);
+		WRITE_ONCE(msk->snd_nxt, msk->write_seq);
 		mptcp_set_state(sk, state);
 		sk->sk_state_change(sk);
 	}
 }
-static void mptcp_propagate_state(struct sock *sk, struct sock *ssk)
-{
-	struct mptcp_sock *msk = mptcp_sk(sk);
-	mptcp_data_lock(sk);
-	if (!sock_owned_by_user(sk)) {
-		__mptcp_sync_state(sk, ssk->sk_state);
-	} else {
-		msk->pending_state = ssk->sk_state;
-		__set_bit(MPTCP_SYNC_STATE, &msk->cb_flags);
-	}
-	mptcp_data_unlock(sk);
-}
 static void subflow_set_remote_key(struct mptcp_sock *msk,
 				   struct mptcp_subflow_context *subflow,
 				   const struct mptcp_options_received *mp_opt)
 	atomic64_set(&msk->rcv_wnd_sent, subflow->iasn);
 }
+static void mptcp_propagate_state(struct sock *sk, struct sock *ssk,
+				  struct mptcp_subflow_context *subflow,
+				  const struct mptcp_options_received *mp_opt)
+{
+	struct mptcp_sock *msk = mptcp_sk(sk);
+	mptcp_data_lock(sk);
+	if (mp_opt) {
+		/* Options are available only in the non fallback cases
+		 * avoid updating rx path fields otherwise
+		 */
+		WRITE_ONCE(msk->snd_una, subflow->idsn + 1);
+		WRITE_ONCE(msk->wnd_end, subflow->idsn + 1 + tcp_sk(ssk)->snd_wnd);
+		subflow_set_remote_key(msk, subflow, mp_opt);
+	}
+	if (!sock_owned_by_user(sk)) {
+		__mptcp_sync_state(sk, ssk->sk_state);
+	} else {
+		msk->pending_state = ssk->sk_state;
+		__set_bit(MPTCP_SYNC_STATE, &msk->cb_flags);
+	}
+	mptcp_data_unlock(sk);
+}
 static void subflow_finish_connect(struct sock *sk, const struct sk_buff *skb)
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
 		if (mp_opt.deny_join_id0)
 			WRITE_ONCE(msk->pm.remote_deny_join_id0, true);
 		subflow->mp_capable = 1;
-		subflow_set_remote_key(msk, subflow, &mp_opt);
 		MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPCAPABLEACTIVEACK);
 		mptcp_finish_connect(sk);
-		mptcp_propagate_state(parent, sk);
+		mptcp_propagate_state(parent, sk, subflow, &mp_opt);
 	} else if (subflow->request_join) {
 		u8 hmac[SHA256_DIGEST_SIZE];
 		}
 	} else if (mptcp_check_fallback(sk)) {
 fallback:
-		mptcp_rcv_space_init(msk, sk);
+		mptcp_propagate_state(parent, sk, subflow, NULL);
-		mptcp_propagate_state(parent, sk);
 	}
 	return;
 	kfree_rcu(ctx, rcu);
 }
-void mptcp_subflow_fully_established(struct mptcp_subflow_context *subflow,
+void __mptcp_subflow_fully_established(struct mptcp_sock *msk,
-				     const struct mptcp_options_received *mp_opt)
+				       struct mptcp_subflow_context *subflow,
+				       const struct mptcp_options_received *mp_opt)
 {
-	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
 	subflow_set_remote_key(msk, subflow, mp_opt);
 	subflow->fully_established = 1;
 	WRITE_ONCE(msk->fully_established, true);
 	if (subflow->is_mptfo)
-		mptcp_fastopen_gen_msk_ackseq(msk, subflow, mp_opt);
+		__mptcp_fastopen_gen_msk_ackseq(msk, subflow, mp_opt);
 }
 static struct sock *subflow_syn_recv_sock(const struct sock *sk,
 			 * mpc option
 			 */
 			if (mp_opt.suboptions & OPTION_MPTCP_MPC_ACK) {
-				mptcp_subflow_fully_established(ctx, &mp_opt);
 				mptcp_pm_fully_established(owner, child);
 				ctx->pm_notified = 1;
 			}
 	msk = mptcp_sk(parent);
 	if (subflow_simultaneous_connect(sk)) {
 		mptcp_do_fallback(sk);
-		mptcp_rcv_space_init(msk, sk);
 		pr_fallback(msk);
 		subflow->conn_finished = 1;
-		mptcp_propagate_state(parent, sk);
+		mptcp_propagate_state(parent, sk, subflow, NULL);
 	}
 	/* as recvmsg() does not acquire the subflow socket for ssk selection

net/netfilter/nf_nat_core.c+4−1

 find_free_id:
 	if (range->flags & NF_NAT_RANGE_PROTO_OFFSET)
 		off = (ntohs(*keyptr) - ntohs(range->base_proto.all));
-	else
+	else if ((range->flags & NF_NAT_RANGE_PROTO_RANDOM_ALL) ||
+		 maniptype != NF_NAT_MANIP_DST)
 		off = get_random_u16();
+	else
+		off = 0;
 	attempts = range_size;
 	if (attempts > NF_NAT_MAX_ATTEMPTS)

net/netfilter/nft_flow_offload.c+1−0

@@ -361,6 +361,7 @@ static void nft_flow_offload_eval(const struct nft_expr *expr, · 360 unmodified lines
361	ct->proto.tcp.seen[1].flags \|= IP_CT_TCP_FLAG_BE_LIBERAL;	361	ct->proto.tcp.seen[1].flags \|= IP_CT_TCP_FLAG_BE_LIBERAL;
362	}	362	}
363		363
		364	__set_bit(NF_FLOW_HW_BIDIRECTIONAL, &flow->flags);
364	ret = flow_offload_add(flowtable, flow);	365	ret = flow_offload_add(flowtable, flow);
365	if (ret < 0)	366	if (ret < 0)
366	goto err_flow_add;	367	goto err_flow_add;

net/netfilter/nft_set_pipapo.h+2−2

@@ -144,10 +144,10 @@ struct nft_pipapo_scratch { · 143 unmodified lines
144		144
145	/**	145	/**
146	* struct nft_pipapo_match - Data used for lookup and matching	146	* struct nft_pipapo_match - Data used for lookup and matching
147	* @field_count Amount of fields in set	147	* @field_count: Amount of fields in set
148	* @scratch: Preallocated per-CPU maps for partial matching results	148	* @scratch: Preallocated per-CPU maps for partial matching results
149	* @bsize_max: Maximum lookup table bucket size of all fields, in longs	149	* @bsize_max: Maximum lookup table bucket size of all fields, in longs
150	* @rcu Matching data is swapped on commits	150	* @rcu: Matching data is swapped on commits
151	* @f: Fields, with lookup and mapping tables	151	* @f: Fields, with lookup and mapping tables
152	*/	152	*/
153	struct nft_pipapo_match {	153	struct nft_pipapo_match {

net/openvswitch/flow_netlink.c+33−16

 #define OVS_ATTR_NESTED -1
 #define OVS_ATTR_VARIABLE -2
+#define OVS_COPY_ACTIONS_MAX_DEPTH 16
 static bool actions_may_change_flow(const struct nlattr *actions)
 {
 				  const struct sw_flow_key *key,
 				  struct sw_flow_actions **sfa,
 				  __be16 eth_type, __be16 vlan_tci,
-				  u32 mpls_label_count, bool log);
+				  u32 mpls_label_count, bool log,
+				  u32 depth);
 static int validate_and_copy_sample(struct net *net, const struct nlattr *attr,
 				    const struct sw_flow_key *key,
 				    struct sw_flow_actions **sfa,
 				    __be16 eth_type, __be16 vlan_tci,
-				    u32 mpls_label_count, bool log, bool last)
+				    u32 mpls_label_count, bool log, bool last,
+				    u32 depth)
 {
 	const struct nlattr *attrs[OVS_SAMPLE_ATTR_MAX + 1];
 	const struct nlattr *probability, *actions;
 		return err;
 	err = __ovs_nla_copy_actions(net, actions, key, sfa,
-				     eth_type, vlan_tci, mpls_label_count, log);
+				     eth_type, vlan_tci, mpls_label_count, log,
+				     depth + 1);
 	if (err)
 		return err;
 				     const struct sw_flow_key *key,
 				     struct sw_flow_actions **sfa,
 				     __be16 eth_type, __be16 vlan_tci,
-				     u32 mpls_label_count, bool log)
+				     u32 mpls_label_count, bool log,
+				     u32 depth)
 {
 	const struct nlattr *attrs[OVS_DEC_TTL_ATTR_MAX + 1];
 	int start, action_start, err, rem;
 		return action_start;
 	err = __ovs_nla_copy_actions(net, actions, key, sfa, eth_type,
-				     vlan_tci, mpls_label_count, log);
+				     vlan_tci, mpls_label_count, log,
+				     depth + 1);
 	if (err)
 		return err;
 				   const struct sw_flow_key *key,
 				   struct sw_flow_actions **sfa,
 				   __be16 eth_type, __be16 vlan_tci,
-				   u32 mpls_label_count, bool log, bool last)
+				   u32 mpls_label_count, bool log, bool last,
+				   u32 depth)
 {
 	int start, err;
 	u32 exec;
 		return err;
 	err = __ovs_nla_copy_actions(net, attr, key, sfa,
-				     eth_type, vlan_tci, mpls_label_count, log);
+				     eth_type, vlan_tci, mpls_label_count, log,
+				     depth + 1);
 	if (err)
 		return err;
 					   struct sw_flow_actions **sfa,
 					   __be16 eth_type, __be16 vlan_tci,
 					   u32 mpls_label_count,
-					   bool log, bool last)
+					   bool log, bool last, u32 depth)
 {
 	const struct nlattr *acts_if_greater, *acts_if_lesser_eq;
 	struct nlattr *a[OVS_CHECK_PKT_LEN_ATTR_MAX + 1];
 		return nested_acts_start;
 	err = __ovs_nla_copy_actions(net, acts_if_lesser_eq, key, sfa,
-				     eth_type, vlan_tci, mpls_label_count, log);
+				     eth_type, vlan_tci, mpls_label_count, log,
+				     depth + 1);
 	if (err)
 		return err;
 		return nested_acts_start;
 	err = __ovs_nla_copy_actions(net, acts_if_greater, key, sfa,
-				     eth_type, vlan_tci, mpls_label_count, log);
+				     eth_type, vlan_tci, mpls_label_count, log,
+				     depth + 1);
 	if (err)
 		return err;
 				  const struct sw_flow_key *key,
 				  struct sw_flow_actions **sfa,
 				  __be16 eth_type, __be16 vlan_tci,
-				  u32 mpls_label_count, bool log)
+				  u32 mpls_label_count, bool log,
+				  u32 depth)
 {
 	u8 mac_proto = ovs_key_mac_proto(key);
 	const struct nlattr *a;
 	int rem, err;
+	if (depth > OVS_COPY_ACTIONS_MAX_DEPTH)
+		return -EOVERFLOW;
 	nla_for_each_nested(a, attr, rem) {
 		/* Expected argument lengths, (u32)-1 for variable length. */
 		static const u32 action_lens[OVS_ACTION_ATTR_MAX + 1] = {
 			err = validate_and_copy_sample(net, a, key, sfa,
 						       eth_type, vlan_tci,
 						       mpls_label_count,
-						       log, last);
+						       log, last, depth);
 			if (err)
 				return err;
 			skip_copy = true;
 			err = validate_and_copy_clone(net, a, key, sfa,
 						      eth_type, vlan_tci,
 						      mpls_label_count,
-						      log, last);
+						      log, last, depth);
 			if (err)
 				return err;
 			skip_copy = true;
 							      eth_type,
 							      vlan_tci,
 							      mpls_label_count,
-							      log, last);
+							      log, last,
+							      depth);
 			if (err)
 				return err;
 			skip_copy = true;
 		case OVS_ACTION_ATTR_DEC_TTL:
 			err = validate_and_copy_dec_ttl(net, a, key, sfa,
 							eth_type, vlan_tci,
-							mpls_label_count, log);
+							mpls_label_count, log,
+							depth);
 			if (err)
 				return err;
 			skip_copy = true;
 	(*sfa)->orig_len = nla_len(attr);
 	err = __ovs_nla_copy_actions(net, attr, key, sfa, key->eth.type,
-				     key->eth.vlan.tci, mpls_label_count, log);
+				     key->eth.vlan.tci, mpls_label_count, log,
+				     0);
 	if (err)
 		ovs_nla_free_flow_actions(*sfa);

net/rds/recv.c+11−2

 	struct sock *sk = rds_rs_to_sk(rs);
 	int ret = 0;
 	unsigned long flags;
+	struct rds_incoming *to_drop = NULL;
 	write_lock_irqsave(&rs->rs_recv_lock, flags);
 	if (!list_empty(&inc->i_item)) {
 					      -be32_to_cpu(inc->i_hdr.h_len),
 					      inc->i_hdr.h_dport);
 			list_del_init(&inc->i_item);
-			rds_inc_put(inc);
+			to_drop = inc;
 		}
 	}
 	write_unlock_irqrestore(&rs->rs_recv_lock, flags);
+	if (to_drop)
+		rds_inc_put(to_drop);
 	rdsdebug("inc %p rs %p still %d dropped %d\n", inc, rs, ret, drop);
 	return ret;
 }
 	struct sock *sk = rds_rs_to_sk(rs);
 	struct rds_incoming *inc, *tmp;
 	unsigned long flags;
+	LIST_HEAD(to_drop);
 	write_lock_irqsave(&rs->rs_recv_lock, flags);
 	list_for_each_entry_safe(inc, tmp, &rs->rs_recv_queue, i_item) {
 		rds_recv_rcvbuf_delta(rs, sk, inc->i_conn->c_lcong,
 				      -be32_to_cpu(inc->i_hdr.h_len),
 				      inc->i_hdr.h_dport);
+		list_move(&inc->i_item, &to_drop);
+	}
+	write_unlock_irqrestore(&rs->rs_recv_lock, flags);
+	list_for_each_entry_safe(inc, tmp, &to_drop, i_item) {
 		list_del_init(&inc->i_item);
 		rds_inc_put(inc);
 	}
-	write_unlock_irqrestore(&rs->rs_recv_lock, flags);
 }
 /*

net/sched/act_mirred.c+0−2

 				 * net_device are already rcu protected.
 				 */
 				RCU_INIT_POINTER(m->tcfm_dev, NULL);
-			} else if (m->tcfm_blockid) {
-				m->tcfm_blockid = 0;
 			}
 			spin_unlock_bh(&m->tcf_lock);
 		}

net/sched/em_canid.c+1−0

@@ -222,6 +222,7 @@ static void __exit exit_em_canid(void) · 221 unmodified lines
222	tcf_em_unregister(&em_canid_ops);	222	tcf_em_unregister(&em_canid_ops);
223	}	223	}
224		224
		225	MODULE_DESCRIPTION("ematch classifier to match CAN IDs embedded in skb CAN frames");
225	MODULE_LICENSE("GPL");	226	MODULE_LICENSE("GPL");
226		227
227	module_init(init_em_canid);	228	module_init(init_em_canid);

net/sched/em_cmp.c+1−0

@@ -87,6 +87,7 @@ static void __exit exit_em_cmp(void) · 86 unmodified lines
87	tcf_em_unregister(&em_cmp_ops);	87	tcf_em_unregister(&em_cmp_ops);
88	}	88	}
89		89
		90	MODULE_DESCRIPTION("ematch classifier for basic data types(8/16/32 bit) against skb data");
90	MODULE_LICENSE("GPL");	91	MODULE_LICENSE("GPL");
91		92
92	module_init(init_em_cmp);	93	module_init(init_em_cmp);

net/sched/em_meta.c+1−0

@@ -1006,6 +1006,7 @@ static void __exit exit_em_meta(void) · 1005 unmodified lines
1006	tcf_em_unregister(&em_meta_ops);	1006	tcf_em_unregister(&em_meta_ops);
1007	}	1007	}
1008		1008
		1009	MODULE_DESCRIPTION("ematch classifier for various internal kernel metadata, skb metadata and sk metadata");
1009	MODULE_LICENSE("GPL");	1010	MODULE_LICENSE("GPL");
1010		1011
1011	module_init(init_em_meta);	1012	module_init(init_em_meta);

net/sched/em_nbyte.c+1−0

@@ -68,6 +68,7 @@ static void __exit exit_em_nbyte(void) · 67 unmodified lines
68	tcf_em_unregister(&em_nbyte_ops);	68	tcf_em_unregister(&em_nbyte_ops);
69	}	69	}
70		70
		71	MODULE_DESCRIPTION("ematch classifier for arbitrary skb multi-bytes");
71	MODULE_LICENSE("GPL");	72	MODULE_LICENSE("GPL");
72		73
73	module_init(init_em_nbyte);	74	module_init(init_em_nbyte);

net/sched/em_text.c+1−0

@@ -147,6 +147,7 @@ static void __exit exit_em_text(void) · 146 unmodified lines
147	tcf_em_unregister(&em_text_ops);	147	tcf_em_unregister(&em_text_ops);
148	}	148	}
149		149
		150	MODULE_DESCRIPTION("ematch classifier for embedded text in skbs");
150	MODULE_LICENSE("GPL");	151	MODULE_LICENSE("GPL");
151		152
152	module_init(init_em_text);	153	module_init(init_em_text);

net/sched/em_u32.c+1−0

@@ -52,6 +52,7 @@ static void __exit exit_em_u32(void) · 51 unmodified lines
52	tcf_em_unregister(&em_u32_ops);	52	tcf_em_unregister(&em_u32_ops);
53	}	53	}
54		54
		55	MODULE_DESCRIPTION("ematch skb classifier using 32 bit chunks of data");
55	MODULE_LICENSE("GPL");	56	MODULE_LICENSE("GPL");
56		57
57	module_init(init_em_u32);	58	module_init(init_em_u32);

net/sctp/inqueue.c+10−4

 	INIT_WORK(&queue->immediate, NULL);
 }
+/* Properly release the chunk which is being worked on. */
+static inline void sctp_inq_chunk_free(struct sctp_chunk *chunk)
+{
+	if (chunk->head_skb)
+		chunk->skb = chunk->head_skb;
+	sctp_chunk_free(chunk);
+}
 /* Release the memory associated with an SCTP inqueue.  */
 void sctp_inq_free(struct sctp_inq *queue)
 {
 	 * free it as well.
 	 */
 	if (queue->in_progress) {
-		sctp_chunk_free(queue->in_progress);
+		sctp_inq_chunk_free(queue->in_progress);
 		queue->in_progress = NULL;
 	}
 }
 				goto new_skb;
 			}
-			if (chunk->head_skb)
+			sctp_inq_chunk_free(chunk);
-				chunk->skb = chunk->head_skb;
-			sctp_chunk_free(chunk);
 			chunk = queue->in_progress = NULL;
 		} else {
 			/* Nothing to do. Next chunk in the packet, please. */

net/smc/af_smc.c+1−0

@@ -924,6 +924,7 @@ static int smc_switch_to_fallback(struct smc_sock *smc, int reason_code) · 923 unmodified lines
924	smc->clcsock->file->private_data = smc->clcsock;	924	smc->clcsock->file->private_data = smc->clcsock;
925	smc->clcsock->wq.fasync_list =	925	smc->clcsock->wq.fasync_list =
926	smc->sk.sk_socket->wq.fasync_list;	926	smc->sk.sk_socket->wq.fasync_list;
		927	smc->sk.sk_socket->wq.fasync_list = NULL;
927		928
928	/* There might be some wait entries remaining	929	/* There might be some wait entries remaining
929	* in smc sk->sk_wq and they should be woken up	930	* in smc sk->sk_wq and they should be woken up

net/tls/tls_sw.c+62−73

@@ -63,6 +63,7 @@ struct tls_decrypt_ctx { · 62 unmodified lines
63	u8 iv[TLS_MAX_IV_SIZE];	63	u8 iv[TLS_MAX_IV_SIZE];
64	u8 aad[TLS_MAX_AAD_SIZE];	64	u8 aad[TLS_MAX_AAD_SIZE];
65	u8 tail;	65	u8 tail;
		66	bool free_sgout;
66	struct scatterlist sg[];	67	struct scatterlist sg[];
67	};	68	};
68		69
@@ -187,7 +188,6 @@ static void tls_decrypt_done(void *data, int err) · 118 unmodified lines
187	struct aead_request *aead_req = data;	188	struct aead_request *aead_req = data;
188	struct crypto_aead *aead = crypto_aead_reqtfm(aead_req);	189	struct crypto_aead *aead = crypto_aead_reqtfm(aead_req);
189	struct scatterlist *sgout = aead_req->dst;	190	struct scatterlist *sgout = aead_req->dst;
190	struct scatterlist *sgin = aead_req->src;
191	struct tls_sw_context_rx *ctx;	191	struct tls_sw_context_rx *ctx;
192	struct tls_decrypt_ctx *dctx;	192	struct tls_decrypt_ctx *dctx;
193	struct tls_context *tls_ctx;	193	struct tls_context *tls_ctx;
@@ -196,6 +196,17 @@ static void tls_decrypt_done(void *data, int err) · 2 unmodified lines
196	struct sock *sk;	196	struct sock *sk;
197	int aead_size;	197	int aead_size;
198		198
		199	/* If requests get too backlogged crypto API returns -EBUSY and calls
		200	* ->complete(-EINPROGRESS) immediately followed by ->complete(0)
		201	* to make waiting for backlog to flush with crypto_wait_req() easier.
		202	* First wait converts -EBUSY -> -EINPROGRESS, and the second one
		203	* -EINPROGRESS -> 0.
		204	* We have a single struct crypto_async_request per direction, this
		205	* scheme doesn't help us, so just ignore the first ->complete().
		206	*/
		207	if (err == -EINPROGRESS)
		208	return;
		209
199	aead_size = sizeof(*aead_req) + crypto_aead_reqsize(aead);	210	aead_size = sizeof(*aead_req) + crypto_aead_reqsize(aead);
200	aead_size = ALIGN(aead_size, __alignof__(*dctx));	211	aead_size = ALIGN(aead_size, __alignof__(*dctx));
201	dctx = (void )((u8 )aead_req + aead_size);	212	dctx = (void )((u8 )aead_req + aead_size);
@@ -213,7 +224,7 @@ static void tls_decrypt_done(void *data, int err) · 11 unmodified lines
213	}	224	}
214		225
215	/* Free the destination pages if skb was not decrypted inplace */	226	/* Free the destination pages if skb was not decrypted inplace */
216	if (sgout != sgin) {	227	if (dctx->free_sgout) {
217	/* Skip the first S/G entry as it points to AAD */	228	/* Skip the first S/G entry as it points to AAD */
218	for_each_sg(sg_next(sgout), sg, UINT_MAX, pages) {	229	for_each_sg(sg_next(sgout), sg, UINT_MAX, pages) {
219	if (!sg)	230	if (!sg)
@@ -224,10 +235,17 @@ static void tls_decrypt_done(void *data, int err) · 4 unmodified lines
224		235
225	kfree(aead_req);	236	kfree(aead_req);
226		237
227	spin_lock_bh(&ctx->decrypt_compl_lock);	238	if (atomic_dec_and_test(&ctx->decrypt_pending))
228	if (!atomic_dec_return(&ctx->decrypt_pending))
229	complete(&ctx->async_wait.completion);	239	complete(&ctx->async_wait.completion);
230	spin_unlock_bh(&ctx->decrypt_compl_lock);	240	}
		241
		242	static int tls_decrypt_async_wait(struct tls_sw_context_rx *ctx)
		243	{
		244	if (!atomic_dec_and_test(&ctx->decrypt_pending))
		245	crypto_wait_req(-EINPROGRESS, &ctx->async_wait);
		246	atomic_inc(&ctx->decrypt_pending);
		247
		248	return ctx->async_wait.err;
231	}	249	}
232		250
233	static int tls_do_decryption(struct sock *sk,	251	static int tls_do_decryption(struct sock *sk,
@@ -253,6 +271,7 @@ static int tls_do_decryption(struct sock *sk, · 19 unmodified lines
253	aead_request_set_callback(aead_req,	271	aead_request_set_callback(aead_req,
254	CRYPTO_TFM_REQ_MAY_BACKLOG,	272	CRYPTO_TFM_REQ_MAY_BACKLOG,
255	tls_decrypt_done, aead_req);	273	tls_decrypt_done, aead_req);
		274	DEBUG_NET_WARN_ON_ONCE(atomic_read(&ctx->decrypt_pending) < 1);
256	atomic_inc(&ctx->decrypt_pending);	275	atomic_inc(&ctx->decrypt_pending);
257	} else {	276	} else {
258	aead_request_set_callback(aead_req,	277	aead_request_set_callback(aead_req,
@@ -261,6 +280,10 @@ static int tls_do_decryption(struct sock *sk, · 2 unmodified lines
261	}	280	}
262		281
263	ret = crypto_aead_decrypt(aead_req);	282	ret = crypto_aead_decrypt(aead_req);
		283	if (ret == -EBUSY) {
		284	ret = tls_decrypt_async_wait(ctx);
		285	ret = ret ?: -EINPROGRESS;
		286	}
264	if (ret == -EINPROGRESS) {	287	if (ret == -EINPROGRESS) {
265	if (darg->async)	288	if (darg->async)
266	return 0;	289	return 0;
@@ -439,9 +462,10 @@ static void tls_encrypt_done(void *data, int err) · 172 unmodified lines
439	struct tls_rec *rec = data;	462	struct tls_rec *rec = data;
440	struct scatterlist *sge;	463	struct scatterlist *sge;
441	struct sk_msg *msg_en;	464	struct sk_msg *msg_en;
442	bool ready = false;
443	struct sock *sk;	465	struct sock *sk;
444	int pending;	466
		467	if (err == -EINPROGRESS) /* see the comment in tls_decrypt_done() */
		468	return;
445		469
446	msg_en = &rec->msg_encrypted;	470	msg_en = &rec->msg_encrypted;
447		471
@@ -476,23 +500,25 @@ static void tls_encrypt_done(void *data, int err) · 28 unmodified lines
476	/* If received record is at head of tx_list, schedule tx */	500	/* If received record is at head of tx_list, schedule tx */
477	first_rec = list_first_entry(&ctx->tx_list,	501	first_rec = list_first_entry(&ctx->tx_list,
478	struct tls_rec, list);	502	struct tls_rec, list);
479	if (rec == first_rec)	503	if (rec == first_rec) {
480	ready = true;	504	/* Schedule the transmission */
		505	if (!test_and_set_bit(BIT_TX_SCHEDULED,
		506	&ctx->tx_bitmask))
		507	schedule_delayed_work(&ctx->tx_work.work, 1);
		508	}
481	}	509	}
482		510
483	spin_lock_bh(&ctx->encrypt_compl_lock);	511	if (atomic_dec_and_test(&ctx->encrypt_pending))
484	pending = atomic_dec_return(&ctx->encrypt_pending);
485
486	if (!pending && ctx->async_notify)
487	complete(&ctx->async_wait.completion);	512	complete(&ctx->async_wait.completion);
488	spin_unlock_bh(&ctx->encrypt_compl_lock);	513	}
489		514
490	if (!ready)	515	static int tls_encrypt_async_wait(struct tls_sw_context_tx *ctx)
491	return;	516	{
		517	if (!atomic_dec_and_test(&ctx->encrypt_pending))
		518	crypto_wait_req(-EINPROGRESS, &ctx->async_wait);
		519	atomic_inc(&ctx->encrypt_pending);
492		520
493	/* Schedule the transmission */	521	return ctx->async_wait.err;
494	if (!test_and_set_bit(BIT_TX_SCHEDULED, &ctx->tx_bitmask))
495	schedule_delayed_work(&ctx->tx_work.work, 1);
496	}	522	}
497		523
498	static int tls_do_encryption(struct sock *sk,	524	static int tls_do_encryption(struct sock *sk,
@@ -541,9 +567,14 @@ static int tls_do_encryption(struct sock *sk, · 42 unmodified lines
541		567
542	/* Add the record in tx_list */	568	/* Add the record in tx_list */
543	list_add_tail((struct list_head *)&rec->list, &ctx->tx_list);	569	list_add_tail((struct list_head *)&rec->list, &ctx->tx_list);
		570	DEBUG_NET_WARN_ON_ONCE(atomic_read(&ctx->encrypt_pending) < 1);
544	atomic_inc(&ctx->encrypt_pending);	571	atomic_inc(&ctx->encrypt_pending);
545		572
546	rc = crypto_aead_encrypt(aead_req);	573	rc = crypto_aead_encrypt(aead_req);
		574	if (rc == -EBUSY) {
		575	rc = tls_encrypt_async_wait(ctx);
		576	rc = rc ?: -EINPROGRESS;
		577	}
547	if (!rc \|\| rc != -EINPROGRESS) {	578	if (!rc \|\| rc != -EINPROGRESS) {
548	atomic_dec(&ctx->encrypt_pending);	579	atomic_dec(&ctx->encrypt_pending);
549	sge->offset -= prot->prepend_size;	580	sge->offset -= prot->prepend_size;
@@ -984,7 +1015,6 @@ static int tls_sw_sendmsg_locked(struct sock sk, struct msghdr msg, · 434 unmodified lines
984	int num_zc = 0;	1015	int num_zc = 0;
985	int orig_size;	1016	int orig_size;
986	int ret = 0;	1017	int ret = 0;
987	int pending;
988		1018
989	if (!eor && (msg->msg_flags & MSG_EOR))	1019	if (!eor && (msg->msg_flags & MSG_EOR))
990	return -EINVAL;	1020	return -EINVAL;
@@ -1163,24 +1193,12 @@ trim_sgl: · 172 unmodified lines
1163	if (!num_async) {	1193	if (!num_async) {
1164	goto send_end;	1194	goto send_end;
1165	} else if (num_zc) {	1195	} else if (num_zc) {
1166	/* Wait for pending encryptions to get completed */	1196	int err;
1167	spin_lock_bh(&ctx->encrypt_compl_lock);
1168	ctx->async_notify = true;
1169
1170	pending = atomic_read(&ctx->encrypt_pending);
1171	spin_unlock_bh(&ctx->encrypt_compl_lock);
1172	if (pending)
1173	crypto_wait_req(-EINPROGRESS, &ctx->async_wait);
1174	else
1175	reinit_completion(&ctx->async_wait.completion);
1176
1177	/* There can be no concurrent accesses, since we have no
1178	* pending encrypt operations
1179	*/
1180	WRITE_ONCE(ctx->async_notify, false);
1181		1197
1182	if (ctx->async_wait.err) {	1198	/* Wait for pending encryptions to get completed */
1183	ret = ctx->async_wait.err;	1199	err = tls_encrypt_async_wait(ctx);
		1200	if (err) {
		1201	ret = err;
1184	copied = 0;	1202	copied = 0;
1185	}	1203	}
1186	}	1204	}
@@ -1229,7 +1247,6 @@ void tls_sw_splice_eof(struct socket *sock) · 42 unmodified lines
1229	ssize_t copied = 0;	1247	ssize_t copied = 0;
1230	bool retrying = false;	1248	bool retrying = false;
1231	int ret = 0;	1249	int ret = 0;
1232	int pending;
1233		1250
1234	if (!ctx->open_rec)	1251	if (!ctx->open_rec)
1235	return;	1252	return;
@@ -1264,22 +1281,7 @@ retry: · 28 unmodified lines
1264	}	1281	}
1265		1282
1266	/* Wait for pending encryptions to get completed */	1283	/* Wait for pending encryptions to get completed */
1267	spin_lock_bh(&ctx->encrypt_compl_lock);	1284	if (tls_encrypt_async_wait(ctx))
1268	ctx->async_notify = true;
1269
1270	pending = atomic_read(&ctx->encrypt_pending);
1271	spin_unlock_bh(&ctx->encrypt_compl_lock);
1272	if (pending)
1273	crypto_wait_req(-EINPROGRESS, &ctx->async_wait);
1274	else
1275	reinit_completion(&ctx->async_wait.completion);
1276
1277	/* There can be no concurrent accesses, since we have no pending
1278	* encrypt operations
1279	*/
1280	WRITE_ONCE(ctx->async_notify, false);
1281
1282	if (ctx->async_wait.err)
1283	goto unlock;	1285	goto unlock;
1284		1286
1285	/* Transmit if any encryptions have completed */	1287	/* Transmit if any encryptions have completed */
@@ -1581,6 +1583,7 @@ static int tls_decrypt_sg(struct sock sk, struct iov_iter out_iov, · 295 unmodified lines
1581	} else if (out_sg) {	1583	} else if (out_sg) {
1582	memcpy(sgout, out_sg, n_sgout * sizeof(*sgout));	1584	memcpy(sgout, out_sg, n_sgout * sizeof(*sgout));
1583	}	1585	}
		1586	dctx->free_sgout = !!pages;
1584		1587
1585	/* Prepare and submit AEAD request */	1588	/* Prepare and submit AEAD request */
1586	err = tls_do_decryption(sk, sgin, sgout, dctx->iv,	1589	err = tls_do_decryption(sk, sgin, sgout, dctx->iv,
@@ -2109,16 +2112,10 @@ put_on_rx_list: · 522 unmodified lines
2109		2112
2110	recv_end:	2113	recv_end:
2111	if (async) {	2114	if (async) {
2112	int ret, pending;	2115	int ret;
2113		2116
2114	/* Wait for all previously submitted records to be decrypted */	2117	/* Wait for all previously submitted records to be decrypted */
2115	spin_lock_bh(&ctx->decrypt_compl_lock);	2118	ret = tls_decrypt_async_wait(ctx);
2116	reinit_completion(&ctx->async_wait.completion);
2117	pending = atomic_read(&ctx->decrypt_pending);
2118	spin_unlock_bh(&ctx->decrypt_compl_lock);
2119	ret = 0;
2120	if (pending)
2121	ret = crypto_wait_req(-EINPROGRESS, &ctx->async_wait);
2122	__skb_queue_purge(&ctx->async_hold);	2119	__skb_queue_purge(&ctx->async_hold);
2123		2120
2124	if (ret) {	2121	if (ret) {
@@ -2135,7 +2132,6 @@ recv_end: · 10 unmodified lines
2135	else	2132	else
2136	err = process_rx_list(ctx, msg, &control, 0,	2133	err = process_rx_list(ctx, msg, &control, 0,
2137	async_copy_bytes, is_peek);	2134	async_copy_bytes, is_peek);
2138	decrypted += max(err, 0);
2139	}	2135	}
2140		2136
2141	copied += decrypted;	2137	copied += decrypted;
@@ -2435,16 +2431,9 @@ void tls_sw_release_resources_tx(struct sock *sk) · 293 unmodified lines
2435	struct tls_context *tls_ctx = tls_get_ctx(sk);	2431	struct tls_context *tls_ctx = tls_get_ctx(sk);
2436	struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);	2432	struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
2437	struct tls_rec rec, tmp;	2433	struct tls_rec rec, tmp;
2438	int pending;
2439		2434
2440	/* Wait for any pending async encryptions to complete */	2435	/* Wait for any pending async encryptions to complete */
2441	spin_lock_bh(&ctx->encrypt_compl_lock);	2436	tls_encrypt_async_wait(ctx);
2442	ctx->async_notify = true;
2443	pending = atomic_read(&ctx->encrypt_pending);
2444	spin_unlock_bh(&ctx->encrypt_compl_lock);
2445
2446	if (pending)
2447	crypto_wait_req(-EINPROGRESS, &ctx->async_wait);
2448		2437
2449	tls_tx_records(sk, -1);	2438	tls_tx_records(sk, -1);
2450		2439
@@ -2607,7 +2596,7 @@ static struct tls_sw_context_tx init_ctx_tx(struct tls_context ctx, struct soc · 156 unmodified lines
2607	}	2596	}
2608		2597
2609	crypto_init_wait(&sw_ctx_tx->async_wait);	2598	crypto_init_wait(&sw_ctx_tx->async_wait);
2610	spin_lock_init(&sw_ctx_tx->encrypt_compl_lock);	2599	atomic_set(&sw_ctx_tx->encrypt_pending, 1);
2611	INIT_LIST_HEAD(&sw_ctx_tx->tx_list);	2600	INIT_LIST_HEAD(&sw_ctx_tx->tx_list);
2612	INIT_DELAYED_WORK(&sw_ctx_tx->tx_work.work, tx_work_handler);	2601	INIT_DELAYED_WORK(&sw_ctx_tx->tx_work.work, tx_work_handler);
2613	sw_ctx_tx->tx_work.sk = sk;	2602	sw_ctx_tx->tx_work.sk = sk;
@@ -2628,7 +2617,7 @@ static struct tls_sw_context_rx init_ctx_rx(struct tls_context ctx) · 14 unmodified lines
2628	}	2617	}
2629		2618
2630	crypto_init_wait(&sw_ctx_rx->async_wait);	2619	crypto_init_wait(&sw_ctx_rx->async_wait);
2631	spin_lock_init(&sw_ctx_rx->decrypt_compl_lock);	2620	atomic_set(&sw_ctx_rx->decrypt_pending, 1);
2632	init_waitqueue_head(&sw_ctx_rx->wq);	2621	init_waitqueue_head(&sw_ctx_rx->wq);
2633	skb_queue_head_init(&sw_ctx_rx->rx_list);	2622	skb_queue_head_init(&sw_ctx_rx->rx_list);
2634	skb_queue_head_init(&sw_ctx_rx->async_hold);	2623	skb_queue_head_init(&sw_ctx_rx->async_hold);

net/unix/garbage.c+4−3

 	__skb_queue_purge(&hitlist);
 #if IS_ENABLED(CONFIG_AF_UNIX_OOB)
-	list_for_each_entry_safe(u, next, &gc_candidates, link) {
+	while (!list_empty(&gc_candidates)) {
-		struct sk_buff *skb = u->oob_skb;
+		u = list_entry(gc_candidates.next, struct unix_sock, link);
+		if (u->oob_skb) {
+			struct sk_buff *skb = u->oob_skb;
-		if (skb) {
 			u->oob_skb = NULL;
 			kfree_skb(skb);
 		}

net/xfrm/xfrm_algo.c+1−0

@@ -858,4 +858,5 @@ int xfrm_count_pfkey_enc_supported(void) · 857 unmodified lines
858	}	858	}
859	EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);	859	EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
860		860
		861	MODULE_DESCRIPTION("XFRM Algorithm interface");
861	MODULE_LICENSE("GPL");	862	MODULE_LICENSE("GPL");

net/xfrm/xfrm_user.c+1−0

@@ -3888,5 +3888,6 @@ static void __exit xfrm_user_exit(void) · 3887 unmodified lines
3888		3888
3889	module_init(xfrm_user_init);	3889	module_init(xfrm_user_init);
3890	module_exit(xfrm_user_exit);	3890	module_exit(xfrm_user_exit);
		3891	MODULE_DESCRIPTION("XFRM User interface");
3891	MODULE_LICENSE("GPL");	3892	MODULE_LICENSE("GPL");
3892	MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_XFRM);	3893	MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_XFRM);

tools/testing/selftests/net/config+5−1

 CONFIG_INET_DIAG=y
 CONFIG_INET_ESP=y
 CONFIG_INET_ESP_OFFLOAD=y
+CONFIG_NET_FOU=y
+CONFIG_NET_FOU_IP_TUNNELS=y
 CONFIG_IP_GRE=m
 CONFIG_NETFILTER=y
 CONFIG_NETFILTER_ADVANCED=y
 CONFIG_NF_CONNTRACK=m
+CONFIG_IPV6_SIT=y
+CONFIG_IP_DCCP=m
 CONFIG_NF_NAT=m
 CONFIG_IP6_NF_IPTABLES=m
 CONFIG_IP_NF_IPTABLES=m
 CONFIG_NET_CLS_U32=m
 CONFIG_NET_IPGRE_DEMUX=m
 CONFIG_NET_IPGRE=m
+CONFIG_NET_IPIP=y
 CONFIG_NET_SCH_FQ_CODEL=m
 CONFIG_NET_SCH_HTB=m
 CONFIG_NET_SCH_FQ=m
 CONFIG_TRACEPOINTS=y
 CONFIG_NET_DROP_MONITOR=m
 CONFIG_NETDEVSIM=m
-CONFIG_NET_FOU=m
 CONFIG_MPLS_ROUTING=m
 CONFIG_MPLS_IPTUNNEL=m
 CONFIG_NET_SCH_INGRESS=m

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

 	RET=0
 	check_port_mab_support || return 0
-	bridge link set dev $swp1 learning on locked on mab on
 	tc qdisc add dev $swp1 clsact
 	tc filter add dev $swp1 ingress protocol all pref 1 handle 101 flower \
 		action mirred egress redirect dev $swp2
+	bridge link set dev $swp1 learning on locked on mab on
 	ping_do $h1 192.0.2.2
 	check_err $? "Ping did not work with redirection"
 	check_err $? "Locked entry not created after deleting filter"
 	bridge fdb del `mac_get $h1` vlan 1 dev $swp1 master
-	tc qdisc del dev $swp1 clsact
 	bridge link set dev $swp1 learning off locked off mab off
+	tc qdisc del dev $swp1 clsact
 	log_test "Locked port MAB redirect"
 }

tools/testing/selftests/net/forwarding/bridge_mdb.sh+9−5

 	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q " 0.00"
 	check_err $? "(*, G) \"permanent\" entry has a pending group timer"
-	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q "\/0.00"
+	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q "/0.00"
 	check_err $? "\"permanent\" source entry has a pending source timer"
 	bridge mdb del dev br0 port $swp1 grp $grp vid 10
 	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q " 0.00"
 	check_fail $? "(*, G) EXCLUDE entry does not have a pending group timer"
-	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q "\/0.00"
+	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q "/0.00"
 	check_err $? "\"blocked\" source entry has a pending source timer"
 	bridge mdb del dev br0 port $swp1 grp $grp vid 10
 	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q " 0.00"
 	check_err $? "(*, G) INCLUDE entry has a pending group timer"
-	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q "\/0.00"
+	bridge -d -s mdb get dev br0 grp $grp vid 10 | grep -q "/0.00"
 	check_fail $? "Source entry does not have a pending source timer"
 	bridge mdb del dev br0 port $swp1 grp $grp vid 10
 	echo
 	log_info "# Forwarding tests"
+	# Set the Max Response Delay to 100 centiseconds (1 second) so that the
+	# bridge will start forwarding according to its MDB soon after a
+	# multicast querier is enabled.
+	ip link set dev br0 type bridge mcast_query_response_interval 100
 	# Forwarding according to MDB entries only takes place when the bridge
 	# detects that there is a valid querier in the network. Set the bridge
 	# as the querier and assign it a valid IPv6 link-local address to be
 	# used as the source address for MLD queries.
 	ip -6 address add fe80::1/64 nodad dev br0
 	ip link set dev br0 type bridge mcast_querier 1
-	# Wait the default Query Response Interval (10 seconds) for the bridge
-	# to determine that there are no other queriers in the network.
 	sleep 10
 	fwd_test_host
 	ip link set dev br0 type bridge mcast_querier 0
 	ip -6 address del fe80::1/64 dev br0
+	ip link set dev br0 type bridge mcast_query_response_interval 1000
 }
 ctrl_igmpv3_is_in_test()

tools/testing/selftests/net/forwarding/tc_flower_l2_miss.sh+6−2

 	# both registered and unregistered multicast traffic.
 	bridge link set dev $swp2 mcast_router 2
+	# Set the Max Response Delay to 100 centiseconds (1 second) so that the
+	# bridge will start forwarding according to its MDB soon after a
+	# multicast querier is enabled.
+	ip link set dev br1 type bridge mcast_query_response_interval 100
 	# Forwarding according to MDB entries only takes place when the bridge
 	# detects that there is a valid querier in the network. Set the bridge
 	# as the querier and assign it a valid IPv6 link-local address to be
 	# used as the source address for MLD queries.
 	ip link set dev br1 type bridge mcast_querier 1
 	ip -6 address add fe80::1/64 nodad dev br1
-	# Wait the default Query Response Interval (10 seconds) for the bridge
-	# to determine that there are no other queriers in the network.
 	sleep 10
 	test_l2_miss_multicast_ipv4
 	ip -6 address del fe80::1/64 dev br1
 	ip link set dev br1 type bridge mcast_querier 0
+	ip link set dev br1 type bridge mcast_query_response_interval 1000
 	bridge link set dev $swp2 mcast_router 1
 }

tools/testing/selftests/net/gro.sh+5−0

       1>>log.txt
     wait "${server_pid}"
     exit_code=$?
+    if [[ ${test} == "large" && -n "${KSFT_MACHINE_SLOW}" && \
+          ${exit_code} -ne 0 ]]; then
+        echo "Ignoring errors due to slow environment" 1>&2
+        exit_code=0
+    fi
     if [[ "${exit_code}" -eq 0 ]]; then
         break;
     fi

tools/testing/selftests/net/ip_local_port_range.c+4−0

 #define IP_LOCAL_PORT_RANGE 51
 #endif
+#ifndef IPPROTO_MPTCP
+#define IPPROTO_MPTCP 262
+#endif
 static __u32 pack_port_range(__u16 lo, __u16 hi)
 {
 	return (hi << 16) | (lo << 0);

tools/testing/selftests/net/net_helper.sh+7−4

 	local listener_ns="${1}"
 	local port="${2}"
 	local protocol="${3}"
-	local port_hex
+	local pattern
 	local i
-	port_hex="$(printf "%04X" "${port}")"
+	pattern=":$(printf "%04X" "${port}") "
+	# for tcp protocol additionally check the socket state
+	[ ${protocol} = "tcp" ] && pattern="${pattern}0A"
 	for i in $(seq 10); do
-		if ip netns exec "${listener_ns}" cat /proc/net/"${protocol}"* | \
+		if ip netns exec "${listener_ns}" awk '{print $2" "$4}' \
-		   grep -q "${port_hex}"; then
+		   /proc/net/"${protocol}"* | grep -q "${pattern}"; then
 			break
 		fi
 		sleep 0.1

tools/testing/selftests/net/openvswitch/openvswitch.sh+13−0

@@ -502,7 +502,20 @@ test_netlink_checks () { · 501 unmodified lines
502	wc -l) == 2 ] \|\| \	502	wc -l) == 2 ] \|\| \
503	return 1	503	return 1
504		504
		505	info "Checking clone depth"
505	ERR_MSG="Flow actions may not be safe on all matching packets"	506	ERR_MSG="Flow actions may not be safe on all matching packets"
		507	PRE_TEST=$(dmesg \| grep -c "${ERR_MSG}")
		508	ovs_add_flow "test_netlink_checks" nv0 \
		509	'in_port(1),eth(),eth_type(0x800),ipv4()' \
		510	'clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(clone(drop)))))))))))))))))' \
		511	>/dev/null 2>&1 && return 1
		512	POST_TEST=$(dmesg \| grep -c "${ERR_MSG}")
		513
		514	if [ "$PRE_TEST" == "$POST_TEST" ]; then
		515	info "failed - clone depth too large"
		516	return 1
		517	fi
		518
506	PRE_TEST=$(dmesg \| grep -c "${ERR_MSG}")	519	PRE_TEST=$(dmesg \| grep -c "${ERR_MSG}")
507	ovs_add_flow "test_netlink_checks" nv0 \	520	ovs_add_flow "test_netlink_checks" nv0 \
508	'in_port(1),eth(),eth_type(0x0806),arp()' 'drop(0),2' \	521	'in_port(1),eth(),eth_type(0x0806),arp()' 'drop(0),2' \

tools/testing/selftests/net/openvswitch/ovs-dpctl.py+56−15

@@ -299,7 +299,7 @@ class ovsactions(nla): · 298 unmodified lines
299	("OVS_ACTION_ATTR_PUSH_NSH", "none"),	299	("OVS_ACTION_ATTR_PUSH_NSH", "none"),
300	("OVS_ACTION_ATTR_POP_NSH", "flag"),	300	("OVS_ACTION_ATTR_POP_NSH", "flag"),
301	("OVS_ACTION_ATTR_METER", "none"),	301	("OVS_ACTION_ATTR_METER", "none"),
302	("OVS_ACTION_ATTR_CLONE", "none"),	302	("OVS_ACTION_ATTR_CLONE", "recursive"),
303	("OVS_ACTION_ATTR_CHECK_PKT_LEN", "none"),	303	("OVS_ACTION_ATTR_CHECK_PKT_LEN", "none"),
304	("OVS_ACTION_ATTR_ADD_MPLS", "none"),	304	("OVS_ACTION_ATTR_ADD_MPLS", "none"),
305	("OVS_ACTION_ATTR_DEC_TTL", "none"),	305	("OVS_ACTION_ATTR_DEC_TTL", "none"),
@@ -465,29 +465,42 @@ class ovsactions(nla): · 159 unmodified lines
465	print_str += "pop_mpls"	465	print_str += "pop_mpls"
466	else:	466	else:
467	datum = self.get_attr(field[0])	467	datum = self.get_attr(field[0])
468	print_str += datum.dpstr(more)	468	if field[0] == "OVS_ACTION_ATTR_CLONE":
		469	print_str += "clone("
		470	print_str += datum.dpstr(more)
		471	print_str += ")"
		472	else:
		473	print_str += datum.dpstr(more)
469		474
470	return print_str	475	return print_str
471		476
472	def parse(self, actstr):	477	def parse(self, actstr):
		478	totallen = len(actstr)
473	while len(actstr) != 0:	479	while len(actstr) != 0:
474	parsed = False	480	parsed = False
		481	parencount = 0
475	if actstr.startswith("drop"):	482	if actstr.startswith("drop"):
476	# If no reason is provided, the implicit drop is used (i.e no	483	# If no reason is provided, the implicit drop is used (i.e no
477	# action). If some reason is given, an explicit action is used.	484	# action). If some reason is given, an explicit action is used.
478	actstr, reason = parse_extract_field(	485	reason = None
479	actstr,	486	if actstr.startswith("drop("):
480	"drop(",	487	parencount += 1
481	"([0-9]+)",	488
482	lambda x: int(x, 0),	489	actstr, reason = parse_extract_field(
483	False,	490	actstr,
484	None,	491	"drop(",
485	)	492	"([0-9]+)",
		493	lambda x: int(x, 0),
		494	False,
		495	None,
		496	)
		497
486	if reason is not None:	498	if reason is not None:
487	self["attrs"].append(["OVS_ACTION_ATTR_DROP", reason])	499	self["attrs"].append(["OVS_ACTION_ATTR_DROP", reason])
488	parsed = True	500	parsed = True
489	else:	501	else:
490	return	502	actstr = actstr[len("drop"): ]
		503	return (totallen - len(actstr))
491		504
492	elif parse_starts_block(actstr, "^(\d+)", False, True):	505	elif parse_starts_block(actstr, "^(\d+)", False, True):
493	actstr, output = parse_extract_field(	506	actstr, output = parse_extract_field(
@@ -504,6 +517,7 @@ class ovsactions(nla): · 10 unmodified lines
504	False,	517	False,
505	0,	518	0,
506	)	519	)
		520	parencount += 1
507	self["attrs"].append(["OVS_ACTION_ATTR_RECIRC", recircid])	521	self["attrs"].append(["OVS_ACTION_ATTR_RECIRC", recircid])
508	parsed = True	522	parsed = True
509		523
@@ -516,12 +530,22 @@ class ovsactions(nla): · 6 unmodified lines
516		530
517	for flat_act in parse_flat_map:	531	for flat_act in parse_flat_map:
518	if parse_starts_block(actstr, flat_act[0], False):	532	if parse_starts_block(actstr, flat_act[0], False):
519	actstr += len(flat_act[0])	533	actstr = actstr[len(flat_act[0]):]
520	self["attrs"].append([flat_act[1]])	534	self["attrs"].append([flat_act[1]])
521	actstr = actstr[strspn(actstr, ", ") :]	535	actstr = actstr[strspn(actstr, ", ") :]
522	parsed = True	536	parsed = True
523		537
524	if parse_starts_block(actstr, "ct(", False):	538	if parse_starts_block(actstr, "clone(", False):
		539	parencount += 1
		540	subacts = ovsactions()
		541	actstr = actstr[len("clone("):]
		542	parsedLen = subacts.parse(actstr)
		543	lst = []
		544	self["attrs"].append(("OVS_ACTION_ATTR_CLONE", subacts))
		545	actstr = actstr[parsedLen:]
		546	parsed = True
		547	elif parse_starts_block(actstr, "ct(", False):
		548	parencount += 1
525	actstr = actstr[len("ct(") :]	549	actstr = actstr[len("ct(") :]
526	ctact = ovsactions.ctact()	550	ctact = ovsactions.ctact()
527		551
@@ -553,6 +577,7 @@ class ovsactions(nla): · 25 unmodified lines
553	natact = ovsactions.ctact.natattr()	577	natact = ovsactions.ctact.natattr()
554		578
555	if actstr.startswith("("):	579	if actstr.startswith("("):
		580	parencount += 1
556	t = None	581	t = None
557	actstr = actstr[1:]	582	actstr = actstr[1:]
558	if actstr.startswith("src"):	583	if actstr.startswith("src"):
@@ -607,15 +632,29 @@ class ovsactions(nla): · 48 unmodified lines
607	actstr = actstr[strspn(actstr, ", ") :]	632	actstr = actstr[strspn(actstr, ", ") :]
608		633
609	ctact["attrs"].append(["OVS_CT_ATTR_NAT", natact])	634	ctact["attrs"].append(["OVS_CT_ATTR_NAT", natact])
610	actstr = actstr[strspn(actstr, ",) ") :]	635	actstr = actstr[strspn(actstr, ", ") :]
611		636
612	self["attrs"].append(["OVS_ACTION_ATTR_CT", ctact])	637	self["attrs"].append(["OVS_ACTION_ATTR_CT", ctact])
613	parsed = True	638	parsed = True
614		639
615	actstr = actstr[strspn(actstr, "), ") :]	640	actstr = actstr[strspn(actstr, ", ") :]
		641	while parencount > 0:
		642	parencount -= 1
		643	actstr = actstr[strspn(actstr, " "):]
		644	if len(actstr) and actstr[0] != ")":
		645	raise ValueError("Action str: '%s' unbalanced" % actstr)
		646	actstr = actstr[1:]
		647
		648	if len(actstr) and actstr[0] == ")":
		649	return (totallen - len(actstr))
		650
		651	actstr = actstr[strspn(actstr, ", ") :]
		652
616	if not parsed:	653	if not parsed:
617	raise ValueError("Action str: '%s' not supported" % actstr)	654	raise ValueError("Action str: '%s' not supported" % actstr)
618		655
		656	return (totallen - len(actstr))
		657
619		658
620	class ovskey(nla):	659	class ovskey(nla):
621	nla_flags = NLA_F_NESTED	660	nla_flags = NLA_F_NESTED
@@ -2111,6 +2150,8 @@ def main(argv): · 1489 unmodified lines
2111	ovsflow = OvsFlow()	2150	ovsflow = OvsFlow()
2112	ndb = NDB()	2151	ndb = NDB()
2113		2152
		2153	sys.setrecursionlimit(100000)
		2154
2114	if hasattr(args, "showdp"):	2155	if hasattr(args, "showdp"):
2115	found = False	2156	found = False
2116	for iface in ndb.interfaces:	2157	for iface in ndb.interfaces:

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

 		else
 			TCPDST="TCP:[${dst}]:50000"
 		fi
-		${ns_b} socat -T 3 -u -6 TCP-LISTEN:50000 STDOUT > $tmpoutfile &
+		${ns_b} socat -T 3 -u -6 TCP-LISTEN:50000,reuseaddr STDOUT > $tmpoutfile &
 		local socat_pid=$!
 		wait_local_port_listen ${NS_B} 50000 tcp
 		dd if=/dev/zero status=none bs=1M count=1 | ${target} socat -T 3 -u STDIN $TCPDST,connect-timeout=3
+		wait ${socat_pid}
 		size=$(du -sb $tmpoutfile)
 		size=${size%%/tmp/*}
-		wait ${socat_pid}
 		[ $size -ne 1048576 ] && err "File size $size mismatches exepcted value in locally bridged vxlan test" && return 1
 	done

tools/testing/selftests/net/so_txtime.sh+25−4

 set -e
+readonly ksft_skip=4
 readonly DEV="veth0"
 readonly BIN="./so_txtime"
 ip -netns "${NS1}" addr add       fd::1/64 dev "${DEV}" nodad
 ip -netns "${NS2}" addr add       fd::2/64 dev "${DEV}" nodad
-do_test() {
+run_test() {
 	local readonly IP="$1"
 	local readonly CLOCK="$2"
 	local readonly TXARGS="$3"
 	fi
 	local readonly START="$(date +%s%N --date="+ 0.1 seconds")"
 	ip netns exec "${NS2}" "${BIN}" -"${IP}" -c "${CLOCK}" -t "${START}" -S "${SADDR}" -D "${DADDR}" "${RXARGS}" -r &
 	ip netns exec "${NS1}" "${BIN}" -"${IP}" -c "${CLOCK}" -t "${START}" -S "${SADDR}" -D "${DADDR}" "${TXARGS}"
 	wait "$!"
 }
+do_test() {
+	run_test $@
+	[ $? -ne 0 ] && ret=1
+}
+do_fail_test() {
+	run_test $@
+	[ $? -eq 0 ] && ret=1
+}
 ip netns exec "${NS1}" tc qdisc add dev "${DEV}" root fq
+set +e
+ret=0
 do_test 4 mono a,-1 a,-1
 do_test 6 mono a,0 a,0
 do_test 6 mono a,10 a,10
 do_test 6 mono a,20,b,10 b,20,a,20
 if ip netns exec "${NS1}" tc qdisc replace dev "${DEV}" root etf clockid CLOCK_TAI delta 400000; then
-	! do_test 4 tai a,-1 a,-1
+	do_fail_test 4 tai a,-1 a,-1
-	! do_test 6 tai a,0 a,0
+	do_fail_test 6 tai a,0 a,0
 	do_test 6 tai a,10 a,10
 	do_test 4 tai a,10,b,20 a,10,b,20
 	do_test 6 tai a,20,b,10 b,10,a,20
 else
 	echo "tc ($(tc -V)) does not support qdisc etf. skipping"
+	[ $ret -eq 0 ] && ret=$ksft_skip
 fi
-echo OK. All tests passed
+if [ $ret -eq 0 ]; then
+	echo OK. All tests passed
+elif [[ $ret -ne $ksft_skip && -n "$KSFT_MACHINE_SLOW" ]]; then
+	echo "Ignoring errors due to slow environment" 1>&2
+	ret=0
+fi
+exit $ret

tools/testing/selftests/net/test_bridge_backup_port.sh+23−0

 	[[ $pkts == $count ]]
 }
+bridge_link_check()
+{
+	local ns=$1; shift
+	local dev=$1; shift
+	local state=$1; shift
+	bridge -n $ns -d -j link show dev $dev | \
+		jq -e ".[][\"state\"] == \"$state\"" &> /dev/null
+}
 ################################################################################
 # Setup
 	log_test $? 0 "No forwarding out of vx0"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	log_test $? 0 "swp1 carrier off"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "No forwarding out of vx0"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier on"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 forwarding
 	log_test $? 0 "swp1 carrier on"
 	# Configure vx0 as the backup port of swp1 and check that packets are
 	log_test $? 0 "No forwarding out of vx0"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	log_test $? 0 "swp1 carrier off"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "Forwarding out of vx0"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier on"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 forwarding
 	log_test $? 0 "swp1 carrier on"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "No forwarding out of vx0"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	log_test $? 0 "swp1 carrier off"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "No forwarding out of vx0"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	log_test $? 0 "swp1 carrier off"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "Forwarding using VXLAN FDB entry"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier on"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 forwarding
 	log_test $? 0 "swp1 carrier on"
 	# Configure nexthop ID 10 as the backup nexthop ID of swp1 and check
 	log_test $? 0 "No forwarding out of vx0"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	log_test $? 0 "swp1 carrier off"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "No forwarding using VXLAN FDB entry"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier on"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 forwarding
 	log_test $? 0 "swp1 carrier on"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "No forwarding using VXLAN FDB entry"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	log_test $? 0 "swp1 carrier off"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	log_test $? 0 "Valid nexthop as backup nexthop"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	log_test $? 0 "swp1 carrier off"
 	run_cmd "ip netns exec $sw1 mausezahn br0.10 -a $smac -b $dmac -A 198.51.100.1 -B 198.51.100.2 -t ip -p 100 -q -c 1"
 	run_cmd "bridge -n $sw2 link set dev swp1 backup_nhid 10"
 	run_cmd "ip -n $sw1 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw1 swp1 disabled
 	run_cmd "ip -n $sw2 link set dev swp1 carrier off"
+	busywait $BUSYWAIT_TIMEOUT bridge_link_check $sw2 swp1 disabled
 	run_cmd "ip netns exec $sw1 ping -i 0.1 -c 10 -w $PING_TIMEOUT 192.0.2.66"
 	log_test $? 0 "Ping with backup nexthop ID"

tools/testing/selftests/net/tls.c+6−6

@@ -1002,12 +1002,12 @@ TEST_F(tls, recv_partial) · 1001 unmodified lines
1002		1002
1003	memset(recv_mem, 0, sizeof(recv_mem));	1003	memset(recv_mem, 0, sizeof(recv_mem));
1004	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);	1004	EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1005	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first),	1005	EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_first),
1006	MSG_WAITALL), -1);	1006	MSG_WAITALL), strlen(test_str_first));
1007	EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);	1007	EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
1008	memset(recv_mem, 0, sizeof(recv_mem));	1008	memset(recv_mem, 0, sizeof(recv_mem));
1009	EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second),	1009	EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_second),
1010	MSG_WAITALL), -1);	1010	MSG_WAITALL), strlen(test_str_second));
1011	EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),	1011	EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
1012	0);	1012	0);
1013	}	1013	}
@@ -1874,13 +1874,13 @@ TEST_F(tls_err, poll_partial_rec_async) · 860 unmodified lines
1874	/* Child should sleep in poll(), never get a wake */	1874	/* Child should sleep in poll(), never get a wake */
1875	pfd.fd = self->cfd2;	1875	pfd.fd = self->cfd2;
1876	pfd.events = POLLIN;	1876	pfd.events = POLLIN;
1877	EXPECT_EQ(poll(&pfd, 1, 5), 0);	1877	EXPECT_EQ(poll(&pfd, 1, 20), 0);
1878		1878
1879	EXPECT_EQ(write(p[1], &token, 1), 1); /* Barrier #1 */	1879	EXPECT_EQ(write(p[1], &token, 1), 1); /* Barrier #1 */
1880		1880
1881	pfd.fd = self->cfd2;	1881	pfd.fd = self->cfd2;
1882	pfd.events = POLLIN;	1882	pfd.events = POLLIN;
1883	EXPECT_EQ(poll(&pfd, 1, 5), 1);	1883	EXPECT_EQ(poll(&pfd, 1, 20), 1);
1884		1884
1885	exit(!_metadata->passed);	1885	exit(!_metadata->passed);
1886	}	1886	}

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