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