Archipelago » qemu

/*

 * QEMU System Emulator

 * 

 * Copyright (c) 2003-2007 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 "vl.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>

#ifdef _BSD

#include <sys/stat.h>

#ifndef __APPLE__

#include <libutil.h>

#endif

#else

#ifndef __sun__

#include <linux/if.h>

#include <linux/if_tun.h>

#include <pty.h>

#include <malloc.h>

#include <linux/rtc.h>

#include <linux/ppdev.h>

#include <linux/parport.h>

#else

#include <sys/stat.h>

#include <sys/ethernet.h>

#include <sys/sockio.h>

#include <arpa/inet.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

#if defined(CONFIG_SLIRP)

#include "libslirp.h"

#endif

#ifdef _WIN32

#include <malloc.h>

#include <sys/timeb.h>

#include <windows.h>

#define getopt_long_only getopt_long

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

#endif

#include "qemu_socket.h"

#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"

#ifdef __sun__

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

#else

#define SMBD_COMMAND "/usr/sbin/smbd"

#endif

//#define DEBUG_UNUSED_IOPORT

//#define DEBUG_IOPORT

#define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)

#ifdef TARGET_PPC

#define DEFAULT_RAM_SIZE 144

#else

#define DEFAULT_RAM_SIZE 128

#endif

/* in ms */

#define GUI_REFRESH_INTERVAL 30

/* 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;

char phys_ram_file[1024];

void *ioport_opaque[MAX_IOPORTS];

IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];

IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];

/* Note: bs_table[MAX_DISKS] is a dummy block driver if none available

   to store the VM snapshots */

BlockDriverState *bs_table[MAX_DISKS + 1], *fd_table[MAX_FD];

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

BlockDriverState *bs_snapshots;

int vga_ram_size;

static DisplayState display_state;

int nographic;

const char* keyboard_layout = NULL;

int64_t ticks_per_sec;

int boot_device = 'c';

int ram_size;

int pit_min_timer_count = 0;

int nb_nics;

NICInfo nd_table[MAX_NICS];

QEMUTimer *gui_timer;

int vm_running;

int rtc_utc = 1;

int cirrus_vga_enabled = 1;

#ifdef TARGET_SPARC

int graphic_width = 1024;

int graphic_height = 768;

#else

int graphic_width = 800;

int graphic_height = 600;

#endif

int graphic_depth = 15;

int full_screen = 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 daemonize = 0;

const char *option_rom[MAX_OPTION_ROMS];

int nb_option_roms;

int semihosting_enabled = 0;

int autostart = 1;

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

/* x86 ISA bus support */

target_phys_addr_t isa_mem_base = 0;

PicState2 *isa_pic;

uint32_t default_ioport_readb(void *opaque, uint32_t address)

{

#ifdef DEBUG_UNUSED_IOPORT

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

#endif

    return 0xff;

}

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

{

#ifdef DEBUG_UNUSED_IOPORT

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

#endif

}

/* default is to make two byte accesses */

uint32_t default_ioport_readw(void *opaque, uint32_t address)

{

    uint32_t data;

    data = ioport_read_table[0][address](ioport_opaque[address], address);

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

    data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;

    return data;

}

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

{

    ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);

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

    ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);

}

uint32_t default_ioport_readl(void *opaque, uint32_t address)

{

#ifdef DEBUG_UNUSED_IOPORT

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

#endif

    return 0xffffffff;

}

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

{

#ifdef DEBUG_UNUSED_IOPORT

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

#endif

}

void init_ioports(void)

{

    int i;

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

        ioport_read_table[0][i] = default_ioport_readb;

        ioport_write_table[0][i] = default_ioport_writeb;

        ioport_read_table[1][i] = default_ioport_readw;

        ioport_write_table[1][i] = default_ioport_writew;

        ioport_read_table[2][i] = default_ioport_readl;

        ioport_write_table[2][i] = default_ioport_writel;

    }

}

/* 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_table[0][addr](ioport_opaque[addr], 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_table[1][addr](ioport_opaque[addr], 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_table[2][addr](ioport_opaque[addr], 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_table[0][addr](ioport_opaque[addr], 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_table[1][addr](ioport_opaque[addr], 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_table[2][addr](ioport_opaque[addr], 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;

    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) {

        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

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

/* 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 (!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;

};

QEMUClock *rt_clock;

QEMUClock *vm_clock;

static QEMUTimer *active_timers[2];

#ifdef _WIN32

static MMRESULT timerID;

static HANDLE host_alarm = NULL;

static unsigned int period = 1;

#else

/* frequency of the times() clock tick */

static int timer_freq;

#endif

QEMUClock *qemu_new_clock(int type)

{

    QEMUClock *clock;

    clock = qemu_mallocz(sizeof(QEMUClock));

    if (!clock)

        return NULL;

    clock->type = type;

    return clock;

}

QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)

{

    QEMUTimer *ts;

    ts = qemu_mallocz(sizeof(QEMUTimer));

    ts->clock = clock;

    ts->cb = cb;

    ts->opaque = opaque;

    return ts;

}

void qemu_free_timer(QEMUTimer *ts)

{

    qemu_free(ts);

}

/* stop a timer, but do not dealloc it */

void qemu_del_timer(QEMUTimer *ts)

{

    QEMUTimer **pt, *t;

    /* NOTE: this code must be signal safe because

       qemu_timer_expired() can be called from a signal. */

    pt = &active_timers[ts->clock->type];

    for(;;) {

        t = *pt;

        if (!t)

            break;

        if (t == ts) {

            *pt = t->next;

            break;

        }

        pt = &t->next;

    }

}

/* modify the current timer so that it will be fired when current_time

   >= expire_time. The corresponding callback will be called. */

void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)

{

    QEMUTimer **pt, *t;

    qemu_del_timer(ts);

    /* add the timer in the sorted list */

    /* NOTE: this code must be signal safe because

       qemu_timer_expired() can be called from a signal. */

    pt = &active_timers[ts->clock->type];

    for(;;) {

        t = *pt;

        if (!t)

            break;

        if (t->expire_time > expire_time) 

            break;

        pt = &t->next;

    }

    ts->expire_time = expire_time;

    ts->next = *pt;

    *pt = ts;

}

int qemu_timer_pending(QEMUTimer *ts)

{

    QEMUTimer *t;

    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {

        if (t == ts)

            return 1;

    }

    return 0;

}

static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)

{

    if (!timer_head)

        return 0;

    return (timer_head->expire_time <= current_time);

}

static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)

{

    QEMUTimer *ts;

    for(;;) {

        ts = *ptimer_head;

        if (!ts || ts->expire_time > current_time)

            break;

        /* remove timer from the list before calling the callback */

        *ptimer_head = ts->next;

        ts->next = NULL;

        /* run the callback (the timer list can be modified) */

        ts->cb(ts->opaque);

    }

}

int64_t qemu_get_clock(QEMUClock *clock)

{

    switch(clock->type) {

    case QEMU_TIMER_REALTIME:

        return get_clock() / 1000000;

    default:

    case QEMU_TIMER_VIRTUAL:

        return cpu_get_clock();

    }

}

static void init_timers(void)

{

    init_get_clock();

    ticks_per_sec = QEMU_TIMER_BASE;

    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);

    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);