inode.c 18.4 KB
Newer Older
Miklos Szeredi's avatar
Miklos Szeredi committed
1
2
/*
  FUSE: Filesystem in Userspace
3
  Copyright (C) 2001-2006  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
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>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
20
#include <linux/sched.h>
Miklos Szeredi's avatar
Miklos Szeredi committed
21
22
23
24
25

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

26
static struct kmem_cache *fuse_inode_cachep;
27
28
struct list_head fuse_conn_list;
DEFINE_MUTEX(fuse_mutex);
Miklos Szeredi's avatar
Miklos Szeredi committed
29
30
31
32
33
34
35

#define FUSE_SUPER_MAGIC 0x65735546

struct fuse_mount_data {
	int fd;
	unsigned rootmode;
	unsigned user_id;
36
	unsigned group_id;
37
38
39
40
	unsigned fd_present : 1;
	unsigned rootmode_present : 1;
	unsigned user_id_present : 1;
	unsigned group_id_present : 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
41
	unsigned flags;
42
	unsigned max_read;
43
	unsigned blksize;
Miklos Szeredi's avatar
Miklos Szeredi committed
44
45
46
47
48
49
50
};

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

51
	inode = kmem_cache_alloc(fuse_inode_cachep, GFP_KERNEL);
Miklos Szeredi's avatar
Miklos Szeredi committed
52
53
54
55
	if (!inode)
		return NULL;

	fi = get_fuse_inode(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
56
	fi->i_time = 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
57
	fi->nodeid = 0;
58
	fi->nlookup = 0;
59
60
61
62
63
	fi->forget_req = fuse_request_alloc();
	if (!fi->forget_req) {
		kmem_cache_free(fuse_inode_cachep, inode);
		return NULL;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
64
65
66
67
68
69

	return inode;
}

static void fuse_destroy_inode(struct inode *inode)
{
70
71
72
	struct fuse_inode *fi = get_fuse_inode(inode);
	if (fi->forget_req)
		fuse_request_free(fi->forget_req);
Miklos Szeredi's avatar
Miklos Szeredi committed
73
74
75
76
77
78
79
80
	kmem_cache_free(fuse_inode_cachep, inode);
}

static void fuse_read_inode(struct inode *inode)
{
	/* No op */
}

81
void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
82
		      unsigned long nodeid, u64 nlookup)
83
84
{
	struct fuse_forget_in *inarg = &req->misc.forget_in;
85
	inarg->nlookup = nlookup;
86
87
88
89
90
91
92
93
	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;
	request_send_noreply(fc, req);
}

