return drv;

}

BlockDriver **pdrv, Error **errp)

{

BlockDriver *drv;

uint8_t buf[BLOCK_PROBE_BUF_SIZE];

int ret = 0;

return ret;

}

if (ret < 0) {

error_setg_errno(errp, -ret, "Could not read image for determining its "

"format");

goto fail_opts;

}

bs->read_only = !(bs->open_flags & BDRV_O_RDWR);

if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {

assert(bdrv_opt_mem_align(bs) != 0);

assert(bdrv_min_mem_align(bs) != 0);

qemu_opts_del(opts);

return 0;

/* Image format probing */

bs->probed = !drv;

if (!drv && file) {

if (ret < 0) {

goto fail;

}

bs->backing_file[0] = '\0';

bs->backing_format[0] = '\0';

bs->total_sectors = 0;

QDECREF(bs->options);

QDECREF(bs->explicit_options);

bs->options = NULL;

return bs->drv->bdrv_check(bs, res, fix);

}

/*

* Return values:

* 0 - success

*nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;

}

{

return bs->read_only;

}

{

return bs->sg;

}

{

if (bs->backing && bs->backing->bs->encrypted) {

}

return bs->encrypted;

}

{

BdrvChild *backing = bs->backing;

if (backing && backing->bs->encrypted && !backing->bs->valid_key) {

}

return (bs->encrypted && !bs->valid_key);

}

}

ret = bs->drv->bdrv_set_key(bs, key);

if (ret < 0) {

} else if (!bs->valid_key) {

/* call the change callback now, we skipped it on open */

bdrv_parent_cb_change_media(bs, true);

}

return ret;

block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o

block-obj-$(CONFIG_POSIX) += raw-posix.o

block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o

block-obj-y += throttle-groups.o

block-obj-y += nbd.o nbd-client.o sheepdog.o

block-obj-y += crypto.o

common-obj-y += stream.o

common-obj-y += backup.o

iscsi.o-cflags := $(LIBISCSI_CFLAGS)

typedef struct BDRVBlkdebugState {

int state;

int new_state;

QLIST_HEAD(, BlkdebugRule) rules[BLKDBG__MAX];

QSIMPLEQ_HEAD(, BlkdebugRule) active_rules;

}

/* Set request alignment */

error_setg(errp, "Invalid alignment");

ret = -EINVAL;

goto fail_unref;

return inject_error(bs, cb, opaque, rule);

}

cb, opaque);

}

return inject_error(bs, cb, opaque, rule);

}

cb, opaque);

}

bs->full_open_options = opts;

}

static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,

BlockReopenQueue *queue, Error **errp)

{

.bdrv_getlength = blkdebug_getlength,

.bdrv_truncate = blkdebug_truncate,

.bdrv_refresh_filename = blkdebug_refresh_filename,

.bdrv_aio_readv = blkdebug_aio_readv,

.bdrv_aio_writev = blkdebug_aio_writev,

replay_block_event(req->bh, reqid);

}

{

uint64_t reqid = request_id++;

block_request_create(reqid, bs, qemu_coroutine_self());

qemu_coroutine_yield();

return ret;

}

{

uint64_t reqid = request_id++;

block_request_create(reqid, bs, qemu_coroutine_self());

qemu_coroutine_yield();

int64_t offset, int count, BdrvRequestFlags flags)

{

uint64_t reqid = request_id++;

block_request_create(reqid, bs, qemu_coroutine_self());

qemu_coroutine_yield();

.bdrv_close = blkreplay_close,

.bdrv_getlength = blkreplay_getlength,

.bdrv_co_pwrite_zeroes = blkreplay_co_pwrite_zeroes,

.bdrv_co_discard = blkreplay_co_discard,

qemu_iovec_init(&acb->raw_qiov, acb->qiov->niov);

qemu_iovec_clone(&acb->raw_qiov, qiov, acb->buf);

blkverify_aio_cb, acb);

blkverify_aio_cb, acb);

return &acb->common;

}

BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov,

nb_sectors, cb, opaque);

blkverify_aio_cb, acb);

blkverify_aio_cb, acb);

return &acb->common;

}

throttle_group_co_io_limits_intercept(blk, bytes, false);

}

}

int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,

flags |= BDRV_REQ_FUA;

}

}

typedef struct BlkRwCo {

flags | BDRV_REQ_ZERO_WRITE);

}

static void error_callback_bh(void *opaque)

{

struct BlockBackendAIOCB *acb = opaque;

}

}

{

BlockDriverState *bs = blk_bs(blk);

if (bs) {

}

}

int blk_get_max_iov(BlockBackend *blk)

struct bochs_header bochs;

int ret;

if (ret < 0) {

return ret;

}

return -ENOMEM;

}

s->catalog_size * 4);

if (ret < 0) {

goto fail;

return ret;

}

static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)

{

BDRVBochsState *s = bs->opaque;

(s->extent_blocks + s->bitmap_blocks));

/* read in bitmap for current extent */

&bitmap_entry, 1);

if (ret < 0) {

return ret;

qemu_iovec_concat(&local_qiov, qiov, bytes_done, 512);

if (block_offset > 0) {

&local_qiov, 0);

if (ret < 0) {

goto fail;

.instance_size = sizeof(BDRVBochsState),

.bdrv_probe = bochs_probe,

.bdrv_open = bochs_open,

.bdrv_co_preadv = bochs_co_preadv,

.bdrv_close = bochs_close,

};

uint32_t offsets_size, max_compressed_block_size = 1, i;

int ret;

/* read header */

if (ret < 0) {

return ret;

}

return -EINVAL;

}

if (ret < 0) {

return ret;

}

return -ENOMEM;

}

if (ret < 0) {

goto fail;

}

return ret;

}

static inline int cloop_read_block(BlockDriverState *bs, int block_num)

{

BDRVCloopState *s = bs->opaque;

int ret;

uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];

s->compressed_block, bytes);

if (ret != bytes) {

return -1;

.instance_size = sizeof(BDRVCloopState),

.bdrv_probe = cloop_probe,

.bdrv_open = cloop_open,

.bdrv_co_preadv = cloop_co_preadv,

.bdrv_close = cloop_close,

};

trace_commit_start(bs, base, top, s, s->common.co, opaque);

qemu_coroutine_enter(s->common.co, s);

}

BlockDriverState *bs = opaque;

ssize_t ret;

if (ret < 0) {

error_setg_errno(errp, -ret, "Could not read encryption header");

return ret;

QemuOpts *opts,

Error **errp)

{

QCryptoBlockOpenOptions *ret = NULL;

Error *local_err = NULL;

ret = g_new0(QCryptoBlockOpenOptions, 1);

ret->format = format;

if (local_err) {

goto out;

}

switch (format) {

case Q_CRYPTO_BLOCK_FORMAT_LUKS:

visit_type_QCryptoBlockOptionsLUKS_members(

break;

default:

break;

}

if (!local_err) {

}

out:

if (local_err) {

qapi_free_QCryptoBlockOpenOptions(ret);

ret = NULL;

}

return ret;

}

QemuOpts *opts,

Error **errp)

{

QCryptoBlockCreateOptions *ret = NULL;

Error *local_err = NULL;

ret = g_new0(QCryptoBlockCreateOptions, 1);

ret->format = format;

if (local_err) {

goto out;

}

switch (format) {

case Q_CRYPTO_BLOCK_FORMAT_LUKS:

visit_type_QCryptoBlockCreateOptionsLUKS_members(

break;

default:

break;

}

if (!local_err) {

}

out:

if (local_err) {

qapi_free_QCryptoBlockCreateOptions(ret);

ret = NULL;

}

return ret;

}

goto cleanup;

}

ret = 0;

cleanup:

qemu_iovec_reset(&hd_qiov);

qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);

payload_offset + sector_num,

cur_nr_sectors, &hd_qiov);

if (ret < 0) {

qemu_iovec_reset(&hd_qiov);

qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);

payload_offset + sector_num,

cur_nr_sectors, &hd_qiov);

if (ret < 0) {

uint64_t buffer;

int ret;

if (ret < 0) {

return ret;

}

uint32_t buffer;

int ret;

if (ret < 0) {

return ret;

}

}

}

{

int64_t length;

int64_t offset = 0;

uint8_t buffer[515];

offset = length - 511 - 512;

}

length = length < 515 ? length : 515;

if (ret < 0) {

error_setg_errno(errp, -ret, "Failed while reading UDIF trailer");

return ret;

offset += 4;

buffer = g_realloc(buffer, count);

if (ret < 0) {

goto fail;

}

buffer = g_malloc(info_length + 1);

buffer[info_length] = '\0';

if (ret != info_length) {

ret = -EINVAL;

goto fail;

int64_t offset;

int ret;

s->n_chunks = 0;

s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;

ds.max_sectors_per_chunk = 1;

/* locate the UDIF trailer */

if (offset < 0) {

ret = offset;

goto fail;

return ret;

}

static inline int is_sector_in_chunk(BDRVDMGState* s,

uint32_t chunk_num, uint64_t sector_num)

{

case 0x80000005: { /* zlib compressed */

/* we need to buffer, because only the chunk as whole can be

* inflated. */

s->compressed_chunk, s->lengths[chunk]);

if (ret != s->lengths[chunk]) {

return -1;

case 0x80000006: /* bzip2 compressed */

/* we need to buffer, because only the chunk as whole can be

* inflated. */

s->compressed_chunk, s->lengths[chunk]);

if (ret != s->lengths[chunk]) {

return -1;

break;

#endif /* CONFIG_BZIP2 */

case 1: /* copy */

s->uncompressed_chunk, s->lengths[chunk]);

if (ret != s->lengths[chunk]) {

return -1;

.instance_size = sizeof(BDRVDMGState),

.bdrv_probe = dmg_probe,

.bdrv_open = dmg_open,

.bdrv_co_preadv = dmg_co_preadv,

.bdrv_close = dmg_close,

};

#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */

int64_t sector_num,

QEMUIOVector *qiov,

int nb_sectors,

}

}

void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)

