inode.c 28.4 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
struct fuse_forget_link *fuse_alloc_forget(void)
75 76 77 78
{
	return kzalloc(sizeof(struct fuse_forget_link), GFP_KERNEL);
}

M
Miklos Szeredi 已提交
79 80 81 82 83
static struct inode *fuse_alloc_inode(struct super_block *sb)
{
	struct inode *inode;
	struct fuse_inode *fi;

84
	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
M
Miklos Szeredi 已提交
85 86 87 88
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
89
	fi->i_time = 0;
M
Miklos Szeredi 已提交
90
	fi->nodeid = 0;
91
	fi->nlookup = 0;
92
	fi->attr_version = 0;
M
Miklos Szeredi 已提交
93
	fi->writectr = 0;
94
	fi->orig_ino = 0;
95
	INIT_LIST_HEAD(&fi->write_files);
M
Miklos Szeredi 已提交
96 97 98
	INIT_LIST_HEAD(&fi->queued_writes);
	INIT_LIST_HEAD(&fi->writepages);
	init_waitqueue_head(&fi->page_waitq);
99 100
	fi->forget = fuse_alloc_forget();
	if (!fi->forget) {
101 102 103
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
M
Miklos Szeredi 已提交
104 105 106 107

	return inode;
}

N
Nick Piggin 已提交
108 109 110 111 112 113
static void fuse_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	kmem_cache_free(fuse_inode_cachep, inode);
}

M
Miklos Szeredi 已提交
114 115
static void fuse_destroy_inode(struct inode *inode)
{
116
	struct fuse_inode *fi = get_fuse_inode(inode);
117
	BUG_ON(!list_empty(&fi->write_files));
M
Miklos Szeredi 已提交
118
	BUG_ON(!list_empty(&fi->queued_writes));
119
	kfree(fi->forget);
N
Nick Piggin 已提交
120
	call_rcu(&inode->i_rcu, fuse_i_callback);
M
Miklos Szeredi 已提交
121 122
}

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

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

	return 0;
}

143 144 145 146 147 148 149 150 151 152 153 154
/*
 * ino_t is 32-bits on 32-bit arch. We have to squash the 64-bit value down
 * so that it will fit.
 */
static ino_t fuse_squash_ino(u64 ino64)
{
	ino_t ino = (ino_t) ino64;
	if (sizeof(ino_t) < sizeof(u64))
		ino ^= ino64 >> (sizeof(u64) - sizeof(ino_t)) * 8;
	return ino;
}

M
Miklos Szeredi 已提交
155 156
void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
				   u64 attr_valid)
