inode.c 26.2 KB
Newer Older
M
Miklos Szeredi 已提交
1 2
/*
  FUSE: Filesystem in Userspace
M
Miklos Szeredi 已提交
3
  Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
M
Miklos Szeredi 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  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>
#include <linux/parser.h>
#include <linux/statfs.h>
19
#include <linux/random.h>
A
Alexey Dobriyan 已提交
20
#include <linux/sched.h>
M
Miklos Szeredi 已提交
21
#include <linux/exportfs.h>
M
Miklos Szeredi 已提交
22 23 24 25 26

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

27
static struct kmem_cache *fuse_inode_cachep;
28 29
struct list_head fuse_conn_list;
DEFINE_MUTEX(fuse_mutex);
M
Miklos Szeredi 已提交
30 31 32

#define FUSE_SUPER_MAGIC 0x65735546

M
Miklos Szeredi 已提交
33 34
#define FUSE_DEFAULT_BLKSIZE 512

M
Miklos Szeredi 已提交
35 36 37 38
struct fuse_mount_data {
	int fd;
	unsigned rootmode;
	unsigned user_id;
39
	unsigned group_id;
M
Miklos Szeredi 已提交
40 41 42 43
	unsigned fd_present:1;
	unsigned rootmode_present:1;
	unsigned user_id_present:1;
	unsigned group_id_present:1;
M
Miklos Szeredi 已提交
44
	unsigned flags;
45
	unsigned max_read;
M
Miklos Szeredi 已提交
46
	unsigned blksize;
M
Miklos Szeredi 已提交
47 48 49 50 51 52 53
};

static struct inode *fuse_alloc_inode(struct super_block *sb)
{
	struct inode *inode;
	struct fuse_inode *fi;

54
	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
M
Miklos Szeredi 已提交
55 56 57 58
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
59
	fi->i_time = 0;
M
Miklos Szeredi 已提交
60
	fi->nodeid = 0;
61
	fi->nlookup = 0;
62
	fi->attr_version = 0;
M
Miklos Szeredi 已提交
63
	fi->writectr = 0;
64
	INIT_LIST_HEAD(&fi->write_files);
M
Miklos Szeredi 已提交
65 66 67
	INIT_LIST_HEAD(&fi->queued_writes);
	INIT_LIST_HEAD(&fi->writepages);
	init_waitqueue_head(&fi->page_waitq);
68 69 70 71 72
	fi->forget_req = fuse_request_alloc();
	if (!fi->forget_req) {
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
M
Miklos Szeredi 已提交
73 74 75 76 77 78

	return inode;
}

static void fuse_destroy_inode(struct inode *inode)
{
79
	struct fuse_inode *fi = get_fuse_inode(inode);
80
	BUG_ON(!list_empty(&fi->write_files));
M
Miklos Szeredi 已提交
81
	BUG_ON(!list_empty(&fi->queued_writes));
82 83
	if (fi->forget_req)
		fuse_request_free(fi->forget_req);
M
Miklos Szeredi 已提交
84 85 86
	kmem_cache_free(fuse_inode_cachep, inode);
}

87
void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
M
Miklos Szeredi 已提交
88
		      u64 nodeid, u64 nlookup)
89 90
{
	struct fuse_forget_in *inarg = &req->misc.forget_in;
91
	inarg->nlookup = nlookup;
92 93 94 95 96
	req->in.h.opcode = FUSE_FORGET;
	req->in.h.nodeid = nodeid;
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(struct fuse_forget_in);
	req->in.args[0].value = inarg;
97
	fuse_request_send_noreply(fc, req);
98 99
}

M
Miklos Szeredi 已提交
100 101
static void fuse_clear_inode(struct inode *inode)
{
M
Miklos Szeredi 已提交
102 103
	if (inode->i_sb->s_flags & MS_ACTIVE) {
		struct fuse_conn *fc = get_fuse_conn(inode);
104
		struct fuse_inode *fi = get_fuse_inode(inode);
105
		fuse_send_forget(fc, fi->forget_req, fi->nodeid, fi->nlookup);
106 107
		fi->forget_req = NULL;
	}
M
Miklos Szeredi 已提交
108 109
}

110 111 112 113 114 115 116 117
static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
{
	if (*flags & MS_MANDLOCK)
		return -EINVAL;

	return 0;
}

M
Miklos Szeredi 已提交
118
void fuse_truncate(struct address_space *mapping, loff_t offset)
119 120 121 122 123 124 125
{
	/* See vmtruncate() */
	unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
	truncate_inode_pages(mapping, offset);
	unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
}

