inode.c 28.9 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 63
struct fuse_mount_data {
	int fd;
	unsigned rootmode;
	unsigned user_id;
64
	unsigned 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 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 115
static void fuse_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	INIT_LIST_HEAD(&inode->i_dentry);
	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
	kfree(fi->forget);
Nick Piggin's avatar
Nick Piggin committed
122
	call_rcu(&inode->i_rcu, fuse_i_callback);
Miklos Szeredi's avatar
Miklos Szeredi committed
123 124
}

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

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

	return 0;
}

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

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

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);
Miklos Szeredi's avatar
Miklos Szeredi committed
169 170 171 172 173 174 175 176 177
	inode->i_uid     = attr->uid;
	inode->i_gid     = attr->gid;
	inode->i_blocks  = attr->blocks;
	inode->i_atime.tv_sec   = attr->atime;
	inode->i_atime.tv_nsec  = attr->atimensec;
	inode->i_mtime.tv_sec   = attr->mtime;
	inode->i_mtime.tv_nsec  = attr->mtimensec;
	inode->i_ctime.tv_sec   = attr->ctime;
	inode->i_ctime.tv_nsec  = attr->ctimensec;
178

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

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

	fi->orig_ino = attr->ino;
Miklos Szeredi's avatar
Miklos Szeredi committed
194 195 196 197 198 199 200 201 202 203
}

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

	spin_lock(&fc->lock);
204 205
	if ((attr_version != 0 && fi->attr_version > attr_version) ||
	    test_bit(FUSE_I_SIZE_UNSTABLE, &fi->state)) {
Miklos Szeredi's avatar
Miklos Szeredi committed
206 207 208 209 210
		spin_unlock(&fc->lock);
		return;
	}

	fuse_change_attributes_common(inode, attr, attr_valid);
211

212 213 214 215 216
	oldsize = inode->i_size;
	i_size_write(inode, attr->size);
	spin_unlock(&fc->lock);

	if (S_ISREG(inode->i_mode) && oldsize != attr->size) {
npiggin@suse.de's avatar
npiggin@suse.de committed
217
		truncate_pagecache(inode, oldsize, attr->size);
Miklos Szeredi's avatar
Miklos Szeredi committed
218
		invalidate_inode_pages2(inode->i_mapping);
219
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
220 221 222 223 224
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
225
	inode->i_size = attr->size;
226 227
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
228
		fuse_init_file_inode(inode);
229 230 231 232 233 234 235 236 237
	} 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));
238 239
	} else
		BUG();
Miklos Szeredi's avatar
Miklos Szeredi committed
240 241
}

John Muir's avatar
John Muir committed
242
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
Miklos Szeredi's avatar
Miklos Szeredi committed
243
{
Miklos Szeredi's avatar
Miklos Szeredi committed
244
	u64 nodeid = *(u64 *) _nodeidp;
Miklos Szeredi's avatar
Miklos Szeredi committed
245 246 247 248 249 250 251 252
	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
253
	u64 nodeid = *(u64 *) _nodeidp;
Miklos Szeredi's avatar
Miklos Szeredi committed
254 255 256 257
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
258
struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
259 260
			int generation, struct fuse_attr *attr,
			u64 attr_valid, u64 attr_version)
Miklos Szeredi's avatar
Miklos Szeredi committed
261 262
{
	struct inode *inode;
263
	struct fuse_inode *fi;
Miklos Szeredi's avatar
Miklos Szeredi committed
264 265 266 267 268 269 270 271
	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)) {
272
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
Miklos Szeredi's avatar
Miklos Szeredi committed
273 274 275 276 277 278 279 280 281 282 283
		inode->i_generation = generation;
		inode->i_data.backing_dev_info = &fc->bdi;
		fuse_init_inode(inode, attr);
		unlock_new_inode(inode);
	} else if ((inode->i_mode ^ attr->mode) & S_IFMT) {
		/* Inode has changed type, any I/O on the old should fail */
		make_bad_inode(inode);
		iput(inode);
		goto retry;
	}

284
	fi = get_fuse_inode(inode);
285
	spin_lock(&fc->lock);
Miklos Szeredi's avatar
Miklos Szeredi committed
286
	fi->nlookup++;
287
	spin_unlock(&fc->lock);
288 289
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

Miklos Szeredi's avatar
Miklos Szeredi committed
290 291 292
	return inode;
}

