Archipelago » qemu

/*

 * QEMU Block driver for iSCSI images

 *

 * Copyright (c) 2010-2011 Ronnie Sahlberg <ronniesahlberg@gmail.com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "config-host.h"

#include <poll.h>

#include <arpa/inet.h>

#include "qemu-common.h"

#include "qemu-error.h"

#include "block_int.h"

#include "trace.h"

#include "hw/scsi-defs.h"

#include <iscsi/iscsi.h>

#include <iscsi/scsi-lowlevel.h>

#ifdef __linux__

#include <scsi/sg.h>

#include <hw/scsi-defs.h>

#endif

typedef struct IscsiLun {

    struct iscsi_context *iscsi;

    int lun;

    enum scsi_inquiry_peripheral_device_type type;

    int block_size;

    uint64_t num_blocks;

    int events;

} IscsiLun;

typedef struct IscsiAIOCB {

    BlockDriverAIOCB common;

    QEMUIOVector *qiov;

    QEMUBH *bh;

    IscsiLun *iscsilun;

    struct scsi_task *task;

    uint8_t *buf;

    int status;

    int canceled;

    size_t read_size;

    size_t read_offset;

#ifdef __linux__

    sg_io_hdr_t *ioh;

#endif

} IscsiAIOCB;

struct IscsiTask {

    IscsiLun *iscsilun;

    BlockDriverState *bs;

    int status;

    int complete;

};

static void

iscsi_bh_cb(void *p)

{

    IscsiAIOCB *acb = p;

    qemu_bh_delete(acb->bh);

    if (acb->canceled == 0) {

        acb->common.cb(acb->common.opaque, acb->status);

    }

    if (acb->task != NULL) {

        scsi_free_scsi_task(acb->task);

        acb->task = NULL;

    }

    qemu_aio_release(acb);

}

static void

iscsi_schedule_bh(IscsiAIOCB *acb)

{

    if (acb->bh) {

        return;

    }

    acb->bh = qemu_bh_new(iscsi_bh_cb, acb);

    qemu_bh_schedule(acb->bh);

}

static void

iscsi_abort_task_cb(struct iscsi_context *iscsi, int status, void *command_data,

                    void *private_data)

{

    IscsiAIOCB *acb = private_data;

    acb->status = -ECANCELED;

    iscsi_schedule_bh(acb);

}

static void

iscsi_aio_cancel(BlockDriverAIOCB *blockacb)

{

    IscsiAIOCB *acb = (IscsiAIOCB *)blockacb;

    IscsiLun *iscsilun = acb->iscsilun;

    if (acb->status != -EINPROGRESS) {

        return;

    }

    acb->canceled = 1;

    /* send a task mgmt call to the target to cancel the task on the target */

    iscsi_task_mgmt_abort_task_async(iscsilun->iscsi, acb->task,

                                     iscsi_abort_task_cb, acb);

    while (acb->status == -EINPROGRESS) {

        qemu_aio_wait();

    }

}

static AIOPool iscsi_aio_pool = {

    .aiocb_size         = sizeof(IscsiAIOCB),

    .cancel             = iscsi_aio_cancel,

};

static void iscsi_process_read(void *arg);

static void iscsi_process_write(void *arg);

static int iscsi_process_flush(void *arg)

{

    IscsiLun *iscsilun = arg;

    return iscsi_queue_length(iscsilun->iscsi) > 0;

}

static void

iscsi_set_events(IscsiLun *iscsilun)

{

    struct iscsi_context *iscsi = iscsilun->iscsi;

    int ev;

    /* We always register a read handler.  */

    ev = POLLIN;

    ev |= iscsi_which_events(iscsi);

    if (ev != iscsilun->events) {

        qemu_aio_set_fd_handler(iscsi_get_fd(iscsi),

                      iscsi_process_read,

                      (ev & POLLOUT) ? iscsi_process_write : NULL,

                      iscsi_process_flush,

                      iscsilun);

    }

    /* If we just added an event, the callback might be delayed

     * unless we call qemu_notify_event().

     */

    if (ev & ~iscsilun->events) {

        qemu_notify_event();

    }

    iscsilun->events = ev;

}

