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

  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>
17
#include <linux/moduleparam.h>
M
Miklos Szeredi 已提交
18 19
#include <linux/parser.h>
#include <linux/statfs.h>
20
#include <linux/random.h>
A
Alexey Dobriyan 已提交
21
#include <linux/sched.h>
M
Miklos Szeredi 已提交
22
#include <linux/exportfs.h>
M
Miklos Szeredi 已提交
23 24 25 26 27

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

28
static struct kmem_cache *fuse_inode_cachep;
29 30
struct list_head fuse_conn_list;
DEFINE_MUTEX(fuse_mutex);
M
Miklos Szeredi 已提交
31

32 33
static int set_global_limit(const char *val, struct kernel_param *kp);

34
unsigned max_user_bgreq;
35 36 37 38 39 40 41
module_param_call(max_user_bgreq, set_global_limit, param_get_uint,
		  &max_user_bgreq, 0644);
__MODULE_PARM_TYPE(max_user_bgreq, "uint");
MODULE_PARM_DESC(max_user_bgreq,
 "Global limit for the maximum number of backgrounded requests an "
 "unprivileged user can set");

42
unsigned max_user_congthresh;
43 44 45 46 47 48 49
module_param_call(max_user_congthresh, set_global_limit, param_get_uint,
		  &max_user_congthresh, 0644);
__MODULE_PARM_TYPE(max_user_congthresh, "uint");
MODULE_PARM_DESC(max_user_congthresh,
 "Global limit for the maximum congestion threshold an "
 "unprivileged user can set");

M
Miklos Szeredi 已提交
50 51
#define FUSE_SUPER_MAGIC 0x65735546

M
Miklos Szeredi 已提交
52 53
#define FUSE_DEFAULT_BLKSIZE 512

54 55 56 57 58 59
/** Maximum number of outstanding background requests */
#define FUSE_DEFAULT_MAX_BACKGROUND 12

/** Congestion starts at 75% of maximum */
#define FUSE_DEFAULT_CONGESTION_THRESHOLD (FUSE_DEFAULT_MAX_BACKGROUND * 3 / 4)

M
Miklos Szeredi 已提交
60 61 62 63
struct fuse_mount_data {
	int fd;
	unsigned rootmode;
	unsigned user_id;
64
	unsigned group_id;
M
Miklos Szeredi 已提交
65 66 67 68
	unsigned fd_present:1;
	unsigned rootmode_present:1;
	unsigned user_id_present:1;
	unsigned group_id_present:1;
M
Miklos Szeredi 已提交
69
	unsigned flags;
70
	unsigned max_read;
M
Miklos Szeredi 已提交
71
	unsigned blksize;
M
Miklos Szeredi 已提交
72 73 74 75 76 77 78
};

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

79
	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
M
Miklos Szeredi 已提交
80 81 82 83
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
84
	fi->i_time = 0;
M
Miklos Szeredi 已提交
85
	fi->nodeid = 0;
86
	fi->nlookup = 0;
87
	fi->attr_version = 0;
M
Miklos Szeredi 已提交
88
	fi->writectr = 0;
89
	INIT_LIST_HEAD(&fi->write_files);
M
Miklos Szeredi 已提交
90 91 92
	INIT_LIST_HEAD(&fi->queued_writes);
	INIT_LIST_HEAD(&fi->writepages);
	init_waitqueue_head(&fi->page_waitq);
93 94 95 96 97
	fi->forget_req = fuse_request_alloc();
	if (!fi->forget_req) {
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
M
Miklos Szeredi 已提交
98 99 100 101 102 103

	return inode;
}

static void fuse_destroy_inode(struct inode *inode)
{
104
	struct fuse_inode *fi = get_fuse_inode(inode);
105
	BUG_ON(!list_empty(&fi->write_files));
M
Miklos Szeredi 已提交
106
	BUG_ON(!list_empty(&fi->queued_writes));
107 108
	if (fi->forget_req)
		fuse_request_free(fi->forget_req);
M
Miklos Szeredi 已提交
109 110 111
	kmem_cache_free(fuse_inode_cachep, inode);
}

112
void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
M
Miklos Szeredi 已提交
113
		      u64 nodeid, u64 nlookup)