John Muir's avatar
John Muir committed
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
int fuse_reverse_inval_inode(struct super_block *sb, u64 nodeid,
			     loff_t offset, loff_t len)
{
	struct inode *inode;
	pgoff_t pg_start;
	pgoff_t pg_end;

	inode = ilookup5(sb, nodeid, fuse_inode_eq, &nodeid);
	if (!inode)
		return -ENOENT;

	fuse_invalidate_attr(inode);
	if (offset >= 0) {
		pg_start = offset >> PAGE_CACHE_SHIFT;
		if (len <= 0)
			pg_end = -1;
		else
			pg_end = (offset + len - 1) >> PAGE_CACHE_SHIFT;
		invalidate_inode_pages2_range(inode->i_mapping,
					      pg_start, pg_end);
	}
	iput(inode);
	return 0;
}

318
static void fuse_umount_begin(struct super_block *sb)
319
{
320
	fuse_abort_conn(get_fuse_conn_super(sb));
321 322
}

323 324 325 326 327 328 329
static void fuse_send_destroy(struct fuse_conn *fc)
{
	struct fuse_req *req = fc->destroy_req;
	if (req && fc->conn_init) {
		fc->destroy_req = NULL;
		req->in.h.opcode = FUSE_DESTROY;
		req->force = 1;
330
		fuse_request_send(fc, req);
331 332 333 334
		fuse_put_request(fc, req);
	}
}

335
static void fuse_bdi_destroy(struct fuse_conn *fc)
Miklos Szeredi's avatar
Miklos Szeredi committed
336
{
337 338 339
	if (fc->bdi_initialized)
		bdi_destroy(&fc->bdi);
}
Miklos Szeredi's avatar
Miklos Szeredi committed
340

341
void fuse_conn_kill(struct fuse_conn *fc)
342
{
343
	spin_lock(&fc->lock);
344
	fc->connected = 0;
345
	fc->blocked = 0;
346
	spin_unlock(&fc->lock);
347
	/* Flush all readers on this fs */
348
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
349
	wake_up_all(&fc->waitq);
350
	wake_up_all(&fc->blocked_waitq);
351
	wake_up_all(&fc->reserved_req_waitq);
352 353 354 355
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
356 357
	fuse_bdi_destroy(fc);
}
358
EXPORT_SYMBOL_GPL(fuse_conn_kill);
359 360 361 362 363 364 365

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

	fuse_send_destroy(fc);
	fuse_conn_kill(fc);
366
	fuse_conn_put(fc);
Miklos Szeredi's avatar
Miklos Szeredi committed
367 368
}

369 370 371 372
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
373
	stbuf->f_frsize  = attr->frsize;
374 375 376 377 378 379 380 381 382
	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 */
}

383
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
384
{
385
	struct super_block *sb = dentry->d_sb;
386 387 388 389 390
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

391 392 393 394 395
	if (!fuse_allow_task(fc, current)) {
		buf->f_type = FUSE_SUPER_MAGIC;
		return 0;
	}

396 397 398
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
399

400
	memset(&outarg, 0, sizeof(outarg));
401 402
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
403
	req->in.h.nodeid = get_node_id(dentry->d_inode);
404
	req->out.numargs = 1;
405 406
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
407
	req->out.args[0].value = &outarg;
408
	fuse_request_send(fc, req);
409 410 411 412 413 414 415
	err = req->out.h.error;
	if (!err)
		convert_fuse_statfs(buf, &outarg.st);
	fuse_put_request(fc, req);
	return err;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
416 417 418 419
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
420
	OPT_GROUP_ID,
Miklos Szeredi's avatar
Miklos Szeredi committed
421 422
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
423
	OPT_MAX_READ,
424
	OPT_BLKSIZE,
Miklos Szeredi's avatar
Miklos Szeredi committed
425 426 427
	OPT_ERR
};

428
static const match_table_t tokens = {
Miklos Szeredi's avatar
Miklos Szeredi committed
429 430 431
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
432
	{OPT_GROUP_ID,			"group_id=%u"},
Miklos Szeredi's avatar
Miklos Szeredi committed
433 434
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
435
	{OPT_MAX_READ,			"max_read=%u"},
436
	{OPT_BLKSIZE,			"blksize=%u"},
Miklos Szeredi's avatar
Miklos Szeredi committed
437 438 439
	{OPT_ERR,			NULL}
};

