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 15 void 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 30 static struct mptcp_pm_addr_entry * 31 mptcp_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 43 static 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 102 append_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 */ 112 static 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 131 static struct mptcp_pm_addr_entry * 132 mptcp_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 143 int 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 165 bool 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 179 static 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 204 int 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 263 static 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 289 remove_err: 290 release_sock(sk); 291 return err; 292 } 293 294 static void 295 mptcp_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 315 int 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; 365 out: 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 375 int 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 450 static 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 496 int 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); 567 release_sock: 568 release_sock(sk); 569 570 destroy_err: 571 sock_put(sk); 572 return err; 573 } 574 575 int 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 636 set_flags_err: 637 sock_put(sk); 638 return ret; 639 } 640 641 int 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 682 int 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 710 static struct mptcp_pm_ops mptcp_pm_userspace = { 711 .name = "userspace", 712 .owner = THIS_MODULE, 713 }; 714 715 void __init mptcp_pm_userspace_register(void) 716 { 717 mptcp_pm_register(&mptcp_pm_userspace); 718 } 719