Skip to contentSkip to conversation

virtio-fs: Create a read-write mapping only if needed

PATCH In review Vivek Goyal 2 participants 7 messages Jul 26, 2019 – Aug 5, 2019 FUSE filesystem core

lore
Share & tools
lore
#0 lore raw

v2 cover virtio-fs: Create a read-write mapping only if needed

This is V2 of patches.

Changes since V1:

- Fixed the issue of dropping lock (liu bo)
- Mapping could already be made writable by another thread after dropping read lock and acquiring write-lock. So check for that.

Do not always create a read-write mapping. Create it read-write only if caller asked for it. Otherwise create a read-only mapping and upgrade it to read-write later when needed.

Vivek Goyal (3):
fuse: Get rid of file parameter from setup mapping
fuse: Move new mapping setup code in a function
fuse: Add logic to upgrade a read-only mapping to read-write

 fs/fuse/file.c   | 253 +++++++++++++++++++++++++++++------------------
 fs/fuse/fuse_i.h |   3 +
 2 files changed, 162 insertions(+), 94 deletions(-)
Signature · 1 line
2.17.2
#1 lore raw

PATCH v2 1/3 fuse: Get rid of file parameter from setup mapping

There is only one caller of fuse_setup_one_mapping() and that passes file argument as NULL. So get rid of this parameter as there are no callers.

---
 fs/fuse/file.c | 30 +++++++-----------------------
 1 file changed, 7 insertions(+), 23 deletions(-)
fs/fuse/file.c +7 -23
index fc40e0f44578..93f8e62e2b5b 100644
@@ -264,41 +264,26 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,
 }
 
 /* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */
-static int fuse_setup_one_mapping(struct inode *inode,
-				struct file *file, loff_t offset,
-				struct fuse_dax_mapping *dmap)
+static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
+				  struct fuse_dax_mapping *dmap)
 {
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_inode *fi = get_fuse_inode(inode);
-	struct fuse_file *ff = NULL;
 	struct fuse_setupmapping_in inarg;
 	FUSE_ARGS(args);
 	ssize_t err;
 
-	if (file)
-		ff = file->private_data;
-
 	WARN_ON(offset % FUSE_DAX_MEM_RANGE_SZ);
 	WARN_ON(fc->nr_free_ranges < 0);
 
 	/* Ask fuse daemon to setup mapping */
 	memset(&inarg, 0, sizeof(inarg));
 	inarg.foffset = offset;
-	if (ff)
-		inarg.fh = ff->fh;
-	else
-		inarg.fh = -1;
+	inarg.fh = -1;
 	inarg.moffset = dmap->window_offset;
 	inarg.len = FUSE_DAX_MEM_RANGE_SZ;
-	if (file) {
-		inarg.flags |= (file->f_mode & FMODE_WRITE) ?
-				FUSE_SETUPMAPPING_FLAG_WRITE : 0;
-		inarg.flags |= (file->f_mode & FMODE_READ) ?
-				FUSE_SETUPMAPPING_FLAG_READ : 0;
-	} else {
-		inarg.flags |= FUSE_SETUPMAPPING_FLAG_READ;
-		inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
-	}
+	inarg.flags |= FUSE_SETUPMAPPING_FLAG_READ;
+	inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
 	args.in.h.opcode = FUSE_SETUPMAPPING;
 	args.in.h.nodeid = fi->nodeid;
 	args.in.numargs = 1;
@@ -1985,9 +1970,8 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 		}
 
 		/* Setup one mapping */
-		ret = fuse_setup_one_mapping(inode, NULL,
-				ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
-				alloc_dmap);
+		ret = fuse_setup_one_mapping(inode,
+			ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ), alloc_dmap);
 		if (ret < 0) {
 			printk("fuse_setup_one_mapping() failed. err=%d"
 				" pos=0x%llx\n", ret, pos);
Signature · 1 line
2.17.2
#2 lore raw

PATCH v2 2/3 fuse: Move new mapping setup code in a function

In reply to Vivek Goyal

Move new mapping setup code in a separate function. More code will come in fuse_iomap_begin() and its becoming too big.

---
 fs/fuse/file.c | 116 +++++++++++++++++++++++++++----------------------
 1 file changed, 64 insertions(+), 52 deletions(-)
fs/fuse/file.c +64 -52
index 93f8e62e2b5b..a2c19e4a28b5 100644
@@ -1882,6 +1882,67 @@ static void fuse_fill_iomap(struct inode *inode, loff_t pos, loff_t length,
 	}
 }
 