440 441 442 443 444 445 446 447 448 449 450
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;
}

451
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
Miklos Szeredi's avatar
Miklos Szeredi committed
452 453 454
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
455
	d->max_read = ~0;
Miklos Szeredi's avatar
Miklos Szeredi committed
456
	d->blksize = FUSE_DEFAULT_BLKSIZE;
Miklos Szeredi's avatar
Miklos Szeredi committed
457 458 459 460

	while ((p = strsep(&opt, ",")) != NULL) {
		int token;
		int value;
461
		unsigned uv;
Miklos Szeredi's avatar
Miklos Szeredi committed
462 463 464 465 466 467 468 469 470 471
		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;
472
			d->fd_present = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
473 474 475 476 477
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
478 479
			if (!fuse_valid_type(value))
				return 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
480
			d->rootmode = value;
481
			d->rootmode_present = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
482 483 484
			break;

		case OPT_USER_ID:
485
			if (fuse_match_uint(&args[0], &uv))
Miklos Szeredi's avatar
Miklos Szeredi committed
486
				return 0;
487
			d->user_id = uv;
488
			d->user_id_present = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
489 490
			break;

491
		case OPT_GROUP_ID:
492
			if (fuse_match_uint(&args[0], &uv))
493
				return 0;
494
			d->group_id = uv;
495
			d->group_id_present = 1;
496 497
			break;

498 499 500 501 502 503 504 505
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

506 507 508 509 510 511
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

512 513 514 515 516 517
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

Miklos Szeredi's avatar
Miklos Szeredi committed
518 519 520 521
		default:
			return 0;
		}
	}
522 523 524

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
Miklos Szeredi's avatar
Miklos Szeredi committed
525 526 527 528 529 530 531 532 533 534
		return 0;

	return 1;
}

static int fuse_show_options(struct seq_file *m, struct vfsmount *mnt)
{
	struct fuse_conn *fc = get_fuse_conn_super(mnt->mnt_sb);

	seq_printf(m, ",user_id=%u", fc->user_id);
535
	seq_printf(m, ",group_id=%u", fc->group_id);
536 537 538 539
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
540 541
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
Miklos Szeredi's avatar
Miklos Szeredi committed
542 543 544
	if (mnt->mnt_sb->s_bdev &&
	    mnt->mnt_sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
		seq_printf(m, ",blksize=%lu", mnt->mnt_sb->s_blocksize);
Miklos Szeredi's avatar
Miklos Szeredi committed
545 546 547
	return 0;
}

548
void fuse_conn_init(struct fuse_conn *fc)
Miklos Szeredi's avatar
Miklos Szeredi committed
549
{
550 551 552
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
	mutex_init(&fc->inst_mutex);
John Muir's avatar
John Muir committed
553
	init_rwsem(&fc->killsb);
554 555 556 557 558 559 560 561 562 563
	atomic_set(&fc->count, 1);
	init_waitqueue_head(&fc->waitq);
	init_waitqueue_head(&fc->blocked_waitq);
	init_waitqueue_head(&fc->reserved_req_waitq);
	INIT_LIST_HEAD(&fc->pending);
	INIT_LIST_HEAD(&fc->processing);
	INIT_LIST_HEAD(&fc->io);
	INIT_LIST_HEAD(&fc->interrupts);
	INIT_LIST_HEAD(&fc->bg_queue);
	INIT_LIST_HEAD(&fc->entry);
564
	fc->forget_list_tail = &fc->forget_list_head;
565
	atomic_set(&fc->num_waiting, 0);
566 567
	fc->max_background = FUSE_DEFAULT_MAX_BACKGROUND;
	fc->congestion_threshold = FUSE_DEFAULT_CONGESTION_THRESHOLD;
568 569 570 571 572 573
	fc->khctr = 0;
	fc->polled_files = RB_ROOT;
	fc->reqctr = 0;
	fc->blocked = 1;
	fc->attr_version = 1;
	get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
Miklos Szeredi's avatar
Miklos Szeredi committed
574
}
575
EXPORT_SYMBOL_GPL(fuse_conn_init);
Miklos Szeredi's avatar
Miklos Szeredi committed
576

577 578
void fuse_conn_put(struct fuse_conn *fc)
{
579
	if (atomic_dec_and_test(&fc->count)) {
580 581
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
582
		mutex_destroy(&fc->inst_mutex);
Tejun Heo's avatar
Tejun Heo committed
583
		fc->release(fc);
584
	}
585
}
586
EXPORT_SYMBOL_GPL(fuse_conn_put);
587 588 589 590 591 592

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

595
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
Miklos Szeredi's avatar
Miklos Szeredi committed
596 597 598 599 600 601
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
602
	attr.nlink = 1;
603
	return fuse_iget(sb, 1, 0, &attr, 0, 0);
Miklos Szeredi's avatar
Miklos Szeredi committed
604 605
}

