inode.c 28.3 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
	INIT_LIST_HEAD(&fi->write_files);
M
Miklos Szeredi 已提交
95 96 97
	INIT_LIST_HEAD(&fi->queued_writes);
	INIT_LIST_HEAD(&fi->writepages);
	init_waitqueue_head(&fi->page_waitq);
98 99
	fi->forget = fuse_alloc_forget();
	if (!fi->forget) {
100 101 102
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
M
Miklos Szeredi 已提交
103 104 105 106

	return inode;
}

N
Nick Piggin 已提交
107 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);
	INIT_LIST_HEAD(&inode->i_dentry);
	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 126
	truncate_inode_pages(&inode->i_data, 0);
	end_writeback(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;
}

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

149 150 151
	fi->attr_version = ++fc->attr_version;
	fi->i_time = attr_valid;

M
Miklos Szeredi 已提交
152
	inode->i_ino     = attr->ino;
153
	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
M
Miklos Szeredi 已提交
154 155 156 157 158 159 160 161 162 163
	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;
164

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

170 171 172 173 174 175 176 177
	/*
	 * 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 已提交
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
}

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

195 196 197 198 199
	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 已提交
200
		truncate_pagecache(inode, oldsize, attr->size);
M
Miklos Szeredi 已提交
201
		invalidate_inode_pages2(inode->i_mapping);
202
	}
M
Miklos Szeredi 已提交
203 204 205 206 207
}

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

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

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

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

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

M
Miklos Szeredi 已提交
273 274 275
	return inode;
}

J
John Muir 已提交
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
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;
}

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

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

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

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

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);
349
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
350 351
}

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

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

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

379 380 381
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
382

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

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

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

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

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

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

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

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

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

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

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

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

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

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

519
void fuse_conn_init(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
520
{
521 522 523
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
	mutex_init(&fc->inst_mutex);
J
John Muir 已提交
524
	init_rwsem(&fc->killsb);
525 526 527 528 529 530 531 532 533 534
	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);
535
	fc->forget_list_tail = &fc->forget_list_head;
536
	atomic_set(&fc->num_waiting, 0);
537 538
	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
539 540 541 542 543 544
	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 已提交
545
}
546
EXPORT_SYMBOL_GPL(fuse_conn_init);
M
Miklos Szeredi 已提交
547

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

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

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

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

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

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
585
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
586 587 588 589 590 591 592 593
	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);
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
	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 已提交
615 616 617 618
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

619
	entry = d_obtain_alias(inode);
A
Al Viro 已提交
620
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
M
Miklos Szeredi 已提交
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
		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;

640 641
	if (*max_len < len) {
		*max_len = len;
M
Miklos Szeredi 已提交
642
		return  255;
643
	}
M
Miklos Szeredi 已提交
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

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

698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
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);
715 716 717
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
718 719
		return ERR_PTR(err);
	}
720 721

	parent = d_obtain_alias(inode);
A
Al Viro 已提交
722
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
723 724 725 726
		fuse_invalidate_entry_cache(parent);

	return parent;
}
M
Miklos Szeredi 已提交
727 728 729 730 731

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,
732
	.get_parent	= fuse_get_parent,
M
Miklos Szeredi 已提交
733 734
};

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

747 748 749 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
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;
	}
}

795 796 797 798 799 800 801
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 {
802 803
		unsigned long ra_pages;

804 805
		process_init_limits(fc, arg);

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

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
837 838
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
839
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
840
		fc->conn_init = 1;
841
	}
842 843
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
844 845
}

846
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
847 848
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
849

850 851
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
852
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
853
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
M
Miklos Szeredi 已提交
854 855
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
		FUSE_FLOCK_LOCKS;
856 857 858 859 860
	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 已提交
861
	/* Variable length argument used for backward compatibility
862 863 864 865 866 867
	   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;
868
	fuse_request_send_background(fc, req);
869 870
}

T
Tejun Heo 已提交
871 872 873 874 875
static void fuse_free_conn(struct fuse_conn *fc)
{
	kfree(fc);
}

876 877 878 879
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

880
	fc->bdi.name = "fuse";
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 913 914 915 916 917
	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 已提交
918 919 920 921 922 923
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;
924
	struct dentry *root_dentry;
925
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
926
	int err;
M
Miklos Szeredi 已提交
927
	int is_bdev = sb->s_bdev != NULL;
M
Miklos Szeredi 已提交
928

929
	err = -EINVAL;
930
	if (sb->s_flags & MS_MANDLOCK)
931
		goto err;
932

A
Al Viro 已提交
933 934
	sb->s_flags &= ~MS_NOSEC;

M
Miklos Szeredi 已提交
935
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
936
		goto err;
M
Miklos Szeredi 已提交
937

M
Miklos Szeredi 已提交
938
	if (is_bdev) {
939
#ifdef CONFIG_BLOCK
940
		err = -EINVAL;
M
Miklos Szeredi 已提交
941
		if (!sb_set_blocksize(sb, d.blksize))
942
			goto err;
943
#endif
M
Miklos Szeredi 已提交
944 945 946 947
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
M
Miklos Szeredi 已提交
948 949 950
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
M
Miklos Szeredi 已提交
951
	sb->s_export_op = &fuse_export_operations;
M
Miklos Szeredi 已提交
952 953

	file = fget(d.fd);
954
	err = -EINVAL;
M
Miklos Szeredi 已提交
955
	if (!file)
956
		goto err;
M
Miklos Szeredi 已提交
957

958 959
	if (file->f_op != &fuse_dev_operations)
		goto err_fput;
M
Miklos Szeredi 已提交
960

961
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
962 963 964
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
M
Miklos Szeredi 已提交
965

966 967 968
	fuse_conn_init(fc);

	fc->dev = sb->s_dev;
J
John Muir 已提交
969
	fc->sb = sb;
970 971 972
	err = fuse_bdi_init(fc, sb);
	if (err)
		goto err_put_conn;
973

J
Jens Axboe 已提交
974 975
	sb->s_bdi = &fc->bdi;

976 977 978 979 980
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

T
Tejun Heo 已提交
981
	fc->release = fuse_free_conn;
M
Miklos Szeredi 已提交
982
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
983
	fc->user_id = d.user_id;
984
	fc->group_id = d.group_id;
985
	fc->max_read = max_t(unsigned, 4096, d.max_read);
M
Miklos Szeredi 已提交
986

987 988 989
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
990
	err = -ENOMEM;
991
	root = fuse_get_root_inode(sb, d.rootmode);
992
	if (!root)
993
		goto err_put_conn;
M
Miklos Szeredi 已提交
994

995 996
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
M
Miklos Szeredi 已提交
997
		iput(root);
998
		goto err_put_conn;
M
Miklos Szeredi 已提交
999
	}
A
Al Viro 已提交
1000 1001
	/* only now - we want root dentry with NULL ->d_op */
	sb->s_d_op = &fuse_dentry_operations;
