[linux-block.git] / net / mptcp / pm.c

// SPDX-License-Identifier: GPL-2.0
/* Multipath TCP
 *
 * Copyright (c) 2019, Intel Corporation.
 */
#define pr_fmt(fmt) "MPTCP: " fmt

#include <linux/kernel.h>
#include <net/tcp.h>
#include <net/mptcp.h>
#include "protocol.h"

/* path manager command handlers */

int mptcp_pm_announce_addr(struct mptcp_sock *msk,
			   const struct mptcp_addr_info *addr,
			   bool echo, bool port)
{
	u8 add_addr = READ_ONCE(msk->pm.addr_signal);

	pr_debug("msk=%p, local_id=%d", msk, addr->id);

	if (add_addr) {
		pr_warn("addr_signal error, add_addr=%d", add_addr);
		return -EINVAL;
	}

	msk->pm.local = *addr;
	add_addr |= BIT(MPTCP_ADD_ADDR_SIGNAL);
	if (echo)
		add_addr |= BIT(MPTCP_ADD_ADDR_ECHO);
	if (addr->family == AF_INET6)
		add_addr |= BIT(MPTCP_ADD_ADDR_IPV6);
	if (port)
		add_addr |= BIT(MPTCP_ADD_ADDR_PORT);
	WRITE_ONCE(msk->pm.addr_signal, add_addr);
	return 0;
}

int mptcp_pm_remove_addr(struct mptcp_sock *msk, u8 local_id)
{
	u8 rm_addr = READ_ONCE(msk->pm.addr_signal);

	pr_debug("msk=%p, local_id=%d", msk, local_id);

	if (rm_addr) {
		pr_warn("addr_signal error, rm_addr=%d", rm_addr);
		return -EINVAL;
	}

	msk->pm.rm_id = local_id;
	rm_addr |= BIT(MPTCP_RM_ADDR_SIGNAL);
	WRITE_ONCE(msk->pm.addr_signal, rm_addr);
	return 0;
}

int mptcp_pm_remove_subflow(struct mptcp_sock *msk, u8 local_id)
{
	pr_debug("msk=%p, local_id=%d", msk, local_id);

	spin_lock_bh(&msk->pm.lock);
	mptcp_pm_nl_rm_subflow_received(msk, local_id);
	spin_unlock_bh(&msk->pm.lock);
	return 0;
}

/* path manager event handlers */

void mptcp_pm_new_connection(struct mptcp_sock *msk, int server_side)
{
	struct mptcp_pm_data *pm = &msk->pm;

	pr_debug("msk=%p, token=%u side=%d", msk, msk->token, server_side);

	WRITE_ONCE(pm->server_side, server_side);
}

bool mptcp_pm_allow_new_subflow(struct mptcp_sock *msk)
{
	struct mptcp_pm_data *pm = &msk->pm;
	int ret = 0;

	pr_debug("msk=%p subflows=%d max=%d allow=%d", msk, pm->subflows,
		 pm->subflows_max, READ_ONCE(pm->accept_subflow));

	/* try to avoid acquiring the lock below */
	if (!READ_ONCE(pm->accept_subflow))
		return false;

	spin_lock_bh(&pm->lock);
	if (READ_ONCE(pm->accept_subflow)) {
		ret = pm->subflows < pm->subflows_max;
		if (ret && ++pm->subflows == pm->subflows_max)
			WRITE_ONCE(pm->accept_subflow, false);
	}
	spin_unlock_bh(&pm->lock);

	return ret;
}

/* return true if the new status bit is currently cleared, that is, this event
 * can be server, eventually by an already scheduled work
 */
static bool mptcp_pm_schedule_work(struct mptcp_sock *msk,
				   enum mptcp_pm_status new_status)
{
	pr_debug("msk=%p status=%x new=%lx", msk, msk->pm.status,
		 BIT(new_status));
	if (msk->pm.status & BIT(new_status))
		return false;

