inode.c 33.4 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>
Seth Forshee's avatar
Seth Forshee committed
23
#include <linux/posix_acl.h>
24
#include <linux/pid_namespace.h>
Miklos Szeredi's avatar
Miklos Szeredi committed
25
26
27
28
29

MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
MODULE_DESCRIPTION("Filesystem in Userspace");
MODULE_LICENSE("GPL");

30
static struct kmem_cache *fuse_inode_cachep;
31
32
struct list_head fuse_conn_list;
DEFINE_MUTEX(fuse_mutex);
Miklos Szeredi's avatar
Miklos Szeredi committed
33

34
static int set_global_limit(const char *val, const struct kernel_param *kp);
35

36
unsigned max_user_bgreq;
37
38
39
40
41
42
43
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");

44
unsigned max_user_congthresh;
45
46
47
48
49
50
51
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
52
53
#define FUSE_SUPER_MAGIC 0x65735546

Miklos Szeredi's avatar
Miklos Szeredi committed
54
55
#define FUSE_DEFAULT_BLKSIZE 512

56
57
58
59
60
61
/** 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
62
63
64
struct fuse_mount_data {
	int fd;
	unsigned rootmode;
65
66
	kuid_t user_id;
	kgid_t group_id;
Miklos Szeredi's avatar
Miklos Szeredi committed
67
68
69
70
	unsigned fd_present:1;
	unsigned rootmode_present:1;
	unsigned user_id_present:1;
	unsigned group_id_present:1;
Miklos Szeredi's avatar
Miklos Szeredi committed
71
72
	unsigned default_permissions:1;
	unsigned allow_other:1;
73
	unsigned max_read;
74
	unsigned blksize;
Miklos Szeredi's avatar
Miklos Szeredi committed
75
76
};

77
struct fuse_forget_link *fuse_alloc_forget(void)
78
79
80
81
{
	return kzalloc(sizeof(struct fuse_forget_link), GFP_KERNEL);
}

Miklos Szeredi's avatar
Miklos Szeredi committed
82
83
84
85
86
static struct inode *fuse_alloc_inode(struct super_block *sb)
{
	struct inode *inode;
	struct fuse_inode *fi;

87
	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
Miklos Szeredi's avatar
Miklos Szeredi committed
88
89
90
91
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
92
	fi->i_time = 0;
93
	fi->inval_mask = 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
94
	fi->nodeid = 0;
95
	fi->nlookup = 0;
96
	fi->attr_version = 0;
97
	fi->orig_ino = 0;
98
	fi->state = 0;
99
	mutex_init(&fi->mutex);
100
101
	fi->forget = fuse_alloc_forget();
	if (!fi->forget) {
102
103
104
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
105
106
107
108

	return inode;
}

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

Miklos Szeredi's avatar
Miklos Szeredi committed
115
116
static void fuse_destroy_inode(struct inode *inode)
{
117
	struct fuse_inode *fi = get_fuse_inode(inode);
118
	if (S_ISREG(inode->i_mode) && !is_bad_inode(inode)) {
119
120
121
		WARN_ON(!list_empty(&fi->write_files));
		WARN_ON(!list_empty(&fi->queued_writes));
	}
122
	mutex_destroy(&fi->mutex);
123
	kfree(fi->forget);
Nick Piggin's avatar
Nick Piggin committed
124
	call_rcu(&inode->i_rcu, fuse_i_callback);
Miklos Szeredi's avatar
Miklos Szeredi committed
125
126
}

127
static void fuse_evict_inode(struct inode *inode)
Miklos Szeredi's avatar
Miklos Szeredi committed
128
{
129
	truncate_inode_pages_final(&inode->i_data);
130
	clear_inode(inode);
131
	if (inode->i_sb->s_flags & SB_ACTIVE) {
Miklos Szeredi's avatar
Miklos Szeredi committed
132
		struct fuse_conn *fc = get_fuse_conn(inode);
133
		struct fuse_inode *fi = get_fuse_inode(inode);
134
135
		fuse_queue_forget(fc, fi->forget, fi->nodeid, fi->nlookup);
		fi->forget = NULL;
136
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
137
138
}

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

	return 0;
}

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

166
167
	fi->attr_version = ++fc->attr_version;
	fi->i_time = attr_valid;
168
	WRITE_ONCE(fi->inval_mask, 0);
169

170
	inode->i_ino     = fuse_squash_ino(attr->ino);
171
	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
Miklos Szeredi's avatar
Miklos Szeredi committed
172
	set_nlink(inode, attr->nlink);
173
174
	inode->i_uid     = make_kuid(fc->user_ns, attr->uid);
	inode->i_gid     = make_kgid(fc->user_ns, attr->gid);
Miklos Szeredi's avatar
Miklos Szeredi committed
175
176
177
	inode->i_blocks  = attr->blocks;
	inode->i_atime.tv_sec   = attr->atime;
	inode->i_atime.tv_nsec  = attr->atimensec;
178
179
180
181
	/* 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;
182
183
		inode->i_ctime.tv_sec   = attr->ctime;
		inode->i_ctime.tv_nsec  = attr->ctimensec;
184
	}
185

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

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;
Miklos Szeredi's avatar
Miklos Szeredi committed
197
	if (!fc->default_permissions)
198
		inode->i_mode &= ~S_ISVTX;
199
200

	fi->orig_ino = attr->ino;
Miklos Szeredi's avatar
Miklos Szeredi committed
201
202
203
204
205
206
207
}

void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
			    u64 attr_valid, u64 attr_version)
{
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_inode *fi = get_fuse_inode(inode);
208
	bool is_wb = fc->writeback_cache;
Miklos Szeredi's avatar
Miklos Szeredi committed
209
	loff_t oldsize;
210
	struct timespec64 old_mtime;
Miklos Szeredi's avatar
Miklos Szeredi committed
211
212

	spin_lock(&fc->lock);
213
214
	if ((attr_version != 0 && fi->attr_version > attr_version) ||
	    test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) {
Miklos Szeredi's avatar
Miklos Szeredi committed
215
216
217
218
		spin_unlock(&fc->lock);
		return;
	}

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

222
	oldsize = inode->i_size;
223
224
225
226
227
228
229
	/*
	 * 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);
230
231
	spin_unlock(&fc->lock);

232
	if (!is_wb && S_ISREG(inode->i_mode)) {
233
234
235
		bool inval = false;

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

			/*
			 * Auto inval mode also checks and invalidates if mtime
			 * has changed.
			 */
