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