Archipelago » qemu

/*

 * 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 "hw/hw.h"

#include "hw/boards.h"

#include "hw/usb.h"

#include "hw/pcmcia.h"

#include "hw/pc.h"

#include "hw/audiodev.h"

#include "hw/isa.h"

#include "hw/baum.h"

#include "net.h"

#include "console.h"

#include "sysemu.h"

#include "gdbstub.h"

#include "qemu-timer.h"

#include "qemu-char.h"

#include "block.h"

#include "audio/audio.h"

#include <unistd.h>

#include <fcntl.h>

#include <signal.h>

#include <time.h>

#include <errno.h>

#include <sys/time.h>

#include <zlib.h>

#ifndef _WIN32

#include <sys/times.h>

#include <sys/wait.h>

#include <termios.h>

#include <sys/poll.h>

#include <sys/mman.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <dirent.h>

#include <netdb.h>

#include <sys/select.h>

#include <arpa/inet.h>

#ifdef _BSD

#include <sys/stat.h>

#if !defined(__APPLE__) && !defined(__OpenBSD__)

#include <libutil.h>

#endif

#ifdef __OpenBSD__

#include <net/if.h>

#endif

#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)

#include <freebsd/stdlib.h>

#else

#ifndef __sun__

#include <linux/if.h>

#include <linux/if_tun.h>

#include <pty.h>

#include <malloc.h>

#include <linux/rtc.h>

/* For the benefit of older linux systems which don't supply it,

   we use a local copy of hpet.h. */

/* #include <linux/hpet.h> */

#include "hpet.h"

#include <linux/ppdev.h>

#include <linux/parport.h>

#else

#include <sys/stat.h>

#include <sys/ethernet.h>

#include <sys/sockio.h>

#include <netinet/arp.h>

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h> // must come after ip.h

#include <netinet/udp.h>

#include <netinet/tcp.h>

#include <net/if.h>

#include <syslog.h>

#include <stropts.h>

#endif

#endif

#endif

#include "qemu_socket.h"

#if defined(CONFIG_SLIRP)

#include "libslirp.h"

#endif

#if defined(__OpenBSD__)

#include <util.h>

#endif

#if defined(CONFIG_VDE)

#include <libvdeplug.h>

#endif

#ifdef _WIN32

#include <malloc.h>

#include <sys/timeb.h>

#include <mmsystem.h>

#define getopt_long_only getopt_long

#define memalign(align, size) malloc(size)

#endif

#ifdef CONFIG_SDL

#ifdef __APPLE__

#include <SDL/SDL.h>

#endif

#endif /* CONFIG_SDL */

#ifdef CONFIG_COCOA

#undef main

#define main qemu_main

#endif /* CONFIG_COCOA */

#include "disas.h"

#include "exec-all.h"

#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"

#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"

#ifdef __sun__

#define SMBD_COMMAND "/usr/sfw/sbin/smbd"

#else

#define SMBD_COMMAND "/usr/sbin/smbd"

#endif

//#define DEBUG_UNUSED_IOPORT

//#define DEBUG_IOPORT

#ifdef TARGET_PPC

#define DEFAULT_RAM_SIZE 144

#else

#define DEFAULT_RAM_SIZE 128

#endif

/* Max number of USB devices that can be specified on the commandline.  */

#define MAX_USB_CMDLINE 8

/* XXX: use a two level table to limit memory usage */

#define MAX_IOPORTS 65536

const char *bios_dir = CONFIG_QEMU_SHAREDIR;

const char *bios_name = NULL;

void *ioport_opaque[MAX_IOPORTS];

IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];

IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];

/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available

   to store the VM snapshots */

DriveInfo drives_table[MAX_DRIVES+1];

int nb_drives;

/* point to the block driver where the snapshots are managed */

BlockDriverState *bs_snapshots;

int vga_ram_size;

static DisplayState display_state;

int nographic;

int curses;

const char* keyboard_layout = NULL;

int64_t ticks_per_sec;

ram_addr_t ram_size;

int pit_min_timer_count = 0;

int nb_nics;

NICInfo nd_table[MAX_NICS];

int vm_running;

static int rtc_utc = 1;

static int rtc_date_offset = -1; /* -1 means no change */

int cirrus_vga_enabled = 1;

