Statistics
| Branch: | Revision:

root / vl.c @ 1d0f0d91

History | View | Annotate | Download (154.8 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
static DisplayState *display_state;
186
DisplayType display_type = DT_DEFAULT;
187
const char* keyboard_layout = NULL;
188
ram_addr_t ram_size;
189
int nb_nics;
190
NICInfo nd_table[MAX_NICS];
191
int vm_running;
192
int autostart;
193
static int rtc_utc = 1;
194
static int rtc_date_offset = -1; /* -1 means no change */
195
QEMUClock *rtc_clock;
196
int vga_interface_type = VGA_NONE;
197
#ifdef TARGET_SPARC
198
int graphic_width = 1024;
199
int graphic_height = 768;
200
int graphic_depth = 8;
201
#else
202
int graphic_width = 800;
203
int graphic_height = 600;
204
int graphic_depth = 15;
205
#endif
206
static int full_screen = 0;
207
#ifdef CONFIG_SDL
208
static int no_frame = 0;
209
#endif
210
int no_quit = 0;
211
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
212
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
213
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
214
#ifdef TARGET_I386
215
int win2k_install_hack = 0;
216
int rtc_td_hack = 0;
217
#endif
218
int usb_enabled = 0;
219
int singlestep = 0;
220
int smp_cpus = 1;
221
int max_cpus = 0;
222
int smp_cores = 1;
223
int smp_threads = 1;
224
const char *vnc_display;
225
int acpi_enabled = 1;
226
int no_hpet = 0;
227
int fd_bootchk = 1;
228
int no_reboot = 0;
229
int no_shutdown = 0;
230
int cursor_hide = 1;
231
int graphic_rotate = 0;
232
uint8_t irq0override = 1;
233
#ifndef _WIN32
234
int daemonize = 0;
235
#endif
236
const char *watchdog;
237
const char *option_rom[MAX_OPTION_ROMS];
238
int nb_option_roms;
239
int semihosting_enabled = 0;
240
#ifdef TARGET_ARM
241
int old_param = 0;
242
#endif
243
const char *qemu_name;
244
int alt_grab = 0;
245
int ctrl_grab = 0;
246
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
247
unsigned int nb_prom_envs = 0;
248
const char *prom_envs[MAX_PROM_ENVS];
249
#endif
250
int boot_menu;
251

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

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

    
269
uint8_t qemu_uuid[16];
270

    
271
static QEMUBootSetHandler *boot_set_handler;
272
static void *boot_set_opaque;
273

    
274
static int default_serial = 1;
275
static int default_parallel = 1;
276
static int default_virtcon = 1;
277
static int default_monitor = 1;
278
static int default_vga = 1;
279
static int default_floppy = 1;
280
static int default_cdrom = 1;
281
static int default_sdcard = 1;
282

    
283
static struct {
284
    const char *driver;
285
    int *flag;
286
} default_list[] = {
287
    { .driver = "isa-serial",           .flag = &default_serial    },
288
    { .driver = "isa-parallel",         .flag = &default_parallel  },
289
    { .driver = "isa-fdc",              .flag = &default_floppy    },
290
    { .driver = "ide-drive",            .flag = &default_cdrom     },
291
    { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
292
    { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },
293
    { .driver = "virtio-serial",        .flag = &default_virtcon   },
294
    { .driver = "VGA",                  .flag = &default_vga       },
295
    { .driver = "cirrus-vga",           .flag = &default_vga       },
296
    { .driver = "vmware-svga",          .flag = &default_vga       },
297
};
298

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

    
304
    if (!driver)
305
        return 0;
306
    for (i = 0; i < ARRAY_SIZE(default_list); i++) {
307
        if (strcmp(default_list[i].driver, driver) != 0)
308
            continue;
309
        *(default_list[i].flag) = 0;
310
    }
311
    return 0;
312
}
313

    
314
/***********************************************************/
315
/* x86 ISA bus support */
316

    
317
target_phys_addr_t isa_mem_base = 0;
318
PicState2 *isa_pic;
319

    
320
/***********************************************************/
321
void hw_error(const char *fmt, ...)
322
{
323
    va_list ap;
324
    CPUState *env;
325

    
326
    va_start(ap, fmt);
327
    fprintf(stderr, "qemu: hardware error: ");
328
    vfprintf(stderr, fmt, ap);
329
    fprintf(stderr, "\n");
330
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
331
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
332
#ifdef TARGET_I386
333
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
334
#else
335
        cpu_dump_state(env, stderr, fprintf, 0);
336
#endif
337
    }
338
    va_end(ap);
339
    abort();
340
}
341

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

    
359
static QEMUBalloonEvent *qemu_balloon_event;
360
void *qemu_balloon_event_opaque;
361

    
362
void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
363
{
364
    qemu_balloon_event = func;
365
    qemu_balloon_event_opaque = opaque;
366
}
367

    
368
int qemu_balloon(ram_addr_t target, MonitorCompletion cb, void *opaque)
369
{
370
    if (qemu_balloon_event) {
371
        qemu_balloon_event(qemu_balloon_event_opaque, target, cb, opaque);
372
        return 1;
373
    } else {
374
        return 0;
375
    }
376
}
377

    
378
int qemu_balloon_status(MonitorCompletion cb, void *opaque)
379
{
380
    if (qemu_balloon_event) {
381
        qemu_balloon_event(qemu_balloon_event_opaque, 0, cb, opaque);
382
        return 1;
383
    } else {
384
        return 0;
385
    }
386
}
387

    
388

    
389
/***********************************************************/
390
/* real time host monotonic timer */
391

    
392
/* compute with 96 bit intermediate result: (a*b)/c */
393
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
394
{
395
    union {
396
        uint64_t ll;
397
        struct {
398
#ifdef HOST_WORDS_BIGENDIAN
399
            uint32_t high, low;
400
#else
401
            uint32_t low, high;
402
#endif
403
        } l;
404
    } u, res;
405
    uint64_t rl, rh;
406

    
407
    u.ll = a;
408
    rl = (uint64_t)u.l.low * (uint64_t)b;
409
    rh = (uint64_t)u.l.high * (uint64_t)b;
410
    rh += (rl >> 32);
411
    res.l.high = rh / c;
412
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
413
    return res.ll;
414
}
415

    
416
static int64_t get_clock_realtime(void)
417
{
418
    struct timeval tv;
419

    
420
    gettimeofday(&tv, NULL);
421
    return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
422
}
423

    
424
#ifdef WIN32
425

    
426
static int64_t clock_freq;
427

    
428
static void init_get_clock(void)
429
{
430
    LARGE_INTEGER freq;
431
    int ret;
432
    ret = QueryPerformanceFrequency(&freq);
433
    if (ret == 0) {
434
        fprintf(stderr, "Could not calibrate ticks\n");
435
        exit(1);
436
    }
437
    clock_freq = freq.QuadPart;
438
}
439

    
440
static int64_t get_clock(void)
441
{
442
    LARGE_INTEGER ti;
443
    QueryPerformanceCounter(&ti);
444
    return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
445
}
446

    
447
#else
448

    
449
static int use_rt_clock;
450

    
451
static void init_get_clock(void)
452
{
453
    use_rt_clock = 0;
454
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
455
    || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
456
    {
457
        struct timespec ts;
458
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
459
            use_rt_clock = 1;
460
        }
461
    }
462
#endif
463
}
464

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

    
483
/* Return the virtual CPU time, based on the instruction counter.  */
484
static int64_t cpu_get_icount(void)
485
{
486
    int64_t icount;
487
    CPUState *env = cpu_single_env;;
488
    icount = qemu_icount;
489
    if (env) {
490
        if (!can_do_io(env))
491
            fprintf(stderr, "Bad clock read\n");
492
        icount -= (env->icount_decr.u16.low + env->icount_extra);
493
    }
494
    return qemu_icount_bias + (icount << icount_time_shift);
495
}
496

    
497
/***********************************************************/
498
/* guest cycle counter */
499

    
500
typedef struct TimersState {
501
    int64_t cpu_ticks_prev;
502
    int64_t cpu_ticks_offset;
503
    int64_t cpu_clock_offset;
504
    int32_t cpu_ticks_enabled;
505
    int64_t dummy;
506
} TimersState;
507

    
508
TimersState timers_state;
509

    
510
/* return the host CPU cycle counter and handle stop/restart */
511
int64_t cpu_get_ticks(void)
512
{
513
    if (use_icount) {
514
        return cpu_get_icount();
515
    }
516
    if (!timers_state.cpu_ticks_enabled) {
517
        return timers_state.cpu_ticks_offset;
518
    } else {
519
        int64_t ticks;
520
        ticks = cpu_get_real_ticks();
521
        if (timers_state.cpu_ticks_prev > ticks) {
522
            /* Note: non increasing ticks may happen if the host uses
523
               software suspend */
524
            timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
525
        }
526
        timers_state.cpu_ticks_prev = ticks;
527
        return ticks + timers_state.cpu_ticks_offset;
528
    }
529
}
530

    
531
/* return the host CPU monotonic timer and handle stop/restart */
532
static int64_t cpu_get_clock(void)
533
{
534
    int64_t ti;
535
    if (!timers_state.cpu_ticks_enabled) {
536
        return timers_state.cpu_clock_offset;
537
    } else {
538
        ti = get_clock();
539
        return ti + timers_state.cpu_clock_offset;
540
    }
541
}
542

    
543
/* enable cpu_get_ticks() */
544
void cpu_enable_ticks(void)
545
{
546
    if (!timers_state.cpu_ticks_enabled) {
547
        timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
548
        timers_state.cpu_clock_offset -= get_clock();
549
        timers_state.cpu_ticks_enabled = 1;
550
    }
551
}
552

    
553
/* disable cpu_get_ticks() : the clock is stopped. You must not call
554
   cpu_get_ticks() after that.  */
555
void cpu_disable_ticks(void)
556
{
557
    if (timers_state.cpu_ticks_enabled) {
558
        timers_state.cpu_ticks_offset = cpu_get_ticks();
559
        timers_state.cpu_clock_offset = cpu_get_clock();
560
        timers_state.cpu_ticks_enabled = 0;
561
    }
562
}
563

    
564
/***********************************************************/
565
/* timers */
566

    
567
#define QEMU_CLOCK_REALTIME 0
568
#define QEMU_CLOCK_VIRTUAL  1
569
#define QEMU_CLOCK_HOST     2
570

    
571
struct QEMUClock {
572
    int type;
573
    /* XXX: add frequency */
574
};
575

    
576
struct QEMUTimer {
577
    QEMUClock *clock;
578
    int64_t expire_time;
579
    QEMUTimerCB *cb;
580
    void *opaque;
581
    struct QEMUTimer *next;
582
};
583

    
584
struct qemu_alarm_timer {
585
    char const *name;
586
    unsigned int flags;
587

    
588
    int (*start)(struct qemu_alarm_timer *t);
589
    void (*stop)(struct qemu_alarm_timer *t);
590
    void (*rearm)(struct qemu_alarm_timer *t);
591
    void *priv;
592
};
593

    
594
#define ALARM_FLAG_DYNTICKS  0x1
595
#define ALARM_FLAG_EXPIRED   0x2
596

    
597
static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
598
{
599
    return t && (t->flags & ALARM_FLAG_DYNTICKS);
600
}
601

    
602
static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
603
{
604
    if (!alarm_has_dynticks(t))
605
        return;
606

    
607
    t->rearm(t);
608
}
609

    
610
/* TODO: MIN_TIMER_REARM_US should be optimized */
611
#define MIN_TIMER_REARM_US 250
612

    
613
static struct qemu_alarm_timer *alarm_timer;
614

    
615
#ifdef _WIN32
616

    
617
struct qemu_alarm_win32 {
618
    MMRESULT timerId;
619
    unsigned int period;
620
} alarm_win32_data = {0, -1};
621

    
622
static int win32_start_timer(struct qemu_alarm_timer *t);
623
static void win32_stop_timer(struct qemu_alarm_timer *t);
624
static void win32_rearm_timer(struct qemu_alarm_timer *t);
625

    
626
#else
627

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

    
631
#ifdef __linux__
632

    
633
static int dynticks_start_timer(struct qemu_alarm_timer *t);
634
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
635
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
636

    
637
static int hpet_start_timer(struct qemu_alarm_timer *t);
638
static void hpet_stop_timer(struct qemu_alarm_timer *t);
639

    
640
static int rtc_start_timer(struct qemu_alarm_timer *t);
641
static void rtc_stop_timer(struct qemu_alarm_timer *t);
642

    
643
#endif /* __linux__ */
644

    
645
#endif /* _WIN32 */
646

    
647
/* Correlation between real and virtual time is always going to be
648
   fairly approximate, so ignore small variation.
649
   When the guest is idle real and virtual time will be aligned in
650
   the IO wait loop.  */
651
#define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
652

    
653
static void icount_adjust(void)
654
{
655
    int64_t cur_time;
656
    int64_t cur_icount;
657
    int64_t delta;
658
    static int64_t last_delta;
659
    /* If the VM is not running, then do nothing.  */
660
    if (!vm_running)
661
        return;
662

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

    
683
static void icount_adjust_rt(void * opaque)
684
{
685
    qemu_mod_timer(icount_rt_timer,
686
                   qemu_get_clock(rt_clock) + 1000);
687
    icount_adjust();
688
}
689

    
690
static void icount_adjust_vm(void * opaque)
691
{
692
    qemu_mod_timer(icount_vm_timer,
693
                   qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);
694
    icount_adjust();
695
}
696

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

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

    
732
static void show_available_alarms(void)
733
{
734
    int i;
735

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

    
741
static void configure_alarms(char const *opt)
742
{
743
    int i;
744
    int cur = 0;
745
    int count = ARRAY_SIZE(alarm_timers) - 1;
746
    char *arg;
747
    char *name;
748
    struct qemu_alarm_timer tmp;
749

    
750
    if (!strcmp(opt, "?")) {
751
        show_available_alarms();
752
        exit(0);
753
    }
754

    
755
    arg = qemu_strdup(opt);
756

    
757
    /* Reorder the array */
758
    name = strtok(arg, ",");
759
    while (name) {
760
        for (i = 0; i < count && alarm_timers[i].name; i++) {
761
            if (!strcmp(alarm_timers[i].name, name))
762
                break;
763
        }
764

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

    
770
        if (i < cur)
771
            /* Ignore */
772
            goto next;
773

    
774
        /* Swap */
775
        tmp = alarm_timers[i];
776
        alarm_timers[i] = alarm_timers[cur];
777
        alarm_timers[cur] = tmp;
778

    
779
        cur++;
780
next:
781
        name = strtok(NULL, ",");
782
    }
783

    
784
    qemu_free(arg);
785

    
786
    if (cur) {
787
        /* Disable remaining timers */
788
        for (i = cur; i < count; i++)
789
            alarm_timers[i].name = NULL;
790
    } else {
791
        show_available_alarms();
792
        exit(1);
793
    }
794
}
795

    
796
#define QEMU_NUM_CLOCKS 3
797

    
798
QEMUClock *rt_clock;
799
QEMUClock *vm_clock;
800
QEMUClock *host_clock;
801

    
802
static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];
803

    
804
static QEMUClock *qemu_new_clock(int type)
805
{
806
    QEMUClock *clock;
807
    clock = qemu_mallocz(sizeof(QEMUClock));
808
    clock->type = type;
809
    return clock;
810
}
811

    
812
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
813
{
814
    QEMUTimer *ts;
815

    
816
    ts = qemu_mallocz(sizeof(QEMUTimer));
817
    ts->clock = clock;
818
    ts->cb = cb;
819
    ts->opaque = opaque;
820
    return ts;
821
}
822

    
823
void qemu_free_timer(QEMUTimer *ts)
824
{
825
    qemu_free(ts);
826
}
827

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

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

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

    
854
    qemu_del_timer(ts);
855

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

    
872
    /* Rearm if necessary  */
873
    if (pt == &active_timers[ts->clock->type]) {
874
        if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
875
            qemu_rearm_alarm_timer(alarm_timer);
876
        }
877
        /* Interrupt execution to force deadline recalculation.  */
878
        if (use_icount)
879
            qemu_notify_event();
880
    }
881
}
882

    
883
int qemu_timer_pending(QEMUTimer *ts)
884
{
885
    QEMUTimer *t;
886
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
887
        if (t == ts)
888
            return 1;
889
    }
890
    return 0;
