[deliverable/linux.git] / net / sunrpc / svc_xprt.c

/*
 * linux/net/sunrpc/svc_xprt.c
 *
 * Author: Tom Tucker <tom@opengridcomputing.com>
 */

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/udp.h>
#include <linux/tcp.h>
#include <linux/unistd.h>
#include <linux/slab.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/file.h>
#include <linux/freezer.h>
#include <net/sock.h>
#include <net/checksum.h>
#include <net/ip.h>
#include <net/ipv6.h>
#include <net/tcp_states.h>
#include <linux/uaccess.h>
#include <asm/ioctls.h>

#include <linux/sunrpc/types.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/xdr.h>
#include <linux/sunrpc/svcsock.h>
#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/svc_xprt.h>

#define RPCDBG_FACILITY	RPCDBG_SVCXPRT

/* List of registered transport classes */
static DEFINE_SPINLOCK(svc_xprt_class_lock);
static LIST_HEAD(svc_xprt_class_list);

int svc_reg_xprt_class(struct svc_xprt_class *xcl)
{
	struct svc_xprt_class *cl;
	int res = -EEXIST;

	dprintk("svc: Adding svc transport class '%s'\n", xcl->xcl_name);

	INIT_LIST_HEAD(&xcl->xcl_list);
	spin_lock(&svc_xprt_class_lock);
	/* Make sure there isn't already a class with the same name */
	list_for_each_entry(cl, &svc_xprt_class_list, xcl_list) {
		if (strcmp(xcl->xcl_name, cl->xcl_name) == 0)
			goto out;
	}
	list_add_tail(&xcl->xcl_list, &svc_xprt_class_list);
	res = 0;
out:
	spin_unlock(&svc_xprt_class_lock);
	return res;
}
EXPORT_SYMBOL_GPL(svc_reg_xprt_class);

void svc_unreg_xprt_class(struct svc_xprt_class *xcl)
{
	dprintk("svc: Removing svc transport class '%s'\n", xcl->xcl_name);
	spin_lock(&svc_xprt_class_lock);
	list_del_init(&xcl->xcl_list);
	spin_unlock(&svc_xprt_class_lock);
}
EXPORT_SYMBOL_GPL(svc_unreg_xprt_class);

static void svc_xprt_free(struct kref *kref)
{
	struct svc_xprt *xprt =
		container_of(kref, struct svc_xprt, xpt_ref);
	struct module *owner = xprt->xpt_class->xcl_owner;
	if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags)
	    && xprt->xpt_auth_cache != NULL)
		svcauth_unix_info_release(xprt->xpt_auth_cache);
	xprt->xpt_ops->xpo_free(xprt);
	module_put(owner);
}

void svc_xprt_put(struct svc_xprt *xprt)
{
	kref_put(&xprt->xpt_ref, svc_xprt_free);
}
EXPORT_SYMBOL_GPL(svc_xprt_put);

/*
 * Called by transport drivers to initialize the transport independent
 * portion of the transport instance.
 */
void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt,
		   struct svc_serv *serv)
{
	memset(xprt, 0, sizeof(*xprt));
	xprt->xpt_class = xcl;
	xprt->xpt_ops = xcl->xcl_ops;
	kref_init(&xprt->xpt_ref);
	xprt->xpt_server = serv;
	INIT_LIST_HEAD(&xprt->xpt_list);
	INIT_LIST_HEAD(&xprt->xpt_ready);
	INIT_LIST_HEAD(&xprt->xpt_deferred);
	mutex_init(&xprt->xpt_mutex);
	spin_lock_init(&xprt->xpt_lock);
}
EXPORT_SYMBOL_GPL(svc_xprt_init);

