vl.c 156.6 KB
Newer Older
1
/*
B
bellard 已提交
2
 * QEMU System Emulator
3
 *
B
bellard 已提交
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
B
bellard 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
23 24 25 26 27 28
 */
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
B
bellard 已提交
29
#include <sys/time.h>
30
#include <zlib.h>
B
bellard 已提交
31

J
Juan Quintela 已提交
32
/* Needed early for CONFIG_BSD etc. */
B
blueswir1 已提交
33
#include "config-host.h"
B
Blue Swirl 已提交
34 35
/* Needed early to override system queue definitions on BSD */
#include "sys-queue.h"
B
blueswir1 已提交
36

B
bellard 已提交
37
#ifndef _WIN32
P
Paul Brook 已提交
38
#include <libgen.h>
39
#include <pwd.h>
B
bellard 已提交
40
#include <sys/times.h>
B
bellard 已提交
41
#include <sys/wait.h>
B
bellard 已提交
42 43
#include <termios.h>
#include <sys/mman.h>
B
bellard 已提交
44
#include <sys/ioctl.h>
B
blueswir1 已提交
45
#include <sys/resource.h>
B
bellard 已提交
46
#include <sys/socket.h>
B
bellard 已提交
47
#include <netinet/in.h>
B
blueswir1 已提交
48 49 50 51 52 53 54 55
#include <net/if.h>
#if defined(__NetBSD__)
#include <net/if_tap.h>
#endif
#ifdef __linux__
#include <linux/if_tun.h>
#endif
#include <arpa/inet.h>
B
bellard 已提交
56
#include <dirent.h>
B
bellard 已提交
57
#include <netdb.h>
58
#include <sys/select.h>
J
Juan Quintela 已提交
59
#ifdef CONFIG_BSD
B
bellard 已提交
60
#include <sys/stat.h>
61
#if defined(__FreeBSD__) || defined(__DragonFly__)
B
bellard 已提交
62
#include <libutil.h>
B
blueswir1 已提交
63 64
#else
#include <util.h>
65
#endif
T
ths 已提交
66 67
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
#include <freebsd/stdlib.h>
B
bellard 已提交
68
#else
69
#ifdef __linux__
B
bellard 已提交
70 71
#include <pty.h>
#include <malloc.h>
72
#include <linux/rtc.h>
A
Andi Kleen 已提交
73
#include <sys/prctl.h>
T
ths 已提交
74 75 76 77 78 79

/* For the benefit of older linux systems which don't supply it,
   we use a local copy of hpet.h. */
/* #include <linux/hpet.h> */
#include "hpet.h"

B
bellard 已提交
80
#include <linux/ppdev.h>
81
#include <linux/parport.h>
82 83
#endif
#ifdef __sun__
84 85 86 87 88 89 90 91 92 93 94 95 96
#include <sys/stat.h>
#include <sys/ethernet.h>
#include <sys/sockio.h>
#include <netinet/arp.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h> // must come after ip.h
#include <netinet/udp.h>
#include <netinet/tcp.h>
#include <net/if.h>
#include <syslog.h>
#include <stropts.h>
B
bellard 已提交
97
#endif
B
bellard 已提交
98
#endif
B
bellard 已提交
99
#endif
B
bellard 已提交
100

101 102 103 104
#if defined(__OpenBSD__)
#include <util.h>
#endif

105 106 107 108
#if defined(CONFIG_VDE)
#include <libvdeplug.h>
#endif

B
bellard 已提交
109
#ifdef _WIN32
110
#include <windows.h>
T
ths 已提交
111
#include <mmsystem.h>
B
bellard 已提交
112 113
#endif

B
bellard 已提交
114
#ifdef CONFIG_SDL
S
Stefan Weil 已提交
115
#if defined(__APPLE__) || defined(main)
S
Stefan Weil 已提交
116
#include <SDL.h>
M
malc 已提交
117 118 119
int qemu_main(int argc, char **argv, char **envp);
int main(int argc, char **argv)
{
S
Stefan Weil 已提交
120
    return qemu_main(argc, argv, NULL);
M
malc 已提交
121 122 123
}
#undef main
#define main qemu_main
B
bellard 已提交
124
#endif
B
bellard 已提交
125
#endif /* CONFIG_SDL */
126

127 128 129 130 131
#ifdef CONFIG_COCOA
#undef main
#define main qemu_main
#endif /* CONFIG_COCOA */

132 133 134 135 136 137 138 139 140
#include "hw/hw.h"
#include "hw/boards.h"
#include "hw/usb.h"
#include "hw/pcmcia.h"
#include "hw/pc.h"
#include "hw/audiodev.h"
#include "hw/isa.h"
#include "hw/baum.h"
#include "hw/bt.h"
R
Richard W.M. Jones 已提交
141
#include "hw/watchdog.h"
142
#include "hw/smbios.h"
143
#include "hw/xen.h"
144
#include "hw/qdev.h"
A
aurel32 已提交
145
#include "bt-host.h"
146 147 148 149 150 151 152 153 154
#include "net.h"
#include "monitor.h"
#include "console.h"
#include "sysemu.h"
#include "gdbstub.h"
#include "qemu-timer.h"
#include "qemu-char.h"
#include "cache-utils.h"
#include "block.h"
B
blueswir1 已提交
155
#include "dma.h"
156 157 158 159
#include "audio/audio.h"
#include "migration.h"
#include "kvm.h"
#include "balloon.h"
K
Kevin Wolf 已提交
160
#include "qemu-option.h"
G
Gerd Hoffmann 已提交
161
#include "qemu-config.h"
162

163
#include "disas.h"
B
bellard 已提交
164

165
#include "exec-all.h"
166

167 168
#include "qemu_socket.h"

J
Jan Kiszka 已提交
169
#include "slirp/libslirp.h"
170

171 172
//#define DEBUG_NET
//#define DEBUG_SLIRP
173

174
#define DEFAULT_RAM_SIZE 128
175

176 177 178
/* Maximum number of monitor devices */
#define MAX_MONITOR_DEVICES 10

P
Paul Brook 已提交
179
static const char *data_dir;
180
const char *bios_name = NULL;
T
ths 已提交
181
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
B
bellard 已提交
182
   to store the VM snapshots */
G
Gerd Hoffmann 已提交
183
struct drivelist drives = TAILQ_HEAD_INITIALIZER(drives);
G
Gerd Hoffmann 已提交
184
struct driveoptlist driveopts = TAILQ_HEAD_INITIALIZER(driveopts);
M
malc 已提交
185
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
186
static DisplayState *display_state;
187
DisplayType display_type = DT_DEFAULT;
188
const char* keyboard_layout = NULL;
189
int64_t ticks_per_sec;
190
ram_addr_t ram_size;
191
int nb_nics;
B
bellard 已提交
192
NICInfo nd_table[MAX_NICS];
193
int vm_running;
P
Paolo Bonzini 已提交
194
int autostart;
195 196
static int rtc_utc = 1;
static int rtc_date_offset = -1; /* -1 means no change */
197
int vga_interface_type = VGA_CIRRUS;
198 199 200
#ifdef TARGET_SPARC
int graphic_width = 1024;
int graphic_height = 768;
B
blueswir1 已提交
201
int graphic_depth = 8;
202
#else
203 204
int graphic_width = 800;
int graphic_height = 600;
205
int graphic_depth = 15;
B
blueswir1 已提交
206
#endif
B
blueswir1 已提交
207
static int full_screen = 0;
208
#ifdef CONFIG_SDL
B
blueswir1 已提交
209
static int no_frame = 0;
210
#endif
T
ths 已提交
211
int no_quit = 0;
212
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
213
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
214
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
215 216
#ifdef TARGET_I386
int win2k_install_hack = 0;
217
int rtc_td_hack = 0;
218
#endif
B
bellard 已提交
219
int usb_enabled = 0;
220
int singlestep = 0;
B
bellard 已提交
221
int smp_cpus = 1;
222
int max_cpus = 0;
223 224
int smp_cores = 1;
int smp_threads = 1;
225
const char *vnc_display;
B
bellard 已提交
226
int acpi_enabled = 1;
A
aliguori 已提交
227
int no_hpet = 0;
B
bellard 已提交
228
int fd_bootchk = 1;
B
bellard 已提交
229
int no_reboot = 0;
A
aurel32 已提交
230
int no_shutdown = 0;
231
int cursor_hide = 1;
232
int graphic_rotate = 0;
J
Jes Sorensen 已提交
233
uint8_t irq0override = 1;
B
blueswir1 已提交
234
#ifndef _WIN32
T
ths 已提交
235
int daemonize = 0;
B
blueswir1 已提交
236
#endif
M
Markus Armbruster 已提交
237
const char *watchdog;
238 239
const char *option_rom[MAX_OPTION_ROMS];
int nb_option_roms;
240
int semihosting_enabled = 0;
241 242 243
#ifdef TARGET_ARM
int old_param = 0;
#endif
T
ths 已提交
244
const char *qemu_name;
T
ths 已提交
245
int alt_grab = 0;
246
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
B
blueswir1 已提交
247 248 249
unsigned int nb_prom_envs = 0;
const char *prom_envs[MAX_PROM_ENVS];
#endif
250
int boot_menu;
251

252 253 254 255
int nb_numa_nodes;
uint64_t node_mem[MAX_NODES];
uint64_t node_cpumask[MAX_NODES];

256 257
static CPUState *cur_cpu;
static CPUState *next_cpu;
258
static int timer_alarm_pending = 1;
T
ths 已提交
259
/* Conversion factor from emulated instructions to virtual clock ticks.  */
P
pbrook 已提交
260
static int icount_time_shift;
T
ths 已提交
261
/* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
P
pbrook 已提交
262 263 264
#define MAX_ICOUNT_SHIFT 10
/* Compensate for varying guest execution speed.  */
static int64_t qemu_icount_bias;
B
blueswir1 已提交
265 266
static QEMUTimer *icount_rt_timer;
static QEMUTimer *icount_vm_timer;
B
blueswir1 已提交
267
static QEMUTimer *nographic_timer;
268

269 270
uint8_t qemu_uuid[16];

J
Jan Kiszka 已提交
271 272 273
static QEMUBootSetHandler *boot_set_handler;
static void *boot_set_opaque;

274
/***********************************************************/
275 276 277
/* x86 ISA bus support */

target_phys_addr_t isa_mem_base = 0;
B
bellard 已提交
278
PicState2 *isa_pic;
279 280 281 282 283

/***********************************************************/
void hw_error(const char *fmt, ...)
{
    va_list ap;
B
bellard 已提交
284
    CPUState *env;
285 286 287 288 289

    va_start(ap, fmt);
    fprintf(stderr, "qemu: hardware error: ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
B
bellard 已提交
290 291
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
292
#ifdef TARGET_I386
B
bellard 已提交
293
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
294
#else
B
bellard 已提交
295
        cpu_dump_state(env, stderr, fprintf, 0);
296
#endif
B
bellard 已提交
297
    }
298 299 300
    va_end(ap);
    abort();
}
A
Andi Kleen 已提交
301 302 303

static void set_proc_name(const char *s)
{
304
#if defined(__linux__) && defined(PR_SET_NAME)
A
Andi Kleen 已提交
305 306 307 308 309 310 311 312 313 314
    char name[16];
    if (!s)
        return;
    name[sizeof(name) - 1] = 0;
    strncpy(name, s, sizeof(name));
    /* Could rewrite argv[0] too, but that's a bit more complicated.
       This simple way is enough for `top'. */
    prctl(PR_SET_NAME, name);
#endif    	
}
A
aliguori 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
 
/***************/
/* ballooning */

static QEMUBalloonEvent *qemu_balloon_event;
void *qemu_balloon_event_opaque;

void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
{
    qemu_balloon_event = func;
    qemu_balloon_event_opaque = opaque;
}

void qemu_balloon(ram_addr_t target)
{
    if (qemu_balloon_event)
        qemu_balloon_event(qemu_balloon_event_opaque, target);
}

ram_addr_t qemu_balloon_status(void)
{
    if (qemu_balloon_event)
        return qemu_balloon_event(qemu_balloon_event_opaque, 0);
    return 0;
}
340

B
bellard 已提交
341 342 343 344 345
/***********************************************************/
/* keyboard/mouse */

static QEMUPutKBDEvent *qemu_put_kbd_event;
static void *qemu_put_kbd_event_opaque;
346 347
static QEMUPutMouseEntry *qemu_put_mouse_event_head;
static QEMUPutMouseEntry *qemu_put_mouse_event_current;
B
bellard 已提交
348 349 350 351 352 353 354

void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
{
    qemu_put_kbd_event_opaque = opaque;
    qemu_put_kbd_event = func;
}

355 356 357
QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
                                                void *opaque, int absolute,
                                                const char *name)
B
bellard 已提交
358
{
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
    QEMUPutMouseEntry *s, *cursor;

    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));

    s->qemu_put_mouse_event = func;
    s->qemu_put_mouse_event_opaque = opaque;
    s->qemu_put_mouse_event_absolute = absolute;
    s->qemu_put_mouse_event_name = qemu_strdup(name);
    s->next = NULL;

    if (!qemu_put_mouse_event_head) {
        qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
        return s;
    }

    cursor = qemu_put_mouse_event_head;
    while (cursor->next != NULL)
        cursor = cursor->next;

    cursor->next = s;
    qemu_put_mouse_event_current = s;

    return s;
}

void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
{
    QEMUPutMouseEntry *prev = NULL, *cursor;

    if (!qemu_put_mouse_event_head || entry == NULL)
        return;

    cursor = qemu_put_mouse_event_head;
    while (cursor != NULL && cursor != entry) {
        prev = cursor;
        cursor = cursor->next;
    }

    if (cursor == NULL) // does not exist or list empty
        return;
    else if (prev == NULL) { // entry is head
        qemu_put_mouse_event_head = cursor->next;
        if (qemu_put_mouse_event_current == entry)
            qemu_put_mouse_event_current = cursor->next;
        qemu_free(entry->qemu_put_mouse_event_name);
        qemu_free(entry);
        return;
    }

    prev->next = entry->next;

    if (qemu_put_mouse_event_current == entry)
        qemu_put_mouse_event_current = prev;

    qemu_free(entry->qemu_put_mouse_event_name);
    qemu_free(entry);
B
bellard 已提交
415 416 417 418 419 420 421 422 423 424 425
}

void kbd_put_keycode(int keycode)
{
    if (qemu_put_kbd_event) {
        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
    }
}

void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
{
426 427
    QEMUPutMouseEvent *mouse_event;
    void *mouse_event_opaque;
428
    int width;
429 430 431 432 433 434 435 436 437 438 439

    if (!qemu_put_mouse_event_current) {
        return;
    }

    mouse_event =
        qemu_put_mouse_event_current->qemu_put_mouse_event;
    mouse_event_opaque =
        qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;

    if (mouse_event) {
440 441 442 443
        if (graphic_rotate) {
            if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
                width = 0x7fff;
            else
444
                width = graphic_width - 1;
445 446 447 448 449
            mouse_event(mouse_event_opaque,
                                 width - dy, dx, dz, buttons_state);
        } else
            mouse_event(mouse_event_opaque,
                                 dx, dy, dz, buttons_state);
B
bellard 已提交
450 451 452
    }
}

453 454
int kbd_mouse_is_absolute(void)
{
455 456 457 458 459 460
    if (!qemu_put_mouse_event_current)
        return 0;

    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
}

A
aliguori 已提交
461
void do_info_mice(Monitor *mon)
462 463 464 465 466
{
    QEMUPutMouseEntry *cursor;
    int index = 0;

    if (!qemu_put_mouse_event_head) {
A
aliguori 已提交
467
        monitor_printf(mon, "No mouse devices connected\n");
468 469 470
        return;
    }

A
aliguori 已提交
471
    monitor_printf(mon, "Mouse devices available:\n");
472 473
    cursor = qemu_put_mouse_event_head;
    while (cursor != NULL) {
A
aliguori 已提交
474 475 476
        monitor_printf(mon, "%c Mouse #%d: %s\n",
                       (cursor == qemu_put_mouse_event_current ? '*' : ' '),
                       index, cursor->qemu_put_mouse_event_name);
477 478 479 480 481
        index++;
        cursor = cursor->next;
    }
}

482
void do_mouse_set(Monitor *mon, const QDict *qdict)
483 484 485
{
    QEMUPutMouseEntry *cursor;
    int i = 0;
486
    int index = qdict_get_int(qdict, "index");
487 488

    if (!qemu_put_mouse_event_head) {
A
aliguori 已提交
489
        monitor_printf(mon, "No mouse devices connected\n");
490 491 492 493 494 495 496 497 498 499 500 501
        return;
    }

    cursor = qemu_put_mouse_event_head;
    while (cursor != NULL && index != i) {
        i++;
        cursor = cursor->next;
    }

    if (cursor != NULL)
        qemu_put_mouse_event_current = cursor;
    else
A
aliguori 已提交
502
        monitor_printf(mon, "Mouse at given index not found\n");
503 504
}

505 506
/* compute with 96 bit intermediate result: (a*b)/c */
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
507
{
508 509 510
    union {
        uint64_t ll;
        struct {
511
#ifdef HOST_WORDS_BIGENDIAN
512 513 514
            uint32_t high, low;
#else
            uint32_t low, high;
515
#endif
516 517 518
        } l;
    } u, res;
    uint64_t rl, rh;
519

520 521 522 523 524 525 526
    u.ll = a;
    rl = (uint64_t)u.l.low * (uint64_t)b;
    rh = (uint64_t)u.l.high * (uint64_t)b;
    rh += (rl >> 32);
    res.l.high = rh / c;
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
    return res.ll;
527 528
}

529 530
/***********************************************************/
/* real time host monotonic timer */
531

532
#define QEMU_TIMER_BASE 1000000000LL
533

534
#ifdef WIN32
535

536
static int64_t clock_freq;
B
bellard 已提交
537

538
static void init_get_clock(void)
B
bellard 已提交
539
{
540 541
    LARGE_INTEGER freq;
    int ret;
542 543 544 545 546 547
    ret = QueryPerformanceFrequency(&freq);
    if (ret == 0) {
        fprintf(stderr, "Could not calibrate ticks\n");
        exit(1);
    }
    clock_freq = freq.QuadPart;
B
bellard 已提交
548 549
}

550
static int64_t get_clock(void)
B
bellard 已提交
551
{
552 553 554
    LARGE_INTEGER ti;
    QueryPerformanceCounter(&ti);
    return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
B
bellard 已提交
555 556
}

557
#else
B
bellard 已提交
558

559 560 561
static int use_rt_clock;

static void init_get_clock(void)
B
bellard 已提交
562
{
563
    use_rt_clock = 0;
564 565
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
    || defined(__DragonFly__)
566 567 568 569 570 571 572
    {
        struct timespec ts;
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
            use_rt_clock = 1;
        }
    }
#endif
B
bellard 已提交
573 574
}

575
static int64_t get_clock(void)
B
bellard 已提交
576
{
577 578
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
	|| defined(__DragonFly__)
579 580 581 582
    if (use_rt_clock) {
        struct timespec ts;
        clock_gettime(CLOCK_MONOTONIC, &ts);
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
583
    } else
B
bellard 已提交
584
#endif
585 586 587 588 589 590 591
    {
        /* XXX: using gettimeofday leads to problems if the date
           changes, so it should be avoided. */
        struct timeval tv;
        gettimeofday(&tv, NULL);
        return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
    }
B
bellard 已提交
592
}
593 594
#endif

P
pbrook 已提交
595 596 597 598 599 600 601 602 603 604 605 606 607 608
/* Return the virtual CPU time, based on the instruction counter.  */
static int64_t cpu_get_icount(void)
{
    int64_t icount;
    CPUState *env = cpu_single_env;;
    icount = qemu_icount;
    if (env) {
        if (!can_do_io(env))
            fprintf(stderr, "Bad clock read\n");
        icount -= (env->icount_decr.u16.low + env->icount_extra);
    }
    return qemu_icount_bias + (icount << icount_time_shift);
}

609 610 611
/***********************************************************/
/* guest cycle counter */

612
static int64_t cpu_ticks_prev;
613
static int64_t cpu_ticks_offset;
614
static int64_t cpu_clock_offset;
615
static int cpu_ticks_enabled;
616

617 618
/* return the host CPU cycle counter and handle stop/restart */
int64_t cpu_get_ticks(void)
619
{
P
pbrook 已提交
620 621 622
    if (use_icount) {
        return cpu_get_icount();
    }
623 624 625
    if (!cpu_ticks_enabled) {
        return cpu_ticks_offset;
    } else {
626 627 628 629 630 631 632 633 634
        int64_t ticks;
        ticks = cpu_get_real_ticks();
        if (cpu_ticks_prev > ticks) {
            /* Note: non increasing ticks may happen if the host uses
               software suspend */
            cpu_ticks_offset += cpu_ticks_prev - ticks;
        }
        cpu_ticks_prev = ticks;
        return ticks + cpu_ticks_offset;
635
    }
636 637
}

638 639 640 641 642 643 644 645 646 647 648 649
/* return the host CPU monotonic timer and handle stop/restart */
static int64_t cpu_get_clock(void)
{
    int64_t ti;
    if (!cpu_ticks_enabled) {
        return cpu_clock_offset;
    } else {
        ti = get_clock();
        return ti + cpu_clock_offset;
    }
}

650 651 652
/* enable cpu_get_ticks() */
void cpu_enable_ticks(void)
{
653 654
    if (!cpu_ticks_enabled) {
        cpu_ticks_offset -= cpu_get_real_ticks();
655
        cpu_clock_offset -= get_clock();
656 657
        cpu_ticks_enabled = 1;
    }
658 659 660 661 662 663
}

/* disable cpu_get_ticks() : the clock is stopped. You must not call
   cpu_get_ticks() after that.  */
void cpu_disable_ticks(void)
{
664 665
    if (cpu_ticks_enabled) {
        cpu_ticks_offset = cpu_get_ticks();
666
        cpu_clock_offset = cpu_get_clock();
667 668
        cpu_ticks_enabled = 0;
    }
669 670
}

671 672
/***********************************************************/
/* timers */
673

674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
#define QEMU_TIMER_REALTIME 0
#define QEMU_TIMER_VIRTUAL  1

struct QEMUClock {
    int type;
    /* XXX: add frequency */
};

struct QEMUTimer {
    QEMUClock *clock;
    int64_t expire_time;
    QEMUTimerCB *cb;
    void *opaque;
    struct QEMUTimer *next;
};

690 691
struct qemu_alarm_timer {
    char const *name;
692
    unsigned int flags;
693 694 695

    int (*start)(struct qemu_alarm_timer *t);
    void (*stop)(struct qemu_alarm_timer *t);
696
    void (*rearm)(struct qemu_alarm_timer *t);
697 698 699
    void *priv;
};

700
#define ALARM_FLAG_DYNTICKS  0x1
701
#define ALARM_FLAG_EXPIRED   0x2
702 703 704

static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
{
705
    return t && (t->flags & ALARM_FLAG_DYNTICKS);
706 707 708 709 710 711 712 713 714 715 716 717 718
}

static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
{
    if (!alarm_has_dynticks(t))
        return;

    t->rearm(t);
}

/* TODO: MIN_TIMER_REARM_US should be optimized */
#define MIN_TIMER_REARM_US 250

719
static struct qemu_alarm_timer *alarm_timer;
720

B
bellard 已提交
721
#ifdef _WIN32
722 723 724 725

struct qemu_alarm_win32 {
    MMRESULT timerId;
    unsigned int period;
B
Blue Swirl 已提交
726
} alarm_win32_data = {0, -1};
727 728 729

static int win32_start_timer(struct qemu_alarm_timer *t);
static void win32_stop_timer(struct qemu_alarm_timer *t);
730
static void win32_rearm_timer(struct qemu_alarm_timer *t);
731

B
bellard 已提交
732
#else
733 734 735 736

static int unix_start_timer(struct qemu_alarm_timer *t);
static void unix_stop_timer(struct qemu_alarm_timer *t);

737 738
#ifdef __linux__

739 740 741 742
static int dynticks_start_timer(struct qemu_alarm_timer *t);
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);

T
ths 已提交
743 744 745
static int hpet_start_timer(struct qemu_alarm_timer *t);
static void hpet_stop_timer(struct qemu_alarm_timer *t);

746 747 748
static int rtc_start_timer(struct qemu_alarm_timer *t);
static void rtc_stop_timer(struct qemu_alarm_timer *t);

749
#endif /* __linux__ */
750

751 752
#endif /* _WIN32 */

