自学教程：C++ virtio_blk_req_complete函数代码示例

static void virtio_blk_handle_request(VirtIOBlockReq *req,    MultiReqBuffer *mrb){    uint32_t type;    if (req->elem.out_num < 1 || req->elem.in_num < 1) {        error_report("virtio-blk missing headers");        exit(1);    }    if (req->elem.out_sg[0].iov_len < sizeof(*req->out) ||        req->elem.in_sg[req->elem.in_num - 1].iov_len < sizeof(*req->in)) {        error_report("virtio-blk header not in correct element");        exit(1);    }    req->out = (void *)req->elem.out_sg[0].iov_base;    req->in = (void *)req->elem.in_sg[req->elem.in_num - 1].iov_base;    type = ldl_p(&req->out->type);    if (type & VIRTIO_BLK_T_FLUSH) {        virtio_blk_handle_flush(req, mrb);    } else if (type & VIRTIO_BLK_T_SCSI_CMD) {        virtio_blk_handle_scsi(req);    } else if (type & VIRTIO_BLK_T_GET_ID) {        VirtIOBlock *s = req->dev;        /*         * NB: per existing s/n string convention the string is         * terminated by '/0' only when shorter than buffer.         */        strncpy(req->elem.in_sg[0].iov_base,                s->blk.serial ? s->blk.serial : "",                MIN(req->elem.in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES));        virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);        g_free(req);    } else if (type & VIRTIO_BLK_T_OUT) {        qemu_iovec_init_external(&req->qiov, &req->elem.out_sg[1],                                 req->elem.out_num - 1);        virtio_blk_handle_write(req, mrb);    } else if (type == VIRTIO_BLK_T_IN || type == VIRTIO_BLK_T_BARRIER) {        /* VIRTIO_BLK_T_IN is 0, so we can't just & it. */        qemu_iovec_init_external(&req->qiov, &req->elem.in_sg[0],                                 req->elem.in_num - 1);        virtio_blk_handle_read(req);    } else {        virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);        g_free(req);    }}

static void virtio_blk_rw_complete(void *opaque, int ret){    VirtIOBlockReq *next = opaque;    while (next) {        VirtIOBlockReq *req = next;        next = req->mr_next;        trace_virtio_blk_rw_complete(req, ret);        if (req->qiov.nalloc != -1) {            /* If nalloc is != 1 req->qiov is a local copy of the original             * external iovec. It was allocated in submit_merged_requests             * to be able to merge requests. */            qemu_iovec_destroy(&req->qiov);        }        if (ret) {            int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);            bool is_read = !(p & VIRTIO_BLK_T_OUT);            if (virtio_blk_handle_rw_error(req, -ret, is_read)) {                continue;            }        }        virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);        block_acct_done(blk_get_stats(req->dev->blk), &req->acct);        virtio_blk_free_request(req);    }}

static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,    int is_read){    BlockErrorAction action = bdrv_get_on_error(req->dev->bs, is_read);    VirtIOBlock *s = req->dev;    if (action == BLOCK_ERR_IGNORE) {        bdrv_emit_qmp_error_event(s->bs, BDRV_ACTION_IGNORE, is_read);        return 0;    }    if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)            || action == BLOCK_ERR_STOP_ANY) {        req->next = s->rq;        s->rq = req;        bdrv_emit_qmp_error_event(s->bs, BDRV_ACTION_STOP, is_read);        vm_stop(RUN_STATE_IO_ERROR);        bdrv_iostatus_set_err(s->bs, error);    } else {        virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);        bdrv_acct_done(s->bs, &req->acct);        g_free(req);        bdrv_emit_qmp_error_event(s->bs, BDRV_ACTION_REPORT, is_read);    }    return 1;}

