Merge branch 'work.mkdir' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[sfrench/cifs-2.6.git] / fs / fuse / dir.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/file.h>
13 #include <linux/sched.h>
14 #include <linux/namei.h>
15 #include <linux/slab.h>
16 #include <linux/xattr.h>
17 #include <linux/posix_acl.h>
18
19 static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
20 {
21         struct fuse_conn *fc = get_fuse_conn(dir);
22         struct fuse_inode *fi = get_fuse_inode(dir);
23
24         if (!fc->do_readdirplus)
25                 return false;
26         if (!fc->readdirplus_auto)
27                 return true;
28         if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
29                 return true;
30         if (ctx->pos == 0)
31                 return true;
32         return false;
33 }
34
35 static void fuse_advise_use_readdirplus(struct inode *dir)
36 {
37         struct fuse_inode *fi = get_fuse_inode(dir);
38
39         set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
40 }
41
42 union fuse_dentry {
43         u64 time;
44         struct rcu_head rcu;
45 };
46
47 static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
48 {
49         ((union fuse_dentry *) entry->d_fsdata)->time = time;
50 }
51
52 static inline u64 fuse_dentry_time(struct dentry *entry)
53 {
54         return ((union fuse_dentry *) entry->d_fsdata)->time;
55 }
56
57 /*
58  * FUSE caches dentries and attributes with separate timeout.  The
59  * time in jiffies until the dentry/attributes are valid is stored in
60  * dentry->d_fsdata and fuse_inode->i_time respectively.
61  */
62
63 /*
64  * Calculate the time in jiffies until a dentry/attributes are valid
65  */
66 static u64 time_to_jiffies(u64 sec, u32 nsec)
67 {
68         if (sec || nsec) {
69                 struct timespec64 ts = {
70                         sec,
71                         min_t(u32, nsec, NSEC_PER_SEC - 1)
72                 };
73
74                 return get_jiffies_64() + timespec64_to_jiffies(&ts);
75         } else
76                 return 0;
77 }
78
79 /*
80  * Set dentry and possibly attribute timeouts from the lookup/mk*
81  * replies
82  */
83 static void fuse_change_entry_timeout(struct dentry *entry,
84                                       struct fuse_entry_out *o)
85 {
86         fuse_dentry_settime(entry,
87                 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
88 }
89
90 static u64 attr_timeout(struct fuse_attr_out *o)
91 {
92         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
93 }
94
95 static u64 entry_attr_timeout(struct fuse_entry_out *o)
96 {
97         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
98 }
99
100 /*
101  * Mark the attributes as stale, so that at the next call to
102  * ->getattr() they will be fetched from userspace
103  */
104 void fuse_invalidate_attr(struct inode *inode)
105 {
106         get_fuse_inode(inode)->i_time = 0;
107 }
108
109 /**
110  * Mark the attributes as stale due to an atime change.  Avoid the invalidate if
111  * atime is not used.
112  */
113 void fuse_invalidate_atime(struct inode *inode)
114 {
115         if (!IS_RDONLY(inode))
116                 fuse_invalidate_attr(inode);
117 }
118
119 /*
120  * Just mark the entry as stale, so that a next attempt to look it up
121  * will result in a new lookup call to userspace
122  *
123  * This is called when a dentry is about to become negative and the
124  * timeout is unknown (unlink, rmdir, rename and in some cases
125  * lookup)
126  */
127 void fuse_invalidate_entry_cache(struct dentry *entry)
128 {
129         fuse_dentry_settime(entry, 0);
130 }
131
132 /*
133  * Same as fuse_invalidate_entry_cache(), but also try to remove the
134  * dentry from the hash
135  */
136 static void fuse_invalidate_entry(struct dentry *entry)
137 {
138         d_invalidate(entry);
139         fuse_invalidate_entry_cache(entry);
140 }
141
142 static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_args *args,
143                              u64 nodeid, const struct qstr *name,
144                              struct fuse_entry_out *outarg)
145 {
146         memset(outarg, 0, sizeof(struct fuse_entry_out));
147         args->in.h.opcode = FUSE_LOOKUP;
148         args->in.h.nodeid = nodeid;
149         args->in.numargs = 1;
150         args->in.args[0].size = name->len + 1;
151         args->in.args[0].value = name->name;
152         args->out.numargs = 1;
153         args->out.args[0].size = sizeof(struct fuse_entry_out);
154         args->out.args[0].value = outarg;
155 }
156
157 u64 fuse_get_attr_version(struct fuse_conn *fc)
158 {
159         u64 curr_version;
160
161         /*
162          * The spin lock isn't actually needed on 64bit archs, but we
163          * don't yet care too much about such optimizations.
164          */
165         spin_lock(&fc->lock);
166         curr_version = fc->attr_version;
167         spin_unlock(&fc->lock);
168
169         return curr_version;
170 }
171
172 /*
173  * Check whether the dentry is still valid
174  *
175  * If the entry validity timeout has expired and the dentry is
176  * positive, try to redo the lookup.  If the lookup results in a
177  * different inode, then let the VFS invalidate the dentry and redo
178  * the lookup once more.  If the lookup results in the same inode,
179  * then refresh the attributes, timeouts and mark the dentry valid.
180  */
181 static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
182 {
183         struct inode *inode;
184         struct dentry *parent;
185         struct fuse_conn *fc;
186         struct fuse_inode *fi;
187         int ret;
188
189         inode = d_inode_rcu(entry);
190         if (inode && is_bad_inode(inode))
191                 goto invalid;
192         else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
193                  (flags & LOOKUP_REVAL)) {
194                 struct fuse_entry_out outarg;
195                 FUSE_ARGS(args);
196                 struct fuse_forget_link *forget;
197                 u64 attr_version;
198
199                 /* For negative dentries, always do a fresh lookup */
200                 if (!inode)
201                         goto invalid;
202
203                 ret = -ECHILD;
204                 if (flags & LOOKUP_RCU)
205                         goto out;
206
207                 fc = get_fuse_conn(inode);
208
209                 forget = fuse_alloc_forget();
210                 ret = -ENOMEM;
211                 if (!forget)
212                         goto out;
213
214                 attr_version = fuse_get_attr_version(fc);
215
216                 parent = dget_parent(entry);
217                 fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)),
218                                  &entry->d_name, &outarg);
219                 ret = fuse_simple_request(fc, &args);
220                 dput(parent);
221                 /* Zero nodeid is same as -ENOENT */
222                 if (!ret && !outarg.nodeid)
223                         ret = -ENOENT;
224                 if (!ret) {
225                         fi = get_fuse_inode(inode);
226                         if (outarg.nodeid != get_node_id(inode)) {
227                                 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
228                                 goto invalid;
229                         }
230                         spin_lock(&fc->lock);
231                         fi->nlookup++;
232                         spin_unlock(&fc->lock);
233                 }
234                 kfree(forget);
235                 if (ret == -ENOMEM)
236                         goto out;
237                 if (ret || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
238                         goto invalid;
239
240                 forget_all_cached_acls(inode);
241                 fuse_change_attributes(inode, &outarg.attr,
242                                        entry_attr_timeout(&outarg),
243                                        attr_version);
244                 fuse_change_entry_timeout(entry, &outarg);
245         } else if (inode) {
246                 fi = get_fuse_inode(inode);
247                 if (flags & LOOKUP_RCU) {
248                         if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
249                                 return -ECHILD;
250                 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
251                         parent = dget_parent(entry);
252                         fuse_advise_use_readdirplus(d_inode(parent));
253                         dput(parent);
254                 }
255         }
256         ret = 1;
257 out:
258         return ret;
259
260 invalid:
261         ret = 0;
262         goto out;
263 }
264
265 static int invalid_nodeid(u64 nodeid)
266 {
267         return !nodeid || nodeid == FUSE_ROOT_ID;
268 }
269
270 static int fuse_dentry_init(struct dentry *dentry)
271 {
272         dentry->d_fsdata = kzalloc(sizeof(union fuse_dentry), GFP_KERNEL);
273
274         return dentry->d_fsdata ? 0 : -ENOMEM;
275 }
276 static void fuse_dentry_release(struct dentry *dentry)
277 {
278         union fuse_dentry *fd = dentry->d_fsdata;
279
280         kfree_rcu(fd, rcu);
281 }
282
283 const struct dentry_operations fuse_dentry_operations = {
284         .d_revalidate   = fuse_dentry_revalidate,
285         .d_init         = fuse_dentry_init,
286         .d_release      = fuse_dentry_release,
287 };
288
289 const struct dentry_operations fuse_root_dentry_operations = {
290         .d_init         = fuse_dentry_init,
291         .d_release      = fuse_dentry_release,
292 };
293
294 int fuse_valid_type(int m)
295 {
296         return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
297                 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
298 }
299
300 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
301                      struct fuse_entry_out *outarg, struct inode **inode)
302 {
303         struct fuse_conn *fc = get_fuse_conn_super(sb);
304         FUSE_ARGS(args);
305         struct fuse_forget_link *forget;
306         u64 attr_version;
307         int err;
308
309         *inode = NULL;
310         err = -ENAMETOOLONG;
311         if (name->len > FUSE_NAME_MAX)
312                 goto out;
313
314
315         forget = fuse_alloc_forget();
316         err = -ENOMEM;
317         if (!forget)
318                 goto out;
319
320         attr_version = fuse_get_attr_version(fc);
321
322         fuse_lookup_init(fc, &args, nodeid, name, outarg);
323         err = fuse_simple_request(fc, &args);
324         /* Zero nodeid is same as -ENOENT, but with valid timeout */
325         if (err || !outarg->nodeid)
326                 goto out_put_forget;
327
328         err = -EIO;
329         if (!outarg->nodeid)
330                 goto out_put_forget;
331         if (!fuse_valid_type(outarg->attr.mode))
332                 goto out_put_forget;
333
334         *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
335                            &outarg->attr, entry_attr_timeout(outarg),
336                            attr_version);
337         err = -ENOMEM;
338         if (!*inode) {
339                 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
340                 goto out;
341         }
342         err = 0;
343
344  out_put_forget:
345         kfree(forget);
346  out:
347         return err;
348 }
349
350 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
351                                   unsigned int flags)
352 {
353         int err;
354         struct fuse_entry_out outarg;
355         struct inode *inode;
356         struct dentry *newent;
357         bool outarg_valid = true;
358
359         fuse_lock_inode(dir);
360         err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
361                                &outarg, &inode);
362         fuse_unlock_inode(dir);
363         if (err == -ENOENT) {
364                 outarg_valid = false;
365                 err = 0;
366         }
367         if (err)
368                 goto out_err;
369
370         err = -EIO;
371         if (inode && get_node_id(inode) == FUSE_ROOT_ID)
372                 goto out_iput;
373
374         newent = d_splice_alias(inode, entry);
375         err = PTR_ERR(newent);
376         if (IS_ERR(newent))
377                 goto out_err;
378
379         entry = newent ? newent : entry;
380         if (outarg_valid)
381                 fuse_change_entry_timeout(entry, &outarg);
382         else
383                 fuse_invalidate_entry_cache(entry);
384
385         fuse_advise_use_readdirplus(dir);
386         return newent;
387
388  out_iput:
389         iput(inode);
390  out_err:
391         return ERR_PTR(err);
392 }
393
394 /*
395  * Atomic create+open operation
396  *
397  * If the filesystem doesn't support this, then fall back to separate
398  * 'mknod' + 'open' requests.
399  */
400 static int fuse_create_open(struct inode *dir, struct dentry *entry,
401                             struct file *file, unsigned flags,
402                             umode_t mode)
403 {
404         int err;
405         struct inode *inode;
406         struct fuse_conn *fc = get_fuse_conn(dir);
407         FUSE_ARGS(args);
408         struct fuse_forget_link *forget;
409         struct fuse_create_in inarg;
410         struct fuse_open_out outopen;
411         struct fuse_entry_out outentry;
412         struct fuse_file *ff;
413
414         /* Userspace expects S_IFREG in create mode */
415         BUG_ON((mode & S_IFMT) != S_IFREG);
416
417         forget = fuse_alloc_forget();
418         err = -ENOMEM;
419         if (!forget)
420                 goto out_err;
421
422         err = -ENOMEM;
423         ff = fuse_file_alloc(fc);
424         if (!ff)
425                 goto out_put_forget_req;
426
427         if (!fc->dont_mask)
428                 mode &= ~current_umask();
429
430         flags &= ~O_NOCTTY;
431         memset(&inarg, 0, sizeof(inarg));
432         memset(&outentry, 0, sizeof(outentry));
433         inarg.flags = flags;
434         inarg.mode = mode;
435         inarg.umask = current_umask();
436         args.in.h.opcode = FUSE_CREATE;
437         args.in.h.nodeid = get_node_id(dir);
438         args.in.numargs = 2;
439         args.in.args[0].size = sizeof(inarg);
440         args.in.args[0].value = &inarg;
441         args.in.args[1].size = entry->d_name.len + 1;
442         args.in.args[1].value = entry->d_name.name;
443         args.out.numargs = 2;
444         args.out.args[0].size = sizeof(outentry);
445         args.out.args[0].value = &outentry;
446         args.out.args[1].size = sizeof(outopen);
447         args.out.args[1].value = &outopen;
448         err = fuse_simple_request(fc, &args);
449         if (err)
450                 goto out_free_ff;
451
452         err = -EIO;
453         if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
454                 goto out_free_ff;
455
456         ff->fh = outopen.fh;
457         ff->nodeid = outentry.nodeid;
458         ff->open_flags = outopen.open_flags;
459         inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
460                           &outentry.attr, entry_attr_timeout(&outentry), 0);
461         if (!inode) {
462                 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
463                 fuse_sync_release(ff, flags);
464                 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
465                 err = -ENOMEM;
466                 goto out_err;
467         }
468         kfree(forget);
469         d_instantiate(entry, inode);
470         fuse_change_entry_timeout(entry, &outentry);
471         fuse_invalidate_attr(dir);
472         err = finish_open(file, entry, generic_file_open);
473         if (err) {
474                 fuse_sync_release(ff, flags);
475         } else {
476                 file->private_data = ff;
477                 fuse_finish_open(inode, file);
478         }
479         return err;
480
481 out_free_ff:
482         fuse_file_free(ff);
483 out_put_forget_req:
484         kfree(forget);
485 out_err:
486         return err;
487 }
488
489 static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
490 static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
491                             struct file *file, unsigned flags,
492                             umode_t mode)
493 {
494         int err;
495         struct fuse_conn *fc = get_fuse_conn(dir);
496         struct dentry *res = NULL;
497
498         if (d_in_lookup(entry)) {
499                 res = fuse_lookup(dir, entry, 0);
500                 if (IS_ERR(res))
501                         return PTR_ERR(res);
502
503                 if (res)
504                         entry = res;
505         }
506
507         if (!(flags & O_CREAT) || d_really_is_positive(entry))
508                 goto no_open;
509
510         /* Only creates */
511         file->f_mode |= FMODE_CREATED;
512
513         if (fc->no_create)
514                 goto mknod;
515
516         err = fuse_create_open(dir, entry, file, flags, mode);
517         if (err == -ENOSYS) {
518                 fc->no_create = 1;
519                 goto mknod;
520         }
521 out_dput:
522         dput(res);
523         return err;
524
525 mknod:
526         err = fuse_mknod(dir, entry, mode, 0);
527         if (err)
528                 goto out_dput;
529 no_open:
530         return finish_no_open(file, res);
531 }
532
533 /*
534  * Code shared between mknod, mkdir, symlink and link
535  */
536 static int create_new_entry(struct fuse_conn *fc, struct fuse_args *args,
537                             struct inode *dir, struct dentry *entry,
538                             umode_t mode)
539 {
540         struct fuse_entry_out outarg;
541         struct inode *inode;
542         struct dentry *d;
543         int err;
544         struct fuse_forget_link *forget;
545
546         forget = fuse_alloc_forget();
547         if (!forget)
548                 return -ENOMEM;
549
550         memset(&outarg, 0, sizeof(outarg));
551         args->in.h.nodeid = get_node_id(dir);
552         args->out.numargs = 1;
553         args->out.args[0].size = sizeof(outarg);
554         args->out.args[0].value = &outarg;
555         err = fuse_simple_request(fc, args);
556         if (err)
557                 goto out_put_forget_req;
558
559         err = -EIO;
560         if (invalid_nodeid(outarg.nodeid))
561                 goto out_put_forget_req;
562
563         if ((outarg.attr.mode ^ mode) & S_IFMT)
564                 goto out_put_forget_req;
565
566         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
567                           &outarg.attr, entry_attr_timeout(&outarg), 0);
568         if (!inode) {
569                 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
570                 return -ENOMEM;
571         }
572         kfree(forget);
573
574         d_drop(entry);
575         d = d_splice_alias(inode, entry);
576         if (IS_ERR(d))
577                 return PTR_ERR(d);
578
579         if (d) {
580                 fuse_change_entry_timeout(d, &outarg);
581                 dput(d);
582         } else {
583                 fuse_change_entry_timeout(entry, &outarg);
584         }
585         fuse_invalidate_attr(dir);
586         return 0;
587
588  out_put_forget_req:
589         kfree(forget);
590         return err;
591 }
592
593 static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
594                       dev_t rdev)
595 {
596         struct fuse_mknod_in inarg;
597         struct fuse_conn *fc = get_fuse_conn(dir);
598         FUSE_ARGS(args);
599
600         if (!fc->dont_mask)
601                 mode &= ~current_umask();
602
603         memset(&inarg, 0, sizeof(inarg));
604         inarg.mode = mode;
605         inarg.rdev = new_encode_dev(rdev);
606         inarg.umask = current_umask();
607         args.in.h.opcode = FUSE_MKNOD;
608         args.in.numargs = 2;
609         args.in.args[0].size = sizeof(inarg);
610         args.in.args[0].value = &inarg;
611         args.in.args[1].size = entry->d_name.len + 1;
612         args.in.args[1].value = entry->d_name.name;
613         return create_new_entry(fc, &args, dir, entry, mode);
614 }
615
616 static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
617                        bool excl)
618 {
619         return fuse_mknod(dir, entry, mode, 0);
620 }
621
622 static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
623 {
624         struct fuse_mkdir_in inarg;
625         struct fuse_conn *fc = get_fuse_conn(dir);
626         FUSE_ARGS(args);
627
628         if (!fc->dont_mask)
629                 mode &= ~current_umask();
630
631         memset(&inarg, 0, sizeof(inarg));
632         inarg.mode = mode;
633         inarg.umask = current_umask();
634         args.in.h.opcode = FUSE_MKDIR;
635         args.in.numargs = 2;
636         args.in.args[0].size = sizeof(inarg);
637         args.in.args[0].value = &inarg;
638         args.in.args[1].size = entry->d_name.len + 1;
639         args.in.args[1].value = entry->d_name.name;
640         return create_new_entry(fc, &args, dir, entry, S_IFDIR);
641 }
642
643 static int fuse_symlink(struct inode *dir, struct dentry *entry,
644                         const char *link)
645 {
646         struct fuse_conn *fc = get_fuse_conn(dir);
647         unsigned len = strlen(link) + 1;
648         FUSE_ARGS(args);
649
650         args.in.h.opcode = FUSE_SYMLINK;
651         args.in.numargs = 2;
652         args.in.args[0].size = entry->d_name.len + 1;
653         args.in.args[0].value = entry->d_name.name;
654         args.in.args[1].size = len;
655         args.in.args[1].value = link;
656         return create_new_entry(fc, &args, dir, entry, S_IFLNK);
657 }
658
659 void fuse_update_ctime(struct inode *inode)
660 {
661         if (!IS_NOCMTIME(inode)) {
662                 inode->i_ctime = current_time(inode);
663                 mark_inode_dirty_sync(inode);
664         }
665 }
666
667 static int fuse_unlink(struct inode *dir, struct dentry *entry)
668 {
669         int err;
670         struct fuse_conn *fc = get_fuse_conn(dir);
671         FUSE_ARGS(args);
672
673         args.in.h.opcode = FUSE_UNLINK;
674         args.in.h.nodeid = get_node_id(dir);
675         args.in.numargs = 1;
676         args.in.args[0].size = entry->d_name.len + 1;
677         args.in.args[0].value = entry->d_name.name;
678         err = fuse_simple_request(fc, &args);
679         if (!err) {
680                 struct inode *inode = d_inode(entry);
681                 struct fuse_inode *fi = get_fuse_inode(inode);
682
683                 spin_lock(&fc->lock);
684                 fi->attr_version = ++fc->attr_version;
685                 /*
686                  * If i_nlink == 0 then unlink doesn't make sense, yet this can
687                  * happen if userspace filesystem is careless.  It would be
688                  * difficult to enforce correct nlink usage so just ignore this
689                  * condition here
690                  */
691                 if (inode->i_nlink > 0)
692                         drop_nlink(inode);
693                 spin_unlock(&fc->lock);
694                 fuse_invalidate_attr(inode);
695                 fuse_invalidate_attr(dir);
696                 fuse_invalidate_entry_cache(entry);
697                 fuse_update_ctime(inode);
698         } else if (err == -EINTR)
699                 fuse_invalidate_entry(entry);
700         return err;
701 }
702
703 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
704 {
705         int err;
706         struct fuse_conn *fc = get_fuse_conn(dir);
707         FUSE_ARGS(args);
708
709         args.in.h.opcode = FUSE_RMDIR;
710         args.in.h.nodeid = get_node_id(dir);
711         args.in.numargs = 1;
712         args.in.args[0].size = entry->d_name.len + 1;
713         args.in.args[0].value = entry->d_name.name;
714         err = fuse_simple_request(fc, &args);
715         if (!err) {
716                 clear_nlink(d_inode(entry));
717                 fuse_invalidate_attr(dir);
718                 fuse_invalidate_entry_cache(entry);
719         } else if (err == -EINTR)
720                 fuse_invalidate_entry(entry);
721         return err;
722 }
723
724 static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
725                               struct inode *newdir, struct dentry *newent,
726                               unsigned int flags, int opcode, size_t argsize)
727 {
728         int err;
729         struct fuse_rename2_in inarg;
730         struct fuse_conn *fc = get_fuse_conn(olddir);
731         FUSE_ARGS(args);
732
733         memset(&inarg, 0, argsize);
734         inarg.newdir = get_node_id(newdir);
735         inarg.flags = flags;
736         args.in.h.opcode = opcode;
737         args.in.h.nodeid = get_node_id(olddir);
738         args.in.numargs = 3;
739         args.in.args[0].size = argsize;
740         args.in.args[0].value = &inarg;
741         args.in.args[1].size = oldent->d_name.len + 1;
742         args.in.args[1].value = oldent->d_name.name;
743         args.in.args[2].size = newent->d_name.len + 1;
744         args.in.args[2].value = newent->d_name.name;
745         err = fuse_simple_request(fc, &args);
746         if (!err) {
747                 /* ctime changes */
748                 fuse_invalidate_attr(d_inode(oldent));
749                 fuse_update_ctime(d_inode(oldent));
750
751                 if (flags & RENAME_EXCHANGE) {
752                         fuse_invalidate_attr(d_inode(newent));
753                         fuse_update_ctime(d_inode(newent));
754                 }
755
756                 fuse_invalidate_attr(olddir);
757                 if (olddir != newdir)
758                         fuse_invalidate_attr(newdir);
759
760                 /* newent will end up negative */
761                 if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) {
762                         fuse_invalidate_attr(d_inode(newent));
763                         fuse_invalidate_entry_cache(newent);
764                         fuse_update_ctime(d_inode(newent));
765                 }
766         } else if (err == -EINTR) {
767                 /* If request was interrupted, DEITY only knows if the
768                    rename actually took place.  If the invalidation
769                    fails (e.g. some process has CWD under the renamed
770                    directory), then there can be inconsistency between
771                    the dcache and the real filesystem.  Tough luck. */
772                 fuse_invalidate_entry(oldent);
773                 if (d_really_is_positive(newent))
774                         fuse_invalidate_entry(newent);
775         }
776
777         return err;
778 }
779
780 static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
781                         struct inode *newdir, struct dentry *newent,
782                         unsigned int flags)
783 {
784         struct fuse_conn *fc = get_fuse_conn(olddir);
785         int err;
786
787         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
788                 return -EINVAL;
789
790         if (flags) {
791                 if (fc->no_rename2 || fc->minor < 23)
792                         return -EINVAL;
793
794                 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
795                                          FUSE_RENAME2,
796                                          sizeof(struct fuse_rename2_in));
797                 if (err == -ENOSYS) {
798                         fc->no_rename2 = 1;
799                         err = -EINVAL;
800                 }
801         } else {
802                 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
803                                          FUSE_RENAME,
804                                          sizeof(struct fuse_rename_in));
805         }
806
807         return err;
808 }
809
810 static int fuse_link(struct dentry *entry, struct inode *newdir,
811                      struct dentry *newent)
812 {
813         int err;
814         struct fuse_link_in inarg;
815         struct inode *inode = d_inode(entry);
816         struct fuse_conn *fc = get_fuse_conn(inode);
817         FUSE_ARGS(args);
818
819         memset(&inarg, 0, sizeof(inarg));
820         inarg.oldnodeid = get_node_id(inode);
821         args.in.h.opcode = FUSE_LINK;
822         args.in.numargs = 2;
823         args.in.args[0].size = sizeof(inarg);
824         args.in.args[0].value = &inarg;
825         args.in.args[1].size = newent->d_name.len + 1;
826         args.in.args[1].value = newent->d_name.name;
827         err = create_new_entry(fc, &args, newdir, newent, inode->i_mode);
828         /* Contrary to "normal" filesystems it can happen that link
829            makes two "logical" inodes point to the same "physical"
830            inode.  We invalidate the attributes of the old one, so it
831            will reflect changes in the backing inode (link count,
832            etc.)
833         */
834         if (!err) {
835                 struct fuse_inode *fi = get_fuse_inode(inode);
836
837                 spin_lock(&fc->lock);
838                 fi->attr_version = ++fc->attr_version;
839                 inc_nlink(inode);
840                 spin_unlock(&fc->lock);
841                 fuse_invalidate_attr(inode);
842                 fuse_update_ctime(inode);
843         } else if (err == -EINTR) {
844                 fuse_invalidate_attr(inode);
845         }
846         return err;
847 }
848
849 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
850                           struct kstat *stat)
851 {
852         unsigned int blkbits;
853         struct fuse_conn *fc = get_fuse_conn(inode);
854
855         /* see the comment in fuse_change_attributes() */
856         if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
857                 attr->size = i_size_read(inode);
858                 attr->mtime = inode->i_mtime.tv_sec;
859                 attr->mtimensec = inode->i_mtime.tv_nsec;
860                 attr->ctime = inode->i_ctime.tv_sec;
861                 attr->ctimensec = inode->i_ctime.tv_nsec;
862         }
863
864         stat->dev = inode->i_sb->s_dev;
865         stat->ino = attr->ino;
866         stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
867         stat->nlink = attr->nlink;
868         stat->uid = make_kuid(fc->user_ns, attr->uid);
869         stat->gid = make_kgid(fc->user_ns, attr->gid);
870         stat->rdev = inode->i_rdev;
871         stat->atime.tv_sec = attr->atime;
872         stat->atime.tv_nsec = attr->atimensec;
873         stat->mtime.tv_sec = attr->mtime;
874         stat->mtime.tv_nsec = attr->mtimensec;
875         stat->ctime.tv_sec = attr->ctime;
876         stat->ctime.tv_nsec = attr->ctimensec;
877         stat->size = attr->size;
878         stat->blocks = attr->blocks;
879
880         if (attr->blksize != 0)
881                 blkbits = ilog2(attr->blksize);
882         else
883                 blkbits = inode->i_sb->s_blocksize_bits;
884
885         stat->blksize = 1 << blkbits;
886 }
887
888 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
889                            struct file *file)
890 {
891         int err;
892         struct fuse_getattr_in inarg;
893         struct fuse_attr_out outarg;
894         struct fuse_conn *fc = get_fuse_conn(inode);
895         FUSE_ARGS(args);
896         u64 attr_version;
897
898         attr_version = fuse_get_attr_version(fc);
899
900         memset(&inarg, 0, sizeof(inarg));
901         memset(&outarg, 0, sizeof(outarg));
902         /* Directories have separate file-handle space */
903         if (file && S_ISREG(inode->i_mode)) {
904                 struct fuse_file *ff = file->private_data;
905
906                 inarg.getattr_flags |= FUSE_GETATTR_FH;
907                 inarg.fh = ff->fh;
908         }
909         args.in.h.opcode = FUSE_GETATTR;
910         args.in.h.nodeid = get_node_id(inode);
911         args.in.numargs = 1;
912         args.in.args[0].size = sizeof(inarg);
913         args.in.args[0].value = &inarg;
914         args.out.numargs = 1;
915         args.out.args[0].size = sizeof(outarg);
916         args.out.args[0].value = &outarg;
917         err = fuse_simple_request(fc, &args);
918         if (!err) {
919                 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
920                         make_bad_inode(inode);
921                         err = -EIO;
922                 } else {
923                         fuse_change_attributes(inode, &outarg.attr,
924                                                attr_timeout(&outarg),
925                                                attr_version);
926                         if (stat)
927                                 fuse_fillattr(inode, &outarg.attr, stat);
928                 }
929         }
930         return err;
931 }
932
933 static int fuse_update_get_attr(struct inode *inode, struct file *file,
934                                 struct kstat *stat, unsigned int flags)
935 {
936         struct fuse_inode *fi = get_fuse_inode(inode);
937         int err = 0;
938         bool sync;
939
940         if (flags & AT_STATX_FORCE_SYNC)
941                 sync = true;
942         else if (flags & AT_STATX_DONT_SYNC)
943                 sync = false;
944         else
945                 sync = time_before64(fi->i_time, get_jiffies_64());
946
947         if (sync) {
948                 forget_all_cached_acls(inode);
949                 err = fuse_do_getattr(inode, stat, file);
950         } else if (stat) {
951                 generic_fillattr(inode, stat);
952                 stat->mode = fi->orig_i_mode;
953                 stat->ino = fi->orig_ino;
954         }
955
956         return err;
957 }
958
959 int fuse_update_attributes(struct inode *inode, struct file *file)
960 {
961         return fuse_update_get_attr(inode, file, NULL, 0);
962 }
963
964 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
965                              u64 child_nodeid, struct qstr *name)
966 {
967         int err = -ENOTDIR;
968         struct inode *parent;
969         struct dentry *dir;
970         struct dentry *entry;
971
972         parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
973         if (!parent)
974                 return -ENOENT;
975
976         inode_lock(parent);
977         if (!S_ISDIR(parent->i_mode))
978                 goto unlock;
979
980         err = -ENOENT;
981         dir = d_find_alias(parent);
982         if (!dir)
983                 goto unlock;
984
985         name->hash = full_name_hash(dir, name->name, name->len);
986         entry = d_lookup(dir, name);
987         dput(dir);
988         if (!entry)
989                 goto unlock;
990
991         fuse_invalidate_attr(parent);
992         fuse_invalidate_entry(entry);
993
994         if (child_nodeid != 0 && d_really_is_positive(entry)) {
995                 inode_lock(d_inode(entry));
996                 if (get_node_id(d_inode(entry)) != child_nodeid) {
997                         err = -ENOENT;
998                         goto badentry;
999                 }
1000                 if (d_mountpoint(entry)) {
1001                         err = -EBUSY;
1002                         goto badentry;
1003                 }
1004                 if (d_is_dir(entry)) {
1005                         shrink_dcache_parent(entry);
1006                         if (!simple_empty(entry)) {
1007                                 err = -ENOTEMPTY;
1008                                 goto badentry;
1009                         }
1010                         d_inode(entry)->i_flags |= S_DEAD;
1011                 }
1012                 dont_mount(entry);
1013                 clear_nlink(d_inode(entry));
1014                 err = 0;
1015  badentry:
1016                 inode_unlock(d_inode(entry));
1017                 if (!err)
1018                         d_delete(entry);
1019         } else {
1020                 err = 0;
1021         }
1022         dput(entry);
1023
1024  unlock:
1025         inode_unlock(parent);
1026         iput(parent);
1027         return err;
1028 }
1029
1030 /*
1031  * Calling into a user-controlled filesystem gives the filesystem
1032  * daemon ptrace-like capabilities over the current process.  This
1033  * means, that the filesystem daemon is able to record the exact
1034  * filesystem operations performed, and can also control the behavior
1035  * of the requester process in otherwise impossible ways.  For example
1036  * it can delay the operation for arbitrary length of time allowing
1037  * DoS against the requester.
1038  *
1039  * For this reason only those processes can call into the filesystem,
1040  * for which the owner of the mount has ptrace privilege.  This
1041  * excludes processes started by other users, suid or sgid processes.
1042  */
1043 int fuse_allow_current_process(struct fuse_conn *fc)
1044 {
1045         const struct cred *cred;
1046
1047         if (fc->allow_other)
1048                 return current_in_userns(fc->user_ns);
1049
1050         cred = current_cred();
1051         if (uid_eq(cred->euid, fc->user_id) &&
1052             uid_eq(cred->suid, fc->user_id) &&
1053             uid_eq(cred->uid,  fc->user_id) &&
1054             gid_eq(cred->egid, fc->group_id) &&
1055             gid_eq(cred->sgid, fc->group_id) &&
1056             gid_eq(cred->gid,  fc->group_id))
1057                 return 1;
1058
1059         return 0;
1060 }
1061
1062 static int fuse_access(struct inode *inode, int mask)
1063 {
1064         struct fuse_conn *fc = get_fuse_conn(inode);
1065         FUSE_ARGS(args);
1066         struct fuse_access_in inarg;
1067         int err;
1068
1069         BUG_ON(mask & MAY_NOT_BLOCK);
1070
1071         if (fc->no_access)
1072                 return 0;
1073
1074         memset(&inarg, 0, sizeof(inarg));
1075         inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1076         args.in.h.opcode = FUSE_ACCESS;
1077         args.in.h.nodeid = get_node_id(inode);
1078         args.in.numargs = 1;
1079         args.in.args[0].size = sizeof(inarg);
1080         args.in.args[0].value = &inarg;
1081         err = fuse_simple_request(fc, &args);
1082         if (err == -ENOSYS) {
1083                 fc->no_access = 1;
1084                 err = 0;
1085         }
1086         return err;
1087 }
1088
1089 static int fuse_perm_getattr(struct inode *inode, int mask)
1090 {
1091         if (mask & MAY_NOT_BLOCK)
1092                 return -ECHILD;
1093
1094         forget_all_cached_acls(inode);
1095         return fuse_do_getattr(inode, NULL, NULL);
1096 }
1097
1098 /*
1099  * Check permission.  The two basic access models of FUSE are:
1100  *
1101  * 1) Local access checking ('default_permissions' mount option) based
1102  * on file mode.  This is the plain old disk filesystem permission
1103  * modell.
1104  *
1105  * 2) "Remote" access checking, where server is responsible for
1106  * checking permission in each inode operation.  An exception to this
1107  * is if ->permission() was invoked from sys_access() in which case an
1108  * access request is sent.  Execute permission is still checked
1109  * locally based on file mode.
1110  */
1111 static int fuse_permission(struct inode *inode, int mask)
1112 {
1113         struct fuse_conn *fc = get_fuse_conn(inode);
1114         bool refreshed = false;
1115         int err = 0;
1116
1117         if (!fuse_allow_current_process(fc))
1118                 return -EACCES;
1119
1120         /*
1121          * If attributes are needed, refresh them before proceeding
1122          */
1123         if (fc->default_permissions ||
1124             ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1125                 struct fuse_inode *fi = get_fuse_inode(inode);
1126
1127                 if (time_before64(fi->i_time, get_jiffies_64())) {
1128                         refreshed = true;
1129
1130                         err = fuse_perm_getattr(inode, mask);
1131                         if (err)
1132                                 return err;
1133                 }
1134         }
1135
1136         if (fc->default_permissions) {
1137                 err = generic_permission(inode, mask);
1138
1139                 /* If permission is denied, try to refresh file
1140                    attributes.  This is also needed, because the root
1141                    node will at first have no permissions */
1142                 if (err == -EACCES && !refreshed) {
1143                         err = fuse_perm_getattr(inode, mask);
1144                         if (!err)
1145                                 err = generic_permission(inode, mask);
1146                 }
1147
1148                 /* Note: the opposite of the above test does not
1149                    exist.  So if permissions are revoked this won't be
1150                    noticed immediately, only after the attribute
1151                    timeout has expired */
1152         } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1153                 err = fuse_access(inode, mask);
1154         } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1155                 if (!(inode->i_mode & S_IXUGO)) {
1156                         if (refreshed)
1157                                 return -EACCES;
1158
1159                         err = fuse_perm_getattr(inode, mask);
1160                         if (!err && !(inode->i_mode & S_IXUGO))
1161                                 return -EACCES;
1162                 }
1163         }
1164         return err;
1165 }
1166
1167 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1168                          struct dir_context *ctx)
1169 {
1170         while (nbytes >= FUSE_NAME_OFFSET) {
1171                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1172                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1173                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1174                         return -EIO;
1175                 if (reclen > nbytes)
1176                         break;
1177                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1178                         return -EIO;
1179
1180                 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1181                                dirent->ino, dirent->type))
1182                         break;
1183
1184                 buf += reclen;
1185                 nbytes -= reclen;
1186                 ctx->pos = dirent->off;
1187         }
1188
1189         return 0;
1190 }
1191
1192 static int fuse_direntplus_link(struct file *file,
1193                                 struct fuse_direntplus *direntplus,
1194                                 u64 attr_version)
1195 {
1196         struct fuse_entry_out *o = &direntplus->entry_out;
1197         struct fuse_dirent *dirent = &direntplus->dirent;
1198         struct dentry *parent = file->f_path.dentry;
1199         struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1200         struct dentry *dentry;
1201         struct dentry *alias;
1202         struct inode *dir = d_inode(parent);
1203         struct fuse_conn *fc;
1204         struct inode *inode;
1205         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
1206
1207         if (!o->nodeid) {
1208                 /*
1209                  * Unlike in the case of fuse_lookup, zero nodeid does not mean
1210                  * ENOENT. Instead, it only means the userspace filesystem did
1211                  * not want to return attributes/handle for this entry.
1212                  *
1213                  * So do nothing.
1214                  */
1215                 return 0;
1216         }
1217
1218         if (name.name[0] == '.') {
1219                 /*
1220                  * We could potentially refresh the attributes of the directory
1221                  * and its parent?
1222                  */
1223                 if (name.len == 1)
1224                         return 0;
1225                 if (name.name[1] == '.' && name.len == 2)
1226                         return 0;
1227         }
1228
1229         if (invalid_nodeid(o->nodeid))
1230                 return -EIO;
1231         if (!fuse_valid_type(o->attr.mode))
1232                 return -EIO;
1233
1234         fc = get_fuse_conn(dir);
1235
1236         name.hash = full_name_hash(parent, name.name, name.len);
1237         dentry = d_lookup(parent, &name);
1238         if (!dentry) {
1239 retry:
1240                 dentry = d_alloc_parallel(parent, &name, &wq);
1241                 if (IS_ERR(dentry))
1242                         return PTR_ERR(dentry);
1243         }
1244         if (!d_in_lookup(dentry)) {
1245                 struct fuse_inode *fi;
1246                 inode = d_inode(dentry);
1247                 if (!inode ||
1248                     get_node_id(inode) != o->nodeid ||
1249                     ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1250                         d_invalidate(dentry);
1251                         dput(dentry);
1252                         goto retry;
1253                 }
1254                 if (is_bad_inode(inode)) {
1255                         dput(dentry);
1256                         return -EIO;
1257                 }
1258
1259                 fi = get_fuse_inode(inode);
1260                 spin_lock(&fc->lock);
1261                 fi->nlookup++;
1262                 spin_unlock(&fc->lock);
1263
1264                 forget_all_cached_acls(inode);
1265                 fuse_change_attributes(inode, &o->attr,
1266                                        entry_attr_timeout(o),
1267                                        attr_version);
1268                 /*
1269                  * The other branch comes via fuse_iget()
1270                  * which bumps nlookup inside
1271                  */
1272         } else {
1273                 inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1274                                   &o->attr, entry_attr_timeout(o),
1275                                   attr_version);
1276                 if (!inode)
1277                         inode = ERR_PTR(-ENOMEM);
1278
1279                 alias = d_splice_alias(inode, dentry);
1280                 d_lookup_done(dentry);
1281                 if (alias) {
1282                         dput(dentry);
1283                         dentry = alias;
1284                 }
1285                 if (IS_ERR(dentry))
1286                         return PTR_ERR(dentry);
1287         }
1288         if (fc->readdirplus_auto)
1289                 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1290         fuse_change_entry_timeout(dentry, o);
1291
1292         dput(dentry);
1293         return 0;
1294 }
1295
1296 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1297                              struct dir_context *ctx, u64 attr_version)
1298 {
1299         struct fuse_direntplus *direntplus;
1300         struct fuse_dirent *dirent;
1301         size_t reclen;
1302         int over = 0;
1303         int ret;
1304
1305         while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1306                 direntplus = (struct fuse_direntplus *) buf;
1307                 dirent = &direntplus->dirent;
1308                 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1309
1310                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1311                         return -EIO;
1312                 if (reclen > nbytes)
1313                         break;
1314                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1315                         return -EIO;
1316
1317                 if (!over) {
1318                         /* We fill entries into dstbuf only as much as
1319                            it can hold. But we still continue iterating
1320                            over remaining entries to link them. If not,
1321                            we need to send a FORGET for each of those
1322                            which we did not link.
1323                         */
1324                         over = !dir_emit(ctx, dirent->name, dirent->namelen,
1325                                        dirent->ino, dirent->type);
1326                         if (!over)
1327                                 ctx->pos = dirent->off;
1328                 }
1329
1330                 buf += reclen;
1331                 nbytes -= reclen;
1332
1333                 ret = fuse_direntplus_link(file, direntplus, attr_version);
1334                 if (ret)
1335                         fuse_force_forget(file, direntplus->entry_out.nodeid);
1336         }
1337
1338         return 0;
1339 }
1340
1341 static int fuse_readdir(struct file *file, struct dir_context *ctx)
1342 {
1343         int plus, err;
1344         size_t nbytes;
1345         struct page *page;
1346         struct inode *inode = file_inode(file);
1347         struct fuse_conn *fc = get_fuse_conn(inode);
1348         struct fuse_req *req;
1349         u64 attr_version = 0;
1350
1351         if (is_bad_inode(inode))
1352                 return -EIO;
1353
1354         req = fuse_get_req(fc, 1);
1355         if (IS_ERR(req))
1356                 return PTR_ERR(req);
1357
1358         page = alloc_page(GFP_KERNEL);
1359         if (!page) {
1360                 fuse_put_request(fc, req);
1361                 return -ENOMEM;
1362         }
1363
1364         plus = fuse_use_readdirplus(inode, ctx);
1365         req->out.argpages = 1;
1366         req->num_pages = 1;
1367         req->pages[0] = page;
1368         req->page_descs[0].length = PAGE_SIZE;
1369         if (plus) {
1370                 attr_version = fuse_get_attr_version(fc);
1371                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1372                                FUSE_READDIRPLUS);
1373         } else {
1374                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1375                                FUSE_READDIR);
1376         }
1377         fuse_lock_inode(inode);
1378         fuse_request_send(fc, req);
1379         fuse_unlock_inode(inode);
1380         nbytes = req->out.args[0].size;
1381         err = req->out.h.error;
1382         fuse_put_request(fc, req);
1383         if (!err) {
1384                 if (plus) {
1385                         err = parse_dirplusfile(page_address(page), nbytes,
1386                                                 file, ctx,
1387                                                 attr_version);
1388                 } else {
1389                         err = parse_dirfile(page_address(page), nbytes, file,
1390                                             ctx);
1391                 }
1392         }
1393
1394         __free_page(page);
1395         fuse_invalidate_atime(inode);
1396         return err;
1397 }
1398
1399 static const char *fuse_get_link(struct dentry *dentry,
1400                                  struct inode *inode,
1401                                  struct delayed_call *done)
1402 {
1403         struct fuse_conn *fc = get_fuse_conn(inode);
1404         FUSE_ARGS(args);
1405         char *link;
1406         ssize_t ret;
1407
1408         if (!dentry)
1409                 return ERR_PTR(-ECHILD);
1410
1411         link = kmalloc(PAGE_SIZE, GFP_KERNEL);
1412         if (!link)
1413                 return ERR_PTR(-ENOMEM);
1414
1415         args.in.h.opcode = FUSE_READLINK;
1416         args.in.h.nodeid = get_node_id(inode);
1417         args.out.argvar = 1;
1418         args.out.numargs = 1;
1419         args.out.args[0].size = PAGE_SIZE - 1;
1420         args.out.args[0].value = link;
1421         ret = fuse_simple_request(fc, &args);
1422         if (ret < 0) {
1423                 kfree(link);
1424                 link = ERR_PTR(ret);
1425         } else {
1426                 link[ret] = '\0';
1427                 set_delayed_call(done, kfree_link, link);
1428         }
1429         fuse_invalidate_atime(inode);
1430         return link;
1431 }
1432
1433 static int fuse_dir_open(struct inode *inode, struct file *file)
1434 {
1435         return fuse_open_common(inode, file, true);
1436 }
1437
1438 static int fuse_dir_release(struct inode *inode, struct file *file)
1439 {
1440         fuse_release_common(file, FUSE_RELEASEDIR);
1441
1442         return 0;
1443 }
1444
1445 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1446                           int datasync)
1447 {
1448         return fuse_fsync_common(file, start, end, datasync, 1);
1449 }
1450
1451 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1452                             unsigned long arg)
1453 {
1454         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1455
1456         /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1457         if (fc->minor < 18)
1458                 return -ENOTTY;
1459
1460         return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1461 }
1462
1463 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1464                                    unsigned long arg)
1465 {
1466         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1467
1468         if (fc->minor < 18)
1469                 return -ENOTTY;
1470
1471         return fuse_ioctl_common(file, cmd, arg,
1472                                  FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1473 }
1474
1475 static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
1476 {
1477         /* Always update if mtime is explicitly set  */
1478         if (ivalid & ATTR_MTIME_SET)
1479                 return true;
1480
1481         /* Or if kernel i_mtime is the official one */
1482         if (trust_local_mtime)
1483                 return true;
1484
1485         /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1486         if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1487                 return false;
1488
1489         /* In all other cases update */
1490         return true;
1491 }
1492
1493 static void iattr_to_fattr(struct fuse_conn *fc, struct iattr *iattr,
1494                            struct fuse_setattr_in *arg, bool trust_local_cmtime)
1495 {
1496         unsigned ivalid = iattr->ia_valid;
1497
1498         if (ivalid & ATTR_MODE)
1499                 arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1500         if (ivalid & ATTR_UID)
1501                 arg->valid |= FATTR_UID,    arg->uid = from_kuid(fc->user_ns, iattr->ia_uid);
1502         if (ivalid & ATTR_GID)
1503                 arg->valid |= FATTR_GID,    arg->gid = from_kgid(fc->user_ns, iattr->ia_gid);
1504         if (ivalid & ATTR_SIZE)
1505                 arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
1506         if (ivalid & ATTR_ATIME) {
1507                 arg->valid |= FATTR_ATIME;
1508                 arg->atime = iattr->ia_atime.tv_sec;
1509                 arg->atimensec = iattr->ia_atime.tv_nsec;
1510                 if (!(ivalid & ATTR_ATIME_SET))
1511                         arg->valid |= FATTR_ATIME_NOW;
1512         }
1513         if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
1514                 arg->valid |= FATTR_MTIME;
1515                 arg->mtime = iattr->ia_mtime.tv_sec;
1516                 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1517                 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
1518                         arg->valid |= FATTR_MTIME_NOW;
1519         }
1520         if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1521                 arg->valid |= FATTR_CTIME;
1522                 arg->ctime = iattr->ia_ctime.tv_sec;
1523                 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1524         }
1525 }
1526
1527 /*
1528  * Prevent concurrent writepages on inode
1529  *
1530  * This is done by adding a negative bias to the inode write counter
1531  * and waiting for all pending writes to finish.
1532  */
1533 void fuse_set_nowrite(struct inode *inode)
1534 {
1535         struct fuse_conn *fc = get_fuse_conn(inode);
1536         struct fuse_inode *fi = get_fuse_inode(inode);
1537
1538         BUG_ON(!inode_is_locked(inode));
1539
1540         spin_lock(&fc->lock);
1541         BUG_ON(fi->writectr < 0);
1542         fi->writectr += FUSE_NOWRITE;
1543         spin_unlock(&fc->lock);
1544         wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1545 }
1546
1547 /*
1548  * Allow writepages on inode
1549  *
1550  * Remove the bias from the writecounter and send any queued
1551  * writepages.
1552  */
1553 static void __fuse_release_nowrite(struct inode *inode)
1554 {
1555         struct fuse_inode *fi = get_fuse_inode(inode);
1556
1557         BUG_ON(fi->writectr != FUSE_NOWRITE);
1558         fi->writectr = 0;
1559         fuse_flush_writepages(inode);
1560 }
1561
1562 void fuse_release_nowrite(struct inode *inode)
1563 {
1564         struct fuse_conn *fc = get_fuse_conn(inode);
1565
1566         spin_lock(&fc->lock);
1567         __fuse_release_nowrite(inode);
1568         spin_unlock(&fc->lock);
1569 }
1570
1571 static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
1572                               struct inode *inode,
1573                               struct fuse_setattr_in *inarg_p,
1574                               struct fuse_attr_out *outarg_p)
1575 {
1576         args->in.h.opcode = FUSE_SETATTR;
1577         args->in.h.nodeid = get_node_id(inode);
1578         args->in.numargs = 1;
1579         args->in.args[0].size = sizeof(*inarg_p);
1580         args->in.args[0].value = inarg_p;
1581         args->out.numargs = 1;
1582         args->out.args[0].size = sizeof(*outarg_p);
1583         args->out.args[0].value = outarg_p;
1584 }
1585
1586 /*
1587  * Flush inode->i_mtime to the server
1588  */
1589 int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
1590 {
1591         struct fuse_conn *fc = get_fuse_conn(inode);
1592         FUSE_ARGS(args);
1593         struct fuse_setattr_in inarg;
1594         struct fuse_attr_out outarg;
1595
1596         memset(&inarg, 0, sizeof(inarg));
1597         memset(&outarg, 0, sizeof(outarg));
1598
1599         inarg.valid = FATTR_MTIME;
1600         inarg.mtime = inode->i_mtime.tv_sec;
1601         inarg.mtimensec = inode->i_mtime.tv_nsec;
1602         if (fc->minor >= 23) {
1603                 inarg.valid |= FATTR_CTIME;
1604                 inarg.ctime = inode->i_ctime.tv_sec;
1605                 inarg.ctimensec = inode->i_ctime.tv_nsec;
1606         }
1607         if (ff) {
1608                 inarg.valid |= FATTR_FH;
1609                 inarg.fh = ff->fh;
1610         }
1611         fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1612
1613         return fuse_simple_request(fc, &args);
1614 }
1615
1616 /*
1617  * Set attributes, and at the same time refresh them.
1618  *
1619  * Truncation is slightly complicated, because the 'truncate' request
1620  * may fail, in which case we don't want to touch the mapping.
1621  * vmtruncate() doesn't allow for this case, so do the rlimit checking
1622  * and the actual truncation by hand.
1623  */
1624 int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
1625                     struct file *file)
1626 {
1627         struct inode *inode = d_inode(dentry);
1628         struct fuse_conn *fc = get_fuse_conn(inode);
1629         struct fuse_inode *fi = get_fuse_inode(inode);
1630         FUSE_ARGS(args);
1631         struct fuse_setattr_in inarg;
1632         struct fuse_attr_out outarg;
1633         bool is_truncate = false;
1634         bool is_wb = fc->writeback_cache;
1635         loff_t oldsize;
1636         int err;
1637         bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
1638
1639         if (!fc->default_permissions)
1640                 attr->ia_valid |= ATTR_FORCE;
1641
1642         err = setattr_prepare(dentry, attr);
1643         if (err)
1644                 return err;
1645
1646         if (attr->ia_valid & ATTR_OPEN) {
1647                 /* This is coming from open(..., ... | O_TRUNC); */
1648                 WARN_ON(!(attr->ia_valid & ATTR_SIZE));
1649                 WARN_ON(attr->ia_size != 0);
1650                 if (fc->atomic_o_trunc) {
1651                         /*
1652                          * No need to send request to userspace, since actual
1653                          * truncation has already been done by OPEN.  But still
1654                          * need to truncate page cache.
1655                          */
1656                         i_size_write(inode, 0);
1657                         truncate_pagecache(inode, 0);
1658                         return 0;
1659                 }
1660                 file = NULL;
1661         }
1662
1663         if (attr->ia_valid & ATTR_SIZE)
1664                 is_truncate = true;
1665
1666         if (is_truncate) {
1667                 fuse_set_nowrite(inode);
1668                 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1669                 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1670                         attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
1671         }
1672
1673         memset(&inarg, 0, sizeof(inarg));
1674         memset(&outarg, 0, sizeof(outarg));
1675         iattr_to_fattr(fc, attr, &inarg, trust_local_cmtime);
1676         if (file) {
1677                 struct fuse_file *ff = file->private_data;
1678                 inarg.valid |= FATTR_FH;
1679                 inarg.fh = ff->fh;
1680         }
1681         if (attr->ia_valid & ATTR_SIZE) {
1682                 /* For mandatory locking in truncate */
1683                 inarg.valid |= FATTR_LOCKOWNER;
1684                 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1685         }
1686         fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1687         err = fuse_simple_request(fc, &args);
1688         if (err) {
1689                 if (err == -EINTR)
1690                         fuse_invalidate_attr(inode);
1691                 goto error;
1692         }
1693
1694         if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1695                 make_bad_inode(inode);
1696                 err = -EIO;
1697                 goto error;
1698         }
1699
1700         spin_lock(&fc->lock);
1701         /* the kernel maintains i_mtime locally */
1702         if (trust_local_cmtime) {
1703                 if (attr->ia_valid & ATTR_MTIME)
1704                         inode->i_mtime = attr->ia_mtime;
1705                 if (attr->ia_valid & ATTR_CTIME)
1706                         inode->i_ctime = attr->ia_ctime;
1707                 /* FIXME: clear I_DIRTY_SYNC? */
1708         }
1709
1710         fuse_change_attributes_common(inode, &outarg.attr,
1711                                       attr_timeout(&outarg));
1712         oldsize = inode->i_size;
1713         /* see the comment in fuse_change_attributes() */
1714         if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1715                 i_size_write(inode, outarg.attr.size);
1716
1717         if (is_truncate) {
1718                 /* NOTE: this may release/reacquire fc->lock */
1719                 __fuse_release_nowrite(inode);
1720         }
1721         spin_unlock(&fc->lock);
1722
1723         /*
1724          * Only call invalidate_inode_pages2() after removing
1725          * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1726          */
1727         if ((is_truncate || !is_wb) &&
1728             S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1729                 truncate_pagecache(inode, outarg.attr.size);
1730                 invalidate_inode_pages2(inode->i_mapping);
1731         }
1732
1733         clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1734         return 0;
1735
1736 error:
1737         if (is_truncate)
1738                 fuse_release_nowrite(inode);
1739
1740         clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1741         return err;
1742 }
1743
1744 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1745 {
1746         struct inode *inode = d_inode(entry);
1747         struct fuse_conn *fc = get_fuse_conn(inode);
1748         struct file *file = (attr->ia_valid & ATTR_FILE) ? attr->ia_file : NULL;
1749         int ret;
1750
1751         if (!fuse_allow_current_process(get_fuse_conn(inode)))
1752                 return -EACCES;
1753
1754         if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) {
1755                 attr->ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID |
1756                                     ATTR_MODE);
1757
1758                 /*
1759                  * The only sane way to reliably kill suid/sgid is to do it in
1760                  * the userspace filesystem
1761                  *
1762                  * This should be done on write(), truncate() and chown().
1763                  */
1764                 if (!fc->handle_killpriv) {
1765                         /*
1766                          * ia_mode calculation may have used stale i_mode.
1767                          * Refresh and recalculate.
1768                          */
1769                         ret = fuse_do_getattr(inode, NULL, file);
1770                         if (ret)
1771                                 return ret;
1772
1773                         attr->ia_mode = inode->i_mode;
1774                         if (inode->i_mode & S_ISUID) {
1775                                 attr->ia_valid |= ATTR_MODE;
1776                                 attr->ia_mode &= ~S_ISUID;
1777                         }
1778                         if ((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
1779                                 attr->ia_valid |= ATTR_MODE;
1780                                 attr->ia_mode &= ~S_ISGID;
1781                         }
1782                 }
1783         }
1784         if (!attr->ia_valid)
1785                 return 0;
1786
1787         ret = fuse_do_setattr(entry, attr, file);
1788         if (!ret) {
1789                 /*
1790                  * If filesystem supports acls it may have updated acl xattrs in
1791                  * the filesystem, so forget cached acls for the inode.
1792                  */
1793                 if (fc->posix_acl)
1794                         forget_all_cached_acls(inode);
1795
1796                 /* Directory mode changed, may need to revalidate access */
1797                 if (d_is_dir(entry) && (attr->ia_valid & ATTR_MODE))
1798                         fuse_invalidate_entry_cache(entry);
1799         }
1800         return ret;
1801 }
1802
1803 static int fuse_getattr(const struct path *path, struct kstat *stat,
1804                         u32 request_mask, unsigned int flags)
1805 {
1806         struct inode *inode = d_inode(path->dentry);
1807         struct fuse_conn *fc = get_fuse_conn(inode);
1808
1809         if (!fuse_allow_current_process(fc))
1810                 return -EACCES;
1811
1812         return fuse_update_get_attr(inode, NULL, stat, flags);
1813 }
1814
1815 static const struct inode_operations fuse_dir_inode_operations = {
1816         .lookup         = fuse_lookup,
1817         .mkdir          = fuse_mkdir,
1818         .symlink        = fuse_symlink,
1819         .unlink         = fuse_unlink,
1820         .rmdir          = fuse_rmdir,
1821         .rename         = fuse_rename2,
1822         .link           = fuse_link,
1823         .setattr        = fuse_setattr,
1824         .create         = fuse_create,
1825         .atomic_open    = fuse_atomic_open,
1826         .mknod          = fuse_mknod,
1827         .permission     = fuse_permission,
1828         .getattr        = fuse_getattr,
1829         .listxattr      = fuse_listxattr,
1830         .get_acl        = fuse_get_acl,
1831         .set_acl        = fuse_set_acl,
1832 };
1833
1834 static const struct file_operations fuse_dir_operations = {
1835         .llseek         = generic_file_llseek,
1836         .read           = generic_read_dir,
1837         .iterate_shared = fuse_readdir,
1838         .open           = fuse_dir_open,
1839         .release        = fuse_dir_release,
1840         .fsync          = fuse_dir_fsync,
1841         .unlocked_ioctl = fuse_dir_ioctl,
1842         .compat_ioctl   = fuse_dir_compat_ioctl,
1843 };
1844
1845 static const struct inode_operations fuse_common_inode_operations = {
1846         .setattr        = fuse_setattr,
1847         .permission     = fuse_permission,
1848         .getattr        = fuse_getattr,
1849         .listxattr      = fuse_listxattr,
1850         .get_acl        = fuse_get_acl,
1851         .set_acl        = fuse_set_acl,
1852 };
1853
1854 static const struct inode_operations fuse_symlink_inode_operations = {
1855         .setattr        = fuse_setattr,
1856         .get_link       = fuse_get_link,
1857         .getattr        = fuse_getattr,
1858         .listxattr      = fuse_listxattr,
1859 };
1860
1861 void fuse_init_common(struct inode *inode)
1862 {
1863         inode->i_op = &fuse_common_inode_operations;
1864 }
1865
1866 void fuse_init_dir(struct inode *inode)
1867 {
1868         inode->i_op = &fuse_dir_inode_operations;
1869         inode->i_fop = &fuse_dir_operations;
1870 }
1871
1872 void fuse_init_symlink(struct inode *inode)
1873 {
1874         inode->i_op = &fuse_symlink_inode_operations;
1875 }