[linux-2.6-block.git] / net / ipv4 / tcp_ulp.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Pluggable TCP upper layer protocol support.
 *
 * Copyright (c) 2016-2017, Mellanox Technologies. All rights reserved.
 * Copyright (c) 2016-2017, Dave Watson <davejwatson@fb.com>. All rights reserved.
 *
 */

#include <linux/module.h>
#include <linux/mm.h>
#include <linux/types.h>
#include <linux/list.h>
#include <linux/gfp.h>
#include <net/tcp.h>

static DEFINE_SPINLOCK(tcp_ulp_list_lock);
static LIST_HEAD(tcp_ulp_list);

/* Simple linear search, don't expect many entries! */
static struct tcp_ulp_ops *tcp_ulp_find(const char *name)
{
	struct tcp_ulp_ops *e;

	list_for_each_entry_rcu(e, &tcp_ulp_list, list) {
		if (strcmp(e->name, name) == 0)
			return e;
	}

	return NULL;
}

static const struct tcp_ulp_ops *__tcp_ulp_find_autoload(const char *name)
{
	const struct tcp_ulp_ops *ulp = NULL;

	rcu_read_lock();
	ulp = tcp_ulp_find(name);

#ifdef CONFIG_MODULES
	if (!ulp && capable(CAP_NET_ADMIN)) {
		rcu_read_unlock();
		request_module("tcp-ulp-%s", name);
		rcu_read_lock();
		ulp = tcp_ulp_find(name);
	}
#endif
	if (!ulp || !try_module_get(ulp->owner))
		ulp = NULL;

	rcu_read_unlock();
	return ulp;
}

/* Attach new upper layer protocol to the list
 * of available protocols.
 */