int svc_create_xprt(struct svc_serv *serv, char *xprt_name, unsigned short port,
		    int flags)
{
	struct svc_xprt_class *xcl;
	int ret = -ENOENT;
	struct sockaddr_in sin = {
		.sin_family		= AF_INET,
		.sin_addr.s_addr	= INADDR_ANY,
		.sin_port		= htons(port),
	};
	dprintk("svc: creating transport %s[%d]\n", xprt_name, port);
	spin_lock(&svc_xprt_class_lock);
	list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
		if (strcmp(xprt_name, xcl->xcl_name) == 0) {
			spin_unlock(&svc_xprt_class_lock);
			if (try_module_get(xcl->xcl_owner)) {
				struct svc_xprt *newxprt;
				ret = 0;
				newxprt = xcl->xcl_ops->xpo_create
					(serv,
					 (struct sockaddr *)&sin, sizeof(sin),
					 flags);
				if (IS_ERR(newxprt)) {
					module_put(xcl->xcl_owner);
					ret = PTR_ERR(newxprt);
				}
			}
			goto out;
		}
	}
	spin_unlock(&svc_xprt_class_lock);
	dprintk("svc: transport %s not found\n", xprt_name);
 out:
	return ret;
}
EXPORT_SYMBOL_GPL(svc_create_xprt);
Commit	Line	Data
1d8206b9 TT	1	/*
	2	* linux/net/sunrpc/svc_xprt.c
	3	*
	4	* Author: Tom Tucker <tom@opengridcomputing.com>
	5	*/
	6
	7	#include <linux/sched.h>
	8	#include <linux/errno.h>
	9	#include <linux/fcntl.h>
	10	#include <linux/net.h>
	11	#include <linux/in.h>
	12	#include <linux/inet.h>
	13	#include <linux/udp.h>
	14	#include <linux/tcp.h>
	15	#include <linux/unistd.h>
	16	#include <linux/slab.h>
	17	#include <linux/netdevice.h>
	18	#include <linux/skbuff.h>
	19	#include <linux/file.h>
	20	#include <linux/freezer.h>
	21	#include <net/sock.h>
	22	#include <net/checksum.h>
	23	#include <net/ip.h>
	24	#include <net/ipv6.h>
	25	#include <net/tcp_states.h>
	26	#include <linux/uaccess.h>
	27	#include <asm/ioctls.h>
	28
	29	#include <linux/sunrpc/types.h>
	30	#include <linux/sunrpc/clnt.h>
	31	#include <linux/sunrpc/xdr.h>
	32	#include <linux/sunrpc/svcsock.h>
	33	#include <linux/sunrpc/stats.h>
	34	#include <linux/sunrpc/svc_xprt.h>
	35
	36	#define RPCDBG_FACILITY RPCDBG_SVCXPRT
	37
	38	/* List of registered transport classes */
	39	static DEFINE_SPINLOCK(svc_xprt_class_lock);
	40	static LIST_HEAD(svc_xprt_class_list);
	41
	42	int svc_reg_xprt_class(struct svc_xprt_class *xcl)
	43	{
	44	struct svc_xprt_class *cl;
	45	int res = -EEXIST;
	46
	47	dprintk("svc: Adding svc transport class '%s'\n", xcl->xcl_name);
	48
	49	INIT_LIST_HEAD(&xcl->xcl_list);
	50	spin_lock(&svc_xprt_class_lock);
	51	/* Make sure there isn't already a class with the same name */
	52	list_for_each_entry(cl, &svc_xprt_class_list, xcl_list) {
	53	if (strcmp(xcl->xcl_name, cl->xcl_name) == 0)
	54	goto out;
	55	}
	56	list_add_tail(&xcl->xcl_list, &svc_xprt_class_list);
	57	res = 0;
	58	out:
	59	spin_unlock(&svc_xprt_class_lock);
	60	return res;
	61	}
	62	EXPORT_SYMBOL_GPL(svc_reg_xprt_class);
	63
	64	void svc_unreg_xprt_class(struct svc_xprt_class *xcl)