891
}
892

    
893
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
894
{
895
    if (!timer_head)
896
        return 0;
897
    return (timer_head->expire_time <= current_time);
898
}
899

    
900
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
901
{
902
    QEMUTimer *ts;
903

    
904
    for(;;) {
905
        ts = *ptimer_head;
906
        if (!ts || ts->expire_time > current_time)
907
            break;
908
        /* remove timer from the list before calling the callback */
909
        *ptimer_head = ts->next;
910
        ts->next = NULL;
911

    
912
        /* run the callback (the timer list can be modified) */
913
        ts->cb(ts->opaque);
914
    }
915
}
916

    
917
int64_t qemu_get_clock(QEMUClock *clock)
918
{
919
    switch(clock->type) {
920
    case QEMU_CLOCK_REALTIME:
921
        return get_clock() / 1000000;
922
    default:
923
    case QEMU_CLOCK_VIRTUAL:
924
        if (use_icount) {
925
            return cpu_get_icount();
926
        } else {
927
            return cpu_get_clock();
928
        }
929
    case QEMU_CLOCK_HOST:
930
        return get_clock_realtime();
931
    }
932
}
933

    
934
int64_t qemu_get_clock_ns(QEMUClock *clock)
935
{
936
    switch(clock->type) {
937
    case QEMU_CLOCK_REALTIME:
938
        return get_clock();
939
    default:
940
    case QEMU_CLOCK_VIRTUAL:
941
        if (use_icount) {
942
            return cpu_get_icount();
943
        } else {
944
            return cpu_get_clock();
945
        }
946
    case QEMU_CLOCK_HOST:
947
        return get_clock_realtime();
948
    }
949
}
950

    
951
static void init_clocks(void)
952
{
953
    init_get_clock();
954
    rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
955
    vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
956
    host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
957

    
958
    rtc_clock = host_clock;
959
}
960

    
961
/* save a timer */
962
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
963
{
964
    uint64_t expire_time;
965

    
966
    if (qemu_timer_pending(ts)) {
967
        expire_time = ts->expire_time;
968
    } else {
969
        expire_time = -1;
970
    }
971
    qemu_put_be64(f, expire_time);
972
}
973

    
974
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
975
{
976
    uint64_t expire_time;
977

    
978
    expire_time = qemu_get_be64(f);
979
    if (expire_time != -1) {
980
        qemu_mod_timer(ts, expire_time);
981
    } else {
982
        qemu_del_timer(ts);
983
    }
984
}
985

    
986
static const VMStateDescription vmstate_timers = {
987
    .name = "timer",
988
    .version_id = 2,
989
    .minimum_version_id = 1,
990
    .minimum_version_id_old = 1,
991
    .fields      = (VMStateField []) {
992
        VMSTATE_INT64(cpu_ticks_offset, TimersState),
993
        VMSTATE_INT64(dummy, TimersState),
994
        VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
995
        VMSTATE_END_OF_LIST()
996
    }
997
};
998

    
999
static void qemu_event_increment(void);
1000

    
1001
#ifdef _WIN32
1002
static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1003
                                        DWORD_PTR dwUser, DWORD_PTR dw1,
1004
                                        DWORD_PTR dw2)
1005
#else
1006
static void host_alarm_handler(int host_signum)
1007
#endif
1008
{
1009
#if 0
1010
#define DISP_FREQ 1000
1011
    {
1012
        static int64_t delta_min = INT64_MAX;
1013
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
1014
        static int count;
1015
        ti = qemu_get_clock(vm_clock);
1016
        if (last_clock != 0) {
1017
            delta = ti - last_clock;
1018
            if (delta < delta_min)
1019
                delta_min = delta;
1020
            if (delta > delta_max)
1021
                delta_max = delta;
1022
            delta_cum += delta;
1023
            if (++count == DISP_FREQ) {
1024
                printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1025
                       muldiv64(delta_min, 1000000, get_ticks_per_sec()),
1026
                       muldiv64(delta_max, 1000000, get_ticks_per_sec()),
1027
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, get_ticks_per_sec()),
1028
                       (double)get_ticks_per_sec() / ((double)delta_cum / DISP_FREQ));
1029
                count = 0;
1030
                delta_min = INT64_MAX;
1031
                delta_max = 0;
1032
                delta_cum = 0;
1033
            }
1034
        }
1035
        last_clock = ti;
1036
    }
1037
#endif
1038
    if (alarm_has_dynticks(alarm_timer) ||
1039
        (!use_icount &&
1040
            qemu_timer_expired(active_timers[QEMU_CLOCK_VIRTUAL],
1041
                               qemu_get_clock(vm_clock))) ||
1042
        qemu_timer_expired(active_timers[QEMU_CLOCK_REALTIME],
1043
                           qemu_get_clock(rt_clock)) ||
1044
        qemu_timer_expired(active_timers[QEMU_CLOCK_HOST],
1045
                           qemu_get_clock(host_clock))) {
1046
        qemu_event_increment();
1047
        if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1048

    
1049
#ifndef CONFIG_IOTHREAD
1050
        if (next_cpu) {
1051
            /* stop the currently executing cpu because a timer occured */
1052
            cpu_exit(next_cpu);
1053
        }
1054
#endif
1055
        timer_alarm_pending = 1;
1056
        qemu_notify_event();
1057
    }
1058
}
1059

    
1060
static int64_t qemu_next_deadline(void)
1061
{
1062
    /* To avoid problems with overflow limit this to 2^32.  */
1063
    int64_t delta = INT32_MAX;
1064

    
1065
    if (active_timers[QEMU_CLOCK_VIRTUAL]) {
1066
        delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
1067
                     qemu_get_clock(vm_clock);
1068
    }
1069
    if (active_timers[QEMU_CLOCK_HOST]) {
1070
        int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
1071
                 qemu_get_clock(host_clock);
1072
        if (hdelta < delta)
1073
            delta = hdelta;
1074
    }
1075

    
1076
    if (delta < 0)
1077
        delta = 0;
1078

    
1079
    return delta;
1080
}
1081

    
1082
#if defined(__linux__)
1083
static uint64_t qemu_next_deadline_dyntick(void)
1084
{
1085
    int64_t delta;
1086
    int64_t rtdelta;
1087

    
1088
    if (use_icount)
1089
        delta = INT32_MAX;
1090
    else
1091
        delta = (qemu_next_deadline() + 999) / 1000;
1092

    
1093
    if (active_timers[QEMU_CLOCK_REALTIME]) {
1094
        rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -
1095
                 qemu_get_clock(rt_clock))*1000;
1096
        if (rtdelta < delta)
1097
            delta = rtdelta;
1098
    }
1099

    
1100
    if (delta < MIN_TIMER_REARM_US)
1101
        delta = MIN_TIMER_REARM_US;
1102

    
1103
    return delta;
1104
}
1105
#endif
1106

    
1107
#ifndef _WIN32
1108

    
1109
/* Sets a specific flag */
1110
static int fcntl_setfl(int fd, int flag)
1111
{
1112
    int flags;
1113

    
1114
    flags = fcntl(fd, F_GETFL);
1115
    if (flags == -1)
1116
        return -errno;
1117

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

    
1121
    return 0;
1122
}
1123

    
1124
#if defined(__linux__)
1125

    
1126
#define RTC_FREQ 1024
1127

    
1128
static void enable_sigio_timer(int fd)
1129
{
1130
    struct sigaction act;
1131

    
1132
    /* timer signal */
1133
    sigfillset(&act.sa_mask);
1134
    act.sa_flags = 0;
1135
    act.sa_handler = host_alarm_handler;
1136

    
1137
    sigaction(SIGIO, &act, NULL);
1138
    fcntl_setfl(fd, O_ASYNC);
1139
    fcntl(fd, F_SETOWN, getpid());
1140
}
1141

    
1142
static int hpet_start_timer(struct qemu_alarm_timer *t)
1143
{
1144
    struct hpet_info info;
1145
    int r, fd;
1146

    
1147
    fd = qemu_open("/dev/hpet", O_RDONLY);
1148
    if (fd < 0)
1149
        return -1;
1150

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

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

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

    
1170
    /* Enable interrupt */
1171
    r = ioctl(fd, HPET_IE_ON, 0);
1172
    if (r < 0)
1173
        goto fail;
1174

    
1175
    enable_sigio_timer(fd);
1176
    t->priv = (void *)(long)fd;
1177

    
1178
    return 0;
1179
fail:
1180
    close(fd);
1181
    return -1;
1182
}
1183

    
1184
static void hpet_stop_timer(struct qemu_alarm_timer *t)
1185
{
1186
    int fd = (long)t->priv;
1187

    
1188
    close(fd);
1189
}
1190

    
1191
static int rtc_start_timer(struct qemu_alarm_timer *t)
1192
{
1193
    int rtc_fd;
1194
    unsigned long current_rtc_freq = 0;
1195

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

    
1213
    enable_sigio_timer(rtc_fd);
1214

    
1215
    t->priv = (void *)(long)rtc_fd;
1216

    
1217
    return 0;
1218
}
1219

    
1220
static void rtc_stop_timer(struct qemu_alarm_timer *t)
1221
{
1222
    int rtc_fd = (long)t->priv;
1223

    
1224
    close(rtc_fd);
1225
}
1226

    
1227
static int dynticks_start_timer(struct qemu_alarm_timer *t)
1228
{
1229
    struct sigevent ev;
1230
    timer_t host_timer;
1231
    struct sigaction act;
1232

    
1233
    sigfillset(&act.sa_mask);
1234
    act.sa_flags = 0;
1235
    act.sa_handler = host_alarm_handler;
1236

    
1237
    sigaction(SIGALRM, &act, NULL);
1238

    
1239
    /* 
1240
     * Initialize ev struct to 0 to avoid valgrind complaining
1241
     * about uninitialized data in timer_create call
1242
     */
1243
    memset(&ev, 0, sizeof(ev));
1244
    ev.sigev_value.sival_int = 0;
1245
    ev.sigev_notify = SIGEV_SIGNAL;
1246
    ev.sigev_signo = SIGALRM;
1247

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

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

    
1254
        return -1;
1255
    }
1256

    
1257
    t->priv = (void *)(long)host_timer;
1258

    
1259
    return 0;
1260
}
1261

    
1262
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1263
{
1264
    timer_t host_timer = (timer_t)(long)t->priv;
1265

    
1266
    timer_delete(host_timer);
1267
}
1268

    
1269
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1270
{
1271
    timer_t host_timer = (timer_t)(long)t->priv;
1272
    struct itimerspec timeout;
1273
    int64_t nearest_delta_us = INT64_MAX;
1274
    int64_t current_us;
1275

    
1276
    if (!active_timers[QEMU_CLOCK_REALTIME] &&
1277
        !active_timers[QEMU_CLOCK_VIRTUAL] &&
1278
        !active_timers[QEMU_CLOCK_HOST])
1279
        return;
1280

    
1281
    nearest_delta_us = qemu_next_deadline_dyntick();
1282

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

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

    
1304
#endif /* defined(__linux__) */
1305

    
1306
static int unix_start_timer(struct qemu_alarm_timer *t)
1307
{
1308
    struct sigaction act;
1309
    struct itimerval itv;
1310
    int err;
1311

    
1312
    /* timer signal */
1313
    sigfillset(&act.sa_mask);
1314
    act.sa_flags = 0;
1315
    act.sa_handler = host_alarm_handler;
1316

    
1317
    sigaction(SIGALRM, &act, NULL);
1318

    
1319
    itv.it_interval.tv_sec = 0;
1320
    /* for i386 kernel 2.6 to get 1 ms */
1321
    itv.it_interval.tv_usec = 999;
1322
    itv.it_value.tv_sec = 0;
1323
    itv.it_value.tv_usec = 10 * 1000;
1324

    
1325
    err = setitimer(ITIMER_REAL, &itv, NULL);
1326
    if (err)
1327
        return -1;
1328

    
1329
    return 0;
1330
}
1331

    
1332
static void unix_stop_timer(struct qemu_alarm_timer *t)
1333
{
1334
    struct itimerval itv;
1335

    
1336
    memset(&itv, 0, sizeof(itv));
1337
    setitimer(ITIMER_REAL, &itv, NULL);
1338
}
1339

    
1340
#endif /* !defined(_WIN32) */
1341

    
1342

    
1343
#ifdef _WIN32
1344

    
1345
static int win32_start_timer(struct qemu_alarm_timer *t)
1346
{
1347
    TIMECAPS tc;
1348
    struct qemu_alarm_win32 *data = t->priv;
1349
    UINT flags;
1350

    
1351
    memset(&tc, 0, sizeof(tc));
1352
    timeGetDevCaps(&tc, sizeof(tc));
1353

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

    
1357
    timeBeginPeriod(data->period);
1358

    
1359
    flags = TIME_CALLBACK_FUNCTION;
1360
    if (alarm_has_dynticks(t))
1361
        flags |= TIME_ONESHOT;
1362
    else
1363
        flags |= TIME_PERIODIC;
1364

    
1365
    data->timerId = timeSetEvent(1,         // interval (ms)
1366
                        data->period,       // resolution
1367
                        host_alarm_handler, // function
1368
                        (DWORD)t,           // parameter
1369
                        flags);
1370

    
1371
    if (!data->timerId) {
1372
        fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
1373
                GetLastError());
1374
        timeEndPeriod(data->period);
1375
        return -1;
1376
    }
1377

    
1378
    return 0;
1379
}
1380

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

    
1385
    timeKillEvent(data->timerId);
1386
    timeEndPeriod(data->period);
1387
}
1388

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

    
1393
    if (!active_timers[QEMU_CLOCK_REALTIME] &&
1394
        !active_timers[QEMU_CLOCK_VIRTUAL] &&
1395
        !active_timers[QEMU_CLOCK_HOST])
1396
        return;
1397

    
1398
    timeKillEvent(data->timerId);
1399

    
1400
    data->timerId = timeSetEvent(1,
1401
                        data->period,
1402
                        host_alarm_handler,
1403
                        (DWORD)t,
1404
                        TIME_ONESHOT | TIME_PERIODIC);
1405

    
1406
    if (!data->timerId) {
1407
        fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
1408
                GetLastError());
1409

    
1410
        timeEndPeriod(data->period);
1411
        exit(1);
1412
    }
1413
}
1414

    
1415
#endif /* _WIN32 */
1416

    
1417
static int init_timer_alarm(void)
1418
{
1419
    struct qemu_alarm_timer *t = NULL;
1420
    int i, err = -1;
1421

    
1422
    for (i = 0; alarm_timers[i].name; i++) {
1423
        t = &alarm_timers[i];
1424

    
1425
        err = t->start(t);
1426
        if (!err)
1427
            break;
1428
    }
1429

    
1430
    if (err) {
1431
        err = -ENOENT;
1432
        goto fail;
1433
    }
1434

    
1435
    alarm_timer = t;
1436

    
1437
    return 0;
1438

    
1439
fail:
1440
    return err;
1441
}
1442

    
1443
static void quit_timers(void)
1444
{
1445
    alarm_timer->stop(alarm_timer);
1446
    alarm_timer = NULL;
1447
}
1448

    
1449
/***********************************************************/
1450
/* host time/date access */
1451
void qemu_get_timedate(struct tm *tm, int offset)
1452
{
1453
    time_t ti;
1454
    struct tm *ret;
1455

    
1456
    time(&ti);
1457
    ti += offset;
1458
    if (rtc_date_offset == -1) {
1459
        if (rtc_utc)
1460
            ret = gmtime(&ti);
1461
        else
1462
            ret = localtime(&ti);
1463
    } else {
1464
        ti -= rtc_date_offset;
1465
        ret = gmtime(&ti);
1466
    }
1467

    
1468
    memcpy(tm, ret, sizeof(struct tm));
1469
}
1470

    
1471
int qemu_timedate_diff(struct tm *tm)
1472
{
1473
    time_t seconds;
1474

    
1475
    if (rtc_date_offset == -1)
1476
        if (rtc_utc)
1477
            seconds = mktimegm(tm);
1478
        else
1479
            seconds = mktime(tm);
1480
    else
1481
        seconds = mktimegm(tm) + rtc_date_offset;
1482

    
1483
    return seconds - time(NULL);
1484
}
1485

    
1486
static void configure_rtc_date_offset(const char *startdate, int legacy)
1487
{
1488
    time_t rtc_start_date;
1489
    struct tm tm;
1490

    
1491
    if (!strcmp(startdate, "now") && legacy) {
1492
        rtc_date_offset = -1;
1493
    } else {
1494
        if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
1495
                   &tm.tm_year,
1496
                   &tm.tm_mon,
1497
                   &tm.tm_mday,
1498
                   &tm.tm_hour,
1499
                   &tm.tm_min,
1500
                   &tm.tm_sec) == 6) {
1501
            /* OK */
1502
        } else if (sscanf(startdate, "%d-%d-%d",
1503
                          &tm.tm_year,
1504
                          &tm.tm_mon,
1505
                          &tm.tm_mday) == 3) {
1506
            tm.tm_hour = 0;
1507
            tm.tm_min = 0;
1508
            tm.tm_sec = 0;
1509
        } else {
1510
            goto date_fail;
1511
        }
1512
        tm.tm_year -= 1900;
1513
        tm.tm_mon--;
1514
        rtc_start_date = mktimegm(&tm);
1515
        if (rtc_start_date == -1) {
1516
        date_fail:
1517
            fprintf(stderr, "Invalid date format. Valid formats are:\n"
1518
                            "'2006-06-17T16:01:21' or '2006-06-17'\n");
1519
            exit(1);
1520
        }
1521
        rtc_date_offset = time(NULL) - rtc_start_date;
1522
    }