{

BlockDriver *drv = bs->drv;

return;

}

/* Take some limits from the children as a default */

if (bs->file) {

bdrv_refresh_limits(bs->file->bs, &local_err);

error_propagate(errp, local_err);

return;

}

} else {

bs->bl.min_mem_alignment = 512;

bs->bl.opt_mem_alignment = getpagesize();

error_propagate(errp, local_err);

return;

}

}

/* Then let the driver override it */

ret = bdrv_get_info(bs, &bdi);

if (ret < 0 || bdi.cluster_size == 0) {

} else {

return bdi.cluster_size;

}

}

typedef struct RwCo {

int64_t offset;

QEMUIOVector *qiov;

bool is_write;

RwCo *rwco = opaque;

if (!rwco->is_write) {

rwco->qiov->size, rwco->qiov,

rwco->flags);

} else {

rwco->qiov->size, rwco->qiov,

rwco->flags);

}

/*

* Process a vectored synchronous request using coroutines

*/

QEMUIOVector *qiov, bool is_write,

BdrvRequestFlags flags)

{

Coroutine *co;

RwCo rwco = {

.offset = offset,

.qiov = qiov,

.is_write = is_write,

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

bdrv_rw_co_entry(&rwco);

} else {

co = qemu_coroutine_create(bdrv_rw_co_entry);

qemu_coroutine_enter(co, &rwco);

/*

* Process a synchronous request using coroutines

*/

int nb_sectors, bool is_write, BdrvRequestFlags flags)

{

QEMUIOVector qiov;

}

qemu_iovec_init_external(&qiov, &iov, 1);

&qiov, is_write, flags);

}

/* return < 0 if error. See bdrv_write() for the return codes */

uint8_t *buf, int nb_sectors)

{

}

/* Return < 0 if error. Important errors are:

-EINVAL Invalid sector number or nb_sectors

-EACCES Trying to write a read-only device

*/

const uint8_t *buf, int nb_sectors)

{

}

int count, BdrvRequestFlags flags)

{

QEMUIOVector qiov;

};

qemu_iovec_init_external(&qiov, &iov, 1);

BDRV_REQ_ZERO_WRITE | flags);

}

*

* Returns < 0 on error, 0 on success. For error codes see bdrv_write().

*/

{

int64_t target_sectors, ret, nb_sectors, sector_num = 0;

BlockDriverState *file;

int n;

sector_num += n;

continue;

}

n << BDRV_SECTOR_BITS, flags);

if (ret < 0) {

error_report("error writing zeroes at sector %" PRId64 ": %s",

}

}

{

int ret;

if (ret < 0) {

return ret;

}

return qiov->size;

}

{

QEMUIOVector qiov;

struct iovec iov = {

}

qemu_iovec_init_external(&qiov, &iov, 1);

}

{

int ret;

if (ret < 0) {

return ret;

}

return qiov->size;

}

{

QEMUIOVector qiov;

struct iovec iov = {

}

qemu_iovec_init_external(&qiov, &iov, 1);

}

/*

*

* Returns 0 on success, -errno in error cases.

*/

{

int ret;

if (ret < 0) {

return ret;

}

if (ret < 0) {

return ret;

}

if (drv->bdrv_co_pwrite_zeroes &&

buffer_is_zero(bounce_buffer, iov.iov_len)) {

ret = bdrv_co_do_pwrite_zeroes(bs, cluster_offset, cluster_bytes, 0);

} else {

/* This does not change the data on the disk, it is not necessary

assert((bytes & (align - 1)) == 0);

assert(!qiov || bytes == qiov->size);

assert((bs->open_flags & BDRV_O_NO_IO) == 0);

/* Handle Copy on Read and associated serialisation */

if (flags & BDRV_REQ_COPY_ON_READ) {

}

max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);

ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0);

} else if (max_bytes > 0) {

QEMUIOVector local_qiov;

/*

* Handle a read request in coroutine context

*/

int64_t offset, unsigned int bytes, QEMUIOVector *qiov,

BdrvRequestFlags flags)

{

BlockDriver *drv = bs->drv;

BdrvTrackedRequest req;

uint8_t *head_buf = NULL;

uint8_t *tail_buf = NULL;

QEMUIOVector local_qiov;

return ret;

}

int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

BdrvRequestFlags flags)

{

return -EINVAL;

}

nb_sectors << BDRV_SECTOR_BITS, qiov, flags);

}

{

}

static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,

int64_t offset, int count, BdrvRequestFlags flags)

int tail = 0;

int max_write_zeroes = MIN_NON_ZERO(bs->bl.max_pwrite_zeroes, INT_MAX);

assert(is_power_of_2(alignment));

head = offset & (alignment - 1);

if (ret == -ENOTSUP) {

/* Fall back to bounce buffer if write zeroes is unsupported */

MAX_WRITE_ZEROES_BOUNCE_BUFFER);

BdrvRequestFlags write_flags = flags & ~BDRV_REQ_ZERO_WRITE;

write_flags &= ~BDRV_REQ_FUA;

need_flush = true;

}

iov.iov_len = num;

if (iov.iov_base == NULL) {

iov.iov_base = qemu_try_blockalign(bs, num);

/* Keep bounce buffer around if it is big enough for all

* all future requests.

*/

qemu_vfree(iov.iov_base);

iov.iov_base = NULL;

}

*/

static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,

BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,

{

BlockDriver *drv = bs->drv;

bool waited;

int64_t start_sector = offset >> BDRV_SECTOR_BITS;

int64_t end_sector = DIV_ROUND_UP(offset + bytes, BDRV_SECTOR_SIZE);

assert(!qiov || bytes == qiov->size);

assert((bs->open_flags & BDRV_O_NO_IO) == 0);

assert(!(flags & ~BDRV_REQ_MASK));

uint8_t *buf = NULL;

QEMUIOVector local_qiov;

struct iovec iov;

unsigned int head_padding_bytes, tail_padding_bytes;

int ret = 0;

memset(buf + head_padding_bytes, 0, zero_bytes);

ret = bdrv_aligned_pwritev(bs, req, offset & ~(align - 1), align,

flags & ~BDRV_REQ_ZERO_WRITE);

if (ret < 0) {

goto fail;

if (bytes >= align) {

/* Write the aligned part in the middle. */

uint64_t aligned_bytes = bytes & ~(align - 1);

NULL, flags);

if (ret < 0) {

goto fail;

bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);

memset(buf, 0, bytes);

&local_qiov, flags & ~BDRV_REQ_ZERO_WRITE);

}

fail:

/*

* Handle a write request in coroutine context

*/

int64_t offset, unsigned int bytes, QEMUIOVector *qiov,

BdrvRequestFlags flags)

{

BdrvTrackedRequest req;

uint8_t *head_buf = NULL;

uint8_t *tail_buf = NULL;

QEMUIOVector local_qiov;

bytes = ROUND_UP(bytes, align);

}

use_local_qiov ? &local_qiov : qiov,

flags);

return ret;

}

int64_t sector_num, int nb_sectors, QEMUIOVector *qiov,

BdrvRequestFlags flags)

{

return -EINVAL;

}

nb_sectors << BDRV_SECTOR_BITS, qiov, flags);

}

int nb_sectors, QEMUIOVector *qiov)

{

}

{

flags &= ~BDRV_REQ_MAY_UNMAP;

}

BDRV_REQ_ZERO_WRITE | flags);

}

/**************************************************************/

/* async I/Os */

QEMUIOVector *qiov, int nb_sectors,

BlockCompletionFunc *cb, void *opaque)

{

cb, opaque, false);

}

QEMUIOVector *qiov, int nb_sectors,

BlockCompletionFunc *cb, void *opaque)

{

cb, opaque, true);

}

typedef struct BlockAIOCBCoroutine {

BlockAIOCB common;

BlockRequest req;

bool is_write;

bool need_bh;

static void coroutine_fn bdrv_co_do_rw(void *opaque)

{

BlockAIOCBCoroutine *acb = opaque;

if (!acb->is_write) {

acb->req.nb_sectors, acb->req.qiov, acb->req.flags);

} else {

acb->req.nb_sectors, acb->req.qiov, acb->req.flags);

}

bdrv_co_complete(acb);

}

int64_t sector_num,

QEMUIOVector *qiov,

int nb_sectors,

Coroutine *co;

BlockAIOCBCoroutine *acb;

acb->need_bh = true;

acb->req.error = -EINPROGRESS;

acb->req.sector = sector_num;

/**************************************************************/

/* Coroutine block device emulation */

static void coroutine_fn bdrv_flush_co_entry(void *opaque)

{

rwco->ret = bdrv_co_flush(rwco->bs);

}

int bdrv_flush(BlockDriverState *bs)

{

Coroutine *co;

.bs = bs,

.ret = NOT_DONE,

};

if (qemu_in_coroutine()) {

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

} else {

AioContext *aio_context = bdrv_get_aio_context(bs);

co = qemu_coroutine_create(bdrv_flush_co_entry);

aio_poll(aio_context, true);

}

}

}

typedef struct DiscardCo {

goto out;

}

while (nb_sectors > 0) {

int ret;

int num = nb_sectors;

/* align request */

}

}

/* limit request size */

return -EINVAL;

}

error_report("iSCSI Error: Write of %d sectors exceeds max_xfer_len "

return -EINVAL;

}

return -EINVAL;

}

error_report("iSCSI Error: Read of %d sectors exceeds max_xfer_len "

return -EINVAL;

}

goto out;

}

bs->total_sectors = sector_lun2qemu(iscsilun->num_blocks, iscsilun);

/* We don't have any emulation for devices other than disks and CD-ROMs, so

* this must be sg ioctl compatible. We force it to be sg, otherwise qemu

* will try to read from the device to guess the image format.

*/

if (iscsilun->type != TYPE_DISK && iscsilun->type != TYPE_ROM) {

}

task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,

