Statistics
| Branch: | Revision:

root / vl.c @ a803cb8e

History | View | Annotate | Download (105.2 kB)

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

    
32
/* Needed early for CONFIG_BSD etc. */
33
#include "config-host.h"
34

    
35
#ifndef _WIN32
36
#include <libgen.h>
37
#include <pwd.h>
38
#include <sys/times.h>
39
#include <sys/wait.h>
40
#include <termios.h>
41
#include <sys/mman.h>
42
#include <sys/ioctl.h>
43
#include <sys/resource.h>
44
#include <sys/socket.h>
45
#include <netinet/in.h>
46
#include <net/if.h>
47
#include <arpa/inet.h>
48
#include <dirent.h>
49
#include <netdb.h>
50
#include <sys/select.h>
51
#ifdef CONFIG_BSD
52
#include <sys/stat.h>
53
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
54
#include <libutil.h>
55
#include <sys/sysctl.h>
56
#else
57
#include <util.h>
58
#endif
59
#else
60
#ifdef __linux__
61
#include <pty.h>
62
#include <malloc.h>
63
#include <sys/prctl.h>
64

    
65
#include <linux/ppdev.h>
66
#include <linux/parport.h>
67
#endif
68
#ifdef __sun__
69
#include <sys/stat.h>
70
#include <sys/ethernet.h>
71
#include <sys/sockio.h>
72
#include <netinet/arp.h>
73
#include <netinet/in.h>
74
#include <netinet/in_systm.h>
75
#include <netinet/ip.h>
76
#include <netinet/ip_icmp.h> // must come after ip.h
77
#include <netinet/udp.h>
78
#include <netinet/tcp.h>
79
#include <net/if.h>
80
#include <syslog.h>
81
#include <stropts.h>
82
/* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
83
   discussion about Solaris header problems */
84
extern int madvise(caddr_t, size_t, int);
85
#endif
86
#endif
87
#endif
88

    
89
#if defined(__OpenBSD__)
90
#include <util.h>
91
#endif
92

    
93
#if defined(CONFIG_VDE)
94
#include <libvdeplug.h>
95
#endif
96

    
97
#ifdef _WIN32
98
#include <windows.h>
99
#endif
100

    
101
#ifdef CONFIG_SDL
102
#if defined(__APPLE__) || defined(main)
103
#include <SDL.h>
104
int qemu_main(int argc, char **argv, char **envp);
105
int main(int argc, char **argv)
106
{
107
    return qemu_main(argc, argv, NULL);
108
}
109
#undef main
110
#define main qemu_main
111
#endif
112
#endif /* CONFIG_SDL */
113

    
114
#ifdef CONFIG_COCOA
115
#undef main
116
#define main qemu_main
117
#endif /* CONFIG_COCOA */
118

    
119
#include "hw/hw.h"
120
#include "hw/boards.h"
121
#include "hw/usb.h"
122
#include "hw/pcmcia.h"
123
#include "hw/pc.h"
124
#include "hw/isa.h"
125
#include "hw/baum.h"
126
#include "hw/bt.h"
127
#include "hw/watchdog.h"
128
#include "hw/smbios.h"
129
#include "hw/xen.h"
130
#include "hw/qdev.h"
131
#include "hw/loader.h"
132
#include "bt-host.h"
133
#include "net.h"
134
#include "net/slirp.h"
135
#include "monitor.h"
136
#include "console.h"
137
#include "sysemu.h"
138
#include "gdbstub.h"
139
#include "qemu-timer.h"
140
#include "qemu-char.h"
141
#include "cache-utils.h"
142
#include "block.h"
143
#include "block_int.h"
144
#include "block-migration.h"
145
#include "dma.h"
146
#include "audio/audio.h"
147
#include "migration.h"
148
#include "kvm.h"
149
#include "qemu-option.h"
150
#include "qemu-config.h"
151
#include "qemu-objects.h"
152
#ifdef CONFIG_LINUX
153
#include "fsdev/qemu-fsdev.h"
154
#endif
155

    
156
#include "disas.h"
157

    
158
#include "qemu_socket.h"
159

    
160
#include "slirp/libslirp.h"
161

    
162
#include "qemu-queue.h"
163
#include "cpus.h"
164
#include "arch_init.h"
165

    
166
//#define DEBUG_NET
167
//#define DEBUG_SLIRP
168

    
169
#define DEFAULT_RAM_SIZE 128
170

    
171
#define MAX_VIRTIO_CONSOLES 1
172

    
173
static const char *data_dir;
174
const char *bios_name = NULL;
175
struct drivelist drives = QTAILQ_HEAD_INITIALIZER(drives);
176
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
177
DisplayType display_type = DT_DEFAULT;
178
const char* keyboard_layout = NULL;
179
ram_addr_t ram_size;
180
const char *mem_path = NULL;
181
#ifdef MAP_POPULATE
182
int mem_prealloc = 0; /* force preallocation of physical target memory */
183
#endif
184
int nb_nics;
185
NICInfo nd_table[MAX_NICS];
186
int vm_running;
187
int autostart;
188
static int rtc_utc = 1;
189
static int rtc_date_offset = -1; /* -1 means no change */
190
QEMUClock *rtc_clock;
191
int vga_interface_type = VGA_NONE;
192
static int full_screen = 0;
193
#ifdef CONFIG_SDL
194
static int no_frame = 0;
195
#endif
196
int no_quit = 0;
197
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
198
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
199
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
200
int win2k_install_hack = 0;
201
int rtc_td_hack = 0;
202
int usb_enabled = 0;
203
int singlestep = 0;
204
int smp_cpus = 1;
205
int max_cpus = 0;
206
int smp_cores = 1;
207
int smp_threads = 1;
208
const char *vnc_display;
209
int acpi_enabled = 1;
210
int no_hpet = 0;
211
int fd_bootchk = 1;
212
int no_reboot = 0;
213
int no_shutdown = 0;
214
int cursor_hide = 1;
215
int graphic_rotate = 0;
216
uint8_t irq0override = 1;
217
#ifndef _WIN32
218
int daemonize = 0;
219
#endif
220
const char *watchdog;
221
const char *option_rom[MAX_OPTION_ROMS];
222
int nb_option_roms;
223
int semihosting_enabled = 0;
224
int old_param = 0;
225
const char *qemu_name;
226
int alt_grab = 0;
227
int ctrl_grab = 0;
228
unsigned int nb_prom_envs = 0;
229
const char *prom_envs[MAX_PROM_ENVS];
230
int boot_menu;
231

    
232
int nb_numa_nodes;
233
uint64_t node_mem[MAX_NODES];
234
uint64_t node_cpumask[MAX_NODES];
235

    
236
static QEMUTimer *nographic_timer;
237

    
238
uint8_t qemu_uuid[16];
239

    
240
static QEMUBootSetHandler *boot_set_handler;
241
static void *boot_set_opaque;
242

    
243
int kvm_allowed = 0;
244
uint32_t xen_domid;
245
enum xen_mode xen_mode = XEN_EMULATE;
246

    
247
static int default_serial = 1;
248
static int default_parallel = 1;
249
static int default_virtcon = 1;
250
static int default_monitor = 1;
251
static int default_vga = 1;
252
static int default_floppy = 1;
253
static int default_cdrom = 1;
254
static int default_sdcard = 1;
255

    
256
static struct {
257
    const char *driver;
258
    int *flag;
259
} default_list[] = {
260
    { .driver = "isa-serial",           .flag = &default_serial    },
261
    { .driver = "isa-parallel",         .flag = &default_parallel  },
262
    { .driver = "isa-fdc",              .flag = &default_floppy    },
263
    { .driver = "ide-drive",            .flag = &default_cdrom     },
264
    { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
265
    { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },
266
    { .driver = "virtio-serial",        .flag = &default_virtcon   },
267
    { .driver = "VGA",                  .flag = &default_vga       },
268
    { .driver = "cirrus-vga",           .flag = &default_vga       },
269
    { .driver = "vmware-svga",          .flag = &default_vga       },
270
};
271

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

    
277
    if (!driver)
278
        return 0;
279
    for (i = 0; i < ARRAY_SIZE(default_list); i++) {
280
        if (strcmp(default_list[i].driver, driver) != 0)
281
            continue;
282
        *(default_list[i].flag) = 0;
283
    }
284
    return 0;
285
}
286

    
287
/***********************************************************/
288

    
289
static void set_proc_name(const char *s)
290
{
291
#if defined(__linux__) && defined(PR_SET_NAME)
292
    char name[16];
293
    if (!s)
294
        return;
295
    name[sizeof(name) - 1] = 0;
296
    strncpy(name, s, sizeof(name));
297
    /* Could rewrite argv[0] too, but that's a bit more complicated.
298
       This simple way is enough for `top'. */
299
    prctl(PR_SET_NAME, name);
300
#endif            
301
}
302
 
303
/***********************************************************/
304
/* real time host monotonic timer */
305

    
306
/* compute with 96 bit intermediate result: (a*b)/c */
307
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
308
{
309
    union {
310
        uint64_t ll;
311
        struct {
312
#ifdef HOST_WORDS_BIGENDIAN
313
            uint32_t high, low;
314
#else
315
            uint32_t low, high;
316
#endif
317
        } l;
318
    } u, res;
319
    uint64_t rl, rh;
320

    
321
    u.ll = a;
322
    rl = (uint64_t)u.l.low * (uint64_t)b;
323
    rh = (uint64_t)u.l.high * (uint64_t)b;
324
    rh += (rl >> 32);
325
    res.l.high = rh / c;
326
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
327
    return res.ll;
328
}
329

    
330
/***********************************************************/
331
/* host time/date access */
332
void qemu_get_timedate(struct tm *tm, int offset)
333
{
334
    time_t ti;
335
    struct tm *ret;
336

    
337
    time(&ti);
338
    ti += offset;
339
    if (rtc_date_offset == -1) {
340
        if (rtc_utc)
341
            ret = gmtime(&ti);
342
        else
343
            ret = localtime(&ti);
344
    } else {
345
        ti -= rtc_date_offset;
346
        ret = gmtime(&ti);
347
    }
348

    
349
    memcpy(tm, ret, sizeof(struct tm));
350
}
351

    
352
int qemu_timedate_diff(struct tm *tm)
353
{
354
    time_t seconds;
355

    
356
    if (rtc_date_offset == -1)
357
        if (rtc_utc)
358
            seconds = mktimegm(tm);
359
        else
360
            seconds = mktime(tm);
361
    else
362
        seconds = mktimegm(tm) + rtc_date_offset;
363

    
364
    return seconds - time(NULL);
365
}
366

    
367
void rtc_change_mon_event(struct tm *tm)
368
{
369
    QObject *data;
370

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

    
376
static void configure_rtc_date_offset(const char *startdate, int legacy)
377
{
378
    time_t rtc_start_date;
379
    struct tm tm;
380

    
381
    if (!strcmp(startdate, "now") && legacy) {
382
        rtc_date_offset = -1;
383
    } else {
384
        if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
385
                   &tm.tm_year,
386
                   &tm.tm_mon,
387
                   &tm.tm_mday,
388
                   &tm.tm_hour,
389
                   &tm.tm_min,
390
                   &tm.tm_sec) == 6) {
391
            /* OK */
392
        } else if (sscanf(startdate, "%d-%d-%d",
393
                          &tm.tm_year,
394
                          &tm.tm_mon,
395
                          &tm.tm_mday) == 3) {
396
            tm.tm_hour = 0;
397
            tm.tm_min = 0;
398
            tm.tm_sec = 0;
399
        } else {
400
            goto date_fail;
401
        }
402
        tm.tm_year -= 1900;
403
        tm.tm_mon--;
404
        rtc_start_date = mktimegm(&tm);
405
        if (rtc_start_date == -1) {
406
        date_fail:
407
            fprintf(stderr, "Invalid date format. Valid formats are:\n"
408
                            "'2006-06-17T16:01:21' or '2006-06-17'\n");
409
            exit(1);
410
        }
411
        rtc_date_offset = time(NULL) - rtc_start_date;
412
    }
413
}
414

    
415
static void configure_rtc(QemuOpts *opts)
416
{
417
    const char *value;
418

    
419
    value = qemu_opt_get(opts, "base");
420
    if (value) {
421
        if (!strcmp(value, "utc")) {
422
            rtc_utc = 1;
423
        } else if (!strcmp(value, "localtime")) {
424
            rtc_utc = 0;
425
        } else {
426
            configure_rtc_date_offset(value, 0);
427
        }
428
    }
429
    value = qemu_opt_get(opts, "clock");
430
    if (value) {
431
        if (!strcmp(value, "host")) {
432
            rtc_clock = host_clock;
433
        } else if (!strcmp(value, "vm")) {
434
            rtc_clock = vm_clock;
435
        } else {
436
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
437
            exit(1);
438
        }
439
    }
440
    value = qemu_opt_get(opts, "driftfix");
441
    if (value) {
442
        if (!strcmp(value, "slew")) {
443
            rtc_td_hack = 1;
444
        } else if (!strcmp(value, "none")) {
445
            rtc_td_hack = 0;
446
        } else {
447
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
448
            exit(1);
449
        }
450
    }
451
}
452

    
453
/***********************************************************/
454
/* Bluetooth support */
455
static int nb_hcis;
456
static int cur_hci;
457
static struct HCIInfo *hci_table[MAX_NICS];
458

    
459
static struct bt_vlan_s {
460
    struct bt_scatternet_s net;
461
    int id;
462
    struct bt_vlan_s *next;
463
} *first_bt_vlan;
464

    
465
/* find or alloc a new bluetooth "VLAN" */
466
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
467
{
468
    struct bt_vlan_s **pvlan, *vlan;
469
    for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
470
        if (vlan->id == id)
471
            return &vlan->net;
472
    }
473
    vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
474
    vlan->id = id;
475
    pvlan = &first_bt_vlan;
476
    while (*pvlan != NULL)
477
        pvlan = &(*pvlan)->next;
478
    *pvlan = vlan;
479
    return &vlan->net;
480
}
481

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

    
486
static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
487
{
488
    return -ENOTSUP;
489
}
490

    
491
static struct HCIInfo null_hci = {
492
    .cmd_send = null_hci_send,
493
    .sco_send = null_hci_send,
494
    .acl_send = null_hci_send,
495
    .bdaddr_set = null_hci_addr_set,
496
};
497

    
498
struct HCIInfo *qemu_next_hci(void)
499
{
500
    if (cur_hci == nb_hcis)
501
        return &null_hci;
502

    
503
    return hci_table[cur_hci++];
504
}
505

    
506
static struct HCIInfo *hci_init(const char *str)
507
{
508
    char *endp;
509
    struct bt_scatternet_s *vlan = 0;
510

    
511
    if (!strcmp(str, "null"))
512
        /* null */
513
        return &null_hci;
514
    else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
515
        /* host[:hciN] */
516
        return bt_host_hci(str[4] ? str + 5 : "hci0");
517
    else if (!strncmp(str, "hci", 3)) {
518
        /* hci[,vlan=n] */
519
        if (str[3]) {
520
            if (!strncmp(str + 3, ",vlan=", 6)) {
521
                vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
522
                if (*endp)
523
                    vlan = 0;
524
            }
525
        } else
526
            vlan = qemu_find_bt_vlan(0);
527
        if (vlan)
528
           return bt_new_hci(vlan);
529
    }
530

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

    
533
    return 0;
534
}
535

    
536
static int bt_hci_parse(const char *str)
537
{
538
    struct HCIInfo *hci;
539
    bdaddr_t bdaddr;
540

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

    
546
    hci = hci_init(str);
547
    if (!hci)
548
        return -1;
549

    
550
    bdaddr.b[0] = 0x52;
551
    bdaddr.b[1] = 0x54;
552
    bdaddr.b[2] = 0x00;
553
    bdaddr.b[3] = 0x12;
554
    bdaddr.b[4] = 0x34;
555
    bdaddr.b[5] = 0x56 + nb_hcis;
556
    hci->bdaddr_set(hci, bdaddr.b);
557

    
558
    hci_table[nb_hcis++] = hci;
559

    
560
    return 0;
561
}
562

    
563
static void bt_vhci_add(int vlan_id)
564
{
565
    struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
566

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

    
571
    bt_vhci_init(bt_new_hci(vlan));
572
}
573

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

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

    
584
    if (endp) {
585
        vlan_id = strtol(endp + 6, &endp, 0);
586
        if (*endp) {
587
            fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
588
            return 0;
589
        }
590
    }