1523
}
1524

    
1525
static void configure_rtc(QemuOpts *opts)
1526
{
1527
    const char *value;
1528

    
1529
    value = qemu_opt_get(opts, "base");
1530
    if (value) {
1531
        if (!strcmp(value, "utc")) {
1532
            rtc_utc = 1;
1533
        } else if (!strcmp(value, "localtime")) {
1534
            rtc_utc = 0;
1535
        } else {
1536
            configure_rtc_date_offset(value, 0);
1537
        }
1538
    }
1539
    value = qemu_opt_get(opts, "clock");
1540
    if (value) {
1541
        if (!strcmp(value, "host")) {
1542
            rtc_clock = host_clock;
1543
        } else if (!strcmp(value, "vm")) {
1544
            rtc_clock = vm_clock;
1545
        } else {
1546
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
1547
            exit(1);
1548
        }
1549
    }
1550
#ifdef CONFIG_TARGET_I386
1551
    value = qemu_opt_get(opts, "driftfix");
1552
    if (value) {
1553
        if (!strcmp(buf, "slew")) {
1554
            rtc_td_hack = 1;
1555
        } else if (!strcmp(buf, "none")) {
1556
            rtc_td_hack = 0;
1557
        } else {
1558
            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
1559
            exit(1);
1560
        }
1561
    }
1562
#endif
1563
}
1564

    
1565
#ifdef _WIN32
1566
static void socket_cleanup(void)
1567
{
1568
    WSACleanup();
1569
}
1570

    
1571
static int socket_init(void)
1572
{
1573
    WSADATA Data;
1574
    int ret, err;
1575

    
1576
    ret = WSAStartup(MAKEWORD(2,2), &Data);
1577
    if (ret != 0) {
1578
        err = WSAGetLastError();
1579
        fprintf(stderr, "WSAStartup: %d\n", err);
1580
        return -1;
1581
    }
1582
    atexit(socket_cleanup);
1583
    return 0;
1584
}
1585
#endif
1586

    
1587
/***********************************************************/
1588
/* Bluetooth support */
1589
static int nb_hcis;
1590
static int cur_hci;
1591
static struct HCIInfo *hci_table[MAX_NICS];
1592

    
1593
static struct bt_vlan_s {
1594
    struct bt_scatternet_s net;
1595
    int id;
1596
    struct bt_vlan_s *next;
1597
} *first_bt_vlan;
1598

    
1599
/* find or alloc a new bluetooth "VLAN" */
1600
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1601
{
1602
    struct bt_vlan_s **pvlan, *vlan;
1603
    for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1604
        if (vlan->id == id)
1605
            return &vlan->net;
1606
    }
1607
    vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1608
    vlan->id = id;
1609
    pvlan = &first_bt_vlan;
1610
    while (*pvlan != NULL)
1611
        pvlan = &(*pvlan)->next;
1612
    *pvlan = vlan;
1613
    return &vlan->net;
1614
}
1615

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

    
1620
static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1621
{
1622
    return -ENOTSUP;
1623
}
1624

    
1625
static struct HCIInfo null_hci = {
1626
    .cmd_send = null_hci_send,
1627
    .sco_send = null_hci_send,
1628
    .acl_send = null_hci_send,
1629
    .bdaddr_set = null_hci_addr_set,
1630
};
1631

    
1632
struct HCIInfo *qemu_next_hci(void)
1633
{
1634
    if (cur_hci == nb_hcis)
1635
        return &null_hci;
1636

    
1637
    return hci_table[cur_hci++];
1638
}
1639

    
1640
static struct HCIInfo *hci_init(const char *str)
1641
{
1642
    char *endp;
1643
    struct bt_scatternet_s *vlan = 0;
1644

    
1645
    if (!strcmp(str, "null"))
1646
        /* null */
1647
        return &null_hci;
1648
    else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1649
        /* host[:hciN] */
1650
        return bt_host_hci(str[4] ? str + 5 : "hci0");
1651
    else if (!strncmp(str, "hci", 3)) {
1652
        /* hci[,vlan=n] */
1653
        if (str[3]) {
1654
            if (!strncmp(str + 3, ",vlan=", 6)) {
1655
                vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1656
                if (*endp)
1657
                    vlan = 0;
1658
            }
1659
        } else
1660
            vlan = qemu_find_bt_vlan(0);
1661
        if (vlan)
1662
           return bt_new_hci(vlan);
1663
    }
1664

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

    
1667
    return 0;
1668
}
1669

    
1670
static int bt_hci_parse(const char *str)
1671
{
1672
    struct HCIInfo *hci;
1673
    bdaddr_t bdaddr;
1674

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

    
1680
    hci = hci_init(str);
1681
    if (!hci)
1682
        return -1;
1683

    
1684
    bdaddr.b[0] = 0x52;
1685
    bdaddr.b[1] = 0x54;
1686
    bdaddr.b[2] = 0x00;
1687
    bdaddr.b[3] = 0x12;
1688
    bdaddr.b[4] = 0x34;
1689
    bdaddr.b[5] = 0x56 + nb_hcis;
1690
    hci->bdaddr_set(hci, bdaddr.b);
1691

    
1692
    hci_table[nb_hcis++] = hci;
1693

    
1694
    return 0;
1695
}
1696

    
1697
static void bt_vhci_add(int vlan_id)
1698
{
1699
    struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1700

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

    
1705
    bt_vhci_init(bt_new_hci(vlan));
1706
}
1707

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

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

    
1718
    if (endp) {
1719
        vlan_id = strtol(endp + 6, &endp, 0);
1720
        if (*endp) {
1721
            fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
1722
            return 0;
1723
        }
1724
    }
1725

    
1726
    vlan = qemu_find_bt_vlan(vlan_id);
1727

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

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

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

    
1739
static int bt_parse(const char *opt)
1740
{
1741
    const char *endp, *p;
1742
    int vlan;
1743

    
1744
    if (strstart(opt, "hci", &endp)) {
1745
        if (!*endp || *endp == ',') {
1746
            if (*endp)
1747
                if (!strstart(endp, ",vlan=", 0))
1748
                    opt = endp + 1;
1749

    
1750
            return bt_hci_parse(opt);
1751
       }
1752
    } else if (strstart(opt, "vhci", &endp)) {
1753
        if (!*endp || *endp == ',') {
1754
            if (*endp) {
1755
                if (strstart(endp, ",vlan=", &p)) {
1756
                    vlan = strtol(p, (char **) &endp, 0);
1757
                    if (*endp) {
1758
                        fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
1759
                        return 1;
1760
                    }
1761
                } else {
1762
                    fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
1763
                    return 1;
1764
                }
1765
            } else
1766
                vlan = 0;
1767

    
1768
            bt_vhci_add(vlan);
1769
            return 0;
1770
        }
1771
    } else if (strstart(opt, "device:", &endp))
1772
        return !bt_device_add(endp);
1773

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

    
1778
/***********************************************************/
1779
/* QEMU Block devices */
1780

    
1781
#define HD_ALIAS "index=%d,media=disk"
1782
#define CDROM_ALIAS "index=2,media=cdrom"
1783
#define FD_ALIAS "index=%d,if=floppy"
1784
#define PFLASH_ALIAS "if=pflash"
1785
#define MTD_ALIAS "if=mtd"
1786
#define SD_ALIAS "index=0,if=sd"
1787

    
1788
QemuOpts *drive_add(const char *file, const char *fmt, ...)
1789
{
1790
    va_list ap;
1791
    char optstr[1024];
1792
    QemuOpts *opts;
1793

    
1794
    va_start(ap, fmt);
1795
    vsnprintf(optstr, sizeof(optstr), fmt, ap);
1796
    va_end(ap);
1797

    
1798
    opts = qemu_opts_parse(&qemu_drive_opts, optstr, NULL);
1799
    if (!opts) {
1800
        fprintf(stderr, "%s: huh? duplicate? (%s)\n",
1801
                __FUNCTION__, optstr);
1802
        return NULL;
1803
    }
1804
    if (file)
1805
        qemu_opt_set(opts, "file", file);
1806
    return opts;
1807
}
1808

    
1809
DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
1810
{
1811
    DriveInfo *dinfo;
1812

    
1813
    /* seek interface, bus and unit */
1814

    
1815
    QTAILQ_FOREACH(dinfo, &drives, next) {
1816
        if (dinfo->type == type &&
1817
            dinfo->bus == bus &&
1818
            dinfo->unit == unit)
1819
            return dinfo;
1820
    }
1821

    
1822
    return NULL;
1823
}
1824

    
1825
DriveInfo *drive_get_by_id(const char *id)
1826
{
1827
    DriveInfo *dinfo;
1828

    
1829
    QTAILQ_FOREACH(dinfo, &drives, next) {
1830
        if (strcmp(id, dinfo->id))
1831
            continue;
1832
        return dinfo;
1833
    }
1834
    return NULL;
1835
}
1836

    
1837
int drive_get_max_bus(BlockInterfaceType type)
1838
{
1839
    int max_bus;
1840
    DriveInfo *dinfo;
1841

    
1842
    max_bus = -1;
1843
    QTAILQ_FOREACH(dinfo, &drives, next) {
1844
        if(dinfo->type == type &&
1845
           dinfo->bus > max_bus)
1846
            max_bus = dinfo->bus;
1847
    }
1848
    return max_bus;
1849
}
1850

    
1851
const char *drive_get_serial(BlockDriverState *bdrv)
1852
{
1853
    DriveInfo *dinfo;
1854

    
1855
    QTAILQ_FOREACH(dinfo, &drives, next) {
1856
        if (dinfo->bdrv == bdrv)
1857
            return dinfo->serial;
1858
    }
1859

    
1860
    return "\0";
1861
}
1862

    
1863
BlockInterfaceErrorAction drive_get_on_error(
1864
    BlockDriverState *bdrv, int is_read)
1865
{
1866
    DriveInfo *dinfo;
1867

    
1868
    QTAILQ_FOREACH(dinfo, &drives, next) {
1869
        if (dinfo->bdrv == bdrv)
1870
            return is_read ? dinfo->on_read_error : dinfo->on_write_error;
1871
    }
1872

    
1873
    return is_read ? BLOCK_ERR_REPORT : BLOCK_ERR_STOP_ENOSPC;
1874
}
1875

    
1876
static void bdrv_format_print(void *opaque, const char *name)
1877
{
1878
    fprintf(stderr, " %s", name);
1879
}
1880

    
1881
void drive_uninit(DriveInfo *dinfo)
1882
{
1883
    qemu_opts_del(dinfo->opts);
1884
    bdrv_delete(dinfo->bdrv);
1885
    QTAILQ_REMOVE(&drives, dinfo, next);
1886
    qemu_free(dinfo);
1887
}
1888

    
1889
static int parse_block_error_action(const char *buf, int is_read)
1890
{
1891
    if (!strcmp(buf, "ignore")) {
1892
        return BLOCK_ERR_IGNORE;
1893
    } else if (!is_read && !strcmp(buf, "enospc")) {
1894
        return BLOCK_ERR_STOP_ENOSPC;
1895
    } else if (!strcmp(buf, "stop")) {
1896
        return BLOCK_ERR_STOP_ANY;
1897
    } else if (!strcmp(buf, "report")) {
1898
        return BLOCK_ERR_REPORT;
1899
    } else {
1900
        fprintf(stderr, "qemu: '%s' invalid %s error action\n",
1901
            buf, is_read ? "read" : "write");
1902
        return -1;
1903
    }
1904
}
1905

    
1906
DriveInfo *drive_init(QemuOpts *opts, void *opaque,
1907
                      int *fatal_error)
1908
{
1909
    const char *buf;
1910
    const char *file = NULL;
1911
    char devname[128];
1912
    const char *serial;
1913
    const char *mediastr = "";
1914
    BlockInterfaceType type;
1915
    enum { MEDIA_DISK, MEDIA_CDROM } media;
1916
    int bus_id, unit_id;
1917
    int cyls, heads, secs, translation;
1918
    BlockDriver *drv = NULL;
1919
    QEMUMachine *machine = opaque;
1920
    int max_devs;
1921
    int index;
1922
    int cache;
1923
    int aio = 0;
1924
    int ro = 0;
1925
    int bdrv_flags;
1926
    int on_read_error, on_write_error;
1927
    const char *devaddr;
1928
    DriveInfo *dinfo;
1929
    int snapshot = 0;
1930

    
1931
    *fatal_error = 1;
1932

    
1933
    translation = BIOS_ATA_TRANSLATION_AUTO;
1934
    cache = 1;
1935

    
1936
    if (machine && machine->use_scsi) {
1937
        type = IF_SCSI;
1938
        max_devs = MAX_SCSI_DEVS;
1939
        pstrcpy(devname, sizeof(devname), "scsi");
1940
    } else {
1941
        type = IF_IDE;
1942
        max_devs = MAX_IDE_DEVS;
1943
        pstrcpy(devname, sizeof(devname), "ide");
1944
    }
1945
    media = MEDIA_DISK;
1946

    
1947
    /* extract parameters */
1948
    bus_id  = qemu_opt_get_number(opts, "bus", 0);
1949
    unit_id = qemu_opt_get_number(opts, "unit", -1);
1950
    index   = qemu_opt_get_number(opts, "index", -1);
1951

    
1952
    cyls  = qemu_opt_get_number(opts, "cyls", 0);
1953
    heads = qemu_opt_get_number(opts, "heads", 0);
1954
    secs  = qemu_opt_get_number(opts, "secs", 0);
1955

    
1956
    snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
1957
    ro = qemu_opt_get_bool(opts, "readonly", 0);
1958

    
1959
    file = qemu_opt_get(opts, "file");
1960
    serial = qemu_opt_get(opts, "serial");
1961

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

    
1997
    if (cyls || heads || secs) {
1998
        if (cyls < 1 || (type == IF_IDE && cyls > 16383)) {
1999
            fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
2000
            return NULL;
2001
        }
2002
        if (heads < 1 || (type == IF_IDE && heads > 16)) {
2003
            fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
2004
            return NULL;
2005
        }
2006
        if (secs < 1 || (type == IF_IDE && secs > 63)) {
2007
            fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
2008
            return NULL;
2009
        }
2010
    }
2011

    
2012
    if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
2013
        if (!cyls) {
2014
            fprintf(stderr,
2015
                    "qemu: '%s' trans must be used with cyls,heads and secs\n",
2016
                    buf);
2017
            return NULL;
2018
        }
2019
        if (!strcmp(buf, "none"))
2020
            translation = BIOS_ATA_TRANSLATION_NONE;
2021
        else if (!strcmp(buf, "lba"))
2022
            translation = BIOS_ATA_TRANSLATION_LBA;
2023
        else if (!strcmp(buf, "auto"))
2024
            translation = BIOS_ATA_TRANSLATION_AUTO;
2025
        else {
2026
            fprintf(stderr, "qemu: '%s' invalid translation type\n", buf);
2027
            return NULL;
2028
        }
2029
    }
2030

    
2031
    if ((buf = qemu_opt_get(opts, "media")) != NULL) {
2032
        if (!strcmp(buf, "disk")) {
2033
            media = MEDIA_DISK;
2034
        } else if (!strcmp(buf, "cdrom")) {
2035
            if (cyls || secs || heads) {
2036
                fprintf(stderr,
2037
                        "qemu: '%s' invalid physical CHS format\n", buf);
2038
                return NULL;
2039
            }
2040
            media = MEDIA_CDROM;
2041
        } else {
2042
            fprintf(stderr, "qemu: '%s' invalid media\n", buf);
2043
            return NULL;
2044
        }
2045
    }
2046

    
2047
    if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
2048
        if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2049
            cache = 0;
2050
        else if (!strcmp(buf, "writethrough"))
2051
            cache = 1;
2052
        else if (!strcmp(buf, "writeback"))
2053
            cache = 2;
2054
        else {
2055
           fprintf(stderr, "qemu: invalid cache option\n");
2056
           return NULL;
2057
        }
2058
    }
2059

    
2060
#ifdef CONFIG_LINUX_AIO
2061
    if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
2062
        if (!strcmp(buf, "threads"))
2063
            aio = 0;
2064
        else if (!strcmp(buf, "native"))
2065
            aio = 1;
2066
        else {
2067
           fprintf(stderr, "qemu: invalid aio option\n");
2068
           return NULL;
2069
        }
2070
    }
2071
#endif
2072

    
2073
    if ((buf = qemu_opt_get(opts, "format")) != NULL) {
2074
       if (strcmp(buf, "?") == 0) {
2075
            fprintf(stderr, "qemu: Supported formats:");
2076
            bdrv_iterate_format(bdrv_format_print, NULL);
2077
            fprintf(stderr, "\n");
2078
            return NULL;
2079
        }
2080
        drv = bdrv_find_whitelisted_format(buf);
2081
        if (!drv) {
2082
            fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2083
            return NULL;
2084
        }
2085
    }
2086

    
2087
    on_write_error = BLOCK_ERR_STOP_ENOSPC;
2088
    if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
2089
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2090
            fprintf(stderr, "werror is no supported by this format\n");
2091
            return NULL;
2092
        }
2093

    
2094
        on_write_error = parse_block_error_action(buf, 0);
2095
        if (on_write_error < 0) {
2096
            return NULL;
2097
        }
2098
    }
2099

    
2100
    on_read_error = BLOCK_ERR_REPORT;
2101
    if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
2102
        if (type != IF_IDE && type != IF_VIRTIO) {
2103
            fprintf(stderr, "rerror is no supported by this format\n");
2104
            return NULL;
2105
        }
2106

    
2107
        on_read_error = parse_block_error_action(buf, 1);
