File block-add-transfer-of-Protection-Informa.patch of Package qemu

Overview Repositories Revisions Requests Users Attributes Meta

File block-add-transfer-of-Protection-Informa.patch of Package qemu (Revision ebf8c8cb01b23cfc7ce787083b34bcc2)

Currently displaying revision ebf8c8cb01b23cfc7ce787083b34bcc2 , Show latest

From: Dmitry Tihov <d.tihov@yadro.com>
Date: Wed, 11 May 2022 14:36:53 +0000
Subject: block: add transfer of Protection Information

Under linux hosts, protection information can be passed from userspace
to integrity capable block device using io_uring API. Discover
integrity capable block devices and support submitting IO with
integrity payload to such block devices if it is present in request.

Signed-off-by: Dmitry Tihov <d.tihov@yadro.com>
---
 block/file-posix.c      | 130 ++++++++++++++++++++++++++++++++++++++--
 block/io_uring.c        |  30 +++++++++-
 include/block/block.h   |   2 +
 include/block/raw-aio.h |   3 +-
 include/qemu/iov.h      |   6 ++
 util/iov.c              |  22 +++++++
 6 files changed, 185 insertions(+), 8 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index b283093e5b7b4a0643dc82e3f5ce..552e75345f6cffe05a0e7121bf16 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -156,6 +156,10 @@ typedef struct BDRVRawState {
     int perm_change_flags;
     BDRVReopenState *reopen_state;
 
+    /* DIF T10 Protection Information */
+    uint8_t t10_type;
+    uint64_t protection_interval_bytes;
+
 #ifdef CONFIG_XFS
     bool is_xfs:1;
 #endif
@@ -2071,8 +2075,9 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
 #ifdef CONFIG_LINUX_IO_URING
     } else if (s->use_linux_io_uring) {
         LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
+        bool is_pi = (s->t10_type && qiov->dif.iov_len);
         assert(qiov->size == bytes);
-        return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
+        return luring_co_submit(bs, aio, s->fd, offset, qiov, type, is_pi);
 #endif
 #ifdef CONFIG_LINUX_AIO
     } else if (s->use_linux_aio) {
@@ -2168,7 +2173,7 @@ static int raw_co_flush_to_disk(BlockDriverState *bs)
 #ifdef CONFIG_LINUX_IO_URING
     if (s->use_linux_io_uring) {
         LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
-        return luring_co_submit(bs, aio, s->fd, 0, NULL, QEMU_AIO_FLUSH);
+        return luring_co_submit(bs, aio, s->fd, 0, NULL, QEMU_AIO_FLUSH, false);
     }
 #endif
     return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
@@ -3488,6 +3493,110 @@ static bool hdev_is_sg(BlockDriverState *bs)
     return false;
 }
 
