2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu>
5 This program can be distributed under the terms of the GNU GPL.
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>
25 static bool __read_mostly allow_sys_admin_access;
26 module_param(allow_sys_admin_access, bool, 0644);
27 MODULE_PARM_DESC(allow_sys_admin_access,
28 "Allow users with CAP_SYS_ADMIN in initial userns to bypass allow_other access check");
30 static void fuse_advise_use_readdirplus(struct inode *dir)
32 struct fuse_inode *fi = get_fuse_inode(dir);
34 set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
37 #if BITS_PER_LONG >= 64
38 static inline void __fuse_dentry_settime(struct dentry *entry, u64 time)
40 entry->d_fsdata = (void *) time;
43 static inline u64 fuse_dentry_time(const struct dentry *entry)
45 return (u64)entry->d_fsdata;
54 static inline void __fuse_dentry_settime(struct dentry *dentry, u64 time)
56 ((union fuse_dentry *) dentry->d_fsdata)->time = time;
59 static inline u64 fuse_dentry_time(const struct dentry *entry)
61 return ((union fuse_dentry *) entry->d_fsdata)->time;
65 static void fuse_dentry_settime(struct dentry *dentry, u64 time)
67 struct fuse_conn *fc = get_fuse_conn_super(dentry->d_sb);
68 bool delete = !time && fc->delete_stale;
70 * Mess with DCACHE_OP_DELETE because dput() will be faster without it.
71 * Don't care about races, either way it's just an optimization
73 if ((!delete && (dentry->d_flags & DCACHE_OP_DELETE)) ||
74 (delete && !(dentry->d_flags & DCACHE_OP_DELETE))) {
75 spin_lock(&dentry->d_lock);
77 dentry->d_flags &= ~DCACHE_OP_DELETE;
79 dentry->d_flags |= DCACHE_OP_DELETE;
80 spin_unlock(&dentry->d_lock);
83 __fuse_dentry_settime(dentry, time);
87 * FUSE caches dentries and attributes with separate timeout. The
88 * time in jiffies until the dentry/attributes are valid is stored in
89 * dentry->d_fsdata and fuse_inode->i_time respectively.
93 * Calculate the time in jiffies until a dentry/attributes are valid
95 static u64 time_to_jiffies(u64 sec, u32 nsec)
98 struct timespec64 ts = {
100 min_t(u32, nsec, NSEC_PER_SEC - 1)
103 return get_jiffies_64() + timespec64_to_jiffies(&ts);
109 * Set dentry and possibly attribute timeouts from the lookup/mk*
112 void fuse_change_entry_timeout(struct dentry *entry, struct fuse_entry_out *o)
114 fuse_dentry_settime(entry,
115 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
118 static u64 attr_timeout(struct fuse_attr_out *o)
120 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
123 u64 entry_attr_timeout(struct fuse_entry_out *o)
125 return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
128 void fuse_invalidate_attr_mask(struct inode *inode, u32 mask)
130 set_mask_bits(&get_fuse_inode(inode)->inval_mask, 0, mask);
134 * Mark the attributes as stale, so that at the next call to
135 * ->getattr() they will be fetched from userspace
137 void fuse_invalidate_attr(struct inode *inode)
139 fuse_invalidate_attr_mask(inode, STATX_BASIC_STATS);
142 static void fuse_dir_changed(struct inode *dir)
144 fuse_invalidate_attr(dir);
145 inode_maybe_inc_iversion(dir, false);
149 * Mark the attributes as stale due to an atime change. Avoid the invalidate if
152 void fuse_invalidate_atime(struct inode *inode)
154 if (!IS_RDONLY(inode))
155 fuse_invalidate_attr_mask(inode, STATX_ATIME);
159 * Just mark the entry as stale, so that a next attempt to look it up
160 * will result in a new lookup call to userspace
162 * This is called when a dentry is about to become negative and the
163 * timeout is unknown (unlink, rmdir, rename and in some cases
166 void fuse_invalidate_entry_cache(struct dentry *entry)
168 fuse_dentry_settime(entry, 0);
172 * Same as fuse_invalidate_entry_cache(), but also try to remove the
173 * dentry from the hash
175 static void fuse_invalidate_entry(struct dentry *entry)
178 fuse_invalidate_entry_cache(entry);
181 static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_args *args,
182 u64 nodeid, const struct qstr *name,
183 struct fuse_entry_out *outarg)
185 memset(outarg, 0, sizeof(struct fuse_entry_out));
186 args->opcode = FUSE_LOOKUP;
187 args->nodeid = nodeid;
188 args->in_numargs = 1;
189 args->in_args[0].size = name->len + 1;
190 args->in_args[0].value = name->name;
191 args->out_numargs = 1;
192 args->out_args[0].size = sizeof(struct fuse_entry_out);
193 args->out_args[0].value = outarg;
197 * Check whether the dentry is still valid
199 * If the entry validity timeout has expired and the dentry is
200 * positive, try to redo the lookup. If the lookup results in a
201 * different inode, then let the VFS invalidate the dentry and redo
202 * the lookup once more. If the lookup results in the same inode,
203 * then refresh the attributes, timeouts and mark the dentry valid.
205 static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
208 struct dentry *parent;
209 struct fuse_mount *fm;
210 struct fuse_inode *fi;
213 inode = d_inode_rcu(entry);
214 if (inode && fuse_is_bad(inode))
216 else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
217 (flags & (LOOKUP_EXCL | LOOKUP_REVAL | LOOKUP_RENAME_TARGET))) {
218 struct fuse_entry_out outarg;
220 struct fuse_forget_link *forget;
223 /* For negative dentries, always do a fresh lookup */
228 if (flags & LOOKUP_RCU)
231 fm = get_fuse_mount(inode);
233 forget = fuse_alloc_forget();
238 attr_version = fuse_get_attr_version(fm->fc);
240 parent = dget_parent(entry);
241 fuse_lookup_init(fm->fc, &args, get_node_id(d_inode(parent)),
242 &entry->d_name, &outarg);
243 ret = fuse_simple_request(fm, &args);
245 /* Zero nodeid is same as -ENOENT */
246 if (!ret && !outarg.nodeid)
249 fi = get_fuse_inode(inode);
250 if (outarg.nodeid != get_node_id(inode) ||
251 (bool) IS_AUTOMOUNT(inode) != (bool) (outarg.attr.flags & FUSE_ATTR_SUBMOUNT)) {
252 fuse_queue_forget(fm->fc, forget,
256 spin_lock(&fi->lock);
258 spin_unlock(&fi->lock);
261 if (ret == -ENOMEM || ret == -EINTR)
263 if (ret || fuse_invalid_attr(&outarg.attr) ||
264 fuse_stale_inode(inode, outarg.generation, &outarg.attr))
267 forget_all_cached_acls(inode);
268 fuse_change_attributes(inode, &outarg.attr,
269 entry_attr_timeout(&outarg),
271 fuse_change_entry_timeout(entry, &outarg);
273 fi = get_fuse_inode(inode);
274 if (flags & LOOKUP_RCU) {
275 if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
277 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
278 parent = dget_parent(entry);
279 fuse_advise_use_readdirplus(d_inode(parent));
292 #if BITS_PER_LONG < 64
293 static int fuse_dentry_init(struct dentry *dentry)
295 dentry->d_fsdata = kzalloc(sizeof(union fuse_dentry),
296 GFP_KERNEL_ACCOUNT | __GFP_RECLAIMABLE);
298 return dentry->d_fsdata ? 0 : -ENOMEM;
300 static void fuse_dentry_release(struct dentry *dentry)
302 union fuse_dentry *fd = dentry->d_fsdata;
308 static int fuse_dentry_delete(const struct dentry *dentry)
310 return time_before64(fuse_dentry_time(dentry), get_jiffies_64());
314 * Create a fuse_mount object with a new superblock (with path->dentry
315 * as the root), and return that mount so it can be auto-mounted on
318 static struct vfsmount *fuse_dentry_automount(struct path *path)
320 struct fs_context *fsc;
321 struct vfsmount *mnt;
322 struct fuse_inode *mp_fi = get_fuse_inode(d_inode(path->dentry));
324 fsc = fs_context_for_submount(path->mnt->mnt_sb->s_type, path->dentry);
326 return ERR_CAST(fsc);
328 /* Pass the FUSE inode of the mount for fuse_get_tree_submount() */
329 fsc->fs_private = mp_fi;
331 /* Create the submount */
340 const struct dentry_operations fuse_dentry_operations = {
341 .d_revalidate = fuse_dentry_revalidate,
342 .d_delete = fuse_dentry_delete,
343 #if BITS_PER_LONG < 64
344 .d_init = fuse_dentry_init,
345 .d_release = fuse_dentry_release,
347 .d_automount = fuse_dentry_automount,
350 const struct dentry_operations fuse_root_dentry_operations = {
351 #if BITS_PER_LONG < 64
352 .d_init = fuse_dentry_init,
353 .d_release = fuse_dentry_release,
357 int fuse_valid_type(int m)
359 return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
360 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
363 bool fuse_invalid_attr(struct fuse_attr *attr)
365 return !fuse_valid_type(attr->mode) ||
366 attr->size > LLONG_MAX;
369 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
370 struct fuse_entry_out *outarg, struct inode **inode)
372 struct fuse_mount *fm = get_fuse_mount_super(sb);
374 struct fuse_forget_link *forget;
380 if (name->len > FUSE_NAME_MAX)
384 forget = fuse_alloc_forget();
389 attr_version = fuse_get_attr_version(fm->fc);
391 fuse_lookup_init(fm->fc, &args, nodeid, name, outarg);
392 err = fuse_simple_request(fm, &args);
393 /* Zero nodeid is same as -ENOENT, but with valid timeout */
394 if (err || !outarg->nodeid)
400 if (fuse_invalid_attr(&outarg->attr))
402 if (outarg->nodeid == FUSE_ROOT_ID && outarg->generation != 0) {
403 pr_warn_once("root generation should be zero\n");
404 outarg->generation = 0;
407 *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
408 &outarg->attr, entry_attr_timeout(outarg),
412 fuse_queue_forget(fm->fc, forget, outarg->nodeid, 1);
423 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
427 struct fuse_entry_out outarg;
429 struct dentry *newent;
430 bool outarg_valid = true;
433 if (fuse_is_bad(dir))
434 return ERR_PTR(-EIO);
436 locked = fuse_lock_inode(dir);
437 err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
439 fuse_unlock_inode(dir, locked);
440 if (err == -ENOENT) {
441 outarg_valid = false;
448 if (inode && get_node_id(inode) == FUSE_ROOT_ID)
451 newent = d_splice_alias(inode, entry);
452 err = PTR_ERR(newent);
456 entry = newent ? newent : entry;
458 fuse_change_entry_timeout(entry, &outarg);
460 fuse_invalidate_entry_cache(entry);
463 fuse_advise_use_readdirplus(dir);
472 static int get_security_context(struct dentry *entry, umode_t mode,
473 void **security_ctx, u32 *security_ctxlen)
475 struct fuse_secctx *fctx;
476 struct fuse_secctx_header *header;
477 void *ctx = NULL, *ptr;
478 u32 ctxlen, total_len = sizeof(*header);
483 err = security_dentry_init_security(entry, mode, &entry->d_name,
484 &name, &ctx, &ctxlen);
486 if (err != -EOPNOTSUPP)
488 /* No LSM is supporting this security hook. Ignore error */
495 namelen = strlen(name) + 1;
497 if (WARN_ON(namelen > XATTR_NAME_MAX + 1 || ctxlen > S32_MAX))
499 total_len += FUSE_REC_ALIGN(sizeof(*fctx) + namelen + ctxlen);
503 header = ptr = kzalloc(total_len, GFP_KERNEL);
507 header->nr_secctx = nr_ctx;
508 header->size = total_len;
509 ptr += sizeof(*header);
513 ptr += sizeof(*fctx);
518 memcpy(ptr, ctx, ctxlen);
520 *security_ctxlen = total_len;
521 *security_ctx = header;
529 * Atomic create+open operation
531 * If the filesystem doesn't support this, then fall back to separate
532 * 'mknod' + 'open' requests.
534 static int fuse_create_open(struct inode *dir, struct dentry *entry,
535 struct file *file, unsigned int flags,
536 umode_t mode, u32 opcode)
540 struct fuse_mount *fm = get_fuse_mount(dir);
542 struct fuse_forget_link *forget;
543 struct fuse_create_in inarg;
544 struct fuse_open_out outopen;
545 struct fuse_entry_out outentry;
546 struct fuse_inode *fi;
547 struct fuse_file *ff;
548 void *security_ctx = NULL;
550 bool trunc = flags & O_TRUNC;
552 /* Userspace expects S_IFREG in create mode */
553 BUG_ON((mode & S_IFMT) != S_IFREG);
555 forget = fuse_alloc_forget();
561 ff = fuse_file_alloc(fm);
563 goto out_put_forget_req;
565 if (!fm->fc->dont_mask)
566 mode &= ~current_umask();
569 memset(&inarg, 0, sizeof(inarg));
570 memset(&outentry, 0, sizeof(outentry));
573 inarg.umask = current_umask();
575 if (fm->fc->handle_killpriv_v2 && trunc &&
576 !(flags & O_EXCL) && !capable(CAP_FSETID)) {
577 inarg.open_flags |= FUSE_OPEN_KILL_SUIDGID;
580 args.opcode = opcode;
581 args.nodeid = get_node_id(dir);
583 args.in_args[0].size = sizeof(inarg);
584 args.in_args[0].value = &inarg;
585 args.in_args[1].size = entry->d_name.len + 1;
586 args.in_args[1].value = entry->d_name.name;
587 args.out_numargs = 2;
588 args.out_args[0].size = sizeof(outentry);
589 args.out_args[0].value = &outentry;
590 args.out_args[1].size = sizeof(outopen);
591 args.out_args[1].value = &outopen;
593 if (fm->fc->init_security) {
594 err = get_security_context(entry, mode, &security_ctx,
597 goto out_put_forget_req;
600 args.in_args[2].size = security_ctxlen;
601 args.in_args[2].value = security_ctx;
604 err = fuse_simple_request(fm, &args);
610 if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid) ||
611 fuse_invalid_attr(&outentry.attr))
615 ff->nodeid = outentry.nodeid;
616 ff->open_flags = outopen.open_flags;
617 inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
618 &outentry.attr, entry_attr_timeout(&outentry), 0);
620 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
621 fuse_sync_release(NULL, ff, flags);
622 fuse_queue_forget(fm->fc, forget, outentry.nodeid, 1);
627 d_instantiate(entry, inode);
628 fuse_change_entry_timeout(entry, &outentry);
629 fuse_dir_changed(dir);
630 err = finish_open(file, entry, generic_file_open);
632 fi = get_fuse_inode(inode);
633 fuse_sync_release(fi, ff, flags);
635 file->private_data = ff;
636 fuse_finish_open(inode, file);
637 if (fm->fc->atomic_o_trunc && trunc)
638 truncate_pagecache(inode, 0);
639 else if (!(ff->open_flags & FOPEN_KEEP_CACHE))
640 invalidate_inode_pages2(inode->i_mapping);
652 static int fuse_mknod(struct user_namespace *, struct inode *, struct dentry *,
654 static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
655 struct file *file, unsigned flags,
659 struct fuse_conn *fc = get_fuse_conn(dir);
660 struct dentry *res = NULL;
662 if (fuse_is_bad(dir))
665 if (d_in_lookup(entry)) {
666 res = fuse_lookup(dir, entry, 0);
674 if (!(flags & O_CREAT) || d_really_is_positive(entry))
678 file->f_mode |= FMODE_CREATED;
683 err = fuse_create_open(dir, entry, file, flags, mode, FUSE_CREATE);
684 if (err == -ENOSYS) {
693 err = fuse_mknod(&init_user_ns, dir, entry, mode, 0);
697 return finish_no_open(file, res);
701 * Code shared between mknod, mkdir, symlink and link
703 static int create_new_entry(struct fuse_mount *fm, struct fuse_args *args,
704 struct inode *dir, struct dentry *entry,
707 struct fuse_entry_out outarg;
711 struct fuse_forget_link *forget;
712 void *security_ctx = NULL;
715 if (fuse_is_bad(dir))
718 forget = fuse_alloc_forget();
722 memset(&outarg, 0, sizeof(outarg));
723 args->nodeid = get_node_id(dir);
724 args->out_numargs = 1;
725 args->out_args[0].size = sizeof(outarg);
726 args->out_args[0].value = &outarg;
728 if (fm->fc->init_security && args->opcode != FUSE_LINK) {
729 err = get_security_context(entry, mode, &security_ctx,
732 goto out_put_forget_req;
734 BUG_ON(args->in_numargs != 2);
736 args->in_numargs = 3;
737 args->in_args[2].size = security_ctxlen;
738 args->in_args[2].value = security_ctx;
741 err = fuse_simple_request(fm, args);
744 goto out_put_forget_req;
747 if (invalid_nodeid(outarg.nodeid) || fuse_invalid_attr(&outarg.attr))
748 goto out_put_forget_req;
750 if ((outarg.attr.mode ^ mode) & S_IFMT)
751 goto out_put_forget_req;
753 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
754 &outarg.attr, entry_attr_timeout(&outarg), 0);
756 fuse_queue_forget(fm->fc, forget, outarg.nodeid, 1);
762 d = d_splice_alias(inode, entry);
767 fuse_change_entry_timeout(d, &outarg);
770 fuse_change_entry_timeout(entry, &outarg);
772 fuse_dir_changed(dir);
780 static int fuse_mknod(struct user_namespace *mnt_userns, struct inode *dir,
781 struct dentry *entry, umode_t mode, dev_t rdev)
783 struct fuse_mknod_in inarg;
784 struct fuse_mount *fm = get_fuse_mount(dir);
787 if (!fm->fc->dont_mask)
788 mode &= ~current_umask();
790 memset(&inarg, 0, sizeof(inarg));
792 inarg.rdev = new_encode_dev(rdev);
793 inarg.umask = current_umask();
794 args.opcode = FUSE_MKNOD;
796 args.in_args[0].size = sizeof(inarg);
797 args.in_args[0].value = &inarg;
798 args.in_args[1].size = entry->d_name.len + 1;
799 args.in_args[1].value = entry->d_name.name;
800 return create_new_entry(fm, &args, dir, entry, mode);
803 static int fuse_create(struct user_namespace *mnt_userns, struct inode *dir,
804 struct dentry *entry, umode_t mode, bool excl)
806 return fuse_mknod(&init_user_ns, dir, entry, mode, 0);
809 static int fuse_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
810 struct file *file, umode_t mode)
812 struct fuse_conn *fc = get_fuse_conn(dir);
818 err = fuse_create_open(dir, file->f_path.dentry, file, file->f_flags, mode, FUSE_TMPFILE);
819 if (err == -ENOSYS) {
826 static int fuse_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
827 struct dentry *entry, umode_t mode)
829 struct fuse_mkdir_in inarg;
830 struct fuse_mount *fm = get_fuse_mount(dir);
833 if (!fm->fc->dont_mask)
834 mode &= ~current_umask();
836 memset(&inarg, 0, sizeof(inarg));
838 inarg.umask = current_umask();
839 args.opcode = FUSE_MKDIR;
841 args.in_args[0].size = sizeof(inarg);
842 args.in_args[0].value = &inarg;
843 args.in_args[1].size = entry->d_name.len + 1;
844 args.in_args[1].value = entry->d_name.name;
845 return create_new_entry(fm, &args, dir, entry, S_IFDIR);
848 static int fuse_symlink(struct user_namespace *mnt_userns, struct inode *dir,
849 struct dentry *entry, const char *link)
851 struct fuse_mount *fm = get_fuse_mount(dir);
852 unsigned len = strlen(link) + 1;
855 args.opcode = FUSE_SYMLINK;
857 args.in_args[0].size = entry->d_name.len + 1;
858 args.in_args[0].value = entry->d_name.name;
859 args.in_args[1].size = len;
860 args.in_args[1].value = link;
861 return create_new_entry(fm, &args, dir, entry, S_IFLNK);
864 void fuse_flush_time_update(struct inode *inode)
866 int err = sync_inode_metadata(inode, 1);
868 mapping_set_error(inode->i_mapping, err);
871 static void fuse_update_ctime_in_cache(struct inode *inode)
873 if (!IS_NOCMTIME(inode)) {
874 inode->i_ctime = current_time(inode);
875 mark_inode_dirty_sync(inode);
876 fuse_flush_time_update(inode);
880 void fuse_update_ctime(struct inode *inode)
882 fuse_invalidate_attr_mask(inode, STATX_CTIME);
883 fuse_update_ctime_in_cache(inode);
886 static void fuse_entry_unlinked(struct dentry *entry)
888 struct inode *inode = d_inode(entry);
889 struct fuse_conn *fc = get_fuse_conn(inode);
890 struct fuse_inode *fi = get_fuse_inode(inode);
892 spin_lock(&fi->lock);
893 fi->attr_version = atomic64_inc_return(&fc->attr_version);
895 * If i_nlink == 0 then unlink doesn't make sense, yet this can
896 * happen if userspace filesystem is careless. It would be
897 * difficult to enforce correct nlink usage so just ignore this
900 if (S_ISDIR(inode->i_mode))
902 else if (inode->i_nlink > 0)
904 spin_unlock(&fi->lock);
905 fuse_invalidate_entry_cache(entry);
906 fuse_update_ctime(inode);
909 static int fuse_unlink(struct inode *dir, struct dentry *entry)
912 struct fuse_mount *fm = get_fuse_mount(dir);
915 if (fuse_is_bad(dir))
918 args.opcode = FUSE_UNLINK;
919 args.nodeid = get_node_id(dir);
921 args.in_args[0].size = entry->d_name.len + 1;
922 args.in_args[0].value = entry->d_name.name;
923 err = fuse_simple_request(fm, &args);
925 fuse_dir_changed(dir);
926 fuse_entry_unlinked(entry);
927 } else if (err == -EINTR)
928 fuse_invalidate_entry(entry);
932 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
935 struct fuse_mount *fm = get_fuse_mount(dir);
938 if (fuse_is_bad(dir))
941 args.opcode = FUSE_RMDIR;
942 args.nodeid = get_node_id(dir);
944 args.in_args[0].size = entry->d_name.len + 1;
945 args.in_args[0].value = entry->d_name.name;
946 err = fuse_simple_request(fm, &args);
948 fuse_dir_changed(dir);
949 fuse_entry_unlinked(entry);
950 } else if (err == -EINTR)
951 fuse_invalidate_entry(entry);
955 static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
956 struct inode *newdir, struct dentry *newent,
957 unsigned int flags, int opcode, size_t argsize)
960 struct fuse_rename2_in inarg;
961 struct fuse_mount *fm = get_fuse_mount(olddir);
964 memset(&inarg, 0, argsize);
965 inarg.newdir = get_node_id(newdir);
967 args.opcode = opcode;
968 args.nodeid = get_node_id(olddir);
970 args.in_args[0].size = argsize;
971 args.in_args[0].value = &inarg;
972 args.in_args[1].size = oldent->d_name.len + 1;
973 args.in_args[1].value = oldent->d_name.name;
974 args.in_args[2].size = newent->d_name.len + 1;
975 args.in_args[2].value = newent->d_name.name;
976 err = fuse_simple_request(fm, &args);
979 fuse_update_ctime(d_inode(oldent));
981 if (flags & RENAME_EXCHANGE)
982 fuse_update_ctime(d_inode(newent));
984 fuse_dir_changed(olddir);
985 if (olddir != newdir)
986 fuse_dir_changed(newdir);
988 /* newent will end up negative */
989 if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent))
990 fuse_entry_unlinked(newent);
991 } else if (err == -EINTR) {
992 /* If request was interrupted, DEITY only knows if the
993 rename actually took place. If the invalidation
994 fails (e.g. some process has CWD under the renamed
995 directory), then there can be inconsistency between
996 the dcache and the real filesystem. Tough luck. */
997 fuse_invalidate_entry(oldent);
998 if (d_really_is_positive(newent))
999 fuse_invalidate_entry(newent);
1005 static int fuse_rename2(struct user_namespace *mnt_userns, struct inode *olddir,
1006 struct dentry *oldent, struct inode *newdir,
1007 struct dentry *newent, unsigned int flags)
1009 struct fuse_conn *fc = get_fuse_conn(olddir);
1012 if (fuse_is_bad(olddir))
1015 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
1019 if (fc->no_rename2 || fc->minor < 23)
1022 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
1024 sizeof(struct fuse_rename2_in));
1025 if (err == -ENOSYS) {
1030 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
1032 sizeof(struct fuse_rename_in));
1038 static int fuse_link(struct dentry *entry, struct inode *newdir,
1039 struct dentry *newent)
1042 struct fuse_link_in inarg;
1043 struct inode *inode = d_inode(entry);
1044 struct fuse_mount *fm = get_fuse_mount(inode);
1047 memset(&inarg, 0, sizeof(inarg));
1048 inarg.oldnodeid = get_node_id(inode);
1049 args.opcode = FUSE_LINK;
1050 args.in_numargs = 2;
1051 args.in_args[0].size = sizeof(inarg);
1052 args.in_args[0].value = &inarg;
1053 args.in_args[1].size = newent->d_name.len + 1;
1054 args.in_args[1].value = newent->d_name.name;
1055 err = create_new_entry(fm, &args, newdir, newent, inode->i_mode);
1057 fuse_update_ctime_in_cache(inode);
1058 else if (err == -EINTR)
1059 fuse_invalidate_attr(inode);
1064 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
1067 unsigned int blkbits;
1068 struct fuse_conn *fc = get_fuse_conn(inode);
1070 stat->dev = inode->i_sb->s_dev;
1071 stat->ino = attr->ino;
1072 stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
1073 stat->nlink = attr->nlink;
1074 stat->uid = make_kuid(fc->user_ns, attr->uid);
1075 stat->gid = make_kgid(fc->user_ns, attr->gid);
1076 stat->rdev = inode->i_rdev;
1077 stat->atime.tv_sec = attr->atime;
1078 stat->atime.tv_nsec = attr->atimensec;
1079 stat->mtime.tv_sec = attr->mtime;
1080 stat->mtime.tv_nsec = attr->mtimensec;
1081 stat->ctime.tv_sec = attr->ctime;
1082 stat->ctime.tv_nsec = attr->ctimensec;
1083 stat->size = attr->size;
1084 stat->blocks = attr->blocks;
1086 if (attr->blksize != 0)
1087 blkbits = ilog2(attr->blksize);
1089 blkbits = inode->i_sb->s_blocksize_bits;
1091 stat->blksize = 1 << blkbits;
1094 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
1098 struct fuse_getattr_in inarg;
1099 struct fuse_attr_out outarg;
1100 struct fuse_mount *fm = get_fuse_mount(inode);
1104 attr_version = fuse_get_attr_version(fm->fc);
1106 memset(&inarg, 0, sizeof(inarg));
1107 memset(&outarg, 0, sizeof(outarg));
1108 /* Directories have separate file-handle space */
1109 if (file && S_ISREG(inode->i_mode)) {
1110 struct fuse_file *ff = file->private_data;
1112 inarg.getattr_flags |= FUSE_GETATTR_FH;
1115 args.opcode = FUSE_GETATTR;
1116 args.nodeid = get_node_id(inode);
1117 args.in_numargs = 1;
1118 args.in_args[0].size = sizeof(inarg);
1119 args.in_args[0].value = &inarg;
1120 args.out_numargs = 1;
1121 args.out_args[0].size = sizeof(outarg);
1122 args.out_args[0].value = &outarg;
1123 err = fuse_simple_request(fm, &args);
1125 if (fuse_invalid_attr(&outarg.attr) ||
1126 inode_wrong_type(inode, outarg.attr.mode)) {
1127 fuse_make_bad(inode);
1130 fuse_change_attributes(inode, &outarg.attr,
1131 attr_timeout(&outarg),
1134 fuse_fillattr(inode, &outarg.attr, stat);
1140 static int fuse_update_get_attr(struct inode *inode, struct file *file,
1141 struct kstat *stat, u32 request_mask,
1144 struct fuse_inode *fi = get_fuse_inode(inode);
1147 u32 inval_mask = READ_ONCE(fi->inval_mask);
1148 u32 cache_mask = fuse_get_cache_mask(inode);
1150 if (flags & AT_STATX_FORCE_SYNC)
1152 else if (flags & AT_STATX_DONT_SYNC)
1154 else if (request_mask & inval_mask & ~cache_mask)
1157 sync = time_before64(fi->i_time, get_jiffies_64());
1160 forget_all_cached_acls(inode);
1161 err = fuse_do_getattr(inode, stat, file);
1163 generic_fillattr(&init_user_ns, inode, stat);
1164 stat->mode = fi->orig_i_mode;
1165 stat->ino = fi->orig_ino;
1171 int fuse_update_attributes(struct inode *inode, struct file *file, u32 mask)
1173 return fuse_update_get_attr(inode, file, NULL, mask, 0);
1176 int fuse_reverse_inval_entry(struct fuse_conn *fc, u64 parent_nodeid,
1177 u64 child_nodeid, struct qstr *name)
1180 struct inode *parent;
1182 struct dentry *entry;
1184 parent = fuse_ilookup(fc, parent_nodeid, NULL);
1188 inode_lock_nested(parent, I_MUTEX_PARENT);
1189 if (!S_ISDIR(parent->i_mode))
1193 dir = d_find_alias(parent);
1197 name->hash = full_name_hash(dir, name->name, name->len);
1198 entry = d_lookup(dir, name);
1203 fuse_dir_changed(parent);
1204 fuse_invalidate_entry(entry);
1206 if (child_nodeid != 0 && d_really_is_positive(entry)) {
1207 inode_lock(d_inode(entry));
1208 if (get_node_id(d_inode(entry)) != child_nodeid) {
1212 if (d_mountpoint(entry)) {
1216 if (d_is_dir(entry)) {
1217 shrink_dcache_parent(entry);
1218 if (!simple_empty(entry)) {
1222 d_inode(entry)->i_flags |= S_DEAD;
1225 clear_nlink(d_inode(entry));
1228 inode_unlock(d_inode(entry));
1237 inode_unlock(parent);
1243 * Calling into a user-controlled filesystem gives the filesystem
1244 * daemon ptrace-like capabilities over the current process. This
1245 * means, that the filesystem daemon is able to record the exact
1246 * filesystem operations performed, and can also control the behavior
1247 * of the requester process in otherwise impossible ways. For example
1248 * it can delay the operation for arbitrary length of time allowing
1249 * DoS against the requester.
1251 * For this reason only those processes can call into the filesystem,
1252 * for which the owner of the mount has ptrace privilege. This
1253 * excludes processes started by other users, suid or sgid processes.
1255 int fuse_allow_current_process(struct fuse_conn *fc)
1257 const struct cred *cred;
1259 if (allow_sys_admin_access && capable(CAP_SYS_ADMIN))
1262 if (fc->allow_other)
1263 return current_in_userns(fc->user_ns);
1265 cred = current_cred();
1266 if (uid_eq(cred->euid, fc->user_id) &&
1267 uid_eq(cred->suid, fc->user_id) &&
1268 uid_eq(cred->uid, fc->user_id) &&
1269 gid_eq(cred->egid, fc->group_id) &&
1270 gid_eq(cred->sgid, fc->group_id) &&
1271 gid_eq(cred->gid, fc->group_id))
1277 static int fuse_access(struct inode *inode, int mask)
1279 struct fuse_mount *fm = get_fuse_mount(inode);
1281 struct fuse_access_in inarg;
1284 BUG_ON(mask & MAY_NOT_BLOCK);
1286 if (fm->fc->no_access)
1289 memset(&inarg, 0, sizeof(inarg));
1290 inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1291 args.opcode = FUSE_ACCESS;
1292 args.nodeid = get_node_id(inode);
1293 args.in_numargs = 1;
1294 args.in_args[0].size = sizeof(inarg);
1295 args.in_args[0].value = &inarg;
1296 err = fuse_simple_request(fm, &args);
1297 if (err == -ENOSYS) {
1298 fm->fc->no_access = 1;
1304 static int fuse_perm_getattr(struct inode *inode, int mask)
1306 if (mask & MAY_NOT_BLOCK)
1309 forget_all_cached_acls(inode);
1310 return fuse_do_getattr(inode, NULL, NULL);
1314 * Check permission. The two basic access models of FUSE are:
1316 * 1) Local access checking ('default_permissions' mount option) based
1317 * on file mode. This is the plain old disk filesystem permission
1320 * 2) "Remote" access checking, where server is responsible for
1321 * checking permission in each inode operation. An exception to this
1322 * is if ->permission() was invoked from sys_access() in which case an
1323 * access request is sent. Execute permission is still checked
1324 * locally based on file mode.
1326 static int fuse_permission(struct user_namespace *mnt_userns,
1327 struct inode *inode, int mask)
1329 struct fuse_conn *fc = get_fuse_conn(inode);
1330 bool refreshed = false;
1333 if (fuse_is_bad(inode))
1336 if (!fuse_allow_current_process(fc))
1340 * If attributes are needed, refresh them before proceeding
1342 if (fc->default_permissions ||
1343 ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1344 struct fuse_inode *fi = get_fuse_inode(inode);
1345 u32 perm_mask = STATX_MODE | STATX_UID | STATX_GID;
1347 if (perm_mask & READ_ONCE(fi->inval_mask) ||
1348 time_before64(fi->i_time, get_jiffies_64())) {
1351 err = fuse_perm_getattr(inode, mask);
1357 if (fc->default_permissions) {
1358 err = generic_permission(&init_user_ns, inode, mask);
1360 /* If permission is denied, try to refresh file
1361 attributes. This is also needed, because the root
1362 node will at first have no permissions */
1363 if (err == -EACCES && !refreshed) {
1364 err = fuse_perm_getattr(inode, mask);
1366 err = generic_permission(&init_user_ns,
1370 /* Note: the opposite of the above test does not
1371 exist. So if permissions are revoked this won't be
1372 noticed immediately, only after the attribute
1373 timeout has expired */
1374 } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1375 err = fuse_access(inode, mask);
1376 } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1377 if (!(inode->i_mode & S_IXUGO)) {
1381 err = fuse_perm_getattr(inode, mask);
1382 if (!err && !(inode->i_mode & S_IXUGO))
1389 static int fuse_readlink_page(struct inode *inode, struct page *page)
1391 struct fuse_mount *fm = get_fuse_mount(inode);
1392 struct fuse_page_desc desc = { .length = PAGE_SIZE - 1 };
1393 struct fuse_args_pages ap = {
1401 ap.args.opcode = FUSE_READLINK;
1402 ap.args.nodeid = get_node_id(inode);
1403 ap.args.out_pages = true;
1404 ap.args.out_argvar = true;
1405 ap.args.page_zeroing = true;
1406 ap.args.out_numargs = 1;
1407 ap.args.out_args[0].size = desc.length;
1408 res = fuse_simple_request(fm, &ap.args);
1410 fuse_invalidate_atime(inode);
1415 if (WARN_ON(res >= PAGE_SIZE))
1418 link = page_address(page);
1424 static const char *fuse_get_link(struct dentry *dentry, struct inode *inode,
1425 struct delayed_call *callback)
1427 struct fuse_conn *fc = get_fuse_conn(inode);
1432 if (fuse_is_bad(inode))
1435 if (fc->cache_symlinks)
1436 return page_get_link(dentry, inode, callback);
1442 page = alloc_page(GFP_KERNEL);
1447 err = fuse_readlink_page(inode, page);
1453 set_delayed_call(callback, page_put_link, page);
1455 return page_address(page);
1458 return ERR_PTR(err);
1461 static int fuse_dir_open(struct inode *inode, struct file *file)
1463 return fuse_open_common(inode, file, true);
1466 static int fuse_dir_release(struct inode *inode, struct file *file)
1468 fuse_release_common(file, true);
1473 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1476 struct inode *inode = file->f_mapping->host;
1477 struct fuse_conn *fc = get_fuse_conn(inode);
1480 if (fuse_is_bad(inode))
1483 if (fc->no_fsyncdir)
1487 err = fuse_fsync_common(file, start, end, datasync, FUSE_FSYNCDIR);
1488 if (err == -ENOSYS) {
1489 fc->no_fsyncdir = 1;
1492 inode_unlock(inode);
1497 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1500 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1502 /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1506 return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1509 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1512 struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1517 return fuse_ioctl_common(file, cmd, arg,
1518 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1521 static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
1523 /* Always update if mtime is explicitly set */
1524 if (ivalid & ATTR_MTIME_SET)
1527 /* Or if kernel i_mtime is the official one */
1528 if (trust_local_mtime)
1531 /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1532 if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1535 /* In all other cases update */
1539 static void iattr_to_fattr(struct fuse_conn *fc, struct iattr *iattr,
1540 struct fuse_setattr_in *arg, bool trust_local_cmtime)
1542 unsigned ivalid = iattr->ia_valid;
1544 if (ivalid & ATTR_MODE)
1545 arg->valid |= FATTR_MODE, arg->mode = iattr->ia_mode;
1546 if (ivalid & ATTR_UID)
1547 arg->valid |= FATTR_UID, arg->uid = from_kuid(fc->user_ns, iattr->ia_uid);
1548 if (ivalid & ATTR_GID)
1549 arg->valid |= FATTR_GID, arg->gid = from_kgid(fc->user_ns, iattr->ia_gid);
1550 if (ivalid & ATTR_SIZE)
1551 arg->valid |= FATTR_SIZE, arg->size = iattr->ia_size;
1552 if (ivalid & ATTR_ATIME) {
1553 arg->valid |= FATTR_ATIME;
1554 arg->atime = iattr->ia_atime.tv_sec;
1555 arg->atimensec = iattr->ia_atime.tv_nsec;
1556 if (!(ivalid & ATTR_ATIME_SET))
1557 arg->valid |= FATTR_ATIME_NOW;
1559 if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
1560 arg->valid |= FATTR_MTIME;
1561 arg->mtime = iattr->ia_mtime.tv_sec;
1562 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1563 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
1564 arg->valid |= FATTR_MTIME_NOW;
1566 if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1567 arg->valid |= FATTR_CTIME;
1568 arg->ctime = iattr->ia_ctime.tv_sec;
1569 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1574 * Prevent concurrent writepages on inode
1576 * This is done by adding a negative bias to the inode write counter
1577 * and waiting for all pending writes to finish.
1579 void fuse_set_nowrite(struct inode *inode)
1581 struct fuse_inode *fi = get_fuse_inode(inode);
1583 BUG_ON(!inode_is_locked(inode));
1585 spin_lock(&fi->lock);
1586 BUG_ON(fi->writectr < 0);
1587 fi->writectr += FUSE_NOWRITE;
1588 spin_unlock(&fi->lock);
1589 wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1593 * Allow writepages on inode
1595 * Remove the bias from the writecounter and send any queued
1598 static void __fuse_release_nowrite(struct inode *inode)
1600 struct fuse_inode *fi = get_fuse_inode(inode);
1602 BUG_ON(fi->writectr != FUSE_NOWRITE);
1604 fuse_flush_writepages(inode);
1607 void fuse_release_nowrite(struct inode *inode)
1609 struct fuse_inode *fi = get_fuse_inode(inode);
1611 spin_lock(&fi->lock);
1612 __fuse_release_nowrite(inode);
1613 spin_unlock(&fi->lock);
1616 static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_args *args,
1617 struct inode *inode,
1618 struct fuse_setattr_in *inarg_p,
1619 struct fuse_attr_out *outarg_p)
1621 args->opcode = FUSE_SETATTR;
1622 args->nodeid = get_node_id(inode);
1623 args->in_numargs = 1;
1624 args->in_args[0].size = sizeof(*inarg_p);
1625 args->in_args[0].value = inarg_p;
1626 args->out_numargs = 1;
1627 args->out_args[0].size = sizeof(*outarg_p);
1628 args->out_args[0].value = outarg_p;
1632 * Flush inode->i_mtime to the server
1634 int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
1636 struct fuse_mount *fm = get_fuse_mount(inode);
1638 struct fuse_setattr_in inarg;
1639 struct fuse_attr_out outarg;
1641 memset(&inarg, 0, sizeof(inarg));
1642 memset(&outarg, 0, sizeof(outarg));
1644 inarg.valid = FATTR_MTIME;
1645 inarg.mtime = inode->i_mtime.tv_sec;
1646 inarg.mtimensec = inode->i_mtime.tv_nsec;
1647 if (fm->fc->minor >= 23) {
1648 inarg.valid |= FATTR_CTIME;
1649 inarg.ctime = inode->i_ctime.tv_sec;
1650 inarg.ctimensec = inode->i_ctime.tv_nsec;
1653 inarg.valid |= FATTR_FH;
1656 fuse_setattr_fill(fm->fc, &args, inode, &inarg, &outarg);
1658 return fuse_simple_request(fm, &args);
1662 * Set attributes, and at the same time refresh them.
1664 * Truncation is slightly complicated, because the 'truncate' request
1665 * may fail, in which case we don't want to touch the mapping.
1666 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1667 * and the actual truncation by hand.
1669 int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
1672 struct inode *inode = d_inode(dentry);
1673 struct fuse_mount *fm = get_fuse_mount(inode);
1674 struct fuse_conn *fc = fm->fc;
1675 struct fuse_inode *fi = get_fuse_inode(inode);
1676 struct address_space *mapping = inode->i_mapping;
1678 struct fuse_setattr_in inarg;
1679 struct fuse_attr_out outarg;
1680 bool is_truncate = false;
1681 bool is_wb = fc->writeback_cache && S_ISREG(inode->i_mode);
1684 bool trust_local_cmtime = is_wb;
1685 bool fault_blocked = false;
1687 if (!fc->default_permissions)
1688 attr->ia_valid |= ATTR_FORCE;
1690 err = setattr_prepare(&init_user_ns, dentry, attr);
1694 if (attr->ia_valid & ATTR_SIZE) {
1695 if (WARN_ON(!S_ISREG(inode->i_mode)))
1700 if (FUSE_IS_DAX(inode) && is_truncate) {
1701 filemap_invalidate_lock(mapping);
1702 fault_blocked = true;
1703 err = fuse_dax_break_layouts(inode, 0, 0);
1705 filemap_invalidate_unlock(mapping);
1710 if (attr->ia_valid & ATTR_OPEN) {
1711 /* This is coming from open(..., ... | O_TRUNC); */
1712 WARN_ON(!(attr->ia_valid & ATTR_SIZE));
1713 WARN_ON(attr->ia_size != 0);
1714 if (fc->atomic_o_trunc) {
1716 * No need to send request to userspace, since actual
1717 * truncation has already been done by OPEN. But still
1718 * need to truncate page cache.
1720 i_size_write(inode, 0);
1721 truncate_pagecache(inode, 0);
1727 /* Flush dirty data/metadata before non-truncate SETATTR */
1730 (ATTR_MODE | ATTR_UID | ATTR_GID | ATTR_MTIME_SET |
1732 err = write_inode_now(inode, true);
1736 fuse_set_nowrite(inode);
1737 fuse_release_nowrite(inode);
1741 fuse_set_nowrite(inode);
1742 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1743 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1744 attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
1747 memset(&inarg, 0, sizeof(inarg));
1748 memset(&outarg, 0, sizeof(outarg));
1749 iattr_to_fattr(fc, attr, &inarg, trust_local_cmtime);
1751 struct fuse_file *ff = file->private_data;
1752 inarg.valid |= FATTR_FH;
1756 /* Kill suid/sgid for non-directory chown unconditionally */
1757 if (fc->handle_killpriv_v2 && !S_ISDIR(inode->i_mode) &&
1758 attr->ia_valid & (ATTR_UID | ATTR_GID))
1759 inarg.valid |= FATTR_KILL_SUIDGID;
1761 if (attr->ia_valid & ATTR_SIZE) {
1762 /* For mandatory locking in truncate */
1763 inarg.valid |= FATTR_LOCKOWNER;
1764 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1766 /* Kill suid/sgid for truncate only if no CAP_FSETID */
1767 if (fc->handle_killpriv_v2 && !capable(CAP_FSETID))
1768 inarg.valid |= FATTR_KILL_SUIDGID;
1770 fuse_setattr_fill(fc, &args, inode, &inarg, &outarg);
1771 err = fuse_simple_request(fm, &args);
1774 fuse_invalidate_attr(inode);
1778 if (fuse_invalid_attr(&outarg.attr) ||
1779 inode_wrong_type(inode, outarg.attr.mode)) {
1780 fuse_make_bad(inode);
1785 spin_lock(&fi->lock);
1786 /* the kernel maintains i_mtime locally */
1787 if (trust_local_cmtime) {
1788 if (attr->ia_valid & ATTR_MTIME)
1789 inode->i_mtime = attr->ia_mtime;
1790 if (attr->ia_valid & ATTR_CTIME)
1791 inode->i_ctime = attr->ia_ctime;
1792 /* FIXME: clear I_DIRTY_SYNC? */
1795 fuse_change_attributes_common(inode, &outarg.attr,
1796 attr_timeout(&outarg),
1797 fuse_get_cache_mask(inode));
1798 oldsize = inode->i_size;
1799 /* see the comment in fuse_change_attributes() */
1800 if (!is_wb || is_truncate)
1801 i_size_write(inode, outarg.attr.size);
1804 /* NOTE: this may release/reacquire fi->lock */
1805 __fuse_release_nowrite(inode);
1807 spin_unlock(&fi->lock);
1810 * Only call invalidate_inode_pages2() after removing
1811 * FUSE_NOWRITE, otherwise fuse_launder_folio() would deadlock.
1813 if ((is_truncate || !is_wb) &&
1814 S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1815 truncate_pagecache(inode, outarg.attr.size);
1816 invalidate_inode_pages2(mapping);
1819 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1822 filemap_invalidate_unlock(mapping);
1828 fuse_release_nowrite(inode);
1830 clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1833 filemap_invalidate_unlock(mapping);
1837 static int fuse_setattr(struct user_namespace *mnt_userns, struct dentry *entry,
1840 struct inode *inode = d_inode(entry);
1841 struct fuse_conn *fc = get_fuse_conn(inode);
1842 struct file *file = (attr->ia_valid & ATTR_FILE) ? attr->ia_file : NULL;
1845 if (fuse_is_bad(inode))
1848 if (!fuse_allow_current_process(get_fuse_conn(inode)))
1851 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) {
1852 attr->ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID |
1856 * The only sane way to reliably kill suid/sgid is to do it in
1857 * the userspace filesystem
1859 * This should be done on write(), truncate() and chown().
1861 if (!fc->handle_killpriv && !fc->handle_killpriv_v2) {
1863 * ia_mode calculation may have used stale i_mode.
1864 * Refresh and recalculate.
1866 ret = fuse_do_getattr(inode, NULL, file);
1870 attr->ia_mode = inode->i_mode;
1871 if (inode->i_mode & S_ISUID) {
1872 attr->ia_valid |= ATTR_MODE;
1873 attr->ia_mode &= ~S_ISUID;
1875 if ((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
1876 attr->ia_valid |= ATTR_MODE;
1877 attr->ia_mode &= ~S_ISGID;
1881 if (!attr->ia_valid)
1884 ret = fuse_do_setattr(entry, attr, file);
1887 * If filesystem supports acls it may have updated acl xattrs in
1888 * the filesystem, so forget cached acls for the inode.
1891 forget_all_cached_acls(inode);
1893 /* Directory mode changed, may need to revalidate access */
1894 if (d_is_dir(entry) && (attr->ia_valid & ATTR_MODE))
1895 fuse_invalidate_entry_cache(entry);
1900 static int fuse_getattr(struct user_namespace *mnt_userns,
1901 const struct path *path, struct kstat *stat,
1902 u32 request_mask, unsigned int flags)
1904 struct inode *inode = d_inode(path->dentry);
1905 struct fuse_conn *fc = get_fuse_conn(inode);
1907 if (fuse_is_bad(inode))
1910 if (!fuse_allow_current_process(fc)) {
1911 if (!request_mask) {
1913 * If user explicitly requested *nothing* then don't
1914 * error out, but return st_dev only.
1916 stat->result_mask = 0;
1917 stat->dev = inode->i_sb->s_dev;
1923 return fuse_update_get_attr(inode, NULL, stat, request_mask, flags);
1926 static const struct inode_operations fuse_dir_inode_operations = {
1927 .lookup = fuse_lookup,
1928 .mkdir = fuse_mkdir,
1929 .symlink = fuse_symlink,
1930 .unlink = fuse_unlink,
1931 .rmdir = fuse_rmdir,
1932 .rename = fuse_rename2,
1934 .setattr = fuse_setattr,
1935 .create = fuse_create,
1936 .atomic_open = fuse_atomic_open,
1937 .tmpfile = fuse_tmpfile,
1938 .mknod = fuse_mknod,
1939 .permission = fuse_permission,
1940 .getattr = fuse_getattr,
1941 .listxattr = fuse_listxattr,
1942 .get_acl = fuse_get_acl,
1943 .set_acl = fuse_set_acl,
1944 .fileattr_get = fuse_fileattr_get,
1945 .fileattr_set = fuse_fileattr_set,
1948 static const struct file_operations fuse_dir_operations = {
1949 .llseek = generic_file_llseek,
1950 .read = generic_read_dir,
1951 .iterate_shared = fuse_readdir,
1952 .open = fuse_dir_open,
1953 .release = fuse_dir_release,
1954 .fsync = fuse_dir_fsync,
1955 .unlocked_ioctl = fuse_dir_ioctl,
1956 .compat_ioctl = fuse_dir_compat_ioctl,
1959 static const struct inode_operations fuse_common_inode_operations = {
1960 .setattr = fuse_setattr,
1961 .permission = fuse_permission,
1962 .getattr = fuse_getattr,
1963 .listxattr = fuse_listxattr,
1964 .get_acl = fuse_get_acl,
1965 .set_acl = fuse_set_acl,
1966 .fileattr_get = fuse_fileattr_get,
1967 .fileattr_set = fuse_fileattr_set,
1970 static const struct inode_operations fuse_symlink_inode_operations = {
1971 .setattr = fuse_setattr,
1972 .get_link = fuse_get_link,
1973 .getattr = fuse_getattr,
1974 .listxattr = fuse_listxattr,
1977 void fuse_init_common(struct inode *inode)
1979 inode->i_op = &fuse_common_inode_operations;
1982 void fuse_init_dir(struct inode *inode)
1984 struct fuse_inode *fi = get_fuse_inode(inode);
1986 inode->i_op = &fuse_dir_inode_operations;
1987 inode->i_fop = &fuse_dir_operations;
1989 spin_lock_init(&fi->rdc.lock);
1990 fi->rdc.cached = false;
1993 fi->rdc.version = 0;
1996 static int fuse_symlink_read_folio(struct file *null, struct folio *folio)
1998 int err = fuse_readlink_page(folio->mapping->host, &folio->page);
2001 folio_mark_uptodate(folio);
2003 folio_unlock(folio);
2008 static const struct address_space_operations fuse_symlink_aops = {
2009 .read_folio = fuse_symlink_read_folio,
2012 void fuse_init_symlink(struct inode *inode)
2014 inode->i_op = &fuse_symlink_inode_operations;
2015 inode->i_data.a_ops = &fuse_symlink_aops;
2016 inode_nohighmem(inode);