2108
        if (on_read_error < 0) {
2109
            return NULL;
2110
        }
2111
    }
2112

    
2113
    if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
2114
        if (type != IF_VIRTIO) {
2115
            fprintf(stderr, "addr is not supported\n");
2116
            return NULL;
2117
        }
2118
    }
2119

    
2120
    /* compute bus and unit according index */
2121

    
2122
    if (index != -1) {
2123
        if (bus_id != 0 || unit_id != -1) {
2124
            fprintf(stderr,
2125
                    "qemu: index cannot be used with bus and unit\n");
2126
            return NULL;
2127
        }
2128
        if (max_devs == 0)
2129
        {
2130
            unit_id = index;
2131
            bus_id = 0;
2132
        } else {
2133
            unit_id = index % max_devs;
2134
            bus_id = index / max_devs;
2135
        }
2136
    }
2137

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

    
2142
    if (unit_id == -1) {
2143
       unit_id = 0;
2144
       while (drive_get(type, bus_id, unit_id) != NULL) {
2145
           unit_id++;
2146
           if (max_devs && unit_id >= max_devs) {
2147
               unit_id -= max_devs;
2148
               bus_id++;
2149
           }
2150
       }
2151
    }
2152

    
2153
    /* check unit id */
2154

    
2155
    if (max_devs && unit_id >= max_devs) {
2156
        fprintf(stderr, "qemu: unit %d too big (max is %d)\n",
2157
                unit_id, max_devs - 1);
2158
        return NULL;
2159
    }
2160

    
2161
    /*
2162
     * ignore multiple definitions
2163
     */
2164

    
2165
    if (drive_get(type, bus_id, unit_id) != NULL) {
2166
        *fatal_error = 0;
2167
        return NULL;
2168
    }
2169

    
2170
    /* init */
2171

    
2172
    dinfo = qemu_mallocz(sizeof(*dinfo));
2173
    if ((buf = qemu_opts_id(opts)) != NULL) {
2174
        dinfo->id = qemu_strdup(buf);
2175
    } else {
2176
        /* no id supplied -> create one */
2177
        dinfo->id = qemu_mallocz(32);
2178
        if (type == IF_IDE || type == IF_SCSI)
2179
            mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2180
        if (max_devs)
2181
            snprintf(dinfo->id, 32, "%s%i%s%i",
2182
                     devname, bus_id, mediastr, unit_id);
2183
        else
2184
            snprintf(dinfo->id, 32, "%s%s%i",
2185
                     devname, mediastr, unit_id);
2186
    }
2187
    dinfo->bdrv = bdrv_new(dinfo->id);
2188
    dinfo->devaddr = devaddr;
2189
    dinfo->type = type;
2190
    dinfo->bus = bus_id;
2191
    dinfo->unit = unit_id;
2192
    dinfo->on_read_error = on_read_error;
2193
    dinfo->on_write_error = on_write_error;
2194
    dinfo->opts = opts;
2195
    if (serial)
2196
        strncpy(dinfo->serial, serial, sizeof(serial));
2197
    QTAILQ_INSERT_TAIL(&drives, dinfo, next);
2198

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

    
2250
    if (aio == 1) {
2251
        bdrv_flags |= BDRV_O_NATIVE_AIO;
2252
    } else {
2253
        bdrv_flags &= ~BDRV_O_NATIVE_AIO;
2254
    }
2255

    
2256
    if (ro == 1) {
2257
        if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY) {
2258
            fprintf(stderr, "qemu: readonly flag not supported for drive with this interface\n");
2259
            return NULL;
2260
        }
2261
    }
2262
    /* 
2263
     * cdrom is read-only. Set it now, after above interface checking
2264
     * since readonly attribute not explicitly required, so no error.
2265
     */
2266
    if (media == MEDIA_CDROM) {
2267
        ro = 1;
2268
    }
2269
    bdrv_flags |= ro ? 0 : BDRV_O_RDWR;
2270

    
2271
    if (bdrv_open2(dinfo->bdrv, file, bdrv_flags, drv) < 0) {
2272
        fprintf(stderr, "qemu: could not open disk image %s: %s\n",
2273
                        file, strerror(errno));
2274
        return NULL;
2275
    }
2276

    
2277
    if (bdrv_key_required(dinfo->bdrv))
2278
        autostart = 0;
2279
    *fatal_error = 0;
2280
    return dinfo;
2281
}
2282

    
2283
static int drive_init_func(QemuOpts *opts, void *opaque)
2284
{
2285
    QEMUMachine *machine = opaque;
2286
    int fatal_error = 0;
2287

    
2288
    if (drive_init(opts, machine, &fatal_error) == NULL) {
2289
        if (fatal_error)
2290
            return 1;
2291
    }
2292
    return 0;
2293
}
2294

    
2295
static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
2296
{
2297
    if (NULL == qemu_opt_get(opts, "snapshot")) {
2298
        qemu_opt_set(opts, "snapshot", "on");
2299
    }
2300
    return 0;
2301
}
2302

    
2303
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
2304
{
2305
    boot_set_handler = func;
2306
    boot_set_opaque = opaque;
2307
}
2308

    
2309
int qemu_boot_set(const char *boot_devices)
2310
{
2311
    if (!boot_set_handler) {
2312
        return -EINVAL;
2313
    }
2314
    return boot_set_handler(boot_set_opaque, boot_devices);
2315
}
2316

    
2317
static int parse_bootdevices(char *devices)
2318
{
2319
    /* We just do some generic consistency checks */
2320
    const char *p;
2321
    int bitmap = 0;
2322

    
2323
    for (p = devices; *p != '\0'; p++) {
2324
        /* Allowed boot devices are:
2325
         * a-b: floppy disk drives
2326
         * c-f: IDE disk drives
2327
         * g-m: machine implementation dependant drives
2328
         * n-p: network devices
2329
         * It's up to each machine implementation to check if the given boot
2330
         * devices match the actual hardware implementation and firmware
2331
         * features.
2332
         */
2333
        if (*p < 'a' || *p > 'p') {
2334
            fprintf(stderr, "Invalid boot device '%c'\n", *p);
2335
            exit(1);
2336
        }
2337
        if (bitmap & (1 << (*p - 'a'))) {
2338
            fprintf(stderr, "Boot device '%c' was given twice\n", *p);
2339
            exit(1);
2340
        }
2341
        bitmap |= 1 << (*p - 'a');
2342
    }
2343
    return bitmap;
2344
}
2345

    
2346
static void restore_boot_devices(void *opaque)
2347
{
2348
    char *standard_boot_devices = opaque;
2349

    
2350
    qemu_boot_set(standard_boot_devices);
2351

    
2352
    qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
2353
    qemu_free(standard_boot_devices);
2354
}
2355

    
2356
static void numa_add(const char *optarg)
2357
{
2358
    char option[128];
2359
    char *endptr;
2360
    unsigned long long value, endvalue;
2361
    int nodenr;
2362

    
2363
    optarg = get_opt_name(option, 128, optarg, ',') + 1;
2364
    if (!strcmp(option, "node")) {
2365
        if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2366
            nodenr = nb_numa_nodes;
2367
        } else {
2368
            nodenr = strtoull(option, NULL, 10);
2369
        }
2370

    
2371
        if (get_param_value(option, 128, "mem", optarg) == 0) {
2372
            node_mem[nodenr] = 0;
2373
        } else {
2374
            value = strtoull(option, &endptr, 0);
2375
            switch (*endptr) {
2376
            case 0: case 'M': case 'm':
2377
                value <<= 20;
2378
                break;
2379
            case 'G': case 'g':
2380
                value <<= 30;
2381
                break;
2382
            }
2383
            node_mem[nodenr] = value;
2384
        }
2385
        if (get_param_value(option, 128, "cpus", optarg) == 0) {
2386
            node_cpumask[nodenr] = 0;
2387
        } else {
2388
            value = strtoull(option, &endptr, 10);
2389
            if (value >= 64) {
2390
                value = 63;
2391
                fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2392
            } else {
2393
                if (*endptr == '-') {
2394
                    endvalue = strtoull(endptr+1, &endptr, 10);
2395
                    if (endvalue >= 63) {
2396
                        endvalue = 62;
2397
                        fprintf(stderr,
2398
                            "only 63 CPUs in NUMA mode supported.\n");
2399
                    }
2400
                    value = (2ULL << endvalue) - (1ULL << value);
2401
                } else {
2402
                    value = 1ULL << value;
2403
                }
2404
            }
2405
            node_cpumask[nodenr] = value;
2406
        }
2407
        nb_numa_nodes++;
2408
    }
2409
    return;
2410
}
2411

    
2412
static void smp_parse(const char *optarg)
2413
{
2414
    int smp, sockets = 0, threads = 0, cores = 0;
2415
    char *endptr;
2416
    char option[128];
2417

    
2418
    smp = strtoul(optarg, &endptr, 10);
2419
    if (endptr != optarg) {
2420
        if (*endptr == ',') {
2421
            endptr++;
2422
        }
2423
    }
2424
    if (get_param_value(option, 128, "sockets", endptr) != 0)
2425
        sockets = strtoull(option, NULL, 10);
2426
    if (get_param_value(option, 128, "cores", endptr) != 0)
2427
        cores = strtoull(option, NULL, 10);
2428
    if (get_param_value(option, 128, "threads", endptr) != 0)
2429
        threads = strtoull(option, NULL, 10);
2430
    if (get_param_value(option, 128, "maxcpus", endptr) != 0)
2431
        max_cpus = strtoull(option, NULL, 10);
2432

    
2433
    /* compute missing values, prefer sockets over cores over threads */
2434
    if (smp == 0 || sockets == 0) {
2435
        sockets = sockets > 0 ? sockets : 1;
2436
        cores = cores > 0 ? cores : 1;
2437
        threads = threads > 0 ? threads : 1;
2438
        if (smp == 0) {
2439
            smp = cores * threads * sockets;
2440
        }
2441
    } else {
2442
        if (cores == 0) {
2443
            threads = threads > 0 ? threads : 1;
2444
            cores = smp / (sockets * threads);
2445
        } else {
2446
            if (sockets) {
2447
                threads = smp / (cores * sockets);
2448
            }
2449
        }
2450
    }
2451
    smp_cpus = smp;
2452
    smp_cores = cores > 0 ? cores : 1;
2453
    smp_threads = threads > 0 ? threads : 1;
2454
    if (max_cpus == 0)
2455
        max_cpus = smp_cpus;
2456
}
2457

    
2458
/***********************************************************/
2459
/* USB devices */
2460

    
2461
static int usb_device_add(const char *devname, int is_hotplug)
2462
{
2463
    const char *p;
2464
    USBDevice *dev = NULL;
2465

    
2466
    if (!usb_enabled)
2467
        return -1;
2468

    
2469
    /* drivers with .usbdevice_name entry in USBDeviceInfo */
2470
    dev = usbdevice_create(devname);
2471
    if (dev)
2472
        goto done;
2473

    
2474
    /* the other ones */
2475
    if (strstart(devname, "host:", &p)) {
2476
        dev = usb_host_device_open(p);
2477
    } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2478
        dev = usb_bt_init(devname[2] ? hci_init(p) :
2479
                        bt_new_hci(qemu_find_bt_vlan(0)));
2480
    } else {
2481
        return -1;
2482
    }
2483
    if (!dev)
2484
        return -1;
2485

    
2486
done:
2487
    return 0;
2488
}
2489

    
2490
static int usb_device_del(const char *devname)
2491
{
2492
    int bus_num, addr;
2493
    const char *p;
2494

    
2495
    if (strstart(devname, "host:", &p))
2496
        return usb_host_device_close(p);
2497

    
2498
    if (!usb_enabled)
2499
        return -1;
2500

    
2501
    p = strchr(devname, '.');
2502
    if (!p)
2503
        return -1;
2504
    bus_num = strtoul(devname, NULL, 0);
2505
    addr = strtoul(p + 1, NULL, 0);
2506

    
2507
    return usb_device_delete_addr(bus_num, addr);
2508
}
2509

    
2510
static int usb_parse(const char *cmdline)
2511
{
2512
    int r;
2513
    r = usb_device_add(cmdline, 0);
2514
    if (r < 0) {
2515
        fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
2516
    }
2517
    return r;
2518
}
2519

    
2520
void do_usb_add(Monitor *mon, const QDict *qdict)
2521
{
2522
    const char *devname = qdict_get_str(qdict, "devname");
2523
    if (usb_device_add(devname, 1) < 0) {
2524
        qemu_error("could not add USB device '%s'\n", devname);
2525
    }
2526
}
2527

    
2528
void do_usb_del(Monitor *mon, const QDict *qdict)
2529
{
2530
    const char *devname = qdict_get_str(qdict, "devname");
2531
    if (usb_device_del(devname) < 0) {
2532
        qemu_error("could not delete USB device '%s'\n", devname);
2533
    }
2534
}
2535

    
2536
/***********************************************************/
2537
/* PCMCIA/Cardbus */
2538

    
2539
static struct pcmcia_socket_entry_s {
2540
    PCMCIASocket *socket;
2541
    struct pcmcia_socket_entry_s *next;
2542
} *pcmcia_sockets = 0;
2543

    
2544
void pcmcia_socket_register(PCMCIASocket *socket)
2545
{
2546
    struct pcmcia_socket_entry_s *entry;
2547

    
2548
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2549
    entry->socket = socket;
2550
    entry->next = pcmcia_sockets;
2551
    pcmcia_sockets = entry;
2552
}
2553

    
2554
void pcmcia_socket_unregister(PCMCIASocket *socket)
2555
{
2556
    struct pcmcia_socket_entry_s *entry, **ptr;
2557

    
2558
    ptr = &pcmcia_sockets;
2559
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2560
        if (entry->socket == socket) {
2561
            *ptr = entry->next;
2562
            qemu_free(entry);
2563
        }
2564
}
2565

    
2566
void pcmcia_info(Monitor *mon)
2567
{
2568
    struct pcmcia_socket_entry_s *iter;
2569

    
2570
    if (!pcmcia_sockets)
2571
        monitor_printf(mon, "No PCMCIA sockets\n");
2572

    
2573
    for (iter = pcmcia_sockets; iter; iter = iter->next)
2574
        monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2575
                       iter->socket->attached ? iter->socket->card_string :
2576
                       "Empty");
2577
}
2578

    
2579
/***********************************************************/
2580
/* register display */
2581

    
2582
struct DisplayAllocator default_allocator = {
2583
    defaultallocator_create_displaysurface,
2584
    defaultallocator_resize_displaysurface,
2585
    defaultallocator_free_displaysurface
2586
};
2587

    
2588
void register_displaystate(DisplayState *ds)
2589
{
2590
    DisplayState **s;
2591
    s = &display_state;
2592
    while (*s != NULL)
2593
        s = &(*s)->next;
2594
    ds->next = NULL;
2595
    *s = ds;
2596
}
2597

    
2598
DisplayState *get_displaystate(void)
2599
{
2600
    return display_state;
2601
}
2602

    
2603
DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2604
{
2605
    if(ds->allocator ==  &default_allocator) ds->allocator = da;
2606
    return ds->allocator;
2607
}
2608

    
2609
/* dumb display */
2610

    
2611
static void dumb_display_init(void)
2612
{
2613
    DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2614
    ds->allocator = &default_allocator;
2615
    ds->surface = qemu_create_displaysurface(ds, 640, 480);
2616
    register_displaystate(ds);
2617
}
2618

    
2619
/***********************************************************/
2620
/* I/O handling */
2621

    
2622
typedef struct IOHandlerRecord {
2623
    int fd;
2624
    IOCanRWHandler *fd_read_poll;
2625
    IOHandler *fd_read;
2626
    IOHandler *fd_write;
2627
    int deleted;
2628
    void *opaque;
2629
    /* temporary data */
2630
    struct pollfd *ufd;
2631
    struct IOHandlerRecord *next;
2632
} IOHandlerRecord;
2633

    
2634
static IOHandlerRecord *first_io_handler;
2635

    
2636
/* XXX: fd_read_poll should be suppressed, but an API change is
2637
   necessary in the character devices to suppress fd_can_read(). */
2638
int qemu_set_fd_handler2(int fd,
2639
                         IOCanRWHandler *fd_read_poll,
2640
                         IOHandler *fd_read,
2641
                         IOHandler *fd_write,
2642
                         void *opaque)
2643
{
2644
    IOHandlerRecord **pioh, *ioh;
2645

    
2646
    if (!fd_read && !fd_write) {
2647
        pioh = &first_io_handler;
2648
        for(;;) {
2649
            ioh = *pioh;
2650
            if (ioh == NULL)
2651
                break;
2652
            if (ioh->fd == fd) {
2653
                ioh->deleted = 1;
2654
                break;
2655
            }
2656
            pioh = &ioh->next;
2657
        }
2658
    } else {
2659
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2660
            if (ioh->fd == fd)
2661
                goto found;
2662
        }
2663
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2664
        ioh->next = first_io_handler;
2665
        first_io_handler = ioh;
2666
    found:
2667
        ioh->fd = fd;
2668
        ioh->fd_read_poll = fd_read_poll;
2669
        ioh->fd_read = fd_read;
2670
        ioh->fd_write = fd_write;
2671
        ioh->opaque = opaque;
2672
        ioh->deleted = 0;
2673
    }
