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