inode.c 17.8 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>
A
Alexey Dobriyan 已提交
20
#include <linux/sched.h>
M
Miklos Szeredi 已提交
21 22 23 24 25

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

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

#define FUSE_SUPER_MAGIC 0x65735546

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

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

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

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

	return inode;
}

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

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

81
void 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 87 88 89 90 91 92 93
	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 已提交
94 95
static void fuse_clear_inode(struct inode *inode)
{
M
Miklos Szeredi 已提交
96 97
	if (inode->i_sb->s_flags & MS_ACTIVE) {
		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 101
		fi->forget_req = NULL;
	}
M
Miklos Szeredi 已提交
102 103
}

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

	return 0;
}

M
Miklos Szeredi 已提交
112 113
void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
{
M
Miklos Szeredi 已提交
114
	struct fuse_conn *fc = get_fuse_conn(inode);
M
Miklos Szeredi 已提交
115
	if (S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size)
116
		invalidate_mapping_pages(inode->i_mapping, 0, -1);
M
Miklos Szeredi 已提交
117 118 119 120 121 122

	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 已提交
123
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
124
	i_size_write(inode, attr->size);
M
Miklos Szeredi 已提交
125
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
126 127 128 129 130 131 132 133 134 135 136 137
	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 已提交
138
	inode->i_size = attr->size;
139 140
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
M
Miklos Szeredi 已提交
141
		fuse_init_file_inode(inode);
142 143 144 145 146 147 148 149 150
	} 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));
151 152
	} else
		BUG();
M
Miklos Szeredi 已提交
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
}

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,
172
			int generation, struct fuse_attr *attr)
M
Miklos Szeredi 已提交
173 174
{
	struct inode *inode;
175
	struct fuse_inode *fi;
M
Miklos Szeredi 已提交
176 177 178 179 180 181 182 183
	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)) {
184
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
M
Miklos Szeredi 已提交
185 186 187 188 189 190 191 192 193 194 195
		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;
	}

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

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

210 211 212 213 214 215 216 217 218 219 220 221
static void fuse_send_destroy(struct fuse_conn *fc)
{
	struct fuse_req *req = fc->destroy_req;
	if (req && fc->conn_init) {
		fc->destroy_req = NULL;
		req->in.h.opcode = FUSE_DESTROY;
		req->force = 1;
		request_send(fc, req);
		fuse_put_request(fc, req);
	}
}

M
Miklos Szeredi 已提交
222 223 224 225
static void fuse_put_super(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

226
	fuse_send_destroy(fc);
227
	spin_lock(&fc->lock);
228
	fc->connected = 0;
229
	fc->blocked = 0;
230
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
231
	/* Flush all readers on this fs */
232
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
M
Miklos Szeredi 已提交
233
	wake_up_all(&fc->waitq);
234
	wake_up_all(&fc->blocked_waitq);
235 236 237 238 239
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
240 241
}

242 243 244 245
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
246
	stbuf->f_frsize  = attr->frsize;
247 248 249 250 251 252 253 254 255
	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 */
}

256
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
257
{
258
	struct super_block *sb = dentry->d_sb;
259 260 261 262 263
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

264 265 266
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
267

268
	memset(&outarg, 0, sizeof(outarg));
269 270
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
271
	req->in.h.nodeid = get_node_id(dentry->d_inode);
272
	req->out.numargs = 1;
273 274
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
275 276 277 278 279 280 281 282 283
	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 已提交
284 285 286 287
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
288
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
289 290
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
291
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
292
	OPT_BLKSIZE,
M
Miklos Szeredi 已提交
293 294 295 296 297 298 299
	OPT_ERR
};

static match_table_t tokens = {
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
300
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
301 302
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
303
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
304
	{OPT_BLKSIZE,			"blksize=%u"},
M
Miklos Szeredi 已提交
305 306 307
	{OPT_ERR,			NULL}
};

M
Miklos Szeredi 已提交
308
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
M
Miklos Szeredi 已提交
309 310 311
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
312
	d->max_read = ~0;
M
Miklos Szeredi 已提交
313
	d->blksize = 512;
M
Miklos Szeredi 已提交
314 315 316 317 318 319 320 321 322 323 324 325 326 327

	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;
328
			d->fd_present = 1;
M
Miklos Szeredi 已提交
329 330 331 332 333
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
334 335
			if (!fuse_valid_type(value))
				return 0;
M
Miklos Szeredi 已提交
336
			d->rootmode = value;
337
			d->rootmode_present = 1;
M
Miklos Szeredi 已提交
338 339 340 341 342 343
			break;

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

347 348 349 350
		case OPT_GROUP_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->group_id = value;
351
			d->group_id_present = 1;
352 353
			break;

