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