History

Merge branch 'mptcp-fixes-for-5-19'

Mat Martineau says: ==================== mptcp: Fixes for 5.19 Several categories of fixes from the mptcp tree: Patches 1-3 are fixes related to MP_FAIL and FASTCLOSE, to make sure MIBs are accurate, and to handle MP_FAIL transmission and responses at the correct times. sk_timer conflicts are also resolved. Patches 4 and 6 handle two separate race conditions, one at socket shutdown and one with unaccepted subflows. Patch 5 makes sure read operations are not blocked during fallback to TCP. Patch 7 improves the diag selftest, which were incorrectly failing on slow machines (like the VMs used for CI testing). Patch 8 avoids possible symbol redefinition errors in the userspace mptcp.h file. Patch 9 fixes a selftest build issue with gcc 12. ====================

Jakub Kicinski committed 4 years ago

Commit bce3bb32 parents ab84db2 fd37c2e10 files · +227 −88Browse files

Unified · Split

10 files
  1. include/uapi/linux/mptcp.h +5 −4
  2. net/mptcp/options.c +4 −3
  3. net/mptcp/pm.c +4 −6
  4. net/mptcp/protocol.c +53 −31
  5. net/mptcp/protocol.h +20 −4
  6. net/mptcp/subflow.c +98 −29
  7. tools/testing/selftests/net/mptcp/diag.sh +40 −8
  8. tools/testing/selftests/net/mptcp/mptcp_connect.c +1 −1
  9. tools/testing/selftests/net/mptcp/mptcp_inq.c +1 −1
  10. tools/testing/selftests/net/mptcp/mptcp_sockopt.c +1 −1
