Archipelago » qemu

    return 0;

}

    BlockDriverState *bs;

    BlockDriverState *base;

    int64_t sector_num;

    int nb_sectors;

    int *pnum;

    bool done;

/*

 * Returns true iff the specified sector is present in the disk image. Drivers

 * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes

 * beyond the end of the disk image it will be clamped.

 */

{

    int64_t length;

    int64_t n;

        nb_sectors = n;

    }

        *pnum = nb_sectors;

        return 1;

    }

}

{

    BlockDriverState *bs = data->bs;

    data->done = true;

}

/*

 *

 */

{

    Coroutine *co;

        .bs = bs,

        .sector_num = sector_num,

        .nb_sectors = nb_sectors,

    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

    } else {

        qemu_coroutine_enter(co, &data);

        while (!data.done) {

            qemu_aio_wait();

    return data.ret;

}

/*

 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]

 *

    return changed;

}

static int cow_update_bitmap(BlockDriverState *bs, int64_t sector_num,

        int nb_sectors)

{

    .bdrv_read              = cow_co_read,

    .bdrv_write             = cow_co_write,

    .create_options = cow_create_options,

};

    return cluster_offset;

}

        int64_t sector_num, int nb_sectors, int *pnum)

{

    BDRVQcowState *s = bs->opaque;

    .bdrv_co_readv          = qcow_co_readv,

    .bdrv_co_writev         = qcow_co_writev,

    .bdrv_set_key           = qcow_set_key,

    .bdrv_make_empty        = qcow_make_empty,

    return 0;

}

        int64_t sector_num, int nb_sectors, int *pnum)

{

    BDRVQcowState *s = bs->opaque;

    .bdrv_reopen_prepare  = qcow2_reopen_prepare,

    .bdrv_create        = qcow2_create,

    .bdrv_has_zero_init = bdrv_has_zero_init_1,

    .bdrv_set_key       = qcow2_set_key,

    .bdrv_make_empty    = qcow2_make_empty,

    }

}

                                                 int64_t sector_num,

                                                 int nb_sectors, int *pnum)

{

    .bdrv_reopen_prepare      = bdrv_qed_reopen_prepare,

    .bdrv_create              = bdrv_qed_create,

    .bdrv_has_zero_init       = bdrv_has_zero_init_1,

    .bdrv_make_empty          = bdrv_qed_make_empty,

    .bdrv_aio_readv           = bdrv_qed_aio_readv,

    .bdrv_aio_writev          = bdrv_qed_aio_writev,

 * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes

 * beyond the end of the disk image it will be clamped.

 */

                                            int64_t sector_num,

                                            int nb_sectors, int *pnum)

{

    .bdrv_close = raw_close,

    .bdrv_create = raw_create,

    .bdrv_has_zero_init = bdrv_has_zero_init_1,

    .bdrv_aio_readv = raw_aio_readv,

    .bdrv_aio_writev = raw_aio_writev,

    return bdrv_co_writev(bs->file, sector_num, nb_sectors, qiov);

}

{

}

static int coroutine_fn raw_co_write_zeroes(BlockDriverState *bs,

    .bdrv_co_writev       = &raw_co_writev,

    .bdrv_co_write_zeroes = &raw_co_write_zeroes,

    .bdrv_co_discard      = &raw_co_discard,

    .bdrv_truncate        = &raw_truncate,

    .bdrv_getlength       = &raw_getlength,

    .bdrv_get_info        = &raw_get_info,

    return acb->ret;

}

{

    BDRVSheepdogState *s = bs->opaque;

    SheepdogInode *inode = &s->inode;

    .bdrv_co_writev = sd_co_writev,

    .bdrv_co_flush_to_disk  = sd_co_flush_to_disk,

    .bdrv_co_discard = sd_co_discard,

    .bdrv_snapshot_create   = sd_snapshot_create,

    .bdrv_snapshot_goto     = sd_snapshot_goto,

    .bdrv_co_writev = sd_co_writev,

    .bdrv_co_flush_to_disk  = sd_co_flush_to_disk,

    .bdrv_co_discard = sd_co_discard,

    .bdrv_snapshot_create   = sd_snapshot_create,

    .bdrv_snapshot_goto     = sd_snapshot_goto,

    .bdrv_co_writev = sd_co_writev,

    .bdrv_co_flush_to_disk  = sd_co_flush_to_disk,

    .bdrv_co_discard = sd_co_discard,

    .bdrv_snapshot_create   = sd_snapshot_create,

    .bdrv_snapshot_goto     = sd_snapshot_goto,

    return 0;

}

        int64_t sector_num, int nb_sectors, int *pnum)

{

    /* TODO: Check for too large sector_num (in bdrv_is_allocated or here). */

    .bdrv_reopen_prepare = vdi_reopen_prepare,

    .bdrv_create = vdi_create,

    .bdrv_has_zero_init = bdrv_has_zero_init_1,

    .bdrv_make_empty = vdi_make_empty,

    .bdrv_read = vdi_co_read,

    return NULL;

}

        int64_t sector_num, int nb_sectors, int *pnum)

{

    BDRVVmdkState *s = bs->opaque;

    .bdrv_close                   = vmdk_close,

    .bdrv_create                  = vmdk_create,

    .bdrv_co_flush_to_disk        = vmdk_co_flush,

    .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,

    .bdrv_has_zero_init           = vmdk_has_zero_init,

    return ret;

}

	int64_t sector_num, int nb_sectors, int* n)

{

    BDRVVVFATState* s = bs->opaque;

    .bdrv_read              = vvfat_co_read,

    .bdrv_write             = vvfat_co_write,

};

static void bdrv_vvfat_init(void)

int bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors);

int bdrv_has_zero_init_1(BlockDriverState *bs);

int bdrv_has_zero_init(BlockDriverState *bs);

int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,

                      int *pnum);

int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,

        int64_t sector_num, int nb_sectors);

    int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs,

        int64_t sector_num, int nb_sectors);

        int64_t sector_num, int nb_sectors, int *pnum);

    /*