1 // SPDX-License-Identifier: GPL-2.0 2 /* Multipath TCP 3 * 4 * Copyright (c) 2020, Red Hat, Inc. 5 */ 6 7 #define pr_fmt(fmt) "MPTCP: " fmt 8 9 #include <linux/inet.h> 10 #include <linux/kernel.h> 11 #include <net/inet_common.h> 12 #include <net/netns/generic.h> 13 #include <net/mptcp.h> 14 15 #include "protocol.h" 16 #include "mib.h" 17 #include "mptcp_pm_gen.h" 18 19 static int pm_nl_pernet_id; 20 21 struct mptcp_pm_add_entry { 22 struct list_head list; 23 struct mptcp_addr_info addr; 24 u8 retrans_times; 25 struct timer_list add_timer; 26 struct mptcp_sock *sock; 27 }; 28 29 struct pm_nl_pernet { 30 /* protects pernet updates */ 31 spinlock_t lock; 32 struct list_head local_addr_list; 33 unsigned int addrs; 34 unsigned int stale_loss_cnt; 35 unsigned int add_addr_signal_max; 36 unsigned int add_addr_accept_max; 37 unsigned int local_addr_max; 38 unsigned int subflows_max; 39 unsigned int next_id; 40 DECLARE_BITMAP(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1); 41 }; 42 43 #define MPTCP_PM_ADDR_MAX 8 44 #define ADD_ADDR_RETRANS_MAX 3 45 46 static struct pm_nl_pernet *pm_nl_get_pernet(const struct net *net) 47 { 48 return net_generic(net, pm_nl_pernet_id); 49 } 50 51 static struct pm_nl_pernet * 52 pm_nl_get_pernet_from_msk(const struct mptcp_sock *msk) 53 { 54 return pm_nl_get_pernet(sock_net((struct sock *)msk)); 55 } 56 57 bool mptcp_addresses_equal(const struct mptcp_addr_info *a, 58 const struct mptcp_addr_info *b, bool use_port) 59 { 60 bool addr_equals = false; 61 62 if (a->family == b->family) { 63 if (a->family == AF_INET) 64 addr_equals = a->addr.s_addr == b->addr.s_addr; 65 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 66 else 67 addr_equals = !ipv6_addr_cmp(&a->addr6, &b->addr6); 68 } else if (a->family == AF_INET) { 69 if (ipv6_addr_v4mapped(&b->addr6)) 70 addr_equals = a->addr.s_addr == b->addr6.s6_addr32[3]; 71 } else if (b->family == AF_INET) { 72 if (ipv6_addr_v4mapped(&a->addr6)) 73 addr_equals = a->addr6.s6_addr32[3] == b->addr.s_addr; 74 #endif 75 } 76 77 if (!addr_equals) 78 return false; 79 if (!use_port) 80 return true; 81 82 return a->port == b->port; 83 } 84 85 void mptcp_local_address(const struct sock_common *skc, struct mptcp_addr_info *addr) 86 { 87 addr->family = skc->skc_family; 88 addr->port = htons(skc->skc_num); 89 if (addr->family == AF_INET) 90 addr->addr.s_addr = skc->skc_rcv_saddr; 91 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 92 else if (addr->family == AF_INET6) 93 addr->addr6 = skc->skc_v6_rcv_saddr; 94 #endif 95 } 96 97 static void remote_address(const struct sock_common *skc, 98 struct mptcp_addr_info *addr) 99 { 100 addr->family = skc->skc_family; 101 addr->port = skc->skc_dport; 102 if (addr->family == AF_INET) 103 addr->addr.s_addr = skc->skc_daddr; 104 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 105 else if (addr->family == AF_INET6) 106 addr->addr6 = skc->skc_v6_daddr; 107 #endif 108 } 109 110 static bool lookup_subflow_by_saddr(const struct list_head *list, 111 const struct mptcp_addr_info *saddr) 112 { 113 struct mptcp_subflow_context *subflow; 114 struct mptcp_addr_info cur; 115 struct sock_common *skc; 116 117 list_for_each_entry(subflow, list, node) { 118 skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow); 119 120 mptcp_local_address(skc, &cur); 121 if (mptcp_addresses_equal(&cur, saddr, saddr->port)) 122 return true; 123 } 124 125 return false; 126 } 127 128 static bool lookup_subflow_by_daddr(const struct list_head *list, 129 const struct mptcp_addr_info *daddr) 130 { 131 struct mptcp_subflow_context *subflow; 132 struct mptcp_addr_info cur; 133 struct sock_common *skc; 134 135 list_for_each_entry(subflow, list, node) { 136 skc = (struct sock_common *)mptcp_subflow_tcp_sock(subflow); 137 138 remote_address(skc, &cur); 139 if (mptcp_addresses_equal(&cur, daddr, daddr->port)) 140 return true; 141 } 142 143 return false; 144 } 145 146 static struct mptcp_pm_addr_entry * 147 select_local_address(const struct pm_nl_pernet *pernet, 148 const struct mptcp_sock *msk) 149 { 150 struct mptcp_pm_addr_entry *entry, *ret = NULL; 151 152 msk_owned_by_me(msk); 153 154 rcu_read_lock(); 155 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) { 156 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW)) 157 continue; 158 159 if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap)) 160 continue; 161 162 ret = entry; 163 break; 164 } 165 rcu_read_unlock(); 166 return ret; 167 } 168 169 static struct mptcp_pm_addr_entry * 170 select_signal_address(struct pm_nl_pernet *pernet, const struct mptcp_sock *msk) 171 { 172 struct mptcp_pm_addr_entry *entry, *ret = NULL; 173 174 rcu_read_lock(); 175 /* do not keep any additional per socket state, just signal 176 * the address list in order. 177 * Note: removal from the local address list during the msk life-cycle 178 * can lead to additional addresses not being announced. 179 */ 180 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) { 181 if (!test_bit(entry->addr.id, msk->pm.id_avail_bitmap)) 182 continue; 183 184 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) 185 continue; 186 187 ret = entry; 188 break; 189 } 190 rcu_read_unlock(); 191 return ret; 192 } 193 194 unsigned int mptcp_pm_get_add_addr_signal_max(const struct mptcp_sock *msk) 195 { 196 const struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk); 197 198 return READ_ONCE(pernet->add_addr_signal_max); 199 } 200 EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_signal_max); 201 202 unsigned int mptcp_pm_get_add_addr_accept_max(const struct mptcp_sock *msk) 203 { 204 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk); 205 206 return READ_ONCE(pernet->add_addr_accept_max); 207 } 208 EXPORT_SYMBOL_GPL(mptcp_pm_get_add_addr_accept_max); 209 210 unsigned int mptcp_pm_get_subflows_max(const struct mptcp_sock *msk) 211 { 212 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk); 213 214 return READ_ONCE(pernet->subflows_max); 215 } 216 EXPORT_SYMBOL_GPL(mptcp_pm_get_subflows_max); 217 218 unsigned int mptcp_pm_get_local_addr_max(const struct mptcp_sock *msk) 219 { 220 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk); 221 222 return READ_ONCE(pernet->local_addr_max); 223 } 224 EXPORT_SYMBOL_GPL(mptcp_pm_get_local_addr_max); 225 226 bool mptcp_pm_nl_check_work_pending(struct mptcp_sock *msk) 227 { 228 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk); 229 230 if (msk->pm.subflows == mptcp_pm_get_subflows_max(msk) || 231 (find_next_and_bit(pernet->id_bitmap, msk->pm.id_avail_bitmap, 232 MPTCP_PM_MAX_ADDR_ID + 1, 0) == MPTCP_PM_MAX_ADDR_ID + 1)) { 233 WRITE_ONCE(msk->pm.work_pending, false); 234 return false; 235 } 236 return true; 237 } 238 239 struct mptcp_pm_add_entry * 240 mptcp_lookup_anno_list_by_saddr(const struct mptcp_sock *msk, 241 const struct mptcp_addr_info *addr) 242 { 243 struct mptcp_pm_add_entry *entry; 244 245 lockdep_assert_held(&msk->pm.lock); 246 247 list_for_each_entry(entry, &msk->pm.anno_list, list) { 248 if (mptcp_addresses_equal(&entry->addr, addr, true)) 249 return entry; 250 } 251 252 return NULL; 253 } 254 255 bool mptcp_pm_sport_in_anno_list(struct mptcp_sock *msk, const struct sock *sk) 256 { 257 struct mptcp_pm_add_entry *entry; 258 struct mptcp_addr_info saddr; 259 bool ret = false; 260 261 mptcp_local_address((struct sock_common *)sk, &saddr); 262 263 spin_lock_bh(&msk->pm.lock); 264 list_for_each_entry(entry, &msk->pm.anno_list, list) { 265 if (mptcp_addresses_equal(&entry->addr, &saddr, true)) { 266 ret = true; 267 goto out; 268 } 269 } 270 271 out: 272 spin_unlock_bh(&msk->pm.lock); 273 return ret; 274 } 275 276 static void mptcp_pm_add_timer(struct timer_list *timer) 277 { 278 struct mptcp_pm_add_entry *entry = from_timer(entry, timer, add_timer); 279 struct mptcp_sock *msk = entry->sock; 280 struct sock *sk = (struct sock *)msk; 281 282 pr_debug("msk=%p", msk); 283 284 if (!msk) 285 return; 286 287 if (inet_sk_state_load(sk) == TCP_CLOSE) 288 return; 289 290 if (!entry->addr.id) 291 return; 292 293 if (mptcp_pm_should_add_signal_addr(msk)) { 294 sk_reset_timer(sk, timer, jiffies + TCP_RTO_MAX / 8); 295 goto out; 296 } 297 298 spin_lock_bh(&msk->pm.lock); 299 300 if (!mptcp_pm_should_add_signal_addr(msk)) { 301 pr_debug("retransmit ADD_ADDR id=%d", entry->addr.id); 302 mptcp_pm_announce_addr(msk, &entry->addr, false); 303 mptcp_pm_add_addr_send_ack(msk); 304 entry->retrans_times++; 305 } 306 307 if (entry->retrans_times < ADD_ADDR_RETRANS_MAX) 308 sk_reset_timer(sk, timer, 309 jiffies + mptcp_get_add_addr_timeout(sock_net(sk))); 310 311 spin_unlock_bh(&msk->pm.lock); 312 313 if (entry->retrans_times == ADD_ADDR_RETRANS_MAX) 314 mptcp_pm_subflow_established(msk); 315 316 out: 317 __sock_put(sk); 318 } 319 320 struct mptcp_pm_add_entry * 321 mptcp_pm_del_add_timer(struct mptcp_sock *msk, 322 const struct mptcp_addr_info *addr, bool check_id) 323 { 324 struct mptcp_pm_add_entry *entry; 325 struct sock *sk = (struct sock *)msk; 326 327 spin_lock_bh(&msk->pm.lock); 328 entry = mptcp_lookup_anno_list_by_saddr(msk, addr); 329 if (entry && (!check_id || entry->addr.id == addr->id)) 330 entry->retrans_times = ADD_ADDR_RETRANS_MAX; 331 spin_unlock_bh(&msk->pm.lock); 332 333 if (entry && (!check_id || entry->addr.id == addr->id)) 334 sk_stop_timer_sync(sk, &entry->add_timer); 335 336 return entry; 337 } 338 339 bool mptcp_pm_alloc_anno_list(struct mptcp_sock *msk, 340 const struct mptcp_addr_info *addr) 341 { 342 struct mptcp_pm_add_entry *add_entry = NULL; 343 struct sock *sk = (struct sock *)msk; 344 struct net *net = sock_net(sk); 345 346 lockdep_assert_held(&msk->pm.lock); 347 348 add_entry = mptcp_lookup_anno_list_by_saddr(msk, addr); 349 350 if (add_entry) { 351 if (mptcp_pm_is_kernel(msk)) 352 return false; 353 354 sk_reset_timer(sk, &add_entry->add_timer, 355 jiffies + mptcp_get_add_addr_timeout(net)); 356 return true; 357 } 358 359 add_entry = kmalloc(sizeof(*add_entry), GFP_ATOMIC); 360 if (!add_entry) 361 return false; 362 363 list_add(&add_entry->list, &msk->pm.anno_list); 364 365 add_entry->addr = *addr; 366 add_entry->sock = msk; 367 add_entry->retrans_times = 0; 368 369 timer_setup(&add_entry->add_timer, mptcp_pm_add_timer, 0); 370 sk_reset_timer(sk, &add_entry->add_timer, 371 jiffies + mptcp_get_add_addr_timeout(net)); 372 373 return true; 374 } 375 376 void mptcp_pm_free_anno_list(struct mptcp_sock *msk) 377 { 378 struct mptcp_pm_add_entry *entry, *tmp; 379 struct sock *sk = (struct sock *)msk; 380 LIST_HEAD(free_list); 381 382 pr_debug("msk=%p", msk); 383 384 spin_lock_bh(&msk->pm.lock); 385 list_splice_init(&msk->pm.anno_list, &free_list); 386 spin_unlock_bh(&msk->pm.lock); 387 388 list_for_each_entry_safe(entry, tmp, &free_list, list) { 389 sk_stop_timer_sync(sk, &entry->add_timer); 390 kfree(entry); 391 } 392 } 393 394 /* Fill all the remote addresses into the array addrs[], 395 * and return the array size. 396 */ 397 static unsigned int fill_remote_addresses_vec(struct mptcp_sock *msk, 398 struct mptcp_addr_info *local, 399 bool fullmesh, 400 struct mptcp_addr_info *addrs) 401 { 402 bool deny_id0 = READ_ONCE(msk->pm.remote_deny_join_id0); 403 struct sock *sk = (struct sock *)msk, *ssk; 404 struct mptcp_subflow_context *subflow; 405 struct mptcp_addr_info remote = { 0 }; 406 unsigned int subflows_max; 407 int i = 0; 408 409 subflows_max = mptcp_pm_get_subflows_max(msk); 410 remote_address((struct sock_common *)sk, &remote); 411 412 /* Non-fullmesh endpoint, fill in the single entry 413 * corresponding to the primary MPC subflow remote address 414 */ 415 if (!fullmesh) { 416 if (deny_id0) 417 return 0; 418 419 if (!mptcp_pm_addr_families_match(sk, local, &remote)) 420 return 0; 421 422 msk->pm.subflows++; 423 addrs[i++] = remote; 424 } else { 425 DECLARE_BITMAP(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1); 426 427 /* Forbid creation of new subflows matching existing 428 * ones, possibly already created by incoming ADD_ADDR 429 */ 430 bitmap_zero(unavail_id, MPTCP_PM_MAX_ADDR_ID + 1); 431 mptcp_for_each_subflow(msk, subflow) 432 if (READ_ONCE(subflow->local_id) == local->id) 433 __set_bit(subflow->remote_id, unavail_id); 434 435 mptcp_for_each_subflow(msk, subflow) { 436 ssk = mptcp_subflow_tcp_sock(subflow); 437 remote_address((struct sock_common *)ssk, &addrs[i]); 438 addrs[i].id = READ_ONCE(subflow->remote_id); 439 if (deny_id0 && !addrs[i].id) 440 continue; 441 442 if (test_bit(addrs[i].id, unavail_id)) 443 continue; 444 445 if (!mptcp_pm_addr_families_match(sk, local, &addrs[i])) 446 continue; 447 448 if (msk->pm.subflows < subflows_max) { 449 /* forbid creating multiple address towards 450 * this id 451 */ 452 __set_bit(addrs[i].id, unavail_id); 453 msk->pm.subflows++; 454 i++; 455 } 456 } 457 } 458 459 return i; 460 } 461 462 static void __mptcp_pm_send_ack(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow, 463 bool prio, bool backup) 464 { 465 struct sock *ssk = mptcp_subflow_tcp_sock(subflow); 466 bool slow; 467 468 pr_debug("send ack for %s", 469 prio ? "mp_prio" : (mptcp_pm_should_add_signal(msk) ? "add_addr" : "rm_addr")); 470 471 slow = lock_sock_fast(ssk); 472 if (prio) { 473 subflow->send_mp_prio = 1; 474 subflow->request_bkup = backup; 475 } 476 477 __mptcp_subflow_send_ack(ssk); 478 unlock_sock_fast(ssk, slow); 479 } 480 481 static void mptcp_pm_send_ack(struct mptcp_sock *msk, struct mptcp_subflow_context *subflow, 482 bool prio, bool backup) 483 { 484 spin_unlock_bh(&msk->pm.lock); 485 __mptcp_pm_send_ack(msk, subflow, prio, backup); 486 spin_lock_bh(&msk->pm.lock); 487 } 488 489 static struct mptcp_pm_addr_entry * 490 __lookup_addr_by_id(struct pm_nl_pernet *pernet, unsigned int id) 491 { 492 struct mptcp_pm_addr_entry *entry; 493 494 list_for_each_entry(entry, &pernet->local_addr_list, list) { 495 if (entry->addr.id == id) 496 return entry; 497 } 498 return NULL; 499 } 500 501 static struct mptcp_pm_addr_entry * 502 __lookup_addr(struct pm_nl_pernet *pernet, const struct mptcp_addr_info *info) 503 { 504 struct mptcp_pm_addr_entry *entry; 505 506 list_for_each_entry(entry, &pernet->local_addr_list, list) { 507 if (mptcp_addresses_equal(&entry->addr, info, entry->addr.port)) 508 return entry; 509 } 510 return NULL; 511 } 512 513 static void mptcp_pm_create_subflow_or_signal_addr(struct mptcp_sock *msk) 514 { 515 struct sock *sk = (struct sock *)msk; 516 struct mptcp_pm_addr_entry *local; 517 unsigned int add_addr_signal_max; 518 unsigned int local_addr_max; 519 struct pm_nl_pernet *pernet; 520 unsigned int subflows_max; 521 522 pernet = pm_nl_get_pernet(sock_net(sk)); 523 524 add_addr_signal_max = mptcp_pm_get_add_addr_signal_max(msk); 525 local_addr_max = mptcp_pm_get_local_addr_max(msk); 526 subflows_max = mptcp_pm_get_subflows_max(msk); 527 528 /* do lazy endpoint usage accounting for the MPC subflows */ 529 if (unlikely(!(msk->pm.status & BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED))) && msk->first) { 530 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(msk->first); 531 struct mptcp_pm_addr_entry *entry; 532 struct mptcp_addr_info mpc_addr; 533 bool backup = false; 534 535 mptcp_local_address((struct sock_common *)msk->first, &mpc_addr); 536 rcu_read_lock(); 537 entry = __lookup_addr(pernet, &mpc_addr); 538 if (entry) { 539 __clear_bit(entry->addr.id, msk->pm.id_avail_bitmap); 540 msk->mpc_endpoint_id = entry->addr.id; 541 backup = !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP); 542 } 543 rcu_read_unlock(); 544 545 if (backup) 546 mptcp_pm_send_ack(msk, subflow, true, backup); 547 548 msk->pm.status |= BIT(MPTCP_PM_MPC_ENDPOINT_ACCOUNTED); 549 } 550 551 pr_debug("local %d:%d signal %d:%d subflows %d:%d\n", 552 msk->pm.local_addr_used, local_addr_max, 553 msk->pm.add_addr_signaled, add_addr_signal_max, 554 msk->pm.subflows, subflows_max); 555 556 /* check first for announce */ 557 if (msk->pm.add_addr_signaled < add_addr_signal_max) { 558 local = select_signal_address(pernet, msk); 559 560 /* due to racing events on both ends we can reach here while 561 * previous add address is still running: if we invoke now 562 * mptcp_pm_announce_addr(), that will fail and the 563 * corresponding id will be marked as used. 564 * Instead let the PM machinery reschedule us when the 565 * current address announce will be completed. 566 */ 567 if (msk->pm.addr_signal & BIT(MPTCP_ADD_ADDR_SIGNAL)) 568 return; 569 570 if (local) { 571 if (mptcp_pm_alloc_anno_list(msk, &local->addr)) { 572 __clear_bit(local->addr.id, msk->pm.id_avail_bitmap); 573 msk->pm.add_addr_signaled++; 574 mptcp_pm_announce_addr(msk, &local->addr, false); 575 mptcp_pm_nl_addr_send_ack(msk); 576 } 577 } 578 } 579 580 /* check if should create a new subflow */ 581 while (msk->pm.local_addr_used < local_addr_max && 582 msk->pm.subflows < subflows_max) { 583 struct mptcp_addr_info addrs[MPTCP_PM_ADDR_MAX]; 584 bool fullmesh; 585 int i, nr; 586 587 local = select_local_address(pernet, msk); 588 if (!local) 589 break; 590 591 fullmesh = !!(local->flags & MPTCP_PM_ADDR_FLAG_FULLMESH); 592 593 msk->pm.local_addr_used++; 594 __clear_bit(local->addr.id, msk->pm.id_avail_bitmap); 595 nr = fill_remote_addresses_vec(msk, &local->addr, fullmesh, addrs); 596 if (nr == 0) 597 continue; 598 599 spin_unlock_bh(&msk->pm.lock); 600 for (i = 0; i < nr; i++) 601 __mptcp_subflow_connect(sk, &local->addr, &addrs[i]); 602 spin_lock_bh(&msk->pm.lock); 603 } 604 mptcp_pm_nl_check_work_pending(msk); 605 } 606 607 static void mptcp_pm_nl_fully_established(struct mptcp_sock *msk) 608 { 609 mptcp_pm_create_subflow_or_signal_addr(msk); 610 } 611 612 static void mptcp_pm_nl_subflow_established(struct mptcp_sock *msk) 613 { 614 mptcp_pm_create_subflow_or_signal_addr(msk); 615 } 616 617 /* Fill all the local addresses into the array addrs[], 618 * and return the array size. 619 */ 620 static unsigned int fill_local_addresses_vec(struct mptcp_sock *msk, 621 struct mptcp_addr_info *remote, 622 struct mptcp_addr_info *addrs) 623 { 624 struct sock *sk = (struct sock *)msk; 625 struct mptcp_pm_addr_entry *entry; 626 struct pm_nl_pernet *pernet; 627 unsigned int subflows_max; 628 int i = 0; 629 630 pernet = pm_nl_get_pernet_from_msk(msk); 631 subflows_max = mptcp_pm_get_subflows_max(msk); 632 633 rcu_read_lock(); 634 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) { 635 if (!(entry->flags & MPTCP_PM_ADDR_FLAG_FULLMESH)) 636 continue; 637 638 if (!mptcp_pm_addr_families_match(sk, &entry->addr, remote)) 639 continue; 640 641 if (msk->pm.subflows < subflows_max) { 642 msk->pm.subflows++; 643 addrs[i++] = entry->addr; 644 } 645 } 646 rcu_read_unlock(); 647 648 /* If the array is empty, fill in the single 649 * 'IPADDRANY' local address 650 */ 651 if (!i) { 652 struct mptcp_addr_info local; 653 654 memset(&local, 0, sizeof(local)); 655 local.family = 656 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 657 remote->family == AF_INET6 && 658 ipv6_addr_v4mapped(&remote->addr6) ? AF_INET : 659 #endif 660 remote->family; 661 662 if (!mptcp_pm_addr_families_match(sk, &local, remote)) 663 return 0; 664 665 msk->pm.subflows++; 666 addrs[i++] = local; 667 } 668 669 return i; 670 } 671 672 static void mptcp_pm_nl_add_addr_received(struct mptcp_sock *msk) 673 { 674 struct mptcp_addr_info addrs[MPTCP_PM_ADDR_MAX]; 675 struct sock *sk = (struct sock *)msk; 676 unsigned int add_addr_accept_max; 677 struct mptcp_addr_info remote; 678 unsigned int subflows_max; 679 bool sf_created = false; 680 int i, nr; 681 682 add_addr_accept_max = mptcp_pm_get_add_addr_accept_max(msk); 683 subflows_max = mptcp_pm_get_subflows_max(msk); 684 685 pr_debug("accepted %d:%d remote family %d", 686 msk->pm.add_addr_accepted, add_addr_accept_max, 687 msk->pm.remote.family); 688 689 remote = msk->pm.remote; 690 mptcp_pm_announce_addr(msk, &remote, true); 691 mptcp_pm_nl_addr_send_ack(msk); 692 693 if (lookup_subflow_by_daddr(&msk->conn_list, &remote)) 694 return; 695 696 /* pick id 0 port, if none is provided the remote address */ 697 if (!remote.port) 698 remote.port = sk->sk_dport; 699 700 /* connect to the specified remote address, using whatever 701 * local address the routing configuration will pick. 702 */ 703 nr = fill_local_addresses_vec(msk, &remote, addrs); 704 if (nr == 0) 705 return; 706 707 spin_unlock_bh(&msk->pm.lock); 708 for (i = 0; i < nr; i++) 709 if (__mptcp_subflow_connect(sk, &addrs[i], &remote) == 0) 710 sf_created = true; 711 spin_lock_bh(&msk->pm.lock); 712 713 if (sf_created) { 714 msk->pm.add_addr_accepted++; 715 if (msk->pm.add_addr_accepted >= add_addr_accept_max || 716 msk->pm.subflows >= subflows_max) 717 WRITE_ONCE(msk->pm.accept_addr, false); 718 } 719 } 720 721 void mptcp_pm_nl_addr_send_ack(struct mptcp_sock *msk) 722 { 723 struct mptcp_subflow_context *subflow; 724 725 msk_owned_by_me(msk); 726 lockdep_assert_held(&msk->pm.lock); 727 728 if (!mptcp_pm_should_add_signal(msk) && 729 !mptcp_pm_should_rm_signal(msk)) 730 return; 731 732 subflow = list_first_entry_or_null(&msk->conn_list, typeof(*subflow), node); 733 if (subflow) 734 mptcp_pm_send_ack(msk, subflow, false, false); 735 } 736 737 int mptcp_pm_nl_mp_prio_send_ack(struct mptcp_sock *msk, 738 struct mptcp_addr_info *addr, 739 struct mptcp_addr_info *rem, 740 u8 bkup) 741 { 742 struct mptcp_subflow_context *subflow; 743 744 pr_debug("bkup=%d", bkup); 745 746 mptcp_for_each_subflow(msk, subflow) { 747 struct sock *ssk = mptcp_subflow_tcp_sock(subflow); 748 struct mptcp_addr_info local, remote; 749 750 mptcp_local_address((struct sock_common *)ssk, &local); 751 if (!mptcp_addresses_equal(&local, addr, addr->port)) 752 continue; 753 754 if (rem && rem->family != AF_UNSPEC) { 755 remote_address((struct sock_common *)ssk, &remote); 756 if (!mptcp_addresses_equal(&remote, rem, rem->port)) 757 continue; 758 } 759 760 __mptcp_pm_send_ack(msk, subflow, true, bkup); 761 return 0; 762 } 763 764 return -EINVAL; 765 } 766 767 static bool mptcp_local_id_match(const struct mptcp_sock *msk, u8 local_id, u8 id) 768 { 769 return local_id == id || (!local_id && msk->mpc_endpoint_id == id); 770 } 771 772 static void mptcp_pm_nl_rm_addr_or_subflow(struct mptcp_sock *msk, 773 const struct mptcp_rm_list *rm_list, 774 enum linux_mptcp_mib_field rm_type) 775 { 776 struct mptcp_subflow_context *subflow, *tmp; 777 struct sock *sk = (struct sock *)msk; 778 u8 i; 779 780 pr_debug("%s rm_list_nr %d", 781 rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow", rm_list->nr); 782 783 msk_owned_by_me(msk); 784 785 if (sk->sk_state == TCP_LISTEN) 786 return; 787 788 if (!rm_list->nr) 789 return; 790 791 if (list_empty(&msk->conn_list)) 792 return; 793 794 for (i = 0; i < rm_list->nr; i++) { 795 u8 rm_id = rm_list->ids[i]; 796 bool removed = false; 797 798 mptcp_for_each_subflow_safe(msk, subflow, tmp) { 799 struct sock *ssk = mptcp_subflow_tcp_sock(subflow); 800 u8 remote_id = READ_ONCE(subflow->remote_id); 801 int how = RCV_SHUTDOWN | SEND_SHUTDOWN; 802 u8 id = subflow_get_local_id(subflow); 803 804 if (rm_type == MPTCP_MIB_RMADDR && remote_id != rm_id) 805 continue; 806 if (rm_type == MPTCP_MIB_RMSUBFLOW && !mptcp_local_id_match(msk, id, rm_id)) 807 continue; 808 809 pr_debug(" -> %s rm_list_ids[%d]=%u local_id=%u remote_id=%u mpc_id=%u", 810 rm_type == MPTCP_MIB_RMADDR ? "address" : "subflow", 811 i, rm_id, id, remote_id, msk->mpc_endpoint_id); 812 spin_unlock_bh(&msk->pm.lock); 813 mptcp_subflow_shutdown(sk, ssk, how); 814 815 /* the following takes care of updating the subflows counter */ 816 mptcp_close_ssk(sk, ssk, subflow); 817 spin_lock_bh(&msk->pm.lock); 818 819 removed = true; 820 if (rm_type == MPTCP_MIB_RMSUBFLOW) 821 __MPTCP_INC_STATS(sock_net(sk), rm_type); 822 } 823 if (rm_type == MPTCP_MIB_RMSUBFLOW) 824 __set_bit(rm_id ? rm_id : msk->mpc_endpoint_id, msk->pm.id_avail_bitmap); 825 else if (rm_type == MPTCP_MIB_RMADDR) 826 __MPTCP_INC_STATS(sock_net(sk), rm_type); 827 if (!removed) 828 continue; 829 830 if (!mptcp_pm_is_kernel(msk)) 831 continue; 832 833 if (rm_type == MPTCP_MIB_RMADDR) { 834 msk->pm.add_addr_accepted--; 835 WRITE_ONCE(msk->pm.accept_addr, true); 836 } else if (rm_type == MPTCP_MIB_RMSUBFLOW) { 837 msk->pm.local_addr_used--; 838 } 839 } 840 } 841 842 static void mptcp_pm_nl_rm_addr_received(struct mptcp_sock *msk) 843 { 844 mptcp_pm_nl_rm_addr_or_subflow(msk, &msk->pm.rm_list_rx, MPTCP_MIB_RMADDR); 845 } 846 847 void mptcp_pm_nl_rm_subflow_received(struct mptcp_sock *msk, 848 const struct mptcp_rm_list *rm_list) 849 { 850 mptcp_pm_nl_rm_addr_or_subflow(msk, rm_list, MPTCP_MIB_RMSUBFLOW); 851 } 852 853 void mptcp_pm_nl_work(struct mptcp_sock *msk) 854 { 855 struct mptcp_pm_data *pm = &msk->pm; 856 857 msk_owned_by_me(msk); 858 859 if (!(pm->status & MPTCP_PM_WORK_MASK)) 860 return; 861 862 spin_lock_bh(&msk->pm.lock); 863 864 pr_debug("msk=%p status=%x", msk, pm->status); 865 if (pm->status & BIT(MPTCP_PM_ADD_ADDR_RECEIVED)) { 866 pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_RECEIVED); 867 mptcp_pm_nl_add_addr_received(msk); 868 } 869 if (pm->status & BIT(MPTCP_PM_ADD_ADDR_SEND_ACK)) { 870 pm->status &= ~BIT(MPTCP_PM_ADD_ADDR_SEND_ACK); 871 mptcp_pm_nl_addr_send_ack(msk); 872 } 873 if (pm->status & BIT(MPTCP_PM_RM_ADDR_RECEIVED)) { 874 pm->status &= ~BIT(MPTCP_PM_RM_ADDR_RECEIVED); 875 mptcp_pm_nl_rm_addr_received(msk); 876 } 877 if (pm->status & BIT(MPTCP_PM_ESTABLISHED)) { 878 pm->status &= ~BIT(MPTCP_PM_ESTABLISHED); 879 mptcp_pm_nl_fully_established(msk); 880 } 881 if (pm->status & BIT(MPTCP_PM_SUBFLOW_ESTABLISHED)) { 882 pm->status &= ~BIT(MPTCP_PM_SUBFLOW_ESTABLISHED); 883 mptcp_pm_nl_subflow_established(msk); 884 } 885 886 spin_unlock_bh(&msk->pm.lock); 887 } 888 889 static bool address_use_port(struct mptcp_pm_addr_entry *entry) 890 { 891 return (entry->flags & 892 (MPTCP_PM_ADDR_FLAG_SIGNAL | MPTCP_PM_ADDR_FLAG_SUBFLOW)) == 893 MPTCP_PM_ADDR_FLAG_SIGNAL; 894 } 895 896 /* caller must ensure the RCU grace period is already elapsed */ 897 static void __mptcp_pm_release_addr_entry(struct mptcp_pm_addr_entry *entry) 898 { 899 if (entry->lsk) 900 sock_release(entry->lsk); 901 kfree(entry); 902 } 903 904 static int mptcp_pm_nl_append_new_local_addr(struct pm_nl_pernet *pernet, 905 struct mptcp_pm_addr_entry *entry, 906 bool needs_id) 907 { 908 struct mptcp_pm_addr_entry *cur, *del_entry = NULL; 909 unsigned int addr_max; 910 int ret = -EINVAL; 911 912 spin_lock_bh(&pernet->lock); 913 /* to keep the code simple, don't do IDR-like allocation for address ID, 914 * just bail when we exceed limits 915 */ 916 if (pernet->next_id == MPTCP_PM_MAX_ADDR_ID) 917 pernet->next_id = 1; 918 if (pernet->addrs >= MPTCP_PM_ADDR_MAX) { 919 ret = -ERANGE; 920 goto out; 921 } 922 if (test_bit(entry->addr.id, pernet->id_bitmap)) { 923 ret = -EBUSY; 924 goto out; 925 } 926 927 /* do not insert duplicate address, differentiate on port only 928 * singled addresses 929 */ 930 if (!address_use_port(entry)) 931 entry->addr.port = 0; 932 list_for_each_entry(cur, &pernet->local_addr_list, list) { 933 if (mptcp_addresses_equal(&cur->addr, &entry->addr, 934 cur->addr.port || entry->addr.port)) { 935 /* allow replacing the exiting endpoint only if such 936 * endpoint is an implicit one and the user-space 937 * did not provide an endpoint id 938 */ 939 if (!(cur->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT)) { 940 ret = -EEXIST; 941 goto out; 942 } 943 if (entry->addr.id) 944 goto out; 945 946 pernet->addrs--; 947 entry->addr.id = cur->addr.id; 948 list_del_rcu(&cur->list); 949 del_entry = cur; 950 break; 951 } 952 } 953 954 if (!entry->addr.id && needs_id) { 955 find_next: 956 entry->addr.id = find_next_zero_bit(pernet->id_bitmap, 957 MPTCP_PM_MAX_ADDR_ID + 1, 958 pernet->next_id); 959 if (!entry->addr.id && pernet->next_id != 1) { 960 pernet->next_id = 1; 961 goto find_next; 962 } 963 } 964 965 if (!entry->addr.id && needs_id) 966 goto out; 967 968 __set_bit(entry->addr.id, pernet->id_bitmap); 969 if (entry->addr.id > pernet->next_id) 970 pernet->next_id = entry->addr.id; 971 972 if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) { 973 addr_max = pernet->add_addr_signal_max; 974 WRITE_ONCE(pernet->add_addr_signal_max, addr_max + 1); 975 } 976 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) { 977 addr_max = pernet->local_addr_max; 978 WRITE_ONCE(pernet->local_addr_max, addr_max + 1); 979 } 980 981 pernet->addrs++; 982 if (!entry->addr.port) 983 list_add_tail_rcu(&entry->list, &pernet->local_addr_list); 984 else 985 list_add_rcu(&entry->list, &pernet->local_addr_list); 986 ret = entry->addr.id; 987 988 out: 989 spin_unlock_bh(&pernet->lock); 990 991 /* just replaced an existing entry, free it */ 992 if (del_entry) { 993 synchronize_rcu(); 994 __mptcp_pm_release_addr_entry(del_entry); 995 } 996 return ret; 997 } 998 999 static struct lock_class_key mptcp_slock_keys[2]; 1000 static struct lock_class_key mptcp_keys[2]; 1001 1002 static int mptcp_pm_nl_create_listen_socket(struct sock *sk, 1003 struct mptcp_pm_addr_entry *entry) 1004 { 1005 bool is_ipv6 = sk->sk_family == AF_INET6; 1006 int addrlen = sizeof(struct sockaddr_in); 1007 struct sockaddr_storage addr; 1008 struct sock *newsk, *ssk; 1009 int backlog = 1024; 1010 int err; 1011 1012 err = sock_create_kern(sock_net(sk), entry->addr.family, 1013 SOCK_STREAM, IPPROTO_MPTCP, &entry->lsk); 1014 if (err) 1015 return err; 1016 1017 newsk = entry->lsk->sk; 1018 if (!newsk) 1019 return -EINVAL; 1020 1021 /* The subflow socket lock is acquired in a nested to the msk one 1022 * in several places, even by the TCP stack, and this msk is a kernel 1023 * socket: lockdep complains. Instead of propagating the _nested 1024 * modifiers in several places, re-init the lock class for the msk 1025 * socket to an mptcp specific one. 1026 */ 1027 sock_lock_init_class_and_name(newsk, 1028 is_ipv6 ? "mlock-AF_INET6" : "mlock-AF_INET", 1029 &mptcp_slock_keys[is_ipv6], 1030 is_ipv6 ? "msk_lock-AF_INET6" : "msk_lock-AF_INET", 1031 &mptcp_keys[is_ipv6]); 1032 1033 lock_sock(newsk); 1034 ssk = __mptcp_nmpc_sk(mptcp_sk(newsk)); 1035 release_sock(newsk); 1036 if (IS_ERR(ssk)) 1037 return PTR_ERR(ssk); 1038 1039 mptcp_info2sockaddr(&entry->addr, &addr, entry->addr.family); 1040 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1041 if (entry->addr.family == AF_INET6) 1042 addrlen = sizeof(struct sockaddr_in6); 1043 #endif 1044 if (ssk->sk_family == AF_INET) 1045 err = inet_bind_sk(ssk, (struct sockaddr *)&addr, addrlen); 1046 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1047 else if (ssk->sk_family == AF_INET6) 1048 err = inet6_bind_sk(ssk, (struct sockaddr *)&addr, addrlen); 1049 #endif 1050 if (err) 1051 return err; 1052 1053 /* We don't use mptcp_set_state() here because it needs to be called 1054 * under the msk socket lock. For the moment, that will not bring 1055 * anything more than only calling inet_sk_state_store(), because the 1056 * old status is known (TCP_CLOSE). 1057 */ 1058 inet_sk_state_store(newsk, TCP_LISTEN); 1059 lock_sock(ssk); 1060 err = __inet_listen_sk(ssk, backlog); 1061 if (!err) 1062 mptcp_event_pm_listener(ssk, MPTCP_EVENT_LISTENER_CREATED); 1063 release_sock(ssk); 1064 return err; 1065 } 1066 1067 int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk, struct mptcp_addr_info *skc) 1068 { 1069 struct mptcp_pm_addr_entry *entry; 1070 struct pm_nl_pernet *pernet; 1071 int ret = -1; 1072 1073 pernet = pm_nl_get_pernet_from_msk(msk); 1074 1075 rcu_read_lock(); 1076 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) { 1077 if (mptcp_addresses_equal(&entry->addr, skc, entry->addr.port)) { 1078 ret = entry->addr.id; 1079 break; 1080 } 1081 } 1082 rcu_read_unlock(); 1083 if (ret >= 0) 1084 return ret; 1085 1086 /* address not found, add to local list */ 1087 entry = kmalloc(sizeof(*entry), GFP_ATOMIC); 1088 if (!entry) 1089 return -ENOMEM; 1090 1091 entry->addr = *skc; 1092 entry->addr.id = 0; 1093 entry->addr.port = 0; 1094 entry->ifindex = 0; 1095 entry->flags = MPTCP_PM_ADDR_FLAG_IMPLICIT; 1096 entry->lsk = NULL; 1097 ret = mptcp_pm_nl_append_new_local_addr(pernet, entry, true); 1098 if (ret < 0) 1099 kfree(entry); 1100 1101 return ret; 1102 } 1103 1104 bool mptcp_pm_nl_is_backup(struct mptcp_sock *msk, struct mptcp_addr_info *skc) 1105 { 1106 struct pm_nl_pernet *pernet = pm_nl_get_pernet_from_msk(msk); 1107 struct mptcp_pm_addr_entry *entry; 1108 bool backup = false; 1109 1110 rcu_read_lock(); 1111 list_for_each_entry_rcu(entry, &pernet->local_addr_list, list) { 1112 if (mptcp_addresses_equal(&entry->addr, skc, entry->addr.port)) { 1113 backup = !!(entry->flags & MPTCP_PM_ADDR_FLAG_BACKUP); 1114 break; 1115 } 1116 } 1117 rcu_read_unlock(); 1118 1119 return backup; 1120 } 1121 1122 #define MPTCP_PM_CMD_GRP_OFFSET 0 1123 #define MPTCP_PM_EV_GRP_OFFSET 1 1124 1125 static const struct genl_multicast_group mptcp_pm_mcgrps[] = { 1126 [MPTCP_PM_CMD_GRP_OFFSET] = { .name = MPTCP_PM_CMD_GRP_NAME, }, 1127 [MPTCP_PM_EV_GRP_OFFSET] = { .name = MPTCP_PM_EV_GRP_NAME, 1128 .flags = GENL_MCAST_CAP_NET_ADMIN, 1129 }, 1130 }; 1131 1132 void mptcp_pm_nl_subflow_chk_stale(const struct mptcp_sock *msk, struct sock *ssk) 1133 { 1134 struct mptcp_subflow_context *iter, *subflow = mptcp_subflow_ctx(ssk); 1135 struct sock *sk = (struct sock *)msk; 1136 unsigned int active_max_loss_cnt; 1137 struct net *net = sock_net(sk); 1138 unsigned int stale_loss_cnt; 1139 bool slow; 1140 1141 stale_loss_cnt = mptcp_stale_loss_cnt(net); 1142 if (subflow->stale || !stale_loss_cnt || subflow->stale_count <= stale_loss_cnt) 1143 return; 1144 1145 /* look for another available subflow not in loss state */ 1146 active_max_loss_cnt = max_t(int, stale_loss_cnt - 1, 1); 1147 mptcp_for_each_subflow(msk, iter) { 1148 if (iter != subflow && mptcp_subflow_active(iter) && 1149 iter->stale_count < active_max_loss_cnt) { 1150 /* we have some alternatives, try to mark this subflow as idle ...*/ 1151 slow = lock_sock_fast(ssk); 1152 if (!tcp_rtx_and_write_queues_empty(ssk)) { 1153 subflow->stale = 1; 1154 __mptcp_retransmit_pending_data(sk); 1155 MPTCP_INC_STATS(net, MPTCP_MIB_SUBFLOWSTALE); 1156 } 1157 unlock_sock_fast(ssk, slow); 1158 1159 /* always try to push the pending data regardless of re-injections: 1160 * we can possibly use backup subflows now, and subflow selection 1161 * is cheap under the msk socket lock 1162 */ 1163 __mptcp_push_pending(sk, 0); 1164 return; 1165 } 1166 } 1167 } 1168 1169 static int mptcp_pm_family_to_addr(int family) 1170 { 1171 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1172 if (family == AF_INET6) 1173 return MPTCP_PM_ADDR_ATTR_ADDR6; 1174 #endif 1175 return MPTCP_PM_ADDR_ATTR_ADDR4; 1176 } 1177 1178 static int mptcp_pm_parse_pm_addr_attr(struct nlattr *tb[], 1179 const struct nlattr *attr, 1180 struct genl_info *info, 1181 struct mptcp_addr_info *addr, 1182 bool require_family) 1183 { 1184 int err, addr_addr; 1185 1186 if (!attr) { 1187 GENL_SET_ERR_MSG(info, "missing address info"); 1188 return -EINVAL; 1189 } 1190 1191 /* no validation needed - was already done via nested policy */ 1192 err = nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr, 1193 mptcp_pm_address_nl_policy, info->extack); 1194 if (err) 1195 return err; 1196 1197 if (tb[MPTCP_PM_ADDR_ATTR_ID]) 1198 addr->id = nla_get_u8(tb[MPTCP_PM_ADDR_ATTR_ID]); 1199 1200 if (!tb[MPTCP_PM_ADDR_ATTR_FAMILY]) { 1201 if (!require_family) 1202 return 0; 1203 1204 NL_SET_ERR_MSG_ATTR(info->extack, attr, 1205 "missing family"); 1206 return -EINVAL; 1207 } 1208 1209 addr->family = nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_FAMILY]); 1210 if (addr->family != AF_INET 1211 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1212 && addr->family != AF_INET6 1213 #endif 1214 ) { 1215 NL_SET_ERR_MSG_ATTR(info->extack, attr, 1216 "unknown address family"); 1217 return -EINVAL; 1218 } 1219 addr_addr = mptcp_pm_family_to_addr(addr->family); 1220 if (!tb[addr_addr]) { 1221 NL_SET_ERR_MSG_ATTR(info->extack, attr, 1222 "missing address data"); 1223 return -EINVAL; 1224 } 1225 1226 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1227 if (addr->family == AF_INET6) 1228 addr->addr6 = nla_get_in6_addr(tb[addr_addr]); 1229 else 1230 #endif 1231 addr->addr.s_addr = nla_get_in_addr(tb[addr_addr]); 1232 1233 if (tb[MPTCP_PM_ADDR_ATTR_PORT]) 1234 addr->port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT])); 1235 1236 return 0; 1237 } 1238 1239 int mptcp_pm_parse_addr(struct nlattr *attr, struct genl_info *info, 1240 struct mptcp_addr_info *addr) 1241 { 1242 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1]; 1243 1244 memset(addr, 0, sizeof(*addr)); 1245 1246 return mptcp_pm_parse_pm_addr_attr(tb, attr, info, addr, true); 1247 } 1248 1249 int mptcp_pm_parse_entry(struct nlattr *attr, struct genl_info *info, 1250 bool require_family, 1251 struct mptcp_pm_addr_entry *entry) 1252 { 1253 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1]; 1254 int err; 1255 1256 memset(entry, 0, sizeof(*entry)); 1257 1258 err = mptcp_pm_parse_pm_addr_attr(tb, attr, info, &entry->addr, require_family); 1259 if (err) 1260 return err; 1261 1262 if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX]) { 1263 u32 val = nla_get_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]); 1264 1265 entry->ifindex = val; 1266 } 1267 1268 if (tb[MPTCP_PM_ADDR_ATTR_FLAGS]) 1269 entry->flags = nla_get_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]); 1270 1271 if (tb[MPTCP_PM_ADDR_ATTR_PORT]) 1272 entry->addr.port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT])); 1273 1274 return 0; 1275 } 1276 1277 static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info) 1278 { 1279 return pm_nl_get_pernet(genl_info_net(info)); 1280 } 1281 1282 static int mptcp_nl_add_subflow_or_signal_addr(struct net *net) 1283 { 1284 struct mptcp_sock *msk; 1285 long s_slot = 0, s_num = 0; 1286 1287 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1288 struct sock *sk = (struct sock *)msk; 1289 1290 if (!READ_ONCE(msk->fully_established) || 1291 mptcp_pm_is_userspace(msk)) 1292 goto next; 1293 1294 lock_sock(sk); 1295 spin_lock_bh(&msk->pm.lock); 1296 mptcp_pm_create_subflow_or_signal_addr(msk); 1297 spin_unlock_bh(&msk->pm.lock); 1298 release_sock(sk); 1299 1300 next: 1301 sock_put(sk); 1302 cond_resched(); 1303 } 1304 1305 return 0; 1306 } 1307 1308 static bool mptcp_pm_has_addr_attr_id(const struct nlattr *attr, 1309 struct genl_info *info) 1310 { 1311 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1]; 1312 1313 if (!nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr, 1314 mptcp_pm_address_nl_policy, info->extack) && 1315 tb[MPTCP_PM_ADDR_ATTR_ID]) 1316 return true; 1317 return false; 1318 } 1319 1320 int mptcp_pm_nl_add_addr_doit(struct sk_buff *skb, struct genl_info *info) 1321 { 1322 struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR]; 1323 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1324 struct mptcp_pm_addr_entry addr, *entry; 1325 int ret; 1326 1327 ret = mptcp_pm_parse_entry(attr, info, true, &addr); 1328 if (ret < 0) 1329 return ret; 1330 1331 if (addr.addr.port && !(addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) { 1332 GENL_SET_ERR_MSG(info, "flags must have signal when using port"); 1333 return -EINVAL; 1334 } 1335 1336 if (addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL && 1337 addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) { 1338 GENL_SET_ERR_MSG(info, "flags mustn't have both signal and fullmesh"); 1339 return -EINVAL; 1340 } 1341 1342 if (addr.flags & MPTCP_PM_ADDR_FLAG_IMPLICIT) { 1343 GENL_SET_ERR_MSG(info, "can't create IMPLICIT endpoint"); 1344 return -EINVAL; 1345 } 1346 1347 entry = kzalloc(sizeof(*entry), GFP_KERNEL_ACCOUNT); 1348 if (!entry) { 1349 GENL_SET_ERR_MSG(info, "can't allocate addr"); 1350 return -ENOMEM; 1351 } 1352 1353 *entry = addr; 1354 if (entry->addr.port) { 1355 ret = mptcp_pm_nl_create_listen_socket(skb->sk, entry); 1356 if (ret) { 1357 GENL_SET_ERR_MSG_FMT(info, "create listen socket error: %d", ret); 1358 goto out_free; 1359 } 1360 } 1361 ret = mptcp_pm_nl_append_new_local_addr(pernet, entry, 1362 !mptcp_pm_has_addr_attr_id(attr, info)); 1363 if (ret < 0) { 1364 GENL_SET_ERR_MSG_FMT(info, "too many addresses or duplicate one: %d", ret); 1365 goto out_free; 1366 } 1367 1368 mptcp_nl_add_subflow_or_signal_addr(sock_net(skb->sk)); 1369 return 0; 1370 1371 out_free: 1372 __mptcp_pm_release_addr_entry(entry); 1373 return ret; 1374 } 1375 1376 int mptcp_pm_nl_get_flags_and_ifindex_by_id(struct mptcp_sock *msk, unsigned int id, 1377 u8 *flags, int *ifindex) 1378 { 1379 struct mptcp_pm_addr_entry *entry; 1380 struct sock *sk = (struct sock *)msk; 1381 struct net *net = sock_net(sk); 1382 1383 rcu_read_lock(); 1384 entry = __lookup_addr_by_id(pm_nl_get_pernet(net), id); 1385 if (entry) { 1386 *flags = entry->flags; 1387 *ifindex = entry->ifindex; 1388 } 1389 rcu_read_unlock(); 1390 1391 return 0; 1392 } 1393 1394 static bool remove_anno_list_by_saddr(struct mptcp_sock *msk, 1395 const struct mptcp_addr_info *addr) 1396 { 1397 struct mptcp_pm_add_entry *entry; 1398 1399 entry = mptcp_pm_del_add_timer(msk, addr, false); 1400 if (entry) { 1401 list_del(&entry->list); 1402 kfree(entry); 1403 return true; 1404 } 1405 1406 return false; 1407 } 1408 1409 static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk, 1410 const struct mptcp_addr_info *addr, 1411 bool force) 1412 { 1413 struct mptcp_rm_list list = { .nr = 0 }; 1414 bool ret; 1415 1416 list.ids[list.nr++] = addr->id; 1417 1418 ret = remove_anno_list_by_saddr(msk, addr); 1419 if (ret || force) { 1420 spin_lock_bh(&msk->pm.lock); 1421 msk->pm.add_addr_signaled -= ret; 1422 mptcp_pm_remove_addr(msk, &list); 1423 spin_unlock_bh(&msk->pm.lock); 1424 } 1425 return ret; 1426 } 1427 1428 static int mptcp_nl_remove_subflow_and_signal_addr(struct net *net, 1429 const struct mptcp_pm_addr_entry *entry) 1430 { 1431 const struct mptcp_addr_info *addr = &entry->addr; 1432 struct mptcp_rm_list list = { .nr = 0 }; 1433 long s_slot = 0, s_num = 0; 1434 struct mptcp_sock *msk; 1435 1436 pr_debug("remove_id=%d", addr->id); 1437 1438 list.ids[list.nr++] = addr->id; 1439 1440 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1441 struct sock *sk = (struct sock *)msk; 1442 bool remove_subflow; 1443 1444 if (mptcp_pm_is_userspace(msk)) 1445 goto next; 1446 1447 if (list_empty(&msk->conn_list)) { 1448 mptcp_pm_remove_anno_addr(msk, addr, false); 1449 goto next; 1450 } 1451 1452 lock_sock(sk); 1453 remove_subflow = lookup_subflow_by_saddr(&msk->conn_list, addr); 1454 mptcp_pm_remove_anno_addr(msk, addr, remove_subflow && 1455 !(entry->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT)); 1456 if (remove_subflow) 1457 mptcp_pm_remove_subflow(msk, &list); 1458 release_sock(sk); 1459 1460 next: 1461 sock_put(sk); 1462 cond_resched(); 1463 } 1464 1465 return 0; 1466 } 1467 1468 static int mptcp_nl_remove_id_zero_address(struct net *net, 1469 struct mptcp_addr_info *addr) 1470 { 1471 struct mptcp_rm_list list = { .nr = 0 }; 1472 long s_slot = 0, s_num = 0; 1473 struct mptcp_sock *msk; 1474 1475 list.ids[list.nr++] = 0; 1476 1477 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1478 struct sock *sk = (struct sock *)msk; 1479 struct mptcp_addr_info msk_local; 1480 1481 if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk)) 1482 goto next; 1483 1484 mptcp_local_address((struct sock_common *)msk, &msk_local); 1485 if (!mptcp_addresses_equal(&msk_local, addr, addr->port)) 1486 goto next; 1487 1488 lock_sock(sk); 1489 spin_lock_bh(&msk->pm.lock); 1490 mptcp_pm_remove_addr(msk, &list); 1491 mptcp_pm_nl_rm_subflow_received(msk, &list); 1492 spin_unlock_bh(&msk->pm.lock); 1493 release_sock(sk); 1494 1495 next: 1496 sock_put(sk); 1497 cond_resched(); 1498 } 1499 1500 return 0; 1501 } 1502 1503 int mptcp_pm_nl_del_addr_doit(struct sk_buff *skb, struct genl_info *info) 1504 { 1505 struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR]; 1506 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1507 struct mptcp_pm_addr_entry addr, *entry; 1508 unsigned int addr_max; 1509 int ret; 1510 1511 ret = mptcp_pm_parse_entry(attr, info, false, &addr); 1512 if (ret < 0) 1513 return ret; 1514 1515 /* the zero id address is special: the first address used by the msk 1516 * always gets such an id, so different subflows can have different zero 1517 * id addresses. Additionally zero id is not accounted for in id_bitmap. 1518 * Let's use an 'mptcp_rm_list' instead of the common remove code. 1519 */ 1520 if (addr.addr.id == 0) 1521 return mptcp_nl_remove_id_zero_address(sock_net(skb->sk), &addr.addr); 1522 1523 spin_lock_bh(&pernet->lock); 1524 entry = __lookup_addr_by_id(pernet, addr.addr.id); 1525 if (!entry) { 1526 GENL_SET_ERR_MSG(info, "address not found"); 1527 spin_unlock_bh(&pernet->lock); 1528 return -EINVAL; 1529 } 1530 if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) { 1531 addr_max = pernet->add_addr_signal_max; 1532 WRITE_ONCE(pernet->add_addr_signal_max, addr_max - 1); 1533 } 1534 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) { 1535 addr_max = pernet->local_addr_max; 1536 WRITE_ONCE(pernet->local_addr_max, addr_max - 1); 1537 } 1538 1539 pernet->addrs--; 1540 list_del_rcu(&entry->list); 1541 __clear_bit(entry->addr.id, pernet->id_bitmap); 1542 spin_unlock_bh(&pernet->lock); 1543 1544 mptcp_nl_remove_subflow_and_signal_addr(sock_net(skb->sk), entry); 1545 synchronize_rcu(); 1546 __mptcp_pm_release_addr_entry(entry); 1547 1548 return ret; 1549 } 1550 1551 void mptcp_pm_remove_addrs(struct mptcp_sock *msk, struct list_head *rm_list) 1552 { 1553 struct mptcp_rm_list alist = { .nr = 0 }; 1554 struct mptcp_pm_addr_entry *entry; 1555 int anno_nr = 0; 1556 1557 list_for_each_entry(entry, rm_list, list) { 1558 if (alist.nr >= MPTCP_RM_IDS_MAX) 1559 break; 1560 1561 /* only delete if either announced or matching a subflow */ 1562 if (remove_anno_list_by_saddr(msk, &entry->addr)) 1563 anno_nr++; 1564 else if (!lookup_subflow_by_saddr(&msk->conn_list, 1565 &entry->addr)) 1566 continue; 1567 1568 alist.ids[alist.nr++] = entry->addr.id; 1569 } 1570 1571 if (alist.nr) { 1572 spin_lock_bh(&msk->pm.lock); 1573 msk->pm.add_addr_signaled -= anno_nr; 1574 mptcp_pm_remove_addr(msk, &alist); 1575 spin_unlock_bh(&msk->pm.lock); 1576 } 1577 } 1578 1579 static void mptcp_pm_remove_addrs_and_subflows(struct mptcp_sock *msk, 1580 struct list_head *rm_list) 1581 { 1582 struct mptcp_rm_list alist = { .nr = 0 }, slist = { .nr = 0 }; 1583 struct mptcp_pm_addr_entry *entry; 1584 1585 list_for_each_entry(entry, rm_list, list) { 1586 if (slist.nr < MPTCP_RM_IDS_MAX && 1587 lookup_subflow_by_saddr(&msk->conn_list, &entry->addr)) 1588 slist.ids[slist.nr++] = entry->addr.id; 1589 1590 if (alist.nr < MPTCP_RM_IDS_MAX && 1591 remove_anno_list_by_saddr(msk, &entry->addr)) 1592 alist.ids[alist.nr++] = entry->addr.id; 1593 } 1594 1595 if (alist.nr) { 1596 spin_lock_bh(&msk->pm.lock); 1597 msk->pm.add_addr_signaled -= alist.nr; 1598 mptcp_pm_remove_addr(msk, &alist); 1599 spin_unlock_bh(&msk->pm.lock); 1600 } 1601 if (slist.nr) 1602 mptcp_pm_remove_subflow(msk, &slist); 1603 } 1604 1605 static void mptcp_nl_remove_addrs_list(struct net *net, 1606 struct list_head *rm_list) 1607 { 1608 long s_slot = 0, s_num = 0; 1609 struct mptcp_sock *msk; 1610 1611 if (list_empty(rm_list)) 1612 return; 1613 1614 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1615 struct sock *sk = (struct sock *)msk; 1616 1617 if (!mptcp_pm_is_userspace(msk)) { 1618 lock_sock(sk); 1619 mptcp_pm_remove_addrs_and_subflows(msk, rm_list); 1620 release_sock(sk); 1621 } 1622 1623 sock_put(sk); 1624 cond_resched(); 1625 } 1626 } 1627 1628 /* caller must ensure the RCU grace period is already elapsed */ 1629 static void __flush_addrs(struct list_head *list) 1630 { 1631 while (!list_empty(list)) { 1632 struct mptcp_pm_addr_entry *cur; 1633 1634 cur = list_entry(list->next, 1635 struct mptcp_pm_addr_entry, list); 1636 list_del_rcu(&cur->list); 1637 __mptcp_pm_release_addr_entry(cur); 1638 } 1639 } 1640 1641 static void __reset_counters(struct pm_nl_pernet *pernet) 1642 { 1643 WRITE_ONCE(pernet->add_addr_signal_max, 0); 1644 WRITE_ONCE(pernet->add_addr_accept_max, 0); 1645 WRITE_ONCE(pernet->local_addr_max, 0); 1646 pernet->addrs = 0; 1647 } 1648 1649 int mptcp_pm_nl_flush_addrs_doit(struct sk_buff *skb, struct genl_info *info) 1650 { 1651 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1652 LIST_HEAD(free_list); 1653 1654 spin_lock_bh(&pernet->lock); 1655 list_splice_init(&pernet->local_addr_list, &free_list); 1656 __reset_counters(pernet); 1657 pernet->next_id = 1; 1658 bitmap_zero(pernet->id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1); 1659 spin_unlock_bh(&pernet->lock); 1660 mptcp_nl_remove_addrs_list(sock_net(skb->sk), &free_list); 1661 synchronize_rcu(); 1662 __flush_addrs(&free_list); 1663 return 0; 1664 } 1665 1666 int mptcp_nl_fill_addr(struct sk_buff *skb, 1667 struct mptcp_pm_addr_entry *entry) 1668 { 1669 struct mptcp_addr_info *addr = &entry->addr; 1670 struct nlattr *attr; 1671 1672 attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR); 1673 if (!attr) 1674 return -EMSGSIZE; 1675 1676 if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FAMILY, addr->family)) 1677 goto nla_put_failure; 1678 if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_PORT, ntohs(addr->port))) 1679 goto nla_put_failure; 1680 if (nla_put_u8(skb, MPTCP_PM_ADDR_ATTR_ID, addr->id)) 1681 goto nla_put_failure; 1682 if (nla_put_u32(skb, MPTCP_PM_ADDR_ATTR_FLAGS, entry->flags)) 1683 goto nla_put_failure; 1684 if (entry->ifindex && 1685 nla_put_s32(skb, MPTCP_PM_ADDR_ATTR_IF_IDX, entry->ifindex)) 1686 goto nla_put_failure; 1687 1688 if (addr->family == AF_INET && 1689 nla_put_in_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR4, 1690 addr->addr.s_addr)) 1691 goto nla_put_failure; 1692 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1693 else if (addr->family == AF_INET6 && 1694 nla_put_in6_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR6, &addr->addr6)) 1695 goto nla_put_failure; 1696 #endif 1697 nla_nest_end(skb, attr); 1698 return 0; 1699 1700 nla_put_failure: 1701 nla_nest_cancel(skb, attr); 1702 return -EMSGSIZE; 1703 } 1704 1705 int mptcp_pm_nl_get_addr(struct sk_buff *skb, struct genl_info *info) 1706 { 1707 struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR]; 1708 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1709 struct mptcp_pm_addr_entry addr, *entry; 1710 struct sk_buff *msg; 1711 void *reply; 1712 int ret; 1713 1714 ret = mptcp_pm_parse_entry(attr, info, false, &addr); 1715 if (ret < 0) 1716 return ret; 1717 1718 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1719 if (!msg) 1720 return -ENOMEM; 1721 1722 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0, 1723 info->genlhdr->cmd); 1724 if (!reply) { 1725 GENL_SET_ERR_MSG(info, "not enough space in Netlink message"); 1726 ret = -EMSGSIZE; 1727 goto fail; 1728 } 1729 1730 spin_lock_bh(&pernet->lock); 1731 entry = __lookup_addr_by_id(pernet, addr.addr.id); 1732 if (!entry) { 1733 GENL_SET_ERR_MSG(info, "address not found"); 1734 ret = -EINVAL; 1735 goto unlock_fail; 1736 } 1737 1738 ret = mptcp_nl_fill_addr(msg, entry); 1739 if (ret) 1740 goto unlock_fail; 1741 1742 genlmsg_end(msg, reply); 1743 ret = genlmsg_reply(msg, info); 1744 spin_unlock_bh(&pernet->lock); 1745 return ret; 1746 1747 unlock_fail: 1748 spin_unlock_bh(&pernet->lock); 1749 1750 fail: 1751 nlmsg_free(msg); 1752 return ret; 1753 } 1754 1755 int mptcp_pm_nl_get_addr_doit(struct sk_buff *skb, struct genl_info *info) 1756 { 1757 return mptcp_pm_get_addr(skb, info); 1758 } 1759 1760 int mptcp_pm_nl_dump_addr(struct sk_buff *msg, 1761 struct netlink_callback *cb) 1762 { 1763 struct net *net = sock_net(msg->sk); 1764 struct mptcp_pm_addr_entry *entry; 1765 struct pm_nl_pernet *pernet; 1766 int id = cb->args[0]; 1767 void *hdr; 1768 int i; 1769 1770 pernet = pm_nl_get_pernet(net); 1771 1772 spin_lock_bh(&pernet->lock); 1773 for (i = id; i < MPTCP_PM_MAX_ADDR_ID + 1; i++) { 1774 if (test_bit(i, pernet->id_bitmap)) { 1775 entry = __lookup_addr_by_id(pernet, i); 1776 if (!entry) 1777 break; 1778 1779 if (entry->addr.id <= id) 1780 continue; 1781 1782 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, 1783 cb->nlh->nlmsg_seq, &mptcp_genl_family, 1784 NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR); 1785 if (!hdr) 1786 break; 1787 1788 if (mptcp_nl_fill_addr(msg, entry) < 0) { 1789 genlmsg_cancel(msg, hdr); 1790 break; 1791 } 1792 1793 id = entry->addr.id; 1794 genlmsg_end(msg, hdr); 1795 } 1796 } 1797 spin_unlock_bh(&pernet->lock); 1798 1799 cb->args[0] = id; 1800 return msg->len; 1801 } 1802 1803 int mptcp_pm_nl_get_addr_dumpit(struct sk_buff *msg, 1804 struct netlink_callback *cb) 1805 { 1806 return mptcp_pm_dump_addr(msg, cb); 1807 } 1808 1809 static int parse_limit(struct genl_info *info, int id, unsigned int *limit) 1810 { 1811 struct nlattr *attr = info->attrs[id]; 1812 1813 if (!attr) 1814 return 0; 1815 1816 *limit = nla_get_u32(attr); 1817 if (*limit > MPTCP_PM_ADDR_MAX) { 1818 GENL_SET_ERR_MSG(info, "limit greater than maximum"); 1819 return -EINVAL; 1820 } 1821 return 0; 1822 } 1823 1824 int mptcp_pm_nl_set_limits_doit(struct sk_buff *skb, struct genl_info *info) 1825 { 1826 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1827 unsigned int rcv_addrs, subflows; 1828 int ret; 1829 1830 spin_lock_bh(&pernet->lock); 1831 rcv_addrs = pernet->add_addr_accept_max; 1832 ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs); 1833 if (ret) 1834 goto unlock; 1835 1836 subflows = pernet->subflows_max; 1837 ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows); 1838 if (ret) 1839 goto unlock; 1840 1841 WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs); 1842 WRITE_ONCE(pernet->subflows_max, subflows); 1843 1844 unlock: 1845 spin_unlock_bh(&pernet->lock); 1846 return ret; 1847 } 1848 1849 int mptcp_pm_nl_get_limits_doit(struct sk_buff *skb, struct genl_info *info) 1850 { 1851 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1852 struct sk_buff *msg; 1853 void *reply; 1854 1855 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1856 if (!msg) 1857 return -ENOMEM; 1858 1859 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0, 1860 MPTCP_PM_CMD_GET_LIMITS); 1861 if (!reply) 1862 goto fail; 1863 1864 if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS, 1865 READ_ONCE(pernet->add_addr_accept_max))) 1866 goto fail; 1867 1868 if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS, 1869 READ_ONCE(pernet->subflows_max))) 1870 goto fail; 1871 1872 genlmsg_end(msg, reply); 1873 return genlmsg_reply(msg, info); 1874 1875 fail: 1876 GENL_SET_ERR_MSG(info, "not enough space in Netlink message"); 1877 nlmsg_free(msg); 1878 return -EMSGSIZE; 1879 } 1880 1881 static void mptcp_pm_nl_fullmesh(struct mptcp_sock *msk, 1882 struct mptcp_addr_info *addr) 1883 { 1884 struct mptcp_rm_list list = { .nr = 0 }; 1885 1886 list.ids[list.nr++] = addr->id; 1887 1888 spin_lock_bh(&msk->pm.lock); 1889 mptcp_pm_nl_rm_subflow_received(msk, &list); 1890 mptcp_pm_create_subflow_or_signal_addr(msk); 1891 spin_unlock_bh(&msk->pm.lock); 1892 } 1893 1894 static int mptcp_nl_set_flags(struct net *net, 1895 struct mptcp_addr_info *addr, 1896 u8 bkup, u8 changed) 1897 { 1898 long s_slot = 0, s_num = 0; 1899 struct mptcp_sock *msk; 1900 int ret = -EINVAL; 1901 1902 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1903 struct sock *sk = (struct sock *)msk; 1904 1905 if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk)) 1906 goto next; 1907 1908 lock_sock(sk); 1909 if (changed & MPTCP_PM_ADDR_FLAG_BACKUP) 1910 ret = mptcp_pm_nl_mp_prio_send_ack(msk, addr, NULL, bkup); 1911 if (changed & MPTCP_PM_ADDR_FLAG_FULLMESH) 1912 mptcp_pm_nl_fullmesh(msk, addr); 1913 release_sock(sk); 1914 1915 next: 1916 sock_put(sk); 1917 cond_resched(); 1918 } 1919 1920 return ret; 1921 } 1922 1923 int mptcp_pm_nl_set_flags(struct sk_buff *skb, struct genl_info *info) 1924 { 1925 struct mptcp_pm_addr_entry addr = { .addr = { .family = AF_UNSPEC }, }; 1926 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR]; 1927 u8 changed, mask = MPTCP_PM_ADDR_FLAG_BACKUP | 1928 MPTCP_PM_ADDR_FLAG_FULLMESH; 1929 struct net *net = sock_net(skb->sk); 1930 struct mptcp_pm_addr_entry *entry; 1931 struct pm_nl_pernet *pernet; 1932 u8 lookup_by_id = 0; 1933 u8 bkup = 0; 1934 int ret; 1935 1936 pernet = pm_nl_get_pernet(net); 1937 1938 ret = mptcp_pm_parse_entry(attr, info, false, &addr); 1939 if (ret < 0) 1940 return ret; 1941 1942 if (addr.addr.family == AF_UNSPEC) { 1943 lookup_by_id = 1; 1944 if (!addr.addr.id) { 1945 GENL_SET_ERR_MSG(info, "missing required inputs"); 1946 return -EOPNOTSUPP; 1947 } 1948 } 1949 1950 if (addr.flags & MPTCP_PM_ADDR_FLAG_BACKUP) 1951 bkup = 1; 1952 1953 spin_lock_bh(&pernet->lock); 1954 entry = lookup_by_id ? __lookup_addr_by_id(pernet, addr.addr.id) : 1955 __lookup_addr(pernet, &addr.addr); 1956 if (!entry) { 1957 spin_unlock_bh(&pernet->lock); 1958 GENL_SET_ERR_MSG(info, "address not found"); 1959 return -EINVAL; 1960 } 1961 if ((addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) && 1962 (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) { 1963 spin_unlock_bh(&pernet->lock); 1964 GENL_SET_ERR_MSG(info, "invalid addr flags"); 1965 return -EINVAL; 1966 } 1967 1968 changed = (addr.flags ^ entry->flags) & mask; 1969 entry->flags = (entry->flags & ~mask) | (addr.flags & mask); 1970 addr = *entry; 1971 spin_unlock_bh(&pernet->lock); 1972 1973 mptcp_nl_set_flags(net, &addr.addr, bkup, changed); 1974 return 0; 1975 } 1976 1977 int mptcp_pm_nl_set_flags_doit(struct sk_buff *skb, struct genl_info *info) 1978 { 1979 return mptcp_pm_set_flags(skb, info); 1980 } 1981 1982 static void mptcp_nl_mcast_send(struct net *net, struct sk_buff *nlskb, gfp_t gfp) 1983 { 1984 genlmsg_multicast_netns(&mptcp_genl_family, net, 1985 nlskb, 0, MPTCP_PM_EV_GRP_OFFSET, gfp); 1986 } 1987 1988 bool mptcp_userspace_pm_active(const struct mptcp_sock *msk) 1989 { 1990 return genl_has_listeners(&mptcp_genl_family, 1991 sock_net((const struct sock *)msk), 1992 MPTCP_PM_EV_GRP_OFFSET); 1993 } 1994 1995 static int mptcp_event_add_subflow(struct sk_buff *skb, const struct sock *ssk) 1996 { 1997 const struct inet_sock *issk = inet_sk(ssk); 1998 const struct mptcp_subflow_context *sf; 1999 2000 if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family)) 2001 return -EMSGSIZE; 2002 2003 switch (ssk->sk_family) { 2004 case AF_INET: 2005 if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr)) 2006 return -EMSGSIZE; 2007 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, issk->inet_daddr)) 2008 return -EMSGSIZE; 2009 break; 2010 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 2011 case AF_INET6: { 2012 const struct ipv6_pinfo *np = inet6_sk(ssk); 2013 2014 if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr)) 2015 return -EMSGSIZE; 2016 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &ssk->sk_v6_daddr)) 2017 return -EMSGSIZE; 2018 break; 2019 } 2020 #endif 2021 default: 2022 WARN_ON_ONCE(1); 2023 return -EMSGSIZE; 2024 } 2025 2026 if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport)) 2027 return -EMSGSIZE; 2028 if (nla_put_be16(skb, MPTCP_ATTR_DPORT, issk->inet_dport)) 2029 return -EMSGSIZE; 2030 2031 sf = mptcp_subflow_ctx(ssk); 2032 if (WARN_ON_ONCE(!sf)) 2033 return -EINVAL; 2034 2035 if (nla_put_u8(skb, MPTCP_ATTR_LOC_ID, subflow_get_local_id(sf))) 2036 return -EMSGSIZE; 2037 2038 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, sf->remote_id)) 2039 return -EMSGSIZE; 2040 2041 return 0; 2042 } 2043 2044 static int mptcp_event_put_token_and_ssk(struct sk_buff *skb, 2045 const struct mptcp_sock *msk, 2046 const struct sock *ssk) 2047 { 2048 const struct sock *sk = (const struct sock *)msk; 2049 const struct mptcp_subflow_context *sf; 2050 u8 sk_err; 2051 2052 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token))) 2053 return -EMSGSIZE; 2054 2055 if (mptcp_event_add_subflow(skb, ssk)) 2056 return -EMSGSIZE; 2057 2058 sf = mptcp_subflow_ctx(ssk); 2059 if (WARN_ON_ONCE(!sf)) 2060 return -EINVAL; 2061 2062 if (nla_put_u8(skb, MPTCP_ATTR_BACKUP, sf->backup)) 2063 return -EMSGSIZE; 2064 2065 if (ssk->sk_bound_dev_if && 2066 nla_put_s32(skb, MPTCP_ATTR_IF_IDX, ssk->sk_bound_dev_if)) 2067 return -EMSGSIZE; 2068 2069 sk_err = READ_ONCE(ssk->sk_err); 2070 if (sk_err && sk->sk_state == TCP_ESTABLISHED && 2071 nla_put_u8(skb, MPTCP_ATTR_ERROR, sk_err)) 2072 return -EMSGSIZE; 2073 2074 return 0; 2075 } 2076 2077 static int mptcp_event_sub_established(struct sk_buff *skb, 2078 const struct mptcp_sock *msk, 2079 const struct sock *ssk) 2080 { 2081 return mptcp_event_put_token_and_ssk(skb, msk, ssk); 2082 } 2083 2084 static int mptcp_event_sub_closed(struct sk_buff *skb, 2085 const struct mptcp_sock *msk, 2086 const struct sock *ssk) 2087 { 2088 const struct mptcp_subflow_context *sf; 2089 2090 if (mptcp_event_put_token_and_ssk(skb, msk, ssk)) 2091 return -EMSGSIZE; 2092 2093 sf = mptcp_subflow_ctx(ssk); 2094 if (!sf->reset_seen) 2095 return 0; 2096 2097 if (nla_put_u32(skb, MPTCP_ATTR_RESET_REASON, sf->reset_reason)) 2098 return -EMSGSIZE; 2099 2100 if (nla_put_u32(skb, MPTCP_ATTR_RESET_FLAGS, sf->reset_transient)) 2101 return -EMSGSIZE; 2102 2103 return 0; 2104 } 2105 2106 static int mptcp_event_created(struct sk_buff *skb, 2107 const struct mptcp_sock *msk, 2108 const struct sock *ssk) 2109 { 2110 int err = nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)); 2111 2112 if (err) 2113 return err; 2114 2115 if (nla_put_u8(skb, MPTCP_ATTR_SERVER_SIDE, READ_ONCE(msk->pm.server_side))) 2116 return -EMSGSIZE; 2117 2118 return mptcp_event_add_subflow(skb, ssk); 2119 } 2120 2121 void mptcp_event_addr_removed(const struct mptcp_sock *msk, uint8_t id) 2122 { 2123 struct net *net = sock_net((const struct sock *)msk); 2124 struct nlmsghdr *nlh; 2125 struct sk_buff *skb; 2126 2127 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET)) 2128 return; 2129 2130 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 2131 if (!skb) 2132 return; 2133 2134 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, MPTCP_EVENT_REMOVED); 2135 if (!nlh) 2136 goto nla_put_failure; 2137 2138 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token))) 2139 goto nla_put_failure; 2140 2141 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, id)) 2142 goto nla_put_failure; 2143 2144 genlmsg_end(skb, nlh); 2145 mptcp_nl_mcast_send(net, skb, GFP_ATOMIC); 2146 return; 2147 2148 nla_put_failure: 2149 nlmsg_free(skb); 2150 } 2151 2152 void mptcp_event_addr_announced(const struct sock *ssk, 2153 const struct mptcp_addr_info *info) 2154 { 2155 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk); 2156 struct mptcp_sock *msk = mptcp_sk(subflow->conn); 2157 struct net *net = sock_net(ssk); 2158 struct nlmsghdr *nlh; 2159 struct sk_buff *skb; 2160 2161 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET)) 2162 return; 2163 2164 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 2165 if (!skb) 2166 return; 2167 2168 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, 2169 MPTCP_EVENT_ANNOUNCED); 2170 if (!nlh) 2171 goto nla_put_failure; 2172 2173 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token))) 2174 goto nla_put_failure; 2175 2176 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, info->id)) 2177 goto nla_put_failure; 2178 2179 if (nla_put_be16(skb, MPTCP_ATTR_DPORT, 2180 info->port == 0 ? 2181 inet_sk(ssk)->inet_dport : 2182 info->port)) 2183 goto nla_put_failure; 2184 2185 switch (info->family) { 2186 case AF_INET: 2187 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, info->addr.s_addr)) 2188 goto nla_put_failure; 2189 break; 2190 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 2191 case AF_INET6: 2192 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &info->addr6)) 2193 goto nla_put_failure; 2194 break; 2195 #endif 2196 default: 2197 WARN_ON_ONCE(1); 2198 goto nla_put_failure; 2199 } 2200 2201 genlmsg_end(skb, nlh); 2202 mptcp_nl_mcast_send(net, skb, GFP_ATOMIC); 2203 return; 2204 2205 nla_put_failure: 2206 nlmsg_free(skb); 2207 } 2208 2209 void mptcp_event_pm_listener(const struct sock *ssk, 2210 enum mptcp_event_type event) 2211 { 2212 const struct inet_sock *issk = inet_sk(ssk); 2213 struct net *net = sock_net(ssk); 2214 struct nlmsghdr *nlh; 2215 struct sk_buff *skb; 2216 2217 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET)) 2218 return; 2219 2220 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 2221 if (!skb) 2222 return; 2223 2224 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, event); 2225 if (!nlh) 2226 goto nla_put_failure; 2227 2228 if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family)) 2229 goto nla_put_failure; 2230 2231 if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport)) 2232 goto nla_put_failure; 2233 2234 switch (ssk->sk_family) { 2235 case AF_INET: 2236 if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr)) 2237 goto nla_put_failure; 2238 break; 2239 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 2240 case AF_INET6: { 2241 const struct ipv6_pinfo *np = inet6_sk(ssk); 2242 2243 if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr)) 2244 goto nla_put_failure; 2245 break; 2246 } 2247 #endif 2248 default: 2249 WARN_ON_ONCE(1); 2250 goto nla_put_failure; 2251 } 2252 2253 genlmsg_end(skb, nlh); 2254 mptcp_nl_mcast_send(net, skb, GFP_KERNEL); 2255 return; 2256 2257 nla_put_failure: 2258 nlmsg_free(skb); 2259 } 2260 2261 void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk, 2262 const struct sock *ssk, gfp_t gfp) 2263 { 2264 struct net *net = sock_net((const struct sock *)msk); 2265 struct nlmsghdr *nlh; 2266 struct sk_buff *skb; 2267 2268 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET)) 2269 return; 2270 2271 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 2272 if (!skb) 2273 return; 2274 2275 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, type); 2276 if (!nlh) 2277 goto nla_put_failure; 2278 2279 switch (type) { 2280 case MPTCP_EVENT_UNSPEC: 2281 WARN_ON_ONCE(1); 2282 break; 2283 case MPTCP_EVENT_CREATED: 2284 case MPTCP_EVENT_ESTABLISHED: 2285 if (mptcp_event_created(skb, msk, ssk) < 0) 2286 goto nla_put_failure; 2287 break; 2288 case MPTCP_EVENT_CLOSED: 2289 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)) < 0) 2290 goto nla_put_failure; 2291 break; 2292 case MPTCP_EVENT_ANNOUNCED: 2293 case MPTCP_EVENT_REMOVED: 2294 /* call mptcp_event_addr_announced()/removed instead */ 2295 WARN_ON_ONCE(1); 2296 break; 2297 case MPTCP_EVENT_SUB_ESTABLISHED: 2298 case MPTCP_EVENT_SUB_PRIORITY: 2299 if (mptcp_event_sub_established(skb, msk, ssk) < 0) 2300 goto nla_put_failure; 2301 break; 2302 case MPTCP_EVENT_SUB_CLOSED: 2303 if (mptcp_event_sub_closed(skb, msk, ssk) < 0) 2304 goto nla_put_failure; 2305 break; 2306 case MPTCP_EVENT_LISTENER_CREATED: 2307 case MPTCP_EVENT_LISTENER_CLOSED: 2308 break; 2309 } 2310 2311 genlmsg_end(skb, nlh); 2312 mptcp_nl_mcast_send(net, skb, gfp); 2313 return; 2314 2315 nla_put_failure: 2316 nlmsg_free(skb); 2317 } 2318 2319 struct genl_family mptcp_genl_family __ro_after_init = { 2320 .name = MPTCP_PM_NAME, 2321 .version = MPTCP_PM_VER, 2322 .netnsok = true, 2323 .module = THIS_MODULE, 2324 .ops = mptcp_pm_nl_ops, 2325 .n_ops = ARRAY_SIZE(mptcp_pm_nl_ops), 2326 .resv_start_op = MPTCP_PM_CMD_SUBFLOW_DESTROY + 1, 2327 .mcgrps = mptcp_pm_mcgrps, 2328 .n_mcgrps = ARRAY_SIZE(mptcp_pm_mcgrps), 2329 }; 2330 2331 static int __net_init pm_nl_init_net(struct net *net) 2332 { 2333 struct pm_nl_pernet *pernet = pm_nl_get_pernet(net); 2334 2335 INIT_LIST_HEAD_RCU(&pernet->local_addr_list); 2336 2337 /* Cit. 2 subflows ought to be enough for anybody. */ 2338 pernet->subflows_max = 2; 2339 pernet->next_id = 1; 2340 pernet->stale_loss_cnt = 4; 2341 spin_lock_init(&pernet->lock); 2342 2343 /* No need to initialize other pernet fields, the struct is zeroed at 2344 * allocation time. 2345 */ 2346 2347 return 0; 2348 } 2349 2350 static void __net_exit pm_nl_exit_net(struct list_head *net_list) 2351 { 2352 struct net *net; 2353 2354 list_for_each_entry(net, net_list, exit_list) { 2355 struct pm_nl_pernet *pernet = pm_nl_get_pernet(net); 2356 2357 /* net is removed from namespace list, can't race with 2358 * other modifiers, also netns core already waited for a 2359 * RCU grace period. 2360 */ 2361 __flush_addrs(&pernet->local_addr_list); 2362 } 2363 } 2364 2365 static struct pernet_operations mptcp_pm_pernet_ops = { 2366 .init = pm_nl_init_net, 2367 .exit_batch = pm_nl_exit_net, 2368 .id = &pm_nl_pernet_id, 2369 .size = sizeof(struct pm_nl_pernet), 2370 }; 2371 2372 void __init mptcp_pm_nl_init(void) 2373 { 2374 if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0) 2375 panic("Failed to register MPTCP PM pernet subsystem.\n"); 2376 2377 if (genl_register_family(&mptcp_genl_family)) 2378 panic("Failed to register MPTCP PM netlink family\n"); 2379 } 2380