P
pbrook 已提交
753
/* Correlation between real and virtual time is always going to be
T
ths 已提交
754
   fairly approximate, so ignore small variation.
P
pbrook 已提交
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
   When the guest is idle real and virtual time will be aligned in
   the IO wait loop.  */
#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)

static void icount_adjust(void)
{
    int64_t cur_time;
    int64_t cur_icount;
    int64_t delta;
    static int64_t last_delta;
    /* If the VM is not running, then do nothing.  */
    if (!vm_running)
        return;

    cur_time = cpu_get_clock();
    cur_icount = qemu_get_clock(vm_clock);
    delta = cur_icount - cur_time;
    /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
    if (delta > 0
        && last_delta + ICOUNT_WOBBLE < delta * 2
        && icount_time_shift > 0) {
        /* The guest is getting too far ahead.  Slow time down.  */
        icount_time_shift--;
    }
    if (delta < 0
        && last_delta - ICOUNT_WOBBLE > delta * 2
        && icount_time_shift < MAX_ICOUNT_SHIFT) {
        /* The guest is getting too far behind.  Speed time up.  */
        icount_time_shift++;
    }
    last_delta = delta;
    qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
}

static void icount_adjust_rt(void * opaque)
{
    qemu_mod_timer(icount_rt_timer,
                   qemu_get_clock(rt_clock) + 1000);
    icount_adjust();
}

static void icount_adjust_vm(void * opaque)
{
    qemu_mod_timer(icount_vm_timer,
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
    icount_adjust();
}

static void init_icount_adjust(void)
{
    /* Have both realtime and virtual time triggers for speed adjustment.
       The realtime trigger catches emulated time passing too slowly,
       the virtual time trigger catches emulated time passing too fast.
       Realtime triggers occur even when idle, so use them less frequently
       than VM triggers.  */
    icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
    qemu_mod_timer(icount_rt_timer,
                   qemu_get_clock(rt_clock) + 1000);
    icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
    qemu_mod_timer(icount_vm_timer,
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
}

818
static struct qemu_alarm_timer alarm_timers[] = {
819
#ifndef _WIN32
820
#ifdef __linux__
821 822
    {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
     dynticks_stop_timer, dynticks_rearm_timer, NULL},
T
ths 已提交
823
    /* HPET - if available - is preferred */
824
    {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
T
ths 已提交
825
    /* ...otherwise try RTC */
826
    {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
827
#endif
828
    {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
829
#else
830 831 832 833
    {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
     win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
    {"win32", 0, win32_start_timer,
     win32_stop_timer, NULL, &alarm_win32_data},
834 835 836 837
#endif
    {NULL, }
};

838
static void show_available_alarms(void)
839 840 841 842 843 844 845 846 847 848 849 850
{
    int i;

    printf("Available alarm timers, in order of precedence:\n");
    for (i = 0; alarm_timers[i].name; i++)
        printf("%s\n", alarm_timers[i].name);
}

static void configure_alarms(char const *opt)
{
    int i;
    int cur = 0;
851
    int count = ARRAY_SIZE(alarm_timers) - 1;
852 853
    char *arg;
    char *name;
P
pbrook 已提交
854
    struct qemu_alarm_timer tmp;
855

856
    if (!strcmp(opt, "?")) {
857 858 859 860 861 862 863 864 865
        show_available_alarms();
        exit(0);
    }

    arg = strdup(opt);

    /* Reorder the array */
    name = strtok(arg, ",");
    while (name) {
866
        for (i = 0; i < count && alarm_timers[i].name; i++) {
867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
            if (!strcmp(alarm_timers[i].name, name))
                break;
        }

        if (i == count) {
            fprintf(stderr, "Unknown clock %s\n", name);
            goto next;
        }

        if (i < cur)
            /* Ignore */
            goto next;

	/* Swap */
        tmp = alarm_timers[i];
        alarm_timers[i] = alarm_timers[cur];
        alarm_timers[cur] = tmp;

        cur++;
next:
        name = strtok(NULL, ",");
    }

    free(arg);

    if (cur) {
P
pbrook 已提交
893
        /* Disable remaining timers */
894 895
        for (i = cur; i < count; i++)
            alarm_timers[i].name = NULL;
896 897 898
    } else {
        show_available_alarms();
        exit(1);
899 900 901
    }
}

902 903 904 905 906
QEMUClock *rt_clock;
QEMUClock *vm_clock;

static QEMUTimer *active_timers[2];

907
static QEMUClock *qemu_new_clock(int type)
908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
{
    QEMUClock *clock;
    clock = qemu_mallocz(sizeof(QEMUClock));
    clock->type = type;
    return clock;
}

QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
{
    QEMUTimer *ts;

    ts = qemu_mallocz(sizeof(QEMUTimer));
    ts->clock = clock;
    ts->cb = cb;
    ts->opaque = opaque;
    return ts;
}

void qemu_free_timer(QEMUTimer *ts)
{
    qemu_free(ts);
}

/* stop a timer, but do not dealloc it */
void qemu_del_timer(QEMUTimer *ts)
{
    QEMUTimer **pt, *t;

    /* NOTE: this code must be signal safe because
       qemu_timer_expired() can be called from a signal. */
    pt = &active_timers[ts->clock->type];
    for(;;) {
        t = *pt;
        if (!t)
            break;
        if (t == ts) {
            *pt = t->next;
            break;
        }
        pt = &t->next;
    }
}

/* modify the current timer so that it will be fired when current_time
   >= expire_time. The corresponding callback will be called. */
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
{
    QEMUTimer **pt, *t;

    qemu_del_timer(ts);

    /* add the timer in the sorted list */
    /* NOTE: this code must be signal safe because
       qemu_timer_expired() can be called from a signal. */
    pt = &active_timers[ts->clock->type];
    for(;;) {
        t = *pt;
        if (!t)
            break;
967
        if (t->expire_time > expire_time)
968 969 970 971 972 973
            break;
        pt = &t->next;
    }
    ts->expire_time = expire_time;
    ts->next = *pt;
    *pt = ts;
974 975

    /* Rearm if necessary  */
P
pbrook 已提交
976 977 978 979 980
    if (pt == &active_timers[ts->clock->type]) {
        if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
            qemu_rearm_alarm_timer(alarm_timer);
        }
        /* Interrupt execution to force deadline recalculation.  */
981 982
        if (use_icount)
            qemu_notify_event();
P
pbrook 已提交
983
    }
984 985 986 987 988 989 990 991 992 993 994 995
}

int qemu_timer_pending(QEMUTimer *ts)
{
    QEMUTimer *t;
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
        if (t == ts)
            return 1;
    }
    return 0;
}

S
Stefano Stabellini 已提交
996
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
997 998 999 1000 1001 1002 1003 1004 1005
{
    if (!timer_head)
        return 0;
    return (timer_head->expire_time <= current_time);
}

static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
{
    QEMUTimer *ts;
1006

1007 1008
    for(;;) {
        ts = *ptimer_head;
1009
        if (!ts || ts->expire_time > current_time)
1010 1011 1012 1013
            break;
        /* remove timer from the list before calling the callback */
        *ptimer_head = ts->next;
        ts->next = NULL;
1014

1015 1016 1017 1018 1019 1020 1021 1022 1023
        /* run the callback (the timer list can be modified) */
        ts->cb(ts->opaque);
    }
}

int64_t qemu_get_clock(QEMUClock *clock)
{
    switch(clock->type) {
    case QEMU_TIMER_REALTIME:
1024
        return get_clock() / 1000000;
1025 1026
    default:
    case QEMU_TIMER_VIRTUAL:
P
pbrook 已提交
1027 1028 1029 1030 1031
        if (use_icount) {
            return cpu_get_icount();
        } else {
            return cpu_get_clock();
        }
1032 1033 1034
    }
}

1035 1036 1037 1038 1039 1040 1041 1042
static void init_timers(void)
{
    init_get_clock();
    ticks_per_sec = QEMU_TIMER_BASE;
    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
}

1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
/* save a timer */
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
{
    uint64_t expire_time;

    if (qemu_timer_pending(ts)) {
        expire_time = ts->expire_time;
    } else {
        expire_time = -1;
    }
    qemu_put_be64(f, expire_time);
}

void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
{
    uint64_t expire_time;

    expire_time = qemu_get_be64(f);
    if (expire_time != -1) {
        qemu_mod_timer(ts, expire_time);
    } else {
        qemu_del_timer(ts);
    }
}

static void timer_save(QEMUFile *f, void *opaque)
{
    if (cpu_ticks_enabled) {
        hw_error("cannot save state if virtual timers are running");
    }
1073 1074 1075
    qemu_put_be64(f, cpu_ticks_offset);
    qemu_put_be64(f, ticks_per_sec);
    qemu_put_be64(f, cpu_clock_offset);
1076 1077 1078 1079
}

static int timer_load(QEMUFile *f, void *opaque, int version_id)
{
1080
    if (version_id != 1 && version_id != 2)
1081 1082 1083 1084
        return -EINVAL;
    if (cpu_ticks_enabled) {
        return -EINVAL;
    }
1085 1086
    cpu_ticks_offset=qemu_get_be64(f);
    ticks_per_sec=qemu_get_be64(f);
1087
    if (version_id == 2) {
1088
        cpu_clock_offset=qemu_get_be64(f);
1089
    }
1090 1091 1092
    return 0;
}

1093 1094
static void qemu_event_increment(void);

B
bellard 已提交
1095
#ifdef _WIN32
B
blueswir1 已提交
1096 1097 1098
static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
                                        DWORD_PTR dwUser, DWORD_PTR dw1,
                                        DWORD_PTR dw2)
B
bellard 已提交
1099
#else
1100
static void host_alarm_handler(int host_signum)
B
bellard 已提交
1101
#endif
1102
{
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
#if 0
#define DISP_FREQ 1000
    {
        static int64_t delta_min = INT64_MAX;
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
        static int count;
        ti = qemu_get_clock(vm_clock);
        if (last_clock != 0) {
            delta = ti - last_clock;
            if (delta < delta_min)
                delta_min = delta;
            if (delta > delta_max)
                delta_max = delta;
            delta_cum += delta;
            if (++count == DISP_FREQ) {
B
bellard 已提交
1118
                printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
                       muldiv64(delta_min, 1000000, ticks_per_sec),
                       muldiv64(delta_max, 1000000, ticks_per_sec),
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
                       (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
                count = 0;
                delta_min = INT64_MAX;
                delta_max = 0;
                delta_cum = 0;
            }
        }
        last_clock = ti;
    }
#endif
1132
    if (alarm_has_dynticks(alarm_timer) ||
P
pbrook 已提交
1133 1134 1135
        (!use_icount &&
            qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
                               qemu_get_clock(vm_clock))) ||
1136 1137
        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
                           qemu_get_clock(rt_clock))) {
1138
        qemu_event_increment();
1139
        if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1140

1141 1142
#ifndef CONFIG_IOTHREAD
        if (next_cpu) {
1143
            /* stop the currently executing cpu because a timer occured */
1144
            cpu_exit(next_cpu);
1145
        }
1146
#endif
1147
        timer_alarm_pending = 1;
1148
        qemu_notify_event();
1149 1150 1151
    }
}

P
pbrook 已提交
1152
static int64_t qemu_next_deadline(void)
1153
{
P
pbrook 已提交
1154
    int64_t delta;
1155 1156

    if (active_timers[QEMU_TIMER_VIRTUAL]) {
P
pbrook 已提交
1157 1158 1159 1160 1161
        delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
                     qemu_get_clock(vm_clock);
    } else {
        /* To avoid problems with overflow limit this to 2^32.  */
        delta = INT32_MAX;
1162 1163
    }

P
pbrook 已提交
1164 1165
    if (delta < 0)
        delta = 0;
1166

P
pbrook 已提交
1167 1168 1169
    return delta;
}

1170
#if defined(__linux__) || defined(_WIN32)
P
pbrook 已提交
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
static uint64_t qemu_next_deadline_dyntick(void)
{
    int64_t delta;
    int64_t rtdelta;

    if (use_icount)
        delta = INT32_MAX;
    else
        delta = (qemu_next_deadline() + 999) / 1000;

    if (active_timers[QEMU_TIMER_REALTIME]) {
        rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
                 qemu_get_clock(rt_clock))*1000;
        if (rtdelta < delta)
            delta = rtdelta;
    }

    if (delta < MIN_TIMER_REARM_US)
        delta = MIN_TIMER_REARM_US;

    return delta;
1192
}
1193
#endif
1194

1195 1196
#ifndef _WIN32

1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
/* Sets a specific flag */
static int fcntl_setfl(int fd, int flag)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    if (flags == -1)
        return -errno;

    if (fcntl(fd, F_SETFL, flags | flag) == -1)
        return -errno;

    return 0;
}

B
BSD fix  
bellard 已提交
1212 1213
#if defined(__linux__)

1214 1215
#define RTC_FREQ 1024

1216
static void enable_sigio_timer(int fd)
1217 1218 1219 1220 1221 1222 1223 1224 1225
{
    struct sigaction act;

    /* timer signal */
    sigfillset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_handler = host_alarm_handler;

    sigaction(SIGIO, &act, NULL);
1226
    fcntl_setfl(fd, O_ASYNC);
1227 1228
    fcntl(fd, F_SETOWN, getpid());
}
B
BSD fix  
bellard 已提交
1229

T
ths 已提交
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
static int hpet_start_timer(struct qemu_alarm_timer *t)
{
    struct hpet_info info;
    int r, fd;

    fd = open("/dev/hpet", O_RDONLY);
    if (fd < 0)
        return -1;

    /* Set frequency */
    r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
    if (r < 0) {
        fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
                "error, but for better emulation accuracy type:\n"
                "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
        goto fail;
    }

    /* Check capabilities */
    r = ioctl(fd, HPET_INFO, &info);
    if (r < 0)
        goto fail;

    /* Enable periodic mode */
    r = ioctl(fd, HPET_EPI, 0);
    if (info.hi_flags && (r < 0))
        goto fail;

    /* Enable interrupt */
    r = ioctl(fd, HPET_IE_ON, 0);
    if (r < 0)
        goto fail;

    enable_sigio_timer(fd);
1264
    t->priv = (void *)(long)fd;
T
ths 已提交
1265 1266 1267 1268 1269 1270 1271 1272 1273

    return 0;
fail:
    close(fd);
    return -1;
}

static void hpet_stop_timer(struct qemu_alarm_timer *t)
{
1274
    int fd = (long)t->priv;
T
ths 已提交
1275 1276 1277 1278

    close(fd);
}

1279
static int rtc_start_timer(struct qemu_alarm_timer *t)
1280
{
1281
    int rtc_fd;
1282
    unsigned long current_rtc_freq = 0;
1283

1284
    TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1285 1286
    if (rtc_fd < 0)
        return -1;
1287 1288 1289
    ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
    if (current_rtc_freq != RTC_FREQ &&
        ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
        goto fail;
    }
    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
    fail:
        close(rtc_fd);
        return -1;
    }
1300 1301 1302

    enable_sigio_timer(rtc_fd);

1303
    t->priv = (void *)(long)rtc_fd;
1304

1305 1306 1307
    return 0;
}

1308
static void rtc_stop_timer(struct qemu_alarm_timer *t)
B
BSD fix  
bellard 已提交
1309
{
1310
    int rtc_fd = (long)t->priv;
1311 1312

    close(rtc_fd);
B
BSD fix  
bellard 已提交
1313 1314
}

1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
static int dynticks_start_timer(struct qemu_alarm_timer *t)
{
    struct sigevent ev;
    timer_t host_timer;
    struct sigaction act;

    sigfillset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_handler = host_alarm_handler;

    sigaction(SIGALRM, &act, NULL);

1327 1328 1329 1330 1331
    /* 
     * Initialize ev struct to 0 to avoid valgrind complaining
     * about uninitialized data in timer_create call
     */
    memset(&ev, 0, sizeof(ev));
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
    ev.sigev_value.sival_int = 0;
    ev.sigev_notify = SIGEV_SIGNAL;
    ev.sigev_signo = SIGALRM;

    if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
        perror("timer_create");

        /* disable dynticks */
        fprintf(stderr, "Dynamic Ticks disabled\n");

        return -1;
    }

1345
    t->priv = (void *)(long)host_timer;
1346 1347 1348 1349 1350 1351

    return 0;
}

static void dynticks_stop_timer(struct qemu_alarm_timer *t)
{
1352
    timer_t host_timer = (timer_t)(long)t->priv;
1353 1354 1355 1356 1357 1358

    timer_delete(host_timer);
}

static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
{
1359
    timer_t host_timer = (timer_t)(long)t->priv;
1360 1361 1362 1363 1364 1365
    struct itimerspec timeout;
    int64_t nearest_delta_us = INT64_MAX;
    int64_t current_us;

    if (!active_timers[QEMU_TIMER_REALTIME] &&
                !active_timers[QEMU_TIMER_VIRTUAL])
1366
        return;
1367

P
pbrook 已提交
1368
    nearest_delta_us = qemu_next_deadline_dyntick();
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390

    /* check whether a timer is already running */
    if (timer_gettime(host_timer, &timeout)) {
        perror("gettime");
        fprintf(stderr, "Internal timer error: aborting\n");
        exit(1);
    }
    current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
    if (current_us && current_us <= nearest_delta_us)
        return;

    timeout.it_interval.tv_sec = 0;
    timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
    timeout.it_value.tv_sec =  nearest_delta_us / 1000000;
    timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
    if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
        perror("settime");
        fprintf(stderr, "Internal timer error: aborting\n");
        exit(1);
    }
}

T
ths 已提交
1391
#endif /* defined(__linux__) */
1392

1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
static int unix_start_timer(struct qemu_alarm_timer *t)
{
    struct sigaction act;
    struct itimerval itv;
    int err;

    /* timer signal */
    sigfillset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_handler = host_alarm_handler;

    sigaction(SIGALRM, &act, NULL);

    itv.it_interval.tv_sec = 0;
    /* for i386 kernel 2.6 to get 1 ms */
    itv.it_interval.tv_usec = 999;
    itv.it_value.tv_sec = 0;
    itv.it_value.tv_usec = 10 * 1000;

    err = setitimer(ITIMER_REAL, &itv, NULL);
    if (err)
        return -1;

    return 0;
}

static void unix_stop_timer(struct qemu_alarm_timer *t)
{
    struct itimerval itv;

    memset(&itv, 0, sizeof(itv));
    setitimer(ITIMER_REAL, &itv, NULL);
}

B
BSD fix  
bellard 已提交
1427
#endif /* !defined(_WIN32) */
1428

1429

1430 1431 1432 1433 1434 1435
#ifdef _WIN32

static int win32_start_timer(struct qemu_alarm_timer *t)
{
    TIMECAPS tc;
    struct qemu_alarm_win32 *data = t->priv;
1436
    UINT flags;
1437 1438 1439 1440 1441 1442 1443 1444 1445

    memset(&tc, 0, sizeof(tc));
    timeGetDevCaps(&tc, sizeof(tc));

    if (data->period < tc.wPeriodMin)
        data->period = tc.wPeriodMin;

    timeBeginPeriod(data->period);

1446 1447 1448 1449 1450 1451
    flags = TIME_CALLBACK_FUNCTION;
    if (alarm_has_dynticks(t))
        flags |= TIME_ONESHOT;
    else
        flags |= TIME_PERIODIC;

1452 1453 1454 1455
    data->timerId = timeSetEvent(1,         // interval (ms)
                        data->period,       // resolution
                        host_alarm_handler, // function
                        (DWORD)t,           // parameter
1456
                        flags);
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474

    if (!data->timerId) {
        perror("Failed to initialize win32 alarm timer");
        timeEndPeriod(data->period);
        return -1;
    }

    return 0;
}

static void win32_stop_timer(struct qemu_alarm_timer *t)
{
    struct qemu_alarm_win32 *data = t->priv;

    timeKillEvent(data->timerId);
    timeEndPeriod(data->period);
}

1475 1476 1477 1478 1479 1480 1481
static void win32_rearm_timer(struct qemu_alarm_timer *t)
{
    struct qemu_alarm_win32 *data = t->priv;
    uint64_t nearest_delta_us;

    if (!active_timers[QEMU_TIMER_REALTIME] &&
                !active_timers[QEMU_TIMER_VIRTUAL])
1482
        return;
1483

P
pbrook 已提交
1484
    nearest_delta_us = qemu_next_deadline_dyntick();
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502
    nearest_delta_us /= 1000;

    timeKillEvent(data->timerId);

    data->timerId = timeSetEvent(1,
                        data->period,
                        host_alarm_handler,
                        (DWORD)t,
                        TIME_ONESHOT | TIME_PERIODIC);

    if (!data->timerId) {
        perror("Failed to re-arm win32 alarm timer");

        timeEndPeriod(data->period);
        exit(1);
    }
}

1503 1504
#endif /* _WIN32 */

1505
static int init_timer_alarm(void)
1506
{
1507
    struct qemu_alarm_timer *t = NULL;
1508
    int i, err = -1;
1509

1510 1511 1512 1513 1514 1515
    for (i = 0; alarm_timers[i].name; i++) {
        t = &alarm_timers[i];

        err = t->start(t);
        if (!err)
            break;
B
bellard 已提交
1516
    }
1517

1518
    if (err) {
1519 1520
        err = -ENOENT;
        goto fail;
B
bellard 已提交
1521
    }
1522 1523

    alarm_timer = t;
1524

1525
    return 0;
1526 1527 1528

fail:
    return err;
1529 1530
}

1531
static void quit_timers(void)
B
bellard 已提交
1532
{
1533 1534
    alarm_timer->stop(alarm_timer);
    alarm_timer = NULL;
B
bellard 已提交
1535 1536
}

1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
/***********************************************************/
/* host time/date access */
void qemu_get_timedate(struct tm *tm, int offset)
{
    time_t ti;
    struct tm *ret;

    time(&ti);
    ti += offset;
    if (rtc_date_offset == -1) {
        if (rtc_utc)
            ret = gmtime(&ti);
        else
            ret = localtime(&ti);
    } else {
        ti -= rtc_date_offset;
        ret = gmtime(&ti);
    }

    memcpy(tm, ret, sizeof(struct tm));
}

int qemu_timedate_diff(struct tm *tm)
{
    time_t seconds;

    if (rtc_date_offset == -1)
        if (rtc_utc)
            seconds = mktimegm(tm);
        else
            seconds = mktime(tm);
    else
        seconds = mktimegm(tm) + rtc_date_offset;

    return seconds - time(NULL);
}

B
bellard 已提交
1574 1575 1576 1577 1578
#ifdef _WIN32
static void socket_cleanup(void)
{
    WSACleanup();
}
B
bellard 已提交
1579

B
bellard 已提交
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
static int socket_init(void)
{
    WSADATA Data;
    int ret, err;

    ret = WSAStartup(MAKEWORD(2,2), &Data);
    if (ret != 0) {
        err = WSAGetLastError();
        fprintf(stderr, "WSAStartup: %d\n", err);
        return -1;
    }
    atexit(socket_cleanup);
    return 0;
}
1594 1595
#endif

1596 1597 1598 1599 1600
/***********************************************************/
/* Bluetooth support */
static int nb_hcis;
static int cur_hci;
static struct HCIInfo *hci_table[MAX_NICS];
1601

1602 1603 1604 1605 1606 1607 1608
static struct bt_vlan_s {
    struct bt_scatternet_s net;
    int id;
    struct bt_vlan_s *next;
} *first_bt_vlan;

/* find or alloc a new bluetooth "VLAN" */
B
blueswir1 已提交
1609
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
{
    struct bt_vlan_s **pvlan, *vlan;
    for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
        if (vlan->id == id)
            return &vlan->net;
    }
    vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
    vlan->id = id;
    pvlan = &first_bt_vlan;
    while (*pvlan != NULL)
        pvlan = &(*pvlan)->next;
    *pvlan = vlan;
    return &vlan->net;
}

static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
{
}

static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
{
    return -ENOTSUP;
}

static struct HCIInfo null_hci = {
    .cmd_send = null_hci_send,
    .sco_send = null_hci_send,
    .acl_send = null_hci_send,
    .bdaddr_set = null_hci_addr_set,
};

struct HCIInfo *qemu_next_hci(void)
{
    if (cur_hci == nb_hcis)
        return &null_hci;

    return hci_table[cur_hci++];
}

1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
static struct HCIInfo *hci_init(const char *str)
{
    char *endp;
    struct bt_scatternet_s *vlan = 0;

