vl.c 81.7 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 34
#include "config-host.h"

B
bellard 已提交
35
#ifndef _WIN32
P
Paul Brook 已提交
36
#include <libgen.h>
B
bellard 已提交
37
#include <sys/times.h>
B
bellard 已提交
38
#include <sys/wait.h>
B
bellard 已提交
39 40
#include <termios.h>
#include <sys/mman.h>
B
bellard 已提交
41
#include <sys/ioctl.h>
B
blueswir1 已提交
42
#include <sys/resource.h>
B
bellard 已提交
43
#include <sys/socket.h>
B
bellard 已提交
44
#include <netinet/in.h>
B
blueswir1 已提交
45 46
#include <net/if.h>
#include <arpa/inet.h>
B
bellard 已提交
47
#include <dirent.h>
B
bellard 已提交
48
#include <netdb.h>
49
#include <sys/select.h>
J
Juan Quintela 已提交
50
#ifdef CONFIG_BSD
B
bellard 已提交
51
#include <sys/stat.h>
A
Aurelien Jarno 已提交
52
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
B
bellard 已提交
53
#include <libutil.h>
54
#include <sys/sysctl.h>
B
blueswir1 已提交
55 56
#else
#include <util.h>
57
#endif
58
#else
59
#ifdef __linux__
B
bellard 已提交
60 61
#include <pty.h>
#include <malloc.h>
T
ths 已提交
62

B
bellard 已提交
63
#include <linux/ppdev.h>
64
#include <linux/parport.h>
65 66
#endif
#ifdef __sun__
67 68 69 70 71 72 73 74 75 76 77 78
#include <sys/stat.h>
#include <sys/ethernet.h>
#include <sys/sockio.h>
#include <netinet/arp.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>
79 80 81
/* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
   discussion about Solaris header problems */
extern int madvise(caddr_t, size_t, int);
B
bellard 已提交
82
#endif
B
bellard 已提交
83
#endif
B
bellard 已提交
84
#endif
B
bellard 已提交
85

86 87 88 89
#if defined(__OpenBSD__)
#include <util.h>
#endif

90 91 92 93
#if defined(CONFIG_VDE)
#include <libvdeplug.h>
#endif

B
bellard 已提交
94
#ifdef _WIN32
95
#include <windows.h>
B
bellard 已提交
96 97
#endif

B
bellard 已提交
98
#ifdef CONFIG_SDL
S
Stefan Weil 已提交
99
#if defined(__APPLE__) || defined(main)
S
Stefan Weil 已提交
100
#include <SDL.h>
M
malc 已提交
101 102 103
int qemu_main(int argc, char **argv, char **envp);
int main(int argc, char **argv)
{
S
Stefan Weil 已提交
104
    return qemu_main(argc, argv, NULL);
M
malc 已提交
105 106 107
}
#undef main
#define main qemu_main
B
bellard 已提交
108
#endif
B
bellard 已提交
109
#endif /* CONFIG_SDL */
110

111 112 113 114 115
#ifdef CONFIG_COCOA
#undef main
#define main qemu_main
#endif /* CONFIG_COCOA */

116 117 118 119 120 121 122 123
#include "hw/hw.h"
#include "hw/boards.h"
#include "hw/usb.h"
#include "hw/pcmcia.h"
#include "hw/pc.h"
#include "hw/isa.h"
#include "hw/baum.h"
#include "hw/bt.h"
R
Richard W.M. Jones 已提交
124
#include "hw/watchdog.h"
125
#include "hw/smbios.h"
126
#include "hw/xen.h"
127
#include "hw/qdev.h"
128
#include "hw/loader.h"
A
aurel32 已提交
129
#include "bt-host.h"
130
#include "net.h"
131
#include "net/slirp.h"
132 133 134 135 136 137 138 139
#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"
140
#include "blockdev.h"
L
lirans@il.ibm.com 已提交
141
#include "block-migration.h"
B
blueswir1 已提交
142
#include "dma.h"
143 144 145
#include "audio/audio.h"
#include "migration.h"
#include "kvm.h"
K
Kevin Wolf 已提交
146
#include "qemu-option.h"
G
Gerd Hoffmann 已提交
147
#include "qemu-config.h"
148
#include "qemu-objects.h"
149
#include "qemu-options.h"
150 151 152
#ifdef CONFIG_LINUX
#include "fsdev/qemu-fsdev.h"
#endif
153

154
#include "disas.h"
B
bellard 已提交
155

156 157
#include "qemu_socket.h"

J
Jan Kiszka 已提交
158
#include "slirp/libslirp.h"
159

B
Blue Swirl 已提交
160
#include "qemu-queue.h"
161
#include "cpus.h"
162
#include "arch_init.h"
B
Blue Swirl 已提交
163

164 165
//#define DEBUG_NET
//#define DEBUG_SLIRP
166

167
#define DEFAULT_RAM_SIZE 128
168

169 170
#define MAX_VIRTIO_CONSOLES 1

P
Paul Brook 已提交
171
static const char *data_dir;
172
const char *bios_name = NULL;
M
malc 已提交
173
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
174
DisplayType display_type = DT_DEFAULT;
175
const char* keyboard_layout = NULL;
A
Anthony Liguori 已提交
176
ram_addr_t ram_size;
177 178 179 180
const char *mem_path = NULL;
#ifdef MAP_POPULATE
int mem_prealloc = 0; /* force preallocation of physical target memory */
#endif
181
int nb_nics;
B
bellard 已提交
182
NICInfo nd_table[MAX_NICS];
183
int vm_running;
P
Paolo Bonzini 已提交
184
int autostart;
185 186
static int rtc_utc = 1;
static int rtc_date_offset = -1; /* -1 means no change */
J
Jan Kiszka 已提交
187
QEMUClock *rtc_clock;
G
Gerd Hoffmann 已提交
188
int vga_interface_type = VGA_NONE;
B
blueswir1 已提交
189
static int full_screen = 0;
190
#ifdef CONFIG_SDL
B
blueswir1 已提交
191
static int no_frame = 0;
192
#endif
T
ths 已提交
193
int no_quit = 0;
194
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
195
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
196
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
197
int win2k_install_hack = 0;
198
int rtc_td_hack = 0;
B
bellard 已提交
199
int usb_enabled = 0;
200
int singlestep = 0;
B
bellard 已提交
201
int smp_cpus = 1;
202
int max_cpus = 0;
203 204
int smp_cores = 1;
int smp_threads = 1;
205
const char *vnc_display;
B
bellard 已提交
206
int acpi_enabled = 1;
A
aliguori 已提交
207
int no_hpet = 0;
B
bellard 已提交
208
int fd_bootchk = 1;
B
bellard 已提交
209
int no_reboot = 0;
A
aurel32 已提交
210
int no_shutdown = 0;
211
int cursor_hide = 1;
212
int graphic_rotate = 0;
J
Jes Sorensen 已提交
213
uint8_t irq0override = 1;
M
Markus Armbruster 已提交
214
const char *watchdog;
215 216
const char *option_rom[MAX_OPTION_ROMS];
int nb_option_roms;
217
int semihosting_enabled = 0;
218
int old_param = 0;
T
ths 已提交
219
const char *qemu_name;
T
ths 已提交
220
int alt_grab = 0;
221
int ctrl_grab = 0;
B
blueswir1 已提交
222 223
unsigned int nb_prom_envs = 0;
const char *prom_envs[MAX_PROM_ENVS];
224
int boot_menu;
225

226 227 228 229
int nb_numa_nodes;
uint64_t node_mem[MAX_NODES];
uint64_t node_cpumask[MAX_NODES];

B
blueswir1 已提交
230
static QEMUTimer *nographic_timer;
231

232 233
uint8_t qemu_uuid[16];

J
Jan Kiszka 已提交
234 235 236
static QEMUBootSetHandler *boot_set_handler;
static void *boot_set_opaque;

237 238 239 240
int kvm_allowed = 0;
uint32_t xen_domid;
enum xen_mode xen_mode = XEN_EMULATE;

241
static int default_serial = 1;
G
Gerd Hoffmann 已提交
242
static int default_parallel = 1;
243
static int default_virtcon = 1;
G
Gerd Hoffmann 已提交
244
static int default_monitor = 1;
G
Gerd Hoffmann 已提交
245
static int default_vga = 1;
G
Gerd Hoffmann 已提交
246 247 248
static int default_floppy = 1;
static int default_cdrom = 1;
static int default_sdcard = 1;
249 250 251 252 253