static void virtio_blk_rw_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    /* Copy read data to the guest */    if (!ret && !(req->out->type & VIRTIO_BLK_T_OUT)) {        size_t offset = 0;        int i;        for (i = 0; i < req->elem.in_num - 1; i++) {            size_t len;            /* Be pretty defensive wrt malicious guests */            len = MIN(req->elem.in_sg[i].iov_len,                      req->size - offset);            memcpy(req->elem.in_sg[i].iov_base,                   req->buffer + offset,                   len);            offset += len;        }    } else if (ret && (req->out->type & VIRTIO_BLK_T_OUT)) {        if (virtio_blk_handle_write_error(req, -ret))            return;    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);}

static void virtio_blk_handle_scsi(VirtIOBlockReq *req){    int status;    status = virtio_blk_handle_scsi_req(req->dev, req->elem);    virtio_blk_req_complete(req, status);    virtio_blk_free_request(req);}

static void virtio_blk_handle_scsi(VirtIOBlockReq *req){    int status;    status = virtio_blk_handle_scsi_req(req);    if (status != -EINPROGRESS) {        virtio_blk_req_complete(req, status);        virtio_blk_free_request(req);    }}

static void virtio_blk_rw_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    if (ret) {        int is_read = !(req->out->type & VIRTIO_BLK_T_OUT);        if (virtio_blk_handle_rw_error(req, -ret, is_read))            return;    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);}

static void virtio_blk_flush_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    if (ret) {        if (virtio_blk_handle_rw_error(req, -ret, 0)) {            return;        }    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);}

static void virtio_blk_flush_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    if (ret) {        if (virtio_blk_handle_rw_error(req, -ret, 0)) {            return;        }    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);    block_acct_done(blk_get_stats(req->dev->blk), &req->acct);    virtio_blk_free_request(req);}

static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb){    BlockDriverAIOCB *acb;    /*     * Make sure all outstanding writes are posted to the backing device.     */    virtio_submit_multiwrite(req->dev->bs, mrb);    acb = bdrv_aio_flush(req->dev->bs, virtio_blk_flush_complete, req);    if (!acb) {        virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);    }}

static void virtio_blk_rw_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    trace_virtio_blk_rw_complete(req, ret);    if (ret) {        int is_read = !(ldl_p(&req->out->type) & VIRTIO_BLK_T_OUT);        if (virtio_blk_handle_rw_error(req, -ret, is_read))            return;    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);    bdrv_acct_done(req->dev->bs, &req->acct);    g_free(req);}

static void virtio_blk_rw_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    trace_virtio_blk_rw_complete(req, ret);    if (ret) {        int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);        bool is_read = !(p & VIRTIO_BLK_T_OUT);        if (virtio_blk_handle_rw_error(req, -ret, is_read))            return;    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);    bdrv_acct_done(req->dev->bs, &req->acct);    virtio_blk_free_request(req);}

static void virtio_blk_handle_request(VirtIOBlockReq *req,    MultiReqBuffer *mrb){    if (req->elem.out_num < 1 || req->elem.in_num < 1) {        fprintf(stderr, "virtio-blk missing headers/n");        exit(1);    }    if (req->elem.out_sg[0].iov_len < sizeof(*req->out) ||        req->elem.in_sg[req->elem.in_num - 1].iov_len < sizeof(*req->in)) {        fprintf(stderr, "virtio-blk header not in correct element/n");        exit(1);    }    req->out = (void *)req->elem.out_sg[0].iov_base;    req->in = (void *)req->elem.in_sg[req->elem.in_num - 1].iov_base;    if (req->out->type & VIRTIO_BLK_T_FLUSH) {        virtio_blk_handle_flush(mrb->blkreq, &mrb->num_writes,            req, &mrb->old_bs);    } else if (req->out->type & VIRTIO_BLK_T_SCSI_CMD) {        virtio_blk_handle_scsi(req);    } else if (req->out->type & VIRTIO_BLK_T_GET_ID) {        VirtIOBlock *s = req->dev;        /*         * NB: per existing s/n string convention the string is         * terminated by '/0' only when shorter than buffer.         */        strncpy(req->elem.in_sg[0].iov_base,                s->blk->serial ? s->blk->serial : "",                MIN(req->elem.in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES));        virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);        qemu_free(req);    } else if (req->out->type & VIRTIO_BLK_T_OUT) {        qemu_iovec_init_external(&req->qiov, &req->elem.out_sg[1],                                 req->elem.out_num - 1);        virtio_blk_handle_write(mrb->blkreq, &mrb->num_writes,            req, &mrb->old_bs);    } else {        qemu_iovec_init_external(&req->qiov, &req->elem.in_sg[0],                                 req->elem.in_num - 1);        virtio_blk_handle_read(req);    }}