M
Miklos Szeredi 已提交
126 127
void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
				   u64 attr_valid)
M
Miklos Szeredi 已提交
128
{
M
Miklos Szeredi 已提交
129
	struct fuse_conn *fc = get_fuse_conn(inode);
130
	struct fuse_inode *fi = get_fuse_inode(inode);
M
Miklos Szeredi 已提交
131

132 133 134
	fi->attr_version = ++fc->attr_version;
	fi->i_time = attr_valid;

M
Miklos Szeredi 已提交
135
	inode->i_ino     = attr->ino;
136
	inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
M
Miklos Szeredi 已提交
137 138 139 140 141 142 143 144 145 146
	inode->i_nlink   = attr->nlink;
	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;
147

148 149 150 151 152
	if (attr->blksize != 0)
		inode->i_blkbits = ilog2(attr->blksize);
	else
		inode->i_blkbits = inode->i_sb->s_blocksize_bits;

153 154 155 156 157 158 159 160
	/*
	 * 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;
M
Miklos Szeredi 已提交
161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
}

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);
	if (attr_version != 0 && fi->attr_version > attr_version) {
		spin_unlock(&fc->lock);
		return;
	}

	fuse_change_attributes_common(inode, attr, attr_valid);
177

178 179 180 181 182 183 184
	oldsize = inode->i_size;
	i_size_write(inode, attr->size);
	spin_unlock(&fc->lock);

	if (S_ISREG(inode->i_mode) && oldsize != attr->size) {
		if (attr->size < oldsize)
			fuse_truncate(inode->i_mapping, attr->size);
M
Miklos Szeredi 已提交
185
		invalidate_inode_pages2(inode->i_mapping);
186
	}
M
Miklos Szeredi 已提交
187 188 189 190 191
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
M
Miklos Szeredi 已提交
192
	inode->i_size = attr->size;
193 194
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
M
Miklos Szeredi 已提交
195
		fuse_init_file_inode(inode);
196 197 198 199 200 201 202 203 204
	} 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));
205 206
	} else
		BUG();
M
Miklos Szeredi 已提交
207 208
}

J
John Muir 已提交
209
int fuse_inode_eq(struct inode *inode, void *_nodeidp)
M
Miklos Szeredi 已提交
210
{
M
Miklos Szeredi 已提交
211
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
212 213 214 215 216 217 218 219
	if (get_node_id(inode) == nodeid)
		return 1;
	else
		return 0;
}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
M
Miklos Szeredi 已提交
220
	u64 nodeid = *(u64 *) _nodeidp;
M
Miklos Szeredi 已提交
221 222 223 224
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

M
Miklos Szeredi 已提交
225
struct inode *fuse_iget(struct super_block *sb, u64 nodeid,
226 227
			int generation, struct fuse_attr *attr,
			u64 attr_valid, u64 attr_version)
M
Miklos Szeredi 已提交
228 229
{
	struct inode *inode;
230
	struct fuse_inode *fi;
M
Miklos Szeredi 已提交
231 232 233 234 235 236 237 238
	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)) {
239
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
M
Miklos Szeredi 已提交
240 241 242 243 244 245 246 247 248 249 250
		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;
	}

251
	fi = get_fuse_inode(inode);
252
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
253
	fi->nlookup++;
254
	spin_unlock(&fc->lock);
255 256
	fuse_change_attributes(inode, attr, attr_valid, attr_version);

M
Miklos Szeredi 已提交
257 258 259
	return inode;
}

J
John Muir 已提交
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
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;
}

285
static void fuse_umount_begin(struct super_block *sb)
286
{
287
	fuse_abort_conn(get_fuse_conn_super(sb));
288 289
}

290 291 292 293 294 295 296
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;
297
		fuse_request_send(fc, req);
298 299 300 301
		fuse_put_request(fc, req);
	}
}

302
static void fuse_bdi_destroy(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
303
{
304 305 306
	if (fc->bdi_initialized)
		bdi_destroy(&fc->bdi);
}
M
Miklos Szeredi 已提交
307

308
void fuse_conn_kill(struct fuse_conn *fc)
309
{
310
	spin_lock(&fc->lock);
311
	fc->connected = 0;
312
	fc->blocked = 0;
313
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
314
	/* Flush all readers on this fs */
315
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
M
Miklos Szeredi 已提交
316
	wake_up_all(&fc->waitq);
317
	wake_up_all(&fc->blocked_waitq);
318
	wake_up_all(&fc->reserved_req_waitq);
319 320 321 322
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
323 324
	fuse_bdi_destroy(fc);
}
325
EXPORT_SYMBOL_GPL(fuse_conn_kill);
326 327 328 329 330 331 332

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);
333
	fuse_conn_put(fc);
