projects/linux·blob master · refs

718 lines · 16.5 KiB

1// SPDX-License-Identifier: GPL-2.0
2/* Multipath TCP
3 *
4 * Copyright (c) 2022, Intel Corporation.
5 */
6
7#include "protocol.h"
8#include "mib.h"
9#include "mptcp_pm_gen.h"
10
11#define mptcp_for_each_userspace_pm_addr(__msk, __entry) \
12 list_for_each_entry(__entry, \
13 &((__msk)->pm.userspace_pm_local_addr_list), list)
14
15void mptcp_userspace_pm_free_local_addr_list(struct mptcp_sock *msk)
16{
17 struct mptcp_pm_addr_entry *entry, *tmp;
18 struct sock *sk = (struct sock *)msk;
19 LIST_HEAD(free_list);
20
21 spin_lock_bh(&msk->pm.lock);
22 list_splice_init(&msk->pm.userspace_pm_local_addr_list, &free_list);
23 spin_unlock_bh(&msk->pm.lock);
24
25 list_for_each_entry_safe(entry, tmp, &free_list, list) {
26 sock_kfree_s(sk, entry, sizeof(*entry));
27 }
28}
29
30static struct mptcp_pm_addr_entry *
31mptcp_userspace_pm_lookup_addr(struct mptcp_sock *msk,
32 const struct mptcp_addr_info *addr)
33{
34 struct mptcp_pm_addr_entry *entry;
35
36 mptcp_for_each_userspace_pm_addr(msk, entry) {
37 if (mptcp_addresses_equal(&entry->addr, addr, false))
38 return entry;
39 }
40 return NULL;
41}
42
43static int mptcp_userspace_pm_append_new_local_addr(struct mptcp_sock *msk,
44 struct mptcp_pm_addr_entry *entry,
45 bool needs_id)
46{
47 DECLARE_BITMAP(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
48 struct sock *sk = (struct sock *)msk;
49 struct mptcp_pm_addr_entry *e;
50 bool addr_match = false;
51 bool id_match = false;
52 int ret = -EINVAL;
53
54 bitmap_zero(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
55
56 spin_lock_bh(&msk->pm.lock);
57 if (msk->pm.status & BIT(MPTCP_PM_DESTROYING)) {
58 ret = -EINVAL;
59 goto append_err;
60 }
61 mptcp_for_each_userspace_pm_addr(msk, e) {
62 addr_match = mptcp_addresses_equal(&e->addr, &entry->addr, true);
63 if (addr_match && entry->addr.id == 0 && needs_id)
64 entry->addr.id = e->addr.id;
65 id_match = (e->addr.id == entry->addr.id);
66 if (addr_match || id_match)
67 break;
68 __set_bit(e->addr.id, id_bitmap);
69 }
70
71 if (!addr_match && !id_match) {
72 unsigned int id;
73
74 if (!entry->addr.id && needs_id) {
75 id = find_next_zero_bit(id_bitmap,
76 MPTCP_PM_MAX_ADDR_ID + 1, 1);
77 if (id > MPTCP_PM_MAX_ADDR_ID) {
78 ret = -ENOSPC;
79 goto append_err;
80 }
81 } else {
82 id = entry->addr.id;
83 }
84
85 /* Memory for the entry is allocated from the
86 * sock option buffer.
87 */
88 e = sock_kmemdup(sk, entry, sizeof(*entry), GFP_ATOMIC);
89 if (!e) {
90 ret = -ENOMEM;
91 goto append_err;
92 }
93
94 e->addr.id = id;
95 list_add_tail_rcu(&e->list, &msk->pm.userspace_pm_local_addr_list);
96 msk->pm.local_addr_used++;
97 ret = e->addr.id;
98 } else if (addr_match && id_match) {
99 ret = entry->addr.id;
100 }
101
102append_err:
103 spin_unlock_bh(&msk->pm.lock);
104 return ret;
105}
106
107/* If the subflow is closed from the other peer (not via a
108 * subflow destroy command then), we want to keep the entry
109 * not to assign the same ID to another address and to be
110 * able to send RM_ADDR after the removal of the subflow.
111 */
112static int mptcp_userspace_pm_delete_local_addr(struct mptcp_sock *msk,
113 struct mptcp_pm_addr_entry *addr)
114{
115 struct sock *sk = (struct sock *)msk;
116 struct mptcp_pm_addr_entry *entry;
117
118 entry = mptcp_userspace_pm_lookup_addr(msk, &addr->addr);
119 if (!entry)
120 return -EINVAL;
121
122 /* TODO: a refcount is needed because the entry can
123 * be used multiple times (e.g. fullmesh mode).
124 */
125 list_del_rcu(&entry->list);
126 sock_kfree_s(sk, entry, sizeof(*entry));
127 msk->pm.local_addr_used--;
128 return 0;
129}
130
131static struct mptcp_pm_addr_entry *
132mptcp_userspace_pm_lookup_addr_by_id(struct mptcp_sock *msk, unsigned int id)
133{
134 struct mptcp_pm_addr_entry *entry;
135
136 mptcp_for_each_userspace_pm_addr(msk, entry) {
137 if (entry->addr.id == id)
138 return entry;
139 }
140 return NULL;
141}
142
143int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,
144 struct mptcp_pm_addr_entry *skc)
145{
146 __be16 msk_sport = ((struct inet_sock *)
147 inet_sk((struct sock *)msk))->inet_sport;
148 struct mptcp_pm_addr_entry *entry;
149 int id;
150
151 spin_lock_bh(&msk->pm.lock);
152 entry = mptcp_userspace_pm_lookup_addr(msk, &skc->addr);
153 id = entry ? entry->addr.id : -1;
154 spin_unlock_bh(&msk->pm.lock);
155
156 if (id != -1)
157 return id;
158
159 if (skc->addr.port == msk_sport)
160 skc->addr.port = 0;
161
162 return mptcp_userspace_pm_append_new_local_addr(msk, skc, true);
163}
164
165bool mptcp_userspace_pm_is_backup(struct mptcp_sock *msk,
166 struct mptcp_addr_info *skc)
167{
168 struct mptcp_pm_addr_entry *entry;
169 bool backup;
170
171 spin_lock_bh(&msk->pm.lock);
172 entry = mptcp_userspace_pm_lookup_addr(msk, skc);
173 backup = entry && !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP);
174 spin_unlock_bh(&msk->pm.lock);
175
176 return backup;
177}
178
179static struct mptcp_sock *mptcp_userspace_pm_get_sock(const struct genl_info *info)
180{
181 struct mptcp_sock *msk;
182 struct nlattr *token;
183
184 if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_TOKEN))
185 return NULL;
186
187 token = info->attrs[MPTCP_PM_ATTR_TOKEN];
188 msk = mptcp_token_get_sock(genl_info_net(info), nla_get_u32(token));
189 if (!msk) {
190 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
191 return NULL;
192 }
193
194 if (!mptcp_pm_is_userspace(msk)) {
195 NL_SET_ERR_MSG_ATTR(info->extack, token,
196 "userspace PM not selected");
197 sock_put((struct sock *)msk);
198 return NULL;
199 }
200
201 return msk;
202}
203
204int mptcp_pm_nl_announce_doit(struct sk_buff *skb, struct genl_info *info)
205{
206 struct mptcp_pm_addr_entry addr_val;
207 struct mptcp_sock *msk;
208 struct nlattr *addr;
209 int err = -EINVAL;
210 struct sock *sk;
211
212 if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR))
213 return err;
214
215 msk = mptcp_userspace_pm_get_sock(info);
216 if (!msk)
217 return err;
218
219 sk = (struct sock *)msk;
220
221 addr = info->attrs[MPTCP_PM_ATTR_ADDR];
222 err = mptcp_pm_parse_entry(addr, info, true, &addr_val);
223 if (err < 0)
224 goto announce_err;
225
226 if (addr_val.addr.id == 0) {
227 NL_SET_ERR_MSG_ATTR(info->extack, addr, "invalid addr id");
228 err = -EINVAL;
229 goto announce_err;
230 }
231
232 if (!(addr_val.flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) {
233 NL_SET_ERR_MSG_ATTR(info->extack, addr, "invalid addr flags");
234 err = -EINVAL;
235 goto announce_err;
236 }
237
238 err = mptcp_userspace_pm_append_new_local_addr(msk, &addr_val, false);
239 if (err < 0) {
240 NL_SET_ERR_MSG_ATTR(info->extack, addr,
241 "did not match address and id");
242 goto announce_err;
243 }
244
245 lock_sock(sk);
246 spin_lock_bh(&msk->pm.lock);
247
248 if (mptcp_pm_announced_alloc(msk, &addr_val.addr)) {
249 msk->pm.add_addr_signaled++;
250 mptcp_pm_announce_addr(msk, &addr_val.addr, false);
251 mptcp_pm_addr_send_ack(msk);
252 }
253
254 spin_unlock_bh(&msk->pm.lock);
255 release_sock(sk);
256
257 err = 0;
258 announce_err:
259 sock_put(sk);
260 return err;
261}
262
263static int mptcp_userspace_pm_remove_id_zero_address(struct mptcp_sock *msk)
264{
265 struct mptcp_rm_list list = { .nr = 0 };
266 struct mptcp_subflow_context *subflow;
267 struct sock *sk = (struct sock *)msk;
268 bool has_id_0 = false;
269 int err = -EINVAL;
270
271 lock_sock(sk);
272 mptcp_for_each_subflow(msk, subflow) {
273 if (READ_ONCE(subflow->local_id) == 0) {
274 has_id_0 = true;
275 break;
276 }
277 }
278 if (!has_id_0)
279 goto remove_err;
280
281 list.ids[list.nr++] = 0;
282
283 spin_lock_bh(&msk->pm.lock);
284 mptcp_pm_remove_addr(msk, &list);
285 spin_unlock_bh(&msk->pm.lock);
286
287 err = 0;
288
289remove_err:
290 release_sock(sk);
291 return err;
292}
293
294static void
295mptcp_userspace_pm_remove_addr_entry(struct mptcp_sock *msk,
296 struct mptcp_pm_addr_entry *entry)
297{
298 struct mptcp_rm_list alist = { .nr = 0 };
299 int anno_nr = 0;
300
301 /* only delete if either announced or matching a subflow */
302 if (mptcp_pm_announced_remove(msk, &entry->addr))
303 anno_nr++;
304 else if (!mptcp_pm_has_subflow_saddr(msk, &entry->addr))
305 return;
306
307 alist.ids[alist.nr++] = entry->addr.id;
308
309 spin_lock_bh(&msk->pm.lock);
310 msk->pm.add_addr_signaled -= anno_nr;
311 mptcp_pm_remove_addr(msk, &alist);
312 spin_unlock_bh(&msk->pm.lock);
313}
314
315int mptcp_pm_nl_remove_doit(struct sk_buff *skb, struct genl_info *info)
316{
317 struct mptcp_pm_addr_entry *match;
318 struct mptcp_sock *msk;
319 struct nlattr *id;
320 int err = -EINVAL;
321 struct sock *sk;
322 u8 id_val;
323
324 if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_LOC_ID))
325 return err;
326
327 id = info->attrs[MPTCP_PM_ATTR_LOC_ID];
328 id_val = nla_get_u8(id);
329
330 msk = mptcp_userspace_pm_get_sock(info);
331 if (!msk)
332 return err;
333
334 sk = (struct sock *)msk;
335
336 if (id_val == 0) {
337 err = mptcp_userspace_pm_remove_id_zero_address(msk);
338 goto out;
339 }
340
341 lock_sock(sk);
342
343 spin_lock_bh(&msk->pm.lock);
344 match = mptcp_userspace_pm_lookup_addr_by_id(msk, id_val);
345 if (!match) {
346 spin_unlock_bh(&msk->pm.lock);
347 release_sock(sk);
348 goto out;
349 }
350
351 list_del_rcu(&match->list);
352 spin_unlock_bh(&msk->pm.lock);
353
354 mptcp_userspace_pm_remove_addr_entry(msk, match);
355
356 release_sock(sk);
357
358 kfree_rcu_mightsleep(match);
359 /* Adjust sk_omem_alloc like sock_kfree_s() does, to match
360 * with allocation of this memory by sock_kmemdup()
361 */
362 atomic_sub(sizeof(*match), &sk->sk_omem_alloc);
363
364 err = 0;
365out:
366 if (err)
367 NL_SET_ERR_MSG_ATTR_FMT(info->extack, id,
368 "address with id %u not found",
369 id_val);
370
371 sock_put(sk);
372 return err;
373}
374
375int mptcp_pm_nl_subflow_create_doit(struct sk_buff *skb, struct genl_info *info)
376{
377 struct mptcp_pm_addr_entry entry = { 0 };
378 struct mptcp_addr_info addr_r;
379 struct nlattr *raddr, *laddr;
380 struct mptcp_pm_local local;
381 struct mptcp_sock *msk;
382 int err = -EINVAL;
383 struct sock *sk;
384
385 if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR) ||
386 GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR_REMOTE))
387 return err;
388
389 msk = mptcp_userspace_pm_get_sock(info);
390 if (!msk)
391 return err;
392
393 sk = (struct sock *)msk;
394
395 laddr = info->attrs[MPTCP_PM_ATTR_ADDR];
396 err = mptcp_pm_parse_entry(laddr, info, true, &entry);
397 if (err < 0)
398 goto create_err;
399
400 if (entry.flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
401 NL_SET_ERR_MSG_ATTR(info->extack, laddr, "invalid addr flags");
402 err = -EINVAL;
403 goto create_err;
404 }
405 entry.flags |= MPTCP_PM_ADDR_FLAG_SUBFLOW;
406
407 raddr = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
408 err = mptcp_pm_parse_addr(raddr, info, &addr_r);
409 if (err < 0)
410 goto create_err;
411
412 if (!mptcp_pm_addr_families_match(sk, &entry.addr, &addr_r)) {
413 GENL_SET_ERR_MSG(info, "families mismatch");
414 err = -EINVAL;
415 goto create_err;
416 }
417
418 err = mptcp_userspace_pm_append_new_local_addr(msk, &entry, false);
419 if (err < 0) {
420 NL_SET_ERR_MSG_ATTR(info->extack, laddr,
421 "did not match address and id");
422 goto create_err;
423 }
424
425 local.addr = entry.addr;
426 local.flags = entry.flags;
427 local.ifindex = entry.ifindex;
428
429 spin_lock_bh(&msk->pm.lock);
430 msk->pm.extra_subflows++;
431 spin_unlock_bh(&msk->pm.lock);
432
433 lock_sock(sk);
434 err = __mptcp_subflow_connect(sk, &local, &addr_r);
435 release_sock(sk);
436
437 if (err) {
438 GENL_SET_ERR_MSG_FMT(info, "connect error: %d", err);
439
440 spin_lock_bh(&msk->pm.lock);
441 mptcp_userspace_pm_delete_local_addr(msk, &entry);
442 spin_unlock_bh(&msk->pm.lock);
443 }
444
445 create_err:
446 sock_put(sk);
447 return err;
448}
449
450static struct sock *mptcp_nl_find_ssk(struct mptcp_sock *msk,
451 const struct mptcp_addr_info *local,
452 const struct mptcp_addr_info *remote)
453{
454 struct mptcp_subflow_context *subflow;
455
456 if (local->family != remote->family)
457 return NULL;
458
459 mptcp_for_each_subflow(msk, subflow) {
460 const struct inet_sock *issk;
461 struct sock *ssk;
462
463 ssk = mptcp_subflow_tcp_sock(subflow);
464
465 if (local->family != ssk->sk_family)
466 continue;
467
468 issk = inet_sk(ssk);
469
470 switch (ssk->sk_family) {
471 case AF_INET:
472 if (issk->inet_saddr != local->addr.s_addr ||
473 issk->inet_daddr != remote->addr.s_addr)
474 continue;
475 break;
476#if IS_ENABLED(CONFIG_MPTCP_IPV6)
477 case AF_INET6: {
478 if (!ipv6_addr_equal(&local->addr6, &issk->pinet6->saddr) ||
479 !ipv6_addr_equal(&remote->addr6, &ssk->sk_v6_daddr))
480 continue;
481 break;
482 }
483#endif
484 default:
485 continue;
486 }
487
488 if (issk->inet_sport == local->port &&
489 issk->inet_dport == remote->port)
490 return ssk;
491 }
492
493 return NULL;
494}
495
496int mptcp_pm_nl_subflow_destroy_doit(struct sk_buff *skb, struct genl_info *info)
497{
498 struct mptcp_pm_addr_entry addr_l;
499 struct mptcp_addr_info addr_r;
500 struct nlattr *raddr, *laddr;
501 struct mptcp_sock *msk;
502 struct sock *sk, *ssk;
503 int err = -EINVAL;
504
505 if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR) ||
506 GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR_REMOTE))
507 return err;
508
509 msk = mptcp_userspace_pm_get_sock(info);
510 if (!msk)
511 return err;
512
513 sk = (struct sock *)msk;
514
515 laddr = info->attrs[MPTCP_PM_ATTR_ADDR];
516 err = mptcp_pm_parse_entry(laddr, info, true, &addr_l);
517 if (err < 0)
518 goto destroy_err;
519
520 raddr = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
521 err = mptcp_pm_parse_addr(raddr, info, &addr_r);
522 if (err < 0)
523 goto destroy_err;
524
525#if IS_ENABLED(CONFIG_MPTCP_IPV6)
526 if (addr_l.addr.family == AF_INET && ipv6_addr_v4mapped(&addr_r.addr6)) {
527 ipv6_addr_set_v4mapped(addr_l.addr.addr.s_addr, &addr_l.addr.addr6);
528 addr_l.addr.family = AF_INET6;
529 }
530 if (addr_r.family == AF_INET && ipv6_addr_v4mapped(&addr_l.addr.addr6)) {
531 ipv6_addr_set_v4mapped(addr_r.addr.s_addr, &addr_r.addr6);
532 addr_r.family = AF_INET6;
533 }
534#endif
535 if (addr_l.addr.family != addr_r.family) {
536 GENL_SET_ERR_MSG(info, "address families do not match");
537 err = -EINVAL;
538 goto destroy_err;
539 }
540
541 if (!addr_l.addr.port) {
542 NL_SET_ERR_MSG_ATTR(info->extack, laddr, "missing local port");
543 err = -EINVAL;
544 goto destroy_err;
545 }
546
547 if (!addr_r.port) {
548 NL_SET_ERR_MSG_ATTR(info->extack, raddr, "missing remote port");
549 err = -EINVAL;
550 goto destroy_err;
551 }
552
553 lock_sock(sk);
554 ssk = mptcp_nl_find_ssk(msk, &addr_l.addr, &addr_r);
555 if (!ssk) {
556 GENL_SET_ERR_MSG(info, "subflow not found");
557 err = -ESRCH;
558 goto release_sock;
559 }
560
561 spin_lock_bh(&msk->pm.lock);
562 mptcp_userspace_pm_delete_local_addr(msk, &addr_l);
563 spin_unlock_bh(&msk->pm.lock);
564 mptcp_subflow_shutdown(sk, ssk, RCV_SHUTDOWN | SEND_SHUTDOWN);
565 mptcp_close_ssk(sk, ssk, mptcp_subflow_ctx(ssk));
566 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_RMSUBFLOW);
567release_sock:
568 release_sock(sk);
569
570destroy_err:
571 sock_put(sk);
572 return err;
573}
574
575int mptcp_userspace_pm_set_flags(struct mptcp_pm_addr_entry *local,
576 struct genl_info *info)
577{
578 struct mptcp_addr_info rem = { .family = AF_UNSPEC, };
579 struct mptcp_pm_addr_entry *entry;
580 struct nlattr *attr, *attr_rem;
581 struct mptcp_sock *msk;
582 int ret = -EINVAL;
583 struct sock *sk;
584 u8 bkup = 0;
585
586 if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR_REMOTE))
587 return ret;
588
589 msk = mptcp_userspace_pm_get_sock(info);
590 if (!msk)
591 return ret;
592
593 sk = (struct sock *)msk;
594
595 attr = info->attrs[MPTCP_PM_ATTR_ADDR];
596 if (local->addr.family == AF_UNSPEC) {
597 NL_SET_ERR_MSG_ATTR(info->extack, attr,
598 "invalid local address family");
599 ret = -EINVAL;
600 goto set_flags_err;
601 }
602
603 attr_rem = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
604 ret = mptcp_pm_parse_addr(attr_rem, info, &rem);
605 if (ret < 0)
606 goto set_flags_err;
607
608 if (rem.family == AF_UNSPEC) {
609 NL_SET_ERR_MSG_ATTR(info->extack, attr_rem,
610 "invalid remote address family");
611 ret = -EINVAL;
612 goto set_flags_err;
613 }
614
615 if (local->flags & MPTCP_PM_ADDR_FLAG_BACKUP)
616 bkup = 1;
617
618 spin_lock_bh(&msk->pm.lock);
619 entry = mptcp_userspace_pm_lookup_addr(msk, &local->addr);
620 if (entry) {
621 if (bkup)
622 entry->flags |= MPTCP_PM_ADDR_FLAG_BACKUP;
623 else
624 entry->flags &= ~MPTCP_PM_ADDR_FLAG_BACKUP;
625 }
626 spin_unlock_bh(&msk->pm.lock);
627
628 lock_sock(sk);
629 ret = mptcp_pm_mp_prio_send_ack(msk, &local->addr, &rem, bkup);
630 release_sock(sk);
631
632 /* mptcp_pm_mp_prio_send_ack() only fails in one case */
633 if (ret < 0)
634 GENL_SET_ERR_MSG(info, "subflow not found");
635
636set_flags_err:
637 sock_put(sk);
638 return ret;
639}
640
641int mptcp_userspace_pm_dump_addr(struct sk_buff *msg,
642 struct netlink_callback *cb)
643{
644 struct id_bitmap {
645 DECLARE_BITMAP(map, MPTCP_PM_MAX_ADDR_ID + 1);
646 } *bitmap;
647 const struct genl_info *info = genl_info_dump(cb);
648 struct mptcp_pm_addr_entry *entry;
649 struct mptcp_sock *msk;
650 int ret = -EINVAL;
651 struct sock *sk;
652
653 BUILD_BUG_ON(sizeof(struct id_bitmap) > sizeof(cb->ctx));
654
655 bitmap = (struct id_bitmap *)cb->ctx;
656
657 msk = mptcp_userspace_pm_get_sock(info);
658 if (!msk)
659 return ret;
660
661 sk = (struct sock *)msk;
662
663 lock_sock(sk);
664 spin_lock_bh(&msk->pm.lock);
665 mptcp_for_each_userspace_pm_addr(msk, entry) {
666 if (test_bit(entry->addr.id, bitmap->map))
667 continue;
668
669 if (mptcp_pm_genl_fill_addr(msg, cb, entry) < 0)
670 break;
671
672 __set_bit(entry->addr.id, bitmap->map);
673 }
674 spin_unlock_bh(&msk->pm.lock);
675 release_sock(sk);
676 ret = msg->len;
677
678 sock_put(sk);
679 return ret;
680}
681
682int mptcp_userspace_pm_get_addr(u8 id, struct mptcp_pm_addr_entry *addr,
683 struct genl_info *info)
684{
685 struct mptcp_pm_addr_entry *entry;
686 struct mptcp_sock *msk;
687 int ret = -EINVAL;
688 struct sock *sk;
689
690 msk = mptcp_userspace_pm_get_sock(info);
691 if (!msk)
692 return ret;
693
694 sk = (struct sock *)msk;
695
696 lock_sock(sk);
697 spin_lock_bh(&msk->pm.lock);
698 entry = mptcp_userspace_pm_lookup_addr_by_id(msk, id);
699 if (entry) {
700 *addr = *entry;
701 ret = 0;
702 }
703 spin_unlock_bh(&msk->pm.lock);
704 release_sock(sk);
705
706 sock_put(sk);
707 return ret;
708}
709
710static struct mptcp_pm_ops mptcp_pm_userspace = {
711 .name = "userspace",
712 .owner = THIS_MODULE,
713};
714
715void __init mptcp_pm_userspace_register(void)
716{
717 mptcp_pm_register(&mptcp_pm_userspace);
718}