static struct {
    const char *driver;
    int *flag;
} default_list[] = {
G
Gerd Hoffmann 已提交
254 255
    { .driver = "isa-serial",           .flag = &default_serial    },
    { .driver = "isa-parallel",         .flag = &default_parallel  },
G
Gerd Hoffmann 已提交
256 257
    { .driver = "isa-fdc",              .flag = &default_floppy    },
    { .driver = "ide-drive",            .flag = &default_cdrom     },
258 259 260
    { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
    { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },
    { .driver = "virtio-serial",        .flag = &default_virtcon   },
G
Gerd Hoffmann 已提交
261
    { .driver = "VGA",                  .flag = &default_vga       },
G
Gerd Hoffmann 已提交
262 263
    { .driver = "cirrus-vga",           .flag = &default_vga       },
    { .driver = "vmware-svga",          .flag = &default_vga       },
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
};

static int default_driver_check(QemuOpts *opts, void *opaque)
{
    const char *driver = qemu_opt_get(opts, "driver");
    int i;

    if (!driver)
        return 0;
    for (i = 0; i < ARRAY_SIZE(default_list); i++) {
        if (strcmp(default_list[i].driver, driver) != 0)
            continue;
        *(default_list[i].flag) = 0;
    }
    return 0;
}

281 282
/***********************************************************/
/* real time host monotonic timer */
283

284 285
/* compute with 96 bit intermediate result: (a*b)/c */
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
286
{
287 288 289
    union {
        uint64_t ll;
        struct {
290
#ifdef HOST_WORDS_BIGENDIAN
291 292 293
            uint32_t high, low;
#else
            uint32_t low, high;
294
#endif
295 296 297
        } l;
    } u, res;
    uint64_t rl, rh;
298

299 300 301 302 303 304 305
    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;
306 307
}

308 309 310 311 312 313 314 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 340 341 342 343 344
/***********************************************************/
/* 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);
}

345 346 347 348 349 350 351 352 353
void rtc_change_mon_event(struct tm *tm)
{
    QObject *data;

    data = qobject_from_jsonf("{ 'offset': %d }", qemu_timedate_diff(tm));
    monitor_protocol_event(QEVENT_RTC_CHANGE, data);
    qobject_decref(data);
}

J
Jan Kiszka 已提交
354 355 356 357 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
static void configure_rtc_date_offset(const char *startdate, int legacy)
{
    time_t rtc_start_date;
    struct tm tm;

    if (!strcmp(startdate, "now") && legacy) {
        rtc_date_offset = -1;
    } else {
        if (sscanf(startdate, "%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(startdate, "%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--;
        rtc_start_date = mktimegm(&tm);
        if (rtc_start_date == -1) {
        date_fail:
            fprintf(stderr, "Invalid date format. Valid formats are:\n"
                            "'2006-06-17T16:01:21' or '2006-06-17'\n");
            exit(1);
        }
        rtc_date_offset = time(NULL) - rtc_start_date;
    }
}

static void configure_rtc(QemuOpts *opts)
{
    const char *value;

    value = qemu_opt_get(opts, "base");
    if (value) {
        if (!strcmp(value, "utc")) {
            rtc_utc = 1;
        } else if (!strcmp(value, "localtime")) {
            rtc_utc = 0;
        } else {
            configure_rtc_date_offset(value, 0);
        }
    }
J
Jan Kiszka 已提交
407 408 409 410 411 412 413 414 415 416 417
    value = qemu_opt_get(opts, "clock");
    if (value) {
        if (!strcmp(value, "host")) {
            rtc_clock = host_clock;
        } else if (!strcmp(value, "vm")) {
            rtc_clock = vm_clock;
        } else {
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
            exit(1);
        }
    }
J
Jan Kiszka 已提交
418 419
    value = qemu_opt_get(opts, "driftfix");
    if (value) {
B
Blue Swirl 已提交
420
        if (!strcmp(value, "slew")) {
J
Jan Kiszka 已提交
421
            rtc_td_hack = 1;
B
Blue Swirl 已提交
422
        } else if (!strcmp(value, "none")) {
J
Jan Kiszka 已提交
423 424 425 426 427 428 429 430
            rtc_td_hack = 0;
        } else {
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
            exit(1);
        }
    }
}

431 432 433 434 435
/***********************************************************/
/* Bluetooth support */
static int nb_hcis;
static int cur_hci;
static struct HCIInfo *hci_table[MAX_NICS];
436

437 438 439 440 441 442 443
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 已提交
444
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
{
    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++];
}

484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
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;
A
Anthony Liguori 已提交
517
    bdaddr_t bdaddr;
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621

    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;
}

622 623 624
/***********************************************************/
/* QEMU Block devices */

625
#define HD_ALIAS "index=%d,media=disk"
T
ths 已提交
626 627
#define CDROM_ALIAS "index=2,media=cdrom"
#define FD_ALIAS "index=%d,if=floppy"
628 629
#define PFLASH_ALIAS "if=pflash"
#define MTD_ALIAS "if=mtd"
630
#define SD_ALIAS "index=0,if=sd"
T
ths 已提交
631

G
Gerd Hoffmann 已提交
632 633
static int drive_init_func(QemuOpts *opts, void *opaque)
{
634
    int *use_scsi = opaque;
G
Gerd Hoffmann 已提交
635 636
    int fatal_error = 0;

637
    if (drive_init(opts, *use_scsi, &fatal_error) == NULL) {
G
Gerd Hoffmann 已提交
638 639 640 641 642 643 644 645 646 647 648 649 650 651
        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 已提交
652 653 654 655 656 657 658 659 660 661 662 663 664 665
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);
}

666
static void validate_bootdevices(char *devices)
J
Jan Kiszka 已提交
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
{
    /* 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');
    }
}

J
Jan Kiszka 已提交
694 695 696
static void restore_boot_devices(void *opaque)
{
    char *standard_boot_devices = opaque;
A
Alex Williamson 已提交
697 698 699 700 701 702 703
    static int first = 1;

    /* Restore boot order and remove ourselves after the first boot */
    if (first) {
        first = 0;
        return;
    }
J
Jan Kiszka 已提交
704 705 706 707 708 709 710

    qemu_boot_set(standard_boot_devices);

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

711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
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");
                    }
P
Paolo Bonzini 已提交
755
                    value = (2ULL << endvalue) - (1ULL << value);
756
                } else {
P
Paolo Bonzini 已提交
757
                    value = 1ULL << value;
758 759 760 761 762 763 764 765 766
                }
            }
            node_cpumask[nodenr] = value;
        }
        nb_numa_nodes++;
    }
    return;
}

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
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 {
        if (cores == 0) {
            threads = threads > 0 ? threads : 1;
            cores = smp / (sockets * threads);
        } else {
A
Amit Shah 已提交
801
            if (sockets) {
802 803 804 805 806 807 808 809 810 811 812
                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 已提交
813 814 815
/***********************************************************/
/* USB devices */

816
static int usb_device_add(const char *devname)
B
bellard 已提交
817 818
{
    const char *p;
819
    USBDevice *dev = NULL;
B
bellard 已提交
820

821
    if (!usb_enabled)
B
bellard 已提交
822 823
        return -1;

G
Gerd Hoffmann 已提交
824 825 826 827 828
    /* drivers with .usbdevice_name entry in USBDeviceInfo */
    dev = usbdevice_create(devname);
    if (dev)
        goto done;

829
    /* the other ones */
B
bellard 已提交
830 831
    if (strstart(devname, "host:", &p)) {
        dev = usb_host_device_open(p);
832 833 834
    } 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 已提交
835 836 837
    } else {
        return -1;
    }
P
pbrook 已提交
838 839 840
    if (!dev)
        return -1;

841
done:
B
bellard 已提交
842 843 844
    return 0;
}

845 846 847 848 849
static int usb_device_del(const char *devname)
{
    int bus_num, addr;
    const char *p;

850 851 852
    if (strstart(devname, "host:", &p))
        return usb_host_device_close(p);

853
    if (!usb_enabled)
854 855 856 857 858 859 860 861
        return -1;

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

862
    return usb_device_delete_addr(bus_num, addr);
863 864
}

865 866
static int usb_parse(const char *cmdline)
{
S
Scott Tsai 已提交
867
    int r;
868
    r = usb_device_add(cmdline);
S
Scott Tsai 已提交
869 870 871 872
    if (r < 0) {
        fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
    }
    return r;
873 874
}

875
void do_usb_add(Monitor *mon, const QDict *qdict)
B
bellard 已提交
876
{
S
Scott Tsai 已提交
877
    const char *devname = qdict_get_str(qdict, "devname");
878
    if (usb_device_add(devname) < 0) {
879
        error_report("could not add USB device '%s'", devname);
S
Scott Tsai 已提交
880
    }
B
bellard 已提交
881 882
}

883
void do_usb_del(Monitor *mon, const QDict *qdict)
B
bellard 已提交
884
{
S
Scott Tsai 已提交
885 886
    const char *devname = qdict_get_str(qdict, "devname");
    if (usb_device_del(devname) < 0) {
887
        error_report("could not delete USB device '%s'", devname);
S
Scott Tsai 已提交
888
    }
B
bellard 已提交
889 890
}

891 892 893 894
/***********************************************************/
/* PCMCIA/Cardbus */

static struct pcmcia_socket_entry_s {
P
Paul Brook 已提交
895
    PCMCIASocket *socket;
896 897 898
    struct pcmcia_socket_entry_s *next;
} *pcmcia_sockets = 0;

P
Paul Brook 已提交
899
void pcmcia_socket_register(PCMCIASocket *socket)
900 901 902 903 904 905 906 907 908
{
    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 已提交
909
void pcmcia_socket_unregister(PCMCIASocket *socket)
910 911 912 913 914 915 916 917 918 919 920
{
    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 已提交
921
void pcmcia_info(Monitor *mon)
922 923
{
    struct pcmcia_socket_entry_s *iter;
A
aliguori 已提交
924

925
    if (!pcmcia_sockets)
A
aliguori 已提交
926
        monitor_printf(mon, "No PCMCIA sockets\n");
927 928

    for (iter = pcmcia_sockets; iter; iter = iter->next)
A
aliguori 已提交
929 930 931
        monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
                       iter->socket->attached ? iter->socket->card_string :
                       "Empty");
932 933
}

934
/***********************************************************/
935
/* I/O handling */
936

937 938
typedef struct IOHandlerRecord {
    int fd;
939
    IOCanReadHandler *fd_read_poll;
B
bellard 已提交
940 941
    IOHandler *fd_read;
    IOHandler *fd_write;
942
    int deleted;
943 944 945
    void *opaque;
    /* temporary data */
    struct pollfd *ufd;
J
Juan Quintela 已提交
946
    QLIST_ENTRY(IOHandlerRecord) next;
947 948
} IOHandlerRecord;

J
Juan Quintela 已提交
949 950 951
static QLIST_HEAD(, IOHandlerRecord) io_handlers =
    QLIST_HEAD_INITIALIZER(io_handlers);

952

B
bellard 已提交
953 954
/* XXX: fd_read_poll should be suppressed, but an API change is
   necessary in the character devices to suppress fd_can_read(). */
955
int qemu_set_fd_handler2(int fd,
956
                         IOCanReadHandler *fd_read_poll,
957 958
                         IOHandler *fd_read,
                         IOHandler *fd_write,
B
bellard 已提交
959
                         void *opaque)
960
{
J
Juan Quintela 已提交
961
    IOHandlerRecord *ioh;
962

B
bellard 已提交
963
    if (!fd_read && !fd_write) {
J
Juan Quintela 已提交
964
        QLIST_FOREACH(ioh, &io_handlers, next) {
B
bellard 已提交
965
            if (ioh->fd == fd) {
966
                ioh->deleted = 1;
B
bellard 已提交
967 968 969 970
                break;
            }
        }
    } else {
J
Juan Quintela 已提交
971
        QLIST_FOREACH(ioh, &io_handlers, next) {
B
bellard 已提交
972 973 974 975
            if (ioh->fd == fd)
                goto found;
        }
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
J
Juan Quintela 已提交
976
        QLIST_INSERT_HEAD(&io_handlers, ioh, next);
B
bellard 已提交
977 978 979 980 981 982
    found:
        ioh->fd = fd;
        ioh->fd_read_poll = fd_read_poll;
        ioh->fd_read = fd_read;
        ioh->fd_write = fd_write;
        ioh->opaque = opaque;
983
        ioh->deleted = 0;
B
bellard 已提交
984
    }
985 986 987
    return 0;
}

988 989 990
int qemu_set_fd_handler(int fd,
                        IOHandler *fd_read,
                        IOHandler *fd_write,
B
bellard 已提交
991
                        void *opaque)
992
{
B
bellard 已提交
993
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
994 995
}

996 997 998
/***********************************************************/
/* machine registration */

B
blueswir1 已提交
999
static QEMUMachine *first_machine = NULL;
1000
QEMUMachine *current_machine = NULL;
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012

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

1013
static QEMUMachine *find_machine(const char *name)
1014 1015 1016 1017 1018 1019
{
    QEMUMachine *m;

    for(m = first_machine; m != NULL; m = m->next) {
        if (!strcmp(m->name, name))
            return m;
M
Mark McLoughlin 已提交
1020 1021
        if (m->alias && !strcmp(m->alias, name))
            return m;
1022 1023 1024 1025
    }
    return NULL;
}

1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
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;
}

1038 1039 1040
/***********************************************************/
/* main execution loop */

1041
static void gui_update(void *opaque)
1042
{
1043
    uint64_t interval = GUI_REFRESH_INTERVAL;
1044
    DisplayState *ds = opaque;
1045 1046
    DisplayChangeListener *dcl = ds->listeners;

1047
    qemu_flush_coalesced_mmio_buffer();
1048 1049 1050 1051 1052 1053 1054 1055 1056
    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));
1057 1058
}

