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