static void

iscsi_process_read(void *arg)

{

    IscsiLun *iscsilun = arg;

    struct iscsi_context *iscsi = iscsilun->iscsi;

    iscsi_service(iscsi, POLLIN);

    iscsi_set_events(iscsilun);

}

static void

iscsi_process_write(void *arg)

{

    IscsiLun *iscsilun = arg;

    struct iscsi_context *iscsi = iscsilun->iscsi;

    iscsi_service(iscsi, POLLOUT);

    iscsi_set_events(iscsilun);

}

static void

iscsi_aio_write16_cb(struct iscsi_context *iscsi, int status,

                     void *command_data, void *opaque)

{

    IscsiAIOCB *acb = opaque;

    trace_iscsi_aio_write16_cb(iscsi, status, acb, acb->canceled);

    g_free(acb->buf);

    if (acb->canceled != 0) {

        return;

    }

    acb->status = 0;

    if (status < 0) {

        error_report("Failed to write16 data to iSCSI lun. %s",

                     iscsi_get_error(iscsi));

        acb->status = -EIO;

    }

    iscsi_schedule_bh(acb);

}

static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)

{

    return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;

}

static BlockDriverAIOCB *

iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num,

                 QEMUIOVector *qiov, int nb_sectors,

                 BlockDriverCompletionFunc *cb,

                 void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    struct iscsi_context *iscsi = iscsilun->iscsi;

    IscsiAIOCB *acb;

    size_t size;

    uint32_t num_sectors;

    uint64_t lba;

    struct iscsi_data data;

    acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);

    trace_iscsi_aio_writev(iscsi, sector_num, nb_sectors, opaque, acb);

    acb->iscsilun = iscsilun;

    acb->qiov     = qiov;

    acb->canceled   = 0;

    acb->bh         = NULL;

    acb->status     = -EINPROGRESS;

    /* XXX we should pass the iovec to write16 to avoid the extra copy */

    /* this will allow us to get rid of 'buf' completely */

    size = nb_sectors * BDRV_SECTOR_SIZE;

    acb->buf = g_malloc(size);

    qemu_iovec_to_buf(acb->qiov, 0, acb->buf, size);

    acb->task = malloc(sizeof(struct scsi_task));

    if (acb->task == NULL) {

        error_report("iSCSI: Failed to allocate task for scsi WRITE16 "

                     "command. %s", iscsi_get_error(iscsi));

        qemu_aio_release(acb);

        return NULL;

    }

    memset(acb->task, 0, sizeof(struct scsi_task));

    acb->task->xfer_dir = SCSI_XFER_WRITE;

    acb->task->cdb_size = 16;

    acb->task->cdb[0] = 0x8a;

    if (!(bs->open_flags & BDRV_O_CACHE_WB)) {

        /* set FUA on writes when cache mode is write through */

        acb->task->cdb[1] |= 0x04;

    }

    lba = sector_qemu2lun(sector_num, iscsilun);

    *(uint32_t *)&acb->task->cdb[2]  = htonl(lba >> 32);

    *(uint32_t *)&acb->task->cdb[6]  = htonl(lba & 0xffffffff);

    num_sectors = size / iscsilun->block_size;

    *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors);

    acb->task->expxferlen = size;

    data.data = acb->buf;

    data.size = size;

    if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,

                                 iscsi_aio_write16_cb,

                                 &data,

                                 acb) != 0) {

        scsi_free_scsi_task(acb->task);

        g_free(acb->buf);

        qemu_aio_release(acb);

        return NULL;

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

static void

iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status,

                    void *command_data, void *opaque)

{

    IscsiAIOCB *acb = opaque;

    trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled);

    if (acb->canceled != 0) {

        return;

    }

    acb->status = 0;

    if (status != 0) {

        error_report("Failed to read16 data from iSCSI lun. %s",

                     iscsi_get_error(iscsi));

        acb->status = -EIO;

    }

    iscsi_schedule_bh(acb);

}

static BlockDriverAIOCB *

iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num,

                QEMUIOVector *qiov, int nb_sectors,

                BlockDriverCompletionFunc *cb,

                void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    struct iscsi_context *iscsi = iscsilun->iscsi;

    IscsiAIOCB *acb;

    size_t qemu_read_size;

    int i;

    uint64_t lba;

    uint32_t num_sectors;

    qemu_read_size = BDRV_SECTOR_SIZE * (size_t)nb_sectors;

    acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);

    trace_iscsi_aio_readv(iscsi, sector_num, nb_sectors, opaque, acb);

    acb->iscsilun = iscsilun;

    acb->qiov     = qiov;

    acb->canceled    = 0;

    acb->bh          = NULL;

    acb->status      = -EINPROGRESS;

    acb->read_size   = qemu_read_size;

    acb->buf         = NULL;

    /* If LUN blocksize is bigger than BDRV_BLOCK_SIZE a read from QEMU

     * may be misaligned to the LUN, so we may need to read some extra

     * data.

     */

    acb->read_offset = 0;

    if (iscsilun->block_size > BDRV_SECTOR_SIZE) {

        uint64_t bdrv_offset = BDRV_SECTOR_SIZE * sector_num;

        acb->read_offset  = bdrv_offset % iscsilun->block_size;

    }

    num_sectors  = (qemu_read_size + iscsilun->block_size

                    + acb->read_offset - 1)

                    / iscsilun->block_size;

    acb->task = malloc(sizeof(struct scsi_task));

    if (acb->task == NULL) {

        error_report("iSCSI: Failed to allocate task for scsi READ16 "

                     "command. %s", iscsi_get_error(iscsi));

        qemu_aio_release(acb);

        return NULL;

    }

    memset(acb->task, 0, sizeof(struct scsi_task));

    acb->task->xfer_dir = SCSI_XFER_READ;

    lba = sector_qemu2lun(sector_num, iscsilun);

    acb->task->expxferlen = qemu_read_size;

    switch (iscsilun->type) {

    case TYPE_DISK:

        acb->task->cdb_size = 16;

        acb->task->cdb[0]  = 0x88;

        *(uint32_t *)&acb->task->cdb[2]  = htonl(lba >> 32);

        *(uint32_t *)&acb->task->cdb[6]  = htonl(lba & 0xffffffff);

        *(uint32_t *)&acb->task->cdb[10] = htonl(num_sectors);

        break;

    default:

        acb->task->cdb_size = 10;

        acb->task->cdb[0]  = 0x28;

        *(uint32_t *)&acb->task->cdb[2] = htonl(lba);

        *(uint16_t *)&acb->task->cdb[7] = htons(num_sectors);

        break;

    }

    if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,

                                 iscsi_aio_read16_cb,

                                 NULL,

                                 acb) != 0) {

        scsi_free_scsi_task(acb->task);

        qemu_aio_release(acb);

        return NULL;

    }

    for (i = 0; i < acb->qiov->niov; i++) {

        scsi_task_add_data_in_buffer(acb->task,

                acb->qiov->iov[i].iov_len,

                acb->qiov->iov[i].iov_base);

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

static void

iscsi_synccache10_cb(struct iscsi_context *iscsi, int status,

                     void *command_data, void *opaque)

{

    IscsiAIOCB *acb = opaque;

    if (acb->canceled != 0) {

        return;

    }

    acb->status = 0;

    if (status < 0) {

        error_report("Failed to sync10 data on iSCSI lun. %s",

                     iscsi_get_error(iscsi));

        acb->status = -EIO;

    }

    iscsi_schedule_bh(acb);

}

static BlockDriverAIOCB *

iscsi_aio_flush(BlockDriverState *bs,

                BlockDriverCompletionFunc *cb, void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    struct iscsi_context *iscsi = iscsilun->iscsi;

    IscsiAIOCB *acb;

    acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);

    acb->iscsilun = iscsilun;

    acb->canceled   = 0;

    acb->bh         = NULL;

    acb->status     = -EINPROGRESS;

    acb->task = iscsi_synchronizecache10_task(iscsi, iscsilun->lun,

                                         0, 0, 0, 0,

                                         iscsi_synccache10_cb,

                                         acb);

    if (acb->task == NULL) {

        error_report("iSCSI: Failed to send synchronizecache10 command. %s",

                     iscsi_get_error(iscsi));

        qemu_aio_release(acb);

        return NULL;

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

static void

iscsi_unmap_cb(struct iscsi_context *iscsi, int status,

                     void *command_data, void *opaque)

{

    IscsiAIOCB *acb = opaque;

    if (acb->canceled != 0) {

        return;

    }

    acb->status = 0;

    if (status < 0) {

        error_report("Failed to unmap data on iSCSI lun. %s",

                     iscsi_get_error(iscsi));

        acb->status = -EIO;

    }

    iscsi_schedule_bh(acb);

}

static BlockDriverAIOCB *

iscsi_aio_discard(BlockDriverState *bs,

                  int64_t sector_num, int nb_sectors,

                  BlockDriverCompletionFunc *cb, void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    struct iscsi_context *iscsi = iscsilun->iscsi;

    IscsiAIOCB *acb;

    struct unmap_list list[1];

    acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);

    acb->iscsilun = iscsilun;

    acb->canceled   = 0;

    acb->bh         = NULL;

    acb->status     = -EINPROGRESS;

    list[0].lba = sector_qemu2lun(sector_num, iscsilun);

    list[0].num = nb_sectors * BDRV_SECTOR_SIZE / iscsilun->block_size;

    acb->task = iscsi_unmap_task(iscsi, iscsilun->lun,

                                 0, 0, &list[0], 1,

                                 iscsi_unmap_cb,

                                 acb);

    if (acb->task == NULL) {

        error_report("iSCSI: Failed to send unmap command. %s",

                     iscsi_get_error(iscsi));

        qemu_aio_release(acb);

        return NULL;

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

#ifdef __linux__

static void

iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,

                     void *command_data, void *opaque)

{

    IscsiAIOCB *acb = opaque;

    if (acb->canceled != 0) {

        return;

    }

    acb->status = 0;

    if (status < 0) {

        error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",

                     iscsi_get_error(iscsi));

        acb->status = -EIO;

    }

    acb->ioh->driver_status = 0;

    acb->ioh->host_status   = 0;

    acb->ioh->resid         = 0;

#define SG_ERR_DRIVER_SENSE    0x08

    if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) {

        int ss;

        acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE;

        acb->ioh->sb_len_wr = acb->task->datain.size - 2;

        ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ?

             acb->ioh->mx_sb_len : acb->ioh->sb_len_wr;

        memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss);

    }

    iscsi_schedule_bh(acb);

}

static BlockDriverAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,

        unsigned long int req, void *buf,

        BlockDriverCompletionFunc *cb, void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    struct iscsi_context *iscsi = iscsilun->iscsi;

    struct iscsi_data data;

    IscsiAIOCB *acb;

    assert(req == SG_IO);

    acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);

    acb->iscsilun = iscsilun;

    acb->canceled    = 0;

    acb->bh          = NULL;

    acb->status      = -EINPROGRESS;

    acb->buf         = NULL;

    acb->ioh         = buf;

    acb->task = malloc(sizeof(struct scsi_task));

    if (acb->task == NULL) {

        error_report("iSCSI: Failed to allocate task for scsi command. %s",

                     iscsi_get_error(iscsi));

        qemu_aio_release(acb);

        return NULL;

    }

    memset(acb->task, 0, sizeof(struct scsi_task));

    switch (acb->ioh->dxfer_direction) {

    case SG_DXFER_TO_DEV:

        acb->task->xfer_dir = SCSI_XFER_WRITE;

        break;

    case SG_DXFER_FROM_DEV:

        acb->task->xfer_dir = SCSI_XFER_READ;

        break;

    default:

        acb->task->xfer_dir = SCSI_XFER_NONE;

        break;

    }

    acb->task->cdb_size = acb->ioh->cmd_len;

    memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len);

    acb->task->expxferlen = acb->ioh->dxfer_len;

    if (acb->task->xfer_dir == SCSI_XFER_WRITE) {

        data.data = acb->ioh->dxferp;

        data.size = acb->ioh->dxfer_len;

    }

    if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,

                                 iscsi_aio_ioctl_cb,

                                 (acb->task->xfer_dir == SCSI_XFER_WRITE) ?

                                     &data : NULL,

                                 acb) != 0) {

        scsi_free_scsi_task(acb->task);

        qemu_aio_release(acb);

        return NULL;

    }

    /* tell libiscsi to read straight into the buffer we got from ioctl */

    if (acb->task->xfer_dir == SCSI_XFER_READ) {

        scsi_task_add_data_in_buffer(acb->task,

                                     acb->ioh->dxfer_len,

                                     acb->ioh->dxferp);

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

static int iscsi_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)