248
			if (!timespec64_equal(&old_mtime, &new_mtime))
249
250
251
252
253
				inval = true;
		}

		if (inval)
			invalidate_inode_pages2(inode->i_mapping);
254
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
255
256
257
258
259
}

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

John Muir's avatar
John Muir committed
281
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
Miklos Szeredi's avatar
Miklos Szeredi committed
282
{
Miklos Szeredi's avatar
Miklos Szeredi committed
283
	u64 nodeid = *(u64 *) _nodeidp;
Miklos Szeredi's avatar
Miklos Szeredi committed
284
285
286
287
288
289
290
291
	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
292
	u64 nodeid = *(u64 *) _nodeidp;
Miklos Szeredi's avatar
Miklos Szeredi committed
293
294
295
296
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

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

324
	fi = get_fuse_inode(inode);
325
	spin_lock(&fc->lock);
Miklos Szeredi's avatar
Miklos Szeredi committed
326
	fi->nlookup++;
327
	spin_unlock(&fc->lock);
328
329
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

Miklos Szeredi's avatar
Miklos Szeredi committed
330
331
332
	return inode;
}

John Muir's avatar
John Muir committed
333
334
335
336
337
338
339
340
341
342
343
344
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);
Seth Forshee's avatar
Seth Forshee committed
345
	forget_all_cached_acls(inode);
