inode.c 31.7 KB
Newer Older
Miklos Szeredi's avatar
Miklos Szeredi committed
1 2
/*
  FUSE: Filesystem in Userspace
Miklos Szeredi's avatar
Miklos Szeredi committed
3
  Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
Miklos Szeredi's avatar
Miklos Szeredi committed
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>
Miklos Szeredi's avatar
Miklos Szeredi committed
18 19
#include <linux/parser.h>
#include <linux/statfs.h>
20
#include <linux/random.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
21
#include <linux/sched.h>
Miklos Szeredi's avatar
Miklos Szeredi committed
22
#include <linux/exportfs.h>
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
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");

Miklos Szeredi's avatar
Miklos Szeredi committed
50 51
#define FUSE_SUPER_MAGIC 0x65735546

Miklos Szeredi's avatar
Miklos Szeredi committed
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)

Miklos Szeredi's avatar
Miklos Szeredi committed
60 61 62
struct fuse_mount_data {
	int fd;
	unsigned rootmode;
63 64
	kuid_t user_id;
	kgid_t group_id;
Miklos Szeredi's avatar
Miklos Szeredi committed
65 66 67 68
	unsigned fd_present:1;
	unsigned rootmode_present:1;
	unsigned user_id_present:1;
	unsigned group_id_present:1;
69
	unsigned flags;
70
	unsigned max_read;
71
	unsigned blksize;
Miklos Szeredi's avatar
Miklos Szeredi committed
72 73
};

74
struct fuse_forget_link *fuse_alloc_forget(void)
75 76 77 78
{
	return kzalloc(sizeof(struct fuse_forget_link), GFP_KERNEL);
}

Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
85 86 87 88
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
89
	fi->i_time = 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
90
	fi->nodeid = 0;
91
	fi->nlookup = 0;
92
	fi->attr_version = 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
93
	fi->writectr = 0;
94
	fi->orig_ino = 0;
95
	fi->state = 0;
96
	INIT_LIST_HEAD(&fi->write_files);
Miklos Szeredi's avatar
Miklos Szeredi committed
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;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
106 107 108 109

	return inode;
}

Nick Piggin's avatar
Nick Piggin committed
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);
}

Miklos Szeredi's avatar
Miklos Szeredi committed
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));
Miklos Szeredi's avatar
Miklos Szeredi committed
120
	BUG_ON(!list_empty(&fi->queued_writes));
121
	mutex_destroy(&fi->mutex);
122
	kfree(fi->forget);
Nick Piggin's avatar
Nick Piggin committed
123
	call_rcu(&inode->i_rcu, fuse_i_callback);
Miklos Szeredi's avatar
Miklos Szeredi committed
124 125
}

126
static void fuse_evict_inode(struct inode *inode)
Miklos Szeredi's avatar
Miklos Szeredi committed
127
{
128
	truncate_inode_pages_final(&inode->i_data);
129
	clear_inode(inode);
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
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
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;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
159 160
void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
				   u64 attr_valid)
Miklos Szeredi's avatar
Miklos Szeredi committed
161
{
162
	struct fuse_conn *fc = get_fuse_conn(inode);
163
	struct fuse_inode *fi = get_fuse_inode(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
173 174 175
	inode->i_blocks  = attr->blocks;
	inode->i_atime.tv_sec   = attr->atime;
	inode->i_atime.tv_nsec  = attr->atimensec;
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;
180 181
		inode->i_ctime.tv_sec   = attr->ctime;
		inode->i_ctime.tv_nsec  = attr->ctimensec;
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;
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
206
	bool is_wb = fc->writeback_cache;
Miklos Szeredi's avatar
Miklos Szeredi committed
207
	loff_t oldsize;
208
	struct timespec old_mtime;
Miklos Szeredi's avatar
Miklos Szeredi committed
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)) {
Miklos Szeredi's avatar
Miklos Szeredi committed
213 214 215 216
		spin_unlock(&fc->lock);
		return;
	}

217
	old_mtime = inode->i_mtime;
Miklos Szeredi's avatar
Miklos Szeredi committed
218
	fuse_change_attributes_common(inode, attr, attr_valid);
219

220
	oldsize = inode->i_size;
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);

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
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
253 254 255 256 257
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
258
	inode->i_size = attr->size;
259 260
	inode->i_mtime.tv_sec  = attr->mtime;
	inode->i_mtime.tv_nsec = attr->mtimensec;
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);
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();
Miklos Szeredi's avatar
Miklos Szeredi committed
277 278
}

John Muir's avatar
John Muir committed
279
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
Miklos Szeredi's avatar
Miklos Szeredi committed
280
{
Miklos Szeredi's avatar
Miklos Szeredi committed
281
	u64 nodeid = *(u64 *) _nodeidp;
Miklos Szeredi's avatar
Miklos Szeredi committed
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)
{
Miklos Szeredi's avatar
Miklos Szeredi committed
290
	u64 nodeid = *(u64 *) _nodeidp;
Miklos Szeredi's avatar
Miklos Szeredi committed
291 292 293 294
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
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)
Miklos Szeredi's avatar
Miklos Szeredi committed
298 299
{
	struct inode *inode;
300
	struct fuse_inode *fi;
Miklos Szeredi's avatar
Miklos Szeredi committed
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)) {
309
		inode->i_flags |= S_NOATIME;
310
		if (!fc->writeback_cache || !S_ISREG(attr->mode))
311
			inode->i_flags |= S_NOCMTIME;
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
324
	fi->nlookup++;
325
	spin_unlock(&fc->lock);
326 327
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

Miklos Szeredi's avatar
Miklos Szeredi committed
328 329 330
	return inode;
}

John Muir's avatar
John Muir committed
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;
John Muir's avatar
John Muir committed
345 346 347
		if (len <= 0)
			pg_end = -1;
		else
348
			pg_end = (offset + len - 1) >> PAGE_SHIFT;
John Muir's avatar
John Muir committed
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;
Miklos Szeredi's avatar
Miklos Szeredi committed
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)
Miklos Szeredi's avatar
Miklos Szeredi committed
387
{
388 389 390
	if (fc->bdi_initialized)
		bdi_destroy(&fc->bdi);
}
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
397

398
	fuse_abort_conn(fc);
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
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)) {
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;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
448 449 450 451
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
452
	OPT_GROUP_ID,
Miklos Szeredi's avatar
Miklos Szeredi committed
453 454
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
455
	OPT_MAX_READ,
456
	OPT_BLKSIZE,
Miklos Szeredi's avatar
Miklos Szeredi committed
457 458 459
	OPT_ERR
};

460
static const match_table_t tokens = {
Miklos Szeredi's avatar
Miklos Szeredi committed
461 462 463
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
464
	{OPT_GROUP_ID,			"group_id=%u"},
Miklos Szeredi's avatar
Miklos Szeredi committed
465 466
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
467
	{OPT_MAX_READ,			"max_read=%u"},
468
	{OPT_BLKSIZE,			"blksize=%u"},
Miklos Szeredi's avatar
Miklos Szeredi committed
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;
}

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

	while ((p = strsep(&opt, ",")) != NULL) {
		int token;
		int value;
493
		unsigned uv;
Miklos Szeredi's avatar
Miklos Szeredi committed
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;
Miklos Szeredi's avatar
Miklos Szeredi committed
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;
Miklos Szeredi's avatar
Miklos Szeredi committed
512
			d->rootmode = value;
513
			d->rootmode_present = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
514 515 516
			break;

		case OPT_USER_ID:
517
			if (fuse_match_uint(&args[0], &uv))
Miklos Szeredi's avatar
Miklos Szeredi committed
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;
Miklos Szeredi's avatar
Miklos Szeredi committed
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;

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;

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

Miklos Szeredi's avatar
Miklos Szeredi committed
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)
Miklos Szeredi's avatar
Miklos Szeredi committed
561 562 563 564 565
		return 0;

	return 1;
}

566
static int fuse_show_options(struct seq_file *m, struct dentry *root)
Miklos Szeredi's avatar
Miklos Szeredi committed
567
{
568 569
	struct super_block *sb = root->d_sb;
	struct fuse_conn *fc = get_fuse_conn_super(sb);
Miklos Szeredi's avatar
Miklos Szeredi committed
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));
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
581 582 583
	return 0;
}

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

594 595 596
static void fuse_pqueue_init(struct fuse_pqueue *fpq)
{
	memset(fpq, 0, sizeof(struct fuse_pqueue));
Miklos Szeredi's avatar
Miklos Szeredi committed
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)
Miklos Szeredi's avatar
Miklos Szeredi committed
604
{
605 606
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
John Muir's avatar
John Muir committed
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);
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;
622
	fc->initialized = 0;
623
	fc->connected = 1;
624 625
	fc->attr_version = 1;
	get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
Miklos Szeredi's avatar
Miklos Szeredi committed
626
}
627
EXPORT_SYMBOL_GPL(fuse_conn_init);
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Tejun Heo's avatar
Tejun Heo committed
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)
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
655 656
}

Miklos Szeredi's avatar
Miklos Szeredi committed
657
struct fuse_inode_handle {
Miklos Szeredi's avatar
Miklos Szeredi committed
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);
Miklos Szeredi's avatar
Miklos Szeredi committed
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 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
	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;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
695 696 697 698
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

699
	entry = d_obtain_alias(inode);
Al Viro's avatar
Al Viro committed
700
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
Miklos Szeredi's avatar
Miklos Szeredi committed
701 702 703 704 705 706 707 708 709 710
		fuse_invalidate_entry_cache(entry);

	return entry;

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

Al Viro's avatar
Al Viro committed
711 712
static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
			   struct inode *parent)
Miklos Szeredi's avatar
Miklos Szeredi committed
713
{
Al Viro's avatar
Al Viro committed
714
	int len = parent ? 6 : 3;
Miklos Szeredi's avatar
Miklos Szeredi committed
715 716 717
	u64 nodeid;
	u32 generation;

718 719
	if (*max_len < len) {
		*max_len = len;
720
		return  FILEID_INVALID;
721
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
722 723 724 725 726 727 728 729

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

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

Al Viro's avatar
Al Viro committed
730
	if (parent) {
Miklos Szeredi's avatar
Miklos Szeredi committed
731 732 733 734 735 736 737 738 739
		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;
Al Viro's avatar
Al Viro committed
740
	return parent ? 0x82 : 0x81;
Miklos Szeredi's avatar
Miklos Szeredi committed
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 769 770
}

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

771 772
static struct dentry *fuse_get_parent(struct dentry *child)
{
773
	struct inode *child_inode = d_inode(child);
774 775 776 777 778 779 780 781 782 783 784 785 786 787
	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);
788 789 790
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
791 792
		return ERR_PTR(err);
	}
793 794

	parent = d_obtain_alias(inode);
Al Viro's avatar
Al Viro committed
795
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
796 797 798 799
		fuse_invalidate_entry_cache(parent);

	return parent;
}
Miklos Szeredi's avatar
Miklos Szeredi committed
800 801 802 803 804

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,
805
	.get_parent	= fuse_get_parent,
Miklos Szeredi's avatar
Miklos Szeredi committed
806 807
};

808
static const struct super_operations fuse_super_operations = {
Miklos Szeredi's avatar
Miklos Szeredi committed
809 810
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
811
	.evict_inode	= fuse_evict_inode,
Miklos Szeredi's avatar
Miklos Szeredi committed
812
	.write_inode	= fuse_write_inode,
Miklos Szeredi's avatar
Miklos Szeredi committed
813
	.drop_inode	= generic_delete_inode,
814
	.remount_fs	= fuse_remount_fs,
Miklos Szeredi's avatar
Miklos Szeredi committed
815
	.put_super	= fuse_put_super,
816
	.umount_begin	= fuse_umount_begin,
817
	.statfs		= fuse_statfs,
Miklos Szeredi's avatar
Miklos Szeredi committed
818 819 820
	.show_options	= fuse_show_options,
};

821 822 823
static void sanitize_global_limit(unsigned *limit)
{
	if (*limit == 0)
824
		*limit = ((totalram_pages << PAGE_SHIFT) >> 13) /
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 865 866 867 868
			 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;
	}
}

869 870 871 872 873 874 875
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 {
876 877
		unsigned long ra_pages;

878 879
		process_init_limits(fc, arg);

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

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

935
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
936 937
{
	struct fuse_init_in *arg = &req->misc.init_in;
938

939 940
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
941
	arg->max_readahead = fc->bdi.ra_pages * PAGE_SIZE;
942
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
Miklos Szeredi's avatar
Miklos Szeredi committed
943
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
944
		FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
945
		FUSE_FLOCK_LOCKS | FUSE_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
946
		FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
947 948
		FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT |
		FUSE_PARALLEL_DIROPS;
949 950 951 952 953
	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;
954
	/* Variable length argument used for backward compatibility
955 956 957 958 959 960
	   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;
961
	fuse_request_send_background(fc, req);
962 963
}

Tejun Heo's avatar
Tejun Heo committed
964 965
static void fuse_free_conn(struct fuse_conn *fc)
{
966
	WARN_ON(!list_empty(&fc->devices));
Al Viro's avatar
Al Viro committed
967
	kfree_rcu(fc, rcu);
Tejun Heo's avatar
Tejun Heo committed
968 969
}

970 971 972 973
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

974
	fc->bdi.name = "fuse";
975
	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE;
976
	/* fuse does it's own writeback accounting */
