Archipelago » qemu

hw-obj-y += vl.o loader.o

vl.o: QEMU_CFLAGS+=$(GPROF_CFLAGS)

vl.o: QEMU_CFLAGS+=$(SDL_CFLAGS)

vl.o: qemu-options.h

qemu-options.h: $(SRC_PATH)/qemu-options.hx

	$(call quiet-command,sh $(SRC_PATH)/hxtool -h < $< > $@,"  GEN   $(TARGET_DIR)$@")

obj-y = arch_init.o cpus.o monitor.o machine.o gdbstub.o

main.o: QEMU_CFLAGS+=$(GPROF_CFLAGS)

	rm -f qemu-monitor.h gdbstub-xml.c

/*

 * QEMU System Emulator

 *

 * Copyright (c) 2003-2008 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

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include <stdint.h>

#include <stdarg.h>

#ifndef _WIN32

#include <sys/mman.h>

#endif

#include "config.h"

#include "monitor.h"

#include "sysemu.h"

#include "arch_init.h"

#include "audio/audio.h"

#include "hw/pc.h"

#include "hw/pci.h"

#include "hw/audiodev.h"

#include "kvm.h"

#include "migration.h"

#include "net.h"

#include "gdbstub.h"

#include "hw/smbios.h"

#ifdef TARGET_SPARC

int graphic_width = 1024;

int graphic_height = 768;

int graphic_depth = 8;

#else

int graphic_width = 800;

int graphic_height = 600;

int graphic_depth = 15;

#endif

const char arch_config_name[] = CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf";

#if defined(TARGET_ALPHA)

#define QEMU_ARCH QEMU_ARCH_ALPHA

#elif defined(TARGET_ARM)

#define QEMU_ARCH QEMU_ARCH_ARM

#elif defined(TARGET_CRIS)

#define QEMU_ARCH QEMU_ARCH_CRIS

#elif defined(TARGET_I386)

#define QEMU_ARCH QEMU_ARCH_I386

#elif defined(TARGET_M68K)

#define QEMU_ARCH QEMU_ARCH_M68K

#elif defined(TARGET_MICROBLAZE)

#define QEMU_ARCH QEMU_ARCH_MICROBLAZE

#elif defined(TARGET_MIPS)

#define QEMU_ARCH QEMU_ARCH_MIPS

#elif defined(TARGET_PPC)

#define QEMU_ARCH QEMU_ARCH_PPC

#elif defined(TARGET_S390X)

#define QEMU_ARCH QEMU_ARCH_S390X

#elif defined(TARGET_SH4)

#define QEMU_ARCH QEMU_ARCH_SH4

#elif defined(TARGET_SPARC)

#define QEMU_ARCH QEMU_ARCH_SPARC

#endif

const uint32_t arch_type = QEMU_ARCH;

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

/* ram save/restore */

#define RAM_SAVE_FLAG_FULL	0x01 /* Obsolete, not used anymore */

#define RAM_SAVE_FLAG_COMPRESS	0x02

#define RAM_SAVE_FLAG_MEM_SIZE	0x04

#define RAM_SAVE_FLAG_PAGE	0x08

#define RAM_SAVE_FLAG_EOS	0x10

static int is_dup_page(uint8_t *page, uint8_t ch)

{

    uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;

    uint32_t *array = (uint32_t *)page;

    int i;

    for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {

        if (array[i] != val) {

            return 0;

        }

    }

    return 1;

}

static int ram_save_block(QEMUFile *f)

{

    static ram_addr_t current_addr = 0;

    ram_addr_t saved_addr = current_addr;

    ram_addr_t addr = 0;

    int found = 0;

    while (addr < last_ram_offset) {

        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {

            uint8_t *p;

            cpu_physical_memory_reset_dirty(current_addr,

                                            current_addr + TARGET_PAGE_SIZE,

                                            MIGRATION_DIRTY_FLAG);

            p = qemu_get_ram_ptr(current_addr);

            if (is_dup_page(p, *p)) {

                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);

                qemu_put_byte(f, *p);

            } else {

                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);

                qemu_put_buffer(f, p, TARGET_PAGE_SIZE);

            }

            found = 1;

            break;

        }

        addr += TARGET_PAGE_SIZE;

        current_addr = (saved_addr + addr) % last_ram_offset;

    }

    return found;

}

static uint64_t bytes_transferred;

static ram_addr_t ram_save_remaining(void)

