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