memset(iscsilun, 0, sizeof(IscsiLun));

}

static void iscsi_refresh_limits(BlockDriverState *bs, Error **errp)

{

/* We don't actually refresh here, but just return data queried in

* iscsi_open(): iscsi targets don't change their limits. */

IscsiLun *iscsilun = bs->opaque;

if (iscsilun->bl.max_xfer_len) {

max_xfer_len = MIN(max_xfer_len, iscsilun->bl.max_xfer_len);

}

if (iscsilun->lbp.lbpu) {

}

} else {

}

if (iscsilun->bl.max_ws_len < 0xffffffff / iscsilun->block_size) {

} else {

bs->bl.pwrite_zeroes_alignment = iscsilun->block_size;

}

}

/* Note that this will not re-establish a connection with an iSCSI target - it

qemu_iovec_memset(laiocb->qiov, ret, 0,

laiocb->qiov->size - ret);

} else {

}

}

}

return -reply.error;

}

int nbd_client_co_readv(BlockDriverState *bs, int64_t sector_num,

int nb_sectors, QEMUIOVector *qiov)

{

static void nbd_refresh_limits(BlockDriverState *bs, Error **errp)

{

}

static int nbd_co_discard(BlockDriverState *bs, int64_t sector_num,

int ret;

space += s->prealloc_size;

if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {

s->data_end << BDRV_SECTOR_BITS,

space << BDRV_SECTOR_BITS, 0);

} else {

if (off + to_write > s->header_size) {

to_write = s->header_size - off;

}

to_write);

if (ret < 0) {

qemu_co_mutex_unlock(&s->lock);

qemu_iovec_reset(&hd_qiov);

qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);

if (ret < 0) {

break;

}

qemu_iovec_reset(&hd_qiov);

qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes);

if (ret < 0) {

break;

}

}

if (flush_bat) {

if (ret < 0) {

res->check_errors++;

return ret;

if (size > s->header_size) {

size = s->header_size;

}

}

static int parallels_open(BlockDriverState *bs, QDict *options, int flags,

Error *local_err = NULL;

char *buf;

if (ret < 0) {

goto fail;

}

s->header_size = size;

}

if (ret < 0) {

goto fail;

}

void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f,

ImageInfoSpecific *info_spec)

{

QObject *obj, *data;

assert(qobject_type(obj) == QTYPE_QDICT);

data = qdict_get(qobject_to_qdict(obj), "data");

dump_qobject(func_fprintf, f, 1, data);

}

void bdrv_image_info_dump(fprintf_function func_fprintf, void *f,

int ret;

QCowHeader header;

if (ret < 0) {

goto fail;

}

goto fail;

}

}

s->cluster_bits = header.cluster_bits;

s->cluster_size = 1 << s->cluster_bits;

goto fail;

}

s->l1_size * sizeof(uint64_t));

if (ret < 0) {

goto fail;

ret = -EINVAL;

goto fail;

}

bs->backing_file, len);

if (ret < 0) {

goto fail;

/* update the L1 entry */

s->l1_table[l1_index] = l2_offset;

tmp = cpu_to_be64(l2_offset);

s->l1_table_offset + l1_index * sizeof(tmp),

&tmp, sizeof(tmp)) < 0)

return 0;

l2_table = s->l2_cache + (min_index << s->l2_bits);

if (new_l2_table) {

memset(l2_table, 0, s->l2_size * sizeof(uint64_t));

s->l2_size * sizeof(uint64_t)) < 0)

return 0;

} else {

s->l2_size * sizeof(uint64_t)) !=

s->l2_size * sizeof(uint64_t))

return 0;

cluster_offset = (cluster_offset + s->cluster_size - 1) &

~(s->cluster_size - 1);

/* write the cluster content */

s->cluster_size) !=

s->cluster_size)

return -1;

errno = EIO;

return -1;

}

cluster_offset + i * 512,

s->cluster_data, 512) != 512)

return -1;

/* update L2 table */

tmp = cpu_to_be64(cluster_offset);

l2_table[l2_index] = tmp;

&tmp, sizeof(tmp)) < 0)

return 0;

}

if (s->cluster_cache_offset != coffset) {

csize = cluster_offset >> (63 - s->cluster_bits);

csize &= (s->cluster_size - 1);

if (ret != csize)

return -1;

if (decompress_buffer(s->cluster_cache, s->cluster_size,

hd_iov.iov_len = n * 512;

qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);

qemu_co_mutex_unlock(&s->lock);

qemu_co_mutex_lock(&s->lock);

if (ret < 0) {

goto fail;

hd_iov.iov_len = n * 512;

qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);

qemu_co_mutex_unlock(&s->lock);

(cluster_offset >> 9) + index_in_cluster,

n, &hd_qiov);

qemu_co_mutex_lock(&s->lock);

hd_iov.iov_len = n * 512;

qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);

qemu_co_mutex_unlock(&s->lock);

(cluster_offset >> 9) + index_in_cluster,

n, &hd_qiov);

qemu_co_mutex_lock(&s->lock);

int ret;

memset(s->l1_table, 0, l1_length);

l1_length) < 0)

return -1;

ret = bdrv_truncate(bs->file->bs, s->l1_table_offset + l1_length);

return 0;

}

/* XXX: put compressed sectors first, then all the cluster aligned

tables to avoid losing bytes in alignment */

static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,

if (ret != Z_STREAM_END || out_len >= s->cluster_size) {

/* could not compress: write normal cluster */

if (ret < 0) {

goto fail;

}

}

cluster_offset &= s->cluster_offset_mask;

if (ret < 0) {

goto fail;

}

BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);

}

qcow2_cache_get_table_addr(bs, c, i), s->cluster_size);

if (ret < 0) {

return ret;

BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);

}

qcow2_cache_get_table_addr(bs, c, i),

s->cluster_size);

if (ret < 0) {

BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);

for(i = 0; i < s->l1_size; i++)

new_l1_table[i] = cpu_to_be64(new_l1_table[i]);

new_l1_table, new_l1_size2);

if (ret < 0)

goto fail;

/* set new table */

BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);

stq_be_p(data + 4, new_l1_table_offset);

data, sizeof(data));

if (ret < 0) {

goto fail;

}

BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);

s->l1_table_offset + 8 * l1_start_index,

buf, sizeof(buf));

if (ret < 0) {

}

BLKDBG_EVENT(bs->file, BLKDBG_COW_WRITE);

bytes, &qiov, 0);

if (ret < 0) {

goto out;

sector_offset = coffset & 511;

csize = nb_csectors * 512 - sector_offset;

BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);

nb_csectors);

if (ret < 0) {

return ret;

(void **)&l2_table);

} else {

/* load inactive L2 tables from disk */

(void *)l2_table, s->cluster_sectors);

}

if (ret < 0) {

goto fail;

}

if (ret < 0) {

if (!preallocated) {

qcow2_free_clusters(bs, offset, s->cluster_size,

goto fail;

}

(void *)l2_table, s->cluster_sectors);

if (ret < 0) {

goto fail;

l1_table = g_realloc(l1_table, l1_sectors * BDRV_SECTOR_SIZE);

s->snapshots[i].l1_table_offset / BDRV_SECTOR_SIZE,

(void *)l1_table, l1_sectors);

if (ret < 0) {

goto fail;

}

BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);

s->refcount_table, refcount_table_size2);

if (ret < 0) {

goto fail;

if (refcount_table_index < s->refcount_table_size) {

uint64_t data64 = cpu_to_be64(new_block);

BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);

s->refcount_table_offset + refcount_table_index * sizeof(uint64_t),

&data64, sizeof(data64));

if (ret < 0) {

/* Write refcount blocks to disk */

BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS);

blocks_clusters * s->cluster_size);

g_free(new_blocks);

new_blocks = NULL;

}

BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);

table_size * sizeof(uint64_t));

if (ret < 0) {

goto fail_table;

uint64_t d64;

uint32_t d32;

} data;

BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);

offsetof(QCowHeader, refcount_table_offset),

&data, sizeof(data));

if (ret < 0) {

}

l1_allocated = true;

if (ret < 0) {

goto fail;

}

cpu_to_be64s(&l1_table[i]);

}

l1_table, l1_size2);

for (i = 0; i < l1_size; i++) {

l2_size = s->l2_size * sizeof(uint64_t);

l2_table = g_malloc(l2_size);

if (ret < 0) {

fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");

res->check_errors++;

res->check_errors++;

goto fail;

}

if (ret < 0) {

fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");

res->check_errors++;

}

}

s->l2_size * sizeof(uint64_t));

if (ret < 0) {

fprintf(stderr, "ERROR: Could not read L2 table: %s\n",

goto fail;

}

s->cluster_size);

if (ret < 0) {

fprintf(stderr, "ERROR: Could not write L2 table: %s\n",

on_disk_refblock = (void *)((char *) *refcount_table +

refblock_index * s->cluster_size);

on_disk_refblock, s->cluster_sectors);

if (ret < 0) {

fprintf(stderr, "ERROR writing refblock: %s\n", strerror(-ret));

}

assert(reftable_size < INT_MAX / sizeof(uint64_t));

reftable_size * sizeof(uint64_t));

if (ret < 0) {

fprintf(stderr, "ERROR writing reftable: %s\n", strerror(-ret));

}

/* Enter new reftable into the image header */

&reftable_offset_and_clusters,

sizeof(reftable_offset_and_clusters));

if (ret < 0) {

return -ENOMEM;

}

if (ret < 0) {

g_free(l1);

return ret;

return ret;

}

if (ret < 0) {

error_setg_errno(errp, -ret, "Failed to write refblock");

return ret;

cpu_to_be64s(&new_reftable[i]);

}

new_reftable_size * sizeof(uint64_t));