John Muir's avatar
John Muir committed
346
	if (offset >= 0) {
347
		pg_start = offset >> PAGE_SHIFT;
John Muir's avatar
John Muir committed
348
349
350
		if (len <= 0)
			pg_end = -1;
		else
351
			pg_end = (offset + len - 1) >> PAGE_SHIFT;
John Muir's avatar
John Muir committed
352
353
354
355
356
357
358
		invalidate_inode_pages2_range(inode->i_mapping,
					      pg_start, pg_end);
	}
	iput(inode);
	return 0;
}

359
bool fuse_lock_inode(struct inode *inode)
360
{
361
362
363
	bool locked = false;

	if (!get_fuse_conn(inode)->parallel_dirops) {
364
		mutex_lock(&get_fuse_inode(inode)->mutex);
365
366
367
368
		locked = true;
	}

	return locked;
369
370
}

371
void fuse_unlock_inode(struct inode *inode, bool locked)
372
{
373
	if (locked)
374
375
376
		mutex_unlock(&get_fuse_inode(inode)->mutex);
}

377
static void fuse_umount_begin(struct super_block *sb)
378
{
379
	fuse_abort_conn(get_fuse_conn_super(sb), false);
380
381
}

382
383
384
385
386
387
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
388
389
		__set_bit(FR_FORCE, &req->flags);
		__clear_bit(FR_BACKGROUND, &req->flags);
390
		fuse_request_send(fc, req);
391
392
393
394
		fuse_put_request(fc, req);
	}
}

395
396
397
398
static void fuse_put_super(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

Miklos Szeredi's avatar
Miklos Szeredi committed
399
400
401
402
403
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);

404
	fuse_conn_put(fc);
Miklos Szeredi's avatar
Miklos Szeredi committed
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
	struct fuse_conn *fc = get_fuse_conn_super(sb);
425
	FUSE_ARGS(args);
426
427
428
	struct fuse_statfs_out outarg;
	int err;

429
	if (!fuse_allow_current_process(fc)) {
Miklos Szeredi's avatar
Miklos Szeredi committed
430
431
432
433
		buf->f_type = FUSE_SUPER_MAGIC;
		return 0;
	}

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

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

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

471
472
473
474
475
476
477
478
479
480
481
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;
}

482
483
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev,
			  struct user_namespace *user_ns)
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(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(user_ns, uv);
529
530
			if (!gid_valid(d->group_id))
				return 0;
531
			d->group_id_present = 1;
532
533
			break;

Miklos Szeredi's avatar
Miklos Szeredi committed
534
		case OPT_DEFAULT_PERMISSIONS:
Miklos Szeredi's avatar
Miklos Szeredi committed
535
			d->default_permissions = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
536
537
538
			break;

		case OPT_ALLOW_OTHER:
Miklos Szeredi's avatar
Miklos Szeredi committed
539
			d->allow_other = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
540
541
			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(fc->user_ns, fc->user_id));
	seq_printf(m, ",group_id=%u", from_kgid_munged(fc->user_ns, fc->group_id));
Miklos Szeredi's avatar
Miklos Szeredi committed
573
	if (fc->default_permissions)
Miklos Szeredi's avatar
Miklos Szeredi committed
574
		seq_puts(m, ",default_permissions");
Miklos Szeredi's avatar
Miklos Szeredi committed
575
	if (fc->allow_other)
Miklos Szeredi's avatar
Miklos Szeredi committed
576
		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
static void fuse_pqueue_init(struct fuse_pqueue *fpq)
{
596
597
	unsigned int i;

Miklos Szeredi's avatar
Miklos Szeredi committed
598
	spin_lock_init(&fpq->lock);
599
600
	for (i = 0; i < FUSE_PQ_HASH_SIZE; i++)
		INIT_LIST_HEAD(&fpq->processing[i]);
601
	INIT_LIST_HEAD(&fpq->io);
602
	fpq->connected = 1;
603
604
}