{

    IscsiLun *iscsilun = bs->opaque;

    switch (req) {

    case SG_GET_VERSION_NUM:

        *(int *)buf = 30000;

        break;

    case SG_GET_SCSI_ID:

        ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type;

        break;

    default:

        return -1;

    }

    return 0;

}

#endif

static int64_t

iscsi_getlength(BlockDriverState *bs)

{

    IscsiLun *iscsilun = bs->opaque;

    int64_t len;

    len  = iscsilun->num_blocks;

    len *= iscsilun->block_size;

    return len;

}

static void

iscsi_readcapacity16_cb(struct iscsi_context *iscsi, int status,

                        void *command_data, void *opaque)

{

    struct IscsiTask *itask = opaque;

    struct scsi_readcapacity16 *rc16;

    struct scsi_task *task = command_data;

    if (status != 0) {

        error_report("iSCSI: Failed to read capacity of iSCSI lun. %s",

                     iscsi_get_error(iscsi));

        itask->status   = 1;

        itask->complete = 1;

        scsi_free_scsi_task(task);

        return;

    }

    rc16 = scsi_datain_unmarshall(task);

    if (rc16 == NULL) {

        error_report("iSCSI: Failed to unmarshall readcapacity16 data.");

        itask->status   = 1;

        itask->complete = 1;

        scsi_free_scsi_task(task);

        return;

    }

    itask->iscsilun->block_size = rc16->block_length;

    itask->iscsilun->num_blocks = rc16->returned_lba + 1;

    itask->bs->total_sectors    = itask->iscsilun->num_blocks *

                               itask->iscsilun->block_size / BDRV_SECTOR_SIZE ;

    itask->status   = 0;

    itask->complete = 1;

    scsi_free_scsi_task(task);

}

static void

iscsi_readcapacity10_cb(struct iscsi_context *iscsi, int status,

                        void *command_data, void *opaque)

{

    struct IscsiTask *itask = opaque;

    struct scsi_readcapacity10 *rc10;

    struct scsi_task *task = command_data;

    if (status != 0) {

        error_report("iSCSI: Failed to read capacity of iSCSI lun. %s",

                     iscsi_get_error(iscsi));

        itask->status   = 1;

        itask->complete = 1;

        scsi_free_scsi_task(task);

        return;

    }

    rc10 = scsi_datain_unmarshall(task);

    if (rc10 == NULL) {

        error_report("iSCSI: Failed to unmarshall readcapacity10 data.");

        itask->status   = 1;

        itask->complete = 1;

        scsi_free_scsi_task(task);

        return;

    }

    itask->iscsilun->block_size = rc10->block_size;

    if (rc10->lba == 0) {

        /* blank disk loaded */

        itask->iscsilun->num_blocks = 0;

    } else {

        itask->iscsilun->num_blocks = rc10->lba + 1;

    }

    itask->bs->total_sectors    = itask->iscsilun->num_blocks *

                               itask->iscsilun->block_size / BDRV_SECTOR_SIZE ;

    itask->status   = 0;

    itask->complete = 1;

    scsi_free_scsi_task(task);

}

static void

iscsi_inquiry_cb(struct iscsi_context *iscsi, int status, void *command_data,

                 void *opaque)

