git.maemo.org Git - qemu/blob - vl.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2005 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 "vl.h"
  25
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <signal.h>
  29 #include <time.h>
  30 #include <errno.h>
  31 #include <sys/time.h>
  32
  33 #ifndef _WIN32
  34 #include <sys/times.h>
  35 #include <sys/wait.h>
  36 #include <termios.h>
  37 #include <sys/poll.h>
  38 #include <sys/mman.h>
  39 #include <sys/ioctl.h>
  40 #include <sys/socket.h>
  41 #include <netinet/in.h>
  42 #include <dirent.h>
  43 #include <netdb.h>
  44 #ifdef _BSD
  45 #include <sys/stat.h>
  46 #ifndef __APPLE__
  47 #include <libutil.h>
  48 #endif
  49 #else
  50 #include <linux/if.h>
  51 #include <linux/if_tun.h>
  52 #include <pty.h>
  53 #include <malloc.h>
  54 #include <linux/rtc.h>
  55 #include <linux/ppdev.h>
  56 #endif
  57 #endif
  58
  59 #if defined(CONFIG_SLIRP)
  60 #include "libslirp.h"
  61 #endif
  62
  63 #ifdef _WIN32
  64 #include <malloc.h>
  65 #include <sys/timeb.h>
  66 #include <windows.h>
  67 #include <winsock2.h>
  68 #include <ws2tcpip.h>
  69 #define getopt_long_only getopt_long
  70 #define memalign(align, size) malloc(size)
  71 #endif
  72
  73 #ifdef CONFIG_SDL
  74 #ifdef __APPLE__
  75 #include <SDL/SDL.h>
  76 #endif
  77 #endif /* CONFIG_SDL */
  78
  79 #ifdef CONFIG_COCOA
  80 #undef main
  81 #define main qemu_main
  82 #endif /* CONFIG_COCOA */
  83
  84 #include "disas.h"
  85
  86 #include "exec-all.h"
  87
  88 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
  89
  90 //#define DEBUG_UNUSED_IOPORT
  91 //#define DEBUG_IOPORT
  92
  93 #if !defined(CONFIG_SOFTMMU)
  94 #define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024)
  95 #else
  96 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
  97 #endif
  98
  99 #ifdef TARGET_PPC
 100 #define DEFAULT_RAM_SIZE 144
 101 #else
 102 #define DEFAULT_RAM_SIZE 128
 103 #endif
 104 /* in ms */
 105 #define GUI_REFRESH_INTERVAL 30
 106
 107 /* XXX: use a two level table to limit memory usage */
 108 #define MAX_IOPORTS 65536
 109
 110 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
 111 char phys_ram_file[1024];
 112 void *ioport_opaque[MAX_IOPORTS];
 113 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
 114 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
 115 BlockDriverState *bs_table[MAX_DISKS], *fd_table[MAX_FD];
 116 int vga_ram_size;
 117 int bios_size;
 118 static DisplayState display_state;
 119 int nographic;
 120 const char* keyboard_layout = NULL;
 121 int64_t ticks_per_sec;
 122 int boot_device = 'c';
 123 int ram_size;
 124 int pit_min_timer_count = 0;
 125 int nb_nics;
 126 NICInfo nd_table[MAX_NICS];
 127 QEMUTimer *gui_timer;
 128 int vm_running;
 129 int rtc_utc = 1;
 130 int cirrus_vga_enabled = 1;
 131 #ifdef TARGET_SPARC
 132 int graphic_width = 1024;
 133 int graphic_height = 768;
 134 #else
 135 int graphic_width = 800;
 136 int graphic_height = 600;
 137 #endif
 138 int graphic_depth = 15;
 139 int full_screen = 0;
 140 TextConsole *vga_console;
 141 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 142 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 143 #ifdef TARGET_I386
 144 int win2k_install_hack = 0;
 145 #endif
 146 int usb_enabled = 0;
 147 USBPort *vm_usb_ports[MAX_VM_USB_PORTS];
 148 USBDevice *vm_usb_hub;
 149 static VLANState *first_vlan;
 150 int smp_cpus = 1;
 151 #if defined(TARGET_SPARC)
 152 #define MAX_CPUS 16
 153 #elif defined(TARGET_I386)
 154 #define MAX_CPUS 255
 155 #else
 156 #define MAX_CPUS 1
 157 #endif
 158
 159 /***********************************************************/
 160 /* x86 ISA bus support */
 161
 162 target_phys_addr_t isa_mem_base = 0;
 163 PicState2 *isa_pic;
 164
 165 uint32_t default_ioport_readb(void *opaque, uint32_t address)
 166 {
 167 #ifdef DEBUG_UNUSED_IOPORT
 168     fprintf(stderr, "inb: port=0x%04x\n", address);
 169 #endif
 170     return 0xff;
 171 }
 172
 173 void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
 174 {
 175 #ifdef DEBUG_UNUSED_IOPORT
 176     fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
 177 #endif
 178 }
 179
 180 /* default is to make two byte accesses */
 181 uint32_t default_ioport_readw(void *opaque, uint32_t address)
 182 {
 183     uint32_t data;
 184     data = ioport_read_table[0][address](ioport_opaque[address], address);
 185     address = (address + 1) & (MAX_IOPORTS - 1);
 186     data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
 187     return data;
 188 }
 189
 190 void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
 191 {
 192     ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
 193     address = (address + 1) & (MAX_IOPORTS - 1);
 194     ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
 195 }
 196
 197 uint32_t default_ioport_readl(void *opaque, uint32_t address)
 198 {
 199 #ifdef DEBUG_UNUSED_IOPORT
 200     fprintf(stderr, "inl: port=0x%04x\n", address);
 201 #endif
 202     return 0xffffffff;
 203 }
 204
 205 void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
 206 {
 207 #ifdef DEBUG_UNUSED_IOPORT
 208     fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
 209 #endif
 210 }
 211
 212 void init_ioports(void)
 213 {
 214     int i;
 215
 216     for(i = 0; i < MAX_IOPORTS; i++) {
 217         ioport_read_table[0][i] = default_ioport_readb;
 218         ioport_write_table[0][i] = default_ioport_writeb;
 219         ioport_read_table[1][i] = default_ioport_readw;
 220         ioport_write_table[1][i] = default_ioport_writew;
 221         ioport_read_table[2][i] = default_ioport_readl;
 222         ioport_write_table[2][i] = default_ioport_writel;
 223     }
 224 }
 225
 226 /* size is the word size in byte */
 227 int register_ioport_read(int start, int length, int size,
 228                          IOPortReadFunc *func, void *opaque)
 229 {
 230     int i, bsize;
 231
 232     if (size == 1) {
 233         bsize = 0;
 234     } else if (size == 2) {
 235         bsize = 1;
 236     } else if (size == 4) {
 237         bsize = 2;
 238     } else {
 239         hw_error("register_ioport_read: invalid size");
 240         return -1;
 241     }
 242     for(i = start; i < start + length; i += size) {
 243         ioport_read_table[bsize][i] = func;
 244         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 245             hw_error("register_ioport_read: invalid opaque");
 246         ioport_opaque[i] = opaque;
 247     }
 248     return 0;
 249 }
 250
 251 /* size is the word size in byte */
 252 int register_ioport_write(int start, int length, int size,
 253                           IOPortWriteFunc *func, void *opaque)
 254 {
 255     int i, bsize;
 256
 257     if (size == 1) {
 258         bsize = 0;
 259     } else if (size == 2) {
 260         bsize = 1;
 261     } else if (size == 4) {
 262         bsize = 2;
 263     } else {
 264         hw_error("register_ioport_write: invalid size");
 265         return -1;
 266     }
 267     for(i = start; i < start + length; i += size) {
 268         ioport_write_table[bsize][i] = func;
 269         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 270             hw_error("register_ioport_read: invalid opaque");
 271         ioport_opaque[i] = opaque;
 272     }
 273     return 0;
 274 }
 275
 276 void isa_unassign_ioport(int start, int length)
 277 {
 278     int i;
 279
 280     for(i = start; i < start + length; i++) {
 281         ioport_read_table[0][i] = default_ioport_readb;
 282         ioport_read_table[1][i] = default_ioport_readw;
 283         ioport_read_table[2][i] = default_ioport_readl;
 284
 285         ioport_write_table[0][i] = default_ioport_writeb;
 286         ioport_write_table[1][i] = default_ioport_writew;
 287         ioport_write_table[2][i] = default_ioport_writel;
 288     }
 289 }
 290
 291 /***********************************************************/
 292
 293 void pstrcpy(char *buf, int buf_size, const char *str)
 294 {
 295     int c;
 296     char *q = buf;
 297
 298     if (buf_size <= 0)
 299         return;
 300
 301     for(;;) {
 302         c = *str++;
 303         if (c == 0 || q >= buf + buf_size - 1)
 304             break;
 305         *q++ = c;
 306     }
 307     *q = '\0';
 308 }
 309
 310 /* strcat and truncate. */
 311 char *pstrcat(char *buf, int buf_size, const char *s)
 312 {
 313     int len;
 314     len = strlen(buf);
 315     if (len < buf_size)
 316         pstrcpy(buf + len, buf_size - len, s);
 317     return buf;
 318 }
 319
 320 int strstart(const char *str, const char *val, const char **ptr)
 321 {
 322     const char *p, *q;
 323     p = str;
 324     q = val;
 325     while (*q != '\0') {
 326         if (*p != *q)
 327             return 0;
 328         p++;
 329         q++;
 330     }
 331     if (ptr)
 332         *ptr = p;
 333     return 1;
 334 }
 335
 336 /* return the size or -1 if error */
 337 int get_image_size(const char *filename)
 338 {
 339     int fd, size;
 340     fd = open(filename, O_RDONLY | O_BINARY);
 341     if (fd < 0)
 342         return -1;
 343     size = lseek(fd, 0, SEEK_END);
 344     close(fd);
 345     return size;
 346 }
 347
 348 /* return the size or -1 if error */
 349 int load_image(const char *filename, uint8_t *addr)
 350 {
 351     int fd, size;
 352     fd = open(filename, O_RDONLY | O_BINARY);
 353     if (fd < 0)
 354         return -1;
 355     size = lseek(fd, 0, SEEK_END);
 356     lseek(fd, 0, SEEK_SET);
 357     if (read(fd, addr, size) != size) {
 358         close(fd);
 359         return -1;
 360     }
 361     close(fd);
 362     return size;
 363 }
 364
 365 void cpu_outb(CPUState *env, int addr, int val)
 366 {
 367 #ifdef DEBUG_IOPORT
 368     if (loglevel & CPU_LOG_IOPORT)
 369         fprintf(logfile, "outb: %04x %02x\n", addr, val);
 370 #endif
 371     ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
 372 #ifdef USE_KQEMU
 373     if (env)
 374         env->last_io_time = cpu_get_time_fast();
 375 #endif
 376 }
 377
 378 void cpu_outw(CPUState *env, int addr, int val)
 379 {
 380 #ifdef DEBUG_IOPORT
 381     if (loglevel & CPU_LOG_IOPORT)
 382         fprintf(logfile, "outw: %04x %04x\n", addr, val);
 383 #endif
 384     ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
 385 #ifdef USE_KQEMU
 386     if (env)
 387         env->last_io_time = cpu_get_time_fast();
 388 #endif
 389 }
 390
 391 void cpu_outl(CPUState *env, int addr, int val)
 392 {
 393 #ifdef DEBUG_IOPORT
 394     if (loglevel & CPU_LOG_IOPORT)
 395         fprintf(logfile, "outl: %04x %08x\n", addr, val);
 396 #endif
 397     ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
 398 #ifdef USE_KQEMU
 399     if (env)
 400         env->last_io_time = cpu_get_time_fast();
 401 #endif
 402 }
 403
 404 int cpu_inb(CPUState *env, int addr)
 405 {
 406     int val;
 407     val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
 408 #ifdef DEBUG_IOPORT
 409     if (loglevel & CPU_LOG_IOPORT)
 410         fprintf(logfile, "inb : %04x %02x\n", addr, val);
 411 #endif
 412 #ifdef USE_KQEMU
 413     if (env)
 414         env->last_io_time = cpu_get_time_fast();
 415 #endif
 416     return val;
 417 }
 418
 419 int cpu_inw(CPUState *env, int addr)
 420 {
 421     int val;
 422     val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
 423 #ifdef DEBUG_IOPORT
 424     if (loglevel & CPU_LOG_IOPORT)
 425         fprintf(logfile, "inw : %04x %04x\n", addr, val);
 426 #endif
 427 #ifdef USE_KQEMU
 428     if (env)
 429         env->last_io_time = cpu_get_time_fast();
 430 #endif
 431     return val;
 432 }
 433
 434 int cpu_inl(CPUState *env, int addr)
 435 {
 436     int val;
 437     val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
 438 #ifdef DEBUG_IOPORT
 439     if (loglevel & CPU_LOG_IOPORT)
 440         fprintf(logfile, "inl : %04x %08x\n", addr, val);
 441 #endif
 442 #ifdef USE_KQEMU
 443     if (env)
 444         env->last_io_time = cpu_get_time_fast();
 445 #endif
 446     return val;
 447 }
 448
 449 /***********************************************************/
 450 void hw_error(const char *fmt, ...)
 451 {
 452     va_list ap;
 453     CPUState *env;
 454
 455     va_start(ap, fmt);
 456     fprintf(stderr, "qemu: hardware error: ");
 457     vfprintf(stderr, fmt, ap);
 458     fprintf(stderr, "\n");
 459     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 460         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
 461 #ifdef TARGET_I386
 462         cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
 463 #else
 464         cpu_dump_state(env, stderr, fprintf, 0);
 465 #endif
 466     }
 467     va_end(ap);
 468     abort();
 469 }
 470
 471 /***********************************************************/
 472 /* keyboard/mouse */
 473
 474 static QEMUPutKBDEvent *qemu_put_kbd_event;
 475 static void *qemu_put_kbd_event_opaque;
 476 static QEMUPutMouseEvent *qemu_put_mouse_event;
 477 static void *qemu_put_mouse_event_opaque;
 478
 479 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
 480 {
 481     qemu_put_kbd_event_opaque = opaque;
 482     qemu_put_kbd_event = func;
 483 }
 484
 485 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque)
 486 {
 487     qemu_put_mouse_event_opaque = opaque;
 488     qemu_put_mouse_event = func;
 489 }
 490
 491 void kbd_put_keycode(int keycode)
 492 {
 493     if (qemu_put_kbd_event) {
 494         qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
 495     }
 496 }
 497
 498 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
 499 {
 500     if (qemu_put_mouse_event) {
 501         qemu_put_mouse_event(qemu_put_mouse_event_opaque,
 502                              dx, dy, dz, buttons_state);
 503     }
 504 }
 505
 506 /***********************************************************/
 507 /* timers */
 508
 509 #if defined(__powerpc__)
 510
 511 static inline uint32_t get_tbl(void)
 512 {
 513     uint32_t tbl;
 514     asm volatile("mftb %0" : "=r" (tbl));
 515     return tbl;
 516 }
 517
 518 static inline uint32_t get_tbu(void)
 519 {
 520         uint32_t tbl;
 521         asm volatile("mftbu %0" : "=r" (tbl));
 522         return tbl;
 523 }
 524
 525 int64_t cpu_get_real_ticks(void)
 526 {
 527     uint32_t l, h, h1;
 528     /* NOTE: we test if wrapping has occurred */
 529     do {
 530         h = get_tbu();
 531         l = get_tbl();
 532         h1 = get_tbu();
 533     } while (h != h1);
 534     return ((int64_t)h << 32) | l;
 535 }
 536
 537 #elif defined(__i386__)
 538
 539 int64_t cpu_get_real_ticks(void)
 540 {
 541     int64_t val;
 542     asm volatile ("rdtsc" : "=A" (val));
 543     return val;
 544 }
 545
 546 #elif defined(__x86_64__)
 547
 548 int64_t cpu_get_real_ticks(void)
 549 {
 550     uint32_t low,high;
 551     int64_t val;
 552     asm volatile("rdtsc" : "=a" (low), "=d" (high));
 553     val = high;
 554     val <<= 32;
 555     val |= low;
 556     return val;
 557 }
 558
 559 #elif defined(__ia64)
 560
 561 int64_t cpu_get_real_ticks(void)
 562 {
 563         int64_t val;
 564         asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
 565         return val;
 566 }
 567
 568 #elif defined(__s390__)
 569
 570 int64_t cpu_get_real_ticks(void)
 571 {
 572     int64_t val;
 573     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
 574     return val;
 575 }
 576
 577 #else
 578 #error unsupported CPU
 579 #endif
 580
 581 static int64_t cpu_ticks_offset;
 582 static int cpu_ticks_enabled;
 583
 584 static inline int64_t cpu_get_ticks(void)
 585 {
 586     if (!cpu_ticks_enabled) {
 587         return cpu_ticks_offset;
 588     } else {
 589         return cpu_get_real_ticks() + cpu_ticks_offset;
 590     }
 591 }
 592
 593 /* enable cpu_get_ticks() */
 594 void cpu_enable_ticks(void)
 595 {
 596     if (!cpu_ticks_enabled) {
 597         cpu_ticks_offset -= cpu_get_real_ticks();
 598         cpu_ticks_enabled = 1;
 599     }
 600 }
 601
 602 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 603    cpu_get_ticks() after that.  */
 604 void cpu_disable_ticks(void)
 605 {
 606     if (cpu_ticks_enabled) {
 607         cpu_ticks_offset = cpu_get_ticks();
 608         cpu_ticks_enabled = 0;
 609     }
 610 }
 611
 612 static int64_t get_clock(void)
 613 {
 614 #ifdef _WIN32
 615     struct _timeb tb;
 616     _ftime(&tb);
 617     return ((int64_t)tb.time * 1000 + (int64_t)tb.millitm) * 1000;
 618 #else
 619     struct timeval tv;
 620     gettimeofday(&tv, NULL);
 621     return tv.tv_sec * 1000000LL + tv.tv_usec;
 622 #endif
 623 }
 624
 625 void cpu_calibrate_ticks(void)
 626 {
 627     int64_t usec, ticks;
 628
 629     usec = get_clock();
 630     ticks = cpu_get_real_ticks();
 631 #ifdef _WIN32
 632     Sleep(50);
 633 #else
 634     usleep(50 * 1000);
 635 #endif
 636     usec = get_clock() - usec;
 637     ticks = cpu_get_real_ticks() - ticks;
 638     ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec;
 639 }
 640
 641 /* compute with 96 bit intermediate result: (a*b)/c */
 642 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 643 {
 644     union {
 645         uint64_t ll;
 646         struct {
 647 #ifdef WORDS_BIGENDIAN
 648             uint32_t high, low;
 649 #else
 650             uint32_t low, high;
 651 #endif
 652         } l;
 653     } u, res;
 654     uint64_t rl, rh;
 655
 656     u.ll = a;
 657     rl = (uint64_t)u.l.low * (uint64_t)b;
 658     rh = (uint64_t)u.l.high * (uint64_t)b;
 659     rh += (rl >> 32);
 660     res.l.high = rh / c;
 661     res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
 662     return res.ll;
 663 }
 664
 665 #define QEMU_TIMER_REALTIME 0
 666 #define QEMU_TIMER_VIRTUAL  1
 667
 668 struct QEMUClock {
 669     int type;
 670     /* XXX: add frequency */
 671 };
 672
 673 struct QEMUTimer {
 674     QEMUClock *clock;
 675     int64_t expire_time;
 676     QEMUTimerCB *cb;
 677     void *opaque;
 678     struct QEMUTimer *next;
 679 };
 680
 681 QEMUClock *rt_clock;
 682 QEMUClock *vm_clock;
 683
 684 static QEMUTimer *active_timers[2];
 685 #ifdef _WIN32
 686 static MMRESULT timerID;
 687 #else
 688 /* frequency of the times() clock tick */
 689 static int timer_freq;
 690 #endif
 691
 692 QEMUClock *qemu_new_clock(int type)
 693 {
 694     QEMUClock *clock;
 695     clock = qemu_mallocz(sizeof(QEMUClock));
 696     if (!clock)
 697         return NULL;
 698     clock->type = type;
 699     return clock;
 700 }
 701
 702 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
 703 {
 704     QEMUTimer *ts;
 705
 706     ts = qemu_mallocz(sizeof(QEMUTimer));
 707     ts->clock = clock;
 708     ts->cb = cb;
 709     ts->opaque = opaque;
 710     return ts;
 711 }
 712
 713 void qemu_free_timer(QEMUTimer *ts)
 714 {
 715     qemu_free(ts);
 716 }
 717
 718 /* stop a timer, but do not dealloc it */
 719 void qemu_del_timer(QEMUTimer *ts)
 720 {
 721     QEMUTimer **pt, *t;
 722
 723     /* NOTE: this code must be signal safe because
 724        qemu_timer_expired() can be called from a signal. */
 725     pt = &active_timers[ts->clock->type];
 726     for(;;) {
 727         t = *pt;
 728         if (!t)
 729             break;
 730         if (t == ts) {
 731             *pt = t->next;
 732             break;
 733         }
 734         pt = &t->next;
 735     }
 736 }
 737
 738 /* modify the current timer so that it will be fired when current_time
 739    >= expire_time. The corresponding callback will be called. */
 740 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
 741 {
 742     QEMUTimer **pt, *t;
 743
 744     qemu_del_timer(ts);
 745
 746     /* add the timer in the sorted list */
 747     /* NOTE: this code must be signal safe because
 748        qemu_timer_expired() can be called from a signal. */
 749     pt = &active_timers[ts->clock->type];
 750     for(;;) {
 751         t = *pt;
 752         if (!t)
 753             break;
 754         if (t->expire_time > expire_time)
 755             break;
 756         pt = &t->next;
 757     }
 758     ts->expire_time = expire_time;
 759     ts->next = *pt;
 760     *pt = ts;
 761 }
 762
 763 int qemu_timer_pending(QEMUTimer *ts)
 764 {
 765     QEMUTimer *t;
 766     for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
 767         if (t == ts)
 768             return 1;
 769     }
 770     return 0;
 771 }
 772
 773 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
 774 {
 775     if (!timer_head)
 776         return 0;
 777     return (timer_head->expire_time <= current_time);
 778 }
 779
 780 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
 781 {
 782     QEMUTimer *ts;
 783
 784     for(;;) {
 785         ts = *ptimer_head;
 786         if (!ts || ts->expire_time > current_time)
 787             break;
 788         /* remove timer from the list before calling the callback */
 789         *ptimer_head = ts->next;
 790         ts->next = NULL;
 791
 792         /* run the callback (the timer list can be modified) */
 793         ts->cb(ts->opaque);
 794     }
 795 }
 796
 797 int64_t qemu_get_clock(QEMUClock *clock)
 798 {
 799     switch(clock->type) {
 800     case QEMU_TIMER_REALTIME:
 801 #ifdef _WIN32
 802         return GetTickCount();
 803 #else
 804         {
 805             struct tms tp;
 806
 807             /* Note that using gettimeofday() is not a good solution
 808                for timers because its value change when the date is
 809                modified. */
 810             if (timer_freq == 100) {
 811                 return times(&tp) * 10;
 812             } else {
 813                 return ((int64_t)times(&tp) * 1000) / timer_freq;
 814             }
 815         }
 816 #endif
 817     default:
 818     case QEMU_TIMER_VIRTUAL:
 819         return cpu_get_ticks();
 820     }
 821 }
 822
 823 /* save a timer */
 824 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
 825 {
 826     uint64_t expire_time;
 827
 828     if (qemu_timer_pending(ts)) {
 829         expire_time = ts->expire_time;
 830     } else {
 831         expire_time = -1;
 832     }
 833     qemu_put_be64(f, expire_time);
 834 }
 835
 836 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
 837 {
 838     uint64_t expire_time;
 839
 840     expire_time = qemu_get_be64(f);
 841     if (expire_time != -1) {
 842         qemu_mod_timer(ts, expire_time);
 843     } else {
 844         qemu_del_timer(ts);
 845     }
 846 }
 847
 848 static void timer_save(QEMUFile *f, void *opaque)
 849 {
 850     if (cpu_ticks_enabled) {
 851         hw_error("cannot save state if virtual timers are running");
 852     }
 853     qemu_put_be64s(f, &cpu_ticks_offset);
 854     qemu_put_be64s(f, &ticks_per_sec);
 855 }
 856
 857 static int timer_load(QEMUFile *f, void *opaque, int version_id)
 858 {
 859     if (version_id != 1)
 860         return -EINVAL;
 861     if (cpu_ticks_enabled) {
 862         return -EINVAL;
 863     }
 864     qemu_get_be64s(f, &cpu_ticks_offset);
 865     qemu_get_be64s(f, &ticks_per_sec);
 866     return 0;
 867 }
 868
 869 #ifdef _WIN32
 870 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
 871                                  DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
 872 #else
 873 static void host_alarm_handler(int host_signum)
 874 #endif
 875 {
 876 #if 0
 877 #define DISP_FREQ 1000
 878     {
 879         static int64_t delta_min = INT64_MAX;
 880         static int64_t delta_max, delta_cum, last_clock, delta, ti;
 881         static int count;
 882         ti = qemu_get_clock(vm_clock);
 883         if (last_clock != 0) {
 884             delta = ti - last_clock;
 885             if (delta < delta_min)
 886                 delta_min = delta;
 887             if (delta > delta_max)
 888                 delta_max = delta;
 889             delta_cum += delta;
 890             if (++count == DISP_FREQ) {
 891                 printf("timer: min=%lld us max=%lld us avg=%lld us avg_freq=%0.3f Hz\n",
 892                        muldiv64(delta_min, 1000000, ticks_per_sec),
 893                        muldiv64(delta_max, 1000000, ticks_per_sec),
 894                        muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
 895                        (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
 896                 count = 0;
 897                 delta_min = INT64_MAX;
 898                 delta_max = 0;
 899                 delta_cum = 0;
 900             }
 901         }
 902         last_clock = ti;
 903     }
 904 #endif
 905     if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
 906                            qemu_get_clock(vm_clock)) ||
 907         qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
 908                            qemu_get_clock(rt_clock))) {
 909         CPUState *env = cpu_single_env;
 910         if (env) {
 911             /* stop the currently executing cpu because a timer occured */
 912             cpu_interrupt(env, CPU_INTERRUPT_EXIT);
 913 #ifdef USE_KQEMU
 914             if (env->kqemu_enabled) {
 915                 kqemu_cpu_interrupt(env);
 916             }
 917 #endif
 918         }
 919     }
 920 }
 921
 922 #ifndef _WIN32
 923
 924 #if defined(__linux__)
 925
 926 #define RTC_FREQ 1024
 927
 928 static int rtc_fd;
 929
 930 static int start_rtc_timer(void)
 931 {
 932     rtc_fd = open("/dev/rtc", O_RDONLY);
 933     if (rtc_fd < 0)
 934         return -1;
 935     if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
 936         fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
 937                 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
 938                 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
 939         goto fail;
 940     }
 941     if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
 942     fail:
 943         close(rtc_fd);
 944         return -1;
 945     }
 946     pit_min_timer_count = PIT_FREQ / RTC_FREQ;
 947     return 0;
 948 }
 949
 950 #else
 951
 952 static int start_rtc_timer(void)
 953 {
 954     return -1;
 955 }
 956
 957 #endif /* !defined(__linux__) */
 958
 959 #endif /* !defined(_WIN32) */
 960
 961 static void init_timers(void)
 962 {
 963     rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
 964     vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
 965
 966 #ifdef _WIN32
 967     {
 968         int count=0;
 969         timerID = timeSetEvent(1,     // interval (ms)
 970                                0,     // resolution
 971                                host_alarm_handler, // function
 972                                (DWORD)&count,  // user parameter
 973                                TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
 974         if( !timerID ) {
 975             perror("failed timer alarm");
 976             exit(1);
 977         }
 978     }
 979     pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
 980 #else
 981     {
 982         struct sigaction act;
 983         struct itimerval itv;
 984
 985         /* get times() syscall frequency */
 986         timer_freq = sysconf(_SC_CLK_TCK);
 987
 988         /* timer signal */
 989         sigfillset(&act.sa_mask);
 990        act.sa_flags = 0;
 991 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
 992         act.sa_flags |= SA_ONSTACK;
 993 #endif
 994         act.sa_handler = host_alarm_handler;
 995         sigaction(SIGALRM, &act, NULL);
 996
 997         itv.it_interval.tv_sec = 0;
 998         itv.it_interval.tv_usec = 999; /* for i386 kernel 2.6 to get 1 ms */
 999         itv.it_value.tv_sec = 0;
1000         itv.it_value.tv_usec = 10 * 1000;
1001         setitimer(ITIMER_REAL, &itv, NULL);
1002         /* we probe the tick duration of the kernel to inform the user if
1003            the emulated kernel requested a too high timer frequency */
1004         getitimer(ITIMER_REAL, &itv);
1005
1006 #if defined(__linux__)
1007         if (itv.it_interval.tv_usec > 1000) {
1008             /* try to use /dev/rtc to have a faster timer */
1009             if (start_rtc_timer() < 0)
1010                 goto use_itimer;
1011             /* disable itimer */
1012             itv.it_interval.tv_sec = 0;
1013             itv.it_interval.tv_usec = 0;
1014             itv.it_value.tv_sec = 0;
1015             itv.it_value.tv_usec = 0;
1016             setitimer(ITIMER_REAL, &itv, NULL);
1017
1018             /* use the RTC */
1019             sigaction(SIGIO, &act, NULL);
1020             fcntl(rtc_fd, F_SETFL, O_ASYNC);
1021             fcntl(rtc_fd, F_SETOWN, getpid());
1022         } else
1023 #endif /* defined(__linux__) */
1024         {
1025         use_itimer:
1026             pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec *
1027                                    PIT_FREQ) / 1000000;
1028         }
1029     }
1030 #endif
1031 }
1032
1033 void quit_timers(void)
1034 {
1035 #ifdef _WIN32
1036     timeKillEvent(timerID);
1037 #endif
1038 }
1039
1040 /***********************************************************/
1041 /* character device */
1042
1043 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1044 {
1045     return s->chr_write(s, buf, len);
1046 }
1047
1048 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1049 {
1050     if (!s->chr_ioctl)
1051         return -ENOTSUP;
1052     return s->chr_ioctl(s, cmd, arg);
1053 }
1054
1055 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1056 {
1057     char buf[4096];
1058     va_list ap;
1059     va_start(ap, fmt);
1060     vsnprintf(buf, sizeof(buf), fmt, ap);
1061     qemu_chr_write(s, buf, strlen(buf));
1062     va_end(ap);
1063 }
1064
1065 void qemu_chr_send_event(CharDriverState *s, int event)
1066 {
1067     if (s->chr_send_event)
1068         s->chr_send_event(s, event);
1069 }
1070
1071 void qemu_chr_add_read_handler(CharDriverState *s,
1072                                IOCanRWHandler *fd_can_read,
1073                                IOReadHandler *fd_read, void *opaque)
1074 {
1075     s->chr_add_read_handler(s, fd_can_read, fd_read, opaque);
1076 }
1077
1078 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event)
1079 {
1080     s->chr_event = chr_event;
1081 }
1082
1083 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1084 {
1085     return len;
1086 }
1087
1088 static void null_chr_add_read_handler(CharDriverState *chr,
1089                                     IOCanRWHandler *fd_can_read,
1090                                     IOReadHandler *fd_read, void *opaque)
1091 {
1092 }
1093
1094 CharDriverState *qemu_chr_open_null(void)
1095 {
1096     CharDriverState *chr;
1097
1098     chr = qemu_mallocz(sizeof(CharDriverState));
1099     if (!chr)
1100         return NULL;
1101     chr->chr_write = null_chr_write;
1102     chr->chr_add_read_handler = null_chr_add_read_handler;
1103     return chr;
1104 }
1105
1106 #ifdef _WIN32
1107
1108 #define socket_error() WSAGetLastError()
1109 #undef EINTR
1110 #define EWOULDBLOCK WSAEWOULDBLOCK
1111 #define EINTR       WSAEINTR
1112 #define EINPROGRESS WSAEINPROGRESS
1113
1114 static void socket_cleanup(void)
1115 {
1116     WSACleanup();
1117 }
1118
1119 static int socket_init(void)
1120 {
1121     WSADATA Data;
1122     int ret, err;
1123
1124     ret = WSAStartup(MAKEWORD(2,2), &Data);
1125     if (ret != 0) {
1126         err = WSAGetLastError();
1127         fprintf(stderr, "WSAStartup: %d\n", err);
1128         return -1;
1129     }
1130     atexit(socket_cleanup);
1131     return 0;
1132 }
1133
1134 static int send_all(int fd, const uint8_t *buf, int len1)
1135 {
1136     int ret, len;
1137
1138     len = len1;
1139     while (len > 0) {
1140         ret = send(fd, buf, len, 0);
1141         if (ret < 0) {
1142             int errno;
1143             errno = WSAGetLastError();
1144             if (errno != WSAEWOULDBLOCK) {
1145                 return -1;
1146             }
1147         } else if (ret == 0) {
1148             break;
1149         } else {
1150             buf += ret;
1151             len -= ret;
1152         }
1153     }
1154     return len1 - len;
1155 }
1156
1157 void socket_set_nonblock(int fd)
1158 {
1159     unsigned long opt = 1;
1160     ioctlsocket(fd, FIONBIO, &opt);
1161 }
1162
1163 #else
1164
1165 #define socket_error() errno
1166 #define closesocket(s) close(s)
1167
1168 static int unix_write(int fd, const uint8_t *buf, int len1)
1169 {
1170     int ret, len;
1171
1172     len = len1;
1173     while (len > 0) {
1174         ret = write(fd, buf, len);
1175         if (ret < 0) {
1176             if (errno != EINTR && errno != EAGAIN)
1177                 return -1;
1178         } else if (ret == 0) {
1179             break;
1180         } else {
1181             buf += ret;
1182             len -= ret;
1183         }
1184     }
1185     return len1 - len;
1186 }
1187
1188 static inline int send_all(int fd, const uint8_t *buf, int len1)
1189 {
1190     return unix_write(fd, buf, len1);
1191 }
1192
1193 void socket_set_nonblock(int fd)
1194 {
1195     fcntl(fd, F_SETFL, O_NONBLOCK);
1196 }
1197 #endif /* !_WIN32 */
1198
1199 #ifndef _WIN32
1200
1201 typedef struct {
1202     int fd_in, fd_out;
1203     IOCanRWHandler *fd_can_read;
1204     IOReadHandler *fd_read;
1205     void *fd_opaque;
1206     int max_size;
1207 } FDCharDriver;
1208
1209 #define STDIO_MAX_CLIENTS 2
1210
1211 static int stdio_nb_clients;
1212 static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1213
1214 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1215 {
1216     FDCharDriver *s = chr->opaque;
1217     return unix_write(s->fd_out, buf, len);
1218 }
1219
1220 static int fd_chr_read_poll(void *opaque)
1221 {
1222     CharDriverState *chr = opaque;
1223     FDCharDriver *s = chr->opaque;
1224
1225     s->max_size = s->fd_can_read(s->fd_opaque);
1226     return s->max_size;
1227 }
1228
1229 static void fd_chr_read(void *opaque)
1230 {
1231     CharDriverState *chr = opaque;
1232     FDCharDriver *s = chr->opaque;
1233     int size, len;
1234     uint8_t buf[1024];
1235
1236     len = sizeof(buf);
1237     if (len > s->max_size)
1238         len = s->max_size;
1239     if (len == 0)
1240         return;
1241     size = read(s->fd_in, buf, len);
1242     if (size > 0) {
1243         s->fd_read(s->fd_opaque, buf, size);
1244     }
1245 }
1246
1247 static void fd_chr_add_read_handler(CharDriverState *chr,
1248                                     IOCanRWHandler *fd_can_read,
1249                                     IOReadHandler *fd_read, void *opaque)
1250 {
1251     FDCharDriver *s = chr->opaque;
1252
1253     if (s->fd_in >= 0) {
1254         s->fd_can_read = fd_can_read;
1255         s->fd_read = fd_read;
1256         s->fd_opaque = opaque;
1257         if (nographic && s->fd_in == 0) {
1258         } else {
1259             qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
1260                                  fd_chr_read, NULL, chr);
1261         }
1262     }
1263 }
1264
1265 /* open a character device to a unix fd */
1266 CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1267 {
1268     CharDriverState *chr;
1269     FDCharDriver *s;
1270
1271     chr = qemu_mallocz(sizeof(CharDriverState));
1272     if (!chr)
1273         return NULL;
1274     s = qemu_mallocz(sizeof(FDCharDriver));
1275     if (!s) {
1276         free(chr);
1277         return NULL;
1278     }
1279     s->fd_in = fd_in;
1280     s->fd_out = fd_out;
1281     chr->opaque = s;
1282     chr->chr_write = fd_chr_write;
1283     chr->chr_add_read_handler = fd_chr_add_read_handler;
1284     return chr;
1285 }
1286
1287 CharDriverState *qemu_chr_open_file_out(const char *file_out)
1288 {
1289     int fd_out;
1290
1291     fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666);
1292     if (fd_out < 0)
1293         return NULL;
1294     return qemu_chr_open_fd(-1, fd_out);
1295 }
1296
1297 CharDriverState *qemu_chr_open_pipe(const char *filename)
1298 {
1299     int fd;
1300
1301     fd = open(filename, O_RDWR | O_BINARY);
1302     if (fd < 0)
1303         return NULL;
1304     return qemu_chr_open_fd(fd, fd);
1305 }
1306
1307
1308 /* for STDIO, we handle the case where several clients use it
1309    (nographic mode) */
1310
1311 #define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */
1312
1313 #define TERM_FIFO_MAX_SIZE 1
1314
1315 static int term_got_escape, client_index;
1316 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
1317 int term_fifo_size;
1318
1319 void term_print_help(void)
1320 {
1321     printf("\n"
1322            "C-a h    print this help\n"
1323            "C-a x    exit emulator\n"
1324            "C-a s    save disk data back to file (if -snapshot)\n"
1325            "C-a b    send break (magic sysrq)\n"
1326            "C-a c    switch between console and monitor\n"
1327            "C-a C-a  send C-a\n"
1328            );
1329 }
1330
1331 /* called when a char is received */
1332 static void stdio_received_byte(int ch)
1333 {
1334     if (term_got_escape) {
1335         term_got_escape = 0;
1336         switch(ch) {
1337         case 'h':
1338             term_print_help();
1339             break;
1340         case 'x':
1341             exit(0);
1342             break;
1343         case 's':
1344             {
1345                 int i;
1346                 for (i = 0; i < MAX_DISKS; i++) {
1347                     if (bs_table[i])
1348                         bdrv_commit(bs_table[i]);
1349                 }
1350             }
1351             break;
1352         case 'b':
1353             if (client_index < stdio_nb_clients) {
1354                 CharDriverState *chr;
1355                 FDCharDriver *s;
1356
1357                 chr = stdio_clients[client_index];
1358                 s = chr->opaque;
1359                 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
1360             }
1361             break;
1362         case 'c':
1363             client_index++;
1364             if (client_index >= stdio_nb_clients)
1365                 client_index = 0;
1366             if (client_index == 0) {
1367                 /* send a new line in the monitor to get the prompt */
1368                 ch = '\r';
1369                 goto send_char;
1370             }
1371             break;
1372         case TERM_ESCAPE:
1373             goto send_char;
1374         }
1375     } else if (ch == TERM_ESCAPE) {
1376         term_got_escape = 1;
1377     } else {
1378     send_char:
1379         if (client_index < stdio_nb_clients) {
1380             uint8_t buf[1];
1381             CharDriverState *chr;
1382             FDCharDriver *s;
1383
1384             chr = stdio_clients[client_index];
1385             s = chr->opaque;
1386             if (s->fd_can_read(s->fd_opaque) > 0) {
1387                 buf[0] = ch;
1388                 s->fd_read(s->fd_opaque, buf, 1);
1389             } else if (term_fifo_size == 0) {
1390                 term_fifo[term_fifo_size++] = ch;
1391             }
1392         }
1393     }
1394 }
1395
1396 static int stdio_read_poll(void *opaque)
1397 {
1398     CharDriverState *chr;
1399     FDCharDriver *s;
1400
1401     if (client_index < stdio_nb_clients) {
1402         chr = stdio_clients[client_index];
1403         s = chr->opaque;
1404         /* try to flush the queue if needed */
1405         if (term_fifo_size != 0 && s->fd_can_read(s->fd_opaque) > 0) {
1406             s->fd_read(s->fd_opaque, term_fifo, 1);
1407             term_fifo_size = 0;
1408         }
1409         /* see if we can absorb more chars */
1410         if (term_fifo_size == 0)
1411             return 1;
1412         else
1413             return 0;
1414     } else {
1415         return 1;
1416     }
1417 }
1418
1419 static void stdio_read(void *opaque)
1420 {
1421     int size;
1422     uint8_t buf[1];
1423
1424     size = read(0, buf, 1);
1425     if (size > 0)
1426         stdio_received_byte(buf[0]);
1427 }
1428
1429 /* init terminal so that we can grab keys */
1430 static struct termios oldtty;
1431 static int old_fd0_flags;
1432
1433 static void term_exit(void)
1434 {
1435     tcsetattr (0, TCSANOW, &oldtty);
1436     fcntl(0, F_SETFL, old_fd0_flags);
1437 }
1438
1439 static void term_init(void)
1440 {
1441     struct termios tty;
1442
1443     tcgetattr (0, &tty);
1444     oldtty = tty;
1445     old_fd0_flags = fcntl(0, F_GETFL);
1446
1447     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1448                           |INLCR|IGNCR|ICRNL|IXON);
1449     tty.c_oflag |= OPOST;
1450     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1451     /* if graphical mode, we allow Ctrl-C handling */
1452     if (nographic)
1453         tty.c_lflag &= ~ISIG;
1454     tty.c_cflag &= ~(CSIZE|PARENB);
1455     tty.c_cflag |= CS8;
1456     tty.c_cc[VMIN] = 1;
1457     tty.c_cc[VTIME] = 0;
1458
1459     tcsetattr (0, TCSANOW, &tty);
1460
1461     atexit(term_exit);
1462
1463     fcntl(0, F_SETFL, O_NONBLOCK);
1464 }
1465
1466 CharDriverState *qemu_chr_open_stdio(void)
1467 {
1468     CharDriverState *chr;
1469
1470     if (nographic) {
1471         if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
1472             return NULL;
1473         chr = qemu_chr_open_fd(0, 1);
1474         if (stdio_nb_clients == 0)
1475             qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, NULL);
1476         client_index = stdio_nb_clients;
1477     } else {
1478         if (stdio_nb_clients != 0)
1479             return NULL;
1480         chr = qemu_chr_open_fd(0, 1);
1481     }
1482     stdio_clients[stdio_nb_clients++] = chr;
1483     if (stdio_nb_clients == 1) {
1484         /* set the terminal in raw mode */
1485         term_init();
1486     }
1487     return chr;
1488 }
1489
1490 #if defined(__linux__)
1491 CharDriverState *qemu_chr_open_pty(void)
1492 {
1493     struct termios tty;
1494     char slave_name[1024];
1495     int master_fd, slave_fd;
1496
1497     /* Not satisfying */
1498     if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
1499         return NULL;
1500     }
1501
1502     /* Disabling local echo and line-buffered output */
1503     tcgetattr (master_fd, &tty);
1504     tty.c_lflag &= ~(ECHO|ICANON|ISIG);
1505     tty.c_cc[VMIN] = 1;
1506     tty.c_cc[VTIME] = 0;
1507     tcsetattr (master_fd, TCSAFLUSH, &tty);
1508
1509     fprintf(stderr, "char device redirected to %s\n", slave_name);
1510     return qemu_chr_open_fd(master_fd, master_fd);
1511 }
1512
1513 static void tty_serial_init(int fd, int speed,
1514                             int parity, int data_bits, int stop_bits)
1515 {
1516     struct termios tty;
1517     speed_t spd;
1518
1519 #if 0
1520     printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1521            speed, parity, data_bits, stop_bits);
1522 #endif
1523     tcgetattr (fd, &tty);
1524
1525     switch(speed) {
1526     case 50:
1527         spd = B50;
1528         break;
1529     case 75:
1530         spd = B75;
1531         break;
1532     case 300:
1533         spd = B300;
1534         break;
1535     case 600:
1536         spd = B600;
1537         break;
1538     case 1200:
1539         spd = B1200;
1540         break;
1541     case 2400:
1542         spd = B2400;
1543         break;
1544     case 4800:
1545         spd = B4800;
1546         break;
1547     case 9600:
1548         spd = B9600;
1549         break;
1550     case 19200:
1551         spd = B19200;
1552         break;
1553     case 38400:
1554         spd = B38400;
1555         break;
1556     case 57600:
1557         spd = B57600;
1558         break;
1559     default:
1560     case 115200:
1561         spd = B115200;
1562         break;
1563     }
1564
1565     cfsetispeed(&tty, spd);
1566     cfsetospeed(&tty, spd);
1567
1568     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1569                           |INLCR|IGNCR|ICRNL|IXON);
1570     tty.c_oflag |= OPOST;
1571     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1572     tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS);
1573     switch(data_bits) {
1574     default:
1575     case 8:
1576         tty.c_cflag |= CS8;
1577         break;
1578     case 7:
1579         tty.c_cflag |= CS7;
1580         break;
1581     case 6:
1582         tty.c_cflag |= CS6;
1583         break;
1584     case 5:
1585         tty.c_cflag |= CS5;
1586         break;
1587     }
1588     switch(parity) {
1589     default:
1590     case 'N':
1591         break;
1592     case 'E':
1593         tty.c_cflag |= PARENB;
1594         break;
1595     case 'O':
1596         tty.c_cflag |= PARENB | PARODD;
1597         break;
1598     }
1599
1600     tcsetattr (fd, TCSANOW, &tty);
1601 }
1602
1603 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1604 {
1605     FDCharDriver *s = chr->opaque;
1606
1607     switch(cmd) {
1608     case CHR_IOCTL_SERIAL_SET_PARAMS:
1609         {
1610             QEMUSerialSetParams *ssp = arg;
1611             tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1612                             ssp->data_bits, ssp->stop_bits);
1613         }
1614         break;
1615     case CHR_IOCTL_SERIAL_SET_BREAK:
1616         {
1617             int enable = *(int *)arg;
1618             if (enable)
1619                 tcsendbreak(s->fd_in, 1);
1620         }
1621         break;
1622     default:
1623         return -ENOTSUP;
1624     }
1625     return 0;
1626 }
1627
1628 CharDriverState *qemu_chr_open_tty(const char *filename)
1629 {
1630     CharDriverState *chr;
1631     int fd;
1632
1633     fd = open(filename, O_RDWR | O_NONBLOCK);
1634     if (fd < 0)
1635         return NULL;
1636     fcntl(fd, F_SETFL, O_NONBLOCK);
1637     tty_serial_init(fd, 115200, 'N', 8, 1);
1638     chr = qemu_chr_open_fd(fd, fd);
1639     if (!chr)
1640         return NULL;
1641     chr->chr_ioctl = tty_serial_ioctl;
1642     return chr;
1643 }
1644
1645 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1646 {
1647     int fd = (int)chr->opaque;
1648     uint8_t b;
1649
1650     switch(cmd) {
1651     case CHR_IOCTL_PP_READ_DATA:
1652         if (ioctl(fd, PPRDATA, &b) < 0)
1653             return -ENOTSUP;
1654         *(uint8_t *)arg = b;
1655         break;
1656     case CHR_IOCTL_PP_WRITE_DATA:
1657         b = *(uint8_t *)arg;
1658         if (ioctl(fd, PPWDATA, &b) < 0)
1659             return -ENOTSUP;
1660         break;
1661     case CHR_IOCTL_PP_READ_CONTROL:
1662         if (ioctl(fd, PPRCONTROL, &b) < 0)
1663             return -ENOTSUP;
1664         *(uint8_t *)arg = b;
1665         break;
1666     case CHR_IOCTL_PP_WRITE_CONTROL:
1667         b = *(uint8_t *)arg;
1668         if (ioctl(fd, PPWCONTROL, &b) < 0)
1669             return -ENOTSUP;
1670         break;
1671     case CHR_IOCTL_PP_READ_STATUS:
1672         if (ioctl(fd, PPRSTATUS, &b) < 0)
1673             return -ENOTSUP;
1674         *(uint8_t *)arg = b;
1675         break;
1676     default:
1677         return -ENOTSUP;
1678     }
1679     return 0;
1680 }
1681
1682 CharDriverState *qemu_chr_open_pp(const char *filename)
1683 {
1684     CharDriverState *chr;
1685     int fd;
1686
1687     fd = open(filename, O_RDWR);
1688     if (fd < 0)
1689         return NULL;
1690
1691     if (ioctl(fd, PPCLAIM) < 0) {
1692         close(fd);
1693         return NULL;
1694     }
1695
1696     chr = qemu_mallocz(sizeof(CharDriverState));
1697     if (!chr) {
1698         close(fd);
1699         return NULL;
1700     }
1701     chr->opaque = (void *)fd;
1702     chr->chr_write = null_chr_write;
1703     chr->chr_add_read_handler = null_chr_add_read_handler;
1704     chr->chr_ioctl = pp_ioctl;
1705     return chr;
1706 }
1707
1708 #else
1709 CharDriverState *qemu_chr_open_pty(void)
1710 {
1711     return NULL;
1712 }
1713 #endif
1714
1715 #endif /* !defined(_WIN32) */
1716
1717 CharDriverState *qemu_chr_open(const char *filename)
1718 {
1719 #ifndef _WIN32
1720     const char *p;
1721 #endif
1722
1723     if (!strcmp(filename, "vc")) {
1724         return text_console_init(&display_state);
1725     } else if (!strcmp(filename, "null")) {
1726         return qemu_chr_open_null();
1727     } else
1728 #ifndef _WIN32
1729     if (strstart(filename, "file:", &p)) {
1730         return qemu_chr_open_file_out(p);
1731     } else if (strstart(filename, "pipe:", &p)) {
1732         return qemu_chr_open_pipe(p);
1733     } else if (!strcmp(filename, "pty")) {
1734         return qemu_chr_open_pty();
1735     } else if (!strcmp(filename, "stdio")) {
1736         return qemu_chr_open_stdio();
1737     } else
1738 #endif
1739 #if defined(__linux__)
1740     if (strstart(filename, "/dev/parport", NULL)) {
1741         return qemu_chr_open_pp(filename);
1742     } else
1743     if (strstart(filename, "/dev/", NULL)) {
1744         return qemu_chr_open_tty(filename);
1745     } else
1746 #endif
1747     {
1748         return NULL;
1749     }
1750 }
1751
1752 /***********************************************************/
1753 /* network device redirectors */
1754
1755 void hex_dump(FILE *f, const uint8_t *buf, int size)
1756 {
1757     int len, i, j, c;
1758
1759     for(i=0;i<size;i+=16) {
1760         len = size - i;
1761         if (len > 16)
1762             len = 16;
1763         fprintf(f, "%08x ", i);
1764         for(j=0;j<16;j++) {
1765             if (j < len)
1766                 fprintf(f, " %02x", buf[i+j]);
1767             else
1768                 fprintf(f, "   ");
1769         }
1770         fprintf(f, " ");
1771         for(j=0;j<len;j++) {
1772             c = buf[i+j];
1773             if (c < ' ' || c > '~')
1774                 c = '.';
1775             fprintf(f, "%c", c);
1776         }
1777         fprintf(f, "\n");
1778     }
1779 }
1780
1781 static int parse_macaddr(uint8_t *macaddr, const char *p)
1782 {
1783     int i;
1784     for(i = 0; i < 6; i++) {
1785         macaddr[i] = strtol(p, (char **)&p, 16);
1786         if (i == 5) {
1787             if (*p != '\0')
1788                 return -1;
1789         } else {
1790             if (*p != ':')
1791                 return -1;
1792             p++;
1793         }
1794     }
1795     return 0;
1796 }
1797
1798 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
1799 {
1800     const char *p, *p1;
1801     int len;
1802     p = *pp;
1803     p1 = strchr(p, sep);
1804     if (!p1)
1805         return -1;
1806     len = p1 - p;
1807     p1++;
1808     if (buf_size > 0) {
1809         if (len > buf_size - 1)
1810             len = buf_size - 1;
1811         memcpy(buf, p, len);
1812         buf[len] = '\0';
1813     }
1814     *pp = p1;
1815     return 0;
1816 }
1817
1818 int parse_host_port(struct sockaddr_in *saddr, const char *str)
1819 {
1820     char buf[512];
1821     struct hostent *he;
1822     const char *p, *r;
1823     int port;
1824
1825     p = str;
1826     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1827         return -1;
1828     saddr->sin_family = AF_INET;
1829     if (buf[0] == '\0') {
1830         saddr->sin_addr.s_addr = 0;
1831     } else {
1832         if (isdigit(buf[0])) {
1833             if (!inet_aton(buf, &saddr->sin_addr))
1834                 return -1;
1835         } else {
1836             if ((he = gethostbyname(buf)) == NULL)
1837                 return - 1;
1838             saddr->sin_addr = *(struct in_addr *)he->h_addr;
1839         }
1840     }
1841     port = strtol(p, (char **)&r, 0);
1842     if (r == p)
1843         return -1;
1844     saddr->sin_port = htons(port);
1845     return 0;
1846 }
1847
1848 /* find or alloc a new VLAN */
1849 VLANState *qemu_find_vlan(int id)
1850 {
1851     VLANState **pvlan, *vlan;
1852     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1853         if (vlan->id == id)
1854             return vlan;
1855     }
1856     vlan = qemu_mallocz(sizeof(VLANState));
1857     if (!vlan)
1858         return NULL;
1859     vlan->id = id;
1860     vlan->next = NULL;
1861     pvlan = &first_vlan;
1862     while (*pvlan != NULL)
1863         pvlan = &(*pvlan)->next;
1864     *pvlan = vlan;
1865     return vlan;
1866 }
1867
1868 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
1869                                       IOReadHandler *fd_read,
1870                                       IOCanRWHandler *fd_can_read,
1871                                       void *opaque)
1872 {
1873     VLANClientState *vc, **pvc;
1874     vc = qemu_mallocz(sizeof(VLANClientState));
1875     if (!vc)
1876         return NULL;
1877     vc->fd_read = fd_read;
1878     vc->fd_can_read = fd_can_read;
1879     vc->opaque = opaque;
1880     vc->vlan = vlan;
1881
1882     vc->next = NULL;
1883     pvc = &vlan->first_client;
1884     while (*pvc != NULL)
1885         pvc = &(*pvc)->next;
1886     *pvc = vc;
1887     return vc;
1888 }
1889
1890 int qemu_can_send_packet(VLANClientState *vc1)
1891 {
1892     VLANState *vlan = vc1->vlan;
1893     VLANClientState *vc;
1894
1895     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
1896         if (vc != vc1) {
1897             if (vc->fd_can_read && !vc->fd_can_read(vc->opaque))
1898                 return 0;
1899         }
1900     }
1901     return 1;
1902 }
1903
1904 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
1905 {
1906     VLANState *vlan = vc1->vlan;
1907     VLANClientState *vc;
1908
1909 #if 0
1910     printf("vlan %d send:\n", vlan->id);
1911     hex_dump(stdout, buf, size);
1912 #endif
1913     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
1914         if (vc != vc1) {
1915             vc->fd_read(vc->opaque, buf, size);
1916         }
1917     }
1918 }
1919
1920 #if defined(CONFIG_SLIRP)
1921
1922 /* slirp network adapter */
1923
1924 static int slirp_inited;
1925 static VLANClientState *slirp_vc;
1926
1927 int slirp_can_output(void)
1928 {
1929     return !slirp_vc || qemu_can_send_packet(slirp_vc);
1930 }
1931
1932 void slirp_output(const uint8_t *pkt, int pkt_len)
1933 {
1934 #if 0
1935     printf("slirp output:\n");
1936     hex_dump(stdout, pkt, pkt_len);
1937 #endif
1938     if (!slirp_vc)
1939         return;
1940     qemu_send_packet(slirp_vc, pkt, pkt_len);
1941 }
1942
1943 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
1944 {
1945 #if 0
1946     printf("slirp input:\n");
1947     hex_dump(stdout, buf, size);
1948 #endif
1949     slirp_input(buf, size);
1950 }
1951
1952 static int net_slirp_init(VLANState *vlan)
1953 {
1954     if (!slirp_inited) {
1955         slirp_inited = 1;
1956         slirp_init();
1957     }
1958     slirp_vc = qemu_new_vlan_client(vlan,
1959                                     slirp_receive, NULL, NULL);
1960     snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
1961     return 0;
1962 }
1963
1964 static void net_slirp_redir(const char *redir_str)
1965 {
1966     int is_udp;
1967     char buf[256], *r;
1968     const char *p;
1969     struct in_addr guest_addr;
1970     int host_port, guest_port;
1971
1972     if (!slirp_inited) {
1973         slirp_inited = 1;
1974         slirp_init();
1975     }
1976
1977     p = redir_str;
1978     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1979         goto fail;
1980     if (!strcmp(buf, "tcp")) {
1981         is_udp = 0;
1982     } else if (!strcmp(buf, "udp")) {
1983         is_udp = 1;
1984     } else {
1985         goto fail;
1986     }
1987
1988     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1989         goto fail;
1990     host_port = strtol(buf, &r, 0);
1991     if (r == buf)
1992         goto fail;
1993
1994     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1995         goto fail;
1996     if (buf[0] == '\0') {
1997         pstrcpy(buf, sizeof(buf), "10.0.2.15");
1998     }
1999     if (!inet_aton(buf, &guest_addr))
2000         goto fail;
2001
2002     guest_port = strtol(p, &r, 0);
2003     if (r == p)
2004         goto fail;
2005
2006     if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
2007         fprintf(stderr, "qemu: could not set up redirection\n");
2008         exit(1);
2009     }
2010     return;
2011  fail:
2012     fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
2013     exit(1);
2014 }
2015
2016 #ifndef _WIN32
2017
2018 char smb_dir[1024];
2019
2020 static void smb_exit(void)
2021 {
2022     DIR *d;
2023     struct dirent *de;
2024     char filename[1024];
2025
2026     /* erase all the files in the directory */
2027     d = opendir(smb_dir);
2028     for(;;) {
2029         de = readdir(d);
2030         if (!de)
2031             break;
2032         if (strcmp(de->d_name, ".") != 0 &&
2033             strcmp(de->d_name, "..") != 0) {
2034             snprintf(filename, sizeof(filename), "%s/%s",
2035                      smb_dir, de->d_name);
2036             unlink(filename);
2037         }
2038     }
2039     closedir(d);
2040     rmdir(smb_dir);
2041 }
2042
2043 /* automatic user mode samba server configuration */
2044 void net_slirp_smb(const char *exported_dir)
2045 {
2046     char smb_conf[1024];
2047     char smb_cmdline[1024];
2048     FILE *f;
2049
2050     if (!slirp_inited) {
2051         slirp_inited = 1;
2052         slirp_init();
2053     }
2054
2055     /* XXX: better tmp dir construction */
2056     snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
2057     if (mkdir(smb_dir, 0700) < 0) {
2058         fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
2059         exit(1);
2060     }
2061     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
2062
2063     f = fopen(smb_conf, "w");
2064     if (!f) {
2065         fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
2066         exit(1);
2067     }
2068     fprintf(f,
2069             "[global]\n"
2070             "private dir=%s\n"
2071             "smb ports=0\n"
2072             "socket address=127.0.0.1\n"
2073             "pid directory=%s\n"
2074             "lock directory=%s\n"
2075             "log file=%s/log.smbd\n"
2076             "smb passwd file=%s/smbpasswd\n"
2077             "security = share\n"
2078             "[qemu]\n"
2079             "path=%s\n"
2080             "read only=no\n"
2081             "guest ok=yes\n",
2082             smb_dir,
2083             smb_dir,
2084             smb_dir,
2085             smb_dir,
2086             smb_dir,
2087             exported_dir
2088             );
2089     fclose(f);
2090     atexit(smb_exit);
2091
2092     snprintf(smb_cmdline, sizeof(smb_cmdline), "/usr/sbin/smbd -s %s",
2093              smb_conf);
2094
2095     slirp_add_exec(0, smb_cmdline, 4, 139);
2096 }
2097
2098 #endif /* !defined(_WIN32) */
2099
2100 #endif /* CONFIG_SLIRP */
2101
2102 #if !defined(_WIN32)
2103
2104 typedef struct TAPState {
2105     VLANClientState *vc;
2106     int fd;
2107 } TAPState;
2108
2109 static void tap_receive(void *opaque, const uint8_t *buf, int size)
2110 {
2111     TAPState *s = opaque;
2112     int ret;
2113     for(;;) {
2114         ret = write(s->fd, buf, size);
2115         if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
2116         } else {
2117             break;
2118         }
2119     }
2120 }
2121
2122 static void tap_send(void *opaque)
2123 {
2124     TAPState *s = opaque;
2125     uint8_t buf[4096];
2126     int size;
2127
2128     size = read(s->fd, buf, sizeof(buf));
2129     if (size > 0) {
2130         qemu_send_packet(s->vc, buf, size);
2131     }
2132 }
2133
2134 /* fd support */
2135
2136 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
2137 {
2138     TAPState *s;
2139
2140     s = qemu_mallocz(sizeof(TAPState));
2141     if (!s)
2142         return NULL;
2143     s->fd = fd;
2144     s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
2145     qemu_set_fd_handler(s->fd, tap_send, NULL, s);
2146     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
2147     return s;
2148 }
2149
2150 #ifdef _BSD
2151 static int tap_open(char *ifname, int ifname_size)
2152 {
2153     int fd;
2154     char *dev;
2155     struct stat s;
2156
2157     fd = open("/dev/tap", O_RDWR);
2158     if (fd < 0) {
2159         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
2160         return -1;
2161     }
2162
2163     fstat(fd, &s);
2164     dev = devname(s.st_rdev, S_IFCHR);
2165     pstrcpy(ifname, ifname_size, dev);
2166
2167     fcntl(fd, F_SETFL, O_NONBLOCK);
2168     return fd;
2169 }
2170 #else
2171 static int tap_open(char *ifname, int ifname_size)
2172 {
2173     struct ifreq ifr;
2174     int fd, ret;
2175
2176     fd = open("/dev/net/tun", O_RDWR);
2177     if (fd < 0) {
2178         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
2179         return -1;
2180     }
2181     memset(&ifr, 0, sizeof(ifr));
2182     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
2183     if (ifname[0] != '\0')
2184         pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
2185     else
2186         pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
2187     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
2188     if (ret != 0) {
2189         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
2190         close(fd);
2191         return -1;
2192     }
2193     pstrcpy(ifname, ifname_size, ifr.ifr_name);
2194     fcntl(fd, F_SETFL, O_NONBLOCK);
2195     return fd;
2196 }
2197 #endif
2198
2199 static int net_tap_init(VLANState *vlan, const char *ifname1,
2200                         const char *setup_script)
2201 {
2202     TAPState *s;
2203     int pid, status, fd;
2204     char *args[3];
2205     char **parg;
2206     char ifname[128];
2207
2208     if (ifname1 != NULL)
2209         pstrcpy(ifname, sizeof(ifname), ifname1);
2210     else
2211         ifname[0] = '\0';
2212     fd = tap_open(ifname, sizeof(ifname));
2213     if (fd < 0)
2214         return -1;
2215
2216     if (!setup_script)
2217         setup_script = "";
2218     if (setup_script[0] != '\0') {
2219         /* try to launch network init script */
2220         pid = fork();
2221         if (pid >= 0) {
2222             if (pid == 0) {
2223                 parg = args;
2224                 *parg++ = (char *)setup_script;
2225                 *parg++ = ifname;
2226                 *parg++ = NULL;
2227                 execv(setup_script, args);
2228                 _exit(1);
2229             }
2230             while (waitpid(pid, &status, 0) != pid);
2231             if (!WIFEXITED(status) ||
2232                 WEXITSTATUS(status) != 0) {
2233                 fprintf(stderr, "%s: could not launch network script\n",
2234                         setup_script);
2235                 return -1;
2236             }
2237         }
2238     }
2239     s = net_tap_fd_init(vlan, fd);
2240     if (!s)
2241         return -1;
2242     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2243              "tap: ifname=%s setup_script=%s", ifname, setup_script);
2244     return 0;
2245 }
2246
2247 #endif /* !_WIN32 */
2248
2249 /* network connection */
2250 typedef struct NetSocketState {
2251     VLANClientState *vc;
2252     int fd;
2253     int state; /* 0 = getting length, 1 = getting data */
2254     int index;
2255     int packet_len;
2256     uint8_t buf[4096];
2257     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
2258 } NetSocketState;
2259
2260 typedef struct NetSocketListenState {
2261     VLANState *vlan;
2262     int fd;
2263 } NetSocketListenState;
2264
2265 /* XXX: we consider we can send the whole packet without blocking */
2266 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
2267 {
2268     NetSocketState *s = opaque;
2269     uint32_t len;
2270     len = htonl(size);
2271
2272     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
2273     send_all(s->fd, buf, size);
2274 }
2275
2276 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
2277 {
2278     NetSocketState *s = opaque;
2279     sendto(s->fd, buf, size, 0,
2280            (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
2281 }
2282
2283 static void net_socket_send(void *opaque)
2284 {
2285     NetSocketState *s = opaque;
2286     int l, size, err;
2287     uint8_t buf1[4096];
2288     const uint8_t *buf;
2289
2290     size = recv(s->fd, buf1, sizeof(buf1), 0);
2291     if (size < 0) {
2292         err = socket_error();
2293         if (err != EWOULDBLOCK)
2294             goto eoc;
2295     } else if (size == 0) {
2296         /* end of connection */
2297     eoc:
2298         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2299         closesocket(s->fd);
2300         return;
2301     }
2302     buf = buf1;
2303     while (size > 0) {
2304         /* reassemble a packet from the network */
2305         switch(s->state) {
2306         case 0:
2307             l = 4 - s->index;
2308             if (l > size)
2309                 l = size;
2310             memcpy(s->buf + s->index, buf, l);
2311             buf += l;
2312             size -= l;
2313             s->index += l;
2314             if (s->index == 4) {
2315                 /* got length */
2316                 s->packet_len = ntohl(*(uint32_t *)s->buf);
2317                 s->index = 0;
2318                 s->state = 1;
2319             }
2320             break;
2321         case 1:
2322             l = s->packet_len - s->index;
2323             if (l > size)
2324                 l = size;
2325             memcpy(s->buf + s->index, buf, l);
2326             s->index += l;
2327             buf += l;
2328             size -= l;
2329             if (s->index >= s->packet_len) {
2330                 qemu_send_packet(s->vc, s->buf, s->packet_len);
2331                 s->index = 0;
2332                 s->state = 0;
2333             }
2334             break;
2335         }
2336     }
2337 }
2338
2339 static void net_socket_send_dgram(void *opaque)
2340 {
2341     NetSocketState *s = opaque;
2342     int size;
2343
2344     size = recv(s->fd, s->buf, sizeof(s->buf), 0);
2345     if (size < 0)
2346         return;
2347     if (size == 0) {
2348         /* end of connection */
2349         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2350         return;
2351     }
2352     qemu_send_packet(s->vc, s->buf, size);
2353 }
2354
2355 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
2356 {
2357     struct ip_mreq imr;
2358     int fd;
2359     int val, ret;
2360     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
2361         fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
2362                 inet_ntoa(mcastaddr->sin_addr),
2363                 (int)ntohl(mcastaddr->sin_addr.s_addr));
2364         return -1;
2365
2366     }
2367     fd = socket(PF_INET, SOCK_DGRAM, 0);
2368     if (fd < 0) {
2369         perror("socket(PF_INET, SOCK_DGRAM)");
2370         return -1;
2371     }
2372
2373     val = 1;
2374     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
2375                    (const char *)&val, sizeof(val));
2376     if (ret < 0) {
2377         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
2378         goto fail;
2379     }
2380
2381     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
2382     if (ret < 0) {
2383         perror("bind");
2384         goto fail;
2385     }
2386
2387     /* Add host to multicast group */
2388     imr.imr_multiaddr = mcastaddr->sin_addr;
2389     imr.imr_interface.s_addr = htonl(INADDR_ANY);
2390
2391     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
2392                      (const char *)&imr, sizeof(struct ip_mreq));
2393     if (ret < 0) {
2394         perror("setsockopt(IP_ADD_MEMBERSHIP)");
2395         goto fail;
2396     }
2397
2398     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
2399     val = 1;
2400     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
2401                    (const char *)&val, sizeof(val));
2402     if (ret < 0) {
2403         perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
2404         goto fail;
2405     }
2406
2407     socket_set_nonblock(fd);
2408     return fd;
2409 fail:
2410     if (fd>=0) close(fd);
2411     return -1;
2412 }
2413
2414 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
2415                                           int is_connected)
2416 {
2417     struct sockaddr_in saddr;
2418     int newfd;
2419     socklen_t saddr_len;
2420     NetSocketState *s;
2421
2422     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
2423      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
2424      * by ONLY ONE process: we must "clone" this dgram socket --jjo
2425      */
2426
2427     if (is_connected) {
2428         if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
2429             /* must be bound */
2430             if (saddr.sin_addr.s_addr==0) {
2431                 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
2432                         fd);
2433                 return NULL;
2434             }
2435             /* clone dgram socket */
2436             newfd = net_socket_mcast_create(&saddr);
2437             if (newfd < 0) {
2438                 /* error already reported by net_socket_mcast_create() */
2439                 close(fd);
2440                 return NULL;
2441             }
2442             /* clone newfd to fd, close newfd */
2443             dup2(newfd, fd);
2444             close(newfd);
2445
2446         } else {
2447             fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
2448                     fd, strerror(errno));
2449             return NULL;
2450         }
2451     }
2452
2453     s = qemu_mallocz(sizeof(NetSocketState));
2454     if (!s)
2455         return NULL;
2456     s->fd = fd;
2457
2458     s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
2459     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2460
2461     /* mcast: save bound address as dst */
2462     if (is_connected) s->dgram_dst=saddr;
2463
2464     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2465             "socket: fd=%d (%s mcast=%s:%d)",
2466             fd, is_connected? "cloned" : "",
2467             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2468     return s;
2469 }
2470
2471 static void net_socket_connect(void *opaque)
2472 {
2473     NetSocketState *s = opaque;
2474     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2475 }
2476
2477 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
2478                                           int is_connected)
2479 {
2480     NetSocketState *s;
2481     s = qemu_mallocz(sizeof(NetSocketState));
2482     if (!s)
2483         return NULL;
2484     s->fd = fd;
2485     s->vc = qemu_new_vlan_client(vlan,
2486                                  net_socket_receive, NULL, s);
2487     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2488              "socket: fd=%d", fd);
2489     if (is_connected) {
2490         net_socket_connect(s);
2491     } else {
2492         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2493     }
2494     return s;
2495 }
2496
2497 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
2498                                           int is_connected)
2499 {
2500     int so_type=-1, optlen=sizeof(so_type);
2501
2502     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
2503         fprintf(stderr, "qemu: error: setsockopt(SO_TYPE) for fd=%d failed\n", fd);
2504         return NULL;
2505     }
2506     switch(so_type) {
2507     case SOCK_DGRAM:
2508         return net_socket_fd_init_dgram(vlan, fd, is_connected);
2509     case SOCK_STREAM:
2510         return net_socket_fd_init_stream(vlan, fd, is_connected);
2511     default:
2512         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2513         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
2514         return net_socket_fd_init_stream(vlan, fd, is_connected);
2515     }
2516     return NULL;
2517 }
2518
2519 static void net_socket_accept(void *opaque)
2520 {
2521     NetSocketListenState *s = opaque;
2522     NetSocketState *s1;
2523     struct sockaddr_in saddr;
2524     socklen_t len;
2525     int fd;
2526
2527     for(;;) {
2528         len = sizeof(saddr);
2529         fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2530         if (fd < 0 && errno != EINTR) {
2531             return;
2532         } else if (fd >= 0) {
2533             break;
2534         }
2535     }
2536     s1 = net_socket_fd_init(s->vlan, fd, 1);
2537     if (!s1) {
2538         close(fd);
2539     } else {
2540         snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2541                  "socket: connection from %s:%d",
2542                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2543     }
2544 }
2545
2546 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
2547 {
2548     NetSocketListenState *s;
2549     int fd, val, ret;
2550     struct sockaddr_in saddr;
2551
2552     if (parse_host_port(&saddr, host_str) < 0)
2553         return -1;
2554
2555     s = qemu_mallocz(sizeof(NetSocketListenState));
2556     if (!s)
2557         return -1;
2558
2559     fd = socket(PF_INET, SOCK_STREAM, 0);
2560     if (fd < 0) {
2561         perror("socket");
2562         return -1;
2563     }
2564     socket_set_nonblock(fd);
2565
2566     /* allow fast reuse */
2567     val = 1;
2568     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2569
2570     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2571     if (ret < 0) {
2572         perror("bind");
2573         return -1;
2574     }
2575     ret = listen(fd, 0);
2576     if (ret < 0) {
2577         perror("listen");
2578         return -1;
2579     }
2580     s->vlan = vlan;
2581     s->fd = fd;
2582     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2583     return 0;
2584 }
2585
2586 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
2587 {
2588     NetSocketState *s;
2589     int fd, connected, ret, err;
2590     struct sockaddr_in saddr;
2591
2592     if (parse_host_port(&saddr, host_str) < 0)
2593         return -1;
2594
2595     fd = socket(PF_INET, SOCK_STREAM, 0);
2596     if (fd < 0) {
2597         perror("socket");
2598         return -1;
2599     }
2600     socket_set_nonblock(fd);
2601
2602     connected = 0;
2603     for(;;) {
2604         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2605         if (ret < 0) {
2606             err = socket_error();
2607             if (err == EINTR || err == EWOULDBLOCK) {
2608             } else if (err == EINPROGRESS) {
2609                 break;
2610             } else {
2611                 perror("connect");
2612                 closesocket(fd);
2613                 return -1;
2614             }
2615         } else {
2616             connected = 1;
2617             break;
2618         }
2619     }
2620     s = net_socket_fd_init(vlan, fd, connected);
2621     if (!s)
2622         return -1;
2623     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2624              "socket: connect to %s:%d",
2625              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2626     return 0;
2627 }
2628
2629 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
2630 {
2631     NetSocketState *s;
2632     int fd;
2633     struct sockaddr_in saddr;
2634
2635     if (parse_host_port(&saddr, host_str) < 0)
2636         return -1;
2637
2638
2639     fd = net_socket_mcast_create(&saddr);
2640     if (fd < 0)
2641         return -1;
2642
2643     s = net_socket_fd_init(vlan, fd, 0);
2644     if (!s)
2645         return -1;
2646
2647     s->dgram_dst = saddr;
2648
2649     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2650              "socket: mcast=%s:%d",
2651              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2652     return 0;
2653
2654 }
2655
2656 static int get_param_value(char *buf, int buf_size,
2657                            const char *tag, const char *str)
2658 {
2659     const char *p;
2660     char *q;
2661     char option[128];
2662
2663     p = str;
2664     for(;;) {
2665         q = option;
2666         while (*p != '\0' && *p != '=') {
2667             if ((q - option) < sizeof(option) - 1)
2668                 *q++ = *p;
2669             p++;
2670         }
2671         *q = '\0';
2672         if (*p != '=')
2673             break;
2674         p++;
2675         if (!strcmp(tag, option)) {
2676             q = buf;
2677             while (*p != '\0' && *p != ',') {
2678                 if ((q - buf) < buf_size - 1)
2679                     *q++ = *p;
2680                 p++;
2681             }
2682             *q = '\0';
2683             return q - buf;
2684         } else {
2685             while (*p != '\0' && *p != ',') {
2686                 p++;
2687             }
2688         }
2689         if (*p != ',')
2690             break;
2691         p++;
2692     }
2693     return 0;
2694 }
2695
2696 int net_client_init(const char *str)
2697 {
2698     const char *p;
2699     char *q;
2700     char device[64];
2701     char buf[1024];
2702     int vlan_id, ret;
2703     VLANState *vlan;
2704
2705     p = str;
2706     q = device;
2707     while (*p != '\0' && *p != ',') {
2708         if ((q - device) < sizeof(device) - 1)
2709             *q++ = *p;
2710         p++;
2711     }
2712     *q = '\0';
2713     if (*p == ',')
2714         p++;
2715     vlan_id = 0;
2716     if (get_param_value(buf, sizeof(buf), "vlan", p)) {
2717         vlan_id = strtol(buf, NULL, 0);
2718     }
2719     vlan = qemu_find_vlan(vlan_id);
2720     if (!vlan) {
2721         fprintf(stderr, "Could not create vlan %d\n", vlan_id);
2722         return -1;
2723     }
2724     if (!strcmp(device, "nic")) {
2725         NICInfo *nd;
2726         uint8_t *macaddr;
2727
2728         if (nb_nics >= MAX_NICS) {
2729             fprintf(stderr, "Too Many NICs\n");
2730             return -1;
2731         }
2732         nd = &nd_table[nb_nics];
2733         macaddr = nd->macaddr;
2734         macaddr[0] = 0x52;
2735         macaddr[1] = 0x54;
2736         macaddr[2] = 0x00;
2737         macaddr[3] = 0x12;
2738         macaddr[4] = 0x34;
2739         macaddr[5] = 0x56 + nb_nics;
2740
2741         if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
2742             if (parse_macaddr(macaddr, buf) < 0) {
2743                 fprintf(stderr, "invalid syntax for ethernet address\n");
2744                 return -1;
2745             }
2746         }
2747         if (get_param_value(buf, sizeof(buf), "model", p)) {
2748             nd->model = strdup(buf);
2749         }
2750         nd->vlan = vlan;
2751         nb_nics++;
2752         ret = 0;
2753     } else
2754     if (!strcmp(device, "none")) {
2755         /* does nothing. It is needed to signal that no network cards
2756            are wanted */
2757         ret = 0;
2758     } else
2759 #ifdef CONFIG_SLIRP
2760     if (!strcmp(device, "user")) {
2761         ret = net_slirp_init(vlan);
2762     } else
2763 #endif
2764 #ifdef _WIN32
2765     if (!strcmp(device, "tap")) {
2766         char ifname[64];
2767         if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
2768             fprintf(stderr, "tap: no interface name\n");
2769             return -1;
2770         }
2771         ret = tap_win32_init(vlan, ifname);
2772     } else
2773 #else
2774     if (!strcmp(device, "tap")) {
2775         char ifname[64];
2776         char setup_script[1024];
2777         int fd;
2778         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
2779             fd = strtol(buf, NULL, 0);
2780             ret = -1;
2781             if (net_tap_fd_init(vlan, fd))
2782                 ret = 0;
2783         } else {
2784             get_param_value(ifname, sizeof(ifname), "ifname", p);
2785             if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
2786                 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
2787             }
2788             ret = net_tap_init(vlan, ifname, setup_script);
2789         }
2790     } else
2791 #endif
2792     if (!strcmp(device, "socket")) {
2793         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
2794             int fd;
2795             fd = strtol(buf, NULL, 0);
2796             ret = -1;
2797             if (net_socket_fd_init(vlan, fd, 1))
2798                 ret = 0;
2799         } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
2800             ret = net_socket_listen_init(vlan, buf);
2801         } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
2802             ret = net_socket_connect_init(vlan, buf);
2803         } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
2804             ret = net_socket_mcast_init(vlan, buf);
2805         } else {
2806             fprintf(stderr, "Unknown socket options: %s\n", p);
2807             return -1;
2808         }
2809     } else
2810     {
2811         fprintf(stderr, "Unknown network device: %s\n", device);
2812         return -1;
2813     }
2814     if (ret < 0) {
2815         fprintf(stderr, "Could not initialize device '%s'\n", device);
2816     }
2817
2818     return ret;
2819 }
2820
2821 void do_info_network(void)
2822 {
2823     VLANState *vlan;
2824     VLANClientState *vc;
2825
2826     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
2827         term_printf("VLAN %d devices:\n", vlan->id);
2828         for(vc = vlan->first_client; vc != NULL; vc = vc->next)
2829             term_printf("  %s\n", vc->info_str);
2830     }
2831 }
2832
2833 /***********************************************************/
2834 /* USB devices */
2835
2836 static int usb_device_add(const char *devname)
2837 {
2838     const char *p;
2839     USBDevice *dev;
2840     int i;
2841
2842     if (!vm_usb_hub)
2843         return -1;
2844     for(i = 0;i < MAX_VM_USB_PORTS; i++) {
2845         if (!vm_usb_ports[i]->dev)
2846             break;
2847     }
2848     if (i == MAX_VM_USB_PORTS)
2849         return -1;
2850
2851     if (strstart(devname, "host:", &p)) {
2852         dev = usb_host_device_open(p);
2853         if (!dev)
2854             return -1;
2855     } else if (!strcmp(devname, "mouse")) {
2856         dev = usb_mouse_init();
2857         if (!dev)
2858             return -1;
2859     } else {
2860         return -1;
2861     }
2862     usb_attach(vm_usb_ports[i], dev);
2863     return 0;
2864 }
2865
2866 static int usb_device_del(const char *devname)
2867 {
2868     USBDevice *dev;
2869     int bus_num, addr, i;
2870     const char *p;
2871
2872     if (!vm_usb_hub)
2873         return -1;
2874
2875     p = strchr(devname, '.');
2876     if (!p)
2877         return -1;
2878     bus_num = strtoul(devname, NULL, 0);
2879     addr = strtoul(p + 1, NULL, 0);
2880     if (bus_num != 0)
2881         return -1;
2882     for(i = 0;i < MAX_VM_USB_PORTS; i++) {
2883         dev = vm_usb_ports[i]->dev;
2884         if (dev && dev->addr == addr)
2885             break;
2886     }
2887     if (i == MAX_VM_USB_PORTS)
2888         return -1;
2889     usb_attach(vm_usb_ports[i], NULL);
2890     return 0;
2891 }
2892
2893 void do_usb_add(const char *devname)
2894 {
2895     int ret;
2896     ret = usb_device_add(devname);
2897     if (ret < 0)
2898         term_printf("Could not add USB device '%s'\n", devname);
2899 }
2900
2901 void do_usb_del(const char *devname)
2902 {
2903     int ret;
2904     ret = usb_device_del(devname);
2905     if (ret < 0)
2906         term_printf("Could not remove USB device '%s'\n", devname);
2907 }
2908
2909 void usb_info(void)
2910 {
2911     USBDevice *dev;
2912     int i;
2913     const char *speed_str;
2914
2915     if (!vm_usb_hub) {
2916         term_printf("USB support not enabled\n");
2917         return;
2918     }
2919
2920     for(i = 0; i < MAX_VM_USB_PORTS; i++) {
2921         dev = vm_usb_ports[i]->dev;
2922         if (dev) {
2923             term_printf("Hub port %d:\n", i);
2924             switch(dev->speed) {
2925             case USB_SPEED_LOW:
2926                 speed_str = "1.5";
2927                 break;
2928             case USB_SPEED_FULL:
2929                 speed_str = "12";
2930                 break;
2931             case USB_SPEED_HIGH:
2932                 speed_str = "480";
2933                 break;
2934             default:
2935                 speed_str = "?";
2936                 break;
2937             }
2938             term_printf("  Device %d.%d, speed %s Mb/s\n",
2939                         0, dev->addr, speed_str);
2940         }
2941     }
2942 }
2943
2944 /***********************************************************/
2945 /* pid file */
2946
2947 static char *pid_filename;
2948
2949 /* Remove PID file. Called on normal exit */
2950
2951 static void remove_pidfile(void)
2952 {
2953     unlink (pid_filename);
2954 }
2955
2956 static void create_pidfile(const char *filename)
2957 {
2958     struct stat pidstat;
2959     FILE *f;
2960
2961     /* Try to write our PID to the named file */
2962     if (stat(filename, &pidstat) < 0) {
2963         if (errno == ENOENT) {
2964             if ((f = fopen (filename, "w")) == NULL) {
2965                 perror("Opening pidfile");
2966                 exit(1);
2967             }
2968             fprintf(f, "%d\n", getpid());
2969             fclose(f);
2970             pid_filename = qemu_strdup(filename);
2971             if (!pid_filename) {
2972                 fprintf(stderr, "Could not save PID filename");
2973                 exit(1);
2974             }
2975             atexit(remove_pidfile);
2976         }
2977     } else {
2978         fprintf(stderr, "%s already exists. Remove it and try again.\n",
2979                 filename);
2980         exit(1);
2981     }
2982 }
2983
2984 /***********************************************************/
2985 /* dumb display */
2986
2987 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
2988 {
2989 }
2990
2991 static void dumb_resize(DisplayState *ds, int w, int h)
2992 {
2993 }
2994
2995 static void dumb_refresh(DisplayState *ds)
2996 {
2997     vga_update_display();
2998 }
2999
3000 void dumb_display_init(DisplayState *ds)
3001 {
3002     ds->data = NULL;
3003     ds->linesize = 0;
3004     ds->depth = 0;
3005     ds->dpy_update = dumb_update;
3006     ds->dpy_resize = dumb_resize;
3007     ds->dpy_refresh = dumb_refresh;
3008 }
3009
3010 #if !defined(CONFIG_SOFTMMU)
3011 /***********************************************************/
3012 /* cpu signal handler */
3013 static void host_segv_handler(int host_signum, siginfo_t *info,
3014                               void *puc)
3015 {
3016     if (cpu_signal_handler(host_signum, info, puc))
3017         return;
3018     if (stdio_nb_clients > 0)
3019         term_exit();
3020     abort();
3021 }
3022 #endif
3023
3024 /***********************************************************/
3025 /* I/O handling */
3026
3027 #define MAX_IO_HANDLERS 64
3028
3029 typedef struct IOHandlerRecord {
3030     int fd;
3031     IOCanRWHandler *fd_read_poll;
3032     IOHandler *fd_read;
3033     IOHandler *fd_write;
3034     void *opaque;
3035     /* temporary data */
3036     struct pollfd *ufd;
3037     struct IOHandlerRecord *next;
3038 } IOHandlerRecord;
3039
3040 static IOHandlerRecord *first_io_handler;
3041
3042 /* XXX: fd_read_poll should be suppressed, but an API change is
3043    necessary in the character devices to suppress fd_can_read(). */
3044 int qemu_set_fd_handler2(int fd,
3045                          IOCanRWHandler *fd_read_poll,
3046                          IOHandler *fd_read,
3047                          IOHandler *fd_write,
3048                          void *opaque)
3049 {
3050     IOHandlerRecord **pioh, *ioh;
3051
3052     if (!fd_read && !fd_write) {
3053         pioh = &first_io_handler;
3054         for(;;) {
3055             ioh = *pioh;
3056             if (ioh == NULL)
3057                 break;
3058             if (ioh->fd == fd) {
3059                 *pioh = ioh->next;
3060                 qemu_free(ioh);
3061                 break;
3062             }
3063             pioh = &ioh->next;
3064         }
3065     } else {
3066         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3067             if (ioh->fd == fd)
3068                 goto found;
3069         }
3070         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
3071         if (!ioh)
3072             return -1;
3073         ioh->next = first_io_handler;
3074         first_io_handler = ioh;
3075     found:
3076         ioh->fd = fd;
3077         ioh->fd_read_poll = fd_read_poll;
3078         ioh->fd_read = fd_read;
3079         ioh->fd_write = fd_write;
3080         ioh->opaque = opaque;
3081     }
3082     return 0;
3083 }
3084
3085 int qemu_set_fd_handler(int fd,
3086                         IOHandler *fd_read,
3087                         IOHandler *fd_write,
3088                         void *opaque)
3089 {
3090     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
3091 }
3092
3093 /***********************************************************/
3094 /* savevm/loadvm support */
3095
3096 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
3097 {
3098     fwrite(buf, 1, size, f);
3099 }
3100
3101 void qemu_put_byte(QEMUFile *f, int v)
3102 {
3103     fputc(v, f);
3104 }
3105
3106 void qemu_put_be16(QEMUFile *f, unsigned int v)
3107 {
3108     qemu_put_byte(f, v >> 8);
3109     qemu_put_byte(f, v);
3110 }
3111
3112 void qemu_put_be32(QEMUFile *f, unsigned int v)
3113 {
3114     qemu_put_byte(f, v >> 24);
3115     qemu_put_byte(f, v >> 16);
3116     qemu_put_byte(f, v >> 8);
3117     qemu_put_byte(f, v);
3118 }
3119
3120 void qemu_put_be64(QEMUFile *f, uint64_t v)
3121 {
3122     qemu_put_be32(f, v >> 32);
3123     qemu_put_be32(f, v);
3124 }
3125
3126 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
3127 {
3128     return fread(buf, 1, size, f);
3129 }
3130
3131 int qemu_get_byte(QEMUFile *f)
3132 {
3133     int v;
3134     v = fgetc(f);
3135     if (v == EOF)
3136         return 0;
3137     else
3138         return v;
3139 }
3140
3141 unsigned int qemu_get_be16(QEMUFile *f)
3142 {
3143     unsigned int v;
3144     v = qemu_get_byte(f) << 8;
3145     v |= qemu_get_byte(f);
3146     return v;
3147 }
3148
3149 unsigned int qemu_get_be32(QEMUFile *f)
3150 {
3151     unsigned int v;
3152     v = qemu_get_byte(f) << 24;
3153     v |= qemu_get_byte(f) << 16;
3154     v |= qemu_get_byte(f) << 8;
3155     v |= qemu_get_byte(f);
3156     return v;
3157 }
3158
3159 uint64_t qemu_get_be64(QEMUFile *f)
3160 {
3161     uint64_t v;
3162     v = (uint64_t)qemu_get_be32(f) << 32;
3163     v |= qemu_get_be32(f);
3164     return v;
3165 }
3166
3167 int64_t qemu_ftell(QEMUFile *f)
3168 {
3169     return ftell(f);
3170 }
3171
3172 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
3173 {
3174     if (fseek(f, pos, whence) < 0)
3175         return -1;
3176     return ftell(f);
3177 }
3178
3179 typedef struct SaveStateEntry {
3180     char idstr[256];
3181     int instance_id;
3182     int version_id;
3183     SaveStateHandler *save_state;
3184     LoadStateHandler *load_state;
3185     void *opaque;
3186     struct SaveStateEntry *next;
3187 } SaveStateEntry;
3188
3189 static SaveStateEntry *first_se;
3190
3191 int register_savevm(const char *idstr,
3192                     int instance_id,
3193                     int version_id,
3194                     SaveStateHandler *save_state,
3195                     LoadStateHandler *load_state,
3196                     void *opaque)
3197 {
3198     SaveStateEntry *se, **pse;
3199
3200     se = qemu_malloc(sizeof(SaveStateEntry));
3201     if (!se)
3202         return -1;
3203     pstrcpy(se->idstr, sizeof(se->idstr), idstr);
3204     se->instance_id = instance_id;
3205     se->version_id = version_id;
3206     se->save_state = save_state;
3207     se->load_state = load_state;
3208     se->opaque = opaque;
3209     se->next = NULL;
3210
3211     /* add at the end of list */
3212     pse = &first_se;
3213     while (*pse != NULL)
3214         pse = &(*pse)->next;
3215     *pse = se;
3216     return 0;
3217 }
3218
3219 #define QEMU_VM_FILE_MAGIC   0x5145564d
3220 #define QEMU_VM_FILE_VERSION 0x00000001
3221
3222 int qemu_savevm(const char *filename)
3223 {
3224     SaveStateEntry *se;
3225     QEMUFile *f;
3226     int len, len_pos, cur_pos, saved_vm_running, ret;
3227
3228     saved_vm_running = vm_running;
3229     vm_stop(0);
3230
3231     f = fopen(filename, "wb");
3232     if (!f) {
3233         ret = -1;
3234         goto the_end;
3235     }
3236
3237     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
3238     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
3239
3240     for(se = first_se; se != NULL; se = se->next) {
3241         /* ID string */
3242         len = strlen(se->idstr);
3243         qemu_put_byte(f, len);
3244         qemu_put_buffer(f, se->idstr, len);
3245
3246         qemu_put_be32(f, se->instance_id);
3247         qemu_put_be32(f, se->version_id);
3248
3249         /* record size: filled later */
3250         len_pos = ftell(f);
3251         qemu_put_be32(f, 0);
3252
3253         se->save_state(f, se->opaque);
3254
3255         /* fill record size */
3256         cur_pos = ftell(f);
3257         len = ftell(f) - len_pos - 4;
3258         fseek(f, len_pos, SEEK_SET);
3259         qemu_put_be32(f, len);
3260         fseek(f, cur_pos, SEEK_SET);
3261     }
3262
3263     fclose(f);
3264     ret = 0;
3265  the_end:
3266     if (saved_vm_running)
3267         vm_start();
3268     return ret;
3269 }
3270
3271 static SaveStateEntry *find_se(const char *idstr, int instance_id)
3272 {
3273     SaveStateEntry *se;
3274
3275     for(se = first_se; se != NULL; se = se->next) {
3276         if (!strcmp(se->idstr, idstr) &&
3277             instance_id == se->instance_id)
3278             return se;
3279     }
3280     return NULL;
3281 }
3282
3283 int qemu_loadvm(const char *filename)
3284 {
3285     SaveStateEntry *se;
3286     QEMUFile *f;
3287     int len, cur_pos, ret, instance_id, record_len, version_id;
3288     int saved_vm_running;
3289     unsigned int v;
3290     char idstr[256];
3291
3292     saved_vm_running = vm_running;
3293     vm_stop(0);
3294
3295     f = fopen(filename, "rb");
3296     if (!f) {
3297         ret = -1;
3298         goto the_end;
3299     }
3300
3301     v = qemu_get_be32(f);
3302     if (v != QEMU_VM_FILE_MAGIC)
3303         goto fail;
3304     v = qemu_get_be32(f);
3305     if (v != QEMU_VM_FILE_VERSION) {
3306     fail:
3307         fclose(f);
3308         ret = -1;
3309         goto the_end;
3310     }
3311     for(;;) {
3312         len = qemu_get_byte(f);
3313         if (feof(f))
3314             break;
3315         qemu_get_buffer(f, idstr, len);
3316         idstr[len] = '\0';
3317         instance_id = qemu_get_be32(f);
3318         version_id = qemu_get_be32(f);
3319         record_len = qemu_get_be32(f);
3320 #if 0
3321         printf("idstr=%s instance=0x%x version=%d len=%d\n",
3322                idstr, instance_id, version_id, record_len);
3323 #endif
3324         cur_pos = ftell(f);
3325         se = find_se(idstr, instance_id);
3326         if (!se) {
3327             fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
3328                     instance_id, idstr);
3329         } else {
3330             ret = se->load_state(f, se->opaque, version_id);
3331             if (ret < 0) {
3332                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
3333                         instance_id, idstr);
3334             }
3335         }
3336         /* always seek to exact end of record */
3337         qemu_fseek(f, cur_pos + record_len, SEEK_SET);
3338     }
3339     fclose(f);
3340     ret = 0;
3341  the_end:
3342     if (saved_vm_running)
3343         vm_start();
3344     return ret;
3345 }
3346
3347 /***********************************************************/
3348 /* cpu save/restore */
3349
3350 #if defined(TARGET_I386)
3351
3352 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
3353 {
3354     qemu_put_be32(f, dt->selector);
3355     qemu_put_betl(f, dt->base);
3356     qemu_put_be32(f, dt->limit);
3357     qemu_put_be32(f, dt->flags);
3358 }
3359
3360 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
3361 {
3362     dt->selector = qemu_get_be32(f);
3363     dt->base = qemu_get_betl(f);
3364     dt->limit = qemu_get_be32(f);
3365     dt->flags = qemu_get_be32(f);
3366 }
3367
3368 void cpu_save(QEMUFile *f, void *opaque)
3369 {
3370     CPUState *env = opaque;
3371     uint16_t fptag, fpus, fpuc, fpregs_format;
3372     uint32_t hflags;
3373     int i;
3374
3375     for(i = 0; i < CPU_NB_REGS; i++)
3376         qemu_put_betls(f, &env->regs[i]);
3377     qemu_put_betls(f, &env->eip);
3378     qemu_put_betls(f, &env->eflags);
3379     hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
3380     qemu_put_be32s(f, &hflags);
3381
3382     /* FPU */
3383     fpuc = env->fpuc;
3384     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
3385     fptag = 0;
3386     for(i = 0; i < 8; i++) {
3387         fptag |= ((!env->fptags[i]) << i);
3388     }
3389
3390     qemu_put_be16s(f, &fpuc);
3391     qemu_put_be16s(f, &fpus);
3392     qemu_put_be16s(f, &fptag);
3393
3394 #ifdef USE_X86LDOUBLE
3395     fpregs_format = 0;
3396 #else
3397     fpregs_format = 1;
3398 #endif
3399     qemu_put_be16s(f, &fpregs_format);
3400
3401     for(i = 0; i < 8; i++) {
3402 #ifdef USE_X86LDOUBLE
3403         {
3404             uint64_t mant;
3405             uint16_t exp;
3406             /* we save the real CPU data (in case of MMX usage only 'mant'
3407                contains the MMX register */
3408             cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
3409             qemu_put_be64(f, mant);
3410             qemu_put_be16(f, exp);
3411         }
3412 #else
3413         /* if we use doubles for float emulation, we save the doubles to
3414            avoid losing information in case of MMX usage. It can give
3415            problems if the image is restored on a CPU where long
3416            doubles are used instead. */
3417         qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
3418 #endif
3419     }
3420
3421     for(i = 0; i < 6; i++)
3422         cpu_put_seg(f, &env->segs[i]);
3423     cpu_put_seg(f, &env->ldt);
3424     cpu_put_seg(f, &env->tr);
3425     cpu_put_seg(f, &env->gdt);
3426     cpu_put_seg(f, &env->idt);
3427
3428     qemu_put_be32s(f, &env->sysenter_cs);
3429     qemu_put_be32s(f, &env->sysenter_esp);
3430     qemu_put_be32s(f, &env->sysenter_eip);
3431
3432     qemu_put_betls(f, &env->cr[0]);
3433     qemu_put_betls(f, &env->cr[2]);
3434     qemu_put_betls(f, &env->cr[3]);
3435     qemu_put_betls(f, &env->cr[4]);
3436
3437     for(i = 0; i < 8; i++)
3438         qemu_put_betls(f, &env->dr[i]);
3439
3440     /* MMU */
3441     qemu_put_be32s(f, &env->a20_mask);
3442
3443     /* XMM */
3444     qemu_put_be32s(f, &env->mxcsr);
3445     for(i = 0; i < CPU_NB_REGS; i++) {
3446         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
3447         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
3448     }
3449
3450 #ifdef TARGET_X86_64
3451     qemu_put_be64s(f, &env->efer);
3452     qemu_put_be64s(f, &env->star);
3453     qemu_put_be64s(f, &env->lstar);
3454     qemu_put_be64s(f, &env->cstar);
3455     qemu_put_be64s(f, &env->fmask);
3456     qemu_put_be64s(f, &env->kernelgsbase);
3457 #endif
3458 }
3459
3460 #ifdef USE_X86LDOUBLE
3461 /* XXX: add that in a FPU generic layer */
3462 union x86_longdouble {
3463     uint64_t mant;
3464     uint16_t exp;
3465 };
3466
3467 #define MANTD1(fp)      (fp & ((1LL << 52) - 1))
3468 #define EXPBIAS1 1023
3469 #define EXPD1(fp)       ((fp >> 52) & 0x7FF)
3470 #define SIGND1(fp)      ((fp >> 32) & 0x80000000)
3471
3472 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
3473 {
3474     int e;
3475     /* mantissa */
3476     p->mant = (MANTD1(temp) << 11) | (1LL << 63);
3477     /* exponent + sign */
3478     e = EXPD1(temp) - EXPBIAS1 + 16383;
3479     e |= SIGND1(temp) >> 16;
3480     p->exp = e;
3481 }
3482 #endif
3483
3484 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3485 {
3486     CPUState *env = opaque;
3487     int i, guess_mmx;
3488     uint32_t hflags;
3489     uint16_t fpus, fpuc, fptag, fpregs_format;
3490
3491     if (version_id != 3)
3492         return -EINVAL;
3493     for(i = 0; i < CPU_NB_REGS; i++)
3494         qemu_get_betls(f, &env->regs[i]);
3495     qemu_get_betls(f, &env->eip);
3496     qemu_get_betls(f, &env->eflags);
3497     qemu_get_be32s(f, &hflags);
3498
3499     qemu_get_be16s(f, &fpuc);
3500     qemu_get_be16s(f, &fpus);
3501     qemu_get_be16s(f, &fptag);
3502     qemu_get_be16s(f, &fpregs_format);
3503
3504     /* NOTE: we cannot always restore the FPU state if the image come
3505        from a host with a different 'USE_X86LDOUBLE' define. We guess
3506        if we are in an MMX state to restore correctly in that case. */
3507     guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
3508     for(i = 0; i < 8; i++) {
3509         uint64_t mant;
3510         uint16_t exp;
3511
3512         switch(fpregs_format) {
3513         case 0:
3514             mant = qemu_get_be64(f);
3515             exp = qemu_get_be16(f);
3516 #ifdef USE_X86LDOUBLE
3517             env->fpregs[i].d = cpu_set_fp80(mant, exp);
3518 #else
3519             /* difficult case */
3520             if (guess_mmx)
3521                 env->fpregs[i].mmx.MMX_Q(0) = mant;
3522             else
3523                 env->fpregs[i].d = cpu_set_fp80(mant, exp);
3524 #endif
3525             break;
3526         case 1:
3527             mant = qemu_get_be64(f);
3528 #ifdef USE_X86LDOUBLE
3529             {
3530                 union x86_longdouble *p;
3531                 /* difficult case */
3532                 p = (void *)&env->fpregs[i];
3533                 if (guess_mmx) {
3534                     p->mant = mant;
3535                     p->exp = 0xffff;
3536                 } else {
3537                     fp64_to_fp80(p, mant);
3538                 }
3539             }
3540 #else
3541             env->fpregs[i].mmx.MMX_Q(0) = mant;
3542 #endif
3543             break;
3544         default:
3545             return -EINVAL;
3546         }
3547     }
3548
3549     env->fpuc = fpuc;
3550     /* XXX: restore FPU round state */
3551     env->fpstt = (fpus >> 11) & 7;
3552     env->fpus = fpus & ~0x3800;
3553     fptag ^= 0xff;
3554     for(i = 0; i < 8; i++) {
3555         env->fptags[i] = (fptag >> i) & 1;
3556     }
3557
3558     for(i = 0; i < 6; i++)
3559         cpu_get_seg(f, &env->segs[i]);
3560     cpu_get_seg(f, &env->ldt);
3561     cpu_get_seg(f, &env->tr);
3562     cpu_get_seg(f, &env->gdt);
3563     cpu_get_seg(f, &env->idt);
3564
3565     qemu_get_be32s(f, &env->sysenter_cs);
3566     qemu_get_be32s(f, &env->sysenter_esp);
3567     qemu_get_be32s(f, &env->sysenter_eip);
3568
3569     qemu_get_betls(f, &env->cr[0]);
3570     qemu_get_betls(f, &env->cr[2]);
3571     qemu_get_betls(f, &env->cr[3]);
3572     qemu_get_betls(f, &env->cr[4]);
3573
3574     for(i = 0; i < 8; i++)
3575         qemu_get_betls(f, &env->dr[i]);
3576
3577     /* MMU */
3578     qemu_get_be32s(f, &env->a20_mask);
3579
3580     qemu_get_be32s(f, &env->mxcsr);
3581     for(i = 0; i < CPU_NB_REGS; i++) {
3582         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
3583         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
3584     }
3585
3586 #ifdef TARGET_X86_64
3587     qemu_get_be64s(f, &env->efer);
3588     qemu_get_be64s(f, &env->star);
3589     qemu_get_be64s(f, &env->lstar);
3590     qemu_get_be64s(f, &env->cstar);
3591     qemu_get_be64s(f, &env->fmask);
3592     qemu_get_be64s(f, &env->kernelgsbase);
3593 #endif
3594
3595     /* XXX: compute hflags from scratch, except for CPL and IIF */
3596     env->hflags = hflags;
3597     tlb_flush(env, 1);
3598     return 0;
3599 }
3600
3601 #elif defined(TARGET_PPC)
3602 void cpu_save(QEMUFile *f, void *opaque)
3603 {
3604 }
3605
3606 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3607 {
3608     return 0;
3609 }
3610
3611 #elif defined(TARGET_MIPS)
3612 void cpu_save(QEMUFile *f, void *opaque)
3613 {
3614 }
3615
3616 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3617 {
3618     return 0;
3619 }
3620
3621 #elif defined(TARGET_SPARC)
3622 void cpu_save(QEMUFile *f, void *opaque)
3623 {
3624     CPUState *env = opaque;
3625     int i;
3626     uint32_t tmp;
3627
3628     for(i = 0; i < 8; i++)
3629         qemu_put_betls(f, &env->gregs[i]);
3630     for(i = 0; i < NWINDOWS * 16; i++)
3631         qemu_put_betls(f, &env->regbase[i]);
3632
3633     /* FPU */
3634     for(i = 0; i < TARGET_FPREGS; i++) {
3635         union {
3636             TARGET_FPREG_T f;
3637             target_ulong i;
3638         } u;
3639         u.f = env->fpr[i];
3640         qemu_put_betl(f, u.i);
3641     }
3642
3643     qemu_put_betls(f, &env->pc);
3644     qemu_put_betls(f, &env->npc);
3645     qemu_put_betls(f, &env->y);
3646     tmp = GET_PSR(env);
3647     qemu_put_be32(f, tmp);
3648     qemu_put_betls(f, &env->fsr);
3649     qemu_put_betls(f, &env->tbr);
3650 #ifndef TARGET_SPARC64
3651     qemu_put_be32s(f, &env->wim);
3652     /* MMU */
3653     for(i = 0; i < 16; i++)
3654         qemu_put_be32s(f, &env->mmuregs[i]);
3655 #endif
3656 }
3657
3658 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3659 {
3660     CPUState *env = opaque;
3661     int i;
3662     uint32_t tmp;
3663
3664     for(i = 0; i < 8; i++)
3665         qemu_get_betls(f, &env->gregs[i]);
3666     for(i = 0; i < NWINDOWS * 16; i++)
3667         qemu_get_betls(f, &env->regbase[i]);
3668
3669     /* FPU */
3670     for(i = 0; i < TARGET_FPREGS; i++) {
3671         union {
3672             TARGET_FPREG_T f;
3673             target_ulong i;
3674         } u;
3675         u.i = qemu_get_betl(f);
3676         env->fpr[i] = u.f;
3677     }
3678
3679     qemu_get_betls(f, &env->pc);
3680     qemu_get_betls(f, &env->npc);
3681     qemu_get_betls(f, &env->y);
3682     tmp = qemu_get_be32(f);
3683     env->cwp = 0; /* needed to ensure that the wrapping registers are
3684                      correctly updated */
3685     PUT_PSR(env, tmp);
3686     qemu_get_betls(f, &env->fsr);
3687     qemu_get_betls(f, &env->tbr);
3688 #ifndef TARGET_SPARC64
3689     qemu_get_be32s(f, &env->wim);
3690     /* MMU */
3691     for(i = 0; i < 16; i++)
3692         qemu_get_be32s(f, &env->mmuregs[i]);
3693 #endif
3694     tlb_flush(env, 1);
3695     return 0;
3696 }
3697
3698 #elif defined(TARGET_ARM)
3699
3700 /* ??? Need to implement these.  */
3701 void cpu_save(QEMUFile *f, void *opaque)
3702 {
3703 }
3704
3705 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3706 {
3707     return 0;
3708 }
3709
3710 #else
3711
3712 #warning No CPU save/restore functions
3713
3714 #endif
3715
3716 /***********************************************************/
3717 /* ram save/restore */
3718
3719 /* we just avoid storing empty pages */
3720 static void ram_put_page(QEMUFile *f, const uint8_t *buf, int len)
3721 {
3722     int i, v;
3723
3724     v = buf[0];
3725     for(i = 1; i < len; i++) {
3726         if (buf[i] != v)
3727             goto normal_save;
3728     }
3729     qemu_put_byte(f, 1);
3730     qemu_put_byte(f, v);
3731     return;
3732  normal_save:
3733     qemu_put_byte(f, 0);
3734     qemu_put_buffer(f, buf, len);
3735 }
3736
3737 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3738 {
3739     int v;
3740
3741     v = qemu_get_byte(f);
3742     switch(v) {
3743     case 0:
3744         if (qemu_get_buffer(f, buf, len) != len)
3745             return -EIO;
3746         break;
3747     case 1:
3748         v = qemu_get_byte(f);
3749         memset(buf, v, len);
3750         break;
3751     default:
3752         return -EINVAL;
3753     }
3754     return 0;
3755 }
3756
3757 static void ram_save(QEMUFile *f, void *opaque)
3758 {
3759     int i;
3760     qemu_put_be32(f, phys_ram_size);
3761     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3762         ram_put_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
3763     }
3764 }
3765
3766 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3767 {
3768     int i, ret;
3769
3770     if (version_id != 1)
3771         return -EINVAL;
3772     if (qemu_get_be32(f) != phys_ram_size)
3773         return -EINVAL;
3774     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3775         ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
3776         if (ret)
3777             return ret;
3778     }
3779     return 0;
3780 }
3781
3782 /***********************************************************/
3783 /* machine registration */
3784
3785 QEMUMachine *first_machine = NULL;
3786
3787 int qemu_register_machine(QEMUMachine *m)
3788 {
3789     QEMUMachine **pm;
3790     pm = &first_machine;
3791     while (*pm != NULL)
3792         pm = &(*pm)->next;
3793     m->next = NULL;
3794     *pm = m;
3795     return 0;
3796 }
3797
3798 QEMUMachine *find_machine(const char *name)
3799 {
3800     QEMUMachine *m;
3801
3802     for(m = first_machine; m != NULL; m = m->next) {
3803         if (!strcmp(m->name, name))
3804             return m;
3805     }
3806     return NULL;
3807 }
3808
3809 /***********************************************************/
3810 /* main execution loop */
3811
3812 void gui_update(void *opaque)
3813 {
3814     display_state.dpy_refresh(&display_state);
3815     qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
3816 }
3817
3818 struct vm_change_state_entry {
3819     VMChangeStateHandler *cb;
3820     void *opaque;
3821     LIST_ENTRY (vm_change_state_entry) entries;
3822 };
3823
3824 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3825
3826 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3827                                                      void *opaque)
3828 {
3829     VMChangeStateEntry *e;
3830
3831     e = qemu_mallocz(sizeof (*e));
3832     if (!e)
3833         return NULL;
3834
3835     e->cb = cb;
3836     e->opaque = opaque;
3837     LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3838     return e;
3839 }
3840
3841 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3842 {
3843     LIST_REMOVE (e, entries);
3844     qemu_free (e);
3845 }
3846
3847 static void vm_state_notify(int running)
3848 {
3849     VMChangeStateEntry *e;
3850
3851     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3852         e->cb(e->opaque, running);
3853     }
3854 }
3855
3856 /* XXX: support several handlers */
3857 static VMStopHandler *vm_stop_cb;
3858 static void *vm_stop_opaque;
3859
3860 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
3861 {
3862     vm_stop_cb = cb;
3863     vm_stop_opaque = opaque;
3864     return 0;
3865 }
3866
3867 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
3868 {
3869     vm_stop_cb = NULL;
3870 }
3871
3872 void vm_start(void)
3873 {
3874     if (!vm_running) {
3875         cpu_enable_ticks();
3876         vm_running = 1;
3877         vm_state_notify(1);
3878     }
3879 }
3880
3881 void vm_stop(int reason)
3882 {
3883     if (vm_running) {
3884         cpu_disable_ticks();
3885         vm_running = 0;
3886         if (reason != 0) {
3887             if (vm_stop_cb) {
3888                 vm_stop_cb(vm_stop_opaque, reason);
3889             }
3890         }
3891         vm_state_notify(0);
3892     }
3893 }
3894
3895 /* reset/shutdown handler */
3896
3897 typedef struct QEMUResetEntry {
3898     QEMUResetHandler *func;
3899     void *opaque;
3900     struct QEMUResetEntry *next;
3901 } QEMUResetEntry;
3902
3903 static QEMUResetEntry *first_reset_entry;
3904 static int reset_requested;
3905 static int shutdown_requested;
3906 static int powerdown_requested;
3907
3908 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3909 {
3910     QEMUResetEntry **pre, *re;
3911
3912     pre = &first_reset_entry;
3913     while (*pre != NULL)
3914         pre = &(*pre)->next;
3915     re = qemu_mallocz(sizeof(QEMUResetEntry));
3916     re->func = func;
3917     re->opaque = opaque;
3918     re->next = NULL;
3919     *pre = re;
3920 }
3921
3922 void qemu_system_reset(void)
3923 {
3924     QEMUResetEntry *re;
3925
3926     /* reset all devices */
3927     for(re = first_reset_entry; re != NULL; re = re->next) {
3928         re->func(re->opaque);
3929     }
3930 }
3931
3932 void qemu_system_reset_request(void)
3933 {
3934     reset_requested = 1;
3935     if (cpu_single_env)
3936         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3937 }
3938
3939 void qemu_system_shutdown_request(void)
3940 {
3941     shutdown_requested = 1;
3942     if (cpu_single_env)
3943         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3944 }
3945
3946 void qemu_system_powerdown_request(void)
3947 {
3948     powerdown_requested = 1;
3949     if (cpu_single_env)
3950         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3951 }
3952
3953 void main_loop_wait(int timeout)
3954 {
3955     IOHandlerRecord *ioh, *ioh_next;
3956     fd_set rfds, wfds;
3957     int ret, nfds;
3958     struct timeval tv;
3959
3960 #ifdef _WIN32
3961     /* XXX: see how to merge it with the select. The constraint is
3962        that the select must be interrupted by the timer */
3963     if (timeout > 0)
3964         Sleep(timeout);
3965 #endif
3966     /* poll any events */
3967     /* XXX: separate device handlers from system ones */
3968     nfds = -1;
3969     FD_ZERO(&rfds);
3970     FD_ZERO(&wfds);
3971     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3972         if (ioh->fd_read &&
3973             (!ioh->fd_read_poll ||
3974              ioh->fd_read_poll(ioh->opaque) != 0)) {
3975             FD_SET(ioh->fd, &rfds);
3976             if (ioh->fd > nfds)
3977                 nfds = ioh->fd;
3978         }
3979         if (ioh->fd_write) {
3980             FD_SET(ioh->fd, &wfds);
3981             if (ioh->fd > nfds)
3982                 nfds = ioh->fd;
3983         }
3984     }
3985
3986     tv.tv_sec = 0;
3987 #ifdef _WIN32
3988     tv.tv_usec = 0;
3989 #else
3990     tv.tv_usec = timeout * 1000;
3991 #endif
3992     ret = select(nfds + 1, &rfds, &wfds, NULL, &tv);
3993     if (ret > 0) {
3994         /* XXX: better handling of removal */
3995         for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
3996             ioh_next = ioh->next;
3997             if (FD_ISSET(ioh->fd, &rfds)) {
3998                 ioh->fd_read(ioh->opaque);
3999             }
4000             if (FD_ISSET(ioh->fd, &wfds)) {
4001                 ioh->fd_write(ioh->opaque);
4002             }
4003         }
4004     }
4005 #ifdef _WIN32
4006     tap_win32_poll();
4007 #endif
4008
4009 #if defined(CONFIG_SLIRP)
4010     /* XXX: merge with the previous select() */
4011     if (slirp_inited) {
4012         fd_set rfds, wfds, xfds;
4013         int nfds;
4014         struct timeval tv;
4015
4016         nfds = -1;
4017         FD_ZERO(&rfds);
4018         FD_ZERO(&wfds);
4019         FD_ZERO(&xfds);
4020         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4021         tv.tv_sec = 0;
4022         tv.tv_usec = 0;
4023         ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4024         if (ret >= 0) {
4025             slirp_select_poll(&rfds, &wfds, &xfds);
4026         }
4027     }
4028 #endif
4029
4030     if (vm_running) {
4031         qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4032                         qemu_get_clock(vm_clock));
4033         /* run dma transfers, if any */
4034         DMA_run();
4035     }
4036
4037     /* real time timers */
4038     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
4039                     qemu_get_clock(rt_clock));
4040 }
4041
4042 static CPUState *cur_cpu;
4043
4044 int main_loop(void)
4045 {
4046     int ret, timeout;
4047 #ifdef CONFIG_PROFILER
4048     int64_t ti;
4049 #endif
4050     CPUState *env;
4051
4052     cur_cpu = first_cpu;
4053     for(;;) {
4054         if (vm_running) {
4055
4056             env = cur_cpu;
4057             for(;;) {
4058                 /* get next cpu */
4059                 env = env->next_cpu;
4060                 if (!env)
4061                     env = first_cpu;
4062 #ifdef CONFIG_PROFILER
4063                 ti = profile_getclock();
4064 #endif
4065                 ret = cpu_exec(env);
4066 #ifdef CONFIG_PROFILER
4067                 qemu_time += profile_getclock() - ti;
4068 #endif
4069                 if (ret != EXCP_HALTED)
4070                     break;
4071                 /* all CPUs are halted ? */
4072                 if (env == cur_cpu) {
4073                     ret = EXCP_HLT;
4074                     break;
4075                 }
4076             }
4077             cur_cpu = env;
4078
4079             if (shutdown_requested) {
4080                 ret = EXCP_INTERRUPT;
4081                 break;
4082             }
4083             if (reset_requested) {
4084                 reset_requested = 0;
4085                 qemu_system_reset();
4086                 ret = EXCP_INTERRUPT;
4087             }
4088             if (powerdown_requested) {
4089                 powerdown_requested = 0;
4090                 qemu_system_powerdown();
4091                 ret = EXCP_INTERRUPT;
4092             }
4093             if (ret == EXCP_DEBUG) {
4094                 vm_stop(EXCP_DEBUG);
4095             }
4096             /* if hlt instruction, we wait until the next IRQ */
4097             /* XXX: use timeout computed from timers */
4098             if (ret == EXCP_HLT)
4099                 timeout = 10;
4100             else
4101                 timeout = 0;
4102         } else {
4103             timeout = 10;
4104         }
4105 #ifdef CONFIG_PROFILER
4106         ti = profile_getclock();
4107 #endif
4108         main_loop_wait(timeout);
4109 #ifdef CONFIG_PROFILER
4110         dev_time += profile_getclock() - ti;
4111 #endif
4112     }
4113     cpu_disable_ticks();
4114     return ret;
4115 }
4116
4117 void help(void)
4118 {
4119     printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2005 Fabrice Bellard\n"
4120            "usage: %s [options] [disk_image]\n"
4121            "\n"
4122            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4123            "\n"
4124            "Standard options:\n"
4125            "-M machine      select emulated machine (-M ? for list)\n"
4126            "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
4127            "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
4128            "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
4129            "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
4130            "-boot [a|c|d]   boot on floppy (a), hard disk (c) or CD-ROM (d)\n"
4131            "-snapshot       write to temporary files instead of disk image files\n"
4132            "-m megs         set virtual RAM size to megs MB [default=%d]\n"
4133            "-smp n          set the number of CPUs to 'n' [default=1]\n"
4134            "-nographic      disable graphical output and redirect serial I/Os to console\n"
4135 #ifndef _WIN32
4136            "-k language     use keyboard layout (for example \"fr\" for French)\n"
4137 #endif
4138 #ifdef HAS_AUDIO
4139            "-audio-help     print list of audio drivers and their options\n"
4140            "-soundhw c1,... enable audio support\n"
4141            "                and only specified sound cards (comma separated list)\n"
4142            "                use -soundhw ? to get the list of supported cards\n"
4143            "                use -soundhw all to enable all of them\n"
4144 #endif
4145            "-localtime      set the real time clock to local time [default=utc]\n"
4146            "-full-screen    start in full screen\n"
4147 #ifdef TARGET_I386
4148            "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n"
4149 #endif
4150            "-usb            enable the USB driver (will be the default soon)\n"
4151            "-usbdevice name add the host or guest USB device 'name'\n"
4152 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4153            "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"
4154 #endif
4155            "\n"
4156            "Network options:\n"
4157            "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
4158            "                create a new Network Interface Card and connect it to VLAN 'n'\n"
4159 #ifdef CONFIG_SLIRP
4160            "-net user[,vlan=n]\n"
4161            "                connect the user mode network stack to VLAN 'n'\n"
4162 #endif
4163 #ifdef _WIN32
4164            "-net tap[,vlan=n],ifname=name\n"
4165            "                connect the host TAP network interface to VLAN 'n'\n"
4166 #else
4167            "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file]\n"
4168            "                connect the host TAP network interface to VLAN 'n' and use\n"
4169            "                the network script 'file' (default=%s);\n"
4170            "                use 'fd=h' to connect to an already opened TAP interface\n"
4171 #endif
4172            "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
4173            "                connect the vlan 'n' to another VLAN using a socket connection\n"
4174            "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
4175            "                connect the vlan 'n' to multicast maddr and port\n"
4176            "-net none       use it alone to have zero network devices; if no -net option\n"
4177            "                is provided, the default is '-net nic -net user'\n"
4178            "\n"
4179 #ifdef CONFIG_SLIRP
4180            "-tftp prefix    allow tftp access to files starting with prefix [-net user]\n"
4181 #ifndef _WIN32
4182            "-smb dir        allow SMB access to files in 'dir' [-net user]\n"
4183 #endif
4184            "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
4185            "                redirect TCP or UDP connections from host to guest [-net user]\n"
4186 #endif
4187            "\n"
4188            "Linux boot specific:\n"
4189            "-kernel bzImage use 'bzImage' as kernel image\n"
4190            "-append cmdline use 'cmdline' as kernel command line\n"
4191            "-initrd file    use 'file' as initial ram disk\n"
4192            "\n"
4193            "Debug/Expert options:\n"
4194            "-monitor dev    redirect the monitor to char device 'dev'\n"
4195            "-serial dev     redirect the serial port to char device 'dev'\n"
4196            "-parallel dev   redirect the parallel port to char device 'dev'\n"
4197            "-pidfile file   Write PID to 'file'\n"
4198            "-S              freeze CPU at startup (use 'c' to start execution)\n"
4199            "-s              wait gdb connection to port %d\n"
4200            "-p port         change gdb connection port\n"
4201            "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
4202            "-hdachs c,h,s[,t]  force hard disk 0 physical geometry and the optional BIOS\n"
4203            "                translation (t=none or lba) (usually qemu can guess them)\n"
4204            "-L path         set the directory for the BIOS and VGA BIOS\n"
4205 #ifdef USE_KQEMU
4206            "-no-kqemu       disable KQEMU kernel module usage\n"
4207 #endif
4208 #ifdef USE_CODE_COPY
4209            "-no-code-copy   disable code copy acceleration\n"
4210 #endif
4211 #ifdef TARGET_I386
4212            "-std-vga        simulate a standard VGA card with VESA Bochs Extensions\n"
4213            "                (default is CL-GD5446 PCI VGA)\n"
4214 #endif
4215            "-loadvm file    start right away with a saved state (loadvm in monitor)\n"
4216            "\n"
4217            "During emulation, the following keys are useful:\n"
4218            "ctrl-alt-f      toggle full screen\n"
4219            "ctrl-alt-n      switch to virtual console 'n'\n"
4220            "ctrl-alt        toggle mouse and keyboard grab\n"
4221            "\n"
4222            "When using -nographic, press 'ctrl-a h' to get some help.\n"
4223            ,
4224 #ifdef CONFIG_SOFTMMU
4225            "qemu",
4226 #else
4227            "qemu-fast",
4228 #endif
4229            DEFAULT_RAM_SIZE,
4230 #ifndef _WIN32
4231            DEFAULT_NETWORK_SCRIPT,
4232 #endif
4233            DEFAULT_GDBSTUB_PORT,
4234            "/tmp/qemu.log");
4235 #ifndef CONFIG_SOFTMMU
4236     printf("\n"
4237            "NOTE: this version of QEMU is faster but it needs slightly patched OSes to\n"
4238            "work. Please use the 'qemu' executable to have a more accurate (but slower)\n"
4239            "PC emulation.\n");
4240 #endif
4241     exit(1);
4242 }
4243
4244 #define HAS_ARG 0x0001
4245
4246 enum {
4247     QEMU_OPTION_h,
4248
4249     QEMU_OPTION_M,
4250     QEMU_OPTION_fda,
4251     QEMU_OPTION_fdb,
4252     QEMU_OPTION_hda,
4253     QEMU_OPTION_hdb,
4254     QEMU_OPTION_hdc,
4255     QEMU_OPTION_hdd,
4256     QEMU_OPTION_cdrom,
4257     QEMU_OPTION_boot,
4258     QEMU_OPTION_snapshot,
4259     QEMU_OPTION_m,
4260     QEMU_OPTION_nographic,
4261 #ifdef HAS_AUDIO
4262     QEMU_OPTION_audio_help,
4263     QEMU_OPTION_soundhw,
4264 #endif
4265
4266     QEMU_OPTION_net,
4267     QEMU_OPTION_tftp,
4268     QEMU_OPTION_smb,
4269     QEMU_OPTION_redir,
4270
4271     QEMU_OPTION_kernel,
4272     QEMU_OPTION_append,
4273     QEMU_OPTION_initrd,
4274
4275     QEMU_OPTION_S,
4276     QEMU_OPTION_s,
4277     QEMU_OPTION_p,
4278     QEMU_OPTION_d,
4279     QEMU_OPTION_hdachs,
4280     QEMU_OPTION_L,
4281     QEMU_OPTION_no_code_copy,
4282     QEMU_OPTION_k,
4283     QEMU_OPTION_localtime,
4284     QEMU_OPTION_cirrusvga,
4285     QEMU_OPTION_g,
4286     QEMU_OPTION_std_vga,
4287     QEMU_OPTION_monitor,
4288     QEMU_OPTION_serial,
4289     QEMU_OPTION_parallel,
4290     QEMU_OPTION_loadvm,
4291     QEMU_OPTION_full_screen,
4292     QEMU_OPTION_pidfile,
4293     QEMU_OPTION_no_kqemu,
4294     QEMU_OPTION_kernel_kqemu,
4295     QEMU_OPTION_win2k_hack,
4296     QEMU_OPTION_usb,
4297     QEMU_OPTION_usbdevice,
4298     QEMU_OPTION_smp,
4299 };
4300
4301 typedef struct QEMUOption {
4302     const char *name;
4303     int flags;
4304     int index;
4305 } QEMUOption;
4306
4307 const QEMUOption qemu_options[] = {
4308     { "h", 0, QEMU_OPTION_h },
4309
4310     { "M", HAS_ARG, QEMU_OPTION_M },
4311     { "fda", HAS_ARG, QEMU_OPTION_fda },
4312     { "fdb", HAS_ARG, QEMU_OPTION_fdb },
4313     { "hda", HAS_ARG, QEMU_OPTION_hda },
4314     { "hdb", HAS_ARG, QEMU_OPTION_hdb },
4315     { "hdc", HAS_ARG, QEMU_OPTION_hdc },
4316     { "hdd", HAS_ARG, QEMU_OPTION_hdd },
4317     { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
4318     { "boot", HAS_ARG, QEMU_OPTION_boot },
4319     { "snapshot", 0, QEMU_OPTION_snapshot },
4320     { "m", HAS_ARG, QEMU_OPTION_m },
4321     { "nographic", 0, QEMU_OPTION_nographic },
4322     { "k", HAS_ARG, QEMU_OPTION_k },
4323 #ifdef HAS_AUDIO
4324     { "audio-help", 0, QEMU_OPTION_audio_help },
4325     { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
4326 #endif
4327
4328     { "net", HAS_ARG, QEMU_OPTION_net},
4329 #ifdef CONFIG_SLIRP
4330     { "tftp", HAS_ARG, QEMU_OPTION_tftp },
4331 #ifndef _WIN32
4332     { "smb", HAS_ARG, QEMU_OPTION_smb },
4333 #endif
4334     { "redir", HAS_ARG, QEMU_OPTION_redir },
4335 #endif
4336
4337     { "kernel", HAS_ARG, QEMU_OPTION_kernel },
4338     { "append", HAS_ARG, QEMU_OPTION_append },
4339     { "initrd", HAS_ARG, QEMU_OPTION_initrd },
4340
4341     { "S", 0, QEMU_OPTION_S },
4342     { "s", 0, QEMU_OPTION_s },
4343     { "p", HAS_ARG, QEMU_OPTION_p },
4344     { "d", HAS_ARG, QEMU_OPTION_d },
4345     { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
4346     { "L", HAS_ARG, QEMU_OPTION_L },
4347     { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
4348 #ifdef USE_KQEMU
4349     { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
4350     { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
4351 #endif
4352 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4353     { "g", 1, QEMU_OPTION_g },
4354 #endif
4355     { "localtime", 0, QEMU_OPTION_localtime },
4356     { "std-vga", 0, QEMU_OPTION_std_vga },
4357     { "monitor", 1, QEMU_OPTION_monitor },
4358     { "serial", 1, QEMU_OPTION_serial },
4359     { "parallel", 1, QEMU_OPTION_parallel },
4360     { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
4361     { "full-screen", 0, QEMU_OPTION_full_screen },
4362     { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
4363     { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
4364     { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
4365     { "smp", HAS_ARG, QEMU_OPTION_smp },
4366
4367     /* temporary options */
4368     { "usb", 0, QEMU_OPTION_usb },
4369     { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
4370     { NULL },
4371 };
4372
4373 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
4374
4375 /* this stack is only used during signal handling */
4376 #define SIGNAL_STACK_SIZE 32768
4377
4378 static uint8_t *signal_stack;
4379
4380 #endif
4381
4382 /* password input */
4383
4384 static BlockDriverState *get_bdrv(int index)
4385 {
4386     BlockDriverState *bs;
4387
4388     if (index < 4) {
4389         bs = bs_table[index];
4390     } else if (index < 6) {
4391         bs = fd_table[index - 4];
4392     } else {
4393         bs = NULL;
4394     }
4395     return bs;
4396 }
4397
4398 static void read_passwords(void)
4399 {
4400     BlockDriverState *bs;
4401     int i, j;
4402     char password[256];
4403
4404     for(i = 0; i < 6; i++) {
4405         bs = get_bdrv(i);
4406         if (bs && bdrv_is_encrypted(bs)) {
4407             term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
4408             for(j = 0; j < 3; j++) {
4409                 monitor_readline("Password: ",
4410                                  1, password, sizeof(password));
4411                 if (bdrv_set_key(bs, password) == 0)
4412                     break;
4413                 term_printf("invalid password\n");
4414             }
4415         }
4416     }
4417 }
4418
4419 /* XXX: currently we cannot use simultaneously different CPUs */
4420 void register_machines(void)
4421 {
4422 #if defined(TARGET_I386)
4423     qemu_register_machine(&pc_machine);
4424     qemu_register_machine(&isapc_machine);
4425 #elif defined(TARGET_PPC)
4426     qemu_register_machine(&heathrow_machine);
4427     qemu_register_machine(&core99_machine);
4428     qemu_register_machine(&prep_machine);
4429 #elif defined(TARGET_MIPS)
4430     qemu_register_machine(&mips_machine);
4431 #elif defined(TARGET_SPARC)
4432 #ifdef TARGET_SPARC64
4433     qemu_register_machine(&sun4u_machine);
4434 #else
4435     qemu_register_machine(&sun4m_machine);
4436 #endif
4437 #elif defined(TARGET_ARM)
4438     qemu_register_machine(&integratorcp926_machine);
4439     qemu_register_machine(&integratorcp1026_machine);
4440 #else
4441 #error unsupported CPU
4442 #endif
4443 }
4444
4445 #ifdef HAS_AUDIO
4446 struct soundhw soundhw[] = {
4447     {
4448         "sb16",
4449         "Creative Sound Blaster 16",
4450         0,
4451         1,
4452         { .init_isa = SB16_init }
4453     },
4454
4455 #ifdef CONFIG_ADLIB
4456     {
4457         "adlib",
4458 #ifdef HAS_YMF262
4459         "Yamaha YMF262 (OPL3)",
4460 #else
4461         "Yamaha YM3812 (OPL2)",
4462 #endif
4463         0,
4464         1,
4465         { .init_isa = Adlib_init }
4466     },
4467 #endif
4468
4469 #ifdef CONFIG_GUS
4470     {
4471         "gus",
4472         "Gravis Ultrasound GF1",
4473         0,
4474         1,
4475         { .init_isa = GUS_init }
4476     },
4477 #endif
4478
4479     {
4480         "es1370",
4481         "ENSONIQ AudioPCI ES1370",
4482         0,
4483         0,
4484         { .init_pci = es1370_init }
4485     },
4486
4487     { NULL, NULL, 0, 0, { NULL } }
4488 };
4489
4490 static void select_soundhw (const char *optarg)
4491 {
4492     struct soundhw *c;
4493
4494     if (*optarg == '?') {
4495     show_valid_cards:
4496
4497         printf ("Valid sound card names (comma separated):\n");
4498         for (c = soundhw; c->name; ++c) {
4499             printf ("%-11s %s\n", c->name, c->descr);
4500         }
4501         printf ("\n-soundhw all will enable all of the above\n");
4502         exit (*optarg != '?');
4503     }
4504     else {
4505         size_t l;
4506         const char *p;
4507         char *e;
4508         int bad_card = 0;
4509
4510         if (!strcmp (optarg, "all")) {
4511             for (c = soundhw; c->name; ++c) {
4512                 c->enabled = 1;
4513             }
4514             return;
4515         }
4516
4517         p = optarg;
4518         while (*p) {
4519             e = strchr (p, ',');
4520             l = !e ? strlen (p) : (size_t) (e - p);
4521
4522             for (c = soundhw; c->name; ++c) {
4523                 if (!strncmp (c->name, p, l)) {
4524                     c->enabled = 1;
4525                     break;
4526                 }
4527             }
4528
4529             if (!c->name) {
4530                 if (l > 80) {
4531                     fprintf (stderr,
4532                              "Unknown sound card name (too big to show)\n");
4533                 }
4534                 else {
4535                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4536                              (int) l, p);
4537                 }
4538                 bad_card = 1;
4539             }
4540             p += l + (e != NULL);
4541         }
4542
4543         if (bad_card)
4544             goto show_valid_cards;
4545     }
4546 }
4547 #endif
4548
4549 #define MAX_NET_CLIENTS 32
4550
4551 int main(int argc, char **argv)
4552 {
4553 #ifdef CONFIG_GDBSTUB
4554     int use_gdbstub, gdbstub_port;
4555 #endif
4556     int i, cdrom_index;
4557     int snapshot, linux_boot;
4558     const char *initrd_filename;
4559     const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
4560     const char *kernel_filename, *kernel_cmdline;
4561     DisplayState *ds = &display_state;
4562     int cyls, heads, secs, translation;
4563     int start_emulation = 1;
4564     char net_clients[MAX_NET_CLIENTS][256];
4565     int nb_net_clients;
4566     int optind;
4567     const char *r, *optarg;
4568     CharDriverState *monitor_hd;
4569     char monitor_device[128];
4570     char serial_devices[MAX_SERIAL_PORTS][128];
4571     int serial_device_index;
4572     char parallel_devices[MAX_PARALLEL_PORTS][128];
4573     int parallel_device_index;
4574     const char *loadvm = NULL;
4575     QEMUMachine *machine;
4576     char usb_devices[MAX_VM_USB_PORTS][128];
4577     int usb_devices_index;
4578
4579     LIST_INIT (&vm_change_state_head);
4580 #if !defined(CONFIG_SOFTMMU)
4581     /* we never want that malloc() uses mmap() */
4582     mallopt(M_MMAP_THRESHOLD, 4096 * 1024);
4583 #endif
4584     register_machines();
4585     machine = first_machine;
4586     initrd_filename = NULL;
4587     for(i = 0; i < MAX_FD; i++)
4588         fd_filename[i] = NULL;
4589     for(i = 0; i < MAX_DISKS; i++)
4590         hd_filename[i] = NULL;
4591     ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
4592     vga_ram_size = VGA_RAM_SIZE;
4593     bios_size = BIOS_SIZE;
4594 #ifdef CONFIG_GDBSTUB
4595     use_gdbstub = 0;
4596     gdbstub_port = DEFAULT_GDBSTUB_PORT;
4597 #endif
4598     snapshot = 0;
4599     nographic = 0;
4600     kernel_filename = NULL;
4601     kernel_cmdline = "";
4602 #ifdef TARGET_PPC
4603     cdrom_index = 1;
4604 #else
4605     cdrom_index = 2;
4606 #endif
4607     cyls = heads = secs = 0;
4608     translation = BIOS_ATA_TRANSLATION_AUTO;
4609     pstrcpy(monitor_device, sizeof(monitor_device), "vc");
4610
4611     pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
4612     for(i = 1; i < MAX_SERIAL_PORTS; i++)
4613         serial_devices[i][0] = '\0';
4614     serial_device_index = 0;
4615
4616     pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
4617     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4618         parallel_devices[i][0] = '\0';
4619     parallel_device_index = 0;
4620
4621     usb_devices_index = 0;
4622
4623     nb_net_clients = 0;
4624
4625     nb_nics = 0;
4626     /* default mac address of the first network interface */
4627
4628     optind = 1;
4629     for(;;) {
4630         if (optind >= argc)
4631             break;
4632         r = argv[optind];
4633         if (r[0] != '-') {
4634             hd_filename[0] = argv[optind++];
4635         } else {
4636             const QEMUOption *popt;
4637
4638             optind++;
4639             popt = qemu_options;
4640             for(;;) {
4641                 if (!popt->name) {
4642                     fprintf(stderr, "%s: invalid option -- '%s'\n",
4643                             argv[0], r);
4644                     exit(1);
4645                 }
4646                 if (!strcmp(popt->name, r + 1))
4647                     break;
4648                 popt++;
4649             }
4650             if (popt->flags & HAS_ARG) {
4651                 if (optind >= argc) {
4652                     fprintf(stderr, "%s: option '%s' requires an argument\n",
4653                             argv[0], r);
4654                     exit(1);
4655                 }
4656                 optarg = argv[optind++];
4657             } else {
4658                 optarg = NULL;
4659             }
4660
4661             switch(popt->index) {
4662             case QEMU_OPTION_M:
4663                 machine = find_machine(optarg);
4664                 if (!machine) {
4665                     QEMUMachine *m;
4666                     printf("Supported machines are:\n");
4667                     for(m = first_machine; m != NULL; m = m->next) {
4668                         printf("%-10s %s%s\n",
4669                                m->name, m->desc,
4670                                m == first_machine ? " (default)" : "");
4671                     }
4672                     exit(1);
4673                 }
4674                 break;
4675             case QEMU_OPTION_initrd:
4676                 initrd_filename = optarg;
4677                 break;
4678             case QEMU_OPTION_hda:
4679             case QEMU_OPTION_hdb:
4680             case QEMU_OPTION_hdc:
4681             case QEMU_OPTION_hdd:
4682                 {
4683                     int hd_index;
4684                     hd_index = popt->index - QEMU_OPTION_hda;
4685                     hd_filename[hd_index] = optarg;
4686                     if (hd_index == cdrom_index)
4687                         cdrom_index = -1;
4688                 }
4689                 break;
4690             case QEMU_OPTION_snapshot:
4691                 snapshot = 1;
4692                 break;
4693             case QEMU_OPTION_hdachs:
4694                 {
4695                     const char *p;
4696                     p = optarg;
4697                     cyls = strtol(p, (char **)&p, 0);
4698                     if (cyls < 1 || cyls > 16383)
4699                         goto chs_fail;
4700                     if (*p != ',')
4701                         goto chs_fail;
4702                     p++;
4703                     heads = strtol(p, (char **)&p, 0);
4704                     if (heads < 1 || heads > 16)
4705                         goto chs_fail;
4706                     if (*p != ',')
4707                         goto chs_fail;
4708                     p++;
4709                     secs = strtol(p, (char **)&p, 0);
4710                     if (secs < 1 || secs > 63)
4711                         goto chs_fail;
4712                     if (*p == ',') {
4713                         p++;
4714                         if (!strcmp(p, "none"))
4715                             translation = BIOS_ATA_TRANSLATION_NONE;
4716                         else if (!strcmp(p, "lba"))
4717                             translation = BIOS_ATA_TRANSLATION_LBA;
4718                         else if (!strcmp(p, "auto"))
4719                             translation = BIOS_ATA_TRANSLATION_AUTO;
4720                         else
4721                             goto chs_fail;
4722                     } else if (*p != '\0') {
4723                     chs_fail:
4724                         fprintf(stderr, "qemu: invalid physical CHS format\n");
4725                         exit(1);
4726                     }
4727                 }
4728                 break;
4729             case QEMU_OPTION_nographic:
4730                 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
4731                 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
4732                 nographic = 1;
4733                 break;
4734             case QEMU_OPTION_kernel:
4735                 kernel_filename = optarg;
4736                 break;
4737             case QEMU_OPTION_append:
4738                 kernel_cmdline = optarg;
4739                 break;
4740             case QEMU_OPTION_cdrom:
4741                 if (cdrom_index >= 0) {
4742                     hd_filename[cdrom_index] = optarg;
4743                 }
4744                 break;
4745             case QEMU_OPTION_boot:
4746                 boot_device = optarg[0];
4747                 if (boot_device != 'a' &&
4748 #ifdef TARGET_SPARC
4749                     // Network boot
4750                     boot_device != 'n' &&
4751 #endif
4752                     boot_device != 'c' && boot_device != 'd') {
4753                     fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
4754                     exit(1);
4755                 }
4756                 break;
4757             case QEMU_OPTION_fda:
4758                 fd_filename[0] = optarg;
4759                 break;
4760             case QEMU_OPTION_fdb:
4761                 fd_filename[1] = optarg;
4762                 break;
4763             case QEMU_OPTION_no_code_copy:
4764                 code_copy_enabled = 0;
4765                 break;
4766             case QEMU_OPTION_net:
4767                 if (nb_net_clients >= MAX_NET_CLIENTS) {
4768                     fprintf(stderr, "qemu: too many network clients\n");
4769                     exit(1);
4770                 }
4771                 pstrcpy(net_clients[nb_net_clients],
4772                         sizeof(net_clients[0]),
4773                         optarg);
4774                 nb_net_clients++;
4775                 break;
4776 #ifdef CONFIG_SLIRP
4777             case QEMU_OPTION_tftp:
4778                 tftp_prefix = optarg;
4779                 break;
4780 #ifndef _WIN32
4781             case QEMU_OPTION_smb:
4782                 net_slirp_smb(optarg);
4783                 break;
4784 #endif
4785             case QEMU_OPTION_redir:
4786                 net_slirp_redir(optarg);
4787                 break;
4788 #endif
4789 #ifdef HAS_AUDIO
4790             case QEMU_OPTION_audio_help:
4791                 AUD_help ();
4792                 exit (0);
4793                 break;
4794             case QEMU_OPTION_soundhw:
4795                 select_soundhw (optarg);
4796                 break;
4797 #endif
4798             case QEMU_OPTION_h:
4799                 help();
4800                 break;
4801             case QEMU_OPTION_m:
4802                 ram_size = atoi(optarg) * 1024 * 1024;
4803                 if (ram_size <= 0)
4804                     help();
4805                 if (ram_size > PHYS_RAM_MAX_SIZE) {
4806                     fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
4807                             PHYS_RAM_MAX_SIZE / (1024 * 1024));
4808                     exit(1);
4809                 }
4810                 break;
4811             case QEMU_OPTION_d:
4812                 {
4813                     int mask;
4814                     CPULogItem *item;
4815
4816                     mask = cpu_str_to_log_mask(optarg);
4817                     if (!mask) {
4818                         printf("Log items (comma separated):\n");
4819                     for(item = cpu_log_items; item->mask != 0; item++) {
4820                         printf("%-10s %s\n", item->name, item->help);
4821                     }
4822                     exit(1);
4823                     }
4824                     cpu_set_log(mask);
4825                 }
4826                 break;
4827 #ifdef CONFIG_GDBSTUB
4828             case QEMU_OPTION_s:
4829                 use_gdbstub = 1;
4830                 break;
4831             case QEMU_OPTION_p:
4832                 gdbstub_port = atoi(optarg);
4833                 break;
4834 #endif
4835             case QEMU_OPTION_L:
4836                 bios_dir = optarg;
4837                 break;
4838             case QEMU_OPTION_S:
4839                 start_emulation = 0;
4840                 break;
4841             case QEMU_OPTION_k:
4842                 keyboard_layout = optarg;
4843                 break;
4844             case QEMU_OPTION_localtime:
4845                 rtc_utc = 0;
4846                 break;
4847             case QEMU_OPTION_cirrusvga:
4848                 cirrus_vga_enabled = 1;
4849                 break;
4850             case QEMU_OPTION_std_vga:
4851                 cirrus_vga_enabled = 0;
4852                 break;
4853             case QEMU_OPTION_g:
4854                 {
4855                     const char *p;
4856                     int w, h, depth;
4857                     p = optarg;
4858                     w = strtol(p, (char **)&p, 10);
4859                     if (w <= 0) {
4860                     graphic_error:
4861                         fprintf(stderr, "qemu: invalid resolution or depth\n");
4862                         exit(1);
4863                     }
4864                     if (*p != 'x')
4865                         goto graphic_error;
4866                     p++;
4867                     h = strtol(p, (char **)&p, 10);
4868                     if (h <= 0)
4869                         goto graphic_error;
4870                     if (*p == 'x') {
4871                         p++;
4872                         depth = strtol(p, (char **)&p, 10);
4873                         if (depth != 8 && depth != 15 && depth != 16 &&
4874                             depth != 24 && depth != 32)
4875                             goto graphic_error;
4876                     } else if (*p == '\0') {
4877                         depth = graphic_depth;
4878                     } else {
4879                         goto graphic_error;
4880                     }
4881
4882                     graphic_width = w;
4883                     graphic_height = h;
4884                     graphic_depth = depth;
4885                 }
4886                 break;
4887             case QEMU_OPTION_monitor:
4888                 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
4889                 break;
4890             case QEMU_OPTION_serial:
4891                 if (serial_device_index >= MAX_SERIAL_PORTS) {
4892                     fprintf(stderr, "qemu: too many serial ports\n");
4893                     exit(1);
4894                 }
4895                 pstrcpy(serial_devices[serial_device_index],
4896                         sizeof(serial_devices[0]), optarg);
4897                 serial_device_index++;
4898                 break;
4899             case QEMU_OPTION_parallel:
4900                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4901                     fprintf(stderr, "qemu: too many parallel ports\n");
4902                     exit(1);
4903                 }
4904                 pstrcpy(parallel_devices[parallel_device_index],
4905                         sizeof(parallel_devices[0]), optarg);
4906                 parallel_device_index++;
4907                 break;
4908             case QEMU_OPTION_loadvm:
4909                 loadvm = optarg;
4910                 break;
4911             case QEMU_OPTION_full_screen:
4912                 full_screen = 1;
4913                 break;
4914             case QEMU_OPTION_pidfile:
4915                 create_pidfile(optarg);
4916                 break;
4917 #ifdef TARGET_I386
4918             case QEMU_OPTION_win2k_hack:
4919                 win2k_install_hack = 1;
4920                 break;
4921 #endif
4922 #ifdef USE_KQEMU
4923             case QEMU_OPTION_no_kqemu:
4924                 kqemu_allowed = 0;
4925                 break;
4926             case QEMU_OPTION_kernel_kqemu:
4927                 kqemu_allowed = 2;
4928                 break;
4929 #endif
4930             case QEMU_OPTION_usb:
4931                 usb_enabled = 1;
4932                 break;
4933             case QEMU_OPTION_usbdevice:
4934                 usb_enabled = 1;
4935                 if (usb_devices_index >= MAX_VM_USB_PORTS) {
4936                     fprintf(stderr, "Too many USB devices\n");
4937                     exit(1);
4938                 }
4939                 pstrcpy(usb_devices[usb_devices_index],
4940                         sizeof(usb_devices[usb_devices_index]),
4941                         optarg);
4942                 usb_devices_index++;
4943                 break;
4944             case QEMU_OPTION_smp:
4945                 smp_cpus = atoi(optarg);
4946                 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
4947                     fprintf(stderr, "Invalid number of CPUs\n");
4948                     exit(1);
4949                 }
4950                 break;
4951             }
4952         }
4953     }
4954
4955 #ifdef USE_KQEMU
4956     if (smp_cpus > 1)
4957         kqemu_allowed = 0;
4958 #endif
4959     linux_boot = (kernel_filename != NULL);
4960
4961     if (!linux_boot &&
4962         hd_filename[0] == '\0' &&
4963         (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') &&
4964         fd_filename[0] == '\0')
4965         help();
4966
4967     /* boot to cd by default if no hard disk */
4968     if (hd_filename[0] == '\0' && boot_device == 'c') {
4969         if (fd_filename[0] != '\0')
4970             boot_device = 'a';
4971         else
4972             boot_device = 'd';
4973     }
4974
4975 #if !defined(CONFIG_SOFTMMU)
4976     /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
4977     {
4978         static uint8_t stdout_buf[4096];
4979         setvbuf(stdout, stdout_buf, _IOLBF, sizeof(stdout_buf));
4980     }
4981 #else
4982     setvbuf(stdout, NULL, _IOLBF, 0);
4983 #endif
4984
4985 #ifdef _WIN32
4986     socket_init();
4987 #endif
4988
4989     /* init network clients */
4990     if (nb_net_clients == 0) {
4991         /* if no clients, we use a default config */
4992         pstrcpy(net_clients[0], sizeof(net_clients[0]),
4993                 "nic");
4994         pstrcpy(net_clients[1], sizeof(net_clients[0]),
4995                 "user");
4996         nb_net_clients = 2;
4997     }
4998
4999     for(i = 0;i < nb_net_clients; i++) {
5000         if (net_client_init(net_clients[i]) < 0)
5001             exit(1);
5002     }
5003
5004     /* init the memory */
5005     phys_ram_size = ram_size + vga_ram_size + bios_size;
5006
5007 #ifdef CONFIG_SOFTMMU
5008     phys_ram_base = qemu_vmalloc(phys_ram_size);
5009     if (!phys_ram_base) {
5010         fprintf(stderr, "Could not allocate physical memory\n");
5011         exit(1);
5012     }
5013 #else
5014     /* as we must map the same page at several addresses, we must use
5015        a fd */
5016     {
5017         const char *tmpdir;
5018
5019         tmpdir = getenv("QEMU_TMPDIR");
5020         if (!tmpdir)
5021             tmpdir = "/tmp";
5022         snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/vlXXXXXX", tmpdir);
5023         if (mkstemp(phys_ram_file) < 0) {
5024             fprintf(stderr, "Could not create temporary memory file '%s'\n",
5025                     phys_ram_file);
5026             exit(1);
5027         }
5028         phys_ram_fd = open(phys_ram_file, O_CREAT | O_TRUNC | O_RDWR, 0600);
5029         if (phys_ram_fd < 0) {
5030             fprintf(stderr, "Could not open temporary memory file '%s'\n",
5031                     phys_ram_file);
5032             exit(1);
5033         }
5034         ftruncate(phys_ram_fd, phys_ram_size);
5035         unlink(phys_ram_file);
5036         phys_ram_base = mmap(get_mmap_addr(phys_ram_size),
5037                              phys_ram_size,
5038                              PROT_WRITE | PROT_READ, MAP_SHARED | MAP_FIXED,
5039                              phys_ram_fd, 0);
5040         if (phys_ram_base == MAP_FAILED) {
5041             fprintf(stderr, "Could not map physical memory\n");
5042             exit(1);
5043         }
5044     }
5045 #endif
5046
5047     /* we always create the cdrom drive, even if no disk is there */
5048     bdrv_init();
5049     if (cdrom_index >= 0) {
5050         bs_table[cdrom_index] = bdrv_new("cdrom");
5051         bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM);
5052     }
5053
5054     /* open the virtual block devices */
5055     for(i = 0; i < MAX_DISKS; i++) {
5056         if (hd_filename[i]) {
5057             if (!bs_table[i]) {
5058                 char buf[64];
5059                 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
5060                 bs_table[i] = bdrv_new(buf);
5061             }
5062             if (bdrv_open(bs_table[i], hd_filename[i], snapshot) < 0) {
5063                 fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
5064                         hd_filename[i]);
5065                 exit(1);
5066             }
5067             if (i == 0 && cyls != 0) {
5068                 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
5069                 bdrv_set_translation_hint(bs_table[i], translation);
5070             }
5071         }
5072     }
5073
5074     /* we always create at least one floppy disk */
5075     fd_table[0] = bdrv_new("fda");
5076     bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
5077
5078     for(i = 0; i < MAX_FD; i++) {
5079         if (fd_filename[i]) {
5080             if (!fd_table[i]) {
5081                 char buf[64];
5082                 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
5083                 fd_table[i] = bdrv_new(buf);
5084                 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
5085             }
5086             if (fd_filename[i] != '\0') {
5087                 if (bdrv_open(fd_table[i], fd_filename[i], snapshot) < 0) {
5088                     fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
5089                             fd_filename[i]);
5090                     exit(1);
5091                 }
5092             }
5093         }
5094     }
5095
5096     /* init USB devices */
5097     if (usb_enabled) {
5098         vm_usb_hub = usb_hub_init(vm_usb_ports, MAX_VM_USB_PORTS);
5099         for(i = 0; i < usb_devices_index; i++) {
5100             if (usb_device_add(usb_devices[i]) < 0) {
5101                 fprintf(stderr, "Warning: could not add USB device %s\n",
5102                         usb_devices[i]);
5103             }
5104         }
5105     }
5106
5107     register_savevm("timer", 0, 1, timer_save, timer_load, NULL);
5108     register_savevm("ram", 0, 1, ram_save, ram_load, NULL);
5109
5110     init_ioports();
5111     cpu_calibrate_ticks();
5112
5113     /* terminal init */
5114     if (nographic) {
5115         dumb_display_init(ds);
5116     } else {
5117 #if defined(CONFIG_SDL)
5118         sdl_display_init(ds, full_screen);
5119 #elif defined(CONFIG_COCOA)
5120         cocoa_display_init(ds, full_screen);
5121 #else
5122         dumb_display_init(ds);
5123 #endif
5124     }
5125
5126     vga_console = graphic_console_init(ds);
5127
5128     monitor_hd = qemu_chr_open(monitor_device);
5129     if (!monitor_hd) {
5130         fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5131         exit(1);
5132     }
5133     monitor_init(monitor_hd, !nographic);
5134
5135     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5136         if (serial_devices[i][0] != '\0') {
5137             serial_hds[i] = qemu_chr_open(serial_devices[i]);
5138             if (!serial_hds[i]) {
5139                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5140                         serial_devices[i]);
5141                 exit(1);
5142             }
5143             if (!strcmp(serial_devices[i], "vc"))
5144                 qemu_chr_printf(serial_hds[i], "serial%d console\n", i);
5145         }
5146     }
5147
5148     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5149         if (parallel_devices[i][0] != '\0') {
5150             parallel_hds[i] = qemu_chr_open(parallel_devices[i]);
5151             if (!parallel_hds[i]) {
5152                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5153                         parallel_devices[i]);
5154                 exit(1);
5155             }
5156             if (!strcmp(parallel_devices[i], "vc"))
5157                 qemu_chr_printf(parallel_hds[i], "parallel%d console\n", i);
5158         }
5159     }
5160
5161     /* setup cpu signal handlers for MMU / self modifying code handling */
5162 #if !defined(CONFIG_SOFTMMU)
5163
5164 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5165     {
5166         stack_t stk;
5167         signal_stack = memalign(16, SIGNAL_STACK_SIZE);
5168         stk.ss_sp = signal_stack;
5169         stk.ss_size = SIGNAL_STACK_SIZE;
5170         stk.ss_flags = 0;
5171
5172         if (sigaltstack(&stk, NULL) < 0) {
5173             perror("sigaltstack");
5174             exit(1);
5175         }
5176     }
5177 #endif
5178     {
5179         struct sigaction act;
5180
5181         sigfillset(&act.sa_mask);
5182         act.sa_flags = SA_SIGINFO;
5183 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5184         act.sa_flags |= SA_ONSTACK;
5185 #endif
5186         act.sa_sigaction = host_segv_handler;
5187         sigaction(SIGSEGV, &act, NULL);
5188         sigaction(SIGBUS, &act, NULL);
5189 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5190         sigaction(SIGFPE, &act, NULL);
5191 #endif
5192     }
5193 #endif
5194
5195 #ifndef _WIN32
5196     {
5197         struct sigaction act;
5198         sigfillset(&act.sa_mask);
5199         act.sa_flags = 0;
5200         act.sa_handler = SIG_IGN;
5201         sigaction(SIGPIPE, &act, NULL);
5202     }
5203 #endif
5204     init_timers();
5205
5206     machine->init(ram_size, vga_ram_size, boot_device,
5207                   ds, fd_filename, snapshot,
5208                   kernel_filename, kernel_cmdline, initrd_filename);
5209
5210     gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
5211     qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
5212
5213 #ifdef CONFIG_GDBSTUB
5214     if (use_gdbstub) {
5215         if (gdbserver_start(gdbstub_port) < 0) {
5216             fprintf(stderr, "Could not open gdbserver socket on port %d\n",
5217                     gdbstub_port);
5218             exit(1);
5219         } else {
5220             printf("Waiting gdb connection on port %d\n", gdbstub_port);
5221         }
5222     } else
5223 #endif
5224     if (loadvm)
5225         qemu_loadvm(loadvm);
5226
5227     {
5228         /* XXX: simplify init */
5229         read_passwords();
5230         if (start_emulation) {
5231             vm_start();
5232         }
5233     }
5234     main_loop();
5235     quit_timers();
5236     return 0;
5237 }