static int qcow2_co_writev(BlockDriverState *bs,

                           int64_t sector_num,

                           int remaining_sectors,

                           QEMUIOVector *qiov)

{

    BDRVQcowState *s = bs->opaque;

    int index_in_cluster;

    int n_end;

    int ret;

    int cur_nr_sectors; /* number of sectors in current iteration */

    QCowL2Meta l2meta;

    uint64_t cluster_offset;

    QEMUIOVector hd_qiov;

    uint64_t bytes_done = 0;

    uint8_t *cluster_data = NULL;



    l2meta.nb_clusters = 0;

    qemu_co_queue_init(&l2meta.dependent_requests);



    qemu_iovec_init(&hd_qiov, qiov->niov);



    s->cluster_cache_offset = -1; /* disable compressed cache */



    qemu_co_mutex_lock(&s->lock);



    while (remaining_sectors != 0) {



        index_in_cluster = sector_num & (s->cluster_sectors - 1);

        n_end = index_in_cluster + remaining_sectors;

        if (s->crypt_method &&

            n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) {

            n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors;

        }



        ret = qcow2_alloc_cluster_offset(bs, sector_num << 9,

            index_in_cluster, n_end, &cur_nr_sectors, &l2meta);

        if (ret < 0) {

            goto fail;

        }



        cluster_offset = l2meta.cluster_offset;

        assert((cluster_offset & 511) == 0);



        qemu_iovec_reset(&hd_qiov);

        qemu_iovec_copy(&hd_qiov, qiov, bytes_done,

            cur_nr_sectors * 512);



        if (s->crypt_method) {

            if (!cluster_data) {

                cluster_data = g_malloc0(QCOW_MAX_CRYPT_CLUSTERS *

                                                 s->cluster_size);

            }



            assert(hd_qiov.size <=

                   QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);

            qemu_iovec_to_buffer(&hd_qiov, cluster_data);



            qcow2_encrypt_sectors(s, sector_num, cluster_data,

                cluster_data, cur_nr_sectors, 1, &s->aes_encrypt_key);



            qemu_iovec_reset(&hd_qiov);

            qemu_iovec_add(&hd_qiov, cluster_data,

                cur_nr_sectors * 512);

        }



        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);

        qemu_co_mutex_unlock(&s->lock);

        ret = bdrv_co_writev(bs->file,

                             (cluster_offset >> 9) + index_in_cluster,

                             cur_nr_sectors, &hd_qiov);

        qemu_co_mutex_lock(&s->lock);

        if (ret < 0) {

            goto fail;

        }



        ret = qcow2_alloc_cluster_link_l2(bs, &l2meta);



        run_dependent_requests(s, &l2meta);



        if (ret < 0) {

            goto fail;

        }



        remaining_sectors -= cur_nr_sectors;

        sector_num += cur_nr_sectors;

        bytes_done += cur_nr_sectors * 512;

    }

    ret = 0;



fail:

    qemu_co_mutex_unlock(&s->lock);



    qemu_iovec_destroy(&hd_qiov);




    return ret;

}
static int qcow2_co_writev(BlockDriverState *bs,

                           int64_t sector_num,

                           int remaining_sectors,

                           QEMUIOVector *qiov)

