inode.c 30.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
struct fuse_mount_data {
	int fd;
	unsigned rootmode;
63 64
	kuid_t user_id;
	kgid_t 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
	fi->state = 0;
96
	INIT_LIST_HEAD(&fi->write_files);
M
Miklos Szeredi 已提交
97 98 99
	INIT_LIST_HEAD(&fi->queued_writes);
	INIT_LIST_HEAD(&fi->writepages);
	init_waitqueue_head(&fi->page_waitq);
100 101
	fi->forget = fuse_alloc_forget();
	if (!fi->forget) {
102 103 104
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
M
Miklos Szeredi 已提交
105 106 107 108

	return inode;
}

N
Nick Piggin 已提交
109 110 111 112 113 114
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 已提交
115 116
static void fuse_destroy_inode(struct inode *inode)
{
117
	struct fuse_inode *fi = get_fuse_inode(inode);
118
	BUG_ON(!list_empty(&fi->write_files));
M
Miklos Szeredi 已提交
119
	BUG_ON(!list_empty(&fi->queued_writes));
120
	kfree(fi->forget);
N
Nick Piggin 已提交
121
	call_rcu(&inode->i_rcu, fuse_i_callback);
M
Miklos Szeredi 已提交
122 123
}

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

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

	return 0;
}

144 145 146 147 148 149 150 151 152 153 154 155
/*
 * 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 已提交
156 157
void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
				   u64 attr_valid)
M
Miklos Szeredi 已提交
158
{
M
Miklos Szeredi 已提交
159
	struct fuse_conn *fc = get_fuse_conn(inode);
160
	struct fuse_inode *fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
161

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

165
	inode->i_ino     = fuse_squash_ino(attr->ino);
166
	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
M
Miklos Szeredi 已提交
167
	set_nlink(inode, attr->nlink);
168 169
	inode->i_uid     = make_kuid(&init_user_ns, attr->uid);
	inode->i_gid     = make_kgid(&init_user_ns, attr->gid);
M
Miklos Szeredi 已提交
170 171 172
	inode->i_blocks  = attr->blocks;
	inode->i_atime.tv_sec   = attr->atime;
	inode->i_atime.tv_nsec  = attr->atimensec;
M
Maxim Patlasov 已提交
173 174 175 176 177
	/* mtime from server may be stale due to local buffered write */
	if (!fc->writeback_cache || !S_ISREG(inode->i_mode)) {
		inode->i_mtime.tv_sec   = attr->mtime;
		inode->i_mtime.tv_nsec  = attr->mtimensec;
	}
M
Miklos Szeredi 已提交
178 179
	inode->i_ctime.tv_sec   = attr->ctime;
	inode->i_ctime.tv_nsec  = attr->ctimensec;
180

181 182 183 184 185
	if (attr->blksize != 0)
		inode->i_blkbits = ilog2(attr->blksize);
	else
		inode->i_blkbits = inode->i_sb->s_blocksize_bits;

186 187 188 189 190 191 192 193
	/*
	 * 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;
194 195

	fi->orig_ino = attr->ino;
M
Miklos Szeredi 已提交
196 197 198 199 200 201 202
}

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);
P
Pavel Emelyanov 已提交
203
	bool is_wb = fc->writeback_cache;
M
Miklos Szeredi 已提交
204
	loff_t oldsize;
205
	struct timespec old_mtime;
M
Miklos Szeredi 已提交
206 207

	spin_lock(&fc->lock);
208 209
	if ((attr_version != 0 && fi->attr_version > attr_version) ||
	    test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) {
M
Miklos Szeredi 已提交
210 211 212 213
		spin_unlock(&fc->lock);
		return;
	}

214
	old_mtime = inode->i_mtime;
M
Miklos Szeredi 已提交
215
	fuse_change_attributes_common(inode, attr, attr_valid);
216

217
	oldsize = inode->i_size;
P
Pavel Emelyanov 已提交
218 219 220 221 222 223 224
	/*
	 * In case of writeback_cache enabled, the cached writes beyond EOF
	 * extend local i_size without keeping userspace server in sync. So,
	 * attr->size coming from server can be stale. We cannot trust it.
	 */
	if (!is_wb || !S_ISREG(inode->i_mode))
		i_size_write(inode, attr->size);