int vmsvga_enabled = 0;

#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

int full_screen = 0;

int no_frame = 0;

int no_quit = 0;

CharDriverState *serial_hds[MAX_SERIAL_PORTS];

CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];

#ifdef TARGET_I386

int win2k_install_hack = 0;

#endif

int usb_enabled = 0;

static VLANState *first_vlan;

int smp_cpus = 1;

const char *vnc_display;

#if defined(TARGET_SPARC)

#define MAX_CPUS 16

#elif defined(TARGET_I386)

#define MAX_CPUS 255

#else

#define MAX_CPUS 1

#endif

int acpi_enabled = 1;

int fd_bootchk = 1;

int no_reboot = 0;

int no_shutdown = 0;

int cursor_hide = 1;

int graphic_rotate = 0;

int daemonize = 0;

const char *option_rom[MAX_OPTION_ROMS];

int nb_option_roms;

int semihosting_enabled = 0;

int autostart = 1;

#ifdef TARGET_ARM

int old_param = 0;

#endif

const char *qemu_name;

int alt_grab = 0;

#ifdef TARGET_SPARC

unsigned int nb_prom_envs = 0;

const char *prom_envs[MAX_PROM_ENVS];

#endif

int nb_drives_opt;

struct drive_opt {

    const char *file;

    char opt[1024];

} drives_opt[MAX_DRIVES];

static CPUState *cur_cpu;

static CPUState *next_cpu;

static int event_pending = 1;

/* Conversion factor from emulated instructions to virtual clock ticks.  */

static int icount_time_shift;

/* Arbitrarily pick 1MIPS as the minimum allowable speed.  */

#define MAX_ICOUNT_SHIFT 10

/* Compensate for varying guest execution speed.  */

static int64_t qemu_icount_bias;

QEMUTimer *icount_rt_timer;

QEMUTimer *icount_vm_timer;

uint8_t qemu_uuid[16];

#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)

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

/* x86 ISA bus support */

target_phys_addr_t isa_mem_base = 0;

PicState2 *isa_pic;

static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;

static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;

static uint32_t ioport_read(int index, uint32_t address)

{

    static IOPortReadFunc *default_func[3] = {

        default_ioport_readb,

        default_ioport_readw,

        default_ioport_readl

    };

    IOPortReadFunc *func = ioport_read_table[index][address];

    if (!func)

        func = default_func[index];

    return func(ioport_opaque[address], address);

}

static void ioport_write(int index, uint32_t address, uint32_t data)

{

    static IOPortWriteFunc *default_func[3] = {

        default_ioport_writeb,

        default_ioport_writew,

        default_ioport_writel

    };

    IOPortWriteFunc *func = ioport_write_table[index][address];

    if (!func)

        func = default_func[index];

    func(ioport_opaque[address], address, data);

}

static uint32_t default_ioport_readb(void *opaque, uint32_t address)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "unused inb: port=0x%04x\n", address);

#endif

    return 0xff;

}

static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);

#endif

}

/* default is to make two byte accesses */

static uint32_t default_ioport_readw(void *opaque, uint32_t address)

{

    uint32_t data;

    data = ioport_read(0, address);

    address = (address + 1) & (MAX_IOPORTS - 1);

    data |= ioport_read(0, address) << 8;

    return data;

}

static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)

{

    ioport_write(0, address, data & 0xff);

    address = (address + 1) & (MAX_IOPORTS - 1);

    ioport_write(0, address, (data >> 8) & 0xff);

}

static uint32_t default_ioport_readl(void *opaque, uint32_t address)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "unused inl: port=0x%04x\n", address);

#endif

    return 0xffffffff;

}

static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)

{

#ifdef DEBUG_UNUSED_IOPORT

    fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);

#endif

}

/* size is the word size in byte */

int register_ioport_read(int start, int length, int size,

                         IOPortReadFunc *func, void *opaque)

{

    int i, bsize;

    if (size == 1) {

        bsize = 0;

    } else if (size == 2) {

        bsize = 1;

    } else if (size == 4) {

        bsize = 2;

    } else {

        hw_error("register_ioport_read: invalid size");

        return -1;

    }

    for(i = start; i < start + length; i += size) {

        ioport_read_table[bsize][i] = func;

        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)

            hw_error("register_ioport_read: invalid opaque");

        ioport_opaque[i] = opaque;

    }

    return 0;

}

