vl.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "hw/hw.h"
  25 #include "hw/boards.h"
  26 #include "hw/usb.h"
  27 #include "hw/pcmcia.h"
  28 #include "hw/pc.h"
  29 #include "hw/fdc.h"
  30 #include "hw/audiodev.h"
  31 #include "hw/isa.h"
  32 #include "net.h"
  33 #include "console.h"
  34 #include "sysemu.h"
  35 #include "gdbstub.h"
  36 #include "qemu-timer.h"
  37 #include "qemu-char.h"
  38 #include "block.h"
  39 #include "audio/audio.h"
  40
  41 #include <unistd.h>
  42 #include <fcntl.h>
  43 #include <signal.h>
  44 #include <time.h>
  45 #include <errno.h>
  46 #include <sys/time.h>
  47 #include <zlib.h>
  48
  49 #ifndef _WIN32
  50 #include <sys/times.h>
  51 #include <sys/wait.h>
  52 #include <termios.h>
  53 #include <sys/poll.h>
  54 #include <sys/mman.h>
  55 #include <sys/ioctl.h>
  56 #include <sys/socket.h>
  57 #include <netinet/in.h>
  58 #include <dirent.h>
  59 #include <netdb.h>
  60 #include <sys/select.h>
  61 #include <arpa/inet.h>
  62 #ifdef _BSD
  63 #include <sys/stat.h>
  64 #ifndef __APPLE__
  65 #include <libutil.h>
  66 #endif
  67 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
  68 #include <freebsd/stdlib.h>
  69 #else
  70 #ifndef __sun__
  71 #include <linux/if.h>
  72 #include <linux/if_tun.h>
  73 #include <pty.h>
  74 #include <malloc.h>
  75 #include <linux/rtc.h>
  76
  77 /* For the benefit of older linux systems which don't supply it,
  78    we use a local copy of hpet.h. */
  79 /* #include <linux/hpet.h> */
  80 #include "hpet.h"
  81
  82 #include <linux/ppdev.h>
  83 #include <linux/parport.h>
  84 #else
  85 #include <sys/stat.h>
  86 #include <sys/ethernet.h>
  87 #include <sys/sockio.h>
  88 #include <netinet/arp.h>
  89 #include <netinet/in.h>
  90 #include <netinet/in_systm.h>
  91 #include <netinet/ip.h>
  92 #include <netinet/ip_icmp.h> // must come after ip.h
  93 #include <netinet/udp.h>
  94 #include <netinet/tcp.h>
  95 #include <net/if.h>
  96 #include <syslog.h>
  97 #include <stropts.h>
  98 #endif
  99 #endif
 100 #else
 101 #include <winsock2.h>
 102 int inet_aton(const char *cp, struct in_addr *ia);
 103 #endif
 104
 105 #if defined(CONFIG_SLIRP)
 106 #include "libslirp.h"
 107 #endif
 108
 109 #ifdef _WIN32
 110 #include <malloc.h>
 111 #include <sys/timeb.h>
 112 #include <mmsystem.h>
 113 #define getopt_long_only getopt_long
 114 #define memalign(align, size) malloc(size)
 115 #endif
 116
 117 #include "qemu_socket.h"
 118
 119 #ifdef CONFIG_SDL
 120 #ifdef __APPLE__
 121 #include <SDL/SDL.h>
 122 #endif
 123 #endif /* CONFIG_SDL */
 124
 125 #ifdef CONFIG_COCOA
 126 #undef main
 127 #define main qemu_main
 128 #endif /* CONFIG_COCOA */
 129
 130 #include "disas.h"
 131
 132 #include "exec-all.h"
 133
 134 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
 135 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
 136 #ifdef __sun__
 137 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
 138 #else
 139 #define SMBD_COMMAND "/usr/sbin/smbd"
 140 #endif
 141
 142 //#define DEBUG_UNUSED_IOPORT
 143 //#define DEBUG_IOPORT
 144
 145 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
 146
 147 #ifdef TARGET_PPC
 148 #define DEFAULT_RAM_SIZE 144
 149 #else
 150 #define DEFAULT_RAM_SIZE 128
 151 #endif
 152 /* in ms */
 153 #define GUI_REFRESH_INTERVAL 30
 154
 155 /* Max number of USB devices that can be specified on the commandline.  */
 156 #define MAX_USB_CMDLINE 8
 157
 158 /* XXX: use a two level table to limit memory usage */
 159 #define MAX_IOPORTS 65536
 160
 161 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
 162 const char *bios_name = NULL;
 163 void *ioport_opaque[MAX_IOPORTS];
 164 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
 165 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
 166 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
 167    to store the VM snapshots */
 168 DriveInfo drives_table[MAX_DRIVES+1];
 169 int nb_drives;
 170 /* point to the block driver where the snapshots are managed */
 171 BlockDriverState *bs_snapshots;
 172 int vga_ram_size;
 173 static DisplayState display_state;
 174 int nographic;
 175 int curses;
 176 const char* keyboard_layout = NULL;
 177 int64_t ticks_per_sec;
 178 int ram_size;
 179 int pit_min_timer_count = 0;
 180 int nb_nics;
 181 NICInfo nd_table[MAX_NICS];
 182 int vm_running;
 183 static int rtc_utc = 1;
 184 static int rtc_date_offset = -1; /* -1 means no change */
 185 int cirrus_vga_enabled = 1;
 186 int vmsvga_enabled = 0;
 187 #ifdef TARGET_SPARC
 188 int graphic_width = 1024;
 189 int graphic_height = 768;
 190 int graphic_depth = 8;
 191 #else
 192 int graphic_width = 800;
 193 int graphic_height = 600;
 194 int graphic_depth = 15;
 195 #endif
 196 int full_screen = 0;
 197 int no_frame = 0;
 198 int no_quit = 0;
 199 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 200 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 201 #ifdef TARGET_I386
 202 int win2k_install_hack = 0;
 203 #endif
 204 int usb_enabled = 0;
 205 static VLANState *first_vlan;
 206 int smp_cpus = 1;
 207 const char *vnc_display;
 208 #if defined(TARGET_SPARC)
 209 #define MAX_CPUS 16
 210 #elif defined(TARGET_I386)
 211 #define MAX_CPUS 255
 212 #else
 213 #define MAX_CPUS 1
 214 #endif
 215 int acpi_enabled = 1;
 216 int fd_bootchk = 1;
 217 int no_reboot = 0;
 218 int cursor_hide = 1;
 219 int graphic_rotate = 0;
 220 int daemonize = 0;
 221 const char *option_rom[MAX_OPTION_ROMS];
 222 int nb_option_roms;
 223 int semihosting_enabled = 0;
 224 int autostart = 1;
 225 #ifdef TARGET_ARM
 226 int old_param = 0;
 227 #endif
 228 const char *qemu_name;
 229 int alt_grab = 0;
 230 #ifdef TARGET_SPARC
 231 unsigned int nb_prom_envs = 0;
 232 const char *prom_envs[MAX_PROM_ENVS];
 233 #endif
 234 int nb_drives_opt;
 235 struct drive_opt {
 236     const char *file;
 237     char opt[1024];
 238 } drives_opt[MAX_DRIVES];
 239
 240 static CPUState *cur_cpu;
 241 static CPUState *next_cpu;
 242 static int event_pending = 1;
 243
 244 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
 245
 246 /***********************************************************/
 247 /* x86 ISA bus support */
 248
 249 target_phys_addr_t isa_mem_base = 0;
 250 PicState2 *isa_pic;
 251
 252 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
 253 {
 254 #ifdef DEBUG_UNUSED_IOPORT
 255     fprintf(stderr, "unused inb: port=0x%04x\n", address);
 256 #endif
 257     return 0xff;
 258 }
 259
 260 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
 261 {
 262 #ifdef DEBUG_UNUSED_IOPORT
 263     fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
 264 #endif
 265 }
 266
 267 /* default is to make two byte accesses */
 268 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
 269 {
 270     uint32_t data;
 271     data = ioport_read_table[0][address](ioport_opaque[address], address);
 272     address = (address + 1) & (MAX_IOPORTS - 1);
 273     data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
 274     return data;
 275 }
 276
 277 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
 278 {
 279     ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
 280     address = (address + 1) & (MAX_IOPORTS - 1);
 281     ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
 282 }
 283
 284 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
 285 {
 286 #ifdef DEBUG_UNUSED_IOPORT
 287     fprintf(stderr, "unused inl: port=0x%04x\n", address);
 288 #endif
 289     return 0xffffffff;
 290 }
 291
 292 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
 293 {
 294 #ifdef DEBUG_UNUSED_IOPORT
 295     fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
 296 #endif
 297 }
 298
 299 static void init_ioports(void)
 300 {
 301     int i;
 302
 303     for(i = 0; i < MAX_IOPORTS; i++) {
 304         ioport_read_table[0][i] = default_ioport_readb;
 305         ioport_write_table[0][i] = default_ioport_writeb;
 306         ioport_read_table[1][i] = default_ioport_readw;
 307         ioport_write_table[1][i] = default_ioport_writew;
 308         ioport_read_table[2][i] = default_ioport_readl;
 309         ioport_write_table[2][i] = default_ioport_writel;
 310     }
 311 }
 312
 313 /* size is the word size in byte */
 314 int register_ioport_read(int start, int length, int size,
 315                          IOPortReadFunc *func, void *opaque)
 316 {
 317     int i, bsize;
 318
 319     if (size == 1) {
 320         bsize = 0;
 321     } else if (size == 2) {
 322         bsize = 1;
 323     } else if (size == 4) {
 324         bsize = 2;
 325     } else {
 326         hw_error("register_ioport_read: invalid size");
 327         return -1;
 328     }
 329     for(i = start; i < start + length; i += size) {
 330         ioport_read_table[bsize][i] = func;
 331         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 332             hw_error("register_ioport_read: invalid opaque");
 333         ioport_opaque[i] = opaque;
 334     }
 335     return 0;
 336 }
 337
 338 /* size is the word size in byte */
 339 int register_ioport_write(int start, int length, int size,
 340                           IOPortWriteFunc *func, void *opaque)
 341 {
 342     int i, bsize;
 343
 344     if (size == 1) {
 345         bsize = 0;
 346     } else if (size == 2) {
 347         bsize = 1;
 348     } else if (size == 4) {
 349         bsize = 2;
 350     } else {
 351         hw_error("register_ioport_write: invalid size");
 352         return -1;
 353     }
 354     for(i = start; i < start + length; i += size) {
 355         ioport_write_table[bsize][i] = func;
 356         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 357             hw_error("register_ioport_write: invalid opaque");
 358         ioport_opaque[i] = opaque;
 359     }
 360     return 0;
 361 }
 362
 363 void isa_unassign_ioport(int start, int length)
 364 {
 365     int i;
 366
 367     for(i = start; i < start + length; i++) {
 368         ioport_read_table[0][i] = default_ioport_readb;
 369         ioport_read_table[1][i] = default_ioport_readw;
 370         ioport_read_table[2][i] = default_ioport_readl;
 371
 372         ioport_write_table[0][i] = default_ioport_writeb;
 373         ioport_write_table[1][i] = default_ioport_writew;
 374         ioport_write_table[2][i] = default_ioport_writel;
 375     }
 376 }
 377
 378 /***********************************************************/
 379
 380 void cpu_outb(CPUState *env, int addr, int val)
 381 {
 382 #ifdef DEBUG_IOPORT
 383     if (loglevel & CPU_LOG_IOPORT)
 384         fprintf(logfile, "outb: %04x %02x\n", addr, val);
 385 #endif
 386     ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
 387 #ifdef USE_KQEMU
 388     if (env)
 389         env->last_io_time = cpu_get_time_fast();
 390 #endif
 391 }
 392
 393 void cpu_outw(CPUState *env, int addr, int val)
 394 {
 395 #ifdef DEBUG_IOPORT
 396     if (loglevel & CPU_LOG_IOPORT)
 397         fprintf(logfile, "outw: %04x %04x\n", addr, val);
 398 #endif
 399     ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
 400 #ifdef USE_KQEMU
 401     if (env)
 402         env->last_io_time = cpu_get_time_fast();
 403 #endif
 404 }
 405
 406 void cpu_outl(CPUState *env, int addr, int val)
 407 {
 408 #ifdef DEBUG_IOPORT
 409     if (loglevel & CPU_LOG_IOPORT)
 410         fprintf(logfile, "outl: %04x %08x\n", addr, val);
 411 #endif
 412     ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
 413 #ifdef USE_KQEMU
 414     if (env)
 415         env->last_io_time = cpu_get_time_fast();
 416 #endif
 417 }
 418
 419 int cpu_inb(CPUState *env, int addr)
 420 {
 421     int val;
 422     val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
 423 #ifdef DEBUG_IOPORT
 424     if (loglevel & CPU_LOG_IOPORT)
 425         fprintf(logfile, "inb : %04x %02x\n", addr, val);
 426 #endif
 427 #ifdef USE_KQEMU
 428     if (env)
 429         env->last_io_time = cpu_get_time_fast();
 430 #endif
 431     return val;
 432 }
 433
 434 int cpu_inw(CPUState *env, int addr)
 435 {
 436     int val;
 437     val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
 438 #ifdef DEBUG_IOPORT
 439     if (loglevel & CPU_LOG_IOPORT)
 440         fprintf(logfile, "inw : %04x %04x\n", addr, val);
 441 #endif
 442 #ifdef USE_KQEMU
 443     if (env)
 444         env->last_io_time = cpu_get_time_fast();
 445 #endif
 446     return val;
 447 }
 448
 449 int cpu_inl(CPUState *env, int addr)
 450 {
 451     int val;
 452     val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
 453 #ifdef DEBUG_IOPORT
 454     if (loglevel & CPU_LOG_IOPORT)
 455         fprintf(logfile, "inl : %04x %08x\n", addr, val);
 456 #endif
 457 #ifdef USE_KQEMU
 458     if (env)
 459         env->last_io_time = cpu_get_time_fast();
 460 #endif
 461     return val;
 462 }
 463
 464 /***********************************************************/
 465 void hw_error(const char *fmt, ...)
 466 {
 467     va_list ap;
 468     CPUState *env;
 469
 470     va_start(ap, fmt);
 471     fprintf(stderr, "qemu: hardware error: ");
 472     vfprintf(stderr, fmt, ap);
 473     fprintf(stderr, "\n");
 474     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 475         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
 476 #ifdef TARGET_I386
 477         cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
 478 #else
 479         cpu_dump_state(env, stderr, fprintf, 0);
 480 #endif
 481     }
 482     va_end(ap);
 483     abort();
 484 }
 485
 486 /***********************************************************/
 487 /* keyboard/mouse */
 488
 489 static QEMUPutKBDEvent *qemu_put_kbd_event;
 490 static void *qemu_put_kbd_event_opaque;
 491 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
 492 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
 493
 494 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
 495 {
 496     qemu_put_kbd_event_opaque = opaque;
 497     qemu_put_kbd_event = func;
 498 }
 499
 500 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
 501                                                 void *opaque, int absolute,
 502                                                 const char *name)
 503 {
 504     QEMUPutMouseEntry *s, *cursor;
 505
 506     s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
 507     if (!s)
 508         return NULL;
 509
 510     s->qemu_put_mouse_event = func;
 511     s->qemu_put_mouse_event_opaque = opaque;
 512     s->qemu_put_mouse_event_absolute = absolute;
 513     s->qemu_put_mouse_event_name = qemu_strdup(name);
 514     s->next = NULL;
 515
 516     if (!qemu_put_mouse_event_head) {
 517         qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
 518         return s;
 519     }
 520
 521     cursor = qemu_put_mouse_event_head;
 522     while (cursor->next != NULL)
 523         cursor = cursor->next;
 524
 525     cursor->next = s;
 526     qemu_put_mouse_event_current = s;
 527
 528     return s;
 529 }
 530
 531 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
 532 {
 533     QEMUPutMouseEntry *prev = NULL, *cursor;
 534
 535     if (!qemu_put_mouse_event_head || entry == NULL)
 536         return;
 537
 538     cursor = qemu_put_mouse_event_head;
 539     while (cursor != NULL && cursor != entry) {
 540         prev = cursor;
 541         cursor = cursor->next;
 542     }
 543
 544     if (cursor == NULL) // does not exist or list empty
 545         return;
 546     else if (prev == NULL) { // entry is head
 547         qemu_put_mouse_event_head = cursor->next;
 548         if (qemu_put_mouse_event_current == entry)
 549             qemu_put_mouse_event_current = cursor->next;
 550         qemu_free(entry->qemu_put_mouse_event_name);
 551         qemu_free(entry);
 552         return;
 553     }
 554
 555     prev->next = entry->next;
 556
 557     if (qemu_put_mouse_event_current == entry)
 558         qemu_put_mouse_event_current = prev;
 559
 560     qemu_free(entry->qemu_put_mouse_event_name);
 561     qemu_free(entry);
 562 }
 563
 564 void kbd_put_keycode(int keycode)
 565 {
 566     if (qemu_put_kbd_event) {
 567         qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
 568     }
 569 }
 570
 571 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
 572 {
 573     QEMUPutMouseEvent *mouse_event;
 574     void *mouse_event_opaque;
 575     int width;
 576
 577     if (!qemu_put_mouse_event_current) {
 578         return;
 579     }
 580
 581     mouse_event =
 582         qemu_put_mouse_event_current->qemu_put_mouse_event;
 583     mouse_event_opaque =
 584         qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
 585
 586     if (mouse_event) {
 587         if (graphic_rotate) {
 588             if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
 589                 width = 0x7fff;
 590             else
 591                 width = graphic_width;
 592             mouse_event(mouse_event_opaque,
 593                                  width - dy, dx, dz, buttons_state);
 594         } else
 595             mouse_event(mouse_event_opaque,
 596                                  dx, dy, dz, buttons_state);
 597     }
 598 }
 599
 600 int kbd_mouse_is_absolute(void)
 601 {
 602     if (!qemu_put_mouse_event_current)
 603         return 0;
 604
 605     return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
 606 }
 607
 608 void do_info_mice(void)
 609 {
 610     QEMUPutMouseEntry *cursor;
 611     int index = 0;
 612
 613     if (!qemu_put_mouse_event_head) {
 614         term_printf("No mouse devices connected\n");
 615         return;
 616     }
 617
 618     term_printf("Mouse devices available:\n");
 619     cursor = qemu_put_mouse_event_head;
 620     while (cursor != NULL) {
 621         term_printf("%c Mouse #%d: %s\n",
 622                     (cursor == qemu_put_mouse_event_current ? '*' : ' '),
 623                     index, cursor->qemu_put_mouse_event_name);
 624         index++;
 625         cursor = cursor->next;
 626     }
 627 }
 628
 629 void do_mouse_set(int index)
 630 {
 631     QEMUPutMouseEntry *cursor;
 632     int i = 0;
 633
 634     if (!qemu_put_mouse_event_head) {
 635         term_printf("No mouse devices connected\n");
 636         return;
 637     }
 638
 639     cursor = qemu_put_mouse_event_head;
 640     while (cursor != NULL && index != i) {
 641         i++;
 642         cursor = cursor->next;
 643     }
 644
 645     if (cursor != NULL)
 646         qemu_put_mouse_event_current = cursor;
 647     else
 648         term_printf("Mouse at given index not found\n");
 649 }
 650
 651 /* compute with 96 bit intermediate result: (a*b)/c */
 652 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 653 {
 654     union {
 655         uint64_t ll;
 656         struct {
 657 #ifdef WORDS_BIGENDIAN
 658             uint32_t high, low;
 659 #else
 660             uint32_t low, high;
 661 #endif
 662         } l;
 663     } u, res;
 664     uint64_t rl, rh;
 665
 666     u.ll = a;
 667     rl = (uint64_t)u.l.low * (uint64_t)b;
 668     rh = (uint64_t)u.l.high * (uint64_t)b;
 669     rh += (rl >> 32);
 670     res.l.high = rh / c;
 671     res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
 672     return res.ll;
 673 }
 674
 675 /***********************************************************/
 676 /* real time host monotonic timer */
 677
 678 #define QEMU_TIMER_BASE 1000000000LL
 679
 680 #ifdef WIN32
 681
 682 static int64_t clock_freq;
 683
 684 static void init_get_clock(void)
 685 {
 686     LARGE_INTEGER freq;
 687     int ret;
 688     ret = QueryPerformanceFrequency(&freq);
 689     if (ret == 0) {
 690         fprintf(stderr, "Could not calibrate ticks\n");
 691         exit(1);
 692     }
 693     clock_freq = freq.QuadPart;
 694 }
 695
 696 static int64_t get_clock(void)
 697 {
 698     LARGE_INTEGER ti;
 699     QueryPerformanceCounter(&ti);
 700     return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
 701 }
 702
 703 #else
 704
 705 static int use_rt_clock;
 706
 707 static void init_get_clock(void)
 708 {
 709     use_rt_clock = 0;
 710 #if defined(__linux__)
 711     {
 712         struct timespec ts;
 713         if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
 714             use_rt_clock = 1;
 715         }
 716     }
 717 #endif
 718 }
 719
 720 static int64_t get_clock(void)
 721 {
 722 #if defined(__linux__)
 723     if (use_rt_clock) {
 724         struct timespec ts;
 725         clock_gettime(CLOCK_MONOTONIC, &ts);
 726         return ts.tv_sec * 1000000000LL + ts.tv_nsec;
 727     } else
 728 #endif
 729     {
 730         /* XXX: using gettimeofday leads to problems if the date
 731            changes, so it should be avoided. */
 732         struct timeval tv;
 733         gettimeofday(&tv, NULL);
 734         return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
 735     }
 736 }
 737
 738 #endif
 739
 740 /***********************************************************/
 741 /* guest cycle counter */
 742
 743 static int64_t cpu_ticks_prev;
 744 static int64_t cpu_ticks_offset;
 745 static int64_t cpu_clock_offset;
 746 static int cpu_ticks_enabled;
 747
 748 /* return the host CPU cycle counter and handle stop/restart */
 749 int64_t cpu_get_ticks(void)
 750 {
 751     if (!cpu_ticks_enabled) {
 752         return cpu_ticks_offset;
 753     } else {
 754         int64_t ticks;
 755         ticks = cpu_get_real_ticks();
 756         if (cpu_ticks_prev > ticks) {
 757             /* Note: non increasing ticks may happen if the host uses
 758                software suspend */
 759             cpu_ticks_offset += cpu_ticks_prev - ticks;
 760         }
 761         cpu_ticks_prev = ticks;
 762         return ticks + cpu_ticks_offset;
 763     }
 764 }
 765
 766 /* return the host CPU monotonic timer and handle stop/restart */
 767 static int64_t cpu_get_clock(void)
 768 {
 769     int64_t ti;
 770     if (!cpu_ticks_enabled) {
 771         return cpu_clock_offset;
 772     } else {
 773         ti = get_clock();
 774         return ti + cpu_clock_offset;
 775     }
 776 }
 777
 778 /* enable cpu_get_ticks() */
 779 void cpu_enable_ticks(void)
 780 {
 781     if (!cpu_ticks_enabled) {
 782         cpu_ticks_offset -= cpu_get_real_ticks();
 783         cpu_clock_offset -= get_clock();
 784         cpu_ticks_enabled = 1;
 785     }
 786 }
 787
 788 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 789    cpu_get_ticks() after that.  */
 790 void cpu_disable_ticks(void)
 791 {
 792     if (cpu_ticks_enabled) {
 793         cpu_ticks_offset = cpu_get_ticks();
 794         cpu_clock_offset = cpu_get_clock();
 795         cpu_ticks_enabled = 0;
 796     }
 797 }
 798
 799 /***********************************************************/
 800 /* timers */
 801
 802 #define QEMU_TIMER_REALTIME 0
 803 #define QEMU_TIMER_VIRTUAL  1
 804
 805 struct QEMUClock {
 806     int type;
 807     /* XXX: add frequency */
 808 };
 809
 810 struct QEMUTimer {
 811     QEMUClock *clock;
 812     int64_t expire_time;
 813     QEMUTimerCB *cb;
 814     void *opaque;
 815     struct QEMUTimer *next;
 816 };
 817
 818 struct qemu_alarm_timer {
 819     char const *name;
 820     unsigned int flags;
 821
 822     int (*start)(struct qemu_alarm_timer *t);
 823     void (*stop)(struct qemu_alarm_timer *t);
 824     void (*rearm)(struct qemu_alarm_timer *t);
 825     void *priv;
 826 };
 827
 828 #define ALARM_FLAG_DYNTICKS  0x1
 829 #define ALARM_FLAG_EXPIRED   0x2
 830
 831 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
 832 {
 833     return t->flags & ALARM_FLAG_DYNTICKS;
 834 }
 835
 836 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
 837 {
 838     if (!alarm_has_dynticks(t))
 839         return;
 840
 841     t->rearm(t);
 842 }
 843
 844 /* TODO: MIN_TIMER_REARM_US should be optimized */
 845 #define MIN_TIMER_REARM_US 250
 846
 847 static struct qemu_alarm_timer *alarm_timer;
 848
 849 #ifdef _WIN32
 850
 851 struct qemu_alarm_win32 {
 852     MMRESULT timerId;
 853     HANDLE host_alarm;
 854     unsigned int period;
 855 } alarm_win32_data = {0, NULL, -1};
 856
 857 static int win32_start_timer(struct qemu_alarm_timer *t);
 858 static void win32_stop_timer(struct qemu_alarm_timer *t);
 859 static void win32_rearm_timer(struct qemu_alarm_timer *t);
 860
 861 #else
 862
 863 static int unix_start_timer(struct qemu_alarm_timer *t);
 864 static void unix_stop_timer(struct qemu_alarm_timer *t);
 865
 866 #ifdef __linux__
 867
 868 static int dynticks_start_timer(struct qemu_alarm_timer *t);
 869 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
 870 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
 871
 872 static int hpet_start_timer(struct qemu_alarm_timer *t);
 873 static void hpet_stop_timer(struct qemu_alarm_timer *t);
 874
 875 static int rtc_start_timer(struct qemu_alarm_timer *t);
 876 static void rtc_stop_timer(struct qemu_alarm_timer *t);
 877
 878 #endif /* __linux__ */
 879
 880 #endif /* _WIN32 */
 881
 882 static struct qemu_alarm_timer alarm_timers[] = {
 883 #ifndef _WIN32
 884 #ifdef __linux__
 885     {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
 886      dynticks_stop_timer, dynticks_rearm_timer, NULL},
 887     /* HPET - if available - is preferred */
 888     {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
 889     /* ...otherwise try RTC */
 890     {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
 891 #endif
 892     {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
 893 #else
 894     {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
 895      win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
 896     {"win32", 0, win32_start_timer,
 897      win32_stop_timer, NULL, &alarm_win32_data},
 898 #endif
 899     {NULL, }
 900 };
 901
 902 static void show_available_alarms()
 903 {
 904     int i;
 905
 906     printf("Available alarm timers, in order of precedence:\n");
 907     for (i = 0; alarm_timers[i].name; i++)
 908         printf("%s\n", alarm_timers[i].name);
 909 }
 910
 911 static void configure_alarms(char const *opt)
 912 {
 913     int i;
 914     int cur = 0;
 915     int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
 916     char *arg;
 917     char *name;
 918
 919     if (!strcmp(opt, "help")) {
 920         show_available_alarms();
 921         exit(0);
 922     }
 923
 924     arg = strdup(opt);
 925
 926     /* Reorder the array */
 927     name = strtok(arg, ",");
 928     while (name) {
 929         struct qemu_alarm_timer tmp;
 930
 931         for (i = 0; i < count && alarm_timers[i].name; i++) {
 932             if (!strcmp(alarm_timers[i].name, name))
 933                 break;
 934         }
 935
 936         if (i == count) {
 937             fprintf(stderr, "Unknown clock %s\n", name);
 938             goto next;
 939         }
 940
 941         if (i < cur)
 942             /* Ignore */
 943             goto next;
 944
 945         /* Swap */
 946         tmp = alarm_timers[i];
 947         alarm_timers[i] = alarm_timers[cur];
 948         alarm_timers[cur] = tmp;
 949
 950         cur++;
 951 next:
 952         name = strtok(NULL, ",");
 953     }
 954
 955     free(arg);
 956
 957     if (cur) {
 958         /* Disable remaining timers */
 959         for (i = cur; i < count; i++)
 960             alarm_timers[i].name = NULL;
 961     }
 962
 963     /* debug */
 964     show_available_alarms();
 965 }
 966
 967 QEMUClock *rt_clock;
 968 QEMUClock *vm_clock;
 969
 970 static QEMUTimer *active_timers[2];
 971
 972 static QEMUClock *qemu_new_clock(int type)
 973 {
 974     QEMUClock *clock;
 975     clock = qemu_mallocz(sizeof(QEMUClock));
 976     if (!clock)
 977         return NULL;
 978     clock->type = type;
 979     return clock;
 980 }
 981
 982 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
 983 {
 984     QEMUTimer *ts;
 985
 986     ts = qemu_mallocz(sizeof(QEMUTimer));
 987     ts->clock = clock;
 988     ts->cb = cb;
 989     ts->opaque = opaque;
 990     return ts;
 991 }
 992
 993 void qemu_free_timer(QEMUTimer *ts)
 994 {
 995     qemu_free(ts);
 996 }
 997
 998 /* stop a timer, but do not dealloc it */
 999 void qemu_del_timer(QEMUTimer *ts)
1000 {
1001     QEMUTimer **pt, *t;
1002
1003     /* NOTE: this code must be signal safe because
1004        qemu_timer_expired() can be called from a signal. */
1005     pt = &active_timers[ts->clock->type];
1006     for(;;) {
1007         t = *pt;
1008         if (!t)
1009             break;
1010         if (t == ts) {
1011             *pt = t->next;
1012             break;
1013         }
1014         pt = &t->next;
1015     }
1016 }
1017
1018 /* modify the current timer so that it will be fired when current_time
1019    >= expire_time. The corresponding callback will be called. */
1020 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1021 {
1022     QEMUTimer **pt, *t;
1023
1024     qemu_del_timer(ts);
1025
1026     /* add the timer in the sorted list */
1027     /* NOTE: this code must be signal safe because
1028        qemu_timer_expired() can be called from a signal. */
1029     pt = &active_timers[ts->clock->type];
1030     for(;;) {
1031         t = *pt;
1032         if (!t)
1033             break;
1034         if (t->expire_time > expire_time)
1035             break;
1036         pt = &t->next;
1037     }
1038     ts->expire_time = expire_time;
1039     ts->next = *pt;
1040     *pt = ts;
1041
1042     /* Rearm if necessary  */
1043     if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0 &&
1044         pt == &active_timers[ts->clock->type])
1045         qemu_rearm_alarm_timer(alarm_timer);
1046 }
1047
1048 int qemu_timer_pending(QEMUTimer *ts)
1049 {
1050     QEMUTimer *t;
1051     for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1052         if (t == ts)
1053             return 1;
1054     }
1055     return 0;
1056 }
1057
1058 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1059 {
1060     if (!timer_head)
1061         return 0;
1062     return (timer_head->expire_time <= current_time);
1063 }
1064
1065 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1066 {
1067     QEMUTimer *ts;
1068
1069     for(;;) {
1070         ts = *ptimer_head;
1071         if (!ts || ts->expire_time > current_time)
1072             break;
1073         /* remove timer from the list before calling the callback */
1074         *ptimer_head = ts->next;
1075         ts->next = NULL;
1076
1077         /* run the callback (the timer list can be modified) */
1078         ts->cb(ts->opaque);
1079     }
1080 }
1081
1082 int64_t qemu_get_clock(QEMUClock *clock)
1083 {
1084     switch(clock->type) {
1085     case QEMU_TIMER_REALTIME:
1086         return get_clock() / 1000000;
1087     default:
1088     case QEMU_TIMER_VIRTUAL:
1089         return cpu_get_clock();
1090     }
1091 }
1092
1093 static void init_timers(void)
1094 {
1095     init_get_clock();
1096     ticks_per_sec = QEMU_TIMER_BASE;
1097     rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1098     vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1099 }
1100
1101 /* save a timer */
1102 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1103 {
1104     uint64_t expire_time;
1105
1106     if (qemu_timer_pending(ts)) {
1107         expire_time = ts->expire_time;
1108     } else {
1109         expire_time = -1;
1110     }
1111     qemu_put_be64(f, expire_time);
1112 }
1113
1114 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1115 {
1116     uint64_t expire_time;
1117
1118     expire_time = qemu_get_be64(f);
1119     if (expire_time != -1) {
1120         qemu_mod_timer(ts, expire_time);
1121     } else {
1122         qemu_del_timer(ts);
1123     }
1124 }
1125
1126 static void timer_save(QEMUFile *f, void *opaque)
1127 {
1128     if (cpu_ticks_enabled) {
1129         hw_error("cannot save state if virtual timers are running");
1130     }
1131     qemu_put_be64(f, cpu_ticks_offset);
1132     qemu_put_be64(f, ticks_per_sec);
1133     qemu_put_be64(f, cpu_clock_offset);
1134 }
1135
1136 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1137 {
1138     if (version_id != 1 && version_id != 2)
1139         return -EINVAL;
1140     if (cpu_ticks_enabled) {
1141         return -EINVAL;
1142     }
1143     cpu_ticks_offset=qemu_get_be64(f);
1144     ticks_per_sec=qemu_get_be64(f);
1145     if (version_id == 2) {
1146         cpu_clock_offset=qemu_get_be64(f);
1147     }
1148     return 0;
1149 }
1150
1151 #ifdef _WIN32
1152 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1153                                  DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1154 #else
1155 static void host_alarm_handler(int host_signum)
1156 #endif
1157 {
1158 #if 0
1159 #define DISP_FREQ 1000
1160     {
1161         static int64_t delta_min = INT64_MAX;
1162         static int64_t delta_max, delta_cum, last_clock, delta, ti;
1163         static int count;
1164         ti = qemu_get_clock(vm_clock);
1165         if (last_clock != 0) {
1166             delta = ti - last_clock;
1167             if (delta < delta_min)
1168                 delta_min = delta;
1169             if (delta > delta_max)
1170                 delta_max = delta;
1171             delta_cum += delta;
1172             if (++count == DISP_FREQ) {
1173                 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1174                        muldiv64(delta_min, 1000000, ticks_per_sec),
1175                        muldiv64(delta_max, 1000000, ticks_per_sec),
1176                        muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1177                        (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1178                 count = 0;
1179                 delta_min = INT64_MAX;
1180                 delta_max = 0;
1181                 delta_cum = 0;
1182             }
1183         }
1184         last_clock = ti;
1185     }
1186 #endif
1187     if (alarm_has_dynticks(alarm_timer) ||
1188         qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1189                            qemu_get_clock(vm_clock)) ||
1190         qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1191                            qemu_get_clock(rt_clock))) {
1192 #ifdef _WIN32
1193         struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1194         SetEvent(data->host_alarm);
1195 #endif
1196         CPUState *env = next_cpu;
1197
1198         alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1199
1200         if (env) {
1201             /* stop the currently executing cpu because a timer occured */
1202             cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1203 #ifdef USE_KQEMU
1204             if (env->kqemu_enabled) {
1205                 kqemu_cpu_interrupt(env);
1206             }
1207 #endif
1208         }
1209         event_pending = 1;
1210     }
1211 }
1212
1213 static uint64_t qemu_next_deadline(void)
1214 {
1215     int64_t nearest_delta_us = INT64_MAX;
1216     int64_t vmdelta_us;
1217
1218     if (active_timers[QEMU_TIMER_REALTIME])
1219         nearest_delta_us = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1220                             qemu_get_clock(rt_clock))*1000;
1221
1222     if (active_timers[QEMU_TIMER_VIRTUAL]) {
1223         /* round up */
1224         vmdelta_us = (active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1225                       qemu_get_clock(vm_clock)+999)/1000;
1226         if (vmdelta_us < nearest_delta_us)
1227             nearest_delta_us = vmdelta_us;
1228     }
1229
1230     /* Avoid arming the timer to negative, zero, or too low values */
1231     if (nearest_delta_us <= MIN_TIMER_REARM_US)
1232         nearest_delta_us = MIN_TIMER_REARM_US;
1233
1234     return nearest_delta_us;
1235 }
1236
1237 #ifndef _WIN32
1238
1239 #if defined(__linux__)
1240
1241 #define RTC_FREQ 1024
1242
1243 static void enable_sigio_timer(int fd)
1244 {
1245     struct sigaction act;
1246
1247     /* timer signal */
1248     sigfillset(&act.sa_mask);
1249     act.sa_flags = 0;
1250     act.sa_handler = host_alarm_handler;
1251
1252     sigaction(SIGIO, &act, NULL);
1253     fcntl(fd, F_SETFL, O_ASYNC);
1254     fcntl(fd, F_SETOWN, getpid());
1255 }
1256
1257 static int hpet_start_timer(struct qemu_alarm_timer *t)
1258 {
1259     struct hpet_info info;
1260     int r, fd;
1261
1262     fd = open("/dev/hpet", O_RDONLY);
1263     if (fd < 0)
1264         return -1;
1265
1266     /* Set frequency */
1267     r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1268     if (r < 0) {
1269         fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1270                 "error, but for better emulation accuracy type:\n"
1271                 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1272         goto fail;
1273     }
1274
1275     /* Check capabilities */
1276     r = ioctl(fd, HPET_INFO, &info);
1277     if (r < 0)
1278         goto fail;
1279
1280     /* Enable periodic mode */
1281     r = ioctl(fd, HPET_EPI, 0);
1282     if (info.hi_flags && (r < 0))
1283         goto fail;
1284
1285     /* Enable interrupt */
1286     r = ioctl(fd, HPET_IE_ON, 0);
1287     if (r < 0)
1288         goto fail;
1289
1290     enable_sigio_timer(fd);
1291     t->priv = (void *)(long)fd;
1292
1293     return 0;
1294 fail:
1295     close(fd);
1296     return -1;
1297 }
1298
1299 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1300 {
1301     int fd = (long)t->priv;
1302
1303     close(fd);
1304 }
1305
1306 static int rtc_start_timer(struct qemu_alarm_timer *t)
1307 {
1308     int rtc_fd;
1309     unsigned long current_rtc_freq = 0;
1310
1311     TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1312     if (rtc_fd < 0)
1313         return -1;
1314     ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1315     if (current_rtc_freq != RTC_FREQ &&
1316         ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1317         fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1318                 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1319                 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1320         goto fail;
1321     }
1322     if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1323     fail:
1324         close(rtc_fd);
1325         return -1;
1326     }
1327
1328     enable_sigio_timer(rtc_fd);
1329
1330     t->priv = (void *)(long)rtc_fd;
1331
1332     return 0;
1333 }
1334
1335 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1336 {
1337     int rtc_fd = (long)t->priv;
1338
1339     close(rtc_fd);
1340 }
1341
1342 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1343 {
1344     struct sigevent ev;
1345     timer_t host_timer;
1346     struct sigaction act;
1347
1348     sigfillset(&act.sa_mask);
1349     act.sa_flags = 0;
1350     act.sa_handler = host_alarm_handler;
1351
1352     sigaction(SIGALRM, &act, NULL);
1353
1354     ev.sigev_value.sival_int = 0;
1355     ev.sigev_notify = SIGEV_SIGNAL;
1356     ev.sigev_signo = SIGALRM;
1357
1358     if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1359         perror("timer_create");
1360
1361         /* disable dynticks */
1362         fprintf(stderr, "Dynamic Ticks disabled\n");
1363
1364         return -1;
1365     }
1366
1367     t->priv = (void *)host_timer;
1368
1369     return 0;
1370 }
1371
1372 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1373 {
1374     timer_t host_timer = (timer_t)t->priv;
1375
1376     timer_delete(host_timer);
1377 }
1378
1379 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1380 {
1381     timer_t host_timer = (timer_t)t->priv;
1382     struct itimerspec timeout;
1383     int64_t nearest_delta_us = INT64_MAX;
1384     int64_t current_us;
1385
1386     if (!active_timers[QEMU_TIMER_REALTIME] &&
1387                 !active_timers[QEMU_TIMER_VIRTUAL])
1388         return;
1389
1390     nearest_delta_us = qemu_next_deadline();
1391
1392     /* check whether a timer is already running */
1393     if (timer_gettime(host_timer, &timeout)) {
1394         perror("gettime");
1395         fprintf(stderr, "Internal timer error: aborting\n");
1396         exit(1);
1397     }
1398     current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1399     if (current_us && current_us <= nearest_delta_us)
1400         return;
1401
1402     timeout.it_interval.tv_sec = 0;
1403     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1404     timeout.it_value.tv_sec =  nearest_delta_us / 1000000;
1405     timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1406     if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1407         perror("settime");
1408         fprintf(stderr, "Internal timer error: aborting\n");
1409         exit(1);
1410     }
1411 }
1412
1413 #endif /* defined(__linux__) */
1414
1415 static int unix_start_timer(struct qemu_alarm_timer *t)
1416 {
1417     struct sigaction act;
1418     struct itimerval itv;
1419     int err;
1420
1421     /* timer signal */
1422     sigfillset(&act.sa_mask);
1423     act.sa_flags = 0;
1424     act.sa_handler = host_alarm_handler;
1425
1426     sigaction(SIGALRM, &act, NULL);
1427
1428     itv.it_interval.tv_sec = 0;
1429     /* for i386 kernel 2.6 to get 1 ms */
1430     itv.it_interval.tv_usec = 999;
1431     itv.it_value.tv_sec = 0;
1432     itv.it_value.tv_usec = 10 * 1000;
1433
1434     err = setitimer(ITIMER_REAL, &itv, NULL);
1435     if (err)
1436         return -1;
1437
1438     return 0;
1439 }
1440
1441 static void unix_stop_timer(struct qemu_alarm_timer *t)
1442 {
1443     struct itimerval itv;
1444
1445     memset(&itv, 0, sizeof(itv));
1446     setitimer(ITIMER_REAL, &itv, NULL);
1447 }
1448
1449 #endif /* !defined(_WIN32) */
1450
1451 #ifdef _WIN32
1452
1453 static int win32_start_timer(struct qemu_alarm_timer *t)
1454 {
1455     TIMECAPS tc;
1456     struct qemu_alarm_win32 *data = t->priv;
1457     UINT flags;
1458
1459     data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1460     if (!data->host_alarm) {
1461         perror("Failed CreateEvent");
1462         return -1;
1463     }
1464
1465     memset(&tc, 0, sizeof(tc));
1466     timeGetDevCaps(&tc, sizeof(tc));
1467
1468     if (data->period < tc.wPeriodMin)
1469         data->period = tc.wPeriodMin;
1470
1471     timeBeginPeriod(data->period);
1472
1473     flags = TIME_CALLBACK_FUNCTION;
1474     if (alarm_has_dynticks(t))
1475         flags |= TIME_ONESHOT;
1476     else
1477         flags |= TIME_PERIODIC;
1478
1479     data->timerId = timeSetEvent(1,         // interval (ms)
1480                         data->period,       // resolution
1481                         host_alarm_handler, // function
1482                         (DWORD)t,           // parameter
1483                         flags);
1484
1485     if (!data->timerId) {
1486         perror("Failed to initialize win32 alarm timer");
1487
1488         timeEndPeriod(data->period);
1489         CloseHandle(data->host_alarm);
1490         return -1;
1491     }
1492
1493     qemu_add_wait_object(data->host_alarm, NULL, NULL);
1494
1495     return 0;
1496 }
1497
1498 static void win32_stop_timer(struct qemu_alarm_timer *t)
1499 {
1500     struct qemu_alarm_win32 *data = t->priv;
1501
1502     timeKillEvent(data->timerId);
1503     timeEndPeriod(data->period);
1504
1505     CloseHandle(data->host_alarm);
1506 }
1507
1508 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1509 {
1510     struct qemu_alarm_win32 *data = t->priv;
1511     uint64_t nearest_delta_us;
1512
1513     if (!active_timers[QEMU_TIMER_REALTIME] &&
1514                 !active_timers[QEMU_TIMER_VIRTUAL])
1515         return;
1516
1517     nearest_delta_us = qemu_next_deadline();
1518     nearest_delta_us /= 1000;
1519
1520     timeKillEvent(data->timerId);
1521
1522     data->timerId = timeSetEvent(1,
1523                         data->period,
1524                         host_alarm_handler,
1525                         (DWORD)t,
1526                         TIME_ONESHOT | TIME_PERIODIC);
1527
1528     if (!data->timerId) {
1529         perror("Failed to re-arm win32 alarm timer");
1530
1531         timeEndPeriod(data->period);
1532         CloseHandle(data->host_alarm);
1533         exit(1);
1534     }
1535 }
1536
1537 #endif /* _WIN32 */
1538
1539 static void init_timer_alarm(void)
1540 {
1541     struct qemu_alarm_timer *t;
1542     int i, err = -1;
1543
1544     for (i = 0; alarm_timers[i].name; i++) {
1545         t = &alarm_timers[i];
1546
1547         err = t->start(t);
1548         if (!err)
1549             break;
1550     }
1551
1552     if (err) {
1553         fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1554         fprintf(stderr, "Terminating\n");
1555         exit(1);
1556     }
1557
1558     alarm_timer = t;
1559 }
1560
1561 static void quit_timers(void)
1562 {
1563     alarm_timer->stop(alarm_timer);
1564     alarm_timer = NULL;
1565 }
1566
1567 /***********************************************************/
1568 /* host time/date access */
1569 void qemu_get_timedate(struct tm *tm, int offset)
1570 {
1571     time_t ti;
1572     struct tm *ret;
1573
1574     time(&ti);
1575     ti += offset;
1576     if (rtc_date_offset == -1) {
1577         if (rtc_utc)
1578             ret = gmtime(&ti);
1579         else
1580             ret = localtime(&ti);
1581     } else {
1582         ti -= rtc_date_offset;
1583         ret = gmtime(&ti);
1584     }
1585
1586     memcpy(tm, ret, sizeof(struct tm));
1587 }
1588
1589 int qemu_timedate_diff(struct tm *tm)
1590 {
1591     time_t seconds;
1592
1593     if (rtc_date_offset == -1)
1594         if (rtc_utc)
1595             seconds = mktimegm(tm);
1596         else
1597             seconds = mktime(tm);
1598     else
1599         seconds = mktimegm(tm) + rtc_date_offset;
1600
1601     return seconds - time(NULL);
1602 }
1603
1604 /***********************************************************/
1605 /* character device */
1606
1607 static void qemu_chr_event(CharDriverState *s, int event)
1608 {
1609     if (!s->chr_event)
1610         return;
1611     s->chr_event(s->handler_opaque, event);
1612 }
1613
1614 static void qemu_chr_reset_bh(void *opaque)
1615 {
1616     CharDriverState *s = opaque;
1617     qemu_chr_event(s, CHR_EVENT_RESET);
1618     qemu_bh_delete(s->bh);
1619     s->bh = NULL;
1620 }
1621
1622 void qemu_chr_reset(CharDriverState *s)
1623 {
1624     if (s->bh == NULL) {
1625         s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1626         qemu_bh_schedule(s->bh);
1627     }
1628 }
1629
1630 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1631 {
1632     return s->chr_write(s, buf, len);
1633 }
1634
1635 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1636 {
1637     if (!s->chr_ioctl)
1638         return -ENOTSUP;
1639     return s->chr_ioctl(s, cmd, arg);
1640 }
1641
1642 int qemu_chr_can_read(CharDriverState *s)
1643 {
1644     if (!s->chr_can_read)
1645         return 0;
1646     return s->chr_can_read(s->handler_opaque);
1647 }
1648
1649 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1650 {
1651     s->chr_read(s->handler_opaque, buf, len);
1652 }
1653
1654 void qemu_chr_accept_input(CharDriverState *s)
1655 {
1656     if (s->chr_accept_input)
1657         s->chr_accept_input(s);
1658 }
1659
1660 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1661 {
1662     char buf[4096];
1663     va_list ap;
1664     va_start(ap, fmt);
1665     vsnprintf(buf, sizeof(buf), fmt, ap);
1666     qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1667     va_end(ap);
1668 }
1669
1670 void qemu_chr_send_event(CharDriverState *s, int event)
1671 {
1672     if (s->chr_send_event)
1673         s->chr_send_event(s, event);
1674 }
1675
1676 void qemu_chr_add_handlers(CharDriverState *s,
1677                            IOCanRWHandler *fd_can_read,
1678                            IOReadHandler *fd_read,
1679                            IOEventHandler *fd_event,
1680                            void *opaque)
1681 {
1682     s->chr_can_read = fd_can_read;
1683     s->chr_read = fd_read;
1684     s->chr_event = fd_event;
1685     s->handler_opaque = opaque;
1686     if (s->chr_update_read_handler)
1687         s->chr_update_read_handler(s);
1688 }
1689
1690 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1691 {
1692     return len;
1693 }
1694
1695 static CharDriverState *qemu_chr_open_null(void)
1696 {
1697     CharDriverState *chr;
1698
1699     chr = qemu_mallocz(sizeof(CharDriverState));
1700     if (!chr)
1701         return NULL;
1702     chr->chr_write = null_chr_write;
1703     return chr;
1704 }
1705
1706 /* MUX driver for serial I/O splitting */
1707 static int term_timestamps;
1708 static int64_t term_timestamps_start;
1709 #define MAX_MUX 4
1710 #define MUX_BUFFER_SIZE 32      /* Must be a power of 2.  */
1711 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1712 typedef struct {
1713     IOCanRWHandler *chr_can_read[MAX_MUX];
1714     IOReadHandler *chr_read[MAX_MUX];
1715     IOEventHandler *chr_event[MAX_MUX];
1716     void *ext_opaque[MAX_MUX];
1717     CharDriverState *drv;
1718     unsigned char buffer[MUX_BUFFER_SIZE];
1719     int prod;
1720     int cons;
1721     int mux_cnt;
1722     int term_got_escape;
1723     int max_size;
1724 } MuxDriver;
1725
1726
1727 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1728 {
1729     MuxDriver *d = chr->opaque;
1730     int ret;
1731     if (!term_timestamps) {
1732         ret = d->drv->chr_write(d->drv, buf, len);
1733     } else {
1734         int i;
1735
1736         ret = 0;
1737         for(i = 0; i < len; i++) {
1738             ret += d->drv->chr_write(d->drv, buf+i, 1);
1739             if (buf[i] == '\n') {
1740                 char buf1[64];
1741                 int64_t ti;
1742                 int secs;
1743
1744                 ti = get_clock();
1745                 if (term_timestamps_start == -1)
1746                     term_timestamps_start = ti;
1747                 ti -= term_timestamps_start;
1748                 secs = ti / 1000000000;
1749                 snprintf(buf1, sizeof(buf1),
1750                          "[%02d:%02d:%02d.%03d] ",
1751                          secs / 3600,
1752                          (secs / 60) % 60,
1753                          secs % 60,
1754                          (int)((ti / 1000000) % 1000));
1755                 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1756             }
1757         }
1758     }
1759     return ret;
1760 }
1761
1762 static char *mux_help[] = {
1763     "% h    print this help\n\r",
1764     "% x    exit emulator\n\r",
1765     "% s    save disk data back to file (if -snapshot)\n\r",
1766     "% t    toggle console timestamps\n\r"
1767     "% b    send break (magic sysrq)\n\r",
1768     "% c    switch between console and monitor\n\r",
1769     "% %  sends %\n\r",
1770     NULL
1771 };
1772
1773 static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1774 static void mux_print_help(CharDriverState *chr)
1775 {
1776     int i, j;
1777     char ebuf[15] = "Escape-Char";
1778     char cbuf[50] = "\n\r";
1779
1780     if (term_escape_char > 0 && term_escape_char < 26) {
1781         sprintf(cbuf,"\n\r");
1782         sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1783     } else {
1784         sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1785             term_escape_char);
1786     }
1787     chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1788     for (i = 0; mux_help[i] != NULL; i++) {
1789         for (j=0; mux_help[i][j] != '\0'; j++) {
1790             if (mux_help[i][j] == '%')
1791                 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1792             else
1793                 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1794         }
1795     }
1796 }
1797
1798 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1799 {
1800     if (d->term_got_escape) {
1801         d->term_got_escape = 0;
1802         if (ch == term_escape_char)
1803             goto send_char;
1804         switch(ch) {
1805         case '?':
1806         case 'h':
1807             mux_print_help(chr);
1808             break;
1809         case 'x':
1810             {
1811                  char *term =  "QEMU: Terminated\n\r";
1812                  chr->chr_write(chr,(uint8_t *)term,strlen(term));
1813                  exit(0);
1814                  break;
1815             }
1816         case 's':
1817             {
1818                 int i;
1819                 for (i = 0; i < nb_drives; i++) {
1820                         bdrv_commit(drives_table[i].bdrv);
1821                 }
1822             }
1823             break;
1824         case 'b':
1825             qemu_chr_event(chr, CHR_EVENT_BREAK);
1826             break;
1827         case 'c':
1828             /* Switch to the next registered device */
1829             chr->focus++;
1830             if (chr->focus >= d->mux_cnt)
1831                 chr->focus = 0;
1832             break;
1833        case 't':
1834            term_timestamps = !term_timestamps;
1835            term_timestamps_start = -1;
1836            break;
1837         }
1838     } else if (ch == term_escape_char) {
1839         d->term_got_escape = 1;
1840     } else {
1841     send_char:
1842         return 1;
1843     }
1844     return 0;
1845 }
1846
1847 static void mux_chr_accept_input(CharDriverState *chr)
1848 {
1849     int m = chr->focus;
1850     MuxDriver *d = chr->opaque;
1851
1852     while (d->prod != d->cons &&
1853            d->chr_can_read[m] &&
1854            d->chr_can_read[m](d->ext_opaque[m])) {
1855         d->chr_read[m](d->ext_opaque[m],
1856                        &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
1857     }
1858 }
1859
1860 static int mux_chr_can_read(void *opaque)
1861 {
1862     CharDriverState *chr = opaque;
1863     MuxDriver *d = chr->opaque;
1864
1865     if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
1866         return 1;
1867     if (d->chr_can_read[chr->focus])
1868         return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1869     return 0;
1870 }
1871
1872 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1873 {
1874     CharDriverState *chr = opaque;
1875     MuxDriver *d = chr->opaque;
1876     int m = chr->focus;
1877     int i;
1878
1879     mux_chr_accept_input (opaque);
1880
1881     for(i = 0; i < size; i++)
1882         if (mux_proc_byte(chr, d, buf[i])) {
1883             if (d->prod == d->cons &&
1884                 d->chr_can_read[m] &&
1885                 d->chr_can_read[m](d->ext_opaque[m]))
1886                 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
1887             else
1888                 d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
1889         }
1890 }
1891
1892 static void mux_chr_event(void *opaque, int event)
1893 {
1894     CharDriverState *chr = opaque;
1895     MuxDriver *d = chr->opaque;
1896     int i;
1897
1898     /* Send the event to all registered listeners */
1899     for (i = 0; i < d->mux_cnt; i++)
1900         if (d->chr_event[i])
1901             d->chr_event[i](d->ext_opaque[i], event);
1902 }
1903
1904 static void mux_chr_update_read_handler(CharDriverState *chr)
1905 {
1906     MuxDriver *d = chr->opaque;
1907
1908     if (d->mux_cnt >= MAX_MUX) {
1909         fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
1910         return;
1911     }
1912     d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
1913     d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
1914     d->chr_read[d->mux_cnt] = chr->chr_read;
1915     d->chr_event[d->mux_cnt] = chr->chr_event;
1916     /* Fix up the real driver with mux routines */
1917     if (d->mux_cnt == 0) {
1918         qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
1919                               mux_chr_event, chr);
1920     }
1921     chr->focus = d->mux_cnt;
1922     d->mux_cnt++;
1923 }
1924
1925 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
1926 {
1927     CharDriverState *chr;
1928     MuxDriver *d;
1929
1930     chr = qemu_mallocz(sizeof(CharDriverState));
1931     if (!chr)
1932         return NULL;
1933     d = qemu_mallocz(sizeof(MuxDriver));
1934     if (!d) {
1935         free(chr);
1936         return NULL;
1937     }
1938
1939     chr->opaque = d;
1940     d->drv = drv;
1941     chr->focus = -1;
1942     chr->chr_write = mux_chr_write;
1943     chr->chr_update_read_handler = mux_chr_update_read_handler;
1944     chr->chr_accept_input = mux_chr_accept_input;
1945     return chr;
1946 }
1947
1948
1949 #ifdef _WIN32
1950
1951 static void socket_cleanup(void)
1952 {
1953     WSACleanup();
1954 }
1955
1956 static int socket_init(void)
1957 {
1958     WSADATA Data;
1959     int ret, err;
1960
1961     ret = WSAStartup(MAKEWORD(2,2), &Data);
1962     if (ret != 0) {
1963         err = WSAGetLastError();
1964         fprintf(stderr, "WSAStartup: %d\n", err);
1965         return -1;
1966     }
1967     atexit(socket_cleanup);
1968     return 0;
1969 }
1970
1971 static int send_all(int fd, const uint8_t *buf, int len1)
1972 {
1973     int ret, len;
1974
1975     len = len1;
1976     while (len > 0) {
1977         ret = send(fd, buf, len, 0);
1978         if (ret < 0) {
1979             int errno;
1980             errno = WSAGetLastError();
1981             if (errno != WSAEWOULDBLOCK) {
1982                 return -1;
1983             }
1984         } else if (ret == 0) {
1985             break;
1986         } else {
1987             buf += ret;
1988             len -= ret;
1989         }
1990     }
1991     return len1 - len;
1992 }
1993
1994 void socket_set_nonblock(int fd)
1995 {
1996     unsigned long opt = 1;
1997     ioctlsocket(fd, FIONBIO, &opt);
1998 }
1999
2000 #else
2001
2002 static int unix_write(int fd, const uint8_t *buf, int len1)
2003 {
2004     int ret, len;
2005
2006     len = len1;
2007     while (len > 0) {
2008         ret = write(fd, buf, len);
2009         if (ret < 0) {
2010             if (errno != EINTR && errno != EAGAIN)
2011                 return -1;
2012         } else if (ret == 0) {
2013             break;
2014         } else {
2015             buf += ret;
2016             len -= ret;
2017         }
2018     }
2019     return len1 - len;
2020 }
2021
2022 static inline int send_all(int fd, const uint8_t *buf, int len1)
2023 {
2024     return unix_write(fd, buf, len1);
2025 }
2026
2027 void socket_set_nonblock(int fd)
2028 {
2029     fcntl(fd, F_SETFL, O_NONBLOCK);
2030 }
2031 #endif /* !_WIN32 */
2032
2033 #ifndef _WIN32
2034
2035 typedef struct {
2036     int fd_in, fd_out;
2037     int max_size;
2038 } FDCharDriver;
2039
2040 #define STDIO_MAX_CLIENTS 1
2041 static int stdio_nb_clients = 0;
2042
2043 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2044 {
2045     FDCharDriver *s = chr->opaque;
2046     return unix_write(s->fd_out, buf, len);
2047 }
2048
2049 static int fd_chr_read_poll(void *opaque)
2050 {
2051     CharDriverState *chr = opaque;
2052     FDCharDriver *s = chr->opaque;
2053
2054     s->max_size = qemu_chr_can_read(chr);
2055     return s->max_size;
2056 }
2057
2058 static void fd_chr_read(void *opaque)
2059 {
2060     CharDriverState *chr = opaque;
2061     FDCharDriver *s = chr->opaque;
2062     int size, len;
2063     uint8_t buf[1024];
2064
2065     len = sizeof(buf);
2066     if (len > s->max_size)
2067         len = s->max_size;
2068     if (len == 0)
2069         return;
2070     size = read(s->fd_in, buf, len);
2071     if (size == 0) {
2072         /* FD has been closed. Remove it from the active list.  */
2073         qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2074         return;
2075     }
2076     if (size > 0) {
2077         qemu_chr_read(chr, buf, size);
2078     }
2079 }
2080
2081 static void fd_chr_update_read_handler(CharDriverState *chr)
2082 {
2083     FDCharDriver *s = chr->opaque;
2084
2085     if (s->fd_in >= 0) {
2086         if (nographic && s->fd_in == 0) {
2087         } else {
2088             qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2089                                  fd_chr_read, NULL, chr);
2090         }
2091     }
2092 }
2093
2094 static void fd_chr_close(struct CharDriverState *chr)
2095 {
2096     FDCharDriver *s = chr->opaque;
2097
2098     if (s->fd_in >= 0) {
2099         if (nographic && s->fd_in == 0) {
2100         } else {
2101             qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2102         }
2103     }
2104
2105     qemu_free(s);
2106 }
2107
2108 /* open a character device to a unix fd */
2109 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2110 {
2111     CharDriverState *chr;
2112     FDCharDriver *s;
2113
2114     chr = qemu_mallocz(sizeof(CharDriverState));
2115     if (!chr)
2116         return NULL;
2117     s = qemu_mallocz(sizeof(FDCharDriver));
2118     if (!s) {
2119         free(chr);
2120         return NULL;
2121     }
2122     s->fd_in = fd_in;
2123     s->fd_out = fd_out;
2124     chr->opaque = s;
2125     chr->chr_write = fd_chr_write;
2126     chr->chr_update_read_handler = fd_chr_update_read_handler;
2127     chr->chr_close = fd_chr_close;
2128
2129     qemu_chr_reset(chr);
2130
2131     return chr;
2132 }
2133
2134 static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2135 {
2136     int fd_out;
2137
2138     TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2139     if (fd_out < 0)
2140         return NULL;
2141     return qemu_chr_open_fd(-1, fd_out);
2142 }
2143
2144 static CharDriverState *qemu_chr_open_pipe(const char *filename)
2145 {
2146     int fd_in, fd_out;
2147     char filename_in[256], filename_out[256];
2148
2149     snprintf(filename_in, 256, "%s.in", filename);
2150     snprintf(filename_out, 256, "%s.out", filename);
2151     TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2152     TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2153     if (fd_in < 0 || fd_out < 0) {
2154         if (fd_in >= 0)
2155             close(fd_in);
2156         if (fd_out >= 0)
2157             close(fd_out);
2158         TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2159         if (fd_in < 0)
2160             return NULL;
2161     }
2162     return qemu_chr_open_fd(fd_in, fd_out);
2163 }
2164
2165
2166 /* for STDIO, we handle the case where several clients use it
2167    (nographic mode) */
2168
2169 #define TERM_FIFO_MAX_SIZE 1
2170
2171 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2172 static int term_fifo_size;
2173
2174 static int stdio_read_poll(void *opaque)
2175 {
2176     CharDriverState *chr = opaque;
2177
2178     /* try to flush the queue if needed */
2179     if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2180         qemu_chr_read(chr, term_fifo, 1);
2181         term_fifo_size = 0;
2182     }
2183     /* see if we can absorb more chars */
2184     if (term_fifo_size == 0)
2185         return 1;
2186     else
2187         return 0;
2188 }
2189
2190 static void stdio_read(void *opaque)
2191 {
2192     int size;
2193     uint8_t buf[1];
2194     CharDriverState *chr = opaque;
2195
2196     size = read(0, buf, 1);
2197     if (size == 0) {
2198         /* stdin has been closed. Remove it from the active list.  */
2199         qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2200         return;
2201     }
2202     if (size > 0) {
2203         if (qemu_chr_can_read(chr) > 0) {
2204             qemu_chr_read(chr, buf, 1);
2205         } else if (term_fifo_size == 0) {
2206             term_fifo[term_fifo_size++] = buf[0];
2207         }
2208     }
2209 }
2210
2211 /* init terminal so that we can grab keys */
2212 static struct termios oldtty;
2213 static int old_fd0_flags;
2214 static int term_atexit_done;
2215
2216 static void term_exit(void)
2217 {
2218     tcsetattr (0, TCSANOW, &oldtty);
2219     fcntl(0, F_SETFL, old_fd0_flags);
2220 }
2221
2222 static void term_init(void)
2223 {
2224     struct termios tty;
2225
2226     tcgetattr (0, &tty);
2227     oldtty = tty;
2228     old_fd0_flags = fcntl(0, F_GETFL);
2229
2230     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2231                           |INLCR|IGNCR|ICRNL|IXON);
2232     tty.c_oflag |= OPOST;
2233     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2234     /* if graphical mode, we allow Ctrl-C handling */
2235     if (nographic)
2236         tty.c_lflag &= ~ISIG;
2237     tty.c_cflag &= ~(CSIZE|PARENB);
2238     tty.c_cflag |= CS8;
2239     tty.c_cc[VMIN] = 1;
2240     tty.c_cc[VTIME] = 0;
2241
2242     tcsetattr (0, TCSANOW, &tty);
2243
2244     if (!term_atexit_done++)
2245         atexit(term_exit);
2246
2247     fcntl(0, F_SETFL, O_NONBLOCK);
2248 }
2249
2250 static void qemu_chr_close_stdio(struct CharDriverState *chr)
2251 {
2252     term_exit();
2253     stdio_nb_clients--;
2254     qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2255     fd_chr_close(chr);
2256 }
2257
2258 static CharDriverState *qemu_chr_open_stdio(void)
2259 {
2260     CharDriverState *chr;
2261
2262     if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2263         return NULL;
2264     chr = qemu_chr_open_fd(0, 1);
2265     chr->chr_close = qemu_chr_close_stdio;
2266     qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2267     stdio_nb_clients++;
2268     term_init();
2269
2270     return chr;
2271 }
2272
2273 #if defined(__linux__) || defined(__sun__)
2274 static CharDriverState *qemu_chr_open_pty(void)
2275 {
2276     struct termios tty;
2277     char slave_name[1024];
2278     int master_fd, slave_fd;
2279
2280 #if defined(__linux__)
2281     /* Not satisfying */
2282     if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
2283         return NULL;
2284     }
2285 #endif
2286
2287     /* Disabling local echo and line-buffered output */
2288     tcgetattr (master_fd, &tty);
2289     tty.c_lflag &= ~(ECHO|ICANON|ISIG);
2290     tty.c_cc[VMIN] = 1;
2291     tty.c_cc[VTIME] = 0;
2292     tcsetattr (master_fd, TCSAFLUSH, &tty);
2293
2294     fprintf(stderr, "char device redirected to %s\n", slave_name);
2295     return qemu_chr_open_fd(master_fd, master_fd);
2296 }
2297
2298 static void tty_serial_init(int fd, int speed,
2299                             int parity, int data_bits, int stop_bits)
2300 {
2301     struct termios tty;
2302     speed_t spd;
2303
2304 #if 0
2305     printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2306            speed, parity, data_bits, stop_bits);
2307 #endif
2308     tcgetattr (fd, &tty);
2309
2310 #define MARGIN 1.1
2311     if (speed <= 50 * MARGIN)
2312         spd = B50;
2313     else if (speed <= 75 * MARGIN)
2314         spd = B75;
2315     else if (speed <= 300 * MARGIN)
2316         spd = B300;
2317     else if (speed <= 600 * MARGIN)
2318         spd = B600;
2319     else if (speed <= 1200 * MARGIN)
2320         spd = B1200;
2321     else if (speed <= 2400 * MARGIN)
2322         spd = B2400;
2323     else if (speed <= 4800 * MARGIN)
2324         spd = B4800;
2325     else if (speed <= 9600 * MARGIN)
2326         spd = B9600;
2327     else if (speed <= 19200 * MARGIN)
2328         spd = B19200;
2329     else if (speed <= 38400 * MARGIN)
2330         spd = B38400;
2331     else if (speed <= 57600 * MARGIN)
2332         spd = B57600;
2333     else if (speed <= 115200 * MARGIN)
2334         spd = B115200;
2335     else
2336         spd = B115200;
2337
2338     cfsetispeed(&tty, spd);
2339     cfsetospeed(&tty, spd);
2340
2341     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2342                           |INLCR|IGNCR|ICRNL|IXON);
2343     tty.c_oflag |= OPOST;
2344     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2345     tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2346     switch(data_bits) {
2347     default:
2348     case 8:
2349         tty.c_cflag |= CS8;
2350         break;
2351     case 7:
2352         tty.c_cflag |= CS7;
2353         break;
2354     case 6:
2355         tty.c_cflag |= CS6;
2356         break;
2357     case 5:
2358         tty.c_cflag |= CS5;
2359         break;
2360     }
2361     switch(parity) {
2362     default:
2363     case 'N':
2364         break;
2365     case 'E':
2366         tty.c_cflag |= PARENB;
2367         break;
2368     case 'O':
2369         tty.c_cflag |= PARENB | PARODD;
2370         break;
2371     }
2372     if (stop_bits == 2)
2373         tty.c_cflag |= CSTOPB;
2374
2375     tcsetattr (fd, TCSANOW, &tty);
2376 }
2377
2378 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2379 {
2380     FDCharDriver *s = chr->opaque;
2381
2382     switch(cmd) {
2383     case CHR_IOCTL_SERIAL_SET_PARAMS:
2384         {
2385             QEMUSerialSetParams *ssp = arg;
2386             tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2387                             ssp->data_bits, ssp->stop_bits);
2388         }
2389         break;
2390     case CHR_IOCTL_SERIAL_SET_BREAK:
2391         {
2392             int enable = *(int *)arg;
2393             if (enable)
2394                 tcsendbreak(s->fd_in, 1);
2395         }
2396         break;
2397     default:
2398         return -ENOTSUP;
2399     }
2400     return 0;
2401 }
2402
2403 static CharDriverState *qemu_chr_open_tty(const char *filename)
2404 {
2405     CharDriverState *chr;
2406     int fd;
2407
2408     TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2409     fcntl(fd, F_SETFL, O_NONBLOCK);
2410     tty_serial_init(fd, 115200, 'N', 8, 1);
2411     chr = qemu_chr_open_fd(fd, fd);
2412     if (!chr) {
2413         close(fd);
2414         return NULL;
2415     }
2416     chr->chr_ioctl = tty_serial_ioctl;
2417     qemu_chr_reset(chr);
2418     return chr;
2419 }
2420 #else  /* ! __linux__ && ! __sun__ */
2421 static CharDriverState *qemu_chr_open_pty(void)
2422 {
2423     return NULL;
2424 }
2425 #endif /* __linux__ || __sun__ */
2426
2427 #if defined(__linux__)
2428 typedef struct {
2429     int fd;
2430     int mode;
2431 } ParallelCharDriver;
2432
2433 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2434 {
2435     if (s->mode != mode) {
2436         int m = mode;
2437         if (ioctl(s->fd, PPSETMODE, &m) < 0)
2438             return 0;
2439         s->mode = mode;
2440     }
2441     return 1;
2442 }
2443
2444 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2445 {
2446     ParallelCharDriver *drv = chr->opaque;
2447     int fd = drv->fd;
2448     uint8_t b;
2449
2450     switch(cmd) {
2451     case CHR_IOCTL_PP_READ_DATA:
2452         if (ioctl(fd, PPRDATA, &b) < 0)
2453             return -ENOTSUP;
2454         *(uint8_t *)arg = b;
2455         break;
2456     case CHR_IOCTL_PP_WRITE_DATA:
2457         b = *(uint8_t *)arg;
2458         if (ioctl(fd, PPWDATA, &b) < 0)
2459             return -ENOTSUP;
2460         break;
2461     case CHR_IOCTL_PP_READ_CONTROL:
2462         if (ioctl(fd, PPRCONTROL, &b) < 0)
2463             return -ENOTSUP;
2464         /* Linux gives only the lowest bits, and no way to know data
2465            direction! For better compatibility set the fixed upper
2466            bits. */
2467         *(uint8_t *)arg = b | 0xc0;
2468         break;
2469     case CHR_IOCTL_PP_WRITE_CONTROL:
2470         b = *(uint8_t *)arg;
2471         if (ioctl(fd, PPWCONTROL, &b) < 0)
2472             return -ENOTSUP;
2473         break;
2474     case CHR_IOCTL_PP_READ_STATUS:
2475         if (ioctl(fd, PPRSTATUS, &b) < 0)
2476             return -ENOTSUP;
2477         *(uint8_t *)arg = b;
2478         break;
2479     case CHR_IOCTL_PP_EPP_READ_ADDR:
2480         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2481             struct ParallelIOArg *parg = arg;
2482             int n = read(fd, parg->buffer, parg->count);
2483             if (n != parg->count) {
2484                 return -EIO;
2485             }
2486         }
2487         break;
2488     case CHR_IOCTL_PP_EPP_READ:
2489         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2490             struct ParallelIOArg *parg = arg;
2491             int n = read(fd, parg->buffer, parg->count);
2492             if (n != parg->count) {
2493                 return -EIO;
2494             }
2495         }
2496         break;
2497     case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2498         if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2499             struct ParallelIOArg *parg = arg;
2500             int n = write(fd, parg->buffer, parg->count);
2501             if (n != parg->count) {
2502                 return -EIO;
2503             }
2504         }
2505         break;
2506     case CHR_IOCTL_PP_EPP_WRITE:
2507         if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2508             struct ParallelIOArg *parg = arg;
2509             int n = write(fd, parg->buffer, parg->count);
2510             if (n != parg->count) {
2511                 return -EIO;
2512             }
2513         }
2514         break;
2515     default:
2516         return -ENOTSUP;
2517     }
2518     return 0;
2519 }
2520
2521 static void pp_close(CharDriverState *chr)
2522 {
2523     ParallelCharDriver *drv = chr->opaque;
2524     int fd = drv->fd;
2525
2526     pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2527     ioctl(fd, PPRELEASE);
2528     close(fd);
2529     qemu_free(drv);
2530 }
2531
2532 static CharDriverState *qemu_chr_open_pp(const char *filename)
2533 {
2534     CharDriverState *chr;
2535     ParallelCharDriver *drv;
2536     int fd;
2537
2538     TFR(fd = open(filename, O_RDWR));
2539     if (fd < 0)
2540         return NULL;
2541
2542     if (ioctl(fd, PPCLAIM) < 0) {
2543         close(fd);
2544         return NULL;
2545     }
2546
2547     drv = qemu_mallocz(sizeof(ParallelCharDriver));
2548     if (!drv) {
2549         close(fd);
2550         return NULL;
2551     }
2552     drv->fd = fd;
2553     drv->mode = IEEE1284_MODE_COMPAT;
2554
2555     chr = qemu_mallocz(sizeof(CharDriverState));
2556     if (!chr) {
2557         qemu_free(drv);
2558         close(fd);
2559         return NULL;
2560     }
2561     chr->chr_write = null_chr_write;
2562     chr->chr_ioctl = pp_ioctl;
2563     chr->chr_close = pp_close;
2564     chr->opaque = drv;
2565
2566     qemu_chr_reset(chr);
2567
2568     return chr;
2569 }
2570 #endif /* __linux__ */
2571
2572 #else /* _WIN32 */
2573
2574 typedef struct {
2575     int max_size;
2576     HANDLE hcom, hrecv, hsend;
2577     OVERLAPPED orecv, osend;
2578     BOOL fpipe;
2579     DWORD len;
2580 } WinCharState;
2581
2582 #define NSENDBUF 2048
2583 #define NRECVBUF 2048
2584 #define MAXCONNECT 1
2585 #define NTIMEOUT 5000
2586
2587 static int win_chr_poll(void *opaque);
2588 static int win_chr_pipe_poll(void *opaque);
2589
2590 static void win_chr_close(CharDriverState *chr)
2591 {
2592     WinCharState *s = chr->opaque;
2593
2594     if (s->hsend) {
2595         CloseHandle(s->hsend);
2596         s->hsend = NULL;
2597     }
2598     if (s->hrecv) {
2599         CloseHandle(s->hrecv);
2600         s->hrecv = NULL;
2601     }
2602     if (s->hcom) {
2603         CloseHandle(s->hcom);
2604         s->hcom = NULL;
2605     }
2606     if (s->fpipe)
2607         qemu_del_polling_cb(win_chr_pipe_poll, chr);
2608     else
2609         qemu_del_polling_cb(win_chr_poll, chr);
2610 }
2611
2612 static int win_chr_init(CharDriverState *chr, const char *filename)
2613 {
2614     WinCharState *s = chr->opaque;
2615     COMMCONFIG comcfg;
2616     COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2617     COMSTAT comstat;
2618     DWORD size;
2619     DWORD err;
2620
2621     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2622     if (!s->hsend) {
2623         fprintf(stderr, "Failed CreateEvent\n");
2624         goto fail;
2625     }
2626     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2627     if (!s->hrecv) {
2628         fprintf(stderr, "Failed CreateEvent\n");
2629         goto fail;
2630     }
2631
2632     s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2633                       OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2634     if (s->hcom == INVALID_HANDLE_VALUE) {
2635         fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2636         s->hcom = NULL;
2637         goto fail;
2638     }
2639
2640     if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2641         fprintf(stderr, "Failed SetupComm\n");
2642         goto fail;
2643     }
2644
2645     ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2646     size = sizeof(COMMCONFIG);
2647     GetDefaultCommConfig(filename, &comcfg, &size);
2648     comcfg.dcb.DCBlength = sizeof(DCB);
2649     CommConfigDialog(filename, NULL, &comcfg);
2650
2651     if (!SetCommState(s->hcom, &comcfg.dcb)) {
2652         fprintf(stderr, "Failed SetCommState\n");
2653         goto fail;
2654     }
2655
2656     if (!SetCommMask(s->hcom, EV_ERR)) {
2657         fprintf(stderr, "Failed SetCommMask\n");
2658         goto fail;
2659     }
2660
2661     cto.ReadIntervalTimeout = MAXDWORD;
2662     if (!SetCommTimeouts(s->hcom, &cto)) {
2663         fprintf(stderr, "Failed SetCommTimeouts\n");
2664         goto fail;
2665     }
2666
2667     if (!ClearCommError(s->hcom, &err, &comstat)) {
2668         fprintf(stderr, "Failed ClearCommError\n");
2669         goto fail;
2670     }
2671     qemu_add_polling_cb(win_chr_poll, chr);
2672     return 0;
2673
2674  fail:
2675     win_chr_close(chr);
2676     return -1;
2677 }
2678
2679 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2680 {
2681     WinCharState *s = chr->opaque;
2682     DWORD len, ret, size, err;
2683
2684     len = len1;
2685     ZeroMemory(&s->osend, sizeof(s->osend));
2686     s->osend.hEvent = s->hsend;
2687     while (len > 0) {
2688         if (s->hsend)
2689             ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2690         else
2691             ret = WriteFile(s->hcom, buf, len, &size, NULL);
2692         if (!ret) {
2693             err = GetLastError();
2694             if (err == ERROR_IO_PENDING) {
2695                 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2696                 if (ret) {
2697                     buf += size;
2698                     len -= size;
2699                 } else {
2700                     break;
2701                 }
2702             } else {
2703                 break;
2704             }
2705         } else {
2706             buf += size;
2707             len -= size;
2708         }
2709     }
2710     return len1 - len;
2711 }
2712
2713 static int win_chr_read_poll(CharDriverState *chr)
2714 {
2715     WinCharState *s = chr->opaque;
2716
2717     s->max_size = qemu_chr_can_read(chr);
2718     return s->max_size;
2719 }
2720
2721 static void win_chr_readfile(CharDriverState *chr)
2722 {
2723     WinCharState *s = chr->opaque;
2724     int ret, err;
2725     uint8_t buf[1024];
2726     DWORD size;
2727
2728     ZeroMemory(&s->orecv, sizeof(s->orecv));
2729     s->orecv.hEvent = s->hrecv;
2730     ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2731     if (!ret) {
2732         err = GetLastError();
2733         if (err == ERROR_IO_PENDING) {
2734             ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2735         }
2736     }
2737
2738     if (size > 0) {
2739         qemu_chr_read(chr, buf, size);
2740     }
2741 }
2742
2743 static void win_chr_read(CharDriverState *chr)
2744 {
2745     WinCharState *s = chr->opaque;
2746
2747     if (s->len > s->max_size)
2748         s->len = s->max_size;
2749     if (s->len == 0)
2750         return;
2751
2752     win_chr_readfile(chr);
2753 }
2754
2755 static int win_chr_poll(void *opaque)
2756 {
2757     CharDriverState *chr = opaque;
2758     WinCharState *s = chr->opaque;
2759     COMSTAT status;
2760     DWORD comerr;
2761
2762     ClearCommError(s->hcom, &comerr, &status);
2763     if (status.cbInQue > 0) {
2764         s->len = status.cbInQue;
2765         win_chr_read_poll(chr);
2766         win_chr_read(chr);
2767         return 1;
2768     }
2769     return 0;
2770 }
2771
2772 static CharDriverState *qemu_chr_open_win(const char *filename)
2773 {
2774     CharDriverState *chr;
2775     WinCharState *s;
2776
2777     chr = qemu_mallocz(sizeof(CharDriverState));
2778     if (!chr)
2779         return NULL;
2780     s = qemu_mallocz(sizeof(WinCharState));
2781     if (!s) {
2782         free(chr);
2783         return NULL;
2784     }
2785     chr->opaque = s;
2786     chr->chr_write = win_chr_write;
2787     chr->chr_close = win_chr_close;
2788
2789     if (win_chr_init(chr, filename) < 0) {
2790         free(s);
2791         free(chr);
2792         return NULL;
2793     }
2794     qemu_chr_reset(chr);
2795     return chr;
2796 }
2797
2798 static int win_chr_pipe_poll(void *opaque)
2799 {
2800     CharDriverState *chr = opaque;
2801     WinCharState *s = chr->opaque;
2802     DWORD size;
2803
2804     PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2805     if (size > 0) {
2806         s->len = size;
2807         win_chr_read_poll(chr);
2808         win_chr_read(chr);
2809         return 1;
2810     }
2811     return 0;
2812 }
2813
2814 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2815 {
2816     WinCharState *s = chr->opaque;
2817     OVERLAPPED ov;
2818     int ret;
2819     DWORD size;
2820     char openname[256];
2821
2822     s->fpipe = TRUE;
2823
2824     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2825     if (!s->hsend) {
2826         fprintf(stderr, "Failed CreateEvent\n");
2827         goto fail;
2828     }
2829     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2830     if (!s->hrecv) {
2831         fprintf(stderr, "Failed CreateEvent\n");
2832         goto fail;
2833     }
2834
2835     snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2836     s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2837                               PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2838                               PIPE_WAIT,
2839                               MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2840     if (s->hcom == INVALID_HANDLE_VALUE) {
2841         fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2842         s->hcom = NULL;
2843         goto fail;
2844     }
2845
2846     ZeroMemory(&ov, sizeof(ov));
2847     ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2848     ret = ConnectNamedPipe(s->hcom, &ov);
2849     if (ret) {
2850         fprintf(stderr, "Failed ConnectNamedPipe\n");
2851         goto fail;
2852     }
2853
2854     ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2855     if (!ret) {
2856         fprintf(stderr, "Failed GetOverlappedResult\n");
2857         if (ov.hEvent) {
2858             CloseHandle(ov.hEvent);
2859             ov.hEvent = NULL;
2860         }
2861         goto fail;
2862     }
2863
2864     if (ov.hEvent) {
2865         CloseHandle(ov.hEvent);
2866         ov.hEvent = NULL;
2867     }
2868     qemu_add_polling_cb(win_chr_pipe_poll, chr);
2869     return 0;
2870
2871  fail:
2872     win_chr_close(chr);
2873     return -1;
2874 }
2875
2876
2877 static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2878 {
2879     CharDriverState *chr;
2880     WinCharState *s;
2881
2882     chr = qemu_mallocz(sizeof(CharDriverState));
2883     if (!chr)
2884         return NULL;
2885     s = qemu_mallocz(sizeof(WinCharState));
2886     if (!s) {
2887         free(chr);
2888         return NULL;
2889     }
2890     chr->opaque = s;
2891     chr->chr_write = win_chr_write;
2892     chr->chr_close = win_chr_close;
2893
2894     if (win_chr_pipe_init(chr, filename) < 0) {
2895         free(s);
2896         free(chr);
2897         return NULL;
2898     }
2899     qemu_chr_reset(chr);
2900     return chr;
2901 }
2902
2903 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2904 {
2905     CharDriverState *chr;
2906     WinCharState *s;
2907
2908     chr = qemu_mallocz(sizeof(CharDriverState));
2909     if (!chr)
2910         return NULL;
2911     s = qemu_mallocz(sizeof(WinCharState));
2912     if (!s) {
2913         free(chr);
2914         return NULL;
2915     }
2916     s->hcom = fd_out;
2917     chr->opaque = s;
2918     chr->chr_write = win_chr_write;
2919     qemu_chr_reset(chr);
2920     return chr;
2921 }
2922
2923 static CharDriverState *qemu_chr_open_win_con(const char *filename)
2924 {
2925     return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
2926 }
2927
2928 static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2929 {
2930     HANDLE fd_out;
2931
2932     fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2933                         OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2934     if (fd_out == INVALID_HANDLE_VALUE)
2935         return NULL;
2936
2937     return qemu_chr_open_win_file(fd_out);
2938 }
2939 #endif /* !_WIN32 */
2940
2941 /***********************************************************/
2942 /* UDP Net console */
2943
2944 typedef struct {
2945     int fd;
2946     struct sockaddr_in daddr;
2947     uint8_t buf[1024];
2948     int bufcnt;
2949     int bufptr;
2950     int max_size;
2951 } NetCharDriver;
2952
2953 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2954 {
2955     NetCharDriver *s = chr->opaque;
2956
2957     return sendto(s->fd, buf, len, 0,
2958                   (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2959 }
2960
2961 static int udp_chr_read_poll(void *opaque)
2962 {
2963     CharDriverState *chr = opaque;
2964     NetCharDriver *s = chr->opaque;
2965
2966     s->max_size = qemu_chr_can_read(chr);
2967
2968     /* If there were any stray characters in the queue process them
2969      * first
2970      */
2971     while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2972         qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2973         s->bufptr++;
2974         s->max_size = qemu_chr_can_read(chr);
2975     }
2976     return s->max_size;
2977 }
2978
2979 static void udp_chr_read(void *opaque)
2980 {
2981     CharDriverState *chr = opaque;
2982     NetCharDriver *s = chr->opaque;
2983
2984     if (s->max_size == 0)
2985         return;
2986     s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2987     s->bufptr = s->bufcnt;
2988     if (s->bufcnt <= 0)
2989         return;
2990
2991     s->bufptr = 0;
2992     while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2993         qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2994         s->bufptr++;
2995         s->max_size = qemu_chr_can_read(chr);
2996     }
2997 }
2998
2999 static void udp_chr_update_read_handler(CharDriverState *chr)
3000 {
3001     NetCharDriver *s = chr->opaque;
3002
3003     if (s->fd >= 0) {
3004         qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3005                              udp_chr_read, NULL, chr);
3006     }
3007 }
3008
3009 int parse_host_port(struct sockaddr_in *saddr, const char *str);
3010 #ifndef _WIN32
3011 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3012 #endif
3013 int parse_host_src_port(struct sockaddr_in *haddr,
3014                         struct sockaddr_in *saddr,
3015                         const char *str);
3016
3017 static CharDriverState *qemu_chr_open_udp(const char *def)
3018 {
3019     CharDriverState *chr = NULL;
3020     NetCharDriver *s = NULL;
3021     int fd = -1;
3022     struct sockaddr_in saddr;
3023
3024     chr = qemu_mallocz(sizeof(CharDriverState));
3025     if (!chr)
3026         goto return_err;
3027     s = qemu_mallocz(sizeof(NetCharDriver));
3028     if (!s)
3029         goto return_err;
3030
3031     fd = socket(PF_INET, SOCK_DGRAM, 0);
3032     if (fd < 0) {
3033         perror("socket(PF_INET, SOCK_DGRAM)");
3034         goto return_err;
3035     }
3036
3037     if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3038         printf("Could not parse: %s\n", def);
3039         goto return_err;
3040     }
3041
3042     if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3043     {
3044         perror("bind");
3045         goto return_err;
3046     }
3047
3048     s->fd = fd;
3049     s->bufcnt = 0;
3050     s->bufptr = 0;
3051     chr->opaque = s;
3052     chr->chr_write = udp_chr_write;
3053     chr->chr_update_read_handler = udp_chr_update_read_handler;
3054     return chr;
3055
3056 return_err:
3057     if (chr)
3058         free(chr);
3059     if (s)
3060         free(s);
3061     if (fd >= 0)
3062         closesocket(fd);
3063     return NULL;
3064 }
3065
3066 /***********************************************************/
3067 /* TCP Net console */
3068
3069 typedef struct {
3070     int fd, listen_fd;
3071     int connected;
3072     int max_size;
3073     int do_telnetopt;
3074     int do_nodelay;
3075     int is_unix;
3076 } TCPCharDriver;
3077
3078 static void tcp_chr_accept(void *opaque);
3079
3080 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3081 {
3082     TCPCharDriver *s = chr->opaque;
3083     if (s->connected) {
3084         return send_all(s->fd, buf, len);
3085     } else {
3086         /* XXX: indicate an error ? */
3087         return len;
3088     }
3089 }
3090
3091 static int tcp_chr_read_poll(void *opaque)
3092 {
3093     CharDriverState *chr = opaque;
3094     TCPCharDriver *s = chr->opaque;
3095     if (!s->connected)
3096         return 0;
3097     s->max_size = qemu_chr_can_read(chr);
3098     return s->max_size;
3099 }
3100
3101 #define IAC 255
3102 #define IAC_BREAK 243
3103 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3104                                       TCPCharDriver *s,
3105                                       uint8_t *buf, int *size)
3106 {
3107     /* Handle any telnet client's basic IAC options to satisfy char by
3108      * char mode with no echo.  All IAC options will be removed from
3109      * the buf and the do_telnetopt variable will be used to track the
3110      * state of the width of the IAC information.
3111      *
3112      * IAC commands come in sets of 3 bytes with the exception of the
3113      * "IAC BREAK" command and the double IAC.
3114      */
3115
3116     int i;
3117     int j = 0;
3118
3119     for (i = 0; i < *size; i++) {
3120         if (s->do_telnetopt > 1) {
3121             if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3122                 /* Double IAC means send an IAC */
3123                 if (j != i)
3124                     buf[j] = buf[i];
3125                 j++;
3126                 s->do_telnetopt = 1;
3127             } else {
3128                 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3129                     /* Handle IAC break commands by sending a serial break */
3130                     qemu_chr_event(chr, CHR_EVENT_BREAK);
3131                     s->do_telnetopt++;
3132                 }
3133                 s->do_telnetopt++;
3134             }
3135             if (s->do_telnetopt >= 4) {
3136                 s->do_telnetopt = 1;
3137             }
3138         } else {
3139             if ((unsigned char)buf[i] == IAC) {
3140                 s->do_telnetopt = 2;
3141             } else {
3142                 if (j != i)
3143                     buf[j] = buf[i];
3144                 j++;
3145             }
3146         }
3147     }
3148     *size = j;
3149 }
3150
3151 static void tcp_chr_read(void *opaque)
3152 {
3153     CharDriverState *chr = opaque;
3154     TCPCharDriver *s = chr->opaque;
3155     uint8_t buf[1024];
3156     int len, size;
3157
3158     if (!s->connected || s->max_size <= 0)
3159         return;
3160     len = sizeof(buf);
3161     if (len > s->max_size)
3162         len = s->max_size;
3163     size = recv(s->fd, buf, len, 0);
3164     if (size == 0) {
3165         /* connection closed */
3166         s->connected = 0;
3167         if (s->listen_fd >= 0) {
3168             qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3169         }
3170         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3171         closesocket(s->fd);
3172         s->fd = -1;
3173     } else if (size > 0) {
3174         if (s->do_telnetopt)
3175             tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3176         if (size > 0)
3177             qemu_chr_read(chr, buf, size);
3178     }
3179 }
3180
3181 static void tcp_chr_connect(void *opaque)
3182 {
3183     CharDriverState *chr = opaque;
3184     TCPCharDriver *s = chr->opaque;
3185
3186     s->connected = 1;
3187     qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3188                          tcp_chr_read, NULL, chr);
3189     qemu_chr_reset(chr);
3190 }
3191
3192 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3193 static void tcp_chr_telnet_init(int fd)
3194 {
3195     char buf[3];
3196     /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3197     IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
3198     send(fd, (char *)buf, 3, 0);
3199     IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
3200     send(fd, (char *)buf, 3, 0);
3201     IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
3202     send(fd, (char *)buf, 3, 0);
3203     IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
3204     send(fd, (char *)buf, 3, 0);
3205 }
3206
3207 static void socket_set_nodelay(int fd)
3208 {
3209     int val = 1;
3210     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3211 }
3212
3213 static void tcp_chr_accept(void *opaque)
3214 {
3215     CharDriverState *chr = opaque;
3216     TCPCharDriver *s = chr->opaque;
3217     struct sockaddr_in saddr;
3218 #ifndef _WIN32
3219     struct sockaddr_un uaddr;
3220 #endif
3221     struct sockaddr *addr;
3222     socklen_t len;
3223     int fd;
3224
3225     for(;;) {
3226 #ifndef _WIN32
3227         if (s->is_unix) {
3228             len = sizeof(uaddr);
3229             addr = (struct sockaddr *)&uaddr;
3230         } else
3231 #endif
3232         {
3233             len = sizeof(saddr);
3234             addr = (struct sockaddr *)&saddr;
3235         }
3236         fd = accept(s->listen_fd, addr, &len);
3237         if (fd < 0 && errno != EINTR) {
3238             return;
3239         } else if (fd >= 0) {
3240             if (s->do_telnetopt)
3241                 tcp_chr_telnet_init(fd);
3242             break;
3243         }
3244     }
3245     socket_set_nonblock(fd);
3246     if (s->do_nodelay)
3247         socket_set_nodelay(fd);
3248     s->fd = fd;
3249     qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3250     tcp_chr_connect(chr);
3251 }
3252
3253 static void tcp_chr_close(CharDriverState *chr)
3254 {
3255     TCPCharDriver *s = chr->opaque;
3256     if (s->fd >= 0)
3257         closesocket(s->fd);
3258     if (s->listen_fd >= 0)
3259         closesocket(s->listen_fd);
3260     qemu_free(s);
3261 }
3262
3263 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3264                                           int is_telnet,
3265                                           int is_unix)
3266 {
3267     CharDriverState *chr = NULL;
3268     TCPCharDriver *s = NULL;
3269     int fd = -1, ret, err, val;
3270     int is_listen = 0;
3271     int is_waitconnect = 1;
3272     int do_nodelay = 0;
3273     const char *ptr;
3274     struct sockaddr_in saddr;
3275 #ifndef _WIN32
3276     struct sockaddr_un uaddr;
3277 #endif
3278     struct sockaddr *addr;
3279     socklen_t addrlen;
3280
3281 #ifndef _WIN32
3282     if (is_unix) {
3283         addr = (struct sockaddr *)&uaddr;
3284         addrlen = sizeof(uaddr);
3285         if (parse_unix_path(&uaddr, host_str) < 0)
3286             goto fail;
3287     } else
3288 #endif
3289     {
3290         addr = (struct sockaddr *)&saddr;
3291         addrlen = sizeof(saddr);
3292         if (parse_host_port(&saddr, host_str) < 0)
3293             goto fail;
3294     }
3295
3296     ptr = host_str;
3297     while((ptr = strchr(ptr,','))) {
3298         ptr++;
3299         if (!strncmp(ptr,"server",6)) {
3300             is_listen = 1;
3301         } else if (!strncmp(ptr,"nowait",6)) {
3302             is_waitconnect = 0;
3303         } else if (!strncmp(ptr,"nodelay",6)) {
3304             do_nodelay = 1;
3305         } else {
3306             printf("Unknown option: %s\n", ptr);
3307             goto fail;
3308         }
3309     }
3310     if (!is_listen)
3311         is_waitconnect = 0;
3312
3313     chr = qemu_mallocz(sizeof(CharDriverState));
3314     if (!chr)
3315         goto fail;
3316     s = qemu_mallocz(sizeof(TCPCharDriver));
3317     if (!s)
3318         goto fail;
3319
3320 #ifndef _WIN32
3321     if (is_unix)
3322         fd = socket(PF_UNIX, SOCK_STREAM, 0);
3323     else
3324 #endif
3325         fd = socket(PF_INET, SOCK_STREAM, 0);
3326
3327     if (fd < 0)
3328         goto fail;
3329
3330     if (!is_waitconnect)
3331         socket_set_nonblock(fd);
3332
3333     s->connected = 0;
3334     s->fd = -1;
3335     s->listen_fd = -1;
3336     s->is_unix = is_unix;
3337     s->do_nodelay = do_nodelay && !is_unix;
3338
3339     chr->opaque = s;
3340     chr->chr_write = tcp_chr_write;
3341     chr->chr_close = tcp_chr_close;
3342
3343     if (is_listen) {
3344         /* allow fast reuse */
3345 #ifndef _WIN32
3346         if (is_unix) {
3347             char path[109];
3348             strncpy(path, uaddr.sun_path, 108);
3349             path[108] = 0;
3350             unlink(path);
3351         } else
3352 #endif
3353         {
3354             val = 1;
3355             setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3356         }
3357
3358         ret = bind(fd, addr, addrlen);
3359         if (ret < 0)
3360             goto fail;
3361
3362         ret = listen(fd, 0);
3363         if (ret < 0)
3364             goto fail;
3365
3366         s->listen_fd = fd;
3367         qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3368         if (is_telnet)
3369             s->do_telnetopt = 1;
3370     } else {
3371         for(;;) {
3372             ret = connect(fd, addr, addrlen);
3373             if (ret < 0) {
3374                 err = socket_error();
3375                 if (err == EINTR || err == EWOULDBLOCK) {
3376                 } else if (err == EINPROGRESS) {
3377                     break;
3378 #ifdef _WIN32
3379                 } else if (err == WSAEALREADY) {
3380                     break;
3381 #endif
3382                 } else {
3383                     goto fail;
3384                 }
3385             } else {
3386                 s->connected = 1;
3387                 break;
3388             }
3389         }
3390         s->fd = fd;
3391         socket_set_nodelay(fd);
3392         if (s->connected)
3393             tcp_chr_connect(chr);
3394         else
3395             qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3396     }
3397
3398     if (is_listen && is_waitconnect) {
3399         printf("QEMU waiting for connection on: %s\n", host_str);
3400         tcp_chr_accept(chr);
3401         socket_set_nonblock(s->listen_fd);
3402     }
3403
3404     return chr;
3405  fail:
3406     if (fd >= 0)
3407         closesocket(fd);
3408     qemu_free(s);
3409     qemu_free(chr);
3410     return NULL;
3411 }
3412
3413 CharDriverState *qemu_chr_open(const char *filename)
3414 {
3415     const char *p;
3416
3417     if (!strcmp(filename, "vc")) {
3418         return text_console_init(&display_state, 0);
3419     } else if (strstart(filename, "vc:", &p)) {
3420         return text_console_init(&display_state, p);
3421     } else if (!strcmp(filename, "null")) {
3422         return qemu_chr_open_null();
3423     } else
3424     if (strstart(filename, "tcp:", &p)) {
3425         return qemu_chr_open_tcp(p, 0, 0);
3426     } else
3427     if (strstart(filename, "telnet:", &p)) {
3428         return qemu_chr_open_tcp(p, 1, 0);
3429     } else
3430     if (strstart(filename, "udp:", &p)) {
3431         return qemu_chr_open_udp(p);
3432     } else
3433     if (strstart(filename, "mon:", &p)) {
3434         CharDriverState *drv = qemu_chr_open(p);
3435         if (drv) {
3436             drv = qemu_chr_open_mux(drv);
3437             monitor_init(drv, !nographic);
3438             return drv;
3439         }
3440         printf("Unable to open driver: %s\n", p);
3441         return 0;
3442     } else
3443 #ifndef _WIN32
3444     if (strstart(filename, "unix:", &p)) {
3445         return qemu_chr_open_tcp(p, 0, 1);
3446     } else if (strstart(filename, "file:", &p)) {
3447         return qemu_chr_open_file_out(p);
3448     } else if (strstart(filename, "pipe:", &p)) {
3449         return qemu_chr_open_pipe(p);
3450     } else if (!strcmp(filename, "pty")) {
3451         return qemu_chr_open_pty();
3452     } else if (!strcmp(filename, "stdio")) {
3453         return qemu_chr_open_stdio();
3454     } else
3455 #if defined(__linux__)
3456     if (strstart(filename, "/dev/parport", NULL)) {
3457         return qemu_chr_open_pp(filename);
3458     } else
3459 #endif
3460 #if defined(__linux__) || defined(__sun__)
3461     if (strstart(filename, "/dev/", NULL)) {
3462         return qemu_chr_open_tty(filename);
3463     } else
3464 #endif
3465 #else /* !_WIN32 */
3466     if (strstart(filename, "COM", NULL)) {
3467         return qemu_chr_open_win(filename);
3468     } else
3469     if (strstart(filename, "pipe:", &p)) {
3470         return qemu_chr_open_win_pipe(p);
3471     } else
3472     if (strstart(filename, "con:", NULL)) {
3473         return qemu_chr_open_win_con(filename);
3474     } else
3475     if (strstart(filename, "file:", &p)) {
3476         return qemu_chr_open_win_file_out(p);
3477     }
3478 #endif
3479     {
3480         return NULL;
3481     }
3482 }
3483
3484 void qemu_chr_close(CharDriverState *chr)
3485 {
3486     if (chr->chr_close)
3487         chr->chr_close(chr);
3488     qemu_free(chr);
3489 }
3490
3491 /***********************************************************/
3492 /* network device redirectors */
3493
3494 __attribute__ (( unused ))
3495 static void hex_dump(FILE *f, const uint8_t *buf, int size)
3496 {
3497     int len, i, j, c;
3498
3499     for(i=0;i<size;i+=16) {
3500         len = size - i;
3501         if (len > 16)
3502             len = 16;
3503         fprintf(f, "%08x ", i);
3504         for(j=0;j<16;j++) {
3505             if (j < len)
3506                 fprintf(f, " %02x", buf[i+j]);
3507             else
3508                 fprintf(f, "   ");
3509         }
3510         fprintf(f, " ");
3511         for(j=0;j<len;j++) {
3512             c = buf[i+j];
3513             if (c < ' ' || c > '~')
3514                 c = '.';
3515             fprintf(f, "%c", c);
3516         }
3517         fprintf(f, "\n");
3518     }
3519 }
3520
3521 static int parse_macaddr(uint8_t *macaddr, const char *p)
3522 {
3523     int i;
3524     char *last_char;
3525     long int offset;
3526
3527     errno = 0;
3528     offset = strtol(p, &last_char, 0);
3529     if (0 == errno && '\0' == *last_char &&
3530             offset >= 0 && offset <= 0xFFFFFF) {
3531         macaddr[3] = (offset & 0xFF0000) >> 16;
3532         macaddr[4] = (offset & 0xFF00) >> 8;
3533         macaddr[5] = offset & 0xFF;
3534         return 0;
3535     } else {
3536         for(i = 0; i < 6; i++) {
3537             macaddr[i] = strtol(p, (char **)&p, 16);
3538             if (i == 5) {
3539                 if (*p != '\0')
3540                     return -1;
3541             } else {
3542                 if (*p != ':' && *p != '-')
3543                     return -1;
3544                 p++;
3545             }
3546         }
3547         return 0;
3548     }
3549
3550     return -1;
3551 }
3552
3553 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3554 {
3555     const char *p, *p1;
3556     int len;
3557     p = *pp;
3558     p1 = strchr(p, sep);
3559     if (!p1)
3560         return -1;
3561     len = p1 - p;
3562     p1++;
3563     if (buf_size > 0) {
3564         if (len > buf_size - 1)
3565             len = buf_size - 1;
3566         memcpy(buf, p, len);
3567         buf[len] = '\0';
3568     }
3569     *pp = p1;
3570     return 0;
3571 }
3572
3573 int parse_host_src_port(struct sockaddr_in *haddr,
3574                         struct sockaddr_in *saddr,
3575                         const char *input_str)
3576 {
3577     char *str = strdup(input_str);
3578     char *host_str = str;
3579     char *src_str;
3580     char *ptr;
3581
3582     /*
3583      * Chop off any extra arguments at the end of the string which
3584      * would start with a comma, then fill in the src port information
3585      * if it was provided else use the "any address" and "any port".
3586      */
3587     if ((ptr = strchr(str,',')))
3588         *ptr = '\0';
3589
3590     if ((src_str = strchr(input_str,'@'))) {
3591         *src_str = '\0';
3592         src_str++;
3593     }
3594
3595     if (parse_host_port(haddr, host_str) < 0)
3596         goto fail;
3597
3598     if (!src_str || *src_str == '\0')
3599         src_str = ":0";
3600
3601     if (parse_host_port(saddr, src_str) < 0)
3602         goto fail;
3603
3604     free(str);
3605     return(0);
3606
3607 fail:
3608     free(str);
3609     return -1;
3610 }
3611
3612 int parse_host_port(struct sockaddr_in *saddr, const char *str)
3613 {
3614     char buf[512];
3615     struct hostent *he;
3616     const char *p, *r;
3617     int port;
3618
3619     p = str;
3620     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3621         return -1;
3622     saddr->sin_family = AF_INET;
3623     if (buf[0] == '\0') {
3624         saddr->sin_addr.s_addr = 0;
3625     } else {
3626         if (isdigit(buf[0])) {
3627             if (!inet_aton(buf, &saddr->sin_addr))
3628                 return -1;
3629         } else {
3630             if ((he = gethostbyname(buf)) == NULL)
3631                 return - 1;
3632             saddr->sin_addr = *(struct in_addr *)he->h_addr;
3633         }
3634     }
3635     port = strtol(p, (char **)&r, 0);
3636     if (r == p)
3637         return -1;
3638     saddr->sin_port = htons(port);
3639     return 0;
3640 }
3641
3642 #ifndef _WIN32
3643 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3644 {
3645     const char *p;
3646     int len;
3647
3648     len = MIN(108, strlen(str));
3649     p = strchr(str, ',');
3650     if (p)
3651         len = MIN(len, p - str);
3652
3653     memset(uaddr, 0, sizeof(*uaddr));
3654
3655     uaddr->sun_family = AF_UNIX;
3656     memcpy(uaddr->sun_path, str, len);
3657
3658     return 0;
3659 }
3660 #endif
3661
3662 /* find or alloc a new VLAN */
3663 VLANState *qemu_find_vlan(int id)
3664 {
3665     VLANState **pvlan, *vlan;
3666     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3667         if (vlan->id == id)
3668             return vlan;
3669     }
3670     vlan = qemu_mallocz(sizeof(VLANState));
3671     if (!vlan)
3672         return NULL;
3673     vlan->id = id;
3674     vlan->next = NULL;
3675     pvlan = &first_vlan;
3676     while (*pvlan != NULL)
3677         pvlan = &(*pvlan)->next;
3678     *pvlan = vlan;
3679     return vlan;
3680 }
3681
3682 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3683                                       IOReadHandler *fd_read,
3684                                       IOCanRWHandler *fd_can_read,
3685                                       void *opaque)
3686 {
3687     VLANClientState *vc, **pvc;
3688     vc = qemu_mallocz(sizeof(VLANClientState));
3689     if (!vc)
3690         return NULL;
3691     vc->fd_read = fd_read;
3692     vc->fd_can_read = fd_can_read;
3693     vc->opaque = opaque;
3694     vc->vlan = vlan;
3695
3696     vc->next = NULL;
3697     pvc = &vlan->first_client;
3698     while (*pvc != NULL)
3699         pvc = &(*pvc)->next;
3700     *pvc = vc;
3701     return vc;
3702 }
3703
3704 int qemu_can_send_packet(VLANClientState *vc1)
3705 {
3706     VLANState *vlan = vc1->vlan;
3707     VLANClientState *vc;
3708
3709     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3710         if (vc != vc1) {
3711             if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3712                 return 1;
3713         }
3714     }
3715     return 0;
3716 }
3717
3718 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3719 {
3720     VLANState *vlan = vc1->vlan;
3721     VLANClientState *vc;
3722
3723 #if 0
3724     printf("vlan %d send:\n", vlan->id);
3725     hex_dump(stdout, buf, size);
3726 #endif
3727     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3728         if (vc != vc1) {
3729             vc->fd_read(vc->opaque, buf, size);
3730         }
3731     }
3732 }
3733
3734 #if defined(CONFIG_SLIRP)
3735
3736 /* slirp network adapter */
3737
3738 static int slirp_inited;
3739 static VLANClientState *slirp_vc;
3740
3741 int slirp_can_output(void)
3742 {
3743     return !slirp_vc || qemu_can_send_packet(slirp_vc);
3744 }
3745
3746 void slirp_output(const uint8_t *pkt, int pkt_len)
3747 {
3748 #if 0
3749     printf("slirp output:\n");
3750     hex_dump(stdout, pkt, pkt_len);
3751 #endif
3752     if (!slirp_vc)
3753         return;
3754     qemu_send_packet(slirp_vc, pkt, pkt_len);
3755 }
3756
3757 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3758 {
3759 #if 0
3760     printf("slirp input:\n");
3761     hex_dump(stdout, buf, size);
3762 #endif
3763     slirp_input(buf, size);
3764 }
3765
3766 static int net_slirp_init(VLANState *vlan)
3767 {
3768     if (!slirp_inited) {
3769         slirp_inited = 1;
3770         slirp_init();
3771     }
3772     slirp_vc = qemu_new_vlan_client(vlan,
3773                                     slirp_receive, NULL, NULL);
3774     snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3775     return 0;
3776 }
3777
3778 static void net_slirp_redir(const char *redir_str)
3779 {
3780     int is_udp;
3781     char buf[256], *r;
3782     const char *p;
3783     struct in_addr guest_addr;
3784     int host_port, guest_port;
3785
3786     if (!slirp_inited) {
3787         slirp_inited = 1;
3788         slirp_init();
3789     }
3790
3791     p = redir_str;
3792     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3793         goto fail;
3794     if (!strcmp(buf, "tcp")) {
3795         is_udp = 0;
3796     } else if (!strcmp(buf, "udp")) {
3797         is_udp = 1;
3798     } else {
3799         goto fail;
3800     }
3801
3802     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3803         goto fail;
3804     host_port = strtol(buf, &r, 0);
3805     if (r == buf)
3806         goto fail;
3807
3808     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3809         goto fail;
3810     if (buf[0] == '\0') {
3811         pstrcpy(buf, sizeof(buf), "10.0.2.15");
3812     }
3813     if (!inet_aton(buf, &guest_addr))
3814         goto fail;
3815
3816     guest_port = strtol(p, &r, 0);
3817     if (r == p)
3818         goto fail;
3819
3820     if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3821         fprintf(stderr, "qemu: could not set up redirection\n");
3822         exit(1);
3823     }
3824     return;
3825  fail:
3826     fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3827     exit(1);
3828 }
3829
3830 #ifndef _WIN32
3831
3832 char smb_dir[1024];
3833
3834 static void erase_dir(char *dir_name)
3835 {
3836     DIR *d;
3837     struct dirent *de;
3838     char filename[1024];
3839
3840     /* erase all the files in the directory */
3841     if ((d = opendir(dir_name)) != 0) {
3842         for(;;) {
3843             de = readdir(d);
3844             if (!de)
3845                 break;
3846             if (strcmp(de->d_name, ".") != 0 &&
3847                 strcmp(de->d_name, "..") != 0) {
3848                 snprintf(filename, sizeof(filename), "%s/%s",
3849                          smb_dir, de->d_name);
3850                 if (unlink(filename) != 0)  /* is it a directory? */
3851                     erase_dir(filename);
3852             }
3853         }
3854         closedir(d);
3855         rmdir(dir_name);
3856     }
3857 }
3858
3859 /* automatic user mode samba server configuration */
3860 static void smb_exit(void)
3861 {
3862     erase_dir(smb_dir);
3863 }
3864
3865 /* automatic user mode samba server configuration */
3866 static void net_slirp_smb(const char *exported_dir)
3867 {
3868     char smb_conf[1024];
3869     char smb_cmdline[1024];
3870     FILE *f;
3871
3872     if (!slirp_inited) {
3873         slirp_inited = 1;
3874         slirp_init();
3875     }
3876
3877     /* XXX: better tmp dir construction */
3878     snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3879     if (mkdir(smb_dir, 0700) < 0) {
3880         fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3881         exit(1);
3882     }
3883     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3884
3885     f = fopen(smb_conf, "w");
3886     if (!f) {
3887         fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3888         exit(1);
3889     }
3890     fprintf(f,
3891             "[global]\n"
3892             "private dir=%s\n"
3893             "smb ports=0\n"
3894             "socket address=127.0.0.1\n"
3895             "pid directory=%s\n"
3896             "lock directory=%s\n"
3897             "log file=%s/log.smbd\n"
3898             "smb passwd file=%s/smbpasswd\n"
3899             "security = share\n"
3900             "[qemu]\n"
3901             "path=%s\n"
3902             "read only=no\n"
3903             "guest ok=yes\n",
3904             smb_dir,
3905             smb_dir,
3906             smb_dir,
3907             smb_dir,
3908             smb_dir,
3909             exported_dir
3910             );
3911     fclose(f);
3912     atexit(smb_exit);
3913
3914     snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3915              SMBD_COMMAND, smb_conf);
3916
3917     slirp_add_exec(0, smb_cmdline, 4, 139);
3918 }
3919
3920 #endif /* !defined(_WIN32) */
3921 void do_info_slirp(void)
3922 {
3923     slirp_stats();
3924 }
3925
3926 #endif /* CONFIG_SLIRP */
3927
3928 #if !defined(_WIN32)
3929
3930 typedef struct TAPState {
3931     VLANClientState *vc;
3932     int fd;
3933     char down_script[1024];
3934 } TAPState;
3935
3936 static void tap_receive(void *opaque, const uint8_t *buf, int size)
3937 {
3938     TAPState *s = opaque;
3939     int ret;
3940     for(;;) {
3941         ret = write(s->fd, buf, size);
3942         if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3943         } else {
3944             break;
3945         }
3946     }
3947 }
3948
3949 static void tap_send(void *opaque)
3950 {
3951     TAPState *s = opaque;
3952     uint8_t buf[4096];
3953     int size;
3954
3955 #ifdef __sun__
3956     struct strbuf sbuf;
3957     int f = 0;
3958     sbuf.maxlen = sizeof(buf);
3959     sbuf.buf = buf;
3960     size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
3961 #else
3962     size = read(s->fd, buf, sizeof(buf));
3963 #endif
3964     if (size > 0) {
3965         qemu_send_packet(s->vc, buf, size);
3966     }
3967 }
3968
3969 /* fd support */
3970
3971 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3972 {
3973     TAPState *s;
3974
3975     s = qemu_mallocz(sizeof(TAPState));
3976     if (!s)
3977         return NULL;
3978     s->fd = fd;
3979     s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3980     qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3981     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3982     return s;
3983 }
3984
3985 #if defined (_BSD) || defined (__FreeBSD_kernel__)
3986 static int tap_open(char *ifname, int ifname_size)
3987 {
3988     int fd;
3989     char *dev;
3990     struct stat s;
3991
3992     TFR(fd = open("/dev/tap", O_RDWR));
3993     if (fd < 0) {
3994         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
3995         return -1;
3996     }
3997
3998     fstat(fd, &s);
3999     dev = devname(s.st_rdev, S_IFCHR);
4000     pstrcpy(ifname, ifname_size, dev);
4001
4002     fcntl(fd, F_SETFL, O_NONBLOCK);
4003     return fd;
4004 }
4005 #elif defined(__sun__)
4006 #define TUNNEWPPA       (('T'<<16) | 0x0001)
4007 /*
4008  * Allocate TAP device, returns opened fd.
4009  * Stores dev name in the first arg(must be large enough).
4010  */
4011 int tap_alloc(char *dev)
4012 {
4013     int tap_fd, if_fd, ppa = -1;
4014     static int ip_fd = 0;
4015     char *ptr;
4016
4017     static int arp_fd = 0;
4018     int ip_muxid, arp_muxid;
4019     struct strioctl  strioc_if, strioc_ppa;
4020     int link_type = I_PLINK;;
4021     struct lifreq ifr;
4022     char actual_name[32] = "";
4023
4024     memset(&ifr, 0x0, sizeof(ifr));
4025
4026     if( *dev ){
4027        ptr = dev;
4028        while( *ptr && !isdigit((int)*ptr) ) ptr++;
4029        ppa = atoi(ptr);
4030     }
4031
4032     /* Check if IP device was opened */
4033     if( ip_fd )
4034        close(ip_fd);
4035
4036     TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4037     if (ip_fd < 0) {
4038        syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4039        return -1;
4040     }
4041
4042     TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4043     if (tap_fd < 0) {
4044        syslog(LOG_ERR, "Can't open /dev/tap");
4045        return -1;
4046     }
4047
4048     /* Assign a new PPA and get its unit number. */
4049     strioc_ppa.ic_cmd = TUNNEWPPA;
4050     strioc_ppa.ic_timout = 0;
4051     strioc_ppa.ic_len = sizeof(ppa);
4052     strioc_ppa.ic_dp = (char *)&ppa;
4053     if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4054        syslog (LOG_ERR, "Can't assign new interface");
4055
4056     TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4057     if (if_fd < 0) {
4058        syslog(LOG_ERR, "Can't open /dev/tap (2)");
4059        return -1;
4060     }
4061     if(ioctl(if_fd, I_PUSH, "ip") < 0){
4062        syslog(LOG_ERR, "Can't push IP module");
4063        return -1;
4064     }
4065
4066     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4067         syslog(LOG_ERR, "Can't get flags\n");
4068
4069     snprintf (actual_name, 32, "tap%d", ppa);
4070     strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4071
4072     ifr.lifr_ppa = ppa;
4073     /* Assign ppa according to the unit number returned by tun device */
4074
4075     if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4076         syslog (LOG_ERR, "Can't set PPA %d", ppa);
4077     if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4078         syslog (LOG_ERR, "Can't get flags\n");
4079     /* Push arp module to if_fd */
4080     if (ioctl (if_fd, I_PUSH, "arp") < 0)
4081         syslog (LOG_ERR, "Can't push ARP module (2)");
4082
4083     /* Push arp module to ip_fd */
4084     if (ioctl (ip_fd, I_POP, NULL) < 0)
4085         syslog (LOG_ERR, "I_POP failed\n");
4086     if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4087         syslog (LOG_ERR, "Can't push ARP module (3)\n");
4088     /* Open arp_fd */
4089     TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4090     if (arp_fd < 0)
4091        syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4092
4093     /* Set ifname to arp */
4094     strioc_if.ic_cmd = SIOCSLIFNAME;
4095     strioc_if.ic_timout = 0;
4096     strioc_if.ic_len = sizeof(ifr);
4097     strioc_if.ic_dp = (char *)&ifr;
4098     if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4099         syslog (LOG_ERR, "Can't set ifname to arp\n");
4100     }
4101
4102     if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4103        syslog(LOG_ERR, "Can't link TAP device to IP");
4104        return -1;
4105     }
4106
4107     if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4108         syslog (LOG_ERR, "Can't link TAP device to ARP");
4109
4110     close (if_fd);
4111
4112     memset(&ifr, 0x0, sizeof(ifr));
4113     strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4114     ifr.lifr_ip_muxid  = ip_muxid;
4115     ifr.lifr_arp_muxid = arp_muxid;
4116
4117     if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4118     {
4119       ioctl (ip_fd, I_PUNLINK , arp_muxid);
4120       ioctl (ip_fd, I_PUNLINK, ip_muxid);
4121       syslog (LOG_ERR, "Can't set multiplexor id");
4122     }
4123
4124     sprintf(dev, "tap%d", ppa);
4125     return tap_fd;
4126 }
4127
4128 static int tap_open(char *ifname, int ifname_size)
4129 {
4130     char  dev[10]="";
4131     int fd;
4132     if( (fd = tap_alloc(dev)) < 0 ){
4133        fprintf(stderr, "Cannot allocate TAP device\n");
4134        return -1;
4135     }
4136     pstrcpy(ifname, ifname_size, dev);
4137     fcntl(fd, F_SETFL, O_NONBLOCK);
4138     return fd;
4139 }
4140 #else
4141 static int tap_open(char *ifname, int ifname_size)
4142 {
4143     struct ifreq ifr;
4144     int fd, ret;
4145
4146     TFR(fd = open("/dev/net/tun", O_RDWR));
4147     if (fd < 0) {
4148         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4149         return -1;
4150     }
4151     memset(&ifr, 0, sizeof(ifr));
4152     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4153     if (ifname[0] != '\0')
4154         pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4155     else
4156         pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4157     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4158     if (ret != 0) {
4159         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4160         close(fd);
4161         return -1;
4162     }
4163     pstrcpy(ifname, ifname_size, ifr.ifr_name);
4164     fcntl(fd, F_SETFL, O_NONBLOCK);
4165     return fd;
4166 }
4167 #endif
4168
4169 static int launch_script(const char *setup_script, const char *ifname, int fd)
4170 {
4171     int pid, status;
4172     char *args[3];
4173     char **parg;
4174
4175         /* try to launch network script */
4176         pid = fork();
4177         if (pid >= 0) {
4178             if (pid == 0) {
4179                 int open_max = sysconf (_SC_OPEN_MAX), i;
4180                 for (i = 0; i < open_max; i++)
4181                     if (i != STDIN_FILENO &&
4182                         i != STDOUT_FILENO &&
4183                         i != STDERR_FILENO &&
4184                         i != fd)
4185                         close(i);
4186
4187                 parg = args;
4188                 *parg++ = (char *)setup_script;
4189                 *parg++ = (char *)ifname;
4190                 *parg++ = NULL;
4191                 execv(setup_script, args);
4192                 _exit(1);
4193             }
4194             while (waitpid(pid, &status, 0) != pid);
4195             if (!WIFEXITED(status) ||
4196                 WEXITSTATUS(status) != 0) {
4197                 fprintf(stderr, "%s: could not launch network script\n",
4198                         setup_script);
4199                 return -1;
4200             }
4201         }
4202     return 0;
4203 }
4204
4205 static int net_tap_init(VLANState *vlan, const char *ifname1,
4206                         const char *setup_script, const char *down_script)
4207 {
4208     TAPState *s;
4209     int fd;
4210     char ifname[128];
4211
4212     if (ifname1 != NULL)
4213         pstrcpy(ifname, sizeof(ifname), ifname1);
4214     else
4215         ifname[0] = '\0';
4216     TFR(fd = tap_open(ifname, sizeof(ifname)));
4217     if (fd < 0)
4218         return -1;
4219
4220     if (!setup_script || !strcmp(setup_script, "no"))
4221         setup_script = "";
4222     if (setup_script[0] != '\0') {
4223         if (launch_script(setup_script, ifname, fd))
4224             return -1;
4225     }
4226     s = net_tap_fd_init(vlan, fd);
4227     if (!s)
4228         return -1;
4229     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4230              "tap: ifname=%s setup_script=%s", ifname, setup_script);
4231     if (down_script && strcmp(down_script, "no"))
4232         snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4233     return 0;
4234 }
4235
4236 #endif /* !_WIN32 */
4237
4238 /* network connection */
4239 typedef struct NetSocketState {
4240     VLANClientState *vc;
4241     int fd;
4242     int state; /* 0 = getting length, 1 = getting data */
4243     int index;
4244     int packet_len;
4245     uint8_t buf[4096];
4246     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4247 } NetSocketState;
4248
4249 typedef struct NetSocketListenState {
4250     VLANState *vlan;
4251     int fd;
4252 } NetSocketListenState;
4253
4254 /* XXX: we consider we can send the whole packet without blocking */
4255 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4256 {
4257     NetSocketState *s = opaque;
4258     uint32_t len;
4259     len = htonl(size);
4260
4261     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4262     send_all(s->fd, buf, size);
4263 }
4264
4265 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4266 {
4267     NetSocketState *s = opaque;
4268     sendto(s->fd, buf, size, 0,
4269            (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4270 }
4271
4272 static void net_socket_send(void *opaque)
4273 {
4274     NetSocketState *s = opaque;
4275     int l, size, err;
4276     uint8_t buf1[4096];
4277     const uint8_t *buf;
4278
4279     size = recv(s->fd, buf1, sizeof(buf1), 0);
4280     if (size < 0) {
4281         err = socket_error();
4282         if (err != EWOULDBLOCK)
4283             goto eoc;
4284     } else if (size == 0) {
4285         /* end of connection */
4286     eoc:
4287         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4288         closesocket(s->fd);
4289         return;
4290     }
4291     buf = buf1;
4292     while (size > 0) {
4293         /* reassemble a packet from the network */
4294         switch(s->state) {
4295         case 0:
4296             l = 4 - s->index;
4297             if (l > size)
4298                 l = size;
4299             memcpy(s->buf + s->index, buf, l);
4300             buf += l;
4301             size -= l;
4302             s->index += l;
4303             if (s->index == 4) {
4304                 /* got length */
4305                 s->packet_len = ntohl(*(uint32_t *)s->buf);
4306                 s->index = 0;
4307                 s->state = 1;
4308             }
4309             break;
4310         case 1:
4311             l = s->packet_len - s->index;
4312             if (l > size)
4313                 l = size;
4314             memcpy(s->buf + s->index, buf, l);
4315             s->index += l;
4316             buf += l;
4317             size -= l;
4318             if (s->index >= s->packet_len) {
4319                 qemu_send_packet(s->vc, s->buf, s->packet_len);
4320                 s->index = 0;
4321                 s->state = 0;
4322             }
4323             break;
4324         }
4325     }
4326 }
4327
4328 static void net_socket_send_dgram(void *opaque)
4329 {
4330     NetSocketState *s = opaque;
4331     int size;
4332
4333     size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4334     if (size < 0)
4335         return;
4336     if (size == 0) {
4337         /* end of connection */
4338         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4339         return;
4340     }
4341     qemu_send_packet(s->vc, s->buf, size);
4342 }
4343
4344 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4345 {
4346     struct ip_mreq imr;
4347     int fd;
4348     int val, ret;
4349     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4350         fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4351                 inet_ntoa(mcastaddr->sin_addr),
4352                 (int)ntohl(mcastaddr->sin_addr.s_addr));
4353         return -1;
4354
4355     }
4356     fd = socket(PF_INET, SOCK_DGRAM, 0);
4357     if (fd < 0) {
4358         perror("socket(PF_INET, SOCK_DGRAM)");
4359         return -1;
4360     }
4361
4362     val = 1;
4363     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4364                    (const char *)&val, sizeof(val));
4365     if (ret < 0) {
4366         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4367         goto fail;
4368     }
4369
4370     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4371     if (ret < 0) {
4372         perror("bind");
4373         goto fail;
4374     }
4375
4376     /* Add host to multicast group */
4377     imr.imr_multiaddr = mcastaddr->sin_addr;
4378     imr.imr_interface.s_addr = htonl(INADDR_ANY);
4379
4380     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4381                      (const char *)&imr, sizeof(struct ip_mreq));
4382     if (ret < 0) {
4383         perror("setsockopt(IP_ADD_MEMBERSHIP)");
4384         goto fail;
4385     }
4386
4387     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4388     val = 1;
4389     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4390                    (const char *)&val, sizeof(val));
4391     if (ret < 0) {
4392         perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4393         goto fail;
4394     }
4395
4396     socket_set_nonblock(fd);
4397     return fd;
4398 fail:
4399     if (fd >= 0)
4400         closesocket(fd);
4401     return -1;
4402 }
4403
4404 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4405                                           int is_connected)
4406 {
4407     struct sockaddr_in saddr;
4408     int newfd;
4409     socklen_t saddr_len;
4410     NetSocketState *s;
4411
4412     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4413      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4414      * by ONLY ONE process: we must "clone" this dgram socket --jjo
4415      */
4416
4417     if (is_connected) {
4418         if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4419             /* must be bound */
4420             if (saddr.sin_addr.s_addr==0) {
4421                 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4422                         fd);
4423                 return NULL;
4424             }
4425             /* clone dgram socket */
4426             newfd = net_socket_mcast_create(&saddr);
4427             if (newfd < 0) {
4428                 /* error already reported by net_socket_mcast_create() */
4429                 close(fd);
4430                 return NULL;
4431             }
4432             /* clone newfd to fd, close newfd */
4433             dup2(newfd, fd);
4434             close(newfd);
4435
4436         } else {
4437             fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4438                     fd, strerror(errno));
4439             return NULL;
4440         }
4441     }
4442
4443     s = qemu_mallocz(sizeof(NetSocketState));
4444     if (!s)
4445         return NULL;
4446     s->fd = fd;
4447
4448     s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4449     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4450
4451     /* mcast: save bound address as dst */
4452     if (is_connected) s->dgram_dst=saddr;
4453
4454     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4455             "socket: fd=%d (%s mcast=%s:%d)",
4456             fd, is_connected? "cloned" : "",
4457             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4458     return s;
4459 }
4460
4461 static void net_socket_connect(void *opaque)
4462 {
4463     NetSocketState *s = opaque;
4464     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4465 }
4466
4467 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4468                                           int is_connected)
4469 {
4470     NetSocketState *s;
4471     s = qemu_mallocz(sizeof(NetSocketState));
4472     if (!s)
4473         return NULL;
4474     s->fd = fd;
4475     s->vc = qemu_new_vlan_client(vlan,
4476                                  net_socket_receive, NULL, s);
4477     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4478              "socket: fd=%d", fd);
4479     if (is_connected) {
4480         net_socket_connect(s);
4481     } else {
4482         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4483     }
4484     return s;
4485 }
4486
4487 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4488                                           int is_connected)
4489 {
4490     int so_type=-1, optlen=sizeof(so_type);
4491
4492     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4493         (socklen_t *)&optlen)< 0) {
4494         fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4495         return NULL;
4496     }
4497     switch(so_type) {
4498     case SOCK_DGRAM:
4499         return net_socket_fd_init_dgram(vlan, fd, is_connected);
4500     case SOCK_STREAM:
4501         return net_socket_fd_init_stream(vlan, fd, is_connected);
4502     default:
4503         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4504         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4505         return net_socket_fd_init_stream(vlan, fd, is_connected);
4506     }
4507     return NULL;
4508 }
4509
4510 static void net_socket_accept(void *opaque)
4511 {
4512     NetSocketListenState *s = opaque;
4513     NetSocketState *s1;
4514     struct sockaddr_in saddr;
4515     socklen_t len;
4516     int fd;
4517
4518     for(;;) {
4519         len = sizeof(saddr);
4520         fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4521         if (fd < 0 && errno != EINTR) {
4522             return;
4523         } else if (fd >= 0) {
4524             break;
4525         }
4526     }
4527     s1 = net_socket_fd_init(s->vlan, fd, 1);
4528     if (!s1) {
4529         closesocket(fd);
4530     } else {
4531         snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4532                  "socket: connection from %s:%d",
4533                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4534     }
4535 }
4536
4537 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4538 {
4539     NetSocketListenState *s;
4540     int fd, val, ret;
4541     struct sockaddr_in saddr;
4542
4543     if (parse_host_port(&saddr, host_str) < 0)
4544         return -1;
4545
4546     s = qemu_mallocz(sizeof(NetSocketListenState));
4547     if (!s)
4548         return -1;
4549
4550     fd = socket(PF_INET, SOCK_STREAM, 0);
4551     if (fd < 0) {
4552         perror("socket");
4553         return -1;
4554     }
4555     socket_set_nonblock(fd);
4556
4557     /* allow fast reuse */
4558     val = 1;
4559     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4560
4561     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4562     if (ret < 0) {
4563         perror("bind");
4564         return -1;
4565     }
4566     ret = listen(fd, 0);
4567     if (ret < 0) {
4568         perror("listen");
4569         return -1;
4570     }
4571     s->vlan = vlan;
4572     s->fd = fd;
4573     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4574     return 0;
4575 }
4576
4577 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4578 {
4579     NetSocketState *s;
4580     int fd, connected, ret, err;
4581     struct sockaddr_in saddr;
4582
4583     if (parse_host_port(&saddr, host_str) < 0)
4584         return -1;
4585
4586     fd = socket(PF_INET, SOCK_STREAM, 0);
4587     if (fd < 0) {
4588         perror("socket");
4589         return -1;
4590     }
4591     socket_set_nonblock(fd);
4592
4593     connected = 0;
4594     for(;;) {
4595         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4596         if (ret < 0) {
4597             err = socket_error();
4598             if (err == EINTR || err == EWOULDBLOCK) {
4599             } else if (err == EINPROGRESS) {
4600                 break;
4601 #ifdef _WIN32
4602             } else if (err == WSAEALREADY) {
4603                 break;
4604 #endif
4605             } else {
4606                 perror("connect");
4607                 closesocket(fd);
4608                 return -1;
4609             }
4610         } else {
4611             connected = 1;
4612             break;
4613         }
4614     }
4615     s = net_socket_fd_init(vlan, fd, connected);
4616     if (!s)
4617         return -1;
4618     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4619              "socket: connect to %s:%d",
4620              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4621     return 0;
4622 }
4623
4624 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4625 {
4626     NetSocketState *s;
4627     int fd;
4628     struct sockaddr_in saddr;
4629
4630     if (parse_host_port(&saddr, host_str) < 0)
4631         return -1;
4632
4633
4634     fd = net_socket_mcast_create(&saddr);
4635     if (fd < 0)
4636         return -1;
4637
4638     s = net_socket_fd_init(vlan, fd, 0);
4639     if (!s)
4640         return -1;
4641
4642     s->dgram_dst = saddr;
4643
4644     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4645              "socket: mcast=%s:%d",
4646              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4647     return 0;
4648
4649 }
4650
4651 static const char *get_opt_name(char *buf, int buf_size, const char *p)
4652 {
4653     char *q;
4654
4655     q = buf;
4656     while (*p != '\0' && *p != '=') {
4657         if (q && (q - buf) < buf_size - 1)
4658             *q++ = *p;
4659         p++;
4660     }
4661     if (q)
4662         *q = '\0';
4663
4664     return p;
4665 }
4666
4667 static const char *get_opt_value(char *buf, int buf_size, const char *p)
4668 {
4669     char *q;
4670
4671     q = buf;
4672     while (*p != '\0') {
4673         if (*p == ',') {
4674             if (*(p + 1) != ',')
4675                 break;
4676             p++;
4677         }
4678         if (q && (q - buf) < buf_size - 1)
4679             *q++ = *p;
4680         p++;
4681     }
4682     if (q)
4683         *q = '\0';
4684
4685     return p;
4686 }
4687
4688 static int get_param_value(char *buf, int buf_size,
4689                            const char *tag, const char *str)
4690 {
4691     const char *p;
4692     char option[128];
4693
4694     p = str;
4695     for(;;) {
4696         p = get_opt_name(option, sizeof(option), p);
4697         if (*p != '=')
4698             break;
4699         p++;
4700         if (!strcmp(tag, option)) {
4701             (void)get_opt_value(buf, buf_size, p);
4702             return strlen(buf);
4703         } else {
4704             p = get_opt_value(NULL, 0, p);
4705         }
4706         if (*p != ',')
4707             break;
4708         p++;
4709     }
4710     return 0;
4711 }
4712
4713 static int check_params(char *buf, int buf_size,
4714                         char **params, const char *str)
4715 {
4716     const char *p;
4717     int i;
4718
4719     p = str;
4720     for(;;) {
4721         p = get_opt_name(buf, buf_size, p);
4722         if (*p != '=')
4723             return -1;
4724         p++;
4725         for(i = 0; params[i] != NULL; i++)
4726             if (!strcmp(params[i], buf))
4727                 break;
4728         if (params[i] == NULL)
4729             return -1;
4730         p = get_opt_value(NULL, 0, p);
4731         if (*p != ',')
4732             break;
4733         p++;
4734     }
4735     return 0;
4736 }
4737
4738
4739 static int net_client_init(const char *str)
4740 {
4741     const char *p;
4742     char *q;
4743     char device[64];
4744     char buf[1024];
4745     int vlan_id, ret;
4746     VLANState *vlan;
4747
4748     p = str;
4749     q = device;
4750     while (*p != '\0' && *p != ',') {
4751         if ((q - device) < sizeof(device) - 1)
4752             *q++ = *p;
4753         p++;
4754     }
4755     *q = '\0';
4756     if (*p == ',')
4757         p++;
4758     vlan_id = 0;
4759     if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4760         vlan_id = strtol(buf, NULL, 0);
4761     }
4762     vlan = qemu_find_vlan(vlan_id);
4763     if (!vlan) {
4764         fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4765         return -1;
4766     }
4767     if (!strcmp(device, "nic")) {
4768         NICInfo *nd;
4769         uint8_t *macaddr;
4770
4771         if (nb_nics >= MAX_NICS) {
4772             fprintf(stderr, "Too Many NICs\n");
4773             return -1;
4774         }
4775         nd = &nd_table[nb_nics];
4776         macaddr = nd->macaddr;
4777         macaddr[0] = 0x52;
4778         macaddr[1] = 0x54;
4779         macaddr[2] = 0x00;
4780         macaddr[3] = 0x12;
4781         macaddr[4] = 0x34;
4782         macaddr[5] = 0x56 + nb_nics;
4783
4784         if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4785             if (parse_macaddr(macaddr, buf) < 0) {
4786                 fprintf(stderr, "invalid syntax for ethernet address\n");
4787                 return -1;
4788             }
4789         }
4790         if (get_param_value(buf, sizeof(buf), "model", p)) {
4791             nd->model = strdup(buf);
4792         }
4793         nd->vlan = vlan;
4794         nb_nics++;
4795         vlan->nb_guest_devs++;
4796         ret = 0;
4797     } else
4798     if (!strcmp(device, "none")) {
4799         /* does nothing. It is needed to signal that no network cards
4800            are wanted */
4801         ret = 0;
4802     } else
4803 #ifdef CONFIG_SLIRP
4804     if (!strcmp(device, "user")) {
4805         if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4806             pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4807         }
4808         vlan->nb_host_devs++;
4809         ret = net_slirp_init(vlan);
4810     } else
4811 #endif
4812 #ifdef _WIN32
4813     if (!strcmp(device, "tap")) {
4814         char ifname[64];
4815         if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4816             fprintf(stderr, "tap: no interface name\n");
4817             return -1;
4818         }
4819         vlan->nb_host_devs++;
4820         ret = tap_win32_init(vlan, ifname);
4821     } else
4822 #else
4823     if (!strcmp(device, "tap")) {
4824         char ifname[64];
4825         char setup_script[1024], down_script[1024];
4826         int fd;
4827         vlan->nb_host_devs++;
4828         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4829             fd = strtol(buf, NULL, 0);
4830             ret = -1;
4831             if (net_tap_fd_init(vlan, fd))
4832                 ret = 0;
4833         } else {
4834             if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4835                 ifname[0] = '\0';
4836             }
4837             if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
4838                 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
4839             }
4840             if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
4841                 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
4842             }
4843             ret = net_tap_init(vlan, ifname, setup_script, down_script);
4844         }
4845     } else
4846 #endif
4847     if (!strcmp(device, "socket")) {
4848         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4849             int fd;
4850             fd = strtol(buf, NULL, 0);
4851             ret = -1;
4852             if (net_socket_fd_init(vlan, fd, 1))
4853                 ret = 0;
4854         } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
4855             ret = net_socket_listen_init(vlan, buf);
4856         } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
4857             ret = net_socket_connect_init(vlan, buf);
4858         } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
4859             ret = net_socket_mcast_init(vlan, buf);
4860         } else {
4861             fprintf(stderr, "Unknown socket options: %s\n", p);
4862             return -1;
4863         }
4864         vlan->nb_host_devs++;
4865     } else
4866     {
4867         fprintf(stderr, "Unknown network device: %s\n", device);
4868         return -1;
4869     }
4870     if (ret < 0) {
4871         fprintf(stderr, "Could not initialize device '%s'\n", device);
4872     }
4873
4874     return ret;
4875 }
4876
4877 void do_info_network(void)
4878 {
4879     VLANState *vlan;
4880     VLANClientState *vc;
4881
4882     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4883         term_printf("VLAN %d devices:\n", vlan->id);
4884         for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4885             term_printf("  %s\n", vc->info_str);
4886     }
4887 }
4888
4889 #define HD_ALIAS "index=%d,media=disk"
4890 #ifdef TARGET_PPC
4891 #define CDROM_ALIAS "index=1,media=cdrom"
4892 #else
4893 #define CDROM_ALIAS "index=2,media=cdrom"
4894 #endif
4895 #define FD_ALIAS "index=%d,if=floppy"
4896 #define PFLASH_ALIAS "if=pflash"
4897 #define MTD_ALIAS "if=mtd"
4898 #define SD_ALIAS "index=0,if=sd"
4899
4900 static int drive_add(const char *file, const char *fmt, ...)
4901 {
4902     va_list ap;
4903
4904     if (nb_drives_opt >= MAX_DRIVES) {
4905         fprintf(stderr, "qemu: too many drives\n");
4906         exit(1);
4907     }
4908
4909     drives_opt[nb_drives_opt].file = file;
4910     va_start(ap, fmt);
4911     vsnprintf(drives_opt[nb_drives_opt].opt,
4912               sizeof(drives_opt[0].opt), fmt, ap);
4913     va_end(ap);
4914
4915     return nb_drives_opt++;
4916 }
4917
4918 int drive_get_index(BlockInterfaceType type, int bus, int unit)
4919 {
4920     int index;
4921
4922     /* seek interface, bus and unit */
4923
4924     for (index = 0; index < nb_drives; index++)
4925         if (drives_table[index].type == type &&
4926             drives_table[index].bus == bus &&
4927             drives_table[index].unit == unit)
4928         return index;
4929
4930     return -1;
4931 }
4932
4933 int drive_get_max_bus(BlockInterfaceType type)
4934 {
4935     int max_bus;
4936     int index;
4937
4938     max_bus = -1;
4939     for (index = 0; index < nb_drives; index++) {
4940         if(drives_table[index].type == type &&
4941            drives_table[index].bus > max_bus)
4942             max_bus = drives_table[index].bus;
4943     }
4944     return max_bus;
4945 }
4946
4947 static int drive_init(struct drive_opt *arg, int snapshot,
4948                       QEMUMachine *machine)
4949 {
4950     char buf[128];
4951     char file[1024];
4952     char devname[128];
4953     const char *mediastr = "";
4954     BlockInterfaceType type;
4955     enum { MEDIA_DISK, MEDIA_CDROM } media;
4956     int bus_id, unit_id;
4957     int cyls, heads, secs, translation;
4958     BlockDriverState *bdrv;
4959     int max_devs;
4960     int index;
4961     int cache;
4962     int bdrv_flags;
4963     char *str = arg->opt;
4964     char *params[] = { "bus", "unit", "if", "index", "cyls", "heads",
4965                        "secs", "trans", "media", "snapshot", "file",
4966                        "cache", NULL };
4967
4968     if (check_params(buf, sizeof(buf), params, str) < 0) {
4969          fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
4970                          buf, str);
4971          return -1;
4972     }
4973
4974     file[0] = 0;
4975     cyls = heads = secs = 0;
4976     bus_id = 0;
4977     unit_id = -1;
4978     translation = BIOS_ATA_TRANSLATION_AUTO;
4979     index = -1;
4980     cache = 1;
4981
4982     if (!strcmp(machine->name, "realview") ||
4983         !strcmp(machine->name, "SS-5") ||
4984         !strcmp(machine->name, "SS-10") ||
4985         !strcmp(machine->name, "SS-600MP") ||
4986         !strcmp(machine->name, "versatilepb") ||
4987         !strcmp(machine->name, "versatileab")) {
4988         type = IF_SCSI;
4989         max_devs = MAX_SCSI_DEVS;
4990         strcpy(devname, "scsi");
4991     } else {
4992         type = IF_IDE;
4993         max_devs = MAX_IDE_DEVS;
4994         strcpy(devname, "ide");
4995     }
4996     media = MEDIA_DISK;
4997
4998     /* extract parameters */
4999
5000     if (get_param_value(buf, sizeof(buf), "bus", str)) {
5001         bus_id = strtol(buf, NULL, 0);
5002         if (bus_id < 0) {
5003             fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
5004             return -1;
5005         }
5006     }
5007
5008     if (get_param_value(buf, sizeof(buf), "unit", str)) {
5009         unit_id = strtol(buf, NULL, 0);
5010         if (unit_id < 0) {
5011             fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
5012             return -1;
5013         }
5014     }
5015
5016     if (get_param_value(buf, sizeof(buf), "if", str)) {
5017         strncpy(devname, buf, sizeof(devname));
5018         if (!strcmp(buf, "ide")) {
5019             type = IF_IDE;
5020             max_devs = MAX_IDE_DEVS;
5021         } else if (!strcmp(buf, "scsi")) {
5022             type = IF_SCSI;
5023             max_devs = MAX_SCSI_DEVS;
5024         } else if (!strcmp(buf, "floppy")) {
5025             type = IF_FLOPPY;
5026             max_devs = 0;
5027         } else if (!strcmp(buf, "pflash")) {
5028             type = IF_PFLASH;
5029             max_devs = 0;
5030         } else if (!strcmp(buf, "mtd")) {
5031             type = IF_MTD;
5032             max_devs = 0;
5033         } else if (!strcmp(buf, "sd")) {
5034             type = IF_SD;
5035             max_devs = 0;
5036         } else {
5037             fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5038             return -1;
5039         }
5040     }
5041
5042     if (get_param_value(buf, sizeof(buf), "index", str)) {
5043         index = strtol(buf, NULL, 0);
5044         if (index < 0) {
5045             fprintf(stderr, "qemu: '%s' invalid index\n", str);
5046             return -1;
5047         }
5048     }
5049
5050     if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5051         cyls = strtol(buf, NULL, 0);
5052     }
5053
5054     if (get_param_value(buf, sizeof(buf), "heads", str)) {
5055         heads = strtol(buf, NULL, 0);
5056     }
5057
5058     if (get_param_value(buf, sizeof(buf), "secs", str)) {
5059         secs = strtol(buf, NULL, 0);
5060     }
5061
5062     if (cyls || heads || secs) {
5063         if (cyls < 1 || cyls > 16383) {
5064             fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5065             return -1;
5066         }
5067         if (heads < 1 || heads > 16) {
5068             fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5069             return -1;
5070         }
5071         if (secs < 1 || secs > 63) {
5072             fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5073             return -1;
5074         }
5075     }
5076
5077     if (get_param_value(buf, sizeof(buf), "trans", str)) {
5078         if (!cyls) {
5079             fprintf(stderr,
5080                     "qemu: '%s' trans must be used with cyls,heads and secs\n",
5081                     str);
5082             return -1;
5083         }
5084         if (!strcmp(buf, "none"))
5085             translation = BIOS_ATA_TRANSLATION_NONE;
5086         else if (!strcmp(buf, "lba"))
5087             translation = BIOS_ATA_TRANSLATION_LBA;
5088         else if (!strcmp(buf, "auto"))
5089             translation = BIOS_ATA_TRANSLATION_AUTO;
5090         else {
5091             fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5092             return -1;
5093         }
5094     }
5095
5096     if (get_param_value(buf, sizeof(buf), "media", str)) {
5097         if (!strcmp(buf, "disk")) {
5098             media = MEDIA_DISK;
5099         } else if (!strcmp(buf, "cdrom")) {
5100             if (cyls || secs || heads) {
5101                 fprintf(stderr,
5102                         "qemu: '%s' invalid physical CHS format\n", str);
5103                 return -1;
5104             }
5105             media = MEDIA_CDROM;
5106         } else {
5107             fprintf(stderr, "qemu: '%s' invalid media\n", str);
5108             return -1;
5109         }
5110     }
5111
5112     if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5113         if (!strcmp(buf, "on"))
5114             snapshot = 1;
5115         else if (!strcmp(buf, "off"))
5116             snapshot = 0;
5117         else {
5118             fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5119             return -1;
5120         }
5121     }
5122
5123     if (get_param_value(buf, sizeof(buf), "cache", str)) {
5124         if (!strcmp(buf, "off"))
5125             cache = 0;
5126         else if (!strcmp(buf, "on"))
5127             cache = 1;
5128         else {
5129            fprintf(stderr, "qemu: invalid cache option\n");
5130            return -1;
5131         }
5132     }
5133
5134     if (arg->file == NULL)
5135         get_param_value(file, sizeof(file), "file", str);
5136     else
5137         pstrcpy(file, sizeof(file), arg->file);
5138
5139     /* compute bus and unit according index */
5140
5141     if (index != -1) {
5142         if (bus_id != 0 || unit_id != -1) {
5143             fprintf(stderr,
5144                     "qemu: '%s' index cannot be used with bus and unit\n", str);
5145             return -1;
5146         }
5147         if (max_devs == 0)
5148         {
5149             unit_id = index;
5150             bus_id = 0;
5151         } else {
5152             unit_id = index % max_devs;
5153             bus_id = index / max_devs;
5154         }
5155     }
5156
5157     /* if user doesn't specify a unit_id,
5158      * try to find the first free
5159      */
5160
5161     if (unit_id == -1) {
5162        unit_id = 0;
5163        while (drive_get_index(type, bus_id, unit_id) != -1) {
5164            unit_id++;
5165            if (max_devs && unit_id >= max_devs) {
5166                unit_id -= max_devs;
5167                bus_id++;
5168            }
5169        }
5170     }
5171
5172     /* check unit id */
5173
5174     if (max_devs && unit_id >= max_devs) {
5175         fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5176                         str, unit_id, max_devs - 1);
5177         return -1;
5178     }
5179
5180     /*
5181      * ignore multiple definitions
5182      */
5183
5184     if (drive_get_index(type, bus_id, unit_id) != -1)
5185         return 0;
5186
5187     /* init */
5188
5189     if (type == IF_IDE || type == IF_SCSI)
5190         mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5191     if (max_devs)
5192         snprintf(buf, sizeof(buf), "%s%i%s%i",
5193                  devname, bus_id, mediastr, unit_id);
5194     else
5195         snprintf(buf, sizeof(buf), "%s%s%i",
5196                  devname, mediastr, unit_id);
5197     bdrv = bdrv_new(buf);
5198     drives_table[nb_drives].bdrv = bdrv;
5199     drives_table[nb_drives].type = type;
5200     drives_table[nb_drives].bus = bus_id;
5201     drives_table[nb_drives].unit = unit_id;
5202     nb_drives++;
5203
5204     switch(type) {
5205     case IF_IDE:
5206     case IF_SCSI:
5207         switch(media) {
5208         case MEDIA_DISK:
5209             if (cyls != 0) {
5210                 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5211                 bdrv_set_translation_hint(bdrv, translation);
5212             }
5213             break;
5214         case MEDIA_CDROM:
5215             bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5216             break;
5217         }
5218         break;
5219     case IF_SD:
5220         /* FIXME: This isn't really a floppy, but it's a reasonable
5221            approximation.  */
5222     case IF_FLOPPY:
5223         bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5224         break;
5225     case IF_PFLASH:
5226     case IF_MTD:
5227         break;
5228     }
5229     if (!file[0])
5230         return 0;
5231     bdrv_flags = 0;
5232     if (snapshot)
5233         bdrv_flags |= BDRV_O_SNAPSHOT;
5234     if (!cache)
5235         bdrv_flags |= BDRV_O_DIRECT;
5236     if (bdrv_open(bdrv, file, bdrv_flags) < 0 || qemu_key_check(bdrv, file)) {
5237         fprintf(stderr, "qemu: could not open disk image %s\n",
5238                         file);
5239         return -1;
5240     }
5241     return 0;
5242 }
5243
5244 /***********************************************************/
5245 /* USB devices */
5246
5247 static USBPort *used_usb_ports;
5248 static USBPort *free_usb_ports;
5249
5250 /* ??? Maybe change this to register a hub to keep track of the topology.  */
5251 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5252                             usb_attachfn attach)
5253 {
5254     port->opaque = opaque;
5255     port->index = index;
5256     port->attach = attach;
5257     port->next = free_usb_ports;
5258     free_usb_ports = port;
5259 }
5260
5261 static int usb_device_add(const char *devname)
5262 {
5263     const char *p;
5264     USBDevice *dev;
5265     USBPort *port;
5266
5267     if (!free_usb_ports)
5268         return -1;
5269
5270     if (strstart(devname, "host:", &p)) {
5271         dev = usb_host_device_open(p);
5272     } else if (!strcmp(devname, "mouse")) {
5273         dev = usb_mouse_init();
5274     } else if (!strcmp(devname, "tablet")) {
5275         dev = usb_tablet_init();
5276     } else if (!strcmp(devname, "keyboard")) {
5277         dev = usb_keyboard_init();
5278     } else if (strstart(devname, "disk:", &p)) {
5279         dev = usb_msd_init(p);
5280     } else if (!strcmp(devname, "wacom-tablet")) {
5281         dev = usb_wacom_init();
5282     } else if (strstart(devname, "serial:", &p)) {
5283         dev = usb_serial_init(p);
5284     } else {
5285         return -1;
5286     }
5287     if (!dev)
5288         return -1;
5289
5290     /* Find a USB port to add the device to.  */
5291     port = free_usb_ports;
5292     if (!port->next) {
5293         USBDevice *hub;
5294
5295         /* Create a new hub and chain it on.  */
5296         free_usb_ports = NULL;
5297         port->next = used_usb_ports;
5298         used_usb_ports = port;
5299
5300         hub = usb_hub_init(VM_USB_HUB_SIZE);
5301         usb_attach(port, hub);
5302         port = free_usb_ports;
5303     }
5304
5305     free_usb_ports = port->next;
5306     port->next = used_usb_ports;
5307     used_usb_ports = port;
5308     usb_attach(port, dev);
5309     return 0;
5310 }
5311
5312 static int usb_device_del(const char *devname)
5313 {
5314     USBPort *port;
5315     USBPort **lastp;
5316     USBDevice *dev;
5317     int bus_num, addr;
5318     const char *p;
5319
5320     if (!used_usb_ports)
5321         return -1;
5322
5323     p = strchr(devname, '.');
5324     if (!p)
5325         return -1;
5326     bus_num = strtoul(devname, NULL, 0);
5327     addr = strtoul(p + 1, NULL, 0);
5328     if (bus_num != 0)
5329         return -1;
5330
5331     lastp = &used_usb_ports;
5332     port = used_usb_ports;
5333     while (port && port->dev->addr != addr) {
5334         lastp = &port->next;
5335         port = port->next;
5336     }
5337
5338     if (!port)
5339         return -1;
5340
5341     dev = port->dev;
5342     *lastp = port->next;
5343     usb_attach(port, NULL);
5344     dev->handle_destroy(dev);
5345     port->next = free_usb_ports;
5346     free_usb_ports = port;
5347     return 0;
5348 }
5349
5350 void do_usb_add(const char *devname)
5351 {
5352     int ret;
5353     ret = usb_device_add(devname);
5354     if (ret < 0)
5355         term_printf("Could not add USB device '%s'\n", devname);
5356 }
5357
5358 void do_usb_del(const char *devname)
5359 {
5360     int ret;
5361     ret = usb_device_del(devname);
5362     if (ret < 0)
5363         term_printf("Could not remove USB device '%s'\n", devname);
5364 }
5365
5366 void usb_info(void)
5367 {
5368     USBDevice *dev;
5369     USBPort *port;
5370     const char *speed_str;
5371
5372     if (!usb_enabled) {
5373         term_printf("USB support not enabled\n");
5374         return;
5375     }
5376
5377     for (port = used_usb_ports; port; port = port->next) {
5378         dev = port->dev;
5379         if (!dev)
5380             continue;
5381         switch(dev->speed) {
5382         case USB_SPEED_LOW:
5383             speed_str = "1.5";
5384             break;
5385         case USB_SPEED_FULL:
5386             speed_str = "12";
5387             break;
5388         case USB_SPEED_HIGH:
5389             speed_str = "480";
5390             break;
5391         default:
5392             speed_str = "?";
5393             break;
5394         }
5395         term_printf("  Device %d.%d, Speed %s Mb/s, Product %s\n",
5396                     0, dev->addr, speed_str, dev->devname);
5397     }
5398 }
5399
5400 /***********************************************************/
5401 /* PCMCIA/Cardbus */
5402
5403 static struct pcmcia_socket_entry_s {
5404     struct pcmcia_socket_s *socket;
5405     struct pcmcia_socket_entry_s *next;
5406 } *pcmcia_sockets = 0;
5407
5408 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5409 {
5410     struct pcmcia_socket_entry_s *entry;
5411
5412     entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5413     entry->socket = socket;
5414     entry->next = pcmcia_sockets;
5415     pcmcia_sockets = entry;
5416 }
5417
5418 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5419 {
5420     struct pcmcia_socket_entry_s *entry, **ptr;
5421
5422     ptr = &pcmcia_sockets;
5423     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5424         if (entry->socket == socket) {
5425             *ptr = entry->next;
5426             qemu_free(entry);
5427         }
5428 }
5429
5430 void pcmcia_info(void)
5431 {
5432     struct pcmcia_socket_entry_s *iter;
5433     if (!pcmcia_sockets)
5434         term_printf("No PCMCIA sockets\n");
5435
5436     for (iter = pcmcia_sockets; iter; iter = iter->next)
5437         term_printf("%s: %s\n", iter->socket->slot_string,
5438                     iter->socket->attached ? iter->socket->card_string :
5439                     "Empty");
5440 }
5441
5442 /***********************************************************/
5443 /* dumb display */
5444
5445 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
5446 {
5447 }
5448
5449 static void dumb_resize(DisplayState *ds, int w, int h)
5450 {
5451 }
5452
5453 static void dumb_refresh(DisplayState *ds)
5454 {
5455 #if defined(CONFIG_SDL)
5456     vga_hw_update();
5457 #endif
5458 }
5459
5460 static void dumb_display_init(DisplayState *ds)
5461 {
5462     ds->data = NULL;
5463     ds->linesize = 0;
5464     ds->depth = 0;
5465     ds->dpy_update = dumb_update;
5466     ds->dpy_resize = dumb_resize;
5467     ds->dpy_refresh = dumb_refresh;
5468 }
5469
5470 /***********************************************************/
5471 /* I/O handling */
5472
5473 #define MAX_IO_HANDLERS 64
5474
5475 typedef struct IOHandlerRecord {
5476     int fd;
5477     IOCanRWHandler *fd_read_poll;
5478     IOHandler *fd_read;
5479     IOHandler *fd_write;
5480     int deleted;
5481     void *opaque;
5482     /* temporary data */
5483     struct pollfd *ufd;
5484     struct IOHandlerRecord *next;
5485 } IOHandlerRecord;
5486
5487 static IOHandlerRecord *first_io_handler;
5488
5489 /* XXX: fd_read_poll should be suppressed, but an API change is
5490    necessary in the character devices to suppress fd_can_read(). */
5491 int qemu_set_fd_handler2(int fd,
5492                          IOCanRWHandler *fd_read_poll,
5493                          IOHandler *fd_read,
5494                          IOHandler *fd_write,
5495                          void *opaque)
5496 {
5497     IOHandlerRecord **pioh, *ioh;
5498
5499     if (!fd_read && !fd_write) {
5500         pioh = &first_io_handler;
5501         for(;;) {
5502             ioh = *pioh;
5503             if (ioh == NULL)
5504                 break;
5505             if (ioh->fd == fd) {
5506                 ioh->deleted = 1;
5507                 break;
5508             }
5509             pioh = &ioh->next;
5510         }
5511     } else {
5512         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5513             if (ioh->fd == fd)
5514                 goto found;
5515         }
5516         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
5517         if (!ioh)
5518             return -1;
5519         ioh->next = first_io_handler;
5520         first_io_handler = ioh;
5521     found:
5522         ioh->fd = fd;
5523         ioh->fd_read_poll = fd_read_poll;
5524         ioh->fd_read = fd_read;
5525         ioh->fd_write = fd_write;
5526         ioh->opaque = opaque;
5527         ioh->deleted = 0;
5528     }
5529     return 0;
5530 }
5531
5532 int qemu_set_fd_handler(int fd,
5533                         IOHandler *fd_read,
5534                         IOHandler *fd_write,
5535                         void *opaque)
5536 {
5537     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
5538 }
5539
5540 /***********************************************************/
5541 /* Polling handling */
5542
5543 typedef struct PollingEntry {
5544     PollingFunc *func;
5545     void *opaque;
5546     struct PollingEntry *next;
5547 } PollingEntry;
5548
5549 static PollingEntry *first_polling_entry;
5550
5551 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
5552 {
5553     PollingEntry **ppe, *pe;
5554     pe = qemu_mallocz(sizeof(PollingEntry));
5555     if (!pe)
5556         return -1;
5557     pe->func = func;
5558     pe->opaque = opaque;
5559     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
5560     *ppe = pe;
5561     return 0;
5562 }
5563
5564 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
5565 {
5566     PollingEntry **ppe, *pe;
5567     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
5568         pe = *ppe;
5569         if (pe->func == func && pe->opaque == opaque) {
5570             *ppe = pe->next;
5571             qemu_free(pe);
5572             break;
5573         }
5574     }
5575 }
5576
5577 #ifdef _WIN32
5578 /***********************************************************/
5579 /* Wait objects support */
5580 typedef struct WaitObjects {
5581     int num;
5582     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
5583     WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
5584     void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
5585 } WaitObjects;
5586
5587 static WaitObjects wait_objects = {0};
5588
5589 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5590 {
5591     WaitObjects *w = &wait_objects;
5592
5593     if (w->num >= MAXIMUM_WAIT_OBJECTS)
5594         return -1;
5595     w->events[w->num] = handle;
5596     w->func[w->num] = func;
5597     w->opaque[w->num] = opaque;
5598     w->num++;
5599     return 0;
5600 }
5601
5602 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5603 {
5604     int i, found;
5605     WaitObjects *w = &wait_objects;
5606
5607     found = 0;
5608     for (i = 0; i < w->num; i++) {
5609         if (w->events[i] == handle)
5610             found = 1;
5611         if (found) {
5612             w->events[i] = w->events[i + 1];
5613             w->func[i] = w->func[i + 1];
5614             w->opaque[i] = w->opaque[i + 1];
5615         }
5616     }
5617     if (found)
5618         w->num--;
5619 }
5620 #endif
5621
5622 /***********************************************************/
5623 /* savevm/loadvm support */
5624
5625 #define IO_BUF_SIZE 32768
5626
5627 struct QEMUFile {
5628     FILE *outfile;
5629     BlockDriverState *bs;
5630     int is_file;
5631     int is_writable;
5632     int64_t base_offset;
5633     int64_t buf_offset; /* start of buffer when writing, end of buffer
5634                            when reading */
5635     int buf_index;
5636     int buf_size; /* 0 when writing */
5637     uint8_t buf[IO_BUF_SIZE];
5638 };
5639
5640 QEMUFile *qemu_fopen(const char *filename, const char *mode)
5641 {
5642     QEMUFile *f;
5643
5644     f = qemu_mallocz(sizeof(QEMUFile));
5645     if (!f)
5646         return NULL;
5647     if (!strcmp(mode, "wb")) {
5648         f->is_writable = 1;
5649     } else if (!strcmp(mode, "rb")) {
5650         f->is_writable = 0;
5651     } else {
5652         goto fail;
5653     }
5654     f->outfile = fopen(filename, mode);
5655     if (!f->outfile)
5656         goto fail;
5657     f->is_file = 1;
5658     return f;
5659  fail:
5660     if (f->outfile)
5661         fclose(f->outfile);
5662     qemu_free(f);
5663     return NULL;
5664 }
5665
5666 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5667 {
5668     QEMUFile *f;
5669
5670     f = qemu_mallocz(sizeof(QEMUFile));
5671     if (!f)
5672         return NULL;
5673     f->is_file = 0;
5674     f->bs = bs;
5675     f->is_writable = is_writable;
5676     f->base_offset = offset;
5677     return f;
5678 }
5679
5680 void qemu_fflush(QEMUFile *f)
5681 {
5682     if (!f->is_writable)
5683         return;
5684     if (f->buf_index > 0) {
5685         if (f->is_file) {
5686             fseek(f->outfile, f->buf_offset, SEEK_SET);
5687             fwrite(f->buf, 1, f->buf_index, f->outfile);
5688         } else {
5689             bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
5690                         f->buf, f->buf_index);
5691         }
5692         f->buf_offset += f->buf_index;
5693         f->buf_index = 0;
5694     }
5695 }
5696
5697 static void qemu_fill_buffer(QEMUFile *f)
5698 {
5699     int len;
5700
5701     if (f->is_writable)
5702         return;
5703     if (f->is_file) {
5704         fseek(f->outfile, f->buf_offset, SEEK_SET);
5705         len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
5706         if (len < 0)
5707             len = 0;
5708     } else {
5709         len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
5710                          f->buf, IO_BUF_SIZE);
5711         if (len < 0)
5712             len = 0;
5713     }
5714     f->buf_index = 0;
5715     f->buf_size = len;
5716     f->buf_offset += len;
5717 }
5718
5719 void qemu_fclose(QEMUFile *f)
5720 {
5721     if (f->is_writable)
5722         qemu_fflush(f);
5723     if (f->is_file) {
5724         fclose(f->outfile);
5725     }
5726     qemu_free(f);
5727 }
5728
5729 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
5730 {
5731     int l;
5732     while (size > 0) {
5733         l = IO_BUF_SIZE - f->buf_index;
5734         if (l > size)
5735             l = size;
5736         memcpy(f->buf + f->buf_index, buf, l);
5737         f->buf_index += l;
5738         buf += l;
5739         size -= l;
5740         if (f->buf_index >= IO_BUF_SIZE)
5741             qemu_fflush(f);
5742     }
5743 }
5744
5745 void qemu_put_byte(QEMUFile *f, int v)
5746 {
5747     f->buf[f->buf_index++] = v;
5748     if (f->buf_index >= IO_BUF_SIZE)
5749         qemu_fflush(f);
5750 }
5751
5752 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
5753 {
5754     int size, l;
5755
5756     size = size1;
5757     while (size > 0) {
5758         l = f->buf_size - f->buf_index;
5759         if (l == 0) {
5760             qemu_fill_buffer(f);
5761             l = f->buf_size - f->buf_index;
5762             if (l == 0)
5763                 break;
5764         }
5765         if (l > size)
5766             l = size;
5767         memcpy(buf, f->buf + f->buf_index, l);
5768         f->buf_index += l;
5769         buf += l;
5770         size -= l;
5771     }
5772     return size1 - size;
5773 }
5774
5775 int qemu_get_byte(QEMUFile *f)
5776 {
5777     if (f->buf_index >= f->buf_size) {
5778         qemu_fill_buffer(f);
5779         if (f->buf_index >= f->buf_size)
5780             return 0;
5781     }
5782     return f->buf[f->buf_index++];
5783 }
5784
5785 int64_t qemu_ftell(QEMUFile *f)
5786 {
5787     return f->buf_offset - f->buf_size + f->buf_index;
5788 }
5789
5790 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
5791 {
5792     if (whence == SEEK_SET) {
5793         /* nothing to do */
5794     } else if (whence == SEEK_CUR) {
5795         pos += qemu_ftell(f);
5796     } else {
5797         /* SEEK_END not supported */
5798         return -1;
5799     }
5800     if (f->is_writable) {
5801         qemu_fflush(f);
5802         f->buf_offset = pos;
5803     } else {
5804         f->buf_offset = pos;
5805         f->buf_index = 0;
5806         f->buf_size = 0;
5807     }
5808     return pos;
5809 }
5810
5811 void qemu_put_be16(QEMUFile *f, unsigned int v)
5812 {
5813     qemu_put_byte(f, v >> 8);
5814     qemu_put_byte(f, v);
5815 }
5816
5817 void qemu_put_be32(QEMUFile *f, unsigned int v)
5818 {
5819     qemu_put_byte(f, v >> 24);
5820     qemu_put_byte(f, v >> 16);
5821     qemu_put_byte(f, v >> 8);
5822     qemu_put_byte(f, v);
5823 }
5824
5825 void qemu_put_be64(QEMUFile *f, uint64_t v)
5826 {
5827     qemu_put_be32(f, v >> 32);
5828     qemu_put_be32(f, v);
5829 }
5830
5831 unsigned int qemu_get_be16(QEMUFile *f)
5832 {
5833     unsigned int v;
5834     v = qemu_get_byte(f) << 8;
5835     v |= qemu_get_byte(f);
5836     return v;
5837 }
5838
5839 unsigned int qemu_get_be32(QEMUFile *f)
5840 {
5841     unsigned int v;
5842     v = qemu_get_byte(f) << 24;
5843     v |= qemu_get_byte(f) << 16;
5844     v |= qemu_get_byte(f) << 8;
5845     v |= qemu_get_byte(f);
5846     return v;
5847 }
5848
5849 uint64_t qemu_get_be64(QEMUFile *f)
5850 {
5851     uint64_t v;
5852     v = (uint64_t)qemu_get_be32(f) << 32;
5853     v |= qemu_get_be32(f);
5854     return v;
5855 }
5856
5857 typedef struct SaveStateEntry {
5858     char idstr[256];
5859     int instance_id;
5860     int version_id;
5861     SaveStateHandler *save_state;
5862     LoadStateHandler *load_state;
5863     void *opaque;
5864     struct SaveStateEntry *next;
5865 } SaveStateEntry;
5866
5867 static SaveStateEntry *first_se;
5868
5869 int register_savevm(const char *idstr,
5870                     int instance_id,
5871                     int version_id,
5872                     SaveStateHandler *save_state,
5873                     LoadStateHandler *load_state,
5874                     void *opaque)
5875 {
5876     SaveStateEntry *se, **pse;
5877
5878     se = qemu_malloc(sizeof(SaveStateEntry));
5879     if (!se)
5880         return -1;
5881     pstrcpy(se->idstr, sizeof(se->idstr), idstr);
5882     se->instance_id = instance_id;
5883     se->version_id = version_id;
5884     se->save_state = save_state;
5885     se->load_state = load_state;
5886     se->opaque = opaque;
5887     se->next = NULL;
5888
5889     /* add at the end of list */
5890     pse = &first_se;
5891     while (*pse != NULL)
5892         pse = &(*pse)->next;
5893     *pse = se;
5894     return 0;
5895 }
5896
5897 #define QEMU_VM_FILE_MAGIC   0x5145564d
5898 #define QEMU_VM_FILE_VERSION 0x00000002
5899
5900 static int qemu_savevm_state(QEMUFile *f)
5901 {
5902     SaveStateEntry *se;
5903     int len, ret;
5904     int64_t cur_pos, len_pos, total_len_pos;
5905
5906     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
5907     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
5908     total_len_pos = qemu_ftell(f);
5909     qemu_put_be64(f, 0); /* total size */
5910
5911     for(se = first_se; se != NULL; se = se->next) {
5912         /* ID string */
5913         len = strlen(se->idstr);
5914         qemu_put_byte(f, len);
5915         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
5916
5917         qemu_put_be32(f, se->instance_id);
5918         qemu_put_be32(f, se->version_id);
5919
5920         /* record size: filled later */
5921         len_pos = qemu_ftell(f);
5922         qemu_put_be32(f, 0);
5923         se->save_state(f, se->opaque);
5924
5925         /* fill record size */
5926         cur_pos = qemu_ftell(f);
5927         len = cur_pos - len_pos - 4;
5928         qemu_fseek(f, len_pos, SEEK_SET);
5929         qemu_put_be32(f, len);
5930         qemu_fseek(f, cur_pos, SEEK_SET);
5931     }
5932     cur_pos = qemu_ftell(f);
5933     qemu_fseek(f, total_len_pos, SEEK_SET);
5934     qemu_put_be64(f, cur_pos - total_len_pos - 8);
5935     qemu_fseek(f, cur_pos, SEEK_SET);
5936
5937     ret = 0;
5938     return ret;
5939 }
5940
5941 static SaveStateEntry *find_se(const char *idstr, int instance_id)
5942 {
5943     SaveStateEntry *se;
5944
5945     for(se = first_se; se != NULL; se = se->next) {
5946         if (!strcmp(se->idstr, idstr) &&
5947             instance_id == se->instance_id)
5948             return se;
5949     }
5950     return NULL;
5951 }
5952
5953 static int qemu_loadvm_state(QEMUFile *f)
5954 {
5955     SaveStateEntry *se;
5956     int len, ret, instance_id, record_len, version_id;
5957     int64_t total_len, end_pos, cur_pos;
5958     unsigned int v;
5959     char idstr[256];
5960
5961     v = qemu_get_be32(f);
5962     if (v != QEMU_VM_FILE_MAGIC)
5963         goto fail;
5964     v = qemu_get_be32(f);
5965     if (v != QEMU_VM_FILE_VERSION) {
5966     fail:
5967         ret = -1;
5968         goto the_end;
5969     }
5970     total_len = qemu_get_be64(f);
5971     end_pos = total_len + qemu_ftell(f);
5972     for(;;) {
5973         if (qemu_ftell(f) >= end_pos)
5974             break;
5975         len = qemu_get_byte(f);
5976         qemu_get_buffer(f, (uint8_t *)idstr, len);
5977         idstr[len] = '\0';
5978         instance_id = qemu_get_be32(f);
5979         version_id = qemu_get_be32(f);
5980         record_len = qemu_get_be32(f);
5981 #if 0
5982         printf("idstr=%s instance=0x%x version=%d len=%d\n",
5983                idstr, instance_id, version_id, record_len);
5984 #endif
5985         cur_pos = qemu_ftell(f);
5986         se = find_se(idstr, instance_id);
5987         if (!se) {
5988             fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
5989                     instance_id, idstr);
5990         } else {
5991             ret = se->load_state(f, se->opaque, version_id);
5992             if (ret < 0) {
5993                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
5994                         instance_id, idstr);
5995             }
5996         }
5997         /* always seek to exact end of record */
5998         qemu_fseek(f, cur_pos + record_len, SEEK_SET);
5999     }
6000     ret = 0;
6001  the_end:
6002     return ret;
6003 }
6004
6005 /* device can contain snapshots */
6006 static int bdrv_can_snapshot(BlockDriverState *bs)
6007 {
6008     return (bs &&
6009             !bdrv_is_removable(bs) &&
6010             !bdrv_is_read_only(bs));
6011 }
6012
6013 /* device must be snapshots in order to have a reliable snapshot */
6014 static int bdrv_has_snapshot(BlockDriverState *bs)
6015 {
6016     return (bs &&
6017             !bdrv_is_removable(bs) &&
6018             !bdrv_is_read_only(bs));
6019 }
6020
6021 static BlockDriverState *get_bs_snapshots(void)
6022 {
6023     BlockDriverState *bs;
6024     int i;
6025
6026     if (bs_snapshots)
6027         return bs_snapshots;
6028     for(i = 0; i <= nb_drives; i++) {
6029         bs = drives_table[i].bdrv;
6030         if (bdrv_can_snapshot(bs))
6031             goto ok;
6032     }
6033     return NULL;
6034  ok:
6035     bs_snapshots = bs;
6036     return bs;
6037 }
6038
6039 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6040                               const char *name)
6041 {
6042     QEMUSnapshotInfo *sn_tab, *sn;
6043     int nb_sns, i, ret;
6044
6045     ret = -ENOENT;
6046     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6047     if (nb_sns < 0)
6048         return ret;
6049     for(i = 0; i < nb_sns; i++) {
6050         sn = &sn_tab[i];
6051         if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6052             *sn_info = *sn;
6053             ret = 0;
6054             break;
6055         }
6056     }
6057     qemu_free(sn_tab);
6058     return ret;
6059 }
6060
6061 void do_savevm(const char *name)
6062 {
6063     BlockDriverState *bs, *bs1;
6064     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6065     int must_delete, ret, i;
6066     BlockDriverInfo bdi1, *bdi = &bdi1;
6067     QEMUFile *f;
6068     int saved_vm_running;
6069 #ifdef _WIN32
6070     struct _timeb tb;
6071 #else
6072     struct timeval tv;
6073 #endif
6074
6075     bs = get_bs_snapshots();
6076     if (!bs) {
6077         term_printf("No block device can accept snapshots\n");
6078         return;
6079     }
6080
6081     /* ??? Should this occur after vm_stop?  */
6082     qemu_aio_flush();
6083
6084     saved_vm_running = vm_running;
6085     vm_stop(0);
6086
6087     must_delete = 0;
6088     if (name) {
6089         ret = bdrv_snapshot_find(bs, old_sn, name);
6090         if (ret >= 0) {
6091             must_delete = 1;
6092         }
6093     }
6094     memset(sn, 0, sizeof(*sn));
6095     if (must_delete) {
6096         pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6097         pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6098     } else {
6099         if (name)
6100             pstrcpy(sn->name, sizeof(sn->name), name);
6101     }
6102
6103     /* fill auxiliary fields */
6104 #ifdef _WIN32
6105     _ftime(&tb);
6106     sn->date_sec = tb.time;
6107     sn->date_nsec = tb.millitm * 1000000;
6108 #else
6109     gettimeofday(&tv, NULL);
6110     sn->date_sec = tv.tv_sec;
6111     sn->date_nsec = tv.tv_usec * 1000;
6112 #endif
6113     sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6114
6115     if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6116         term_printf("Device %s does not support VM state snapshots\n",
6117                     bdrv_get_device_name(bs));
6118         goto the_end;
6119     }
6120
6121     /* save the VM state */
6122     f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6123     if (!f) {
6124         term_printf("Could not open VM state file\n");
6125         goto the_end;
6126     }
6127     ret = qemu_savevm_state(f);
6128     sn->vm_state_size = qemu_ftell(f);
6129     qemu_fclose(f);
6130     if (ret < 0) {
6131         term_printf("Error %d while writing VM\n", ret);
6132         goto the_end;
6133     }
6134
6135     /* create the snapshots */
6136
6137     for(i = 0; i < nb_drives; i++) {
6138         bs1 = drives_table[i].bdrv;
6139         if (bdrv_has_snapshot(bs1)) {
6140             if (must_delete) {
6141                 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6142                 if (ret < 0) {
6143                     term_printf("Error while deleting snapshot on '%s'\n",
6144                                 bdrv_get_device_name(bs1));
6145                 }
6146             }
6147             ret = bdrv_snapshot_create(bs1, sn);
6148             if (ret < 0) {
6149                 term_printf("Error while creating snapshot on '%s'\n",
6150                             bdrv_get_device_name(bs1));
6151             }
6152         }
6153     }
6154
6155  the_end:
6156     if (saved_vm_running)
6157         vm_start();
6158 }
6159
6160 void do_loadvm(const char *name)
6161 {
6162     BlockDriverState *bs, *bs1;
6163     BlockDriverInfo bdi1, *bdi = &bdi1;
6164     QEMUFile *f;
6165     int i, ret;
6166     int saved_vm_running;
6167
6168     bs = get_bs_snapshots();
6169     if (!bs) {
6170         term_printf("No block device supports snapshots\n");
6171         return;
6172     }
6173
6174     /* Flush all IO requests so they don't interfere with the new state.  */
6175     qemu_aio_flush();
6176
6177     saved_vm_running = vm_running;
6178     vm_stop(0);
6179
6180     for(i = 0; i <= nb_drives; i++) {
6181         bs1 = drives_table[i].bdrv;
6182         if (bdrv_has_snapshot(bs1)) {
6183             ret = bdrv_snapshot_goto(bs1, name);
6184             if (ret < 0) {
6185                 if (bs != bs1)
6186                     term_printf("Warning: ");
6187                 switch(ret) {
6188                 case -ENOTSUP:
6189                     term_printf("Snapshots not supported on device '%s'\n",
6190                                 bdrv_get_device_name(bs1));
6191                     break;
6192                 case -ENOENT:
6193                     term_printf("Could not find snapshot '%s' on device '%s'\n",
6194                                 name, bdrv_get_device_name(bs1));
6195                     break;
6196                 default:
6197                     term_printf("Error %d while activating snapshot on '%s'\n",
6198                                 ret, bdrv_get_device_name(bs1));
6199                     break;
6200                 }
6201                 /* fatal on snapshot block device */
6202                 if (bs == bs1)
6203                     goto the_end;
6204             }
6205         }
6206     }
6207
6208     if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6209         term_printf("Device %s does not support VM state snapshots\n",
6210                     bdrv_get_device_name(bs));
6211         return;
6212     }
6213
6214     /* restore the VM state */
6215     f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6216     if (!f) {
6217         term_printf("Could not open VM state file\n");
6218         goto the_end;
6219     }
6220     ret = qemu_loadvm_state(f);
6221     qemu_fclose(f);
6222     if (ret < 0) {
6223         term_printf("Error %d while loading VM state\n", ret);
6224     }
6225  the_end:
6226     if (saved_vm_running)
6227         vm_start();
6228 }
6229
6230 void do_delvm(const char *name)
6231 {
6232     BlockDriverState *bs, *bs1;
6233     int i, ret;
6234
6235     bs = get_bs_snapshots();
6236     if (!bs) {
6237         term_printf("No block device supports snapshots\n");
6238         return;
6239     }
6240
6241     for(i = 0; i <= nb_drives; i++) {
6242         bs1 = drives_table[i].bdrv;
6243         if (bdrv_has_snapshot(bs1)) {
6244             ret = bdrv_snapshot_delete(bs1, name);
6245             if (ret < 0) {
6246                 if (ret == -ENOTSUP)
6247                     term_printf("Snapshots not supported on device '%s'\n",
6248                                 bdrv_get_device_name(bs1));
6249                 else
6250                     term_printf("Error %d while deleting snapshot on '%s'\n",
6251                                 ret, bdrv_get_device_name(bs1));
6252             }
6253         }
6254     }
6255 }
6256
6257 void do_info_snapshots(void)
6258 {
6259     BlockDriverState *bs, *bs1;
6260     QEMUSnapshotInfo *sn_tab, *sn;
6261     int nb_sns, i;
6262     char buf[256];
6263
6264     bs = get_bs_snapshots();
6265     if (!bs) {
6266         term_printf("No available block device supports snapshots\n");
6267         return;
6268     }
6269     term_printf("Snapshot devices:");
6270     for(i = 0; i <= nb_drives; i++) {
6271         bs1 = drives_table[i].bdrv;
6272         if (bdrv_has_snapshot(bs1)) {
6273             if (bs == bs1)
6274                 term_printf(" %s", bdrv_get_device_name(bs1));
6275         }
6276     }
6277     term_printf("\n");
6278
6279     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6280     if (nb_sns < 0) {
6281         term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
6282         return;
6283     }
6284     term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
6285     term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
6286     for(i = 0; i < nb_sns; i++) {
6287         sn = &sn_tab[i];
6288         term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
6289     }
6290     qemu_free(sn_tab);
6291 }
6292
6293 /***********************************************************/
6294 /* cpu save/restore */
6295
6296 #if defined(TARGET_I386)
6297
6298 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
6299 {
6300     qemu_put_be32(f, dt->selector);
6301     qemu_put_betl(f, dt->base);
6302     qemu_put_be32(f, dt->limit);
6303     qemu_put_be32(f, dt->flags);
6304 }
6305
6306 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
6307 {
6308     dt->selector = qemu_get_be32(f);
6309     dt->base = qemu_get_betl(f);
6310     dt->limit = qemu_get_be32(f);
6311     dt->flags = qemu_get_be32(f);
6312 }
6313
6314 void cpu_save(QEMUFile *f, void *opaque)
6315 {
6316     CPUState *env = opaque;
6317     uint16_t fptag, fpus, fpuc, fpregs_format;
6318     uint32_t hflags;
6319     int i;
6320
6321     for(i = 0; i < CPU_NB_REGS; i++)
6322         qemu_put_betls(f, &env->regs[i]);
6323     qemu_put_betls(f, &env->eip);
6324     qemu_put_betls(f, &env->eflags);
6325     hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
6326     qemu_put_be32s(f, &hflags);
6327
6328     /* FPU */
6329     fpuc = env->fpuc;
6330     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
6331     fptag = 0;
6332     for(i = 0; i < 8; i++) {
6333         fptag |= ((!env->fptags[i]) << i);
6334     }
6335
6336     qemu_put_be16s(f, &fpuc);
6337     qemu_put_be16s(f, &fpus);
6338     qemu_put_be16s(f, &fptag);
6339
6340 #ifdef USE_X86LDOUBLE
6341     fpregs_format = 0;
6342 #else
6343     fpregs_format = 1;
6344 #endif
6345     qemu_put_be16s(f, &fpregs_format);
6346
6347     for(i = 0; i < 8; i++) {
6348 #ifdef USE_X86LDOUBLE
6349         {
6350             uint64_t mant;
6351             uint16_t exp;
6352             /* we save the real CPU data (in case of MMX usage only 'mant'
6353                contains the MMX register */
6354             cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
6355             qemu_put_be64(f, mant);
6356             qemu_put_be16(f, exp);
6357         }
6358 #else
6359         /* if we use doubles for float emulation, we save the doubles to
6360            avoid losing information in case of MMX usage. It can give
6361            problems if the image is restored on a CPU where long
6362            doubles are used instead. */
6363         qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
6364 #endif
6365     }
6366
6367     for(i = 0; i < 6; i++)
6368         cpu_put_seg(f, &env->segs[i]);
6369     cpu_put_seg(f, &env->ldt);
6370     cpu_put_seg(f, &env->tr);
6371     cpu_put_seg(f, &env->gdt);
6372     cpu_put_seg(f, &env->idt);
6373
6374     qemu_put_be32s(f, &env->sysenter_cs);
6375     qemu_put_be32s(f, &env->sysenter_esp);
6376     qemu_put_be32s(f, &env->sysenter_eip);
6377
6378     qemu_put_betls(f, &env->cr[0]);
6379     qemu_put_betls(f, &env->cr[2]);
6380     qemu_put_betls(f, &env->cr[3]);
6381     qemu_put_betls(f, &env->cr[4]);
6382
6383     for(i = 0; i < 8; i++)
6384         qemu_put_betls(f, &env->dr[i]);
6385
6386     /* MMU */
6387     qemu_put_be32s(f, &env->a20_mask);
6388
6389     /* XMM */
6390     qemu_put_be32s(f, &env->mxcsr);
6391     for(i = 0; i < CPU_NB_REGS; i++) {
6392         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6393         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6394     }
6395
6396 #ifdef TARGET_X86_64
6397     qemu_put_be64s(f, &env->efer);
6398     qemu_put_be64s(f, &env->star);
6399     qemu_put_be64s(f, &env->lstar);
6400     qemu_put_be64s(f, &env->cstar);
6401     qemu_put_be64s(f, &env->fmask);
6402     qemu_put_be64s(f, &env->kernelgsbase);
6403 #endif
6404     qemu_put_be32s(f, &env->smbase);
6405 }
6406
6407 #ifdef USE_X86LDOUBLE
6408 /* XXX: add that in a FPU generic layer */
6409 union x86_longdouble {
6410     uint64_t mant;
6411     uint16_t exp;
6412 };
6413
6414 #define MANTD1(fp)      (fp & ((1LL << 52) - 1))
6415 #define EXPBIAS1 1023
6416 #define EXPD1(fp)       ((fp >> 52) & 0x7FF)
6417 #define SIGND1(fp)      ((fp >> 32) & 0x80000000)
6418
6419 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
6420 {
6421     int e;
6422     /* mantissa */
6423     p->mant = (MANTD1(temp) << 11) | (1LL << 63);
6424     /* exponent + sign */
6425     e = EXPD1(temp) - EXPBIAS1 + 16383;
6426     e |= SIGND1(temp) >> 16;
6427     p->exp = e;
6428 }
6429 #endif
6430
6431 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6432 {
6433     CPUState *env = opaque;
6434     int i, guess_mmx;
6435     uint32_t hflags;
6436     uint16_t fpus, fpuc, fptag, fpregs_format;
6437
6438     if (version_id != 3 && version_id != 4)
6439         return -EINVAL;
6440     for(i = 0; i < CPU_NB_REGS; i++)
6441         qemu_get_betls(f, &env->regs[i]);
6442     qemu_get_betls(f, &env->eip);
6443     qemu_get_betls(f, &env->eflags);
6444     qemu_get_be32s(f, &hflags);
6445
6446     qemu_get_be16s(f, &fpuc);
6447     qemu_get_be16s(f, &fpus);
6448     qemu_get_be16s(f, &fptag);
6449     qemu_get_be16s(f, &fpregs_format);
6450
6451     /* NOTE: we cannot always restore the FPU state if the image come
6452        from a host with a different 'USE_X86LDOUBLE' define. We guess
6453        if we are in an MMX state to restore correctly in that case. */
6454     guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
6455     for(i = 0; i < 8; i++) {
6456         uint64_t mant;
6457         uint16_t exp;
6458
6459         switch(fpregs_format) {
6460         case 0:
6461             mant = qemu_get_be64(f);
6462             exp = qemu_get_be16(f);
6463 #ifdef USE_X86LDOUBLE
6464             env->fpregs[i].d = cpu_set_fp80(mant, exp);
6465 #else
6466             /* difficult case */
6467             if (guess_mmx)
6468                 env->fpregs[i].mmx.MMX_Q(0) = mant;
6469             else
6470                 env->fpregs[i].d = cpu_set_fp80(mant, exp);
6471 #endif
6472             break;
6473         case 1:
6474             mant = qemu_get_be64(f);
6475 #ifdef USE_X86LDOUBLE
6476             {
6477                 union x86_longdouble *p;
6478                 /* difficult case */
6479                 p = (void *)&env->fpregs[i];
6480                 if (guess_mmx) {
6481                     p->mant = mant;
6482                     p->exp = 0xffff;
6483                 } else {
6484                     fp64_to_fp80(p, mant);
6485                 }
6486             }
6487 #else
6488             env->fpregs[i].mmx.MMX_Q(0) = mant;
6489 #endif
6490             break;
6491         default:
6492             return -EINVAL;
6493         }
6494     }
6495
6496     env->fpuc = fpuc;
6497     /* XXX: restore FPU round state */
6498     env->fpstt = (fpus >> 11) & 7;
6499     env->fpus = fpus & ~0x3800;
6500     fptag ^= 0xff;
6501     for(i = 0; i < 8; i++) {
6502         env->fptags[i] = (fptag >> i) & 1;
6503     }
6504
6505     for(i = 0; i < 6; i++)
6506         cpu_get_seg(f, &env->segs[i]);
6507     cpu_get_seg(f, &env->ldt);
6508     cpu_get_seg(f, &env->tr);
6509     cpu_get_seg(f, &env->gdt);
6510     cpu_get_seg(f, &env->idt);
6511
6512     qemu_get_be32s(f, &env->sysenter_cs);
6513     qemu_get_be32s(f, &env->sysenter_esp);
6514     qemu_get_be32s(f, &env->sysenter_eip);
6515
6516     qemu_get_betls(f, &env->cr[0]);
6517     qemu_get_betls(f, &env->cr[2]);
6518     qemu_get_betls(f, &env->cr[3]);
6519     qemu_get_betls(f, &env->cr[4]);
6520
6521     for(i = 0; i < 8; i++)
6522         qemu_get_betls(f, &env->dr[i]);
6523
6524     /* MMU */
6525     qemu_get_be32s(f, &env->a20_mask);
6526
6527     qemu_get_be32s(f, &env->mxcsr);
6528     for(i = 0; i < CPU_NB_REGS; i++) {
6529         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6530         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6531     }
6532
6533 #ifdef TARGET_X86_64
6534     qemu_get_be64s(f, &env->efer);
6535     qemu_get_be64s(f, &env->star);
6536     qemu_get_be64s(f, &env->lstar);
6537     qemu_get_be64s(f, &env->cstar);
6538     qemu_get_be64s(f, &env->fmask);
6539     qemu_get_be64s(f, &env->kernelgsbase);
6540 #endif
6541     if (version_id >= 4)
6542         qemu_get_be32s(f, &env->smbase);
6543
6544     /* XXX: compute hflags from scratch, except for CPL and IIF */
6545     env->hflags = hflags;
6546     tlb_flush(env, 1);
6547     return 0;
6548 }
6549
6550 #elif defined(TARGET_PPC)
6551 void cpu_save(QEMUFile *f, void *opaque)
6552 {
6553 }
6554
6555 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6556 {
6557     return 0;
6558 }
6559
6560 #elif defined(TARGET_MIPS)
6561 void cpu_save(QEMUFile *f, void *opaque)
6562 {
6563 }
6564
6565 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6566 {
6567     return 0;
6568 }
6569
6570 #elif defined(TARGET_SPARC)
6571 void cpu_save(QEMUFile *f, void *opaque)
6572 {
6573     CPUState *env = opaque;
6574     int i;
6575     uint32_t tmp;
6576
6577     for(i = 0; i < 8; i++)
6578         qemu_put_betls(f, &env->gregs[i]);
6579     for(i = 0; i < NWINDOWS * 16; i++)
6580         qemu_put_betls(f, &env->regbase[i]);
6581
6582     /* FPU */
6583     for(i = 0; i < TARGET_FPREGS; i++) {
6584         union {
6585             float32 f;
6586             uint32_t i;
6587         } u;
6588         u.f = env->fpr[i];
6589         qemu_put_be32(f, u.i);
6590     }
6591
6592     qemu_put_betls(f, &env->pc);
6593     qemu_put_betls(f, &env->npc);
6594     qemu_put_betls(f, &env->y);
6595     tmp = GET_PSR(env);
6596     qemu_put_be32(f, tmp);
6597     qemu_put_betls(f, &env->fsr);
6598     qemu_put_betls(f, &env->tbr);
6599 #ifndef TARGET_SPARC64
6600     qemu_put_be32s(f, &env->wim);
6601     /* MMU */
6602     for(i = 0; i < 16; i++)
6603         qemu_put_be32s(f, &env->mmuregs[i]);
6604 #endif
6605 }
6606
6607 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6608 {
6609     CPUState *env = opaque;
6610     int i;
6611     uint32_t tmp;
6612
6613     for(i = 0; i < 8; i++)
6614         qemu_get_betls(f, &env->gregs[i]);
6615     for(i = 0; i < NWINDOWS * 16; i++)
6616         qemu_get_betls(f, &env->regbase[i]);
6617
6618     /* FPU */
6619     for(i = 0; i < TARGET_FPREGS; i++) {
6620         union {
6621             float32 f;
6622             uint32_t i;
6623         } u;
6624         u.i = qemu_get_be32(f);
6625         env->fpr[i] = u.f;
6626     }
6627
6628     qemu_get_betls(f, &env->pc);
6629     qemu_get_betls(f, &env->npc);
6630     qemu_get_betls(f, &env->y);
6631     tmp = qemu_get_be32(f);
6632     env->cwp = 0; /* needed to ensure that the wrapping registers are
6633                      correctly updated */
6634     PUT_PSR(env, tmp);
6635     qemu_get_betls(f, &env->fsr);
6636     qemu_get_betls(f, &env->tbr);
6637 #ifndef TARGET_SPARC64
6638     qemu_get_be32s(f, &env->wim);
6639     /* MMU */
6640     for(i = 0; i < 16; i++)
6641         qemu_get_be32s(f, &env->mmuregs[i]);
6642 #endif
6643     tlb_flush(env, 1);
6644     return 0;
6645 }
6646
6647 #elif defined(TARGET_ARM)
6648
6649 void cpu_save(QEMUFile *f, void *opaque)
6650 {
6651     int i;
6652     CPUARMState *env = (CPUARMState *)opaque;
6653
6654     for (i = 0; i < 16; i++) {
6655         qemu_put_be32(f, env->regs[i]);
6656     }
6657     qemu_put_be32(f, cpsr_read(env));
6658     qemu_put_be32(f, env->spsr);
6659     for (i = 0; i < 6; i++) {
6660         qemu_put_be32(f, env->banked_spsr[i]);
6661         qemu_put_be32(f, env->banked_r13[i]);
6662         qemu_put_be32(f, env->banked_r14[i]);
6663     }
6664     for (i = 0; i < 5; i++) {
6665         qemu_put_be32(f, env->usr_regs[i]);
6666         qemu_put_be32(f, env->fiq_regs[i]);
6667     }
6668     qemu_put_be32(f, env->cp15.c0_cpuid);
6669     qemu_put_be32(f, env->cp15.c0_cachetype);
6670     qemu_put_be32(f, env->cp15.c1_sys);
6671     qemu_put_be32(f, env->cp15.c1_coproc);
6672     qemu_put_be32(f, env->cp15.c1_xscaleauxcr);
6673     qemu_put_be32(f, env->cp15.c2_base0);
6674     qemu_put_be32(f, env->cp15.c2_base1);
6675     qemu_put_be32(f, env->cp15.c2_mask);
6676     qemu_put_be32(f, env->cp15.c2_data);
6677     qemu_put_be32(f, env->cp15.c2_insn);
6678     qemu_put_be32(f, env->cp15.c3);
6679     qemu_put_be32(f, env->cp15.c5_insn);
6680     qemu_put_be32(f, env->cp15.c5_data);
6681     for (i = 0; i < 8; i++) {
6682         qemu_put_be32(f, env->cp15.c6_region[i]);
6683     }
6684     qemu_put_be32(f, env->cp15.c6_insn);
6685     qemu_put_be32(f, env->cp15.c6_data);
6686     qemu_put_be32(f, env->cp15.c9_insn);
6687     qemu_put_be32(f, env->cp15.c9_data);
6688     qemu_put_be32(f, env->cp15.c13_fcse);
6689     qemu_put_be32(f, env->cp15.c13_context);
6690     qemu_put_be32(f, env->cp15.c13_tls1);
6691     qemu_put_be32(f, env->cp15.c13_tls2);
6692     qemu_put_be32(f, env->cp15.c13_tls3);
6693     qemu_put_be32(f, env->cp15.c15_cpar);
6694
6695     qemu_put_be32(f, env->features);
6696
6697     if (arm_feature(env, ARM_FEATURE_VFP)) {
6698         for (i = 0;  i < 16; i++) {
6699             CPU_DoubleU u;
6700             u.d = env->vfp.regs[i];
6701             qemu_put_be32(f, u.l.upper);
6702             qemu_put_be32(f, u.l.lower);
6703         }
6704         for (i = 0; i < 16; i++) {
6705             qemu_put_be32(f, env->vfp.xregs[i]);
6706         }
6707
6708         /* TODO: Should use proper FPSCR access functions.  */
6709         qemu_put_be32(f, env->vfp.vec_len);
6710         qemu_put_be32(f, env->vfp.vec_stride);
6711
6712         if (arm_feature(env, ARM_FEATURE_VFP3)) {
6713             for (i = 16;  i < 32; i++) {
6714                 CPU_DoubleU u;
6715                 u.d = env->vfp.regs[i];
6716                 qemu_put_be32(f, u.l.upper);
6717                 qemu_put_be32(f, u.l.lower);
6718             }
6719         }
6720     }
6721
6722     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6723         for (i = 0; i < 16; i++) {
6724             qemu_put_be64(f, env->iwmmxt.regs[i]);
6725         }
6726         for (i = 0; i < 16; i++) {
6727             qemu_put_be32(f, env->iwmmxt.cregs[i]);
6728         }
6729     }
6730
6731     if (arm_feature(env, ARM_FEATURE_M)) {
6732         qemu_put_be32(f, env->v7m.other_sp);
6733         qemu_put_be32(f, env->v7m.vecbase);
6734         qemu_put_be32(f, env->v7m.basepri);
6735         qemu_put_be32(f, env->v7m.control);
6736         qemu_put_be32(f, env->v7m.current_sp);
6737         qemu_put_be32(f, env->v7m.exception);
6738     }
6739 }
6740
6741 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6742 {
6743     CPUARMState *env = (CPUARMState *)opaque;
6744     int i;
6745
6746     if (version_id != ARM_CPU_SAVE_VERSION)
6747         return -EINVAL;
6748
6749     for (i = 0; i < 16; i++) {
6750         env->regs[i] = qemu_get_be32(f);
6751     }
6752     cpsr_write(env, qemu_get_be32(f), 0xffffffff);
6753     env->spsr = qemu_get_be32(f);
6754     for (i = 0; i < 6; i++) {
6755         env->banked_spsr[i] = qemu_get_be32(f);
6756         env->banked_r13[i] = qemu_get_be32(f);
6757         env->banked_r14[i] = qemu_get_be32(f);
6758     }
6759     for (i = 0; i < 5; i++) {
6760         env->usr_regs[i] = qemu_get_be32(f);
6761         env->fiq_regs[i] = qemu_get_be32(f);
6762     }
6763     env->cp15.c0_cpuid = qemu_get_be32(f);
6764     env->cp15.c0_cachetype = qemu_get_be32(f);
6765     env->cp15.c1_sys = qemu_get_be32(f);
6766     env->cp15.c1_coproc = qemu_get_be32(f);
6767     env->cp15.c1_xscaleauxcr = qemu_get_be32(f);
6768     env->cp15.c2_base0 = qemu_get_be32(f);
6769     env->cp15.c2_base1 = qemu_get_be32(f);
6770     env->cp15.c2_mask = qemu_get_be32(f);
6771     env->cp15.c2_data = qemu_get_be32(f);
6772     env->cp15.c2_insn = qemu_get_be32(f);
6773     env->cp15.c3 = qemu_get_be32(f);
6774     env->cp15.c5_insn = qemu_get_be32(f);
6775     env->cp15.c5_data = qemu_get_be32(f);
6776     for (i = 0; i < 8; i++) {
6777         env->cp15.c6_region[i] = qemu_get_be32(f);
6778     }
6779     env->cp15.c6_insn = qemu_get_be32(f);
6780     env->cp15.c6_data = qemu_get_be32(f);
6781     env->cp15.c9_insn = qemu_get_be32(f);
6782     env->cp15.c9_data = qemu_get_be32(f);
6783     env->cp15.c13_fcse = qemu_get_be32(f);
6784     env->cp15.c13_context = qemu_get_be32(f);
6785     env->cp15.c13_tls1 = qemu_get_be32(f);
6786     env->cp15.c13_tls2 = qemu_get_be32(f);
6787     env->cp15.c13_tls3 = qemu_get_be32(f);
6788     env->cp15.c15_cpar = qemu_get_be32(f);
6789
6790     env->features = qemu_get_be32(f);
6791
6792     if (arm_feature(env, ARM_FEATURE_VFP)) {
6793         for (i = 0;  i < 16; i++) {
6794             CPU_DoubleU u;
6795             u.l.upper = qemu_get_be32(f);
6796             u.l.lower = qemu_get_be32(f);
6797             env->vfp.regs[i] = u.d;
6798         }
6799         for (i = 0; i < 16; i++) {
6800             env->vfp.xregs[i] = qemu_get_be32(f);
6801         }
6802
6803         /* TODO: Should use proper FPSCR access functions.  */
6804         env->vfp.vec_len = qemu_get_be32(f);
6805         env->vfp.vec_stride = qemu_get_be32(f);
6806
6807         if (arm_feature(env, ARM_FEATURE_VFP3)) {
6808             for (i = 0;  i < 16; i++) {
6809                 CPU_DoubleU u;
6810                 u.l.upper = qemu_get_be32(f);
6811                 u.l.lower = qemu_get_be32(f);
6812                 env->vfp.regs[i] = u.d;
6813             }
6814         }
6815     }
6816
6817     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6818         for (i = 0; i < 16; i++) {
6819             env->iwmmxt.regs[i] = qemu_get_be64(f);
6820         }
6821         for (i = 0; i < 16; i++) {
6822             env->iwmmxt.cregs[i] = qemu_get_be32(f);
6823         }
6824     }
6825
6826     if (arm_feature(env, ARM_FEATURE_M)) {
6827         env->v7m.other_sp = qemu_get_be32(f);
6828         env->v7m.vecbase = qemu_get_be32(f);
6829         env->v7m.basepri = qemu_get_be32(f);
6830         env->v7m.control = qemu_get_be32(f);
6831         env->v7m.current_sp = qemu_get_be32(f);
6832         env->v7m.exception = qemu_get_be32(f);
6833     }
6834
6835     return 0;
6836 }
6837
6838 #else
6839
6840 //#warning No CPU save/restore functions
6841
6842 #endif
6843
6844 /***********************************************************/
6845 /* ram save/restore */
6846
6847 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
6848 {
6849     int v;
6850
6851     v = qemu_get_byte(f);
6852     switch(v) {
6853     case 0:
6854         if (qemu_get_buffer(f, buf, len) != len)
6855             return -EIO;
6856         break;
6857     case 1:
6858         v = qemu_get_byte(f);
6859         memset(buf, v, len);
6860         break;
6861     default:
6862         return -EINVAL;
6863     }
6864     return 0;
6865 }
6866
6867 static int ram_load_v1(QEMUFile *f, void *opaque)
6868 {
6869     int i, ret;
6870
6871     if (qemu_get_be32(f) != phys_ram_size)
6872         return -EINVAL;
6873     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
6874         ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
6875         if (ret)
6876             return ret;
6877     }
6878     return 0;
6879 }
6880
6881 #define BDRV_HASH_BLOCK_SIZE 1024
6882 #define IOBUF_SIZE 4096
6883 #define RAM_CBLOCK_MAGIC 0xfabe
6884
6885 typedef struct RamCompressState {
6886     z_stream zstream;
6887     QEMUFile *f;
6888     uint8_t buf[IOBUF_SIZE];
6889 } RamCompressState;
6890
6891 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
6892 {
6893     int ret;
6894     memset(s, 0, sizeof(*s));
6895     s->f = f;
6896     ret = deflateInit2(&s->zstream, 1,
6897                        Z_DEFLATED, 15,
6898                        9, Z_DEFAULT_STRATEGY);
6899     if (ret != Z_OK)
6900         return -1;
6901     s->zstream.avail_out = IOBUF_SIZE;
6902     s->zstream.next_out = s->buf;
6903     return 0;
6904 }
6905
6906 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
6907 {
6908     qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
6909     qemu_put_be16(s->f, len);
6910     qemu_put_buffer(s->f, buf, len);
6911 }
6912
6913 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
6914 {
6915     int ret;
6916
6917     s->zstream.avail_in = len;
6918     s->zstream.next_in = (uint8_t *)buf;
6919     while (s->zstream.avail_in > 0) {
6920         ret = deflate(&s->zstream, Z_NO_FLUSH);
6921         if (ret != Z_OK)
6922             return -1;
6923         if (s->zstream.avail_out == 0) {
6924             ram_put_cblock(s, s->buf, IOBUF_SIZE);
6925             s->zstream.avail_out = IOBUF_SIZE;
6926             s->zstream.next_out = s->buf;
6927         }
6928     }
6929     return 0;
6930 }
6931
6932 static void ram_compress_close(RamCompressState *s)
6933 {
6934     int len, ret;
6935
6936     /* compress last bytes */
6937     for(;;) {
6938         ret = deflate(&s->zstream, Z_FINISH);
6939         if (ret == Z_OK || ret == Z_STREAM_END) {
6940             len = IOBUF_SIZE - s->zstream.avail_out;
6941             if (len > 0) {
6942                 ram_put_cblock(s, s->buf, len);
6943             }
6944             s->zstream.avail_out = IOBUF_SIZE;
6945             s->zstream.next_out = s->buf;
6946             if (ret == Z_STREAM_END)
6947                 break;
6948         } else {
6949             goto fail;
6950         }
6951     }
6952 fail:
6953     deflateEnd(&s->zstream);
6954 }
6955
6956 typedef struct RamDecompressState {
6957     z_stream zstream;
6958     QEMUFile *f;
6959     uint8_t buf[IOBUF_SIZE];
6960 } RamDecompressState;
6961
6962 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
6963 {
6964     int ret;
6965     memset(s, 0, sizeof(*s));
6966     s->f = f;
6967     ret = inflateInit(&s->zstream);
6968     if (ret != Z_OK)
6969         return -1;
6970     return 0;
6971 }
6972
6973 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
6974 {
6975     int ret, clen;
6976
6977     s->zstream.avail_out = len;
6978     s->zstream.next_out = buf;
6979     while (s->zstream.avail_out > 0) {
6980         if (s->zstream.avail_in == 0) {
6981             if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
6982                 return -1;
6983             clen = qemu_get_be16(s->f);
6984             if (clen > IOBUF_SIZE)
6985                 return -1;
6986             qemu_get_buffer(s->f, s->buf, clen);
6987             s->zstream.avail_in = clen;
6988             s->zstream.next_in = s->buf;
6989         }
6990         ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
6991         if (ret != Z_OK && ret != Z_STREAM_END) {
6992             return -1;
6993         }
6994     }
6995     return 0;
6996 }
6997
6998 static void ram_decompress_close(RamDecompressState *s)
6999 {
7000     inflateEnd(&s->zstream);
7001 }
7002
7003 static void ram_save(QEMUFile *f, void *opaque)
7004 {
7005     int i;
7006     RamCompressState s1, *s = &s1;
7007     uint8_t buf[10];
7008
7009     qemu_put_be32(f, phys_ram_size);
7010     if (ram_compress_open(s, f) < 0)
7011         return;
7012     for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7013 #if 0
7014         if (tight_savevm_enabled) {
7015             int64_t sector_num;
7016             int j;
7017
7018             /* find if the memory block is available on a virtual
7019                block device */
7020             sector_num = -1;
7021             for(j = 0; j < nb_drives; j++) {
7022                 sector_num = bdrv_hash_find(drives_table[j].bdrv,
7023                                             phys_ram_base + i,
7024                                             BDRV_HASH_BLOCK_SIZE);
7025                 if (sector_num >= 0)
7026                     break;
7027             }
7028             if (j == nb_drives)
7029                 goto normal_compress;
7030             buf[0] = 1;
7031             buf[1] = j;
7032             cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
7033             ram_compress_buf(s, buf, 10);
7034         } else
7035 #endif
7036         {
7037             //        normal_compress:
7038             buf[0] = 0;
7039             ram_compress_buf(s, buf, 1);
7040             ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
7041         }
7042     }
7043     ram_compress_close(s);
7044 }
7045
7046 static int ram_load(QEMUFile *f, void *opaque, int version_id)
7047 {
7048     RamDecompressState s1, *s = &s1;
7049     uint8_t buf[10];
7050     int i;
7051
7052     if (version_id == 1)
7053         return ram_load_v1(f, opaque);
7054     if (version_id != 2)
7055         return -EINVAL;
7056     if (qemu_get_be32(f) != phys_ram_size)
7057         return -EINVAL;
7058     if (ram_decompress_open(s, f) < 0)
7059         return -EINVAL;
7060     for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7061         if (ram_decompress_buf(s, buf, 1) < 0) {
7062             fprintf(stderr, "Error while reading ram block header\n");
7063             goto error;
7064         }
7065         if (buf[0] == 0) {
7066             if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
7067                 fprintf(stderr, "Error while reading ram block address=0x%08x", i);
7068                 goto error;
7069             }
7070         } else
7071 #if 0
7072         if (buf[0] == 1) {
7073             int bs_index;
7074             int64_t sector_num;
7075
7076             ram_decompress_buf(s, buf + 1, 9);
7077             bs_index = buf[1];
7078             sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
7079             if (bs_index >= nb_drives) {
7080                 fprintf(stderr, "Invalid block device index %d\n", bs_index);
7081                 goto error;
7082             }
7083             if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
7084                           phys_ram_base + i,
7085                           BDRV_HASH_BLOCK_SIZE / 512) < 0) {
7086                 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
7087                         bs_index, sector_num);
7088                 goto error;
7089             }
7090         } else
7091 #endif
7092         {
7093         error:
7094             printf("Error block header\n");
7095             return -EINVAL;
7096         }
7097     }
7098     ram_decompress_close(s);
7099     return 0;
7100 }
7101
7102 /***********************************************************/
7103 /* bottom halves (can be seen as timers which expire ASAP) */
7104
7105 struct QEMUBH {
7106     QEMUBHFunc *cb;
7107     void *opaque;
7108     int scheduled;
7109     QEMUBH *next;
7110 };
7111
7112 static QEMUBH *first_bh = NULL;
7113
7114 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
7115 {
7116     QEMUBH *bh;
7117     bh = qemu_mallocz(sizeof(QEMUBH));
7118     if (!bh)
7119         return NULL;
7120     bh->cb = cb;
7121     bh->opaque = opaque;
7122     return bh;
7123 }
7124
7125 int qemu_bh_poll(void)
7126 {
7127     QEMUBH *bh, **pbh;
7128     int ret;
7129
7130     ret = 0;
7131     for(;;) {
7132         pbh = &first_bh;
7133         bh = *pbh;
7134         if (!bh)
7135             break;
7136         ret = 1;
7137         *pbh = bh->next;
7138         bh->scheduled = 0;
7139         bh->cb(bh->opaque);
7140     }
7141     return ret;
7142 }
7143
7144 void qemu_bh_schedule(QEMUBH *bh)
7145 {
7146     CPUState *env = cpu_single_env;
7147     if (bh->scheduled)
7148         return;
7149     bh->scheduled = 1;
7150     bh->next = first_bh;
7151     first_bh = bh;
7152
7153     /* stop the currently executing CPU to execute the BH ASAP */
7154     if (env) {
7155         cpu_interrupt(env, CPU_INTERRUPT_EXIT);
7156     }
7157 }
7158
7159 void qemu_bh_cancel(QEMUBH *bh)
7160 {
7161     QEMUBH **pbh;
7162     if (bh->scheduled) {
7163         pbh = &first_bh;
7164         while (*pbh != bh)
7165             pbh = &(*pbh)->next;
7166         *pbh = bh->next;
7167         bh->scheduled = 0;
7168     }
7169 }
7170
7171 void qemu_bh_delete(QEMUBH *bh)
7172 {
7173     qemu_bh_cancel(bh);
7174     qemu_free(bh);
7175 }
7176
7177 /***********************************************************/
7178 /* machine registration */
7179
7180 QEMUMachine *first_machine = NULL;
7181
7182 int qemu_register_machine(QEMUMachine *m)
7183 {
7184     QEMUMachine **pm;
7185     pm = &first_machine;
7186     while (*pm != NULL)
7187         pm = &(*pm)->next;
7188     m->next = NULL;
7189     *pm = m;
7190     return 0;
7191 }
7192
7193 static QEMUMachine *find_machine(const char *name)
7194 {
7195     QEMUMachine *m;
7196
7197     for(m = first_machine; m != NULL; m = m->next) {
7198         if (!strcmp(m->name, name))
7199             return m;
7200     }
7201     return NULL;
7202 }
7203
7204 /***********************************************************/
7205 /* main execution loop */
7206
7207 static void gui_update(void *opaque)
7208 {
7209     DisplayState *ds = opaque;
7210     ds->dpy_refresh(ds);
7211     qemu_mod_timer(ds->gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
7212 }
7213
7214 struct vm_change_state_entry {
7215     VMChangeStateHandler *cb;
7216     void *opaque;
7217     LIST_ENTRY (vm_change_state_entry) entries;
7218 };
7219
7220 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
7221
7222 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
7223                                                      void *opaque)
7224 {
7225     VMChangeStateEntry *e;
7226
7227     e = qemu_mallocz(sizeof (*e));
7228     if (!e)
7229         return NULL;
7230
7231     e->cb = cb;
7232     e->opaque = opaque;
7233     LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
7234     return e;
7235 }
7236
7237 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
7238 {
7239     LIST_REMOVE (e, entries);
7240     qemu_free (e);
7241 }
7242
7243 static void vm_state_notify(int running)
7244 {
7245     VMChangeStateEntry *e;
7246
7247     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
7248         e->cb(e->opaque, running);
7249     }
7250 }
7251
7252 /* XXX: support several handlers */
7253 static VMStopHandler *vm_stop_cb;
7254 static void *vm_stop_opaque;
7255
7256 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
7257 {
7258     vm_stop_cb = cb;
7259     vm_stop_opaque = opaque;
7260     return 0;
7261 }
7262
7263 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
7264 {
7265     vm_stop_cb = NULL;
7266 }
7267
7268 void vm_start(void)
7269 {
7270     if (!vm_running) {
7271         cpu_enable_ticks();
7272         vm_running = 1;
7273         vm_state_notify(1);
7274         qemu_rearm_alarm_timer(alarm_timer);
7275     }
7276 }
7277
7278 void vm_stop(int reason)
7279 {
7280     if (vm_running) {
7281         cpu_disable_ticks();
7282         vm_running = 0;
7283         if (reason != 0) {
7284             if (vm_stop_cb) {
7285                 vm_stop_cb(vm_stop_opaque, reason);
7286             }
7287         }
7288         vm_state_notify(0);
7289     }
7290 }
7291
7292 /* reset/shutdown handler */
7293
7294 typedef struct QEMUResetEntry {
7295     QEMUResetHandler *func;
7296     void *opaque;
7297     struct QEMUResetEntry *next;
7298 } QEMUResetEntry;
7299
7300 static QEMUResetEntry *first_reset_entry;
7301 static int reset_requested;
7302 static int shutdown_requested;
7303 static int powerdown_requested;
7304
7305 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
7306 {
7307     QEMUResetEntry **pre, *re;
7308
7309     pre = &first_reset_entry;
7310     while (*pre != NULL)
7311         pre = &(*pre)->next;
7312     re = qemu_mallocz(sizeof(QEMUResetEntry));
7313     re->func = func;
7314     re->opaque = opaque;
7315     re->next = NULL;
7316     *pre = re;
7317 }
7318
7319 static void qemu_system_reset(void)
7320 {
7321     QEMUResetEntry *re;
7322
7323     /* reset all devices */
7324     for(re = first_reset_entry; re != NULL; re = re->next) {
7325         re->func(re->opaque);
7326     }
7327 }
7328
7329 void qemu_system_reset_request(void)
7330 {
7331     if (no_reboot) {
7332         shutdown_requested = 1;
7333     } else {
7334         reset_requested = 1;
7335     }
7336     if (cpu_single_env)
7337         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7338 }
7339
7340 void qemu_system_shutdown_request(void)
7341 {
7342     shutdown_requested = 1;
7343     if (cpu_single_env)
7344         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7345 }
7346
7347 void qemu_system_powerdown_request(void)
7348 {
7349     powerdown_requested = 1;
7350     if (cpu_single_env)
7351         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7352 }
7353
7354 void main_loop_wait(int timeout)
7355 {
7356     IOHandlerRecord *ioh;
7357     fd_set rfds, wfds, xfds;
7358     int ret, nfds;
7359 #ifdef _WIN32
7360     int ret2, i;
7361 #endif
7362     struct timeval tv;
7363     PollingEntry *pe;
7364
7365
7366     /* XXX: need to suppress polling by better using win32 events */
7367     ret = 0;
7368     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7369         ret |= pe->func(pe->opaque);
7370     }
7371 #ifdef _WIN32
7372     if (ret == 0) {
7373         int err;
7374         WaitObjects *w = &wait_objects;
7375
7376         ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
7377         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7378             if (w->func[ret - WAIT_OBJECT_0])
7379                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
7380
7381             /* Check for additional signaled events */
7382             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
7383
7384                 /* Check if event is signaled */
7385                 ret2 = WaitForSingleObject(w->events[i], 0);
7386                 if(ret2 == WAIT_OBJECT_0) {
7387                     if (w->func[i])
7388                         w->func[i](w->opaque[i]);
7389                 } else if (ret2 == WAIT_TIMEOUT) {
7390                 } else {
7391                     err = GetLastError();
7392                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
7393                 }
7394             }
7395         } else if (ret == WAIT_TIMEOUT) {
7396         } else {
7397             err = GetLastError();
7398             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
7399         }
7400     }
7401 #endif
7402     /* poll any events */
7403     /* XXX: separate device handlers from system ones */
7404     nfds = -1;
7405     FD_ZERO(&rfds);
7406     FD_ZERO(&wfds);
7407     FD_ZERO(&xfds);
7408     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7409         if (ioh->deleted)
7410             continue;
7411         if (ioh->fd_read &&
7412             (!ioh->fd_read_poll ||
7413              ioh->fd_read_poll(ioh->opaque) != 0)) {
7414             FD_SET(ioh->fd, &rfds);
7415             if (ioh->fd > nfds)
7416                 nfds = ioh->fd;
7417         }
7418         if (ioh->fd_write) {
7419             FD_SET(ioh->fd, &wfds);
7420             if (ioh->fd > nfds)
7421                 nfds = ioh->fd;
7422         }
7423     }
7424
7425     tv.tv_sec = 0;
7426 #ifdef _WIN32
7427     tv.tv_usec = 0;
7428 #else
7429     tv.tv_usec = timeout * 1000;
7430 #endif
7431 #if defined(CONFIG_SLIRP)
7432     if (slirp_inited) {
7433         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7434     }
7435 #endif
7436     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
7437     if (ret > 0) {
7438         IOHandlerRecord **pioh;
7439
7440         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7441             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
7442                 ioh->fd_read(ioh->opaque);
7443             }
7444             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
7445                 ioh->fd_write(ioh->opaque);
7446             }
7447         }
7448
7449         /* remove deleted IO handlers */
7450         pioh = &first_io_handler;
7451         while (*pioh) {
7452             ioh = *pioh;
7453             if (ioh->deleted) {
7454                 *pioh = ioh->next;
7455                 qemu_free(ioh);
7456             } else
7457                 pioh = &ioh->next;
7458         }
7459     }
7460 #if defined(CONFIG_SLIRP)
7461     if (slirp_inited) {
7462         if (ret < 0) {
7463             FD_ZERO(&rfds);
7464             FD_ZERO(&wfds);
7465             FD_ZERO(&xfds);
7466         }
7467         slirp_select_poll(&rfds, &wfds, &xfds);
7468     }
7469 #endif
7470     qemu_aio_poll();
7471
7472     if (vm_running) {
7473         qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
7474                         qemu_get_clock(vm_clock));
7475         /* run dma transfers, if any */
7476         DMA_run();
7477     }
7478
7479     /* real time timers */
7480     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
7481                     qemu_get_clock(rt_clock));
7482
7483     if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7484         alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7485         qemu_rearm_alarm_timer(alarm_timer);
7486     }
7487
7488     /* Check bottom-halves last in case any of the earlier events triggered
7489        them.  */
7490     qemu_bh_poll();
7491
7492 }
7493
7494 static int main_loop(void)
7495 {
7496     int ret, timeout;
7497 #ifdef CONFIG_PROFILER
7498     int64_t ti;
7499 #endif
7500     CPUState *env;
7501
7502     cur_cpu = first_cpu;
7503     next_cpu = cur_cpu->next_cpu ?: first_cpu;
7504     for(;;) {
7505         if (vm_running) {
7506
7507             for(;;) {
7508                 /* get next cpu */
7509                 env = next_cpu;
7510 #ifdef CONFIG_PROFILER
7511                 ti = profile_getclock();
7512 #endif
7513                 ret = cpu_exec(env);
7514 #ifdef CONFIG_PROFILER
7515                 qemu_time += profile_getclock() - ti;
7516 #endif
7517                 next_cpu = env->next_cpu ?: first_cpu;
7518                 if (event_pending) {
7519                     ret = EXCP_INTERRUPT;
7520                     event_pending = 0;
7521                     break;
7522                 }
7523                 if (ret == EXCP_HLT) {
7524                     /* Give the next CPU a chance to run.  */
7525                     cur_cpu = env;
7526                     continue;
7527                 }
7528                 if (ret != EXCP_HALTED)
7529                     break;
7530                 /* all CPUs are halted ? */
7531                 if (env == cur_cpu)
7532                     break;
7533             }
7534             cur_cpu = env;
7535
7536             if (shutdown_requested) {
7537                 ret = EXCP_INTERRUPT;
7538                 break;
7539             }
7540             if (reset_requested) {
7541                 reset_requested = 0;
7542                 qemu_system_reset();
7543                 ret = EXCP_INTERRUPT;
7544             }
7545             if (powerdown_requested) {
7546                 powerdown_requested = 0;
7547                 qemu_system_powerdown();
7548                 ret = EXCP_INTERRUPT;
7549             }
7550             if (ret == EXCP_DEBUG) {
7551                 vm_stop(EXCP_DEBUG);
7552             }
7553             /* If all cpus are halted then wait until the next IRQ */
7554             /* XXX: use timeout computed from timers */
7555             if (ret == EXCP_HALTED)
7556                 timeout = 10;
7557             else
7558                 timeout = 0;
7559         } else {
7560             timeout = 10;
7561         }
7562 #ifdef CONFIG_PROFILER
7563         ti = profile_getclock();
7564 #endif
7565         main_loop_wait(timeout);
7566 #ifdef CONFIG_PROFILER
7567         dev_time += profile_getclock() - ti;
7568 #endif
7569     }
7570     cpu_disable_ticks();
7571     return ret;
7572 }
7573
7574 static void help(int exitcode)
7575 {
7576     printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
7577            "usage: %s [options] [disk_image]\n"
7578            "\n"
7579            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7580            "\n"
7581            "Standard options:\n"
7582            "-M machine      select emulated machine (-M ? for list)\n"
7583            "-cpu cpu        select CPU (-cpu ? for list)\n"
7584            "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
7585            "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
7586            "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
7587            "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7588            "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][index=i]\n"
7589            "       [,cyls=c,heads=h,secs=s[,trans=t]][snapshot=on|off]"
7590            "       [,cache=on|off]\n"
7591            "                use 'file' as a drive image\n"
7592            "-mtdblock file  use 'file' as on-board Flash memory image\n"
7593            "-sd file        use 'file' as SecureDigital card image\n"
7594            "-pflash file    use 'file' as a parallel flash image\n"
7595            "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7596            "-snapshot       write to temporary files instead of disk image files\n"
7597 #ifdef CONFIG_SDL
7598            "-no-frame       open SDL window without a frame and window decorations\n"
7599            "-alt-grab       use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7600            "-no-quit        disable SDL window close capability\n"
7601 #endif
7602 #ifdef TARGET_I386
7603            "-no-fd-bootchk  disable boot signature checking for floppy disks\n"
7604 #endif
7605            "-m megs         set virtual RAM size to megs MB [default=%d]\n"
7606            "-smp n          set the number of CPUs to 'n' [default=1]\n"
7607            "-nographic      disable graphical output and redirect serial I/Os to console\n"
7608            "-portrait       rotate graphical output 90 deg left (only PXA LCD)\n"
7609 #ifndef _WIN32
7610            "-k language     use keyboard layout (for example \"fr\" for French)\n"
7611 #endif
7612 #ifdef HAS_AUDIO
7613            "-audio-help     print list of audio drivers and their options\n"
7614            "-soundhw c1,... enable audio support\n"
7615            "                and only specified sound cards (comma separated list)\n"
7616            "                use -soundhw ? to get the list of supported cards\n"
7617            "                use -soundhw all to enable all of them\n"
7618 #endif
7619            "-localtime      set the real time clock to local time [default=utc]\n"
7620            "-full-screen    start in full screen\n"
7621 #ifdef TARGET_I386
7622            "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n"
7623 #endif
7624            "-usb            enable the USB driver (will be the default soon)\n"
7625            "-usbdevice name add the host or guest USB device 'name'\n"
7626 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7627            "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"
7628 #endif
7629            "-name string    set the name of the guest\n"
7630            "\n"
7631            "Network options:\n"
7632            "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7633            "                create a new Network Interface Card and connect it to VLAN 'n'\n"
7634 #ifdef CONFIG_SLIRP
7635            "-net user[,vlan=n][,hostname=host]\n"
7636            "                connect the user mode network stack to VLAN 'n' and send\n"
7637            "                hostname 'host' to DHCP clients\n"
7638 #endif
7639 #ifdef _WIN32
7640            "-net tap[,vlan=n],ifname=name\n"
7641            "                connect the host TAP network interface to VLAN 'n'\n"
7642 #else
7643            "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7644            "                connect the host TAP network interface to VLAN 'n' and use the\n"
7645            "                network scripts 'file' (default=%s)\n"
7646            "                and 'dfile' (default=%s);\n"
7647            "                use '[down]script=no' to disable script execution;\n"
7648            "                use 'fd=h' to connect to an already opened TAP interface\n"
7649 #endif
7650            "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7651            "                connect the vlan 'n' to another VLAN using a socket connection\n"
7652            "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7653            "                connect the vlan 'n' to multicast maddr and port\n"
7654            "-net none       use it alone to have zero network devices; if no -net option\n"
7655            "                is provided, the default is '-net nic -net user'\n"
7656            "\n"
7657 #ifdef CONFIG_SLIRP
7658            "-tftp dir       allow tftp access to files in dir [-net user]\n"
7659            "-bootp file     advertise file in BOOTP replies\n"
7660 #ifndef _WIN32
7661            "-smb dir        allow SMB access to files in 'dir' [-net user]\n"
7662 #endif
7663            "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7664            "                redirect TCP or UDP connections from host to guest [-net user]\n"
7665 #endif
7666            "\n"
7667            "Linux boot specific:\n"
7668            "-kernel bzImage use 'bzImage' as kernel image\n"
7669            "-append cmdline use 'cmdline' as kernel command line\n"
7670            "-initrd file    use 'file' as initial ram disk\n"
7671            "\n"
7672            "Debug/Expert options:\n"
7673            "-monitor dev    redirect the monitor to char device 'dev'\n"
7674            "-serial dev     redirect the serial port to char device 'dev'\n"
7675            "-parallel dev   redirect the parallel port to char device 'dev'\n"
7676            "-pidfile file   Write PID to 'file'\n"
7677            "-S              freeze CPU at startup (use 'c' to start execution)\n"
7678            "-s              wait gdb connection to port\n"
7679            "-p port         set gdb connection port [default=%s]\n"
7680            "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
7681            "-hdachs c,h,s[,t]  force hard disk 0 physical geometry and the optional BIOS\n"
7682            "                translation (t=none or lba) (usually qemu can guess them)\n"
7683            "-L path         set the directory for the BIOS, VGA BIOS and keymaps\n"
7684 #ifdef USE_KQEMU
7685            "-kernel-kqemu   enable KQEMU full virtualization (default is user mode only)\n"
7686            "-no-kqemu       disable KQEMU kernel module usage\n"
7687 #endif
7688 #ifdef TARGET_I386
7689            "-std-vga        simulate a standard VGA card with VESA Bochs Extensions\n"
7690            "                (default is CL-GD5446 PCI VGA)\n"
7691            "-no-acpi        disable ACPI\n"
7692 #endif
7693 #ifdef CONFIG_CURSES
7694            "-curses         use a curses/ncurses interface instead of SDL\n"
7695 #endif
7696            "-no-reboot      exit instead of rebooting\n"
7697            "-loadvm file    start right away with a saved state (loadvm in monitor)\n"
7698            "-vnc display    start a VNC server on display\n"
7699 #ifndef _WIN32
7700            "-daemonize      daemonize QEMU after initializing\n"
7701 #endif
7702            "-option-rom rom load a file, rom, into the option ROM space\n"
7703 #ifdef TARGET_SPARC
7704            "-prom-env variable=value  set OpenBIOS nvram variables\n"
7705 #endif
7706            "-clock          force the use of the given methods for timer alarm.\n"
7707            "                To see what timers are available use -clock help\n"
7708            "-startdate      select initial date of the clock\n"
7709            "\n"
7710            "During emulation, the following keys are useful:\n"
7711            "ctrl-alt-f      toggle full screen\n"
7712            "ctrl-alt-n      switch to virtual console 'n'\n"
7713            "ctrl-alt        toggle mouse and keyboard grab\n"
7714            "\n"
7715            "When using -nographic, press 'ctrl-a h' to get some help.\n"
7716            ,
7717            "qemu",
7718            DEFAULT_RAM_SIZE,
7719 #ifndef _WIN32
7720            DEFAULT_NETWORK_SCRIPT,
7721            DEFAULT_NETWORK_DOWN_SCRIPT,
7722 #endif
7723            DEFAULT_GDBSTUB_PORT,
7724            "/tmp/qemu.log");
7725     exit(exitcode);
7726 }
7727
7728 #define HAS_ARG 0x0001
7729
7730 enum {
7731     QEMU_OPTION_h,
7732
7733     QEMU_OPTION_M,
7734     QEMU_OPTION_cpu,
7735     QEMU_OPTION_fda,
7736     QEMU_OPTION_fdb,
7737     QEMU_OPTION_hda,
7738     QEMU_OPTION_hdb,
7739     QEMU_OPTION_hdc,
7740     QEMU_OPTION_hdd,
7741     QEMU_OPTION_drive,
7742     QEMU_OPTION_cdrom,
7743     QEMU_OPTION_mtdblock,
7744     QEMU_OPTION_sd,
7745     QEMU_OPTION_pflash,
7746     QEMU_OPTION_boot,
7747     QEMU_OPTION_snapshot,
7748 #ifdef TARGET_I386
7749     QEMU_OPTION_no_fd_bootchk,
7750 #endif
7751     QEMU_OPTION_m,
7752     QEMU_OPTION_nographic,
7753     QEMU_OPTION_portrait,
7754 #ifdef HAS_AUDIO
7755     QEMU_OPTION_audio_help,
7756     QEMU_OPTION_soundhw,
7757 #endif
7758
7759     QEMU_OPTION_net,
7760     QEMU_OPTION_tftp,
7761     QEMU_OPTION_bootp,
7762     QEMU_OPTION_smb,
7763     QEMU_OPTION_redir,
7764
7765     QEMU_OPTION_kernel,
7766     QEMU_OPTION_append,
7767     QEMU_OPTION_initrd,
7768
7769     QEMU_OPTION_S,
7770     QEMU_OPTION_s,
7771     QEMU_OPTION_p,
7772     QEMU_OPTION_d,
7773     QEMU_OPTION_hdachs,
7774     QEMU_OPTION_L,
7775     QEMU_OPTION_bios,
7776     QEMU_OPTION_no_code_copy,
7777     QEMU_OPTION_k,
7778     QEMU_OPTION_localtime,
7779     QEMU_OPTION_cirrusvga,
7780     QEMU_OPTION_vmsvga,
7781     QEMU_OPTION_g,
7782     QEMU_OPTION_std_vga,
7783     QEMU_OPTION_echr,
7784     QEMU_OPTION_monitor,
7785     QEMU_OPTION_serial,
7786     QEMU_OPTION_parallel,
7787     QEMU_OPTION_loadvm,
7788     QEMU_OPTION_full_screen,
7789     QEMU_OPTION_no_frame,
7790     QEMU_OPTION_alt_grab,
7791     QEMU_OPTION_no_quit,
7792     QEMU_OPTION_pidfile,
7793     QEMU_OPTION_no_kqemu,
7794     QEMU_OPTION_kernel_kqemu,
7795     QEMU_OPTION_win2k_hack,
7796     QEMU_OPTION_usb,
7797     QEMU_OPTION_usbdevice,
7798     QEMU_OPTION_smp,
7799     QEMU_OPTION_vnc,
7800     QEMU_OPTION_no_acpi,
7801     QEMU_OPTION_curses,
7802     QEMU_OPTION_no_reboot,
7803     QEMU_OPTION_show_cursor,
7804     QEMU_OPTION_daemonize,
7805     QEMU_OPTION_option_rom,
7806     QEMU_OPTION_semihosting,
7807     QEMU_OPTION_name,
7808     QEMU_OPTION_prom_env,
7809     QEMU_OPTION_old_param,
7810     QEMU_OPTION_clock,
7811     QEMU_OPTION_startdate,
7812 };
7813
7814 typedef struct QEMUOption {
7815     const char *name;
7816     int flags;
7817     int index;
7818 } QEMUOption;
7819
7820 const QEMUOption qemu_options[] = {
7821     { "h", 0, QEMU_OPTION_h },
7822     { "help", 0, QEMU_OPTION_h },
7823
7824     { "M", HAS_ARG, QEMU_OPTION_M },
7825     { "cpu", HAS_ARG, QEMU_OPTION_cpu },
7826     { "fda", HAS_ARG, QEMU_OPTION_fda },
7827     { "fdb", HAS_ARG, QEMU_OPTION_fdb },
7828     { "hda", HAS_ARG, QEMU_OPTION_hda },
7829     { "hdb", HAS_ARG, QEMU_OPTION_hdb },
7830     { "hdc", HAS_ARG, QEMU_OPTION_hdc },
7831     { "hdd", HAS_ARG, QEMU_OPTION_hdd },
7832     { "drive", HAS_ARG, QEMU_OPTION_drive },
7833     { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
7834     { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
7835     { "sd", HAS_ARG, QEMU_OPTION_sd },
7836     { "pflash", HAS_ARG, QEMU_OPTION_pflash },
7837     { "boot", HAS_ARG, QEMU_OPTION_boot },
7838     { "snapshot", 0, QEMU_OPTION_snapshot },
7839 #ifdef TARGET_I386
7840     { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
7841 #endif
7842     { "m", HAS_ARG, QEMU_OPTION_m },
7843     { "nographic", 0, QEMU_OPTION_nographic },
7844     { "portrait", 0, QEMU_OPTION_portrait },
7845     { "k", HAS_ARG, QEMU_OPTION_k },
7846 #ifdef HAS_AUDIO
7847     { "audio-help", 0, QEMU_OPTION_audio_help },
7848     { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
7849 #endif
7850
7851     { "net", HAS_ARG, QEMU_OPTION_net},
7852 #ifdef CONFIG_SLIRP
7853     { "tftp", HAS_ARG, QEMU_OPTION_tftp },
7854     { "bootp", HAS_ARG, QEMU_OPTION_bootp },
7855 #ifndef _WIN32
7856     { "smb", HAS_ARG, QEMU_OPTION_smb },
7857 #endif
7858     { "redir", HAS_ARG, QEMU_OPTION_redir },
7859 #endif
7860
7861     { "kernel", HAS_ARG, QEMU_OPTION_kernel },
7862     { "append", HAS_ARG, QEMU_OPTION_append },
7863     { "initrd", HAS_ARG, QEMU_OPTION_initrd },
7864
7865     { "S", 0, QEMU_OPTION_S },
7866     { "s", 0, QEMU_OPTION_s },
7867     { "p", HAS_ARG, QEMU_OPTION_p },
7868     { "d", HAS_ARG, QEMU_OPTION_d },
7869     { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
7870     { "L", HAS_ARG, QEMU_OPTION_L },
7871     { "bios", HAS_ARG, QEMU_OPTION_bios },
7872     { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
7873 #ifdef USE_KQEMU
7874     { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
7875     { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
7876 #endif
7877 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7878     { "g", 1, QEMU_OPTION_g },
7879 #endif
7880     { "localtime", 0, QEMU_OPTION_localtime },
7881     { "std-vga", 0, QEMU_OPTION_std_vga },
7882     { "echr", HAS_ARG, QEMU_OPTION_echr },
7883     { "monitor", HAS_ARG, QEMU_OPTION_monitor },
7884     { "serial", HAS_ARG, QEMU_OPTION_serial },
7885     { "parallel", HAS_ARG, QEMU_OPTION_parallel },
7886     { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
7887     { "full-screen", 0, QEMU_OPTION_full_screen },
7888 #ifdef CONFIG_SDL
7889     { "no-frame", 0, QEMU_OPTION_no_frame },
7890     { "alt-grab", 0, QEMU_OPTION_alt_grab },
7891     { "no-quit", 0, QEMU_OPTION_no_quit },
7892 #endif
7893     { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
7894     { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
7895     { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
7896     { "smp", HAS_ARG, QEMU_OPTION_smp },
7897     { "vnc", HAS_ARG, QEMU_OPTION_vnc },
7898 #ifdef CONFIG_CURSES
7899     { "curses", 0, QEMU_OPTION_curses },
7900 #endif
7901
7902     /* temporary options */
7903     { "usb", 0, QEMU_OPTION_usb },
7904     { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
7905     { "vmwarevga", 0, QEMU_OPTION_vmsvga },
7906     { "no-acpi", 0, QEMU_OPTION_no_acpi },
7907     { "no-reboot", 0, QEMU_OPTION_no_reboot },
7908     { "show-cursor", 0, QEMU_OPTION_show_cursor },
7909     { "daemonize", 0, QEMU_OPTION_daemonize },
7910     { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
7911 #if defined(TARGET_ARM) || defined(TARGET_M68K)
7912     { "semihosting", 0, QEMU_OPTION_semihosting },
7913 #endif
7914     { "name", HAS_ARG, QEMU_OPTION_name },
7915 #if defined(TARGET_SPARC)
7916     { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
7917 #endif
7918 #if defined(TARGET_ARM)
7919     { "old-param", 0, QEMU_OPTION_old_param },
7920 #endif
7921     { "clock", HAS_ARG, QEMU_OPTION_clock },
7922     { "startdate", HAS_ARG, QEMU_OPTION_startdate },
7923     { NULL },
7924 };
7925
7926 /* password input */
7927
7928 int qemu_key_check(BlockDriverState *bs, const char *name)
7929 {
7930     char password[256];
7931     int i;
7932
7933     if (!bdrv_is_encrypted(bs))
7934         return 0;
7935
7936     term_printf("%s is encrypted.\n", name);
7937     for(i = 0; i < 3; i++) {
7938         monitor_readline("Password: ", 1, password, sizeof(password));
7939         if (bdrv_set_key(bs, password) == 0)
7940             return 0;
7941         term_printf("invalid password\n");
7942     }
7943     return -EPERM;
7944 }
7945
7946 static BlockDriverState *get_bdrv(int index)
7947 {
7948     if (index > nb_drives)
7949         return NULL;
7950     return drives_table[index].bdrv;
7951 }
7952
7953 static void read_passwords(void)
7954 {
7955     BlockDriverState *bs;
7956     int i;
7957
7958     for(i = 0; i < 6; i++) {
7959         bs = get_bdrv(i);
7960         if (bs)
7961             qemu_key_check(bs, bdrv_get_device_name(bs));
7962     }
7963 }
7964
7965 /* XXX: currently we cannot use simultaneously different CPUs */
7966 static void register_machines(void)
7967 {
7968 #if defined(TARGET_I386)
7969     qemu_register_machine(&pc_machine);
7970     qemu_register_machine(&isapc_machine);
7971 #elif defined(TARGET_PPC)
7972     qemu_register_machine(&heathrow_machine);
7973     qemu_register_machine(&core99_machine);
7974     qemu_register_machine(&prep_machine);
7975     qemu_register_machine(&ref405ep_machine);
7976     qemu_register_machine(&taihu_machine);
7977 #elif defined(TARGET_MIPS)
7978     qemu_register_machine(&mips_machine);
7979     qemu_register_machine(&mips_malta_machine);
7980     qemu_register_machine(&mips_pica61_machine);
7981     qemu_register_machine(&mips_mipssim_machine);
7982 #elif defined(TARGET_SPARC)
7983 #ifdef TARGET_SPARC64
7984     qemu_register_machine(&sun4u_machine);
7985 #else
7986     qemu_register_machine(&ss5_machine);
7987     qemu_register_machine(&ss10_machine);
7988     qemu_register_machine(&ss600mp_machine);
7989     qemu_register_machine(&ss20_machine);
7990     qemu_register_machine(&ss2_machine);
7991     qemu_register_machine(&ss1000_machine);
7992     qemu_register_machine(&ss2000_machine);
7993 #endif
7994 #elif defined(TARGET_ARM)
7995     qemu_register_machine(&integratorcp_machine);
7996     qemu_register_machine(&versatilepb_machine);
7997     qemu_register_machine(&versatileab_machine);
7998     qemu_register_machine(&realview_machine);
7999     qemu_register_machine(&akitapda_machine);
8000     qemu_register_machine(&spitzpda_machine);
8001     qemu_register_machine(&borzoipda_machine);
8002     qemu_register_machine(&terrierpda_machine);
8003     qemu_register_machine(&palmte_machine);
8004     qemu_register_machine(&lm3s811evb_machine);
8005     qemu_register_machine(&lm3s6965evb_machine);
8006     qemu_register_machine(&connex_machine);
8007     qemu_register_machine(&verdex_machine);
8008     qemu_register_machine(&mainstone2_machine);
8009 #elif defined(TARGET_SH4)
8010     qemu_register_machine(&shix_machine);
8011     qemu_register_machine(&r2d_machine);
8012 #elif defined(TARGET_ALPHA)
8013     /* XXX: TODO */
8014 #elif defined(TARGET_M68K)
8015     qemu_register_machine(&mcf5208evb_machine);
8016     qemu_register_machine(&an5206_machine);
8017     qemu_register_machine(&dummy_m68k_machine);
8018 #elif defined(TARGET_CRIS)
8019     qemu_register_machine(&bareetraxfs_machine);
8020 #else
8021 #error unsupported CPU
8022 #endif
8023 }
8024
8025 #ifdef HAS_AUDIO
8026 struct soundhw soundhw[] = {
8027 #ifdef HAS_AUDIO_CHOICE
8028 #ifdef TARGET_I386
8029     {
8030         "pcspk",
8031         "PC speaker",
8032         0,
8033         1,
8034         { .init_isa = pcspk_audio_init }
8035     },
8036 #endif
8037     {
8038         "sb16",
8039         "Creative Sound Blaster 16",
8040         0,
8041         1,
8042         { .init_isa = SB16_init }
8043     },
8044
8045 #ifdef CONFIG_ADLIB
8046     {
8047         "adlib",
8048 #ifdef HAS_YMF262
8049         "Yamaha YMF262 (OPL3)",
8050 #else
8051         "Yamaha YM3812 (OPL2)",
8052 #endif
8053         0,
8054         1,
8055         { .init_isa = Adlib_init }
8056     },
8057 #endif
8058
8059 #ifdef CONFIG_GUS
8060     {
8061         "gus",
8062         "Gravis Ultrasound GF1",
8063         0,
8064         1,
8065         { .init_isa = GUS_init }
8066     },
8067 #endif
8068
8069 #ifdef CONFIG_AC97
8070     {
8071         "ac97",
8072         "Intel 82801AA AC97 Audio",
8073         0,
8074         0,
8075         { .init_pci = ac97_init }
8076     },
8077 #endif
8078
8079     {
8080         "es1370",
8081         "ENSONIQ AudioPCI ES1370",
8082         0,
8083         0,
8084         { .init_pci = es1370_init }
8085     },
8086 #endif
8087
8088     { NULL, NULL, 0, 0, { NULL } }
8089 };
8090
8091 static void select_soundhw (const char *optarg)
8092 {
8093     struct soundhw *c;
8094
8095     if (*optarg == '?') {
8096     show_valid_cards:
8097
8098         printf ("Valid sound card names (comma separated):\n");
8099         for (c = soundhw; c->name; ++c) {
8100             printf ("%-11s %s\n", c->name, c->descr);
8101         }
8102         printf ("\n-soundhw all will enable all of the above\n");
8103         exit (*optarg != '?');
8104     }
8105     else {
8106         size_t l;
8107         const char *p;
8108         char *e;
8109         int bad_card = 0;
8110
8111         if (!strcmp (optarg, "all")) {
8112             for (c = soundhw; c->name; ++c) {
8113                 c->enabled = 1;
8114             }
8115             return;
8116         }
8117
8118         p = optarg;
8119         while (*p) {
8120             e = strchr (p, ',');
8121             l = !e ? strlen (p) : (size_t) (e - p);
8122
8123             for (c = soundhw; c->name; ++c) {
8124                 if (!strncmp (c->name, p, l)) {
8125                     c->enabled = 1;
8126                     break;
8127                 }
8128             }
8129
8130             if (!c->name) {
8131                 if (l > 80) {
8132                     fprintf (stderr,
8133                              "Unknown sound card name (too big to show)\n");
8134                 }
8135                 else {
8136                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
8137                              (int) l, p);
8138                 }
8139                 bad_card = 1;
8140             }
8141             p += l + (e != NULL);
8142         }
8143
8144         if (bad_card)
8145             goto show_valid_cards;
8146     }
8147 }
8148 #endif
8149
8150 #ifdef _WIN32
8151 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
8152 {
8153     exit(STATUS_CONTROL_C_EXIT);
8154     return TRUE;
8155 }
8156 #endif
8157
8158 #define MAX_NET_CLIENTS 32
8159
8160 int main(int argc, char **argv)
8161 {
8162 #ifdef CONFIG_GDBSTUB
8163     int use_gdbstub;
8164     const char *gdbstub_port;
8165 #endif
8166     uint32_t boot_devices_bitmap = 0;
8167     int i;
8168     int snapshot, linux_boot, net_boot;
8169     const char *initrd_filename;
8170     const char *kernel_filename, *kernel_cmdline;
8171     const char *boot_devices = "";
8172     DisplayState *ds = &display_state;
8173     int cyls, heads, secs, translation;
8174     char net_clients[MAX_NET_CLIENTS][256];
8175     int nb_net_clients;
8176     int hda_index;
8177     int optind;
8178     const char *r, *optarg;
8179     CharDriverState *monitor_hd;
8180     char monitor_device[128];
8181     char serial_devices[MAX_SERIAL_PORTS][128];
8182     int serial_device_index;
8183     char parallel_devices[MAX_PARALLEL_PORTS][128];
8184     int parallel_device_index;
8185     const char *loadvm = NULL;
8186     QEMUMachine *machine;
8187     const char *cpu_model;
8188     char usb_devices[MAX_USB_CMDLINE][128];
8189     int usb_devices_index;
8190     int fds[2];
8191     const char *pid_file = NULL;
8192     VLANState *vlan;
8193
8194     LIST_INIT (&vm_change_state_head);
8195 #ifndef _WIN32
8196     {
8197         struct sigaction act;
8198         sigfillset(&act.sa_mask);
8199         act.sa_flags = 0;
8200         act.sa_handler = SIG_IGN;
8201         sigaction(SIGPIPE, &act, NULL);
8202     }
8203 #else
8204     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
8205     /* Note: cpu_interrupt() is currently not SMP safe, so we force
8206        QEMU to run on a single CPU */
8207     {
8208         HANDLE h;
8209         DWORD mask, smask;
8210         int i;
8211         h = GetCurrentProcess();
8212         if (GetProcessAffinityMask(h, &mask, &smask)) {
8213             for(i = 0; i < 32; i++) {
8214                 if (mask & (1 << i))
8215                     break;
8216             }
8217             if (i != 32) {
8218                 mask = 1 << i;
8219                 SetProcessAffinityMask(h, mask);
8220             }
8221         }
8222     }
8223 #endif
8224
8225     register_machines();
8226     machine = first_machine;
8227     cpu_model = NULL;
8228     initrd_filename = NULL;
8229     ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
8230     vga_ram_size = VGA_RAM_SIZE;
8231 #ifdef CONFIG_GDBSTUB
8232     use_gdbstub = 0;
8233     gdbstub_port = DEFAULT_GDBSTUB_PORT;
8234 #endif
8235     snapshot = 0;
8236     nographic = 0;
8237     curses = 0;
8238     kernel_filename = NULL;
8239     kernel_cmdline = "";
8240     cyls = heads = secs = 0;
8241     translation = BIOS_ATA_TRANSLATION_AUTO;
8242     pstrcpy(monitor_device, sizeof(monitor_device), "vc");
8243
8244     pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
8245     for(i = 1; i < MAX_SERIAL_PORTS; i++)
8246         serial_devices[i][0] = '\0';
8247     serial_device_index = 0;
8248
8249     pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
8250     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
8251         parallel_devices[i][0] = '\0';
8252     parallel_device_index = 0;
8253
8254     usb_devices_index = 0;
8255
8256     nb_net_clients = 0;
8257     nb_drives = 0;
8258     nb_drives_opt = 0;
8259     hda_index = -1;
8260
8261     nb_nics = 0;
8262     /* default mac address of the first network interface */
8263
8264     optind = 1;
8265     for(;;) {
8266         if (optind >= argc)
8267             break;
8268         r = argv[optind];
8269         if (r[0] != '-') {
8270             hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
8271         } else {
8272             const QEMUOption *popt;
8273
8274             optind++;
8275             /* Treat --foo the same as -foo.  */
8276             if (r[1] == '-')
8277                 r++;
8278             popt = qemu_options;
8279             for(;;) {
8280                 if (!popt->name) {
8281                     fprintf(stderr, "%s: invalid option -- '%s'\n",
8282                             argv[0], r);
8283                     exit(1);
8284                 }
8285                 if (!strcmp(popt->name, r + 1))
8286                     break;
8287                 popt++;
8288             }
8289             if (popt->flags & HAS_ARG) {
8290                 if (optind >= argc) {
8291                     fprintf(stderr, "%s: option '%s' requires an argument\n",
8292                             argv[0], r);
8293                     exit(1);
8294                 }
8295                 optarg = argv[optind++];
8296             } else {
8297                 optarg = NULL;
8298             }
8299
8300             switch(popt->index) {
8301             case QEMU_OPTION_M:
8302                 machine = find_machine(optarg);
8303                 if (!machine) {
8304                     QEMUMachine *m;
8305                     printf("Supported machines are:\n");
8306                     for(m = first_machine; m != NULL; m = m->next) {
8307                         printf("%-10s %s%s\n",
8308                                m->name, m->desc,
8309                                m == first_machine ? " (default)" : "");
8310                     }
8311                     exit(*optarg != '?');
8312                 }
8313                 break;
8314             case QEMU_OPTION_cpu:
8315                 /* hw initialization will check this */
8316                 if (*optarg == '?') {
8317 /* XXX: implement xxx_cpu_list for targets that still miss it */
8318 #if defined(cpu_list)
8319                     cpu_list(stdout, &fprintf);
8320 #endif
8321                     exit(0);
8322                 } else {
8323                     cpu_model = optarg;
8324                 }
8325                 break;
8326             case QEMU_OPTION_initrd:
8327                 initrd_filename = optarg;
8328                 break;
8329             case QEMU_OPTION_hda:
8330                 if (cyls == 0)
8331                     hda_index = drive_add(optarg, HD_ALIAS, 0);
8332                 else
8333                     hda_index = drive_add(optarg, HD_ALIAS
8334                              ",cyls=%d,heads=%d,secs=%d%s",
8335                              0, cyls, heads, secs,
8336                              translation == BIOS_ATA_TRANSLATION_LBA ?
8337                                  ",trans=lba" :
8338                              translation == BIOS_ATA_TRANSLATION_NONE ?
8339                                  ",trans=none" : "");
8340                  break;
8341             case QEMU_OPTION_hdb:
8342             case QEMU_OPTION_hdc:
8343             case QEMU_OPTION_hdd:
8344                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
8345                 break;
8346             case QEMU_OPTION_drive:
8347                 drive_add(NULL, "%s", optarg);
8348                 break;
8349             case QEMU_OPTION_mtdblock:
8350                 drive_add(optarg, MTD_ALIAS);
8351                 break;
8352             case QEMU_OPTION_sd:
8353                 drive_add(optarg, SD_ALIAS);
8354                 break;
8355             case QEMU_OPTION_pflash:
8356                 drive_add(optarg, PFLASH_ALIAS);
8357                 break;
8358             case QEMU_OPTION_snapshot:
8359                 snapshot = 1;
8360                 break;
8361             case QEMU_OPTION_hdachs:
8362                 {
8363                     const char *p;
8364                     p = optarg;
8365                     cyls = strtol(p, (char **)&p, 0);
8366                     if (cyls < 1 || cyls > 16383)
8367                         goto chs_fail;
8368                     if (*p != ',')
8369                         goto chs_fail;
8370                     p++;
8371                     heads = strtol(p, (char **)&p, 0);
8372                     if (heads < 1 || heads > 16)
8373                         goto chs_fail;
8374                     if (*p != ',')
8375                         goto chs_fail;
8376                     p++;
8377                     secs = strtol(p, (char **)&p, 0);
8378                     if (secs < 1 || secs > 63)
8379                         goto chs_fail;
8380                     if (*p == ',') {
8381                         p++;
8382                         if (!strcmp(p, "none"))
8383                             translation = BIOS_ATA_TRANSLATION_NONE;
8384                         else if (!strcmp(p, "lba"))
8385                             translation = BIOS_ATA_TRANSLATION_LBA;
8386                         else if (!strcmp(p, "auto"))
8387                             translation = BIOS_ATA_TRANSLATION_AUTO;
8388                         else
8389                             goto chs_fail;
8390                     } else if (*p != '\0') {
8391                     chs_fail:
8392                         fprintf(stderr, "qemu: invalid physical CHS format\n");
8393                         exit(1);
8394                     }
8395                     if (hda_index != -1)
8396                         snprintf(drives_opt[hda_index].opt,
8397                                  sizeof(drives_opt[hda_index].opt),
8398                                  HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
8399                                  0, cyls, heads, secs,
8400                                  translation == BIOS_ATA_TRANSLATION_LBA ?
8401                                     ",trans=lba" :
8402                                  translation == BIOS_ATA_TRANSLATION_NONE ?
8403                                      ",trans=none" : "");
8404                 }
8405                 break;
8406             case QEMU_OPTION_nographic:
8407                 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
8408                 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "null");
8409                 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
8410                 nographic = 1;
8411                 break;
8412 #ifdef CONFIG_CURSES
8413             case QEMU_OPTION_curses:
8414                 curses = 1;
8415                 break;
8416 #endif
8417             case QEMU_OPTION_portrait:
8418                 graphic_rotate = 1;
8419                 break;
8420             case QEMU_OPTION_kernel:
8421                 kernel_filename = optarg;
8422                 break;
8423             case QEMU_OPTION_append:
8424                 kernel_cmdline = optarg;
8425                 break;
8426             case QEMU_OPTION_cdrom:
8427                 drive_add(optarg, CDROM_ALIAS);
8428                 break;
8429             case QEMU_OPTION_boot:
8430                 boot_devices = optarg;
8431                 /* We just do some generic consistency checks */
8432                 {
8433                     /* Could easily be extended to 64 devices if needed */
8434                     const char *p;
8435
8436                     boot_devices_bitmap = 0;
8437                     for (p = boot_devices; *p != '\0'; p++) {
8438                         /* Allowed boot devices are:
8439                          * a b     : floppy disk drives
8440                          * c ... f : IDE disk drives
8441                          * g ... m : machine implementation dependant drives
8442                          * n ... p : network devices
8443                          * It's up to each machine implementation to check
8444                          * if the given boot devices match the actual hardware
8445                          * implementation and firmware features.
8446                          */
8447                         if (*p < 'a' || *p > 'q') {
8448                             fprintf(stderr, "Invalid boot device '%c'\n", *p);
8449                             exit(1);
8450                         }
8451                         if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8452                             fprintf(stderr,
8453                                     "Boot device '%c' was given twice\n",*p);
8454                             exit(1);
8455                         }
8456                         boot_devices_bitmap |= 1 << (*p - 'a');
8457                     }
8458                 }
8459                 break;
8460             case QEMU_OPTION_fda:
8461             case QEMU_OPTION_fdb:
8462                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
8463                 break;
8464 #ifdef TARGET_I386
8465             case QEMU_OPTION_no_fd_bootchk:
8466                 fd_bootchk = 0;
8467                 break;
8468 #endif
8469             case QEMU_OPTION_no_code_copy:
8470                 code_copy_enabled = 0;
8471                 break;
8472             case QEMU_OPTION_net:
8473                 if (nb_net_clients >= MAX_NET_CLIENTS) {
8474                     fprintf(stderr, "qemu: too many network clients\n");
8475                     exit(1);
8476                 }
8477                 pstrcpy(net_clients[nb_net_clients],
8478                         sizeof(net_clients[0]),
8479                         optarg);
8480                 nb_net_clients++;
8481                 break;
8482 #ifdef CONFIG_SLIRP
8483             case QEMU_OPTION_tftp:
8484                 tftp_prefix = optarg;
8485                 break;
8486             case QEMU_OPTION_bootp:
8487                 bootp_filename = optarg;
8488                 break;
8489 #ifndef _WIN32
8490             case QEMU_OPTION_smb:
8491                 net_slirp_smb(optarg);
8492                 break;
8493 #endif
8494             case QEMU_OPTION_redir:
8495                 net_slirp_redir(optarg);
8496                 break;
8497 #endif
8498 #ifdef HAS_AUDIO
8499             case QEMU_OPTION_audio_help:
8500                 AUD_help ();
8501                 exit (0);
8502                 break;
8503             case QEMU_OPTION_soundhw:
8504                 select_soundhw (optarg);
8505                 break;
8506 #endif
8507             case QEMU_OPTION_h:
8508                 help(0);
8509                 break;
8510             case QEMU_OPTION_m:
8511                 ram_size = atoi(optarg) * 1024 * 1024;
8512                 if (ram_size <= 0)
8513                     help(1);
8514                 if (ram_size > PHYS_RAM_MAX_SIZE) {
8515                     fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
8516                             PHYS_RAM_MAX_SIZE / (1024 * 1024));
8517                     exit(1);
8518                 }
8519                 break;
8520             case QEMU_OPTION_d:
8521                 {
8522                     int mask;
8523                     CPULogItem *item;
8524
8525                     mask = cpu_str_to_log_mask(optarg);
8526                     if (!mask) {
8527                         printf("Log items (comma separated):\n");
8528                     for(item = cpu_log_items; item->mask != 0; item++) {
8529                         printf("%-10s %s\n", item->name, item->help);
8530                     }
8531                     exit(1);
8532                     }
8533                     cpu_set_log(mask);
8534                 }
8535                 break;
8536 #ifdef CONFIG_GDBSTUB
8537             case QEMU_OPTION_s:
8538                 use_gdbstub = 1;
8539                 break;
8540             case QEMU_OPTION_p:
8541                 gdbstub_port = optarg;
8542                 break;
8543 #endif
8544             case QEMU_OPTION_L:
8545                 bios_dir = optarg;
8546                 break;
8547             case QEMU_OPTION_bios:
8548                 bios_name = optarg;
8549                 break;
8550             case QEMU_OPTION_S:
8551                 autostart = 0;
8552                 break;
8553             case QEMU_OPTION_k:
8554                 keyboard_layout = optarg;
8555                 break;
8556             case QEMU_OPTION_localtime:
8557                 rtc_utc = 0;
8558                 break;
8559             case QEMU_OPTION_cirrusvga:
8560                 cirrus_vga_enabled = 1;
8561                 vmsvga_enabled = 0;
8562                 break;
8563             case QEMU_OPTION_vmsvga:
8564                 cirrus_vga_enabled = 0;
8565                 vmsvga_enabled = 1;
8566                 break;
8567             case QEMU_OPTION_std_vga:
8568                 cirrus_vga_enabled = 0;
8569                 vmsvga_enabled = 0;
8570                 break;
8571             case QEMU_OPTION_g:
8572                 {
8573                     const char *p;
8574                     int w, h, depth;
8575                     p = optarg;
8576                     w = strtol(p, (char **)&p, 10);
8577                     if (w <= 0) {
8578                     graphic_error:
8579                         fprintf(stderr, "qemu: invalid resolution or depth\n");
8580                         exit(1);
8581                     }
8582                     if (*p != 'x')
8583                         goto graphic_error;
8584                     p++;
8585                     h = strtol(p, (char **)&p, 10);
8586                     if (h <= 0)
8587                         goto graphic_error;
8588                     if (*p == 'x') {
8589                         p++;
8590                         depth = strtol(p, (char **)&p, 10);
8591                         if (depth != 8 && depth != 15 && depth != 16 &&
8592                             depth != 24 && depth != 32)
8593                             goto graphic_error;
8594                     } else if (*p == '\0') {
8595                         depth = graphic_depth;
8596                     } else {
8597                         goto graphic_error;
8598                     }
8599
8600                     graphic_width = w;
8601                     graphic_height = h;
8602                     graphic_depth = depth;
8603                 }
8604                 break;
8605             case QEMU_OPTION_echr:
8606                 {
8607                     char *r;
8608                     term_escape_char = strtol(optarg, &r, 0);
8609                     if (r == optarg)
8610                         printf("Bad argument to echr\n");
8611                     break;
8612                 }
8613             case QEMU_OPTION_monitor:
8614                 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
8615                 break;
8616             case QEMU_OPTION_serial:
8617                 if (serial_device_index >= MAX_SERIAL_PORTS) {
8618                     fprintf(stderr, "qemu: too many serial ports\n");
8619                     exit(1);
8620                 }
8621                 pstrcpy(serial_devices[serial_device_index],
8622                         sizeof(serial_devices[0]), optarg);
8623                 serial_device_index++;
8624                 break;
8625             case QEMU_OPTION_parallel:
8626                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8627                     fprintf(stderr, "qemu: too many parallel ports\n");
8628                     exit(1);
8629                 }
8630                 pstrcpy(parallel_devices[parallel_device_index],
8631                         sizeof(parallel_devices[0]), optarg);
8632                 parallel_device_index++;
8633                 break;
8634             case QEMU_OPTION_loadvm:
8635                 loadvm = optarg;
8636                 break;
8637             case QEMU_OPTION_full_screen:
8638                 full_screen = 1;
8639                 break;
8640 #ifdef CONFIG_SDL
8641             case QEMU_OPTION_no_frame:
8642                 no_frame = 1;
8643                 break;
8644             case QEMU_OPTION_alt_grab:
8645                 alt_grab = 1;
8646                 break;
8647             case QEMU_OPTION_no_quit:
8648                 no_quit = 1;
8649                 break;
8650 #endif
8651             case QEMU_OPTION_pidfile:
8652                 pid_file = optarg;
8653                 break;
8654 #ifdef TARGET_I386
8655             case QEMU_OPTION_win2k_hack:
8656                 win2k_install_hack = 1;
8657                 break;
8658 #endif
8659 #ifdef USE_KQEMU
8660             case QEMU_OPTION_no_kqemu:
8661                 kqemu_allowed = 0;
8662                 break;
8663             case QEMU_OPTION_kernel_kqemu:
8664                 kqemu_allowed = 2;
8665                 break;
8666 #endif
8667             case QEMU_OPTION_usb:
8668                 usb_enabled = 1;
8669                 break;
8670             case QEMU_OPTION_usbdevice:
8671                 usb_enabled = 1;
8672                 if (usb_devices_index >= MAX_USB_CMDLINE) {
8673                     fprintf(stderr, "Too many USB devices\n");
8674                     exit(1);
8675                 }
8676                 pstrcpy(usb_devices[usb_devices_index],
8677                         sizeof(usb_devices[usb_devices_index]),
8678                         optarg);
8679                 usb_devices_index++;
8680                 break;
8681             case QEMU_OPTION_smp:
8682                 smp_cpus = atoi(optarg);
8683                 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
8684                     fprintf(stderr, "Invalid number of CPUs\n");
8685                     exit(1);
8686                 }
8687                 break;
8688             case QEMU_OPTION_vnc:
8689                 vnc_display = optarg;
8690                 break;
8691             case QEMU_OPTION_no_acpi:
8692                 acpi_enabled = 0;
8693                 break;
8694             case QEMU_OPTION_no_reboot:
8695                 no_reboot = 1;
8696                 break;
8697             case QEMU_OPTION_show_cursor:
8698                 cursor_hide = 0;
8699                 break;
8700             case QEMU_OPTION_daemonize:
8701                 daemonize = 1;
8702                 break;
8703             case QEMU_OPTION_option_rom:
8704                 if (nb_option_roms >= MAX_OPTION_ROMS) {
8705                     fprintf(stderr, "Too many option ROMs\n");
8706                     exit(1);
8707                 }
8708                 option_rom[nb_option_roms] = optarg;
8709                 nb_option_roms++;
8710                 break;
8711             case QEMU_OPTION_semihosting:
8712                 semihosting_enabled = 1;
8713                 break;
8714             case QEMU_OPTION_name:
8715                 qemu_name = optarg;
8716                 break;
8717 #ifdef TARGET_SPARC
8718             case QEMU_OPTION_prom_env:
8719                 if (nb_prom_envs >= MAX_PROM_ENVS) {
8720                     fprintf(stderr, "Too many prom variables\n");
8721                     exit(1);
8722                 }
8723                 prom_envs[nb_prom_envs] = optarg;
8724                 nb_prom_envs++;
8725                 break;
8726 #endif
8727 #ifdef TARGET_ARM
8728             case QEMU_OPTION_old_param:
8729                 old_param = 1;
8730                 break;
8731 #endif
8732             case QEMU_OPTION_clock:
8733                 configure_alarms(optarg);
8734                 break;
8735             case QEMU_OPTION_startdate:
8736                 {
8737                     struct tm tm;
8738                     time_t rtc_start_date;
8739                     if (!strcmp(optarg, "now")) {
8740                         rtc_date_offset = -1;
8741                     } else {
8742                         if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
8743                                &tm.tm_year,
8744                                &tm.tm_mon,
8745                                &tm.tm_mday,
8746                                &tm.tm_hour,
8747                                &tm.tm_min,
8748                                &tm.tm_sec) == 6) {
8749                             /* OK */
8750                         } else if (sscanf(optarg, "%d-%d-%d",
8751                                           &tm.tm_year,
8752                                           &tm.tm_mon,
8753                                           &tm.tm_mday) == 3) {
8754                             tm.tm_hour = 0;
8755                             tm.tm_min = 0;
8756                             tm.tm_sec = 0;
8757                         } else {
8758                             goto date_fail;
8759                         }
8760                         tm.tm_year -= 1900;
8761                         tm.tm_mon--;
8762                         rtc_start_date = mktimegm(&tm);
8763                         if (rtc_start_date == -1) {
8764                         date_fail:
8765                             fprintf(stderr, "Invalid date format. Valid format are:\n"
8766                                     "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
8767                             exit(1);
8768                         }
8769                         rtc_date_offset = time(NULL) - rtc_start_date;
8770                     }
8771                 }
8772                 break;
8773             }
8774         }
8775     }
8776
8777 #ifndef _WIN32
8778     if (daemonize && !nographic && vnc_display == NULL) {
8779         fprintf(stderr, "Can only daemonize if using -nographic or -vnc\n");
8780         daemonize = 0;
8781     }
8782
8783     if (daemonize) {
8784         pid_t pid;
8785
8786         if (pipe(fds) == -1)
8787             exit(1);
8788
8789         pid = fork();
8790         if (pid > 0) {
8791             uint8_t status;
8792             ssize_t len;
8793
8794             close(fds[1]);
8795
8796         again:
8797             len = read(fds[0], &status, 1);
8798             if (len == -1 && (errno == EINTR))
8799                 goto again;
8800
8801             if (len != 1)
8802                 exit(1);
8803             else if (status == 1) {
8804                 fprintf(stderr, "Could not acquire pidfile\n");
8805                 exit(1);
8806             } else
8807                 exit(0);
8808         } else if (pid < 0)
8809             exit(1);
8810
8811         setsid();
8812
8813         pid = fork();
8814         if (pid > 0)
8815             exit(0);
8816         else if (pid < 0)
8817             exit(1);
8818
8819         umask(027);
8820         chdir("/");
8821
8822         signal(SIGTSTP, SIG_IGN);
8823         signal(SIGTTOU, SIG_IGN);
8824         signal(SIGTTIN, SIG_IGN);
8825     }
8826 #endif
8827
8828     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
8829         if (daemonize) {
8830             uint8_t status = 1;
8831             write(fds[1], &status, 1);
8832         } else
8833             fprintf(stderr, "Could not acquire pid file\n");
8834         exit(1);
8835     }
8836
8837 #ifdef USE_KQEMU
8838     if (smp_cpus > 1)
8839         kqemu_allowed = 0;
8840 #endif
8841     linux_boot = (kernel_filename != NULL);
8842     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
8843
8844     /* XXX: this should not be: some embedded targets just have flash */
8845     if (!linux_boot && net_boot == 0 &&
8846         nb_drives_opt == 0)
8847         help(1);
8848
8849     /* boot to floppy or the default cd if no hard disk defined yet */
8850     if (!boot_devices[0]) {
8851         boot_devices = "cad";
8852     }
8853     setvbuf(stdout, NULL, _IOLBF, 0);
8854
8855     init_timers();
8856     init_timer_alarm();
8857     qemu_aio_init();
8858
8859 #ifdef _WIN32
8860     socket_init();
8861 #endif
8862
8863     /* init network clients */
8864     if (nb_net_clients == 0) {
8865         /* if no clients, we use a default config */
8866         pstrcpy(net_clients[0], sizeof(net_clients[0]),
8867                 "nic");
8868         pstrcpy(net_clients[1], sizeof(net_clients[0]),
8869                 "user");
8870         nb_net_clients = 2;
8871     }
8872
8873     for(i = 0;i < nb_net_clients; i++) {
8874         if (net_client_init(net_clients[i]) < 0)
8875             exit(1);
8876     }
8877     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8878         if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
8879             continue;
8880         if (vlan->nb_guest_devs == 0) {
8881             fprintf(stderr, "Invalid vlan (%d) with no nics\n", vlan->id);
8882             exit(1);
8883         }
8884         if (vlan->nb_host_devs == 0)
8885             fprintf(stderr,
8886                     "Warning: vlan %d is not connected to host network\n",
8887                     vlan->id);
8888     }
8889
8890 #ifdef TARGET_I386
8891     /* XXX: this should be moved in the PC machine instantiation code */
8892     if (net_boot != 0) {
8893         int netroms = 0;
8894         for (i = 0; i < nb_nics && i < 4; i++) {
8895             const char *model = nd_table[i].model;
8896             char buf[1024];
8897             if (net_boot & (1 << i)) {
8898                 if (model == NULL)
8899                     model = "ne2k_pci";
8900                 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
8901                 if (get_image_size(buf) > 0) {
8902                     if (nb_option_roms >= MAX_OPTION_ROMS) {
8903                         fprintf(stderr, "Too many option ROMs\n");
8904                         exit(1);
8905                     }
8906                     option_rom[nb_option_roms] = strdup(buf);
8907                     nb_option_roms++;
8908                     netroms++;
8909                 }
8910             }
8911         }
8912         if (netroms == 0) {
8913             fprintf(stderr, "No valid PXE rom found for network device\n");
8914             exit(1);
8915         }
8916     }
8917 #endif
8918
8919     /* init the memory */
8920     phys_ram_size = ram_size + vga_ram_size + MAX_BIOS_SIZE;
8921
8922     phys_ram_base = qemu_vmalloc(phys_ram_size);
8923     if (!phys_ram_base) {
8924         fprintf(stderr, "Could not allocate physical memory\n");
8925         exit(1);
8926     }
8927
8928     bdrv_init();
8929
8930     /* we always create the cdrom drive, even if no disk is there */
8931
8932     if (nb_drives_opt < MAX_DRIVES)
8933         drive_add(NULL, CDROM_ALIAS);
8934
8935     /* we always create at least one floppy */
8936
8937     if (nb_drives_opt < MAX_DRIVES)
8938         drive_add(NULL, FD_ALIAS, 0);
8939
8940     /* we always create one sd slot, even if no card is in it */
8941
8942     if (nb_drives_opt < MAX_DRIVES)
8943         drive_add(NULL, SD_ALIAS);
8944
8945     /* open the virtual block devices */
8946
8947     for(i = 0; i < nb_drives_opt; i++)
8948         if (drive_init(&drives_opt[i], snapshot, machine) == -1)
8949             exit(1);
8950
8951     register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
8952     register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8953
8954     init_ioports();
8955
8956     /* terminal init */
8957     memset(&display_state, 0, sizeof(display_state));
8958     if (nographic) {
8959         if (curses) {
8960             fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
8961             exit(1);
8962         }
8963         /* nearly nothing to do */
8964         dumb_display_init(ds);
8965     } else if (vnc_display != NULL) {
8966         vnc_display_init(ds);
8967         if (vnc_display_open(ds, vnc_display) < 0)
8968             exit(1);
8969     } else
8970 #if defined(CONFIG_CURSES)
8971     if (curses) {
8972         curses_display_init(ds, full_screen);
8973     } else
8974 #endif
8975     {
8976 #if defined(CONFIG_SDL)
8977         sdl_display_init(ds, full_screen, no_frame);
8978 #elif defined(CONFIG_COCOA)
8979         cocoa_display_init(ds, full_screen);
8980 #else
8981         dumb_display_init(ds);
8982 #endif
8983     }
8984
8985     /* Maintain compatibility with multiple stdio monitors */
8986     if (!strcmp(monitor_device,"stdio")) {
8987         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
8988             if (!strcmp(serial_devices[i],"mon:stdio")) {
8989                 monitor_device[0] = '\0';
8990                 break;
8991             } else if (!strcmp(serial_devices[i],"stdio")) {
8992                 monitor_device[0] = '\0';
8993                 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "mon:stdio");
8994                 break;
8995             }
8996         }
8997     }
8998     if (monitor_device[0] != '\0') {
8999         monitor_hd = qemu_chr_open(monitor_device);
9000         if (!monitor_hd) {
9001             fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
9002             exit(1);
9003         }
9004         monitor_init(monitor_hd, !nographic);
9005     }
9006
9007     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
9008         const char *devname = serial_devices[i];
9009         if (devname[0] != '\0' && strcmp(devname, "none")) {
9010             serial_hds[i] = qemu_chr_open(devname);
9011             if (!serial_hds[i]) {
9012                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
9013                         devname);
9014                 exit(1);
9015             }
9016             if (strstart(devname, "vc", 0))
9017                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
9018         }
9019     }
9020
9021     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
9022         const char *devname = parallel_devices[i];
9023         if (devname[0] != '\0' && strcmp(devname, "none")) {
9024             parallel_hds[i] = qemu_chr_open(devname);
9025             if (!parallel_hds[i]) {
9026                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
9027                         devname);
9028                 exit(1);
9029             }
9030             if (strstart(devname, "vc", 0))
9031                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
9032         }
9033     }
9034
9035     machine->init(ram_size, vga_ram_size, boot_devices, ds,
9036                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
9037
9038     /* init USB devices */
9039     if (usb_enabled) {
9040         for(i = 0; i < usb_devices_index; i++) {
9041             if (usb_device_add(usb_devices[i]) < 0) {
9042                 fprintf(stderr, "Warning: could not add USB device %s\n",
9043                         usb_devices[i]);
9044             }
9045         }
9046     }
9047
9048     if (display_state.dpy_refresh) {
9049         display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
9050         qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
9051     }
9052
9053 #ifdef CONFIG_GDBSTUB
9054     if (use_gdbstub) {
9055         /* XXX: use standard host:port notation and modify options
9056            accordingly. */
9057         if (gdbserver_start(gdbstub_port) < 0) {
9058             fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
9059                     gdbstub_port);
9060             exit(1);
9061         }
9062     }
9063 #endif
9064
9065     if (loadvm)
9066         do_loadvm(loadvm);
9067
9068     {
9069         /* XXX: simplify init */
9070         read_passwords();
9071         if (autostart) {
9072             vm_start();
9073         }
9074     }
9075
9076     if (daemonize) {
9077         uint8_t status = 0;
9078         ssize_t len;
9079         int fd;
9080
9081     again1:
9082         len = write(fds[1], &status, 1);
9083         if (len == -1 && (errno == EINTR))
9084             goto again1;
9085
9086         if (len != 1)
9087             exit(1);
9088
9089         TFR(fd = open("/dev/null", O_RDWR));
9090         if (fd == -1)
9091             exit(1);
9092
9093         dup2(fd, 0);
9094         dup2(fd, 1);
9095         dup2(fd, 2);
9096
9097         close(fd);
9098     }
9099
9100     main_loop();
9101     quit_timers();
9102
9103 #if !defined(_WIN32)
9104     /* close network clients */
9105     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9106         VLANClientState *vc;
9107
9108         for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
9109             if (vc->fd_read == tap_receive) {
9110                 char ifname[64];
9111                 TAPState *s = vc->opaque;
9112
9113                 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
9114                     s->down_script[0])
9115                     launch_script(s->down_script, ifname, s->fd);
9116             }
9117         }
9118     }
9119 #endif
9120     return 0;
9121 }