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 #ifdef _BSD
  44 #include <sys/stat.h>
  45 #ifndef __APPLE__
  46 #include <libutil.h>
  47 #endif
  48 #else
  49 #include <linux/if.h>
  50 #include <linux/if_tun.h>
  51 #include <pty.h>
  52 #include <malloc.h>
  53 #include <linux/rtc.h>
  54 #endif
  55 #endif
  56
  57 #if defined(CONFIG_SLIRP)
  58 #include "libslirp.h"
  59 #endif
  60
  61 #ifdef _WIN32
  62 #include <malloc.h>
  63 #include <sys/timeb.h>
  64 #include <windows.h>
  65 #define getopt_long_only getopt_long
  66 #define memalign(align, size) malloc(size)
  67 #endif
  68
  69 #ifdef CONFIG_SDL
  70 #ifdef __APPLE__
  71 #include <SDL/SDL.h>
  72 #endif
  73 #endif /* CONFIG_SDL */
  74
  75 #ifdef CONFIG_COCOA
  76 #undef main
  77 #define main qemu_main
  78 #endif /* CONFIG_COCOA */
  79
  80 #include "disas.h"
  81
  82 #include "exec-all.h"
  83
  84 //#define DO_TB_FLUSH
  85
  86 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
  87
  88 //#define DEBUG_UNUSED_IOPORT
  89 //#define DEBUG_IOPORT
  90
  91 #if !defined(CONFIG_SOFTMMU)
  92 #define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024)
  93 #else
  94 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
  95 #endif
  96
  97 #ifdef TARGET_PPC
  98 #define DEFAULT_RAM_SIZE 144
  99 #else
 100 #define DEFAULT_RAM_SIZE 128
 101 #endif
 102 /* in ms */
 103 #define GUI_REFRESH_INTERVAL 30
 104
 105 /* XXX: use a two level table to limit memory usage */
 106 #define MAX_IOPORTS 65536
 107
 108 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
 109 char phys_ram_file[1024];
 110 CPUState *global_env;
 111 CPUState *cpu_single_env;
 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 static char network_script[1024];
 125 int pit_min_timer_count = 0;
 126 int nb_nics;
 127 NetDriverState nd_table[MAX_NICS];
 128 QEMUTimer *gui_timer;
 129 int vm_running;
 130 int audio_enabled = 0;
 131 int sb16_enabled = 1;
 132 int adlib_enabled = 1;
 133 int gus_enabled = 1;
 134 int pci_enabled = 1;
 135 int prep_enabled = 0;
 136 int rtc_utc = 1;
 137 int cirrus_vga_enabled = 1;
 138 #ifdef TARGET_SPARC
 139 int graphic_width = 1024;
 140 int graphic_height = 768;
 141 #else
 142 int graphic_width = 800;
 143 int graphic_height = 600;
 144 #endif
 145 int graphic_depth = 15;
 146 int full_screen = 0;
 147 TextConsole *vga_console;
 148 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 149 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 150 #ifdef TARGET_I386
 151 int win2k_install_hack = 0;
 152 #endif
 153
 154 /***********************************************************/
 155 /* x86 ISA bus support */
 156
 157 target_phys_addr_t isa_mem_base = 0;
 158 PicState2 *isa_pic;
 159
 160 uint32_t default_ioport_readb(void *opaque, uint32_t address)
 161 {
 162 #ifdef DEBUG_UNUSED_IOPORT
 163     fprintf(stderr, "inb: port=0x%04x\n", address);
 164 #endif
 165     return 0xff;
 166 }
 167
 168 void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
 169 {
 170 #ifdef DEBUG_UNUSED_IOPORT
 171     fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
 172 #endif
 173 }
 174
 175 /* default is to make two byte accesses */
 176 uint32_t default_ioport_readw(void *opaque, uint32_t address)
 177 {
 178     uint32_t data;
 179     data = ioport_read_table[0][address](ioport_opaque[address], address);
 180     address = (address + 1) & (MAX_IOPORTS - 1);
 181     data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
 182     return data;
 183 }
 184
 185 void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
 186 {
 187     ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
 188     address = (address + 1) & (MAX_IOPORTS - 1);
 189     ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
 190 }
 191
 192 uint32_t default_ioport_readl(void *opaque, uint32_t address)
 193 {
 194 #ifdef DEBUG_UNUSED_IOPORT
 195     fprintf(stderr, "inl: port=0x%04x\n", address);
 196 #endif
 197     return 0xffffffff;
 198 }
 199
 200 void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
 201 {
 202 #ifdef DEBUG_UNUSED_IOPORT
 203     fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
 204 #endif
 205 }
 206
 207 void init_ioports(void)
 208 {
 209     int i;
 210
 211     for(i = 0; i < MAX_IOPORTS; i++) {
 212         ioport_read_table[0][i] = default_ioport_readb;
 213         ioport_write_table[0][i] = default_ioport_writeb;
 214         ioport_read_table[1][i] = default_ioport_readw;
 215         ioport_write_table[1][i] = default_ioport_writew;
 216         ioport_read_table[2][i] = default_ioport_readl;
 217         ioport_write_table[2][i] = default_ioport_writel;
 218     }
 219 }
 220
 221 /* size is the word size in byte */
 222 int register_ioport_read(int start, int length, int size,
 223                          IOPortReadFunc *func, void *opaque)
 224 {
 225     int i, bsize;
 226
 227     if (size == 1) {
 228         bsize = 0;
 229     } else if (size == 2) {
 230         bsize = 1;
 231     } else if (size == 4) {
 232         bsize = 2;
 233     } else {
 234         hw_error("register_ioport_read: invalid size");
 235         return -1;
 236     }
 237     for(i = start; i < start + length; i += size) {
 238         ioport_read_table[bsize][i] = func;
 239         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 240             hw_error("register_ioport_read: invalid opaque");
 241         ioport_opaque[i] = opaque;
 242     }
 243     return 0;
 244 }
 245
 246 /* size is the word size in byte */
 247 int register_ioport_write(int start, int length, int size,
 248                           IOPortWriteFunc *func, void *opaque)
 249 {
 250     int i, bsize;
 251
 252     if (size == 1) {
 253         bsize = 0;
 254     } else if (size == 2) {
 255         bsize = 1;
 256     } else if (size == 4) {
 257         bsize = 2;
 258     } else {
 259         hw_error("register_ioport_write: invalid size");
 260         return -1;
 261     }
 262     for(i = start; i < start + length; i += size) {
 263         ioport_write_table[bsize][i] = func;
 264         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 265             hw_error("register_ioport_read: invalid opaque");
 266         ioport_opaque[i] = opaque;
 267     }
 268     return 0;
 269 }
 270
 271 void isa_unassign_ioport(int start, int length)
 272 {
 273     int i;
 274
 275     for(i = start; i < start + length; i++) {
 276         ioport_read_table[0][i] = default_ioport_readb;
 277         ioport_read_table[1][i] = default_ioport_readw;
 278         ioport_read_table[2][i] = default_ioport_readl;
 279
 280         ioport_write_table[0][i] = default_ioport_writeb;
 281         ioport_write_table[1][i] = default_ioport_writew;
 282         ioport_write_table[2][i] = default_ioport_writel;
 283     }
 284 }
 285
 286 /***********************************************************/
 287
 288 void pstrcpy(char *buf, int buf_size, const char *str)
 289 {
 290     int c;
 291     char *q = buf;
 292
 293     if (buf_size <= 0)
 294         return;
 295
 296     for(;;) {
 297         c = *str++;
 298         if (c == 0 || q >= buf + buf_size - 1)
 299             break;
 300         *q++ = c;
 301     }
 302     *q = '\0';
 303 }
 304
 305 /* strcat and truncate. */
 306 char *pstrcat(char *buf, int buf_size, const char *s)
 307 {
 308     int len;
 309     len = strlen(buf);
 310     if (len < buf_size)
 311         pstrcpy(buf + len, buf_size - len, s);
 312     return buf;
 313 }
 314
 315 int strstart(const char *str, const char *val, const char **ptr)
 316 {
 317     const char *p, *q;
 318     p = str;
 319     q = val;
 320     while (*q != '\0') {
 321         if (*p != *q)
 322             return 0;
 323         p++;
 324         q++;
 325     }
 326     if (ptr)
 327         *ptr = p;
 328     return 1;
 329 }
 330
 331 /* return the size or -1 if error */
 332 int get_image_size(const char *filename)
 333 {
 334     int fd, size;
 335     fd = open(filename, O_RDONLY | O_BINARY);
 336     if (fd < 0)
 337         return -1;
 338     size = lseek(fd, 0, SEEK_END);
 339     close(fd);
 340     return size;
 341 }
 342
 343 /* return the size or -1 if error */
 344 int load_image(const char *filename, uint8_t *addr)
 345 {
 346     int fd, size;
 347     fd = open(filename, O_RDONLY | O_BINARY);
 348     if (fd < 0)
 349         return -1;
 350     size = lseek(fd, 0, SEEK_END);
 351     lseek(fd, 0, SEEK_SET);
 352     if (read(fd, addr, size) != size) {
 353         close(fd);
 354         return -1;
 355     }
 356     close(fd);
 357     return size;
 358 }
 359
 360 void cpu_outb(CPUState *env, int addr, int val)
 361 {
 362 #ifdef DEBUG_IOPORT
 363     if (loglevel & CPU_LOG_IOPORT)
 364         fprintf(logfile, "outb: %04x %02x\n", addr, val);
 365 #endif
 366     ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
 367 }
 368
 369 void cpu_outw(CPUState *env, int addr, int val)
 370 {
 371 #ifdef DEBUG_IOPORT
 372     if (loglevel & CPU_LOG_IOPORT)
 373         fprintf(logfile, "outw: %04x %04x\n", addr, val);
 374 #endif
 375     ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
 376 }
 377
 378 void cpu_outl(CPUState *env, int addr, int val)
 379 {
 380 #ifdef DEBUG_IOPORT
 381     if (loglevel & CPU_LOG_IOPORT)
 382         fprintf(logfile, "outl: %04x %08x\n", addr, val);
 383 #endif
 384     ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
 385 }
 386
 387 int cpu_inb(CPUState *env, int addr)
 388 {
 389     int val;
 390     val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
 391 #ifdef DEBUG_IOPORT
 392     if (loglevel & CPU_LOG_IOPORT)
 393         fprintf(logfile, "inb : %04x %02x\n", addr, val);
 394 #endif
 395     return val;
 396 }
 397
 398 int cpu_inw(CPUState *env, int addr)
 399 {
 400     int val;
 401     val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
 402 #ifdef DEBUG_IOPORT
 403     if (loglevel & CPU_LOG_IOPORT)
 404         fprintf(logfile, "inw : %04x %04x\n", addr, val);
 405 #endif
 406     return val;
 407 }
 408
 409 int cpu_inl(CPUState *env, int addr)
 410 {
 411     int val;
 412     val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
 413 #ifdef DEBUG_IOPORT
 414     if (loglevel & CPU_LOG_IOPORT)
 415         fprintf(logfile, "inl : %04x %08x\n", addr, val);
 416 #endif
 417     return val;
 418 }
 419
 420 /***********************************************************/
 421 void hw_error(const char *fmt, ...)
 422 {
 423     va_list ap;
 424
 425     va_start(ap, fmt);
 426     fprintf(stderr, "qemu: hardware error: ");
 427     vfprintf(stderr, fmt, ap);
 428     fprintf(stderr, "\n");
 429 #ifdef TARGET_I386
 430     cpu_dump_state(global_env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
 431 #else
 432     cpu_dump_state(global_env, stderr, fprintf, 0);
 433 #endif
 434     va_end(ap);
 435     abort();
 436 }
 437
 438 /***********************************************************/
 439 /* keyboard/mouse */
 440
 441 static QEMUPutKBDEvent *qemu_put_kbd_event;
 442 static void *qemu_put_kbd_event_opaque;
 443 static QEMUPutMouseEvent *qemu_put_mouse_event;
 444 static void *qemu_put_mouse_event_opaque;
 445
 446 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
 447 {
 448     qemu_put_kbd_event_opaque = opaque;
 449     qemu_put_kbd_event = func;
 450 }
 451
 452 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque)
 453 {
 454     qemu_put_mouse_event_opaque = opaque;
 455     qemu_put_mouse_event = func;
 456 }
 457
 458 void kbd_put_keycode(int keycode)
 459 {
 460     if (qemu_put_kbd_event) {
 461         qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
 462     }
 463 }
 464
 465 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
 466 {
 467     if (qemu_put_mouse_event) {
 468         qemu_put_mouse_event(qemu_put_mouse_event_opaque,
 469                              dx, dy, dz, buttons_state);
 470     }
 471 }
 472
 473 /***********************************************************/
 474 /* timers */
 475
 476 #if defined(__powerpc__)
 477
 478 static inline uint32_t get_tbl(void)
 479 {
 480     uint32_t tbl;
 481     asm volatile("mftb %0" : "=r" (tbl));
 482     return tbl;
 483 }
 484
 485 static inline uint32_t get_tbu(void)
 486 {
 487         uint32_t tbl;
 488         asm volatile("mftbu %0" : "=r" (tbl));
 489         return tbl;
 490 }
 491
 492 int64_t cpu_get_real_ticks(void)
 493 {
 494     uint32_t l, h, h1;
 495     /* NOTE: we test if wrapping has occurred */
 496     do {
 497         h = get_tbu();
 498         l = get_tbl();
 499         h1 = get_tbu();
 500     } while (h != h1);
 501     return ((int64_t)h << 32) | l;
 502 }
 503
 504 #elif defined(__i386__)
 505
 506 int64_t cpu_get_real_ticks(void)
 507 {
 508     int64_t val;
 509     asm volatile ("rdtsc" : "=A" (val));
 510     return val;
 511 }
 512
 513 #elif defined(__x86_64__)
 514
 515 int64_t cpu_get_real_ticks(void)
 516 {
 517     uint32_t low,high;
 518     int64_t val;
 519     asm volatile("rdtsc" : "=a" (low), "=d" (high));
 520     val = high;
 521     val <<= 32;
 522     val |= low;
 523     return val;
 524 }
 525
 526 #elif defined(__ia64)
 527
 528 int64_t cpu_get_real_ticks(void)
 529 {
 530         int64_t val;
 531         asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
 532         return val;
 533 }
 534
 535 #elif defined(__s390__)
 536
 537 int64_t cpu_get_real_ticks(void)
 538 {
 539     int64_t val;
 540     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
 541     return val;
 542 }
 543
 544 #else
 545 #error unsupported CPU
 546 #endif
 547
 548 static int64_t cpu_ticks_offset;
 549 static int cpu_ticks_enabled;
 550
 551 static inline int64_t cpu_get_ticks(void)
 552 {
 553     if (!cpu_ticks_enabled) {
 554         return cpu_ticks_offset;
 555     } else {
 556         return cpu_get_real_ticks() + cpu_ticks_offset;
 557     }
 558 }
 559
 560 /* enable cpu_get_ticks() */
 561 void cpu_enable_ticks(void)
 562 {
 563     if (!cpu_ticks_enabled) {
 564         cpu_ticks_offset -= cpu_get_real_ticks();
 565         cpu_ticks_enabled = 1;
 566     }
 567 }
 568
 569 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 570    cpu_get_ticks() after that.  */
 571 void cpu_disable_ticks(void)
 572 {
 573     if (cpu_ticks_enabled) {
 574         cpu_ticks_offset = cpu_get_ticks();
 575         cpu_ticks_enabled = 0;
 576     }
 577 }
 578
 579 static int64_t get_clock(void)
 580 {
 581 #ifdef _WIN32
 582     struct _timeb tb;
 583     _ftime(&tb);
 584     return ((int64_t)tb.time * 1000 + (int64_t)tb.millitm) * 1000;
 585 #else
 586     struct timeval tv;
 587     gettimeofday(&tv, NULL);
 588     return tv.tv_sec * 1000000LL + tv.tv_usec;
 589 #endif
 590 }
 591
 592 void cpu_calibrate_ticks(void)
 593 {
 594     int64_t usec, ticks;
 595
 596     usec = get_clock();
 597     ticks = cpu_get_real_ticks();
 598 #ifdef _WIN32
 599     Sleep(50);
 600 #else
 601     usleep(50 * 1000);
 602 #endif
 603     usec = get_clock() - usec;
 604     ticks = cpu_get_real_ticks() - ticks;
 605     ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec;
 606 }
 607
 608 /* compute with 96 bit intermediate result: (a*b)/c */
 609 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 610 {
 611     union {
 612         uint64_t ll;
 613         struct {
 614 #ifdef WORDS_BIGENDIAN
 615             uint32_t high, low;
 616 #else
 617             uint32_t low, high;
 618 #endif
 619         } l;
 620     } u, res;
 621     uint64_t rl, rh;
 622
 623     u.ll = a;
 624     rl = (uint64_t)u.l.low * (uint64_t)b;
 625     rh = (uint64_t)u.l.high * (uint64_t)b;
 626     rh += (rl >> 32);
 627     res.l.high = rh / c;
 628     res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
 629     return res.ll;
 630 }
 631
 632 #define QEMU_TIMER_REALTIME 0
 633 #define QEMU_TIMER_VIRTUAL  1
 634
 635 struct QEMUClock {
 636     int type;
 637     /* XXX: add frequency */
 638 };
 639
 640 struct QEMUTimer {
 641     QEMUClock *clock;
 642     int64_t expire_time;
 643     QEMUTimerCB *cb;
 644     void *opaque;
 645     struct QEMUTimer *next;
 646 };
 647
 648 QEMUClock *rt_clock;
 649 QEMUClock *vm_clock;
 650
 651 static QEMUTimer *active_timers[2];
 652 #ifdef _WIN32
 653 static MMRESULT timerID;
 654 #else
 655 /* frequency of the times() clock tick */
 656 static int timer_freq;
 657 #endif
 658
 659 QEMUClock *qemu_new_clock(int type)
 660 {
 661     QEMUClock *clock;
 662     clock = qemu_mallocz(sizeof(QEMUClock));
 663     if (!clock)
 664         return NULL;
 665     clock->type = type;
 666     return clock;
 667 }
 668
 669 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
 670 {
 671     QEMUTimer *ts;
 672
 673     ts = qemu_mallocz(sizeof(QEMUTimer));
 674     ts->clock = clock;
 675     ts->cb = cb;
 676     ts->opaque = opaque;
 677     return ts;
 678 }
 679
 680 void qemu_free_timer(QEMUTimer *ts)
 681 {
 682     qemu_free(ts);
 683 }
 684
 685 /* stop a timer, but do not dealloc it */
 686 void qemu_del_timer(QEMUTimer *ts)
 687 {
 688     QEMUTimer **pt, *t;
 689
 690     /* NOTE: this code must be signal safe because
 691        qemu_timer_expired() can be called from a signal. */
 692     pt = &active_timers[ts->clock->type];
 693     for(;;) {
 694         t = *pt;
 695         if (!t)
 696             break;
 697         if (t == ts) {
 698             *pt = t->next;
 699             break;
 700         }
 701         pt = &t->next;
 702     }
 703 }
 704
 705 /* modify the current timer so that it will be fired when current_time
 706    >= expire_time. The corresponding callback will be called. */
 707 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
 708 {
 709     QEMUTimer **pt, *t;
 710
 711     qemu_del_timer(ts);
 712
 713     /* add the timer in the sorted list */
 714     /* NOTE: this code must be signal safe because
 715        qemu_timer_expired() can be called from a signal. */
 716     pt = &active_timers[ts->clock->type];
 717     for(;;) {
 718         t = *pt;
 719         if (!t)
 720             break;
 721         if (t->expire_time > expire_time)
 722             break;
 723         pt = &t->next;
 724     }
 725     ts->expire_time = expire_time;
 726     ts->next = *pt;
 727     *pt = ts;
 728 }
 729
 730 int qemu_timer_pending(QEMUTimer *ts)
 731 {
 732     QEMUTimer *t;
 733     for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
 734         if (t == ts)
 735             return 1;
 736     }
 737     return 0;
 738 }
 739
 740 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
 741 {
 742     if (!timer_head)
 743         return 0;
 744     return (timer_head->expire_time <= current_time);
 745 }
 746
 747 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
 748 {
 749     QEMUTimer *ts;
 750
 751     for(;;) {
 752         ts = *ptimer_head;
 753         if (!ts || ts->expire_time > current_time)
 754             break;
 755         /* remove timer from the list before calling the callback */
 756         *ptimer_head = ts->next;
 757         ts->next = NULL;
 758
 759         /* run the callback (the timer list can be modified) */
 760         ts->cb(ts->opaque);
 761     }
 762 }
 763
 764 int64_t qemu_get_clock(QEMUClock *clock)
 765 {
 766     switch(clock->type) {
 767     case QEMU_TIMER_REALTIME:
 768 #ifdef _WIN32
 769         return GetTickCount();
 770 #else
 771         {
 772             struct tms tp;
 773
 774             /* Note that using gettimeofday() is not a good solution
 775                for timers because its value change when the date is
 776                modified. */
 777             if (timer_freq == 100) {
 778                 return times(&tp) * 10;
 779             } else {
 780                 return ((int64_t)times(&tp) * 1000) / timer_freq;
 781             }
 782         }
 783 #endif
 784     default:
 785     case QEMU_TIMER_VIRTUAL:
 786         return cpu_get_ticks();
 787     }
 788 }
 789
 790 /* save a timer */
 791 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
 792 {
 793     uint64_t expire_time;
 794
 795     if (qemu_timer_pending(ts)) {
 796         expire_time = ts->expire_time;
 797     } else {
 798         expire_time = -1;
 799     }
 800     qemu_put_be64(f, expire_time);
 801 }
 802
 803 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
 804 {
 805     uint64_t expire_time;
 806
 807     expire_time = qemu_get_be64(f);
 808     if (expire_time != -1) {
 809         qemu_mod_timer(ts, expire_time);
 810     } else {
 811         qemu_del_timer(ts);
 812     }
 813 }
 814
 815 static void timer_save(QEMUFile *f, void *opaque)
 816 {
 817     if (cpu_ticks_enabled) {
 818         hw_error("cannot save state if virtual timers are running");
 819     }
 820     qemu_put_be64s(f, &cpu_ticks_offset);
 821     qemu_put_be64s(f, &ticks_per_sec);
 822 }
 823
 824 static int timer_load(QEMUFile *f, void *opaque, int version_id)
 825 {
 826     if (version_id != 1)
 827         return -EINVAL;
 828     if (cpu_ticks_enabled) {
 829         return -EINVAL;
 830     }
 831     qemu_get_be64s(f, &cpu_ticks_offset);
 832     qemu_get_be64s(f, &ticks_per_sec);
 833     return 0;
 834 }
 835
 836 #ifdef _WIN32
 837 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
 838                                  DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
 839 #else
 840 static void host_alarm_handler(int host_signum)
 841 #endif
 842 {
 843 #if 0
 844 #define DISP_FREQ 1000
 845     {
 846         static int64_t delta_min = INT64_MAX;
 847         static int64_t delta_max, delta_cum, last_clock, delta, ti;
 848         static int count;
 849         ti = qemu_get_clock(vm_clock);
 850         if (last_clock != 0) {
 851             delta = ti - last_clock;
 852             if (delta < delta_min)
 853                 delta_min = delta;
 854             if (delta > delta_max)
 855                 delta_max = delta;
 856             delta_cum += delta;
 857             if (++count == DISP_FREQ) {
 858                 printf("timer: min=%lld us max=%lld us avg=%lld us avg_freq=%0.3f Hz\n",
 859                        muldiv64(delta_min, 1000000, ticks_per_sec),
 860                        muldiv64(delta_max, 1000000, ticks_per_sec),
 861                        muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
 862                        (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
 863                 count = 0;
 864                 delta_min = INT64_MAX;
 865                 delta_max = 0;
 866                 delta_cum = 0;
 867             }
 868         }
 869         last_clock = ti;
 870     }
 871 #endif
 872     if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
 873                            qemu_get_clock(vm_clock)) ||
 874         qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
 875                            qemu_get_clock(rt_clock))) {
 876         /* stop the cpu because a timer occured */
 877         cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
 878 #ifdef USE_KQEMU
 879         if (global_env->kqemu_enabled) {
 880             kqemu_cpu_interrupt(global_env);
 881         }
 882 #endif
 883     }
 884 }
 885
 886 #ifndef _WIN32
 887
 888 #if defined(__linux__)
 889
 890 #define RTC_FREQ 1024
 891
 892 static int rtc_fd;
 893
 894 static int start_rtc_timer(void)
 895 {
 896     rtc_fd = open("/dev/rtc", O_RDONLY);
 897     if (rtc_fd < 0)
 898         return -1;
 899     if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
 900         fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
 901                 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
 902                 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
 903         goto fail;
 904     }
 905     if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
 906     fail:
 907         close(rtc_fd);
 908         return -1;
 909     }
 910     pit_min_timer_count = PIT_FREQ / RTC_FREQ;
 911     return 0;
 912 }
 913
 914 #else
 915
 916 static int start_rtc_timer(void)
 917 {
 918     return -1;
 919 }
 920
 921 #endif /* !defined(__linux__) */
 922
 923 #endif /* !defined(_WIN32) */
 924
 925 static void init_timers(void)
 926 {
 927     rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
 928     vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
 929
 930 #ifdef _WIN32
 931     {
 932         int count=0;
 933         timerID = timeSetEvent(10,    // interval (ms)
 934                                0,     // resolution
 935                                host_alarm_handler, // function
 936                                (DWORD)&count,  // user parameter
 937                                TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
 938         if( !timerID ) {
 939             perror("failed timer alarm");
 940             exit(1);
 941         }
 942     }
 943     pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
 944 #else
 945     {
 946         struct sigaction act;
 947         struct itimerval itv;
 948
 949         /* get times() syscall frequency */
 950         timer_freq = sysconf(_SC_CLK_TCK);
 951
 952         /* timer signal */
 953         sigfillset(&act.sa_mask);
 954        act.sa_flags = 0;
 955 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
 956         act.sa_flags |= SA_ONSTACK;
 957 #endif
 958         act.sa_handler = host_alarm_handler;
 959         sigaction(SIGALRM, &act, NULL);
 960
 961         itv.it_interval.tv_sec = 0;
 962         itv.it_interval.tv_usec = 999; /* for i386 kernel 2.6 to get 1 ms */
 963         itv.it_value.tv_sec = 0;
 964         itv.it_value.tv_usec = 10 * 1000;
 965         setitimer(ITIMER_REAL, &itv, NULL);
 966         /* we probe the tick duration of the kernel to inform the user if
 967            the emulated kernel requested a too high timer frequency */
 968         getitimer(ITIMER_REAL, &itv);
 969
 970 #if defined(__linux__)
 971         if (itv.it_interval.tv_usec > 1000) {
 972             /* try to use /dev/rtc to have a faster timer */
 973             if (start_rtc_timer() < 0)
 974                 goto use_itimer;
 975             /* disable itimer */
 976             itv.it_interval.tv_sec = 0;
 977             itv.it_interval.tv_usec = 0;
 978             itv.it_value.tv_sec = 0;
 979             itv.it_value.tv_usec = 0;
 980             setitimer(ITIMER_REAL, &itv, NULL);
 981
 982             /* use the RTC */
 983             sigaction(SIGIO, &act, NULL);
 984             fcntl(rtc_fd, F_SETFL, O_ASYNC);
 985             fcntl(rtc_fd, F_SETOWN, getpid());
 986         } else
 987 #endif /* defined(__linux__) */
 988         {
 989         use_itimer:
 990             pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec *
 991                                    PIT_FREQ) / 1000000;
 992         }
 993     }
 994 #endif
 995 }
 996
 997 void quit_timers(void)
 998 {
 999 #ifdef _WIN32
1000     timeKillEvent(timerID);
1001 #endif
1002 }
1003
1004 /***********************************************************/
1005 /* character device */
1006
1007 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1008 {
1009     return s->chr_write(s, buf, len);
1010 }
1011
1012 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1013 {
1014     char buf[4096];
1015     va_list ap;
1016     va_start(ap, fmt);
1017     vsnprintf(buf, sizeof(buf), fmt, ap);
1018     qemu_chr_write(s, buf, strlen(buf));
1019     va_end(ap);
1020 }
1021
1022 void qemu_chr_send_event(CharDriverState *s, int event)
1023 {
1024     if (s->chr_send_event)
1025         s->chr_send_event(s, event);
1026 }
1027
1028 void qemu_chr_add_read_handler(CharDriverState *s,
1029                                IOCanRWHandler *fd_can_read,
1030                                IOReadHandler *fd_read, void *opaque)
1031 {
1032     s->chr_add_read_handler(s, fd_can_read, fd_read, opaque);
1033 }
1034
1035 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event)
1036 {
1037     s->chr_event = chr_event;
1038 }
1039
1040 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1041 {
1042     return len;
1043 }
1044
1045 static void null_chr_add_read_handler(CharDriverState *chr,
1046                                     IOCanRWHandler *fd_can_read,
1047                                     IOReadHandler *fd_read, void *opaque)
1048 {
1049 }
1050
1051 CharDriverState *qemu_chr_open_null(void)
1052 {
1053     CharDriverState *chr;
1054
1055     chr = qemu_mallocz(sizeof(CharDriverState));
1056     if (!chr)
1057         return NULL;
1058     chr->chr_write = null_chr_write;
1059     chr->chr_add_read_handler = null_chr_add_read_handler;
1060     return chr;
1061 }
1062
1063 #ifndef _WIN32
1064
1065 typedef struct {
1066     int fd_in, fd_out;
1067     /* for nographic stdio only */
1068     IOCanRWHandler *fd_can_read;
1069     IOReadHandler *fd_read;
1070     void *fd_opaque;
1071 } FDCharDriver;
1072
1073 #define STDIO_MAX_CLIENTS 2
1074
1075 static int stdio_nb_clients;
1076 static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1077
1078 static int unix_write(int fd, const uint8_t *buf, int len1)
1079 {
1080     int ret, len;
1081
1082     len = len1;
1083     while (len > 0) {
1084         ret = write(fd, buf, len);
1085         if (ret < 0) {
1086             if (errno != EINTR && errno != EAGAIN)
1087                 return -1;
1088         } else if (ret == 0) {
1089             break;
1090         } else {
1091             buf += ret;
1092             len -= ret;
1093         }
1094     }
1095     return len1 - len;
1096 }
1097
1098 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1099 {
1100     FDCharDriver *s = chr->opaque;
1101     return unix_write(s->fd_out, buf, len);
1102 }
1103
1104 static void fd_chr_add_read_handler(CharDriverState *chr,
1105                                     IOCanRWHandler *fd_can_read,
1106                                     IOReadHandler *fd_read, void *opaque)
1107 {
1108     FDCharDriver *s = chr->opaque;
1109
1110     if (nographic && s->fd_in == 0) {
1111         s->fd_can_read = fd_can_read;
1112         s->fd_read = fd_read;
1113         s->fd_opaque = opaque;
1114     } else {
1115         qemu_add_fd_read_handler(s->fd_in, fd_can_read, fd_read, opaque);
1116     }
1117 }
1118
1119 /* open a character device to a unix fd */
1120 CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1121 {
1122     CharDriverState *chr;
1123     FDCharDriver *s;
1124
1125     chr = qemu_mallocz(sizeof(CharDriverState));
1126     if (!chr)
1127         return NULL;
1128     s = qemu_mallocz(sizeof(FDCharDriver));
1129     if (!s) {
1130         free(chr);
1131         return NULL;
1132     }
1133     s->fd_in = fd_in;
1134     s->fd_out = fd_out;
1135     chr->opaque = s;
1136     chr->chr_write = fd_chr_write;
1137     chr->chr_add_read_handler = fd_chr_add_read_handler;
1138     return chr;
1139 }
1140
1141 /* for STDIO, we handle the case where several clients use it
1142    (nographic mode) */
1143
1144 #define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */
1145
1146 #define TERM_FIFO_MAX_SIZE 1
1147
1148 static int term_got_escape, client_index;
1149 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
1150 int term_fifo_size;
1151
1152 void term_print_help(void)
1153 {
1154     printf("\n"
1155            "C-a h    print this help\n"
1156            "C-a x    exit emulator\n"
1157            "C-a s    save disk data back to file (if -snapshot)\n"
1158            "C-a b    send break (magic sysrq)\n"
1159            "C-a c    switch between console and monitor\n"
1160            "C-a C-a  send C-a\n"
1161            );
1162 }
1163
1164 /* called when a char is received */
1165 static void stdio_received_byte(int ch)
1166 {
1167     if (term_got_escape) {
1168         term_got_escape = 0;
1169         switch(ch) {
1170         case 'h':
1171             term_print_help();
1172             break;
1173         case 'x':
1174             exit(0);
1175             break;
1176         case 's':
1177             {
1178                 int i;
1179                 for (i = 0; i < MAX_DISKS; i++) {
1180                     if (bs_table[i])
1181                         bdrv_commit(bs_table[i]);
1182                 }
1183             }
1184             break;
1185         case 'b':
1186             if (client_index < stdio_nb_clients) {
1187                 CharDriverState *chr;
1188                 FDCharDriver *s;
1189
1190                 chr = stdio_clients[client_index];
1191                 s = chr->opaque;
1192                 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
1193             }
1194             break;
1195         case 'c':
1196             client_index++;
1197             if (client_index >= stdio_nb_clients)
1198                 client_index = 0;
1199             if (client_index == 0) {
1200                 /* send a new line in the monitor to get the prompt */
1201                 ch = '\r';
1202                 goto send_char;
1203             }
1204             break;
1205         case TERM_ESCAPE:
1206             goto send_char;
1207         }
1208     } else if (ch == TERM_ESCAPE) {
1209         term_got_escape = 1;
1210     } else {
1211     send_char:
1212         if (client_index < stdio_nb_clients) {
1213             uint8_t buf[1];
1214             CharDriverState *chr;
1215             FDCharDriver *s;
1216
1217             chr = stdio_clients[client_index];
1218             s = chr->opaque;
1219             if (s->fd_can_read(s->fd_opaque) > 0) {
1220                 buf[0] = ch;
1221                 s->fd_read(s->fd_opaque, buf, 1);
1222             } else if (term_fifo_size == 0) {
1223                 term_fifo[term_fifo_size++] = ch;
1224             }
1225         }
1226     }
1227 }
1228
1229 static int stdio_can_read(void *opaque)
1230 {
1231     CharDriverState *chr;
1232     FDCharDriver *s;
1233
1234     if (client_index < stdio_nb_clients) {
1235         chr = stdio_clients[client_index];
1236         s = chr->opaque;
1237         /* try to flush the queue if needed */
1238         if (term_fifo_size != 0 && s->fd_can_read(s->fd_opaque) > 0) {
1239             s->fd_read(s->fd_opaque, term_fifo, 1);
1240             term_fifo_size = 0;
1241         }
1242         /* see if we can absorb more chars */
1243         if (term_fifo_size == 0)
1244             return 1;
1245         else
1246             return 0;
1247     } else {
1248         return 1;
1249     }
1250 }
1251
1252 static void stdio_read(void *opaque, const uint8_t *buf, int size)
1253 {
1254     int i;
1255     for(i = 0; i < size; i++)
1256         stdio_received_byte(buf[i]);
1257 }
1258
1259 /* init terminal so that we can grab keys */
1260 static struct termios oldtty;
1261 static int old_fd0_flags;
1262
1263 static void term_exit(void)
1264 {
1265     tcsetattr (0, TCSANOW, &oldtty);
1266     fcntl(0, F_SETFL, old_fd0_flags);
1267 }
1268
1269 static void term_init(void)
1270 {
1271     struct termios tty;
1272
1273     tcgetattr (0, &tty);
1274     oldtty = tty;
1275     old_fd0_flags = fcntl(0, F_GETFL);
1276
1277     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1278                           |INLCR|IGNCR|ICRNL|IXON);
1279     tty.c_oflag |= OPOST;
1280     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1281     /* if graphical mode, we allow Ctrl-C handling */
1282     if (nographic)
1283         tty.c_lflag &= ~ISIG;
1284     tty.c_cflag &= ~(CSIZE|PARENB);
1285     tty.c_cflag |= CS8;
1286     tty.c_cc[VMIN] = 1;
1287     tty.c_cc[VTIME] = 0;
1288
1289     tcsetattr (0, TCSANOW, &tty);
1290
1291     atexit(term_exit);
1292
1293     fcntl(0, F_SETFL, O_NONBLOCK);
1294 }
1295
1296 CharDriverState *qemu_chr_open_stdio(void)
1297 {
1298     CharDriverState *chr;
1299
1300     if (nographic) {
1301         if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
1302             return NULL;
1303         chr = qemu_chr_open_fd(0, 1);
1304         if (stdio_nb_clients == 0)
1305             qemu_add_fd_read_handler(0, stdio_can_read, stdio_read, NULL);
1306         client_index = stdio_nb_clients;
1307     } else {
1308         if (stdio_nb_clients != 0)
1309             return NULL;
1310         chr = qemu_chr_open_fd(0, 1);
1311     }
1312     stdio_clients[stdio_nb_clients++] = chr;
1313     if (stdio_nb_clients == 1) {
1314         /* set the terminal in raw mode */
1315         term_init();
1316     }
1317     return chr;
1318 }
1319
1320 #if defined(__linux__)
1321 CharDriverState *qemu_chr_open_pty(void)
1322 {
1323     char slave_name[1024];
1324     int master_fd, slave_fd;
1325
1326     /* Not satisfying */
1327     if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
1328         return NULL;
1329     }
1330     fprintf(stderr, "char device redirected to %s\n", slave_name);
1331     return qemu_chr_open_fd(master_fd, master_fd);
1332 }
1333 #else
1334 CharDriverState *qemu_chr_open_pty(void)
1335 {
1336     return NULL;
1337 }
1338 #endif
1339
1340 #endif /* !defined(_WIN32) */
1341
1342 CharDriverState *qemu_chr_open(const char *filename)
1343 {
1344     if (!strcmp(filename, "vc")) {
1345         return text_console_init(&display_state);
1346     } else if (!strcmp(filename, "null")) {
1347         return qemu_chr_open_null();
1348     } else
1349 #ifndef _WIN32
1350     if (!strcmp(filename, "pty")) {
1351         return qemu_chr_open_pty();
1352     } else if (!strcmp(filename, "stdio")) {
1353         return qemu_chr_open_stdio();
1354     } else
1355 #endif
1356     {
1357         return NULL;
1358     }
1359 }
1360
1361 /***********************************************************/
1362 /* Linux network device redirectors */
1363
1364 void hex_dump(FILE *f, const uint8_t *buf, int size)
1365 {
1366     int len, i, j, c;
1367
1368     for(i=0;i<size;i+=16) {
1369         len = size - i;
1370         if (len > 16)
1371             len = 16;
1372         fprintf(f, "%08x ", i);
1373         for(j=0;j<16;j++) {
1374             if (j < len)
1375                 fprintf(f, " %02x", buf[i+j]);
1376             else
1377                 fprintf(f, "   ");
1378         }
1379         fprintf(f, " ");
1380         for(j=0;j<len;j++) {
1381             c = buf[i+j];
1382             if (c < ' ' || c > '~')
1383                 c = '.';
1384             fprintf(f, "%c", c);
1385         }
1386         fprintf(f, "\n");
1387     }
1388 }
1389
1390 void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1391 {
1392     nd->send_packet(nd, buf, size);
1393 }
1394
1395 void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read,
1396                           IOReadHandler *fd_read, void *opaque)
1397 {
1398     nd->add_read_packet(nd, fd_can_read, fd_read, opaque);
1399 }
1400
1401 /* dummy network adapter */
1402
1403 static void dummy_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1404 {
1405 }
1406
1407 static void dummy_add_read_packet(NetDriverState *nd,
1408                                   IOCanRWHandler *fd_can_read,
1409                                   IOReadHandler *fd_read, void *opaque)
1410 {
1411 }
1412
1413 static int net_dummy_init(NetDriverState *nd)
1414 {
1415     nd->send_packet = dummy_send_packet;
1416     nd->add_read_packet = dummy_add_read_packet;
1417     pstrcpy(nd->ifname, sizeof(nd->ifname), "dummy");
1418     return 0;
1419 }
1420
1421 #if defined(CONFIG_SLIRP)
1422
1423 /* slirp network adapter */
1424
1425 static void *slirp_fd_opaque;
1426 static IOCanRWHandler *slirp_fd_can_read;
1427 static IOReadHandler *slirp_fd_read;
1428 static int slirp_inited;
1429
1430 int slirp_can_output(void)
1431 {
1432     return slirp_fd_can_read(slirp_fd_opaque);
1433 }
1434
1435 void slirp_output(const uint8_t *pkt, int pkt_len)
1436 {
1437 #if 0
1438     printf("output:\n");
1439     hex_dump(stdout, pkt, pkt_len);
1440 #endif
1441     slirp_fd_read(slirp_fd_opaque, pkt, pkt_len);
1442 }
1443
1444 static void slirp_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1445 {
1446 #if 0
1447     printf("input:\n");
1448     hex_dump(stdout, buf, size);
1449 #endif
1450     slirp_input(buf, size);
1451 }
1452
1453 static void slirp_add_read_packet(NetDriverState *nd,
1454                                   IOCanRWHandler *fd_can_read,
1455                                   IOReadHandler *fd_read, void *opaque)
1456 {
1457     slirp_fd_opaque = opaque;
1458     slirp_fd_can_read = fd_can_read;
1459     slirp_fd_read = fd_read;
1460 }
1461
1462 static int net_slirp_init(NetDriverState *nd)
1463 {
1464     if (!slirp_inited) {
1465         slirp_inited = 1;
1466         slirp_init();
1467     }
1468     nd->send_packet = slirp_send_packet;
1469     nd->add_read_packet = slirp_add_read_packet;
1470     pstrcpy(nd->ifname, sizeof(nd->ifname), "slirp");
1471     return 0;
1472 }
1473
1474 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
1475 {
1476     const char *p, *p1;
1477     int len;
1478     p = *pp;
1479     p1 = strchr(p, sep);
1480     if (!p1)
1481         return -1;
1482     len = p1 - p;
1483     p1++;
1484     if (buf_size > 0) {
1485         if (len > buf_size - 1)
1486             len = buf_size - 1;
1487         memcpy(buf, p, len);
1488         buf[len] = '\0';
1489     }
1490     *pp = p1;
1491     return 0;
1492 }
1493
1494 static void net_slirp_redir(const char *redir_str)
1495 {
1496     int is_udp;
1497     char buf[256], *r;
1498     const char *p;
1499     struct in_addr guest_addr;
1500     int host_port, guest_port;
1501
1502     if (!slirp_inited) {
1503         slirp_inited = 1;
1504         slirp_init();
1505     }
1506
1507     p = redir_str;
1508     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1509         goto fail;
1510     if (!strcmp(buf, "tcp")) {
1511         is_udp = 0;
1512     } else if (!strcmp(buf, "udp")) {
1513         is_udp = 1;
1514     } else {
1515         goto fail;
1516     }
1517
1518     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1519         goto fail;
1520     host_port = strtol(buf, &r, 0);
1521     if (r == buf)
1522         goto fail;
1523
1524     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1525         goto fail;
1526     if (buf[0] == '\0') {
1527         pstrcpy(buf, sizeof(buf), "10.0.2.15");
1528     }
1529     if (!inet_aton(buf, &guest_addr))
1530         goto fail;
1531
1532     guest_port = strtol(p, &r, 0);
1533     if (r == p)
1534         goto fail;
1535
1536     if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
1537         fprintf(stderr, "qemu: could not set up redirection\n");
1538         exit(1);
1539     }
1540     return;
1541  fail:
1542     fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
1543     exit(1);
1544 }
1545
1546 #ifndef _WIN32
1547
1548 char smb_dir[1024];
1549
1550 static void smb_exit(void)
1551 {
1552     DIR *d;
1553     struct dirent *de;
1554     char filename[1024];
1555
1556     /* erase all the files in the directory */
1557     d = opendir(smb_dir);
1558     for(;;) {
1559         de = readdir(d);
1560         if (!de)
1561             break;
1562         if (strcmp(de->d_name, ".") != 0 &&
1563             strcmp(de->d_name, "..") != 0) {
1564             snprintf(filename, sizeof(filename), "%s/%s",
1565                      smb_dir, de->d_name);
1566             unlink(filename);
1567         }
1568     }
1569     closedir(d);
1570     rmdir(smb_dir);
1571 }
1572
1573 /* automatic user mode samba server configuration */
1574 void net_slirp_smb(const char *exported_dir)
1575 {
1576     char smb_conf[1024];
1577     char smb_cmdline[1024];
1578     FILE *f;
1579
1580     if (!slirp_inited) {
1581         slirp_inited = 1;
1582         slirp_init();
1583     }
1584
1585     /* XXX: better tmp dir construction */
1586     snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
1587     if (mkdir(smb_dir, 0700) < 0) {
1588         fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
1589         exit(1);
1590     }
1591     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
1592
1593     f = fopen(smb_conf, "w");
1594     if (!f) {
1595         fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
1596         exit(1);
1597     }
1598     fprintf(f,
1599             "[global]\n"
1600             "private dir=%s\n"
1601             "smb ports=0\n"
1602             "socket address=127.0.0.1\n"
1603             "pid directory=%s\n"
1604             "lock directory=%s\n"
1605             "log file=%s/log.smbd\n"
1606             "smb passwd file=%s/smbpasswd\n"
1607             "security = share\n"
1608             "[qemu]\n"
1609             "path=%s\n"
1610             "read only=no\n"
1611             "guest ok=yes\n",
1612             smb_dir,
1613             smb_dir,
1614             smb_dir,
1615             smb_dir,
1616             smb_dir,
1617             exported_dir
1618             );
1619     fclose(f);
1620     atexit(smb_exit);
1621
1622     snprintf(smb_cmdline, sizeof(smb_cmdline), "/usr/sbin/smbd -s %s",
1623              smb_conf);
1624
1625     slirp_add_exec(0, smb_cmdline, 4, 139);
1626 }
1627
1628 #endif /* !defined(_WIN32) */
1629
1630 #endif /* CONFIG_SLIRP */
1631
1632 #if !defined(_WIN32)
1633 #ifdef _BSD
1634 static int tun_open(char *ifname, int ifname_size)
1635 {
1636     int fd;
1637     char *dev;
1638     struct stat s;
1639
1640     fd = open("/dev/tap", O_RDWR);
1641     if (fd < 0) {
1642         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
1643         return -1;
1644     }
1645
1646     fstat(fd, &s);
1647     dev = devname(s.st_rdev, S_IFCHR);
1648     pstrcpy(ifname, ifname_size, dev);
1649
1650     fcntl(fd, F_SETFL, O_NONBLOCK);
1651     return fd;
1652 }
1653 #else
1654 static int tun_open(char *ifname, int ifname_size)
1655 {
1656     struct ifreq ifr;
1657     int fd, ret;
1658
1659     fd = open("/dev/net/tun", O_RDWR);
1660     if (fd < 0) {
1661         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1662         return -1;
1663     }
1664     memset(&ifr, 0, sizeof(ifr));
1665     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1666     pstrcpy(ifr.ifr_name, IFNAMSIZ, "tun%d");
1667     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1668     if (ret != 0) {
1669         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1670         close(fd);
1671         return -1;
1672     }
1673     printf("Connected to host network interface: %s\n", ifr.ifr_name);
1674     pstrcpy(ifname, ifname_size, ifr.ifr_name);
1675     fcntl(fd, F_SETFL, O_NONBLOCK);
1676     return fd;
1677 }
1678 #endif
1679
1680 static void tun_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1681 {
1682     write(nd->fd, buf, size);
1683 }
1684
1685 static void tun_add_read_packet(NetDriverState *nd,
1686                                 IOCanRWHandler *fd_can_read,
1687                                 IOReadHandler *fd_read, void *opaque)
1688 {
1689     qemu_add_fd_read_handler(nd->fd, fd_can_read, fd_read, opaque);
1690 }
1691
1692 static int net_tun_init(NetDriverState *nd)
1693 {
1694     int pid, status;
1695     char *args[3];
1696     char **parg;
1697
1698     nd->fd = tun_open(nd->ifname, sizeof(nd->ifname));
1699     if (nd->fd < 0)
1700         return -1;
1701
1702     /* try to launch network init script */
1703     pid = fork();
1704     if (pid >= 0) {
1705         if (pid == 0) {
1706             parg = args;
1707             *parg++ = network_script;
1708             *parg++ = nd->ifname;
1709             *parg++ = NULL;
1710             execv(network_script, args);
1711             exit(1);
1712         }
1713         while (waitpid(pid, &status, 0) != pid);
1714         if (!WIFEXITED(status) ||
1715             WEXITSTATUS(status) != 0) {
1716             fprintf(stderr, "%s: could not launch network script\n",
1717                     network_script);
1718         }
1719     }
1720     nd->send_packet = tun_send_packet;
1721     nd->add_read_packet = tun_add_read_packet;
1722     return 0;
1723 }
1724
1725 static int net_fd_init(NetDriverState *nd, int fd)
1726 {
1727     nd->fd = fd;
1728     nd->send_packet = tun_send_packet;
1729     nd->add_read_packet = tun_add_read_packet;
1730     pstrcpy(nd->ifname, sizeof(nd->ifname), "tunfd");
1731     return 0;
1732 }
1733
1734 #endif /* !_WIN32 */
1735
1736 /***********************************************************/
1737 /* pid file */
1738
1739 static char *pid_filename;
1740
1741 /* Remove PID file. Called on normal exit */
1742
1743 static void remove_pidfile(void)
1744 {
1745     unlink (pid_filename);
1746 }
1747
1748 static void create_pidfile(const char *filename)
1749 {
1750     struct stat pidstat;
1751     FILE *f;
1752
1753     /* Try to write our PID to the named file */
1754     if (stat(filename, &pidstat) < 0) {
1755         if (errno == ENOENT) {
1756             if ((f = fopen (filename, "w")) == NULL) {
1757                 perror("Opening pidfile");
1758                 exit(1);
1759             }
1760             fprintf(f, "%d\n", getpid());
1761             fclose(f);
1762             pid_filename = qemu_strdup(filename);
1763             if (!pid_filename) {
1764                 fprintf(stderr, "Could not save PID filename");
1765                 exit(1);
1766             }
1767             atexit(remove_pidfile);
1768         }
1769     } else {
1770         fprintf(stderr, "%s already exists. Remove it and try again.\n",
1771                 filename);
1772         exit(1);
1773     }
1774 }
1775
1776 /***********************************************************/
1777 /* dumb display */
1778
1779 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
1780 {
1781 }
1782
1783 static void dumb_resize(DisplayState *ds, int w, int h)
1784 {
1785 }
1786
1787 static void dumb_refresh(DisplayState *ds)
1788 {
1789     vga_update_display();
1790 }
1791
1792 void dumb_display_init(DisplayState *ds)
1793 {
1794     ds->data = NULL;
1795     ds->linesize = 0;
1796     ds->depth = 0;
1797     ds->dpy_update = dumb_update;
1798     ds->dpy_resize = dumb_resize;
1799     ds->dpy_refresh = dumb_refresh;
1800 }
1801
1802 #if !defined(CONFIG_SOFTMMU)
1803 /***********************************************************/
1804 /* cpu signal handler */
1805 static void host_segv_handler(int host_signum, siginfo_t *info,
1806                               void *puc)
1807 {
1808     if (cpu_signal_handler(host_signum, info, puc))
1809         return;
1810     if (stdio_nb_clients > 0)
1811         term_exit();
1812     abort();
1813 }
1814 #endif
1815
1816 /***********************************************************/
1817 /* I/O handling */
1818
1819 #define MAX_IO_HANDLERS 64
1820
1821 typedef struct IOHandlerRecord {
1822     int fd;
1823     IOCanRWHandler *fd_can_read;
1824     IOReadHandler *fd_read;
1825     void *opaque;
1826     /* temporary data */
1827     struct pollfd *ufd;
1828     int max_size;
1829     struct IOHandlerRecord *next;
1830 } IOHandlerRecord;
1831
1832 static IOHandlerRecord *first_io_handler;
1833
1834 int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read,
1835                              IOReadHandler *fd_read, void *opaque)
1836 {
1837     IOHandlerRecord *ioh;
1838
1839     ioh = qemu_mallocz(sizeof(IOHandlerRecord));
1840     if (!ioh)
1841         return -1;
1842     ioh->fd = fd;
1843     ioh->fd_can_read = fd_can_read;
1844     ioh->fd_read = fd_read;
1845     ioh->opaque = opaque;
1846     ioh->next = first_io_handler;
1847     first_io_handler = ioh;
1848     return 0;
1849 }
1850
1851 void qemu_del_fd_read_handler(int fd)
1852 {
1853     IOHandlerRecord **pioh, *ioh;
1854
1855     pioh = &first_io_handler;
1856     for(;;) {
1857         ioh = *pioh;
1858         if (ioh == NULL)
1859             break;
1860         if (ioh->fd == fd) {
1861             *pioh = ioh->next;
1862             break;
1863         }
1864         pioh = &ioh->next;
1865     }
1866 }
1867
1868 /***********************************************************/
1869 /* savevm/loadvm support */
1870
1871 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
1872 {
1873     fwrite(buf, 1, size, f);
1874 }
1875
1876 void qemu_put_byte(QEMUFile *f, int v)
1877 {
1878     fputc(v, f);
1879 }
1880
1881 void qemu_put_be16(QEMUFile *f, unsigned int v)
1882 {
1883     qemu_put_byte(f, v >> 8);
1884     qemu_put_byte(f, v);
1885 }
1886
1887 void qemu_put_be32(QEMUFile *f, unsigned int v)
1888 {
1889     qemu_put_byte(f, v >> 24);
1890     qemu_put_byte(f, v >> 16);
1891     qemu_put_byte(f, v >> 8);
1892     qemu_put_byte(f, v);
1893 }
1894
1895 void qemu_put_be64(QEMUFile *f, uint64_t v)
1896 {
1897     qemu_put_be32(f, v >> 32);
1898     qemu_put_be32(f, v);
1899 }
1900
1901 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
1902 {
1903     return fread(buf, 1, size, f);
1904 }
1905
1906 int qemu_get_byte(QEMUFile *f)
1907 {
1908     int v;
1909     v = fgetc(f);
1910     if (v == EOF)
1911         return 0;
1912     else
1913         return v;
1914 }
1915
1916 unsigned int qemu_get_be16(QEMUFile *f)
1917 {
1918     unsigned int v;
1919     v = qemu_get_byte(f) << 8;
1920     v |= qemu_get_byte(f);
1921     return v;
1922 }
1923
1924 unsigned int qemu_get_be32(QEMUFile *f)
1925 {
1926     unsigned int v;
1927     v = qemu_get_byte(f) << 24;
1928     v |= qemu_get_byte(f) << 16;
1929     v |= qemu_get_byte(f) << 8;
1930     v |= qemu_get_byte(f);
1931     return v;
1932 }
1933
1934 uint64_t qemu_get_be64(QEMUFile *f)
1935 {
1936     uint64_t v;
1937     v = (uint64_t)qemu_get_be32(f) << 32;
1938     v |= qemu_get_be32(f);
1939     return v;
1940 }
1941
1942 int64_t qemu_ftell(QEMUFile *f)
1943 {
1944     return ftell(f);
1945 }
1946
1947 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
1948 {
1949     if (fseek(f, pos, whence) < 0)
1950         return -1;
1951     return ftell(f);
1952 }
1953
1954 typedef struct SaveStateEntry {
1955     char idstr[256];
1956     int instance_id;
1957     int version_id;
1958     SaveStateHandler *save_state;
1959     LoadStateHandler *load_state;
1960     void *opaque;
1961     struct SaveStateEntry *next;
1962 } SaveStateEntry;
1963
1964 static SaveStateEntry *first_se;
1965
1966 int register_savevm(const char *idstr,
1967                     int instance_id,
1968                     int version_id,
1969                     SaveStateHandler *save_state,
1970                     LoadStateHandler *load_state,
1971                     void *opaque)
1972 {
1973     SaveStateEntry *se, **pse;
1974
1975     se = qemu_malloc(sizeof(SaveStateEntry));
1976     if (!se)
1977         return -1;
1978     pstrcpy(se->idstr, sizeof(se->idstr), idstr);
1979     se->instance_id = instance_id;
1980     se->version_id = version_id;
1981     se->save_state = save_state;
1982     se->load_state = load_state;
1983     se->opaque = opaque;
1984     se->next = NULL;
1985
1986     /* add at the end of list */
1987     pse = &first_se;
1988     while (*pse != NULL)
1989         pse = &(*pse)->next;
1990     *pse = se;
1991     return 0;
1992 }
1993
1994 #define QEMU_VM_FILE_MAGIC   0x5145564d
1995 #define QEMU_VM_FILE_VERSION 0x00000001
1996
1997 int qemu_savevm(const char *filename)
1998 {
1999     SaveStateEntry *se;
2000     QEMUFile *f;
2001     int len, len_pos, cur_pos, saved_vm_running, ret;
2002
2003     saved_vm_running = vm_running;
2004     vm_stop(0);
2005
2006     f = fopen(filename, "wb");
2007     if (!f) {
2008         ret = -1;
2009         goto the_end;
2010     }
2011
2012     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
2013     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
2014
2015     for(se = first_se; se != NULL; se = se->next) {
2016         /* ID string */
2017         len = strlen(se->idstr);
2018         qemu_put_byte(f, len);
2019         qemu_put_buffer(f, se->idstr, len);
2020
2021         qemu_put_be32(f, se->instance_id);
2022         qemu_put_be32(f, se->version_id);
2023
2024         /* record size: filled later */
2025         len_pos = ftell(f);
2026         qemu_put_be32(f, 0);
2027
2028         se->save_state(f, se->opaque);
2029
2030         /* fill record size */
2031         cur_pos = ftell(f);
2032         len = ftell(f) - len_pos - 4;
2033         fseek(f, len_pos, SEEK_SET);
2034         qemu_put_be32(f, len);
2035         fseek(f, cur_pos, SEEK_SET);
2036     }
2037
2038     fclose(f);
2039     ret = 0;
2040  the_end:
2041     if (saved_vm_running)
2042         vm_start();
2043     return ret;
2044 }
2045
2046 static SaveStateEntry *find_se(const char *idstr, int instance_id)
2047 {
2048     SaveStateEntry *se;
2049
2050     for(se = first_se; se != NULL; se = se->next) {
2051         if (!strcmp(se->idstr, idstr) &&
2052             instance_id == se->instance_id)
2053             return se;
2054     }
2055     return NULL;
2056 }
2057
2058 int qemu_loadvm(const char *filename)
2059 {
2060     SaveStateEntry *se;
2061     QEMUFile *f;
2062     int len, cur_pos, ret, instance_id, record_len, version_id;
2063     int saved_vm_running;
2064     unsigned int v;
2065     char idstr[256];
2066
2067     saved_vm_running = vm_running;
2068     vm_stop(0);
2069
2070     f = fopen(filename, "rb");
2071     if (!f) {
2072         ret = -1;
2073         goto the_end;
2074     }
2075
2076     v = qemu_get_be32(f);
2077     if (v != QEMU_VM_FILE_MAGIC)
2078         goto fail;
2079     v = qemu_get_be32(f);
2080     if (v != QEMU_VM_FILE_VERSION) {
2081     fail:
2082         fclose(f);
2083         ret = -1;
2084         goto the_end;
2085     }
2086     for(;;) {
2087 #if defined (DO_TB_FLUSH)
2088         tb_flush(global_env);
2089 #endif
2090         len = qemu_get_byte(f);
2091         if (feof(f))
2092             break;
2093         qemu_get_buffer(f, idstr, len);
2094         idstr[len] = '\0';
2095         instance_id = qemu_get_be32(f);
2096         version_id = qemu_get_be32(f);
2097         record_len = qemu_get_be32(f);
2098 #if 0
2099         printf("idstr=%s instance=0x%x version=%d len=%d\n",
2100                idstr, instance_id, version_id, record_len);
2101 #endif
2102         cur_pos = ftell(f);
2103         se = find_se(idstr, instance_id);
2104         if (!se) {
2105             fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
2106                     instance_id, idstr);
2107         } else {
2108             ret = se->load_state(f, se->opaque, version_id);
2109             if (ret < 0) {
2110                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
2111                         instance_id, idstr);
2112             }
2113         }
2114         /* always seek to exact end of record */
2115         qemu_fseek(f, cur_pos + record_len, SEEK_SET);
2116     }
2117     fclose(f);
2118     ret = 0;
2119  the_end:
2120     if (saved_vm_running)
2121         vm_start();
2122     return ret;
2123 }
2124
2125 /***********************************************************/
2126 /* cpu save/restore */
2127
2128 #if defined(TARGET_I386)
2129
2130 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
2131 {
2132     qemu_put_be32(f, dt->selector);
2133     qemu_put_betl(f, dt->base);
2134     qemu_put_be32(f, dt->limit);
2135     qemu_put_be32(f, dt->flags);
2136 }
2137
2138 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
2139 {
2140     dt->selector = qemu_get_be32(f);
2141     dt->base = qemu_get_betl(f);
2142     dt->limit = qemu_get_be32(f);
2143     dt->flags = qemu_get_be32(f);
2144 }
2145
2146 void cpu_save(QEMUFile *f, void *opaque)
2147 {
2148     CPUState *env = opaque;
2149     uint16_t fptag, fpus, fpuc, fpregs_format;
2150     uint32_t hflags;
2151     int i;
2152
2153     for(i = 0; i < CPU_NB_REGS; i++)
2154         qemu_put_betls(f, &env->regs[i]);
2155     qemu_put_betls(f, &env->eip);
2156     qemu_put_betls(f, &env->eflags);
2157     hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
2158     qemu_put_be32s(f, &hflags);
2159
2160     /* FPU */
2161     fpuc = env->fpuc;
2162     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
2163     fptag = 0;
2164     for(i = 0; i < 8; i++) {
2165         fptag |= ((!env->fptags[i]) << i);
2166     }
2167
2168     qemu_put_be16s(f, &fpuc);
2169     qemu_put_be16s(f, &fpus);
2170     qemu_put_be16s(f, &fptag);
2171
2172 #ifdef USE_X86LDOUBLE
2173     fpregs_format = 0;
2174 #else
2175     fpregs_format = 1;
2176 #endif
2177     qemu_put_be16s(f, &fpregs_format);
2178
2179     for(i = 0; i < 8; i++) {
2180 #ifdef USE_X86LDOUBLE
2181         {
2182             uint64_t mant;
2183             uint16_t exp;
2184             /* we save the real CPU data (in case of MMX usage only 'mant'
2185                contains the MMX register */
2186             cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
2187             qemu_put_be64(f, mant);
2188             qemu_put_be16(f, exp);
2189         }
2190 #else
2191         /* if we use doubles for float emulation, we save the doubles to
2192            avoid losing information in case of MMX usage. It can give
2193            problems if the image is restored on a CPU where long
2194            doubles are used instead. */
2195         qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
2196 #endif
2197     }
2198
2199     for(i = 0; i < 6; i++)
2200         cpu_put_seg(f, &env->segs[i]);
2201     cpu_put_seg(f, &env->ldt);
2202     cpu_put_seg(f, &env->tr);
2203     cpu_put_seg(f, &env->gdt);
2204     cpu_put_seg(f, &env->idt);
2205
2206     qemu_put_be32s(f, &env->sysenter_cs);
2207     qemu_put_be32s(f, &env->sysenter_esp);
2208     qemu_put_be32s(f, &env->sysenter_eip);
2209
2210     qemu_put_betls(f, &env->cr[0]);
2211     qemu_put_betls(f, &env->cr[2]);
2212     qemu_put_betls(f, &env->cr[3]);
2213     qemu_put_betls(f, &env->cr[4]);
2214
2215     for(i = 0; i < 8; i++)
2216         qemu_put_betls(f, &env->dr[i]);
2217
2218     /* MMU */
2219     qemu_put_be32s(f, &env->a20_mask);
2220
2221     /* XMM */
2222     qemu_put_be32s(f, &env->mxcsr);
2223     for(i = 0; i < CPU_NB_REGS; i++) {
2224         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
2225         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
2226     }
2227
2228 #ifdef TARGET_X86_64
2229     qemu_put_be64s(f, &env->efer);
2230     qemu_put_be64s(f, &env->star);
2231     qemu_put_be64s(f, &env->lstar);
2232     qemu_put_be64s(f, &env->cstar);
2233     qemu_put_be64s(f, &env->fmask);
2234     qemu_put_be64s(f, &env->kernelgsbase);
2235 #endif
2236 }
2237
2238 #ifdef USE_X86LDOUBLE
2239 /* XXX: add that in a FPU generic layer */
2240 union x86_longdouble {
2241     uint64_t mant;
2242     uint16_t exp;
2243 };
2244
2245 #define MANTD1(fp)      (fp & ((1LL << 52) - 1))
2246 #define EXPBIAS1 1023
2247 #define EXPD1(fp)       ((fp >> 52) & 0x7FF)
2248 #define SIGND1(fp)      ((fp >> 32) & 0x80000000)
2249
2250 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
2251 {
2252     int e;
2253     /* mantissa */
2254     p->mant = (MANTD1(temp) << 11) | (1LL << 63);
2255     /* exponent + sign */
2256     e = EXPD1(temp) - EXPBIAS1 + 16383;
2257     e |= SIGND1(temp) >> 16;
2258     p->exp = e;
2259 }
2260 #endif
2261
2262 int cpu_load(QEMUFile *f, void *opaque, int version_id)
2263 {
2264     CPUState *env = opaque;
2265     int i, guess_mmx;
2266     uint32_t hflags;
2267     uint16_t fpus, fpuc, fptag, fpregs_format;
2268
2269     if (version_id != 3)
2270         return -EINVAL;
2271     for(i = 0; i < CPU_NB_REGS; i++)
2272         qemu_get_betls(f, &env->regs[i]);
2273     qemu_get_betls(f, &env->eip);
2274     qemu_get_betls(f, &env->eflags);
2275     qemu_get_be32s(f, &hflags);
2276
2277     qemu_get_be16s(f, &fpuc);
2278     qemu_get_be16s(f, &fpus);
2279     qemu_get_be16s(f, &fptag);
2280     qemu_get_be16s(f, &fpregs_format);
2281
2282     /* NOTE: we cannot always restore the FPU state if the image come
2283        from a host with a different 'USE_X86LDOUBLE' define. We guess
2284        if we are in an MMX state to restore correctly in that case. */
2285     guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
2286     for(i = 0; i < 8; i++) {
2287         uint64_t mant;
2288         uint16_t exp;
2289
2290         switch(fpregs_format) {
2291         case 0:
2292             mant = qemu_get_be64(f);
2293             exp = qemu_get_be16(f);
2294 #ifdef USE_X86LDOUBLE
2295             env->fpregs[i].d = cpu_set_fp80(mant, exp);
2296 #else
2297             /* difficult case */
2298             if (guess_mmx)
2299                 env->fpregs[i].mmx.MMX_Q(0) = mant;
2300             else
2301                 env->fpregs[i].d = cpu_set_fp80(mant, exp);
2302 #endif
2303             break;
2304         case 1:
2305             mant = qemu_get_be64(f);
2306 #ifdef USE_X86LDOUBLE
2307             {
2308                 union x86_longdouble *p;
2309                 /* difficult case */
2310                 p = (void *)&env->fpregs[i];
2311                 if (guess_mmx) {
2312                     p->mant = mant;
2313                     p->exp = 0xffff;
2314                 } else {
2315                     fp64_to_fp80(p, mant);
2316                 }
2317             }
2318 #else
2319             env->fpregs[i].mmx.MMX_Q(0) = mant;
2320 #endif
2321             break;
2322         default:
2323             return -EINVAL;
2324         }
2325     }
2326
2327     env->fpuc = fpuc;
2328     /* XXX: restore FPU round state */
2329     env->fpstt = (fpus >> 11) & 7;
2330     env->fpus = fpus & ~0x3800;
2331     fptag ^= 0xff;
2332     for(i = 0; i < 8; i++) {
2333         env->fptags[i] = (fptag >> i) & 1;
2334     }
2335
2336     for(i = 0; i < 6; i++)
2337         cpu_get_seg(f, &env->segs[i]);
2338     cpu_get_seg(f, &env->ldt);
2339     cpu_get_seg(f, &env->tr);
2340     cpu_get_seg(f, &env->gdt);
2341     cpu_get_seg(f, &env->idt);
2342
2343     qemu_get_be32s(f, &env->sysenter_cs);
2344     qemu_get_be32s(f, &env->sysenter_esp);
2345     qemu_get_be32s(f, &env->sysenter_eip);
2346
2347     qemu_get_betls(f, &env->cr[0]);
2348     qemu_get_betls(f, &env->cr[2]);
2349     qemu_get_betls(f, &env->cr[3]);
2350     qemu_get_betls(f, &env->cr[4]);
2351
2352     for(i = 0; i < 8; i++)
2353         qemu_get_betls(f, &env->dr[i]);
2354
2355     /* MMU */
2356     qemu_get_be32s(f, &env->a20_mask);
2357
2358     qemu_get_be32s(f, &env->mxcsr);
2359     for(i = 0; i < CPU_NB_REGS; i++) {
2360         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
2361         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
2362     }
2363
2364 #ifdef TARGET_X86_64
2365     qemu_get_be64s(f, &env->efer);
2366     qemu_get_be64s(f, &env->star);
2367     qemu_get_be64s(f, &env->lstar);
2368     qemu_get_be64s(f, &env->cstar);
2369     qemu_get_be64s(f, &env->fmask);
2370     qemu_get_be64s(f, &env->kernelgsbase);
2371 #endif
2372
2373     /* XXX: compute hflags from scratch, except for CPL and IIF */
2374     env->hflags = hflags;
2375     tlb_flush(env, 1);
2376     return 0;
2377 }
2378
2379 #elif defined(TARGET_PPC)
2380 void cpu_save(QEMUFile *f, void *opaque)
2381 {
2382 }
2383
2384 int cpu_load(QEMUFile *f, void *opaque, int version_id)
2385 {
2386     return 0;
2387 }
2388
2389 #elif defined(TARGET_MIPS)
2390 void cpu_save(QEMUFile *f, void *opaque)
2391 {
2392 }
2393
2394 int cpu_load(QEMUFile *f, void *opaque, int version_id)
2395 {
2396     return 0;
2397 }
2398
2399 #elif defined(TARGET_SPARC)
2400 void cpu_save(QEMUFile *f, void *opaque)
2401 {
2402     CPUState *env = opaque;
2403     int i;
2404     uint32_t tmp;
2405
2406     for(i = 0; i < 8; i++)
2407         qemu_put_betls(f, &env->gregs[i]);
2408     for(i = 0; i < NWINDOWS * 16; i++)
2409         qemu_put_betls(f, &env->regbase[i]);
2410
2411     /* FPU */
2412     for(i = 0; i < TARGET_FPREGS; i++) {
2413         union {
2414             TARGET_FPREG_T f;
2415             target_ulong i;
2416         } u;
2417         u.f = env->fpr[i];
2418         qemu_put_betl(f, u.i);
2419     }
2420
2421     qemu_put_betls(f, &env->pc);
2422     qemu_put_betls(f, &env->npc);
2423     qemu_put_betls(f, &env->y);
2424     tmp = GET_PSR(env);
2425     qemu_put_be32(f, tmp);
2426     qemu_put_betls(f, &env->fsr);
2427     qemu_put_betls(f, &env->tbr);
2428 #ifndef TARGET_SPARC64
2429     qemu_put_be32s(f, &env->wim);
2430     /* MMU */
2431     for(i = 0; i < 16; i++)
2432         qemu_put_be32s(f, &env->mmuregs[i]);
2433 #endif
2434 }
2435
2436 int cpu_load(QEMUFile *f, void *opaque, int version_id)
2437 {
2438     CPUState *env = opaque;
2439     int i;
2440     uint32_t tmp;
2441
2442     for(i = 0; i < 8; i++)
2443         qemu_get_betls(f, &env->gregs[i]);
2444     for(i = 0; i < NWINDOWS * 16; i++)
2445         qemu_get_betls(f, &env->regbase[i]);
2446
2447     /* FPU */
2448     for(i = 0; i < TARGET_FPREGS; i++) {
2449         union {
2450             TARGET_FPREG_T f;
2451             target_ulong i;
2452         } u;
2453         u.i = qemu_get_betl(f);
2454         env->fpr[i] = u.f;
2455     }
2456
2457     qemu_get_betls(f, &env->pc);
2458     qemu_get_betls(f, &env->npc);
2459     qemu_get_betls(f, &env->y);
2460     tmp = qemu_get_be32(f);
2461     env->cwp = 0; /* needed to ensure that the wrapping registers are
2462                      correctly updated */
2463     PUT_PSR(env, tmp);
2464     qemu_get_betls(f, &env->fsr);
2465     qemu_get_betls(f, &env->tbr);
2466 #ifndef TARGET_SPARC64
2467     qemu_get_be32s(f, &env->wim);
2468     /* MMU */
2469     for(i = 0; i < 16; i++)
2470         qemu_get_be32s(f, &env->mmuregs[i]);
2471 #endif
2472     tlb_flush(env, 1);
2473     return 0;
2474 }
2475 #else
2476
2477 #warning No CPU save/restore functions
2478
2479 #endif
2480
2481 /***********************************************************/
2482 /* ram save/restore */
2483
2484 /* we just avoid storing empty pages */
2485 static void ram_put_page(QEMUFile *f, const uint8_t *buf, int len)
2486 {
2487     int i, v;
2488
2489     v = buf[0];
2490     for(i = 1; i < len; i++) {
2491         if (buf[i] != v)
2492             goto normal_save;
2493     }
2494     qemu_put_byte(f, 1);
2495     qemu_put_byte(f, v);
2496     return;
2497  normal_save:
2498     qemu_put_byte(f, 0);
2499     qemu_put_buffer(f, buf, len);
2500 }
2501
2502 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
2503 {
2504     int v;
2505
2506     v = qemu_get_byte(f);
2507     switch(v) {
2508     case 0:
2509         if (qemu_get_buffer(f, buf, len) != len)
2510             return -EIO;
2511         break;
2512     case 1:
2513         v = qemu_get_byte(f);
2514         memset(buf, v, len);
2515         break;
2516     default:
2517         return -EINVAL;
2518     }
2519     return 0;
2520 }
2521
2522 static void ram_save(QEMUFile *f, void *opaque)
2523 {
2524     int i;
2525     qemu_put_be32(f, phys_ram_size);
2526     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
2527         ram_put_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
2528     }
2529 }
2530
2531 static int ram_load(QEMUFile *f, void *opaque, int version_id)
2532 {
2533     int i, ret;
2534
2535     if (version_id != 1)
2536         return -EINVAL;
2537     if (qemu_get_be32(f) != phys_ram_size)
2538         return -EINVAL;
2539     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
2540         ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
2541         if (ret)
2542             return ret;
2543     }
2544     return 0;
2545 }
2546
2547 /***********************************************************/
2548 /* machine registration */
2549
2550 QEMUMachine *first_machine = NULL;
2551
2552 int qemu_register_machine(QEMUMachine *m)
2553 {
2554     QEMUMachine **pm;
2555     pm = &first_machine;
2556     while (*pm != NULL)
2557         pm = &(*pm)->next;
2558     m->next = NULL;
2559     *pm = m;
2560     return 0;
2561 }
2562
2563 QEMUMachine *find_machine(const char *name)
2564 {
2565     QEMUMachine *m;
2566
2567     for(m = first_machine; m != NULL; m = m->next) {
2568         if (!strcmp(m->name, name))
2569             return m;
2570     }
2571     return NULL;
2572 }
2573
2574 /***********************************************************/
2575 /* main execution loop */
2576
2577 void gui_update(void *opaque)
2578 {
2579     display_state.dpy_refresh(&display_state);
2580     qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
2581 }
2582
2583 /* XXX: support several handlers */
2584 VMStopHandler *vm_stop_cb;
2585 VMStopHandler *vm_stop_opaque;
2586
2587 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
2588 {
2589     vm_stop_cb = cb;
2590     vm_stop_opaque = opaque;
2591     return 0;
2592 }
2593
2594 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
2595 {
2596     vm_stop_cb = NULL;
2597 }
2598
2599 void vm_start(void)
2600 {
2601     if (!vm_running) {
2602         cpu_enable_ticks();
2603         vm_running = 1;
2604     }
2605 }
2606
2607 void vm_stop(int reason)
2608 {
2609     if (vm_running) {
2610         cpu_disable_ticks();
2611         vm_running = 0;
2612         if (reason != 0) {
2613             if (vm_stop_cb) {
2614                 vm_stop_cb(vm_stop_opaque, reason);
2615             }
2616         }
2617     }
2618 }
2619
2620 /* reset/shutdown handler */
2621
2622 typedef struct QEMUResetEntry {
2623     QEMUResetHandler *func;
2624     void *opaque;
2625     struct QEMUResetEntry *next;
2626 } QEMUResetEntry;
2627
2628 static QEMUResetEntry *first_reset_entry;
2629 static int reset_requested;
2630 static int shutdown_requested;
2631 static int powerdown_requested;
2632
2633 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
2634 {
2635     QEMUResetEntry **pre, *re;
2636
2637     pre = &first_reset_entry;
2638     while (*pre != NULL)
2639         pre = &(*pre)->next;
2640     re = qemu_mallocz(sizeof(QEMUResetEntry));
2641     re->func = func;
2642     re->opaque = opaque;
2643     re->next = NULL;
2644     *pre = re;
2645 }
2646
2647 void qemu_system_reset(void)
2648 {
2649     QEMUResetEntry *re;
2650
2651     /* reset all devices */
2652     for(re = first_reset_entry; re != NULL; re = re->next) {
2653         re->func(re->opaque);
2654     }
2655 }
2656
2657 void qemu_system_reset_request(void)
2658 {
2659     reset_requested = 1;
2660     cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
2661 }
2662
2663 void qemu_system_shutdown_request(void)
2664 {
2665     shutdown_requested = 1;
2666     cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
2667 }
2668
2669 void qemu_system_powerdown_request(void)
2670 {
2671     powerdown_requested = 1;
2672     cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
2673 }
2674
2675 static void main_cpu_reset(void *opaque)
2676 {
2677 #if defined(TARGET_I386) || defined(TARGET_SPARC)
2678     CPUState *env = opaque;
2679     cpu_reset(env);
2680 #endif
2681 }
2682
2683 void main_loop_wait(int timeout)
2684 {
2685 #ifndef _WIN32
2686     struct pollfd ufds[MAX_IO_HANDLERS + 1], *pf;
2687     IOHandlerRecord *ioh, *ioh_next;
2688     uint8_t buf[4096];
2689     int n, max_size;
2690 #endif
2691     int ret;
2692
2693 #ifdef _WIN32
2694         if (timeout > 0)
2695             Sleep(timeout);
2696 #else
2697         /* poll any events */
2698         /* XXX: separate device handlers from system ones */
2699         pf = ufds;
2700         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2701             if (!ioh->fd_can_read) {
2702                 max_size = 0;
2703                 pf->fd = ioh->fd;
2704                 pf->events = POLLIN;
2705                 ioh->ufd = pf;
2706                 pf++;
2707             } else {
2708                 max_size = ioh->fd_can_read(ioh->opaque);
2709                 if (max_size > 0) {
2710                     if (max_size > sizeof(buf))
2711                         max_size = sizeof(buf);
2712                     pf->fd = ioh->fd;
2713                     pf->events = POLLIN;
2714                     ioh->ufd = pf;
2715                     pf++;
2716                 } else {
2717                     ioh->ufd = NULL;
2718                 }
2719             }
2720             ioh->max_size = max_size;
2721         }
2722
2723         ret = poll(ufds, pf - ufds, timeout);
2724         if (ret > 0) {
2725             /* XXX: better handling of removal */
2726             for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
2727                 ioh_next = ioh->next;
2728                 pf = ioh->ufd;
2729                 if (pf) {
2730                     if (pf->revents & POLLIN) {
2731                         if (ioh->max_size == 0) {
2732                             /* just a read event */
2733                             ioh->fd_read(ioh->opaque, NULL, 0);
2734                         } else {
2735                             n = read(ioh->fd, buf, ioh->max_size);
2736                             if (n >= 0) {
2737                                 ioh->fd_read(ioh->opaque, buf, n);
2738                             } else if (errno != EAGAIN) {
2739                                 ioh->fd_read(ioh->opaque, NULL, -errno);
2740                             }
2741                         }
2742                     }
2743                 }
2744             }
2745         }
2746 #endif /* !defined(_WIN32) */
2747 #if defined(CONFIG_SLIRP)
2748         /* XXX: merge with poll() */
2749         if (slirp_inited) {
2750             fd_set rfds, wfds, xfds;
2751             int nfds;
2752             struct timeval tv;
2753
2754             nfds = -1;
2755             FD_ZERO(&rfds);
2756             FD_ZERO(&wfds);
2757             FD_ZERO(&xfds);
2758             slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
2759             tv.tv_sec = 0;
2760             tv.tv_usec = 0;
2761             ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
2762             if (ret >= 0) {
2763                 slirp_select_poll(&rfds, &wfds, &xfds);
2764             }
2765         }
2766 #endif
2767
2768         if (vm_running) {
2769             qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
2770                             qemu_get_clock(vm_clock));
2771             /* run dma transfers, if any */
2772             DMA_run();
2773         }
2774
2775         /* real time timers */
2776         qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
2777                         qemu_get_clock(rt_clock));
2778 }
2779
2780 int main_loop(void)
2781 {
2782     int ret, timeout;
2783     CPUState *env = global_env;
2784
2785     for(;;) {
2786         if (vm_running) {
2787             ret = cpu_exec(env);
2788             if (shutdown_requested) {
2789                 ret = EXCP_INTERRUPT;
2790                 break;
2791             }
2792             if (reset_requested) {
2793                 reset_requested = 0;
2794                 qemu_system_reset();
2795                 ret = EXCP_INTERRUPT;
2796             }
2797             if (powerdown_requested) {
2798                 powerdown_requested = 0;
2799                 qemu_system_powerdown();
2800                 ret = EXCP_INTERRUPT;
2801             }
2802             if (ret == EXCP_DEBUG) {
2803                 vm_stop(EXCP_DEBUG);
2804             }
2805             /* if hlt instruction, we wait until the next IRQ */
2806             /* XXX: use timeout computed from timers */
2807             if (ret == EXCP_HLT)
2808                 timeout = 10;
2809             else
2810                 timeout = 0;
2811         } else {
2812             timeout = 10;
2813         }
2814         main_loop_wait(timeout);
2815     }
2816     cpu_disable_ticks();
2817     return ret;
2818 }
2819
2820 void help(void)
2821 {
2822     printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2005 Fabrice Bellard\n"
2823            "usage: %s [options] [disk_image]\n"
2824            "\n"
2825            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
2826            "\n"
2827            "Standard options:\n"
2828            "-M machine      select emulated machine (-M ? for list)\n"
2829            "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
2830            "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
2831            "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
2832            "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
2833            "-boot [a|c|d]   boot on floppy (a), hard disk (c) or CD-ROM (d)\n"
2834            "-snapshot       write to temporary files instead of disk image files\n"
2835            "-m megs         set virtual RAM size to megs MB [default=%d]\n"
2836            "-nographic      disable graphical output and redirect serial I/Os to console\n"
2837 #ifndef _WIN32
2838            "-k language     use keyboard layout (for example \"fr\" for French)\n"
2839 #endif
2840            "-enable-audio   enable audio support\n"
2841            "-localtime      set the real time clock to local time [default=utc]\n"
2842            "-full-screen    start in full screen\n"
2843 #ifdef TARGET_I386
2844            "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n"
2845 #endif
2846 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
2847            "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"
2848 #endif
2849            "\n"
2850            "Network options:\n"
2851            "-nics n         simulate 'n' network cards [default=1]\n"
2852            "-macaddr addr   set the mac address of the first interface\n"
2853            "-n script       set tap/tun network init script [default=%s]\n"
2854            "-tun-fd fd      use this fd as already opened tap/tun interface\n"
2855 #ifdef CONFIG_SLIRP
2856            "-user-net       use user mode network stack [default if no tap/tun script]\n"
2857            "-tftp prefix    allow tftp access to files starting with prefix [-user-net]\n"
2858 #ifndef _WIN32
2859            "-smb dir        allow SMB access to files in 'dir' [-user-net]\n"
2860 #endif
2861            "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
2862            "                redirect TCP or UDP connections from host to guest [-user-net]\n"
2863 #endif
2864            "-dummy-net      use dummy network stack\n"
2865            "\n"
2866            "Linux boot specific:\n"
2867            "-kernel bzImage use 'bzImage' as kernel image\n"
2868            "-append cmdline use 'cmdline' as kernel command line\n"
2869            "-initrd file    use 'file' as initial ram disk\n"
2870            "\n"
2871            "Debug/Expert options:\n"
2872            "-monitor dev    redirect the monitor to char device 'dev'\n"
2873            "-serial dev     redirect the serial port to char device 'dev'\n"
2874            "-parallel dev   redirect the parallel port to char device 'dev'\n"
2875            "-pidfile file   Write PID to 'file'\n"
2876            "-S              freeze CPU at startup (use 'c' to start execution)\n"
2877            "-s              wait gdb connection to port %d\n"
2878            "-p port         change gdb connection port\n"
2879            "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
2880            "-hdachs c,h,s[,t]  force hard disk 0 physical geometry and the optional BIOS\n"
2881            "                translation (t=none or lba) (usually qemu can guess them)\n"
2882            "-L path         set the directory for the BIOS and VGA BIOS\n"
2883 #ifdef USE_KQEMU
2884            "-no-kqemu       disable KQEMU kernel module usage\n"
2885 #endif
2886 #ifdef USE_CODE_COPY
2887            "-no-code-copy   disable code copy acceleration\n"
2888 #endif
2889 #ifdef TARGET_I386
2890            "-isa            simulate an ISA-only system (default is PCI system)\n"
2891            "-std-vga        simulate a standard VGA card with VESA Bochs Extensions\n"
2892            "                (default is CL-GD5446 PCI VGA)\n"
2893 #endif
2894            "-loadvm file    start right away with a saved state (loadvm in monitor)\n"
2895            "\n"
2896            "During emulation, the following keys are useful:\n"
2897            "ctrl-alt-f      toggle full screen\n"
2898            "ctrl-alt-n      switch to virtual console 'n'\n"
2899            "ctrl-alt        toggle mouse and keyboard grab\n"
2900            "\n"
2901            "When using -nographic, press 'ctrl-a h' to get some help.\n"
2902            ,
2903 #ifdef CONFIG_SOFTMMU
2904            "qemu",
2905 #else
2906            "qemu-fast",
2907 #endif
2908            DEFAULT_RAM_SIZE,
2909            DEFAULT_NETWORK_SCRIPT,
2910            DEFAULT_GDBSTUB_PORT,
2911            "/tmp/qemu.log");
2912 #ifndef CONFIG_SOFTMMU
2913     printf("\n"
2914            "NOTE: this version of QEMU is faster but it needs slightly patched OSes to\n"
2915            "work. Please use the 'qemu' executable to have a more accurate (but slower)\n"
2916            "PC emulation.\n");
2917 #endif
2918     exit(1);
2919 }
2920
2921 #define HAS_ARG 0x0001
2922
2923 enum {
2924     QEMU_OPTION_h,
2925
2926     QEMU_OPTION_M,
2927     QEMU_OPTION_fda,
2928     QEMU_OPTION_fdb,
2929     QEMU_OPTION_hda,
2930     QEMU_OPTION_hdb,
2931     QEMU_OPTION_hdc,
2932     QEMU_OPTION_hdd,
2933     QEMU_OPTION_cdrom,
2934     QEMU_OPTION_boot,
2935     QEMU_OPTION_snapshot,
2936     QEMU_OPTION_m,
2937     QEMU_OPTION_nographic,
2938     QEMU_OPTION_enable_audio,
2939
2940     QEMU_OPTION_nics,
2941     QEMU_OPTION_macaddr,
2942     QEMU_OPTION_n,
2943     QEMU_OPTION_tun_fd,
2944     QEMU_OPTION_user_net,
2945     QEMU_OPTION_tftp,
2946     QEMU_OPTION_smb,
2947     QEMU_OPTION_redir,
2948     QEMU_OPTION_dummy_net,
2949
2950     QEMU_OPTION_kernel,
2951     QEMU_OPTION_append,
2952     QEMU_OPTION_initrd,
2953
2954     QEMU_OPTION_S,
2955     QEMU_OPTION_s,
2956     QEMU_OPTION_p,
2957     QEMU_OPTION_d,
2958     QEMU_OPTION_hdachs,
2959     QEMU_OPTION_L,
2960     QEMU_OPTION_no_code_copy,
2961     QEMU_OPTION_pci,
2962     QEMU_OPTION_isa,
2963     QEMU_OPTION_prep,
2964     QEMU_OPTION_k,
2965     QEMU_OPTION_localtime,
2966     QEMU_OPTION_cirrusvga,
2967     QEMU_OPTION_g,
2968     QEMU_OPTION_std_vga,
2969     QEMU_OPTION_monitor,
2970     QEMU_OPTION_serial,
2971     QEMU_OPTION_parallel,
2972     QEMU_OPTION_loadvm,
2973     QEMU_OPTION_full_screen,
2974     QEMU_OPTION_pidfile,
2975     QEMU_OPTION_no_kqemu,
2976     QEMU_OPTION_win2k_hack,
2977 };
2978
2979 typedef struct QEMUOption {
2980     const char *name;
2981     int flags;
2982     int index;
2983 } QEMUOption;
2984
2985 const QEMUOption qemu_options[] = {
2986     { "h", 0, QEMU_OPTION_h },
2987
2988     { "M", HAS_ARG, QEMU_OPTION_M },
2989     { "fda", HAS_ARG, QEMU_OPTION_fda },
2990     { "fdb", HAS_ARG, QEMU_OPTION_fdb },
2991     { "hda", HAS_ARG, QEMU_OPTION_hda },
2992     { "hdb", HAS_ARG, QEMU_OPTION_hdb },
2993     { "hdc", HAS_ARG, QEMU_OPTION_hdc },
2994     { "hdd", HAS_ARG, QEMU_OPTION_hdd },
2995     { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
2996     { "boot", HAS_ARG, QEMU_OPTION_boot },
2997     { "snapshot", 0, QEMU_OPTION_snapshot },
2998     { "m", HAS_ARG, QEMU_OPTION_m },
2999     { "nographic", 0, QEMU_OPTION_nographic },
3000     { "k", HAS_ARG, QEMU_OPTION_k },
3001     { "enable-audio", 0, QEMU_OPTION_enable_audio },
3002
3003     { "nics", HAS_ARG, QEMU_OPTION_nics},
3004     { "macaddr", HAS_ARG, QEMU_OPTION_macaddr},
3005     { "n", HAS_ARG, QEMU_OPTION_n },
3006     { "tun-fd", HAS_ARG, QEMU_OPTION_tun_fd },
3007 #ifdef CONFIG_SLIRP
3008     { "user-net", 0, QEMU_OPTION_user_net },
3009     { "tftp", HAS_ARG, QEMU_OPTION_tftp },
3010 #ifndef _WIN32
3011     { "smb", HAS_ARG, QEMU_OPTION_smb },
3012 #endif
3013     { "redir", HAS_ARG, QEMU_OPTION_redir },
3014 #endif
3015     { "dummy-net", 0, QEMU_OPTION_dummy_net },
3016
3017     { "kernel", HAS_ARG, QEMU_OPTION_kernel },
3018     { "append", HAS_ARG, QEMU_OPTION_append },
3019     { "initrd", HAS_ARG, QEMU_OPTION_initrd },
3020
3021     { "S", 0, QEMU_OPTION_S },
3022     { "s", 0, QEMU_OPTION_s },
3023     { "p", HAS_ARG, QEMU_OPTION_p },
3024     { "d", HAS_ARG, QEMU_OPTION_d },
3025     { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
3026     { "L", HAS_ARG, QEMU_OPTION_L },
3027     { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
3028 #ifdef USE_KQEMU
3029     { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
3030 #endif
3031 #ifdef TARGET_PPC
3032     { "prep", 0, QEMU_OPTION_prep },
3033 #endif
3034 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
3035     { "g", 1, QEMU_OPTION_g },
3036 #endif
3037     { "localtime", 0, QEMU_OPTION_localtime },
3038     { "isa", 0, QEMU_OPTION_isa },
3039     { "std-vga", 0, QEMU_OPTION_std_vga },
3040     { "monitor", 1, QEMU_OPTION_monitor },
3041     { "serial", 1, QEMU_OPTION_serial },
3042     { "parallel", 1, QEMU_OPTION_parallel },
3043     { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
3044     { "full-screen", 0, QEMU_OPTION_full_screen },
3045     { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
3046     { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
3047
3048     /* temporary options */
3049     { "pci", 0, QEMU_OPTION_pci },
3050     { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
3051     { NULL },
3052 };
3053
3054 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
3055
3056 /* this stack is only used during signal handling */
3057 #define SIGNAL_STACK_SIZE 32768
3058
3059 static uint8_t *signal_stack;
3060
3061 #endif
3062
3063 /* password input */
3064
3065 static BlockDriverState *get_bdrv(int index)
3066 {
3067     BlockDriverState *bs;
3068
3069     if (index < 4) {
3070         bs = bs_table[index];
3071     } else if (index < 6) {
3072         bs = fd_table[index - 4];
3073     } else {
3074         bs = NULL;
3075     }
3076     return bs;
3077 }
3078
3079 static void read_passwords(void)
3080 {
3081     BlockDriverState *bs;
3082     int i, j;
3083     char password[256];
3084
3085     for(i = 0; i < 6; i++) {
3086         bs = get_bdrv(i);
3087         if (bs && bdrv_is_encrypted(bs)) {
3088             term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
3089             for(j = 0; j < 3; j++) {
3090                 monitor_readline("Password: ",
3091                                  1, password, sizeof(password));
3092                 if (bdrv_set_key(bs, password) == 0)
3093                     break;
3094                 term_printf("invalid password\n");
3095             }
3096         }
3097     }
3098 }
3099
3100 /* XXX: currently we cannot use simultaneously different CPUs */
3101 void register_machines(void)
3102 {
3103 #if defined(TARGET_I386)
3104     qemu_register_machine(&pc_machine);
3105 #elif defined(TARGET_PPC)
3106     qemu_register_machine(&heathrow_machine);
3107     qemu_register_machine(&core99_machine);
3108     qemu_register_machine(&prep_machine);
3109 #elif defined(TARGET_MIPS)
3110     qemu_register_machine(&mips_machine);
3111 #elif defined(TARGET_SPARC)
3112 #ifdef TARGET_SPARC64
3113     qemu_register_machine(&sun4u_machine);
3114 #else
3115     qemu_register_machine(&sun4m_machine);
3116 #endif
3117 #endif
3118 }
3119
3120 #define NET_IF_TUN   0
3121 #define NET_IF_USER  1
3122 #define NET_IF_DUMMY 2
3123
3124 int main(int argc, char **argv)
3125 {
3126 #ifdef CONFIG_GDBSTUB
3127     int use_gdbstub, gdbstub_port;
3128 #endif
3129     int i, cdrom_index;
3130     int snapshot, linux_boot;
3131     CPUState *env;
3132     const char *initrd_filename;
3133     const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
3134     const char *kernel_filename, *kernel_cmdline;
3135     DisplayState *ds = &display_state;
3136     int cyls, heads, secs, translation;
3137     int start_emulation = 1;
3138     uint8_t macaddr[6];
3139     int net_if_type, nb_tun_fds, tun_fds[MAX_NICS];
3140     int optind;
3141     const char *r, *optarg;
3142     CharDriverState *monitor_hd;
3143     char monitor_device[128];
3144     char serial_devices[MAX_SERIAL_PORTS][128];
3145     int serial_device_index;
3146     char parallel_devices[MAX_PARALLEL_PORTS][128];
3147     int parallel_device_index;
3148     const char *loadvm = NULL;
3149     QEMUMachine *machine;
3150
3151 #if !defined(CONFIG_SOFTMMU)
3152     /* we never want that malloc() uses mmap() */
3153     mallopt(M_MMAP_THRESHOLD, 4096 * 1024);
3154 #endif
3155     register_machines();
3156     machine = first_machine;
3157     initrd_filename = NULL;
3158     for(i = 0; i < MAX_FD; i++)
3159         fd_filename[i] = NULL;
3160     for(i = 0; i < MAX_DISKS; i++)
3161         hd_filename[i] = NULL;
3162     ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
3163     vga_ram_size = VGA_RAM_SIZE;
3164     bios_size = BIOS_SIZE;
3165     pstrcpy(network_script, sizeof(network_script), DEFAULT_NETWORK_SCRIPT);
3166 #ifdef CONFIG_GDBSTUB
3167     use_gdbstub = 0;
3168     gdbstub_port = DEFAULT_GDBSTUB_PORT;
3169 #endif
3170     snapshot = 0;
3171     nographic = 0;
3172     kernel_filename = NULL;
3173     kernel_cmdline = "";
3174 #ifdef TARGET_PPC
3175     cdrom_index = 1;
3176 #else
3177     cdrom_index = 2;
3178 #endif
3179     cyls = heads = secs = 0;
3180     translation = BIOS_ATA_TRANSLATION_AUTO;
3181     pstrcpy(monitor_device, sizeof(monitor_device), "vc");
3182
3183     pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
3184     for(i = 1; i < MAX_SERIAL_PORTS; i++)
3185         serial_devices[i][0] = '\0';
3186     serial_device_index = 0;
3187
3188     pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
3189     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
3190         parallel_devices[i][0] = '\0';
3191     parallel_device_index = 0;
3192
3193     nb_tun_fds = 0;
3194     net_if_type = -1;
3195     nb_nics = 1;
3196     /* default mac address of the first network interface */
3197     macaddr[0] = 0x52;
3198     macaddr[1] = 0x54;
3199     macaddr[2] = 0x00;
3200     macaddr[3] = 0x12;
3201     macaddr[4] = 0x34;
3202     macaddr[5] = 0x56;
3203
3204     optind = 1;
3205     for(;;) {
3206         if (optind >= argc)
3207             break;
3208         r = argv[optind];
3209         if (r[0] != '-') {
3210             hd_filename[0] = argv[optind++];
3211         } else {
3212             const QEMUOption *popt;
3213
3214             optind++;
3215             popt = qemu_options;
3216             for(;;) {
3217                 if (!popt->name) {
3218                     fprintf(stderr, "%s: invalid option -- '%s'\n",
3219                             argv[0], r);
3220                     exit(1);
3221                 }
3222                 if (!strcmp(popt->name, r + 1))
3223                     break;
3224                 popt++;
3225             }
3226             if (popt->flags & HAS_ARG) {
3227                 if (optind >= argc) {
3228                     fprintf(stderr, "%s: option '%s' requires an argument\n",
3229                             argv[0], r);
3230                     exit(1);
3231                 }
3232                 optarg = argv[optind++];
3233             } else {
3234                 optarg = NULL;
3235             }
3236
3237             switch(popt->index) {
3238             case QEMU_OPTION_M:
3239                 machine = find_machine(optarg);
3240                 if (!machine) {
3241                     QEMUMachine *m;
3242                     printf("Supported machines are:\n");
3243                     for(m = first_machine; m != NULL; m = m->next) {
3244                         printf("%-10s %s%s\n",
3245                                m->name, m->desc,
3246                                m == first_machine ? " (default)" : "");
3247                     }
3248                     exit(1);
3249                 }
3250                 break;
3251             case QEMU_OPTION_initrd:
3252                 initrd_filename = optarg;
3253                 break;
3254             case QEMU_OPTION_hda:
3255             case QEMU_OPTION_hdb:
3256             case QEMU_OPTION_hdc:
3257             case QEMU_OPTION_hdd:
3258                 {
3259                     int hd_index;
3260                     hd_index = popt->index - QEMU_OPTION_hda;
3261                     hd_filename[hd_index] = optarg;
3262                     if (hd_index == cdrom_index)
3263                         cdrom_index = -1;
3264                 }
3265                 break;
3266             case QEMU_OPTION_snapshot:
3267                 snapshot = 1;
3268                 break;
3269             case QEMU_OPTION_hdachs:
3270                 {
3271                     const char *p;
3272                     p = optarg;
3273                     cyls = strtol(p, (char **)&p, 0);
3274                     if (cyls < 1 || cyls > 16383)
3275                         goto chs_fail;
3276                     if (*p != ',')
3277                         goto chs_fail;
3278                     p++;
3279                     heads = strtol(p, (char **)&p, 0);
3280                     if (heads < 1 || heads > 16)
3281                         goto chs_fail;
3282                     if (*p != ',')
3283                         goto chs_fail;
3284                     p++;
3285                     secs = strtol(p, (char **)&p, 0);
3286                     if (secs < 1 || secs > 63)
3287                         goto chs_fail;
3288                     if (*p == ',') {
3289                         p++;
3290                         if (!strcmp(p, "none"))
3291                             translation = BIOS_ATA_TRANSLATION_NONE;
3292                         else if (!strcmp(p, "lba"))
3293                             translation = BIOS_ATA_TRANSLATION_LBA;
3294                         else if (!strcmp(p, "auto"))
3295                             translation = BIOS_ATA_TRANSLATION_AUTO;
3296                         else
3297                             goto chs_fail;
3298                     } else if (*p != '\0') {
3299                     chs_fail:
3300                         fprintf(stderr, "qemu: invalid physical CHS format\n");
3301                         exit(1);
3302                     }
3303                 }
3304                 break;
3305             case QEMU_OPTION_nographic:
3306                 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
3307                 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
3308                 nographic = 1;
3309                 break;
3310             case QEMU_OPTION_kernel:
3311                 kernel_filename = optarg;
3312                 break;
3313             case QEMU_OPTION_append:
3314                 kernel_cmdline = optarg;
3315                 break;
3316             case QEMU_OPTION_tun_fd:
3317                 {
3318                     const char *p;
3319                     int fd;
3320                     net_if_type = NET_IF_TUN;
3321                     if (nb_tun_fds < MAX_NICS) {
3322                         fd = strtol(optarg, (char **)&p, 0);
3323                         if (*p != '\0') {
3324                             fprintf(stderr, "qemu: invalid fd for network interface %d\n", nb_tun_fds);
3325                             exit(1);
3326                         }
3327                         tun_fds[nb_tun_fds++] = fd;
3328                     }
3329                 }
3330                 break;
3331             case QEMU_OPTION_cdrom:
3332                 if (cdrom_index >= 0) {
3333                     hd_filename[cdrom_index] = optarg;
3334                 }
3335                 break;
3336             case QEMU_OPTION_boot:
3337                 boot_device = optarg[0];
3338                 if (boot_device != 'a' &&
3339 #ifdef TARGET_SPARC
3340                     // Network boot
3341                     boot_device != 'n' &&
3342 #endif
3343                     boot_device != 'c' && boot_device != 'd') {
3344                     fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
3345                     exit(1);
3346                 }
3347                 break;
3348             case QEMU_OPTION_fda:
3349                 fd_filename[0] = optarg;
3350                 break;
3351             case QEMU_OPTION_fdb:
3352                 fd_filename[1] = optarg;
3353                 break;
3354             case QEMU_OPTION_no_code_copy:
3355                 code_copy_enabled = 0;
3356                 break;
3357             case QEMU_OPTION_nics:
3358                 nb_nics = atoi(optarg);
3359                 if (nb_nics < 0 || nb_nics > MAX_NICS) {
3360                     fprintf(stderr, "qemu: invalid number of network interfaces\n");
3361                     exit(1);
3362                 }
3363                 break;
3364             case QEMU_OPTION_macaddr:
3365                 {
3366                     const char *p;
3367                     int i;
3368                     p = optarg;
3369                     for(i = 0; i < 6; i++) {
3370                         macaddr[i] = strtol(p, (char **)&p, 16);
3371                         if (i == 5) {
3372                             if (*p != '\0')
3373                                 goto macaddr_error;
3374                         } else {
3375                             if (*p != ':') {
3376                             macaddr_error:
3377                                 fprintf(stderr, "qemu: invalid syntax for ethernet address\n");
3378                                 exit(1);
3379                             }
3380                             p++;
3381                         }
3382                     }
3383                 }
3384                 break;
3385 #ifdef CONFIG_SLIRP
3386             case QEMU_OPTION_tftp:
3387                 tftp_prefix = optarg;
3388                 break;
3389 #ifndef _WIN32
3390             case QEMU_OPTION_smb:
3391                 net_slirp_smb(optarg);
3392                 break;
3393 #endif
3394             case QEMU_OPTION_user_net:
3395                 net_if_type = NET_IF_USER;
3396                 break;
3397             case QEMU_OPTION_redir:
3398                 net_slirp_redir(optarg);
3399                 break;
3400 #endif
3401             case QEMU_OPTION_dummy_net:
3402                 net_if_type = NET_IF_DUMMY;
3403                 break;
3404             case QEMU_OPTION_enable_audio:
3405                 audio_enabled = 1;
3406                 break;
3407             case QEMU_OPTION_h:
3408                 help();
3409                 break;
3410             case QEMU_OPTION_m:
3411                 ram_size = atoi(optarg) * 1024 * 1024;
3412                 if (ram_size <= 0)
3413                     help();
3414                 if (ram_size > PHYS_RAM_MAX_SIZE) {
3415                     fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
3416                             PHYS_RAM_MAX_SIZE / (1024 * 1024));
3417                     exit(1);
3418                 }
3419                 break;
3420             case QEMU_OPTION_d:
3421                 {
3422                     int mask;
3423                     CPULogItem *item;
3424
3425                     mask = cpu_str_to_log_mask(optarg);
3426                     if (!mask) {
3427                         printf("Log items (comma separated):\n");
3428                     for(item = cpu_log_items; item->mask != 0; item++) {
3429                         printf("%-10s %s\n", item->name, item->help);
3430                     }
3431                     exit(1);
3432                     }
3433                     cpu_set_log(mask);
3434                 }
3435                 break;
3436             case QEMU_OPTION_n:
3437                 pstrcpy(network_script, sizeof(network_script), optarg);
3438                 break;
3439 #ifdef CONFIG_GDBSTUB
3440             case QEMU_OPTION_s:
3441                 use_gdbstub = 1;
3442                 break;
3443             case QEMU_OPTION_p:
3444                 gdbstub_port = atoi(optarg);
3445                 break;
3446 #endif
3447             case QEMU_OPTION_L:
3448                 bios_dir = optarg;
3449                 break;
3450             case QEMU_OPTION_S:
3451                 start_emulation = 0;
3452                 break;
3453             case QEMU_OPTION_pci:
3454                 pci_enabled = 1;
3455                 break;
3456             case QEMU_OPTION_isa:
3457                 pci_enabled = 0;
3458                 break;
3459             case QEMU_OPTION_prep:
3460                 prep_enabled = 1;
3461                 break;
3462             case QEMU_OPTION_k:
3463                 keyboard_layout = optarg;
3464                 break;
3465             case QEMU_OPTION_localtime:
3466                 rtc_utc = 0;
3467                 break;
3468             case QEMU_OPTION_cirrusvga:
3469                 cirrus_vga_enabled = 1;
3470                 break;
3471             case QEMU_OPTION_std_vga:
3472                 cirrus_vga_enabled = 0;
3473                 break;
3474             case QEMU_OPTION_g:
3475                 {
3476                     const char *p;
3477                     int w, h, depth;
3478                     p = optarg;
3479                     w = strtol(p, (char **)&p, 10);
3480                     if (w <= 0) {
3481                     graphic_error:
3482                         fprintf(stderr, "qemu: invalid resolution or depth\n");
3483                         exit(1);
3484                     }
3485                     if (*p != 'x')
3486                         goto graphic_error;
3487                     p++;
3488                     h = strtol(p, (char **)&p, 10);
3489                     if (h <= 0)
3490                         goto graphic_error;
3491                     if (*p == 'x') {
3492                         p++;
3493                         depth = strtol(p, (char **)&p, 10);
3494                         if (depth != 8 && depth != 15 && depth != 16 &&
3495                             depth != 24 && depth != 32)
3496                             goto graphic_error;
3497                     } else if (*p == '\0') {
3498                         depth = graphic_depth;
3499                     } else {
3500                         goto graphic_error;
3501                     }
3502
3503                     graphic_width = w;
3504                     graphic_height = h;
3505                     graphic_depth = depth;
3506                 }
3507                 break;
3508             case QEMU_OPTION_monitor:
3509                 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
3510                 break;
3511             case QEMU_OPTION_serial:
3512                 if (serial_device_index >= MAX_SERIAL_PORTS) {
3513                     fprintf(stderr, "qemu: too many serial ports\n");
3514                     exit(1);
3515                 }
3516                 pstrcpy(serial_devices[serial_device_index],
3517                         sizeof(serial_devices[0]), optarg);
3518                 serial_device_index++;
3519                 break;
3520             case QEMU_OPTION_parallel:
3521                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
3522                     fprintf(stderr, "qemu: too many parallel ports\n");
3523                     exit(1);
3524                 }
3525                 pstrcpy(parallel_devices[parallel_device_index],
3526                         sizeof(parallel_devices[0]), optarg);
3527                 parallel_device_index++;
3528                 break;
3529             case QEMU_OPTION_loadvm:
3530                 loadvm = optarg;
3531                 break;
3532             case QEMU_OPTION_full_screen:
3533                 full_screen = 1;
3534                 break;
3535             case QEMU_OPTION_pidfile:
3536                 create_pidfile(optarg);
3537                 break;
3538 #ifdef TARGET_I386
3539             case QEMU_OPTION_win2k_hack:
3540                 win2k_install_hack = 1;
3541                 break;
3542 #endif
3543 #ifdef USE_KQEMU
3544             case QEMU_OPTION_no_kqemu:
3545                 kqemu_allowed = 0;
3546                 break;
3547 #endif
3548             }
3549         }
3550     }
3551
3552     linux_boot = (kernel_filename != NULL);
3553
3554     if (!linux_boot &&
3555         hd_filename[0] == '\0' &&
3556         (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') &&
3557         fd_filename[0] == '\0')
3558         help();
3559
3560     /* boot to cd by default if no hard disk */
3561     if (hd_filename[0] == '\0' && boot_device == 'c') {
3562         if (fd_filename[0] != '\0')
3563             boot_device = 'a';
3564         else
3565             boot_device = 'd';
3566     }
3567
3568 #if !defined(CONFIG_SOFTMMU)
3569     /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
3570     {
3571         static uint8_t stdout_buf[4096];
3572         setvbuf(stdout, stdout_buf, _IOLBF, sizeof(stdout_buf));
3573     }
3574 #else
3575     setvbuf(stdout, NULL, _IOLBF, 0);
3576 #endif
3577
3578     /* init host network redirectors */
3579     if (net_if_type == -1) {
3580         net_if_type = NET_IF_TUN;
3581 #if defined(CONFIG_SLIRP)
3582         if (access(network_script, R_OK) < 0) {
3583             net_if_type = NET_IF_USER;
3584         }
3585 #endif
3586     }
3587
3588     for(i = 0; i < nb_nics; i++) {
3589         NetDriverState *nd = &nd_table[i];
3590         nd->index = i;
3591         /* init virtual mac address */
3592         nd->macaddr[0] = macaddr[0];
3593         nd->macaddr[1] = macaddr[1];
3594         nd->macaddr[2] = macaddr[2];
3595         nd->macaddr[3] = macaddr[3];
3596         nd->macaddr[4] = macaddr[4];
3597         nd->macaddr[5] = macaddr[5] + i;
3598         switch(net_if_type) {
3599 #if defined(CONFIG_SLIRP)
3600         case NET_IF_USER:
3601             net_slirp_init(nd);
3602             break;
3603 #endif
3604 #if !defined(_WIN32)
3605         case NET_IF_TUN:
3606             if (i < nb_tun_fds) {
3607                 net_fd_init(nd, tun_fds[i]);
3608             } else {
3609                 if (net_tun_init(nd) < 0)
3610                     net_dummy_init(nd);
3611             }
3612             break;
3613 #endif
3614         case NET_IF_DUMMY:
3615         default:
3616             net_dummy_init(nd);
3617             break;
3618         }
3619     }
3620
3621     /* init the memory */
3622     phys_ram_size = ram_size + vga_ram_size + bios_size;
3623
3624 #ifdef CONFIG_SOFTMMU
3625     phys_ram_base = qemu_vmalloc(phys_ram_size);
3626     if (!phys_ram_base) {
3627         fprintf(stderr, "Could not allocate physical memory\n");
3628         exit(1);
3629     }
3630 #else
3631     /* as we must map the same page at several addresses, we must use
3632        a fd */
3633     {
3634         const char *tmpdir;
3635
3636         tmpdir = getenv("QEMU_TMPDIR");
3637         if (!tmpdir)
3638             tmpdir = "/tmp";
3639         snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/vlXXXXXX", tmpdir);
3640         if (mkstemp(phys_ram_file) < 0) {
3641             fprintf(stderr, "Could not create temporary memory file '%s'\n",
3642                     phys_ram_file);
3643             exit(1);
3644         }
3645         phys_ram_fd = open(phys_ram_file, O_CREAT | O_TRUNC | O_RDWR, 0600);
3646         if (phys_ram_fd < 0) {
3647             fprintf(stderr, "Could not open temporary memory file '%s'\n",
3648                     phys_ram_file);
3649             exit(1);
3650         }
3651         ftruncate(phys_ram_fd, phys_ram_size);
3652         unlink(phys_ram_file);
3653         phys_ram_base = mmap(get_mmap_addr(phys_ram_size),
3654                              phys_ram_size,
3655                              PROT_WRITE | PROT_READ, MAP_SHARED | MAP_FIXED,
3656                              phys_ram_fd, 0);
3657         if (phys_ram_base == MAP_FAILED) {
3658             fprintf(stderr, "Could not map physical memory\n");
3659             exit(1);
3660         }
3661     }
3662 #endif
3663
3664     /* we always create the cdrom drive, even if no disk is there */
3665     bdrv_init();
3666     if (cdrom_index >= 0) {
3667         bs_table[cdrom_index] = bdrv_new("cdrom");
3668         bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM);
3669     }
3670
3671     /* open the virtual block devices */
3672     for(i = 0; i < MAX_DISKS; i++) {
3673         if (hd_filename[i]) {
3674             if (!bs_table[i]) {
3675                 char buf[64];
3676                 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
3677                 bs_table[i] = bdrv_new(buf);
3678             }
3679             if (bdrv_open(bs_table[i], hd_filename[i], snapshot) < 0) {
3680                 fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
3681                         hd_filename[i]);
3682                 exit(1);
3683             }
3684             if (i == 0 && cyls != 0) {
3685                 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
3686                 bdrv_set_translation_hint(bs_table[i], translation);
3687             }
3688         }
3689     }
3690
3691     /* we always create at least one floppy disk */
3692     fd_table[0] = bdrv_new("fda");
3693     bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
3694
3695     for(i = 0; i < MAX_FD; i++) {
3696         if (fd_filename[i]) {
3697             if (!fd_table[i]) {
3698                 char buf[64];
3699                 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
3700                 fd_table[i] = bdrv_new(buf);
3701                 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
3702             }
3703             if (fd_filename[i] != '\0') {
3704                 if (bdrv_open(fd_table[i], fd_filename[i], snapshot) < 0) {
3705                     fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
3706                             fd_filename[i]);
3707                     exit(1);
3708                 }
3709             }
3710         }
3711     }
3712
3713     /* init CPU state */
3714     env = cpu_init();
3715     global_env = env;
3716     cpu_single_env = env;
3717
3718     register_savevm("timer", 0, 1, timer_save, timer_load, env);
3719     register_savevm("cpu", 0, 3, cpu_save, cpu_load, env);
3720     register_savevm("ram", 0, 1, ram_save, ram_load, NULL);
3721     qemu_register_reset(main_cpu_reset, global_env);
3722
3723     init_ioports();
3724     cpu_calibrate_ticks();
3725
3726     /* terminal init */
3727     if (nographic) {
3728         dumb_display_init(ds);
3729     } else {
3730 #if defined(CONFIG_SDL)
3731         sdl_display_init(ds, full_screen);
3732 #elif defined(CONFIG_COCOA)
3733         cocoa_display_init(ds, full_screen);
3734 #else
3735         dumb_display_init(ds);
3736 #endif
3737     }
3738
3739     vga_console = graphic_console_init(ds);
3740
3741     monitor_hd = qemu_chr_open(monitor_device);
3742     if (!monitor_hd) {
3743         fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
3744         exit(1);
3745     }
3746     monitor_init(monitor_hd, !nographic);
3747
3748     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
3749         if (serial_devices[i][0] != '\0') {
3750             serial_hds[i] = qemu_chr_open(serial_devices[i]);
3751             if (!serial_hds[i]) {
3752                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
3753                         serial_devices[i]);
3754                 exit(1);
3755             }
3756             if (!strcmp(serial_devices[i], "vc"))
3757                 qemu_chr_printf(serial_hds[i], "serial%d console\n", i);
3758         }
3759     }
3760
3761     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
3762         if (parallel_devices[i][0] != '\0') {
3763             parallel_hds[i] = qemu_chr_open(parallel_devices[i]);
3764             if (!parallel_hds[i]) {
3765                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
3766                         parallel_devices[i]);
3767                 exit(1);
3768             }
3769             if (!strcmp(parallel_devices[i], "vc"))
3770                 qemu_chr_printf(parallel_hds[i], "parallel%d console\n", i);
3771         }
3772     }
3773
3774     /* setup cpu signal handlers for MMU / self modifying code handling */
3775 #if !defined(CONFIG_SOFTMMU)
3776
3777 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
3778     {
3779         stack_t stk;
3780         signal_stack = memalign(16, SIGNAL_STACK_SIZE);
3781         stk.ss_sp = signal_stack;
3782         stk.ss_size = SIGNAL_STACK_SIZE;
3783         stk.ss_flags = 0;
3784
3785         if (sigaltstack(&stk, NULL) < 0) {
3786             perror("sigaltstack");
3787             exit(1);
3788         }
3789     }
3790 #endif
3791     {
3792         struct sigaction act;
3793
3794         sigfillset(&act.sa_mask);
3795         act.sa_flags = SA_SIGINFO;
3796 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
3797         act.sa_flags |= SA_ONSTACK;
3798 #endif
3799         act.sa_sigaction = host_segv_handler;
3800         sigaction(SIGSEGV, &act, NULL);
3801         sigaction(SIGBUS, &act, NULL);
3802 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
3803         sigaction(SIGFPE, &act, NULL);
3804 #endif
3805     }
3806 #endif
3807
3808 #ifndef _WIN32
3809     {
3810         struct sigaction act;
3811         sigfillset(&act.sa_mask);
3812         act.sa_flags = 0;
3813         act.sa_handler = SIG_IGN;
3814         sigaction(SIGPIPE, &act, NULL);
3815     }
3816 #endif
3817     init_timers();
3818
3819     machine->init(ram_size, vga_ram_size, boot_device,
3820                   ds, fd_filename, snapshot,
3821                   kernel_filename, kernel_cmdline, initrd_filename);
3822
3823     gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
3824     qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
3825
3826 #ifdef CONFIG_GDBSTUB
3827     if (use_gdbstub) {
3828         if (gdbserver_start(gdbstub_port) < 0) {
3829             fprintf(stderr, "Could not open gdbserver socket on port %d\n",
3830                     gdbstub_port);
3831             exit(1);
3832         } else {
3833             printf("Waiting gdb connection on port %d\n", gdbstub_port);
3834         }
3835     } else
3836 #endif
3837     if (loadvm)
3838         qemu_loadvm(loadvm);
3839
3840     {
3841         /* XXX: simplify init */
3842         read_passwords();
3843         if (start_emulation) {
3844             vm_start();
3845         }
3846     }
3847     main_loop();
3848     quit_timers();
3849     return 0;
3850 }