{

    ram_addr_t addr;

    ram_addr_t count = 0;

    for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {

        if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {

            count++;

        }

    }

    return count;

}

uint64_t ram_bytes_remaining(void)

{

    return ram_save_remaining() * TARGET_PAGE_SIZE;

}

uint64_t ram_bytes_transferred(void)

{

    return bytes_transferred;

}

uint64_t ram_bytes_total(void)

{

    return last_ram_offset;

}

int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)

{

    ram_addr_t addr;

    uint64_t bytes_transferred_last;

    double bwidth = 0;

    uint64_t expected_time = 0;

    if (stage < 0) {

        cpu_physical_memory_set_dirty_tracking(0);

        return 0;

    }

    if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {

        qemu_file_set_error(f);

        return 0;

    }

    if (stage == 1) {

        bytes_transferred = 0;

        /* Make sure all dirty bits are set */

        for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {

            if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {

                cpu_physical_memory_set_dirty(addr);

            }

        }

        /* Enable dirty memory tracking */

        cpu_physical_memory_set_dirty_tracking(1);

        qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);

    }

    bytes_transferred_last = bytes_transferred;

    bwidth = qemu_get_clock_ns(rt_clock);

    while (!qemu_file_rate_limit(f)) {

        int ret;

        ret = ram_save_block(f);

        bytes_transferred += ret * TARGET_PAGE_SIZE;

        if (ret == 0) { /* no more blocks */

            break;

        }

    }

    bwidth = qemu_get_clock_ns(rt_clock) - bwidth;

    bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;

    /* if we haven't transferred anything this round, force expected_time to a

     * a very high value, but without crashing */

    if (bwidth == 0) {

        bwidth = 0.000001;

    }

    /* try transferring iterative blocks of memory */

    if (stage == 3) {

        /* flush all remaining blocks regardless of rate limiting */

        while (ram_save_block(f) != 0) {

            bytes_transferred += TARGET_PAGE_SIZE;

        }

        cpu_physical_memory_set_dirty_tracking(0);

    }

    qemu_put_be64(f, RAM_SAVE_FLAG_EOS);

    expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;

    return (stage == 2) && (expected_time <= migrate_max_downtime());

}

int ram_load(QEMUFile *f, void *opaque, int version_id)

{

    ram_addr_t addr;

    int flags;

    if (version_id != 3) {

        return -EINVAL;

    }

    do {

        addr = qemu_get_be64(f);

        flags = addr & ~TARGET_PAGE_MASK;

        addr &= TARGET_PAGE_MASK;

        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {

            if (addr != last_ram_offset) {

                return -EINVAL;

            }

        }

        if (flags & RAM_SAVE_FLAG_COMPRESS) {

            uint8_t ch = qemu_get_byte(f);

            memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);

#ifndef _WIN32

            if (ch == 0 &&

                (!kvm_enabled() || kvm_has_sync_mmu())) {

                madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE,

                        MADV_DONTNEED);

            }

#endif

        } else if (flags & RAM_SAVE_FLAG_PAGE) {

            qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);

        }

        if (qemu_file_has_error(f)) {

            return -EIO;

        }

    } while (!(flags & RAM_SAVE_FLAG_EOS));

    return 0;

}

void qemu_service_io(void)

{

    qemu_notify_event();

}

#ifdef HAS_AUDIO

struct soundhw soundhw[] = {

#ifdef HAS_AUDIO_CHOICE

#if defined(TARGET_I386) || defined(TARGET_MIPS)

    {

        "pcspk",

        "PC speaker",

        0,

        1,

        { .init_isa = pcspk_audio_init }

    },

#endif

#ifdef CONFIG_SB16

    {

        "sb16",

        "Creative Sound Blaster 16",

        0,

        1,

        { .init_isa = SB16_init }

    },

#endif

#ifdef CONFIG_CS4231A

    {

        "cs4231a",

        "CS4231A",

        0,

        1,

        { .init_isa = cs4231a_init }

    },

#endif

#ifdef CONFIG_ADLIB

    {

        "adlib",

#ifdef HAS_YMF262

        "Yamaha YMF262 (OPL3)",

#else

        "Yamaha YM3812 (OPL2)",

#endif

        0,

        1,

        { .init_isa = Adlib_init }

    },

#endif

#ifdef CONFIG_GUS

    {

        "gus",

        "Gravis Ultrasound GF1",

        0,

        1,

        { .init_isa = GUS_init }

    },

#endif

#ifdef CONFIG_AC97