{

    BDRVQcowState *s = bs->opaque;

    int index_in_cluster;

    int n_end;

    int ret;

    int cur_nr_sectors; 

    QCowL2Meta l2meta;

    uint64_t cluster_offset;

    QEMUIOVector hd_qiov;

    uint64_t bytes_done = 0;

    uint8_t *cluster_data = NULL;



    l2meta.nb_clusters = 0;

    qemu_co_queue_init(&l2meta.dependent_requests);



    qemu_iovec_init(&hd_qiov, qiov->niov);



    s->cluster_cache_offset = -1; 



    qemu_co_mutex_lock(&s->lock);



    while (remaining_sectors != 0) {



        index_in_cluster = sector_num & (s->cluster_sectors - 1);

        n_end = index_in_cluster + remaining_sectors;

        if (s->crypt_method &&

            n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) {

            n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors;

        }



        ret = qcow2_alloc_cluster_offset(bs, sector_num << 9,

            index_in_cluster, n_end, &cur_nr_sectors, &l2meta);

        if (ret < 0) {

            goto fail;

        }



        cluster_offset = l2meta.cluster_offset;

        assert((cluster_offset & 511) == 0);



        qemu_iovec_reset(&hd_qiov);

        qemu_iovec_copy(&hd_qiov, qiov, bytes_done,

            cur_nr_sectors * 512);



        if (s->crypt_method) {

            if (!cluster_data) {

                cluster_data = g_malloc0(QCOW_MAX_CRYPT_CLUSTERS *

                                                 s->cluster_size);

            }



            assert(hd_qiov.size <=

                   QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);

            qemu_iovec_to_buffer(&hd_qiov, cluster_data);



            qcow2_encrypt_sectors(s, sector_num, cluster_data,

                cluster_data, cur_nr_sectors, 1, &s->aes_encrypt_key);



            qemu_iovec_reset(&hd_qiov);

            qemu_iovec_add(&hd_qiov, cluster_data,

                cur_nr_sectors * 512);

        }



        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);

        qemu_co_mutex_unlock(&s->lock);

        ret = bdrv_co_writev(bs->file,

                             (cluster_offset >> 9) + index_in_cluster,

                             cur_nr_sectors, &hd_qiov);

        qemu_co_mutex_lock(&s->lock);

        if (ret < 0) {

            goto fail;

        }



        ret = qcow2_alloc_cluster_link_l2(bs, &l2meta);



        run_dependent_requests(s, &l2meta);



        if (ret < 0) {

            goto fail;

        }



        remaining_sectors -= cur_nr_sectors;

        sector_num += cur_nr_sectors;

        bytes_done += cur_nr_sectors * 512;

    }

    ret = 0;



fail:

    qemu_co_mutex_unlock(&s->lock);



    qemu_iovec_destroy(&hd_qiov);




    return ret;

}
static int FUNC_0(BlockDriverState *VAR_0,

                           int64_t VAR_1,

                           int VAR_2,

                           QEMUIOVector *VAR_3)