225 226
	spin_unlock(&fc->lock);

P
Pavel Emelyanov 已提交
227
	if (!is_wb && S_ISREG(inode->i_mode)) {
228 229 230
		bool inval = false;

		if (oldsize != attr->size) {
231
			truncate_pagecache(inode, attr->size);
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
			inval = true;
		} else if (fc->auto_inval_data) {
			struct timespec new_mtime = {
				.tv_sec = attr->mtime,
				.tv_nsec = attr->mtimensec,
			};

			/*
			 * Auto inval mode also checks and invalidates if mtime
			 * has changed.
			 */
			if (!timespec_equal(&old_mtime, &new_mtime))
				inval = true;
		}

		if (inval)
			invalidate_inode_pages2(inode->i_mapping);
249
	}
M
Miklos Szeredi 已提交
250 251 252 253 254
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
M
Miklos Szeredi 已提交
255
	inode->i_size = attr->size;
M
Maxim Patlasov 已提交
256 257
	inode->i_mtime.tv_sec  = attr->mtime;
	inode->i_mtime.tv_nsec = attr->mtimensec;
258 259
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
M
Miklos Szeredi 已提交
260
		fuse_init_file_inode(inode);
261 262 263 264 265 266 267 268 269
	} 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));
270 271
	} else
		BUG();
M
Miklos Szeredi 已提交
272 273
}

J
John Muir 已提交
274
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
M
Miklos Szeredi 已提交
275
{
M
Miklos Szeredi 已提交
276
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
277 278 279 280 281 282 283 284
	if (get_node_id(inode) == nodeid)
		return 1;
	else
		return 0;
}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
M
Miklos Szeredi 已提交
285
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
286 287 288 289
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

M
Miklos Szeredi 已提交
290
struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
291 292
			int generation, struct fuse_attr *attr,
			u64 attr_valid, u64 attr_version)
M
Miklos Szeredi 已提交
293 294
{
	struct inode *inode;
295
	struct fuse_inode *fi;
M
Miklos Szeredi 已提交
296 297 298 299 300 301 302 303
	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)) {
M
Maxim Patlasov 已提交
304 305 306
		inode->i_flags |= S_NOATIME;
		if (!fc->writeback_cache || !S_ISREG(inode->i_mode))
			inode->i_flags |= S_NOCMTIME;
M
Miklos Szeredi 已提交
307 308 309 310 311 312 313 314 315 316 317
		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;
	}

318
	fi = get_fuse_inode(inode);
319
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
320
	fi->nlookup++;
321
	spin_unlock(&fc->lock);
322 323
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

M
Miklos Szeredi 已提交
324 325 326
	return inode;
}

J
John Muir 已提交
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
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;
}

352
static void fuse_umount_begin(struct super_block *sb)
353
{
354
	fuse_abort_conn(get_fuse_conn_super(sb));
355 356
}

357 358 359 360 361 362 363
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;
364
		req->background = 0;
365
		fuse_request_send(fc, req);
366 367 368 369
		fuse_put_request(fc, req);
	}
}

370
static void fuse_bdi_destroy(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
371
{
372 373 374
	if (fc->bdi_initialized)
		bdi_destroy(&fc->bdi);
}
M
Miklos Szeredi 已提交
375

376
void fuse_conn_kill(struct fuse_conn *fc)
377
{
378
	spin_lock(&fc->lock);
379
	fc->connected = 0;
380
	fc->blocked = 0;
M
Maxim Patlasov 已提交
381
	fc->initialized = 1;
382
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
383
	/* Flush all readers on this fs */
384
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
M
Miklos Szeredi 已提交
385
	wake_up_all(&fc->waitq);
386
	wake_up_all(&fc->blocked_waitq);
387
	wake_up_all(&fc->reserved_req_waitq);
388
}
389
EXPORT_SYMBOL_GPL(fuse_conn_kill);
390 391 392 393 394 395

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

	fuse_send_destroy(fc);
M
Miklos Szeredi 已提交
396

397
	fuse_conn_kill(fc);
M
Miklos Szeredi 已提交
398 399 400 401 402 403
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
	fuse_bdi_destroy(fc);

404
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
405 406
}