+static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
+					 loff_t length, unsigned flags,
+					 struct iomap *iomap)
+{
+	struct fuse_inode *fi = get_fuse_inode(inode);
+	struct fuse_conn *fc = get_fuse_conn(inode);
+	struct fuse_dax_mapping *dmap, *alloc_dmap = NULL;
+	int ret;
+
+	/* Can't do reclaim in fault path yet due to lock ordering.
+	 * Read path takes shared inode lock and that's not sufficient
+	 * for inline range reclaim. Caller needs to drop lock, wait
+	 * and retry.
+	 */
+	if (flags & IOMAP_FAULT || !(flags & IOMAP_WRITE)) {
+		alloc_dmap = alloc_dax_mapping(fc);
+		if (!alloc_dmap)
+			return -ENOSPC;
+	} else {
+		alloc_dmap = alloc_dax_mapping_reclaim(fc, inode);
+		if (IS_ERR(alloc_dmap))
+			return PTR_ERR(alloc_dmap);
+	}
+
+	/* If we are here, we should have memory allocated */
+	if (WARN_ON(!alloc_dmap))
+		return -EBUSY;
+
+	/*
+	 * Drop read lock and take write lock so that only one
+	 * caller can try to setup mapping and other waits
+	 */
+	down_write(&fi->i_dmap_sem);
+	/*
+	 * We dropped lock. Check again if somebody else setup
+	 * mapping already.
+	 */
+	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos,
+						pos);
+	if (dmap) {
+		fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+		dmap_add_to_free_pool(fc, alloc_dmap);
+		up_write(&fi->i_dmap_sem);
+		return 0;
+	}
+
+	/* Setup one mapping */
+	ret = fuse_setup_one_mapping(inode,
+		ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ), alloc_dmap);
+	if (ret < 0) {
+		printk("fuse_setup_one_mapping() failed. err=%d"
+			" pos=0x%llx\n", ret, pos);
+		dmap_add_to_free_pool(fc, alloc_dmap);
+		up_write(&fi->i_dmap_sem);
+		return ret;
+	}
+	fuse_fill_iomap(inode, pos, length, iomap, alloc_dmap, flags);
+	up_write(&fi->i_dmap_sem);
+	return 0;
+}
+
 /* This is just for DAX and the mapping is ephemeral, do not use it for other
  * purposes since there is no block device with a permanent mapping.
  */
@@ -1890,8 +1951,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 {
 	struct fuse_inode *fi = get_fuse_inode(inode);
 	struct fuse_conn *fc = get_fuse_conn(inode);
-	struct fuse_dax_mapping *dmap, *alloc_dmap = NULL;
-	int ret;
+	struct fuse_dax_mapping *dmap;
 
 	/* We don't support FIEMAP */
 	BUG_ON(flags & IOMAP_REPORT);
@@ -1932,56 +1992,8 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 		if (pos >= i_size_read(inode))
 			goto iomap_hole;
 
-		/* Can't do reclaim in fault path yet due to lock ordering.
-		 * Read path takes shared inode lock and that's not sufficient
-		 * for inline range reclaim. Caller needs to drop lock, wait
-		 * and retry.
-		 */
-		if (flags & IOMAP_FAULT || !(flags & IOMAP_WRITE)) {
-			alloc_dmap = alloc_dax_mapping(fc);
-			if (!alloc_dmap)
-				return -ENOSPC;
-		} else {
-			alloc_dmap = alloc_dax_mapping_reclaim(fc, inode);
-			if (IS_ERR(alloc_dmap))
-				return PTR_ERR(alloc_dmap);
-		}
-
-		/* If we are here, we should have memory allocated */
-		if (WARN_ON(!alloc_dmap))
-			return -EBUSY;
-
-		/*
-		 * Drop read lock and take write lock so that only one
-		 * caller can try to setup mapping and other waits
-		 */
-		down_write(&fi->i_dmap_sem);
-		/*
-		 * We dropped lock. Check again if somebody else setup
-		 * mapping already.
-		 */
-		dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos,
-							pos);
-		if (dmap) {
-			fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
-			dmap_add_to_free_pool(fc, alloc_dmap);
-			up_write(&fi->i_dmap_sem);
-			return 0;
-		}
-
-		/* Setup one mapping */
-		ret = fuse_setup_one_mapping(inode,
-			ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ), alloc_dmap);
-		if (ret < 0) {
-			printk("fuse_setup_one_mapping() failed. err=%d"
-				" pos=0x%llx\n", ret, pos);
-			dmap_add_to_free_pool(fc, alloc_dmap);
-			up_write(&fi->i_dmap_sem);
-			return ret;
-		}
-		fuse_fill_iomap(inode, pos, length, iomap, alloc_dmap, flags);
-		up_write(&fi->i_dmap_sem);
-		return 0;
+		return iomap_begin_setup_new_mapping(inode, pos, length, flags,
+						    iomap);
 	}
 
 	/*
Signature · 1 line
2.17.2
#3 lore raw

PATCH v2 3/3 fuse: Add logic to upgrade a read-only mapping to read-write

In reply to Vivek Goyal

Do not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.

Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.

---
 fs/fuse/file.c   | 121 +++++++++++++++++++++++++++++++++++++----------
 fs/fuse/fuse_i.h |   3 ++
 2 files changed, 98 insertions(+), 26 deletions(-)
fs/fuse/file.c +95 -26
index a2c19e4a28b5..5277de7028a6 100644
@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,
 
 /* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */
 static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