B
blueswir1 已提交
1059 1060 1061 1062
static void nographic_update(void *opaque)
{
    uint64_t interval = GUI_REFRESH_INTERVAL;

1063
    qemu_flush_coalesced_mmio_buffer();
B
blueswir1 已提交
1064 1065 1066
    qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
}

B
bellard 已提交
1067 1068 1069
struct vm_change_state_entry {
    VMChangeStateHandler *cb;
    void *opaque;
B
Blue Swirl 已提交
1070
    QLIST_ENTRY (vm_change_state_entry) entries;
B
bellard 已提交
1071 1072
};

B
Blue Swirl 已提交
1073
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
B
bellard 已提交
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083

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

    e = qemu_mallocz(sizeof (*e));

    e->cb = cb;
    e->opaque = opaque;
B
Blue Swirl 已提交
1084
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
B
bellard 已提交
1085 1086 1087 1088 1089
    return e;
}

void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
{
B
Blue Swirl 已提交
1090
    QLIST_REMOVE (e, entries);
B
bellard 已提交
1091 1092 1093
    qemu_free (e);
}

1094
void vm_state_notify(int running, int reason)
B
bellard 已提交
1095 1096 1097 1098
{
    VMChangeStateEntry *e;

    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
1099
        e->cb(e->opaque, running, reason);
B
bellard 已提交
1100 1101 1102
    }
}

1103 1104 1105 1106 1107
void vm_start(void)
{
    if (!vm_running) {
        cpu_enable_ticks();
        vm_running = 1;
1108
        vm_state_notify(1, 0);
1109
        resume_all_vcpus();
L
Luiz Capitulino 已提交
1110
        monitor_protocol_event(QEVENT_RESUME, NULL);
1111 1112 1113
    }
}

1114 1115 1116
/* reset/shutdown handler */

typedef struct QEMUResetEntry {
B
Blue Swirl 已提交
1117
    QTAILQ_ENTRY(QEMUResetEntry) entry;
1118 1119 1120 1121
    QEMUResetHandler *func;
    void *opaque;
} QEMUResetEntry;

B
Blue Swirl 已提交
1122 1123
static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
    QTAILQ_HEAD_INITIALIZER(reset_handlers);
1124 1125
static int reset_requested;
static int shutdown_requested;
B
bellard 已提交
1126
static int powerdown_requested;
1127
int debug_requested;
1128
int vmstop_requested;
1129

A
aurel32 已提交
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
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;
}

1151 1152 1153 1154 1155 1156 1157
static int qemu_debug_requested(void)
{
    int r = debug_requested;
    debug_requested = 0;
    return r;
}

1158 1159 1160 1161 1162 1163 1164
static int qemu_vmstop_requested(void)
{
    int r = vmstop_requested;
    vmstop_requested = 0;
    return r;
}

1165
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
1166
{
J
Jan Kiszka 已提交
1167
    QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
1168 1169 1170

    re->func = func;
    re->opaque = opaque;
B
Blue Swirl 已提交
1171
    QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
1172 1173
}

J
Jan Kiszka 已提交
1174
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
1175 1176 1177
{
    QEMUResetEntry *re;

B
Blue Swirl 已提交
1178
    QTAILQ_FOREACH(re, &reset_handlers, entry) {
J
Jan Kiszka 已提交
1179
        if (re->func == func && re->opaque == opaque) {
B
Blue Swirl 已提交
1180
            QTAILQ_REMOVE(&reset_handlers, re, entry);
J
Jan Kiszka 已提交
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
            qemu_free(re);
            return;
        }
    }
}

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

    /* reset all devices */
B
Blue Swirl 已提交
1192
    QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
1193 1194
        re->func(re->opaque);
    }
1195
    monitor_protocol_event(QEVENT_RESET, NULL);
1196
    cpu_synchronize_all_post_reset();
1197 1198 1199 1200
}

void qemu_system_reset_request(void)
{
B
bellard 已提交
1201 1202 1203 1204 1205
    if (no_reboot) {
        shutdown_requested = 1;
    } else {
        reset_requested = 1;
    }
1206
    qemu_notify_event();
1207 1208 1209 1210 1211
}

void qemu_system_shutdown_request(void)
{
    shutdown_requested = 1;
1212
    qemu_notify_event();
1213 1214
}

B
bellard 已提交
1215 1216 1217
void qemu_system_powerdown_request(void)
{
    powerdown_requested = 1;
1218 1219 1220
    qemu_notify_event();
}

1221
void main_loop_wait(int nonblocking)
A
aliguori 已提交
1222 1223 1224 1225 1226
{
    IOHandlerRecord *ioh;
    fd_set rfds, wfds, xfds;
    int ret, nfds;
    struct timeval tv;
1227
    int timeout;
A
aliguori 已提交
1228

1229 1230 1231 1232 1233 1234
    if (nonblocking)
        timeout = 0;
    else {
        timeout = qemu_calculate_timeout();
        qemu_bh_update_timeout(&timeout);
    }
A
aliguori 已提交
1235

1236
    os_host_main_loop_wait(&timeout);
A
aliguori 已提交
1237

B
bellard 已提交
1238 1239
    /* poll any events */
    /* XXX: separate device handlers from system ones */
1240
    nfds = -1;
B
bellard 已提交
1241 1242
    FD_ZERO(&rfds);
    FD_ZERO(&wfds);
1243
    FD_ZERO(&xfds);
J
Juan Quintela 已提交
1244
    QLIST_FOREACH(ioh, &io_handlers, next) {
1245 1246
        if (ioh->deleted)
            continue;
B
bellard 已提交
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
        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;
        }
    }
1260

A
aliguori 已提交
1261 1262 1263
    tv.tv_sec = timeout / 1000;
    tv.tv_usec = (timeout % 1000) * 1000;

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

1266
    qemu_mutex_unlock_iothread();
1267
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
1268
    qemu_mutex_lock_iothread();
B
bellard 已提交
1269
    if (ret > 0) {
J
Juan Quintela 已提交
1270
        IOHandlerRecord *pioh;
1271

J
Juan Quintela 已提交
1272
        QLIST_FOREACH_SAFE(ioh, &io_handlers, next, pioh) {
1273
            if (ioh->deleted) {
J
Juan Quintela 已提交
1274
                QLIST_REMOVE(ioh, next);
1275
                qemu_free(ioh);
1276 1277 1278 1279 1280 1281 1282
                continue;
            }
            if (ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
                ioh->fd_read(ioh->opaque);
            }
            if (ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
                ioh->fd_write(ioh->opaque);
J
Juan Quintela 已提交
1283
            }
1284
        }
B
bellard 已提交
1285
    }
J
Jan Kiszka 已提交
1286 1287

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

1289
    qemu_run_all_timers();
J
Jan Kiszka 已提交
1290

P
pbrook 已提交
1291 1292 1293
    /* Check bottom-halves last in case any of the earlier events triggered
       them.  */
    qemu_bh_poll();
1294

B
bellard 已提交
1295 1296
}

1297 1298 1299 1300 1301 1302 1303 1304
static int vm_can_run(void)
{
    if (powerdown_requested)
        return 0;
    if (reset_requested)
        return 0;
    if (shutdown_requested)
        return 0;
1305 1306
    if (debug_requested)
        return 0;
1307 1308 1309
    return 1;
}

B
Blue Swirl 已提交
1310 1311
qemu_irq qemu_system_powerdown;

1312 1313
static void main_loop(void)
{
1314
    int r;
1315

1316
    qemu_main_loop_start();
1317

1318
    for (;;) {
1319
        do {
1320
            bool nonblocking = false;
1321 1322 1323
#ifdef CONFIG_PROFILER
            int64_t ti;
#endif
1324
#ifndef CONFIG_IOTHREAD
1325
            nonblocking = tcg_cpu_exec();
1326
#endif
1327
#ifdef CONFIG_PROFILER
1328
            ti = profile_getclock();
1329
#endif
1330
            main_loop_wait(nonblocking);
1331
#ifdef CONFIG_PROFILER
1332
            dev_time += profile_getclock() - ti;
1333
#endif
1334
        } while (vm_can_run());
1335

B
Blue Swirl 已提交
1336 1337
        if ((r = qemu_debug_requested())) {
            vm_stop(r);
1338
        }
1339
        if (qemu_shutdown_requested()) {
1340
            monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
1341 1342 1343 1344 1345 1346
            if (no_shutdown) {
                vm_stop(0);
                no_shutdown = 0;
            } else
                break;
        }
1347 1348
        if (qemu_reset_requested()) {
            pause_all_vcpus();
1349
            qemu_system_reset();
1350 1351
            resume_all_vcpus();
        }
B
Blue Swirl 已提交
1352
        if (qemu_powerdown_requested()) {
1353
            monitor_protocol_event(QEVENT_POWERDOWN, NULL);
B
Blue Swirl 已提交
1354 1355
            qemu_irq_raise(qemu_system_powerdown);
        }
1356
        if ((r = qemu_vmstop_requested())) {
1357
            vm_stop(r);
1358
        }
B
bellard 已提交
1359
    }
1360
    bdrv_close_all();
1361
    pause_all_vcpus();
B
bellard 已提交
1362 1363
}

