[linux.git] / net / ipv4 / tcp_ulp.c

/*
 * Pluggable TCP upper layer protocol support.
 *
 * Copyright (c) 2016-2017, Mellanox Technologies. All rights reserved.
 * Copyright (c) 2016-2017, Dave Watson <[email protected]>. 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 struct tcp_ulp_ops *tcp_ulp_find_id(const int ulp)
{
	struct tcp_ulp_ops *e;

	list_for_each_entry_rcu(e, &tcp_ulp_list, list) {
		if (e->uid == ulp)
			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("%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;
}

static const struct tcp_ulp_ops *__tcp_ulp_lookup(const int uid)
{
	const struct tcp_ulp_ops *ulp;

	rcu_read_lock();
	ulp = tcp_ulp_find_id(uid);
	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_cleanup_ulp(struct sock *sk)
{
	struct inet_connection_sock *icsk = inet_csk(sk);

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

/* Change upper layer protocol for socket */
int tcp_set_ulp(struct sock *sk, const char *name)
{
	struct inet_connection_sock *icsk = inet_csk(sk);
	const struct tcp_ulp_ops *ulp_ops;
	int err = 0;

	if (icsk->icsk_ulp_ops)
		return -EEXIST;

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

	if (!ulp_ops->user_visible) {
		module_put(ulp_ops->owner);
		return -ENOENT;
	}

	err = ulp_ops->init(sk);
	if (err) {
		module_put(ulp_ops->owner);
		return err;
	}

	icsk->icsk_ulp_ops = ulp_ops;
	return 0;
}

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

	if (icsk->icsk_ulp_ops)
		return -EEXIST;

	ulp_ops = __tcp_ulp_lookup(ulp);
	if (!ulp_ops)
		return -ENOENT;

	err = ulp_ops->init(sk);
	if (err) {
		module_put(ulp_ops->owner);
		return err;
	}

	icsk->icsk_ulp_ops = ulp_ops;
	return 0;
}
Commit	Line	Data
734942cc DW	1	/*
	2	* Pluggable TCP upper layer protocol support.
	3	*
	4	* Copyright (c) 2016-2017, Mellanox Technologies. All rights reserved.
	5	* Copyright (c) 2016-2017, Dave Watson <[email protected]>. All rights reserved.
	6	*
	7	*/
	8
	9	#include<linux/module.h>
	10	#include <linux/mm.h>
	11	#include <linux/types.h>
	12	#include <linux/list.h>
	13	#include <linux/gfp.h>
	14	#include <net/tcp.h>
	15
	16	static DEFINE_SPINLOCK(tcp_ulp_list_lock);
	17	static LIST_HEAD(tcp_ulp_list);
	18
	19	/* Simple linear search, don't expect many entries! */
	20	static struct tcp_ulp_ops tcp_ulp_find(const char name)
	21	{
	22	struct tcp_ulp_ops *e;
	23
	24	list_for_each_entry_rcu(e, &tcp_ulp_list, list) {
	25	if (strcmp(e->name, name) == 0)
	26	return e;
	27	}
	28
	29	return NULL;
	30	}
	31
b11a632c JF	32	static struct tcp_ulp_ops *tcp_ulp_find_id(const int ulp)
	33	{
	34	struct tcp_ulp_ops *e;
	35
	36	list_for_each_entry_rcu(e, &tcp_ulp_list, list) {
	37	if (e->uid == ulp)
	38	return e;
	39	}
	40
	41	return NULL;
	42	}
	43
734942cc DW	44	static const struct tcp_ulp_ops __tcp_ulp_find_autoload(const char name)
	45	{
	46	const struct tcp_ulp_ops *ulp = NULL;
	47
	48	rcu_read_lock();
	49	ulp = tcp_ulp_find(name);
	50
	51	#ifdef CONFIG_MODULES
	52	if (!ulp && capable(CAP_NET_ADMIN)) {
	53	rcu_read_unlock();
	54	request_module("%s", name);
	55	rcu_read_lock();
	56	ulp = tcp_ulp_find(name);
	57	}
	58	#endif
	59	if (!ulp \|\| !try_module_get(ulp->owner))
	60	ulp = NULL;
	61
	62	rcu_read_unlock();
	63	return ulp;
	64	}
	65