-				  struct fuse_dax_mapping *dmap)
+				  struct fuse_dax_mapping *dmap, bool writable,
+				  bool upgrade)
 {
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_inode *fi = get_fuse_inode(inode);
@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 	inarg.moffset = dmap->window_offset;
 	inarg.len = FUSE_DAX_MEM_RANGE_SZ;
 	inarg.flags |= FUSE_SETUPMAPPING_FLAG_READ;
-	inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
+	if (writable)
+		inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
 	args.in.h.opcode = FUSE_SETUPMAPPING;
 	args.in.h.nodeid = fi->nodeid;
 	args.in.numargs = 1;
@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 		return err;
 	}
 
-	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n", offset, err);
+	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d"
+		 " err=%zd\n", offset, writable, err);
 
-	/*
-	 * We don't take a refernce on inode. inode is valid right now and
-	 * when inode is going away, cleanup logic should first cleanup
-	 * dmap entries.
-	 *
-	 * TODO: Do we need to ensure that we are holding inode lock
-	 * as well.
-	 */
-	dmap->inode = inode;
-	dmap->start = offset;
-	dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
-	/* Protected by fi->i_dmap_sem */
-	fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
-	fi->nr_dmaps++;
-	spin_lock(&fc->lock);
-	list_add_tail(&dmap->busy_list, &fc->busy_ranges);
-	fc->nr_busy_ranges++;
-	spin_unlock(&fc->lock);
+	dmap->writable = writable;
+	if (!upgrade) {
+		/*
+		 * We don't take a refernce on inode. inode is valid right now
+		 * and when inode is going away, cleanup logic should first
+		 * cleanup dmap entries.
+		 *
+		 * TODO: Do we need to ensure that we are holding inode lock
+		 * as well.
+		 */
+		dmap->inode = inode;
+		dmap->start = offset;
+		dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
+		/* Protected by fi->i_dmap_sem */
+		fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
+		fi->nr_dmaps++;
+		spin_lock(&fc->lock);
+		list_add_tail(&dmap->busy_list, &fc->busy_ranges);
+		fc->nr_busy_ranges++;
+		spin_unlock(&fc->lock);
+	}
 	return 0;
 }
 
@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap, *alloc_dmap = NULL;
 	int ret;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* Can't do reclaim in fault path yet due to lock ordering.
 	 * Read path takes shared inode lock and that's not sufficient
@@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 
 	/* Setup one mapping */
 	ret = fuse_setup_one_mapping(inode,
-		ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ), alloc_dmap);
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     alloc_dmap, writable, false);
 	if (ret < 0) {
 		printk("fuse_setup_one_mapping() failed. err=%d"
-			" pos=0x%llx\n", ret, pos);
+			" pos=0x%llx, writable=%d\n", ret, pos, writable);
 		dmap_add_to_free_pool(fc, alloc_dmap);
 		up_write(&fi->i_dmap_sem);
 		return ret;
@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	return 0;
 }
 
+static int iomap_begin_upgrade_mapping(struct inode *inode, loff_t pos,
+					 loff_t length, unsigned flags,
+					 struct iomap *iomap)
+{
+	struct fuse_inode *fi = get_fuse_inode(inode);
+	struct fuse_dax_mapping *dmap;
+	int ret;
+
+	/*
+	 * Take exclusive lock so that only one caller can try to setup
+	 * mapping and others wait.
+	 */
+	down_write(&fi->i_dmap_sem);
+	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
+
+	/* We are holding either inode lock or i_mmap_sem, and that should
+	 * ensure that dmap can't reclaimed or truncated and it should still
+	 * be there in tree despite the fact we dropped and re-acquired the
+	 * lock.
+	 */
+	ret = -EIO;
+	if (WARN_ON(!dmap))
+		goto out_err;
+
+	/* Maybe another thread already upgraded mapping while we were not
+	 * holding lock.
+	 */
+	if (dmap->writable)
+		goto out_fill_iomap;
+
+	ret = fuse_setup_one_mapping(inode,
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     dmap, true, true);
+	if (ret < 0) {
+		printk("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n",
+		       ret, pos);
+		goto out_err;
+	}
+
+out_fill_iomap:
+	fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+out_err:
+	up_write(&fi->i_dmap_sem);
+	return ret;
+}
+
 /* This is just for DAX and the mapping is ephemeral, do not use it for other
  * purposes since there is no block device with a permanent mapping.
  */