114 115
{
	struct fuse_forget_in *inarg = &req->misc.forget_in;
116
	inarg->nlookup = nlookup;
117 118 119 120 121
	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;
122
	fuse_request_send_noreply(fc, req);
123 124
}

125
static void fuse_evict_inode(struct inode *inode)
M
Miklos Szeredi 已提交
126
{
127 128
	truncate_inode_pages(&inode->i_data, 0);
	end_writeback(inode);
M
Miklos Szeredi 已提交
129 130
	if (inode->i_sb->s_flags & MS_ACTIVE) {
		struct fuse_conn *fc = get_fuse_conn(inode);
131
		struct fuse_inode *fi = get_fuse_inode(inode);
132
		fuse_send_forget(fc, fi->forget_req, fi->nodeid, fi->nlookup);
133 134
		fi->forget_req = NULL;
	}
M
Miklos Szeredi 已提交
135 136
}

137 138 139 140 141 142 143 144
static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
{
	if (*flags & MS_MANDLOCK)
		return -EINVAL;

	return 0;
}

M
Miklos Szeredi 已提交
145 146
void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
				   u64 attr_valid)
M
Miklos Szeredi 已提交
147
{
M
Miklos Szeredi 已提交
148
	struct fuse_conn *fc = get_fuse_conn(inode);
149
	struct fuse_inode *fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
150

151 152 153
	fi->attr_version = ++fc->attr_version;
	fi->i_time = attr_valid;

M
Miklos Szeredi 已提交
154
	inode->i_ino     = attr->ino;
155
	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
M
Miklos Szeredi 已提交
156 157 158 159 160 161 162 163 164 165
	inode->i_nlink   = attr->nlink;
	inode->i_uid     = attr->uid;
	inode->i_gid     = attr->gid;
	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;
166

167 168 169 170 171
	if (attr->blksize != 0)
		inode->i_blkbits = ilog2(attr->blksize);
	else
		inode->i_blkbits = inode->i_sb->s_blocksize_bits;

172 173 174 175 176 177 178 179
	/*
	 * Don't set the sticky bit in i_mode, unless we want the VFS
	 * to check permissions.  This prevents failures due to the
	 * check in may_delete().
	 */
	fi->orig_i_mode = inode->i_mode;
	if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
		inode->i_mode &= ~S_ISVTX;
M
Miklos Szeredi 已提交
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
}

void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
			    u64 attr_valid, u64 attr_version)
{
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_inode *fi = get_fuse_inode(inode);
	loff_t oldsize;

	spin_lock(&fc->lock);
	if (attr_version != 0 && fi->attr_version > attr_version) {
		spin_unlock(&fc->lock);
		return;
	}

	fuse_change_attributes_common(inode, attr, attr_valid);
196

197 198 199 200 201
	oldsize = inode->i_size;
	i_size_write(inode, attr->size);
	spin_unlock(&fc->lock);

	if (S_ISREG(inode->i_mode) && oldsize != attr->size) {
N
npiggin@suse.de 已提交
202
		truncate_pagecache(inode, oldsize, attr->size);
M
Miklos Szeredi 已提交
203
		invalidate_inode_pages2(inode->i_mapping);
204
	}
M
Miklos Szeredi 已提交
205 206 207 208 209
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
M
Miklos Szeredi 已提交
210
	inode->i_size = attr->size;
211 212
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
M
Miklos Szeredi 已提交
213
		fuse_init_file_inode(inode);
214 215 216 217 218 219 220 221 222
	} 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));
223 224
	} else
		BUG();
M
Miklos Szeredi 已提交
225 226
}

J
John Muir 已提交
227
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
M
Miklos Szeredi 已提交
228
{
M
Miklos Szeredi 已提交
229
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
230 231 232 233 234 235 236 237
	if (get_node_id(inode) == nodeid)
		return 1;
	else
		return 0;
}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
M
Miklos Szeredi 已提交
238
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
239 240 241 242
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

M
Miklos Szeredi 已提交
243
struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
244 245
			int generation, struct fuse_attr *attr,
			u64 attr_valid, u64 attr_version)
M
Miklos Szeredi 已提交
246 247
{
	struct inode *inode;
248
	struct fuse_inode *fi;
M
Miklos Szeredi 已提交
249 250 251 252 253 254 255 256
	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)) {
257
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
M
Miklos Szeredi 已提交
258 259 260 261 262 263 264 265 266 267 268
		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;
	}

