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