@@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	struct fuse_inode *fi = get_fuse_inode(inode);
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* We don't support FIEMAP */
 	BUG_ON(flags & IOMAP_REPORT);
@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
 
 	if (dmap) {
-		fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
-		up_read(&fi->i_dmap_sem);
-		return 0;
+		if (writable && !dmap->writable) {
+			/* Upgrade read-only mapping to read-write. This will
+			 * require exclusive i_dmap_sem lock as we don't want
+			 * two threads to be trying to this simultaneously
+			 * for same dmap. So drop shared lock and acquire
+			 * exclusive lock.
+			 */
+			up_read(&fi->i_dmap_sem);
+			pr_debug("%s: Upgrading mapping at offset 0x%llx"
+				 " length 0x%llx\n", __func__, pos, length);
+			return iomap_begin_upgrade_mapping(inode, pos, length,
+							   flags, iomap);
+		} else {
+			fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+			up_read(&fi->i_dmap_sem);
+			return 0;
+		}
 	} else {
 		up_read(&fi->i_dmap_sem);
 		pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",
fs/fuse/fuse_i.h +3 -0
index e899a06e29d7..34ca8b90a1e1 100644
@@ -134,6 +134,9 @@ struct fuse_dax_mapping {
 
 	/** Length of mapping, in bytes */
 	loff_t length;
+
+	/* Is this mapping read-only or read-write */
+	bool writable;
 };
 
 /** FUSE inode */
Signature · 1 line
2.17.2
#4 lore raw

Re: [Virtio-fs] [PATCH 3/3] fuse: Add logic to upgrade a read-only mapping to read-write

Hi Vivek,

Shall we downgrade dax mapping from rw to read-only, if current user open with O_RDONLY, and last user opened with O_RDWR? This will minimize the access authority.

I wonder if my concern is necessary. And if it will cause frequent dax mapping?

Thanks,
Jun

Quoted 214 lines · Vivek Goyal

Do not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.

Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.

---
 fs/fuse/file.c   | 121 +++++++++++++++++++++++++++++++++++++----------
 fs/fuse/fuse_i.h |   3 ++
 2 files changed, 98 insertions(+), 26 deletions(-)
fs/fuse/file.c +95 -26
index a2c19e4a28b5..5277de7028a6 100644
@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,
 
 /* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */
 static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
-				  struct fuse_dax_mapping *dmap)
+				  struct fuse_dax_mapping *dmap, bool writable,
+				  bool upgrade)
 {
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_inode *fi = get_fuse_inode(inode);
@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 	inarg.moffset = dmap->window_offset;
 	inarg.len = FUSE_DAX_MEM_RANGE_SZ;
 	inarg.flags |= FUSE_SETUPMAPPING_FLAG_READ;
-	inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
+	if (writable)
+		inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
 	args.in.h.opcode = FUSE_SETUPMAPPING;
 	args.in.h.nodeid = fi->nodeid;
 	args.in.numargs = 1;
@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 		return err;
 	}
 
-	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n", offset, err);
+	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d"
+		 " err=%zd\n", offset, writable, err);
 
-	/*
-	 * We don't take a refernce on inode. inode is valid right now and
-	 * when inode is going away, cleanup logic should first cleanup
-	 * dmap entries.
-	 *
-	 * TODO: Do we need to ensure that we are holding inode lock
-	 * as well.
-	 */
-	dmap->inode = inode;
-	dmap->start = offset;
-	dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
-	/* Protected by fi->i_dmap_sem */
-	fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
-	fi->nr_dmaps++;
-	spin_lock(&fc->lock);
-	list_add_tail(&dmap->busy_list, &fc->busy_ranges);
-	fc->nr_busy_ranges++;
-	spin_unlock(&fc->lock);
+	dmap->writable = writable;
+	if (!upgrade) {
+		/*
+		 * We don't take a refernce on inode. inode is valid right now
+		 * and when inode is going away, cleanup logic should first
+		 * cleanup dmap entries.
+		 *
+		 * TODO: Do we need to ensure that we are holding inode lock
+		 * as well.
+		 */
+		dmap->inode = inode;
+		dmap->start = offset;
+		dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
+		/* Protected by fi->i_dmap_sem */
+		fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
+		fi->nr_dmaps++;
+		spin_lock(&fc->lock);
+		list_add_tail(&dmap->busy_list, &fc->busy_ranges);
+		fc->nr_busy_ranges++;
+		spin_unlock(&fc->lock);
+	}
 	return 0;
 }
 