591

    
592
    vlan = qemu_find_bt_vlan(vlan_id);
593

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

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

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

    
605
static int bt_parse(const char *opt)
606
{
607
    const char *endp, *p;
608
    int vlan;
609

    
610
    if (strstart(opt, "hci", &endp)) {
611
        if (!*endp || *endp == ',') {
612
            if (*endp)
613
                if (!strstart(endp, ",vlan=", 0))
614
                    opt = endp + 1;
615

    
616
            return bt_hci_parse(opt);
617
       }
618
    } else if (strstart(opt, "vhci", &endp)) {
619
        if (!*endp || *endp == ',') {
620
            if (*endp) {
621
                if (strstart(endp, ",vlan=", &p)) {
622
                    vlan = strtol(p, (char **) &endp, 0);
623
                    if (*endp) {
624
                        fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
625
                        return 1;
626
                    }
627
                } else {
628
                    fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
629
                    return 1;
630
                }
631
            } else
632
                vlan = 0;
633

    
634
            bt_vhci_add(vlan);
635
            return 0;
636
        }
637
    } else if (strstart(opt, "device:", &endp))
638
        return !bt_device_add(endp);
639

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

    
644
/***********************************************************/
645
/* QEMU Block devices */
646

    
647
#define HD_ALIAS "index=%d,media=disk"
648
#define CDROM_ALIAS "index=2,media=cdrom"
649
#define FD_ALIAS "index=%d,if=floppy"
650
#define PFLASH_ALIAS "if=pflash"
651
#define MTD_ALIAS "if=mtd"
652
#define SD_ALIAS "index=0,if=sd"
653

    
654
QemuOpts *drive_add(const char *file, const char *fmt, ...)
655
{
656
    va_list ap;
657
    char optstr[1024];
658
    QemuOpts *opts;
659

    
660
    va_start(ap, fmt);
661
    vsnprintf(optstr, sizeof(optstr), fmt, ap);
662
    va_end(ap);
663

    
664
    opts = qemu_opts_parse(&qemu_drive_opts, optstr, 0);
665
    if (!opts) {
666
        return NULL;
667
    }
668
    if (file)
669
        qemu_opt_set(opts, "file", file);
670
    return opts;
671
}
672

    
673
DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
674
{
675
    DriveInfo *dinfo;
676

    
677
    /* seek interface, bus and unit */
678

    
679
    QTAILQ_FOREACH(dinfo, &drives, next) {
680
        if (dinfo->type == type &&
681
            dinfo->bus == bus &&
682
            dinfo->unit == unit)
683
            return dinfo;
684
    }
685

    
686
    return NULL;
687
}
688

    
689
DriveInfo *drive_get_by_id(const char *id)
690
{
691
    DriveInfo *dinfo;
692

    
693
    QTAILQ_FOREACH(dinfo, &drives, next) {
694
        if (strcmp(id, dinfo->id))
695
            continue;
696
        return dinfo;
697
    }
698
    return NULL;
699
}
700

    
701
int drive_get_max_bus(BlockInterfaceType type)
702
{
703
    int max_bus;
704
    DriveInfo *dinfo;
705

    
706
    max_bus = -1;
707
    QTAILQ_FOREACH(dinfo, &drives, next) {
708
        if(dinfo->type == type &&
709
           dinfo->bus > max_bus)
710
            max_bus = dinfo->bus;
711
    }
712
    return max_bus;
713
}
714

    
715
const char *drive_get_serial(BlockDriverState *bdrv)
716
{
717
    DriveInfo *dinfo;
718

    
719
    QTAILQ_FOREACH(dinfo, &drives, next) {
720
        if (dinfo->bdrv == bdrv)
721
            return dinfo->serial;
722
    }
723

    
724
    return "\0";
725
}
726

    
727
BlockInterfaceErrorAction drive_get_on_error(
728
    BlockDriverState *bdrv, int is_read)
729
{
730
    DriveInfo *dinfo;
731

    
732
    QTAILQ_FOREACH(dinfo, &drives, next) {
733
        if (dinfo->bdrv == bdrv)
734
            return is_read ? dinfo->on_read_error : dinfo->on_write_error;
735
    }
736

    
737
    return is_read ? BLOCK_ERR_REPORT : BLOCK_ERR_STOP_ENOSPC;
738
}
739

    
740
static void bdrv_format_print(void *opaque, const char *name)
741
{
742
    fprintf(stderr, " %s", name);
743
}
744

    
745
void drive_uninit(DriveInfo *dinfo)
746
{
747
    qemu_opts_del(dinfo->opts);
748
    bdrv_delete(dinfo->bdrv);
749
    QTAILQ_REMOVE(&drives, dinfo, next);
750
    qemu_free(dinfo);
751
}
752

    
753
static int parse_block_error_action(const char *buf, int is_read)
754
{
755
    if (!strcmp(buf, "ignore")) {
756
        return BLOCK_ERR_IGNORE;
757
    } else if (!is_read && !strcmp(buf, "enospc")) {
758
        return BLOCK_ERR_STOP_ENOSPC;
759
    } else if (!strcmp(buf, "stop")) {
760
        return BLOCK_ERR_STOP_ANY;
761
    } else if (!strcmp(buf, "report")) {
762
        return BLOCK_ERR_REPORT;
763
    } else {
764
        fprintf(stderr, "qemu: '%s' invalid %s error action\n",
765
            buf, is_read ? "read" : "write");
766
        return -1;
767
    }
768
}
769

    
770
DriveInfo *drive_init(QemuOpts *opts, int default_to_scsi, int *fatal_error)
771
{
772
    const char *buf;
773
    const char *file = NULL;
774
    char devname[128];
775
    const char *serial;
776
    const char *mediastr = "";
777
    BlockInterfaceType type;
778
    enum { MEDIA_DISK, MEDIA_CDROM } media;
779
    int bus_id, unit_id;
780
    int cyls, heads, secs, translation;
781
    BlockDriver *drv = NULL;
782
    int max_devs;
783
    int index;
784
    int ro = 0;
785
    int bdrv_flags = 0;
786
    int on_read_error, on_write_error;
787
    const char *devaddr;
788
    DriveInfo *dinfo;
789
    int snapshot = 0;
790
    int ret;
791

    
792
    *fatal_error = 1;
793

    
794
    translation = BIOS_ATA_TRANSLATION_AUTO;
795

    
796
    if (default_to_scsi) {
797
        type = IF_SCSI;
798
        max_devs = MAX_SCSI_DEVS;
799
        pstrcpy(devname, sizeof(devname), "scsi");
800
    } else {
801
        type = IF_IDE;
802
        max_devs = MAX_IDE_DEVS;
803
        pstrcpy(devname, sizeof(devname), "ide");
804
    }
805
    media = MEDIA_DISK;
806

    
807
    /* extract parameters */
808
    bus_id  = qemu_opt_get_number(opts, "bus", 0);
809
    unit_id = qemu_opt_get_number(opts, "unit", -1);
810
    index   = qemu_opt_get_number(opts, "index", -1);
811

    
812
    cyls  = qemu_opt_get_number(opts, "cyls", 0);
813
    heads = qemu_opt_get_number(opts, "heads", 0);
814
    secs  = qemu_opt_get_number(opts, "secs", 0);
815

    
816
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
817
    ro = qemu_opt_get_bool(opts, "readonly", 0);
818

    
819
    file = qemu_opt_get(opts, "file");
820
    serial = qemu_opt_get(opts, "serial");
821

    
822
    if ((buf = qemu_opt_get(opts, "if")) != NULL) {
823
        pstrcpy(devname, sizeof(devname), buf);
824
        if (!strcmp(buf, "ide")) {
825
            type = IF_IDE;
826
            max_devs = MAX_IDE_DEVS;
827
        } else if (!strcmp(buf, "scsi")) {
828
            type = IF_SCSI;
829
            max_devs = MAX_SCSI_DEVS;
830
        } else if (!strcmp(buf, "floppy")) {
831
            type = IF_FLOPPY;
832
            max_devs = 0;
833
        } else if (!strcmp(buf, "pflash")) {
834
            type = IF_PFLASH;
835
            max_devs = 0;
836
        } else if (!strcmp(buf, "mtd")) {
837
            type = IF_MTD;
838
            max_devs = 0;
839
        } else if (!strcmp(buf, "sd")) {
840
            type = IF_SD;
841
            max_devs = 0;
842
        } else if (!strcmp(buf, "virtio")) {
843
            type = IF_VIRTIO;
844
            max_devs = 0;
845
        } else if (!strcmp(buf, "xen")) {
846
            type = IF_XEN;
847
            max_devs = 0;
848
        } else if (!strcmp(buf, "none")) {
849
            type = IF_NONE;
850
            max_devs = 0;
851
        } else {
852
            fprintf(stderr, "qemu: unsupported bus type '%s'\n", buf);
853
            return NULL;
854
        }
855
    }
856

    
857
    if (cyls || heads || secs) {
858
        if (cyls < 1 || (type == IF_IDE && cyls > 16383)) {
859
            fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
860
            return NULL;
861
        }
862
        if (heads < 1 || (type == IF_IDE && heads > 16)) {
863
            fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
864
            return NULL;
865
        }
866
        if (secs < 1 || (type == IF_IDE && secs > 63)) {
867
            fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
868
            return NULL;
869
        }
870
    }
871

    
872
    if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
873
        if (!cyls) {
874
            fprintf(stderr,
875
                    "qemu: '%s' trans must be used with cyls,heads and secs\n",
876
                    buf);
877
            return NULL;
878
        }
879
        if (!strcmp(buf, "none"))
880
            translation = BIOS_ATA_TRANSLATION_NONE;
881
        else if (!strcmp(buf, "lba"))
882
            translation = BIOS_ATA_TRANSLATION_LBA;
883
        else if (!strcmp(buf, "auto"))
884
            translation = BIOS_ATA_TRANSLATION_AUTO;
885
        else {
886
            fprintf(stderr, "qemu: '%s' invalid translation type\n", buf);
887
            return NULL;
888
        }
889
    }
890

    
891
    if ((buf = qemu_opt_get(opts, "media")) != NULL) {
892
        if (!strcmp(buf, "disk")) {
893
            media = MEDIA_DISK;
894
        } else if (!strcmp(buf, "cdrom")) {
895
            if (cyls || secs || heads) {
896
                fprintf(stderr,
897
                        "qemu: '%s' invalid physical CHS format\n", buf);
898
                return NULL;
899
            }
900
            media = MEDIA_CDROM;
901
        } else {
902
            fprintf(stderr, "qemu: '%s' invalid media\n", buf);
903
            return NULL;
904
        }
905
    }
906

    
907
    if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
908
        if (!strcmp(buf, "off") || !strcmp(buf, "none")) {
909
            bdrv_flags |= BDRV_O_NOCACHE;
910
        } else if (!strcmp(buf, "writeback")) {
911
            bdrv_flags |= BDRV_O_CACHE_WB;
912
        } else if (!strcmp(buf, "unsafe")) {
913
            bdrv_flags |= BDRV_O_CACHE_WB;
914
            bdrv_flags |= BDRV_O_NO_FLUSH;
915
        } else if (!strcmp(buf, "writethrough")) {
916
            /* this is the default */
917
        } else {
918
           fprintf(stderr, "qemu: invalid cache option\n");
919
           return NULL;
920
        }
921
    }
922

    
923
#ifdef CONFIG_LINUX_AIO
924
    if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
925
        if (!strcmp(buf, "native")) {
926
            bdrv_flags |= BDRV_O_NATIVE_AIO;
927
        } else if (!strcmp(buf, "threads")) {
928
            /* this is the default */
929
        } else {
930
           fprintf(stderr, "qemu: invalid aio option\n");
931
           return NULL;
932
        }
933
    }
934
#endif
935

    
936
    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
937
       if (strcmp(buf, "?") == 0) {
938
            fprintf(stderr, "qemu: Supported formats:");
939
            bdrv_iterate_format(bdrv_format_print, NULL);
940
            fprintf(stderr, "\n");
941
            return NULL;
942
        }
943
        drv = bdrv_find_whitelisted_format(buf);
944
        if (!drv) {
945
            fprintf(stderr, "qemu: '%s' invalid format\n", buf);
946
            return NULL;
947
        }
948
    }
949

    
950
    on_write_error = BLOCK_ERR_STOP_ENOSPC;
951
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
952
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && type != IF_NONE) {
953
            fprintf(stderr, "werror is no supported by this format\n");
954
            return NULL;
955
        }
956

    
957
        on_write_error = parse_block_error_action(buf, 0);
958
        if (on_write_error < 0) {
959
            return NULL;
960
        }
961
    }
962

    
963
    on_read_error = BLOCK_ERR_REPORT;
964
    if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
965
        if (type != IF_IDE && type != IF_VIRTIO && type != IF_NONE) {
966
            fprintf(stderr, "rerror is no supported by this format\n");
967
            return NULL;
968
        }
969

    
970
        on_read_error = parse_block_error_action(buf, 1);
971
        if (on_read_error < 0) {
972
            return NULL;
973
        }
974
    }
975

    
976
    if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
977
        if (type != IF_VIRTIO) {
978
            fprintf(stderr, "addr is not supported\n");
979
            return NULL;
980
        }
981
    }
982

    
983
    /* compute bus and unit according index */
984

    
985
    if (index != -1) {
986
        if (bus_id != 0 || unit_id != -1) {
987
            fprintf(stderr,
988
                    "qemu: index cannot be used with bus and unit\n");
989
            return NULL;
990
        }
991
        if (max_devs == 0)
992
        {
993
            unit_id = index;
994
            bus_id = 0;
995
        } else {
996
            unit_id = index % max_devs;
997
            bus_id = index / max_devs;
998
        }
999
    }
1000

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

    
1005
    if (unit_id == -1) {
1006
       unit_id = 0;
1007
       while (drive_get(type, bus_id, unit_id) != NULL) {
1008
           unit_id++;
1009
           if (max_devs && unit_id >= max_devs) {
1010
               unit_id -= max_devs;
1011
               bus_id++;
1012
           }
1013
       }
1014
    }
1015

    
1016
    /* check unit id */
1017

    
1018
    if (max_devs && unit_id >= max_devs) {
1019
        fprintf(stderr, "qemu: unit %d too big (max is %d)\n",
1020
                unit_id, max_devs - 1);
1021
        return NULL;
1022
    }
1023

    
1024
    /*
1025
     * ignore multiple definitions
1026
     */
1027

    
1028
    if (drive_get(type, bus_id, unit_id) != NULL) {
1029
        *fatal_error = 0;
1030
        return NULL;
1031
    }
1032

    
1033
    /* init */
1034

    
1035
    dinfo = qemu_mallocz(sizeof(*dinfo));