407 408 409 410
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
411
	stbuf->f_frsize  = attr->frsize;
412 413 414 415 416 417 418 419 420
	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 */
}

421
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
422
{
423
	struct super_block *sb = dentry->d_sb;
424 425 426 427 428
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

429
	if (!fuse_allow_current_process(fc)) {
M
Miklos Szeredi 已提交
430 431 432 433
		buf->f_type = FUSE_SUPER_MAGIC;
		return 0;
	}

M
Maxim Patlasov 已提交
434
	req = fuse_get_req_nopages(fc);
435 436
	if (IS_ERR(req))
		return PTR_ERR(req);
437

438
	memset(&outarg, 0, sizeof(outarg));
439 440
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
441
	req->in.h.nodeid = get_node_id(dentry->d_inode);
442
	req->out.numargs = 1;
443 444
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
445
	req->out.args[0].value = &outarg;
446
	fuse_request_send(fc, req);
447 448 449 450 451 452 453
	err = req->out.h.error;
	if (!err)
		convert_fuse_statfs(buf, &outarg.st);
	fuse_put_request(fc, req);
	return err;
}

M
Miklos Szeredi 已提交
454 455 456 457
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
458
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
459 460
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
461
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
462
	OPT_BLKSIZE,
M
Miklos Szeredi 已提交
463 464 465
	OPT_ERR
};

466
static const match_table_t tokens = {
M
Miklos Szeredi 已提交
467 468 469
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
470
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
471 472
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
473
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
474
	{OPT_BLKSIZE,			"blksize=%u"},
M
Miklos Szeredi 已提交
475 476 477
	{OPT_ERR,			NULL}
};

M
Miklos Szeredi 已提交
478
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
M
Miklos Szeredi 已提交
479 480 481
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
482
	d->max_read = ~0;
M
Miklos Szeredi 已提交
483
	d->blksize = FUSE_DEFAULT_BLKSIZE;
M
Miklos Szeredi 已提交
484 485 486 487 488 489 490 491 492 493 494 495 496 497

	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;
498
			d->fd_present = 1;
M
Miklos Szeredi 已提交
499 500 501 502 503
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
504 505
			if (!fuse_valid_type(value))
				return 0;
M
Miklos Szeredi 已提交
506
			d->rootmode = value;
507
			d->rootmode_present = 1;
M
Miklos Szeredi 已提交
508 509 510 511 512
			break;

		case OPT_USER_ID:
			if (match_int(&args[0], &value))
				return 0;
513 514 515
			d->user_id = make_kuid(current_user_ns(), value);
			if (!uid_valid(d->user_id))
				return 0;
516
			d->user_id_present = 1;
M
Miklos Szeredi 已提交
517 518
			break;

519 520 521
		case OPT_GROUP_ID:
			if (match_int(&args[0], &value))
				return 0;
522 523 524
			d->group_id = make_kgid(current_user_ns(), value);
			if (!gid_valid(d->group_id))
				return 0;
525
			d->group_id_present = 1;
526 527
			break;

M
Miklos Szeredi 已提交
528 529 530 531 532 533 534 535
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

536 537 538 539 540 541
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

M
Miklos Szeredi 已提交
542 543 544 545 546 547
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

M
Miklos Szeredi 已提交
548 549 550 551
		default:
			return 0;
		}
	}
552 553 554

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
555 556 557 558 559
		return 0;

	return 1;
}

560
static int fuse_show_options(struct seq_file *m, struct dentry *root)
M
Miklos Szeredi 已提交
561
{
562 563
	struct super_block *sb = root->d_sb;
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
564

565 566
	seq_printf(m, ",user_id=%u", from_kuid_munged(&init_user_ns, fc->user_id));
	seq_printf(m, ",group_id=%u", from_kgid_munged(&init_user_ns, fc->group_id));
M
Miklos Szeredi 已提交
567 568 569 570
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
571 572
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
573 574
	if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
		seq_printf(m, ",blksize=%lu", sb->s_blocksize);
M
Miklos Szeredi 已提交
575 576 577
	return 0;
}

