Archipelago » qemu

 */

#include "qemu-common.h"

#include "block_int.h"

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

    close(s->fd);

}

    .format_name	= "bochs",

    .instance_size	= sizeof(BDRVBochsState),

    .bdrv_probe		= bochs_probe,

    .bdrv_read		= bochs_read,

    .bdrv_close		= bochs_close,

};

 */

#include "qemu-common.h"

#include "block_int.h"

#include <zlib.h>

typedef struct BDRVCloopState {

    inflateEnd(&s->zstream);

}

    .format_name	= "cloop",

    .instance_size	= sizeof(BDRVCloopState),

    .bdrv_probe		= cloop_probe,

    .bdrv_read		= cloop_read,

    .bdrv_close		= cloop_close,

};

#ifndef _WIN32

#include "qemu-common.h"

#include "block_int.h"

#include <sys/mman.h>

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

    fsync(s->fd);

}

    .format_name	= "cow",

    .instance_size	= sizeof(BDRVCowState),

    .bdrv_probe		= cow_probe,

    .bdrv_flush		= cow_flush,

    .bdrv_is_allocated	= cow_is_allocated,

};

#endif

#include "qemu-common.h"

#include "block_int.h"

#include "bswap.h"

#include <zlib.h>

typedef struct BDRVDMGState {

dmg_close:

	close(s->fd);

	/* open raw instead */

	return bs->drv->bdrv_open(bs, filename, flags);

    }

    info_begin=read_off(s->fd);

    inflateEnd(&s->zstream);

}

    .format_name	= "dmg",

    .instance_size	= sizeof(BDRVDMGState),

    .bdrv_probe		= dmg_probe,

    .bdrv_read		= dmg_read,

    .bdrv_close		= dmg_close,

};

#include "qemu-common.h"

#include "nbd.h"

#include <sys/types.h>

#include <unistd.h>

    return s->size;

}

    .format_name	= "nbd",

    .instance_size	= sizeof(BDRVNBDState),

    .bdrv_open		= nbd_open,

    .bdrv_getlength	= nbd_getlength,

    .protocol_name	= "nbd",

};

 */

#include "qemu-common.h"

#include "block_int.h"

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

    close(s->fd);

}

    .format_name	= "parallels",

    .instance_size	= sizeof(BDRVParallelsState),

    .bdrv_probe		= parallels_probe,

    .bdrv_read		= parallels_read,

    .bdrv_close		= parallels_close,

};

 */

#include "qemu-common.h"

#include "block_int.h"

#include <zlib.h>

#include "aes.h"

    return 0;

}

    .format_name	= "qcow",

    .instance_size	= sizeof(BDRVQcowState),

    .bdrv_probe		= qcow_probe,

    .bdrv_write_compressed = qcow_write_compressed,

    .bdrv_get_info	= qcow_get_info,

};

 */

#include "qemu-common.h"

#include "block_int.h"

#include <zlib.h>

#include "aes.h"

    return ret;

}

    .format_name	= "qcow2",

    .instance_size	= sizeof(BDRVQcowState),

    .bdrv_probe		= qcow_probe,

    .bdrv_create2 = qcow_create2,

    .bdrv_check = qcow_check,

};

#include "qemu-timer.h"

#include "qemu-char.h"

#include "block_int.h"

#ifdef CONFIG_AIO

#include "posix-aio-compat.h"

#endif

    fsync(s->fd);

}

    .format_name = "raw",

    .instance_size = sizeof(BDRVRawState),

    .bdrv_probe = NULL, /* no probe for protocols */

}

#endif

    .format_name	= "host_device",

    .instance_size	= sizeof(BDRVRawState),

    .bdrv_open		= hdev_open,

    .bdrv_aio_ioctl	= raw_aio_ioctl,

#endif

};

#include "qemu-common.h"

#include "qemu-timer.h"

#include "block_int.h"

#include <windows.h>

#include <winioctl.h>

    return 0;

}

    .format_name	= "raw",

    .instance_size	= sizeof(BDRVRawState),

    .bdrv_open		= raw_open,

}

#endif

    .format_name	= "host_device",

    .instance_size	= sizeof(BDRVRawState),

    .bdrv_open		= hdev_open,

    .bdrv_write	        = raw_write,

    .bdrv_getlength	= raw_getlength,

};