1036
    if ((buf = qemu_opts_id(opts)) != NULL) {
1037
        dinfo->id = qemu_strdup(buf);
1038
    } else {
1039
        /* no id supplied -> create one */
1040
        dinfo->id = qemu_mallocz(32);
1041
        if (type == IF_IDE || type == IF_SCSI)
1042
            mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
1043
        if (max_devs)
1044
            snprintf(dinfo->id, 32, "%s%i%s%i",
1045
                     devname, bus_id, mediastr, unit_id);
1046
        else
1047
            snprintf(dinfo->id, 32, "%s%s%i",
1048
                     devname, mediastr, unit_id);
1049
    }
1050
    dinfo->bdrv = bdrv_new(dinfo->id);
1051
    dinfo->devaddr = devaddr;
1052
    dinfo->type = type;
1053
    dinfo->bus = bus_id;
1054
    dinfo->unit = unit_id;
1055
    dinfo->on_read_error = on_read_error;
1056
    dinfo->on_write_error = on_write_error;
1057
    dinfo->opts = opts;
1058
    if (serial)
1059
        strncpy(dinfo->serial, serial, sizeof(serial));
1060
    QTAILQ_INSERT_TAIL(&drives, dinfo, next);
1061

    
1062
    switch(type) {
1063
    case IF_IDE:
1064
    case IF_SCSI:
1065
    case IF_XEN:
1066
    case IF_NONE:
1067
        switch(media) {
1068
        case MEDIA_DISK:
1069
            if (cyls != 0) {
1070
                bdrv_set_geometry_hint(dinfo->bdrv, cyls, heads, secs);
1071
                bdrv_set_translation_hint(dinfo->bdrv, translation);
1072
            }
1073
            break;
1074
        case MEDIA_CDROM:
1075
            bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM);
1076
            break;
1077
        }
1078
        break;
1079
    case IF_SD:
1080
        /* FIXME: This isn't really a floppy, but it's a reasonable
1081
           approximation.  */
1082
    case IF_FLOPPY:
1083
        bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY);
1084
        break;
1085
    case IF_PFLASH:
1086
    case IF_MTD:
1087
        break;
1088
    case IF_VIRTIO:
1089
        /* add virtio block device */
1090
        opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
1091
        qemu_opt_set(opts, "driver", "virtio-blk-pci");
1092
        qemu_opt_set(opts, "drive", dinfo->id);
1093
        if (devaddr)
1094
            qemu_opt_set(opts, "addr", devaddr);
1095
        break;
1096
    case IF_COUNT:
1097
        abort();
1098
    }
1099
    if (!file) {
1100
        *fatal_error = 0;
1101
        return NULL;
1102
    }
1103
    if (snapshot) {
1104
        /* always use cache=unsafe with snapshot */
1105
        bdrv_flags &= ~BDRV_O_CACHE_MASK;
1106
        bdrv_flags |= (BDRV_O_SNAPSHOT|BDRV_O_CACHE_WB|BDRV_O_NO_FLUSH);
1107
    }
1108

    
1109
    if (media == MEDIA_CDROM) {
1110
        /* CDROM is fine for any interface, don't check.  */
1111
        ro = 1;
1112
    } else if (ro == 1) {
1113
        if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY && type != IF_NONE) {
1114
            fprintf(stderr, "qemu: readonly flag not supported for drive with this interface\n");
1115
            return NULL;
1116
        }
1117
    }
1118

    
1119
    bdrv_flags |= ro ? 0 : BDRV_O_RDWR;
1120

    
1121
    ret = bdrv_open(dinfo->bdrv, file, bdrv_flags, drv);
1122
    if (ret < 0) {
1123
        fprintf(stderr, "qemu: could not open disk image %s: %s\n",
1124
                        file, strerror(-ret));
1125
        return NULL;
1126
    }
1127

    
1128
    if (bdrv_key_required(dinfo->bdrv))
1129
        autostart = 0;
1130
    *fatal_error = 0;
1131
    return dinfo;
1132
}
1133

    
1134
static int drive_init_func(QemuOpts *opts, void *opaque)
1135
{
1136
    int *use_scsi = opaque;
1137
    int fatal_error = 0;
1138

    
1139
    if (drive_init(opts, *use_scsi, &fatal_error) == NULL) {
1140
        if (fatal_error)
1141
            return 1;
1142
    }
1143
    return 0;
1144
}
1145

    
1146
static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
1147
{
1148
    if (NULL == qemu_opt_get(opts, "snapshot")) {
1149
        qemu_opt_set(opts, "snapshot", "on");
1150
    }
1151
    return 0;
1152
}
1153

    
1154
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
1155
{
1156
    boot_set_handler = func;
1157
    boot_set_opaque = opaque;
1158
}
1159

    
1160
int qemu_boot_set(const char *boot_devices)
1161
{
1162
    if (!boot_set_handler) {
1163
        return -EINVAL;
1164
    }
1165
    return boot_set_handler(boot_set_opaque, boot_devices);
1166
}
1167

    
1168
static void validate_bootdevices(char *devices)
1169
{
1170
    /* We just do some generic consistency checks */
1171
    const char *p;
1172
    int bitmap = 0;
1173

    
1174
    for (p = devices; *p != '\0'; p++) {
1175
        /* Allowed boot devices are:
1176
         * a-b: floppy disk drives
1177
         * c-f: IDE disk drives
1178
         * g-m: machine implementation dependant drives
1179
         * n-p: network devices
1180
         * It's up to each machine implementation to check if the given boot
1181
         * devices match the actual hardware implementation and firmware
1182
         * features.
1183
         */
1184
        if (*p < 'a' || *p > 'p') {
1185
            fprintf(stderr, "Invalid boot device '%c'\n", *p);
1186
            exit(1);
1187
        }
1188
        if (bitmap & (1 << (*p - 'a'))) {
1189
            fprintf(stderr, "Boot device '%c' was given twice\n", *p);
1190
            exit(1);
1191
        }
1192
        bitmap |= 1 << (*p - 'a');
1193
    }
1194
}
1195

    
1196
static void restore_boot_devices(void *opaque)
1197
{
1198
    char *standard_boot_devices = opaque;
1199
    static int first = 1;
1200

    
1201
    /* Restore boot order and remove ourselves after the first boot */
1202
    if (first) {
1203
        first = 0;
1204
        return;
1205
    }
1206

    
1207
    qemu_boot_set(standard_boot_devices);
1208

    
1209
    qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
1210
    qemu_free(standard_boot_devices);
1211
}
1212

    
1213
static void numa_add(const char *optarg)
1214
{
1215
    char option[128];
1216
    char *endptr;
1217
    unsigned long long value, endvalue;
1218
    int nodenr;
1219

    
1220
    optarg = get_opt_name(option, 128, optarg, ',') + 1;
1221
    if (!strcmp(option, "node")) {
1222
        if (get_param_value(option, 128, "nodeid", optarg) == 0) {
1223
            nodenr = nb_numa_nodes;
1224
        } else {
1225
            nodenr = strtoull(option, NULL, 10);
1226
        }
1227

    
1228
        if (get_param_value(option, 128, "mem", optarg) == 0) {
1229
            node_mem[nodenr] = 0;
1230
        } else {
1231
            value = strtoull(option, &endptr, 0);
1232
            switch (*endptr) {
1233
            case 0: case 'M': case 'm':
1234
                value <<= 20;
1235
                break;
1236
            case 'G': case 'g':
1237
                value <<= 30;
1238
                break;
1239
            }
1240
            node_mem[nodenr] = value;
1241
        }
1242
        if (get_param_value(option, 128, "cpus", optarg) == 0) {
1243
            node_cpumask[nodenr] = 0;
1244
        } else {
1245
            value = strtoull(option, &endptr, 10);
1246
            if (value >= 64) {
1247
                value = 63;
1248
                fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
1249
            } else {
1250
                if (*endptr == '-') {
1251
                    endvalue = strtoull(endptr+1, &endptr, 10);
1252
                    if (endvalue >= 63) {
1253
                        endvalue = 62;
1254
                        fprintf(stderr,
1255
                            "only 63 CPUs in NUMA mode supported.\n");
1256
                    }
1257
                    value = (2ULL << endvalue) - (1ULL << value);
1258
                } else {
1259
                    value = 1ULL << value;
1260
                }
1261
            }
1262
            node_cpumask[nodenr] = value;
1263
        }
1264
        nb_numa_nodes++;
1265
    }
1266
    return;
1267
}
1268

    
1269
static void smp_parse(const char *optarg)
1270
{
1271
    int smp, sockets = 0, threads = 0, cores = 0;
1272
    char *endptr;
1273
    char option[128];
1274

    
1275
    smp = strtoul(optarg, &endptr, 10);
1276
    if (endptr != optarg) {
1277
        if (*endptr == ',') {
1278
            endptr++;
1279
        }
1280
    }
1281
    if (get_param_value(option, 128, "sockets", endptr) != 0)
1282
        sockets = strtoull(option, NULL, 10);
1283
    if (get_param_value(option, 128, "cores", endptr) != 0)
1284
        cores = strtoull(option, NULL, 10);
1285
    if (get_param_value(option, 128, "threads", endptr) != 0)
1286
        threads = strtoull(option, NULL, 10);
1287
    if (get_param_value(option, 128, "maxcpus", endptr) != 0)
1288
        max_cpus = strtoull(option, NULL, 10);
1289

    
1290
    /* compute missing values, prefer sockets over cores over threads */
1291
    if (smp == 0 || sockets == 0) {
1292
        sockets = sockets > 0 ? sockets : 1;
1293
        cores = cores > 0 ? cores : 1;
1294
        threads = threads > 0 ? threads : 1;
1295
        if (smp == 0) {
1296
            smp = cores * threads * sockets;
1297
        }
1298
    } else {
1299
        if (cores == 0) {
1300
            threads = threads > 0 ? threads : 1;
1301
            cores = smp / (sockets * threads);
1302
        } else {
1303
            if (sockets) {
1304
                threads = smp / (cores * sockets);
1305
            }
1306
        }
1307
    }
1308
    smp_cpus = smp;
1309
    smp_cores = cores > 0 ? cores : 1;
1310
    smp_threads = threads > 0 ? threads : 1;
1311
    if (max_cpus == 0)
1312
        max_cpus = smp_cpus;
1313
}
1314

    
1315
/***********************************************************/
1316
/* USB devices */
1317

    
1318
static int usb_device_add(const char *devname)
1319
{
1320
    const char *p;
1321
    USBDevice *dev = NULL;
1322

    
1323
    if (!usb_enabled)
1324
        return -1;
1325

    
1326
    /* drivers with .usbdevice_name entry in USBDeviceInfo */
1327
    dev = usbdevice_create(devname);
1328
    if (dev)
1329
        goto done;
1330

    
1331
    /* the other ones */
1332
    if (strstart(devname, "host:", &p)) {
1333
        dev = usb_host_device_open(p);
1334
    } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
1335
        dev = usb_bt_init(devname[2] ? hci_init(p) :
1336
                        bt_new_hci(qemu_find_bt_vlan(0)));
1337
    } else {
1338
        return -1;
1339
    }
1340
    if (!dev)
1341
        return -1;
1342

    
1343
done:
1344
    return 0;
1345
}
1346

    
1347
static int usb_device_del(const char *devname)
1348
{
1349
    int bus_num, addr;
1350
    const char *p;
1351

    
1352
    if (strstart(devname, "host:", &p))
1353
        return usb_host_device_close(p);
1354

    
1355
    if (!usb_enabled)
1356
        return -1;
1357

    
1358
    p = strchr(devname, '.');
1359
    if (!p)
1360
        return -1;
1361
    bus_num = strtoul(devname, NULL, 0);
1362
    addr = strtoul(p + 1, NULL, 0);
1363

    
1364
    return usb_device_delete_addr(bus_num, addr);
1365
}
1366

    
1367
static int usb_parse(const char *cmdline)
1368
{
1369
    int r;
1370
    r = usb_device_add(cmdline);
1371
    if (r < 0) {
1372
        fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
1373
    }
1374
    return r;
1375
}
1376

    
1377
void do_usb_add(Monitor *mon, const QDict *qdict)
1378
{
1379
    const char *devname = qdict_get_str(qdict, "devname");
1380
    if (usb_device_add(devname) < 0) {
1381
        error_report("could not add USB device '%s'", devname);
1382
    }
1383
}
1384

    
1385
void do_usb_del(Monitor *mon, const QDict *qdict)
1386
{
1387
    const char *devname = qdict_get_str(qdict, "devname");
1388
    if (usb_device_del(devname) < 0) {
1389
        error_report("could not delete USB device '%s'", devname);
1390
    }
1391
}
1392

    
1393
/***********************************************************/
1394
/* PCMCIA/Cardbus */
1395

    
1396
static struct pcmcia_socket_entry_s {
1397
    PCMCIASocket *socket;
1398
    struct pcmcia_socket_entry_s *next;
1399
} *pcmcia_sockets = 0;
1400

    
1401
void pcmcia_socket_register(PCMCIASocket *socket)
1402
{
1403
    struct pcmcia_socket_entry_s *entry;
1404

    
1405
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
1406
    entry->socket = socket;
1407
    entry->next = pcmcia_sockets;
1408
    pcmcia_sockets = entry;
1409
}
1410

    
1411
void pcmcia_socket_unregister(PCMCIASocket *socket)
1412
{
1413
    struct pcmcia_socket_entry_s *entry, **ptr;
1414

    
1415
    ptr = &pcmcia_sockets;
1416
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
1417
        if (entry->socket == socket) {
1418
            *ptr = entry->next;
1419
            qemu_free(entry);
1420
        }
1421
}
1422

    
1423
void pcmcia_info(Monitor *mon)
1424
{
1425
    struct pcmcia_socket_entry_s *iter;
1426

    
1427
    if (!pcmcia_sockets)
1428
        monitor_printf(mon, "No PCMCIA sockets\n");
1429

    
1430
    for (iter = pcmcia_sockets; iter; iter = iter->next)
1431
        monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
1432
                       iter->socket->attached ? iter->socket->card_string :
1433
                       "Empty");
1434
}
1435

    
1436
/***********************************************************/
1437
/* I/O handling */
1438

    
1439
typedef struct IOHandlerRecord {
1440
    int fd;
1441
    IOCanReadHandler *fd_read_poll;
1442
    IOHandler *fd_read;
1443
    IOHandler *fd_write;
1444
    int deleted;
1445
    void *opaque;
1446
    /* temporary data */
1447
    struct pollfd *ufd;
1448
    QLIST_ENTRY(IOHandlerRecord) next;
1449
} IOHandlerRecord;
1450

    
1451
static QLIST_HEAD(, IOHandlerRecord) io_handlers =
1452
    QLIST_HEAD_INITIALIZER(io_handlers);
1453

    
1454

    
1455
/* XXX: fd_read_poll should be suppressed, but an API change is
1456
   necessary in the character devices to suppress fd_can_read(). */
1457
int qemu_set_fd_handler2(int fd,
1458
                         IOCanReadHandler *fd_read_poll,
1459
                         IOHandler *fd_read,
1460
                         IOHandler *fd_write,
1461
                         void *opaque)