M
Miklos Szeredi 已提交
334 335
}

336 337 338 339
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
340
	stbuf->f_frsize  = attr->frsize;
341 342 343 344 345 346 347 348 349
	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 */
}

350
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
351
{
352
	struct super_block *sb = dentry->d_sb;
353 354 355 356 357
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

M
Miklos Szeredi 已提交
358 359 360 361 362
	if (!fuse_allow_task(fc, current)) {
		buf->f_type = FUSE_SUPER_MAGIC;
		return 0;
	}

363 364 365
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
366

367
	memset(&outarg, 0, sizeof(outarg));
368 369
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
370
	req->in.h.nodeid = get_node_id(dentry->d_inode);
371
	req->out.numargs = 1;
372 373
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
374
	req->out.args[0].value = &outarg;
375
	fuse_request_send(fc, req);
376 377 378 379 380 381 382
	err = req->out.h.error;
	if (!err)
		convert_fuse_statfs(buf, &outarg.st);
	fuse_put_request(fc, req);
	return err;
}

M
Miklos Szeredi 已提交
383 384 385 386
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
387
	OPT_GROUP_ID,
M
Miklos Szeredi 已提交
388 389
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
390
	OPT_MAX_READ,
M
Miklos Szeredi 已提交
391
	OPT_BLKSIZE,
M
Miklos Szeredi 已提交
392 393 394
	OPT_ERR
};

395
static const match_table_t tokens = {
M
Miklos Szeredi 已提交
396 397 398
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
399
	{OPT_GROUP_ID,			"group_id=%u"},
M
Miklos Szeredi 已提交
400 401
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
402
	{OPT_MAX_READ,			"max_read=%u"},
M
Miklos Szeredi 已提交
403
	{OPT_BLKSIZE,			"blksize=%u"},
M
Miklos Szeredi 已提交
404 405 406
	{OPT_ERR,			NULL}
};

M
Miklos Szeredi 已提交
407
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
M
Miklos Szeredi 已提交
408 409 410
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
411
	d->max_read = ~0;
M
Miklos Szeredi 已提交
412
	d->blksize = FUSE_DEFAULT_BLKSIZE;