include/uapi/linux/mptcp.h+5−4
@@ -2,16 +2,17 @@ · 1 unmodified line
22 #ifndef _UAPI_MPTCP_H
33 #define _UAPI_MPTCP_H
44
5+#ifndef __KERNEL__
6+#include <netinet/in.h> /* for sockaddr_in and sockaddr_in6 */
7+#include <sys/socket.h> /* for struct sockaddr */
8+#endif
9+
510 #include <linux/const.h>
611 #include <linux/types.h>
712 #include <linux/in.h> /* for sockaddr_in */
813 #include <linux/in6.h> /* for sockaddr_in6 */
914 #include <linux/socket.h> /* for sockaddr_storage and sa_family */
1015
11−#ifndef __KERNEL__
12−#include <sys/socket.h> /* for struct sockaddr */
13−#endif
14−
1516 #define MPTCP_SUBFLOW_FLAG_MCAP_REM _BITUL(0)
1617 #define MPTCP_SUBFLOW_FLAG_MCAP_LOC _BITUL(1)
1718 #define MPTCP_SUBFLOW_FLAG_JOIN_REM _BITUL(2)
net/mptcp/options.c+4−3
@@ -765,6 +765,7 @@ static noinline bool mptcp_established_options_rst(struct sock *sk, struct sk_bu · 764 unmodified lines
765765 opts->suboptions |= OPTION_MPTCP_RST;
766766 opts->reset_transient = subflow->reset_transient;
767767 opts->reset_reason = subflow->reset_reason;
768+ MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPRSTTX);
768769
769770 return true;
770771 }
@@ -788,6 +789,7 @@ static bool mptcp_established_options_fastclose(struct sock *sk, · 17 unmodified lines
788789 opts->rcvr_key = msk->remote_key;
789790
790791 pr_debug("FASTCLOSE key=%llu", opts->rcvr_key);
792+ MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFASTCLOSETX);
791793 return true;
792794 }
793795
@@ -809,6 +811,7 @@ static bool mptcp_established_options_mp_fail(struct sock *sk, · 15 unmodified lines
809811 opts->fail_seq = subflow->map_seq;
810812
811813 pr_debug("MP_FAIL fail_seq=%llu", opts->fail_seq);
814+ MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFAILTX);
812815
813816 return true;
814817 }
@@ -833,13 +836,11 @@ bool mptcp_established_options(struct sock *sk, struct sk_buff *skb, · 18 unmodified lines
833836 mptcp_established_options_mp_fail(sk, &opt_size, remaining, opts)) {
834837 *size += opt_size;
835838 remaining -= opt_size;
836− MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFASTCLOSETX);
837839 }
838840 /* MP_RST can be used with MP_FASTCLOSE and MP_FAIL if there is room */
839841 if (mptcp_established_options_rst(sk, skb, &opt_size, remaining, opts)) {
840842 *size += opt_size;
841843 remaining -= opt_size;
842− MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPRSTTX);
843844 }
844845 return true;
845846 }
@@ -966,7 +967,7 @@ static bool check_fully_established(struct mptcp_sock *msk, struct sock *ssk, · 120 unmodified lines
966967 goto reset;
967968 subflow->mp_capable = 0;
968969 pr_fallback(msk);
969− __mptcp_do_fallback(msk);
970+ mptcp_do_fallback(ssk);
970971 return false;
971972 }
972973
net/mptcp/pm.c+4−6
@@ -299,23 +299,21 @@ void mptcp_pm_mp_fail_received(struct sock *sk, u64 fail_seq) · 298 unmodified lines
299299 {
300300 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
301301 struct mptcp_sock *msk = mptcp_sk(subflow->conn);
302− struct sock *s = (struct sock *)msk;
303302
304303 pr_debug("fail_seq=%llu", fail_seq);
305304
306305 if (!READ_ONCE(msk->allow_infinite_fallback))
307306 return;
308307
309− if (!READ_ONCE(subflow->mp_fail_response_expect)) {
308+ if (!subflow->fail_tout) {
310309 pr_debug("send MP_FAIL response and infinite map");
311310
312311 subflow->send_mp_fail = 1;
313− MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFAILTX);
314312 subflow->send_infinite_map = 1;
315− } else if (!sock_flag(sk, SOCK_DEAD)) {
313+ tcp_send_ack(sk);
314+ } else {
316315 pr_debug("MP_FAIL response received");
317−
318− sk_stop_timer(s, &s->sk_timer);
316+ WRITE_ONCE(subflow->fail_tout, 0);
319317 }
320318 }
321319
net/mptcp/protocol.c+53−31
@@ -500,7 +500,7 @@ static void mptcp_set_timeout(struct sock *sk) · 499 unmodified lines
500500 __mptcp_set_timeout(sk, tout);
501501 }
502502
503−static bool tcp_can_send_ack(const struct sock *ssk)
503+static inline bool tcp_can_send_ack(const struct sock *ssk)
504504 {
505505 return !((1 << inet_sk_state_load(ssk)) &
506506 (TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_TIME_WAIT | TCPF_CLOSE | TCPF_LISTEN));
@@ -1245,7 +1245,7 @@ static void mptcp_update_infinite_map(struct mptcp_sock *msk, · 738 unmodified lines
12451245 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_INFINITEMAPTX);
12461246 mptcp_subflow_ctx(ssk)->send_infinite_map = 0;
12471247 pr_fallback(msk);
1248− __mptcp_do_fallback(msk);
1248+ mptcp_do_fallback(ssk);
12491249 }
12501250
12511251 static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk,
@@ -2175,21 +2175,6 @@ static void mptcp_retransmit_timer(struct timer_list *t) · 923 unmodified lines
21752175 sock_put(sk);
21762176 }
21772177
2178−static struct mptcp_subflow_context *
2179−mp_fail_response_expect_subflow(struct mptcp_sock *msk)
2180−{
2181− struct mptcp_subflow_context *subflow, *ret = NULL;
2182−
2183− mptcp_for_each_subflow(msk, subflow) {
2184− if (READ_ONCE(subflow->mp_fail_response_expect)) {
2185− ret = subflow;
2186− break;
2187− }
2188− }
2189−
2190− return ret;
2191−}
2192−
21932178 static void mptcp_timeout_timer(struct timer_list *t)
21942179 {
21952180 struct sock *sk = from_timer(sk, t, sk_timer);
@@ -2346,6 +2331,11 @@ static void __mptcp_close_ssk(struct sock *sk, struct sock *ssk, · 150 unmodified lines
23462331 kfree_rcu(subflow, rcu);
23472332 } else {
23482333 /* otherwise tcp will dispose of the ssk and subflow ctx */
2334+ if (ssk->sk_state == TCP_LISTEN) {
2335+ tcp_set_state(ssk, TCP_CLOSE);
2336+ mptcp_subflow_queue_clean(ssk);
2337+ inet_csk_listen_stop(ssk);
2338+ }
23492339 __tcp_close(ssk, 0);
23502340
23512341 /* close acquired an extra ref */
@@ -2518,27 +2508,50 @@ reset_timer: · 166 unmodified lines
25182508 mptcp_reset_timer(sk);
25192509 }
25202510
2511+/* schedule the timeout timer for the relevant event: either close timeout
2512+ * or mp_fail timeout. The close timeout takes precedence on the mp_fail one
2513+ */
2514+void mptcp_reset_timeout(struct mptcp_sock *msk, unsigned long fail_tout)
2515+{
2516+ struct sock *sk = (struct sock *)msk;
2517+ unsigned long timeout, close_timeout;
2518+
2519+ if (!fail_tout && !sock_flag(sk, SOCK_DEAD))
2520+ return;
2521+
2522+ close_timeout = inet_csk(sk)->icsk_mtup.probe_timestamp - tcp_jiffies32 + jiffies + TCP_TIMEWAIT_LEN;
2523+
2524+ /* the close timeout takes precedence on the fail one, and here at least one of
2525+ * them is active
2526+ */
2527+ timeout = sock_flag(sk, SOCK_DEAD) ? close_timeout : fail_tout;
2528+
2529+ sk_reset_timer(sk, &sk->sk_timer, timeout);
2530+}
2531+
25212532 static void mptcp_mp_fail_no_response(struct mptcp_sock *msk)
25222533 {
2523− struct mptcp_subflow_context *subflow;
2524− struct sock *ssk;
2534+ struct sock *ssk = msk->first;
25252535 bool slow;
25262536
2527− subflow = mp_fail_response_expect_subflow(msk);
2528− if (subflow) {
2529− pr_debug("MP_FAIL doesn't respond, reset the subflow");
2537+ if (!ssk)
2538+ return;
25302539
2531− ssk = mptcp_subflow_tcp_sock(subflow);
2532− slow = lock_sock_fast(ssk);
2533− mptcp_subflow_reset(ssk);
2534− unlock_sock_fast(ssk, slow);
2535− }
2540+ pr_debug("MP_FAIL doesn't respond, reset the subflow");
2541+
2542+ slow = lock_sock_fast(ssk);
2543+ mptcp_subflow_reset(ssk);
2544+ WRITE_ONCE(mptcp_subflow_ctx(ssk)->fail_tout, 0);
2545+ unlock_sock_fast(ssk, slow);
2546+
2547+ mptcp_reset_timeout(msk, 0);
25362548 }
25372549
25382550 static void mptcp_worker(struct work_struct *work)
25392551 {
25402552 struct mptcp_sock *msk = container_of(work, struct mptcp_sock, work);
25412553 struct sock *sk = &msk->sk.icsk_inet.sk;
2554+ unsigned long fail_tout;
25422555 int state;
25432556
25442557 lock_sock(sk);
@@ -2575,7 +2588,9 @@ static void mptcp_worker(struct work_struct *work) · 30 unmodified lines
25752588 if (test_and_clear_bit(MPTCP_WORK_RTX, &msk->flags))
25762589 __mptcp_retrans(sk);
25772590
2578− mptcp_mp_fail_no_response(msk);
2591+ fail_tout = msk->first ? READ_ONCE(mptcp_subflow_ctx(msk->first)->fail_tout) : 0;
2592+ if (fail_tout && time_after(jiffies, fail_tout))
2593+ mptcp_mp_fail_no_response(msk);
25792594
25802595 unlock:
25812596 release_sock(sk);
@@ -2822,6 +2837,7 @@ static void __mptcp_destroy_sock(struct sock *sk) · 240 unmodified lines
28222837 static void mptcp_close(struct sock *sk, long timeout)
28232838 {
28242839 struct mptcp_subflow_context *subflow;
2840+ struct mptcp_sock *msk = mptcp_sk(sk);
28252841 bool do_cancel_work = false;
28262842
28272843 lock_sock(sk);
@@ -2840,10 +2856,16 @@ static void mptcp_close(struct sock *sk, long timeout) · 12 unmodified lines
28402856 cleanup:
28412857 /* orphan all the subflows */
28422858 inet_csk(sk)->icsk_mtup.probe_timestamp = tcp_jiffies32;
2843− mptcp_for_each_subflow(mptcp_sk(sk), subflow) {
2859+ mptcp_for_each_subflow(msk, subflow) {
28442860 struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
28452861 bool slow = lock_sock_fast_nested(ssk);
28462862
2863+ /* since the close timeout takes precedence on the fail one,
2864+ * cancel the latter
2865+ */
2866+ if (ssk == msk->first)
2867+ subflow->fail_tout = 0;
2868+
28472869 sock_orphan(ssk);
28482870 unlock_sock_fast(ssk, slow);
28492871 }
@@ -2852,13 +2874,13 @@ cleanup: · 2 unmodified lines
28522874 sock_hold(sk);
28532875 pr_debug("msk=%p state=%d", sk, sk->sk_state);
28542876 if (mptcp_sk(sk)->token)
2855− mptcp_event(MPTCP_EVENT_CLOSED, mptcp_sk(sk), NULL, GFP_KERNEL);
2877+ mptcp_event(MPTCP_EVENT_CLOSED, msk, NULL, GFP_KERNEL);
28562878
28572879 if (sk->sk_state == TCP_CLOSE) {
28582880 __mptcp_destroy_sock(sk);
28592881 do_cancel_work = true;
28602882 } else {
2861− sk_reset_timer(sk, &sk->sk_timer, jiffies + TCP_TIMEWAIT_LEN);
2883+ mptcp_reset_timeout(msk, 0);
28622884 }
28632885 release_sock(sk);
28642886 if (do_cancel_work)
net/mptcp/protocol.h+20−4
@@ -306,6 +306,7 @@ struct mptcp_sock { · 305 unmodified lines
306306
307307 u32 setsockopt_seq;
308308 char ca_name[TCP_CA_NAME_MAX];
309+ struct mptcp_sock *dl_next;
309310 };
310311
311312 #define mptcp_data_lock(sk) spin_lock_bh(&(sk)->sk_lock.slock)
@@ -468,7 +469,6 @@ struct mptcp_subflow_context { · 156 unmodified lines
468469 local_id_valid : 1, /* local_id is correctly initialized */
469470 valid_csum_seen : 1; /* at least one csum validated */
470471 enum mptcp_data_avail data_avail;
471− bool mp_fail_response_expect;
472472 u32 remote_nonce;
473473 u64 thmac;
474474 u32 local_nonce;
@@ -482,6 +482,7 @@ struct mptcp_subflow_context { · 7 unmodified lines
482482 u8 stale_count;
483483
484484 long delegated_status;
485+ unsigned long fail_tout;
485486
486487 );
487488
@@ -608,6 +609,7 @@ void mptcp_close_ssk(struct sock *sk, struct sock *ssk, · 120 unmodified lines
608609 struct mptcp_subflow_context *subflow);
609610 void mptcp_subflow_send_ack(struct sock *ssk);
610611 void mptcp_subflow_reset(struct sock *ssk);
612+void mptcp_subflow_queue_clean(struct sock *ssk);
611613 void mptcp_sock_graft(struct sock *sk, struct socket *parent);
612614 struct socket *__mptcp_nmpc_socket(const struct mptcp_sock *msk);
613615
@@ -662,6 +664,7 @@ void mptcp_get_options(const struct sk_buff *skb, · 48 unmodified lines
662664
663665 void mptcp_finish_connect(struct sock *sk);
664666 void __mptcp_set_connected(struct sock *sk);
667+void mptcp_reset_timeout(struct mptcp_sock *msk, unsigned long fail_tout);
665668 static inline bool mptcp_is_fully_established(struct sock *sk)
666669 {
667670 return inet_sk_state_load(sk) == TCP_ESTABLISHED &&
@@ -926,12 +929,25 @@ static inline void __mptcp_do_fallback(struct mptcp_sock *msk) · 258 unmodified lines
926929 set_bit(MPTCP_FALLBACK_DONE, &msk->flags);
927930 }
928931
929−static inline void mptcp_do_fallback(struct sock *sk)
932+static inline void mptcp_do_fallback(struct sock *ssk)
930933 {
931− struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
932− struct mptcp_sock *msk = mptcp_sk(subflow->conn);
934+ struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
935+ struct sock *sk = subflow->conn;
936+ struct mptcp_sock *msk;
933937
938+ msk = mptcp_sk(sk);
934939 __mptcp_do_fallback(msk);
940+ if (READ_ONCE(msk->snd_data_fin_enable) && !(ssk->sk_shutdown & SEND_SHUTDOWN)) {
941+ gfp_t saved_allocation = ssk->sk_allocation;
942+
943+ /* we are in a atomic (BH) scope, override ssk default for data
944+ * fin allocation
945+ */
946+ ssk->sk_allocation = GFP_ATOMIC;
947+ ssk->sk_shutdown |= SEND_SHUTDOWN;
948+ tcp_shutdown(ssk, SEND_SHUTDOWN);
949+ ssk->sk_allocation = saved_allocation;
950+ }
935951 }
936952
937953 #define pr_fallback(a) pr_debug("%s:fallback to TCP (msk=%p)", __func__, a)
net/mptcp/subflow.c+98−29
@@ -843,7 +843,8 @@ enum mapping_status { · 842 unmodified lines
843843 MAPPING_INVALID,
844844 MAPPING_EMPTY,
845845 MAPPING_DATA_FIN,
846− MAPPING_DUMMY
846+ MAPPING_DUMMY,
847+ MAPPING_BAD_CSUM
847848 };
848849
849850 static void dbg_bad_map(struct mptcp_subflow_context *subflow, u32 ssn)
@@ -958,11 +959,7 @@ static enum mapping_status validate_data_csum(struct sock *ssk, struct sk_buff * · 108 unmodified lines
958959 subflow->map_data_csum);
959960 if (unlikely(csum)) {
960961 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_DATACSUMERR);
961− if (subflow->mp_join || subflow->valid_csum_seen) {
962− subflow->send_mp_fail = 1;
963− MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_MPFAILTX);
964− }
965− return subflow->mp_join ? MAPPING_INVALID : MAPPING_DUMMY;
962+ return MAPPING_BAD_CSUM;
966963 }
967964
968965 subflow->valid_csum_seen = 1;
@@ -974,7 +971,6 @@ static enum mapping_status get_mapping_status(struct sock *ssk, · 5 unmodified lines
974971 {
975972 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
976973 bool csum_reqd = READ_ONCE(msk->csum_enabled);
977− struct sock *sk = (struct sock *)msk;
978974 struct mptcp_ext *mpext;
979975 struct sk_buff *skb;
980976 u16 data_len;
@@ -1016,9 +1012,6 @@ static enum mapping_status get_mapping_status(struct sock *ssk, · 35 unmodified lines
10161012 pr_debug("infinite mapping received");
10171013 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_INFINITEMAPRX);
10181014 subflow->map_data_len = 0;
1019− if (!sock_flag(ssk, SOCK_DEAD))
1020− sk_stop_timer(sk, &sk->sk_timer);
1021−
10221015 return MAPPING_INVALID;
10231016 }
10241017
@@ -1165,6 +1158,33 @@ static bool subflow_can_fallback(struct mptcp_subflow_context *subflow) · 140 unmodified lines
11651158 return !subflow->fully_established;
11661159 }
11671160
1161+static void mptcp_subflow_fail(struct mptcp_sock *msk, struct sock *ssk)
1162+{
1163+ struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1164+ unsigned long fail_tout;
1165+
1166+ /* greceful failure can happen only on the MPC subflow */
1167+ if (WARN_ON_ONCE(ssk != READ_ONCE(msk->first)))
1168+ return;
1169+
1170+ /* since the close timeout take precedence on the fail one,
1171+ * no need to start the latter when the first is already set
1172+ */
1173+ if (sock_flag((struct sock *)msk, SOCK_DEAD))
1174+ return;
1175+
1176+ /* we don't need extreme accuracy here, use a zero fail_tout as special
1177+ * value meaning no fail timeout at all;
1178+ */
1179+ fail_tout = jiffies + TCP_RTO_MAX;
1180+ if (!fail_tout)
1181+ fail_tout = 1;
1182+ WRITE_ONCE(subflow->fail_tout, fail_tout);
1183+ tcp_send_ack(ssk);
1184+
1185+ mptcp_reset_timeout(msk, subflow->fail_tout);
1186+}
1187+
11681188 static bool subflow_check_data_avail(struct sock *ssk)
11691189 {
11701190 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
@@ -1184,10 +1204,8 @@ static bool subflow_check_data_avail(struct sock *ssk) · 13 unmodified lines
11841204
11851205 status = get_mapping_status(ssk, msk);
11861206 trace_subflow_check_data_avail(status, skb_peek(&ssk->sk_receive_queue));
1187− if (unlikely(status == MAPPING_INVALID))
1188− goto fallback;
1189−
1190− if (unlikely(status == MAPPING_DUMMY))
1207+ if (unlikely(status == MAPPING_INVALID || status == MAPPING_DUMMY ||
1208+ status == MAPPING_BAD_CSUM))
11911209 goto fallback;
11921210
11931211 if (status != MAPPING_OK)
@@ -1229,22 +1247,17 @@ no_data: · 35 unmodified lines
12291247 fallback:
12301248 if (!__mptcp_check_fallback(msk)) {
12311249 /* RFC 8684 section 3.7. */
1232− if (subflow->send_mp_fail) {
1250+ if (status == MAPPING_BAD_CSUM &&
1251+ (subflow->mp_join || subflow->valid_csum_seen)) {
1252+ subflow->send_mp_fail = 1;
1253+
12331254 if (!READ_ONCE(msk->allow_infinite_fallback)) {
1234− ssk->sk_err = EBADMSG;
1235− tcp_set_state(ssk, TCP_CLOSE);
12361255 subflow->reset_transient = 0;
12371256 subflow->reset_reason = MPTCP_RST_EMIDDLEBOX;
1238− tcp_send_active_reset(ssk, GFP_ATOMIC);
1239− while ((skb = skb_peek(&ssk->sk_receive_queue)))
1240− sk_eat_skb(ssk, skb);
1241− } else if (!sock_flag(ssk, SOCK_DEAD)) {
1242− WRITE_ONCE(subflow->mp_fail_response_expect, true);
1243− sk_reset_timer((struct sock *)msk,
1244− &((struct sock *)msk)->sk_timer,
1245− jiffies + TCP_RTO_MAX);
1257+ goto reset;
12461258 }
1247− WRITE_ONCE(subflow->data_avail, MPTCP_SUBFLOW_NODATA);
1259+ mptcp_subflow_fail(msk, ssk);
1260+ WRITE_ONCE(subflow->data_avail, MPTCP_SUBFLOW_DATA_AVAIL);
12481261 return true;
12491262 }
12501263
@@ -1252,16 +1265,20 @@ fallback: · 1 unmodified line
12521265 /* fatal protocol error, close the socket.
12531266 * subflow_error_report() will introduce the appropriate barriers
12541267 */
1255− ssk->sk_err = EBADMSG;
1256− tcp_set_state(ssk, TCP_CLOSE);
12571268 subflow->reset_transient = 0;
12581269 subflow->reset_reason = MPTCP_RST_EMPTCP;
1270+
1271+reset:
1272+ ssk->sk_err = EBADMSG;
1273+ tcp_set_state(ssk, TCP_CLOSE);
1274+ while ((skb = skb_peek(&ssk->sk_receive_queue)))
1275+ sk_eat_skb(ssk, skb);
12591276 tcp_send_active_reset(ssk, GFP_ATOMIC);
12601277 WRITE_ONCE(subflow->data_avail, MPTCP_SUBFLOW_NODATA);
12611278 return false;
12621279 }
12631280
1264− __mptcp_do_fallback(msk);
1281+ mptcp_do_fallback(ssk);
12651282 }
12661283
12671284 skb = skb_peek(&ssk->sk_receive_queue);
@@ -1706,6 +1723,58 @@ static void subflow_state_change(struct sock *sk) · 438 unmodified lines
17061723 }
17071724 }
17081725
1726+void mptcp_subflow_queue_clean(struct sock *listener_ssk)
1727+{
1728+ struct request_sock_queue *queue = &inet_csk(listener_ssk)->icsk_accept_queue;
1729+ struct mptcp_sock *msk, *next, *head = NULL;
1730+ struct request_sock *req;
1731+
1732+ /* build a list of all unaccepted mptcp sockets */
1733+ spin_lock_bh(&queue->rskq_lock);
1734+ for (req = queue->rskq_accept_head; req; req = req->dl_next) {
1735+ struct mptcp_subflow_context *subflow;
1736+ struct sock *ssk = req->sk;
1737+ struct mptcp_sock *msk;
1738+
1739+ if (!sk_is_mptcp(ssk))
1740+ continue;
1741+
1742+ subflow = mptcp_subflow_ctx(ssk);
1743+ if (!subflow || !subflow->conn)
1744+ continue;
1745+
1746+ /* skip if already in list */
1747+ msk = mptcp_sk(subflow->conn);
1748+ if (msk->dl_next || msk == head)
1749+ continue;
1750+
1751+ msk->dl_next = head;
1752+ head = msk;
1753+ }
1754+ spin_unlock_bh(&queue->rskq_lock);
1755+ if (!head)
1756+ return;
1757+
1758+ /* can't acquire the msk socket lock under the subflow one,
1759+ * or will cause ABBA deadlock
1760+ */
1761+ release_sock(listener_ssk);
1762+
1763+ for (msk = head; msk; msk = next) {
1764+ struct sock *sk = (struct sock *)msk;
1765+ bool slow;
1766+
1767+ slow = lock_sock_fast_nested(sk);
1768+ next = msk->dl_next;
1769+ msk->first = NULL;
1770+ msk->dl_next = NULL;
1771+ unlock_sock_fast(sk, slow);
1772+ }
1773+
1774+ /* we are still under the listener msk socket lock */
1775+ lock_sock_nested(listener_ssk, SINGLE_DEPTH_NESTING);
1776+}
1777+
17091778 static int subflow_ulp_init(struct sock *sk)
17101779 {
17111780 struct inet_connection_sock *icsk = inet_csk(sk);
tools/testing/selftests/net/mptcp/diag.sh+40−8
@@ -61,6 +61,39 @@ chk_msk_nr() · 60 unmodified lines
6161 __chk_nr "grep -c token:" $*
6262 }
6363
64+wait_msk_nr()
65+{
66+ local condition="grep -c token:"
67+ local expected=$1
68+ local timeout=20
69+ local msg nr
70+ local max=0
71+ local i=0
72+
73+ shift 1
74+ msg=$*
75+
76+ while [ $i -lt $timeout ]; do
77+ nr=$(ss -inmHMN $ns | $condition)
78+ [ $nr == $expected ] && break;
79+ [ $nr -gt $max ] && max=$nr
80+ i=$((i + 1))
81+ sleep 1
82+ done
83+
84+ printf "%-50s" "$msg"
85+ if [ $i -ge $timeout ]; then
86+ echo "[ fail ] timeout while expecting $expected max $max last $nr"
87+ ret=$test_cnt
88+ elif [ $nr != $expected ]; then
89+ echo "[ fail ] expected $expected found $nr"
90+ ret=$test_cnt
91+ else
92+ echo "[ ok ]"
93+ fi
94+ test_cnt=$((test_cnt+1))
95+}
96+
6497 chk_msk_fallback_nr()
6598 {
6699 __chk_nr "grep -c fallback" $*
@@ -146,7 +179,7 @@ ip -n $ns link set dev lo up · 79 unmodified lines
146179 echo "a" | \
147180 timeout ${timeout_test} \
148181 ip netns exec $ns \
149− ./mptcp_connect -p 10000 -l -t ${timeout_poll} \
182+ ./mptcp_connect -p 10000 -l -t ${timeout_poll} -w 20 \
150183 0.0.0.0 >/dev/null &
151184 wait_local_port_listen $ns 10000
152185 chk_msk_nr 0 "no msk on netns creation"
@@ -155,7 +188,7 @@ chk_msk_listen 10000 · 2 unmodified lines
155188 echo "b" | \
156189 timeout ${timeout_test} \
157190 ip netns exec $ns \
158− ./mptcp_connect -p 10000 -r 0 -t ${timeout_poll} \
191+ ./mptcp_connect -p 10000 -r 0 -t ${timeout_poll} -w 20 \
159192 127.0.0.1 >/dev/null &
160193 wait_connected $ns 10000
161194 chk_msk_nr 2 "after MPC handshake "
@@ -167,13 +200,13 @@ flush_pids · 5 unmodified lines
167200 echo "a" | \
168201 timeout ${timeout_test} \
169202 ip netns exec $ns \
170− ./mptcp_connect -p 10001 -l -s TCP -t ${timeout_poll} \
203+ ./mptcp_connect -p 10001 -l -s TCP -t ${timeout_poll} -w 20 \
171204 0.0.0.0 >/dev/null &
172205 wait_local_port_listen $ns 10001
173206 echo "b" | \
174207 timeout ${timeout_test} \
175208 ip netns exec $ns \
176− ./mptcp_connect -p 10001 -r 0 -t ${timeout_poll} \
209+ ./mptcp_connect -p 10001 -r 0 -t ${timeout_poll} -w 20 \
177210 127.0.0.1 >/dev/null &
178211 wait_connected $ns 10001
179212 chk_msk_fallback_nr 1 "check fallback"
@@ -184,7 +217,7 @@ for I in `seq 1 $NR_CLIENTS`; do · 4 unmodified lines
184217 echo "a" | \
185218 timeout ${timeout_test} \
186219 ip netns exec $ns \
187− ./mptcp_connect -p $((I+10001)) -l -w 10 \
220+ ./mptcp_connect -p $((I+10001)) -l -w 20 \
188221 -t ${timeout_poll} 0.0.0.0 >/dev/null &
189222 done
190223 wait_local_port_listen $ns $((NR_CLIENTS + 10001))
@@ -193,12 +226,11 @@ for I in `seq 1 $NR_CLIENTS`; do · 2 unmodified lines
193226 echo "b" | \
194227 timeout ${timeout_test} \
195228 ip netns exec $ns \
196− ./mptcp_connect -p $((I+10001)) -w 10 \
229+ ./mptcp_connect -p $((I+10001)) -w 20 \
197230 -t ${timeout_poll} 127.0.0.1 >/dev/null &
198231 done
199−sleep 1.5
200232
201−chk_msk_nr $((NR_CLIENTS*2)) "many msk socket present"
233+wait_msk_nr $((NR_CLIENTS*2)) "many msk socket present"
202234 flush_pids
203235
204236 exit $ret
tools/testing/selftests/net/mptcp/mptcp_connect.c+1−1
@@ -265,7 +265,7 @@ static void sock_test_tcpulp(int sock, int proto, unsigned int line) · 264 unmodified lines
265265 static int sock_listen_mptcp(const char * const listenaddr,
266266 const char * const port)
267267 {
268− int sock;
268+ int sock = -1;
269269 struct addrinfo hints = {
270270 .ai_protocol = IPPROTO_TCP,
271271 .ai_socktype = SOCK_STREAM,
tools/testing/selftests/net/mptcp/mptcp_inq.c+1−1
@@ -88,7 +88,7 @@ static void xgetaddrinfo(const char *node, const char *service, · 87 unmodified lines
8888 static int sock_listen_mptcp(const char * const listenaddr,
8989 const char * const port)
9090 {
91− int sock;
91+ int sock = -1;
9292 struct addrinfo hints = {
9393 .ai_protocol = IPPROTO_TCP,
9494 .ai_socktype = SOCK_STREAM,
tools/testing/selftests/net/mptcp/mptcp_sockopt.c+1−1
@@ -136,7 +136,7 @@ static void xgetaddrinfo(const char *node, const char *service, · 135 unmodified lines
136136 static int sock_listen_mptcp(const char * const listenaddr,
137137 const char * const port)
138138 {
139− int sock;
139+ int sock = -1;
140140 struct addrinfo hints = {
141141 .ai_protocol = IPPROTO_TCP,
142142 .ai_socktype = SOCK_STREAM,