1462
{
1463
    IOHandlerRecord *ioh;
1464

    
1465
    if (!fd_read && !fd_write) {
1466
        QLIST_FOREACH(ioh, &io_handlers, next) {
1467
            if (ioh->fd == fd) {
1468
                ioh->deleted = 1;
1469
                break;
1470
            }
1471
        }
1472
    } else {
1473
        QLIST_FOREACH(ioh, &io_handlers, next) {
1474
            if (ioh->fd == fd)
1475
                goto found;
1476
        }
1477
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
1478
        QLIST_INSERT_HEAD(&io_handlers, ioh, next);
1479
    found:
1480
        ioh->fd = fd;
1481
        ioh->fd_read_poll = fd_read_poll;
1482
        ioh->fd_read = fd_read;
1483
        ioh->fd_write = fd_write;
1484
        ioh->opaque = opaque;
1485
        ioh->deleted = 0;
1486
    }
1487
    return 0;
1488
}
1489

    
1490
int qemu_set_fd_handler(int fd,
1491
                        IOHandler *fd_read,
1492
                        IOHandler *fd_write,
1493
                        void *opaque)
1494
{
1495
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
1496
}
1497

    
1498
#ifdef _WIN32
1499
/***********************************************************/
1500
/* Polling handling */
1501

    
1502
typedef struct PollingEntry {
1503
    PollingFunc *func;
1504
    void *opaque;
1505
    struct PollingEntry *next;
1506
} PollingEntry;
1507

    
1508
static PollingEntry *first_polling_entry;
1509

    
1510
int qemu_add_polling_cb(PollingFunc *func, void *opaque)
1511
{
1512
    PollingEntry **ppe, *pe;
1513
    pe = qemu_mallocz(sizeof(PollingEntry));
1514
    pe->func = func;
1515
    pe->opaque = opaque;
1516
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
1517
    *ppe = pe;
1518
    return 0;
1519
}
1520

    
1521
void qemu_del_polling_cb(PollingFunc *func, void *opaque)
1522
{
1523
    PollingEntry **ppe, *pe;
1524
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
1525
        pe = *ppe;
1526
        if (pe->func == func && pe->opaque == opaque) {
1527
            *ppe = pe->next;
1528
            qemu_free(pe);
1529
            break;
1530
        }
1531
    }
1532
}
1533

    
1534
/***********************************************************/
1535
/* Wait objects support */
1536
typedef struct WaitObjects {
1537
    int num;
1538
    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
1539
    WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
1540
    void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
1541
} WaitObjects;
1542

    
1543
static WaitObjects wait_objects = {0};
1544

    
1545
int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
1546
{
1547
    WaitObjects *w = &wait_objects;
1548

    
1549
    if (w->num >= MAXIMUM_WAIT_OBJECTS)
1550
        return -1;
1551
    w->events[w->num] = handle;
1552
    w->func[w->num] = func;
1553
    w->opaque[w->num] = opaque;
1554
    w->num++;
1555
    return 0;
1556
}
1557

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

    
1563
    found = 0;
1564
    for (i = 0; i < w->num; i++) {
1565
        if (w->events[i] == handle)
1566
            found = 1;
1567
        if (found) {
1568
            w->events[i] = w->events[i + 1];
1569
            w->func[i] = w->func[i + 1];
1570
            w->opaque[i] = w->opaque[i + 1];
1571
        }
1572
    }
1573
    if (found)
1574
        w->num--;
1575
}
1576
#endif
1577

    
1578
/***********************************************************/
1579
/* machine registration */
1580

    
1581
static QEMUMachine *first_machine = NULL;
1582
QEMUMachine *current_machine = NULL;
1583

    
1584
int qemu_register_machine(QEMUMachine *m)
1585
{
1586
    QEMUMachine **pm;
1587
    pm = &first_machine;
1588
    while (*pm != NULL)
1589
        pm = &(*pm)->next;
1590
    m->next = NULL;
1591
    *pm = m;
1592
    return 0;
1593
}
1594

    
1595
static QEMUMachine *find_machine(const char *name)
1596
{
1597
    QEMUMachine *m;
1598

    
1599
    for(m = first_machine; m != NULL; m = m->next) {
1600
        if (!strcmp(m->name, name))
1601
            return m;
1602
        if (m->alias && !strcmp(m->alias, name))
1603
            return m;
1604
    }
1605
    return NULL;
1606
}
1607

    
1608
static QEMUMachine *find_default_machine(void)
1609
{
1610
    QEMUMachine *m;
1611

    
1612
    for(m = first_machine; m != NULL; m = m->next) {
1613
        if (m->is_default) {
1614
            return m;
1615
        }
1616
    }
1617
    return NULL;
1618
}
1619

    
1620
/***********************************************************/
1621
/* main execution loop */
1622

    
1623
static void gui_update(void *opaque)
1624
{
1625
    uint64_t interval = GUI_REFRESH_INTERVAL;
1626
    DisplayState *ds = opaque;
1627
    DisplayChangeListener *dcl = ds->listeners;
1628

    
1629
    qemu_flush_coalesced_mmio_buffer();
1630
    dpy_refresh(ds);
1631

    
1632
    while (dcl != NULL) {
1633
        if (dcl->gui_timer_interval &&
1634
            dcl->gui_timer_interval < interval)
1635
            interval = dcl->gui_timer_interval;
1636
        dcl = dcl->next;
1637
    }
1638
    qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
1639
}
1640

    
1641
static void nographic_update(void *opaque)
1642
{
1643
    uint64_t interval = GUI_REFRESH_INTERVAL;
1644

    
1645
    qemu_flush_coalesced_mmio_buffer();
1646
    qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
1647
}
1648

    
1649
struct vm_change_state_entry {
1650
    VMChangeStateHandler *cb;
1651
    void *opaque;
1652
    QLIST_ENTRY (vm_change_state_entry) entries;
1653
};
1654

    
1655
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
1656

    
1657
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
1658
                                                     void *opaque)
1659
{
1660
    VMChangeStateEntry *e;
1661

    
1662
    e = qemu_mallocz(sizeof (*e));
1663

    
1664
    e->cb = cb;
1665
    e->opaque = opaque;
1666
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
1667
    return e;
1668
}
1669

    
1670
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
1671
{
1672
    QLIST_REMOVE (e, entries);
1673
    qemu_free (e);
1674
}
1675

    
1676
void vm_state_notify(int running, int reason)
1677
{
1678
    VMChangeStateEntry *e;
1679

    
1680
    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
1681
        e->cb(e->opaque, running, reason);
1682
    }
1683
}
1684

    
1685
void vm_start(void)
1686
{
1687
    if (!vm_running) {
1688
        cpu_enable_ticks();
1689
        vm_running = 1;
1690
        vm_state_notify(1, 0);
1691
        resume_all_vcpus();
1692
        monitor_protocol_event(QEVENT_RESUME, NULL);
1693
    }
1694
}
1695

    
1696
/* reset/shutdown handler */
1697

    
1698
typedef struct QEMUResetEntry {
1699
    QTAILQ_ENTRY(QEMUResetEntry) entry;
1700
    QEMUResetHandler *func;
1701
    void *opaque;
1702
} QEMUResetEntry;
1703

    
1704
static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
1705
    QTAILQ_HEAD_INITIALIZER(reset_handlers);
1706
static int reset_requested;
1707
static int shutdown_requested;
1708
static int powerdown_requested;
1709
int debug_requested;
1710
int vmstop_requested;
1711

    
1712
int qemu_shutdown_requested(void)
1713
{
1714
    int r = shutdown_requested;
1715
    shutdown_requested = 0;
1716
    return r;
1717
}
1718

    
1719
int qemu_reset_requested(void)
1720
{
1721
    int r = reset_requested;
1722
    reset_requested = 0;
1723
    return r;
1724
}
1725

    
1726
int qemu_powerdown_requested(void)
1727
{
1728
    int r = powerdown_requested;
1729
    powerdown_requested = 0;
1730
    return r;
1731
}
1732

    
1733
static int qemu_debug_requested(void)
1734
{
1735
    int r = debug_requested;
1736
    debug_requested = 0;
1737
    return r;
1738
}
1739

    
1740
static int qemu_vmstop_requested(void)
1741
{
1742
    int r = vmstop_requested;
1743
    vmstop_requested = 0;
1744
    return r;
1745
}
1746

    
1747
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
1748
{
1749
    QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
1750

    
1751
    re->func = func;
1752
    re->opaque = opaque;
1753
    QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
1754
}
1755

    
1756
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
1757
{
1758
    QEMUResetEntry *re;
1759

    
1760
    QTAILQ_FOREACH(re, &reset_handlers, entry) {
1761
        if (re->func == func && re->opaque == opaque) {
1762
            QTAILQ_REMOVE(&reset_handlers, re, entry);
1763
            qemu_free(re);
1764
            return;
1765
        }
1766
    }
1767
}
1768

    
1769
void qemu_system_reset(void)
1770
{
1771
    QEMUResetEntry *re, *nre;
1772

    
1773
    /* reset all devices */
1774
    QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
1775
        re->func(re->opaque);
1776
    }
1777
    monitor_protocol_event(QEVENT_RESET, NULL);
1778
    cpu_synchronize_all_post_reset();
1779
}
1780

    
1781
void qemu_system_reset_request(void)
1782
{
1783
    if (no_reboot) {
1784
        shutdown_requested = 1;
1785
    } else {
1786
        reset_requested = 1;
1787
    }
1788
    qemu_notify_event();
1789
}
1790

    
1791
void qemu_system_shutdown_request(void)
1792
{
1793
    shutdown_requested = 1;
1794
    qemu_notify_event();
1795
}
1796

    
1797
void qemu_system_powerdown_request(void)
1798
{
1799
    powerdown_requested = 1;
1800
    qemu_notify_event();
1801
}
1802

    
1803
#ifdef _WIN32
1804
static void host_main_loop_wait(int *timeout)
1805
{
1806
    int ret, ret2, i;
1807
    PollingEntry *pe;
1808

    
1809

    
1810
    /* XXX: need to suppress polling by better using win32 events */
1811
    ret = 0;
1812
    for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
1813
        ret |= pe->func(pe->opaque);
1814
    }
1815
    if (ret == 0) {
1816
        int err;
1817
        WaitObjects *w = &wait_objects;
1818

    
1819
        ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
1820
        if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
1821
            if (w->func[ret - WAIT_OBJECT_0])
1822
                w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
1823

    
1824
            /* Check for additional signaled events */
1825
            for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
1826

    
1827
                /* Check if event is signaled */
1828
                ret2 = WaitForSingleObject(w->events[i], 0);
1829
                if(ret2 == WAIT_OBJECT_0) {
1830
                    if (w->func[i])
1831
                        w->func[i](w->opaque[i]);
1832
                } else if (ret2 == WAIT_TIMEOUT) {
1833
                } else {
1834
                    err = GetLastError();
1835
                    fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
1836
                }
1837
            }
1838
        } else if (ret == WAIT_TIMEOUT) {
1839
        } else {
1840
            err = GetLastError();
1841
            fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
1842
        }
1843
    }
1844

    
1845
    *timeout = 0;