	msk->pm.status |= BIT(new_status);
	mptcp_schedule_work((struct sock *)msk);
	return true;
}

void mptcp_pm_fully_established(struct mptcp_sock *msk)
{
	struct mptcp_pm_data *pm = &msk->pm;

	pr_debug("msk=%p", msk);

	/* try to avoid acquiring the lock below */
	if (!READ_ONCE(pm->work_pending))
		return;

	spin_lock_bh(&pm->lock);

	/* mptcp_pm_fully_established() can be invoked by multiple
	 * racing paths - accept() and check_fully_established()
	 * be sure to serve this event only once.
	 */
	if (READ_ONCE(pm->work_pending) &&
	    !(msk->pm.status & BIT(MPTCP_PM_ALREADY_ESTABLISHED)))
		mptcp_pm_schedule_work(msk, MPTCP_PM_ESTABLISHED);
	msk->pm.status |= BIT(MPTCP_PM_ALREADY_ESTABLISHED);

	spin_unlock_bh(&pm->lock);
}

void mptcp_pm_connection_closed(struct mptcp_sock *msk)
{
	pr_debug("msk=%p", msk);
}

void mptcp_pm_subflow_established(struct mptcp_sock *msk,
				  struct mptcp_subflow_context *subflow)
{
	struct mptcp_pm_data *pm = &msk->pm;

	pr_debug("msk=%p", msk);

	if (!READ_ONCE(pm->work_pending))
		return;

	spin_lock_bh(&pm->lock);

	if (READ_ONCE(pm->work_pending))
		mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);

	spin_unlock_bh(&pm->lock);
}

void mptcp_pm_subflow_closed(struct mptcp_sock *msk, u8 id)
{
	pr_debug("msk=%p", msk);
}

void mptcp_pm_add_addr_received(struct mptcp_sock *msk,
				const struct mptcp_addr_info *addr)
{
	struct mptcp_pm_data *pm = &msk->pm;

	pr_debug("msk=%p remote_id=%d accept=%d", msk, addr->id,
		 READ_ONCE(pm->accept_addr));

	spin_lock_bh(&pm->lock);

	if (!READ_ONCE(pm->accept_addr)) {
		mptcp_pm_announce_addr(msk, addr, true, addr->port);
		mptcp_pm_add_addr_send_ack(msk);
	} else if (mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_RECEIVED)) {
		pm->remote = *addr;
	}

	spin_unlock_bh(&pm->lock);
}

void mptcp_pm_add_addr_send_ack(struct mptcp_sock *msk)
{
	if (!mptcp_pm_should_add_signal_ipv6(msk) &&
	    !mptcp_pm_should_add_signal_port(msk))
		return;

	mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_SEND_ACK);
}

void mptcp_pm_rm_addr_received(struct mptcp_sock *msk, u8 rm_id)
{
	struct mptcp_pm_data *pm = &msk->pm;

	pr_debug("msk=%p remote_id=%d", msk, rm_id);

	spin_lock_bh(&pm->lock);
	mptcp_pm_schedule_work(msk, MPTCP_PM_RM_ADDR_RECEIVED);
	pm->rm_id = rm_id;
	spin_unlock_bh(&pm->lock);
}

void mptcp_pm_mp_prio_received(struct sock *sk, u8 bkup)
{
	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);

	pr_debug("subflow->backup=%d, bkup=%d\n", subflow->backup, bkup);
	subflow->backup = bkup;
}

/* path manager helpers */

bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
			      struct mptcp_addr_info *saddr, bool *echo, bool *port)
{
	int ret = false;

	spin_lock_bh(&msk->pm.lock);

	/* double check after the lock is acquired */
	if (!mptcp_pm_should_add_signal(msk))
		goto out_unlock;

	*echo = mptcp_pm_should_add_signal_echo(msk);
	*port = mptcp_pm_should_add_signal_port(msk);