int tcp_register_ulp(struct tcp_ulp_ops *ulp)
{
	int ret = 0;

	spin_lock(&tcp_ulp_list_lock);
	if (tcp_ulp_find(ulp->name))
		ret = -EEXIST;
	else
		list_add_tail_rcu(&ulp->list, &tcp_ulp_list);
	spin_unlock(&tcp_ulp_list_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(tcp_register_ulp);

void tcp_unregister_ulp(struct tcp_ulp_ops *ulp)
{
	spin_lock(&tcp_ulp_list_lock);
	list_del_rcu(&ulp->list);
	spin_unlock(&tcp_ulp_list_lock);

	synchronize_rcu();
}
EXPORT_SYMBOL_GPL(tcp_unregister_ulp);

/* Build string with list of available upper layer protocl values */
void tcp_get_available_ulp(char *buf, size_t maxlen)
{
	struct tcp_ulp_ops *ulp_ops;
	size_t offs = 0;

	*buf = '\0';
	rcu_read_lock();
	list_for_each_entry_rcu(ulp_ops, &tcp_ulp_list, list) {
		offs += snprintf(buf + offs, maxlen - offs,
				 "%s%s",
				 offs == 0 ? "" : " ", ulp_ops->name);
	}
	rcu_read_unlock();
}

void tcp_update_ulp(struct sock *sk, struct proto *proto)
{
	struct inet_connection_sock *icsk = inet_csk(sk);

	if (!icsk->icsk_ulp_ops) {
		sk->sk_prot = proto;
		return;
	}

	if (icsk->icsk_ulp_ops->update)
		icsk->icsk_ulp_ops->update(sk, proto);
}

void tcp_cleanup_ulp(struct sock *sk)
{
	struct inet_connection_sock *icsk = inet_csk(sk);

	/* No sock_owned_by_me() check here as at the time the
	 * stack calls this function, the socket is dead and
	 * about to be destroyed.
	 */
	if (!icsk->icsk_ulp_ops)
		return;

	if (icsk->icsk_ulp_ops->release)
		icsk->icsk_ulp_ops->release(sk);
	module_put(icsk->icsk_ulp_ops->owner);

	icsk->icsk_ulp_ops = NULL;
}

static int __tcp_set_ulp(struct sock *sk, const struct tcp_ulp_ops *ulp_ops)
{
	struct inet_connection_sock *icsk = inet_csk(sk);
	int err;

	err = -EEXIST;
	if (icsk->icsk_ulp_ops)
		goto out_err;

	err = ulp_ops->init(sk);
	if (err)
		goto out_err;

	icsk->icsk_ulp_ops = ulp_ops;
	return 0;
out_err:
	module_put(ulp_ops->owner);
	return err;
}

int tcp_set_ulp(struct sock *sk, const char *name)
{
	const struct tcp_ulp_ops *ulp_ops;

	sock_owned_by_me(sk);

	ulp_ops = __tcp_ulp_find_autoload(name);
	if (!ulp_ops)
		return -ENOENT;

	return __tcp_set_ulp(sk, ulp_ops);
}
Commit	Line	Data
457c8996	1	// SPDX-License-Identifier: GPL-2.0-only
734942cc DW	2	/*
	3	* Pluggable TCP upper layer protocol support.
	4	*
	5	* Copyright (c) 2016-2017, Mellanox Technologies. All rights reserved.
	6	* Copyright (c) 2016-2017, Dave Watson <davejwatson@fb.com>. All rights reserved.
	7	*
	8	*/
	9
1243a51f	10	#include <linux/module.h>
734942cc DW	11	#include <linux/mm.h>
	12	#include <linux/types.h>
	13	#include <linux/list.h>
	14	#include <linux/gfp.h>
	15	#include <net/tcp.h>
	16
	17	static DEFINE_SPINLOCK(tcp_ulp_list_lock);
	18	static LIST_HEAD(tcp_ulp_list);
	19
	20	/* Simple linear search, don't expect many entries! */
	21	static struct tcp_ulp_ops tcp_ulp_find(const char name)
	22	{
	23	struct tcp_ulp_ops *e;
	24
	25	list_for_each_entry_rcu(e, &tcp_ulp_list, list) {
	26	if (strcmp(e->name, name) == 0)
	27	return e;
	28	}
	29
	30	return NULL;
	31	}
	32
	33	static const struct tcp_ulp_ops __tcp_ulp_find_autoload(const char name)
	34	{
	35	const struct tcp_ulp_ops *ulp = NULL;
	36
	37	rcu_read_lock();
	38	ulp = tcp_ulp_find(name);
	39
	40	#ifdef CONFIG_MODULES
	41	if (!ulp && capable(CAP_NET_ADMIN)) {
	42	rcu_read_unlock();
037b0b86	43	request_module("tcp-ulp-%s", name);
734942cc DW	44	rcu_read_lock();
	45	ulp = tcp_ulp_find(name);
	46	}
	47	#endif
	48	if (!ulp \|\| !try_module_get(ulp->owner))
	49	ulp = NULL;
	50
	51	rcu_read_unlock();
	52	return ulp;
	53	}
	54
	55	/* Attach new upper layer protocol to the list
	56	* of available protocols.
	57	*/
	58	int tcp_register_ulp(struct tcp_ulp_ops *ulp)
	59	{
	60	int ret = 0;
	61
	62	spin_lock(&tcp_ulp_list_lock);
b11a632c	63	if (tcp_ulp_find(ulp->name))
734942cc	64	ret = -EEXIST;
b11a632c	65	else
734942cc	66	list_add_tail_rcu(&ulp->list, &tcp_ulp_list);
734942cc DW	67	spin_unlock(&tcp_ulp_list_lock);
	68
	69	return ret;
	70	}
	71	EXPORT_SYMBOL_GPL(tcp_register_ulp);
	72
	73	void tcp_unregister_ulp(struct tcp_ulp_ops *ulp)
	74	{
	75	spin_lock(&tcp_ulp_list_lock);
	76	list_del_rcu(&ulp->list);
	77	spin_unlock(&tcp_ulp_list_lock);
	78
	79	synchronize_rcu();
	80	}
	81	EXPORT_SYMBOL_GPL(tcp_unregister_ulp);
	82
	83	/* Build string with list of available upper layer protocl values */
	84	void tcp_get_available_ulp(char *buf, size_t maxlen)
	85	{
	86	struct tcp_ulp_ops *ulp_ops;
	87	size_t offs = 0;
	88
926f38e9	89	*buf = '\0';
734942cc DW	90	rcu_read_lock();
	91	list_for_each_entry_rcu(ulp_ops, &tcp_ulp_list, list) {
	92	offs += snprintf(buf + offs, maxlen - offs,
	93	"%s%s",
	94	offs == 0 ? "" : " ", ulp_ops->name);
	95	}
	96	rcu_read_unlock();
	97	}
	98
95fa1454 JF	99	void tcp_update_ulp(struct sock sk, struct proto proto)
	100	{
	101	struct inet_connection_sock *icsk = inet_csk(sk);
	102
	103	if (!icsk->icsk_ulp_ops) {
	104	sk->sk_prot = proto;
	105	return;
	106	}
	107
	108	if (icsk->icsk_ulp_ops->update)
	109	icsk->icsk_ulp_ops->update(sk, proto);
	110	}
	111
734942cc DW	112	void tcp_cleanup_ulp(struct sock *sk)
	113	{
	114	struct inet_connection_sock *icsk = inet_csk(sk);
	115
aadd4355 DB	116	/* No sock_owned_by_me() check here as at the time the
	117	* stack calls this function, the socket is dead and
	118	* about to be destroyed.
	119	*/
734942cc DW	120	if (!icsk->icsk_ulp_ops)
	121	return;
	122
	123	if (icsk->icsk_ulp_ops->release)
	124	icsk->icsk_ulp_ops->release(sk);
	125	module_put(icsk->icsk_ulp_ops->owner);
90545cdc DB	126
90545cdc DB	127	icsk->icsk_ulp_ops = NULL;
734942cc DW	128	}
734942cc DW	129
1243a51f	130	static int __tcp_set_ulp(struct sock sk, const struct tcp_ulp_ops ulp_ops)
734942cc DW	131	{
734942cc DW	132	struct inet_connection_sock *icsk = inet_csk(sk);
1243a51f	133	int err;
734942cc	134
1243a51f	135	err = -EEXIST;
734942cc	136	if (icsk->icsk_ulp_ops)
1243a51f	137	goto out_err;
b11a632c JF	138
b11a632c JF	139	err = ulp_ops->init(sk);
1243a51f DB	140	if (err)
1243a51f DB	141	goto out_err;
b11a632c JF	142
	143	icsk->icsk_ulp_ops = ulp_ops;
	144	return 0;
1243a51f DB	145	out_err:
	146	module_put(ulp_ops->owner);
	147	return err;
b11a632c JF	148	}
b11a632c JF	149
1243a51f	150	int tcp_set_ulp(struct sock sk, const char name)
b11a632c	151	{
b11a632c	152	const struct tcp_ulp_ops *ulp_ops;
b11a632c	153
8b9088f8	154	sock_owned_by_me(sk);
b11a632c	155
1243a51f	156	ulp_ops = __tcp_ulp_find_autoload(name);
b11a632c JF	157	if (!ulp_ops)
	158	return -ENOENT;
	159
1243a51f	160	return __tcp_set_ulp(sk, ulp_ops);
734942cc	161	}