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