@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap, *alloc_dmap = NULL;
 	int ret;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* Can't do reclaim in fault path yet due to lock ordering.
 	 * Read path takes shared inode lock and that's not sufficient
@@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 
 	/* Setup one mapping */
 	ret = fuse_setup_one_mapping(inode,
-		ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ), alloc_dmap);
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     alloc_dmap, writable, false);
 	if (ret < 0) {
 		printk("fuse_setup_one_mapping() failed. err=%d"
-			" pos=0x%llx\n", ret, pos);
+			" pos=0x%llx, writable=%d\n", ret, pos, writable);
 		dmap_add_to_free_pool(fc, alloc_dmap);
 		up_write(&fi->i_dmap_sem);
 		return ret;
@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	return 0;
 }
 
+static int iomap_begin_upgrade_mapping(struct inode *inode, loff_t pos,
+					 loff_t length, unsigned flags,
+					 struct iomap *iomap)
+{
+	struct fuse_inode *fi = get_fuse_inode(inode);
+	struct fuse_dax_mapping *dmap;
+	int ret;
+
+	/*
+	 * Take exclusive lock so that only one caller can try to setup
+	 * mapping and others wait.
+	 */
+	down_write(&fi->i_dmap_sem);
+	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
+
+	/* We are holding either inode lock or i_mmap_sem, and that should
+	 * ensure that dmap can't reclaimed or truncated and it should still
+	 * be there in tree despite the fact we dropped and re-acquired the
+	 * lock.
+	 */
+	ret = -EIO;
+	if (WARN_ON(!dmap))
+		goto out_err;
+
+	/* Maybe another thread already upgraded mapping while we were not
+	 * holding lock.
+	 */
+	if (dmap->writable)
+		goto out_fill_iomap;
+
+	ret = fuse_setup_one_mapping(inode,
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     dmap, true, true);
+	if (ret < 0) {
+		printk("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n",
+		       ret, pos);
+		goto out_err;
+	}
+
+out_fill_iomap:
+	fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+out_err:
+	up_write(&fi->i_dmap_sem);
+	return ret;
+}
+
 /* This is just for DAX and the mapping is ephemeral, do not use it for other
  * purposes since there is no block device with a permanent mapping.
  */
@@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	struct fuse_inode *fi = get_fuse_inode(inode);
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* We don't support FIEMAP */
 	BUG_ON(flags & IOMAP_REPORT);
@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
 
 	if (dmap) {
-		fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
-		up_read(&fi->i_dmap_sem);
-		return 0;
+		if (writable && !dmap->writable) {
+			/* Upgrade read-only mapping to read-write. This will
+			 * require exclusive i_dmap_sem lock as we don't want
+			 * two threads to be trying to this simultaneously
+			 * for same dmap. So drop shared lock and acquire
+			 * exclusive lock.
+			 */
+			up_read(&fi->i_dmap_sem);
+			pr_debug("%s: Upgrading mapping at offset 0x%llx"
+				 " length 0x%llx\n", __func__, pos, length);
+			return iomap_begin_upgrade_mapping(inode, pos, length,
+							   flags, iomap);
+		} else {
+			fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+			up_read(&fi->i_dmap_sem);
+			return 0;
+		}
 	} else {
 		up_read(&fi->i_dmap_sem);
 		pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",
fs/fuse/fuse_i.h +3 -0
index e899a06e29d7..34ca8b90a1e1 100644
@@ -134,6 +134,9 @@ struct fuse_dax_mapping {
 
 	/** Length of mapping, in bytes */
 	loff_t length;
+
+	/* Is this mapping read-only or read-write */
+	bool writable;
 };
 
 /** FUSE inode */
#5 lore raw

Re: [Virtio-fs] [PATCH 3/3] fuse: Add logic to upgrade a read-only mapping to read-write

Quoted 8 lines · piaojun

Hi Vivek,

Shall we downgrade dax mapping from rw to read-only, if current user open with O_RDONLY, and last user opened with O_RDWR? This will minimize the access authority.

I wonder if my concern is necessary. And if it will cause frequent dax mapping?

There is a chance that memory mapping will be reclaimed and setup as read-only again.

I will not worry about this at this point of time.

Thanks
Vivek

Quoted 219 lines

Thanks,
Jun

Quoted 214 lines · Vivek Goyal

Do not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.

Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.

---
 fs/fuse/file.c   | 121 +++++++++++++++++++++++++++++++++++++----------
 fs/fuse/fuse_i.h |   3 ++
 2 files changed, 98 insertions(+), 26 deletions(-)
fs/fuse/file.c +95 -26
index a2c19e4a28b5..5277de7028a6 100644
@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,
 
 /* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */
 static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
-				  struct fuse_dax_mapping *dmap)
+				  struct fuse_dax_mapping *dmap, bool writable,
+				  bool upgrade)
 {
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_inode *fi = get_fuse_inode(inode);
@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 	inarg.moffset = dmap->window_offset;
 	inarg.len = FUSE_DAX_MEM_RANGE_SZ;
 	inarg.flags |= FUSE_SETUPMAPPING_FLAG_READ;
-	inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
+	if (writable)
+		inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
 	args.in.h.opcode = FUSE_SETUPMAPPING;
 	args.in.h.nodeid = fi->nodeid;
 	args.in.numargs = 1;
@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 		return err;
 	}
 
