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