Statistics
| Branch: | Revision:

root / vl.c @ 7a5e5838

History | View | Annotate | Download (157.3 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
#else
56
#include <util.h>
57
#endif
58
#else
59
#ifdef __linux__
60
#include <pty.h>
61
#include <malloc.h>
62
#include <linux/rtc.h>
63
#include <sys/prctl.h>
64

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

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

    
94
#if defined(__OpenBSD__)
95
#include <util.h>
96
#endif
97

    
98
#if defined(CONFIG_VDE)
99
#include <libvdeplug.h>
100
#endif
101

    
102
#ifdef _WIN32
103
#include <windows.h>
104
#include <mmsystem.h>
105
#endif
106

    
107
#ifdef CONFIG_SDL
108
#if defined(__APPLE__) || defined(main)
109
#include <SDL.h>
110
int qemu_main(int argc, char **argv, char **envp);
111
int main(int argc, char **argv)
112
{
113
    return qemu_main(argc, argv, NULL);
114
}
115
#undef main
116
#define main qemu_main
117
#endif
118
#endif /* CONFIG_SDL */
119

    
120
#ifdef CONFIG_COCOA
121
#undef main
122
#define main qemu_main
123
#endif /* CONFIG_COCOA */
124

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

    
161
#include "disas.h"
162

    
163
#include "exec-all.h"
164

    
165
#include "qemu_socket.h"
166

    
167
#include "slirp/libslirp.h"
168

    
169
#include "qemu-queue.h"
170

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

    
174
#define DEFAULT_RAM_SIZE 128
175

    
176
#define MAX_VIRTIO_CONSOLES 1
177

    
178
static const char *data_dir;
179
const char *bios_name = NULL;
180
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
181
   to store the VM snapshots */
182
struct drivelist drives = QTAILQ_HEAD_INITIALIZER(drives);
183
struct driveoptlist driveopts = QTAILQ_HEAD_INITIALIZER(driveopts);
184
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
185
DisplayType display_type = DT_DEFAULT;
186
const char* keyboard_layout = NULL;
187
ram_addr_t ram_size;
188
const char *mem_path = NULL;
189
#ifdef MAP_POPULATE
190
int mem_prealloc = 0; /* force preallocation of physical target memory */
191
#endif
192
int nb_nics;
193
NICInfo nd_table[MAX_NICS];
194
int vm_running;
195
int autostart;
196
static int rtc_utc = 1;
197
static int rtc_date_offset = -1; /* -1 means no change */
198
QEMUClock *rtc_clock;
199
int vga_interface_type = VGA_NONE;
200
#ifdef TARGET_SPARC
201
int graphic_width = 1024;
202
int graphic_height = 768;
203
int graphic_depth = 8;
204
#else
205
int graphic_width = 800;
206
int graphic_height = 600;
207
int graphic_depth = 15;
208
#endif
209
static int full_screen = 0;
210
#ifdef CONFIG_SDL
211
static int no_frame = 0;
212
#endif
213
int no_quit = 0;
214
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
215
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
216
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
217
#ifdef TARGET_I386
218
int win2k_install_hack = 0;
219
int rtc_td_hack = 0;
220
#endif
221
int usb_enabled = 0;
222
int singlestep = 0;
223
int smp_cpus = 1;
224
int max_cpus = 0;
225
int smp_cores = 1;
226
int smp_threads = 1;
227
const char *vnc_display;
228
int acpi_enabled = 1;
229
int no_hpet = 0;
230
int fd_bootchk = 1;
231
int no_reboot = 0;
232
int no_shutdown = 0;
233
int cursor_hide = 1;
234
int graphic_rotate = 0;
235
uint8_t irq0override = 1;
236
#ifndef _WIN32
237
int daemonize = 0;
238
#endif
239
const char *watchdog;
240
const char *option_rom[MAX_OPTION_ROMS];
241
int nb_option_roms;
242
int semihosting_enabled = 0;
243
#ifdef TARGET_ARM
244
int old_param = 0;
245
#endif
246
const char *qemu_name;
247
int alt_grab = 0;
248
int ctrl_grab = 0;
249
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
250
unsigned int nb_prom_envs = 0;
251
const char *prom_envs[MAX_PROM_ENVS];
252
#endif
253
int boot_menu;
254

    
255
int nb_numa_nodes;
256
uint64_t node_mem[MAX_NODES];
257
uint64_t node_cpumask[MAX_NODES];
258

    
259
static CPUState *cur_cpu;
260
static CPUState *next_cpu;
261
/* Conversion factor from emulated instructions to virtual clock ticks.  */
262
static int icount_time_shift;
263
/* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
264
#define MAX_ICOUNT_SHIFT 10
265
/* Compensate for varying guest execution speed.  */
266
static int64_t qemu_icount_bias;
267
static QEMUTimer *icount_rt_timer;
268
static QEMUTimer *icount_vm_timer;
269
static QEMUTimer *nographic_timer;
270

    
271
uint8_t qemu_uuid[16];
272

    
273
static QEMUBootSetHandler *boot_set_handler;
274
static void *boot_set_opaque;
275

    
276
#ifdef SIGRTMIN
277
#define SIG_IPI (SIGRTMIN+4)
278
#else
279
#define SIG_IPI SIGUSR1
280
#endif
281

    
282
static int default_serial = 1;
283
static int default_parallel = 1;
284
static int default_virtcon = 1;
285
static int default_monitor = 1;
286
static int default_vga = 1;
287
static int default_floppy = 1;
288
static int default_cdrom = 1;
289
static int default_sdcard = 1;
290

    
291
static struct {
292
    const char *driver;
293
    int *flag;
294
} default_list[] = {
295
    { .driver = "isa-serial",           .flag = &default_serial    },
296
    { .driver = "isa-parallel",         .flag = &default_parallel  },
297
    { .driver = "isa-fdc",              .flag = &default_floppy    },
298
    { .driver = "ide-drive",            .flag = &default_cdrom     },
299
    { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
300
    { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },
301
    { .driver = "virtio-serial",        .flag = &default_virtcon   },
302
    { .driver = "VGA",                  .flag = &default_vga       },
303
    { .driver = "cirrus-vga",           .flag = &default_vga       },
304
    { .driver = "vmware-svga",          .flag = &default_vga       },
305
};
306

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

    
312
    if (!driver)
313
        return 0;
314
    for (i = 0; i < ARRAY_SIZE(default_list); i++) {
315
        if (strcmp(default_list[i].driver, driver) != 0)
316
            continue;
317
        *(default_list[i].flag) = 0;
318
    }
319
    return 0;
320
}
321

    
322
/***********************************************************/
323
/* x86 ISA bus support */
324

    
325
target_phys_addr_t isa_mem_base = 0;
326
PicState2 *isa_pic;
327

    
328
/***********************************************************/
329
void hw_error(const char *fmt, ...)
330
{
331
    va_list ap;
332
    CPUState *env;
333

    
334
    va_start(ap, fmt);
335
    fprintf(stderr, "qemu: hardware error: ");
336
    vfprintf(stderr, fmt, ap);
337
    fprintf(stderr, "\n");
338
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
339
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
340
#ifdef TARGET_I386
341
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
342
#else
343
        cpu_dump_state(env, stderr, fprintf, 0);
344
#endif
345
    }
346
    va_end(ap);
347
    abort();
348
}
349

    
350
static void set_proc_name(const char *s)
351
{
352
#if defined(__linux__) && defined(PR_SET_NAME)
353
    char name[16];
354
    if (!s)
355
        return;
356
    name[sizeof(name) - 1] = 0;
357
    strncpy(name, s, sizeof(name));
358
    /* Could rewrite argv[0] too, but that's a bit more complicated.
359
       This simple way is enough for `top'. */
360
    prctl(PR_SET_NAME, name);
361
#endif            
362
}
363
 
364
/***************/
365
/* ballooning */
366

    
367
static QEMUBalloonEvent *qemu_balloon_event;
368
void *qemu_balloon_event_opaque;
369

    
370
void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
371
{
372
    qemu_balloon_event = func;
373
    qemu_balloon_event_opaque = opaque;
374
}
375

    
376
int qemu_balloon(ram_addr_t target, MonitorCompletion cb, void *opaque)
377
{
378
    if (qemu_balloon_event) {
379
        qemu_balloon_event(qemu_balloon_event_opaque, target, cb, opaque);
380
        return 1;
381
    } else {
382
        return 0;
383
    }
384
}
385

    
386
int qemu_balloon_status(MonitorCompletion cb, void *opaque)
387
{
388
    if (qemu_balloon_event) {
389
        qemu_balloon_event(qemu_balloon_event_opaque, 0, cb, opaque);
390
        return 1;
391
    } else {
392
        return 0;
393
    }
394
}
395

    
396

    
397
/***********************************************************/
398
/* real time host monotonic timer */
399

    
400
/* compute with 96 bit intermediate result: (a*b)/c */
401
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
402
{
403
    union {
404
        uint64_t ll;
405
        struct {
406
#ifdef HOST_WORDS_BIGENDIAN
407
            uint32_t high, low;
408
#else
409
            uint32_t low, high;
410
#endif
411
        } l;
412
    } u, res;
413
    uint64_t rl, rh;
414

    
415
    u.ll = a;
416
    rl = (uint64_t)u.l.low * (uint64_t)b;
417
    rh = (uint64_t)u.l.high * (uint64_t)b;
418
    rh += (rl >> 32);
419
    res.l.high = rh / c;
420
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
421
    return res.ll;
422
}
423

    
424
static int64_t get_clock_realtime(void)
425
{
426
    struct timeval tv;
427

    
428
    gettimeofday(&tv, NULL);
429
    return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
430
}
431

    
432
#ifdef WIN32
433

    
434
static int64_t clock_freq;
435

    
436
static void init_get_clock(void)
437
{
438
    LARGE_INTEGER freq;
439
    int ret;
440
    ret = QueryPerformanceFrequency(&freq);
441
    if (ret == 0) {
442
        fprintf(stderr, "Could not calibrate ticks\n");
443
        exit(1);
444
    }
445
    clock_freq = freq.QuadPart;
446
}
447

    
448
static int64_t get_clock(void)
449
{
450
    LARGE_INTEGER ti;
451
    QueryPerformanceCounter(&ti);
452
    return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
453
}
454

    
455
#else
456

    
457
static int use_rt_clock;
458

    
459
static void init_get_clock(void)
460
{
461
    use_rt_clock = 0;
462
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
463
    || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
464
    {
465
        struct timespec ts;
466
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
467
            use_rt_clock = 1;
468
        }
469
    }
470
#endif
471
}
472

    
473
static int64_t get_clock(void)
474
{
475
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
476
        || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
477
    if (use_rt_clock) {
478
        struct timespec ts;
479
        clock_gettime(CLOCK_MONOTONIC, &ts);
480
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
481
    } else
482
#endif
483
    {
484
        /* XXX: using gettimeofday leads to problems if the date
485
           changes, so it should be avoided. */
486
        return get_clock_realtime();
487
    }
488
}
489
#endif
490

    
491
/* Return the virtual CPU time, based on the instruction counter.  */
492
static int64_t cpu_get_icount(void)
493
{
494
    int64_t icount;
495
    CPUState *env = cpu_single_env;;
496
    icount = qemu_icount;
497
    if (env) {
498
        if (!can_do_io(env))
499
            fprintf(stderr, "Bad clock read\n");
500
        icount -= (env->icount_decr.u16.low + env->icount_extra);
501
    }
502
    return qemu_icount_bias + (icount << icount_time_shift);
503
}
504

    
505
/***********************************************************/
506
/* guest cycle counter */
507

    
508
typedef struct TimersState {
509
    int64_t cpu_ticks_prev;
510
    int64_t cpu_ticks_offset;
511
    int64_t cpu_clock_offset;
512
    int32_t cpu_ticks_enabled;
513
    int64_t dummy;
514
} TimersState;
515

    
516
TimersState timers_state;
517

    
518
/* return the host CPU cycle counter and handle stop/restart */
519
int64_t cpu_get_ticks(void)
520
{
521
    if (use_icount) {
522
        return cpu_get_icount();
523
    }
524
    if (!timers_state.cpu_ticks_enabled) {
525
        return timers_state.cpu_ticks_offset;
526
    } else {
527
        int64_t ticks;
528
        ticks = cpu_get_real_ticks();
529
        if (timers_state.cpu_ticks_prev > ticks) {
530
            /* Note: non increasing ticks may happen if the host uses
531
               software suspend */
532
            timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
533
        }
534
        timers_state.cpu_ticks_prev = ticks;
535
        return ticks + timers_state.cpu_ticks_offset;
536
    }
537
}
538

    
539
/* return the host CPU monotonic timer and handle stop/restart */
540
static int64_t cpu_get_clock(void)
541
{
542
    int64_t ti;
543
    if (!timers_state.cpu_ticks_enabled) {
544
        return timers_state.cpu_clock_offset;
545
    } else {
546
        ti = get_clock();
547
        return ti + timers_state.cpu_clock_offset;
548
    }
549
}
550

    
551
/* enable cpu_get_ticks() */
552
void cpu_enable_ticks(void)
553
{
554
    if (!timers_state.cpu_ticks_enabled) {
555
        timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
556
        timers_state.cpu_clock_offset -= get_clock();
557
        timers_state.cpu_ticks_enabled = 1;
558
    }
559
}
560

    
561
/* disable cpu_get_ticks() : the clock is stopped. You must not call
562
   cpu_get_ticks() after that.  */
563
void cpu_disable_ticks(void)
564
{
565
    if (timers_state.cpu_ticks_enabled) {
566
        timers_state.cpu_ticks_offset = cpu_get_ticks();
567
        timers_state.cpu_clock_offset = cpu_get_clock();
568
        timers_state.cpu_ticks_enabled = 0;
569
    }
570
}
571

    
572
/***********************************************************/
573
/* timers */
574

    
575
#define QEMU_CLOCK_REALTIME 0
576
#define QEMU_CLOCK_VIRTUAL  1
577
#define QEMU_CLOCK_HOST     2
578

    
579
struct QEMUClock {
580
    int type;
581
    /* XXX: add frequency */
582
};
583

    
584
struct QEMUTimer {
585
    QEMUClock *clock;
586
    int64_t expire_time;
587
    QEMUTimerCB *cb;
588
    void *opaque;
589
    struct QEMUTimer *next;
590
};
591

    
592
struct qemu_alarm_timer {
593
    char const *name;
594
    int (*start)(struct qemu_alarm_timer *t);
595
    void (*stop)(struct qemu_alarm_timer *t);
596
    void (*rearm)(struct qemu_alarm_timer *t);
597
    void *priv;
598

    
599
    char expired;
600
    char pending;
601
};
602

    
603
static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
604
{
605
    return !!t->rearm;
606
}
607

    
608
static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
609
{
610
    if (!alarm_has_dynticks(t))
611
        return;
612

    
613
    t->rearm(t);
614
}
615

    
616
/* TODO: MIN_TIMER_REARM_US should be optimized */
617
#define MIN_TIMER_REARM_US 250
618

    
619
static struct qemu_alarm_timer *alarm_timer;
620

    
621
#ifdef _WIN32
622

    
623
struct qemu_alarm_win32 {
624
    MMRESULT timerId;
625
    unsigned int period;
626
} alarm_win32_data = {0, 0};
627

    
628
static int win32_start_timer(struct qemu_alarm_timer *t);
629
static void win32_stop_timer(struct qemu_alarm_timer *t);
630
static void win32_rearm_timer(struct qemu_alarm_timer *t);
631

    
632
#else
633

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

    
637
#ifdef __linux__
638

    
639
static int dynticks_start_timer(struct qemu_alarm_timer *t);
640
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
641
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
642

    
643
static int hpet_start_timer(struct qemu_alarm_timer *t);
644
static void hpet_stop_timer(struct qemu_alarm_timer *t);
645

    
646
static int rtc_start_timer(struct qemu_alarm_timer *t);
647
static void rtc_stop_timer(struct qemu_alarm_timer *t);
648

    
649
#endif /* __linux__ */
650

    
651
#endif /* _WIN32 */
652

    
653
/* Correlation between real and virtual time is always going to be
654
   fairly approximate, so ignore small variation.
655
   When the guest is idle real and virtual time will be aligned in
656
   the IO wait loop.  */