    if (!strcmp(str, "null"))
        /* null */
        return &null_hci;
    else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
        /* host[:hciN] */
        return bt_host_hci(str[4] ? str + 5 : "hci0");
    else if (!strncmp(str, "hci", 3)) {
        /* hci[,vlan=n] */
        if (str[3]) {
            if (!strncmp(str + 3, ",vlan=", 6)) {
                vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
                if (*endp)
                    vlan = 0;
            }
        } else
            vlan = qemu_find_bt_vlan(0);
        if (vlan)
           return bt_new_hci(vlan);
    }

    fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);

    return 0;
}

static int bt_hci_parse(const char *str)
{
    struct HCIInfo *hci;
    bdaddr_t bdaddr;

    if (nb_hcis >= MAX_NICS) {
        fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
        return -1;
    }

    hci = hci_init(str);
    if (!hci)
        return -1;

    bdaddr.b[0] = 0x52;
    bdaddr.b[1] = 0x54;
    bdaddr.b[2] = 0x00;
    bdaddr.b[3] = 0x12;
    bdaddr.b[4] = 0x34;
    bdaddr.b[5] = 0x56 + nb_hcis;
    hci->bdaddr_set(hci, bdaddr.b);

    hci_table[nb_hcis++] = hci;

    return 0;
}

static void bt_vhci_add(int vlan_id)
{
    struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);

    if (!vlan->slave)
        fprintf(stderr, "qemu: warning: adding a VHCI to "
                        "an empty scatternet %i\n", vlan_id);

    bt_vhci_init(bt_new_hci(vlan));
}

static struct bt_device_s *bt_device_add(const char *opt)
{
    struct bt_scatternet_s *vlan;
    int vlan_id = 0;
    char *endp = strstr(opt, ",vlan=");
    int len = (endp ? endp - opt : strlen(opt)) + 1;
    char devname[10];

    pstrcpy(devname, MIN(sizeof(devname), len), opt);

    if (endp) {
        vlan_id = strtol(endp + 6, &endp, 0);
        if (*endp) {
            fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
            return 0;
        }
    }

    vlan = qemu_find_bt_vlan(vlan_id);

    if (!vlan->slave)
        fprintf(stderr, "qemu: warning: adding a slave device to "
                        "an empty scatternet %i\n", vlan_id);

    if (!strcmp(devname, "keyboard"))
        return bt_keyboard_init(vlan);

    fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
    return 0;
}

static int bt_parse(const char *opt)
{
    const char *endp, *p;
    int vlan;

    if (strstart(opt, "hci", &endp)) {
        if (!*endp || *endp == ',') {
            if (*endp)
                if (!strstart(endp, ",vlan=", 0))
                    opt = endp + 1;

            return bt_hci_parse(opt);
       }
    } else if (strstart(opt, "vhci", &endp)) {
        if (!*endp || *endp == ',') {
            if (*endp) {
                if (strstart(endp, ",vlan=", &p)) {
                    vlan = strtol(p, (char **) &endp, 0);
                    if (*endp) {
                        fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
                        return 1;
                    }
                } else {
                    fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
                    return 1;
                }
            } else
                vlan = 0;

            bt_vhci_add(vlan);
            return 0;
        }
    } else if (strstart(opt, "device:", &endp))
        return !bt_device_add(endp);

    fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
    return 1;
}

1787 1788 1789
/***********************************************************/
/* QEMU Block devices */

1790
#define HD_ALIAS "index=%d,media=disk"
T
ths 已提交
1791 1792
#define CDROM_ALIAS "index=2,media=cdrom"
#define FD_ALIAS "index=%d,if=floppy"
1793 1794
#define PFLASH_ALIAS "if=pflash"
#define MTD_ALIAS "if=mtd"
1795
#define SD_ALIAS "index=0,if=sd"
T
ths 已提交
1796

G
Gerd Hoffmann 已提交
1797
QemuOpts *drive_add(const char *file, const char *fmt, ...)
T
ths 已提交
1798 1799
{
    va_list ap;
G
Gerd Hoffmann 已提交
1800 1801
    char optstr[1024];
    QemuOpts *opts;
T
ths 已提交
1802 1803

    va_start(ap, fmt);
G
Gerd Hoffmann 已提交
1804
    vsnprintf(optstr, sizeof(optstr), fmt, ap);
T
ths 已提交
1805 1806
    va_end(ap);

G
Gerd Hoffmann 已提交
1807
    opts = qemu_opts_parse(&qemu_drive_opts, optstr, NULL);
G
Gerd Hoffmann 已提交
1808 1809 1810 1811 1812 1813 1814 1815
    if (!opts) {
        fprintf(stderr, "%s: huh? duplicate? (%s)\n",
                __FUNCTION__, optstr);
        return NULL;
    }
    if (file)
        qemu_opt_set(opts, "file", file);
    return opts;
1816 1817
}

G
Gerd Hoffmann 已提交
1818
DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
T
ths 已提交
1819
{
G
Gerd Hoffmann 已提交
1820
    DriveInfo *dinfo;
T
ths 已提交
1821 1822 1823

    /* seek interface, bus and unit */

G
Gerd Hoffmann 已提交
1824 1825 1826 1827 1828 1829
    TAILQ_FOREACH(dinfo, &drives, next) {
        if (dinfo->type == type &&
	    dinfo->bus == bus &&
	    dinfo->unit == unit)
            return dinfo;
    }
T
ths 已提交
1830

G
Gerd Hoffmann 已提交
1831
    return NULL;
T
ths 已提交
1832 1833
}

G
Gerd Hoffmann 已提交
1834
DriveInfo *drive_get_by_id(const char *id)
G
Gerd Hoffmann 已提交
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
{
    DriveInfo *dinfo;

    TAILQ_FOREACH(dinfo, &drives, next) {
        if (strcmp(id, dinfo->id))
            continue;
        return dinfo;
    }
    return NULL;
}

1846
int drive_get_max_bus(BlockInterfaceType type)
T
ths 已提交
1847 1848
{
    int max_bus;
G
Gerd Hoffmann 已提交
1849
    DriveInfo *dinfo;
T
ths 已提交
1850 1851

    max_bus = -1;
G
Gerd Hoffmann 已提交
1852 1853 1854 1855
    TAILQ_FOREACH(dinfo, &drives, next) {
        if(dinfo->type == type &&
           dinfo->bus > max_bus)
            max_bus = dinfo->bus;
T
ths 已提交
1856 1857 1858 1859
    }
    return max_bus;
}

1860 1861
const char *drive_get_serial(BlockDriverState *bdrv)
{
G
Gerd Hoffmann 已提交
1862
    DriveInfo *dinfo;
1863

G
Gerd Hoffmann 已提交
1864 1865 1866 1867
    TAILQ_FOREACH(dinfo, &drives, next) {
        if (dinfo->bdrv == bdrv)
            return dinfo->serial;
    }
1868 1869 1870 1871

    return "\0";
}

1872 1873
BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
{
G
Gerd Hoffmann 已提交
1874
    DriveInfo *dinfo;
1875

G
Gerd Hoffmann 已提交
1876 1877 1878 1879
    TAILQ_FOREACH(dinfo, &drives, next) {
        if (dinfo->bdrv == bdrv)
            return dinfo->onerror;
    }
1880

1881
    return BLOCK_ERR_STOP_ENOSPC;
1882 1883
}

1884 1885 1886 1887 1888
static void bdrv_format_print(void *opaque, const char *name)
{
    fprintf(stderr, " %s", name);
}

1889 1890
void drive_uninit(BlockDriverState *bdrv)
{
G
Gerd Hoffmann 已提交
1891
    DriveInfo *dinfo;
1892

G
Gerd Hoffmann 已提交
1893 1894 1895
    TAILQ_FOREACH(dinfo, &drives, next) {
        if (dinfo->bdrv != bdrv)
            continue;
G
Gerd Hoffmann 已提交
1896
        qemu_opts_del(dinfo->opts);
G
Gerd Hoffmann 已提交
1897 1898 1899 1900
        TAILQ_REMOVE(&drives, dinfo, next);
        qemu_free(dinfo);
        break;
    }
1901 1902
}

G
Gerd Hoffmann 已提交
1903
DriveInfo *drive_init(QemuOpts *opts, void *opaque,
G
Gerd Hoffmann 已提交
1904
                      int *fatal_error)
T
ths 已提交
1905
{
G
Gerd Hoffmann 已提交
1906 1907
    const char *buf;
    const char *file = NULL;
1908
    char devname[128];
G
Gerd Hoffmann 已提交
1909
    const char *serial;
1910
    const char *mediastr = "";
1911
    BlockInterfaceType type;
T
ths 已提交
1912 1913 1914
    enum { MEDIA_DISK, MEDIA_CDROM } media;
    int bus_id, unit_id;
    int cyls, heads, secs, translation;
1915
    BlockDriver *drv = NULL;
1916
    QEMUMachine *machine = opaque;
T
ths 已提交
1917 1918
    int max_devs;
    int index;
1919
    int cache;
1920
    int aio = 0;
1921
    int bdrv_flags, onerror;
1922
    const char *devaddr;
G
Gerd Hoffmann 已提交
1923
    DriveInfo *dinfo;
G
Gerd Hoffmann 已提交
1924
    int snapshot = 0;
T
ths 已提交
1925

G
Gerd Hoffmann 已提交
1926
    *fatal_error = 1;
T
ths 已提交
1927 1928

    translation = BIOS_ATA_TRANSLATION_AUTO;
1929
    cache = 1;
T
ths 已提交
1930

1931
    if (machine && machine->use_scsi) {
1932
        type = IF_SCSI;
T
ths 已提交
1933
        max_devs = MAX_SCSI_DEVS;
B
blueswir1 已提交
1934
        pstrcpy(devname, sizeof(devname), "scsi");
T
ths 已提交
1935
    } else {
1936
        type = IF_IDE;
T
ths 已提交
1937
        max_devs = MAX_IDE_DEVS;
B
blueswir1 已提交
1938
        pstrcpy(devname, sizeof(devname), "ide");
T
ths 已提交
1939 1940 1941 1942
    }
    media = MEDIA_DISK;

    /* extract parameters */
G
Gerd Hoffmann 已提交
1943 1944 1945
    bus_id  = qemu_opt_get_number(opts, "bus", 0);
    unit_id = qemu_opt_get_number(opts, "unit", -1);
    index   = qemu_opt_get_number(opts, "index", -1);
T
ths 已提交
1946

G
Gerd Hoffmann 已提交
1947 1948 1949
    cyls  = qemu_opt_get_number(opts, "cyls", 0);
    heads = qemu_opt_get_number(opts, "heads", 0);
    secs  = qemu_opt_get_number(opts, "secs", 0);
T
ths 已提交
1950

G
Gerd Hoffmann 已提交
1951
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
T
ths 已提交
1952

G
Gerd Hoffmann 已提交
1953 1954 1955 1956
    file = qemu_opt_get(opts, "file");
    serial = qemu_opt_get(opts, "serial");

    if ((buf = qemu_opt_get(opts, "if")) != NULL) {
B
bellard 已提交
1957
        pstrcpy(devname, sizeof(devname), buf);
T
ths 已提交
1958
        if (!strcmp(buf, "ide")) {
1959
	    type = IF_IDE;
T
ths 已提交
1960 1961
            max_devs = MAX_IDE_DEVS;
        } else if (!strcmp(buf, "scsi")) {
1962
	    type = IF_SCSI;
T
ths 已提交
1963 1964
            max_devs = MAX_SCSI_DEVS;
        } else if (!strcmp(buf, "floppy")) {
1965
	    type = IF_FLOPPY;
T
ths 已提交
1966 1967
            max_devs = 0;
        } else if (!strcmp(buf, "pflash")) {
1968
	    type = IF_PFLASH;
T
ths 已提交
1969 1970
            max_devs = 0;
	} else if (!strcmp(buf, "mtd")) {
1971
	    type = IF_MTD;
T
ths 已提交
1972 1973
            max_devs = 0;
	} else if (!strcmp(buf, "sd")) {
1974
	    type = IF_SD;
T
ths 已提交
1975
            max_devs = 0;
A
aliguori 已提交
1976 1977 1978
        } else if (!strcmp(buf, "virtio")) {
            type = IF_VIRTIO;
            max_devs = 0;
1979 1980 1981
	} else if (!strcmp(buf, "xen")) {
	    type = IF_XEN;
            max_devs = 0;
G
Gerd Hoffmann 已提交
1982 1983 1984
	} else if (!strcmp(buf, "none")) {
	    type = IF_NONE;
            max_devs = 0;
1985
	} else {
G
Gerd Hoffmann 已提交
1986
            fprintf(stderr, "qemu: unsupported bus type '%s'\n", buf);
G
Gerd Hoffmann 已提交
1987
            return NULL;
T
ths 已提交
1988 1989 1990 1991 1992
	}
    }

    if (cyls || heads || secs) {
        if (cyls < 1 || cyls > 16383) {
G
Gerd Hoffmann 已提交
1993
            fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
G
Gerd Hoffmann 已提交
1994
	    return NULL;
T
ths 已提交
1995 1996
	}
        if (heads < 1 || heads > 16) {
G
Gerd Hoffmann 已提交
1997
            fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
G
Gerd Hoffmann 已提交
1998
	    return NULL;
T
ths 已提交
1999 2000
	}
        if (secs < 1 || secs > 63) {
G
Gerd Hoffmann 已提交
2001
            fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
G
Gerd Hoffmann 已提交
2002
	    return NULL;
T
ths 已提交
2003 2004 2005
	}
    }

G
Gerd Hoffmann 已提交
2006
    if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
T
ths 已提交
2007 2008 2009
        if (!cyls) {
            fprintf(stderr,
                    "qemu: '%s' trans must be used with cyls,heads and secs\n",
G
Gerd Hoffmann 已提交
2010
                    buf);
G
Gerd Hoffmann 已提交
2011
            return NULL;
T
ths 已提交
2012 2013 2014 2015 2016 2017 2018 2019
        }
        if (!strcmp(buf, "none"))
            translation = BIOS_ATA_TRANSLATION_NONE;
        else if (!strcmp(buf, "lba"))
            translation = BIOS_ATA_TRANSLATION_LBA;
        else if (!strcmp(buf, "auto"))
            translation = BIOS_ATA_TRANSLATION_AUTO;
	else {
G
Gerd Hoffmann 已提交
2020
            fprintf(stderr, "qemu: '%s' invalid translation type\n", buf);
G
Gerd Hoffmann 已提交
2021
	    return NULL;
T
ths 已提交
2022 2023 2024
	}
    }

G
Gerd Hoffmann 已提交
2025
    if ((buf = qemu_opt_get(opts, "media")) != NULL) {
T
ths 已提交
2026 2027 2028 2029 2030
        if (!strcmp(buf, "disk")) {
	    media = MEDIA_DISK;
	} else if (!strcmp(buf, "cdrom")) {
            if (cyls || secs || heads) {
                fprintf(stderr,
G
Gerd Hoffmann 已提交
2031
                        "qemu: '%s' invalid physical CHS format\n", buf);
G
Gerd Hoffmann 已提交
2032
	        return NULL;
T
ths 已提交
2033 2034 2035
            }
	    media = MEDIA_CDROM;
	} else {
G
Gerd Hoffmann 已提交
2036
	    fprintf(stderr, "qemu: '%s' invalid media\n", buf);
G
Gerd Hoffmann 已提交
2037
	    return NULL;
T
ths 已提交
2038 2039 2040
	}
    }

G
Gerd Hoffmann 已提交
2041
    if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
2042
        if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2043
            cache = 0;
2044
        else if (!strcmp(buf, "writethrough"))
2045
            cache = 1;
2046 2047
        else if (!strcmp(buf, "writeback"))
            cache = 2;
2048 2049
        else {
           fprintf(stderr, "qemu: invalid cache option\n");
G
Gerd Hoffmann 已提交
2050
           return NULL;
2051 2052 2053
        }
    }

2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
#ifdef CONFIG_LINUX_AIO
    if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
        if (!strcmp(buf, "threads"))
            aio = 0;
        else if (!strcmp(buf, "native"))
            aio = 1;
        else {
           fprintf(stderr, "qemu: invalid aio option\n");
           return NULL;
        }
    }
#endif

G
Gerd Hoffmann 已提交
2067
    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
2068 2069 2070 2071
       if (strcmp(buf, "?") == 0) {
            fprintf(stderr, "qemu: Supported formats:");
            bdrv_iterate_format(bdrv_format_print, NULL);
            fprintf(stderr, "\n");
G
Gerd Hoffmann 已提交
2072
	    return NULL;
2073
        }
2074 2075 2076
        drv = bdrv_find_format(buf);
        if (!drv) {
            fprintf(stderr, "qemu: '%s' invalid format\n", buf);
G
Gerd Hoffmann 已提交
2077
            return NULL;
2078 2079 2080
        }
    }

2081
    onerror = BLOCK_ERR_STOP_ENOSPC;
G
Gerd Hoffmann 已提交
2082
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
2083
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2084
            fprintf(stderr, "werror is no supported by this format\n");
G
Gerd Hoffmann 已提交
2085
            return NULL;
2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
        }
        if (!strcmp(buf, "ignore"))
            onerror = BLOCK_ERR_IGNORE;
        else if (!strcmp(buf, "enospc"))
            onerror = BLOCK_ERR_STOP_ENOSPC;
        else if (!strcmp(buf, "stop"))
            onerror = BLOCK_ERR_STOP_ANY;
        else if (!strcmp(buf, "report"))
            onerror = BLOCK_ERR_REPORT;
        else {
            fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
G
Gerd Hoffmann 已提交
2097
            return NULL;
2098 2099 2100
        }
    }

G
Gerd Hoffmann 已提交
2101
    if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
2102
        if (type != IF_VIRTIO) {
G
Gerd Hoffmann 已提交
2103
            fprintf(stderr, "addr is not supported\n");
G
Gerd Hoffmann 已提交
2104
            return NULL;
2105 2106 2107
        }
    }

T
ths 已提交
2108 2109 2110 2111 2112
    /* compute bus and unit according index */

    if (index != -1) {
        if (bus_id != 0 || unit_id != -1) {
            fprintf(stderr,
G
Gerd Hoffmann 已提交
2113
                    "qemu: index cannot be used with bus and unit\n");
G
Gerd Hoffmann 已提交
2114
            return NULL;
T
ths 已提交
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
        }
        if (max_devs == 0)
        {
            unit_id = index;
            bus_id = 0;
        } else {
            unit_id = index % max_devs;
            bus_id = index / max_devs;
        }
    }

    /* if user doesn't specify a unit_id,
     * try to find the first free
     */

    if (unit_id == -1) {
       unit_id = 0;
G
Gerd Hoffmann 已提交
2132
       while (drive_get(type, bus_id, unit_id) != NULL) {
T
ths 已提交
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
           unit_id++;
           if (max_devs && unit_id >= max_devs) {
               unit_id -= max_devs;
               bus_id++;
           }
       }
    }

    /* check unit id */

    if (max_devs && unit_id >= max_devs) {
G
Gerd Hoffmann 已提交
2144 2145
        fprintf(stderr, "qemu: unit %d too big (max is %d)\n",
                unit_id, max_devs - 1);
G
Gerd Hoffmann 已提交
2146
        return NULL;
T
ths 已提交
2147 2148 2149 2150 2151 2152
    }

    /*
     * ignore multiple definitions
     */

G
Gerd Hoffmann 已提交
2153 2154 2155 2156
    if (drive_get(type, bus_id, unit_id) != NULL) {
        *fatal_error = 0;
        return NULL;
    }
T
ths 已提交
2157 2158 2159

    /* init */

G
Gerd Hoffmann 已提交
2160
    dinfo = qemu_mallocz(sizeof(*dinfo));
2161
    if ((buf = qemu_opts_id(opts)) != NULL) {
G
Gerd Hoffmann 已提交
2162 2163
        dinfo->id = qemu_strdup(buf);
    } else {
G
Gerd Hoffmann 已提交
2164
        /* no id supplied -> create one */
G
Gerd Hoffmann 已提交
2165
        dinfo->id = qemu_mallocz(32);
G
Gerd Hoffmann 已提交
2166 2167 2168
        if (type == IF_IDE || type == IF_SCSI)
            mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
        if (max_devs)
G
Gerd Hoffmann 已提交
2169
            snprintf(dinfo->id, 32, "%s%i%s%i",
G
Gerd Hoffmann 已提交
2170 2171
                     devname, bus_id, mediastr, unit_id);
        else
G
Gerd Hoffmann 已提交
2172
            snprintf(dinfo->id, 32, "%s%s%i",
G
Gerd Hoffmann 已提交
2173 2174 2175
                     devname, mediastr, unit_id);
    }
    dinfo->bdrv = bdrv_new(dinfo->id);
G
Gerd Hoffmann 已提交
2176 2177 2178 2179 2180
    dinfo->devaddr = devaddr;
    dinfo->type = type;
    dinfo->bus = bus_id;
    dinfo->unit = unit_id;
    dinfo->onerror = onerror;
G
Gerd Hoffmann 已提交
2181 2182 2183
    dinfo->opts = opts;
    if (serial)
        strncpy(dinfo->serial, serial, sizeof(serial));
G
Gerd Hoffmann 已提交
2184
    TAILQ_INSERT_TAIL(&drives, dinfo, next);
T
ths 已提交
2185

2186
    switch(type) {
T
ths 已提交
2187 2188
    case IF_IDE:
    case IF_SCSI:
2189
    case IF_XEN:
T
ths 已提交
2190 2191 2192
        switch(media) {
	case MEDIA_DISK:
            if (cyls != 0) {
G
Gerd Hoffmann 已提交
2193 2194
                bdrv_set_geometry_hint(dinfo->bdrv, cyls, heads, secs);
                bdrv_set_translation_hint(dinfo->bdrv, translation);
T
ths 已提交
2195 2196 2197
            }
	    break;
	case MEDIA_CDROM:
G
Gerd Hoffmann 已提交
2198
            bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM);
T
ths 已提交
2199 2200 2201 2202 2203 2204 2205
	    break;
	}
        break;
    case IF_SD:
        /* FIXME: This isn't really a floppy, but it's a reasonable
           approximation.  */
    case IF_FLOPPY:
G
Gerd Hoffmann 已提交
2206
        bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY);
T
ths 已提交
2207 2208 2209
        break;
    case IF_PFLASH:
    case IF_MTD:
G
Gerd Hoffmann 已提交
2210
    case IF_NONE:
T
ths 已提交
2211
        break;
G
Gerd Hoffmann 已提交
2212 2213 2214 2215 2216 2217 2218 2219
    case IF_VIRTIO:
        /* add virtio block device */
        opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
        qemu_opt_set(opts, "driver", "virtio-blk-pci");
        qemu_opt_set(opts, "drive", dinfo->id);
        if (devaddr)
            qemu_opt_set(opts, "addr", devaddr);
        break;
P
Paul Brook 已提交
2220 2221
    case IF_COUNT:
        abort();
T
ths 已提交
2222
    }
G
Gerd Hoffmann 已提交
2223
    if (!file) {
G
Gerd Hoffmann 已提交
2224 2225 2226
        *fatal_error = 0;
        return NULL;
    }
2227
    bdrv_flags = 0;
2228
    if (snapshot) {
2229
        bdrv_flags |= BDRV_O_SNAPSHOT;
2230 2231 2232 2233 2234 2235
        cache = 2; /* always use write-back with snapshot */
    }
    if (cache == 0) /* no caching */
        bdrv_flags |= BDRV_O_NOCACHE;
    else if (cache == 2) /* write-back */
        bdrv_flags |= BDRV_O_CACHE_WB;
2236 2237 2238 2239 2240 2241 2242

    if (aio == 1) {
        bdrv_flags |= BDRV_O_NATIVE_AIO;
    } else {
        bdrv_flags &= ~BDRV_O_NATIVE_AIO;
    }

G
Gerd Hoffmann 已提交
2243
    if (bdrv_open2(dinfo->bdrv, file, bdrv_flags, drv) < 0) {
T
ths 已提交
2244 2245
        fprintf(stderr, "qemu: could not open disk image %s\n",
                        file);
G
Gerd Hoffmann 已提交
2246
        return NULL;
T
ths 已提交
2247
    }
2248

G
Gerd Hoffmann 已提交
2249
    if (bdrv_key_required(dinfo->bdrv))
2250
        autostart = 0;
G
Gerd Hoffmann 已提交
2251 2252
    *fatal_error = 0;
    return dinfo;
T
ths 已提交
2253 2254
}