for (i = 0; i < new_reftable_size; i++) {

for(i = 0; i < s->nb_snapshots; i++) {

/* Read statically sized part of the snapshot header */

offset = align_offset(offset, 8);

if (ret < 0) {

goto fail;

}

name_size = be16_to_cpu(h.name_size);

/* Read extra data */

MIN(sizeof(extra), extra_data_size));

if (ret < 0) {

goto fail;

/* Read snapshot ID */

sn->id_str = g_malloc(id_str_size + 1);

if (ret < 0) {

goto fail;

}

/* Read snapshot name */

sn->name = g_malloc(name_size + 1);

if (ret < 0) {

goto fail;

}

h.name_size = cpu_to_be16(name_size);

offset = align_offset(offset, 8);

if (ret < 0) {

goto fail;

}

offset += sizeof(h);

if (ret < 0) {

goto fail;

}

offset += sizeof(extra);

if (ret < 0) {

goto fail;

}

offset += id_str_size;

if (ret < 0) {

goto fail;

}

header_data.nb_snapshots = cpu_to_be32(s->nb_snapshots);

header_data.snapshots_offset = cpu_to_be64(snapshots_offset);

&header_data, sizeof(header_data));

if (ret < 0) {

goto fail;

goto fail;

}

s->l1_size * sizeof(uint64_t));

if (ret < 0) {

goto fail;

goto fail;

}

sn_l1_table, sn_l1_bytes);

if (ret < 0) {

goto fail;

goto fail;

}

cur_l1_bytes);

if (ret < 0) {

goto fail;

return -ENOMEM;

}

new_l1_table, new_l1_bytes);

if (ret < 0) {

error_setg(errp, "Failed to read l1 table for snapshot");

printf("attempting to read extended header in offset %lu\n", offset);

#endif

if (ret < 0) {

error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "

"pread fail from offset %" PRIu64, offset);

sizeof(bs->backing_format));

return 2;

}

if (ret < 0) {

error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "

"Could not read format name");

case QCOW2_EXT_MAGIC_FEATURE_TABLE:

if (p_feature_table != NULL) {

void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));

if (ret < 0) {

error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "

"Could not read table");

uext->len = ext.len;

QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);

if (ret < 0) {

error_setg_errno(errp, -ret, "ERROR: unknown extension: "

"Could not read data");

}

val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);

&val, sizeof(val));

if (ret < 0) {

return ret;

uint64_t ext_end;

uint64_t l1_vm_state_index;

if (ret < 0) {

error_setg_errno(errp, -ret, "Could not read qcow2 header");

goto fail;

if (header.header_length > sizeof(header)) {

s->unknown_header_fields_size = header.header_length - sizeof(header);

s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);

s->unknown_header_fields_size);

if (ret < 0) {

error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "

goto fail;

}

}

s->l2_bits = s->cluster_bits - 3; /* L2 is always one cluster */

ret = -ENOMEM;

goto fail;

}

s->l1_size * sizeof(uint64_t));

if (ret < 0) {

error_setg_errno(errp, -ret, "Could not read L1 table");

ret = -EINVAL;

goto fail;

}

bs->backing_file, len);

if (ret < 0) {

error_setg_errno(errp, -ret, "Could not read backing file name");

{

BDRVQcow2State *s = bs->opaque;

bs->bl.pwrite_zeroes_alignment = s->cluster_size;

}

BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);

qemu_co_mutex_unlock(&s->lock);

&local_qiov, 0);

qemu_co_mutex_lock(&s->lock);

BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);

qemu_co_mutex_unlock(&s->lock);

cluster_offset + offset_in_cluster,

cur_bytes, &hd_qiov, 0);

qemu_co_mutex_lock(&s->lock);

BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);

trace_qcow2_writev_data(qemu_coroutine_self(),

cluster_offset + offset_in_cluster);

cluster_offset + offset_in_cluster,

cur_bytes, &hd_qiov, 0);

qemu_co_mutex_lock(&s->lock);

}

/* Write the new header */

if (ret < 0) {

goto fail;

}

*/

if (host_offset != 0) {

uint8_t data = 0;

&data, 1);

if (ret < 0) {

return ret;

/* write updated header.size */

offset = cpu_to_be64(offset);

&offset, sizeof(uint64_t));

if (ret < 0) {

return ret;

return 0;

}

/* XXX: put compressed sectors first, then all the cluster aligned

tables to avoid losing bytes in alignment */

static int qcow2_write_compressed(BlockDriverState *bs, int64_t sector_num,

if (ret != Z_STREAM_END || out_len >= s->cluster_size) {

/* could not compress: write normal cluster */

if (ret < 0) {

goto fail;

}

}

BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);

if (ret < 0) {

goto fail;

}

/* After this call, neither the in-memory nor the on-disk refcount

* information accurately describe the actual references */

l1_clusters * s->cluster_size, 0);

if (ret < 0) {

goto fail_broken_refcounts;

* overwrite parts of the existing refcount and L1 table, which is not

* an issue because the dirty flag is set, complete data loss is in fact

* desired and partial data loss is consequently fine as well */

(2 + l1_clusters) * s->cluster_size, 0);

/* This call (even if it failed overall) may have overwritten on-disk

* refcount structures; in that case, the in-memory refcount information

/* "Create" an empty reftable (one cluster) directly after the image

* header and an empty L1 table three clusters after the image header;

* the cluster between those two will be used as the first refblock */

&l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));

if (ret < 0) {

goto fail_broken_refcounts;

/* Enter the first refblock into the reftable */

rt_entry = cpu_to_be64(2 * s->cluster_size);

&rt_entry, sizeof(rt_entry));

if (ret < 0) {

goto fail_broken_refcounts;

read_table_cb->iov.iov_len = s->header.cluster_size * s->header.table_size,

qemu_iovec_init_external(qiov, &read_table_cb->iov, 1);

qiov->size / BDRV_SECTOR_SIZE,

qed_read_table_cb, read_table_cb);

}

/* Adjust for offset into table */

offset += start * sizeof(uint64_t);

&write_table_cb->qiov,

write_table_cb->qiov.size / BDRV_SECTOR_SIZE,

qed_write_table_cb, write_table_cb);

int ret;

qed_header_cpu_to_le(&s->header, &le);

if (ret != sizeof(le)) {

return ret;

}

/* Update header */

qed_header_cpu_to_le(&s->header, (QEDHeader *)write_header_cb->buf);

write_header_cb->nsectors, qed_write_header_cb,

write_header_cb);

}

write_header_cb->iov.iov_len = len;

qemu_iovec_init_external(&write_header_cb->qiov, &write_header_cb->iov, 1);

qed_write_header_read_cb, write_header_cb);

}

*

* The string is NUL-terminated.

*/

char *buf, size_t buflen)

{

int ret;

s->bs = bs;

QSIMPLEQ_INIT(&s->allocating_write_reqs);

if (ret < 0) {

return ret;

}

return -EINVAL;

}

s->header.backing_filename_size, bs->backing_file,

sizeof(bs->backing_file));

if (ret < 0) {

qemu_iovec_concat(*backing_qiov, qiov, 0, size);

BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);

*backing_qiov, size / BDRV_SECTOR_SIZE, cb, opaque);

}

}

BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE);

&copy_cb->qiov, copy_cb->qiov.size / BDRV_SECTOR_SIZE,

qed_copy_from_backing_file_cb, copy_cb);

}

}

BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO);

&acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,

next_fn, acb);

}

}

BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);

&acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,

qed_aio_next_io, acb);

return;

}

/* Write new header */

g_free(buffer);

if (ret == 0) {

memcpy(&s->header, &new_header, sizeof(new_header));

continue;

}

QLIST_FOREACH(item, &version->items, next) {

acb->qiov, acb->nb_sectors, quorum_rewrite_aio_cb,

acb);

}

}

for (i = 0; i < s->num_children; i++) {

&acb->qcrs[i].qiov, acb->nb_sectors,

quorum_aio_cb, &acb->qcrs[i]);

}

qemu_iovec_clone(&acb->qcrs[acb->child_iter].qiov, acb->qiov,

acb->qcrs[acb->child_iter].buf);

acb->qcrs[acb->child_iter].aiocb =

&acb->qcrs[acb->child_iter].qiov, acb->nb_sectors,

quorum_aio_cb, &acb->qcrs[acb->child_iter]);

int i;

for (i = 0; i < s->num_children; i++) {

qiov, nb_sectors, &quorum_aio_cb,

&acb->qcrs[i]);

}

/* For SCSI generic devices the alignment is not really used.

With buffered I/O, we don't have any restrictions. */

if (bdrv_is_sg(bs) || !s->needs_alignment) {

s->buf_align = 1;

return;

}

s->buf_align = 0;

/* Let's try to use the logical blocksize for the alignment. */

}

#ifdef CONFIG_XFS

if (s->is_xfs) {

struct dioattr da;

if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {

/* The kernel returns wrong information for d_mem */

/* s->buf_align = da.d_mem; */

}

qemu_vfree(buf);

}

size_t align;

buf = qemu_memalign(s->buf_align, max_align);

for (align = 512; align <= max_align; align <<= 1) {

if (raw_is_io_aligned(fd, buf, align)) {

break;

}

}

qemu_vfree(buf);

}

}

}

if (!fstat(s->fd, &st)) {

if (S_ISBLK(st.st_mode)) {

int ret = hdev_get_max_transfer_length(s->fd);

}

}

}

}

}

{

BDRVRawState *s = bs->opaque;

DWORD sectorsPerCluster, freeClusters, totalClusters, count;

BOOL status;

if (s->type == FTYPE_CD) {

return;

}

if (s->type == FTYPE_HARDDISK) {

status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,

NULL, 0, &dg, sizeof(dg), &count, NULL);

if (status != 0) {

return;

}

/* try GetDiskFreeSpace too */

GetDiskFreeSpace(s->drive_path, &sectorsPerCluster,

&dg.Geometry.BytesPerSector,

&freeClusters, &totalClusters);

}

}

win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));

}

ret = 0;

fail:

qemu_opts_del(opts);

.bdrv_needs_filename = true,

.bdrv_parse_filename = raw_parse_filename,

.bdrv_file_open = raw_open,

