ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bdev/virtio: introduce virtio_scsi_dev

Browse Source 
Virtio-SCSI devices now have their
own structs. This patch introduces
only the struct, no functionality
has changed.

Change-Id: I04907497ed173747875e1b67acad38043bf4de09
Signed-off-by: Dariusz Stojaczyk <dariuszx.stojaczyk@intel.com>
Reviewed-on: https://review.gerrithub.io/390108
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
This commit is contained in:
Dariusz Stojaczyk 2017-11-30 11:58:25 +01:00 committed by Jim Harris
parent 1ce0368f99
commit 491de04cc4
1 changed files with 73 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
lib/bdev/virtio/bdev_virtio.c
View File

@ -67,6 +67,11 @@
static int bdev_virtio_initialize(void); static int bdev_virtio_initialize(void);
static void bdev_virtio_finish(void); static void bdev_virtio_finish(void);
struct virtio_scsi_dev {
/* Generic virtio device data. */
struct virtio_dev vdev;
};
struct virtio_scsi_io_ctx { struct virtio_scsi_io_ctx {
struct virtio_req vreq; struct virtio_req vreq;
union { union {
@ -87,7 +92,7 @@ struct virtio_scsi_scan_info {
}; };
struct virtio_scsi_scan_base { struct virtio_scsi_scan_base {
struct virtio_dev *vdev; struct virtio_scsi_dev *svdev;
/** Virtqueue used for the scan I/O. */ /** Virtqueue used for the scan I/O. */
struct virtqueue *vq; struct virtqueue *vq;
@ -114,13 +119,13 @@ struct virtio_scsi_scan_base {
struct virtio_scsi_disk { struct virtio_scsi_disk {
struct spdk_bdev bdev; struct spdk_bdev bdev;
struct virtio_dev *vdev; struct virtio_scsi_dev *svdev;
struct virtio_scsi_scan_info info; struct virtio_scsi_scan_info info;
TAILQ_ENTRY(virtio_scsi_disk) link; TAILQ_ENTRY(virtio_scsi_disk) link;
}; };
struct bdev_virtio_io_channel { struct bdev_virtio_io_channel {
struct virtio_dev *vdev; struct virtio_scsi_dev *svdev;
/** Virtqueue exclusively assigned to this channel. */ /** Virtqueue exclusively assigned to this channel. */
struct virtqueue *vq; struct virtqueue *vq;
@ -130,17 +135,19 @@ static int
virtio_pci_scsi_dev_create_cb(struct virtio_pci_ctx *pci_ctx) virtio_pci_scsi_dev_create_cb(struct virtio_pci_ctx *pci_ctx)
{ {
static int pci_dev_counter = 0; static int pci_dev_counter = 0;
struct virtio_scsi_dev *svdev;
struct virtio_dev *vdev; struct virtio_dev *vdev;
char *name; char *name;
uint32_t num_queues; uint32_t num_queues;
int rc; int rc;
vdev = calloc(1, sizeof(*vdev)); svdev = calloc(1, sizeof(*svdev));
if (vdev == NULL) { if (svdev == NULL) {
SPDK_ERRLOG("virtio device calloc failed\n"); SPDK_ERRLOG("virtio device calloc failed\n");
return -1; return -1;
} }
vdev = &svdev->vdev;
name = spdk_sprintf_alloc("VirtioScsi%"PRIu32, ++pci_dev_counter); name = spdk_sprintf_alloc("VirtioScsi%"PRIu32, ++pci_dev_counter);
if (name == NULL) { if (name == NULL) {
free(vdev); free(vdev);
@ -151,7 +158,7 @@ virtio_pci_scsi_dev_create_cb(struct virtio_pci_ctx *pci_ctx)
free(name); free(name);
if (rc != 0) { if (rc != 0) {
free(vdev); free(svdev);
return -1; return -1;
} }
@ -176,6 +183,12 @@ SPDK_BDEV_MODULE_REGISTER(virtio_scsi, bdev_virtio_initialize, bdev_virtio_finis
SPDK_BDEV_MODULE_ASYNC_INIT(virtio_scsi) SPDK_BDEV_MODULE_ASYNC_INIT(virtio_scsi)
SPDK_BDEV_MODULE_ASYNC_FINI(virtio_scsi); SPDK_BDEV_MODULE_ASYNC_FINI(virtio_scsi);
static struct virtio_scsi_dev *
virtio_dev_to_scsi(struct virtio_dev *vdev)
{
return SPDK_CONTAINEROF(vdev, struct virtio_scsi_dev, vdev);
}
static struct virtio_req * static struct virtio_req *
bdev_virtio_init_io_vreq(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io) bdev_virtio_init_io_vreq(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
{ {
@ -279,7 +292,8 @@ bdev_virtio_reset(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
struct bdev_virtio_io_channel *virtio_ch = spdk_io_channel_get_ctx(ch); struct bdev_virtio_io_channel *virtio_ch = spdk_io_channel_get_ctx(ch);
struct virtio_req *vreq = bdev_virtio_init_tmf_vreq(ch, bdev_io); struct virtio_req *vreq = bdev_virtio_init_tmf_vreq(ch, bdev_io);
struct virtio_scsi_ctrl_tmf_req *tmf_req = vreq->iov_req.iov_base; struct virtio_scsi_ctrl_tmf_req *tmf_req = vreq->iov_req.iov_base;
struct spdk_ring *ctrlq_send_ring = virtio_ch->vdev->vqs[VIRTIO_SCSI_CONTROLQ]->poller_ctx; struct virtio_dev *vdev = &virtio_ch->svdev->vdev;
struct spdk_ring *ctrlq_send_ring = vdev->vqs[VIRTIO_SCSI_CONTROLQ]->poller_ctx;
size_t enqueued_count; size_t enqueued_count;
tmf_req->type = VIRTIO_SCSI_T_TMF; tmf_req->type = VIRTIO_SCSI_T_TMF;
@ -411,7 +425,7 @@ bdev_virtio_get_io_channel(void *ctx)
{ {
struct virtio_scsi_disk *disk = ctx; struct virtio_scsi_disk *disk = ctx;
return spdk_get_io_channel(disk->vdev); return spdk_get_io_channel(disk->svdev);
} }
static int static int
@ -425,7 +439,7 @@ bdev_virtio_dump_json_config(void *ctx, struct spdk_json_write_ctx *w)
{ {
struct virtio_scsi_disk *disk = ctx; struct virtio_scsi_disk *disk = ctx;
virtio_dev_dump_json_config(disk->vdev, w); virtio_dev_dump_json_config(&disk->svdev->vdev, w);
return 0; return 0;
} }
@ -570,7 +584,8 @@ bdev_virtio_ctrlq_poll(void *arg)
static int static int
bdev_virtio_scsi_ch_create_cb(void *io_device, void *ctx_buf) bdev_virtio_scsi_ch_create_cb(void *io_device, void *ctx_buf)
{ {
struct virtio_dev *vdev = io_device; struct virtio_scsi_dev *svdev = io_device;
struct virtio_dev *vdev = &svdev->vdev;
struct bdev_virtio_io_channel *ch = ctx_buf; struct bdev_virtio_io_channel *ch = ctx_buf;
struct virtqueue *vq; struct virtqueue *vq;
int32_t queue_idx; int32_t queue_idx;
@ -583,7 +598,7 @@ bdev_virtio_scsi_ch_create_cb(void *io_device, void *ctx_buf)
vq = vdev->vqs[queue_idx]; vq = vdev->vqs[queue_idx];
ch->vdev = vdev; ch->svdev = svdev;
ch->vq = vq; ch->vq = vq;
vq->poller = spdk_poller_register(bdev_virtio_poll, ch, 0); vq->poller = spdk_poller_register(bdev_virtio_poll, ch, 0);
@ -595,7 +610,8 @@ static void
bdev_virtio_scsi_ch_destroy_cb(void *io_device, void *ctx_buf) bdev_virtio_scsi_ch_destroy_cb(void *io_device, void *ctx_buf)
{ {
struct bdev_virtio_io_channel *io_channel = ctx_buf; struct bdev_virtio_io_channel *io_channel = ctx_buf;
struct virtio_dev *vdev = io_channel->vdev; struct virtio_scsi_dev *svdev = io_channel->svdev;
struct virtio_dev *vdev = &svdev->vdev;
struct virtqueue *vq = io_channel->vq; struct virtqueue *vq = io_channel->vq;
spdk_poller_unregister(&vq->poller); spdk_poller_unregister(&vq->poller);
@ -605,6 +621,7 @@ bdev_virtio_scsi_ch_destroy_cb(void *io_device, void *ctx_buf)
static void static void
scan_target_abort(struct virtio_scsi_scan_base *base, int error) scan_target_abort(struct virtio_scsi_scan_base *base, int error)
{ {
struct virtio_dev *vdev = &base->svdev->vdev;
struct virtio_scsi_disk *disk; struct virtio_scsi_disk *disk;
while ((disk = TAILQ_FIRST(&base->found_disks))) { while ((disk = TAILQ_FIRST(&base->found_disks))) {
@ -612,11 +629,10 @@ scan_target_abort(struct virtio_scsi_scan_base *base, int error)
free(disk); free(disk);
} }
TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, base->vdev, tailq); TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, vdev, tailq);
virtio_dev_stop(base->vdev); virtio_dev_stop(vdev);
virtio_dev_destruct(base->vdev); virtio_dev_destruct(vdev);
free(base->vdev); free(vdev);
if (base->cb_fn) { if (base->cb_fn) {
base->cb_fn(base->cb_arg, error, NULL, 0); base->cb_fn(base->cb_arg, error, NULL, 0);
@ -628,6 +644,7 @@ scan_target_abort(struct virtio_scsi_scan_base *base, int error)
static void static void
scan_target_finish(struct virtio_scsi_scan_base *base) scan_target_finish(struct virtio_scsi_scan_base *base)
{ {
struct virtio_dev *vdev = &base->svdev->vdev;
size_t bdevs_cnt = 0; size_t bdevs_cnt = 0;
struct spdk_bdev *bdevs[BDEV_VIRTIO_MAX_TARGET]; struct spdk_bdev *bdevs[BDEV_VIRTIO_MAX_TARGET];
struct virtio_scsi_disk *disk; struct virtio_scsi_disk *disk;
@ -646,7 +663,7 @@ scan_target_finish(struct virtio_scsi_scan_base *base)
spdk_poller_unregister(&base->vq->poller); spdk_poller_unregister(&base->vq->poller);
base->vq->poller_ctx = NULL; base->vq->poller_ctx = NULL;
virtio_dev_release_queue(base->vdev, base->vq->vq_queue_index); virtio_dev_release_queue(vdev, base->vq->vq_queue_index);
ctrlq_ring = spdk_ring_create(SPDK_RING_TYPE_MP_SC, CTRLQ_RING_SIZE, ctrlq_ring = spdk_ring_create(SPDK_RING_TYPE_MP_SC, CTRLQ_RING_SIZE,
SPDK_ENV_SOCKET_ID_ANY); SPDK_ENV_SOCKET_ID_ANY);
@ -656,7 +673,7 @@ scan_target_finish(struct virtio_scsi_scan_base *base)
return; return;
} }
rc = virtio_dev_acquire_queue(base->vdev, VIRTIO_SCSI_CONTROLQ); rc = virtio_dev_acquire_queue(vdev, VIRTIO_SCSI_CONTROLQ);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("Failed to acquire the controlq.\n"); SPDK_ERRLOG("Failed to acquire the controlq.\n");
assert(false); assert(false);
@ -665,11 +682,11 @@ scan_target_finish(struct virtio_scsi_scan_base *base)
return; return;
} }
ctrlq = base->vdev->vqs[VIRTIO_SCSI_CONTROLQ]; ctrlq = vdev->vqs[VIRTIO_SCSI_CONTROLQ];
ctrlq->poller_ctx = ctrlq_ring; ctrlq->poller_ctx = ctrlq_ring;
ctrlq->poller = spdk_poller_register(bdev_virtio_ctrlq_poll, base->vdev, CTRLQ_POLL_PERIOD_US); ctrlq->poller = spdk_poller_register(bdev_virtio_ctrlq_poll, vdev, CTRLQ_POLL_PERIOD_US);
spdk_io_device_register(base->vdev, bdev_virtio_scsi_ch_create_cb, spdk_io_device_register(base->svdev, bdev_virtio_scsi_ch_create_cb,
bdev_virtio_scsi_ch_destroy_cb, bdev_virtio_scsi_ch_destroy_cb,
sizeof(struct bdev_virtio_io_channel)); sizeof(struct bdev_virtio_io_channel));
@ -677,7 +694,7 @@ scan_target_finish(struct virtio_scsi_scan_base *base)
TAILQ_REMOVE(&base->found_disks, disk, link); TAILQ_REMOVE(&base->found_disks, disk, link);
rc = spdk_bdev_register(&disk->bdev); rc = spdk_bdev_register(&disk->bdev);
if (rc) { if (rc) {
spdk_io_device_unregister(base->vdev, NULL); spdk_io_device_unregister(base->svdev, NULL);
SPDK_ERRLOG("Failed to register bdev name=%s\n", disk->bdev.name); SPDK_ERRLOG("Failed to register bdev name=%s\n", disk->bdev.name);
spdk_ring_free(ctrlq_ring); spdk_ring_free(ctrlq_ring);
scan_target_abort(base, rc); scan_target_abort(base, rc);
@ -687,8 +704,8 @@ scan_target_finish(struct virtio_scsi_scan_base *base)
bdevs_cnt++; bdevs_cnt++;
} }
TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, base->vdev, tailq); TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, vdev, tailq);
TAILQ_INSERT_TAIL(&g_virtio_driver.attached_ctrlrs, base->vdev, tailq); TAILQ_INSERT_TAIL(&g_virtio_driver.attached_ctrlrs, vdev, tailq);
if (base->cb_fn) { if (base->cb_fn) {
base->cb_fn(base->cb_arg, 0, bdevs, bdevs_cnt); base->cb_fn(base->cb_arg, 0, bdevs, bdevs_cnt);
@ -960,11 +977,11 @@ alloc_virtio_disk(struct virtio_scsi_scan_base *base)
return -1; return -1;
} }
disk->vdev = base->vdev; disk->svdev = base->svdev;
disk->info = base->info; disk->info = base->info;
bdev = &disk->bdev; bdev = &disk->bdev;
bdev->name = spdk_sprintf_alloc("%st%"PRIu8, base->vdev->name, disk->info.target); bdev->name = spdk_sprintf_alloc("%st%"PRIu8, base->svdev->vdev.name, disk->info.target);
if (bdev->name == NULL) { if (bdev->name == NULL) {
SPDK_ERRLOG("Couldn't alloc memory for the bdev name.\n"); SPDK_ERRLOG("Couldn't alloc memory for the bdev name.\n");
free(disk); free(disk);
@ -1156,7 +1173,7 @@ static int
bdev_virtio_process_config(void) bdev_virtio_process_config(void)
{ {
struct spdk_conf_section *sp; struct spdk_conf_section *sp;
struct virtio_dev *vdev = NULL; struct virtio_scsi_dev *svdev;
char *default_name = NULL; char *default_name = NULL;
char *path, *name; char *path, *name;
unsigned vdev_num; unsigned vdev_num;
@ -1188,8 +1205,8 @@ bdev_virtio_process_config(void)
num_queues = 1; num_queues = 1;
} }
vdev = calloc(1, sizeof(*vdev)); svdev = calloc(1, sizeof(*svdev));
if (vdev == NULL) { if (svdev == NULL) {
SPDK_ERRLOG("virtio device calloc failed\n"); SPDK_ERRLOG("virtio device calloc failed\n");
goto out; goto out;
} }
@ -1200,14 +1217,14 @@ bdev_virtio_process_config(void)
name = default_name; name = default_name;
} }
rc = virtio_user_dev_init(vdev, name, path, num_queues, 512, rc = virtio_user_dev_init(&svdev->vdev, name, path, num_queues, 512,
SPDK_VIRTIO_SCSI_QUEUE_NUM_FIXED); SPDK_VIRTIO_SCSI_QUEUE_NUM_FIXED);
free(default_name); free(default_name);
default_name = NULL; default_name = NULL;
if (rc != 0) { if (rc != 0) {
free(vdev); free(svdev);
goto out; goto out;
} }
} }
@ -1227,8 +1244,9 @@ out:
} }
static void static void
bdev_virtio_scsi_free(struct virtio_dev *vdev) bdev_virtio_scsi_dev_free(struct virtio_scsi_dev *svdev)
{ {
struct virtio_dev *vdev = &svdev->vdev;
struct virtqueue *vq; struct virtqueue *vq;
if (virtio_dev_queue_is_acquired(vdev, VIRTIO_SCSI_REQUESTQ)) { if (virtio_dev_queue_is_acquired(vdev, VIRTIO_SCSI_REQUESTQ)) {
@ -1241,12 +1259,13 @@ bdev_virtio_scsi_free(struct virtio_dev *vdev)
virtio_dev_stop(vdev); virtio_dev_stop(vdev);
virtio_dev_destruct(vdev); virtio_dev_destruct(vdev);
free(vdev); free(svdev);
} }
static int static int
bdev_virtio_scsi_scan(struct virtio_dev *vdev, bdev_virtio_create_cb cb_fn, void *cb_arg) bdev_virtio_scsi_scan(struct virtio_scsi_dev *svdev, bdev_virtio_create_cb cb_fn, void *cb_arg)
{ {
struct virtio_dev *vdev = &svdev->vdev;
struct virtio_scsi_scan_base *base = spdk_dma_zmalloc(sizeof(struct virtio_scsi_scan_base), 64, struct virtio_scsi_scan_base *base = spdk_dma_zmalloc(sizeof(struct virtio_scsi_scan_base), 64,
NULL); NULL);
struct virtqueue *vq; struct virtqueue *vq;
@ -1266,7 +1285,7 @@ bdev_virtio_scsi_scan(struct virtio_dev *vdev, bdev_virtio_create_cb cb_fn, void
return rc; return rc;
} }
base->vdev = vdev; base->svdev = svdev;
TAILQ_INIT(&base->found_disks); TAILQ_INIT(&base->found_disks);
rc = virtio_dev_acquire_queue(vdev, VIRTIO_SCSI_REQUESTQ); rc = virtio_dev_acquire_queue(vdev, VIRTIO_SCSI_REQUESTQ);
@ -1301,6 +1320,7 @@ bdev_virtio_initial_scan_complete(void *ctx __attribute__((unused)),
static int static int
bdev_virtio_initialize(void) bdev_virtio_initialize(void)
{ {
struct virtio_scsi_dev *svdev;
struct virtio_dev *vdev, *next_vdev; struct virtio_dev *vdev, *next_vdev;
int rc; int rc;
@ -1316,7 +1336,8 @@ bdev_virtio_initialize(void)
/* Initialize all created devices and scan available targets */ /* Initialize all created devices and scan available targets */
TAILQ_FOREACH(vdev, &g_virtio_driver.init_ctrlrs, tailq) { TAILQ_FOREACH(vdev, &g_virtio_driver.init_ctrlrs, tailq) {
rc = bdev_virtio_scsi_scan(vdev, bdev_virtio_initial_scan_complete, NULL); svdev = virtio_dev_to_scsi(vdev);
rc = bdev_virtio_scsi_scan(svdev, bdev_virtio_initial_scan_complete, NULL);
if (rc != 0) { if (rc != 0) {
goto out; goto out;
} }
@ -1327,8 +1348,9 @@ bdev_virtio_initialize(void)
out: out:
/* Remove any created devices */ /* Remove any created devices */
TAILQ_FOREACH_SAFE(vdev, &g_virtio_driver.init_ctrlrs, tailq, next_vdev) { TAILQ_FOREACH_SAFE(vdev, &g_virtio_driver.init_ctrlrs, tailq, next_vdev) {
svdev = virtio_dev_to_scsi(vdev);
TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, vdev, tailq); TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, vdev, tailq);
bdev_virtio_scsi_free(vdev); bdev_virtio_scsi_dev_free(svdev);
} }
spdk_bdev_module_init_done(SPDK_GET_BDEV_MODULE(virtio_scsi)); spdk_bdev_module_init_done(SPDK_GET_BDEV_MODULE(virtio_scsi));
@ -1338,7 +1360,8 @@ out:
static void static void
virtio_scsi_dev_unregister_cb(void *io_device) virtio_scsi_dev_unregister_cb(void *io_device)
{ {
struct virtio_dev *vdev = io_device; struct virtio_scsi_dev *svdev = io_device;
struct virtio_dev *vdev = &svdev->vdev;
struct virtqueue *vq; struct virtqueue *vq;
struct spdk_ring *send_ring; struct spdk_ring *send_ring;
struct spdk_thread *thread; struct spdk_thread *thread;
@ -1363,7 +1386,7 @@ virtio_scsi_dev_unregister_cb(void *io_device)
virtio_dev_stop(vdev); virtio_dev_stop(vdev);
virtio_dev_destruct(vdev); virtio_dev_destruct(vdev);
free(vdev); free(svdev);
TAILQ_REMOVE(&g_virtio_driver.attached_ctrlrs, vdev, tailq); TAILQ_REMOVE(&g_virtio_driver.attached_ctrlrs, vdev, tailq);
finish_module = TAILQ_EMPTY(&g_virtio_driver.attached_ctrlrs); finish_module = TAILQ_EMPTY(&g_virtio_driver.attached_ctrlrs);
@ -1384,7 +1407,8 @@ bdev_virtio_finish(void)
} }
TAILQ_FOREACH_SAFE(vdev, &g_virtio_driver.attached_ctrlrs, tailq, next) { TAILQ_FOREACH_SAFE(vdev, &g_virtio_driver.attached_ctrlrs, tailq, next) {
spdk_io_device_unregister(vdev, virtio_scsi_dev_unregister_cb); spdk_io_device_unregister(virtio_dev_to_scsi(vdev),
virtio_scsi_dev_unregister_cb);
} }
} }
@ -1392,27 +1416,27 @@ int
bdev_virtio_scsi_dev_create(const char *base_name, const char *path, unsigned num_queues, bdev_virtio_scsi_dev_create(const char *base_name, const char *path, unsigned num_queues,
unsigned queue_size, bdev_virtio_create_cb cb_fn, void *cb_arg) unsigned queue_size, bdev_virtio_create_cb cb_fn, void *cb_arg)
{ {
struct virtio_dev *vdev; struct virtio_scsi_dev *svdev;
int rc; int rc;
vdev = calloc(1, sizeof(*vdev)); svdev = calloc(1, sizeof(*svdev));
if (vdev == NULL) { if (svdev == NULL) {
SPDK_ERRLOG("calloc failed for virtio device %s: %s\n", base_name, path); SPDK_ERRLOG("calloc failed for virtio device %s: %s\n", base_name, path);
return -ENOMEM; return -ENOMEM;
} }
rc = virtio_user_dev_init(vdev, base_name, path, num_queues, queue_size, rc = virtio_user_dev_init(&svdev->vdev, base_name, path, num_queues, queue_size,
SPDK_VIRTIO_SCSI_QUEUE_NUM_FIXED); SPDK_VIRTIO_SCSI_QUEUE_NUM_FIXED);
if (rc != 0) { if (rc != 0) {
SPDK_ERRLOG("Failed to create virito device %s: %s\n", base_name, path); SPDK_ERRLOG("Failed to create virito device %s: %s\n", base_name, path);
free(vdev); free(svdev);
return -EINVAL; return -EINVAL;
} }
rc = bdev_virtio_scsi_scan(vdev, cb_fn, cb_arg); rc = bdev_virtio_scsi_scan(svdev, cb_fn, cb_arg);
if (rc) { if (rc) {
TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, vdev, tailq); TAILQ_REMOVE(&g_virtio_driver.init_ctrlrs, &svdev->vdev, tailq);
bdev_virtio_scsi_free(vdev); bdev_virtio_scsi_dev_free(svdev);
} }
return rc; return rc;