inode.c 31.7 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
	mutex_init(&fi->mutex);
101 102
	fi->forget = fuse_alloc_forget();
	if (!fi->forget) {
103 104 105
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
M
Miklos Szeredi 已提交
106 107 108 109

	return inode;
}

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

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

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

	return 0;
}

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

165 166 167
	fi->attr_version = ++fc->attr_version;
	fi->i_time = attr_valid;

168
	inode->i_ino     = fuse_squash_ino(attr->ino);
169
	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
M
Miklos Szeredi 已提交
170
	set_nlink(inode, attr->nlink);
171 172
	inode->i_uid     = make_kuid(&init_user_ns, attr->uid);
	inode->i_gid     = make_kgid(&init_user_ns, attr->gid);
M
Miklos Szeredi 已提交
173 174 175
	inode->i_blocks  = attr->blocks;
	inode->i_atime.tv_sec   = attr->atime;
	inode->i_atime.tv_nsec  = attr->atimensec;
M
Maxim Patlasov 已提交
176 177 178 179
	/* 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
Maxim Patlasov 已提交
180 181
		inode->i_ctime.tv_sec   = attr->ctime;
		inode->i_ctime.tv_nsec  = attr->ctimensec;
M
Maxim Patlasov 已提交
182
	}
183

184 185 186 187 188
	if (attr->blksize != 0)
		inode->i_blkbits = ilog2(attr->blksize);
	else
		inode->i_blkbits = inode->i_sb->s_blocksize_bits;

189 190 191 192 193 194 195 196
	/*
	 * 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;
197 198

	fi->orig_ino = attr->ino;
M
Miklos Szeredi 已提交
199 200 201 202 203 204 205
}

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 已提交
206
	bool is_wb = fc->writeback_cache;
M
Miklos Szeredi 已提交
207
	loff_t oldsize;
208
	struct timespec old_mtime;
M
Miklos Szeredi 已提交
209 210

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

217
	old_mtime = inode->i_mtime;
M
Miklos Szeredi 已提交
218
	fuse_change_attributes_common(inode, attr, attr_valid);
219

220
	oldsize = inode->i_size;
P
Pavel Emelyanov 已提交
221 222 223 224 225 226 227
	/*
	 * 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);
228 229
	spin_unlock(&fc->lock);

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

		if (oldsize != attr->size) {
234
			truncate_pagecache(inode, attr->size);
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
			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);
252
	}
M
Miklos Szeredi 已提交
253 254 255 256 257
}

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

J
John Muir 已提交
279
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
M
Miklos Szeredi 已提交
280
{
M
Miklos Szeredi 已提交
281
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
282 283 284 285 286 287 288 289
	if (get_node_id(inode) == nodeid)
		return 1;
	else
		return 0;
}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
M
Miklos Szeredi 已提交
290
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
291 292 293 294
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

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

322
	fi = get_fuse_inode(inode);
323
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
324
	fi->nlookup++;
325
	spin_unlock(&fc->lock);
326 327
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

M
Miklos Szeredi 已提交
328 329 330
	return inode;
}

J
John Muir 已提交
331 332 333 334 335 336 337 338 339 340 341 342 343
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) {
344
		pg_start = offset >> PAGE_SHIFT;
J
John Muir 已提交
345 346 347
		if (len <= 0)
			pg_end = -1;
		else
348
			pg_end = (offset + len - 1) >> PAGE_SHIFT;
J
John Muir 已提交
349 350 351 352 353 354 355
		invalidate_inode_pages2_range(inode->i_mapping,
					      pg_start, pg_end);
	}
	iput(inode);
	return 0;
}

356 357 358 359 360 361 362 363 364 365 366 367
void fuse_lock_inode(struct inode *inode)
{
	if (!get_fuse_conn(inode)->parallel_dirops)
		mutex_lock(&get_fuse_inode(inode)->mutex);
}

void fuse_unlock_inode(struct inode *inode)
{
	if (!get_fuse_conn(inode)->parallel_dirops)
		mutex_unlock(&get_fuse_inode(inode)->mutex);
}

368
static void fuse_umount_begin(struct super_block *sb)
369
{
370
	fuse_abort_conn(get_fuse_conn_super(sb));
371 372
}

373 374 375 376 377 378
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;
M
Miklos Szeredi 已提交
379 380
		__set_bit(FR_FORCE, &req->flags);
		__clear_bit(FR_BACKGROUND, &req->flags);
381
		fuse_request_send(fc, req);
382 383 384 385
		fuse_put_request(fc, req);
	}
}

386
static void fuse_bdi_destroy(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
387
{
388 389 390
	if (fc->bdi_initialized)
		bdi_destroy(&fc->bdi);
}
M
Miklos Szeredi 已提交
391

392 393 394 395 396
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 已提交
397

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

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

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

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

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

435
	memset(&outarg, 0, sizeof(outarg));
436 437
	args.in.numargs = 0;
	args.in.h.opcode = FUSE_STATFS;
438
	args.in.h.nodeid = get_node_id(d_inode(dentry));
439
	args.out.numargs = 1;
440
	args.out.args[0].size = sizeof(outarg);
441 442
	args.out.args[0].value = &outarg;
	err = fuse_simple_request(fc, &args);
443 444 445 446 447
	if (!err)
		convert_fuse_statfs(buf, &outarg.st);
	return err;
}

M
Miklos Szeredi 已提交
448 449 450 451
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
452
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
453 454
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
455
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
456
	OPT_BLKSIZE,
M
Miklos Szeredi 已提交
457 458 459
	OPT_ERR
};

460
static const match_table_t tokens = {
M
Miklos Szeredi 已提交
461 462 463
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
464
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
465 466
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
467
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
468
	{OPT_BLKSIZE,			"blksize=%u"},
M
Miklos Szeredi 已提交
469 470 471
	{OPT_ERR,			NULL}
};

472 473 474 475 476 477 478 479 480 481 482
static int fuse_match_uint(substring_t *s, unsigned int *res)
{
	int err = -ENOMEM;
	char *buf = match_strdup(s);
	if (buf) {
		err = kstrtouint(buf, 10, res);
		kfree(buf);
	}
	return err;
}

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

	while ((p = strsep(&opt, ",")) != NULL) {
		int token;
		int value;
493
		unsigned uv;
M
Miklos Szeredi 已提交
494 495 496 497 498 499 500 501 502 503
		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;
504
			d->fd_present = 1;
M
Miklos Szeredi 已提交
505 506 507 508 509
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
510 511
			if (!fuse_valid_type(value))
				return 0;
M
Miklos Szeredi 已提交
512
			d->rootmode = value;
513
			d->rootmode_present = 1;
M
Miklos Szeredi 已提交
514 515 516
			break;

		case OPT_USER_ID:
517
			if (fuse_match_uint(&args[0], &uv))
M
Miklos Szeredi 已提交
518
				return 0;
519
			d->user_id = make_kuid(current_user_ns(), uv);
520 521
			if (!uid_valid(d->user_id))
				return 0;
522
			d->user_id_present = 1;
M
Miklos Szeredi 已提交
523 524
			break;

525
		case OPT_GROUP_ID:
526
			if (fuse_match_uint(&args[0], &uv))
527
				return 0;
528
			d->group_id = make_kgid(current_user_ns(), uv);
529 530
			if (!gid_valid(d->group_id))
				return 0;
531
			d->group_id_present = 1;
532 533
			break;

M
Miklos Szeredi 已提交
534 535 536 537 538 539 540 541
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

542 543 544 545 546 547
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

M
Miklos Szeredi 已提交
548 549 550 551 552 553
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

M
Miklos Szeredi 已提交
554 555 556 557
		default:
			return 0;
		}
	}
558 559 560

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
561 562 563 564 565
		return 0;

	return 1;
}

566
static int fuse_show_options(struct seq_file *m, struct dentry *root)
M
Miklos Szeredi 已提交
567
{
568 569
	struct super_block *sb = root->d_sb;
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
570

571 572
	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 已提交
573 574 575 576
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
577 578
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
579 580
	if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
		seq_printf(m, ",blksize=%lu", sb->s_blocksize);
M
Miklos Szeredi 已提交
581 582 583
	return 0;
}

M
Miklos Szeredi 已提交
584 585 586 587 588 589 590
static void fuse_iqueue_init(struct fuse_iqueue *fiq)
{
	memset(fiq, 0, sizeof(struct fuse_iqueue));
	init_waitqueue_head(&fiq->waitq);
	INIT_LIST_HEAD(&fiq->pending);
	INIT_LIST_HEAD(&fiq->interrupts);
	fiq->forget_list_tail = &fiq->forget_list_head;
591
	fiq->connected = 1;
M
Miklos Szeredi 已提交
592 593
}

594 595 596
static void fuse_pqueue_init(struct fuse_pqueue *fpq)
{
	memset(fpq, 0, sizeof(struct fuse_pqueue));
M
Miklos Szeredi 已提交
597
	spin_lock_init(&fpq->lock);
598 599
	INIT_LIST_HEAD(&fpq->processing);
	INIT_LIST_HEAD(&fpq->io);
600
	fpq->connected = 1;
601 602
}

603
void fuse_conn_init(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
604
{
605 606
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
J
John Muir 已提交
607
	init_rwsem(&fc->killsb);
608
	atomic_set(&fc->count, 1);
609
	atomic_set(&fc->dev_count, 1);
610 611
	init_waitqueue_head(&fc->blocked_waitq);
	init_waitqueue_head(&fc->reserved_req_waitq);
M
Miklos Szeredi 已提交
612
	fuse_iqueue_init(&fc->iq);
613 614
	INIT_LIST_HEAD(&fc->bg_queue);
	INIT_LIST_HEAD(&fc->entry);
615
	INIT_LIST_HEAD(&fc->devices);
616
	atomic_set(&fc->num_waiting, 0);
617 618
	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
619 620
	fc->khctr = 0;
	fc->polled_files = RB_ROOT;
621
	fc->blocked = 0;
M
Maxim Patlasov 已提交
622
	fc->initialized = 0;
623
	fc->connected = 1;
624 625
	fc->attr_version = 1;
	get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
M
Miklos Szeredi 已提交
626
}
627
EXPORT_SYMBOL_GPL(fuse_conn_init);
M
Miklos Szeredi 已提交
628

629 630
void fuse_conn_put(struct fuse_conn *fc)
{
631
	if (atomic_dec_and_test(&fc->count)) {
632 633
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
T
Tejun Heo 已提交
634
		fc->release(fc);
635
	}
636
}
637
EXPORT_SYMBOL_GPL(fuse_conn_put);
638 639 640 641 642 643

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

646
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
M
Miklos Szeredi 已提交
647 648 649 650 651 652
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
653
	attr.nlink = 1;
654
	return fuse_iget(sb, 1, 0, &attr, 0, 0);
M
Miklos Szeredi 已提交
655 656
}

M
Miklos Szeredi 已提交
657
struct fuse_inode_handle {
M
Miklos Szeredi 已提交
658 659 660 661 662 663 664
	u64 nodeid;
	u32 generation;
};

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
665
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
666 667 668 669 670 671 672 673
	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);
674 675
	if (!inode) {
		struct fuse_entry_out outarg;
A
Al Viro 已提交
676
		const struct qstr name = QSTR_INIT(".", 1);
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692

		if (!fc->export_support)
			goto out_err;

		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 已提交
693 694 695 696
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

697
	entry = d_obtain_alias(inode);
A
Al Viro 已提交
698
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
M
Miklos Szeredi 已提交
699 700 701 702 703 704 705 706 707 708
		fuse_invalidate_entry_cache(entry);

	return entry;

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

A
Al Viro 已提交
709 710
static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
			   struct inode *parent)
M
Miklos Szeredi 已提交
711
{
A
Al Viro 已提交
712
	int len = parent ? 6 : 3;
M
Miklos Szeredi 已提交
713 714 715
	u64 nodeid;
	u32 generation;

716 717
	if (*max_len < len) {
		*max_len = len;
718
		return  FILEID_INVALID;
719
	}
M
Miklos Szeredi 已提交
720 721 722 723 724 725 726 727

	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 已提交
728
	if (parent) {
M
Miklos Szeredi 已提交
729 730 731 732 733 734 735 736 737
		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 已提交
738
	return parent ? 0x82 : 0x81;
M
Miklos Szeredi 已提交
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
}

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

769 770
static struct dentry *fuse_get_parent(struct dentry *child)
{
771
	struct inode *child_inode = d_inode(child);
772 773 774 775
	struct fuse_conn *fc = get_fuse_conn(child_inode);
	struct inode *inode;
	struct dentry *parent;
	struct fuse_entry_out outarg;
A
Al Viro 已提交
776
	const struct qstr name = QSTR_INIT("..", 2);
777 778 779 780 781 782 783
	int err;

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

	err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode),
			       &name, &outarg, &inode);
784 785 786
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
787 788
		return ERR_PTR(err);
	}
789 790

	parent = d_obtain_alias(inode);
A
Al Viro 已提交
791
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
792 793 794 795
		fuse_invalidate_entry_cache(parent);

	return parent;
}
M
Miklos Szeredi 已提交
796 797 798 799 800

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,
801
	.get_parent	= fuse_get_parent,
M
Miklos Szeredi 已提交
802 803
};

804
static const struct super_operations fuse_super_operations = {
M
Miklos Szeredi 已提交
805 806
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
807
	.evict_inode	= fuse_evict_inode,
M
Miklos Szeredi 已提交
808
	.write_inode	= fuse_write_inode,
M
Miklos Szeredi 已提交
809
	.drop_inode	= generic_delete_inode,
810
	.remount_fs	= fuse_remount_fs,
M
Miklos Szeredi 已提交
811
	.put_super	= fuse_put_super,
812
	.umount_begin	= fuse_umount_begin,
813
	.statfs		= fuse_statfs,
M
Miklos Szeredi 已提交
814 815 816
	.show_options	= fuse_show_options,
};

817 818 819
static void sanitize_global_limit(unsigned *limit)
{
	if (*limit == 0)
820
		*limit = ((totalram_pages << PAGE_SHIFT) >> 13) /
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 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
			 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;
	}
}

865 866 867 868 869 870 871
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 {
872 873
		unsigned long ra_pages;

874 875
		process_init_limits(fc, arg);

876
		if (arg->minor >= 6) {
877
			ra_pages = arg->max_readahead / PAGE_SIZE;
878 879
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
880 881
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
M
Miklos Szeredi 已提交
882 883 884
			if (arg->minor >= 17) {
				if (!(arg->flags & FUSE_FLOCK_LOCKS))
					fc->no_flock = 1;
M
Miklos Szeredi 已提交
885 886 887
			} else {
				if (!(arg->flags & FUSE_POSIX_LOCKS))
					fc->no_flock = 1;
M
Miklos Szeredi 已提交
888
			}
889 890
			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
				fc->atomic_o_trunc = 1;
891 892 893 894 895
			if (arg->minor >= 9) {
				/* LOOKUP has dependency on proto version */
				if (arg->flags & FUSE_EXPORT_SUPPORT)
					fc->export_support = 1;
			}