.bdrv_close = raw_close,

.bdrv_create = raw_create,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

/* BlockDriver implementation for "raw"

*

* Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com>

* Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com>

*

int nb_sectors, QEMUIOVector *qiov)

{

BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);

}

static int coroutine_fn

}

BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);

nb_sectors * BDRV_SECTOR_SIZE, qiov, flags);

fail:

int64_t offset, int count,

BdrvRequestFlags flags)

{

}

static int coroutine_fn raw_co_discard(BlockDriverState *bs,

return bdrv_get_info(bs->file->bs, bdi);

}

static int raw_truncate(BlockDriverState *bs, int64_t offset)

{

return bdrv_truncate(bs->file->bs, offset);

.bdrv_getlength = &raw_getlength,

.has_variable_length = true,

.bdrv_get_info = &raw_get_info,

.bdrv_probe_blocksizes = &raw_probe_blocksizes,

.bdrv_probe_geometry = &raw_probe_geometry,

.bdrv_media_changed = &raw_media_changed,

logout("\n");

if (ret < 0) {

goto fail;

}

goto fail;

}

bmap_size);

if (ret < 0) {

goto fail_free_bmap;

qemu_iovec_reset(&local_qiov);

qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);

&local_qiov, 0);

}

logout("%u bytes read\n", n_bytes);

* acquire the lock and thus the padded cluster is written before

* the other coroutines can write to the affected area. */

qemu_co_mutex_lock(&s->write_lock);

qemu_co_mutex_unlock(&s->write_lock);

} else {

uint64_t data_offset = s->header.offset_data +

qemu_iovec_reset(&local_qiov);

qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);

&local_qiov, 0);

}

assert(VDI_IS_ALLOCATED(bmap_first));

*header = s->header;

vdi_header_to_le(header);

g_free(block);

block = NULL;

base = ((uint8_t *)&s->bmap[0]) + bmap_first * SECTOR_SIZE;

logout("will write %u block map sectors starting from entry %u\n",

n_sectors, bmap_first);

}

return ret;

offset = log->offset + read;

if (ret < 0) {

goto exit;

}

}

offset = log->offset + read;

if (ret < 0) {

goto exit;

}

/* full */

break;

}

VHDX_LOG_SECTOR_SIZE);

if (ret < 0) {

goto exit;

/* count is only > 1 if we are writing zeroes */

for (i = 0; i < count; i++) {

VHDX_LOG_SECTOR_SIZE);

if (ret < 0) {

goto exit;

if (i == 0 && leading_length) {

/* partial sector at the front of the buffer */

VHDX_LOG_SECTOR_SIZE);

if (ret < 0) {

goto exit;

sector_write = merged_sector;

} else if (i == sectors - 1 && trailing_length) {

/* partial sector at the end of the buffer */

file_offset,

merged_sector + trailing_length,

VHDX_LOG_SECTOR_SIZE - trailing_length);

* and then update the header checksum. Header is converted to proper

* endianness before being written to the specified file offset

*/

uint64_t offset, bool read)

{

uint8_t *buffer = NULL;

int ret;

VHDXHeader *header_le;

buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE);

if (read) {

/* if true, we can't assume the extra reserved bytes are 0 */

if (ret < 0) {

goto exit;

}

vhdx_header_le_export(hdr, header_le);

vhdx_update_checksum(buffer, VHDX_HEADER_SIZE,

offsetof(VHDXHeader, checksum));

exit:

qemu_vfree(buffer);

inactive_header->log_guid = *log_guid;

}

if (ret < 0) {

goto exit;

}

/* We have to read the whole VHDX_HEADER_SIZE instead of

* sizeof(VHDXHeader), because the checksum is over the whole

* region */

VHDX_HEADER_SIZE);

if (ret < 0) {

goto fail;

}

}

VHDX_HEADER_SIZE);

if (ret < 0) {

goto fail;

* whole block */

buffer = qemu_blockalign(bs, VHDX_HEADER_BLOCK_SIZE);

VHDX_HEADER_BLOCK_SIZE);

if (ret < 0) {

goto fail;

buffer = qemu_blockalign(bs, VHDX_METADATA_TABLE_MAX_SIZE);

VHDX_METADATA_TABLE_MAX_SIZE);

if (ret < 0) {

goto exit;

goto exit;

}

s->metadata_entries.file_parameters_entry.offset

+ s->metadata_rt.file_offset,

&s->params,

/* determine virtual disk size, logical sector size,

* and phys sector size */

s->metadata_entries.virtual_disk_size_entry.offset

+ s->metadata_rt.file_offset,

&s->virtual_disk_size,

if (ret < 0) {

goto exit;

}

s->metadata_entries.logical_sector_size_entry.offset

+ s->metadata_rt.file_offset,

&s->logical_sector_size,

if (ret < 0) {

goto exit;

}

s->metadata_entries.phys_sector_size_entry.offset

+ s->metadata_rt.file_offset,

&s->physical_sector_size,

QLIST_INIT(&s->regions);

/* validate the file signature */

if (ret < 0) {

goto fail;

}

goto fail;

}

if (ret < 0) {

goto fail;

}

break;

case PAYLOAD_BLOCK_FULLY_PRESENT:

qemu_co_mutex_unlock(&s->lock);

sinfo.file_offset >> BDRV_SECTOR_BITS,

sinfo.sectors_avail, &hd_qiov);

qemu_co_mutex_lock(&s->lock);

}

/* block exists, so we can just overwrite it */

qemu_co_mutex_unlock(&s->lock);

sinfo.file_offset >> BDRV_SECTOR_BITS,

sectors_to_write, &hd_qiov);

qemu_co_mutex_lock(&s->lock);

* There are 2 headers, and the highest sequence number will represent

* the active header

*/

uint32_t log_size)

{

int ret = 0;

VHDXHeader *hdr = NULL;

vhdx_guid_generate(&hdr->file_write_guid);

vhdx_guid_generate(&hdr->data_write_guid);

if (ret < 0) {

goto exit;

}

hdr->sequence_number++;

if (ret < 0) {

goto exit;

}

* The first 64KB of the Metadata section is reserved for the metadata

* header and entries; beyond that, the metadata items themselves reside.

*/

uint64_t image_size,

uint32_t block_size,

uint32_t sector_size,

VHDX_META_FLAGS_IS_VIRTUAL_DISK;

vhdx_metadata_entry_le_export(&md_table_entry[4]);

if (ret < 0) {

goto exit;

}

if (ret < 0) {

goto exit;

}

* Fixed images: default state of the BAT is fully populated, with

* file offsets and state PAYLOAD_BLOCK_FULLY_PRESENT.

*/

uint64_t image_size, VHDXImageType type,

bool use_zero_blocks, uint64_t file_offset,

uint32_t length)

if (type == VHDX_TYPE_DYNAMIC) {

/* All zeroes, so we can just extend the file - the end of the BAT

* is the furthest thing we have written yet */

if (ret < 0) {

goto exit;

}

} else if (type == VHDX_TYPE_FIXED) {

if (ret < 0) {

goto exit;

}

if (type == VHDX_TYPE_FIXED ||

use_zero_blocks ||

/* for a fixed file, the default BAT entry is not zero */

s->bat = g_try_malloc0(length);

if (length && s->bat == NULL) {

sinfo.file_offset = data_file_offset +

(sector_num << s->logical_sector_size_bits);

sinfo.file_offset = ROUND_UP(sinfo.file_offset, MiB);

block_state);

cpu_to_le64s(&s->bat[sinfo.bat_idx]);

sector_num += s->sectors_per_block;

}

if (ret < 0) {

goto exit;

}

* to create the BAT itself, we will also cause the BAT to be

* created.

*/

uint64_t image_size,

uint32_t block_size,

uint32_t sector_size,

/* The region table gives us the data we need to create the BAT,

* so do that now */

bat_file_offset, bat_length);

if (ret < 0) {

goto exit;

}

/* Now write out the region headers to disk */

if (ret < 0) {

goto exit;

}

if (ret < 0) {

goto exit;

}

/* Creates (B),(C) */

if (ret < 0) {

goto delete_and_exit;

}

/* Creates (D),(E),(G) explicitly. (F) created as by-product */

log_size, use_zero_blocks, image_type,

&metadata_offset);

if (ret < 0) {

}

/* Creates (H) */

metadata_offset, image_type);

if (ret < 0) {

goto delete_and_exit;

int ret;

desc = g_malloc0(DESC_SIZE);

if (ret < 0) {

g_free(desc);

return 0;

desc = g_malloc0(DESC_SIZE);

tmp_desc = g_malloc0(DESC_SIZE);

if (ret < 0) {

goto out;

}

pstrcat(desc, DESC_SIZE, tmp_desc);

}

out:

g_free(desc);

int ret;

desc = g_malloc0(DESC_SIZE + 1);

if (ret < 0) {

goto out;

}

return -ENOMEM;

}

extent->l1_table_offset,

extent->l1_table,

l1_size);

ret = -ENOMEM;

goto fail_l1;

}

extent->l1_backup_table_offset,

extent->l1_backup_table,

l1_size);

VMDK3Header header;

VmdkExtent *extent;