/* size is the word size in byte */

int register_ioport_write(int start, int length, int size,

                          IOPortWriteFunc *func, void *opaque)

{

    int i, bsize;

    if (size == 1) {

        bsize = 0;

    } else if (size == 2) {

        bsize = 1;

    } else if (size == 4) {

        bsize = 2;

    } else {

        hw_error("register_ioport_write: invalid size");

        return -1;

    }

    for(i = start; i < start + length; i += size) {

        ioport_write_table[bsize][i] = func;

        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)

            hw_error("register_ioport_write: invalid opaque");

        ioport_opaque[i] = opaque;

    }

    return 0;

}

void isa_unassign_ioport(int start, int length)

{

    int i;

    for(i = start; i < start + length; i++) {

        ioport_read_table[0][i] = default_ioport_readb;

        ioport_read_table[1][i] = default_ioport_readw;

        ioport_read_table[2][i] = default_ioport_readl;

        ioport_write_table[0][i] = default_ioport_writeb;

        ioport_write_table[1][i] = default_ioport_writew;

        ioport_write_table[2][i] = default_ioport_writel;

    }

}

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

void cpu_outb(CPUState *env, int addr, int val)

{

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "outb: %04x %02x\n", addr, val);

#endif

    ioport_write(0, addr, val);

#ifdef USE_KQEMU

    if (env)

        env->last_io_time = cpu_get_time_fast();

#endif

}

void cpu_outw(CPUState *env, int addr, int val)

{

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "outw: %04x %04x\n", addr, val);

#endif

    ioport_write(1, addr, val);

#ifdef USE_KQEMU

    if (env)

        env->last_io_time = cpu_get_time_fast();

#endif

}

void cpu_outl(CPUState *env, int addr, int val)

{

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "outl: %04x %08x\n", addr, val);

#endif

    ioport_write(2, addr, val);

#ifdef USE_KQEMU

    if (env)

        env->last_io_time = cpu_get_time_fast();

#endif

}

int cpu_inb(CPUState *env, int addr)

{

    int val;

    val = ioport_read(0, addr);

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "inb : %04x %02x\n", addr, val);

#endif

#ifdef USE_KQEMU

    if (env)

        env->last_io_time = cpu_get_time_fast();

#endif

    return val;

}

int cpu_inw(CPUState *env, int addr)

{

    int val;

    val = ioport_read(1, addr);

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "inw : %04x %04x\n", addr, val);

#endif

#ifdef USE_KQEMU

    if (env)

        env->last_io_time = cpu_get_time_fast();

#endif

    return val;

}

int cpu_inl(CPUState *env, int addr)

{

    int val;

    val = ioport_read(2, addr);

#ifdef DEBUG_IOPORT

    if (loglevel & CPU_LOG_IOPORT)

        fprintf(logfile, "inl : %04x %08x\n", addr, val);

#endif

#ifdef USE_KQEMU

    if (env)

        env->last_io_time = cpu_get_time_fast();

#endif

    return val;

}

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

void hw_error(const char *fmt, ...)

{

    va_list ap;

    CPUState *env;

    va_start(ap, fmt);

    fprintf(stderr, "qemu: hardware error: ");

    vfprintf(stderr, fmt, ap);

    fprintf(stderr, "\n");

    for(env = first_cpu; env != NULL; env = env->next_cpu) {

        fprintf(stderr, "CPU #%d:\n", env->cpu_index);

#ifdef TARGET_I386

        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);

#else

        cpu_dump_state(env, stderr, fprintf, 0);

#endif

    }

    va_end(ap);

    abort();

}

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

/* keyboard/mouse */

static QEMUPutKBDEvent *qemu_put_kbd_event;

static void *qemu_put_kbd_event_opaque;

static QEMUPutMouseEntry *qemu_put_mouse_event_head;

static QEMUPutMouseEntry *qemu_put_mouse_event_current;

void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)

{

    qemu_put_kbd_event_opaque = opaque;

    qemu_put_kbd_event = func;

}

QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,

                                                void *opaque, int absolute,

                                                const char *name)