578
void fuse_conn_init(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
579
{
580 581
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
J
John Muir 已提交
582
	init_rwsem(&fc->killsb);
583 584 585 586 587 588 589 590 591 592
	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);
593
	fc->forget_list_tail = &fc->forget_list_head;
594
	atomic_set(&fc->num_waiting, 0);
595 596
	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
597 598 599
	fc->khctr = 0;
	fc->polled_files = RB_ROOT;
	fc->reqctr = 0;
600
	fc->blocked = 0;
M
Maxim Patlasov 已提交
601
	fc->initialized = 0;
602 603
	fc->attr_version = 1;
	get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
M
Miklos Szeredi 已提交
604
}
605
EXPORT_SYMBOL_GPL(fuse_conn_init);
M
Miklos Szeredi 已提交
606

607 608
void fuse_conn_put(struct fuse_conn *fc)
{
609
	if (atomic_dec_and_test(&fc->count)) {
610 611
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
T
Tejun Heo 已提交
612
		fc->release(fc);
613
	}
614
}
615
EXPORT_SYMBOL_GPL(fuse_conn_put);
616 617 618 619 620 621

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

624
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
M
Miklos Szeredi 已提交
625 626 627 628 629 630
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
631
	attr.nlink = 1;
632
	return fuse_iget(sb, 1, 0, &attr, 0, 0);
M
Miklos Szeredi 已提交
633 634
}

M
Miklos Szeredi 已提交
635
struct fuse_inode_handle {
M
Miklos Szeredi 已提交
636 637 638 639 640 641 642
	u64 nodeid;
	u32 generation;
};

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
643
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
644 645 646 647 648 649 650 651
	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);
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
	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 已提交
673 674 675 676
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

677
	entry = d_obtain_alias(inode);
A
Al Viro 已提交
678
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
M
Miklos Szeredi 已提交
679 680 681 682 683 684 685 686 687 688
		fuse_invalidate_entry_cache(entry);

	return entry;

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

A
Al Viro 已提交
689 690
static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
			   struct inode *parent)
M
Miklos Szeredi 已提交
691
{
A
Al Viro 已提交
692
	int len = parent ? 6 : 3;
M
Miklos Szeredi 已提交
693 694 695
	u64 nodeid;
	u32 generation;

696 697
	if (*max_len < len) {
		*max_len = len;
698
		return  FILEID_INVALID;
699
	}
M
Miklos Szeredi 已提交
700 701 702 703 704 705 706 707

	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 已提交
708
	if (parent) {
M
Miklos Szeredi 已提交
709 710 711 712 713 714 715 716 717
		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 已提交
718
	return parent ? 0x82 : 0x81;
M
Miklos Szeredi 已提交
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
}

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

749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
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);
766 767 768
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
769 770
		return ERR_PTR(err);
	}
771 772

	parent = d_obtain_alias(inode);
A
Al Viro 已提交
773
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
774 775 776 777
		fuse_invalidate_entry_cache(parent);

	return parent;
}
M
Miklos Szeredi 已提交
778 779 780 781 782

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,
783
	.get_parent	= fuse_get_parent,
M
Miklos Szeredi 已提交
784 785
};

786
static const struct super_operations fuse_super_operations = {
M
Miklos Szeredi 已提交
787 788
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
789
	.evict_inode	= fuse_evict_inode,
M
Miklos Szeredi 已提交
790
	.drop_inode	= generic_delete_inode,
791
	.remount_fs	= fuse_remount_fs,
M
Miklos Szeredi 已提交
792
	.put_super	= fuse_put_super,
793
	.umount_begin	= fuse_umount_begin,
794
	.statfs		= fuse_statfs,
M
Miklos Szeredi 已提交
795 796 797
	.show_options	= fuse_show_options,
};