G
Gerd Hoffmann 已提交
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
static int drive_init_func(QemuOpts *opts, void *opaque)
{
    QEMUMachine *machine = opaque;
    int fatal_error = 0;

    if (drive_init(opts, machine, &fatal_error) == NULL) {
        if (fatal_error)
            return 1;
    }
    return 0;
}

static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
{
    if (NULL == qemu_opt_get(opts, "snapshot")) {
        qemu_opt_set(opts, "snapshot", "on");
    }
    return 0;
}

J
Jan Kiszka 已提交
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
{
    boot_set_handler = func;
    boot_set_opaque = opaque;
}

int qemu_boot_set(const char *boot_devices)
{
    if (!boot_set_handler) {
        return -EINVAL;
    }
    return boot_set_handler(boot_set_opaque, boot_devices);
}

J
Jan Kiszka 已提交
2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
static int parse_bootdevices(char *devices)
{
    /* We just do some generic consistency checks */
    const char *p;
    int bitmap = 0;

    for (p = devices; *p != '\0'; p++) {
        /* Allowed boot devices are:
         * a-b: floppy disk drives
         * c-f: IDE disk drives
         * g-m: machine implementation dependant drives
         * n-p: network devices
         * It's up to each machine implementation to check if the given boot
         * devices match the actual hardware implementation and firmware
         * features.
         */
        if (*p < 'a' || *p > 'p') {
            fprintf(stderr, "Invalid boot device '%c'\n", *p);
            exit(1);
        }
        if (bitmap & (1 << (*p - 'a'))) {
            fprintf(stderr, "Boot device '%c' was given twice\n", *p);
            exit(1);
        }
        bitmap |= 1 << (*p - 'a');
    }
    return bitmap;
}

J
Jan Kiszka 已提交
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327
static void restore_boot_devices(void *opaque)
{
    char *standard_boot_devices = opaque;

    qemu_boot_set(standard_boot_devices);

    qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
    qemu_free(standard_boot_devices);
}

2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383
static void numa_add(const char *optarg)
{
    char option[128];
    char *endptr;
    unsigned long long value, endvalue;
    int nodenr;

    optarg = get_opt_name(option, 128, optarg, ',') + 1;
    if (!strcmp(option, "node")) {
        if (get_param_value(option, 128, "nodeid", optarg) == 0) {
            nodenr = nb_numa_nodes;
        } else {
            nodenr = strtoull(option, NULL, 10);
        }

        if (get_param_value(option, 128, "mem", optarg) == 0) {
            node_mem[nodenr] = 0;
        } else {
            value = strtoull(option, &endptr, 0);
            switch (*endptr) {
            case 0: case 'M': case 'm':
                value <<= 20;
                break;
            case 'G': case 'g':
                value <<= 30;
                break;
            }
            node_mem[nodenr] = value;
        }
        if (get_param_value(option, 128, "cpus", optarg) == 0) {
            node_cpumask[nodenr] = 0;
        } else {
            value = strtoull(option, &endptr, 10);
            if (value >= 64) {
                value = 63;
                fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
            } else {
                if (*endptr == '-') {
                    endvalue = strtoull(endptr+1, &endptr, 10);
                    if (endvalue >= 63) {
                        endvalue = 62;
                        fprintf(stderr,
                            "only 63 CPUs in NUMA mode supported.\n");
                    }
                    value = (1 << (endvalue + 1)) - (1 << value);
                } else {
                    value = 1 << value;
                }
            }
            node_cpumask[nodenr] = value;
        }
        nb_numa_nodes++;
    }
    return;
}

2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433
static void smp_parse(const char *optarg)
{
    int smp, sockets = 0, threads = 0, cores = 0;
    char *endptr;
    char option[128];

    smp = strtoul(optarg, &endptr, 10);
    if (endptr != optarg) {
        if (*endptr == ',') {
            endptr++;
        }
    }
    if (get_param_value(option, 128, "sockets", endptr) != 0)
        sockets = strtoull(option, NULL, 10);
    if (get_param_value(option, 128, "cores", endptr) != 0)
        cores = strtoull(option, NULL, 10);
    if (get_param_value(option, 128, "threads", endptr) != 0)
        threads = strtoull(option, NULL, 10);
    if (get_param_value(option, 128, "maxcpus", endptr) != 0)
        max_cpus = strtoull(option, NULL, 10);

    /* compute missing values, prefer sockets over cores over threads */
    if (smp == 0 || sockets == 0) {
        sockets = sockets > 0 ? sockets : 1;
        cores = cores > 0 ? cores : 1;
        threads = threads > 0 ? threads : 1;
        if (smp == 0) {
            smp = cores * threads * sockets;
        } else {
            sockets = smp / (cores * threads);
        }
    } else {
        if (cores == 0) {
            threads = threads > 0 ? threads : 1;
            cores = smp / (sockets * threads);
        } else {
            if (sockets == 0) {
                sockets = smp / (cores * threads);
            } else {
                threads = smp / (cores * sockets);
            }
        }
    }
    smp_cpus = smp;
    smp_cores = cores > 0 ? cores : 1;
    smp_threads = threads > 0 ? threads : 1;
    if (max_cpus == 0)
        max_cpus = smp_cpus;
}

B
bellard 已提交
2434 2435 2436
/***********************************************************/
/* USB devices */

P
pbrook 已提交
2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
static USBPort *used_usb_ports;
static USBPort *free_usb_ports;

/* ??? Maybe change this to register a hub to keep track of the topology.  */
void qemu_register_usb_port(USBPort *port, void *opaque, int index,
                            usb_attachfn attach)
{
    port->opaque = opaque;
    port->index = index;
    port->attach = attach;
    port->next = free_usb_ports;
    free_usb_ports = port;
}

2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
int usb_device_add_dev(USBDevice *dev)
{
    USBPort *port;

    /* Find a USB port to add the device to.  */
    port = free_usb_ports;
    if (!port->next) {
        USBDevice *hub;

        /* Create a new hub and chain it on.  */
        free_usb_ports = NULL;
        port->next = used_usb_ports;
        used_usb_ports = port;

        hub = usb_hub_init(VM_USB_HUB_SIZE);
        usb_attach(port, hub);
        port = free_usb_ports;
    }

    free_usb_ports = port->next;
    port->next = used_usb_ports;
    used_usb_ports = port;
    usb_attach(port, dev);
    return 0;
}

2477 2478 2479 2480 2481 2482 2483
static void usb_msd_password_cb(void *opaque, int err)
{
    USBDevice *dev = opaque;

    if (!err)
        usb_device_add_dev(dev);
    else
2484
        dev->info->handle_destroy(dev);
2485 2486
}

2487
static int usb_device_add(const char *devname, int is_hotplug)
B
bellard 已提交
2488 2489 2490 2491
{
    const char *p;
    USBDevice *dev;

P
pbrook 已提交
2492
    if (!free_usb_ports)
B
bellard 已提交
2493 2494 2495 2496 2497 2498
        return -1;

    if (strstart(devname, "host:", &p)) {
        dev = usb_host_device_open(p);
    } else if (!strcmp(devname, "mouse")) {
        dev = usb_mouse_init();
2499
    } else if (!strcmp(devname, "tablet")) {
B
balrog 已提交
2500 2501 2502
        dev = usb_tablet_init();
    } else if (!strcmp(devname, "keyboard")) {
        dev = usb_keyboard_init();
P
pbrook 已提交
2503
    } else if (strstart(devname, "disk:", &p)) {
2504 2505
        BlockDriverState *bs;

2506
        dev = usb_msd_init(p);
2507 2508
        if (!dev)
            return -1;
2509
        bs = usb_msd_get_bdrv(dev);
2510 2511
        if (bdrv_key_required(bs)) {
            autostart = 0;
2512
            if (is_hotplug) {
A
aliguori 已提交
2513 2514
                monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
                                            dev);
2515
                return 0;
2516 2517
            }
        }
2518 2519
    } else if (!strcmp(devname, "wacom-tablet")) {
        dev = usb_wacom_init();
B
balrog 已提交
2520 2521
    } else if (strstart(devname, "serial:", &p)) {
        dev = usb_serial_init(p);
A
aurel32 已提交
2522 2523 2524 2525
#ifdef CONFIG_BRLAPI
    } else if (!strcmp(devname, "braille")) {
        dev = usb_baum_init();
#endif
2526
    } else if (strstart(devname, "net:", &p)) {
2527
        int nic = nb_nics;
2528

2529
        if (net_client_init(NULL, "nic", p) < 0)
2530
            return -1;
2531 2532
        nd_table[nic].model = "usb";
        dev = usb_net_init(&nd_table[nic]);
2533 2534 2535
    } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
        dev = usb_bt_init(devname[2] ? hci_init(p) :
                        bt_new_hci(qemu_find_bt_vlan(0)));
B
bellard 已提交
2536 2537 2538
    } else {
        return -1;
    }
P
pbrook 已提交
2539 2540 2541
    if (!dev)
        return -1;

2542
    return usb_device_add_dev(dev);
B
bellard 已提交
2543 2544
}

2545
int usb_device_del_addr(int bus_num, int addr)
B
bellard 已提交
2546
{
P
pbrook 已提交
2547 2548
    USBPort *port;
    USBPort **lastp;
B
bellard 已提交
2549
    USBDevice *dev;
B
bellard 已提交
2550

P
pbrook 已提交
2551
    if (!used_usb_ports)
B
bellard 已提交
2552 2553 2554 2555
        return -1;

    if (bus_num != 0)
        return -1;
P
pbrook 已提交
2556 2557 2558 2559 2560 2561

    lastp = &used_usb_ports;
    port = used_usb_ports;
    while (port && port->dev->addr != addr) {
        lastp = &port->next;
        port = port->next;
B
bellard 已提交
2562
    }
P
pbrook 已提交
2563 2564

    if (!port)
B
bellard 已提交
2565
        return -1;
P
pbrook 已提交
2566

B
bellard 已提交
2567
    dev = port->dev;
P
pbrook 已提交
2568 2569
    *lastp = port->next;
    usb_attach(port, NULL);
2570
    dev->info->handle_destroy(dev);
P
pbrook 已提交
2571 2572
    port->next = free_usb_ports;
    free_usb_ports = port;
B
bellard 已提交
2573 2574 2575
    return 0;
}

2576 2577 2578 2579 2580
static int usb_device_del(const char *devname)
{
    int bus_num, addr;
    const char *p;

2581 2582 2583
    if (strstart(devname, "host:", &p))
        return usb_host_device_close(p);

2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
    if (!used_usb_ports)
        return -1;

    p = strchr(devname, '.');
    if (!p)
        return -1;
    bus_num = strtoul(devname, NULL, 0);
    addr = strtoul(p + 1, NULL, 0);

    return usb_device_del_addr(bus_num, addr);
}

2596 2597 2598 2599 2600
static int usb_parse(const char *cmdline)
{
    return usb_device_add(cmdline, 0);
}

2601
void do_usb_add(Monitor *mon, const QDict *qdict)
B
bellard 已提交
2602
{
2603
    usb_device_add(qdict_get_str(qdict, "devname"), 1);
B
bellard 已提交
2604 2605
}

2606
void do_usb_del(Monitor *mon, const QDict *qdict)
B
bellard 已提交
2607
{
2608
    usb_device_del(qdict_get_str(qdict, "devname"));
B
bellard 已提交
2609 2610
}

A
aliguori 已提交
2611
void usb_info(Monitor *mon)
B
bellard 已提交
2612 2613
{
    USBDevice *dev;
P
pbrook 已提交
2614
    USBPort *port;
B
bellard 已提交
2615 2616
    const char *speed_str;

P
pbrook 已提交
2617
    if (!usb_enabled) {
A
aliguori 已提交
2618
        monitor_printf(mon, "USB support not enabled\n");
B
bellard 已提交
2619 2620 2621
        return;
    }

P
pbrook 已提交
2622 2623 2624 2625 2626
    for (port = used_usb_ports; port; port = port->next) {
        dev = port->dev;
        if (!dev)
            continue;
        switch(dev->speed) {
2627 2628
        case USB_SPEED_LOW:
            speed_str = "1.5";
P
pbrook 已提交
2629
            break;
2630 2631
        case USB_SPEED_FULL:
            speed_str = "12";
P
pbrook 已提交
2632
            break;
2633 2634
        case USB_SPEED_HIGH:
            speed_str = "480";
P
pbrook 已提交
2635 2636
            break;
        default:
2637
            speed_str = "?";
P
pbrook 已提交
2638
            break;
B
bellard 已提交
2639
        }
A
aliguori 已提交
2640 2641
        monitor_printf(mon, "  Device %d.%d, Speed %s Mb/s, Product %s\n",
                       0, dev->addr, speed_str, dev->devname);
B
bellard 已提交
2642 2643 2644
    }
}

2645 2646 2647 2648
/***********************************************************/
/* PCMCIA/Cardbus */

static struct pcmcia_socket_entry_s {
P
Paul Brook 已提交
2649
    PCMCIASocket *socket;
2650 2651 2652
    struct pcmcia_socket_entry_s *next;
} *pcmcia_sockets = 0;

P
Paul Brook 已提交
2653
void pcmcia_socket_register(PCMCIASocket *socket)
2654 2655 2656 2657 2658 2659 2660 2661 2662
{
    struct pcmcia_socket_entry_s *entry;

    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
    entry->socket = socket;
    entry->next = pcmcia_sockets;
    pcmcia_sockets = entry;
}

P
Paul Brook 已提交
2663
void pcmcia_socket_unregister(PCMCIASocket *socket)
2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674
{
    struct pcmcia_socket_entry_s *entry, **ptr;

    ptr = &pcmcia_sockets;
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
        if (entry->socket == socket) {
            *ptr = entry->next;
            qemu_free(entry);
        }
}

A
aliguori 已提交
2675
void pcmcia_info(Monitor *mon)
2676 2677
{
    struct pcmcia_socket_entry_s *iter;
A
aliguori 已提交
2678

2679
    if (!pcmcia_sockets)
A
aliguori 已提交
2680
        monitor_printf(mon, "No PCMCIA sockets\n");
2681 2682

    for (iter = pcmcia_sockets; iter; iter = iter->next)
A
aliguori 已提交
2683 2684 2685
        monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
                       iter->socket->attached ? iter->socket->card_string :
                       "Empty");
2686 2687
}

2688
/***********************************************************/
2689 2690
/* register display */

2691 2692 2693 2694 2695 2696
struct DisplayAllocator default_allocator = {
    defaultallocator_create_displaysurface,
    defaultallocator_resize_displaysurface,
    defaultallocator_free_displaysurface
};

2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711
void register_displaystate(DisplayState *ds)
{
    DisplayState **s;
    s = &display_state;
    while (*s != NULL)
        s = &(*s)->next;
    ds->next = NULL;
    *s = ds;
}

DisplayState *get_displaystate(void)
{
    return display_state;
}

2712 2713 2714 2715 2716 2717
DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
{
    if(ds->allocator ==  &default_allocator) ds->allocator = da;
    return ds->allocator;
}

2718 2719
/* dumb display */

2720
static void dumb_display_init(void)
2721
{
2722
    DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2723 2724
    ds->allocator = &default_allocator;
    ds->surface = qemu_create_displaysurface(ds, 640, 480);
2725
    register_displaystate(ds);
2726 2727
}

2728 2729
/***********************************************************/
/* I/O handling */
2730

2731 2732
typedef struct IOHandlerRecord {
    int fd;
B
bellard 已提交
2733 2734 2735
    IOCanRWHandler *fd_read_poll;
    IOHandler *fd_read;
    IOHandler *fd_write;
2736
    int deleted;
2737 2738 2739
    void *opaque;
    /* temporary data */
    struct pollfd *ufd;
2740
    struct IOHandlerRecord *next;
2741 2742
} IOHandlerRecord;

2743
static IOHandlerRecord *first_io_handler;
2744

B
bellard 已提交
2745 2746
/* XXX: fd_read_poll should be suppressed, but an API change is
   necessary in the character devices to suppress fd_can_read(). */
2747 2748 2749 2750
int qemu_set_fd_handler2(int fd,
                         IOCanRWHandler *fd_read_poll,
                         IOHandler *fd_read,
                         IOHandler *fd_write,
B
bellard 已提交
2751
                         void *opaque)
2752
{
B
bellard 已提交
2753
    IOHandlerRecord **pioh, *ioh;
2754

B
bellard 已提交
2755 2756 2757 2758 2759 2760 2761
    if (!fd_read && !fd_write) {
        pioh = &first_io_handler;
        for(;;) {
            ioh = *pioh;
            if (ioh == NULL)
                break;
            if (ioh->fd == fd) {
2762
                ioh->deleted = 1;
B
bellard 已提交
2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780
                break;
            }
            pioh = &ioh->next;
        }
    } else {
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
            if (ioh->fd == fd)
                goto found;
        }
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
        ioh->next = first_io_handler;
        first_io_handler = ioh;
    found:
        ioh->fd = fd;
        ioh->fd_read_poll = fd_read_poll;
        ioh->fd_read = fd_read;
        ioh->fd_write = fd_write;
        ioh->opaque = opaque;
2781
        ioh->deleted = 0;
B
bellard 已提交
2782
    }
2783 2784 2785
    return 0;
}

2786 2787 2788
int qemu_set_fd_handler(int fd,
                        IOHandler *fd_read,
                        IOHandler *fd_write,
B
bellard 已提交
2789
                        void *opaque)
2790
{
B
bellard 已提交
2791
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2792 2793
}

A
aliguori 已提交
2794
#ifdef _WIN32
2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829
/***********************************************************/
/* Polling handling */

typedef struct PollingEntry {
    PollingFunc *func;
    void *opaque;
    struct PollingEntry *next;
} PollingEntry;

static PollingEntry *first_polling_entry;

int qemu_add_polling_cb(PollingFunc *func, void *opaque)
{
    PollingEntry **ppe, *pe;
    pe = qemu_mallocz(sizeof(PollingEntry));
    pe->func = func;
    pe->opaque = opaque;
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
    *ppe = pe;
    return 0;
}

void qemu_del_polling_cb(PollingFunc *func, void *opaque)
{
    PollingEntry **ppe, *pe;
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
        pe = *ppe;
        if (pe->func == func && pe->opaque == opaque) {
            *ppe = pe->next;
            qemu_free(pe);
            break;
        }
    }
}

2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
/***********************************************************/
/* Wait objects support */
typedef struct WaitObjects {
    int num;
    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
    WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
    void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
} WaitObjects;

static WaitObjects wait_objects = {0};
2840

2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866
int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
{
    WaitObjects *w = &wait_objects;

    if (w->num >= MAXIMUM_WAIT_OBJECTS)
        return -1;
    w->events[w->num] = handle;
    w->func[w->num] = func;
    w->opaque[w->num] = opaque;
    w->num++;
    return 0;
}

void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
{
    int i, found;
    WaitObjects *w = &wait_objects;

    found = 0;
    for (i = 0; i < w->num; i++) {
        if (w->events[i] == handle)
            found = 1;
        if (found) {
            w->events[i] = w->events[i + 1];
            w->func[i] = w->func[i + 1];
            w->opaque[i] = w->opaque[i + 1];
2867
        }
2868 2869 2870 2871 2872 2873
    }
    if (found)
        w->num--;
}
#endif

2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893
/***********************************************************/
/* ram save/restore */

static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
{
    int v;

    v = qemu_get_byte(f);
    switch(v) {
    case 0:
        if (qemu_get_buffer(f, buf, len) != len)
            return -EIO;
        break;
    case 1:
        v = qemu_get_byte(f);
        memset(buf, v, len);
        break;
    default:
        return -EINVAL;
    }
A
aliguori 已提交
2894 2895 2896 2897

    if (qemu_file_has_error(f))
        return -EIO;

2898 2899 2900
    return 0;
}

2901 2902
static int ram_load_v1(QEMUFile *f, void *opaque)
{
2903 2904
    int ret;
    ram_addr_t i;
2905

P
pbrook 已提交
2906
    if (qemu_get_be32(f) != last_ram_offset)
2907
        return -EINVAL;
P
pbrook 已提交
2908
    for(i = 0; i < last_ram_offset; i+= TARGET_PAGE_SIZE) {
P
pbrook 已提交
2909
        ret = ram_get_page(f, qemu_get_ram_ptr(i), TARGET_PAGE_SIZE);
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
        if (ret)
            return ret;
    }
    return 0;
}

#define BDRV_HASH_BLOCK_SIZE 1024
#define IOBUF_SIZE 4096
#define RAM_CBLOCK_MAGIC 0xfabe

typedef struct RamDecompressState {
    z_stream zstream;
    QEMUFile *f;
    uint8_t buf[IOBUF_SIZE];
} RamDecompressState;

static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
{
    int ret;
    memset(s, 0, sizeof(*s));
    s->f = f;
    ret = inflateInit(&s->zstream);
    if (ret != Z_OK)
        return -1;
    return 0;
}

static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
{
    int ret, clen;

    s->zstream.avail_out = len;
    s->zstream.next_out = buf;
    while (s->zstream.avail_out > 0) {
        if (s->zstream.avail_in == 0) {
            if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
                return -1;
            clen = qemu_get_be16(s->f);
            if (clen > IOBUF_SIZE)
                return -1;
            qemu_get_buffer(s->f, s->buf, clen);
            s->zstream.avail_in = clen;
            s->zstream.next_in = s->buf;
        }
        ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
        if (ret != Z_OK && ret != Z_STREAM_END) {
            return -1;
        }
    }
    return 0;
}

static void ram_decompress_close(RamDecompressState *s)
{
    inflateEnd(&s->zstream);
}

2967 2968 2969 2970 2971 2972 2973
#define RAM_SAVE_FLAG_FULL	0x01
#define RAM_SAVE_FLAG_COMPRESS	0x02
#define RAM_SAVE_FLAG_MEM_SIZE	0x04
#define RAM_SAVE_FLAG_PAGE	0x08
#define RAM_SAVE_FLAG_EOS	0x10

static int is_dup_page(uint8_t *page, uint8_t ch)
2974
{
2975 2976 2977
    uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
    uint32_t *array = (uint32_t *)page;
    int i;
2978

2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993
    for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
        if (array[i] != val)
            return 0;
    }

    return 1;
}

static int ram_save_block(QEMUFile *f)
{
    static ram_addr_t current_addr = 0;
    ram_addr_t saved_addr = current_addr;
    ram_addr_t addr = 0;
    int found = 0;

P
pbrook 已提交
2994
    while (addr < last_ram_offset) {
2995
        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
P
pbrook 已提交
2996
            uint8_t *p;
2997 2998 2999 3000 3001

            cpu_physical_memory_reset_dirty(current_addr,
                                            current_addr + TARGET_PAGE_SIZE,
                                            MIGRATION_DIRTY_FLAG);

P
pbrook 已提交
3002
            p = qemu_get_ram_ptr(current_addr);
3003

P
pbrook 已提交
3004
            if (is_dup_page(p, *p)) {
3005
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
P
pbrook 已提交
3006
                qemu_put_byte(f, *p);
3007 3008
            } else {
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
P
pbrook 已提交
3009
                qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
3010
            }
3011 3012 3013

            found = 1;
            break;
3014
        }
3015
        addr += TARGET_PAGE_SIZE;
P
pbrook 已提交
3016
        current_addr = (saved_addr + addr) % last_ram_offset;
3017
    }
3018 3019

    return found;
3020 3021
}

3022
static uint64_t bytes_transferred = 0;
3023 3024 3025 3026 3027 3028

static ram_addr_t ram_save_remaining(void)
{
    ram_addr_t addr;
    ram_addr_t count = 0;

P
pbrook 已提交
3029
    for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3030 3031 3032 3033 3034 3035 3036
        if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
            count++;
    }

    return count;
}

3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051
uint64_t ram_bytes_remaining(void)
{
    return ram_save_remaining() * TARGET_PAGE_SIZE;
}

uint64_t ram_bytes_transferred(void)
{
    return bytes_transferred;
}

uint64_t ram_bytes_total(void)
{
    return last_ram_offset;
}

3052 3053 3054
static int ram_save_live(QEMUFile *f, int stage, void *opaque)
{
    ram_addr_t addr;
3055 3056 3057
    uint64_t bytes_transferred_last;
    double bwidth = 0;
    uint64_t expected_time = 0;
3058

3059
    if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
3060 3061 3062 3063
        qemu_file_set_error(f);
        return 0;
    }

3064 3065
    if (stage == 1) {
        /* Make sure all dirty bits are set */
P
pbrook 已提交
3066
        for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3067 3068 3069
            if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
                cpu_physical_memory_set_dirty(addr);
        }
