X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=vl.c;h=3828bfd7aeb370bcda5627aabf174228a8d6933d;hb=221f715d90ec5fec569a19119887445c037bca86;hp=00adb79978c7c0a595771d10350823c41a9b0acf;hpb=4dc822d726376fd4369089f04eb8605d2f94b74f;p=qemu diff --git a/vl.c b/vl.c index 00adb79..3828bfd 100644 --- a/vl.c +++ b/vl.c @@ -21,27 +21,6 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -#include "hw/hw.h" -#include "hw/boards.h" -#include "hw/usb.h" -#include "hw/pcmcia.h" -#include "hw/pc.h" -#include "hw/audiodev.h" -#include "hw/isa.h" -#include "hw/baum.h" -#include "hw/bt.h" -#include "net.h" -#include "console.h" -#include "sysemu.h" -#include "gdbstub.h" -#include "qemu-timer.h" -#include "qemu-char.h" -#include "block.h" -#include "audio/audio.h" -#include "migration.h" -#include "kvm.h" -#include "balloon.h" - #include #include #include @@ -50,7 +29,11 @@ #include #include +/* Needed early for HOST_BSD etc. */ +#include "config-host.h" + #ifndef _WIN32 +#include #include #include #include @@ -70,9 +53,9 @@ #include #include #include -#ifdef _BSD +#ifdef HOST_BSD #include -#ifdef __FreeBSD__ +#if defined(__FreeBSD__) || defined(__DragonFly__) #include #else #include @@ -111,12 +94,6 @@ #endif #endif -#include "qemu_socket.h" - -#if defined(CONFIG_SLIRP) -#include "libslirp.h" -#endif - #if defined(__OpenBSD__) #include #endif @@ -126,6 +103,7 @@ #endif #ifdef _WIN32 +#include #include #include #include @@ -136,6 +114,13 @@ #ifdef CONFIG_SDL #ifdef __APPLE__ #include +int qemu_main(int argc, char **argv, char **envp); +int main(int argc, char **argv) +{ + qemu_main(argc, argv, NULL); +} +#undef main +#define main qemu_main #endif #endif /* CONFIG_SDL */ @@ -144,16 +129,39 @@ #define main qemu_main #endif /* CONFIG_COCOA */ +#include "hw/hw.h" +#include "hw/boards.h" +#include "hw/usb.h" +#include "hw/pcmcia.h" +#include "hw/pc.h" +#include "hw/audiodev.h" +#include "hw/isa.h" +#include "hw/baum.h" +#include "hw/bt.h" +#include "bt-host.h" +#include "net.h" +#include "monitor.h" +#include "console.h" +#include "sysemu.h" +#include "gdbstub.h" +#include "qemu-timer.h" +#include "qemu-char.h" +#include "cache-utils.h" +#include "block.h" +#include "dma.h" +#include "audio/audio.h" +#include "migration.h" +#include "kvm.h" +#include "balloon.h" + #include "disas.h" #include "exec-all.h" -#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup" -#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown" -#ifdef __sun__ -#define SMBD_COMMAND "/usr/sfw/sbin/smbd" -#else -#define SMBD_COMMAND "/usr/sbin/smbd" +#include "qemu_socket.h" + +#if defined(CONFIG_SLIRP) +#include "libslirp.h" #endif //#define DEBUG_UNUSED_IOPORT @@ -161,12 +169,15 @@ //#define DEBUG_NET //#define DEBUG_SLIRP -#ifdef TARGET_PPC -#define DEFAULT_RAM_SIZE 144 + +#ifdef DEBUG_IOPORT +# define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__) #else -#define DEFAULT_RAM_SIZE 128 +# define LOG_IOPORT(...) do { } while (0) #endif +#define DEFAULT_RAM_SIZE 128 + /* Max number of USB devices that can be specified on the commandline. */ #define MAX_USB_CMDLINE 8 @@ -187,18 +198,21 @@ DriveInfo drives_table[MAX_DRIVES+1]; int nb_drives; static int vga_ram_size; enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB; -DisplayState display_state; +static DisplayState *display_state; int nographic; static int curses; +static int sdl; const char* keyboard_layout = NULL; int64_t ticks_per_sec; ram_addr_t ram_size; int nb_nics; NICInfo nd_table[MAX_NICS]; int vm_running; +static int autostart; static int rtc_utc = 1; static int rtc_date_offset = -1; /* -1 means no change */ int cirrus_vga_enabled = 1; +int std_vga_enabled = 0; int vmsvga_enabled = 0; #ifdef TARGET_SPARC int graphic_width = 1024; @@ -216,13 +230,16 @@ static int no_frame = 0; int no_quit = 0; CharDriverState *serial_hds[MAX_SERIAL_PORTS]; CharDriverState *parallel_hds[MAX_PARALLEL_PORTS]; +CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES]; #ifdef TARGET_I386 int win2k_install_hack = 0; +int rtc_td_hack = 0; #endif int usb_enabled = 0; int smp_cpus = 1; const char *vnc_display; int acpi_enabled = 1; +int no_hpet = 0; int fd_bootchk = 1; int no_reboot = 0; int no_shutdown = 0; @@ -237,15 +254,12 @@ int old_param = 0; #endif const char *qemu_name; int alt_grab = 0; -#ifdef TARGET_SPARC +#if defined(TARGET_SPARC) || defined(TARGET_PPC) unsigned int nb_prom_envs = 0; const char *prom_envs[MAX_PROM_ENVS]; #endif -static int nb_drives_opt; -static struct drive_opt { - const char *file; - char opt[1024]; -} drives_opt[MAX_DRIVES]; +int nb_drives_opt; +struct drive_opt drives_opt[MAX_DRIVES]; static CPUState *cur_cpu; static CPUState *next_cpu; @@ -258,6 +272,7 @@ static int icount_time_shift; static int64_t qemu_icount_bias; static QEMUTimer *icount_rt_timer; static QEMUTimer *icount_vm_timer; +static QEMUTimer *nographic_timer; uint8_t qemu_uuid[16]; @@ -405,6 +420,8 @@ void isa_unassign_ioport(int start, int length) ioport_write_table[0][i] = default_ioport_writeb; ioport_write_table[1][i] = default_ioport_writew; ioport_write_table[2][i] = default_ioport_writel; + + ioport_opaque[i] = NULL; } } @@ -412,10 +429,7 @@ void isa_unassign_ioport(int start, int length) void cpu_outb(CPUState *env, int addr, int val) { -#ifdef DEBUG_IOPORT - if (loglevel & CPU_LOG_IOPORT) - fprintf(logfile, "outb: %04x %02x\n", addr, val); -#endif + LOG_IOPORT("outb: %04x %02x\n", addr, val); ioport_write(0, addr, val); #ifdef USE_KQEMU if (env) @@ -425,10 +439,7 @@ void cpu_outb(CPUState *env, int addr, int val) void cpu_outw(CPUState *env, int addr, int val) { -#ifdef DEBUG_IOPORT - if (loglevel & CPU_LOG_IOPORT) - fprintf(logfile, "outw: %04x %04x\n", addr, val); -#endif + LOG_IOPORT("outw: %04x %04x\n", addr, val); ioport_write(1, addr, val); #ifdef USE_KQEMU if (env) @@ -438,10 +449,7 @@ void cpu_outw(CPUState *env, int addr, int val) void cpu_outl(CPUState *env, int addr, int val) { -#ifdef DEBUG_IOPORT - if (loglevel & CPU_LOG_IOPORT) - fprintf(logfile, "outl: %04x %08x\n", addr, val); -#endif + LOG_IOPORT("outl: %04x %08x\n", addr, val); ioport_write(2, addr, val); #ifdef USE_KQEMU if (env) @@ -453,10 +461,7 @@ int cpu_inb(CPUState *env, int addr) { int val; val = ioport_read(0, addr); -#ifdef DEBUG_IOPORT - if (loglevel & CPU_LOG_IOPORT) - fprintf(logfile, "inb : %04x %02x\n", addr, val); -#endif + LOG_IOPORT("inb : %04x %02x\n", addr, val); #ifdef USE_KQEMU if (env) env->last_io_time = cpu_get_time_fast(); @@ -468,10 +473,7 @@ int cpu_inw(CPUState *env, int addr) { int val; val = ioport_read(1, addr); -#ifdef DEBUG_IOPORT - if (loglevel & CPU_LOG_IOPORT) - fprintf(logfile, "inw : %04x %04x\n", addr, val); -#endif + LOG_IOPORT("inw : %04x %04x\n", addr, val); #ifdef USE_KQEMU if (env) env->last_io_time = cpu_get_time_fast(); @@ -483,10 +485,7 @@ int cpu_inl(CPUState *env, int addr) { int val; val = ioport_read(2, addr); -#ifdef DEBUG_IOPORT - if (loglevel & CPU_LOG_IOPORT) - fprintf(logfile, "inl : %04x %08x\n", addr, val); -#endif + LOG_IOPORT("inl : %04x %08x\n", addr, val); #ifdef USE_KQEMU if (env) env->last_io_time = cpu_get_time_fast(); @@ -562,8 +561,6 @@ QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, QEMUPutMouseEntry *s, *cursor; s = qemu_mallocz(sizeof(QEMUPutMouseEntry)); - if (!s) - return NULL; s->qemu_put_mouse_event = func; s->qemu_put_mouse_event_opaque = opaque; @@ -663,34 +660,34 @@ int kbd_mouse_is_absolute(void) return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute; } -void do_info_mice(void) +void do_info_mice(Monitor *mon) { QEMUPutMouseEntry *cursor; int index = 0; if (!qemu_put_mouse_event_head) { - term_printf("No mouse devices connected\n"); + monitor_printf(mon, "No mouse devices connected\n"); return; } - term_printf("Mouse devices available:\n"); + monitor_printf(mon, "Mouse devices available:\n"); cursor = qemu_put_mouse_event_head; while (cursor != NULL) { - term_printf("%c Mouse #%d: %s\n", - (cursor == qemu_put_mouse_event_current ? '*' : ' '), - index, cursor->qemu_put_mouse_event_name); + monitor_printf(mon, "%c Mouse #%d: %s\n", + (cursor == qemu_put_mouse_event_current ? '*' : ' '), + index, cursor->qemu_put_mouse_event_name); index++; cursor = cursor->next; } } -void do_mouse_set(int index) +void do_mouse_set(Monitor *mon, int index) { QEMUPutMouseEntry *cursor; int i = 0; if (!qemu_put_mouse_event_head) { - term_printf("No mouse devices connected\n"); + monitor_printf(mon, "No mouse devices connected\n"); return; } @@ -703,7 +700,7 @@ void do_mouse_set(int index) if (cursor != NULL) qemu_put_mouse_event_current = cursor; else - term_printf("Mouse at given index not found\n"); + monitor_printf(mon, "Mouse at given index not found\n"); } /* compute with 96 bit intermediate result: (a*b)/c */ @@ -765,7 +762,8 @@ static int use_rt_clock; static void init_get_clock(void) { use_rt_clock = 0; -#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) +#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \ + || defined(__DragonFly__) { struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) { @@ -777,7 +775,8 @@ static void init_get_clock(void) static int64_t get_clock(void) { -#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) +#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \ + || defined(__DragonFly__) if (use_rt_clock) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); @@ -1054,7 +1053,7 @@ static void configure_alarms(char const *opt) { int i; int cur = 0; - int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1; + int count = ARRAY_SIZE(alarm_timers) - 1; char *arg; char *name; struct qemu_alarm_timer tmp; @@ -1114,8 +1113,6 @@ static QEMUClock *qemu_new_clock(int type) { QEMUClock *clock; clock = qemu_mallocz(sizeof(QEMUClock)); - if (!clock) - return NULL; clock->type = type; return clock; } @@ -1187,7 +1184,7 @@ void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time) } /* Interrupt execution to force deadline recalculation. */ if (use_icount && cpu_single_env) { - cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT); + cpu_exit(cpu_single_env); } } } @@ -1354,7 +1351,7 @@ static void host_alarm_handler(int host_signum) if (env) { /* stop the currently executing cpu because a timer occured */ - cpu_interrupt(env, CPU_INTERRUPT_EXIT); + cpu_exit(env); #ifdef USE_KQEMU if (env->kqemu_enabled) { kqemu_cpu_interrupt(env); @@ -2145,32 +2142,62 @@ static int bt_parse(const char *opt) /* QEMU Block devices */ #define HD_ALIAS "index=%d,media=disk" -#ifdef TARGET_PPC -#define CDROM_ALIAS "index=1,media=cdrom" -#else #define CDROM_ALIAS "index=2,media=cdrom" -#endif #define FD_ALIAS "index=%d,if=floppy" #define PFLASH_ALIAS "if=pflash" #define MTD_ALIAS "if=mtd" #define SD_ALIAS "index=0,if=sd" -static int drive_add(const char *file, const char *fmt, ...) +static int drive_opt_get_free_idx(void) +{ + int index; + + for (index = 0; index < MAX_DRIVES; index++) + if (!drives_opt[index].used) { + drives_opt[index].used = 1; + return index; + } + + return -1; +} + +static int drive_get_free_idx(void) +{ + int index; + + for (index = 0; index < MAX_DRIVES; index++) + if (!drives_table[index].used) { + drives_table[index].used = 1; + return index; + } + + return -1; +} + +int drive_add(const char *file, const char *fmt, ...) { va_list ap; + int index = drive_opt_get_free_idx(); - if (nb_drives_opt >= MAX_DRIVES) { + if (nb_drives_opt >= MAX_DRIVES || index == -1) { fprintf(stderr, "qemu: too many drives\n"); - exit(1); + return -1; } - drives_opt[nb_drives_opt].file = file; + drives_opt[index].file = file; va_start(ap, fmt); - vsnprintf(drives_opt[nb_drives_opt].opt, + vsnprintf(drives_opt[index].opt, sizeof(drives_opt[0].opt), fmt, ap); va_end(ap); - return nb_drives_opt++; + nb_drives_opt++; + return index; +} + +void drive_remove(int index) +{ + drives_opt[index].used = 0; + nb_drives_opt--; } int drive_get_index(BlockInterfaceType type, int bus, int unit) @@ -2179,10 +2206,11 @@ int drive_get_index(BlockInterfaceType type, int bus, int unit) /* seek interface, bus and unit */ - for (index = 0; index < nb_drives; index++) + for (index = 0; index < MAX_DRIVES; index++) if (drives_table[index].type == type && drives_table[index].bus == bus && - drives_table[index].unit == unit) + drives_table[index].unit == unit && + drives_table[index].used) return index; return -1; @@ -2202,17 +2230,53 @@ int drive_get_max_bus(BlockInterfaceType type) return max_bus; } +const char *drive_get_serial(BlockDriverState *bdrv) +{ + int index; + + for (index = 0; index < nb_drives; index++) + if (drives_table[index].bdrv == bdrv) + return drives_table[index].serial; + + return "\0"; +} + +BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv) +{ + int index; + + for (index = 0; index < nb_drives; index++) + if (drives_table[index].bdrv == bdrv) + return drives_table[index].onerror; + + return BLOCK_ERR_STOP_ENOSPC; +} + static void bdrv_format_print(void *opaque, const char *name) { fprintf(stderr, " %s", name); } -static int drive_init(struct drive_opt *arg, int snapshot, - QEMUMachine *machine) +void drive_uninit(BlockDriverState *bdrv) +{ + int i; + + for (i = 0; i < MAX_DRIVES; i++) + if (drives_table[i].bdrv == bdrv) { + drives_table[i].bdrv = NULL; + drives_table[i].used = 0; + drive_remove(drives_table[i].drive_opt_idx); + nb_drives--; + break; + } +} + +int drive_init(struct drive_opt *arg, int snapshot, void *opaque) { char buf[128]; char file[1024]; char devname[128]; + char serial[21]; const char *mediastr = ""; BlockInterfaceType type; enum { MEDIA_DISK, MEDIA_CDROM } media; @@ -2220,15 +2284,18 @@ static int drive_init(struct drive_opt *arg, int snapshot, int cyls, heads, secs, translation; BlockDriverState *bdrv; BlockDriver *drv = NULL; + QEMUMachine *machine = opaque; int max_devs; int index; int cache; - int bdrv_flags; + int bdrv_flags, onerror; + int drives_table_idx; char *str = arg->opt; static const char * const params[] = { "bus", "unit", "if", "index", "cyls", "heads", "secs", "trans", "media", "snapshot", "file", - "cache", "format", NULL }; + "cache", "format", "serial", "werror", + NULL }; if (check_params(buf, sizeof(buf), params, str) < 0) { fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n", @@ -2415,6 +2482,29 @@ static int drive_init(struct drive_opt *arg, int snapshot, else pstrcpy(file, sizeof(file), arg->file); + if (!get_param_value(serial, sizeof(serial), "serial", str)) + memset(serial, 0, sizeof(serial)); + + onerror = BLOCK_ERR_STOP_ENOSPC; + if (get_param_value(buf, sizeof(serial), "werror", str)) { + if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) { + fprintf(stderr, "werror is no supported by this format\n"); + return -1; + } + if (!strcmp(buf, "ignore")) + onerror = BLOCK_ERR_IGNORE; + else if (!strcmp(buf, "enospc")) + onerror = BLOCK_ERR_STOP_ENOSPC; + else if (!strcmp(buf, "stop")) + onerror = BLOCK_ERR_STOP_ANY; + else if (!strcmp(buf, "report")) + onerror = BLOCK_ERR_REPORT; + else { + fprintf(stderr, "qemu: '%s' invalid write error action\n", buf); + return -1; + } + } + /* compute bus and unit according index */ if (index != -1) { @@ -2461,7 +2551,7 @@ static int drive_init(struct drive_opt *arg, int snapshot, */ if (drive_get_index(type, bus_id, unit_id) != -1) - return 0; + return -2; /* init */ @@ -2474,10 +2564,14 @@ static int drive_init(struct drive_opt *arg, int snapshot, snprintf(buf, sizeof(buf), "%s%s%i", devname, mediastr, unit_id); bdrv = bdrv_new(buf); - drives_table[nb_drives].bdrv = bdrv; - drives_table[nb_drives].type = type; - drives_table[nb_drives].bus = bus_id; - drives_table[nb_drives].unit = unit_id; + drives_table_idx = drive_get_free_idx(); + drives_table[drives_table_idx].bdrv = bdrv; + drives_table[drives_table_idx].type = type; + drives_table[drives_table_idx].bus = bus_id; + drives_table[drives_table_idx].unit = unit_id; + drives_table[drives_table_idx].onerror = onerror; + drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt; + strncpy(drives_table[nb_drives].serial, serial, sizeof(serial)); nb_drives++; switch(type) { @@ -2507,7 +2601,7 @@ static int drive_init(struct drive_opt *arg, int snapshot, break; } if (!file[0]) - return 0; + return -2; bdrv_flags = 0; if (snapshot) { bdrv_flags |= BDRV_O_SNAPSHOT; @@ -2519,12 +2613,14 @@ static int drive_init(struct drive_opt *arg, int snapshot, bdrv_flags |= BDRV_O_CACHE_WB; else if (cache == 3) /* not specified */ bdrv_flags |= BDRV_O_CACHE_DEF; - if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) { + if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) { fprintf(stderr, "qemu: could not open disk image %s\n", file); return -1; } - return 0; + if (bdrv_key_required(bdrv)) + autostart = 0; + return drives_table_idx; } /***********************************************************/ @@ -2570,7 +2666,17 @@ int usb_device_add_dev(USBDevice *dev) return 0; } -static int usb_device_add(const char *devname) +static void usb_msd_password_cb(void *opaque, int err) +{ + USBDevice *dev = opaque; + + if (!err) + usb_device_add_dev(dev); + else + dev->handle_destroy(dev); +} + +static int usb_device_add(const char *devname, int is_hotplug) { const char *p; USBDevice *dev; @@ -2587,7 +2693,20 @@ static int usb_device_add(const char *devname) } else if (!strcmp(devname, "keyboard")) { dev = usb_keyboard_init(); } else if (strstart(devname, "disk:", &p)) { + BlockDriverState *bs; + dev = usb_msd_init(p); + if (!dev) + return -1; + bs = usb_msd_get_bdrv(dev); + if (bdrv_key_required(bs)) { + autostart = 0; + if (is_hotplug) { + monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb, + dev); + return 0; + } + } } else if (!strcmp(devname, "wacom-tablet")) { dev = usb_wacom_init(); } else if (strstart(devname, "serial:", &p)) { @@ -2666,24 +2785,24 @@ static int usb_device_del(const char *devname) return usb_device_del_addr(bus_num, addr); } -void do_usb_add(const char *devname) +void do_usb_add(Monitor *mon, const char *devname) { - usb_device_add(devname); + usb_device_add(devname, 1); } -void do_usb_del(const char *devname) +void do_usb_del(Monitor *mon, const char *devname) { usb_device_del(devname); } -void usb_info(void) +void usb_info(Monitor *mon) { USBDevice *dev; USBPort *port; const char *speed_str; if (!usb_enabled) { - term_printf("USB support not enabled\n"); + monitor_printf(mon, "USB support not enabled\n"); return; } @@ -2705,8 +2824,8 @@ void usb_info(void) speed_str = "?"; break; } - term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n", - 0, dev->addr, speed_str, dev->devname); + monitor_printf(mon, " Device %d.%d, Speed %s Mb/s, Product %s\n", + 0, dev->addr, speed_str, dev->devname); } } @@ -2740,46 +2859,62 @@ void pcmcia_socket_unregister(struct pcmcia_socket_s *socket) } } -void pcmcia_info(void) +void pcmcia_info(Monitor *mon) { struct pcmcia_socket_entry_s *iter; + if (!pcmcia_sockets) - term_printf("No PCMCIA sockets\n"); + monitor_printf(mon, "No PCMCIA sockets\n"); for (iter = pcmcia_sockets; iter; iter = iter->next) - term_printf("%s: %s\n", iter->socket->slot_string, - iter->socket->attached ? iter->socket->card_string : - "Empty"); + monitor_printf(mon, "%s: %s\n", iter->socket->slot_string, + iter->socket->attached ? iter->socket->card_string : + "Empty"); } /***********************************************************/ -/* dumb display */ +/* register display */ + +struct DisplayAllocator default_allocator = { + defaultallocator_create_displaysurface, + defaultallocator_resize_displaysurface, + defaultallocator_free_displaysurface +}; + +void register_displaystate(DisplayState *ds) +{ + DisplayState **s; + s = &display_state; + while (*s != NULL) + s = &(*s)->next; + ds->next = NULL; + *s = ds; +} -static void dumb_update(DisplayState *ds, int x, int y, int w, int h) +DisplayState *get_displaystate(void) { + return display_state; } -static void dumb_resize(DisplayState *ds, int w, int h) +DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da) { + if(ds->allocator == &default_allocator) ds->allocator = da; + return ds->allocator; } -static void dumb_display_init(DisplayState *ds) +/* dumb display */ + +static void dumb_display_init(void) { - ds->data = NULL; - ds->linesize = 0; - ds->depth = 0; - ds->dpy_update = dumb_update; - ds->dpy_resize = dumb_resize; - ds->dpy_refresh = NULL; - ds->gui_timer_interval = 0; - ds->idle = 1; + DisplayState *ds = qemu_mallocz(sizeof(DisplayState)); + ds->allocator = &default_allocator; + ds->surface = qemu_create_displaysurface(ds, 640, 480); + register_displaystate(ds); } /***********************************************************/ /* I/O handling */ -#define MAX_IO_HANDLERS 64 - typedef struct IOHandlerRecord { int fd; IOCanRWHandler *fd_read_poll; @@ -2822,8 +2957,6 @@ int qemu_set_fd_handler2(int fd, goto found; } ioh = qemu_mallocz(sizeof(IOHandlerRecord)); - if (!ioh) - return -1; ioh->next = first_io_handler; first_io_handler = ioh; found: @@ -2861,8 +2994,6 @@ int qemu_add_polling_cb(PollingFunc *func, void *opaque) { PollingEntry **ppe, *pe; pe = qemu_mallocz(sizeof(PollingEntry)); - if (!pe) - return -1; pe->func = func; pe->opaque = opaque; for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next); @@ -3205,7 +3336,7 @@ void qemu_service_io(void) { CPUState *env = cpu_single_env; if (env) { - cpu_interrupt(env, CPU_INTERRUPT_EXIT); + cpu_exit(env); #ifdef USE_KQEMU if (env->kqemu_enabled) { kqemu_cpu_interrupt(env); @@ -3232,8 +3363,6 @@ QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque) { QEMUBH *bh; bh = qemu_mallocz(sizeof(QEMUBH)); - if (!bh) - return NULL; bh->cb = cb; bh->opaque = opaque; bh->next = first_bh; @@ -3288,7 +3417,7 @@ void qemu_bh_schedule(QEMUBH *bh) bh->idle = 0; /* stop the currently executing CPU to execute the BH ASAP */ if (env) { - cpu_interrupt(env, CPU_INTERRUPT_EXIT); + cpu_exit(env); } } @@ -3327,6 +3456,7 @@ static void qemu_bh_update_timeout(int *timeout) /* machine registration */ static QEMUMachine *first_machine = NULL; +QEMUMachine *current_machine = NULL; int qemu_register_machine(QEMUMachine *m) { @@ -3355,13 +3485,26 @@ static QEMUMachine *find_machine(const char *name) static void gui_update(void *opaque) { + uint64_t interval = GUI_REFRESH_INTERVAL; DisplayState *ds = opaque; - ds->dpy_refresh(ds); - qemu_mod_timer(ds->gui_timer, - (ds->gui_timer_interval ? - ds->gui_timer_interval : - GUI_REFRESH_INTERVAL) - + qemu_get_clock(rt_clock)); + DisplayChangeListener *dcl = ds->listeners; + + dpy_refresh(ds); + + while (dcl != NULL) { + if (dcl->gui_timer_interval && + dcl->gui_timer_interval < interval) + interval = dcl->gui_timer_interval; + dcl = dcl->next; + } + qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock)); +} + +static void nographic_update(void *opaque) +{ + uint64_t interval = GUI_REFRESH_INTERVAL; + + qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock)); } struct vm_change_state_entry { @@ -3378,8 +3521,6 @@ VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, VMChangeStateEntry *e; e = qemu_mallocz(sizeof (*e)); - if (!e) - return NULL; e->cb = cb; e->opaque = opaque; @@ -3393,37 +3534,21 @@ void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) qemu_free (e); } -static void vm_state_notify(int running) +static void vm_state_notify(int running, int reason) { VMChangeStateEntry *e; for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) { - e->cb(e->opaque, running); + e->cb(e->opaque, running, reason); } } -/* XXX: support several handlers */ -static VMStopHandler *vm_stop_cb; -static void *vm_stop_opaque; - -int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque) -{ - vm_stop_cb = cb; - vm_stop_opaque = opaque; - return 0; -} - -void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque) -{ - vm_stop_cb = NULL; -} - void vm_start(void) { if (!vm_running) { cpu_enable_ticks(); vm_running = 1; - vm_state_notify(1); + vm_state_notify(1, 0); qemu_rearm_alarm_timer(alarm_timer); } } @@ -3433,12 +3558,7 @@ void vm_stop(int reason) if (vm_running) { cpu_disable_ticks(); vm_running = 0; - if (reason != 0) { - if (vm_stop_cb) { - vm_stop_cb(vm_stop_opaque, reason); - } - } - vm_state_notify(0); + vm_state_notify(0, reason); } } @@ -3508,25 +3628,25 @@ void qemu_system_reset_request(void) reset_requested = 1; } if (cpu_single_env) - cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT); + cpu_exit(cpu_single_env); } void qemu_system_shutdown_request(void) { shutdown_requested = 1; if (cpu_single_env) - cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT); + cpu_exit(cpu_single_env); } void qemu_system_powerdown_request(void) { powerdown_requested = 1; if (cpu_single_env) - cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT); + cpu_exit(cpu_single_env); } #ifdef _WIN32 -void host_main_loop_wait(int *timeout) +static void host_main_loop_wait(int *timeout) { int ret, ret2, i; PollingEntry *pe; @@ -3570,7 +3690,7 @@ void host_main_loop_wait(int *timeout) *timeout = 0; } #else -void host_main_loop_wait(int *timeout) +static void host_main_loop_wait(int *timeout) { } #endif @@ -3823,158 +3943,13 @@ static void help(int exitcode) "\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" - "-cpu cpu select CPU (-cpu ? 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 image (cdrom is ide1 master)\n" - "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n" - " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n" - " [,cache=writethrough|writeback|none][,format=f]\n" - " use 'file' as a drive image\n" - "-mtdblock file use 'file' as on-board Flash memory image\n" - "-sd file use 'file' as SecureDigital card image\n" - "-pflash file use 'file' as a parallel flash image\n" - "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n" - "-snapshot write to temporary files instead of disk image files\n" -#ifdef CONFIG_SDL - "-no-frame open SDL window without a frame and window decorations\n" - "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n" - "-no-quit disable SDL window close capability\n" -#endif -#ifdef TARGET_I386 - "-no-fd-bootchk disable boot signature checking for floppy disks\n" -#endif - "-m megs set virtual RAM size to megs MB [default=%d]\n" - "-smp n set the number of CPUs to 'n' [default=1]\n" - "-nographic disable graphical output and redirect serial I/Os to console\n" - "-portrait rotate graphical output 90 deg left (only PXA LCD)\n" -#ifndef _WIN32 - "-k language use keyboard layout (for example \"fr\" for French)\n" -#endif -#ifdef HAS_AUDIO - "-audio-help print list of audio drivers and their options\n" - "-soundhw c1,... enable audio support\n" - " and only specified sound cards (comma separated list)\n" - " use -soundhw ? to get the list of supported cards\n" - " use -soundhw all to enable all of them\n" -#endif - "-vga [std|cirrus|vmware]\n" - " select video card type\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 - "-usb enable the USB driver (will be the default soon)\n" - "-usbdevice name add the host or guest USB device 'name'\n" -#if defined(TARGET_PPC) || defined(TARGET_SPARC) - "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n" -#endif - "-name string set the name of the guest\n" - "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n" - "\n" - "Network options:\n" - "-net nic[,vlan=n][,macaddr=addr][,model=type]\n" - " create a new Network Interface Card and connect it to VLAN 'n'\n" -#ifdef CONFIG_SLIRP - "-net user[,vlan=n][,hostname=host]\n" - " connect the user mode network stack to VLAN 'n' and send\n" - " hostname 'host' to DHCP clients\n" -#endif -#ifdef _WIN32 - "-net tap[,vlan=n],ifname=name\n" - " connect the host TAP network interface to VLAN 'n'\n" -#else - "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n" - " connect the host TAP network interface to VLAN 'n' and use the\n" - " network scripts 'file' (default=%s)\n" - " and 'dfile' (default=%s);\n" - " use '[down]script=no' to disable script execution;\n" - " use 'fd=h' to connect to an already opened TAP interface\n" -#endif - "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n" - " connect the vlan 'n' to another VLAN using a socket connection\n" - "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n" - " connect the vlan 'n' to multicast maddr and port\n" -#ifdef CONFIG_VDE - "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n" - " connect the vlan 'n' to port 'n' of a vde switch running\n" - " on host and listening for incoming connections on 'socketpath'.\n" - " Use group 'groupname' and mode 'octalmode' to change default\n" - " ownership and permissions for communication port.\n" -#endif - "-net none use it alone to have zero network devices; if no -net option\n" - " is provided, the default is '-net nic -net user'\n" - "\n" - "-bt hci,null Dumb bluetooth HCI - doesn't respond to commands\n" - "-bt hci,host[:id]\n" - " Use host's HCI with the given name\n" - "-bt hci[,vlan=n]\n" - " Emulate a standard HCI in virtual scatternet 'n'\n" - "-bt vhci[,vlan=n]\n" - " Add host computer to virtual scatternet 'n' using VHCI\n" - "-bt device:dev[,vlan=n]\n" - " Emulate a bluetooth device 'dev' in scatternet 'n'\n" - "\n" -#ifdef CONFIG_SLIRP - "-tftp dir allow tftp access to files in dir [-net user]\n" - "-bootp file advertise file in BOOTP replies\n" -#ifndef _WIN32 - "-smb dir allow SMB access to files in 'dir' [-net user]\n" -#endif - "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n" - " redirect TCP or UDP connections from host to guest [-net user]\n" -#endif - "\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\n" - "-p port set gdb connection port [default=%s]\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, VGA BIOS and keymaps\n" -#ifdef USE_KQEMU - "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n" - "-no-kqemu disable KQEMU kernel module usage\n" -#endif -#ifdef CONFIG_KVM - "-enable-kvm enable KVM full virtualization support\n" -#endif -#ifdef TARGET_I386 - "-no-acpi disable ACPI\n" -#endif -#ifdef CONFIG_CURSES - "-curses use a curses/ncurses interface instead of SDL\n" -#endif - "-no-reboot exit instead of rebooting\n" - "-no-shutdown stop before shutdown\n" - "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n" - "-vnc display start a VNC server on display\n" -#ifndef _WIN32 - "-daemonize daemonize QEMU after initializing\n" -#endif - "-option-rom rom load a file, rom, into the option ROM space\n" -#ifdef TARGET_SPARC - "-prom-env variable=value set OpenBIOS nvram variables\n" -#endif - "-clock force the use of the given methods for timer alarm.\n" - " To see what timers are available use -clock ?\n" - "-startdate select initial date of the clock\n" - "-icount [N|auto]\n" - " Enable virtual instruction counter with 2^N clock ticks per instruction\n" +#define DEF(option, opt_arg, opt_enum, opt_help) \ + opt_help +#define DEFHEADING(text) stringify(text) "\n" +#include "qemu-options.h" +#undef DEF +#undef DEFHEADING +#undef GEN_DOCS "\n" "During emulation, the following keys are useful:\n" "ctrl-alt-f toggle full screen\n" @@ -3997,91 +3972,13 @@ static void help(int exitcode) #define HAS_ARG 0x0001 enum { - QEMU_OPTION_h, - - QEMU_OPTION_M, - QEMU_OPTION_cpu, - QEMU_OPTION_fda, - QEMU_OPTION_fdb, - QEMU_OPTION_hda, - QEMU_OPTION_hdb, - QEMU_OPTION_hdc, - QEMU_OPTION_hdd, - QEMU_OPTION_drive, - QEMU_OPTION_cdrom, - QEMU_OPTION_mtdblock, - QEMU_OPTION_sd, - QEMU_OPTION_pflash, - QEMU_OPTION_boot, - QEMU_OPTION_snapshot, -#ifdef TARGET_I386 - QEMU_OPTION_no_fd_bootchk, -#endif - QEMU_OPTION_m, - QEMU_OPTION_nographic, - QEMU_OPTION_portrait, -#ifdef HAS_AUDIO - QEMU_OPTION_audio_help, - QEMU_OPTION_soundhw, -#endif - - QEMU_OPTION_net, - QEMU_OPTION_tftp, - QEMU_OPTION_bootp, - QEMU_OPTION_smb, - QEMU_OPTION_redir, - QEMU_OPTION_bt, - - 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_bios, - QEMU_OPTION_k, - QEMU_OPTION_localtime, - QEMU_OPTION_g, - QEMU_OPTION_vga, - QEMU_OPTION_echr, - QEMU_OPTION_monitor, - QEMU_OPTION_serial, - QEMU_OPTION_parallel, - QEMU_OPTION_loadvm, - QEMU_OPTION_full_screen, - QEMU_OPTION_no_frame, - QEMU_OPTION_alt_grab, - QEMU_OPTION_no_quit, - QEMU_OPTION_pidfile, - QEMU_OPTION_no_kqemu, - QEMU_OPTION_kernel_kqemu, - QEMU_OPTION_enable_kvm, - QEMU_OPTION_win2k_hack, - QEMU_OPTION_usb, - QEMU_OPTION_usbdevice, - QEMU_OPTION_smp, - QEMU_OPTION_vnc, - QEMU_OPTION_no_acpi, - QEMU_OPTION_curses, - QEMU_OPTION_no_reboot, - QEMU_OPTION_no_shutdown, - QEMU_OPTION_show_cursor, - QEMU_OPTION_daemonize, - QEMU_OPTION_option_rom, - QEMU_OPTION_semihosting, - QEMU_OPTION_name, - QEMU_OPTION_prom_env, - QEMU_OPTION_old_param, - QEMU_OPTION_clock, - QEMU_OPTION_startdate, - QEMU_OPTION_tb_size, - QEMU_OPTION_icount, - QEMU_OPTION_uuid, - QEMU_OPTION_incoming, +#define DEF(option, opt_arg, opt_enum, opt_help) \ + opt_enum, +#define DEFHEADING(text) +#include "qemu-options.h" +#undef DEF +#undef DEFHEADING +#undef GEN_DOCS }; typedef struct QEMUOption { @@ -4092,155 +3989,16 @@ typedef struct QEMUOption { static const QEMUOption qemu_options[] = { { "h", 0, QEMU_OPTION_h }, - { "help", 0, QEMU_OPTION_h }, - - { "M", HAS_ARG, QEMU_OPTION_M }, - { "cpu", HAS_ARG, QEMU_OPTION_cpu }, - { "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 }, - { "drive", HAS_ARG, QEMU_OPTION_drive }, - { "cdrom", HAS_ARG, QEMU_OPTION_cdrom }, - { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock }, - { "sd", HAS_ARG, QEMU_OPTION_sd }, - { "pflash", HAS_ARG, QEMU_OPTION_pflash }, - { "boot", HAS_ARG, QEMU_OPTION_boot }, - { "snapshot", 0, QEMU_OPTION_snapshot }, -#ifdef TARGET_I386 - { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk }, -#endif - { "m", HAS_ARG, QEMU_OPTION_m }, - { "nographic", 0, QEMU_OPTION_nographic }, - { "portrait", 0, QEMU_OPTION_portrait }, - { "k", HAS_ARG, QEMU_OPTION_k }, -#ifdef HAS_AUDIO - { "audio-help", 0, QEMU_OPTION_audio_help }, - { "soundhw", HAS_ARG, QEMU_OPTION_soundhw }, -#endif - - { "net", HAS_ARG, QEMU_OPTION_net}, -#ifdef CONFIG_SLIRP - { "tftp", HAS_ARG, QEMU_OPTION_tftp }, - { "bootp", HAS_ARG, QEMU_OPTION_bootp }, -#ifndef _WIN32 - { "smb", HAS_ARG, QEMU_OPTION_smb }, -#endif - { "redir", HAS_ARG, QEMU_OPTION_redir }, -#endif - { "bt", HAS_ARG, QEMU_OPTION_bt }, - - { "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 }, - { "bios", HAS_ARG, QEMU_OPTION_bios }, -#ifdef USE_KQEMU - { "no-kqemu", 0, QEMU_OPTION_no_kqemu }, - { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu }, -#endif -#ifdef CONFIG_KVM - { "enable-kvm", 0, QEMU_OPTION_enable_kvm }, -#endif -#if defined(TARGET_PPC) || defined(TARGET_SPARC) - { "g", 1, QEMU_OPTION_g }, -#endif - { "localtime", 0, QEMU_OPTION_localtime }, - { "vga", HAS_ARG, QEMU_OPTION_vga }, - { "echr", HAS_ARG, QEMU_OPTION_echr }, - { "monitor", HAS_ARG, QEMU_OPTION_monitor }, - { "serial", HAS_ARG, QEMU_OPTION_serial }, - { "parallel", HAS_ARG, QEMU_OPTION_parallel }, - { "loadvm", HAS_ARG, QEMU_OPTION_loadvm }, - { "full-screen", 0, QEMU_OPTION_full_screen }, -#ifdef CONFIG_SDL - { "no-frame", 0, QEMU_OPTION_no_frame }, - { "alt-grab", 0, QEMU_OPTION_alt_grab }, - { "no-quit", 0, QEMU_OPTION_no_quit }, -#endif - { "pidfile", HAS_ARG, QEMU_OPTION_pidfile }, - { "win2k-hack", 0, QEMU_OPTION_win2k_hack }, - { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice }, - { "smp", HAS_ARG, QEMU_OPTION_smp }, - { "vnc", HAS_ARG, QEMU_OPTION_vnc }, -#ifdef CONFIG_CURSES - { "curses", 0, QEMU_OPTION_curses }, -#endif - { "uuid", HAS_ARG, QEMU_OPTION_uuid }, - - /* temporary options */ - { "usb", 0, QEMU_OPTION_usb }, - { "no-acpi", 0, QEMU_OPTION_no_acpi }, - { "no-reboot", 0, QEMU_OPTION_no_reboot }, - { "no-shutdown", 0, QEMU_OPTION_no_shutdown }, - { "show-cursor", 0, QEMU_OPTION_show_cursor }, - { "daemonize", 0, QEMU_OPTION_daemonize }, - { "option-rom", HAS_ARG, QEMU_OPTION_option_rom }, -#if defined(TARGET_ARM) || defined(TARGET_M68K) - { "semihosting", 0, QEMU_OPTION_semihosting }, -#endif - { "name", HAS_ARG, QEMU_OPTION_name }, -#if defined(TARGET_SPARC) - { "prom-env", HAS_ARG, QEMU_OPTION_prom_env }, -#endif -#if defined(TARGET_ARM) - { "old-param", 0, QEMU_OPTION_old_param }, -#endif - { "clock", HAS_ARG, QEMU_OPTION_clock }, - { "startdate", HAS_ARG, QEMU_OPTION_startdate }, - { "tb-size", HAS_ARG, QEMU_OPTION_tb_size }, - { "icount", HAS_ARG, QEMU_OPTION_icount }, - { "incoming", HAS_ARG, QEMU_OPTION_incoming }, +#define DEF(option, opt_arg, opt_enum, opt_help) \ + { option, opt_arg, opt_enum }, +#define DEFHEADING(text) +#include "qemu-options.h" +#undef DEF +#undef DEFHEADING +#undef GEN_DOCS { NULL }, }; -/* password input */ - -int qemu_key_check(BlockDriverState *bs, const char *name) -{ - char password[256]; - int i; - - if (!bdrv_is_encrypted(bs)) - return 0; - - term_printf("%s is encrypted.\n", name); - for(i = 0; i < 3; i++) { - monitor_readline("Password: ", 1, password, sizeof(password)); - if (bdrv_set_key(bs, password) == 0) - return 0; - term_printf("invalid password\n"); - } - return -EPERM; -} - -static BlockDriverState *get_bdrv(int index) -{ - if (index > nb_drives) - return NULL; - return drives_table[index].bdrv; -} - -static void read_passwords(void) -{ - BlockDriverState *bs; - int i; - - for(i = 0; i < 6; i++) { - bs = get_bdrv(i); - if (bs) - qemu_key_check(bs, bdrv_get_device_name(bs)); - } -} - #ifdef HAS_AUDIO struct soundhw soundhw[] = { #ifdef HAS_AUDIO_CHOICE @@ -4253,6 +4011,8 @@ struct soundhw soundhw[] = { { .init_isa = pcspk_audio_init } }, #endif + +#ifdef CONFIG_SB16 { "sb16", "Creative Sound Blaster 16", @@ -4260,6 +4020,7 @@ struct soundhw soundhw[] = { 1, { .init_isa = SB16_init } }, +#endif #ifdef CONFIG_CS4231A { @@ -4305,6 +4066,7 @@ struct soundhw soundhw[] = { }, #endif +#ifdef CONFIG_ES1370 { "es1370", "ENSONIQ AudioPCI ES1370", @@ -4314,6 +4076,8 @@ struct soundhw soundhw[] = { }, #endif +#endif /* HAS_AUDIO_CHOICE */ + { NULL, NULL, 0, 0, { NULL } } }; @@ -4381,14 +4145,21 @@ static void select_vgahw (const char *p) const char *opts; if (strstart(p, "std", &opts)) { + std_vga_enabled = 1; cirrus_vga_enabled = 0; vmsvga_enabled = 0; } else if (strstart(p, "cirrus", &opts)) { cirrus_vga_enabled = 1; + std_vga_enabled = 0; vmsvga_enabled = 0; } else if (strstart(p, "vmware", &opts)) { cirrus_vga_enabled = 0; + std_vga_enabled = 0; vmsvga_enabled = 1; + } else if (strstart(p, "none", &opts)) { + cirrus_vga_enabled = 0; + std_vga_enabled = 0; + vmsvga_enabled = 0; } else { invalid_vga: fprintf(stderr, "Unknown vga type: %s\n", p); @@ -4456,7 +4227,7 @@ static void termsig_setup(void) #endif -int main(int argc, char **argv) +int main(int argc, char **argv, char **envp) { #ifdef CONFIG_GDBSTUB int use_gdbstub; @@ -4468,7 +4239,8 @@ int main(int argc, char **argv) const char *initrd_filename; const char *kernel_filename, *kernel_cmdline; const char *boot_devices = ""; - DisplayState *ds = &display_state; + DisplayState *ds; + DisplayChangeListener *dcl; int cyls, heads, secs, translation; const char *net_clients[MAX_NET_CLIENTS]; int nb_net_clients; @@ -4477,12 +4249,14 @@ int main(int argc, char **argv) int hda_index; int optind; const char *r, *optarg; - CharDriverState *monitor_hd; + CharDriverState *monitor_hd = NULL; const char *monitor_device; const char *serial_devices[MAX_SERIAL_PORTS]; int serial_device_index; const char *parallel_devices[MAX_PARALLEL_PORTS]; int parallel_device_index; + const char *virtio_consoles[MAX_VIRTIO_CONSOLES]; + int virtio_console_index; const char *loadvm = NULL; QEMUMachine *machine; const char *cpu_model; @@ -4491,8 +4265,13 @@ int main(int argc, char **argv) int fds[2]; int tb_size; const char *pid_file = NULL; - int autostart; const char *incoming = NULL; + int fd = 0; + struct passwd *pwd = NULL; + const char *chroot_dir = NULL; + const char *run_as = NULL; + + qemu_cache_utils_init(envp); LIST_INIT (&vm_change_state_head); #ifndef _WIN32 @@ -4542,18 +4321,22 @@ int main(int argc, char **argv) kernel_cmdline = ""; cyls = heads = secs = 0; translation = BIOS_ATA_TRANSLATION_AUTO; - monitor_device = "vc"; + monitor_device = "vc:80Cx24C"; serial_devices[0] = "vc:80Cx24C"; for(i = 1; i < MAX_SERIAL_PORTS; i++) serial_devices[i] = NULL; serial_device_index = 0; - parallel_devices[0] = "vc:640x480"; + parallel_devices[0] = "vc:80Cx24C"; for(i = 1; i < MAX_PARALLEL_PORTS; i++) parallel_devices[i] = NULL; parallel_device_index = 0; + for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) + virtio_consoles[i] = NULL; + virtio_console_index = 0; + usb_devices_index = 0; nb_net_clients = 0; @@ -4878,15 +4661,18 @@ int main(int argc, char **argv) case QEMU_OPTION_S: autostart = 0; break; +#ifndef _WIN32 case QEMU_OPTION_k: keyboard_layout = optarg; break; +#endif case QEMU_OPTION_localtime: rtc_utc = 0; break; case QEMU_OPTION_vga: select_vgahw (optarg); break; +#if defined(TARGET_PPC) || defined(TARGET_SPARC) case QEMU_OPTION_g: { const char *p; @@ -4921,6 +4707,7 @@ int main(int argc, char **argv) graphic_depth = depth; } break; +#endif case QEMU_OPTION_echr: { char *r; @@ -4940,6 +4727,14 @@ int main(int argc, char **argv) serial_devices[serial_device_index] = optarg; serial_device_index++; break; + case QEMU_OPTION_virtiocon: + if (virtio_console_index >= MAX_VIRTIO_CONSOLES) { + fprintf(stderr, "qemu: too many virtio consoles\n"); + exit(1); + } + virtio_consoles[virtio_console_index] = optarg; + virtio_console_index++; + break; case QEMU_OPTION_parallel: if (parallel_device_index >= MAX_PARALLEL_PORTS) { fprintf(stderr, "qemu: too many parallel ports\n"); @@ -4964,6 +4759,9 @@ int main(int argc, char **argv) case QEMU_OPTION_no_quit: no_quit = 1; break; + case QEMU_OPTION_sdl: + sdl = 1; + break; #endif case QEMU_OPTION_pidfile: pid_file = optarg; @@ -4972,6 +4770,15 @@ int main(int argc, char **argv) case QEMU_OPTION_win2k_hack: win2k_install_hack = 1; break; + case QEMU_OPTION_rtc_td_hack: + rtc_td_hack = 1; + break; + case QEMU_OPTION_acpitable: + if(acpi_table_add(optarg) < 0) { + fprintf(stderr, "Wrong acpi table provided\n"); + exit(1); + } + break; #endif #ifdef USE_KQEMU case QEMU_OPTION_no_kqemu: @@ -5011,9 +4818,14 @@ int main(int argc, char **argv) case QEMU_OPTION_vnc: vnc_display = optarg; break; +#ifdef TARGET_I386 case QEMU_OPTION_no_acpi: acpi_enabled = 0; break; + case QEMU_OPTION_no_hpet: + no_hpet = 1; + break; +#endif case QEMU_OPTION_no_reboot: no_reboot = 1; break; @@ -5030,9 +4842,11 @@ int main(int argc, char **argv) exit(1); } break; +#ifndef _WIN32 case QEMU_OPTION_daemonize: daemonize = 1; break; +#endif case QEMU_OPTION_option_rom: if (nb_option_roms >= MAX_OPTION_ROMS) { fprintf(stderr, "Too many option ROMs\n"); @@ -5041,13 +4855,15 @@ int main(int argc, char **argv) option_rom[nb_option_roms] = optarg; nb_option_roms++; break; +#if defined(TARGET_ARM) || defined(TARGET_M68K) case QEMU_OPTION_semihosting: semihosting_enabled = 1; break; +#endif case QEMU_OPTION_name: qemu_name = optarg; break; -#ifdef TARGET_SPARC +#if defined(TARGET_SPARC) || defined(TARGET_PPC) case QEMU_OPTION_prom_env: if (nb_prom_envs >= MAX_PROM_ENVS) { fprintf(stderr, "Too many prom variables\n"); @@ -5119,6 +4935,14 @@ int main(int argc, char **argv) case QEMU_OPTION_incoming: incoming = optarg; break; +#ifndef _WIN32 + case QEMU_OPTION_chroot: + chroot_dir = optarg; + break; + case QEMU_OPTION_runas: + run_as = optarg; + break; +#endif } } } @@ -5326,6 +5150,7 @@ int main(int argc, char **argv) cpu_exec_init_all(tb_size * 1024 * 1024); bdrv_init(); + dma_helper_init(); /* we always create the cdrom drive, even if no disk is there */ @@ -5351,35 +5176,6 @@ int main(int argc, char **argv) register_savevm("timer", 0, 2, timer_save, timer_load, NULL); register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL); - /* terminal init */ - memset(&display_state, 0, sizeof(display_state)); - if (nographic) { - if (curses) { - fprintf(stderr, "fatal: -nographic can't be used with -curses\n"); - exit(1); - } - /* nearly nothing to do */ - dumb_display_init(ds); - } else if (vnc_display != NULL) { - vnc_display_init(ds); - if (vnc_display_open(ds, vnc_display) < 0) - exit(1); - } else -#if defined(CONFIG_CURSES) - if (curses) { - curses_display_init(ds, full_screen); - } else -#endif - { -#if defined(CONFIG_SDL) - sdl_display_init(ds, full_screen, no_frame); -#elif defined(CONFIG_COCOA) - cocoa_display_init(ds, full_screen); -#else - dumb_display_init(ds); -#endif - } - #ifndef _WIN32 /* must be after terminal init, SDL library changes signal handlers */ termsig_setup(); @@ -5399,13 +5195,23 @@ int main(int argc, char **argv) } } } + + if (kvm_enabled()) { + int ret; + + ret = kvm_init(smp_cpus); + if (ret < 0) { + fprintf(stderr, "failed to initialize KVM\n"); + exit(1); + } + } + if (monitor_device) { - monitor_hd = qemu_chr_open("monitor", monitor_device); + monitor_hd = qemu_chr_open("monitor", monitor_device, NULL); if (!monitor_hd) { fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device); exit(1); } - monitor_init(monitor_hd, !nographic); } for(i = 0; i < MAX_SERIAL_PORTS; i++) { @@ -5413,14 +5219,12 @@ int main(int argc, char **argv) if (devname && strcmp(devname, "none")) { char label[32]; snprintf(label, sizeof(label), "serial%d", i); - serial_hds[i] = qemu_chr_open(label, devname); + serial_hds[i] = qemu_chr_open(label, devname, NULL); if (!serial_hds[i]) { fprintf(stderr, "qemu: could not open serial device '%s'\n", devname); exit(1); } - if (strstart(devname, "vc", 0)) - qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i); } } @@ -5429,43 +5233,137 @@ int main(int argc, char **argv) if (devname && strcmp(devname, "none")) { char label[32]; snprintf(label, sizeof(label), "parallel%d", i); - parallel_hds[i] = qemu_chr_open(label, devname); + parallel_hds[i] = qemu_chr_open(label, devname, NULL); if (!parallel_hds[i]) { fprintf(stderr, "qemu: could not open parallel device '%s'\n", devname); exit(1); } - if (strstart(devname, "vc", 0)) - qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i); } } + for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) { + const char *devname = virtio_consoles[i]; + if (devname && strcmp(devname, "none")) { + char label[32]; + snprintf(label, sizeof(label), "virtcon%d", i); + virtcon_hds[i] = qemu_chr_open(label, devname, NULL); + if (!virtcon_hds[i]) { + fprintf(stderr, "qemu: could not open virtio console '%s'\n", + devname); + exit(1); + } + } + } + + machine->init(ram_size, vga_ram_size, boot_devices, + kernel_filename, kernel_cmdline, initrd_filename, cpu_model); + + current_machine = machine; + + /* Set KVM's vcpu state to qemu's initial CPUState. */ if (kvm_enabled()) { int ret; - ret = kvm_init(smp_cpus); + ret = kvm_sync_vcpus(); if (ret < 0) { - fprintf(stderr, "failed to initialize KVM\n"); + fprintf(stderr, "failed to initialize vcpus\n"); exit(1); } } - machine->init(ram_size, vga_ram_size, boot_devices, ds, - kernel_filename, kernel_cmdline, initrd_filename, cpu_model); - /* init USB devices */ if (usb_enabled) { for(i = 0; i < usb_devices_index; i++) { - if (usb_device_add(usb_devices[i]) < 0) { + if (usb_device_add(usb_devices[i], 0) < 0) { fprintf(stderr, "Warning: could not add USB device %s\n", usb_devices[i]); } } } - if (display_state.dpy_refresh) { - display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state); - qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock)); + if (!display_state) + dumb_display_init(); + /* just use the first displaystate for the moment */ + ds = display_state; + /* terminal init */ + if (nographic) { + if (curses) { + fprintf(stderr, "fatal: -nographic can't be used with -curses\n"); + exit(1); + } + } else { +#if defined(CONFIG_CURSES) + if (curses) { + /* At the moment curses cannot be used with other displays */ + curses_display_init(ds, full_screen); + } else +#endif + { + if (vnc_display != NULL) { + vnc_display_init(ds); + if (vnc_display_open(ds, vnc_display) < 0) + exit(1); + } +#if defined(CONFIG_SDL) + if (sdl || !vnc_display) + sdl_display_init(ds, full_screen, no_frame); +#elif defined(CONFIG_COCOA) + if (sdl || !vnc_display) + cocoa_display_init(ds, full_screen); +#endif + } + } + dpy_resize(ds); + + dcl = ds->listeners; + while (dcl != NULL) { + if (dcl->dpy_refresh != NULL) { + ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds); + qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock)); + } + dcl = dcl->next; + } + + if (nographic || (vnc_display && !sdl)) { + nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL); + qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock)); + } + + text_consoles_set_display(display_state); + qemu_chr_initial_reset(); + + if (monitor_device && monitor_hd) + monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT); + + for(i = 0; i < MAX_SERIAL_PORTS; i++) { + const char *devname = serial_devices[i]; + if (devname && strcmp(devname, "none")) { + char label[32]; + snprintf(label, sizeof(label), "serial%d", i); + if (strstart(devname, "vc", 0)) + qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i); + } + } + + for(i = 0; i < MAX_PARALLEL_PORTS; i++) { + const char *devname = parallel_devices[i]; + if (devname && strcmp(devname, "none")) { + char label[32]; + snprintf(label, sizeof(label), "parallel%d", i); + if (strstart(devname, "vc", 0)) + qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i); + } + } + + for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) { + const char *devname = virtio_consoles[i]; + if (virtcon_hds[i] && devname) { + char label[32]; + snprintf(label, sizeof(label), "virtcon%d", i); + if (strstart(devname, "vc", 0)) + qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i); + } } #ifdef CONFIG_GDBSTUB @@ -5481,25 +5379,19 @@ int main(int argc, char **argv) #endif if (loadvm) - do_loadvm(loadvm); + do_loadvm(cur_mon, loadvm); if (incoming) { autostart = 0; /* fixme how to deal with -daemonize */ qemu_start_incoming_migration(incoming); } - { - /* XXX: simplify init */ - read_passwords(); - if (autostart) { - vm_start(); - } - } + if (autostart) + vm_start(); if (daemonize) { uint8_t status = 0; ssize_t len; - int fd; again1: len = write(fds[1], &status, 1); @@ -5513,12 +5405,47 @@ int main(int argc, char **argv) TFR(fd = open("/dev/null", O_RDWR)); if (fd == -1) exit(1); + } - dup2(fd, 0); - dup2(fd, 1); - dup2(fd, 2); +#ifndef _WIN32 + if (run_as) { + pwd = getpwnam(run_as); + if (!pwd) { + fprintf(stderr, "User \"%s\" doesn't exist\n", run_as); + exit(1); + } + } + + if (chroot_dir) { + if (chroot(chroot_dir) < 0) { + fprintf(stderr, "chroot failed\n"); + exit(1); + } + chdir("/"); + } + + if (run_as) { + if (setgid(pwd->pw_gid) < 0) { + fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid); + exit(1); + } + if (setuid(pwd->pw_uid) < 0) { + fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid); + exit(1); + } + if (setuid(0) != -1) { + fprintf(stderr, "Dropping privileges failed\n"); + exit(1); + } + } +#endif + + if (daemonize) { + dup2(fd, 0); + dup2(fd, 1); + dup2(fd, 2); - close(fd); + close(fd); } main_loop();