#include "qemu-common.h"

#include "block_int.h"

#define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')

#define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V')

    bdrv_flush(s->hd);

}

    .format_name	= "vmdk",

    .instance_size	= sizeof(BDRVVmdkState),

    .bdrv_probe		= vmdk_probe,

    .bdrv_flush		= vmdk_flush,

    .bdrv_is_allocated	= vmdk_is_allocated,

};

 */

#include "qemu-common.h"

#include "block_int.h"

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

    bdrv_delete(s->hd);

}

    .format_name	= "vpc",

    .instance_size	= sizeof(BDRVVPCState),

    .bdrv_probe		= vpc_probe,

    .bdrv_close		= vpc_close,

    .bdrv_create	= vpc_create,

};

#include <dirent.h>

#include "qemu-common.h"

#include "block_int.h"

#ifndef S_IWGRP

#define S_IWGRP 0

    s->qcow_filename = qemu_malloc(1024);

    get_tmp_filename(s->qcow_filename, 1024);

		s->qcow_filename, s->sector_count, "fat:", 0) < 0)

	return -1;

    s->qcow = bdrv_new("");

        free(s->cluster_buffer);

}

    .format_name	= "vvfat",

    .instance_size	= sizeof(BDRVVVFATState),

    .bdrv_open		= vvfat_open,

    .protocol_name	= "fat",

};

#ifdef DEBUG

static void checkpoint(void) {

    assert(((mapping_t*)array_get(&(vvv->mapping), 0))->end == 2);

#include "qemu-common.h"

#include "monitor.h"

#include "block_int.h"

#ifdef HOST_BSD

#include <sys/types.h>

}

{

    if (!bdrv->bdrv_aio_readv) {

        /* add AIO emulation layer */

#ifdef _WIN32

    if (is_windows_drive(filename) ||

        is_windows_drive_prefix(filename))

#endif

    p = strchr(filename, ':');

    if (!p)

    len = p - filename;

    if (len > sizeof(protocol) - 1)

        len = sizeof(protocol) - 1;

    /* detect host devices. By convention, /dev/cdrom[N] is always

       recognized as a host CDROM */

    if (strstart(filename, "/dev/cdrom", NULL))

#ifdef _WIN32

    if (is_windows_drive(filename))

#else

    {

        struct stat st;

        if (stat(filename, &st) >= 0 &&

            (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {

        }

    }

#endif

    drv = find_protocol(filename);

    /* no need to test disk image formats for vvfat */

        return drv;

    ret = bdrv_file_open(&bs, filename, BDRV_O_RDONLY);

        else

            realpath(filename, backing_filename);

                           total_size, backing_filename, 

                           (drv ? drv->format_name : NULL), 0);

        if (ret < 0) {

            return ret;

        }

        filename = tmp_filename;

        bs->is_temporary = 1;

    }

void bdrv_init(void)

{

}

void aio_pool_init(AIOPool *pool, int aiocb_size,

/* block.c */

typedef struct BlockDriver BlockDriver;

typedef struct BlockDriverInfo {

    /* in bytes, 0 if irrelevant */

    int cluster_size;

void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr);

void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs);

int bdrv_commit(BlockDriverState *bs);

/* async block I/O */

typedef struct BlockDriverAIOCB BlockDriverAIOCB;

typedef void BlockDriverCompletionFunc(void *opaque, int ret);

    drv = bdrv_find_format(out_fmt);

    if (!drv)

        error("Unknown file format '%s'", out_fmt);

        error("Compression not supported for this file format");

        error("Encryption not supported for this file format");

        error("Alternative compatibility level not supported for this file format");

    if (flags & BLOCK_FLAG_ENCRYPT && flags & BLOCK_FLAG_COMPRESS)

        error("Compression and encryption not supported at the same time");

            if (n > bs_offset + bs_sectors - sector_num)

                n = bs_offset + bs_sectors - sector_num;

                if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,

                                       n, &n1)) {

                    sector_num += n1;

                   If the output is to a host device, we also write out

                   sectors that are entirely 0, since whatever data was

                   already there is garbage, not 0s. */

                    is_allocated_sectors(buf1, n, &n1)) {

                    if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)

                        error("error while writing");