static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,    bool is_read){    BlockErrorAction action = bdrv_get_error_action(req->dev->bs, is_read, error);    VirtIOBlock *s = req->dev;    if (action == BLOCK_ERROR_ACTION_STOP) {        req->next = s->rq;        s->rq = req;    } else if (action == BLOCK_ERROR_ACTION_REPORT) {        virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);        bdrv_acct_done(s->bs, &req->acct);        virtio_blk_free_request(req);    }    bdrv_error_action(s->bs, action, is_read, error);    return action != BLOCK_ERROR_ACTION_IGNORE;}

static void virtio_blk_ioctl_complete(void *opaque, int status){    VirtIOBlockIoctlReq *ioctl_req = opaque;    VirtIOBlockReq *req = ioctl_req->req;    VirtIOBlock *s = req->dev;    VirtIODevice *vdev = VIRTIO_DEVICE(s);    struct virtio_scsi_inhdr *scsi;    struct sg_io_hdr *hdr;    scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base;    if (status) {        status = VIRTIO_BLK_S_UNSUPP;        virtio_stl_p(vdev, &scsi->errors, 255);        goto out;    }    hdr = &ioctl_req->hdr;    /*     * From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi)     * clear the masked_status field [hence status gets cleared too, see     * block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED     * status has occurred.  However they do set DRIVER_SENSE in driver_status     * field. Also a (sb_len_wr > 0) indicates there is a sense buffer.     */    if (hdr->status == 0 && hdr->sb_len_wr > 0) {        hdr->status = CHECK_CONDITION;    }    virtio_stl_p(vdev, &scsi->errors,                 hdr->status | (hdr->msg_status << 8) |                 (hdr->host_status << 16) | (hdr->driver_status << 24));    virtio_stl_p(vdev, &scsi->residual, hdr->resid);    virtio_stl_p(vdev, &scsi->sense_len, hdr->sb_len_wr);    virtio_stl_p(vdev, &scsi->data_len, hdr->dxfer_len);out:    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));    virtio_blk_req_complete(req, status);    virtio_blk_free_request(req);    aio_context_release(blk_get_aio_context(s->conf.conf.blk));    g_free(ioctl_req);}

static int virtio_blk_handle_write_error(VirtIOBlockReq *req, int error){    BlockInterfaceErrorAction action = drive_get_onerror(req->dev->bs);    VirtIOBlock *s = req->dev;    if (action == BLOCK_ERR_IGNORE)        return 0;    if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)            || action == BLOCK_ERR_STOP_ANY) {        req->next = s->rq;        s->rq = req;        vm_stop(0);    } else {        virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);    }    return 1;}

static void virtio_blk_flush_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    VirtIOBlock *s = req->dev;    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));    if (ret) {        if (virtio_blk_handle_rw_error(req, -ret, 0)) {            goto out;        }    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);    block_acct_done(blk_get_stats(req->dev->blk), &req->acct);    virtio_blk_free_request(req);out:    aio_context_release(blk_get_aio_context(s->conf.conf.blk));}