65	{
66	dprintk("svc: Removing svc transport class '%s'\n", xcl->xcl_name);
67	spin_lock(&svc_xprt_class_lock);
68	list_del_init(&xcl->xcl_list);
69	spin_unlock(&svc_xprt_class_lock);
70	}
71	EXPORT_SYMBOL_GPL(svc_unreg_xprt_class);
72
e1b3157f TT	73	static void svc_xprt_free(struct kref *kref)
	74	{
	75	struct svc_xprt *xprt =
	76	container_of(kref, struct svc_xprt, xpt_ref);
	77	struct module *owner = xprt->xpt_class->xcl_owner;
def13d74 TT	78	if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags)
	79	&& xprt->xpt_auth_cache != NULL)
	80	svcauth_unix_info_release(xprt->xpt_auth_cache);
e1b3157f TT	81	xprt->xpt_ops->xpo_free(xprt);
	82	module_put(owner);
	83	}
	84
	85	void svc_xprt_put(struct svc_xprt *xprt)
	86	{
	87	kref_put(&xprt->xpt_ref, svc_xprt_free);
	88	}
	89	EXPORT_SYMBOL_GPL(svc_xprt_put);
	90
1d8206b9 TT	91	/*
	92	* Called by transport drivers to initialize the transport independent
	93	* portion of the transport instance.
	94	*/
bb5cf160 TT	95	void svc_xprt_init(struct svc_xprt_class xcl, struct svc_xprt xprt,
bb5cf160 TT	96	struct svc_serv *serv)
1d8206b9 TT	97	{
	98	memset(xprt, 0, sizeof(*xprt));
	99	xprt->xpt_class = xcl;
	100	xprt->xpt_ops = xcl->xcl_ops;
e1b3157f	101	kref_init(&xprt->xpt_ref);
bb5cf160	102	xprt->xpt_server = serv;
7a182083 TT	103	INIT_LIST_HEAD(&xprt->xpt_list);
7a182083 TT	104	INIT_LIST_HEAD(&xprt->xpt_ready);
8c7b0172	105	INIT_LIST_HEAD(&xprt->xpt_deferred);
a50fea26	106	mutex_init(&xprt->xpt_mutex);
def13d74	107	spin_lock_init(&xprt->xpt_lock);
1d8206b9 TT	108	}
1d8206b9 TT	109	EXPORT_SYMBOL_GPL(svc_xprt_init);
b700cbb1 TT	110
	111	int svc_create_xprt(struct svc_serv serv, char xprt_name, unsigned short port,
	112	int flags)
	113	{
	114	struct svc_xprt_class *xcl;
	115	int ret = -ENOENT;
	116	struct sockaddr_in sin = {
	117	.sin_family = AF_INET,
	118	.sin_addr.s_addr = INADDR_ANY,
	119	.sin_port = htons(port),
	120	};
	121	dprintk("svc: creating transport %s[%d]\n", xprt_name, port);
	122	spin_lock(&svc_xprt_class_lock);
	123	list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
	124	if (strcmp(xprt_name, xcl->xcl_name) == 0) {
	125	spin_unlock(&svc_xprt_class_lock);
	126	if (try_module_get(xcl->xcl_owner)) {
	127	struct svc_xprt *newxprt;
	128	ret = 0;
	129	newxprt = xcl->xcl_ops->xpo_create
	130	(serv,
	131	(struct sockaddr *)&sin, sizeof(sin),
	132	flags);
	133	if (IS_ERR(newxprt)) {
	134	module_put(xcl->xcl_owner);
	135	ret = PTR_ERR(newxprt);
	136	}
	137	}
	138	goto out;
	139	}
	140	}
	141	spin_unlock(&svc_xprt_class_lock);
	142	dprintk("svc: transport %s not found\n", xprt_name);
	143	out:
	144	return ret;
	145	}
	146	EXPORT_SYMBOL_GPL(svc_create_xprt);