657
#define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
658

    
659
static void icount_adjust(void)
660
{
661
    int64_t cur_time;
662
    int64_t cur_icount;
663
    int64_t delta;
664
    static int64_t last_delta;
665
    /* If the VM is not running, then do nothing.  */
666
    if (!vm_running)
667
        return;
668

    
669
    cur_time = cpu_get_clock();
670
    cur_icount = qemu_get_clock(vm_clock);
671
    delta = cur_icount - cur_time;
672
    /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
673
    if (delta > 0
674
        && last_delta + ICOUNT_WOBBLE < delta * 2
675
        && icount_time_shift > 0) {
676
        /* The guest is getting too far ahead.  Slow time down.  */
677
        icount_time_shift--;
678
    }
679
    if (delta < 0
680
        && last_delta - ICOUNT_WOBBLE > delta * 2
681
        && icount_time_shift < MAX_ICOUNT_SHIFT) {
682
        /* The guest is getting too far behind.  Speed time up.  */
683
        icount_time_shift++;
684
    }
685
    last_delta = delta;
686
    qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
687
}
688

    
689
static void icount_adjust_rt(void * opaque)
690
{
691
    qemu_mod_timer(icount_rt_timer,
692
                   qemu_get_clock(rt_clock) + 1000);
693
    icount_adjust();
694
}
695

    
696
static void icount_adjust_vm(void * opaque)
697
{
698
    qemu_mod_timer(icount_vm_timer,
699
                   qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);
700
    icount_adjust();
701
}
702

    
703
static void init_icount_adjust(void)
704
{
705
    /* Have both realtime and virtual time triggers for speed adjustment.
706
       The realtime trigger catches emulated time passing too slowly,
707
       the virtual time trigger catches emulated time passing too fast.
708
       Realtime triggers occur even when idle, so use them less frequently
709
       than VM triggers.  */
710
    icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
711
    qemu_mod_timer(icount_rt_timer,
712
                   qemu_get_clock(rt_clock) + 1000);
713
    icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
714
    qemu_mod_timer(icount_vm_timer,
715
                   qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);
716
}
717

    
718
static struct qemu_alarm_timer alarm_timers[] = {
719
#ifndef _WIN32
720
#ifdef __linux__
721
    {"dynticks", dynticks_start_timer,
722
     dynticks_stop_timer, dynticks_rearm_timer, NULL},
723
    /* HPET - if available - is preferred */
724
    {"hpet", hpet_start_timer, hpet_stop_timer, NULL, NULL},
725
    /* ...otherwise try RTC */
726
    {"rtc", rtc_start_timer, rtc_stop_timer, NULL, NULL},
727
#endif
728
    {"unix", unix_start_timer, unix_stop_timer, NULL, NULL},
729
#else
730
    {"dynticks", win32_start_timer,
731
     win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
732
    {"win32", win32_start_timer,
733
     win32_stop_timer, NULL, &alarm_win32_data},
734
#endif
735
    {NULL, }
736
};
737

    
738
static void show_available_alarms(void)
739
{
740
    int i;
741

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

    
747
static void configure_alarms(char const *opt)
748
{
749
    int i;
750
    int cur = 0;
751
    int count = ARRAY_SIZE(alarm_timers) - 1;
752
    char *arg;
753
    char *name;
754
    struct qemu_alarm_timer tmp;
755

    
756
    if (!strcmp(opt, "?")) {
757
        show_available_alarms();
758
        exit(0);
759
    }
760

    
761
    arg = qemu_strdup(opt);
762

    
763
    /* Reorder the array */
764
    name = strtok(arg, ",");
765
    while (name) {
766
        for (i = 0; i < count && alarm_timers[i].name; i++) {
767
            if (!strcmp(alarm_timers[i].name, name))
768
                break;
769
        }
770

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

    
776
        if (i < cur)
777
            /* Ignore */
778
            goto next;
779

    
780
        /* Swap */
781
        tmp = alarm_timers[i];
782
        alarm_timers[i] = alarm_timers[cur];
783
        alarm_timers[cur] = tmp;
784

    
785
        cur++;
786
next:
787
        name = strtok(NULL, ",");
788
    }
789

    
790
    qemu_free(arg);
791

    
792
    if (cur) {
793
        /* Disable remaining timers */
794
        for (i = cur; i < count; i++)
795
            alarm_timers[i].name = NULL;
796
    } else {
797
        show_available_alarms();
798
        exit(1);
799
    }
800
}
801

    
802
#define QEMU_NUM_CLOCKS 3
803

    
804
QEMUClock *rt_clock;
805
QEMUClock *vm_clock;
806
QEMUClock *host_clock;
807

    
808
static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];
809

    
810
static QEMUClock *qemu_new_clock(int type)
811
{
812
    QEMUClock *clock;
813
    clock = qemu_mallocz(sizeof(QEMUClock));
814
    clock->type = type;
815
    return clock;
816
}
817

    
818
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
819
{
820
    QEMUTimer *ts;
821

    
822
    ts = qemu_mallocz(sizeof(QEMUTimer));
823
    ts->clock = clock;
824
    ts->cb = cb;
825
    ts->opaque = opaque;
826
    return ts;
827
}
828

    
829
void qemu_free_timer(QEMUTimer *ts)
830
{
831
    qemu_free(ts);
832
}
833

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

    
839
    /* NOTE: this code must be signal safe because
840
       qemu_timer_expired() can be called from a signal. */
841
    pt = &active_timers[ts->clock->type];
842
    for(;;) {
843
        t = *pt;
844
        if (!t)
845
            break;
846
        if (t == ts) {
847
            *pt = t->next;
848
            break;
849
        }
850
        pt = &t->next;
851
    }
852
}
853

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

    
860
    qemu_del_timer(ts);
861

    
862
    /* add the timer in the sorted list */
863
    /* NOTE: this code must be signal safe because
864
       qemu_timer_expired() can be called from a signal. */
865
    pt = &active_timers[ts->clock->type];
866
    for(;;) {
867
        t = *pt;
868
        if (!t)
869
            break;
870
        if (t->expire_time > expire_time)
871
            break;
872
        pt = &t->next;
873
    }
874
    ts->expire_time = expire_time;
875
    ts->next = *pt;
876
    *pt = ts;
877

    
878
    /* Rearm if necessary  */
879
    if (pt == &active_timers[ts->clock->type]) {
880
        if (!alarm_timer->pending) {
881
            qemu_rearm_alarm_timer(alarm_timer);
882
        }
883
        /* Interrupt execution to force deadline recalculation.  */
884
        if (use_icount)
885
            qemu_notify_event();
886
    }
887
}
888

    
889
int qemu_timer_pending(QEMUTimer *ts)
890
{
891
    QEMUTimer *t;
892
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
893
        if (t == ts)
894
            return 1;
895
    }
896
    return 0;
897
}
898

    
899
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
900
{
901
    if (!timer_head)
902
        return 0;
903
    return (timer_head->expire_time <= current_time);
904
}
905

    
906
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
907
{
908
    QEMUTimer *ts;
909

    
910
    for(;;) {
911
        ts = *ptimer_head;
912
        if (!ts || ts->expire_time > current_time)
913
            break;
914
        /* remove timer from the list before calling the callback */
915
        *ptimer_head = ts->next;
916
        ts->next = NULL;
917

    
918
        /* run the callback (the timer list can be modified) */
919
        ts->cb(ts->opaque);
920
    }
921
}
922

    
923
int64_t qemu_get_clock(QEMUClock *clock)
924
{
925
    switch(clock->type) {
926
    case QEMU_CLOCK_REALTIME:
927
        return get_clock() / 1000000;
928
    default:
929
    case QEMU_CLOCK_VIRTUAL:
930
        if (use_icount) {
931
            return cpu_get_icount();
932
        } else {
933
            return cpu_get_clock();
934
        }
935
    case QEMU_CLOCK_HOST:
936
        return get_clock_realtime();
937
    }
938
}
939

    
940
int64_t qemu_get_clock_ns(QEMUClock *clock)
941
{
942
    switch(clock->type) {
943
    case QEMU_CLOCK_REALTIME:
944
        return get_clock();
945
    default:
946
    case QEMU_CLOCK_VIRTUAL:
947
        if (use_icount) {
948
            return cpu_get_icount();
949
        } else {
950
            return cpu_get_clock();
951
        }
952
    case QEMU_CLOCK_HOST:
953
        return get_clock_realtime();
954
    }
955
}
956

    
957
static void init_clocks(void)
958
{
959
    init_get_clock();
960
    rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
961
    vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
962
    host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
963

    
964
    rtc_clock = host_clock;
965
}
966

    
967
/* save a timer */
968
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
969
{
970
    uint64_t expire_time;
971

    
972
    if (qemu_timer_pending(ts)) {
973
        expire_time = ts->expire_time;
974
    } else {
975
        expire_time = -1;
976
    }
977
    qemu_put_be64(f, expire_time);
978
}
979

    
980
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
981
{
982
    uint64_t expire_time;
983

    
984
    expire_time = qemu_get_be64(f);
985
    if (expire_time != -1) {
986
        qemu_mod_timer(ts, expire_time);
987
    } else {
988
        qemu_del_timer(ts);
989
    }
990
}
991

    
992
static const VMStateDescription vmstate_timers = {
993
    .name = "timer",
994
    .version_id = 2,
995
    .minimum_version_id = 1,
996
    .minimum_version_id_old = 1,
997
    .fields      = (VMStateField []) {
998
        VMSTATE_INT64(cpu_ticks_offset, TimersState),
999
        VMSTATE_INT64(dummy, TimersState),
1000
        VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
1001
        VMSTATE_END_OF_LIST()
1002
    }
1003
};
1004

    
1005
static void qemu_event_increment(void);
1006

    
1007
#ifdef _WIN32
1008
static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1009
                                        DWORD_PTR dwUser, DWORD_PTR dw1,
1010
                                        DWORD_PTR dw2)
1011
#else
1012
static void host_alarm_handler(int host_signum)
1013
#endif
1014
{
1015
    struct qemu_alarm_timer *t = alarm_timer;
1016
    if (!t)
1017
        return;
1018

    
1019
#if 0
1020
#define DISP_FREQ 1000
1021
    {
1022
        static int64_t delta_min = INT64_MAX;
1023
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
1024
        static int count;
1025
        ti = qemu_get_clock(vm_clock);
1026
        if (last_clock != 0) {
1027
            delta = ti - last_clock;
1028
            if (delta < delta_min)
1029
                delta_min = delta;
1030
            if (delta > delta_max)
1031
                delta_max = delta;
1032
            delta_cum += delta;
1033
            if (++count == DISP_FREQ) {
1034
                printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1035
                       muldiv64(delta_min, 1000000, get_ticks_per_sec()),
1036
                       muldiv64(delta_max, 1000000, get_ticks_per_sec()),
1037
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, get_ticks_per_sec()),
1038
                       (double)get_ticks_per_sec() / ((double)delta_cum / DISP_FREQ));
1039
                count = 0;
1040
                delta_min = INT64_MAX;
1041
                delta_max = 0;
1042
                delta_cum = 0;
1043
            }
1044
        }
1045
        last_clock = ti;
1046
    }
1047
#endif
1048
    if (alarm_has_dynticks(t) ||
1049
        (!use_icount &&
1050
            qemu_timer_expired(active_timers[QEMU_CLOCK_VIRTUAL],
1051
                               qemu_get_clock(vm_clock))) ||
1052
        qemu_timer_expired(active_timers[QEMU_CLOCK_REALTIME],
1053
                           qemu_get_clock(rt_clock)) ||
1054
        qemu_timer_expired(active_timers[QEMU_CLOCK_HOST],
1055
                           qemu_get_clock(host_clock))) {
1056

    
1057
        t->expired = alarm_has_dynticks(t);
1058

    
1059
#ifndef CONFIG_IOTHREAD
1060
        if (next_cpu) {
1061
            /* stop the currently executing cpu because a timer occured */
1062
            cpu_exit(next_cpu);
1063
        }
1064
#endif
1065
        t->pending = 1;
1066
        qemu_notify_event();
1067
    }
1068
}
1069

    
1070
static int64_t qemu_next_deadline(void)
1071
{
1072
    /* To avoid problems with overflow limit this to 2^32.  */
1073
    int64_t delta = INT32_MAX;
1074

    
1075
    if (active_timers[QEMU_CLOCK_VIRTUAL]) {
1076
        delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
1077
                     qemu_get_clock(vm_clock);
1078
    }
1079
    if (active_timers[QEMU_CLOCK_HOST]) {
1080
        int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
1081
                 qemu_get_clock(host_clock);
1082
        if (hdelta < delta)
1083
            delta = hdelta;
1084
    }
1085

    
1086
    if (delta < 0)
1087
        delta = 0;
1088

    
1089
    return delta;
1090
}
1091

    
1092
#if defined(__linux__)
1093
static uint64_t qemu_next_deadline_dyntick(void)
1094
{
1095
    int64_t delta;
1096
    int64_t rtdelta;
1097

    
1098
    if (use_icount)
1099
        delta = INT32_MAX;
1100
    else
1101
        delta = (qemu_next_deadline() + 999) / 1000;
1102

    
1103
    if (active_timers[QEMU_CLOCK_REALTIME]) {
1104
        rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -
1105
                 qemu_get_clock(rt_clock))*1000;
1106
        if (rtdelta < delta)
1107
            delta = rtdelta;
1108
    }
1109

    
1110
    if (delta < MIN_TIMER_REARM_US)
1111
        delta = MIN_TIMER_REARM_US;
1112

    
1113
    return delta;
1114
}
1115
#endif
1116

    
1117
#ifndef _WIN32
1118

    
1119
/* Sets a specific flag */
1120
static int fcntl_setfl(int fd, int flag)
1121
{
1122
    int flags;
1123

    
1124
    flags = fcntl(fd, F_GETFL);
1125
    if (flags == -1)
1126
        return -errno;
1127

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

    
1131
    return 0;
1132
}
1133

    
1134
#if defined(__linux__)
1135

    
1136
#define RTC_FREQ 1024
1137

    
1138
static void enable_sigio_timer(int fd)
1139
{
1140
    struct sigaction act;
1141

    
1142
    /* timer signal */
1143
    sigfillset(&act.sa_mask);
1144
    act.sa_flags = 0;
1145
    act.sa_handler = host_alarm_handler;
1146

    
1147
    sigaction(SIGIO, &act, NULL);
1148
    fcntl_setfl(fd, O_ASYNC);
1149
    fcntl(fd, F_SETOWN, getpid());
1150
}
1151

    
1152
static int hpet_start_timer(struct qemu_alarm_timer *t)
1153
{
1154
    struct hpet_info info;
1155
    int r, fd;
1156

    
1157
    fd = qemu_open("/dev/hpet", O_RDONLY);
1158
    if (fd < 0)
1159
        return -1;
1160

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

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

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

    
1180
    /* Enable interrupt */
1181
    r = ioctl(fd, HPET_IE_ON, 0);
1182
    if (r < 0)
1183
        goto fail;
1184

    
1185
    enable_sigio_timer(fd);
1186
    t->priv = (void *)(long)fd;
1187

    
1188
    return 0;
1189
fail:
1190
    close(fd);
1191
    return -1;
1192
}
1193

    
1194
static void hpet_stop_timer(struct qemu_alarm_timer *t)
1195
{
1196
    int fd = (long)t->priv;
1197

    
1198
    close(fd);
1199
}
1200

    
1201
static int rtc_start_timer(struct qemu_alarm_timer *t)
1202
{
1203
    int rtc_fd;
1204
    unsigned long current_rtc_freq = 0;
1205

    
1206
    TFR(rtc_fd = qemu_open("/dev/rtc", O_RDONLY));
1207
    if (rtc_fd < 0)
1208
        return -1;
1209
    ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1210
    if (current_rtc_freq != RTC_FREQ &&
1211
        ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1212
        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1213
                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1214
                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1215
        goto fail;
1216
    }
1217
    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1218
    fail:
1219
        close(rtc_fd);
1220
        return -1;
1221
    }
1222

    
1223
    enable_sigio_timer(rtc_fd);
1224

    
1225
    t->priv = (void *)(long)rtc_fd;
1226

    
1227
    return 0;
1228
}
1229

    
1230
static void rtc_stop_timer(struct qemu_alarm_timer *t)
1231
{
1232
    int rtc_fd = (long)t->priv;
1233

    
1234
    close(rtc_fd);
1235
}
1236

    
1237
static int dynticks_start_timer(struct qemu_alarm_timer *t)
1238
{
1239
    struct sigevent ev;
1240
    timer_t host_timer;
1241
    struct sigaction act;
1242

    
1243
    sigfillset(&act.sa_mask);
1244
    act.sa_flags = 0;
1245
    act.sa_handler = host_alarm_handler;
1246

    
1247
    sigaction(SIGALRM, &act, NULL);
1248

    
1249
    /* 
1250
     * Initialize ev struct to 0 to avoid valgrind complaining
1251
     * about uninitialized data in timer_create call
1252
     */
1253
    memset(&ev, 0, sizeof(ev));
1254
    ev.sigev_value.sival_int = 0;
1255
    ev.sigev_notify = SIGEV_SIGNAL;
1256
    ev.sigev_signo = SIGALRM;
1257

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

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

    
1264
        return -1;
1265
    }
1266

    
1267
    t->priv = (void *)(long)host_timer;
1268

    
1269
    return 0;
1270
}
1271

    
1272
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1273
{
1274
    timer_t host_timer = (timer_t)(long)t->priv;
1275

    
1276
    timer_delete(host_timer);
1277
}
1278

    
1279
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1280
{
1281
    timer_t host_timer = (timer_t)(long)t->priv;
1282
    struct itimerspec timeout;
1283
    int64_t nearest_delta_us = INT64_MAX;
1284
    int64_t current_us;
1285

    
1286
    assert(alarm_has_dynticks(t));
1287
    if (!active_timers[QEMU_CLOCK_REALTIME] &&
1288
        !active_timers[QEMU_CLOCK_VIRTUAL] &&
1289
        !active_timers[QEMU_CLOCK_HOST])
1290
        return;
1291

    
1292
    nearest_delta_us = qemu_next_deadline_dyntick();
1293

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

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

    
1315
#endif /* defined(__linux__) */
1316

    
1317
static int unix_start_timer(struct qemu_alarm_timer *t)
1318
{
1319
    struct sigaction act;
1320
    struct itimerval itv;
1321
    int err;
1322

    
1323
    /* timer signal */
1324
    sigfillset(&act.sa_mask);
1325
    act.sa_flags = 0;
1326
    act.sa_handler = host_alarm_handler;
1327

    
1328
    sigaction(SIGALRM, &act, NULL);
1329

    
1330
    itv.it_interval.tv_sec = 0;
1331
    /* for i386 kernel 2.6 to get 1 ms */
1332
    itv.it_interval.tv_usec = 999;
1333
    itv.it_value.tv_sec = 0;
1334
    itv.it_value.tv_usec = 10 * 1000;
1335

    
1336
    err = setitimer(ITIMER_REAL, &itv, NULL);
1337
    if (err)
1338
        return -1;
1339

    
1340
    return 0;
1341
}
1342

    
1343
static void unix_stop_timer(struct qemu_alarm_timer *t)
1344
{
1345
    struct itimerval itv;
1346

    
1347
    memset(&itv, 0, sizeof(itv));
1348
    setitimer(ITIMER_REAL, &itv, NULL);
1349
}
1350

    
1351
#endif /* !defined(_WIN32) */
1352

    
1353

    
1354
#ifdef _WIN32
1355

    
1356
static int win32_start_timer(struct qemu_alarm_timer *t)
1357
{
1358
    TIMECAPS tc;
1359
    struct qemu_alarm_win32 *data = t->priv;
1360
    UINT flags;
1361

    
1362
    memset(&tc, 0, sizeof(tc));
1363
    timeGetDevCaps(&tc, sizeof(tc));
1364

    
1365
    data->period = tc.wPeriodMin;
1366
    timeBeginPeriod(data->period);
1367

    
1368
    flags = TIME_CALLBACK_FUNCTION;
1369
    if (alarm_has_dynticks(t))
1370
        flags |= TIME_ONESHOT;
1371
    else
1372
        flags |= TIME_PERIODIC;
1373

    
1374
    data->timerId = timeSetEvent(1,         // interval (ms)
1375
                        data->period,       // resolution
1376
                        host_alarm_handler, // function
1377
                        (DWORD)t,           // parameter
1378
                        flags);
1379

    
1380
    if (!data->timerId) {
1381
        fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
1382
                GetLastError());
1383
        timeEndPeriod(data->period);
1384
        return -1;
1385
    }
1386

    
1387
    return 0;
1388
}
1389

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

    
1394
    timeKillEvent(data->timerId);