	if (remaining < mptcp_add_addr_len(msk->pm.local.family, *echo, *port))
		goto out_unlock;

	*saddr = msk->pm.local;
	WRITE_ONCE(msk->pm.addr_signal, 0);
	ret = true;

out_unlock:
	spin_unlock_bh(&msk->pm.lock);
	return ret;
}

bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
			     u8 *rm_id)
{
	int ret = false;

	spin_lock_bh(&msk->pm.lock);

	/* double check after the lock is acquired */
	if (!mptcp_pm_should_rm_signal(msk))
		goto out_unlock;

	if (remaining < TCPOLEN_MPTCP_RM_ADDR_BASE)
		goto out_unlock;

	*rm_id = msk->pm.rm_id;
	WRITE_ONCE(msk->pm.addr_signal, 0);
	ret = true;

out_unlock:
	spin_unlock_bh(&msk->pm.lock);
	return ret;
}

int mptcp_pm_get_local_id(struct mptcp_sock *msk, struct sock_common *skc)
{
	return mptcp_pm_nl_get_local_id(msk, skc);
}

void mptcp_pm_data_init(struct mptcp_sock *msk)
{
	msk->pm.add_addr_signaled = 0;
	msk->pm.add_addr_accepted = 0;
	msk->pm.local_addr_used = 0;
	msk->pm.subflows = 0;
	msk->pm.rm_id = 0;
	WRITE_ONCE(msk->pm.work_pending, false);
	WRITE_ONCE(msk->pm.addr_signal, 0);
	WRITE_ONCE(msk->pm.accept_addr, false);
	WRITE_ONCE(msk->pm.accept_subflow, false);
	msk->pm.status = 0;

	spin_lock_init(&msk->pm.lock);
	INIT_LIST_HEAD(&msk->pm.anno_list);

	mptcp_pm_nl_data_init(msk);
}

void __init mptcp_pm_init(void)
{
	mptcp_pm_nl_init();
}
Commit	Line	Data
1b1c7a0e PK	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Multipath TCP
	3	*
	4	* Copyright (c) 2019, Intel Corporation.
	5	*/
c85adced GT	6	#define pr_fmt(fmt) "MPTCP: " fmt
c85adced GT	7
1b1c7a0e PK	8	#include <linux/kernel.h>
	9	#include <net/tcp.h>
	10	#include <net/mptcp.h>
	11	#include "protocol.h"
	12
