Support direct file I/O operations for system_heap dma-buf objects.
Implementation includes:
1. Convert sg_table to bio_vec
2. Set IOCB_DIRECT when O_DIRECT is supported
3. Invoke vfs_iocb_iter_read()/vfs_iocb_iter_write() for actual I/O
Performance metrics (UFS 4.0 device @4GB/s, Arm64 CPU @1GHz):
| Metric | 1MB | 8MB | 64MB | 1024MB | 3072MB |
|--------------------|-------:|-------:|--------:|---------:|---------:|
| Buffer Read (us) | 1658 | 9028 | 69295 | 1019783 | 2978179 |
| Direct Read (us) | 707 | 2647 | 18689 | 299627 | 937758 |
| Buffer Rate (MB/s) | 603 | 886 | 924 | 1004 | 1032 |
| Direct Rate (MB/s) | 1414 | 3022 | 3425 | 3418 | 3276 |
Signed-off-by: wangtao <tao.wang...@honor.com>
---
drivers/dma-buf/heaps/system_heap.c | 118 ++++++++++++++++++++++++++++
1 file changed, 118 insertions(+)
diff --git a/drivers/dma-buf/heaps/system_heap.c
b/drivers/dma-buf/heaps/system_heap.c
index 26d5dc89ea16..f7b71b9843aa 100644
--- a/drivers/dma-buf/heaps/system_heap.c
+++ b/drivers/dma-buf/heaps/system_heap.c
@@ -20,6 +20,8 @@
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
+#include <linux/bvec.h>
+#include <linux/uio.h>
static struct dma_heap *sys_heap;
@@ -281,6 +283,121 @@ static void system_heap_vunmap(struct dma_buf *dmabuf,
struct iosys_map *map)
iosys_map_clear(map);
}
+static struct bio_vec *system_heap_init_bvec(struct system_heap_buffer *buffer,
+ size_t offset, size_t len, int *nr_segs)
+{
+ struct sg_table *sgt = &buffer->sg_table;
+ struct scatterlist *sg;
+ size_t length = 0;
+ unsigned int i, k = 0;
+ struct bio_vec *bvec;
+ size_t sg_left;
+ size_t sg_offset;
+ size_t sg_len;
+
+ bvec = kvcalloc(sgt->nents, sizeof(*bvec), GFP_KERNEL);
+ if (!bvec)
+ return NULL;
+
+ for_each_sg(sgt->sgl, sg, sgt->nents, i) {
+ length += sg->length;
+ if (length <= offset)
+ continue;
+
+ sg_left = length - offset;
+ sg_offset = sg->offset + sg->length - sg_left;
+ sg_len = min(sg_left, len);
+
+ bvec[k].bv_page = sg_page(sg);
+ bvec[k].bv_len = sg_len;
+ bvec[k].bv_offset = sg_offset;
+ k++;
+
+ offset += sg_len;
+ len -= sg_len;
+ if (len <= 0)
+ break;
+ }
+
+ *nr_segs = k;
+ return bvec;
+}
+
+static int system_heap_rw_file(struct system_heap_buffer *buffer, bool is_read,
+ bool direct_io, struct file *filp, loff_t file_offset,
+ size_t buf_offset, size_t len)
+{
+ struct bio_vec *bvec;
+ int nr_segs = 0;
+ struct iov_iter iter;
+ struct kiocb kiocb;
+ ssize_t ret = 0;
+
+ if (direct_io) {
+ if (!(filp->f_mode & FMODE_CAN_ODIRECT))
+ return -EINVAL;
+ }
+
+ bvec = system_heap_init_bvec(buffer, buf_offset, len, &nr_segs);
+ if (!bvec)
+ return -ENOMEM;
+
+ iov_iter_bvec(&iter, is_read ? ITER_DEST : ITER_SOURCE, bvec, nr_segs,
len);
+ init_sync_kiocb(&kiocb, filp);
+ kiocb.ki_pos = file_offset;
+ if (direct_io)
+ kiocb.ki_flags |= IOCB_DIRECT;
+
+ while (kiocb.ki_pos < file_offset + len) {
+ if (is_read)
+ ret = vfs_iocb_iter_read(filp, &kiocb, &iter);
+ else
+ ret = vfs_iocb_iter_write(filp, &kiocb, &iter);
+ if (ret <= 0)
+ break;
+ }
+
+ kvfree(bvec);
+ return ret < 0 ? ret : 0;
+}
+
+static int system_heap_dma_buf_rw_file(struct dma_buf *dmabuf,
+ struct dma_buf_rw_file *back)
+{
+ struct system_heap_buffer *buffer = dmabuf->priv;
+ int ret = 0;
+ __u32 op = back->flags & DMA_BUF_RW_FLAGS_OP_MASK;
+ bool direct_io = back->flags & DMA_BUF_RW_FLAGS_DIRECT;
+ struct file *filp;
+
+ if (op != DMA_BUF_RW_FLAGS_READ && op != DMA_BUF_RW_FLAGS_WRITE)
+ return -EINVAL;
+ if (direct_io) {
+ if (!PAGE_ALIGNED(back->file_offset) ||
+ !PAGE_ALIGNED(back->buf_offset) ||
+ !PAGE_ALIGNED(back->buf_len))
+ return -EINVAL;
+ }
+ if (!back->buf_len || back->buf_len > dmabuf->size ||
+ back->buf_offset >= dmabuf->size ||
+ back->buf_offset + back->buf_len > dmabuf->size)
+ return -EINVAL;
+ if (back->file_offset + back->buf_len < back->file_offset)
+ return -EINVAL;
+
+ filp = fget(back->fd);
+ if (!filp)
+ return -EBADF;
+
+ mutex_lock(&buffer->lock);
+ ret = system_heap_rw_file(buffer, op == DMA_BUF_RW_FLAGS_READ,
direct_io,
+ filp, back->file_offset, back->buf_offset,
back->buf_len);
+ mutex_unlock(&buffer->lock);
+
+ fput(filp);
+ return ret;
+}
+
static void system_heap_dma_buf_release(struct dma_buf *dmabuf)
{
struct system_heap_buffer *buffer = dmabuf->priv;
@@ -308,6 +425,7 @@ static const struct dma_buf_ops system_heap_buf_ops = {
.mmap = system_heap_mmap,
.vmap = system_heap_vmap,
.vunmap = system_heap_vunmap,
+ .rw_file = system_heap_dma_buf_rw_file,
.release = system_heap_dma_buf_release,
};
--
2.17.1