    {

        "ac97",

        "Intel 82801AA AC97 Audio",

        0,

        0,

        { .init_pci = ac97_init }

    },

#endif

#ifdef CONFIG_ES1370

    {

        "es1370",

        "ENSONIQ AudioPCI ES1370",

        0,

        0,

        { .init_pci = es1370_init }

    },

#endif

#endif /* HAS_AUDIO_CHOICE */

    { NULL, NULL, 0, 0, { NULL } }

};

void select_soundhw(const char *optarg)

{

    struct soundhw *c;

    if (*optarg == '?') {

    show_valid_cards:

        printf("Valid sound card names (comma separated):\n");

        for (c = soundhw; c->name; ++c) {

            printf ("%-11s %s\n", c->name, c->descr);

        }

        printf("\n-soundhw all will enable all of the above\n");

        exit(*optarg != '?');

    }

    else {

        size_t l;

        const char *p;

        char *e;

        int bad_card = 0;

        if (!strcmp(optarg, "all")) {

            for (c = soundhw; c->name; ++c) {

                c->enabled = 1;

            }

            return;

        }

        p = optarg;

        while (*p) {

            e = strchr(p, ',');

            l = !e ? strlen(p) : (size_t) (e - p);

            for (c = soundhw; c->name; ++c) {

                if (!strncmp(c->name, p, l) && !c->name[l]) {

                    c->enabled = 1;

                    break;

                }

            }

            if (!c->name) {

                if (l > 80) {

                    fprintf(stderr,

                            "Unknown sound card name (too big to show)\n");

                }

                else {

                    fprintf(stderr, "Unknown sound card name `%.*s'\n",

                            (int) l, p);

                }

                bad_card = 1;

            }

            p += l + (e != NULL);

        }

        if (bad_card) {

            goto show_valid_cards;

        }

    }

}

#else

void select_soundhw(const char *optarg)

{

}

#endif

int qemu_uuid_parse(const char *str, uint8_t *uuid)

{

    int ret;

    if (strlen(str) != 36) {

        return -1;

    }

    ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],

                 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],

                 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],

                 &uuid[15]);

    if (ret != 16) {

        return -1;

    }

#ifdef TARGET_I386

    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);

#endif

    return 0;

}

void do_acpitable_option(const char *optarg)

{

#ifdef TARGET_I386

    if (acpi_table_add(optarg) < 0) {

        fprintf(stderr, "Wrong acpi table provided\n");

        exit(1);

    }

#endif

}

void do_smbios_option(const char *optarg)

{

#ifdef TARGET_I386

    if (smbios_entry_add(optarg) < 0) {

        fprintf(stderr, "Wrong smbios provided\n");

        exit(1);

    }

#endif

}

void cpudef_init(void)

{

#if defined(cpudef_setup)

    cpudef_setup(); /* parse cpu definitions in target config file */

#endif

}

int audio_available(void)

{

#ifdef HAS_AUDIO

    return 1;

#else

    return 0;

#endif

}

int kvm_available(void)

{

#ifdef CONFIG_KVM

    return 1;

#else

    return 0;

#endif

}

int xen_available(void)

{

#ifdef CONFIG_XEN

    return 1;

#else

    return 0;

#endif

}

#ifndef QEMU_ARCH_INIT_H

#define QEMU_ARCH_INIT_H

extern const char arch_config_name[];

enum {

    QEMU_ARCH_ALL = -1,

    QEMU_ARCH_ALPHA = 1,

    QEMU_ARCH_ARM = 2,

    QEMU_ARCH_CRIS = 4,

    QEMU_ARCH_I386 = 8,

    QEMU_ARCH_M68K = 16,

    QEMU_ARCH_MICROBLAZE = 32,

    QEMU_ARCH_MIPS = 64,

    QEMU_ARCH_PPC = 128,

    QEMU_ARCH_S390X = 256,

    QEMU_ARCH_SH4 = 512,

    QEMU_ARCH_SPARC = 1024,

};

extern const uint32_t arch_type;

void select_soundhw(const char *optarg);

int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque);

int ram_load(QEMUFile *f, void *opaque, int version_id);

void do_acpitable_option(const char *optarg);

void do_smbios_option(const char *optarg);

void cpudef_init(void);

int audio_available(void);

int kvm_available(void);

int xen_available(void);

#endif

HXCOMM DEF(option, HAS_ARG/0, opt_enum, opt_help, arch_mask) is used to

HXCOMM construct option structures, enums and help message for specified