M
Miklos Szeredi 已提交
157
{
M
Miklos Szeredi 已提交
158
	struct fuse_conn *fc = get_fuse_conn(inode);
159
	struct fuse_inode *fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
160

161 162 163
	fi->attr_version = ++fc->attr_version;
	fi->i_time = attr_valid;

164
	inode->i_ino     = fuse_squash_ino(attr->ino);
165
	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
M
Miklos Szeredi 已提交
166
	set_nlink(inode, attr->nlink);
M
Miklos Szeredi 已提交
167 168 169 170 171 172 173 174 175
	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;
176

177 178 179 180 181
	if (attr->blksize != 0)
		inode->i_blkbits = ilog2(attr->blksize);
	else
		inode->i_blkbits = inode->i_sb->s_blocksize_bits;

182 183 184 185 186 187 188 189
	/*
	 * 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;
190 191

	fi->orig_ino = attr->ino;
M
Miklos Szeredi 已提交
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
}

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);
208

209 210 211 212 213
	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 已提交
214
		truncate_pagecache(inode, oldsize, attr->size);
M
Miklos Szeredi 已提交
215
		invalidate_inode_pages2(inode->i_mapping);
216
	}
M
Miklos Szeredi 已提交
217 218 219 220 221
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
M
Miklos Szeredi 已提交
222
	inode->i_size = attr->size;
223 224
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
M
Miklos Szeredi 已提交
225
		fuse_init_file_inode(inode);
226 227 228 229 230 231 232 233 234
	} 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));
235 236
	} else
		BUG();
M
Miklos Szeredi 已提交
237 238
}

J
John Muir 已提交
239
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
M
Miklos Szeredi 已提交
240
{
M
Miklos Szeredi 已提交
241
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
242 243 244 245 246 247 248 249
	if (get_node_id(inode) == nodeid)
		return 1;
	else
		return 0;
}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
M
Miklos Szeredi 已提交
250
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
251 252 253 254
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

M
Miklos Szeredi 已提交
255
struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
256 257
			int generation, struct fuse_attr *attr,
			u64 attr_valid, u64 attr_version)
M
Miklos Szeredi 已提交
258 259
{
	struct inode *inode;
260
	struct fuse_inode *fi;
M
Miklos Szeredi 已提交
261 262 263 264 265 266 267 268
	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)) {
269
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
M
Miklos Szeredi 已提交
270 271 272 273 274 275 276 277 278 279 280
		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;
	}

281
	fi = get_fuse_inode(inode);
282
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
283
	fi->nlookup++;
284
	spin_unlock(&fc->lock);
285 286
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

M
Miklos Szeredi 已提交
287 288 289
	return inode;
}

J
John Muir 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
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;
}

315
static void fuse_umount_begin(struct super_block *sb)
316
{
317
	fuse_abort_conn(get_fuse_conn_super(sb));
318 319
}

320 321 322 323 324 325 326
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;
327
		fuse_request_send(fc, req);
328 329 330 331
		fuse_put_request(fc, req);
	}
}

332
static void fuse_bdi_destroy(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
333
{
334 335 336
	if (fc->bdi_initialized)
		bdi_destroy(&fc->bdi);
}
M
Miklos Szeredi 已提交
337

338
void fuse_conn_kill(struct fuse_conn *fc)
339
{
340
	spin_lock(&fc->lock);
341
	fc->connected = 0;
342
	fc->blocked = 0;
343
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
344
	/* Flush all readers on this fs */
345
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
M
Miklos Szeredi 已提交
346
	wake_up_all(&fc->waitq);
347
	wake_up_all(&fc->blocked_waitq);
348
	wake_up_all(&fc->reserved_req_waitq);
349 350 351 352
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
353 354
	fuse_bdi_destroy(fc);
}
355
EXPORT_SYMBOL_GPL(fuse_conn_kill);
356 357 358 359 360 361 362

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);
363
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
364 365
}

366 367 368 369
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
370
	stbuf->f_frsize  = attr->frsize;
371 372 373 374 375 376 377 378 379
	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 */
}

380
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
381
{
382
	struct super_block *sb = dentry->d_sb;
383 384 385 386 387
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

M
Miklos Szeredi 已提交
388 389 390 391 392
	if (!fuse_allow_task(fc, current)) {
		buf->f_type = FUSE_SUPER_MAGIC;
		return 0;
	}

393 394 395
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
396

397
	memset(&outarg, 0, sizeof(outarg));
398 399
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
400
	req->in.h.nodeid = get_node_id(dentry->d_inode);
401
	req->out.numargs = 1;
402 403
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
404
	req->out.args[0].value = &outarg;
405
	fuse_request_send(fc, req);
406 407 408 409 410 411 412
	err = req->out.h.error;
	if (!err)
		convert_fuse_statfs(buf, &outarg.st);
	fuse_put_request(fc, req);
	return err;
}

M
Miklos Szeredi 已提交
413 414 415 416
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
417
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
418 419
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
420
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
421
	OPT_BLKSIZE,
M
Miklos Szeredi 已提交
422 423 424
	OPT_ERR
};

425
static const match_table_t tokens = {
M
Miklos Szeredi 已提交
426 427 428
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
429
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
430 431
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
432
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
433
	{OPT_BLKSIZE,			"blksize=%u"},
M
Miklos Szeredi 已提交
434 435 436
	{OPT_ERR,			NULL}
};

