[mirror_ubuntu-jammy-kernel.git] / net / 9p / mod.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  net/9p/9p.c
 *
 *  9P entry point
 *
 *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/moduleparam.h>
#include <net/9p/9p.h>
#include <linux/fs.h>
#include <linux/parser.h>
#include <net/9p/client.h>
#include <net/9p/transport.h>
#include <linux/list.h>
#include <linux/spinlock.h>

#ifdef CONFIG_NET_9P_DEBUG
unsigned int p9_debug_level = 0;	/* feature-rific global debug level  */
EXPORT_SYMBOL(p9_debug_level);
module_param_named(debug, p9_debug_level, uint, 0);
MODULE_PARM_DESC(debug, "9P debugging level");

void _p9_debug(enum p9_debug_flags level, const char *func,
		const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;

	if ((p9_debug_level & level) != level)
		return;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

	if (level == P9_DEBUG_9P)
		pr_notice("(%8.8d) %pV", task_pid_nr(current), &vaf);
	else
		pr_notice("-- %s (%d): %pV", func, task_pid_nr(current), &vaf);

	va_end(args);
}
EXPORT_SYMBOL(_p9_debug);
#endif

/*
 * Dynamic Transport Registration Routines
 *
 */

static DEFINE_SPINLOCK(v9fs_trans_lock);
static LIST_HEAD(v9fs_trans_list);

/**
 * v9fs_register_trans - register a new transport with 9p
 * @m: structure describing the transport module and entry points
 *
 */
void v9fs_register_trans(struct p9_trans_module *m)
{
	spin_lock(&v9fs_trans_lock);
	list_add_tail(&m->list, &v9fs_trans_list);
	spin_unlock(&v9fs_trans_lock);
}
EXPORT_SYMBOL(v9fs_register_trans);

/**
 * v9fs_unregister_trans - unregister a 9p transport
 * @m: the transport to remove
 *
 */
void v9fs_unregister_trans(struct p9_trans_module *m)
{
	spin_lock(&v9fs_trans_lock);
	list_del_init(&m->list);
	spin_unlock(&v9fs_trans_lock);
}
EXPORT_SYMBOL(v9fs_unregister_trans);

/**
 * v9fs_get_trans_by_name - get transport with the matching name
 * @s: string identifying transport
 *
 */
struct p9_trans_module *v9fs_get_trans_by_name(char *s)
{
	struct p9_trans_module *t, *found = NULL;

	spin_lock(&v9fs_trans_lock);

	list_for_each_entry(t, &v9fs_trans_list, list)
		if (strcmp(t->name, s) == 0 &&
		    try_module_get(t->owner)) {
			found = t;
			break;
		}

	spin_unlock(&v9fs_trans_lock);
	return found;
}
EXPORT_SYMBOL(v9fs_get_trans_by_name);

/**
 * v9fs_get_default_trans - get the default transport
 *
 */

struct p9_trans_module *v9fs_get_default_trans(void)
{
	struct p9_trans_module *t, *found = NULL;

	spin_lock(&v9fs_trans_lock);

	list_for_each_entry(t, &v9fs_trans_list, list)
		if (t->def && try_module_get(t->owner)) {
			found = t;
			break;
		}

	if (!found)
		list_for_each_entry(t, &v9fs_trans_list, list)
			if (try_module_get(t->owner)) {
				found = t;
				break;
			}

	spin_unlock(&v9fs_trans_lock);
	return found;
}
EXPORT_SYMBOL(v9fs_get_default_trans);

/**
 * v9fs_put_trans - put trans
 * @m: transport to put
 *
 */
void v9fs_put_trans(struct p9_trans_module *m)
{
	if (m)
		module_put(m->owner);
}

/**
 * init_p9 - Initialize module
 *
 */
static int __init init_p9(void)
{
	int ret;

	ret = p9_client_init();
	if (ret)
		return ret;

	p9_error_init();
	pr_info("Installing 9P2000 support\n");
	p9_trans_fd_init();

	return ret;
}

/**
 * exit_p9 - shutdown module
 *
 */

static void __exit exit_p9(void)
{
	pr_info("Unloading 9P2000 support\n");

	p9_trans_fd_exit();
	p9_client_exit();
}

module_init(init_p9)
module_exit(exit_p9)

MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Plan 9 Resource Sharing Support (9P2000)");
Commit	Line	Data
1f327613	1	// SPDX-License-Identifier: GPL-2.0-only
bd238fb4 LI	2	/*
	3	* net/9p/9p.c
	4	*
	5	* 9P entry point
	6	*
	7	* Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
	8	* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
	9	* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
bd238fb4 LI	10	*/
bd238fb4 LI	11
5d385153 JP	12	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
5d385153 JP	13
bd238fb4	14	#include <linux/module.h>
5d385153 JP	15	#include <linux/errno.h>
5d385153 JP	16	#include <linux/sched.h>
bd238fb4 LI	17	#include <linux/moduleparam.h>
bd238fb4 LI	18	#include <net/9p/9p.h>
fb0466c3 EVH	19	#include <linux/fs.h>
fb0466c3 EVH	20	#include <linux/parser.h>
8b81ef58	21	#include <net/9p/client.h>
fb0466c3 EVH	22	#include <net/9p/transport.h>
fb0466c3 EVH	23	#include <linux/list.h>
72029fe8	24	#include <linux/spinlock.h>
bd238fb4 LI	25
	26	#ifdef CONFIG_NET_9P_DEBUG
	27	unsigned int p9_debug_level = 0; /* feature-rific global debug level */
	28	EXPORT_SYMBOL(p9_debug_level);
	29	module_param_named(debug, p9_debug_level, uint, 0);
	30	MODULE_PARM_DESC(debug, "9P debugging level");