1b1c7a0e PK	13	/* path manager command handlers */
	14
	15	int mptcp_pm_announce_addr(struct mptcp_sock *msk,
6a6c05a8	16	const struct mptcp_addr_info *addr,
0f5c9e3f	17	bool echo, bool port)
1b1c7a0e	18	{
13ad9f01	19	u8 add_addr = READ_ONCE(msk->pm.addr_signal);
d91d322a	20
926bdeab PK	21	pr_debug("msk=%p, local_id=%d", msk, addr->id);
926bdeab PK	22
42842a42 GT	23	if (add_addr) {
	24	pr_warn("addr_signal error, add_addr=%d", add_addr);
	25	return -EINVAL;
	26	}
	27
926bdeab	28	msk->pm.local = *addr;
d91d322a GT	29	add_addr \|= BIT(MPTCP_ADD_ADDR_SIGNAL);
	30	if (echo)
	31	add_addr \|= BIT(MPTCP_ADD_ADDR_ECHO);
84dfe367 GT	32	if (addr->family == AF_INET6)
84dfe367 GT	33	add_addr \|= BIT(MPTCP_ADD_ADDR_IPV6);
0f5c9e3f GT	34	if (port)
0f5c9e3f GT	35	add_addr \|= BIT(MPTCP_ADD_ADDR_PORT);
13ad9f01	36	WRITE_ONCE(msk->pm.addr_signal, add_addr);
926bdeab	37	return 0;
1b1c7a0e PK	38	}
	39
	40	int mptcp_pm_remove_addr(struct mptcp_sock *msk, u8 local_id)
	41	{
13ad9f01	42	u8 rm_addr = READ_ONCE(msk->pm.addr_signal);
42842a42	43
b6c08380 GT	44	pr_debug("msk=%p, local_id=%d", msk, local_id);
b6c08380 GT	45
42842a42 GT	46	if (rm_addr) {
	47	pr_warn("addr_signal error, rm_addr=%d", rm_addr);
	48	return -EINVAL;
	49	}
	50
b6c08380	51	msk->pm.rm_id = local_id;
42842a42	52	rm_addr \|= BIT(MPTCP_RM_ADDR_SIGNAL);
13ad9f01	53	WRITE_ONCE(msk->pm.addr_signal, rm_addr);
b6c08380	54	return 0;
1b1c7a0e PK	55	}
1b1c7a0e PK	56
0ee4261a	57	int mptcp_pm_remove_subflow(struct mptcp_sock *msk, u8 local_id)
1b1c7a0e	58	{
0ee4261a GT	59	pr_debug("msk=%p, local_id=%d", msk, local_id);
	60
	61	spin_lock_bh(&msk->pm.lock);
	62	mptcp_pm_nl_rm_subflow_received(msk, local_id);
	63	spin_unlock_bh(&msk->pm.lock);
	64	return 0;
1b1c7a0e PK	65	}
	66
	67	/* path manager event handlers */
	68
	69	void mptcp_pm_new_connection(struct mptcp_sock *msk, int server_side)
	70	{
	71	struct mptcp_pm_data *pm = &msk->pm;
	72
	73	pr_debug("msk=%p, token=%u side=%d", msk, msk->token, server_side);
	74
	75	WRITE_ONCE(pm->server_side, server_side);
	76	}
	77
	78	bool mptcp_pm_allow_new_subflow(struct mptcp_sock *msk)
	79	{
926bdeab	80	struct mptcp_pm_data *pm = &msk->pm;
f58f065a	81	int ret = 0;
926bdeab PK	82
	83	pr_debug("msk=%p subflows=%d max=%d allow=%d", msk, pm->subflows,
	84	pm->subflows_max, READ_ONCE(pm->accept_subflow));
	85
	86	/* try to avoid acquiring the lock below */
	87	if (!READ_ONCE(pm->accept_subflow))
	88	return false;
	89
	90	spin_lock_bh(&pm->lock);
f58f065a GT	91	if (READ_ONCE(pm->accept_subflow)) {
	92	ret = pm->subflows < pm->subflows_max;
	93	if (ret && ++pm->subflows == pm->subflows_max)
	94	WRITE_ONCE(pm->accept_subflow, false);
	95	}
926bdeab PK	96	spin_unlock_bh(&pm->lock);
	97
	98	return ret;
	99	}
	100
	101	/* return true if the new status bit is currently cleared, that is, this event
	102	* can be server, eventually by an already scheduled work
	103	*/
	104	static bool mptcp_pm_schedule_work(struct mptcp_sock *msk,
	105	enum mptcp_pm_status new_status)
	106	{
	107	pr_debug("msk=%p status=%x new=%lx", msk, msk->pm.status,
	108	BIT(new_status));
	109	if (msk->pm.status & BIT(new_status))
	110	return false;
	111
	112	msk->pm.status \|= BIT(new_status);
ba8f48f7	113	mptcp_schedule_work((struct sock *)msk);
926bdeab	114	return true;
1b1c7a0e PK	115	}
	116
	117	void mptcp_pm_fully_established(struct mptcp_sock *msk)
	118	{
926bdeab PK	119	struct mptcp_pm_data *pm = &msk->pm;
926bdeab PK	120
1b1c7a0e	121	pr_debug("msk=%p", msk);
926bdeab PK	122
	123	/* try to avoid acquiring the lock below */
	124	if (!READ_ONCE(pm->work_pending))
	125	return;
	126
	127	spin_lock_bh(&pm->lock);
	128
5b950ff4 PA	129	/* mptcp_pm_fully_established() can be invoked by multiple
	130	* racing paths - accept() and check_fully_established()
	131	* be sure to serve this event only once.
	132	*/
	133	if (READ_ONCE(pm->work_pending) &&
	134	!(msk->pm.status & BIT(MPTCP_PM_ALREADY_ESTABLISHED)))
926bdeab	135	mptcp_pm_schedule_work(msk, MPTCP_PM_ESTABLISHED);
5b950ff4	136	msk->pm.status \|= BIT(MPTCP_PM_ALREADY_ESTABLISHED);
926bdeab PK	137
926bdeab PK	138	spin_unlock_bh(&pm->lock);
1b1c7a0e PK	139	}
	140
	141	void mptcp_pm_connection_closed(struct mptcp_sock *msk)
	142	{
	143	pr_debug("msk=%p", msk);
	144	}
	145
	146	void mptcp_pm_subflow_established(struct mptcp_sock *msk,
	147	struct mptcp_subflow_context *subflow)
	148	{
926bdeab PK	149	struct mptcp_pm_data *pm = &msk->pm;
926bdeab PK	150
1b1c7a0e	151	pr_debug("msk=%p", msk);
926bdeab PK	152
	153	if (!READ_ONCE(pm->work_pending))
	154	return;
	155
	156	spin_lock_bh(&pm->lock);
	157
	158	if (READ_ONCE(pm->work_pending))
	159	mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
	160
	161	spin_unlock_bh(&pm->lock);
1b1c7a0e PK	162	}
	163
	164	void mptcp_pm_subflow_closed(struct mptcp_sock *msk, u8 id)
	165	{
	166	pr_debug("msk=%p", msk);
	167	}
	168
	169	void mptcp_pm_add_addr_received(struct mptcp_sock *msk,
	170	const struct mptcp_addr_info *addr)
	171	{
926bdeab PK	172	struct mptcp_pm_data *pm = &msk->pm;
	173
	174	pr_debug("msk=%p remote_id=%d accept=%d", msk, addr->id,
	175	READ_ONCE(pm->accept_addr));
	176
926bdeab PK	177	spin_lock_bh(&pm->lock);
926bdeab PK	178
84dfe367	179	if (!READ_ONCE(pm->accept_addr)) {
0f5c9e3f	180	mptcp_pm_announce_addr(msk, addr, true, addr->port);
84dfe367 GT	181	mptcp_pm_add_addr_send_ack(msk);
84dfe367 GT	182	} else if (mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_RECEIVED)) {
926bdeab	183	pm->remote = *addr;
84dfe367	184	}
926bdeab PK	185
926bdeab PK	186	spin_unlock_bh(&pm->lock);
84dfe367 GT	187	}
	188
	189	void mptcp_pm_add_addr_send_ack(struct mptcp_sock *msk)
	190	{
fbe0f87a GT	191	if (!mptcp_pm_should_add_signal_ipv6(msk) &&
fbe0f87a GT	192	!mptcp_pm_should_add_signal_port(msk))
84dfe367 GT	193	return;
	194
	195	mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_SEND_ACK);