Miklos Szeredi's avatar
Miklos Szeredi committed
94
95
static void fuse_clear_inode(struct inode *inode)
{
Miklos Szeredi's avatar
Miklos Szeredi committed
96
97
	if (inode->i_sb->s_flags & MS_ACTIVE) {
		struct fuse_conn *fc = get_fuse_conn(inode);
98
		struct fuse_inode *fi = get_fuse_inode(inode);
99
		fuse_send_forget(fc, fi->forget_req, fi->nodeid, fi->nlookup);
100
101
		fi->forget_req = NULL;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
102
103
}

104
105
106
107
108
109
110
111
static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
{
	if (*flags & MS_MANDLOCK)
		return -EINVAL;

	return 0;
}

112
113
114
115
116
117
118
119
static void fuse_truncate(struct address_space *mapping, loff_t offset)
{
	/* 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);
}

Miklos Szeredi's avatar
Miklos Szeredi committed
120
121
void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
{
Miklos Szeredi's avatar
Miklos Szeredi committed
122
	struct fuse_conn *fc = get_fuse_conn(inode);
123
	loff_t oldsize;
Miklos Szeredi's avatar
Miklos Szeredi committed
124
125
126
127
128
129
130
131
132
133
134
135
136

	inode->i_ino     = attr->ino;
	inode->i_mode    = (inode->i_mode & S_IFMT) + (attr->mode & 07777);
	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;
137
138
139
140
141
142
143
144
145

	spin_lock(&fc->lock);
	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);
Miklos Szeredi's avatar
Miklos Szeredi committed
146
		invalidate_inode_pages2(inode->i_mapping);
147
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
148
149
150
151
152
}

static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
{
	inode->i_mode = attr->mode & S_IFMT;
Miklos Szeredi's avatar
Miklos Szeredi committed
153
	inode->i_size = attr->size;
154
155
	if (S_ISREG(inode->i_mode)) {
		fuse_init_common(inode);
156
		fuse_init_file_inode(inode);
157
158
159
160
161
162
163
164
165
	} 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));
166
167
	} else
		BUG();
Miklos Szeredi's avatar
Miklos Szeredi committed
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
}

static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
{
	unsigned long nodeid = *(unsigned long *) _nodeidp;
	if (get_node_id(inode) == nodeid)
		return 1;
	else
		return 0;
}

static int fuse_inode_set(struct inode *inode, void *_nodeidp)
{
	unsigned long nodeid = *(unsigned long *) _nodeidp;
	get_fuse_inode(inode)->nodeid = nodeid;
	return 0;
}

struct inode *fuse_iget(struct super_block *sb, unsigned long nodeid,
187
			int generation, struct fuse_attr *attr)
Miklos Szeredi's avatar
Miklos Szeredi committed
188
189
{
	struct inode *inode;
190
	struct fuse_inode *fi;
Miklos Szeredi's avatar
Miklos Szeredi committed
191
192
193
194
195
196
197
198
	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)) {
199
		inode->i_flags |= S_NOATIME|S_NOCMTIME;
Miklos Szeredi's avatar
Miklos Szeredi committed
200
201
202
203
204
205
206
207
208
209
210
		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;
	}

211
	fi = get_fuse_inode(inode);
212
	spin_lock(&fc->lock);
213
	fi->nlookup ++;
214
	spin_unlock(&fc->lock);
Miklos Szeredi's avatar
Miklos Szeredi committed
215
216
217
218
	fuse_change_attributes(inode, attr);
	return inode;
}

219
static void fuse_umount_begin(struct vfsmount *vfsmnt, int flags)
220
{
221
222
	if (flags & MNT_FORCE)
		fuse_abort_conn(get_fuse_conn_super(vfsmnt->mnt_sb));
223
224
}

225
226
227
228
229
230
231
232
233
234
235
236
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;
		request_send(fc, req);
		fuse_put_request(fc, req);
	}
}

Miklos Szeredi's avatar
Miklos Szeredi committed
237
238
239
240
static void fuse_put_super(struct super_block *sb)
{
	struct fuse_conn *fc = get_fuse_conn_super(sb);

241
	fuse_send_destroy(fc);
242
	spin_lock(&fc->lock);
243
	fc->connected = 0;
244
	fc->blocked = 0;
245
	spin_unlock(&fc->lock);
246
	/* Flush all readers on this fs */
247
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
248
	wake_up_all(&fc->waitq);
249
	wake_up_all(&fc->blocked_waitq);
250
	wake_up_all(&fc->reserved_req_waitq);
251
252
253
254
255
	mutex_lock(&fuse_mutex);
	list_del(&fc->entry);
	fuse_ctl_remove_conn(fc);
	mutex_unlock(&fuse_mutex);
	fuse_conn_put(fc);
Miklos Szeredi's avatar
Miklos Szeredi committed
256
257
}

258
259
260
261
static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
{
	stbuf->f_type    = FUSE_SUPER_MAGIC;
	stbuf->f_bsize   = attr->bsize;
262
	stbuf->f_frsize  = attr->frsize;
263
264
265
266
267
268
269
270
271
	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 */
}

272
static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
273
{
274
	struct super_block *sb = dentry->d_sb;
275
276
277
278
279
	struct fuse_conn *fc = get_fuse_conn_super(sb);
	struct fuse_req *req;
	struct fuse_statfs_out outarg;
	int err;

280
281
282
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
283

284
	memset(&outarg, 0, sizeof(outarg));
285
286
	req->in.numargs = 0;
	req->in.h.opcode = FUSE_STATFS;
287
	req->in.h.nodeid = get_node_id(dentry->d_inode);
288
	req->out.numargs = 1;
289
290
	req->out.args[0].size =
		fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
291
292
293
294
295
296
297
298
299
	req->out.args[0].value = &outarg;
	request_send(fc, req);
	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
300
301
302
303
enum {
	OPT_FD,
	OPT_ROOTMODE,
	OPT_USER_ID,
304
	OPT_GROUP_ID,
Miklos Szeredi's avatar
Miklos Szeredi committed
305
306
	OPT_DEFAULT_PERMISSIONS,
	OPT_ALLOW_OTHER,
307
	OPT_MAX_READ,
308
	OPT_BLKSIZE,
Miklos Szeredi's avatar
Miklos Szeredi committed
309
310
311
312
313
314
315
	OPT_ERR
};

static match_table_t tokens = {
	{OPT_FD,			"fd=%u"},
	{OPT_ROOTMODE,			"rootmode=%o"},
	{OPT_USER_ID,			"user_id=%u"},
316
	{OPT_GROUP_ID,			"group_id=%u"},
Miklos Szeredi's avatar
Miklos Szeredi committed
317
318
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
	{OPT_ALLOW_OTHER,		"allow_other"},
319
	{OPT_MAX_READ,			"max_read=%u"},
320
	{OPT_BLKSIZE,			"blksize=%u"},
Miklos Szeredi's avatar
Miklos Szeredi committed
321
322
323
	{OPT_ERR,			NULL}
};

324
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
Miklos Szeredi's avatar
Miklos Szeredi committed
325
326
327
{
	char *p;
	memset(d, 0, sizeof(struct fuse_mount_data));
328
	d->max_read = ~0;
329
	d->blksize = 512;
Miklos Szeredi's avatar
Miklos Szeredi committed
330
331
332
333
334
335
336
337
338
339
340
341
342
343

	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;
344
			d->fd_present = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
345
346
347
348
349
			break;

		case OPT_ROOTMODE:
			if (match_octal(&args[0], &value))
				return 0;
350
351
			if (!fuse_valid_type(value))
				return 0;
Miklos Szeredi's avatar
Miklos Szeredi committed
352
			d->rootmode = value;
353
			d->rootmode_present = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
354
355
356
357
358
359
			break;

		case OPT_USER_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->user_id = value;
360
			d->user_id_present = 1;
Miklos Szeredi's avatar
Miklos Szeredi committed
361
362
			break;

363
364
365
366
		case OPT_GROUP_ID:
			if (match_int(&args[0], &value))
				return 0;
			d->group_id = value;
367
			d->group_id_present = 1;
368
369
			break;

Miklos Szeredi's avatar
Miklos Szeredi committed
370
371
372
373
374
375
376
377
		case OPT_DEFAULT_PERMISSIONS:
			d->flags |= FUSE_DEFAULT_PERMISSIONS;
			break;

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

378
379
380
381
382
383
		case OPT_MAX_READ:
			if (match_int(&args[0], &value))
				return 0;
			d->max_read = value;
			break;

384
385
386
387
388
389
		case OPT_BLKSIZE:
			if (!is_bdev || match_int(&args[0], &value))
				return 0;
			d->blksize = value;
			break;

Miklos Szeredi's avatar
Miklos Szeredi committed
390
391
392
393
		default:
			return 0;
		}
	}
394
395
396

	if (!d->fd_present || !d->rootmode_present ||
	    !d->user_id_present || !d->group_id_present)
Miklos Szeredi's avatar
Miklos Szeredi committed
397
398
399
400
401
402
403
404
405
406
		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);