1395
    timeEndPeriod(data->period);
1396
}
1397

    
1398
static void win32_rearm_timer(struct qemu_alarm_timer *t)
1399
{
1400
    struct qemu_alarm_win32 *data = t->priv;
1401

    
1402
    assert(alarm_has_dynticks(t));
1403
    if (!active_timers[QEMU_CLOCK_REALTIME] &&
1404
        !active_timers[QEMU_CLOCK_VIRTUAL] &&
1405
        !active_timers[QEMU_CLOCK_HOST])
1406
        return;
1407

    
1408
    timeKillEvent(data->timerId);
1409

    
1410
    data->timerId = timeSetEvent(1,
1411
                        data->period,
1412
                        host_alarm_handler,
1413
                        (DWORD)t,
1414
                        TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
1415

    
1416
    if (!data->timerId) {
1417
        fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
1418
                GetLastError());
1419

    
1420
        timeEndPeriod(data->period);
1421
        exit(1);
1422
    }
1423
}
1424

    
1425
#endif /* _WIN32 */
1426

    
1427
static int init_timer_alarm(void)
1428
{
1429
    struct qemu_alarm_timer *t = NULL;
1430
    int i, err = -1;
1431

    
1432
    for (i = 0; alarm_timers[i].name; i++) {
1433
        t = &alarm_timers[i];
1434

    
1435
        err = t->start(t);
1436
        if (!err)
1437
            break;
1438
    }
1439

    
1440
    if (err) {
1441
        err = -ENOENT;
1442
        goto fail;
1443
    }
1444

    
1445
    /* first event is at time 0 */
1446
    t->pending = 1;
1447
    alarm_timer = t;
1448

    
1449
    return 0;
1450

    
1451
fail:
1452
    return err;
1453
}
1454

    
1455
static void quit_timers(void)
1456
{
1457
    struct qemu_alarm_timer *t = alarm_timer;
1458
    alarm_timer = NULL;
1459
    t->stop(t);
1460
}
1461

    
1462
/***********************************************************/
1463
/* host time/date access */
1464
void qemu_get_timedate(struct tm *tm, int offset)
1465
{
1466
    time_t ti;
1467
    struct tm *ret;
1468

    
1469
    time(&ti);
1470
    ti += offset;
1471
    if (rtc_date_offset == -1) {
1472
        if (rtc_utc)
1473
            ret = gmtime(&ti);
1474
        else
1475
            ret = localtime(&ti);
1476
    } else {
1477
        ti -= rtc_date_offset;
1478
        ret = gmtime(&ti);
1479
    }
1480

    
1481
    memcpy(tm, ret, sizeof(struct tm));
1482
}
1483

    
1484
int qemu_timedate_diff(struct tm *tm)
1485
{
1486
    time_t seconds;
1487

    
1488
    if (rtc_date_offset == -1)
1489
        if (rtc_utc)
1490
            seconds = mktimegm(tm);
1491
        else
1492
            seconds = mktime(tm);
1493
    else
1494
        seconds = mktimegm(tm) + rtc_date_offset;
1495

    
1496
    return seconds - time(NULL);
1497
}
1498

    
1499
void rtc_change_mon_event(struct tm *tm)
1500
{
1501
    QObject *data;
1502

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

    
1508
static void configure_rtc_date_offset(const char *startdate, int legacy)
1509
{
1510
    time_t rtc_start_date;
1511
    struct tm tm;
1512

    
1513
    if (!strcmp(startdate, "now") && legacy) {
1514
        rtc_date_offset = -1;
1515
    } else {
1516
        if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
1517
                   &tm.tm_year,
1518
                   &tm.tm_mon,
1519
                   &tm.tm_mday,
1520
                   &tm.tm_hour,
1521
                   &tm.tm_min,
1522
                   &tm.tm_sec) == 6) {
1523
            /* OK */
1524
        } else if (sscanf(startdate, "%d-%d-%d",
1525
                          &tm.tm_year,
1526
                          &tm.tm_mon,
1527
                          &tm.tm_mday) == 3) {
1528
            tm.tm_hour = 0;
1529
            tm.tm_min = 0;
1530
            tm.tm_sec = 0;
1531
        } else {
1532
            goto date_fail;
1533
        }
1534
        tm.tm_year -= 1900;
1535
        tm.tm_mon--;
1536
        rtc_start_date = mktimegm(&tm);
1537
        if (rtc_start_date == -1) {
1538
        date_fail:
1539
            fprintf(stderr, "Invalid date format. Valid formats are:\n"
1540
                            "'2006-06-17T16:01:21' or '2006-06-17'\n");
1541
            exit(1);
1542
        }
1543
        rtc_date_offset = time(NULL) - rtc_start_date;
1544
    }
1545
}
1546

    
1547
static void configure_rtc(QemuOpts *opts)
1548
{
1549
    const char *value;
1550

    
1551
    value = qemu_opt_get(opts, "base");
1552
    if (value) {
1553
        if (!strcmp(value, "utc")) {
1554
            rtc_utc = 1;
1555
        } else if (!strcmp(value, "localtime")) {
1556
            rtc_utc = 0;
1557
        } else {
1558
            configure_rtc_date_offset(value, 0);
1559
        }
1560
    }
1561
    value = qemu_opt_get(opts, "clock");
1562
    if (value) {
1563
        if (!strcmp(value, "host")) {
1564
            rtc_clock = host_clock;
1565
        } else if (!strcmp(value, "vm")) {
1566
            rtc_clock = vm_clock;
1567
        } else {
1568
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
1569
            exit(1);
1570
        }
1571
    }
1572
#ifdef CONFIG_TARGET_I386
1573
    value = qemu_opt_get(opts, "driftfix");
1574
    if (value) {
1575
        if (!strcmp(buf, "slew")) {
1576
            rtc_td_hack = 1;
1577
        } else if (!strcmp(buf, "none")) {
1578
            rtc_td_hack = 0;
1579
        } else {
1580
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
1581
            exit(1);
1582
        }
1583
    }
1584
#endif
1585
}
1586

    
1587
#ifdef _WIN32
1588
static void socket_cleanup(void)
1589
{
1590
    WSACleanup();
1591
}
1592

    
1593
static int socket_init(void)
1594
{
1595
    WSADATA Data;
1596
    int ret, err;
1597

    
1598
    ret = WSAStartup(MAKEWORD(2,2), &Data);
1599
    if (ret != 0) {
1600
        err = WSAGetLastError();
1601
        fprintf(stderr, "WSAStartup: %d\n", err);
1602
        return -1;
1603
    }
1604
    atexit(socket_cleanup);
1605
    return 0;
1606
}
1607
#endif
1608

    
1609
/***********************************************************/
1610
/* Bluetooth support */
1611
static int nb_hcis;
1612
static int cur_hci;
1613
static struct HCIInfo *hci_table[MAX_NICS];
1614

    
1615
static struct bt_vlan_s {
1616
    struct bt_scatternet_s net;
1617
    int id;
1618
    struct bt_vlan_s *next;
1619
} *first_bt_vlan;
1620

    
1621
/* find or alloc a new bluetooth "VLAN" */
1622
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1623
{
1624
    struct bt_vlan_s **pvlan, *vlan;
1625
    for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1626
        if (vlan->id == id)
1627
            return &vlan->net;
1628
    }
1629
    vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1630
    vlan->id = id;
1631
    pvlan = &first_bt_vlan;
1632
    while (*pvlan != NULL)
1633
        pvlan = &(*pvlan)->next;
1634
    *pvlan = vlan;
1635
    return &vlan->net;
1636
}
1637

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

    
1642
static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1643
{
1644
    return -ENOTSUP;
1645
}
1646

    
1647
static struct HCIInfo null_hci = {
1648
    .cmd_send = null_hci_send,
1649
    .sco_send = null_hci_send,
1650
    .acl_send = null_hci_send,
1651
    .bdaddr_set = null_hci_addr_set,
1652
};
1653

    
1654
struct HCIInfo *qemu_next_hci(void)
1655
{
1656
    if (cur_hci == nb_hcis)
1657
        return &null_hci;
1658

    
1659
    return hci_table[cur_hci++];
1660
}
1661

    
1662
static struct HCIInfo *hci_init(const char *str)
1663
{
1664
    char *endp;
1665
    struct bt_scatternet_s *vlan = 0;
1666

    
1667
    if (!strcmp(str, "null"))
1668
        /* null */
1669
        return &null_hci;
1670
    else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1671
        /* host[:hciN] */
1672
        return bt_host_hci(str[4] ? str + 5 : "hci0");
1673
    else if (!strncmp(str, "hci", 3)) {
1674
        /* hci[,vlan=n] */
1675
        if (str[3]) {
1676
            if (!strncmp(str + 3, ",vlan=", 6)) {
1677
                vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1678
                if (*endp)
1679
                    vlan = 0;
1680
            }
1681
        } else
1682
            vlan = qemu_find_bt_vlan(0);
1683
        if (vlan)
1684
           return bt_new_hci(vlan);
1685
    }
1686

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

    
1689
    return 0;
1690
}
1691

    
1692
static int bt_hci_parse(const char *str)
1693
{
1694
    struct HCIInfo *hci;
1695
    bdaddr_t bdaddr;
1696

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

    
1702
    hci = hci_init(str);
1703
    if (!hci)
1704
        return -1;
1705

    
1706
    bdaddr.b[0] = 0x52;
1707
    bdaddr.b[1] = 0x54;
1708
    bdaddr.b[2] = 0x00;
1709
    bdaddr.b[3] = 0x12;
1710
    bdaddr.b[4] = 0x34;
1711
    bdaddr.b[5] = 0x56 + nb_hcis;
1712
    hci->bdaddr_set(hci, bdaddr.b);
1713

    
1714
    hci_table[nb_hcis++] = hci;
1715

    
1716
    return 0;
1717
}
1718

    
1719
static void bt_vhci_add(int vlan_id)
1720
{
1721
    struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1722

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

    
1727
    bt_vhci_init(bt_new_hci(vlan));
1728
}
1729

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

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

    
1740
    if (endp) {
1741
        vlan_id = strtol(endp + 6, &endp, 0);
1742
        if (*endp) {
1743
            fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
1744
            return 0;
1745
        }
1746
    }
1747

    
1748
    vlan = qemu_find_bt_vlan(vlan_id);
1749

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

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

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

    
1761
static int bt_parse(const char *opt)
1762
{
1763
    const char *endp, *p;
1764
    int vlan;
1765

    
1766
    if (strstart(opt, "hci", &endp)) {
1767
        if (!*endp || *endp == ',') {
1768
            if (*endp)
1769
                if (!strstart(endp, ",vlan=", 0))
1770
                    opt = endp + 1;
1771

    
1772
            return bt_hci_parse(opt);
1773
       }
1774
    } else if (strstart(opt, "vhci", &endp)) {
1775
        if (!*endp || *endp == ',') {
1776
            if (*endp) {
1777
                if (strstart(endp, ",vlan=", &p)) {
1778
                    vlan = strtol(p, (char **) &endp, 0);
1779
                    if (*endp) {
1780
                        fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
1781
                        return 1;
1782
                    }
1783
                } else {
1784
                    fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
1785
                    return 1;
1786
                }
1787
            } else
1788
                vlan = 0;
1789

    
1790
            bt_vhci_add(vlan);
1791
            return 0;
1792
        }
1793
    } else if (strstart(opt, "device:", &endp))
1794
        return !bt_device_add(endp);
1795

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

    
1800
/***********************************************************/
1801
/* QEMU Block devices */
1802

    
1803
#define HD_ALIAS "index=%d,media=disk"
1804
#define CDROM_ALIAS "index=2,media=cdrom"
1805
#define FD_ALIAS "index=%d,if=floppy"
1806
#define PFLASH_ALIAS "if=pflash"
1807
#define MTD_ALIAS "if=mtd"
1808
#define SD_ALIAS "index=0,if=sd"
1809

    
1810
QemuOpts *drive_add(const char *file, const char *fmt, ...)
1811
{
1812
    va_list ap;
1813
    char optstr[1024];
1814
    QemuOpts *opts;
1815

    
1816
    va_start(ap, fmt);
1817
    vsnprintf(optstr, sizeof(optstr), fmt, ap);
1818
    va_end(ap);
1819

    
1820
    opts = qemu_opts_parse(&qemu_drive_opts, optstr, 0);
1821
    if (!opts) {
1822
        fprintf(stderr, "%s: huh? duplicate? (%s)\n",
1823
                __FUNCTION__, optstr);
1824
        return NULL;
1825
    }
1826
    if (file)
1827
        qemu_opt_set(opts, "file", file);
1828
    return opts;
1829
}
1830

    
1831
DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
1832
{
1833
    DriveInfo *dinfo;
1834

    
1835
    /* seek interface, bus and unit */
1836

    
1837
    QTAILQ_FOREACH(dinfo, &drives, next) {
1838
        if (dinfo->type == type &&
1839
            dinfo->bus == bus &&
1840
            dinfo->unit == unit)
1841
            return dinfo;
1842
    }
1843

    
1844
    return NULL;
1845
}
1846

    
1847
DriveInfo *drive_get_by_id(const char *id)
1848
{
1849
    DriveInfo *dinfo;
1850

    
1851
    QTAILQ_FOREACH(dinfo, &drives, next) {
1852
        if (strcmp(id, dinfo->id))
1853
            continue;
1854
        return dinfo;
1855
    }
1856
    return NULL;
1857
}
1858

    
1859
int drive_get_max_bus(BlockInterfaceType type)
1860
{
1861
    int max_bus;
1862
    DriveInfo *dinfo;
1863

    
1864
    max_bus = -1;
1865
    QTAILQ_FOREACH(dinfo, &drives, next) {
1866
        if(dinfo->type == type &&
1867
           dinfo->bus > max_bus)
1868
            max_bus = dinfo->bus;
1869
    }
1870
    return max_bus;
1871
}
1872

    
1873
const char *drive_get_serial(BlockDriverState *bdrv)
1874
{
1875
    DriveInfo *dinfo;
1876

    
1877
    QTAILQ_FOREACH(dinfo, &drives, next) {
1878
        if (dinfo->bdrv == bdrv)
1879
            return dinfo->serial;
1880
    }
1881

    
1882
    return "\0";
1883
}
1884

    
1885
BlockInterfaceErrorAction drive_get_on_error(
1886
    BlockDriverState *bdrv, int is_read)
1887
{
1888
    DriveInfo *dinfo;
1889

    
1890
    QTAILQ_FOREACH(dinfo, &drives, next) {
1891
        if (dinfo->bdrv == bdrv)
1892
            return is_read ? dinfo->on_read_error : dinfo->on_write_error;
1893
    }
1894

    
1895
    return is_read ? BLOCK_ERR_REPORT : BLOCK_ERR_STOP_ENOSPC;
1896
}
1897

    
1898
static void bdrv_format_print(void *opaque, const char *name)
1899
{
1900
    fprintf(stderr, " %s", name);
1901
}
1902

    
1903
void drive_uninit(DriveInfo *dinfo)
1904
{
1905
    qemu_opts_del(dinfo->opts);
1906
    bdrv_delete(dinfo->bdrv);
1907
    QTAILQ_REMOVE(&drives, dinfo, next);
1908
    qemu_free(dinfo);
1909
}
1910

    
1911
static int parse_block_error_action(const char *buf, int is_read)
1912
{
1913
    if (!strcmp(buf, "ignore")) {
1914
        return BLOCK_ERR_IGNORE;
1915
    } else if (!is_read && !strcmp(buf, "enospc")) {
1916
        return BLOCK_ERR_STOP_ENOSPC;
1917
    } else if (!strcmp(buf, "stop")) {
1918
        return BLOCK_ERR_STOP_ANY;
1919
    } else if (!strcmp(buf, "report")) {
1920
        return BLOCK_ERR_REPORT;
1921
    } else {
1922
        fprintf(stderr, "qemu: '%s' invalid %s error action\n",
1923
            buf, is_read ? "read" : "write");
1924
        return -1;
1925
    }
1926
}
1927

    
1928
DriveInfo *drive_init(QemuOpts *opts, void *opaque,
1929
                      int *fatal_error)
1930
{
1931
    const char *buf;
1932
    const char *file = NULL;
1933
    char devname[128];
1934
    const char *serial;
1935
    const char *mediastr = "";
1936
    BlockInterfaceType type;
1937
    enum { MEDIA_DISK, MEDIA_CDROM } media;
1938
    int bus_id, unit_id;
1939
    int cyls, heads, secs, translation;
1940
    BlockDriver *drv = NULL;
1941
    QEMUMachine *machine = opaque;
1942
    int max_devs;
1943
    int index;
1944
    int cache;
1945
    int aio = 0;
1946
    int ro = 0;
1947
    int bdrv_flags;
1948
    int on_read_error, on_write_error;
1949
    const char *devaddr;
1950
    DriveInfo *dinfo;
1951
    int snapshot = 0;
1952

    
1953
    *fatal_error = 1;
1954

    
1955
    translation = BIOS_ATA_TRANSLATION_AUTO;
1956
    cache = 1;
1957

    
1958
    if (machine && machine->use_scsi) {
1959
        type = IF_SCSI;
1960
        max_devs = MAX_SCSI_DEVS;
1961
        pstrcpy(devname, sizeof(devname), "scsi");
1962
    } else {
1963
        type = IF_IDE;
1964
        max_devs = MAX_IDE_DEVS;
1965
        pstrcpy(devname, sizeof(devname), "ide");
1966
    }
1967
    media = MEDIA_DISK;
1968

    
1969
    /* extract parameters */
1970
    bus_id  = qemu_opt_get_number(opts, "bus", 0);
1971
    unit_id = qemu_opt_get_number(opts, "unit", -1);
1972
    index   = qemu_opt_get_number(opts, "index", -1);
1973

    
1974
    cyls  = qemu_opt_get_number(opts, "cyls", 0);
1975
    heads = qemu_opt_get_number(opts, "heads", 0);
1976
    secs  = qemu_opt_get_number(opts, "secs", 0);
1977

    
1978
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
1979
    ro = qemu_opt_get_bool(opts, "readonly", 0);
1980

    
1981
    file = qemu_opt_get(opts, "file");
1982
    serial = qemu_opt_get(opts, "serial");
1983

    
1984
    if ((buf = qemu_opt_get(opts, "if")) != NULL) {
1985
        pstrcpy(devname, sizeof(devname), buf);
1986
        if (!strcmp(buf, "ide")) {
1987
            type = IF_IDE;
1988
            max_devs = MAX_IDE_DEVS;
1989
        } else if (!strcmp(buf, "scsi")) {
1990
            type = IF_SCSI;
1991
            max_devs = MAX_SCSI_DEVS;
1992
        } else if (!strcmp(buf, "floppy")) {
1993
            type = IF_FLOPPY;
1994
            max_devs = 0;
1995
        } else if (!strcmp(buf, "pflash")) {
1996
            type = IF_PFLASH;
1997
            max_devs = 0;
1998
        } else if (!strcmp(buf, "mtd")) {
1999
            type = IF_MTD;
2000
            max_devs = 0;
2001
        } else if (!strcmp(buf, "sd")) {
2002
            type = IF_SD;
2003
            max_devs = 0;
2004
        } else if (!strcmp(buf, "virtio")) {
2005
            type = IF_VIRTIO;
2006
            max_devs = 0;
2007
        } else if (!strcmp(buf, "xen")) {
2008
            type = IF_XEN;
2009
            max_devs = 0;
2010
        } else if (!strcmp(buf, "none")) {
2011
            type = IF_NONE;
2012
            max_devs = 0;
2013
        } else {
2014
            fprintf(stderr, "qemu: unsupported bus type '%s'\n", buf);
2015
            return NULL;
2016
        }
2017
    }
2018

    
2019
    if (cyls || heads || secs) {
2020
        if (cyls < 1 || (type == IF_IDE && cyls > 16383)) {
2021
            fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
2022
            return NULL;
2023
        }
2024
        if (heads < 1 || (type == IF_IDE && heads > 16)) {
2025
            fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
2026
            return NULL;
2027
        }
2028
        if (secs < 1 || (type == IF_IDE && secs > 63)) {
2029
            fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
2030
            return NULL;
2031
        }
2032
    }
2033

    
2034
    if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
2035
        if (!cyls) {
2036
            fprintf(stderr,
2037
                    "qemu: '%s' trans must be used with cyls,heads and secs\n",
2038
                    buf);
2039
            return NULL;
2040
        }
2041
        if (!strcmp(buf, "none"))
2042
            translation = BIOS_ATA_TRANSLATION_NONE;
2043
        else if (!strcmp(buf, "lba"))
2044
            translation = BIOS_ATA_TRANSLATION_LBA;
2045
        else if (!strcmp(buf, "auto"))
2046
            translation = BIOS_ATA_TRANSLATION_AUTO;
2047
        else {
2048
            fprintf(stderr, "qemu: '%s' invalid translation type\n", buf);
2049
            return NULL;
2050
        }
2051
    }
2052

    
2053
    if ((buf = qemu_opt_get(opts, "media")) != NULL) {
2054
        if (!strcmp(buf, "disk")) {
2055
            media = MEDIA_DISK;
2056
        } else if (!strcmp(buf, "cdrom")) {
2057
            if (cyls || secs || heads) {
2058
                fprintf(stderr,
2059
                        "qemu: '%s' invalid physical CHS format\n", buf);
2060
                return NULL;
2061
            }
2062
            media = MEDIA_CDROM;
2063
        } else {
2064
            fprintf(stderr, "qemu: '%s' invalid media\n", buf);
2065
            return NULL;
2066
        }
2067
    }
2068

    
2069
    if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
2070
        if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2071
            cache = 0;
2072
        else if (!strcmp(buf, "writethrough"))
2073
            cache = 1;
2074
        else if (!strcmp(buf, "writeback"))
2075
            cache = 2;
2076
        else {
2077
           fprintf(stderr, "qemu: invalid cache option\n");
2078
           return NULL;
2079
        }
2080
    }