896 897
			if (arg->flags & FUSE_BIG_WRITES)
				fc->big_writes = 1;
898 899
			if (arg->flags & FUSE_DONT_MASK)
				fc->dont_mask = 1;
900 901
			if (arg->flags & FUSE_AUTO_INVAL_DATA)
				fc->auto_inval_data = 1;
902
			if (arg->flags & FUSE_DO_READDIRPLUS) {
903
				fc->do_readdirplus = 1;
904 905 906
				if (arg->flags & FUSE_READDIRPLUS_AUTO)
					fc->readdirplus_auto = 1;
			}
907 908
			if (arg->flags & FUSE_ASYNC_DIO)
				fc->async_dio = 1;
P
Pavel Emelyanov 已提交
909 910
			if (arg->flags & FUSE_WRITEBACK_CACHE)
				fc->writeback_cache = 1;
911 912
			if (arg->flags & FUSE_PARALLEL_DIROPS)
				fc->parallel_dirops = 1;
913 914
			if (arg->time_gran && arg->time_gran <= 1000000000)
				fc->sb->s_time_gran = arg->time_gran;
915
		} else {
916
			ra_pages = fc->max_read / PAGE_SIZE;
917
			fc->no_lock = 1;
M
Miklos Szeredi 已提交
918
			fc->no_flock = 1;
919
		}