M
Miklos Szeredi 已提交
413 414 415 416 417 418 419 420 421 422 423 424 425 426

	while ((p = strsep(&opt, ",")) != NULL) {
		int token;
		int value;
		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;
427
			d->fd_present = 1;
M
Miklos Szeredi 已提交
428 429 430 431 432
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
433 434
			if (!fuse_valid_type(value))
				return 0;
M
Miklos Szeredi 已提交
435
			d->rootmode = value;
436
			d->rootmode_present = 1;
M
Miklos Szeredi 已提交
437 438 439 440 441 442
			break;

		case OPT_USER_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->user_id = value;
443
			d->user_id_present = 1;
M
Miklos Szeredi 已提交
444 445
			break;

446 447 448 449
		case OPT_GROUP_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->group_id = value;
450
			d->group_id_present = 1;
451 452
			break;

M
Miklos Szeredi 已提交
453 454 455 456 457 458 459 460
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

461 462 463 464 465 466
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

M
Miklos Szeredi 已提交
467 468 469 470 471 472
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

M
Miklos Szeredi 已提交
473 474 475 476
		default:
			return 0;
		}
	}
477 478 479

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
M
Miklos Szeredi 已提交
480 481 482 483 484 485 486 487 488 489
		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);
490
	seq_printf(m, ",group_id=%u", fc->group_id);
M
Miklos Szeredi 已提交
491 492 493 494
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
495 496
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
M
Miklos Szeredi 已提交
497 498 499
	if (mnt->mnt_sb->s_bdev &&
	    mnt->mnt_sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
		seq_printf(m, ",blksize=%lu", mnt->mnt_sb->s_blocksize);
M
Miklos Szeredi 已提交
500 501 502
	return 0;
}

503
void fuse_conn_init(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
504
{
505 506 507
	memset(fc, 0, sizeof(*fc));
	spin_lock_init(&fc->lock);
	mutex_init(&fc->inst_mutex);
J
John Muir 已提交
508
	init_rwsem(&fc->killsb);
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	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);
	atomic_set(&fc->num_waiting, 0);
	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));
M
Miklos Szeredi 已提交
526
}
527
EXPORT_SYMBOL_GPL(fuse_conn_init);
M
Miklos Szeredi 已提交
528

529 530
void fuse_conn_put(struct fuse_conn *fc)
{
531
	if (atomic_dec_and_test(&fc->count)) {
532 533
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
534
		mutex_destroy(&fc->inst_mutex);
T
Tejun Heo 已提交
535
		fc->release(fc);
536
	}
537
}
538
EXPORT_SYMBOL_GPL(fuse_conn_put);
539 540 541 542 543 544

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

547
static struct inode *fuse_get_root_inode(struct super_block *sb, unsigned mode)
M
Miklos Szeredi 已提交
548 549 550 551 552 553
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
554
	attr.nlink = 1;
555
	return fuse_iget(sb, 1, 0, &attr, 0, 0);
M
Miklos Szeredi 已提交
556 557
}

M
Miklos Szeredi 已提交
558
struct fuse_inode_handle {
M
Miklos Szeredi 已提交
559 560 561 562 563 564 565
	u64 nodeid;
	u32 generation;
};

static struct dentry *fuse_get_dentry(struct super_block *sb,
				      struct fuse_inode_handle *handle)
{
566
	struct fuse_conn *fc = get_fuse_conn_super(sb);
M
Miklos Szeredi 已提交
567 568 569 570 571 572 573 574
	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);
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
	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;
	}
M
Miklos Szeredi 已提交
596 597 598 599
	err = -ESTALE;
	if (inode->i_generation != handle->generation)
		goto out_iput;

600 601
	entry = d_obtain_alias(inode);
	if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID) {
M
Miklos Szeredi 已提交
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
		entry->d_op = &fuse_dentry_operations;
		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;

	if (*max_len < len)
		return  255;

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

679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
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);
696 697 698
	if (err) {
		if (err == -ENOENT)
			return ERR_PTR(-ESTALE);
699 700
		return ERR_PTR(err);
	}
701 702 703

	parent = d_obtain_alias(inode);
	if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID) {
704 705 706 707 708 709
		parent->d_op = &fuse_dentry_operations;
		fuse_invalidate_entry_cache(parent);
	}

	return parent;
}
M
Miklos Szeredi 已提交
710 711 712 713 714

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,
715
	.get_parent	= fuse_get_parent,