static void virtio_blk_rw_complete(void *opaque, int ret){    VirtIOBlockReq *next = opaque;    VirtIOBlock *s = next->dev;    VirtIODevice *vdev = VIRTIO_DEVICE(s);    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));    while (next) {        VirtIOBlockReq *req = next;        next = req->mr_next;        trace_virtio_blk_rw_complete(vdev, req, ret);        if (req->qiov.nalloc != -1) {            /* If nalloc is != -1 req->qiov is a local copy of the original             * external iovec. It was allocated in submit_requests to be             * able to merge requests. */            qemu_iovec_destroy(&req->qiov);        }        if (ret) {            int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);            bool is_read = !(p & VIRTIO_BLK_T_OUT);            /* Note that memory may be dirtied on read failure.  If the             * virtio request is not completed here, as is the case for             * BLOCK_ERROR_ACTION_STOP, the memory may not be copied             * correctly during live migration.  While this is ugly,             * it is acceptable because the device is free to write to             * the memory until the request is completed (which will             * happen on the other side of the migration).             */            if (virtio_blk_handle_rw_error(req, -ret, is_read, true)) {                continue;            }        }        virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);        block_acct_done(blk_get_stats(req->dev->blk), &req->acct);        virtio_blk_free_request(req);    }    aio_context_release(blk_get_aio_context(s->conf.conf.blk));}

static void virtio_blk_handle_request(VirtIOBlockReq *req,    MultiReqBuffer *mrb){    uint32_t type;    if (req->elem.out_num < 1 || req->elem.in_num < 1) {        error_report("virtio-blk missing headers");        exit(1);    }    if (req->elem.out_sg[0].iov_len < sizeof(*req->out) ||        req->elem.in_sg[req->elem.in_num - 1].iov_len < sizeof(*req->in)) {        error_report("virtio-blk header not in correct element");        exit(1);    }    req->out = (void *)req->elem.out_sg[0].iov_base;    req->in = (void *)req->elem.in_sg[req->elem.in_num - 1].iov_base;    type = ldl_p(&req->out->type);    if (type & VIRTIO_BLK_T_FLUSH) {        virtio_blk_handle_flush(req, mrb);    } else if (type & VIRTIO_BLK_T_SCSI_CMD) {        virtio_blk_handle_scsi(req);    } else if (type & VIRTIO_BLK_T_GET_ID) {        VirtIOBlock *s = req->dev;        memcpy(req->elem.in_sg[0].iov_base, s->sn,               MIN(req->elem.in_sg[0].iov_len, sizeof(s->sn)));        virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);    } else if (type & VIRTIO_BLK_T_OUT) {        qemu_iovec_init_external(&req->qiov, &req->elem.out_sg[1],                                 req->elem.out_num - 1);        virtio_blk_handle_write(req, mrb);    } else {        qemu_iovec_init_external(&req->qiov, &req->elem.in_sg[0],                                 req->elem.in_num - 1);        virtio_blk_handle_read(req);    }}

static void virtio_blk_rw_complete(void *opaque, int ret){    VirtIOBlockReq *next = opaque;    while (next) {        VirtIOBlockReq *req = next;        next = req->mr_next;        trace_virtio_blk_rw_complete(req, ret);        if (req->qiov.nalloc != -1) {            /* If nalloc is != 1 req->qiov is a local copy of the original             * external iovec. It was allocated in submit_merged_requests             * to be able to merge requests. */            qemu_iovec_destroy(&req->qiov);        }        if (ret) {            int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);            bool is_read = !(p & VIRTIO_BLK_T_OUT);            /* Note that memory may be dirtied on read failure.  If the             * virtio request is not completed here, as is the case for             * BLOCK_ERROR_ACTION_STOP, the memory may not be copied             * correctly during live migration.  While this is ugly,             * it is acceptable because the device is free to write to             * the memory until the request is completed (which will             * happen on the other side of the migration).             */            if (virtio_blk_handle_rw_error(req, -ret, is_read)) {                /* Break the link in case the next request is added to the                 * restart queue and is going to be parsed from the ring again.                 */                req->mr_next = NULL;                continue;            }        }        virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);        block_acct_done(blk_get_stats(req->dev->blk), &req->acct);        virtio_blk_free_request(req);    }}