2081

    
2082
#ifdef CONFIG_LINUX_AIO
2083
    if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
2084
        if (!strcmp(buf, "threads"))
2085
            aio = 0;
2086
        else if (!strcmp(buf, "native"))
2087
            aio = 1;
2088
        else {
2089
           fprintf(stderr, "qemu: invalid aio option\n");
2090
           return NULL;
2091
        }
2092
    }
2093
#endif
2094

    
2095
    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
2096
       if (strcmp(buf, "?") == 0) {
2097
            fprintf(stderr, "qemu: Supported formats:");
2098
            bdrv_iterate_format(bdrv_format_print, NULL);
2099
            fprintf(stderr, "\n");
2100
            return NULL;
2101
        }
2102
        drv = bdrv_find_whitelisted_format(buf);
2103
        if (!drv) {
2104
            fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2105
            return NULL;
2106
        }
2107
    }
2108

    
2109
    on_write_error = BLOCK_ERR_STOP_ENOSPC;
2110
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
2111
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2112
            fprintf(stderr, "werror is no supported by this format\n");
2113
            return NULL;
2114
        }
2115

    
2116
        on_write_error = parse_block_error_action(buf, 0);
2117
        if (on_write_error < 0) {
2118
            return NULL;
2119
        }
2120
    }
2121

    
2122
    on_read_error = BLOCK_ERR_REPORT;
2123
    if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
2124
        if (type != IF_IDE && type != IF_VIRTIO) {
2125
            fprintf(stderr, "rerror is no supported by this format\n");
2126
            return NULL;
2127
        }
2128

    
2129
        on_read_error = parse_block_error_action(buf, 1);
2130
        if (on_read_error < 0) {
2131
            return NULL;
2132
        }
2133
    }
2134

    
2135
    if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
2136
        if (type != IF_VIRTIO) {
2137
            fprintf(stderr, "addr is not supported\n");
2138
            return NULL;
2139
        }
2140
    }
2141

    
2142
    /* compute bus and unit according index */
2143

    
2144
    if (index != -1) {
2145
        if (bus_id != 0 || unit_id != -1) {
2146
            fprintf(stderr,
2147
                    "qemu: index cannot be used with bus and unit\n");
2148
            return NULL;
2149
        }
2150
        if (max_devs == 0)
2151
        {
2152
            unit_id = index;
2153
            bus_id = 0;
2154
        } else {
2155
            unit_id = index % max_devs;
2156
            bus_id = index / max_devs;
2157
        }
2158
    }
2159

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

    
2164
    if (unit_id == -1) {
2165
       unit_id = 0;
2166
       while (drive_get(type, bus_id, unit_id) != NULL) {
2167
           unit_id++;
2168
           if (max_devs && unit_id >= max_devs) {
2169
               unit_id -= max_devs;
2170
               bus_id++;
2171
           }
2172
       }
2173
    }
2174

    
2175
    /* check unit id */
2176

    
2177
    if (max_devs && unit_id >= max_devs) {
2178
        fprintf(stderr, "qemu: unit %d too big (max is %d)\n",
2179
                unit_id, max_devs - 1);
2180
        return NULL;
2181
    }
2182

    
2183
    /*
2184
     * ignore multiple definitions
2185
     */
2186

    
2187
    if (drive_get(type, bus_id, unit_id) != NULL) {
2188
        *fatal_error = 0;
2189
        return NULL;
2190
    }
2191

    
2192
    /* init */
2193

    
2194
    dinfo = qemu_mallocz(sizeof(*dinfo));
2195
    if ((buf = qemu_opts_id(opts)) != NULL) {
2196
        dinfo->id = qemu_strdup(buf);
2197
    } else {
2198
        /* no id supplied -> create one */
2199
        dinfo->id = qemu_mallocz(32);
2200
        if (type == IF_IDE || type == IF_SCSI)
2201
            mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2202
        if (max_devs)
2203
            snprintf(dinfo->id, 32, "%s%i%s%i",
2204
                     devname, bus_id, mediastr, unit_id);
2205
        else
2206
            snprintf(dinfo->id, 32, "%s%s%i",
2207
                     devname, mediastr, unit_id);
2208
    }
2209
    dinfo->bdrv = bdrv_new(dinfo->id);
2210
    dinfo->devaddr = devaddr;
2211
    dinfo->type = type;
2212
    dinfo->bus = bus_id;
2213
    dinfo->unit = unit_id;
2214
    dinfo->on_read_error = on_read_error;
2215
    dinfo->on_write_error = on_write_error;
2216
    dinfo->opts = opts;
2217
    if (serial)
2218
        strncpy(dinfo->serial, serial, sizeof(serial));
2219
    QTAILQ_INSERT_TAIL(&drives, dinfo, next);
2220

    
2221
    switch(type) {
2222
    case IF_IDE:
2223
    case IF_SCSI:
2224
    case IF_XEN:
2225
    case IF_NONE:
2226
        switch(media) {
2227
        case MEDIA_DISK:
2228
            if (cyls != 0) {
2229
                bdrv_set_geometry_hint(dinfo->bdrv, cyls, heads, secs);
2230
                bdrv_set_translation_hint(dinfo->bdrv, translation);
2231
            }
2232
            break;
2233
        case MEDIA_CDROM:
2234
            bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM);
2235
            break;
2236
        }
2237
        break;
2238
    case IF_SD:
2239
        /* FIXME: This isn't really a floppy, but it's a reasonable
2240
           approximation.  */
2241
    case IF_FLOPPY:
2242
        bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY);
2243
        break;
2244
    case IF_PFLASH:
2245
    case IF_MTD:
2246
        break;
2247
    case IF_VIRTIO:
2248
        /* add virtio block device */
2249
        opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
2250
        qemu_opt_set(opts, "driver", "virtio-blk-pci");
2251
        qemu_opt_set(opts, "drive", dinfo->id);
2252
        if (devaddr)
2253
            qemu_opt_set(opts, "addr", devaddr);
2254
        break;
2255
    case IF_COUNT:
2256
        abort();
2257
    }
2258
    if (!file) {
2259
        *fatal_error = 0;
2260
        return NULL;
2261
    }
2262
    bdrv_flags = 0;
2263
    if (snapshot) {
2264
        bdrv_flags |= BDRV_O_SNAPSHOT;
2265
        cache = 2; /* always use write-back with snapshot */
2266
    }
2267
    if (cache == 0) /* no caching */
2268
        bdrv_flags |= BDRV_O_NOCACHE;
2269
    else if (cache == 2) /* write-back */
2270
        bdrv_flags |= BDRV_O_CACHE_WB;
2271

    
2272
    if (aio == 1) {
2273
        bdrv_flags |= BDRV_O_NATIVE_AIO;
2274
    } else {
2275
        bdrv_flags &= ~BDRV_O_NATIVE_AIO;
2276
    }
2277

    
2278
    if (ro == 1) {
2279
        if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY) {
2280
            fprintf(stderr, "qemu: readonly flag not supported for drive with this interface\n");
2281
            return NULL;
2282
        }
2283
    }
2284
    /* 
2285
     * cdrom is read-only. Set it now, after above interface checking
2286
     * since readonly attribute not explicitly required, so no error.
2287
     */
2288
    if (media == MEDIA_CDROM) {
2289
        ro = 1;
2290
    }
2291
    bdrv_flags |= ro ? 0 : BDRV_O_RDWR;
2292

    
2293
    if (bdrv_open2(dinfo->bdrv, file, bdrv_flags, drv) < 0) {
2294
        fprintf(stderr, "qemu: could not open disk image %s: %s\n",
2295
                        file, strerror(errno));
2296
        return NULL;
2297
    }
2298

    
2299
    if (bdrv_key_required(dinfo->bdrv))
2300
        autostart = 0;
2301
    *fatal_error = 0;
2302
    return dinfo;
2303
}
2304

    
2305
static int drive_init_func(QemuOpts *opts, void *opaque)
2306
{
2307
    QEMUMachine *machine = opaque;
2308
    int fatal_error = 0;
2309

    
2310
    if (drive_init(opts, machine, &fatal_error) == NULL) {
2311
        if (fatal_error)
2312
            return 1;
2313
    }
2314
    return 0;
2315
}
2316

    
2317
static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
2318
{
2319
    if (NULL == qemu_opt_get(opts, "snapshot")) {
2320
        qemu_opt_set(opts, "snapshot", "on");
2321
    }
2322
    return 0;
2323
}
2324

    
2325
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
2326
{
2327
    boot_set_handler = func;
2328
    boot_set_opaque = opaque;
2329
}
2330

    
2331
int qemu_boot_set(const char *boot_devices)
2332
{
2333
    if (!boot_set_handler) {
2334
        return -EINVAL;
2335
    }
2336
    return boot_set_handler(boot_set_opaque, boot_devices);
2337
}
2338

    
2339
static int parse_bootdevices(char *devices)
2340
{
2341
    /* We just do some generic consistency checks */
2342
    const char *p;
2343
    int bitmap = 0;
2344

    
2345
    for (p = devices; *p != '\0'; p++) {
2346
        /* Allowed boot devices are:
2347
         * a-b: floppy disk drives
2348
         * c-f: IDE disk drives
2349
         * g-m: machine implementation dependant drives
2350
         * n-p: network devices
2351
         * It's up to each machine implementation to check if the given boot
2352
         * devices match the actual hardware implementation and firmware
2353
         * features.
2354
         */
2355
        if (*p < 'a' || *p > 'p') {
2356
            fprintf(stderr, "Invalid boot device '%c'\n", *p);
2357
            exit(1);
2358
        }
2359
        if (bitmap & (1 << (*p - 'a'))) {
2360
            fprintf(stderr, "Boot device '%c' was given twice\n", *p);
2361
            exit(1);
2362
        }
2363
        bitmap |= 1 << (*p - 'a');
2364
    }
2365
    return bitmap;
2366
}
2367

    
2368
static void restore_boot_devices(void *opaque)
2369
{
2370
    char *standard_boot_devices = opaque;
2371

    
2372
    qemu_boot_set(standard_boot_devices);
2373

    
2374
    qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
2375
    qemu_free(standard_boot_devices);
2376
}
2377

    
2378
static void numa_add(const char *optarg)
2379
{
2380
    char option[128];
2381
    char *endptr;
2382
    unsigned long long value, endvalue;
2383
    int nodenr;
2384

    
2385
    optarg = get_opt_name(option, 128, optarg, ',') + 1;
2386
    if (!strcmp(option, "node")) {
2387
        if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2388
            nodenr = nb_numa_nodes;
2389
        } else {
2390
            nodenr = strtoull(option, NULL, 10);
2391
        }
2392

    
2393
        if (get_param_value(option, 128, "mem", optarg) == 0) {
2394
            node_mem[nodenr] = 0;
2395
        } else {
2396
            value = strtoull(option, &endptr, 0);
2397
            switch (*endptr) {
2398
            case 0: case 'M': case 'm':
2399
                value <<= 20;
2400
                break;
2401
            case 'G': case 'g':
2402
                value <<= 30;
2403
                break;
2404
            }
2405
            node_mem[nodenr] = value;
2406
        }
2407
        if (get_param_value(option, 128, "cpus", optarg) == 0) {
2408
            node_cpumask[nodenr] = 0;
2409
        } else {
2410
            value = strtoull(option, &endptr, 10);
2411
            if (value >= 64) {
2412
                value = 63;
2413
                fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2414
            } else {
2415
                if (*endptr == '-') {
2416
                    endvalue = strtoull(endptr+1, &endptr, 10);
2417
                    if (endvalue >= 63) {
2418
                        endvalue = 62;
2419
                        fprintf(stderr,
2420
                            "only 63 CPUs in NUMA mode supported.\n");
2421
                    }
2422
                    value = (2ULL << endvalue) - (1ULL << value);
2423
                } else {
2424
                    value = 1ULL << value;
2425
                }
2426
            }
2427
            node_cpumask[nodenr] = value;
2428
        }
2429
        nb_numa_nodes++;
2430
    }
2431
    return;
2432
}
2433

    
2434
static void smp_parse(const char *optarg)
2435
{
2436
    int smp, sockets = 0, threads = 0, cores = 0;
2437
    char *endptr;
2438
    char option[128];
2439

    
2440
    smp = strtoul(optarg, &endptr, 10);
2441
    if (endptr != optarg) {
2442
        if (*endptr == ',') {
2443
            endptr++;
2444
        }
2445
    }
2446
    if (get_param_value(option, 128, "sockets", endptr) != 0)
2447
        sockets = strtoull(option, NULL, 10);
2448
    if (get_param_value(option, 128, "cores", endptr) != 0)
2449
        cores = strtoull(option, NULL, 10);
2450
    if (get_param_value(option, 128, "threads", endptr) != 0)
2451
        threads = strtoull(option, NULL, 10);
2452
    if (get_param_value(option, 128, "maxcpus", endptr) != 0)
2453
        max_cpus = strtoull(option, NULL, 10);
2454

    
2455
    /* compute missing values, prefer sockets over cores over threads */
2456
    if (smp == 0 || sockets == 0) {
2457
        sockets = sockets > 0 ? sockets : 1;
2458
        cores = cores > 0 ? cores : 1;
2459
        threads = threads > 0 ? threads : 1;
2460
        if (smp == 0) {
2461
            smp = cores * threads * sockets;
2462
        }
2463
    } else {
2464
        if (cores == 0) {
2465
            threads = threads > 0 ? threads : 1;
2466
            cores = smp / (sockets * threads);
2467
        } else {
2468
            if (sockets) {
2469
                threads = smp / (cores * sockets);
2470
            }
2471
        }
2472
    }
2473
    smp_cpus = smp;
2474
    smp_cores = cores > 0 ? cores : 1;
2475
    smp_threads = threads > 0 ? threads : 1;
2476
    if (max_cpus == 0)
2477
        max_cpus = smp_cpus;
2478
}
2479

    
2480
/***********************************************************/
2481
/* USB devices */
2482

    
2483
static int usb_device_add(const char *devname, int is_hotplug)
2484
{
2485
    const char *p;
2486
    USBDevice *dev = NULL;
2487

    
2488
    if (!usb_enabled)
2489
        return -1;
2490

    
2491
    /* drivers with .usbdevice_name entry in USBDeviceInfo */
2492
    dev = usbdevice_create(devname);
2493
    if (dev)
2494
        goto done;
2495

    
2496
    /* the other ones */
2497
    if (strstart(devname, "host:", &p)) {
2498
        dev = usb_host_device_open(p);
2499
    } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2500
        dev = usb_bt_init(devname[2] ? hci_init(p) :
2501
                        bt_new_hci(qemu_find_bt_vlan(0)));
2502
    } else {
2503
        return -1;
2504
    }
2505
    if (!dev)
2506
        return -1;
2507

    
2508
done:
2509
    return 0;