269
	fi = get_fuse_inode(inode);
270
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
271
	fi->nlookup++;
272
	spin_unlock(&fc->lock);
273 274
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

M
Miklos Szeredi 已提交
275 276 277
	return inode;
}

J
John Muir 已提交
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid,
			     loff_t offset, loff_t len)
{
	struct inode *inode;
	pgoff_t pg_start;
	pgoff_t pg_end;

	inode = ilookup5(sb, nodeid, fuse_inode_eq, &nodeid);
	if (!inode)
		return -ENOENT;

	fuse_invalidate_attr(inode);
	if (offset >= 0) {
		pg_start = offset >> PAGE_CACHE_SHIFT;
		if (len <= 0)
			pg_end = -1;
		else
			pg_end = (offset + len - 1) >> PAGE_CACHE_SHIFT;
		invalidate_inode_pages2_range(inode->i_mapping,
					      pg_start, pg_end);
	}
	iput(inode);
	return 0;
}

303
static void fuse_umount_begin(struct super_block *sb)
304
{
305
	fuse_abort_conn(get_fuse_conn_super(sb));
306 307
}

308 309 310 311 312 313 314
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;
315
		fuse_request_send(fc, req);
316 317 318 319
		fuse_put_request(fc, req);
	}
}

320
static void fuse_bdi_destroy(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
321
{
322 323 324
	if (fc->bdi_initialized)
		bdi_destroy(&fc->bdi);
}
M
Miklos Szeredi 已提交
325

326
void fuse_conn_kill(struct fuse_conn *fc)
327
{
328
	spin_lock(&fc->lock);
329
	fc->connected = 0;
330
	fc->blocked = 0;
331
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
332
	/* Flush all readers on this fs */
333
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
M
Miklos Szeredi 已提交
334
	wake_up_all(&fc->waitq);
335
	wake_up_all(&fc->blocked_waitq);
336
	wake_up_all(&fc->reserved_req_waitq);
337 338 339 340
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
341 342
	fuse_bdi_destroy(fc);
}
343
EXPORT_SYMBOL_GPL(fuse_conn_kill);
344 345 346 347 348 349 350

static void fuse_put_super(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

	fuse_send_destroy(fc);
	fuse_conn_kill(fc);
351
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
352 353
}

354 355 356 357
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
358
	stbuf->f_frsize  = attr->frsize;
359 360 361 362 363 364 365 366 367
	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 */
}

368
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
369
{
370
	struct super_block *sb = dentry->d_sb;
371 372 373 374 375
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

M
Miklos Szeredi 已提交
376 377 378 379 380
	if (!fuse_allow_task(fc, current)) {
		buf->f_type = FUSE_SUPER_MAGIC;
		return 0;
	}

381 382 383
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
384

385
	memset(&outarg, 0, sizeof(outarg));
386 387
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
388
	req->in.h.nodeid = get_node_id(dentry->d_inode);
389
	req->out.numargs = 1;
390 391
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
392
	req->out.args[0].value = &outarg;
393
	fuse_request_send(fc, req);
394 395 396 397 398 399 400
	err = req->out.h.error;
	if (!err)
		convert_fuse_statfs(buf, &outarg.st);
	fuse_put_request(fc, req);
	return err;
}

M
Miklos Szeredi 已提交
401 402 403 404
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
405
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
406 407
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
408
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
409
	OPT_BLKSIZE,
M
Miklos Szeredi 已提交
410 411 412
	OPT_ERR
};

413
static const match_table_t tokens = {
M
Miklos Szeredi 已提交
414 415 416
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
417
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
418 419
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
420
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
421
	{OPT_BLKSIZE,			"blksize=%u"},
M
Miklos Szeredi 已提交
422 423 424
	{OPT_ERR,			NULL}
};

M
Miklos Szeredi 已提交
425
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
M
Miklos Szeredi 已提交
426 427 428
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
429
	d->max_read = ~0;
M
Miklos Szeredi 已提交
430
	d->blksize = FUSE_DEFAULT_BLKSIZE;
M
Miklos Szeredi 已提交
431 432 433 434 435 436 437 438 439 440 441 442 443 444

	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;
