inode.c 15.9 KB
Newer Older
M
Miklos Szeredi 已提交
1 2
/*
  FUSE: Filesystem in Userspace
3
  Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
M
Miklos Szeredi 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  This program can be distributed under the terms of the GNU GPL.
  See the file COPYING.
*/

#include "fuse_i.h"

#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/parser.h>
#include <linux/statfs.h>
19
#include <linux/random.h>
M
Miklos Szeredi 已提交
20 21 22 23 24 25

MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
MODULE_DESCRIPTION("Filesystem in Userspace");
MODULE_LICENSE("GPL");

static kmem_cache_t *fuse_inode_cachep;
26 27
struct list_head fuse_conn_list;
DEFINE_MUTEX(fuse_mutex);
M
Miklos Szeredi 已提交
28 29 30 31 32 33 34

#define FUSE_SUPER_MAGIC 0x65735546

struct fuse_mount_data {
	int fd;
	unsigned rootmode;
	unsigned user_id;
35
	unsigned group_id;
36 37 38 39
	unsigned fd_present : 1;
	unsigned rootmode_present : 1;
	unsigned user_id_present : 1;
	unsigned group_id_present : 1;
M
Miklos Szeredi 已提交
40
	unsigned flags;
41
	unsigned max_read;
M
Miklos Szeredi 已提交
42 43 44 45 46 47 48 49 50 51 52 53 54 55
};

static struct inode *fuse_alloc_inode(struct super_block *sb)
{
	struct inode *inode;
	struct fuse_inode *fi;

	inode = kmem_cache_alloc(fuse_inode_cachep, SLAB_KERNEL);
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
	fi->i_time = jiffies - 1;
	fi->nodeid = 0;
56
	fi->nlookup = 0;
57 58 59 60 61
	fi->forget_req = fuse_request_alloc();
	if (!fi->forget_req) {
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
M
Miklos Szeredi 已提交
62 63 64 65 66 67

	return inode;
}

static void fuse_destroy_inode(struct inode *inode)
{
68 69 70
	struct fuse_inode *fi = get_fuse_inode(inode);
	if (fi->forget_req)
		fuse_request_free(fi->forget_req);
M
Miklos Szeredi 已提交
71 72 73 74 75 76 77 78
	kmem_cache_free(fuse_inode_cachep, inode);
}

static void fuse_read_inode(struct inode *inode)
{
	/* No op */
}

79
void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
80
		      unsigned long nodeid, u64 nlookup)
81 82
{
	struct fuse_forget_in *inarg = &req->misc.forget_in;
83
	inarg->nlookup = nlookup;
84 85 86 87 88 89 90 91
	req->in.h.opcode = FUSE_FORGET;
	req->in.h.nodeid = nodeid;
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(struct fuse_forget_in);
	req->in.args[0].value = inarg;
	request_send_noreply(fc, req);
}

M
Miklos Szeredi 已提交
92 93
static void fuse_clear_inode(struct inode *inode)
{
M
Miklos Szeredi 已提交
94 95
	if (inode->i_sb->s_flags & MS_ACTIVE) {
		struct fuse_conn *fc = get_fuse_conn(inode);
96
		struct fuse_inode *fi = get_fuse_inode(inode);
97
		fuse_send_forget(fc, fi->forget_req, fi->nodeid, fi->nlookup);
98 99
		fi->forget_req = NULL;
	}
M
Miklos Szeredi 已提交
100 101
}

102 103 104 105 106 107 108 109
static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
{
	if (*flags & MS_MANDLOCK)
		return -EINVAL;

	return 0;
}