2510
}
2511

    
2512
static int usb_device_del(const char *devname)
2513
{
2514
    int bus_num, addr;
2515
    const char *p;
2516

    
2517
    if (strstart(devname, "host:", &p))
2518
        return usb_host_device_close(p);
2519

    
2520
    if (!usb_enabled)
2521
        return -1;
2522

    
2523
    p = strchr(devname, '.');
2524
    if (!p)
2525
        return -1;
2526
    bus_num = strtoul(devname, NULL, 0);
2527
    addr = strtoul(p + 1, NULL, 0);
2528

    
2529
    return usb_device_delete_addr(bus_num, addr);
2530
}
2531

    
2532
static int usb_parse(const char *cmdline)
2533
{
2534
    int r;
2535
    r = usb_device_add(cmdline, 0);
2536
    if (r < 0) {
2537
        fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
2538
    }
2539
    return r;
2540
}
2541

    
2542
void do_usb_add(Monitor *mon, const QDict *qdict)
2543
{
2544
    const char *devname = qdict_get_str(qdict, "devname");
2545
    if (usb_device_add(devname, 1) < 0) {
2546
        error_report("could not add USB device '%s'", devname);
2547
    }
2548
}
2549

    
2550
void do_usb_del(Monitor *mon, const QDict *qdict)
2551
{
2552
    const char *devname = qdict_get_str(qdict, "devname");
2553
    if (usb_device_del(devname) < 0) {
2554
        error_report("could not delete USB device '%s'", devname);
2555
    }
2556
}
2557

    
2558
/***********************************************************/
2559
/* PCMCIA/Cardbus */
2560

    
2561
static struct pcmcia_socket_entry_s {
2562
    PCMCIASocket *socket;
2563
    struct pcmcia_socket_entry_s *next;
2564
} *pcmcia_sockets = 0;
2565

    
2566
void pcmcia_socket_register(PCMCIASocket *socket)
2567
{
2568
    struct pcmcia_socket_entry_s *entry;
2569

    
2570
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2571
    entry->socket = socket;
2572
    entry->next = pcmcia_sockets;
2573
    pcmcia_sockets = entry;
2574
}
2575

    
2576
void pcmcia_socket_unregister(PCMCIASocket *socket)
2577
{
2578
    struct pcmcia_socket_entry_s *entry, **ptr;
2579

    
2580
    ptr = &pcmcia_sockets;
2581
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2582
        if (entry->socket == socket) {
2583
            *ptr = entry->next;
2584
            qemu_free(entry);
2585
        }
2586
}
2587

    
2588
void pcmcia_info(Monitor *mon)
2589
{
2590
    struct pcmcia_socket_entry_s *iter;
2591

    
2592
    if (!pcmcia_sockets)
2593
        monitor_printf(mon, "No PCMCIA sockets\n");
2594

    
2595
    for (iter = pcmcia_sockets; iter; iter = iter->next)
2596
        monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2597
                       iter->socket->attached ? iter->socket->card_string :
2598
                       "Empty");
2599
}
2600

    
2601
/***********************************************************/
2602
/* I/O handling */
2603

    
2604
typedef struct IOHandlerRecord {
2605
    int fd;
2606
    IOCanRWHandler *fd_read_poll;
2607
    IOHandler *fd_read;
2608
    IOHandler *fd_write;
2609
    int deleted;
2610
    void *opaque;
2611
    /* temporary data */
2612
    struct pollfd *ufd;
2613
    struct IOHandlerRecord *next;
2614
} IOHandlerRecord;
2615

    
2616
static IOHandlerRecord *first_io_handler;
2617

    
2618
/* XXX: fd_read_poll should be suppressed, but an API change is
2619
   necessary in the character devices to suppress fd_can_read(). */
2620
int qemu_set_fd_handler2(int fd,
2621
                         IOCanRWHandler *fd_read_poll,
2622
                         IOHandler *fd_read,
2623
                         IOHandler *fd_write,
2624
                         void *opaque)
2625
{
2626
    IOHandlerRecord **pioh, *ioh;
2627

    
2628
    if (!fd_read && !fd_write) {
2629
        pioh = &first_io_handler;
2630
        for(;;) {
2631
            ioh = *pioh;
2632
            if (ioh == NULL)
2633
                break;
2634
            if (ioh->fd == fd) {
2635
                ioh->deleted = 1;
2636
                break;
2637
            }
2638
            pioh = &ioh->next;
2639
        }
2640
    } else {
2641
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2642
            if (ioh->fd == fd)
2643
                goto found;
2644
        }
2645
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2646
        ioh->next = first_io_handler;
2647
        first_io_handler = ioh;
2648
    found:
2649
        ioh->fd = fd;
2650
        ioh->fd_read_poll = fd_read_poll;
2651
        ioh->fd_read = fd_read;
2652
        ioh->fd_write = fd_write;
2653
        ioh->opaque = opaque;
2654
        ioh->deleted = 0;
2655
    }
2656
    return 0;
2657
}
2658

    
2659
int qemu_set_fd_handler(int fd,
2660
                        IOHandler *fd_read,
2661
                        IOHandler *fd_write,
2662
                        void *opaque)
2663
{
2664
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2665
}
2666

    
2667
#ifdef _WIN32
2668
/***********************************************************/
2669
/* Polling handling */
2670

    
2671
typedef struct PollingEntry {
2672
    PollingFunc *func;
2673
    void *opaque;
2674
    struct PollingEntry *next;
2675
} PollingEntry;
2676

    
2677
static PollingEntry *first_polling_entry;
2678

    
2679
int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2680
{
2681
    PollingEntry **ppe, *pe;
2682
    pe = qemu_mallocz(sizeof(PollingEntry));
2683
    pe->func = func;
2684
    pe->opaque = opaque;
2685
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2686
    *ppe = pe;
2687
    return 0;
2688
}
2689

    
2690
void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2691
{
2692
    PollingEntry **ppe, *pe;
2693
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2694
        pe = *ppe;
2695
        if (pe->func == func && pe->opaque == opaque) {
2696
            *ppe = pe->next;
2697
            qemu_free(pe);
2698
            break;
2699
        }
2700
    }
2701
}
2702

    
2703
/***********************************************************/
2704
/* Wait objects support */
2705
typedef struct WaitObjects {
2706
    int num;
2707
    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
2708
    WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
2709
    void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
2710
} WaitObjects;
2711

    
2712
static WaitObjects wait_objects = {0};
2713

    
2714
int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2715
{
2716
    WaitObjects *w = &wait_objects;
2717

    
2718
    if (w->num >= MAXIMUM_WAIT_OBJECTS)
2719
        return -1;
2720
    w->events[w->num] = handle;
2721
    w->func[w->num] = func;
2722
    w->opaque[w->num] = opaque;
2723
    w->num++;
2724
    return 0;
2725
}
2726

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

    
2732
    found = 0;
2733
    for (i = 0; i < w->num; i++) {
2734
        if (w->events[i] == handle)
2735
            found = 1;
2736
        if (found) {
2737
            w->events[i] = w->events[i + 1];
2738
            w->func[i] = w->func[i + 1];
2739
            w->opaque[i] = w->opaque[i + 1];
2740
        }
2741
    }
2742
    if (found)
2743
        w->num--;
2744
}
2745
#endif
2746

    
2747
/***********************************************************/
2748
/* ram save/restore */
2749

    
2750
#define RAM_SAVE_FLAG_FULL        0x01 /* Obsolete, not used anymore */
2751
#define RAM_SAVE_FLAG_COMPRESS        0x02
2752
#define RAM_SAVE_FLAG_MEM_SIZE        0x04
2753
#define RAM_SAVE_FLAG_PAGE        0x08
2754
#define RAM_SAVE_FLAG_EOS        0x10
2755

    
2756
static int is_dup_page(uint8_t *page, uint8_t ch)
2757
{
2758
    uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
2759
    uint32_t *array = (uint32_t *)page;
2760
    int i;
2761

    
2762
    for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
2763
        if (array[i] != val)
2764
            return 0;
2765
    }
2766

    
2767
    return 1;
2768
}
2769

    
2770
static int ram_save_block(QEMUFile *f)
2771
{
2772
    static ram_addr_t current_addr = 0;
2773
    ram_addr_t saved_addr = current_addr;
2774
    ram_addr_t addr = 0;
2775
    int found = 0;
2776

    
2777
    while (addr < last_ram_offset) {
2778
        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
2779
            uint8_t *p;
2780

    
2781
            cpu_physical_memory_reset_dirty(current_addr,
2782
                                            current_addr + TARGET_PAGE_SIZE,
2783
                                            MIGRATION_DIRTY_FLAG);
2784

    
2785
            p = qemu_get_ram_ptr(current_addr);
2786

    
2787
            if (is_dup_page(p, *p)) {
2788
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
2789
                qemu_put_byte(f, *p);
2790
            } else {
2791
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
2792
                qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
2793
            }
2794

    
2795
            found = 1;
2796
            break;
2797
        }
2798
        addr += TARGET_PAGE_SIZE;
2799
        current_addr = (saved_addr + addr) % last_ram_offset;
2800
    }
2801

    
2802
    return found;
2803
}
2804

    
2805
static uint64_t bytes_transferred;
2806

    
2807
static ram_addr_t ram_save_remaining(void)
2808
{
2809
    ram_addr_t addr;
2810
    ram_addr_t count = 0;
2811

    
2812
    for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
2813
        if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
2814
            count++;
2815
    }
2816

    
2817
    return count;
2818
}
2819

    
2820
uint64_t ram_bytes_remaining(void)
2821
{
2822
    return ram_save_remaining() * TARGET_PAGE_SIZE;
2823
}
2824

    
2825
uint64_t ram_bytes_transferred(void)
2826
{
2827
    return bytes_transferred;
2828
}
2829

    
2830
uint64_t ram_bytes_total(void)
2831
{
2832
    return last_ram_offset;
2833
}
2834

    
2835
static int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
2836
{
2837
    ram_addr_t addr;
2838
    uint64_t bytes_transferred_last;
2839
    double bwidth = 0;
2840
    uint64_t expected_time = 0;
2841

    
2842
    if (stage < 0) {
2843
        cpu_physical_memory_set_dirty_tracking(0);
2844
        return 0;
2845
    }
2846

    
2847
    if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
2848
        qemu_file_set_error(f);
2849
        return 0;
2850
    }
2851

    
2852
    if (stage == 1) {
2853
        bytes_transferred = 0;
2854

    
2855
        /* Make sure all dirty bits are set */
2856
        for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
2857
            if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
2858
                cpu_physical_memory_set_dirty(addr);
2859
        }
2860

    
2861
        /* Enable dirty memory tracking */
2862
        cpu_physical_memory_set_dirty_tracking(1);
2863

    
2864
        qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
2865
    }
2866

    
2867
    bytes_transferred_last = bytes_transferred;
2868
    bwidth = qemu_get_clock_ns(rt_clock);
2869

    
2870
    while (!qemu_file_rate_limit(f)) {
2871
        int ret;
2872

    
2873
        ret = ram_save_block(f);
2874
        bytes_transferred += ret * TARGET_PAGE_SIZE;
2875
        if (ret == 0) /* no more blocks */
2876
            break;
2877
    }
2878

    
2879
    bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
2880
    bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
2881

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

    
2887
    /* try transferring iterative blocks of memory */
2888
    if (stage == 3) {
2889
        /* flush all remaining blocks regardless of rate limiting */
2890
        while (ram_save_block(f) != 0) {
2891
            bytes_transferred += TARGET_PAGE_SIZE;
2892
        }
2893
        cpu_physical_memory_set_dirty_tracking(0);
2894
    }
2895

    
2896
    qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
2897

    
2898
    expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
2899

    
2900
    return (stage == 2) && (expected_time <= migrate_max_downtime());
2901
}
2902

    
2903
static int ram_load(QEMUFile *f, void *opaque, int version_id)
2904
{
2905
    ram_addr_t addr;
2906
    int flags;
2907

    
2908
    if (version_id != 3)
2909
        return -EINVAL;
2910

    
2911
    do {
2912
        addr = qemu_get_be64(f);
2913

    
2914
        flags = addr & ~TARGET_PAGE_MASK;
2915
        addr &= TARGET_PAGE_MASK;
2916

    
2917
        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
2918
            if (addr != last_ram_offset)
2919
                return -EINVAL;
2920
        }
2921

    
2922
        if (flags & RAM_SAVE_FLAG_COMPRESS) {
2923
            uint8_t ch = qemu_get_byte(f);
2924
            memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
2925
#ifndef _WIN32
2926
            if (ch == 0 &&
2927
                (!kvm_enabled() || kvm_has_sync_mmu())) {
2928
                madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
2929
            }
2930
#endif
2931
        } else if (flags & RAM_SAVE_FLAG_PAGE) {
2932
            qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
2933
        }
2934
        if (qemu_file_has_error(f)) {
2935
            return -EIO;
2936
        }
2937
    } while (!(flags & RAM_SAVE_FLAG_EOS));
2938

    
2939
    return 0;
2940
}
2941

    
2942
void qemu_service_io(void)
2943
{
2944
    qemu_notify_event();
2945
}
2946

    
2947
/***********************************************************/
2948
/* machine registration */
2949

    
2950
static QEMUMachine *first_machine = NULL;
2951
QEMUMachine *current_machine = NULL;
2952

    
2953
int qemu_register_machine(QEMUMachine *m)
2954
{
2955
    QEMUMachine **pm;
2956
    pm = &first_machine;
2957
    while (*pm != NULL)
2958
        pm = &(*pm)->next;
2959
    m->next = NULL;
2960
    *pm = m;
2961
    return 0;
2962
}
2963

    
2964
static QEMUMachine *find_machine(const char *name)
2965
{
2966
    QEMUMachine *m;
2967

    
2968
    for(m = first_machine; m != NULL; m = m->next) {
2969
        if (!strcmp(m->name, name))
2970
            return m;
2971
        if (m->alias && !strcmp(m->alias, name))
2972
            return m;
2973
    }
2974
    return NULL;
2975
}
2976

    
2977
static QEMUMachine *find_default_machine(void)
2978
{
2979
    QEMUMachine *m;
2980

    
2981
    for(m = first_machine; m != NULL; m = m->next) {
2982
        if (m->is_default) {
2983
            return m;
2984
        }
2985
    }
2986
    return NULL;
2987
}
2988

    
2989
/***********************************************************/
2990
/* main execution loop */
2991

    
2992
static void gui_update(void *opaque)
2993
{
2994
    uint64_t interval = GUI_REFRESH_INTERVAL;
2995
    DisplayState *ds = opaque;
2996
    DisplayChangeListener *dcl = ds->listeners;
2997

    
2998
    qemu_flush_coalesced_mmio_buffer();
2999
    dpy_refresh(ds);
3000

    
3001
    while (dcl != NULL) {
3002
        if (dcl->gui_timer_interval &&
3003
            dcl->gui_timer_interval < interval)
3004
            interval = dcl->gui_timer_interval;
3005
        dcl = dcl->next;
3006
    }
3007
    qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3008
}
3009

    
3010
static void nographic_update(void *opaque)
3011
{
3012
    uint64_t interval = GUI_REFRESH_INTERVAL;
3013

    
3014
    qemu_flush_coalesced_mmio_buffer();
3015
    qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3016
}
3017

    
3018
void cpu_synchronize_all_states(void)
3019
{
3020
    CPUState *cpu;
3021

    
3022
    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
3023
        cpu_synchronize_state(cpu);
3024
    }
3025
}
3026

    
3027
void cpu_synchronize_all_post_reset(void)
3028
{
3029
    CPUState *cpu;
3030

    
3031
    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
3032
        cpu_synchronize_post_reset(cpu);
3033
    }
3034
}
3035

    
3036
void cpu_synchronize_all_post_init(void)
3037
{
3038
    CPUState *cpu;
3039

    
3040
    for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
3041
        cpu_synchronize_post_init(cpu);
3042
    }
3043
}
3044

    
3045
struct vm_change_state_entry {
3046
    VMChangeStateHandler *cb;
3047
    void *opaque;
3048
    QLIST_ENTRY (vm_change_state_entry) entries;
3049
};
3050

    
3051
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3052

    
3053
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3054
                                                     void *opaque)
3055
{
3056
    VMChangeStateEntry *e;
3057

    
3058
    e = qemu_mallocz(sizeof (*e));
3059

    
3060
    e->cb = cb;
3061
    e->opaque = opaque;
3062
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3063
    return e;
3064
}
3065

    
3066
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3067
{
3068
    QLIST_REMOVE (e, entries);
3069
    qemu_free (e);
3070
}
3071

    
3072
static void vm_state_notify(int running, int reason)
3073
{
3074
    VMChangeStateEntry *e;
3075

    
3076
    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3077
        e->cb(e->opaque, running, reason);
3078
    }
3079
}
3080

    
3081
static void resume_all_vcpus(void);
3082
static void pause_all_vcpus(void);
3083

    
3084
void vm_start(void)
3085
{
3086
    if (!vm_running) {
3087
        cpu_enable_ticks();
3088
        vm_running = 1;
3089
        vm_state_notify(1, 0);
3090
        qemu_rearm_alarm_timer(alarm_timer);
3091
        resume_all_vcpus();
3092
    }
3093
}
3094

    
3095
/* reset/shutdown handler */
3096

    
3097
typedef struct QEMUResetEntry {
3098
    QTAILQ_ENTRY(QEMUResetEntry) entry;
3099
    QEMUResetHandler *func;
3100
    void *opaque;
3101
} QEMUResetEntry;
3102

    
3103
static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
3104
    QTAILQ_HEAD_INITIALIZER(reset_handlers);