977
	fc->bdi.capabilities = BDI_CAP_NO_ACCT_WB | BDI_CAP_STRICTLIMIT;
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 1008 1009 1010 1011

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

1012 1013 1014 1015 1016 1017 1018
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);
1019
		fuse_pqueue_init(&fud->pq);
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044

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

Miklos Szeredi's avatar
Miklos Szeredi committed
1045 1046
static int fuse_fill_super(struct super_block *sb, void *data, int silent)
{
1047
	struct fuse_dev *fud;
Miklos Szeredi's avatar
Miklos Szeredi committed
1048 1049 1050 1051
	struct fuse_conn *fc;
	struct inode *root;
	struct fuse_mount_data d;
	struct file *file;
1052
	struct dentry *root_dentry;
1053
	struct fuse_req *init_req;
Miklos Szeredi's avatar
Miklos Szeredi committed
1054
	int err;
1055
	int is_bdev = sb->s_bdev != NULL;
Miklos Szeredi's avatar
Miklos Szeredi committed
1056

1057
	err = -EINVAL;
1058
	if (sb->s_flags & MS_MANDLOCK)
1059
		goto err;
1060

Miklos Szeredi's avatar
Miklos Szeredi committed
1061
	sb->s_flags &= ~(MS_NOSEC | MS_I_VERSION);
Al Viro's avatar
Al Viro committed
1062

Himangi Saraogi's avatar
Himangi Saraogi committed
1063
	if (!parse_fuse_opt(data, &d, is_bdev))
1064
		goto err;
Miklos Szeredi's avatar
Miklos Szeredi committed
1065

1066
	if (is_bdev) {
1067
#ifdef CONFIG_BLOCK
1068
		err = -EINVAL;
1069
		if (!sb_set_blocksize(sb, d.blksize))
1070
			goto err;
1071
#endif
1072
	} else {
1073 1074
		sb->s_blocksize = PAGE_SIZE;
		sb->s_blocksize_bits = PAGE_SHIFT;
1075
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
1076 1077 1078
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
1079
	sb->s_time_gran = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
1080
	sb->s_export_op = &fuse_export_operations;
Miklos Szeredi's avatar
Miklos Szeredi committed
1081 1082

	file = fget(d.fd);
1083
	err = -EINVAL;
Miklos Szeredi's avatar
Miklos Szeredi committed
1084
	if (!file)
1085
		goto err;
Miklos Szeredi's avatar
Miklos Szeredi committed
1086

1087 1088
	if ((file->f_op != &fuse_dev_operations) ||
	    (file->f_cred->user_ns != &init_user_ns))
1089
		goto err_fput;
1090

1091
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
1092 1093 1094
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
Miklos Szeredi's avatar
Miklos Szeredi committed
1095

1096
	fuse_conn_init(fc);
1097
	fc->release = fuse_free_conn;
1098

1099 1100 1101 1102
	fud = fuse_dev_alloc(fc);
	if (!fud)
		goto err_put_conn;

1103
	fc->dev = sb->s_dev;
John Muir's avatar
John Muir committed
1104
	fc->sb = sb;
1105 1106
	err = fuse_bdi_init(fc, sb);
	if (err)
1107
		goto err_dev_free;
1108

Jens Axboe's avatar
Jens Axboe committed
1109 1110
	sb->s_bdi = &fc->bdi;

1111 1112 1113 1114 1115
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

1116
	fc->flags = d.flags;
Miklos Szeredi's avatar
Miklos Szeredi committed
1117
	fc->user_id = d.user_id;
1118
	fc->group_id = d.group_id;
1119
	fc->max_read = max_t(unsigned, 4096, d.max_read);
Miklos Szeredi's avatar
Miklos Szeredi committed
1120

1121 1122 1123
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

Miklos Szeredi's avatar
Miklos Szeredi committed
1124
	err = -ENOMEM;
1125
	root = fuse_get_root_inode(sb, d.rootmode);
1126 1127
	root_dentry = d_make_root(root);
	if (!root_dentry)