P
pbrook 已提交
1364 1365
static void version(void)
{
T
Thomas Monjalon 已提交
1366
    printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
P
pbrook 已提交
1367 1368
}

1369
static void help(int exitcode)
1370
{
1371
    const char *options_help =
1372 1373
#define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
        opt_help
1374
#define DEFHEADING(text) stringify(text) "\n"
1375
#include "qemu-options.def"
1376 1377 1378
#undef DEF
#undef DEFHEADING
#undef GEN_DOCS
1379 1380 1381 1382
        ;
    version();
    printf("usage: %s [options] [disk_image]\n"
           "\n"
T
Thomas Monjalon 已提交
1383
           "'disk_image' is a raw hard disk image for IDE hard disk 0\n"
1384
           "\n"
1385
           "%s\n"
1386 1387 1388 1389 1390
           "During emulation, the following keys are useful:\n"
           "ctrl-alt-f      toggle full screen\n"
           "ctrl-alt-n      switch to virtual console 'n'\n"
           "ctrl-alt        toggle mouse and keyboard grab\n"
           "\n"
1391 1392 1393
           "When using -nographic, press 'ctrl-a h' to get some help.\n",
           "qemu",
           options_help);
1394
    exit(exitcode);
1395 1396
}

1397 1398 1399 1400 1401 1402
#define HAS_ARG 0x0001

typedef struct QEMUOption {
    const char *name;
    int flags;
    int index;
1403
    uint32_t arch_mask;
1404 1405
} QEMUOption;

B
blueswir1 已提交
1406
static const QEMUOption qemu_options[] = {
1407 1408 1409
    { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
#define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
    { option, opt_arg, opt_enum, arch_mask },
1410
#define DEFHEADING(text)
1411
#include "qemu-options.def"
1412 1413 1414
#undef DEF
#undef DEFHEADING
#undef GEN_DOCS
1415
    { NULL },
B
bellard 已提交
1416
};
1417 1418 1419 1420
static void select_vgahw (const char *p)
{
    const char *opts;

G
Gerd Hoffmann 已提交
1421
    default_vga = 0;
1422
    vga_interface_type = VGA_NONE;
1423
    if (strstart(p, "std", &opts)) {
1424
        vga_interface_type = VGA_STD;
1425
    } else if (strstart(p, "cirrus", &opts)) {
1426
        vga_interface_type = VGA_CIRRUS;
1427
    } else if (strstart(p, "vmware", &opts)) {
1428
        vga_interface_type = VGA_VMWARE;
1429
    } else if (strstart(p, "xenfb", &opts)) {
1430
        vga_interface_type = VGA_XENFB;
1431
    } else if (!strstart(p, "none", &opts)) {
1432 1433 1434 1435
    invalid_vga:
        fprintf(stderr, "Unknown vga type: %s\n", p);
        exit(1);
    }
M
malc 已提交
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
    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;
    }
1449 1450
}

1451 1452
static int balloon_parse(const char *arg)
{
1453
    QemuOpts *opts;
1454

1455 1456 1457 1458 1459 1460 1461
    if (strcmp(arg, "none") == 0) {
        return 0;
    }

    if (!strncmp(arg, "virtio", 6)) {
        if (arg[6] == ',') {
            /* have params -> parse them */
1462
            opts = qemu_opts_parse(&qemu_device_opts, arg+7, 0);
1463 1464 1465 1466 1467
            if (!opts)
                return  -1;
        } else {
            /* create empty opts */
            opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
1468
        }
1469 1470
        qemu_opt_set(opts, "driver", "virtio-balloon-pci");
        return 0;
1471
    }
1472 1473

    return -1;
1474 1475
}

P
Paul Brook 已提交
1476 1477 1478 1479 1480 1481 1482 1483 1484
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) {
1485
        return qemu_strdup(name);
P
Paul Brook 已提交
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
    }
    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);
1499
    snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
P
Paul Brook 已提交
1500 1501 1502 1503 1504 1505 1506
    if (access(buf, R_OK)) {
        qemu_free(buf);
        return NULL;
    }
    return buf;
}

1507 1508 1509 1510 1511
static int device_help_func(QemuOpts *opts, void *opaque)
{
    return qdev_device_help(opts);
}

G
Gerd Hoffmann 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
static int device_init_func(QemuOpts *opts, void *opaque)
{
    DeviceState *dev;

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

1522 1523 1524 1525 1526 1527 1528 1529 1530 1531
static int chardev_init_func(QemuOpts *opts, void *opaque)
{
    CharDriverState *chr;

    chr = qemu_chr_open_opts(opts, NULL);
    if (!chr)
        return -1;
    return 0;
}

1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
#ifdef CONFIG_LINUX
static int fsdev_init_func(QemuOpts *opts, void *opaque)
{
    int ret;
    ret = qemu_fsdev_add(opts);

    return ret;
}
#endif

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 1574 1575
static int mon_init_func(QemuOpts *opts, void *opaque)
{
    CharDriverState *chr;
    const char *chardev;
    const char *mode;
    int flags;

    mode = qemu_opt_get(opts, "mode");
    if (mode == NULL) {
        mode = "readline";
    }
    if (strcmp(mode, "readline") == 0) {
        flags = MONITOR_USE_READLINE;
    } else if (strcmp(mode, "control") == 0) {
        flags = MONITOR_USE_CONTROL;
    } else {
        fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
        exit(1);
    }

    if (qemu_opt_get_bool(opts, "default", 0))
        flags |= MONITOR_IS_DEFAULT;

    chardev = qemu_opt_get(opts, "chardev");
    chr = qemu_chr_find(chardev);
    if (chr == NULL) {
        fprintf(stderr, "chardev \"%s\" not found\n", chardev);
        exit(1);
    }

    monitor_init(chr, flags);
    return 0;
}

G
Gerd Hoffmann 已提交
1576
static void monitor_parse(const char *optarg, const char *mode)
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
{
    static int monitor_device_index = 0;
    QemuOpts *opts;
    const char *p;
    char label[32];
    int def = 0;

    if (strstart(optarg, "chardev:", &p)) {
        snprintf(label, sizeof(label), "%s", p);
    } else {
1587 1588 1589
        snprintf(label, sizeof(label), "compat_monitor%d",
                 monitor_device_index);
        if (monitor_device_index == 0) {
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
            def = 1;
        }
        opts = qemu_chr_parse_compat(label, optarg);
        if (!opts) {
            fprintf(stderr, "parse error: %s\n", optarg);
            exit(1);
        }
    }

    opts = qemu_opts_create(&qemu_mon_opts, label, 1);
    if (!opts) {
        fprintf(stderr, "duplicate chardev: %s\n", label);
        exit(1);
    }
G
Gerd Hoffmann 已提交
1604
    qemu_opt_set(opts, "mode", mode);
1605 1606 1607 1608 1609 1610
    qemu_opt_set(opts, "chardev", label);
    if (def)
        qemu_opt_set(opts, "default", "on");
    monitor_device_index++;
}

1611 1612
struct device_config {
    enum {
G
Gerd Hoffmann 已提交
1613 1614 1615 1616 1617
        DEV_USB,       /* -usbdevice     */
        DEV_BT,        /* -bt            */
        DEV_SERIAL,    /* -serial        */
        DEV_PARALLEL,  /* -parallel      */
        DEV_VIRTCON,   /* -virtioconsole */
1618
        DEV_DEBUGCON,  /* -debugcon */
1619 1620
    } type;
    const char *cmdline;
B
Blue Swirl 已提交
1621
    QTAILQ_ENTRY(device_config) next;
1622
};
B
Blue Swirl 已提交
1623
QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
1624 1625 1626 1627 1628 1629 1630 1631

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;
B
Blue Swirl 已提交
1632
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
1633 1634 1635 1636 1637 1638 1639
}

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

B
Blue Swirl 已提交
1640
    QTAILQ_FOREACH(conf, &device_configs, next) {
1641 1642 1643 1644 1645 1646 1647 1648 1649
        if (conf->type != type)
            continue;
        rc = func(conf->cmdline);
        if (0 != rc)
            return rc;
    }
    return 0;
}

1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
static int serial_parse(const char *devname)
{
    static int index = 0;
    char label[32];

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_SERIAL_PORTS) {
        fprintf(stderr, "qemu: too many serial ports\n");
        exit(1);
    }
    snprintf(label, sizeof(label), "serial%d", index);
    serial_hds[index] = qemu_chr_open(label, devname, NULL);
    if (!serial_hds[index]) {
        fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
                devname, strerror(errno));
        return -1;
    }
    index++;
    return 0;
}

G
Gerd Hoffmann 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
static int parallel_parse(const char *devname)
{
    static int index = 0;
    char label[32];

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_PARALLEL_PORTS) {
        fprintf(stderr, "qemu: too many parallel ports\n");
        exit(1);
    }
    snprintf(label, sizeof(label), "parallel%d", index);
    parallel_hds[index] = qemu_chr_open(label, devname, NULL);
    if (!parallel_hds[index]) {
        fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
                devname, strerror(errno));
        return -1;
    }
    index++;
    return 0;
}