407
	seq_printf(m, ",group_id=%u", fc->group_id);
Miklos Szeredi's avatar
Miklos Szeredi committed
408
409
410
411
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS)
		seq_puts(m, ",default_permissions");
	if (fc->flags & FUSE_ALLOW_OTHER)
		seq_puts(m, ",allow_other");
412
413
	if (fc->max_read != ~0)
		seq_printf(m, ",max_read=%u", fc->max_read);
Miklos Szeredi's avatar
Miklos Szeredi committed
414
415
416
417
418
419
	return 0;
}

static struct fuse_conn *new_conn(void)
{
	struct fuse_conn *fc;
Peter Zijlstra's avatar
Peter Zijlstra committed
420
	int err;
Miklos Szeredi's avatar
Miklos Szeredi committed
421

422
	fc = kzalloc(sizeof(*fc), GFP_KERNEL);
423
	if (fc) {
424
		spin_lock_init(&fc->lock);
425
		mutex_init(&fc->inst_mutex);
426
		atomic_set(&fc->count, 1);
427
		init_waitqueue_head(&fc->waitq);
428
		init_waitqueue_head(&fc->blocked_waitq);
429
		init_waitqueue_head(&fc->reserved_req_waitq);
430
431
		INIT_LIST_HEAD(&fc->pending);
		INIT_LIST_HEAD(&fc->processing);
432
		INIT_LIST_HEAD(&fc->io);
433
		INIT_LIST_HEAD(&fc->interrupts);
434
		atomic_set(&fc->num_waiting, 0);
Miklos Szeredi's avatar
Miklos Szeredi committed
435
436
		fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
		fc->bdi.unplug_io_fn = default_unplug_io_fn;
Peter Zijlstra's avatar
Peter Zijlstra committed
437
438
439
440
441
442
		err = bdi_init(&fc->bdi);
		if (err) {
			kfree(fc);
			fc = NULL;
			goto out;
		}
443
		fc->reqctr = 0;
444
		fc->blocked = 1;
445
		get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
Miklos Szeredi's avatar
Miklos Szeredi committed
446
	}
Peter Zijlstra's avatar
Peter Zijlstra committed
447
out:
Miklos Szeredi's avatar
Miklos Szeredi committed
448
449
450
	return fc;
}