M
Miklos Szeredi 已提交
716 717
};

718
static const struct super_operations fuse_super_operations = {
M
Miklos Szeredi 已提交
719 720 721
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
	.clear_inode	= fuse_clear_inode,
M
Miklos Szeredi 已提交
722
	.drop_inode	= generic_delete_inode,
723
	.remount_fs	= fuse_remount_fs,
M
Miklos Szeredi 已提交
724
	.put_super	= fuse_put_super,
725
	.umount_begin	= fuse_umount_begin,
726
	.statfs		= fuse_statfs,
M
Miklos Szeredi 已提交
727 728 729
	.show_options	= fuse_show_options,
};

730 731 732 733 734 735 736
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 {
737 738 739 740 741 742
		unsigned long ra_pages;

		if (arg->minor >= 6) {
			ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
			if (arg->flags & FUSE_ASYNC_READ)
				fc->async_read = 1;
743 744
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
745 746
			if (arg->flags & FUSE_ATOMIC_O_TRUNC)
				fc->atomic_o_trunc = 1;
747 748 749 750 751
			if (arg->minor >= 9) {
				/* LOOKUP has dependency on proto version */
				if (arg->flags & FUSE_EXPORT_SUPPORT)
					fc->export_support = 1;
			}
752 753
			if (arg->flags & FUSE_BIG_WRITES)
				fc->big_writes = 1;
754 755
			if (arg->flags & FUSE_DONT_MASK)
				fc->dont_mask = 1;
756
		} else {
757
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
758 759
			fc->no_lock = 1;
		}
760 761

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
762 763
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
764
		fc->max_write = max_t(unsigned, 4096, fc->max_write);
765
		fc->conn_init = 1;
766
	}
767 768
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
769 770
}

771
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
772 773
{
	struct fuse_init_in *arg = &req->misc.init_in;
M
Miklos Szeredi 已提交
774

775 776
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
777
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
778
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
779
		FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK;
780 781 782 783 784 785 786 787 788 789 790 791
	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;
	/* Variable length arguement used for backward compatibility
	   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;
792
	fuse_request_send_background(fc, req);
793 794
}

T
Tejun Heo 已提交
795 796 797 798 799
static void fuse_free_conn(struct fuse_conn *fc)
{
	kfree(fc);
}

800 801 802 803
static int fuse_bdi_init(struct fuse_conn *fc, struct super_block *sb)
{
	int err;

804
	fc->bdi.name = "fuse";
805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
	fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
	fc->bdi.unplug_io_fn = default_unplug_io_fn;
	/* 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;
}

M
Miklos Szeredi 已提交
843 844 845 846 847 848
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;
849
	struct dentry *root_dentry;
850
	struct fuse_req *init_req;
M
Miklos Szeredi 已提交
851
	int err;
M
Miklos Szeredi 已提交
852
	int is_bdev = sb->s_bdev != NULL;
M
Miklos Szeredi 已提交
853

854
	err = -EINVAL;
855
	if (sb->s_flags & MS_MANDLOCK)
856
		goto err;
857

M
Miklos Szeredi 已提交
858
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
859
		goto err;
M
Miklos Szeredi 已提交
860

M
Miklos Szeredi 已提交
861
	if (is_bdev) {
862
#ifdef CONFIG_BLOCK
863
		err = -EINVAL;
M
Miklos Szeredi 已提交
864
		if (!sb_set_blocksize(sb, d.blksize))
865
			goto err;
866
#endif
M
Miklos Szeredi 已提交
867 868 869 870
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
M
Miklos Szeredi 已提交
871 872 873
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
M
Miklos Szeredi 已提交
874
	sb->s_export_op = &fuse_export_operations;
M
Miklos Szeredi 已提交
875 876

	file = fget(d.fd);
877
	err = -EINVAL;
M
Miklos Szeredi 已提交
878
	if (!file)
879
		goto err;
M
Miklos Szeredi 已提交
880

881 882
	if (file->f_op != &fuse_dev_operations)
		goto err_fput;
M
Miklos Szeredi 已提交
883

884
	fc = kmalloc(sizeof(*fc), GFP_KERNEL);
885 886 887
	err = -ENOMEM;
	if (!fc)
		goto err_fput;
M
Miklos Szeredi 已提交
888

889 890 891
	fuse_conn_init(fc);

	fc->dev = sb->s_dev;
J
John Muir 已提交
892
	fc->sb = sb;
893 894 895
	err = fuse_bdi_init(fc, sb);
	if (err)
		goto err_put_conn;
896

897 898 899 900 901
	/* Handle umasking inside the fuse code */
	if (sb->s_flags & MS_POSIXACL)
		fc->dont_mask = 1;
	sb->s_flags |= MS_POSIXACL;

T
Tejun Heo 已提交
902
	fc->release = fuse_free_conn;
M
Miklos Szeredi 已提交
903
	fc->flags = d.flags;
M
Miklos Szeredi 已提交
904
	fc->user_id = d.user_id;
905
	fc->group_id = d.group_id;
906
	fc->max_read = max_t(unsigned, 4096, d.max_read);
M
Miklos Szeredi 已提交
907

908 909 910
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

M
Miklos Szeredi 已提交
911
	err = -ENOMEM;
912
	root = fuse_get_root_inode(sb, d.rootmode);
913
	if (!root)
914
		goto err_put_conn;
M
Miklos Szeredi 已提交
915

916 917
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
M
Miklos Szeredi 已提交
918
		iput(root);
919
		goto err_put_conn;
M
Miklos Szeredi 已提交
920
	}