445
			d->fd_present = 1;
M
Miklos Szeredi 已提交
446 447 448 449 450
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
451 452
			if (!fuse_valid_type(value))
				return 0;
M
Miklos Szeredi 已提交
453
			d->rootmode = value;
454
			d->rootmode_present = 1;
M
Miklos Szeredi 已提交
455 456 457 458 459 460
			break;

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

464 465 466 467
		case OPT_GROUP_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->group_id = value;
468
			d->group_id_present = 1;
469 470
			break;

M
Miklos Szeredi 已提交
471 472 473 474 475 476 477 478
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

479 480 481 482 483 484
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

M
Miklos Szeredi 已提交
485 486 487 488 489 490
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

M
Miklos Szeredi 已提交
491 492 493 494
		default:
			return 0;
		}
	}
495 496 497

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
498 499 500 501 502 503 504 505 506 507
		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);
508
	seq_printf(m, ",group_id=%u", fc->group_id);
M
Miklos Szeredi 已提交
509 510 511 512
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
513 514
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
M
Miklos Szeredi 已提交
515 516 517
	if (mnt->mnt_sb->s_bdev &&
	    mnt->mnt_sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
		seq_printf(m, ",blksize=%lu", mnt->mnt_sb->s_blocksize);
M
Miklos Szeredi 已提交
518 519 520
	return 0;
}

521
void fuse_conn_init(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
522
{
523 524 525
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
	mutex_init(&fc->inst_mutex);
J
John Muir 已提交
526
	init_rwsem(&fc->killsb);
527 528 529 530 531 532 533 534 535 536 537
	atomic_set(&fc->count, 1);
	init_waitqueue_head(&fc->waitq);
	init_waitqueue_head(&fc->blocked_waitq);
	init_waitqueue_head(&fc->reserved_req_waitq);
	INIT_LIST_HEAD(&fc->pending);
	INIT_LIST_HEAD(&fc->processing);
	INIT_LIST_HEAD(&fc->io);
	INIT_LIST_HEAD(&fc->interrupts);
	INIT_LIST_HEAD(&fc->bg_queue);
	INIT_LIST_HEAD(&fc->entry);
	atomic_set(&fc->num_waiting, 0);
538 539
	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
540 541 542 543 544 545
	fc->khctr = 0;
	fc->polled_files = RB_ROOT;
	fc->reqctr = 0;
	fc->blocked = 1;
	fc->attr_version = 1;
	get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
M
Miklos Szeredi 已提交
546
}
547
EXPORT_SYMBOL_GPL(fuse_conn_init);
M
Miklos Szeredi 已提交
548

549 550
void fuse_conn_put(struct fuse_conn *fc)
{
551
	if (atomic_dec_and_test(&fc->count)) {
552 553
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
554
		mutex_destroy(&fc->inst_mutex);
T
Tejun Heo 已提交
555
		fc->release(fc);
556
	}
557
}
558
EXPORT_SYMBOL_GPL(fuse_conn_put);
559 560 561 562 563 564

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

567
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
M
Miklos Szeredi 已提交
568 569 570 571 572 573
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
574
	attr.nlink = 1;
575
	return fuse_iget(sb, 1, 0, &attr, 0, 0);
M
Miklos Szeredi 已提交
576 577
}

M
Miklos Szeredi 已提交
578
struct fuse_inode_handle {
M
Miklos Szeredi 已提交
579 580 581 582 583 584 585
	u64 nodeid;
	u32 generation;
};

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
586
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
587 588 589 590 591 592 593 594
	struct inode *inode;
	struct dentry *entry;
	int err = -ESTALE;

	if (handle->nodeid == 0)
		goto out_err;

	inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid);
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
	if (!inode) {
		struct fuse_entry_out outarg;
		struct qstr name;

		if (!fc->export_support)
			goto out_err;

		name.len = 1;
		name.name = ".";
		err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg,
				       &inode);
		if (err && err != -ENOENT)
			goto out_err;
		if (err || !inode) {
			err = -ESTALE;
			goto out_err;
		}
		err = -EIO;
		if (get_node_id(inode) != handle->nodeid)
			goto out_iput;
	}
M
Miklos Szeredi 已提交
616 617 618 619
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