M
Miklos Szeredi 已提交
437
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
M
Miklos Szeredi 已提交
438 439 440
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
441
	d->max_read = ~0;
M
Miklos Szeredi 已提交
442
	d->blksize = FUSE_DEFAULT_BLKSIZE;
M
Miklos Szeredi 已提交
443 444 445 446 447 448 449 450 451 452 453 454 455 456

	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;
457
			d->fd_present = 1;
M
Miklos Szeredi 已提交
458 459 460 461 462
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
463 464
			if (!fuse_valid_type(value))
				return 0;
M
Miklos Szeredi 已提交
465
			d->rootmode = value;
466
			d->rootmode_present = 1;
M
Miklos Szeredi 已提交
467 468 469 470 471 472
			break;

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

476 477 478 479
		case OPT_GROUP_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->group_id = value;
480
			d->group_id_present = 1;
481 482
			break;

M
Miklos Szeredi 已提交
483 484 485 486 487 488 489 490
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

491 492 493 494 495 496
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

M
Miklos Szeredi 已提交
497 498 499 500 501 502
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

M
Miklos Szeredi 已提交
503 504 505 506
		default:
			return 0;
		}
	}
507 508 509

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
510 511 512 513 514
		return 0;

	return 1;
}

515
static int fuse_show_options(struct seq_file *m, struct dentry *root)
M
Miklos Szeredi 已提交
516
{
517 518
	struct super_block *sb = root->d_sb;
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
519 520

	seq_printf(m, ",user_id=%u", fc->user_id);
521
	seq_printf(m, ",group_id=%u", fc->group_id);
M
Miklos Szeredi 已提交
522 523 524 525
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
526 527
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
528 529
	if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
		seq_printf(m, ",blksize=%lu", sb->s_blocksize);
M
Miklos Szeredi 已提交
530 531 532
	return 0;
}

533
void fuse_conn_init(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
534
{
535 536 537
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
	mutex_init(&fc->inst_mutex);
J
John Muir 已提交
538
	init_rwsem(&fc->killsb);
539 540 541 542 543 544 545 546 547 548
	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);
549
	fc->forget_list_tail = &fc->forget_list_head;
550
	atomic_set(&fc->num_waiting, 0);
551 552
	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
553 554 555 556 557 558
	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 已提交
559
}
560
EXPORT_SYMBOL_GPL(fuse_conn_init);
M
Miklos Szeredi 已提交
561

562 563
void fuse_conn_put(struct fuse_conn *fc)
{
564
	if (atomic_dec_and_test(&fc->count)) {
565 566
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
567
		mutex_destroy(&fc->inst_mutex);
T
Tejun Heo 已提交
568
		fc->release(fc);
569
	}
570
}
571
EXPORT_SYMBOL_GPL(fuse_conn_put);
572 573 574 575 576 577

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

580
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
M
Miklos Szeredi 已提交
581 582 583 584 585 586
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
587
	attr.nlink = 1;
588
	return fuse_iget(sb, 1, 0, &attr, 0, 0);
M
Miklos Szeredi 已提交
589 590
}

M
Miklos Szeredi 已提交
591
struct fuse_inode_handle {
M
Miklos Szeredi 已提交
592 593 594 595 596 597 598
	u64 nodeid;
	u32 generation;
};

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
599
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
600 601 602 603 604 605 606 607
	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);
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
	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 已提交
629 630 631 632
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

633
	entry = d_obtain_alias(inode);
A
Al Viro 已提交
634
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
M
Miklos Szeredi 已提交
635 636 637 638 639 640 641 642 643 644
		fuse_invalidate_entry_cache(entry);

	return entry;

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

A
Al Viro 已提交
645 646
static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
			   struct inode *parent)
