[linux.git] / fs / afs / main.c

/* AFS client file system
 *
 * Copyright (C) 2002,5 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/completion.h>
#include <linux/sched.h>
#include <linux/random.h>
#include <linux/proc_fs.h>
#define CREATE_TRACE_POINTS
#include "internal.h"

MODULE_DESCRIPTION("AFS Client File System");
MODULE_AUTHOR("Red Hat, Inc.");
MODULE_LICENSE("GPL");

unsigned afs_debug;
module_param_named(debug, afs_debug, uint, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(debug, "AFS debugging mask");

static char *rootcell;

module_param(rootcell, charp, 0);
MODULE_PARM_DESC(rootcell, "root AFS cell name and VL server IP addr list");

struct workqueue_struct *afs_wq;
static struct proc_dir_entry *afs_proc_symlink;

#if defined(CONFIG_ALPHA)
const char afs_init_sysname[] = "alpha_linux26";
#elif defined(CONFIG_X86_64)
const char afs_init_sysname[] = "amd64_linux26";
#elif defined(CONFIG_ARM)
const char afs_init_sysname[] = "arm_linux26";
#elif defined(CONFIG_ARM64)
const char afs_init_sysname[] = "aarch64_linux26";
#elif defined(CONFIG_X86_32)
const char afs_init_sysname[] = "i386_linux26";
#elif defined(CONFIG_IA64)
const char afs_init_sysname[] = "ia64_linux26";
#elif defined(CONFIG_PPC64)
const char afs_init_sysname[] = "ppc64_linux26";
#elif defined(CONFIG_PPC32)
const char afs_init_sysname[] = "ppc_linux26";
#elif defined(CONFIG_S390)
#ifdef CONFIG_64BIT
const char afs_init_sysname[] = "s390x_linux26";
#else
const char afs_init_sysname[] = "s390_linux26";
#endif
#elif defined(CONFIG_SPARC64)
const char afs_init_sysname[] = "sparc64_linux26";
#elif defined(CONFIG_SPARC32)
const char afs_init_sysname[] = "sparc_linux26";
#else
const char afs_init_sysname[] = "unknown_linux26";
#endif

/*
 * Initialise an AFS network namespace record.
 */
static int __net_init afs_net_init(struct net *net_ns)
{
	struct afs_sysnames *sysnames;
	struct afs_net *net = afs_net(net_ns);
	int ret;

	net->net = net_ns;
	net->live = true;
	generate_random_uuid((unsigned char *)&net->uuid);

	INIT_WORK(&net->charge_preallocation_work, afs_charge_preallocation);
	mutex_init(&net->socket_mutex);

	net->cells = RB_ROOT;
	seqlock_init(&net->cells_lock);
	INIT_WORK(&net->cells_manager, afs_manage_cells);
	timer_setup(&net->cells_timer, afs_cells_timer, 0);

	mutex_init(&net->proc_cells_lock);
	INIT_LIST_HEAD(&net->proc_cells);

	seqlock_init(&net->fs_lock);
	net->fs_servers = RB_ROOT;
	INIT_LIST_HEAD(&net->fs_updates);
	INIT_HLIST_HEAD(&net->fs_proc);

	INIT_HLIST_HEAD(&net->fs_addresses4);
	INIT_HLIST_HEAD(&net->fs_addresses6);
	seqlock_init(&net->fs_addr_lock);

	INIT_WORK(&net->fs_manager, afs_manage_servers);
	timer_setup(&net->fs_timer, afs_servers_timer, 0);

	ret = -ENOMEM;
	sysnames = kzalloc(sizeof(*sysnames), GFP_KERNEL);
	if (!sysnames)
		goto error_sysnames;
	sysnames->subs[0] = (char *)&afs_init_sysname;
	sysnames->nr = 1;
	refcount_set(&sysnames->usage, 1);
	net->sysnames = sysnames;
	rwlock_init(&net->sysnames_lock);

	/* Register the /proc stuff */
	ret = afs_proc_init(net);
	if (ret < 0)
		goto error_proc;

	/* Initialise the cell DB */
	ret = afs_cell_init(net, rootcell);
	if (ret < 0)
		goto error_cell_init;

	/* Create the RxRPC transport */
	ret = afs_open_socket(net);
	if (ret < 0)
		goto error_open_socket;

	return 0;

error_open_socket:
	net->live = false;
	afs_cell_purge(net);
	afs_purge_servers(net);
error_cell_init:
	net->live = false;
	afs_proc_cleanup(net);
error_proc:
	afs_put_sysnames(net->sysnames);
error_sysnames:
	net->live = false;
	return ret;
}

