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

vhost_scsi: removed internal eventq events ring

Browse Source 
Since we are calling eventq_enqueue only from inside of the controller
reactor, such ring is not needed. Eventq events will now be sent
immediately. This simplifies the whole process greatly.

The abstract vhost event layer is being replaced with much simpler and
less error-prone vhost external spdk_event API.

This reverts commit 542b5415 [1] together with vhost scsi device
hot-attach feature. Hot-attach shall be reintroduced in upcoming
patches.

[1] 542b541588 ("vhost_scsi: implemented abstract vhost event layer")

Change-Id: I39a427332d573c4e0be548d1c8caf0cf2858f6a5
Signed-off-by: Dariusz Stojaczyk <dariuszx.stojaczyk@intel.com>
Reviewed-on: https://review.gerrithub.io/371117
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Pawel Wodkowski <pawelx.wodkowski@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
This commit is contained in:
Dariusz Stojaczyk 2017-07-25 13:55:42 +02:00 committed by Daniel Verkamp
parent dcb7db965d
commit 4c4492dcc4
2 changed files with 68 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

271
lib/vhost/vhost_scsi.c
View File

@ -46,8 +46,6 @@
#include "spdk/vhost.h" #include "spdk/vhost.h"
#include "vhost_internal.h" #include "vhost_internal.h"
#include "spdk_internal/assert.h"
/* Features supported by SPDK VHOST lib. */ /* Features supported by SPDK VHOST lib. */
#define SPDK_VHOST_SCSI_FEATURES (SPDK_VHOST_FEATURES | \ #define SPDK_VHOST_SCSI_FEATURES (SPDK_VHOST_FEATURES | \
(1ULL << VIRTIO_SCSI_F_INOUT) | \ (1ULL << VIRTIO_SCSI_F_INOUT) | \
@ -71,13 +69,11 @@
struct spdk_vhost_scsi_dev { struct spdk_vhost_scsi_dev {
struct spdk_vhost_dev vdev; struct spdk_vhost_dev vdev;
struct spdk_scsi_dev *scsi_dev[SPDK_VHOST_SCSI_CTRLR_MAX_DEVS]; struct spdk_scsi_dev *scsi_dev[SPDK_VHOST_SCSI_CTRLR_MAX_DEVS];
bool detached_dev[SPDK_VHOST_SCSI_CTRLR_MAX_DEVS]; bool removed_dev[SPDK_VHOST_SCSI_CTRLR_MAX_DEVS];
struct spdk_ring *task_pool; struct spdk_ring *task_pool;
struct spdk_poller *requestq_poller; struct spdk_poller *requestq_poller;
struct spdk_poller *mgmt_poller; struct spdk_poller *mgmt_poller;
struct spdk_ring *vhost_events;
} __rte_cache_aligned; } __rte_cache_aligned;
struct spdk_vhost_scsi_task { struct spdk_vhost_scsi_task {
@ -97,18 +93,6 @@ struct spdk_vhost_scsi_task {
struct rte_vhost_vring *vq; struct rte_vhost_vring *vq;
}; };
enum spdk_vhost_scsi_event_type {
SPDK_VHOST_SCSI_EVENT_HOTATTACH,
SPDK_VHOST_SCSI_EVENT_HOTDETACH,
};
struct spdk_vhost_scsi_event {
enum spdk_vhost_scsi_event_type type;
unsigned dev_index;
struct spdk_scsi_dev *dev;
struct spdk_scsi_lun *lun;
};
static int new_device(struct spdk_vhost_dev *, void *); static int new_device(struct spdk_vhost_dev *, void *);
static int destroy_device(struct spdk_vhost_dev *, void *); static int destroy_device(struct spdk_vhost_dev *, void *);
static void spdk_vhost_scsi_config_json(struct spdk_vhost_dev *vdev, struct spdk_json_write_ctx *w); static void spdk_vhost_scsi_config_json(struct spdk_vhost_dev *vdev, struct spdk_json_write_ctx *w);
@ -154,107 +138,6 @@ spdk_vhost_get_tasks(struct spdk_vhost_scsi_dev *svdev, struct spdk_vhost_scsi_t
svdev->vdev.task_cnt += res_count; svdev->vdev.task_cnt += res_count;
} }
static void
spdk_vhost_scsi_event_process(struct spdk_vhost_scsi_dev *svdev, struct spdk_vhost_scsi_event *ev,
struct virtio_scsi_event *desc_ev)
{
int event_id, reason_id;
int dev_id, lun_id;
assert(ev->dev);
assert(ev->dev_index < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS);
dev_id = ev->dev_index;
switch (ev->type) {
case SPDK_VHOST_SCSI_EVENT_HOTATTACH:
event_id = VIRTIO_SCSI_T_TRANSPORT_RESET;
reason_id = VIRTIO_SCSI_EVT_RESET_RESCAN;
spdk_scsi_dev_allocate_io_channels(ev->dev);
svdev->scsi_dev[dev_id] = ev->dev;
svdev->detached_dev[dev_id] = false;
SPDK_NOTICELOG("%s: hot-attached device %d\n", svdev->vdev.name, dev_id);
break;
case SPDK_VHOST_SCSI_EVENT_HOTDETACH:
event_id = VIRTIO_SCSI_T_TRANSPORT_RESET;
reason_id = VIRTIO_SCSI_EVT_RESET_REMOVED;
if (ev->lun == NULL) {
svdev->detached_dev[dev_id] = true;
SPDK_NOTICELOG("%s: marked 'Dev %d' for hot-detach\n", svdev->vdev.name, dev_id);
} else {
SPDK_NOTICELOG("%s: hotremoved LUN '%s'\n", svdev->vdev.name, spdk_scsi_lun_get_name(ev->lun));
}
break;
default:
SPDK_UNREACHABLE();
}
/* some events may apply to the entire device via lun id set to 0 */
lun_id = ev->lun == NULL ? 0 : spdk_scsi_lun_get_id(ev->lun);
if (desc_ev) {
desc_ev->event = event_id;
desc_ev->lun[0] = 1;
desc_ev->lun[1] = dev_id;
desc_ev->lun[2] = lun_id >> 8; /* relies on linux kernel implementation */
desc_ev->lun[3] = lun_id & 0xFF;
memset(&desc_ev->lun[4], 0, 4);
desc_ev->reason = reason_id;
}
}
/**
* Process vhost event, send virtio event
*/
static void
process_event(struct spdk_vhost_scsi_dev *svdev, struct spdk_vhost_scsi_event *ev)
{
struct vring_desc *desc;
struct virtio_scsi_event *desc_ev;
uint32_t req_size;
uint16_t req;
struct rte_vhost_vring *vq = &svdev->vdev.virtqueue[VIRTIO_SCSI_EVENTQ];
if (spdk_vhost_vq_avail_ring_get(vq, &req, 1) != 1) {
SPDK_ERRLOG("%s: no avail virtio eventq ring entries. virtio event won't be sent.\n",
svdev->vdev.name);
desc = NULL;
desc_ev = NULL;
req_size = 0;
/* even though we can't send virtio event,
* the spdk vhost event should still be processed
*/
} else {
desc = spdk_vhost_vq_get_desc(vq, req);
desc_ev = spdk_vhost_gpa_to_vva(&svdev->vdev, desc->addr);
req_size = sizeof(*desc_ev);
if (desc->len < sizeof(*desc_ev) || desc_ev == NULL) {
SPDK_ERRLOG("%s: invalid eventq descriptor.\n", svdev->vdev.name);
desc_ev = NULL;
req_size = 0;
}
}
spdk_vhost_scsi_event_process(svdev, ev, desc_ev);
if (desc) {
spdk_vhost_vq_used_ring_enqueue(&svdev->vdev, vq, req, req_size);
}
}
static void
process_eventq(struct spdk_vhost_scsi_dev *svdev)
{
struct spdk_vhost_scsi_event *ev;
while (spdk_ring_dequeue(svdev->vhost_events, (void **)&ev, 1) == 1) {
process_event(svdev, ev);
spdk_dma_free(ev);
}
}
static void static void
process_removed_devs(struct spdk_vhost_scsi_dev *svdev) process_removed_devs(struct spdk_vhost_scsi_dev *svdev)
{ {
@ -264,41 +147,76 @@ process_removed_devs(struct spdk_vhost_scsi_dev *svdev)
for (i = 0; i < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS; ++i) { for (i = 0; i < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS; ++i) {
dev = svdev->scsi_dev[i]; dev = svdev->scsi_dev[i];
if (dev && svdev->detached_dev[i] && !spdk_scsi_dev_has_pending_tasks(dev)) { if (dev && svdev->removed_dev[i] && !spdk_scsi_dev_has_pending_tasks(dev)) {
spdk_scsi_dev_free_io_channels(dev); spdk_scsi_dev_free_io_channels(dev);
spdk_scsi_dev_destruct(dev); spdk_scsi_dev_destruct(dev);
svdev->scsi_dev[i] = NULL; svdev->scsi_dev[i] = NULL;
SPDK_NOTICELOG("%s: hot-detached 'Dev %d'.\n", svdev->vdev.name, i); SPDK_NOTICELOG("%s: hot-detached device 'Dev %u'.\n", svdev->vdev.name, i);
} }
} }
} }
static void static void
enqueue_vhost_event(struct spdk_vhost_scsi_dev *svdev, enum spdk_vhost_scsi_event_type type, eventq_enqueue(struct spdk_vhost_scsi_dev *svdev, const struct spdk_scsi_dev *dev,
int dev_index, struct spdk_scsi_dev *dev, struct spdk_scsi_lun *lun) const struct spdk_scsi_lun *lun, uint32_t event,
uint32_t reason)
{ {
struct spdk_vhost_scsi_event *ev; int dev_id, lun_id;
struct rte_vhost_vring *vq;
struct vring_desc *desc;
struct virtio_scsi_event *desc_ev;
uint32_t req_size;
uint16_t req;
if (dev == NULL) { if (dev == NULL) {
SPDK_ERRLOG("%s: vhost event device cannot be NULL.\n", svdev->vdev.name); SPDK_ERRLOG("%s: eventq device cannot be NULL.\n", svdev->vdev.name);
return; return;
} }
ev = spdk_dma_zmalloc(sizeof(*ev), SPDK_CACHE_LINE_SIZE, NULL); for (dev_id = 0; dev_id < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS; dev_id++) {
if (ev == NULL) { if (svdev->scsi_dev[dev_id] == dev) {
SPDK_ERRLOG("%s: failed to alloc vhost event.\n", svdev->vdev.name); break;
}
}
if (dev_id == SPDK_VHOST_SCSI_CTRLR_MAX_DEVS) {
SPDK_ERRLOG("Dev %s is not a part of vhost scsi controller '%s'.\n", spdk_scsi_dev_get_name(dev),
svdev->vdev.name);
return; return;
} }
ev->type = type; /* some events may apply to the entire device via lun id set to 0 */
ev->dev_index = dev_index; lun_id = lun == NULL ? 0 : spdk_scsi_lun_get_id(lun);
ev->dev = dev;
ev->lun = lun;
if (spdk_ring_enqueue(svdev->vhost_events, (void **)&ev, 1) != 1) { vq = &svdev->vdev.virtqueue[VIRTIO_SCSI_EVENTQ];
SPDK_ERRLOG("%s: failed to enqueue vhost event (no room in ring?).\n", svdev->vdev.name);
spdk_dma_free(ev); if (spdk_vhost_vq_avail_ring_get(vq, &req, 1) != 1) {
SPDK_ERRLOG("Controller %s: Failed to send virtio event (no avail ring entries?).\n",
svdev->vdev.name);
return;
} }
desc = spdk_vhost_vq_get_desc(vq, req);
desc_ev = spdk_vhost_gpa_to_vva(&svdev->vdev, desc->addr);
if (desc->len < sizeof(*desc_ev) || desc_ev == NULL) {
SPDK_ERRLOG("Controller %s: Invalid eventq descriptor.\n", svdev->vdev.name);
req_size = 0;
} else {
desc_ev->event = event;
desc_ev->lun[0] = 1;
desc_ev->lun[1] = dev_id;
desc_ev->lun[2] = lun_id >> 8; /* relies on linux kernel implementation */
desc_ev->lun[3] = lun_id & 0xFF;
/* virtio doesn't specify any strict format for LUN id (bytes 2 and 3)
* current implementation relies on linux kernel sources
*/
memset(&desc_ev->lun[4], 0, 4);
desc_ev->reason = reason;
req_size = sizeof(*desc_ev);
}
spdk_vhost_vq_used_ring_enqueue(&svdev->vdev, vq, req, req_size);
} }
static void static void
@ -355,11 +273,6 @@ mgmt_task_submit(struct spdk_vhost_scsi_task *task, enum spdk_scsi_task_func fun
static void static void
invalid_request(struct spdk_vhost_scsi_task *task) invalid_request(struct spdk_vhost_scsi_task *task)
{ {
/* Flush eventq so that guest is instantly notified about any hotremoved luns.
* This might prevent him from sending more invalid requests and trying to reset
* the device.
*/
process_eventq(task->svdev);
spdk_vhost_vq_used_ring_enqueue(&task->svdev->vdev, task->vq, task->req_idx, 0); spdk_vhost_vq_used_ring_enqueue(&task->svdev->vdev, task->vq, task->req_idx, 0);
spdk_vhost_scsi_task_put(task); spdk_vhost_scsi_task_put(task);
@ -382,10 +295,10 @@ spdk_vhost_scsi_task_init_target(struct spdk_vhost_scsi_task *task, const __u8 *
dev = task->svdev->scsi_dev[lun[1]]; dev = task->svdev->scsi_dev[lun[1]];
task->scsi_dev = dev; task->scsi_dev = dev;
if (dev == NULL) { if (dev == NULL) {
/* If dev has been hot-detached, return 0 to allow sending additional /* If dev has been hotdetached, return 0 to allow sending
* scsi hotremove event via sense codes. * additional hotremove event via sense codes.
*/ */
return task->svdev->detached_dev[lun[1]] ? 0 : -1; return task->svdev->removed_dev[lun[1]] ? 0 : -1;
} }
task->scsi.target_port = spdk_scsi_dev_find_port_by_id(task->scsi_dev, 0); task->scsi.target_port = spdk_scsi_dev_find_port_by_id(task->scsi_dev, 0);
@ -673,7 +586,6 @@ vdev_mgmt_worker(void *arg)
struct spdk_vhost_scsi_dev *svdev = arg; struct spdk_vhost_scsi_dev *svdev = arg;
process_removed_devs(svdev); process_removed_devs(svdev);
process_eventq(svdev);
process_controlq(svdev, &svdev->vdev.virtqueue[VIRTIO_SCSI_CONTROLQ]); process_controlq(svdev, &svdev->vdev.virtqueue[VIRTIO_SCSI_CONTROLQ]);
} }
@ -720,7 +632,6 @@ spdk_vhost_scsi_dev_construct(const char *name, const char *cpumask)
&spdk_vhost_scsi_device_backend); &spdk_vhost_scsi_device_backend);
if (rc) { if (rc) {
spdk_ring_free(svdev->vhost_events);
spdk_dma_free(svdev); spdk_dma_free(svdev);
} }
@ -750,7 +661,6 @@ spdk_vhost_scsi_dev_remove(struct spdk_vhost_dev *vdev)
return rc; return rc;
} }
spdk_ring_free(svdev->vhost_events);
spdk_dma_free(svdev); spdk_dma_free(svdev);
return 0; return 0;
} }
@ -770,8 +680,6 @@ static void
spdk_vhost_scsi_lun_hotremove(const struct spdk_scsi_lun *lun, void *arg) spdk_vhost_scsi_lun_hotremove(const struct spdk_scsi_lun *lun, void *arg)
{ {
struct spdk_vhost_scsi_dev *svdev = arg; struct spdk_vhost_scsi_dev *svdev = arg;
const struct spdk_scsi_dev *scsi_dev;
unsigned scsi_dev_num;
assert(lun != NULL); assert(lun != NULL);
assert(svdev != NULL); assert(svdev != NULL);
@ -780,25 +688,8 @@ spdk_vhost_scsi_lun_hotremove(const struct spdk_scsi_lun *lun, void *arg)
return; return;
} }
scsi_dev = spdk_scsi_lun_get_dev(lun); eventq_enqueue(svdev, spdk_scsi_lun_get_dev(lun), lun, VIRTIO_SCSI_T_TRANSPORT_RESET,
VIRTIO_SCSI_EVT_RESET_REMOVED);
for (scsi_dev_num = 0; scsi_dev_num < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS; ++scsi_dev_num) {
if (svdev->scsi_dev[scsi_dev_num] == scsi_dev) {
break;
}
}
if (scsi_dev_num == SPDK_VHOST_SCSI_CTRLR_MAX_DEVS) {
SPDK_ERRLOG("%s: '%s' is not a part of this controller.\n", svdev->vdev.name,
spdk_scsi_dev_get_name(scsi_dev));
return;
}
enqueue_vhost_event(svdev, SPDK_VHOST_SCSI_EVENT_HOTDETACH, scsi_dev_num,
(struct spdk_scsi_dev *) scsi_dev, (struct spdk_scsi_lun *) lun);
SPDK_NOTICELOG("%s: queued LUN '%s' for hotremove\n", svdev->vdev.name,
spdk_scsi_dev_get_name(scsi_dev));
} }
int int
@ -806,7 +697,6 @@ spdk_vhost_scsi_dev_add_dev(struct spdk_vhost_dev *vdev, unsigned scsi_dev_num,
const char *lun_name) const char *lun_name)
{ {
struct spdk_vhost_scsi_dev *svdev; struct spdk_vhost_scsi_dev *svdev;
struct spdk_scsi_dev *scsi_dev;
char dev_name[SPDK_SCSI_DEV_MAX_NAME]; char dev_name[SPDK_SCSI_DEV_MAX_NAME];
int lun_id_list[1]; int lun_id_list[1];
char *lun_names_list[1]; char *lun_names_list[1];
@ -835,9 +725,8 @@ spdk_vhost_scsi_dev_add_dev(struct spdk_vhost_dev *vdev, unsigned scsi_dev_num,
return -EINVAL; return -EINVAL;
} }
if (vdev->lcore != -1 && !spdk_vhost_dev_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG)) { if (vdev->lcore != -1) {
SPDK_ERRLOG("%s: 'Dev %u' is in use and hot-attach is not enabled for this controller\n", SPDK_ERRLOG("Controller %s is in use and hotplug is not supported\n", vdev->name);
vdev->name, scsi_dev_num);
return -ENOTSUP; return -ENOTSUP;
} }
@ -853,23 +742,16 @@ spdk_vhost_scsi_dev_add_dev(struct spdk_vhost_dev *vdev, unsigned scsi_dev_num,
lun_id_list[0] = 0; lun_id_list[0] = 0;
lun_names_list[0] = (char *)lun_name; lun_names_list[0] = (char *)lun_name;
scsi_dev = spdk_scsi_dev_construct(dev_name, lun_names_list, lun_id_list, 1, svdev->removed_dev[scsi_dev_num] = false;
SPDK_SPC_PROTOCOL_IDENTIFIER_SAS, spdk_vhost_scsi_lun_hotremove, svdev); svdev->scsi_dev[scsi_dev_num] = spdk_scsi_dev_construct(dev_name, lun_names_list, lun_id_list, 1,
if (scsi_dev == NULL) { SPDK_SPC_PROTOCOL_IDENTIFIER_SAS, spdk_vhost_scsi_lun_hotremove, svdev);
if (svdev->scsi_dev[scsi_dev_num] == NULL) {
SPDK_ERRLOG("Couldn't create spdk SCSI device '%s' using lun device '%s' in controller: %s\n", SPDK_ERRLOG("Couldn't create spdk SCSI device '%s' using lun device '%s' in controller: %s\n",
dev_name, lun_name, vdev->name); dev_name, lun_name, vdev->name);
return -EINVAL; return -EINVAL;
} }
spdk_scsi_dev_add_port(svdev->scsi_dev[scsi_dev_num], 0, "vhost");
spdk_scsi_dev_add_port(scsi_dev, 0, "vhost");
if (vdev->lcore == -1) {
svdev->detached_dev[scsi_dev_num] = false;
svdev->scsi_dev[scsi_dev_num] = scsi_dev;
} else {
enqueue_vhost_event(svdev, SPDK_VHOST_SCSI_EVENT_HOTATTACH, scsi_dev_num, scsi_dev, NULL);
}
SPDK_NOTICELOG("Controller %s: defined device '%s' using lun '%s'\n", SPDK_NOTICELOG("Controller %s: defined device '%s' using lun '%s'\n",
vdev->name, dev_name, lun_name); vdev->name, dev_name, lun_name);
return 0; return 0;
@ -911,7 +793,8 @@ spdk_vhost_scsi_dev_remove_dev(struct spdk_vhost_dev *vdev, unsigned scsi_dev_nu
return -ENOTSUP; return -ENOTSUP;
} }
enqueue_vhost_event(svdev, SPDK_VHOST_SCSI_EVENT_HOTDETACH, scsi_dev_num, scsi_dev, NULL); svdev->removed_dev[scsi_dev_num] = true;
eventq_enqueue(svdev, scsi_dev, NULL, VIRTIO_SCSI_T_TRANSPORT_RESET, VIRTIO_SCSI_EVT_RESET_REMOVED);
SPDK_NOTICELOG("%s: queued 'Dev %u' for hot-detach.\n", vdev->name, scsi_dev_num); SPDK_NOTICELOG("%s: queued 'Dev %u' for hot-detach.\n", vdev->name, scsi_dev_num);
return 0; return 0;
@ -1055,7 +938,7 @@ new_device(struct spdk_vhost_dev *vdev, void *event_ctx)
{ {
struct spdk_vhost_scsi_dev *svdev; struct spdk_vhost_scsi_dev *svdev;
uint32_t i; uint32_t i;
int rc = 0; int rc;
svdev = to_scsi_dev(vdev); svdev = to_scsi_dev(vdev);
if (svdev == NULL) { if (svdev == NULL) {
@ -1070,14 +953,6 @@ new_device(struct spdk_vhost_dev *vdev, void *event_ctx)
goto out; goto out;
} }
svdev->vhost_events = spdk_ring_create(SPDK_RING_TYPE_MP_SC, 16,
spdk_env_get_socket_id(vdev->lcore));
if (svdev->vhost_events == NULL) {
SPDK_ERRLOG("%s: failed to alloc event pool.\n", vdev->name);
rc = -1;
goto out;
}
for (i = 0; i < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS; i++) { for (i = 0; i < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS; i++) {
if (svdev->scsi_dev[i] == NULL) { if (svdev->scsi_dev[i] == NULL) {
continue; continue;
@ -1107,7 +982,6 @@ destroy_device_poller_cb(void *arg)
{ {
struct spdk_vhost_dev_destroy_ctx *ctx = arg; struct spdk_vhost_dev_destroy_ctx *ctx = arg;
struct spdk_vhost_scsi_dev *svdev = ctx->svdev; struct spdk_vhost_scsi_dev *svdev = ctx->svdev;
void *ev;
uint32_t i; uint32_t i;
if (svdev->vdev.task_cnt > 0) { if (svdev->vdev.task_cnt > 0) {
@ -1124,15 +998,6 @@ destroy_device_poller_cb(void *arg)
SPDK_NOTICELOG("Stopping poller for vhost controller %s\n", svdev->vdev.name); SPDK_NOTICELOG("Stopping poller for vhost controller %s\n", svdev->vdev.name);
spdk_vhost_dev_mem_unregister(&svdev->vdev); spdk_vhost_dev_mem_unregister(&svdev->vdev);
/* Flush not sent events */
while (spdk_ring_dequeue(svdev->vhost_events, &ev, 1) == 1) {
/* process vhost event, but don't send virtio event */
spdk_vhost_scsi_event_process(svdev, ev, NULL);
spdk_dma_free(ev);
}
spdk_ring_free(svdev->vhost_events);
free_task_pool(svdev); free_task_pool(svdev);
spdk_poller_unregister(&ctx->poller, NULL); spdk_poller_unregister(&ctx->poller, NULL);

20
test/vhost/fiotest/autotest.sh
View File

@ -250,26 +250,6 @@ done
$COMMON_DIR/vm_run.sh $x --work-dir=$TEST_DIR $used_vms $COMMON_DIR/vm_run.sh $x --work-dir=$TEST_DIR $used_vms
vm_wait_for_boot 600 $used_vms vm_wait_for_boot 600 $used_vms
if [[ $test_type == "spdk_vhost_scsi" ]]; then
for vm_conf in ${vms[@]}; do
IFS=',' read -ra conf <<< "$vm_conf"
while IFS=':' read -ra disks; do
for disk in "${disks[@]}"; do
echo "INFO: Hotdetach test. Trying to remove existing device from a controller naa.$disk.${conf[0]}"
$rpc_py remove_vhost_scsi_dev naa.$disk.${conf[0]} 0
sleep 0.1
echo "INFO: Hotattach test. Re-adding device 0 to naa.$disk.${conf[0]}"
$rpc_py add_vhost_scsi_lun naa.$disk.${conf[0]} 0 $disk
done
done <<< "${conf[2]}"
unset IFS;
done
fi
sleep 0.1
echo "===============" echo "==============="
echo "" echo ""
echo "INFO: Testing..." echo "INFO: Testing..."