M
Miklos Szeredi 已提交
647
{
A
Al Viro 已提交
648
	int len = parent ? 6 : 3;
M
Miklos Szeredi 已提交
649 650 651
	u64 nodeid;
	u32 generation;

652 653
	if (*max_len < len) {
		*max_len = len;
M
Miklos Szeredi 已提交
654
		return  255;
655
	}
M
Miklos Szeredi 已提交
656 657 658 659 660 661 662 663

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

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

A
Al Viro 已提交
664
	if (parent) {
M
Miklos Szeredi 已提交
665 666 667 668 669 670 671 672 673
		nodeid = get_fuse_inode(parent)->nodeid;
		generation = parent->i_generation;

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

	*max_len = len;
A
Al Viro 已提交
674
	return parent ? 0x82 : 0x81;
M
Miklos Szeredi 已提交
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
}

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);
}

705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
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);
722 723 724
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
725 726
		return ERR_PTR(err);
	}
727 728

	parent = d_obtain_alias(inode);
A
Al Viro 已提交
729
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
730 731 732 733
		fuse_invalidate_entry_cache(parent);

	return parent;
}
M
Miklos Szeredi 已提交
734 735 736 737 738

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,
739
	.get_parent	= fuse_get_parent,
M
Miklos Szeredi 已提交
740 741
};

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

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 798 799 800 801
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;
	}
}

802 803 804 805 806 807 808
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 {
809 810
		unsigned long ra_pages;

811 812
		process_init_limits(fc, arg);

813 814 815 816
		if (arg->minor >= 6) {
			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
817 818
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
M
Miklos Szeredi 已提交
819 820 821
			if (arg->minor >= 17) {
				if (!(arg->flags & FUSE_FLOCK_LOCKS))
					fc->no_flock = 1;
M
Miklos Szeredi 已提交
822 823 824
			} else {
				if (!(arg->flags & FUSE_POSIX_LOCKS))
					fc->no_flock = 1;
M
Miklos Szeredi 已提交
825
			}
826 827
			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
				fc->atomic_o_trunc = 1;
828 829 830 831 832
			if (arg->minor >= 9) {
				/* LOOKUP has dependency on proto version */
				if (arg->flags & FUSE_EXPORT_SUPPORT)
					fc->export_support = 1;
			}
833 834
			if (arg->flags & FUSE_BIG_WRITES)
				fc->big_writes = 1;
835 836
			if (arg->flags & FUSE_DONT_MASK)
				fc->dont_mask = 1;
837 838
			if (arg->flags & FUSE_AUTO_INVAL_DATA)
				fc->auto_inval_data = 1;
839
		} else {
840
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
841
			fc->no_lock = 1;
M
Miklos Szeredi 已提交
842
			fc->no_flock = 1;
843
		}
844 845

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
846 847
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
848
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
849
		fc->conn_init = 1;
850
	}
851 852
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
853 854
}

855
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
856 857
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
858

859 860
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
861
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
862
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
M
Miklos Szeredi 已提交
863
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
864
		FUSE_FLOCK_LOCKS | FUSE_AUTO_INVAL_DATA;
865 866 867 868 869
	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 已提交