G
Gerd Hoffmann 已提交
1694 1695 1696 1697
static int virtcon_parse(const char *devname)
{
    static int index = 0;
    char label[32];
1698
    QemuOpts *bus_opts, *dev_opts;
G
Gerd Hoffmann 已提交
1699 1700 1701 1702 1703 1704 1705

    if (strcmp(devname, "none") == 0)
        return 0;
    if (index == MAX_VIRTIO_CONSOLES) {
        fprintf(stderr, "qemu: too many virtio consoles\n");
        exit(1);
    }
1706 1707 1708 1709 1710 1711 1712

    bus_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
    qemu_opt_set(bus_opts, "driver", "virtio-serial");

    dev_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
    qemu_opt_set(dev_opts, "driver", "virtconsole");

G
Gerd Hoffmann 已提交
1713 1714 1715 1716 1717 1718 1719
    snprintf(label, sizeof(label), "virtcon%d", index);
    virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
    if (!virtcon_hds[index]) {
        fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
                devname, strerror(errno));
        return -1;
    }
1720 1721
    qemu_opt_set(dev_opts, "chardev", label);

G
Gerd Hoffmann 已提交
1722 1723 1724 1725
    index++;
    return 0;
}

1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742
static int debugcon_parse(const char *devname)
{   
    QemuOpts *opts;

    if (!qemu_chr_open("debugcon", devname, NULL)) {
        exit(1);
    }
    opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
    if (!opts) {
        fprintf(stderr, "qemu: already have a debugcon device\n");
        exit(1);
    }
    qemu_opt_set(opts, "driver", "isa-debugcon");
    qemu_opt_set(opts, "chardev", "debugcon");
    return 0;
}

1743 1744 1745 1746 1747 1748 1749 1750
static const QEMUOption *lookup_opt(int argc, char **argv,
                                    const char **poptarg, int *poptind)
{
    const QEMUOption *popt;
    int optind = *poptind;
    char *r = argv[optind];
    const char *optarg;

1751
    loc_set_cmdline(argv, optind, 1);
1752 1753 1754 1755 1756 1757 1758
    optind++;
    /* Treat --foo the same as -foo.  */
    if (r[1] == '-')
        r++;
    popt = qemu_options;
    for(;;) {
        if (!popt->name) {
1759
            error_report("invalid option");
1760 1761 1762 1763 1764 1765 1766 1767
            exit(1);
        }
        if (!strcmp(popt->name, r + 1))
            break;
        popt++;
    }
    if (popt->flags & HAS_ARG) {
        if (optind >= argc) {
1768
            error_report("requires an argument");
1769 1770 1771
            exit(1);
        }
        optarg = argv[optind++];
1772
        loc_set_cmdline(argv, optind - 2, 2);
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
    } else {
        optarg = NULL;
    }

    *poptarg = optarg;
    *poptind = optind;

    return popt;
}

M
malc 已提交
1783
int main(int argc, char **argv, char **envp)
1784
{
1785
    const char *gdbstub_dev = NULL;
T
ths 已提交
1786
    int i;
1787
    int snapshot, linux_boot;
P
Paolo Bonzini 已提交
1788
    const char *icount_option = NULL;
B
bellard 已提交
1789
    const char *initrd_filename;
1790
    const char *kernel_filename, *kernel_cmdline;
1791
    char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
1792
    DisplayState *ds;
1793
    DisplayChangeListener *dcl;
B
bellard 已提交
1794
    int cyls, heads, secs, translation;
G
Gerd Hoffmann 已提交
1795
    QemuOpts *hda_opts = NULL, *opts;
1796
    int optind;
1797
    const char *optarg;
B
bellard 已提交
1798
    const char *loadvm = NULL;
1799
    QEMUMachine *machine;
1800
    const char *cpu_model;
1801
    int tb_size;
1802
    const char *pid_file = NULL;
A
aliguori 已提交
1803
    const char *incoming = NULL;
1804
    int show_vnc_port = 0;
1805
    int defconfig = 1;
B
bellard 已提交
1806

1807 1808
    error_set_progname(argv[0]);

J
Jan Kiszka 已提交
1809 1810
    init_clocks();

M
malc 已提交
1811 1812
    qemu_cache_utils_init(envp);

B
Blue Swirl 已提交
1813
    QLIST_INIT (&vm_change_state_head);
1814
    os_setup_early_signal_handling();
1815

1816
    module_call_init(MODULE_INIT_MACHINE);
1817
    machine = find_default_machine();
1818
    cpu_model = NULL;
B
bellard 已提交
1819
    initrd_filename = NULL;
1820
    ram_size = 0;
1821
    snapshot = 0;
1822 1823
    kernel_filename = NULL;
    kernel_cmdline = "";
1824
    cyls = heads = secs = 0;
B
bellard 已提交
1825
    translation = BIOS_ATA_TRANSLATION_AUTO;
1826

1827 1828 1829 1830 1831 1832
    for (i = 0; i < MAX_NODES; i++) {
        node_mem[i] = 0;
        node_cpumask[i] = 0;
    }

    nb_numa_nodes = 0;
B
bellard 已提交
1833
    nb_nics = 0;
1834

1835
    tb_size = 0;
1836 1837
    autostart= 1;

1838 1839 1840 1841 1842
    /* first pass of option parsing */
    optind = 1;
    while (optind < argc) {
        if (argv[optind][0] != '-') {
            /* disk image */
1843
            optind++;
1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857
            continue;
        } else {
            const QEMUOption *popt;

            popt = lookup_opt(argc, argv, &optarg, &optind);
            switch (popt->index) {
            case QEMU_OPTION_nodefconfig:
                defconfig=0;
                break;
            }
        }
    }

    if (defconfig) {
1858
        int ret;
1859

1860
        ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf");
1861
        if (ret < 0 && ret != -ENOENT) {
1862
            exit(1);
1863 1864
        }

1865
        ret = qemu_read_config_file(arch_config_name);
1866
        if (ret < 0 && ret != -ENOENT) {
1867
            exit(1);
1868 1869
        }
    }
1870
    cpudef_init();
1871 1872

    /* second pass of option parsing */
1873
    optind = 1;
1874
    for(;;) {
1875
        if (optind >= argc)
1876
            break;
1877
        if (argv[optind][0] != '-') {
G
Gerd Hoffmann 已提交
1878
	    hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
1879 1880 1881
        } else {
            const QEMUOption *popt;

1882
            popt = lookup_opt(argc, argv, &optarg, &optind);
1883 1884 1885 1886
            if (!(popt->arch_mask & arch_type)) {
                printf("Option %s not supported for this target\n", popt->name);
                exit(1);
            }
1887
            switch(popt->index) {
1888 1889 1890 1891 1892 1893
            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 已提交
1894 1895 1896
                        if (m->alias)
                            printf("%-10s %s (alias of %s)\n",
                                   m->alias, m->desc, m->name);
1897
                        printf("%-10s %s%s\n",
1898
                               m->name, m->desc,
1899
                               m->is_default ? " (default)" : "");
1900
                    }
1901
                    exit(*optarg != '?');
1902 1903
                }
                break;
1904 1905
            case QEMU_OPTION_cpu:
                /* hw initialization will check this */
1906
                if (*optarg == '?') {
1907
                    list_cpus(stdout, &fprintf, optarg);
1908
                    exit(0);
1909 1910 1911 1912
                } else {
                    cpu_model = optarg;
                }
                break;
1913
            case QEMU_OPTION_initrd:
B
bellard 已提交
1914 1915
                initrd_filename = optarg;
                break;
1916
            case QEMU_OPTION_hda:
T
ths 已提交
1917
                if (cyls == 0)
G
Gerd Hoffmann 已提交
1918
                    hda_opts = drive_add(optarg, HD_ALIAS, 0);
T
ths 已提交
1919
                else
G
Gerd Hoffmann 已提交
1920
                    hda_opts = drive_add(optarg, HD_ALIAS
T
ths 已提交
1921
			     ",cyls=%d,heads=%d,secs=%d%s",
1922
                             0, cyls, heads, secs,
T
ths 已提交
1923 1924 1925 1926 1927
                             translation == BIOS_ATA_TRANSLATION_LBA ?
                                 ",trans=lba" :
                             translation == BIOS_ATA_TRANSLATION_NONE ?
                                 ",trans=none" : "");
                 break;
1928
            case QEMU_OPTION_hdb:
1929 1930
            case QEMU_OPTION_hdc:
            case QEMU_OPTION_hdd:
1931
                drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
B
bellard 已提交
1932
                break;
T
ths 已提交
1933
            case QEMU_OPTION_drive:
1934
                drive_add(NULL, "%s", optarg);
T
ths 已提交
1935
	        break;
G
Gerd Hoffmann 已提交
1936 1937 1938 1939
            case QEMU_OPTION_set:
                if (qemu_set_option(optarg) != 0)
                    exit(1);
	        break;
1940 1941 1942 1943
            case QEMU_OPTION_global:
                if (qemu_global_option(optarg) != 0)
                    exit(1);
	        break;
1944
            case QEMU_OPTION_mtdblock:
1945
                drive_add(optarg, MTD_ALIAS);
1946
                break;
1947
            case QEMU_OPTION_sd:
1948
                drive_add(optarg, SD_ALIAS);
1949
                break;
1950
            case QEMU_OPTION_pflash:
1951
                drive_add(optarg, PFLASH_ALIAS);
1952
                break;
1953
            case QEMU_OPTION_snapshot:
1954 1955
                snapshot = 1;
                break;
1956
            case QEMU_OPTION_hdachs:
1957 1958 1959 1960
                {
                    const char *p;
                    p = optarg;
                    cyls = strtol(p, (char **)&p, 0);
B
bellard 已提交
1961 1962
                    if (cyls < 1 || cyls > 16383)
                        goto chs_fail;
1963 1964 1965 1966
                    if (*p != ',')
                        goto chs_fail;
                    p++;
                    heads = strtol(p, (char **)&p, 0);
B
bellard 已提交
1967 1968
                    if (heads < 1 || heads > 16)
                        goto chs_fail;
1969 1970 1971 1972
                    if (*p != ',')
                        goto chs_fail;
                    p++;
                    secs = strtol(p, (char **)&p, 0);
B
bellard 已提交
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
                    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') {
1986
                    chs_fail:
B
bellard 已提交
1987 1988
                        fprintf(stderr, "qemu: invalid physical CHS format\n");
                        exit(1);
1989
                    }
G
Gerd Hoffmann 已提交
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
		    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");
                    }
2003 2004
                }
                break;
