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