3070

3071 3072 3073
        /* Enable dirty memory tracking */
        cpu_physical_memory_set_dirty_tracking(1);

P
pbrook 已提交
3074
        qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
3075 3076
    }

3077 3078 3079
    bytes_transferred_last = bytes_transferred;
    bwidth = get_clock();

3080 3081 3082 3083
    while (!qemu_file_rate_limit(f)) {
        int ret;

        ret = ram_save_block(f);
3084
        bytes_transferred += ret * TARGET_PAGE_SIZE;
3085 3086 3087 3088
        if (ret == 0) /* no more blocks */
            break;
    }

3089 3090 3091 3092 3093 3094 3095 3096
    bwidth = get_clock() - bwidth;
    bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;

    /* if we haven't transferred anything this round, force expected_time to a
     * a very high value, but without crashing */
    if (bwidth == 0)
        bwidth = 0.000001;

3097 3098 3099 3100 3101
    /* try transferring iterative blocks of memory */

    if (stage == 3) {

        /* flush all remaining blocks regardless of rate limiting */
3102 3103 3104
        while (ram_save_block(f) != 0) {
            bytes_transferred += TARGET_PAGE_SIZE;
        }
3105
        cpu_physical_memory_set_dirty_tracking(0);
3106 3107 3108 3109
    }

    qemu_put_be64(f, RAM_SAVE_FLAG_EOS);

3110 3111 3112
    expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;

    return (stage == 2) && (expected_time <= migrate_max_downtime());
3113 3114 3115
}

static int ram_load_dead(QEMUFile *f, void *opaque)
3116
{
3117 3118
    RamDecompressState s1, *s = &s1;
    uint8_t buf[10];
3119
    ram_addr_t i;
3120

3121 3122
    if (ram_decompress_open(s, f) < 0)
        return -EINVAL;
P
pbrook 已提交
3123
    for(i = 0; i < last_ram_offset; i+= BDRV_HASH_BLOCK_SIZE) {
3124 3125 3126 3127 3128
        if (ram_decompress_buf(s, buf, 1) < 0) {
            fprintf(stderr, "Error while reading ram block header\n");
            goto error;
        }
        if (buf[0] == 0) {
P
pbrook 已提交
3129 3130
            if (ram_decompress_buf(s, qemu_get_ram_ptr(i),
                                   BDRV_HASH_BLOCK_SIZE) < 0) {
3131
                fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3132 3133
                goto error;
            }
3134
        } else {
3135 3136 3137 3138
        error:
            printf("Error block header\n");
            return -EINVAL;
        }
3139
    }
3140
    ram_decompress_close(s);
3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153

    return 0;
}

static int ram_load(QEMUFile *f, void *opaque, int version_id)
{
    ram_addr_t addr;
    int flags;

    if (version_id == 1)
        return ram_load_v1(f, opaque);

    if (version_id == 2) {
P
pbrook 已提交
3154
        if (qemu_get_be32(f) != last_ram_offset)
3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
            return -EINVAL;
        return ram_load_dead(f, opaque);
    }

    if (version_id != 3)
        return -EINVAL;

    do {
        addr = qemu_get_be64(f);

        flags = addr & ~TARGET_PAGE_MASK;
        addr &= TARGET_PAGE_MASK;

        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
P
pbrook 已提交
3169
            if (addr != last_ram_offset)
3170 3171 3172 3173 3174 3175 3176 3177 3178 3179
                return -EINVAL;
        }

        if (flags & RAM_SAVE_FLAG_FULL) {
            if (ram_load_dead(f, opaque) < 0)
                return -EINVAL;
        }
        
        if (flags & RAM_SAVE_FLAG_COMPRESS) {
            uint8_t ch = qemu_get_byte(f);
3180 3181
            memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
#ifndef _WIN32
3182 3183 3184
            if (ch == 0 &&
                (!kvm_enabled() || kvm_has_sync_mmu())) {
                madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
3185
            }
3186
#endif
3187
        } else if (flags & RAM_SAVE_FLAG_PAGE)
P
pbrook 已提交
3188
            qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
3189 3190
    } while (!(flags & RAM_SAVE_FLAG_EOS));

3191 3192 3193
    return 0;
}

A
aliguori 已提交
3194 3195
void qemu_service_io(void)
{
3196
    qemu_notify_event();
A
aliguori 已提交
3197 3198
}

B
bellard 已提交
3199 3200 3201 3202 3203 3204 3205
/***********************************************************/
/* bottom halves (can be seen as timers which expire ASAP) */

struct QEMUBH {
    QEMUBHFunc *cb;
    void *opaque;
    int scheduled;
A
aliguori 已提交
3206 3207
    int idle;
    int deleted;
B
bellard 已提交
3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218
    QEMUBH *next;
};

static QEMUBH *first_bh = NULL;

QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
{
    QEMUBH *bh;
    bh = qemu_mallocz(sizeof(QEMUBH));
    bh->cb = cb;
    bh->opaque = opaque;
A
aliguori 已提交
3219 3220
    bh->next = first_bh;
    first_bh = bh;
B
bellard 已提交
3221 3222 3223
    return bh;
}

B
bellard 已提交
3224
int qemu_bh_poll(void)
B
bellard 已提交
3225
{
A
aliguori 已提交
3226
    QEMUBH *bh, **bhp;
B
bellard 已提交
3227
    int ret;
B
bellard 已提交
3228

B
bellard 已提交
3229
    ret = 0;
A
aliguori 已提交
3230 3231 3232 3233 3234 3235 3236 3237
    for (bh = first_bh; bh; bh = bh->next) {
        if (!bh->deleted && bh->scheduled) {
            bh->scheduled = 0;
            if (!bh->idle)
                ret = 1;
            bh->idle = 0;
            bh->cb(bh->opaque);
        }
B
bellard 已提交
3238
    }
A
aliguori 已提交
3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250

    /* remove deleted bhs */
    bhp = &first_bh;
    while (*bhp) {
        bh = *bhp;
        if (bh->deleted) {
            *bhp = bh->next;
            qemu_free(bh);
        } else
            bhp = &bh->next;
    }

B
bellard 已提交
3251
    return ret;
B
bellard 已提交
3252 3253
}

A
aliguori 已提交
3254 3255 3256 3257 3258 3259 3260 3261
void qemu_bh_schedule_idle(QEMUBH *bh)
{
    if (bh->scheduled)
        return;
    bh->scheduled = 1;
    bh->idle = 1;
}

B
bellard 已提交
3262 3263 3264 3265 3266
void qemu_bh_schedule(QEMUBH *bh)
{
    if (bh->scheduled)
        return;
    bh->scheduled = 1;
A
aliguori 已提交
3267
    bh->idle = 0;
B
bellard 已提交
3268
    /* stop the currently executing CPU to execute the BH ASAP */
3269
    qemu_notify_event();
B
bellard 已提交
3270 3271 3272 3273
}

void qemu_bh_cancel(QEMUBH *bh)
{
A
aliguori 已提交
3274
    bh->scheduled = 0;
B
bellard 已提交
3275 3276 3277 3278
}

void qemu_bh_delete(QEMUBH *bh)
{
A
aliguori 已提交
3279 3280
    bh->scheduled = 0;
    bh->deleted = 1;
B
bellard 已提交
3281 3282
}

A
aliguori 已提交
3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302
static void qemu_bh_update_timeout(int *timeout)
{
    QEMUBH *bh;

    for (bh = first_bh; bh; bh = bh->next) {
        if (!bh->deleted && bh->scheduled) {
            if (bh->idle) {
                /* idle bottom halves will be polled at least
                 * every 10ms */
                *timeout = MIN(10, *timeout);
            } else {
                /* non-idle bottom halves will be executed
                 * immediately */
                *timeout = 0;
                break;
            }
        }
    }
}

3303 3304 3305
/***********************************************************/
/* machine registration */

B
blueswir1 已提交
3306
static QEMUMachine *first_machine = NULL;
3307
QEMUMachine *current_machine = NULL;
3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319

int qemu_register_machine(QEMUMachine *m)
{
    QEMUMachine **pm;
    pm = &first_machine;
    while (*pm != NULL)
        pm = &(*pm)->next;
    m->next = NULL;
    *pm = m;
    return 0;
}

3320
static QEMUMachine *find_machine(const char *name)
3321 3322 3323 3324 3325 3326
{
    QEMUMachine *m;

    for(m = first_machine; m != NULL; m = m->next) {
        if (!strcmp(m->name, name))
            return m;
M
Mark McLoughlin 已提交
3327 3328
        if (m->alias && !strcmp(m->alias, name))
            return m;
3329 3330 3331 3332
    }
    return NULL;
}

3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344
static QEMUMachine *find_default_machine(void)
{
    QEMUMachine *m;

    for(m = first_machine; m != NULL; m = m->next) {
        if (m->is_default) {
            return m;
        }
    }
    return NULL;
}

3345 3346 3347
/***********************************************************/
/* main execution loop */

3348
static void gui_update(void *opaque)
3349
{
3350
    uint64_t interval = GUI_REFRESH_INTERVAL;
3351
    DisplayState *ds = opaque;
3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362
    DisplayChangeListener *dcl = ds->listeners;

    dpy_refresh(ds);

    while (dcl != NULL) {
        if (dcl->gui_timer_interval &&
            dcl->gui_timer_interval < interval)
            interval = dcl->gui_timer_interval;
        dcl = dcl->next;
    }
    qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3363 3364
}

B
blueswir1 已提交
3365 3366 3367 3368 3369 3370 3371
static void nographic_update(void *opaque)
{
    uint64_t interval = GUI_REFRESH_INTERVAL;

    qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
}

B
bellard 已提交
3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
struct vm_change_state_entry {
    VMChangeStateHandler *cb;
    void *opaque;
    LIST_ENTRY (vm_change_state_entry) entries;
};

static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;

VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
                                                     void *opaque)
{
    VMChangeStateEntry *e;

    e = qemu_mallocz(sizeof (*e));

    e->cb = cb;
    e->opaque = opaque;
    LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
    return e;
}

void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
{
    LIST_REMOVE (e, entries);
    qemu_free (e);
}

3399
static void vm_state_notify(int running, int reason)
B
bellard 已提交
3400 3401 3402 3403
{
    VMChangeStateEntry *e;

    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3404
        e->cb(e->opaque, running, reason);
B
bellard 已提交
3405 3406 3407
    }
}

3408 3409 3410
static void resume_all_vcpus(void);
static void pause_all_vcpus(void);

3411 3412 3413 3414 3415
void vm_start(void)
{
    if (!vm_running) {
        cpu_enable_ticks();
        vm_running = 1;
3416
        vm_state_notify(1, 0);
3417
        qemu_rearm_alarm_timer(alarm_timer);
3418
        resume_all_vcpus();
3419 3420 3421
    }
}

3422 3423 3424
/* reset/shutdown handler */

typedef struct QEMUResetEntry {
J
Jan Kiszka 已提交
3425
    TAILQ_ENTRY(QEMUResetEntry) entry;
3426 3427 3428 3429
    QEMUResetHandler *func;
    void *opaque;
} QEMUResetEntry;

J
Jan Kiszka 已提交
3430 3431
static TAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
    TAILQ_HEAD_INITIALIZER(reset_handlers);
3432 3433
static int reset_requested;
static int shutdown_requested;
B
bellard 已提交
3434
static int powerdown_requested;
3435
static int debug_requested;
3436
static int vmstop_requested;
3437

A
aurel32 已提交
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458
int qemu_shutdown_requested(void)
{
    int r = shutdown_requested;
    shutdown_requested = 0;
    return r;
}

int qemu_reset_requested(void)
{
    int r = reset_requested;
    reset_requested = 0;
    return r;
}

int qemu_powerdown_requested(void)
{
    int r = powerdown_requested;
    powerdown_requested = 0;
    return r;
}

3459 3460 3461 3462 3463 3464 3465
static int qemu_debug_requested(void)
{
    int r = debug_requested;
    debug_requested = 0;
    return r;
}

3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477
static int qemu_vmstop_requested(void)
{
    int r = vmstop_requested;
    vmstop_requested = 0;
    return r;
}

static void do_vm_stop(int reason)
{
    if (vm_running) {
        cpu_disable_ticks();
        vm_running = 0;
3478
        pause_all_vcpus();
3479 3480 3481 3482
        vm_state_notify(0, reason);
    }
}

3483
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3484
{
J
Jan Kiszka 已提交
3485
    QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
3486 3487 3488

    re->func = func;
    re->opaque = opaque;
J
Jan Kiszka 已提交
3489
    TAILQ_INSERT_TAIL(&reset_handlers, re, entry);
3490 3491
}

J
Jan Kiszka 已提交
3492
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
3493 3494 3495
{
    QEMUResetEntry *re;

J
Jan Kiszka 已提交
3496
    TAILQ_FOREACH(re, &reset_handlers, entry) {
J
Jan Kiszka 已提交
3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510
        if (re->func == func && re->opaque == opaque) {
            TAILQ_REMOVE(&reset_handlers, re, entry);
            qemu_free(re);
            return;
        }
    }
}

void qemu_system_reset(void)
{
    QEMUResetEntry *re, *nre;

    /* reset all devices */
    TAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
3511 3512 3513 3514 3515 3516
        re->func(re->opaque);
    }
}

void qemu_system_reset_request(void)
{
B
bellard 已提交
3517 3518 3519 3520 3521
    if (no_reboot) {
        shutdown_requested = 1;
    } else {
        reset_requested = 1;
    }
3522
    qemu_notify_event();
3523 3524 3525 3526 3527
}

void qemu_system_shutdown_request(void)
{
    shutdown_requested = 1;
3528
    qemu_notify_event();
3529 3530
}

B
bellard 已提交
3531 3532 3533
void qemu_system_powerdown_request(void)
{
    powerdown_requested = 1;
3534 3535 3536
    qemu_notify_event();
}

3537 3538
#ifdef CONFIG_IOTHREAD
static void qemu_system_vmstop_request(int reason)
3539
{
3540 3541
    vmstop_requested = reason;
    qemu_notify_event();
3542
}
3543
#endif
3544

3545 3546 3547 3548
#ifndef _WIN32
static int io_thread_fd = -1;

static void qemu_event_increment(void)
3549
{
3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
    static const char byte = 0;

    if (io_thread_fd == -1)
        return;

    write(io_thread_fd, &byte, sizeof(byte));
}

static void qemu_event_read(void *opaque)
{
    int fd = (unsigned long)opaque;
    ssize_t len;

    /* Drain the notify pipe */
    do {
        char buffer[512];
        len = read(fd, buffer, sizeof(buffer));
    } while ((len == -1 && errno == EINTR) || len > 0);
}

static int qemu_event_init(void)
{
    int err;
    int fds[2];

    err = pipe(fds);
    if (err == -1)
        return -errno;

    err = fcntl_setfl(fds[0], O_NONBLOCK);
    if (err < 0)
        goto fail;

    err = fcntl_setfl(fds[1], O_NONBLOCK);
    if (err < 0)
        goto fail;

    qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
                         (void *)(unsigned long)fds[0]);

    io_thread_fd = fds[1];
J
Jan Kiszka 已提交
3591 3592
    return 0;

3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612
fail:
    close(fds[0]);
    close(fds[1]);
    return err;
}
#else
HANDLE qemu_event_handle;

static void dummy_event_handler(void *opaque)
{
}

static int qemu_event_init(void)
{
    qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (!qemu_event_handle) {
        perror("Failed CreateEvent");
        return -1;
    }
    qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3613 3614 3615
    return 0;
}

3616 3617 3618 3619 3620 3621
static void qemu_event_increment(void)
{
    SetEvent(qemu_event_handle);
}
#endif

3622 3623 3624 3625 3626 3627 3628 3629 3630 3631
static int cpu_can_run(CPUState *env)
{
    if (env->stop)
        return 0;
    if (env->stopped)
        return 0;
    return 1;
}

#ifndef CONFIG_IOTHREAD
3632 3633 3634 3635 3636
static int qemu_init_main_loop(void)
{
    return qemu_event_init();
}

3637 3638 3639 3640 3641 3642
void qemu_init_vcpu(void *_env)
{
    CPUState *env = _env;

    if (kvm_enabled())
        kvm_init_vcpu(env);
3643 3644
    env->nr_cores = smp_cores;
    env->nr_threads = smp_threads;
3645 3646 3647
    return;
}

3648 3649 3650 3651 3652
int qemu_cpu_self(void *env)
{
    return 1;
}

3653 3654 3655 3656 3657 3658 3659 3660
static void resume_all_vcpus(void)
{
}

static void pause_all_vcpus(void)
{
}

3661 3662 3663 3664 3665
void qemu_cpu_kick(void *env)
{
    return;
}

3666 3667 3668 3669 3670 3671
void qemu_notify_event(void)
{
    CPUState *env = cpu_single_env;

    if (env) {
        cpu_exit(env);
3672
    }
3673 3674
}

3675 3676 3677
#define qemu_mutex_lock_iothread() do { } while (0)
#define qemu_mutex_unlock_iothread() do { } while (0)

3678 3679 3680 3681 3682
void vm_stop(int reason)
{
    do_vm_stop(reason);
}

3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755
#else /* CONFIG_IOTHREAD */

#include "qemu-thread.h"

QemuMutex qemu_global_mutex;
static QemuMutex qemu_fair_mutex;

static QemuThread io_thread;

static QemuThread *tcg_cpu_thread;
static QemuCond *tcg_halt_cond;

static int qemu_system_ready;
/* cpu creation */
static QemuCond qemu_cpu_cond;
/* system init */
static QemuCond qemu_system_cond;
static QemuCond qemu_pause_cond;

static void block_io_signals(void);
static void unblock_io_signals(void);
static int tcg_has_work(void);

static int qemu_init_main_loop(void)
{
    int ret;

    ret = qemu_event_init();
    if (ret)
        return ret;

    qemu_cond_init(&qemu_pause_cond);
    qemu_mutex_init(&qemu_fair_mutex);
    qemu_mutex_init(&qemu_global_mutex);
    qemu_mutex_lock(&qemu_global_mutex);

    unblock_io_signals();
    qemu_thread_self(&io_thread);

    return 0;
}

static void qemu_wait_io_event(CPUState *env)
{
    while (!tcg_has_work())
        qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);

    qemu_mutex_unlock(&qemu_global_mutex);

    /*
     * Users of qemu_global_mutex can be starved, having no chance
     * to acquire it since this path will get to it first.
     * So use another lock to provide fairness.
     */
    qemu_mutex_lock(&qemu_fair_mutex);
    qemu_mutex_unlock(&qemu_fair_mutex);

    qemu_mutex_lock(&qemu_global_mutex);
    if (env->stop) {
        env->stop = 0;
        env->stopped = 1;
        qemu_cond_signal(&qemu_pause_cond);
    }
}

static int qemu_cpu_exec(CPUState *env);

static void *kvm_cpu_thread_fn(void *arg)
{
    CPUState *env = arg;

    block_io_signals();
    qemu_thread_self(env->thread);
3756
    kvm_init_vcpu(env);
3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967

    /* signal CPU creation */
    qemu_mutex_lock(&qemu_global_mutex);
    env->created = 1;
    qemu_cond_signal(&qemu_cpu_cond);

    /* and wait for machine initialization */
    while (!qemu_system_ready)
        qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);

    while (1) {
        if (cpu_can_run(env))
            qemu_cpu_exec(env);
        qemu_wait_io_event(env);
    }

    return NULL;
}

static void tcg_cpu_exec(void);

static void *tcg_cpu_thread_fn(void *arg)
{
    CPUState *env = arg;

    block_io_signals();
    qemu_thread_self(env->thread);

    /* signal CPU creation */
    qemu_mutex_lock(&qemu_global_mutex);
    for (env = first_cpu; env != NULL; env = env->next_cpu)
        env->created = 1;
    qemu_cond_signal(&qemu_cpu_cond);

    /* and wait for machine initialization */
    while (!qemu_system_ready)
        qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);

    while (1) {
        tcg_cpu_exec();
        qemu_wait_io_event(cur_cpu);
    }

    return NULL;
}

void qemu_cpu_kick(void *_env)
{
    CPUState *env = _env;
    qemu_cond_broadcast(env->halt_cond);
    if (kvm_enabled())
        qemu_thread_signal(env->thread, SIGUSR1);
}

int qemu_cpu_self(void *env)
{
    return (cpu_single_env != NULL);
}

static void cpu_signal(int sig)
{
    if (cpu_single_env)
        cpu_exit(cpu_single_env);
}

static void block_io_signals(void)
{
    sigset_t set;
    struct sigaction sigact;

    sigemptyset(&set);
    sigaddset(&set, SIGUSR2);
    sigaddset(&set, SIGIO);
    sigaddset(&set, SIGALRM);
    pthread_sigmask(SIG_BLOCK, &set, NULL);

    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);

    memset(&sigact, 0, sizeof(sigact));
    sigact.sa_handler = cpu_signal;
    sigaction(SIGUSR1, &sigact, NULL);
}

static void unblock_io_signals(void)
{
    sigset_t set;

    sigemptyset(&set);
    sigaddset(&set, SIGUSR2);
    sigaddset(&set, SIGIO);
    sigaddset(&set, SIGALRM);
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);

    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    pthread_sigmask(SIG_BLOCK, &set, NULL);
}

static void qemu_signal_lock(unsigned int msecs)
{
    qemu_mutex_lock(&qemu_fair_mutex);

    while (qemu_mutex_trylock(&qemu_global_mutex)) {
        qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
        if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
            break;
    }
    qemu_mutex_unlock(&qemu_fair_mutex);
}

static void qemu_mutex_lock_iothread(void)
{
    if (kvm_enabled()) {
        qemu_mutex_lock(&qemu_fair_mutex);
        qemu_mutex_lock(&qemu_global_mutex);
        qemu_mutex_unlock(&qemu_fair_mutex);
    } else
        qemu_signal_lock(100);
}

static void qemu_mutex_unlock_iothread(void)
{
    qemu_mutex_unlock(&qemu_global_mutex);
}

static int all_vcpus_paused(void)
{
    CPUState *penv = first_cpu;

    while (penv) {
        if (!penv->stopped)
            return 0;
        penv = (CPUState *)penv->next_cpu;
    }

    return 1;
}

static void pause_all_vcpus(void)
{
    CPUState *penv = first_cpu;

    while (penv) {
        penv->stop = 1;
        qemu_thread_signal(penv->thread, SIGUSR1);
        qemu_cpu_kick(penv);
        penv = (CPUState *)penv->next_cpu;
    }

    while (!all_vcpus_paused()) {
        qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
        penv = first_cpu;
        while (penv) {
            qemu_thread_signal(penv->thread, SIGUSR1);
            penv = (CPUState *)penv->next_cpu;
        }
    }
}

static void resume_all_vcpus(void)
{
    CPUState *penv = first_cpu;

    while (penv) {
        penv->stop = 0;
        penv->stopped = 0;
        qemu_thread_signal(penv->thread, SIGUSR1);
        qemu_cpu_kick(penv);
        penv = (CPUState *)penv->next_cpu;
    }
}

static void tcg_init_vcpu(void *_env)
{
    CPUState *env = _env;
    /* share a single thread for all cpus with TCG */
    if (!tcg_cpu_thread) {
        env->thread = qemu_mallocz(sizeof(QemuThread));
        env->halt_cond = qemu_mallocz(sizeof(QemuCond));
        qemu_cond_init(env->halt_cond);
        qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
        while (env->created == 0)
            qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
        tcg_cpu_thread = env->thread;
        tcg_halt_cond = env->halt_cond;
    } else {
        env->thread = tcg_cpu_thread;
        env->halt_cond = tcg_halt_cond;
    }
}

static void kvm_start_vcpu(CPUState *env)
{
    env->thread = qemu_mallocz(sizeof(QemuThread));
    env->halt_cond = qemu_mallocz(sizeof(QemuCond));
    qemu_cond_init(env->halt_cond);
    qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
    while (env->created == 0)
        qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
}

void qemu_init_vcpu(void *_env)
{
    CPUState *env = _env;

    if (kvm_enabled())
        kvm_start_vcpu(env);
    else
        tcg_init_vcpu(env);
3968 3969
    env->nr_cores = smp_cores;
    env->nr_threads = smp_threads;
3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999
}

void qemu_notify_event(void)
{
    qemu_event_increment();
}