451
452
void fuse_conn_put(struct fuse_conn *fc)
{
453
	if (atomic_dec_and_test(&fc->count)) {
454
455
		if (fc->destroy_req)
			fuse_request_free(fc->destroy_req);
456
		mutex_destroy(&fc->inst_mutex);
Peter Zijlstra's avatar
Peter Zijlstra committed
457
		bdi_destroy(&fc->bdi);
458
		kfree(fc);
459
	}
460
461
462
463
464
465
466
467
}

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

Miklos Szeredi's avatar
Miklos Szeredi committed
468
469
470
471
472
473
474
static struct inode *get_root_inode(struct super_block *sb, unsigned mode)
{
	struct fuse_attr attr;
	memset(&attr, 0, sizeof(attr));

	attr.mode = mode;
	attr.ino = FUSE_ROOT_ID;
475
	return fuse_iget(sb, 1, 0, &attr);
Miklos Szeredi's avatar
Miklos Szeredi committed
476
477
}

478
static const struct super_operations fuse_super_operations = {
Miklos Szeredi's avatar
Miklos Szeredi committed
479
480
481
482
	.alloc_inode    = fuse_alloc_inode,
	.destroy_inode  = fuse_destroy_inode,
	.read_inode	= fuse_read_inode,
	.clear_inode	= fuse_clear_inode,
Miklos Szeredi's avatar
Miklos Szeredi committed
483
	.drop_inode	= generic_delete_inode,
484
	.remount_fs	= fuse_remount_fs,
Miklos Szeredi's avatar
Miklos Szeredi committed
485
	.put_super	= fuse_put_super,
486
	.umount_begin	= fuse_umount_begin,
487
	.statfs		= fuse_statfs,
Miklos Szeredi's avatar
Miklos Szeredi committed
488
489
490
	.show_options	= fuse_show_options,
};

491
492
493
494
495
496
497
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 {
498
499
500
501
502
503
		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;
504
505
506
			if (!(arg->flags & FUSE_POSIX_LOCKS))
				fc->no_lock = 1;
		} else {
507
			ra_pages = fc->max_read / PAGE_CACHE_SIZE;
508
509
			fc->no_lock = 1;
		}
510
511

		fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
512
513
		fc->minor = arg->minor;
		fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
514
		fc->conn_init = 1;
515
516
	}
	fuse_put_request(fc, req);
517
518
	fc->blocked = 0;
	wake_up_all(&fc->blocked_waitq);
519
520
}

521
static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
522
523
{
	struct fuse_init_in *arg = &req->misc.init_in;
524

525
526
	arg->major = FUSE_KERNEL_VERSION;
	arg->minor = FUSE_KERNEL_MINOR_VERSION;
527
	arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
528
	arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS;
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
	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;
	request_send_background(fc, req);
}

544
static u64 conn_id(void)
545
{
546
	static u64 ctr = 1;
547
	return ctr++;
548
549
}

Miklos Szeredi's avatar
Miklos Szeredi committed
550
551
552
553
554
555
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;
556
	struct dentry *root_dentry;
557
	struct fuse_req *init_req;
Miklos Szeredi's avatar
Miklos Szeredi committed
558
	int err;