static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,    bool is_read){    VirtIOBlock *s = req->dev;    BlockErrorAction action = blk_get_error_action(s->blk, is_read, error);    if (action == BLOCK_ERROR_ACTION_STOP) {        /* Break the link as the next request is going to be parsed from the         * ring again. Otherwise we may end up doing a double completion! */        req->mr_next = NULL;        req->next = s->rq;        s->rq = req;    } else if (action == BLOCK_ERROR_ACTION_REPORT) {        virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);        block_acct_failed(blk_get_stats(s->blk), &req->acct);        virtio_blk_free_request(req);    }    blk_error_action(s->blk, action, is_read, error);    return action != BLOCK_ERROR_ACTION_IGNORE;}

static void virtio_blk_discard_write_zeroes_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    VirtIOBlock *s = req->dev;    bool is_write_zeroes = (virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type) &                            ~VIRTIO_BLK_T_BARRIER) == VIRTIO_BLK_T_WRITE_ZEROES;    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));    if (ret) {        if (virtio_blk_handle_rw_error(req, -ret, false, is_write_zeroes)) {            goto out;        }    }    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);    if (is_write_zeroes) {        block_acct_done(blk_get_stats(s->blk), &req->acct);    }    virtio_blk_free_request(req);out:    aio_context_release(blk_get_aio_context(s->conf.conf.blk));}

static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,    int is_read){    BlockErrorAction action = bdrv_get_on_error(req->dev->bs, is_read);    VirtIOBlock *s = req->dev;    if (action == BLOCK_ERR_IGNORE) {        bdrv_mon_event(s->bs, BDRV_ACTION_IGNORE, is_read);        return 0;    }    if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)            || action == BLOCK_ERR_STOP_ANY) {        req->next = s->rq;        s->rq = req;        bdrv_mon_event(s->bs, BDRV_ACTION_STOP, is_read);        vm_stop(0);    } else {        virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);        bdrv_mon_event(s->bs, BDRV_ACTION_REPORT, is_read);    }    return 1;}

static void virtio_blk_handle_scsi(VirtIOBlockReq *req){    virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);}