void vm_stop(int reason)
{
    QemuThread me;
    qemu_thread_self(&me);

    if (!qemu_thread_equal(&me, &io_thread)) {
        qemu_system_vmstop_request(reason);
        /*
         * FIXME: should not return to device code in case
         * vm_stop() has been requested.
         */
        if (cpu_single_env) {
            cpu_exit(cpu_single_env);
            cpu_single_env->stop = 1;
        }
        return;
    }
    do_vm_stop(reason);
}

#endif


T
ths 已提交
4000
#ifdef _WIN32
4001
static void host_main_loop_wait(int *timeout)
A
aliguori 已提交
4002 4003
{
    int ret, ret2, i;
4004 4005
    PollingEntry *pe;

4006

4007 4008 4009 4010 4011
    /* XXX: need to suppress polling by better using win32 events */
    ret = 0;
    for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
        ret |= pe->func(pe->opaque);
    }
4012
    if (ret == 0) {
4013 4014
        int err;
        WaitObjects *w = &wait_objects;
4015

A
aliguori 已提交
4016
        ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
4017 4018 4019
        if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
            if (w->func[ret - WAIT_OBJECT_0])
                w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
4020

4021
            /* Check for additional signaled events */
4022
            for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
4023

4024 4025 4026 4027 4028 4029 4030 4031 4032
                /* Check if event is signaled */
                ret2 = WaitForSingleObject(w->events[i], 0);
                if(ret2 == WAIT_OBJECT_0) {
                    if (w->func[i])
                        w->func[i](w->opaque[i]);
                } else if (ret2 == WAIT_TIMEOUT) {
                } else {
                    err = GetLastError();
                    fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
4033 4034
                }
            }
4035 4036 4037
        } else if (ret == WAIT_TIMEOUT) {
        } else {
            err = GetLastError();
4038
            fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
4039
        }
4040
    }
A
aliguori 已提交
4041 4042 4043 4044

    *timeout = 0;
}
#else
4045
static void host_main_loop_wait(int *timeout)
A
aliguori 已提交
4046 4047
{
}
B
bellard 已提交
4048
#endif
A
aliguori 已提交
4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060

void main_loop_wait(int timeout)
{
    IOHandlerRecord *ioh;
    fd_set rfds, wfds, xfds;
    int ret, nfds;
    struct timeval tv;

    qemu_bh_update_timeout(&timeout);

    host_main_loop_wait(&timeout);

B
bellard 已提交
4061 4062
    /* poll any events */
    /* XXX: separate device handlers from system ones */
4063
    nfds = -1;
B
bellard 已提交
4064 4065
    FD_ZERO(&rfds);
    FD_ZERO(&wfds);
4066
    FD_ZERO(&xfds);
B
bellard 已提交
4067
    for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4068 4069
        if (ioh->deleted)
            continue;
B
bellard 已提交
4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082
        if (ioh->fd_read &&
            (!ioh->fd_read_poll ||
             ioh->fd_read_poll(ioh->opaque) != 0)) {
            FD_SET(ioh->fd, &rfds);
            if (ioh->fd > nfds)
                nfds = ioh->fd;
        }
        if (ioh->fd_write) {
            FD_SET(ioh->fd, &wfds);
            if (ioh->fd > nfds)
                nfds = ioh->fd;
        }
    }
4083

A
aliguori 已提交
4084 4085 4086
    tv.tv_sec = timeout / 1000;
    tv.tv_usec = (timeout % 1000) * 1000;

J
Jan Kiszka 已提交
4087 4088
    slirp_select_fill(&nfds, &rfds, &wfds, &xfds);

4089
    qemu_mutex_unlock_iothread();
4090
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4091
    qemu_mutex_lock_iothread();
B
bellard 已提交
4092
    if (ret > 0) {
4093 4094 4095
        IOHandlerRecord **pioh;

        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4096
            if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
B
bellard 已提交
4097
                ioh->fd_read(ioh->opaque);
B
bellard 已提交
4098
            }
4099
            if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
B
bellard 已提交
4100
                ioh->fd_write(ioh->opaque);
4101
            }
B
bellard 已提交
4102
        }
4103 4104 4105 4106 4107 4108 4109 4110

	/* remove deleted IO handlers */
	pioh = &first_io_handler;
	while (*pioh) {
            ioh = *pioh;
            if (ioh->deleted) {
                *pioh = ioh->next;
                qemu_free(ioh);
4111
            } else
4112 4113
                pioh = &ioh->next;
        }
B
bellard 已提交
4114
    }
J
Jan Kiszka 已提交
4115 4116

    slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
B
bellard 已提交
4117

4118 4119 4120 4121 4122 4123
    /* rearm timer, if not periodic */
    if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
        alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
        qemu_rearm_alarm_timer(alarm_timer);
    }

4124
    /* vm time timers */
4125 4126 4127 4128 4129
    if (vm_running) {
        if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
            qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
                qemu_get_clock(vm_clock));
    }
4130 4131 4132 4133 4134

    /* real time timers */
    qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
                    qemu_get_clock(rt_clock));

P
pbrook 已提交
4135 4136 4137
    /* Check bottom-halves last in case any of the earlier events triggered
       them.  */
    qemu_bh_poll();
4138

B
bellard 已提交
4139 4140
}

4141
static int qemu_cpu_exec(CPUState *env)
B
bellard 已提交
4142
{
4143
    int ret;
4144 4145 4146
#ifdef CONFIG_PROFILER
    int64_t ti;
#endif
B
bellard 已提交
4147

4148
#ifdef CONFIG_PROFILER
4149
    ti = profile_getclock();
4150
#endif
4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166
    if (use_icount) {
        int64_t count;
        int decr;
        qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
        env->icount_decr.u16.low = 0;
        env->icount_extra = 0;
        count = qemu_next_deadline();
        count = (count + (1 << icount_time_shift) - 1)
                >> icount_time_shift;
        qemu_icount += count;
        decr = (count > 0xffff) ? 0xffff : count;
        count -= decr;
        env->icount_decr.u16.low = decr;
        env->icount_extra = count;
    }
    ret = cpu_exec(env);
4167
#ifdef CONFIG_PROFILER
4168
    qemu_time += profile_getclock() - ti;
4169
#endif
4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180
    if (use_icount) {
        /* Fold pending instructions back into the
           instruction counter, and clear the interrupt flag.  */
        qemu_icount -= (env->icount_decr.u16.low
                        + env->icount_extra);
        env->icount_decr.u32 = 0;
        env->icount_extra = 0;
    }
    return ret;
}

4181 4182
static void tcg_cpu_exec(void)
{
4183
    int ret = 0;
4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195

    if (next_cpu == NULL)
        next_cpu = first_cpu;
    for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
        CPUState *env = cur_cpu = next_cpu;

        if (!vm_running)
            break;
        if (timer_alarm_pending) {
            timer_alarm_pending = 0;
            break;
        }
4196 4197
        if (cpu_can_run(env))
            ret = qemu_cpu_exec(env);
4198 4199 4200 4201 4202 4203 4204 4205
        if (ret == EXCP_DEBUG) {
            gdb_set_stop_cpu(env);
            debug_requested = 1;
            break;
        }
    }
}

4206 4207
static int cpu_has_work(CPUState *env)
{
4208 4209 4210 4211
    if (env->stop)
        return 1;
    if (env->stopped)
        return 0;
4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230
    if (!env->halted)
        return 1;
    if (qemu_cpu_has_work(env))
        return 1;
    return 0;
}

static int tcg_has_work(void)
{
    CPUState *env;

    for (env = first_cpu; env != NULL; env = env->next_cpu)
        if (cpu_has_work(env))
            return 1;
    return 0;
}

static int qemu_calculate_timeout(void)
{
4231
#ifndef CONFIG_IOTHREAD
4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276
    int timeout;

    if (!vm_running)
        timeout = 5000;
    else if (tcg_has_work())
        timeout = 0;
    else if (!use_icount)
        timeout = 5000;
    else {
     /* XXX: use timeout computed from timers */
        int64_t add;
        int64_t delta;
        /* Advance virtual time to the next event.  */
        if (use_icount == 1) {
            /* When not using an adaptive execution frequency
               we tend to get badly out of sync with real time,
               so just delay for a reasonable amount of time.  */
            delta = 0;
        } else {
            delta = cpu_get_icount() - cpu_get_clock();
        }
        if (delta > 0) {
            /* If virtual time is ahead of real time then just
               wait for IO.  */
            timeout = (delta / 1000000) + 1;
        } else {
            /* Wait for either IO to occur or the next
               timer event.  */
            add = qemu_next_deadline();
            /* We advance the timer before checking for IO.
               Limit the amount we advance so that early IO
               activity won't get the guest too far ahead.  */
            if (add > 10000000)
                add = 10000000;
            delta += add;
            add = (add + (1 << icount_time_shift) - 1)
                  >> icount_time_shift;
            qemu_icount += add;
            timeout = delta / 1000000;
            if (timeout < 0)
                timeout = 0;
        }
    }

    return timeout;
4277 4278 4279
#else /* CONFIG_IOTHREAD */
    return 1000;
#endif
4280 4281 4282 4283 4284 4285 4286 4287 4288 4289
}

static int vm_can_run(void)
{
    if (powerdown_requested)
        return 0;
    if (reset_requested)
        return 0;
    if (shutdown_requested)
        return 0;
4290 4291
    if (debug_requested)
        return 0;
4292 4293 4294
    return 1;
}

B
Blue Swirl 已提交
4295 4296
qemu_irq qemu_system_powerdown;

4297 4298
static void main_loop(void)
{
4299
    int r;
4300

4301 4302 4303 4304 4305
#ifdef CONFIG_IOTHREAD
    qemu_system_ready = 1;
    qemu_cond_broadcast(&qemu_system_cond);
#endif

4306
    for (;;) {
4307
        do {
4308 4309 4310
#ifdef CONFIG_PROFILER
            int64_t ti;
#endif
4311
#ifndef CONFIG_IOTHREAD
4312
            tcg_cpu_exec();
4313
#endif
4314
#ifdef CONFIG_PROFILER
4315
            ti = profile_getclock();
4316
#endif
4317
            main_loop_wait(qemu_calculate_timeout());
4318
#ifdef CONFIG_PROFILER
4319
            dev_time += profile_getclock() - ti;
4320
#endif
4321
        } while (vm_can_run());
4322

4323 4324
        if (qemu_debug_requested())
            vm_stop(EXCP_DEBUG);
4325 4326 4327 4328 4329 4330 4331
        if (qemu_shutdown_requested()) {
            if (no_shutdown) {
                vm_stop(0);
                no_shutdown = 0;
            } else
                break;
        }
4332 4333
        if (qemu_reset_requested()) {
            pause_all_vcpus();
4334
            qemu_system_reset();
4335 4336
            resume_all_vcpus();
        }
B
Blue Swirl 已提交
4337 4338 4339
        if (qemu_powerdown_requested()) {
            qemu_irq_raise(qemu_system_powerdown);
        }
4340 4341
        if ((r = qemu_vmstop_requested()))
            vm_stop(r);
B
bellard 已提交
4342
    }
4343
    pause_all_vcpus();
B
bellard 已提交
4344 4345
}

P
pbrook 已提交
4346 4347
static void version(void)
{
P
pbrook 已提交
4348
    printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
P
pbrook 已提交
4349 4350
}

4351
static void help(int exitcode)
4352
{
P
pbrook 已提交
4353 4354
    version();
    printf("usage: %s [options] [disk_image]\n"
4355
           "\n"
4356
           "'disk_image' is a raw hard image image for IDE hard disk 0\n"
B
bellard 已提交
4357
           "\n"
4358 4359 4360 4361 4362 4363 4364
#define DEF(option, opt_arg, opt_enum, opt_help)        \
           opt_help
#define DEFHEADING(text) stringify(text) "\n"
#include "qemu-options.h"
#undef DEF
#undef DEFHEADING
#undef GEN_DOCS
4365
           "\n"
B
bellard 已提交
4366
           "During emulation, the following keys are useful:\n"
B
bellard 已提交
4367 4368 4369
           "ctrl-alt-f      toggle full screen\n"
           "ctrl-alt-n      switch to virtual console 'n'\n"
           "ctrl-alt        toggle mouse and keyboard grab\n"
B
bellard 已提交
4370 4371 4372
           "\n"
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
           ,
4373
           "qemu",
B
bellard 已提交
4374
           DEFAULT_RAM_SIZE,
B
bellard 已提交
4375
#ifndef _WIN32
B
bellard 已提交
4376
           DEFAULT_NETWORK_SCRIPT,
T
ths 已提交
4377
           DEFAULT_NETWORK_DOWN_SCRIPT,
B
bellard 已提交
4378
#endif
4379
           DEFAULT_GDBSTUB_PORT,
B
bellard 已提交
4380
           "/tmp/qemu.log");
4381
    exit(exitcode);
4382 4383
}

4384 4385 4386
#define HAS_ARG 0x0001

enum {
4387 4388 4389 4390 4391 4392 4393
#define DEF(option, opt_arg, opt_enum, opt_help)        \
    opt_enum,
#define DEFHEADING(text)
#include "qemu-options.h"
#undef DEF
#undef DEFHEADING
#undef GEN_DOCS
4394 4395 4396 4397 4398 4399 4400 4401
};

typedef struct QEMUOption {
    const char *name;
    int flags;
    int index;
} QEMUOption;

B
blueswir1 已提交
4402
static const QEMUOption qemu_options[] = {
4403
    { "h", 0, QEMU_OPTION_h },
4404 4405 4406 4407 4408 4409 4410
#define DEF(option, opt_arg, opt_enum, opt_help)        \
    { option, opt_arg, opt_enum },
#define DEFHEADING(text)
#include "qemu-options.h"
#undef DEF
#undef DEFHEADING
#undef GEN_DOCS
4411
    { NULL },
B
bellard 已提交
4412 4413
};

4414
#ifdef HAS_AUDIO
4415
struct soundhw soundhw[] = {
4416
#ifdef HAS_AUDIO_CHOICE
A
aurel32 已提交
4417
#if defined(TARGET_I386) || defined(TARGET_MIPS)
B
bellard 已提交
4418 4419 4420 4421 4422 4423 4424 4425
    {
        "pcspk",
        "PC speaker",
        0,
        1,
        { .init_isa = pcspk_audio_init }
    },
#endif
M
malc 已提交
4426 4427

#ifdef CONFIG_SB16
4428 4429 4430 4431 4432 4433 4434
    {
        "sb16",
        "Creative Sound Blaster 16",
        0,
        1,
        { .init_isa = SB16_init }
    },
M
malc 已提交
4435
#endif
4436

M
malc 已提交
4437 4438 4439 4440 4441 4442 4443 4444 4445 4446
#ifdef CONFIG_CS4231A
    {
        "cs4231a",
        "CS4231A",
        0,
        1,
        { .init_isa = cs4231a_init }
    },
#endif

4447
#ifdef CONFIG_ADLIB
4448 4449
    {
        "adlib",
4450
#ifdef HAS_YMF262
4451
        "Yamaha YMF262 (OPL3)",
4452
#else
4453
        "Yamaha YM3812 (OPL2)",
4454
#endif
4455 4456 4457 4458
        0,
        1,
        { .init_isa = Adlib_init }
    },
4459
#endif
4460

4461
#ifdef CONFIG_GUS
4462 4463 4464 4465 4466 4467 4468
    {
        "gus",
        "Gravis Ultrasound GF1",
        0,
        1,
        { .init_isa = GUS_init }
    },
4469
#endif
4470

M
malc 已提交
4471
#ifdef CONFIG_AC97
B
balrog 已提交
4472 4473 4474 4475 4476 4477 4478
    {
        "ac97",
        "Intel 82801AA AC97 Audio",
        0,
        0,
        { .init_pci = ac97_init }
    },
M
malc 已提交
4479
#endif
B
balrog 已提交
4480

M
malc 已提交
4481
#ifdef CONFIG_ES1370
4482 4483 4484 4485 4486 4487 4488
    {
        "es1370",
        "ENSONIQ AudioPCI ES1370",
        0,
        0,
        { .init_pci = es1370_init }
    },
4489
#endif
4490

M
malc 已提交
4491 4492
#endif /* HAS_AUDIO_CHOICE */

4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507
    { NULL, NULL, 0, 0, { NULL } }
};

static void select_soundhw (const char *optarg)
{
    struct soundhw *c;

    if (*optarg == '?') {
    show_valid_cards:

        printf ("Valid sound card names (comma separated):\n");
        for (c = soundhw; c->name; ++c) {
            printf ("%-11s %s\n", c->name, c->descr);
        }
        printf ("\n-soundhw all will enable all of the above\n");
4508 4509 4510
        exit (*optarg != '?');
    }
    else {
4511
        size_t l;
4512 4513 4514 4515
        const char *p;
        char *e;
        int bad_card = 0;

4516 4517 4518 4519 4520 4521
        if (!strcmp (optarg, "all")) {
            for (c = soundhw; c->name; ++c) {
                c->enabled = 1;
            }
            return;
        }
4522

4523
        p = optarg;
4524 4525 4526
        while (*p) {
            e = strchr (p, ',');
            l = !e ? strlen (p) : (size_t) (e - p);
4527 4528

            for (c = soundhw; c->name; ++c) {
4529
                if (!strncmp (c->name, p, l) && !c->name[l]) {
4530
                    c->enabled = 1;
4531 4532 4533
                    break;
                }
            }
4534 4535

            if (!c->name) {
4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554
                if (l > 80) {
                    fprintf (stderr,
                             "Unknown sound card name (too big to show)\n");
                }
                else {
                    fprintf (stderr, "Unknown sound card name `%.*s'\n",
                             (int) l, p);
                }
                bad_card = 1;
            }
            p += l + (e != NULL);
        }

        if (bad_card)
            goto show_valid_cards;
    }
}
#endif

4555 4556 4557 4558
static void select_vgahw (const char *p)
{
    const char *opts;

4559
    vga_interface_type = VGA_NONE;
4560
    if (strstart(p, "std", &opts)) {
4561
        vga_interface_type = VGA_STD;
4562
    } else if (strstart(p, "cirrus", &opts)) {
4563
        vga_interface_type = VGA_CIRRUS;
4564
    } else if (strstart(p, "vmware", &opts)) {
4565
        vga_interface_type = VGA_VMWARE;
4566
    } else if (strstart(p, "xenfb", &opts)) {
4567
        vga_interface_type = VGA_XENFB;
4568
    } else if (!strstart(p, "none", &opts)) {
4569 4570 4571 4572
    invalid_vga:
        fprintf(stderr, "Unknown vga type: %s\n", p);
        exit(1);
    }
M
malc 已提交
4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585
    while (*opts) {
        const char *nextopt;

        if (strstart(opts, ",retrace=", &nextopt)) {
            opts = nextopt;
            if (strstart(opts, "dumb", &nextopt))
                vga_retrace_method = VGA_RETRACE_DUMB;
            else if (strstart(opts, "precise", &nextopt))
                vga_retrace_method = VGA_RETRACE_PRECISE;
            else goto invalid_vga;
        } else goto invalid_vga;
        opts = nextopt;
    }
4586 4587
}

4588 4589 4590
#ifdef TARGET_I386
static int balloon_parse(const char *arg)
{
4591
    QemuOpts *opts;
4592

4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605
    if (strcmp(arg, "none") == 0) {
        return 0;
    }

    if (!strncmp(arg, "virtio", 6)) {
        if (arg[6] == ',') {
            /* have params -> parse them */
            opts = qemu_opts_parse(&qemu_device_opts, arg+7, NULL);
            if (!opts)
                return  -1;
        } else {
            /* create empty opts */
            opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4606
        }
4607 4608
        qemu_opt_set(opts, "driver", "virtio-balloon-pci");
        return 0;
4609
    }
4610 4611

    return -1;
4612 4613 4614
}
#endif

4615 4616 4617 4618 4619 4620 4621 4622
#ifdef _WIN32
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
{
    exit(STATUS_CONTROL_C_EXIT);
    return TRUE;
}
#endif

4623
int qemu_uuid_parse(const char *str, uint8_t *uuid)
4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636
{
    int ret;

    if(strlen(str) != 36)
        return -1;

    ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
            &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
            &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);

    if(ret != 16)
        return -1;

4637 4638 4639 4640
#ifdef TARGET_I386
    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
#endif

4641 4642 4643
    return 0;
}

B
bellard 已提交
4644
#define MAX_NET_CLIENTS 32
B
bellard 已提交
4645

4646 4647 4648 4649 4650 4651 4652
#ifndef _WIN32

static void termsig_handler(int signal)
{
    qemu_system_shutdown_request();
}

4653 4654 4655 4656 4657 4658
static void sigchld_handler(int signal)
{
    waitpid(-1, NULL, WNOHANG);
}

static void sighandler_setup(void)
4659 4660 4661 4662 4663 4664 4665 4666
{
    struct sigaction act;

    memset(&act, 0, sizeof(act));
    act.sa_handler = termsig_handler;
    sigaction(SIGINT,  &act, NULL);
    sigaction(SIGHUP,  &act, NULL);
    sigaction(SIGTERM, &act, NULL);
4667 4668 4669 4670

    act.sa_handler = sigchld_handler;
    act.sa_flags = SA_NOCLDSTOP;
    sigaction(SIGCHLD, &act, NULL);
4671 4672 4673 4674
}

#endif

P
Paul Brook 已提交
4675 4676 4677 4678 4679 4680 4681 4682 4683 4684
#ifdef _WIN32
/* Look for support files in the same directory as the executable.  */
static char *find_datadir(const char *argv0)
{
    char *p;
    char buf[MAX_PATH];
    DWORD len;

    len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
    if (len == 0) {
B
Blue Swirl 已提交
4685
        return NULL;
P
Paul Brook 已提交
4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712
    }

    buf[len] = 0;
    p = buf + len - 1;
    while (p != buf && *p != '\\')
        p--;
    *p = 0;
    if (access(buf, R_OK) == 0) {
        return qemu_strdup(buf);
    }
    return NULL;
}
#else /* !_WIN32 */

/* Find a likely location for support files using the location of the binary.
   For installed binaries this will be "$bindir/../share/qemu".  When
   running from the build tree this will be "$bindir/../pc-bios".  */
#define SHARE_SUFFIX "/share/qemu"
#define BUILD_SUFFIX "/pc-bios"
static char *find_datadir(const char *argv0)
{
    char *dir;
    char *p = NULL;
    char *res;
#ifdef PATH_MAX
    char buf[PATH_MAX];
#endif
4713
    size_t max_len;
P
Paul Brook 已提交
4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747

#if defined(__linux__)
    {
        int len;
        len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
        if (len > 0) {
            buf[len] = 0;
            p = buf;
        }
    }
#elif defined(__FreeBSD__)
    {
        int len;
        len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
        if (len > 0) {
            buf[len] = 0;
            p = buf;
        }
    }
#endif
    /* If we don't have any way of figuring out the actual executable
       location then try argv[0].  */
    if (!p) {
#ifdef PATH_MAX
        p = buf;
#endif
        p = realpath(argv0, p);
        if (!p) {
            return NULL;
        }
    }
    dir = dirname(p);
    dir = dirname(dir);

4748 4749 4750 4751
    max_len = strlen(dir) +
        MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
    res = qemu_mallocz(max_len);
    snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
P
Paul Brook 已提交
4752
    if (access(res, R_OK)) {
4753
        snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
P
Paul Brook 已提交
4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790
        if (access(res, R_OK)) {
            qemu_free(res);
            res = NULL;
        }
    }
#ifndef PATH_MAX
    free(p);
#endif
    return res;
}
#undef SHARE_SUFFIX
#undef BUILD_SUFFIX
#endif

char *qemu_find_file(int type, const char *name)
{
    int len;
    const char *subdir;
    char *buf;

    /* If name contains path separators then try it as a straight path.  */
    if ((strchr(name, '/') || strchr(name, '\\'))
        && access(name, R_OK) == 0) {
        return strdup(name);
    }
    switch (type) {
    case QEMU_FILE_TYPE_BIOS:
        subdir = "";
        break;
    case QEMU_FILE_TYPE_KEYMAP:
        subdir = "keymaps/";
        break;
    default:
        abort();
    }
    len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
    buf = qemu_mallocz(len);
4791
    snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
P
Paul Brook 已提交
4792 4793 4794 4795 4796 4797 4798
    if (access(buf, R_OK)) {
        qemu_free(buf);
        return NULL;
    }
    return buf;
}

G
Gerd Hoffmann 已提交
4799 4800 4801 4802 4803 4804 4805 4806 4807 4808
static int device_init_func(QemuOpts *opts, void *opaque)
{
    DeviceState *dev;

    dev = qdev_device_add(opts);
    if (!dev)
        return -1;
    return 0;
}

