[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);

	if (READ_ONCE(pm->work_pending))
		mptcp_pm_schedule_work(msk, MPTCP_PM_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);
}

/* 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
	129	if (READ_ONCE(pm->work_pending))
	130	mptcp_pm_schedule_work(msk, MPTCP_PM_ESTABLISHED);
	131
	132	spin_unlock_bh(&pm->lock);
1b1c7a0e PK	133	}
	134
	135	void mptcp_pm_connection_closed(struct mptcp_sock *msk)
	136	{
	137	pr_debug("msk=%p", msk);
	138	}
	139
	140	void mptcp_pm_subflow_established(struct mptcp_sock *msk,
	141	struct mptcp_subflow_context *subflow)
	142	{
926bdeab PK	143	struct mptcp_pm_data *pm = &msk->pm;
926bdeab PK	144
1b1c7a0e	145	pr_debug("msk=%p", msk);
926bdeab PK	146
	147	if (!READ_ONCE(pm->work_pending))
	148	return;
	149
	150	spin_lock_bh(&pm->lock);
	151
	152	if (READ_ONCE(pm->work_pending))
	153	mptcp_pm_schedule_work(msk, MPTCP_PM_SUBFLOW_ESTABLISHED);
	154
	155	spin_unlock_bh(&pm->lock);
1b1c7a0e PK	156	}
	157
	158	void mptcp_pm_subflow_closed(struct mptcp_sock *msk, u8 id)
	159	{
	160	pr_debug("msk=%p", msk);
	161	}
	162
	163	void mptcp_pm_add_addr_received(struct mptcp_sock *msk,
	164	const struct mptcp_addr_info *addr)
	165	{
926bdeab PK	166	struct mptcp_pm_data *pm = &msk->pm;
	167
	168	pr_debug("msk=%p remote_id=%d accept=%d", msk, addr->id,
	169	READ_ONCE(pm->accept_addr));
	170
926bdeab PK	171	spin_lock_bh(&pm->lock);
926bdeab PK	172
84dfe367	173	if (!READ_ONCE(pm->accept_addr)) {
0f5c9e3f	174	mptcp_pm_announce_addr(msk, addr, true, addr->port);
84dfe367 GT	175	mptcp_pm_add_addr_send_ack(msk);
84dfe367 GT	176	} else if (mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_RECEIVED)) {
926bdeab	177	pm->remote = *addr;
84dfe367	178	}
926bdeab PK	179
926bdeab PK	180	spin_unlock_bh(&pm->lock);
84dfe367 GT	181	}
	182
	183	void mptcp_pm_add_addr_send_ack(struct mptcp_sock *msk)
	184	{
fbe0f87a GT	185	if (!mptcp_pm_should_add_signal_ipv6(msk) &&
fbe0f87a GT	186	!mptcp_pm_should_add_signal_port(msk))
84dfe367 GT	187	return;
	188
	189	mptcp_pm_schedule_work(msk, MPTCP_PM_ADD_ADDR_SEND_ACK);
1b1c7a0e PK	190	}
1b1c7a0e PK	191
d0876b22 GT	192	void mptcp_pm_rm_addr_received(struct mptcp_sock *msk, u8 rm_id)
	193	{
	194	struct mptcp_pm_data *pm = &msk->pm;
	195
	196	pr_debug("msk=%p remote_id=%d", msk, rm_id);
	197
	198	spin_lock_bh(&pm->lock);
	199	mptcp_pm_schedule_work(msk, MPTCP_PM_RM_ADDR_RECEIVED);
	200	pm->rm_id = rm_id;
	201	spin_unlock_bh(&pm->lock);
	202	}
	203
1b1c7a0e PK	204	/* path manager helpers */
1b1c7a0e PK	205
f643b803	206	bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
4a2777a8	207	struct mptcp_addr_info saddr, bool echo, bool *port)
1b1c7a0e	208	{
926bdeab PK	209	int ret = false;
	210
	211	spin_lock_bh(&msk->pm.lock);
	212
	213	/* double check after the lock is acquired */
f643b803	214	if (!mptcp_pm_should_add_signal(msk))
926bdeab PK	215	goto out_unlock;
926bdeab PK	216
d91d322a	217	*echo = mptcp_pm_should_add_signal_echo(msk);
4a2777a8	218	*port = mptcp_pm_should_add_signal_port(msk);
456afe01	219
4a2777a8	220	if (remaining < mptcp_add_addr_len(msk->pm.local.family, echo, port))
926bdeab PK	221	goto out_unlock;
	222
	223	*saddr = msk->pm.local;
13ad9f01	224	WRITE_ONCE(msk->pm.addr_signal, 0);
926bdeab PK	225	ret = true;
	226
	227	out_unlock:
	228	spin_unlock_bh(&msk->pm.lock);
	229	return ret;
1b1c7a0e PK	230	}
1b1c7a0e PK	231
5cb104ae GT	232	bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,
	233	u8 *rm_id)
	234	{
	235	int ret = false;
	236
	237	spin_lock_bh(&msk->pm.lock);
	238
	239	/* double check after the lock is acquired */
	240	if (!mptcp_pm_should_rm_signal(msk))
	241	goto out_unlock;
	242
	243	if (remaining < TCPOLEN_MPTCP_RM_ADDR_BASE)
	244	goto out_unlock;
	245
	246	*rm_id = msk->pm.rm_id;
13ad9f01	247	WRITE_ONCE(msk->pm.addr_signal, 0);
5cb104ae GT	248	ret = true;
	249
	250	out_unlock:
	251	spin_unlock_bh(&msk->pm.lock);
	252	return ret;
	253	}
	254
1b1c7a0e PK	255	int mptcp_pm_get_local_id(struct mptcp_sock msk, struct sock_common skc)
1b1c7a0e PK	256	{
01cacb00	257	return mptcp_pm_nl_get_local_id(msk, skc);
1b1c7a0e PK	258	}
1b1c7a0e PK	259
1b1c7a0e PK	260	void mptcp_pm_data_init(struct mptcp_sock *msk)
	261	{
	262	msk->pm.add_addr_signaled = 0;
	263	msk->pm.add_addr_accepted = 0;
	264	msk->pm.local_addr_used = 0;
	265	msk->pm.subflows = 0;
5cb104ae	266	msk->pm.rm_id = 0;
1b1c7a0e	267	WRITE_ONCE(msk->pm.work_pending, false);
13ad9f01	268	WRITE_ONCE(msk->pm.addr_signal, 0);
1b1c7a0e PK	269	WRITE_ONCE(msk->pm.accept_addr, false);
	270	WRITE_ONCE(msk->pm.accept_subflow, false);
	271	msk->pm.status = 0;
	272
	273	spin_lock_init(&msk->pm.lock);
b6c08380	274	INIT_LIST_HEAD(&msk->pm.anno_list);
01cacb00 PA	275
01cacb00 PA	276	mptcp_pm_nl_data_init(msk);
1b1c7a0e PK	277	}
1b1c7a0e PK	278
d39dceca	279	void __init mptcp_pm_init(void)
1b1c7a0e	280	{
01cacb00	281	mptcp_pm_nl_init();
1b1c7a0e	282	}