Commit f7fccaa7 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'fuse-update-6.12' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse 

Pull fuse updates from Miklos Szeredi:

 - Add support for idmapped fuse mounts (Alexander Mikhalitsyn)

 - Add optimization when checking for writeback (yangyun)

 - Add tracepoints (Josef Bacik)

 - Clean up writeback code (Joanne Koong)

 - Clean up request queuing (me)

 - Misc fixes

* tag 'fuse-update-6.12' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse: (32 commits)
  fuse: use exclusive lock when FUSE_I_CACHE_IO_MODE is set
  fuse: clear FR_PENDING if abort is detected when sending request
  fs/fuse: convert to use invalid_mnt_idmap
  fs/mnt_idmapping: introduce an invalid_mnt_idmap
  fs/fuse: introduce and use fuse_simple_idmap_request() helper
  fs/fuse: fix null-ptr-deref when checking SB_I_NOIDMAP flag
  fuse: allow O_PATH fd for FUSE_DEV_IOC_BACKING_OPEN
  virtio_fs: allow idmapped mounts
  fuse: allow idmapped mounts
  fuse: warn if fuse_access is called when idmapped mounts are allowed
  fuse: handle idmappings properly in ->write_iter()
  fuse: support idmapped ->rename op
  fuse: support idmapped ->set_acl
  fuse: drop idmap argument from __fuse_get_acl
  fuse: support idmapped ->setattr op
  fuse: support idmapped ->permission inode op
  fuse: support idmapped getattr inode op
  fuse: support idmap for mkdir/mknod/symlink/create/tmpfile
  fuse: support idmapped FUSE_EXT_GROUPS
  fuse: add an idmap argument to fuse_simple_request
  ...
parents 4165cee7 2f3d8ff4

fs/fuse/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -3,6 +3,9 @@ 
# Makefile for the FUSE filesystem.

#



# Needed for trace events

ccflags-y = -I$(src)



obj-$(CONFIG_FUSE_FS) += fuse.o

obj-$(CONFIG_CUSE) += cuse.o

obj-$(CONFIG_VIRTIO_FS) += virtiofs.o

fs/fuse/acl.c

+4 −6
Original line number Diff line number Diff line
@@ -12,7 +12,6 @@ 
#include <linux/posix_acl_xattr.h>



static struct posix_acl *__fuse_get_acl(struct fuse_conn *fc,

					struct mnt_idmap *idmap,

					struct inode *inode, int type, bool rcu)

{

	int size;
@@ -74,7 +73,7 @@ struct posix_acl *fuse_get_acl(struct mnt_idmap *idmap, 
	if (fuse_no_acl(fc, inode))

		return ERR_PTR(-EOPNOTSUPP);



	return __fuse_get_acl(fc, idmap, inode, type, false);

	return __fuse_get_acl(fc, inode, type, false);

}



struct posix_acl *fuse_get_inode_acl(struct inode *inode, int type, bool rcu)
@@ -90,8 +89,7 @@ struct posix_acl *fuse_get_inode_acl(struct inode *inode, int type, bool rcu) 
	 */

	if (!fc->posix_acl)

		return NULL;



	return __fuse_get_acl(fc, &nop_mnt_idmap, inode, type, rcu);

	return __fuse_get_acl(fc,  inode, type, rcu);

}