/*
 * Clean up and destroy an AFS network namespace record.
 */
static void __net_exit afs_net_exit(struct net *net_ns)
{
	struct afs_net *net = afs_net(net_ns);

	net->live = false;
	afs_cell_purge(net);
	afs_purge_servers(net);
	afs_close_socket(net);
	afs_proc_cleanup(net);
	afs_put_sysnames(net->sysnames);
}

static struct pernet_operations afs_net_ops = {
	.init	= afs_net_init,
	.exit	= afs_net_exit,
	.id	= &afs_net_id,
	.size	= sizeof(struct afs_net),
};

/*
 * initialise the AFS client FS module
 */
static int __init afs_init(void)
{
	int ret = -ENOMEM;

	printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 registering.\n");

	afs_wq = alloc_workqueue("afs", 0, 0);
	if (!afs_wq)
		goto error_afs_wq;
	afs_async_calls = alloc_workqueue("kafsd", WQ_MEM_RECLAIM, 0);
	if (!afs_async_calls)
		goto error_async;
	afs_lock_manager = alloc_workqueue("kafs_lockd", WQ_MEM_RECLAIM, 0);
	if (!afs_lock_manager)
		goto error_lockmgr;

#ifdef CONFIG_AFS_FSCACHE
	/* we want to be able to cache */
	ret = fscache_register_netfs(&afs_cache_netfs);
	if (ret < 0)
		goto error_cache;
#endif

	ret = register_pernet_subsys(&afs_net_ops);
	if (ret < 0)
		goto error_net;

	/* register the filesystems */
	ret = afs_fs_init();
	if (ret < 0)
		goto error_fs;

	afs_proc_symlink = proc_symlink("fs/afs", NULL, "../self/net/afs");
	if (IS_ERR(afs_proc_symlink)) {
		ret = PTR_ERR(afs_proc_symlink);
		goto error_proc;
	}

	return ret;

error_proc:
	afs_fs_exit();
error_fs:
	unregister_pernet_subsys(&afs_net_ops);
error_net:
#ifdef CONFIG_AFS_FSCACHE
	fscache_unregister_netfs(&afs_cache_netfs);
error_cache:
#endif
	destroy_workqueue(afs_lock_manager);
error_lockmgr:
	destroy_workqueue(afs_async_calls);
error_async:
	destroy_workqueue(afs_wq);
error_afs_wq:
	rcu_barrier();
	printk(KERN_ERR "kAFS: failed to register: %d\n", ret);
	return ret;
}

/* XXX late_initcall is kludgy, but the only alternative seems to create
 * a transport upon the first mount, which is worse. Or is it?
 */
late_initcall(afs_init);	/* must be called after net/ to create socket */

/*
 * clean up on module removal
 */
static void __exit afs_exit(void)
{
	printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n");

	proc_remove(afs_proc_symlink);
	afs_fs_exit();
	unregister_pernet_subsys(&afs_net_ops);
#ifdef CONFIG_AFS_FSCACHE
	fscache_unregister_netfs(&afs_cache_netfs);
#endif
	destroy_workqueue(afs_lock_manager);
	destroy_workqueue(afs_async_calls);
	destroy_workqueue(afs_wq);
	afs_clean_up_permit_cache();
	rcu_barrier();
}