605
void fuse_conn_init(struct fuse_conn *fc, struct user_namespace *user_ns)
Miklos Szeredi's avatar
Miklos Szeredi committed
606
{
607
608
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
Kirill Tkhai's avatar
Kirill Tkhai committed
609
	spin_lock_init(&fc->bg_lock);
John Muir's avatar
John Muir committed
610
	init_rwsem(&fc->killsb);
611
	refcount_set(&fc->count, 1);
612
	atomic_set(&fc->dev_count, 1);
613
614
	init_waitqueue_head(&fc->blocked_waitq);
	init_waitqueue_head(&fc->reserved_req_waitq);
615
	fuse_iqueue_init(&fc->iq);
616
617
	INIT_LIST_HEAD(&fc->bg_queue);
	INIT_LIST_HEAD(&fc->entry);
618
	INIT_LIST_HEAD(&fc->devices);
619
	atomic_set(&fc->num_waiting, 0);
620
621
	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
622
623
	fc->khctr = 0;
	fc->polled_files = RB_ROOT;
624
	fc->blocked = 0;
625
	fc->initialized = 0;
626
	fc->connected = 1;
627
628
	fc->attr_version = 1;
	get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
629
	fc->pid_ns = get_pid_ns(task_active_pid_ns(current));
630
	fc->user_ns = get_user_ns(user_ns);
Miklos Szeredi's avatar
Miklos Szeredi committed
631
}
632
EXPORT_SYMBOL_GPL(fuse_conn_init);
Miklos Szeredi's avatar
Miklos Szeredi committed
633

634
635
void fuse_conn_put(struct fuse_conn *fc)
{
636
	if (refcount_dec_and_test(&fc->count)) {
637
638
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
639
		put_pid_ns(fc->pid_ns);
640
		put_user_ns(fc->user_ns);
Tejun Heo's avatar
Tejun Heo committed
641
		fc->release(fc);
642
	}
643
}
644
EXPORT_SYMBOL_GPL(fuse_conn_put);
645
646
647

struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
{
648
	refcount_inc(&fc->count);
649
650
	return fc;
}
651
EXPORT_SYMBOL_GPL(fuse_conn_get);
652

653
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
Miklos Szeredi's avatar
Miklos Szeredi committed
654
655
656
657
658
659
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
660
	attr.nlink = 1;
661
	return fuse_iget(sb, 1, 0, &attr, 0, 0);
Miklos Szeredi's avatar
Miklos Szeredi committed
662
663
}

Miklos Szeredi's avatar
Miklos Szeredi committed
664
struct fuse_inode_handle {
Miklos Szeredi's avatar
Miklos Szeredi committed
665
666
667
668
669
670
671
	u64 nodeid;
	u32 generation;
};

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
672
	struct fuse_conn *fc = get_fuse_conn_super(sb);
Miklos Szeredi's avatar
Miklos Szeredi committed
673
674
675
676
677
678
679
680
	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);
681
682
	if (!inode) {
		struct fuse_entry_out outarg;
Al Viro's avatar
Al Viro committed
683
		const struct qstr name = QSTR_INIT(".", 1);
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699

		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;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
700
701
702
703
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

704
	entry = d_obtain_alias(inode);
Al Viro's avatar
Al Viro committed
705
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
Miklos Szeredi's avatar
Miklos Szeredi committed
706
707
708
709
710
711
712
713
714
715
		fuse_invalidate_entry_cache(entry);

	return entry;

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

Al Viro's avatar
Al Viro committed
716
717
static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
			   struct inode *parent)