M
Miklos Szeredi 已提交
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
{
	if (S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size)
		invalidate_inode_pages(inode->i_mapping);

	inode->i_ino     = attr->ino;
	inode->i_mode    = (inode->i_mode & S_IFMT) + (attr->mode & 07777);
	inode->i_nlink   = attr->nlink;
	inode->i_uid     = attr->uid;
	inode->i_gid     = attr->gid;
	i_size_write(inode, attr->size);
	inode->i_blksize = PAGE_CACHE_SIZE;
	inode->i_blocks  = attr->blocks;
	inode->i_atime.tv_sec   = attr->atime;
	inode->i_atime.tv_nsec  = attr->atimensec;
	inode->i_mtime.tv_sec   = attr->mtime;
	inode->i_mtime.tv_nsec  = attr->mtimensec;
	inode->i_ctime.tv_sec   = attr->ctime;
	inode->i_ctime.tv_nsec  = attr->ctimensec;
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
	i_size_write(inode, attr->size);
135 136
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
M
Miklos Szeredi 已提交
137
		fuse_init_file_inode(inode);
138 139 140 141 142 143 144 145 146
	} else if (S_ISDIR(inode->i_mode))
		fuse_init_dir(inode);
	else if (S_ISLNK(inode->i_mode))
		fuse_init_symlink(inode);
	else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
		 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
		fuse_init_common(inode);
		init_special_inode(inode, inode->i_mode,
				   new_decode_dev(attr->rdev));
147 148
	} else
		BUG();
M
Miklos Szeredi 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
}

static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
{
	unsigned long nodeid = *(unsigned long *) _nodeidp;
	if (get_node_id(inode) == nodeid)
		return 1;
	else
		return 0;
}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
	unsigned long nodeid = *(unsigned long *) _nodeidp;
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
168
			int generation, struct fuse_attr *attr)
M
Miklos Szeredi 已提交
169 170
{
	struct inode *inode;
171
	struct fuse_inode *fi;
M
Miklos Szeredi 已提交
172 173 174 175 176 177 178 179 180
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	int retried = 0;

 retry:
	inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
	if (!inode)
		return NULL;

	if ((inode->i_state & I_NEW)) {
181
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
M
Miklos Szeredi 已提交
182 183 184 185 186 187 188 189 190 191 192 193 194
		inode->i_generation = generation;
		inode->i_data.backing_dev_info = &fc->bdi;
		fuse_init_inode(inode, attr);
		unlock_new_inode(inode);
	} else if ((inode->i_mode ^ attr->mode) & S_IFMT) {
		BUG_ON(retried);
		/* Inode has changed type, any I/O on the old should fail */
		make_bad_inode(inode);
		iput(inode);
		retried = 1;
		goto retry;
	}

195 196
	fi = get_fuse_inode(inode);
	fi->nlookup ++;
M
Miklos Szeredi 已提交
197 198 199 200
	fuse_change_attributes(inode, attr);
	return inode;
}

201
static void fuse_umount_begin(struct vfsmount *vfsmnt, int flags)
202
{
203 204
	if (flags & MNT_FORCE)
		fuse_abort_conn(get_fuse_conn_super(vfsmnt->mnt_sb));
205 206
}

M
Miklos Szeredi 已提交
207 208 209 210
static void fuse_put_super(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

211
	spin_lock(&fc->lock);
212
	fc->connected = 0;
213
	fc->blocked = 0;
214
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
215
	/* Flush all readers on this fs */
216
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
M
Miklos Szeredi 已提交
217
	wake_up_all(&fc->waitq);
218
	wake_up_all(&fc->blocked_waitq);
219 220 221 222 223
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
224 225
}

226 227 228 229
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
230
	stbuf->f_frsize  = attr->frsize;
231 232 233 234 235 236 237 238 239
	stbuf->f_blocks  = attr->blocks;
	stbuf->f_bfree   = attr->bfree;
	stbuf->f_bavail  = attr->bavail;
	stbuf->f_files   = attr->files;
	stbuf->f_ffree   = attr->ffree;
	stbuf->f_namelen = attr->namelen;
	/* fsid is left zero */
}

