From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A49F449F10A for ; Tue, 6 Oct 2026 18:01:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1791309704; cv=none; b=cUVmHk6PUHPDkKK5/M40BMK7dGZmWTEgig/H+UeFZyzNtDcMVwcOG+PezTRkpK889LXdNOrI9EVffUntRruyZ//8LOeoZA8L+qFZnV/SMycTmrk0b6+FdxKRPIFtXdCU0ex49xotYU6wfAj8I91URjXyTV3pPJU04mG4LYJ1KCs= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1791309704; c=relaxed/simple; bh=i7mT7pXewCXM235y8KXQzQ1MN4xioTNU2w3uqNNS+1A=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:content-type; b=cvMhL/2jV7NjdJnZ4kw07w61/AyrJpwbFJObSyCi9TJJuoLa9ItMliNzise55Zy3wZIEZfkDvuPKCkEKiN2cldpv27FCSV1BQ1DfAAyozLS25PKuvtzFQOcVzAx2FZcY6CvtvbHG6hncRXsSbV2IkR61eLplddfh7ymhZ1OR/hE= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=dZ0ifxZl; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="dZ0ifxZl" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1791309701; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=ZnS/KbxuQ9CYdcjb2BQBcgSshyIqB8n4a77KuFPKRm8=; b=dZ0ifxZlXSvKIKmc5UDRsiUiZcMOYRfuzxrxc/NtZ38+a2abv0cgNStS2Y3SdwrZjWxvJf M6GCNVYSjAfuhSzeMrV153dAFAtU0k7J6NqrOUkNFgKiaUdOXOCXGxm0iw/cFVVC02db/o KGqSBXiduQfIp7HHOBbvHIWhmUlVuxQ= Received: from mail-ed1-f70.google.com (mail-ed1-f70.google.com [209.85.208.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-456-OVCDS24WN-ePMR5DwcPB9g-1; Tue, 06 Oct 2026 14:01:37 -0400 X-MC-Unique: OVCDS24WN-ePMR5DwcPB9g-1 X-Mimecast-MFC-AGG-ID: OVCDS24WN-ePMR5DwcPB9g_1791309696 Received: by mail-ed1-f70.google.com with SMTP id 4fb4d7f45d1cf-6aa47eed2c3so4453638a12.2 for ; Tue, 06 Oct 2026 11:01:37 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1791309696; x=1791914496; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=ZnS/KbxuQ9CYdcjb2BQBcgSshyIqB8n4a77KuFPKRm8=; b=lMzfYdoNckNhSlwK6ThyjdFgsCYqQYjshYP/KG+Pjckg196tI1D0eUd7s/uGJzM11l heHBkNvjbO/MIQJILDDV6YWhGrxHII/M8aJ49A8ObaZhCEYRGQgoiRXZP31v7mC4jJ10 iw1eN5ZT2fIP6axYsWgiqqc2GU1W0XAg5392yt3p34Gjd76TR0lpfHzjVlOGV61EXI9i H3dntoNewr9NZQP8Bti0H3P7KvxkMl8cnZ+vvME8lhr8RHdfnkoDTFZ2pG2wtqHki2Zb Pva0ksP72gkyAli2p7n43x5UOoMo61ld4a9a8wHe939CajBUtBXsdE413fvXBHDN6TW8 PXUw== X-Forwarded-Encrypted: i=1; AKwUvBxlSNdpujQVdjCplKwx/4wGzNAFBdpFLgiq9Idq8hScly9G6PrUmEgcI4zW4PAbc/5YSwxtyjJPsxI=@vger.kernel.org X-Gm-Message-State: AFq9FYLIDHmiJvW3m8XwAOxTVgOXaO9gpd0ZTQrTh3E6XsWhdWeFYLrA /Rz2uaYrBs5+sv93LVXlmSCvhynIv+4TBmVnl89VJYcY2sbAx5AZN5hVQIKKe/qaA4zS1lK2orL HnrjwSdvJZQB+9uUSTagy2lxSvgXhD93A6hGXWvBcxcPFJ+/WqixHmEFpWKJjmA== X-Gm-Gg: AYBFou2iOwlKTv2zqDVKIfoFBWVGT/Pnc5ZMtHbFGCB2WhaIYfMj5YFAcRJhggBww6q A9DP0gkw0B1PCcD+EtJLjCCs5pOPn27ucQBc+vkCACaJkWgl4gYHubXwlcVEbJamVSyqi6wnvTX 8xizWv5Uk7YTtKn2jXl9BxwVkeLi6Y2aLCgmtJiDLk+66D9BOy095fmqPeqy67gF0fHYouyNDjn OCtafLPeRSqLnfi+mTJEykwD5As/wFScvnPo7wJ9vMdccEQY04LV0kDmYZzAP/LAYGMtDqVLSKS Hz2WgbFdLHkxQ8Fw+Ak6iy9ID2L883juuIzFMMH9t7TYieSDGoy09QGvgocK80ZIR+4GN8MUReI 5Cbl4a2p78QfvOTEFY5v4+gZ3657yAbCMz/GqK4Jv6h7mqp5xLf5WB6Bi X-Received: by 2002:a05:6402:4541:b0:6aa:e589:87d6 with SMTP id 4fb4d7f45d1cf-6afe2977ddbmr1805437a12.9.1791309695927; Tue, 06 Oct 2026 11:01:35 -0700 (PDT) X-Received: by 2002:a05:6402:4541:b0:6aa:e589:87d6 with SMTP id 4fb4d7f45d1cf-6afe2977ddbmr1805411a12.9.1791309695439; Tue, 06 Oct 2026 11:01:35 -0700 (PDT) Received: from maszat.piliscsaba.szeredi.hu (188-142-152-55.pool.digikabel.hu. [188.142.152.55]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-6afb01e5942sm5056684a12.9.2026.10.06.11.01.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 Oct 2026 11:01:33 -0700 (PDT) From: Miklos Szeredi To: fuse-devel@lists.linux.dev Cc: John Groves , Amir Goldstein , "Darrick J . Wong" , Vishal Verma , Dave Jiang , Alison Schofield , nvdimm@lists.linux.dev, linux-cxl@vger.kernel.org Subject: [PATCH v3 8/9] fuse: add extent map I/O support Date: Tue, 6 Oct 2026 20:01:13 +0200 Message-ID: <20261006180115.1425232-9-mszeredi@redhat.com> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20261006180115.1425232-1-mszeredi@redhat.com> References: <20261006180115.1425232-1-mszeredi@redhat.com> Precedence: bulk X-Mailing-List: linux-cxl@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-MFC-PROC-ID: HS-qie9bt8IB4ws3gWrL1mcFl5IsfiX_MtiYbP8lnXE_1791309696 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit content-type: text/plain; charset="US-ASCII"; x-default=true Wire up read, write, splice and mmap operations for extent-mapped files through the iomap/DAX infrastructure. When a passthrough file is opened with an EXTMAP backing, I/O is dispatched to the dax devices referenced by the extent map. If an address is not mapped, EIO is returned on the I/O operation. Originally-by: John Groves Reviewed-by: Amir Goldstein Signed-off-by: Miklos Szeredi --- fs/fuse/backing.c | 15 ++++ fs/fuse/ext_map.c | 161 ++++++++++++++++++++++++++++++++++++++++++ fs/fuse/file.c | 4 ++ fs/fuse/fuse_i.h | 4 ++ fs/fuse/notify.c | 3 + fs/fuse/passthrough.c | 29 ++++++-- 6 files changed, 210 insertions(+), 6 deletions(-) diff --git a/fs/fuse/backing.c b/fs/fuse/backing.c index b7ebc951dc31..c53538448dfb 100644 --- a/fs/fuse/backing.c +++ b/fs/fuse/backing.c @@ -288,6 +288,21 @@ int fuse_backing_close(struct fuse_conn *fc, int backing_id) return err; } +bool fuse_backing_is_dax(struct fuse_backing *fb) +{ + switch (fb->type) { + case FUSE_BACKING_PATH: + return false; + case FUSE_BACKING_DAXDEV: + return true; + case FUSE_BACKING_EXTMAP: + return fuse_ext_map_is_dax(fb); + default: + WARN_ON(1); + return false; + } +} + struct fuse_backing *fuse_backing_lookup(struct fuse_conn *fc, u64 backing_id) { struct fuse_backing *fb; diff --git a/fs/fuse/ext_map.c b/fs/fuse/ext_map.c index 39d7bb521873..4f418185c0b7 100644 --- a/fs/fuse/ext_map.c +++ b/fs/fuse/ext_map.c @@ -3,6 +3,14 @@ #include "fuse_i.h" #include #include +#include +#include + +#ifndef CONFIG_FS_DAX +#define dax_iomap_rw(...) (-EIO) +#define dax_iomap_fault(...) (-EIO) +#define dax_finish_sync_fault(...) (-EIO) +#endif struct fuse_iext { struct rb_node rb; @@ -22,6 +30,24 @@ void fuse_ext_map_destroy(struct rb_root *extents) } } +static struct fuse_iext *fuse_find_extent(struct rb_root *extents, u64 offset) +{ + struct rb_node *node = extents->rb_node; + + while (node) { + struct fuse_iext *fie = rb_entry(node, typeof(*fie), rb); + + if (offset < fie->start) + node = node->rb_left; + else if (offset >= fie->end) + node = node->rb_right; + else + return fie; + } + + return NULL; +} + static int fuse_add_extent(struct fuse_conn *fc, struct rb_root *extents, struct fuse_extent *ext) { @@ -78,6 +104,141 @@ static int fuse_add_extent(struct fuse_conn *fc, struct rb_root *extents, return 0; } +static int fuse_ext_map_iomap_begin(struct inode *inode, loff_t offset, loff_t length, + unsigned int flags, struct iomap *iomap, struct iomap *srcmap) +{ + struct fuse_backing *fb = fuse_inode_backing(get_fuse_inode(inode)); + struct fuse_iext *fie; + loff_t ext_len; + + if (!fb || fb->type != FUSE_BACKING_EXTMAP) + return fuse_EIO("missing or wrong type backing"); + + fie = fuse_find_extent(&fb->extents, offset); + if (!fie) + return fuse_EIO("missing mapping"); + + if (WARN_ON(fie->backing->type != FUSE_BACKING_DAXDEV)) + return fuse_EIO("wrong type backing for extent"); + + if (fie->backing->dax_error) { + fuse_make_bad(inode); + return fuse_EIO("dax error"); + } + + ext_len = fie->end - fie->start; + + iomap->offset = fie->start; + iomap->addr = fie->backing_offset; + iomap->length = ext_len; + iomap->dax_dev = fie->backing->dax_dev; + iomap->type = IOMAP_MAPPED; + iomap->flags = 0; + + return 0; +} + +static const struct iomap_ops fuse_ext_map_iomap_ops = { + .iomap_begin = fuse_ext_map_iomap_begin, +}; + +static vm_fault_t fuse_ext_map_huge_fault(struct vm_fault *vmf, unsigned int order) +{ + struct inode *inode = file_inode(vmf->vma->vm_file); + bool write_fault = (vmf->flags & FAULT_FLAG_WRITE) && (vmf->vma->vm_flags & VM_SHARED); + vm_fault_t ret; + unsigned long pfn; + + if (WARN_ON_ONCE(!IS_DAX(inode))) + return VM_FAULT_SIGBUS; + + if (write_fault) { + sb_start_pagefault(inode->i_sb); + file_update_time(vmf->vma->vm_file); + } + + filemap_invalidate_lock_shared(inode->i_mapping); + + ret = dax_iomap_fault(vmf, order, &pfn, NULL, &fuse_ext_map_iomap_ops); + if (ret & VM_FAULT_NEEDDSYNC) + ret = dax_finish_sync_fault(vmf, order, pfn); + + filemap_invalidate_unlock_shared(inode->i_mapping); + + if (write_fault) + sb_end_pagefault(inode->i_sb); + + return ret; +} + +static vm_fault_t fuse_ext_map_fault(struct vm_fault *vmf) +{ + return fuse_ext_map_huge_fault(vmf, 0); +} + +static const struct vm_operations_struct fuse_ext_map_vm_ops = { + .fault = fuse_ext_map_fault, + .huge_fault = fuse_ext_map_huge_fault, + .page_mkwrite = fuse_ext_map_fault, + .pfn_mkwrite = fuse_ext_map_fault, +}; + +static void fuse_rw_clamp(struct kiocb *iocb, struct iov_iter *ubuf) +{ + struct inode *inode = iocb->ki_filp->f_mapping->host; + loff_t i_size = i_size_read(inode); + loff_t max_count = iocb->ki_pos >= i_size ? 0 : i_size - iocb->ki_pos; + + if (iov_iter_count(ubuf) > max_count) + iov_iter_truncate(ubuf, max_count); +} + +ssize_t fuse_ext_map_read_iter(struct kiocb *iocb, struct iov_iter *to) +{ + struct inode *inode = iocb->ki_filp->f_mapping->host; + ssize_t res; + + guard(rwsem_read)(&inode->i_rwsem); + + fuse_rw_clamp(iocb, to); + + if (!iov_iter_count(to)) + return 0; + + res = dax_iomap_rw(iocb, to, &fuse_ext_map_iomap_ops); + + file_accessed(iocb->ki_filp); + return res; +} + +ssize_t fuse_ext_map_write_iter(struct kiocb *iocb, struct iov_iter *from) +{ + ssize_t res; + + res = generic_write_checks(iocb, from); + if (res <= 0) + return res; + + fuse_rw_clamp(iocb, from); + + if (!iov_iter_count(from)) + return -EFBIG; + + res = kiocb_modified(iocb); + if (res) + return res; + + return dax_iomap_rw(iocb, from, &fuse_ext_map_iomap_ops); +} + +int fuse_ext_map_mmap(struct file *file, struct vm_area_struct *vma) +{ + file_accessed(file); + vma->vm_ops = &fuse_ext_map_vm_ops; + vm_flags_set(vma, VM_HUGEPAGE); + return 0; +} + bool fuse_ext_map_is_dax(struct fuse_backing *fb) { struct fuse_iext *fie; diff --git a/fs/fuse/file.c b/fs/fuse/file.c index e0d72b9d3c4a..8d12d6162424 100644 --- a/fs/fuse/file.c +++ b/fs/fuse/file.c @@ -551,6 +551,10 @@ static int fuse_fsync(struct file *file, loff_t start, loff_t end, if (fuse_is_bad(inode)) return -EIO; + /* Skip sync for DAX inodes */ + if (IS_DAX(inode) && !fuse_inode_vdax(inode)) + return 0; + inode_lock(inode); /* diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h index 75eec5c17985..5d38dc1b6f0c 100644 --- a/fs/fuse/fuse_i.h +++ b/fs/fuse/fuse_i.h @@ -1324,6 +1324,7 @@ static inline void fuse_backing_put(struct fuse_backing *fb) struct fuse_backing *fuse_backing_lookup(struct fuse_conn *fc, u64 backing_id); int fuse_backing_add_64(struct fuse_conn *fc, struct fuse_backing *fb); +bool fuse_backing_is_dax(struct fuse_backing *fb); void fuse_backing_files_init(struct fuse_conn *fc); void fuse_backing_files_init_64(struct fuse_conn *fc); void fuse_backing_files_free(struct fuse_conn *fc); @@ -1377,6 +1378,9 @@ extern void fuse_sysctl_unregister(void); /* ext_map.c */ void fuse_ext_map_destroy(struct rb_root *extents); +ssize_t fuse_ext_map_write_iter(struct kiocb *iocb, struct iov_iter *from); +ssize_t fuse_ext_map_read_iter(struct kiocb *iocb, struct iov_iter *to); +int fuse_ext_map_mmap(struct file *file, struct vm_area_struct *vma); bool fuse_ext_map_is_dax(struct fuse_backing *fb); int fuse_ext_map_populate(struct fuse_conn *fc, struct fuse_notify_backing_map_out *arg, struct fuse_extent *ext); diff --git a/fs/fuse/notify.c b/fs/fuse/notify.c index 7c427f88bbc5..3bfedd0cdbdd 100644 --- a/fs/fuse/notify.c +++ b/fs/fuse/notify.c @@ -448,6 +448,9 @@ static int fuse_notify_map(struct fuse_conn *fc, unsigned int size, if (err) return err; + if (!fc->backing_id_64) + return -EINVAL; + if (outarg.num_extents > FUSE_MAX_EXTENTS) return -EINVAL; diff --git a/fs/fuse/passthrough.c b/fs/fuse/passthrough.c index e9ab1aea34e2..040817ad76e9 100644 --- a/fs/fuse/passthrough.c +++ b/fs/fuse/passthrough.c @@ -35,7 +35,6 @@ ssize_t fuse_passthrough_read_iter(struct kiocb *iocb, struct iov_iter *iter) struct fuse_file *ff = file->private_data; struct file *backing_file = fuse_file_passthrough(ff); size_t count = iov_iter_count(iter); - ssize_t ret; struct backing_file_ctx ctx = { .cred = ff->cred, .accessed = fuse_file_accessed, @@ -48,10 +47,10 @@ ssize_t fuse_passthrough_read_iter(struct kiocb *iocb, struct iov_iter *iter) if (!count) return 0; - ret = backing_file_read_iter(backing_file, iter, iocb, iocb->ki_flags, - &ctx); + if (!backing_file) + return fuse_ext_map_read_iter(iocb, iter); - return ret; + return backing_file_read_iter(backing_file, iter, iocb, iocb->ki_flags, &ctx); } ssize_t fuse_passthrough_write_iter(struct kiocb *iocb, @@ -74,10 +73,13 @@ ssize_t fuse_passthrough_write_iter(struct kiocb *iocb, if (!count) return 0; - inode_lock(inode); + guard(rwsem_write)(&inode->i_rwsem); + + if (!backing_file) + return fuse_ext_map_write_iter(iocb, iter); + ret = backing_file_write_iter(backing_file, iter, iocb, iocb->ki_flags, &ctx); - inode_unlock(inode); return ret; } @@ -98,6 +100,9 @@ ssize_t fuse_passthrough_splice_read(struct file *in, loff_t *ppos, pr_debug("%s: backing_file=0x%p, pos=%lld, len=%zu, flags=0x%x\n", __func__, backing_file, *ppos, len, flags); + if (!backing_file) + return copy_splice_read(in, ppos, pipe, len, flags); + init_sync_kiocb(&iocb, in); iocb.ki_pos = *ppos; ret = backing_file_splice_read(backing_file, &iocb, pipe, len, flags, &ctx); @@ -123,6 +128,9 @@ ssize_t fuse_passthrough_splice_write(struct pipe_inode_info *pipe, pr_debug("%s: backing_file=0x%p, pos=%lld, len=%zu, flags=0x%x\n", __func__, backing_file, *ppos, len, flags); + if (!backing_file) + return iter_file_splice_write(pipe, out, ppos, len, flags); + inode_lock(inode); init_sync_kiocb(&iocb, out); iocb.ki_pos = *ppos; @@ -145,6 +153,9 @@ ssize_t fuse_passthrough_mmap(struct file *file, struct vm_area_struct *vma) pr_debug("%s: backing_file=0x%p, start=%lu, end=%lu\n", __func__, backing_file, vma->vm_start, vma->vm_end); + if (!backing_file) + return fuse_ext_map_mmap(file, vma); + return backing_file_mmap(backing_file, vma, &ctx); } @@ -156,6 +167,12 @@ int fuse_passthrough_open(struct file *file, struct fuse_backing *fb) struct fuse_file *ff = file->private_data; struct file *backing_file; + if (fb->type == FUSE_BACKING_EXTMAP) { + if (fuse_backing_is_dax(fb) != !!IS_DAX(file_inode(file))) + return fuse_EIO("dax mode mismatch"); + return 0; + } + if (fb->type != FUSE_BACKING_PATH) return fuse_EIO("invalid backing type"); -- 2.54.0