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