1/*
2  FUSE: Filesystem in Userspace
3  Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
4
5  This program can be distributed under the terms of the GNU GPL.
6  See the file COPYING.
7*/
8
9#include "fuse_i.h"
10
11#include <linux/pagemap.h>
12#include <linux/slab.h>
13#include <linux/file.h>
14#include <linux/seq_file.h>
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/parser.h>
18#include <linux/statfs.h>
19#include <linux/random.h>
20#include <linux/sched.h>
21
22MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
23MODULE_DESCRIPTION("Filesystem in Userspace");
24MODULE_LICENSE("GPL");
25
26static struct kmem_cache *fuse_inode_cachep;
27struct list_head fuse_conn_list;
28DEFINE_MUTEX(fuse_mutex);
29
30#define FUSE_SUPER_MAGIC 0x65735546
31
32struct fuse_mount_data {
33	int fd;
34	unsigned rootmode;
35	unsigned user_id;
36	unsigned group_id;
37	unsigned fd_present : 1;
38	unsigned rootmode_present : 1;
39	unsigned user_id_present : 1;
40	unsigned group_id_present : 1;
41	unsigned flags;
42	unsigned max_read;
43	unsigned blksize;
44};
45
46static struct inode *fuse_alloc_inode(struct super_block *sb)
47{
48	struct inode *inode;
49	struct fuse_inode *fi;
50
51	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
52	if (!inode)
53		return NULL;
54
55	fi = get_fuse_inode(inode);
56	fi->i_time = 0;
57	fi->nodeid = 0;
58	fi->nlookup = 0;
59	fi->forget_req = fuse_request_alloc();
60	if (!fi->forget_req) {
61		kmem_cache_free(fuse_inode_cachep, inode);
62		return NULL;
63	}
64
65	return inode;
66}
67
68static void fuse_destroy_inode(struct inode *inode)
69{
70	struct fuse_inode *fi = get_fuse_inode(inode);
71	if (fi->forget_req)
72		fuse_request_free(fi->forget_req);
73	kmem_cache_free(fuse_inode_cachep, inode);
74}
75
76static void fuse_read_inode(struct inode *inode)
77{
78	/* No op */
79}
80
81void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
82		      unsigned long nodeid, u64 nlookup)
83{
84	struct fuse_forget_in *inarg = &req->misc.forget_in;
85	inarg->nlookup = nlookup;
86	req->in.h.opcode = FUSE_FORGET;
87	req->in.h.nodeid = nodeid;
88	req->in.numargs = 1;
89	req->in.args[0].size = sizeof(struct fuse_forget_in);
90	req->in.args[0].value = inarg;
91	request_send_noreply(fc, req);
92}
93
94static void fuse_clear_inode(struct inode *inode)
95{
96	if (inode->i_sb->s_flags & MS_ACTIVE) {
97		struct fuse_conn *fc = get_fuse_conn(inode);
98		struct fuse_inode *fi = get_fuse_inode(inode);
99		fuse_send_forget(fc, fi->forget_req, fi->nodeid, fi->nlookup);
100		fi->forget_req = NULL;
101	}
102}
103
104static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
105{
106	if (*flags & MS_MANDLOCK)
107		return -EINVAL;
108
109	return 0;
110}
111
112void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
113{
114	struct fuse_conn *fc = get_fuse_conn(inode);
115	if (S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size)
116		invalidate_mapping_pages(inode->i_mapping, 0, -1);
117
118	inode->i_ino     = attr->ino;
119	inode->i_mode    = (inode->i_mode & S_IFMT) + (attr->mode & 07777);
120	inode->i_nlink   = attr->nlink;
121	inode->i_uid     = attr->uid;
122	inode->i_gid     = attr->gid;
123	spin_lock(&fc->lock);
124	i_size_write(inode, attr->size);
125	spin_unlock(&fc->lock);
126	inode->i_blocks  = attr->blocks;
127	inode->i_atime.tv_sec   = attr->atime;
128	inode->i_atime.tv_nsec  = attr->atimensec;
129	inode->i_mtime.tv_sec   = attr->mtime;
130	inode->i_mtime.tv_nsec  = attr->mtimensec;
131	inode->i_ctime.tv_sec   = attr->ctime;
132	inode->i_ctime.tv_nsec  = attr->ctimensec;
133}
134
135static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
136{
137	inode->i_mode = attr->mode & S_IFMT;
138	inode->i_size = attr->size;
139	if (S_ISREG(inode->i_mode)) {
140		fuse_init_common(inode);
141		fuse_init_file_inode(inode);
142	} else if (S_ISDIR(inode->i_mode))
143		fuse_init_dir(inode);
144	else if (S_ISLNK(inode->i_mode))
145		fuse_init_symlink(inode);
146	else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
147		 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
148		fuse_init_common(inode);
149		init_special_inode(inode, inode->i_mode,
150				   new_decode_dev(attr->rdev));
151	} else
152		BUG();
153}
154
155static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
156{
157	unsigned long nodeid = *(unsigned long *) _nodeidp;
158	if (get_node_id(inode) == nodeid)
159		return 1;
160	else
161		return 0;
162}
163
164static int fuse_inode_set(struct inode *inode, void *_nodeidp)
165{
166	unsigned long nodeid = *(unsigned long *) _nodeidp;
167	get_fuse_inode(inode)->nodeid = nodeid;
168	return 0;
169}
170
171struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
172			int generation, struct fuse_attr *attr)
173{
174	struct inode *inode;
175	struct fuse_inode *fi;
176	struct fuse_conn *fc = get_fuse_conn_super(sb);
177
178 retry:
179	inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
180	if (!inode)
181		return NULL;
182
183	if ((inode->i_state & I_NEW)) {
184		inode->i_flags |= S_NOATIME|S_NOCMTIME;
185		inode->i_generation = generation;
186		inode->i_data.backing_dev_info = &fc->bdi;
187		fuse_init_inode(inode, attr);
188		unlock_new_inode(inode);
189	} else if ((inode->i_mode ^ attr->mode) & S_IFMT) {
190		/* Inode has changed type, any I/O on the old should fail */
191		make_bad_inode(inode);
192		iput(inode);
193		goto retry;
194	}
195
196	fi = get_fuse_inode(inode);
197	spin_lock(&fc->lock);
198	fi->nlookup ++;
199	spin_unlock(&fc->lock);
200	fuse_change_attributes(inode, attr);
201	return inode;
202}
203
204static void fuse_umount_begin(struct vfsmount *vfsmnt, int flags)
205{
206	if (flags & MNT_FORCE)
207		fuse_abort_conn(get_fuse_conn_super(vfsmnt->mnt_sb));
208}
209
210static void fuse_send_destroy(struct fuse_conn *fc)
211{
212	struct fuse_req *req = fc->destroy_req;
213	if (req && fc->conn_init) {
214		fc->destroy_req = NULL;
215		req->in.h.opcode = FUSE_DESTROY;
216		req->force = 1;
217		request_send(fc, req);
218		fuse_put_request(fc, req);
219	}
220}
221
222static void fuse_put_super(struct super_block *sb)
223{
224	struct fuse_conn *fc = get_fuse_conn_super(sb);
225
226	fuse_send_destroy(fc);
227	spin_lock(&fc->lock);
228	fc->connected = 0;
229	fc->blocked = 0;
230	spin_unlock(&fc->lock);
231	/* Flush all readers on this fs */
232	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
233	wake_up_all(&fc->waitq);
234	wake_up_all(&fc->blocked_waitq);
235	mutex_lock(&fuse_mutex);
236	list_del(&fc->entry);
237	fuse_ctl_remove_conn(fc);
238	mutex_unlock(&fuse_mutex);
239	fuse_conn_put(fc);
240}
241
242static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
243{
244	stbuf->f_type    = FUSE_SUPER_MAGIC;
245	stbuf->f_bsize   = attr->bsize;
246	stbuf->f_frsize  = attr->frsize;
247	stbuf->f_blocks  = attr->blocks;
248	stbuf->f_bfree   = attr->bfree;
249	stbuf->f_bavail  = attr->bavail;
250	stbuf->f_files   = attr->files;
251	stbuf->f_ffree   = attr->ffree;
252	stbuf->f_namelen = attr->namelen;
253	/* fsid is left zero */
254}
255
256static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
257{
258	struct super_block *sb = dentry->d_sb;
259	struct fuse_conn *fc = get_fuse_conn_super(sb);
260	struct fuse_req *req;
261	struct fuse_statfs_out outarg;
262	int err;
263
264	req = fuse_get_req(fc);
265	if (IS_ERR(req))
266		return PTR_ERR(req);
267
268	memset(&outarg, 0, sizeof(outarg));
269	req->in.numargs = 0;
270	req->in.h.opcode = FUSE_STATFS;
271	req->in.h.nodeid = get_node_id(dentry->d_inode);
272	req->out.numargs = 1;
273	req->out.args[0].size =
274		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
275	req->out.args[0].value = &outarg;
276	request_send(fc, req);
277	err = req->out.h.error;
278	if (!err)
279		convert_fuse_statfs(buf, &outarg.st);
280	fuse_put_request(fc, req);
281	return err;
282}
283
284enum {
285	OPT_FD,
286	OPT_ROOTMODE,
287	OPT_USER_ID,
288	OPT_GROUP_ID,
289	OPT_DEFAULT_PERMISSIONS,
290	OPT_ALLOW_OTHER,
291	OPT_MAX_READ,
292	OPT_BLKSIZE,
293	OPT_ERR
294};
295
296static match_table_t tokens = {
297	{OPT_FD,			"fd=%u"},
298	{OPT_ROOTMODE,			"rootmode=%o"},
299	{OPT_USER_ID,			"user_id=%u"},
300	{OPT_GROUP_ID,			"group_id=%u"},
301	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
302	{OPT_ALLOW_OTHER,		"allow_other"},
303	{OPT_MAX_READ,			"max_read=%u"},
304	{OPT_BLKSIZE,			"blksize=%u"},
305	{OPT_ERR,			NULL}
306};
307
308static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
309{
310	char *p;
311	memset(d, 0, sizeof(struct fuse_mount_data));
312	d->max_read = ~0;
313	d->blksize = 512;
314
315	while ((p = strsep(&opt, ",")) != NULL) {
316		int token;
317		int value;
318		substring_t args[MAX_OPT_ARGS];
319		if (!*p)
320			continue;
321
322		token = match_token(p, tokens, args);
323		switch (token) {
324		case OPT_FD:
325			if (match_int(&args[0], &value))
326				return 0;
327			d->fd = value;
328			d->fd_present = 1;
329			break;
330
331		case OPT_ROOTMODE:
332			if (match_octal(&args[0], &value))
333				return 0;
334			if (!fuse_valid_type(value))
335				return 0;
336			d->rootmode = value;
337			d->rootmode_present = 1;
338			break;
339
340		case OPT_USER_ID:
341			if (match_int(&args[0], &value))
342				return 0;
343			d->user_id = value;
344			d->user_id_present = 1;
345			break;
346
347		case OPT_GROUP_ID:
348			if (match_int(&args[0], &value))
349				return 0;
350			d->group_id = value;
351			d->group_id_present = 1;
352			break;
353
354		case OPT_DEFAULT_PERMISSIONS:
355			d->flags |= FUSE_DEFAULT_PERMISSIONS;
356			break;
357
358		case OPT_ALLOW_OTHER:
359			d->flags |= FUSE_ALLOW_OTHER;
360			break;
361
362		case OPT_MAX_READ:
363			if (match_int(&args[0], &value))
364				return 0;
365			d->max_read = value;
366			break;
367
368		case OPT_BLKSIZE:
369			if (!is_bdev || match_int(&args[0], &value))
370				return 0;
371			d->blksize = value;
372			break;
373
374		default:
375			return 0;
376		}
377	}
378
379	if (!d->fd_present || !d->rootmode_present ||
380	    !d->user_id_present || !d->group_id_present)
381		return 0;
382
383	return 1;
384}
385
386static int fuse_show_options(struct seq_file *m, struct vfsmount *mnt)
387{
388	struct fuse_conn *fc = get_fuse_conn_super(mnt->mnt_sb);
389
390	seq_printf(m, ",user_id=%u", fc->user_id);
391	seq_printf(m, ",group_id=%u", fc->group_id);
392	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
393		seq_puts(m, ",default_permissions");
394	if (fc->flags & FUSE_ALLOW_OTHER)
395		seq_puts(m, ",allow_other");
396	if (fc->max_read != ~0)
397		seq_printf(m, ",max_read=%u", fc->max_read);
398	return 0;
399}
400
401static struct fuse_conn *new_conn(void)
402{
403	struct fuse_conn *fc;
404
405	fc = kzalloc(sizeof(*fc), GFP_KERNEL);
406	if (fc) {
407		spin_lock_init(&fc->lock);
408		mutex_init(&fc->inst_mutex);
409		atomic_set(&fc->count, 1);
410		init_waitqueue_head(&fc->waitq);
411		init_waitqueue_head(&fc->blocked_waitq);
412		INIT_LIST_HEAD(&fc->pending);
413		INIT_LIST_HEAD(&fc->processing);
414		INIT_LIST_HEAD(&fc->io);
415		INIT_LIST_HEAD(&fc->interrupts);
416		atomic_set(&fc->num_waiting, 0);
417		fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
418		fc->bdi.unplug_io_fn = default_unplug_io_fn;
419		fc->reqctr = 0;
420		fc->blocked = 1;
421		get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
422	}
423	return fc;
424}
425
426void fuse_conn_put(struct fuse_conn *fc)
427{
428	if (atomic_dec_and_test(&fc->count)) {
429		if (fc->destroy_req)
430			fuse_request_free(fc->destroy_req);
431		mutex_destroy(&fc->inst_mutex);
432		kfree(fc);
433	}
434}
435
436struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
437{
438	atomic_inc(&fc->count);
439	return fc;
440}
441
442static struct inode *get_root_inode(struct super_block *sb, unsigned mode)
443{
444	struct fuse_attr attr;
445	memset(&attr, 0, sizeof(attr));
446
447	attr.mode = mode;
448	attr.ino = FUSE_ROOT_ID;
449	return fuse_iget(sb, 1, 0, &attr);
450}
451
452static const struct super_operations fuse_super_operations = {
453	.alloc_inode    = fuse_alloc_inode,
454	.destroy_inode  = fuse_destroy_inode,
455	.read_inode	= fuse_read_inode,
456	.clear_inode	= fuse_clear_inode,
457	.drop_inode	= generic_delete_inode,
458	.remount_fs	= fuse_remount_fs,
459	.put_super	= fuse_put_super,
460	.umount_begin	= fuse_umount_begin,
461	.statfs		= fuse_statfs,
462	.show_options	= fuse_show_options,
463};
464
465static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
466{
467	struct fuse_init_out *arg = &req->misc.init_out;
468
469	if (req->out.h.error || arg->major != FUSE_KERNEL_VERSION)
470		fc->conn_error = 1;
471	else {
472		unsigned long ra_pages;
473
474		if (arg->minor >= 6) {
475			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
476			if (arg->flags & FUSE_ASYNC_READ)
477				fc->async_read = 1;
478			if (!(arg->flags & FUSE_POSIX_LOCKS))
479				fc->no_lock = 1;
480		} else {
481			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
482			fc->no_lock = 1;
483		}
484
485		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
486		fc->minor = arg->minor;
487		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
488		fc->conn_init = 1;
489	}
490	fuse_put_request(fc, req);
491	fc->blocked = 0;
492	wake_up_all(&fc->blocked_waitq);
493}
494
495static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
496{
497	struct fuse_init_in *arg = &req->misc.init_in;
498
499	arg->major = FUSE_KERNEL_VERSION;
500	arg->minor = FUSE_KERNEL_MINOR_VERSION;
501	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
502	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS;
503	req->in.h.opcode = FUSE_INIT;
504	req->in.numargs = 1;
505	req->in.args[0].size = sizeof(*arg);
506	req->in.args[0].value = arg;
507	req->out.numargs = 1;
508	/* Variable length arguement used for backward compatibility
509	   with interface version < 7.5.  Rest of init_out is zeroed
510	   by do_get_request(), so a short reply is not a problem */
511	req->out.argvar = 1;
512	req->out.args[0].size = sizeof(struct fuse_init_out);
513	req->out.args[0].value = &req->misc.init_out;
514	req->end = process_init_reply;
515	request_send_background(fc, req);
516}
517
518static u64 conn_id(void)
519{
520	static u64 ctr = 1;
521	return ctr++;
522}
523
524static int fuse_fill_super(struct super_block *sb, void *data, int silent)
525{
526	struct fuse_conn *fc;
527	struct inode *root;
528	struct fuse_mount_data d;
529	struct file *file;
530	struct dentry *root_dentry;
531	struct fuse_req *init_req;
532	int err;
533	int is_bdev = sb->s_bdev != NULL;
534
535	if (sb->s_flags & MS_MANDLOCK)
536		return -EINVAL;
537
538	if (!parse_fuse_opt((char *) data, &d, is_bdev))
539		return -EINVAL;
540
541	if (is_bdev) {
542#ifdef CONFIG_BLOCK
543		if (!sb_set_blocksize(sb, d.blksize))
544			return -EINVAL;
545#endif
546	} else {
547		sb->s_blocksize = PAGE_CACHE_SIZE;
548		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
549	}
550	sb->s_magic = FUSE_SUPER_MAGIC;
551	sb->s_op = &fuse_super_operations;
552	sb->s_maxbytes = MAX_LFS_FILESIZE;
553
554	file = fget(d.fd);
555	if (!file)
556		return -EINVAL;
557
558	if (file->f_op != &fuse_dev_operations)
559		return -EINVAL;
560
561	fc = new_conn();
562	if (!fc)
563		return -ENOMEM;
564
565	fc->flags = d.flags;
566	fc->user_id = d.user_id;
567	fc->group_id = d.group_id;
568	fc->max_read = d.max_read;
569
570	/* Used by get_root_inode() */
571	sb->s_fs_info = fc;
572
573	err = -ENOMEM;
574	root = get_root_inode(sb, d.rootmode);
575	if (!root)
576		goto err;
577
578	root_dentry = d_alloc_root(root);
579	if (!root_dentry) {
580		iput(root);
581		goto err;
582	}
583
584	init_req = fuse_request_alloc();
585	if (!init_req)
586		goto err_put_root;
587
588	if (is_bdev) {
589		fc->destroy_req = fuse_request_alloc();
590		if (!fc->destroy_req)
591			goto err_put_root;
592	}
593
594	mutex_lock(&fuse_mutex);
595	err = -EINVAL;
596	if (file->private_data)
597		goto err_unlock;
598
599	fc->id = conn_id();
600	err = fuse_ctl_add_conn(fc);
601	if (err)
602		goto err_unlock;
603
604	list_add_tail(&fc->entry, &fuse_conn_list);
605	sb->s_root = root_dentry;
606	fc->connected = 1;
607	file->private_data = fuse_conn_get(fc);
608	mutex_unlock(&fuse_mutex);
609	/*
610	 * atomic_dec_and_test() in fput() provides the necessary
611	 * memory barrier for file->private_data to be visible on all
612	 * CPUs after this
613	 */
614	fput(file);
615
616	fuse_send_init(fc, init_req);
617
618	return 0;
619
620 err_unlock:
621	mutex_unlock(&fuse_mutex);
622	fuse_request_free(init_req);
623 err_put_root:
624	dput(root_dentry);
625 err:
626	fput(file);
627	fuse_conn_put(fc);
628	return err;
629}
630
631static int fuse_get_sb(struct file_system_type *fs_type,
632		       int flags, const char *dev_name,
633		       void *raw_data, struct vfsmount *mnt)
634{
635	return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
636}
637
638static struct file_system_type fuse_fs_type = {
639	.owner		= THIS_MODULE,
640	.name		= "fuse",
641	.fs_flags	= FS_HAS_SUBTYPE,
642	.get_sb		= fuse_get_sb,
643	.kill_sb	= kill_anon_super,
644};
645
646#ifdef CONFIG_BLOCK
647static int fuse_get_sb_blk(struct file_system_type *fs_type,
648			   int flags, const char *dev_name,
649			   void *raw_data, struct vfsmount *mnt)
650{
651	return get_sb_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super,
652			   mnt);
653}
654
655static struct file_system_type fuseblk_fs_type = {
656	.owner		= THIS_MODULE,
657	.name		= "fuseblk",
658	.get_sb		= fuse_get_sb_blk,
659	.kill_sb	= kill_block_super,
660	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
661};
662
663static inline int register_fuseblk(void)
664{
665	return register_filesystem(&fuseblk_fs_type);
666}
667
668static inline void unregister_fuseblk(void)
669{
670	unregister_filesystem(&fuseblk_fs_type);
671}
672#else
673static inline int register_fuseblk(void)
674{
675	return 0;
676}
677
678static inline void unregister_fuseblk(void)
679{
680}
681#endif
682
683static decl_subsys(fuse, NULL, NULL);
684static decl_subsys(connections, NULL, NULL);
685
686static void fuse_inode_init_once(void *foo, struct kmem_cache *cachep,
687				 unsigned long flags)
688{
689	struct inode * inode = foo;
690
691	inode_init_once(inode);
692}
693
694static int __init fuse_fs_init(void)
695{
696	int err;
697
698	err = register_filesystem(&fuse_fs_type);
699	if (err)
700		goto out;
701
702	err = register_fuseblk();
703	if (err)
704		goto out_unreg;
705
706	fuse_inode_cachep = kmem_cache_create("fuse_inode",
707					      sizeof(struct fuse_inode),
708					      0, SLAB_HWCACHE_ALIGN,
709					      fuse_inode_init_once, NULL);
710	err = -ENOMEM;
711	if (!fuse_inode_cachep)
712		goto out_unreg2;
713
714	return 0;
715
716 out_unreg2:
717	unregister_fuseblk();
718 out_unreg:
719	unregister_filesystem(&fuse_fs_type);
720 out:
721	return err;
722}
723
724static void fuse_fs_cleanup(void)
725{
726	unregister_filesystem(&fuse_fs_type);
727	unregister_fuseblk();
728	kmem_cache_destroy(fuse_inode_cachep);
729}
730
731static int fuse_sysfs_init(void)
732{
733	int err;
734
735	kobj_set_kset_s(&fuse_subsys, fs_subsys);
736	err = subsystem_register(&fuse_subsys);
737	if (err)
738		goto out_err;
739
740	kobj_set_kset_s(&connections_subsys, fuse_subsys);
741	err = subsystem_register(&connections_subsys);
742	if (err)
743		goto out_fuse_unregister;
744
745	return 0;
746
747 out_fuse_unregister:
748	subsystem_unregister(&fuse_subsys);
749 out_err:
750	return err;
751}
752
753static void fuse_sysfs_cleanup(void)
754{
755	subsystem_unregister(&connections_subsys);
756	subsystem_unregister(&fuse_subsys);
757}
758
759static int __init fuse_init(void)
760{
761	int res;
762
763	printk("fuse init (API version %i.%i)\n",
764	       FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
765
766	INIT_LIST_HEAD(&fuse_conn_list);
767	res = fuse_fs_init();
768	if (res)
769		goto err;
770
771	res = fuse_dev_init();
772	if (res)
773		goto err_fs_cleanup;
774
775	res = fuse_sysfs_init();
776	if (res)
777		goto err_dev_cleanup;
778
779	res = fuse_ctl_init();
780	if (res)
781		goto err_sysfs_cleanup;
782
783	return 0;
784
785 err_sysfs_cleanup:
786	fuse_sysfs_cleanup();
787 err_dev_cleanup:
788	fuse_dev_cleanup();
789 err_fs_cleanup:
790	fuse_fs_cleanup();
791 err:
792	return res;
793}
794
795static void __exit fuse_exit(void)
796{
797	printk(KERN_DEBUG "fuse exit\n");
798
799	fuse_ctl_cleanup();
800	fuse_sysfs_cleanup();
801	fuse_fs_cleanup();
802	fuse_dev_cleanup();
803}
804
805module_init(fuse_init);
806module_exit(fuse_exit);
807