620 621
	entry = d_obtain_alias(inode);
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID) {
M
Miklos Szeredi 已提交
622 623 624 625 626 627 628 629 630 631 632 633 634 635 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 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
		entry->d_op = &fuse_dentry_operations;
		fuse_invalidate_entry_cache(entry);
	}

	return entry;

 out_iput:
	iput(inode);
 out_err:
	return ERR_PTR(err);
}

static int fuse_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
			   int connectable)
{
	struct inode *inode = dentry->d_inode;
	bool encode_parent = connectable && !S_ISDIR(inode->i_mode);
	int len = encode_parent ? 6 : 3;
	u64 nodeid;
	u32 generation;

	if (*max_len < len)
		return  255;

	nodeid = get_fuse_inode(inode)->nodeid;
	generation = inode->i_generation;

	fh[0] = (u32)(nodeid >> 32);
	fh[1] = (u32)(nodeid & 0xffffffff);
	fh[2] = generation;

	if (encode_parent) {
		struct inode *parent;

		spin_lock(&dentry->d_lock);
		parent = dentry->d_parent->d_inode;
		nodeid = get_fuse_inode(parent)->nodeid;
		generation = parent->i_generation;
		spin_unlock(&dentry->d_lock);

		fh[3] = (u32)(nodeid >> 32);
		fh[4] = (u32)(nodeid & 0xffffffff);
		fh[5] = generation;
	}

	*max_len = len;
	return encode_parent ? 0x82 : 0x81;
}

static struct dentry *fuse_fh_to_dentry(struct super_block *sb,
		struct fid *fid, int fh_len, int fh_type)
{
	struct fuse_inode_handle handle;

	if ((fh_type != 0x81 && fh_type != 0x82) || fh_len < 3)
		return NULL;

	handle.nodeid = (u64) fid->raw[0] << 32;
	handle.nodeid |= (u64) fid->raw[1];
	handle.generation = fid->raw[2];
	return fuse_get_dentry(sb, &handle);
}

static struct dentry *fuse_fh_to_parent(struct super_block *sb,
		struct fid *fid, int fh_len, int fh_type)
{
	struct fuse_inode_handle parent;

	if (fh_type != 0x82 || fh_len < 6)
		return NULL;

	parent.nodeid = (u64) fid->raw[3] << 32;
	parent.nodeid |= (u64) fid->raw[4];
	parent.generation = fid->raw[5];
	return fuse_get_dentry(sb, &parent);
}

699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
static struct dentry *fuse_get_parent(struct dentry *child)
{
	struct inode *child_inode = child->d_inode;
	struct fuse_conn *fc = get_fuse_conn(child_inode);
	struct inode *inode;
	struct dentry *parent;
	struct fuse_entry_out outarg;
	struct qstr name;
	int err;

	if (!fc->export_support)
		return ERR_PTR(-ESTALE);

	name.len = 2;
	name.name = "..";
	err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode),
			       &name, &outarg, &inode);
716 717 718
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
719 720
		return ERR_PTR(err);
	}
721 722 723

	parent = d_obtain_alias(inode);
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID) {
724 725 726 727 728 729
		parent->d_op = &fuse_dentry_operations;
		fuse_invalidate_entry_cache(parent);
	}

	return parent;
}
M
Miklos Szeredi 已提交
730 731 732 733 734

static const struct export_operations fuse_export_operations = {
	.fh_to_dentry	= fuse_fh_to_dentry,
	.fh_to_parent	= fuse_fh_to_parent,
	.encode_fh	= fuse_encode_fh,
735
	.get_parent	= fuse_get_parent,
M
Miklos Szeredi 已提交
736 737
};

738
static const struct super_operations fuse_super_operations = {
M
Miklos Szeredi 已提交
739 740
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
741
	.evict_inode	= fuse_evict_inode,
M
Miklos Szeredi 已提交
742
	.drop_inode	= generic_delete_inode,
743
	.remount_fs	= fuse_remount_fs,
M
Miklos Szeredi 已提交
744
	.put_super	= fuse_put_super,
745
	.umount_begin	= fuse_umount_begin,
746
	.statfs		= fuse_statfs,
M
Miklos Szeredi 已提交
747 748 749
	.show_options	= fuse_show_options,
};