{

    BDRVQcowState *s = VAR_0->opaque;

    int VAR_4;

    int VAR_5;

    int VAR_6;

    int VAR_7; 

    QCowL2Meta l2meta;

    uint64_t cluster_offset;

    QEMUIOVector hd_qiov;

    uint64_t bytes_done = 0;

    uint8_t *cluster_data = NULL;



    l2meta.nb_clusters = 0;

    qemu_co_queue_init(&l2meta.dependent_requests);



    qemu_iovec_init(&hd_qiov, VAR_3->niov);



    s->cluster_cache_offset = -1; 



    qemu_co_mutex_lock(&s->lock);



    while (VAR_2 != 0) {



        VAR_4 = VAR_1 & (s->cluster_sectors - 1);

        VAR_5 = VAR_4 + VAR_2;

        if (s->crypt_method &&

            VAR_5 > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) {

            VAR_5 = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors;

        }



        VAR_6 = qcow2_alloc_cluster_offset(VAR_0, VAR_1 << 9,

            VAR_4, VAR_5, &VAR_7, &l2meta);

        if (VAR_6 < 0) {

            goto fail;

        }



        cluster_offset = l2meta.cluster_offset;

        assert((cluster_offset & 511) == 0);



        qemu_iovec_reset(&hd_qiov);

        qemu_iovec_copy(&hd_qiov, VAR_3, bytes_done,

            VAR_7 * 512);



        if (s->crypt_method) {

            if (!cluster_data) {

                cluster_data = g_malloc0(QCOW_MAX_CRYPT_CLUSTERS *

                                                 s->cluster_size);

            }



            assert(hd_qiov.size <=

                   QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);

            qemu_iovec_to_buffer(&hd_qiov, cluster_data);



            qcow2_encrypt_sectors(s, VAR_1, cluster_data,

                cluster_data, VAR_7, 1, &s->aes_encrypt_key);



            qemu_iovec_reset(&hd_qiov);

            qemu_iovec_add(&hd_qiov, cluster_data,

                VAR_7 * 512);

        }



        BLKDBG_EVENT(VAR_0->file, BLKDBG_WRITE_AIO);

        qemu_co_mutex_unlock(&s->lock);

        VAR_6 = bdrv_co_writev(VAR_0->file,

                             (cluster_offset >> 9) + VAR_4,

                             VAR_7, &hd_qiov);

        qemu_co_mutex_lock(&s->lock);

        if (VAR_6 < 0) {

            goto fail;

        }



        VAR_6 = qcow2_alloc_cluster_link_l2(VAR_0, &l2meta);



        run_dependent_requests(s, &l2meta);



        if (VAR_6 < 0) {

            goto fail;

        }



        VAR_2 -= VAR_7;

        VAR_1 += VAR_7;

        bytes_done += VAR_7 * 512;

    }

    VAR_6 = 0;



fail:

    qemu_co_mutex_unlock(&s->lock);



    qemu_iovec_destroy(&hd_qiov);




    return VAR_6;

}
static int FUNC_0(BlockDriverState *VAR_0,
int64_t VAR_1,
int VAR_2,
QEMUIOVector *VAR_3)
{ BDRVQcowState *s = VAR_0->opaque; int VAR_4; int VAR_5; int VAR_6; int VAR_7; QCowL2Meta l2meta; uint64_t cluster_offset; QEMUIOVector hd_qiov; uint64_t bytes_done = 0; uint8_t *cluster_data = NULL; l2meta.nb_clusters = 0; qemu_co_queue_init(&l2meta.dependent_requests); qemu_iovec_init(&hd_qiov, VAR_3->niov); s->cluster_cache_offset = -1; qemu_co_mutex_lock(&s->lock); while (VAR_2 != 0) { VAR_4 = VAR_1 & (s->cluster_sectors - 1); VAR_5 = VAR_4 + VAR_2; if (s->crypt_method &&
VAR_5 > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) { VAR_5 = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; } VAR_6 = qcow2_alloc_cluster_offset(VAR_0, VAR_1 << 9,
VAR_4, VAR_5, &VAR_7, &l2meta); if (VAR_6 < 0) { goto fail; } cluster_offset = l2meta.cluster_offset; assert((cluster_offset & 511) == 0); qemu_iovec_reset(&hd_qiov); qemu_iovec_copy(&hd_qiov, VAR_3, bytes_done,
VAR_7 * 512); if (s->crypt_method) { if (!cluster_data) { cluster_data = g_malloc0(QCOW_MAX_CRYPT_CLUSTERS *
s->cluster_size); } assert(hd_qiov.size <=
QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); qemu_iovec_to_buffer(&hd_qiov, cluster_data); qcow2_encrypt_sectors(s, VAR_1, cluster_data,
cluster_data, VAR_7, 1, &s->aes_encrypt_key); qemu_iovec_reset(&hd_qiov); qemu_iovec_add(&hd_qiov, cluster_data,
VAR_7 * 512); } BLKDBG_EVENT(VAR_0->file, BLKDBG_WRITE_AIO); qemu_co_mutex_unlock(&s->lock); VAR_6 = bdrv_co_writev(VAR_0->file,
(cluster_offset >> 9) + VAR_4,
VAR_7, &hd_qiov); qemu_co_mutex_lock(&s->lock); if (VAR_6 < 0) { goto fail; } VAR_6 = qcow2_alloc_cluster_link_l2(VAR_0, &l2meta); run_dependent_requests(s, &l2meta); if (VAR_6 < 0) { goto fail; } VAR_2 -= VAR_7; VAR_1 += VAR_7; bytes_done += VAR_7 * 512; } VAR_6 = 0; fail:
qemu_co_mutex_unlock(&s->lock); qemu_iovec_destroy(&hd_qiov); return VAR_6; }