4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843
struct device_config {
    enum {
        DEV_USB,       /* -usbdevice   */
        DEV_BT,        /* -bt          */
    } type;
    const char *cmdline;
    TAILQ_ENTRY(device_config) next;
};
TAILQ_HEAD(, device_config) device_configs = TAILQ_HEAD_INITIALIZER(device_configs);

static void add_device_config(int type, const char *cmdline)
{
    struct device_config *conf;

    conf = qemu_mallocz(sizeof(*conf));
    conf->type = type;
    conf->cmdline = cmdline;
    TAILQ_INSERT_TAIL(&device_configs, conf, next);
}

static int foreach_device_config(int type, int (*func)(const char *cmdline))
{
    struct device_config *conf;
    int rc;

    TAILQ_FOREACH(conf, &device_configs, next) {
        if (conf->type != type)
            continue;
        rc = func(conf->cmdline);
        if (0 != rc)
            return rc;
    }
    return 0;
}

M
malc 已提交
4844
int main(int argc, char **argv, char **envp)
4845
{
4846
    const char *gdbstub_dev = NULL;
4847
    uint32_t boot_devices_bitmap = 0;
T
ths 已提交
4848
    int i;
4849
    int snapshot, linux_boot, net_boot;
B
bellard 已提交
4850
    const char *initrd_filename;
4851
    const char *kernel_filename, *kernel_cmdline;
J
Jan Kiszka 已提交
4852
    char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4853
    DisplayState *ds;
4854
    DisplayChangeListener *dcl;
B
bellard 已提交
4855
    int cyls, heads, secs, translation;
4856
    const char *net_clients[MAX_NET_CLIENTS];
B
bellard 已提交
4857
    int nb_net_clients;
G
Gerd Hoffmann 已提交
4858
    QemuOpts *hda_opts = NULL, *opts;
4859 4860
    int optind;
    const char *r, *optarg;
4861 4862 4863
    CharDriverState *monitor_hds[MAX_MONITOR_DEVICES];
    const char *monitor_devices[MAX_MONITOR_DEVICES];
    int monitor_device_index;
4864
    const char *serial_devices[MAX_SERIAL_PORTS];
4865
    int serial_device_index;
4866
    const char *parallel_devices[MAX_PARALLEL_PORTS];
4867
    int parallel_device_index;
4868 4869
    const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
    int virtio_console_index;
B
bellard 已提交
4870
    const char *loadvm = NULL;
4871
    QEMUMachine *machine;
4872
    const char *cpu_model;
B
blueswir1 已提交
4873
#ifndef _WIN32
T
ths 已提交
4874
    int fds[2];
B
blueswir1 已提交
4875
#endif
4876
    int tb_size;
4877
    const char *pid_file = NULL;
A
aliguori 已提交
4878
    const char *incoming = NULL;
B
blueswir1 已提交
4879
#ifndef _WIN32
4880 4881
    int fd = 0;
    struct passwd *pwd = NULL;
4882 4883
    const char *chroot_dir = NULL;
    const char *run_as = NULL;
B
blueswir1 已提交
4884
#endif
4885
    CPUState *env;
4886
    int show_vnc_port = 0;
B
bellard 已提交
4887

G
Gerd Hoffmann 已提交
4888
    qemu_errors_to_file(stderr);
M
malc 已提交
4889 4890
    qemu_cache_utils_init(envp);

B
bellard 已提交
4891
    LIST_INIT (&vm_change_state_head);
4892 4893 4894 4895 4896 4897 4898 4899
#ifndef _WIN32
    {
        struct sigaction act;
        sigfillset(&act.sa_mask);
        act.sa_flags = 0;
        act.sa_handler = SIG_IGN;
        sigaction(SIGPIPE, &act, NULL);
    }
4900 4901
#else
    SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919
    /* Note: cpu_interrupt() is currently not SMP safe, so we force
       QEMU to run on a single CPU */
    {
        HANDLE h;
        DWORD mask, smask;
        int i;
        h = GetCurrentProcess();
        if (GetProcessAffinityMask(h, &mask, &smask)) {
            for(i = 0; i < 32; i++) {
                if (mask & (1 << i))
                    break;
            }
            if (i != 32) {
                mask = 1 << i;
                SetProcessAffinityMask(h, mask);
            }
        }
    }
B
bellard 已提交
4920
#endif
4921

4922
    module_call_init(MODULE_INIT_MACHINE);
4923
    machine = find_default_machine();
4924
    cpu_model = NULL;
B
bellard 已提交
4925
    initrd_filename = NULL;
4926
    ram_size = 0;
4927
    snapshot = 0;
4928 4929
    kernel_filename = NULL;
    kernel_cmdline = "";
4930
    cyls = heads = secs = 0;
B
bellard 已提交
4931
    translation = BIOS_ATA_TRANSLATION_AUTO;
4932

A
aurel32 已提交
4933
    serial_devices[0] = "vc:80Cx24C";
4934
    for(i = 1; i < MAX_SERIAL_PORTS; i++)
4935
        serial_devices[i] = NULL;
4936
    serial_device_index = 0;
4937

4938
    parallel_devices[0] = "vc:80Cx24C";
4939
    for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4940
        parallel_devices[i] = NULL;
4941
    parallel_device_index = 0;
4942

4943
    for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4944 4945 4946
        virtio_consoles[i] = NULL;
    virtio_console_index = 0;

4947 4948 4949 4950 4951 4952
    monitor_devices[0] = "vc:80Cx24C";
    for (i = 1; i < MAX_MONITOR_DEVICES; i++) {
        monitor_devices[i] = NULL;
    }
    monitor_device_index = 0;

4953 4954 4955 4956 4957
    for (i = 0; i < MAX_NODES; i++) {
        node_mem[i] = 0;
        node_cpumask[i] = 0;
    }

B
bellard 已提交
4958
    nb_net_clients = 0;
4959
    nb_numa_nodes = 0;
B
bellard 已提交
4960
    nb_nics = 0;
4961

4962
    tb_size = 0;
4963 4964
    autostart= 1;

4965
    optind = 1;
4966
    for(;;) {
4967
        if (optind >= argc)
4968
            break;
4969 4970
        r = argv[optind];
        if (r[0] != '-') {
G
Gerd Hoffmann 已提交
4971
	    hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
4972 4973 4974 4975
        } else {
            const QEMUOption *popt;

            optind++;
P
pbrook 已提交
4976 4977 4978
            /* Treat --foo the same as -foo.  */
            if (r[1] == '-')
                r++;
4979 4980 4981
            popt = qemu_options;
            for(;;) {
                if (!popt->name) {
4982
                    fprintf(stderr, "%s: invalid option -- '%s'\n",
4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001
                            argv[0], r);
                    exit(1);
                }
                if (!strcmp(popt->name, r + 1))
                    break;
                popt++;
            }
            if (popt->flags & HAS_ARG) {
                if (optind >= argc) {
                    fprintf(stderr, "%s: option '%s' requires an argument\n",
                            argv[0], r);
                    exit(1);
                }
                optarg = argv[optind++];
            } else {
                optarg = NULL;
            }

            switch(popt->index) {
5002 5003 5004 5005 5006 5007
            case QEMU_OPTION_M:
                machine = find_machine(optarg);
                if (!machine) {
                    QEMUMachine *m;
                    printf("Supported machines are:\n");
                    for(m = first_machine; m != NULL; m = m->next) {
M
Mark McLoughlin 已提交
5008 5009 5010
                        if (m->alias)
                            printf("%-10s %s (alias of %s)\n",
                                   m->alias, m->desc, m->name);
5011
                        printf("%-10s %s%s\n",
5012
                               m->name, m->desc,
5013
                               m->is_default ? " (default)" : "");
5014
                    }
5015
                    exit(*optarg != '?');
5016 5017
                }
                break;
5018 5019
            case QEMU_OPTION_cpu:
                /* hw initialization will check this */
5020
                if (*optarg == '?') {
J
j_mayer 已提交
5021 5022 5023
/* XXX: implement xxx_cpu_list for targets that still miss it */
#if defined(cpu_list)
                    cpu_list(stdout, &fprintf);
5024
#endif
5025
                    exit(0);
5026 5027 5028 5029
                } else {
                    cpu_model = optarg;
                }
                break;
5030
            case QEMU_OPTION_initrd:
B
bellard 已提交
5031 5032
                initrd_filename = optarg;
                break;
5033
            case QEMU_OPTION_hda:
T
ths 已提交
5034
                if (cyls == 0)
G
Gerd Hoffmann 已提交
5035
                    hda_opts = drive_add(optarg, HD_ALIAS, 0);
T
ths 已提交
5036
                else
G
Gerd Hoffmann 已提交
5037
                    hda_opts = drive_add(optarg, HD_ALIAS
T
ths 已提交
5038
			     ",cyls=%d,heads=%d,secs=%d%s",
5039
                             0, cyls, heads, secs,
T
ths 已提交
5040 5041 5042 5043 5044
                             translation == BIOS_ATA_TRANSLATION_LBA ?
                                 ",trans=lba" :
                             translation == BIOS_ATA_TRANSLATION_NONE ?
                                 ",trans=none" : "");
                 break;
5045
            case QEMU_OPTION_hdb:
5046 5047
            case QEMU_OPTION_hdc:
            case QEMU_OPTION_hdd:
5048
                drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
B
bellard 已提交
5049
                break;
T
ths 已提交
5050
            case QEMU_OPTION_drive:
5051
                drive_add(NULL, "%s", optarg);
T
ths 已提交
5052
	        break;
G
Gerd Hoffmann 已提交
5053 5054 5055 5056
            case QEMU_OPTION_set:
                if (qemu_set_option(optarg) != 0)
                    exit(1);
	        break;
5057
            case QEMU_OPTION_mtdblock:
5058
                drive_add(optarg, MTD_ALIAS);
5059
                break;
5060
            case QEMU_OPTION_sd:
5061
                drive_add(optarg, SD_ALIAS);
5062
                break;
5063
            case QEMU_OPTION_pflash:
5064
                drive_add(optarg, PFLASH_ALIAS);
5065
                break;
5066
            case QEMU_OPTION_snapshot:
5067 5068
                snapshot = 1;
                break;
5069
            case QEMU_OPTION_hdachs:
5070 5071 5072 5073
                {
                    const char *p;
                    p = optarg;
                    cyls = strtol(p, (char **)&p, 0);
B
bellard 已提交
5074 5075
                    if (cyls < 1 || cyls > 16383)
                        goto chs_fail;
5076 5077 5078 5079
                    if (*p != ',')
                        goto chs_fail;
                    p++;
                    heads = strtol(p, (char **)&p, 0);
B
bellard 已提交
5080 5081
                    if (heads < 1 || heads > 16)
                        goto chs_fail;
5082 5083 5084 5085
                    if (*p != ',')
                        goto chs_fail;
                    p++;
                    secs = strtol(p, (char **)&p, 0);
B
bellard 已提交
5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098
                    if (secs < 1 || secs > 63)
                        goto chs_fail;
                    if (*p == ',') {
                        p++;
                        if (!strcmp(p, "none"))
                            translation = BIOS_ATA_TRANSLATION_NONE;
                        else if (!strcmp(p, "lba"))
                            translation = BIOS_ATA_TRANSLATION_LBA;
                        else if (!strcmp(p, "auto"))
                            translation = BIOS_ATA_TRANSLATION_AUTO;
                        else
                            goto chs_fail;
                    } else if (*p != '\0') {
5099
                    chs_fail:
B
bellard 已提交
5100 5101
                        fprintf(stderr, "qemu: invalid physical CHS format\n");
                        exit(1);
5102
                    }
G
Gerd Hoffmann 已提交
5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115
		    if (hda_opts != NULL) {
                        char num[16];
                        snprintf(num, sizeof(num), "%d", cyls);
                        qemu_opt_set(hda_opts, "cyls", num);
                        snprintf(num, sizeof(num), "%d", heads);
                        qemu_opt_set(hda_opts, "heads", num);
                        snprintf(num, sizeof(num), "%d", secs);
                        qemu_opt_set(hda_opts, "secs", num);
                        if (translation == BIOS_ATA_TRANSLATION_LBA)
                            qemu_opt_set(hda_opts, "trans", "lba");
                        if (translation == BIOS_ATA_TRANSLATION_NONE)
                            qemu_opt_set(hda_opts, "trans", "none");
                    }
5116 5117
                }
                break;
5118 5119 5120 5121 5122 5123 5124
            case QEMU_OPTION_numa:
                if (nb_numa_nodes >= MAX_NODES) {
                    fprintf(stderr, "qemu: too many NUMA nodes\n");
                    exit(1);
                }
                numa_add(optarg);
                break;
5125
            case QEMU_OPTION_nographic:
5126
                display_type = DT_NOGRAPHIC;
5127
                break;
B
balrog 已提交
5128 5129
#ifdef CONFIG_CURSES
            case QEMU_OPTION_curses:
5130
                display_type = DT_CURSES;
B
balrog 已提交
5131 5132
                break;
#endif
5133 5134 5135
            case QEMU_OPTION_portrait:
                graphic_rotate = 1;
                break;
5136
            case QEMU_OPTION_kernel:
5137 5138
                kernel_filename = optarg;
                break;
5139
            case QEMU_OPTION_append:
5140
                kernel_cmdline = optarg;
5141
                break;
5142
            case QEMU_OPTION_cdrom:
5143
                drive_add(optarg, CDROM_ALIAS);
5144
                break;
5145
            case QEMU_OPTION_boot:
5146
                {
J
Jan Kiszka 已提交
5147
                    static const char * const params[] = {
5148
                        "order", "once", "menu", NULL
J
Jan Kiszka 已提交
5149 5150
                    };
                    char buf[sizeof(boot_devices)];
J
Jan Kiszka 已提交
5151
                    char *standard_boot_devices;
J
Jan Kiszka 已提交
5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167
                    int legacy = 0;

                    if (!strchr(optarg, '=')) {
                        legacy = 1;
                        pstrcpy(buf, sizeof(buf), optarg);
                    } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
                        fprintf(stderr,
                                "qemu: unknown boot parameter '%s' in '%s'\n",
                                buf, optarg);
                        exit(1);
                    }

                    if (legacy ||
                        get_param_value(buf, sizeof(buf), "order", optarg)) {
                        boot_devices_bitmap = parse_bootdevices(buf);
                        pstrcpy(boot_devices, sizeof(boot_devices), buf);
5168
                    }
J
Jan Kiszka 已提交
5169 5170 5171 5172 5173 5174 5175 5176 5177
                    if (!legacy) {
                        if (get_param_value(buf, sizeof(buf),
                                            "once", optarg)) {
                            boot_devices_bitmap |= parse_bootdevices(buf);
                            standard_boot_devices = qemu_strdup(boot_devices);
                            pstrcpy(boot_devices, sizeof(boot_devices), buf);
                            qemu_register_reset(restore_boot_devices,
                                                standard_boot_devices);
                        }
5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190
                        if (get_param_value(buf, sizeof(buf),
                                            "menu", optarg)) {
                            if (!strcmp(buf, "on")) {
                                boot_menu = 1;
                            } else if (!strcmp(buf, "off")) {
                                boot_menu = 0;
                            } else {
                                fprintf(stderr,
                                        "qemu: invalid option value '%s'\n",
                                        buf);
                                exit(1);
                            }
                        }
J
Jan Kiszka 已提交
5191
                    }
5192 5193
                }
                break;
5194 5195
            case QEMU_OPTION_fda:
            case QEMU_OPTION_fdb:
5196
                drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
5197
                break;
B
bellard 已提交
5198 5199 5200 5201 5202
#ifdef TARGET_I386
            case QEMU_OPTION_no_fd_bootchk:
                fd_bootchk = 0;
                break;
#endif
B
bellard 已提交
5203 5204 5205
            case QEMU_OPTION_net:
                if (nb_net_clients >= MAX_NET_CLIENTS) {
                    fprintf(stderr, "qemu: too many network clients\n");
5206 5207
                    exit(1);
                }
5208
                net_clients[nb_net_clients] = optarg;
B
bellard 已提交
5209
                nb_net_clients++;
B
bellard 已提交
5210
                break;
B
bellard 已提交
5211 5212
#ifdef CONFIG_SLIRP
            case QEMU_OPTION_tftp:
5213
                legacy_tftp_prefix = optarg;
B
bellard 已提交
5214
                break;
5215
            case QEMU_OPTION_bootp:
5216
                legacy_bootp_filename = optarg;
5217
                break;
B
bellard 已提交
5218
#ifndef _WIN32
B
bellard 已提交
5219
            case QEMU_OPTION_smb:
5220
                net_slirp_smb(optarg);
B
bellard 已提交
5221
                break;
B
bellard 已提交
5222
#endif
B
bellard 已提交
5223
            case QEMU_OPTION_redir:
5224
                net_slirp_redir(optarg);
B
bellard 已提交
5225
                break;
B
bellard 已提交
5226
#endif
5227
            case QEMU_OPTION_bt:
5228
                add_device_config(DEV_BT, optarg);
5229
                break;
5230 5231 5232 5233 5234 5235 5236 5237 5238
#ifdef HAS_AUDIO
            case QEMU_OPTION_audio_help:
                AUD_help ();
                exit (0);
                break;
            case QEMU_OPTION_soundhw:
                select_soundhw (optarg);
                break;
#endif
5239
            case QEMU_OPTION_h:
5240
                help(0);
5241
                break;
P
pbrook 已提交
5242 5243 5244 5245
            case QEMU_OPTION_version:
                version();
                exit(0);
                break;
5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259
            case QEMU_OPTION_m: {
                uint64_t value;
                char *ptr;

                value = strtoul(optarg, &ptr, 10);
                switch (*ptr) {
                case 0: case 'M': case 'm':
                    value <<= 20;
                    break;
                case 'G': case 'g':
                    value <<= 30;
                    break;
                default:
                    fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5260 5261
                    exit(1);
                }
5262 5263

                /* On 32-bit hosts, QEMU is limited by virtual address space */
5264
                if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
5265 5266 5267 5268 5269 5270 5271 5272
                    fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
                    exit(1);
                }
                if (value != (uint64_t)(ram_addr_t)value) {
                    fprintf(stderr, "qemu: ram size too large\n");
                    exit(1);
                }
                ram_size = value;
5273
                break;
5274
            }
5275 5276 5277
            case QEMU_OPTION_d:
                {
                    int mask;
B
blueswir1 已提交
5278
                    const CPULogItem *item;
5279

5280 5281 5282
                    mask = cpu_str_to_log_mask(optarg);
                    if (!mask) {
                        printf("Log items (comma separated):\n");
5283 5284 5285 5286
                    for(item = cpu_log_items; item->mask != 0; item++) {
                        printf("%-10s %s\n", item->name, item->help);
                    }
                    exit(1);
5287 5288
                    }
                    cpu_set_log(mask);
5289
                }
5290 5291
                break;
            case QEMU_OPTION_s:
5292
                gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5293
                break;
5294 5295
            case QEMU_OPTION_gdb:
                gdbstub_dev = optarg;
5296 5297
                break;
            case QEMU_OPTION_L:
P
Paul Brook 已提交
5298
                data_dir = optarg;
5299
                break;
5300 5301 5302
            case QEMU_OPTION_bios:
                bios_name = optarg;
                break;
5303 5304 5305
            case QEMU_OPTION_singlestep:
                singlestep = 1;
                break;
5306
            case QEMU_OPTION_S:
5307
                autostart = 0;
5308
                break;
5309
#ifndef _WIN32
5310 5311 5312
	    case QEMU_OPTION_k:
		keyboard_layout = optarg;
		break;
5313
#endif
B
bellard 已提交
5314 5315 5316
            case QEMU_OPTION_localtime:
                rtc_utc = 0;
                break;
5317 5318
            case QEMU_OPTION_vga:
                select_vgahw (optarg);
5319
                break;
5320
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340
            case QEMU_OPTION_g:
                {
                    const char *p;
                    int w, h, depth;
                    p = optarg;
                    w = strtol(p, (char **)&p, 10);
                    if (w <= 0) {
                    graphic_error:
                        fprintf(stderr, "qemu: invalid resolution or depth\n");
                        exit(1);
                    }
                    if (*p != 'x')
                        goto graphic_error;
                    p++;
                    h = strtol(p, (char **)&p, 10);
                    if (h <= 0)
                        goto graphic_error;
                    if (*p == 'x') {
                        p++;
                        depth = strtol(p, (char **)&p, 10);
5341
                        if (depth != 8 && depth != 15 && depth != 16 &&
5342 5343 5344 5345 5346 5347 5348
                            depth != 24 && depth != 32)
                            goto graphic_error;
                    } else if (*p == '\0') {
                        depth = graphic_depth;
                    } else {
                        goto graphic_error;
                    }
5349

5350 5351 5352 5353 5354
                    graphic_width = w;
                    graphic_height = h;
                    graphic_depth = depth;
                }
                break;
5355
#endif
T
ths 已提交
5356 5357 5358 5359 5360 5361 5362 5363
            case QEMU_OPTION_echr:
                {
                    char *r;
                    term_escape_char = strtol(optarg, &r, 0);
                    if (r == optarg)
                        printf("Bad argument to echr\n");
                    break;
                }
B
bellard 已提交
5364
            case QEMU_OPTION_monitor:
5365 5366 5367 5368 5369 5370
                if (monitor_device_index >= MAX_MONITOR_DEVICES) {
                    fprintf(stderr, "qemu: too many monitor devices\n");
                    exit(1);
                }
                monitor_devices[monitor_device_index] = optarg;
                monitor_device_index++;
B
bellard 已提交
5371 5372
                break;
            case QEMU_OPTION_serial:
5373 5374 5375 5376
                if (serial_device_index >= MAX_SERIAL_PORTS) {
                    fprintf(stderr, "qemu: too many serial ports\n");
                    exit(1);
                }
5377
                serial_devices[serial_device_index] = optarg;
5378
                serial_device_index++;
B
bellard 已提交
5379
                break;
R
Richard W.M. Jones 已提交
5380
            case QEMU_OPTION_watchdog:
M
Markus Armbruster 已提交
5381 5382 5383 5384 5385 5386
                if (watchdog) {
                    fprintf(stderr,
                            "qemu: only one watchdog option may be given\n");
                    return 1;
                }
                watchdog = optarg;
R
Richard W.M. Jones 已提交
5387 5388 5389 5390 5391 5392 5393
                break;
            case QEMU_OPTION_watchdog_action:
                if (select_watchdog_action(optarg) == -1) {
                    fprintf(stderr, "Unknown -watchdog-action parameter\n");
                    exit(1);
                }
                break;
5394 5395 5396 5397 5398 5399 5400 5401
            case QEMU_OPTION_virtiocon:
                if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
                    fprintf(stderr, "qemu: too many virtio consoles\n");
                    exit(1);
                }
                virtio_consoles[virtio_console_index] = optarg;
                virtio_console_index++;
                break;
5402 5403 5404 5405 5406
            case QEMU_OPTION_parallel:
                if (parallel_device_index >= MAX_PARALLEL_PORTS) {
                    fprintf(stderr, "qemu: too many parallel ports\n");
                    exit(1);
                }
5407
                parallel_devices[parallel_device_index] = optarg;
5408 5409
                parallel_device_index++;
                break;
B
bellard 已提交
5410 5411 5412 5413 5414 5415
	    case QEMU_OPTION_loadvm:
		loadvm = optarg;
		break;
            case QEMU_OPTION_full_screen:
                full_screen = 1;
                break;
T
ths 已提交
5416
#ifdef CONFIG_SDL
5417 5418 5419
            case QEMU_OPTION_no_frame:
                no_frame = 1;
                break;
T
ths 已提交
5420 5421 5422
            case QEMU_OPTION_alt_grab:
                alt_grab = 1;
                break;
T
ths 已提交
5423 5424 5425
            case QEMU_OPTION_no_quit:
                no_quit = 1;
                break;
5426
            case QEMU_OPTION_sdl:
5427
                display_type = DT_SDL;
5428
                break;
T
ths 已提交
5429
#endif
B
bellard 已提交
5430
            case QEMU_OPTION_pidfile:
5431
                pid_file = optarg;
B
bellard 已提交
5432
                break;
5433 5434 5435 5436
#ifdef TARGET_I386
            case QEMU_OPTION_win2k_hack:
                win2k_install_hack = 1;
                break;
5437 5438 5439
            case QEMU_OPTION_rtc_td_hack:
                rtc_td_hack = 1;
                break;
5440 5441 5442 5443 5444 5445
            case QEMU_OPTION_acpitable:
                if(acpi_table_add(optarg) < 0) {
                    fprintf(stderr, "Wrong acpi table provided\n");
                    exit(1);
                }
                break;
5446 5447 5448 5449 5450 5451
            case QEMU_OPTION_smbios:
                if(smbios_entry_add(optarg) < 0) {
                    fprintf(stderr, "Wrong smbios provided\n");
                    exit(1);
                }
                break;
5452
#endif
A
aliguori 已提交
5453 5454 5455 5456
#ifdef CONFIG_KVM
            case QEMU_OPTION_enable_kvm:
                kvm_allowed = 1;
                break;
B
bellard 已提交
5457
#endif
B
bellard 已提交
5458 5459 5460
            case QEMU_OPTION_usb:
                usb_enabled = 1;
                break;
B
bellard 已提交
5461 5462
            case QEMU_OPTION_usbdevice:
                usb_enabled = 1;
5463 5464 5465
                add_device_config(DEV_USB, optarg);
                break;
            case QEMU_OPTION_device:
G
Gerd Hoffmann 已提交
5466 5467 5468 5469 5470
                opts = qemu_opts_parse(&qemu_device_opts, optarg, "driver");
                if (!opts) {
                    fprintf(stderr, "parse error: %s\n", optarg);
                    exit(1);
                }
B
bellard 已提交
5471
                break;
B
bellard 已提交
5472
            case QEMU_OPTION_smp:
5473
                smp_parse(optarg);
5474
                if (smp_cpus < 1) {
B
bellard 已提交
5475 5476 5477
                    fprintf(stderr, "Invalid number of CPUs\n");
                    exit(1);
                }
5478 5479 5480 5481 5482 5483 5484 5485 5486
                if (max_cpus < smp_cpus) {
                    fprintf(stderr, "maxcpus must be equal to or greater than "
                            "smp\n");
                    exit(1);
                }
                if (max_cpus > 255) {
                    fprintf(stderr, "Unsupported number of maxcpus\n");
                    exit(1);
                }
B
bellard 已提交
5487
                break;
B
bellard 已提交
5488
	    case QEMU_OPTION_vnc:
5489
                display_type = DT_VNC;
5490
		vnc_display = optarg;
B
bellard 已提交
5491
		break;
5492
#ifdef TARGET_I386
B
bellard 已提交
5493 5494 5495
            case QEMU_OPTION_no_acpi:
                acpi_enabled = 0;
                break;
A
aliguori 已提交
5496 5497 5498
            case QEMU_OPTION_no_hpet:
                no_hpet = 1;
                break;
5499 5500 5501 5502 5503
            case QEMU_OPTION_balloon:
                if (balloon_parse(optarg) < 0) {
                    fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
                    exit(1);
                }
5504
                break;
5505
#endif
B
bellard 已提交
5506 5507 5508
            case QEMU_OPTION_no_reboot:
                no_reboot = 1;
                break;
A
aurel32 已提交
5509 5510 5511
            case QEMU_OPTION_no_shutdown:
                no_shutdown = 1;
                break;
5512 5513 5514
            case QEMU_OPTION_show_cursor:
                cursor_hide = 0;
                break;
5515 5516 5517 5518 5519 5520 5521
            case QEMU_OPTION_uuid:
                if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
                    fprintf(stderr, "Fail to parse UUID string."
                            " Wrong format.\n");
                    exit(1);
                }
                break;
