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/config-file.h"

#include "qemu/error-report.h"

#include "block/block_int.h"

#include "trace.h"

#include "block/scsi.h"

#include "qemu/iov.h"

#include "sysemu/sysemu.h"

#include "qmp-commands.h"

#include <iscsi/iscsi.h>

#include <iscsi/scsi-lowlevel.h>

#ifdef __linux__

#include <scsi/sg.h>

#include <block/scsi.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;

    QEMUTimer *nop_timer;

    uint8_t lbpme;

    uint8_t lbprz;

    struct scsi_inquiry_logical_block_provisioning lbp;

    struct scsi_inquiry_block_limits bl;

} IscsiLun;

typedef struct IscsiTask {

    int status;

    int complete;

    int retries;

    int do_retry;

    struct scsi_task *task;

    Coroutine *co;

} IscsiTask;

typedef struct IscsiAIOCB {

    BlockDriverAIOCB common;

    QEMUIOVector *qiov;

    QEMUBH *bh;

    IscsiLun *iscsilun;

    struct scsi_task *task;

    uint8_t *buf;

    int status;

    int canceled;

    int retries;

    int64_t sector_num;

    int nb_sectors;

#ifdef __linux__

    sg_io_hdr_t *ioh;

#endif

} IscsiAIOCB;

#define NOP_INTERVAL 5000

#define MAX_NOP_FAILURES 3

#define ISCSI_CMD_RETRIES 5

#define ISCSI_MAX_UNMAP 131072

static void

iscsi_bh_cb(void *p)

{

    IscsiAIOCB *acb = p;

    qemu_bh_delete(acb->bh);

    g_free(acb->buf);

    acb->buf = NULL;

    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_co_generic_cb(struct iscsi_context *iscsi, int status,

                        void *command_data, void *opaque)

{

    struct IscsiTask *iTask = opaque;

    struct scsi_task *task = command_data;

    iTask->complete = 1;

    iTask->status = status;

    iTask->do_retry = 0;

    iTask->task = task;

    if (iTask->retries-- > 0 && status == SCSI_STATUS_CHECK_CONDITION

        && task->sense.key == SCSI_SENSE_UNIT_ATTENTION) {

        iTask->do_retry = 1;

        goto out;

    }

    if (status != SCSI_STATUS_GOOD) {

        error_report("iSCSI: Failure. %s", iscsi_get_error(iscsi));

    }

out:

    if (iTask->co) {

        qemu_coroutine_enter(iTask->co, NULL);

    }

}

static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask)

{

    *iTask = (struct IscsiTask) {

        .co         = qemu_coroutine_self(),

        .retries    = ISCSI_CMD_RETRIES,

    };

}

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 const AIOCBInfo iscsi_aiocb_info = {

    .aiocb_size         = sizeof(IscsiAIOCB),

    .cancel             = iscsi_aio_cancel,

};

static void iscsi_process_read(void *arg);

static void iscsi_process_write(void *arg);

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,

                      iscsilun);

    }

    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 int

iscsi_aio_writev_acb(IscsiAIOCB *acb);

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);

    acb->buf = NULL;

    if (acb->canceled != 0) {

        return;

    }

    acb->status = 0;

    if (status != 0) {

        if (status == SCSI_STATUS_CHECK_CONDITION

            && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION

            && acb->retries-- > 0) {

            scsi_free_scsi_task(acb->task);

            acb->task = NULL;

            if (iscsi_aio_writev_acb(acb) == 0) {

                iscsi_set_events(acb->iscsilun);

                return;

            }

        }

        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_lun2qemu(int64_t sector, IscsiLun *iscsilun)

{

    return sector * iscsilun->block_size / BDRV_SECTOR_SIZE;

}

static int64_t sector_qemu2lun(int64_t sector, IscsiLun *iscsilun)

{

    return sector * BDRV_SECTOR_SIZE / iscsilun->block_size;

}

static bool is_request_lun_aligned(int64_t sector_num, int nb_sectors,

                                      IscsiLun *iscsilun)

{

    if ((sector_num * BDRV_SECTOR_SIZE) % iscsilun->block_size ||

        (nb_sectors * BDRV_SECTOR_SIZE) % iscsilun->block_size) {

            error_report("iSCSI misaligned request: "

                         "iscsilun->block_size %u, sector_num %" PRIi64

                         ", nb_sectors %d",

                         iscsilun->block_size, sector_num, nb_sectors);

            return 0;

    }

    return 1;

}

static int

iscsi_aio_writev_acb(IscsiAIOCB *acb)

{

    struct iscsi_context *iscsi = acb->iscsilun->iscsi;

    size_t size;

    uint32_t num_sectors;

    uint64_t lba;

#if !defined(LIBISCSI_FEATURE_IOVECTOR)

    struct iscsi_data data;

#endif

    int ret;

    acb->canceled   = 0;

    acb->bh         = NULL;

    acb->status     = -EINPROGRESS;

    acb->buf        = NULL;

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

    size = acb->nb_sectors * BDRV_SECTOR_SIZE;

#if !defined(LIBISCSI_FEATURE_IOVECTOR)

    data.size = MIN(size, acb->qiov->size);

    /* if the iovec only contains one buffer we can pass it directly */

    if (acb->qiov->niov == 1) {

        data.data = acb->qiov->iov[0].iov_base;

    } else {

        acb->buf = g_malloc(data.size);

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

        data.data = acb->buf;

    }

#endif

    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));

        return -1;

    }

    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;

    lba = sector_qemu2lun(acb->sector_num, acb->iscsilun);

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

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

    num_sectors = sector_qemu2lun(acb->nb_sectors, acb->iscsilun);

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

    acb->task->expxferlen = size;

#if defined(LIBISCSI_FEATURE_IOVECTOR)

    ret = iscsi_scsi_command_async(iscsi, acb->iscsilun->lun, acb->task,

                                   iscsi_aio_write16_cb,

                                   NULL,

                                   acb);

#else

    ret = iscsi_scsi_command_async(iscsi, acb->iscsilun->lun, acb->task,

                                   iscsi_aio_write16_cb,

                                   &data,

                                   acb);

#endif

    if (ret != 0) {

        scsi_free_scsi_task(acb->task);

        g_free(acb->buf);

        return -1;

    }

#if defined(LIBISCSI_FEATURE_IOVECTOR)

    scsi_task_set_iov_out(acb->task, (struct scsi_iovec*) acb->qiov->iov, acb->qiov->niov);

#endif

    return 0;

}

static BlockDriverAIOCB *

iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num,

                 QEMUIOVector *qiov, int nb_sectors,

                 BlockDriverCompletionFunc *cb,

                 void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    IscsiAIOCB *acb;

    if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {

        return NULL;

    }

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

    trace_iscsi_aio_writev(iscsilun->iscsi, sector_num, nb_sectors, opaque, acb);

    acb->iscsilun    = iscsilun;

    acb->qiov        = qiov;

    acb->nb_sectors  = nb_sectors;

    acb->sector_num  = sector_num;

    acb->retries     = ISCSI_CMD_RETRIES;

    if (iscsi_aio_writev_acb(acb) != 0) {

        qemu_aio_release(acb);

        return NULL;

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

static int

iscsi_aio_readv_acb(IscsiAIOCB *acb);

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) {

        if (status == SCSI_STATUS_CHECK_CONDITION

            && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION

            && acb->retries-- > 0) {

            scsi_free_scsi_task(acb->task);

            acb->task = NULL;

            if (iscsi_aio_readv_acb(acb) == 0) {

                iscsi_set_events(acb->iscsilun);

                return;

            }

        }

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

                     iscsi_get_error(iscsi));

        acb->status = -EIO;

    }

    iscsi_schedule_bh(acb);

}

static int

iscsi_aio_readv_acb(IscsiAIOCB *acb)

{

    struct iscsi_context *iscsi = acb->iscsilun->iscsi;

    size_t size;

    uint64_t lba;

    uint32_t num_sectors;

    int ret;

#if !defined(LIBISCSI_FEATURE_IOVECTOR)

    int i;

#endif

    acb->canceled    = 0;

    acb->bh          = NULL;

    acb->status      = -EINPROGRESS;

    acb->buf         = NULL;

    size = acb->nb_sectors * BDRV_SECTOR_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));

        return -1;

    }

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

    acb->task->xfer_dir = SCSI_XFER_READ;

    acb->task->expxferlen = size;

    lba = sector_qemu2lun(acb->sector_num, acb->iscsilun);

    num_sectors = sector_qemu2lun(acb->nb_sectors, acb->iscsilun);

    switch (acb->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;

    }

    ret = iscsi_scsi_command_async(iscsi, acb->iscsilun->lun, acb->task,

                                   iscsi_aio_read16_cb,

                                   NULL,

                                   acb);

    if (ret != 0) {

        scsi_free_scsi_task(acb->task);

        return -1;

    }

#if defined(LIBISCSI_FEATURE_IOVECTOR)

    scsi_task_set_iov_in(acb->task, (struct scsi_iovec*) acb->qiov->iov, acb->qiov->niov);

#else

    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);

    }

#endif

    return 0;

}

static BlockDriverAIOCB *

iscsi_aio_readv(BlockDriverState *bs, int64_t sector_num,

                QEMUIOVector *qiov, int nb_sectors,

                BlockDriverCompletionFunc *cb,

                void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    IscsiAIOCB *acb;

    if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {

        return NULL;

    }

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

    trace_iscsi_aio_readv(iscsilun->iscsi, sector_num, nb_sectors, opaque, acb);

    acb->nb_sectors  = nb_sectors;

    acb->sector_num  = sector_num;

    acb->iscsilun    = iscsilun;

    acb->qiov        = qiov;

    acb->retries     = ISCSI_CMD_RETRIES;

    if (iscsi_aio_readv_acb(acb) != 0) {

        qemu_aio_release(acb);

        return NULL;

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

static int

iscsi_aio_flush_acb(IscsiAIOCB *acb);

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) {

        if (status == SCSI_STATUS_CHECK_CONDITION

            && acb->task->sense.key == SCSI_SENSE_UNIT_ATTENTION

            && acb->retries-- > 0) {

            scsi_free_scsi_task(acb->task);

            acb->task = NULL;

            if (iscsi_aio_flush_acb(acb) == 0) {

                iscsi_set_events(acb->iscsilun);

                return;

            }

        }

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

                     iscsi_get_error(iscsi));

        acb->status = -EIO;

    }

    iscsi_schedule_bh(acb);

}

static int

iscsi_aio_flush_acb(IscsiAIOCB *acb)

{

    struct iscsi_context *iscsi = acb->iscsilun->iscsi;

    acb->canceled   = 0;

    acb->bh         = NULL;

    acb->status     = -EINPROGRESS;

    acb->buf        = NULL;

    acb->task = iscsi_synchronizecache10_task(iscsi, acb->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));

        return -1;

    }

    return 0;

}

static BlockDriverAIOCB *

iscsi_aio_flush(BlockDriverState *bs,

                BlockDriverCompletionFunc *cb, void *opaque)

{

    IscsiLun *iscsilun = bs->opaque;

    IscsiAIOCB *acb;

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

    acb->iscsilun    = iscsilun;

    acb->retries     = ISCSI_CMD_RETRIES;

    if (iscsi_aio_flush_acb(acb) != 0) {

        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;

    g_free(acb->buf);

    acb->buf = NULL;

    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_aiocb_info, 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;

    data.size = 0;

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

        if (acb->ioh->iovec_count == 0) {

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

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

        } else {

#if defined(LIBISCSI_FEATURE_IOVECTOR)

            scsi_task_set_iov_out(acb->task,

                                 (struct scsi_iovec *) acb->ioh->dxferp,

                                 acb->ioh->iovec_count);

#else

            struct iovec *iov = (struct iovec *)acb->ioh->dxferp;

            acb->buf = g_malloc(acb->ioh->dxfer_len);

            data.data = acb->buf;

            data.size = iov_to_buf(iov, acb->ioh->iovec_count, 0,

                                   acb->buf, acb->ioh->dxfer_len);

#endif

        }

    }

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

                                 iscsi_aio_ioctl_cb,

                                 (data.size > 0) ? &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) {

        if (acb->ioh->iovec_count == 0) {

            scsi_task_add_data_in_buffer(acb->task,

                                         acb->ioh->dxfer_len,

                                         acb->ioh->dxferp);

        } else {

#if defined(LIBISCSI_FEATURE_IOVECTOR)

            scsi_task_set_iov_in(acb->task,

                                 (struct scsi_iovec *) acb->ioh->dxferp,

                                 acb->ioh->iovec_count);

#else

            int i;

            for (i = 0; i < acb->ioh->iovec_count; i++) {

                struct iovec *iov = (struct iovec *)acb->ioh->dxferp;

                scsi_task_add_data_in_buffer(acb->task,

                    iov[i].iov_len,

                    iov[i].iov_base);

            }

#endif

        }

    }

    iscsi_set_events(iscsilun);

    return &acb->common;

}

static void ioctl_cb(void *opaque, int status)

{

    int *p_status = opaque;

    *p_status = status;

}

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

{

    IscsiLun *iscsilun = bs->opaque;

    int status;

    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;

    case SG_IO:

        status = -EINPROGRESS;

        iscsi_aio_ioctl(bs, req, buf, ioctl_cb, &status);

        while (status == -EINPROGRESS) {

            qemu_aio_wait();

        }

        return 0;

    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 int64_t coroutine_fn iscsi_co_get_block_status(BlockDriverState *bs,

                                                  int64_t sector_num,

                                                  int nb_sectors, int *pnum)

{

    IscsiLun *iscsilun = bs->opaque;

    struct scsi_get_lba_status *lbas = NULL;

    struct scsi_lba_status_descriptor *lbasd = NULL;

    struct IscsiTask iTask;

    int64_t ret;

    iscsi_co_init_iscsitask(iscsilun, &iTask);

    if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {

        ret = -EINVAL;

        goto out;

    }

    /* default to all sectors allocated */

    ret = BDRV_BLOCK_DATA;

    ret |= (sector_num << BDRV_SECTOR_BITS) | BDRV_BLOCK_OFFSET_VALID;

    *pnum = nb_sectors;

    /* LUN does not support logical block provisioning */

    if (iscsilun->lbpme == 0) {

        goto out;

    }

retry:

    if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun,

                                  sector_qemu2lun(sector_num, iscsilun),

                                  8 + 16, iscsi_co_generic_cb,

                                  &iTask) == NULL) {

        ret = -EIO;

        goto out;

    }

    while (!iTask.complete) {

        iscsi_set_events(iscsilun);

        qemu_coroutine_yield();

    }

    if (iTask.do_retry) {

        if (iTask.task != NULL) {

            scsi_free_scsi_task(iTask.task);

            iTask.task = NULL;

        }

        goto retry;

    }

    if (iTask.status != SCSI_STATUS_GOOD) {

        /* in case the get_lba_status_callout fails (i.e.

         * because the device is busy or the cmd is not

         * supported) we pretend all blocks are allocated

         * for backwards compatiblity */

        goto out;

    }

    lbas = scsi_datain_unmarshall(iTask.task);

    if (lbas == NULL) {

        ret = -EIO;

        goto out;

    }

    lbasd = &lbas->descriptors[0];

    if (sector_qemu2lun(sector_num, iscsilun) != lbasd->lba) {

        ret = -EIO;

        goto out;

    }

    *pnum = sector_lun2qemu(lbasd->num_blocks, iscsilun);

    if (*pnum > nb_sectors) {

        *pnum = nb_sectors;

    }

    if (lbasd->provisioning == SCSI_PROVISIONING_TYPE_DEALLOCATED ||

        lbasd->provisioning == SCSI_PROVISIONING_TYPE_ANCHORED) {

        ret &= ~BDRV_BLOCK_DATA;

        if (iscsilun->lbprz) {

            ret |= BDRV_BLOCK_ZERO;

        }

    }

out:

    if (iTask.task != NULL) {

        scsi_free_scsi_task(iTask.task);

    }

    return ret;

}

static int

coroutine_fn iscsi_co_discard(BlockDriverState *bs, int64_t sector_num,

                                   int nb_sectors)

{

    IscsiLun *iscsilun = bs->opaque;

    struct IscsiTask iTask;

    struct unmap_list list;

    uint32_t nb_blocks;

    uint32_t max_unmap;

    if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {

        return -EINVAL;