Miklos Szeredi's avatar
Miklos Szeredi committed
718
{
Al Viro's avatar
Al Viro committed
719
	int len = parent ? 6 : 3;
Miklos Szeredi's avatar
Miklos Szeredi committed
720
721
722
	u64 nodeid;
	u32 generation;

723
724
	if (*max_len < len) {
		*max_len = len;
725
		return  FILEID_INVALID;
726
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
727
728
729
730
731
732
733
734

	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
735
	if (parent) {
Miklos Szeredi's avatar
Miklos Szeredi committed
736
737
738
739
740
741
742
743
744
		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
745
	return parent ? 0x82 : 0x81;
Miklos Szeredi's avatar
Miklos Szeredi committed
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
771
772
773
774
775
}

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

776
777
static struct dentry *fuse_get_parent(struct dentry *child)
{
778
	struct inode *child_inode = d_inode(child);
779
780
781
782
	struct fuse_conn *fc = get_fuse_conn(child_inode);
	struct inode *inode;
	struct dentry *parent;
	struct fuse_entry_out outarg;
Al Viro's avatar
Al Viro committed
783
	const struct qstr name = QSTR_INIT("..", 2);
784
785
786
787
788
789
790
	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);
791
792
793
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
794
795
		return ERR_PTR(err);
	}
796
797

	parent = d_obtain_alias(inode);
Al Viro's avatar
Al Viro committed
798
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
799
800
801
802
		fuse_invalidate_entry_cache(parent);

	return parent;
}
Miklos Szeredi's avatar
Miklos Szeredi committed
803
804
805
806
807

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,
808
	.get_parent	= fuse_get_parent,
Miklos Szeredi's avatar
Miklos Szeredi committed
809
810
};

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

824
825
826
static void sanitize_global_limit(unsigned *limit)
{
	if (*limit == 0)
827
		*limit = ((totalram_pages << PAGE_SHIFT) >> 13) /
828
829
830
831
832
833
			 sizeof(struct fuse_req);

	if (*limit >= 1 << 16)
		*limit = (1 << 16) - 1;
}

834
static int set_global_limit(const char *val, const struct kernel_param *kp)
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
{
	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);

Kirill Tkhai's avatar
Kirill Tkhai committed
857
	spin_lock(&fc->bg_lock);
858
859
860
861
862
863
864
865
866
867
868
869
870
	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;
	}
Kirill Tkhai's avatar
Kirill Tkhai committed
871
	spin_unlock(&fc->bg_lock);
872
873
}

874
875
876
877
878
879
880
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 {
881
882
		unsigned long ra_pages;

883
884
		process_init_limits(fc, arg);

885
		if (arg->minor >= 6) {
886
			ra_pages = arg->max_readahead / PAGE_SIZE;
887
888
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
889
890
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
891
892
893
			if (arg->minor >= 17) {
				if (!(arg->flags & FUSE_FLOCK_LOCKS))
					fc->no_flock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
894
895
896
			} else {
				if (!(arg->flags & FUSE_POSIX_LOCKS))
					fc->no_flock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
897
			}
898
899
			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
				fc->atomic_o_trunc = 1;
900
901
902
903
904
			if (arg->minor >= 9) {
				/* LOOKUP has dependency on proto version */
				if (arg->flags & FUSE_EXPORT_SUPPORT)
					fc->export_support = 1;
			}
905
906
			if (arg->flags & FUSE_BIG_WRITES)
				fc->big_writes = 1;
907
908
			if (arg->flags & FUSE_DONT_MASK)
				fc->dont_mask = 1;
909
910
			if (arg->flags & FUSE_AUTO_INVAL_DATA)
				fc->auto_inval_data = 1;
911
			if (arg->flags & FUSE_DO_READDIRPLUS) {
912
				fc->do_readdirplus = 1;
913
914
915
				if (arg->flags & FUSE_READDIRPLUS_AUTO)
					fc->readdirplus_auto = 1;
			}
916
917
			if (arg->flags & FUSE_ASYNC_DIO)
				fc->async_dio = 1;
918
919
			if (arg->flags & FUSE_WRITEBACK_CACHE)
				fc->writeback_cache = 1;
920
921
			if (arg->flags & FUSE_PARALLEL_DIROPS)
				fc->parallel_dirops = 1;
922
923
			if (arg->flags & FUSE_HANDLE_KILLPRIV)
				fc->handle_killpriv = 1;
924
925
			if (arg->time_gran && arg->time_gran <= 1000000000)
				fc->sb->s_time_gran = arg->time_gran;
Seth Forshee's avatar
Seth Forshee committed
926
			if ((arg->flags & FUSE_POSIX_ACL)) {
Miklos Szeredi's avatar
Miklos Szeredi committed
927
				fc->default_permissions = 1;
Seth Forshee's avatar
Seth Forshee committed
928
929
930
				fc->posix_acl = 1;
				fc->sb->s_xattr = fuse_acl_xattr_handlers;
			}
931
932
			if (arg->flags & FUSE_CACHE_SYMLINKS)
				fc->cache_symlinks = 1;
933
934
			if (arg->flags & FUSE_ABORT_ERROR)
				fc->abort_err = 1;
935
936
937
938
939
			if (arg->flags & FUSE_MAX_PAGES) {
				fc->max_pages =
					min_t(unsigned int, FUSE_MAX_MAX_PAGES,
					max_t(unsigned int, arg->max_pages, 1));
			}
940
		} else {
941
			ra_pages = fc->max_read / PAGE_SIZE;
942
			fc->no_lock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
943
			fc->no_flock = 1;
944
		}
945

946
947
		fc->sb->s_bdi->ra_pages =
				min(fc->sb->s_bdi->ra_pages, ra_pages);
948
949
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
950
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
951
		fc->conn_init = 1;
952
	}
