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