Miklos Szeredi's avatar
Miklos Szeredi committed
606
struct fuse_inode_handle {
Miklos Szeredi's avatar
Miklos Szeredi committed
607 608 609 610 611 612 613
	u64 nodeid;
	u32 generation;
};

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
614
	struct fuse_conn *fc = get_fuse_conn_super(sb);
Miklos Szeredi's avatar
Miklos Szeredi committed
615 616 617 618 619 620 621 622
	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);
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
	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
644 645 646 647
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

648
	entry = d_obtain_alias(inode);
Al Viro's avatar
Al Viro committed
649
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID)
Miklos Szeredi's avatar
Miklos Szeredi committed
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
		fuse_invalidate_entry_cache(entry);

	return entry;

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

static int fuse_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
			   int connectable)
{
	struct inode *inode = dentry->d_inode;
	bool encode_parent = connectable && !S_ISDIR(inode->i_mode);
	int len = encode_parent ? 6 : 3;
	u64 nodeid;
	u32 generation;

669 670
	if (*max_len < len) {
		*max_len = len;
Miklos Szeredi's avatar
Miklos Szeredi committed
671
		return  255;
672
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726

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

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

	if (encode_parent) {
		struct inode *parent;

		spin_lock(&dentry->d_lock);
		parent = dentry->d_parent->d_inode;
		nodeid = get_fuse_inode(parent)->nodeid;
		generation = parent->i_generation;
		spin_unlock(&dentry->d_lock);

		fh[3] = (u32)(nodeid >> 32);
		fh[4] = (u32)(nodeid & 0xffffffff);
		fh[5] = generation;
	}

	*max_len = len;
	return encode_parent ? 0x82 : 0x81;
}

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

727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
static struct dentry *fuse_get_parent(struct dentry *child)
{
	struct inode *child_inode = child->d_inode;
	struct fuse_conn *fc = get_fuse_conn(child_inode);
	struct inode *inode;
	struct dentry *parent;
	struct fuse_entry_out outarg;
	struct qstr name;
	int err;

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

	name.len = 2;
	name.name = "..";
	err = fuse_lookup_name(child_inode->i_sb, get_node_id(child_inode),
			       &name, &outarg, &inode);
744 745 746
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
747 748
		return ERR_PTR(err);
	}
749 750

	parent = d_obtain_alias(inode);
Al Viro's avatar
Al Viro committed
751
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID)
752 753 754 755
		fuse_invalidate_entry_cache(parent);

	return parent;
}
Miklos Szeredi's avatar
Miklos Szeredi committed
756 757 758 759 760

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,
761
	.get_parent	= fuse_get_parent,
Miklos Szeredi's avatar
Miklos Szeredi committed
762 763
};

764
static const struct super_operations fuse_super_operations = {
Miklos Szeredi's avatar
Miklos Szeredi committed
765 766
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
767
	.evict_inode	= fuse_evict_inode,
Miklos Szeredi's avatar
Miklos Szeredi committed
768
	.drop_inode	= generic_delete_inode,
769
	.remount_fs	= fuse_remount_fs,
Miklos Szeredi's avatar
Miklos Szeredi committed
770
	.put_super	= fuse_put_super,
771
	.umount_begin	= fuse_umount_begin,
772
	.statfs		= fuse_statfs,
Miklos Szeredi's avatar
Miklos Szeredi committed
773 774 775
	.show_options	= fuse_show_options,
};

776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
static void sanitize_global_limit(unsigned *limit)
{
	if (*limit == 0)
		*limit = ((num_physpages << PAGE_SHIFT) >> 13) /
			 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;
	}
}

