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