870
	/* Variable length argument used for backward compatibility
871 872 873 874 875 876
	   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;
877
	fuse_request_send_background(fc, req);
878 879
}

T
Tejun Heo 已提交
880 881 882 883 884
static void fuse_free_conn(struct fuse_conn *fc)
{
	kfree(fc);
}

885 886 887 888
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

889
	fc->bdi.name = "fuse";
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
	/* 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 已提交
927 928 929 930 931 932
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;
933
	struct dentry *root_dentry;
934
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
935
	int err;
M
Miklos Szeredi 已提交
936
	int is_bdev = sb->s_bdev != NULL;
M
Miklos Szeredi 已提交
937

938
	err = -EINVAL;
939
	if (sb->s_flags & MS_MANDLOCK)
940
		goto err;
941

A
Al Viro 已提交
942 943
	sb->s_flags &= ~MS_NOSEC;

M
Miklos Szeredi 已提交
944
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
945
		goto err;
M
Miklos Szeredi 已提交
946

M
Miklos Szeredi 已提交
947
	if (is_bdev) {
948
#ifdef CONFIG_BLOCK
949
		err = -EINVAL;
M
Miklos Szeredi 已提交
950
		if (!sb_set_blocksize(sb, d.blksize))
951
			goto err;
952
#endif
M
Miklos Szeredi 已提交
953 954 955 956
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
M
Miklos Szeredi 已提交
957 958 959
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
960
	sb->s_time_gran = 1;
M
Miklos Szeredi 已提交
961
	sb->s_export_op = &fuse_export_operations;
M
Miklos Szeredi 已提交
962 963

	file = fget(d.fd);
964
	err = -EINVAL;
M
Miklos Szeredi 已提交
965
	if (!file)
966
		goto err;
M
Miklos Szeredi 已提交
967

968 969
	if (file->f_op != &fuse_dev_operations)
		goto err_fput;
M
Miklos Szeredi 已提交
970

971
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
972 973 974
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
M
Miklos Szeredi 已提交
975

976 977 978
	fuse_conn_init(fc);

	fc->dev = sb->s_dev;
J
John Muir 已提交
979
	fc->sb = sb;
980 981 982
	err = fuse_bdi_init(fc, sb);
	if (err)
		goto err_put_conn;
983

J
Jens Axboe 已提交
984 985
	sb->s_bdi = &fc->bdi;

986 987 988 989 990
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

T
Tejun Heo 已提交
991
	fc->release = fuse_free_conn;
M
Miklos Szeredi 已提交
992
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
993
	fc->user_id = d.user_id;
994
	fc->group_id = d.group_id;
995
	fc->max_read = max_t(unsigned, 4096, d.max_read);
M
Miklos Szeredi 已提交
996

997 998 999
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
1000
	err = -ENOMEM;
1001
	root = fuse_get_root_inode(sb, d.rootmode);
1002 1003
	root_dentry = d_make_root(root);
	if (!root_dentry)
1004
		goto err_put_conn;
A
Al Viro 已提交
1005 1006
	/* only now - we want root dentry with NULL ->d_op */
	sb->s_d_op = &fuse_dentry_operations;
1007

1008 1009 1010 1011
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

1012 1013 1014
	if (is_bdev) {
		fc->destroy_req = fuse_request_alloc();
		if (!fc->destroy_req)
J
Julia Lawall 已提交
1015
			goto err_free_init_req;
1016 1017
	}

1018
	mutex_lock(&fuse_mutex);
1019 1020
	err = -EINVAL;
	if (file->private_data)
1021
		goto err_unlock;
1022

1023 1024 1025 1026 1027
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
1028 1029
	sb->s_root = root_dentry;
	fc->connected = 1;