HXCOMM architectures.

    "-h or -help     display this help and exit\n", QEMU_ARCH_ALL)

    "-version        display version information and exit\n", QEMU_ARCH_ALL)

    "-M machine      select emulated machine (-M ? for list)\n", QEMU_ARCH_ALL)

    "-cpu cpu        select CPU (-cpu ? for list)\n", QEMU_ARCH_ALL)

    "                sockets= number of discrete sockets in the system\n",

        QEMU_ARCH_ALL)

    "-numa node[,mem=size][,cpus=cpu[-cpu]][,nodeid=node]\n", QEMU_ARCH_ALL)

    "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n", QEMU_ARCH_ALL)

DEF("fdb", HAS_ARG, QEMU_OPTION_fdb, "", QEMU_ARCH_ALL)

    "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n", QEMU_ARCH_ALL)

DEF("hdb", HAS_ARG, QEMU_OPTION_hdb, "", QEMU_ARCH_ALL)

    "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n", QEMU_ARCH_ALL)

DEF("hdd", HAS_ARG, QEMU_OPTION_hdd, "", QEMU_ARCH_ALL)

    "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n",

    QEMU_ARCH_ALL)

    "                use 'file' as a drive image\n", QEMU_ARCH_ALL)

    "                i.e. -set drive.$id.file=/path/to/image\n", QEMU_ARCH_ALL)

    "                set a global default for a driver property\n",

    QEMU_ARCH_ALL)

    "-mtdblock file  use 'file' as on-board Flash memory image\n",

    QEMU_ARCH_ALL)

    "-sd file        use 'file' as SecureDigital card image\n", QEMU_ARCH_ALL)

    "-pflash file    use 'file' as a parallel flash image\n", QEMU_ARCH_ALL)

    "                'drives': floppy (a), hard disk (c), CD-ROM (d), network (n)\n",

    QEMU_ARCH_ALL)

    "-snapshot       write to temporary files instead of disk image files\n",

    QEMU_ARCH_ALL)

    stringify(DEFAULT_RAM_SIZE) "]\n", QEMU_ARCH_ALL)

    "-mem-path FILE  provide backing storage for guest RAM\n", QEMU_ARCH_ALL)

    "-mem-prealloc   preallocate guest memory (use with -mem-path)\n",

    QEMU_ARCH_ALL)

    "-k language     use keyboard layout (for example 'fr' for French)\n",

    QEMU_ARCH_ALL)

    "-audio-help     print list of audio drivers and their options\n",

    QEMU_ARCH_ALL)

    "                use -soundhw all to enable all of them\n", QEMU_ARCH_ALL)

    "-usb            enable the USB driver (will be the default soon)\n",

    QEMU_ARCH_ALL)

    "-usbdevice name add the host or guest USB device 'name'\n",

    QEMU_ARCH_ALL)

    "                use -device driver,option=? to print a help for value\n",

    QEMU_ARCH_ALL)

    "                string1 sets the window title and string2 the process name (on Linux)\n",

    QEMU_ARCH_ALL)

    "                specify machine UUID\n", QEMU_ARCH_ALL)

    "-nographic      disable graphical output and redirect serial I/Os to console\n",

    QEMU_ARCH_ALL)

    "-curses         use a curses/ncurses interface instead of SDL\n",

    QEMU_ARCH_ALL)

    "-no-frame       open SDL window without a frame and window decorations\n",

    QEMU_ARCH_ALL)

    "-alt-grab       use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n",

    QEMU_ARCH_ALL)

    "-ctrl-grab      use Right-Ctrl to grab mouse (instead of Ctrl-Alt)\n",

    QEMU_ARCH_ALL)

    "-no-quit        disable SDL window close capability\n", QEMU_ARCH_ALL)

    "-sdl            enable SDL\n", QEMU_ARCH_ALL)

    "-portrait       rotate graphical output 90 deg left (only PXA LCD)\n",

    QEMU_ARCH_ALL)

    "                select video card type\n", QEMU_ARCH_ALL)

    "-full-screen    start in full screen\n", QEMU_ARCH_ALL)

    "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n",

    QEMU_ARCH_PPC | QEMU_ARCH_SPARC)

    "-vnc display    start a VNC server on display\n", QEMU_ARCH_ALL)

    "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n",

    QEMU_ARCH_I386)