2005 2006 2007 2008 2009 2010 2011
            case QEMU_OPTION_numa:
                if (nb_numa_nodes >= MAX_NODES) {
                    fprintf(stderr, "qemu: too many NUMA nodes\n");
                    exit(1);
                }
                numa_add(optarg);
                break;
2012
            case QEMU_OPTION_nographic:
2013
                display_type = DT_NOGRAPHIC;
2014
                break;
B
balrog 已提交
2015 2016
#ifdef CONFIG_CURSES
            case QEMU_OPTION_curses:
2017
                display_type = DT_CURSES;
B
balrog 已提交
2018 2019
                break;
#endif
2020 2021 2022
            case QEMU_OPTION_portrait:
                graphic_rotate = 1;
                break;
2023
            case QEMU_OPTION_kernel:
2024 2025
                kernel_filename = optarg;
                break;
2026
            case QEMU_OPTION_append:
2027
                kernel_cmdline = optarg;
2028
                break;
2029
            case QEMU_OPTION_cdrom:
2030
                drive_add(optarg, CDROM_ALIAS);
2031
                break;
2032
            case QEMU_OPTION_boot:
2033
                {
J
Jan Kiszka 已提交
2034
                    static const char * const params[] = {
2035
                        "order", "once", "menu", NULL
J
Jan Kiszka 已提交
2036 2037
                    };
                    char buf[sizeof(boot_devices)];
J
Jan Kiszka 已提交
2038
                    char *standard_boot_devices;
J
Jan Kiszka 已提交
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052
                    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)) {
2053
                        validate_bootdevices(buf);
J
Jan Kiszka 已提交
2054
                        pstrcpy(boot_devices, sizeof(boot_devices), buf);
2055
                    }
J
Jan Kiszka 已提交
2056 2057 2058
                    if (!legacy) {
                        if (get_param_value(buf, sizeof(buf),
                                            "once", optarg)) {
2059
                            validate_bootdevices(buf);
J
Jan Kiszka 已提交
2060 2061 2062 2063 2064
                            standard_boot_devices = qemu_strdup(boot_devices);
                            pstrcpy(boot_devices, sizeof(boot_devices), buf);
                            qemu_register_reset(restore_boot_devices,
                                                standard_boot_devices);
                        }
2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077
                        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 已提交
2078
                    }
2079 2080
                }
                break;
2081 2082
            case QEMU_OPTION_fda:
            case QEMU_OPTION_fdb:
2083
                drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
2084
                break;
B
bellard 已提交
2085 2086 2087
            case QEMU_OPTION_no_fd_bootchk:
                fd_bootchk = 0;
                break;
M
Mark McLoughlin 已提交
2088 2089 2090 2091 2092
            case QEMU_OPTION_netdev:
                if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
                    exit(1);
                }
                break;
B
bellard 已提交
2093
            case QEMU_OPTION_net:
2094
                if (net_client_parse(&qemu_net_opts, optarg) == -1) {
2095 2096
                    exit(1);
                }
B
bellard 已提交
2097
                break;
B
bellard 已提交
2098 2099
#ifdef CONFIG_SLIRP
            case QEMU_OPTION_tftp:
2100
                legacy_tftp_prefix = optarg;
B
bellard 已提交
2101
                break;
2102
            case QEMU_OPTION_bootp:
2103
                legacy_bootp_filename = optarg;
2104
                break;
B
bellard 已提交
2105
            case QEMU_OPTION_redir:
M
Markus Armbruster 已提交
2106 2107
                if (net_slirp_redir(optarg) < 0)
                    exit(1);
B
bellard 已提交
2108
                break;
B
bellard 已提交
2109
#endif
2110
            case QEMU_OPTION_bt:
2111
                add_device_config(DEV_BT, optarg);
2112
                break;
2113
            case QEMU_OPTION_audio_help:
2114 2115 2116 2117
                if (!(audio_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
2118 2119 2120 2121
                AUD_help ();
                exit (0);
                break;
            case QEMU_OPTION_soundhw:
2122 2123 2124 2125
                if (!(audio_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
2126 2127
                select_soundhw (optarg);
                break;
2128
            case QEMU_OPTION_h:
2129
                help(0);
2130
                break;
P
pbrook 已提交
2131 2132 2133 2134
            case QEMU_OPTION_version:
                version();
                exit(0);
                break;
2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
            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);
2149 2150
                    exit(1);
                }
2151 2152

                /* On 32-bit hosts, QEMU is limited by virtual address space */
2153
                if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
2154 2155 2156
                    fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
                    exit(1);
                }
A
Anthony Liguori 已提交
2157
                if (value != (uint64_t)(ram_addr_t)value) {
2158 2159 2160 2161
                    fprintf(stderr, "qemu: ram size too large\n");
                    exit(1);
                }
                ram_size = value;
2162
                break;
2163
            }
2164 2165 2166 2167 2168 2169 2170 2171
            case QEMU_OPTION_mempath:
                mem_path = optarg;
                break;
#ifdef MAP_POPULATE
            case QEMU_OPTION_mem_prealloc:
                mem_prealloc = 1;
                break;
#endif
2172
            case QEMU_OPTION_d:
2173
                set_cpu_log(optarg);
2174 2175
                break;
            case QEMU_OPTION_s:
2176
                gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
2177
                break;
2178 2179
            case QEMU_OPTION_gdb:
                gdbstub_dev = optarg;
2180 2181
                break;
            case QEMU_OPTION_L:
P
Paul Brook 已提交
2182
                data_dir = optarg;
2183
                break;
2184 2185 2186
            case QEMU_OPTION_bios:
                bios_name = optarg;
                break;
2187 2188 2189
            case QEMU_OPTION_singlestep:
                singlestep = 1;
                break;
2190
            case QEMU_OPTION_S:
2191
                autostart = 0;
2192
                break;
2193 2194 2195
	    case QEMU_OPTION_k:
		keyboard_layout = optarg;
		break;
B
bellard 已提交
2196 2197 2198
            case QEMU_OPTION_localtime:
                rtc_utc = 0;
                break;
2199 2200
            case QEMU_OPTION_vga:
                select_vgahw (optarg);
2201
                break;
2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
            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);
2222
                        if (depth != 8 && depth != 15 && depth != 16 &&
2223 2224 2225 2226 2227 2228 2229
                            depth != 24 && depth != 32)
                            goto graphic_error;
                    } else if (*p == '\0') {
                        depth = graphic_depth;
                    } else {
                        goto graphic_error;
                    }
2230

2231 2232 2233 2234 2235
                    graphic_width = w;
                    graphic_height = h;
                    graphic_depth = depth;
                }
                break;
T
ths 已提交
2236 2237 2238 2239 2240 2241 2242 2243
            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 已提交
2244
            case QEMU_OPTION_monitor:
G
Gerd Hoffmann 已提交
2245 2246 2247 2248 2249
                monitor_parse(optarg, "readline");
                default_monitor = 0;
                break;
            case QEMU_OPTION_qmp:
                monitor_parse(optarg, "control");
2250
                default_monitor = 0;
B
bellard 已提交
2251
                break;
G
Gerd Hoffmann 已提交
2252
            case QEMU_OPTION_mon:
2253
                opts = qemu_opts_parse(&qemu_mon_opts, optarg, 1);
G
Gerd Hoffmann 已提交
2254 2255 2256
                if (!opts) {
                    exit(1);
                }
2257
                default_monitor = 0;
G
Gerd Hoffmann 已提交
2258
                break;
2259
            case QEMU_OPTION_chardev:
2260
                opts = qemu_opts_parse(&qemu_chardev_opts, optarg, 1);
2261 2262 2263 2264
                if (!opts) {
                    exit(1);
                }
                break;
2265 2266 2267 2268 2269 2270 2271 2272
#ifdef CONFIG_LINUX
            case QEMU_OPTION_fsdev:
                opts = qemu_opts_parse(&qemu_fsdev_opts, optarg, 1);
                if (!opts) {
                    fprintf(stderr, "parse error: %s\n", optarg);
                    exit(1);
                }
                break;
2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 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 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
            case QEMU_OPTION_virtfs: {
                char *arg_fsdev = NULL;
                char *arg_9p = NULL;
                int len = 0;

                opts = qemu_opts_parse(&qemu_virtfs_opts, optarg, 1);
                if (!opts) {
                    fprintf(stderr, "parse error: %s\n", optarg);
                    exit(1);
                }

                len = strlen(",id=,path=");
                len += strlen(qemu_opt_get(opts, "fstype"));
                len += strlen(qemu_opt_get(opts, "mount_tag"));
                len += strlen(qemu_opt_get(opts, "path"));
                arg_fsdev = qemu_malloc((len + 1) * sizeof(*arg_fsdev));

                if (!arg_fsdev) {
                    fprintf(stderr, "No memory to parse -fsdev for %s\n",
                            optarg);
                    exit(1);
                }

                sprintf(arg_fsdev, "%s,id=%s,path=%s",
                                qemu_opt_get(opts, "fstype"),
                                qemu_opt_get(opts, "mount_tag"),
                                qemu_opt_get(opts, "path"));

                len = strlen("virtio-9p-pci,fsdev=,mount_tag=");
                len += 2*strlen(qemu_opt_get(opts, "mount_tag"));
                arg_9p = qemu_malloc((len + 1) * sizeof(*arg_9p));

                if (!arg_9p) {
                    fprintf(stderr, "No memory to parse -device for %s\n",
                            optarg);
                    exit(1);
                }

                sprintf(arg_9p, "virtio-9p-pci,fsdev=%s,mount_tag=%s",
                                qemu_opt_get(opts, "mount_tag"),
                                qemu_opt_get(opts, "mount_tag"));

                if (!qemu_opts_parse(&qemu_fsdev_opts, arg_fsdev, 1)) {
                    fprintf(stderr, "parse error [fsdev]: %s\n", optarg);
                    exit(1);
                }

                if (!qemu_opts_parse(&qemu_device_opts, arg_9p, 1)) {
                    fprintf(stderr, "parse error [device]: %s\n", optarg);
                    exit(1);
                }

                qemu_free(arg_fsdev);
                qemu_free(arg_9p);
                break;
            }
2329
#endif
B
bellard 已提交
2330
            case QEMU_OPTION_serial:
2331 2332
                add_device_config(DEV_SERIAL, optarg);
                default_serial = 0;
2333 2334 2335
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
B
bellard 已提交
2336
                break;
R
Richard W.M. Jones 已提交
2337
            case QEMU_OPTION_watchdog:
M
Markus Armbruster 已提交
2338 2339 2340 2341 2342 2343
                if (watchdog) {
                    fprintf(stderr,
                            "qemu: only one watchdog option may be given\n");
                    return 1;
                }
                watchdog = optarg;
R
Richard W.M. Jones 已提交
2344 2345 2346 2347 2348 2349 2350
                break;
            case QEMU_OPTION_watchdog_action:
                if (select_watchdog_action(optarg) == -1) {
                    fprintf(stderr, "Unknown -watchdog-action parameter\n");
                    exit(1);
                }
                break;
2351
            case QEMU_OPTION_virtiocon:
G
Gerd Hoffmann 已提交
2352 2353
                add_device_config(DEV_VIRTCON, optarg);
                default_virtcon = 0;
2354 2355 2356
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
2357
                break;
2358
            case QEMU_OPTION_parallel:
G
Gerd Hoffmann 已提交
2359 2360
                add_device_config(DEV_PARALLEL, optarg);
                default_parallel = 0;
2361 2362 2363
                if (strncmp(optarg, "mon:", 4) == 0) {
                    default_monitor = 0;
                }
2364
                break;
2365 2366 2367
            case QEMU_OPTION_debugcon:
                add_device_config(DEV_DEBUGCON, optarg);
                break;
B
bellard 已提交
2368 2369 2370 2371 2372 2373
	    case QEMU_OPTION_loadvm:
		loadvm = optarg;
		break;
            case QEMU_OPTION_full_screen:
                full_screen = 1;
                break;
T
ths 已提交
2374
#ifdef CONFIG_SDL
2375 2376 2377
            case QEMU_OPTION_no_frame:
                no_frame = 1;
                break;
T
ths 已提交
2378 2379 2380
            case QEMU_OPTION_alt_grab:
                alt_grab = 1;
                break;
2381 2382 2383
            case QEMU_OPTION_ctrl_grab:
                ctrl_grab = 1;
                break;
T
ths 已提交
2384 2385 2386
            case QEMU_OPTION_no_quit:
                no_quit = 1;
                break;
2387
            case QEMU_OPTION_sdl:
2388
                display_type = DT_SDL;
2389
                break;
T
ths 已提交
2390
#endif
B
bellard 已提交
2391
            case QEMU_OPTION_pidfile:
2392
                pid_file = optarg;
B
bellard 已提交
2393
                break;
2394 2395 2396
            case QEMU_OPTION_win2k_hack:
                win2k_install_hack = 1;
                break;
2397 2398 2399
            case QEMU_OPTION_rtc_td_hack:
                rtc_td_hack = 1;
                break;
2400
            case QEMU_OPTION_acpitable:
2401
                do_acpitable_option(optarg);
2402
                break;
2403
            case QEMU_OPTION_smbios:
2404
                do_smbios_option(optarg);
2405
                break;
A
aliguori 已提交
2406 2407 2408
            case QEMU_OPTION_enable_kvm:
                kvm_allowed = 1;
                break;
B
bellard 已提交
2409 2410 2411
            case QEMU_OPTION_usb:
                usb_enabled = 1;
                break;
B
bellard 已提交
2412 2413
            case QEMU_OPTION_usbdevice:
                usb_enabled = 1;
2414 2415 2416
                add_device_config(DEV_USB, optarg);
                break;
            case QEMU_OPTION_device:
2417
                if (!qemu_opts_parse(&qemu_device_opts, optarg, 1)) {
G
Gerd Hoffmann 已提交
2418 2419
                    exit(1);
                }
B
bellard 已提交
2420
                break;
B
bellard 已提交
2421
            case QEMU_OPTION_smp:
2422
                smp_parse(optarg);
2423
                if (smp_cpus < 1) {
B
bellard 已提交
2424 2425 2426
                    fprintf(stderr, "Invalid number of CPUs\n");
                    exit(1);
                }
2427 2428 2429 2430 2431 2432 2433 2434 2435
                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 已提交
2436
                break;
B
bellard 已提交
2437
	    case QEMU_OPTION_vnc:
2438
                display_type = DT_VNC;
2439
		vnc_display = optarg;
B
bellard 已提交
2440
		break;
B
bellard 已提交
2441 2442 2443
            case QEMU_OPTION_no_acpi:
                acpi_enabled = 0;
                break;
A
aliguori 已提交
2444 2445 2446
            case QEMU_OPTION_no_hpet:
                no_hpet = 1;
                break;
2447 2448 2449 2450 2451
            case QEMU_OPTION_balloon:
                if (balloon_parse(optarg) < 0) {
                    fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
                    exit(1);
                }
2452
                break;
B
bellard 已提交
2453 2454 2455
            case QEMU_OPTION_no_reboot:
                no_reboot = 1;
                break;
A
aurel32 已提交
2456 2457 2458
            case QEMU_OPTION_no_shutdown:
                no_shutdown = 1;
                break;
2459 2460 2461
            case QEMU_OPTION_show_cursor:
                cursor_hide = 0;
                break;
2462 2463 2464 2465 2466 2467 2468
            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;
2469 2470 2471 2472 2473 2474 2475 2476
	    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;
2477 2478 2479
            case QEMU_OPTION_semihosting:
                semihosting_enabled = 1;
                break;
T
ths 已提交
2480
            case QEMU_OPTION_name:
A
Andi Kleen 已提交
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490
                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;
2491
			os_set_proc_name(p);
A
Andi Kleen 已提交
2492 2493
		     }	
		 }	
T
ths 已提交
2494
                break;
B
blueswir1 已提交
2495 2496 2497 2498 2499 2500 2501 2502
            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;
2503 2504
            case QEMU_OPTION_old_param:
                old_param = 1;
2505
                break;
2506 2507 2508
            case QEMU_OPTION_clock:
                configure_alarms(optarg);
                break;
B
bellard 已提交
2509
            case QEMU_OPTION_startdate:
J
Jan Kiszka 已提交
2510 2511 2512
                configure_rtc_date_offset(optarg, 1);
                break;
            case QEMU_OPTION_rtc:
2513
                opts = qemu_opts_parse(&qemu_rtc_opts, optarg, 0);
J
Jan Kiszka 已提交
2514 2515
                if (!opts) {
                    exit(1);
B
bellard 已提交
2516
                }
J
Jan Kiszka 已提交
2517
                configure_rtc(opts);
B
bellard 已提交
2518
                break;
2519 2520 2521 2522 2523
            case QEMU_OPTION_tb_size:
                tb_size = strtol(optarg, NULL, 0);
                if (tb_size < 0)
                    tb_size = 0;
                break;
P
pbrook 已提交
2524
            case QEMU_OPTION_icount:
P
Paolo Bonzini 已提交
2525
                icount_option = optarg;
P
pbrook 已提交
2526
                break;
A
aliguori 已提交
2527 2528 2529
            case QEMU_OPTION_incoming:
                incoming = optarg;
                break;
2530 2531 2532
            case QEMU_OPTION_nodefaults:
                default_serial = 0;
                default_parallel = 0;
G
Gerd Hoffmann 已提交
2533
                default_virtcon = 0;
2534 2535
                default_monitor = 0;
                default_vga = 0;
G
Gerd Hoffmann 已提交
2536
                default_net = 0;
G
Gerd Hoffmann 已提交
2537 2538 2539
                default_floppy = 0;
                default_cdrom = 0;
                default_sdcard = 0;
2540
                break;
2541
            case QEMU_OPTION_xen_domid:
2542 2543 2544 2545
                if (!(xen_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
2546 2547 2548
                xen_domid = atoi(optarg);
                break;
            case QEMU_OPTION_xen_create:
2549 2550 2551 2552
                if (!(xen_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
2553 2554 2555
                xen_mode = XEN_CREATE;
                break;
            case QEMU_OPTION_xen_attach:
2556 2557 2558 2559
                if (!(xen_available())) {
                    printf("Option %s not supported for this target\n", popt->name);
                    exit(1);
                }
2560 2561
                xen_mode = XEN_ATTACH;
                break;
2562 2563
            case QEMU_OPTION_readconfig:
                {
2564 2565 2566 2567
                    int ret = qemu_read_config_file(optarg);
                    if (ret < 0) {
                        fprintf(stderr, "read config %s: %s\n", optarg,
                            strerror(-ret));
2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587
                        exit(1);
                    }
                    break;
                }
            case QEMU_OPTION_writeconfig:
                {
                    FILE *fp;
                    if (strcmp(optarg, "-") == 0) {
                        fp = stdout;
                    } else {
                        fp = fopen(optarg, "w");
                        if (fp == NULL) {
                            fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
                            exit(1);
                        }
                    }
                    qemu_config_write(fp);
                    fclose(fp);
                    break;
                }
2588 2589
            default:
                os_parse_cmd_args(popt->index, optarg);
2590
            }
2591 2592
        }
    }
2593
    loc_set_none();
2594

P
Paul Brook 已提交
2595 2596 2597
    /* If no data_dir is specified then try to find it relative to the
       executable path.  */
    if (!data_dir) {
2598
        data_dir = os_find_datadir(argv[0]);
P
Paul Brook 已提交
2599 2600 2601
    }
    /* If all else fails use the install patch specified when building.  */
    if (!data_dir) {
2602
        data_dir = CONFIG_QEMU_DATADIR;
P
Paul Brook 已提交
2603 2604
    }

2605 2606 2607 2608 2609 2610 2611
    /*
     * 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 已提交
2612
    machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
2613 2614 2615 2616 2617 2618 2619
    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);
    }

2620
    qemu_opts_foreach(&qemu_device_opts, default_driver_check, NULL, 0);
G
Gerd Hoffmann 已提交
2621
    qemu_opts_foreach(&qemu_global_opts, default_driver_check, NULL, 0);
2622

2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634
    if (machine->no_serial) {
        default_serial = 0;
    }
    if (machine->no_parallel) {
        default_parallel = 0;
    }
    if (!machine->use_virtcon) {
        default_virtcon = 0;
    }
    if (machine->no_vga) {
        default_vga = 0;
    }
G
Gerd Hoffmann 已提交
2635 2636 2637 2638 2639 2640 2641 2642 2643
    if (machine->no_floppy) {
        default_floppy = 0;
    }
    if (machine->no_cdrom) {
        default_cdrom = 0;
    }
    if (machine->no_sdcard) {
        default_sdcard = 0;
    }
2644

2645
    if (display_type == DT_NOGRAPHIC) {
G
Gerd Hoffmann 已提交
2646 2647
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "null");
G
Gerd Hoffmann 已提交
2648 2649
        if (default_serial && default_monitor) {
            add_device_config(DEV_SERIAL, "mon:stdio");
2650 2651
        } else if (default_virtcon && default_monitor) {
            add_device_config(DEV_VIRTCON, "mon:stdio");
G
Gerd Hoffmann 已提交
2652 2653 2654
        } else {
            if (default_serial)
                add_device_config(DEV_SERIAL, "stdio");
2655 2656
            if (default_virtcon)
                add_device_config(DEV_VIRTCON, "stdio");
G
Gerd Hoffmann 已提交
2657
            if (default_monitor)
G
Gerd Hoffmann 已提交
2658
                monitor_parse("stdio", "readline");
G
Gerd Hoffmann 已提交
2659
        }
2660 2661 2662
    } else {
        if (default_serial)
            add_device_config(DEV_SERIAL, "vc:80Cx24C");
G
Gerd Hoffmann 已提交
2663 2664
        if (default_parallel)
            add_device_config(DEV_PARALLEL, "vc:80Cx24C");
G
Gerd Hoffmann 已提交
2665
        if (default_monitor)
G
Gerd Hoffmann 已提交
2666
            monitor_parse("vc:80Cx24C", "readline");
2667 2668
        if (default_virtcon)
            add_device_config(DEV_VIRTCON, "vc:80Cx24C");
2669
    }
G
Gerd Hoffmann 已提交
2670 2671
    if (default_vga)
        vga_interface_type = VGA_CIRRUS;
2672

T
TeLeMan 已提交
2673 2674
    socket_init();

2675 2676
    if (qemu_opts_foreach(&qemu_chardev_opts, chardev_init_func, NULL, 1) != 0)
        exit(1);
2677 2678 2679 2680 2681
#ifdef CONFIG_LINUX
    if (qemu_opts_foreach(&qemu_fsdev_opts, fsdev_init_func, NULL, 1) != 0) {
        exit(1);
    }
#endif
2682

2683
    os_daemonize();
T
ths 已提交
2684

2685
    if (pid_file && qemu_create_pidfile(pid_file) != 0) {
2686
        os_pidfile_error();
2687 2688 2689
        exit(1);
    }

2690 2691
    if (kvm_allowed) {
        int ret = kvm_init(smp_cpus);
M
Marcelo Tosatti 已提交
2692
        if (ret < 0) {
2693 2694 2695 2696 2697
            if (!kvm_available()) {
                printf("KVM not supported for this target\n");
            } else {
                fprintf(stderr, "failed to initialize KVM: %s\n", strerror(-ret));
            }
M
Marcelo Tosatti 已提交
2698 2699 2700 2701
            exit(1);
        }
    }

2702 2703 2704 2705
    if (qemu_init_main_loop()) {
        fprintf(stderr, "qemu_init_main_loop failed\n");
        exit(1);
    }
2706
    linux_boot = (kernel_filename != NULL);
B
balrog 已提交
2707

2708 2709 2710 2711 2712 2713 2714 2715 2716 2717
    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);
    }

2718
    os_set_line_buffering();
2719

2720 2721 2722 2723
    if (init_timer_alarm() < 0) {
        fprintf(stderr, "could not initialize alarm timer\n");
        exit(1);
    }
P
Paolo Bonzini 已提交
2724
    configure_icount(icount_option);
2725

2726 2727
    if (net_init_clients() < 0) {
        exit(1);
B
bellard 已提交
2728
    }
B
bellard 已提交
2729

2730
    /* init the bluetooth world */
2731 2732
    if (foreach_device_config(DEV_BT, bt_parse))
        exit(1);
2733

2734
    /* init the memory */
P
pbrook 已提交
2735 2736
    if (ram_size == 0)
        ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
2737

2738 2739 2740
    /* init the dynamic translator */
    cpu_exec_init_all(tb_size * 1024 * 1024);

2741
    bdrv_init_with_whitelist();
2742

L
lirans@il.ibm.com 已提交
2743 2744
    blk_mig_init();

G
Gerd Hoffmann 已提交
2745
    if (default_cdrom) {
G
Gerd Hoffmann 已提交
2746 2747
        /* we always create the cdrom drive, even if no disk is there */
        drive_add(NULL, CDROM_ALIAS);
G
Gerd Hoffmann 已提交
2748
    }
2749

G
Gerd Hoffmann 已提交
2750
    if (default_floppy) {
G
Gerd Hoffmann 已提交
2751 2752
        /* we always create at least one floppy */
        drive_add(NULL, FD_ALIAS, 0);
G
Gerd Hoffmann 已提交
2753
    }
2754

G
Gerd Hoffmann 已提交
2755
    if (default_sdcard) {
G
Gerd Hoffmann 已提交
2756 2757 2758
        /* we always create one sd slot, even if no card is in it */
        drive_add(NULL, SD_ALIAS);
    }
2759

T
ths 已提交
2760
    /* open the virtual block devices */
G
Gerd Hoffmann 已提交
2761
    if (snapshot)
G
Gerd Hoffmann 已提交
2762
        qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
2763
    if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, &machine->use_scsi, 1) != 0)
G
Gerd Hoffmann 已提交
2764
        exit(1);
2765

L
lirans@il.ibm.com 已提交
2766 2767
    register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL, 
                         ram_load, NULL);
2768

2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810
    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;
            }
        }
    }

2811 2812 2813 2814
    if (qemu_opts_foreach(&qemu_mon_opts, mon_init_func, NULL, 1) != 0) {
        exit(1);
    }

2815 2816
    if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
        exit(1);
G
Gerd Hoffmann 已提交
2817 2818
    if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
        exit(1);
G
Gerd Hoffmann 已提交
2819 2820
    if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
        exit(1);
2821 2822
    if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
        exit(1);
2823

P
Paul Brook 已提交
2824 2825
    module_call_init(MODULE_INIT_DEVICE);

2826 2827 2828
    if (qemu_opts_foreach(&qemu_device_opts, device_help_func, NULL, 0) != 0)
        exit(0);

M
Markus Armbruster 已提交
2829 2830 2831 2832 2833 2834
    if (watchdog) {
        i = select_watchdog(watchdog);
        if (i > 0)
            exit (i == 1 ? 1 : 0);
    }

2835
    if (machine->compat_props) {
2836
        qdev_prop_register_global_list(machine->compat_props);
2837
    }
2838 2839
    qemu_add_globals();

P
Paul Brook 已提交
2840
    machine->init(ram_size, boot_devices,
2841 2842
                  kernel_filename, kernel_cmdline, initrd_filename, cpu_model);

2843
    cpu_synchronize_all_post_init();
2844

J
Juan Quintela 已提交
2845
    /* must be after terminal init, SDL library changes signal handlers */
2846
    os_setup_signal_handling();
J
Juan Quintela 已提交
2847

B
Blue Swirl 已提交
2848
    set_numa_modes();
2849

2850 2851
    current_machine = machine;

2852 2853
    /* init USB devices */
    if (usb_enabled) {
M
Markus Armbruster 已提交
2854 2855
        if (foreach_device_config(DEV_USB, usb_parse) < 0)
            exit(1);
2856 2857
    }

2858
    /* init generic devices */
G
Gerd Hoffmann 已提交
2859
    if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
2860 2861
        exit(1);

2862 2863
    net_check_clients();

2864
    /* just use the first displaystate for the moment */
2865
    ds = get_displaystate();
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880

    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 已提交
2881
#if defined(CONFIG_CURSES)
2882 2883 2884
    case DT_CURSES:
        curses_display_init(ds, full_screen);
        break;
B
balrog 已提交
2885
#endif
2886
#if defined(CONFIG_SDL)
2887 2888 2889
    case DT_SDL:
        sdl_display_init(ds, full_screen, no_frame);
        break;
2890
#elif defined(CONFIG_COCOA)
2891 2892 2893
    case DT_SDL:
        cocoa_display_init(ds, full_screen);
        break;
2894
#endif
2895 2896 2897 2898
    case DT_VNC:
        vnc_display_init(ds);
        if (vnc_display_open(ds, vnc_display) < 0)
            exit(1);
2899

2900 2901
        if (show_vnc_port) {
            printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
2902
        }
2903 2904 2905
        break;
    default:
        break;
2906
    }
2907
    dpy_resize(ds);
2908

2909 2910 2911 2912 2913
    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));
2914
            break;
T
ths 已提交
2915
        }
2916
        dcl = dcl->next;
T
ths 已提交
2917
    }
2918

2919
    if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
B
blueswir1 已提交
2920 2921 2922 2923
        nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
        qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
    }

2924
    text_consoles_set_display(ds);
2925

2926 2927 2928 2929
    if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
        fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
                gdbstub_dev);
        exit(1);
2930 2931
    }

2932 2933
    qdev_machine_creation_done();

G
Gerd Hoffmann 已提交
2934 2935 2936 2937
    if (rom_load_all() != 0) {
        fprintf(stderr, "rom loading failed\n");
        exit(1);
    }
2938

2939
    qemu_system_reset();
2940
    if (loadvm) {
2941
        if (load_vmstate(loadvm) < 0) {
2942 2943 2944
            autostart = 0;
        }
    }
B
bellard 已提交
2945

G
Glauber Costa 已提交
2946
    if (incoming) {
A
aliguori 已提交
2947
        qemu_start_incoming_migration(incoming);
2948
    } else if (autostart) {
2949
        vm_start();
2950
    }
2951

2952
    os_setup_post();
T
ths 已提交
2953

2954
    main_loop();
B
bellard 已提交
2955
    quit_timers();
2956
    net_cleanup();
T
ths 已提交
2957

2958 2959
    return 0;
}