Archipelago » qemu

/*

 * QEMU System Emulator block driver

 * Copyright (c) 2003 Fabrice Bellard

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

        int64_t sector_num, const uint8_t *buf, int nb_sectors,

        BlockDriverCompletionFunc *cb, void *opaque);

static void bdrv_aio_cancel_em(BlockDriverAIOCB *acb);

                        uint8_t *buf, int nb_sectors);

static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,

                         const uint8_t *buf, int nb_sectors);

    return NULL;

}

                const char *filename, int64_t size_in_sectors,

                const char *backing_file, int flags)

{

void get_tmp_filename(char *filename, int size)

{

    char temp_dir[MAX_PATH];

    GetTempPath(MAX_PATH, temp_dir);

    GetTempFileName(temp_dir, "qem", 0, filename);

}

             (filename[0] >= 'A' && filename[0] <= 'Z')) &&

            filename[1] == ':');

}

static int is_windows_drive(const char *filename)

{

        filename[2] == '\0')

        return 1;

    if (strstart(filename, "\\\\.\\", NULL) ||

    memcpy(protocol, filename, len);

    protocol[len] = '\0';

    for(drv1 = first_drv; drv1 != NULL; drv1 = drv1->next) {

            !strcmp(drv1->protocol_name, protocol))

            return drv1;

    }

    BlockDriver *drv1, *drv;

    uint8_t buf[2048];

    BlockDriverState *bs;

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

       recognized as a host CDROM */

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

#else

    {

        struct stat st;

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

            return &bdrv_host_device;

        }

    }

#endif

    drv = find_protocol(filename);

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

    if (drv == &bdrv_vvfat)

    int ret, open_flags;

    char tmp_filename[PATH_MAX];

    char backing_filename[PATH_MAX];

    bs->read_only = 0;

    bs->is_temporary = 0;

    bs->encrypted = 0;

    if (flags & BDRV_O_SNAPSHOT) {

        BlockDriverState *bs1;

        int64_t total_size;

        /* if snapshot, we create a temporary backing file and open it

           instead of opening 'filename' directly */

        }

        total_size = bdrv_getlength(bs1) >> SECTOR_BITS;

        bdrv_delete(bs1);

        get_tmp_filename(tmp_filename, sizeof(tmp_filename));

        realpath(filename, backing_filename);

                        total_size, backing_filename, 0) < 0) {

            return -1;

        }

}

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

              uint8_t *buf, int nb_sectors)

{

    BlockDriver *drv = bs->drv;

    }

}

  -EIO         generic I/O error (may happen for all errors)

  -ENOMEDIUM   No media inserted.

  -EINVAL      Invalid sector number or nb_sectors

  -EACCES      Trying to write a read-only device

*/

               const uint8_t *buf, int nb_sectors)

{

    BlockDriver *drv = bs->drv;

    if (bs->read_only)

        return -EACCES;

    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {

    }

    if (drv->bdrv_pwrite) {

        int ret, len;

    }

}

                         uint8_t *buf, int count1)

{

    uint8_t tmp_buf[SECTOR_SIZE];

    return count1;

}

                          const uint8_t *buf, int count1)

{

    uint8_t tmp_buf[SECTOR_SIZE];

}

/**

 */

               void *buf1, int count1)

{

    BlockDriver *drv = bs->drv;

    return drv->bdrv_pread(bs, offset, buf1, count1);

}

 */

                const void *buf1, int count1)

{

    BlockDriver *drv = bs->drv;

    memset(bs->boot_sector_data + size, 0, 512 - size);

}

                            int cyls, int heads, int secs)

{

    bs->cyls = cyls;

    bs->translation = translation;

}

                            int *pcyls, int *pheads, int *psecs)

{

    *pcyls = bs->cyls;

}

/* XXX: no longer used */

                        void (*change_cb)(void *opaque), void *opaque)

{

    bs->change_cb = change_cb;

    }

}

                         void *opaque)

{

    BlockDriver *drv;

    }

}

                               char *filename, int filename_size)

{

    if (!bs->backing_hd) {

    }

}

                          const uint8_t *buf, int nb_sectors)

{

    BlockDriver *drv = bs->drv;

        return -ENOTSUP;

    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);

}

int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)

{

    BlockDriver *drv = bs->drv;

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

/* handling of snapshots */

                         QEMUSnapshotInfo *sn_info)

{

    BlockDriver *drv = bs->drv;

    return drv->bdrv_snapshot_create(bs, sn_info);

}

                       const char *snapshot_id)

{

    BlockDriver *drv = bs->drv;

    return drv->bdrv_snapshot_delete(bs, snapshot_id);

}

                       QEMUSnapshotInfo **psn_info)

{

    BlockDriver *drv = bs->drv;

        base = 1024;

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

            if (size < (10 * base)) {

                         (double)size / base,

                         suffixes[i]);

                break;

            } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {

                         ((size + (base >> 1)) / base),

                         suffixes[i]);

                break;

    int64_t secs;

    if (!sn) {

                 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");

    } else {

        ti = sn->date_sec;

                 "%02d:%02d:%02d.%03d",

                 (int)(secs / 3600),

                 (int)((secs / 60) % 60),

                 (int)((sn->vm_clock_nsec / 1000000) % 1000));

        snprintf(buf, buf_size,

                 sn->id_str, sn->name,

                 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size),

                 date_buf,

    if (!drv)

        return NULL;

    /* XXX: we assume that nb_sectors == 0 is suppored by the async read */

    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {

        memcpy(buf, bs->boot_sector_data, 512);

    if (bs->read_only)

        return NULL;

    if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {

    }

    return drv->bdrv_aio_write(bs, sector_num, buf, nb_sectors, cb, opaque);

#define NOT_DONE 0x7fffffff

                        uint8_t *buf, int nb_sectors)

{

    int async_ret;

    async_ret = NOT_DONE;

    qemu_aio_wait_start();

                        bdrv_rw_em_cb, &async_ret);

    if (acb == NULL) {

        qemu_aio_wait_end();

    async_ret = NOT_DONE;

    qemu_aio_wait_start();

                         bdrv_rw_em_cb, &async_ret);

    if (acb == NULL) {

        qemu_aio_wait_end();

/**

 * Return TRUE if the media changed since the last call to this

 */

int bdrv_media_changed(BlockDriverState *bs)

{