1 /* 1
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2008 Miklos Szeredi <mik
4
5 This program can be distributed under the te
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/fs_context.h>
14 #include <linux/moduleparam.h>
15 #include <linux/sched.h>
16 #include <linux/namei.h>
17 #include <linux/slab.h>
18 #include <linux/xattr.h>
19 #include <linux/iversion.h>
20 #include <linux/posix_acl.h>
21 #include <linux/security.h>
22 #include <linux/types.h>
23 #include <linux/kernel.h>
24
25 static bool __read_mostly allow_sys_admin_acce
26 module_param(allow_sys_admin_access, bool, 064
27 MODULE_PARM_DESC(allow_sys_admin_access,
28 "Allow users with CAP_SYS_ADM
29
30 static void fuse_advise_use_readdirplus(struct
31 {
32 struct fuse_inode *fi = get_fuse_inode
33
34 set_bit(FUSE_I_ADVISE_RDPLUS, &fi->sta
35 }
36
37 #if BITS_PER_LONG >= 64
38 static inline void __fuse_dentry_settime(struc
39 {
40 entry->d_fsdata = (void *) time;
41 }
42
43 static inline u64 fuse_dentry_time(const struc
44 {
45 return (u64)entry->d_fsdata;
46 }
47
48 #else
49 union fuse_dentry {
50 u64 time;
51 struct rcu_head rcu;
52 };
53
54 static inline void __fuse_dentry_settime(struc
55 {
56 ((union fuse_dentry *) dentry->d_fsdat
57 }
58
59 static inline u64 fuse_dentry_time(const struc
60 {
61 return ((union fuse_dentry *) entry->d
62 }
63 #endif
64
65 static void fuse_dentry_settime(struct dentry
66 {
67 struct fuse_conn *fc = get_fuse_conn_s
68 bool delete = !time && fc->delete_stal
69 /*
70 * Mess with DCACHE_OP_DELETE because
71 * Don't care about races, either way
72 */
73 if ((!delete && (dentry->d_flags & DCA
74 (delete && !(dentry->d_flags & DCA
75 spin_lock(&dentry->d_lock);
76 if (!delete)
77 dentry->d_flags &= ~DC
78 else
79 dentry->d_flags |= DCA
80 spin_unlock(&dentry->d_lock);
81 }
82
83 __fuse_dentry_settime(dentry, time);
84 }
85
86 /*
87 * FUSE caches dentries and attributes with se
88 * time in jiffies until the dentry/attributes
89 * dentry->d_fsdata and fuse_inode->i_time res
90 */
91
92 /*
93 * Calculate the time in jiffies until a dentr
94 */
95 u64 fuse_time_to_jiffies(u64 sec, u32 nsec)
96 {
97 if (sec || nsec) {
98 struct timespec64 ts = {
99 sec,
100 min_t(u32, nsec, NSEC_
101 };
102
103 return get_jiffies_64() + time
104 } else
105 return 0;
106 }
107
108 /*
109 * Set dentry and possibly attribute timeouts
110 * replies
111 */
112 void fuse_change_entry_timeout(struct dentry *
113 {
114 fuse_dentry_settime(entry,
115 fuse_time_to_jiffies(o->entry_
116 }
117
118 void fuse_invalidate_attr_mask(struct inode *i
119 {
120 set_mask_bits(&get_fuse_inode(inode)->
121 }
122
123 /*
124 * Mark the attributes as stale, so that at th
125 * ->getattr() they will be fetched from users
126 */
127 void fuse_invalidate_attr(struct inode *inode)
128 {
129 fuse_invalidate_attr_mask(inode, STATX
130 }
131
132 static void fuse_dir_changed(struct inode *dir
133 {
134 fuse_invalidate_attr(dir);
135 inode_maybe_inc_iversion(dir, false);
136 }
137
138 /*
139 * Mark the attributes as stale due to an atim
140 * atime is not used.
141 */
142 void fuse_invalidate_atime(struct inode *inode
143 {
144 if (!IS_RDONLY(inode))
145 fuse_invalidate_attr_mask(inod
146 }
147
148 /*
149 * Just mark the entry as stale, so that a nex
150 * will result in a new lookup call to userspa
151 *
152 * This is called when a dentry is about to be
153 * timeout is unknown (unlink, rmdir, rename a
154 * lookup)
155 */
156 void fuse_invalidate_entry_cache(struct dentry
157 {
158 fuse_dentry_settime(entry, 0);
159 }
160
161 /*
162 * Same as fuse_invalidate_entry_cache(), but
163 * dentry from the hash
164 */
165 static void fuse_invalidate_entry(struct dentr
166 {
167 d_invalidate(entry);
168 fuse_invalidate_entry_cache(entry);
169 }
170
171 static void fuse_lookup_init(struct fuse_conn
172 u64 nodeid, const
173 struct fuse_entry
174 {
175 memset(outarg, 0, sizeof(struct fuse_e
176 args->opcode = FUSE_LOOKUP;
177 args->nodeid = nodeid;
178 args->in_numargs = 1;
179 args->in_args[0].size = name->len + 1;
180 args->in_args[0].value = name->name;
181 args->out_numargs = 1;
182 args->out_args[0].size = sizeof(struct
183 args->out_args[0].value = outarg;
184 }
185
186 /*
187 * Check whether the dentry is still valid
188 *
189 * If the entry validity timeout has expired a
190 * positive, try to redo the lookup. If the l
191 * different inode, then let the VFS invalidat
192 * the lookup once more. If the lookup result
193 * then refresh the attributes, timeouts and m
194 */
195 static int fuse_dentry_revalidate(struct dentr
196 {
197 struct inode *inode;
198 struct dentry *parent;
199 struct fuse_mount *fm;
200 struct fuse_inode *fi;
201 int ret;
202
203 inode = d_inode_rcu(entry);
204 if (inode && fuse_is_bad(inode))
205 goto invalid;
206 else if (time_before64(fuse_dentry_tim
207 (flags & (LOOKUP_EXCL | LOOKU
208 struct fuse_entry_out outarg;
209 FUSE_ARGS(args);
210 struct fuse_forget_link *forge
211 u64 attr_version;
212
213 /* For negative dentries, alwa
214 if (!inode)
215 goto invalid;
216
217 ret = -ECHILD;
218 if (flags & LOOKUP_RCU)
219 goto out;
220
221 fm = get_fuse_mount(inode);
222
223 forget = fuse_alloc_forget();
224 ret = -ENOMEM;
225 if (!forget)
226 goto out;
227
228 attr_version = fuse_get_attr_v
229
230 parent = dget_parent(entry);
231 fuse_lookup_init(fm->fc, &args
232 &entry->d_nam
233 ret = fuse_simple_request(fm,
234 dput(parent);
235 /* Zero nodeid is same as -ENO
236 if (!ret && !outarg.nodeid)
237 ret = -ENOENT;
238 if (!ret) {
239 fi = get_fuse_inode(in
240 if (outarg.nodeid != g
241 (bool) IS_AUTOMOUN
242 fuse_queue_for
243
244 goto invalid;
245 }
246 spin_lock(&fi->lock);
247 fi->nlookup++;
248 spin_unlock(&fi->lock)
249 }
250 kfree(forget);
251 if (ret == -ENOMEM || ret == -
252 goto out;
253 if (ret || fuse_invalid_attr(&
254 fuse_stale_inode(inode, ou
255 goto invalid;
256
257 forget_all_cached_acls(inode);
258 fuse_change_attributes(inode,
259 ATTR_TI
260 attr_ve
261 fuse_change_entry_timeout(entr
262 } else if (inode) {
263 fi = get_fuse_inode(inode);
264 if (flags & LOOKUP_RCU) {
265 if (test_bit(FUSE_I_IN
266 return -ECHILD
267 } else if (test_and_clear_bit(
268 parent = dget_parent(e
269 fuse_advise_use_readdi
270 dput(parent);
271 }
272 }
273 ret = 1;
274 out:
275 return ret;
276
277 invalid:
278 ret = 0;
279 goto out;
280 }
281
282 #if BITS_PER_LONG < 64
283 static int fuse_dentry_init(struct dentry *den
284 {
285 dentry->d_fsdata = kzalloc(sizeof(unio
286 GFP_KERNEL_
287
288 return dentry->d_fsdata ? 0 : -ENOMEM;
289 }
290 static void fuse_dentry_release(struct dentry
291 {
292 union fuse_dentry *fd = dentry->d_fsda
293
294 kfree_rcu(fd, rcu);
295 }
296 #endif
297
298 static int fuse_dentry_delete(const struct den
299 {
300 return time_before64(fuse_dentry_time(
301 }
302
303 /*
304 * Create a fuse_mount object with a new super
305 * as the root), and return that mount so it c
306 * @path.
307 */
308 static struct vfsmount *fuse_dentry_automount(
309 {
310 struct fs_context *fsc;
311 struct vfsmount *mnt;
312 struct fuse_inode *mp_fi = get_fuse_in
313
314 fsc = fs_context_for_submount(path->mn
315 if (IS_ERR(fsc))
316 return ERR_CAST(fsc);
317
318 /* Pass the FUSE inode of the mount fo
319 fsc->fs_private = mp_fi;
320
321 /* Create the submount */
322 mnt = fc_mount(fsc);
323 if (!IS_ERR(mnt))
324 mntget(mnt);
325
326 put_fs_context(fsc);
327 return mnt;
328 }
329
330 const struct dentry_operations fuse_dentry_ope
331 .d_revalidate = fuse_dentry_revalida
332 .d_delete = fuse_dentry_delete,
333 #if BITS_PER_LONG < 64
334 .d_init = fuse_dentry_init,
335 .d_release = fuse_dentry_release,
336 #endif
337 .d_automount = fuse_dentry_automoun
338 };
339
340 const struct dentry_operations fuse_root_dentr
341 #if BITS_PER_LONG < 64
342 .d_init = fuse_dentry_init,
343 .d_release = fuse_dentry_release,
344 #endif
345 };
346
347 int fuse_valid_type(int m)
348 {
349 return S_ISREG(m) || S_ISDIR(m) || S_I
350 S_ISBLK(m) || S_ISFIFO(m) || S
351 }
352
353 static bool fuse_valid_size(u64 size)
354 {
355 return size <= LLONG_MAX;
356 }
357
358 bool fuse_invalid_attr(struct fuse_attr *attr)
359 {
360 return !fuse_valid_type(attr->mode) ||
361 }
362
363 int fuse_lookup_name(struct super_block *sb, u
364 struct fuse_entry_out *ou
365 {
366 struct fuse_mount *fm = get_fuse_mount
367 FUSE_ARGS(args);
368 struct fuse_forget_link *forget;
369 u64 attr_version;
370 int err;
371
372 *inode = NULL;
373 err = -ENAMETOOLONG;
374 if (name->len > FUSE_NAME_MAX)
375 goto out;
376
377
378 forget = fuse_alloc_forget();
379 err = -ENOMEM;
380 if (!forget)
381 goto out;
382
383 attr_version = fuse_get_attr_version(f
384
385 fuse_lookup_init(fm->fc, &args, nodeid
386 err = fuse_simple_request(fm, &args);
387 /* Zero nodeid is same as -ENOENT, but
388 if (err || !outarg->nodeid)
389 goto out_put_forget;
390
391 err = -EIO;
392 if (fuse_invalid_attr(&outarg->attr))
393 goto out_put_forget;
394 if (outarg->nodeid == FUSE_ROOT_ID &&
395 pr_warn_once("root generation
396 outarg->generation = 0;
397 }
398
399 *inode = fuse_iget(sb, outarg->nodeid,
400 &outarg->attr, ATTR
401 attr_version);
402 err = -ENOMEM;
403 if (!*inode) {
404 fuse_queue_forget(fm->fc, forg
405 goto out;
406 }
407 err = 0;
408
409 out_put_forget:
410 kfree(forget);
411 out:
412 return err;
413 }
414
415 static struct dentry *fuse_lookup(struct inode
416 unsigned int
417 {
418 int err;
419 struct fuse_entry_out outarg;
420 struct inode *inode;
421 struct dentry *newent;
422 bool outarg_valid = true;
423 bool locked;
424
425 if (fuse_is_bad(dir))
426 return ERR_PTR(-EIO);
427
428 locked = fuse_lock_inode(dir);
429 err = fuse_lookup_name(dir->i_sb, get_
430 &outarg, &inode
431 fuse_unlock_inode(dir, locked);
432 if (err == -ENOENT) {
433 outarg_valid = false;
434 err = 0;
435 }
436 if (err)
437 goto out_err;
438
439 err = -EIO;
440 if (inode && get_node_id(inode) == FUS
441 goto out_iput;
442
443 newent = d_splice_alias(inode, entry);
444 err = PTR_ERR(newent);
445 if (IS_ERR(newent))
446 goto out_err;
447
448 entry = newent ? newent : entry;
449 if (outarg_valid)
450 fuse_change_entry_timeout(entr
451 else
452 fuse_invalidate_entry_cache(en
453
454 if (inode)
455 fuse_advise_use_readdirplus(di
456 return newent;
457
458 out_iput:
459 iput(inode);
460 out_err:
461 return ERR_PTR(err);
462 }
463
464 static int get_security_context(struct dentry
465 struct fuse_in
466 {
467 struct fuse_secctx *fctx;
468 struct fuse_secctx_header *header;
469 void *ctx = NULL, *ptr;
470 u32 ctxlen, total_len = sizeof(*header
471 int err, nr_ctx = 0;
472 const char *name;
473 size_t namelen;
474
475 err = security_dentry_init_security(en
476 &n
477 if (err) {
478 if (err != -EOPNOTSUPP)
479 goto out_err;
480 /* No LSM is supporting this s
481 ctxlen = 0;
482 ctx = NULL;
483 }
484
485 if (ctxlen) {
486 nr_ctx = 1;
487 namelen = strlen(name) + 1;
488 err = -EIO;
489 if (WARN_ON(namelen > XATTR_NA
490 goto out_err;
491 total_len += FUSE_REC_ALIGN(si
492 }
493
494 err = -ENOMEM;
495 header = ptr = kzalloc(total_len, GFP_
496 if (!ptr)
497 goto out_err;
498
499 header->nr_secctx = nr_ctx;
500 header->size = total_len;
501 ptr += sizeof(*header);
502 if (nr_ctx) {
503 fctx = ptr;
504 fctx->size = ctxlen;
505 ptr += sizeof(*fctx);
506
507 strcpy(ptr, name);
508 ptr += namelen;
509
510 memcpy(ptr, ctx, ctxlen);
511 }
512 ext->size = total_len;
513 ext->value = header;
514 err = 0;
515 out_err:
516 kfree(ctx);
517 return err;
518 }
519
520 static void *extend_arg(struct fuse_in_arg *bu
521 {
522 void *p;
523 u32 newlen = buf->size + bytes;
524
525 p = krealloc(buf->value, newlen, GFP_K
526 if (!p) {
527 kfree(buf->value);
528 buf->size = 0;
529 buf->value = NULL;
530 return NULL;
531 }
532
533 memset(p + buf->size, 0, bytes);
534 buf->value = p;
535 buf->size = newlen;
536
537 return p + newlen - bytes;
538 }
539
540 static u32 fuse_ext_size(size_t size)
541 {
542 return FUSE_REC_ALIGN(sizeof(struct fu
543 }
544
545 /*
546 * This adds just a single supplementary group
547 */
548 static int get_create_supp_group(struct inode
549 {
550 struct fuse_conn *fc = get_fuse_conn(d
551 struct fuse_ext_header *xh;
552 struct fuse_supp_groups *sg;
553 kgid_t kgid = dir->i_gid;
554 gid_t parent_gid = from_kgid(fc->user_
555 u32 sg_len = fuse_ext_size(sizeof(*sg)
556
557 if (parent_gid == (gid_t) -1 || gid_eq
558 !in_group_p(kgid))
559 return 0;
560
561 xh = extend_arg(ext, sg_len);
562 if (!xh)
563 return -ENOMEM;
564
565 xh->size = sg_len;
566 xh->type = FUSE_EXT_GROUPS;
567
568 sg = (struct fuse_supp_groups *) &xh[1
569 sg->nr_groups = 1;
570 sg->groups[0] = parent_gid;
571
572 return 0;
573 }
574
575 static int get_create_ext(struct fuse_args *ar
576 struct inode *dir, s
577 umode_t mode)
578 {
579 struct fuse_conn *fc = get_fuse_conn_s
580 struct fuse_in_arg ext = { .size = 0,
581 int err = 0;
582
583 if (fc->init_security)
584 err = get_security_context(den
585 if (!err && fc->create_supp_group)
586 err = get_create_supp_group(di
587
588 if (!err && ext.size) {
589 WARN_ON(args->in_numargs >= AR
590 args->is_ext = true;
591 args->ext_idx = args->in_numar
592 args->in_args[args->ext_idx] =
593 } else {
594 kfree(ext.value);
595 }
596
597 return err;
598 }
599
600 static void free_ext_value(struct fuse_args *a
601 {
602 if (args->is_ext)
603 kfree(args->in_args[args->ext_
604 }
605
606 /*
607 * Atomic create+open operation
608 *
609 * If the filesystem doesn't support this, the
610 * 'mknod' + 'open' requests.
611 */
612 static int fuse_create_open(struct inode *dir,
613 struct file *file,
614 umode_t mode, u32
615 {
616 int err;
617 struct inode *inode;
618 struct fuse_mount *fm = get_fuse_mount
619 FUSE_ARGS(args);
620 struct fuse_forget_link *forget;
621 struct fuse_create_in inarg;
622 struct fuse_open_out *outopenp;
623 struct fuse_entry_out outentry;
624 struct fuse_inode *fi;
625 struct fuse_file *ff;
626 bool trunc = flags & O_TRUNC;
627
628 /* Userspace expects S_IFREG in create
629 BUG_ON((mode & S_IFMT) != S_IFREG);
630
631 forget = fuse_alloc_forget();
632 err = -ENOMEM;
633 if (!forget)
634 goto out_err;
635
636 err = -ENOMEM;
637 ff = fuse_file_alloc(fm, true);
638 if (!ff)
639 goto out_put_forget_req;
640
641 if (!fm->fc->dont_mask)
642 mode &= ~current_umask();
643
644 flags &= ~O_NOCTTY;
645 memset(&inarg, 0, sizeof(inarg));
646 memset(&outentry, 0, sizeof(outentry))
647 inarg.flags = flags;
648 inarg.mode = mode;
649 inarg.umask = current_umask();
650
651 if (fm->fc->handle_killpriv_v2 && trun
652 !(flags & O_EXCL) && !capable(CAP_
653 inarg.open_flags |= FUSE_OPEN_
654 }
655
656 args.opcode = opcode;
657 args.nodeid = get_node_id(dir);
658 args.in_numargs = 2;
659 args.in_args[0].size = sizeof(inarg);
660 args.in_args[0].value = &inarg;
661 args.in_args[1].size = entry->d_name.l
662 args.in_args[1].value = entry->d_name.
663 args.out_numargs = 2;
664 args.out_args[0].size = sizeof(outentr
665 args.out_args[0].value = &outentry;
666 /* Store outarg for fuse_finish_open()
667 outopenp = &ff->args->open_outarg;
668 args.out_args[1].size = sizeof(*outope
669 args.out_args[1].value = outopenp;
670
671 err = get_create_ext(&args, dir, entry
672 if (err)
673 goto out_free_ff;
674
675 err = fuse_simple_request(fm, &args);
676 free_ext_value(&args);
677 if (err)
678 goto out_free_ff;
679
680 err = -EIO;
681 if (!S_ISREG(outentry.attr.mode) || in
682 fuse_invalid_attr(&outentry.attr))
683 goto out_free_ff;
684
685 ff->fh = outopenp->fh;
686 ff->nodeid = outentry.nodeid;
687 ff->open_flags = outopenp->open_flags;
688 inode = fuse_iget(dir->i_sb, outentry.
689 &outentry.attr, ATTR
690 if (!inode) {
691 flags &= ~(O_CREAT | O_EXCL |
692 fuse_sync_release(NULL, ff, fl
693 fuse_queue_forget(fm->fc, forg
694 err = -ENOMEM;
695 goto out_err;
696 }
697 kfree(forget);
698 d_instantiate(entry, inode);
699 fuse_change_entry_timeout(entry, &oute
700 fuse_dir_changed(dir);
701 err = generic_file_open(inode, file);
702 if (!err) {
703 file->private_data = ff;
704 err = finish_open(file, entry,
705 }
706 if (err) {
707 fi = get_fuse_inode(inode);
708 fuse_sync_release(fi, ff, flag
709 } else {
710 if (fm->fc->atomic_o_trunc &&
711 truncate_pagecache(ino
712 else if (!(ff->open_flags & FO
713 invalidate_inode_pages
714 }
715 return err;
716
717 out_free_ff:
718 fuse_file_free(ff);
719 out_put_forget_req:
720 kfree(forget);
721 out_err:
722 return err;
723 }
724
725 static int fuse_mknod(struct mnt_idmap *, stru
726 umode_t, dev_t);
727 static int fuse_atomic_open(struct inode *dir,
728 struct file *file,
729 umode_t mode)
730 {
731 int err;
732 struct fuse_conn *fc = get_fuse_conn(d
733 struct dentry *res = NULL;
734
735 if (fuse_is_bad(dir))
736 return -EIO;
737
738 if (d_in_lookup(entry)) {
739 res = fuse_lookup(dir, entry,
740 if (IS_ERR(res))
741 return PTR_ERR(res);
742
743 if (res)
744 entry = res;
745 }
746
747 if (!(flags & O_CREAT) || d_really_is_
748 goto no_open;
749
750 /* Only creates */
751 file->f_mode |= FMODE_CREATED;
752
753 if (fc->no_create)
754 goto mknod;
755
756 err = fuse_create_open(dir, entry, fil
757 if (err == -ENOSYS) {
758 fc->no_create = 1;
759 goto mknod;
760 } else if (err == -EEXIST)
761 fuse_invalidate_entry(entry);
762 out_dput:
763 dput(res);
764 return err;
765
766 mknod:
767 err = fuse_mknod(&nop_mnt_idmap, dir,
768 if (err)
769 goto out_dput;
770 no_open:
771 return finish_no_open(file, res);
772 }
773
774 /*
775 * Code shared between mknod, mkdir, symlink a
776 */
777 static int create_new_entry(struct fuse_mount
778 struct inode *dir,
779 umode_t mode)
780 {
781 struct fuse_entry_out outarg;
782 struct inode *inode;
783 struct dentry *d;
784 int err;
785 struct fuse_forget_link *forget;
786
787 if (fuse_is_bad(dir))
788 return -EIO;
789
790 forget = fuse_alloc_forget();
791 if (!forget)
792 return -ENOMEM;
793
794 memset(&outarg, 0, sizeof(outarg));
795 args->nodeid = get_node_id(dir);
796 args->out_numargs = 1;
797 args->out_args[0].size = sizeof(outarg
798 args->out_args[0].value = &outarg;
799
800 if (args->opcode != FUSE_LINK) {
801 err = get_create_ext(args, dir
802 if (err)
803 goto out_put_forget_re
804 }
805
806 err = fuse_simple_request(fm, args);
807 free_ext_value(args);
808 if (err)
809 goto out_put_forget_req;
810
811 err = -EIO;
812 if (invalid_nodeid(outarg.nodeid) || f
813 goto out_put_forget_req;
814
815 if ((outarg.attr.mode ^ mode) & S_IFMT
816 goto out_put_forget_req;
817
818 inode = fuse_iget(dir->i_sb, outarg.no
819 &outarg.attr, ATTR_T
820 if (!inode) {
821 fuse_queue_forget(fm->fc, forg
822 return -ENOMEM;
823 }
824 kfree(forget);
825
826 d_drop(entry);
827 d = d_splice_alias(inode, entry);
828 if (IS_ERR(d))
829 return PTR_ERR(d);
830
831 if (d) {
832 fuse_change_entry_timeout(d, &
833 dput(d);
834 } else {
835 fuse_change_entry_timeout(entr
836 }
837 fuse_dir_changed(dir);
838 return 0;
839
840 out_put_forget_req:
841 if (err == -EEXIST)
842 fuse_invalidate_entry(entry);
843 kfree(forget);
844 return err;
845 }
846
847 static int fuse_mknod(struct mnt_idmap *idmap,
848 struct dentry *entry, um
849 {
850 struct fuse_mknod_in inarg;
851 struct fuse_mount *fm = get_fuse_mount
852 FUSE_ARGS(args);
853
854 if (!fm->fc->dont_mask)
855 mode &= ~current_umask();
856
857 memset(&inarg, 0, sizeof(inarg));
858 inarg.mode = mode;
859 inarg.rdev = new_encode_dev(rdev);
860 inarg.umask = current_umask();
861 args.opcode = FUSE_MKNOD;
862 args.in_numargs = 2;
863 args.in_args[0].size = sizeof(inarg);
864 args.in_args[0].value = &inarg;
865 args.in_args[1].size = entry->d_name.l
866 args.in_args[1].value = entry->d_name.
867 return create_new_entry(fm, &args, dir
868 }
869
870 static int fuse_create(struct mnt_idmap *idmap
871 struct dentry *entry, u
872 {
873 return fuse_mknod(&nop_mnt_idmap, dir,
874 }
875
876 static int fuse_tmpfile(struct mnt_idmap *idma
877 struct file *file, umo
878 {
879 struct fuse_conn *fc = get_fuse_conn(d
880 int err;
881
882 if (fc->no_tmpfile)
883 return -EOPNOTSUPP;
884
885 err = fuse_create_open(dir, file->f_pa
886 if (err == -ENOSYS) {
887 fc->no_tmpfile = 1;
888 err = -EOPNOTSUPP;
889 }
890 return err;
891 }
892
893 static int fuse_mkdir(struct mnt_idmap *idmap,
894 struct dentry *entry, um
895 {
896 struct fuse_mkdir_in inarg;
897 struct fuse_mount *fm = get_fuse_mount
898 FUSE_ARGS(args);
899
900 if (!fm->fc->dont_mask)
901 mode &= ~current_umask();
902
903 memset(&inarg, 0, sizeof(inarg));
904 inarg.mode = mode;
905 inarg.umask = current_umask();
906 args.opcode = FUSE_MKDIR;
907 args.in_numargs = 2;
908 args.in_args[0].size = sizeof(inarg);
909 args.in_args[0].value = &inarg;
910 args.in_args[1].size = entry->d_name.l
911 args.in_args[1].value = entry->d_name.
912 return create_new_entry(fm, &args, dir
913 }
914
915 static int fuse_symlink(struct mnt_idmap *idma
916 struct dentry *entry,
917 {
918 struct fuse_mount *fm = get_fuse_mount
919 unsigned len = strlen(link) + 1;
920 FUSE_ARGS(args);
921
922 args.opcode = FUSE_SYMLINK;
923 args.in_numargs = 2;
924 args.in_args[0].size = entry->d_name.l
925 args.in_args[0].value = entry->d_name.
926 args.in_args[1].size = len;
927 args.in_args[1].value = link;
928 return create_new_entry(fm, &args, dir
929 }
930
931 void fuse_flush_time_update(struct inode *inod
932 {
933 int err = sync_inode_metadata(inode, 1
934
935 mapping_set_error(inode->i_mapping, er
936 }
937
938 static void fuse_update_ctime_in_cache(struct
939 {
940 if (!IS_NOCMTIME(inode)) {
941 inode_set_ctime_current(inode)
942 mark_inode_dirty_sync(inode);
943 fuse_flush_time_update(inode);
944 }
945 }
946
947 void fuse_update_ctime(struct inode *inode)
948 {
949 fuse_invalidate_attr_mask(inode, STATX
950 fuse_update_ctime_in_cache(inode);
951 }
952
953 static void fuse_entry_unlinked(struct dentry
954 {
955 struct inode *inode = d_inode(entry);
956 struct fuse_conn *fc = get_fuse_conn(i
957 struct fuse_inode *fi = get_fuse_inode
958
959 spin_lock(&fi->lock);
960 fi->attr_version = atomic64_inc_return
961 /*
962 * If i_nlink == 0 then unlink doesn't
963 * happen if userspace filesystem is c
964 * difficult to enforce correct nlink
965 * condition here
966 */
967 if (S_ISDIR(inode->i_mode))
968 clear_nlink(inode);
969 else if (inode->i_nlink > 0)
970 drop_nlink(inode);
971 spin_unlock(&fi->lock);
972 fuse_invalidate_entry_cache(entry);
973 fuse_update_ctime(inode);
974 }
975
976 static int fuse_unlink(struct inode *dir, stru
977 {
978 int err;
979 struct fuse_mount *fm = get_fuse_mount
980 FUSE_ARGS(args);
981
982 if (fuse_is_bad(dir))
983 return -EIO;
984
985 args.opcode = FUSE_UNLINK;
986 args.nodeid = get_node_id(dir);
987 args.in_numargs = 1;
988 args.in_args[0].size = entry->d_name.l
989 args.in_args[0].value = entry->d_name.
990 err = fuse_simple_request(fm, &args);
991 if (!err) {
992 fuse_dir_changed(dir);
993 fuse_entry_unlinked(entry);
994 } else if (err == -EINTR || err == -EN
995 fuse_invalidate_entry(entry);
996 return err;
997 }
998
999 static int fuse_rmdir(struct inode *dir, struc
1000 {
1001 int err;
1002 struct fuse_mount *fm = get_fuse_moun
1003 FUSE_ARGS(args);
1004
1005 if (fuse_is_bad(dir))
1006 return -EIO;
1007
1008 args.opcode = FUSE_RMDIR;
1009 args.nodeid = get_node_id(dir);
1010 args.in_numargs = 1;
1011 args.in_args[0].size = entry->d_name.
1012 args.in_args[0].value = entry->d_name
1013 err = fuse_simple_request(fm, &args);
1014 if (!err) {
1015 fuse_dir_changed(dir);
1016 fuse_entry_unlinked(entry);
1017 } else if (err == -EINTR || err == -E
1018 fuse_invalidate_entry(entry);
1019 return err;
1020 }
1021
1022 static int fuse_rename_common(struct inode *o
1023 struct inode *n
1024 unsigned int fl
1025 {
1026 int err;
1027 struct fuse_rename2_in inarg;
1028 struct fuse_mount *fm = get_fuse_moun
1029 FUSE_ARGS(args);
1030
1031 memset(&inarg, 0, argsize);
1032 inarg.newdir = get_node_id(newdir);
1033 inarg.flags = flags;
1034 args.opcode = opcode;
1035 args.nodeid = get_node_id(olddir);
1036 args.in_numargs = 3;
1037 args.in_args[0].size = argsize;
1038 args.in_args[0].value = &inarg;
1039 args.in_args[1].size = oldent->d_name
1040 args.in_args[1].value = oldent->d_nam
1041 args.in_args[2].size = newent->d_name
1042 args.in_args[2].value = newent->d_nam
1043 err = fuse_simple_request(fm, &args);
1044 if (!err) {
1045 /* ctime changes */
1046 fuse_update_ctime(d_inode(old
1047
1048 if (flags & RENAME_EXCHANGE)
1049 fuse_update_ctime(d_i
1050
1051 fuse_dir_changed(olddir);
1052 if (olddir != newdir)
1053 fuse_dir_changed(newd
1054
1055 /* newent will end up negativ
1056 if (!(flags & RENAME_EXCHANGE
1057 fuse_entry_unlinked(n
1058 } else if (err == -EINTR || err == -E
1059 /* If request was interrupted
1060 rename actually took place
1061 fails (e.g. some process h
1062 directory), then there can
1063 the dcache and the real fi
1064 fuse_invalidate_entry(oldent)
1065 if (d_really_is_positive(newe
1066 fuse_invalidate_entry
1067 }
1068
1069 return err;
1070 }
1071
1072 static int fuse_rename2(struct mnt_idmap *idm
1073 struct dentry *oldent
1074 struct dentry *newent
1075 {
1076 struct fuse_conn *fc = get_fuse_conn(
1077 int err;
1078
1079 if (fuse_is_bad(olddir))
1080 return -EIO;
1081
1082 if (flags & ~(RENAME_NOREPLACE | RENA
1083 return -EINVAL;
1084
1085 if (flags) {
1086 if (fc->no_rename2 || fc->min
1087 return -EINVAL;
1088
1089 err = fuse_rename_common(oldd
1090 FUSE
1091 size
1092 if (err == -ENOSYS) {
1093 fc->no_rename2 = 1;
1094 err = -EINVAL;
1095 }
1096 } else {
1097 err = fuse_rename_common(oldd
1098 FUSE
1099 size
1100 }
1101
1102 return err;
1103 }
1104
1105 static int fuse_link(struct dentry *entry, st
1106 struct dentry *newent)
1107 {
1108 int err;
1109 struct fuse_link_in inarg;
1110 struct inode *inode = d_inode(entry);
1111 struct fuse_mount *fm = get_fuse_moun
1112 FUSE_ARGS(args);
1113
1114 memset(&inarg, 0, sizeof(inarg));
1115 inarg.oldnodeid = get_node_id(inode);
1116 args.opcode = FUSE_LINK;
1117 args.in_numargs = 2;
1118 args.in_args[0].size = sizeof(inarg);
1119 args.in_args[0].value = &inarg;
1120 args.in_args[1].size = newent->d_name
1121 args.in_args[1].value = newent->d_nam
1122 err = create_new_entry(fm, &args, new
1123 if (!err)
1124 fuse_update_ctime_in_cache(in
1125 else if (err == -EINTR)
1126 fuse_invalidate_attr(inode);
1127
1128 return err;
1129 }
1130
1131 static void fuse_fillattr(struct inode *inode
1132 struct kstat *stat)
1133 {
1134 unsigned int blkbits;
1135 struct fuse_conn *fc = get_fuse_conn(
1136
1137 stat->dev = inode->i_sb->s_dev;
1138 stat->ino = attr->ino;
1139 stat->mode = (inode->i_mode & S_IFMT)
1140 stat->nlink = attr->nlink;
1141 stat->uid = make_kuid(fc->user_ns, at
1142 stat->gid = make_kgid(fc->user_ns, at
1143 stat->rdev = inode->i_rdev;
1144 stat->atime.tv_sec = attr->atime;
1145 stat->atime.tv_nsec = attr->atimensec
1146 stat->mtime.tv_sec = attr->mtime;
1147 stat->mtime.tv_nsec = attr->mtimensec
1148 stat->ctime.tv_sec = attr->ctime;
1149 stat->ctime.tv_nsec = attr->ctimensec
1150 stat->size = attr->size;
1151 stat->blocks = attr->blocks;
1152
1153 if (attr->blksize != 0)
1154 blkbits = ilog2(attr->blksize
1155 else
1156 blkbits = inode->i_sb->s_bloc
1157
1158 stat->blksize = 1 << blkbits;
1159 }
1160
1161 static void fuse_statx_to_attr(struct fuse_st
1162 {
1163 memset(attr, 0, sizeof(*attr));
1164 attr->ino = sx->ino;
1165 attr->size = sx->size;
1166 attr->blocks = sx->blocks;
1167 attr->atime = sx->atime.tv_sec;
1168 attr->mtime = sx->mtime.tv_sec;
1169 attr->ctime = sx->ctime.tv_sec;
1170 attr->atimensec = sx->atime.tv_nsec;
1171 attr->mtimensec = sx->mtime.tv_nsec;
1172 attr->ctimensec = sx->ctime.tv_nsec;
1173 attr->mode = sx->mode;
1174 attr->nlink = sx->nlink;
1175 attr->uid = sx->uid;
1176 attr->gid = sx->gid;
1177 attr->rdev = new_encode_dev(MKDEV(sx-
1178 attr->blksize = sx->blksize;
1179 }
1180
1181 static int fuse_do_statx(struct inode *inode,
1182 struct kstat *stat)
1183 {
1184 int err;
1185 struct fuse_attr attr;
1186 struct fuse_statx *sx;
1187 struct fuse_statx_in inarg;
1188 struct fuse_statx_out outarg;
1189 struct fuse_mount *fm = get_fuse_moun
1190 u64 attr_version = fuse_get_attr_vers
1191 FUSE_ARGS(args);
1192
1193 memset(&inarg, 0, sizeof(inarg));
1194 memset(&outarg, 0, sizeof(outarg));
1195 /* Directories have separate file-han
1196 if (file && S_ISREG(inode->i_mode)) {
1197 struct fuse_file *ff = file->
1198
1199 inarg.getattr_flags |= FUSE_G
1200 inarg.fh = ff->fh;
1201 }
1202 /* For now leave sync hints as the de
1203 inarg.sx_flags = 0;
1204 inarg.sx_mask = STATX_BASIC_STATS | S
1205 args.opcode = FUSE_STATX;
1206 args.nodeid = get_node_id(inode);
1207 args.in_numargs = 1;
1208 args.in_args[0].size = sizeof(inarg);
1209 args.in_args[0].value = &inarg;
1210 args.out_numargs = 1;
1211 args.out_args[0].size = sizeof(outarg
1212 args.out_args[0].value = &outarg;
1213 err = fuse_simple_request(fm, &args);
1214 if (err)
1215 return err;
1216
1217 sx = &outarg.stat;
1218 if (((sx->mask & STATX_SIZE) && !fuse
1219 ((sx->mask & STATX_TYPE) && (!fus
1220 inod
1221 fuse_make_bad(inode);
1222 return -EIO;
1223 }
1224
1225 fuse_statx_to_attr(&outarg.stat, &att
1226 if ((sx->mask & STATX_BASIC_STATS) ==
1227 fuse_change_attributes(inode,
1228 ATTR_T
1229 }
1230
1231 if (stat) {
1232 stat->result_mask = sx->mask
1233 stat->btime.tv_sec = sx->btim
1234 stat->btime.tv_nsec = min_t(u
1235 fuse_fillattr(inode, &attr, s
1236 stat->result_mask |= STATX_TY
1237 }
1238
1239 return 0;
1240 }
1241
1242 static int fuse_do_getattr(struct inode *inod
1243 struct file *file)
1244 {
1245 int err;
1246 struct fuse_getattr_in inarg;
1247 struct fuse_attr_out outarg;
1248 struct fuse_mount *fm = get_fuse_moun
1249 FUSE_ARGS(args);
1250 u64 attr_version;
1251
1252 attr_version = fuse_get_attr_version(
1253
1254 memset(&inarg, 0, sizeof(inarg));
1255 memset(&outarg, 0, sizeof(outarg));
1256 /* Directories have separate file-han
1257 if (file && S_ISREG(inode->i_mode)) {
1258 struct fuse_file *ff = file->
1259
1260 inarg.getattr_flags |= FUSE_G
1261 inarg.fh = ff->fh;
1262 }
1263 args.opcode = FUSE_GETATTR;
1264 args.nodeid = get_node_id(inode);
1265 args.in_numargs = 1;
1266 args.in_args[0].size = sizeof(inarg);
1267 args.in_args[0].value = &inarg;
1268 args.out_numargs = 1;
1269 args.out_args[0].size = sizeof(outarg
1270 args.out_args[0].value = &outarg;
1271 err = fuse_simple_request(fm, &args);
1272 if (!err) {
1273 if (fuse_invalid_attr(&outarg
1274 inode_wrong_type(inode, o
1275 fuse_make_bad(inode);
1276 err = -EIO;
1277 } else {
1278 fuse_change_attribute
1279
1280
1281 if (stat)
1282 fuse_fillattr
1283 }
1284 }
1285 return err;
1286 }
1287
1288 static int fuse_update_get_attr(struct inode
1289 struct kstat
1290 unsigned int
1291 {
1292 struct fuse_inode *fi = get_fuse_inod
1293 struct fuse_conn *fc = get_fuse_conn(
1294 int err = 0;
1295 bool sync;
1296 u32 inval_mask = READ_ONCE(fi->inval_
1297 u32 cache_mask = fuse_get_cache_mask(
1298
1299
1300 /* FUSE only supports basic stats and
1301 request_mask &= STATX_BASIC_STATS | S
1302 retry:
1303 if (fc->no_statx)
1304 request_mask &= STATX_BASIC_S
1305
1306 if (!request_mask)
1307 sync = false;
1308 else if (flags & AT_STATX_FORCE_SYNC)
1309 sync = true;
1310 else if (flags & AT_STATX_DONT_SYNC)
1311 sync = false;
1312 else if (request_mask & inval_mask &
1313 sync = true;
1314 else
1315 sync = time_before64(fi->i_ti
1316
1317 if (sync) {
1318 forget_all_cached_acls(inode)
1319 /* Try statx if BTIME is requ
1320 if (!fc->no_statx && (request
1321 err = fuse_do_statx(i
1322 if (err == -ENOSYS) {
1323 fc->no_statx
1324 err = 0;
1325 goto retry;
1326 }
1327 } else {
1328 err = fuse_do_getattr
1329 }
1330 } else if (stat) {
1331 generic_fillattr(&nop_mnt_idm
1332 stat->mode = fi->orig_i_mode;
1333 stat->ino = fi->orig_ino;
1334 if (test_bit(FUSE_I_BTIME, &f
1335 stat->btime = fi->i_b
1336 stat->result_mask |=
1337 }
1338 }
1339
1340 return err;
1341 }
1342
1343 int fuse_update_attributes(struct inode *inod
1344 {
1345 return fuse_update_get_attr(inode, fi
1346 }
1347
1348 int fuse_reverse_inval_entry(struct fuse_conn
1349 u64 child_nodeid
1350 {
1351 int err = -ENOTDIR;
1352 struct inode *parent;
1353 struct dentry *dir;
1354 struct dentry *entry;
1355
1356 parent = fuse_ilookup(fc, parent_node
1357 if (!parent)
1358 return -ENOENT;
1359
1360 inode_lock_nested(parent, I_MUTEX_PAR
1361 if (!S_ISDIR(parent->i_mode))
1362 goto unlock;
1363
1364 err = -ENOENT;
1365 dir = d_find_alias(parent);
1366 if (!dir)
1367 goto unlock;
1368
1369 name->hash = full_name_hash(dir, name
1370 entry = d_lookup(dir, name);
1371 dput(dir);
1372 if (!entry)
1373 goto unlock;
1374
1375 fuse_dir_changed(parent);
1376 if (!(flags & FUSE_EXPIRE_ONLY))
1377 d_invalidate(entry);
1378 fuse_invalidate_entry_cache(entry);
1379
1380 if (child_nodeid != 0 && d_really_is_
1381 inode_lock(d_inode(entry));
1382 if (get_node_id(d_inode(entry
1383 err = -ENOENT;
1384 goto badentry;
1385 }
1386 if (d_mountpoint(entry)) {
1387 err = -EBUSY;
1388 goto badentry;
1389 }
1390 if (d_is_dir(entry)) {
1391 shrink_dcache_parent(
1392 if (!simple_empty(ent
1393 err = -ENOTEM
1394 goto badentry
1395 }
1396 d_inode(entry)->i_fla
1397 }
1398 dont_mount(entry);
1399 clear_nlink(d_inode(entry));
1400 err = 0;
1401 badentry:
1402 inode_unlock(d_inode(entry));
1403 if (!err)
1404 d_delete(entry);
1405 } else {
1406 err = 0;
1407 }
1408 dput(entry);
1409
1410 unlock:
1411 inode_unlock(parent);
1412 iput(parent);
1413 return err;
1414 }
1415
1416 static inline bool fuse_permissible_uidgid(st
1417 {
1418 const struct cred *cred = current_cre
1419
1420 return (uid_eq(cred->euid, fc->user_i
1421 uid_eq(cred->suid, fc->user_i
1422 uid_eq(cred->uid, fc->user_i
1423 gid_eq(cred->egid, fc->group_
1424 gid_eq(cred->sgid, fc->group_
1425 gid_eq(cred->gid, fc->group_
1426 }
1427
1428 /*
1429 * Calling into a user-controlled filesystem
1430 * daemon ptrace-like capabilities over the c
1431 * means, that the filesystem daemon is able
1432 * filesystem operations performed, and can a
1433 * of the requester process in otherwise impo
1434 * it can delay the operation for arbitrary l
1435 * DoS against the requester.
1436 *
1437 * For this reason only those processes can c
1438 * for which the owner of the mount has ptrac
1439 * excludes processes started by other users,
1440 */
1441 bool fuse_allow_current_process(struct fuse_c
1442 {
1443 bool allow;
1444
1445 if (fc->allow_other)
1446 allow = current_in_userns(fc-
1447 else
1448 allow = fuse_permissible_uidg
1449
1450 if (!allow && allow_sys_admin_access
1451 allow = true;
1452
1453 return allow;
1454 }
1455
1456 static int fuse_access(struct inode *inode, i
1457 {
1458 struct fuse_mount *fm = get_fuse_moun
1459 FUSE_ARGS(args);
1460 struct fuse_access_in inarg;
1461 int err;
1462
1463 BUG_ON(mask & MAY_NOT_BLOCK);
1464
1465 if (fm->fc->no_access)
1466 return 0;
1467
1468 memset(&inarg, 0, sizeof(inarg));
1469 inarg.mask = mask & (MAY_READ | MAY_W
1470 args.opcode = FUSE_ACCESS;
1471 args.nodeid = get_node_id(inode);
1472 args.in_numargs = 1;
1473 args.in_args[0].size = sizeof(inarg);
1474 args.in_args[0].value = &inarg;
1475 err = fuse_simple_request(fm, &args);
1476 if (err == -ENOSYS) {
1477 fm->fc->no_access = 1;
1478 err = 0;
1479 }
1480 return err;
1481 }
1482
1483 static int fuse_perm_getattr(struct inode *in
1484 {
1485 if (mask & MAY_NOT_BLOCK)
1486 return -ECHILD;
1487
1488 forget_all_cached_acls(inode);
1489 return fuse_do_getattr(inode, NULL, N
1490 }
1491
1492 /*
1493 * Check permission. The two basic access mo
1494 *
1495 * 1) Local access checking ('default_permiss
1496 * on file mode. This is the plain old disk
1497 * model.
1498 *
1499 * 2) "Remote" access checking, where server
1500 * checking permission in each inode operatio
1501 * is if ->permission() was invoked from sys_
1502 * access request is sent. Execute permissio
1503 * locally based on file mode.
1504 */
1505 static int fuse_permission(struct mnt_idmap *
1506 struct inode *inod
1507 {
1508 struct fuse_conn *fc = get_fuse_conn(
1509 bool refreshed = false;
1510 int err = 0;
1511
1512 if (fuse_is_bad(inode))
1513 return -EIO;
1514
1515 if (!fuse_allow_current_process(fc))
1516 return -EACCES;
1517
1518 /*
1519 * If attributes are needed, refresh
1520 */
1521 if (fc->default_permissions ||
1522 ((mask & MAY_EXEC) && S_ISREG(ino
1523 struct fuse_inode *fi = get_f
1524 u32 perm_mask = STATX_MODE |
1525
1526 if (perm_mask & READ_ONCE(fi-
1527 time_before64(fi->i_time,
1528 refreshed = true;
1529
1530 err = fuse_perm_getat
1531 if (err)
1532 return err;
1533 }
1534 }
1535
1536 if (fc->default_permissions) {
1537 err = generic_permission(&nop
1538
1539 /* If permission is denied, t
1540 attributes. This is also
1541 node will at first have no
1542 if (err == -EACCES && !refres
1543 err = fuse_perm_getat
1544 if (!err)
1545 err = generic
1546
1547 }
1548
1549 /* Note: the opposite of the
1550 exist. So if permissions
1551 noticed immediately, only
1552 timeout has expired */
1553 } else if (mask & (MAY_ACCESS | MAY_C
1554 err = fuse_access(inode, mask
1555 } else if ((mask & MAY_EXEC) && S_ISR
1556 if (!(inode->i_mode & S_IXUGO
1557 if (refreshed)
1558 return -EACCE
1559
1560 err = fuse_perm_getat
1561 if (!err && !(inode->
1562 return -EACCE
1563 }
1564 }
1565 return err;
1566 }
1567
1568 static int fuse_readlink_page(struct inode *i
1569 {
1570 struct fuse_mount *fm = get_fuse_moun
1571 struct fuse_page_desc desc = { .lengt
1572 struct fuse_args_pages ap = {
1573 .num_pages = 1,
1574 .pages = &page,
1575 .descs = &desc,
1576 };
1577 char *link;
1578 ssize_t res;
1579
1580 ap.args.opcode = FUSE_READLINK;
1581 ap.args.nodeid = get_node_id(inode);
1582 ap.args.out_pages = true;
1583 ap.args.out_argvar = true;
1584 ap.args.page_zeroing = true;
1585 ap.args.out_numargs = 1;
1586 ap.args.out_args[0].size = desc.lengt
1587 res = fuse_simple_request(fm, &ap.arg
1588
1589 fuse_invalidate_atime(inode);
1590
1591 if (res < 0)
1592 return res;
1593
1594 if (WARN_ON(res >= PAGE_SIZE))
1595 return -EIO;
1596
1597 link = page_address(page);
1598 link[res] = '\0';
1599
1600 return 0;
1601 }
1602
1603 static const char *fuse_get_link(struct dentr
1604 struct delay
1605 {
1606 struct fuse_conn *fc = get_fuse_conn(
1607 struct page *page;
1608 int err;
1609
1610 err = -EIO;
1611 if (fuse_is_bad(inode))
1612 goto out_err;
1613
1614 if (fc->cache_symlinks)
1615 return page_get_link(dentry,
1616
1617 err = -ECHILD;
1618 if (!dentry)
1619 goto out_err;
1620
1621 page = alloc_page(GFP_KERNEL);
1622 err = -ENOMEM;
1623 if (!page)
1624 goto out_err;
1625
1626 err = fuse_readlink_page(inode, page)
1627 if (err) {
1628 __free_page(page);
1629 goto out_err;
1630 }
1631
1632 set_delayed_call(callback, page_put_l
1633
1634 return page_address(page);
1635
1636 out_err:
1637 return ERR_PTR(err);
1638 }
1639
1640 static int fuse_dir_open(struct inode *inode,
1641 {
1642 struct fuse_mount *fm = get_fuse_moun
1643 int err;
1644
1645 if (fuse_is_bad(inode))
1646 return -EIO;
1647
1648 err = generic_file_open(inode, file);
1649 if (err)
1650 return err;
1651
1652 err = fuse_do_open(fm, get_node_id(in
1653 if (!err) {
1654 struct fuse_file *ff = file->
1655
1656 /*
1657 * Keep handling FOPEN_STREAM
1658 * directories for backward c
1659 * to be useful.
1660 */
1661 if (ff->open_flags & (FOPEN_S
1662 nonseekable_open(inod
1663 }
1664
1665 return err;
1666 }
1667
1668 static int fuse_dir_release(struct inode *ino
1669 {
1670 fuse_release_common(file, true);
1671
1672 return 0;
1673 }
1674
1675 static int fuse_dir_fsync(struct file *file,
1676 int datasync)
1677 {
1678 struct inode *inode = file->f_mapping
1679 struct fuse_conn *fc = get_fuse_conn(
1680 int err;
1681
1682 if (fuse_is_bad(inode))
1683 return -EIO;
1684
1685 if (fc->no_fsyncdir)
1686 return 0;
1687
1688 inode_lock(inode);
1689 err = fuse_fsync_common(file, start,
1690 if (err == -ENOSYS) {
1691 fc->no_fsyncdir = 1;
1692 err = 0;
1693 }
1694 inode_unlock(inode);
1695
1696 return err;
1697 }
1698
1699 static long fuse_dir_ioctl(struct file *file,
1700 unsigned long arg
1701 {
1702 struct fuse_conn *fc = get_fuse_conn(
1703
1704 /* FUSE_IOCTL_DIR only supported for
1705 if (fc->minor < 18)
1706 return -ENOTTY;
1707
1708 return fuse_ioctl_common(file, cmd, a
1709 }
1710
1711 static long fuse_dir_compat_ioctl(struct file
1712 unsigned l
1713 {
1714 struct fuse_conn *fc = get_fuse_conn(
1715
1716 if (fc->minor < 18)
1717 return -ENOTTY;
1718
1719 return fuse_ioctl_common(file, cmd, a
1720 FUSE_IOCTL_C
1721 }
1722
1723 static bool update_mtime(unsigned ivalid, boo
1724 {
1725 /* Always update if mtime is explicit
1726 if (ivalid & ATTR_MTIME_SET)
1727 return true;
1728
1729 /* Or if kernel i_mtime is the offici
1730 if (trust_local_mtime)
1731 return true;
1732
1733 /* If it's an open(O_TRUNC) or an ftr
1734 if ((ivalid & ATTR_SIZE) && (ivalid &
1735 return false;
1736
1737 /* In all other cases update */
1738 return true;
1739 }
1740
1741 static void iattr_to_fattr(struct fuse_conn *
1742 struct fuse_setatt
1743 {
1744 unsigned ivalid = iattr->ia_valid;
1745
1746 if (ivalid & ATTR_MODE)
1747 arg->valid |= FATTR_MODE, a
1748 if (ivalid & ATTR_UID)
1749 arg->valid |= FATTR_UID, a
1750 if (ivalid & ATTR_GID)
1751 arg->valid |= FATTR_GID, a
1752 if (ivalid & ATTR_SIZE)
1753 arg->valid |= FATTR_SIZE, a
1754 if (ivalid & ATTR_ATIME) {
1755 arg->valid |= FATTR_ATIME;
1756 arg->atime = iattr->ia_atime.
1757 arg->atimensec = iattr->ia_at
1758 if (!(ivalid & ATTR_ATIME_SET
1759 arg->valid |= FATTR_A
1760 }
1761 if ((ivalid & ATTR_MTIME) && update_m
1762 arg->valid |= FATTR_MTIME;
1763 arg->mtime = iattr->ia_mtime.
1764 arg->mtimensec = iattr->ia_mt
1765 if (!(ivalid & ATTR_MTIME_SET
1766 arg->valid |= FATTR_M
1767 }
1768 if ((ivalid & ATTR_CTIME) && trust_lo
1769 arg->valid |= FATTR_CTIME;
1770 arg->ctime = iattr->ia_ctime.
1771 arg->ctimensec = iattr->ia_ct
1772 }
1773 }
1774
1775 /*
1776 * Prevent concurrent writepages on inode
1777 *
1778 * This is done by adding a negative bias to
1779 * and waiting for all pending writes to fini
1780 */
1781 void fuse_set_nowrite(struct inode *inode)
1782 {
1783 struct fuse_inode *fi = get_fuse_inod
1784
1785 BUG_ON(!inode_is_locked(inode));
1786
1787 spin_lock(&fi->lock);
1788 BUG_ON(fi->writectr < 0);
1789 fi->writectr += FUSE_NOWRITE;
1790 spin_unlock(&fi->lock);
1791 wait_event(fi->page_waitq, fi->writec
1792 }
1793
1794 /*
1795 * Allow writepages on inode
1796 *
1797 * Remove the bias from the writecounter and
1798 * writepages.
1799 */
1800 static void __fuse_release_nowrite(struct ino
1801 {
1802 struct fuse_inode *fi = get_fuse_inod
1803
1804 BUG_ON(fi->writectr != FUSE_NOWRITE);
1805 fi->writectr = 0;
1806 fuse_flush_writepages(inode);
1807 }
1808
1809 void fuse_release_nowrite(struct inode *inode
1810 {
1811 struct fuse_inode *fi = get_fuse_inod
1812
1813 spin_lock(&fi->lock);
1814 __fuse_release_nowrite(inode);
1815 spin_unlock(&fi->lock);
1816 }
1817
1818 static void fuse_setattr_fill(struct fuse_con
1819 struct inode *i
1820 struct fuse_set
1821 struct fuse_att
1822 {
1823 args->opcode = FUSE_SETATTR;
1824 args->nodeid = get_node_id(inode);
1825 args->in_numargs = 1;
1826 args->in_args[0].size = sizeof(*inarg
1827 args->in_args[0].value = inarg_p;
1828 args->out_numargs = 1;
1829 args->out_args[0].size = sizeof(*outa
1830 args->out_args[0].value = outarg_p;
1831 }
1832
1833 /*
1834 * Flush inode->i_mtime to the server
1835 */
1836 int fuse_flush_times(struct inode *inode, str
1837 {
1838 struct fuse_mount *fm = get_fuse_moun
1839 FUSE_ARGS(args);
1840 struct fuse_setattr_in inarg;
1841 struct fuse_attr_out outarg;
1842
1843 memset(&inarg, 0, sizeof(inarg));
1844 memset(&outarg, 0, sizeof(outarg));
1845
1846 inarg.valid = FATTR_MTIME;
1847 inarg.mtime = inode_get_mtime_sec(ino
1848 inarg.mtimensec = inode_get_mtime_nse
1849 if (fm->fc->minor >= 23) {
1850 inarg.valid |= FATTR_CTIME;
1851 inarg.ctime = inode_get_ctime
1852 inarg.ctimensec = inode_get_c
1853 }
1854 if (ff) {
1855 inarg.valid |= FATTR_FH;
1856 inarg.fh = ff->fh;
1857 }
1858 fuse_setattr_fill(fm->fc, &args, inod
1859
1860 return fuse_simple_request(fm, &args)
1861 }
1862
1863 /*
1864 * Set attributes, and at the same time refre
1865 *
1866 * Truncation is slightly complicated, becaus
1867 * may fail, in which case we don't want to t
1868 * vmtruncate() doesn't allow for this case,
1869 * and the actual truncation by hand.
1870 */
1871 int fuse_do_setattr(struct dentry *dentry, st
1872 struct file *file)
1873 {
1874 struct inode *inode = d_inode(dentry)
1875 struct fuse_mount *fm = get_fuse_moun
1876 struct fuse_conn *fc = fm->fc;
1877 struct fuse_inode *fi = get_fuse_inod
1878 struct address_space *mapping = inode
1879 FUSE_ARGS(args);
1880 struct fuse_setattr_in inarg;
1881 struct fuse_attr_out outarg;
1882 bool is_truncate = false;
1883 bool is_wb = fc->writeback_cache && S
1884 loff_t oldsize;
1885 int err;
1886 bool trust_local_cmtime = is_wb;
1887 bool fault_blocked = false;
1888
1889 if (!fc->default_permissions)
1890 attr->ia_valid |= ATTR_FORCE;
1891
1892 err = setattr_prepare(&nop_mnt_idmap,
1893 if (err)
1894 return err;
1895
1896 if (attr->ia_valid & ATTR_SIZE) {
1897 if (WARN_ON(!S_ISREG(inode->i
1898 return -EIO;
1899 is_truncate = true;
1900 }
1901
1902 if (FUSE_IS_DAX(inode) && is_truncate
1903 filemap_invalidate_lock(mappi
1904 fault_blocked = true;
1905 err = fuse_dax_break_layouts(
1906 if (err) {
1907 filemap_invalidate_un
1908 return err;
1909 }
1910 }
1911
1912 if (attr->ia_valid & ATTR_OPEN) {
1913 /* This is coming from open(.
1914 WARN_ON(!(attr->ia_valid & AT
1915 WARN_ON(attr->ia_size != 0);
1916 if (fc->atomic_o_trunc) {
1917 /*
1918 * No need to send re
1919 * truncation has alr
1920 * need to truncate p
1921 */
1922 i_size_write(inode, 0
1923 truncate_pagecache(in
1924 goto out;
1925 }
1926 file = NULL;
1927 }
1928
1929 /* Flush dirty data/metadata before n
1930 if (is_wb &&
1931 attr->ia_valid &
1932 (ATTR_MODE | ATTR_UID
1933 ATTR_TIMES_SET)) {
1934 err = write_inode_now(inode,
1935 if (err)
1936 return err;
1937
1938 fuse_set_nowrite(inode);
1939 fuse_release_nowrite(inode);
1940 }
1941
1942 if (is_truncate) {
1943 fuse_set_nowrite(inode);
1944 set_bit(FUSE_I_SIZE_UNSTABLE,
1945 if (trust_local_cmtime && att
1946 attr->ia_valid |= ATT
1947 }
1948
1949 memset(&inarg, 0, sizeof(inarg));
1950 memset(&outarg, 0, sizeof(outarg));
1951 iattr_to_fattr(fc, attr, &inarg, trus
1952 if (file) {
1953 struct fuse_file *ff = file->
1954 inarg.valid |= FATTR_FH;
1955 inarg.fh = ff->fh;
1956 }
1957
1958 /* Kill suid/sgid for non-directory c
1959 if (fc->handle_killpriv_v2 && !S_ISDI
1960 attr->ia_valid & (ATTR_UID | ATTR
1961 inarg.valid |= FATTR_KILL_SUI
1962
1963 if (attr->ia_valid & ATTR_SIZE) {
1964 /* For mandatory locking in t
1965 inarg.valid |= FATTR_LOCKOWNE
1966 inarg.lock_owner = fuse_lock_
1967
1968 /* Kill suid/sgid for truncat
1969 if (fc->handle_killpriv_v2 &&
1970 inarg.valid |= FATTR_
1971 }
1972 fuse_setattr_fill(fc, &args, inode, &
1973 err = fuse_simple_request(fm, &args);
1974 if (err) {
1975 if (err == -EINTR)
1976 fuse_invalidate_attr(
1977 goto error;
1978 }
1979
1980 if (fuse_invalid_attr(&outarg.attr) |
1981 inode_wrong_type(inode, outarg.at
1982 fuse_make_bad(inode);
1983 err = -EIO;
1984 goto error;
1985 }
1986
1987 spin_lock(&fi->lock);
1988 /* the kernel maintains i_mtime local
1989 if (trust_local_cmtime) {
1990 if (attr->ia_valid & ATTR_MTI
1991 inode_set_mtime_to_ts
1992 if (attr->ia_valid & ATTR_CTI
1993 inode_set_ctime_to_ts
1994 /* FIXME: clear I_DIRTY_SYNC?
1995 }
1996
1997 fuse_change_attributes_common(inode,
1998 ATTR_TI
1999 fuse_ge
2000 oldsize = inode->i_size;
2001 /* see the comment in fuse_change_att
2002 if (!is_wb || is_truncate)
2003 i_size_write(inode, outarg.at
2004
2005 if (is_truncate) {
2006 /* NOTE: this may release/rea
2007 __fuse_release_nowrite(inode)
2008 }
2009 spin_unlock(&fi->lock);
2010
2011 /*
2012 * Only call invalidate_inode_pages2(
2013 * FUSE_NOWRITE, otherwise fuse_laund
2014 */
2015 if ((is_truncate || !is_wb) &&
2016 S_ISREG(inode->i_mode) && oldsize
2017 truncate_pagecache(inode, out
2018 invalidate_inode_pages2(mappi
2019 }
2020
2021 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->
2022 out:
2023 if (fault_blocked)
2024 filemap_invalidate_unlock(map
2025
2026 return 0;
2027
2028 error:
2029 if (is_truncate)
2030 fuse_release_nowrite(inode);
2031
2032 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->
2033
2034 if (fault_blocked)
2035 filemap_invalidate_unlock(map
2036 return err;
2037 }
2038
2039 static int fuse_setattr(struct mnt_idmap *idm
2040 struct iattr *attr)
2041 {
2042 struct inode *inode = d_inode(entry);
2043 struct fuse_conn *fc = get_fuse_conn(
2044 struct file *file = (attr->ia_valid &
2045 int ret;
2046
2047 if (fuse_is_bad(inode))
2048 return -EIO;
2049
2050 if (!fuse_allow_current_process(get_f
2051 return -EACCES;
2052
2053 if (attr->ia_valid & (ATTR_KILL_SUID
2054 attr->ia_valid &= ~(ATTR_KILL
2055 ATTR_MODE
2056
2057 /*
2058 * The only sane way to relia
2059 * the userspace filesystem
2060 *
2061 * This should be done on wri
2062 */
2063 if (!fc->handle_killpriv && !
2064 /*
2065 * ia_mode calculatio
2066 * Refresh and recalc
2067 */
2068 ret = fuse_do_getattr
2069 if (ret)
2070 return ret;
2071
2072 attr->ia_mode = inode
2073 if (inode->i_mode & S
2074 attr->ia_vali
2075 attr->ia_mode
2076 }
2077 if ((inode->i_mode &
2078 attr->ia_vali
2079 attr->ia_mode
2080 }
2081 }
2082 }
2083 if (!attr->ia_valid)
2084 return 0;
2085
2086 ret = fuse_do_setattr(entry, attr, fi
2087 if (!ret) {
2088 /*
2089 * If filesystem supports acl
2090 * the filesystem, so forget
2091 */
2092 if (fc->posix_acl)
2093 forget_all_cached_acl
2094
2095 /* Directory mode changed, ma
2096 if (d_is_dir(entry) && (attr-
2097 fuse_invalidate_entry
2098 }
2099 return ret;
2100 }
2101
2102 static int fuse_getattr(struct mnt_idmap *idm
2103 const struct path *pa
2104 u32 request_mask, uns
2105 {
2106 struct inode *inode = d_inode(path->d
2107 struct fuse_conn *fc = get_fuse_conn(
2108
2109 if (fuse_is_bad(inode))
2110 return -EIO;
2111
2112 if (!fuse_allow_current_process(fc))
2113 if (!request_mask) {
2114 /*
2115 * If user explicitly
2116 * error out, but ret
2117 */
2118 stat->result_mask = 0
2119 stat->dev = inode->i_
2120 return 0;
2121 }
2122 return -EACCES;
2123 }
2124
2125 return fuse_update_get_attr(inode, NU
2126 }
2127
2128 static const struct inode_operations fuse_dir
2129 .lookup = fuse_lookup,
2130 .mkdir = fuse_mkdir,
2131 .symlink = fuse_symlink,
2132 .unlink = fuse_unlink,
2133 .rmdir = fuse_rmdir,
2134 .rename = fuse_rename2,
2135 .link = fuse_link,
2136 .setattr = fuse_setattr,
2137 .create = fuse_create,
2138 .atomic_open = fuse_atomic_open,
2139 .tmpfile = fuse_tmpfile,
2140 .mknod = fuse_mknod,
2141 .permission = fuse_permission,
2142 .getattr = fuse_getattr,
2143 .listxattr = fuse_listxattr,
2144 .get_inode_acl = fuse_get_inode_acl,
2145 .get_acl = fuse_get_acl,
2146 .set_acl = fuse_set_acl,
2147 .fileattr_get = fuse_fileattr_get,
2148 .fileattr_set = fuse_fileattr_set,
2149 };
2150
2151 static const struct file_operations fuse_dir_
2152 .llseek = generic_file_llseek
2153 .read = generic_read_dir,
2154 .iterate_shared = fuse_readdir,
2155 .open = fuse_dir_open,
2156 .release = fuse_dir_release,
2157 .fsync = fuse_dir_fsync,
2158 .unlocked_ioctl = fuse_dir_ioctl,
2159 .compat_ioctl = fuse_dir_compat_ioc
2160 };
2161
2162 static const struct inode_operations fuse_com
2163 .setattr = fuse_setattr,
2164 .permission = fuse_permission,
2165 .getattr = fuse_getattr,
2166 .listxattr = fuse_listxattr,
2167 .get_inode_acl = fuse_get_inode_acl,
2168 .get_acl = fuse_get_acl,
2169 .set_acl = fuse_set_acl,
2170 .fileattr_get = fuse_fileattr_get,
2171 .fileattr_set = fuse_fileattr_set,
2172 };
2173
2174 static const struct inode_operations fuse_sym
2175 .setattr = fuse_setattr,
2176 .get_link = fuse_get_link,
2177 .getattr = fuse_getattr,
2178 .listxattr = fuse_listxattr,
2179 };
2180
2181 void fuse_init_common(struct inode *inode)
2182 {
2183 inode->i_op = &fuse_common_inode_oper
2184 }
2185
2186 void fuse_init_dir(struct inode *inode)
2187 {
2188 struct fuse_inode *fi = get_fuse_inod
2189
2190 inode->i_op = &fuse_dir_inode_operati
2191 inode->i_fop = &fuse_dir_operations;
2192
2193 spin_lock_init(&fi->rdc.lock);
2194 fi->rdc.cached = false;
2195 fi->rdc.size = 0;
2196 fi->rdc.pos = 0;
2197 fi->rdc.version = 0;
2198 }
2199
2200 static int fuse_symlink_read_folio(struct fil
2201 {
2202 int err = fuse_readlink_page(folio->m
2203
2204 if (!err)
2205 folio_mark_uptodate(folio);
2206
2207 folio_unlock(folio);
2208
2209 return err;
2210 }
2211
2212 static const struct address_space_operations
2213 .read_folio = fuse_symlink_read_f
2214 };
2215
2216 void fuse_init_symlink(struct inode *inode)
2217 {
2218 inode->i_op = &fuse_symlink_inode_ope
2219 inode->i_data.a_ops = &fuse_symlink_a
2220 inode_nohighmem(inode);
2221 }
2222
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.