953
	fuse_set_initialized(fc);
954
	wake_up_all(&fc->blocked_waitq);
955
956
}

957
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
958
959
{
	struct fuse_init_in *arg = &req->misc.init_in;
960

961
962
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
963
	arg->max_readahead = fc->sb->s_bdi->ra_pages * PAGE_SIZE;
964
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
Miklos Szeredi's avatar
Miklos Szeredi committed
965
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
Miklos Szeredi's avatar
Miklos Szeredi committed
966
		FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
967
		FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
968
		FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
969
		FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT |
970
		FUSE_PARALLEL_DIROPS | FUSE_HANDLE_KILLPRIV | FUSE_POSIX_ACL |
971
		FUSE_ABORT_ERROR | FUSE_MAX_PAGES | FUSE_CACHE_SYMLINKS;
972
973
974
975
976
	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;
977
	/* Variable length argument used for backward compatibility
978
979
980
981
982
983
	   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;
984
	fuse_request_send_background(fc, req);
985
986
}

Tejun Heo's avatar
Tejun Heo committed
987
988
static void fuse_free_conn(struct fuse_conn *fc)
{
989
	WARN_ON(!list_empty(&fc->devices));
Al Viro's avatar
Al Viro committed
990
	kfree_rcu(fc, rcu);
Tejun Heo's avatar
Tejun Heo committed
991
992
}

993
994
995
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;
996
	char *suffix = "";
997

998
	if (sb->s_bdev) {
999
		suffix = "-fuseblk";
1000
1001
1002
1003
1004
1005
1006
		/*
		 * sb->s_bdi points to blkdev's bdi however we want to redirect
		 * it to our private bdi...
		 */
		bdi_put(sb->s_bdi);
		sb->s_bdi = &noop_backing_dev_info;
	}
1007
1008
	err = super_setup_bdi_name(sb, "%u:%u%s", MAJOR(fc->dev),
				   MINOR(fc->dev), suffix);
1009
1010
1011
	if (err)
		return err;

1012
1013
1014
	sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE;
	/* fuse does it's own writeback accounting */
	sb->s_bdi->capabilities = BDI_CAP_NO_ACCT_WB | BDI_CAP_STRICTLIMIT;
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027

	/*
	 * 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
	 */
1028
	bdi_set_max_ratio(sb->s_bdi, 1);
1029
1030
1031
1032

	return 0;
}

1033
1034
1035
struct fuse_dev *fuse_dev_alloc(struct fuse_conn *fc)
{
	struct fuse_dev *fud;
1036
	struct list_head *pq;
1037
1038

	fud = kzalloc(sizeof(struct fuse_dev), GFP_KERNEL);
1039
1040
	if (!fud)
		return NULL;
1041

1042
1043
1044
1045
	pq = kcalloc(FUSE_PQ_HASH_SIZE, sizeof(struct list_head), GFP_KERNEL);
	if (!pq) {
		kfree(fud);
		return NULL;