3105
static int reset_requested;
3106
static int shutdown_requested;
3107
static int powerdown_requested;
3108
static int debug_requested;
3109
static int vmstop_requested;
3110

    
3111
int qemu_shutdown_requested(void)
3112
{
3113
    int r = shutdown_requested;
3114
    shutdown_requested = 0;
3115
    return r;
3116
}
3117

    
3118
int qemu_reset_requested(void)
3119
{
3120
    int r = reset_requested;
3121
    reset_requested = 0;
3122
    return r;
3123
}
3124

    
3125
int qemu_powerdown_requested(void)
3126
{
3127
    int r = powerdown_requested;
3128
    powerdown_requested = 0;
3129
    return r;
3130
}
3131

    
3132
static int qemu_debug_requested(void)
3133
{
3134
    int r = debug_requested;
3135
    debug_requested = 0;
3136
    return r;
3137
}
3138

    
3139
static int qemu_vmstop_requested(void)
3140
{
3141
    int r = vmstop_requested;
3142
    vmstop_requested = 0;
3143
    return r;
3144
}
3145

    
3146
static void do_vm_stop(int reason)
3147
{
3148
    if (vm_running) {
3149
        cpu_disable_ticks();
3150
        vm_running = 0;
3151
        pause_all_vcpus();
3152
        vm_state_notify(0, reason);
3153
        monitor_protocol_event(QEVENT_STOP, NULL);
3154
    }
3155
}
3156

    
3157
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3158
{
3159
    QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
3160

    
3161
    re->func = func;
3162
    re->opaque = opaque;
3163
    QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
3164
}
3165

    
3166
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
3167
{
3168
    QEMUResetEntry *re;
3169

    
3170
    QTAILQ_FOREACH(re, &reset_handlers, entry) {
3171
        if (re->func == func && re->opaque == opaque) {
3172
            QTAILQ_REMOVE(&reset_handlers, re, entry);
3173
            qemu_free(re);
3174
            return;
3175
        }
3176
    }
3177
}
3178

    
3179
void qemu_system_reset(void)
3180
{
3181
    QEMUResetEntry *re, *nre;
3182

    
3183
    /* reset all devices */
3184
    QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
3185
        re->func(re->opaque);
3186
    }
3187
    monitor_protocol_event(QEVENT_RESET, NULL);
3188
    cpu_synchronize_all_post_reset();
3189
}
3190

    
3191
void qemu_system_reset_request(void)
3192
{
3193
    if (no_reboot) {
3194
        shutdown_requested = 1;
3195
    } else {
3196
        reset_requested = 1;
3197
    }
3198
    qemu_notify_event();
3199
}
3200

    
3201
void qemu_system_shutdown_request(void)
3202
{
3203
    shutdown_requested = 1;
3204
    qemu_notify_event();
3205
}
3206

    
3207
void qemu_system_powerdown_request(void)
3208
{
3209
    powerdown_requested = 1;
3210
    qemu_notify_event();
3211
}
3212

    
3213
#ifdef CONFIG_IOTHREAD
3214
static void qemu_system_vmstop_request(int reason)
3215
{
3216
    vmstop_requested = reason;
3217
    qemu_notify_event();
3218
}
3219
#endif
3220

    
3221
#ifndef _WIN32
3222
static int io_thread_fd = -1;
3223

    
3224
static void qemu_event_increment(void)
3225
{
3226
    /* Write 8 bytes to be compatible with eventfd.  */
3227
    static uint64_t val = 1;
3228
    ssize_t ret;
3229

    
3230
    if (io_thread_fd == -1)
3231
        return;
3232

    
3233
    do {
3234
        ret = write(io_thread_fd, &val, sizeof(val));
3235
    } while (ret < 0 && errno == EINTR);
3236

    
3237
    /* EAGAIN is fine, a read must be pending.  */
3238
    if (ret < 0 && errno != EAGAIN) {
3239
        fprintf(stderr, "qemu_event_increment: write() filed: %s\n",
3240
                strerror(errno));
3241
        exit (1);
3242
    }
3243
}
3244

    
3245
static void qemu_event_read(void *opaque)
3246
{
3247
    int fd = (unsigned long)opaque;
3248
    ssize_t len;
3249
    char buffer[512];
3250

    
3251
    /* Drain the notify pipe.  For eventfd, only 8 bytes will be read.  */
3252
    do {
3253
        len = read(fd, buffer, sizeof(buffer));
3254
    } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
3255
}
3256

    
3257
static int qemu_event_init(void)
3258
{
3259
    int err;
3260
    int fds[2];
3261

    
3262
    err = qemu_eventfd(fds);
3263
    if (err == -1)
3264
        return -errno;
3265

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

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

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

    
3277
    io_thread_fd = fds[1];
3278
    return 0;
3279

    
3280
fail:
3281
    close(fds[0]);
3282
    close(fds[1]);
3283
    return err;
3284
}
3285
#else
3286
HANDLE qemu_event_handle;
3287

    
3288
static void dummy_event_handler(void *opaque)
3289
{
3290
}
3291

    
3292
static int qemu_event_init(void)
3293
{
3294
    qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3295
    if (!qemu_event_handle) {
3296
        fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
3297
        return -1;
3298
    }
3299
    qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3300
    return 0;
3301
}
3302

    
3303
static void qemu_event_increment(void)
3304
{
3305
    if (!SetEvent(qemu_event_handle)) {
3306
        fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
3307
                GetLastError());
3308
        exit (1);
3309
    }
3310
}
3311
#endif
3312

    
3313
static int cpu_can_run(CPUState *env)
3314
{
3315
    if (env->stop)
3316
        return 0;
3317
    if (env->stopped)
3318
        return 0;
3319
    if (!vm_running)
3320
        return 0;
3321
    return 1;
3322
}
3323

    
3324
#ifndef CONFIG_IOTHREAD
3325
static int qemu_init_main_loop(void)
3326
{
3327
    return qemu_event_init();
3328
}
3329

    
3330
void qemu_init_vcpu(void *_env)
3331
{
3332
    CPUState *env = _env;
3333

    
3334
    env->nr_cores = smp_cores;
3335
    env->nr_threads = smp_threads;
3336
    if (kvm_enabled())
3337
        kvm_init_vcpu(env);
3338
    return;
3339
}
3340

    
3341
int qemu_cpu_self(void *env)
3342
{
3343
    return 1;
3344
}
3345

    
3346
static void resume_all_vcpus(void)
3347
{
3348
}
3349

    
3350
static void pause_all_vcpus(void)
3351
{
3352
}
3353

    
3354
void qemu_cpu_kick(void *env)
3355
{
3356
    return;
3357
}
3358

    
3359
void qemu_notify_event(void)
3360
{
3361
    CPUState *env = cpu_single_env;
3362

    
3363
    qemu_event_increment ();
3364
    if (env) {
3365
        cpu_exit(env);
3366
    }
3367
}
3368

    
3369
void qemu_mutex_lock_iothread(void) {}
3370
void qemu_mutex_unlock_iothread(void) {}
3371

    
3372
void vm_stop(int reason)
3373
{
3374
    do_vm_stop(reason);
3375
}
3376

    
3377
#else /* CONFIG_IOTHREAD */
3378

    
3379
#include "qemu-thread.h"
3380

    
3381
QemuMutex qemu_global_mutex;
3382
static QemuMutex qemu_fair_mutex;
3383

    
3384
static QemuThread io_thread;
3385

    
3386
static QemuThread *tcg_cpu_thread;
3387
static QemuCond *tcg_halt_cond;
3388

    
3389
static int qemu_system_ready;
3390
/* cpu creation */
3391
static QemuCond qemu_cpu_cond;
3392
/* system init */
3393
static QemuCond qemu_system_cond;
3394
static QemuCond qemu_pause_cond;
3395

    
3396
static void tcg_block_io_signals(void);
3397
static void kvm_block_io_signals(CPUState *env);
3398
static void unblock_io_signals(void);
3399
static int tcg_has_work(void);
3400
static int cpu_has_work(CPUState *env);
3401

    
3402
static int qemu_init_main_loop(void)
3403
{
3404
    int ret;
3405

    
3406
    ret = qemu_event_init();
3407
    if (ret)
3408
        return ret;
3409

    
3410
    qemu_cond_init(&qemu_pause_cond);
3411
    qemu_mutex_init(&qemu_fair_mutex);
3412
    qemu_mutex_init(&qemu_global_mutex);
3413
    qemu_mutex_lock(&qemu_global_mutex);
3414

    
3415
    unblock_io_signals();
3416
    qemu_thread_self(&io_thread);
3417

    
3418
    return 0;
3419
}
3420

    
3421
static void qemu_wait_io_event_common(CPUState *env)
3422
{
3423
    if (env->stop) {
3424
        env->stop = 0;
3425
        env->stopped = 1;
3426
        qemu_cond_signal(&qemu_pause_cond);
3427
    }
3428
}
3429

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

    
3435
    qemu_mutex_unlock(&qemu_global_mutex);
3436

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

    
3445
    qemu_mutex_lock(&qemu_global_mutex);
3446
    qemu_wait_io_event_common(env);
3447
}
3448

    
3449
static void qemu_kvm_eat_signal(CPUState *env, int timeout)
3450
{
3451
    struct timespec ts;
3452
    int r, e;
3453
    siginfo_t siginfo;
3454
    sigset_t waitset;
3455

    
3456
    ts.tv_sec = timeout / 1000;
3457
    ts.tv_nsec = (timeout % 1000) * 1000000;
3458

    
3459
    sigemptyset(&waitset);
3460
    sigaddset(&waitset, SIG_IPI);
3461

    
3462
    qemu_mutex_unlock(&qemu_global_mutex);
3463
    r = sigtimedwait(&waitset, &siginfo, &ts);
3464
    e = errno;
3465
    qemu_mutex_lock(&qemu_global_mutex);
3466

    
3467
    if (r == -1 && !(e == EAGAIN || e == EINTR)) {
3468
        fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
3469
        exit(1);
3470
    }
3471
}
3472

    
3473
static void qemu_kvm_wait_io_event(CPUState *env)
3474
{
3475
    while (!cpu_has_work(env))
3476
        qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3477

    
3478
    qemu_kvm_eat_signal(env, 0);
3479
    qemu_wait_io_event_common(env);
3480
}
3481

    
3482
static int qemu_cpu_exec(CPUState *env);
3483

    
3484
static void *kvm_cpu_thread_fn(void *arg)
3485
{
3486
    CPUState *env = arg;
3487

    
3488
    qemu_thread_self(env->thread);
3489
    if (kvm_enabled())
3490
        kvm_init_vcpu(env);
3491

    
3492
    kvm_block_io_signals(env);
3493

    
3494
    /* signal CPU creation */
3495
    qemu_mutex_lock(&qemu_global_mutex);
3496
    env->created = 1;
3497
    qemu_cond_signal(&qemu_cpu_cond);
3498

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

    
3503
    while (1) {
3504
        if (cpu_can_run(env))
3505
            qemu_cpu_exec(env);
3506
        qemu_kvm_wait_io_event(env);
3507
    }
3508

    
3509
    return NULL;
3510
}
3511

    
3512
static void tcg_cpu_exec(void);
3513

    
3514
static void *tcg_cpu_thread_fn(void *arg)
3515
{
3516
    CPUState *env = arg;
3517

    
3518
    tcg_block_io_signals();
3519
    qemu_thread_self(env->thread);
3520

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

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

    
3531
    while (1) {
3532
        tcg_cpu_exec();
3533
        qemu_wait_io_event(cur_cpu);
3534
    }
3535

    
3536
    return NULL;
3537
}
3538

    
3539
void qemu_cpu_kick(void *_env)
3540
{
3541
    CPUState *env = _env;
3542
    qemu_cond_broadcast(env->halt_cond);
3543
    if (kvm_enabled())
3544
        qemu_thread_signal(env->thread, SIG_IPI);
3545
}
3546

    
3547
int qemu_cpu_self(void *_env)
3548
{
3549
    CPUState *env = _env;
3550
    QemuThread this;
3551
 
3552
    qemu_thread_self(&this);
3553
 
3554
    return qemu_thread_equal(&this, env->thread);
3555
}
3556

    
3557
static void cpu_signal(int sig)
3558
{
3559
    if (cpu_single_env)
3560
        cpu_exit(cpu_single_env);
3561
}
3562

    
3563
static void tcg_block_io_signals(void)
3564
{
3565
    sigset_t set;
3566
    struct sigaction sigact;
3567

    
3568
    sigemptyset(&set);
3569
    sigaddset(&set, SIGUSR2);
3570
    sigaddset(&set, SIGIO);
3571
    sigaddset(&set, SIGALRM);
3572
    sigaddset(&set, SIGCHLD);
3573
    pthread_sigmask(SIG_BLOCK, &set, NULL);
3574

    
3575
    sigemptyset(&set);
3576
    sigaddset(&set, SIG_IPI);
3577
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3578

    
3579
    memset(&sigact, 0, sizeof(sigact));
3580
    sigact.sa_handler = cpu_signal;
3581
    sigaction(SIG_IPI, &sigact, NULL);
3582
}
3583

    
3584
static void dummy_signal(int sig)
3585
{
3586
}
3587

    
3588
static void kvm_block_io_signals(CPUState *env)
3589
{
3590
    int r;
3591
    sigset_t set;
3592
    struct sigaction sigact;
3593

    
3594
    sigemptyset(&set);
3595
    sigaddset(&set, SIGUSR2);
3596
    sigaddset(&set, SIGIO);
3597
    sigaddset(&set, SIGALRM);
3598
    sigaddset(&set, SIGCHLD);
3599
    sigaddset(&set, SIG_IPI);
3600
    pthread_sigmask(SIG_BLOCK, &set, NULL);
3601

    
3602
    pthread_sigmask(SIG_BLOCK, NULL, &set);
3603
    sigdelset(&set, SIG_IPI);
3604

    
3605
    memset(&sigact, 0, sizeof(sigact));
3606
    sigact.sa_handler = dummy_signal;
3607
    sigaction(SIG_IPI, &sigact, NULL);
3608

    
3609
    r = kvm_set_signal_mask(env, &set);
3610
    if (r) {
3611
        fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r));
3612
        exit(1);
3613
    }
3614
}
3615

    
3616
static void unblock_io_signals(void)
3617
{
3618
    sigset_t set;
3619

    
3620
    sigemptyset(&set);
3621
    sigaddset(&set, SIGUSR2);
3622
    sigaddset(&set, SIGIO);
3623
    sigaddset(&set, SIGALRM);
3624
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3625

    
3626
    sigemptyset(&set);
3627
    sigaddset(&set, SIG_IPI);
3628
    pthread_sigmask(SIG_BLOCK, &set, NULL);
3629
}
3630

    
3631
static void qemu_signal_lock(unsigned int msecs)
3632
{
3633
    qemu_mutex_lock(&qemu_fair_mutex);
3634

    
3635
    while (qemu_mutex_trylock(&qemu_global_mutex)) {
3636
        qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
3637
        if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
3638
            break;
3639
    }
3640
    qemu_mutex_unlock(&qemu_fair_mutex);
3641
}
3642

    
3643
void qemu_mutex_lock_iothread(void)
3644
{
3645
    if (kvm_enabled()) {
3646
        qemu_mutex_lock(&qemu_fair_mutex);
3647
        qemu_mutex_lock(&qemu_global_mutex);
3648
        qemu_mutex_unlock(&qemu_fair_mutex);
3649
    } else
3650
        qemu_signal_lock(100);
3651
}
3652

    
3653
void qemu_mutex_unlock_iothread(void)
3654
{
3655
    qemu_mutex_unlock(&qemu_global_mutex);
3656
}
3657

    
3658
static int all_vcpus_paused(void)
3659
{
3660
    CPUState *penv = first_cpu;
3661

    
3662
    while (penv) {
3663
        if (!penv->stopped)
3664
            return 0;
3665
        penv = (CPUState *)penv->next_cpu;
3666
    }
3667

    
3668
    return 1;
3669
}
3670

    
3671
static void pause_all_vcpus(void)
3672
{
3673
    CPUState *penv = first_cpu;
3674

    
3675
    while (penv) {
3676
        penv->stop = 1;
3677
        qemu_thread_signal(penv->thread, SIG_IPI);
3678
        qemu_cpu_kick(penv);
3679
        penv = (CPUState *)penv->next_cpu;
3680
    }
3681

    
3682
    while (!all_vcpus_paused()) {
3683
        qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
3684
        penv = first_cpu;
3685
        while (penv) {
3686
            qemu_thread_signal(penv->thread, SIG_IPI);
3687
            penv = (CPUState *)penv->next_cpu;
3688
        }
3689
    }
3690
}
3691

    
3692
static void resume_all_vcpus(void)
3693
{
3694
    CPUState *penv = first_cpu;
3695

    
3696
    while (penv) {
3697
        penv->stop = 0;
3698
        penv->stopped = 0;
3699
        qemu_thread_signal(penv->thread, SIG_IPI);
3700
        qemu_cpu_kick(penv);
3701
        penv = (CPUState *)penv->next_cpu;
3702
    }
3703
}
3704

    
3705
static void tcg_init_vcpu(void *_env)
3706
{
3707
    CPUState *env = _env;
3708
    /* share a single thread for all cpus with TCG */
3709
    if (!tcg_cpu_thread) {
3710
        env->thread = qemu_mallocz(sizeof(QemuThread));
3711
        env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3712
        qemu_cond_init(env->halt_cond);
3713
        qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
3714
        while (env->created == 0)
3715
            qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3716
        tcg_cpu_thread = env->thread;
3717
        tcg_halt_cond = env->halt_cond;
3718
    } else {
3719
        env->thread = tcg_cpu_thread;
3720
        env->halt_cond = tcg_halt_cond;
3721
    }
3722
}
3723

    
3724
static void kvm_start_vcpu(CPUState *env)
3725
{
3726
    env->thread = qemu_mallocz(sizeof(QemuThread));
3727
    env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3728
    qemu_cond_init(env->halt_cond);
3729
    qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
3730
    while (env->created == 0)
3731
        qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3732
}
3733

    
3734
void qemu_init_vcpu(void *_env)
3735
{
3736
    CPUState *env = _env;
3737

    
3738
    env->nr_cores = smp_cores;
3739
    env->nr_threads = smp_threads;
3740
    if (kvm_enabled())
3741
        kvm_start_vcpu(env);
3742
    else
3743
        tcg_init_vcpu(env);
3744
}
3745

    
3746
void qemu_notify_event(void)
3747
{
3748
    qemu_event_increment();
3749
}
3750

    
3751
void vm_stop(int reason)
3752
{
3753
    QemuThread me;
3754
    qemu_thread_self(&me);
3755

    
3756
    if (!qemu_thread_equal(&me, &io_thread)) {
3757
        qemu_system_vmstop_request(reason);
3758
        /*
3759
         * FIXME: should not return to device code in case
3760
         * vm_stop() has been requested.
3761
         */
3762
        if (cpu_single_env) {
3763
            cpu_exit(cpu_single_env);
3764
            cpu_single_env->stop = 1;
3765
        }
3766
        return;
3767
    }
3768
    do_vm_stop(reason);
3769
}
3770

    
3771
#endif
3772

    
3773

    
3774
#ifdef _WIN32
3775
static void host_main_loop_wait(int *timeout)
3776
{
3777
    int ret, ret2, i;
3778
    PollingEntry *pe;
3779

    
3780

    
3781
    /* XXX: need to suppress polling by better using win32 events */
3782
    ret = 0;
3783
    for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3784
        ret |= pe->func(pe->opaque);
3785
    }