798 799 800
static void sanitize_global_limit(unsigned *limit)
{
	if (*limit == 0)
801
		*limit = ((totalram_pages << PAGE_SHIFT) >> 13) /
802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
			 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;
	}
}

846 847 848 849 850 851 852
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 {
853 854
		unsigned long ra_pages;

855 856
		process_init_limits(fc, arg);

857 858 859 860
		if (arg->minor >= 6) {
			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
861 862
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
M
Miklos Szeredi 已提交
863 864 865
			if (arg->minor >= 17) {
				if (!(arg->flags & FUSE_FLOCK_LOCKS))
					fc->no_flock = 1;
M
Miklos Szeredi 已提交
866 867 868
			} else {
				if (!(arg->flags & FUSE_POSIX_LOCKS))
					fc->no_flock = 1;
M
Miklos Szeredi 已提交
869
			}
870 871
			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
				fc->atomic_o_trunc = 1;
872 873 874 875 876
			if (arg->minor >= 9) {
				/* LOOKUP has dependency on proto version */
				if (arg->flags & FUSE_EXPORT_SUPPORT)
					fc->export_support = 1;
			}
877 878
			if (arg->flags & FUSE_BIG_WRITES)
				fc->big_writes = 1;
879 880
			if (arg->flags & FUSE_DONT_MASK)
				fc->dont_mask = 1;
881 882
			if (arg->flags & FUSE_AUTO_INVAL_DATA)
				fc->auto_inval_data = 1;
883
			if (arg->flags & FUSE_DO_READDIRPLUS) {
884
				fc->do_readdirplus = 1;
885 886 887
				if (arg->flags & FUSE_READDIRPLUS_AUTO)
					fc->readdirplus_auto = 1;
			}
888 889
			if (arg->flags & FUSE_ASYNC_DIO)
				fc->async_dio = 1;
890
		} else {
891
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
892
			fc->no_lock = 1;
M
Miklos Szeredi 已提交
893
			fc->no_flock = 1;
894
		}
895 896

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
897 898
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
899
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
900
		fc->conn_init = 1;
901
	}
M
Maxim Patlasov 已提交
902
	fc->initialized = 1;
903
	wake_up_all(&fc->blocked_waitq);
904 905
}

906
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
907 908
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
909

910 911
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
912
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
913
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
M
Miklos Szeredi 已提交
914
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
M
Miklos Szeredi 已提交
915
		FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
916
		FUSE_FLOCK_LOCKS | FUSE_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
917
		FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO;
918 919 920 921 922
	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 已提交
923
	/* Variable length argument used for backward compatibility
924 925 926 927 928 929
	   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;
930
	fuse_request_send_background(fc, req);
931 932
}

T
Tejun Heo 已提交
933 934
static void fuse_free_conn(struct fuse_conn *fc)
{
A
Al Viro 已提交
935
	kfree_rcu(fc, rcu);
T
Tejun Heo 已提交
936 937
}

938 939 940 941
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

942
	fc->bdi.name = "fuse";
943 944
	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
	/* fuse does it's own writeback accounting */
945
	fc->bdi.capabilities = BDI_CAP_NO_ACCT_WB | BDI_CAP_STRICTLIMIT;
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979

	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 已提交
980 981 982 983 984 985
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;
986
	struct dentry *root_dentry;
987
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
988
	int err;
M
Miklos Szeredi 已提交
989
	int is_bdev = sb->s_bdev != NULL;
M
Miklos Szeredi 已提交
990

991
	err = -EINVAL;
992
	if (sb->s_flags & MS_MANDLOCK)
993
		goto err;
994

A
Al Viro 已提交
995 996
	sb->s_flags &= ~MS_NOSEC;

M
Miklos Szeredi 已提交
997
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
998
		goto err;
M
Miklos Szeredi 已提交
999

