inode.c 16.1 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

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

25
static struct kmem_cache *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
};

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

49
	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
M
Miklos Szeredi 已提交
50 51 52 53
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
54
	fi->i_time = 0;
M
Miklos Szeredi 已提交
55
	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
void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
{
M
Miklos Szeredi 已提交
112
	struct fuse_conn *fc = get_fuse_conn(inode);
M
Miklos Szeredi 已提交
113 114 115 116 117 118 119 120
	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;
M
Miklos Szeredi 已提交
121
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
122
	i_size_write(inode, attr->size);
M
Miklos Szeredi 已提交
123
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
124 125 126 127 128 129 130 131 132 133 134 135
	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;
M
Miklos Szeredi 已提交
136
	inode->i_size = attr->size;
137 138
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
M
Miklos Szeredi 已提交
139
		fuse_init_file_inode(inode);
140 141 142 143 144 145 146 147 148
	} 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));
149 150
	} else
		BUG();
M
Miklos Szeredi 已提交
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
}

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,
170
			int generation, struct fuse_attr *attr)
M
Miklos Szeredi 已提交
171 172
{
	struct inode *inode;
173
	struct fuse_inode *fi;
M
Miklos Szeredi 已提交
174 175 176 177 178 179 180 181
	struct fuse_conn *fc = get_fuse_conn_super(sb);

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

	if ((inode->i_state & I_NEW)) {
182
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
M
Miklos Szeredi 已提交
183 184 185 186 187 188 189 190 191 192 193
		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) {
		/* Inode has changed type, any I/O on the old should fail */
		make_bad_inode(inode);
		iput(inode);
		goto retry;
	}

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

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

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

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

227 228 229 230
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
231
	stbuf->f_frsize  = attr->frsize;
232 233 234 235 236 237 238 239 240
	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 */
}

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

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

253
	memset(&outarg, 0, sizeof(outarg));
254 255
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
256
	req->in.h.nodeid = get_node_id(dentry->d_inode);
257
	req->out.numargs = 1;
258 259
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
260 261 262 263 264 265 266 267 268
	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 已提交
269 270 271 272
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
273
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
274 275
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
276
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
277 278 279 280 281 282 283
	OPT_ERR
};

static match_table_t tokens = {
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
284
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
285 286
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
287
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
288 289 290 291 292 293 294
	{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));
295
	d->max_read = ~0;
M
Miklos Szeredi 已提交
296 297 298 299 300 301 302 303 304 305 306 307 308 309

	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;
310
			d->fd_present = 1;
M
Miklos Szeredi 已提交
311 312 313 314 315 316
			break;

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

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

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

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

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

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

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

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
355 356 357 358 359 360 361 362 363 364
		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);
365
	seq_printf(m, ",group_id=%u", fc->group_id);
M
Miklos Szeredi 已提交
366 367 368 369
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
370 371
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
M
Miklos Szeredi 已提交
372 373 374 375 376 377 378
	return 0;
}

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

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

400 401
void fuse_conn_put(struct fuse_conn *fc)
{
402 403
	if (atomic_dec_and_test(&fc->count)) {
		mutex_destroy(&fc->inst_mutex);
404
		kfree(fc);
405
	}
406 407 408 409 410 411 412 413
}

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

M
Miklos Szeredi 已提交
414 415 416 417 418 419 420
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;
421
	return fuse_iget(sb, 1, 0, &attr);
M
Miklos Szeredi 已提交
422 423 424 425 426 427 428
}

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,
429
	.remount_fs	= fuse_remount_fs,
M
Miklos Szeredi 已提交
430
	.put_super	= fuse_put_super,
431
	.umount_begin	= fuse_umount_begin,
432
	.statfs		= fuse_statfs,
M
Miklos Szeredi 已提交
433 434 435
	.show_options	= fuse_show_options,
};

436 437 438 439 440 441 442
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 {
443 444 445 446 447 448
		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;
449 450 451
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
		} else {
452
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
453 454
			fc->no_lock = 1;
		}
455 456

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
457 458 459 460
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
	}
	fuse_put_request(fc, req);
461 462
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
463 464
}

465
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
466 467
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
468

469 470
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
471
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
472
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS;
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
	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);
}

488
static u64 conn_id(void)
489
{
490
	static u64 ctr = 1;
M
Miklos Szeredi 已提交
491
	return ctr++;
492 493
}

M
Miklos Szeredi 已提交
494 495 496 497 498 499
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;
500
	struct dentry *root_dentry;
501
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
502 503
	int err;

504 505 506
	if (sb->s_flags & MS_MANDLOCK)
		return -EINVAL;

M
Miklos Szeredi 已提交
507 508 509 510 511 512 513 514 515 516 517 518 519
	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 已提交
520 521 522 523 524 525
	if (file->f_op != &fuse_dev_operations)
		return -EINVAL;

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

M
Miklos Szeredi 已提交
527
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
528
	fc->user_id = d.user_id;
529
	fc->group_id = d.group_id;
530
	fc->max_read = d.max_read;
M
Miklos Szeredi 已提交
531

532 533 534
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
535 536
	err = -ENOMEM;
	root = get_root_inode(sb, d.rootmode);
537
	if (!root)
M
Miklos Szeredi 已提交
538 539
		goto err;

540 541
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
M
Miklos Szeredi 已提交
542 543 544
		iput(root);
		goto err;
	}
545

546 547 548 549
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

550
	mutex_lock(&fuse_mutex);
551 552
	err = -EINVAL;
	if (file->private_data)
553
		goto err_unlock;
554

555 556 557 558 559 560
	fc->id = conn_id();
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
561 562
	sb->s_root = root_dentry;
	fc->connected = 1;
563 564
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
565 566 567 568 569 570
	/*
	 * 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);
571

572
	fuse_send_init(fc, init_req);
573

M
Miklos Szeredi 已提交
574 575
	return 0;

576 577
 err_unlock:
	mutex_unlock(&fuse_mutex);
578
	fuse_request_free(init_req);
579 580
 err_put_root:
	dput(root_dentry);
M
Miklos Szeredi 已提交
581
 err:
M
Miklos Szeredi 已提交
582
	fput(file);
583
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
584 585 586
	return err;
}

587 588 589
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 已提交
590
{
591
	return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
M
Miklos Szeredi 已提交
592 593 594 595 596 597 598 599 600
}

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

601
static decl_subsys(fuse, NULL, NULL);
602
static decl_subsys(connections, NULL, NULL);
603

604
static void fuse_inode_init_once(void *foo, struct kmem_cache *cachep,
M
Miklos Szeredi 已提交
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 636 637 638 639 640
				 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);
}

641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
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 已提交
669 670 671 672 673 674 675
static int __init fuse_init(void)
{
	int res;

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

676
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
677 678 679 680
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
681 682 683 684
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

685 686 687 688
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

689 690 691 692
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

M
Miklos Szeredi 已提交
693 694
	return 0;

695 696
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
697 698
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
699 700
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
701 702 703 704 705 706 707 708
 err:
	return res;
}

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

709
	fuse_ctl_cleanup();
710
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
711
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
712
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
713 714 715 716
}

module_init(fuse_init);
module_exit(fuse_exit);