2674
    return 0;
2675
}
2676

    
2677
int qemu_set_fd_handler(int fd,
2678
                        IOHandler *fd_read,
2679
                        IOHandler *fd_write,
2680
                        void *opaque)
2681
{
2682
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2683
}
2684

    
2685
#ifdef _WIN32
2686
/***********************************************************/
2687
/* Polling handling */
2688

    
2689
typedef struct PollingEntry {
2690
    PollingFunc *func;
2691
    void *opaque;
2692
    struct PollingEntry *next;
2693
} PollingEntry;
2694

    
2695
static PollingEntry *first_polling_entry;
2696

    
2697
int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2698
{
2699
    PollingEntry **ppe, *pe;
2700
    pe = qemu_mallocz(sizeof(PollingEntry));
2701
    pe->func = func;
2702
    pe->opaque = opaque;
2703
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2704
    *ppe = pe;
2705
    return 0;
2706
}
2707

    
2708
void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2709
{
2710
    PollingEntry **ppe, *pe;
2711
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2712
        pe = *ppe;
2713
        if (pe->func == func && pe->opaque == opaque) {
2714
            *ppe = pe->next;
2715
            qemu_free(pe);
2716
            break;
2717
        }
2718
    }
2719
}
2720

    
2721
/***********************************************************/
2722
/* Wait objects support */
2723
typedef struct WaitObjects {
2724
    int num;
2725
    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
2726
    WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
2727
    void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
2728
} WaitObjects;
2729

    
2730
static WaitObjects wait_objects = {0};
2731

    
2732
int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2733
{
2734
    WaitObjects *w = &wait_objects;
2735

    
2736
    if (w->num >= MAXIMUM_WAIT_OBJECTS)
2737
        return -1;
2738
    w->events[w->num] = handle;
2739
    w->func[w->num] = func;
2740
    w->opaque[w->num] = opaque;
2741
    w->num++;
2742
    return 0;
2743
}
2744

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

    
2750
    found = 0;
2751
    for (i = 0; i < w->num; i++) {
2752
        if (w->events[i] == handle)
2753
            found = 1;
2754
        if (found) {
2755
            w->events[i] = w->events[i + 1];
2756
            w->func[i] = w->func[i + 1];
2757
            w->opaque[i] = w->opaque[i + 1];
2758
        }
2759
    }
2760
    if (found)
2761
        w->num--;
2762
}
2763
#endif
2764

    
2765
/***********************************************************/
2766
/* ram save/restore */
2767

    
2768
#define RAM_SAVE_FLAG_FULL        0x01 /* Obsolete, not used anymore */
2769
#define RAM_SAVE_FLAG_COMPRESS        0x02
2770
#define RAM_SAVE_FLAG_MEM_SIZE        0x04
2771
#define RAM_SAVE_FLAG_PAGE        0x08
2772
#define RAM_SAVE_FLAG_EOS        0x10
2773

    
2774
static int is_dup_page(uint8_t *page, uint8_t ch)
2775
{
2776
    uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
2777
    uint32_t *array = (uint32_t *)page;
2778
    int i;
2779

    
2780
    for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
2781
        if (array[i] != val)
2782
            return 0;
2783
    }
2784

    
2785
    return 1;
2786
}
2787

    
2788
static int ram_save_block(QEMUFile *f)
2789
{
2790
    static ram_addr_t current_addr = 0;
2791
    ram_addr_t saved_addr = current_addr;
2792
    ram_addr_t addr = 0;
2793
    int found = 0;
2794

    
2795
    while (addr < last_ram_offset) {
2796
        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
2797
            uint8_t *p;
2798

    
2799
            cpu_physical_memory_reset_dirty(current_addr,
2800
                                            current_addr + TARGET_PAGE_SIZE,
2801
                                            MIGRATION_DIRTY_FLAG);
2802

    
2803
            p = qemu_get_ram_ptr(current_addr);
2804

    
2805
            if (is_dup_page(p, *p)) {
2806
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
2807
                qemu_put_byte(f, *p);
2808
            } else {
2809
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
2810
                qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
2811
            }
2812

    
2813
            found = 1;
2814
            break;
2815
        }
2816
        addr += TARGET_PAGE_SIZE;
2817
        current_addr = (saved_addr + addr) % last_ram_offset;
2818
    }
2819

    
2820
    return found;
2821
}
2822

    
2823
static uint64_t bytes_transferred;
2824

    
2825
static ram_addr_t ram_save_remaining(void)
2826
{
2827
    ram_addr_t addr;
2828
    ram_addr_t count = 0;
2829

    
2830
    for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
2831
        if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
2832
            count++;
2833
    }
2834

    
2835
    return count;
2836
}
2837

    
2838
uint64_t ram_bytes_remaining(void)
2839
{
2840
    return ram_save_remaining() * TARGET_PAGE_SIZE;
2841
}
2842

    
2843
uint64_t ram_bytes_transferred(void)
2844
{
2845
    return bytes_transferred;
2846
}
2847

    
2848
uint64_t ram_bytes_total(void)
2849
{
2850
    return last_ram_offset;
2851
}
2852

    
2853
static int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
2854
{
2855
    ram_addr_t addr;
2856
    uint64_t bytes_transferred_last;
2857
    double bwidth = 0;
2858
    uint64_t expected_time = 0;
2859

    
2860
    if (stage < 0) {
2861
        cpu_physical_memory_set_dirty_tracking(0);
2862
        return 0;
2863
    }
2864

    
2865
    if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
2866
        qemu_file_set_error(f);
2867
        return 0;
2868
    }
2869

    
2870
    if (stage == 1) {
2871
        bytes_transferred = 0;
2872

    
2873
        /* Make sure all dirty bits are set */
2874
        for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
2875
            if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
2876
                cpu_physical_memory_set_dirty(addr);
2877
        }
2878

    
2879
        /* Enable dirty memory tracking */
2880
        cpu_physical_memory_set_dirty_tracking(1);
2881

    
2882
        qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
2883
    }
2884

    
2885
    bytes_transferred_last = bytes_transferred;
2886
    bwidth = qemu_get_clock_ns(rt_clock);
2887

    
2888
    while (!qemu_file_rate_limit(f)) {
2889
        int ret;
2890

    
2891
        ret = ram_save_block(f);
2892
        bytes_transferred += ret * TARGET_PAGE_SIZE;
2893
        if (ret == 0) /* no more blocks */
2894
            break;
2895
    }
2896

    
2897
    bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
2898
    bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
2899

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

    
2905
    /* try transferring iterative blocks of memory */
2906
    if (stage == 3) {
2907
        /* flush all remaining blocks regardless of rate limiting */
2908
        while (ram_save_block(f) != 0) {
2909
            bytes_transferred += TARGET_PAGE_SIZE;
2910
        }
2911
        cpu_physical_memory_set_dirty_tracking(0);
2912
    }
2913

    
2914
    qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
2915

    
2916
    expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
2917

    
2918
    return (stage == 2) && (expected_time <= migrate_max_downtime());
2919
}
2920

    
2921
static int ram_load(QEMUFile *f, void *opaque, int version_id)
2922
{
2923
    ram_addr_t addr;
2924
    int flags;
2925

    
2926
    if (version_id != 3)
2927
        return -EINVAL;
2928

    
2929
    do {
2930
        addr = qemu_get_be64(f);
2931

    
2932
        flags = addr & ~TARGET_PAGE_MASK;
2933
        addr &= TARGET_PAGE_MASK;
2934

    
2935
        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
2936
            if (addr != last_ram_offset)
2937
                return -EINVAL;
2938
        }
2939

    
2940
        if (flags & RAM_SAVE_FLAG_COMPRESS) {
2941
            uint8_t ch = qemu_get_byte(f);
2942
            memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
2943
#ifndef _WIN32
2944
            if (ch == 0 &&
2945
                (!kvm_enabled() || kvm_has_sync_mmu())) {
2946
                madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
2947
            }
2948
#endif
2949
        } else if (flags & RAM_SAVE_FLAG_PAGE) {
2950
            qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
2951
        }
2952
        if (qemu_file_has_error(f)) {
2953
            return -EIO;
2954
        }
2955
    } while (!(flags & RAM_SAVE_FLAG_EOS));
2956

    
2957
    return 0;
2958
}
2959

    
2960
void qemu_service_io(void)
2961
{
2962
    qemu_notify_event();
2963
}
2964

    
2965
/***********************************************************/
2966
/* machine registration */
2967

    
2968
static QEMUMachine *first_machine = NULL;
2969
QEMUMachine *current_machine = NULL;
2970

    
2971
int qemu_register_machine(QEMUMachine *m)
2972
{
2973
    QEMUMachine **pm;
2974
    pm = &first_machine;
2975
    while (*pm != NULL)
2976
        pm = &(*pm)->next;
2977
    m->next = NULL;
2978
    *pm = m;
2979
    return 0;
2980
}
2981

    
2982
static QEMUMachine *find_machine(const char *name)
2983
{
2984
    QEMUMachine *m;
2985

    
2986
    for(m = first_machine; m != NULL; m = m->next) {
2987
        if (!strcmp(m->name, name))
2988
            return m;
2989
        if (m->alias && !strcmp(m->alias, name))
2990
            return m;
2991
    }
2992
    return NULL;
2993
}
2994

    
2995
static QEMUMachine *find_default_machine(void)
2996
{
2997
    QEMUMachine *m;
2998

    
2999
    for(m = first_machine; m != NULL; m = m->next) {
3000
        if (m->is_default) {
3001
            return m;
3002
        }
3003
    }
3004
    return NULL;
3005
}
3006

    
3007
/***********************************************************/
3008
/* main execution loop */
3009

    
3010
static void gui_update(void *opaque)
3011
{
3012
    uint64_t interval = GUI_REFRESH_INTERVAL;
3013
    DisplayState *ds = opaque;
3014
    DisplayChangeListener *dcl = ds->listeners;
3015

    
3016
    qemu_flush_coalesced_mmio_buffer();
3017
    dpy_refresh(ds);
3018

    
3019
    while (dcl != NULL) {
3020
        if (dcl->gui_timer_interval &&
3021
            dcl->gui_timer_interval < interval)
3022
            interval = dcl->gui_timer_interval;
3023
        dcl = dcl->next;
3024
    }
3025
    qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3026
}
3027

    
3028
static void nographic_update(void *opaque)
3029
{
3030
    uint64_t interval = GUI_REFRESH_INTERVAL;
3031

    
3032
    qemu_flush_coalesced_mmio_buffer();
3033
    qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3034
}
3035

    
3036
struct vm_change_state_entry {
3037
    VMChangeStateHandler *cb;
3038
    void *opaque;
3039
    QLIST_ENTRY (vm_change_state_entry) entries;
3040
};
3041

    
3042
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3043

    
3044
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3045
                                                     void *opaque)
3046
{
3047
    VMChangeStateEntry *e;
3048

    
3049
    e = qemu_mallocz(sizeof (*e));
3050

    
3051
    e->cb = cb;
3052
    e->opaque = opaque;
3053
    QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3054
    return e;
3055
}
3056

    
3057
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3058
{
3059
    QLIST_REMOVE (e, entries);
3060
    qemu_free (e);
3061
}
3062

    
3063
static void vm_state_notify(int running, int reason)
3064
{
3065
    VMChangeStateEntry *e;
3066

    
3067
    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3068
        e->cb(e->opaque, running, reason);
3069
    }
3070
}
3071

    
3072
static void resume_all_vcpus(void);
3073
static void pause_all_vcpus(void);
3074

    
3075
void vm_start(void)
3076
{
3077
    if (!vm_running) {
3078
        cpu_enable_ticks();
3079
        vm_running = 1;
3080
        vm_state_notify(1, 0);
3081
        qemu_rearm_alarm_timer(alarm_timer);
3082
        resume_all_vcpus();
3083
    }
3084
}
3085

    
3086
/* reset/shutdown handler */
3087

    
3088
typedef struct QEMUResetEntry {
3089
    QTAILQ_ENTRY(QEMUResetEntry) entry;
3090
    QEMUResetHandler *func;
3091
    void *opaque;
3092
} QEMUResetEntry;
3093

    
3094
static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
3095
    QTAILQ_HEAD_INITIALIZER(reset_handlers);
3096
static int reset_requested;
3097
static int shutdown_requested;
3098
static int powerdown_requested;
3099
static int debug_requested;
3100
static int vmstop_requested;
3101

    
3102
int qemu_shutdown_requested(void)
3103
{
3104
    int r = shutdown_requested;
3105
    shutdown_requested = 0;
3106
    return r;
3107
}
3108

    
3109
int qemu_reset_requested(void)
3110
{
3111
    int r = reset_requested;
3112
    reset_requested = 0;
3113
    return r;
3114
}
3115

    
3116
int qemu_powerdown_requested(void)
3117
{
3118
    int r = powerdown_requested;
3119
    powerdown_requested = 0;
3120
    return r;
3121
}
3122

    
3123
static int qemu_debug_requested(void)
3124
{
3125
    int r = debug_requested;
3126
    debug_requested = 0;
3127
    return r;
3128
}
3129

    
3130
static int qemu_vmstop_requested(void)
3131
{
3132
    int r = vmstop_requested;
3133
    vmstop_requested = 0;
3134
    return r;
3135
}
3136

    
3137
static void do_vm_stop(int reason)
3138
{
3139
    if (vm_running) {
3140
        cpu_disable_ticks();
3141
        vm_running = 0;
3142
        pause_all_vcpus();
3143
        vm_state_notify(0, reason);
3144
    }
3145
}
3146

    
3147
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3148
{
3149
    QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
3150

    
3151
    re->func = func;
3152
    re->opaque = opaque;
3153
    QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
3154
}
3155

    
3156
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
3157
{
3158
    QEMUResetEntry *re;
3159

    
3160
    QTAILQ_FOREACH(re, &reset_handlers, entry) {
3161
        if (re->func == func && re->opaque == opaque) {
3162
            QTAILQ_REMOVE(&reset_handlers, re, entry);
3163
            qemu_free(re);
3164
            return;
3165
        }
3166
    }
3167
}
3168

    
3169
void qemu_system_reset(void)
3170
{
3171
    QEMUResetEntry *re, *nre;
3172

    
3173
    /* reset all devices */
3174
    QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
3175
        re->func(re->opaque);
3176
    }
3177
}
3178

    
3179
void qemu_system_reset_request(void)
3180
{
3181
    if (no_reboot) {
3182
        shutdown_requested = 1;
3183
    } else {
3184
        reset_requested = 1;
3185
    }
3186
    qemu_notify_event();
3187
}
3188

    
3189
void qemu_system_shutdown_request(void)
3190
{
3191
    shutdown_requested = 1;
3192
    qemu_notify_event();
3193
}
3194

    
3195
void qemu_system_powerdown_request(void)
3196
{
3197
    powerdown_requested = 1;
3198
    qemu_notify_event();
3199
}
3200

    
3201
#ifdef CONFIG_IOTHREAD
3202
static void qemu_system_vmstop_request(int reason)
3203
{
3204
    vmstop_requested = reason;
3205
    qemu_notify_event();
3206
}
3207
#endif
3208

    
3209
#ifndef _WIN32
3210
static int io_thread_fd = -1;
3211

    
3212
static void qemu_event_increment(void)
3213
{
3214
    static const char byte = 0;
3215
    ssize_t ret;
3216

    
3217
    if (io_thread_fd == -1)
3218
        return;
3219

    
3220
    ret = write(io_thread_fd, &byte, sizeof(byte));
3221
    if (ret < 0 && (errno != EINTR && errno != EAGAIN)) {
3222
        fprintf(stderr, "qemu_event_increment: write() filed: %s\n",
3223
                strerror(errno));
3224
        exit (1);
3225
    }
3226
}
3227

    
3228
static void qemu_event_read(void *opaque)
3229
{
3230
    int fd = (unsigned long)opaque;
3231
    ssize_t len;
3232
    char buffer[512];
3233

    
3234
    /* Drain the notify pipe */
3235
    do {
3236
        len = read(fd, buffer, sizeof(buffer));
3237
    } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
3238
}
3239

    
3240
static int qemu_event_init(void)
3241
{
3242
    int err;
3243
    int fds[2];
3244

    
3245
    err = qemu_pipe(fds);
3246
    if (err == -1)
3247
        return -errno;
3248

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

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

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

    
3260
    io_thread_fd = fds[1];
3261
    return 0;
3262

    
3263
fail:
3264
    close(fds[0]);
3265
    close(fds[1]);
3266
    return err;
3267
}
3268
#else
3269
HANDLE qemu_event_handle;
3270

    
3271
static void dummy_event_handler(void *opaque)
3272
{
3273
}
3274

    
3275
static int qemu_event_init(void)
3276
{
3277
    qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3278
    if (!qemu_event_handle) {
3279
        fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
3280
        return -1;
3281
    }
3282
    qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3283
    return 0;
3284
}
3285

    
3286
static void qemu_event_increment(void)
3287
{
3288
    if (!SetEvent(qemu_event_handle)) {
3289
        fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
3290
                GetLastError());
3291
        exit (1);
3292
    }