240
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
241
{
242
	struct super_block *sb = dentry->d_sb;
243 244 245 246 247
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

248 249 250
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
251

252
	memset(&outarg, 0, sizeof(outarg));
253 254 255
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
	req->out.numargs = 1;
256 257
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
258 259 260 261 262 263 264 265 266
	req->out.args[0].value = &outarg;
	request_send(fc, req);
	err = req->out.h.error;
	if (!err)
		convert_fuse_statfs(buf, &outarg.st);
	fuse_put_request(fc, req);
	return err;
}

M
Miklos Szeredi 已提交
267 268 269 270
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
271
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
272 273
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
274
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
275 276 277 278 279 280 281
	OPT_ERR
};

static match_table_t tokens = {
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
282
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
283 284
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
285
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
286 287 288 289 290 291 292
	{OPT_ERR,			NULL}
};

static int parse_fuse_opt(char *opt, struct fuse_mount_data *d)
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
293
	d->max_read = ~0;
M
Miklos Szeredi 已提交
294 295 296 297 298 299 300 301 302 303 304 305 306 307

	while ((p = strsep(&opt, ",")) != NULL) {
		int token;
		int value;
		substring_t args[MAX_OPT_ARGS];
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case OPT_FD:
			if (match_int(&args[0], &value))
				return 0;
			d->fd = value;
308
			d->fd_present = 1;
M
Miklos Szeredi 已提交
309 310 311 312 313 314
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
			d->rootmode = value;
315
			d->rootmode_present = 1;
M
Miklos Szeredi 已提交
316 317 318 319 320 321
			break;

		case OPT_USER_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->user_id = value;
322
			d->user_id_present = 1;
M
Miklos Szeredi 已提交
323 324
			break;

325 326 327 328
		case OPT_GROUP_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->group_id = value;
329
			d->group_id_present = 1;
330 331
			break;

M
Miklos Szeredi 已提交
332 333 334 335 336 337 338 339
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

		case OPT_ALLOW_OTHER:
			d->flags |= FUSE_ALLOW_OTHER;
			break;

340 341 342 343 344 345
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

M
Miklos Szeredi 已提交
346 347 348 349
		default:
			return 0;
		}
	}
350 351 352

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
353 354 355 356 357 358 359 360 361 362
		return 0;

	return 1;
}

static int fuse_show_options(struct seq_file *m, struct vfsmount *mnt)
{
	struct fuse_conn *fc = get_fuse_conn_super(mnt->mnt_sb);

	seq_printf(m, ",user_id=%u", fc->user_id);
363
	seq_printf(m, ",group_id=%u", fc->group_id);
M
Miklos Szeredi 已提交
364 365 366 367
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
368 369
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
M
Miklos Szeredi 已提交
370 371 372 373 374 375 376
	return 0;
}

static struct fuse_conn *new_conn(void)
{
	struct fuse_conn *fc;

377
	fc = kzalloc(sizeof(*fc), GFP_KERNEL);
378
	if (fc) {
379
		spin_lock_init(&fc->lock);
380
		atomic_set(&fc->count, 1);
M
Miklos Szeredi 已提交
381
		init_waitqueue_head(&fc->waitq);
382
		init_waitqueue_head(&fc->blocked_waitq);
M
Miklos Szeredi 已提交
383 384
		INIT_LIST_HEAD(&fc->pending);
		INIT_LIST_HEAD(&fc->processing);
385
		INIT_LIST_HEAD(&fc->io);
386
		INIT_LIST_HEAD(&fc->interrupts);
M
Miklos Szeredi 已提交
387
		atomic_set(&fc->num_waiting, 0);
M
Miklos Szeredi 已提交
388 389
		fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
		fc->bdi.unplug_io_fn = default_unplug_io_fn;
M
Miklos Szeredi 已提交
390
		fc->reqctr = 0;
391
		fc->blocked = 1;
392
		get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
M
Miklos Szeredi 已提交
393 394 395 396
	}
	return fc;
}