+#if defined(CONFIG_LINUX_IO_URING)
+
+static int fill_pi_info(BlockDriverState *bs, Error **errp)
+{
+    BDRVRawState *s = bs->opaque;
+    int ret = 0, bytes;
+    uint64_t is_integrity_capable;
+    g_autofree char *sysfs_int_cap = NULL;
+    g_autofree char *sysfs_fmt = NULL;
+    g_autofree char *sysfs_bytes = NULL;
+    const char *str_int_cap;
+    const char *str_bytes;
+    int fd_fmt = -1, fd_bytes = -1, fd_int_cap = -1;
+    char buf[24] = {0};
+    g_autofree char *dev_name = g_path_get_basename(bs->filename);
+
+    str_int_cap = "/sys/class/block/%s/integrity/device_is_integrity_capable";
+    sysfs_int_cap = g_strdup_printf(str_int_cap, dev_name);
+    sysfs_fmt = g_strdup_printf("/sys/class/block/%s/integrity/format",
+                                dev_name);
+    str_bytes = "/sys/class/block/%s/integrity/protection_interval_bytes";
+    sysfs_bytes = g_strdup_printf(str_bytes, dev_name);
+
+    if (!(bs->open_flags & BDRV_O_NOCACHE)) {
+        goto out;
+    }
+
+    fd_int_cap = open(sysfs_int_cap, O_RDONLY);
+    if (fd_int_cap == -1) {
+        error_setg_errno(errp, errno, "Can not open %s integrity capability"
+                         " sysfs entry", dev_name);
+        ret = -errno;
+        goto out;
+    }
+    bytes = read(fd_int_cap, buf, sizeof(buf));
+    if (bytes < 0) {
+        error_setg_errno(errp, errno, "Can not read %s integrity capability"
+                         " sysfs entry", dev_name);
+        ret = -errno;
+        goto out;
+    }
+    is_integrity_capable = g_ascii_strtoull(buf, NULL, 10);
+    if (!is_integrity_capable) {
+        goto out;
+    }
+    memset(buf, 0, sizeof(buf));
+
+    fd_fmt = open(sysfs_fmt, O_RDONLY);
+    if (fd_fmt == -1) {
+        error_setg_errno(errp, errno, "Can not open %s integrity format"
+                         " sysfs entry", dev_name);
+        ret = -errno;
+        goto out;
+    }
+    bytes = read(fd_fmt, buf, sizeof(buf));
+    if (bytes < 0) {
+        error_setg_errno(errp, errno, "Can not read %s integrity format"
+                         " sysfs entry", dev_name);
+        ret = -errno;
+        goto out;
+    }
+    if (bytes > 0 && buf[bytes - 1] == '\n') {
+        buf[bytes - 1] = 0;
+    }
+    if (strcmp(buf, "T10-DIF-TYPE1-CRC") == 0) {
+        s->t10_type = 1;
+    } else if (strcmp(buf, "T10-DIF-TYPE3-CRC") == 0) {
+        s->t10_type = 3;
+    } else {
+        s->t10_type = 0;
+    }
+    memset(buf, 0, sizeof(buf));
+
+    fd_bytes = open(sysfs_bytes, O_RDONLY);
+    if (fd_bytes == -1) {
+        error_setg_errno(errp, errno, "Can not open %s protection interval"
+                         " bytes sysfs entry", dev_name);
+        ret = -errno;
+        goto out;
+    }
+    if (read(fd_bytes, buf, sizeof(buf)) < 0) {
+        error_setg_errno(errp, errno, "Can not read %s protection interval"
+                   " bytes sysfs entry", dev_name);
+        ret = -errno;
+        goto out;
+    }
+    s->protection_interval_bytes = g_ascii_strtoull(buf, NULL, 10);
+
+out:
+    if (fd_fmt != -1) {
+        close(fd_fmt);
+    }
+    if (fd_bytes != -1) {
+        close(fd_bytes);
+    }
+    if (fd_int_cap != -1) {
+        close(fd_int_cap);
+    }
+
+    return ret;
+}
+
+#endif
+
 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
 {
@@ -3573,6 +3682,11 @@ hdev_open_Mac_error:
     /* Since this does ioctl the device must be already opened */
     bs->sg = hdev_is_sg(bs);
 
+#if defined(CONFIG_LINUX_IO_URING)
+    if (s->use_linux_io_uring) {
+        ret = fill_pi_info(bs, errp);
+    }
+#endif
     return ret;
 }
 
@@ -3640,6 +3754,14 @@ static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
     return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
 }
 