3786
    if (ret == 0) {
3787
        int err;
3788
        WaitObjects *w = &wait_objects;
3789

    
3790
        ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3791
        if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3792
            if (w->func[ret - WAIT_OBJECT_0])
3793
                w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3794

    
3795
            /* Check for additional signaled events */
3796
            for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3797

    
3798
                /* Check if event is signaled */
3799
                ret2 = WaitForSingleObject(w->events[i], 0);
3800
                if(ret2 == WAIT_OBJECT_0) {
3801
                    if (w->func[i])
3802
                        w->func[i](w->opaque[i]);
3803
                } else if (ret2 == WAIT_TIMEOUT) {
3804
                } else {
3805
                    err = GetLastError();
3806
                    fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3807
                }
3808
            }
3809
        } else if (ret == WAIT_TIMEOUT) {
3810
        } else {
3811
            err = GetLastError();
3812
            fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3813
        }
3814
    }
3815

    
3816
    *timeout = 0;
3817
}
3818
#else
3819
static void host_main_loop_wait(int *timeout)
3820
{
3821
}
3822
#endif
3823

    
3824
void main_loop_wait(int timeout)
3825
{
3826
    IOHandlerRecord *ioh;
3827
    fd_set rfds, wfds, xfds;
3828
    int ret, nfds;
3829
    struct timeval tv;
3830

    
3831
    qemu_bh_update_timeout(&timeout);
3832

    
3833
    host_main_loop_wait(&timeout);
3834

    
3835
    /* poll any events */
3836
    /* XXX: separate device handlers from system ones */
3837
    nfds = -1;
3838
    FD_ZERO(&rfds);
3839
    FD_ZERO(&wfds);
3840
    FD_ZERO(&xfds);
3841
    for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3842
        if (ioh->deleted)
3843
            continue;
3844
        if (ioh->fd_read &&
3845
            (!ioh->fd_read_poll ||
3846
             ioh->fd_read_poll(ioh->opaque) != 0)) {
3847
            FD_SET(ioh->fd, &rfds);
3848
            if (ioh->fd > nfds)
3849
                nfds = ioh->fd;
3850
        }
3851
        if (ioh->fd_write) {
3852
            FD_SET(ioh->fd, &wfds);
3853
            if (ioh->fd > nfds)
3854
                nfds = ioh->fd;
3855
        }
3856
    }
3857

    
3858
    tv.tv_sec = timeout / 1000;
3859
    tv.tv_usec = (timeout % 1000) * 1000;
3860

    
3861
    slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3862

    
3863
    qemu_mutex_unlock_iothread();
3864
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3865
    qemu_mutex_lock_iothread();
3866
    if (ret > 0) {
3867
        IOHandlerRecord **pioh;
3868

    
3869
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3870
            if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3871
                ioh->fd_read(ioh->opaque);
3872
            }
3873
            if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3874
                ioh->fd_write(ioh->opaque);
3875
            }
3876
        }
3877

    
3878
        /* remove deleted IO handlers */
3879
        pioh = &first_io_handler;
3880
        while (*pioh) {
3881
            ioh = *pioh;
3882
            if (ioh->deleted) {
3883
                *pioh = ioh->next;
3884
                qemu_free(ioh);
3885
            } else
3886
                pioh = &ioh->next;
3887
        }
3888
    }
3889

    
3890
    slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
3891

    
3892
    /* rearm timer, if not periodic */
3893
    if (alarm_timer->expired) {
3894
        alarm_timer->expired = 0;
3895
        qemu_rearm_alarm_timer(alarm_timer);
3896
    }
3897

    
3898
    alarm_timer->pending = 0;
3899

    
3900
    /* vm time timers */
3901
    if (vm_running) {
3902
        if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3903
            qemu_run_timers(&active_timers[QEMU_CLOCK_VIRTUAL],
3904
                            qemu_get_clock(vm_clock));
3905
    }
3906

    
3907
    /* real time timers */
3908
    qemu_run_timers(&active_timers[QEMU_CLOCK_REALTIME],
3909
                    qemu_get_clock(rt_clock));
3910

    
3911
    qemu_run_timers(&active_timers[QEMU_CLOCK_HOST],
3912
                    qemu_get_clock(host_clock));
3913

    
3914
    /* Check bottom-halves last in case any of the earlier events triggered
3915
       them.  */
3916
    qemu_bh_poll();
3917

    
3918
}
3919

    
3920
static int qemu_cpu_exec(CPUState *env)
3921
{
3922
    int ret;
3923
#ifdef CONFIG_PROFILER
3924
    int64_t ti;
3925
#endif
3926

    
3927
#ifdef CONFIG_PROFILER
3928
    ti = profile_getclock();
3929
#endif
3930
    if (use_icount) {
3931
        int64_t count;
3932
        int decr;
3933
        qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3934
        env->icount_decr.u16.low = 0;
3935
        env->icount_extra = 0;
3936
        count = qemu_next_deadline();
3937
        count = (count + (1 << icount_time_shift) - 1)
3938
                >> icount_time_shift;
3939
        qemu_icount += count;
3940
        decr = (count > 0xffff) ? 0xffff : count;
3941
        count -= decr;
3942
        env->icount_decr.u16.low = decr;
3943
        env->icount_extra = count;
3944
    }
3945
    ret = cpu_exec(env);
3946
#ifdef CONFIG_PROFILER
3947
    qemu_time += profile_getclock() - ti;
3948
#endif
3949
    if (use_icount) {
3950
        /* Fold pending instructions back into the
3951
           instruction counter, and clear the interrupt flag.  */
3952
        qemu_icount -= (env->icount_decr.u16.low
3953
                        + env->icount_extra);
3954
        env->icount_decr.u32 = 0;
3955
        env->icount_extra = 0;
3956
    }
3957
    return ret;
3958
}
3959

    
3960
static void tcg_cpu_exec(void)
3961
{
3962
    int ret = 0;
3963

    
3964
    if (next_cpu == NULL)
3965
        next_cpu = first_cpu;
3966
    for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
3967
        CPUState *env = cur_cpu = next_cpu;
3968

    
3969
        if (alarm_timer->pending)
3970
            break;
3971
        if (cpu_can_run(env))
3972
            ret = qemu_cpu_exec(env);
3973
        else if (env->stop)
3974
            break;
3975

    
3976
        if (ret == EXCP_DEBUG) {
3977
            gdb_set_stop_cpu(env);
3978
            debug_requested = 1;
3979
            break;
3980
        }
3981
    }
3982
}
3983

    
3984
static int cpu_has_work(CPUState *env)
3985
{
3986
    if (env->stop)
3987
        return 1;
3988
    if (env->stopped)
3989
        return 0;
3990
    if (!env->halted)
3991
        return 1;
3992
    if (qemu_cpu_has_work(env))
3993
        return 1;
3994
    return 0;
3995
}
3996

    
3997
static int tcg_has_work(void)
3998
{
3999
    CPUState *env;
4000

    
4001
    for (env = first_cpu; env != NULL; env = env->next_cpu)
4002
        if (cpu_has_work(env))
4003
            return 1;
4004
    return 0;
4005
}
4006

    
4007
static int qemu_calculate_timeout(void)
4008
{
4009
#ifndef CONFIG_IOTHREAD
4010
    int timeout;
4011

    
4012
    if (!vm_running)
4013
        timeout = 5000;
4014
    else if (tcg_has_work())
4015
        timeout = 0;
4016
    else if (!use_icount)
4017
        timeout = 5000;
4018
    else {
4019
     /* XXX: use timeout computed from timers */
4020
        int64_t add;
4021
        int64_t delta;
4022
        /* Advance virtual time to the next event.  */
4023
        if (use_icount == 1) {
4024
            /* When not using an adaptive execution frequency
4025
               we tend to get badly out of sync with real time,
4026
               so just delay for a reasonable amount of time.  */
4027
            delta = 0;
4028
        } else {
4029
            delta = cpu_get_icount() - cpu_get_clock();
4030
        }
4031
        if (delta > 0) {
4032
            /* If virtual time is ahead of real time then just
4033
               wait for IO.  */
4034
            timeout = (delta / 1000000) + 1;
4035
        } else {
4036
            /* Wait for either IO to occur or the next
4037
               timer event.  */
4038
            add = qemu_next_deadline();
4039
            /* We advance the timer before checking for IO.
4040
               Limit the amount we advance so that early IO
4041
               activity won't get the guest too far ahead.  */
4042
            if (add > 10000000)
4043
                add = 10000000;
4044
            delta += add;
4045
            add = (add + (1 << icount_time_shift) - 1)
4046
                  >> icount_time_shift;
4047
            qemu_icount += add;
4048
            timeout = delta / 1000000;
4049
            if (timeout < 0)
4050
                timeout = 0;
4051
        }
4052
    }
4053

    
4054
    return timeout;
4055
#else /* CONFIG_IOTHREAD */
4056
    return 1000;
4057
#endif
4058
}
4059

    
4060
static int vm_can_run(void)
4061
{
4062
    if (powerdown_requested)
4063
        return 0;
4064
    if (reset_requested)
4065
        return 0;
4066
    if (shutdown_requested)
4067
        return 0;
4068
    if (debug_requested)
4069
        return 0;
4070
    return 1;
4071
}
4072

    
4073
qemu_irq qemu_system_powerdown;
4074

    
4075
static void main_loop(void)
4076
{
4077
    int r;
4078

    
4079
#ifdef CONFIG_IOTHREAD
4080
    qemu_system_ready = 1;
4081
    qemu_cond_broadcast(&qemu_system_cond);
4082
#endif
4083

    
4084
    for (;;) {
4085
        do {
4086
#ifdef CONFIG_PROFILER
4087
            int64_t ti;
4088
#endif
4089
#ifndef CONFIG_IOTHREAD
4090
            tcg_cpu_exec();
4091
#endif
4092
#ifdef CONFIG_PROFILER
4093
            ti = profile_getclock();
4094
#endif
4095
            main_loop_wait(qemu_calculate_timeout());
4096
#ifdef CONFIG_PROFILER
4097
            dev_time += profile_getclock() - ti;
4098
#endif
4099
        } while (vm_can_run());
4100

    
4101
        if (qemu_debug_requested()) {
4102
            vm_stop(EXCP_DEBUG);
4103
        }
4104
        if (qemu_shutdown_requested()) {
4105
            monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
4106
            if (no_shutdown) {
4107
                vm_stop(0);
4108
                no_shutdown = 0;
4109
            } else
4110
                break;
4111
        }
4112
        if (qemu_reset_requested()) {
4113
            pause_all_vcpus();
4114
            qemu_system_reset();
4115
            resume_all_vcpus();
4116
        }
4117
        if (qemu_powerdown_requested()) {
4118
            monitor_protocol_event(QEVENT_POWERDOWN, NULL);
4119
            qemu_irq_raise(qemu_system_powerdown);
4120
        }
4121
        if ((r = qemu_vmstop_requested())) {
4122
            vm_stop(r);
4123
        }
4124
    }
4125
    pause_all_vcpus();
4126
}
4127

    
4128
static void version(void)
4129
{
4130
    printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4131
}
4132

    
4133
static void help(int exitcode)
4134
{
4135
    const char *options_help =
4136
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4137
           opt_help
4138
#define DEFHEADING(text) stringify(text) "\n"
4139
#include "qemu-options.h"
4140
#undef DEF
4141
#undef DEFHEADING
4142
#undef GEN_DOCS
4143
        ;
4144
    version();
4145
    printf("usage: %s [options] [disk_image]\n"
4146
           "\n"
4147
           "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4148
           "\n"
4149
           "%s\n"
4150
           "During emulation, the following keys are useful:\n"
4151
           "ctrl-alt-f      toggle full screen\n"
4152
           "ctrl-alt-n      switch to virtual console 'n'\n"
4153
           "ctrl-alt        toggle mouse and keyboard grab\n"
4154
           "\n"
4155
           "When using -nographic, press 'ctrl-a h' to get some help.\n",
4156
           "qemu",
4157
           options_help);
4158
    exit(exitcode);
4159
}
4160

    
4161
#define HAS_ARG 0x0001
4162

    
4163
enum {
4164
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4165
    opt_enum,
4166
#define DEFHEADING(text)
4167
#include "qemu-options.h"
4168
#undef DEF
4169
#undef DEFHEADING
4170
#undef GEN_DOCS
4171
};
4172

    
4173
typedef struct QEMUOption {
4174
    const char *name;
4175
    int flags;
4176
    int index;
4177
} QEMUOption;
4178

    
4179
static const QEMUOption qemu_options[] = {
4180
    { "h", 0, QEMU_OPTION_h },
4181
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4182
    { option, opt_arg, opt_enum },
4183
#define DEFHEADING(text)
4184
#include "qemu-options.h"
4185
#undef DEF
4186
#undef DEFHEADING
4187
#undef GEN_DOCS
4188
    { NULL },
4189
};
4190

    
4191
#ifdef HAS_AUDIO
4192
struct soundhw soundhw[] = {
4193
#ifdef HAS_AUDIO_CHOICE
4194
#if defined(TARGET_I386) || defined(TARGET_MIPS)
4195
    {
4196
        "pcspk",
4197
        "PC speaker",
4198
        0,
4199
        1,
4200
        { .init_isa = pcspk_audio_init }
4201
    },
4202
#endif
4203

    
4204
#ifdef CONFIG_SB16
4205
    {
4206
        "sb16",
4207
        "Creative Sound Blaster 16",
4208
        0,
4209
        1,
4210
        { .init_isa = SB16_init }
4211
    },
4212
#endif
4213

    
4214
#ifdef CONFIG_CS4231A
4215
    {
4216
        "cs4231a",
4217
        "CS4231A",
4218
        0,
4219
        1,
4220
        { .init_isa = cs4231a_init }
4221
    },
4222
#endif
4223

    
4224
#ifdef CONFIG_ADLIB
4225
    {
4226
        "adlib",
4227
#ifdef HAS_YMF262
4228
        "Yamaha YMF262 (OPL3)",
4229
#else
4230
        "Yamaha YM3812 (OPL2)",
4231
#endif
4232
        0,
4233
        1,
4234
        { .init_isa = Adlib_init }
4235
    },
4236
#endif
4237

    
4238
#ifdef CONFIG_GUS
4239
    {
4240
        "gus",
4241
        "Gravis Ultrasound GF1",
4242
        0,
4243
        1,
4244
        { .init_isa = GUS_init }
4245
    },
4246
#endif
4247

    
4248
#ifdef CONFIG_AC97
4249
    {
4250
        "ac97",
4251
        "Intel 82801AA AC97 Audio",
4252
        0,
4253
        0,
4254
        { .init_pci = ac97_init }
4255
    },
4256
#endif
4257

    
4258
#ifdef CONFIG_ES1370
4259
    {
4260
        "es1370",
4261
        "ENSONIQ AudioPCI ES1370",
4262
        0,
4263
        0,
4264
        { .init_pci = es1370_init }
4265
    },
4266
#endif
4267

    
4268
#endif /* HAS_AUDIO_CHOICE */
4269

    
4270
    { NULL, NULL, 0, 0, { NULL } }
4271
};
4272

    
4273
static void select_soundhw (const char *optarg)
4274
{
4275
    struct soundhw *c;
4276

    
4277
    if (*optarg == '?') {
4278
    show_valid_cards:
4279

    
4280
        printf ("Valid sound card names (comma separated):\n");
4281
        for (c = soundhw; c->name; ++c) {
4282
            printf ("%-11s %s\n", c->name, c->descr);
4283
        }
4284
        printf ("\n-soundhw all will enable all of the above\n");
4285
        exit (*optarg != '?');
4286
    }
4287
    else {
4288
        size_t l;
4289
        const char *p;
4290
        char *e;
4291
        int bad_card = 0;
4292

    
4293
        if (!strcmp (optarg, "all")) {
4294
            for (c = soundhw; c->name; ++c) {
4295
                c->enabled = 1;
4296
            }
4297
            return;
4298
        }
4299

    
4300
        p = optarg;
4301
        while (*p) {
4302
            e = strchr (p, ',');
4303
            l = !e ? strlen (p) : (size_t) (e - p);
4304

    
4305
            for (c = soundhw; c->name; ++c) {
4306
                if (!strncmp (c->name, p, l) && !c->name[l]) {
4307
                    c->enabled = 1;
4308
                    break;
4309
                }
4310
            }
4311

    
4312
            if (!c->name) {
4313
                if (l > 80) {
4314
                    fprintf (stderr,
4315
                             "Unknown sound card name (too big to show)\n");
4316
                }
4317
                else {
4318
                    fprintf (stderr, "Unknown sound card name `%.*s'\n",
4319
                             (int) l, p);
4320
                }
4321
                bad_card = 1;
4322
            }
4323
            p += l + (e != NULL);
4324
        }
4325

    
4326
        if (bad_card)
4327
            goto show_valid_cards;
4328
    }
4329
}
4330
#endif
4331

    
4332
static void select_vgahw (const char *p)
4333
{
4334
    const char *opts;
4335

    
4336
    default_vga = 0;
4337
    vga_interface_type = VGA_NONE;
4338
    if (strstart(p, "std", &opts)) {
4339
        vga_interface_type = VGA_STD;
4340
    } else if (strstart(p, "cirrus", &opts)) {
4341
        vga_interface_type = VGA_CIRRUS;
4342
    } else if (strstart(p, "vmware", &opts)) {
4343
        vga_interface_type = VGA_VMWARE;
4344
    } else if (strstart(p, "xenfb", &opts)) {
4345
        vga_interface_type = VGA_XENFB;
4346
    } else if (!strstart(p, "none", &opts)) {
4347
    invalid_vga:
4348
        fprintf(stderr, "Unknown vga type: %s\n", p);
4349
        exit(1);
4350
    }
4351
    while (*opts) {
4352
        const char *nextopt;
4353

    
4354
        if (strstart(opts, ",retrace=", &nextopt)) {
4355
            opts = nextopt;
4356
            if (strstart(opts, "dumb", &nextopt))
4357
                vga_retrace_method = VGA_RETRACE_DUMB;
4358
            else if (strstart(opts, "precise", &nextopt))
4359
                vga_retrace_method = VGA_RETRACE_PRECISE;
4360
            else goto invalid_vga;
4361
        } else goto invalid_vga;
4362
        opts = nextopt;
4363
    }
4364
}
4365

    
4366
#ifdef TARGET_I386
4367
static int balloon_parse(const char *arg)
4368
{
4369
    QemuOpts *opts;
4370

    
4371
    if (strcmp(arg, "none") == 0) {
4372
        return 0;
4373
    }
4374

    
4375
    if (!strncmp(arg, "virtio", 6)) {
4376
        if (arg[6] == ',') {
4377
            /* have params -> parse them */
4378
            opts = qemu_opts_parse(&qemu_device_opts, arg+7, 0);
4379
            if (!opts)
4380
                return  -1;
4381
        } else {
4382
            /* create empty opts */
4383
            opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4384
        }
4385
        qemu_opt_set(opts, "driver", "virtio-balloon-pci");
4386
        return 0;
4387
    }
4388

    
4389
    return -1;
4390
}
4391
#endif
4392

    
4393
#ifdef _WIN32
4394
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4395
{
4396
    exit(STATUS_CONTROL_C_EXIT);
4397
    return TRUE;
4398
}
4399
#endif
4400

    
4401
int qemu_uuid_parse(const char *str, uint8_t *uuid)
4402
{
4403
    int ret;
4404

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

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

    
4412
    if(ret != 16)
4413
        return -1;
4414

    
4415
#ifdef TARGET_I386
4416
    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4417
#endif
4418

    
4419
    return 0;
4420
}
4421

    
4422
#ifndef _WIN32
4423

    
4424
static void termsig_handler(int signal)
4425
{
4426
    qemu_system_shutdown_request();
4427
}
4428

    
4429
static void sigchld_handler(int signal)
4430
{
4431
    waitpid(-1, NULL, WNOHANG);
4432
}
4433

    
4434
static void sighandler_setup(void)
4435
{
4436
    struct sigaction act;
4437

    
4438
    memset(&act, 0, sizeof(act));
4439
    act.sa_handler = termsig_handler;
4440
    sigaction(SIGINT,  &act, NULL);
4441
    sigaction(SIGHUP,  &act, NULL);
4442
    sigaction(SIGTERM, &act, NULL);
4443

    
4444
    act.sa_handler = sigchld_handler;
4445
    act.sa_flags = SA_NOCLDSTOP;
4446
    sigaction(SIGCHLD, &act, NULL);
4447
}
4448

    
4449
#endif
4450

    
4451
#ifdef _WIN32
4452
/* Look for support files in the same directory as the executable.  */
4453
static char *find_datadir(const char *argv0)
4454
{
4455
    char *p;
4456
    char buf[MAX_PATH];
4457
    DWORD len;
4458

    
4459
    len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4460
    if (len == 0) {
4461
        return NULL;
4462
    }
4463

    
4464
    buf[len] = 0;
4465
    p = buf + len - 1;
4466
    while (p != buf && *p != '\\')
4467
        p--;
4468
    *p = 0;
4469
    if (access(buf, R_OK) == 0) {
4470
        return qemu_strdup(buf);
4471
    }
4472
    return NULL;
4473
}
4474
#else /* !_WIN32 */
4475

    
4476
/* Find a likely location for support files using the location of the binary.
4477
   For installed binaries this will be "$bindir/../share/qemu".  When
4478
   running from the build tree this will be "$bindir/../pc-bios".  */