3293
}
3294
#endif
3295

    
3296
static int cpu_can_run(CPUState *env)
3297
{
3298
    if (env->stop)
3299
        return 0;
3300
    if (env->stopped)
3301
        return 0;
3302
    if (!vm_running)
3303
        return 0;
3304
    return 1;
3305
}
3306

    
3307
#ifndef CONFIG_IOTHREAD
3308
static int qemu_init_main_loop(void)
3309
{
3310
    return qemu_event_init();
3311
}
3312

    
3313
void qemu_init_vcpu(void *_env)
3314
{
3315
    CPUState *env = _env;
3316

    
3317
    env->nr_cores = smp_cores;
3318
    env->nr_threads = smp_threads;
3319
    if (kvm_enabled())
3320
        kvm_init_vcpu(env);
3321
    return;
3322
}
3323

    
3324
int qemu_cpu_self(void *env)
3325
{
3326
    return 1;
3327
}
3328

    
3329
static void resume_all_vcpus(void)
3330
{
3331
}
3332

    
3333
static void pause_all_vcpus(void)
3334
{
3335
}
3336

    
3337
void qemu_cpu_kick(void *env)
3338
{
3339
    return;
3340
}
3341

    
3342
void qemu_notify_event(void)
3343
{
3344
    CPUState *env = cpu_single_env;
3345

    
3346
    if (env) {
3347
        cpu_exit(env);
3348
    }
3349
}
3350

    
3351
void qemu_mutex_lock_iothread(void) {}
3352
void qemu_mutex_unlock_iothread(void) {}
3353

    
3354
void vm_stop(int reason)
3355
{
3356
    do_vm_stop(reason);
3357
}
3358

    
3359
#else /* CONFIG_IOTHREAD */
3360

    
3361
#include "qemu-thread.h"
3362

    
3363
QemuMutex qemu_global_mutex;
3364
static QemuMutex qemu_fair_mutex;
3365

    
3366
static QemuThread io_thread;
3367

    
3368
static QemuThread *tcg_cpu_thread;
3369
static QemuCond *tcg_halt_cond;
3370

    
3371
static int qemu_system_ready;
3372
/* cpu creation */
3373
static QemuCond qemu_cpu_cond;
3374
/* system init */
3375
static QemuCond qemu_system_cond;
3376
static QemuCond qemu_pause_cond;
3377

    
3378
static void block_io_signals(void);
3379
static void unblock_io_signals(void);
3380
static int tcg_has_work(void);
3381

    
3382
static int qemu_init_main_loop(void)
3383
{
3384
    int ret;
3385

    
3386
    ret = qemu_event_init();
3387
    if (ret)
3388
        return ret;
3389

    
3390
    qemu_cond_init(&qemu_pause_cond);
3391
    qemu_mutex_init(&qemu_fair_mutex);
3392
    qemu_mutex_init(&qemu_global_mutex);
3393
    qemu_mutex_lock(&qemu_global_mutex);
3394

    
3395
    unblock_io_signals();
3396
    qemu_thread_self(&io_thread);
3397

    
3398
    return 0;
3399
}
3400

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

    
3406
    qemu_mutex_unlock(&qemu_global_mutex);
3407

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

    
3416
    qemu_mutex_lock(&qemu_global_mutex);
3417
    if (env->stop) {
3418
        env->stop = 0;
3419
        env->stopped = 1;
3420
        qemu_cond_signal(&qemu_pause_cond);
3421
    }
3422
}
3423

    
3424
static int qemu_cpu_exec(CPUState *env);
3425

    
3426
static void *kvm_cpu_thread_fn(void *arg)
3427
{
3428
    CPUState *env = arg;
3429

    
3430
    block_io_signals();
3431
    qemu_thread_self(env->thread);
3432
    if (kvm_enabled())
3433
        kvm_init_vcpu(env);
3434

    
3435
    /* signal CPU creation */
3436
    qemu_mutex_lock(&qemu_global_mutex);
3437
    env->created = 1;
3438
    qemu_cond_signal(&qemu_cpu_cond);
3439

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

    
3444
    while (1) {
3445
        if (cpu_can_run(env))
3446
            qemu_cpu_exec(env);
3447
        qemu_wait_io_event(env);
3448
    }
3449

    
3450
    return NULL;
3451
}
3452

    
3453
static void tcg_cpu_exec(void);
3454

    
3455
static void *tcg_cpu_thread_fn(void *arg)
3456
{
3457
    CPUState *env = arg;
3458

    
3459
    block_io_signals();
3460
    qemu_thread_self(env->thread);
3461

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

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

    
3472
    while (1) {
3473
        tcg_cpu_exec();
3474
        qemu_wait_io_event(cur_cpu);
3475
    }
3476

    
3477
    return NULL;
3478
}
3479

    
3480
void qemu_cpu_kick(void *_env)
3481
{
3482
    CPUState *env = _env;
3483
    qemu_cond_broadcast(env->halt_cond);
3484
    if (kvm_enabled())
3485
        qemu_thread_signal(env->thread, SIGUSR1);
3486
}
3487

    
3488
int qemu_cpu_self(void *_env)
3489
{
3490
    CPUState *env = _env;
3491
    QemuThread this;
3492
 
3493
    qemu_thread_self(&this);
3494
 
3495
    return qemu_thread_equal(&this, env->thread);
3496
}
3497

    
3498
static void cpu_signal(int sig)
3499
{
3500
    if (cpu_single_env)
3501
        cpu_exit(cpu_single_env);
3502
}
3503

    
3504
static void block_io_signals(void)
3505
{
3506
    sigset_t set;
3507
    struct sigaction sigact;
3508

    
3509
    sigemptyset(&set);
3510
    sigaddset(&set, SIGUSR2);
3511
    sigaddset(&set, SIGIO);
3512
    sigaddset(&set, SIGALRM);
3513
    pthread_sigmask(SIG_BLOCK, &set, NULL);
3514

    
3515
    sigemptyset(&set);
3516
    sigaddset(&set, SIGUSR1);
3517
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3518

    
3519
    memset(&sigact, 0, sizeof(sigact));
3520
    sigact.sa_handler = cpu_signal;
3521
    sigaction(SIGUSR1, &sigact, NULL);
3522
}
3523

    
3524
static void unblock_io_signals(void)
3525
{
3526
    sigset_t set;
3527

    
3528
    sigemptyset(&set);
3529
    sigaddset(&set, SIGUSR2);
3530
    sigaddset(&set, SIGIO);
3531
    sigaddset(&set, SIGALRM);
3532
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3533

    
3534
    sigemptyset(&set);
3535
    sigaddset(&set, SIGUSR1);
3536
    pthread_sigmask(SIG_BLOCK, &set, NULL);
3537
}
3538

    
3539
static void qemu_signal_lock(unsigned int msecs)
3540
{
3541
    qemu_mutex_lock(&qemu_fair_mutex);
3542

    
3543
    while (qemu_mutex_trylock(&qemu_global_mutex)) {
3544
        qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
3545
        if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
3546
            break;
3547
    }
3548
    qemu_mutex_unlock(&qemu_fair_mutex);
3549
}
3550

    
3551
void qemu_mutex_lock_iothread(void)
3552
{
3553
    if (kvm_enabled()) {
3554
        qemu_mutex_lock(&qemu_fair_mutex);
3555
        qemu_mutex_lock(&qemu_global_mutex);
3556
        qemu_mutex_unlock(&qemu_fair_mutex);
3557
    } else
3558
        qemu_signal_lock(100);
3559
}
3560

    
3561
void qemu_mutex_unlock_iothread(void)
3562
{
3563
    qemu_mutex_unlock(&qemu_global_mutex);
3564
}
3565

    
3566
static int all_vcpus_paused(void)
3567
{
3568
    CPUState *penv = first_cpu;
3569

    
3570
    while (penv) {
3571
        if (!penv->stopped)
3572
            return 0;
3573
        penv = (CPUState *)penv->next_cpu;
3574
    }
3575

    
3576
    return 1;
3577
}
3578

    
3579
static void pause_all_vcpus(void)
3580
{
3581
    CPUState *penv = first_cpu;
3582

    
3583
    while (penv) {
3584
        penv->stop = 1;
3585
        qemu_thread_signal(penv->thread, SIGUSR1);
3586
        qemu_cpu_kick(penv);
3587
        penv = (CPUState *)penv->next_cpu;
3588
    }
3589

    
3590
    while (!all_vcpus_paused()) {
3591
        qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
3592
        penv = first_cpu;
3593
        while (penv) {
3594
            qemu_thread_signal(penv->thread, SIGUSR1);
3595
            penv = (CPUState *)penv->next_cpu;
3596
        }
3597
    }
3598
}
3599

    
3600
static void resume_all_vcpus(void)
3601
{
3602
    CPUState *penv = first_cpu;
3603

    
3604
    while (penv) {
3605
        penv->stop = 0;
3606
        penv->stopped = 0;
3607
        qemu_thread_signal(penv->thread, SIGUSR1);
3608
        qemu_cpu_kick(penv);
3609
        penv = (CPUState *)penv->next_cpu;
3610
    }
3611
}
3612

    
3613
static void tcg_init_vcpu(void *_env)
3614
{
3615
    CPUState *env = _env;
3616
    /* share a single thread for all cpus with TCG */
3617
    if (!tcg_cpu_thread) {
3618
        env->thread = qemu_mallocz(sizeof(QemuThread));
3619
        env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3620
        qemu_cond_init(env->halt_cond);
3621
        qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
3622
        while (env->created == 0)
3623
            qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3624
        tcg_cpu_thread = env->thread;
3625
        tcg_halt_cond = env->halt_cond;
3626
    } else {
3627
        env->thread = tcg_cpu_thread;
3628
        env->halt_cond = tcg_halt_cond;
3629
    }
3630
}
3631

    
3632
static void kvm_start_vcpu(CPUState *env)
3633
{
3634
    env->thread = qemu_mallocz(sizeof(QemuThread));
3635
    env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3636
    qemu_cond_init(env->halt_cond);
3637
    qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
3638
    while (env->created == 0)
3639
        qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3640
}
3641

    
3642
void qemu_init_vcpu(void *_env)
3643
{
3644
    CPUState *env = _env;
3645

    
3646
    env->nr_cores = smp_cores;
3647
    env->nr_threads = smp_threads;
3648
    if (kvm_enabled())
3649
        kvm_start_vcpu(env);
3650
    else
3651
        tcg_init_vcpu(env);
3652
}
3653

    
3654
void qemu_notify_event(void)
3655
{
3656
    qemu_event_increment();
3657
}
3658

    
3659
void vm_stop(int reason)
3660
{
3661
    QemuThread me;
3662
    qemu_thread_self(&me);
3663

    
3664
    if (!qemu_thread_equal(&me, &io_thread)) {
3665
        qemu_system_vmstop_request(reason);
3666
        /*
3667
         * FIXME: should not return to device code in case
3668
         * vm_stop() has been requested.
3669
         */
3670
        if (cpu_single_env) {
3671
            cpu_exit(cpu_single_env);
3672
            cpu_single_env->stop = 1;
3673
        }
3674
        return;
3675
    }
3676
    do_vm_stop(reason);
3677
}
3678

    
3679
#endif
3680

    
3681

    
3682
#ifdef _WIN32
3683
static void host_main_loop_wait(int *timeout)
3684
{
3685
    int ret, ret2, i;
3686
    PollingEntry *pe;
3687

    
3688

    
3689
    /* XXX: need to suppress polling by better using win32 events */
3690
    ret = 0;
3691
    for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3692
        ret |= pe->func(pe->opaque);
3693
    }
3694
    if (ret == 0) {
3695
        int err;
3696
        WaitObjects *w = &wait_objects;
3697

    
3698
        ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3699
        if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3700
            if (w->func[ret - WAIT_OBJECT_0])
3701
                w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3702

    
3703
            /* Check for additional signaled events */
3704
            for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3705

    
3706
                /* Check if event is signaled */
3707
                ret2 = WaitForSingleObject(w->events[i], 0);
3708
                if(ret2 == WAIT_OBJECT_0) {
3709
                    if (w->func[i])
3710
                        w->func[i](w->opaque[i]);
3711
                } else if (ret2 == WAIT_TIMEOUT) {
3712
                } else {
3713
                    err = GetLastError();
3714
                    fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3715
                }
3716
            }
3717
        } else if (ret == WAIT_TIMEOUT) {
3718
        } else {
3719
            err = GetLastError();
3720
            fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3721
        }
3722
    }
3723

    
3724
    *timeout = 0;
3725
}
3726
#else
3727
static void host_main_loop_wait(int *timeout)
3728
{
3729
}
3730
#endif
3731

    
3732
void main_loop_wait(int timeout)
3733
{
3734
    IOHandlerRecord *ioh;
3735
    fd_set rfds, wfds, xfds;
3736
    int ret, nfds;
3737
    struct timeval tv;
3738

    
3739
    qemu_bh_update_timeout(&timeout);
3740

    
3741
    host_main_loop_wait(&timeout);
3742

    
3743
    /* poll any events */
3744
    /* XXX: separate device handlers from system ones */
3745
    nfds = -1;
3746
    FD_ZERO(&rfds);
3747
    FD_ZERO(&wfds);
3748
    FD_ZERO(&xfds);
3749
    for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3750
        if (ioh->deleted)
3751
            continue;
3752
        if (ioh->fd_read &&
3753
            (!ioh->fd_read_poll ||
3754
             ioh->fd_read_poll(ioh->opaque) != 0)) {
3755
            FD_SET(ioh->fd, &rfds);
3756
            if (ioh->fd > nfds)
3757
                nfds = ioh->fd;
3758
        }
3759
        if (ioh->fd_write) {
3760
            FD_SET(ioh->fd, &wfds);
3761
            if (ioh->fd > nfds)
3762
                nfds = ioh->fd;
3763
        }
3764
    }
3765

    
3766
    tv.tv_sec = timeout / 1000;
3767
    tv.tv_usec = (timeout % 1000) * 1000;
3768

    
3769
    slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3770

    
3771
    qemu_mutex_unlock_iothread();
3772
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3773
    qemu_mutex_lock_iothread();
3774
    if (ret > 0) {
3775
        IOHandlerRecord **pioh;
3776

    
3777
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3778
            if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3779
                ioh->fd_read(ioh->opaque);
3780
            }
3781
            if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3782
                ioh->fd_write(ioh->opaque);
3783
            }
3784
        }
3785

    
3786
        /* remove deleted IO handlers */
3787
        pioh = &first_io_handler;
3788
        while (*pioh) {
3789
            ioh = *pioh;
3790
            if (ioh->deleted) {
3791
                *pioh = ioh->next;
3792
                qemu_free(ioh);
3793
            } else
3794
                pioh = &ioh->next;
3795
        }
3796
    }
3797

    
3798
    slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
3799

    
3800
    /* rearm timer, if not periodic */
3801
    if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
3802
        alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
3803
        qemu_rearm_alarm_timer(alarm_timer);
3804
    }
3805

    
3806
    /* vm time timers */
3807
    if (vm_running) {
3808
        if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3809
            qemu_run_timers(&active_timers[QEMU_CLOCK_VIRTUAL],
3810
                            qemu_get_clock(vm_clock));
3811
    }
3812

    
3813
    /* real time timers */
3814
    qemu_run_timers(&active_timers[QEMU_CLOCK_REALTIME],
3815
                    qemu_get_clock(rt_clock));
3816

    
3817
    qemu_run_timers(&active_timers[QEMU_CLOCK_HOST],
3818
                    qemu_get_clock(host_clock));
3819

    
3820
    /* Check bottom-halves last in case any of the earlier events triggered
3821
       them.  */
3822
    qemu_bh_poll();
3823

    
3824
}
3825

    
3826
static int qemu_cpu_exec(CPUState *env)
3827
{
3828
    int ret;
3829
#ifdef CONFIG_PROFILER
3830
    int64_t ti;
3831
#endif
3832

    
3833
#ifdef CONFIG_PROFILER
3834
    ti = profile_getclock();
3835
#endif
3836
    if (use_icount) {
3837
        int64_t count;
3838
        int decr;
3839
        qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3840
        env->icount_decr.u16.low = 0;
3841
        env->icount_extra = 0;
3842
        count = qemu_next_deadline();
3843
        count = (count + (1 << icount_time_shift) - 1)
3844
                >> icount_time_shift;
3845
        qemu_icount += count;
3846
        decr = (count > 0xffff) ? 0xffff : count;
3847
        count -= decr;
3848
        env->icount_decr.u16.low = decr;
3849
        env->icount_extra = count;
3850
    }
3851
    ret = cpu_exec(env);
3852
#ifdef CONFIG_PROFILER
3853
    qemu_time += profile_getclock() - ti;
3854
#endif
3855
    if (use_icount) {
3856
        /* Fold pending instructions back into the
3857
           instruction counter, and clear the interrupt flag.  */
3858
        qemu_icount -= (env->icount_decr.u16.low
3859
                        + env->icount_extra);
3860
        env->icount_decr.u32 = 0;
3861
        env->icount_extra = 0;
3862
    }
3863
    return ret;
3864
}
3865

    
3866
static void tcg_cpu_exec(void)
3867
{
3868
    int ret = 0;
3869

    
3870
    if (next_cpu == NULL)
3871
        next_cpu = first_cpu;
3872
    for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
3873
        CPUState *env = cur_cpu = next_cpu;
3874

    
3875
        if (!vm_running)
3876
            break;
3877
        if (timer_alarm_pending) {
3878
            timer_alarm_pending = 0;
3879
            break;
3880
        }
3881
        if (cpu_can_run(env))
3882
            ret = qemu_cpu_exec(env);
3883
        if (ret == EXCP_DEBUG) {
3884
            gdb_set_stop_cpu(env);
3885
            debug_requested = 1;
3886
            break;
3887
        }
3888
    }