static void virtio_blk_handle_scsi(VirtIOBlockReq *req){    struct sg_io_hdr hdr;    int ret;    int status;    int i;    if ((req->dev->vdev.guest_features & (1 << VIRTIO_BLK_F_SCSI)) == 0) {        virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);        g_free(req);        return;    }    /*     * We require at least one output segment each for the virtio_blk_outhdr     * and the SCSI command block.     *     * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr     * and the sense buffer pointer in the input segments.     */    if (req->elem.out_num < 2 || req->elem.in_num < 3) {        virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);        g_free(req);        return;    }    /*     * No support for bidirection commands yet.     */    if (req->elem.out_num > 2 && req->elem.in_num > 3) {        virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);        g_free(req);        return;    }    /*     * The scsi inhdr is placed in the second-to-last input segment, just     * before the regular inhdr.     */    req->scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base;    memset(&hdr, 0, sizeof(struct sg_io_hdr));    hdr.interface_id = 'S';    hdr.cmd_len = req->elem.out_sg[1].iov_len;    hdr.cmdp = req->elem.out_sg[1].iov_base;    hdr.dxfer_len = 0;    if (req->elem.out_num > 2) {        /*         * If there are more than the minimally required 2 output segments         * there is write payload starting from the third iovec.         */        hdr.dxfer_direction = SG_DXFER_TO_DEV;        hdr.iovec_count = req->elem.out_num - 2;        for (i = 0; i < hdr.iovec_count; i++)            hdr.dxfer_len += req->elem.out_sg[i + 2].iov_len;        hdr.dxferp = req->elem.out_sg + 2;    } else if (req->elem.in_num > 3) {        /*         * If we have more than 3 input segments the guest wants to actually         * read data.         */        hdr.dxfer_direction = SG_DXFER_FROM_DEV;        hdr.iovec_count = req->elem.in_num - 3;        for (i = 0; i < hdr.iovec_count; i++)            hdr.dxfer_len += req->elem.in_sg[i].iov_len;        hdr.dxferp = req->elem.in_sg;    } else {        /*         * Some SCSI commands don't actually transfer any data.         */        hdr.dxfer_direction = SG_DXFER_NONE;    }    hdr.sbp = req->elem.in_sg[req->elem.in_num - 3].iov_base;    hdr.mx_sb_len = req->elem.in_sg[req->elem.in_num - 3].iov_len;    ret = bdrv_ioctl(req->dev->bs, SG_IO, &hdr);    if (ret) {        status = VIRTIO_BLK_S_UNSUPP;        hdr.status = ret;        hdr.resid = hdr.dxfer_len;    } else if (hdr.status) {        status = VIRTIO_BLK_S_IOERR;    } else {        status = VIRTIO_BLK_S_OK;    }    /*     * From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi)     * clear the masked_status field [hence status gets cleared too, see     * block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED     * status has occurred.  However they do set DRIVER_SENSE in driver_status     * field. Also a (sb_len_wr > 0) indicates there is a sense buffer.     */    if (hdr.status == 0 && hdr.sb_len_wr > 0) {//.........这里部分代码省略.........

void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb){    uint32_t type;    struct iovec *in_iov = req->elem->in_sg;    struct iovec *iov = req->elem->out_sg;    unsigned in_num = req->elem->in_num;    unsigned out_num = req->elem->out_num;    if (req->elem->out_num < 1 || req->elem->in_num < 1) {        error_report("virtio-blk missing headers");        exit(1);    }    if (unlikely(iov_to_buf(iov, out_num, 0, &req->out,                            sizeof(req->out)) != sizeof(req->out))) {        error_report("virtio-blk request outhdr too short");        exit(1);    }    iov_discard_front(&iov, &out_num, sizeof(req->out));    if (in_num < 1 ||        in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {        error_report("virtio-blk request inhdr too short");        exit(1);    }    req->in = (void *)in_iov[in_num - 1].iov_base              + in_iov[in_num - 1].iov_len              - sizeof(struct virtio_blk_inhdr);    iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));    type = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type);    if (type & VIRTIO_BLK_T_FLUSH) {        virtio_blk_handle_flush(req, mrb);    } else if (type & VIRTIO_BLK_T_SCSI_CMD) {        virtio_blk_handle_scsi(req);    } else if (type & VIRTIO_BLK_T_GET_ID) {        VirtIOBlock *s = req->dev;        /*         * NB: per existing s/n string convention the string is         * terminated by '/0' only when shorter than buffer.         */        strncpy(req->elem->in_sg[0].iov_base,                s->blk.serial ? s->blk.serial : "",                MIN(req->elem->in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES));        virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);        virtio_blk_free_request(req);    } else if (type & VIRTIO_BLK_T_OUT) {        qemu_iovec_init_external(&req->qiov, &req->elem->out_sg[1],                                 req->elem->out_num - 1);        virtio_blk_handle_write(req, mrb);    } else if (type == VIRTIO_BLK_T_IN || type == VIRTIO_BLK_T_BARRIER) {        /* VIRTIO_BLK_T_IN is 0, so we can't just & it. */        qemu_iovec_init_external(&req->qiov, &req->elem->in_sg[0],                                 req->elem->in_num - 1);        virtio_blk_handle_read(req);    } else {        virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);        virtio_blk_free_request(req);    }}

static void virtio_blk_flush_complete(void *opaque, int ret){    VirtIOBlockReq *req = opaque;    virtio_blk_req_complete(req, ret ? VIRTIO_BLK_S_IOERR : VIRTIO_BLK_S_OK);}