1846
}
1847
#else
1848
static void host_main_loop_wait(int *timeout)
1849
{
1850
}
1851
#endif
1852

    
1853
void main_loop_wait(int nonblocking)
1854
{
1855
    IOHandlerRecord *ioh;
1856
    fd_set rfds, wfds, xfds;
1857
    int ret, nfds;
1858
    struct timeval tv;
1859
    int timeout;
1860

    
1861
    if (nonblocking)
1862
        timeout = 0;
1863
    else {
1864
        timeout = qemu_calculate_timeout();
1865
        qemu_bh_update_timeout(&timeout);
1866
    }
1867

    
1868
    host_main_loop_wait(&timeout);
1869

    
1870
    /* poll any events */
1871
    /* XXX: separate device handlers from system ones */
1872
    nfds = -1;
1873
    FD_ZERO(&rfds);
1874
    FD_ZERO(&wfds);
1875
    FD_ZERO(&xfds);
1876
    QLIST_FOREACH(ioh, &io_handlers, next) {
1877
        if (ioh->deleted)
1878
            continue;
1879
        if (ioh->fd_read &&
1880
            (!ioh->fd_read_poll ||
1881
             ioh->fd_read_poll(ioh->opaque) != 0)) {
1882
            FD_SET(ioh->fd, &rfds);
1883
            if (ioh->fd > nfds)
1884
                nfds = ioh->fd;
1885
        }
1886
        if (ioh->fd_write) {
1887
            FD_SET(ioh->fd, &wfds);
1888
            if (ioh->fd > nfds)
1889
                nfds = ioh->fd;
1890
        }
1891
    }
1892

    
1893
    tv.tv_sec = timeout / 1000;
1894
    tv.tv_usec = (timeout % 1000) * 1000;
1895

    
1896
    slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
1897

    
1898
    qemu_mutex_unlock_iothread();
1899
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
1900
    qemu_mutex_lock_iothread();
1901
    if (ret > 0) {
1902
        IOHandlerRecord *pioh;
1903

    
1904
        QLIST_FOREACH_SAFE(ioh, &io_handlers, next, pioh) {
1905
            if (ioh->deleted) {
1906
                QLIST_REMOVE(ioh, next);
1907
                qemu_free(ioh);
1908
                continue;
1909
            }
1910
            if (ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
1911
                ioh->fd_read(ioh->opaque);
1912
            }
1913
            if (ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
1914
                ioh->fd_write(ioh->opaque);
1915
            }
1916
        }
1917
    }
1918

    
1919
    slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
1920

    
1921
    qemu_run_all_timers();
1922

    
1923
    /* Check bottom-halves last in case any of the earlier events triggered
1924
       them.  */
1925
    qemu_bh_poll();
1926

    
1927
}
1928

    
1929
static int vm_can_run(void)
1930
{
1931
    if (powerdown_requested)
1932
        return 0;
1933
    if (reset_requested)
1934
        return 0;
1935
    if (shutdown_requested)
1936
        return 0;
1937
    if (debug_requested)
1938
        return 0;
1939
    return 1;
1940
}
1941

    
1942
qemu_irq qemu_system_powerdown;
1943

    
1944
static void main_loop(void)
1945
{
1946
    int r;
1947

    
1948
    qemu_main_loop_start();
1949

    
1950
    for (;;) {
1951
        do {
1952
            bool nonblocking = false;
1953
#ifdef CONFIG_PROFILER
1954
            int64_t ti;
1955
#endif
1956
#ifndef CONFIG_IOTHREAD
1957
            nonblocking = tcg_cpu_exec();
1958
#endif
1959
#ifdef CONFIG_PROFILER
1960
            ti = profile_getclock();
1961
#endif
1962
            main_loop_wait(nonblocking);
1963
#ifdef CONFIG_PROFILER
1964
            dev_time += profile_getclock() - ti;
1965
#endif
1966
        } while (vm_can_run());
1967

    
1968
        if ((r = qemu_debug_requested())) {
1969
            vm_stop(r);
1970
        }
1971
        if (qemu_shutdown_requested()) {
1972
            monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
1973
            if (no_shutdown) {
1974
                vm_stop(0);
1975
                no_shutdown = 0;
1976
            } else
1977
                break;
1978
        }
1979
        if (qemu_reset_requested()) {
1980
            pause_all_vcpus();
1981
            qemu_system_reset();
1982
            resume_all_vcpus();
1983
        }
1984
        if (qemu_powerdown_requested()) {
1985
            monitor_protocol_event(QEVENT_POWERDOWN, NULL);
1986
            qemu_irq_raise(qemu_system_powerdown);
1987
        }
1988
        if ((r = qemu_vmstop_requested())) {
1989
            vm_stop(r);
1990
        }
1991
    }
1992
    bdrv_close_all();
1993
    pause_all_vcpus();
1994
}
1995

    
1996
static void version(void)
1997
{
1998
    printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
1999
}
2000

    
2001
static void help(int exitcode)
2002
{
2003
    const char *options_help =
2004
#define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
2005
        opt_help
2006
#define DEFHEADING(text) stringify(text) "\n"
2007
#include "qemu-options.h"
2008
#undef DEF
2009
#undef DEFHEADING
2010
#undef GEN_DOCS
2011
        ;
2012
    version();
2013
    printf("usage: %s [options] [disk_image]\n"
2014
           "\n"
2015
           "'disk_image' is a raw hard disk image for IDE hard disk 0\n"
2016
           "\n"
2017
           "%s\n"
2018
           "During emulation, the following keys are useful:\n"
2019
           "ctrl-alt-f      toggle full screen\n"
2020
           "ctrl-alt-n      switch to virtual console 'n'\n"
2021
           "ctrl-alt        toggle mouse and keyboard grab\n"
2022
           "\n"
2023
           "When using -nographic, press 'ctrl-a h' to get some help.\n",
2024
           "qemu",
2025
           options_help);
2026
    exit(exitcode);
2027
}
2028

    
2029
#define HAS_ARG 0x0001
2030

    
2031
enum {
2032
#define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
2033
    opt_enum,
2034
#define DEFHEADING(text)
2035
#include "qemu-options.h"
2036
#undef DEF
2037
#undef DEFHEADING
2038
#undef GEN_DOCS
2039
};
2040

    
2041
typedef struct QEMUOption {
2042
    const char *name;
2043
    int flags;
2044
    int index;
2045
    uint32_t arch_mask;
2046
} QEMUOption;
2047

    
2048
static const QEMUOption qemu_options[] = {
2049
    { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
2050
#define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
2051
    { option, opt_arg, opt_enum, arch_mask },
2052
#define DEFHEADING(text)
2053
#include "qemu-options.h"
2054
#undef DEF
2055
#undef DEFHEADING
2056
#undef GEN_DOCS
2057
    { NULL },
2058
};
2059
static void select_vgahw (const char *p)
2060
{
2061
    const char *opts;
2062

    
2063
    default_vga = 0;
2064
    vga_interface_type = VGA_NONE;
2065
    if (strstart(p, "std", &opts)) {
2066
        vga_interface_type = VGA_STD;
2067
    } else if (strstart(p, "cirrus", &opts)) {
2068
        vga_interface_type = VGA_CIRRUS;
2069
    } else if (strstart(p, "vmware", &opts)) {
2070
        vga_interface_type = VGA_VMWARE;
2071
    } else if (strstart(p, "xenfb", &opts)) {
2072
        vga_interface_type = VGA_XENFB;
2073
    } else if (!strstart(p, "none", &opts)) {
2074
    invalid_vga:
2075
        fprintf(stderr, "Unknown vga type: %s\n", p);
2076
        exit(1);
2077
    }
2078
    while (*opts) {
2079
        const char *nextopt;
2080

    
2081
        if (strstart(opts, ",retrace=", &nextopt)) {
2082
            opts = nextopt;
2083
            if (strstart(opts, "dumb", &nextopt))
2084
                vga_retrace_method = VGA_RETRACE_DUMB;
2085
            else if (strstart(opts, "precise", &nextopt))
2086
                vga_retrace_method = VGA_RETRACE_PRECISE;
2087
            else goto invalid_vga;
2088
        } else goto invalid_vga;
2089
        opts = nextopt;
2090
    }
2091
}
2092

    
2093
static int balloon_parse(const char *arg)
2094
{
2095
    QemuOpts *opts;
2096

    
2097
    if (strcmp(arg, "none") == 0) {
2098
        return 0;
2099
    }
2100

    
2101
    if (!strncmp(arg, "virtio", 6)) {
2102
        if (arg[6] == ',') {
2103
            /* have params -> parse them */
2104
            opts = qemu_opts_parse(&qemu_device_opts, arg+7, 0);
2105
            if (!opts)
2106
                return  -1;
2107
        } else {
2108
            /* create empty opts */
2109
            opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
2110
        }
2111
        qemu_opt_set(opts, "driver", "virtio-balloon-pci");
2112
        return 0;
2113
    }
2114

    
2115
    return -1;
2116
}
2117

    
2118
#ifdef _WIN32
2119
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
2120
{
2121
    exit(STATUS_CONTROL_C_EXIT);
2122
    return TRUE;
2123
}
2124
#endif
2125

    
2126
#ifndef _WIN32
2127

    
2128
static void termsig_handler(int signal)
2129
{
2130
    qemu_system_shutdown_request();
2131
}
2132

    
2133
static void sigchld_handler(int signal)
2134
{
2135
    waitpid(-1, NULL, WNOHANG);
2136
}
2137

    
2138
static void sighandler_setup(void)
2139
{
2140
    struct sigaction act;
2141

    
2142
    memset(&act, 0, sizeof(act));
2143
    act.sa_handler = termsig_handler;
2144
    sigaction(SIGINT,  &act, NULL);
2145
    sigaction(SIGHUP,  &act, NULL);
2146
    sigaction(SIGTERM, &act, NULL);
2147

    
2148
    act.sa_handler = sigchld_handler;
2149
    act.sa_flags = SA_NOCLDSTOP;
2150
    sigaction(SIGCHLD, &act, NULL);
2151
}
2152

    
2153
#endif
2154

    
2155
#ifdef _WIN32
2156
/* Look for support files in the same directory as the executable.  */
2157
static char *find_datadir(const char *argv0)
2158
{
2159
    char *p;
2160
    char buf[MAX_PATH];
2161
    DWORD len;
2162

    
2163
    len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
2164
    if (len == 0) {
2165
        return NULL;
2166
    }
2167

    
2168
    buf[len] = 0;
2169
    p = buf + len - 1;
2170
    while (p != buf && *p != '\\')
2171
        p--;
2172
    *p = 0;
2173
    if (access(buf, R_OK) == 0) {
2174
        return qemu_strdup(buf);
2175
    }
2176
    return NULL;
2177
}
2178
#else /* !_WIN32 */
2179

    
2180
/* Find a likely location for support files using the location of the binary.
2181
   For installed binaries this will be "$bindir/../share/qemu".  When
2182
   running from the build tree this will be "$bindir/../pc-bios".  */
2183
#define SHARE_SUFFIX "/share/qemu"
2184
#define BUILD_SUFFIX "/pc-bios"
2185
static char *find_datadir(const char *argv0)
2186
{
2187
    char *dir;
2188
    char *p = NULL;
2189
    char *res;
2190
    char buf[PATH_MAX];
2191
    size_t max_len;
2192

    
2193
#if defined(__linux__)
2194
    {
2195
        int len;
2196
        len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
2197
        if (len > 0) {
2198
            buf[len] = 0;
2199
            p = buf;
2200
        }
2201
    }
2202
#elif defined(__FreeBSD__)
2203
    {
2204
        static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
2205
        size_t len = sizeof(buf) - 1;
2206

    
2207
        *buf = '\0';
2208
        if (!sysctl(mib, sizeof(mib)/sizeof(*mib), buf, &len, NULL, 0) &&
2209
            *buf) {
2210
            buf[sizeof(buf) - 1] = '\0';
2211
            p = buf;
2212
        }
2213
    }
2214
#endif
2215
    /* If we don't have any way of figuring out the actual executable
2216
       location then try argv[0].  */
2217
    if (!p) {
2218
        p = realpath(argv0, buf);
2219
        if (!p) {
2220
            return NULL;
2221
        }
2222
    }
2223
    dir = dirname(p);
2224
    dir = dirname(dir);
2225

    
2226
    max_len = strlen(dir) +
2227
        MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
2228
    res = qemu_mallocz(max_len);
2229
    snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
2230
    if (access(res, R_OK)) {
2231
        snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
2232
        if (access(res, R_OK)) {
2233
            qemu_free(res);
2234
            res = NULL;
2235
        }
2236
    }
2237

    
2238
    return res;
2239
}
2240
#undef SHARE_SUFFIX
2241
#undef BUILD_SUFFIX
2242
#endif
2243

    
2244
char *qemu_find_file(int type, const char *name)
2245
{
2246
    int len;
2247
    const char *subdir;
2248
    char *buf;
2249

    
2250
    /* If name contains path separators then try it as a straight path.  */
2251
    if ((strchr(name, '/') || strchr(name, '\\'))
2252
        && access(name, R_OK) == 0) {
2253
        return qemu_strdup(name);
2254
    }
2255
    switch (type) {
2256
    case QEMU_FILE_TYPE_BIOS:
2257
        subdir = "";
2258
        break;
2259
    case QEMU_FILE_TYPE_KEYMAP:
2260
        subdir = "keymaps/";
2261
        break;
2262
    default:
2263
        abort();
2264
    }
2265
    len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
2266
    buf = qemu_mallocz(len);
2267
    snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
2268
    if (access(buf, R_OK)) {
2269
        qemu_free(buf);
2270
        return NULL;
2271
    }
2272
    return buf;
2273
}
2274

    
2275
static int device_help_func(QemuOpts *opts, void *opaque)
2276
{
2277
    return qdev_device_help(opts);
2278
}
2279

    
2280
static int device_init_func(QemuOpts *opts, void *opaque)
2281
{
2282
    DeviceState *dev;
2283

    
2284
    dev = qdev_device_add(opts);
2285
    if (!dev)
2286
        return -1;
2287
    return 0;
2288
}
2289

    
2290
static int chardev_init_func(QemuOpts *opts, void *opaque)
2291
{
2292
    CharDriverState *chr;
2293

    
2294
    chr = qemu_chr_open_opts(opts, NULL);
2295
    if (!chr)
2296
        return -1;
2297
    return 0;
2298
}
2299

    
2300
#ifdef CONFIG_LINUX
2301
static int fsdev_init_func(QemuOpts *opts, void *opaque)
2302
{
2303
    int ret;
2304
    ret = qemu_fsdev_add(opts);
2305

    
2306
    return ret;
2307
}
2308
#endif
2309

    
2310
static int mon_init_func(QemuOpts *opts, void *opaque)
2311
{
2312
    CharDriverState *chr;
2313
    const char *chardev;
2314
    const char *mode;
2315
    int flags;
2316

    
2317
    mode = qemu_opt_get(opts, "mode");
2318
    if (mode == NULL) {
2319
        mode = "readline";
2320
    }
2321
    if (strcmp(mode, "readline") == 0) {
2322
        flags = MONITOR_USE_READLINE;
2323
    } else if (strcmp(mode, "control") == 0) {
2324
        flags = MONITOR_USE_CONTROL;
2325
    } else {
2326
        fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
2327
        exit(1);
2328
    }
2329

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

    
2333
    chardev = qemu_opt_get(opts, "chardev");
2334
    chr = qemu_chr_find(chardev);
2335
    if (chr == NULL) {
2336
        fprintf(stderr, "chardev \"%s\" not found\n", chardev);
2337
        exit(1);
2338
    }
2339

    
2340
    monitor_init(chr, flags);
2341
    return 0;
2342
}
2343

    
2344
static void monitor_parse(const char *optarg, const char *mode)
2345
{
2346
    static int monitor_device_index = 0;
2347
    QemuOpts *opts;
2348
    const char *p;
2349
    char label[32];
2350
    int def = 0;
2351

    
2352
    if (strstart(optarg, "chardev:", &p)) {
2353
        snprintf(label, sizeof(label), "%s", p);
2354
    } else {
2355
        snprintf(label, sizeof(label), "compat_monitor%d",
2356
                 monitor_device_index);
2357
        if (monitor_device_index == 0) {
2358
            def = 1;
2359
        }
2360
        opts = qemu_chr_parse_compat(label, optarg);
2361
        if (!opts) {
2362
            fprintf(stderr, "parse error: %s\n", optarg);
2363
            exit(1);
2364
        }
2365
    }
2366

    
2367
    opts = qemu_opts_create(&qemu_mon_opts, label, 1);
2368
    if (!opts) {
2369
        fprintf(stderr, "duplicate chardev: %s\n", label);
2370
        exit(1);
2371
    }
2372
    qemu_opt_set(opts, "mode", mode);
2373
    qemu_opt_set(opts, "chardev", label);
2374
    if (def)
2375
        qemu_opt_set(opts, "default", "on");
2376
    monitor_device_index++;
2377
}
2378

    
2379
struct device_config {
2380
    enum {
2381
        DEV_USB,       /* -usbdevice     */
2382
        DEV_BT,        /* -bt            */
2383
        DEV_SERIAL,    /* -serial        */
2384
        DEV_PARALLEL,  /* -parallel      */
2385
        DEV_VIRTCON,   /* -virtioconsole */
2386
        DEV_DEBUGCON,  /* -debugcon */
2387
    } type;
2388
    const char *cmdline;
2389
    QTAILQ_ENTRY(device_config) next;
2390
};
2391
QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
2392

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

    
2397
    conf = qemu_mallocz(sizeof(*conf));
2398
    conf->type = type;
2399
    conf->cmdline = cmdline;
2400
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
2401
}
2402

    
2403
static int foreach_device_config(int type, int (*func)(const char *cmdline))
2404
{
2405
    struct device_config *conf;
2406
    int rc;
2407

    
2408
    QTAILQ_FOREACH(conf, &device_configs, next) {
2409
        if (conf->type != type)
2410
            continue;
2411
        rc = func(conf->cmdline);
2412
        if (0 != rc)
2413
            return rc;
2414
    }
2415
    return 0;
2416
}
2417

    
2418
static int serial_parse(const char *devname)
2419
{
2420
    static int index = 0;
2421
    char label[32];
2422

    
2423
    if (strcmp(devname, "none") == 0)
2424
        return 0;
2425
    if (index == MAX_SERIAL_PORTS) {
2426
        fprintf(stderr, "qemu: too many serial ports\n");
2427
        exit(1);
2428
    }
2429
    snprintf(label, sizeof(label), "serial%d", index);
2430
    serial_hds[index] = qemu_chr_open(label, devname, NULL);
2431
    if (!serial_hds[index]) {
2432
        fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
2433
                devname, strerror(errno));
2434
        return -1;
2435
    }
2436
    index++;
2437
    return 0;
2438
}
2439

    
2440
static int parallel_parse(const char *devname)
2441
{
2442
    static int index = 0;
2443
    char label[32];
2444

    
2445
    if (strcmp(devname, "none") == 0)
2446
        return 0;
2447
    if (index == MAX_PARALLEL_PORTS) {
2448
        fprintf(stderr, "qemu: too many parallel ports\n");
2449
        exit(1);
2450
    }
2451
    snprintf(label, sizeof(label), "parallel%d", index);
2452
    parallel_hds[index] = qemu_chr_open(label, devname, NULL);
2453
    if (!parallel_hds[index]) {
2454
        fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
2455
                devname, strerror(errno));
2456
        return -1;
2457
    }
2458
    index++;
2459
    return 0;
2460
}
2461

    
2462
static int virtcon_parse(const char *devname)
2463
{
2464
    static int index = 0;
2465
    char label[32];
2466
    QemuOpts *bus_opts, *dev_opts;
2467

    
2468
    if (strcmp(devname, "none") == 0)
2469
        return 0;
2470
    if (index == MAX_VIRTIO_CONSOLES) {
2471
        fprintf(stderr, "qemu: too many virtio consoles\n");
2472
        exit(1);
2473
    }
2474

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

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

    
2481
    snprintf(label, sizeof(label), "virtcon%d", index);
2482
    virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
2483
    if (!virtcon_hds[index]) {
2484
        fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
2485
                devname, strerror(errno));
2486
        return -1;
2487
    }
2488
    qemu_opt_set(dev_opts, "chardev", label);
2489

    
2490
    index++;
2491
    return 0;
