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