mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/net/sctp/stream_interleave.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /* SCTP kernel implementation
2
3
  * (C) Copyright Red Hat Inc. 2017
3
4
  *
..
..
@@ -5,22 +6,6 @@
5
6
  *
6
7
  * These functions implement sctp stream message interleaving, mostly
7
8
  * including I-DATA and I-FORWARD-TSN chunks process.
8
- *
9
- * This SCTP implementation is free software;
10
- * you can redistribute it and/or modify it under the terms of
11
- * the GNU General Public License as published by
12
- * the Free Software Foundation; either version 2, or (at your option)
13
- * any later version.
14
- *
15
- * This SCTP implementation is distributed in the hope that it
16
- * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17
- *                 ************************
18
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19
- * See the GNU General Public License for more details.
20
- *
21
- * You should have received a copy of the GNU General Public License
22
- * along with GNU CC; see the file COPYING.  If not, see
23
- * <http://www.gnu.org/licenses/>.
24
9
  *
25
10
  * Please send any bug reports or fixes you make to the
26
11
  * email addresched(es):
..
..
@@ -101,7 +86,7 @@
101
86
 
102
87
 static bool sctp_validate_data(struct sctp_chunk *chunk)
103
88
 {
104
-	const struct sctp_stream *stream;
89
+	struct sctp_stream *stream;
105
90
 	__u16 sid, ssn;
106
91
 
107
92
 	if (chunk->chunk_hdr->type != SCTP_CID_DATA)
..
..
@@ -140,7 +125,7 @@
140
125
 				  struct sctp_ulpevent *event)
141
126
 {
142
127
 	struct sctp_ulpevent *cevent;
143
-	struct sk_buff *pos;
128
+	struct sk_buff *pos, *loc;
144
129
 
145
130
 	pos = skb_peek_tail(&ulpq->reasm);
146
131
 	if (!pos) {
..
..
@@ -166,23 +151,30 @@
166
151
 		return;
167
152
 	}
168
153
 
154
+	loc = NULL;
169
155
 	skb_queue_walk(&ulpq->reasm, pos) {
170
156
 		cevent = sctp_skb2event(pos);
171
157
 
172
158
 		if (event->stream < cevent->stream ||
173
159
 		    (event->stream == cevent->stream &&
174
-		     MID_lt(event->mid, cevent->mid)))
160
+		     MID_lt(event->mid, cevent->mid))) {
161
+			loc = pos;
175
162
 			break;
176
-
163
+		}
177
164
 		if (event->stream == cevent->stream &&
178
165
 		    event->mid == cevent->mid &&
179
166
 		    !(cevent->msg_flags & SCTP_DATA_FIRST_FRAG) &&
180
167
 		    (event->msg_flags & SCTP_DATA_FIRST_FRAG ||
181
-		     event->fsn < cevent->fsn))
168
+		     event->fsn < cevent->fsn)) {
169
+			loc = pos;
182
170
 			break;
171
+		}
183
172
 	}
184
173
 
185
-	__skb_queue_before(&ulpq->reasm, pos, sctp_event2skb(event));
174
+	if (!loc)
175
+		__skb_queue_tail(&ulpq->reasm, sctp_event2skb(event));
176
+	else
177
+		__skb_queue_before(&ulpq->reasm, loc, sctp_event2skb(event));
186
178
 }
187
179
 
188
180
 static struct sctp_ulpevent *sctp_intl_retrieve_partial(
..
..
@@ -249,9 +241,8 @@
249
241
 	if (!first_frag)
250
242
 		return NULL;
251
243
 
252
-	retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk),
253
-					     &ulpq->reasm, first_frag,
254
-					     last_frag);
244
+	retval = sctp_make_reassembled_event(ulpq->asoc->base.net, &ulpq->reasm,
245
+					     first_frag, last_frag);
255
246
 	if (retval) {
256
247
 		sin->fsn = next_fsn;
257
248
 		if (is_last) {
..
..
@@ -334,7 +325,7 @@
334
325
 
335
326
 	pd_point = sctp_sk(asoc->base.sk)->pd_point;
336
327
 	if (pd_point && pd_point <= pd_len) {
337
-		retval = sctp_make_reassembled_event(sock_net(asoc->base.sk),
328
+		retval = sctp_make_reassembled_event(asoc->base.net,
338
329
 						     &ulpq->reasm,
339
330
 						     pd_first, pd_last);
340
331
 		if (retval) {
..
..
@@ -345,8 +336,7 @@
345
336
 	goto out;
346
337
 
347
338
 found:
348
-	retval = sctp_make_reassembled_event(sock_net(asoc->base.sk),
349
-					     &ulpq->reasm,
339
+	retval = sctp_make_reassembled_event(asoc->base.net, &ulpq->reasm,
350
340
 					     first_frag, pos);
351
341
 	if (retval)
352
342
 		retval->msg_flags |= MSG_EOR;
..
..
@@ -383,7 +373,7 @@
383
373
 				    struct sctp_ulpevent *event)
384
374
 {
385
375
 	struct sctp_ulpevent *cevent;
386
-	struct sk_buff *pos;
376
+	struct sk_buff *pos, *loc;
387
377
 
388
378
 	pos = skb_peek_tail(&ulpq->lobby);
389
379
 	if (!pos) {
..
..
@@ -403,18 +393,25 @@
403
393
 		return;
404
394
 	}
405
395
 
396
+	loc = NULL;
406
397
 	skb_queue_walk(&ulpq->lobby, pos) {
407
398
 		cevent = (struct sctp_ulpevent *)pos->cb;
408
399
 
409
-		if (cevent->stream > event->stream)
400
+		if (cevent->stream > event->stream) {
401
+			loc = pos;
410
402
 			break;
411
-
403
+		}
412
404
 		if (cevent->stream == event->stream &&
413
-		    MID_lt(event->mid, cevent->mid))
405
+		    MID_lt(event->mid, cevent->mid)) {
406
+			loc = pos;
414
407
 			break;
408
+		}
415
409
 	}
416
410
 
417
-	__skb_queue_before(&ulpq->lobby, pos, sctp_event2skb(event));
411
+	if (!loc)
412
+		__skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
413
+	else
414
+		__skb_queue_before(&ulpq->lobby, loc, sctp_event2skb(event));
418
415
 }
419
416
 
420
417
 static void sctp_intl_retrieve_ordered(struct sctp_ulpq *ulpq,
..
..
@@ -470,14 +467,15 @@
470
467
 }
471
468
 
472
469
 static int sctp_enqueue_event(struct sctp_ulpq *ulpq,
473
-			      struct sctp_ulpevent *event)
470
+			      struct sk_buff_head *skb_list)
474
471
 {
475
-	struct sk_buff *skb = sctp_event2skb(event);
476
472
 	struct sock *sk = ulpq->asoc->base.sk;
477
473
 	struct sctp_sock *sp = sctp_sk(sk);
478
-	struct sk_buff_head *skb_list;
474
+	struct sctp_ulpevent *event;
475
+	struct sk_buff *skb;
479
476
 
480
-	skb_list = (struct sk_buff_head *)skb->prev;
477
+	skb = __skb_peek(skb_list);
478
+	event = sctp_skb2event(skb);
481
479
 
482
480
 	if (sk->sk_shutdown & RCV_SHUTDOWN &&
483
481
 	    (sk->sk_shutdown & SEND_SHUTDOWN ||
..
..
@@ -489,7 +487,7 @@
489
487
 		sk_incoming_cpu_update(sk);
490
488
 	}
491
489
 
492
-	if (!sctp_ulpevent_is_enabled(event, &sp->subscribe))
490
+	if (!sctp_ulpevent_is_enabled(event, ulpq->asoc->subscribe))
493
491
 		goto out_free;
494
492
 
495
493
 	if (skb_list)
..
..
@@ -630,7 +628,7 @@
630
628
 	if (!first_frag)
631
629
 		return NULL;
632
630
 
633
-	retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk),
631
+	retval = sctp_make_reassembled_event(ulpq->asoc->base.net,
634
632
 					     &ulpq->reasm_uo, first_frag,
635
633
 					     last_frag);
636
634
 	if (retval) {
..
..
@@ -716,7 +714,7 @@
716
714
 
717
715
 	pd_point = sctp_sk(asoc->base.sk)->pd_point;
718
716
 	if (pd_point && pd_point <= pd_len) {
719
-		retval = sctp_make_reassembled_event(sock_net(asoc->base.sk),
717
+		retval = sctp_make_reassembled_event(asoc->base.net,
720
718
 						     &ulpq->reasm_uo,
721
719
 						     pd_first, pd_last);
722
720
 		if (retval) {
..
..
@@ -727,8 +725,7 @@
727
725
 	goto out;
728
726
 
729
727
 found:
730
-	retval = sctp_make_reassembled_event(sock_net(asoc->base.sk),
731
-					     &ulpq->reasm_uo,
728
+	retval = sctp_make_reassembled_event(asoc->base.net, &ulpq->reasm_uo,
732
729
 					     first_frag, pos);
733
730
 	if (retval)
734
731
 		retval->msg_flags |= MSG_EOR;
..
..
@@ -814,7 +811,7 @@
814
811
 		return NULL;
815
812
 
816
813
 out:
817
-	retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk),
814
+	retval = sctp_make_reassembled_event(ulpq->asoc->base.net,
818
815
 					     &ulpq->reasm_uo, first_frag,
819
816
 					     last_frag);
820
817
 	if (retval) {
..
..
@@ -844,19 +841,24 @@
844
841
 
845
842
 	if (!(event->msg_flags & SCTP_DATA_UNORDERED)) {
846
843
 		event = sctp_intl_reasm(ulpq, event);
847
-		if (event && event->msg_flags & MSG_EOR) {
844
+		if (event) {
848
845
 			skb_queue_head_init(&temp);
849
846
 			__skb_queue_tail(&temp, sctp_event2skb(event));
850
847
 
851
-			event = sctp_intl_order(ulpq, event);
848
+			if (event->msg_flags & MSG_EOR)
849
+				event = sctp_intl_order(ulpq, event);
852
850
 		}
853
851
 	} else {
854
852
 		event = sctp_intl_reasm_uo(ulpq, event);
853
+		if (event) {
854
+			skb_queue_head_init(&temp);
855
+			__skb_queue_tail(&temp, sctp_event2skb(event));
856
+		}
855
857
 	}
856
858
 
857
859
 	if (event) {
858
860
 		event_eor = (event->msg_flags & MSG_EOR) ? 1 : 0;
859
-		sctp_enqueue_event(ulpq, event);
861
+		sctp_enqueue_event(ulpq, &temp);
860
862
 	}
861
863
 
862
864
 	return event_eor;
..
..
@@ -916,7 +918,7 @@
916
918
 		return NULL;
917
919
 
918
920
 out:
919
-	retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk),
921
+	retval = sctp_make_reassembled_event(ulpq->asoc->base.net,
920
922
 					     &ulpq->reasm, first_frag,
921
923
 					     last_frag);
922
924
 	if (retval) {
..
..
@@ -930,20 +932,27 @@
930
932
 static void sctp_intl_start_pd(struct sctp_ulpq *ulpq, gfp_t gfp)
931
933
 {
932
934
 	struct sctp_ulpevent *event;
935
+	struct sk_buff_head temp;
933
936
 
934
937
 	if (!skb_queue_empty(&ulpq->reasm)) {
935
938
 		do {
936
939
 			event = sctp_intl_retrieve_first(ulpq);
937
-			if (event)
938
-				sctp_enqueue_event(ulpq, event);
940
+			if (event) {
941
+				skb_queue_head_init(&temp);
942
+				__skb_queue_tail(&temp, sctp_event2skb(event));
943
+				sctp_enqueue_event(ulpq, &temp);
944
+			}
939
945
 		} while (event);
940
946
 	}
941
947
 
942
948
 	if (!skb_queue_empty(&ulpq->reasm_uo)) {
943
949
 		do {
944
950
 			event = sctp_intl_retrieve_first_uo(ulpq);
945
-			if (event)
946
-				sctp_enqueue_event(ulpq, event);
951
+			if (event) {
952
+				skb_queue_head_init(&temp);
953
+				__skb_queue_tail(&temp, sctp_event2skb(event));
954
+				sctp_enqueue_event(ulpq, &temp);
955
+			}
947
956
 		} while (event);
948
957
 	}
949
958
 }
..
..
@@ -980,17 +989,19 @@
980
989
 	struct sock *sk = ulpq->asoc->base.sk;
981
990
 	struct sctp_ulpevent *ev = NULL;
982
991
 
983
-	if (!sctp_ulpevent_type_enabled(SCTP_PARTIAL_DELIVERY_EVENT,
984
-					&sctp_sk(sk)->subscribe))
992
+	if (!sctp_ulpevent_type_enabled(ulpq->asoc->subscribe,
993
+					SCTP_PARTIAL_DELIVERY_EVENT))
985
994
 		return;
986
995
 
987
996
 	ev = sctp_ulpevent_make_pdapi(ulpq->asoc, SCTP_PARTIAL_DELIVERY_ABORTED,
988
997
 				      sid, mid, flags, gfp);
989
998
 	if (ev) {
999
+		struct sctp_sock *sp = sctp_sk(sk);
1000
+
990
1001
 		__skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev));
991
1002
 
992
-		if (!sctp_sk(sk)->data_ready_signalled) {
993
-			sctp_sk(sk)->data_ready_signalled = 1;
1003
+		if (!sp->data_ready_signalled) {
1004
+			sp->data_ready_signalled = 1;
994
1005
 			sk->sk_data_ready(sk);
995
1006
 		}
996
1007
 	}
..
..
@@ -1043,7 +1054,7 @@
1043
1054
 
1044
1055
 	if (event) {
1045
1056
 		sctp_intl_retrieve_ordered(ulpq, event);
1046
-		sctp_enqueue_event(ulpq, event);
1057
+		sctp_enqueue_event(ulpq, &temp);
1047
1058
 	}
1048
1059
 }
1049
1060
 
..
..
@@ -1145,7 +1156,7 @@
1145
1156
 
1146
1157
 	if (ftsn_chunk) {
1147
1158
 		list_add_tail(&ftsn_chunk->list, &q->control_chunk_list);
1148
-		SCTP_INC_STATS(sock_net(asoc->base.sk), SCTP_MIB_OUTCTRLCHUNKS);
1159
+		SCTP_INC_STATS(asoc->base.net, SCTP_MIB_OUTCTRLCHUNKS);
1149
1160
 	}
1150
1161
 }
1151
1162
 
..
..
@@ -1282,6 +1293,15 @@
1282
1293
 			       ntohl(skip->mid), skip->flags);
1283
1294
 }
1284
1295
 
1296
+static int do_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event)
1297
+{
1298
+	struct sk_buff_head temp;
1299
+
1300
+	skb_queue_head_init(&temp);
1301
+	__skb_queue_tail(&temp, sctp_event2skb(event));
1302
+	return sctp_ulpq_tail_event(ulpq, &temp);
1303
+}
1304
+
1285
1305
 static struct sctp_stream_interleave sctp_stream_interleave_0 = {
1286
1306
 	.data_chunk_len		= sizeof(struct sctp_data_chunk),
1287
1307
 	.ftsn_chunk_len		= sizeof(struct sctp_fwdtsn_chunk),
..
..
@@ -1290,7 +1310,7 @@
1290
1310
 	.assign_number		= sctp_chunk_assign_ssn,
1291
1311
 	.validate_data		= sctp_validate_data,
1292
1312
 	.ulpevent_data		= sctp_ulpq_tail_data,
1293
-	.enqueue_event		= sctp_ulpq_tail_event,
1313
+	.enqueue_event		= do_ulpq_tail_event,
1294
1314
 	.renege_events		= sctp_ulpq_renege,
1295
1315
 	.start_pd		= sctp_ulpq_partial_delivery,
1296
1316
 	.abort_pd		= sctp_ulpq_abort_pd,
..
..
@@ -1301,6 +1321,16 @@
1301
1321
 	.handle_ftsn		= sctp_handle_fwdtsn,
1302
1322
 };
1303
1323
 
1324
+static int do_sctp_enqueue_event(struct sctp_ulpq *ulpq,
1325
+				 struct sctp_ulpevent *event)
1326
+{
1327
+	struct sk_buff_head temp;
1328
+
1329
+	skb_queue_head_init(&temp);
1330
+	__skb_queue_tail(&temp, sctp_event2skb(event));
1331
+	return sctp_enqueue_event(ulpq, &temp);
1332
+}
1333
+
1304
1334
 static struct sctp_stream_interleave sctp_stream_interleave_1 = {
1305
1335
 	.data_chunk_len		= sizeof(struct sctp_idata_chunk),
1306
1336
 	.ftsn_chunk_len		= sizeof(struct sctp_ifwdtsn_chunk),
..
..
@@ -1309,7 +1339,7 @@
1309
1339
 	.assign_number		= sctp_chunk_assign_mid,
1310
1340
 	.validate_data		= sctp_validate_idata,
1311
1341
 	.ulpevent_data		= sctp_ulpevent_idata,
1312
-	.enqueue_event		= sctp_enqueue_event,
1342
+	.enqueue_event		= do_sctp_enqueue_event,
1313
1343
 	.renege_events		= sctp_renege_events,
1314
1344
 	.start_pd		= sctp_intl_start_pd,
1315
1345
 	.abort_pd		= sctp_intl_abort_pd,
..
..
@@ -1325,6 +1355,6 @@
1325
1355
 	struct sctp_association *asoc;
1326
1356
 
1327
1357
 	asoc = container_of(stream, struct sctp_association, stream);
1328
-	stream->si = asoc->intl_enable ? &sctp_stream_interleave_1
1329
-				       : &sctp_stream_interleave_0;
1358
+	stream->si = asoc->peer.intl_capable ? &sctp_stream_interleave_1
1359
+					     : &sctp_stream_interleave_0;
1330
1360
 }