2492
}
2493

    
2494
static int debugcon_parse(const char *devname)
2495
{   
2496
    QemuOpts *opts;
2497

    
2498
    if (!qemu_chr_open("debugcon", devname, NULL)) {
2499
        exit(1);
2500
    }
2501
    opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
2502
    if (!opts) {
2503
        fprintf(stderr, "qemu: already have a debugcon device\n");
2504
        exit(1);
2505
    }
2506
    qemu_opt_set(opts, "driver", "isa-debugcon");
2507
    qemu_opt_set(opts, "chardev", "debugcon");
2508
    return 0;
2509
}
2510

    
2511
static const QEMUOption *lookup_opt(int argc, char **argv,
2512
                                    const char **poptarg, int *poptind)
2513
{
2514
    const QEMUOption *popt;
2515
    int optind = *poptind;
2516
    char *r = argv[optind];
2517
    const char *optarg;
2518

    
2519
    loc_set_cmdline(argv, optind, 1);
2520
    optind++;
2521
    /* Treat --foo the same as -foo.  */
2522
    if (r[1] == '-')
2523
        r++;
2524
    popt = qemu_options;
2525
    for(;;) {
2526
        if (!popt->name) {
2527
            error_report("invalid option");
2528
            exit(1);
2529
        }
2530
        if (!strcmp(popt->name, r + 1))
2531
            break;
2532
        popt++;
2533
    }
2534
    if (popt->flags & HAS_ARG) {
2535
        if (optind >= argc) {
2536
            error_report("requires an argument");
2537
            exit(1);
2538
        }
2539
        optarg = argv[optind++];
2540
        loc_set_cmdline(argv, optind - 2, 2);
2541
    } else {
2542
        optarg = NULL;
2543
    }
2544

    
2545
    *poptarg = optarg;
2546
    *poptind = optind;
2547

    
2548
    return popt;
2549
}
2550

    
2551
int main(int argc, char **argv, char **envp)
2552
{
2553
    const char *gdbstub_dev = NULL;
2554
    int i;
2555
    int snapshot, linux_boot;
2556
    const char *icount_option = NULL;
2557
    const char *initrd_filename;
2558
    const char *kernel_filename, *kernel_cmdline;
2559
    char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
2560
    DisplayState *ds;
2561
    DisplayChangeListener *dcl;
2562
    int cyls, heads, secs, translation;
2563
    QemuOpts *hda_opts = NULL, *opts;
2564
    int optind;
2565
    const char *optarg;
2566
    const char *loadvm = NULL;
2567
    QEMUMachine *machine;
2568
    const char *cpu_model;
2569
#ifndef _WIN32
2570
    int fds[2];
2571
#endif
2572
    int tb_size;
2573
    const char *pid_file = NULL;
2574
    const char *incoming = NULL;
2575
#ifndef _WIN32
2576
    int fd = 0;
2577
    struct passwd *pwd = NULL;
2578
    const char *chroot_dir = NULL;
2579
    const char *run_as = NULL;
2580
#endif
2581
    int show_vnc_port = 0;
2582
    int defconfig = 1;
2583

    
2584
    error_set_progname(argv[0]);
2585

    
2586
    init_clocks();
2587

    
2588
    qemu_cache_utils_init(envp);
2589

    
2590
    QLIST_INIT (&vm_change_state_head);
2591
#ifndef _WIN32
2592
    {
2593
        struct sigaction act;
2594
        sigfillset(&act.sa_mask);
2595
        act.sa_flags = 0;
2596
        act.sa_handler = SIG_IGN;
2597
        sigaction(SIGPIPE, &act, NULL);
2598
    }
2599
#else
2600
    SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
2601
    /* Note: cpu_interrupt() is currently not SMP safe, so we force
2602
       QEMU to run on a single CPU */
2603
    {
2604
        HANDLE h;
2605
        DWORD mask, smask;
2606
        int i;
2607
        h = GetCurrentProcess();
2608
        if (GetProcessAffinityMask(h, &mask, &smask)) {
2609
            for(i = 0; i < 32; i++) {
2610
                if (mask & (1 << i))
2611
                    break;
2612
            }
2613
            if (i != 32) {
2614
                mask = 1 << i;
2615
                SetProcessAffinityMask(h, mask);
2616
            }
2617
        }
2618
    }
2619
#endif
2620

    
2621
    module_call_init(MODULE_INIT_MACHINE);
2622
    machine = find_default_machine();
2623
    cpu_model = NULL;
2624
    initrd_filename = NULL;
2625
    ram_size = 0;
2626
    snapshot = 0;
2627
    kernel_filename = NULL;
2628
    kernel_cmdline = "";
2629
    cyls = heads = secs = 0;
2630
    translation = BIOS_ATA_TRANSLATION_AUTO;
2631

    
2632
    for (i = 0; i < MAX_NODES; i++) {
2633
        node_mem[i] = 0;
2634
        node_cpumask[i] = 0;
2635
    }
2636

    
2637
    nb_numa_nodes = 0;
2638
    nb_nics = 0;
2639

    
2640
    tb_size = 0;
2641
    autostart= 1;
2642

    
2643
    /* first pass of option parsing */
2644
    optind = 1;
2645
    while (optind < argc) {
2646
        if (argv[optind][0] != '-') {
2647
            /* disk image */
2648
            optind++;
2649
            continue;
2650
        } else {
2651
            const QEMUOption *popt;
2652

    
2653
            popt = lookup_opt(argc, argv, &optarg, &optind);
2654
            switch (popt->index) {
2655
            case QEMU_OPTION_nodefconfig:
2656
                defconfig=0;
2657
                break;
2658
            }
2659
        }
2660
    }
2661

    
2662
    if (defconfig) {
2663
        int ret;
2664

    
2665
        ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf");
2666
        if (ret < 0 && ret != -ENOENT) {
2667
            exit(1);
2668
        }
2669

    
2670
        ret = qemu_read_config_file(arch_config_name);
2671
        if (ret < 0 && ret != -ENOENT) {
2672
            exit(1);
2673
        }
2674
    }
2675
    cpudef_init();
2676

    
2677
    /* second pass of option parsing */
2678
    optind = 1;
2679
    for(;;) {
2680
        if (optind >= argc)
2681
            break;
2682
        if (argv[optind][0] != '-') {
2683
            hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
2684
        } else {
2685
            const QEMUOption *popt;
2686

    
2687
            popt = lookup_opt(argc, argv, &optarg, &optind);
2688
            if (!(popt->arch_mask & arch_type)) {
2689
                printf("Option %s not supported for this target\n", popt->name);
2690
                exit(1);
2691
            }
2692
            switch(popt->index) {
2693
            case QEMU_OPTION_M:
2694
                machine = find_machine(optarg);
2695
                if (!machine) {
2696
                    QEMUMachine *m;
2697
                    printf("Supported machines are:\n");
2698
                    for(m = first_machine; m != NULL; m = m->next) {
2699
                        if (m->alias)
2700
                            printf("%-10s %s (alias of %s)\n",
2701
                                   m->alias, m->desc, m->name);
2702
                        printf("%-10s %s%s\n",
2703
                               m->name, m->desc,
2704
                               m->is_default ? " (default)" : "");
2705
                    }
2706
                    exit(*optarg != '?');
2707
                }
2708
                break;
2709
            case QEMU_OPTION_cpu:
2710
                /* hw initialization will check this */
2711
                if (*optarg == '?') {
2712
                    list_cpus(stdout, &fprintf, optarg);
2713
                    exit(0);
2714
                } else {
2715
                    cpu_model = optarg;
2716
                }
2717
                break;
2718
            case QEMU_OPTION_initrd:
2719
                initrd_filename = optarg;
2720
                break;
2721
            case QEMU_OPTION_hda:
2722
                if (cyls == 0)
2723
                    hda_opts = drive_add(optarg, HD_ALIAS, 0);
2724
                else
2725
                    hda_opts = drive_add(optarg, HD_ALIAS
2726
                             ",cyls=%d,heads=%d,secs=%d%s",
2727
                             0, cyls, heads, secs,
2728
                             translation == BIOS_ATA_TRANSLATION_LBA ?
2729
                                 ",trans=lba" :
2730
                             translation == BIOS_ATA_TRANSLATION_NONE ?
2731
                                 ",trans=none" : "");
2732
                 break;
2733
            case QEMU_OPTION_hdb:
2734
            case QEMU_OPTION_hdc:
2735
            case QEMU_OPTION_hdd:
2736
                drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
2737
                break;
2738
            case QEMU_OPTION_drive:
2739
                drive_add(NULL, "%s", optarg);
2740
                break;
2741
            case QEMU_OPTION_set:
2742
                if (qemu_set_option(optarg) != 0)
2743
                    exit(1);
2744
                break;
2745
            case QEMU_OPTION_global:
2746
                if (qemu_global_option(optarg) != 0)
2747
                    exit(1);
2748
                break;
2749
            case QEMU_OPTION_mtdblock:
2750
                drive_add(optarg, MTD_ALIAS);
2751
                break;
2752
            case QEMU_OPTION_sd:
2753
                drive_add(optarg, SD_ALIAS);
2754
                break;
2755
            case QEMU_OPTION_pflash:
2756
                drive_add(optarg, PFLASH_ALIAS);
2757
                break;
2758
            case QEMU_OPTION_snapshot:
2759
                snapshot = 1;
2760
                break;
2761
            case QEMU_OPTION_hdachs:
2762
                {
2763
                    const char *p;
2764
                    p = optarg;
2765
                    cyls = strtol(p, (char **)&p, 0);
2766
                    if (cyls < 1 || cyls > 16383)
2767
                        goto chs_fail;
2768
                    if (*p != ',')
2769
                        goto chs_fail;
2770
                    p++;
2771
                    heads = strtol(p, (char **)&p, 0);
2772
                    if (heads < 1 || heads > 16)
2773
                        goto chs_fail;
2774
                    if (*p != ',')
2775
                        goto chs_fail;
2776
                    p++;
2777
                    secs = strtol(p, (char **)&p, 0);
2778
                    if (secs < 1 || secs > 63)
2779
                        goto chs_fail;
2780
                    if (*p == ',') {
2781
                        p++;
2782
                        if (!strcmp(p, "none"))
2783
                            translation = BIOS_ATA_TRANSLATION_NONE;
2784
                        else if (!strcmp(p, "lba"))
2785
                            translation = BIOS_ATA_TRANSLATION_LBA;
2786
                        else if (!strcmp(p, "auto"))
2787
                            translation = BIOS_ATA_TRANSLATION_AUTO;
2788
                        else
2789
                            goto chs_fail;
2790
                    } else if (*p != '\0') {
2791
                    chs_fail:
2792
                        fprintf(stderr, "qemu: invalid physical CHS format\n");
2793
                        exit(1);
2794
                    }
2795
                    if (hda_opts != NULL) {
2796
                        char num[16];
2797
                        snprintf(num, sizeof(num), "%d", cyls);
2798
                        qemu_opt_set(hda_opts, "cyls", num);
2799
                        snprintf(num, sizeof(num), "%d", heads);
2800
                        qemu_opt_set(hda_opts, "heads", num);
2801
                        snprintf(num, sizeof(num), "%d", secs);
2802
                        qemu_opt_set(hda_opts, "secs", num);
2803
                        if (translation == BIOS_ATA_TRANSLATION_LBA)
2804
                            qemu_opt_set(hda_opts, "trans", "lba");
2805
                        if (translation == BIOS_ATA_TRANSLATION_NONE)
2806
                            qemu_opt_set(hda_opts, "trans", "none");
2807
                    }
2808
                }
2809
                break;
2810
            case QEMU_OPTION_numa:
2811
                if (nb_numa_nodes >= MAX_NODES) {
2812
                    fprintf(stderr, "qemu: too many NUMA nodes\n");
2813
                    exit(1);
2814
                }
2815
                numa_add(optarg);
2816
                break;
2817
            case QEMU_OPTION_nographic:
2818
                display_type = DT_NOGRAPHIC;
2819
                break;
2820
#ifdef CONFIG_CURSES
2821
            case QEMU_OPTION_curses:
2822
                display_type = DT_CURSES;
2823
                break;
2824
#endif
2825
            case QEMU_OPTION_portrait:
2826
                graphic_rotate = 1;
2827
                break;
2828
            case QEMU_OPTION_kernel:
2829
                kernel_filename = optarg;
2830
                break;
2831
            case QEMU_OPTION_append:
2832
                kernel_cmdline = optarg;
2833
                break;
2834
            case QEMU_OPTION_cdrom:
2835
                drive_add(optarg, CDROM_ALIAS);
2836
                break;
2837
            case QEMU_OPTION_boot:
2838
                {
2839
                    static const char * const params[] = {
2840
                        "order", "once", "menu", NULL
2841
                    };
2842
                    char buf[sizeof(boot_devices)];
2843
                    char *standard_boot_devices;
2844
                    int legacy = 0;
2845

    
2846
                    if (!strchr(optarg, '=')) {
2847
                        legacy = 1;
2848
                        pstrcpy(buf, sizeof(buf), optarg);
2849
                    } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
2850
                        fprintf(stderr,
2851
                                "qemu: unknown boot parameter '%s' in '%s'\n",
2852
                                buf, optarg);
2853
                        exit(1);
2854
                    }
2855

    
2856
                    if (legacy ||
2857
                        get_param_value(buf, sizeof(buf), "order", optarg)) {
2858
                        validate_bootdevices(buf);
2859
                        pstrcpy(boot_devices, sizeof(boot_devices), buf);
2860
                    }
2861
                    if (!legacy) {
2862
                        if (get_param_value(buf, sizeof(buf),
2863
                                            "once", optarg)) {
2864
                            validate_bootdevices(buf);
2865
                            standard_boot_devices = qemu_strdup(boot_devices);
2866
                            pstrcpy(boot_devices, sizeof(boot_devices), buf);
2867
                            qemu_register_reset(restore_boot_devices,
2868
                                                standard_boot_devices);
2869
                        }
2870
                        if (get_param_value(buf, sizeof(buf),
2871
                                            "menu", optarg)) {
2872
                            if (!strcmp(buf, "on")) {
2873
                                boot_menu = 1;
2874
                            } else if (!strcmp(buf, "off")) {
2875
                                boot_menu = 0;
2876
                            } else {
2877
                                fprintf(stderr,
2878
                                        "qemu: invalid option value '%s'\n",
2879
                                        buf);
2880
                                exit(1);
2881
                            }
2882
                        }
2883
                    }
2884
                }
2885
                break;
2886
            case QEMU_OPTION_fda:
2887
            case QEMU_OPTION_fdb:
2888
                drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
2889
                break;
2890
            case QEMU_OPTION_no_fd_bootchk:
2891
                fd_bootchk = 0;
2892
                break;
2893
            case QEMU_OPTION_netdev:
2894
                if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
2895
                    exit(1);
2896
                }
2897
                break;
2898
            case QEMU_OPTION_net:
2899
                if (net_client_parse(&qemu_net_opts, optarg) == -1) {
2900
                    exit(1);
2901
                }
2902
                break;
2903
#ifdef CONFIG_SLIRP
2904
            case QEMU_OPTION_tftp:
2905
                legacy_tftp_prefix = optarg;
2906
                break;
2907
            case QEMU_OPTION_bootp:
2908
                legacy_bootp_filename = optarg;
2909
                break;
2910
#ifndef _WIN32
2911
            case QEMU_OPTION_smb:
2912
                if (net_slirp_smb(optarg) < 0)
2913
                    exit(1);
2914
                break;
2915
#endif
2916
            case QEMU_OPTION_redir:
2917
                if (net_slirp_redir(optarg) < 0)
2918
                    exit(1);
2919
                break;
2920
#endif
2921
            case QEMU_OPTION_bt:
2922
                add_device_config(DEV_BT, optarg);
2923
                break;
2924
            case QEMU_OPTION_audio_help:
2925
                if (!(audio_available())) {
2926
                    printf("Option %s not supported for this target\n", popt->name);
2927
                    exit(1);
2928
                }
2929
                AUD_help ();
2930
                exit (0);
2931
                break;
2932
            case QEMU_OPTION_soundhw:
2933
                if (!(audio_available())) {
2934
                    printf("Option %s not supported for this target\n", popt->name);
2935
                    exit(1);
2936
                }
2937
                select_soundhw (optarg);
2938
                break;
2939
            case QEMU_OPTION_h:
2940
                help(0);
2941
                break;
2942
            case QEMU_OPTION_version:
2943
                version();
2944
                exit(0);
2945
                break;
2946
            case QEMU_OPTION_m: {
2947
                uint64_t value;
2948
                char *ptr;
2949

    
2950
                value = strtoul(optarg, &ptr, 10);
2951
                switch (*ptr) {
2952
                case 0: case 'M': case 'm':
2953
                    value <<= 20;
2954
                    break;
2955
                case 'G': case 'g':
2956
                    value <<= 30;
2957
                    break;
2958
                default:
2959
                    fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
2960
                    exit(1);
2961
                }
2962

    
2963
                /* On 32-bit hosts, QEMU is limited by virtual address space */
2964
                if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
2965
                    fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
2966
                    exit(1);
2967
                }
2968
                if (value != (uint64_t)(ram_addr_t)value) {
2969
                    fprintf(stderr, "qemu: ram size too large\n");
2970
                    exit(1);
2971
                }
2972
                ram_size = value;
2973
                break;
2974
            }
2975
            case QEMU_OPTION_mempath:
2976
                mem_path = optarg;
2977
                break;
2978
#ifdef MAP_POPULATE
2979
            case QEMU_OPTION_mem_prealloc:
2980
                mem_prealloc = 1;
2981
                break;
2982
#endif
2983
            case QEMU_OPTION_d:
2984
                set_cpu_log(optarg);
2985
                break;
2986
            case QEMU_OPTION_s:
2987
                gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
2988
                break;
2989
            case QEMU_OPTION_gdb:
2990
                gdbstub_dev = optarg;
2991
                break;
2992
            case QEMU_OPTION_L:
2993
                data_dir = optarg;
2994
                break;
2995
            case QEMU_OPTION_bios:
2996
                bios_name = optarg;
2997
                break;
2998
            case QEMU_OPTION_singlestep:
2999
                singlestep = 1;
3000
                break;
3001
            case QEMU_OPTION_S:
3002
                autostart = 0;
3003
                break;
3004
            case QEMU_OPTION_k:
3005
                keyboard_layout = optarg;
3006
                break;
3007
            case QEMU_OPTION_localtime:
3008
                rtc_utc = 0;
3009
                break;
3010
            case QEMU_OPTION_vga:
3011
                select_vgahw (optarg);
3012
                break;
3013
            case QEMU_OPTION_g:
3014
                {
3015
                    const char *p;
3016
                    int w, h, depth;
3017
                    p = optarg;
3018
                    w = strtol(p, (char **)&p, 10);
3019
                    if (w <= 0) {
3020
                    graphic_error:
3021
                        fprintf(stderr, "qemu: invalid resolution or depth\n");
3022
                        exit(1);
3023
                    }
3024
                    if (*p != 'x')
3025
                        goto graphic_error;
3026
                    p++;
3027
                    h = strtol(p, (char **)&p, 10);
3028
                    if (h <= 0)
3029
                        goto graphic_error;
3030
                    if (*p == 'x') {
3031
                        p++;
3032
                        depth = strtol(p, (char **)&p, 10);
3033
                        if (depth != 8 && depth != 15 && depth != 16 &&
3034
                            depth != 24 && depth != 32)
3035
                            goto graphic_error;
3036
                    } else if (*p == '\0') {
3037
                        depth = graphic_depth;
3038
                    } else {
3039
                        goto graphic_error;
3040
                    }
3041

    
3042
                    graphic_width = w;
3043
                    graphic_height = h;
3044
                    graphic_depth = depth;
3045
                }
3046
                break;
3047
            case QEMU_OPTION_echr:
3048
                {
3049
                    char *r;
3050
                    term_escape_char = strtol(optarg, &r, 0);
3051
                    if (r == optarg)
3052
                        printf("Bad argument to echr\n");
3053
                    break;
3054
                }
3055
            case QEMU_OPTION_monitor:
3056
                monitor_parse(optarg, "readline");
3057
                default_monitor = 0;
3058
                break;
3059
            case QEMU_OPTION_qmp:
3060
                monitor_parse(optarg, "control");
3061
                default_monitor = 0;
3062
                break;
3063
            case QEMU_OPTION_mon:
3064
                opts = qemu_opts_parse(&qemu_mon_opts, optarg, 1);
3065
                if (!opts) {
3066
                    exit(1);
3067
                }
3068
                default_monitor = 0;
3069
                break;
3070
            case QEMU_OPTION_chardev:
3071
                opts = qemu_opts_parse(&qemu_chardev_opts, optarg, 1);
3072
                if (!opts) {
3073
                    exit(1);
3074
                }
3075
                break;
3076
#ifdef CONFIG_LINUX
3077
            case QEMU_OPTION_fsdev:
3078
                opts = qemu_opts_parse(&qemu_fsdev_opts, optarg, 1);
3079
                if (!opts) {
3080
                    fprintf(stderr, "parse error: %s\n", optarg);
3081
                    exit(1);
3082
                }
3083
                break;
3084
            case QEMU_OPTION_virtfs: {
3085
                char *arg_fsdev = NULL;
3086
                char *arg_9p = NULL;
3087
                int len = 0;
3088

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

    
3095
                len = strlen(",id=,path=");
3096
                len += strlen(qemu_opt_get(opts, "fstype"));
3097
                len += strlen(qemu_opt_get(opts, "mount_tag"));
3098
                len += strlen(qemu_opt_get(opts, "path"));
3099
                arg_fsdev = qemu_malloc((len + 1) * sizeof(*arg_fsdev));
3100

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

    
3107
                sprintf(arg_fsdev, "%s,id=%s,path=%s",
3108
                                qemu_opt_get(opts, "fstype"),
3109
                                qemu_opt_get(opts, "mount_tag"),
3110
                                qemu_opt_get(opts, "path"));
3111

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

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

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

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

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

    
3136
                qemu_free(arg_fsdev);
3137
                qemu_free(arg_9p);
3138
                break;
3139
            }
3140
#endif
3141
            case QEMU_OPTION_serial:
3142
                add_device_config(DEV_SERIAL, optarg);
3143
                default_serial = 0;
3144
                if (strncmp(optarg, "mon:", 4) == 0) {
3145
                    default_monitor = 0;
3146
                }
3147
                break;
3148
            case QEMU_OPTION_watchdog:
3149
                if (watchdog) {
3150
                    fprintf(stderr,
3151
                            "qemu: only one watchdog option may be given\n");
3152
                    return 1;
3153
                }
3154
                watchdog = optarg;
3155
                break;
3156
            case QEMU_OPTION_watchdog_action:
3157
                if (select_watchdog_action(optarg) == -1) {
3158
                    fprintf(stderr, "Unknown -watchdog-action parameter\n");
3159
                    exit(1);
3160
                }
3161
                break;
3162
            case QEMU_OPTION_virtiocon:
3163
                add_device_config(DEV_VIRTCON, optarg);
3164
                default_virtcon = 0;
3165
                if (strncmp(optarg, "mon:", 4) == 0) {
3166
                    default_monitor = 0;
3167
                }
3168
                break;
3169
            case QEMU_OPTION_parallel:
3170
                add_device_config(DEV_PARALLEL, optarg);
3171
                default_parallel = 0;
3172
                if (strncmp(optarg, "mon:", 4) == 0) {
3173
                    default_monitor = 0;
3174
                }
3175
                break;
3176
            case QEMU_OPTION_debugcon:
3177
                add_device_config(DEV_DEBUGCON, optarg);
3178
                break;
3179
            case QEMU_OPTION_loadvm:
3180
                loadvm = optarg;
3181
                break;
3182
            case QEMU_OPTION_full_screen:
3183
                full_screen = 1;
3184
                break;
3185
#ifdef CONFIG_SDL
3186
            case QEMU_OPTION_no_frame:
3187
                no_frame = 1;
3188
                break;
3189
            case QEMU_OPTION_alt_grab:
3190
                alt_grab = 1;
3191
                break;
3192
            case QEMU_OPTION_ctrl_grab:
3193
                ctrl_grab = 1;
3194
                break;
3195
            case QEMU_OPTION_no_quit:
3196
                no_quit = 1;
3197
                break;
3198
            case QEMU_OPTION_sdl:
3199
                display_type = DT_SDL;
3200
                break;
3201
#endif
3202
            case QEMU_OPTION_pidfile:
3203
                pid_file = optarg;
3204
                break;
3205
            case QEMU_OPTION_win2k_hack:
3206
                win2k_install_hack = 1;
3207
                break;
3208
            case QEMU_OPTION_rtc_td_hack:
3209
                rtc_td_hack = 1;
3210
                break;
3211
            case QEMU_OPTION_acpitable:
3212
                do_acpitable_option(optarg);
3213
                break;
3214
            case QEMU_OPTION_smbios:
3215
                do_smbios_option(optarg);
3216
                break;
3217
            case QEMU_OPTION_enable_kvm:
3218
                kvm_allowed = 1;
3219
                break;
3220
            case QEMU_OPTION_usb:
3221
                usb_enabled = 1;
3222
                break;
3223
            case QEMU_OPTION_usbdevice:
3224
                usb_enabled = 1;
3225
                add_device_config(DEV_USB, optarg);
3226
                break;
3227
            case QEMU_OPTION_device:
3228
                if (!qemu_opts_parse(&qemu_device_opts, optarg, 1)) {
3229
                    exit(1);
3230
                }
3231
                break;
3232
            case QEMU_OPTION_smp:
3233
                smp_parse(optarg);
3234
                if (smp_cpus < 1) {
3235
                    fprintf(stderr, "Invalid number of CPUs\n");
3236
                    exit(1);
3237
                }
3238
                if (max_cpus < smp_cpus) {
3239
                    fprintf(stderr, "maxcpus must be equal to or greater than "
3240
                            "smp\n");
3241
                    exit(1);
3242
                }
3243
                if (max_cpus > 255) {
3244
                    fprintf(stderr, "Unsupported number of maxcpus\n");
3245
                    exit(1);
3246
                }
3247
                break;
3248
            case QEMU_OPTION_vnc:
3249
                display_type = DT_VNC;
3250
                vnc_display = optarg;
3251
                break;
3252
            case QEMU_OPTION_no_acpi:
3253
                acpi_enabled = 0;
3254
                break;
3255
            case QEMU_OPTION_no_hpet:
3256
                no_hpet = 1;
3257
                break;
3258
            case QEMU_OPTION_balloon:
3259
                if (balloon_parse(optarg) < 0) {
3260
                    fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
3261
                    exit(1);
3262
                }
3263
                break;
3264
            case QEMU_OPTION_no_reboot:
3265
                no_reboot = 1;
3266
                break;
3267
            case QEMU_OPTION_no_shutdown:
3268
                no_shutdown = 1;
3269
                break;
3270
            case QEMU_OPTION_show_cursor:
3271
                cursor_hide = 0;
3272
                break;
3273
            case QEMU_OPTION_uuid:
3274
                if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
3275
                    fprintf(stderr, "Fail to parse UUID string."
3276
                            " Wrong format.\n");
3277
                    exit(1);
3278
                }