int fuse_set_acl(struct mnt_idmap *idmap, struct dentry *dentry,
@@ -146,8 +144,8 @@ int fuse_set_acl(struct mnt_idmap *idmap, struct dentry *dentry, 
		 * be stripped.

		 */

		if (fc->posix_acl &&

		    !in_group_or_capable(&nop_mnt_idmap, inode,

					 i_gid_into_vfsgid(&nop_mnt_idmap, inode)))

		    !in_group_or_capable(idmap, inode,

					 i_gid_into_vfsgid(idmap, inode)))

			extra_flags |= FUSE_SETXATTR_ACL_KILL_SGID;



		ret = fuse_setxattr(inode, name, value, size, 0, extra_flags);

fs/fuse/dev.c

+131 −83
Original line number Diff line number Diff line
@@ -22,6 +22,9 @@ 
#include <linux/splice.h>

#include <linux/sched.h>



#define CREATE_TRACE_POINTS

#include "fuse_trace.h"



MODULE_ALIAS_MISCDEV(FUSE_MINOR);

MODULE_ALIAS("devname:fuse");
@@ -105,11 +108,17 @@ static void fuse_drop_waiting(struct fuse_conn *fc) 


static void fuse_put_request(struct fuse_req *req);



static struct fuse_req *fuse_get_req(struct fuse_mount *fm, bool for_background)

static struct fuse_req *fuse_get_req(struct mnt_idmap *idmap,

				     struct fuse_mount *fm,

				     bool for_background)

{

	struct fuse_conn *fc = fm->fc;

	struct fuse_req *req;

	bool no_idmap = !fm->sb || (fm->sb->s_iflags & SB_I_NOIDMAP);

	kuid_t fsuid;

	kgid_t fsgid;

	int err;



	atomic_inc(&fc->num_waiting);



	if (fuse_block_alloc(fc, for_background)) {
@@ -137,19 +146,32 @@ static struct fuse_req *fuse_get_req(struct fuse_mount *fm, bool for_background) 
		goto out;

	}



	req->in.h.uid = from_kuid(fc->user_ns, current_fsuid());

	req->in.h.gid = from_kgid(fc->user_ns, current_fsgid());

	req->in.h.pid = pid_nr_ns(task_pid(current), fc->pid_ns);



	__set_bit(FR_WAITING, &req->flags);

	if (for_background)

		__set_bit(FR_BACKGROUND, &req->flags);



	if (unlikely(req->in.h.uid == ((uid_t)-1) ||

	/*

	 * Keep the old behavior when idmappings support was not

	 * declared by a FUSE server.

	 *

	 * For those FUSE servers who support idmapped mounts,

	 * we send UID/GID only along with "inode creation"

	 * fuse requests, otherwise idmap == &invalid_mnt_idmap and

	 * req->in.h.{u,g}id will be equal to FUSE_INVALID_UIDGID.

	 */

	fsuid = no_idmap ? current_fsuid() : mapped_fsuid(idmap, fc->user_ns);

	fsgid = no_idmap ? current_fsgid() : mapped_fsgid(idmap, fc->user_ns);

	req->in.h.uid = from_kuid(fc->user_ns, fsuid);

	req->in.h.gid = from_kgid(fc->user_ns, fsgid);



	if (no_idmap && unlikely(req->in.h.uid == ((uid_t)-1) ||

				 req->in.h.gid == ((gid_t)-1))) {

		fuse_put_request(req);

		return ERR_PTR(-EOVERFLOW);

	}



	return req;



 out:
@@ -194,11 +216,22 @@ unsigned int fuse_len_args(unsigned int numargs, struct fuse_arg *args) 
}

EXPORT_SYMBOL_GPL(fuse_len_args);



u64 fuse_get_unique(struct fuse_iqueue *fiq)

static u64 fuse_get_unique_locked(struct fuse_iqueue *fiq)

{

	fiq->reqctr += FUSE_REQ_ID_STEP;

	return fiq->reqctr;

}



u64 fuse_get_unique(struct fuse_iqueue *fiq)

{

	u64 ret;



	spin_lock(&fiq->lock);

	ret = fuse_get_unique_locked(fiq);

	spin_unlock(&fiq->lock);



	return ret;

}

EXPORT_SYMBOL_GPL(fuse_get_unique);



static unsigned int fuse_req_hash(u64 unique)
@@ -217,22 +250,70 @@ __releases(fiq->lock) 
	spin_unlock(&fiq->lock);

}



static void fuse_dev_queue_forget(struct fuse_iqueue *fiq, struct fuse_forget_link *forget)

{

	spin_lock(&fiq->lock);

	if (fiq->connected) {

		fiq->forget_list_tail->next = forget;

		fiq->forget_list_tail = forget;

		fuse_dev_wake_and_unlock(fiq);

	} else {

		kfree(forget);

		spin_unlock(&fiq->lock);

	}

}



static void fuse_dev_queue_interrupt(struct fuse_iqueue *fiq, struct fuse_req *req)

{

	spin_lock(&fiq->lock);

	if (list_empty(&req->intr_entry)) {

		list_add_tail(&req->intr_entry, &fiq->interrupts);

		/*

		 * Pairs with smp_mb() implied by test_and_set_bit()

		 * from fuse_request_end().

		 */

		smp_mb();

		if (test_bit(FR_FINISHED, &req->flags)) {

			list_del_init(&req->intr_entry);

			spin_unlock(&fiq->lock);

		} else  {

			fuse_dev_wake_and_unlock(fiq);

		}

	} else {

		spin_unlock(&fiq->lock);

	}

}



static void fuse_dev_queue_req(struct fuse_iqueue *fiq, struct fuse_req *req)

{

	spin_lock(&fiq->lock);

	if (fiq->connected) {

		if (req->in.h.opcode != FUSE_NOTIFY_REPLY)

			req->in.h.unique = fuse_get_unique_locked(fiq);

		list_add_tail(&req->list, &fiq->pending);

		fuse_dev_wake_and_unlock(fiq);

	} else {

		spin_unlock(&fiq->lock);

		req->out.h.error = -ENOTCONN;

		clear_bit(FR_PENDING, &req->flags);

		fuse_request_end(req);

	}

}



const struct fuse_iqueue_ops fuse_dev_fiq_ops = {

	.wake_forget_and_unlock		= fuse_dev_wake_and_unlock,

	.wake_interrupt_and_unlock	= fuse_dev_wake_and_unlock,

	.wake_pending_and_unlock	= fuse_dev_wake_and_unlock,

	.send_forget	= fuse_dev_queue_forget,

	.send_interrupt	= fuse_dev_queue_interrupt,

	.send_req	= fuse_dev_queue_req,

};

EXPORT_SYMBOL_GPL(fuse_dev_fiq_ops);



static void queue_request_and_unlock(struct fuse_iqueue *fiq,

				     struct fuse_req *req)

__releases(fiq->lock)

static void fuse_send_one(struct fuse_iqueue *fiq, struct fuse_req *req)

{

	req->in.h.len = sizeof(struct fuse_in_header) +

		fuse_len_args(req->args->in_numargs,

			      (struct fuse_arg *) req->args->in_args);

	list_add_tail(&req->list, &fiq->pending);

	fiq->ops->wake_pending_and_unlock(fiq);

	trace_fuse_request_send(req);

	fiq->ops->send_req(fiq, req);

}



void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget,
@@ -243,15 +324,7 @@ void fuse_queue_forget(struct fuse_conn *fc, struct fuse_forget_link *forget, 
	forget->forget_one.nodeid = nodeid;

	forget->forget_one.nlookup = nlookup;



	spin_lock(&fiq->lock);

	if (fiq->connected) {

		fiq->forget_list_tail->next = forget;

		fiq->forget_list_tail = forget;

		fiq->ops->wake_forget_and_unlock(fiq);

	} else {

		kfree(forget);

		spin_unlock(&fiq->lock);

	}

	fiq->ops->send_forget(fiq, forget);

}



static void flush_bg_queue(struct fuse_conn *fc)
@@ -265,9 +338,7 @@ static void flush_bg_queue(struct fuse_conn *fc) 
		req = list_first_entry(&fc->bg_queue, struct fuse_req, list);

		list_del(&req->list);

		fc->active_background++;

		spin_lock(&fiq->lock);

		req->in.h.unique = fuse_get_unique(fiq);

		queue_request_and_unlock(fiq, req);

		fuse_send_one(fiq, req);

	}

}
@@ -288,6 +359,7 @@ void fuse_request_end(struct fuse_req *req) 
	if (test_and_set_bit(FR_FINISHED, &req->flags))

		goto put_request;



	trace_fuse_request_end(req);

	/*

	 * test_and_set_bit() implies smp_mb() between bit

	 * changing and below FR_INTERRUPTED check. Pairs with
@@ -337,29 +409,12 @@ static int queue_interrupt(struct fuse_req *req) 
{

	struct fuse_iqueue *fiq = &req->fm->fc->iq;



	spin_lock(&fiq->lock);

	/* Check for we've sent request to interrupt this req */

	if (unlikely(!test_bit(FR_INTERRUPTED, &req->flags))) {

		spin_unlock(&fiq->lock);

	if (unlikely(!test_bit(FR_INTERRUPTED, &req->flags)))

		return -EINVAL;

	}



	if (list_empty(&req->intr_entry)) {

		list_add_tail(&req->intr_entry, &fiq->interrupts);

		/*

		 * Pairs with smp_mb() implied by test_and_set_bit()

		 * from fuse_request_end().

		 */

		smp_mb();

		if (test_bit(FR_FINISHED, &req->flags)) {

			list_del_init(&req->intr_entry);

			spin_unlock(&fiq->lock);

			return 0;

		}

		fiq->ops->wake_interrupt_and_unlock(fiq);

	} else {

		spin_unlock(&fiq->lock);

	}

	fiq->ops->send_interrupt(fiq, req);



	return 0;

}
@@ -414,22 +469,16 @@ static void __fuse_request_send(struct fuse_req *req) 
	struct fuse_iqueue *fiq = &req->fm->fc->iq;



	BUG_ON(test_bit(FR_BACKGROUND, &req->flags));

	spin_lock(&fiq->lock);

	if (!fiq->connected) {

		spin_unlock(&fiq->lock);

		req->out.h.error = -ENOTCONN;

	} else {

		req->in.h.unique = fuse_get_unique(fiq);

		/* acquire extra reference, since request is still needed

		   after fuse_request_end() */



	/* acquire extra reference, since request is still needed after

	   fuse_request_end() */

	__fuse_get_request(req);

		queue_request_and_unlock(fiq, req);

	fuse_send_one(fiq, req);



	request_wait_answer(req);

	/* Pairs with smp_wmb() in fuse_request_end() */

	smp_rmb();

}

}