920 921

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
922 923
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
924
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
925
		fc->conn_init = 1;
926
	}
927
	fuse_set_initialized(fc);
928
	wake_up_all(&fc->blocked_waitq);
929 930
}

931
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
932 933
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
934

935 936
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
937
	arg->max_readahead = fc->bdi.ra_pages * PAGE_SIZE;
938
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
M
Miklos Szeredi 已提交
939
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
M
Miklos Szeredi 已提交
940
		FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
941
		FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
P
Pavel Emelyanov 已提交
942
		FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
943 944
		FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT |
		FUSE_PARALLEL_DIROPS;
945 946 947 948 949
	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 已提交
950
	/* Variable length argument used for backward compatibility
951 952 953 954 955 956
	   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;
957
	fuse_request_send_background(fc, req);
958 959
}

T
Tejun Heo 已提交
960 961
static void fuse_free_conn(struct fuse_conn *fc)
{
962
	WARN_ON(!list_empty(&fc->devices));
A
Al Viro 已提交
963
	kfree_rcu(fc, rcu);
T
Tejun Heo 已提交
964 965
}

966 967 968 969
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

970
	fc->bdi.name = "fuse";
971
	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE;
972
	/* fuse does it's own writeback accounting */
973
	fc->bdi.capabilities = BDI_CAP_NO_ACCT_WB | BDI_CAP_STRICTLIMIT;
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007

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