5522
#ifndef _WIN32
T
ths 已提交
5523 5524 5525
	    case QEMU_OPTION_daemonize:
		daemonize = 1;
		break;
5526
#endif
5527 5528 5529 5530 5531 5532 5533 5534
	    case QEMU_OPTION_option_rom:
		if (nb_option_roms >= MAX_OPTION_ROMS) {
		    fprintf(stderr, "Too many option ROMs\n");
		    exit(1);
		}
		option_rom[nb_option_roms] = optarg;
		nb_option_roms++;
		break;
5535
#if defined(TARGET_ARM) || defined(TARGET_M68K)
5536 5537 5538
            case QEMU_OPTION_semihosting:
                semihosting_enabled = 1;
                break;
5539
#endif
T
ths 已提交
5540
            case QEMU_OPTION_name:
A
Andi Kleen 已提交
5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553
                qemu_name = qemu_strdup(optarg);
		 {
		     char *p = strchr(qemu_name, ',');
		     if (p != NULL) {
		        *p++ = 0;
			if (strncmp(p, "process=", 8)) {
			    fprintf(stderr, "Unknown subargument %s to -name", p);
			    exit(1);
			}
			p += 8;
			set_proc_name(p);
		     }	
		 }	
T
ths 已提交
5554
                break;
5555
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
B
blueswir1 已提交
5556 5557 5558 5559 5560 5561 5562 5563
            case QEMU_OPTION_prom_env:
                if (nb_prom_envs >= MAX_PROM_ENVS) {
                    fprintf(stderr, "Too many prom variables\n");
                    exit(1);
                }
                prom_envs[nb_prom_envs] = optarg;
                nb_prom_envs++;
                break;
5564 5565 5566 5567
#endif
#ifdef TARGET_ARM
            case QEMU_OPTION_old_param:
                old_param = 1;
5568
                break;
B
blueswir1 已提交
5569
#endif
5570 5571 5572
            case QEMU_OPTION_clock:
                configure_alarms(optarg);
                break;
B
bellard 已提交
5573 5574 5575
            case QEMU_OPTION_startdate:
                {
                    struct tm tm;
5576
                    time_t rtc_start_date;
B
bellard 已提交
5577
                    if (!strcmp(optarg, "now")) {
5578
                        rtc_date_offset = -1;
B
bellard 已提交
5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599
                    } else {
                        if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
                               &tm.tm_year,
                               &tm.tm_mon,
                               &tm.tm_mday,
                               &tm.tm_hour,
                               &tm.tm_min,
                               &tm.tm_sec) == 6) {
                            /* OK */
                        } else if (sscanf(optarg, "%d-%d-%d",
                                          &tm.tm_year,
                                          &tm.tm_mon,
                                          &tm.tm_mday) == 3) {
                            tm.tm_hour = 0;
                            tm.tm_min = 0;
                            tm.tm_sec = 0;
                        } else {
                            goto date_fail;
                        }
                        tm.tm_year -= 1900;
                        tm.tm_mon--;
B
bellard 已提交
5600
                        rtc_start_date = mktimegm(&tm);
B
bellard 已提交
5601 5602 5603 5604 5605 5606
                        if (rtc_start_date == -1) {
                        date_fail:
                            fprintf(stderr, "Invalid date format. Valid format are:\n"
                                    "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
                            exit(1);
                        }
5607
                        rtc_date_offset = time(NULL) - rtc_start_date;
B
bellard 已提交
5608 5609 5610
                    }
                }
                break;
5611 5612 5613 5614 5615
            case QEMU_OPTION_tb_size:
                tb_size = strtol(optarg, NULL, 0);
                if (tb_size < 0)
                    tb_size = 0;
                break;
P
pbrook 已提交
5616 5617 5618 5619 5620 5621 5622 5623
            case QEMU_OPTION_icount:
                use_icount = 1;
                if (strcmp(optarg, "auto") == 0) {
                    icount_time_shift = -1;
                } else {
                    icount_time_shift = strtol(optarg, NULL, 0);
                }
                break;
A
aliguori 已提交
5624 5625 5626
            case QEMU_OPTION_incoming:
                incoming = optarg;
                break;
5627
#ifndef _WIN32
5628 5629 5630 5631 5632 5633
            case QEMU_OPTION_chroot:
                chroot_dir = optarg;
                break;
            case QEMU_OPTION_runas:
                run_as = optarg;
                break;
5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644
#endif
#ifdef CONFIG_XEN
            case QEMU_OPTION_xen_domid:
                xen_domid = atoi(optarg);
                break;
            case QEMU_OPTION_xen_create:
                xen_mode = XEN_CREATE;
                break;
            case QEMU_OPTION_xen_attach:
                xen_mode = XEN_ATTACH;
                break;
5645
#endif
5646
            }
5647 5648
        }
    }
5649

P
Paul Brook 已提交
5650 5651 5652 5653 5654 5655 5656 5657 5658 5659
    /* If no data_dir is specified then try to find it relative to the
       executable path.  */
    if (!data_dir) {
        data_dir = find_datadir(argv[0]);
    }
    /* If all else fails use the install patch specified when building.  */
    if (!data_dir) {
        data_dir = CONFIG_QEMU_SHAREDIR;
    }

5660 5661 5662 5663 5664 5665 5666
    /*
     * Default to max_cpus = smp_cpus, in case the user doesn't
     * specify a max_cpus value.
     */
    if (!max_cpus)
        max_cpus = smp_cpus;

B
balrog 已提交
5667
    machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5668 5669 5670 5671 5672 5673 5674
    if (smp_cpus > machine->max_cpus) {
        fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
                "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
                machine->max_cpus);
        exit(1);
    }

5675
    if (display_type == DT_NOGRAPHIC) {
5676 5677 5678 5679
       if (serial_device_index == 0)
           serial_devices[0] = "stdio";
       if (parallel_device_index == 0)
           parallel_devices[0] = "null";
5680 5681 5682
       if (strncmp(monitor_devices[0], "vc", 2) == 0) {
           monitor_devices[0] = "stdio";
       }
5683 5684
    }

T
ths 已提交
5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699
#ifndef _WIN32
    if (daemonize) {
	pid_t pid;

	if (pipe(fds) == -1)
	    exit(1);

	pid = fork();
	if (pid > 0) {
	    uint8_t status;
	    ssize_t len;

	    close(fds[1]);

	again:
5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710
            len = read(fds[0], &status, 1);
            if (len == -1 && (errno == EINTR))
                goto again;

            if (len != 1)
                exit(1);
            else if (status == 1) {
                fprintf(stderr, "Could not acquire pidfile\n");
                exit(1);
            } else
                exit(0);
T
ths 已提交
5711
	} else if (pid < 0)
5712
            exit(1);
T
ths 已提交
5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728

	setsid();

	pid = fork();
	if (pid > 0)
	    exit(0);
	else if (pid < 0)
	    exit(1);

	umask(027);

        signal(SIGTSTP, SIG_IGN);
        signal(SIGTTOU, SIG_IGN);
        signal(SIGTTIN, SIG_IGN);
    }

5729
    if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5730 5731 5732 5733 5734 5735 5736
        if (daemonize) {
            uint8_t status = 1;
            write(fds[1], &status, 1);
        } else
            fprintf(stderr, "Could not acquire pid file\n");
        exit(1);
    }
B
blueswir1 已提交
5737
#endif
5738

5739 5740 5741 5742
    if (qemu_init_main_loop()) {
        fprintf(stderr, "qemu_init_main_loop failed\n");
        exit(1);
    }
5743
    linux_boot = (kernel_filename != NULL);
B
balrog 已提交
5744

5745 5746 5747 5748 5749 5750 5751 5752 5753 5754
    if (!linux_boot && *kernel_cmdline != '\0') {
        fprintf(stderr, "-append only allowed with -kernel option\n");
        exit(1);
    }

    if (!linux_boot && initrd_filename != NULL) {
        fprintf(stderr, "-initrd only allowed with -kernel option\n");
        exit(1);
    }

5755 5756
#ifndef _WIN32
    /* Win32 doesn't support line-buffering and requires size >= 2 */
B
bellard 已提交
5757
    setvbuf(stdout, NULL, _IOLBF, 0);
5758
#endif
5759

5760
    init_timers();
5761 5762 5763 5764
    if (init_timer_alarm() < 0) {
        fprintf(stderr, "could not initialize alarm timer\n");
        exit(1);
    }
P
pbrook 已提交
5765 5766 5767 5768 5769 5770 5771
    if (use_icount && icount_time_shift < 0) {
        use_icount = 2;
        /* 125MIPS seems a reasonable initial guess at the guest speed.
           It will be corrected fairly quickly anyway.  */
        icount_time_shift = 3;
        init_icount_adjust();
    }
5772

B
bellard 已提交
5773 5774 5775 5776
#ifdef _WIN32
    socket_init();
#endif

B
bellard 已提交
5777 5778 5779
    /* init network clients */
    if (nb_net_clients == 0) {
        /* if no clients, we use a default config */
5780 5781 5782 5783
        net_clients[nb_net_clients++] = "nic";
#ifdef CONFIG_SLIRP
        net_clients[nb_net_clients++] = "user";
#endif
B
bellard 已提交
5784 5785
    }

B
bellard 已提交
5786
    for(i = 0;i < nb_net_clients; i++) {
5787
        if (net_client_parse(net_clients[i]) < 0)
B
bellard 已提交
5788
            exit(1);
B
bellard 已提交
5789
    }
B
bellard 已提交
5790

5791 5792 5793 5794
    net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
    net_set_boot_mask(net_boot);

    net_client_check();
5795

5796
    /* init the bluetooth world */
5797 5798
    if (foreach_device_config(DEV_BT, bt_parse))
        exit(1);
5799

5800
    /* init the memory */
P
pbrook 已提交
5801 5802
    if (ram_size == 0)
        ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5803

5804 5805 5806
    /* init the dynamic translator */
    cpu_exec_init_all(tb_size * 1024 * 1024);

B
bellard 已提交
5807
    bdrv_init();
5808

T
ths 已提交
5809
    /* we always create the cdrom drive, even if no disk is there */
G
Gerd Hoffmann 已提交
5810
    drive_add(NULL, CDROM_ALIAS);
5811

5812
    /* we always create at least one floppy */
G
Gerd Hoffmann 已提交
5813
    drive_add(NULL, FD_ALIAS, 0);
5814

5815
    /* we always create one sd slot, even if no card is in it */
G
Gerd Hoffmann 已提交
5816
    drive_add(NULL, SD_ALIAS);
5817

T
ths 已提交
5818
    /* open the virtual block devices */
G
Gerd Hoffmann 已提交
5819
    if (snapshot)
G
Gerd Hoffmann 已提交
5820 5821
        qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
    if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
G
Gerd Hoffmann 已提交
5822
        exit(1);
5823

5824
    register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5825
    register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5826

5827
    /* Maintain compatibility with multiple stdio monitors */
5828
    if (!strcmp(monitor_devices[0],"stdio")) {
5829 5830 5831
        for (i = 0; i < MAX_SERIAL_PORTS; i++) {
            const char *devname = serial_devices[i];
            if (devname && !strcmp(devname,"mon:stdio")) {
5832
                monitor_devices[0] = NULL;
5833 5834
                break;
            } else if (devname && !strcmp(devname,"stdio")) {
5835
                monitor_devices[0] = NULL;
5836 5837 5838 5839 5840 5841
                serial_devices[i] = "mon:stdio";
                break;
            }
        }
    }

5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883
    if (nb_numa_nodes > 0) {
        int i;

        if (nb_numa_nodes > smp_cpus) {
            nb_numa_nodes = smp_cpus;
        }

        /* If no memory size if given for any node, assume the default case
         * and distribute the available memory equally across all nodes
         */
        for (i = 0; i < nb_numa_nodes; i++) {
            if (node_mem[i] != 0)
                break;
        }
        if (i == nb_numa_nodes) {
            uint64_t usedmem = 0;

            /* On Linux, the each node's border has to be 8MB aligned,
             * the final node gets the rest.
             */
            for (i = 0; i < nb_numa_nodes - 1; i++) {
                node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
                usedmem += node_mem[i];
            }
            node_mem[i] = ram_size - usedmem;
        }

        for (i = 0; i < nb_numa_nodes; i++) {
            if (node_cpumask[i] != 0)
                break;
        }
        /* assigning the VCPUs round-robin is easier to implement, guest OSes
         * must cope with this anyway, because there are BIOSes out there in
         * real machines which also use this scheme.
         */
        if (i == nb_numa_nodes) {
            for (i = 0; i < smp_cpus; i++) {
                node_cpumask[i % nb_numa_nodes] |= 1 << i;
            }
        }
    }

5884 5885 5886 5887 5888 5889 5890 5891 5892 5893
    if (kvm_enabled()) {
        int ret;

        ret = kvm_init(smp_cpus);
        if (ret < 0) {
            fprintf(stderr, "failed to initialize KVM\n");
            exit(1);
        }
    }

5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908
    for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
        const char *devname = monitor_devices[i];
        if (devname && strcmp(devname, "none")) {
            char label[32];
            if (i == 0) {
                snprintf(label, sizeof(label), "monitor");
            } else {
                snprintf(label, sizeof(label), "monitor%d", i);
            }
            monitor_hds[i] = qemu_chr_open(label, devname, NULL);
            if (!monitor_hds[i]) {
                fprintf(stderr, "qemu: could not open monitor device '%s'\n",
                        devname);
                exit(1);
            }
A
aliguori 已提交
5909 5910 5911
        }
    }

5912 5913 5914 5915 5916
    for(i = 0; i < MAX_SERIAL_PORTS; i++) {
        const char *devname = serial_devices[i];
        if (devname && strcmp(devname, "none")) {
            char label[32];
            snprintf(label, sizeof(label), "serial%d", i);
5917
            serial_hds[i] = qemu_chr_open(label, devname, NULL);
5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930
            if (!serial_hds[i]) {
                fprintf(stderr, "qemu: could not open serial device '%s'\n",
                        devname);
                exit(1);
            }
        }
    }

    for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
        const char *devname = parallel_devices[i];
        if (devname && strcmp(devname, "none")) {
            char label[32];
            snprintf(label, sizeof(label), "parallel%d", i);
5931
            parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944
            if (!parallel_hds[i]) {
                fprintf(stderr, "qemu: could not open parallel device '%s'\n",
                        devname);
                exit(1);
            }
        }
    }

    for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
        const char *devname = virtio_consoles[i];
        if (devname && strcmp(devname, "none")) {
            char label[32];
            snprintf(label, sizeof(label), "virtcon%d", i);
5945
            virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5946 5947 5948 5949 5950 5951 5952 5953
            if (!virtcon_hds[i]) {
                fprintf(stderr, "qemu: could not open virtio console '%s'\n",
                        devname);
                exit(1);
            }
        }
    }

P
Paul Brook 已提交
5954 5955
    module_call_init(MODULE_INIT_DEVICE);

M
Markus Armbruster 已提交
5956 5957 5958 5959 5960 5961
    if (watchdog) {
        i = select_watchdog(watchdog);
        if (i > 0)
            exit (i == 1 ? 1 : 0);
    }

5962 5963 5964
    if (machine->compat_props) {
        qdev_prop_register_compat(machine->compat_props);
    }
P
Paul Brook 已提交
5965
    machine->init(ram_size, boot_devices,
5966 5967
                  kernel_filename, kernel_cmdline, initrd_filename, cpu_model);

5968

J
Juan Quintela 已提交
5969 5970 5971 5972 5973
#ifndef _WIN32
    /* must be after terminal init, SDL library changes signal handlers */
    sighandler_setup();
#endif

5974 5975 5976 5977 5978 5979 5980 5981
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
        for (i = 0; i < nb_numa_nodes; i++) {
            if (node_cpumask[i] & (1 << env->cpu_index)) {
                env->numa_node = i;
            }
        }
    }

5982 5983
    current_machine = machine;

5984 5985
    /* init USB devices */
    if (usb_enabled) {
5986
        foreach_device_config(DEV_USB, usb_parse);
5987 5988
    }

5989
    /* init generic devices */
G
Gerd Hoffmann 已提交
5990
    if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5991 5992
        exit(1);

5993 5994
    if (!display_state)
        dumb_display_init();
5995 5996
    /* just use the first displaystate for the moment */
    ds = display_state;
5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011

    if (display_type == DT_DEFAULT) {
#if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
        display_type = DT_SDL;
#else
        display_type = DT_VNC;
        vnc_display = "localhost:0,to=99";
        show_vnc_port = 1;
#endif
    }
        

    switch (display_type) {
    case DT_NOGRAPHIC:
        break;
B
balrog 已提交
6012
#if defined(CONFIG_CURSES)
6013 6014 6015
    case DT_CURSES:
        curses_display_init(ds, full_screen);
        break;
B
balrog 已提交
6016
#endif
6017
#if defined(CONFIG_SDL)
6018 6019 6020
    case DT_SDL:
        sdl_display_init(ds, full_screen, no_frame);
        break;
6021
#elif defined(CONFIG_COCOA)
6022 6023 6024
    case DT_SDL:
        cocoa_display_init(ds, full_screen);
        break;
6025
#endif
6026 6027 6028 6029
    case DT_VNC:
        vnc_display_init(ds);
        if (vnc_display_open(ds, vnc_display) < 0)
            exit(1);
6030

6031 6032
        if (show_vnc_port) {
            printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
6033
        }
6034 6035 6036
        break;
    default:
        break;
6037
    }
6038
    dpy_resize(ds);
6039

6040 6041 6042 6043 6044
    dcl = ds->listeners;
    while (dcl != NULL) {
        if (dcl->dpy_refresh != NULL) {
            ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
            qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
T
ths 已提交
6045
        }
6046
        dcl = dcl->next;
T
ths 已提交
6047
    }
6048

6049
    if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
B
blueswir1 已提交
6050 6051 6052 6053
        nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
        qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
    }

6054
    text_consoles_set_display(display_state);
A
aliguori 已提交
6055
    qemu_chr_initial_reset();
6056

6057 6058 6059 6060 6061 6062 6063
    for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
        if (monitor_devices[i] && monitor_hds[i]) {
            monitor_init(monitor_hds[i],
                         MONITOR_USE_READLINE |
                         ((i == 0) ? MONITOR_IS_DEFAULT : 0));
        }
    }
B
bellard 已提交
6064

6065
    for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6066
        const char *devname = serial_devices[i];
6067
        if (devname && strcmp(devname, "none")) {
6068
            if (strstart(devname, "vc", 0))
B
bellard 已提交
6069
                qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
6070
        }
B
bellard 已提交
6071 6072
    }

6073
    for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6074
        const char *devname = parallel_devices[i];
6075
        if (devname && strcmp(devname, "none")) {
6076
            if (strstart(devname, "vc", 0))
B
bellard 已提交
6077
                qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6078 6079 6080
        }
    }

6081 6082
    for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
        const char *devname = virtio_consoles[i];
6083
        if (virtcon_hds[i] && devname) {
6084 6085 6086 6087 6088
            if (strstart(devname, "vc", 0))
                qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
        }
    }

6089 6090 6091 6092
    if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
        fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
                gdbstub_dev);
        exit(1);
6093 6094
    }

6095 6096 6097 6098 6099
    if (loadvm) {
        if (load_vmstate(cur_mon, loadvm) < 0) {
            autostart = 0;
        }
    }
B
bellard 已提交
6100

G
Glauber Costa 已提交
6101
    if (incoming) {
A
aliguori 已提交
6102
        qemu_start_incoming_migration(incoming);
6103
    } else if (autostart) {
6104
        vm_start();
6105
    }
6106

B
blueswir1 已提交
6107
#ifndef _WIN32
T
ths 已提交
6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119
    if (daemonize) {
	uint8_t status = 0;
	ssize_t len;

    again1:
	len = write(fds[1], &status, 1);
	if (len == -1 && (errno == EINTR))
	    goto again1;

	if (len != 1)
	    exit(1);

A
aliguori 已提交
6120
	chdir("/");
6121
	TFR(fd = open("/dev/null", O_RDWR));
T
ths 已提交
6122 6123
	if (fd == -1)
	    exit(1);
6124
    }
T
ths 已提交
6125

6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160
    if (run_as) {
        pwd = getpwnam(run_as);
        if (!pwd) {
            fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
            exit(1);
        }
    }

    if (chroot_dir) {
        if (chroot(chroot_dir) < 0) {
            fprintf(stderr, "chroot failed\n");
            exit(1);
        }
        chdir("/");
    }

    if (run_as) {
        if (setgid(pwd->pw_gid) < 0) {
            fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
            exit(1);
        }
        if (setuid(pwd->pw_uid) < 0) {
            fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
            exit(1);
        }
        if (setuid(0) != -1) {
            fprintf(stderr, "Dropping privileges failed\n");
            exit(1);
        }
    }

    if (daemonize) {
        dup2(fd, 0);
        dup2(fd, 1);
        dup2(fd, 2);
T
ths 已提交
6161

6162
        close(fd);
T
ths 已提交
6163
    }
B
blueswir1 已提交
6164
#endif
T
ths 已提交
6165

6166
    main_loop();
B
bellard 已提交
6167
    quit_timers();
6168
    net_cleanup();
T
ths 已提交
6169

6170 6171
    return 0;
}