if (ret < 0) {

error_setg_errno(errp, -ret,

"Could not read header from file '%s'",

static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,

QDict *options, Error **errp);

{

int64_t size;

char *buf;

int ret;

if (size < 0) {

error_setg_errno(errp, -size, "Could not access file");

return NULL;

int64_t l1_backup_offset = 0;

bool compressed;

if (ret < 0) {

error_setg_errno(errp, -ret,

"Could not read header from file '%s'",

if (header.capacity == 0) {

uint64_t desc_offset = le64_to_cpu(header.desc_offset);

if (desc_offset) {

if (!buf) {

return -EINVAL;

}

} QEMU_PACKED eos_marker;

} QEMU_PACKED footer;

bs->file->bs->total_sectors * 512 - 1536,

&footer, sizeof(footer));

if (ret < 0) {

extent->flat_start_offset = flat_offset << 9;

} else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {

/* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/

if (!buf) {

ret = -EINVAL;

} else {

BDRVVmdkState *s = bs->opaque;

uint32_t magic;

if (!buf) {

return -EINVAL;

}

/* Read backing data before skip range */

if (skip_start_bytes > 0) {

if (bs->backing) {

skip_start_bytes);

if (ret < 0) {

ret = VMDK_ERROR;

goto exit;

}

}

skip_start_bytes);

if (ret < 0) {

ret = VMDK_ERROR;

/* Read backing data after skip range */

if (skip_end_bytes < cluster_bytes) {

if (bs->backing) {

whole_grain + skip_end_bytes,

cluster_bytes - skip_end_bytes);

if (ret < 0) {

goto exit;

}

}

whole_grain + skip_end_bytes,

cluster_bytes - skip_end_bytes);

if (ret < 0) {

{

offset = cpu_to_le32(offset);

/* update L2 table */

((int64_t)m_data->l2_offset * 512)

+ (m_data->l2_index * sizeof(offset)),

&offset, sizeof(offset)) < 0) {

/* update backup L2 table */

if (extent->l1_backup_table_offset != 0) {

m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];

((int64_t)m_data->l2_offset * 512)

+ (m_data->l2_index * sizeof(offset)),

&offset, sizeof(offset)) < 0) {

}

}

l2_table = extent->l2_cache + (min_index * extent->l2_size);

(int64_t)l2_offset * 512,

l2_table,

extent->l2_size * sizeof(uint32_t)

}

write_offset = cluster_offset + offset_in_cluster,

&local_qiov, 0);

write_end_sector = DIV_ROUND_UP(write_offset + n_bytes, BDRV_SECTOR_SIZE);

if (!extent->compressed) {

cluster_offset + offset_in_cluster, bytes,

qiov, 0);

if (ret < 0) {

buf_bytes = cluster_bytes * 2;

cluster_buf = g_malloc(buf_bytes);

uncomp_buf = g_malloc(cluster_bytes);

cluster_offset,

cluster_buf, buf_bytes);

if (ret < 0) {

qemu_iovec_reset(&local_qiov);

qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);

&local_qiov, 0);

if (ret < 0) {

goto fail;

goto fail;

}

if (ret < 0) {

error_setg(errp, "Unable to read VHD header");

goto fail;

}

/* If a fixed disk, the footer is found only at the end of the file */

HEADER_SIZE);

if (ret < 0) {

goto fail;

}

if (disk_type == VHD_DYNAMIC) {

HEADER_SIZE);

if (ret < 0) {

error_setg(errp, "Error reading dynamic VHD header");

s->bat_offset = be64_to_cpu(dyndisk_header->table_offset);

pagetable_size);

if (ret < 0) {

error_setg(errp, "Error reading pagetable");

s->last_bitmap_offset = bitmap_offset;

memset(bitmap, 0xff, s->bitmap_size);

}

return block_offset;

BDRVVPCState *s = bs->opaque;

int64_t offset = s->free_data_block_offset;

if (ret < 0)

return ret;

/* Initialize the block's bitmap */

memset(bitmap, 0xff, s->bitmap_size);

s->bitmap_size);

if (ret < 0) {

return ret;

/* Write BAT entry to disk */

bat_offset = s->bat_offset + (4 * index);

bat_value = cpu_to_be32(s->pagetable[index]);

if (ret < 0)

goto fail;

QEMUIOVector local_qiov;

if (be32_to_cpu(footer->type) == VHD_FIXED) {

}

qemu_co_mutex_lock(&s->lock);

qemu_iovec_reset(&local_qiov);

qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);

&local_qiov, 0);

if (ret < 0) {

goto fail;

QEMUIOVector local_qiov;

if (be32_to_cpu(footer->type) == VHD_FIXED) {

}

qemu_co_mutex_lock(&s->lock);

qemu_iovec_reset(&local_qiov);

qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);

&local_qiov, 0);

if (ret < 0) {

goto fail;

unsigned int current_cluster;

/* write support */

char* qcow_filename;

void* fat2;

char* used_clusters;

array_t commits;

static BDRVVVFATState *vvv = NULL;

#endif

static int is_consistent(BDRVVVFATState *s);

static QemuOptsList runtime_opts = {

s->current_cluster=0xffffffff;

/* read only is the default for safety */

s->qcow_filename = NULL;

s->fat2 = NULL;

s->downcase_short_names = 1;

s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);

if (qemu_opt_get_bool(opts, "rw", false)) {

if (ret < 0) {

goto fail;

}

}

bs->total_sectors = cyls * heads * secs;

if (init_directories(s, dirname, heads, secs, errp)) {

return ret;

}

static inline void vvfat_close_current_file(BDRVVVFATState *s)

{

if(s->current_mapping) {

return -1;

if (s->qcow) {

int n;

return -1;

}

i += n - 1;

int was_modified = 0;

int i, dummy;

return was_modified;

}

vvfat_close_current_file(s);

for (i = 0; i < s->sectors_per_cluster; i++) {

return -1;

}

return -2;

}

}

return ret;

}

}

memset(s->used_clusters, 0, sector2cluster(s, s->sector_count));

static void write_target_close(BlockDriverState *bs) {

BDRVVVFATState* s = *((BDRVVVFATState**) bs->opaque);

g_free(s->qcow_filename);

}

.bdrv_close = write_target_close,

};

{

BlockDriver *bdrv_qcow = NULL;

BlockDriverState *backing;

QemuOpts *opts = NULL;

options = qdict_new();

qdict_put(options, "driver", qstring_from_str("qcow"));

if (!s->qcow) {

ret = -EINVAL;

goto err;

.bdrv_parse_filename = vvfat_parse_filename,

.bdrv_file_open = vvfat_open,

.bdrv_close = vvfat_close,

.bdrv_co_preadv = vvfat_co_preadv,

void qmp_blockdev_add(BlockdevOptions *options, Error **errp)

{

BlockDriverState *bs;

BlockBackend *blk = NULL;

QObject *obj;

QDict *qdict;

Error *local_err = NULL;

}

}

if (local_err) {

error_propagate(errp, local_err);

goto fail;

}

qdict = qobject_to_qdict(obj);

qdict_flatten(qdict);

}

fail:

}

void qmp_x_blockdev_del(bool has_id, const char *id,

void qapi_free_UserDefOne(UserDefOne *obj)

{

Visitor *v;

if (!obj) {

return;

}

visit_type_UserDefOne(v, NULL, &obj, NULL);

}

void qapi_free_UserDefOneList(UserDefOneList *obj)

{

Visitor *v;

if (!obj) {

return;

}

visit_type_UserDefOneList(v, NULL, &obj, NULL);

}

=== scripts/qapi-visit.py ===

}

visit_check_struct(v, &err);

out_obj:

if (err && visit_is_input(v)) {

qapi_free_UserDefOne(*obj);

*obj = NULL;

}

}

if (err && visit_is_input(v)) {

qapi_free_UserDefOneList(*obj);

*obj = NULL;

static void qmp_marshal_output_UserDefOne(UserDefOne *ret_in, QObject **ret_out, Error **errp)

{

Error *err = NULL;

Visitor *v;

visit_type_UserDefOne(v, "unused", &ret_in, &err);

}

error_propagate(errp, err);

visit_type_UserDefOne(v, "unused", &ret_in, NULL);

}

static void qmp_marshal_my_command(QDict *args, QObject **ret, Error **errp)

{

Error *err = NULL;

UserDefOne *retval;

Visitor *v;

UserDefOneList *arg1 = NULL;

visit_start_struct(v, NULL, NULL, 0, &err);

if (err) {

goto out;

if (!err) {

visit_check_struct(v, &err);

}

if (err) {

goto out;

}

out:

error_propagate(errp, err);

visit_start_struct(v, NULL, NULL, 0, NULL);

visit_type_UserDefOneList(v, "arg1", &arg1, NULL);

}

static void qmp_init_marshal(void)

{

Error *err = NULL;

QemuOpts *opts;

Object *obj = NULL;

opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);

return;

}

qemu_opts_del(opts);

if (err) {

Error *err = NULL;

MemdevList *memdev_list = qmp_query_memdev(&err);

MemdevList *m = memdev_list;

char *str;

int i = 0;

while (m) {

monitor_printf(mon, "memory backend: %d\n", i);

monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);

monitor_printf(mon, " merge: %s\n",

m->value->prealloc ? "true" : "false");

monitor_printf(mon, " policy: %s\n",

HostMemPolicy_lookup[m->value->policy]);

monitor_printf(mon, " host nodes: %s\n", str);

g_free(str);

m = m->next;

i++;

}

char unsigned *blob = NULL;

{

}

if (err) {

void virtio_blk_submit_multireq(BlockBackend *blk, MultiReqBuffer *mrb)

{

int i = 0, start = 0, num_reqs = 0, niov = 0, nb_sectors = 0;

int64_t sector_num = 0;

if (mrb->num_reqs == 1) {

return;

}

qsort(mrb->reqs, mrb->num_reqs, sizeof(*mrb->reqs),

&multireq_compare);

*/

if (sector_num + nb_sectors != req->sector_num ||

niov > blk_get_max_iov(blk) - req->qiov.niov ||

submit_requests(blk, mrb, start, num_reqs, niov);

num_reqs = 0;

}

if (blk_attach_dev(blk, dev) < 0) {

DriveInfo *dinfo = blk_legacy_dinfo(blk);

error_setg(errp, "Drive '%s' is already in use because "

"it has been automatically connected to another "

"device (did you need 'if=none' in the drive options?)",

qxl_rom_set_dirty(qxl);

}

static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)

{

PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);

qxl->rom->mm_clock = cpu_to_le32(mm_time);

qxl_rom_set_dirty(qxl);

}

static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)

{

int qxl_i;

qemu_mutex_lock(&qxl->ssd.lock);

qemu_mutex_unlock(&qxl->ssd.lock);

return;

}