824 825 826 827 828 829 830
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 {
831 832
		unsigned long ra_pages;

833 834
		process_init_limits(fc, arg);

835 836 837 838
		if (arg->minor >= 6) {
			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
839 840
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
841 842 843
			if (arg->minor >= 17) {
				if (!(arg->flags & FUSE_FLOCK_LOCKS))
					fc->no_flock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
844 845 846
			} else {
				if (!(arg->flags & FUSE_POSIX_LOCKS))
					fc->no_flock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
847
			}
848 849
			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
				fc->atomic_o_trunc = 1;
850 851 852 853 854
			if (arg->minor >= 9) {
				/* LOOKUP has dependency on proto version */
				if (arg->flags & FUSE_EXPORT_SUPPORT)
					fc->export_support = 1;
			}
855 856
			if (arg->flags & FUSE_BIG_WRITES)
				fc->big_writes = 1;
857 858
			if (arg->flags & FUSE_DONT_MASK)
				fc->dont_mask = 1;
859
		} else {
860
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
861
			fc->no_lock = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
862
			fc->no_flock = 1;
863
		}
864 865

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
866 867
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
868
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
869
		fc->conn_init = 1;
870
	}
871 872
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
873 874
}

875
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
876 877
{
	struct fuse_init_in *arg = &req->misc.init_in;
878

879 880
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
881
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
882
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
Miklos Szeredi's avatar
Miklos Szeredi committed
883 884
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
		FUSE_FLOCK_LOCKS;
885 886 887 888 889
	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;
890
	/* Variable length argument used for backward compatibility
891 892 893 894 895 896
	   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;
897
	fuse_request_send_background(fc, req);
898 899
}

Tejun Heo's avatar
Tejun Heo committed
900 901 902 903 904
static void fuse_free_conn(struct fuse_conn *fc)
{
	kfree(fc);
}

905 906 907 908
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

909
	fc->bdi.name = "fuse";
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
	/* fuse does it's own writeback accounting */
	fc->bdi.capabilities = BDI_CAP_NO_ACCT_WB;

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

Miklos Szeredi's avatar
Miklos Szeredi committed
947 948 949 950 951 952
static int fuse_fill_super(struct super_block *sb, void *data, int silent)
{
	struct fuse_conn *fc;
	struct inode *root;
	struct fuse_mount_data d;
	struct file *file;
953
	struct dentry *root_dentry;
954
	struct fuse_req *init_req;
Miklos Szeredi's avatar
Miklos Szeredi committed
955
	int err;
956
	int is_bdev = sb->s_bdev != NULL;
Miklos Szeredi's avatar
Miklos Szeredi committed
957

958
	err = -EINVAL;
959
	if (sb->s_flags & MS_MANDLOCK)
960
		goto err;
961

Al Viro's avatar
Al Viro committed
962 963
	sb->s_flags &= ~MS_NOSEC;

964
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
965
		goto err;
Miklos Szeredi's avatar
Miklos Szeredi committed
966

967
	if (is_bdev) {
968
#ifdef CONFIG_BLOCK
969
		err = -EINVAL;
970
		if (!sb_set_blocksize(sb, d.blksize))
971
			goto err;
972
#endif
973 974 975 976
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
977 978 979
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
Miklos Szeredi's avatar
Miklos Szeredi committed
980
	sb->s_export_op = &fuse_export_operations;
Miklos Szeredi's avatar
Miklos Szeredi committed
981 982

	file = fget(d.fd);
983
	err = -EINVAL;
Miklos Szeredi's avatar
Miklos Szeredi committed
984
	if (!file)
985
		goto err;
Miklos Szeredi's avatar
Miklos Szeredi committed
986

987 988
	if (file->f_op != &fuse_dev_operations)
		goto err_fput;
989

990
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
991 992 993
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
Miklos Szeredi's avatar
Miklos Szeredi committed
994

995
	fuse_conn_init(fc);
996
	fc->release = fuse_free_conn;
997 998

	fc->dev = sb->s_dev;
John Muir's avatar
John Muir committed
999
	fc->sb = sb;
1000 1001 1002
	err = fuse_bdi_init(fc, sb);
	if (err)
		goto err_put_conn;
1003

Jens Axboe's avatar
Jens Axboe committed
1004 1005
	sb->s_bdi = &fc->bdi;

1006 1007 1008 1009 1010
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

1011
	fc->flags = d.flags;
Miklos Szeredi's avatar
Miklos Szeredi committed
1012
	fc->user_id = d.user_id;
1013
	fc->group_id = d.group_id;
1014
	fc->max_read = max_t(unsigned, 4096, d.max_read);
Miklos Szeredi's avatar
Miklos Szeredi committed
1015

1016 1017 1018
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

Miklos Szeredi's avatar
Miklos Szeredi committed
1019
	err = -ENOMEM;
1020
	root = fuse_get_root_inode(sb, d.rootmode);
1021
	if (!root)
1022
		goto err_put_conn;
Miklos Szeredi's avatar
Miklos Szeredi committed
1023

1024 1025
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
Miklos Szeredi's avatar
Miklos Szeredi committed
1026
		iput(root);
1027
		goto err_put_conn;
Miklos Szeredi's avatar
Miklos Szeredi committed
1028
	}
Al Viro's avatar
Al Viro committed
1029 1030
	/* only now - we want root dentry with NULL ->d_op */
	sb->s_d_op = &fuse_dentry_operations;
1031

1032 1033 1034 1035
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

1036 1037 1038
	if (is_bdev) {
		fc->destroy_req = fuse_request_alloc();
		if (!fc->destroy_req)
1039
			goto err_free_init_req;
1040 1041
	}

1042
	mutex_lock(&fuse_mutex);
1043 1044
	err = -EINVAL;
	if (file->private_data)
1045
		goto err_unlock;
1046

1047 1048 1049 1050 1051
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
1052 1053
	sb->s_root = root_dentry;
	fc->connected = 1;
1054 1055
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
1056 1057 1058 1059 1060 1061
	/*
	 * atomic_dec_and_test() in fput() provides the necessary
	 * memory barrier for file->private_data to be visible on all
	 * CPUs after this
	 */
	fput(file);
1062

1063
	fuse_send_init(fc, init_req);
1064

Miklos Szeredi's avatar
Miklos Szeredi committed
1065 1066
	return 0;

1067 1068
 err_unlock:
	mutex_unlock(&fuse_mutex);
1069
 err_free_init_req:
1070
	fuse_request_free(init_req);
1071 1072
 err_put_root:
	dput(root_dentry);
1073
 err_put_conn:
1074
	fuse_bdi_destroy(fc);
1075
	fuse_conn_put(fc);
1076 1077 1078
 err_fput:
	fput(file);
 err:
Miklos Szeredi's avatar
Miklos Szeredi committed
1079 1080 1081
	return err;
}

Al Viro's avatar
Al Viro committed
1082
static struct dentry *fuse_mount(struct file_system_type *fs_type,
1083
		       int flags, const char *dev_name,
Al Viro's avatar
Al Viro committed
1084
		       void *raw_data)
Miklos Szeredi's avatar
Miklos Szeredi committed
1085
{
Al Viro's avatar
Al Viro committed
1086
	return mount_nodev(fs_type, flags, raw_data, fuse_fill_super);
Miklos Szeredi's avatar
Miklos Szeredi committed
1087 1088
}

John Muir's avatar
John Muir committed
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
static void fuse_kill_sb_anon(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

	if (fc) {
		down_write(&fc->killsb);
		fc->sb = NULL;
		up_write(&fc->killsb);
	}

	kill_anon_super(sb);
}

1102 1103 1104
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
1105
	.fs_flags	= FS_HAS_SUBTYPE,
Al Viro's avatar
Al Viro committed
1106
	.mount		= fuse_mount,
John Muir's avatar
John Muir committed
1107
	.kill_sb	= fuse_kill_sb_anon,
1108 1109 1110
};