{

    QEMUPutMouseEntry *s, *cursor;

    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));

    if (!s)

        return NULL;

    s->qemu_put_mouse_event = func;

    s->qemu_put_mouse_event_opaque = opaque;

    s->qemu_put_mouse_event_absolute = absolute;

    s->qemu_put_mouse_event_name = qemu_strdup(name);

    s->next = NULL;

    if (!qemu_put_mouse_event_head) {

        qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;

        return s;

    }

    cursor = qemu_put_mouse_event_head;

    while (cursor->next != NULL)

        cursor = cursor->next;

    cursor->next = s;

    qemu_put_mouse_event_current = s;

    return s;

}

void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)

{

    QEMUPutMouseEntry *prev = NULL, *cursor;

    if (!qemu_put_mouse_event_head || entry == NULL)

        return;

    cursor = qemu_put_mouse_event_head;

    while (cursor != NULL && cursor != entry) {

        prev = cursor;

        cursor = cursor->next;

    }

    if (cursor == NULL) // does not exist or list empty

        return;

    else if (prev == NULL) { // entry is head

        qemu_put_mouse_event_head = cursor->next;

        if (qemu_put_mouse_event_current == entry)

            qemu_put_mouse_event_current = cursor->next;

        qemu_free(entry->qemu_put_mouse_event_name);

        qemu_free(entry);

        return;

    }

    prev->next = entry->next;

    if (qemu_put_mouse_event_current == entry)

        qemu_put_mouse_event_current = prev;

    qemu_free(entry->qemu_put_mouse_event_name);

    qemu_free(entry);

}

void kbd_put_keycode(int keycode)

{

    if (qemu_put_kbd_event) {

        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);

    }

}

void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)

{

    QEMUPutMouseEvent *mouse_event;

    void *mouse_event_opaque;

    int width;

    if (!qemu_put_mouse_event_current) {

        return;

    }

    mouse_event =

        qemu_put_mouse_event_current->qemu_put_mouse_event;

    mouse_event_opaque =

        qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;

    if (mouse_event) {

        if (graphic_rotate) {

            if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)

                width = 0x7fff;

            else

                width = graphic_width - 1;

            mouse_event(mouse_event_opaque,

                                 width - dy, dx, dz, buttons_state);

        } else

            mouse_event(mouse_event_opaque,

                                 dx, dy, dz, buttons_state);

    }

}

int kbd_mouse_is_absolute(void)

{

    if (!qemu_put_mouse_event_current)

        return 0;

    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;

}

void do_info_mice(void)

{

    QEMUPutMouseEntry *cursor;

    int index = 0;

    if (!qemu_put_mouse_event_head) {

        term_printf("No mouse devices connected\n");

        return;

    }

    term_printf("Mouse devices available:\n");

    cursor = qemu_put_mouse_event_head;

    while (cursor != NULL) {

        term_printf("%c Mouse #%d: %s\n",

                    (cursor == qemu_put_mouse_event_current ? '*' : ' '),

                    index, cursor->qemu_put_mouse_event_name);

        index++;

        cursor = cursor->next;

    }

}

void do_mouse_set(int index)

{

    QEMUPutMouseEntry *cursor;

    int i = 0;

    if (!qemu_put_mouse_event_head) {

        term_printf("No mouse devices connected\n");

        return;

    }

    cursor = qemu_put_mouse_event_head;

    while (cursor != NULL && index != i) {

        i++;

        cursor = cursor->next;

    }

    if (cursor != NULL)

        qemu_put_mouse_event_current = cursor;

    else

        term_printf("Mouse at given index not found\n");

}

/* compute with 96 bit intermediate result: (a*b)/c */

uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)

{

    union {

        uint64_t ll;

        struct {

#ifdef WORDS_BIGENDIAN

            uint32_t high, low;

#else

            uint32_t low, high;

#endif

        } l;

    } u, res;

    uint64_t rl, rh;

    u.ll = a;

    rl = (uint64_t)u.l.low * (uint64_t)b;

    rh = (uint64_t)u.l.high * (uint64_t)b;

    rh += (rl >> 32);

    res.l.high = rh / c;

    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;

    return res.ll;

}

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

/* real time host monotonic timer */

#define QEMU_TIMER_BASE 1000000000LL

#ifdef WIN32