M
Miklos Szeredi 已提交
354 355 356 357 358 359 360 361
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

362 363 364 365 366 367
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

M
Miklos Szeredi 已提交
368 369 370 371 372 373
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

M
Miklos Szeredi 已提交
374 375 376 377
		default:
			return 0;
		}
	}
378 379 380

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
381 382 383 384 385 386 387 388 389 390
		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);
391
	seq_printf(m, ",group_id=%u", fc->group_id);
M
Miklos Szeredi 已提交
392 393 394 395
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
396 397
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
M
Miklos Szeredi 已提交
398 399 400 401 402 403 404
	return 0;
}

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

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);
M
Miklos Szeredi 已提交
410
		init_waitqueue_head(&fc->waitq);
411
		init_waitqueue_head(&fc->blocked_waitq);
M
Miklos Szeredi 已提交
412 413
		INIT_LIST_HEAD(&fc->pending);
		INIT_LIST_HEAD(&fc->processing);
414
		INIT_LIST_HEAD(&fc->io);
415
		INIT_LIST_HEAD(&fc->interrupts);
M
Miklos Szeredi 已提交
416
		atomic_set(&fc->num_waiting, 0);
M
Miklos Szeredi 已提交
417 418
		fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
		fc->bdi.unplug_io_fn = default_unplug_io_fn;
M
Miklos Szeredi 已提交
419
		fc->reqctr = 0;
420
		fc->blocked = 1;
421
		get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
M
Miklos Szeredi 已提交
422 423 424 425
	}
	return fc;
}

426 427
void fuse_conn_put(struct fuse_conn *fc)
{
428
	if (atomic_dec_and_test(&fc->count)) {
429 430
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
431
		mutex_destroy(&fc->inst_mutex);
432
		kfree(fc);
433
	}
434 435 436 437 438 439 440 441
}

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

M
Miklos Szeredi 已提交
442 443 444 445 446 447 448
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;
449
	return fuse_iget(sb, 1, 0, &attr);
M
Miklos Szeredi 已提交
450 451
}

452
static const struct super_operations fuse_super_operations = {
M
Miklos Szeredi 已提交
453 454 455 456
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
	.read_inode	= fuse_read_inode,
	.clear_inode	= fuse_clear_inode,
M
Miklos Szeredi 已提交
457
	.drop_inode	= generic_delete_inode,
458
	.remount_fs	= fuse_remount_fs,
M
Miklos Szeredi 已提交
459
	.put_super	= fuse_put_super,
460
	.umount_begin	= fuse_umount_begin,
461
	.statfs		= fuse_statfs,
M
Miklos Szeredi 已提交
462 463 464
	.show_options	= fuse_show_options,
};

465 466 467 468 469 470 471
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 {
472 473 474 475 476 477
		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;
478 479 480
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
		} else {
481
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
482 483
			fc->no_lock = 1;
		}
484 485

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
486 487
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
488
		fc->conn_init = 1;
489 490
	}
	fuse_put_request(fc, req);
491 492
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
493 494
}

495
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
496 497
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
498

499 500
	arg->major = FUSE_KERNEL_VERSION;
	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 504 505 506 507 508 509 510 511 512 513 514 515 516 517
	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);
}

518
static u64 conn_id(void)
519
{
520
	static u64 ctr = 1;
M
Miklos Szeredi 已提交
521
	return ctr++;
522 523
}

M
Miklos Szeredi 已提交
524 525 526 527 528 529
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;
530
	struct dentry *root_dentry;
531
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
532
	int err;
M
Miklos Szeredi 已提交
533
	int is_bdev = sb->s_bdev != NULL;
M
Miklos Szeredi 已提交
534

535 536 537
	if (sb->s_flags & MS_MANDLOCK)
		return -EINVAL;

M
Miklos Szeredi 已提交
538
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
M
Miklos Szeredi 已提交
539 540
		return -EINVAL;

M
Miklos Szeredi 已提交
541
	if (is_bdev) {
542
#ifdef CONFIG_BLOCK
M
Miklos Szeredi 已提交
543 544
		if (!sb_set_blocksize(sb, d.blksize))
			return -EINVAL;
545
#endif
M
Miklos Szeredi 已提交
546 547 548 549
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
M
Miklos Szeredi 已提交
550 551 552 553 554 555 556 557
	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 已提交
558 559 560 561 562 563
	if (file->f_op != &fuse_dev_operations)
		return -EINVAL;

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

M
Miklos Szeredi 已提交
565
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
566
	fc->user_id = d.user_id;
567
	fc->group_id = d.group_id;
568
	fc->max_read = d.max_read;
M
Miklos Szeredi 已提交
569

570 571 572
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
573 574
	err = -ENOMEM;
	root = get_root_inode(sb, d.rootmode);
575
	if (!root)
M
Miklos Szeredi 已提交
576 577
		goto err;

578 579
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
M
Miklos Szeredi 已提交
580 581 582
		iput(root);
		goto err;
	}