559
	int is_bdev = sb->s_bdev != NULL;
Miklos Szeredi's avatar
Miklos Szeredi committed
560

561
562
563
	if (sb->s_flags & MS_MANDLOCK)
		return -EINVAL;

564
	if (!parse_fuse_opt((char *) data, &d, is_bdev))
Miklos Szeredi's avatar
Miklos Szeredi committed
565
566
		return -EINVAL;

567
	if (is_bdev) {
568
#ifdef CONFIG_BLOCK
569
570
		if (!sb_set_blocksize(sb, d.blksize))
			return -EINVAL;
571
#endif
572
573
574
575
	} else {
		sb->s_blocksize = PAGE_CACHE_SIZE;
		sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
576
577
578
579
580
581
582
583
	sb->s_magic = FUSE_SUPER_MAGIC;
	sb->s_op = &fuse_super_operations;
	sb->s_maxbytes = MAX_LFS_FILESIZE;

	file = fget(d.fd);
	if (!file)
		return -EINVAL;

584
585
586
587
588
589
	if (file->f_op != &fuse_dev_operations)
		return -EINVAL;

	fc = new_conn();
	if (!fc)
		return -ENOMEM;
Miklos Szeredi's avatar
Miklos Szeredi committed
590

Miklos Szeredi's avatar
Miklos Szeredi committed
591
	fc->flags = d.flags;
Miklos Szeredi's avatar
Miklos Szeredi committed
592
	fc->user_id = d.user_id;
593
	fc->group_id = d.group_id;
594
	fc->max_read = d.max_read;
Miklos Szeredi's avatar
Miklos Szeredi committed
595

596
597
598
	/* Used by get_root_inode() */
	sb->s_fs_info = fc;

Miklos Szeredi's avatar
Miklos Szeredi committed
599
600
	err = -ENOMEM;
	root = get_root_inode(sb, d.rootmode);
601
	if (!root)
Miklos Szeredi's avatar
Miklos Szeredi committed
602
603
		goto err;

604
605
	root_dentry = d_alloc_root(root);
	if (!root_dentry) {
Miklos Szeredi's avatar
Miklos Szeredi committed
606
607
608
		iput(root);
		goto err;
	}
609

610
611
612
613
	init_req = fuse_request_alloc();
	if (!init_req)
		goto err_put_root;

614
615
616
617
618
619
	if (is_bdev) {
		fc->destroy_req = fuse_request_alloc();
		if (!fc->destroy_req)
			goto err_put_root;
	}

620
	mutex_lock(&fuse_mutex);
621
622
	err = -EINVAL;
	if (file->private_data)
623
		goto err_unlock;
624

625
626
627
628
629
630
	fc->id = conn_id();
	err = fuse_ctl_add_conn(fc);
	if (err)
		goto err_unlock;

	list_add_tail(&fc->entry, &fuse_conn_list);
631
632
	sb->s_root = root_dentry;
	fc->connected = 1;
633
634
	file->private_data = fuse_conn_get(fc);
	mutex_unlock(&fuse_mutex);
635
636
637
638
639
640
	/*
	 * 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);
641

642
	fuse_send_init(fc, init_req);
643

Miklos Szeredi's avatar
Miklos Szeredi committed
644
645
	return 0;

646
647
 err_unlock:
	mutex_unlock(&fuse_mutex);
648
	fuse_request_free(init_req);
649
650
 err_put_root:
	dput(root_dentry);
Miklos Szeredi's avatar
Miklos Szeredi committed
651
 err:
652
	fput(file);
653
	fuse_conn_put(fc);
Miklos Szeredi's avatar
Miklos Szeredi committed
654
655
656
	return err;
}

657
658
659
static int fuse_get_sb(struct file_system_type *fs_type,
		       int flags, const char *dev_name,
		       void *raw_data, struct vfsmount *mnt)
Miklos Szeredi's avatar
Miklos Szeredi committed
660
{
661
	return get_sb_nodev(fs_type, flags, raw_data, fuse_fill_super, mnt);
Miklos Szeredi's avatar
Miklos Szeredi committed
662
663
}

664
665
666
static struct file_system_type fuse_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuse",
667
	.fs_flags	= FS_HAS_SUBTYPE,
668
669
670
671
672
	.get_sb		= fuse_get_sb,
	.kill_sb	= kill_anon_super,
};

#ifdef CONFIG_BLOCK
673
674
675
676
677
678
679
680
681
682
683
684
685
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);
}

static struct file_system_type fuseblk_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "fuseblk",
	.get_sb		= fuse_get_sb_blk,
	.kill_sb	= kill_block_super,
Alexey Dobriyan's avatar
Alexey Dobriyan committed
686
	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_SUBTYPE,
687
688
};

689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
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

709
static decl_subsys(fuse, NULL, NULL);
710
static decl_subsys(connections, NULL, NULL);
711

712
static void fuse_inode_init_once(struct kmem_cache *cachep, void *foo)
Miklos Szeredi's avatar
Miklos Szeredi committed
713
714
715
{
	struct inode * inode = foo;

716
	inode_init_once(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
717
718
719
720
721
722
723
724
}

static int __init fuse_fs_init(void)
{
	int err;

	err = register_filesystem(&fuse_fs_type);
	if (err)
725
726
		goto out;

727
	err = register_fuseblk();
728
729
730
731
732
733
	if (err)
		goto out_unreg;

	fuse_inode_cachep = kmem_cache_create("fuse_inode",
					      sizeof(struct fuse_inode),
					      0, SLAB_HWCACHE_ALIGN,
734
					      fuse_inode_init_once);
735
736
737
738
739
	err = -ENOMEM;
	if (!fuse_inode_cachep)
		goto out_unreg2;

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

741
 out_unreg2:
742
	unregister_fuseblk();
743
744
745
 out_unreg:
	unregister_filesystem(&fuse_fs_type);
 out:
Miklos Szeredi's avatar
Miklos Szeredi committed
746
747
748
749
750
751
	return err;
}

static void fuse_fs_cleanup(void)
{
	unregister_filesystem(&fuse_fs_type);
752
	unregister_fuseblk();
Miklos Szeredi's avatar
Miklos Szeredi committed
753
754
755
	kmem_cache_destroy(fuse_inode_cachep);
}

756
757
758
759
static int fuse_sysfs_init(void)
{
	int err;

760
	kobj_set_kset_s(&fuse_subsys, fs_subsys);
761
762
763
764
	err = subsystem_register(&fuse_subsys);
	if (err)
		goto out_err;

765
	kobj_set_kset_s(&connections_subsys, fuse_subsys);
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
	err = subsystem_register(&connections_subsys);
	if (err)
		goto out_fuse_unregister;

	return 0;

 out_fuse_unregister:
	subsystem_unregister(&fuse_subsys);
 out_err:
	return err;
}

static void fuse_sysfs_cleanup(void)
{
	subsystem_unregister(&connections_subsys);
	subsystem_unregister(&fuse_subsys);
}

Miklos Szeredi's avatar
Miklos Szeredi committed
784
785
786
787
788
789
790
static int __init fuse_init(void)
{
	int res;

	printk("fuse init (API version %i.%i)\n",
	       FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);

791
	INIT_LIST_HEAD(&fuse_conn_list);
Miklos Szeredi's avatar
Miklos Szeredi committed
792
793
794
795
	res = fuse_fs_init();
	if (res)
		goto err;

796
797
798
799
	res = fuse_dev_init();
	if (res)
		goto err_fs_cleanup;

800
801
802
803
	res = fuse_sysfs_init();
	if (res)
		goto err_dev_cleanup;

804
805
806
807
	res = fuse_ctl_init();
	if (res)
		goto err_sysfs_cleanup;

Miklos Szeredi's avatar
Miklos Szeredi committed
808
809
	return 0;

810
811
 err_sysfs_cleanup:
	fuse_sysfs_cleanup();
812
813
 err_dev_cleanup:
	fuse_dev_cleanup();
814
815
 err_fs_cleanup:
	fuse_fs_cleanup();
Miklos Szeredi's avatar
Miklos Szeredi committed
816
817
818
819
820
821
822
823
 err:
	return res;
}

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

824
	fuse_ctl_cleanup();
825
	fuse_sysfs_cleanup();
Miklos Szeredi's avatar
Miklos Szeredi committed
826
	fuse_fs_cleanup();
827
	fuse_dev_cleanup();
Miklos Szeredi's avatar
Miklos Szeredi committed
828
829
830
831
}

module_init(fuse_init);
module_exit(fuse_exit);