750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
static void sanitize_global_limit(unsigned *limit)
{
	if (*limit == 0)
		*limit = ((num_physpages << PAGE_SHIFT) >> 13) /
			 sizeof(struct fuse_req);

	if (*limit >= 1 << 16)
		*limit = (1 << 16) - 1;
}

static int set_global_limit(const char *val, struct kernel_param *kp)
{
	int rv;

	rv = param_set_uint(val, kp);
	if (rv)
		return rv;

	sanitize_global_limit((unsigned *)kp->arg);

	return 0;
}

static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg)
{
	int cap_sys_admin = capable(CAP_SYS_ADMIN);

	if (arg->minor < 13)
		return;

	sanitize_global_limit(&max_user_bgreq);
	sanitize_global_limit(&max_user_congthresh);

	if (arg->max_background) {
		fc->max_background = arg->max_background;

		if (!cap_sys_admin && fc->max_background > max_user_bgreq)
			fc->max_background = max_user_bgreq;
	}
	if (arg->congestion_threshold) {
		fc->congestion_threshold = arg->congestion_threshold;

		if (!cap_sys_admin &&
		    fc->congestion_threshold > max_user_congthresh)
			fc->congestion_threshold = max_user_congthresh;
	}
}

798 799 800 801 802 803 804
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 {
805 806
		unsigned long ra_pages;

807 808
		process_init_limits(fc, arg);

809 810 811 812
		if (arg->minor >= 6) {
			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
813 814
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
815 816
			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
				fc->atomic_o_trunc = 1;
817 818 819 820 821
			if (arg->minor >= 9) {
				/* LOOKUP has dependency on proto version */
				if (arg->flags & FUSE_EXPORT_SUPPORT)
					fc->export_support = 1;
			}
822 823
			if (arg->flags & FUSE_BIG_WRITES)
				fc->big_writes = 1;
824 825
			if (arg->flags & FUSE_DONT_MASK)
				fc->dont_mask = 1;
826
		} else {
827
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
828 829
			fc->no_lock = 1;
		}
830 831

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
832 833
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
834
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
835
		fc->conn_init = 1;
836
	}
837 838
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
839 840
}

841
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
842 843
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
844

845 846
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
847
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
848
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
849
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK;
850 851 852 853 854
	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;
D
Daniel Mack 已提交
855
	/* Variable length argument used for backward compatibility
856 857 858 859 860 861
	   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;
862
	fuse_request_send_background(fc, req);
863 864
}

T
Tejun Heo 已提交
865 866 867 868 869
static void fuse_free_conn(struct fuse_conn *fc)
{
	kfree(fc);
}

870 871 872 873
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

874
	fc->bdi.name = "fuse";
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
	fc->bdi.unplug_io_fn = default_unplug_io_fn;
	/* fuse does it's own writeback accounting */
	fc->bdi.capabilities = BDI_CAP_NO_ACCT_WB;

	err = bdi_init(&fc->bdi);
	if (err)
		return err;

	fc->bdi_initialized = 1;

	if (sb->s_bdev) {
		err =  bdi_register(&fc->bdi, NULL, "%u:%u-fuseblk",
				    MAJOR(fc->dev), MINOR(fc->dev));
	} else {
		err = bdi_register_dev(&fc->bdi, fc->dev);
	}

	if (err)
		return err;

	/*
	 * For a single fuse filesystem use max 1% of dirty +
	 * writeback threshold.
	 *
	 * This gives about 1M of write buffer for memory maps on a
	 * machine with 1G and 10% dirty_ratio, which should be more
	 * than enough.
	 *
	 * Privileged users can raise it by writing to
	 *
	 *    /sys/class/bdi/<bdi>/max_ratio
	 */
	bdi_set_max_ratio(&fc->bdi, 1);

	return 0;
}

M
Miklos Szeredi 已提交
913 914 915 916 917 918
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;
919
	struct dentry *root_dentry;
920
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
921
	int err;
M
Miklos Szeredi 已提交
922
	int is_bdev = sb->s_bdev != NULL;
M
Miklos Szeredi 已提交
923

924
	err = -EINVAL;
925
	if (sb->s_flags & MS_MANDLOCK)
926
		goto err;
927

M
Miklos Szeredi 已提交
928
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
929
		goto err;
M
Miklos Szeredi 已提交
930