#ifdef CONFIG_BLOCK
Al Viro's avatar
Al Viro committed
1111
static struct dentry *fuse_mount_blk(struct file_system_type *fs_type,
1112
			   int flags, const char *dev_name,
Al Viro's avatar
Al Viro committed
1113
			   void *raw_data)
1114
{
Al Viro's avatar
Al Viro committed
1115
	return mount_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super);
1116 1117
}

John Muir's avatar
John Muir committed
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
static void fuse_kill_sb_blk(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

	if (fc) {
		down_write(&fc->killsb);
		fc->sb = NULL;
		up_write(&fc->killsb);
	}

	kill_block_super(sb);
}

1131 1132 1133
static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
Al Viro's avatar
Al Viro committed
1134
	.mount		= fuse_mount_blk,
John Muir's avatar
John Muir committed
1135
	.kill_sb	= fuse_kill_sb_blk,
Alexey Dobriyan's avatar
Alexey Dobriyan committed
1136
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1137 1138
};

1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
static inline int register_fuseblk(void)
{
	return register_filesystem(&fuseblk_fs_type);
}

static inline void unregister_fuseblk(void)
{
	unregister_filesystem(&fuseblk_fs_type);
}
#else
static inline int register_fuseblk(void)
{
	return 0;
}

static inline void unregister_fuseblk(void)
{
}
#endif

