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