-	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n", offset, err);
+	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d"
+		 " err=%zd\n", offset, writable, err);
 
-	/*
-	 * We don't take a refernce on inode. inode is valid right now and
-	 * when inode is going away, cleanup logic should first cleanup
-	 * dmap entries.
-	 *
-	 * TODO: Do we need to ensure that we are holding inode lock
-	 * as well.
-	 */
-	dmap->inode = inode;
-	dmap->start = offset;
-	dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
-	/* Protected by fi->i_dmap_sem */
-	fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
-	fi->nr_dmaps++;
-	spin_lock(&fc->lock);
-	list_add_tail(&dmap->busy_list, &fc->busy_ranges);
-	fc->nr_busy_ranges++;
-	spin_unlock(&fc->lock);
+	dmap->writable = writable;
+	if (!upgrade) {
+		/*
+		 * We don't take a refernce on inode. inode is valid right now
+		 * and when inode is going away, cleanup logic should first
+		 * cleanup dmap entries.
+		 *
+		 * TODO: Do we need to ensure that we are holding inode lock
+		 * as well.
+		 */
+		dmap->inode = inode;
+		dmap->start = offset;
+		dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
+		/* Protected by fi->i_dmap_sem */
+		fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
+		fi->nr_dmaps++;
+		spin_lock(&fc->lock);
+		list_add_tail(&dmap->busy_list, &fc->busy_ranges);
+		fc->nr_busy_ranges++;
+		spin_unlock(&fc->lock);
+	}
 	return 0;
 }
 
@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap, *alloc_dmap = NULL;
 	int ret;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* Can't do reclaim in fault path yet due to lock ordering.
 	 * Read path takes shared inode lock and that's not sufficient
@@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 
 	/* Setup one mapping */
 	ret = fuse_setup_one_mapping(inode,
-		ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ), alloc_dmap);
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     alloc_dmap, writable, false);
 	if (ret < 0) {
 		printk("fuse_setup_one_mapping() failed. err=%d"
-			" pos=0x%llx\n", ret, pos);
+			" pos=0x%llx, writable=%d\n", ret, pos, writable);
 		dmap_add_to_free_pool(fc, alloc_dmap);
 		up_write(&fi->i_dmap_sem);
 		return ret;
@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	return 0;
 }
 
+static int iomap_begin_upgrade_mapping(struct inode *inode, loff_t pos,
+					 loff_t length, unsigned flags,
+					 struct iomap *iomap)
+{
+	struct fuse_inode *fi = get_fuse_inode(inode);
+	struct fuse_dax_mapping *dmap;
+	int ret;
+
+	/*
+	 * Take exclusive lock so that only one caller can try to setup
+	 * mapping and others wait.
+	 */
+	down_write(&fi->i_dmap_sem);
+	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
+
+	/* We are holding either inode lock or i_mmap_sem, and that should
+	 * ensure that dmap can't reclaimed or truncated and it should still
+	 * be there in tree despite the fact we dropped and re-acquired the
+	 * lock.
+	 */
+	ret = -EIO;
+	if (WARN_ON(!dmap))
+		goto out_err;
+
+	/* Maybe another thread already upgraded mapping while we were not
+	 * holding lock.
+	 */
+	if (dmap->writable)
+		goto out_fill_iomap;
+
+	ret = fuse_setup_one_mapping(inode,
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     dmap, true, true);
+	if (ret < 0) {
+		printk("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n",
+		       ret, pos);
+		goto out_err;
+	}
+
+out_fill_iomap:
+	fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+out_err:
+	up_write(&fi->i_dmap_sem);
+	return ret;
+}
+
 /* This is just for DAX and the mapping is ephemeral, do not use it for other
  * purposes since there is no block device with a permanent mapping.
  */