module_exit(afs_exit);
Commit	Line	Data
ec26815a	1	/* AFS client file system
1da177e4	2	*
9b3f26c9	3	* Copyright (C) 2002,5 Red Hat, Inc. All Rights Reserved.
1da177e4 LT	4	* Written by David Howells ([email protected])
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/moduleparam.h>
	14	#include <linux/init.h>
1da177e4	15	#include <linux/completion.h>
e8edc6e0	16	#include <linux/sched.h>
e0661dfc	17	#include <linux/random.h>
5b86d4ff	18	#include <linux/proc_fs.h>
8e8d7f13	19	#define CREATE_TRACE_POINTS
1da177e4 LT	20	#include "internal.h"
1da177e4 LT	21
1da177e4 LT	22	MODULE_DESCRIPTION("AFS Client File System");
	23	MODULE_AUTHOR("Red Hat, Inc.");
	24	MODULE_LICENSE("GPL");
	25
08e0e7c8 DH	26	unsigned afs_debug;
08e0e7c8 DH	27	module_param_named(debug, afs_debug, uint, S_IWUSR \| S_IRUGO);
424b00e2	28	MODULE_PARM_DESC(debug, "AFS debugging mask");
08e0e7c8	29
1da177e4 LT	30	static char *rootcell;
	31
	32	module_param(rootcell, charp, 0);
	33	MODULE_PARM_DESC(rootcell, "root AFS cell name and VL server IP addr list");
	34
0ad53eee	35	struct workqueue_struct *afs_wq;
5b86d4ff	36	static struct proc_dir_entry *afs_proc_symlink;
f044c884	37
6f8880d8 DH	38	#if defined(CONFIG_ALPHA)
	39	const char afs_init_sysname[] = "alpha_linux26";
	40	#elif defined(CONFIG_X86_64)
	41	const char afs_init_sysname[] = "amd64_linux26";
	42	#elif defined(CONFIG_ARM)
	43	const char afs_init_sysname[] = "arm_linux26";
	44	#elif defined(CONFIG_ARM64)
	45	const char afs_init_sysname[] = "aarch64_linux26";
	46	#elif defined(CONFIG_X86_32)
	47	const char afs_init_sysname[] = "i386_linux26";
	48	#elif defined(CONFIG_IA64)
	49	const char afs_init_sysname[] = "ia64_linux26";
	50	#elif defined(CONFIG_PPC64)
	51	const char afs_init_sysname[] = "ppc64_linux26";
	52	#elif defined(CONFIG_PPC32)
	53	const char afs_init_sysname[] = "ppc_linux26";
	54	#elif defined(CONFIG_S390)
	55	#ifdef CONFIG_64BIT
	56	const char afs_init_sysname[] = "s390x_linux26";
	57	#else
	58	const char afs_init_sysname[] = "s390_linux26";
	59	#endif
	60	#elif defined(CONFIG_SPARC64)
	61	const char afs_init_sysname[] = "sparc64_linux26";
	62	#elif defined(CONFIG_SPARC32)
	63	const char afs_init_sysname[] = "sparc_linux26";
	64	#else
	65	const char afs_init_sysname[] = "unknown_linux26";
	66	#endif
	67
f044c884 DH	68	/*
	69	* Initialise an AFS network namespace record.
	70	*/
