X-Git-Url: http://vcs.maemo.org/git/?a=blobdiff_plain;f=vl.c;h=c3894b8017ad81b227eb8032a9f85c5136fd0974;hb=90cb94935228cc064f99fe98e70a8ea5deefb689;hp=e2e1393032cc2a1d8ff8ab7d82c3bafbd1c7048d;hpb=a735aa3139c5b9785eac09dcf6384d89c8d8c445;p=qemu diff --git a/vl.c b/vl.c index e2e1393..c3894b8 100644 --- a/vl.c +++ b/vl.c @@ -1,7 +1,7 @@ /* - * QEMU PC System Emulator + * QEMU System Emulator * - * Copyright (c) 2003 Fabrice Bellard + * Copyright (c) 2003-2005 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 @@ -21,62 +21,72 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -#include -#include -#include -#include -#include -#include -#include +#include "vl.h" + #include -#include #include #include #include +#include #include -#include + +#ifndef _WIN32 +#include +#include #include #include -#include -#include - +#include #include #include +#include +#include +#ifdef _BSD +#include +#ifndef __APPLE__ +#include +#endif +#else #include #include +#include +#include +#include +#endif +#endif -#include "disas.h" -#include "thunk.h" - -#include "vl.h" - -#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup" -#define BIOS_FILENAME "bios.bin" -#define VGABIOS_FILENAME "vgabios.bin" -#define LINUX_BOOT_FILENAME "linux_boot.bin" - -//#define DEBUG_UNUSED_IOPORT +#if defined(CONFIG_SLIRP) +#include "libslirp.h" +#endif -//#define DEBUG_IRQ_LATENCY +#ifdef _WIN32 +#include +#include +#include +#define getopt_long_only getopt_long +#define memalign(align, size) malloc(size) +#endif -/* output Bochs bios info messages */ -//#define DEBUG_BIOS +#ifdef CONFIG_SDL +#ifdef __APPLE__ +#include +#endif +#endif /* CONFIG_SDL */ -//#define DEBUG_CMOS +#ifdef CONFIG_COCOA +#undef main +#define main qemu_main +#endif /* CONFIG_COCOA */ -/* debug PIC */ -//#define DEBUG_PIC +#include "disas.h" -/* debug NE2000 card */ -//#define DEBUG_NE2000 +#include "exec-all.h" -/* debug PC keyboard */ -//#define DEBUG_KBD +//#define DO_TB_FLUSH -/* debug PC keyboard : only mouse */ -//#define DEBUG_MOUSE +#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup" -//#define DEBUG_SERIAL +//#define DEBUG_UNUSED_IOPORT +//#define DEBUG_IOPORT #if !defined(CONFIG_SOFTMMU) #define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024) @@ -84,46 +94,70 @@ #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024) #endif -#if defined (TARGET_I386) -#define KERNEL_LOAD_ADDR 0x00100000 -#elif defined (TARGET_PPC) -//#define USE_OPEN_FIRMWARE -#if !defined (USE_OPEN_FIRMWARE) -#define KERNEL_LOAD_ADDR 0x01000000 -#define KERNEL_STACK_ADDR 0x01200000 +#ifdef TARGET_PPC +#define DEFAULT_RAM_SIZE 144 #else -#define KERNEL_LOAD_ADDR 0x00000000 -#define KERNEL_STACK_ADDR 0x00400000 +#define DEFAULT_RAM_SIZE 128 #endif -#endif -#define INITRD_LOAD_ADDR 0x00400000 -#define KERNEL_PARAMS_ADDR 0x00090000 -#define KERNEL_CMDLINE_ADDR 0x00099000 - -#define GUI_REFRESH_INTERVAL 30 +/* in ms */ +#define GUI_REFRESH_INTERVAL 30 /* XXX: use a two level table to limit memory usage */ #define MAX_IOPORTS 65536 -static const char *bios_dir = CONFIG_QEMU_SHAREDIR; +const char *bios_dir = CONFIG_QEMU_SHAREDIR; char phys_ram_file[1024]; CPUState *global_env; CPUState *cpu_single_env; +void *ioport_opaque[MAX_IOPORTS]; IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS]; IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS]; BlockDriverState *bs_table[MAX_DISKS], *fd_table[MAX_FD]; int vga_ram_size; +int bios_size; static DisplayState display_state; int nographic; -int term_inited; +const char* keyboard_layout = NULL; int64_t ticks_per_sec; int boot_device = 'c'; -static int ram_size; +int ram_size; +static char network_script[1024]; +int pit_min_timer_count = 0; +int nb_nics; +NetDriverState nd_table[MAX_NICS]; +QEMUTimer *gui_timer; +int vm_running; +int audio_enabled = 0; +int sb16_enabled = 1; +int adlib_enabled = 1; +int gus_enabled = 1; +int pci_enabled = 1; +int prep_enabled = 0; +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; +TextConsole *vga_console; +CharDriverState *serial_hds[MAX_SERIAL_PORTS]; +CharDriverState *parallel_hds[MAX_PARALLEL_PORTS]; +#ifdef TARGET_I386 +int win2k_install_hack = 0; +#endif /***********************************************************/ -/* x86 io ports */ +/* x86 ISA bus support */ -uint32_t default_ioport_readb(CPUState *env, uint32_t address) +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); @@ -131,7 +165,7 @@ uint32_t default_ioport_readb(CPUState *env, uint32_t address) return 0xff; } -void default_ioport_writeb(CPUState *env, uint32_t address, uint32_t data) +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); @@ -139,21 +173,23 @@ void default_ioport_writeb(CPUState *env, uint32_t address, uint32_t data) } /* default is to make two byte accesses */ -uint32_t default_ioport_readw(CPUState *env, uint32_t address) +uint32_t default_ioport_readw(void *opaque, uint32_t address) { uint32_t data; - data = ioport_read_table[0][address & (MAX_IOPORTS - 1)](env, address); - data |= ioport_read_table[0][(address + 1) & (MAX_IOPORTS - 1)](env, address + 1) << 8; + 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(CPUState *env, uint32_t address, uint32_t data) +void default_ioport_writew(void *opaque, uint32_t address, uint32_t data) { - ioport_write_table[0][address & (MAX_IOPORTS - 1)](env, address, data & 0xff); - ioport_write_table[0][(address + 1) & (MAX_IOPORTS - 1)](env, address + 1, (data >> 8) & 0xff); + 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(CPUState *env, uint32_t address) +uint32_t default_ioport_readl(void *opaque, uint32_t address) { #ifdef DEBUG_UNUSED_IOPORT fprintf(stderr, "inl: port=0x%04x\n", address); @@ -161,7 +197,7 @@ uint32_t default_ioport_readl(CPUState *env, uint32_t address) return 0xffffffff; } -void default_ioport_writel(CPUState *env, uint32_t address, uint32_t data) +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); @@ -183,41 +219,72 @@ void init_ioports(void) } /* size is the word size in byte */ -int register_ioport_read(int start, int length, IOPortReadFunc *func, int size) +int register_ioport_read(int start, int length, int size, + IOPortReadFunc *func, void *opaque) { int i, bsize; - if (size == 1) + if (size == 1) { bsize = 0; - else if (size == 2) + } else if (size == 2) { bsize = 1; - else if (size == 4) + } else if (size == 4) { bsize = 2; - else + } else { + hw_error("register_ioport_read: invalid size"); return -1; - for(i = start; i < start + length; i += size) + } + 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, IOPortWriteFunc *func, int size) +int register_ioport_write(int start, int length, int size, + IOPortWriteFunc *func, void *opaque) { int i, bsize; - if (size == 1) + if (size == 1) { bsize = 0; - else if (size == 2) + } else if (size == 2) { bsize = 1; - else if (size == 4) + } else if (size == 4) { bsize = 2; - else + } else { + hw_error("register_ioport_write: invalid size"); return -1; - for(i = start; i < start + length; i += size) + } + 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_read: 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 pstrcpy(char *buf, int buf_size, const char *str) { int c; @@ -245,44 +312,39 @@ char *pstrcat(char *buf, int buf_size, const char *s) return buf; } -#if defined (TARGET_I386) -int load_kernel(const char *filename, uint8_t *addr, - uint8_t *real_addr) +int strstart(const char *str, const char *val, const char **ptr) { - int fd, size; - int setup_sects; + const char *p, *q; + p = str; + q = val; + while (*q != '\0') { + if (*p != *q) + return 0; + p++; + q++; + } + if (ptr) + *ptr = p; + return 1; +} - fd = open(filename, O_RDONLY); +/* return the size or -1 if error */ +int get_image_size(const char *filename) +{ + int fd, size; + fd = open(filename, O_RDONLY | O_BINARY); if (fd < 0) return -1; - - /* load 16 bit code */ - if (read(fd, real_addr, 512) != 512) - goto fail; - setup_sects = real_addr[0x1F1]; - if (!setup_sects) - setup_sects = 4; - if (read(fd, real_addr + 512, setup_sects * 512) != - setup_sects * 512) - goto fail; - - /* load 32 bit code */ - size = read(fd, addr, 16 * 1024 * 1024); - if (size < 0) - goto fail; + size = lseek(fd, 0, SEEK_END); close(fd); return size; - fail: - close(fd); - return -1; } -#endif /* return the size or -1 if error */ int load_image(const char *filename, uint8_t *addr) { int fd, size; - fd = open(filename, O_RDONLY); + fd = open(filename, O_RDONLY | O_BINARY); if (fd < 0) return -1; size = lseek(fd, 0, SEEK_END); @@ -297,39 +359,65 @@ int load_image(const char *filename, uint8_t *addr) void cpu_outb(CPUState *env, int addr, int val) { - ioport_write_table[0][addr & (MAX_IOPORTS - 1)](env, addr, 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); } void cpu_outw(CPUState *env, int addr, int val) { - ioport_write_table[1][addr & (MAX_IOPORTS - 1)](env, addr, 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); } void cpu_outl(CPUState *env, int addr, int val) { - ioport_write_table[2][addr & (MAX_IOPORTS - 1)](env, addr, 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); } int cpu_inb(CPUState *env, int addr) { - return ioport_read_table[0][addr & (MAX_IOPORTS - 1)](env, 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 + return val; } int cpu_inw(CPUState *env, int addr) { - return ioport_read_table[1][addr & (MAX_IOPORTS - 1)](env, 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 + return val; } int cpu_inl(CPUState *env, int addr) { - return ioport_read_table[2][addr & (MAX_IOPORTS - 1)](env, 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 + return val; } /***********************************************************/ -void ioport80_write(CPUState *env, uint32_t addr, uint32_t data) -{ -} - void hw_error(const char *fmt, ...) { va_list ap; @@ -339,620 +427,51 @@ void hw_error(const char *fmt, ...) vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); #ifdef TARGET_I386 - cpu_x86_dump_state(global_env, stderr, X86_DUMP_FPU | X86_DUMP_CCOP); + cpu_dump_state(global_env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP); #else - cpu_dump_state(global_env, stderr, 0); + cpu_dump_state(global_env, stderr, fprintf, 0); #endif va_end(ap); abort(); } /***********************************************************/ -/* cmos emulation */ - -#if defined (TARGET_I386) -#define RTC_SECONDS 0 -#define RTC_SECONDS_ALARM 1 -#define RTC_MINUTES 2 -#define RTC_MINUTES_ALARM 3 -#define RTC_HOURS 4 -#define RTC_HOURS_ALARM 5 -#define RTC_ALARM_DONT_CARE 0xC0 - -#define RTC_DAY_OF_WEEK 6 -#define RTC_DAY_OF_MONTH 7 -#define RTC_MONTH 8 -#define RTC_YEAR 9 - -#define RTC_REG_A 10 -#define RTC_REG_B 11 -#define RTC_REG_C 12 -#define RTC_REG_D 13 - -/* PC cmos mappings */ -#define REG_EQUIPMENT_BYTE 0x14 -#define REG_IBM_CENTURY_BYTE 0x32 -#define REG_IBM_PS2_CENTURY_BYTE 0x37 - -uint8_t cmos_data[128]; -uint8_t cmos_index; - -void cmos_ioport_write(CPUState *env, uint32_t addr, uint32_t data) -{ - if (addr == 0x70) { - cmos_index = data & 0x7f; - } else { -#ifdef DEBUG_CMOS - printf("cmos: write index=0x%02x val=0x%02x\n", - cmos_index, data); -#endif - switch(addr) { - case RTC_SECONDS_ALARM: - case RTC_MINUTES_ALARM: - case RTC_HOURS_ALARM: - /* XXX: not supported */ - cmos_data[cmos_index] = data; - break; - case RTC_SECONDS: - case RTC_MINUTES: - case RTC_HOURS: - case RTC_DAY_OF_WEEK: - case RTC_DAY_OF_MONTH: - case RTC_MONTH: - case RTC_YEAR: - cmos_data[cmos_index] = data; - break; - case RTC_REG_A: - case RTC_REG_B: - cmos_data[cmos_index] = data; - break; - case RTC_REG_C: - case RTC_REG_D: - /* cannot write to them */ - break; - default: - cmos_data[cmos_index] = data; - break; - } - } -} - -static inline int to_bcd(int a) -{ - return ((a / 10) << 4) | (a % 10); -} - -static void cmos_update_time(void) -{ - struct tm *tm; - time_t ti; - - ti = time(NULL); - tm = gmtime(&ti); - cmos_data[RTC_SECONDS] = to_bcd(tm->tm_sec); - cmos_data[RTC_MINUTES] = to_bcd(tm->tm_min); - cmos_data[RTC_HOURS] = to_bcd(tm->tm_hour); - cmos_data[RTC_DAY_OF_WEEK] = to_bcd(tm->tm_wday); - cmos_data[RTC_DAY_OF_MONTH] = to_bcd(tm->tm_mday); - cmos_data[RTC_MONTH] = to_bcd(tm->tm_mon + 1); - cmos_data[RTC_YEAR] = to_bcd(tm->tm_year % 100); - cmos_data[REG_IBM_CENTURY_BYTE] = to_bcd((tm->tm_year / 100) + 19); - cmos_data[REG_IBM_PS2_CENTURY_BYTE] = cmos_data[REG_IBM_CENTURY_BYTE]; -} - -uint32_t cmos_ioport_read(CPUState *env, uint32_t addr) -{ - int ret; - - if (addr == 0x70) { - return 0xff; - } else { - switch(cmos_index) { - case RTC_SECONDS: - case RTC_MINUTES: - case RTC_HOURS: - case RTC_DAY_OF_WEEK: - case RTC_DAY_OF_MONTH: - case RTC_MONTH: - case RTC_YEAR: - case REG_IBM_CENTURY_BYTE: - case REG_IBM_PS2_CENTURY_BYTE: - cmos_update_time(); - ret = cmos_data[cmos_index]; - break; - case RTC_REG_A: - ret = cmos_data[cmos_index]; - /* toggle update-in-progress bit for Linux (same hack as - plex86) */ - cmos_data[RTC_REG_A] ^= 0x80; - break; - case RTC_REG_C: - ret = cmos_data[cmos_index]; - pic_set_irq(8, 0); - cmos_data[RTC_REG_C] = 0x00; - break; - default: - ret = cmos_data[cmos_index]; - break; - } -#ifdef DEBUG_CMOS - printf("cmos: read index=0x%02x val=0x%02x\n", - cmos_index, ret); -#endif - return ret; - } -} - -void cmos_init(void) -{ - int val; - - cmos_update_time(); - - cmos_data[RTC_REG_A] = 0x26; - cmos_data[RTC_REG_B] = 0x02; - cmos_data[RTC_REG_C] = 0x00; - cmos_data[RTC_REG_D] = 0x80; - - /* various important CMOS locations needed by PC/Bochs bios */ - - cmos_data[REG_EQUIPMENT_BYTE] = 0x02; /* FPU is there */ - cmos_data[REG_EQUIPMENT_BYTE] |= 0x04; /* PS/2 mouse installed */ - - /* memory size */ - val = (ram_size / 1024) - 1024; - if (val > 65535) - val = 65535; - cmos_data[0x17] = val; - cmos_data[0x18] = val >> 8; - cmos_data[0x30] = val; - cmos_data[0x31] = val >> 8; - - val = (ram_size / 65536) - ((16 * 1024 * 1024) / 65536); - if (val > 65535) - val = 65535; - cmos_data[0x34] = val; - cmos_data[0x35] = val >> 8; - - switch(boot_device) { - case 'a': - case 'b': - cmos_data[0x3d] = 0x01; /* floppy boot */ - break; - default: - case 'c': - cmos_data[0x3d] = 0x02; /* hard drive boot */ - break; - case 'd': - cmos_data[0x3d] = 0x03; /* CD-ROM boot */ - break; - } - - register_ioport_write(0x70, 2, cmos_ioport_write, 1); - register_ioport_read(0x70, 2, cmos_ioport_read, 1); -} - -void cmos_register_fd (uint8_t fd0, uint8_t fd1) -{ - int nb = 0; - - cmos_data[0x10] = 0; - switch (fd0) { - case 0: - /* 1.44 Mb 3"5 drive */ - cmos_data[0x10] |= 0x40; - break; - case 1: - /* 2.88 Mb 3"5 drive */ - cmos_data[0x10] |= 0x60; - break; - case 2: - /* 1.2 Mb 5"5 drive */ - cmos_data[0x10] |= 0x20; - break; - } - switch (fd1) { - case 0: - /* 1.44 Mb 3"5 drive */ - cmos_data[0x10] |= 0x04; - break; - case 1: - /* 2.88 Mb 3"5 drive */ - cmos_data[0x10] |= 0x06; - break; - case 2: - /* 1.2 Mb 5"5 drive */ - cmos_data[0x10] |= 0x02; - break; - } - if (fd0 < 3) - nb++; - if (fd1 < 3) - nb++; - switch (nb) { - case 0: - break; - case 1: - cmos_data[REG_EQUIPMENT_BYTE] |= 0x01; /* 1 drive, ready for boot */ - break; - case 2: - cmos_data[REG_EQUIPMENT_BYTE] |= 0x41; /* 2 drives, ready for boot */ - break; - } -} -#endif /* TARGET_I386 */ - -/***********************************************************/ -/* 8259 pic emulation */ - -typedef struct PicState { - uint8_t last_irr; /* edge detection */ - uint8_t irr; /* interrupt request register */ - uint8_t imr; /* interrupt mask register */ - uint8_t isr; /* interrupt service register */ - uint8_t priority_add; /* highest irq priority */ - uint8_t irq_base; - uint8_t read_reg_select; - uint8_t poll; - uint8_t special_mask; - uint8_t init_state; - uint8_t auto_eoi; - uint8_t rotate_on_auto_eoi; - uint8_t special_fully_nested_mode; - uint8_t init4; /* true if 4 byte init */ -} PicState; - -/* 0 is master pic, 1 is slave pic */ -PicState pics[2]; -int pic_irq_requested; - -/* set irq level. If an edge is detected, then the IRR is set to 1 */ -static inline void pic_set_irq1(PicState *s, int irq, int level) -{ - int mask; - mask = 1 << irq; - if (level) { - if ((s->last_irr & mask) == 0) - s->irr |= mask; - s->last_irr |= mask; - } else { - s->last_irr &= ~mask; - } -} - -/* return the highest priority found in mask (highest = smallest - number). Return 8 if no irq */ -static inline int get_priority(PicState *s, int mask) -{ - int priority; - if (mask == 0) - return 8; - priority = 0; - while ((mask & (1 << ((priority + s->priority_add) & 7))) == 0) - priority++; - return priority; -} - -/* return the pic wanted interrupt. return -1 if none */ -static int pic_get_irq(PicState *s) -{ - int mask, cur_priority, priority; - - mask = s->irr & ~s->imr; - priority = get_priority(s, mask); - if (priority == 8) - return -1; - /* compute current priority. If special fully nested mode on the - master, the IRQ coming from the slave is not taken into account - for the priority computation. */ - mask = s->isr; - if (s->special_fully_nested_mode && s == &pics[0]) - mask &= ~(1 << 2); - cur_priority = get_priority(s, mask); - if (priority < cur_priority) { - /* higher priority found: an irq should be generated */ - return (priority + s->priority_add) & 7; - } else { - return -1; - } -} - -/* raise irq to CPU if necessary. must be called every time the active - irq may change */ -void pic_update_irq(void) -{ - int irq2, irq; - - /* first look at slave pic */ - irq2 = pic_get_irq(&pics[1]); - if (irq2 >= 0) { - /* if irq request by slave pic, signal master PIC */ - pic_set_irq1(&pics[0], 2, 1); - pic_set_irq1(&pics[0], 2, 0); - } - /* look at requested irq */ - irq = pic_get_irq(&pics[0]); - if (irq >= 0) { - if (irq == 2) { - /* from slave pic */ - pic_irq_requested = 8 + irq2; - } else { - /* from master pic */ - pic_irq_requested = irq; - } -#if defined(DEBUG_PIC) - { - int i; - for(i = 0; i < 2; i++) { - printf("pic%d: imr=%x irr=%x padd=%d\n", - i, pics[i].imr, pics[i].irr, pics[i].priority_add); - - } - } - printf("pic: cpu_interrupt req=%d\n", pic_irq_requested); -#endif - cpu_interrupt(global_env, CPU_INTERRUPT_HARD); - } -} - -#ifdef DEBUG_IRQ_LATENCY -int64_t irq_time[16]; -int64_t cpu_get_ticks(void); -#endif -#if defined(DEBUG_PIC) -int irq_level[16]; -#endif +/* keyboard/mouse */ -void pic_set_irq(int irq, int level) -{ -#if defined(DEBUG_PIC) - if (level != irq_level[irq]) { - printf("pic_set_irq: irq=%d level=%d\n", irq, level); - irq_level[irq] = level; - } -#endif -#ifdef DEBUG_IRQ_LATENCY - if (level) { - irq_time[irq] = cpu_get_ticks(); - } -#endif - pic_set_irq1(&pics[irq >> 3], irq & 7, level); - pic_update_irq(); -} +static QEMUPutKBDEvent *qemu_put_kbd_event; +static void *qemu_put_kbd_event_opaque; +static QEMUPutMouseEvent *qemu_put_mouse_event; +static void *qemu_put_mouse_event_opaque; -/* acknowledge interrupt 'irq' */ -static inline void pic_intack(PicState *s, int irq) +void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque) { - if (s->auto_eoi) { - if (s->rotate_on_auto_eoi) - s->priority_add = (irq + 1) & 7; - } else { - s->isr |= (1 << irq); - } - s->irr &= ~(1 << irq); + qemu_put_kbd_event_opaque = opaque; + qemu_put_kbd_event = func; } -int cpu_x86_get_pic_interrupt(CPUState *env) +void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque) { - int irq, irq2, intno; - - /* signal the pic that the irq was acked by the CPU */ - irq = pic_irq_requested; -#ifdef DEBUG_IRQ_LATENCY - printf("IRQ%d latency=%0.3fus\n", - irq, - (double)(cpu_get_ticks() - irq_time[irq]) * 1000000.0 / ticks_per_sec); -#endif -#if defined(DEBUG_PIC) - printf("pic_interrupt: irq=%d\n", irq); -#endif - - if (irq >= 8) { - irq2 = irq & 7; - pic_intack(&pics[1], irq2); - irq = 2; - intno = pics[1].irq_base + irq2; - } else { - intno = pics[0].irq_base + irq; - } - pic_intack(&pics[0], irq); - return intno; -} - -void pic_ioport_write(CPUState *env, uint32_t addr, uint32_t val) -{ - PicState *s; - int priority, cmd, irq; - -#ifdef DEBUG_PIC - printf("pic_write: addr=0x%02x val=0x%02x\n", addr, val); -#endif - s = &pics[addr >> 7]; - addr &= 1; - if (addr == 0) { - if (val & 0x10) { - /* init */ - memset(s, 0, sizeof(PicState)); - s->init_state = 1; - s->init4 = val & 1; - if (val & 0x02) - hw_error("single mode not supported"); - if (val & 0x08) - hw_error("level sensitive irq not supported"); - } else if (val & 0x08) { - if (val & 0x04) - s->poll = 1; - if (val & 0x02) - s->read_reg_select = val & 1; - if (val & 0x40) - s->special_mask = (val >> 5) & 1; - } else { - cmd = val >> 5; - switch(cmd) { - case 0: - case 4: - s->rotate_on_auto_eoi = cmd >> 2; - break; - case 1: /* end of interrupt */ - case 5: - priority = get_priority(s, s->isr); - if (priority != 8) { - irq = (priority + s->priority_add) & 7; - s->isr &= ~(1 << irq); - if (cmd == 5) - s->priority_add = (irq + 1) & 7; - pic_update_irq(); - } - break; - case 3: - irq = val & 7; - s->isr &= ~(1 << irq); - pic_update_irq(); - break; - case 6: - s->priority_add = (val + 1) & 7; - pic_update_irq(); - break; - case 7: - irq = val & 7; - s->isr &= ~(1 << irq); - s->priority_add = (irq + 1) & 7; - pic_update_irq(); - break; - default: - /* no operation */ - break; - } - } - } else { - switch(s->init_state) { - case 0: - /* normal mode */ - s->imr = val; - pic_update_irq(); - break; - case 1: - s->irq_base = val & 0xf8; - s->init_state = 2; - break; - case 2: - if (s->init4) { - s->init_state = 3; - } else { - s->init_state = 0; - } - break; - case 3: - s->special_fully_nested_mode = (val >> 4) & 1; - s->auto_eoi = (val >> 1) & 1; - s->init_state = 0; - break; - } - } + qemu_put_mouse_event_opaque = opaque; + qemu_put_mouse_event = func; } -static uint32_t pic_poll_read (PicState *s, uint32_t addr1) +void kbd_put_keycode(int keycode) { - int ret; - - ret = pic_get_irq(s); - if (ret >= 0) { - if (addr1 >> 7) { - pics[0].isr &= ~(1 << 2); - pics[0].irr &= ~(1 << 2); - } - s->irr &= ~(1 << ret); - s->isr &= ~(1 << ret); - if (addr1 >> 7 || ret != 2) - pic_update_irq(); - } else { - ret = 0x07; - pic_update_irq(); + if (qemu_put_kbd_event) { + qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode); } - - return ret; } -uint32_t pic_ioport_read(CPUState *env, uint32_t addr1) +void kbd_mouse_event(int dx, int dy, int dz, int buttons_state) { - PicState *s; - unsigned int addr; - int ret; - - addr = addr1; - s = &pics[addr >> 7]; - addr &= 1; - if (s->poll) { - ret = pic_poll_read(s, addr1); - s->poll = 0; - } else { - if (addr == 0) { - if (s->read_reg_select) - ret = s->isr; - else - ret = s->irr; - } else { - ret = s->imr; - } + if (qemu_put_mouse_event) { + qemu_put_mouse_event(qemu_put_mouse_event_opaque, + dx, dy, dz, buttons_state); } -#ifdef DEBUG_PIC - printf("pic_read: addr=0x%02x val=0x%02x\n", addr1, ret); -#endif - return ret; -} - -/* memory mapped interrupt status */ -uint32_t pic_intack_read(CPUState *env) -{ - int ret; - - ret = pic_poll_read(&pics[0], 0x00); - if (ret == 2) - ret = pic_poll_read(&pics[1], 0x80) + 8; - /* Prepare for ISR read */ - pics[0].read_reg_select = 1; - - return ret; -} - -void pic_init(void) -{ -#if defined (TARGET_I386) || defined (TARGET_PPC) - register_ioport_write(0x20, 2, pic_ioport_write, 1); - register_ioport_read(0x20, 2, pic_ioport_read, 1); - register_ioport_write(0xa0, 2, pic_ioport_write, 1); - register_ioport_read(0xa0, 2, pic_ioport_read, 1); -#endif } /***********************************************************/ -/* 8253 PIT emulation */ - -#define PIT_FREQ 1193182 - -#define RW_STATE_LSB 0 -#define RW_STATE_MSB 1 -#define RW_STATE_WORD0 2 -#define RW_STATE_WORD1 3 -#define RW_STATE_LATCHED_WORD0 4 -#define RW_STATE_LATCHED_WORD1 5 - -typedef struct PITChannelState { - int count; /* can be 65536 */ - uint16_t latched_count; - uint8_t rw_state; - uint8_t mode; - uint8_t bcd; /* not supported */ - uint8_t gate; /* timer start */ - int64_t count_load_time; - int64_t count_last_edge_check_time; -} PITChannelState; - -PITChannelState pit_channels[3]; -int speaker_data_on; -int dummy_refresh_clock; -int pit_min_timer_count = 0; - +/* timers */ #if defined(__powerpc__) @@ -987,7 +506,38 @@ int64_t cpu_get_real_ticks(void) int64_t cpu_get_real_ticks(void) { int64_t val; - asm("rdtsc" : "=A" (val)); + asm volatile ("rdtsc" : "=A" (val)); + return val; +} + +#elif defined(__x86_64__) + +int64_t cpu_get_real_ticks(void) +{ + uint32_t low,high; + int64_t val; + asm volatile("rdtsc" : "=a" (low), "=d" (high)); + val = high; + val <<= 32; + val |= low; + return val; +} + +#elif defined(__ia64) + +int64_t cpu_get_real_ticks(void) +{ + int64_t val; + asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory"); + return val; +} + +#elif defined(__s390__) + +int64_t cpu_get_real_ticks(void) +{ + int64_t val; + asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc"); return val; } @@ -996,31 +546,47 @@ int64_t cpu_get_real_ticks(void) #endif static int64_t cpu_ticks_offset; -static int64_t cpu_ticks_last; +static int cpu_ticks_enabled; -int64_t cpu_get_ticks(void) +static inline int64_t cpu_get_ticks(void) { - return cpu_get_real_ticks() + cpu_ticks_offset; + if (!cpu_ticks_enabled) { + return cpu_ticks_offset; + } else { + return cpu_get_real_ticks() + cpu_ticks_offset; + } } /* enable cpu_get_ticks() */ void cpu_enable_ticks(void) { - cpu_ticks_offset = cpu_ticks_last - cpu_get_real_ticks(); + if (!cpu_ticks_enabled) { + cpu_ticks_offset -= cpu_get_real_ticks(); + 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) { - cpu_ticks_last = cpu_get_ticks(); + if (cpu_ticks_enabled) { + cpu_ticks_offset = cpu_get_ticks(); + cpu_ticks_enabled = 0; + } } -int64_t get_clock(void) +static int64_t get_clock(void) { +#ifdef _WIN32 + struct _timeb tb; + _ftime(&tb); + return ((int64_t)tb.time * 1000 + (int64_t)tb.millitm) * 1000; +#else struct timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec * 1000000LL + tv.tv_usec; +#endif } void cpu_calibrate_ticks(void) @@ -1028,15 +594,19 @@ void cpu_calibrate_ticks(void) int64_t usec, ticks; usec = get_clock(); - ticks = cpu_get_ticks(); + ticks = cpu_get_real_ticks(); +#ifdef _WIN32 + Sleep(50); +#else usleep(50 * 1000); +#endif usec = get_clock() - usec; - ticks = cpu_get_ticks() - ticks; + ticks = cpu_get_real_ticks() - ticks; ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec; } /* compute with 96 bit intermediate result: (a*b)/c */ -static uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c) +uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c) { union { uint64_t ll; @@ -1059,625 +629,569 @@ static uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c) return res.ll; } -static int pit_get_count(PITChannelState *s) +#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; +#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) { - uint64_t d; - int counter; + QEMUTimer *ts; - d = muldiv64(cpu_get_ticks() - s->count_load_time, PIT_FREQ, ticks_per_sec); - switch(s->mode) { - case 0: - case 1: - case 4: - case 5: - counter = (s->count - d) & 0xffff; - break; - case 3: - /* XXX: may be incorrect for odd counts */ - counter = s->count - ((2 * d) % s->count); - break; - default: - counter = s->count - (d % s->count); - break; - } - return counter; + ts = qemu_mallocz(sizeof(QEMUTimer)); + ts->clock = clock; + ts->cb = cb; + ts->opaque = opaque; + return ts; } -/* get pit output bit */ -static int pit_get_out(PITChannelState *s) +void qemu_free_timer(QEMUTimer *ts) { - uint64_t d; - int out; + qemu_free(ts); +} - d = muldiv64(cpu_get_ticks() - s->count_load_time, PIT_FREQ, ticks_per_sec); - switch(s->mode) { - default: - case 0: - out = (d >= s->count); - break; - case 1: - out = (d < s->count); - break; - case 2: - if ((d % s->count) == 0 && d != 0) - out = 1; - else - out = 0; - break; - case 3: - out = (d % s->count) < ((s->count + 1) >> 1); - break; - case 4: - case 5: - out = (d == s->count); - break; +/* 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; } - return out; } -/* get the number of 0 to 1 transitions we had since we call this - function */ -/* XXX: maybe better to use ticks precision to avoid getting edges - twice if checks are done at very small intervals */ -static int pit_get_out_edges(PITChannelState *s) +/* 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) { - uint64_t d1, d2; - int64_t ticks; - int ret, v; + QEMUTimer **pt, *t; - ticks = cpu_get_ticks(); - d1 = muldiv64(s->count_last_edge_check_time - s->count_load_time, - PIT_FREQ, ticks_per_sec); - d2 = muldiv64(ticks - s->count_load_time, - PIT_FREQ, ticks_per_sec); - s->count_last_edge_check_time = ticks; - switch(s->mode) { - default: - case 0: - if (d1 < s->count && d2 >= s->count) - ret = 1; - else - ret = 0; - break; - case 1: - ret = 0; - break; - case 2: - d1 /= s->count; - d2 /= s->count; - ret = d2 - d1; - break; - case 3: - v = s->count - ((s->count + 1) >> 1); - d1 = (d1 + v) / s->count; - d2 = (d2 + v) / s->count; - ret = d2 - d1; - break; - case 4: - case 5: - if (d1 < s->count && d2 >= s->count) - ret = 1; - else - ret = 0; - break; + 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; } - return ret; + ts->expire_time = expire_time; + ts->next = *pt; + *pt = ts; } -/* val must be 0 or 1 */ -static inline void pit_set_gate(PITChannelState *s, int val) +int qemu_timer_pending(QEMUTimer *ts) { - switch(s->mode) { - default: - case 0: - case 4: - /* XXX: just disable/enable counting */ - break; - case 1: - case 5: - if (s->gate < val) { - /* restart counting on rising edge */ - s->count_load_time = cpu_get_ticks(); - s->count_last_edge_check_time = s->count_load_time; - } - break; - case 2: - case 3: - if (s->gate < val) { - /* restart counting on rising edge */ - s->count_load_time = cpu_get_ticks(); - s->count_last_edge_check_time = s->count_load_time; - } - /* XXX: disable/enable counting */ - break; + QEMUTimer *t; + for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) { + if (t == ts) + return 1; } - s->gate = val; + 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 inline void pit_load_count(PITChannelState *s, int val) +static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time) { - if (val == 0) - val = 0x10000; - s->count_load_time = cpu_get_ticks(); - s->count_last_edge_check_time = s->count_load_time; - s->count = val; - if (s == &pit_channels[0] && val <= pit_min_timer_count) { - fprintf(stderr, - "\nWARNING: qemu: on your system, accurate timer emulation is impossible if its frequency is more than %d Hz. If using a 2.6 guest Linux kernel, you must patch asm/param.h to change HZ from 1000 to 100.\n\n", - PIT_FREQ / pit_min_timer_count); + 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); } } -void pit_ioport_write(CPUState *env, uint32_t addr, uint32_t val) +int64_t qemu_get_clock(QEMUClock *clock) { - int channel, access; - PITChannelState *s; + switch(clock->type) { + case QEMU_TIMER_REALTIME: +#ifdef _WIN32 + return GetTickCount(); +#else + { + struct tms tp; - addr &= 3; - if (addr == 3) { - channel = val >> 6; - if (channel == 3) - return; - s = &pit_channels[channel]; - access = (val >> 4) & 3; - switch(access) { - case 0: - s->latched_count = pit_get_count(s); - s->rw_state = RW_STATE_LATCHED_WORD0; - break; - default: - s->mode = (val >> 1) & 7; - s->bcd = val & 1; - s->rw_state = access - 1 + RW_STATE_LSB; - break; - } - } else { - s = &pit_channels[addr]; - switch(s->rw_state) { - case RW_STATE_LSB: - pit_load_count(s, val); - break; - case RW_STATE_MSB: - pit_load_count(s, val << 8); - break; - case RW_STATE_WORD0: - case RW_STATE_WORD1: - if (s->rw_state & 1) { - pit_load_count(s, (s->latched_count & 0xff) | (val << 8)); + /* Note that using gettimeofday() is not a good solution + for timers because its value change when the date is + modified. */ + if (timer_freq == 100) { + return times(&tp) * 10; } else { - s->latched_count = val; + return ((int64_t)times(&tp) * 1000) / timer_freq; } - s->rw_state ^= 1; - break; } +#endif + default: + case QEMU_TIMER_VIRTUAL: + return cpu_get_ticks(); } } -uint32_t pit_ioport_read(CPUState *env, uint32_t addr) +/* save a timer */ +void qemu_put_timer(QEMUFile *f, QEMUTimer *ts) { - int ret, count; - PITChannelState *s; - - addr &= 3; - s = &pit_channels[addr]; - switch(s->rw_state) { - case RW_STATE_LSB: - case RW_STATE_MSB: - case RW_STATE_WORD0: - case RW_STATE_WORD1: - count = pit_get_count(s); - if (s->rw_state & 1) - ret = (count >> 8) & 0xff; - else - ret = count & 0xff; - if (s->rw_state & 2) - s->rw_state ^= 1; - break; - default: - case RW_STATE_LATCHED_WORD0: - case RW_STATE_LATCHED_WORD1: - if (s->rw_state & 1) - ret = s->latched_count >> 8; - else - ret = s->latched_count & 0xff; - s->rw_state ^= 1; - break; + uint64_t expire_time; + + if (qemu_timer_pending(ts)) { + expire_time = ts->expire_time; + } else { + expire_time = -1; } - return ret; + qemu_put_be64(f, expire_time); } -#if defined (TARGET_I386) -void speaker_ioport_write(CPUState *env, uint32_t addr, uint32_t val) +void qemu_get_timer(QEMUFile *f, QEMUTimer *ts) { - speaker_data_on = (val >> 1) & 1; - pit_set_gate(&pit_channels[2], val & 1); + uint64_t expire_time; + + expire_time = qemu_get_be64(f); + if (expire_time != -1) { + qemu_mod_timer(ts, expire_time); + } else { + qemu_del_timer(ts); + } } -uint32_t speaker_ioport_read(CPUState *env, uint32_t addr) +static void timer_save(QEMUFile *f, void *opaque) { - int out; - out = pit_get_out(&pit_channels[2]); - dummy_refresh_clock ^= 1; - return (speaker_data_on << 1) | pit_channels[2].gate | (out << 5) | - (dummy_refresh_clock << 4); + if (cpu_ticks_enabled) { + hw_error("cannot save state if virtual timers are running"); + } + qemu_put_be64s(f, &cpu_ticks_offset); + qemu_put_be64s(f, &ticks_per_sec); } -#endif -void pit_init(void) +static int timer_load(QEMUFile *f, void *opaque, int version_id) { - PITChannelState *s; - int i; - - cpu_calibrate_ticks(); - - for(i = 0;i < 3; i++) { - s = &pit_channels[i]; - s->mode = 3; - s->gate = (i != 2); - pit_load_count(s, 0); + if (version_id != 1) + return -EINVAL; + if (cpu_ticks_enabled) { + return -EINVAL; } + qemu_get_be64s(f, &cpu_ticks_offset); + qemu_get_be64s(f, &ticks_per_sec); + return 0; +} - register_ioport_write(0x40, 4, pit_ioport_write, 1); - register_ioport_read(0x40, 3, pit_ioport_read, 1); - -#if defined (TARGET_I386) - register_ioport_read(0x61, 1, speaker_ioport_read, 1); - register_ioport_write(0x61, 1, speaker_ioport_write, 1); +#ifdef _WIN32 +void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg, + DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) +#else +static void host_alarm_handler(int host_signum) +#endif +{ +#if 0 +#define DISP_FREQ 1000 + { + static int64_t delta_min = INT64_MAX; + static int64_t delta_max, delta_cum, last_clock, delta, ti; + static int count; + ti = qemu_get_clock(vm_clock); + if (last_clock != 0) { + delta = ti - last_clock; + if (delta < delta_min) + delta_min = delta; + if (delta > delta_max) + delta_max = delta; + delta_cum += delta; + if (++count == DISP_FREQ) { + printf("timer: min=%lld us max=%lld us avg=%lld us avg_freq=%0.3f Hz\n", + muldiv64(delta_min, 1000000, ticks_per_sec), + muldiv64(delta_max, 1000000, ticks_per_sec), + muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec), + (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ)); + count = 0; + delta_min = INT64_MAX; + delta_max = 0; + delta_cum = 0; + } + } + last_clock = ti; + } #endif + if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL], + qemu_get_clock(vm_clock)) || + qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME], + qemu_get_clock(rt_clock))) { + /* stop the cpu because a timer occured */ + cpu_interrupt(global_env, CPU_INTERRUPT_EXIT); + } } -/***********************************************************/ -/* serial port emulation */ - -#define UART_IRQ 4 +#ifndef _WIN32 -#define UART_LCR_DLAB 0x80 /* Divisor latch access bit */ +#if defined(__linux__) -#define UART_IER_MSI 0x08 /* Enable Modem status interrupt */ -#define UART_IER_RLSI 0x04 /* Enable receiver line status interrupt */ -#define UART_IER_THRI 0x02 /* Enable Transmitter holding register int. */ -#define UART_IER_RDI 0x01 /* Enable receiver data interrupt */ +#define RTC_FREQ 1024 -#define UART_IIR_NO_INT 0x01 /* No interrupts pending */ -#define UART_IIR_ID 0x06 /* Mask for the interrupt ID */ - -#define UART_IIR_MSI 0x00 /* Modem status interrupt */ -#define UART_IIR_THRI 0x02 /* Transmitter holding register empty */ -#define UART_IIR_RDI 0x04 /* Receiver data interrupt */ -#define UART_IIR_RLSI 0x06 /* Receiver line status interrupt */ - -/* - * These are the definitions for the Modem Control Register - */ -#define UART_MCR_LOOP 0x10 /* Enable loopback test mode */ -#define UART_MCR_OUT2 0x08 /* Out2 complement */ -#define UART_MCR_OUT1 0x04 /* Out1 complement */ -#define UART_MCR_RTS 0x02 /* RTS complement */ -#define UART_MCR_DTR 0x01 /* DTR complement */ +static int rtc_fd; -/* - * These are the definitions for the Modem Status Register - */ -#define UART_MSR_DCD 0x80 /* Data Carrier Detect */ -#define UART_MSR_RI 0x40 /* Ring Indicator */ -#define UART_MSR_DSR 0x20 /* Data Set Ready */ -#define UART_MSR_CTS 0x10 /* Clear to Send */ -#define UART_MSR_DDCD 0x08 /* Delta DCD */ -#define UART_MSR_TERI 0x04 /* Trailing edge ring indicator */ -#define UART_MSR_DDSR 0x02 /* Delta DSR */ -#define UART_MSR_DCTS 0x01 /* Delta CTS */ -#define UART_MSR_ANY_DELTA 0x0F /* Any of the delta bits! */ - -#define UART_LSR_TEMT 0x40 /* Transmitter empty */ -#define UART_LSR_THRE 0x20 /* Transmit-hold-register empty */ -#define UART_LSR_BI 0x10 /* Break interrupt indicator */ -#define UART_LSR_FE 0x08 /* Frame error indicator */ -#define UART_LSR_PE 0x04 /* Parity error indicator */ -#define UART_LSR_OE 0x02 /* Overrun error indicator */ -#define UART_LSR_DR 0x01 /* Receiver data ready */ - -typedef struct SerialState { - uint8_t divider; - uint8_t rbr; /* receive register */ - uint8_t ier; - uint8_t iir; /* read only */ - uint8_t lcr; - uint8_t mcr; - uint8_t lsr; /* read only */ - uint8_t msr; - uint8_t scr; - /* NOTE: this hidden state is necessary for tx irq generation as - it can be reset while reading iir */ - int thr_ipending; -} SerialState; - -SerialState serial_ports[1]; - -void serial_update_irq(void) -{ - SerialState *s = &serial_ports[0]; - - if ((s->lsr & UART_LSR_DR) && (s->ier & UART_IER_RDI)) { - s->iir = UART_IIR_RDI; - } else if (s->thr_ipending && (s->ier & UART_IER_THRI)) { - s->iir = UART_IIR_THRI; - } else { - s->iir = UART_IIR_NO_INT; +static int start_rtc_timer(void) +{ + rtc_fd = open("/dev/rtc", O_RDONLY); + if (rtc_fd < 0) + return -1; + if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) { + fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n" + "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n" + "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n"); + goto fail; } - if (s->iir != UART_IIR_NO_INT) { - pic_set_irq(UART_IRQ, 1); - } else { - pic_set_irq(UART_IRQ, 0); + if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) { + fail: + close(rtc_fd); + return -1; } + pit_min_timer_count = PIT_FREQ / RTC_FREQ; + return 0; } -void serial_ioport_write(CPUState *env, uint32_t addr, uint32_t val) +#else + +static int start_rtc_timer(void) { - SerialState *s = &serial_ports[0]; - unsigned char ch; - int ret; - - addr &= 7; -#ifdef DEBUG_SERIAL - printf("serial: write addr=0x%02x val=0x%02x\n", addr, val); -#endif - switch(addr) { - default: - case 0: - if (s->lcr & UART_LCR_DLAB) { - s->divider = (s->divider & 0xff00) | val; - } else { - s->thr_ipending = 0; - s->lsr &= ~UART_LSR_THRE; - serial_update_irq(); - - ch = val; - do { - ret = write(1, &ch, 1); - } while (ret != 1); - s->thr_ipending = 1; - s->lsr |= UART_LSR_THRE; - s->lsr |= UART_LSR_TEMT; - serial_update_irq(); - } - break; - case 1: - if (s->lcr & UART_LCR_DLAB) { - s->divider = (s->divider & 0x00ff) | (val << 8); - } else { - s->ier = val; - serial_update_irq(); - } - break; - case 2: - break; - case 3: - s->lcr = val; - break; - case 4: - s->mcr = val; - break; - case 5: - break; - case 6: - s->msr = val; - break; - case 7: - s->scr = val; - break; - } + return -1; } -uint32_t serial_ioport_read(CPUState *env, uint32_t addr) +#endif /* !defined(__linux__) */ + +#endif /* !defined(_WIN32) */ + +static void init_timers(void) { - SerialState *s = &serial_ports[0]; - uint32_t ret; + rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME); + vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL); - addr &= 7; - switch(addr) { - default: - case 0: - if (s->lcr & UART_LCR_DLAB) { - ret = s->divider & 0xff; - } else { - ret = s->rbr; - s->lsr &= ~(UART_LSR_DR | UART_LSR_BI); - serial_update_irq(); - } - break; - case 1: - if (s->lcr & UART_LCR_DLAB) { - ret = (s->divider >> 8) & 0xff; - } else { - ret = s->ier; - } - break; - case 2: - ret = s->iir; - /* reset THR pending bit */ - if ((ret & 0x7) == UART_IIR_THRI) - s->thr_ipending = 0; - serial_update_irq(); - break; - case 3: - ret = s->lcr; - break; - case 4: - ret = s->mcr; - break; - case 5: - ret = s->lsr; - break; - case 6: - if (s->mcr & UART_MCR_LOOP) { - /* in loopback, the modem output pins are connected to the - inputs */ - ret = (s->mcr & 0x0c) << 4; - ret |= (s->mcr & 0x02) << 3; - ret |= (s->mcr & 0x01) << 5; - } else { - ret = s->msr; +#ifdef _WIN32 + { + int count=0; + timerID = timeSetEvent(10, // interval (ms) + 0, // resolution + host_alarm_handler, // function + (DWORD)&count, // user parameter + TIME_PERIODIC | TIME_CALLBACK_FUNCTION); + if( !timerID ) { + perror("failed timer alarm"); + exit(1); + } + } + pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000; +#else + { + struct sigaction act; + struct itimerval itv; + + /* get times() syscall frequency */ + timer_freq = sysconf(_SC_CLK_TCK); + + /* timer signal */ + sigfillset(&act.sa_mask); + act.sa_flags = 0; +#if defined (TARGET_I386) && defined(USE_CODE_COPY) + act.sa_flags |= SA_ONSTACK; +#endif + act.sa_handler = host_alarm_handler; + sigaction(SIGALRM, &act, NULL); + + itv.it_interval.tv_sec = 0; + itv.it_interval.tv_usec = 999; /* for i386 kernel 2.6 to get 1 ms */ + itv.it_value.tv_sec = 0; + itv.it_value.tv_usec = 10 * 1000; + setitimer(ITIMER_REAL, &itv, NULL); + /* we probe the tick duration of the kernel to inform the user if + the emulated kernel requested a too high timer frequency */ + getitimer(ITIMER_REAL, &itv); + +#if defined(__linux__) + if (itv.it_interval.tv_usec > 1000) { + /* try to use /dev/rtc to have a faster timer */ + if (start_rtc_timer() < 0) + goto use_itimer; + /* disable itimer */ + itv.it_interval.tv_sec = 0; + itv.it_interval.tv_usec = 0; + itv.it_value.tv_sec = 0; + itv.it_value.tv_usec = 0; + setitimer(ITIMER_REAL, &itv, NULL); + + /* use the RTC */ + sigaction(SIGIO, &act, NULL); + fcntl(rtc_fd, F_SETFL, O_ASYNC); + fcntl(rtc_fd, F_SETOWN, getpid()); + } else +#endif /* defined(__linux__) */ + { + use_itimer: + pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec * + PIT_FREQ) / 1000000; } - break; - case 7: - ret = s->scr; - break; } -#ifdef DEBUG_SERIAL - printf("serial: read addr=0x%02x val=0x%02x\n", addr, ret); #endif - return ret; } -#define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */ -static int term_got_escape, term_command; -static unsigned char term_cmd_buf[128]; - -typedef struct term_cmd_t { - const unsigned char *name; - void (*handler)(unsigned char *params); -} term_cmd_t; - -static void do_change_cdrom (unsigned char *params); -static void do_change_fd0 (unsigned char *params); -static void do_change_fd1 (unsigned char *params); - -static term_cmd_t term_cmds[] = { - { "changecd", &do_change_cdrom, }, - { "changefd0", &do_change_fd0, }, - { "changefd1", &do_change_fd1, }, - { NULL, NULL, }, -}; +void quit_timers(void) +{ +#ifdef _WIN32 + timeKillEvent(timerID); +#endif +} -void term_print_help(void) +/***********************************************************/ +/* character device */ + +int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len) { - printf("\n" - "C-a h print this help\n" - "C-a x exit emulatior\n" - "C-a d switch on/off debug log\n" - "C-a s save disk data back to file (if -snapshot)\n" - "C-a b send break (magic sysrq)\n" - "C-a c send qemu internal command\n" - "C-a C-a send C-a\n" - ); + return s->chr_write(s, buf, len); } -static void do_change_cdrom (unsigned char *params) +void qemu_chr_printf(CharDriverState *s, const char *fmt, ...) { - /* Dunno how to do it... */ + char buf[4096]; + va_list ap; + va_start(ap, fmt); + vsnprintf(buf, sizeof(buf), fmt, ap); + qemu_chr_write(s, buf, strlen(buf)); + va_end(ap); } -static void do_change_fd (int fd, unsigned char *params) +void qemu_chr_send_event(CharDriverState *s, int event) { - unsigned char *name_start, *name_end, *ros; - int ro; + if (s->chr_send_event) + s->chr_send_event(s, event); +} - for (name_start = params; - isspace(*name_start); name_start++) - continue; - if (*name_start == '\0') - return; - for (name_end = name_start; - !isspace(*name_end) && *name_end != '\0'; name_end++) - continue; - for (ros = name_end + 1; isspace(*ros); ros++) - continue; - if (ros[0] == 'r' && ros[1] == 'o') - ro = 1; - else - ro = 0; - *name_end = '\0'; - printf("Change fd %d to %s (%s)\n", fd, name_start, params); - fdctrl_disk_change(fd, name_start, ro); +void qemu_chr_add_read_handler(CharDriverState *s, + IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) +{ + s->chr_add_read_handler(s, fd_can_read, fd_read, opaque); +} + +void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event) +{ + s->chr_event = chr_event; } -static void do_change_fd0 (unsigned char *params) +static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { - do_change_fd(0, params); + return len; } -static void do_change_fd1 (unsigned char *params) +static void null_chr_add_read_handler(CharDriverState *chr, + IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) { - do_change_fd(1, params); } -static void serial_treat_command () +CharDriverState *qemu_chr_open_null(void) { - unsigned char *cmd_start, *cmd_end; - int i; + CharDriverState *chr; - for (cmd_start = term_cmd_buf; isspace(*cmd_start); cmd_start++) - continue; - for (cmd_end = cmd_start; - !isspace(*cmd_end) && *cmd_end != '\0'; cmd_end++) - continue; - for (i = 0; term_cmds[i].name != NULL; i++) { - if (strlen(term_cmds[i].name) == (cmd_end - cmd_start) && - memcmp(term_cmds[i].name, cmd_start, cmd_end - cmd_start) == 0) { - (*term_cmds[i].handler)(cmd_end + 1); - return; - } - } - *cmd_end = '\0'; - printf("Unknown term command: %s\n", cmd_start); + chr = qemu_mallocz(sizeof(CharDriverState)); + if (!chr) + return NULL; + chr->chr_write = null_chr_write; + chr->chr_add_read_handler = null_chr_add_read_handler; + return chr; } -extern FILE *logfile; +#ifndef _WIN32 -/* called when a char is received */ -void serial_received_byte(SerialState *s, int ch) +typedef struct { + int fd_in, fd_out; + /* for nographic stdio only */ + IOCanRWHandler *fd_can_read; + IOReadHandler *fd_read; + void *fd_opaque; +} FDCharDriver; + +#define STDIO_MAX_CLIENTS 2 + +static int stdio_nb_clients; +static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS]; + +static int unix_write(int fd, const uint8_t *buf, int len1) { - if (term_command) { - if (ch == '\n' || ch == '\r' || term_command == 127) { - printf("\n"); - serial_treat_command(); - term_command = 0; + int ret, len; + + len = len1; + while (len > 0) { + ret = write(fd, buf, len); + if (ret < 0) { + if (errno != EINTR && errno != EAGAIN) + return -1; + } else if (ret == 0) { + break; } else { - if (ch == 0x7F || ch == 0x08) { - if (term_command > 1) { - term_cmd_buf[--term_command - 1] = '\0'; - printf("\r " - " "); - printf("\r> %s", term_cmd_buf); - } - } else if (ch > 0x1f) { - term_cmd_buf[term_command++ - 1] = ch; - term_cmd_buf[term_command - 1] = '\0'; - printf("\r> %s", term_cmd_buf); - } - fflush(stdout); + buf += ret; + len -= ret; } - } else if (term_got_escape) { - term_got_escape = 0; - switch(ch) { - case 'h': - term_print_help(); - break; - case 'x': - exit(0); - break; - case 's': - { - int i; - for (i = 0; i < MAX_DISKS; i++) { - if (bs_table[i]) - bdrv_commit(bs_table[i]); - } - } - break; - case 'b': - /* send break */ - s->rbr = 0; - s->lsr |= UART_LSR_BI | UART_LSR_DR; - serial_update_irq(); - break; - case 'c': - printf("> "); - fflush(stdout); - term_command = 1; + } + return len1 - len; +} + +static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len) +{ + FDCharDriver *s = chr->opaque; + return unix_write(s->fd_out, buf, len); +} + +static void fd_chr_add_read_handler(CharDriverState *chr, + IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) +{ + FDCharDriver *s = chr->opaque; + + if (nographic && s->fd_in == 0) { + s->fd_can_read = fd_can_read; + s->fd_read = fd_read; + s->fd_opaque = opaque; + } else { + qemu_add_fd_read_handler(s->fd_in, fd_can_read, fd_read, opaque); + } +} + +/* open a character device to a unix fd */ +CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out) +{ + CharDriverState *chr; + FDCharDriver *s; + + chr = qemu_mallocz(sizeof(CharDriverState)); + if (!chr) + return NULL; + s = qemu_mallocz(sizeof(FDCharDriver)); + if (!s) { + free(chr); + return NULL; + } + s->fd_in = fd_in; + s->fd_out = fd_out; + chr->opaque = s; + chr->chr_write = fd_chr_write; + chr->chr_add_read_handler = fd_chr_add_read_handler; + return chr; +} + +/* for STDIO, we handle the case where several clients use it + (nographic mode) */ + +#define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */ + +static int term_got_escape, client_index; + +void term_print_help(void) +{ + printf("\n" + "C-a h print this help\n" + "C-a x exit emulator\n" + "C-a s save disk data back to file (if -snapshot)\n" + "C-a b send break (magic sysrq)\n" + "C-a c switch between console and monitor\n" + "C-a C-a send C-a\n" + ); +} + +/* called when a char is received */ +static void stdio_received_byte(int ch) +{ + if (term_got_escape) { + term_got_escape = 0; + switch(ch) { + case 'h': + term_print_help(); + break; + case 'x': + exit(0); + break; + case 's': + { + int i; + for (i = 0; i < MAX_DISKS; i++) { + if (bs_table[i]) + bdrv_commit(bs_table[i]); + } + } + break; + case 'b': + if (client_index < stdio_nb_clients) { + CharDriverState *chr; + FDCharDriver *s; + + chr = stdio_clients[client_index]; + s = chr->opaque; + chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK); + } break; - case 'd': - cpu_set_log(CPU_LOG_ALL); + case 'c': + client_index++; + if (client_index >= stdio_nb_clients) + client_index = 0; + if (client_index == 0) { + /* send a new line in the monitor to get the prompt */ + ch = '\r'; + goto send_char; + } break; case TERM_ESCAPE: goto send_char; @@ -1686,170 +1200,434 @@ void serial_received_byte(SerialState *s, int ch) term_got_escape = 1; } else { send_char: - s->rbr = ch; - s->lsr |= UART_LSR_DR; - serial_update_irq(); + if (client_index < stdio_nb_clients) { + uint8_t buf[1]; + CharDriverState *chr; + FDCharDriver *s; + + chr = stdio_clients[client_index]; + s = chr->opaque; + buf[0] = ch; + /* XXX: should queue the char if the device is not + ready */ + if (s->fd_can_read(s->fd_opaque) > 0) + s->fd_read(s->fd_opaque, buf, 1); + } } } -void serial_init(void) +static int stdio_can_read(void *opaque) +{ + /* XXX: not strictly correct */ + return 1; +} + +static void stdio_read(void *opaque, const uint8_t *buf, int size) { - SerialState *s = &serial_ports[0]; + int i; + for(i = 0; i < size; i++) + stdio_received_byte(buf[i]); +} + +/* init terminal so that we can grab keys */ +static struct termios oldtty; +static int old_fd0_flags; + +static void term_exit(void) +{ + tcsetattr (0, TCSANOW, &oldtty); + fcntl(0, F_SETFL, old_fd0_flags); +} + +static void term_init(void) +{ + struct termios tty; - s->lsr = UART_LSR_TEMT | UART_LSR_THRE; - s->iir = UART_IIR_NO_INT; + tcgetattr (0, &tty); + oldtty = tty; + old_fd0_flags = fcntl(0, F_GETFL); + + tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP + |INLCR|IGNCR|ICRNL|IXON); + tty.c_oflag |= OPOST; + tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); + /* if graphical mode, we allow Ctrl-C handling */ + if (nographic) + tty.c_lflag &= ~ISIG; + tty.c_cflag &= ~(CSIZE|PARENB); + tty.c_cflag |= CS8; + tty.c_cc[VMIN] = 1; + tty.c_cc[VTIME] = 0; -#if defined(TARGET_I386) || defined (TARGET_PPC) - register_ioport_write(0x3f8, 8, serial_ioport_write, 1); - register_ioport_read(0x3f8, 8, serial_ioport_read, 1); + tcsetattr (0, TCSANOW, &tty); + + atexit(term_exit); + + fcntl(0, F_SETFL, O_NONBLOCK); +} + +CharDriverState *qemu_chr_open_stdio(void) +{ + CharDriverState *chr; + + if (nographic) { + if (stdio_nb_clients >= STDIO_MAX_CLIENTS) + return NULL; + chr = qemu_chr_open_fd(0, 1); + if (stdio_nb_clients == 0) + qemu_add_fd_read_handler(0, stdio_can_read, stdio_read, NULL); + client_index = stdio_nb_clients; + } else { + if (stdio_nb_clients != 0) + return NULL; + chr = qemu_chr_open_fd(0, 1); + } + stdio_clients[stdio_nb_clients++] = chr; + if (stdio_nb_clients == 1) { + /* set the terminal in raw mode */ + term_init(); + } + return chr; +} + +#if defined(__linux__) +CharDriverState *qemu_chr_open_pty(void) +{ + char slave_name[1024]; + int master_fd, slave_fd; + + /* Not satisfying */ + if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) { + return NULL; + } + fprintf(stderr, "char device redirected to %s\n", slave_name); + return qemu_chr_open_fd(master_fd, master_fd); +} +#else +CharDriverState *qemu_chr_open_pty(void) +{ + return NULL; +} #endif + +#endif /* !defined(_WIN32) */ + +CharDriverState *qemu_chr_open(const char *filename) +{ + if (!strcmp(filename, "vc")) { + return text_console_init(&display_state); + } else if (!strcmp(filename, "null")) { + return qemu_chr_open_null(); + } else +#ifndef _WIN32 + if (!strcmp(filename, "pty")) { + return qemu_chr_open_pty(); + } else if (!strcmp(filename, "stdio")) { + return qemu_chr_open_stdio(); + } else +#endif + { + return NULL; + } } /***********************************************************/ -/* ne2000 emulation */ - -#if defined (TARGET_I386) -#define NE2000_IOPORT 0x300 -#define NE2000_IRQ 9 - -#define MAX_ETH_FRAME_SIZE 1514 - -#define E8390_CMD 0x00 /* The command register (for all pages) */ -/* Page 0 register offsets. */ -#define EN0_CLDALO 0x01 /* Low byte of current local dma addr RD */ -#define EN0_STARTPG 0x01 /* Starting page of ring bfr WR */ -#define EN0_CLDAHI 0x02 /* High byte of current local dma addr RD */ -#define EN0_STOPPG 0x02 /* Ending page +1 of ring bfr WR */ -#define EN0_BOUNDARY 0x03 /* Boundary page of ring bfr RD WR */ -#define EN0_TSR 0x04 /* Transmit status reg RD */ -#define EN0_TPSR 0x04 /* Transmit starting page WR */ -#define EN0_NCR 0x05 /* Number of collision reg RD */ -#define EN0_TCNTLO 0x05 /* Low byte of tx byte count WR */ -#define EN0_FIFO 0x06 /* FIFO RD */ -#define EN0_TCNTHI 0x06 /* High byte of tx byte count WR */ -#define EN0_ISR 0x07 /* Interrupt status reg RD WR */ -#define EN0_CRDALO 0x08 /* low byte of current remote dma address RD */ -#define EN0_RSARLO 0x08 /* Remote start address reg 0 */ -#define EN0_CRDAHI 0x09 /* high byte, current remote dma address RD */ -#define EN0_RSARHI 0x09 /* Remote start address reg 1 */ -#define EN0_RCNTLO 0x0a /* Remote byte count reg WR */ -#define EN0_RCNTHI 0x0b /* Remote byte count reg WR */ -#define EN0_RSR 0x0c /* rx status reg RD */ -#define EN0_RXCR 0x0c /* RX configuration reg WR */ -#define EN0_TXCR 0x0d /* TX configuration reg WR */ -#define EN0_COUNTER0 0x0d /* Rcv alignment error counter RD */ -#define EN0_DCFG 0x0e /* Data configuration reg WR */ -#define EN0_COUNTER1 0x0e /* Rcv CRC error counter RD */ -#define EN0_IMR 0x0f /* Interrupt mask reg WR */ -#define EN0_COUNTER2 0x0f /* Rcv missed frame error counter RD */ - -#define EN1_PHYS 0x11 -#define EN1_CURPAG 0x17 -#define EN1_MULT 0x18 - -/* Register accessed at EN_CMD, the 8390 base addr. */ -#define E8390_STOP 0x01 /* Stop and reset the chip */ -#define E8390_START 0x02 /* Start the chip, clear reset */ -#define E8390_TRANS 0x04 /* Transmit a frame */ -#define E8390_RREAD 0x08 /* Remote read */ -#define E8390_RWRITE 0x10 /* Remote write */ -#define E8390_NODMA 0x20 /* Remote DMA */ -#define E8390_PAGE0 0x00 /* Select page chip registers */ -#define E8390_PAGE1 0x40 /* using the two high-order bits */ -#define E8390_PAGE2 0x80 /* Page 3 is invalid. */ - -/* Bits in EN0_ISR - Interrupt status register */ -#define ENISR_RX 0x01 /* Receiver, no error */ -#define ENISR_TX 0x02 /* Transmitter, no error */ -#define ENISR_RX_ERR 0x04 /* Receiver, with error */ -#define ENISR_TX_ERR 0x08 /* Transmitter, with error */ -#define ENISR_OVER 0x10 /* Receiver overwrote the ring */ -#define ENISR_COUNTERS 0x20 /* Counters need emptying */ -#define ENISR_RDC 0x40 /* remote dma complete */ -#define ENISR_RESET 0x80 /* Reset completed */ -#define ENISR_ALL 0x3f /* Interrupts we will enable */ - -/* Bits in received packet status byte and EN0_RSR*/ -#define ENRSR_RXOK 0x01 /* Received a good packet */ -#define ENRSR_CRC 0x02 /* CRC error */ -#define ENRSR_FAE 0x04 /* frame alignment error */ -#define ENRSR_FO 0x08 /* FIFO overrun */ -#define ENRSR_MPA 0x10 /* missed pkt */ -#define ENRSR_PHY 0x20 /* physical/multicast address */ -#define ENRSR_DIS 0x40 /* receiver disable. set in monitor mode */ -#define ENRSR_DEF 0x80 /* deferring */ - -/* Transmitted packet status, EN0_TSR. */ -#define ENTSR_PTX 0x01 /* Packet transmitted without error */ -#define ENTSR_ND 0x02 /* The transmit wasn't deferred. */ -#define ENTSR_COL 0x04 /* The transmit collided at least once. */ -#define ENTSR_ABT 0x08 /* The transmit collided 16 times, and was deferred. */ -#define ENTSR_CRS 0x10 /* The carrier sense was lost. */ -#define ENTSR_FU 0x20 /* A "FIFO underrun" occurred during transmit. */ -#define ENTSR_CDH 0x40 /* The collision detect "heartbeat" signal was lost. */ -#define ENTSR_OWC 0x80 /* There was an out-of-window collision. */ - -#define NE2000_MEM_SIZE 32768 - -typedef struct NE2000State { - uint8_t cmd; - uint32_t start; - uint32_t stop; - uint8_t boundary; - uint8_t tsr; - uint8_t tpsr; - uint16_t tcnt; - uint16_t rcnt; - uint32_t rsar; - uint8_t isr; - uint8_t dcfg; - uint8_t imr; - uint8_t phys[6]; /* mac address */ - uint8_t curpag; - uint8_t mult[8]; /* multicast mask array */ - uint8_t mem[NE2000_MEM_SIZE]; -} NE2000State; - -NE2000State ne2000_state; -int net_fd = -1; -char network_script[1024]; - -void ne2000_reset(void) -{ - NE2000State *s = &ne2000_state; - int i; +/* Linux network device redirectors */ - s->isr = ENISR_RESET; - s->mem[0] = 0x52; - s->mem[1] = 0x54; - s->mem[2] = 0x00; - s->mem[3] = 0x12; - s->mem[4] = 0x34; - s->mem[5] = 0x56; - s->mem[14] = 0x57; - s->mem[15] = 0x57; +void hex_dump(FILE *f, const uint8_t *buf, int size) +{ + int len, i, j, c; - /* duplicate prom data */ - for(i = 15;i >= 0; i--) { - s->mem[2 * i] = s->mem[i]; - s->mem[2 * i + 1] = s->mem[i]; + for(i=0;i 16) + len = 16; + fprintf(f, "%08x ", i); + for(j=0;j<16;j++) { + if (j < len) + fprintf(f, " %02x", buf[i+j]); + else + fprintf(f, " "); + } + fprintf(f, " "); + for(j=0;j '~') + c = '.'; + fprintf(f, "%c", c); + } + fprintf(f, "\n"); } } -void ne2000_update_irq(NE2000State *s) +void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size) { - int isr; - isr = s->isr & s->imr; - if (isr) - pic_set_irq(NE2000_IRQ, 1); - else - pic_set_irq(NE2000_IRQ, 0); + nd->send_packet(nd, buf, size); } -int net_init(void) +void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) +{ + nd->add_read_packet(nd, fd_can_read, fd_read, opaque); +} + +/* dummy network adapter */ + +static void dummy_send_packet(NetDriverState *nd, const uint8_t *buf, int size) +{ +} + +static void dummy_add_read_packet(NetDriverState *nd, + IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) +{ +} + +static int net_dummy_init(NetDriverState *nd) +{ + nd->send_packet = dummy_send_packet; + nd->add_read_packet = dummy_add_read_packet; + pstrcpy(nd->ifname, sizeof(nd->ifname), "dummy"); + return 0; +} + +#if defined(CONFIG_SLIRP) + +/* slirp network adapter */ + +static void *slirp_fd_opaque; +static IOCanRWHandler *slirp_fd_can_read; +static IOReadHandler *slirp_fd_read; +static int slirp_inited; + +int slirp_can_output(void) +{ + return slirp_fd_can_read(slirp_fd_opaque); +} + +void slirp_output(const uint8_t *pkt, int pkt_len) +{ +#if 0 + printf("output:\n"); + hex_dump(stdout, pkt, pkt_len); +#endif + slirp_fd_read(slirp_fd_opaque, pkt, pkt_len); +} + +static void slirp_send_packet(NetDriverState *nd, const uint8_t *buf, int size) +{ +#if 0 + printf("input:\n"); + hex_dump(stdout, buf, size); +#endif + slirp_input(buf, size); +} + +static void slirp_add_read_packet(NetDriverState *nd, + IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) +{ + slirp_fd_opaque = opaque; + slirp_fd_can_read = fd_can_read; + slirp_fd_read = fd_read; +} + +static int net_slirp_init(NetDriverState *nd) +{ + if (!slirp_inited) { + slirp_inited = 1; + slirp_init(); + } + nd->send_packet = slirp_send_packet; + nd->add_read_packet = slirp_add_read_packet; + pstrcpy(nd->ifname, sizeof(nd->ifname), "slirp"); + return 0; +} + +static int get_str_sep(char *buf, int buf_size, const char **pp, int sep) +{ + const char *p, *p1; + int len; + p = *pp; + p1 = strchr(p, sep); + if (!p1) + return -1; + len = p1 - p; + p1++; + if (buf_size > 0) { + if (len > buf_size - 1) + len = buf_size - 1; + memcpy(buf, p, len); + buf[len] = '\0'; + } + *pp = p1; + return 0; +} + +static void net_slirp_redir(const char *redir_str) +{ + int is_udp; + char buf[256], *r; + const char *p; + struct in_addr guest_addr; + int host_port, guest_port; + + if (!slirp_inited) { + slirp_inited = 1; + slirp_init(); + } + + p = redir_str; + if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) + goto fail; + if (!strcmp(buf, "tcp")) { + is_udp = 0; + } else if (!strcmp(buf, "udp")) { + is_udp = 1; + } else { + goto fail; + } + + if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) + goto fail; + host_port = strtol(buf, &r, 0); + if (r == buf) + goto fail; + + if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) + goto fail; + if (buf[0] == '\0') { + pstrcpy(buf, sizeof(buf), "10.0.2.15"); + } + if (!inet_aton(buf, &guest_addr)) + goto fail; + + guest_port = strtol(p, &r, 0); + if (r == p) + goto fail; + + if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) { + fprintf(stderr, "qemu: could not set up redirection\n"); + exit(1); + } + return; + fail: + fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n"); + exit(1); +} + +#ifndef _WIN32 + +char smb_dir[1024]; + +static void smb_exit(void) +{ + DIR *d; + struct dirent *de; + char filename[1024]; + + /* erase all the files in the directory */ + d = opendir(smb_dir); + for(;;) { + de = readdir(d); + if (!de) + break; + if (strcmp(de->d_name, ".") != 0 && + strcmp(de->d_name, "..") != 0) { + snprintf(filename, sizeof(filename), "%s/%s", + smb_dir, de->d_name); + unlink(filename); + } + } + closedir(d); + rmdir(smb_dir); +} + +/* automatic user mode samba server configuration */ +void net_slirp_smb(const char *exported_dir) +{ + char smb_conf[1024]; + char smb_cmdline[1024]; + FILE *f; + + if (!slirp_inited) { + slirp_inited = 1; + slirp_init(); + } + + /* XXX: better tmp dir construction */ + snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid()); + if (mkdir(smb_dir, 0700) < 0) { + fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir); + exit(1); + } + snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf"); + + f = fopen(smb_conf, "w"); + if (!f) { + fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf); + exit(1); + } + fprintf(f, + "[global]\n" + "private dir=%s\n" + "smb ports=0\n" + "socket address=127.0.0.1\n" + "pid directory=%s\n" + "lock directory=%s\n" + "log file=%s/log.smbd\n" + "smb passwd file=%s/smbpasswd\n" + "security = share\n" + "[qemu]\n" + "path=%s\n" + "read only=no\n" + "guest ok=yes\n", + smb_dir, + smb_dir, + smb_dir, + smb_dir, + smb_dir, + exported_dir + ); + fclose(f); + atexit(smb_exit); + + snprintf(smb_cmdline, sizeof(smb_cmdline), "/usr/sbin/smbd -s %s", + smb_conf); + + slirp_add_exec(0, smb_cmdline, 4, 139); +} + +#endif /* !defined(_WIN32) */ + +#endif /* CONFIG_SLIRP */ + +#if !defined(_WIN32) +#ifdef _BSD +static int tun_open(char *ifname, int ifname_size) +{ + int fd; + char *dev; + struct stat s; + + fd = open("/dev/tap", O_RDWR); + if (fd < 0) { + fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n"); + return -1; + } + + fstat(fd, &s); + dev = devname(s.st_rdev, S_IFCHR); + pstrcpy(ifname, ifname_size, dev); + + fcntl(fd, F_SETFL, O_NONBLOCK); + return fd; +} +#else +static int tun_open(char *ifname, int ifname_size) { struct ifreq ifr; - int fd, ret, pid, status; + int fd, ret; fd = open("/dev/net/tun", O_RDWR); if (fd < 0) { @@ -1866,1237 +1644,1147 @@ int net_init(void) return -1; } printf("Connected to host network interface: %s\n", ifr.ifr_name); + pstrcpy(ifname, ifname_size, ifr.ifr_name); fcntl(fd, F_SETFL, O_NONBLOCK); - net_fd = fd; + return fd; +} +#endif + +static void tun_send_packet(NetDriverState *nd, const uint8_t *buf, int size) +{ + write(nd->fd, buf, size); +} + +static void tun_add_read_packet(NetDriverState *nd, + IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) +{ + qemu_add_fd_read_handler(nd->fd, fd_can_read, fd_read, opaque); +} + +static int net_tun_init(NetDriverState *nd) +{ + int pid, status; + char *args[3]; + char **parg; + + nd->fd = tun_open(nd->ifname, sizeof(nd->ifname)); + if (nd->fd < 0) + return -1; /* try to launch network init script */ pid = fork(); if (pid >= 0) { if (pid == 0) { - execl(network_script, network_script, ifr.ifr_name, NULL); + parg = args; + *parg++ = network_script; + *parg++ = nd->ifname; + *parg++ = NULL; + execv(network_script, args); exit(1); } while (waitpid(pid, &status, 0) != pid); if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { - fprintf(stderr, "%s: could not launch network script for '%s'\n", - network_script, ifr.ifr_name); + fprintf(stderr, "%s: could not launch network script\n", + network_script); } } + nd->send_packet = tun_send_packet; + nd->add_read_packet = tun_add_read_packet; return 0; } -void net_send_packet(NE2000State *s, const uint8_t *buf, int size) +static int net_fd_init(NetDriverState *nd, int fd) { -#ifdef DEBUG_NE2000 - printf("NE2000: sending packet size=%d\n", size); -#endif - write(net_fd, buf, size); + nd->fd = fd; + nd->send_packet = tun_send_packet; + nd->add_read_packet = tun_add_read_packet; + pstrcpy(nd->ifname, sizeof(nd->ifname), "tunfd"); + return 0; } -/* return true if the NE2000 can receive more data */ -int ne2000_can_receive(NE2000State *s) -{ - int avail, index, boundary; - - if (s->cmd & E8390_STOP) - return 0; - index = s->curpag << 8; - boundary = s->boundary << 8; - if (index < boundary) - avail = boundary - index; - else - avail = (s->stop - s->start) - (index - boundary); - if (avail < (MAX_ETH_FRAME_SIZE + 4)) - return 0; - return 1; -} +#endif /* !_WIN32 */ -void ne2000_receive(NE2000State *s, uint8_t *buf, int size) -{ - uint8_t *p; - int total_len, next, avail, len, index; - -#if defined(DEBUG_NE2000) - printf("NE2000: received len=%d\n", size); -#endif - - index = s->curpag << 8; - /* 4 bytes for header */ - total_len = size + 4; - /* address for next packet (4 bytes for CRC) */ - next = index + ((total_len + 4 + 255) & ~0xff); - if (next >= s->stop) - next -= (s->stop - s->start); - /* prepare packet header */ - p = s->mem + index; - p[0] = ENRSR_RXOK; /* receive status */ - p[1] = next >> 8; - p[2] = total_len; - p[3] = total_len >> 8; - index += 4; - - /* write packet data */ - while (size > 0) { - avail = s->stop - index; - len = size; - if (len > avail) - len = avail; - memcpy(s->mem + index, buf, len); - buf += len; - index += len; - if (index == s->stop) - index = s->start; - size -= len; - } - s->curpag = next >> 8; - - /* now we can signal we have receive something */ - s->isr |= ENISR_RX; - ne2000_update_irq(s); +/***********************************************************/ +/* pid file */ + +static char *pid_filename; + +/* Remove PID file. Called on normal exit */ + +static void remove_pidfile(void) +{ + unlink (pid_filename); } -void ne2000_ioport_write(CPUState *env, uint32_t addr, uint32_t val) +static void create_pidfile(const char *filename) { - NE2000State *s = &ne2000_state; - int offset, page; + struct stat pidstat; + FILE *f; - addr &= 0xf; -#ifdef DEBUG_NE2000 - printf("NE2000: write addr=0x%x val=0x%02x\n", addr, val); -#endif - if (addr == E8390_CMD) { - /* control register */ - s->cmd = val; - if (val & E8390_START) { - /* test specific case: zero length transfert */ - if ((val & (E8390_RREAD | E8390_RWRITE)) && - s->rcnt == 0) { - s->isr |= ENISR_RDC; - ne2000_update_irq(s); + /* Try to write our PID to the named file */ + if (stat(filename, &pidstat) < 0) { + if (errno == ENOENT) { + if ((f = fopen (filename, "w")) == NULL) { + perror("Opening pidfile"); + exit(1); } - if (val & E8390_TRANS) { - net_send_packet(s, s->mem + (s->tpsr << 8), s->tcnt); - /* signal end of transfert */ - s->tsr = ENTSR_PTX; - s->isr |= ENISR_TX; - ne2000_update_irq(s); + fprintf(f, "%d\n", getpid()); + fclose(f); + pid_filename = qemu_strdup(filename); + if (!pid_filename) { + fprintf(stderr, "Could not save PID filename"); + exit(1); } + atexit(remove_pidfile); } } else { - page = s->cmd >> 6; - offset = addr | (page << 4); - switch(offset) { - case EN0_STARTPG: - s->start = val << 8; - break; - case EN0_STOPPG: - s->stop = val << 8; - break; - case EN0_BOUNDARY: - s->boundary = val; - break; - case EN0_IMR: - s->imr = val; - ne2000_update_irq(s); - break; - case EN0_TPSR: - s->tpsr = val; - break; - case EN0_TCNTLO: - s->tcnt = (s->tcnt & 0xff00) | val; - break; - case EN0_TCNTHI: - s->tcnt = (s->tcnt & 0x00ff) | (val << 8); - break; - case EN0_RSARLO: - s->rsar = (s->rsar & 0xff00) | val; - break; - case EN0_RSARHI: - s->rsar = (s->rsar & 0x00ff) | (val << 8); - break; - case EN0_RCNTLO: - s->rcnt = (s->rcnt & 0xff00) | val; - break; - case EN0_RCNTHI: - s->rcnt = (s->rcnt & 0x00ff) | (val << 8); - break; - case EN0_DCFG: - s->dcfg = val; - break; - case EN0_ISR: - s->isr &= ~val; - ne2000_update_irq(s); - break; - case EN1_PHYS ... EN1_PHYS + 5: - s->phys[offset - EN1_PHYS] = val; - break; - case EN1_CURPAG: - s->curpag = val; - break; - case EN1_MULT ... EN1_MULT + 7: - s->mult[offset - EN1_MULT] = val; - break; - } + fprintf(stderr, "%s already exists. Remove it and try again.\n", + filename); + exit(1); } } -uint32_t ne2000_ioport_read(CPUState *env, uint32_t addr) +/***********************************************************/ +/* dumb display */ + +static void dumb_update(DisplayState *ds, int x, int y, int w, int h) { - NE2000State *s = &ne2000_state; - int offset, page, ret; +} - addr &= 0xf; - if (addr == E8390_CMD) { - ret = s->cmd; - } else { - page = s->cmd >> 6; - offset = addr | (page << 4); - switch(offset) { - case EN0_TSR: - ret = s->tsr; - break; - case EN0_BOUNDARY: - ret = s->boundary; - break; - case EN0_ISR: - ret = s->isr; - break; - case EN1_PHYS ... EN1_PHYS + 5: - ret = s->phys[offset - EN1_PHYS]; - break; - case EN1_CURPAG: - ret = s->curpag; - break; - case EN1_MULT ... EN1_MULT + 7: - ret = s->mult[offset - EN1_MULT]; +static void dumb_resize(DisplayState *ds, int w, int h) +{ +} + +static void dumb_refresh(DisplayState *ds) +{ + vga_update_display(); +} + +void dumb_display_init(DisplayState *ds) +{ + ds->data = NULL; + ds->linesize = 0; + ds->depth = 0; + ds->dpy_update = dumb_update; + ds->dpy_resize = dumb_resize; + ds->dpy_refresh = dumb_refresh; +} + +#if !defined(CONFIG_SOFTMMU) +/***********************************************************/ +/* cpu signal handler */ +static void host_segv_handler(int host_signum, siginfo_t *info, + void *puc) +{ + if (cpu_signal_handler(host_signum, info, puc)) + return; + if (stdio_nb_clients > 0) + term_exit(); + abort(); +} +#endif + +/***********************************************************/ +/* I/O handling */ + +#define MAX_IO_HANDLERS 64 + +typedef struct IOHandlerRecord { + int fd; + IOCanRWHandler *fd_can_read; + IOReadHandler *fd_read; + void *opaque; + /* temporary data */ + struct pollfd *ufd; + int max_size; + struct IOHandlerRecord *next; +} IOHandlerRecord; + +static IOHandlerRecord *first_io_handler; + +int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read, + IOReadHandler *fd_read, void *opaque) +{ + IOHandlerRecord *ioh; + + ioh = qemu_mallocz(sizeof(IOHandlerRecord)); + if (!ioh) + return -1; + ioh->fd = fd; + ioh->fd_can_read = fd_can_read; + ioh->fd_read = fd_read; + ioh->opaque = opaque; + ioh->next = first_io_handler; + first_io_handler = ioh; + return 0; +} + +void qemu_del_fd_read_handler(int fd) +{ + IOHandlerRecord **pioh, *ioh; + + pioh = &first_io_handler; + for(;;) { + ioh = *pioh; + if (ioh == NULL) break; - default: - ret = 0x00; + if (ioh->fd == fd) { + *pioh = ioh->next; break; } + pioh = &ioh->next; } -#ifdef DEBUG_NE2000 - printf("NE2000: read addr=0x%x val=%02x\n", addr, ret); -#endif - return ret; } -void ne2000_asic_ioport_write(CPUState *env, uint32_t addr, uint32_t val) +/***********************************************************/ +/* savevm/loadvm support */ + +void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size) { - NE2000State *s = &ne2000_state; - uint8_t *p; + fwrite(buf, 1, size, f); +} -#ifdef DEBUG_NE2000 - printf("NE2000: asic write val=0x%04x\n", val); -#endif - p = s->mem + s->rsar; - if (s->dcfg & 0x01) { - /* 16 bit access */ - p[0] = val; - p[1] = val >> 8; - s->rsar += 2; - s->rcnt -= 2; - } else { - /* 8 bit access */ - p[0] = val; - s->rsar++; - s->rcnt--; - } - /* wrap */ - if (s->rsar == s->stop) - s->rsar = s->start; - if (s->rcnt == 0) { - /* signal end of transfert */ - s->isr |= ENISR_RDC; - ne2000_update_irq(s); - } +void qemu_put_byte(QEMUFile *f, int v) +{ + fputc(v, f); } -uint32_t ne2000_asic_ioport_read(CPUState *env, uint32_t addr) +void qemu_put_be16(QEMUFile *f, unsigned int v) { - NE2000State *s = &ne2000_state; - uint8_t *p; - int ret; + qemu_put_byte(f, v >> 8); + qemu_put_byte(f, v); +} - p = s->mem + s->rsar; - if (s->dcfg & 0x01) { - /* 16 bit access */ - ret = p[0] | (p[1] << 8); - s->rsar += 2; - s->rcnt -= 2; - } else { - /* 8 bit access */ - ret = p[0]; - s->rsar++; - s->rcnt--; - } - /* wrap */ - if (s->rsar == s->stop) - s->rsar = s->start; - if (s->rcnt == 0) { - /* signal end of transfert */ - s->isr |= ENISR_RDC; - ne2000_update_irq(s); - } -#ifdef DEBUG_NE2000 - printf("NE2000: asic read val=0x%04x\n", ret); -#endif - return ret; +void qemu_put_be32(QEMUFile *f, unsigned int v) +{ + qemu_put_byte(f, v >> 24); + qemu_put_byte(f, v >> 16); + qemu_put_byte(f, v >> 8); + qemu_put_byte(f, v); } -void ne2000_reset_ioport_write(CPUState *env, uint32_t addr, uint32_t val) +void qemu_put_be64(QEMUFile *f, uint64_t v) { - /* nothing to do (end of reset pulse) */ + qemu_put_be32(f, v >> 32); + qemu_put_be32(f, v); } -uint32_t ne2000_reset_ioport_read(CPUState *env, uint32_t addr) +int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size) { - ne2000_reset(); - return 0; + return fread(buf, 1, size, f); } -void ne2000_init(void) +int qemu_get_byte(QEMUFile *f) { - register_ioport_write(NE2000_IOPORT, 16, ne2000_ioport_write, 1); - register_ioport_read(NE2000_IOPORT, 16, ne2000_ioport_read, 1); + int v; + v = fgetc(f); + if (v == EOF) + return 0; + else + return v; +} - register_ioport_write(NE2000_IOPORT + 0x10, 1, ne2000_asic_ioport_write, 1); - register_ioport_read(NE2000_IOPORT + 0x10, 1, ne2000_asic_ioport_read, 1); - register_ioport_write(NE2000_IOPORT + 0x10, 2, ne2000_asic_ioport_write, 2); - register_ioport_read(NE2000_IOPORT + 0x10, 2, ne2000_asic_ioport_read, 2); +unsigned int qemu_get_be16(QEMUFile *f) +{ + unsigned int v; + v = qemu_get_byte(f) << 8; + v |= qemu_get_byte(f); + return v; +} - register_ioport_write(NE2000_IOPORT + 0x1f, 1, ne2000_reset_ioport_write, 1); - register_ioport_read(NE2000_IOPORT + 0x1f, 1, ne2000_reset_ioport_read, 1); - ne2000_reset(); +unsigned int qemu_get_be32(QEMUFile *f) +{ + unsigned int v; + v = qemu_get_byte(f) << 24; + v |= qemu_get_byte(f) << 16; + v |= qemu_get_byte(f) << 8; + v |= qemu_get_byte(f); + return v; } -#endif -/***********************************************************/ -/* PC floppy disk controler emulation glue */ -#define PC_FDC_DMA 0x2 -#define PC_FDC_IRQ 0x6 -#define PC_FDC_BASE 0x3F0 +uint64_t qemu_get_be64(QEMUFile *f) +{ + uint64_t v; + v = (uint64_t)qemu_get_be32(f) << 32; + v |= qemu_get_be32(f); + return v; +} -static void fdctrl_register (unsigned char **disknames, int ro, - char boot_device) +int64_t qemu_ftell(QEMUFile *f) { - int i; + return ftell(f); +} + +int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence) +{ + if (fseek(f, pos, whence) < 0) + return -1; + return ftell(f); +} + +typedef struct SaveStateEntry { + char idstr[256]; + int instance_id; + int version_id; + SaveStateHandler *save_state; + LoadStateHandler *load_state; + void *opaque; + struct SaveStateEntry *next; +} SaveStateEntry; + +static SaveStateEntry *first_se; + +int register_savevm(const char *idstr, + int instance_id, + int version_id, + SaveStateHandler *save_state, + LoadStateHandler *load_state, + void *opaque) +{ + SaveStateEntry *se, **pse; + + se = qemu_malloc(sizeof(SaveStateEntry)); + if (!se) + return -1; + pstrcpy(se->idstr, sizeof(se->idstr), idstr); + se->instance_id = instance_id; + se->version_id = version_id; + se->save_state = save_state; + se->load_state = load_state; + se->opaque = opaque; + se->next = NULL; + + /* add at the end of list */ + pse = &first_se; + while (*pse != NULL) + pse = &(*pse)->next; + *pse = se; + return 0; +} + +#define QEMU_VM_FILE_MAGIC 0x5145564d +#define QEMU_VM_FILE_VERSION 0x00000001 - fdctrl_init(PC_FDC_IRQ, PC_FDC_DMA, 0, PC_FDC_BASE, boot_device); - for (i = 0; i < MAX_FD; i++) { - if (disknames[i] != NULL) - fdctrl_disk_change(i, disknames[i], ro); +int qemu_savevm(const char *filename) +{ + SaveStateEntry *se; + QEMUFile *f; + int len, len_pos, cur_pos, saved_vm_running, ret; + + saved_vm_running = vm_running; + vm_stop(0); + + f = fopen(filename, "wb"); + if (!f) { + ret = -1; + goto the_end; + } + + qemu_put_be32(f, QEMU_VM_FILE_MAGIC); + qemu_put_be32(f, QEMU_VM_FILE_VERSION); + + for(se = first_se; se != NULL; se = se->next) { + /* ID string */ + len = strlen(se->idstr); + qemu_put_byte(f, len); + qemu_put_buffer(f, se->idstr, len); + + qemu_put_be32(f, se->instance_id); + qemu_put_be32(f, se->version_id); + + /* record size: filled later */ + len_pos = ftell(f); + qemu_put_be32(f, 0); + + se->save_state(f, se->opaque); + + /* fill record size */ + cur_pos = ftell(f); + len = ftell(f) - len_pos - 4; + fseek(f, len_pos, SEEK_SET); + qemu_put_be32(f, len); + fseek(f, cur_pos, SEEK_SET); } + + fclose(f); + ret = 0; + the_end: + if (saved_vm_running) + vm_start(); + return ret; } -/***********************************************************/ -/* keyboard emulation */ - -/* Keyboard Controller Commands */ -#define KBD_CCMD_READ_MODE 0x20 /* Read mode bits */ -#define KBD_CCMD_WRITE_MODE 0x60 /* Write mode bits */ -#define KBD_CCMD_GET_VERSION 0xA1 /* Get controller version */ -#define KBD_CCMD_MOUSE_DISABLE 0xA7 /* Disable mouse interface */ -#define KBD_CCMD_MOUSE_ENABLE 0xA8 /* Enable mouse interface */ -#define KBD_CCMD_TEST_MOUSE 0xA9 /* Mouse interface test */ -#define KBD_CCMD_SELF_TEST 0xAA /* Controller self test */ -#define KBD_CCMD_KBD_TEST 0xAB /* Keyboard interface test */ -#define KBD_CCMD_KBD_DISABLE 0xAD /* Keyboard interface disable */ -#define KBD_CCMD_KBD_ENABLE 0xAE /* Keyboard interface enable */ -#define KBD_CCMD_READ_INPORT 0xC0 /* read input port */ -#define KBD_CCMD_READ_OUTPORT 0xD0 /* read output port */ -#define KBD_CCMD_WRITE_OUTPORT 0xD1 /* write output port */ -#define KBD_CCMD_WRITE_OBUF 0xD2 -#define KBD_CCMD_WRITE_AUX_OBUF 0xD3 /* Write to output buffer as if - initiated by the auxiliary device */ -#define KBD_CCMD_WRITE_MOUSE 0xD4 /* Write the following byte to the mouse */ -#define KBD_CCMD_DISABLE_A20 0xDD /* HP vectra only ? */ -#define KBD_CCMD_ENABLE_A20 0xDF /* HP vectra only ? */ -#define KBD_CCMD_RESET 0xFE - -/* Keyboard Commands */ -#define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */ -#define KBD_CMD_ECHO 0xEE -#define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */ -#define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */ -#define KBD_CMD_ENABLE 0xF4 /* Enable scanning */ -#define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */ -#define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */ -#define KBD_CMD_RESET 0xFF /* Reset */ - -/* Keyboard Replies */ -#define KBD_REPLY_POR 0xAA /* Power on reset */ -#define KBD_REPLY_ACK 0xFA /* Command ACK */ -#define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */ - -/* Status Register Bits */ -#define KBD_STAT_OBF 0x01 /* Keyboard output buffer full */ -#define KBD_STAT_IBF 0x02 /* Keyboard input buffer full */ -#define KBD_STAT_SELFTEST 0x04 /* Self test successful */ -#define KBD_STAT_CMD 0x08 /* Last write was a command write (0=data) */ -#define KBD_STAT_UNLOCKED 0x10 /* Zero if keyboard locked */ -#define KBD_STAT_MOUSE_OBF 0x20 /* Mouse output buffer full */ -#define KBD_STAT_GTO 0x40 /* General receive/xmit timeout */ -#define KBD_STAT_PERR 0x80 /* Parity error */ - -/* Controller Mode Register Bits */ -#define KBD_MODE_KBD_INT 0x01 /* Keyboard data generate IRQ1 */ -#define KBD_MODE_MOUSE_INT 0x02 /* Mouse data generate IRQ12 */ -#define KBD_MODE_SYS 0x04 /* The system flag (?) */ -#define KBD_MODE_NO_KEYLOCK 0x08 /* The keylock doesn't affect the keyboard if set */ -#define KBD_MODE_DISABLE_KBD 0x10 /* Disable keyboard interface */ -#define KBD_MODE_DISABLE_MOUSE 0x20 /* Disable mouse interface */ -#define KBD_MODE_KCC 0x40 /* Scan code conversion to PC format */ -#define KBD_MODE_RFU 0x80 - -/* Mouse Commands */ -#define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */ -#define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */ -#define AUX_SET_RES 0xE8 /* Set resolution */ -#define AUX_GET_SCALE 0xE9 /* Get scaling factor */ -#define AUX_SET_STREAM 0xEA /* Set stream mode */ -#define AUX_POLL 0xEB /* Poll */ -#define AUX_RESET_WRAP 0xEC /* Reset wrap mode */ -#define AUX_SET_WRAP 0xEE /* Set wrap mode */ -#define AUX_SET_REMOTE 0xF0 /* Set remote mode */ -#define AUX_GET_TYPE 0xF2 /* Get type */ -#define AUX_SET_SAMPLE 0xF3 /* Set sample rate */ -#define AUX_ENABLE_DEV 0xF4 /* Enable aux device */ -#define AUX_DISABLE_DEV 0xF5 /* Disable aux device */ -#define AUX_SET_DEFAULT 0xF6 -#define AUX_RESET 0xFF /* Reset aux device */ -#define AUX_ACK 0xFA /* Command byte ACK. */ - -#define MOUSE_STATUS_REMOTE 0x40 -#define MOUSE_STATUS_ENABLED 0x20 -#define MOUSE_STATUS_SCALE21 0x10 - -#define KBD_QUEUE_SIZE 256 +static SaveStateEntry *find_se(const char *idstr, int instance_id) +{ + SaveStateEntry *se; -typedef struct { - uint8_t data[KBD_QUEUE_SIZE]; - int rptr, wptr, count; -} KBDQueue; - -typedef struct KBDState { - KBDQueue queues[2]; - uint8_t write_cmd; /* if non zero, write data to port 60 is expected */ - uint8_t status; - uint8_t mode; - /* keyboard state */ - int kbd_write_cmd; - int scan_enabled; - /* mouse state */ - int mouse_write_cmd; - uint8_t mouse_status; - uint8_t mouse_resolution; - uint8_t mouse_sample_rate; - uint8_t mouse_wrap; - uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */ - uint8_t mouse_detect_state; - int mouse_dx; /* current values, needed for 'poll' mode */ - int mouse_dy; - int mouse_dz; - uint8_t mouse_buttons; -} KBDState; - -KBDState kbd_state; -int reset_requested; - -/* update irq and KBD_STAT_[MOUSE_]OBF */ -/* XXX: not generating the irqs if KBD_MODE_DISABLE_KBD is set may be - incorrect, but it avoids having to simulate exact delays */ -static void kbd_update_irq(KBDState *s) -{ - int irq12_level, irq1_level; - - irq1_level = 0; - irq12_level = 0; - s->status &= ~(KBD_STAT_OBF | KBD_STAT_MOUSE_OBF); - if (s->queues[0].count != 0 || - s->queues[1].count != 0) { - s->status |= KBD_STAT_OBF; - if (s->queues[1].count != 0) { - s->status |= KBD_STAT_MOUSE_OBF; - if (s->mode & KBD_MODE_MOUSE_INT) - irq12_level = 1; - } else { - if ((s->mode & KBD_MODE_KBD_INT) && - !(s->mode & KBD_MODE_DISABLE_KBD)) - irq1_level = 1; - } + for(se = first_se; se != NULL; se = se->next) { + if (!strcmp(se->idstr, idstr) && + instance_id == se->instance_id) + return se; } - pic_set_irq(1, irq1_level); - pic_set_irq(12, irq12_level); + return NULL; } -static void kbd_queue(KBDState *s, int b, int aux) +int qemu_loadvm(const char *filename) { - KBDQueue *q = &kbd_state.queues[aux]; + SaveStateEntry *se; + QEMUFile *f; + int len, cur_pos, ret, instance_id, record_len, version_id; + int saved_vm_running; + unsigned int v; + char idstr[256]; + + saved_vm_running = vm_running; + vm_stop(0); -#if defined(DEBUG_MOUSE) || defined(DEBUG_KBD) - if (aux) - printf("mouse event: 0x%02x\n", b); -#ifdef DEBUG_KBD - else - printf("kbd event: 0x%02x\n", b); -#endif + f = fopen(filename, "rb"); + if (!f) { + ret = -1; + goto the_end; + } + + v = qemu_get_be32(f); + if (v != QEMU_VM_FILE_MAGIC) + goto fail; + v = qemu_get_be32(f); + if (v != QEMU_VM_FILE_VERSION) { + fail: + fclose(f); + ret = -1; + goto the_end; + } + for(;;) { +#if defined (DO_TB_FLUSH) + tb_flush(global_env); #endif - if (q->count >= KBD_QUEUE_SIZE) - return; - q->data[q->wptr] = b; - if (++q->wptr == KBD_QUEUE_SIZE) - q->wptr = 0; - q->count++; - kbd_update_irq(s); + len = qemu_get_byte(f); + if (feof(f)) + break; + qemu_get_buffer(f, idstr, len); + idstr[len] = '\0'; + instance_id = qemu_get_be32(f); + version_id = qemu_get_be32(f); + record_len = qemu_get_be32(f); +#if 0 + printf("idstr=%s instance=0x%x version=%d len=%d\n", + idstr, instance_id, version_id, record_len); +#endif + cur_pos = ftell(f); + se = find_se(idstr, instance_id); + if (!se) { + fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n", + instance_id, idstr); + } else { + ret = se->load_state(f, se->opaque, version_id); + if (ret < 0) { + fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n", + instance_id, idstr); + } + } + /* always seek to exact end of record */ + qemu_fseek(f, cur_pos + record_len, SEEK_SET); + } + fclose(f); + ret = 0; + the_end: + if (saved_vm_running) + vm_start(); + return ret; } -void kbd_put_keycode(int keycode) +/***********************************************************/ +/* cpu save/restore */ + +#if defined(TARGET_I386) + +static void cpu_put_seg(QEMUFile *f, SegmentCache *dt) { - KBDState *s = &kbd_state; - kbd_queue(s, keycode, 0); + qemu_put_be32(f, dt->selector); + qemu_put_betl(f, dt->base); + qemu_put_be32(f, dt->limit); + qemu_put_be32(f, dt->flags); } -uint32_t kbd_read_status(CPUState *env, uint32_t addr) +static void cpu_get_seg(QEMUFile *f, SegmentCache *dt) { - KBDState *s = &kbd_state; - int val; - val = s->status; -#if defined(DEBUG_KBD) - printf("kbd: read status=0x%02x\n", val); -#endif - return val; + dt->selector = qemu_get_be32(f); + dt->base = qemu_get_betl(f); + dt->limit = qemu_get_be32(f); + dt->flags = qemu_get_be32(f); } -void kbd_write_command(CPUState *env, uint32_t addr, uint32_t val) +void cpu_save(QEMUFile *f, void *opaque) { - KBDState *s = &kbd_state; + CPUState *env = opaque; + uint16_t fptag, fpus, fpuc, fpregs_format; + uint32_t hflags; + int i; + + for(i = 0; i < CPU_NB_REGS; i++) + qemu_put_betls(f, &env->regs[i]); + qemu_put_betls(f, &env->eip); + qemu_put_betls(f, &env->eflags); + hflags = env->hflags; /* XXX: suppress most of the redundant hflags */ + qemu_put_be32s(f, &hflags); + + /* FPU */ + fpuc = env->fpuc; + fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11; + fptag = 0; + for(i = 0; i < 8; i++) { + fptag |= ((!env->fptags[i]) << i); + } + + qemu_put_be16s(f, &fpuc); + qemu_put_be16s(f, &fpus); + qemu_put_be16s(f, &fptag); -#ifdef DEBUG_KBD - printf("kbd: write cmd=0x%02x\n", val); -#endif - switch(val) { - case KBD_CCMD_READ_MODE: - kbd_queue(s, s->mode, 0); - break; - case KBD_CCMD_WRITE_MODE: - case KBD_CCMD_WRITE_OBUF: - case KBD_CCMD_WRITE_AUX_OBUF: - case KBD_CCMD_WRITE_MOUSE: - case KBD_CCMD_WRITE_OUTPORT: - s->write_cmd = val; - break; - case KBD_CCMD_MOUSE_DISABLE: - s->mode |= KBD_MODE_DISABLE_MOUSE; - break; - case KBD_CCMD_MOUSE_ENABLE: - s->mode &= ~KBD_MODE_DISABLE_MOUSE; - break; - case KBD_CCMD_TEST_MOUSE: - kbd_queue(s, 0x00, 0); - break; - case KBD_CCMD_SELF_TEST: - s->status |= KBD_STAT_SELFTEST; - kbd_queue(s, 0x55, 0); - break; - case KBD_CCMD_KBD_TEST: - kbd_queue(s, 0x00, 0); - break; - case KBD_CCMD_KBD_DISABLE: - s->mode |= KBD_MODE_DISABLE_KBD; - kbd_update_irq(s); - break; - case KBD_CCMD_KBD_ENABLE: - s->mode &= ~KBD_MODE_DISABLE_KBD; - kbd_update_irq(s); - break; - case KBD_CCMD_READ_INPORT: - kbd_queue(s, 0x00, 0); - break; - case KBD_CCMD_READ_OUTPORT: - /* XXX: check that */ -#ifdef TARGET_I386 - val = 0x01 | (((cpu_single_env->a20_mask >> 20) & 1) << 1); +#ifdef USE_X86LDOUBLE + fpregs_format = 0; #else - val = 0x01; + fpregs_format = 1; #endif - if (s->status & KBD_STAT_OBF) - val |= 0x10; - if (s->status & KBD_STAT_MOUSE_OBF) - val |= 0x20; - kbd_queue(s, val, 0); - break; -#ifdef TARGET_I386 - case KBD_CCMD_ENABLE_A20: - cpu_x86_set_a20(env, 1); - break; - case KBD_CCMD_DISABLE_A20: - cpu_x86_set_a20(env, 0); - break; + qemu_put_be16s(f, &fpregs_format); + + for(i = 0; i < 8; i++) { +#ifdef USE_X86LDOUBLE + { + uint64_t mant; + uint16_t exp; + /* we save the real CPU data (in case of MMX usage only 'mant' + contains the MMX register */ + cpu_get_fp80(&mant, &exp, env->fpregs[i].d); + qemu_put_be64(f, mant); + qemu_put_be16(f, exp); + } +#else + /* if we use doubles for float emulation, we save the doubles to + avoid losing information in case of MMX usage. It can give + problems if the image is restored on a CPU where long + doubles are used instead. */ + qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0)); #endif - case KBD_CCMD_RESET: - reset_requested = 1; - cpu_interrupt(global_env, CPU_INTERRUPT_EXIT); - break; - case 0xff: - /* ignore that - I don't know what is its use */ - break; - default: - fprintf(stderr, "qemu: unsupported keyboard cmd=0x%02x\n", val); - break; } -} -uint32_t kbd_read_data(CPUState *env, uint32_t addr) -{ - KBDState *s = &kbd_state; - KBDQueue *q; - int val, index; + for(i = 0; i < 6; i++) + cpu_put_seg(f, &env->segs[i]); + cpu_put_seg(f, &env->ldt); + cpu_put_seg(f, &env->tr); + cpu_put_seg(f, &env->gdt); + cpu_put_seg(f, &env->idt); - q = &s->queues[0]; /* first check KBD data */ - if (q->count == 0) - q = &s->queues[1]; /* then check AUX data */ - if (q->count == 0) { - /* NOTE: if no data left, we return the last keyboard one - (needed for EMM386) */ - /* XXX: need a timer to do things correctly */ - q = &s->queues[0]; - index = q->rptr - 1; - if (index < 0) - index = KBD_QUEUE_SIZE - 1; - val = q->data[index]; - } else { - val = q->data[q->rptr]; - if (++q->rptr == KBD_QUEUE_SIZE) - q->rptr = 0; - q->count--; - /* reading deasserts IRQ */ - if (q == &s->queues[0]) - pic_set_irq(1, 0); - else - pic_set_irq(12, 0); + qemu_put_be32s(f, &env->sysenter_cs); + qemu_put_be32s(f, &env->sysenter_esp); + qemu_put_be32s(f, &env->sysenter_eip); + + qemu_put_betls(f, &env->cr[0]); + qemu_put_betls(f, &env->cr[2]); + qemu_put_betls(f, &env->cr[3]); + qemu_put_betls(f, &env->cr[4]); + + for(i = 0; i < 8; i++) + qemu_put_betls(f, &env->dr[i]); + + /* MMU */ + qemu_put_be32s(f, &env->a20_mask); + + /* XMM */ + qemu_put_be32s(f, &env->mxcsr); + for(i = 0; i < CPU_NB_REGS; i++) { + qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0)); + qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1)); } - /* reassert IRQs if data left */ - kbd_update_irq(s); -#ifdef DEBUG_KBD - printf("kbd: read data=0x%02x\n", val); + +#ifdef TARGET_X86_64 + qemu_put_be64s(f, &env->efer); + qemu_put_be64s(f, &env->star); + qemu_put_be64s(f, &env->lstar); + qemu_put_be64s(f, &env->cstar); + qemu_put_be64s(f, &env->fmask); + qemu_put_be64s(f, &env->kernelgsbase); #endif - return val; } -static void kbd_reset_keyboard(KBDState *s) +#ifdef USE_X86LDOUBLE +/* XXX: add that in a FPU generic layer */ +union x86_longdouble { + uint64_t mant; + uint16_t exp; +}; + +#define MANTD1(fp) (fp & ((1LL << 52) - 1)) +#define EXPBIAS1 1023 +#define EXPD1(fp) ((fp >> 52) & 0x7FF) +#define SIGND1(fp) ((fp >> 32) & 0x80000000) + +static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp) { - s->scan_enabled = 1; + int e; + /* mantissa */ + p->mant = (MANTD1(temp) << 11) | (1LL << 63); + /* exponent + sign */ + e = EXPD1(temp) - EXPBIAS1 + 16383; + e |= SIGND1(temp) >> 16; + p->exp = e; } +#endif -static void kbd_write_keyboard(KBDState *s, int val) +int cpu_load(QEMUFile *f, void *opaque, int version_id) { - switch(s->kbd_write_cmd) { - default: - case -1: - switch(val) { - case 0x00: - kbd_queue(s, KBD_REPLY_ACK, 0); - break; - case 0x05: - kbd_queue(s, KBD_REPLY_RESEND, 0); - break; - case KBD_CMD_GET_ID: - kbd_queue(s, KBD_REPLY_ACK, 0); - kbd_queue(s, 0xab, 0); - kbd_queue(s, 0x83, 0); - break; - case KBD_CMD_ECHO: - kbd_queue(s, KBD_CMD_ECHO, 0); - break; - case KBD_CMD_ENABLE: - s->scan_enabled = 1; - kbd_queue(s, KBD_REPLY_ACK, 0); - break; - case KBD_CMD_SET_LEDS: - case KBD_CMD_SET_RATE: - s->kbd_write_cmd = val; - kbd_queue(s, KBD_REPLY_ACK, 0); - break; - case KBD_CMD_RESET_DISABLE: - kbd_reset_keyboard(s); - s->scan_enabled = 0; - kbd_queue(s, KBD_REPLY_ACK, 0); - break; - case KBD_CMD_RESET_ENABLE: - kbd_reset_keyboard(s); - s->scan_enabled = 1; - kbd_queue(s, KBD_REPLY_ACK, 0); + CPUState *env = opaque; + int i, guess_mmx; + uint32_t hflags; + uint16_t fpus, fpuc, fptag, fpregs_format; + + if (version_id != 3) + return -EINVAL; + for(i = 0; i < CPU_NB_REGS; i++) + qemu_get_betls(f, &env->regs[i]); + qemu_get_betls(f, &env->eip); + qemu_get_betls(f, &env->eflags); + qemu_get_be32s(f, &hflags); + + qemu_get_be16s(f, &fpuc); + qemu_get_be16s(f, &fpus); + qemu_get_be16s(f, &fptag); + qemu_get_be16s(f, &fpregs_format); + + /* NOTE: we cannot always restore the FPU state if the image come + from a host with a different 'USE_X86LDOUBLE' define. We guess + if we are in an MMX state to restore correctly in that case. */ + guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0); + for(i = 0; i < 8; i++) { + uint64_t mant; + uint16_t exp; + + switch(fpregs_format) { + case 0: + mant = qemu_get_be64(f); + exp = qemu_get_be16(f); +#ifdef USE_X86LDOUBLE + env->fpregs[i].d = cpu_set_fp80(mant, exp); +#else + /* difficult case */ + if (guess_mmx) + env->fpregs[i].mmx.MMX_Q(0) = mant; + else + env->fpregs[i].d = cpu_set_fp80(mant, exp); +#endif break; - case KBD_CMD_RESET: - kbd_reset_keyboard(s); - kbd_queue(s, KBD_REPLY_ACK, 0); - kbd_queue(s, KBD_REPLY_POR, 0); + case 1: + mant = qemu_get_be64(f); +#ifdef USE_X86LDOUBLE + { + union x86_longdouble *p; + /* difficult case */ + p = (void *)&env->fpregs[i]; + if (guess_mmx) { + p->mant = mant; + p->exp = 0xffff; + } else { + fp64_to_fp80(p, mant); + } + } +#else + env->fpregs[i].mmx.MMX_Q(0) = mant; +#endif break; default: - kbd_queue(s, KBD_REPLY_ACK, 0); - break; + return -EINVAL; } - break; - case KBD_CMD_SET_LEDS: - kbd_queue(s, KBD_REPLY_ACK, 0); - s->kbd_write_cmd = -1; - break; - case KBD_CMD_SET_RATE: - kbd_queue(s, KBD_REPLY_ACK, 0); - s->kbd_write_cmd = -1; - break; } -} -static void kbd_mouse_send_packet(KBDState *s) -{ - unsigned int b; - int dx1, dy1, dz1; - - dx1 = s->mouse_dx; - dy1 = s->mouse_dy; - dz1 = s->mouse_dz; - /* XXX: increase range to 8 bits ? */ - if (dx1 > 127) - dx1 = 127; - else if (dx1 < -127) - dx1 = -127; - if (dy1 > 127) - dy1 = 127; - else if (dy1 < -127) - dy1 = -127; - b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07); - kbd_queue(s, b, 1); - kbd_queue(s, dx1 & 0xff, 1); - kbd_queue(s, dy1 & 0xff, 1); - /* extra byte for IMPS/2 or IMEX */ - switch(s->mouse_type) { - default: - break; - case 3: - if (dz1 > 127) - dz1 = 127; - else if (dz1 < -127) - dz1 = -127; - kbd_queue(s, dz1 & 0xff, 1); - break; - case 4: - if (dz1 > 7) - dz1 = 7; - else if (dz1 < -7) - dz1 = -7; - b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1); - kbd_queue(s, b, 1); - break; + env->fpuc = fpuc; + /* XXX: restore FPU round state */ + env->fpstt = (fpus >> 11) & 7; + env->fpus = fpus & ~0x3800; + fptag ^= 0xff; + for(i = 0; i < 8; i++) { + env->fptags[i] = (fptag >> i) & 1; } + + for(i = 0; i < 6; i++) + cpu_get_seg(f, &env->segs[i]); + cpu_get_seg(f, &env->ldt); + cpu_get_seg(f, &env->tr); + cpu_get_seg(f, &env->gdt); + cpu_get_seg(f, &env->idt); + + qemu_get_be32s(f, &env->sysenter_cs); + qemu_get_be32s(f, &env->sysenter_esp); + qemu_get_be32s(f, &env->sysenter_eip); + + qemu_get_betls(f, &env->cr[0]); + qemu_get_betls(f, &env->cr[2]); + qemu_get_betls(f, &env->cr[3]); + qemu_get_betls(f, &env->cr[4]); + + for(i = 0; i < 8; i++) + qemu_get_betls(f, &env->dr[i]); - /* update deltas */ - s->mouse_dx -= dx1; - s->mouse_dy -= dy1; - s->mouse_dz -= dz1; -} + /* MMU */ + qemu_get_be32s(f, &env->a20_mask); -void kbd_mouse_event(int dx, int dy, int dz, int buttons_state) -{ - KBDState *s = &kbd_state; + qemu_get_be32s(f, &env->mxcsr); + for(i = 0; i < CPU_NB_REGS; i++) { + qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0)); + qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1)); + } - /* check if deltas are recorded when disabled */ - if (!(s->mouse_status & MOUSE_STATUS_ENABLED)) - return; +#ifdef TARGET_X86_64 + qemu_get_be64s(f, &env->efer); + qemu_get_be64s(f, &env->star); + qemu_get_be64s(f, &env->lstar); + qemu_get_be64s(f, &env->cstar); + qemu_get_be64s(f, &env->fmask); + qemu_get_be64s(f, &env->kernelgsbase); +#endif - s->mouse_dx += dx; - s->mouse_dy -= dy; - s->mouse_dz += dz; - s->mouse_buttons = buttons_state; - - if (!(s->mouse_status & MOUSE_STATUS_REMOTE) && - (s->queues[1].count < (KBD_QUEUE_SIZE - 16))) { - for(;;) { - /* if not remote, send event. Multiple events are sent if - too big deltas */ - kbd_mouse_send_packet(s); - if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0) - break; - } - } + /* XXX: compute hflags from scratch, except for CPL and IIF */ + env->hflags = hflags; + tlb_flush(env, 1); + return 0; } -static void kbd_write_mouse(KBDState *s, int val) +#elif defined(TARGET_PPC) +void cpu_save(QEMUFile *f, void *opaque) { -#ifdef DEBUG_MOUSE - printf("kbd: write mouse 0x%02x\n", val); -#endif - switch(s->mouse_write_cmd) { - default: - case -1: - /* mouse command */ - if (s->mouse_wrap) { - if (val == AUX_RESET_WRAP) { - s->mouse_wrap = 0; - kbd_queue(s, AUX_ACK, 1); - return; - } else if (val != AUX_RESET) { - kbd_queue(s, val, 1); - return; - } - } - switch(val) { - case AUX_SET_SCALE11: - s->mouse_status &= ~MOUSE_STATUS_SCALE21; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_SET_SCALE21: - s->mouse_status |= MOUSE_STATUS_SCALE21; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_SET_STREAM: - s->mouse_status &= ~MOUSE_STATUS_REMOTE; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_SET_WRAP: - s->mouse_wrap = 1; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_SET_REMOTE: - s->mouse_status |= MOUSE_STATUS_REMOTE; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_GET_TYPE: - kbd_queue(s, AUX_ACK, 1); - kbd_queue(s, s->mouse_type, 1); - break; - case AUX_SET_RES: - case AUX_SET_SAMPLE: - s->mouse_write_cmd = val; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_GET_SCALE: - kbd_queue(s, AUX_ACK, 1); - kbd_queue(s, s->mouse_status, 1); - kbd_queue(s, s->mouse_resolution, 1); - kbd_queue(s, s->mouse_sample_rate, 1); - break; - case AUX_POLL: - kbd_queue(s, AUX_ACK, 1); - kbd_mouse_send_packet(s); - break; - case AUX_ENABLE_DEV: - s->mouse_status |= MOUSE_STATUS_ENABLED; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_DISABLE_DEV: - s->mouse_status &= ~MOUSE_STATUS_ENABLED; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_SET_DEFAULT: - s->mouse_sample_rate = 100; - s->mouse_resolution = 2; - s->mouse_status = 0; - kbd_queue(s, AUX_ACK, 1); - break; - case AUX_RESET: - s->mouse_sample_rate = 100; - s->mouse_resolution = 2; - s->mouse_status = 0; - kbd_queue(s, AUX_ACK, 1); - kbd_queue(s, 0xaa, 1); - kbd_queue(s, s->mouse_type, 1); - break; - default: - break; - } - break; - case AUX_SET_SAMPLE: - s->mouse_sample_rate = val; -#if 0 - /* detect IMPS/2 or IMEX */ - switch(s->mouse_detect_state) { - default: - case 0: - if (val == 200) - s->mouse_detect_state = 1; - break; - case 1: - if (val == 100) - s->mouse_detect_state = 2; - else if (val == 200) - s->mouse_detect_state = 3; - else - s->mouse_detect_state = 0; - break; - case 2: - if (val == 80) - s->mouse_type = 3; /* IMPS/2 */ - s->mouse_detect_state = 0; - break; - case 3: - if (val == 80) - s->mouse_type = 4; /* IMEX */ - s->mouse_detect_state = 0; - break; - } -#endif - kbd_queue(s, AUX_ACK, 1); - s->mouse_write_cmd = -1; - break; - case AUX_SET_RES: - s->mouse_resolution = val; - kbd_queue(s, AUX_ACK, 1); - s->mouse_write_cmd = -1; - break; - } } -void kbd_write_data(CPUState *env, uint32_t addr, uint32_t val) +int cpu_load(QEMUFile *f, void *opaque, int version_id) { - KBDState *s = &kbd_state; + return 0; +} -#ifdef DEBUG_KBD - printf("kbd: write data=0x%02x\n", val); -#endif +#elif defined(TARGET_MIPS) +void cpu_save(QEMUFile *f, void *opaque) +{ +} - switch(s->write_cmd) { - case 0: - kbd_write_keyboard(s, val); - break; - case KBD_CCMD_WRITE_MODE: - s->mode = val; - kbd_update_irq(s); - break; - case KBD_CCMD_WRITE_OBUF: - kbd_queue(s, val, 0); - break; - case KBD_CCMD_WRITE_AUX_OBUF: - kbd_queue(s, val, 1); - break; - case KBD_CCMD_WRITE_OUTPORT: -#ifdef TARGET_I386 - cpu_x86_set_a20(env, (val >> 1) & 1); -#endif - if (!(val & 1)) { - reset_requested = 1; - cpu_interrupt(global_env, CPU_INTERRUPT_EXIT); - } - break; - case KBD_CCMD_WRITE_MOUSE: - kbd_write_mouse(s, val); - break; - default: - break; - } - s->write_cmd = 0; +int cpu_load(QEMUFile *f, void *opaque, int version_id) +{ + return 0; } -void kbd_reset(KBDState *s) +#elif defined(TARGET_SPARC) +void cpu_save(QEMUFile *f, void *opaque) { - KBDQueue *q; + CPUState *env = opaque; int i; + uint32_t tmp; - s->kbd_write_cmd = -1; - s->mouse_write_cmd = -1; - s->mode = KBD_MODE_KBD_INT | KBD_MODE_MOUSE_INT; - s->status = KBD_STAT_CMD | KBD_STAT_UNLOCKED; - for(i = 0; i < 2; i++) { - q = &s->queues[i]; - q->rptr = 0; - q->wptr = 0; - q->count = 0; + for(i = 0; i < 8; i++) + qemu_put_betls(f, &env->gregs[i]); + for(i = 0; i < NWINDOWS * 16; i++) + qemu_put_betls(f, &env->regbase[i]); + + /* FPU */ + for(i = 0; i < TARGET_FPREGS; i++) { + union { + TARGET_FPREG_T f; + target_ulong i; + } u; + u.f = env->fpr[i]; + qemu_put_betl(f, u.i); } + + qemu_put_betls(f, &env->pc); + qemu_put_betls(f, &env->npc); + qemu_put_betls(f, &env->y); + tmp = GET_PSR(env); + qemu_put_be32(f, tmp); + qemu_put_betls(f, &env->fsr); + qemu_put_betls(f, &env->tbr); +#ifndef TARGET_SPARC64 + qemu_put_be32s(f, &env->wim); + /* MMU */ + for(i = 0; i < 16; i++) + qemu_put_be32s(f, &env->mmuregs[i]); +#endif } -void kbd_init(void) +int cpu_load(QEMUFile *f, void *opaque, int version_id) { - kbd_reset(&kbd_state); -#if defined (TARGET_I386) || defined (TARGET_PPC) - register_ioport_read(0x60, 1, kbd_read_data, 1); - register_ioport_write(0x60, 1, kbd_write_data, 1); - register_ioport_read(0x64, 1, kbd_read_status, 1); - register_ioport_write(0x64, 1, kbd_write_command, 1); -#endif + CPUState *env = opaque; + int i; + uint32_t tmp; + + for(i = 0; i < 8; i++) + qemu_get_betls(f, &env->gregs[i]); + for(i = 0; i < NWINDOWS * 16; i++) + qemu_get_betls(f, &env->regbase[i]); + + /* FPU */ + for(i = 0; i < TARGET_FPREGS; i++) { + union { + TARGET_FPREG_T f; + target_ulong i; + } u; + u.i = qemu_get_betl(f); + env->fpr[i] = u.f; + } + + qemu_get_betls(f, &env->pc); + qemu_get_betls(f, &env->npc); + qemu_get_betls(f, &env->y); + tmp = qemu_get_be32(f); + env->cwp = 0; /* needed to ensure that the wrapping registers are + correctly updated */ + PUT_PSR(env, tmp); + qemu_get_betls(f, &env->fsr); + qemu_get_betls(f, &env->tbr); +#ifndef TARGET_SPARC64 + qemu_get_be32s(f, &env->wim); + /* MMU */ + for(i = 0; i < 16; i++) + qemu_get_be32s(f, &env->mmuregs[i]); +#endif + tlb_flush(env, 1); + return 0; } +#else + +#warning No CPU save/restore functions + +#endif /***********************************************************/ -/* Bochs BIOS debug ports */ -#ifdef TARGET_I386 -void bochs_bios_write(CPUX86State *env, uint32_t addr, uint32_t val) +/* ram save/restore */ + +/* we just avoid storing empty pages */ +static void ram_put_page(QEMUFile *f, const uint8_t *buf, int len) { - switch(addr) { - /* Bochs BIOS messages */ - case 0x400: - case 0x401: - fprintf(stderr, "BIOS panic at rombios.c, line %d\n", val); - exit(1); - case 0x402: - case 0x403: -#ifdef DEBUG_BIOS - fprintf(stderr, "%c", val); -#endif - break; + int i, v; - /* LGPL'ed VGA BIOS messages */ - case 0x501: - case 0x502: - fprintf(stderr, "VGA BIOS panic, line %d\n", val); - exit(1); - case 0x500: - case 0x503: -#ifdef DEBUG_BIOS - fprintf(stderr, "%c", val); -#endif + v = buf[0]; + for(i = 1; i < len; i++) { + if (buf[i] != v) + goto normal_save; + } + qemu_put_byte(f, 1); + qemu_put_byte(f, v); + return; + normal_save: + qemu_put_byte(f, 0); + qemu_put_buffer(f, buf, len); +} + +static int ram_get_page(QEMUFile *f, uint8_t *buf, int len) +{ + int v; + + v = qemu_get_byte(f); + switch(v) { + case 0: + if (qemu_get_buffer(f, buf, len) != len) + return -EIO; + break; + case 1: + v = qemu_get_byte(f); + memset(buf, v, len); break; + default: + return -EINVAL; + } + return 0; +} + +static void ram_save(QEMUFile *f, void *opaque) +{ + int i; + qemu_put_be32(f, phys_ram_size); + for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) { + ram_put_page(f, phys_ram_base + i, TARGET_PAGE_SIZE); } } -void bochs_bios_init(void) +static int ram_load(QEMUFile *f, void *opaque, int version_id) { - register_ioport_write(0x400, 1, bochs_bios_write, 2); - register_ioport_write(0x401, 1, bochs_bios_write, 2); - register_ioport_write(0x402, 1, bochs_bios_write, 1); - register_ioport_write(0x403, 1, bochs_bios_write, 1); + int i, ret; - register_ioport_write(0x501, 1, bochs_bios_write, 2); - register_ioport_write(0x502, 1, bochs_bios_write, 2); - register_ioport_write(0x500, 1, bochs_bios_write, 1); - register_ioport_write(0x503, 1, bochs_bios_write, 1); + if (version_id != 1) + return -EINVAL; + if (qemu_get_be32(f) != phys_ram_size) + return -EINVAL; + for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) { + ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE); + if (ret) + return ret; + } + return 0; } -#endif /***********************************************************/ -/* dumb display */ +/* machine registration */ -/* init terminal so that we can grab keys */ -static struct termios oldtty; +QEMUMachine *first_machine = NULL; -static void term_exit(void) +int qemu_register_machine(QEMUMachine *m) { - tcsetattr (0, TCSANOW, &oldtty); + QEMUMachine **pm; + pm = &first_machine; + while (*pm != NULL) + pm = &(*pm)->next; + m->next = NULL; + *pm = m; + return 0; } -static void term_init(void) +QEMUMachine *find_machine(const char *name) { - struct termios tty; - - tcgetattr (0, &tty); - oldtty = tty; - - tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP - |INLCR|IGNCR|ICRNL|IXON); - tty.c_oflag |= OPOST; - tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); - /* if graphical mode, we allow Ctrl-C handling */ - if (nographic) - tty.c_lflag &= ~ISIG; - tty.c_cflag &= ~(CSIZE|PARENB); - tty.c_cflag |= CS8; - tty.c_cc[VMIN] = 1; - tty.c_cc[VTIME] = 0; - - tcsetattr (0, TCSANOW, &tty); + QEMUMachine *m; - atexit(term_exit); - - fcntl(0, F_SETFL, O_NONBLOCK); + for(m = first_machine; m != NULL; m = m->next) { + if (!strcmp(m->name, name)) + return m; + } + return NULL; } -static void dumb_update(DisplayState *ds, int x, int y, int w, int h) +/***********************************************************/ +/* main execution loop */ + +void gui_update(void *opaque) { + display_state.dpy_refresh(&display_state); + qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock)); } -static void dumb_resize(DisplayState *ds, int w, int h) +/* XXX: support several handlers */ +VMStopHandler *vm_stop_cb; +VMStopHandler *vm_stop_opaque; + +int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque) { + vm_stop_cb = cb; + vm_stop_opaque = opaque; + return 0; } -static void dumb_refresh(DisplayState *ds) +void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque) { - vga_update_display(); + vm_stop_cb = NULL; } -void dumb_display_init(DisplayState *ds) +void vm_start(void) { - ds->data = NULL; - ds->linesize = 0; - ds->depth = 0; - ds->dpy_update = dumb_update; - ds->dpy_resize = dumb_resize; - ds->dpy_refresh = dumb_refresh; + if (!vm_running) { + cpu_enable_ticks(); + vm_running = 1; + } } -#if !defined(CONFIG_SOFTMMU) -/***********************************************************/ -/* cpu signal handler */ -static void host_segv_handler(int host_signum, siginfo_t *info, - void *puc) +void vm_stop(int reason) { - if (cpu_signal_handler(host_signum, info, puc)) - return; - term_exit(); - abort(); + if (vm_running) { + cpu_disable_ticks(); + vm_running = 0; + if (reason != 0) { + if (vm_stop_cb) { + vm_stop_cb(vm_stop_opaque, reason); + } + } + } } -#endif -static int timer_irq_pending; -static int timer_irq_count; +/* reset/shutdown handler */ + +typedef struct QEMUResetEntry { + QEMUResetHandler *func; + void *opaque; + struct QEMUResetEntry *next; +} QEMUResetEntry; -static int timer_ms; -static int gui_refresh_pending, gui_refresh_count; +static QEMUResetEntry *first_reset_entry; +static int reset_requested; +static int shutdown_requested; +static int powerdown_requested; -static void host_alarm_handler(int host_signum, siginfo_t *info, - void *puc) +void qemu_register_reset(QEMUResetHandler *func, void *opaque) { - /* NOTE: since usually the OS asks a 100 Hz clock, there can be - some drift between cpu_get_ticks() and the interrupt time. So - we queue some interrupts to avoid missing some */ - timer_irq_count += pit_get_out_edges(&pit_channels[0]); - if (timer_irq_count) { - if (timer_irq_count > 2) - timer_irq_count = 2; - timer_irq_count--; - timer_irq_pending = 1; - } - gui_refresh_count += timer_ms; - if (gui_refresh_count >= GUI_REFRESH_INTERVAL) { - gui_refresh_count = 0; - gui_refresh_pending = 1; - } + QEMUResetEntry **pre, *re; - if (gui_refresh_pending || timer_irq_pending) { - /* just exit from the cpu to have a chance to handle timers */ - cpu_interrupt(global_env, CPU_INTERRUPT_EXIT); + pre = &first_reset_entry; + while (*pre != NULL) + pre = &(*pre)->next; + re = qemu_mallocz(sizeof(QEMUResetEntry)); + re->func = func; + re->opaque = opaque; + re->next = NULL; + *pre = re; +} + +void qemu_system_reset(void) +{ + QEMUResetEntry *re; + + /* reset all devices */ + for(re = first_reset_entry; re != NULL; re = re->next) { + re->func(re->opaque); } } -/* main execution loop */ +void qemu_system_reset_request(void) +{ + reset_requested = 1; + cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT); +} -CPUState *cpu_gdbstub_get_env(void *opaque) +void qemu_system_shutdown_request(void) { - return global_env; + shutdown_requested = 1; + cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT); } -int main_loop(void *opaque) +void qemu_system_powerdown_request(void) { - struct pollfd ufds[3], *pf, *serial_ufd, *gdb_ufd; -#if defined (TARGET_I386) - struct pollfd *net_ufd; -#endif - int ret, n, timeout, serial_ok; - uint8_t ch; - CPUState *env = global_env; + powerdown_requested = 1; + cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT); +} - if (!term_inited) { - /* initialize terminal only there so that the user has a - chance to stop QEMU with Ctrl-C before the gdb connection - is launched */ - term_inited = 1; - term_init(); - } +static void main_cpu_reset(void *opaque) +{ +#if defined(TARGET_I386) || defined(TARGET_SPARC) + CPUState *env = opaque; + cpu_reset(env); +#endif +} - serial_ok = 1; - cpu_enable_ticks(); - for(;;) { -#if defined (DO_TB_FLUSH) - tb_flush(); +void main_loop_wait(int timeout) +{ +#ifndef _WIN32 + struct pollfd ufds[MAX_IO_HANDLERS + 1], *pf; + IOHandlerRecord *ioh, *ioh_next; + uint8_t buf[4096]; + int n, max_size; #endif - ret = cpu_exec(env); - if (reset_requested) { - ret = EXCP_INTERRUPT; - break; - } - if (ret == EXCP_DEBUG) { - ret = EXCP_DEBUG; - break; - } - /* if hlt instruction, we wait until the next IRQ */ - if (ret == EXCP_HLT) - timeout = 10; - else - timeout = 0; + int ret; + +#ifdef _WIN32 + if (timeout > 0) + Sleep(timeout); +#else /* poll any events */ - serial_ufd = NULL; + /* XXX: separate device handlers from system ones */ pf = ufds; - if (serial_ok && !(serial_ports[0].lsr & UART_LSR_DR)) { - serial_ufd = pf; - pf->fd = 0; - pf->events = POLLIN; - pf++; - } -#if defined (TARGET_I386) - net_ufd = NULL; - if (net_fd > 0 && ne2000_can_receive(&ne2000_state)) { - net_ufd = pf; - pf->fd = net_fd; - pf->events = POLLIN; - pf++; - } -#endif - gdb_ufd = NULL; - if (gdbstub_fd > 0) { - gdb_ufd = pf; - pf->fd = gdbstub_fd; - pf->events = POLLIN; - pf++; - } - - ret = poll(ufds, pf - ufds, timeout); - if (ret > 0) { - if (serial_ufd && (serial_ufd->revents & POLLIN)) { - n = read(0, &ch, 1); - if (n == 1) { - serial_received_byte(&serial_ports[0], ch); + for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) { + if (!ioh->fd_can_read) { + max_size = 0; + pf->fd = ioh->fd; + pf->events = POLLIN; + ioh->ufd = pf; + pf++; + } else { + max_size = ioh->fd_can_read(ioh->opaque); + if (max_size > 0) { + if (max_size > sizeof(buf)) + max_size = sizeof(buf); + pf->fd = ioh->fd; + pf->events = POLLIN; + ioh->ufd = pf; + pf++; } else { - /* Closed, stop polling. */ - serial_ok = 0; + ioh->ufd = NULL; } } -#if defined (TARGET_I386) - if (net_ufd && (net_ufd->revents & POLLIN)) { - uint8_t buf[MAX_ETH_FRAME_SIZE]; - - n = read(net_fd, buf, MAX_ETH_FRAME_SIZE); - if (n > 0) { - if (n < 60) { - memset(buf + n, 0, 60 - n); - n = 60; + ioh->max_size = max_size; + } + + ret = poll(ufds, pf - ufds, timeout); + if (ret > 0) { + /* XXX: better handling of removal */ + for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) { + ioh_next = ioh->next; + pf = ioh->ufd; + if (pf) { + if (pf->revents & POLLIN) { + if (ioh->max_size == 0) { + /* just a read event */ + ioh->fd_read(ioh->opaque, NULL, 0); + } else { + n = read(ioh->fd, buf, ioh->max_size); + if (n >= 0) { + ioh->fd_read(ioh->opaque, buf, n); + } else if (errno != EAGAIN) { + ioh->fd_read(ioh->opaque, NULL, -errno); + } + } } - ne2000_receive(&ne2000_state, buf, n); } } -#endif - if (gdb_ufd && (gdb_ufd->revents & POLLIN)) { - uint8_t buf[1]; - /* stop emulation if requested by gdb */ - n = read(gdbstub_fd, buf, 1); - if (n == 1) { - ret = EXCP_INTERRUPT; - break; - } + } +#endif /* !defined(_WIN32) */ +#if defined(CONFIG_SLIRP) + /* XXX: merge with poll() */ + if (slirp_inited) { + fd_set rfds, wfds, xfds; + int nfds; + struct timeval tv; + + nfds = -1; + FD_ZERO(&rfds); + FD_ZERO(&wfds); + FD_ZERO(&xfds); + slirp_select_fill(&nfds, &rfds, &wfds, &xfds); + tv.tv_sec = 0; + tv.tv_usec = 0; + ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv); + if (ret >= 0) { + slirp_select_poll(&rfds, &wfds, &xfds); } } +#endif + + if (vm_running) { + qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL], + qemu_get_clock(vm_clock)); + /* run dma transfers, if any */ + DMA_run(); + } + + /* real time timers */ + qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME], + qemu_get_clock(rt_clock)); +} + +int main_loop(void) +{ + int ret, timeout; + CPUState *env = global_env; - /* timer IRQ */ - if (timer_irq_pending) { -#if defined (TARGET_I386) - pic_set_irq(0, 1); - pic_set_irq(0, 0); - timer_irq_pending = 0; - /* XXX: RTC test */ - if (cmos_data[RTC_REG_B] & 0x50) { - pic_set_irq(8, 1); + for(;;) { + if (vm_running) { + ret = cpu_exec(env); + if (shutdown_requested) { + ret = EXCP_INTERRUPT; + break; + } + if (reset_requested) { + reset_requested = 0; + qemu_system_reset(); + ret = EXCP_INTERRUPT; + } + if (powerdown_requested) { + powerdown_requested = 0; + qemu_system_powerdown(); + ret = EXCP_INTERRUPT; } -#endif - } - /* XXX: add explicit timer */ - SB16_run(); - - /* run dma transfers, if any */ - DMA_run(); - - /* VGA */ - if (gui_refresh_pending) { - display_state.dpy_refresh(&display_state); - gui_refresh_pending = 0; + if (ret == EXCP_DEBUG) { + vm_stop(EXCP_DEBUG); + } + /* if hlt instruction, we wait until the next IRQ */ + /* XXX: use timeout computed from timers */ + if (ret == EXCP_HLT) + timeout = 10; + else + timeout = 0; + } else { + timeout = 10; } + main_loop_wait(timeout); } cpu_disable_ticks(); return ret; @@ -3104,49 +2792,96 @@ int main_loop(void *opaque) void help(void) { - printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003 Fabrice Bellard\n" + printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2004 Fabrice Bellard\n" "usage: %s [options] [disk_image]\n" "\n" "'disk_image' is a raw hard image image for IDE hard disk 0\n" "\n" "Standard options:\n" + "-M machine select emulated machine (-M ? for list)\n" "-fda/-fdb file use 'file' as floppy disk 0/1 image\n" "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n" "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n" - "-cdrom file use 'file' as IDE cdrom 2 image\n" - "-boot [a|b|c|d] boot on floppy (a, b), hard disk (c) or CD-ROM (d)\n" + "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n" + "-boot [a|c|d] boot on floppy (a), hard disk (c) or CD-ROM (d)\n" "-snapshot write to temporary files instead of disk image files\n" - "-m megs set virtual RAM size to megs MB\n" - "-n script set network init script [default=%s]\n" - "-tun-fd fd this fd talks to tap/tun, use it.\n" - "-nographic disable graphical output\n" + "-m megs set virtual RAM size to megs MB [default=%d]\n" + "-nographic disable graphical output and redirect serial I/Os to console\n" +#ifndef _WIN32 + "-k language use keyboard layout (for example \"fr\" for French)\n" +#endif + "-enable-audio enable audio support\n" + "-localtime set the real time clock to local time [default=utc]\n" + "-full-screen start in full screen\n" +#ifdef TARGET_I386 + "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n" +#endif +#if defined(TARGET_PPC) || defined(TARGET_SPARC) + "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n" +#endif + "\n" + "Network options:\n" + "-nics n simulate 'n' network cards [default=1]\n" + "-macaddr addr set the mac address of the first interface\n" + "-n script set tap/tun network init script [default=%s]\n" + "-tun-fd fd use this fd as already opened tap/tun interface\n" +#ifdef CONFIG_SLIRP + "-user-net use user mode network stack [default if no tap/tun script]\n" + "-tftp prefix allow tftp access to files starting with prefix [-user-net]\n" +#ifndef _WIN32 + "-smb dir allow SMB access to files in 'dir' [-user-net]\n" +#endif + "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n" + " redirect TCP or UDP connections from host to guest [-user-net]\n" +#endif + "-dummy-net use dummy network stack\n" "\n" - "Linux boot specific (does not require PC BIOS):\n" + "Linux boot specific:\n" "-kernel bzImage use 'bzImage' as kernel image\n" "-append cmdline use 'cmdline' as kernel command line\n" "-initrd file use 'file' as initial ram disk\n" "\n" "Debug/Expert options:\n" + "-monitor dev redirect the monitor to char device 'dev'\n" + "-serial dev redirect the serial port to char device 'dev'\n" + "-parallel dev redirect the parallel port to char device 'dev'\n" + "-pidfile file Write PID to 'file'\n" + "-S freeze CPU at startup (use 'c' to start execution)\n" "-s wait gdb connection to port %d\n" "-p port change gdb connection port\n" - "-d output log to %s\n" - "-hdachs c,h,s force hard disk 0 geometry (usually qemu can guess it)\n" + "-d item1,... output log to %s (use -d ? for a list of log items)\n" + "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n" + " translation (t=none or lba) (usually qemu can guess them)\n" "-L path set the directory for the BIOS and VGA BIOS\n" +#ifdef USE_KQEMU + "-no-kqemu disable KQEMU kernel module usage\n" +#endif #ifdef USE_CODE_COPY "-no-code-copy disable code copy acceleration\n" #endif - +#ifdef TARGET_I386 + "-isa simulate an ISA-only system (default is PCI system)\n" + "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n" + " (default is CL-GD5446 PCI VGA)\n" +#endif + "-loadvm file start right away with a saved state (loadvm in monitor)\n" "\n" - "During emulation, use C-a h to get terminal commands:\n", + "During emulation, the following keys are useful:\n" + "ctrl-alt-f toggle full screen\n" + "ctrl-alt-n switch to virtual console 'n'\n" + "ctrl-alt toggle mouse and keyboard grab\n" + "\n" + "When using -nographic, press 'ctrl-a h' to get some help.\n" + , #ifdef CONFIG_SOFTMMU "qemu", #else "qemu-fast", #endif - DEFAULT_NETWORK_SCRIPT, + DEFAULT_RAM_SIZE, + DEFAULT_NETWORK_SCRIPT, DEFAULT_GDBSTUB_PORT, "/tmp/qemu.log"); - term_print_help(); #ifndef CONFIG_SOFTMMU printf("\n" "NOTE: this version of QEMU is faster but it needs slightly patched OSes to\n" @@ -3156,37 +2891,138 @@ void help(void) exit(1); } -struct option long_options[] = { - { "initrd", 1, NULL, 0, }, - { "hda", 1, NULL, 0, }, - { "hdb", 1, NULL, 0, }, - { "snapshot", 0, NULL, 0, }, - { "hdachs", 1, NULL, 0, }, - { "nographic", 0, NULL, 0, }, - { "kernel", 1, NULL, 0, }, - { "append", 1, NULL, 0, }, - { "tun-fd", 1, NULL, 0, }, - { "hdc", 1, NULL, 0, }, - { "hdd", 1, NULL, 0, }, - { "cdrom", 1, NULL, 0, }, - { "boot", 1, NULL, 0, }, - { "fda", 1, NULL, 0, }, - { "fdb", 1, NULL, 0, }, - { "no-code-copy", 0, NULL, 0}, - { NULL, 0, NULL, 0 }, +#define HAS_ARG 0x0001 + +enum { + QEMU_OPTION_h, + + QEMU_OPTION_M, + QEMU_OPTION_fda, + QEMU_OPTION_fdb, + QEMU_OPTION_hda, + QEMU_OPTION_hdb, + QEMU_OPTION_hdc, + QEMU_OPTION_hdd, + QEMU_OPTION_cdrom, + QEMU_OPTION_boot, + QEMU_OPTION_snapshot, + QEMU_OPTION_m, + QEMU_OPTION_nographic, + QEMU_OPTION_enable_audio, + + QEMU_OPTION_nics, + QEMU_OPTION_macaddr, + QEMU_OPTION_n, + QEMU_OPTION_tun_fd, + QEMU_OPTION_user_net, + QEMU_OPTION_tftp, + QEMU_OPTION_smb, + QEMU_OPTION_redir, + QEMU_OPTION_dummy_net, + + QEMU_OPTION_kernel, + QEMU_OPTION_append, + QEMU_OPTION_initrd, + + QEMU_OPTION_S, + QEMU_OPTION_s, + QEMU_OPTION_p, + QEMU_OPTION_d, + QEMU_OPTION_hdachs, + QEMU_OPTION_L, + QEMU_OPTION_no_code_copy, + QEMU_OPTION_pci, + QEMU_OPTION_isa, + QEMU_OPTION_prep, + QEMU_OPTION_k, + QEMU_OPTION_localtime, + QEMU_OPTION_cirrusvga, + QEMU_OPTION_g, + QEMU_OPTION_std_vga, + QEMU_OPTION_monitor, + QEMU_OPTION_serial, + QEMU_OPTION_parallel, + QEMU_OPTION_loadvm, + QEMU_OPTION_full_screen, + QEMU_OPTION_pidfile, + QEMU_OPTION_no_kqemu, + QEMU_OPTION_win2k_hack, }; -#ifdef CONFIG_SDL -/* SDL use the pthreads and they modify sigaction. We don't - want that. */ -#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) -extern void __libc_sigaction(); -#define sigaction(sig, act, oact) __libc_sigaction(sig, act, oact) -#else -extern void __sigaction(); -#define sigaction(sig, act, oact) __sigaction(sig, act, oact) -#endif -#endif /* CONFIG_SDL */ +typedef struct QEMUOption { + const char *name; + int flags; + int index; +} QEMUOption; + +const QEMUOption qemu_options[] = { + { "h", 0, QEMU_OPTION_h }, + + { "M", HAS_ARG, QEMU_OPTION_M }, + { "fda", HAS_ARG, QEMU_OPTION_fda }, + { "fdb", HAS_ARG, QEMU_OPTION_fdb }, + { "hda", HAS_ARG, QEMU_OPTION_hda }, + { "hdb", HAS_ARG, QEMU_OPTION_hdb }, + { "hdc", HAS_ARG, QEMU_OPTION_hdc }, + { "hdd", HAS_ARG, QEMU_OPTION_hdd }, + { "cdrom", HAS_ARG, QEMU_OPTION_cdrom }, + { "boot", HAS_ARG, QEMU_OPTION_boot }, + { "snapshot", 0, QEMU_OPTION_snapshot }, + { "m", HAS_ARG, QEMU_OPTION_m }, + { "nographic", 0, QEMU_OPTION_nographic }, + { "k", HAS_ARG, QEMU_OPTION_k }, + { "enable-audio", 0, QEMU_OPTION_enable_audio }, + + { "nics", HAS_ARG, QEMU_OPTION_nics}, + { "macaddr", HAS_ARG, QEMU_OPTION_macaddr}, + { "n", HAS_ARG, QEMU_OPTION_n }, + { "tun-fd", HAS_ARG, QEMU_OPTION_tun_fd }, +#ifdef CONFIG_SLIRP + { "user-net", 0, QEMU_OPTION_user_net }, + { "tftp", HAS_ARG, QEMU_OPTION_tftp }, +#ifndef _WIN32 + { "smb", HAS_ARG, QEMU_OPTION_smb }, +#endif + { "redir", HAS_ARG, QEMU_OPTION_redir }, +#endif + { "dummy-net", 0, QEMU_OPTION_dummy_net }, + + { "kernel", HAS_ARG, QEMU_OPTION_kernel }, + { "append", HAS_ARG, QEMU_OPTION_append }, + { "initrd", HAS_ARG, QEMU_OPTION_initrd }, + + { "S", 0, QEMU_OPTION_S }, + { "s", 0, QEMU_OPTION_s }, + { "p", HAS_ARG, QEMU_OPTION_p }, + { "d", HAS_ARG, QEMU_OPTION_d }, + { "hdachs", HAS_ARG, QEMU_OPTION_hdachs }, + { "L", HAS_ARG, QEMU_OPTION_L }, + { "no-code-copy", 0, QEMU_OPTION_no_code_copy }, +#ifdef USE_KQEMU + { "no-kqemu", 0, QEMU_OPTION_no_kqemu }, +#endif +#ifdef TARGET_PPC + { "prep", 0, QEMU_OPTION_prep }, +#endif +#if defined(TARGET_PPC) || defined(TARGET_SPARC) + { "g", 1, QEMU_OPTION_g }, +#endif + { "localtime", 0, QEMU_OPTION_localtime }, + { "isa", 0, QEMU_OPTION_isa }, + { "std-vga", 0, QEMU_OPTION_std_vga }, + { "monitor", 1, QEMU_OPTION_monitor }, + { "serial", 1, QEMU_OPTION_serial }, + { "parallel", 1, QEMU_OPTION_parallel }, + { "loadvm", HAS_ARG, QEMU_OPTION_loadvm }, + { "full-screen", 0, QEMU_OPTION_full_screen }, + { "pidfile", HAS_ARG, QEMU_OPTION_pidfile }, + { "win2k-hack", 0, QEMU_OPTION_win2k_hack }, + + /* temporary options */ + { "pci", 0, QEMU_OPTION_pci }, + { "cirrusvga", 0, QEMU_OPTION_cirrusvga }, + { NULL }, +}; #if defined (TARGET_I386) && defined(USE_CODE_COPY) @@ -3197,159 +3033,500 @@ static uint8_t *signal_stack; #endif +/* password input */ + +static BlockDriverState *get_bdrv(int index) +{ + BlockDriverState *bs; + + if (index < 4) { + bs = bs_table[index]; + } else if (index < 6) { + bs = fd_table[index - 4]; + } else { + bs = NULL; + } + return bs; +} + +static void read_passwords(void) +{ + BlockDriverState *bs; + int i, j; + char password[256]; + + for(i = 0; i < 6; i++) { + bs = get_bdrv(i); + if (bs && bdrv_is_encrypted(bs)) { + term_printf("%s is encrypted.\n", bdrv_get_device_name(bs)); + for(j = 0; j < 3; j++) { + monitor_readline("Password: ", + 1, password, sizeof(password)); + if (bdrv_set_key(bs, password) == 0) + break; + term_printf("invalid password\n"); + } + } + } +} + +/* XXX: currently we cannot use simultaneously different CPUs */ +void register_machines(void) +{ +#if defined(TARGET_I386) + qemu_register_machine(&pc_machine); +#elif defined(TARGET_PPC) + qemu_register_machine(&heathrow_machine); + qemu_register_machine(&core99_machine); + qemu_register_machine(&prep_machine); +#elif defined(TARGET_MIPS) + qemu_register_machine(&mips_machine); +#elif defined(TARGET_SPARC) +#ifdef TARGET_SPARC64 + qemu_register_machine(&sun4u_machine); +#else + qemu_register_machine(&sun4m_machine); +#endif +#endif +} + +#define NET_IF_TUN 0 +#define NET_IF_USER 1 +#define NET_IF_DUMMY 2 + int main(int argc, char **argv) { - int c, ret, initrd_size, i, use_gdbstub, gdbstub_port, long_index; +#ifdef CONFIG_GDBSTUB + int use_gdbstub, gdbstub_port; +#endif + int i, cdrom_index; int snapshot, linux_boot; - struct sigaction act; - struct itimerval itv; CPUState *env; const char *initrd_filename; const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD]; const char *kernel_filename, *kernel_cmdline; - char buf[1024]; DisplayState *ds = &display_state; + int cyls, heads, secs, translation; + int start_emulation = 1; + uint8_t macaddr[6]; + int net_if_type, nb_tun_fds, tun_fds[MAX_NICS]; + int optind; + const char *r, *optarg; + CharDriverState *monitor_hd; + char monitor_device[128]; + char serial_devices[MAX_SERIAL_PORTS][128]; + int serial_device_index; + char parallel_devices[MAX_PARALLEL_PORTS][128]; + int parallel_device_index; + const char *loadvm = NULL; + QEMUMachine *machine; +#if !defined(CONFIG_SOFTMMU) /* we never want that malloc() uses mmap() */ mallopt(M_MMAP_THRESHOLD, 4096 * 1024); +#endif + register_machines(); + machine = first_machine; initrd_filename = NULL; for(i = 0; i < MAX_FD; i++) fd_filename[i] = NULL; for(i = 0; i < MAX_DISKS; i++) hd_filename[i] = NULL; - ram_size = 32 * 1024 * 1024; + ram_size = DEFAULT_RAM_SIZE * 1024 * 1024; vga_ram_size = VGA_RAM_SIZE; -#if defined (TARGET_I386) + bios_size = BIOS_SIZE; pstrcpy(network_script, sizeof(network_script), DEFAULT_NETWORK_SCRIPT); -#endif +#ifdef CONFIG_GDBSTUB use_gdbstub = 0; gdbstub_port = DEFAULT_GDBSTUB_PORT; +#endif snapshot = 0; nographic = 0; kernel_filename = NULL; kernel_cmdline = ""; +#ifdef TARGET_PPC + cdrom_index = 1; +#else + cdrom_index = 2; +#endif + cyls = heads = secs = 0; + translation = BIOS_ATA_TRANSLATION_AUTO; + pstrcpy(monitor_device, sizeof(monitor_device), "vc"); + + pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc"); + for(i = 1; i < MAX_SERIAL_PORTS; i++) + serial_devices[i][0] = '\0'; + serial_device_index = 0; + + pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc"); + for(i = 1; i < MAX_PARALLEL_PORTS; i++) + parallel_devices[i][0] = '\0'; + parallel_device_index = 0; + + nb_tun_fds = 0; + net_if_type = -1; + nb_nics = 1; + /* default mac address of the first network interface */ + macaddr[0] = 0x52; + macaddr[1] = 0x54; + macaddr[2] = 0x00; + macaddr[3] = 0x12; + macaddr[4] = 0x34; + macaddr[5] = 0x56; + + optind = 1; for(;;) { - c = getopt_long_only(argc, argv, "hm:dn:sp:L:", long_options, &long_index); - if (c == -1) + if (optind >= argc) break; - switch(c) { - case 0: - switch(long_index) { - case 0: - initrd_filename = optarg; + r = argv[optind]; + if (r[0] != '-') { + hd_filename[0] = argv[optind++]; + } else { + const QEMUOption *popt; + + optind++; + popt = qemu_options; + for(;;) { + if (!popt->name) { + fprintf(stderr, "%s: invalid option -- '%s'\n", + argv[0], r); + exit(1); + } + if (!strcmp(popt->name, r + 1)) + break; + popt++; + } + if (popt->flags & HAS_ARG) { + if (optind >= argc) { + fprintf(stderr, "%s: option '%s' requires an argument\n", + argv[0], r); + exit(1); + } + optarg = argv[optind++]; + } else { + optarg = NULL; + } + + switch(popt->index) { + case QEMU_OPTION_M: + machine = find_machine(optarg); + if (!machine) { + QEMUMachine *m; + printf("Supported machines are:\n"); + for(m = first_machine; m != NULL; m = m->next) { + printf("%-10s %s%s\n", + m->name, m->desc, + m == first_machine ? " (default)" : ""); + } + exit(1); + } break; - case 1: - hd_filename[0] = optarg; + case QEMU_OPTION_initrd: + initrd_filename = optarg; break; - case 2: - hd_filename[1] = optarg; + case QEMU_OPTION_hda: + case QEMU_OPTION_hdb: + case QEMU_OPTION_hdc: + case QEMU_OPTION_hdd: + { + int hd_index; + hd_index = popt->index - QEMU_OPTION_hda; + hd_filename[hd_index] = optarg; + if (hd_index == cdrom_index) + cdrom_index = -1; + } break; - case 3: + case QEMU_OPTION_snapshot: snapshot = 1; break; - case 4: + case QEMU_OPTION_hdachs: { - int cyls, heads, secs; const char *p; p = optarg; cyls = strtol(p, (char **)&p, 0); + if (cyls < 1 || cyls > 16383) + goto chs_fail; if (*p != ',') goto chs_fail; p++; heads = strtol(p, (char **)&p, 0); + if (heads < 1 || heads > 16) + goto chs_fail; if (*p != ',') goto chs_fail; p++; secs = strtol(p, (char **)&p, 0); - if (*p != '\0') + if (secs < 1 || secs > 63) goto chs_fail; - ide_set_geometry(0, cyls, heads, secs); - chs_fail: ; + if (*p == ',') { + p++; + if (!strcmp(p, "none")) + translation = BIOS_ATA_TRANSLATION_NONE; + else if (!strcmp(p, "lba")) + translation = BIOS_ATA_TRANSLATION_LBA; + else if (!strcmp(p, "auto")) + translation = BIOS_ATA_TRANSLATION_AUTO; + else + goto chs_fail; + } else if (*p != '\0') { + chs_fail: + fprintf(stderr, "qemu: invalid physical CHS format\n"); + exit(1); + } } break; - case 5: + case QEMU_OPTION_nographic: + pstrcpy(monitor_device, sizeof(monitor_device), "stdio"); + pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio"); nographic = 1; break; - case 6: + case QEMU_OPTION_kernel: kernel_filename = optarg; break; - case 7: + case QEMU_OPTION_append: kernel_cmdline = optarg; break; -#if defined (TARGET_I386) - case 8: - net_fd = atoi(optarg); + case QEMU_OPTION_tun_fd: + { + const char *p; + int fd; + net_if_type = NET_IF_TUN; + if (nb_tun_fds < MAX_NICS) { + fd = strtol(optarg, (char **)&p, 0); + if (*p != '\0') { + fprintf(stderr, "qemu: invalid fd for network interface %d\n", nb_tun_fds); + exit(1); + } + tun_fds[nb_tun_fds++] = fd; + } + } break; -#endif - case 9: - hd_filename[2] = optarg; - break; - case 10: - hd_filename[3] = optarg; - break; - case 11: - hd_filename[2] = optarg; - ide_set_cdrom(2, 1); + case QEMU_OPTION_cdrom: + if (cdrom_index >= 0) { + hd_filename[cdrom_index] = optarg; + } break; - case 12: + case QEMU_OPTION_boot: boot_device = optarg[0]; - if (boot_device != 'a' && boot_device != 'b' && + if (boot_device != 'a' && +#ifdef TARGET_SPARC + // Network boot + boot_device != 'n' && +#endif boot_device != 'c' && boot_device != 'd') { fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device); exit(1); } break; - case 13: + case QEMU_OPTION_fda: fd_filename[0] = optarg; break; - case 14: + case QEMU_OPTION_fdb: fd_filename[1] = optarg; break; - case 15: + case QEMU_OPTION_no_code_copy: code_copy_enabled = 0; break; - } - break; - case 'h': - help(); - break; - case 'm': - ram_size = atoi(optarg) * 1024 * 1024; - if (ram_size <= 0) + case QEMU_OPTION_nics: + nb_nics = atoi(optarg); + if (nb_nics < 0 || nb_nics > MAX_NICS) { + fprintf(stderr, "qemu: invalid number of network interfaces\n"); + exit(1); + } + break; + case QEMU_OPTION_macaddr: + { + const char *p; + int i; + p = optarg; + for(i = 0; i < 6; i++) { + macaddr[i] = strtol(p, (char **)&p, 16); + if (i == 5) { + if (*p != '\0') + goto macaddr_error; + } else { + if (*p != ':') { + macaddr_error: + fprintf(stderr, "qemu: invalid syntax for ethernet address\n"); + exit(1); + } + p++; + } + } + } + break; +#ifdef CONFIG_SLIRP + case QEMU_OPTION_tftp: + tftp_prefix = optarg; + break; +#ifndef _WIN32 + case QEMU_OPTION_smb: + net_slirp_smb(optarg); + break; +#endif + case QEMU_OPTION_user_net: + net_if_type = NET_IF_USER; + break; + case QEMU_OPTION_redir: + net_slirp_redir(optarg); + break; +#endif + case QEMU_OPTION_dummy_net: + net_if_type = NET_IF_DUMMY; + break; + case QEMU_OPTION_enable_audio: + audio_enabled = 1; + break; + case QEMU_OPTION_h: help(); - if (ram_size > PHYS_RAM_MAX_SIZE) { - fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n", - PHYS_RAM_MAX_SIZE / (1024 * 1024)); - exit(1); - } - break; - case 'd': - cpu_set_log(CPU_LOG_ALL); - break; -#if defined (TARGET_I386) - case 'n': - pstrcpy(network_script, sizeof(network_script), optarg); - break; + break; + case QEMU_OPTION_m: + ram_size = atoi(optarg) * 1024 * 1024; + if (ram_size <= 0) + help(); + if (ram_size > PHYS_RAM_MAX_SIZE) { + fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n", + PHYS_RAM_MAX_SIZE / (1024 * 1024)); + exit(1); + } + break; + case QEMU_OPTION_d: + { + int mask; + CPULogItem *item; + + mask = cpu_str_to_log_mask(optarg); + if (!mask) { + printf("Log items (comma separated):\n"); + for(item = cpu_log_items; item->mask != 0; item++) { + printf("%-10s %s\n", item->name, item->help); + } + exit(1); + } + cpu_set_log(mask); + } + break; + case QEMU_OPTION_n: + pstrcpy(network_script, sizeof(network_script), optarg); + break; +#ifdef CONFIG_GDBSTUB + case QEMU_OPTION_s: + use_gdbstub = 1; + break; + case QEMU_OPTION_p: + gdbstub_port = atoi(optarg); + break; #endif - case 's': - use_gdbstub = 1; - break; - case 'p': - gdbstub_port = atoi(optarg); - break; - case 'L': - bios_dir = optarg; - break; + case QEMU_OPTION_L: + bios_dir = optarg; + break; + case QEMU_OPTION_S: + start_emulation = 0; + break; + case QEMU_OPTION_pci: + pci_enabled = 1; + break; + case QEMU_OPTION_isa: + pci_enabled = 0; + break; + case QEMU_OPTION_prep: + prep_enabled = 1; + break; + case QEMU_OPTION_k: + keyboard_layout = optarg; + break; + case QEMU_OPTION_localtime: + rtc_utc = 0; + break; + case QEMU_OPTION_cirrusvga: + cirrus_vga_enabled = 1; + break; + case QEMU_OPTION_std_vga: + cirrus_vga_enabled = 0; + break; + case QEMU_OPTION_g: + { + const char *p; + int w, h, depth; + p = optarg; + w = strtol(p, (char **)&p, 10); + if (w <= 0) { + graphic_error: + fprintf(stderr, "qemu: invalid resolution or depth\n"); + exit(1); + } + if (*p != 'x') + goto graphic_error; + p++; + h = strtol(p, (char **)&p, 10); + if (h <= 0) + goto graphic_error; + if (*p == 'x') { + p++; + depth = strtol(p, (char **)&p, 10); + if (depth != 8 && depth != 15 && depth != 16 && + depth != 24 && depth != 32) + goto graphic_error; + } else if (*p == '\0') { + depth = graphic_depth; + } else { + goto graphic_error; + } + + graphic_width = w; + graphic_height = h; + graphic_depth = depth; + } + break; + case QEMU_OPTION_monitor: + pstrcpy(monitor_device, sizeof(monitor_device), optarg); + break; + case QEMU_OPTION_serial: + if (serial_device_index >= MAX_SERIAL_PORTS) { + fprintf(stderr, "qemu: too many serial ports\n"); + exit(1); + } + pstrcpy(serial_devices[serial_device_index], + sizeof(serial_devices[0]), optarg); + serial_device_index++; + break; + case QEMU_OPTION_parallel: + if (parallel_device_index >= MAX_PARALLEL_PORTS) { + fprintf(stderr, "qemu: too many parallel ports\n"); + exit(1); + } + pstrcpy(parallel_devices[parallel_device_index], + sizeof(parallel_devices[0]), optarg); + parallel_device_index++; + break; + case QEMU_OPTION_loadvm: + loadvm = optarg; + break; + case QEMU_OPTION_full_screen: + full_screen = 1; + break; + case QEMU_OPTION_pidfile: + create_pidfile(optarg); + break; +#ifdef TARGET_I386 + case QEMU_OPTION_win2k_hack: + win2k_install_hack = 1; + break; +#endif +#ifdef USE_KQEMU + case QEMU_OPTION_no_kqemu: + kqemu_allowed = 0; + break; +#endif + } } } - if (optind < argc) { - hd_filename[0] = argv[optind++]; - } - linux_boot = (kernel_filename != NULL); - if (!linux_boot && hd_filename[0] == '\0' && hd_filename[2] == '\0' && + if (!linux_boot && + hd_filename[0] == '\0' && + (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') && fd_filename[0] == '\0') help(); @@ -3371,17 +3548,54 @@ int main(int argc, char **argv) setvbuf(stdout, NULL, _IOLBF, 0); #endif - /* init network tun interface */ -#if defined (TARGET_I386) - if (net_fd < 0) - net_init(); + /* init host network redirectors */ + if (net_if_type == -1) { + net_if_type = NET_IF_TUN; +#if defined(CONFIG_SLIRP) + if (access(network_script, R_OK) < 0) { + net_if_type = NET_IF_USER; + } +#endif + } + + for(i = 0; i < nb_nics; i++) { + NetDriverState *nd = &nd_table[i]; + nd->index = i; + /* init virtual mac address */ + nd->macaddr[0] = macaddr[0]; + nd->macaddr[1] = macaddr[1]; + nd->macaddr[2] = macaddr[2]; + nd->macaddr[3] = macaddr[3]; + nd->macaddr[4] = macaddr[4]; + nd->macaddr[5] = macaddr[5] + i; + switch(net_if_type) { +#if defined(CONFIG_SLIRP) + case NET_IF_USER: + net_slirp_init(nd); + break; +#endif +#if !defined(_WIN32) + case NET_IF_TUN: + if (i < nb_tun_fds) { + net_fd_init(nd, tun_fds[i]); + } else { + if (net_tun_init(nd) < 0) + net_dummy_init(nd); + } + break; #endif + case NET_IF_DUMMY: + default: + net_dummy_init(nd); + break; + } + } /* init the memory */ - phys_ram_size = ram_size + vga_ram_size; + phys_ram_size = ram_size + vga_ram_size + bios_size; #ifdef CONFIG_SOFTMMU - phys_ram_base = memalign(TARGET_PAGE_SIZE, phys_ram_size); + phys_ram_base = qemu_vmalloc(phys_ram_size); if (!phys_ram_base) { fprintf(stderr, "Could not allocate physical memory\n"); exit(1); @@ -3420,15 +3634,52 @@ int main(int argc, char **argv) } #endif + /* we always create the cdrom drive, even if no disk is there */ + bdrv_init(); + if (cdrom_index >= 0) { + bs_table[cdrom_index] = bdrv_new("cdrom"); + bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM); + } + /* open the virtual block devices */ for(i = 0; i < MAX_DISKS; i++) { if (hd_filename[i]) { - bs_table[i] = bdrv_open(hd_filename[i], snapshot); if (!bs_table[i]) { - fprintf(stderr, "qemu: could not open hard disk image '%s\n", + char buf[64]; + snprintf(buf, sizeof(buf), "hd%c", i + 'a'); + bs_table[i] = bdrv_new(buf); + } + if (bdrv_open(bs_table[i], hd_filename[i], snapshot) < 0) { + fprintf(stderr, "qemu: could not open hard disk image '%s'\n", hd_filename[i]); exit(1); } + if (i == 0 && cyls != 0) { + bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs); + bdrv_set_translation_hint(bs_table[i], translation); + } + } + } + + /* we always create at least one floppy disk */ + fd_table[0] = bdrv_new("fda"); + bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY); + + for(i = 0; i < MAX_FD; i++) { + if (fd_filename[i]) { + if (!fd_table[i]) { + char buf[64]; + snprintf(buf, sizeof(buf), "fd%c", i + 'a'); + fd_table[i] = bdrv_new(buf); + bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY); + } + if (fd_filename[i] != '\0') { + if (bdrv_open(fd_table[i], fd_filename[i], snapshot) < 0) { + fprintf(stderr, "qemu: could not open floppy disk image '%s'\n", + fd_filename[i]); + exit(1); + } + } } } @@ -3437,137 +3688,69 @@ int main(int argc, char **argv) global_env = env; cpu_single_env = env; - init_ioports(); + register_savevm("timer", 0, 1, timer_save, timer_load, env); + register_savevm("cpu", 0, 3, cpu_save, cpu_load, env); + register_savevm("ram", 0, 1, ram_save, ram_load, NULL); + qemu_register_reset(main_cpu_reset, global_env); - /* allocate RAM */ - cpu_register_physical_memory(0, ram_size, 0); + init_ioports(); + cpu_calibrate_ticks(); -#if defined(TARGET_I386) - /* RAW PC boot */ + /* terminal init */ + if (nographic) { + dumb_display_init(ds); + } else { +#if defined(CONFIG_SDL) + sdl_display_init(ds, full_screen); +#elif defined(CONFIG_COCOA) + cocoa_display_init(ds, full_screen); +#else + dumb_display_init(ds); +#endif + } - /* BIOS load */ - snprintf(buf, sizeof(buf), "%s/%s", bios_dir, BIOS_FILENAME); - ret = load_image(buf, phys_ram_base + 0x000f0000); - if (ret != 0x10000) { - fprintf(stderr, "qemu: could not load PC bios '%s'\n", buf); + vga_console = graphic_console_init(ds); + + monitor_hd = qemu_chr_open(monitor_device); + if (!monitor_hd) { + fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device); exit(1); } - - /* VGA BIOS load */ - snprintf(buf, sizeof(buf), "%s/%s", bios_dir, VGABIOS_FILENAME); - ret = load_image(buf, phys_ram_base + 0x000c0000); - - /* setup basic memory access */ - cpu_register_physical_memory(0xc0000, 0x10000, 0xc0000 | IO_MEM_ROM); - cpu_register_physical_memory(0xf0000, 0x10000, 0xf0000 | IO_MEM_ROM); - - bochs_bios_init(); - - if (linux_boot) { - uint8_t bootsect[512]; - - if (bs_table[0] == NULL) { - fprintf(stderr, "A disk image must be given for 'hda' when booting a Linux kernel\n"); - exit(1); - } - snprintf(buf, sizeof(buf), "%s/%s", bios_dir, LINUX_BOOT_FILENAME); - ret = load_image(buf, bootsect); - if (ret != sizeof(bootsect)) { - fprintf(stderr, "qemu: could not load linux boot sector '%s'\n", - buf); - exit(1); - } + monitor_init(monitor_hd, !nographic); - bdrv_set_boot_sector(bs_table[0], bootsect, sizeof(bootsect)); - - /* now we can load the kernel */ - ret = load_kernel(kernel_filename, - phys_ram_base + KERNEL_LOAD_ADDR, - phys_ram_base + KERNEL_PARAMS_ADDR); - if (ret < 0) { - fprintf(stderr, "qemu: could not load kernel '%s'\n", - kernel_filename); - exit(1); - } - - /* load initrd */ - initrd_size = 0; - if (initrd_filename) { - initrd_size = load_image(initrd_filename, phys_ram_base + INITRD_LOAD_ADDR); - if (initrd_size < 0) { - fprintf(stderr, "qemu: could not load initial ram disk '%s'\n", - initrd_filename); + for(i = 0; i < MAX_SERIAL_PORTS; i++) { + if (serial_devices[i][0] != '\0') { + serial_hds[i] = qemu_chr_open(serial_devices[i]); + if (!serial_hds[i]) { + fprintf(stderr, "qemu: could not open serial device '%s'\n", + serial_devices[i]); exit(1); } + if (!strcmp(serial_devices[i], "vc")) + qemu_chr_printf(serial_hds[i], "serial%d console\n", i); } - if (initrd_size > 0) { - stl_raw(phys_ram_base + KERNEL_PARAMS_ADDR + 0x218, INITRD_LOAD_ADDR); - stl_raw(phys_ram_base + KERNEL_PARAMS_ADDR + 0x21c, initrd_size); - } - pstrcpy(phys_ram_base + KERNEL_CMDLINE_ADDR, 4096, - kernel_cmdline); - stw_raw(phys_ram_base + KERNEL_PARAMS_ADDR + 0x20, 0xA33F); - stw_raw(phys_ram_base + KERNEL_PARAMS_ADDR + 0x22, - KERNEL_CMDLINE_ADDR - KERNEL_PARAMS_ADDR); - /* loader type */ - stw_raw(phys_ram_base + KERNEL_PARAMS_ADDR + 0x210, 0x01); - } -#elif defined(TARGET_PPC) - /* allocate ROM */ - // snprintf(buf, sizeof(buf), "%s/%s", bios_dir, BIOS_FILENAME); - snprintf(buf, sizeof(buf), "%s", BIOS_FILENAME); - printf("load BIOS at %p\n", phys_ram_base + 0x000f0000); - ret = load_image(buf, phys_ram_base + 0x000f0000); - if (ret != 0x10000) { - fprintf(stderr, "qemu: could not load PPC bios '%s' (%d)\n%m\n", - buf, ret); - exit(1); } -#endif - /* terminal init */ - if (nographic) { - dumb_display_init(ds); - } else { -#ifdef CONFIG_SDL - sdl_display_init(ds); -#else - dumb_display_init(ds); -#endif + for(i = 0; i < MAX_PARALLEL_PORTS; i++) { + if (parallel_devices[i][0] != '\0') { + parallel_hds[i] = qemu_chr_open(parallel_devices[i]); + if (!parallel_hds[i]) { + fprintf(stderr, "qemu: could not open parallel device '%s'\n", + parallel_devices[i]); + exit(1); + } + if (!strcmp(parallel_devices[i], "vc")) + qemu_chr_printf(parallel_hds[i], "parallel%d console\n", i); + } } - /* init basic PC hardware */ - register_ioport_write(0x80, 1, ioport80_write, 1); - - vga_initialize(ds, phys_ram_base + ram_size, ram_size, - vga_ram_size); -#if defined (TARGET_I386) - cmos_init(); -#endif - pic_init(); - pit_init(); - serial_init(); -#if defined (TARGET_I386) - ne2000_init(); -#endif - ide_init(); - kbd_init(); - AUD_init(); - DMA_init(); -#if defined (TARGET_I386) - SB16_init(); -#endif -#if defined (TARGET_PPC) - PPC_end_init(); -#endif - fdctrl_register((unsigned char **)fd_filename, snapshot, boot_device); /* setup cpu signal handlers for MMU / self modifying code handling */ #if !defined(CONFIG_SOFTMMU) - + #if defined (TARGET_I386) && defined(USE_CODE_COPY) { stack_t stk; - signal_stack = malloc(SIGNAL_STACK_SIZE); + signal_stack = memalign(16, SIGNAL_STACK_SIZE); stk.ss_sp = signal_stack; stk.ss_size = SIGNAL_STACK_SIZE; stk.ss_flags = 0; @@ -3578,45 +3761,63 @@ int main(int argc, char **argv) } } #endif + { + struct sigaction act; - sigfillset(&act.sa_mask); - act.sa_flags = SA_SIGINFO; + sigfillset(&act.sa_mask); + act.sa_flags = SA_SIGINFO; #if defined (TARGET_I386) && defined(USE_CODE_COPY) - act.sa_flags |= SA_ONSTACK; + act.sa_flags |= SA_ONSTACK; #endif - act.sa_sigaction = host_segv_handler; - sigaction(SIGSEGV, &act, NULL); - sigaction(SIGBUS, &act, NULL); + act.sa_sigaction = host_segv_handler; + sigaction(SIGSEGV, &act, NULL); + sigaction(SIGBUS, &act, NULL); #if defined (TARGET_I386) && defined(USE_CODE_COPY) - sigaction(SIGFPE, &act, NULL); + sigaction(SIGFPE, &act, NULL); #endif + } #endif - /* timer signal */ - sigfillset(&act.sa_mask); - act.sa_flags = SA_SIGINFO; -#if defined (TARGET_I386) && defined(USE_CODE_COPY) - act.sa_flags |= SA_ONSTACK; -#endif - act.sa_sigaction = host_alarm_handler; - sigaction(SIGALRM, &act, NULL); - - itv.it_interval.tv_sec = 0; - itv.it_interval.tv_usec = 1000; - itv.it_value.tv_sec = 0; - itv.it_value.tv_usec = 10 * 1000; - setitimer(ITIMER_REAL, &itv, NULL); - /* we probe the tick duration of the kernel to inform the user if - the emulated kernel requested a too high timer frequency */ - getitimer(ITIMER_REAL, &itv); - timer_ms = itv.it_interval.tv_usec / 1000; - pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec * PIT_FREQ) / - 1000000; +#ifndef _WIN32 + { + struct sigaction act; + sigfillset(&act.sa_mask); + act.sa_flags = 0; + act.sa_handler = SIG_IGN; + sigaction(SIGPIPE, &act, NULL); + } +#endif + init_timers(); + + machine->init(ram_size, vga_ram_size, boot_device, + ds, fd_filename, snapshot, + kernel_filename, kernel_cmdline, initrd_filename); + + gui_timer = qemu_new_timer(rt_clock, gui_update, NULL); + qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock)); +#ifdef CONFIG_GDBSTUB if (use_gdbstub) { - cpu_gdbstub(NULL, main_loop, gdbstub_port); - } else { - main_loop(NULL); + if (gdbserver_start(gdbstub_port) < 0) { + fprintf(stderr, "Could not open gdbserver socket on port %d\n", + gdbstub_port); + exit(1); + } else { + printf("Waiting gdb connection on port %d\n", gdbstub_port); + } + } else +#endif + if (loadvm) + qemu_loadvm(loadvm); + + { + /* XXX: simplify init */ + read_passwords(); + if (start_emulation) { + vm_start(); + } } + main_loop(); + quit_timers(); return 0; }