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