1002

1003 1004 1005 1006
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

1007 1008 1009
	if (is_bdev) {
		fc->destroy_req = fuse_request_alloc();
		if (!fc->destroy_req)
J
Julia Lawall 已提交
1010
			goto err_free_init_req;
1011 1012
	}

1013
	mutex_lock(&fuse_mutex);
1014 1015
	err = -EINVAL;
	if (file->private_data)
1016
		goto err_unlock;
1017

1018 1019 1020 1021 1022
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

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

1034
	fuse_send_init(fc, init_req);
1035

M
Miklos Szeredi 已提交
1036 1037
	return 0;

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

A
Al Viro 已提交
1053
static struct dentry *fuse_mount(struct file_system_type *fs_type,
1054
		       int flags, const char *dev_name,
A
Al Viro 已提交
1055
		       void *raw_data)
M
Miklos Szeredi 已提交
1056
{
A
Al Viro 已提交
1057
	return mount_nodev(fs_type, flags, raw_data, fuse_fill_super);
M
Miklos Szeredi 已提交
1058 1059
}

J
John Muir 已提交
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
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);
}

1073 1074 1075
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
M
Miklos Szeredi 已提交
1076
	.fs_flags	= FS_HAS_SUBTYPE,
A
Al Viro 已提交
1077
	.mount		= fuse_mount,