@@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	struct fuse_inode *fi = get_fuse_inode(inode);
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* We don't support FIEMAP */
 	BUG_ON(flags & IOMAP_REPORT);
@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
 
 	if (dmap) {
-		fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
-		up_read(&fi->i_dmap_sem);
-		return 0;
+		if (writable && !dmap->writable) {
+			/* Upgrade read-only mapping to read-write. This will
+			 * require exclusive i_dmap_sem lock as we don't want
+			 * two threads to be trying to this simultaneously
+			 * for same dmap. So drop shared lock and acquire
+			 * exclusive lock.
+			 */
+			up_read(&fi->i_dmap_sem);
+			pr_debug("%s: Upgrading mapping at offset 0x%llx"
+				 " length 0x%llx\n", __func__, pos, length);
+			return iomap_begin_upgrade_mapping(inode, pos, length,
+							   flags, iomap);
+		} else {
+			fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+			up_read(&fi->i_dmap_sem);
+			return 0;
+		}
 	} else {
 		up_read(&fi->i_dmap_sem);
 		pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",
fs/fuse/fuse_i.h +3 -0
index e899a06e29d7..34ca8b90a1e1 100644
@@ -134,6 +134,9 @@ struct fuse_dax_mapping {
 
 	/** Length of mapping, in bytes */
 	loff_t length;
+
+	/* Is this mapping read-only or read-write */
+	bool writable;
 };
 
 /** FUSE inode */
#6 lore raw

Re: [Virtio-fs] [PATCH 3/3] fuse: Add logic to upgrade a read-only mapping to read-write

Hi Vivek,

Quoted 7 lines · Vivek Goyal
Quoted 6 lines · piaojun

Hi Vivek,

Shall we downgrade dax mapping from rw to read-only, if current user open with O_RDONLY, and last user opened with O_RDWR? This will minimize the access authority.

Quoted 5 lines
Quoted 2 lines

I wonder if my concern is necessary. And if it will cause frequent dax mapping?

There is a chance that memory mapping will be reclaimed and setup as read-only again.

I got it, and thanks for your reply.

Thanks,
Jun

Quoted 227 lines

I will not worry about this at this point of time.

Thanks
Vivek

Quoted 217 lines

Thanks,
Jun

Quoted 212 lines · Vivek Goyal

Do not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.

Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.

---
 fs/fuse/file.c   | 121 +++++++++++++++++++++++++++++++++++++----------
 fs/fuse/fuse_i.h |   3 ++
 2 files changed, 98 insertions(+), 26 deletions(-)
fs/fuse/file.c +95 -26
index a2c19e4a28b5..5277de7028a6 100644
@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,
 
 /* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */
 static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
-				  struct fuse_dax_mapping *dmap)
+				  struct fuse_dax_mapping *dmap, bool writable,
+				  bool upgrade)
 {
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_inode *fi = get_fuse_inode(inode);
@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 	inarg.moffset = dmap->window_offset;
 	inarg.len = FUSE_DAX_MEM_RANGE_SZ;
 	inarg.flags |= FUSE_SETUPMAPPING_FLAG_READ;
-	inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
+	if (writable)
+		inarg.flags |= FUSE_SETUPMAPPING_FLAG_WRITE;
 	args.in.h.opcode = FUSE_SETUPMAPPING;
 	args.in.h.nodeid = fi->nodeid;
 	args.in.numargs = 1;
@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,
 		return err;
 	}
 
-	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n", offset, err);
+	pr_debug("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d"
+		 " err=%zd\n", offset, writable, err);
 
-	/*
-	 * We don't take a refernce on inode. inode is valid right now and
-	 * when inode is going away, cleanup logic should first cleanup
-	 * dmap entries.
-	 *
-	 * TODO: Do we need to ensure that we are holding inode lock
-	 * as well.
-	 */
-	dmap->inode = inode;
-	dmap->start = offset;
-	dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
-	/* Protected by fi->i_dmap_sem */
-	fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
-	fi->nr_dmaps++;
-	spin_lock(&fc->lock);
-	list_add_tail(&dmap->busy_list, &fc->busy_ranges);
-	fc->nr_busy_ranges++;
-	spin_unlock(&fc->lock);
+	dmap->writable = writable;
+	if (!upgrade) {
+		/*
+		 * We don't take a refernce on inode. inode is valid right now
+		 * and when inode is going away, cleanup logic should first
+		 * cleanup dmap entries.
+		 *
+		 * TODO: Do we need to ensure that we are holding inode lock
+		 * as well.
+		 */
+		dmap->inode = inode;
+		dmap->start = offset;
+		dmap->end = offset + FUSE_DAX_MEM_RANGE_SZ - 1;
+		/* Protected by fi->i_dmap_sem */
+		fuse_dax_interval_tree_insert(dmap, &fi->dmap_tree);
+		fi->nr_dmaps++;
+		spin_lock(&fc->lock);
+		list_add_tail(&dmap->busy_list, &fc->busy_ranges);
+		fc->nr_busy_ranges++;
+		spin_unlock(&fc->lock);
+	}
 	return 0;
 }
 