3889
}
3890

    
3891
static int cpu_has_work(CPUState *env)
3892
{
3893
    if (env->stop)
3894
        return 1;
3895
    if (env->stopped)
3896
        return 0;
3897
    if (!env->halted)
3898
        return 1;
3899
    if (qemu_cpu_has_work(env))
3900
        return 1;
3901
    return 0;
3902
}
3903

    
3904
static int tcg_has_work(void)
3905
{
3906
    CPUState *env;
3907

    
3908
    for (env = first_cpu; env != NULL; env = env->next_cpu)
3909
        if (cpu_has_work(env))
3910
            return 1;
3911
    return 0;
3912
}
3913

    
3914
static int qemu_calculate_timeout(void)
3915
{
3916
#ifndef CONFIG_IOTHREAD
3917
    int timeout;
3918

    
3919
    if (!vm_running)
3920
        timeout = 5000;
3921
    else if (tcg_has_work())
3922
        timeout = 0;
3923
    else if (!use_icount)
3924
        timeout = 5000;
3925
    else {
3926
     /* XXX: use timeout computed from timers */
3927
        int64_t add;
3928
        int64_t delta;
3929
        /* Advance virtual time to the next event.  */
3930
        if (use_icount == 1) {
3931
            /* When not using an adaptive execution frequency
3932
               we tend to get badly out of sync with real time,
3933
               so just delay for a reasonable amount of time.  */
3934
            delta = 0;
3935
        } else {
3936
            delta = cpu_get_icount() - cpu_get_clock();
3937
        }
3938
        if (delta > 0) {
3939
            /* If virtual time is ahead of real time then just
3940
               wait for IO.  */
3941
            timeout = (delta / 1000000) + 1;
3942
        } else {
3943
            /* Wait for either IO to occur or the next
3944
               timer event.  */
3945
            add = qemu_next_deadline();
3946
            /* We advance the timer before checking for IO.
3947
               Limit the amount we advance so that early IO
3948
               activity won't get the guest too far ahead.  */
3949
            if (add > 10000000)
3950
                add = 10000000;
3951
            delta += add;
3952
            add = (add + (1 << icount_time_shift) - 1)
3953
                  >> icount_time_shift;
3954
            qemu_icount += add;
3955
            timeout = delta / 1000000;
3956
            if (timeout < 0)
3957
                timeout = 0;
3958
        }
3959
    }
3960

    
3961
    return timeout;
3962
#else /* CONFIG_IOTHREAD */
3963
    return 1000;
3964
#endif
3965
}
3966

    
3967
static int vm_can_run(void)
3968
{
3969
    if (powerdown_requested)
3970
        return 0;
3971
    if (reset_requested)
3972
        return 0;
3973
    if (shutdown_requested)
3974
        return 0;
3975
    if (debug_requested)
3976
        return 0;
3977
    return 1;
3978
}
3979

    
3980
qemu_irq qemu_system_powerdown;
3981

    
3982
static void main_loop(void)
3983
{
3984
    int r;
3985

    
3986
#ifdef CONFIG_IOTHREAD
3987
    qemu_system_ready = 1;
3988
    qemu_cond_broadcast(&qemu_system_cond);
3989
#endif
3990

    
3991
    for (;;) {
3992
        do {
3993
#ifdef CONFIG_PROFILER
3994
            int64_t ti;
3995
#endif
3996
#ifndef CONFIG_IOTHREAD
3997
            tcg_cpu_exec();
3998
#endif
3999
#ifdef CONFIG_PROFILER
4000
            ti = profile_getclock();
4001
#endif
4002
            main_loop_wait(qemu_calculate_timeout());
4003
#ifdef CONFIG_PROFILER
4004
            dev_time += profile_getclock() - ti;
4005
#endif
4006
        } while (vm_can_run());
4007

    
4008
        if (qemu_debug_requested()) {
4009
            monitor_protocol_event(QEVENT_DEBUG, NULL);
4010
            vm_stop(EXCP_DEBUG);
4011
        }
4012
        if (qemu_shutdown_requested()) {
4013
            monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
4014
            if (no_shutdown) {
4015
                vm_stop(0);
4016
                no_shutdown = 0;
4017
            } else
4018
                break;
4019
        }
4020
        if (qemu_reset_requested()) {
4021
            monitor_protocol_event(QEVENT_RESET, NULL);
4022
            pause_all_vcpus();
4023
            qemu_system_reset();
4024
            resume_all_vcpus();
4025
        }
4026
        if (qemu_powerdown_requested()) {
4027
            monitor_protocol_event(QEVENT_POWERDOWN, NULL);
4028
            qemu_irq_raise(qemu_system_powerdown);
4029
        }
4030
        if ((r = qemu_vmstop_requested())) {
4031
            monitor_protocol_event(QEVENT_STOP, NULL);
4032
            vm_stop(r);
4033
        }
4034
    }
4035
    pause_all_vcpus();
4036
}
4037

    
4038
static void version(void)
4039
{
4040
    printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4041
}
4042

    
4043
static void help(int exitcode)
4044
{
4045
    const char *options_help =
4046
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4047
           opt_help
4048
#define DEFHEADING(text) stringify(text) "\n"
4049
#include "qemu-options.h"
4050
#undef DEF
4051
#undef DEFHEADING
4052
#undef GEN_DOCS
4053
        ;
4054
    version();
4055
    printf("usage: %s [options] [disk_image]\n"
4056
           "\n"
4057
           "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4058
           "\n"
4059
           "%s\n"
4060
           "During emulation, the following keys are useful:\n"
4061
           "ctrl-alt-f      toggle full screen\n"
4062
           "ctrl-alt-n      switch to virtual console 'n'\n"
4063
           "ctrl-alt        toggle mouse and keyboard grab\n"
4064
           "\n"
4065
           "When using -nographic, press 'ctrl-a h' to get some help.\n",
4066
           "qemu",
4067
           options_help);
4068
    exit(exitcode);
4069
}
4070

    
4071
#define HAS_ARG 0x0001
4072

    
4073
enum {
4074
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4075
    opt_enum,
4076
#define DEFHEADING(text)
4077
#include "qemu-options.h"
4078
#undef DEF
4079
#undef DEFHEADING
4080
#undef GEN_DOCS
4081
};
4082

    
4083
typedef struct QEMUOption {
4084
    const char *name;
4085
    int flags;
4086
    int index;
4087
} QEMUOption;
4088

    
4089
static const QEMUOption qemu_options[] = {
4090
    { "h", 0, QEMU_OPTION_h },
4091
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4092
    { option, opt_arg, opt_enum },
4093
#define DEFHEADING(text)
4094
#include "qemu-options.h"
4095
#undef DEF
4096
#undef DEFHEADING
4097
#undef GEN_DOCS
4098
    { NULL },
4099
};
4100

    
4101
#ifdef HAS_AUDIO
4102
struct soundhw soundhw[] = {
4103
#ifdef HAS_AUDIO_CHOICE
4104
#if defined(TARGET_I386) || defined(TARGET_MIPS)
4105
    {
4106
        "pcspk",
4107
        "PC speaker",
4108
        0,
4109
        1,
4110
        { .init_isa = pcspk_audio_init }
4111
    },
4112
#endif
4113

    
4114
#ifdef CONFIG_SB16
4115
    {
4116
        "sb16",
4117
        "Creative Sound Blaster 16",
4118
        0,
4119
        1,
4120
        { .init_isa = SB16_init }
4121
    },
4122
#endif
4123

    
4124
#ifdef CONFIG_CS4231A
4125
    {
4126
        "cs4231a",
4127
        "CS4231A",
4128
        0,
4129
        1,
4130
        { .init_isa = cs4231a_init }
4131
    },
4132
#endif
4133

    
4134
#ifdef CONFIG_ADLIB
4135
    {
4136
        "adlib",
4137
#ifdef HAS_YMF262
4138
        "Yamaha YMF262 (OPL3)",
4139
#else
4140
        "Yamaha YM3812 (OPL2)",
4141
#endif
4142
        0,
4143
        1,
4144
        { .init_isa = Adlib_init }
4145
    },
4146
#endif
4147

    
4148
#ifdef CONFIG_GUS
4149
    {
4150
        "gus",
4151
        "Gravis Ultrasound GF1",
4152
        0,
4153
        1,
4154
        { .init_isa = GUS_init }
4155
    },
4156
#endif
4157

    
4158
#ifdef CONFIG_AC97
4159
    {
4160
        "ac97",
4161
        "Intel 82801AA AC97 Audio",
4162
        0,
4163
        0,
4164
        { .init_pci = ac97_init }
4165
    },
4166
#endif
4167

    
4168
#ifdef CONFIG_ES1370
4169
    {
4170
        "es1370",
4171
        "ENSONIQ AudioPCI ES1370",
4172
        0,
4173
        0,
4174
        { .init_pci = es1370_init }
4175
    },
4176
#endif
4177

    
4178
#endif /* HAS_AUDIO_CHOICE */
4179

    
4180
    { NULL, NULL, 0, 0, { NULL } }
4181
};
4182

    
4183
static void select_soundhw (const char *optarg)
4184
{
4185
    struct soundhw *c;
4186

    
4187
    if (*optarg == '?') {
4188
    show_valid_cards:
4189

    
4190
        printf ("Valid sound card names (comma separated):\n");
4191
        for (c = soundhw; c->name; ++c) {
4192
            printf ("%-11s %s\n", c->name, c->descr);
4193
        }
4194
        printf ("\n-soundhw all will enable all of the above\n");
4195
        exit (*optarg != '?');
4196
    }
4197
    else {
4198
        size_t l;
4199
        const char *p;
4200
        char *e;
4201
        int bad_card = 0;
4202

    
4203
        if (!strcmp (optarg, "all")) {
4204
            for (c = soundhw; c->name; ++c) {
4205
                c->enabled = 1;
4206
            }
4207
            return;
4208
        }
4209

    
4210
        p = optarg;
4211
        while (*p) {
4212
            e = strchr (p, ',');
4213
            l = !e ? strlen (p) : (size_t) (e - p);
4214

    
4215
            for (c = soundhw; c->name; ++c) {
4216
                if (!strncmp (c->name, p, l) && !c->name[l]) {
4217
                    c->enabled = 1;
4218
                    break;
4219
                }
4220
            }
4221

    
4222
            if (!c->name) {
4223
                if (l > 80) {
4224
                    fprintf (stderr,
4225
                             "Unknown sound card name (too big to show)\n");
4226
                }
4227
                else {
4228
                    fprintf (stderr, "Unknown sound card name `%.*s'\n",
4229
                             (int) l, p);
4230
                }
4231
                bad_card = 1;
4232
            }
4233
            p += l + (e != NULL);
4234
        }
4235

    
4236
        if (bad_card)
4237
            goto show_valid_cards;
4238
    }
4239
}
4240
#endif
4241

    
4242
static void select_vgahw (const char *p)
4243
{
4244
    const char *opts;
4245

    
4246
    default_vga = 0;
4247
    vga_interface_type = VGA_NONE;
4248
    if (strstart(p, "std", &opts)) {
4249
        vga_interface_type = VGA_STD;
4250
    } else if (strstart(p, "cirrus", &opts)) {
4251
        vga_interface_type = VGA_CIRRUS;
4252
    } else if (strstart(p, "vmware", &opts)) {
4253
        vga_interface_type = VGA_VMWARE;
4254
    } else if (strstart(p, "xenfb", &opts)) {
4255
        vga_interface_type = VGA_XENFB;
4256
    } else if (!strstart(p, "none", &opts)) {
4257
    invalid_vga:
4258
        fprintf(stderr, "Unknown vga type: %s\n", p);
4259
        exit(1);
4260
    }
4261
    while (*opts) {
4262
        const char *nextopt;
4263

    
4264
        if (strstart(opts, ",retrace=", &nextopt)) {
4265
            opts = nextopt;
4266
            if (strstart(opts, "dumb", &nextopt))
4267
                vga_retrace_method = VGA_RETRACE_DUMB;
4268
            else if (strstart(opts, "precise", &nextopt))
4269
                vga_retrace_method = VGA_RETRACE_PRECISE;
4270
            else goto invalid_vga;
4271
        } else goto invalid_vga;
4272
        opts = nextopt;
4273
    }
4274
}
4275

    
4276
#ifdef TARGET_I386
4277
static int balloon_parse(const char *arg)
4278
{
4279
    QemuOpts *opts;
4280

    
4281
    if (strcmp(arg, "none") == 0) {
4282
        return 0;
4283
    }
4284

    
4285
    if (!strncmp(arg, "virtio", 6)) {
4286
        if (arg[6] == ',') {
4287
            /* have params -> parse them */
4288
            opts = qemu_opts_parse(&qemu_device_opts, arg+7, NULL);
4289
            if (!opts)
4290
                return  -1;
4291
        } else {
4292
            /* create empty opts */
4293
            opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4294
        }
4295
        qemu_opt_set(opts, "driver", "virtio-balloon-pci");
4296
        return 0;
4297
    }
4298

    
4299
    return -1;
4300
}
4301
#endif
4302

    
4303
#ifdef _WIN32
4304
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4305
{
4306
    exit(STATUS_CONTROL_C_EXIT);
4307
    return TRUE;
4308
}
4309
#endif
4310

    
4311
int qemu_uuid_parse(const char *str, uint8_t *uuid)
4312
{
4313
    int ret;
4314

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

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

    
4322
    if(ret != 16)
4323
        return -1;
4324

    
4325
#ifdef TARGET_I386
4326
    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4327
#endif
4328

    
4329
    return 0;
4330
}
4331

    
4332
#ifndef _WIN32
4333

    
4334
static void termsig_handler(int signal)
4335
{
4336
    qemu_system_shutdown_request();
4337
}
4338

    
4339
static void sigchld_handler(int signal)
4340
{
4341
    waitpid(-1, NULL, WNOHANG);
4342
}
4343

    
4344
static void sighandler_setup(void)
4345
{
4346
    struct sigaction act;
4347

    
4348
    memset(&act, 0, sizeof(act));
4349
    act.sa_handler = termsig_handler;
4350
    sigaction(SIGINT,  &act, NULL);
4351
    sigaction(SIGHUP,  &act, NULL);
4352
    sigaction(SIGTERM, &act, NULL);
4353

    
4354
    act.sa_handler = sigchld_handler;
4355
    act.sa_flags = SA_NOCLDSTOP;
4356
    sigaction(SIGCHLD, &act, NULL);
4357
}
4358

    
4359
#endif
4360

    
4361
#ifdef _WIN32
4362
/* Look for support files in the same directory as the executable.  */
4363
static char *find_datadir(const char *argv0)
4364
{
4365
    char *p;
4366
    char buf[MAX_PATH];
4367
    DWORD len;
4368

    
4369
    len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4370
    if (len == 0) {
4371
        return NULL;
4372
    }
4373

    
4374
    buf[len] = 0;
4375
    p = buf + len - 1;
4376
    while (p != buf && *p != '\\')
4377
        p--;
4378
    *p = 0;
4379
    if (access(buf, R_OK) == 0) {
4380
        return qemu_strdup(buf);
4381
    }
4382
    return NULL;
4383
}
4384
#else /* !_WIN32 */
4385

    
4386
/* Find a likely location for support files using the location of the binary.
4387
   For installed binaries this will be "$bindir/../share/qemu".  When
4388
   running from the build tree this will be "$bindir/../pc-bios".  */
