* [PATCH 0/9] Support persistent reservation operations
@ 2024-05-08 9:36 Changqi Lu
2024-05-08 9:36 ` [PATCH 1/9] block: add persistent reservation in/out api Changqi Lu
` (9 more replies)
0 siblings, 10 replies; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu
Hi,
I am going to introduce persistent reservation for QEMU block.
There are three parts in this series:
Firstly, at the block layer, the commit abstracts seven APIs related to
the persistent reservation command. These APIs including reading keys,
reading reservations, registering, reserving, releasing, clearing and preempting.
Next, the commit implements the necessary pr-related operation APIs for both the
SCSI protocol and NVMe protocol at the device layer. This ensures that the necessary
functionality is available for handling persistent reservations in these protocols.
Finally, the commit includes adaptations to the iscsi driver at the driver layer
to verify the correct implementation and functionality of the changes.
With these changes, GFS works fine in the guest. Also, sg-utils(for SCSI block) and
nvme-cli(for NVMe block) work fine too.
Changqi Lu (9):
block: add persistent reservation in/out api
block/raw: add persistent reservation in/out driver
scsi/constant: add persistent reservation in/out protocol constants
scsi/util: add helper functions for persistent reservation types
conversion
hw/scsi: add persistent reservation in/out api for scsi device
block/nvme: add reservation command protocol constants
hw/nvme: add helper functions for converting reservation types
hw/nvme: add reservation protocal command
block/iscsi: add persistent reservation in/out driver
block/block-backend.c | 386 +++++++++++++++++++++++++++++
block/io.c | 161 ++++++++++++
block/iscsi.c | 390 ++++++++++++++++++++++++++++++
block/raw-format.c | 55 +++++
hw/nvme/ctrl.c | 304 ++++++++++++++++++++++-
hw/nvme/nvme.h | 44 ++++
hw/scsi/scsi-disk.c | 302 +++++++++++++++++++++++
include/block/block-common.h | 9 +
include/block/block-io.h | 19 ++
include/block/block_int-common.h | 31 +++
include/block/nvme.h | 67 +++++
include/scsi/constants.h | 29 +++
include/scsi/utils.h | 5 +
include/sysemu/block-backend-io.h | 22 ++
scsi/utils.c | 40 +++
15 files changed, 1863 insertions(+), 1 deletion(-)
--
2.20.1
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 1/9] block: add persistent reservation in/out api
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 18:22 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 2/9] block/raw: add persistent reservation in/out driver Changqi Lu
` (8 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
Add persistent reservation in/out operations
at the block level. The following operations
are included:
- read_keys: retrieves the list of registered keys.
- read_reservation: retrieves the current reservation status.
- register: registers a new reservation key.
- reserve: initiates a reservation for a specific key.
- release: releases a reservation for a specific key.
- clear: clears all existing reservations.
- preempt: preempts a reservation held by another key.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
block/block-backend.c | 386 ++++++++++++++++++++++++++++++
block/io.c | 161 +++++++++++++
include/block/block-common.h | 9 +
include/block/block-io.h | 19 ++
include/block/block_int-common.h | 31 +++
include/sysemu/block-backend-io.h | 22 ++
6 files changed, 628 insertions(+)
diff --git a/block/block-backend.c b/block/block-backend.c
index db6f9b92a3..ec67937d28 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -1770,6 +1770,392 @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
}
+typedef struct BlkPrInCo {
+ BlockBackend *blk;
+ uint32_t *generation;
+ uint32_t num_keys;
+ BlockPrType *type;
+ uint64_t *keys;
+ int ret;
+} BlkPrInCo;
+
+typedef struct BlkPrInCB {
+ BlockAIOCB common;
+ BlkPrInCo prco;
+ bool has_returned;
+} BlkPrInCB;
+
+static const AIOCBInfo blk_pr_in_aiocb_info = {
+ .aiocb_size = sizeof(BlkPrInCB),
+};
+
+static void blk_pr_in_complete(BlkPrInCB *acb)
+{
+ if (acb->has_returned) {
+ acb->common.cb(acb->common.opaque, acb->prco.ret);
+ blk_dec_in_flight(acb->prco.blk);
+ qemu_aio_unref(acb);
+ }
+}
+
+static void blk_pr_in_complete_bh(void *opaque)
+{
+ BlkPrInCB *acb = opaque;
+ assert(acb->has_returned);
+ blk_pr_in_complete(acb);
+}
+
+static BlockAIOCB *blk_aio_pr_in(BlockBackend *blk, uint32_t *generation,
+ uint32_t num_keys, BlockPrType *type,
+ uint64_t *keys, CoroutineEntry co_entry,
+ BlockCompletionFunc *cb, void *opaque)
+{
+ BlkPrInCB *acb;
+ Coroutine *co;
+
+ blk_inc_in_flight(blk);
+ acb = blk_aio_get(&blk_pr_in_aiocb_info, blk, cb, opaque);
+ acb->prco = (BlkPrInCo) {
+ .blk = blk,
+ .generation = generation,
+ .num_keys = num_keys,
+ .type = type,
+ .ret = NOT_DONE,
+ .keys = keys,
+ };
+ acb->has_returned = false;
+
+ co = qemu_coroutine_create(co_entry, acb);
+ aio_co_enter(qemu_get_current_aio_context(), co);
+
+ acb->has_returned = true;
+ if (acb->prco.ret != NOT_DONE) {
+ replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
+ blk_pr_in_complete_bh, acb);
+ }
+
+ return &acb->common;
+}
+
+
+static int coroutine_fn
+blk_aio_pr_do_read_keys(BlockBackend *blk, uint32_t *generation,
+ uint32_t num_keys, uint64_t *keys)
+{
+ IO_CODE();
+
+ blk_wait_while_drained(blk);
+ GRAPH_RDLOCK_GUARD();
+
+ if (!blk_co_is_available(blk)) {
+ return -ENOMEDIUM;
+ }
+
+ return bdrv_co_pr_read_keys(blk_bs(blk), generation, num_keys, keys);
+}
+
+static void coroutine_fn blk_aio_pr_read_keys_entry(void *opaque)
+{
+ BlkPrInCB *acb = opaque;
+ BlkPrInCo *prco = &acb->prco;
+
+ prco->ret = blk_aio_pr_do_read_keys(prco->blk, prco->generation,
+ prco->num_keys, prco->keys);
+ blk_pr_in_complete(acb);
+}
+
+BlockAIOCB *blk_aio_pr_read_keys(BlockBackend *blk, uint32_t *generation,
+ uint32_t num_keys, uint64_t *keys,
+ BlockCompletionFunc *cb, void *opaque)
+{
+ IO_CODE();
+ return blk_aio_pr_in(blk, generation, num_keys, NULL, keys,
+ blk_aio_pr_read_keys_entry, cb, opaque);
+}
+
+
+static int coroutine_fn
+blk_aio_pr_do_read_reservation(BlockBackend *blk, uint32_t *generation,
+ uint64_t *key, BlockPrType *type)
+{
+ IO_CODE();
+
+ blk_wait_while_drained(blk);
+ GRAPH_RDLOCK_GUARD();
+
+ if (!blk_co_is_available(blk)) {
+ return -ENOMEDIUM;
+ }
+
+ return bdrv_co_pr_read_reservation(blk_bs(blk), generation, key, type);
+}
+
+static void coroutine_fn blk_aio_pr_read_reservation_entry(void *opaque)
+{
+ BlkPrInCB *acb = opaque;
+ BlkPrInCo *prco = &acb->prco;
+
+ prco->ret = blk_aio_pr_do_read_reservation(prco->blk, prco->generation,
+ prco->keys, prco->type);
+ blk_pr_in_complete(acb);
+}
+
+BlockAIOCB *blk_aio_pr_read_reservation(BlockBackend *blk, uint32_t *generation,
+ uint64_t *key, BlockPrType *type,
+ BlockCompletionFunc *cb, void *opaque)
+{
+ IO_CODE();
+ return blk_aio_pr_in(blk, generation, 0, type, key,
+ blk_aio_pr_read_reservation_entry, cb, opaque);
+}
+
+
+typedef struct BlkPrOutCo {
+ BlockBackend *blk;
+ uint64_t old_key;
+ uint64_t new_key;
+ BlockPrType type;
+ bool ignore_key;
+ bool abort;
+ int ret;
+} BlkPrOutCo;
+
+typedef struct BlkPrOutCB {
+ BlockAIOCB common;
+ BlkPrOutCo prco;
+ bool has_returned;
+} BlkPrOutCB;
+
+static const AIOCBInfo blk_pr_out_aiocb_info = {
+ .aiocb_size = sizeof(BlkPrOutCB),
+};
+
+static void blk_pr_out_complete(BlkPrOutCB *acb)
+{
+ if (acb->has_returned) {
+ acb->common.cb(acb->common.opaque, acb->prco.ret);
+ blk_dec_in_flight(acb->prco.blk);
+ qemu_aio_unref(acb);
+ }
+}
+
+static void blk_pr_out_complete_bh(void *opaque)
+{
+ BlkPrOutCB *acb = opaque;
+ assert(acb->has_returned);
+ blk_pr_out_complete(acb);
+}
+
+static BlockAIOCB *blk_aio_pr_out(BlockBackend *blk, uint64_t old_key,
+ uint64_t new_key, BlockPrType type,
+ bool ignore_key, bool abort,
+ CoroutineEntry co_entry,
+ BlockCompletionFunc *cb, void *opaque)
+{
+ BlkPrOutCB *acb;
+ Coroutine *co;
+
+ blk_inc_in_flight(blk);
+ acb = blk_aio_get(&blk_pr_out_aiocb_info, blk, cb, opaque);
+ acb->prco = (BlkPrOutCo) {
+ .blk = blk,
+ .old_key = old_key,
+ .new_key = new_key,
+ .type = type,
+ .ignore_key = ignore_key,
+ .abort = abort,
+ .ret = NOT_DONE,
+ };
+ acb->has_returned = false;
+
+ co = qemu_coroutine_create(co_entry, acb);
+ aio_co_enter(qemu_get_current_aio_context(), co);
+
+ acb->has_returned = true;
+ if (acb->prco.ret != NOT_DONE) {
+ replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
+ blk_pr_out_complete_bh, acb);
+ }
+
+ return &acb->common;
+}
+
+static int coroutine_fn
+blk_aio_pr_do_register(BlockBackend *blk, uint64_t old_key,
+ uint64_t new_key, BlockPrType type,
+ bool ignore_key)
+{
+ IO_CODE();
+
+ blk_wait_while_drained(blk);
+ GRAPH_RDLOCK_GUARD();
+
+ if (!blk_co_is_available(blk)) {
+ return -ENOMEDIUM;
+ }
+
+ return bdrv_co_pr_register(blk_bs(blk), old_key, new_key, type, ignore_key);
+}
+
+static void coroutine_fn blk_aio_pr_register_entry(void *opaque)
+{
+ BlkPrOutCB *acb = opaque;
+ BlkPrOutCo *prco = &acb->prco;
+
+ prco->ret = blk_aio_pr_do_register(prco->blk, prco->old_key, prco->new_key,
+ prco->type, prco->ignore_key);
+ blk_pr_out_complete(acb);
+}
+
+BlockAIOCB *blk_aio_pr_register(BlockBackend *blk, uint64_t old_key,
+ uint64_t new_key, BlockPrType type,
+ bool ignore_key, BlockCompletionFunc *cb,
+ void *opaque)
+{
+ IO_CODE();
+ return blk_aio_pr_out(blk, old_key, new_key, type, ignore_key, false,
+ blk_aio_pr_register_entry, cb, opaque);
+}
+
+static int coroutine_fn
+blk_aio_pr_do_reserve(BlockBackend *blk, uint64_t key, BlockPrType type)
+{
+ IO_CODE();
+
+ blk_wait_while_drained(blk);
+ GRAPH_RDLOCK_GUARD();
+
+ if (!blk_co_is_available(blk)) {
+ return -ENOMEDIUM;
+ }
+
+ return bdrv_co_pr_reserve(blk_bs(blk), key, type);
+}
+
+static void coroutine_fn blk_aio_pr_reserve_entry(void *opaque)
+{
+ BlkPrOutCB *acb = opaque;
+ BlkPrOutCo *prco = &acb->prco;
+
+ prco->ret = blk_aio_pr_do_reserve(prco->blk, prco->old_key, prco->type);
+ blk_pr_out_complete(acb);
+}
+
+
+BlockAIOCB *blk_aio_pr_reserve(BlockBackend *blk, uint64_t key,
+ BlockPrType type, BlockCompletionFunc *cb,
+ void *opaque)
+{
+ IO_CODE();
+ return blk_aio_pr_out(blk, key, 0, type, false, false,
+ blk_aio_pr_reserve_entry, cb, opaque);
+}
+
+static int coroutine_fn
+blk_aio_pr_do_release(BlockBackend *blk, uint64_t key, BlockPrType type)
+{
+ IO_CODE();
+
+ blk_wait_while_drained(blk);
+ GRAPH_RDLOCK_GUARD();
+
+ if (!blk_co_is_available(blk)) {
+ return -ENOMEDIUM;
+ }
+
+ return bdrv_co_pr_release(blk_bs(blk), key, type);
+}
+
+static void coroutine_fn blk_aio_pr_release_entry(void *opaque)
+{
+ BlkPrOutCB *acb = opaque;
+ BlkPrOutCo *prco = &acb->prco;
+
+ prco->ret = blk_aio_pr_do_release(prco->blk, prco->old_key, prco->type);
+ blk_pr_out_complete(acb);
+}
+
+
+BlockAIOCB *blk_aio_pr_release(BlockBackend *blk, uint64_t key,
+ BlockPrType type, BlockCompletionFunc *cb,
+ void *opaque)
+{
+ IO_CODE();
+ return blk_aio_pr_out(blk, key, 0, type, false, false,
+ blk_aio_pr_release_entry, cb, opaque);
+}
+
+static int coroutine_fn
+blk_aio_pr_do_clear(BlockBackend *blk, uint64_t key)
+{
+ IO_CODE();
+
+ blk_wait_while_drained(blk);
+ GRAPH_RDLOCK_GUARD();
+
+ if (!blk_co_is_available(blk)) {
+ return -ENOMEDIUM;
+ }
+
+ return bdrv_co_pr_clear(blk_bs(blk), key);
+}
+
+static void coroutine_fn blk_aio_pr_clear_entry(void *opaque)
+{
+ BlkPrOutCB *acb = opaque;
+ BlkPrOutCo *prco = &acb->prco;
+
+ prco->ret = blk_aio_pr_do_clear(prco->blk, prco->old_key);
+ blk_pr_out_complete(acb);
+}
+
+
+BlockAIOCB *blk_aio_pr_clear(BlockBackend *blk, uint64_t key,
+ BlockCompletionFunc *cb, void *opaque)
+{
+ IO_CODE();
+ return blk_aio_pr_out(blk, key, 0, 0, false, false,
+ blk_aio_pr_clear_entry, cb, opaque);
+}
+
+static int coroutine_fn
+blk_aio_pr_do_preempt(BlockBackend *blk, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool abort)
+{
+ IO_CODE();
+
+ blk_wait_while_drained(blk);
+ GRAPH_RDLOCK_GUARD();
+
+ if (!blk_co_is_available(blk)) {
+ return -ENOMEDIUM;
+ }
+
+ return bdrv_co_pr_preempt(blk_bs(blk), old_key, new_key, type, abort);
+}
+
+static void coroutine_fn blk_aio_pr_preempt_entry(void *opaque)
+{
+ BlkPrOutCB *acb = opaque;
+ BlkPrOutCo *prco = &acb->prco;
+
+ prco->ret = blk_aio_pr_do_preempt(prco->blk, prco->old_key,
+ prco->new_key, prco->type,
+ prco->abort);
+ blk_pr_out_complete(acb);
+}
+
+
+BlockAIOCB *blk_aio_pr_preempt(BlockBackend *blk, uint64_t old_key,
+ uint64_t new_key, BlockPrType type,
+ bool abort, BlockCompletionFunc *cb,
+ void *opaque)
+{
+ IO_CODE();
+ return blk_aio_pr_out(blk, old_key, new_key, type, false, abort,
+ blk_aio_pr_preempt_entry, cb, opaque);
+}
+
/* To be called between exactly one pair of blk_inc/dec_in_flight() */
static int coroutine_fn
blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
diff --git a/block/io.c b/block/io.c
index 7217cf811b..98a358c6b2 100644
--- a/block/io.c
+++ b/block/io.c
@@ -3220,6 +3220,167 @@ out:
return co.ret;
}
+int coroutine_fn bdrv_co_pr_read_keys(BlockDriverState *bs,
+ uint32_t *generation, uint32_t num_keys,
+ uint64_t *keys)
+{
+ BlockDriver *drv = bs->drv;
+ CoroutineIOCompletion co = {
+ .coroutine = qemu_coroutine_self(),
+ };
+
+ IO_CODE();
+ assert_bdrv_graph_readable();
+
+ bdrv_inc_in_flight(bs);
+ if (!drv || !drv->bdrv_co_pr_read_keys) {
+ co.ret = -ENOTSUP;
+ goto out;
+ }
+
+ co.ret = drv->bdrv_co_pr_read_keys(bs, generation, num_keys, keys);
+out:
+ bdrv_dec_in_flight(bs);
+ return co.ret;
+}
+
+int coroutine_fn bdrv_co_pr_read_reservation(BlockDriverState *bs,
+ uint32_t *generation, uint64_t *key, BlockPrType *type)
+{
+ BlockDriver *drv = bs->drv;
+ CoroutineIOCompletion co = {
+ .coroutine = qemu_coroutine_self(),
+ };
+
+ IO_CODE();
+ assert_bdrv_graph_readable();
+
+ bdrv_inc_in_flight(bs);
+ if (!drv || !drv->bdrv_co_pr_read_reservation) {
+ co.ret = -ENOTSUP;
+ goto out;
+ }
+
+ co.ret = drv->bdrv_co_pr_read_reservation(bs, generation, key, type);
+out:
+ bdrv_dec_in_flight(bs);
+ return co.ret;
+}
+
+int coroutine_fn bdrv_co_pr_register(BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool ignore_key)
+{
+ BlockDriver *drv = bs->drv;
+ CoroutineIOCompletion co = {
+ .coroutine = qemu_coroutine_self(),
+ };
+
+ IO_CODE();
+ assert_bdrv_graph_readable();
+
+ bdrv_inc_in_flight(bs);
+ if (!drv || !drv->bdrv_co_pr_register) {
+ co.ret = -ENOTSUP;
+ goto out;
+ }
+
+ co.ret = drv->bdrv_co_pr_register(bs, old_key, new_key, type, ignore_key);
+out:
+ bdrv_dec_in_flight(bs);
+ return co.ret;
+}
+
+int coroutine_fn bdrv_co_pr_reserve(BlockDriverState *bs, uint64_t key,
+ BlockPrType type)
+{
+ BlockDriver *drv = bs->drv;
+ CoroutineIOCompletion co = {
+ .coroutine = qemu_coroutine_self(),
+ };
+
+ IO_CODE();
+ assert_bdrv_graph_readable();
+
+ bdrv_inc_in_flight(bs);
+ if (!drv || !drv->bdrv_co_pr_reserve) {
+ co.ret = -ENOTSUP;
+ goto out;
+ }
+
+ co.ret = drv->bdrv_co_pr_reserve(bs, key, type);
+out:
+ bdrv_dec_in_flight(bs);
+ return co.ret;
+}
+
+int coroutine_fn bdrv_co_pr_release(BlockDriverState *bs, uint64_t key,
+ BlockPrType type)
+{
+ BlockDriver *drv = bs->drv;
+ CoroutineIOCompletion co = {
+ .coroutine = qemu_coroutine_self(),
+ };
+
+ IO_CODE();
+ assert_bdrv_graph_readable();
+
+ bdrv_inc_in_flight(bs);
+ if (!drv || !drv->bdrv_co_pr_release) {
+ co.ret = -ENOTSUP;
+ goto out;
+ }
+
+ co.ret = drv->bdrv_co_pr_release(bs, key, type);
+out:
+ bdrv_dec_in_flight(bs);
+ return co.ret;
+}
+
+int coroutine_fn bdrv_co_pr_clear(BlockDriverState *bs, uint64_t key)
+{
+ BlockDriver *drv = bs->drv;
+ CoroutineIOCompletion co = {
+ .coroutine = qemu_coroutine_self(),
+ };
+
+ IO_CODE();
+ assert_bdrv_graph_readable();
+
+ bdrv_inc_in_flight(bs);
+ if (!drv || !drv->bdrv_co_pr_clear) {
+ co.ret = -ENOTSUP;
+ goto out;
+ }
+
+ co.ret = drv->bdrv_co_pr_clear(bs, key);
+out:
+ bdrv_dec_in_flight(bs);
+ return co.ret;
+}
+
+int coroutine_fn bdrv_co_pr_preempt(BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool abort)
+{
+ BlockDriver *drv = bs->drv;
+ CoroutineIOCompletion co = {
+ .coroutine = qemu_coroutine_self(),
+ };
+
+ IO_CODE();
+ assert_bdrv_graph_readable();
+
+ bdrv_inc_in_flight(bs);
+ if (!drv || !drv->bdrv_co_pr_preempt) {
+ co.ret = -ENOTSUP;
+ goto out;
+ }
+
+ co.ret = drv->bdrv_co_pr_preempt(bs, old_key, new_key, type, abort);
+out:
+ bdrv_dec_in_flight(bs);
+ return co.ret;
+}
+
int coroutine_fn bdrv_co_zone_report(BlockDriverState *bs, int64_t offset,
unsigned int *nr_zones,
BlockZoneDescriptor *zones)
diff --git a/include/block/block-common.h b/include/block/block-common.h
index a846023a09..c078d69f79 100644
--- a/include/block/block-common.h
+++ b/include/block/block-common.h
@@ -524,6 +524,15 @@ typedef enum {
BDRV_FIX_ERRORS = 2,
} BdrvCheckMode;
+typedef enum {
+ BLK_PR_WRITE_EXCLUSIVE = 0x1,
+ BLK_PR_EXCLUSIVE_ACCESS = 0x2,
+ BLK_PR_WRITE_EXCLUSIVE_REGS_ONLY = 0x3,
+ BLK_PR_EXCLUSIVE_ACCESS_REGS_ONLY = 0x4,
+ BLK_PR_WRITE_EXCLUSIVE_ALL_REGS = 0x5,
+ BLK_PR_EXCLUSIVE_ACCESS_ALL_REGS = 0x6,
+} BlockPrType;
+
typedef struct BlockSizes {
uint32_t phys;
uint32_t log;
diff --git a/include/block/block-io.h b/include/block/block-io.h
index b49e0537dd..f2827cd74e 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -106,6 +106,25 @@ void bdrv_aio_cancel_async(BlockAIOCB *acb);
int coroutine_fn GRAPH_RDLOCK
bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
+int coroutine_fn GRAPH_RDLOCK
+bdrv_co_pr_read_keys(BlockDriverState *bs, uint32_t *generation,
+ uint32_t num_keys, uint64_t *keys);
+int coroutine_fn GRAPH_RDLOCK
+bdrv_co_pr_read_reservation(BlockDriverState *bs, uint32_t *generation,
+ uint64_t *key, BlockPrType *type);
+int coroutine_fn GRAPH_RDLOCK
+bdrv_co_pr_register(BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool ignore_key);
+int coroutine_fn GRAPH_RDLOCK
+bdrv_co_pr_reserve(BlockDriverState *bs, uint64_t key, BlockPrType type);
+int coroutine_fn GRAPH_RDLOCK
+bdrv_co_pr_release(BlockDriverState *bs, uint64_t key, BlockPrType type);
+int coroutine_fn GRAPH_RDLOCK
+bdrv_co_pr_clear(BlockDriverState *bs, uint64_t key);
+int coroutine_fn GRAPH_RDLOCK
+bdrv_co_pr_preempt(BlockDriverState *bs, uint64_t old_key, uint64_t new_key,
+ BlockPrType type, bool abort);
+
/* Ensure contents are flushed to disk. */
int coroutine_fn GRAPH_RDLOCK bdrv_co_flush(BlockDriverState *bs);
diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
index 761276127e..e5526f1d04 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -766,6 +766,37 @@ struct BlockDriver {
int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_ioctl)(
BlockDriverState *bs, unsigned long int req, void *buf);
+ /**
+ * bdrv_co_pr_read_keys is called to read the registered keys,
+ * @num_keys is the maximum number of keys that can be transmitted.
+ * On success, store generation in @generation and store keys @keys
+ * and return the number of @keys.
+ * On failure return -errno.
+ */
+ int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_read_keys)(
+ BlockDriverState *bs, uint32_t *generation,
+ uint32_t num_keys, uint64_t *keys);
+ int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_read_reservation)(
+ BlockDriverState *bs, uint32_t *generation,
+ uint64_t *key, BlockPrType *type);
+
+ /**
+ * Persist Through Power Loss(PTPL) is considered as required in QEMU
+ * block layer, the block driver need always enable PTPL.
+ */
+ int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_register)(
+ BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool ignore_key);
+ int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_reserve)(
+ BlockDriverState *bs, uint64_t key, BlockPrType type);
+ int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_release)(
+ BlockDriverState *bs, uint64_t key, BlockPrType type);
+ int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_clear)(
+ BlockDriverState *bs, uint64_t key);
+ int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_preempt)(
+ BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool abort);
+
/*
* Returns 0 for completed check, -errno for internal errors.
* The check results are stored in result.
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index d174275a5c..f87c61c06e 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -62,6 +62,28 @@ void blk_aio_cancel_async(BlockAIOCB *acb);
BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
BlockCompletionFunc *cb, void *opaque);
+BlockAIOCB *blk_aio_pr_read_keys(BlockBackend *blk, uint32_t *generation,
+ uint32_t num_keys, uint64_t *keys,
+ BlockCompletionFunc *cb, void *opaque);
+BlockAIOCB *blk_aio_pr_read_reservation(BlockBackend *blk, uint32_t *generation,
+ uint64_t *key, BlockPrType *type,
+ BlockCompletionFunc *cb, void *opaque);
+BlockAIOCB *blk_aio_pr_register(BlockBackend *blk, uint64_t old_key,
+ uint64_t new_key, BlockPrType type,
+ bool ignore_key, BlockCompletionFunc *cb,
+ void *opaque);
+BlockAIOCB *blk_aio_pr_reserve(BlockBackend *blk, uint64_t key,
+ BlockPrType type, BlockCompletionFunc *cb,
+ void *opaque);
+BlockAIOCB *blk_aio_pr_release(BlockBackend *blk, uint64_t key,
+ BlockPrType type, BlockCompletionFunc *cb,
+ void *opaque);
+BlockAIOCB *blk_aio_pr_clear(BlockBackend *blk, uint64_t key,
+ BlockCompletionFunc *cb, void *opaque);
+BlockAIOCB *blk_aio_pr_preempt(BlockBackend *blk, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool abort,
+ BlockCompletionFunc *cb, void *opaque);
+
void blk_inc_in_flight(BlockBackend *blk);
void blk_dec_in_flight(BlockBackend *blk);
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 2/9] block/raw: add persistent reservation in/out driver
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
2024-05-08 9:36 ` [PATCH 1/9] block: add persistent reservation in/out api Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 18:23 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 3/9] scsi/constant: add persistent reservation in/out protocol constants Changqi Lu
` (7 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
Add persistent reservation in/out operations for raw driver.
The following methods are implemented: bdrv_co_pr_read_keys,
bdrv_co_pr_read_reservation, bdrv_co_pr_register, bdrv_co_pr_reserve,
bdrv_co_pr_release, bdrv_co_pr_clear and bdrv_co_pr_preempt.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
block/raw-format.c | 55 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 55 insertions(+)
diff --git a/block/raw-format.c b/block/raw-format.c
index ac7e8495f6..7ba5b12101 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -454,6 +454,54 @@ raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
return bdrv_co_ioctl(bs->file->bs, req, buf);
}
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pr_read_keys(BlockDriverState *bs, uint32_t *generation,
+ uint32_t num_keys, uint64_t *keys)
+{
+
+ return bdrv_co_pr_read_keys(bs->file->bs, generation, num_keys, keys);
+}
+
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pr_read_reservation(BlockDriverState *bs, uint32_t *generation,
+ uint64_t *key, BlockPrType *type)
+{
+ return bdrv_co_pr_read_reservation(bs->file->bs, generation, key, type);
+}
+
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pr_register(BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool ignore_key)
+{
+ return bdrv_co_pr_register(bs->file->bs, old_key, new_key,
+ type, ignore_key);
+}
+
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pr_reserve(BlockDriverState *bs, uint64_t key, BlockPrType type)
+{
+ return bdrv_co_pr_reserve(bs->file->bs, key, type);
+}
+
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pr_release(BlockDriverState *bs, uint64_t key, BlockPrType type)
+{
+ return bdrv_co_pr_release(bs->file->bs, key, type);
+}
+
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pr_clear(BlockDriverState *bs, uint64_t key)
+{
+ return bdrv_co_pr_clear(bs->file->bs, key);
+}
+
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_pr_preempt(BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool abort)
+{
+ return bdrv_co_pr_preempt(bs->file->bs, old_key, new_key, type, abort);
+}
+
static int GRAPH_RDLOCK raw_has_zero_init(BlockDriverState *bs)
{
return bdrv_has_zero_init(bs->file->bs);
@@ -672,6 +720,13 @@ BlockDriver bdrv_raw = {
.strong_runtime_opts = raw_strong_runtime_opts,
.mutable_opts = mutable_opts,
.bdrv_cancel_in_flight = raw_cancel_in_flight,
+ .bdrv_co_pr_read_keys = raw_co_pr_read_keys,
+ .bdrv_co_pr_read_reservation = raw_co_pr_read_reservation,
+ .bdrv_co_pr_register = raw_co_pr_register,
+ .bdrv_co_pr_reserve = raw_co_pr_reserve,
+ .bdrv_co_pr_release = raw_co_pr_release,
+ .bdrv_co_pr_clear = raw_co_pr_clear,
+ .bdrv_co_pr_preempt = raw_co_pr_preempt,
};
static void bdrv_raw_init(void)
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 3/9] scsi/constant: add persistent reservation in/out protocol constants
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
2024-05-08 9:36 ` [PATCH 1/9] block: add persistent reservation in/out api Changqi Lu
2024-05-08 9:36 ` [PATCH 2/9] block/raw: add persistent reservation in/out driver Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 18:28 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 4/9] scsi/util: add helper functions for persistent reservation types conversion Changqi Lu
` (6 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
Add constants for the persistent reservation in/out protocol
in the scsi/constant module. The constants include the persistent
reservation command, type, and scope values defined in sections
6.13 and 6.14 of the SCSI Primary Commands-4 (SPC-4) specification.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
include/scsi/constants.h | 29 +++++++++++++++++++++++++++++
1 file changed, 29 insertions(+)
diff --git a/include/scsi/constants.h b/include/scsi/constants.h
index 9b98451912..511cb3d03e 100644
--- a/include/scsi/constants.h
+++ b/include/scsi/constants.h
@@ -319,4 +319,33 @@
#define IDENT_DESCR_TGT_DESCR_SIZE 32
#define XCOPY_BLK2BLK_SEG_DESC_SIZE 28
+typedef enum {
+ SCSI_PR_WRITE_EXCLUSIVE = 0x01,
+ SCSI_PR_EXCLUSIVE_ACCESS = 0x03,
+ SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY = 0x05,
+ SCSI_PR_EXCLUSIVE_ACCESS_REGS_ONLY = 0x06,
+ SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS = 0x07,
+ SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS = 0x08,
+} SCSIPrType;
+
+typedef enum {
+ SCSI_PR_LU_SCOPE = 0x00,
+} SCSIPrScope;
+
+typedef enum {
+ SCSI_PR_OUT_REGISTER = 0x0,
+ SCSI_PR_OUT_RESERVE = 0x1,
+ SCSI_PR_OUT_RELEASE = 0x2,
+ SCSI_PR_OUT_CLEAR = 0x3,
+ SCSI_PR_OUT_PREEMPT = 0x4,
+ SCSI_PR_OUT_PREEMPT_AND_ABORT = 0x5,
+ SCSI_PR_OUT_REG_AND_IGNORE_KEY = 0x6,
+ SCSI_PR_OUT_REG_AND_MOVE = 0x7,
+} SCSIPrOutAction;
+
+typedef enum {
+ SCSI_PR_IN_READ_KEYS = 0x0,
+ SCSI_PR_IN_READ_RESERVATION = 0x1,
+} SCSIPrInAction;
+
#endif
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 4/9] scsi/util: add helper functions for persistent reservation types conversion
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
` (2 preceding siblings ...)
2024-05-08 9:36 ` [PATCH 3/9] scsi/constant: add persistent reservation in/out protocol constants Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 18:28 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device Changqi Lu
` (5 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
This commit introduces two helper functions
that facilitate the conversion between the
persistent reservation types used in the SCSI
protocol and those used in the block layer.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
include/scsi/utils.h | 5 +++++
scsi/utils.c | 40 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 45 insertions(+)
diff --git a/include/scsi/utils.h b/include/scsi/utils.h
index d5c8efa16e..8212860231 100644
--- a/include/scsi/utils.h
+++ b/include/scsi/utils.h
@@ -1,6 +1,8 @@
#ifndef SCSI_UTILS_H
#define SCSI_UTILS_H
+#include "block/block-common.h"
+#include "scsi/constants.h"
#ifdef CONFIG_LINUX
#include <scsi/sg.h>
#endif
@@ -135,6 +137,9 @@ uint32_t scsi_data_cdb_xfer(uint8_t *buf);
uint32_t scsi_cdb_xfer(uint8_t *buf);
int scsi_cdb_length(uint8_t *buf);
+BlockPrType scsi_pr_type_to_block(SCSIPrType type);
+SCSIPrType block_pr_type_to_scsi(BlockPrType type);
+
/* Linux SG_IO interface. */
#ifdef CONFIG_LINUX
#define SG_ERR_DRIVER_TIMEOUT 0x06
diff --git a/scsi/utils.c b/scsi/utils.c
index 357b036671..381803c81c 100644
--- a/scsi/utils.c
+++ b/scsi/utils.c
@@ -658,3 +658,43 @@ int scsi_sense_from_host_status(uint8_t host_status,
}
return GOOD;
}
+
+BlockPrType scsi_pr_type_to_block(SCSIPrType type)
+{
+ switch (type) {
+ case SCSI_PR_WRITE_EXCLUSIVE:
+ return BLK_PR_WRITE_EXCLUSIVE;
+ case SCSI_PR_EXCLUSIVE_ACCESS:
+ return BLK_PR_EXCLUSIVE_ACCESS;
+ case SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY:
+ return BLK_PR_WRITE_EXCLUSIVE_REGS_ONLY;
+ case SCSI_PR_EXCLUSIVE_ACCESS_REGS_ONLY:
+ return BLK_PR_EXCLUSIVE_ACCESS_REGS_ONLY;
+ case SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS:
+ return BLK_PR_WRITE_EXCLUSIVE_ALL_REGS;
+ case SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS:
+ return BLK_PR_EXCLUSIVE_ACCESS_ALL_REGS;
+ }
+
+ return 0;
+}
+
+SCSIPrType block_pr_type_to_scsi(BlockPrType type)
+{
+ switch (type) {
+ case BLK_PR_WRITE_EXCLUSIVE:
+ return SCSI_PR_WRITE_EXCLUSIVE;
+ case BLK_PR_EXCLUSIVE_ACCESS:
+ return SCSI_PR_EXCLUSIVE_ACCESS;
+ case BLK_PR_WRITE_EXCLUSIVE_REGS_ONLY:
+ return SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY;
+ case BLK_PR_EXCLUSIVE_ACCESS_REGS_ONLY:
+ return SCSI_PR_EXCLUSIVE_ACCESS_REGS_ONLY;
+ case BLK_PR_WRITE_EXCLUSIVE_ALL_REGS:
+ return SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS;
+ case BLK_PR_EXCLUSIVE_ACCESS_ALL_REGS:
+ return SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS;
+ }
+
+ return 0;
+}
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
` (3 preceding siblings ...)
2024-05-08 9:36 ` [PATCH 4/9] scsi/util: add helper functions for persistent reservation types conversion Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 18:45 ` Stefan Hajnoczi
2024-05-09 19:09 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 6/9] block/nvme: add reservation command protocol constants Changqi Lu
` (4 subsequent siblings)
9 siblings, 2 replies; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
Add persistent reservation in/out operations in the
SCSI device layer. By introducing the persistent
reservation in/out api, this enables the SCSI device
to perform reservation-related tasks, including querying
keys, querying reservation status, registering reservation
keys, initiating and releasing reservations, as well as
clearing and preempting reservations held by other keys.
These operations are crucial for management and control of
shared storage resources in a persistent manner.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
hw/scsi/scsi-disk.c | 302 ++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 302 insertions(+)
diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
index 4bd7af9d0c..bdd66c4026 100644
--- a/hw/scsi/scsi-disk.c
+++ b/hw/scsi/scsi-disk.c
@@ -32,6 +32,7 @@
#include "migration/vmstate.h"
#include "hw/scsi/emulation.h"
#include "scsi/constants.h"
+#include "scsi/utils.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h"
#include "hw/block/block.h"
@@ -1474,6 +1475,296 @@ static void scsi_disk_emulate_read_data(SCSIRequest *req)
scsi_req_complete(&r->req, GOOD);
}
+typedef struct SCSIPrReadKeys {
+ uint32_t generation;
+ uint32_t num_keys;
+ uint64_t *keys;
+ void *req;
+} SCSIPrReadKeys;
+
+typedef struct SCSIPrReadReservation {
+ uint32_t generation;
+ uint64_t key;
+ BlockPrType type;
+ void *req;
+} SCSIPrReadReservation;
+
+static void scsi_pr_read_keys_complete(void *opaque, int ret)
+{
+ int num_keys;
+ uint8_t *buf;
+ SCSIPrReadKeys *blk_keys = (SCSIPrReadKeys *)opaque;
+ SCSIDiskReq *r = (SCSIDiskReq *)blk_keys->req;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
+
+ assert(blk_get_aio_context(s->qdev.conf.blk) ==
+ qemu_get_current_aio_context());
+
+ assert(r->req.aiocb != NULL);
+ r->req.aiocb = NULL;
+
+ if (scsi_disk_req_check_error(r, ret, true)) {
+ goto done;
+ }
+
+ buf = scsi_req_get_buf(&r->req);
+ num_keys = MIN(blk_keys->num_keys, ret);
+ blk_keys->generation = cpu_to_be32(blk_keys->generation);
+ memcpy(&buf[0], &blk_keys->generation, 4);
+ for (int i = 0; i < num_keys; i++) {
+ blk_keys->keys[i] = cpu_to_be64(blk_keys->keys[i]);
+ memcpy(&buf[8 + i * 8], &blk_keys->keys[i], 8);
+ }
+ num_keys = cpu_to_be32(num_keys * 8);
+ memcpy(&buf[4], &num_keys, 4);
+
+ scsi_req_data(&r->req, r->buflen);
+done:
+ scsi_req_unref(&r->req);
+ g_free(blk_keys->keys);
+ g_free(blk_keys);
+}
+
+static int scsi_disk_emulate_pr_read_keys(SCSIRequest *req)
+{
+ SCSIPrReadKeys *blk_keys;
+ SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
+ int buflen = MIN(r->req.cmd.xfer, r->buflen);
+ int num_keys = (buflen - sizeof(uint32_t) * 2) / sizeof(uint64_t);
+
+ blk_keys = g_new0(SCSIPrReadKeys, 1);
+ blk_keys->generation = 0;
+ /* num_keys is the maximum number of keys that can be transmitted */
+ blk_keys->num_keys = num_keys;
+ blk_keys->keys = g_malloc(sizeof(uint64_t) * num_keys);
+ blk_keys->req = r;
+
+ scsi_req_ref(&r->req);
+ r->req.aiocb = blk_aio_pr_read_keys(s->qdev.conf.blk, &blk_keys->generation,
+ blk_keys->num_keys, blk_keys->keys,
+ scsi_pr_read_keys_complete, blk_keys);
+ return 0;
+}
+
+static void scsi_pr_read_reservation_complete(void *opaque, int ret)
+{
+ uint8_t *buf;
+ uint32_t num_keys = 0;
+ SCSIPrReadReservation *blk_rsv = (SCSIPrReadReservation *)opaque;
+ SCSIDiskReq *r = (SCSIDiskReq *)blk_rsv->req;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
+
+ assert(blk_get_aio_context(s->qdev.conf.blk) ==
+ qemu_get_current_aio_context());
+
+ assert(r->req.aiocb != NULL);
+ r->req.aiocb = NULL;
+
+ if (scsi_disk_req_check_error(r, ret, true)) {
+ goto done;
+ }
+
+ buf = scsi_req_get_buf(&r->req);
+ blk_rsv->generation = cpu_to_be32(blk_rsv->generation);
+ memcpy(&buf[0], &blk_rsv->generation, 4);
+ if (ret) {
+ num_keys = cpu_to_be32(16);
+ blk_rsv->key = cpu_to_be64(blk_rsv->key);
+ memcpy(&buf[8], &blk_rsv->key, 8);
+ buf[21] = block_pr_type_to_scsi(blk_rsv->type) & 0xf;
+ } else {
+ num_keys = cpu_to_be32(0);
+ }
+
+ memcpy(&buf[4], &num_keys, 4);
+ scsi_req_data(&r->req, r->buflen);
+
+done:
+ scsi_req_unref(&r->req);
+ g_free(blk_rsv);
+}
+
+static int scsi_disk_emulate_pr_read_reservation(SCSIRequest *req)
+{
+ SCSIPrReadReservation *blk_rsv;
+ SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
+
+ blk_rsv = g_malloc(sizeof(*blk_rsv));
+ blk_rsv->generation = 0;
+ blk_rsv->key = 0;
+ blk_rsv->type = 0;
+ blk_rsv->req = r;
+
+ scsi_req_ref(&r->req);
+ r->req.aiocb = blk_aio_pr_read_reservation(s->qdev.conf.blk,
+ &blk_rsv->generation, &blk_rsv->key, &blk_rsv->type,
+ scsi_pr_read_reservation_complete, blk_rsv);
+ return 0;
+}
+
+static void scsi_aio_pr_complete(void *opaque, int ret)
+{
+ SCSIDiskReq *r = (SCSIDiskReq *)opaque;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
+
+ /* The request must only run in the BlockBackend's AioContext */
+ assert(blk_get_aio_context(s->qdev.conf.blk) ==
+ qemu_get_current_aio_context());
+
+ assert(r->req.aiocb != NULL);
+ r->req.aiocb = NULL;
+
+ if (scsi_disk_req_check_error(r, ret, true)) {
+ goto done;
+ }
+
+ scsi_req_complete(&r->req, GOOD);
+
+done:
+ scsi_req_unref(&r->req);
+}
+
+static int scsi_disk_emulate_pr_register(SCSIDiskReq *r, uint64_t old_key,
+ uint64_t new_key, SCSIPrType type,
+ bool ignore_key)
+{
+ SCSIRequest *req = &r->req;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
+
+ scsi_req_ref(&r->req);
+ r->req.aiocb = blk_aio_pr_register(s->qdev.conf.blk, old_key, new_key,
+ scsi_pr_type_to_block(type),
+ ignore_key, scsi_aio_pr_complete, r);
+
+ return 0;
+}
+
+static int scsi_disk_emulate_pr_reserve(SCSIDiskReq *r, uint64_t key,
+ SCSIPrType type)
+{
+ SCSIRequest *req = &r->req;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
+
+ scsi_req_ref(&r->req);
+ r->req.aiocb = blk_aio_pr_reserve(s->qdev.conf.blk, key,
+ scsi_pr_type_to_block(type),
+ scsi_aio_pr_complete, r);
+
+ return 0;
+}
+
+static int scsi_disk_emulate_pr_release(SCSIDiskReq *r, uint64_t key,
+ SCSIPrType type)
+{
+ SCSIRequest *req = &r->req;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
+
+ scsi_req_ref(&r->req);
+ r->req.aiocb = blk_aio_pr_release(s->qdev.conf.blk, key,
+ scsi_pr_type_to_block(type),
+ scsi_aio_pr_complete, r);
+
+ return 0;
+}
+
+static int scsi_disk_emulate_pr_clear(SCSIDiskReq *r, uint64_t key)
+{
+ SCSIRequest *req = &r->req;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
+
+ scsi_req_ref(&r->req);
+ r->req.aiocb = blk_aio_pr_clear(s->qdev.conf.blk, key,
+ scsi_aio_pr_complete, r);
+
+ return 0;
+}
+
+static int scsi_disk_emulate_pr_preempt(SCSIDiskReq *r, uint64_t new_key,
+ uint64_t old_key, SCSIPrType type,
+ bool abort)
+{
+ SCSIRequest *req = &r->req;
+ SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
+
+ scsi_req_ref(&r->req);
+ r->req.aiocb = blk_aio_pr_preempt(s->qdev.conf.blk, new_key, old_key,
+ scsi_pr_type_to_block(type), abort,
+ scsi_aio_pr_complete, r);
+
+ return 0;
+}
+
+static int scsi_disk_emulate_pr_in(SCSIRequest *req)
+{
+ int rc;
+ SCSIPrInAction action = req->cmd.buf[1] & 0x1f;
+
+ switch (action) {
+ case SCSI_PR_IN_READ_KEYS:
+ rc = scsi_disk_emulate_pr_read_keys(req);
+ break;
+ case SCSI_PR_IN_READ_RESERVATION:
+ rc = scsi_disk_emulate_pr_read_reservation(req);
+ break;
+ default:
+ return -ENOTSUP;
+ }
+
+ return rc;
+}
+
+static int scsi_disk_emulate_pr_out(SCSIDiskReq *r, uint8_t *inbuf)
+{
+ int rc;
+ uint64_t old_key, new_key;
+ SCSIPrOutAction action;
+ SCSIPrScope scope;
+ SCSIPrType type;
+ SCSIRequest *req = &r->req;
+
+ memcpy(&old_key, &inbuf[0], 8);
+ old_key = be64_to_cpu(old_key);
+ memcpy(&new_key, &inbuf[8], 8);
+ new_key = be64_to_cpu(new_key);
+ action = req->cmd.buf[1] & 0x1f;
+ scope = (req->cmd.buf[2] >> 4) & 0x0f;
+ type = req->cmd.buf[2] & 0x0f;
+
+ if (scope != SCSI_PR_LU_SCOPE) {
+ return -ENOTSUP;
+ }
+
+ switch (action) {
+ case SCSI_PR_OUT_REGISTER:
+ rc = scsi_disk_emulate_pr_register(r, old_key, new_key, type, false);
+ break;
+ case SCSI_PR_OUT_REG_AND_IGNORE_KEY:
+ rc = scsi_disk_emulate_pr_register(r, old_key, new_key, type, true);
+ break;
+ case SCSI_PR_OUT_RESERVE:
+ rc = scsi_disk_emulate_pr_reserve(r, old_key, type);
+ break;
+ case SCSI_PR_OUT_RELEASE:
+ rc = scsi_disk_emulate_pr_release(r, old_key, type);
+ break;
+ case SCSI_PR_OUT_CLEAR:
+ rc = scsi_disk_emulate_pr_clear(r, old_key);
+ break;
+ case SCSI_PR_OUT_PREEMPT:
+ rc = scsi_disk_emulate_pr_preempt(r, old_key, new_key, type, false);
+ break;
+ case SCSI_PR_OUT_PREEMPT_AND_ABORT:
+ rc = scsi_disk_emulate_pr_preempt(r, old_key, new_key, type, true);
+ break;
+ default:
+ return -ENOTSUP;
+ }
+
+ return rc;
+}
+
static int scsi_disk_check_mode_select(SCSIDiskState *s, int page,
uint8_t *inbuf, int inlen)
{
@@ -1957,6 +2248,9 @@ static void scsi_disk_emulate_write_data(SCSIRequest *req)
scsi_req_complete(&r->req, GOOD);
break;
+ case PERSISTENT_RESERVE_OUT:
+ scsi_disk_emulate_pr_out(r, r->iov.iov_base);
+ break;
default:
abort();
}
@@ -2213,6 +2507,12 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf)
case FORMAT_UNIT:
trace_scsi_disk_emulate_command_FORMAT_UNIT(r->req.cmd.xfer);
break;
+ case PERSISTENT_RESERVE_OUT:
+ break;
+ case PERSISTENT_RESERVE_IN:
+ scsi_req_ref(&r->req);
+ scsi_disk_emulate_pr_in(req);
+ return 0;
default:
trace_scsi_disk_emulate_command_UNKNOWN(buf[0],
scsi_command_name(buf[0]));
@@ -2632,6 +2932,8 @@ static const SCSIReqOps *const scsi_disk_reqops_dispatch[256] = {
[VERIFY_12] = &scsi_disk_emulate_reqops,
[VERIFY_16] = &scsi_disk_emulate_reqops,
[FORMAT_UNIT] = &scsi_disk_emulate_reqops,
+ [PERSISTENT_RESERVE_IN] = &scsi_disk_emulate_reqops,
+ [PERSISTENT_RESERVE_OUT] = &scsi_disk_emulate_reqops,
[READ_6] = &scsi_disk_dma_reqops,
[READ_10] = &scsi_disk_dma_reqops,
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 6/9] block/nvme: add reservation command protocol constants
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
` (4 preceding siblings ...)
2024-05-08 9:36 ` [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 18:48 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 7/9] hw/nvme: add helper functions for converting reservation types Changqi Lu
` (3 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
Add constants for the NVMe persistent command protocol.
The constants include the reservation command opcode and
reservation type values defined in section 7 of the NVMe
2.0 specification.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
include/block/nvme.h | 30 ++++++++++++++++++++++++++++++
1 file changed, 30 insertions(+)
diff --git a/include/block/nvme.h b/include/block/nvme.h
index bb231d0b9a..3409fba762 100644
--- a/include/block/nvme.h
+++ b/include/block/nvme.h
@@ -633,6 +633,10 @@ enum NvmeIoCommands {
NVME_CMD_WRITE_ZEROES = 0x08,
NVME_CMD_DSM = 0x09,
NVME_CMD_VERIFY = 0x0c,
+ NVME_CMD_RESV_REGISTER = 0x0d,
+ NVME_CMD_RESV_REPORT = 0x0e,
+ NVME_CMD_RESV_ACQUIRE = 0x11,
+ NVME_CMD_RESV_RELEASE = 0x15,
NVME_CMD_IO_MGMT_RECV = 0x12,
NVME_CMD_COPY = 0x19,
NVME_CMD_IO_MGMT_SEND = 0x1d,
@@ -641,6 +645,32 @@ enum NvmeIoCommands {
NVME_CMD_ZONE_APPEND = 0x7d,
};
+typedef enum {
+ NVME_RESV_REGISTER_ACTION_REGISTER = 0x00,
+ NVME_RESV_REGISTER_ACTION_UNREGISTER = 0x01,
+ NVME_RESV_REGISTER_ACTION_REPLACE = 0x02,
+} NVME_RESV_REGISTER_ACTION;
+
+typedef enum {
+ NVME_RESV_RELEASE_ACTION_RELEASE = 0x00,
+ NVME_RESV_RELEASE_ACTION_CLEAR = 0x01,
+} NVME_RESV_RELEASE_ACTION;
+
+typedef enum {
+ NVME_RESV_ACQUIRE_ACTION_ACQUIRE = 0x00,
+ NVME_RESV_ACQUIRE_ACTION_PREEMPT = 0x01,
+ NVME_RESV_ACQUIRE_ACTION_PREEMPT_AND_ABORT = 0x02,
+} NVME_RESV_ACQUIRE_ACTION;
+
+typedef enum {
+ NVME_RESV_WRITE_EXCLUSIVE = 0x01,
+ NVME_RESV_EXCLUSIVE_ACCESS = 0x02,
+ NVME_RESV_WRITE_EXCLUSIVE_REGS_ONLY = 0x03,
+ NVME_RESV_EXCLUSIVE_ACCESS_REGS_ONLY = 0x04,
+ NVME_RESV_WRITE_EXCLUSIVE_ALL_REGS = 0x05,
+ NVME_RESV_EXCLUSIVE_ACCESS_ALL_REGS = 0x06,
+} NVMEResvType;
+
typedef struct QEMU_PACKED NvmeDeleteQ {
uint8_t opcode;
uint8_t flags;
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 7/9] hw/nvme: add helper functions for converting reservation types
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
` (5 preceding siblings ...)
2024-05-08 9:36 ` [PATCH 6/9] block/nvme: add reservation command protocol constants Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 18:48 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 8/9] hw/nvme: add reservation protocal command Changqi Lu
` (2 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
This commit introduces two helper functions
that facilitate the conversion between the
reservation types used in the NVME protocol
and those used in the block layer.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
hw/nvme/nvme.h | 40 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 40 insertions(+)
diff --git a/hw/nvme/nvme.h b/hw/nvme/nvme.h
index bed8191bd5..6abe479410 100644
--- a/hw/nvme/nvme.h
+++ b/hw/nvme/nvme.h
@@ -474,6 +474,46 @@ static inline const char *nvme_io_opc_str(uint8_t opc)
}
}
+static inline NVMEResvType block_pr_type_to_nvme(BlockPrType type)
+{
+ switch (type) {
+ case BLK_PR_WRITE_EXCLUSIVE:
+ return NVME_RESV_WRITE_EXCLUSIVE;
+ case BLK_PR_EXCLUSIVE_ACCESS:
+ return NVME_RESV_EXCLUSIVE_ACCESS;
+ case BLK_PR_WRITE_EXCLUSIVE_REGS_ONLY:
+ return NVME_RESV_WRITE_EXCLUSIVE_REGS_ONLY;
+ case BLK_PR_EXCLUSIVE_ACCESS_REGS_ONLY:
+ return NVME_RESV_EXCLUSIVE_ACCESS_REGS_ONLY;
+ case BLK_PR_WRITE_EXCLUSIVE_ALL_REGS:
+ return NVME_RESV_WRITE_EXCLUSIVE_ALL_REGS;
+ case BLK_PR_EXCLUSIVE_ACCESS_ALL_REGS:
+ return NVME_RESV_EXCLUSIVE_ACCESS_ALL_REGS;
+ }
+
+ return 0;
+}
+
+static inline BlockPrType nvme_pr_type_to_block(NVMEResvType type)
+{
+ switch (type) {
+ case NVME_RESV_WRITE_EXCLUSIVE:
+ return BLK_PR_WRITE_EXCLUSIVE;
+ case NVME_RESV_EXCLUSIVE_ACCESS:
+ return BLK_PR_EXCLUSIVE_ACCESS;
+ case NVME_RESV_WRITE_EXCLUSIVE_REGS_ONLY:
+ return BLK_PR_WRITE_EXCLUSIVE_REGS_ONLY;
+ case NVME_RESV_EXCLUSIVE_ACCESS_REGS_ONLY:
+ return BLK_PR_EXCLUSIVE_ACCESS_REGS_ONLY;
+ case NVME_RESV_WRITE_EXCLUSIVE_ALL_REGS:
+ return BLK_PR_WRITE_EXCLUSIVE_ALL_REGS;
+ case NVME_RESV_EXCLUSIVE_ACCESS_ALL_REGS:
+ return BLK_PR_EXCLUSIVE_ACCESS_ALL_REGS;
+ }
+
+ return 0;
+}
+
typedef struct NvmeSQueue {
struct NvmeCtrl *ctrl;
uint16_t sqid;
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 8/9] hw/nvme: add reservation protocal command
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
` (6 preceding siblings ...)
2024-05-08 9:36 ` [PATCH 7/9] hw/nvme: add helper functions for converting reservation types Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-08 10:41 ` Klaus Jensen
2024-05-08 9:36 ` [PATCH 9/9] block/iscsi: add persistent reservation in/out driver Changqi Lu
2024-05-09 19:08 ` [PATCH 0/9] Support persistent reservation operations Stefan Hajnoczi
9 siblings, 1 reply; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
Add reservation acquire, reservation register,
reservation release and reservation report commands
in the nvme device layer.
By introducing these commands, this enables the nvme
device to perform reservation-related tasks, including
querying keys, querying reservation status, registering
reservation keys, initiating and releasing reservations,
as well as clearing and preempting reservations held by
other keys.
These commands are crucial for management and control of
shared storage resources in a persistent manner.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
hw/nvme/ctrl.c | 304 ++++++++++++++++++++++++++++++++++++++++++-
hw/nvme/nvme.h | 4 +
include/block/nvme.h | 37 ++++++
3 files changed, 344 insertions(+), 1 deletion(-)
diff --git a/hw/nvme/ctrl.c b/hw/nvme/ctrl.c
index 127c3d2383..1f881fc44c 100644
--- a/hw/nvme/ctrl.c
+++ b/hw/nvme/ctrl.c
@@ -294,6 +294,10 @@ static const uint32_t nvme_cse_iocs_nvm[256] = {
[NVME_CMD_COMPARE] = NVME_CMD_EFF_CSUPP,
[NVME_CMD_IO_MGMT_RECV] = NVME_CMD_EFF_CSUPP,
[NVME_CMD_IO_MGMT_SEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
+ [NVME_CMD_RESV_REGISTER] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_REPORT] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_ACQUIRE] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_RELEASE] = NVME_CMD_EFF_CSUPP,
};
static const uint32_t nvme_cse_iocs_zoned[256] = {
@@ -308,6 +312,10 @@ static const uint32_t nvme_cse_iocs_zoned[256] = {
[NVME_CMD_ZONE_APPEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
[NVME_CMD_ZONE_MGMT_SEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
[NVME_CMD_ZONE_MGMT_RECV] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_REGISTER] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_REPORT] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_ACQUIRE] = NVME_CMD_EFF_CSUPP,
+ [NVME_CMD_RESV_RELEASE] = NVME_CMD_EFF_CSUPP,
};
static void nvme_process_sq(void *opaque);
@@ -1745,6 +1753,7 @@ static void nvme_aio_err(NvmeRequest *req, int ret)
switch (req->cmd.opcode) {
case NVME_CMD_READ:
+ case NVME_CMD_RESV_REPORT:
status = NVME_UNRECOVERED_READ;
break;
case NVME_CMD_FLUSH:
@@ -1752,6 +1761,9 @@ static void nvme_aio_err(NvmeRequest *req, int ret)
case NVME_CMD_WRITE_ZEROES:
case NVME_CMD_ZONE_APPEND:
case NVME_CMD_COPY:
+ case NVME_CMD_RESV_REGISTER:
+ case NVME_CMD_RESV_ACQUIRE:
+ case NVME_CMD_RESV_RELEASE:
status = NVME_WRITE_FAULT;
break;
default:
@@ -2127,7 +2139,10 @@ static inline bool nvme_is_write(NvmeRequest *req)
return rw->opcode == NVME_CMD_WRITE ||
rw->opcode == NVME_CMD_ZONE_APPEND ||
- rw->opcode == NVME_CMD_WRITE_ZEROES;
+ rw->opcode == NVME_CMD_WRITE_ZEROES ||
+ rw->opcode == NVME_CMD_RESV_REGISTER ||
+ rw->opcode == NVME_CMD_RESV_ACQUIRE ||
+ rw->opcode == NVME_CMD_RESV_RELEASE;
}
static void nvme_misc_cb(void *opaque, int ret)
@@ -2692,6 +2707,285 @@ static uint16_t nvme_verify(NvmeCtrl *n, NvmeRequest *req)
return NVME_NO_COMPLETE;
}
+typedef struct NvmeKeyInfo {
+ uint64_t cr_key;
+ uint64_t nr_key;
+} NvmeKeyInfo;
+
+static uint16_t nvme_resv_register(NvmeCtrl *n, NvmeRequest *req)
+{
+ int ret;
+ NvmeKeyInfo key_info;
+ NvmeNamespace *ns = req->ns;
+ uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
+ bool ignore_key = cdw10 >> 3 & 0x1;
+ uint8_t action = cdw10 & 0x7;
+
+ ret = nvme_h2c(n, (uint8_t *)&key_info, sizeof(NvmeKeyInfo), req);
+ if (ret) {
+ return ret;
+ }
+
+ switch (action) {
+ case NVME_RESV_REGISTER_ACTION_REGISTER:
+ req->aiocb = blk_aio_pr_register(ns->blkconf.blk, 0,
+ key_info.nr_key, 0,
+ ignore_key, nvme_misc_cb,
+ req);
+ break;
+ case NVME_RESV_REGISTER_ACTION_UNREGISTER:
+ req->aiocb = blk_aio_pr_register(ns->blkconf.blk, key_info.cr_key, 0,
+ 0, ignore_key, nvme_misc_cb, req);
+ break;
+ case NVME_RESV_REGISTER_ACTION_REPLACE:
+ req->aiocb = blk_aio_pr_register(ns->blkconf.blk, key_info.cr_key,
+ key_info.nr_key, 0, ignore_key,
+ nvme_misc_cb, req);
+ break;
+ default:
+ return NVME_INVALID_FIELD;
+ }
+
+ return NVME_NO_COMPLETE;
+}
+
+static uint16_t nvme_resv_release(NvmeCtrl *n, NvmeRequest *req)
+{
+ int ret;
+ uint64_t cr_key;
+ NvmeNamespace *ns = req->ns;
+ uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
+ uint8_t action = cdw10 & 0x7;
+ NVMEResvType type = cdw10 >> 8 & 0xff;
+
+ ret = nvme_h2c(n, (uint8_t *)&cr_key, sizeof(cr_key), req);
+ if (ret) {
+ return ret;
+ }
+
+ switch (action) {
+ case NVME_RESV_RELEASE_ACTION_RELEASE:
+ req->aiocb = blk_aio_pr_release(ns->blkconf.blk, cr_key,
+ nvme_pr_type_to_block(type),
+ nvme_misc_cb, req);
+ break;
+ case NVME_RESV_RELEASE_ACTION_CLEAR:
+ req->aiocb = blk_aio_pr_clear(ns->blkconf.blk, cr_key,
+ nvme_misc_cb, req);
+ break;
+ default:
+ return NVME_INVALID_FIELD;
+ }
+
+ return NVME_NO_COMPLETE;
+}
+
+static uint16_t nvme_resv_acquire(NvmeCtrl *n, NvmeRequest *req)
+{
+ int ret;
+ NvmeKeyInfo key_info;
+ NvmeNamespace *ns = req->ns;
+ uint32_t cdw10 = le32_to_cpu(req->cmd.cdw10);
+ uint8_t action = cdw10 & 0x7;
+ NVMEResvType type = cdw10 >> 8 & 0xff;
+
+ ret = nvme_h2c(n, (uint8_t *)&key_info, sizeof(NvmeKeyInfo), req);
+ if (ret) {
+ return ret;
+ }
+
+ switch (action) {
+ case NVME_RESV_ACQUIRE_ACTION_ACQUIRE:
+ req->aiocb = blk_aio_pr_reserve(ns->blkconf.blk, key_info.cr_key,
+ nvme_pr_type_to_block(type),
+ nvme_misc_cb, req);
+ break;
+ case NVME_RESV_ACQUIRE_ACTION_PREEMPT:
+ req->aiocb = blk_aio_pr_preempt(ns->blkconf.blk,
+ key_info.cr_key, key_info.nr_key,
+ nvme_pr_type_to_block(type),
+ false, nvme_misc_cb, req);
+ break;
+ case NVME_RESV_ACQUIRE_ACTION_PREEMPT_AND_ABORT:
+ req->aiocb = blk_aio_pr_preempt(ns->blkconf.blk, key_info.cr_key,
+ key_info.nr_key, type, true,
+ nvme_misc_cb, req);
+ break;
+ default:
+ return NVME_INVALID_FIELD;
+ }
+
+ return NVME_NO_COMPLETE;
+}
+
+typedef struct NvmeResvKeys {
+ uint32_t generation;
+ uint32_t num_keys;
+ uint64_t *keys;
+ NvmeRequest *req;
+} NvmeResvKeys;
+
+typedef struct NvmeReadReservation {
+ uint32_t generation;
+ uint64_t key;
+ BlockPrType type;
+ NvmeRequest *req;
+ NvmeResvKeys *keys_info;
+} NvmeReadReservation;
+
+static int _nvme_resv_read_reservation_cb(NvmeReadReservation *reservation)
+{
+ int rc;
+ NvmeReservationStatus *nvme_status;
+ NvmeRequest *req = reservation->req;
+ NvmeCtrl *n = req->sq->ctrl;
+ NvmeResvKeys *keys_info = reservation->keys_info;
+ int len = sizeof(NvmeReservationStatusHeader) +
+ sizeof(NvmeRegisteredCtrl) * keys_info->num_keys;
+
+ nvme_status = g_malloc(len);
+ nvme_status->header.gen = reservation->generation;
+ nvme_status->header.rtype = block_pr_type_to_nvme(reservation->type);
+ nvme_status->header.regctl = keys_info->num_keys;
+ for (int i = 0; i < keys_info->num_keys; i++) {
+ nvme_status->regctl_ds[i].cntlid = nvme_ctrl(req)->cntlid;
+ nvme_status->regctl_ds[i].rkey = keys_info->keys[i];
+ nvme_status->regctl_ds[i].rcsts = keys_info->keys[i] ==
+ reservation->key ? 1 : 0;
+ /* hostid is not supported currently */
+ memset(&nvme_status->regctl_ds[i].hostid, 0, 8);
+ }
+
+ rc = nvme_c2h(n, (uint8_t *)nvme_status, len, req);
+ g_free(nvme_status);
+ return rc;
+}
+
+static int _nvme_resv_read_reservation_ext_cb(NvmeReadReservation *reservation)
+{
+ int rc;
+ NvmeReservationStatusExt *nvme_status_ext;
+ NvmeRequest *req = reservation->req;
+ NvmeCtrl *n = req->sq->ctrl;
+ NvmeResvKeys *keys_info = reservation->keys_info;
+ int len = sizeof(NvmeReservationStatusHeader) +
+ sizeof(uint8_t) * 40 +
+ sizeof(NvmeRegisteredCtrlExt) * keys_info->num_keys;
+
+ nvme_status_ext = g_malloc(len);
+ nvme_status_ext->header.gen = cpu_to_be32(reservation->generation);
+ nvme_status_ext->header.rtype = block_pr_type_to_nvme(reservation->type);
+ nvme_status_ext->header.regctl = cpu_to_be16(keys_info->num_keys);
+
+ for (int i = 0; i < keys_info->num_keys; i++) {
+ uint16_t ctnlid = nvme_ctrl(req)->cntlid;
+ nvme_status_ext->regctl_eds[i].cntlid = cpu_to_be16(ctnlid);
+ nvme_status_ext->regctl_eds[i].rkey = cpu_to_be64(keys_info->keys[i]);
+ nvme_status_ext->regctl_eds[i].rcsts = keys_info->keys[i] ==
+ reservation->key ? 1 : 0;
+ /* hostid is not supported currently */
+ memset(&nvme_status_ext->regctl_eds[i].hostid, 0, 16);
+ }
+
+ rc = nvme_c2h(n, (uint8_t *)nvme_status_ext, len, req);
+ g_free(nvme_status_ext);
+ return rc;
+}
+
+static void nvme_resv_read_reservation_cb(void *opaque, int ret)
+{
+ NvmeReadReservation *reservation = opaque;
+ NvmeRequest *req = reservation->req;
+ bool eds = req->cmd.cdw11 & 0x1;
+ NvmeResvKeys *keys_info = reservation->keys_info;
+
+ if (ret < 0) {
+ goto out;
+ }
+
+ if (eds) {
+ ret = _nvme_resv_read_reservation_ext_cb(reservation);
+ } else {
+ ret = _nvme_resv_read_reservation_cb(reservation);
+ }
+
+out:
+ g_free(keys_info);
+ g_free(reservation);
+ nvme_misc_cb(req, ret);
+}
+
+static void nvme_resv_read_keys_cb(void *opaque, int ret)
+{
+ NvmeResvKeys *keys_info = opaque;
+ NvmeRequest *req = keys_info->req;
+ NvmeNamespace *ns = req->ns;
+ NvmeReadReservation *reservation;
+
+ if (ret < 0) {
+ goto out;
+ }
+
+ keys_info->num_keys = MIN(ret, keys_info->num_keys);
+ reservation = g_new0(NvmeReadReservation, 1);
+ memset(reservation, 0, sizeof(*reservation));
+ reservation->req = req;
+ reservation->keys_info = keys_info;
+
+ req->aiocb = blk_aio_pr_read_reservation(ns->blkconf.blk,
+ &reservation->generation, &reservation->key,
+ &reservation->type, nvme_resv_read_reservation_cb,
+ reservation);
+ return;
+
+out:
+ g_free(keys_info);
+ nvme_misc_cb(req, ret);
+}
+
+
+static uint16_t nvme_resv_report(NvmeCtrl *n, NvmeRequest *req)
+{
+ int num_keys;
+ uint32_t cdw10 = req->cmd.cdw10;
+ uint32_t cdw11 = req->cmd.cdw11;
+ int buflen = (cdw10 + 1) * sizeof(uint32_t);
+ bool eds = cdw11 & 0x1;
+ NvmeNamespace *ns = req->ns;
+ NvmeResvKeys *keys_info;
+
+ if (eds) {
+ if (buflen < sizeof(NvmeReservationStatusHeader) +
+ sizeof(uint8_t) * 40) {
+ return NVME_INVALID_FIELD;
+ }
+
+ num_keys = (buflen - sizeof(NvmeReservationStatusHeader) -
+ sizeof(uint8_t) * 40) /
+ sizeof(struct NvmeRegisteredCtrlExt);
+ } else {
+ if (buflen < sizeof(NvmeReservationStatusHeader)) {
+ return NVME_INVALID_FIELD;
+ }
+
+ num_keys = (buflen - sizeof(NvmeReservationStatusHeader)) /
+ sizeof(struct NvmeRegisteredCtrl);
+ }
+
+ keys_info = g_new0(NvmeResvKeys, 1);
+ keys_info->generation = 0;
+ /* num_keys is the maximum number of keys that can be transmitted */
+ keys_info->num_keys = num_keys;
+ keys_info->keys = g_malloc(sizeof(uint64_t) * num_keys);
+ keys_info->req = req;
+
+ req->aiocb = blk_aio_pr_read_keys(ns->blkconf.blk, &keys_info->generation,
+ keys_info->num_keys, keys_info->keys,
+ nvme_resv_read_keys_cb, keys_info);
+
+ return NVME_NO_COMPLETE;
+}
+
typedef struct NvmeCopyAIOCB {
BlockAIOCB common;
BlockAIOCB *aiocb;
@@ -4469,6 +4763,14 @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeRequest *req)
return nvme_dsm(n, req);
case NVME_CMD_VERIFY:
return nvme_verify(n, req);
+ case NVME_CMD_RESV_REGISTER:
+ return nvme_resv_register(n, req);
+ case NVME_CMD_RESV_REPORT:
+ return nvme_resv_report(n, req);
+ case NVME_CMD_RESV_ACQUIRE:
+ return nvme_resv_acquire(n, req);
+ case NVME_CMD_RESV_RELEASE:
+ return nvme_resv_release(n, req);
case NVME_CMD_COPY:
return nvme_copy(n, req);
case NVME_CMD_ZONE_MGMT_SEND:
diff --git a/hw/nvme/nvme.h b/hw/nvme/nvme.h
index 6abe479410..c18f17a332 100644
--- a/hw/nvme/nvme.h
+++ b/hw/nvme/nvme.h
@@ -470,6 +470,10 @@ static inline const char *nvme_io_opc_str(uint8_t opc)
case NVME_CMD_ZONE_MGMT_SEND: return "NVME_ZONED_CMD_MGMT_SEND";
case NVME_CMD_ZONE_MGMT_RECV: return "NVME_ZONED_CMD_MGMT_RECV";
case NVME_CMD_ZONE_APPEND: return "NVME_ZONED_CMD_ZONE_APPEND";
+ case NVME_CMD_RESV_REGISTER: return "NVME_CMD_RESV_REGISTER";
+ case NVME_CMD_RESV_REPORT: return "NVME_CMD_RESV_REPORT";
+ case NVME_CMD_RESV_ACQUIRE: return "NVME_CMD_RESV_ACQUIRE";
+ case NVME_CMD_RESV_RELEASE: return "NVME_CMD_RESV_RELEASE";
default: return "NVME_NVM_CMD_UNKNOWN";
}
}
diff --git a/include/block/nvme.h b/include/block/nvme.h
index 3409fba762..33503b9ba9 100644
--- a/include/block/nvme.h
+++ b/include/block/nvme.h
@@ -671,6 +671,43 @@ typedef enum {
NVME_RESV_EXCLUSIVE_ACCESS_ALL_REGS = 0x06,
} NVMEResvType;
+typedef struct QEMU_PACKED NvmeRegisteredCtrl {
+ uint16_t cntlid;
+ uint8_t rcsts;
+ uint8_t rsvd3[5];
+ uint8_t hostid[8];
+ uint64_t rkey;
+} NvmeRegisteredCtrl;
+
+typedef struct QEMU_PACKED NvmeRegisteredCtrlExt {
+ uint16_t cntlid;
+ uint8_t rcsts;
+ uint8_t rsvd3[5];
+ uint64_t rkey;
+ uint8_t hostid[16];
+ uint8_t rsvd32[32];
+} NvmeRegisteredCtrlExt;
+
+typedef struct QEMU_PACKED NvmeReservationStatusHeader {
+ uint32_t gen;
+ uint8_t rtype;
+ uint16_t regctl;
+ uint16_t resv5;
+ uint8_t ptpls;
+ uint8_t resv10[14];
+} NvmeReservationStatusHeader;
+
+typedef struct QEMU_PACKED NvmeReservationStatus {
+ struct NvmeReservationStatusHeader header;
+ struct NvmeRegisteredCtrl regctl_ds[];
+} NvmeReservationStatus;
+
+typedef struct QEMU_PACKED NvmeReservationStatusExt {
+ struct NvmeReservationStatusHeader header;
+ uint8_t rsvd24[40];
+ struct NvmeRegisteredCtrlExt regctl_eds[];
+} NvmeReservationStatusExt;
+
typedef struct QEMU_PACKED NvmeDeleteQ {
uint8_t opcode;
uint8_t flags;
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 9/9] block/iscsi: add persistent reservation in/out driver
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
` (7 preceding siblings ...)
2024-05-08 9:36 ` [PATCH 8/9] hw/nvme: add reservation protocal command Changqi Lu
@ 2024-05-08 9:36 ` Changqi Lu
2024-05-09 19:08 ` [PATCH 0/9] Support persistent reservation operations Stefan Hajnoczi
9 siblings, 0 replies; 21+ messages in thread
From: Changqi Lu @ 2024-05-08 9:36 UTC (permalink / raw)
To: qemu-block, qemu-devel
Cc: kwolf, hreitz, stefanha, fam, ronniesahlberg, pbonzini, pl,
kbusch, its, foss, philmd, Changqi Lu, zhenwei pi
Add persistent reservation in/out operations for iscsi driver.
The following methods are implemented: bdrv_co_pr_read_keys,
bdrv_co_pr_read_reservation, bdrv_co_pr_register, bdrv_co_pr_reserve,
bdrv_co_pr_release, bdrv_co_pr_clear and bdrv_co_pr_preempt.
Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
---
block/iscsi.c | 390 ++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 390 insertions(+)
diff --git a/block/iscsi.c b/block/iscsi.c
index 2ff14b7472..212fab53ad 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -280,6 +280,8 @@ iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,
iTask->err_code = -error;
iTask->err_str = g_strdup(iscsi_get_error(iscsi));
}
+ } else if (status == SCSI_STATUS_RESERVATION_CONFLICT) {
+ iTask->err_code = -EBADE;
}
}
}
@@ -2408,6 +2410,386 @@ out_unlock:
return r;
}
+static int coroutine_fn
+iscsi_co_pr_read_keys(BlockDriverState *bs, uint32_t *generation,
+ uint32_t num_keys, uint64_t *keys)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ QEMUIOVector qiov;
+ struct IscsiTask iTask;
+ int xferlen = sizeof(struct scsi_persistent_reserve_in_read_keys) +
+ sizeof(uint64_t) * num_keys;
+ uint8_t *buf = g_malloc0(xferlen);
+ int32_t num_collect_keys = 0;
+ int r = 0;
+
+ qemu_iovec_init_buf(&qiov, buf, xferlen);
+ iscsi_co_init_iscsitask(iscsilun, &iTask);
+ qemu_mutex_lock(&iscsilun->mutex);
+retry:
+ iTask.task = iscsi_persistent_reserve_in_task(iscsilun->iscsi,
+ iscsilun->lun, SCSI_PR_IN_READ_KEYS, xferlen,
+ iscsi_co_generic_cb, &iTask);
+
+ if (iTask.task == NULL) {
+ qemu_mutex_unlock(&iscsilun->mutex);
+ return -ENOMEM;
+ }
+
+ scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *)qiov.iov, qiov.niov);
+ iscsi_co_wait_for_task(&iTask, iscsilun);
+
+ if (iTask.task != NULL) {
+ scsi_free_scsi_task(iTask.task);
+ iTask.task = NULL;
+ }
+
+ if (iTask.do_retry) {
+ iTask.complete = 0;
+ goto retry;
+ }
+
+ if (iTask.status != SCSI_STATUS_GOOD) {
+ error_report("iSCSI PERSISTENT_RESERVE_IN failed: %s", iTask.err_str);
+ r = iTask.err_code;
+ goto out;
+ }
+
+ memcpy(generation, &buf[0], 4);
+ *generation = be32_to_cpu(*generation);
+ memcpy(&num_collect_keys, &buf[4], 4);
+ if (num_collect_keys > num_keys) {
+ r = -EINVAL;
+ goto out;
+ }
+
+ for (int i = 0; i < num_collect_keys; i++) {
+ memcpy(&keys[i], &buf[8 + i * 8], 8);
+ keys[i] = be64_to_cpu(keys[i]);
+ }
+
+out:
+ qemu_mutex_unlock(&iscsilun->mutex);
+ g_free(iTask.err_str);
+ g_free(buf);
+ return r;
+}
+
+static int coroutine_fn
+iscsi_co_pr_read_reservation(BlockDriverState *bs, uint32_t *generation,
+ uint64_t *key, BlockPrType *type)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ QEMUIOVector qiov;
+ struct IscsiTask iTask;
+ int xferlen = sizeof(struct scsi_persistent_reserve_in_read_reservation);
+ uint8_t *buf = g_malloc0(xferlen);
+ uint8_t scope_type = 0;
+ int32_t num_collect_keys = 0;
+ int r = 0;
+
+ qemu_iovec_init_buf(&qiov, buf, xferlen);
+ iscsi_co_init_iscsitask(iscsilun, &iTask);
+ qemu_mutex_lock(&iscsilun->mutex);
+retry:
+ iTask.task = iscsi_persistent_reserve_in_task(iscsilun->iscsi,
+ iscsilun->lun, SCSI_PR_IN_READ_RESERVATION,
+ xferlen, iscsi_co_generic_cb, &iTask);
+
+ if (iTask.task == NULL) {
+ qemu_mutex_unlock(&iscsilun->mutex);
+ return -ENOMEM;
+ }
+
+ scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *)qiov.iov, qiov.niov);
+ iscsi_co_wait_for_task(&iTask, iscsilun);
+
+ if (iTask.task != NULL) {
+ scsi_free_scsi_task(iTask.task);
+ iTask.task = NULL;
+ }
+
+ if (iTask.do_retry) {
+ iTask.complete = 0;
+ goto retry;
+ }
+
+ if (iTask.status != SCSI_STATUS_GOOD) {
+ error_report("iSCSI PERSISTENT_RESERVE_IN failed: %s", iTask.err_str);
+ r = iTask.err_code;
+ goto out;
+ }
+
+ memcpy(generation, &buf[0], 4);
+ *generation = be32_to_cpu(*generation);
+ memcpy(key, &buf[8], 8);
+ *key = be64_to_cpu(*key);
+ memcpy(&scope_type, &buf[21], 1);
+ *type = scsi_pr_type_to_block(scope_type & 0xf);
+ memcpy(&num_collect_keys, &buf[4], 4);
+ r = be32_to_cpu(num_collect_keys) / sizeof(uint64_t);
+out:
+ qemu_mutex_unlock(&iscsilun->mutex);
+ g_free(iTask.err_str);
+ g_free(buf);
+ return r;
+}
+
+static int coroutine_fn
+iscsi_co_pr_register(BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type,
+ bool ignore_key)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ struct IscsiTask iTask;
+ struct scsi_persistent_reserve_out_basic *basic;
+ SCSIPrOutAction action = ignore_key ? SCSI_PR_OUT_REG_AND_IGNORE_KEY :
+ SCSI_PR_OUT_REGISTER;
+ int r = 0;
+
+ basic = g_new0(struct scsi_persistent_reserve_out_basic, 1);
+ /**
+ * spec_i_pt/all_tg_pt is currently not supported,
+ * aptpl is enable by default.
+ */
+ basic->reservation_key = old_key;
+ basic->service_action_reservation_key = new_key;
+ basic->aptpl = 1;
+
+ iscsi_co_init_iscsitask(iscsilun, &iTask);
+ qemu_mutex_lock(&iscsilun->mutex);
+retry:
+ iTask.task = iscsi_persistent_reserve_out_task(iscsilun->iscsi,
+ iscsilun->lun, action, 0, block_pr_type_to_scsi(type),
+ basic, iscsi_co_generic_cb, &iTask);
+
+ if (iTask.task == NULL) {
+ qemu_mutex_unlock(&iscsilun->mutex);
+ return -ENOMEM;
+ }
+
+ iscsi_co_wait_for_task(&iTask, iscsilun);
+
+ if (iTask.task != NULL) {
+ scsi_free_scsi_task(iTask.task);
+ iTask.task = NULL;
+ }
+
+ if (iTask.do_retry) {
+ iTask.complete = 0;
+ goto retry;
+ }
+
+ if (iTask.status != SCSI_STATUS_GOOD) {
+ error_report("iSCSI PERSISTENT_RESERVE_OUT failed: %s", iTask.err_str);
+ r = iTask.err_code;
+ }
+
+ qemu_mutex_unlock(&iscsilun->mutex);
+
+ g_free(iTask.err_str);
+ g_free(basic);
+ return r;
+}
+
+static int coroutine_fn
+iscsi_co_pr_reserve(BlockDriverState *bs, uint64_t key, BlockPrType type)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ struct IscsiTask iTask;
+ struct scsi_persistent_reserve_out_basic *basic;
+ int r = 0;
+
+ basic = g_new0(struct scsi_persistent_reserve_out_basic, 1);
+ basic->reservation_key = key;
+
+ iscsi_co_init_iscsitask(iscsilun, &iTask);
+ qemu_mutex_lock(&iscsilun->mutex);
+retry:
+ iTask.task = iscsi_persistent_reserve_out_task(iscsilun->iscsi,
+ iscsilun->lun, SCSI_PR_OUT_RESERVE, 0,
+ block_pr_type_to_scsi(type), basic,
+ iscsi_co_generic_cb, &iTask);
+
+ if (iTask.task == NULL) {
+ qemu_mutex_unlock(&iscsilun->mutex);
+ return -ENOMEM;
+ }
+
+
+ iscsi_co_wait_for_task(&iTask, iscsilun);
+
+ if (iTask.task != NULL) {
+ scsi_free_scsi_task(iTask.task);
+ iTask.task = NULL;
+ }
+
+ if (iTask.do_retry) {
+ iTask.complete = 0;
+ goto retry;
+ }
+
+ if (iTask.status != SCSI_STATUS_GOOD) {
+ error_report("iSCSI PERSISTENT_RESERVE_OUT failed: %s", iTask.err_str);
+ r = iTask.err_code;
+ }
+
+ qemu_mutex_unlock(&iscsilun->mutex);
+
+ g_free(iTask.err_str);
+ g_free(basic);
+ return r;
+}
+
+static int coroutine_fn
+iscsi_co_pr_release(BlockDriverState *bs, uint64_t key, BlockPrType type)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ struct IscsiTask iTask;
+ struct scsi_persistent_reserve_out_basic *basic;
+ int r = 0;
+
+ basic = g_new0(struct scsi_persistent_reserve_out_basic, 1);
+ basic->reservation_key = key;
+
+ iscsi_co_init_iscsitask(iscsilun, &iTask);
+ qemu_mutex_lock(&iscsilun->mutex);
+retry:
+ iTask.task = iscsi_persistent_reserve_out_task(iscsilun->iscsi,
+ iscsilun->lun, SCSI_PR_OUT_RELEASE, 0,
+ block_pr_type_to_scsi(type), basic,
+ iscsi_co_generic_cb, &iTask);
+
+ if (iTask.task == NULL) {
+ qemu_mutex_unlock(&iscsilun->mutex);
+ return -ENOMEM;
+ }
+
+
+ iscsi_co_wait_for_task(&iTask, iscsilun);
+
+ if (iTask.task != NULL) {
+ scsi_free_scsi_task(iTask.task);
+ iTask.task = NULL;
+ }
+
+ if (iTask.do_retry) {
+ iTask.complete = 0;
+ goto retry;
+ }
+
+ if (iTask.status != SCSI_STATUS_GOOD) {
+ error_report("iSCSI PERSISTENT_RESERVE_OUT failed: %s", iTask.err_str);
+ r = iTask.err_code;
+ }
+
+ qemu_mutex_unlock(&iscsilun->mutex);
+
+ g_free(iTask.err_str);
+ g_free(basic);
+ return r;
+}
+
+static int coroutine_fn
+iscsi_co_pr_clear(BlockDriverState *bs, uint64_t key)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ struct IscsiTask iTask;
+ struct scsi_persistent_reserve_out_basic *basic;
+ int r = 0;
+
+ basic = g_new0(struct scsi_persistent_reserve_out_basic, 1);
+ basic->reservation_key = key;
+
+ iscsi_co_init_iscsitask(iscsilun, &iTask);
+ qemu_mutex_lock(&iscsilun->mutex);
+retry:
+ iTask.task = iscsi_persistent_reserve_out_task(iscsilun->iscsi,
+ iscsilun->lun, SCSI_PR_OUT_CLEAR, 0, 0, basic,
+ iscsi_co_generic_cb, &iTask);
+
+ if (iTask.task == NULL) {
+ qemu_mutex_unlock(&iscsilun->mutex);
+ return -ENOMEM;
+ }
+
+
+ iscsi_co_wait_for_task(&iTask, iscsilun);
+
+ if (iTask.task != NULL) {
+ scsi_free_scsi_task(iTask.task);
+ iTask.task = NULL;
+ }
+
+ if (iTask.do_retry) {
+ iTask.complete = 0;
+ goto retry;
+ }
+
+ if (iTask.status != SCSI_STATUS_GOOD) {
+ error_report("iSCSI PERSISTENT_RESERVE_OUT failed: %s", iTask.err_str);
+ r = iTask.err_code;
+ }
+
+ qemu_mutex_unlock(&iscsilun->mutex);
+
+ g_free(iTask.err_str);
+ g_free(basic);
+ return r;
+}
+
+static int coroutine_fn
+iscsi_co_pr_preempt(BlockDriverState *bs, uint64_t old_key,
+ uint64_t new_key, BlockPrType type, bool abort)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ struct IscsiTask iTask;
+ struct scsi_persistent_reserve_out_basic *basic;
+ SCSIPrOutAction action = abort ? SCSI_PR_OUT_PREEMPT_AND_ABORT :
+ SCSI_PR_OUT_PREEMPT;
+ int r = 0;
+
+ basic = g_new0(struct scsi_persistent_reserve_out_basic, 1);
+ basic->reservation_key = old_key;
+ basic->service_action_reservation_key = new_key;
+
+ iscsi_co_init_iscsitask(iscsilun, &iTask);
+ qemu_mutex_lock(&iscsilun->mutex);
+retry:
+ iTask.task = iscsi_persistent_reserve_out_task(iscsilun->iscsi,
+ iscsilun->lun, action, 0, block_pr_type_to_scsi(type),
+ basic, iscsi_co_generic_cb, &iTask);
+
+ if (iTask.task == NULL) {
+ qemu_mutex_unlock(&iscsilun->mutex);
+ return -ENOMEM;
+ }
+
+
+ iscsi_co_wait_for_task(&iTask, iscsilun);
+
+ if (iTask.task != NULL) {
+ scsi_free_scsi_task(iTask.task);
+ iTask.task = NULL;
+ }
+
+ if (iTask.do_retry) {
+ iTask.complete = 0;
+ goto retry;
+ }
+
+ if (iTask.status != SCSI_STATUS_GOOD) {
+ error_report("iSCSI PERSISTENT_RESERVE_OUT failed: %s", iTask.err_str);
+ r = iTask.err_code;
+ }
+
+ qemu_mutex_unlock(&iscsilun->mutex);
+
+
+ g_free(iTask.err_str);
+ g_free(basic);
+ return r;
+}
static const char *const iscsi_strong_runtime_opts[] = {
"transport",
@@ -2451,6 +2833,14 @@ static BlockDriver bdrv_iscsi = {
.bdrv_co_writev = iscsi_co_writev,
.bdrv_co_flush_to_disk = iscsi_co_flush,
+ .bdrv_co_pr_read_keys = iscsi_co_pr_read_keys,
+ .bdrv_co_pr_read_reservation = iscsi_co_pr_read_reservation,
+ .bdrv_co_pr_register = iscsi_co_pr_register,
+ .bdrv_co_pr_reserve = iscsi_co_pr_reserve,
+ .bdrv_co_pr_release = iscsi_co_pr_release,
+ .bdrv_co_pr_clear = iscsi_co_pr_clear,
+ .bdrv_co_pr_preempt = iscsi_co_pr_preempt,
+
#ifdef __linux__
.bdrv_aio_ioctl = iscsi_aio_ioctl,
#endif
--
2.20.1
^ permalink raw reply related [flat|nested] 21+ messages in thread
* Re: [PATCH 8/9] hw/nvme: add reservation protocal command
2024-05-08 9:36 ` [PATCH 8/9] hw/nvme: add reservation protocal command Changqi Lu
@ 2024-05-08 10:41 ` Klaus Jensen
0 siblings, 0 replies; 21+ messages in thread
From: Klaus Jensen @ 2024-05-08 10:41 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, stefanha, fam,
ronniesahlberg, pbonzini, pl, kbusch, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 1739 bytes --]
On May 8 17:36, Changqi Lu wrote:
> Add reservation acquire, reservation register,
> reservation release and reservation report commands
> in the nvme device layer.
>
> By introducing these commands, this enables the nvme
> device to perform reservation-related tasks, including
> querying keys, querying reservation status, registering
> reservation keys, initiating and releasing reservations,
> as well as clearing and preempting reservations held by
> other keys.
>
> These commands are crucial for management and control of
> shared storage resources in a persistent manner.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> hw/nvme/ctrl.c | 304 ++++++++++++++++++++++++++++++++++++++++++-
> hw/nvme/nvme.h | 4 +
> include/block/nvme.h | 37 ++++++
> 3 files changed, 344 insertions(+), 1 deletion(-)
>
> diff --git a/hw/nvme/ctrl.c b/hw/nvme/ctrl.c
> index 127c3d2383..1f881fc44c 100644
> --- a/hw/nvme/ctrl.c
> +++ b/hw/nvme/ctrl.c
> @@ -294,6 +294,10 @@ static const uint32_t nvme_cse_iocs_nvm[256] = {
> [NVME_CMD_COMPARE] = NVME_CMD_EFF_CSUPP,
> [NVME_CMD_IO_MGMT_RECV] = NVME_CMD_EFF_CSUPP,
> [NVME_CMD_IO_MGMT_SEND] = NVME_CMD_EFF_CSUPP | NVME_CMD_EFF_LBCC,
> + [NVME_CMD_RESV_REGISTER] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_REPORT] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_ACQUIRE] = NVME_CMD_EFF_CSUPP,
> + [NVME_CMD_RESV_RELEASE] = NVME_CMD_EFF_CSUPP,
> };
We need to indicate support for these commands in ONCS, right? And that
should depend on if or not the underlying block device supports it.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 1/9] block: add persistent reservation in/out api
2024-05-08 9:36 ` [PATCH 1/9] block: add persistent reservation in/out api Changqi Lu
@ 2024-05-09 18:22 ` Stefan Hajnoczi
2024-05-10 2:37 ` zhenwei pi
0 siblings, 1 reply; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 18:22 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 25949 bytes --]
On Wed, May 08, 2024 at 05:36:21PM +0800, Changqi Lu wrote:
> Add persistent reservation in/out operations
> at the block level. The following operations
> are included:
>
> - read_keys: retrieves the list of registered keys.
> - read_reservation: retrieves the current reservation status.
> - register: registers a new reservation key.
> - reserve: initiates a reservation for a specific key.
> - release: releases a reservation for a specific key.
> - clear: clears all existing reservations.
> - preempt: preempts a reservation held by another key.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> block/block-backend.c | 386 ++++++++++++++++++++++++++++++
> block/io.c | 161 +++++++++++++
> include/block/block-common.h | 9 +
> include/block/block-io.h | 19 ++
> include/block/block_int-common.h | 31 +++
> include/sysemu/block-backend-io.h | 22 ++
> 6 files changed, 628 insertions(+)
>
> diff --git a/block/block-backend.c b/block/block-backend.c
> index db6f9b92a3..ec67937d28 100644
> --- a/block/block-backend.c
> +++ b/block/block-backend.c
> @@ -1770,6 +1770,392 @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
> return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
> }
>
> +typedef struct BlkPrInCo {
> + BlockBackend *blk;
> + uint32_t *generation;
> + uint32_t num_keys;
> + BlockPrType *type;
> + uint64_t *keys;
> + int ret;
> +} BlkPrInCo;
> +
> +typedef struct BlkPrInCB {
> + BlockAIOCB common;
> + BlkPrInCo prco;
> + bool has_returned;
> +} BlkPrInCB;
> +
> +static const AIOCBInfo blk_pr_in_aiocb_info = {
> + .aiocb_size = sizeof(BlkPrInCB),
> +};
> +
> +static void blk_pr_in_complete(BlkPrInCB *acb)
> +{
> + if (acb->has_returned) {
> + acb->common.cb(acb->common.opaque, acb->prco.ret);
> + blk_dec_in_flight(acb->prco.blk);
Please add a comment identifying which blk_inc_in_flight() call this dec
is paired with. That makes it easier for people trying to understand
in-flight reference counting.
> + qemu_aio_unref(acb);
> + }
> +}
> +
> +static void blk_pr_in_complete_bh(void *opaque)
> +{
> + BlkPrInCB *acb = opaque;
> + assert(acb->has_returned);
> + blk_pr_in_complete(acb);
> +}
> +
> +static BlockAIOCB *blk_aio_pr_in(BlockBackend *blk, uint32_t *generation,
> + uint32_t num_keys, BlockPrType *type,
> + uint64_t *keys, CoroutineEntry co_entry,
> + BlockCompletionFunc *cb, void *opaque)
> +{
> + BlkPrInCB *acb;
> + Coroutine *co;
> +
> + blk_inc_in_flight(blk);
Please add a comment identifying which blk_dec_in_flight() call this inc
is paired with.
> + acb = blk_aio_get(&blk_pr_in_aiocb_info, blk, cb, opaque);
> + acb->prco = (BlkPrInCo) {
> + .blk = blk,
> + .generation = generation,
> + .num_keys = num_keys,
> + .type = type,
> + .ret = NOT_DONE,
> + .keys = keys,
> + };
> + acb->has_returned = false;
> +
> + co = qemu_coroutine_create(co_entry, acb);
> + aio_co_enter(qemu_get_current_aio_context(), co);
> +
> + acb->has_returned = true;
> + if (acb->prco.ret != NOT_DONE) {
> + replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
> + blk_pr_in_complete_bh, acb);
> + }
> +
> + return &acb->common;
> +}
> +
> +
> +static int coroutine_fn
> +blk_aio_pr_do_read_keys(BlockBackend *blk, uint32_t *generation,
> + uint32_t num_keys, uint64_t *keys)
> +{
> + IO_CODE();
> +
> + blk_wait_while_drained(blk);
> + GRAPH_RDLOCK_GUARD();
> +
> + if (!blk_co_is_available(blk)) {
> + return -ENOMEDIUM;
> + }
> +
> + return bdrv_co_pr_read_keys(blk_bs(blk), generation, num_keys, keys);
> +}
> +
> +static void coroutine_fn blk_aio_pr_read_keys_entry(void *opaque)
> +{
> + BlkPrInCB *acb = opaque;
> + BlkPrInCo *prco = &acb->prco;
> +
> + prco->ret = blk_aio_pr_do_read_keys(prco->blk, prco->generation,
> + prco->num_keys, prco->keys);
> + blk_pr_in_complete(acb);
> +}
> +
> +BlockAIOCB *blk_aio_pr_read_keys(BlockBackend *blk, uint32_t *generation,
> + uint32_t num_keys, uint64_t *keys,
> + BlockCompletionFunc *cb, void *opaque)
> +{
> + IO_CODE();
> + return blk_aio_pr_in(blk, generation, num_keys, NULL, keys,
> + blk_aio_pr_read_keys_entry, cb, opaque);
> +}
> +
> +
> +static int coroutine_fn
> +blk_aio_pr_do_read_reservation(BlockBackend *blk, uint32_t *generation,
> + uint64_t *key, BlockPrType *type)
> +{
> + IO_CODE();
> +
> + blk_wait_while_drained(blk);
> + GRAPH_RDLOCK_GUARD();
> +
> + if (!blk_co_is_available(blk)) {
> + return -ENOMEDIUM;
> + }
> +
> + return bdrv_co_pr_read_reservation(blk_bs(blk), generation, key, type);
> +}
> +
> +static void coroutine_fn blk_aio_pr_read_reservation_entry(void *opaque)
> +{
> + BlkPrInCB *acb = opaque;
> + BlkPrInCo *prco = &acb->prco;
> +
> + prco->ret = blk_aio_pr_do_read_reservation(prco->blk, prco->generation,
> + prco->keys, prco->type);
> + blk_pr_in_complete(acb);
> +}
> +
> +BlockAIOCB *blk_aio_pr_read_reservation(BlockBackend *blk, uint32_t *generation,
> + uint64_t *key, BlockPrType *type,
> + BlockCompletionFunc *cb, void *opaque)
> +{
> + IO_CODE();
> + return blk_aio_pr_in(blk, generation, 0, type, key,
> + blk_aio_pr_read_reservation_entry, cb, opaque);
> +}
> +
> +
> +typedef struct BlkPrOutCo {
> + BlockBackend *blk;
> + uint64_t old_key;
> + uint64_t new_key;
> + BlockPrType type;
> + bool ignore_key;
> + bool abort;
> + int ret;
> +} BlkPrOutCo;
> +
> +typedef struct BlkPrOutCB {
> + BlockAIOCB common;
> + BlkPrOutCo prco;
> + bool has_returned;
> +} BlkPrOutCB;
> +
> +static const AIOCBInfo blk_pr_out_aiocb_info = {
> + .aiocb_size = sizeof(BlkPrOutCB),
> +};
> +
> +static void blk_pr_out_complete(BlkPrOutCB *acb)
> +{
> + if (acb->has_returned) {
> + acb->common.cb(acb->common.opaque, acb->prco.ret);
> + blk_dec_in_flight(acb->prco.blk);
Same here.
> + qemu_aio_unref(acb);
> + }
> +}
> +
> +static void blk_pr_out_complete_bh(void *opaque)
> +{
> + BlkPrOutCB *acb = opaque;
> + assert(acb->has_returned);
> + blk_pr_out_complete(acb);
> +}
> +
> +static BlockAIOCB *blk_aio_pr_out(BlockBackend *blk, uint64_t old_key,
> + uint64_t new_key, BlockPrType type,
> + bool ignore_key, bool abort,
> + CoroutineEntry co_entry,
> + BlockCompletionFunc *cb, void *opaque)
> +{
> + BlkPrOutCB *acb;
> + Coroutine *co;
> +
> + blk_inc_in_flight(blk);
Same here.
> + acb = blk_aio_get(&blk_pr_out_aiocb_info, blk, cb, opaque);
> + acb->prco = (BlkPrOutCo) {
> + .blk = blk,
> + .old_key = old_key,
> + .new_key = new_key,
> + .type = type,
> + .ignore_key = ignore_key,
> + .abort = abort,
> + .ret = NOT_DONE,
> + };
> + acb->has_returned = false;
> +
> + co = qemu_coroutine_create(co_entry, acb);
> + aio_co_enter(qemu_get_current_aio_context(), co);
> +
> + acb->has_returned = true;
> + if (acb->prco.ret != NOT_DONE) {
> + replay_bh_schedule_oneshot_event(qemu_get_current_aio_context(),
> + blk_pr_out_complete_bh, acb);
> + }
> +
> + return &acb->common;
> +}
> +
> +static int coroutine_fn
> +blk_aio_pr_do_register(BlockBackend *blk, uint64_t old_key,
> + uint64_t new_key, BlockPrType type,
> + bool ignore_key)
> +{
> + IO_CODE();
> +
> + blk_wait_while_drained(blk);
> + GRAPH_RDLOCK_GUARD();
> +
> + if (!blk_co_is_available(blk)) {
> + return -ENOMEDIUM;
> + }
> +
> + return bdrv_co_pr_register(blk_bs(blk), old_key, new_key, type, ignore_key);
> +}
> +
> +static void coroutine_fn blk_aio_pr_register_entry(void *opaque)
> +{
> + BlkPrOutCB *acb = opaque;
> + BlkPrOutCo *prco = &acb->prco;
> +
> + prco->ret = blk_aio_pr_do_register(prco->blk, prco->old_key, prco->new_key,
> + prco->type, prco->ignore_key);
> + blk_pr_out_complete(acb);
> +}
> +
> +BlockAIOCB *blk_aio_pr_register(BlockBackend *blk, uint64_t old_key,
> + uint64_t new_key, BlockPrType type,
> + bool ignore_key, BlockCompletionFunc *cb,
> + void *opaque)
> +{
> + IO_CODE();
> + return blk_aio_pr_out(blk, old_key, new_key, type, ignore_key, false,
> + blk_aio_pr_register_entry, cb, opaque);
> +}
> +
> +static int coroutine_fn
> +blk_aio_pr_do_reserve(BlockBackend *blk, uint64_t key, BlockPrType type)
> +{
> + IO_CODE();
> +
> + blk_wait_while_drained(blk);
> + GRAPH_RDLOCK_GUARD();
> +
> + if (!blk_co_is_available(blk)) {
> + return -ENOMEDIUM;
> + }
> +
> + return bdrv_co_pr_reserve(blk_bs(blk), key, type);
> +}
> +
> +static void coroutine_fn blk_aio_pr_reserve_entry(void *opaque)
> +{
> + BlkPrOutCB *acb = opaque;
> + BlkPrOutCo *prco = &acb->prco;
> +
> + prco->ret = blk_aio_pr_do_reserve(prco->blk, prco->old_key, prco->type);
> + blk_pr_out_complete(acb);
> +}
> +
> +
> +BlockAIOCB *blk_aio_pr_reserve(BlockBackend *blk, uint64_t key,
> + BlockPrType type, BlockCompletionFunc *cb,
> + void *opaque)
> +{
> + IO_CODE();
> + return blk_aio_pr_out(blk, key, 0, type, false, false,
> + blk_aio_pr_reserve_entry, cb, opaque);
> +}
> +
> +static int coroutine_fn
> +blk_aio_pr_do_release(BlockBackend *blk, uint64_t key, BlockPrType type)
> +{
> + IO_CODE();
> +
> + blk_wait_while_drained(blk);
> + GRAPH_RDLOCK_GUARD();
> +
> + if (!blk_co_is_available(blk)) {
> + return -ENOMEDIUM;
> + }
> +
> + return bdrv_co_pr_release(blk_bs(blk), key, type);
> +}
> +
> +static void coroutine_fn blk_aio_pr_release_entry(void *opaque)
> +{
> + BlkPrOutCB *acb = opaque;
> + BlkPrOutCo *prco = &acb->prco;
> +
> + prco->ret = blk_aio_pr_do_release(prco->blk, prco->old_key, prco->type);
> + blk_pr_out_complete(acb);
> +}
> +
> +
> +BlockAIOCB *blk_aio_pr_release(BlockBackend *blk, uint64_t key,
> + BlockPrType type, BlockCompletionFunc *cb,
> + void *opaque)
> +{
> + IO_CODE();
> + return blk_aio_pr_out(blk, key, 0, type, false, false,
> + blk_aio_pr_release_entry, cb, opaque);
> +}
> +
> +static int coroutine_fn
> +blk_aio_pr_do_clear(BlockBackend *blk, uint64_t key)
> +{
> + IO_CODE();
> +
> + blk_wait_while_drained(blk);
> + GRAPH_RDLOCK_GUARD();
> +
> + if (!blk_co_is_available(blk)) {
> + return -ENOMEDIUM;
> + }
> +
> + return bdrv_co_pr_clear(blk_bs(blk), key);
> +}
> +
> +static void coroutine_fn blk_aio_pr_clear_entry(void *opaque)
> +{
> + BlkPrOutCB *acb = opaque;
> + BlkPrOutCo *prco = &acb->prco;
> +
> + prco->ret = blk_aio_pr_do_clear(prco->blk, prco->old_key);
> + blk_pr_out_complete(acb);
> +}
> +
> +
> +BlockAIOCB *blk_aio_pr_clear(BlockBackend *blk, uint64_t key,
> + BlockCompletionFunc *cb, void *opaque)
> +{
> + IO_CODE();
> + return blk_aio_pr_out(blk, key, 0, 0, false, false,
> + blk_aio_pr_clear_entry, cb, opaque);
> +}
> +
> +static int coroutine_fn
> +blk_aio_pr_do_preempt(BlockBackend *blk, uint64_t old_key,
> + uint64_t new_key, BlockPrType type, bool abort)
> +{
> + IO_CODE();
> +
> + blk_wait_while_drained(blk);
> + GRAPH_RDLOCK_GUARD();
> +
> + if (!blk_co_is_available(blk)) {
> + return -ENOMEDIUM;
> + }
> +
> + return bdrv_co_pr_preempt(blk_bs(blk), old_key, new_key, type, abort);
> +}
> +
> +static void coroutine_fn blk_aio_pr_preempt_entry(void *opaque)
> +{
> + BlkPrOutCB *acb = opaque;
> + BlkPrOutCo *prco = &acb->prco;
> +
> + prco->ret = blk_aio_pr_do_preempt(prco->blk, prco->old_key,
> + prco->new_key, prco->type,
> + prco->abort);
> + blk_pr_out_complete(acb);
> +}
> +
> +
> +BlockAIOCB *blk_aio_pr_preempt(BlockBackend *blk, uint64_t old_key,
> + uint64_t new_key, BlockPrType type,
> + bool abort, BlockCompletionFunc *cb,
> + void *opaque)
> +{
> + IO_CODE();
> + return blk_aio_pr_out(blk, old_key, new_key, type, false, abort,
> + blk_aio_pr_preempt_entry, cb, opaque);
> +}
> +
> /* To be called between exactly one pair of blk_inc/dec_in_flight() */
> static int coroutine_fn
> blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
> diff --git a/block/io.c b/block/io.c
> index 7217cf811b..98a358c6b2 100644
> --- a/block/io.c
> +++ b/block/io.c
> @@ -3220,6 +3220,167 @@ out:
> return co.ret;
> }
>
> +int coroutine_fn bdrv_co_pr_read_keys(BlockDriverState *bs,
> + uint32_t *generation, uint32_t num_keys,
> + uint64_t *keys)
> +{
> + BlockDriver *drv = bs->drv;
> + CoroutineIOCompletion co = {
> + .coroutine = qemu_coroutine_self(),
> + };
> +
> + IO_CODE();
> + assert_bdrv_graph_readable();
> +
> + bdrv_inc_in_flight(bs);
> + if (!drv || !drv->bdrv_co_pr_read_keys) {
> + co.ret = -ENOTSUP;
> + goto out;
> + }
> +
> + co.ret = drv->bdrv_co_pr_read_keys(bs, generation, num_keys, keys);
> +out:
> + bdrv_dec_in_flight(bs);
> + return co.ret;
> +}
> +
> +int coroutine_fn bdrv_co_pr_read_reservation(BlockDriverState *bs,
> + uint32_t *generation, uint64_t *key, BlockPrType *type)
> +{
> + BlockDriver *drv = bs->drv;
> + CoroutineIOCompletion co = {
> + .coroutine = qemu_coroutine_self(),
> + };
> +
> + IO_CODE();
> + assert_bdrv_graph_readable();
> +
> + bdrv_inc_in_flight(bs);
> + if (!drv || !drv->bdrv_co_pr_read_reservation) {
> + co.ret = -ENOTSUP;
> + goto out;
> + }
> +
> + co.ret = drv->bdrv_co_pr_read_reservation(bs, generation, key, type);
> +out:
> + bdrv_dec_in_flight(bs);
> + return co.ret;
> +}
> +
> +int coroutine_fn bdrv_co_pr_register(BlockDriverState *bs, uint64_t old_key,
> + uint64_t new_key, BlockPrType type, bool ignore_key)
> +{
> + BlockDriver *drv = bs->drv;
> + CoroutineIOCompletion co = {
> + .coroutine = qemu_coroutine_self(),
> + };
> +
> + IO_CODE();
> + assert_bdrv_graph_readable();
> +
> + bdrv_inc_in_flight(bs);
> + if (!drv || !drv->bdrv_co_pr_register) {
> + co.ret = -ENOTSUP;
> + goto out;
> + }
> +
> + co.ret = drv->bdrv_co_pr_register(bs, old_key, new_key, type, ignore_key);
> +out:
> + bdrv_dec_in_flight(bs);
> + return co.ret;
> +}
> +
> +int coroutine_fn bdrv_co_pr_reserve(BlockDriverState *bs, uint64_t key,
> + BlockPrType type)
> +{
> + BlockDriver *drv = bs->drv;
> + CoroutineIOCompletion co = {
> + .coroutine = qemu_coroutine_self(),
> + };
> +
> + IO_CODE();
> + assert_bdrv_graph_readable();
> +
> + bdrv_inc_in_flight(bs);
> + if (!drv || !drv->bdrv_co_pr_reserve) {
> + co.ret = -ENOTSUP;
> + goto out;
> + }
> +
> + co.ret = drv->bdrv_co_pr_reserve(bs, key, type);
> +out:
> + bdrv_dec_in_flight(bs);
> + return co.ret;
> +}
> +
> +int coroutine_fn bdrv_co_pr_release(BlockDriverState *bs, uint64_t key,
> + BlockPrType type)
> +{
> + BlockDriver *drv = bs->drv;
> + CoroutineIOCompletion co = {
> + .coroutine = qemu_coroutine_self(),
> + };
> +
> + IO_CODE();
> + assert_bdrv_graph_readable();
> +
> + bdrv_inc_in_flight(bs);
> + if (!drv || !drv->bdrv_co_pr_release) {
> + co.ret = -ENOTSUP;
> + goto out;
> + }
> +
> + co.ret = drv->bdrv_co_pr_release(bs, key, type);
> +out:
> + bdrv_dec_in_flight(bs);
> + return co.ret;
> +}
> +
> +int coroutine_fn bdrv_co_pr_clear(BlockDriverState *bs, uint64_t key)
> +{
> + BlockDriver *drv = bs->drv;
> + CoroutineIOCompletion co = {
> + .coroutine = qemu_coroutine_self(),
> + };
> +
> + IO_CODE();
> + assert_bdrv_graph_readable();
> +
> + bdrv_inc_in_flight(bs);
> + if (!drv || !drv->bdrv_co_pr_clear) {
> + co.ret = -ENOTSUP;
> + goto out;
> + }
> +
> + co.ret = drv->bdrv_co_pr_clear(bs, key);
> +out:
> + bdrv_dec_in_flight(bs);
> + return co.ret;
> +}
> +
> +int coroutine_fn bdrv_co_pr_preempt(BlockDriverState *bs, uint64_t old_key,
> + uint64_t new_key, BlockPrType type, bool abort)
> +{
> + BlockDriver *drv = bs->drv;
> + CoroutineIOCompletion co = {
> + .coroutine = qemu_coroutine_self(),
> + };
> +
> + IO_CODE();
> + assert_bdrv_graph_readable();
> +
> + bdrv_inc_in_flight(bs);
> + if (!drv || !drv->bdrv_co_pr_preempt) {
> + co.ret = -ENOTSUP;
> + goto out;
> + }
> +
> + co.ret = drv->bdrv_co_pr_preempt(bs, old_key, new_key, type, abort);
> +out:
> + bdrv_dec_in_flight(bs);
> + return co.ret;
> +}
> +
> int coroutine_fn bdrv_co_zone_report(BlockDriverState *bs, int64_t offset,
> unsigned int *nr_zones,
> BlockZoneDescriptor *zones)
> diff --git a/include/block/block-common.h b/include/block/block-common.h
> index a846023a09..c078d69f79 100644
> --- a/include/block/block-common.h
> +++ b/include/block/block-common.h
> @@ -524,6 +524,15 @@ typedef enum {
> BDRV_FIX_ERRORS = 2,
> } BdrvCheckMode;
>
> +typedef enum {
> + BLK_PR_WRITE_EXCLUSIVE = 0x1,
> + BLK_PR_EXCLUSIVE_ACCESS = 0x2,
> + BLK_PR_WRITE_EXCLUSIVE_REGS_ONLY = 0x3,
> + BLK_PR_EXCLUSIVE_ACCESS_REGS_ONLY = 0x4,
> + BLK_PR_WRITE_EXCLUSIVE_ALL_REGS = 0x5,
> + BLK_PR_EXCLUSIVE_ACCESS_ALL_REGS = 0x6,
Documentation needed. If you don't want to document the full meaning
here, please include a comment referring to a specific section in a
SCSI/NVMe standard that explains the semantics.
> +} BlockPrType;
> +
> typedef struct BlockSizes {
> uint32_t phys;
> uint32_t log;
> diff --git a/include/block/block-io.h b/include/block/block-io.h
> index b49e0537dd..f2827cd74e 100644
> --- a/include/block/block-io.h
> +++ b/include/block/block-io.h
> @@ -106,6 +106,25 @@ void bdrv_aio_cancel_async(BlockAIOCB *acb);
> int coroutine_fn GRAPH_RDLOCK
> bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
>
> +int coroutine_fn GRAPH_RDLOCK
> +bdrv_co_pr_read_keys(BlockDriverState *bs, uint32_t *generation,
> + uint32_t num_keys, uint64_t *keys);
> +int coroutine_fn GRAPH_RDLOCK
> +bdrv_co_pr_read_reservation(BlockDriverState *bs, uint32_t *generation,
> + uint64_t *key, BlockPrType *type);
> +int coroutine_fn GRAPH_RDLOCK
> +bdrv_co_pr_register(BlockDriverState *bs, uint64_t old_key,
> + uint64_t new_key, BlockPrType type, bool ignore_key);
> +int coroutine_fn GRAPH_RDLOCK
> +bdrv_co_pr_reserve(BlockDriverState *bs, uint64_t key, BlockPrType type);
> +int coroutine_fn GRAPH_RDLOCK
> +bdrv_co_pr_release(BlockDriverState *bs, uint64_t key, BlockPrType type);
> +int coroutine_fn GRAPH_RDLOCK
> +bdrv_co_pr_clear(BlockDriverState *bs, uint64_t key);
> +int coroutine_fn GRAPH_RDLOCK
> +bdrv_co_pr_preempt(BlockDriverState *bs, uint64_t old_key, uint64_t new_key,
> + BlockPrType type, bool abort);
> +
> /* Ensure contents are flushed to disk. */
> int coroutine_fn GRAPH_RDLOCK bdrv_co_flush(BlockDriverState *bs);
>
> diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
> index 761276127e..e5526f1d04 100644
> --- a/include/block/block_int-common.h
> +++ b/include/block/block_int-common.h
> @@ -766,6 +766,37 @@ struct BlockDriver {
> int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_ioctl)(
> BlockDriverState *bs, unsigned long int req, void *buf);
>
> + /**
> + * bdrv_co_pr_read_keys is called to read the registered keys,
> + * @num_keys is the maximum number of keys that can be transmitted.
> + * On success, store generation in @generation and store keys @keys
> + * and return the number of @keys.
> + * On failure return -errno.
> + */
> + int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_read_keys)(
> + BlockDriverState *bs, uint32_t *generation,
> + uint32_t num_keys, uint64_t *keys);
> + int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_read_reservation)(
> + BlockDriverState *bs, uint32_t *generation,
> + uint64_t *key, BlockPrType *type);
Plase add doc comments for each new function. It's okay to refer to
specific sections in the SCSI or NVMe standards if explaining the
concepts is too verbose. Someone implementing persistent reservations
support in another block driver must be able to figure out what the
exact model for persistent reservations is.
> +
> + /**
> + * Persist Through Power Loss(PTPL) is considered as required in QEMU
> + * block layer, the block driver need always enable PTPL.
> + */
What is the reasoning behind this? Will applications that rely on PTPL=0
work?
> + int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_register)(
> + BlockDriverState *bs, uint64_t old_key,
> + uint64_t new_key, BlockPrType type, bool ignore_key);
> + int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_reserve)(
> + BlockDriverState *bs, uint64_t key, BlockPrType type);
> + int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_release)(
> + BlockDriverState *bs, uint64_t key, BlockPrType type);
> + int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_clear)(
> + BlockDriverState *bs, uint64_t key);
> + int coroutine_fn GRAPH_RDLOCK_PTR(*bdrv_co_pr_preempt)(
> + BlockDriverState *bs, uint64_t old_key,
> + uint64_t new_key, BlockPrType type, bool abort);
Does a block driver need to implement all or none of these callbacks? I
guess they are not optional on a per-callback basis.
> +
> /*
> * Returns 0 for completed check, -errno for internal errors.
> * The check results are stored in result.
> diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
> index d174275a5c..f87c61c06e 100644
> --- a/include/sysemu/block-backend-io.h
> +++ b/include/sysemu/block-backend-io.h
> @@ -62,6 +62,28 @@ void blk_aio_cancel_async(BlockAIOCB *acb);
> BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
> BlockCompletionFunc *cb, void *opaque);
>
> +BlockAIOCB *blk_aio_pr_read_keys(BlockBackend *blk, uint32_t *generation,
> + uint32_t num_keys, uint64_t *keys,
> + BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *blk_aio_pr_read_reservation(BlockBackend *blk, uint32_t *generation,
> + uint64_t *key, BlockPrType *type,
> + BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *blk_aio_pr_register(BlockBackend *blk, uint64_t old_key,
> + uint64_t new_key, BlockPrType type,
> + bool ignore_key, BlockCompletionFunc *cb,
> + void *opaque);
> +BlockAIOCB *blk_aio_pr_reserve(BlockBackend *blk, uint64_t key,
> + BlockPrType type, BlockCompletionFunc *cb,
> + void *opaque);
> +BlockAIOCB *blk_aio_pr_release(BlockBackend *blk, uint64_t key,
> + BlockPrType type, BlockCompletionFunc *cb,
> + void *opaque);
> +BlockAIOCB *blk_aio_pr_clear(BlockBackend *blk, uint64_t key,
> + BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *blk_aio_pr_preempt(BlockBackend *blk, uint64_t old_key,
> + uint64_t new_key, BlockPrType type, bool abort,
> + BlockCompletionFunc *cb, void *opaque);
> +
> void blk_inc_in_flight(BlockBackend *blk);
> void blk_dec_in_flight(BlockBackend *blk);
>
> --
> 2.20.1
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/9] block/raw: add persistent reservation in/out driver
2024-05-08 9:36 ` [PATCH 2/9] block/raw: add persistent reservation in/out driver Changqi Lu
@ 2024-05-09 18:23 ` Stefan Hajnoczi
0 siblings, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 18:23 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 617 bytes --]
On Wed, May 08, 2024 at 05:36:22PM +0800, Changqi Lu wrote:
> Add persistent reservation in/out operations for raw driver.
> The following methods are implemented: bdrv_co_pr_read_keys,
> bdrv_co_pr_read_reservation, bdrv_co_pr_register, bdrv_co_pr_reserve,
> bdrv_co_pr_release, bdrv_co_pr_clear and bdrv_co_pr_preempt.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> block/raw-format.c | 55 ++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 55 insertions(+)
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 3/9] scsi/constant: add persistent reservation in/out protocol constants
2024-05-08 9:36 ` [PATCH 3/9] scsi/constant: add persistent reservation in/out protocol constants Changqi Lu
@ 2024-05-09 18:28 ` Stefan Hajnoczi
0 siblings, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 18:28 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 612 bytes --]
On Wed, May 08, 2024 at 05:36:23PM +0800, Changqi Lu wrote:
> Add constants for the persistent reservation in/out protocol
> in the scsi/constant module. The constants include the persistent
> reservation command, type, and scope values defined in sections
> 6.13 and 6.14 of the SCSI Primary Commands-4 (SPC-4) specification.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> include/scsi/constants.h | 29 +++++++++++++++++++++++++++++
> 1 file changed, 29 insertions(+)
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 4/9] scsi/util: add helper functions for persistent reservation types conversion
2024-05-08 9:36 ` [PATCH 4/9] scsi/util: add helper functions for persistent reservation types conversion Changqi Lu
@ 2024-05-09 18:28 ` Stefan Hajnoczi
0 siblings, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 18:28 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 574 bytes --]
On Wed, May 08, 2024 at 05:36:24PM +0800, Changqi Lu wrote:
> This commit introduces two helper functions
> that facilitate the conversion between the
> persistent reservation types used in the SCSI
> protocol and those used in the block layer.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> include/scsi/utils.h | 5 +++++
> scsi/utils.c | 40 ++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 45 insertions(+)
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device
2024-05-08 9:36 ` [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device Changqi Lu
@ 2024-05-09 18:45 ` Stefan Hajnoczi
2024-05-09 19:09 ` Stefan Hajnoczi
1 sibling, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 18:45 UTC (permalink / raw)
To: Paolo Bonzini
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
Changqi Lu, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 13453 bytes --]
On Wed, May 08, 2024 at 05:36:25PM +0800, Changqi Lu wrote:
> Add persistent reservation in/out operations in the
> SCSI device layer. By introducing the persistent
> reservation in/out api, this enables the SCSI device
> to perform reservation-related tasks, including querying
> keys, querying reservation status, registering reservation
> keys, initiating and releasing reservations, as well as
> clearing and preempting reservations held by other keys.
>
> These operations are crucial for management and control of
> shared storage resources in a persistent manner.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> hw/scsi/scsi-disk.c | 302 ++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 302 insertions(+)
Paolo: Please review for buffer overflows. I find the buffer size
assumption in the SCSI layer mysterious (e.g. scsi_req_get_buf() returns
a void* and it's not obvious how large the buffer is), so I didn't check
for buffer overflows.
>
> diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
> index 4bd7af9d0c..bdd66c4026 100644
> --- a/hw/scsi/scsi-disk.c
> +++ b/hw/scsi/scsi-disk.c
> @@ -32,6 +32,7 @@
> #include "migration/vmstate.h"
> #include "hw/scsi/emulation.h"
> #include "scsi/constants.h"
> +#include "scsi/utils.h"
> #include "sysemu/block-backend.h"
> #include "sysemu/blockdev.h"
> #include "hw/block/block.h"
> @@ -1474,6 +1475,296 @@ static void scsi_disk_emulate_read_data(SCSIRequest *req)
> scsi_req_complete(&r->req, GOOD);
> }
>
> +typedef struct SCSIPrReadKeys {
> + uint32_t generation;
> + uint32_t num_keys;
> + uint64_t *keys;
> + void *req;
> +} SCSIPrReadKeys;
> +
> +typedef struct SCSIPrReadReservation {
> + uint32_t generation;
> + uint64_t key;
> + BlockPrType type;
> + void *req;
> +} SCSIPrReadReservation;
> +
> +static void scsi_pr_read_keys_complete(void *opaque, int ret)
> +{
> + int num_keys;
> + uint8_t *buf;
> + SCSIPrReadKeys *blk_keys = (SCSIPrReadKeys *)opaque;
> + SCSIDiskReq *r = (SCSIDiskReq *)blk_keys->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
> +
> + assert(blk_get_aio_context(s->qdev.conf.blk) ==
> + qemu_get_current_aio_context());
> +
> + assert(r->req.aiocb != NULL);
> + r->req.aiocb = NULL;
> +
> + if (scsi_disk_req_check_error(r, ret, true)) {
> + goto done;
> + }
> +
> + buf = scsi_req_get_buf(&r->req);
> + num_keys = MIN(blk_keys->num_keys, ret);
> + blk_keys->generation = cpu_to_be32(blk_keys->generation);
> + memcpy(&buf[0], &blk_keys->generation, 4);
> + for (int i = 0; i < num_keys; i++) {
> + blk_keys->keys[i] = cpu_to_be64(blk_keys->keys[i]);
> + memcpy(&buf[8 + i * 8], &blk_keys->keys[i], 8);
> + }
> + num_keys = cpu_to_be32(num_keys * 8);
> + memcpy(&buf[4], &num_keys, 4);
> +
> + scsi_req_data(&r->req, r->buflen);
> +done:
> + scsi_req_unref(&r->req);
> + g_free(blk_keys->keys);
> + g_free(blk_keys);
> +}
> +
> +static int scsi_disk_emulate_pr_read_keys(SCSIRequest *req)
> +{
> + SCSIPrReadKeys *blk_keys;
> + SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> + int buflen = MIN(r->req.cmd.xfer, r->buflen);
> + int num_keys = (buflen - sizeof(uint32_t) * 2) / sizeof(uint64_t);
> +
> + blk_keys = g_new0(SCSIPrReadKeys, 1);
> + blk_keys->generation = 0;
> + /* num_keys is the maximum number of keys that can be transmitted */
> + blk_keys->num_keys = num_keys;
> + blk_keys->keys = g_malloc(sizeof(uint64_t) * num_keys);
> + blk_keys->req = r;
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_read_keys(s->qdev.conf.blk, &blk_keys->generation,
> + blk_keys->num_keys, blk_keys->keys,
> + scsi_pr_read_keys_complete, blk_keys);
> + return 0;
> +}
> +
> +static void scsi_pr_read_reservation_complete(void *opaque, int ret)
> +{
> + uint8_t *buf;
> + uint32_t num_keys = 0;
> + SCSIPrReadReservation *blk_rsv = (SCSIPrReadReservation *)opaque;
> + SCSIDiskReq *r = (SCSIDiskReq *)blk_rsv->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
> +
> + assert(blk_get_aio_context(s->qdev.conf.blk) ==
> + qemu_get_current_aio_context());
> +
> + assert(r->req.aiocb != NULL);
> + r->req.aiocb = NULL;
> +
> + if (scsi_disk_req_check_error(r, ret, true)) {
> + goto done;
> + }
> +
> + buf = scsi_req_get_buf(&r->req);
> + blk_rsv->generation = cpu_to_be32(blk_rsv->generation);
> + memcpy(&buf[0], &blk_rsv->generation, 4);
> + if (ret) {
> + num_keys = cpu_to_be32(16);
The SPC-6 calls this field Additional Length, which is clearer than
num_keys (there is only 1 key here!). Could you rename it to
additional_len to avoid confusion?
> + blk_rsv->key = cpu_to_be64(blk_rsv->key);
> + memcpy(&buf[8], &blk_rsv->key, 8);
> + buf[21] = block_pr_type_to_scsi(blk_rsv->type) & 0xf;
> + } else {
> + num_keys = cpu_to_be32(0);
> + }
> +
> + memcpy(&buf[4], &num_keys, 4);
> + scsi_req_data(&r->req, r->buflen);
> +
> +done:
> + scsi_req_unref(&r->req);
> + g_free(blk_rsv);
> +}
> +
> +static int scsi_disk_emulate_pr_read_reservation(SCSIRequest *req)
> +{
> + SCSIPrReadReservation *blk_rsv;
> + SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + blk_rsv = g_malloc(sizeof(*blk_rsv));
> + blk_rsv->generation = 0;
> + blk_rsv->key = 0;
> + blk_rsv->type = 0;
> + blk_rsv->req = r;
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_read_reservation(s->qdev.conf.blk,
> + &blk_rsv->generation, &blk_rsv->key, &blk_rsv->type,
> + scsi_pr_read_reservation_complete, blk_rsv);
> + return 0;
> +}
> +
> +static void scsi_aio_pr_complete(void *opaque, int ret)
> +{
> + SCSIDiskReq *r = (SCSIDiskReq *)opaque;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
> +
> + /* The request must only run in the BlockBackend's AioContext */
> + assert(blk_get_aio_context(s->qdev.conf.blk) ==
> + qemu_get_current_aio_context());
> +
> + assert(r->req.aiocb != NULL);
> + r->req.aiocb = NULL;
> +
> + if (scsi_disk_req_check_error(r, ret, true)) {
> + goto done;
> + }
> +
> + scsi_req_complete(&r->req, GOOD);
> +
> +done:
> + scsi_req_unref(&r->req);
> +}
> +
> +static int scsi_disk_emulate_pr_register(SCSIDiskReq *r, uint64_t old_key,
> + uint64_t new_key, SCSIPrType type,
> + bool ignore_key)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_register(s->qdev.conf.blk, old_key, new_key,
> + scsi_pr_type_to_block(type),
> + ignore_key, scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_reserve(SCSIDiskReq *r, uint64_t key,
> + SCSIPrType type)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_reserve(s->qdev.conf.blk, key,
> + scsi_pr_type_to_block(type),
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_release(SCSIDiskReq *r, uint64_t key,
> + SCSIPrType type)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_release(s->qdev.conf.blk, key,
> + scsi_pr_type_to_block(type),
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_clear(SCSIDiskReq *r, uint64_t key)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_clear(s->qdev.conf.blk, key,
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_preempt(SCSIDiskReq *r, uint64_t new_key,
> + uint64_t old_key, SCSIPrType type,
> + bool abort)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_preempt(s->qdev.conf.blk, new_key, old_key,
> + scsi_pr_type_to_block(type), abort,
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_in(SCSIRequest *req)
> +{
> + int rc;
> + SCSIPrInAction action = req->cmd.buf[1] & 0x1f;
> +
> + switch (action) {
> + case SCSI_PR_IN_READ_KEYS:
> + rc = scsi_disk_emulate_pr_read_keys(req);
> + break;
> + case SCSI_PR_IN_READ_RESERVATION:
> + rc = scsi_disk_emulate_pr_read_reservation(req);
> + break;
> + default:
> + return -ENOTSUP;
> + }
> +
> + return rc;
> +}
> +
> +static int scsi_disk_emulate_pr_out(SCSIDiskReq *r, uint8_t *inbuf)
> +{
> + int rc;
> + uint64_t old_key, new_key;
> + SCSIPrOutAction action;
> + SCSIPrScope scope;
> + SCSIPrType type;
> + SCSIRequest *req = &r->req;
> +
> + memcpy(&old_key, &inbuf[0], 8);
> + old_key = be64_to_cpu(old_key);
> + memcpy(&new_key, &inbuf[8], 8);
> + new_key = be64_to_cpu(new_key);
> + action = req->cmd.buf[1] & 0x1f;
> + scope = (req->cmd.buf[2] >> 4) & 0x0f;
> + type = req->cmd.buf[2] & 0x0f;
> +
> + if (scope != SCSI_PR_LU_SCOPE) {
> + return -ENOTSUP;
> + }
> +
> + switch (action) {
> + case SCSI_PR_OUT_REGISTER:
> + rc = scsi_disk_emulate_pr_register(r, old_key, new_key, type, false);
> + break;
> + case SCSI_PR_OUT_REG_AND_IGNORE_KEY:
> + rc = scsi_disk_emulate_pr_register(r, old_key, new_key, type, true);
> + break;
> + case SCSI_PR_OUT_RESERVE:
> + rc = scsi_disk_emulate_pr_reserve(r, old_key, type);
> + break;
> + case SCSI_PR_OUT_RELEASE:
> + rc = scsi_disk_emulate_pr_release(r, old_key, type);
> + break;
> + case SCSI_PR_OUT_CLEAR:
> + rc = scsi_disk_emulate_pr_clear(r, old_key);
> + break;
> + case SCSI_PR_OUT_PREEMPT:
> + rc = scsi_disk_emulate_pr_preempt(r, old_key, new_key, type, false);
> + break;
> + case SCSI_PR_OUT_PREEMPT_AND_ABORT:
> + rc = scsi_disk_emulate_pr_preempt(r, old_key, new_key, type, true);
> + break;
> + default:
> + return -ENOTSUP;
> + }
> +
> + return rc;
> +}
> +
> static int scsi_disk_check_mode_select(SCSIDiskState *s, int page,
> uint8_t *inbuf, int inlen)
> {
> @@ -1957,6 +2248,9 @@ static void scsi_disk_emulate_write_data(SCSIRequest *req)
> scsi_req_complete(&r->req, GOOD);
> break;
>
> + case PERSISTENT_RESERVE_OUT:
> + scsi_disk_emulate_pr_out(r, r->iov.iov_base);
> + break;
> default:
> abort();
> }
> @@ -2213,6 +2507,12 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf)
> case FORMAT_UNIT:
> trace_scsi_disk_emulate_command_FORMAT_UNIT(r->req.cmd.xfer);
> break;
> + case PERSISTENT_RESERVE_OUT:
> + break;
> + case PERSISTENT_RESERVE_IN:
> + scsi_req_ref(&r->req);
Please add a comment indicating which scsi_req_unref() this ref is
paired with. That makes it easier to understand request reference
counting.
> + scsi_disk_emulate_pr_in(req);
> + return 0;
> default:
> trace_scsi_disk_emulate_command_UNKNOWN(buf[0],
> scsi_command_name(buf[0]));
> @@ -2632,6 +2932,8 @@ static const SCSIReqOps *const scsi_disk_reqops_dispatch[256] = {
> [VERIFY_12] = &scsi_disk_emulate_reqops,
> [VERIFY_16] = &scsi_disk_emulate_reqops,
> [FORMAT_UNIT] = &scsi_disk_emulate_reqops,
> + [PERSISTENT_RESERVE_IN] = &scsi_disk_emulate_reqops,
> + [PERSISTENT_RESERVE_OUT] = &scsi_disk_emulate_reqops,
>
> [READ_6] = &scsi_disk_dma_reqops,
> [READ_10] = &scsi_disk_dma_reqops,
> --
> 2.20.1
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 6/9] block/nvme: add reservation command protocol constants
2024-05-08 9:36 ` [PATCH 6/9] block/nvme: add reservation command protocol constants Changqi Lu
@ 2024-05-09 18:48 ` Stefan Hajnoczi
0 siblings, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 18:48 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 539 bytes --]
On Wed, May 08, 2024 at 05:36:26PM +0800, Changqi Lu wrote:
> Add constants for the NVMe persistent command protocol.
> The constants include the reservation command opcode and
> reservation type values defined in section 7 of the NVMe
> 2.0 specification.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> include/block/nvme.h | 30 ++++++++++++++++++++++++++++++
> 1 file changed, 30 insertions(+)
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 7/9] hw/nvme: add helper functions for converting reservation types
2024-05-08 9:36 ` [PATCH 7/9] hw/nvme: add helper functions for converting reservation types Changqi Lu
@ 2024-05-09 18:48 ` Stefan Hajnoczi
0 siblings, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 18:48 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 520 bytes --]
On Wed, May 08, 2024 at 05:36:27PM +0800, Changqi Lu wrote:
> This commit introduces two helper functions
> that facilitate the conversion between the
> reservation types used in the NVME protocol
> and those used in the block layer.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> hw/nvme/nvme.h | 40 ++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 40 insertions(+)
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 0/9] Support persistent reservation operations
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
` (8 preceding siblings ...)
2024-05-08 9:36 ` [PATCH 9/9] block/iscsi: add persistent reservation in/out driver Changqi Lu
@ 2024-05-09 19:08 ` Stefan Hajnoczi
9 siblings, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 19:08 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd
[-- Attachment #1: Type: text/plain, Size: 1352 bytes --]
On Wed, May 08, 2024 at 05:36:20PM +0800, Changqi Lu wrote:
> Hi,
>
> I am going to introduce persistent reservation for QEMU block.
> There are three parts in this series:
>
> Firstly, at the block layer, the commit abstracts seven APIs related to
> the persistent reservation command. These APIs including reading keys,
> reading reservations, registering, reserving, releasing, clearing and preempting.
>
> Next, the commit implements the necessary pr-related operation APIs for both the
> SCSI protocol and NVMe protocol at the device layer. This ensures that the necessary
> functionality is available for handling persistent reservations in these protocols.
>
> Finally, the commit includes adaptations to the iscsi driver at the driver layer
> to verify the correct implementation and functionality of the changes.
>
> With these changes, GFS works fine in the guest. Also, sg-utils(for SCSI block) and
> nvme-cli(for NVMe block) work fine too.
What is the relationship to the existing PRManager functionality
(docs/interop/pr-helper.rst) where block/file-posix.c interprets SCSI
ioctls and sends persistent reservation requests to an external helper
process?
I wonder if block/file-posix.c can implement the new block driver
callbacks using pr_mgr (while keeping the existing scsi-generic
support).
Stefan
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device
2024-05-08 9:36 ` [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device Changqi Lu
2024-05-09 18:45 ` Stefan Hajnoczi
@ 2024-05-09 19:09 ` Stefan Hajnoczi
1 sibling, 0 replies; 21+ messages in thread
From: Stefan Hajnoczi @ 2024-05-09 19:09 UTC (permalink / raw)
To: Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd, zhenwei pi
[-- Attachment #1: Type: text/plain, Size: 13075 bytes --]
On Wed, May 08, 2024 at 05:36:25PM +0800, Changqi Lu wrote:
> Add persistent reservation in/out operations in the
> SCSI device layer. By introducing the persistent
> reservation in/out api, this enables the SCSI device
> to perform reservation-related tasks, including querying
> keys, querying reservation status, registering reservation
> keys, initiating and releasing reservations, as well as
> clearing and preempting reservations held by other keys.
>
> These operations are crucial for management and control of
> shared storage resources in a persistent manner.
>
> Signed-off-by: Changqi Lu <luchangqi.123@bytedance.com>
> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com>
> ---
> hw/scsi/scsi-disk.c | 302 ++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 302 insertions(+)
Does sg_persist --report-capabilities
(https://linux.die.net/man/8/sg_persist) show that persistent
reservations are supported? Maybe some INQUIRY data still needs to be
added.
>
> diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
> index 4bd7af9d0c..bdd66c4026 100644
> --- a/hw/scsi/scsi-disk.c
> +++ b/hw/scsi/scsi-disk.c
> @@ -32,6 +32,7 @@
> #include "migration/vmstate.h"
> #include "hw/scsi/emulation.h"
> #include "scsi/constants.h"
> +#include "scsi/utils.h"
> #include "sysemu/block-backend.h"
> #include "sysemu/blockdev.h"
> #include "hw/block/block.h"
> @@ -1474,6 +1475,296 @@ static void scsi_disk_emulate_read_data(SCSIRequest *req)
> scsi_req_complete(&r->req, GOOD);
> }
>
> +typedef struct SCSIPrReadKeys {
> + uint32_t generation;
> + uint32_t num_keys;
> + uint64_t *keys;
> + void *req;
> +} SCSIPrReadKeys;
> +
> +typedef struct SCSIPrReadReservation {
> + uint32_t generation;
> + uint64_t key;
> + BlockPrType type;
> + void *req;
> +} SCSIPrReadReservation;
> +
> +static void scsi_pr_read_keys_complete(void *opaque, int ret)
> +{
> + int num_keys;
> + uint8_t *buf;
> + SCSIPrReadKeys *blk_keys = (SCSIPrReadKeys *)opaque;
> + SCSIDiskReq *r = (SCSIDiskReq *)blk_keys->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
> +
> + assert(blk_get_aio_context(s->qdev.conf.blk) ==
> + qemu_get_current_aio_context());
> +
> + assert(r->req.aiocb != NULL);
> + r->req.aiocb = NULL;
> +
> + if (scsi_disk_req_check_error(r, ret, true)) {
> + goto done;
> + }
> +
> + buf = scsi_req_get_buf(&r->req);
> + num_keys = MIN(blk_keys->num_keys, ret);
> + blk_keys->generation = cpu_to_be32(blk_keys->generation);
> + memcpy(&buf[0], &blk_keys->generation, 4);
> + for (int i = 0; i < num_keys; i++) {
> + blk_keys->keys[i] = cpu_to_be64(blk_keys->keys[i]);
> + memcpy(&buf[8 + i * 8], &blk_keys->keys[i], 8);
> + }
> + num_keys = cpu_to_be32(num_keys * 8);
> + memcpy(&buf[4], &num_keys, 4);
> +
> + scsi_req_data(&r->req, r->buflen);
> +done:
> + scsi_req_unref(&r->req);
> + g_free(blk_keys->keys);
> + g_free(blk_keys);
> +}
> +
> +static int scsi_disk_emulate_pr_read_keys(SCSIRequest *req)
> +{
> + SCSIPrReadKeys *blk_keys;
> + SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> + int buflen = MIN(r->req.cmd.xfer, r->buflen);
> + int num_keys = (buflen - sizeof(uint32_t) * 2) / sizeof(uint64_t);
> +
> + blk_keys = g_new0(SCSIPrReadKeys, 1);
> + blk_keys->generation = 0;
> + /* num_keys is the maximum number of keys that can be transmitted */
> + blk_keys->num_keys = num_keys;
> + blk_keys->keys = g_malloc(sizeof(uint64_t) * num_keys);
> + blk_keys->req = r;
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_read_keys(s->qdev.conf.blk, &blk_keys->generation,
> + blk_keys->num_keys, blk_keys->keys,
> + scsi_pr_read_keys_complete, blk_keys);
> + return 0;
> +}
> +
> +static void scsi_pr_read_reservation_complete(void *opaque, int ret)
> +{
> + uint8_t *buf;
> + uint32_t num_keys = 0;
> + SCSIPrReadReservation *blk_rsv = (SCSIPrReadReservation *)opaque;
> + SCSIDiskReq *r = (SCSIDiskReq *)blk_rsv->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
> +
> + assert(blk_get_aio_context(s->qdev.conf.blk) ==
> + qemu_get_current_aio_context());
> +
> + assert(r->req.aiocb != NULL);
> + r->req.aiocb = NULL;
> +
> + if (scsi_disk_req_check_error(r, ret, true)) {
> + goto done;
> + }
> +
> + buf = scsi_req_get_buf(&r->req);
> + blk_rsv->generation = cpu_to_be32(blk_rsv->generation);
> + memcpy(&buf[0], &blk_rsv->generation, 4);
> + if (ret) {
> + num_keys = cpu_to_be32(16);
> + blk_rsv->key = cpu_to_be64(blk_rsv->key);
> + memcpy(&buf[8], &blk_rsv->key, 8);
> + buf[21] = block_pr_type_to_scsi(blk_rsv->type) & 0xf;
> + } else {
> + num_keys = cpu_to_be32(0);
> + }
> +
> + memcpy(&buf[4], &num_keys, 4);
> + scsi_req_data(&r->req, r->buflen);
> +
> +done:
> + scsi_req_unref(&r->req);
> + g_free(blk_rsv);
> +}
> +
> +static int scsi_disk_emulate_pr_read_reservation(SCSIRequest *req)
> +{
> + SCSIPrReadReservation *blk_rsv;
> + SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + blk_rsv = g_malloc(sizeof(*blk_rsv));
> + blk_rsv->generation = 0;
> + blk_rsv->key = 0;
> + blk_rsv->type = 0;
> + blk_rsv->req = r;
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_read_reservation(s->qdev.conf.blk,
> + &blk_rsv->generation, &blk_rsv->key, &blk_rsv->type,
> + scsi_pr_read_reservation_complete, blk_rsv);
> + return 0;
> +}
> +
> +static void scsi_aio_pr_complete(void *opaque, int ret)
> +{
> + SCSIDiskReq *r = (SCSIDiskReq *)opaque;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
> +
> + /* The request must only run in the BlockBackend's AioContext */
> + assert(blk_get_aio_context(s->qdev.conf.blk) ==
> + qemu_get_current_aio_context());
> +
> + assert(r->req.aiocb != NULL);
> + r->req.aiocb = NULL;
> +
> + if (scsi_disk_req_check_error(r, ret, true)) {
> + goto done;
> + }
> +
> + scsi_req_complete(&r->req, GOOD);
> +
> +done:
> + scsi_req_unref(&r->req);
> +}
> +
> +static int scsi_disk_emulate_pr_register(SCSIDiskReq *r, uint64_t old_key,
> + uint64_t new_key, SCSIPrType type,
> + bool ignore_key)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_register(s->qdev.conf.blk, old_key, new_key,
> + scsi_pr_type_to_block(type),
> + ignore_key, scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_reserve(SCSIDiskReq *r, uint64_t key,
> + SCSIPrType type)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_reserve(s->qdev.conf.blk, key,
> + scsi_pr_type_to_block(type),
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_release(SCSIDiskReq *r, uint64_t key,
> + SCSIPrType type)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_release(s->qdev.conf.blk, key,
> + scsi_pr_type_to_block(type),
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_clear(SCSIDiskReq *r, uint64_t key)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_clear(s->qdev.conf.blk, key,
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_preempt(SCSIDiskReq *r, uint64_t new_key,
> + uint64_t old_key, SCSIPrType type,
> + bool abort)
> +{
> + SCSIRequest *req = &r->req;
> + SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
> +
> + scsi_req_ref(&r->req);
> + r->req.aiocb = blk_aio_pr_preempt(s->qdev.conf.blk, new_key, old_key,
> + scsi_pr_type_to_block(type), abort,
> + scsi_aio_pr_complete, r);
> +
> + return 0;
> +}
> +
> +static int scsi_disk_emulate_pr_in(SCSIRequest *req)
> +{
> + int rc;
> + SCSIPrInAction action = req->cmd.buf[1] & 0x1f;
> +
> + switch (action) {
> + case SCSI_PR_IN_READ_KEYS:
> + rc = scsi_disk_emulate_pr_read_keys(req);
> + break;
> + case SCSI_PR_IN_READ_RESERVATION:
> + rc = scsi_disk_emulate_pr_read_reservation(req);
> + break;
> + default:
> + return -ENOTSUP;
> + }
> +
> + return rc;
> +}
> +
> +static int scsi_disk_emulate_pr_out(SCSIDiskReq *r, uint8_t *inbuf)
> +{
> + int rc;
> + uint64_t old_key, new_key;
> + SCSIPrOutAction action;
> + SCSIPrScope scope;
> + SCSIPrType type;
> + SCSIRequest *req = &r->req;
> +
> + memcpy(&old_key, &inbuf[0], 8);
> + old_key = be64_to_cpu(old_key);
> + memcpy(&new_key, &inbuf[8], 8);
> + new_key = be64_to_cpu(new_key);
> + action = req->cmd.buf[1] & 0x1f;
> + scope = (req->cmd.buf[2] >> 4) & 0x0f;
> + type = req->cmd.buf[2] & 0x0f;
> +
> + if (scope != SCSI_PR_LU_SCOPE) {
> + return -ENOTSUP;
> + }
> +
> + switch (action) {
> + case SCSI_PR_OUT_REGISTER:
> + rc = scsi_disk_emulate_pr_register(r, old_key, new_key, type, false);
> + break;
> + case SCSI_PR_OUT_REG_AND_IGNORE_KEY:
> + rc = scsi_disk_emulate_pr_register(r, old_key, new_key, type, true);
> + break;
> + case SCSI_PR_OUT_RESERVE:
> + rc = scsi_disk_emulate_pr_reserve(r, old_key, type);
> + break;
> + case SCSI_PR_OUT_RELEASE:
> + rc = scsi_disk_emulate_pr_release(r, old_key, type);
> + break;
> + case SCSI_PR_OUT_CLEAR:
> + rc = scsi_disk_emulate_pr_clear(r, old_key);
> + break;
> + case SCSI_PR_OUT_PREEMPT:
> + rc = scsi_disk_emulate_pr_preempt(r, old_key, new_key, type, false);
> + break;
> + case SCSI_PR_OUT_PREEMPT_AND_ABORT:
> + rc = scsi_disk_emulate_pr_preempt(r, old_key, new_key, type, true);
> + break;
> + default:
> + return -ENOTSUP;
> + }
> +
> + return rc;
> +}
> +
> static int scsi_disk_check_mode_select(SCSIDiskState *s, int page,
> uint8_t *inbuf, int inlen)
> {
> @@ -1957,6 +2248,9 @@ static void scsi_disk_emulate_write_data(SCSIRequest *req)
> scsi_req_complete(&r->req, GOOD);
> break;
>
> + case PERSISTENT_RESERVE_OUT:
> + scsi_disk_emulate_pr_out(r, r->iov.iov_base);
> + break;
> default:
> abort();
> }
> @@ -2213,6 +2507,12 @@ static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf)
> case FORMAT_UNIT:
> trace_scsi_disk_emulate_command_FORMAT_UNIT(r->req.cmd.xfer);
> break;
> + case PERSISTENT_RESERVE_OUT:
> + break;
> + case PERSISTENT_RESERVE_IN:
> + scsi_req_ref(&r->req);
> + scsi_disk_emulate_pr_in(req);
> + return 0;
> default:
> trace_scsi_disk_emulate_command_UNKNOWN(buf[0],
> scsi_command_name(buf[0]));
> @@ -2632,6 +2932,8 @@ static const SCSIReqOps *const scsi_disk_reqops_dispatch[256] = {
> [VERIFY_12] = &scsi_disk_emulate_reqops,
> [VERIFY_16] = &scsi_disk_emulate_reqops,
> [FORMAT_UNIT] = &scsi_disk_emulate_reqops,
> + [PERSISTENT_RESERVE_IN] = &scsi_disk_emulate_reqops,
> + [PERSISTENT_RESERVE_OUT] = &scsi_disk_emulate_reqops,
>
> [READ_6] = &scsi_disk_dma_reqops,
> [READ_10] = &scsi_disk_dma_reqops,
> --
> 2.20.1
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: Re: [PATCH 1/9] block: add persistent reservation in/out api
2024-05-09 18:22 ` Stefan Hajnoczi
@ 2024-05-10 2:37 ` zhenwei pi
0 siblings, 0 replies; 21+ messages in thread
From: zhenwei pi @ 2024-05-10 2:37 UTC (permalink / raw)
To: Stefan Hajnoczi, Changqi Lu
Cc: qemu-block, qemu-devel, kwolf, hreitz, fam, ronniesahlberg,
pbonzini, pl, kbusch, its, foss, philmd
On 5/10/24 02:22, Stefan Hajnoczi wrote:
> On Wed, May 08, 2024 at 05:36:21PM +0800, Changqi Lu wrote:
[SNIP]
>> +
>> + /**
>> + * Persist Through Power Loss(PTPL) is considered as required in QEMU
>> + * block layer, the block driver need always enable PTPL.
>> + */
>
> What is the reasoning behind this? Will applications that rely on PTPL=0
> work?
>
Hi Stefan,
PTPL needs to be supported at QEMU block layer in theory, include
reporting PTPL capability and PTPL flag in PR OUT command. However, in
the real production environment, both SCSI driver and NVMe driver, even
linux block layer always enable PTPL nnconditionally on a linux platform.
Ref the latest code:
1, SCSI:
https://github.com/torvalds/linux/blob/master/drivers/scsi/sd.c#L1978
static int sd_pr_register(struct block_device *bdev, u64 old_key, u64
new_key,
u32 flags)
{
if (flags & ~PR_FL_IGNORE_KEY)
return -EOPNOTSUPP;
return sd_pr_out_command(bdev, (flags & PR_FL_IGNORE_KEY) ? 0x06 : 0x00,
old_key, new_key, 0,
(1 << 0) /* APTPL */);
}
2, NVMe:
https://github.com/torvalds/linux/blob/master/drivers/nvme/host/pr.c#L127
static int nvme_pr_register(struct block_device *bdev, u64 old,
u64 new, unsigned flags)
{
u32 cdw10;
if (flags & ~PR_FL_IGNORE_KEY)
return -EOPNOTSUPP;
cdw10 = old ? 2 : 0;
cdw10 |= (flags & PR_FL_IGNORE_KEY) ? 1 << 3 : 0;
cdw10 |= (1 << 30) | (1 << 31); /* PTPL=1 */
return nvme_pr_command(bdev, cdw10, old, new, nvme_cmd_resv_register);
}
3, linux block layers also hides PTPL flag:
https://github.com/torvalds/linux/blob/master/block/ioctl.c#L283
static int blkdev_pr_register(struct block_device *bdev, blk_mode_t mode,
struct pr_registration __user *arg)
{
const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops;
struct pr_registration reg;
if (!blkdev_pr_allowed(bdev, mode))
return -EPERM;
if (!ops || !ops->pr_register)
return -EOPNOTSUPP;
if (copy_from_user(®, arg, sizeof(reg)))
return -EFAULT;
if (reg.flags & ~PR_FL_IGNORE_KEY)
return -EOPNOTSUPP;
return ops->pr_register(bdev, reg.old_key, reg.new_key, reg.flags);
}
So we(Changqi and me) wanted to keep PR a bit simple in QEMU block layer:
- consider PTPL is required in QEMU block, then we don't need an extra flag
- the block backend driver always request PR OUT with PTPL flag
Then: Will applications that rely on PTPL=0 work?
Yes, a guest PR out without PTPL will work, but the backend uses PTPL=1
instead.
Will this request succeed?
If the backend driver' supports PTPL capability, it will succeed.
Otherwise it will fail.
--
zhenwei pi
^ permalink raw reply [flat|nested] 21+ messages in thread
end of thread, other threads:[~2024-05-10 2:37 UTC | newest]
Thread overview: 21+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-05-08 9:36 [PATCH 0/9] Support persistent reservation operations Changqi Lu
2024-05-08 9:36 ` [PATCH 1/9] block: add persistent reservation in/out api Changqi Lu
2024-05-09 18:22 ` Stefan Hajnoczi
2024-05-10 2:37 ` zhenwei pi
2024-05-08 9:36 ` [PATCH 2/9] block/raw: add persistent reservation in/out driver Changqi Lu
2024-05-09 18:23 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 3/9] scsi/constant: add persistent reservation in/out protocol constants Changqi Lu
2024-05-09 18:28 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 4/9] scsi/util: add helper functions for persistent reservation types conversion Changqi Lu
2024-05-09 18:28 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 5/9] hw/scsi: add persistent reservation in/out api for scsi device Changqi Lu
2024-05-09 18:45 ` Stefan Hajnoczi
2024-05-09 19:09 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 6/9] block/nvme: add reservation command protocol constants Changqi Lu
2024-05-09 18:48 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 7/9] hw/nvme: add helper functions for converting reservation types Changqi Lu
2024-05-09 18:48 ` Stefan Hajnoczi
2024-05-08 9:36 ` [PATCH 8/9] hw/nvme: add reservation protocal command Changqi Lu
2024-05-08 10:41 ` Klaus Jensen
2024-05-08 9:36 ` [PATCH 9/9] block/iscsi: add persistent reservation in/out driver Changqi Lu
2024-05-09 19:08 ` [PATCH 0/9] Support persistent reservation operations Stefan Hajnoczi
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).