M
Miklos Szeredi 已提交
1000
	if (is_bdev) {
1001
#ifdef CONFIG_BLOCK
1002
		err = -EINVAL;
M
Miklos Szeredi 已提交
1003
		if (!sb_set_blocksize(sb, d.blksize))
1004
			goto err;
1005
#endif
M
Miklos Szeredi 已提交
1006 1007 1008 1009
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
M
Miklos Szeredi 已提交
1010 1011 1012
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
1013
	sb->s_time_gran = 1;
M
Miklos Szeredi 已提交
1014
	sb->s_export_op = &fuse_export_operations;
M
Miklos Szeredi 已提交
1015 1016

	file = fget(d.fd);
1017
	err = -EINVAL;
M
Miklos Szeredi 已提交
1018
	if (!file)
1019
		goto err;
M
Miklos Szeredi 已提交
1020

1021 1022
	if ((file->f_op != &fuse_dev_operations) ||
	    (file->f_cred->user_ns != &init_user_ns))
1023
		goto err_fput;
M
Miklos Szeredi 已提交
1024

1025
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
1026 1027 1028
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
M
Miklos Szeredi 已提交
1029

1030 1031 1032
	fuse_conn_init(fc);

	fc->dev = sb->s_dev;
J
John Muir 已提交
1033
	fc->sb = sb;
1034 1035 1036
	err = fuse_bdi_init(fc, sb);
	if (err)
		goto err_put_conn;
1037

J
Jens Axboe 已提交
1038 1039
	sb->s_bdi = &fc->bdi;

1040 1041 1042 1043 1044
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

T
Tejun Heo 已提交
1045
	fc->release = fuse_free_conn;
M
Miklos Szeredi 已提交
1046
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
1047
	fc->user_id = d.user_id;
1048
	fc->group_id = d.group_id;
1049
	fc->max_read = max_t(unsigned, 4096, d.max_read);
M
Miklos Szeredi 已提交
1050

1051 1052 1053
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
1054
	err = -ENOMEM;
1055
	root = fuse_get_root_inode(sb, d.rootmode);
1056 1057
	root_dentry = d_make_root(root);
	if (!root_dentry)
1058
		goto err_put_conn;
A
Al Viro 已提交
1059 1060
	/* only now - we want root dentry with NULL ->d_op */
	sb->s_d_op = &fuse_dentry_operations;
1061

1062
	init_req = fuse_request_alloc(0);
1063 1064
	if (!init_req)
		goto err_put_root;
1065
	init_req->background = 1;
1066

1067
	if (is_bdev) {
1068
		fc->destroy_req = fuse_request_alloc(0);
1069
		if (!fc->destroy_req)
J
Julia Lawall 已提交
1070
			goto err_free_init_req;
1071 1072
	}

1073
	mutex_lock(&fuse_mutex);
1074 1075
	err = -EINVAL;
	if (file->private_data)
1076
		goto err_unlock;
1077

1078 1079 1080 1081 1082
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
1083 1084
	sb->s_root = root_dentry;
	fc->connected = 1;
1085 1086
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
1087 1088 1089 1090 1091 1092
	/*
	 * 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);
1093

1094
	fuse_send_init(fc, init_req);
1095

M
Miklos Szeredi 已提交
1096 1097
	return 0;

1098 1099
 err_unlock:
	mutex_unlock(&fuse_mutex);
J
Julia Lawall 已提交
1100
 err_free_init_req:
1101
	fuse_request_free(init_req);
1102 1103
 err_put_root:
	dput(root_dentry);
1104
 err_put_conn:
1105
	fuse_bdi_destroy(fc);
1106
	fuse_conn_put(fc);
1107 1108 1109
 err_fput:
	fput(file);
 err:
M
Miklos Szeredi 已提交
1110 1111 1112
	return err;
}

A
Al Viro 已提交
1113
static struct dentry *fuse_mount(struct file_system_type *fs_type,
1114
		       int flags, const char *dev_name,
A
Al Viro 已提交
1115
		       void *raw_data)
M
Miklos Szeredi 已提交
1116
{
A
Al Viro 已提交
1117
	return mount_nodev(fs_type, flags, raw_data, fuse_fill_super);
M
Miklos Szeredi 已提交
1118 1119
}

J
John Muir 已提交
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
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);
}

1133 1134 1135
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
M
Miklos Szeredi 已提交
1136
	.fs_flags	= FS_HAS_SUBTYPE,
A
Al Viro 已提交
1137
	.mount		= fuse_mount,
J
John Muir 已提交
1138
	.kill_sb	= fuse_kill_sb_anon,
1139
};
1140
MODULE_ALIAS_FS("fuse");
1141 1142

#ifdef CONFIG_BLOCK
A
Al Viro 已提交
1143
static struct dentry *fuse_mount_blk(struct file_system_type *fs_type,
1144
			   int flags, const char *dev_name,
A
Al Viro 已提交
1145
			   void *raw_data)
1146
{
A
Al Viro 已提交
1147
	return mount_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super);
1148 1149
}

J
John Muir 已提交
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
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);
}

1163 1164 1165
static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
A
Al Viro 已提交
1166
	.mount		= fuse_mount_blk,
J
John Muir 已提交
1167
	.kill_sb	= fuse_kill_sb_blk,
A
Alexey Dobriyan 已提交
1168
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1169
};
1170
MODULE_ALIAS_FS("fuseblk");
1171

1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
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

1192
static void fuse_inode_init_once(void *foo)
M
Miklos Szeredi 已提交
1193
{
M
Miklos Szeredi 已提交
1194
	struct inode *inode = foo;
M
Miklos Szeredi 已提交
1195

C
Christoph Lameter 已提交
1196
	inode_init_once(inode);
M
Miklos Szeredi 已提交
1197 1198 1199 1200 1201 1202
}

static int __init fuse_fs_init(void)
{
	int err;

1203 1204 1205
	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
1206
					      fuse_inode_init_once);
1207 1208
	err = -ENOMEM;
	if (!fuse_inode_cachep)
1209 1210 1211 1212 1213 1214 1215 1216 1217
		goto out;

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

	err = register_filesystem(&fuse_fs_type);
	if (err)
		goto out3;
1218 1219

	return 0;
M
Miklos Szeredi 已提交
1220

1221
 out3:
1222
	unregister_fuseblk();
1223 1224
 out2:
	kmem_cache_destroy(fuse_inode_cachep);
1225
 out:
M
Miklos Szeredi 已提交
1226 1227 1228 1229 1230 1231
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
1232
	unregister_fuseblk();
1233 1234 1235 1236 1237 1238

	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
M
Miklos Szeredi 已提交
1239 1240 1241
	kmem_cache_destroy(fuse_inode_cachep);
}

1242 1243 1244
static struct kobject *fuse_kobj;
static struct kobject *connections_kobj;

1245 1246 1247 1248
static int fuse_sysfs_init(void)
{
	int err;

1249
	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1250 1251
	if (!fuse_kobj) {
		err = -ENOMEM;
1252
		goto out_err;
1253
	}
1254

1255 1256 1257
	connections_kobj = kobject_create_and_add("connections", fuse_kobj);
	if (!connections_kobj) {
		err = -ENOMEM;
1258
		goto out_fuse_unregister;
1259
	}
1260 1261 1262 1263

	return 0;

 out_fuse_unregister:
1264
	kobject_put(fuse_kobj);
1265 1266 1267 1268 1269 1270
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
1271 1272
	kobject_put(connections_kobj);
	kobject_put(fuse_kobj);
1273 1274
}

M
Miklos Szeredi 已提交
1275 1276 1277 1278
static int __init fuse_init(void)
{
	int res;

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

1282
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
1283 1284 1285 1286
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
1287 1288 1289 1290
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

1291 1292 1293 1294
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

1295 1296 1297 1298
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

1299 1300 1301
	sanitize_global_limit(&max_user_bgreq);
	sanitize_global_limit(&max_user_congthresh);

M
Miklos Szeredi 已提交
1302 1303
	return 0;

1304 1305
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
1306 1307
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1308 1309
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1310 1311 1312 1313 1314 1315 1316 1317
 err:
	return res;
}

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

1318
	fuse_ctl_cleanup();
1319
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
1320
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1321
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1322 1323 1324 1325
}

module_init(fuse_init);
module_exit(fuse_exit);