Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /* Multipath TCP
3 : : *
4 : : * Copyright (c) 2019, Intel Corporation.
5 : : */
6 : : #define pr_fmt(fmt) "MPTCP: " fmt
7 : :
8 : : #include <linux/rculist.h>
9 : : #include <linux/spinlock.h>
10 : : #include "protocol.h"
11 : : #include "mib.h"
12 : :
13 : : #define ADD_ADDR_RETRANS_MAX 3
14 : :
15 : : struct mptcp_pm_add_entry {
16 : : struct list_head list;
17 : : struct mptcp_addr_info addr;
18 : : u8 retrans_times;
19 : : struct timer_list add_timer;
20 : : struct mptcp_sock *sock;
21 : : struct rcu_head rcu;
22 : : };
23 : :
24 : : static DEFINE_SPINLOCK(mptcp_pm_list_lock);
25 : : static LIST_HEAD(mptcp_pm_list);
26 : :
27 : : /* path manager helpers */
28 : :
29 : : /* if sk is ipv4 or ipv6_only allows only same-family local and remote addresses,
30 : : * otherwise allow any matching local/remote pair
31 : : */
32 : 676 : bool mptcp_pm_addr_families_match(const struct sock *sk,
33 : : const struct mptcp_addr_info *loc,
34 : : const struct mptcp_addr_info *rem)
35 : : {
36 : 676 : bool mptcp_is_v4 = sk->sk_family == AF_INET;
37 : :
38 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
39 [ + + + + ]: 676 : bool loc_is_v4 = loc->family == AF_INET || ipv6_addr_v4mapped(&loc->addr6);
40 [ + + + + ]: 676 : bool rem_is_v4 = rem->family == AF_INET || ipv6_addr_v4mapped(&rem->addr6);
41 : :
42 [ + + ]: 676 : if (mptcp_is_v4)
43 : 540 : return loc_is_v4 && rem_is_v4;
44 : :
45 [ - + ]: 136 : if (ipv6_only_sock(sk))
46 : 0 : return !loc_is_v4 && !rem_is_v4;
47 : :
48 : 136 : return loc_is_v4 == rem_is_v4;
49 : : #else
50 : : return mptcp_is_v4 && loc->family == AF_INET && rem->family == AF_INET;
51 : : #endif
52 : : }
53 : :
54 : 8810 : bool mptcp_addresses_equal(const struct mptcp_addr_info *a,
55 : : const struct mptcp_addr_info *b, bool use_port)
56 : : {
57 : 8810 : bool addr_equals = false;
58 : :
59 [ + + ]: 8810 : if (a->family == b->family) {
60 [ + + ]: 7345 : if (a->family == AF_INET)
61 : 6283 : addr_equals = a->addr.s_addr == b->addr.s_addr;
62 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
63 : : else
64 : 1062 : addr_equals = ipv6_addr_equal(&a->addr6, &b->addr6);
65 [ + + ]: 1465 : } else if (a->family == AF_INET) {
66 [ + + ]: 1040 : if (ipv6_addr_v4mapped(&b->addr6))
67 : 724 : addr_equals = a->addr.s_addr == b->addr6.s6_addr32[3];
68 [ + - ]: 425 : } else if (b->family == AF_INET) {
69 [ + + ]: 425 : if (ipv6_addr_v4mapped(&a->addr6))
70 : 197 : addr_equals = a->addr6.s6_addr32[3] == b->addr.s_addr;
71 : : #endif
72 : : }
73 : :
74 [ + + ]: 8266 : if (!addr_equals)
75 : : return false;
76 [ + + ]: 1932 : if (!use_port)
77 : : return true;
78 : :
79 : 664 : return a->port == b->port;
80 : : }
81 : :
82 : 3519 : void mptcp_local_address(const struct sock_common *skc,
83 : : struct mptcp_addr_info *addr)
84 : : {
85 : 3519 : addr->family = skc->skc_family;
86 : 3519 : addr->port = htons(skc->skc_num);
87 [ + + ]: 3519 : if (addr->family == AF_INET)
88 : 1600 : addr->addr.s_addr = skc->skc_rcv_saddr;
89 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
90 [ + - ]: 1919 : else if (addr->family == AF_INET6)
91 : 1919 : addr->addr6 = skc->skc_v6_rcv_saddr;
92 : : #endif
93 : 3519 : }
94 : :
95 : 795 : void mptcp_remote_address(const struct sock_common *skc,
96 : : struct mptcp_addr_info *addr)
97 : : {
98 : 0 : addr->family = skc->skc_family;
99 : 0 : addr->port = skc->skc_dport;
100 [ + + ]: 885 : if (addr->family == AF_INET)
101 : 0 : addr->addr.s_addr = skc->skc_daddr;
102 : : #if IS_ENABLED(CONFIG_MPTCP_IPV6)
103 [ - - - - : 210 : else if (addr->family == AF_INET6)
+ - ]
104 : 0 : addr->addr6 = skc->skc_v6_daddr;
105 : : #endif
106 : 885 : }
107 : :
108 : 4 : static bool mptcp_pm_is_init_remote_addr(struct mptcp_sock *msk,
109 : : const struct mptcp_addr_info *remote)
110 : : {
111 : 4 : struct mptcp_addr_info mpc_remote;
112 : :
113 [ + - ]: 4 : mptcp_remote_address((struct sock_common *)msk, &mpc_remote);
114 : 4 : return mptcp_addresses_equal(&mpc_remote, remote, remote->port);
115 : : }
116 : :
117 : 104 : bool mptcp_lookup_subflow_by_saddr(const struct list_head *list,
118 : : const struct mptcp_addr_info *saddr)
119 : : {
120 : 104 : struct mptcp_subflow_context *subflow;
121 : 104 : struct mptcp_addr_info cur;
122 : 104 : struct sock_common *skc;
123 : :
124 [ + + ]: 226 : list_for_each_entry(subflow, list, node) {
125 : 200 : skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow);
126 : :
127 : 200 : mptcp_local_address(skc, &cur);
128 [ + + ]: 200 : if (mptcp_addresses_equal(&cur, saddr, saddr->port))
129 : : return true;
130 : : }
131 : :
132 : : return false;
133 : : }
134 : :
135 : : static struct mptcp_pm_add_entry *
136 : 991 : mptcp_lookup_anno_list_by_saddr(const struct mptcp_sock *msk,
137 : : const struct mptcp_addr_info *addr)
138 : : {
139 : 991 : struct mptcp_pm_add_entry *entry;
140 : :
141 [ + - - + ]: 991 : lockdep_assert_held(&msk->pm.lock);
142 : :
143 [ + + ]: 1299 : list_for_each_entry(entry, &msk->pm.anno_list, list) {
144 [ + + ]: 864 : if (mptcp_addresses_equal(&entry->addr, addr, true))
145 : : return entry;
146 : : }
147 : :
148 : : return NULL;
149 : : }
150 : :
151 : 132 : bool mptcp_remove_anno_list_by_saddr(struct mptcp_sock *msk,
152 : : const struct mptcp_addr_info *addr)
153 : : {
154 : 132 : struct mptcp_pm_add_entry *entry;
155 : 132 : bool ret;
156 : :
157 : 132 : entry = mptcp_pm_del_add_timer(msk, addr, false);
158 : 132 : ret = entry;
159 [ + + ]: 132 : kfree_rcu(entry, rcu);
160 : :
161 : 132 : return ret;
162 : : }
163 : :
164 : 48 : bool mptcp_pm_sport_in_anno_list(struct mptcp_sock *msk, const struct sock *sk)
165 : : {
166 : 48 : struct mptcp_pm_add_entry *entry;
167 : 48 : struct mptcp_addr_info saddr;
168 : 48 : bool ret = false;
169 : :
170 : 48 : mptcp_local_address((struct sock_common *)sk, &saddr);
171 : :
172 : 48 : spin_lock_bh(&msk->pm.lock);
173 [ + - ]: 48 : list_for_each_entry(entry, &msk->pm.anno_list, list) {
174 [ + - ]: 48 : if (mptcp_addresses_equal(&entry->addr, &saddr, true)) {
175 : 48 : ret = true;
176 : 48 : goto out;
177 : : }
178 : : }
179 : :
180 : 0 : out:
181 : 48 : spin_unlock_bh(&msk->pm.lock);
182 : 48 : return ret;
183 : : }
184 : :
185 : 966 : static void __mptcp_pm_send_ack(struct mptcp_sock *msk,
186 : : struct mptcp_subflow_context *subflow,
187 : : bool prio, bool backup)
188 : : {
189 [ - + ]: 966 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
190 : 966 : bool slow;
191 : :
192 [ - + - - : 966 : pr_debug("send ack for %s\n",
- - - - ]
193 : : prio ? "mp_prio" :
194 : : (mptcp_pm_should_add_signal(msk) ? "add_addr" : "rm_addr"));
195 : :
196 : 966 : slow = lock_sock_fast(ssk);
197 [ + + ]: 966 : if (prio) {
198 : 28 : subflow->send_mp_prio = 1;
199 : 28 : subflow->request_bkup = backup;
200 : : }
201 : :
202 : 966 : __mptcp_subflow_send_ack(ssk);
203 : 966 : unlock_sock_fast(ssk, slow);
204 : 966 : }
205 : :
206 : 944 : void mptcp_pm_send_ack(struct mptcp_sock *msk,
207 : : struct mptcp_subflow_context *subflow,
208 : : bool prio, bool backup)
209 : : {
210 : 944 : spin_unlock_bh(&msk->pm.lock);
211 : 944 : __mptcp_pm_send_ack(msk, subflow, prio, backup);
212 : 944 : spin_lock_bh(&msk->pm.lock);
213 : 944 : }
214 : :
215 : 0 : static bool subflow_in_rm_list(const struct mptcp_subflow_context *subflow,
216 : : const struct mptcp_rm_list *rm_list)
217 : : {
218 : 118 : u8 i, id = subflow_get_local_id(subflow);
219 : :
220 [ + + ]: 234 : for (i = 0; i < rm_list->nr; i++) {
221 [ + + ]: 126 : if (rm_list->ids[i] == id)
222 : : return true;
223 : : }
224 : :
225 : : return false;
226 : : }
227 : :
228 : : static void
229 : 939 : mptcp_pm_addr_send_ack_avoid_list(struct mptcp_sock *msk,
230 : : const struct mptcp_rm_list *rm_list)
231 : : {
232 : 939 : struct mptcp_subflow_context *subflow, *stale = NULL, *same_id = NULL;
233 : :
234 : 939 : msk_owned_by_me(msk);
235 [ + - - + ]: 939 : lockdep_assert_held(&msk->pm.lock);
236 : :
237 [ + + + + ]: 939 : if (!mptcp_pm_should_add_signal(msk) &&
[ - + ]
238 [ # # ]: 0 : !mptcp_pm_should_rm_signal(msk))
239 : : return;
240 : :
241 [ + - ]: 962 : mptcp_for_each_subflow(msk, subflow) {
242 [ + + ]: 962 : if (!__mptcp_subflow_active(subflow))
243 : 14 : continue;
244 : :
245 [ - + ]: 948 : if (unlikely(subflow->stale)) {
246 [ # # ]: 0 : if (!stale)
247 : 0 : stale = subflow;
248 [ + + + + ]: 1066 : } else if (unlikely(rm_list &&
249 : : subflow_in_rm_list(subflow, rm_list))) {
250 [ - + ]: 10 : if (!same_id)
251 : 0 : same_id = subflow;
252 : : } else {
253 : 938 : goto send_ack;
254 : : }
255 : : }
256 : :
257 [ # # ]: 0 : if (same_id)
258 : : subflow = same_id;
259 [ # # ]: 0 : else if (stale)
260 : : subflow = stale;
261 : : else
262 : : return;
263 : :
264 : 938 : send_ack:
265 : 938 : mptcp_pm_send_ack(msk, subflow, false, false);
266 : : }
267 : :
268 : 696 : void mptcp_pm_addr_send_ack(struct mptcp_sock *msk)
269 : : {
270 : 696 : mptcp_pm_addr_send_ack_avoid_list(msk, NULL);
271 : 129 : }
272 : :
273 : 26 : int mptcp_pm_mp_prio_send_ack(struct mptcp_sock *msk,
274 : : struct mptcp_addr_info *addr,
275 : : struct mptcp_addr_info *rem,
276 : : u8 bkup)
277 : : {
278 : 26 : struct mptcp_subflow_context *subflow;
279 : :
280 [ - + - - ]: 26 : pr_debug("bkup=%d\n", bkup);
281 : :
282 [ + + ]: 46 : mptcp_for_each_subflow(msk, subflow) {
283 : 42 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
284 : 42 : struct mptcp_addr_info local, remote;
285 : :
286 : 42 : mptcp_local_address((struct sock_common *)ssk, &local);
287 [ + + ]: 42 : if (!mptcp_addresses_equal(&local, addr, addr->port))
288 : 20 : continue;
289 : :
290 [ + + + - ]: 22 : if (rem && rem->family != AF_UNSPEC) {
291 [ + - ]: 2 : mptcp_remote_address((struct sock_common *)ssk, &remote);
292 [ - + ]: 2 : if (!mptcp_addresses_equal(&remote, rem, rem->port))
293 : 0 : continue;
294 : : }
295 : :
296 : 22 : __mptcp_pm_send_ack(msk, subflow, true, bkup);
297 : 22 : return 0;
298 : : }
299 : :
300 : : return -EINVAL;
301 : : }
302 : :
303 : 439 : static unsigned int mptcp_adjust_add_addr_timeout(struct mptcp_sock *msk)
304 : : {
305 : 439 : const struct net *net = sock_net((struct sock *)msk);
306 : 439 : unsigned int rto = mptcp_get_add_addr_timeout(net);
307 : 439 : struct mptcp_subflow_context *subflow;
308 : 439 : unsigned int max = 0;
309 : :
310 [ + + ]: 1146 : mptcp_for_each_subflow(msk, subflow) {
311 : 707 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
312 : 707 : struct inet_connection_sock *icsk = inet_csk(ssk);
313 : :
314 : 707 : if (icsk->icsk_rto > max)
315 : : max = icsk->icsk_rto;
316 : : }
317 : :
318 [ + + ]: 439 : if (max && max < rto)
319 : 426 : rto = max;
320 : :
321 : 439 : return rto;
322 : : }
323 : :
324 : 67 : static void mptcp_pm_add_timer(struct timer_list *timer)
325 : : {
326 : 67 : struct mptcp_pm_add_entry *entry = timer_container_of(entry, timer,
327 : : add_timer);
328 : 67 : struct mptcp_sock *msk = entry->sock;
329 : 67 : struct sock *sk = (struct sock *)msk;
330 : 67 : unsigned int timeout;
331 : :
332 [ - + - - ]: 67 : pr_debug("msk=%p\n", msk);
333 : :
334 [ + - ]: 67 : if (!msk)
335 : : return;
336 : :
337 [ + - ]: 67 : if (inet_sk_state_load(sk) == TCP_CLOSE)
338 : : return;
339 : :
340 [ + - ]: 67 : if (!entry->addr.id)
341 : : return;
342 : :
343 [ + + ]: 67 : if (mptcp_pm_should_add_signal_addr(msk)) {
344 : 2 : sk_reset_timer(sk, timer, jiffies + TCP_RTO_MAX / 8);
345 : 2 : goto out;
346 : : }
347 : :
348 : 65 : timeout = mptcp_adjust_add_addr_timeout(msk);
349 [ - + ]: 65 : if (!timeout)
350 : 0 : goto out;
351 : :
352 : 65 : spin_lock_bh(&msk->pm.lock);
353 : :
354 [ + - ]: 65 : if (!mptcp_pm_should_add_signal_addr(msk)) {
355 [ - + - - ]: 65 : pr_debug("retransmit ADD_ADDR id=%d\n", entry->addr.id);
356 : 65 : mptcp_pm_announce_addr(msk, &entry->addr, false);
357 : 65 : mptcp_pm_add_addr_send_ack(msk);
358 : 65 : entry->retrans_times++;
359 : : }
360 : :
361 [ + + ]: 65 : if (entry->retrans_times < ADD_ADDR_RETRANS_MAX)
362 : 53 : sk_reset_timer(sk, timer,
363 : 53 : jiffies + (timeout << entry->retrans_times));
364 : :
365 : 65 : spin_unlock_bh(&msk->pm.lock);
366 : :
367 [ + + ]: 65 : if (entry->retrans_times == ADD_ADDR_RETRANS_MAX)
368 : 12 : mptcp_pm_subflow_established(msk);
369 : :
370 : 53 : out:
371 : 67 : __sock_put(sk);
372 : : }
373 : :
374 : : struct mptcp_pm_add_entry *
375 : 504 : mptcp_pm_del_add_timer(struct mptcp_sock *msk,
376 : : const struct mptcp_addr_info *addr, bool check_id)
377 : : {
378 : 504 : struct mptcp_pm_add_entry *entry;
379 : 504 : struct sock *sk = (struct sock *)msk;
380 : 504 : bool stop_timer = false;
381 : :
382 : 504 : rcu_read_lock();
383 : :
384 : 504 : spin_lock_bh(&msk->pm.lock);
385 : 504 : entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
386 [ + + + + : 504 : if (entry && (!check_id || entry->addr.id == addr->id)) {
+ + ]
387 : 436 : entry->retrans_times = ADD_ADDR_RETRANS_MAX;
388 : 436 : stop_timer = true;
389 : : }
390 [ + + ]: 504 : if (!check_id && entry)
391 : 80 : list_del(&entry->list);
392 : 504 : spin_unlock_bh(&msk->pm.lock);
393 : :
394 : : /* Note: entry might have been removed by another thread.
395 : : * We hold rcu_read_lock() to ensure it is not freed under us.
396 : : */
397 [ + + ]: 504 : if (stop_timer)
398 : 436 : sk_stop_timer_sync(sk, &entry->add_timer);
399 : :
400 : 504 : rcu_read_unlock();
401 : 504 : return entry;
402 : : }
403 : :
404 : 374 : bool mptcp_pm_alloc_anno_list(struct mptcp_sock *msk,
405 : : const struct mptcp_addr_info *addr)
406 : : {
407 : 374 : struct mptcp_pm_add_entry *add_entry = NULL;
408 : 374 : struct sock *sk = (struct sock *)msk;
409 : 374 : unsigned int timeout;
410 : :
411 [ + - - + ]: 374 : lockdep_assert_held(&msk->pm.lock);
412 : :
413 : 374 : add_entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
414 : :
415 [ - + ]: 374 : if (add_entry) {
416 [ # # ]: 0 : if (WARN_ON_ONCE(mptcp_pm_is_kernel(msk)))
417 : 0 : return false;
418 : :
419 : 0 : goto reset_timer;
420 : : }
421 : :
422 : 374 : add_entry = kmalloc(sizeof(*add_entry), GFP_ATOMIC);
423 [ - + ]: 374 : if (!add_entry)
424 : : return false;
425 : :
426 : 374 : list_add(&add_entry->list, &msk->pm.anno_list);
427 : :
428 : 374 : add_entry->addr = *addr;
429 : 374 : add_entry->sock = msk;
430 : 374 : add_entry->retrans_times = 0;
431 : :
432 : 374 : timer_setup(&add_entry->add_timer, mptcp_pm_add_timer, 0);
433 : 374 : reset_timer:
434 : 374 : timeout = mptcp_adjust_add_addr_timeout(msk);
435 [ + + ]: 374 : if (timeout)
436 : 362 : sk_reset_timer(sk, &add_entry->add_timer, jiffies + timeout);
437 : :
438 : : return true;
439 : : }
440 : :
441 : 5007 : static void mptcp_pm_free_anno_list(struct mptcp_sock *msk)
442 : : {
443 : 5007 : struct mptcp_pm_add_entry *entry, *tmp;
444 : 5007 : struct sock *sk = (struct sock *)msk;
445 : 5007 : LIST_HEAD(free_list);
446 : :
447 [ - + - - ]: 5007 : pr_debug("msk=%p\n", msk);
448 : :
449 : 5007 : spin_lock_bh(&msk->pm.lock);
450 [ + + ]: 5007 : list_splice_init(&msk->pm.anno_list, &free_list);
451 : 5007 : spin_unlock_bh(&msk->pm.lock);
452 : :
453 [ + + ]: 5301 : list_for_each_entry_safe(entry, tmp, &free_list, list) {
454 : 294 : sk_stop_timer_sync(sk, &entry->add_timer);
455 [ + - ]: 294 : kfree_rcu(entry, rcu);
456 : : }
457 : 5007 : }
458 : :
459 : : /* path manager command handlers */
460 : :
461 : 831 : int mptcp_pm_announce_addr(struct mptcp_sock *msk,
462 : : const struct mptcp_addr_info *addr,
463 : : bool echo)
464 : : {
465 : 831 : u8 add_addr = READ_ONCE(msk->pm.addr_signal);
466 : :
467 [ - + - - ]: 831 : pr_debug("msk=%p, local_id=%d, echo=%d\n", msk, addr->id, echo);
468 : :
469 [ + - - + ]: 831 : lockdep_assert_held(&msk->pm.lock);
470 : :
471 [ - + ]: 831 : if (add_addr &
472 [ + + ]: 831 : (echo ? BIT(MPTCP_ADD_ADDR_ECHO) : BIT(MPTCP_ADD_ADDR_SIGNAL))) {
473 [ # # ]: 0 : MPTCP_INC_STATS(sock_net((struct sock *)msk),
[ # # # # ]
474 : : echo ? MPTCP_MIB_ECHOADDTXDROP : MPTCP_MIB_ADDADDRTXDROP);
475 : 0 : return -EINVAL;
476 : : }
477 : :
478 [ + + ]: 831 : if (echo) {
479 : 392 : msk->pm.remote = *addr;
480 : 392 : add_addr |= BIT(MPTCP_ADD_ADDR_ECHO);
481 : : } else {
482 : 439 : msk->pm.local = *addr;
483 : 439 : add_addr |= BIT(MPTCP_ADD_ADDR_SIGNAL);
484 : : }
485 : 831 : WRITE_ONCE(msk->pm.addr_signal, add_addr);
486 : 831 : return 0;
487 : : }
488 : :
489 : 108 : int mptcp_pm_remove_addr(struct mptcp_sock *msk, const struct mptcp_rm_list *rm_list)
490 : : {
491 : 108 : u8 rm_addr = READ_ONCE(msk->pm.addr_signal);
492 : :
493 [ - + - - ]: 108 : pr_debug("msk=%p, rm_list_nr=%d\n", msk, rm_list->nr);
494 : :
495 [ - + ]: 108 : if (rm_addr) {
496 : 0 : MPTCP_ADD_STATS(sock_net((struct sock *)msk),
497 : 0 : MPTCP_MIB_RMADDRTXDROP, rm_list->nr);
498 : 0 : return -EINVAL;
499 : : }
500 : :
501 : 108 : msk->pm.rm_list_tx = *rm_list;
502 : 108 : rm_addr |= BIT(MPTCP_RM_ADDR_SIGNAL);
503 : 108 : WRITE_ONCE(msk->pm.addr_signal, rm_addr);
504 : 108 : mptcp_pm_addr_send_ack_avoid_list(msk, rm_list);
505 : 108 : return 0;
506 : : }
507 : :
508 : : /* path manager event handlers */
509 : :
510 : 3068 : void mptcp_pm_new_connection(struct mptcp_sock *msk, const struct sock *ssk, int server_side)
511 : : {
512 : 3068 : struct mptcp_pm_data *pm = &msk->pm;
513 : :
514 [ - + - - ]: 3068 : pr_debug("msk=%p, token=%u side=%d\n", msk, READ_ONCE(msk->token), server_side);
515 : :
516 : 3068 : WRITE_ONCE(pm->server_side, server_side);
517 : 3068 : mptcp_event(MPTCP_EVENT_CREATED, msk, ssk, GFP_ATOMIC);
518 : 3068 : }
519 : :
520 : 520 : bool mptcp_pm_allow_new_subflow(struct mptcp_sock *msk)
521 : : {
522 : 520 : struct mptcp_pm_data *pm = &msk->pm;
523 : 520 : unsigned int limit_extra_subflows;
524 : 520 : int ret = 0;
525 : :
526 [ + + ]: 520 : if (mptcp_pm_is_userspace(msk)) {
527 [ + - ]: 22 : if (mptcp_userspace_pm_active(msk)) {
528 : 22 : spin_lock_bh(&pm->lock);
529 : 22 : pm->extra_subflows++;
530 : 22 : spin_unlock_bh(&pm->lock);
531 : 22 : return true;
532 : : }
533 : : return false;
534 : : }
535 : :
536 : 498 : limit_extra_subflows = mptcp_pm_get_limit_extra_subflows(msk);
537 : :
538 [ - + - - : 498 : pr_debug("msk=%p subflows=%d max=%d allow=%d\n", msk,
- - ]
[ - + - - ]
539 : : pm->extra_subflows, limit_extra_subflows,
540 : : READ_ONCE(pm->accept_subflow));
541 : :
542 : : /* try to avoid acquiring the lock below */
543 [ - + - + ]: 498 : if (!READ_ONCE(pm->accept_subflow))
[ - + ]
544 : : return false;
545 : :
546 : 498 : spin_lock_bh(&pm->lock);
547 [ - + + - ]: 498 : if (READ_ONCE(pm->accept_subflow)) {
[ + - ]
548 : 498 : ret = pm->extra_subflows < limit_extra_subflows;
549 [ - + + + ]: 498 : if (ret && ++pm->extra_subflows == limit_extra_subflows)
550 : 186 : WRITE_ONCE(pm->accept_subflow, false);
551 : : }
552 : 498 : spin_unlock_bh(&pm->lock);
553 : :
554 : 498 : return ret;
555 : : }
556 : :
557 : : /* return true if the new status bit is currently cleared, that is, this event
558 : : * can be server, eventually by an already scheduled work
559 : : */
560 : 1474 : static bool mptcp_pm_schedule_work(struct mptcp_sock *msk,
561 : : enum mptcp_pm_status new_status)
562 : : {
563 [ - + - - : 1474 : pr_debug("msk=%p status=%x new=%lx\n", msk, msk->pm.status,
- - ]
[ - + - - ]
564 : : BIT(new_status));
565 [ - + + + ]: 1474 : if (msk->pm.status & BIT(new_status))
[ + + ]
566 : : return false;
567 : :
568 [ - + ]: 1333 : msk->pm.status |= BIT(new_status);
569 : 1333 : mptcp_schedule_work((struct sock *)msk);
570 : 1333 : return true;
571 : : }
572 : :
573 : 2990 : void mptcp_pm_fully_established(struct mptcp_sock *msk, const struct sock *ssk)
574 : : {
575 : 2990 : struct mptcp_pm_data *pm = &msk->pm;
576 : 2990 : bool announce = false;
577 : :
578 [ - + - - ]: 2990 : pr_debug("msk=%p\n", msk);
579 : :
580 : 2990 : spin_lock_bh(&pm->lock);
581 : :
582 : : /* mptcp_pm_fully_established() can be invoked by multiple
583 : : * racing paths - accept() and check_fully_established()
584 : : * be sure to serve this event only once.
585 : : */
586 [ - + + + ]: 2990 : if (READ_ONCE(pm->work_pending) &&
[ + + ]
587 [ + - ]: 466 : !(pm->status & BIT(MPTCP_PM_ALREADY_ESTABLISHED)))
588 : 466 : mptcp_pm_schedule_work(msk, MPTCP_PM_ESTABLISHED);
589 : :
590 [ + - ]: 2990 : if ((pm->status & BIT(MPTCP_PM_ALREADY_ESTABLISHED)) == 0)
591 : 2990 : announce = true;
592 : :
593 : 2990 : pm->status |= BIT(MPTCP_PM_ALREADY_ESTABLISHED);
594 : 2990 : spin_unlock_bh(&pm->lock);
595 : :
596 [ + - ]: 2990 : if (announce)
597 : 2990 : mptcp_event(MPTCP_EVENT_ESTABLISHED, msk, ssk, GFP_ATOMIC);
598 : 2990 : }
599 : :
600 : 5020 : void mptcp_pm_connection_closed(struct mptcp_sock *msk)
601 : : {
602 [ - + - - ]: 5020 : pr_debug("msk=%p\n", msk);
603 : :
604 [ + + ]: 5020 : if (msk->token)
605 : 3119 : mptcp_event(MPTCP_EVENT_CLOSED, msk, NULL, GFP_KERNEL);
606 : 5020 : }
607 : :
608 : 1020 : void mptcp_pm_subflow_established(struct mptcp_sock *msk)
609 : : {
610 : 1020 : struct mptcp_pm_data *pm = &msk->pm;
611 : :
612 [ - + - - ]: 1020 : pr_debug("msk=%p\n", msk);
613 : :
614 [ - + + + ]: 1020 : if (!READ_ONCE(pm->work_pending))
[ + + ]
615 : : return;
616 : :
617 : 251 : spin_lock_bh(&pm->lock);
618 : :
619 [ - + + - ]: 251 : if (READ_ONCE(pm->work_pending))
[ + - ]
620 : 251 : mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
621 : :
622 : 251 : spin_unlock_bh(&pm->lock);
623 : : }
624 : :
625 : 1999 : void mptcp_pm_subflow_check_next(struct mptcp_sock *msk,
626 : : const struct mptcp_subflow_context *subflow)
627 : : {
628 : 1999 : struct sock *sk = (struct sock *)msk;
629 : 1999 : struct mptcp_pm_data *pm = &msk->pm;
630 : 1999 : bool update_subflows;
631 : :
632 [ + + + + ]: 1999 : update_subflows = subflow->request_join || subflow->mp_join;
633 [ + + ]: 1999 : if (mptcp_pm_is_userspace(msk)) {
634 [ + + ]: 63 : if (update_subflows) {
635 : 43 : spin_lock_bh(&pm->lock);
636 : 43 : pm->extra_subflows--;
637 : 43 : spin_unlock_bh(&pm->lock);
638 : : }
639 : 63 : return;
640 : : }
641 : :
642 [ - + + + : 1936 : if (!READ_ONCE(pm->work_pending) && !update_subflows)
+ + ]
[ + + + + ]
643 : : return;
644 : :
645 : 603 : spin_lock_bh(&pm->lock);
646 [ + + ]: 603 : if (update_subflows)
647 : 601 : __mptcp_pm_close_subflow(msk);
648 : :
649 : : /* Even if this subflow is not really established, tell the PM to try
650 : : * to pick the next ones, if possible.
651 : : */
652 [ + + + + ]: 841 : if (mptcp_is_fully_established(sk) &&
653 : 238 : mptcp_pm_nl_check_work_pending(msk))
654 : 75 : mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
655 : :
656 : 603 : spin_unlock_bh(&pm->lock);
657 : : }
658 : :
659 : 401 : void mptcp_pm_add_addr_received(const struct sock *ssk,
660 : : const struct mptcp_addr_info *addr)
661 : : {
662 [ - + ]: 401 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
663 [ - + ]: 401 : struct mptcp_sock *msk = mptcp_sk(subflow->conn);
664 : 401 : struct mptcp_pm_data *pm = &msk->pm;
665 : :
666 [ - + - - : 401 : pr_debug("msk=%p remote_id=%d accept=%d\n", msk, addr->id,
- - ]
[ - + - - ]
667 : : READ_ONCE(pm->accept_addr));
668 : :
669 : 401 : mptcp_event_addr_announced(ssk, addr);
670 : :
671 : 401 : spin_lock_bh(&pm->lock);
672 : :
673 [ + + ]: 401 : if (mptcp_pm_is_userspace(msk)) {
674 [ + + ]: 30 : if (mptcp_userspace_pm_active(msk)) {
675 : 28 : mptcp_pm_announce_addr(msk, addr, true);
676 : 28 : mptcp_pm_add_addr_send_ack(msk);
677 : : } else {
678 [ + - ]: 2 : __MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_ADDADDRDROP);
679 : : }
680 : : /* - id0 should not have a different address
681 : : * - special case for C-flag: linked to fill_local_addresses_vec()
682 : : */
683 [ + + + - : 371 : } else if ((addr->id == 0 && !mptcp_pm_is_init_remote_addr(msk, addr)) ||
+ + ]
684 [ - + + + : 405 : (addr->id > 0 && !READ_ONCE(pm->accept_addr) &&
+ + ]
[ + + + + ]
685 : 38 : !mptcp_pm_add_addr_c_flag_case(msk))) {
686 : 36 : mptcp_pm_announce_addr(msk, addr, true);
687 : 36 : mptcp_pm_add_addr_send_ack(msk);
688 [ + + ]: 335 : } else if (mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_RECEIVED)) {
689 : 328 : pm->remote = *addr;
690 : : } else {
691 [ + - ]: 7 : __MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_ADDADDRDROP);
692 : : }
693 : :
694 : 401 : spin_unlock_bh(&pm->lock);
695 : 401 : }
696 : :
697 : 372 : void mptcp_pm_add_addr_echoed(struct mptcp_sock *msk,
698 : : const struct mptcp_addr_info *addr)
699 : : {
700 : 372 : struct mptcp_pm_data *pm = &msk->pm;
701 : :
702 [ - + - - ]: 372 : pr_debug("msk=%p\n", msk);
703 : :
704 [ - + + + ]: 372 : if (!READ_ONCE(pm->work_pending))
[ + + ]
705 : : return;
706 : :
707 : 113 : spin_lock_bh(&pm->lock);
708 : :
709 [ + + - + : 113 : if (mptcp_lookup_anno_list_by_saddr(msk, addr) && READ_ONCE(pm->work_pending))
+ - ]
[ + - + - ]
710 : 110 : mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
711 : :
712 : 113 : spin_unlock_bh(&pm->lock);
713 : : }
714 : :
715 : 129 : void mptcp_pm_add_addr_send_ack(struct mptcp_sock *msk)
716 : : {
717 [ + - ]: 129 : if (!mptcp_pm_should_add_signal(msk))
718 : : return;
719 : :
720 : 129 : mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_SEND_ACK);
721 : : }
722 : :
723 : 194 : static void mptcp_pm_rm_addr_or_subflow(struct mptcp_sock *msk,
724 : : const struct mptcp_rm_list *rm_list,
725 : : enum linux_mptcp_mib_field rm_type)
726 : : {
727 : 194 : struct mptcp_subflow_context *subflow, *tmp;
728 : 194 : struct sock *sk = (struct sock *)msk;
729 : 194 : u8 i;
730 : :
731 [ - + - - : 194 : pr_debug("%s rm_list_nr %d\n",
- - ]
732 : : rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow", rm_list->nr);
733 : :
734 : 194 : msk_owned_by_me(msk);
735 : :
736 [ + - ]: 194 : if (sk->sk_state == TCP_LISTEN)
737 : : return;
738 : :
739 [ + - ]: 194 : if (!rm_list->nr)
740 : : return;
741 : :
742 [ + - ]: 194 : if (list_empty(&msk->conn_list))
743 : : return;
744 : :
745 [ + + ]: 406 : for (i = 0; i < rm_list->nr; i++) {
746 : 212 : u8 rm_id = rm_list->ids[i];
747 : 212 : bool removed = false;
748 : :
749 [ + + ]: 724 : mptcp_for_each_subflow_safe(msk, subflow, tmp) {
750 : 512 : struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
751 : 512 : u8 remote_id = READ_ONCE(subflow->remote_id);
752 : 512 : int how = RCV_SHUTDOWN | SEND_SHUTDOWN;
753 : 512 : u8 id = subflow_get_local_id(subflow);
754 : :
755 [ - + + + ]: 512 : if ((1 << inet_sk_state_load(ssk)) &
[ + + ]
756 : : (TCPF_FIN_WAIT1 | TCPF_FIN_WAIT2 | TCPF_CLOSING | TCPF_CLOSE))
757 : 12 : continue;
758 [ + + ]: 500 : if (rm_type == MPTCP_MIB_RMADDR && remote_id != rm_id)
759 : 172 : continue;
760 [ + + ]: 328 : if (rm_type == MPTCP_MIB_RMSUBFLOW && id != rm_id)
761 : 156 : continue;
762 : :
763 [ - + - - : 172 : pr_debug(" -> %s rm_list_ids[%d]=%u local_id=%u remote_id=%u mpc_id=%u\n",
- - ]
764 : : rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow",
765 : : i, rm_id, id, remote_id, msk->mpc_endpoint_id);
766 : 172 : spin_unlock_bh(&msk->pm.lock);
767 : 172 : mptcp_subflow_shutdown(sk, ssk, how);
768 : 172 : removed |= subflow->request_join;
769 : :
770 : : /* the following takes care of updating the subflows counter */
771 : 172 : mptcp_close_ssk(sk, ssk, subflow);
772 : 172 : spin_lock_bh(&msk->pm.lock);
773 : :
774 [ + + ]: 172 : if (rm_type == MPTCP_MIB_RMSUBFLOW)
775 [ - + ]: 90 : __MPTCP_INC_STATS(sock_net(sk), rm_type);
776 : : }
777 : :
778 [ + + ]: 212 : if (rm_type == MPTCP_MIB_RMADDR) {
779 [ + - ]: 116 : __MPTCP_INC_STATS(sock_net(sk), rm_type);
780 [ + + + - ]: 116 : if (removed && mptcp_pm_is_kernel(msk))
781 : 46 : mptcp_pm_nl_rm_addr(msk, rm_id);
782 : : }
783 : : }
784 : : }
785 : :
786 : 0 : static void mptcp_pm_rm_addr_recv(struct mptcp_sock *msk)
787 : : {
788 : 108 : mptcp_pm_rm_addr_or_subflow(msk, &msk->pm.rm_list_rx, MPTCP_MIB_RMADDR);
789 : 108 : }
790 : :
791 : 86 : void mptcp_pm_rm_subflow(struct mptcp_sock *msk,
792 : : const struct mptcp_rm_list *rm_list)
793 : : {
794 : 86 : mptcp_pm_rm_addr_or_subflow(msk, rm_list, MPTCP_MIB_RMSUBFLOW);
795 : 86 : }
796 : :
797 : 108 : void mptcp_pm_rm_addr_received(struct mptcp_sock *msk,
798 : : const struct mptcp_rm_list *rm_list)
799 : : {
800 : 108 : struct mptcp_pm_data *pm = &msk->pm;
801 : 108 : u8 i;
802 : :
803 [ - + - - ]: 108 : pr_debug("msk=%p remote_ids_nr=%d\n", msk, rm_list->nr);
804 : :
805 [ + + ]: 224 : for (i = 0; i < rm_list->nr; i++)
806 : 116 : mptcp_event_addr_removed(msk, rm_list->ids[i]);
807 : :
808 : 108 : spin_lock_bh(&pm->lock);
809 [ + - ]: 108 : if (mptcp_pm_schedule_work(msk, MPTCP_PM_RM_ADDR_RECEIVED))
810 : 108 : pm->rm_list_rx = *rm_list;
811 : : else
812 [ # # ]: 0 : __MPTCP_INC_STATS(sock_net((struct sock *)msk), MPTCP_MIB_RMADDRDROP);
813 : 108 : spin_unlock_bh(&pm->lock);
814 : 108 : }
815 : :
816 : 40 : void mptcp_pm_mp_prio_received(struct sock *ssk, u8 bkup)
817 : : {
818 [ - + ]: 40 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
819 : 40 : struct sock *sk = subflow->conn;
820 : 40 : struct mptcp_sock *msk;
821 : :
822 [ - + - - ]: 40 : pr_debug("subflow->backup=%d, bkup=%d\n", subflow->backup, bkup);
823 [ - + ]: 40 : msk = mptcp_sk(sk);
824 [ + - ]: 40 : if (subflow->backup != bkup)
825 : 40 : subflow->backup = bkup;
826 : :
827 : 40 : mptcp_event(MPTCP_EVENT_SUB_PRIORITY, msk, ssk, GFP_ATOMIC);
828 : 40 : }
829 : :
830 : 6 : void mptcp_pm_mp_fail_received(struct sock *sk, u64 fail_seq)
831 : : {
832 [ - + ]: 6 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
833 [ - + ]: 6 : struct mptcp_sock *msk = mptcp_sk(subflow->conn);
834 : :
835 [ - + - - ]: 6 : pr_debug("fail_seq=%llu\n", fail_seq);
836 : :
837 : : /* After accepting the fail, we can't create any other subflows */
838 : 6 : spin_lock_bh(&msk->fallback_lock);
839 [ - + + + ]: 6 : if (!msk->allow_infinite_fallback) {
[ + + ]
840 : 2 : spin_unlock_bh(&msk->fallback_lock);
841 : 2 : return;
842 : : }
843 : 4 : msk->allow_subflows = false;
844 : 4 : spin_unlock_bh(&msk->fallback_lock);
845 : :
846 [ + + ]: 4 : if (!subflow->fail_tout) {
847 [ - + - - ]: 2 : pr_debug("send MP_FAIL response and infinite map\n");
848 : :
849 : 2 : subflow->send_mp_fail = 1;
850 : 2 : subflow->send_infinite_map = 1;
851 : 2 : tcp_send_ack(sk);
852 : : } else {
853 [ - + - - ]: 2 : pr_debug("MP_FAIL response received\n");
854 : 2 : WRITE_ONCE(subflow->fail_tout, 0);
855 : : }
856 : : }
857 : :
858 : 831 : bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, const struct sk_buff *skb,
859 : : unsigned int opt_size, unsigned int remaining,
860 : : struct mptcp_addr_info *addr, bool *echo,
861 : : bool *drop_other_suboptions)
862 : : {
863 : 831 : int ret = false;
864 : 831 : u8 add_addr;
865 : 831 : u8 family;
866 : 831 : bool port;
867 : :
868 : 831 : spin_lock_bh(&msk->pm.lock);
869 : :
870 : : /* double check after the lock is acquired */
871 [ - + ]: 831 : if (!mptcp_pm_should_add_signal(msk))
872 : 0 : goto out_unlock;
873 : :
874 : : /* always drop every other options for pure ack ADD_ADDR; this is a
875 : : * plain dup-ack from TCP perspective. The other MPTCP-relevant info,
876 : : * if any, will be carried by the 'original' TCP ack
877 : : */
878 [ + - + - ]: 831 : if (skb && skb_is_tcp_pure_ack(skb)) {
879 : 831 : remaining += opt_size;
880 : 831 : *drop_other_suboptions = true;
881 : : }
882 : :
883 [ + + ]: 831 : *echo = mptcp_pm_should_add_signal_echo(msk);
884 [ - + + + ]: 831 : port = !!(*echo ? msk->pm.remote.port : msk->pm.local.port);
[ + + ]
885 : :
886 [ - + + + ]: 831 : family = *echo ? msk->pm.remote.family : msk->pm.local.family;
[ + + ]
887 [ - + + + : 1662 : if (remaining < mptcp_add_addr_len(family, *echo, port))
- + ]
[ + + - + ]
888 : 0 : goto out_unlock;
889 : :
890 [ - + + + ]: 831 : if (*echo) {
[ + + ]
891 : 392 : *addr = msk->pm.remote;
892 : 392 : add_addr = msk->pm.addr_signal & ~BIT(MPTCP_ADD_ADDR_ECHO);
893 : : } else {
894 : 439 : *addr = msk->pm.local;
895 : 439 : add_addr = msk->pm.addr_signal & ~BIT(MPTCP_ADD_ADDR_SIGNAL);
896 : : }
897 : 831 : WRITE_ONCE(msk->pm.addr_signal, add_addr);
898 : 831 : ret = true;
899 : :
900 : 831 : out_unlock:
901 : 831 : spin_unlock_bh(&msk->pm.lock);
902 : 831 : return ret;
903 : : }
904 : :
905 : 108 : bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
906 : : struct mptcp_rm_list *rm_list)
907 : : {
908 : 108 : int ret = false, len;
909 : 108 : u8 rm_addr;
910 : :
911 : 108 : spin_lock_bh(&msk->pm.lock);
912 : :
913 : : /* double check after the lock is acquired */
914 [ - + ]: 108 : if (!mptcp_pm_should_rm_signal(msk))
915 : 0 : goto out_unlock;
916 : :
917 : 108 : rm_addr = msk->pm.addr_signal & ~BIT(MPTCP_RM_ADDR_SIGNAL);
918 [ - + ]: 108 : len = mptcp_rm_addr_len(&msk->pm.rm_list_tx);
919 : 0 : if (len < 0) {
920 : 0 : WRITE_ONCE(msk->pm.addr_signal, rm_addr);
921 : 0 : goto out_unlock;
922 : : }
923 [ - + ]: 108 : if (remaining < len)
924 : 0 : goto out_unlock;
925 : :
926 : 108 : *rm_list = msk->pm.rm_list_tx;
927 : 108 : WRITE_ONCE(msk->pm.addr_signal, rm_addr);
928 : 108 : ret = true;
929 : :
930 : 108 : out_unlock:
931 : 108 : spin_unlock_bh(&msk->pm.lock);
932 : 108 : return ret;
933 : : }
934 : :
935 : 843 : int mptcp_pm_get_local_id(struct mptcp_sock *msk, struct sock_common *skc)
936 : : {
937 : 843 : struct mptcp_pm_addr_entry skc_local = { 0 };
938 : 843 : struct mptcp_addr_info msk_local;
939 : :
940 [ - + ]: 843 : if (WARN_ON_ONCE(!msk))
941 : 0 : return -1;
942 : :
943 : : /* The 0 ID mapping is defined by the first subflow, copied into the msk
944 : : * addr
945 : : */
946 : 843 : mptcp_local_address((struct sock_common *)msk, &msk_local);
947 : 843 : mptcp_local_address((struct sock_common *)skc, &skc_local.addr);
948 [ + + ]: 843 : if (mptcp_addresses_equal(&msk_local, &skc_local.addr, false))
949 : : return 0;
950 : :
951 : 411 : skc_local.addr.id = 0;
952 : 411 : skc_local.flags = MPTCP_PM_ADDR_FLAG_IMPLICIT;
953 : :
954 : 411 : return msk->pm.ops->get_local_id(msk, &skc_local);
955 : : }
956 : :
957 : 843 : bool mptcp_pm_is_backup(struct mptcp_sock *msk, struct sock_common *skc)
958 : : {
959 : 843 : struct mptcp_addr_info skc_local;
960 : :
961 : 843 : mptcp_local_address((struct sock_common *)skc, &skc_local);
962 : :
963 : 843 : return msk->pm.ops->get_priority(msk, &skc_local);
964 : : }
965 : :
966 : 1890 : static void mptcp_pm_subflows_chk_stale(const struct mptcp_sock *msk, struct sock *ssk)
967 : : {
968 : 1890 : struct mptcp_subflow_context *iter, *subflow = mptcp_subflow_ctx(ssk);
969 : 1890 : struct sock *sk = (struct sock *)msk;
970 : 1890 : unsigned int active_max_loss_cnt;
971 : 1890 : struct net *net = sock_net(sk);
972 : 1890 : unsigned int stale_loss_cnt;
973 : 1890 : bool slow;
974 : :
975 : 1890 : stale_loss_cnt = mptcp_stale_loss_cnt(net);
976 [ + + + - : 1890 : if (subflow->stale || !stale_loss_cnt || subflow->stale_count <= stale_loss_cnt)
+ + ]
977 : : return;
978 : :
979 : : /* look for another available subflow not in loss state */
980 : 1744 : active_max_loss_cnt = max_t(int, stale_loss_cnt - 1, 1);
981 [ + + ]: 4991 : mptcp_for_each_subflow(msk, iter) {
982 [ + + + + ]: 3264 : if (iter != subflow && mptcp_subflow_active(iter) &&
983 [ + + ]: 22 : iter->stale_count < active_max_loss_cnt) {
984 : : /* we have some alternatives, try to mark this subflow as idle ...*/
985 : 17 : slow = lock_sock_fast(ssk);
986 [ + + ]: 17 : if (!tcp_rtx_and_write_queues_empty(ssk)) {
987 : 17 : subflow->stale = 1;
988 : 17 : __mptcp_retransmit_pending_data(sk);
989 [ + - ]: 17 : MPTCP_INC_STATS(net, MPTCP_MIB_SUBFLOWSTALE);
990 : : }
991 : 17 : unlock_sock_fast(ssk, slow);
992 : :
993 : : /* always try to push the pending data regardless of re-injections:
994 : : * we can possibly use backup subflows now, and subflow selection
995 : : * is cheap under the msk socket lock
996 : : */
997 : 17 : __mptcp_push_pending(sk, 0);
998 : 17 : return;
999 : : }
1000 : : }
1001 : : }
1002 : :
1003 : 2413 : void mptcp_pm_subflow_chk_stale(const struct mptcp_sock *msk, struct sock *ssk)
1004 : : {
1005 [ - + ]: 2413 : struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1006 [ - + ]: 2413 : u32 rcv_tstamp = READ_ONCE(tcp_sk(ssk)->rcv_tstamp);
1007 : :
1008 : : /* keep track of rtx periods with no progress */
1009 [ + + ]: 2413 : if (!subflow->stale_count) {
1010 : 376 : subflow->stale_rcv_tstamp = rcv_tstamp;
1011 : 376 : subflow->stale_count++;
1012 [ + + ]: 2037 : } else if (subflow->stale_rcv_tstamp == rcv_tstamp) {
1013 [ + + ]: 1890 : if (subflow->stale_count < U8_MAX)
1014 : 1803 : subflow->stale_count++;
1015 : 1890 : mptcp_pm_subflows_chk_stale(msk, ssk);
1016 : : } else {
1017 : 147 : subflow->stale_count = 0;
1018 : 147 : mptcp_subflow_set_active(subflow);
1019 : : }
1020 : 2413 : }
1021 : :
1022 : 12179 : void mptcp_pm_worker(struct mptcp_sock *msk)
1023 : : {
1024 : 12179 : struct mptcp_pm_data *pm = &msk->pm;
1025 : :
1026 : 12179 : msk_owned_by_me(msk);
1027 : :
1028 [ + + ]: 12179 : if (!(pm->status & MPTCP_PM_WORK_MASK))
1029 : : return;
1030 : :
1031 : 1042 : spin_lock_bh(&msk->pm.lock);
1032 : :
1033 [ - + - - ]: 1042 : pr_debug("msk=%p status=%x\n", msk, pm->status);
1034 [ + + ]: 1042 : if (pm->status & BIT(MPTCP_PM_ADD_ADDR_SEND_ACK)) {
1035 : 129 : pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_SEND_ACK);
1036 : 129 : mptcp_pm_addr_send_ack(msk);
1037 : : }
1038 [ + + ]: 1042 : if (pm->status & BIT(MPTCP_PM_RM_ADDR_RECEIVED)) {
1039 : 108 : pm->status &= ~BIT(MPTCP_PM_RM_ADDR_RECEIVED);
1040 : 108 : mptcp_pm_rm_addr_recv(msk);
1041 : : }
1042 : 1042 : __mptcp_pm_kernel_worker(msk);
1043 : :
1044 : 1042 : spin_unlock_bh(&msk->pm.lock);
1045 : : }
1046 : :
1047 : 5082 : static void mptcp_pm_ops_init(struct mptcp_sock *msk,
1048 : : struct mptcp_pm_ops *pm_ops)
1049 : : {
1050 [ + - - + ]: 5082 : if (!pm_ops || !bpf_try_module_get(pm_ops, pm_ops->owner)) {
1051 [ # # # # ]: 0 : pr_warn_once("pm %s fails, fallback to default pm",
[ # # ]
1052 : : pm_ops->name);
1053 : : pm_ops = &mptcp_pm_kernel;
1054 : : }
1055 : :
1056 : 5082 : msk->pm.ops = pm_ops;
1057 [ + + ]: 5082 : if (msk->pm.ops->init)
1058 : 5016 : msk->pm.ops->init(msk);
1059 : :
1060 [ - + - - ]: 5082 : pr_debug("pm %s initialized\n", pm_ops->name);
1061 : 5082 : }
1062 : :
1063 : 5007 : static void mptcp_pm_ops_release(struct mptcp_sock *msk)
1064 : : {
1065 : 5007 : struct mptcp_pm_ops *pm_ops = msk->pm.ops;
1066 : :
1067 : 5007 : msk->pm.ops = NULL;
1068 [ + + ]: 5007 : if (pm_ops->release)
1069 : 66 : pm_ops->release(msk);
1070 : :
1071 : 5007 : bpf_module_put(pm_ops, pm_ops->owner);
1072 : :
1073 [ - + - - ]: 5007 : pr_debug("pm %s released\n", pm_ops->name);
1074 : 5007 : }
1075 : :
1076 : 5007 : void mptcp_pm_destroy(struct mptcp_sock *msk)
1077 : : {
1078 : 5007 : mptcp_pm_free_anno_list(msk);
1079 : 5007 : mptcp_pm_ops_release(msk);
1080 : 5007 : }
1081 : :
1082 : 5082 : void mptcp_pm_data_reset(struct mptcp_sock *msk)
1083 : : {
1084 : 5082 : const struct net *net = sock_net((struct sock *)msk);
1085 : 5082 : const char *pm_name = mptcp_get_path_manager(net);
1086 : 5082 : u8 pm_type = mptcp_get_pm_type(net);
1087 : 5082 : struct mptcp_pm_data *pm = &msk->pm;
1088 : :
1089 : 5082 : memset(&pm->reset, 0, sizeof(pm->reset));
1090 : 5082 : pm->rm_list_tx.nr = 0;
1091 : 5082 : pm->rm_list_rx.nr = 0;
1092 : 5082 : WRITE_ONCE(pm->pm_type, pm_type);
1093 : :
1094 : 5082 : rcu_read_lock();
1095 : 5082 : mptcp_pm_ops_init(msk, mptcp_pm_find(pm_name));
1096 : 5082 : rcu_read_unlock();
1097 : 5082 : }
1098 : :
1099 : 4976 : void mptcp_pm_data_init(struct mptcp_sock *msk)
1100 : : {
1101 : 4976 : spin_lock_init(&msk->pm.lock);
1102 : 4976 : INIT_LIST_HEAD(&msk->pm.anno_list);
1103 : 4976 : INIT_LIST_HEAD(&msk->pm.userspace_pm_local_addr_list);
1104 : 4976 : mptcp_pm_data_reset(msk);
1105 : 4976 : }
1106 : :
1107 : 6 : void __init mptcp_pm_init(void)
1108 : : {
1109 : 6 : mptcp_pm_kernel_register();
1110 : 6 : mptcp_pm_userspace_register();
1111 : 6 : mptcp_pm_nl_init();
1112 : 6 : }
1113 : :
1114 : : /* Must be called with rcu read lock held */
1115 : 5678 : struct mptcp_pm_ops *mptcp_pm_find(const char *name)
1116 : : {
1117 : 5678 : struct mptcp_pm_ops *pm_ops;
1118 : :
1119 [ + - - + : 5786 : list_for_each_entry_rcu(pm_ops, &mptcp_pm_list, list) {
- - - - -
- + + ]
[ + + ]
1120 [ + + ]: 5772 : if (!strcmp(pm_ops->name, name))
1121 : : return pm_ops;
1122 : : }
1123 : :
1124 : : return NULL;
1125 : : }
1126 : :
1127 : 12 : int mptcp_pm_validate(struct mptcp_pm_ops *pm_ops)
1128 : : {
1129 [ + - - + ]: 12 : if (!pm_ops->get_local_id || !pm_ops->get_priority) {
1130 : 0 : pr_err("%s does not implement required ops\n", pm_ops->name);
1131 : 0 : return -EINVAL;
1132 : : }
1133 : :
1134 : : return 0;
1135 : : }
1136 : :
1137 : 12 : int mptcp_pm_register(struct mptcp_pm_ops *pm_ops)
1138 : : {
1139 : 12 : int ret;
1140 : :
1141 : 12 : ret = mptcp_pm_validate(pm_ops);
1142 [ + - ]: 12 : if (ret)
1143 : : return ret;
1144 : :
1145 : 12 : spin_lock(&mptcp_pm_list_lock);
1146 [ - + ]: 12 : if (mptcp_pm_find(pm_ops->name)) {
1147 : 0 : spin_unlock(&mptcp_pm_list_lock);
1148 : 0 : return -EEXIST;
1149 : : }
1150 : 12 : list_add_tail_rcu(&pm_ops->list, &mptcp_pm_list);
1151 : 12 : spin_unlock(&mptcp_pm_list_lock);
1152 : :
1153 [ - + - - ]: 12 : pr_debug("%s registered\n", pm_ops->name);
1154 : : return 0;
1155 : : }
1156 : :
1157 : 0 : void mptcp_pm_unregister(struct mptcp_pm_ops *pm_ops)
1158 : : {
1159 : : /* skip unregistering the default path manager */
1160 [ # # # # ]: 0 : if (WARN_ON_ONCE(pm_ops == &mptcp_pm_kernel))
1161 : : return;
1162 : :
1163 : 0 : spin_lock(&mptcp_pm_list_lock);
1164 : 0 : list_del_rcu(&pm_ops->list);
1165 : 0 : spin_unlock(&mptcp_pm_list_lock);
1166 : : }
1167 : :
1168 : : /* Build string with list of available path manager values.
1169 : : * Similar to tcp_get_available_congestion_control()
1170 : : */
1171 : 20 : void mptcp_pm_get_available(char *buf, size_t maxlen)
1172 : : {
1173 : 20 : struct mptcp_pm_ops *pm_ops;
1174 : 20 : size_t offs = 0;
1175 : :
1176 : 20 : rcu_read_lock();
1177 [ + - - + : 60 : list_for_each_entry_rcu(pm_ops, &mptcp_pm_list, list) {
- - - - -
- + + ]
[ + + ]
1178 : 80 : offs += snprintf(buf + offs, maxlen - offs, "%s%s",
1179 [ + + ]: 40 : offs == 0 ? "" : " ", pm_ops->name);
1180 : :
1181 [ - + + - ]: 40 : if (WARN_ON_ONCE(offs >= maxlen))
1182 : : break;
1183 : : }
1184 : 20 : rcu_read_unlock();
1185 : 20 : }
|