DEF("rtc-td-hack", 0, QEMU_OPTION_rtc_td_hack, "", QEMU_ARCH_I386)

    "-no-fd-bootchk  disable boot signature checking for floppy disks\n",

    QEMU_ARCH_I386)

           "-no-acpi        disable ACPI\n", QEMU_ARCH_I386)

    "-no-hpet        disable HPET\n", QEMU_ARCH_I386)

    "                enable virtio balloon device (default)\n", QEMU_ARCH_ALL)

    "                ACPI table description\n", QEMU_ARCH_I386)

    "                specify SMBIOS type 1 fields\n", QEMU_ARCH_I386)

DEF("tftp", HAS_ARG, QEMU_OPTION_tftp, "", QEMU_ARCH_ALL)

DEF("bootp", HAS_ARG, QEMU_OPTION_bootp, "", QEMU_ARCH_ALL)

DEF("redir", HAS_ARG, QEMU_OPTION_redir, "", QEMU_ARCH_ALL)

DEF("smb", HAS_ARG, QEMU_OPTION_smb, "", QEMU_ARCH_ALL)

    "                is provided, the default is '-net nic -net user'\n", QEMU_ARCH_ALL)

    "socket],id=str[,option][,option][,...]\n", QEMU_ARCH_ALL)

    , QEMU_ARCH_ALL

    "                emulate a bluetooth device 'dev' in scatternet 'n'\n",

    QEMU_ARCH_ALL)

    "-kernel bzImage use 'bzImage' as kernel image\n", QEMU_ARCH_ALL)

    "-append cmdline use 'cmdline' as kernel command line\n", QEMU_ARCH_ALL)

           "-initrd file    use 'file' as initial ram disk\n", QEMU_ARCH_ALL)

    "-serial dev     redirect the serial port to char device 'dev'\n",

    QEMU_ARCH_ALL)

    "-parallel dev   redirect the parallel port to char device 'dev'\n",

    QEMU_ARCH_ALL)

    "-monitor dev    redirect the monitor to char device 'dev'\n",

    QEMU_ARCH_ALL)

    "-qmp dev        like -monitor but opens in 'control' mode\n",

    QEMU_ARCH_ALL)

    "-mon chardev=[name][,mode=readline|control][,default]\n", QEMU_ARCH_ALL)

    "-debugcon dev   redirect the debug console to char device 'dev'\n",

    QEMU_ARCH_ALL)

    "-pidfile file   write PID to 'file'\n", QEMU_ARCH_ALL)

    "-singlestep     always run in singlestep mode\n", QEMU_ARCH_ALL)

    "-S              freeze CPU at startup (use 'c' to start execution)\n",

    QEMU_ARCH_ALL)

    "-gdb dev        wait for gdb connection on 'dev'\n", QEMU_ARCH_ALL)

    "-s              shorthand for -gdb tcp::" DEFAULT_GDBSTUB_PORT "\n",

    QEMU_ARCH_ALL)

    "-d item1,...    output log to /tmp/qemu.log (use -d ? for a list of log items)\n",

    QEMU_ARCH_ALL)

    "                translation (t=none or lba) (usually qemu can guess them)\n",

    QEMU_ARCH_ALL)

    "-L path         set the directory for the BIOS, VGA BIOS and keymaps\n",

    QEMU_ARCH_ALL)

    "-bios file      set the filename for the BIOS\n", QEMU_ARCH_ALL)

    "-enable-kvm     enable KVM full virtualization support\n", QEMU_ARCH_ALL)

    "-xen-domid id   specify xen guest domain id\n", QEMU_ARCH_ALL)

    "                warning: should not be used when xend is in use\n",

    QEMU_ARCH_ALL)

    "                xend will use this when starting qemu\n",

    QEMU_ARCH_ALL)

    "-no-reboot      exit instead of rebooting\n", QEMU_ARCH_ALL)

    "-no-shutdown    stop before shutdown\n", QEMU_ARCH_ALL)

    "                start right away with a saved state (loadvm in monitor)\n",

    QEMU_ARCH_ALL)

    "-daemonize      daemonize QEMU after initializing\n", QEMU_ARCH_ALL)

    "-option-rom rom load a file, rom, into the option ROM space\n",

    QEMU_ARCH_ALL)

    "                To see what timers are available use -clock ?\n",

    QEMU_ARCH_ALL)

DEF("localtime", 0, QEMU_OPTION_localtime, "", QEMU_ARCH_ALL)

DEF("startdate", HAS_ARG, QEMU_OPTION_startdate, "", QEMU_ARCH_ALL)