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