397 398 399 400 401 402 403 404 405 406 407 408
void fuse_conn_put(struct fuse_conn *fc)
{
	if (atomic_dec_and_test(&fc->count))
		kfree(fc);
}

struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
{
	atomic_inc(&fc->count);
	return fc;
}

M
Miklos Szeredi 已提交
409 410 411 412 413 414 415
static struct inode *get_root_inode(struct super_block *sb, unsigned mode)
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
416
	return fuse_iget(sb, 1, 0, &attr);
M
Miklos Szeredi 已提交
417 418 419 420 421 422 423
}

static struct super_operations fuse_super_operations = {
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
	.read_inode	= fuse_read_inode,
	.clear_inode	= fuse_clear_inode,
424
	.remount_fs	= fuse_remount_fs,
M
Miklos Szeredi 已提交
425
	.put_super	= fuse_put_super,
426
	.umount_begin	= fuse_umount_begin,
427
	.statfs		= fuse_statfs,
M
Miklos Szeredi 已提交
428 429 430
	.show_options	= fuse_show_options,
};

431 432 433 434 435 436 437
static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
{
	struct fuse_init_out *arg = &req->misc.init_out;

	if (req->out.h.error || arg->major != FUSE_KERNEL_VERSION)
		fc->conn_error = 1;
	else {
438 439 440 441 442 443
		unsigned long ra_pages;

		if (arg->minor >= 6) {
			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
444 445 446
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
		} else {
447
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
448 449
			fc->no_lock = 1;
		}
450 451

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
452 453 454 455
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
	}
	fuse_put_request(fc, req);
456 457
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
458 459
}

460
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
461 462
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
463

464 465
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
466
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
467
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS;
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
	req->in.h.opcode = FUSE_INIT;
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(*arg);
	req->in.args[0].value = arg;
	req->out.numargs = 1;
	/* Variable length arguement used for backward compatibility
	   with interface version < 7.5.  Rest of init_out is zeroed
	   by do_get_request(), so a short reply is not a problem */
	req->out.argvar = 1;
	req->out.args[0].size = sizeof(struct fuse_init_out);
	req->out.args[0].value = &req->misc.init_out;
	req->end = process_init_reply;
	request_send_background(fc, req);
}

483
static u64 conn_id(void)
484
{
485
	static u64 ctr = 1;
M
Miklos Szeredi 已提交
486
	return ctr++;
487 488
}

M
Miklos Szeredi 已提交
489 490 491 492 493 494
static int fuse_fill_super(struct super_block *sb, void *data, int silent)
{
	struct fuse_conn *fc;
	struct inode *root;
	struct fuse_mount_data d;
	struct file *file;
495
	struct dentry *root_dentry;
496
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
497 498
	int err;

499 500 501
	if (sb->s_flags & MS_MANDLOCK)
		return -EINVAL;

M
Miklos Szeredi 已提交
502 503 504 505 506 507 508 509 510 511 512 513 514
	if (!parse_fuse_opt((char *) data, &d))
		return -EINVAL;

	sb->s_blocksize = PAGE_CACHE_SIZE;
	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;

	file = fget(d.fd);
	if (!file)
		return -EINVAL;

M
Miklos Szeredi 已提交
515 516 517 518 519 520
	if (file->f_op != &fuse_dev_operations)
		return -EINVAL;

	fc = new_conn();
	if (!fc)
		return -ENOMEM;
M
Miklos Szeredi 已提交
521

M
Miklos Szeredi 已提交
522
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
523
	fc->user_id = d.user_id;
524
	fc->group_id = d.group_id;
525
	fc->max_read = d.max_read;
M
Miklos Szeredi 已提交
526

527 528 529
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
530 531
	err = -ENOMEM;
	root = get_root_inode(sb, d.rootmode);
532
	if (!root)
M
Miklos Szeredi 已提交
533 534
		goto err;

535 536
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
M
Miklos Szeredi 已提交
537 538 539
		iput(root);
		goto err;
	}