4479
#define SHARE_SUFFIX "/share/qemu"
4480
#define BUILD_SUFFIX "/pc-bios"
4481
static char *find_datadir(const char *argv0)
4482
{
4483
    char *dir;
4484
    char *p = NULL;
4485
    char *res;
4486
    char buf[PATH_MAX];
4487
    size_t max_len;
4488

    
4489
#if defined(__linux__)
4490
    {
4491
        int len;
4492
        len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4493
        if (len > 0) {
4494
            buf[len] = 0;
4495
            p = buf;
4496
        }
4497
    }
4498
#elif defined(__FreeBSD__)
4499
    {
4500
        int len;
4501
        len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4502
        if (len > 0) {
4503
            buf[len] = 0;
4504
            p = buf;
4505
        }
4506
    }
4507
#endif
4508
    /* If we don't have any way of figuring out the actual executable
4509
       location then try argv[0].  */
4510
    if (!p) {
4511
        p = realpath(argv0, buf);
4512
        if (!p) {
4513
            return NULL;
4514
        }
4515
    }
4516
    dir = dirname(p);
4517
    dir = dirname(dir);
4518

    
4519
    max_len = strlen(dir) +
4520
        MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4521
    res = qemu_mallocz(max_len);
4522
    snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4523
    if (access(res, R_OK)) {
4524
        snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4525
        if (access(res, R_OK)) {
4526
            qemu_free(res);
4527
            res = NULL;
4528
        }
4529
    }
4530

    
4531
    return res;
4532
}
4533
#undef SHARE_SUFFIX
4534
#undef BUILD_SUFFIX
4535
#endif
4536

    
4537
char *qemu_find_file(int type, const char *name)
4538
{
4539
    int len;
4540
    const char *subdir;
4541
    char *buf;
4542

    
4543
    /* If name contains path separators then try it as a straight path.  */
4544
    if ((strchr(name, '/') || strchr(name, '\\'))
4545
        && access(name, R_OK) == 0) {
4546
        return qemu_strdup(name);
4547
    }
4548
    switch (type) {
4549
    case QEMU_FILE_TYPE_BIOS:
4550
        subdir = "";
4551
        break;
4552
    case QEMU_FILE_TYPE_KEYMAP:
4553
        subdir = "keymaps/";
4554
        break;
4555
    default:
4556
        abort();
4557
    }
4558
    len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4559
    buf = qemu_mallocz(len);
4560
    snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4561
    if (access(buf, R_OK)) {
4562
        qemu_free(buf);
4563
        return NULL;
4564
    }
4565
    return buf;
4566
}
4567

    
4568
static int device_help_func(QemuOpts *opts, void *opaque)
4569
{
4570
    return qdev_device_help(opts);
4571
}
4572

    
4573
static int device_init_func(QemuOpts *opts, void *opaque)
4574
{
4575
    DeviceState *dev;
4576

    
4577
    dev = qdev_device_add(opts);
4578
    if (!dev)
4579
        return -1;
4580
    return 0;
4581
}
4582

    
4583
static int chardev_init_func(QemuOpts *opts, void *opaque)
4584
{
4585
    CharDriverState *chr;
4586

    
4587
    chr = qemu_chr_open_opts(opts, NULL);
4588
    if (!chr)
4589
        return -1;
4590
    return 0;
4591
}
4592

    
4593
static int mon_init_func(QemuOpts *opts, void *opaque)
4594
{
4595
    CharDriverState *chr;
4596
    const char *chardev;
4597
    const char *mode;
4598
    int flags;
4599

    
4600
    mode = qemu_opt_get(opts, "mode");
4601
    if (mode == NULL) {
4602
        mode = "readline";
4603
    }
4604
    if (strcmp(mode, "readline") == 0) {
4605
        flags = MONITOR_USE_READLINE;
4606
    } else if (strcmp(mode, "control") == 0) {
4607
        flags = MONITOR_USE_CONTROL;
4608
    } else {
4609
        fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
4610
        exit(1);
4611
    }
4612

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

    
4616
    chardev = qemu_opt_get(opts, "chardev");
4617
    chr = qemu_chr_find(chardev);
4618
    if (chr == NULL) {
4619
        fprintf(stderr, "chardev \"%s\" not found\n", chardev);
4620
        exit(1);
4621
    }
4622

    
4623
    monitor_init(chr, flags);
4624
    return 0;
4625
}
4626

    
4627
static void monitor_parse(const char *optarg, const char *mode)
4628
{
4629
    static int monitor_device_index = 0;
4630
    QemuOpts *opts;
4631
    const char *p;
4632
    char label[32];
4633
    int def = 0;
4634

    
4635
    if (strstart(optarg, "chardev:", &p)) {
4636
        snprintf(label, sizeof(label), "%s", p);
4637
    } else {
4638
        if (monitor_device_index) {
4639
            snprintf(label, sizeof(label), "monitor%d",
4640
                     monitor_device_index);
4641
        } else {
4642
            snprintf(label, sizeof(label), "monitor");
4643
            def = 1;
4644
        }
4645
        opts = qemu_chr_parse_compat(label, optarg);
4646
        if (!opts) {
4647
            fprintf(stderr, "parse error: %s\n", optarg);
4648
            exit(1);
4649
        }
4650
    }
4651

    
4652
    opts = qemu_opts_create(&qemu_mon_opts, label, 1);
4653
    if (!opts) {
4654
        fprintf(stderr, "duplicate chardev: %s\n", label);
4655
        exit(1);
4656
    }
4657
    qemu_opt_set(opts, "mode", mode);
4658
    qemu_opt_set(opts, "chardev", label);
4659
    if (def)
4660
        qemu_opt_set(opts, "default", "on");
4661
    monitor_device_index++;
4662
}
4663

    
4664
struct device_config {
4665
    enum {
4666
        DEV_USB,       /* -usbdevice     */
4667
        DEV_BT,        /* -bt            */
4668
        DEV_SERIAL,    /* -serial        */
4669
        DEV_PARALLEL,  /* -parallel      */
4670
        DEV_VIRTCON,   /* -virtioconsole */
4671
        DEV_DEBUGCON,  /* -debugcon */
4672
    } type;
4673
    const char *cmdline;
4674
    QTAILQ_ENTRY(device_config) next;
4675
};
4676
QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
4677

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

    
4682
    conf = qemu_mallocz(sizeof(*conf));
4683
    conf->type = type;
4684
    conf->cmdline = cmdline;
4685
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
4686
}
4687

    
4688
static int foreach_device_config(int type, int (*func)(const char *cmdline))
4689
{
4690
    struct device_config *conf;
4691
    int rc;
4692

    
4693
    QTAILQ_FOREACH(conf, &device_configs, next) {
4694
        if (conf->type != type)
4695
            continue;
4696
        rc = func(conf->cmdline);
4697
        if (0 != rc)
4698
            return rc;
4699
    }
4700
    return 0;
4701
}
4702

    
4703
static int serial_parse(const char *devname)
4704
{
4705
    static int index = 0;
4706
    char label[32];
4707

    
4708
    if (strcmp(devname, "none") == 0)
4709
        return 0;
4710
    if (index == MAX_SERIAL_PORTS) {
4711
        fprintf(stderr, "qemu: too many serial ports\n");
4712
        exit(1);
4713
    }
4714
    snprintf(label, sizeof(label), "serial%d", index);
4715
    serial_hds[index] = qemu_chr_open(label, devname, NULL);
4716
    if (!serial_hds[index]) {
4717
        fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
4718
                devname, strerror(errno));
4719
        return -1;
4720
    }
4721
    index++;
4722
    return 0;
4723
}
4724

    
4725
static int parallel_parse(const char *devname)
4726
{
4727
    static int index = 0;
4728
    char label[32];
4729

    
4730
    if (strcmp(devname, "none") == 0)
4731
        return 0;
4732
    if (index == MAX_PARALLEL_PORTS) {
4733
        fprintf(stderr, "qemu: too many parallel ports\n");
4734
        exit(1);
4735
    }
4736
    snprintf(label, sizeof(label), "parallel%d", index);
4737
    parallel_hds[index] = qemu_chr_open(label, devname, NULL);
4738
    if (!parallel_hds[index]) {
4739
        fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
4740
                devname, strerror(errno));
4741
        return -1;
4742
    }
4743
    index++;
4744
    return 0;
4745
}
4746

    
4747
static int virtcon_parse(const char *devname)
4748
{
4749
    static int index = 0;
4750
    char label[32];
4751
    QemuOpts *bus_opts, *dev_opts;
4752

    
4753
    if (strcmp(devname, "none") == 0)
4754
        return 0;
4755
    if (index == MAX_VIRTIO_CONSOLES) {
4756
        fprintf(stderr, "qemu: too many virtio consoles\n");
4757
        exit(1);
4758
    }
4759

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

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

    
4766
    snprintf(label, sizeof(label), "virtcon%d", index);
4767
    virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
4768
    if (!virtcon_hds[index]) {
4769
        fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
4770
                devname, strerror(errno));
4771
        return -1;
4772
    }
4773
    qemu_opt_set(dev_opts, "chardev", label);
4774

    
4775
    index++;
4776
    return 0;
4777
}
4778

    
4779
static int debugcon_parse(const char *devname)
4780
{   
4781
    QemuOpts *opts;
4782

    
4783
    if (!qemu_chr_open("debugcon", devname, NULL)) {
4784
        exit(1);
4785
    }
4786
    opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
4787
    if (!opts) {
4788
        fprintf(stderr, "qemu: already have a debugcon device\n");
4789
        exit(1);
4790
    }
4791
    qemu_opt_set(opts, "driver", "isa-debugcon");
4792
    qemu_opt_set(opts, "chardev", "debugcon");
4793
    return 0;
4794
}
4795

    
4796
static const QEMUOption *lookup_opt(int argc, char **argv,
4797
                                    const char **poptarg, int *poptind)
4798
{
4799
    const QEMUOption *popt;
4800
    int optind = *poptind;
4801
    char *r = argv[optind];
4802
    const char *optarg;
4803

    
4804
    loc_set_cmdline(argv, optind, 1);
4805
    optind++;
4806
    /* Treat --foo the same as -foo.  */
4807
    if (r[1] == '-')
4808
        r++;
4809
    popt = qemu_options;
4810
    for(;;) {
4811
        if (!popt->name) {
4812
            error_report("invalid option");
4813
            exit(1);
4814
        }
4815
        if (!strcmp(popt->name, r + 1))
4816
            break;
4817
        popt++;
4818
    }
4819
    if (popt->flags & HAS_ARG) {
4820
        if (optind >= argc) {
4821
            error_report("requires an argument");
4822
            exit(1);
4823
        }
4824
        optarg = argv[optind++];
4825
        loc_set_cmdline(argv, optind - 2, 2);
4826
    } else {
4827
        optarg = NULL;
4828
    }
4829

    
4830
    *poptarg = optarg;
4831
    *poptind = optind;
4832

    
4833
    return popt;
4834
}
4835

    
4836
int main(int argc, char **argv, char **envp)
4837
{
4838
    const char *gdbstub_dev = NULL;
4839
    uint32_t boot_devices_bitmap = 0;
4840
    int i;
4841
    int snapshot, linux_boot, net_boot;
4842
    const char *initrd_filename;
4843
    const char *kernel_filename, *kernel_cmdline;
4844
    char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4845
    DisplayState *ds;
4846
    DisplayChangeListener *dcl;
4847
    int cyls, heads, secs, translation;
4848
    QemuOpts *hda_opts = NULL, *opts;
4849
    int optind;
4850
    const char *optarg;
4851
    const char *loadvm = NULL;
4852
    QEMUMachine *machine;
4853
    const char *cpu_model;
4854
#ifndef _WIN32
4855
    int fds[2];
4856
#endif
4857
    int tb_size;
4858
    const char *pid_file = NULL;
4859
    const char *incoming = NULL;
4860
#ifndef _WIN32
4861
    int fd = 0;
4862
    struct passwd *pwd = NULL;
4863
    const char *chroot_dir = NULL;
4864
    const char *run_as = NULL;
4865
#endif
4866
    CPUState *env;
4867
    int show_vnc_port = 0;
4868
    int defconfig = 1;
4869

    
4870
    error_set_progname(argv[0]);
4871

    
4872
    init_clocks();
4873

    
4874
    qemu_cache_utils_init(envp);
4875

    
4876
    QLIST_INIT (&vm_change_state_head);
4877
#ifndef _WIN32
4878
    {
4879
        struct sigaction act;
4880
        sigfillset(&act.sa_mask);
4881
        act.sa_flags = 0;
4882
        act.sa_handler = SIG_IGN;
4883
        sigaction(SIGPIPE, &act, NULL);
4884
    }
4885
#else
4886
    SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4887
    /* Note: cpu_interrupt() is currently not SMP safe, so we force
4888
       QEMU to run on a single CPU */
4889
    {
4890
        HANDLE h;
4891
        DWORD mask, smask;
4892
        int i;
4893
        h = GetCurrentProcess();
4894
        if (GetProcessAffinityMask(h, &mask, &smask)) {
4895
            for(i = 0; i < 32; i++) {
4896
                if (mask & (1 << i))
4897
                    break;
4898
            }
4899
            if (i != 32) {
4900
                mask = 1 << i;
4901
                SetProcessAffinityMask(h, mask);
4902
            }
4903
        }
4904
    }
4905
#endif
4906

    
4907
    module_call_init(MODULE_INIT_MACHINE);
4908
    machine = find_default_machine();
4909
    cpu_model = NULL;
4910
    initrd_filename = NULL;
4911
    ram_size = 0;
4912
    snapshot = 0;
4913
    kernel_filename = NULL;
4914
    kernel_cmdline = "";
4915
    cyls = heads = secs = 0;
4916
    translation = BIOS_ATA_TRANSLATION_AUTO;
4917

    
4918
    for (i = 0; i < MAX_NODES; i++) {
4919
        node_mem[i] = 0;
4920
        node_cpumask[i] = 0;
4921
    }
4922

    
4923
    nb_numa_nodes = 0;
4924
    nb_nics = 0;
4925

    
4926
    tb_size = 0;
4927
    autostart= 1;
4928

    
4929
    /* first pass of option parsing */
4930
    optind = 1;
4931
    while (optind < argc) {
4932
        if (argv[optind][0] != '-') {
4933
            /* disk image */
4934
            optind++;
4935
            continue;
4936
        } else {
4937
            const QEMUOption *popt;
4938

    
4939
            popt = lookup_opt(argc, argv, &optarg, &optind);
4940
            switch (popt->index) {
4941
            case QEMU_OPTION_nodefconfig:
4942
                defconfig=0;
4943
                break;
4944
            }
4945
        }
4946
    }
4947

    
4948
    if (defconfig) {
4949
        const char *fname;
4950
        FILE *fp;
4951

    
4952
        fname = CONFIG_QEMU_CONFDIR "/qemu.conf";
4953
        fp = fopen(fname, "r");
4954
        if (fp) {
4955
            if (qemu_config_parse(fp, fname) != 0) {
4956
                exit(1);
4957
            }
4958
            fclose(fp);
4959
        }
4960

    
4961
        fname = CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf";
4962
        fp = fopen(fname, "r");
4963
        if (fp) {
4964
            if (qemu_config_parse(fp, fname) != 0) {
4965
                exit(1);
4966
            }
4967
            fclose(fp);
4968
        }
4969
    }
4970
#if defined(cpudef_setup)