1159
static void fuse_inode_init_once(void *foo)
Miklos Szeredi's avatar
Miklos Szeredi committed
1160
{
Miklos Szeredi's avatar
Miklos Szeredi committed
1161
	struct inode *inode = foo;
Miklos Szeredi's avatar
Miklos Szeredi committed
1162

1163
	inode_init_once(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
1164 1165 1166 1167 1168 1169
}

static int __init fuse_fs_init(void)
{
	int err;

1170 1171 1172
	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
1173
					      fuse_inode_init_once);
1174 1175
	err = -ENOMEM;
	if (!fuse_inode_cachep)
1176 1177 1178 1179 1180 1181 1182 1183 1184
		goto out;

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

	err = register_filesystem(&fuse_fs_type);
	if (err)
		goto out3;
1185 1186

	return 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
1187

1188
 out3:
1189
	unregister_fuseblk();
1190 1191
 out2:
	kmem_cache_destroy(fuse_inode_cachep);
1192
 out:
Miklos Szeredi's avatar
Miklos Szeredi committed
1193 1194 1195 1196 1197 1198
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
1199
	unregister_fuseblk();
Miklos Szeredi's avatar
Miklos Szeredi committed
1200 1201 1202
	kmem_cache_destroy(fuse_inode_cachep);
}

1203 1204 1205
static struct kobject *fuse_kobj;
static struct kobject *connections_kobj;

1206 1207 1208 1209
static int fuse_sysfs_init(void)
{
	int err;

1210
	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1211 1212
	if (!fuse_kobj) {
		err = -ENOMEM;
1213
		goto out_err;
1214
	}
1215

1216 1217 1218
	connections_kobj = kobject_create_and_add("connections", fuse_kobj);
	if (!connections_kobj) {
		err = -ENOMEM;
1219
		goto out_fuse_unregister;
1220
	}
1221 1222 1223 1224

	return 0;

 out_fuse_unregister:
1225
	kobject_put(fuse_kobj);
1226 1227 1228 1229 1230 1231
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
1232 1233
	kobject_put(connections_kobj);
	kobject_put(fuse_kobj);
1234 1235
}

Miklos Szeredi's avatar
Miklos Szeredi committed
1236 1237 1238 1239
static int __init fuse_init(void)
{
	int res;

Miklos Szeredi's avatar
Miklos Szeredi committed
1240
	printk(KERN_INFO "fuse init (API version %i.%i)\n",
Miklos Szeredi's avatar
Miklos Szeredi committed
1241 1242
	       FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);

1243
	INIT_LIST_HEAD(&fuse_conn_list);
Miklos Szeredi's avatar
Miklos Szeredi committed
1244 1245 1246 1247
	res = fuse_fs_init();
	if (res)
		goto err;

1248 1249 1250 1251
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

1252 1253 1254 1255
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

1256 1257 1258 1259
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

1260 1261 1262
	sanitize_global_limit(&max_user_bgreq);
	sanitize_global_limit(&max_user_congthresh);

Miklos Szeredi's avatar
Miklos Szeredi committed
1263 1264
	return 0;

1265 1266
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
1267 1268
 err_dev_cleanup:
	fuse_dev_cleanup();
1269 1270
 err_fs_cleanup:
	fuse_fs_cleanup();
Miklos Szeredi's avatar
Miklos Szeredi committed
1271 1272 1273 1274 1275 1276 1277 1278
 err:
	return res;
}

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

1279
	fuse_ctl_cleanup();
1280
	fuse_sysfs_cleanup();
Miklos Szeredi's avatar
Miklos Szeredi committed
1281
	fuse_fs_cleanup();
1282
	fuse_dev_cleanup();
Miklos Szeredi's avatar
Miklos Szeredi committed
1283 1284 1285 1286
}

module_init(fuse_init);
module_exit(fuse_exit);