Re: [PATCH 24/33] fuse: invalidate ranges of block devices being used for iomap

["Darrick J. Wong" <djwong@kernel.org>]

On Wed, Apr 29, 2026 at 07:29:56AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <djwong@kernel.org>
> 
> Make it easier to invalidate the page cache for a block device that is
> being used in conjunction with iomap.  This allows a fuse server to kill
> all cached data for a block that is being freed, so that block reuse
> doesn't result in file corruption.  Right now, the only way to do this
> is with fadvise, which ignores and doesn't wait for pages undergoing
> writeback.
> 
> Signed-off-by: "Darrick J. Wong" <djwong@kernel.org>
> ---
>  fs/fuse/fuse_iomap.h      |    3 +++
>  include/uapi/linux/fuse.h |   16 ++++++++++++++++
>  fs/fuse/dev.c             |   27 +++++++++++++++++++++++++++
>  fs/fuse/fuse_iomap.c      |   41 +++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 87 insertions(+)
> 
> 
> diff --git a/fs/fuse/fuse_iomap.h b/fs/fuse/fuse_iomap.h
> index 17d0507a243b59..31d6f7b392771c 100644
> --- a/fs/fuse/fuse_iomap.h
> +++ b/fs/fuse/fuse_iomap.h
> @@ -65,6 +65,8 @@ int fuse_iomap_flush_unmap_range(struct inode *inode, loff_t pos,
>  
>  int fuse_dev_ioctl_iomap_support(struct file *file,
>  				 struct fuse_iomap_support __user *argp);
> +int fuse_iomap_dev_inval(struct fuse_conn *fc,
> +			 const struct fuse_iomap_dev_inval_out *arg);
>  
>  int fuse_iomap_fadvise(struct file *file, loff_t start, loff_t end, int advice);
>  #else
> @@ -92,6 +94,7 @@ int fuse_iomap_fadvise(struct file *file, loff_t start, loff_t end, int advice);
>  # define fuse_iomap_fallocate(...)		(-ENOSYS)
>  # define fuse_iomap_flush_unmap_range(...)	(-ENOSYS)
>  # define fuse_dev_ioctl_iomap_support(...)	(-EOPNOTSUPP)
> +# define fuse_iomap_dev_inval(...)		(-ENOSYS)
>  # define fuse_iomap_fadvise			NULL
>  #endif /* CONFIG_FUSE_IOMAP */
>  
> diff --git a/include/uapi/linux/fuse.h b/include/uapi/linux/fuse.h
> index 33668d66e9c4b4..1ef7152306a24f 100644
> --- a/include/uapi/linux/fuse.h
> +++ b/include/uapi/linux/fuse.h
> @@ -247,6 +247,7 @@
>   *  - add FUSE_ATTR_EXCLUSIVE to enable exclusive mode for specific inodes
>   *  - add FUSE_ATTR_IOMAP to enable iomap for specific inodes
>   *  - add FUSE_IOMAP_CONFIG so the fuse server can configure more fs geometry
> + *  - add FUSE_NOTIFY_IOMAP_DEV_INVAL to invalidate iomap bdev ranges
>   */
>  
>  #ifndef _LINUX_FUSE_H
> @@ -701,6 +702,8 @@ enum fuse_notify_code {
>  	FUSE_NOTIFY_RESEND = 7,
>  	FUSE_NOTIFY_INC_EPOCH = 8,
>  	FUSE_NOTIFY_PRUNE = 9,
> +	FUSE_NOTIFY_IOMAP_DEV_INVAL = 99,
> +	FUSE_NOTIFY_CODE_MAX,
>  };
>  
>  /* The read buffer is required to be at least 8k, but may be much larger */
> @@ -1491,4 +1494,17 @@ struct fuse_iomap_config_out {
>  	int64_t s_maxbytes;	/* max file size */
>  };
>  
> +struct fuse_range {
> +	uint64_t offset;
> +	uint64_t length;
> +};
> +
> +struct fuse_iomap_dev_inval_out {
> +	uint32_t dev;		/* device cookie */
> +	uint32_t reserved;	/* zero */
> +
> +	/* range of bdev pagecache to invalidate, in bytes */
> +	struct fuse_range range;
> +};
> +
>  #endif /* _LINUX_FUSE_H */
> diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
> index 75e1e3f8a4ddd1..9918911fe44855 100644
> --- a/fs/fuse/dev.c
> +++ b/fs/fuse/dev.c
> @@ -1848,6 +1848,30 @@ static int fuse_notify_store(struct fuse_conn *fc, unsigned int size,
>  	return err;
>  }
>  
> +static int fuse_notify_iomap_dev_inval(struct fuse_conn *fc, unsigned int size,
> +				       struct fuse_copy_state *cs)
> +{
> +	struct fuse_iomap_dev_inval_out outarg;
> +	int err = -EINVAL;
> +
> +	if (size != sizeof(outarg))
> +		goto err;
> +
> +	err = fuse_copy_one(cs, &outarg, sizeof(outarg));
> +	if (err)
> +		goto err;
> +	if (outarg.reserved) {
> +		err = -EINVAL;
> +		goto err;
> +	}
> +	fuse_copy_finish(cs);
> +
> +	return fuse_iomap_dev_inval(fc, &outarg);
> +err:
> +	fuse_copy_finish(cs);
> +	return err;
> +}
> +
>  struct fuse_retrieve_args {
>  	struct fuse_args_pages ap;
>  	struct fuse_notify_retrieve_in inarg;
> @@ -2138,6 +2162,9 @@ static int fuse_notify(struct fuse_conn *fc, enum fuse_notify_code code,
>  	case FUSE_NOTIFY_PRUNE:
>  		return fuse_notify_prune(fc, size, cs);
>  
> +	case FUSE_NOTIFY_IOMAP_DEV_INVAL:
> +		return fuse_notify_iomap_dev_inval(fc, size, cs);
> +
>  	default:
>  		return -EINVAL;
>  	}
> diff --git a/fs/fuse/fuse_iomap.c b/fs/fuse/fuse_iomap.c
> index ad7c526545776e..fe937529543b0c 100644
> --- a/fs/fuse/fuse_iomap.c
> +++ b/fs/fuse/fuse_iomap.c
> @@ -2002,3 +2002,44 @@ int fuse_iomap_fadvise(struct file *file, loff_t start, loff_t end, int advice)
>  		inode_unlock_shared(inode);
>  	return ret;
>  }
> +
> +int fuse_iomap_dev_inval(struct fuse_conn *fc,
> +			 const struct fuse_iomap_dev_inval_out *arg)
> +{
> +	struct fuse_backing *fb;
> +	struct block_device *bdev;
> +	loff_t end;
> +	int ret = 0;
> +
> +	if (!fc->iomap || arg->dev == FUSE_IOMAP_DEV_NULL)
> +		return -EINVAL;
> +
> +	down_read(&fc->killsb);
> +	fb = fuse_backing_lookup(fc, &fuse_iomap_backing_ops, arg->dev);
> +	if (!fb) {
> +		ret = -ENODEV;
> +		goto out_killsb;
> +	}
> +	bdev = fb->bdev;
> +
> +	inode_lock(bdev->bd_mapping->host);
> +	filemap_invalidate_lock(bdev->bd_mapping);
> +
> +	if (check_add_overflow(arg->range.offset, arg->range.length, &end) ||

Codex complains here about weird behavior when length==0 -- if offset is
also 0, then it'll truncate the entire bdev pagecache.  If it's nonzero,
then it does nothing.

I think I'll just have it return 0 without doing any work in the
length==0 case.


> +	    arg->range.offset >= bdev_nr_bytes(bdev)) {
> +		ret = -EINVAL;
> +		goto out_unlock;
> +	}
> +
> +	end = min(end, bdev_nr_bytes(bdev));
> +	truncate_inode_pages_range(bdev->bd_mapping, arg->range.offset,
> +				   end - 1);

It also complains that truncate_inode_pages_range doesn't actually
truncate the pagecache for page-unaligned regions at the start and end
of the range.  This ioctl is intended for fuse servers that use the bdev
pagecache for metadata IO that have freed a block and want to make sure
that the kernel won't surreptitiously issue a writeback to that block
after (say) it gets allocated to file data and iomap writes the block.

I'll leave a comment documenting that motivation.

--D

> +
> +out_unlock:
> +	filemap_invalidate_unlock(bdev->bd_mapping);
> +	inode_unlock(bdev->bd_mapping->host);
> +	fuse_backing_put(fb);
> +out_killsb:
> +	up_read(&fc->killsb);
> +	return ret;
> +}
> 
>