+static int hdev_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
+{
+    BDRVRawState *s = bs->opaque;
+    bdi->protection_interval = s->protection_interval_bytes;
+    bdi->protection_type = s->t10_type;
+    return 0;
+}
+
 static BlockDriver bdrv_host_device = {
     .format_name        = "host_device",
     .protocol_name        = "host_device",
@@ -3670,8 +3792,8 @@ static BlockDriver bdrv_host_device = {
     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
 
     .bdrv_co_truncate       = raw_co_truncate,
-    .bdrv_getlength	= raw_getlength,
-    .bdrv_get_info = raw_get_info,
+    .bdrv_getlength         = raw_getlength,
+    .bdrv_get_info          = hdev_get_info,
     .bdrv_get_allocated_file_size
                         = raw_get_allocated_file_size,
     .bdrv_get_specific_stats = hdev_get_specific_stats,
diff --git a/block/io_uring.c b/block/io_uring.c
index dfa475cc874650e67d3d7c362cd8..018a28e13602978cfb6593c340c6 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -22,6 +22,8 @@
 /* io_uring ring size */
 #define MAX_ENTRIES 128
 
+#define IOSQE_IO_WITH_PI  (1U << 6)
+
 typedef struct LuringAIOCB {
     Coroutine *co;
     struct io_uring_sqe sqeq;
@@ -147,6 +149,7 @@ static void luring_process_completions(LuringState *s)
     while (io_uring_peek_cqe(&s->ring, &cqes) == 0) {
         LuringAIOCB *luringcb;
         int ret;
+        QEMUIOVector *qiov;
 
         if (!cqes) {
             break;
@@ -157,6 +160,13 @@ static void luring_process_completions(LuringState *s)
         io_uring_cqe_seen(&s->ring, cqes);
         cqes = NULL;
 
+        /* pop integrity metadata iovec from iovs */
+        qiov = luringcb->qiov;
+        if (qiov && qiov->niov >= 2 &&
+            qiov->iov[qiov->niov - 1].iov_base == qiov->dif.iov_base) {
+            qemu_iovec_discard_back(qiov, qiov->dif.iov_len);
+        }
+
         /* Change counters one-by-one because we can be nested. */
         s->io_q.in_flight--;
         trace_luring_process_completion(s, luringcb, ret);
@@ -333,22 +343,31 @@ void luring_io_unplug(BlockDriverState *bs, LuringState *s)
  * @s: AIO state
  * @offset: offset for request
  * @type: type of request
+ * @is_pi: is protection information attached
  *
  * Fetches sqes from ring, adds to pending queue and preps them
  *
  */
 static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
-                            uint64_t offset, int type)
+                            uint64_t offset, int type, bool is_pi)
 {
     int ret;
     struct io_uring_sqe *sqes = &luringcb->sqeq;
 
     switch (type) {
     case QEMU_AIO_WRITE:
+        if (is_pi) {
+            qemu_iovec_add(luringcb->qiov, luringcb->qiov->dif.iov_base,
+                           luringcb->qiov->dif.iov_len);
+        }
         io_uring_prep_writev(sqes, fd, luringcb->qiov->iov,
                              luringcb->qiov->niov, offset);
         break;
     case QEMU_AIO_READ:
+        if (is_pi) {
+            qemu_iovec_add(luringcb->qiov, luringcb->qiov->dif.iov_base,
+                           luringcb->qiov->dif.iov_len);
+        }
         io_uring_prep_readv(sqes, fd, luringcb->qiov->iov,
                             luringcb->qiov->niov, offset);
         break;
@@ -360,6 +379,9 @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
                         __func__, type);
         abort();
     }
+    if (luringcb && luringcb->qiov && is_pi) {
+        sqes->flags = IOSQE_IO_WITH_PI;
+    }
     io_uring_sqe_set_data(sqes, luringcb);
 
     QSIMPLEQ_INSERT_TAIL(&s->io_q.submit_queue, luringcb, next);
@@ -377,7 +399,8 @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
 }
 
 int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
-                                  uint64_t offset, QEMUIOVector *qiov, int type)
+                                  uint64_t offset, QEMUIOVector *qiov, int type,
+                                  bool is_pi)
 {
     int ret;
     LuringAIOCB luringcb = {
@@ -386,9 +409,10 @@ int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
         .qiov       = qiov,
         .is_read    = (type == QEMU_AIO_READ),
     };
+
     trace_luring_co_submit(bs, s, &luringcb, fd, offset, qiov ? qiov->size : 0,
                            type);
-    ret = luring_do_submit(fd, &luringcb, s, offset, type);
+    ret = luring_do_submit(fd, &luringcb, s, offset, type, is_pi);
 
     if (ret < 0) {
         return ret;
diff --git a/include/block/block.h b/include/block/block.h
index e5dd22b03435b6d7972fb8cf991c..739a30f7bd9eadb93851b6a8beb5 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -36,6 +36,8 @@ typedef struct BlockDriverInfo {
      * True if this block driver only supports compressed writes
      */
     bool needs_compressed_writes;
+    uint8_t protection_type;
+    uint32_t protection_interval;
 } BlockDriverInfo;
 
 typedef struct BlockFragInfo {
diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
index 21fc10c4c96b733d71301abf72c1..3f715b4bcc67f6177525d4d6c814 100644
--- a/include/block/raw-aio.h
+++ b/include/block/raw-aio.h
@@ -65,7 +65,8 @@ typedef struct LuringState LuringState;
 LuringState *luring_init(Error **errp);
 void luring_cleanup(LuringState *s);
 int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
-                                uint64_t offset, QEMUIOVector *qiov, int type);
+                                uint64_t offset, QEMUIOVector *qiov, int type,
+                                bool is_pi);
 void luring_detach_aio_context(LuringState *s, AioContext *old_context);
 void luring_attach_aio_context(LuringState *s, AioContext *new_context);
 void luring_io_plug(BlockDriverState *bs, LuringState *s);
diff --git a/include/qemu/iov.h b/include/qemu/iov.h
index 93307466809b6faf7727128edb2b..58ae2d1f51334956737435e15cf6 100644
--- a/include/qemu/iov.h
+++ b/include/qemu/iov.h
@@ -181,6 +181,9 @@ typedef struct QEMUIOVector {
             size_t size;
         };
     };