@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap, *alloc_dmap = NULL;
 	int ret;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* Can't do reclaim in fault path yet due to lock ordering.
 	 * Read path takes shared inode lock and that's not sufficient
@@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 
 	/* Setup one mapping */
 	ret = fuse_setup_one_mapping(inode,
-		ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ), alloc_dmap);
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     alloc_dmap, writable, false);
 	if (ret < 0) {
 		printk("fuse_setup_one_mapping() failed. err=%d"
-			" pos=0x%llx\n", ret, pos);
+			" pos=0x%llx, writable=%d\n", ret, pos, writable);
 		dmap_add_to_free_pool(fc, alloc_dmap);
 		up_write(&fi->i_dmap_sem);
 		return ret;
@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,
 	return 0;
 }
 
+static int iomap_begin_upgrade_mapping(struct inode *inode, loff_t pos,
+					 loff_t length, unsigned flags,
+					 struct iomap *iomap)
+{
+	struct fuse_inode *fi = get_fuse_inode(inode);
+	struct fuse_dax_mapping *dmap;
+	int ret;
+
+	/*
+	 * Take exclusive lock so that only one caller can try to setup
+	 * mapping and others wait.
+	 */
+	down_write(&fi->i_dmap_sem);
+	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
+
+	/* We are holding either inode lock or i_mmap_sem, and that should
+	 * ensure that dmap can't reclaimed or truncated and it should still
+	 * be there in tree despite the fact we dropped and re-acquired the
+	 * lock.
+	 */
+	ret = -EIO;
+	if (WARN_ON(!dmap))
+		goto out_err;
+
+	/* Maybe another thread already upgraded mapping while we were not
+	 * holding lock.
+	 */
+	if (dmap->writable)
+		goto out_fill_iomap;
+
+	ret = fuse_setup_one_mapping(inode,
+				     ALIGN_DOWN(pos, FUSE_DAX_MEM_RANGE_SZ),
+				     dmap, true, true);
+	if (ret < 0) {
+		printk("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n",
+		       ret, pos);
+		goto out_err;
+	}
+
+out_fill_iomap:
+	fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+out_err:
+	up_write(&fi->i_dmap_sem);
+	return ret;
+}
+
 /* This is just for DAX and the mapping is ephemeral, do not use it for other
  * purposes since there is no block device with a permanent mapping.
  */
@@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	struct fuse_inode *fi = get_fuse_inode(inode);
 	struct fuse_conn *fc = get_fuse_conn(inode);
 	struct fuse_dax_mapping *dmap;
+	bool writable = flags & IOMAP_WRITE;
 
 	/* We don't support FIEMAP */
 	BUG_ON(flags & IOMAP_REPORT);
@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
 	dmap = fuse_dax_interval_tree_iter_first(&fi->dmap_tree, pos, pos);
 
 	if (dmap) {
-		fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
-		up_read(&fi->i_dmap_sem);
-		return 0;
+		if (writable && !dmap->writable) {
+			/* Upgrade read-only mapping to read-write. This will
+			 * require exclusive i_dmap_sem lock as we don't want
+			 * two threads to be trying to this simultaneously
+			 * for same dmap. So drop shared lock and acquire
+			 * exclusive lock.
+			 */
+			up_read(&fi->i_dmap_sem);
+			pr_debug("%s: Upgrading mapping at offset 0x%llx"
+				 " length 0x%llx\n", __func__, pos, length);
+			return iomap_begin_upgrade_mapping(inode, pos, length,
+							   flags, iomap);
+		} else {
+			fuse_fill_iomap(inode, pos, length, iomap, dmap, flags);
+			up_read(&fi->i_dmap_sem);
+			return 0;
+		}
 	} else {
 		up_read(&fi->i_dmap_sem);
 		pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",
fs/fuse/fuse_i.h +3 -0
index e899a06e29d7..34ca8b90a1e1 100644
@@ -134,6 +134,9 @@ struct fuse_dax_mapping {
 
 	/** Length of mapping, in bytes */
 	loff_t length;
+
+	/* Is this mapping read-only or read-write */
+	bool writable;
 };
 
Quoted 2 lines

fs/fuse/fuse_i.h struct fuse_dax_mapping { · line 142

Quoted 2 lines
fs/fuse/fuse_i.h +0 -0
 /** FUSE inode */

.