static void fuse_adjust_compat(struct fuse_conn *fc, struct fuse_args *args)

{
@@ -468,8 +517,14 @@ static void fuse_force_creds(struct fuse_req *req) 
{

	struct fuse_conn *fc = req->fm->fc;



	if (!req->fm->sb || req->fm->sb->s_iflags & SB_I_NOIDMAP) {

		req->in.h.uid = from_kuid_munged(fc->user_ns, current_fsuid());

		req->in.h.gid = from_kgid_munged(fc->user_ns, current_fsgid());

	} else {

		req->in.h.uid = FUSE_INVALID_UIDGID;

		req->in.h.gid = FUSE_INVALID_UIDGID;

	}



	req->in.h.pid = pid_nr_ns(task_pid(current), fc->pid_ns);

}
@@ -484,7 +539,9 @@ static void fuse_args_to_req(struct fuse_req *req, struct fuse_args *args) 
		__set_bit(FR_ASYNC, &req->flags);

}



ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args)

ssize_t __fuse_simple_request(struct mnt_idmap *idmap,

			      struct fuse_mount *fm,

			      struct fuse_args *args)

{

	struct fuse_conn *fc = fm->fc;

	struct fuse_req *req;
@@ -501,7 +558,7 @@ ssize_t fuse_simple_request(struct fuse_mount *fm, struct fuse_args *args) 
		__set_bit(FR_FORCE, &req->flags);

	} else {

		WARN_ON(args->nocreds);

		req = fuse_get_req(fm, false);

		req = fuse_get_req(idmap, fm, false);

		if (IS_ERR(req))

			return PTR_ERR(req);

	}