5d385153 JP	31
	32	void _p9_debug(enum p9_debug_flags level, const char *func,
	33	const char *fmt, ...)
	34	{
	35	struct va_format vaf;
	36	va_list args;
	37
	38	if ((p9_debug_level & level) != level)
	39	return;
	40
	41	va_start(args, fmt);
	42
	43	vaf.fmt = fmt;
	44	vaf.va = &args;
	45
	46	if (level == P9_DEBUG_9P)
	47	pr_notice("(%8.8d) %pV", task_pid_nr(current), &vaf);
	48	else
	49	pr_notice("-- %s (%d): %pV", func, task_pid_nr(current), &vaf);
	50
	51	va_end(args);
	52	}
	53	EXPORT_SYMBOL(_p9_debug);
bd238fb4 LI	54	#endif
bd238fb4 LI	55
fb0466c3 EVH	56	/*
	57	* Dynamic Transport Registration Routines
	58	*
	59	*/
	60
72029fe8	61	static DEFINE_SPINLOCK(v9fs_trans_lock);
fb0466c3	62	static LIST_HEAD(v9fs_trans_list);
fb0466c3 EVH	63
	64	/**
	65	* v9fs_register_trans - register a new transport with 9p
ee443996	66	* @m: structure describing the transport module and entry points
fb0466c3 EVH	67	*
	68	*/
	69	void v9fs_register_trans(struct p9_trans_module *m)
	70	{
72029fe8	71	spin_lock(&v9fs_trans_lock);
fb0466c3	72	list_add_tail(&m->list, &v9fs_trans_list);
72029fe8	73	spin_unlock(&v9fs_trans_lock);
fb0466c3 EVH	74	}
	75	EXPORT_SYMBOL(v9fs_register_trans);
	76
	77	/**
72029fe8 TH	78	* v9fs_unregister_trans - unregister a 9p transport
	79	* @m: the transport to remove
	80	*
	81	*/
	82	void v9fs_unregister_trans(struct p9_trans_module *m)
	83	{
	84	spin_lock(&v9fs_trans_lock);
	85	list_del_init(&m->list);
	86	spin_unlock(&v9fs_trans_lock);
	87	}
	88	EXPORT_SYMBOL(v9fs_unregister_trans);
	89
	90	/**
	91	* v9fs_get_trans_by_name - get transport with the matching name
3a443bd6	92	* @s: string identifying transport
fb0466c3 EVH	93	*
fb0466c3 EVH	94	*/
4d63055f	95	struct p9_trans_module v9fs_get_trans_by_name(char s)
fb0466c3	96	{
72029fe8 TH	97	struct p9_trans_module t, found = NULL;
	98
	99	spin_lock(&v9fs_trans_lock);
	100
	101	list_for_each_entry(t, &v9fs_trans_list, list)
4d63055f	102	if (strcmp(t->name, s) == 0 &&
72029fe8 TH	103	try_module_get(t->owner)) {
	104	found = t;
	105	break;
	106	}
	107
	108	spin_unlock(&v9fs_trans_lock);
	109	return found;
fb0466c3	110	}
72029fe8	111	EXPORT_SYMBOL(v9fs_get_trans_by_name);
fb0466c3 EVH	112
fb0466c3 EVH	113	/**
72029fe8	114	* v9fs_get_default_trans - get the default transport
fb0466c3 EVH	115	*
	116	*/
	117
72029fe8	118	struct p9_trans_module *v9fs_get_default_trans(void)
fb0466c3	119	{
72029fe8 TH	120	struct p9_trans_module t, found = NULL;
	121
	122	spin_lock(&v9fs_trans_lock);
	123
	124	list_for_each_entry(t, &v9fs_trans_list, list)
	125	if (t->def && try_module_get(t->owner)) {
	126	found = t;
	127	break;
	128	}
	129
	130	if (!found)
	131	list_for_each_entry(t, &v9fs_trans_list, list)
	132	if (try_module_get(t->owner)) {
	133	found = t;
	134	break;
	135	}
	136
	137	spin_unlock(&v9fs_trans_lock);
	138	return found;
fb0466c3	139	}
72029fe8	140	EXPORT_SYMBOL(v9fs_get_default_trans);
fb0466c3	141
72029fe8 TH	142	/**
	143	* v9fs_put_trans - put trans
	144	* @m: transport to put
	145	*
	146	*/
	147	void v9fs_put_trans(struct p9_trans_module *m)
	148	{
	149	if (m)
	150	module_put(m->owner);
	151	}
fb0466c3	152
bd238fb4	153	/**
961a5a50	154	* init_p9 - Initialize module
bd238fb4 LI	155	*
	156	*/
	157	static int __init init_p9(void)
	158	{
996d5b4d MW	159	int ret;
	160
	161	ret = p9_client_init();
	162	if (ret)
	163	return ret;
	164
bd238fb4	165	p9_error_init();
5d385153	166	pr_info("Installing 9P2000 support\n");
887b3ece	167	p9_trans_fd_init();
bd238fb4	168
996d5b4d	169	return ret;
bd238fb4 LI	170	}
	171
	172	/**
961a5a50	173	* exit_p9 - shutdown module
bd238fb4 LI	174	*
	175	*/
	176
	177	static void __exit exit_p9(void)
	178	{
5d385153	179	pr_info("Unloading 9P2000 support\n");
72029fe8 TH	180
72029fe8 TH	181	p9_trans_fd_exit();
996d5b4d	182	p9_client_exit();
bd238fb4 LI	183	}
	184
	185	module_init(init_p9)
	186	module_exit(exit_p9)
	187
	188	MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
	189	MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
	190	MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
	191	MODULE_LICENSE("GPL");
67c20de3	192	MODULE_DESCRIPTION("Plan 9 Resource Sharing Support (9P2000)");