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