.attache_worker = interface_attach_worker,

.set_compression_level = interface_set_compression_level,

.set_mm_time = interface_set_mm_time,

.get_init_info = interface_get_init_info,

/* the callbacks below are called from spice server thread context */

int pci_region;

pcibus_t pci_start;

pcibus_t pci_end;

intptr_t virt_start;

QXLDevMemSlot memslot;

int i;

switch (pci_region) {

case QXL_RAM_RANGE_INDEX:

break;

case QXL_VRAM_RANGE_INDEX:

case 4 /* vram 64bit */:

break;

default:

/* should not happen */

return 1;

}

memslot.slot_id = slot_id;

memslot.slot_group_id = MEMSLOT_GROUP_GUEST; /* guest group */

memslot.virt_start = virt_start + (guest_start - pci_start);

qxl_rom_set_dirty(d);

qemu_spice_add_memslot(&d->ssd, &memslot, async);

d->guest_slots[slot_id].size = memslot.virt_end - memslot.virt_start;

d->guest_slots[slot_id].delta = delta;

d->guest_slots[slot_id].active = 1;

}

/* can be also called from spice server thread context */

{

uint64_t phys = le64_to_cpu(pqxl);

uint32_t slot = (phys >> (64 - 8)) & 0xff;

uint64_t offset = phys & 0xffffffffffff;

"slot %d offset %"PRIu64" < delta %"PRIu64"\n",

slot, offset, qxl->guest_slots[slot].delta);

"slot %d offset %"PRIu64" > size %"PRIu64"\n",

slot, offset, qxl->guest_slots[slot].size);

return NULL;

}

}

return NULL;

}

qxl_render_update(qxl);

}

static void qxl_dirty_surfaces(PCIQXLDevice *qxl)

{

int i;

if (qxl->mode != QXL_MODE_NATIVE && qxl->mode != QXL_MODE_COMPAT) {

}

/* dirty the primary surface */

/* dirty the off-screen surfaces */

for (i = 0; i < qxl->ssd.num_surfaces; i++) {

QXLSurfaceCmd *cmd;

if (qxl->guest_surfaces.cmds[i] == 0) {

continue;

MEMSLOT_GROUP_GUEST);

assert(cmd);

assert(cmd->type == QXL_SURFACE_CMD_CREATE);

}

}

/* vram (surfaces, 64bit, bar 4+5) */

if (qxl->vram_size_mb != -1) {

}

if (qxl->vram_size < qxl->vram32_size) {

qxl->vram_size = qxl->vram32_size;

dprint(qxl, 1, "ram/%s: %d MB [region 0]\n",

qxl->id == 0 ? "pri" : "sec",

qxl->vga.vram_size / (1024*1024));

qxl->vram32_size / (1024*1024));

qxl->vram_size / (1024*1024),

qxl->vram32_size < qxl->vram_size ? "[region 4]" : "[unmapped]");

static Property qxl_properties[] = {

DEFINE_PROP_UINT32("ram_size", PCIQXLDevice, vga.vram_size,

64 * 1024 * 1024),

64 * 1024 * 1024),

DEFINE_PROP_UINT32("revision", PCIQXLDevice, revision,

QXL_DEFAULT_REVISION),

struct guest_slots {

QXLMemSlot slot;

uint64_t size;

uint64_t delta;

uint32_t active;

#endif

/* vram pci bar */

MemoryRegion vram_bar;

MemoryRegion vram32_bar;

/* io bar */

qxl_spice_reset_memslots(int qid) "%d"

qxl_spice_update_area(int qid, uint32_t surface_id, uint32_t left, uint32_t right, uint32_t top, uint32_t bottom) "%d sid=%d [%d,%d,%d,%d]"

qxl_spice_update_area_rest(int qid, uint32_t num_dirty_rects, uint32_t clear_dirty_region) "%d #d=%d clear=%d"

qxl_send_events(int qid, uint32_t events) "%d %d"

qxl_send_events_vm_stopped(int qid, uint32_t events) "%d %d"

qxl_set_guest_bug(int qid) "%d"

virgl_renderer_force_ctx_0();

dpy_gl_scanout(g->scanout[ss.scanout_id].con, info.tex_id,

info.flags & 1 /* FIXME: Y_0_TOP */,

ss.r.x, ss.r.y, ss.r.width, ss.r.height);

} else {

if (ss.scanout_id != 0) {

dpy_gfx_replace_surface(g->scanout[ss.scanout_id].con, NULL);

}

dpy_gl_scanout(g->scanout[ss.scanout_id].con, 0, false,

}

g->scanout[ss.scanout_id].resource_id = ss.resource_id;

}

if (i != 0) {

dpy_gfx_replace_surface(g->scanout[i].con, NULL);

}

}

}

{

VirtIOGPU *g = opaque;

virtio_gpu_process_cmdq(g);

}

}

#include "qemu/osdep.h"

#include "sysemu/sysemu.h"

#include "qapi/qmp/types.h"

#include "monitor/monitor.h"

#include "hw/pci/pci_bridge.h"

#include "hw/pci/pcie.h"

/* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */

g_assert(fdt_depth > 0);

visit_check_struct(v, &err);

if (err) {

error_propagate(errp, err);

return;

return;

}

}

break;

}

default:

if (s->type == TYPE_DISK &&

r->req.cmd.buf[0] == INQUIRY &&

r->req.cmd.buf[2] == 0xb0) {

}

}

scsi_req_data(&r->req, len);

}

visit_check_struct(v, &err);

out_nested:

if (!err) {

visit_check_struct(v, &err);

}

out_end:

out:

error_propagate(errp, err);

}

BlockReopenQueue *queue, Error **errp);

void bdrv_reopen_commit(BDRVReopenState *reopen_state);

void bdrv_reopen_abort(BDRVReopenState *reopen_state);

uint8_t *buf, int nb_sectors);

const uint8_t *buf, int nb_sectors);

int count, BdrvRequestFlags flags);

/*

* Efficiently zero a region of the disk image. Note that this is a regular

* I/O request like read or write and should have a reasonable size. This

* function is not suitable for zeroing the entire image in a single request

* because it may allocate memory for the entire region.

*/

BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,

const char *backing_file);

int bdrv_get_backing_file_depth(BlockDriverState *bs);

const char *node_name, Error **errp);

/* async block I/O */

QEMUIOVector *iov, int nb_sectors,

BlockCompletionFunc *cb, void *opaque);

QEMUIOVector *iov, int nb_sectors,

BlockCompletionFunc *cb, void *opaque);

BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,

int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,

int64_t sector_num, int nb_sectors, int *pnum);

bool bdrv_is_inserted(BlockDriverState *bs);

int bdrv_media_changed(BlockDriverState *bs);

void bdrv_lock_medium(BlockDriverState *bs, bool locked);

BlockDriverState *bdrv_next(BdrvNextIterator *it);

BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);

int bdrv_set_key(BlockDriverState *bs, const char *key);

void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp);

int bdrv_query_missing_keys(void);

};

typedef struct BlockLimits {

/* maximum number of bytes that can zeroized at once (since it is

int32_t max_pwrite_zeroes;

/* optimal alignment for write zeroes requests in bytes, must be

uint32_t pwrite_zeroes_alignment;

size_t min_mem_alignment;

size_t opt_mem_alignment;

/* maximum number of iovec elements */

struct BlockDriverState {

int64_t total_sectors; /* if we are reading a disk image, give its

size in sectors */

int open_flags; /* flags used to open the file, re-used for re-open */

note this is a reference count */

BlockDriver *drv; /* NULL means no media */

void *opaque;

/* I/O Limits */

BlockLimits bl;

/* Flags honored during pwrite (so far: BDRV_REQ_FUA) */

unsigned int supported_write_flags;

/* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA,

*/

void bdrv_setup_io_funcs(BlockDriver *bdrv);

int64_t offset, unsigned int bytes, QEMUIOVector *qiov,

BdrvRequestFlags flags);

int64_t offset, unsigned int bytes, QEMUIOVector *qiov,

BdrvRequestFlags flags);

/* Maximum size of a single READ/WRITE data buffer */

#define NBD_MAX_BUFFER_SIZE (32 * 1024 * 1024)

/* Maximum size of an export name. The NBD spec requires 256 and

* suggests that servers support up to 4096, but we stick to only the

* required size so that we can stack-allocate the names, and because

bool use_virgl_renderer;

bool renderer_inited;

QEMUTimer *fence_poll;

QEMUTimer *print_stats;

* QIOTask *task;

* SocketAddress *addrCopy;

*

* task = qio_task_new(OBJECT(obj), func, opaque, notify);

*

* qio_task_run_in_thread(task, myobject_listen_worker,

* qapi_free_FOO() functions, and is the only visitor designed to work

* correctly in the face of a partially-constructed QAPI tree.

*/

#endif

* QTypes. It also requires a non-null list argument to

* visit_start_list().

*/

#endif

* Set @strict to reject a parse that doesn't consume all keys of a

* dictionary; otherwise excess input is ignored.

*/

#endif

typedef struct QmpOutputVisitor QmpOutputVisitor;

#endif

#include "qapi/qmp/qstring.h"

#include "qapi/qmp/qdict.h"

#include "qapi/qmp/qlist.h"

#endif /* QEMU_OBJECTS_H */

* QAPI structs, alternates, null, or arbitrary QTypes. It also

* requires a non-null list argument to visit_start_list().

*/

#endif

typedef struct StringOutputVisitor StringOutputVisitor;

/*

* The string output visitor does not implement support for visiting

* QAPI structs, alternates, null, or arbitrary QTypes. It also

* requires a non-null list argument to visit_start_list().

*/

#endif

*/

/*

* how QAPI enums are visited, as well as what additional restrictions

*/

typedef enum VisitorType {

} VisitorType;

struct Visitor

void (*check_struct)(Visitor *v, Error **errp);

/* Must be set to visit structs */