static int64_t clock_freq;

static void init_get_clock(void)

{

    LARGE_INTEGER freq;

    int ret;

    ret = QueryPerformanceFrequency(&freq);

    if (ret == 0) {

        fprintf(stderr, "Could not calibrate ticks\n");

        exit(1);

    }

    clock_freq = freq.QuadPart;

}

static int64_t get_clock(void)

{

    LARGE_INTEGER ti;

    QueryPerformanceCounter(&ti);

    return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);

}

#else

static int use_rt_clock;

static void init_get_clock(void)

{

    use_rt_clock = 0;

#if defined(__linux__)

    {

        struct timespec ts;

        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {

            use_rt_clock = 1;

        }

    }

#endif

}

static int64_t get_clock(void)

{

#if defined(__linux__)

    if (use_rt_clock) {

        struct timespec ts;

        clock_gettime(CLOCK_MONOTONIC, &ts);

        return ts.tv_sec * 1000000000LL + ts.tv_nsec;

    } else

#endif

    {

        /* XXX: using gettimeofday leads to problems if the date

           changes, so it should be avoided. */

        struct timeval tv;

        gettimeofday(&tv, NULL);

        return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);

    }

}

#endif

/* Return the virtual CPU time, based on the instruction counter.  */

static int64_t cpu_get_icount(void)

{

    int64_t icount;

    CPUState *env = cpu_single_env;;

    icount = qemu_icount;

    if (env) {

        if (!can_do_io(env))

            fprintf(stderr, "Bad clock read\n");

        icount -= (env->icount_decr.u16.low + env->icount_extra);

    }

    return qemu_icount_bias + (icount << icount_time_shift);

}

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

/* guest cycle counter */

static int64_t cpu_ticks_prev;

static int64_t cpu_ticks_offset;

static int64_t cpu_clock_offset;

static int cpu_ticks_enabled;

/* return the host CPU cycle counter and handle stop/restart */

int64_t cpu_get_ticks(void)

{

    if (use_icount) {

        return cpu_get_icount();

    }

    if (!cpu_ticks_enabled) {

        return cpu_ticks_offset;

    } else {

        int64_t ticks;

        ticks = cpu_get_real_ticks();

        if (cpu_ticks_prev > ticks) {

            /* Note: non increasing ticks may happen if the host uses

               software suspend */

            cpu_ticks_offset += cpu_ticks_prev - ticks;

        }

        cpu_ticks_prev = ticks;

        return ticks + cpu_ticks_offset;

    }

}

/* return the host CPU monotonic timer and handle stop/restart */

static int64_t cpu_get_clock(void)

{

    int64_t ti;

    if (!cpu_ticks_enabled) {

        return cpu_clock_offset;

    } else {

        ti = get_clock();

        return ti + cpu_clock_offset;

    }

}

/* enable cpu_get_ticks() */

void cpu_enable_ticks(void)

{

    if (!cpu_ticks_enabled) {

        cpu_ticks_offset -= cpu_get_real_ticks();

        cpu_clock_offset -= get_clock();

        cpu_ticks_enabled = 1;

    }

}

/* disable cpu_get_ticks() : the clock is stopped. You must not call

   cpu_get_ticks() after that.  */

void cpu_disable_ticks(void)

{

    if (cpu_ticks_enabled) {

        cpu_ticks_offset = cpu_get_ticks();

        cpu_clock_offset = cpu_get_clock();

        cpu_ticks_enabled = 0;

    }

}

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

/* timers */

#define QEMU_TIMER_REALTIME 0

#define QEMU_TIMER_VIRTUAL  1

struct QEMUClock {

    int type;

    /* XXX: add frequency */

};

struct QEMUTimer {

    QEMUClock *clock;

    int64_t expire_time;

    QEMUTimerCB *cb;

    void *opaque;

    struct QEMUTimer *next;

};

struct qemu_alarm_timer {

    char const *name;

    unsigned int flags;

    int (*start)(struct qemu_alarm_timer *t);

    void (*stop)(struct qemu_alarm_timer *t);

    void (*rearm)(struct qemu_alarm_timer *t);

    void *priv;

};

#define ALARM_FLAG_DYNTICKS  0x1

#define ALARM_FLAG_EXPIRED   0x2

static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)

{