540

541 542 543 544
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

545
	mutex_lock(&fuse_mutex);
546 547
	err = -EINVAL;
	if (file->private_data)
548
		goto err_unlock;
549

550 551 552 553 554 555
	fc->id = conn_id();
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
556 557
	sb->s_root = root_dentry;
	fc->connected = 1;
558 559
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
560 561 562 563 564 565
	/*
	 * atomic_dec_and_test() in fput() provides the necessary
	 * memory barrier for file->private_data to be visible on all
	 * CPUs after this
	 */
	fput(file);
566

567
	fuse_send_init(fc, init_req);
568

M
Miklos Szeredi 已提交
569 570
	return 0;

571 572
 err_unlock:
	mutex_unlock(&fuse_mutex);
573
	fuse_request_free(init_req);
574 575
 err_put_root:
	dput(root_dentry);
M
Miklos Szeredi 已提交
576
 err:
M
Miklos Szeredi 已提交
577
	fput(file);
578
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
579 580 581
	return err;
}

582 583 584
static int fuse_get_sb(struct file_system_type *fs_type,
		       int flags, const char *dev_name,
		       void *raw_data, struct vfsmount *mnt)
M
Miklos Szeredi 已提交
585
{
586
	return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
M
Miklos Szeredi 已提交
587 588 589 590 591 592 593 594 595
}

static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
	.get_sb		= fuse_get_sb,
	.kill_sb	= kill_anon_super,
};

596
static decl_subsys(fuse, NULL, NULL);
597
static decl_subsys(connections, NULL, NULL);
598

M
Miklos Szeredi 已提交
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
static void fuse_inode_init_once(void *foo, kmem_cache_t *cachep,
				 unsigned long flags)
{
	struct inode * inode = foo;

	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
	    SLAB_CTOR_CONSTRUCTOR)
		inode_init_once(inode);
}

static int __init fuse_fs_init(void)
{
	int err;

	err = register_filesystem(&fuse_fs_type);
	if (err)
		printk("fuse: failed to register filesystem\n");
	else {
		fuse_inode_cachep = kmem_cache_create("fuse_inode",
						      sizeof(struct fuse_inode),
						      0, SLAB_HWCACHE_ALIGN,
						      fuse_inode_init_once, NULL);
		if (!fuse_inode_cachep) {
			unregister_filesystem(&fuse_fs_type);
			err = -ENOMEM;
		}
	}

	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
	kmem_cache_destroy(fuse_inode_cachep);
}

636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
static int fuse_sysfs_init(void)
{
	int err;

	kset_set_kset_s(&fuse_subsys, fs_subsys);
	err = subsystem_register(&fuse_subsys);
	if (err)
		goto out_err;

	kset_set_kset_s(&connections_subsys, fuse_subsys);
	err = subsystem_register(&connections_subsys);
	if (err)
		goto out_fuse_unregister;

	return 0;

 out_fuse_unregister:
	subsystem_unregister(&fuse_subsys);
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
	subsystem_unregister(&connections_subsys);
	subsystem_unregister(&fuse_subsys);
}

M
Miklos Szeredi 已提交
664 665 666 667 668 669 670
static int __init fuse_init(void)
{
	int res;

	printk("fuse init (API version %i.%i)\n",
	       FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);

671
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
672 673 674 675
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
676 677 678 679
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

680 681 682 683
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

684 685 686 687
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

M
Miklos Szeredi 已提交
688 689
	return 0;

690 691
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
692 693
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
694 695
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
696 697 698 699 700 701 702 703
 err:
	return res;
}

static void __exit fuse_exit(void)
{
	printk(KERN_DEBUG "fuse exit\n");

704
	fuse_ctl_cleanup();
705
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
706
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
707
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
708 709 710 711
}

module_init(fuse_init);
module_exit(fuse_exit);