b11a632c JF	66	static const struct tcp_ulp_ops *__tcp_ulp_lookup(const int uid)
	67	{
	68	const struct tcp_ulp_ops *ulp;
	69
	70	rcu_read_lock();
	71	ulp = tcp_ulp_find_id(uid);
	72	if (!ulp \|\| !try_module_get(ulp->owner))
	73	ulp = NULL;
	74	rcu_read_unlock();
	75	return ulp;
	76	}
	77
734942cc DW	78	/* Attach new upper layer protocol to the list
	79	* of available protocols.
	80	*/
	81	int tcp_register_ulp(struct tcp_ulp_ops *ulp)
	82	{
	83	int ret = 0;
	84
	85	spin_lock(&tcp_ulp_list_lock);
b11a632c	86	if (tcp_ulp_find(ulp->name))
734942cc	87	ret = -EEXIST;
b11a632c	88	else
734942cc	89	list_add_tail_rcu(&ulp->list, &tcp_ulp_list);
734942cc DW	90	spin_unlock(&tcp_ulp_list_lock);
	91
	92	return ret;
	93	}
	94	EXPORT_SYMBOL_GPL(tcp_register_ulp);
	95
	96	void tcp_unregister_ulp(struct tcp_ulp_ops *ulp)
	97	{
	98	spin_lock(&tcp_ulp_list_lock);
	99	list_del_rcu(&ulp->list);
	100	spin_unlock(&tcp_ulp_list_lock);
	101
	102	synchronize_rcu();
	103	}
	104	EXPORT_SYMBOL_GPL(tcp_unregister_ulp);
	105
	106	/* Build string with list of available upper layer protocl values */
	107	void tcp_get_available_ulp(char *buf, size_t maxlen)
	108	{
	109	struct tcp_ulp_ops *ulp_ops;
	110	size_t offs = 0;
	111
926f38e9	112	*buf = '\0';
734942cc DW	113	rcu_read_lock();
	114	list_for_each_entry_rcu(ulp_ops, &tcp_ulp_list, list) {
	115	offs += snprintf(buf + offs, maxlen - offs,
	116	"%s%s",
	117	offs == 0 ? "" : " ", ulp_ops->name);
	118	}
	119	rcu_read_unlock();
	120	}
	121
	122	void tcp_cleanup_ulp(struct sock *sk)
	123	{
	124	struct inet_connection_sock *icsk = inet_csk(sk);
	125
	126	if (!icsk->icsk_ulp_ops)
	127	return;
	128
	129	if (icsk->icsk_ulp_ops->release)
	130	icsk->icsk_ulp_ops->release(sk);
	131	module_put(icsk->icsk_ulp_ops->owner);
	132	}
	133
	134	/* Change upper layer protocol for socket */
	135	int tcp_set_ulp(struct sock sk, const char name)
	136	{
	137	struct inet_connection_sock *icsk = inet_csk(sk);
	138	const struct tcp_ulp_ops *ulp_ops;
	139	int err = 0;
	140
	141	if (icsk->icsk_ulp_ops)
	142	return -EEXIST;
	143
	144	ulp_ops = __tcp_ulp_find_autoload(name);
	145	if (!ulp_ops)
539a06ba	146	return -ENOENT;
734942cc	147
b11a632c JF	148	if (!ulp_ops->user_visible) {
	149	module_put(ulp_ops->owner);
	150	return -ENOENT;
	151	}
	152
	153	err = ulp_ops->init(sk);
	154	if (err) {
	155	module_put(ulp_ops->owner);
	156	return err;
	157	}
	158
	159	icsk->icsk_ulp_ops = ulp_ops;
	160	return 0;
	161	}
	162
	163	int tcp_set_ulp_id(struct sock *sk, int ulp)
	164	{
	165	struct inet_connection_sock *icsk = inet_csk(sk);
	166	const struct tcp_ulp_ops *ulp_ops;
	167	int err;
	168
	169	if (icsk->icsk_ulp_ops)
	170	return -EEXIST;
	171
	172	ulp_ops = __tcp_ulp_lookup(ulp);
	173	if (!ulp_ops)
	174	return -ENOENT;
	175
539a06ba SD	176	err = ulp_ops->init(sk);
	177	if (err) {
	178	module_put(ulp_ops->owner);
	179	return err;
	180	}
734942cc DW	181
734942cc DW	182	icsk->icsk_ulp_ops = ulp_ops;
539a06ba	183	return 0;
734942cc	184	}