+
+    /* T10 data integrity field */
+    struct iovec dif;
 } QEMUIOVector;
 
 QEMU_BUILD_BUG_ON(offsetof(QEMUIOVector, size) !=
@@ -229,6 +232,9 @@ int qemu_iovec_init_extended(
         void *tail_buf, size_t tail_len);
 void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
                            size_t offset, size_t len);
+void qemu_iovec_init_pi(QEMUIOVector *qiov, int alloc_hint,
+                        unsigned int lba_cnt);
+void qemu_iovec_destroy_pi(QEMUIOVector *qiov);
 int qemu_iovec_subvec_niov(QEMUIOVector *qiov, size_t offset, size_t len);
 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
 void qemu_iovec_concat(QEMUIOVector *dst,
diff --git a/util/iov.c b/util/iov.c
index 58c7b3eeee5ffed2a42dfec82ff7..6b6ceb1b792585d6e18804bf4602 100644
--- a/util/iov.c
+++ b/util/iov.c
@@ -273,6 +273,8 @@ void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
     qiov->niov = 0;
     qiov->nalloc = alloc_hint;
     qiov->size = 0;
+    qiov->dif.iov_base = NULL;
+    qiov->dif.iov_len = 0;
 }
 
 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
@@ -287,6 +289,18 @@ void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
         qiov->size += iov[i].iov_len;
 }
 
+void qemu_iovec_init_pi(QEMUIOVector *qiov, int alloc_hint,
+                        unsigned int lba_cnt)
+{
+    void *alignd_mem = NULL;
+    qemu_iovec_init(qiov, alloc_hint);
+
+    /* dif size is always 8 bytes */
+    qiov->dif.iov_len = lba_cnt << 3;
+    alignd_mem = qemu_memalign(qemu_real_host_page_size, qiov->dif.iov_len);
+    qiov->dif.iov_base = memset(alignd_mem, 0, qiov->dif.iov_len);
+}
+
 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
 {
     assert(qiov->nalloc != -1);
@@ -525,12 +539,20 @@ void qemu_iovec_destroy(QEMUIOVector *qiov)
     memset(qiov, 0, sizeof(*qiov));
 }
 
+void qemu_iovec_destroy_pi(QEMUIOVector *qiov)
+{
+    g_free(qiov->dif.iov_base);
+
+    qemu_iovec_destroy(qiov);
+}
+
 void qemu_iovec_reset(QEMUIOVector *qiov)
 {
     assert(qiov->nalloc != -1);
 
     qiov->niov = 0;
     qiov->size = 0;
+    qiov->dif.iov_len = 0;
 }
 
 size_t qemu_iovec_to_buf(QEMUIOVector *qiov, size_t offset,

Places

File block-add-transfer-of-Protection-Informa.patch of Package qemu (Revision ebf8c8cb01b23cfc7ce787083b34bcc2)

Places