1b1c7a0e PK	196	}
1b1c7a0e PK	197
d0876b22 GT	198	void mptcp_pm_rm_addr_received(struct mptcp_sock *msk, u8 rm_id)
	199	{
	200	struct mptcp_pm_data *pm = &msk->pm;
	201
	202	pr_debug("msk=%p remote_id=%d", msk, rm_id);
	203
	204	spin_lock_bh(&pm->lock);
	205	mptcp_pm_schedule_work(msk, MPTCP_PM_RM_ADDR_RECEIVED);
	206	pm->rm_id = rm_id;
	207	spin_unlock_bh(&pm->lock);
	208	}
	209
40453a5c GT	210	void mptcp_pm_mp_prio_received(struct sock *sk, u8 bkup)
	211	{
	212	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
	213
	214	pr_debug("subflow->backup=%d, bkup=%d\n", subflow->backup, bkup);
	215	subflow->backup = bkup;
	216	}
	217
1b1c7a0e PK	218	/* path manager helpers */
1b1c7a0e PK	219
f643b803	220	bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
4a2777a8	221	struct mptcp_addr_info saddr, bool echo, bool *port)
1b1c7a0e	222	{
926bdeab PK	223	int ret = false;
	224
	225	spin_lock_bh(&msk->pm.lock);
	226
	227	/* double check after the lock is acquired */
f643b803	228	if (!mptcp_pm_should_add_signal(msk))
926bdeab PK	229	goto out_unlock;
926bdeab PK	230
d91d322a	231	*echo = mptcp_pm_should_add_signal_echo(msk);
4a2777a8	232	*port = mptcp_pm_should_add_signal_port(msk);
456afe01	233
4a2777a8	234	if (remaining < mptcp_add_addr_len(msk->pm.local.family, echo, port))
926bdeab PK	235	goto out_unlock;
	236
	237	*saddr = msk->pm.local;
13ad9f01	238	WRITE_ONCE(msk->pm.addr_signal, 0);
926bdeab PK	239	ret = true;
	240
	241	out_unlock:
	242	spin_unlock_bh(&msk->pm.lock);
	243	return ret;
1b1c7a0e PK	244	}
1b1c7a0e PK	245
5cb104ae GT	246	bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
	247	u8 *rm_id)
	248	{
	249	int ret = false;
	250
	251	spin_lock_bh(&msk->pm.lock);
	252
	253	/* double check after the lock is acquired */
	254	if (!mptcp_pm_should_rm_signal(msk))
	255	goto out_unlock;
	256
	257	if (remaining < TCPOLEN_MPTCP_RM_ADDR_BASE)
	258	goto out_unlock;
	259
	260	*rm_id = msk->pm.rm_id;
13ad9f01	261	WRITE_ONCE(msk->pm.addr_signal, 0);
5cb104ae GT	262	ret = true;
	263
	264	out_unlock:
	265	spin_unlock_bh(&msk->pm.lock);
	266	return ret;
	267	}
	268
