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 #define MPTCP_PM_CMD_GRP_OFFSET 0 1065 #define MPTCP_PM_EV_GRP_OFFSET 1 1066 1067 static const struct genl_multicast_group mptcp_pm_mcgrps[] = { 1068 [MPTCP_PM_CMD_GRP_OFFSET] = { .name = MPTCP_PM_CMD_GRP_NAME, }, 1069 [MPTCP_PM_EV_GRP_OFFSET] = { .name = MPTCP_PM_EV_GRP_NAME, 1070 .flags = GENL_UNS_ADMIN_PERM, 1071 }, 1072 }; 1073 1074 static const struct nla_policy 1075 mptcp_pm_addr_policy[MPTCP_PM_ADDR_ATTR_MAX + 1] = { 1076 [MPTCP_PM_ADDR_ATTR_FAMILY] = { .type = NLA_U16, }, 1077 [MPTCP_PM_ADDR_ATTR_ID] = { .type = NLA_U8, }, 1078 [MPTCP_PM_ADDR_ATTR_ADDR4] = { .type = NLA_U32, }, 1079 [MPTCP_PM_ADDR_ATTR_ADDR6] = 1080 NLA_POLICY_EXACT_LEN(sizeof(struct in6_addr)), 1081 [MPTCP_PM_ADDR_ATTR_PORT] = { .type = NLA_U16 }, 1082 [MPTCP_PM_ADDR_ATTR_FLAGS] = { .type = NLA_U32 }, 1083 [MPTCP_PM_ADDR_ATTR_IF_IDX] = { .type = NLA_S32 }, 1084 }; 1085 1086 static const struct nla_policy mptcp_pm_policy[MPTCP_PM_ATTR_MAX + 1] = { 1087 [MPTCP_PM_ATTR_ADDR] = 1088 NLA_POLICY_NESTED(mptcp_pm_addr_policy), 1089 [MPTCP_PM_ATTR_RCV_ADD_ADDRS] = { .type = NLA_U32, }, 1090 [MPTCP_PM_ATTR_SUBFLOWS] = { .type = NLA_U32, }, 1091 }; 1092 1093 void mptcp_pm_nl_subflow_chk_stale(const struct mptcp_sock *msk, struct sock *ssk) 1094 { 1095 struct mptcp_subflow_context *iter, *subflow = mptcp_subflow_ctx(ssk); 1096 struct sock *sk = (struct sock *)msk; 1097 unsigned int active_max_loss_cnt; 1098 struct net *net = sock_net(sk); 1099 unsigned int stale_loss_cnt; 1100 bool slow; 1101 1102 stale_loss_cnt = mptcp_stale_loss_cnt(net); 1103 if (subflow->stale || !stale_loss_cnt || subflow->stale_count <= stale_loss_cnt) 1104 return; 1105 1106 /* look for another available subflow not in loss state */ 1107 active_max_loss_cnt = max_t(int, stale_loss_cnt - 1, 1); 1108 mptcp_for_each_subflow(msk, iter) { 1109 if (iter != subflow && mptcp_subflow_active(iter) && 1110 iter->stale_count < active_max_loss_cnt) { 1111 /* we have some alternatives, try to mark this subflow as idle ...*/ 1112 slow = lock_sock_fast(ssk); 1113 if (!tcp_rtx_and_write_queues_empty(ssk)) { 1114 subflow->stale = 1; 1115 __mptcp_retransmit_pending_data(sk); 1116 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_SUBFLOWSTALE); 1117 } 1118 unlock_sock_fast(ssk, slow); 1119 1120 /* always try to push the pending data regarless of re-injections: 1121 * we can possibly use backup subflows now, and subflow selection 1122 * is cheap under the msk socket lock 1123 */ 1124 __mptcp_push_pending(sk, 0); 1125 return; 1126 } 1127 } 1128 } 1129 1130 static int mptcp_pm_family_to_addr(int family) 1131 { 1132 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1133 if (family == AF_INET6) 1134 return MPTCP_PM_ADDR_ATTR_ADDR6; 1135 #endif 1136 return MPTCP_PM_ADDR_ATTR_ADDR4; 1137 } 1138 1139 static int mptcp_pm_parse_addr(struct nlattr *attr, struct genl_info *info, 1140 bool require_family, 1141 struct mptcp_pm_addr_entry *entry) 1142 { 1143 struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1]; 1144 int err, addr_addr; 1145 1146 if (!attr) { 1147 GENL_SET_ERR_MSG(info, "missing address info"); 1148 return -EINVAL; 1149 } 1150 1151 /* no validation needed - was already done via nested policy */ 1152 err = nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr, 1153 mptcp_pm_addr_policy, info->extack); 1154 if (err) 1155 return err; 1156 1157 memset(entry, 0, sizeof(*entry)); 1158 if (!tb[MPTCP_PM_ADDR_ATTR_FAMILY]) { 1159 if (!require_family) 1160 goto skip_family; 1161 1162 NL_SET_ERR_MSG_ATTR(info->extack, attr, 1163 "missing family"); 1164 return -EINVAL; 1165 } 1166 1167 entry->addr.family = nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_FAMILY]); 1168 if (entry->addr.family != AF_INET 1169 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1170 && entry->addr.family != AF_INET6 1171 #endif 1172 ) { 1173 NL_SET_ERR_MSG_ATTR(info->extack, attr, 1174 "unknown address family"); 1175 return -EINVAL; 1176 } 1177 addr_addr = mptcp_pm_family_to_addr(entry->addr.family); 1178 if (!tb[addr_addr]) { 1179 NL_SET_ERR_MSG_ATTR(info->extack, attr, 1180 "missing address data"); 1181 return -EINVAL; 1182 } 1183 1184 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1185 if (entry->addr.family == AF_INET6) 1186 entry->addr.addr6 = nla_get_in6_addr(tb[addr_addr]); 1187 else 1188 #endif 1189 entry->addr.addr.s_addr = nla_get_in_addr(tb[addr_addr]); 1190 1191 skip_family: 1192 if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX]) { 1193 u32 val = nla_get_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]); 1194 1195 entry->ifindex = val; 1196 } 1197 1198 if (tb[MPTCP_PM_ADDR_ATTR_ID]) 1199 entry->addr.id = nla_get_u8(tb[MPTCP_PM_ADDR_ATTR_ID]); 1200 1201 if (tb[MPTCP_PM_ADDR_ATTR_FLAGS]) 1202 entry->flags = nla_get_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]); 1203 1204 if (tb[MPTCP_PM_ADDR_ATTR_PORT]) 1205 entry->addr.port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT])); 1206 1207 return 0; 1208 } 1209 1210 static struct pm_nl_pernet *genl_info_pm_nl(struct genl_info *info) 1211 { 1212 return pm_nl_get_pernet(genl_info_net(info)); 1213 } 1214 1215 static int mptcp_nl_add_subflow_or_signal_addr(struct net *net) 1216 { 1217 struct mptcp_sock *msk; 1218 long s_slot = 0, s_num = 0; 1219 1220 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1221 struct sock *sk = (struct sock *)msk; 1222 1223 if (!READ_ONCE(msk->fully_established) || 1224 mptcp_pm_is_userspace(msk)) 1225 goto next; 1226 1227 lock_sock(sk); 1228 spin_lock_bh(&msk->pm.lock); 1229 mptcp_pm_create_subflow_or_signal_addr(msk); 1230 spin_unlock_bh(&msk->pm.lock); 1231 release_sock(sk); 1232 1233 next: 1234 sock_put(sk); 1235 cond_resched(); 1236 } 1237 1238 return 0; 1239 } 1240 1241 static int mptcp_nl_cmd_add_addr(struct sk_buff *skb, struct genl_info *info) 1242 { 1243 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR]; 1244 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1245 struct mptcp_pm_addr_entry addr, *entry; 1246 int ret; 1247 1248 ret = mptcp_pm_parse_addr(attr, info, true, &addr); 1249 if (ret < 0) 1250 return ret; 1251 1252 if (addr.addr.port && !(addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) { 1253 GENL_SET_ERR_MSG(info, "flags must have signal when using port"); 1254 return -EINVAL; 1255 } 1256 1257 if (addr.flags & MPTCP_PM_ADDR_FLAG_SIGNAL && 1258 addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) { 1259 GENL_SET_ERR_MSG(info, "flags mustn't have both signal and fullmesh"); 1260 return -EINVAL; 1261 } 1262 1263 if (addr.flags & MPTCP_PM_ADDR_FLAG_IMPLICIT) { 1264 GENL_SET_ERR_MSG(info, "can't create IMPLICIT endpoint"); 1265 return -EINVAL; 1266 } 1267 1268 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 1269 if (!entry) { 1270 GENL_SET_ERR_MSG(info, "can't allocate addr"); 1271 return -ENOMEM; 1272 } 1273 1274 *entry = addr; 1275 if (entry->addr.port) { 1276 ret = mptcp_pm_nl_create_listen_socket(skb->sk, entry); 1277 if (ret) { 1278 GENL_SET_ERR_MSG(info, "create listen socket error"); 1279 kfree(entry); 1280 return ret; 1281 } 1282 } 1283 ret = mptcp_pm_nl_append_new_local_addr(pernet, entry); 1284 if (ret < 0) { 1285 GENL_SET_ERR_MSG(info, "too many addresses or duplicate one"); 1286 if (entry->lsk) 1287 sock_release(entry->lsk); 1288 kfree(entry); 1289 return ret; 1290 } 1291 1292 mptcp_nl_add_subflow_or_signal_addr(sock_net(skb->sk)); 1293 1294 return 0; 1295 } 1296 1297 int mptcp_pm_get_flags_and_ifindex_by_id(struct net *net, unsigned int id, 1298 u8 *flags, int *ifindex) 1299 { 1300 struct mptcp_pm_addr_entry *entry; 1301 1302 *flags = 0; 1303 *ifindex = 0; 1304 1305 if (id) { 1306 rcu_read_lock(); 1307 entry = __lookup_addr_by_id(pm_nl_get_pernet(net), id); 1308 if (entry) { 1309 *flags = entry->flags; 1310 *ifindex = entry->ifindex; 1311 } 1312 rcu_read_unlock(); 1313 } 1314 1315 return 0; 1316 } 1317 1318 static bool remove_anno_list_by_saddr(struct mptcp_sock *msk, 1319 const struct mptcp_addr_info *addr) 1320 { 1321 struct mptcp_pm_add_entry *entry; 1322 1323 entry = mptcp_pm_del_add_timer(msk, addr, false); 1324 if (entry) { 1325 list_del(&entry->list); 1326 kfree(entry); 1327 return true; 1328 } 1329 1330 return false; 1331 } 1332 1333 static bool mptcp_pm_remove_anno_addr(struct mptcp_sock *msk, 1334 const struct mptcp_addr_info *addr, 1335 bool force) 1336 { 1337 struct mptcp_rm_list list = { .nr = 0 }; 1338 bool ret; 1339 1340 list.ids[list.nr++] = addr->id; 1341 1342 ret = remove_anno_list_by_saddr(msk, addr); 1343 if (ret || force) { 1344 spin_lock_bh(&msk->pm.lock); 1345 mptcp_pm_remove_addr(msk, &list); 1346 spin_unlock_bh(&msk->pm.lock); 1347 } 1348 return ret; 1349 } 1350 1351 static int mptcp_nl_remove_subflow_and_signal_addr(struct net *net, 1352 const struct mptcp_pm_addr_entry *entry) 1353 { 1354 const struct mptcp_addr_info *addr = &entry->addr; 1355 struct mptcp_rm_list list = { .nr = 0 }; 1356 long s_slot = 0, s_num = 0; 1357 struct mptcp_sock *msk; 1358 1359 pr_debug("remove_id=%d", addr->id); 1360 1361 list.ids[list.nr++] = addr->id; 1362 1363 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1364 struct sock *sk = (struct sock *)msk; 1365 bool remove_subflow; 1366 1367 if (mptcp_pm_is_userspace(msk)) 1368 goto next; 1369 1370 if (list_empty(&msk->conn_list)) { 1371 mptcp_pm_remove_anno_addr(msk, addr, false); 1372 goto next; 1373 } 1374 1375 lock_sock(sk); 1376 remove_subflow = lookup_subflow_by_saddr(&msk->conn_list, addr); 1377 mptcp_pm_remove_anno_addr(msk, addr, remove_subflow && 1378 !(entry->flags & MPTCP_PM_ADDR_FLAG_IMPLICIT)); 1379 if (remove_subflow) 1380 mptcp_pm_remove_subflow(msk, &list); 1381 release_sock(sk); 1382 1383 next: 1384 sock_put(sk); 1385 cond_resched(); 1386 } 1387 1388 return 0; 1389 } 1390 1391 static int mptcp_nl_remove_id_zero_address(struct net *net, 1392 struct mptcp_addr_info *addr) 1393 { 1394 struct mptcp_rm_list list = { .nr = 0 }; 1395 long s_slot = 0, s_num = 0; 1396 struct mptcp_sock *msk; 1397 1398 list.ids[list.nr++] = 0; 1399 1400 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1401 struct sock *sk = (struct sock *)msk; 1402 struct mptcp_addr_info msk_local; 1403 1404 if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk)) 1405 goto next; 1406 1407 local_address((struct sock_common *)msk, &msk_local); 1408 if (!addresses_equal(&msk_local, addr, addr->port)) 1409 goto next; 1410 1411 lock_sock(sk); 1412 spin_lock_bh(&msk->pm.lock); 1413 mptcp_pm_remove_addr(msk, &list); 1414 mptcp_pm_nl_rm_subflow_received(msk, &list); 1415 spin_unlock_bh(&msk->pm.lock); 1416 release_sock(sk); 1417 1418 next: 1419 sock_put(sk); 1420 cond_resched(); 1421 } 1422 1423 return 0; 1424 } 1425 1426 static int mptcp_nl_cmd_del_addr(struct sk_buff *skb, struct genl_info *info) 1427 { 1428 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR]; 1429 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1430 struct mptcp_pm_addr_entry addr, *entry; 1431 unsigned int addr_max; 1432 int ret; 1433 1434 ret = mptcp_pm_parse_addr(attr, info, false, &addr); 1435 if (ret < 0) 1436 return ret; 1437 1438 /* the zero id address is special: the first address used by the msk 1439 * always gets such an id, so different subflows can have different zero 1440 * id addresses. Additionally zero id is not accounted for in id_bitmap. 1441 * Let's use an 'mptcp_rm_list' instead of the common remove code. 1442 */ 1443 if (addr.addr.id == 0) 1444 return mptcp_nl_remove_id_zero_address(sock_net(skb->sk), &addr.addr); 1445 1446 spin_lock_bh(&pernet->lock); 1447 entry = __lookup_addr_by_id(pernet, addr.addr.id); 1448 if (!entry) { 1449 GENL_SET_ERR_MSG(info, "address not found"); 1450 spin_unlock_bh(&pernet->lock); 1451 return -EINVAL; 1452 } 1453 if (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL) { 1454 addr_max = pernet->add_addr_signal_max; 1455 WRITE_ONCE(pernet->add_addr_signal_max, addr_max - 1); 1456 } 1457 if (entry->flags & MPTCP_PM_ADDR_FLAG_SUBFLOW) { 1458 addr_max = pernet->local_addr_max; 1459 WRITE_ONCE(pernet->local_addr_max, addr_max - 1); 1460 } 1461 1462 pernet->addrs--; 1463 list_del_rcu(&entry->list); 1464 __clear_bit(entry->addr.id, pernet->id_bitmap); 1465 spin_unlock_bh(&pernet->lock); 1466 1467 mptcp_nl_remove_subflow_and_signal_addr(sock_net(skb->sk), entry); 1468 synchronize_rcu(); 1469 __mptcp_pm_release_addr_entry(entry); 1470 1471 return ret; 1472 } 1473 1474 static void mptcp_pm_remove_addrs_and_subflows(struct mptcp_sock *msk, 1475 struct list_head *rm_list) 1476 { 1477 struct mptcp_rm_list alist = { .nr = 0 }, slist = { .nr = 0 }; 1478 struct mptcp_pm_addr_entry *entry; 1479 1480 list_for_each_entry(entry, rm_list, list) { 1481 if (lookup_subflow_by_saddr(&msk->conn_list, &entry->addr) && 1482 slist.nr < MPTCP_RM_IDS_MAX) 1483 slist.ids[slist.nr++] = entry->addr.id; 1484 1485 if (remove_anno_list_by_saddr(msk, &entry->addr) && 1486 alist.nr < MPTCP_RM_IDS_MAX) 1487 alist.ids[alist.nr++] = entry->addr.id; 1488 } 1489 1490 if (alist.nr) { 1491 spin_lock_bh(&msk->pm.lock); 1492 mptcp_pm_remove_addr(msk, &alist); 1493 spin_unlock_bh(&msk->pm.lock); 1494 } 1495 if (slist.nr) 1496 mptcp_pm_remove_subflow(msk, &slist); 1497 } 1498 1499 static void mptcp_nl_remove_addrs_list(struct net *net, 1500 struct list_head *rm_list) 1501 { 1502 long s_slot = 0, s_num = 0; 1503 struct mptcp_sock *msk; 1504 1505 if (list_empty(rm_list)) 1506 return; 1507 1508 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1509 struct sock *sk = (struct sock *)msk; 1510 1511 if (!mptcp_pm_is_userspace(msk)) { 1512 lock_sock(sk); 1513 mptcp_pm_remove_addrs_and_subflows(msk, rm_list); 1514 release_sock(sk); 1515 } 1516 1517 sock_put(sk); 1518 cond_resched(); 1519 } 1520 } 1521 1522 /* caller must ensure the RCU grace period is already elapsed */ 1523 static void __flush_addrs(struct list_head *list) 1524 { 1525 while (!list_empty(list)) { 1526 struct mptcp_pm_addr_entry *cur; 1527 1528 cur = list_entry(list->next, 1529 struct mptcp_pm_addr_entry, list); 1530 list_del_rcu(&cur->list); 1531 __mptcp_pm_release_addr_entry(cur); 1532 } 1533 } 1534 1535 static void __reset_counters(struct pm_nl_pernet *pernet) 1536 { 1537 WRITE_ONCE(pernet->add_addr_signal_max, 0); 1538 WRITE_ONCE(pernet->add_addr_accept_max, 0); 1539 WRITE_ONCE(pernet->local_addr_max, 0); 1540 pernet->addrs = 0; 1541 } 1542 1543 static int mptcp_nl_cmd_flush_addrs(struct sk_buff *skb, struct genl_info *info) 1544 { 1545 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1546 LIST_HEAD(free_list); 1547 1548 spin_lock_bh(&pernet->lock); 1549 list_splice_init(&pernet->local_addr_list, &free_list); 1550 __reset_counters(pernet); 1551 pernet->next_id = 1; 1552 bitmap_zero(pernet->id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1); 1553 spin_unlock_bh(&pernet->lock); 1554 mptcp_nl_remove_addrs_list(sock_net(skb->sk), &free_list); 1555 synchronize_rcu(); 1556 __flush_addrs(&free_list); 1557 return 0; 1558 } 1559 1560 static int mptcp_nl_fill_addr(struct sk_buff *skb, 1561 struct mptcp_pm_addr_entry *entry) 1562 { 1563 struct mptcp_addr_info *addr = &entry->addr; 1564 struct nlattr *attr; 1565 1566 attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR); 1567 if (!attr) 1568 return -EMSGSIZE; 1569 1570 if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FAMILY, addr->family)) 1571 goto nla_put_failure; 1572 if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_PORT, ntohs(addr->port))) 1573 goto nla_put_failure; 1574 if (nla_put_u8(skb, MPTCP_PM_ADDR_ATTR_ID, addr->id)) 1575 goto nla_put_failure; 1576 if (nla_put_u32(skb, MPTCP_PM_ADDR_ATTR_FLAGS, entry->flags)) 1577 goto nla_put_failure; 1578 if (entry->ifindex && 1579 nla_put_s32(skb, MPTCP_PM_ADDR_ATTR_IF_IDX, entry->ifindex)) 1580 goto nla_put_failure; 1581 1582 if (addr->family == AF_INET && 1583 nla_put_in_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR4, 1584 addr->addr.s_addr)) 1585 goto nla_put_failure; 1586 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1587 else if (addr->family == AF_INET6 && 1588 nla_put_in6_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR6, &addr->addr6)) 1589 goto nla_put_failure; 1590 #endif 1591 nla_nest_end(skb, attr); 1592 return 0; 1593 1594 nla_put_failure: 1595 nla_nest_cancel(skb, attr); 1596 return -EMSGSIZE; 1597 } 1598 1599 static int mptcp_nl_cmd_get_addr(struct sk_buff *skb, struct genl_info *info) 1600 { 1601 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR]; 1602 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1603 struct mptcp_pm_addr_entry addr, *entry; 1604 struct sk_buff *msg; 1605 void *reply; 1606 int ret; 1607 1608 ret = mptcp_pm_parse_addr(attr, info, false, &addr); 1609 if (ret < 0) 1610 return ret; 1611 1612 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1613 if (!msg) 1614 return -ENOMEM; 1615 1616 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0, 1617 info->genlhdr->cmd); 1618 if (!reply) { 1619 GENL_SET_ERR_MSG(info, "not enough space in Netlink message"); 1620 ret = -EMSGSIZE; 1621 goto fail; 1622 } 1623 1624 spin_lock_bh(&pernet->lock); 1625 entry = __lookup_addr_by_id(pernet, addr.addr.id); 1626 if (!entry) { 1627 GENL_SET_ERR_MSG(info, "address not found"); 1628 ret = -EINVAL; 1629 goto unlock_fail; 1630 } 1631 1632 ret = mptcp_nl_fill_addr(msg, entry); 1633 if (ret) 1634 goto unlock_fail; 1635 1636 genlmsg_end(msg, reply); 1637 ret = genlmsg_reply(msg, info); 1638 spin_unlock_bh(&pernet->lock); 1639 return ret; 1640 1641 unlock_fail: 1642 spin_unlock_bh(&pernet->lock); 1643 1644 fail: 1645 nlmsg_free(msg); 1646 return ret; 1647 } 1648 1649 static int mptcp_nl_cmd_dump_addrs(struct sk_buff *msg, 1650 struct netlink_callback *cb) 1651 { 1652 struct net *net = sock_net(msg->sk); 1653 struct mptcp_pm_addr_entry *entry; 1654 struct pm_nl_pernet *pernet; 1655 int id = cb->args[0]; 1656 void *hdr; 1657 int i; 1658 1659 pernet = pm_nl_get_pernet(net); 1660 1661 spin_lock_bh(&pernet->lock); 1662 for (i = id; i < MPTCP_PM_MAX_ADDR_ID + 1; i++) { 1663 if (test_bit(i, pernet->id_bitmap)) { 1664 entry = __lookup_addr_by_id(pernet, i); 1665 if (!entry) 1666 break; 1667 1668 if (entry->addr.id <= id) 1669 continue; 1670 1671 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, 1672 cb->nlh->nlmsg_seq, &mptcp_genl_family, 1673 NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR); 1674 if (!hdr) 1675 break; 1676 1677 if (mptcp_nl_fill_addr(msg, entry) < 0) { 1678 genlmsg_cancel(msg, hdr); 1679 break; 1680 } 1681 1682 id = entry->addr.id; 1683 genlmsg_end(msg, hdr); 1684 } 1685 } 1686 spin_unlock_bh(&pernet->lock); 1687 1688 cb->args[0] = id; 1689 return msg->len; 1690 } 1691 1692 static int parse_limit(struct genl_info *info, int id, unsigned int *limit) 1693 { 1694 struct nlattr *attr = info->attrs[id]; 1695 1696 if (!attr) 1697 return 0; 1698 1699 *limit = nla_get_u32(attr); 1700 if (*limit > MPTCP_PM_ADDR_MAX) { 1701 GENL_SET_ERR_MSG(info, "limit greater than maximum"); 1702 return -EINVAL; 1703 } 1704 return 0; 1705 } 1706 1707 static int 1708 mptcp_nl_cmd_set_limits(struct sk_buff *skb, struct genl_info *info) 1709 { 1710 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1711 unsigned int rcv_addrs, subflows; 1712 int ret; 1713 1714 spin_lock_bh(&pernet->lock); 1715 rcv_addrs = pernet->add_addr_accept_max; 1716 ret = parse_limit(info, MPTCP_PM_ATTR_RCV_ADD_ADDRS, &rcv_addrs); 1717 if (ret) 1718 goto unlock; 1719 1720 subflows = pernet->subflows_max; 1721 ret = parse_limit(info, MPTCP_PM_ATTR_SUBFLOWS, &subflows); 1722 if (ret) 1723 goto unlock; 1724 1725 WRITE_ONCE(pernet->add_addr_accept_max, rcv_addrs); 1726 WRITE_ONCE(pernet->subflows_max, subflows); 1727 1728 unlock: 1729 spin_unlock_bh(&pernet->lock); 1730 return ret; 1731 } 1732 1733 static int 1734 mptcp_nl_cmd_get_limits(struct sk_buff *skb, struct genl_info *info) 1735 { 1736 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1737 struct sk_buff *msg; 1738 void *reply; 1739 1740 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1741 if (!msg) 1742 return -ENOMEM; 1743 1744 reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0, 1745 MPTCP_PM_CMD_GET_LIMITS); 1746 if (!reply) 1747 goto fail; 1748 1749 if (nla_put_u32(msg, MPTCP_PM_ATTR_RCV_ADD_ADDRS, 1750 READ_ONCE(pernet->add_addr_accept_max))) 1751 goto fail; 1752 1753 if (nla_put_u32(msg, MPTCP_PM_ATTR_SUBFLOWS, 1754 READ_ONCE(pernet->subflows_max))) 1755 goto fail; 1756 1757 genlmsg_end(msg, reply); 1758 return genlmsg_reply(msg, info); 1759 1760 fail: 1761 GENL_SET_ERR_MSG(info, "not enough space in Netlink message"); 1762 nlmsg_free(msg); 1763 return -EMSGSIZE; 1764 } 1765 1766 static void mptcp_pm_nl_fullmesh(struct mptcp_sock *msk, 1767 struct mptcp_addr_info *addr) 1768 { 1769 struct mptcp_rm_list list = { .nr = 0 }; 1770 1771 list.ids[list.nr++] = addr->id; 1772 1773 mptcp_pm_nl_rm_subflow_received(msk, &list); 1774 mptcp_pm_create_subflow_or_signal_addr(msk); 1775 } 1776 1777 static int mptcp_nl_set_flags(struct net *net, 1778 struct mptcp_addr_info *addr, 1779 u8 bkup, u8 changed) 1780 { 1781 long s_slot = 0, s_num = 0; 1782 struct mptcp_sock *msk; 1783 int ret = -EINVAL; 1784 1785 while ((msk = mptcp_token_iter_next(net, &s_slot, &s_num)) != NULL) { 1786 struct sock *sk = (struct sock *)msk; 1787 1788 if (list_empty(&msk->conn_list) || mptcp_pm_is_userspace(msk)) 1789 goto next; 1790 1791 lock_sock(sk); 1792 spin_lock_bh(&msk->pm.lock); 1793 if (changed & MPTCP_PM_ADDR_FLAG_BACKUP) 1794 ret = mptcp_pm_nl_mp_prio_send_ack(msk, addr, bkup); 1795 if (changed & MPTCP_PM_ADDR_FLAG_FULLMESH) 1796 mptcp_pm_nl_fullmesh(msk, addr); 1797 spin_unlock_bh(&msk->pm.lock); 1798 release_sock(sk); 1799 1800 next: 1801 sock_put(sk); 1802 cond_resched(); 1803 } 1804 1805 return ret; 1806 } 1807 1808 static int mptcp_nl_cmd_set_flags(struct sk_buff *skb, struct genl_info *info) 1809 { 1810 struct mptcp_pm_addr_entry addr = { .addr = { .family = AF_UNSPEC }, }, *entry; 1811 struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR]; 1812 struct pm_nl_pernet *pernet = genl_info_pm_nl(info); 1813 u8 changed, mask = MPTCP_PM_ADDR_FLAG_BACKUP | 1814 MPTCP_PM_ADDR_FLAG_FULLMESH; 1815 struct net *net = sock_net(skb->sk); 1816 u8 bkup = 0, lookup_by_id = 0; 1817 int ret; 1818 1819 ret = mptcp_pm_parse_addr(attr, info, false, &addr); 1820 if (ret < 0) 1821 return ret; 1822 1823 if (addr.flags & MPTCP_PM_ADDR_FLAG_BACKUP) 1824 bkup = 1; 1825 if (addr.addr.family == AF_UNSPEC) { 1826 lookup_by_id = 1; 1827 if (!addr.addr.id) 1828 return -EOPNOTSUPP; 1829 } 1830 1831 spin_lock_bh(&pernet->lock); 1832 entry = __lookup_addr(pernet, &addr.addr, lookup_by_id); 1833 if (!entry) { 1834 spin_unlock_bh(&pernet->lock); 1835 return -EINVAL; 1836 } 1837 if ((addr.flags & MPTCP_PM_ADDR_FLAG_FULLMESH) && 1838 (entry->flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) { 1839 spin_unlock_bh(&pernet->lock); 1840 return -EINVAL; 1841 } 1842 1843 changed = (addr.flags ^ entry->flags) & mask; 1844 entry->flags = (entry->flags & ~mask) | (addr.flags & mask); 1845 addr = *entry; 1846 spin_unlock_bh(&pernet->lock); 1847 1848 mptcp_nl_set_flags(net, &addr.addr, bkup, changed); 1849 return 0; 1850 } 1851 1852 static void mptcp_nl_mcast_send(struct net *net, struct sk_buff *nlskb, gfp_t gfp) 1853 { 1854 genlmsg_multicast_netns(&mptcp_genl_family, net, 1855 nlskb, 0, MPTCP_PM_EV_GRP_OFFSET, gfp); 1856 } 1857 1858 static int mptcp_event_add_subflow(struct sk_buff *skb, const struct sock *ssk) 1859 { 1860 const struct inet_sock *issk = inet_sk(ssk); 1861 const struct mptcp_subflow_context *sf; 1862 1863 if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family)) 1864 return -EMSGSIZE; 1865 1866 switch (ssk->sk_family) { 1867 case AF_INET: 1868 if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr)) 1869 return -EMSGSIZE; 1870 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, issk->inet_daddr)) 1871 return -EMSGSIZE; 1872 break; 1873 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 1874 case AF_INET6: { 1875 const struct ipv6_pinfo *np = inet6_sk(ssk); 1876 1877 if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &np->saddr)) 1878 return -EMSGSIZE; 1879 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &ssk->sk_v6_daddr)) 1880 return -EMSGSIZE; 1881 break; 1882 } 1883 #endif 1884 default: 1885 WARN_ON_ONCE(1); 1886 return -EMSGSIZE; 1887 } 1888 1889 if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport)) 1890 return -EMSGSIZE; 1891 if (nla_put_be16(skb, MPTCP_ATTR_DPORT, issk->inet_dport)) 1892 return -EMSGSIZE; 1893 1894 sf = mptcp_subflow_ctx(ssk); 1895 if (WARN_ON_ONCE(!sf)) 1896 return -EINVAL; 1897 1898 if (nla_put_u8(skb, MPTCP_ATTR_LOC_ID, sf->local_id)) 1899 return -EMSGSIZE; 1900 1901 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, sf->remote_id)) 1902 return -EMSGSIZE; 1903 1904 return 0; 1905 } 1906 1907 static int mptcp_event_put_token_and_ssk(struct sk_buff *skb, 1908 const struct mptcp_sock *msk, 1909 const struct sock *ssk) 1910 { 1911 const struct sock *sk = (const struct sock *)msk; 1912 const struct mptcp_subflow_context *sf; 1913 u8 sk_err; 1914 1915 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token)) 1916 return -EMSGSIZE; 1917 1918 if (mptcp_event_add_subflow(skb, ssk)) 1919 return -EMSGSIZE; 1920 1921 sf = mptcp_subflow_ctx(ssk); 1922 if (WARN_ON_ONCE(!sf)) 1923 return -EINVAL; 1924 1925 if (nla_put_u8(skb, MPTCP_ATTR_BACKUP, sf->backup)) 1926 return -EMSGSIZE; 1927 1928 if (ssk->sk_bound_dev_if && 1929 nla_put_s32(skb, MPTCP_ATTR_IF_IDX, ssk->sk_bound_dev_if)) 1930 return -EMSGSIZE; 1931 1932 sk_err = ssk->sk_err; 1933 if (sk_err && sk->sk_state == TCP_ESTABLISHED && 1934 nla_put_u8(skb, MPTCP_ATTR_ERROR, sk_err)) 1935 return -EMSGSIZE; 1936 1937 return 0; 1938 } 1939 1940 static int mptcp_event_sub_established(struct sk_buff *skb, 1941 const struct mptcp_sock *msk, 1942 const struct sock *ssk) 1943 { 1944 return mptcp_event_put_token_and_ssk(skb, msk, ssk); 1945 } 1946 1947 static int mptcp_event_sub_closed(struct sk_buff *skb, 1948 const struct mptcp_sock *msk, 1949 const struct sock *ssk) 1950 { 1951 const struct mptcp_subflow_context *sf; 1952 1953 if (mptcp_event_put_token_and_ssk(skb, msk, ssk)) 1954 return -EMSGSIZE; 1955 1956 sf = mptcp_subflow_ctx(ssk); 1957 if (!sf->reset_seen) 1958 return 0; 1959 1960 if (nla_put_u32(skb, MPTCP_ATTR_RESET_REASON, sf->reset_reason)) 1961 return -EMSGSIZE; 1962 1963 if (nla_put_u32(skb, MPTCP_ATTR_RESET_FLAGS, sf->reset_transient)) 1964 return -EMSGSIZE; 1965 1966 return 0; 1967 } 1968 1969 static int mptcp_event_created(struct sk_buff *skb, 1970 const struct mptcp_sock *msk, 1971 const struct sock *ssk) 1972 { 1973 int err = nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token); 1974 1975 if (err) 1976 return err; 1977 1978 return mptcp_event_add_subflow(skb, ssk); 1979 } 1980 1981 void mptcp_event_addr_removed(const struct mptcp_sock *msk, uint8_t id) 1982 { 1983 struct net *net = sock_net((const struct sock *)msk); 1984 struct nlmsghdr *nlh; 1985 struct sk_buff *skb; 1986 1987 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET)) 1988 return; 1989 1990 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 1991 if (!skb) 1992 return; 1993 1994 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, MPTCP_EVENT_REMOVED); 1995 if (!nlh) 1996 goto nla_put_failure; 1997 1998 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token)) 1999 goto nla_put_failure; 2000 2001 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, id)) 2002 goto nla_put_failure; 2003 2004 genlmsg_end(skb, nlh); 2005 mptcp_nl_mcast_send(net, skb, GFP_ATOMIC); 2006 return; 2007 2008 nla_put_failure: 2009 kfree_skb(skb); 2010 } 2011 2012 void mptcp_event_addr_announced(const struct mptcp_sock *msk, 2013 const struct mptcp_addr_info *info) 2014 { 2015 struct net *net = sock_net((const struct sock *)msk); 2016 struct nlmsghdr *nlh; 2017 struct sk_buff *skb; 2018 2019 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET)) 2020 return; 2021 2022 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 2023 if (!skb) 2024 return; 2025 2026 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, 2027 MPTCP_EVENT_ANNOUNCED); 2028 if (!nlh) 2029 goto nla_put_failure; 2030 2031 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token)) 2032 goto nla_put_failure; 2033 2034 if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, info->id)) 2035 goto nla_put_failure; 2036 2037 if (nla_put_be16(skb, MPTCP_ATTR_DPORT, info->port)) 2038 goto nla_put_failure; 2039 2040 switch (info->family) { 2041 case AF_INET: 2042 if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, info->addr.s_addr)) 2043 goto nla_put_failure; 2044 break; 2045 #if IS_ENABLED(CONFIG_MPTCP_IPV6) 2046 case AF_INET6: 2047 if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &info->addr6)) 2048 goto nla_put_failure; 2049 break; 2050 #endif 2051 default: 2052 WARN_ON_ONCE(1); 2053 goto nla_put_failure; 2054 } 2055 2056 genlmsg_end(skb, nlh); 2057 mptcp_nl_mcast_send(net, skb, GFP_ATOMIC); 2058 return; 2059 2060 nla_put_failure: 2061 kfree_skb(skb); 2062 } 2063 2064 void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk, 2065 const struct sock *ssk, gfp_t gfp) 2066 { 2067 struct net *net = sock_net((const struct sock *)msk); 2068 struct nlmsghdr *nlh; 2069 struct sk_buff *skb; 2070 2071 if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET)) 2072 return; 2073 2074 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 2075 if (!skb) 2076 return; 2077 2078 nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, type); 2079 if (!nlh) 2080 goto nla_put_failure; 2081 2082 switch (type) { 2083 case MPTCP_EVENT_UNSPEC: 2084 WARN_ON_ONCE(1); 2085 break; 2086 case MPTCP_EVENT_CREATED: 2087 case MPTCP_EVENT_ESTABLISHED: 2088 if (mptcp_event_created(skb, msk, ssk) < 0) 2089 goto nla_put_failure; 2090 break; 2091 case MPTCP_EVENT_CLOSED: 2092 if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, msk->token) < 0) 2093 goto nla_put_failure; 2094 break; 2095 case MPTCP_EVENT_ANNOUNCED: 2096 case MPTCP_EVENT_REMOVED: 2097 /* call mptcp_event_addr_announced()/removed instead */ 2098 WARN_ON_ONCE(1); 2099 break; 2100 case MPTCP_EVENT_SUB_ESTABLISHED: 2101 case MPTCP_EVENT_SUB_PRIORITY: 2102 if (mptcp_event_sub_established(skb, msk, ssk) < 0) 2103 goto nla_put_failure; 2104 break; 2105 case MPTCP_EVENT_SUB_CLOSED: 2106 if (mptcp_event_sub_closed(skb, msk, ssk) < 0) 2107 goto nla_put_failure; 2108 break; 2109 } 2110 2111 genlmsg_end(skb, nlh); 2112 mptcp_nl_mcast_send(net, skb, gfp); 2113 return; 2114 2115 nla_put_failure: 2116 kfree_skb(skb); 2117 } 2118 2119 static const struct genl_small_ops mptcp_pm_ops[] = { 2120 { 2121 .cmd = MPTCP_PM_CMD_ADD_ADDR, 2122 .doit = mptcp_nl_cmd_add_addr, 2123 .flags = GENL_ADMIN_PERM, 2124 }, 2125 { 2126 .cmd = MPTCP_PM_CMD_DEL_ADDR, 2127 .doit = mptcp_nl_cmd_del_addr, 2128 .flags = GENL_ADMIN_PERM, 2129 }, 2130 { 2131 .cmd = MPTCP_PM_CMD_FLUSH_ADDRS, 2132 .doit = mptcp_nl_cmd_flush_addrs, 2133 .flags = GENL_ADMIN_PERM, 2134 }, 2135 { 2136 .cmd = MPTCP_PM_CMD_GET_ADDR, 2137 .doit = mptcp_nl_cmd_get_addr, 2138 .dumpit = mptcp_nl_cmd_dump_addrs, 2139 }, 2140 { 2141 .cmd = MPTCP_PM_CMD_SET_LIMITS, 2142 .doit = mptcp_nl_cmd_set_limits, 2143 .flags = GENL_ADMIN_PERM, 2144 }, 2145 { 2146 .cmd = MPTCP_PM_CMD_GET_LIMITS, 2147 .doit = mptcp_nl_cmd_get_limits, 2148 }, 2149 { 2150 .cmd = MPTCP_PM_CMD_SET_FLAGS, 2151 .doit = mptcp_nl_cmd_set_flags, 2152 .flags = GENL_ADMIN_PERM, 2153 }, 2154 }; 2155 2156 static struct genl_family mptcp_genl_family __ro_after_init = { 2157 .name = MPTCP_PM_NAME, 2158 .version = MPTCP_PM_VER, 2159 .maxattr = MPTCP_PM_ATTR_MAX, 2160 .policy = mptcp_pm_policy, 2161 .netnsok = true, 2162 .module = THIS_MODULE, 2163 .small_ops = mptcp_pm_ops, 2164 .n_small_ops = ARRAY_SIZE(mptcp_pm_ops), 2165 .mcgrps = mptcp_pm_mcgrps, 2166 .n_mcgrps = ARRAY_SIZE(mptcp_pm_mcgrps), 2167 }; 2168 2169 static int __net_init pm_nl_init_net(struct net *net) 2170 { 2171 struct pm_nl_pernet *pernet = pm_nl_get_pernet(net); 2172 2173 INIT_LIST_HEAD_RCU(&pernet->local_addr_list); 2174 2175 /* Cit. 2 subflows ought to be enough for anybody. */ 2176 pernet->subflows_max = 2; 2177 pernet->next_id = 1; 2178 pernet->stale_loss_cnt = 4; 2179 spin_lock_init(&pernet->lock); 2180 2181 /* No need to initialize other pernet fields, the struct is zeroed at 2182 * allocation time. 2183 */ 2184 2185 return 0; 2186 } 2187 2188 static void __net_exit pm_nl_exit_net(struct list_head *net_list) 2189 { 2190 struct net *net; 2191 2192 list_for_each_entry(net, net_list, exit_list) { 2193 struct pm_nl_pernet *pernet = pm_nl_get_pernet(net); 2194 2195 /* net is removed from namespace list, can't race with 2196 * other modifiers, also netns core already waited for a 2197 * RCU grace period. 2198 */ 2199 __flush_addrs(&pernet->local_addr_list); 2200 } 2201 } 2202 2203 static struct pernet_operations mptcp_pm_pernet_ops = { 2204 .init = pm_nl_init_net, 2205 .exit_batch = pm_nl_exit_net, 2206 .id = &pm_nl_pernet_id, 2207 .size = sizeof(struct pm_nl_pernet), 2208 }; 2209 2210 void __init mptcp_pm_nl_init(void) 2211 { 2212 if (register_pernet_subsys(&mptcp_pm_pernet_ops) < 0) 2213 panic("Failed to register MPTCP PM pernet subsystem.\n"); 2214 2215 if (genl_register_family(&mptcp_genl_family)) 2216 panic("Failed to register MPTCP PM netlink family\n"); 2217 } 2218