static void virtio_blk_handle_request(VirtIOBlockReq *req,

    MultiReqBuffer *mrb)

{

    uint32_t type;

    struct iovec *iov = req->elem->out_sg;

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

    }



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

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

        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_handle_request(VirtIOBlockReq *req,

    MultiReqBuffer *mrb)

{

    uint32_t type;

    struct iovec *iov = req->elem->out_sg;

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

    }



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

    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;



        







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

        

        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 FUNC_0(VirtIOBlockReq *VAR_0,

    MultiReqBuffer *VAR_1)

{

    uint32_t type;

    struct iovec *VAR_2 = VAR_0->elem->out_sg;

    unsigned VAR_3 = VAR_0->elem->VAR_3;



    if (VAR_0->elem->VAR_3 < 1 || VAR_0->elem->in_num < 1) {

        error_report("virtio-blk missing headers");

        exit(1);

    }



    if (VAR_0->elem->out_sg[0].iov_len < sizeof(VAR_0->out) ||

        VAR_0->elem->in_sg[VAR_0->elem->in_num - 1].iov_len < sizeof(*VAR_0->in)) {

        error_report("virtio-blk header not in correct element");

        exit(1);

    }



    if (unlikely(iov_to_buf(VAR_2, VAR_3, 0, &VAR_0->out,

                            sizeof(VAR_0->out)) != sizeof(VAR_0->out))) {

        error_report("virtio-blk request outhdr too short");

        exit(1);

    }

    iov_discard_front(&VAR_2, &VAR_3, sizeof(VAR_0->out));

    VAR_0->in = (void *)VAR_0->elem->in_sg[VAR_0->elem->in_num - 1].iov_base;



    type = ldl_p(&VAR_0->out.type);



    if (type & VIRTIO_BLK_T_FLUSH) {

        virtio_blk_handle_flush(VAR_0, VAR_1);

    } else if (type & VIRTIO_BLK_T_SCSI_CMD) {

        virtio_blk_handle_scsi(VAR_0);

    } else if (type & VIRTIO_BLK_T_GET_ID) {

        VirtIOBlock *s = VAR_0->dev;



        







        strncpy(VAR_0->elem->in_sg[0].iov_base,

                s->blk.serial ? s->blk.serial : "",

                MIN(VAR_0->elem->in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES));

        virtio_blk_req_complete(VAR_0, VIRTIO_BLK_S_OK);

        virtio_blk_free_request(VAR_0);

    } else if (type & VIRTIO_BLK_T_OUT) {

        qemu_iovec_init_external(&VAR_0->qiov, &VAR_0->elem->out_sg[1],

                                 VAR_0->elem->VAR_3 - 1);

        virtio_blk_handle_write(VAR_0, VAR_1);

    } else if (type == VIRTIO_BLK_T_IN || type == VIRTIO_BLK_T_BARRIER) {

        

        qemu_iovec_init_external(&VAR_0->qiov, &VAR_0->elem->in_sg[0],

                                 VAR_0->elem->in_num - 1);

        virtio_blk_handle_read(VAR_0);

    } else {

        virtio_blk_req_complete(VAR_0, VIRTIO_BLK_S_UNSUPP);

        virtio_blk_free_request(VAR_0);

    }

}

static void FUNC_0(VirtIOBlockReq *VAR_0,
MultiReqBuffer *VAR_1)
{ uint32_t type; struct iovec *VAR_2 = VAR_0->elem->out_sg; unsigned VAR_3 = VAR_0->elem->VAR_3; if (VAR_0->elem->VAR_3 < 1 || VAR_0->elem->in_num < 1) { error_report("virtio-blk missing headers"); exit(1); } if (VAR_0->elem->out_sg[0].iov_len < sizeof(VAR_0->out) ||
VAR_0->elem->in_sg[VAR_0->elem->in_num - 1].iov_len < sizeof(*VAR_0->in)) { error_report("virtio-blk header not in correct element"); exit(1); } if (unlikely(iov_to_buf(VAR_2, VAR_3, 0, &VAR_0->out,
sizeof(VAR_0->out)) != sizeof(VAR_0->out))) { error_report("virtio-blk request outhdr too short"); exit(1); } iov_discard_front(&VAR_2, &VAR_3, sizeof(VAR_0->out)); VAR_0->in = (void *)VAR_0->elem->in_sg[VAR_0->elem->in_num - 1].iov_base; type = ldl_p(&VAR_0->out.type); if (type & VIRTIO_BLK_T_FLUSH) { virtio_blk_handle_flush(VAR_0, VAR_1); } else if (type & VIRTIO_BLK_T_SCSI_CMD) { virtio_blk_handle_scsi(VAR_0); } else if (type & VIRTIO_BLK_T_GET_ID) { VirtIOBlock *s = VAR_0->dev; strncpy(VAR_0->elem->in_sg[0].iov_base,
s->blk.serial ? s->blk.serial : "",
MIN(VAR_0->elem->in_sg[0].iov_len, VIRTIO_BLK_ID_BYTES)); virtio_blk_req_complete(VAR_0, VIRTIO_BLK_S_OK); virtio_blk_free_request(VAR_0); } else if (type & VIRTIO_BLK_T_OUT) { qemu_iovec_init_external(&VAR_0->qiov, &VAR_0->elem->out_sg[1],
VAR_0->elem->VAR_3 - 1); virtio_blk_handle_write(VAR_0, VAR_1); } else if (type == VIRTIO_BLK_T_IN || type == VIRTIO_BLK_T_BARRIER) { qemu_iovec_init_external(&VAR_0->qiov, &VAR_0->elem->in_sg[0],
VAR_0->elem->in_num - 1); virtio_blk_handle_read(VAR_0); } else { virtio_blk_req_complete(VAR_0, VIRTIO_BLK_S_UNSUPP); virtio_blk_free_request(VAR_0); } }