{

    struct IscsiTask *itask = opaque;

    struct scsi_task *task = command_data;

    struct scsi_inquiry_standard *inq;

    if (status != 0) {

        itask->status   = 1;

        itask->complete = 1;

        scsi_free_scsi_task(task);

        return;

    }

    inq = scsi_datain_unmarshall(task);

    if (inq == NULL) {

        error_report("iSCSI: Failed to unmarshall inquiry data.");

        itask->status   = 1;

        itask->complete = 1;

        scsi_free_scsi_task(task);

        return;

    }

    itask->iscsilun->type = inq->periperal_device_type;

    scsi_free_scsi_task(task);

    switch (itask->iscsilun->type) {

    case TYPE_DISK:

        task = iscsi_readcapacity16_task(iscsi, itask->iscsilun->lun,

                                   iscsi_readcapacity16_cb, opaque);

        if (task == NULL) {

            error_report("iSCSI: failed to send readcapacity16 command.");

            itask->status   = 1;

            itask->complete = 1;

            return;

        }

        break;

    case TYPE_ROM:

        task = iscsi_readcapacity10_task(iscsi, itask->iscsilun->lun,

                                   0, 0,

                                   iscsi_readcapacity10_cb, opaque);

        if (task == NULL) {

            error_report("iSCSI: failed to send readcapacity16 command.");

            itask->status   = 1;

            itask->complete = 1;

            return;

        }

        break;

    default:

        itask->status   = 0;

        itask->complete = 1;

    }

}

static void

iscsi_connect_cb(struct iscsi_context *iscsi, int status, void *command_data,

                 void *opaque)

{

    struct IscsiTask *itask = opaque;

    struct scsi_task *task;

    if (status != 0) {

        itask->status   = 1;

        itask->complete = 1;

        return;

    }

    task = iscsi_inquiry_task(iscsi, itask->iscsilun->lun,

                              0, 0, 36,

                              iscsi_inquiry_cb, opaque);

    if (task == NULL) {

        error_report("iSCSI: failed to send inquiry command.");

        itask->status   = 1;

        itask->complete = 1;

        return;

    }

}

static int parse_chap(struct iscsi_context *iscsi, const char *target)

{

    QemuOptsList *list;

    QemuOpts *opts;

    const char *user = NULL;

    const char *password = NULL;

    list = qemu_find_opts("iscsi");

    if (!list) {

        return 0;

    }

    opts = qemu_opts_find(list, target);

    if (opts == NULL) {

        opts = QTAILQ_FIRST(&list->head);

        if (!opts) {

            return 0;

        }

    }

    user = qemu_opt_get(opts, "user");

    if (!user) {

        return 0;

    }

    password = qemu_opt_get(opts, "password");

    if (!password) {

        error_report("CHAP username specified but no password was given");

        return -1;

    }

    if (iscsi_set_initiator_username_pwd(iscsi, user, password)) {

        error_report("Failed to set initiator username and password");

        return -1;

    }

    return 0;

}

static void parse_header_digest(struct iscsi_context *iscsi, const char *target)

{

    QemuOptsList *list;

    QemuOpts *opts;

    const char *digest = NULL;

    list = qemu_find_opts("iscsi");

    if (!list) {

        return;

    }

    opts = qemu_opts_find(list, target);

    if (opts == NULL) {

        opts = QTAILQ_FIRST(&list->head);

        if (!opts) {

            return;

        }

    }

    digest = qemu_opt_get(opts, "header-digest");

    if (!digest) {

        return;

    }

    if (!strcmp(digest, "CRC32C")) {

        iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);

    } else if (!strcmp(digest, "NONE")) {

        iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);

    } else if (!strcmp(digest, "CRC32C-NONE")) {

        iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);

    } else if (!strcmp(digest, "NONE-CRC32C")) {

        iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);

    } else {

        error_report("Invalid header-digest setting : %s", digest);

    }

}

static char *parse_initiator_name(const char *target)

{

    QemuOptsList *list;

    QemuOpts *opts;

    const char *name = NULL;

    const char *iscsi_name = qemu_get_vm_name();

    list = qemu_find_opts("iscsi");

    if (list) {

        opts = qemu_opts_find(list, target);

        if (!opts) {

            opts = QTAILQ_FIRST(&list->head);

        }