4389
#define SHARE_SUFFIX "/share/qemu"
4390
#define BUILD_SUFFIX "/pc-bios"
4391
static char *find_datadir(const char *argv0)
4392
{
4393
    char *dir;
4394
    char *p = NULL;
4395
    char *res;
4396
    char buf[PATH_MAX];
4397
    size_t max_len;
4398

    
4399
#if defined(__linux__)
4400
    {
4401
        int len;
4402
        len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4403
        if (len > 0) {
4404
            buf[len] = 0;
4405
            p = buf;
4406
        }
4407
    }
4408
#elif defined(__FreeBSD__)
4409
    {
4410
        int len;
4411
        len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4412
        if (len > 0) {
4413
            buf[len] = 0;
4414
            p = buf;
4415
        }
4416
    }
4417
#endif
4418
    /* If we don't have any way of figuring out the actual executable
4419
       location then try argv[0].  */
4420
    if (!p) {
4421
        p = realpath(argv0, buf);
4422
        if (!p) {
4423
            return NULL;
4424
        }
4425
    }
4426
    dir = dirname(p);
4427
    dir = dirname(dir);
4428

    
4429
    max_len = strlen(dir) +
4430
        MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4431
    res = qemu_mallocz(max_len);
4432
    snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4433
    if (access(res, R_OK)) {
4434
        snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4435
        if (access(res, R_OK)) {
4436
            qemu_free(res);
4437
            res = NULL;
4438
        }
4439
    }
4440

    
4441
    return res;
4442
}
4443
#undef SHARE_SUFFIX
4444
#undef BUILD_SUFFIX
4445
#endif
4446

    
4447
char *qemu_find_file(int type, const char *name)
4448
{
4449
    int len;
4450
    const char *subdir;
4451
    char *buf;
4452

    
4453
    /* If name contains path separators then try it as a straight path.  */
4454
    if ((strchr(name, '/') || strchr(name, '\\'))
4455
        && access(name, R_OK) == 0) {
4456
        return qemu_strdup(name);
4457
    }
4458
    switch (type) {
4459
    case QEMU_FILE_TYPE_BIOS:
4460
        subdir = "";
4461
        break;
4462
    case QEMU_FILE_TYPE_KEYMAP:
4463
        subdir = "keymaps/";
4464
        break;
4465
    default:
4466
        abort();
4467
    }
4468
    len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4469
    buf = qemu_mallocz(len);
4470
    snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4471
    if (access(buf, R_OK)) {
4472
        qemu_free(buf);
4473
        return NULL;
4474
    }
4475
    return buf;
4476
}
4477

    
4478
static int device_help_func(QemuOpts *opts, void *opaque)
4479
{
4480
    return qdev_device_help(opts);
4481
}
4482

    
4483
static int device_init_func(QemuOpts *opts, void *opaque)
4484
{
4485
    DeviceState *dev;
4486

    
4487
    dev = qdev_device_add(opts);
4488
    if (!dev)
4489
        return -1;
4490
    return 0;
4491
}
4492

    
4493
static int chardev_init_func(QemuOpts *opts, void *opaque)
4494
{
4495
    CharDriverState *chr;
4496

    
4497
    chr = qemu_chr_open_opts(opts, NULL);
4498
    if (!chr)
4499
        return -1;
4500
    return 0;
4501
}
4502

    
4503
static int mon_init_func(QemuOpts *opts, void *opaque)
4504
{
4505
    CharDriverState *chr;
4506
    const char *chardev;
4507
    const char *mode;
4508
    int flags;
4509

    
4510
    mode = qemu_opt_get(opts, "mode");
4511
    if (mode == NULL) {
4512
        mode = "readline";
4513
    }
4514
    if (strcmp(mode, "readline") == 0) {
4515
        flags = MONITOR_USE_READLINE;
4516
    } else if (strcmp(mode, "control") == 0) {
4517
        flags = MONITOR_USE_CONTROL;
4518
    } else {
4519
        fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
4520
        exit(1);
4521
    }
4522

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

    
4526
    chardev = qemu_opt_get(opts, "chardev");
4527
    chr = qemu_chr_find(chardev);
4528
    if (chr == NULL) {
4529
        fprintf(stderr, "chardev \"%s\" not found\n", chardev);
4530
        exit(1);
4531
    }
4532

    
4533
    monitor_init(chr, flags);
4534
    return 0;
4535
}
4536

    
4537
static void monitor_parse(const char *optarg, const char *mode)
4538
{
4539
    static int monitor_device_index = 0;
4540
    QemuOpts *opts;
4541
    const char *p;
4542
    char label[32];
4543
    int def = 0;
4544

    
4545
    if (strstart(optarg, "chardev:", &p)) {
4546
        snprintf(label, sizeof(label), "%s", p);
4547
    } else {
4548
        if (monitor_device_index) {
4549
            snprintf(label, sizeof(label), "monitor%d",
4550
                     monitor_device_index);
4551
        } else {
4552
            snprintf(label, sizeof(label), "monitor");
4553
            def = 1;
4554
        }
4555
        opts = qemu_chr_parse_compat(label, optarg);
4556
        if (!opts) {
4557
            fprintf(stderr, "parse error: %s\n", optarg);
4558
            exit(1);
4559
        }
4560
    }
4561

    
4562
    opts = qemu_opts_create(&qemu_mon_opts, label, 1);
4563
    if (!opts) {
4564
        fprintf(stderr, "duplicate chardev: %s\n", label);
4565
        exit(1);
4566
    }
4567
    qemu_opt_set(opts, "mode", mode);
4568
    qemu_opt_set(opts, "chardev", label);
4569
    if (def)
4570
        qemu_opt_set(opts, "default", "on");
4571
    monitor_device_index++;
4572
}
4573

    
4574
struct device_config {
4575
    enum {
4576
        DEV_USB,       /* -usbdevice     */
4577
        DEV_BT,        /* -bt            */
4578
        DEV_SERIAL,    /* -serial        */
4579
        DEV_PARALLEL,  /* -parallel      */
4580
        DEV_VIRTCON,   /* -virtioconsole */
4581
        DEV_DEBUGCON,  /* -debugcon */
4582
    } type;
4583
    const char *cmdline;
4584
    QTAILQ_ENTRY(device_config) next;
4585
};
4586
QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
4587

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

    
4592
    conf = qemu_mallocz(sizeof(*conf));
4593
    conf->type = type;
4594
    conf->cmdline = cmdline;
4595
    QTAILQ_INSERT_TAIL(&device_configs, conf, next);
4596
}
4597

    
4598
static int foreach_device_config(int type, int (*func)(const char *cmdline))
4599
{
4600
    struct device_config *conf;
4601
    int rc;
4602

    
4603
    QTAILQ_FOREACH(conf, &device_configs, next) {
4604
        if (conf->type != type)
4605
            continue;
4606
        rc = func(conf->cmdline);
4607
        if (0 != rc)
4608
            return rc;
4609
    }
4610
    return 0;
4611
}
4612

    
4613
static int serial_parse(const char *devname)
4614
{
4615
    static int index = 0;
4616
    char label[32];
4617

    
4618
    if (strcmp(devname, "none") == 0)
4619
        return 0;
4620
    if (index == MAX_SERIAL_PORTS) {
4621
        fprintf(stderr, "qemu: too many serial ports\n");
4622
        exit(1);
4623
    }
4624
    snprintf(label, sizeof(label), "serial%d", index);
4625
    serial_hds[index] = qemu_chr_open(label, devname, NULL);
4626
    if (!serial_hds[index]) {
4627
        fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
4628
                devname, strerror(errno));
4629
        return -1;
4630
    }
4631
    index++;
4632
    return 0;
4633
}
4634

    
4635
static int parallel_parse(const char *devname)
4636
{
4637
    static int index = 0;
4638
    char label[32];
4639

    
4640
    if (strcmp(devname, "none") == 0)
4641
        return 0;
4642
    if (index == MAX_PARALLEL_PORTS) {
4643
        fprintf(stderr, "qemu: too many parallel ports\n");
4644
        exit(1);
4645
    }
4646
    snprintf(label, sizeof(label), "parallel%d", index);
4647
    parallel_hds[index] = qemu_chr_open(label, devname, NULL);
4648
    if (!parallel_hds[index]) {
4649
        fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
4650
                devname, strerror(errno));
4651
        return -1;
4652
    }
4653
    index++;
4654
    return 0;
4655
}
4656

    
4657
static int virtcon_parse(const char *devname)
4658
{
4659
    static int index = 0;
4660
    char label[32];
4661
    QemuOpts *bus_opts, *dev_opts;
4662

    
4663
    if (strcmp(devname, "none") == 0)
4664
        return 0;
4665
    if (index == MAX_VIRTIO_CONSOLES) {
4666
        fprintf(stderr, "qemu: too many virtio consoles\n");
4667
        exit(1);
4668
    }
4669

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

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

    
4676
    snprintf(label, sizeof(label), "virtcon%d", index);
4677
    virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
4678
    if (!virtcon_hds[index]) {
4679
        fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
4680
                devname, strerror(errno));
4681
        return -1;
4682
    }
4683
    qemu_opt_set(dev_opts, "chardev", label);
4684

    
4685
    index++;
4686
    return 0;
4687
}
4688

    
4689
static int debugcon_parse(const char *devname)
4690
{   
4691
    QemuOpts *opts;
4692

    
4693
    if (!qemu_chr_open("debugcon", devname, NULL)) {
4694
        exit(1);
4695
    }
4696
    opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
4697
    if (!opts) {
4698
        fprintf(stderr, "qemu: already have a debugcon device\n");
4699
        exit(1);
4700
    }
4701
    qemu_opt_set(opts, "driver", "isa-debugcon");
4702
    qemu_opt_set(opts, "chardev", "debugcon");
4703
    return 0;
4704
}
4705

    
4706
static const QEMUOption *lookup_opt(int argc, char **argv,
4707
                                    const char **poptarg, int *poptind)
4708
{
4709
    const QEMUOption *popt;
4710
    int optind = *poptind;
4711
    char *r = argv[optind];
4712
    const char *optarg;
4713

    
4714
    optind++;
4715
    /* Treat --foo the same as -foo.  */
4716
    if (r[1] == '-')
4717
        r++;
4718
    popt = qemu_options;
4719
    for(;;) {
4720
        if (!popt->name) {
4721
            fprintf(stderr, "%s: invalid option -- '%s'\n",
4722
                    argv[0], r);
4723
            exit(1);
4724
        }
4725
        if (!strcmp(popt->name, r + 1))
4726
            break;
4727
        popt++;
4728
    }
4729
    if (popt->flags & HAS_ARG) {
4730
        if (optind >= argc) {
4731
            fprintf(stderr, "%s: option '%s' requires an argument\n",
4732
                    argv[0], r);
4733
            exit(1);
4734
        }
4735
        optarg = argv[optind++];
4736
    } else {
4737
        optarg = NULL;
4738
    }
4739

    
4740
    *poptarg = optarg;
4741
    *poptind = optind;
4742

    
4743
    return popt;
4744
}
4745

    
4746
int main(int argc, char **argv, char **envp)
4747
{
4748
    const char *gdbstub_dev = NULL;
4749
    uint32_t boot_devices_bitmap = 0;
4750
    int i;
4751
    int snapshot, linux_boot, net_boot;
4752
    const char *initrd_filename;
4753
    const char *kernel_filename, *kernel_cmdline;
4754
    char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4755
    DisplayState *ds;
4756
    DisplayChangeListener *dcl;
4757
    int cyls, heads, secs, translation;
4758
    QemuOpts *hda_opts = NULL, *opts;
4759
    int optind;
4760
    const char *optarg;
4761
    const char *loadvm = NULL;
4762
    QEMUMachine *machine;
4763
    const char *cpu_model;
4764
#ifndef _WIN32
4765
    int fds[2];
4766
#endif
4767
    int tb_size;
4768
    const char *pid_file = NULL;
4769
    const char *incoming = NULL;
4770
#ifndef _WIN32
4771
    int fd = 0;
4772
    struct passwd *pwd = NULL;
4773
    const char *chroot_dir = NULL;
4774
    const char *run_as = NULL;
4775
#endif
4776
    CPUState *env;
4777
    int show_vnc_port = 0;
4778
    int defconfig = 1;
4779

    
4780
    init_clocks();
4781

    
4782
    qemu_errors_to_file(stderr);
4783
    qemu_cache_utils_init(envp);
4784

    
4785
    QLIST_INIT (&vm_change_state_head);
4786
#ifndef _WIN32
4787
    {
4788
        struct sigaction act;
4789
        sigfillset(&act.sa_mask);
4790
        act.sa_flags = 0;
4791
        act.sa_handler = SIG_IGN;
4792
        sigaction(SIGPIPE, &act, NULL);
4793
    }
4794
#else
4795
    SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4796
    /* Note: cpu_interrupt() is currently not SMP safe, so we force
4797
       QEMU to run on a single CPU */
4798
    {
4799
        HANDLE h;
4800
        DWORD mask, smask;
4801
        int i;
4802
        h = GetCurrentProcess();
4803
        if (GetProcessAffinityMask(h, &mask, &smask)) {
4804
            for(i = 0; i < 32; i++) {
4805
                if (mask & (1 << i))
4806
                    break;
4807
            }
4808
            if (i != 32) {
4809
                mask = 1 << i;
4810
                SetProcessAffinityMask(h, mask);
4811
            }
4812
        }
4813
    }
4814
#endif
4815

    
4816
    module_call_init(MODULE_INIT_MACHINE);
4817
    machine = find_default_machine();
4818
    cpu_model = NULL;
4819
    initrd_filename = NULL;
4820
    ram_size = 0;
4821
    snapshot = 0;
4822
    kernel_filename = NULL;
4823
    kernel_cmdline = "";
4824
    cyls = heads = secs = 0;
4825
    translation = BIOS_ATA_TRANSLATION_AUTO;
4826

    
4827
    for (i = 0; i < MAX_NODES; i++) {
4828
        node_mem[i] = 0;
4829
        node_cpumask[i] = 0;
4830
    }
4831

    
4832
    nb_numa_nodes = 0;
4833
    nb_nics = 0;
4834

    
4835
    tb_size = 0;
4836
    autostart= 1;
4837

    
4838
    /* first pass of option parsing */
4839
    optind = 1;
4840
    while (optind < argc) {
4841
        if (argv[optind][0] != '-') {
4842
            /* disk image */
4843
            optind++;
4844
            continue;
4845
        } else {
4846
            const QEMUOption *popt;
4847

    
4848
            popt = lookup_opt(argc, argv, &optarg, &optind);
4849
            switch (popt->index) {
4850
            case QEMU_OPTION_nodefconfig:
4851
                defconfig=0;
4852
                break;
4853
            }
4854
        }
4855
    }
4856

    
4857
    if (defconfig) {
4858
        FILE *fp;
4859
        fp = fopen(CONFIG_QEMU_CONFDIR "/qemu.conf", "r");
4860
        if (fp) {
4861
            if (qemu_config_parse(fp) != 0) {
4862
                exit(1);
4863
            }
4864
            fclose(fp);
4865
        }
4866

    
4867
        fp = fopen(CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", "r");
4868
        if (fp) {
4869
            if (qemu_config_parse(fp) != 0) {
4870
                exit(1);
4871
            }
4872
            fclose(fp);
4873
        }
4874
    }
4875

    
4876
    /* second pass of option parsing */
4877
    optind = 1;
4878
    for(;;) {
4879
        if (optind >= argc)
4880
            break;
4881
        if (argv[optind][0] != '-') {
4882
            hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
4883
        } else {
4884
            const QEMUOption *popt;
4885

    
4886
            popt = lookup_opt(argc, argv, &optarg, &optind);
4887
            switch(popt->index) {
4888
            case QEMU_OPTION_M:
4889
                machine = find_machine(optarg);
4890
                if (!machine) {
4891
                    QEMUMachine *m;
4892
                    printf("Supported machines are:\n");
4893
                    for(m = first_machine; m != NULL; m = m->next) {
4894
                        if (m->alias)
4895
                            printf("%-10s %s (alias of %s)\n",
4896
                                   m->alias, m->desc, m->name);
4897
                        printf("%-10s %s%s\n",
4898
                               m->name, m->desc,
4899
                               m->is_default ? " (default)" : "");
4900
                    }
4901
                    exit(*optarg != '?');
4902
                }
4903
                break;
4904
            case QEMU_OPTION_cpu:
4905
                /* hw initialization will check this */
4906
                if (*optarg == '?') {
4907
/* XXX: implement xxx_cpu_list for targets that still miss it */
4908
#if defined(cpu_list)
4909
                    cpu_list(stdout, &fprintf);
4910
#endif
4911
                    exit(0);
4912
                } else {
4913
                    cpu_model = optarg;
4914
                }
4915
                break;
4916
            case QEMU_OPTION_initrd:
4917
                initrd_filename = optarg;
4918
                break;
4919
            case QEMU_OPTION_hda:
4920
                if (cyls == 0)
4921
                    hda_opts = drive_add(optarg, HD_ALIAS, 0);
4922
                else
4923
                    hda_opts = drive_add(optarg, HD_ALIAS
4924
                             ",cyls=%d,heads=%d,secs=%d%s",
4925
                             0, cyls, heads, secs,
4926
                             translation == BIOS_ATA_TRANSLATION_LBA ?
4927
                                 ",trans=lba" :
4928
                             translation == BIOS_ATA_TRANSLATION_NONE ?
4929
                                 ",trans=none" : "");
4930
                 break;
4931
            case QEMU_OPTION_hdb:
4932
            case QEMU_OPTION_hdc:
4933
            case QEMU_OPTION_hdd:
4934
                drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4935
                break;
4936
            case QEMU_OPTION_drive:
4937
                drive_add(NULL, "%s", optarg);
4938
                break;
4939
            case QEMU_OPTION_set:
4940
                if (qemu_set_option(optarg) != 0)
4941
                    exit(1);
4942
                break;
4943
            case QEMU_OPTION_global:
4944
                if (qemu_global_option(optarg) != 0)
4945
                    exit(1);
4946
                break;
4947
            case QEMU_OPTION_mtdblock:
4948
                drive_add(optarg, MTD_ALIAS);
4949
                break;
4950
            case QEMU_OPTION_sd:
4951
                drive_add(optarg, SD_ALIAS);
4952
                break;
4953
            case QEMU_OPTION_pflash: