Archipelago » qemu

/*

 * QEMU Block driver for iSCSI images

 *

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

 * Copyright (c) 2012-2013 Peter Lieven <pl@kamp.de>

 *

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

    uint8_t has_write_same;

    struct scsi_inquiry_logical_block_provisioning lbp;

    struct scsi_inquiry_block_limits bl;

    unsigned char *zeroblock;

} IscsiLun;

typedef struct IscsiTask {

    int status;

    int complete;

    int retries;

    int do_retry;

    struct scsi_task *task;

    Coroutine *co;

    QEMUBH *bh;

} 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

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_bh_cb(void *opaque)

{

    struct IscsiTask *iTask = opaque;

    qemu_bh_delete(iTask->bh);

    qemu_coroutine_enter(iTask->co, NULL);

}

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

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

        iTask->do_retry = 1;

        goto out;

    }

    if (status != SCSI_STATUS_GOOD) {

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

    }

out:

    if (iTask->co) {

        iTask->bh = qemu_bh_new(iscsi_co_generic_bh_cb, iTask);

        qemu_bh_schedule(iTask->bh);

    }

}

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

                                        int64_t sector_num, int nb_sectors,

                                        QEMUIOVector *iov)

{

    IscsiLun *iscsilun = bs->opaque;

    struct IscsiTask iTask;

    uint64_t lba;

    uint32_t num_sectors;

    uint8_t *data = NULL;

    uint8_t *buf = NULL;

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

        return -EINVAL;

    }

    lba = sector_qemu2lun(sector_num, iscsilun);

    num_sectors = sector_qemu2lun(nb_sectors, iscsilun);

#if !defined(LIBISCSI_FEATURE_IOVECTOR)

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

    if (iov->niov == 1) {

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

    } else {

        size_t size = MIN(nb_sectors * BDRV_SECTOR_SIZE, iov->size);

        buf = g_malloc(size);

        qemu_iovec_to_buf(iov, 0, buf, size);

        data = buf;

    }

#endif

    iscsi_co_init_iscsitask(iscsilun, &iTask);

retry:

    iTask.task = iscsi_write16_task(iscsilun->iscsi, iscsilun->lun, lba,

                                    data, num_sectors * iscsilun->block_size,

                                    iscsilun->block_size, 0, 0, 0, 0, 0,

                                    iscsi_co_generic_cb, &iTask);

    if (iTask.task == NULL) {

        g_free(buf);

        return -ENOMEM;

    }

#if defined(LIBISCSI_FEATURE_IOVECTOR)

    scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov,

                          iov->niov);

#endif

    while (!iTask.complete) {

        iscsi_set_events(iscsilun);

        qemu_coroutine_yield();

    }

    if (iTask.task != NULL) {

        scsi_free_scsi_task(iTask.task);

        iTask.task = NULL;

    }

    if (iTask.do_retry) {

        iTask.complete = 0;

        goto retry;

    }

    g_free(buf);

    if (iTask.status != SCSI_STATUS_GOOD) {

        return -EIO;

    }

    return 0;

}

static int coroutine_fn iscsi_co_readv(BlockDriverState *bs,

                                       int64_t sector_num, int nb_sectors,

                                       QEMUIOVector *iov)

{

    IscsiLun *iscsilun = bs->opaque;

    struct IscsiTask iTask;

    uint64_t lba;

    uint32_t num_sectors;

#if !defined(LIBISCSI_FEATURE_IOVECTOR)

    int i;

#endif

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

        return -EINVAL;

    }

    lba = sector_qemu2lun(sector_num, iscsilun);

    num_sectors = sector_qemu2lun(nb_sectors, iscsilun);

    iscsi_co_init_iscsitask(iscsilun, &iTask);

retry:

    switch (iscsilun->type) {

    case TYPE_DISK:

        iTask.task = iscsi_read16_task(iscsilun->iscsi, iscsilun->lun, lba,

                                       num_sectors * iscsilun->block_size,

                                       iscsilun->block_size, 0, 0, 0, 0, 0,

                                       iscsi_co_generic_cb, &iTask);

        break;

    default:

        iTask.task = iscsi_read10_task(iscsilun->iscsi, iscsilun->lun, lba,

                                       num_sectors * iscsilun->block_size,

                                       iscsilun->block_size,

#if !defined(CONFIG_LIBISCSI_1_4) /* API change from 1.4.0 to 1.5.0 */

                                       0, 0, 0, 0, 0,

#endif

                                       iscsi_co_generic_cb, &iTask);

        break;

    }

    if (iTask.task == NULL) {

        return -ENOMEM;

    }

#if defined(LIBISCSI_FEATURE_IOVECTOR)

    scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov);

#else

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

        scsi_task_add_data_in_buffer(iTask.task,

                                     iov->iov[i].iov_len,

                                     iov->iov[i].iov_base);

    }

#endif

    while (!iTask.complete) {

        iscsi_set_events(iscsilun);

        qemu_coroutine_yield();

    }

    if (iTask.task != NULL) {

        scsi_free_scsi_task(iTask.task);

        iTask.task = NULL;

    }

    if (iTask.do_retry) {

        iTask.complete = 0;

        goto retry;

    }

    if (iTask.status != SCSI_STATUS_GOOD) {

        return -EIO;

    }

    return 0;

}

static int coroutine_fn iscsi_co_flush(BlockDriverState *bs)

{

    IscsiLun *iscsilun = bs->opaque;

    struct IscsiTask iTask;

    iscsi_co_init_iscsitask(iscsilun, &iTask);

retry:

    if (iscsi_synchronizecache10_task(iscsilun->iscsi, iscsilun->lun, 0, 0, 0,

                                      0, iscsi_co_generic_cb, &iTask) == NULL) {

        return -ENOMEM;

    }

    while (!iTask.complete) {

        iscsi_set_events(iscsilun);

        qemu_coroutine_yield();

    }

    if (iTask.task != NULL) {

        scsi_free_scsi_task(iTask.task);

        iTask.task = NULL;

    }

    if (iTask.do_retry) {

        iTask.complete = 0;

        goto retry;

    }

    if (iTask.status != SCSI_STATUS_GOOD) {

        return -EIO;

    }

    return 0;

}

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

}

#if defined(LIBISCSI_FEATURE_IOVECTOR)

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 = -ENOMEM;

        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;

        }

        iTask.complete = 0;

        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 compatibility */

        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;

}

#endif /* LIBISCSI_FEATURE_IOVECTOR */

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;

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

        return -EINVAL;

    }

    if (!iscsilun->lbp.lbpu) {

        /* UNMAP is not supported by the target */

        return 0;

    }

    list.lba = sector_qemu2lun(sector_num, iscsilun);

    list.num = sector_qemu2lun(nb_sectors, iscsilun);

    iscsi_co_init_iscsitask(iscsilun, &iTask);

retry:

    if (iscsi_unmap_task(iscsilun->iscsi, iscsilun->lun, 0, 0, &list, 1,

                     iscsi_co_generic_cb, &iTask) == NULL) {

        return -ENOMEM;

    }

    while (!iTask.complete) {

        iscsi_set_events(iscsilun);

        qemu_coroutine_yield();

    }

    if (iTask.task != NULL) {

        scsi_free_scsi_task(iTask.task);

        iTask.task = NULL;

    }

    if (iTask.do_retry) {

        iTask.complete = 0;

        goto retry;

    }

    if (iTask.status == SCSI_STATUS_CHECK_CONDITION) {

        /* the target might fail with a check condition if it

           is not happy with the alignment of the UNMAP request

           we silently fail in this case */

        return 0;

    }

    if (iTask.status != SCSI_STATUS_GOOD) {

        return -EIO;

    }

    return 0;

}

#if defined(SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED)

static int

coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,

                                   int nb_sectors, BdrvRequestFlags flags)

{

    IscsiLun *iscsilun = bs->opaque;

    struct IscsiTask iTask;

    uint64_t lba;

    uint32_t nb_blocks;

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

        return -EINVAL;

    }

    if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {

        /* WRITE SAME without UNMAP is not supported by the target */

        return -ENOTSUP;

    }

    if ((flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->lbp.lbpws) {

        /* WRITE SAME with UNMAP is not supported by the target */

        return -ENOTSUP;

    }

    lba = sector_qemu2lun(sector_num, iscsilun);

    nb_blocks = sector_qemu2lun(nb_sectors, iscsilun);

    if (iscsilun->zeroblock == NULL) {

        iscsilun->zeroblock = g_malloc0(iscsilun->block_size);

    }

    iscsi_co_init_iscsitask(iscsilun, &iTask);

retry:

    if (iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,

                               iscsilun->zeroblock, iscsilun->block_size,

                               nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),

                               0, 0, iscsi_co_generic_cb, &iTask) == NULL) {

        return -ENOMEM;

    }

    while (!iTask.complete) {

        iscsi_set_events(iscsilun);

        qemu_coroutine_yield();

    }

    if (iTask.task != NULL) {

        scsi_free_scsi_task(iTask.task);

        iTask.task = NULL;

    }

    if (iTask.do_retry) {

        iTask.complete = 0;

        goto retry;

    }

    if (iTask.status != SCSI_STATUS_GOOD) {

        if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&

            iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&

            iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {

            /* WRITE SAME is not supported by the target */

            iscsilun->has_write_same = false;

            return -ENOTSUP;

        }

        return -EIO;

    }

    return 0;

}

#endif /* SCSI_SENSE_ASCQ_CAPACITY_DATA_HAS_CHANGED */

static void parse_chap(struct iscsi_context *iscsi, const char *target,

                       Error **errp)

{

    QemuOptsList *list;

    QemuOpts *opts;

    const char *user = NULL;

    const char *password = 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;

        }

    }

    user = qemu_opt_get(opts, "user");

    if (!user) {

        return;

    }

    password = qemu_opt_get(opts, "password");

    if (!password) {

        error_setg(errp, "CHAP username specified but no password was given");

        return;

    }

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

        error_setg(errp, "Failed to set initiator username and password");

    }

}

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

                                Error **errp)

{

    QemuOptsList *list;

    QemuOpts *opts;

    const char *digest = NULL;

    list = qemu_find_opts("iscsi");

    if (!list) {

        return;

    }