3279
                break;
3280
#ifndef _WIN32
3281
            case QEMU_OPTION_daemonize:
3282
                daemonize = 1;
3283
                break;
3284
#endif
3285
            case QEMU_OPTION_option_rom:
3286
                if (nb_option_roms >= MAX_OPTION_ROMS) {
3287
                    fprintf(stderr, "Too many option ROMs\n");
3288
                    exit(1);
3289
                }
3290
                option_rom[nb_option_roms] = optarg;
3291
                nb_option_roms++;
3292
                break;
3293
            case QEMU_OPTION_semihosting:
3294
                semihosting_enabled = 1;
3295
                break;
3296
            case QEMU_OPTION_name:
3297
                qemu_name = qemu_strdup(optarg);
3298
                 {
3299
                     char *p = strchr(qemu_name, ',');
3300
                     if (p != NULL) {
3301
                        *p++ = 0;
3302
                        if (strncmp(p, "process=", 8)) {
3303
                            fprintf(stderr, "Unknown subargument %s to -name", p);
3304
                            exit(1);
3305
                        }
3306
                        p += 8;
3307
                        set_proc_name(p);
3308
                     }        
3309
                 }        
3310
                break;
3311
            case QEMU_OPTION_prom_env:
3312
                if (nb_prom_envs >= MAX_PROM_ENVS) {
3313
                    fprintf(stderr, "Too many prom variables\n");
3314
                    exit(1);
3315
                }
3316
                prom_envs[nb_prom_envs] = optarg;
3317
                nb_prom_envs++;
3318
                break;
3319
            case QEMU_OPTION_old_param:
3320
                old_param = 1;
3321
                break;
3322
            case QEMU_OPTION_clock:
3323
                configure_alarms(optarg);
3324
                break;
3325
            case QEMU_OPTION_startdate:
3326
                configure_rtc_date_offset(optarg, 1);
3327
                break;
3328
            case QEMU_OPTION_rtc:
3329
                opts = qemu_opts_parse(&qemu_rtc_opts, optarg, 0);
3330
                if (!opts) {
3331
                    exit(1);
3332
                }
3333
                configure_rtc(opts);
3334
                break;
3335
            case QEMU_OPTION_tb_size:
3336
                tb_size = strtol(optarg, NULL, 0);
3337
                if (tb_size < 0)
3338
                    tb_size = 0;
3339
                break;
3340
            case QEMU_OPTION_icount:
3341
                icount_option = optarg;
3342
                break;
3343
            case QEMU_OPTION_incoming:
3344
                incoming = optarg;
3345
                break;
3346
            case QEMU_OPTION_nodefaults:
3347
                default_serial = 0;
3348
                default_parallel = 0;
3349
                default_virtcon = 0;
3350
                default_monitor = 0;
3351
                default_vga = 0;
3352
                default_net = 0;
3353
                default_floppy = 0;
3354
                default_cdrom = 0;
3355
                default_sdcard = 0;
3356
                break;
3357
#ifndef _WIN32
3358
            case QEMU_OPTION_chroot:
3359
                chroot_dir = optarg;
3360
                break;
3361
            case QEMU_OPTION_runas:
3362
                run_as = optarg;
3363
                break;
3364
#endif
3365
            case QEMU_OPTION_xen_domid:
3366
                if (!(xen_available())) {
3367
                    printf("Option %s not supported for this target\n", popt->name);
3368
                    exit(1);
3369
                }
3370
                xen_domid = atoi(optarg);
3371
                break;
3372
            case QEMU_OPTION_xen_create:
3373
                if (!(xen_available())) {
3374
                    printf("Option %s not supported for this target\n", popt->name);
3375
                    exit(1);
3376
                }
3377
                xen_mode = XEN_CREATE;
3378
                break;
3379
            case QEMU_OPTION_xen_attach:
3380
                if (!(xen_available())) {
3381
                    printf("Option %s not supported for this target\n", popt->name);
3382
                    exit(1);
3383
                }
3384
                xen_mode = XEN_ATTACH;
3385
                break;
3386
            case QEMU_OPTION_readconfig:
3387
                {
3388
                    int ret = qemu_read_config_file(optarg);
3389
                    if (ret < 0) {
3390
                        fprintf(stderr, "read config %s: %s\n", optarg,
3391
                            strerror(-ret));
3392
                        exit(1);
3393
                    }
3394
                    break;
3395
                }
3396
            case QEMU_OPTION_writeconfig:
3397
                {
3398
                    FILE *fp;
3399
                    if (strcmp(optarg, "-") == 0) {
3400
                        fp = stdout;
3401
                    } else {
3402
                        fp = fopen(optarg, "w");
3403
                        if (fp == NULL) {
3404
                            fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
3405
                            exit(1);
3406
                        }
3407
                    }
3408
                    qemu_config_write(fp);
3409
                    fclose(fp);
3410
                    break;
3411
                }
3412
            }
3413
        }
3414
    }
3415
    loc_set_none();
3416

    
3417
    /* If no data_dir is specified then try to find it relative to the
3418
       executable path.  */
3419
    if (!data_dir) {
3420
        data_dir = find_datadir(argv[0]);
3421
    }
3422
    /* If all else fails use the install patch specified when building.  */
3423
    if (!data_dir) {
3424
        data_dir = CONFIG_QEMU_SHAREDIR;
3425
    }
3426

    
3427
    /*
3428
     * Default to max_cpus = smp_cpus, in case the user doesn't
3429
     * specify a max_cpus value.
3430
     */
3431
    if (!max_cpus)
3432
        max_cpus = smp_cpus;
3433

    
3434
    machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
3435
    if (smp_cpus > machine->max_cpus) {
3436
        fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
3437
                "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
3438
                machine->max_cpus);
3439
        exit(1);
3440
    }
3441

    
3442
    qemu_opts_foreach(&qemu_device_opts, default_driver_check, NULL, 0);
3443
    qemu_opts_foreach(&qemu_global_opts, default_driver_check, NULL, 0);
3444

    
3445
    if (machine->no_serial) {
3446
        default_serial = 0;
3447
    }
3448
    if (machine->no_parallel) {
3449
        default_parallel = 0;
3450
    }
3451
    if (!machine->use_virtcon) {
3452
        default_virtcon = 0;
3453
    }
3454
    if (machine->no_vga) {
3455
        default_vga = 0;
3456
    }
3457
    if (machine->no_floppy) {
3458
        default_floppy = 0;
3459
    }
3460
    if (machine->no_cdrom) {
3461
        default_cdrom = 0;
3462
    }
3463
    if (machine->no_sdcard) {
3464
        default_sdcard = 0;
3465
    }
3466

    
3467
    if (display_type == DT_NOGRAPHIC) {
3468
        if (default_parallel)
3469
            add_device_config(DEV_PARALLEL, "null");
3470
        if (default_serial && default_monitor) {
3471
            add_device_config(DEV_SERIAL, "mon:stdio");
3472
        } else if (default_virtcon && default_monitor) {
3473
            add_device_config(DEV_VIRTCON, "mon:stdio");
3474
        } else {
3475
            if (default_serial)
3476
                add_device_config(DEV_SERIAL, "stdio");
3477
            if (default_virtcon)
3478
                add_device_config(DEV_VIRTCON, "stdio");
3479
            if (default_monitor)
3480
                monitor_parse("stdio", "readline");
3481
        }
3482
    } else {
3483
        if (default_serial)
3484
            add_device_config(DEV_SERIAL, "vc:80Cx24C");
3485
        if (default_parallel)
3486
            add_device_config(DEV_PARALLEL, "vc:80Cx24C");
3487
        if (default_monitor)
3488
            monitor_parse("vc:80Cx24C", "readline");
3489
        if (default_virtcon)
3490
            add_device_config(DEV_VIRTCON, "vc:80Cx24C");
3491
    }
3492
    if (default_vga)
3493
        vga_interface_type = VGA_CIRRUS;
3494

    
3495
    socket_init();
3496

    
3497
    if (qemu_opts_foreach(&qemu_chardev_opts, chardev_init_func, NULL, 1) != 0)
3498
        exit(1);
3499
#ifdef CONFIG_LINUX
3500
    if (qemu_opts_foreach(&qemu_fsdev_opts, fsdev_init_func, NULL, 1) != 0) {
3501
        exit(1);
3502
    }
3503
#endif
3504

    
3505
#ifndef _WIN32
3506
    if (daemonize) {
3507
        pid_t pid;
3508

    
3509
        if (pipe(fds) == -1)
3510
            exit(1);
3511

    
3512
        pid = fork();
3513
        if (pid > 0) {
3514
            uint8_t status;
3515
            ssize_t len;
3516

    
3517
            close(fds[1]);
3518

    
3519
        again:
3520
            len = read(fds[0], &status, 1);
3521
            if (len == -1 && (errno == EINTR))
3522
                goto again;
3523

    
3524
            if (len != 1)
3525
                exit(1);
3526
            else if (status == 1) {
3527
                fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
3528
                exit(1);
3529
            } else
3530
                exit(0);
3531
        } else if (pid < 0)
3532
            exit(1);
3533

    
3534
        close(fds[0]);
3535
        qemu_set_cloexec(fds[1]);
3536

    
3537
        setsid();
3538

    
3539
        pid = fork();
3540
        if (pid > 0)
3541
            exit(0);
3542
        else if (pid < 0)
3543
            exit(1);
3544

    
3545
        umask(027);
3546

    
3547
        signal(SIGTSTP, SIG_IGN);
3548
        signal(SIGTTOU, SIG_IGN);
3549
        signal(SIGTTIN, SIG_IGN);
3550
    }
3551
#endif
3552

    
3553
    if (pid_file && qemu_create_pidfile(pid_file) != 0) {
3554
#ifndef _WIN32
3555
        if (daemonize) {
3556
            uint8_t status = 1;
3557
            if (write(fds[1], &status, 1) != 1) {
3558
                perror("daemonize. Writing to pipe\n");
3559
            }
3560
        } else
3561
#endif
3562
            fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
3563
        exit(1);
3564
    }
3565

    
3566
    if (kvm_allowed) {
3567
        int ret = kvm_init(smp_cpus);
3568
        if (ret < 0) {
3569
            if (!kvm_available()) {
3570
                printf("KVM not supported for this target\n");
3571
            } else {
3572
                fprintf(stderr, "failed to initialize KVM: %s\n", strerror(-ret));
3573
            }
3574
            exit(1);
3575
        }
3576
    }
3577

    
3578
    if (qemu_init_main_loop()) {
3579
        fprintf(stderr, "qemu_init_main_loop failed\n");
3580
        exit(1);
3581
    }
3582
    linux_boot = (kernel_filename != NULL);
3583

    
3584
    if (!linux_boot && *kernel_cmdline != '\0') {
3585
        fprintf(stderr, "-append only allowed with -kernel option\n");
3586
        exit(1);
3587
    }
3588

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

    
3594
#ifndef _WIN32
3595
    /* Win32 doesn't support line-buffering and requires size >= 2 */
3596
    setvbuf(stdout, NULL, _IOLBF, 0);
3597
#endif
3598

    
3599
    if (init_timer_alarm() < 0) {
3600
        fprintf(stderr, "could not initialize alarm timer\n");
3601
        exit(1);
3602
    }
3603
    configure_icount(icount_option);
3604

    
3605
    if (net_init_clients() < 0) {
3606
        exit(1);
3607
    }
3608

    
3609
    /* init the bluetooth world */
3610
    if (foreach_device_config(DEV_BT, bt_parse))
3611
        exit(1);
3612

    
3613
    /* init the memory */
3614
    if (ram_size == 0)
3615
        ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
3616

    
3617
    /* init the dynamic translator */
3618
    cpu_exec_init_all(tb_size * 1024 * 1024);
3619

    
3620
    bdrv_init_with_whitelist();
3621

    
3622
    blk_mig_init();
3623

    
3624
    if (default_cdrom) {
3625
        /* we always create the cdrom drive, even if no disk is there */
3626
        drive_add(NULL, CDROM_ALIAS);
3627
    }
3628

    
3629
    if (default_floppy) {
3630
        /* we always create at least one floppy */
3631
        drive_add(NULL, FD_ALIAS, 0);
3632
    }
3633

    
3634
    if (default_sdcard) {
3635
        /* we always create one sd slot, even if no card is in it */
3636
        drive_add(NULL, SD_ALIAS);
3637
    }
3638

    
3639
    /* open the virtual block devices */
3640
    if (snapshot)
3641
        qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
3642
    if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, &machine->use_scsi, 1) != 0)
3643
        exit(1);
3644

    
3645
    register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL, 
3646
                         ram_load, NULL);
3647

    
3648
    if (nb_numa_nodes > 0) {
3649
        int i;
3650

    
3651
        if (nb_numa_nodes > smp_cpus) {
3652
            nb_numa_nodes = smp_cpus;
3653
        }
3654

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

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

    
3675
        for (i = 0; i < nb_numa_nodes; i++) {
3676
            if (node_cpumask[i] != 0)
3677
                break;
3678
        }
3679
        /* assigning the VCPUs round-robin is easier to implement, guest OSes
3680
         * must cope with this anyway, because there are BIOSes out there in
3681
         * real machines which also use this scheme.
3682
         */
3683
        if (i == nb_numa_nodes) {
3684
            for (i = 0; i < smp_cpus; i++) {
3685
                node_cpumask[i % nb_numa_nodes] |= 1 << i;
3686
            }
3687
        }
3688
    }
3689

    
3690
    if (qemu_opts_foreach(&qemu_mon_opts, mon_init_func, NULL, 1) != 0) {
3691
        exit(1);
3692
    }
3693

    
3694
    if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
3695
        exit(1);
3696
    if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
3697
        exit(1);
3698
    if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
3699
        exit(1);
3700
    if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
3701
        exit(1);
3702

    
3703
    module_call_init(MODULE_INIT_DEVICE);
3704

    
3705
    if (qemu_opts_foreach(&qemu_device_opts, device_help_func, NULL, 0) != 0)
3706
        exit(0);
3707

    
3708
    if (watchdog) {
3709
        i = select_watchdog(watchdog);
3710
        if (i > 0)
3711
            exit (i == 1 ? 1 : 0);
3712
    }
3713

    
3714
    if (machine->compat_props) {
3715
        qdev_prop_register_global_list(machine->compat_props);
3716
    }
3717
    qemu_add_globals();
3718

    
3719
    machine->init(ram_size, boot_devices,
3720
                  kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
3721

    
3722
    cpu_synchronize_all_post_init();
3723

    
3724
#ifndef _WIN32
3725
    /* must be after terminal init, SDL library changes signal handlers */
3726
    sighandler_setup();
3727
#endif
3728

    
3729
    set_numa_modes();
3730

    
3731
    current_machine = machine;
3732

    
3733
    /* init USB devices */
3734
    if (usb_enabled) {
3735
        if (foreach_device_config(DEV_USB, usb_parse) < 0)
3736
            exit(1);
3737
    }
3738

    
3739
    /* init generic devices */
3740
    if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
3741
        exit(1);
3742

    
3743
    net_check_clients();
3744

    
3745
    /* just use the first displaystate for the moment */
3746
    ds = get_displaystate();
3747

    
3748
    if (display_type == DT_DEFAULT) {
3749
#if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
3750
        display_type = DT_SDL;
3751
#else
3752
        display_type = DT_VNC;
3753
        vnc_display = "localhost:0,to=99";
3754
        show_vnc_port = 1;
3755
#endif
3756
    }
3757
        
3758

    
3759
    switch (display_type) {
3760
    case DT_NOGRAPHIC:
3761
        break;
3762
#if defined(CONFIG_CURSES)
3763
    case DT_CURSES:
3764
        curses_display_init(ds, full_screen);
3765
        break;
3766
#endif
3767
#if defined(CONFIG_SDL)
3768
    case DT_SDL:
3769
        sdl_display_init(ds, full_screen, no_frame);
3770
        break;
3771
#elif defined(CONFIG_COCOA)
3772
    case DT_SDL:
3773
        cocoa_display_init(ds, full_screen);
3774
        break;
3775
#endif
3776
    case DT_VNC:
3777
        vnc_display_init(ds);
3778
        if (vnc_display_open(ds, vnc_display) < 0)
3779
            exit(1);
3780

    
3781
        if (show_vnc_port) {
3782
            printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
3783
        }
3784
        break;
3785
    default:
3786
        break;
3787
    }
3788
    dpy_resize(ds);
3789

    
3790
    dcl = ds->listeners;
3791
    while (dcl != NULL) {
3792
        if (dcl->dpy_refresh != NULL) {
3793
            ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
3794
            qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
3795
        }
3796
        dcl = dcl->next;
3797
    }
3798

    
3799
    if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
3800
        nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
3801
        qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
3802
    }
3803

    
3804
    text_consoles_set_display(ds);
3805

    
3806
    if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
3807
        fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
3808
                gdbstub_dev);
3809
        exit(1);
3810
    }
3811

    
3812
    qdev_machine_creation_done();
3813

    
3814
    if (rom_load_all() != 0) {
3815
        fprintf(stderr, "rom loading failed\n");
3816
        exit(1);
3817
    }
3818

    
3819
    qemu_system_reset();
3820
    if (loadvm) {
3821
        if (load_vmstate(loadvm) < 0) {
3822
            autostart = 0;
3823
        }
3824
    }
3825

    
3826
    if (incoming) {
3827
        qemu_start_incoming_migration(incoming);
3828
    } else if (autostart) {
3829
        vm_start();
3830
    }
3831

    
3832
#ifndef _WIN32
3833
    if (daemonize) {
3834
        uint8_t status = 0;
3835
        ssize_t len;
3836

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

    
3842
        if (len != 1)
3843
            exit(1);
3844

    
3845
        if (chdir("/")) {
3846
            perror("not able to chdir to /");
3847
            exit(1);
3848
        }
3849
        TFR(fd = qemu_open("/dev/null", O_RDWR));
3850
        if (fd == -1)
3851
            exit(1);
3852
    }
3853

    
3854
    if (run_as) {
3855
        pwd = getpwnam(run_as);
3856
        if (!pwd) {
3857
            fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
3858
            exit(1);
3859
        }
3860
    }
3861

    
3862
    if (chroot_dir) {
3863
        if (chroot(chroot_dir) < 0) {
3864
            fprintf(stderr, "chroot failed\n");
3865
            exit(1);
3866
        }
3867
        if (chdir("/")) {
3868
            perror("not able to chdir to /");
3869
            exit(1);
3870
        }
3871
    }
3872

    
3873
    if (run_as) {
3874
        if (setgid(pwd->pw_gid) < 0) {
3875
            fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
3876
            exit(1);
3877
        }
3878
        if (setuid(pwd->pw_uid) < 0) {
3879
            fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
3880
            exit(1);
3881
        }
3882
        if (setuid(0) != -1) {
3883
            fprintf(stderr, "Dropping privileges failed\n");
3884
            exit(1);
3885
        }
3886
    }
3887

    
3888
    if (daemonize) {
3889
        dup2(fd, 0);
3890
        dup2(fd, 1);
3891
        dup2(fd, 2);
3892

    
3893
        close(fd);
3894
    }
3895
#endif
3896

    
3897
    main_loop();
3898
    quit_timers();
3899
    net_cleanup();
3900

    
3901
    return 0;
3902
}