583

584 585 586 587
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

588 589 590 591 592 593
	if (is_bdev) {
		fc->destroy_req = fuse_request_alloc();
		if (!fc->destroy_req)
			goto err_put_root;
	}

594
	mutex_lock(&fuse_mutex);
595 596
	err = -EINVAL;
	if (file->private_data)
597
		goto err_unlock;
598

599 600 601 602 603 604
	fc->id = conn_id();
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
605 606
	sb->s_root = root_dentry;
	fc->connected = 1;
607 608
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
609 610 611 612 613 614
	/*
	 * 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);
615

616
	fuse_send_init(fc, init_req);
617

M
Miklos Szeredi 已提交
618 619
	return 0;

620 621
 err_unlock:
	mutex_unlock(&fuse_mutex);
622
	fuse_request_free(init_req);
623 624
 err_put_root:
	dput(root_dentry);
M
Miklos Szeredi 已提交
625
 err:
M
Miklos Szeredi 已提交
626
	fput(file);
627
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
628 629 630
	return err;
}

631 632 633
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 已提交
634
{
635
	return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
M
Miklos Szeredi 已提交
636 637
}

638 639 640
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
M
Miklos Szeredi 已提交
641
	.fs_flags	= FS_HAS_SUBTYPE,
642 643 644 645 646
	.get_sb		= fuse_get_sb,
	.kill_sb	= kill_anon_super,
};

#ifdef CONFIG_BLOCK
647 648 649 650 651 652 653 654 655 656 657 658 659
static int fuse_get_sb_blk(struct file_system_type *fs_type,
			   int flags, const char *dev_name,
			   void *raw_data, struct vfsmount *mnt)
{
	return get_sb_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super,
			   mnt);
}

static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
	.get_sb		= fuse_get_sb_blk,
	.kill_sb	= kill_block_super,
A
Alexey Dobriyan 已提交
660
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
661 662
};

663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
static inline int register_fuseblk(void)
{
	return register_filesystem(&fuseblk_fs_type);
}

static inline void unregister_fuseblk(void)
{
	unregister_filesystem(&fuseblk_fs_type);
}
#else
static inline int register_fuseblk(void)
{
	return 0;
}

static inline void unregister_fuseblk(void)
{
}
#endif

683
static decl_subsys(fuse, NULL, NULL);
684
static decl_subsys(connections, NULL, NULL);
685

686
static void fuse_inode_init_once(void *foo, struct kmem_cache *cachep,
M
Miklos Szeredi 已提交
687 688 689 690
				 unsigned long flags)
{
	struct inode * inode = foo;

C
Christoph Lameter 已提交
691
	inode_init_once(inode);
M
Miklos Szeredi 已提交
692 693 694 695 696 697 698 699
}

static int __init fuse_fs_init(void)
{
	int err;

	err = register_filesystem(&fuse_fs_type);
	if (err)
700 701
		goto out;

702
	err = register_fuseblk();
703 704 705 706 707 708 709 710 711 712 713 714
	if (err)
		goto out_unreg;

	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
					      fuse_inode_init_once, NULL);
	err = -ENOMEM;
	if (!fuse_inode_cachep)
		goto out_unreg2;

	return 0;
M
Miklos Szeredi 已提交
715

716
 out_unreg2:
717
	unregister_fuseblk();
718 719 720
 out_unreg:
	unregister_filesystem(&fuse_fs_type);
 out:
M
Miklos Szeredi 已提交
721 722 723 724 725 726
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
727
	unregister_fuseblk();
M
Miklos Szeredi 已提交
728 729 730
	kmem_cache_destroy(fuse_inode_cachep);
}

731 732 733 734
static int fuse_sysfs_init(void)
{
	int err;

735
	kobj_set_kset_s(&fuse_subsys, fs_subsys);
736 737 738 739
	err = subsystem_register(&fuse_subsys);
	if (err)
		goto out_err;

740
	kobj_set_kset_s(&connections_subsys, fuse_subsys);
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
	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 已提交
759 760 761 762 763 764 765
static int __init fuse_init(void)
{
	int res;

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

766
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
767 768 769 770
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
771 772 773 774
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

775 776 777 778
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

779 780 781 782
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

M
Miklos Szeredi 已提交
783 784
	return 0;

785 786
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
787 788
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
789 790
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
791 792 793 794 795 796 797 798
 err:
	return res;
}

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

799
	fuse_ctl_cleanup();
800
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
801
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
802
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
803 804 805 806
}

module_init(fuse_init);
module_exit(fuse_exit);