1/*
2  FUSE: Filesystem in Userspace
3  Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
4
5  This program can be distributed under the terms of the GNU GPL.
6  See the file COPYING.
7*/
8
9#include "fuse_i.h"
10
11#include <linux/pagemap.h>
12#include <linux/slab.h>
13#include <linux/file.h>
14#include <linux/seq_file.h>
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/moduleparam.h>
18#include <linux/parser.h>
19#include <linux/statfs.h>
20#include <linux/random.h>
21#include <linux/sched.h>
22#include <linux/exportfs.h>
23
24MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
25MODULE_DESCRIPTION("Filesystem in Userspace");
26MODULE_LICENSE("GPL");
27
28static struct kmem_cache *fuse_inode_cachep;
29struct list_head fuse_conn_list;
30DEFINE_MUTEX(fuse_mutex);
31
32static int set_global_limit(const char *val, struct kernel_param *kp);
33
34unsigned max_user_bgreq;
35module_param_call(max_user_bgreq, set_global_limit, param_get_uint,
36		  &max_user_bgreq, 0644);
37__MODULE_PARM_TYPE(max_user_bgreq, "uint");
38MODULE_PARM_DESC(max_user_bgreq,
39 "Global limit for the maximum number of backgrounded requests an "
40 "unprivileged user can set");
41
42unsigned max_user_congthresh;
43module_param_call(max_user_congthresh, set_global_limit, param_get_uint,
44		  &max_user_congthresh, 0644);
45__MODULE_PARM_TYPE(max_user_congthresh, "uint");
46MODULE_PARM_DESC(max_user_congthresh,
47 "Global limit for the maximum congestion threshold an "
48 "unprivileged user can set");
49
50#define FUSE_SUPER_MAGIC 0x65735546
51
52#define FUSE_DEFAULT_BLKSIZE 512
53
54/** Maximum number of outstanding background requests */
55#define FUSE_DEFAULT_MAX_BACKGROUND 12
56
57/** Congestion starts at 75% of maximum */
58#define FUSE_DEFAULT_CONGESTION_THRESHOLD (FUSE_DEFAULT_MAX_BACKGROUND * 3 / 4)
59
60struct fuse_mount_data {
61	int fd;
62	unsigned rootmode;
63	kuid_t user_id;
64	kgid_t group_id;
65	unsigned fd_present:1;
66	unsigned rootmode_present:1;
67	unsigned user_id_present:1;
68	unsigned group_id_present:1;
69	unsigned flags;
70	unsigned max_read;
71	unsigned blksize;
72};
73
74struct fuse_forget_link *fuse_alloc_forget(void)
75{
76	return kzalloc(sizeof(struct fuse_forget_link), GFP_KERNEL);
77}
78
79static struct inode *fuse_alloc_inode(struct super_block *sb)
80{
81	struct inode *inode;
82	struct fuse_inode *fi;
83
84	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
85	if (!inode)
86		return NULL;
87
88	fi = get_fuse_inode(inode);
89	fi->i_time = 0;
90	fi->nodeid = 0;
91	fi->nlookup = 0;
92	fi->attr_version = 0;
93	fi->writectr = 0;
94	fi->orig_ino = 0;
95	fi->state = 0;
96	INIT_LIST_HEAD(&fi->write_files);
97	INIT_LIST_HEAD(&fi->queued_writes);
98	INIT_LIST_HEAD(&fi->writepages);
99	init_waitqueue_head(&fi->page_waitq);
100	fi->forget = fuse_alloc_forget();
101	if (!fi->forget) {
102		kmem_cache_free(fuse_inode_cachep, inode);
103		return NULL;
104	}
105
106	return inode;
107}
108
109static void fuse_i_callback(struct rcu_head *head)
110{
111	struct inode *inode = container_of(head, struct inode, i_rcu);
112	kmem_cache_free(fuse_inode_cachep, inode);
113}
114
115static void fuse_destroy_inode(struct inode *inode)
116{
117	struct fuse_inode *fi = get_fuse_inode(inode);
118	BUG_ON(!list_empty(&fi->write_files));
119	BUG_ON(!list_empty(&fi->queued_writes));
120	kfree(fi->forget);
121	call_rcu(&inode->i_rcu, fuse_i_callback);
122}
123
124static void fuse_evict_inode(struct inode *inode)
125{
126	truncate_inode_pages_final(&inode->i_data);
127	clear_inode(inode);
128	if (inode->i_sb->s_flags & MS_ACTIVE) {
129		struct fuse_conn *fc = get_fuse_conn(inode);
130		struct fuse_inode *fi = get_fuse_inode(inode);
131		fuse_queue_forget(fc, fi->forget, fi->nodeid, fi->nlookup);
132		fi->forget = NULL;
133	}
134}
135
136static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
137{
138	sync_filesystem(sb);
139	if (*flags & MS_MANDLOCK)
140		return -EINVAL;
141
142	return 0;
143}
144
145/*
146 * ino_t is 32-bits on 32-bit arch. We have to squash the 64-bit value down
147 * so that it will fit.
148 */
149static ino_t fuse_squash_ino(u64 ino64)
150{
151	ino_t ino = (ino_t) ino64;
152	if (sizeof(ino_t) < sizeof(u64))
153		ino ^= ino64 >> (sizeof(u64) - sizeof(ino_t)) * 8;
154	return ino;
155}
156
157void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
158				   u64 attr_valid)
159{
160	struct fuse_conn *fc = get_fuse_conn(inode);
161	struct fuse_inode *fi = get_fuse_inode(inode);
162
163	fi->attr_version = ++fc->attr_version;
164	fi->i_time = attr_valid;
165
166	inode->i_ino     = fuse_squash_ino(attr->ino);
167	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
168	set_nlink(inode, attr->nlink);
169	inode->i_uid     = make_kuid(&init_user_ns, attr->uid);
170	inode->i_gid     = make_kgid(&init_user_ns, attr->gid);
171	inode->i_blocks  = attr->blocks;
172	inode->i_atime.tv_sec   = attr->atime;
173	inode->i_atime.tv_nsec  = attr->atimensec;
174	/* mtime from server may be stale due to local buffered write */
175	if (!fc->writeback_cache || !S_ISREG(inode->i_mode)) {
176		inode->i_mtime.tv_sec   = attr->mtime;
177		inode->i_mtime.tv_nsec  = attr->mtimensec;
178		inode->i_ctime.tv_sec   = attr->ctime;
179		inode->i_ctime.tv_nsec  = attr->ctimensec;
180	}
181
182	if (attr->blksize != 0)
183		inode->i_blkbits = ilog2(attr->blksize);
184	else
185		inode->i_blkbits = inode->i_sb->s_blocksize_bits;
186
187	/*
188	 * Don't set the sticky bit in i_mode, unless we want the VFS
189	 * to check permissions.  This prevents failures due to the
190	 * check in may_delete().
191	 */
192	fi->orig_i_mode = inode->i_mode;
193	if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
194		inode->i_mode &= ~S_ISVTX;
195
196	fi->orig_ino = attr->ino;
197}
198
199void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
200			    u64 attr_valid, u64 attr_version)
201{
202	struct fuse_conn *fc = get_fuse_conn(inode);
203	struct fuse_inode *fi = get_fuse_inode(inode);
204	bool is_wb = fc->writeback_cache;
205	loff_t oldsize;
206	struct timespec old_mtime;
207
208	spin_lock(&fc->lock);
209	if ((attr_version != 0 && fi->attr_version > attr_version) ||
210	    test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) {
211		spin_unlock(&fc->lock);
212		return;
213	}
214
215	old_mtime = inode->i_mtime;
216	fuse_change_attributes_common(inode, attr, attr_valid);
217
218	oldsize = inode->i_size;
219	/*
220	 * In case of writeback_cache enabled, the cached writes beyond EOF
221	 * extend local i_size without keeping userspace server in sync. So,
222	 * attr->size coming from server can be stale. We cannot trust it.
223	 */
224	if (!is_wb || !S_ISREG(inode->i_mode))
225		i_size_write(inode, attr->size);
226	spin_unlock(&fc->lock);
227
228	if (!is_wb && S_ISREG(inode->i_mode)) {
229		bool inval = false;
230
231		if (oldsize != attr->size) {
232			truncate_pagecache(inode, attr->size);
233			inval = true;
234		} else if (fc->auto_inval_data) {
235			struct timespec new_mtime = {
236				.tv_sec = attr->mtime,
237				.tv_nsec = attr->mtimensec,
238			};
239
240			/*
241			 * Auto inval mode also checks and invalidates if mtime
242			 * has changed.
243			 */
244			if (!timespec_equal(&old_mtime, &new_mtime))
245				inval = true;
246		}
247
248		if (inval)
249			invalidate_inode_pages2(inode->i_mapping);
250	}
251}
252
253static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
254{
255	inode->i_mode = attr->mode & S_IFMT;
256	inode->i_size = attr->size;
257	inode->i_mtime.tv_sec  = attr->mtime;
258	inode->i_mtime.tv_nsec = attr->mtimensec;
259	inode->i_ctime.tv_sec  = attr->ctime;
260	inode->i_ctime.tv_nsec = attr->ctimensec;
261	if (S_ISREG(inode->i_mode)) {
262		fuse_init_common(inode);
263		fuse_init_file_inode(inode);
264	} else if (S_ISDIR(inode->i_mode))
265		fuse_init_dir(inode);
266	else if (S_ISLNK(inode->i_mode))
267		fuse_init_symlink(inode);
268	else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
269		 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
270		fuse_init_common(inode);
271		init_special_inode(inode, inode->i_mode,
272				   new_decode_dev(attr->rdev));
273	} else
274		BUG();
275}
276
277int fuse_inode_eq(struct inode *inode, void *_nodeidp)
278{
279	u64 nodeid = *(u64 *) _nodeidp;
280	if (get_node_id(inode) == nodeid)
281		return 1;
282	else
283		return 0;
284}
285
286static int fuse_inode_set(struct inode *inode, void *_nodeidp)
287{
288	u64 nodeid = *(u64 *) _nodeidp;
289	get_fuse_inode(inode)->nodeid = nodeid;
290	return 0;
291}
292
293struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
294			int generation, struct fuse_attr *attr,
295			u64 attr_valid, u64 attr_version)
296{
297	struct inode *inode;
298	struct fuse_inode *fi;
299	struct fuse_conn *fc = get_fuse_conn_super(sb);
300
301 retry:
302	inode = iget5_locked(sb, nodeid, fuse_inode_eq, fuse_inode_set, &nodeid);
303	if (!inode)
304		return NULL;
305
306	if ((inode->i_state & I_NEW)) {
307		inode->i_flags |= S_NOATIME;
308		if (!fc->writeback_cache || !S_ISREG(attr->mode))
309			inode->i_flags |= S_NOCMTIME;
310		inode->i_generation = generation;
311		fuse_init_inode(inode, attr);
312		unlock_new_inode(inode);
313	} else if ((inode->i_mode ^ attr->mode) & S_IFMT) {
314		/* Inode has changed type, any I/O on the old should fail */
315		make_bad_inode(inode);
316		iput(inode);
317		goto retry;
318	}
319
320	fi = get_fuse_inode(inode);
321	spin_lock(&fc->lock);
322	fi->nlookup++;
323	spin_unlock(&fc->lock);
324	fuse_change_attributes(inode, attr, attr_valid, attr_version);
325
326	return inode;
327}
328
329int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid,
330			     loff_t offset, loff_t len)
331{
332	struct inode *inode;
333	pgoff_t pg_start;
334	pgoff_t pg_end;
335
336	inode = ilookup5(sb, nodeid, fuse_inode_eq, &nodeid);
337	if (!inode)
338		return -ENOENT;
339
340	fuse_invalidate_attr(inode);
341	if (offset >= 0) {
342		pg_start = offset >> PAGE_CACHE_SHIFT;
343		if (len <= 0)
344			pg_end = -1;
345		else
346			pg_end = (offset + len - 1) >> PAGE_CACHE_SHIFT;
347		invalidate_inode_pages2_range(inode->i_mapping,
348					      pg_start, pg_end);
349	}
350	iput(inode);
351	return 0;
352}
353
354static void fuse_umount_begin(struct super_block *sb)
355{
356	fuse_abort_conn(get_fuse_conn_super(sb));
357}
358
359static void fuse_send_destroy(struct fuse_conn *fc)
360{
361	struct fuse_req *req = fc->destroy_req;
362	if (req && fc->conn_init) {
363		fc->destroy_req = NULL;
364		req->in.h.opcode = FUSE_DESTROY;
365		req->force = 1;
366		req->background = 0;
367		fuse_request_send(fc, req);
368		fuse_put_request(fc, req);
369	}
370}
371
372static void fuse_bdi_destroy(struct fuse_conn *fc)
373{
374	if (fc->bdi_initialized)
375		bdi_destroy(&fc->bdi);
376}
377
378static void fuse_put_super(struct super_block *sb)
379{
380	struct fuse_conn *fc = get_fuse_conn_super(sb);
381
382	fuse_send_destroy(fc);
383
384	fuse_abort_conn(fc);
385	mutex_lock(&fuse_mutex);
386	list_del(&fc->entry);
387	fuse_ctl_remove_conn(fc);
388	mutex_unlock(&fuse_mutex);
389	fuse_bdi_destroy(fc);
390
391	fuse_conn_put(fc);
392}
393
394static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
395{
396	stbuf->f_type    = FUSE_SUPER_MAGIC;
397	stbuf->f_bsize   = attr->bsize;
398	stbuf->f_frsize  = attr->frsize;
399	stbuf->f_blocks  = attr->blocks;
400	stbuf->f_bfree   = attr->bfree;
401	stbuf->f_bavail  = attr->bavail;
402	stbuf->f_files   = attr->files;
403	stbuf->f_ffree   = attr->ffree;
404	stbuf->f_namelen = attr->namelen;
405	/* fsid is left zero */
406}
407
408static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
409{
410	struct super_block *sb = dentry->d_sb;
411	struct fuse_conn *fc = get_fuse_conn_super(sb);
412	FUSE_ARGS(args);
413	struct fuse_statfs_out outarg;
414	int err;
415
416	if (!fuse_allow_current_process(fc)) {
417		buf->f_type = FUSE_SUPER_MAGIC;
418		return 0;
419	}
420
421	memset(&outarg, 0, sizeof(outarg));
422	args.in.numargs = 0;
423	args.in.h.opcode = FUSE_STATFS;
424	args.in.h.nodeid = get_node_id(d_inode(dentry));
425	args.out.numargs = 1;
426	args.out.args[0].size = sizeof(outarg);
427	args.out.args[0].value = &outarg;
428	err = fuse_simple_request(fc, &args);
429	if (!err)
430		convert_fuse_statfs(buf, &outarg.st);
431	return err;
432}
433
434enum {
435	OPT_FD,
436	OPT_ROOTMODE,
437	OPT_USER_ID,
438	OPT_GROUP_ID,
439	OPT_DEFAULT_PERMISSIONS,
440	OPT_ALLOW_OTHER,
441	OPT_MAX_READ,
442	OPT_BLKSIZE,
443	OPT_ERR
444};
445
446static const match_table_t tokens = {
447	{OPT_FD,			"fd=%u"},
448	{OPT_ROOTMODE,			"rootmode=%o"},
449	{OPT_USER_ID,			"user_id=%u"},
450	{OPT_GROUP_ID,			"group_id=%u"},
451	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
452	{OPT_ALLOW_OTHER,		"allow_other"},
453	{OPT_MAX_READ,			"max_read=%u"},
454	{OPT_BLKSIZE,			"blksize=%u"},
455	{OPT_ERR,			NULL}
456};
457
458static int fuse_match_uint(substring_t *s, unsigned int *res)
459{
460	int err = -ENOMEM;
461	char *buf = match_strdup(s);
462	if (buf) {
463		err = kstrtouint(buf, 10, res);
464		kfree(buf);
465	}
466	return err;
467}
468
469static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
470{
471	char *p;
472	memset(d, 0, sizeof(struct fuse_mount_data));
473	d->max_read = ~0;
474	d->blksize = FUSE_DEFAULT_BLKSIZE;
475
476	while ((p = strsep(&opt, ",")) != NULL) {
477		int token;
478		int value;
479		unsigned uv;
480		substring_t args[MAX_OPT_ARGS];
481		if (!*p)
482			continue;
483
484		token = match_token(p, tokens, args);
485		switch (token) {
486		case OPT_FD:
487			if (match_int(&args[0], &value))
488				return 0;
489			d->fd = value;
490			d->fd_present = 1;
491			break;
492
493		case OPT_ROOTMODE:
494			if (match_octal(&args[0], &value))
495				return 0;
496			if (!fuse_valid_type(value))
497				return 0;
498			d->rootmode = value;
499			d->rootmode_present = 1;
500			break;
501
502		case OPT_USER_ID:
503			if (fuse_match_uint(&args[0], &uv))
504				return 0;
505			d->user_id = make_kuid(current_user_ns(), uv);
506			if (!uid_valid(d->user_id))
507				return 0;
508			d->user_id_present = 1;
509			break;
510
511		case OPT_GROUP_ID:
512			if (fuse_match_uint(&args[0], &uv))
513				return 0;
514			d->group_id = make_kgid(current_user_ns(), uv);
515			if (!gid_valid(d->group_id))
516				return 0;
517			d->group_id_present = 1;
518			break;
519
520		case OPT_DEFAULT_PERMISSIONS:
521			d->flags |= FUSE_DEFAULT_PERMISSIONS;
522			break;
523
524		case OPT_ALLOW_OTHER:
525			d->flags |= FUSE_ALLOW_OTHER;
526			break;
527
528		case OPT_MAX_READ:
529			if (match_int(&args[0], &value))
530				return 0;
531			d->max_read = value;
532			break;
533
534		case OPT_BLKSIZE:
535			if (!is_bdev || match_int(&args[0], &value))
536				return 0;
537			d->blksize = value;
538			break;
539
540		default:
541			return 0;
542		}
543	}
544
545	if (!d->fd_present || !d->rootmode_present ||
546	    !d->user_id_present || !d->group_id_present)
547		return 0;
548
549	return 1;
550}
551
552static int fuse_show_options(struct seq_file *m, struct dentry *root)
553{
554	struct super_block *sb = root->d_sb;
555	struct fuse_conn *fc = get_fuse_conn_super(sb);
556
557	seq_printf(m, ",user_id=%u", from_kuid_munged(&init_user_ns, fc->user_id));
558	seq_printf(m, ",group_id=%u", from_kgid_munged(&init_user_ns, fc->group_id));
559	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
560		seq_puts(m, ",default_permissions");
561	if (fc->flags & FUSE_ALLOW_OTHER)
562		seq_puts(m, ",allow_other");
563	if (fc->max_read != ~0)
564		seq_printf(m, ",max_read=%u", fc->max_read);
565	if (sb->s_bdev && sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
566		seq_printf(m, ",blksize=%lu", sb->s_blocksize);
567	return 0;
568}
569
570void fuse_conn_init(struct fuse_conn *fc)
571{
572	memset(fc, 0, sizeof(*fc));
573	spin_lock_init(&fc->lock);
574	init_rwsem(&fc->killsb);
575	atomic_set(&fc->count, 1);
576	init_waitqueue_head(&fc->waitq);
577	init_waitqueue_head(&fc->blocked_waitq);
578	init_waitqueue_head(&fc->reserved_req_waitq);
579	INIT_LIST_HEAD(&fc->pending);
580	INIT_LIST_HEAD(&fc->processing);
581	INIT_LIST_HEAD(&fc->io);
582	INIT_LIST_HEAD(&fc->interrupts);
583	INIT_LIST_HEAD(&fc->bg_queue);
584	INIT_LIST_HEAD(&fc->entry);
585	fc->forget_list_tail = &fc->forget_list_head;
586	atomic_set(&fc->num_waiting, 0);
587	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
588	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
589	fc->khctr = 0;
590	fc->polled_files = RB_ROOT;
591	fc->reqctr = 0;
592	fc->blocked = 0;
593	fc->initialized = 0;
594	fc->attr_version = 1;
595	get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
596}
597EXPORT_SYMBOL_GPL(fuse_conn_init);
598
599void fuse_conn_put(struct fuse_conn *fc)
600{
601	if (atomic_dec_and_test(&fc->count)) {
602		if (fc->destroy_req)
603			fuse_request_free(fc->destroy_req);
604		fc->release(fc);
605	}
606}
607EXPORT_SYMBOL_GPL(fuse_conn_put);
608
609struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
610{
611	atomic_inc(&fc->count);
612	return fc;
613}
614EXPORT_SYMBOL_GPL(fuse_conn_get);
615
616static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
617{
618	struct fuse_attr attr;
619	memset(&attr, 0, sizeof(attr));
620
621	attr.mode = mode;
622	attr.ino = FUSE_ROOT_ID;
623	attr.nlink = 1;
624	return fuse_iget(sb, 1, 0, &attr, 0, 0);
625}
626
627struct fuse_inode_handle {
628	u64 nodeid;
629	u32 generation;
630};
631
632static struct dentry *fuse_get_dentry(struct super_block *sb,
633				      struct fuse_inode_handle *handle)
634{
635	struct fuse_conn *fc = get_fuse_conn_super(sb);
636	struct inode *inode;
637	struct dentry *entry;
638	int err = -ESTALE;
639
640	if (handle->nodeid == 0)
641		goto out_err;
642
643	inode = ilookup5(sb, handle->nodeid, fuse_inode_eq, &handle->nodeid);
644	if (!inode) {
645		struct fuse_entry_out outarg;
646		struct qstr name;
647
648		if (!fc->export_support)
649			goto out_err;
650
651		name.len = 1;
652		name.name = ".";
653		err = fuse_lookup_name(sb, handle->nodeid, &name, &outarg,
654				       &inode);
655		if (err && err != -ENOENT)
656			goto out_err;
657		if (err || !inode) {
658			err = -ESTALE;
659			goto out_err;
660		}
661		err = -EIO;
662		if (get_node_id(inode) != handle->nodeid)
663			goto out_iput;
664	}
665	err = -ESTALE;
666	if (inode->i_generation != handle->generation)
667		goto out_iput;
668
669	entry = d_obtain_alias(inode);
670	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
671		fuse_invalidate_entry_cache(entry);
672
673	return entry;
674
675 out_iput:
676	iput(inode);
677 out_err:
678	return ERR_PTR(err);
679}
680
681static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
682			   struct inode *parent)
683{
684	int len = parent ? 6 : 3;
685	u64 nodeid;
686	u32 generation;
687
688	if (*max_len < len) {
689		*max_len = len;
690		return  FILEID_INVALID;
691	}
692
693	nodeid = get_fuse_inode(inode)->nodeid;
694	generation = inode->i_generation;
695
696	fh[0] = (u32)(nodeid >> 32);
697	fh[1] = (u32)(nodeid & 0xffffffff);
698	fh[2] = generation;
699
700	if (parent) {
701		nodeid = get_fuse_inode(parent)->nodeid;
702		generation = parent->i_generation;
703
704		fh[3] = (u32)(nodeid >> 32);
705		fh[4] = (u32)(nodeid & 0xffffffff);
706		fh[5] = generation;
707	}
708
709	*max_len = len;
710	return parent ? 0x82 : 0x81;
711}
712
713static struct dentry *fuse_fh_to_dentry(struct super_block *sb,
714		struct fid *fid, int fh_len, int fh_type)
715{
716	struct fuse_inode_handle handle;
717
718	if ((fh_type != 0x81 && fh_type != 0x82) || fh_len < 3)
719		return NULL;
720
721	handle.nodeid = (u64) fid->raw[0] << 32;
722	handle.nodeid |= (u64) fid->raw[1];
723	handle.generation = fid->raw[2];
724	return fuse_get_dentry(sb, &handle);
725}
726
727static struct dentry *fuse_fh_to_parent(struct super_block *sb,
728		struct fid *fid, int fh_len, int fh_type)
729{
730	struct fuse_inode_handle parent;
731
732	if (fh_type != 0x82 || fh_len < 6)
733		return NULL;
734
735	parent.nodeid = (u64) fid->raw[3] << 32;
736	parent.nodeid |= (u64) fid->raw[4];
737	parent.generation = fid->raw[5];
738	return fuse_get_dentry(sb, &parent);
739}
740
741static struct dentry *fuse_get_parent(struct dentry *child)
742{
743	struct inode *child_inode = d_inode(child);
744	struct fuse_conn *fc = get_fuse_conn(child_inode);
745	struct inode *inode;
746	struct dentry *parent;
747	struct fuse_entry_out outarg;
748	struct qstr name;
749	int err;
750
751	if (!fc->export_support)
752		return ERR_PTR(-ESTALE);
753
754	name.len = 2;
755	name.name = "..";
756	err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode),
757			       &name, &outarg, &inode);
758	if (err) {
759		if (err == -ENOENT)
760			return ERR_PTR(-ESTALE);
761		return ERR_PTR(err);
762	}
763
764	parent = d_obtain_alias(inode);
765	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
766		fuse_invalidate_entry_cache(parent);
767
768	return parent;
769}
770
771static const struct export_operations fuse_export_operations = {
772	.fh_to_dentry	= fuse_fh_to_dentry,
773	.fh_to_parent	= fuse_fh_to_parent,
774	.encode_fh	= fuse_encode_fh,
775	.get_parent	= fuse_get_parent,
776};
777
778static const struct super_operations fuse_super_operations = {
779	.alloc_inode    = fuse_alloc_inode,
780	.destroy_inode  = fuse_destroy_inode,
781	.evict_inode	= fuse_evict_inode,
782	.write_inode	= fuse_write_inode,
783	.drop_inode	= generic_delete_inode,
784	.remount_fs	= fuse_remount_fs,
785	.put_super	= fuse_put_super,
786	.umount_begin	= fuse_umount_begin,
787	.statfs		= fuse_statfs,
788	.show_options	= fuse_show_options,
789};
790
791static void sanitize_global_limit(unsigned *limit)
792{
793	if (*limit == 0)
794		*limit = ((totalram_pages << PAGE_SHIFT) >> 13) /
795			 sizeof(struct fuse_req);
796
797	if (*limit >= 1 << 16)
798		*limit = (1 << 16) - 1;
799}
800
801static int set_global_limit(const char *val, struct kernel_param *kp)
802{
803	int rv;
804
805	rv = param_set_uint(val, kp);
806	if (rv)
807		return rv;
808
809	sanitize_global_limit((unsigned *)kp->arg);
810
811	return 0;
812}
813
814static void process_init_limits(struct fuse_conn *fc, struct fuse_init_out *arg)
815{
816	int cap_sys_admin = capable(CAP_SYS_ADMIN);
817
818	if (arg->minor < 13)
819		return;
820
821	sanitize_global_limit(&max_user_bgreq);
822	sanitize_global_limit(&max_user_congthresh);
823
824	if (arg->max_background) {
825		fc->max_background = arg->max_background;
826
827		if (!cap_sys_admin && fc->max_background > max_user_bgreq)
828			fc->max_background = max_user_bgreq;
829	}
830	if (arg->congestion_threshold) {
831		fc->congestion_threshold = arg->congestion_threshold;
832
833		if (!cap_sys_admin &&
834		    fc->congestion_threshold > max_user_congthresh)
835			fc->congestion_threshold = max_user_congthresh;
836	}
837}
838
839static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
840{
841	struct fuse_init_out *arg = &req->misc.init_out;
842
843	if (req->out.h.error || arg->major != FUSE_KERNEL_VERSION)
844		fc->conn_error = 1;
845	else {
846		unsigned long ra_pages;
847
848		process_init_limits(fc, arg);
849
850		if (arg->minor >= 6) {
851			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
852			if (arg->flags & FUSE_ASYNC_READ)
853				fc->async_read = 1;
854			if (!(arg->flags & FUSE_POSIX_LOCKS))
855				fc->no_lock = 1;
856			if (arg->minor >= 17) {
857				if (!(arg->flags & FUSE_FLOCK_LOCKS))
858					fc->no_flock = 1;
859			} else {
860				if (!(arg->flags & FUSE_POSIX_LOCKS))
861					fc->no_flock = 1;
862			}
863			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
864				fc->atomic_o_trunc = 1;
865			if (arg->minor >= 9) {
866				/* LOOKUP has dependency on proto version */
867				if (arg->flags & FUSE_EXPORT_SUPPORT)
868					fc->export_support = 1;
869			}
870			if (arg->flags & FUSE_BIG_WRITES)
871				fc->big_writes = 1;
872			if (arg->flags & FUSE_DONT_MASK)
873				fc->dont_mask = 1;
874			if (arg->flags & FUSE_AUTO_INVAL_DATA)
875				fc->auto_inval_data = 1;
876			if (arg->flags & FUSE_DO_READDIRPLUS) {
877				fc->do_readdirplus = 1;
878				if (arg->flags & FUSE_READDIRPLUS_AUTO)
879					fc->readdirplus_auto = 1;
880			}
881			if (arg->flags & FUSE_ASYNC_DIO)
882				fc->async_dio = 1;
883			if (arg->flags & FUSE_WRITEBACK_CACHE)
884				fc->writeback_cache = 1;
885			if (arg->time_gran && arg->time_gran <= 1000000000)
886				fc->sb->s_time_gran = arg->time_gran;
887		} else {
888			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
889			fc->no_lock = 1;
890			fc->no_flock = 1;
891		}
892
893		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
894		fc->minor = arg->minor;
895		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
896		fc->max_write = max_t(unsigned, 4096, fc->max_write);
897		fc->conn_init = 1;
898	}
899	fuse_set_initialized(fc);
900	wake_up_all(&fc->blocked_waitq);
901}
902
903static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
904{
905	struct fuse_init_in *arg = &req->misc.init_in;
906
907	arg->major = FUSE_KERNEL_VERSION;
908	arg->minor = FUSE_KERNEL_MINOR_VERSION;
909	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
910	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
911		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
912		FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
913		FUSE_FLOCK_LOCKS | FUSE_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
914		FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
915		FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT;
916	req->in.h.opcode = FUSE_INIT;
917	req->in.numargs = 1;
918	req->in.args[0].size = sizeof(*arg);
919	req->in.args[0].value = arg;
920	req->out.numargs = 1;
921	/* Variable length argument used for backward compatibility
922	   with interface version < 7.5.  Rest of init_out is zeroed
923	   by do_get_request(), so a short reply is not a problem */
924	req->out.argvar = 1;
925	req->out.args[0].size = sizeof(struct fuse_init_out);
926	req->out.args[0].value = &req->misc.init_out;
927	req->end = process_init_reply;
928	fuse_request_send_background(fc, req);
929}
930
931static void fuse_free_conn(struct fuse_conn *fc)
932{
933	kfree_rcu(fc, rcu);
934}
935
936static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
937{
938	int err;
939
940	fc->bdi.name = "fuse";
941	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
942	/* fuse does it's own writeback accounting */
943	fc->bdi.capabilities = BDI_CAP_NO_ACCT_WB | BDI_CAP_STRICTLIMIT;
944
945	err = bdi_init(&fc->bdi);
946	if (err)
947		return err;
948
949	fc->bdi_initialized = 1;
950
951	if (sb->s_bdev) {
952		err =  bdi_register(&fc->bdi, NULL, "%u:%u-fuseblk",
953				    MAJOR(fc->dev), MINOR(fc->dev));
954	} else {
955		err = bdi_register_dev(&fc->bdi, fc->dev);
956	}
957
958	if (err)
959		return err;
960
961	/*
962	 * For a single fuse filesystem use max 1% of dirty +
963	 * writeback threshold.
964	 *
965	 * This gives about 1M of write buffer for memory maps on a
966	 * machine with 1G and 10% dirty_ratio, which should be more
967	 * than enough.
968	 *
969	 * Privileged users can raise it by writing to
970	 *
971	 *    /sys/class/bdi/<bdi>/max_ratio
972	 */
973	bdi_set_max_ratio(&fc->bdi, 1);
974
975	return 0;
976}
977
978static int fuse_fill_super(struct super_block *sb, void *data, int silent)
979{
980	struct fuse_conn *fc;
981	struct inode *root;
982	struct fuse_mount_data d;
983	struct file *file;
984	struct dentry *root_dentry;
985	struct fuse_req *init_req;
986	int err;
987	int is_bdev = sb->s_bdev != NULL;
988
989	err = -EINVAL;
990	if (sb->s_flags & MS_MANDLOCK)
991		goto err;
992
993	sb->s_flags &= ~(MS_NOSEC | MS_I_VERSION);
994
995	if (!parse_fuse_opt(data, &d, is_bdev))
996		goto err;
997
998	if (is_bdev) {
999#ifdef CONFIG_BLOCK
1000		err = -EINVAL;
1001		if (!sb_set_blocksize(sb, d.blksize))
1002			goto err;
1003#endif
1004	} else {
1005		sb->s_blocksize = PAGE_CACHE_SIZE;
1006		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
1007	}
1008	sb->s_magic = FUSE_SUPER_MAGIC;
1009	sb->s_op = &fuse_super_operations;
1010	sb->s_maxbytes = MAX_LFS_FILESIZE;
1011	sb->s_time_gran = 1;
1012	sb->s_export_op = &fuse_export_operations;
1013
1014	file = fget(d.fd);
1015	err = -EINVAL;
1016	if (!file)
1017		goto err;
1018
1019	if ((file->f_op != &fuse_dev_operations) ||
1020	    (file->f_cred->user_ns != &init_user_ns))
1021		goto err_fput;
1022
1023	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
1024	err = -ENOMEM;
1025	if (!fc)
1026		goto err_fput;
1027
1028	fuse_conn_init(fc);
1029	fc->release = fuse_free_conn;
1030
1031	fc->dev = sb->s_dev;
1032	fc->sb = sb;
1033	err = fuse_bdi_init(fc, sb);
1034	if (err)
1035		goto err_put_conn;
1036
1037	sb->s_bdi = &fc->bdi;
1038
1039	/* Handle umasking inside the fuse code */
1040	if (sb->s_flags & MS_POSIXACL)
1041		fc->dont_mask = 1;
1042	sb->s_flags |= MS_POSIXACL;
1043
1044	fc->flags = d.flags;
1045	fc->user_id = d.user_id;
1046	fc->group_id = d.group_id;
1047	fc->max_read = max_t(unsigned, 4096, d.max_read);
1048
1049	/* Used by get_root_inode() */
1050	sb->s_fs_info = fc;
1051
1052	err = -ENOMEM;
1053	root = fuse_get_root_inode(sb, d.rootmode);
1054	root_dentry = d_make_root(root);
1055	if (!root_dentry)
1056		goto err_put_conn;
1057	/* only now - we want root dentry with NULL ->d_op */
1058	sb->s_d_op = &fuse_dentry_operations;
1059
1060	init_req = fuse_request_alloc(0);
1061	if (!init_req)
1062		goto err_put_root;
1063	init_req->background = 1;
1064
1065	if (is_bdev) {
1066		fc->destroy_req = fuse_request_alloc(0);
1067		if (!fc->destroy_req)
1068			goto err_free_init_req;
1069	}
1070
1071	mutex_lock(&fuse_mutex);
1072	err = -EINVAL;
1073	if (file->private_data)
1074		goto err_unlock;
1075
1076	err = fuse_ctl_add_conn(fc);
1077	if (err)
1078		goto err_unlock;
1079
1080	list_add_tail(&fc->entry, &fuse_conn_list);
1081	sb->s_root = root_dentry;
1082	fc->connected = 1;
1083	file->private_data = fuse_conn_get(fc);
1084	mutex_unlock(&fuse_mutex);
1085	/*
1086	 * atomic_dec_and_test() in fput() provides the necessary
1087	 * memory barrier for file->private_data to be visible on all
1088	 * CPUs after this
1089	 */
1090	fput(file);
1091
1092	fuse_send_init(fc, init_req);
1093
1094	return 0;
1095
1096 err_unlock:
1097	mutex_unlock(&fuse_mutex);
1098 err_free_init_req:
1099	fuse_request_free(init_req);
1100 err_put_root:
1101	dput(root_dentry);
1102 err_put_conn:
1103	fuse_bdi_destroy(fc);
1104	fuse_conn_put(fc);
1105 err_fput:
1106	fput(file);
1107 err:
1108	return err;
1109}
1110
1111static struct dentry *fuse_mount(struct file_system_type *fs_type,
1112		       int flags, const char *dev_name,
1113		       void *raw_data)
1114{
1115	return mount_nodev(fs_type, flags, raw_data, fuse_fill_super);
1116}
1117
1118static void fuse_kill_sb_anon(struct super_block *sb)
1119{
1120	struct fuse_conn *fc = get_fuse_conn_super(sb);
1121
1122	if (fc) {
1123		down_write(&fc->killsb);
1124		fc->sb = NULL;
1125		up_write(&fc->killsb);
1126	}
1127
1128	kill_anon_super(sb);
1129}
1130
1131static struct file_system_type fuse_fs_type = {
1132	.owner		= THIS_MODULE,
1133	.name		= "fuse",
1134	.fs_flags	= FS_HAS_SUBTYPE,
1135	.mount		= fuse_mount,
1136	.kill_sb	= fuse_kill_sb_anon,
1137};
1138MODULE_ALIAS_FS("fuse");
1139
1140#ifdef CONFIG_BLOCK
1141static struct dentry *fuse_mount_blk(struct file_system_type *fs_type,
1142			   int flags, const char *dev_name,
1143			   void *raw_data)
1144{
1145	return mount_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super);
1146}
1147
1148static void fuse_kill_sb_blk(struct super_block *sb)
1149{
1150	struct fuse_conn *fc = get_fuse_conn_super(sb);
1151
1152	if (fc) {
1153		down_write(&fc->killsb);
1154		fc->sb = NULL;
1155		up_write(&fc->killsb);
1156	}
1157
1158	kill_block_super(sb);
1159}
1160
1161static struct file_system_type fuseblk_fs_type = {
1162	.owner		= THIS_MODULE,
1163	.name		= "fuseblk",
1164	.mount		= fuse_mount_blk,
1165	.kill_sb	= fuse_kill_sb_blk,
1166	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1167};
1168MODULE_ALIAS_FS("fuseblk");
1169
1170static inline int register_fuseblk(void)
1171{
1172	return register_filesystem(&fuseblk_fs_type);
1173}
1174
1175static inline void unregister_fuseblk(void)
1176{
1177	unregister_filesystem(&fuseblk_fs_type);
1178}
1179#else
1180static inline int register_fuseblk(void)
1181{
1182	return 0;
1183}
1184
1185static inline void unregister_fuseblk(void)
1186{
1187}
1188#endif
1189
1190static void fuse_inode_init_once(void *foo)
1191{
1192	struct inode *inode = foo;
1193
1194	inode_init_once(inode);
1195}
1196
1197static int __init fuse_fs_init(void)
1198{
1199	int err;
1200
1201	fuse_inode_cachep = kmem_cache_create("fuse_inode",
1202					      sizeof(struct fuse_inode),
1203					      0, SLAB_HWCACHE_ALIGN,
1204					      fuse_inode_init_once);
1205	err = -ENOMEM;
1206	if (!fuse_inode_cachep)
1207		goto out;
1208
1209	err = register_fuseblk();
1210	if (err)
1211		goto out2;
1212
1213	err = register_filesystem(&fuse_fs_type);
1214	if (err)
1215		goto out3;
1216
1217	return 0;
1218
1219 out3:
1220	unregister_fuseblk();
1221 out2:
1222	kmem_cache_destroy(fuse_inode_cachep);
1223 out:
1224	return err;
1225}
1226
1227static void fuse_fs_cleanup(void)
1228{
1229	unregister_filesystem(&fuse_fs_type);
1230	unregister_fuseblk();
1231
1232	/*
1233	 * Make sure all delayed rcu free inodes are flushed before we
1234	 * destroy cache.
1235	 */
1236	rcu_barrier();
1237	kmem_cache_destroy(fuse_inode_cachep);
1238}
1239
1240static struct kobject *fuse_kobj;
1241
1242static int fuse_sysfs_init(void)
1243{
1244	int err;
1245
1246	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1247	if (!fuse_kobj) {
1248		err = -ENOMEM;
1249		goto out_err;
1250	}
1251
1252	err = sysfs_create_mount_point(fuse_kobj, "connections");
1253	if (err)
1254		goto out_fuse_unregister;
1255
1256	return 0;
1257
1258 out_fuse_unregister:
1259	kobject_put(fuse_kobj);
1260 out_err:
1261	return err;
1262}
1263
1264static void fuse_sysfs_cleanup(void)
1265{
1266	sysfs_remove_mount_point(fuse_kobj, "connections");
1267	kobject_put(fuse_kobj);
1268}
1269
1270static int __init fuse_init(void)
1271{
1272	int res;
1273
1274	printk(KERN_INFO "fuse init (API version %i.%i)\n",
1275	       FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
1276
1277	INIT_LIST_HEAD(&fuse_conn_list);
1278	res = fuse_fs_init();
1279	if (res)
1280		goto err;
1281
1282	res = fuse_dev_init();
1283	if (res)
1284		goto err_fs_cleanup;
1285
1286	res = fuse_sysfs_init();
1287	if (res)
1288		goto err_dev_cleanup;
1289
1290	res = fuse_ctl_init();
1291	if (res)
1292		goto err_sysfs_cleanup;
1293
1294	sanitize_global_limit(&max_user_bgreq);
1295	sanitize_global_limit(&max_user_congthresh);
1296
1297	return 0;
1298
1299 err_sysfs_cleanup:
1300	fuse_sysfs_cleanup();
1301 err_dev_cleanup:
1302	fuse_dev_cleanup();
1303 err_fs_cleanup:
1304	fuse_fs_cleanup();
1305 err:
1306	return res;
1307}
1308
1309static void __exit fuse_exit(void)
1310{
1311	printk(KERN_DEBUG "fuse exit\n");
1312
1313	fuse_ctl_cleanup();
1314	fuse_sysfs_cleanup();
1315	fuse_fs_cleanup();
1316	fuse_dev_cleanup();
1317}
1318
1319module_init(fuse_init);
1320module_exit(fuse_exit);
1321