J
John Muir 已提交
1078
	.kill_sb	= fuse_kill_sb_anon,
1079 1080 1081
};

#ifdef CONFIG_BLOCK
A
Al Viro 已提交
1082
static struct dentry *fuse_mount_blk(struct file_system_type *fs_type,
1083
			   int flags, const char *dev_name,
A
Al Viro 已提交
1084
			   void *raw_data)
1085
{
A
Al Viro 已提交
1086
	return mount_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super);
1087 1088
}

J
John Muir 已提交
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
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);
}

1102 1103 1104
static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
A
Al Viro 已提交
1105
	.mount		= fuse_mount_blk,
J
John Muir 已提交
1106
	.kill_sb	= fuse_kill_sb_blk,
A
Alexey Dobriyan 已提交
1107
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1108 1109
};

1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
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

1130
static void fuse_inode_init_once(void *foo)
M
Miklos Szeredi 已提交
1131
{
M
Miklos Szeredi 已提交
1132
	struct inode *inode = foo;
M
Miklos Szeredi 已提交
1133

C
Christoph Lameter 已提交
1134
	inode_init_once(inode);
M
Miklos Szeredi 已提交
1135 1136 1137 1138 1139 1140 1141 1142
}

static int __init fuse_fs_init(void)
{
	int err;

	err = register_filesystem(&fuse_fs_type);
	if (err)
1143 1144
		goto out;

1145
	err = register_fuseblk();
1146 1147 1148 1149 1150 1151
	if (err)
		goto out_unreg;

	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
1152
					      fuse_inode_init_once);
1153 1154 1155 1156 1157
	err = -ENOMEM;
	if (!fuse_inode_cachep)
		goto out_unreg2;

	return 0;
M
Miklos Szeredi 已提交
1158

1159
 out_unreg2:
1160
	unregister_fuseblk();
1161 1162 1163
 out_unreg:
	unregister_filesystem(&fuse_fs_type);
 out:
M
Miklos Szeredi 已提交
1164 1165 1166 1167 1168 1169
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
1170
	unregister_fuseblk();
M
Miklos Szeredi 已提交
1171 1172 1173
	kmem_cache_destroy(fuse_inode_cachep);
}

1174 1175 1176
static struct kobject *fuse_kobj;
static struct kobject *connections_kobj;

1177 1178 1179 1180
static int fuse_sysfs_init(void)
{
	int err;

1181
	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1182 1183
	if (!fuse_kobj) {
		err = -ENOMEM;
1184
		goto out_err;
1185
	}
1186

1187 1188 1189
	connections_kobj = kobject_create_and_add("connections", fuse_kobj);
	if (!connections_kobj) {
		err = -ENOMEM;
1190
		goto out_fuse_unregister;
1191
	}
1192 1193 1194 1195

	return 0;

 out_fuse_unregister:
1196
	kobject_put(fuse_kobj);
1197 1198 1199 1200 1201 1202
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
1203 1204
	kobject_put(connections_kobj);
	kobject_put(fuse_kobj);
1205 1206
}

M
Miklos Szeredi 已提交
1207 1208 1209 1210
static int __init fuse_init(void)
{
	int res;

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

1214
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
1215 1216 1217 1218
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
1219 1220 1221 1222
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

1223 1224 1225 1226
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

1227 1228 1229 1230
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

1231 1232 1233
	sanitize_global_limit(&max_user_bgreq);
	sanitize_global_limit(&max_user_congthresh);

M
Miklos Szeredi 已提交
1234 1235
	return 0;

1236 1237
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
1238 1239
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1240 1241
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1242 1243 1244 1245 1246 1247 1248 1249
 err:
	return res;
}

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

1250
	fuse_ctl_cleanup();
1251
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
1252
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1253
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1254 1255 1256 1257
}

module_init(fuse_init);
module_exit(fuse_exit);