M
Miklos Szeredi 已提交
931
	if (is_bdev) {
932
#ifdef CONFIG_BLOCK
933
		err = -EINVAL;
M
Miklos Szeredi 已提交
934
		if (!sb_set_blocksize(sb, d.blksize))
935
			goto err;
936
#endif
M
Miklos Szeredi 已提交
937 938 939 940
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
M
Miklos Szeredi 已提交
941 942 943
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
M
Miklos Szeredi 已提交
944
	sb->s_export_op = &fuse_export_operations;
M
Miklos Szeredi 已提交
945 946

	file = fget(d.fd);
947
	err = -EINVAL;
M
Miklos Szeredi 已提交
948
	if (!file)
949
		goto err;
M
Miklos Szeredi 已提交
950

951 952
	if (file->f_op != &fuse_dev_operations)
		goto err_fput;
M
Miklos Szeredi 已提交
953

954
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
955 956 957
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
M
Miklos Szeredi 已提交
958

959 960 961
	fuse_conn_init(fc);

	fc->dev = sb->s_dev;
J
John Muir 已提交
962
	fc->sb = sb;
963 964 965
	err = fuse_bdi_init(fc, sb);
	if (err)
		goto err_put_conn;
966

J
Jens Axboe 已提交
967 968
	sb->s_bdi = &fc->bdi;

969 970 971 972 973
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

T
Tejun Heo 已提交
974
	fc->release = fuse_free_conn;
M
Miklos Szeredi 已提交
975
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
976
	fc->user_id = d.user_id;
977
	fc->group_id = d.group_id;
978
	fc->max_read = max_t(unsigned, 4096, d.max_read);
M
Miklos Szeredi 已提交
979

980 981 982
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
983
	err = -ENOMEM;
984
	root = fuse_get_root_inode(sb, d.rootmode);
985
	if (!root)
986
		goto err_put_conn;
M
Miklos Szeredi 已提交
987

988 989
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
M
Miklos Szeredi 已提交
990
		iput(root);
991
		goto err_put_conn;
M
Miklos Szeredi 已提交
992
	}
993

994 995 996 997
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

998 999 1000
	if (is_bdev) {
		fc->destroy_req = fuse_request_alloc();
		if (!fc->destroy_req)
J
Julia Lawall 已提交
1001
			goto err_free_init_req;
1002 1003
	}

1004
	mutex_lock(&fuse_mutex);
1005 1006
	err = -EINVAL;
	if (file->private_data)
1007
		goto err_unlock;
1008

1009 1010 1011 1012 1013
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
1014 1015
	sb->s_root = root_dentry;
	fc->connected = 1;