5b86d4ff	71	static int __net_init afs_net_init(struct net *net_ns)
f044c884	72	{
6f8880d8	73	struct afs_sysnames *sysnames;
5b86d4ff	74	struct afs_net *net = afs_net(net_ns);
f044c884 DH	75	int ret;
f044c884 DH	76
5b86d4ff	77	net->net = net_ns;
f044c884 DH	78	net->live = true;
	79	generate_random_uuid((unsigned char *)&net->uuid);
	80
	81	INIT_WORK(&net->charge_preallocation_work, afs_charge_preallocation);
	82	mutex_init(&net->socket_mutex);
989782dc DH	83
	84	net->cells = RB_ROOT;
	85	seqlock_init(&net->cells_lock);
	86	INIT_WORK(&net->cells_manager, afs_manage_cells);
	87	timer_setup(&net->cells_timer, afs_cells_timer, 0);
	88
0da0b7fd	89	mutex_init(&net->proc_cells_lock);
f044c884	90	INIT_LIST_HEAD(&net->proc_cells);
989782dc	91
d2ddc776 DH	92	seqlock_init(&net->fs_lock);
	93	net->fs_servers = RB_ROOT;
	94	INIT_LIST_HEAD(&net->fs_updates);
	95	INIT_HLIST_HEAD(&net->fs_proc);
	96
	97	INIT_HLIST_HEAD(&net->fs_addresses4);
	98	INIT_HLIST_HEAD(&net->fs_addresses6);
	99	seqlock_init(&net->fs_addr_lock);
	100
	101	INIT_WORK(&net->fs_manager, afs_manage_servers);
	102	timer_setup(&net->fs_timer, afs_servers_timer, 0);
f044c884	103
6f8880d8 DH	104	ret = -ENOMEM;
	105	sysnames = kzalloc(sizeof(*sysnames), GFP_KERNEL);
	106	if (!sysnames)
	107	goto error_sysnames;
	108	sysnames->subs[0] = (char *)&afs_init_sysname;
	109	sysnames->nr = 1;
	110	refcount_set(&sysnames->usage, 1);
	111	net->sysnames = sysnames;
	112	rwlock_init(&net->sysnames_lock);
	113
f044c884 DH	114	/* Register the /proc stuff */
	115	ret = afs_proc_init(net);
	116	if (ret < 0)
	117	goto error_proc;
	118
	119	/* Initialise the cell DB */
	120	ret = afs_cell_init(net, rootcell);
	121	if (ret < 0)
	122	goto error_cell_init;
	123
	124	/* Create the RxRPC transport */
	125	ret = afs_open_socket(net);
	126	if (ret < 0)
	127	goto error_open_socket;
	128
	129	return 0;
	130
	131	error_open_socket:
989782dc	132	net->live = false;
f044c884	133	afs_cell_purge(net);
d2ddc776	134	afs_purge_servers(net);
f044c884	135	error_cell_init:
989782dc	136	net->live = false;
f044c884 DH	137	afs_proc_cleanup(net);
f044c884 DH	138	error_proc:
6f8880d8 DH	139	afs_put_sysnames(net->sysnames);
6f8880d8 DH	140	error_sysnames:
989782dc	141	net->live = false;
f044c884 DH	142	return ret;
	143	}
	144
	145	/*
	146	* Clean up and destroy an AFS network namespace record.
	147	*/
5b86d4ff	148	static void __net_exit afs_net_exit(struct net *net_ns)
f044c884	149	{
5b86d4ff DH	150	struct afs_net *net = afs_net(net_ns);
5b86d4ff DH	151
f044c884	152	net->live = false;
f044c884	153	afs_cell_purge(net);
d2ddc776	154	afs_purge_servers(net);
e3b2ffe0	155	afs_close_socket(net);
f044c884	156	afs_proc_cleanup(net);
6f8880d8	157	afs_put_sysnames(net->sysnames);
f044c884	158	}
b908fe6b	159
5b86d4ff DH	160	static struct pernet_operations afs_net_ops = {
	161	.init = afs_net_init,
	162	.exit = afs_net_exit,
	163	.id = &afs_net_id,
	164	.size = sizeof(struct afs_net),
	165	};
	166