1008 1009 1010 1011 1012 1013 1014
struct fuse_dev *fuse_dev_alloc(struct fuse_conn *fc)
{
	struct fuse_dev *fud;

	fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL);
	if (fud) {
		fud->fc = fuse_conn_get(fc);
1015
		fuse_pqueue_init(&fud->pq);
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040

		spin_lock(&fc->lock);
		list_add_tail(&fud->entry, &fc->devices);
		spin_unlock(&fc->lock);
	}

	return fud;
}
EXPORT_SYMBOL_GPL(fuse_dev_alloc);

void fuse_dev_free(struct fuse_dev *fud)
{
	struct fuse_conn *fc = fud->fc;

	if (fc) {
		spin_lock(&fc->lock);
		list_del(&fud->entry);
		spin_unlock(&fc->lock);

		fuse_conn_put(fc);
	}
	kfree(fud);
}
EXPORT_SYMBOL_GPL(fuse_dev_free);

M
Miklos Szeredi 已提交
1041 1042
static int fuse_fill_super(struct super_block *sb, void *data, int silent)
{
1043
	struct fuse_dev *fud;
M
Miklos Szeredi 已提交
1044 1045 1046 1047
	struct fuse_conn *fc;
	struct inode *root;
	struct fuse_mount_data d;
	struct file *file;
1048
	struct dentry *root_dentry;
1049
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
1050
	int err;
M
Miklos Szeredi 已提交
1051
	int is_bdev = sb->s_bdev != NULL;
M
Miklos Szeredi 已提交
1052

1053
	err = -EINVAL;
1054
	if (sb->s_flags & MS_MANDLOCK)
1055
		goto err;
1056

M
Miklos Szeredi 已提交
1057
	sb->s_flags &= ~(MS_NOSEC | MS_I_VERSION);
A
Al Viro 已提交
1058

H
Himangi Saraogi 已提交
1059
	if (!parse_fuse_opt(data, &d, is_bdev))
1060
		goto err;
M
Miklos Szeredi 已提交
1061

M
Miklos Szeredi 已提交
1062
	if (is_bdev) {
1063
#ifdef CONFIG_BLOCK
1064
		err = -EINVAL;
M
Miklos Szeredi 已提交
1065
		if (!sb_set_blocksize(sb, d.blksize))
1066
			goto err;
1067
#endif
M
Miklos Szeredi 已提交
1068
	} else {
1069 1070
		sb->s_blocksize = PAGE_SIZE;
		sb->s_blocksize_bits = PAGE_SHIFT;
M
Miklos Szeredi 已提交
1071
	}
M
Miklos Szeredi 已提交
1072 1073 1074
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
1075
	sb->s_time_gran = 1;
M
Miklos Szeredi 已提交
1076
	sb->s_export_op = &fuse_export_operations;
M
Miklos Szeredi 已提交
1077 1078

	file = fget(d.fd);
1079
	err = -EINVAL;
M
Miklos Szeredi 已提交
1080
	if (!file)
1081
		goto err;
M
Miklos Szeredi 已提交
1082

1083 1084
	if ((file->f_op != &fuse_dev_operations) ||
	    (file->f_cred->user_ns != &init_user_ns))
1085
		goto err_fput;
M
Miklos Szeredi 已提交
1086

1087
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
1088 1089 1090
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
M
Miklos Szeredi 已提交
1091

1092
	fuse_conn_init(fc);
1093
	fc->release = fuse_free_conn;
1094

1095 1096 1097 1098
	fud = fuse_dev_alloc(fc);
	if (!fud)
		goto err_put_conn;

1099
	fc->dev = sb->s_dev;
J
John Muir 已提交
1100
	fc->sb = sb;
1101 1102
	err = fuse_bdi_init(fc, sb);
	if (err)
1103
		goto err_dev_free;
1104

J
Jens Axboe 已提交
1105 1106
	sb->s_bdi = &fc->bdi;

1107 1108 1109 1110 1111
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

M
Miklos Szeredi 已提交
1112
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
1113
	fc->user_id = d.user_id;
1114
	fc->group_id = d.group_id;
1115
	fc->max_read = max_t(unsigned, 4096, d.max_read);
M
Miklos Szeredi 已提交
1116

1117 1118 1119
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
1120
	err = -ENOMEM;
1121
	root = fuse_get_root_inode(sb, d.rootmode);
1122 1123
	root_dentry = d_make_root(root);
	if (!root_dentry)
1124
		goto err_dev_free;
A
Al Viro 已提交
1125 1126
	/* only now - we want root dentry with NULL ->d_op */
	sb->s_d_op = &fuse_dentry_operations;
1127

1128
	init_req = fuse_request_alloc(0);
1129 1130
	if (!init_req)
		goto err_put_root;
M
Miklos Szeredi 已提交
1131
	__set_bit(FR_BACKGROUND, &init_req->flags);
1132

1133
	if (is_bdev) {
1134
		fc->destroy_req = fuse_request_alloc(0);
1135
		if (!fc->destroy_req)
J
Julia Lawall 已提交
1136
			goto err_free_init_req;
1137 1138
	}

1139
	mutex_lock(&fuse_mutex);
1140 1141
	err = -EINVAL;
	if (file->private_data)
1142
		goto err_unlock;
1143

1144 1145 1146 1147 1148
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
1149
	sb->s_root = root_dentry;
1150
	file->private_data = fud;
1151
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
1152 1153 1154 1155 1156 1157
	/*
	 * 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);
1158

1159
	fuse_send_init(fc, init_req);
1160

M
Miklos Szeredi 已提交
1161 1162
	return 0;

1163 1164
 err_unlock:
	mutex_unlock(&fuse_mutex);
J
Julia Lawall 已提交
1165
 err_free_init_req:
1166
	fuse_request_free(init_req);
1167 1168
 err_put_root:
	dput(root_dentry);
1169 1170
 err_dev_free:
	fuse_dev_free(fud);
1171
 err_put_conn:
1172
	fuse_bdi_destroy(fc);
1173
	fuse_conn_put(fc);
1174 1175 1176
 err_fput:
	fput(file);
 err:
M
Miklos Szeredi 已提交
1177 1178 1179
	return err;
}

A
Al Viro 已提交
1180
static struct dentry *fuse_mount(struct file_system_type *fs_type,
1181
		       int flags, const char *dev_name,
A
Al Viro 已提交
1182
		       void *raw_data)
M
Miklos Szeredi 已提交
1183
{
A
Al Viro 已提交
1184
	return mount_nodev(fs_type, flags, raw_data, fuse_fill_super);
M
Miklos Szeredi 已提交
1185 1186
}

J
John Muir 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
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);
}

1200 1201 1202
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
M
Miklos Szeredi 已提交
1203
	.fs_flags	= FS_HAS_SUBTYPE,
A
Al Viro 已提交
1204
	.mount		= fuse_mount,
J
John Muir 已提交
1205
	.kill_sb	= fuse_kill_sb_anon,
1206
};
1207
MODULE_ALIAS_FS("fuse");
1208 1209

#ifdef CONFIG_BLOCK
A
Al Viro 已提交
1210
static struct dentry *fuse_mount_blk(struct file_system_type *fs_type,
1211
			   int flags, const char *dev_name,
A
Al Viro 已提交
1212
			   void *raw_data)
1213
{
A
Al Viro 已提交
1214
	return mount_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super);
1215 1216
}

J
John Muir 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
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);
}

1230 1231 1232
static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
A
Al Viro 已提交
1233
	.mount		= fuse_mount_blk,
J
John Muir 已提交
1234
	.kill_sb	= fuse_kill_sb_blk,
A
Alexey Dobriyan 已提交
1235
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1236
};
1237
MODULE_ALIAS_FS("fuseblk");
1238

1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
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

1259
static void fuse_inode_init_once(void *foo)
M
Miklos Szeredi 已提交
1260
{
M
Miklos Szeredi 已提交
1261
	struct inode *inode = foo;
M
Miklos Szeredi 已提交
1262

C
Christoph Lameter 已提交
1263
	inode_init_once(inode);
M
Miklos Szeredi 已提交
1264 1265 1266 1267 1268 1269
}

static int __init fuse_fs_init(void)
{
	int err;

1270
	fuse_inode_cachep = kmem_cache_create("fuse_inode",
1271 1272
					      sizeof(struct fuse_inode), 0,
					      SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT,
1273
					      fuse_inode_init_once);
1274 1275
	err = -ENOMEM;
	if (!fuse_inode_cachep)
1276 1277 1278 1279 1280 1281 1282 1283 1284
		goto out;

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

	err = register_filesystem(&fuse_fs_type);
	if (err)
		goto out3;
1285 1286

	return 0;
M
Miklos Szeredi 已提交
1287

1288
 out3:
1289
	unregister_fuseblk();
1290 1291
 out2:
	kmem_cache_destroy(fuse_inode_cachep);
1292
 out:
M
Miklos Szeredi 已提交
1293 1294 1295 1296 1297 1298
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
1299
	unregister_fuseblk();
1300 1301 1302 1303 1304 1305

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

1309 1310
static struct kobject *fuse_kobj;

1311 1312 1313 1314
static int fuse_sysfs_init(void)
{
	int err;

1315
	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1316 1317
	if (!fuse_kobj) {
		err = -ENOMEM;
1318
		goto out_err;
1319
	}
1320

1321 1322
	err = sysfs_create_mount_point(fuse_kobj, "connections");
	if (err)
1323 1324 1325 1326 1327
		goto out_fuse_unregister;

	return 0;

 out_fuse_unregister:
1328
	kobject_put(fuse_kobj);
1329 1330 1331 1332 1333 1334
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
1335
	sysfs_remove_mount_point(fuse_kobj, "connections");
1336
	kobject_put(fuse_kobj);
1337 1338
}

M
Miklos Szeredi 已提交
1339 1340 1341 1342
static int __init fuse_init(void)
{
	int res;

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

1346
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
1347 1348 1349 1350
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
1351 1352 1353 1354
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

1355 1356 1357 1358
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

1359 1360 1361 1362
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

1363 1364 1365
	sanitize_global_limit(&max_user_bgreq);
	sanitize_global_limit(&max_user_congthresh);

M
Miklos Szeredi 已提交
1366 1367
	return 0;

1368 1369
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
1370 1371
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1372 1373
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1374 1375 1376 1377 1378 1379 1380 1381
 err:
	return res;
}

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

1382
	fuse_ctl_cleanup();
1383
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
1384
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1385
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1386 1387 1388 1389
}

module_init(fuse_init);
module_exit(fuse_exit);