Archipelago » qemu

    int ret = 0;

    while (ret >= 0 && nb_sectors > 0) {

        block_index = sector_num / s->block_sectors;

        sector_in_block = sector_num % s->block_sectors;

        n_sectors = s->block_sectors - sector_in_block;

        if (n_sectors > nb_sectors) {

            n_sectors = nb_sectors;

        }

        logout("will read %u sectors starting at sector %" PRIu64 "\n",

               n_sectors, sector_num);

        /* prepare next AIO request */

        bmap_entry = le32_to_cpu(s->bmap[block_index]);

        if (!VDI_IS_ALLOCATED(bmap_entry)) {

            /* Block not allocated, return zeros, no need to wait. */

            memset(buf, 0, n_sectors * SECTOR_SIZE);

            ret = 0;

        } else {

            uint64_t offset = s->header.offset_data / SECTOR_SIZE +

                              (uint64_t)bmap_entry * s->block_sectors +

                              sector_in_block;

            ret = bdrv_read(bs->file, offset, buf, n_sectors);

        }

        logout("%u sectors read\n", n_sectors);

        nb_sectors -= n_sectors;

        sector_num += n_sectors;

        buf += n_sectors * SECTOR_SIZE;

    int ret = 0;

    while (ret >= 0 && nb_sectors > 0) {

        block_index = sector_num / s->block_sectors;

        sector_in_block = sector_num % s->block_sectors;

        n_sectors = s->block_sectors - sector_in_block;

        if (n_sectors > nb_sectors) {

            n_sectors = nb_sectors;

        }

        logout("will write %u sectors starting at sector %" PRIu64 "\n",

               n_sectors, sector_num);

        /* prepare next AIO request */

        bmap_entry = le32_to_cpu(s->bmap[block_index]);

        if (!VDI_IS_ALLOCATED(bmap_entry)) {

            /* Allocate new block and write to it. */

            uint64_t offset;

            bmap_entry = s->header.blocks_allocated;

            s->bmap[block_index] = cpu_to_le32(bmap_entry);

            s->header.blocks_allocated++;

            offset = s->header.offset_data / SECTOR_SIZE +

                     (uint64_t)bmap_entry * s->block_sectors;

            if (block == NULL) {

                block = g_malloc(s->block_size);

                bmap_first = block_index;

            }

            bmap_last = block_index;

            /* Copy data to be written to new block and zero unused parts. */

            memset(block, 0, sector_in_block * SECTOR_SIZE);

            memcpy(block + sector_in_block * SECTOR_SIZE,

                   buf, n_sectors * SECTOR_SIZE);

            memset(block + (sector_in_block + n_sectors) * SECTOR_SIZE, 0,

                   (s->block_sectors - n_sectors - sector_in_block) * SECTOR_SIZE);

            ret = bdrv_write(bs->file, offset, block, s->block_sectors);

        } else {

            uint64_t offset = s->header.offset_data / SECTOR_SIZE +

                              (uint64_t)bmap_entry * s->block_sectors +

                              sector_in_block;

            ret = bdrv_write(bs->file, offset, buf, n_sectors);

        nb_sectors -= n_sectors;

        sector_num += n_sectors;

        buf += n_sectors * SECTOR_SIZE;

        logout("%u sectors written\n", n_sectors);