@@ -562,7 +619,7 @@ int fuse_simple_background(struct fuse_mount *fm, struct fuse_args *args, 
		__set_bit(FR_BACKGROUND, &req->flags);

	} else {

		WARN_ON(args->nocreds);

		req = fuse_get_req(fm, true);

		req = fuse_get_req(&invalid_mnt_idmap, fm, true);

		if (IS_ERR(req))

			return PTR_ERR(req);

	}
@@ -583,9 +640,8 @@ static int fuse_simple_notify_reply(struct fuse_mount *fm, 
{

	struct fuse_req *req;

	struct fuse_iqueue *fiq = &fm->fc->iq;

	int err = 0;



	req = fuse_get_req(fm, false);

	req = fuse_get_req(&invalid_mnt_idmap, fm, false);

	if (IS_ERR(req))

		return PTR_ERR(req);
@@ -594,16 +650,9 @@ static int fuse_simple_notify_reply(struct fuse_mount *fm, 


	fuse_args_to_req(req, args);



	spin_lock(&fiq->lock);

	if (fiq->connected) {

		queue_request_and_unlock(fiq, req);

	} else {

		err = -ENODEV;

		spin_unlock(&fiq->lock);

		fuse_put_request(req);

	}

	fuse_send_one(fiq, req);



	return err;

	return 0;

}



/*
@@ -1075,7 +1124,7 @@ __releases(fiq->lock) 
	return err ? err : reqsize;

}



struct fuse_forget_link *fuse_dequeue_forget(struct fuse_iqueue *fiq,

static struct fuse_forget_link *fuse_dequeue_forget(struct fuse_iqueue *fiq,

						    unsigned int max,

						    unsigned int *countp)

{
@@ -1096,7 +1145,6 @@ struct fuse_forget_link *fuse_dequeue_forget(struct fuse_iqueue *fiq, 


	return head;

}

EXPORT_SYMBOL(fuse_dequeue_forget);



static int fuse_read_single_forget(struct fuse_iqueue *fiq,

				   struct fuse_copy_state *cs,
@@ -1111,7 +1159,7 @@ __releases(fiq->lock) 
	struct fuse_in_header ih = {

		.opcode = FUSE_FORGET,

		.nodeid = forget->forget_one.nodeid,

		.unique = fuse_get_unique(fiq),

		.unique = fuse_get_unique_locked(fiq),

		.len = sizeof(ih) + sizeof(arg),

	};
@@ -1142,7 +1190,7 @@ __releases(fiq->lock) 
	struct fuse_batch_forget_in arg = { .count = 0 };

	struct fuse_in_header ih = {

		.opcode = FUSE_BATCH_FORGET,

		.unique = fuse_get_unique(fiq),

		.unique = fuse_get_unique_locked(fiq),

		.len = sizeof(ih) + sizeof(arg),

	};
@@ -1830,7 +1878,7 @@ static void fuse_resend(struct fuse_conn *fc) 
	}

	/* iq and pq requests are both oldest to newest */

	list_splice(&to_queue, &fiq->pending);

	fiq->ops->wake_pending_and_unlock(fiq);

	fuse_dev_wake_and_unlock(fiq);

}



static int fuse_notify_resend(struct fuse_conn *fc)

fs/fuse/dir.c

+92 −60
Original line number Diff line number Diff line
@@ -545,17 +545,21 @@ static u32 fuse_ext_size(size_t size) 
/*

 * This adds just a single supplementary group that matches the parent's group.

 */

static int get_create_supp_group(struct inode *dir, struct fuse_in_arg *ext)

static int get_create_supp_group(struct mnt_idmap *idmap,

				 struct inode *dir,

				 struct fuse_in_arg *ext)

{

	struct fuse_conn *fc = get_fuse_conn(dir);

	struct fuse_ext_header *xh;

	struct fuse_supp_groups *sg;

	kgid_t kgid = dir->i_gid;

	vfsgid_t vfsgid = make_vfsgid(idmap, fc->user_ns, kgid);

	gid_t parent_gid = from_kgid(fc->user_ns, kgid);



	u32 sg_len = fuse_ext_size(sizeof(*sg) + sizeof(sg->groups[0]));



	if (parent_gid == (gid_t) -1 || gid_eq(kgid, current_fsgid()) ||

	    !in_group_p(kgid))

	if (parent_gid == (gid_t) -1 || vfsgid_eq_kgid(vfsgid, current_fsgid()) ||

	    !vfsgid_in_group_p(vfsgid))

		return 0;



	xh = extend_arg(ext, sg_len);
@@ -572,7 +576,8 @@ static int get_create_supp_group(struct inode *dir, struct fuse_in_arg *ext) 
	return 0;

}



static int get_create_ext(struct fuse_args *args,

static int get_create_ext(struct mnt_idmap *idmap,

			  struct fuse_args *args,

			  struct inode *dir, struct dentry *dentry,

			  umode_t mode)

{
@@ -583,7 +588,7 @@ static int get_create_ext(struct fuse_args *args, 
	if (fc->init_security)

		err = get_security_context(dentry, mode, &ext);

	if (!err && fc->create_supp_group)

		err = get_create_supp_group(dir, &ext);

		err = get_create_supp_group(idmap, dir, &ext);



	if (!err && ext.size) {

		WARN_ON(args->in_numargs >= ARRAY_SIZE(args->in_args));
@@ -609,9 +614,9 @@ static void free_ext_value(struct fuse_args *args) 
 * If the filesystem doesn't support this, then fall back to separate

 * 'mknod' + 'open' requests.

 */

static int fuse_create_open(struct inode *dir, struct dentry *entry,

			    struct file *file, unsigned int flags,

			    umode_t mode, u32 opcode)

static int fuse_create_open(struct mnt_idmap *idmap, struct inode *dir,

			    struct dentry *entry, struct file *file,

			    unsigned int flags, umode_t mode, u32 opcode)

{

	int err;

	struct inode *inode;
@@ -668,11 +673,11 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, 
	args.out_args[1].size = sizeof(*outopenp);

	args.out_args[1].value = outopenp;



	err = get_create_ext(&args, dir, entry, mode);

	err = get_create_ext(idmap, &args, dir, entry, mode);

	if (err)

		goto out_free_ff;



	err = fuse_simple_request(fm, &args);

	err = fuse_simple_idmap_request(idmap, fm, &args);

	free_ext_value(&args);

	if (err)

		goto out_free_ff;
@@ -729,6 +734,7 @@ static int fuse_atomic_open(struct inode *dir, struct dentry *entry, 
			    umode_t mode)

{

	int err;

	struct mnt_idmap *idmap = file_mnt_idmap(file);

	struct fuse_conn *fc = get_fuse_conn(dir);

	struct dentry *res = NULL;
@@ -753,7 +759,7 @@ static int fuse_atomic_open(struct inode *dir, struct dentry *entry, 
	if (fc->no_create)

		goto mknod;



	err = fuse_create_open(dir, entry, file, flags, mode, FUSE_CREATE);

	err = fuse_create_open(idmap, dir, entry, file, flags, mode, FUSE_CREATE);

	if (err == -ENOSYS) {

		fc->no_create = 1;

		goto mknod;
@@ -764,7 +770,7 @@ static int fuse_atomic_open(struct inode *dir, struct dentry *entry, 
	return err;



mknod:

	err = fuse_mknod(&nop_mnt_idmap, dir, entry, mode, 0);

	err = fuse_mknod(idmap, dir, entry, mode, 0);

	if (err)

		goto out_dput;

no_open:
@@ -774,9 +780,9 @@ static int fuse_atomic_open(struct inode *dir, struct dentry *entry, 
/*

 * Code shared between mknod, mkdir, symlink and link

 */

static int create_new_entry(struct fuse_mount *fm, struct fuse_args *args,

			    struct inode *dir, struct dentry *entry,

			    umode_t mode)

static int create_new_entry(struct mnt_idmap *idmap, struct fuse_mount *fm,

			    struct fuse_args *args, struct inode *dir,

			    struct dentry *entry, umode_t mode)

{

	struct fuse_entry_out outarg;

	struct inode *inode;
@@ -798,12 +804,12 @@ static int create_new_entry(struct fuse_mount *fm, struct fuse_args *args, 
	args->out_args[0].value = &outarg;



	if (args->opcode != FUSE_LINK) {

		err = get_create_ext(args, dir, entry, mode);

		err = get_create_ext(idmap, args, dir, entry, mode);

		if (err)

			goto out_put_forget_req;

	}



	err = fuse_simple_request(fm, args);

	err = fuse_simple_idmap_request(idmap, fm, args);

	free_ext_value(args);

	if (err)

		goto out_put_forget_req;
@@ -864,13 +870,13 @@ static int fuse_mknod(struct mnt_idmap *idmap, struct inode *dir, 
	args.in_args[0].value = &inarg;

	args.in_args[1].size = entry->d_name.len + 1;

	args.in_args[1].value = entry->d_name.name;

	return create_new_entry(fm, &args, dir, entry, mode);

	return create_new_entry(idmap, fm, &args, dir, entry, mode);

}



static int fuse_create(struct mnt_idmap *idmap, struct inode *dir,

		       struct dentry *entry, umode_t mode, bool excl)

{

	return fuse_mknod(&nop_mnt_idmap, dir, entry, mode, 0);

	return fuse_mknod(idmap, dir, entry, mode, 0);

}



static int fuse_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
@@ -882,7 +888,8 @@ static int fuse_tmpfile(struct mnt_idmap *idmap, struct inode *dir, 
	if (fc->no_tmpfile)

		return -EOPNOTSUPP;



	err = fuse_create_open(dir, file->f_path.dentry, file, file->f_flags, mode, FUSE_TMPFILE);

	err = fuse_create_open(idmap, dir, file->f_path.dentry, file,

			       file->f_flags, mode, FUSE_TMPFILE);

	if (err == -ENOSYS) {

		fc->no_tmpfile = 1;

		err = -EOPNOTSUPP;
@@ -909,7 +916,7 @@ static int fuse_mkdir(struct mnt_idmap *idmap, struct inode *dir, 
	args.in_args[0].value = &inarg;

	args.in_args[1].size = entry->d_name.len + 1;

	args.in_args[1].value = entry->d_name.name;

	return create_new_entry(fm, &args, dir, entry, S_IFDIR);

	return create_new_entry(idmap, fm, &args, dir, entry, S_IFDIR);

}



static int fuse_symlink(struct mnt_idmap *idmap, struct inode *dir,
@@ -925,7 +932,7 @@ static int fuse_symlink(struct mnt_idmap *idmap, struct inode *dir, 
	args.in_args[0].value = entry->d_name.name;

	args.in_args[1].size = len;

	args.in_args[1].value = link;

	return create_new_entry(fm, &args, dir, entry, S_IFLNK);

	return create_new_entry(idmap, fm, &args, dir, entry, S_IFLNK);

}



void fuse_flush_time_update(struct inode *inode)
@@ -1019,7 +1026,7 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry) 
	return err;

}



static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,

static int fuse_rename_common(struct mnt_idmap *idmap, struct inode *olddir, struct dentry *oldent,

			      struct inode *newdir, struct dentry *newent,

			      unsigned int flags, int opcode, size_t argsize)

{
@@ -1040,7 +1047,7 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent, 
	args.in_args[1].value = oldent->d_name.name;

	args.in_args[2].size = newent->d_name.len + 1;

	args.in_args[2].value = newent->d_name.name;

	err = fuse_simple_request(fm, &args);

	err = fuse_simple_idmap_request(idmap, fm, &args);

	if (!err) {

		/* ctime changes */

		fuse_update_ctime(d_inode(oldent));
@@ -1086,7 +1093,8 @@ static int fuse_rename2(struct mnt_idmap *idmap, struct inode *olddir, 
		if (fc->no_rename2 || fc->minor < 23)

			return -EINVAL;



		err = fuse_rename_common(olddir, oldent, newdir, newent, flags,

		err = fuse_rename_common((flags & RENAME_WHITEOUT) ? idmap : &invalid_mnt_idmap,

					 olddir, oldent, newdir, newent, flags,

					 FUSE_RENAME2,

					 sizeof(struct fuse_rename2_in));

		if (err == -ENOSYS) {
@@ -1094,7 +1102,7 @@ static int fuse_rename2(struct mnt_idmap *idmap, struct inode *olddir, 
			err = -EINVAL;

		}

	} else {

		err = fuse_rename_common(olddir, oldent, newdir, newent, 0,

		err = fuse_rename_common(&invalid_mnt_idmap, olddir, oldent, newdir, newent, 0,

					 FUSE_RENAME,

					 sizeof(struct fuse_rename_in));

	}
@@ -1119,7 +1127,7 @@ static int fuse_link(struct dentry *entry, struct inode *newdir, 
	args.in_args[0].value = &inarg;

	args.in_args[1].size = newent->d_name.len + 1;

	args.in_args[1].value = newent->d_name.name;

	err = create_new_entry(fm, &args, newdir, newent, inode->i_mode);

	err = create_new_entry(&invalid_mnt_idmap, fm, &args, newdir, newent, inode->i_mode);

	if (!err)

		fuse_update_ctime_in_cache(inode);

	else if (err == -EINTR)
@@ -1128,18 +1136,22 @@ static int fuse_link(struct dentry *entry, struct inode *newdir, 
	return err;

}



static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,

			  struct kstat *stat)

static void fuse_fillattr(struct mnt_idmap *idmap, struct inode *inode,

			  struct fuse_attr *attr, struct kstat *stat)

{

	unsigned int blkbits;

	struct fuse_conn *fc = get_fuse_conn(inode);

	vfsuid_t vfsuid = make_vfsuid(idmap, fc->user_ns,

				      make_kuid(fc->user_ns, attr->uid));

	vfsgid_t vfsgid = make_vfsgid(idmap, fc->user_ns,

				      make_kgid(fc->user_ns, attr->gid));



	stat->dev = inode->i_sb->s_dev;

	stat->ino = attr->ino;

	stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);

	stat->nlink = attr->nlink;

	stat->uid = make_kuid(fc->user_ns, attr->uid);

	stat->gid = make_kgid(fc->user_ns, attr->gid);

	stat->uid = vfsuid_into_kuid(vfsuid);

	stat->gid = vfsgid_into_kgid(vfsgid);

	stat->rdev = inode->i_rdev;

	stat->atime.tv_sec = attr->atime;

	stat->atime.tv_nsec = attr->atimensec;
@@ -1178,8 +1190,8 @@ static void fuse_statx_to_attr(struct fuse_statx *sx, struct fuse_attr *attr) 
	attr->blksize = sx->blksize;

}



static int fuse_do_statx(struct inode *inode, struct file *file,

			 struct kstat *stat)

static int fuse_do_statx(struct mnt_idmap *idmap, struct inode *inode,

			 struct file *file, struct kstat *stat)

{

	int err;

	struct fuse_attr attr;
@@ -1232,15 +1244,15 @@ static int fuse_do_statx(struct inode *inode, struct file *file, 
		stat->result_mask = sx->mask & (STATX_BASIC_STATS | STATX_BTIME);

		stat->btime.tv_sec = sx->btime.tv_sec;

		stat->btime.tv_nsec = min_t(u32, sx->btime.tv_nsec, NSEC_PER_SEC - 1);

		fuse_fillattr(inode, &attr, stat);

		fuse_fillattr(idmap, inode, &attr, stat);

		stat->result_mask |= STATX_TYPE;

	}



	return 0;

}



static int fuse_do_getattr(struct inode *inode, struct kstat *stat,

			   struct file *file)

static int fuse_do_getattr(struct mnt_idmap *idmap, struct inode *inode,

			   struct kstat *stat, struct file *file)

{

	int err;

	struct fuse_getattr_in inarg;
@@ -1279,15 +1291,15 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat, 
					       ATTR_TIMEOUT(&outarg),

					       attr_version);

			if (stat)

				fuse_fillattr(inode, &outarg.attr, stat);

				fuse_fillattr(idmap, inode, &outarg.attr, stat);

		}

	}

	return err;

}



static int fuse_update_get_attr(struct inode *inode, struct file *file,

				struct kstat *stat, u32 request_mask,

				unsigned int flags)

static int fuse_update_get_attr(struct mnt_idmap *idmap, struct inode *inode,

				struct file *file, struct kstat *stat,

				u32 request_mask, unsigned int flags)

{

	struct fuse_inode *fi = get_fuse_inode(inode);

	struct fuse_conn *fc = get_fuse_conn(inode);
@@ -1318,17 +1330,17 @@ static int fuse_update_get_attr(struct inode *inode, struct file *file, 
		forget_all_cached_acls(inode);

		/* Try statx if BTIME is requested */

		if (!fc->no_statx && (request_mask & ~STATX_BASIC_STATS)) {

			err = fuse_do_statx(inode, file, stat);

			err = fuse_do_statx(idmap, inode, file, stat);

			if (err == -ENOSYS) {

				fc->no_statx = 1;

				err = 0;

				goto retry;

			}

		} else {

			err = fuse_do_getattr(inode, stat, file);

			err = fuse_do_getattr(idmap, inode, stat, file);

		}

	} else if (stat) {

		generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);

		generic_fillattr(idmap, request_mask, inode, stat);

		stat->mode = fi->orig_i_mode;

		stat->ino = fi->orig_ino;

		if (test_bit(FUSE_I_BTIME, &fi->state)) {
@@ -1342,7 +1354,7 @@ static int fuse_update_get_attr(struct inode *inode, struct file *file, 


int fuse_update_attributes(struct inode *inode, struct file *file, u32 mask)

{

	return fuse_update_get_attr(inode, file, NULL, mask, 0);

	return fuse_update_get_attr(&nop_mnt_idmap, inode, file, NULL, mask, 0);

}



int fuse_reverse_inval_entry(struct fuse_conn *fc, u64 parent_nodeid,
@@ -1462,6 +1474,14 @@ static int fuse_access(struct inode *inode, int mask) 


	BUG_ON(mask & MAY_NOT_BLOCK);



	/*

	 * We should not send FUSE_ACCESS to the userspace

	 * when idmapped mounts are enabled as for this case

	 * we have fc->default_permissions = 1 and access

	 * permission checks are done on the kernel side.

	 */

	WARN_ON_ONCE(!(fm->sb->s_iflags & SB_I_NOIDMAP));



	if (fm->fc->no_access)

		return 0;
@@ -1486,7 +1506,7 @@ static int fuse_perm_getattr(struct inode *inode, int mask) 
		return -ECHILD;



	forget_all_cached_acls(inode);

	return fuse_do_getattr(inode, NULL, NULL);

	return fuse_do_getattr(&nop_mnt_idmap, inode, NULL, NULL);

}



/*
@@ -1534,7 +1554,7 @@ static int fuse_permission(struct mnt_idmap *idmap, 
	}



	if (fc->default_permissions) {

		err = generic_permission(&nop_mnt_idmap, inode, mask);

		err = generic_permission(idmap, inode, mask);



		/* If permission is denied, try to refresh file

		   attributes.  This is also needed, because the root
@@ -1542,7 +1562,7 @@ static int fuse_permission(struct mnt_idmap *idmap, 
		if (err == -EACCES && !refreshed) {

			err = fuse_perm_getattr(inode, mask);

			if (!err)

				err = generic_permission(&nop_mnt_idmap,

				err = generic_permission(idmap,

							 inode, mask);

		}
@@ -1738,17 +1758,29 @@ static bool update_mtime(unsigned ivalid, bool trust_local_mtime) 
	return true;

}



static void iattr_to_fattr(struct fuse_conn *fc, struct iattr *iattr,

			   struct fuse_setattr_in *arg, bool trust_local_cmtime)

static void iattr_to_fattr(struct mnt_idmap *idmap, struct fuse_conn *fc,

			   struct iattr *iattr, struct fuse_setattr_in *arg,

			   bool trust_local_cmtime)

{

	unsigned ivalid = iattr->ia_valid;



	if (ivalid & ATTR_MODE)

		arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;

	if (ivalid & ATTR_UID)

		arg->valid |= FATTR_UID,    arg->uid = from_kuid(fc->user_ns, iattr->ia_uid);

	if (ivalid & ATTR_GID)

		arg->valid |= FATTR_GID,    arg->gid = from_kgid(fc->user_ns, iattr->ia_gid);



	if (ivalid & ATTR_UID) {

		kuid_t fsuid = from_vfsuid(idmap, fc->user_ns, iattr->ia_vfsuid);



		arg->valid |= FATTR_UID;

		arg->uid = from_kuid(fc->user_ns, fsuid);

	}



	if (ivalid & ATTR_GID) {

		kgid_t fsgid = from_vfsgid(idmap, fc->user_ns, iattr->ia_vfsgid);



		arg->valid |= FATTR_GID;

		arg->gid = from_kgid(fc->user_ns, fsgid);

	}



	if (ivalid & ATTR_SIZE)

		arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;

	if (ivalid & ATTR_ATIME) {
@@ -1868,8 +1900,8 @@ int fuse_flush_times(struct inode *inode, struct fuse_file *ff) 
 * vmtruncate() doesn't allow for this case, so do the rlimit checking

 * and the actual truncation by hand.

 */

int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,

		    struct file *file)

int fuse_do_setattr(struct mnt_idmap *idmap, struct dentry *dentry,

		    struct iattr *attr, struct file *file)

{

	struct inode *inode = d_inode(dentry);

	struct fuse_mount *fm = get_fuse_mount(inode);
@@ -1889,7 +1921,7 @@ int fuse_do_setattr(struct dentry *dentry, struct iattr *attr, 
	if (!fc->default_permissions)

		attr->ia_valid |= ATTR_FORCE;



	err = setattr_prepare(&nop_mnt_idmap, dentry, attr);

	err = setattr_prepare(idmap, dentry, attr);

	if (err)

		return err;
@@ -1948,7 +1980,7 @@ int fuse_do_setattr(struct dentry *dentry, struct iattr *attr, 


	memset(&inarg, 0, sizeof(inarg));

	memset(&outarg, 0, sizeof(outarg));

	iattr_to_fattr(fc, attr, &inarg, trust_local_cmtime);

	iattr_to_fattr(idmap, fc, attr, &inarg, trust_local_cmtime);

	if (file) {

		struct fuse_file *ff = file->private_data;

		inarg.valid |= FATTR_FH;
@@ -2065,7 +2097,7 @@ static int fuse_setattr(struct mnt_idmap *idmap, struct dentry *entry, 
			 * ia_mode calculation may have used stale i_mode.

			 * Refresh and recalculate.

			 */

			ret = fuse_do_getattr(inode, NULL, file);

			ret = fuse_do_getattr(idmap, inode, NULL, file);

			if (ret)

				return ret;
@@ -2083,7 +2115,7 @@ static int fuse_setattr(struct mnt_idmap *idmap, struct dentry *entry, 
	if (!attr->ia_valid)

		return 0;



	ret = fuse_do_setattr(entry, attr, file);

	ret = fuse_do_setattr(idmap, entry, attr, file);

	if (!ret) {

		/*

		 * If filesystem supports acls it may have updated acl xattrs in
@@ -2122,7 +2154,7 @@ static int fuse_getattr(struct mnt_idmap *idmap, 
		return -EACCES;

	}



	return fuse_update_get_attr(inode, NULL, stat, request_mask, flags);

	return fuse_update_get_attr(idmap, inode, NULL, stat, request_mask, flags);

}



static const struct inode_operations fuse_dir_inode_operations = {

fs/fuse/file.c

+92 −92

File changed.

Preview size limit exceeded, changes collapsed.