/* Must be set; implementations may require @list to be non-null,

* but must document it. */

GenericList *(*next_list)(Visitor *v, GenericList *tail, size_t size);

/* Must be set */

/* Must be set by input and dealloc visitors to visit alternates;

* optional for output visitors. */

bool promote_int, Error **errp);

/* Optional, needed for dealloc visitor */

/* Must be set */

void (*type_int64)(Visitor *v, const char *name, int64_t *obj,

/* Must be set */

VisitorType type;

};

#endif

* for doing work at each node of a QAPI graph; it can also be used

* for a virtual walk, where there is no actual QAPI C struct.

*

* string, and QemuOpts) parse an external representation and build

* the corresponding QAPI graph, output visitors (QMP and string) take

* supports. Also, see visitor-impl.h for the callback contracts

* implemented by each visitor, and docs/qapi-code-gen.txt for more

* about the QAPI code generator.

*

* All QAPI types have a corresponding function with a signature

* roughly compatible with this:

*

*

* If an error is detected during visit_type_FOO() with an input

* visitor, then *@obj will be NULL for pointer types, and left

* visitor safely handles incomplete objects. Since input visitors

* never produce an incomplete object, such an object is possible only

* by manual construction.

*

* void qapi_free_FOO(FOO *obj);

*

*

* BASE *qapi_CHILD_base(CHILD *obj);

*

* Error *err = NULL;

* Visitor *v;

*

* visit_type_Foo(v, NULL, &f, &err);

* if (err) {

* ...handle error...

* } else {

* ...use f...

* }

* qapi_free_Foo(f);

* </example>

*

* Error *err = NULL;

* Visitor *v;

*

* visit_type_FooList(v, NULL, &l, &err);

* if (err) {

* ...handle error...

* ...use l->value...

* }

* }

* qapi_free_FooList(l);

* </example>

*

* Foo *f = ...obtain populated object...

* Error *err = NULL;

* Visitor *v;

*

* visit_type_Foo(v, NULL, &f, &err);

* if (err) {

* ...handle error...

* }

* </example>

*

* When visiting a real QAPI struct, this file provides several

* Error *err = NULL;

* int value;

*

* visit_start_struct(v, NULL, NULL, 0, &err);

* if (err) {

* goto out;

* goto outlist;

* }

* outlist:

* if (!err) {

* visit_check_struct(v, &err);

* }

* outobj:

* out:

* error_propagate(errp, err);

* </example>

*/

char padding[];

} GenericAlternate;

/*** Visiting structures ***/

/*

* container; see the general description of @name above.

*

* @obj must be non-NULL for a real walk, in which case @size

*

* @errp obeys typical error usage, and reports failures such as a

* member @name is not present, or present but not an object. On

* After visit_start_struct() succeeds, the caller may visit its

* members one after the other, passing the member's name and address

* within the struct. Finally, visit_end_struct() needs to be called

*

* FIXME Should this be named visit_start_object, since it is also

* used for QAPI unions, and maps to JSON objects?

/*

* Complete an object visit started earlier.

*

* Must be called after any successful use of visit_start_struct(),

* even if intermediate processing was skipped due to errors, to allow

* the backend to release any resources. Destroying the visitor early

*/

/*** Visiting lists ***/

* container; see the general description of @name above.

*

* @list must be non-NULL for a real walk, in which case @size

* ignored.

*

* @errp obeys typical error usage, and reports failures such as a

* visit (where @obj is NULL) uses other means. For each list

* element, call the appropriate visit_type_FOO() with name set to

* NULL and obj set to the address of the value member of the list

*/

void visit_start_list(Visitor *v, const char *name, GenericList **list,

size_t size, Error **errp);

/*

* Complete a list visit started earlier.

*

* Must be called after any successful use of visit_start_list(), even

* if intermediate processing was skipped due to errors, to allow the

* backend to release any resources. Destroying the visitor early

*/

/*** Visiting alternates ***/

* @name expresses the relationship of this alternate to its parent

* container; see the general description of @name above.

*

*

* If @promote_int, treat integers as QTYPE_FLOAT.

*

*/

void visit_start_alternate(Visitor *v, const char *name,

GenericAlternate **obj, size_t size,

/*

* Finish visiting an alternate type.

*

* Must be called after any successful use of visit_start_alternate(),

* even if intermediate processing was skipped due to errors, to allow

* the backend to release any resources. Destroying the visitor early

*

*/

/*** Other helpers ***/

* @name expresses the relationship of this string to its parent

* container; see the general description of @name above.

*

*

* It is safe to cast away const when preparing a (const char *) value

* into @obj for use by an output visitor.

*/

SocketAddress *socket_remote_address(int fd, Error **errp);

/**

* socket_address_to_string:

* @addr: the socket address struct

void object_ref(Object *obj);

/**

* @obj: the object

*

* Decrease the reference count of a object. A object cannot be freed as long

BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,

int count, BdrvRequestFlags flags,

BlockCompletionFunc *cb, void *opaque);

int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count);

int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count,

BdrvRequestFlags flags);

void blk_lock_medium(BlockBackend *blk, bool locked);

void blk_eject(BlockBackend *blk, bool eject_flag);

int blk_get_flags(BlockBackend *blk);

int blk_get_max_iov(BlockBackend *blk);

void blk_set_guest_block_size(BlockBackend *blk, int align);

void *blk_try_blockalign(BlockBackend *blk, size_t size);

void (*dpy_gl_scanout)(DisplayChangeListener *dcl,

uint32_t backing_id, bool backing_y_0_top,

uint32_t x, uint32_t y, uint32_t w, uint32_t h);

void (*dpy_gl_update)(DisplayChangeListener *dcl,

uint32_t x, uint32_t y, uint32_t w, uint32_t h);

void dpy_gl_scanout(QemuConsole *con,

uint32_t backing_id, bool backing_y_0_top,

uint32_t x, uint32_t y, uint32_t w, uint32_t h);

void dpy_gl_update(QemuConsole *con,

uint32_t x, uint32_t y, uint32_t w, uint32_t h);

QEMUGLParams *params);

void gd_egl_scanout(DisplayChangeListener *dcl,

uint32_t backing_id, bool backing_y_0_top,

uint32_t x, uint32_t y,

uint32_t w, uint32_t h);

void gd_egl_scanout_flush(DisplayChangeListener *dcl,

int qemu_spice_migrate_info(const char *hostname, int port, int tls_port,

const char *subject);

#if SPICE_SERVER_VERSION >= 0x000c02

void qemu_spice_register_ports(void);

#else

void sdl2_gl_scanout(DisplayChangeListener *dcl,

uint32_t backing_id, bool backing_y_0_top,

uint32_t x, uint32_t y,

uint32_t w, uint32_t h);

void sdl2_gl_scanout_flush(DisplayChangeListener *dcl,

#include "io/channel-socket.h"

#include "io/channel-watch.h"

#include "trace.h"

#define SOCKET_MAX_FDS 16

OBJECT(ioc), callback, opaque, destroy);

SocketAddress *addrCopy;

/* socket_connect() does a non-blocking connect(), but it

* still blocks in DNS lookups, so we must use a thread */

OBJECT(ioc), callback, opaque, destroy);

SocketAddress *addrCopy;

/* socket_listen() blocks in DNS lookups, so we must use a thread */

trace_qio_channel_socket_listen_async(ioc, addr);

struct QIOChannelSocketDGramWorkerData *data = g_new0(

struct QIOChannelSocketDGramWorkerData, 1);

trace_qio_channel_socket_dgram_async(ioc, localAddr, remoteAddr);

qio_task_run_in_thread(task,

#include "qemu/acl.h"

#include "sysemu/tpm.h"

#include "qapi/qmp/qerror.h"

#include "qapi/qmp/qjson.h"

#include "qapi/qmp/json-streamer.h"

#include "qapi/qmp/json-parser.h"

void *object = NULL;

Error *err = NULL;

int ret = -1;

{

/* Parse convenience option format ip6-net=fec0::0[/64] */

}

error_propagate(errp, err);

return ret;

}

char *str;

ObjectProperty *prop;

ObjectPropertyIterator iter;

/* generate info str */

object_property_iter_init(&iter, OBJECT(nf));

if (!strcmp(prop->name, "type")) {

continue;

}

monitor_printf(mon, ",%s=%s", prop->name, str);

g_free(str);

}

Error *err = NULL;

{

}

if (err) {

util-obj-y = qapi-visit-core.o qapi-dealloc-visitor.o qmp-input-visitor.o

util-obj-y += qmp-output-visitor.o qmp-registry.o qmp-dispatch.o

util-obj-y += string-input-visitor.o string-output-visitor.o

util-obj-y += qmp-event.o

util-obj-y += qapi-util.o

#

# @config: #optional filename of the configuration file

#

#

# @inject-error: #optional array of error injection descriptions

#

static void

{

OptsVisitor *ov = to_ov(v);

static void

{

OptsVisitor *ov = to_ov(v);

}

opts_visitor_new(const QemuOpts *opts)

{

OptsVisitor *ov;

* skip some mandatory methods... */

ov->visitor.optional = &opts_optional;

ov->opts_root = opts;

return &ov->visitor;

}

#include "qapi/qmp/types.h"

#include "qapi/visitor-impl.h"

struct QapiDeallocVisitor

{

Visitor visitor;

};

static void qapi_dealloc_start_struct(Visitor *v, const char *name, void **obj,

size_t unused, Error **errp)

{

}

{

if (obj) {

g_free(*obj);

}

GenericAlternate **obj, size_t size,

bool promote_int, Error **errp)

{

}

{

if (obj) {

g_free(*obj);

}

return next;

}

{

}

{

}

{

}

{

QapiDeallocVisitor *v;

v->visitor.type_number = qapi_dealloc_type_number;

v->visitor.type_any = qapi_dealloc_type_anything;

v->visitor.type_null = qapi_dealloc_type_null;

}

#include "qapi/visitor.h"

#include "qapi/visitor-impl.h"