1b1c7a0e PK	269	int mptcp_pm_get_local_id(struct mptcp_sock msk, struct sock_common skc)
1b1c7a0e PK	270	{
01cacb00	271	return mptcp_pm_nl_get_local_id(msk, skc);
1b1c7a0e PK	272	}
1b1c7a0e PK	273
1b1c7a0e PK	274	void mptcp_pm_data_init(struct mptcp_sock *msk)
	275	{
	276	msk->pm.add_addr_signaled = 0;
	277	msk->pm.add_addr_accepted = 0;
	278	msk->pm.local_addr_used = 0;
	279	msk->pm.subflows = 0;
5cb104ae	280	msk->pm.rm_id = 0;
1b1c7a0e	281	WRITE_ONCE(msk->pm.work_pending, false);
13ad9f01	282	WRITE_ONCE(msk->pm.addr_signal, 0);
1b1c7a0e PK	283	WRITE_ONCE(msk->pm.accept_addr, false);
	284	WRITE_ONCE(msk->pm.accept_subflow, false);
	285	msk->pm.status = 0;
	286
	287	spin_lock_init(&msk->pm.lock);
b6c08380	288	INIT_LIST_HEAD(&msk->pm.anno_list);
01cacb00 PA	289
01cacb00 PA	290	mptcp_pm_nl_data_init(msk);
1b1c7a0e PK	291	}
1b1c7a0e PK	292
d39dceca	293	void __init mptcp_pm_init(void)
1b1c7a0e	294	{
01cacb00	295	mptcp_pm_nl_init();
1b1c7a0e	296	}