921

922 923 924 925
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

926 927 928
	if (is_bdev) {
		fc->destroy_req = fuse_request_alloc();
		if (!fc->destroy_req)
J
Julia Lawall 已提交
929
			goto err_free_init_req;
930 931
	}

932
	mutex_lock(&fuse_mutex);
933 934
	err = -EINVAL;
	if (file->private_data)
935
		goto err_unlock;
936

937 938 939 940 941
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
942 943
	sb->s_root = root_dentry;
	fc->connected = 1;
944 945
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
M
Miklos Szeredi 已提交
946 947 948 949 950 951
	/*
	 * 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);
952

953
	fuse_send_init(fc, init_req);
954

M
Miklos Szeredi 已提交
955 956
	return 0;

957 958
 err_unlock:
	mutex_unlock(&fuse_mutex);
J
Julia Lawall 已提交
959
 err_free_init_req:
960
	fuse_request_free(init_req);
961 962
 err_put_root:
	dput(root_dentry);
963
 err_put_conn:
964
	fuse_bdi_destroy(fc);
965
	fuse_conn_put(fc);
966 967 968
 err_fput:
	fput(file);
 err:
M
Miklos Szeredi 已提交
969 970 971
	return err;
}

972 973 974
static int fuse_get_sb(struct file_system_type *fs_type,
		       int flags, const char *dev_name,
		       void *raw_data, struct vfsmount *mnt)
M
Miklos Szeredi 已提交
975
{
976
	return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
M
Miklos Szeredi 已提交
977 978
}

J
John Muir 已提交
979 980 981 982 983 984 985 986 987 988 989 990 991
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);
}

992 993 994
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
M
Miklos Szeredi 已提交
995
	.fs_flags	= FS_HAS_SUBTYPE,
996
	.get_sb		= fuse_get_sb,
J
John Muir 已提交
997
	.kill_sb	= fuse_kill_sb_anon,
998 999 1000
};

#ifdef CONFIG_BLOCK
1001 1002 1003 1004 1005 1006 1007 1008
static int fuse_get_sb_blk(struct file_system_type *fs_type,
			   int flags, const char *dev_name,
			   void *raw_data, struct vfsmount *mnt)
{
	return get_sb_bdev(fs_type, flags, dev_name, raw_data, fuse_fill_super,
			   mnt);
}

J
John Muir 已提交
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
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);
}

1022 1023 1024 1025
static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
	.get_sb		= fuse_get_sb_blk,
J
John Muir 已提交
1026
	.kill_sb	= fuse_kill_sb_blk,
A
Alexey Dobriyan 已提交
1027
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
1028 1029
};

1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
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

1050
static void fuse_inode_init_once(void *foo)
M
Miklos Szeredi 已提交
1051
{
M
Miklos Szeredi 已提交
1052
	struct inode *inode = foo;
M
Miklos Szeredi 已提交
1053

C
Christoph Lameter 已提交
1054
	inode_init_once(inode);
M
Miklos Szeredi 已提交
1055 1056 1057 1058 1059 1060 1061 1062
}

static int __init fuse_fs_init(void)
{
	int err;

	err = register_filesystem(&fuse_fs_type);
	if (err)
1063 1064
		goto out;

1065
	err = register_fuseblk();
1066 1067 1068 1069 1070 1071
	if (err)
		goto out_unreg;

	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
1072
					      fuse_inode_init_once);
1073 1074 1075 1076 1077
	err = -ENOMEM;
	if (!fuse_inode_cachep)
		goto out_unreg2;

	return 0;
M
Miklos Szeredi 已提交
1078

1079
 out_unreg2:
1080
	unregister_fuseblk();
1081 1082 1083
 out_unreg:
	unregister_filesystem(&fuse_fs_type);
 out:
M
Miklos Szeredi 已提交
1084 1085 1086 1087 1088 1089
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
1090
	unregister_fuseblk();
M
Miklos Szeredi 已提交
1091 1092 1093
	kmem_cache_destroy(fuse_inode_cachep);
}

1094 1095 1096
static struct kobject *fuse_kobj;
static struct kobject *connections_kobj;

1097 1098 1099 1100
static int fuse_sysfs_init(void)
{
	int err;

1101
	fuse_kobj = kobject_create_and_add("fuse", fs_kobj);
1102 1103
	if (!fuse_kobj) {
		err = -ENOMEM;
1104
		goto out_err;
1105
	}
1106

1107 1108 1109
	connections_kobj = kobject_create_and_add("connections", fuse_kobj);
	if (!connections_kobj) {
		err = -ENOMEM;
1110
		goto out_fuse_unregister;
1111
	}
1112 1113 1114 1115

	return 0;

 out_fuse_unregister:
1116
	kobject_put(fuse_kobj);
1117 1118 1119 1120 1121 1122
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
1123 1124
	kobject_put(connections_kobj);
	kobject_put(fuse_kobj);
1125 1126
}

M
Miklos Szeredi 已提交
1127 1128 1129 1130
static int __init fuse_init(void)
{
	int res;

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

1134
	INIT_LIST_HEAD(&fuse_conn_list);
M
Miklos Szeredi 已提交
1135 1136 1137 1138
	res = fuse_fs_init();
	if (res)
		goto err;

M
Miklos Szeredi 已提交
1139 1140 1141 1142
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

1143 1144 1145 1146
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

1147 1148 1149 1150
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

M
Miklos Szeredi 已提交
1151 1152
	return 0;

1153 1154
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
1155 1156
 err_dev_cleanup:
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1157 1158
 err_fs_cleanup:
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1159 1160 1161 1162 1163 1164 1165 1166
 err:
	return res;
}

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

1167
	fuse_ctl_cleanup();
1168
	fuse_sysfs_cleanup();
M
Miklos Szeredi 已提交
1169
	fuse_fs_cleanup();
M
Miklos Szeredi 已提交
1170
	fuse_dev_cleanup();
M
Miklos Szeredi 已提交
1171 1172 1173 1174
}

module_init(fuse_init);
module_exit(fuse_exit);