1da177e4 LT	167	/*
	168	* initialise the AFS client FS module
	169	*/
	170	static int __init afs_init(void)
	171	{
f044c884	172	int ret = -ENOMEM;
1da177e4 LT	173
	174	printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 registering.\n");
	175
0ad53eee TH	176	afs_wq = alloc_workqueue("afs", 0, 0);
0ad53eee TH	177	if (!afs_wq)
f044c884 DH	178	goto error_afs_wq;
	179	afs_async_calls = alloc_workqueue("kafsd", WQ_MEM_RECLAIM, 0);
	180	if (!afs_async_calls)
	181	goto error_async;
f044c884 DH	182	afs_lock_manager = alloc_workqueue("kafs_lockd", WQ_MEM_RECLAIM, 0);
	183	if (!afs_lock_manager)
	184	goto error_lockmgr;
1da177e4	185
9b3f26c9	186	#ifdef CONFIG_AFS_FSCACHE
1da177e4	187	/* we want to be able to cache */
9b3f26c9	188	ret = fscache_register_netfs(&afs_cache_netfs);
1da177e4 LT	189	if (ret < 0)
	190	goto error_cache;
	191	#endif
	192
5b86d4ff	193	ret = register_pernet_subsys(&afs_net_ops);
df44f9f4	194	if (ret < 0)
f044c884	195	goto error_net;
1da177e4 LT	196
	197	/* register the filesystems */
	198	ret = afs_fs_init();
	199	if (ret < 0)
ec26815a	200	goto error_fs;
1da177e4	201
5b86d4ff DH	202	afs_proc_symlink = proc_symlink("fs/afs", NULL, "../self/net/afs");
	203	if (IS_ERR(afs_proc_symlink)) {
	204	ret = PTR_ERR(afs_proc_symlink);
	205	goto error_proc;
	206	}
	207
1da177e4 LT	208	return ret;
1da177e4 LT	209
5b86d4ff DH	210	error_proc:
5b86d4ff DH	211	afs_fs_exit();
ec26815a	212	error_fs:
5b86d4ff	213	unregister_pernet_subsys(&afs_net_ops);
f044c884	214	error_net:
9b3f26c9 DH	215	#ifdef CONFIG_AFS_FSCACHE
9b3f26c9 DH	216	fscache_unregister_netfs(&afs_cache_netfs);
ec26815a	217	error_cache:
1da177e4	218	#endif
f044c884 DH	219	destroy_workqueue(afs_lock_manager);
f044c884 DH	220	error_lockmgr:
f044c884 DH	221	destroy_workqueue(afs_async_calls);
f044c884 DH	222	error_async:
0ad53eee	223	destroy_workqueue(afs_wq);
f044c884	224	error_afs_wq:
416351f2	225	rcu_barrier();
1da177e4 LT	226	printk(KERN_ERR "kAFS: failed to register: %d\n", ret);
1da177e4 LT	227	return ret;
ec26815a	228	}
1da177e4 LT	229
	230	/* XXX late_initcall is kludgy, but the only alternative seems to create
	231	* a transport upon the first mount, which is worse. Or is it?
	232	*/
	233	late_initcall(afs_init); /* must be called after net/ to create socket */
ec26815a	234
1da177e4 LT	235	/*
	236	* clean up on module removal
	237	*/
	238	static void __exit afs_exit(void)
	239	{
	240	printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n");
	241
5b86d4ff	242	proc_remove(afs_proc_symlink);
1da177e4	243	afs_fs_exit();
5b86d4ff	244	unregister_pernet_subsys(&afs_net_ops);
9b3f26c9 DH	245	#ifdef CONFIG_AFS_FSCACHE
9b3f26c9 DH	246	fscache_unregister_netfs(&afs_cache_netfs);
1da177e4	247	#endif
f044c884	248	destroy_workqueue(afs_lock_manager);
f044c884 DH	249	destroy_workqueue(afs_async_calls);
f044c884 DH	250	destroy_workqueue(afs_wq);
be080a6f	251	afs_clean_up_permit_cache();
416351f2	252	rcu_barrier();
ec26815a	253	}
1da177e4 LT	254
1da177e4 LT	255	module_exit(afs_exit);