+++ /dev/null
-/*-
- * BSD LICENSE
- *
- * Copyright (c) Intel Corporation.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * * Neither the name of Intel Corporation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "spdk/stdinc.h"
-
-#include "spdk/bdev.h"
-#include "spdk/conf.h"
-#include "spdk/endian.h"
-#include "spdk/env.h"
-#include "spdk/thread.h"
-#include "spdk/scsi_spec.h"
-#include "spdk/string.h"
-#include "spdk/util.h"
-#include "spdk/json.h"
-
-#include "spdk/bdev_module.h"
-#include "spdk_internal/log.h"
-#include "spdk_internal/virtio.h"
-
-#include <linux/virtio_scsi.h>
-
-#include "bdev_virtio.h"
-
-#define BDEV_VIRTIO_MAX_TARGET 64
-#define BDEV_VIRTIO_SCAN_PAYLOAD_SIZE 256
-#define MGMT_POLL_PERIOD_US (1000 * 5)
-#define CTRLQ_RING_SIZE 16
-#define SCAN_REQUEST_RETRIES 5
-
-/* Number of non-request queues - eventq and controlq */
-#define SPDK_VIRTIO_SCSI_QUEUE_NUM_FIXED 2
-
-#define VIRTIO_SCSI_EVENTQ_BUFFER_COUNT 16
-
-#define VIRTIO_SCSI_CONTROLQ 0
-#define VIRTIO_SCSI_EVENTQ 1
-#define VIRTIO_SCSI_REQUESTQ 2
-
-static int bdev_virtio_initialize(void);
-static void bdev_virtio_finish(void);
-
-struct virtio_scsi_dev {
- /* Generic virtio device data. */
- struct virtio_dev vdev;
-
- /** Detected SCSI LUNs */
- TAILQ_HEAD(, virtio_scsi_disk) luns;
-
- /** Context for the SCSI target scan. */
- struct virtio_scsi_scan_base *scan_ctx;
-
- /** Controlq poller. */
- struct spdk_poller *mgmt_poller;
-
- /** Controlq messages to be sent. */
- struct spdk_ring *ctrlq_ring;
-
- /** Buffers for the eventq. */
- struct virtio_scsi_eventq_io *eventq_ios;
-
- /** Device marked for removal. */
- bool removed;
-
- /** Callback to be called after vdev removal. */
- bdev_virtio_remove_cb remove_cb;
-
- /** Context for the `remove_cb`. */
- void *remove_ctx;
-
- TAILQ_ENTRY(virtio_scsi_dev) tailq;
-};
-
-struct virtio_scsi_io_ctx {
- struct iovec iov_req;
- struct iovec iov_resp;
- union {
- struct virtio_scsi_cmd_req req;
- struct virtio_scsi_ctrl_tmf_req tmf_req;
- };
- union {
- struct virtio_scsi_cmd_resp resp;
- struct virtio_scsi_ctrl_tmf_resp tmf_resp;
- };
-};
-
-struct virtio_scsi_eventq_io {
- struct iovec iov;
- struct virtio_scsi_event ev;
-};
-
-struct virtio_scsi_scan_info {
- uint64_t num_blocks;
- uint32_t block_size;
- uint8_t target;
- bool unmap_supported;
- TAILQ_ENTRY(virtio_scsi_scan_info) tailq;
-};
-
-struct virtio_scsi_scan_base {
- struct virtio_scsi_dev *svdev;
-
- /** I/O channel used for the scan I/O. */
- struct bdev_virtio_io_channel *channel;
-
- bdev_virtio_create_cb cb_fn;
- void *cb_arg;
-
- /** Scan all targets on the device. */
- bool full_scan;
-
- /** Start a full rescan after receiving next scan I/O response. */
- bool restart;
-
- /** Additional targets to be (re)scanned. */
- TAILQ_HEAD(, virtio_scsi_scan_info) scan_queue;
-
- /** Remaining attempts for sending the current request. */
- unsigned retries;
-
- /** If set, the last scan I/O needs to be resent */
- bool needs_resend;
-
- struct virtio_scsi_io_ctx io_ctx;
- struct iovec iov;
- uint8_t payload[BDEV_VIRTIO_SCAN_PAYLOAD_SIZE];
-
- /** Scan results for the current target. */
- struct virtio_scsi_scan_info info;
-};
-
-struct virtio_scsi_disk {
- struct spdk_bdev bdev;
- struct virtio_scsi_dev *svdev;
- struct virtio_scsi_scan_info info;
-
- /** Descriptor opened just to be notified of external bdev hotremove. */
- struct spdk_bdev_desc *notify_desc;
-
- /** Disk marked for removal. */
- bool removed;
- TAILQ_ENTRY(virtio_scsi_disk) link;
-};
-
-struct bdev_virtio_io_channel {
- struct virtio_scsi_dev *svdev;
-
- /** Virtqueue exclusively assigned to this channel. */
- struct virtqueue *vq;
-
- /** Virtio response poller. */
- struct spdk_poller *poller;
-};
-
-static TAILQ_HEAD(, virtio_scsi_dev) g_virtio_scsi_devs =
- TAILQ_HEAD_INITIALIZER(g_virtio_scsi_devs);
-
-static pthread_mutex_t g_virtio_scsi_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-/** Module finish in progress */
-static bool g_bdev_virtio_finish = false;
-
-/* Features desired/implemented by this driver. */
-#define VIRTIO_SCSI_DEV_SUPPORTED_FEATURES \
- (1ULL << VIRTIO_SCSI_F_INOUT | \
- 1ULL << VIRTIO_SCSI_F_HOTPLUG | \
- 1ULL << VIRTIO_RING_F_EVENT_IDX | \
- 1ULL << VHOST_USER_F_PROTOCOL_FEATURES)
-
-static void virtio_scsi_dev_unregister_cb(void *io_device);
-static void virtio_scsi_dev_remove(struct virtio_scsi_dev *svdev,
- bdev_virtio_remove_cb cb_fn, void *cb_arg);
-static int bdev_virtio_scsi_ch_create_cb(void *io_device, void *ctx_buf);
-static void bdev_virtio_scsi_ch_destroy_cb(void *io_device, void *ctx_buf);
-static void process_scan_resp(struct virtio_scsi_scan_base *base);
-static int bdev_virtio_mgmt_poll(void *arg);
-
-static int
-virtio_scsi_dev_send_eventq_io(struct virtqueue *vq, struct virtio_scsi_eventq_io *io)
-{
- int rc;
-
- rc = virtqueue_req_start(vq, io, 1);
- if (rc != 0) {
- return -1;
- }
-
- virtqueue_req_add_iovs(vq, &io->iov, 1, SPDK_VIRTIO_DESC_WR);
- virtqueue_req_flush(vq);
-
- return 0;
-}
-
-static int
-virtio_scsi_dev_init(struct virtio_scsi_dev *svdev, uint16_t max_queues)
-{
- struct virtio_dev *vdev = &svdev->vdev;
- struct spdk_ring *ctrlq_ring;
- struct virtio_scsi_eventq_io *eventq_io;
- struct virtqueue *eventq;
- uint16_t i, num_events;
- int rc;
-
- rc = virtio_dev_reset(vdev, VIRTIO_SCSI_DEV_SUPPORTED_FEATURES);
- if (rc != 0) {
- return rc;
- }
-
- rc = virtio_dev_start(vdev, max_queues, SPDK_VIRTIO_SCSI_QUEUE_NUM_FIXED);
- if (rc != 0) {
- return rc;
- }
-
- ctrlq_ring = spdk_ring_create(SPDK_RING_TYPE_MP_SC, CTRLQ_RING_SIZE,
- SPDK_ENV_SOCKET_ID_ANY);
- if (ctrlq_ring == NULL) {
- SPDK_ERRLOG("Failed to allocate send ring for the controlq.\n");
- return -1;
- }
-
- rc = virtio_dev_acquire_queue(vdev, VIRTIO_SCSI_CONTROLQ);
- if (rc != 0) {
- SPDK_ERRLOG("Failed to acquire the controlq.\n");
- spdk_ring_free(ctrlq_ring);
- return -1;
- }
-
- rc = virtio_dev_acquire_queue(vdev, VIRTIO_SCSI_EVENTQ);
- if (rc != 0) {
- SPDK_ERRLOG("Failed to acquire the eventq.\n");
- virtio_dev_release_queue(vdev, VIRTIO_SCSI_CONTROLQ);
- spdk_ring_free(ctrlq_ring);
- return -1;
- }
-
- eventq = vdev->vqs[VIRTIO_SCSI_EVENTQ];
- num_events = spdk_min(eventq->vq_nentries, VIRTIO_SCSI_EVENTQ_BUFFER_COUNT);
- svdev->eventq_ios = spdk_zmalloc(sizeof(*svdev->eventq_ios) * num_events,
- 0, NULL, SPDK_ENV_LCORE_ID_ANY,
- SPDK_MALLOC_DMA);
- if (svdev->eventq_ios == NULL) {
- SPDK_ERRLOG("cannot allocate memory for %"PRIu16" eventq buffers\n",
- num_events);
- virtio_dev_release_queue(vdev, VIRTIO_SCSI_EVENTQ);
- virtio_dev_release_queue(vdev, VIRTIO_SCSI_CONTROLQ);
- spdk_ring_free(ctrlq_ring);
- return -1;
- }
-
- for (i = 0; i < num_events; i++) {
- eventq_io = &svdev->eventq_ios[i];
- eventq_io->iov.iov_base = &eventq_io->ev;
- eventq_io->iov.iov_len = sizeof(eventq_io->ev);
- virtio_scsi_dev_send_eventq_io(eventq, eventq_io);
- }
-
- svdev->ctrlq_ring = ctrlq_ring;
-
- svdev->mgmt_poller = spdk_poller_register(bdev_virtio_mgmt_poll, svdev,
- MGMT_POLL_PERIOD_US);
-
- TAILQ_INIT(&svdev->luns);
- svdev->scan_ctx = NULL;
- svdev->removed = false;
- svdev->remove_cb = NULL;
- svdev->remove_ctx = NULL;
-
- spdk_io_device_register(svdev, bdev_virtio_scsi_ch_create_cb,
- bdev_virtio_scsi_ch_destroy_cb,
- sizeof(struct bdev_virtio_io_channel),
- svdev->vdev.name);
-
- pthread_mutex_lock(&g_virtio_scsi_mutex);
- TAILQ_INSERT_TAIL(&g_virtio_scsi_devs, svdev, tailq);
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
- return 0;
-}
-
-static struct virtio_scsi_dev *
-virtio_pci_scsi_dev_create(const char *name, struct virtio_pci_ctx *pci_ctx)
-{
- static int pci_dev_counter = 0;
- struct virtio_scsi_dev *svdev;
- struct virtio_dev *vdev;
- char *default_name = NULL;
- uint32_t num_queues;
- int rc;
-
- svdev = calloc(1, sizeof(*svdev));
- if (svdev == NULL) {
- SPDK_ERRLOG("virtio device calloc failed\n");
- return NULL;
- }
-
- vdev = &svdev->vdev;
- if (name == NULL) {
- default_name = spdk_sprintf_alloc("VirtioScsi%"PRIu32, pci_dev_counter++);
- if (default_name == NULL) {
- free(vdev);
- return NULL;
- }
- name = default_name;
- }
-
- rc = virtio_pci_dev_init(vdev, name, pci_ctx);
- free(default_name);
-
- if (rc != 0) {
- free(svdev);
- return NULL;
- }
-
- rc = virtio_dev_read_dev_config(vdev, offsetof(struct virtio_scsi_config, num_queues),
- &num_queues, sizeof(num_queues));
- if (rc) {
- SPDK_ERRLOG("%s: config read failed: %s\n", vdev->name, spdk_strerror(-rc));
- virtio_dev_destruct(vdev);
- free(svdev);
- return NULL;
- }
-
- rc = virtio_scsi_dev_init(svdev, num_queues);
- if (rc != 0) {
- virtio_dev_destruct(vdev);
- free(svdev);
- return NULL;
- }
-
- return svdev;
-}
-
-static struct virtio_scsi_dev *
-virtio_user_scsi_dev_create(const char *name, const char *path,
- uint16_t num_queues, uint32_t queue_size)
-{
- struct virtio_scsi_dev *svdev;
- struct virtio_dev *vdev;
- int rc;
-
- svdev = calloc(1, sizeof(*svdev));
- if (svdev == NULL) {
- SPDK_ERRLOG("calloc failed for virtio device %s: %s\n", name, path);
- return NULL;
- }
-
- vdev = &svdev->vdev;
- rc = virtio_user_dev_init(vdev, name, path, queue_size);
- if (rc != 0) {
- SPDK_ERRLOG("Failed to create virito device %s: %s\n", name, path);
- free(svdev);
- return NULL;
- }
-
- rc = virtio_scsi_dev_init(svdev, num_queues);
- if (rc != 0) {
- virtio_dev_destruct(vdev);
- free(svdev);
- return NULL;
- }
-
- return svdev;
-}
-
-static struct virtio_scsi_disk *
-virtio_scsi_dev_get_disk_by_id(struct virtio_scsi_dev *svdev, uint8_t target_id)
-{
- struct virtio_scsi_disk *disk;
-
- TAILQ_FOREACH(disk, &svdev->luns, link) {
- if (disk->info.target == target_id) {
- return disk;
- }
- }
-
- return NULL;
-}
-
-static int virtio_scsi_dev_scan(struct virtio_scsi_dev *svdev,
- bdev_virtio_create_cb cb_fn, void *cb_arg);
-static int send_scan_io(struct virtio_scsi_scan_base *base);
-static void _virtio_scsi_dev_scan_tgt(struct virtio_scsi_scan_base *base, uint8_t target);
-static int _virtio_scsi_dev_scan_next(struct virtio_scsi_scan_base *base, int rc);
-static void _virtio_scsi_dev_scan_finish(struct virtio_scsi_scan_base *base, int errnum);
-static int virtio_scsi_dev_scan_tgt(struct virtio_scsi_dev *svdev, uint8_t target);
-
-static int
-bdev_virtio_get_ctx_size(void)
-{
- return sizeof(struct virtio_scsi_io_ctx);
-}
-
-static int
-bdev_virtio_scsi_config_json(struct spdk_json_write_ctx *w)
-{
- struct virtio_scsi_dev *svdev;
-
- pthread_mutex_lock(&g_virtio_scsi_mutex);
- TAILQ_FOREACH(svdev, &g_virtio_scsi_devs, tailq) {
- spdk_json_write_object_begin(w);
-
- spdk_json_write_named_string(w, "method", "construct_virtio_dev");
-
- spdk_json_write_named_object_begin(w, "params");
- spdk_json_write_named_string(w, "name", svdev->vdev.name);
- spdk_json_write_named_string(w, "dev_type", "scsi");
-
- /* Write transport specific parameters. */
- svdev->vdev.backend_ops->write_json_config(&svdev->vdev, w);
-
- spdk_json_write_object_end(w);
-
- spdk_json_write_object_end(w);
-
- }
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
-
- return 0;
-}
-
-
-static struct spdk_bdev_module virtio_scsi_if = {
- .name = "virtio_scsi",
- .module_init = bdev_virtio_initialize,
- .module_fini = bdev_virtio_finish,
- .get_ctx_size = bdev_virtio_get_ctx_size,
- .config_json = bdev_virtio_scsi_config_json,
- .async_init = true,
- .async_fini = true,
-};
-
-SPDK_BDEV_MODULE_REGISTER(virtio_scsi, &virtio_scsi_if)
-
-static struct virtio_scsi_io_ctx *
-bdev_virtio_init_io_vreq(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
-{
- struct virtio_scsi_cmd_req *req;
- struct virtio_scsi_cmd_resp *resp;
- struct virtio_scsi_disk *disk = (struct virtio_scsi_disk *)bdev_io->bdev;
- struct virtio_scsi_io_ctx *io_ctx = (struct virtio_scsi_io_ctx *)bdev_io->driver_ctx;
-
- req = &io_ctx->req;
- resp = &io_ctx->resp;
-
- io_ctx->iov_req.iov_base = req;
- io_ctx->iov_req.iov_len = sizeof(*req);
-
- io_ctx->iov_resp.iov_base = resp;
- io_ctx->iov_resp.iov_len = sizeof(*resp);
-
- memset(req, 0, sizeof(*req));
- req->lun[0] = 1;
- req->lun[1] = disk->info.target;
-
- return io_ctx;
-}
-
-static struct virtio_scsi_io_ctx *
-bdev_virtio_init_tmf_vreq(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
-{
- struct virtio_scsi_ctrl_tmf_req *tmf_req;
- struct virtio_scsi_ctrl_tmf_resp *tmf_resp;
- struct virtio_scsi_disk *disk = SPDK_CONTAINEROF(bdev_io->bdev, struct virtio_scsi_disk, bdev);
- struct virtio_scsi_io_ctx *io_ctx = (struct virtio_scsi_io_ctx *)bdev_io->driver_ctx;
-
- tmf_req = &io_ctx->tmf_req;
- tmf_resp = &io_ctx->tmf_resp;
-
- io_ctx->iov_req.iov_base = tmf_req;
- io_ctx->iov_req.iov_len = sizeof(*tmf_req);
- io_ctx->iov_resp.iov_base = tmf_resp;
- io_ctx->iov_resp.iov_len = sizeof(*tmf_resp);
-
- memset(tmf_req, 0, sizeof(*tmf_req));
- tmf_req->lun[0] = 1;
- tmf_req->lun[1] = disk->info.target;
-
- return io_ctx;
-}
-
-static void
-bdev_virtio_send_io(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
-{
- struct bdev_virtio_io_channel *virtio_channel = spdk_io_channel_get_ctx(ch);
- struct virtqueue *vq = virtio_channel->vq;
- struct virtio_scsi_io_ctx *io_ctx = (struct virtio_scsi_io_ctx *)bdev_io->driver_ctx;
- int rc;
-
- rc = virtqueue_req_start(vq, bdev_io, bdev_io->u.bdev.iovcnt + 2);
- if (rc == -ENOMEM) {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_NOMEM);
- return;
- } else if (rc != 0) {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
- return;
- }
-
- virtqueue_req_add_iovs(vq, &io_ctx->iov_req, 1, SPDK_VIRTIO_DESC_RO);
- if (bdev_io->type == SPDK_BDEV_IO_TYPE_READ) {
- virtqueue_req_add_iovs(vq, &io_ctx->iov_resp, 1, SPDK_VIRTIO_DESC_WR);
- virtqueue_req_add_iovs(vq, bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
- SPDK_VIRTIO_DESC_WR);
- } else {
- virtqueue_req_add_iovs(vq, bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
- SPDK_VIRTIO_DESC_RO);
- virtqueue_req_add_iovs(vq, &io_ctx->iov_resp, 1, SPDK_VIRTIO_DESC_WR);
- }
-
- virtqueue_req_flush(vq);
-}
-
-static void
-bdev_virtio_rw(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
-{
- struct virtio_scsi_disk *disk = SPDK_CONTAINEROF(bdev_io->bdev, struct virtio_scsi_disk, bdev);
- struct virtio_scsi_io_ctx *io_ctx = bdev_virtio_init_io_vreq(ch, bdev_io);
- struct virtio_scsi_cmd_req *req = &io_ctx->req;
- bool is_write = bdev_io->type == SPDK_BDEV_IO_TYPE_WRITE;
-
- if (disk->info.num_blocks > (1ULL << 32)) {
- req->cdb[0] = is_write ? SPDK_SBC_WRITE_16 : SPDK_SBC_READ_16;
- to_be64(&req->cdb[2], bdev_io->u.bdev.offset_blocks);
- to_be32(&req->cdb[10], bdev_io->u.bdev.num_blocks);
- } else {
- req->cdb[0] = is_write ? SPDK_SBC_WRITE_10 : SPDK_SBC_READ_10;
- to_be32(&req->cdb[2], bdev_io->u.bdev.offset_blocks);
- to_be16(&req->cdb[7], bdev_io->u.bdev.num_blocks);
- }
-
- bdev_virtio_send_io(ch, bdev_io);
-}
-
-static void
-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 virtio_scsi_io_ctx *io_ctx = bdev_virtio_init_tmf_vreq(ch, bdev_io);
- struct virtio_scsi_ctrl_tmf_req *tmf_req = &io_ctx->tmf_req;
- struct virtio_scsi_dev *svdev = virtio_ch->svdev;
- size_t enqueued_count;
-
- tmf_req->type = VIRTIO_SCSI_T_TMF;
- tmf_req->subtype = VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET;
-
- enqueued_count = spdk_ring_enqueue(svdev->ctrlq_ring, (void **)&bdev_io, 1, NULL);
- if (spdk_likely(enqueued_count == 1)) {
- return;
- } else {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_NOMEM);
- }
-}
-
-static void
-bdev_virtio_unmap(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, bool success)
-{
- struct virtio_scsi_io_ctx *io_ctx = bdev_virtio_init_io_vreq(ch, bdev_io);
- struct virtio_scsi_cmd_req *req = &io_ctx->req;
- struct spdk_scsi_unmap_bdesc *desc, *first_desc;
- uint8_t *buf;
- uint64_t offset_blocks, num_blocks;
- uint16_t cmd_len;
-
- if (!success) {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
- return;
- }
-
- buf = bdev_io->u.bdev.iovs[0].iov_base;
-
- offset_blocks = bdev_io->u.bdev.offset_blocks;
- num_blocks = bdev_io->u.bdev.num_blocks;
-
- /* (n-1) * 16-byte descriptors */
- first_desc = desc = (struct spdk_scsi_unmap_bdesc *)&buf[8];
- while (num_blocks > UINT32_MAX) {
- to_be64(&desc->lba, offset_blocks);
- to_be32(&desc->block_count, UINT32_MAX);
- memset(&desc->reserved, 0, sizeof(desc->reserved));
- offset_blocks += UINT32_MAX;
- num_blocks -= UINT32_MAX;
- desc++;
- }
-
- /* The last descriptor with block_count <= UINT32_MAX */
- to_be64(&desc->lba, offset_blocks);
- to_be32(&desc->block_count, num_blocks);
- memset(&desc->reserved, 0, sizeof(desc->reserved));
-
- /* 8-byte header + n * 16-byte block descriptor */
- cmd_len = 8 + (desc - first_desc + 1) * sizeof(struct spdk_scsi_unmap_bdesc);
-
- req->cdb[0] = SPDK_SBC_UNMAP;
- to_be16(&req->cdb[7], cmd_len);
-
- /* 8-byte header */
- to_be16(&buf[0], cmd_len - 2); /* total length (excluding the length field) */
- to_be16(&buf[2], cmd_len - 8); /* length of block descriptors */
- memset(&buf[4], 0, 4); /* reserved */
-
- bdev_virtio_send_io(ch, bdev_io);
-}
-
-static void
-bdev_virtio_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io,
- bool success)
-{
- if (!success) {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
- return;
- }
-
- bdev_virtio_rw(ch, bdev_io);
-}
-
-static int _bdev_virtio_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
-{
- struct virtio_scsi_disk *disk = SPDK_CONTAINEROF(bdev_io->bdev, struct virtio_scsi_disk, bdev);
-
- switch (bdev_io->type) {
- case SPDK_BDEV_IO_TYPE_READ:
- spdk_bdev_io_get_buf(bdev_io, bdev_virtio_get_buf_cb,
- bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen);
- return 0;
- case SPDK_BDEV_IO_TYPE_WRITE:
- bdev_virtio_rw(ch, bdev_io);
- return 0;
- case SPDK_BDEV_IO_TYPE_RESET:
- bdev_virtio_reset(ch, bdev_io);
- return 0;
- case SPDK_BDEV_IO_TYPE_UNMAP: {
- uint64_t buf_len = 8 /* header size */ +
- (bdev_io->u.bdev.num_blocks + UINT32_MAX - 1) /
- UINT32_MAX * sizeof(struct spdk_scsi_unmap_bdesc);
-
- if (!disk->info.unmap_supported) {
- return -1;
- }
-
- if (buf_len > SPDK_BDEV_LARGE_BUF_MAX_SIZE) {
- SPDK_ERRLOG("Trying to UNMAP too many blocks: %"PRIu64"\n",
- bdev_io->u.bdev.num_blocks);
- return -1;
- }
- spdk_bdev_io_get_buf(bdev_io, bdev_virtio_unmap, buf_len);
- return 0;
- }
- case SPDK_BDEV_IO_TYPE_FLUSH:
- default:
- return -1;
- }
- return 0;
-}
-
-static void bdev_virtio_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
-{
- if (_bdev_virtio_submit_request(ch, bdev_io) < 0) {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
- }
-}
-
-static bool
-bdev_virtio_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
-{
- struct virtio_scsi_disk *disk = ctx;
-
- switch (io_type) {
- case SPDK_BDEV_IO_TYPE_READ:
- case SPDK_BDEV_IO_TYPE_WRITE:
- case SPDK_BDEV_IO_TYPE_FLUSH:
- case SPDK_BDEV_IO_TYPE_RESET:
- return true;
-
- case SPDK_BDEV_IO_TYPE_UNMAP:
- return disk->info.unmap_supported;
-
- default:
- return false;
- }
-}
-
-static struct spdk_io_channel *
-bdev_virtio_get_io_channel(void *ctx)
-{
- struct virtio_scsi_disk *disk = ctx;
-
- return spdk_get_io_channel(disk->svdev);
-}
-
-static int
-bdev_virtio_disk_destruct(void *ctx)
-{
- struct virtio_scsi_disk *disk = ctx;
- struct virtio_scsi_dev *svdev = disk->svdev;
-
- TAILQ_REMOVE(&svdev->luns, disk, link);
- free(disk->bdev.name);
- free(disk);
-
- if (svdev->removed && TAILQ_EMPTY(&svdev->luns)) {
- spdk_io_device_unregister(svdev, virtio_scsi_dev_unregister_cb);
- }
-
- return 0;
-}
-
-static int
-bdev_virtio_dump_info_json(void *ctx, struct spdk_json_write_ctx *w)
-{
- struct virtio_scsi_disk *disk = ctx;
-
- virtio_dev_dump_json_info(&disk->svdev->vdev, w);
- return 0;
-}
-
-static void
-bdev_virtio_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w)
-{
- /* SCSI targets and LUNS are discovered during scan process so nothing
- * to save here.
- */
-}
-
-static const struct spdk_bdev_fn_table virtio_fn_table = {
- .destruct = bdev_virtio_disk_destruct,
- .submit_request = bdev_virtio_submit_request,
- .io_type_supported = bdev_virtio_io_type_supported,
- .get_io_channel = bdev_virtio_get_io_channel,
- .dump_info_json = bdev_virtio_dump_info_json,
- .write_config_json = bdev_virtio_write_config_json,
-};
-
-static void
-get_scsi_status(struct virtio_scsi_cmd_resp *resp, int *sk, int *asc, int *ascq)
-{
- /* see spdk_scsi_task_build_sense_data() for sense data details */
- *sk = 0;
- *asc = 0;
- *ascq = 0;
-
- if (resp->sense_len < 3) {
- return;
- }
-
- *sk = resp->sense[2] & 0xf;
-
- if (resp->sense_len < 13) {
- return;
- }
-
- *asc = resp->sense[12];
-
- if (resp->sense_len < 14) {
- return;
- }
-
- *ascq = resp->sense[13];
-}
-
-static void
-bdev_virtio_io_cpl(struct spdk_bdev_io *bdev_io)
-{
- struct virtio_scsi_io_ctx *io_ctx = (struct virtio_scsi_io_ctx *)bdev_io->driver_ctx;
- int sk, asc, ascq;
-
- get_scsi_status(&io_ctx->resp, &sk, &asc, &ascq);
- spdk_bdev_io_complete_scsi_status(bdev_io, io_ctx->resp.status, sk, asc, ascq);
-}
-
-static int
-bdev_virtio_poll(void *arg)
-{
- struct bdev_virtio_io_channel *ch = arg;
- struct virtio_scsi_dev *svdev = ch->svdev;
- struct virtio_scsi_scan_base *scan_ctx = svdev->scan_ctx;
- void *io[32];
- uint32_t io_len[32];
- uint16_t i, cnt;
- int rc;
-
- cnt = virtio_recv_pkts(ch->vq, (void **)io, io_len, SPDK_COUNTOF(io));
- for (i = 0; i < cnt; ++i) {
- if (spdk_unlikely(scan_ctx && io[i] == &scan_ctx->io_ctx)) {
- if (svdev->removed) {
- _virtio_scsi_dev_scan_finish(scan_ctx, -EINTR);
- return -1;
- }
-
- if (scan_ctx->restart) {
- scan_ctx->restart = false;
- scan_ctx->full_scan = true;
- _virtio_scsi_dev_scan_tgt(scan_ctx, 0);
- continue;
- }
-
- process_scan_resp(scan_ctx);
- continue;
- }
-
- bdev_virtio_io_cpl(io[i]);
- }
-
- if (spdk_unlikely(scan_ctx && scan_ctx->needs_resend)) {
- if (svdev->removed) {
- _virtio_scsi_dev_scan_finish(scan_ctx, -EINTR);
- return -1;
- } else if (cnt == 0) {
- return 0;
- }
-
- rc = send_scan_io(scan_ctx);
- if (rc != 0) {
- assert(scan_ctx->retries > 0);
- scan_ctx->retries--;
- if (scan_ctx->retries == 0) {
- SPDK_ERRLOG("Target scan failed unrecoverably with rc = %d.\n", rc);
- _virtio_scsi_dev_scan_finish(scan_ctx, rc);
- }
- }
- }
-
- return cnt;
-}
-
-static void
-bdev_virtio_tmf_cpl_cb(void *ctx)
-{
- struct spdk_bdev_io *bdev_io = ctx;
- struct virtio_scsi_io_ctx *io_ctx = (struct virtio_scsi_io_ctx *)bdev_io->driver_ctx;
-
- if (io_ctx->tmf_resp.response == VIRTIO_SCSI_S_OK) {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS);
- } else {
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
- }
-}
-
-static void
-bdev_virtio_tmf_cpl(struct spdk_bdev_io *bdev_io)
-{
- spdk_thread_send_msg(spdk_bdev_io_get_thread(bdev_io), bdev_virtio_tmf_cpl_cb, bdev_io);
-}
-
-static void
-bdev_virtio_eventq_io_cpl(struct virtio_scsi_dev *svdev, struct virtio_scsi_eventq_io *io)
-{
- struct virtio_scsi_event *ev = &io->ev;
- struct virtio_scsi_disk *disk;
-
- if (ev->lun[0] != 1) {
- SPDK_WARNLOG("Received an event with invalid data layout.\n");
- goto out;
- }
-
- if (ev->event & VIRTIO_SCSI_T_EVENTS_MISSED) {
- ev->event &= ~VIRTIO_SCSI_T_EVENTS_MISSED;
- virtio_scsi_dev_scan(svdev, NULL, NULL);
- }
-
- switch (ev->event) {
- case VIRTIO_SCSI_T_NO_EVENT:
- break;
- case VIRTIO_SCSI_T_TRANSPORT_RESET:
- switch (ev->reason) {
- case VIRTIO_SCSI_EVT_RESET_RESCAN:
- virtio_scsi_dev_scan_tgt(svdev, ev->lun[1]);
- break;
- case VIRTIO_SCSI_EVT_RESET_REMOVED:
- disk = virtio_scsi_dev_get_disk_by_id(svdev, ev->lun[1]);
- if (disk != NULL) {
- spdk_bdev_unregister(&disk->bdev, NULL, NULL);
- }
- break;
- default:
- break;
- }
- break;
- default:
- break;
- }
-
-out:
- virtio_scsi_dev_send_eventq_io(svdev->vdev.vqs[VIRTIO_SCSI_EVENTQ], io);
-}
-
-static void
-bdev_virtio_tmf_abort_nomem_cb(void *ctx)
-{
- struct spdk_bdev_io *bdev_io = ctx;
-
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_NOMEM);
-}
-
-static void
-bdev_virtio_tmf_abort_ioerr_cb(void *ctx)
-{
- struct spdk_bdev_io *bdev_io = ctx;
-
- spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
-}
-
-static void
-bdev_virtio_tmf_abort(struct spdk_bdev_io *bdev_io, int status)
-{
- spdk_msg_fn fn;
-
- if (status == -ENOMEM) {
- fn = bdev_virtio_tmf_abort_nomem_cb;
- } else {
- fn = bdev_virtio_tmf_abort_ioerr_cb;
- }
-
- spdk_thread_send_msg(spdk_bdev_io_get_thread(bdev_io), fn, bdev_io);
-}
-
-static int
-bdev_virtio_send_tmf_io(struct virtqueue *ctrlq, struct spdk_bdev_io *bdev_io)
-{
- struct virtio_scsi_io_ctx *io_ctx = (struct virtio_scsi_io_ctx *)bdev_io->driver_ctx;
- int rc;
-
- rc = virtqueue_req_start(ctrlq, bdev_io, 2);
- if (rc != 0) {
- return rc;
- }
-
- virtqueue_req_add_iovs(ctrlq, &io_ctx->iov_req, 1, SPDK_VIRTIO_DESC_RO);
- virtqueue_req_add_iovs(ctrlq, &io_ctx->iov_resp, 1, SPDK_VIRTIO_DESC_WR);
-
- virtqueue_req_flush(ctrlq);
- return 0;
-}
-
-static int
-bdev_virtio_mgmt_poll(void *arg)
-{
- struct virtio_scsi_dev *svdev = arg;
- struct virtio_dev *vdev = &svdev->vdev;
- struct virtqueue *eventq = vdev->vqs[VIRTIO_SCSI_EVENTQ];
- struct virtqueue *ctrlq = vdev->vqs[VIRTIO_SCSI_CONTROLQ];
- struct spdk_ring *send_ring = svdev->ctrlq_ring;
- void *io[16];
- uint32_t io_len[16];
- uint16_t i, cnt;
- int rc;
- int total = 0;
-
- cnt = spdk_ring_dequeue(send_ring, io, SPDK_COUNTOF(io));
- total += cnt;
- for (i = 0; i < cnt; ++i) {
- rc = bdev_virtio_send_tmf_io(ctrlq, io[i]);
- if (rc != 0) {
- bdev_virtio_tmf_abort(io[i], rc);
- }
- }
-
- cnt = virtio_recv_pkts(ctrlq, io, io_len, SPDK_COUNTOF(io));
- total += cnt;
- for (i = 0; i < cnt; ++i) {
- bdev_virtio_tmf_cpl(io[i]);
- }
-
- cnt = virtio_recv_pkts(eventq, io, io_len, SPDK_COUNTOF(io));
- total += cnt;
- for (i = 0; i < cnt; ++i) {
- bdev_virtio_eventq_io_cpl(svdev, io[i]);
- }
-
- return total;
-}
-
-static int
-bdev_virtio_scsi_ch_create_cb(void *io_device, void *ctx_buf)
-{
- struct virtio_scsi_dev *svdev = io_device;
- struct virtio_dev *vdev = &svdev->vdev;
- struct bdev_virtio_io_channel *ch = ctx_buf;
- struct virtqueue *vq;
- int32_t queue_idx;
-
- queue_idx = virtio_dev_find_and_acquire_queue(vdev, VIRTIO_SCSI_REQUESTQ);
- if (queue_idx < 0) {
- SPDK_ERRLOG("Couldn't get an unused queue for the io_channel.\n");
- return -1;
- }
-
- vq = vdev->vqs[queue_idx];
-
- ch->svdev = svdev;
- ch->vq = vq;
-
- ch->poller = spdk_poller_register(bdev_virtio_poll, ch, 0);
-
- return 0;
-}
-
-static void
-bdev_virtio_scsi_ch_destroy_cb(void *io_device, void *ctx_buf)
-{
- struct bdev_virtio_io_channel *ch = ctx_buf;
- struct virtio_scsi_dev *svdev = ch->svdev;
- struct virtio_dev *vdev = &svdev->vdev;
- struct virtqueue *vq = ch->vq;
-
- spdk_poller_unregister(&ch->poller);
- virtio_dev_release_queue(vdev, vq->vq_queue_index);
-}
-
-static void
-_virtio_scsi_dev_scan_finish(struct virtio_scsi_scan_base *base, int errnum)
-{
- struct virtio_scsi_dev *svdev = base->svdev;
- size_t bdevs_cnt;
- struct spdk_bdev *bdevs[BDEV_VIRTIO_MAX_TARGET];
- struct virtio_scsi_disk *disk;
- struct virtio_scsi_scan_info *tgt, *next_tgt;
-
- spdk_put_io_channel(spdk_io_channel_from_ctx(base->channel));
- base->svdev->scan_ctx = NULL;
-
- TAILQ_FOREACH_SAFE(tgt, &base->scan_queue, tailq, next_tgt) {
- TAILQ_REMOVE(&base->scan_queue, tgt, tailq);
- free(tgt);
- }
-
- if (base->cb_fn == NULL) {
- spdk_free(base);
- return;
- }
-
- bdevs_cnt = 0;
- if (errnum == 0) {
- TAILQ_FOREACH(disk, &svdev->luns, link) {
- bdevs[bdevs_cnt] = &disk->bdev;
- bdevs_cnt++;
- }
- }
-
- base->cb_fn(base->cb_arg, errnum, bdevs, bdevs_cnt);
- spdk_free(base);
-}
-
-static int
-send_scan_io(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_io_ctx *io_ctx = &base->io_ctx;
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
- struct virtqueue *vq = base->channel->vq;
- int payload_iov_cnt = base->iov.iov_len > 0 ? 1 : 0;
- int rc;
-
- req->lun[0] = 1;
- req->lun[1] = base->info.target;
-
- rc = virtqueue_req_start(vq, io_ctx, 2 + payload_iov_cnt);
- if (rc != 0) {
- base->needs_resend = true;
- return -1;
- }
-
- virtqueue_req_add_iovs(vq, &io_ctx->iov_req, 1, SPDK_VIRTIO_DESC_RO);
- virtqueue_req_add_iovs(vq, &io_ctx->iov_resp, 1, SPDK_VIRTIO_DESC_WR);
- virtqueue_req_add_iovs(vq, &base->iov, payload_iov_cnt, SPDK_VIRTIO_DESC_WR);
-
- virtqueue_req_flush(vq);
- return 0;
-}
-
-static int
-send_inquiry(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
- struct spdk_scsi_cdb_inquiry *cdb;
-
- memset(req, 0, sizeof(*req));
-
- base->iov.iov_len = BDEV_VIRTIO_SCAN_PAYLOAD_SIZE;
- cdb = (struct spdk_scsi_cdb_inquiry *)req->cdb;
- cdb->opcode = SPDK_SPC_INQUIRY;
- to_be16(cdb->alloc_len, BDEV_VIRTIO_SCAN_PAYLOAD_SIZE);
-
- return send_scan_io(base);
-}
-
-static int
-send_inquiry_vpd(struct virtio_scsi_scan_base *base, uint8_t page_code)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
- struct spdk_scsi_cdb_inquiry *inquiry_cdb = (struct spdk_scsi_cdb_inquiry *)req->cdb;
-
- memset(req, 0, sizeof(*req));
-
- base->iov.iov_len = BDEV_VIRTIO_SCAN_PAYLOAD_SIZE;
- inquiry_cdb->opcode = SPDK_SPC_INQUIRY;
- inquiry_cdb->evpd = 1;
- inquiry_cdb->page_code = page_code;
- to_be16(inquiry_cdb->alloc_len, base->iov.iov_len);
-
- return send_scan_io(base);
-}
-
-static int
-send_read_cap_10(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
-
- memset(req, 0, sizeof(*req));
-
- base->iov.iov_len = 8;
- req->cdb[0] = SPDK_SBC_READ_CAPACITY_10;
-
- return send_scan_io(base);
-}
-
-static int
-send_read_cap_16(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
-
- memset(req, 0, sizeof(*req));
-
- base->iov.iov_len = 32;
- req->cdb[0] = SPDK_SPC_SERVICE_ACTION_IN_16;
- req->cdb[1] = SPDK_SBC_SAI_READ_CAPACITY_16;
- to_be32(&req->cdb[10], base->iov.iov_len);
-
- return send_scan_io(base);
-}
-
-static int
-send_test_unit_ready(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
-
- memset(req, 0, sizeof(*req));
- req->cdb[0] = SPDK_SPC_TEST_UNIT_READY;
- base->iov.iov_len = 0;
-
- return send_scan_io(base);
-}
-
-static int
-send_start_stop_unit(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
-
- memset(req, 0, sizeof(*req));
- req->cdb[0] = SPDK_SBC_START_STOP_UNIT;
- req->cdb[4] = SPDK_SBC_START_STOP_UNIT_START_BIT;
- base->iov.iov_len = 0;
-
- return send_scan_io(base);
-}
-
-static int
-process_scan_start_stop_unit(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
-
- if (resp->status == SPDK_SCSI_STATUS_GOOD) {
- return send_inquiry_vpd(base, SPDK_SPC_VPD_SUPPORTED_VPD_PAGES);
- }
-
- return -1;
-}
-
-static int
-process_scan_test_unit_ready(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
- int sk, asc, ascq;
-
- get_scsi_status(resp, &sk, &asc, &ascq);
-
- /* check response, get VPD if spun up otherwise send SSU */
- if (resp->status == SPDK_SCSI_STATUS_GOOD) {
- return send_inquiry_vpd(base, SPDK_SPC_VPD_SUPPORTED_VPD_PAGES);
- } else if (resp->response == VIRTIO_SCSI_S_OK &&
- resp->status == SPDK_SCSI_STATUS_CHECK_CONDITION &&
- sk == SPDK_SCSI_SENSE_UNIT_ATTENTION &&
- asc == SPDK_SCSI_ASC_LOGICAL_UNIT_NOT_READY) {
- return send_start_stop_unit(base);
- } else {
- return -1;
- }
-}
-
-static int
-process_scan_inquiry_standard(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
- struct spdk_scsi_cdb_inquiry_data *inquiry_data =
- (struct spdk_scsi_cdb_inquiry_data *)base->payload;
-
- if (resp->status != SPDK_SCSI_STATUS_GOOD) {
- return -1;
- }
-
- /* check to make sure its a supported device */
- if (inquiry_data->peripheral_device_type != SPDK_SPC_PERIPHERAL_DEVICE_TYPE_DISK ||
- inquiry_data->peripheral_qualifier != SPDK_SPC_PERIPHERAL_QUALIFIER_CONNECTED) {
- SPDK_WARNLOG("Unsupported peripheral device type 0x%02x (qualifier 0x%02x)\n",
- inquiry_data->peripheral_device_type,
- inquiry_data->peripheral_qualifier);
- return -1;
- }
-
- return send_test_unit_ready(base);
-}
-
-static int
-process_scan_inquiry_vpd_supported_vpd_pages(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
- bool block_provisioning_page_supported = false;
-
- if (resp->status == SPDK_SCSI_STATUS_GOOD) {
- const uint8_t *vpd_data = base->payload;
- const uint8_t *supported_vpd_pages = vpd_data + 4;
- uint16_t page_length;
- uint16_t num_supported_pages;
- uint16_t i;
-
- page_length = from_be16(vpd_data + 2);
- num_supported_pages = spdk_min(page_length, base->iov.iov_len - 4);
-
- for (i = 0; i < num_supported_pages; i++) {
- if (supported_vpd_pages[i] == SPDK_SPC_VPD_BLOCK_THIN_PROVISION) {
- block_provisioning_page_supported = true;
- break;
- }
- }
- }
-
- if (block_provisioning_page_supported) {
- return send_inquiry_vpd(base, SPDK_SPC_VPD_BLOCK_THIN_PROVISION);
- } else {
- return send_read_cap_10(base);
- }
-}
-
-static int
-process_scan_inquiry_vpd_block_thin_provision(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
-
- base->info.unmap_supported = false;
-
- if (resp->status == SPDK_SCSI_STATUS_GOOD) {
- uint8_t *vpd_data = base->payload;
-
- base->info.unmap_supported = !!(vpd_data[5] & SPDK_SCSI_UNMAP_LBPU);
- }
-
- SPDK_INFOLOG(SPDK_LOG_VIRTIO, "Target %u: unmap supported = %d\n",
- base->info.target, (int)base->info.unmap_supported);
-
- return send_read_cap_10(base);
-}
-
-static int
-process_scan_inquiry(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
- struct spdk_scsi_cdb_inquiry *inquiry_cdb = (struct spdk_scsi_cdb_inquiry *)req->cdb;
-
- if ((inquiry_cdb->evpd & 1) == 0) {
- return process_scan_inquiry_standard(base);
- }
-
- switch (inquiry_cdb->page_code) {
- case SPDK_SPC_VPD_SUPPORTED_VPD_PAGES:
- return process_scan_inquiry_vpd_supported_vpd_pages(base);
- case SPDK_SPC_VPD_BLOCK_THIN_PROVISION:
- return process_scan_inquiry_vpd_block_thin_provision(base);
- default:
- SPDK_DEBUGLOG(SPDK_LOG_VIRTIO, "Unexpected VPD page 0x%02x\n", inquiry_cdb->page_code);
- return -1;
- }
-}
-
-static void
-bdev_virtio_disc_notify_remove(void *remove_ctx)
-{
- struct virtio_scsi_disk *disk = remove_ctx;
-
- disk->removed = true;
- spdk_bdev_close(disk->notify_desc);
-}
-
-/* To be called only from the thread performing target scan */
-static int
-virtio_scsi_dev_add_tgt(struct virtio_scsi_dev *svdev, struct virtio_scsi_scan_info *info)
-{
- struct virtio_scsi_disk *disk;
- struct spdk_bdev *bdev;
- int rc;
-
- TAILQ_FOREACH(disk, &svdev->luns, link) {
- if (disk->info.target == info->target) {
- /* Target is already attached and param change is not supported */
- return 0;
- }
- }
-
- if (info->block_size == 0 || info->num_blocks == 0) {
- SPDK_ERRLOG("%s: invalid target %u: bs=%"PRIu32" blocks=%"PRIu64"\n",
- svdev->vdev.name, info->target, info->block_size, info->num_blocks);
- return -EINVAL;
- }
-
- disk = calloc(1, sizeof(*disk));
- if (disk == NULL) {
- SPDK_ERRLOG("could not allocate disk\n");
- return -ENOMEM;
- }
-
- disk->svdev = svdev;
- memcpy(&disk->info, info, sizeof(*info));
-
- bdev = &disk->bdev;
- bdev->name = spdk_sprintf_alloc("%st%"PRIu8, svdev->vdev.name, info->target);
- if (bdev->name == NULL) {
- SPDK_ERRLOG("Couldn't alloc memory for the bdev name.\n");
- free(disk);
- return -ENOMEM;
- }
-
- bdev->product_name = "Virtio SCSI Disk";
- bdev->write_cache = 0;
- bdev->blocklen = disk->info.block_size;
- bdev->blockcnt = disk->info.num_blocks;
-
- bdev->ctxt = disk;
- bdev->fn_table = &virtio_fn_table;
- bdev->module = &virtio_scsi_if;
-
- rc = spdk_bdev_register(&disk->bdev);
- if (rc) {
- SPDK_ERRLOG("Failed to register bdev name=%s\n", disk->bdev.name);
- free(bdev->name);
- free(disk);
- return rc;
- }
-
- rc = spdk_bdev_open(bdev, false, bdev_virtio_disc_notify_remove, disk, &disk->notify_desc);
- if (rc) {
- assert(false);
- }
-
- TAILQ_INSERT_TAIL(&svdev->luns, disk, link);
- return 0;
-}
-
-static int
-process_read_cap_10(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
- uint64_t max_block;
- uint32_t block_size;
- uint8_t target_id = req->lun[1];
- int rc;
-
- if (resp->response != VIRTIO_SCSI_S_OK || resp->status != SPDK_SCSI_STATUS_GOOD) {
- SPDK_ERRLOG("READ CAPACITY (10) failed for target %"PRIu8".\n", target_id);
- return -1;
- }
-
- block_size = from_be32(base->payload + 4);
- max_block = from_be32(base->payload);
-
- if (max_block == 0xffffffff) {
- return send_read_cap_16(base);
- }
-
- base->info.num_blocks = (uint64_t)max_block + 1;
- base->info.block_size = block_size;
-
- rc = virtio_scsi_dev_add_tgt(base->svdev, &base->info);
- if (rc != 0) {
- return rc;
- }
-
- return _virtio_scsi_dev_scan_next(base, 0);
-}
-
-static int
-process_read_cap_16(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
- uint8_t target_id = req->lun[1];
- int rc;
-
- if (resp->response != VIRTIO_SCSI_S_OK || resp->status != SPDK_SCSI_STATUS_GOOD) {
- SPDK_ERRLOG("READ CAPACITY (16) failed for target %"PRIu8".\n", target_id);
- return -1;
- }
-
- base->info.num_blocks = from_be64(base->payload) + 1;
- base->info.block_size = from_be32(base->payload + 8);
- rc = virtio_scsi_dev_add_tgt(base->svdev, &base->info);
- if (rc != 0) {
- return rc;
- }
-
- return _virtio_scsi_dev_scan_next(base, 0);
-}
-
-static void
-process_scan_resp(struct virtio_scsi_scan_base *base)
-{
- struct virtio_scsi_cmd_req *req = &base->io_ctx.req;
- struct virtio_scsi_cmd_resp *resp = &base->io_ctx.resp;
- int rc, sk, asc, ascq;
- uint8_t target_id;
-
- if (base->io_ctx.iov_req.iov_len < sizeof(struct virtio_scsi_cmd_req) ||
- base->io_ctx.iov_resp.iov_len < sizeof(struct virtio_scsi_cmd_resp)) {
- SPDK_ERRLOG("Received target scan message with invalid length.\n");
- _virtio_scsi_dev_scan_next(base, -EIO);
- return;
- }
-
- get_scsi_status(resp, &sk, &asc, &ascq);
- target_id = req->lun[1];
-
- if (resp->response == VIRTIO_SCSI_S_BAD_TARGET ||
- resp->response == VIRTIO_SCSI_S_INCORRECT_LUN) {
- _virtio_scsi_dev_scan_next(base, -ENODEV);
- return;
- }
-
- if (resp->response != VIRTIO_SCSI_S_OK ||
- (resp->status == SPDK_SCSI_STATUS_CHECK_CONDITION &&
- sk != SPDK_SCSI_SENSE_ILLEGAL_REQUEST)) {
- assert(base->retries > 0);
- base->retries--;
- if (base->retries == 0) {
- SPDK_NOTICELOG("Target %"PRIu8" is present, but unavailable.\n", target_id);
- SPDK_LOGDUMP(SPDK_LOG_VIRTIO, "CDB", req->cdb, sizeof(req->cdb));
- SPDK_LOGDUMP(SPDK_LOG_VIRTIO, "SENSE DATA", resp->sense, sizeof(resp->sense));
- _virtio_scsi_dev_scan_next(base, -EBUSY);
- return;
- }
-
- /* resend the same request */
- rc = send_scan_io(base);
- if (rc != 0) {
- /* Let response poller do the resend */
- }
- return;
- }
-
- base->retries = SCAN_REQUEST_RETRIES;
-
- switch (req->cdb[0]) {
- case SPDK_SPC_INQUIRY:
- rc = process_scan_inquiry(base);
- break;
- case SPDK_SPC_TEST_UNIT_READY:
- rc = process_scan_test_unit_ready(base);
- break;
- case SPDK_SBC_START_STOP_UNIT:
- rc = process_scan_start_stop_unit(base);
- break;
- case SPDK_SBC_READ_CAPACITY_10:
- rc = process_read_cap_10(base);
- break;
- case SPDK_SPC_SERVICE_ACTION_IN_16:
- rc = process_read_cap_16(base);
- break;
- default:
- SPDK_ERRLOG("Received invalid target scan message: cdb[0] = %"PRIu8".\n", req->cdb[0]);
- rc = -1;
- break;
- }
-
- if (rc != 0) {
- if (base->needs_resend) {
- return; /* Let response poller do the resend */
- }
-
- _virtio_scsi_dev_scan_next(base, rc);
- }
-}
-
-static int
-_virtio_scsi_dev_scan_next(struct virtio_scsi_scan_base *base, int rc)
-{
- struct virtio_scsi_scan_info *next;
- struct virtio_scsi_disk *disk;
- uint8_t target_id;
-
- if (base->full_scan) {
- if (rc != 0) {
- disk = virtio_scsi_dev_get_disk_by_id(base->svdev,
- base->info.target);
- if (disk != NULL) {
- spdk_bdev_unregister(&disk->bdev, NULL, NULL);
- }
- }
-
- target_id = base->info.target + 1;
- if (target_id < BDEV_VIRTIO_MAX_TARGET) {
- _virtio_scsi_dev_scan_tgt(base, target_id);
- return 0;
- }
-
- base->full_scan = false;
- }
-
- next = TAILQ_FIRST(&base->scan_queue);
- if (next == NULL) {
- _virtio_scsi_dev_scan_finish(base, 0);
- return 0;
- }
-
- TAILQ_REMOVE(&base->scan_queue, next, tailq);
- target_id = next->target;
- free(next);
-
- _virtio_scsi_dev_scan_tgt(base, target_id);
- return 0;
-}
-
-static int
-virtio_pci_scsi_dev_enumerate_cb(struct virtio_pci_ctx *pci_ctx, void *ctx)
-{
- struct virtio_scsi_dev *svdev;
-
- svdev = virtio_pci_scsi_dev_create(NULL, pci_ctx);
- return svdev == NULL ? -1 : 0;
-}
-
-static int
-bdev_virtio_process_config(void)
-{
- struct spdk_conf_section *sp;
- struct virtio_scsi_dev *svdev;
- char *default_name = NULL;
- char *path, *type, *name;
- unsigned vdev_num;
- int num_queues;
- bool enable_pci;
- int rc = 0;
-
- for (sp = spdk_conf_first_section(NULL); sp != NULL; sp = spdk_conf_next_section(sp)) {
- if (!spdk_conf_section_match_prefix(sp, "VirtioUser")) {
- continue;
- }
-
- if (sscanf(spdk_conf_section_get_name(sp), "VirtioUser%u", &vdev_num) != 1) {
- SPDK_ERRLOG("Section '%s' has non-numeric suffix.\n",
- spdk_conf_section_get_name(sp));
- rc = -1;
- goto out;
- }
-
- path = spdk_conf_section_get_val(sp, "Path");
- if (path == NULL) {
- SPDK_ERRLOG("VirtioUser%u: missing Path\n", vdev_num);
- rc = -1;
- goto out;
- }
-
- type = spdk_conf_section_get_val(sp, "Type");
- if (type != NULL && strcmp(type, "SCSI") != 0) {
- continue;
- }
-
- num_queues = spdk_conf_section_get_intval(sp, "Queues");
- if (num_queues < 1) {
- num_queues = 1;
- } else if (num_queues > SPDK_VIRTIO_MAX_VIRTQUEUES) {
- num_queues = SPDK_VIRTIO_MAX_VIRTQUEUES;
- }
-
- name = spdk_conf_section_get_val(sp, "Name");
- if (name == NULL) {
- default_name = spdk_sprintf_alloc("VirtioScsi%u", vdev_num);
- name = default_name;
- }
-
- svdev = virtio_user_scsi_dev_create(name, path, num_queues, 512);
- free(default_name);
- default_name = NULL;
-
- if (svdev == NULL) {
- rc = -1;
- goto out;
- }
- }
-
- sp = spdk_conf_find_section(NULL, "VirtioPci");
- if (sp == NULL) {
- return 0;
- }
-
- enable_pci = spdk_conf_section_get_boolval(sp, "Enable", false);
- if (enable_pci) {
- rc = virtio_pci_dev_enumerate(virtio_pci_scsi_dev_enumerate_cb, NULL,
- PCI_DEVICE_ID_VIRTIO_SCSI_MODERN);
- }
-
-out:
- return rc;
-}
-
-static int
-_virtio_scsi_dev_scan_init(struct virtio_scsi_dev *svdev)
-{
- struct virtio_scsi_scan_base *base;
- struct spdk_io_channel *io_ch;
- struct virtio_scsi_io_ctx *io_ctx;
- struct virtio_scsi_cmd_req *req;
- struct virtio_scsi_cmd_resp *resp;
-
- io_ch = spdk_get_io_channel(svdev);
- if (io_ch == NULL) {
- return -EBUSY;
- }
-
- base = spdk_zmalloc(sizeof(*base), 64, NULL,
- SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
- if (base == NULL) {
- SPDK_ERRLOG("couldn't allocate memory for scsi target scan.\n");
- return -ENOMEM;
- }
-
- base->svdev = svdev;
-
- base->channel = spdk_io_channel_get_ctx(io_ch);
- TAILQ_INIT(&base->scan_queue);
- svdev->scan_ctx = base;
-
- base->iov.iov_base = base->payload;
- io_ctx = &base->io_ctx;
- req = &io_ctx->req;
- resp = &io_ctx->resp;
- io_ctx->iov_req.iov_base = req;
- io_ctx->iov_req.iov_len = sizeof(*req);
- io_ctx->iov_resp.iov_base = resp;
- io_ctx->iov_resp.iov_len = sizeof(*resp);
-
- base->retries = SCAN_REQUEST_RETRIES;
- return 0;
-}
-
-static void
-_virtio_scsi_dev_scan_tgt(struct virtio_scsi_scan_base *base, uint8_t target)
-{
- int rc;
-
- memset(&base->info, 0, sizeof(base->info));
- base->info.target = target;
-
- rc = send_inquiry(base);
- if (rc) {
- /* Let response poller do the resend */
- }
-}
-
-static int
-virtio_scsi_dev_scan(struct virtio_scsi_dev *svdev, bdev_virtio_create_cb cb_fn,
- void *cb_arg)
-{
- struct virtio_scsi_scan_base *base;
- struct virtio_scsi_scan_info *tgt, *next_tgt;
- int rc;
-
- if (svdev->scan_ctx) {
- if (svdev->scan_ctx->full_scan) {
- return -EEXIST;
- }
-
- /* We're about to start a full rescan, so there's no need
- * to scan particular targets afterwards.
- */
- TAILQ_FOREACH_SAFE(tgt, &svdev->scan_ctx->scan_queue, tailq, next_tgt) {
- TAILQ_REMOVE(&svdev->scan_ctx->scan_queue, tgt, tailq);
- free(tgt);
- }
-
- svdev->scan_ctx->cb_fn = cb_fn;
- svdev->scan_ctx->cb_arg = cb_arg;
- svdev->scan_ctx->restart = true;
- return 0;
- }
-
- rc = _virtio_scsi_dev_scan_init(svdev);
- if (rc != 0) {
- return rc;
- }
-
- base = svdev->scan_ctx;
- base->cb_fn = cb_fn;
- base->cb_arg = cb_arg;
- base->full_scan = true;
-
- _virtio_scsi_dev_scan_tgt(base, 0);
- return 0;
-}
-
-static int
-virtio_scsi_dev_scan_tgt(struct virtio_scsi_dev *svdev, uint8_t target)
-{
- struct virtio_scsi_scan_base *base;
- struct virtio_scsi_scan_info *info;
- int rc;
-
- base = svdev->scan_ctx;
- if (base) {
- info = calloc(1, sizeof(*info));
- if (info == NULL) {
- SPDK_ERRLOG("calloc failed\n");
- return -ENOMEM;
- }
-
- info->target = target;
- TAILQ_INSERT_TAIL(&base->scan_queue, info, tailq);
- return 0;
- }
-
- rc = _virtio_scsi_dev_scan_init(svdev);
- if (rc != 0) {
- return rc;
- }
-
- base = svdev->scan_ctx;
- base->full_scan = true;
- _virtio_scsi_dev_scan_tgt(base, target);
- return 0;
-}
-
-static void
-bdev_virtio_initial_scan_complete(void *ctx, int result,
- struct spdk_bdev **bdevs, size_t bdevs_cnt)
-{
- struct virtio_scsi_dev *svdev;
-
- pthread_mutex_lock(&g_virtio_scsi_mutex);
- TAILQ_FOREACH(svdev, &g_virtio_scsi_devs, tailq) {
- if (svdev->scan_ctx) {
- /* another device is still being scanned */
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
- return;
- }
- }
-
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
- spdk_bdev_module_init_done(&virtio_scsi_if);
-}
-
-static int
-bdev_virtio_initialize(void)
-{
- struct virtio_scsi_dev *svdev, *next_svdev;
- int rc;
-
- rc = bdev_virtio_process_config();
- pthread_mutex_lock(&g_virtio_scsi_mutex);
-
- if (rc != 0) {
- goto err_unlock;
- }
-
- if (TAILQ_EMPTY(&g_virtio_scsi_devs)) {
- goto out_unlock;
- }
-
- /* Initialize all created devices and scan available targets */
- TAILQ_FOREACH(svdev, &g_virtio_scsi_devs, tailq) {
- rc = virtio_scsi_dev_scan(svdev, bdev_virtio_initial_scan_complete, NULL);
- if (rc != 0) {
- goto err_unlock;
- }
- }
-
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
- return 0;
-
-err_unlock:
- /* Remove any created devices */
- TAILQ_FOREACH_SAFE(svdev, &g_virtio_scsi_devs, tailq, next_svdev) {
- virtio_scsi_dev_remove(svdev, NULL, NULL);
- }
-
-out_unlock:
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
- spdk_bdev_module_init_done(&virtio_scsi_if);
- return rc;
-}
-
-static void
-_virtio_scsi_dev_unregister_cb(void *io_device)
-{
- struct virtio_scsi_dev *svdev = io_device;
- struct virtio_dev *vdev = &svdev->vdev;
- bool finish_module;
- bdev_virtio_remove_cb remove_cb;
- void *remove_ctx;
-
- assert(spdk_ring_count(svdev->ctrlq_ring) == 0);
- spdk_ring_free(svdev->ctrlq_ring);
- spdk_poller_unregister(&svdev->mgmt_poller);
-
- virtio_dev_release_queue(vdev, VIRTIO_SCSI_EVENTQ);
- virtio_dev_release_queue(vdev, VIRTIO_SCSI_CONTROLQ);
-
- virtio_dev_stop(vdev);
- virtio_dev_destruct(vdev);
-
- pthread_mutex_lock(&g_virtio_scsi_mutex);
- TAILQ_REMOVE(&g_virtio_scsi_devs, svdev, tailq);
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
-
- remove_cb = svdev->remove_cb;
- remove_ctx = svdev->remove_ctx;
- spdk_free(svdev->eventq_ios);
- free(svdev);
-
- if (remove_cb) {
- remove_cb(remove_ctx, 0);
- }
-
- finish_module = TAILQ_EMPTY(&g_virtio_scsi_devs);
-
- if (g_bdev_virtio_finish && finish_module) {
- spdk_bdev_module_finish_done();
- }
-}
-
-static void
-virtio_scsi_dev_unregister_cb(void *io_device)
-{
- struct virtio_scsi_dev *svdev = io_device;
- struct spdk_thread *thread;
-
- thread = virtio_dev_queue_get_thread(&svdev->vdev, VIRTIO_SCSI_CONTROLQ);
- spdk_thread_send_msg(thread, _virtio_scsi_dev_unregister_cb, io_device);
-}
-
-static void
-virtio_scsi_dev_remove(struct virtio_scsi_dev *svdev,
- bdev_virtio_remove_cb cb_fn, void *cb_arg)
-{
- struct virtio_scsi_disk *disk, *disk_tmp;
- bool do_remove = true;
-
- if (svdev->removed) {
- if (cb_fn) {
- cb_fn(cb_arg, -EBUSY);
- }
- return;
- }
-
- svdev->remove_cb = cb_fn;
- svdev->remove_ctx = cb_arg;
- svdev->removed = true;
-
- if (svdev->scan_ctx) {
- /* The removal will continue after we receive a pending scan I/O. */
- return;
- }
-
- TAILQ_FOREACH_SAFE(disk, &svdev->luns, link, disk_tmp) {
- if (!disk->removed) {
- spdk_bdev_unregister(&disk->bdev, NULL, NULL);
- }
- do_remove = false;
- }
-
- if (do_remove) {
- spdk_io_device_unregister(svdev, virtio_scsi_dev_unregister_cb);
- }
-}
-
-static void
-bdev_virtio_finish(void)
-{
- struct virtio_scsi_dev *svdev, *next;
-
- g_bdev_virtio_finish = true;
-
- pthread_mutex_lock(&g_virtio_scsi_mutex);
- if (TAILQ_EMPTY(&g_virtio_scsi_devs)) {
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
- spdk_bdev_module_finish_done();
- return;
- }
-
- /* Defer module finish until all controllers are removed. */
- TAILQ_FOREACH_SAFE(svdev, &g_virtio_scsi_devs, tailq, next) {
- virtio_scsi_dev_remove(svdev, NULL, NULL);
- }
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
-}
-
-int
-bdev_virtio_user_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)
-{
- struct virtio_scsi_dev *svdev;
- int rc;
-
- svdev = virtio_user_scsi_dev_create(base_name, path, num_queues, queue_size);
- if (svdev == NULL) {
- return -1;
- }
-
- rc = virtio_scsi_dev_scan(svdev, cb_fn, cb_arg);
- if (rc) {
- virtio_scsi_dev_remove(svdev, NULL, NULL);
- }
-
- return rc;
-}
-
-struct bdev_virtio_pci_dev_create_ctx {
- const char *name;
- bdev_virtio_create_cb cb_fn;
- void *cb_arg;
-};
-
-static int
-bdev_virtio_pci_scsi_dev_create_cb(struct virtio_pci_ctx *pci_ctx, void *ctx)
-{
- struct virtio_scsi_dev *svdev;
- struct bdev_virtio_pci_dev_create_ctx *create_ctx = ctx;
- int rc;
-
- svdev = virtio_pci_scsi_dev_create(create_ctx->name, pci_ctx);
- if (svdev == NULL) {
- return -1;
- }
-
- rc = virtio_scsi_dev_scan(svdev, create_ctx->cb_fn, create_ctx->cb_arg);
- if (rc) {
- virtio_scsi_dev_remove(svdev, NULL, NULL);
- }
-
- return rc;
-}
-
-int
-bdev_virtio_pci_scsi_dev_create(const char *name, struct spdk_pci_addr *pci_addr,
- bdev_virtio_create_cb cb_fn, void *cb_arg)
-{
- struct bdev_virtio_pci_dev_create_ctx create_ctx;
-
- create_ctx.name = name;
- create_ctx.cb_fn = cb_fn;
- create_ctx.cb_arg = cb_arg;
-
- return virtio_pci_dev_attach(bdev_virtio_pci_scsi_dev_create_cb, &create_ctx,
- PCI_DEVICE_ID_VIRTIO_SCSI_MODERN, pci_addr);
-}
-
-int
-bdev_virtio_scsi_dev_remove(const char *name, bdev_virtio_remove_cb cb_fn, void *cb_arg)
-{
- struct virtio_scsi_dev *svdev;
-
- pthread_mutex_lock(&g_virtio_scsi_mutex);
- TAILQ_FOREACH(svdev, &g_virtio_scsi_devs, tailq) {
- if (strcmp(svdev->vdev.name, name) == 0) {
- break;
- }
- }
-
- if (svdev == NULL) {
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
- SPDK_ERRLOG("Cannot find Virtio-SCSI device named '%s'\n", name);
- return -ENODEV;
- }
-
- virtio_scsi_dev_remove(svdev, cb_fn, cb_arg);
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
-
- return 0;
-}
-
-void
-bdev_virtio_scsi_dev_list(struct spdk_json_write_ctx *w)
-{
- struct virtio_scsi_dev *svdev;
-
- spdk_json_write_array_begin(w);
-
- pthread_mutex_lock(&g_virtio_scsi_mutex);
- TAILQ_FOREACH(svdev, &g_virtio_scsi_devs, tailq) {
- spdk_json_write_object_begin(w);
-
- spdk_json_write_named_string(w, "name", svdev->vdev.name);
-
- virtio_dev_dump_json_info(&svdev->vdev, w);
-
- spdk_json_write_object_end(w);
- }
- pthread_mutex_unlock(&g_virtio_scsi_mutex);
-
- spdk_json_write_array_end(w);
-}
-
-SPDK_LOG_REGISTER_COMPONENT("virtio", SPDK_LOG_VIRTIO)
projects / ceph.git / blobdiff