1016 1017
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
1018 1019 1020 1021 1022 1023
	/*
	 * 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);
1024

1025
	fuse_send_init(fc, init_req);
1026

M
Miklos Szeredi 已提交
1027 1028
	return 0;

1029 1030
 err_unlock:
	mutex_unlock(&fuse_mutex);
J
Julia Lawall 已提交
1031
 err_free_init_req:
1032
	fuse_request_free(init_req);
1033 1034
 err_put_root:
	dput(root_dentry);
1035
 err_put_conn:
1036
	fuse_bdi_destroy(fc);
1037
	fuse_conn_put(fc);
1038 1039 1040
 err_fput:
	fput(file);
 err:
M
Miklos Szeredi 已提交
1041 1042 1043
	return err;
}

A
Al Viro 已提交
1044
static struct dentry *fuse_mount(struct file_system_type *fs_type,
1045
		       int flags, const char *dev_name,
A
Al Viro 已提交
1046
		       void *raw_data)
M
Miklos Szeredi 已提交
1047
{
A
Al Viro 已提交
1048
	return mount_nodev(fs_type, flags, raw_data, fuse_fill_super);
M
Miklos Szeredi 已提交
1049 1050
}

J
John Muir 已提交
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
static void fuse_kill_sb_anon(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

	if (fc) {
		down_write(&fc->killsb);
		fc->sb = NULL;
		up_write(&fc->killsb);
	}

	kill_anon_super(sb);
}

1064 1065 1066
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
M
Miklos Szeredi 已提交
1067
	.fs_flags	= FS_HAS_SUBTYPE,
A
Al Viro 已提交
1068
	.mount		= fuse_mount,
J
John Muir 已提交
1069
	.kill_sb	= fuse_kill_sb_anon,
1070 1071 1072
};

#ifdef CONFIG_BLOCK
A
Al Viro 已提交
1073
static struct dentry *fuse_mount_blk(struct file_system_type *fs_type,
1074
			   int flags, const char *dev_name,
A
Al Viro 已提交
1075
			   void *raw_data)
1076
{
A
Al Viro 已提交
1077
	return mount_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super);
1078 1079
}

J
John Muir 已提交
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
static void fuse_kill_sb_blk(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

	if (fc) {
		down_write(&fc->killsb);
		fc->sb = NULL;
		up_write(&fc->killsb);
	}

	kill_block_super(sb);
}

1093 1094 1095
static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
A
Al Viro 已提交
1096
	.mount		= fuse_mount_blk,
J
John Muir 已提交
1097
	.kill_sb	= fuse_kill_sb_blk,
A
Alexey Dobriyan 已提交
1098
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1099 1100
};

1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
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

1121
static void fuse_inode_init_once(void *foo)
M
Miklos Szeredi 已提交
1122
{
M
Miklos Szeredi 已提交
1123
	struct inode *inode = foo;
M
Miklos Szeredi 已提交
1124

C
Christoph Lameter 已提交
1125
	inode_init_once(inode);
M
Miklos Szeredi 已提交
1126 1127 1128 1129 1130 1131 1132 1133
}

static int __init fuse_fs_init(void)
{
	int err;

	err = register_filesystem(&fuse_fs_type);
	if (err)
1134 1135
		goto out;

1136
	err = register_fuseblk();
1137 1138 1139 1140 1141 1142
	if (err)
		goto out_unreg;

	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
1143
					      fuse_inode_init_once);
1144 1145 1146 1147 1148
	err = -ENOMEM;
	if (!fuse_inode_cachep)
		goto out_unreg2;

	return 0;
M
Miklos Szeredi 已提交
1149

1150
 out_unreg2:
1151
	unregister_fuseblk();
1152 1153 1154
 out_unreg:
	unregister_filesystem(&fuse_fs_type);
 out:
M
Miklos Szeredi 已提交
1155 1156 1157 1158 1159 1160
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
1161
	unregister_fuseblk();
M
Miklos Szeredi 已提交
1162 1163 1164
	kmem_cache_destroy(fuse_inode_cachep);
}

1165 1166 1167
static struct kobject *fuse_kobj;
static struct kobject *connections_kobj;

1168 1169 1170 1171
static int fuse_sysfs_init(void)
{
	int err;

1172
	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1173 1174
	if (!fuse_kobj) {
		err = -ENOMEM;
1175
		goto out_err;
1176
	}
1177

1178 1179 1180
	connections_kobj = kobject_create_and_add("connections", fuse_kobj);
	if (!connections_kobj) {
		err = -ENOMEM;
1181
		goto out_fuse_unregister;
1182
	}
1183 1184 1185 1186

	return 0;

 out_fuse_unregister:
1187
	kobject_put(fuse_kobj);
1188 1189 1190 1191 1192 1193
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
1194 1195
	kobject_put(connections_kobj);
	kobject_put(fuse_kobj);
1196 1197
}

M
Miklos Szeredi 已提交
1198 1199 1200 1201
static int __init fuse_init(void)
{
	int res;

M
Miklos Szeredi 已提交
1202
	printk(KERN_INFO "fuse init (API version %i.%i)\n",
M
Miklos Szeredi 已提交
1203 1204
	       FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);

1205
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
1206 1207 1208 1209
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
1210 1211 1212 1213
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

1214 1215 1216 1217
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

1218 1219 1220 1221
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

1222 1223 1224
	sanitize_global_limit(&max_user_bgreq);
	sanitize_global_limit(&max_user_congthresh);

M
Miklos Szeredi 已提交
1225 1226
	return 0;

1227 1228
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
1229 1230
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1231 1232
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1233 1234 1235 1236 1237 1238 1239 1240
 err:
	return res;
}

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

1241
	fuse_ctl_cleanup();
1242
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
1243
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1244
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1245 1246 1247 1248
}

module_init(fuse_init);
module_exit(fuse_exit);