1030 1031
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
1032 1033 1034 1035 1036 1037
	/*
	 * 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);
1038

1039
	fuse_send_init(fc, init_req);
1040

M
Miklos Szeredi 已提交
1041 1042
	return 0;

1043 1044
 err_unlock:
	mutex_unlock(&fuse_mutex);
J
Julia Lawall 已提交
1045
 err_free_init_req:
1046
	fuse_request_free(init_req);
1047 1048
 err_put_root:
	dput(root_dentry);
1049
 err_put_conn:
1050
	fuse_bdi_destroy(fc);
1051
	fuse_conn_put(fc);
1052 1053 1054
 err_fput:
	fput(file);
 err:
M
Miklos Szeredi 已提交
1055 1056 1057
	return err;
}

A
Al Viro 已提交
1058
static struct dentry *fuse_mount(struct file_system_type *fs_type,
1059
		       int flags, const char *dev_name,
A
Al Viro 已提交
1060
		       void *raw_data)
M
Miklos Szeredi 已提交
1061
{
A
Al Viro 已提交
1062
	return mount_nodev(fs_type, flags, raw_data, fuse_fill_super);
M
Miklos Szeredi 已提交
1063 1064
}

J
John Muir 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
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);
}

1078 1079 1080
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
M
Miklos Szeredi 已提交
1081
	.fs_flags	= FS_HAS_SUBTYPE,
A
Al Viro 已提交
1082
	.mount		= fuse_mount,
J
John Muir 已提交
1083
	.kill_sb	= fuse_kill_sb_anon,
1084 1085 1086
};

#ifdef CONFIG_BLOCK
A
Al Viro 已提交
1087
static struct dentry *fuse_mount_blk(struct file_system_type *fs_type,
1088
			   int flags, const char *dev_name,
A
Al Viro 已提交
1089
			   void *raw_data)
1090
{
A
Al Viro 已提交
1091
	return mount_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super);
1092 1093
}

J
John Muir 已提交
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
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);
}

1107 1108 1109
static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
A
Al Viro 已提交
1110
	.mount		= fuse_mount_blk,
J
John Muir 已提交
1111
	.kill_sb	= fuse_kill_sb_blk,
A
Alexey Dobriyan 已提交
1112
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1113 1114
};

1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
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

1135
static void fuse_inode_init_once(void *foo)
M
Miklos Szeredi 已提交
1136
{
M
Miklos Szeredi 已提交
1137
	struct inode *inode = foo;
M
Miklos Szeredi 已提交
1138

C
Christoph Lameter 已提交
1139
	inode_init_once(inode);
M
Miklos Szeredi 已提交
1140 1141 1142 1143 1144 1145
}

static int __init fuse_fs_init(void)
{
	int err;

1146 1147 1148
	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
1149
					      fuse_inode_init_once);
1150 1151
	err = -ENOMEM;
	if (!fuse_inode_cachep)
1152 1153 1154 1155 1156 1157 1158 1159 1160
		goto out;

	err = register_fuseblk();
	if (err)
		goto out2;

	err = register_filesystem(&fuse_fs_type);
	if (err)
		goto out3;
1161 1162

	return 0;
M
Miklos Szeredi 已提交
1163

1164
 out3:
1165
	unregister_fuseblk();
1166 1167
 out2:
	kmem_cache_destroy(fuse_inode_cachep);
1168
 out:
M
Miklos Szeredi 已提交
1169 1170 1171 1172 1173 1174
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
1175
	unregister_fuseblk();
M
Miklos Szeredi 已提交
1176 1177 1178
	kmem_cache_destroy(fuse_inode_cachep);
}

1179 1180 1181
static struct kobject *fuse_kobj;
static struct kobject *connections_kobj;

1182 1183 1184 1185
static int fuse_sysfs_init(void)
{
	int err;

1186
	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1187 1188
	if (!fuse_kobj) {
		err = -ENOMEM;
1189
		goto out_err;
1190
	}
1191

1192 1193 1194
	connections_kobj = kobject_create_and_add("connections", fuse_kobj);
	if (!connections_kobj) {
		err = -ENOMEM;
1195
		goto out_fuse_unregister;
1196
	}
1197 1198 1199 1200

	return 0;

 out_fuse_unregister:
1201
	kobject_put(fuse_kobj);
1202 1203 1204 1205 1206 1207
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
1208 1209
	kobject_put(connections_kobj);
	kobject_put(fuse_kobj);
1210 1211
}

M
Miklos Szeredi 已提交
1212 1213 1214 1215
static int __init fuse_init(void)
{
	int res;

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

1219
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
1220 1221 1222 1223
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
1224 1225 1226 1227
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

1228 1229 1230 1231
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

1232 1233 1234 1235
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

1236 1237 1238
	sanitize_global_limit(&max_user_bgreq);
	sanitize_global_limit(&max_user_congthresh);

M
Miklos Szeredi 已提交
1239 1240
	return 0;

1241 1242
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
1243 1244
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1245 1246
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1247 1248 1249 1250 1251 1252 1253 1254
 err:
	return res;
}

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

1255
	fuse_ctl_cleanup();
1256
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
1257
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1258
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1259 1260 1261 1262
}

module_init(fuse_init);
module_exit(fuse_exit);