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