Statistics
| Branch: | Revision:

root / vl.c @ b0a46a33

History | View | Annotate | Download (154.5 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 HOST_BSD etc. */
33
#include "config-host.h"
34

    
35
#ifndef _WIN32
36
#include <pwd.h>
37
#include <sys/times.h>
38
#include <sys/wait.h>
39
#include <termios.h>
40
#include <sys/mman.h>
41
#include <sys/ioctl.h>
42
#include <sys/resource.h>
43
#include <sys/socket.h>
44
#include <netinet/in.h>
45
#include <net/if.h>
46
#if defined(__NetBSD__)
47
#include <net/if_tap.h>
48
#endif
49
#ifdef __linux__
50
#include <linux/if_tun.h>
51
#endif
52
#include <arpa/inet.h>
53
#include <dirent.h>
54
#include <netdb.h>
55
#include <sys/select.h>
56
#ifdef HOST_BSD
57
#include <sys/stat.h>
58
#if defined(__FreeBSD__) || defined(__DragonFly__)
59
#include <libutil.h>
60
#else
61
#include <util.h>
62
#endif
63
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
64
#include <freebsd/stdlib.h>
65
#else
66
#ifdef __linux__
67
#include <pty.h>
68
#include <malloc.h>
69
#include <linux/rtc.h>
70

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

    
76
#include <linux/ppdev.h>
77
#include <linux/parport.h>
78
#endif
79
#ifdef __sun__
80
#include <sys/stat.h>
81
#include <sys/ethernet.h>
82
#include <sys/sockio.h>
83
#include <netinet/arp.h>
84
#include <netinet/in.h>
85
#include <netinet/in_systm.h>
86
#include <netinet/ip.h>
87
#include <netinet/ip_icmp.h> // must come after ip.h
88
#include <netinet/udp.h>
89
#include <netinet/tcp.h>
90
#include <net/if.h>
91
#include <syslog.h>
92
#include <stropts.h>
93
#endif
94
#endif
95
#endif
96

    
97
#if defined(__OpenBSD__)
98
#include <util.h>
99
#endif
100

    
101
#if defined(CONFIG_VDE)
102
#include <libvdeplug.h>
103
#endif
104

    
105
#ifdef _WIN32
106
#include <windows.h>
107
#include <malloc.h>
108
#include <sys/timeb.h>
109
#include <mmsystem.h>
110
#define getopt_long_only getopt_long
111
#define memalign(align, size) malloc(size)
112
#endif
113

    
114
#ifdef CONFIG_SDL
115
#ifdef __APPLE__
116
#include <SDL/SDL.h>
117
int qemu_main(int argc, char **argv, char **envp);
118
int main(int argc, char **argv)
119
{
120
    qemu_main(argc, argv, NULL);
121
}
122
#undef main
123
#define main qemu_main
124
#endif
125
#endif /* CONFIG_SDL */
126

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

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

    
161
#include "disas.h"
162

    
163
#include "exec-all.h"
164

    
165
#include "qemu_socket.h"
166

    
167
#if defined(CONFIG_SLIRP)
168
#include "libslirp.h"
169
#endif
170

    
171
//#define DEBUG_UNUSED_IOPORT
172
//#define DEBUG_IOPORT
173
//#define DEBUG_NET
174
//#define DEBUG_SLIRP
175

    
176

    
177
#ifdef DEBUG_IOPORT
178
#  define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
179
#else
180
#  define LOG_IOPORT(...) do { } while (0)
181
#endif
182

    
183
#define DEFAULT_RAM_SIZE 128
184

    
185
/* Max number of USB devices that can be specified on the commandline.  */
186
#define MAX_USB_CMDLINE 8
187

    
188
/* Max number of bluetooth switches on the commandline.  */
189
#define MAX_BT_CMDLINE 10
190

    
191
/* XXX: use a two level table to limit memory usage */
192
#define MAX_IOPORTS 65536
193

    
194
const char *bios_dir = CONFIG_QEMU_SHAREDIR;
195
const char *bios_name = NULL;
196
static void *ioport_opaque[MAX_IOPORTS];
197
static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
198
static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
199
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
200
   to store the VM snapshots */
201
DriveInfo drives_table[MAX_DRIVES+1];
202
int nb_drives;
203
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
204
static DisplayState *display_state;
205
DisplayType display_type = DT_DEFAULT;
206
const char* keyboard_layout = NULL;
207
int64_t ticks_per_sec;
208
ram_addr_t ram_size;
209
int nb_nics;
210
NICInfo nd_table[MAX_NICS];
211
int vm_running;
212
static int autostart;
213
static int rtc_utc = 1;
214
static int rtc_date_offset = -1; /* -1 means no change */
215
int cirrus_vga_enabled = 1;
216
int std_vga_enabled = 0;
217
int vmsvga_enabled = 0;
218
int xenfb_enabled = 0;
219
#ifdef TARGET_SPARC
220
int graphic_width = 1024;
221
int graphic_height = 768;
222
int graphic_depth = 8;
223
#else
224
int graphic_width = 800;
225
int graphic_height = 600;
226
int graphic_depth = 15;
227
#endif
228
static int full_screen = 0;
229
#ifdef CONFIG_SDL
230
static int no_frame = 0;
231
#endif
232
int no_quit = 0;
233
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
234
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
235
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
236
#ifdef TARGET_I386
237
int win2k_install_hack = 0;
238
int rtc_td_hack = 0;
239
#endif
240
int usb_enabled = 0;
241
int singlestep = 0;
242
int smp_cpus = 1;
243
const char *vnc_display;
244
int acpi_enabled = 1;
245
int no_hpet = 0;
246
int fd_bootchk = 1;
247
int no_reboot = 0;
248
int no_shutdown = 0;
249
int cursor_hide = 1;
250
int graphic_rotate = 0;
251
#ifndef _WIN32
252
int daemonize = 0;
253
#endif
254
WatchdogTimerModel *watchdog = NULL;
255
int watchdog_action = WDT_RESET;
256
const char *option_rom[MAX_OPTION_ROMS];
257
int nb_option_roms;
258
int semihosting_enabled = 0;
259
#ifdef TARGET_ARM
260
int old_param = 0;
261
#endif
262
const char *qemu_name;
263
int alt_grab = 0;
264
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
265
unsigned int nb_prom_envs = 0;
266
const char *prom_envs[MAX_PROM_ENVS];
267
#endif
268
int nb_drives_opt;
269
struct drive_opt drives_opt[MAX_DRIVES];
270

    
271
int nb_numa_nodes;
272
uint64_t node_mem[MAX_NODES];
273
uint64_t node_cpumask[MAX_NODES];
274

    
275
static CPUState *cur_cpu;
276
static CPUState *next_cpu;
277
static int timer_alarm_pending = 1;
278
/* Conversion factor from emulated instructions to virtual clock ticks.  */
279
static int icount_time_shift;
280
/* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
281
#define MAX_ICOUNT_SHIFT 10
282
/* Compensate for varying guest execution speed.  */
283
static int64_t qemu_icount_bias;
284
static QEMUTimer *icount_rt_timer;
285
static QEMUTimer *icount_vm_timer;
286
static QEMUTimer *nographic_timer;
287

    
288
uint8_t qemu_uuid[16];
289

    
290
/***********************************************************/
291
/* x86 ISA bus support */
292

    
293
target_phys_addr_t isa_mem_base = 0;
294
PicState2 *isa_pic;
295

    
296
static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
297
static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
298

    
299
static uint32_t ioport_read(int index, uint32_t address)
300
{
301
    static IOPortReadFunc *default_func[3] = {
302
        default_ioport_readb,
303
        default_ioport_readw,
304
        default_ioport_readl
305
    };
306
    IOPortReadFunc *func = ioport_read_table[index][address];
307
    if (!func)
308
        func = default_func[index];
309
    return func(ioport_opaque[address], address);
310
}
311

    
312
static void ioport_write(int index, uint32_t address, uint32_t data)
313
{
314
    static IOPortWriteFunc *default_func[3] = {
315
        default_ioport_writeb,
316
        default_ioport_writew,
317
        default_ioport_writel
318
    };
319
    IOPortWriteFunc *func = ioport_write_table[index][address];
320
    if (!func)
321
        func = default_func[index];
322
    func(ioport_opaque[address], address, data);
323
}
324

    
325
static uint32_t default_ioport_readb(void *opaque, uint32_t address)
326
{
327
#ifdef DEBUG_UNUSED_IOPORT
328
    fprintf(stderr, "unused inb: port=0x%04x\n", address);
329
#endif
330
    return 0xff;
331
}
332

    
333
static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
334
{
335
#ifdef DEBUG_UNUSED_IOPORT
336
    fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
337
#endif
338
}
339

    
340
/* default is to make two byte accesses */
341
static uint32_t default_ioport_readw(void *opaque, uint32_t address)
342
{
343
    uint32_t data;
344
    data = ioport_read(0, address);
345
    address = (address + 1) & (MAX_IOPORTS - 1);
346
    data |= ioport_read(0, address) << 8;
347
    return data;
348
}
349

    
350
static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
351
{
352
    ioport_write(0, address, data & 0xff);
353
    address = (address + 1) & (MAX_IOPORTS - 1);
354
    ioport_write(0, address, (data >> 8) & 0xff);
355
}
356

    
357
static uint32_t default_ioport_readl(void *opaque, uint32_t address)
358
{
359
#ifdef DEBUG_UNUSED_IOPORT
360
    fprintf(stderr, "unused inl: port=0x%04x\n", address);
361
#endif
362
    return 0xffffffff;
363
}
364

    
365
static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
366
{
367
#ifdef DEBUG_UNUSED_IOPORT
368
    fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
369
#endif
370
}
371

    
372
/* size is the word size in byte */
373
int register_ioport_read(int start, int length, int size,
374
                         IOPortReadFunc *func, void *opaque)
375
{
376
    int i, bsize;
377

    
378
    if (size == 1) {
379
        bsize = 0;
380
    } else if (size == 2) {
381
        bsize = 1;
382
    } else if (size == 4) {
383
        bsize = 2;
384
    } else {
385
        hw_error("register_ioport_read: invalid size");
386
        return -1;
387
    }
388
    for(i = start; i < start + length; i += size) {
389
        ioport_read_table[bsize][i] = func;
390
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
391
            hw_error("register_ioport_read: invalid opaque");
392
        ioport_opaque[i] = opaque;
393
    }
394
    return 0;
395
}
396

    
397
/* size is the word size in byte */
398
int register_ioport_write(int start, int length, int size,
399
                          IOPortWriteFunc *func, void *opaque)
400
{
401
    int i, bsize;
402

    
403
    if (size == 1) {
404
        bsize = 0;
405
    } else if (size == 2) {
406
        bsize = 1;
407
    } else if (size == 4) {
408
        bsize = 2;
409
    } else {
410
        hw_error("register_ioport_write: invalid size");
411
        return -1;
412
    }
413
    for(i = start; i < start + length; i += size) {
414
        ioport_write_table[bsize][i] = func;
415
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
416
            hw_error("register_ioport_write: invalid opaque");
417
        ioport_opaque[i] = opaque;
418
    }
419
    return 0;
420
}
421

    
422
void isa_unassign_ioport(int start, int length)
423
{
424
    int i;
425

    
426
    for(i = start; i < start + length; i++) {
427
        ioport_read_table[0][i] = default_ioport_readb;
428
        ioport_read_table[1][i] = default_ioport_readw;
429
        ioport_read_table[2][i] = default_ioport_readl;
430

    
431
        ioport_write_table[0][i] = default_ioport_writeb;
432
        ioport_write_table[1][i] = default_ioport_writew;
433
        ioport_write_table[2][i] = default_ioport_writel;
434

    
435
        ioport_opaque[i] = NULL;
436
    }
437
}
438

    
439
/***********************************************************/
440

    
441
void cpu_outb(CPUState *env, int addr, int val)
442
{
443
    LOG_IOPORT("outb: %04x %02x\n", addr, val);
444
    ioport_write(0, addr, val);
445
#ifdef CONFIG_KQEMU
446
    if (env)
447
        env->last_io_time = cpu_get_time_fast();
448
#endif
449
}
450

    
451
void cpu_outw(CPUState *env, int addr, int val)
452
{
453
    LOG_IOPORT("outw: %04x %04x\n", addr, val);
454
    ioport_write(1, addr, val);
455
#ifdef CONFIG_KQEMU
456
    if (env)
457
        env->last_io_time = cpu_get_time_fast();
458
#endif
459
}
460

    
461
void cpu_outl(CPUState *env, int addr, int val)
462
{
463
    LOG_IOPORT("outl: %04x %08x\n", addr, val);
464
    ioport_write(2, addr, val);
465
#ifdef CONFIG_KQEMU
466
    if (env)
467
        env->last_io_time = cpu_get_time_fast();
468
#endif
469
}
470

    
471
int cpu_inb(CPUState *env, int addr)
472
{
473
    int val;
474
    val = ioport_read(0, addr);
475
    LOG_IOPORT("inb : %04x %02x\n", addr, val);
476
#ifdef CONFIG_KQEMU
477
    if (env)
478
        env->last_io_time = cpu_get_time_fast();
479
#endif
480
    return val;
481
}
482

    
483
int cpu_inw(CPUState *env, int addr)
484
{
485
    int val;
486
    val = ioport_read(1, addr);
487
    LOG_IOPORT("inw : %04x %04x\n", addr, val);
488
#ifdef CONFIG_KQEMU
489
    if (env)
490
        env->last_io_time = cpu_get_time_fast();
491
#endif
492
    return val;
493
}
494

    
495
int cpu_inl(CPUState *env, int addr)
496
{
497
    int val;
498
    val = ioport_read(2, addr);
499
    LOG_IOPORT("inl : %04x %08x\n", addr, val);
500
#ifdef CONFIG_KQEMU
501
    if (env)
502
        env->last_io_time = cpu_get_time_fast();
503
#endif
504
    return val;
505
}
506

    
507
/***********************************************************/
508
void hw_error(const char *fmt, ...)
509
{
510
    va_list ap;
511
    CPUState *env;
512

    
513
    va_start(ap, fmt);
514
    fprintf(stderr, "qemu: hardware error: ");
515
    vfprintf(stderr, fmt, ap);
516
    fprintf(stderr, "\n");
517
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
518
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
519
#ifdef TARGET_I386
520
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
521
#else
522
        cpu_dump_state(env, stderr, fprintf, 0);
523
#endif
524
    }
525
    va_end(ap);
526
    abort();
527
}
528
 
529
/***************/
530
/* ballooning */
531

    
532
static QEMUBalloonEvent *qemu_balloon_event;
533
void *qemu_balloon_event_opaque;
534

    
535
void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
536
{
537
    qemu_balloon_event = func;
538
    qemu_balloon_event_opaque = opaque;
539
}
540

    
541
void qemu_balloon(ram_addr_t target)
542
{
543
    if (qemu_balloon_event)
544
        qemu_balloon_event(qemu_balloon_event_opaque, target);
545
}
546

    
547
ram_addr_t qemu_balloon_status(void)
548
{
549
    if (qemu_balloon_event)
550
        return qemu_balloon_event(qemu_balloon_event_opaque, 0);
551
    return 0;
552
}
553

    
554
/***********************************************************/
555
/* keyboard/mouse */
556

    
557
static QEMUPutKBDEvent *qemu_put_kbd_event;
558
static void *qemu_put_kbd_event_opaque;
559
static QEMUPutMouseEntry *qemu_put_mouse_event_head;
560
static QEMUPutMouseEntry *qemu_put_mouse_event_current;
561

    
562
void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
563
{
564
    qemu_put_kbd_event_opaque = opaque;
565
    qemu_put_kbd_event = func;
566
}
567

    
568
QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
569
                                                void *opaque, int absolute,
570
                                                const char *name)
571
{
572
    QEMUPutMouseEntry *s, *cursor;
573

    
574
    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
575

    
576
    s->qemu_put_mouse_event = func;
577
    s->qemu_put_mouse_event_opaque = opaque;
578
    s->qemu_put_mouse_event_absolute = absolute;
579
    s->qemu_put_mouse_event_name = qemu_strdup(name);
580
    s->next = NULL;
581

    
582
    if (!qemu_put_mouse_event_head) {
583
        qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
584
        return s;
585
    }
586

    
587
    cursor = qemu_put_mouse_event_head;
588
    while (cursor->next != NULL)
589
        cursor = cursor->next;
590

    
591
    cursor->next = s;
592
    qemu_put_mouse_event_current = s;
593

    
594
    return s;
595
}
596

    
597
void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
598
{
599
    QEMUPutMouseEntry *prev = NULL, *cursor;
600

    
601
    if (!qemu_put_mouse_event_head || entry == NULL)
602
        return;
603

    
604
    cursor = qemu_put_mouse_event_head;
605
    while (cursor != NULL && cursor != entry) {
606
        prev = cursor;
607
        cursor = cursor->next;
608
    }
609

    
610
    if (cursor == NULL) // does not exist or list empty
611
        return;
612
    else if (prev == NULL) { // entry is head
613
        qemu_put_mouse_event_head = cursor->next;
614
        if (qemu_put_mouse_event_current == entry)
615
            qemu_put_mouse_event_current = cursor->next;
616
        qemu_free(entry->qemu_put_mouse_event_name);
617
        qemu_free(entry);
618
        return;
619
    }
620

    
621
    prev->next = entry->next;
622

    
623
    if (qemu_put_mouse_event_current == entry)
624
        qemu_put_mouse_event_current = prev;
625

    
626
    qemu_free(entry->qemu_put_mouse_event_name);
627
    qemu_free(entry);
628
}
629

    
630
void kbd_put_keycode(int keycode)
631
{
632
    if (qemu_put_kbd_event) {
633
        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
634
    }
635
}
636

    
637
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
638
{
639
    QEMUPutMouseEvent *mouse_event;
640
    void *mouse_event_opaque;
641
    int width;
642

    
643
    if (!qemu_put_mouse_event_current) {
644
        return;
645
    }
646

    
647
    mouse_event =
648
        qemu_put_mouse_event_current->qemu_put_mouse_event;
649
    mouse_event_opaque =
650
        qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
651

    
652
    if (mouse_event) {
653
        if (graphic_rotate) {
654
            if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
655
                width = 0x7fff;
656
            else
657
                width = graphic_width - 1;
658
            mouse_event(mouse_event_opaque,
659
                                 width - dy, dx, dz, buttons_state);
660
        } else
661
            mouse_event(mouse_event_opaque,
662
                                 dx, dy, dz, buttons_state);
663
    }
664
}
665

    
666
int kbd_mouse_is_absolute(void)
667
{
668
    if (!qemu_put_mouse_event_current)
669
        return 0;
670

    
671
    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
672
}
673

    
674
void do_info_mice(Monitor *mon)
675
{
676
    QEMUPutMouseEntry *cursor;
677
    int index = 0;
678

    
679
    if (!qemu_put_mouse_event_head) {
680
        monitor_printf(mon, "No mouse devices connected\n");
681
        return;
682
    }
683

    
684
    monitor_printf(mon, "Mouse devices available:\n");
685
    cursor = qemu_put_mouse_event_head;
686
    while (cursor != NULL) {
687
        monitor_printf(mon, "%c Mouse #%d: %s\n",
688
                       (cursor == qemu_put_mouse_event_current ? '*' : ' '),
689
                       index, cursor->qemu_put_mouse_event_name);
690
        index++;
691
        cursor = cursor->next;
692
    }
693
}
694

    
695
void do_mouse_set(Monitor *mon, int index)
696
{
697
    QEMUPutMouseEntry *cursor;
698
    int i = 0;
699

    
700
    if (!qemu_put_mouse_event_head) {
701
        monitor_printf(mon, "No mouse devices connected\n");
702
        return;
703
    }
704

    
705
    cursor = qemu_put_mouse_event_head;
706
    while (cursor != NULL && index != i) {
707
        i++;
708
        cursor = cursor->next;
709
    }
710

    
711
    if (cursor != NULL)
712
        qemu_put_mouse_event_current = cursor;
713
    else
714
        monitor_printf(mon, "Mouse at given index not found\n");
715
}
716

    
717
/* compute with 96 bit intermediate result: (a*b)/c */
718
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
719
{
720
    union {
721
        uint64_t ll;
722
        struct {
723
#ifdef WORDS_BIGENDIAN
724
            uint32_t high, low;
725
#else
726
            uint32_t low, high;
727
#endif
728
        } l;
729
    } u, res;
730
    uint64_t rl, rh;
731

    
732
    u.ll = a;
733
    rl = (uint64_t)u.l.low * (uint64_t)b;
734
    rh = (uint64_t)u.l.high * (uint64_t)b;
735
    rh += (rl >> 32);
736
    res.l.high = rh / c;
737
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
738
    return res.ll;
739
}
740

    
741
/***********************************************************/
742
/* real time host monotonic timer */
743

    
744
#define QEMU_TIMER_BASE 1000000000LL
745

    
746
#ifdef WIN32
747

    
748
static int64_t clock_freq;
749

    
750
static void init_get_clock(void)
751
{
752
    LARGE_INTEGER freq;
753
    int ret;
754
    ret = QueryPerformanceFrequency(&freq);
755
    if (ret == 0) {
756
        fprintf(stderr, "Could not calibrate ticks\n");
757
        exit(1);
758
    }
759
    clock_freq = freq.QuadPart;
760
}
761

    
762
static int64_t get_clock(void)
763
{
764
    LARGE_INTEGER ti;
765
    QueryPerformanceCounter(&ti);
766
    return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
767
}
768

    
769
#else
770

    
771
static int use_rt_clock;
772

    
773
static void init_get_clock(void)
774
{
775
    use_rt_clock = 0;
776
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
777
    || defined(__DragonFly__)
778
    {
779
        struct timespec ts;
780
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
781
            use_rt_clock = 1;
782
        }
783
    }
784
#endif
785
}
786

    
787
static int64_t get_clock(void)
788
{
789
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
790
        || defined(__DragonFly__)
791
    if (use_rt_clock) {
792
        struct timespec ts;
793
        clock_gettime(CLOCK_MONOTONIC, &ts);
794
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
795
    } else
796
#endif
797
    {
798
        /* XXX: using gettimeofday leads to problems if the date
799
           changes, so it should be avoided. */
800
        struct timeval tv;
801
        gettimeofday(&tv, NULL);
802
        return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
803
    }
804
}
805
#endif
806

    
807
/* Return the virtual CPU time, based on the instruction counter.  */
808
static int64_t cpu_get_icount(void)
809
{
810
    int64_t icount;
811
    CPUState *env = cpu_single_env;;
812
    icount = qemu_icount;
813
    if (env) {
814
        if (!can_do_io(env))
815
            fprintf(stderr, "Bad clock read\n");
816
        icount -= (env->icount_decr.u16.low + env->icount_extra);
817
    }
818
    return qemu_icount_bias + (icount << icount_time_shift);
819
}
820

    
821
/***********************************************************/
822
/* guest cycle counter */
823

    
824
static int64_t cpu_ticks_prev;
825
static int64_t cpu_ticks_offset;
826
static int64_t cpu_clock_offset;
827
static int cpu_ticks_enabled;
828

    
829
/* return the host CPU cycle counter and handle stop/restart */
830
int64_t cpu_get_ticks(void)
831
{
832
    if (use_icount) {
833
        return cpu_get_icount();
834
    }
835
    if (!cpu_ticks_enabled) {
836
        return cpu_ticks_offset;
837
    } else {
838
        int64_t ticks;
839
        ticks = cpu_get_real_ticks();
840
        if (cpu_ticks_prev > ticks) {
841
            /* Note: non increasing ticks may happen if the host uses
842
               software suspend */
843
            cpu_ticks_offset += cpu_ticks_prev - ticks;
844
        }
845
        cpu_ticks_prev = ticks;
846
        return ticks + cpu_ticks_offset;
847
    }
848
}
849

    
850
/* return the host CPU monotonic timer and handle stop/restart */
851
static int64_t cpu_get_clock(void)
852
{
853
    int64_t ti;
854
    if (!cpu_ticks_enabled) {
855
        return cpu_clock_offset;
856
    } else {
857
        ti = get_clock();
858
        return ti + cpu_clock_offset;
859
    }
860
}
861

    
862
/* enable cpu_get_ticks() */
863
void cpu_enable_ticks(void)
864
{
865
    if (!cpu_ticks_enabled) {
866
        cpu_ticks_offset -= cpu_get_real_ticks();
867
        cpu_clock_offset -= get_clock();
868
        cpu_ticks_enabled = 1;
869
    }
870
}
871

    
872
/* disable cpu_get_ticks() : the clock is stopped. You must not call
873
   cpu_get_ticks() after that.  */
874
void cpu_disable_ticks(void)
875
{
876
    if (cpu_ticks_enabled) {
877
        cpu_ticks_offset = cpu_get_ticks();
878
        cpu_clock_offset = cpu_get_clock();
879
        cpu_ticks_enabled = 0;
880
    }
881
}
882

    
883
/***********************************************************/
884
/* timers */
885

    
886
#define QEMU_TIMER_REALTIME 0
887
#define QEMU_TIMER_VIRTUAL  1
888

    
889
struct QEMUClock {
890
    int type;
891
    /* XXX: add frequency */
892
};
893

    
894
struct QEMUTimer {
895
    QEMUClock *clock;
896
    int64_t expire_time;
897
    QEMUTimerCB *cb;
898
    void *opaque;
899
    struct QEMUTimer *next;
900
};
901

    
902
struct qemu_alarm_timer {
903
    char const *name;
904
    unsigned int flags;
905

    
906
    int (*start)(struct qemu_alarm_timer *t);
907
    void (*stop)(struct qemu_alarm_timer *t);
908
    void (*rearm)(struct qemu_alarm_timer *t);
909
    void *priv;
910
};
911

    
912
#define ALARM_FLAG_DYNTICKS  0x1
913
#define ALARM_FLAG_EXPIRED   0x2
914

    
915
static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
916
{
917
    return t && (t->flags & ALARM_FLAG_DYNTICKS);
918
}
919

    
920
static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
921
{
922
    if (!alarm_has_dynticks(t))
923
        return;
924

    
925
    t->rearm(t);
926
}
927

    
928
/* TODO: MIN_TIMER_REARM_US should be optimized */
929
#define MIN_TIMER_REARM_US 250
930

    
931
static struct qemu_alarm_timer *alarm_timer;
932

    
933
#ifdef _WIN32
934

    
935
struct qemu_alarm_win32 {
936
    MMRESULT timerId;
937
    unsigned int period;
938
} alarm_win32_data = {0, -1};
939

    
940
static int win32_start_timer(struct qemu_alarm_timer *t);
941
static void win32_stop_timer(struct qemu_alarm_timer *t);
942
static void win32_rearm_timer(struct qemu_alarm_timer *t);
943

    
944
#else
945

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

    
949
#ifdef __linux__
950

    
951
static int dynticks_start_timer(struct qemu_alarm_timer *t);
952
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
953
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
954

    
955
static int hpet_start_timer(struct qemu_alarm_timer *t);
956
static void hpet_stop_timer(struct qemu_alarm_timer *t);
957

    
958
static int rtc_start_timer(struct qemu_alarm_timer *t);
959
static void rtc_stop_timer(struct qemu_alarm_timer *t);
960

    
961
#endif /* __linux__ */
962

    
963
#endif /* _WIN32 */
964

    
965
/* Correlation between real and virtual time is always going to be
966
   fairly approximate, so ignore small variation.
967
   When the guest is idle real and virtual time will be aligned in
968
   the IO wait loop.  */
969
#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
970

    
971
static void icount_adjust(void)
972
{
973
    int64_t cur_time;
974
    int64_t cur_icount;
975
    int64_t delta;
976
    static int64_t last_delta;
977
    /* If the VM is not running, then do nothing.  */
978
    if (!vm_running)
979
        return;
980

    
981
    cur_time = cpu_get_clock();
982
    cur_icount = qemu_get_clock(vm_clock);
983
    delta = cur_icount - cur_time;
984
    /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
985
    if (delta > 0
986
        && last_delta + ICOUNT_WOBBLE < delta * 2
987
        && icount_time_shift > 0) {
988
        /* The guest is getting too far ahead.  Slow time down.  */
989
        icount_time_shift--;
990
    }
991
    if (delta < 0
992
        && last_delta - ICOUNT_WOBBLE > delta * 2
993
        && icount_time_shift < MAX_ICOUNT_SHIFT) {
994
        /* The guest is getting too far behind.  Speed time up.  */
995
        icount_time_shift++;
996
    }
997
    last_delta = delta;
998
    qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
999
}
1000

    
1001
static void icount_adjust_rt(void * opaque)
1002
{
1003
    qemu_mod_timer(icount_rt_timer,
1004
                   qemu_get_clock(rt_clock) + 1000);
1005
    icount_adjust();
1006
}
1007

    
1008
static void icount_adjust_vm(void * opaque)
1009
{
1010
    qemu_mod_timer(icount_vm_timer,
1011
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1012
    icount_adjust();
1013
}
1014

    
1015
static void init_icount_adjust(void)
1016
{
1017
    /* Have both realtime and virtual time triggers for speed adjustment.
1018
       The realtime trigger catches emulated time passing too slowly,
1019
       the virtual time trigger catches emulated time passing too fast.
1020
       Realtime triggers occur even when idle, so use them less frequently
1021
       than VM triggers.  */
1022
    icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
1023
    qemu_mod_timer(icount_rt_timer,
1024
                   qemu_get_clock(rt_clock) + 1000);
1025
    icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
1026
    qemu_mod_timer(icount_vm_timer,
1027
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1028
}
1029

    
1030
static struct qemu_alarm_timer alarm_timers[] = {
1031
#ifndef _WIN32
1032
#ifdef __linux__
1033
    {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1034
     dynticks_stop_timer, dynticks_rearm_timer, NULL},
1035
    /* HPET - if available - is preferred */
1036
    {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1037
    /* ...otherwise try RTC */
1038
    {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1039
#endif
1040
    {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1041
#else
1042
    {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1043
     win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1044
    {"win32", 0, win32_start_timer,
1045
     win32_stop_timer, NULL, &alarm_win32_data},
1046
#endif
1047
    {NULL, }
1048
};
1049

    
1050
static void show_available_alarms(void)
1051
{
1052
    int i;
1053

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

    
1059
static void configure_alarms(char const *opt)
1060
{
1061
    int i;
1062
    int cur = 0;
1063
    int count = ARRAY_SIZE(alarm_timers) - 1;
1064
    char *arg;
1065
    char *name;
1066
    struct qemu_alarm_timer tmp;
1067

    
1068
    if (!strcmp(opt, "?")) {
1069
        show_available_alarms();
1070
        exit(0);
1071
    }
1072

    
1073
    arg = strdup(opt);
1074

    
1075
    /* Reorder the array */
1076
    name = strtok(arg, ",");
1077
    while (name) {
1078
        for (i = 0; i < count && alarm_timers[i].name; i++) {
1079
            if (!strcmp(alarm_timers[i].name, name))
1080
                break;
1081
        }
1082

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

    
1088
        if (i < cur)
1089
            /* Ignore */
1090
            goto next;
1091

    
1092
        /* Swap */
1093
        tmp = alarm_timers[i];
1094
        alarm_timers[i] = alarm_timers[cur];
1095
        alarm_timers[cur] = tmp;
1096

    
1097
        cur++;
1098
next:
1099
        name = strtok(NULL, ",");
1100
    }
1101

    
1102
    free(arg);
1103

    
1104
    if (cur) {
1105
        /* Disable remaining timers */
1106
        for (i = cur; i < count; i++)
1107
            alarm_timers[i].name = NULL;
1108
    } else {
1109
        show_available_alarms();
1110
        exit(1);
1111
    }
1112
}
1113

    
1114
QEMUClock *rt_clock;
1115
QEMUClock *vm_clock;
1116

    
1117
static QEMUTimer *active_timers[2];
1118

    
1119
static QEMUClock *qemu_new_clock(int type)
1120
{
1121
    QEMUClock *clock;
1122
    clock = qemu_mallocz(sizeof(QEMUClock));
1123
    clock->type = type;
1124
    return clock;
1125
}
1126

    
1127
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1128
{
1129
    QEMUTimer *ts;
1130

    
1131
    ts = qemu_mallocz(sizeof(QEMUTimer));
1132
    ts->clock = clock;
1133
    ts->cb = cb;
1134
    ts->opaque = opaque;
1135
    return ts;
1136
}
1137

    
1138
void qemu_free_timer(QEMUTimer *ts)
1139
{
1140
    qemu_free(ts);
1141
}
1142

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

    
1148
    /* NOTE: this code must be signal safe because
1149
       qemu_timer_expired() can be called from a signal. */
1150
    pt = &active_timers[ts->clock->type];
1151
    for(;;) {
1152
        t = *pt;
1153
        if (!t)
1154
            break;
1155
        if (t == ts) {
1156
            *pt = t->next;
1157
            break;
1158
        }
1159
        pt = &t->next;
1160
    }
1161
}
1162

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

    
1169
    qemu_del_timer(ts);
1170

    
1171
    /* add the timer in the sorted list */
1172
    /* NOTE: this code must be signal safe because
1173
       qemu_timer_expired() can be called from a signal. */
1174
    pt = &active_timers[ts->clock->type];
1175
    for(;;) {
1176
        t = *pt;
1177
        if (!t)
1178
            break;
1179
        if (t->expire_time > expire_time)
1180
            break;
1181
        pt = &t->next;
1182
    }
1183
    ts->expire_time = expire_time;
1184
    ts->next = *pt;
1185
    *pt = ts;
1186

    
1187
    /* Rearm if necessary  */
1188
    if (pt == &active_timers[ts->clock->type]) {
1189
        if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1190
            qemu_rearm_alarm_timer(alarm_timer);
1191
        }
1192
        /* Interrupt execution to force deadline recalculation.  */
1193
        if (use_icount)
1194
            qemu_notify_event();
1195
    }
1196
}
1197

    
1198
int qemu_timer_pending(QEMUTimer *ts)
1199
{
1200
    QEMUTimer *t;
1201
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1202
        if (t == ts)
1203
            return 1;
1204
    }
1205
    return 0;
1206
}
1207

    
1208
static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1209
{
1210
    if (!timer_head)
1211
        return 0;
1212
    return (timer_head->expire_time <= current_time);
1213
}
1214

    
1215
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1216
{
1217
    QEMUTimer *ts;
1218

    
1219
    for(;;) {
1220
        ts = *ptimer_head;
1221
        if (!ts || ts->expire_time > current_time)
1222
            break;
1223
        /* remove timer from the list before calling the callback */
1224
        *ptimer_head = ts->next;
1225
        ts->next = NULL;
1226

    
1227
        /* run the callback (the timer list can be modified) */
1228
        ts->cb(ts->opaque);
1229
    }
1230
}
1231

    
1232
int64_t qemu_get_clock(QEMUClock *clock)
1233
{
1234
    switch(clock->type) {
1235
    case QEMU_TIMER_REALTIME:
1236
        return get_clock() / 1000000;
1237
    default:
1238
    case QEMU_TIMER_VIRTUAL:
1239
        if (use_icount) {
1240
            return cpu_get_icount();
1241
        } else {
1242
            return cpu_get_clock();
1243
        }
1244
    }
1245
}
1246

    
1247
static void init_timers(void)
1248
{
1249
    init_get_clock();
1250
    ticks_per_sec = QEMU_TIMER_BASE;
1251
    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1252
    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1253
}
1254

    
1255
/* save a timer */
1256
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1257
{
1258
    uint64_t expire_time;
1259

    
1260
    if (qemu_timer_pending(ts)) {
1261
        expire_time = ts->expire_time;
1262
    } else {
1263
        expire_time = -1;
1264
    }
1265
    qemu_put_be64(f, expire_time);
1266
}
1267

    
1268
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1269
{
1270
    uint64_t expire_time;
1271

    
1272
    expire_time = qemu_get_be64(f);
1273
    if (expire_time != -1) {
1274
        qemu_mod_timer(ts, expire_time);
1275
    } else {
1276
        qemu_del_timer(ts);
1277
    }
1278
}
1279

    
1280
static void timer_save(QEMUFile *f, void *opaque)
1281
{
1282
    if (cpu_ticks_enabled) {
1283
        hw_error("cannot save state if virtual timers are running");
1284
    }
1285
    qemu_put_be64(f, cpu_ticks_offset);
1286
    qemu_put_be64(f, ticks_per_sec);
1287
    qemu_put_be64(f, cpu_clock_offset);
1288
}
1289

    
1290
static int timer_load(QEMUFile *f, void *opaque, int version_id)
1291
{
1292
    if (version_id != 1 && version_id != 2)
1293
        return -EINVAL;
1294
    if (cpu_ticks_enabled) {
1295
        return -EINVAL;
1296
    }
1297
    cpu_ticks_offset=qemu_get_be64(f);
1298
    ticks_per_sec=qemu_get_be64(f);
1299
    if (version_id == 2) {
1300
        cpu_clock_offset=qemu_get_be64(f);
1301
    }
1302
    return 0;
1303
}
1304

    
1305
static void qemu_event_increment(void);
1306

    
1307
#ifdef _WIN32
1308
static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1309
                                        DWORD_PTR dwUser, DWORD_PTR dw1,
1310
                                        DWORD_PTR dw2)
1311
#else
1312
static void host_alarm_handler(int host_signum)
1313
#endif
1314
{
1315
#if 0
1316
#define DISP_FREQ 1000
1317
    {
1318
        static int64_t delta_min = INT64_MAX;
1319
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
1320
        static int count;
1321
        ti = qemu_get_clock(vm_clock);
1322
        if (last_clock != 0) {
1323
            delta = ti - last_clock;
1324
            if (delta < delta_min)
1325
                delta_min = delta;
1326
            if (delta > delta_max)
1327
                delta_max = delta;
1328
            delta_cum += delta;
1329
            if (++count == DISP_FREQ) {
1330
                printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1331
                       muldiv64(delta_min, 1000000, ticks_per_sec),
1332
                       muldiv64(delta_max, 1000000, ticks_per_sec),
1333
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1334
                       (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1335
                count = 0;
1336
                delta_min = INT64_MAX;
1337
                delta_max = 0;
1338
                delta_cum = 0;
1339
            }
1340
        }
1341
        last_clock = ti;
1342
    }
1343
#endif
1344
    if (alarm_has_dynticks(alarm_timer) ||
1345
        (!use_icount &&
1346
            qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1347
                               qemu_get_clock(vm_clock))) ||
1348
        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1349
                           qemu_get_clock(rt_clock))) {
1350
        qemu_event_increment();
1351
        if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1352

    
1353
#ifndef CONFIG_IOTHREAD
1354
        if (next_cpu) {
1355
            /* stop the currently executing cpu because a timer occured */
1356
            cpu_exit(next_cpu);
1357
#ifdef CONFIG_KQEMU
1358
            if (next_cpu->kqemu_enabled) {
1359
                kqemu_cpu_interrupt(next_cpu);
1360
            }
1361
#endif
1362
        }
1363
#endif
1364
        timer_alarm_pending = 1;
1365
        qemu_notify_event();
1366
    }
1367
}
1368

    
1369
static int64_t qemu_next_deadline(void)
1370
{
1371
    int64_t delta;
1372

    
1373
    if (active_timers[QEMU_TIMER_VIRTUAL]) {
1374
        delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1375
                     qemu_get_clock(vm_clock);
1376
    } else {
1377
        /* To avoid problems with overflow limit this to 2^32.  */
1378
        delta = INT32_MAX;
1379
    }
1380

    
1381
    if (delta < 0)
1382
        delta = 0;
1383

    
1384
    return delta;
1385
}
1386

    
1387
#if defined(__linux__) || defined(_WIN32)
1388
static uint64_t qemu_next_deadline_dyntick(void)
1389
{
1390
    int64_t delta;
1391
    int64_t rtdelta;
1392

    
1393
    if (use_icount)
1394
        delta = INT32_MAX;
1395
    else
1396
        delta = (qemu_next_deadline() + 999) / 1000;
1397

    
1398
    if (active_timers[QEMU_TIMER_REALTIME]) {
1399
        rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1400
                 qemu_get_clock(rt_clock))*1000;
1401
        if (rtdelta < delta)
1402
            delta = rtdelta;
1403
    }
1404

    
1405
    if (delta < MIN_TIMER_REARM_US)
1406
        delta = MIN_TIMER_REARM_US;
1407

    
1408
    return delta;
1409
}
1410
#endif
1411

    
1412
#ifndef _WIN32
1413

    
1414
/* Sets a specific flag */
1415
static int fcntl_setfl(int fd, int flag)
1416
{
1417
    int flags;
1418

    
1419
    flags = fcntl(fd, F_GETFL);
1420
    if (flags == -1)
1421
        return -errno;
1422

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

    
1426
    return 0;
1427
}
1428

    
1429
#if defined(__linux__)
1430

    
1431
#define RTC_FREQ 1024
1432

    
1433
static void enable_sigio_timer(int fd)
1434
{
1435
    struct sigaction act;
1436

    
1437
    /* timer signal */
1438
    sigfillset(&act.sa_mask);
1439
    act.sa_flags = 0;
1440
    act.sa_handler = host_alarm_handler;
1441

    
1442
    sigaction(SIGIO, &act, NULL);
1443
    fcntl_setfl(fd, O_ASYNC);
1444
    fcntl(fd, F_SETOWN, getpid());
1445
}
1446

    
1447
static int hpet_start_timer(struct qemu_alarm_timer *t)
1448
{
1449
    struct hpet_info info;
1450
    int r, fd;
1451

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

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

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

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

    
1475
    /* Enable interrupt */
1476
    r = ioctl(fd, HPET_IE_ON, 0);
1477
    if (r < 0)
1478
        goto fail;
1479

    
1480
    enable_sigio_timer(fd);
1481
    t->priv = (void *)(long)fd;
1482

    
1483
    return 0;
1484
fail:
1485
    close(fd);
1486
    return -1;
1487
}
1488

    
1489
static void hpet_stop_timer(struct qemu_alarm_timer *t)
1490
{
1491
    int fd = (long)t->priv;
1492

    
1493
    close(fd);
1494
}
1495

    
1496
static int rtc_start_timer(struct qemu_alarm_timer *t)
1497
{
1498
    int rtc_fd;
1499
    unsigned long current_rtc_freq = 0;
1500

    
1501
    TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1502
    if (rtc_fd < 0)
1503
        return -1;
1504
    ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1505
    if (current_rtc_freq != RTC_FREQ &&
1506
        ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1507
        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1508
                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1509
                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1510
        goto fail;
1511
    }
1512
    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1513
    fail:
1514
        close(rtc_fd);
1515
        return -1;
1516
    }
1517

    
1518
    enable_sigio_timer(rtc_fd);
1519

    
1520
    t->priv = (void *)(long)rtc_fd;
1521

    
1522
    return 0;
1523
}
1524

    
1525
static void rtc_stop_timer(struct qemu_alarm_timer *t)
1526
{
1527
    int rtc_fd = (long)t->priv;
1528

    
1529
    close(rtc_fd);
1530
}
1531

    
1532
static int dynticks_start_timer(struct qemu_alarm_timer *t)
1533
{
1534
    struct sigevent ev;
1535
    timer_t host_timer;
1536
    struct sigaction act;
1537

    
1538
    sigfillset(&act.sa_mask);
1539
    act.sa_flags = 0;
1540
    act.sa_handler = host_alarm_handler;
1541

    
1542
    sigaction(SIGALRM, &act, NULL);
1543

    
1544
    /* 
1545
     * Initialize ev struct to 0 to avoid valgrind complaining
1546
     * about uninitialized data in timer_create call
1547
     */
1548
    memset(&ev, 0, sizeof(ev));
1549
    ev.sigev_value.sival_int = 0;
1550
    ev.sigev_notify = SIGEV_SIGNAL;
1551
    ev.sigev_signo = SIGALRM;
1552

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

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

    
1559
        return -1;
1560
    }
1561

    
1562
    t->priv = (void *)(long)host_timer;
1563

    
1564
    return 0;
1565
}
1566

    
1567
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1568
{
1569
    timer_t host_timer = (timer_t)(long)t->priv;
1570

    
1571
    timer_delete(host_timer);
1572
}
1573

    
1574
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1575
{
1576
    timer_t host_timer = (timer_t)(long)t->priv;
1577
    struct itimerspec timeout;
1578
    int64_t nearest_delta_us = INT64_MAX;
1579
    int64_t current_us;
1580

    
1581
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1582
                !active_timers[QEMU_TIMER_VIRTUAL])
1583
        return;
1584

    
1585
    nearest_delta_us = qemu_next_deadline_dyntick();
1586

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

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

    
1608
#endif /* defined(__linux__) */
1609

    
1610
static int unix_start_timer(struct qemu_alarm_timer *t)
1611
{
1612
    struct sigaction act;
1613
    struct itimerval itv;
1614
    int err;
1615

    
1616
    /* timer signal */
1617
    sigfillset(&act.sa_mask);
1618
    act.sa_flags = 0;
1619
    act.sa_handler = host_alarm_handler;
1620

    
1621
    sigaction(SIGALRM, &act, NULL);
1622

    
1623
    itv.it_interval.tv_sec = 0;
1624
    /* for i386 kernel 2.6 to get 1 ms */
1625
    itv.it_interval.tv_usec = 999;
1626
    itv.it_value.tv_sec = 0;
1627
    itv.it_value.tv_usec = 10 * 1000;
1628

    
1629
    err = setitimer(ITIMER_REAL, &itv, NULL);
1630
    if (err)
1631
        return -1;
1632

    
1633
    return 0;
1634
}
1635

    
1636
static void unix_stop_timer(struct qemu_alarm_timer *t)
1637
{
1638
    struct itimerval itv;
1639

    
1640
    memset(&itv, 0, sizeof(itv));
1641
    setitimer(ITIMER_REAL, &itv, NULL);
1642
}
1643

    
1644
#endif /* !defined(_WIN32) */
1645

    
1646

    
1647
#ifdef _WIN32
1648

    
1649
static int win32_start_timer(struct qemu_alarm_timer *t)
1650
{
1651
    TIMECAPS tc;
1652
    struct qemu_alarm_win32 *data = t->priv;
1653
    UINT flags;
1654

    
1655
    memset(&tc, 0, sizeof(tc));
1656
    timeGetDevCaps(&tc, sizeof(tc));
1657

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

    
1661
    timeBeginPeriod(data->period);
1662

    
1663
    flags = TIME_CALLBACK_FUNCTION;
1664
    if (alarm_has_dynticks(t))
1665
        flags |= TIME_ONESHOT;
1666
    else
1667
        flags |= TIME_PERIODIC;
1668

    
1669
    data->timerId = timeSetEvent(1,         // interval (ms)
1670
                        data->period,       // resolution
1671
                        host_alarm_handler, // function
1672
                        (DWORD)t,           // parameter
1673
                        flags);
1674

    
1675
    if (!data->timerId) {
1676
        perror("Failed to initialize win32 alarm timer");
1677
        timeEndPeriod(data->period);
1678
        return -1;
1679
    }
1680

    
1681
    return 0;
1682
}
1683

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

    
1688
    timeKillEvent(data->timerId);
1689
    timeEndPeriod(data->period);
1690
}
1691

    
1692
static void win32_rearm_timer(struct qemu_alarm_timer *t)
1693
{
1694
    struct qemu_alarm_win32 *data = t->priv;
1695
    uint64_t nearest_delta_us;
1696

    
1697
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1698
                !active_timers[QEMU_TIMER_VIRTUAL])
1699
        return;
1700

    
1701
    nearest_delta_us = qemu_next_deadline_dyntick();
1702
    nearest_delta_us /= 1000;
1703

    
1704
    timeKillEvent(data->timerId);
1705

    
1706
    data->timerId = timeSetEvent(1,
1707
                        data->period,
1708
                        host_alarm_handler,
1709
                        (DWORD)t,
1710
                        TIME_ONESHOT | TIME_PERIODIC);
1711

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

    
1715
        timeEndPeriod(data->period);
1716
        exit(1);
1717
    }
1718
}
1719

    
1720
#endif /* _WIN32 */
1721

    
1722
static int init_timer_alarm(void)
1723
{
1724
    struct qemu_alarm_timer *t = NULL;
1725
    int i, err = -1;
1726

    
1727
    for (i = 0; alarm_timers[i].name; i++) {
1728
        t = &alarm_timers[i];
1729

    
1730
        err = t->start(t);
1731
        if (!err)
1732
            break;
1733
    }
1734

    
1735
    if (err) {
1736
        err = -ENOENT;
1737
        goto fail;
1738
    }
1739

    
1740
    alarm_timer = t;
1741

    
1742
    return 0;
1743

    
1744
fail:
1745
    return err;
1746
}
1747

    
1748
static void quit_timers(void)
1749
{
1750
    alarm_timer->stop(alarm_timer);
1751
    alarm_timer = NULL;
1752
}
1753

    
1754
/***********************************************************/
1755
/* host time/date access */
1756
void qemu_get_timedate(struct tm *tm, int offset)
1757
{
1758
    time_t ti;
1759
    struct tm *ret;
1760

    
1761
    time(&ti);
1762
    ti += offset;
1763
    if (rtc_date_offset == -1) {
1764
        if (rtc_utc)
1765
            ret = gmtime(&ti);
1766
        else
1767
            ret = localtime(&ti);
1768
    } else {
1769
        ti -= rtc_date_offset;
1770
        ret = gmtime(&ti);
1771
    }
1772

    
1773
    memcpy(tm, ret, sizeof(struct tm));
1774
}
1775

    
1776
int qemu_timedate_diff(struct tm *tm)
1777
{
1778
    time_t seconds;
1779

    
1780
    if (rtc_date_offset == -1)
1781
        if (rtc_utc)
1782
            seconds = mktimegm(tm);
1783
        else
1784
            seconds = mktime(tm);
1785
    else
1786
        seconds = mktimegm(tm) + rtc_date_offset;
1787

    
1788
    return seconds - time(NULL);
1789
}
1790

    
1791
#ifdef _WIN32
1792
static void socket_cleanup(void)
1793
{
1794
    WSACleanup();
1795
}
1796

    
1797
static int socket_init(void)
1798
{
1799
    WSADATA Data;
1800
    int ret, err;
1801

    
1802
    ret = WSAStartup(MAKEWORD(2,2), &Data);
1803
    if (ret != 0) {
1804
        err = WSAGetLastError();
1805
        fprintf(stderr, "WSAStartup: %d\n", err);
1806
        return -1;
1807
    }
1808
    atexit(socket_cleanup);
1809
    return 0;
1810
}
1811
#endif
1812

    
1813
int get_param_value(char *buf, int buf_size,
1814
                    const char *tag, const char *str)
1815
{
1816
    const char *p;
1817
    char option[128];
1818

    
1819
    p = str;
1820
    for(;;) {
1821
        p = get_opt_name(option, sizeof(option), p, '=');
1822
        if (*p != '=')
1823
            break;
1824
        p++;
1825
        if (!strcmp(tag, option)) {
1826
            (void)get_opt_value(buf, buf_size, p);
1827
            return strlen(buf);
1828
        } else {
1829
            p = get_opt_value(NULL, 0, p);
1830
        }
1831
        if (*p != ',')
1832
            break;
1833
        p++;
1834
    }
1835
    return 0;
1836
}
1837

    
1838
int check_params(const char * const *params, const char *str)
1839
{
1840
    int name_buf_size = 1;
1841
    const char *p;
1842
    char *name_buf;
1843
    int i, len;
1844
    int ret = 0;
1845

    
1846
    for (i = 0; params[i] != NULL; i++) {
1847
        len = strlen(params[i]) + 1;
1848
        if (len > name_buf_size) {
1849
            name_buf_size = len;
1850
        }
1851
    }
1852
    name_buf = qemu_malloc(name_buf_size);
1853

    
1854
    p = str;
1855
    while (*p != '\0') {
1856
        p = get_opt_name(name_buf, name_buf_size, p, '=');
1857
        if (*p != '=') {
1858
            ret = -1;
1859
            break;
1860
        }
1861
        p++;
1862
        for(i = 0; params[i] != NULL; i++)
1863
            if (!strcmp(params[i], name_buf))
1864
                break;
1865
        if (params[i] == NULL) {
1866
            ret = -1;
1867
            break;
1868
        }
1869
        p = get_opt_value(NULL, 0, p);
1870
        if (*p != ',')
1871
            break;
1872
        p++;
1873
    }
1874

    
1875
    qemu_free(name_buf);
1876
    return ret;
1877
}
1878

    
1879
/***********************************************************/
1880
/* Bluetooth support */
1881
static int nb_hcis;
1882
static int cur_hci;
1883
static struct HCIInfo *hci_table[MAX_NICS];
1884

    
1885
static struct bt_vlan_s {
1886
    struct bt_scatternet_s net;
1887
    int id;
1888
    struct bt_vlan_s *next;
1889
} *first_bt_vlan;
1890

    
1891
/* find or alloc a new bluetooth "VLAN" */
1892
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1893
{
1894
    struct bt_vlan_s **pvlan, *vlan;
1895
    for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1896
        if (vlan->id == id)
1897
            return &vlan->net;
1898
    }
1899
    vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1900
    vlan->id = id;
1901
    pvlan = &first_bt_vlan;
1902
    while (*pvlan != NULL)
1903
        pvlan = &(*pvlan)->next;
1904
    *pvlan = vlan;
1905
    return &vlan->net;
1906
}
1907

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

    
1912
static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1913
{
1914
    return -ENOTSUP;
1915
}
1916

    
1917
static struct HCIInfo null_hci = {
1918
    .cmd_send = null_hci_send,
1919
    .sco_send = null_hci_send,
1920
    .acl_send = null_hci_send,
1921
    .bdaddr_set = null_hci_addr_set,
1922
};
1923

    
1924
struct HCIInfo *qemu_next_hci(void)
1925
{
1926
    if (cur_hci == nb_hcis)
1927
        return &null_hci;
1928

    
1929
    return hci_table[cur_hci++];
1930
}
1931

    
1932
static struct HCIInfo *hci_init(const char *str)
1933
{
1934
    char *endp;
1935
    struct bt_scatternet_s *vlan = 0;
1936

    
1937
    if (!strcmp(str, "null"))
1938
        /* null */
1939
        return &null_hci;
1940
    else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1941
        /* host[:hciN] */
1942
        return bt_host_hci(str[4] ? str + 5 : "hci0");
1943
    else if (!strncmp(str, "hci", 3)) {
1944
        /* hci[,vlan=n] */
1945
        if (str[3]) {
1946
            if (!strncmp(str + 3, ",vlan=", 6)) {
1947
                vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1948
                if (*endp)
1949
                    vlan = 0;
1950
            }
1951
        } else
1952
            vlan = qemu_find_bt_vlan(0);
1953
        if (vlan)
1954
           return bt_new_hci(vlan);
1955
    }
1956

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

    
1959
    return 0;
1960
}
1961

    
1962
static int bt_hci_parse(const char *str)
1963
{
1964
    struct HCIInfo *hci;
1965
    bdaddr_t bdaddr;
1966

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

    
1972
    hci = hci_init(str);
1973
    if (!hci)
1974
        return -1;
1975

    
1976
    bdaddr.b[0] = 0x52;
1977
    bdaddr.b[1] = 0x54;
1978
    bdaddr.b[2] = 0x00;
1979
    bdaddr.b[3] = 0x12;
1980
    bdaddr.b[4] = 0x34;
1981
    bdaddr.b[5] = 0x56 + nb_hcis;
1982
    hci->bdaddr_set(hci, bdaddr.b);
1983

    
1984
    hci_table[nb_hcis++] = hci;
1985

    
1986
    return 0;
1987
}
1988

    
1989
static void bt_vhci_add(int vlan_id)
1990
{
1991
    struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1992

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

    
1997
    bt_vhci_init(bt_new_hci(vlan));
1998
}
1999

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

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

    
2010
    if (endp) {
2011
        vlan_id = strtol(endp + 6, &endp, 0);
2012
        if (*endp) {
2013
            fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2014
            return 0;
2015
        }
2016
    }
2017

    
2018
    vlan = qemu_find_bt_vlan(vlan_id);
2019

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

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

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

    
2031
static int bt_parse(const char *opt)
2032
{
2033
    const char *endp, *p;
2034
    int vlan;
2035

    
2036
    if (strstart(opt, "hci", &endp)) {
2037
        if (!*endp || *endp == ',') {
2038
            if (*endp)
2039
                if (!strstart(endp, ",vlan=", 0))
2040
                    opt = endp + 1;
2041

    
2042
            return bt_hci_parse(opt);
2043
       }
2044
    } else if (strstart(opt, "vhci", &endp)) {
2045
        if (!*endp || *endp == ',') {
2046
            if (*endp) {
2047
                if (strstart(endp, ",vlan=", &p)) {
2048
                    vlan = strtol(p, (char **) &endp, 0);
2049
                    if (*endp) {
2050
                        fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2051
                        return 1;
2052
                    }
2053
                } else {
2054
                    fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2055
                    return 1;
2056
                }
2057
            } else
2058
                vlan = 0;
2059

    
2060
            bt_vhci_add(vlan);
2061
            return 0;
2062
        }
2063
    } else if (strstart(opt, "device:", &endp))
2064
        return !bt_device_add(endp);
2065

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

    
2070
/***********************************************************/
2071
/* QEMU Block devices */
2072

    
2073
#define HD_ALIAS "index=%d,media=disk"
2074
#define CDROM_ALIAS "index=2,media=cdrom"
2075
#define FD_ALIAS "index=%d,if=floppy"
2076
#define PFLASH_ALIAS "if=pflash"
2077
#define MTD_ALIAS "if=mtd"
2078
#define SD_ALIAS "index=0,if=sd"
2079

    
2080
static int drive_opt_get_free_idx(void)
2081
{
2082
    int index;
2083

    
2084
    for (index = 0; index < MAX_DRIVES; index++)
2085
        if (!drives_opt[index].used) {
2086
            drives_opt[index].used = 1;
2087
            return index;
2088
        }
2089

    
2090
    return -1;
2091
}
2092

    
2093
static int drive_get_free_idx(void)
2094
{
2095
    int index;
2096

    
2097
    for (index = 0; index < MAX_DRIVES; index++)
2098
        if (!drives_table[index].used) {
2099
            drives_table[index].used = 1;
2100
            return index;
2101
        }
2102

    
2103
    return -1;
2104
}
2105

    
2106
int drive_add(const char *file, const char *fmt, ...)
2107
{
2108
    va_list ap;
2109
    int index = drive_opt_get_free_idx();
2110

    
2111
    if (nb_drives_opt >= MAX_DRIVES || index == -1) {
2112
        fprintf(stderr, "qemu: too many drives\n");
2113
        return -1;
2114
    }
2115

    
2116
    drives_opt[index].file = file;
2117
    va_start(ap, fmt);
2118
    vsnprintf(drives_opt[index].opt,
2119
              sizeof(drives_opt[0].opt), fmt, ap);
2120
    va_end(ap);
2121

    
2122
    nb_drives_opt++;
2123
    return index;
2124
}
2125

    
2126
void drive_remove(int index)
2127
{
2128
    drives_opt[index].used = 0;
2129
    nb_drives_opt--;
2130
}
2131

    
2132
int drive_get_index(BlockInterfaceType type, int bus, int unit)
2133
{
2134
    int index;
2135

    
2136
    /* seek interface, bus and unit */
2137

    
2138
    for (index = 0; index < MAX_DRIVES; index++)
2139
        if (drives_table[index].type == type &&
2140
            drives_table[index].bus == bus &&
2141
            drives_table[index].unit == unit &&
2142
            drives_table[index].used)
2143
        return index;
2144

    
2145
    return -1;
2146
}
2147

    
2148
int drive_get_max_bus(BlockInterfaceType type)
2149
{
2150
    int max_bus;
2151
    int index;
2152

    
2153
    max_bus = -1;
2154
    for (index = 0; index < nb_drives; index++) {
2155
        if(drives_table[index].type == type &&
2156
           drives_table[index].bus > max_bus)
2157
            max_bus = drives_table[index].bus;
2158
    }
2159
    return max_bus;
2160
}
2161

    
2162
const char *drive_get_serial(BlockDriverState *bdrv)
2163
{
2164
    int index;
2165

    
2166
    for (index = 0; index < nb_drives; index++)
2167
        if (drives_table[index].bdrv == bdrv)
2168
            return drives_table[index].serial;
2169

    
2170
    return "\0";
2171
}
2172

    
2173
BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2174
{
2175
    int index;
2176

    
2177
    for (index = 0; index < nb_drives; index++)
2178
        if (drives_table[index].bdrv == bdrv)
2179
            return drives_table[index].onerror;
2180

    
2181
    return BLOCK_ERR_STOP_ENOSPC;
2182
}
2183

    
2184
static void bdrv_format_print(void *opaque, const char *name)
2185
{
2186
    fprintf(stderr, " %s", name);
2187
}
2188

    
2189
void drive_uninit(BlockDriverState *bdrv)
2190
{
2191
    int i;
2192

    
2193
    for (i = 0; i < MAX_DRIVES; i++)
2194
        if (drives_table[i].bdrv == bdrv) {
2195
            drives_table[i].bdrv = NULL;
2196
            drives_table[i].used = 0;
2197
            drive_remove(drives_table[i].drive_opt_idx);
2198
            nb_drives--;
2199
            break;
2200
        }
2201
}
2202

    
2203
int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
2204
{
2205
    char buf[128];
2206
    char file[1024];
2207
    char devname[128];
2208
    char serial[21];
2209
    const char *mediastr = "";
2210
    BlockInterfaceType type;
2211
    enum { MEDIA_DISK, MEDIA_CDROM } media;
2212
    int bus_id, unit_id;
2213
    int cyls, heads, secs, translation;
2214
    BlockDriverState *bdrv;
2215
    BlockDriver *drv = NULL;
2216
    QEMUMachine *machine = opaque;
2217
    int max_devs;
2218
    int index;
2219
    int cache;
2220
    int bdrv_flags, onerror;
2221
    int drives_table_idx;
2222
    char *str = arg->opt;
2223
    static const char * const params[] = { "bus", "unit", "if", "index",
2224
                                           "cyls", "heads", "secs", "trans",
2225
                                           "media", "snapshot", "file",
2226
                                           "cache", "format", "serial", "werror",
2227
                                           NULL };
2228

    
2229
    if (check_params(params, str) < 0) {
2230
         fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
2231
                         buf, str);
2232
         return -1;
2233
    }
2234

    
2235
    file[0] = 0;
2236
    cyls = heads = secs = 0;
2237
    bus_id = 0;
2238
    unit_id = -1;
2239
    translation = BIOS_ATA_TRANSLATION_AUTO;
2240
    index = -1;
2241
    cache = 3;
2242

    
2243
    if (machine->use_scsi) {
2244
        type = IF_SCSI;
2245
        max_devs = MAX_SCSI_DEVS;
2246
        pstrcpy(devname, sizeof(devname), "scsi");
2247
    } else {
2248
        type = IF_IDE;
2249
        max_devs = MAX_IDE_DEVS;
2250
        pstrcpy(devname, sizeof(devname), "ide");
2251
    }
2252
    media = MEDIA_DISK;
2253

    
2254
    /* extract parameters */
2255

    
2256
    if (get_param_value(buf, sizeof(buf), "bus", str)) {
2257
        bus_id = strtol(buf, NULL, 0);
2258
        if (bus_id < 0) {
2259
            fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2260
            return -1;
2261
        }
2262
    }
2263

    
2264
    if (get_param_value(buf, sizeof(buf), "unit", str)) {
2265
        unit_id = strtol(buf, NULL, 0);
2266
        if (unit_id < 0) {
2267
            fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2268
            return -1;
2269
        }
2270
    }
2271

    
2272
    if (get_param_value(buf, sizeof(buf), "if", str)) {
2273
        pstrcpy(devname, sizeof(devname), buf);
2274
        if (!strcmp(buf, "ide")) {
2275
            type = IF_IDE;
2276
            max_devs = MAX_IDE_DEVS;
2277
        } else if (!strcmp(buf, "scsi")) {
2278
            type = IF_SCSI;
2279
            max_devs = MAX_SCSI_DEVS;
2280
        } else if (!strcmp(buf, "floppy")) {
2281
            type = IF_FLOPPY;
2282
            max_devs = 0;
2283
        } else if (!strcmp(buf, "pflash")) {
2284
            type = IF_PFLASH;
2285
            max_devs = 0;
2286
        } else if (!strcmp(buf, "mtd")) {
2287
            type = IF_MTD;
2288
            max_devs = 0;
2289
        } else if (!strcmp(buf, "sd")) {
2290
            type = IF_SD;
2291
            max_devs = 0;
2292
        } else if (!strcmp(buf, "virtio")) {
2293
            type = IF_VIRTIO;
2294
            max_devs = 0;
2295
        } else if (!strcmp(buf, "xen")) {
2296
            type = IF_XEN;
2297
            max_devs = 0;
2298
        } else {
2299
            fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2300
            return -1;
2301
        }
2302
    }
2303

    
2304
    if (get_param_value(buf, sizeof(buf), "index", str)) {
2305
        index = strtol(buf, NULL, 0);
2306
        if (index < 0) {
2307
            fprintf(stderr, "qemu: '%s' invalid index\n", str);
2308
            return -1;
2309
        }
2310
    }
2311

    
2312
    if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2313
        cyls = strtol(buf, NULL, 0);
2314
    }
2315

    
2316
    if (get_param_value(buf, sizeof(buf), "heads", str)) {
2317
        heads = strtol(buf, NULL, 0);
2318
    }
2319

    
2320
    if (get_param_value(buf, sizeof(buf), "secs", str)) {
2321
        secs = strtol(buf, NULL, 0);
2322
    }
2323

    
2324
    if (cyls || heads || secs) {
2325
        if (cyls < 1 || cyls > 16383) {
2326
            fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2327
            return -1;
2328
        }
2329
        if (heads < 1 || heads > 16) {
2330
            fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2331
            return -1;
2332
        }
2333
        if (secs < 1 || secs > 63) {
2334
            fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2335
            return -1;
2336
        }
2337
    }
2338

    
2339
    if (get_param_value(buf, sizeof(buf), "trans", str)) {
2340
        if (!cyls) {
2341
            fprintf(stderr,
2342
                    "qemu: '%s' trans must be used with cyls,heads and secs\n",
2343
                    str);
2344
            return -1;
2345
        }
2346
        if (!strcmp(buf, "none"))
2347
            translation = BIOS_ATA_TRANSLATION_NONE;
2348
        else if (!strcmp(buf, "lba"))
2349
            translation = BIOS_ATA_TRANSLATION_LBA;
2350
        else if (!strcmp(buf, "auto"))
2351
            translation = BIOS_ATA_TRANSLATION_AUTO;
2352
        else {
2353
            fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2354
            return -1;
2355
        }
2356
    }
2357

    
2358
    if (get_param_value(buf, sizeof(buf), "media", str)) {
2359
        if (!strcmp(buf, "disk")) {
2360
            media = MEDIA_DISK;
2361
        } else if (!strcmp(buf, "cdrom")) {
2362
            if (cyls || secs || heads) {
2363
                fprintf(stderr,
2364
                        "qemu: '%s' invalid physical CHS format\n", str);
2365
                return -1;
2366
            }
2367
            media = MEDIA_CDROM;
2368
        } else {
2369
            fprintf(stderr, "qemu: '%s' invalid media\n", str);
2370
            return -1;
2371
        }
2372
    }
2373

    
2374
    if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2375
        if (!strcmp(buf, "on"))
2376
            snapshot = 1;
2377
        else if (!strcmp(buf, "off"))
2378
            snapshot = 0;
2379
        else {
2380
            fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2381
            return -1;
2382
        }
2383
    }
2384

    
2385
    if (get_param_value(buf, sizeof(buf), "cache", str)) {
2386
        if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2387
            cache = 0;
2388
        else if (!strcmp(buf, "writethrough"))
2389
            cache = 1;
2390
        else if (!strcmp(buf, "writeback"))
2391
            cache = 2;
2392
        else {
2393
           fprintf(stderr, "qemu: invalid cache option\n");
2394
           return -1;
2395
        }
2396
    }
2397

    
2398
    if (get_param_value(buf, sizeof(buf), "format", str)) {
2399
       if (strcmp(buf, "?") == 0) {
2400
            fprintf(stderr, "qemu: Supported formats:");
2401
            bdrv_iterate_format(bdrv_format_print, NULL);
2402
            fprintf(stderr, "\n");
2403
            return -1;
2404
        }
2405
        drv = bdrv_find_format(buf);
2406
        if (!drv) {
2407
            fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2408
            return -1;
2409
        }
2410
    }
2411

    
2412
    if (arg->file == NULL)
2413
        get_param_value(file, sizeof(file), "file", str);
2414
    else
2415
        pstrcpy(file, sizeof(file), arg->file);
2416

    
2417
    if (!get_param_value(serial, sizeof(serial), "serial", str))
2418
            memset(serial, 0,  sizeof(serial));
2419

    
2420
    onerror = BLOCK_ERR_STOP_ENOSPC;
2421
    if (get_param_value(buf, sizeof(serial), "werror", str)) {
2422
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2423
            fprintf(stderr, "werror is no supported by this format\n");
2424
            return -1;
2425
        }
2426
        if (!strcmp(buf, "ignore"))
2427
            onerror = BLOCK_ERR_IGNORE;
2428
        else if (!strcmp(buf, "enospc"))
2429
            onerror = BLOCK_ERR_STOP_ENOSPC;
2430
        else if (!strcmp(buf, "stop"))
2431
            onerror = BLOCK_ERR_STOP_ANY;
2432
        else if (!strcmp(buf, "report"))
2433
            onerror = BLOCK_ERR_REPORT;
2434
        else {
2435
            fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2436
            return -1;
2437
        }
2438
    }
2439

    
2440
    /* compute bus and unit according index */
2441

    
2442
    if (index != -1) {
2443
        if (bus_id != 0 || unit_id != -1) {
2444
            fprintf(stderr,
2445
                    "qemu: '%s' index cannot be used with bus and unit\n", str);
2446
            return -1;
2447
        }
2448
        if (max_devs == 0)
2449
        {
2450
            unit_id = index;
2451
            bus_id = 0;
2452
        } else {
2453
            unit_id = index % max_devs;
2454
            bus_id = index / max_devs;
2455
        }
2456
    }
2457

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

    
2462
    if (unit_id == -1) {
2463
       unit_id = 0;
2464
       while (drive_get_index(type, bus_id, unit_id) != -1) {
2465
           unit_id++;
2466
           if (max_devs && unit_id >= max_devs) {
2467
               unit_id -= max_devs;
2468
               bus_id++;
2469
           }
2470
       }
2471
    }
2472

    
2473
    /* check unit id */
2474

    
2475
    if (max_devs && unit_id >= max_devs) {
2476
        fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2477
                        str, unit_id, max_devs - 1);
2478
        return -1;
2479
    }
2480

    
2481
    /*
2482
     * ignore multiple definitions
2483
     */
2484

    
2485
    if (drive_get_index(type, bus_id, unit_id) != -1)
2486
        return -2;
2487

    
2488
    /* init */
2489

    
2490
    if (type == IF_IDE || type == IF_SCSI)
2491
        mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2492
    if (max_devs)
2493
        snprintf(buf, sizeof(buf), "%s%i%s%i",
2494
                 devname, bus_id, mediastr, unit_id);
2495
    else
2496
        snprintf(buf, sizeof(buf), "%s%s%i",
2497
                 devname, mediastr, unit_id);
2498
    bdrv = bdrv_new(buf);
2499
    drives_table_idx = drive_get_free_idx();
2500
    drives_table[drives_table_idx].bdrv = bdrv;
2501
    drives_table[drives_table_idx].type = type;
2502
    drives_table[drives_table_idx].bus = bus_id;
2503
    drives_table[drives_table_idx].unit = unit_id;
2504
    drives_table[drives_table_idx].onerror = onerror;
2505
    drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
2506
    strncpy(drives_table[drives_table_idx].serial, serial, sizeof(serial));
2507
    nb_drives++;
2508

    
2509
    switch(type) {
2510
    case IF_IDE:
2511
    case IF_SCSI:
2512
    case IF_XEN:
2513
        switch(media) {
2514
        case MEDIA_DISK:
2515
            if (cyls != 0) {
2516
                bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2517
                bdrv_set_translation_hint(bdrv, translation);
2518
            }
2519
            break;
2520
        case MEDIA_CDROM:
2521
            bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2522
            break;
2523
        }
2524
        break;
2525
    case IF_SD:
2526
        /* FIXME: This isn't really a floppy, but it's a reasonable
2527
           approximation.  */
2528
    case IF_FLOPPY:
2529
        bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2530
        break;
2531
    case IF_PFLASH:
2532
    case IF_MTD:
2533
    case IF_VIRTIO:
2534
        break;
2535
    case IF_COUNT:
2536
        abort();
2537
    }
2538
    if (!file[0])
2539
        return -2;
2540
    bdrv_flags = 0;
2541
    if (snapshot) {
2542
        bdrv_flags |= BDRV_O_SNAPSHOT;
2543
        cache = 2; /* always use write-back with snapshot */
2544
    }
2545
    if (cache == 0) /* no caching */
2546
        bdrv_flags |= BDRV_O_NOCACHE;
2547
    else if (cache == 2) /* write-back */
2548
        bdrv_flags |= BDRV_O_CACHE_WB;
2549
    else if (cache == 3) /* not specified */
2550
        bdrv_flags |= BDRV_O_CACHE_DEF;
2551
    if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) {
2552
        fprintf(stderr, "qemu: could not open disk image %s\n",
2553
                        file);
2554
        return -1;
2555
    }
2556
    if (bdrv_key_required(bdrv))
2557
        autostart = 0;
2558
    return drives_table_idx;
2559
}
2560

    
2561
static void numa_add(const char *optarg)
2562
{
2563
    char option[128];
2564
    char *endptr;
2565
    unsigned long long value, endvalue;
2566
    int nodenr;
2567

    
2568
    optarg = get_opt_name(option, 128, optarg, ',') + 1;
2569
    if (!strcmp(option, "node")) {
2570
        if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2571
            nodenr = nb_numa_nodes;
2572
        } else {
2573
            nodenr = strtoull(option, NULL, 10);
2574
        }
2575

    
2576
        if (get_param_value(option, 128, "mem", optarg) == 0) {
2577
            node_mem[nodenr] = 0;
2578
        } else {
2579
            value = strtoull(option, &endptr, 0);
2580
            switch (*endptr) {
2581
            case 0: case 'M': case 'm':
2582
                value <<= 20;
2583
                break;
2584
            case 'G': case 'g':
2585
                value <<= 30;
2586
                break;
2587
            }
2588
            node_mem[nodenr] = value;
2589
        }
2590
        if (get_param_value(option, 128, "cpus", optarg) == 0) {
2591
            node_cpumask[nodenr] = 0;
2592
        } else {
2593
            value = strtoull(option, &endptr, 10);
2594
            if (value >= 64) {
2595
                value = 63;
2596
                fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2597
            } else {
2598
                if (*endptr == '-') {
2599
                    endvalue = strtoull(endptr+1, &endptr, 10);
2600
                    if (endvalue >= 63) {
2601
                        endvalue = 62;
2602
                        fprintf(stderr,
2603
                            "only 63 CPUs in NUMA mode supported.\n");
2604
                    }
2605
                    value = (1 << (endvalue + 1)) - (1 << value);
2606
                } else {
2607
                    value = 1 << value;
2608
                }
2609
            }
2610
            node_cpumask[nodenr] = value;
2611
        }
2612
        nb_numa_nodes++;
2613
    }
2614
    return;
2615
}
2616

    
2617
/***********************************************************/
2618
/* USB devices */
2619

    
2620
static USBPort *used_usb_ports;
2621
static USBPort *free_usb_ports;
2622

    
2623
/* ??? Maybe change this to register a hub to keep track of the topology.  */
2624
void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2625
                            usb_attachfn attach)
2626
{
2627
    port->opaque = opaque;
2628
    port->index = index;
2629
    port->attach = attach;
2630
    port->next = free_usb_ports;
2631
    free_usb_ports = port;
2632
}
2633

    
2634
int usb_device_add_dev(USBDevice *dev)
2635
{
2636
    USBPort *port;
2637

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

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

    
2648
        hub = usb_hub_init(VM_USB_HUB_SIZE);
2649
        usb_attach(port, hub);
2650
        port = free_usb_ports;
2651
    }
2652

    
2653
    free_usb_ports = port->next;
2654
    port->next = used_usb_ports;
2655
    used_usb_ports = port;
2656
    usb_attach(port, dev);
2657
    return 0;
2658
}
2659

    
2660
static void usb_msd_password_cb(void *opaque, int err)
2661
{
2662
    USBDevice *dev = opaque;
2663

    
2664
    if (!err)
2665
        usb_device_add_dev(dev);
2666
    else
2667
        dev->handle_destroy(dev);
2668
}
2669

    
2670
static int usb_device_add(const char *devname, int is_hotplug)
2671
{
2672
    const char *p;
2673
    USBDevice *dev;
2674

    
2675
    if (!free_usb_ports)
2676
        return -1;
2677

    
2678
    if (strstart(devname, "host:", &p)) {
2679
        dev = usb_host_device_open(p);
2680
    } else if (!strcmp(devname, "mouse")) {
2681
        dev = usb_mouse_init();
2682
    } else if (!strcmp(devname, "tablet")) {
2683
        dev = usb_tablet_init();
2684
    } else if (!strcmp(devname, "keyboard")) {
2685
        dev = usb_keyboard_init();
2686
    } else if (strstart(devname, "disk:", &p)) {
2687
        BlockDriverState *bs;
2688

    
2689
        dev = usb_msd_init(p);
2690
        if (!dev)
2691
            return -1;
2692
        bs = usb_msd_get_bdrv(dev);
2693
        if (bdrv_key_required(bs)) {
2694
            autostart = 0;
2695
            if (is_hotplug) {
2696
                monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
2697
                                            dev);
2698
                return 0;
2699
            }
2700
        }
2701
    } else if (!strcmp(devname, "wacom-tablet")) {
2702
        dev = usb_wacom_init();
2703
    } else if (strstart(devname, "serial:", &p)) {
2704
        dev = usb_serial_init(p);
2705
#ifdef CONFIG_BRLAPI
2706
    } else if (!strcmp(devname, "braille")) {
2707
        dev = usb_baum_init();
2708
#endif
2709
    } else if (strstart(devname, "net:", &p)) {
2710
        int nic = nb_nics;
2711

    
2712
        if (net_client_init("nic", p) < 0)
2713
            return -1;
2714
        nd_table[nic].model = "usb";
2715
        dev = usb_net_init(&nd_table[nic]);
2716
    } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2717
        dev = usb_bt_init(devname[2] ? hci_init(p) :
2718
                        bt_new_hci(qemu_find_bt_vlan(0)));
2719
    } else {
2720
        return -1;
2721
    }
2722
    if (!dev)
2723
        return -1;
2724

    
2725
    return usb_device_add_dev(dev);
2726
}
2727

    
2728
int usb_device_del_addr(int bus_num, int addr)
2729
{
2730
    USBPort *port;
2731
    USBPort **lastp;
2732
    USBDevice *dev;
2733

    
2734
    if (!used_usb_ports)
2735
        return -1;
2736

    
2737
    if (bus_num != 0)
2738
        return -1;
2739

    
2740
    lastp = &used_usb_ports;
2741
    port = used_usb_ports;
2742
    while (port && port->dev->addr != addr) {
2743
        lastp = &port->next;
2744
        port = port->next;
2745
    }
2746

    
2747
    if (!port)
2748
        return -1;
2749

    
2750
    dev = port->dev;
2751
    *lastp = port->next;
2752
    usb_attach(port, NULL);
2753
    dev->handle_destroy(dev);
2754
    port->next = free_usb_ports;
2755
    free_usb_ports = port;
2756
    return 0;
2757
}
2758

    
2759
static int usb_device_del(const char *devname)
2760
{
2761
    int bus_num, addr;
2762
    const char *p;
2763

    
2764
    if (strstart(devname, "host:", &p))
2765
        return usb_host_device_close(p);
2766

    
2767
    if (!used_usb_ports)
2768
        return -1;
2769

    
2770
    p = strchr(devname, '.');
2771
    if (!p)
2772
        return -1;
2773
    bus_num = strtoul(devname, NULL, 0);
2774
    addr = strtoul(p + 1, NULL, 0);
2775

    
2776
    return usb_device_del_addr(bus_num, addr);
2777
}
2778

    
2779
void do_usb_add(Monitor *mon, const char *devname)
2780
{
2781
    usb_device_add(devname, 1);
2782
}
2783

    
2784
void do_usb_del(Monitor *mon, const char *devname)
2785
{
2786
    usb_device_del(devname);
2787
}
2788

    
2789
void usb_info(Monitor *mon)
2790
{
2791
    USBDevice *dev;
2792
    USBPort *port;
2793
    const char *speed_str;
2794

    
2795
    if (!usb_enabled) {
2796
        monitor_printf(mon, "USB support not enabled\n");
2797
        return;
2798
    }
2799

    
2800
    for (port = used_usb_ports; port; port = port->next) {
2801
        dev = port->dev;
2802
        if (!dev)
2803
            continue;
2804
        switch(dev->speed) {
2805
        case USB_SPEED_LOW:
2806
            speed_str = "1.5";
2807
            break;
2808
        case USB_SPEED_FULL:
2809
            speed_str = "12";
2810
            break;
2811
        case USB_SPEED_HIGH:
2812
            speed_str = "480";
2813
            break;
2814
        default:
2815
            speed_str = "?";
2816
            break;
2817
        }
2818
        monitor_printf(mon, "  Device %d.%d, Speed %s Mb/s, Product %s\n",
2819
                       0, dev->addr, speed_str, dev->devname);
2820
    }
2821
}
2822

    
2823
/***********************************************************/
2824
/* PCMCIA/Cardbus */
2825

    
2826
static struct pcmcia_socket_entry_s {
2827
    PCMCIASocket *socket;
2828
    struct pcmcia_socket_entry_s *next;
2829
} *pcmcia_sockets = 0;
2830

    
2831
void pcmcia_socket_register(PCMCIASocket *socket)
2832
{
2833
    struct pcmcia_socket_entry_s *entry;
2834

    
2835
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2836
    entry->socket = socket;
2837
    entry->next = pcmcia_sockets;
2838
    pcmcia_sockets = entry;
2839
}
2840

    
2841
void pcmcia_socket_unregister(PCMCIASocket *socket)
2842
{
2843
    struct pcmcia_socket_entry_s *entry, **ptr;
2844

    
2845
    ptr = &pcmcia_sockets;
2846
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2847
        if (entry->socket == socket) {
2848
            *ptr = entry->next;
2849
            qemu_free(entry);
2850
        }
2851
}
2852

    
2853
void pcmcia_info(Monitor *mon)
2854
{
2855
    struct pcmcia_socket_entry_s *iter;
2856

    
2857
    if (!pcmcia_sockets)
2858
        monitor_printf(mon, "No PCMCIA sockets\n");
2859

    
2860
    for (iter = pcmcia_sockets; iter; iter = iter->next)
2861
        monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2862
                       iter->socket->attached ? iter->socket->card_string :
2863
                       "Empty");
2864
}
2865

    
2866
/***********************************************************/
2867
/* register display */
2868

    
2869
struct DisplayAllocator default_allocator = {
2870
    defaultallocator_create_displaysurface,
2871
    defaultallocator_resize_displaysurface,
2872
    defaultallocator_free_displaysurface
2873
};
2874

    
2875
void register_displaystate(DisplayState *ds)
2876
{
2877
    DisplayState **s;
2878
    s = &display_state;
2879
    while (*s != NULL)
2880
        s = &(*s)->next;
2881
    ds->next = NULL;
2882
    *s = ds;
2883
}
2884

    
2885
DisplayState *get_displaystate(void)
2886
{
2887
    return display_state;
2888
}
2889

    
2890
DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2891
{
2892
    if(ds->allocator ==  &default_allocator) ds->allocator = da;
2893
    return ds->allocator;
2894
}
2895

    
2896
/* dumb display */
2897

    
2898
static void dumb_display_init(void)
2899
{
2900
    DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2901
    ds->allocator = &default_allocator;
2902
    ds->surface = qemu_create_displaysurface(ds, 640, 480);
2903
    register_displaystate(ds);
2904
}
2905

    
2906
/***********************************************************/
2907
/* I/O handling */
2908

    
2909
typedef struct IOHandlerRecord {
2910
    int fd;
2911
    IOCanRWHandler *fd_read_poll;
2912
    IOHandler *fd_read;
2913
    IOHandler *fd_write;
2914
    int deleted;
2915
    void *opaque;
2916
    /* temporary data */
2917
    struct pollfd *ufd;
2918
    struct IOHandlerRecord *next;
2919
} IOHandlerRecord;
2920

    
2921
static IOHandlerRecord *first_io_handler;
2922

    
2923
/* XXX: fd_read_poll should be suppressed, but an API change is
2924
   necessary in the character devices to suppress fd_can_read(). */
2925
int qemu_set_fd_handler2(int fd,
2926
                         IOCanRWHandler *fd_read_poll,
2927
                         IOHandler *fd_read,
2928
                         IOHandler *fd_write,
2929
                         void *opaque)
2930
{
2931
    IOHandlerRecord **pioh, *ioh;
2932

    
2933
    if (!fd_read && !fd_write) {
2934
        pioh = &first_io_handler;
2935
        for(;;) {
2936
            ioh = *pioh;
2937
            if (ioh == NULL)
2938
                break;
2939
            if (ioh->fd == fd) {
2940
                ioh->deleted = 1;
2941
                break;
2942
            }
2943
            pioh = &ioh->next;
2944
        }
2945
    } else {
2946
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2947
            if (ioh->fd == fd)
2948
                goto found;
2949
        }
2950
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2951
        ioh->next = first_io_handler;
2952
        first_io_handler = ioh;
2953
    found:
2954
        ioh->fd = fd;
2955
        ioh->fd_read_poll = fd_read_poll;
2956
        ioh->fd_read = fd_read;
2957
        ioh->fd_write = fd_write;
2958
        ioh->opaque = opaque;
2959
        ioh->deleted = 0;
2960
    }
2961
    return 0;
2962
}
2963

    
2964
int qemu_set_fd_handler(int fd,
2965
                        IOHandler *fd_read,
2966
                        IOHandler *fd_write,
2967
                        void *opaque)
2968
{
2969
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2970
}
2971

    
2972
#ifdef _WIN32
2973
/***********************************************************/
2974
/* Polling handling */
2975

    
2976
typedef struct PollingEntry {
2977
    PollingFunc *func;
2978
    void *opaque;
2979
    struct PollingEntry *next;
2980
} PollingEntry;
2981

    
2982
static PollingEntry *first_polling_entry;
2983

    
2984
int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2985
{
2986
    PollingEntry **ppe, *pe;
2987
    pe = qemu_mallocz(sizeof(PollingEntry));
2988
    pe->func = func;
2989
    pe->opaque = opaque;
2990
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2991
    *ppe = pe;
2992
    return 0;
2993
}
2994

    
2995
void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2996
{
2997
    PollingEntry **ppe, *pe;
2998
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2999
        pe = *ppe;
3000
        if (pe->func == func && pe->opaque == opaque) {
3001
            *ppe = pe->next;
3002
            qemu_free(pe);
3003
            break;
3004
        }
3005
    }
3006
}
3007

    
3008
/***********************************************************/
3009
/* Wait objects support */
3010
typedef struct WaitObjects {
3011
    int num;
3012
    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
3013
    WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
3014
    void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
3015
} WaitObjects;
3016

    
3017
static WaitObjects wait_objects = {0};
3018

    
3019
int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3020
{
3021
    WaitObjects *w = &wait_objects;
3022

    
3023
    if (w->num >= MAXIMUM_WAIT_OBJECTS)
3024
        return -1;
3025
    w->events[w->num] = handle;
3026
    w->func[w->num] = func;
3027
    w->opaque[w->num] = opaque;
3028
    w->num++;
3029
    return 0;
3030
}
3031

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

    
3037
    found = 0;
3038
    for (i = 0; i < w->num; i++) {
3039
        if (w->events[i] == handle)
3040
            found = 1;
3041
        if (found) {
3042
            w->events[i] = w->events[i + 1];
3043
            w->func[i] = w->func[i + 1];
3044
            w->opaque[i] = w->opaque[i + 1];
3045
        }
3046
    }
3047
    if (found)
3048
        w->num--;
3049
}
3050
#endif
3051

    
3052
/***********************************************************/
3053
/* ram save/restore */
3054

    
3055
static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3056
{
3057
    int v;
3058

    
3059
    v = qemu_get_byte(f);
3060
    switch(v) {
3061
    case 0:
3062
        if (qemu_get_buffer(f, buf, len) != len)
3063
            return -EIO;
3064
        break;
3065
    case 1:
3066
        v = qemu_get_byte(f);
3067
        memset(buf, v, len);
3068
        break;
3069
    default:
3070
        return -EINVAL;
3071
    }
3072

    
3073
    if (qemu_file_has_error(f))
3074
        return -EIO;
3075

    
3076
    return 0;
3077
}
3078

    
3079
static int ram_load_v1(QEMUFile *f, void *opaque)
3080
{
3081
    int ret;
3082
    ram_addr_t i;
3083

    
3084
    if (qemu_get_be32(f) != last_ram_offset)
3085
        return -EINVAL;
3086
    for(i = 0; i < last_ram_offset; i+= TARGET_PAGE_SIZE) {
3087
        ret = ram_get_page(f, qemu_get_ram_ptr(i), TARGET_PAGE_SIZE);
3088
        if (ret)
3089
            return ret;
3090
    }
3091
    return 0;
3092
}
3093

    
3094
#define BDRV_HASH_BLOCK_SIZE 1024
3095
#define IOBUF_SIZE 4096
3096
#define RAM_CBLOCK_MAGIC 0xfabe
3097

    
3098
typedef struct RamDecompressState {
3099
    z_stream zstream;
3100
    QEMUFile *f;
3101
    uint8_t buf[IOBUF_SIZE];
3102
} RamDecompressState;
3103

    
3104
static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3105
{
3106
    int ret;
3107
    memset(s, 0, sizeof(*s));
3108
    s->f = f;
3109
    ret = inflateInit(&s->zstream);
3110
    if (ret != Z_OK)
3111
        return -1;
3112
    return 0;
3113
}
3114

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

    
3119
    s->zstream.avail_out = len;
3120
    s->zstream.next_out = buf;
3121
    while (s->zstream.avail_out > 0) {
3122
        if (s->zstream.avail_in == 0) {
3123
            if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3124
                return -1;
3125
            clen = qemu_get_be16(s->f);
3126
            if (clen > IOBUF_SIZE)
3127
                return -1;
3128
            qemu_get_buffer(s->f, s->buf, clen);
3129
            s->zstream.avail_in = clen;
3130
            s->zstream.next_in = s->buf;
3131
        }
3132
        ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3133
        if (ret != Z_OK && ret != Z_STREAM_END) {
3134
            return -1;
3135
        }
3136
    }
3137
    return 0;
3138
}
3139

    
3140
static void ram_decompress_close(RamDecompressState *s)
3141
{
3142
    inflateEnd(&s->zstream);
3143
}
3144

    
3145
#define RAM_SAVE_FLAG_FULL        0x01
3146
#define RAM_SAVE_FLAG_COMPRESS        0x02
3147
#define RAM_SAVE_FLAG_MEM_SIZE        0x04
3148
#define RAM_SAVE_FLAG_PAGE        0x08
3149
#define RAM_SAVE_FLAG_EOS        0x10
3150

    
3151
static int is_dup_page(uint8_t *page, uint8_t ch)
3152
{
3153
    uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3154
    uint32_t *array = (uint32_t *)page;
3155
    int i;
3156

    
3157
    for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3158
        if (array[i] != val)
3159
            return 0;
3160
    }
3161

    
3162
    return 1;
3163
}
3164

    
3165
static int ram_save_block(QEMUFile *f)
3166
{
3167
    static ram_addr_t current_addr = 0;
3168
    ram_addr_t saved_addr = current_addr;
3169
    ram_addr_t addr = 0;
3170
    int found = 0;
3171

    
3172
    while (addr < last_ram_offset) {
3173
        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3174
            uint8_t *p;
3175

    
3176
            cpu_physical_memory_reset_dirty(current_addr,
3177
                                            current_addr + TARGET_PAGE_SIZE,
3178
                                            MIGRATION_DIRTY_FLAG);
3179

    
3180
            p = qemu_get_ram_ptr(current_addr);
3181

    
3182
            if (is_dup_page(p, *p)) {
3183
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3184
                qemu_put_byte(f, *p);
3185
            } else {
3186
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3187
                qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
3188
            }
3189

    
3190
            found = 1;
3191
            break;
3192
        }
3193
        addr += TARGET_PAGE_SIZE;
3194
        current_addr = (saved_addr + addr) % last_ram_offset;
3195
    }
3196

    
3197
    return found;
3198
}
3199

    
3200
static ram_addr_t ram_save_threshold = 10;
3201
static uint64_t bytes_transferred = 0;
3202

    
3203
static ram_addr_t ram_save_remaining(void)
3204
{
3205
    ram_addr_t addr;
3206
    ram_addr_t count = 0;
3207

    
3208
    for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3209
        if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3210
            count++;
3211
    }
3212

    
3213
    return count;
3214
}
3215

    
3216
uint64_t ram_bytes_remaining(void)
3217
{
3218
    return ram_save_remaining() * TARGET_PAGE_SIZE;
3219
}
3220

    
3221
uint64_t ram_bytes_transferred(void)
3222
{
3223
    return bytes_transferred;
3224
}
3225

    
3226
uint64_t ram_bytes_total(void)
3227
{
3228
    return last_ram_offset;
3229
}
3230

    
3231
static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3232
{
3233
    ram_addr_t addr;
3234

    
3235
    if (cpu_physical_sync_dirty_bitmap(0, last_ram_offset) != 0) {
3236
        qemu_file_set_error(f);
3237
        return 0;
3238
    }
3239

    
3240
    if (stage == 1) {
3241
        /* Make sure all dirty bits are set */
3242
        for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3243
            if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3244
                cpu_physical_memory_set_dirty(addr);
3245
        }
3246

    
3247
        /* Enable dirty memory tracking */
3248
        cpu_physical_memory_set_dirty_tracking(1);
3249

    
3250
        qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
3251
    }
3252

    
3253
    while (!qemu_file_rate_limit(f)) {
3254
        int ret;
3255

    
3256
        ret = ram_save_block(f);
3257
        bytes_transferred += ret * TARGET_PAGE_SIZE;
3258
        if (ret == 0) /* no more blocks */
3259
            break;
3260
    }
3261

    
3262
    /* try transferring iterative blocks of memory */
3263

    
3264
    if (stage == 3) {
3265

    
3266
        /* flush all remaining blocks regardless of rate limiting */
3267
        while (ram_save_block(f) != 0) {
3268
            bytes_transferred += TARGET_PAGE_SIZE;
3269
        }
3270
        cpu_physical_memory_set_dirty_tracking(0);
3271
    }
3272

    
3273
    qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3274

    
3275
    return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3276
}
3277

    
3278
static int ram_load_dead(QEMUFile *f, void *opaque)
3279
{
3280
    RamDecompressState s1, *s = &s1;
3281
    uint8_t buf[10];
3282
    ram_addr_t i;
3283

    
3284
    if (ram_decompress_open(s, f) < 0)
3285
        return -EINVAL;
3286
    for(i = 0; i < last_ram_offset; i+= BDRV_HASH_BLOCK_SIZE) {
3287
        if (ram_decompress_buf(s, buf, 1) < 0) {
3288
            fprintf(stderr, "Error while reading ram block header\n");
3289
            goto error;
3290
        }
3291
        if (buf[0] == 0) {
3292
            if (ram_decompress_buf(s, qemu_get_ram_ptr(i),
3293
                                   BDRV_HASH_BLOCK_SIZE) < 0) {
3294
                fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3295
                goto error;
3296
            }
3297
        } else {
3298
        error:
3299
            printf("Error block header\n");
3300
            return -EINVAL;
3301
        }
3302
    }
3303
    ram_decompress_close(s);
3304

    
3305
    return 0;
3306
}
3307

    
3308
static int ram_load(QEMUFile *f, void *opaque, int version_id)
3309
{
3310
    ram_addr_t addr;
3311
    int flags;
3312

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

    
3316
    if (version_id == 2) {
3317
        if (qemu_get_be32(f) != last_ram_offset)
3318
            return -EINVAL;
3319
        return ram_load_dead(f, opaque);
3320
    }
3321

    
3322
    if (version_id != 3)
3323
        return -EINVAL;
3324

    
3325
    do {
3326
        addr = qemu_get_be64(f);
3327

    
3328
        flags = addr & ~TARGET_PAGE_MASK;
3329
        addr &= TARGET_PAGE_MASK;
3330

    
3331
        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3332
            if (addr != last_ram_offset)
3333
                return -EINVAL;
3334
        }
3335

    
3336
        if (flags & RAM_SAVE_FLAG_FULL) {
3337
            if (ram_load_dead(f, opaque) < 0)
3338
                return -EINVAL;
3339
        }
3340
        
3341
        if (flags & RAM_SAVE_FLAG_COMPRESS) {
3342
            uint8_t ch = qemu_get_byte(f);
3343
            memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
3344
        } else if (flags & RAM_SAVE_FLAG_PAGE)
3345
            qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
3346
    } while (!(flags & RAM_SAVE_FLAG_EOS));
3347

    
3348
    return 0;
3349
}
3350

    
3351
void qemu_service_io(void)
3352
{
3353
    qemu_notify_event();
3354
}
3355

    
3356
/***********************************************************/
3357
/* bottom halves (can be seen as timers which expire ASAP) */
3358

    
3359
struct QEMUBH {
3360
    QEMUBHFunc *cb;
3361
    void *opaque;
3362
    int scheduled;
3363
    int idle;
3364
    int deleted;
3365
    QEMUBH *next;
3366
};
3367

    
3368
static QEMUBH *first_bh = NULL;
3369

    
3370
QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3371
{
3372
    QEMUBH *bh;
3373
    bh = qemu_mallocz(sizeof(QEMUBH));
3374
    bh->cb = cb;
3375
    bh->opaque = opaque;
3376
    bh->next = first_bh;
3377
    first_bh = bh;
3378
    return bh;
3379
}
3380

    
3381
int qemu_bh_poll(void)
3382
{
3383
    QEMUBH *bh, **bhp;
3384
    int ret;
3385

    
3386
    ret = 0;
3387
    for (bh = first_bh; bh; bh = bh->next) {
3388
        if (!bh->deleted && bh->scheduled) {
3389
            bh->scheduled = 0;
3390
            if (!bh->idle)
3391
                ret = 1;
3392
            bh->idle = 0;
3393
            bh->cb(bh->opaque);
3394
        }
3395
    }
3396

    
3397
    /* remove deleted bhs */
3398
    bhp = &first_bh;
3399
    while (*bhp) {
3400
        bh = *bhp;
3401
        if (bh->deleted) {
3402
            *bhp = bh->next;
3403
            qemu_free(bh);
3404
        } else
3405
            bhp = &bh->next;
3406
    }
3407

    
3408
    return ret;
3409
}
3410

    
3411
void qemu_bh_schedule_idle(QEMUBH *bh)
3412
{
3413
    if (bh->scheduled)
3414
        return;
3415
    bh->scheduled = 1;
3416
    bh->idle = 1;
3417
}
3418

    
3419
void qemu_bh_schedule(QEMUBH *bh)
3420
{
3421
    if (bh->scheduled)
3422
        return;
3423
    bh->scheduled = 1;
3424
    bh->idle = 0;
3425
    /* stop the currently executing CPU to execute the BH ASAP */
3426
    qemu_notify_event();
3427
}
3428

    
3429
void qemu_bh_cancel(QEMUBH *bh)
3430
{
3431
    bh->scheduled = 0;
3432
}
3433

    
3434
void qemu_bh_delete(QEMUBH *bh)
3435
{
3436
    bh->scheduled = 0;
3437
    bh->deleted = 1;
3438
}
3439

    
3440
static void qemu_bh_update_timeout(int *timeout)
3441
{
3442
    QEMUBH *bh;
3443

    
3444
    for (bh = first_bh; bh; bh = bh->next) {
3445
        if (!bh->deleted && bh->scheduled) {
3446
            if (bh->idle) {
3447
                /* idle bottom halves will be polled at least
3448
                 * every 10ms */
3449
                *timeout = MIN(10, *timeout);
3450
            } else {
3451
                /* non-idle bottom halves will be executed
3452
                 * immediately */
3453
                *timeout = 0;
3454
                break;
3455
            }
3456
        }
3457
    }
3458
}
3459

    
3460
/***********************************************************/
3461
/* machine registration */
3462

    
3463
static QEMUMachine *first_machine = NULL;
3464
QEMUMachine *current_machine = NULL;
3465

    
3466
int qemu_register_machine(QEMUMachine *m)
3467
{
3468
    QEMUMachine **pm;
3469
    pm = &first_machine;
3470
    while (*pm != NULL)
3471
        pm = &(*pm)->next;
3472
    m->next = NULL;
3473
    *pm = m;
3474
    return 0;
3475
}
3476

    
3477
static QEMUMachine *find_machine(const char *name)
3478
{
3479
    QEMUMachine *m;
3480

    
3481
    for(m = first_machine; m != NULL; m = m->next) {
3482
        if (!strcmp(m->name, name))
3483
            return m;
3484
    }
3485
    return NULL;
3486
}
3487

    
3488
static QEMUMachine *find_default_machine(void)
3489
{
3490
    QEMUMachine *m;
3491

    
3492
    for(m = first_machine; m != NULL; m = m->next) {
3493
        if (m->is_default) {
3494
            return m;
3495
        }
3496
    }
3497
    return NULL;
3498
}
3499

    
3500
/***********************************************************/
3501
/* main execution loop */
3502

    
3503
static void gui_update(void *opaque)
3504
{
3505
    uint64_t interval = GUI_REFRESH_INTERVAL;
3506
    DisplayState *ds = opaque;
3507
    DisplayChangeListener *dcl = ds->listeners;
3508

    
3509
    dpy_refresh(ds);
3510

    
3511
    while (dcl != NULL) {
3512
        if (dcl->gui_timer_interval &&
3513
            dcl->gui_timer_interval < interval)
3514
            interval = dcl->gui_timer_interval;
3515
        dcl = dcl->next;
3516
    }
3517
    qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3518
}
3519

    
3520
static void nographic_update(void *opaque)
3521
{
3522
    uint64_t interval = GUI_REFRESH_INTERVAL;
3523

    
3524
    qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3525
}
3526

    
3527
struct vm_change_state_entry {
3528
    VMChangeStateHandler *cb;
3529
    void *opaque;
3530
    LIST_ENTRY (vm_change_state_entry) entries;
3531
};
3532

    
3533
static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3534

    
3535
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3536
                                                     void *opaque)
3537
{
3538
    VMChangeStateEntry *e;
3539

    
3540
    e = qemu_mallocz(sizeof (*e));
3541

    
3542
    e->cb = cb;
3543
    e->opaque = opaque;
3544
    LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3545
    return e;
3546
}
3547

    
3548
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3549
{
3550
    LIST_REMOVE (e, entries);
3551
    qemu_free (e);
3552
}
3553

    
3554
static void vm_state_notify(int running, int reason)
3555
{
3556
    VMChangeStateEntry *e;
3557

    
3558
    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3559
        e->cb(e->opaque, running, reason);
3560
    }
3561
}
3562

    
3563
static void resume_all_vcpus(void);
3564
static void pause_all_vcpus(void);
3565

    
3566
void vm_start(void)
3567
{
3568
    if (!vm_running) {
3569
        cpu_enable_ticks();
3570
        vm_running = 1;
3571
        vm_state_notify(1, 0);
3572
        qemu_rearm_alarm_timer(alarm_timer);
3573
        resume_all_vcpus();
3574
    }
3575
}
3576

    
3577
/* reset/shutdown handler */
3578

    
3579
typedef struct QEMUResetEntry {
3580
    QEMUResetHandler *func;
3581
    void *opaque;
3582
    struct QEMUResetEntry *next;
3583
} QEMUResetEntry;
3584

    
3585
static QEMUResetEntry *first_reset_entry;
3586
static int reset_requested;
3587
static int shutdown_requested;
3588
static int powerdown_requested;
3589
static int debug_requested;
3590
static int vmstop_requested;
3591

    
3592
int qemu_shutdown_requested(void)
3593
{
3594
    int r = shutdown_requested;
3595
    shutdown_requested = 0;
3596
    return r;
3597
}
3598

    
3599
int qemu_reset_requested(void)
3600
{
3601
    int r = reset_requested;
3602
    reset_requested = 0;
3603
    return r;
3604
}
3605

    
3606
int qemu_powerdown_requested(void)
3607
{
3608
    int r = powerdown_requested;
3609
    powerdown_requested = 0;
3610
    return r;
3611
}
3612

    
3613
static int qemu_debug_requested(void)
3614
{
3615
    int r = debug_requested;
3616
    debug_requested = 0;
3617
    return r;
3618
}
3619

    
3620
static int qemu_vmstop_requested(void)
3621
{
3622
    int r = vmstop_requested;
3623
    vmstop_requested = 0;
3624
    return r;
3625
}
3626

    
3627
static void do_vm_stop(int reason)
3628
{
3629
    if (vm_running) {
3630
        cpu_disable_ticks();
3631
        vm_running = 0;
3632
        pause_all_vcpus();
3633
        vm_state_notify(0, reason);
3634
    }
3635
}
3636

    
3637
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3638
{
3639
    QEMUResetEntry **pre, *re;
3640

    
3641
    pre = &first_reset_entry;
3642
    while (*pre != NULL)
3643
        pre = &(*pre)->next;
3644
    re = qemu_mallocz(sizeof(QEMUResetEntry));
3645
    re->func = func;
3646
    re->opaque = opaque;
3647
    re->next = NULL;
3648
    *pre = re;
3649
}
3650

    
3651
void qemu_system_reset(void)
3652
{
3653
    QEMUResetEntry *re;
3654

    
3655
    /* reset all devices */
3656
    for(re = first_reset_entry; re != NULL; re = re->next) {
3657
        re->func(re->opaque);
3658
    }
3659
    if (kvm_enabled())
3660
        kvm_sync_vcpus();
3661
}
3662

    
3663
void qemu_system_reset_request(void)
3664
{
3665
    if (no_reboot) {
3666
        shutdown_requested = 1;
3667
    } else {
3668
        reset_requested = 1;
3669
    }
3670
    qemu_notify_event();
3671
}
3672

    
3673
void qemu_system_shutdown_request(void)
3674
{
3675
    shutdown_requested = 1;
3676
    qemu_notify_event();
3677
}
3678

    
3679
void qemu_system_powerdown_request(void)
3680
{
3681
    powerdown_requested = 1;
3682
    qemu_notify_event();
3683
}
3684

    
3685
#ifdef CONFIG_IOTHREAD
3686
static void qemu_system_vmstop_request(int reason)
3687
{
3688
    vmstop_requested = reason;
3689
    qemu_notify_event();
3690
}
3691
#endif
3692

    
3693
#ifndef _WIN32
3694
static int io_thread_fd = -1;
3695

    
3696
static void qemu_event_increment(void)
3697
{
3698
    static const char byte = 0;
3699

    
3700
    if (io_thread_fd == -1)
3701
        return;
3702

    
3703
    write(io_thread_fd, &byte, sizeof(byte));
3704
}
3705

    
3706
static void qemu_event_read(void *opaque)
3707
{
3708
    int fd = (unsigned long)opaque;
3709
    ssize_t len;
3710

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

    
3718
static int qemu_event_init(void)
3719
{
3720
    int err;
3721
    int fds[2];
3722

    
3723
    err = pipe(fds);
3724
    if (err == -1)
3725
        return -errno;
3726

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

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

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

    
3738
    io_thread_fd = fds[1];
3739
    return 0;
3740

    
3741
fail:
3742
    close(fds[0]);
3743
    close(fds[1]);
3744
    return err;
3745
}
3746
#else
3747
HANDLE qemu_event_handle;
3748

    
3749
static void dummy_event_handler(void *opaque)
3750
{
3751
}
3752

    
3753
static int qemu_event_init(void)
3754
{
3755
    qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3756
    if (!qemu_event_handle) {
3757
        perror("Failed CreateEvent");
3758
        return -1;
3759
    }
3760
    qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3761
    return 0;
3762
}
3763

    
3764
static void qemu_event_increment(void)
3765
{
3766
    SetEvent(qemu_event_handle);
3767
}
3768
#endif
3769

    
3770
static int cpu_can_run(CPUState *env)
3771
{
3772
    if (env->stop)
3773
        return 0;
3774
    if (env->stopped)
3775
        return 0;
3776
    return 1;
3777
}
3778

    
3779
#ifndef CONFIG_IOTHREAD
3780
static int qemu_init_main_loop(void)
3781
{
3782
    return qemu_event_init();
3783
}
3784

    
3785
void qemu_init_vcpu(void *_env)
3786
{
3787
    CPUState *env = _env;
3788

    
3789
    if (kvm_enabled())
3790
        kvm_init_vcpu(env);
3791
    return;
3792
}
3793

    
3794
int qemu_cpu_self(void *env)
3795
{
3796
    return 1;
3797
}
3798

    
3799
static void resume_all_vcpus(void)
3800
{
3801
}
3802

    
3803
static void pause_all_vcpus(void)
3804
{
3805
}
3806

    
3807
void qemu_cpu_kick(void *env)
3808
{
3809
    return;
3810
}
3811

    
3812
void qemu_notify_event(void)
3813
{
3814
    CPUState *env = cpu_single_env;
3815

    
3816
    if (env) {
3817
        cpu_exit(env);
3818
#ifdef USE_KQEMU
3819
        if (env->kqemu_enabled)
3820
            kqemu_cpu_interrupt(env);
3821
#endif
3822
     }
3823
}
3824

    
3825
#define qemu_mutex_lock_iothread() do { } while (0)
3826
#define qemu_mutex_unlock_iothread() do { } while (0)
3827

    
3828
void vm_stop(int reason)
3829
{
3830
    do_vm_stop(reason);
3831
}
3832

    
3833
#else /* CONFIG_IOTHREAD */
3834

    
3835
#include "qemu-thread.h"
3836

    
3837
QemuMutex qemu_global_mutex;
3838
static QemuMutex qemu_fair_mutex;
3839

    
3840
static QemuThread io_thread;
3841

    
3842
static QemuThread *tcg_cpu_thread;
3843
static QemuCond *tcg_halt_cond;
3844

    
3845
static int qemu_system_ready;
3846
/* cpu creation */
3847
static QemuCond qemu_cpu_cond;
3848
/* system init */
3849
static QemuCond qemu_system_cond;
3850
static QemuCond qemu_pause_cond;
3851

    
3852
static void block_io_signals(void);
3853
static void unblock_io_signals(void);
3854
static int tcg_has_work(void);
3855

    
3856
static int qemu_init_main_loop(void)
3857
{
3858
    int ret;
3859

    
3860
    ret = qemu_event_init();
3861
    if (ret)
3862
        return ret;
3863

    
3864
    qemu_cond_init(&qemu_pause_cond);
3865
    qemu_mutex_init(&qemu_fair_mutex);
3866
    qemu_mutex_init(&qemu_global_mutex);
3867
    qemu_mutex_lock(&qemu_global_mutex);
3868

    
3869
    unblock_io_signals();
3870
    qemu_thread_self(&io_thread);
3871

    
3872
    return 0;
3873
}
3874

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

    
3880
    qemu_mutex_unlock(&qemu_global_mutex);
3881

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

    
3890
    qemu_mutex_lock(&qemu_global_mutex);
3891
    if (env->stop) {
3892
        env->stop = 0;
3893
        env->stopped = 1;
3894
        qemu_cond_signal(&qemu_pause_cond);
3895
    }
3896
}
3897

    
3898
static int qemu_cpu_exec(CPUState *env);
3899

    
3900
static void *kvm_cpu_thread_fn(void *arg)
3901
{
3902
    CPUState *env = arg;
3903

    
3904
    block_io_signals();
3905
    qemu_thread_self(env->thread);
3906

    
3907
    /* signal CPU creation */
3908
    qemu_mutex_lock(&qemu_global_mutex);
3909
    env->created = 1;
3910
    qemu_cond_signal(&qemu_cpu_cond);
3911

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

    
3916
    while (1) {
3917
        if (cpu_can_run(env))
3918
            qemu_cpu_exec(env);
3919
        qemu_wait_io_event(env);
3920
    }
3921

    
3922
    return NULL;
3923
}
3924

    
3925
static void tcg_cpu_exec(void);
3926

    
3927
static void *tcg_cpu_thread_fn(void *arg)
3928
{
3929
    CPUState *env = arg;
3930

    
3931
    block_io_signals();
3932
    qemu_thread_self(env->thread);
3933

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

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

    
3944
    while (1) {
3945
        tcg_cpu_exec();
3946
        qemu_wait_io_event(cur_cpu);
3947
    }
3948

    
3949
    return NULL;
3950
}
3951

    
3952
void qemu_cpu_kick(void *_env)
3953
{
3954
    CPUState *env = _env;
3955
    qemu_cond_broadcast(env->halt_cond);
3956
    if (kvm_enabled())
3957
        qemu_thread_signal(env->thread, SIGUSR1);
3958
}
3959

    
3960
int qemu_cpu_self(void *env)
3961
{
3962
    return (cpu_single_env != NULL);
3963
}
3964

    
3965
static void cpu_signal(int sig)
3966
{
3967
    if (cpu_single_env)
3968
        cpu_exit(cpu_single_env);
3969
}
3970

    
3971
static void block_io_signals(void)
3972
{
3973
    sigset_t set;
3974
    struct sigaction sigact;
3975

    
3976
    sigemptyset(&set);
3977
    sigaddset(&set, SIGUSR2);
3978
    sigaddset(&set, SIGIO);
3979
    sigaddset(&set, SIGALRM);
3980
    pthread_sigmask(SIG_BLOCK, &set, NULL);
3981

    
3982
    sigemptyset(&set);
3983
    sigaddset(&set, SIGUSR1);
3984
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3985

    
3986
    memset(&sigact, 0, sizeof(sigact));
3987
    sigact.sa_handler = cpu_signal;
3988
    sigaction(SIGUSR1, &sigact, NULL);
3989
}
3990

    
3991
static void unblock_io_signals(void)
3992
{
3993
    sigset_t set;
3994

    
3995
    sigemptyset(&set);
3996
    sigaddset(&set, SIGUSR2);
3997
    sigaddset(&set, SIGIO);
3998
    sigaddset(&set, SIGALRM);
3999
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
4000

    
4001
    sigemptyset(&set);
4002
    sigaddset(&set, SIGUSR1);
4003
    pthread_sigmask(SIG_BLOCK, &set, NULL);
4004
}
4005

    
4006
static void qemu_signal_lock(unsigned int msecs)
4007
{
4008
    qemu_mutex_lock(&qemu_fair_mutex);
4009

    
4010
    while (qemu_mutex_trylock(&qemu_global_mutex)) {
4011
        qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
4012
        if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
4013
            break;
4014
    }
4015
    qemu_mutex_unlock(&qemu_fair_mutex);
4016
}
4017

    
4018
static void qemu_mutex_lock_iothread(void)
4019
{
4020
    if (kvm_enabled()) {
4021
        qemu_mutex_lock(&qemu_fair_mutex);
4022
        qemu_mutex_lock(&qemu_global_mutex);
4023
        qemu_mutex_unlock(&qemu_fair_mutex);
4024
    } else
4025
        qemu_signal_lock(100);
4026
}
4027

    
4028
static void qemu_mutex_unlock_iothread(void)
4029
{
4030
    qemu_mutex_unlock(&qemu_global_mutex);
4031
}
4032

    
4033
static int all_vcpus_paused(void)
4034
{
4035
    CPUState *penv = first_cpu;
4036

    
4037
    while (penv) {
4038
        if (!penv->stopped)
4039
            return 0;
4040
        penv = (CPUState *)penv->next_cpu;
4041
    }
4042

    
4043
    return 1;
4044
}
4045

    
4046
static void pause_all_vcpus(void)
4047
{
4048
    CPUState *penv = first_cpu;
4049

    
4050
    while (penv) {
4051
        penv->stop = 1;
4052
        qemu_thread_signal(penv->thread, SIGUSR1);
4053
        qemu_cpu_kick(penv);
4054
        penv = (CPUState *)penv->next_cpu;
4055
    }
4056

    
4057
    while (!all_vcpus_paused()) {
4058
        qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
4059
        penv = first_cpu;
4060
        while (penv) {
4061
            qemu_thread_signal(penv->thread, SIGUSR1);
4062
            penv = (CPUState *)penv->next_cpu;
4063
        }
4064
    }
4065
}
4066

    
4067
static void resume_all_vcpus(void)
4068
{
4069
    CPUState *penv = first_cpu;
4070

    
4071
    while (penv) {
4072
        penv->stop = 0;
4073
        penv->stopped = 0;
4074
        qemu_thread_signal(penv->thread, SIGUSR1);
4075
        qemu_cpu_kick(penv);
4076
        penv = (CPUState *)penv->next_cpu;
4077
    }
4078
}
4079

    
4080
static void tcg_init_vcpu(void *_env)
4081
{
4082
    CPUState *env = _env;
4083
    /* share a single thread for all cpus with TCG */
4084
    if (!tcg_cpu_thread) {
4085
        env->thread = qemu_mallocz(sizeof(QemuThread));
4086
        env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4087
        qemu_cond_init(env->halt_cond);
4088
        qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
4089
        while (env->created == 0)
4090
            qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4091
        tcg_cpu_thread = env->thread;
4092
        tcg_halt_cond = env->halt_cond;
4093
    } else {
4094
        env->thread = tcg_cpu_thread;
4095
        env->halt_cond = tcg_halt_cond;
4096
    }
4097
}
4098

    
4099
static void kvm_start_vcpu(CPUState *env)
4100
{
4101
    kvm_init_vcpu(env);
4102
    env->thread = qemu_mallocz(sizeof(QemuThread));
4103
    env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4104
    qemu_cond_init(env->halt_cond);
4105
    qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
4106
    while (env->created == 0)
4107
        qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4108
}
4109

    
4110
void qemu_init_vcpu(void *_env)
4111
{
4112
    CPUState *env = _env;
4113

    
4114
    if (kvm_enabled())
4115
        kvm_start_vcpu(env);
4116
    else
4117
        tcg_init_vcpu(env);
4118
}
4119

    
4120
void qemu_notify_event(void)
4121
{
4122
    qemu_event_increment();
4123
}
4124

    
4125
void vm_stop(int reason)
4126
{
4127
    QemuThread me;
4128
    qemu_thread_self(&me);
4129

    
4130
    if (!qemu_thread_equal(&me, &io_thread)) {
4131
        qemu_system_vmstop_request(reason);
4132
        /*
4133
         * FIXME: should not return to device code in case
4134
         * vm_stop() has been requested.
4135
         */
4136
        if (cpu_single_env) {
4137
            cpu_exit(cpu_single_env);
4138
            cpu_single_env->stop = 1;
4139
        }
4140
        return;
4141
    }
4142
    do_vm_stop(reason);
4143
}
4144

    
4145
#endif
4146

    
4147

    
4148
#ifdef _WIN32
4149
static void host_main_loop_wait(int *timeout)
4150
{
4151
    int ret, ret2, i;
4152
    PollingEntry *pe;
4153

    
4154

    
4155
    /* XXX: need to suppress polling by better using win32 events */
4156
    ret = 0;
4157
    for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
4158
        ret |= pe->func(pe->opaque);
4159
    }
4160
    if (ret == 0) {
4161
        int err;
4162
        WaitObjects *w = &wait_objects;
4163

    
4164
        ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
4165
        if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
4166
            if (w->func[ret - WAIT_OBJECT_0])
4167
                w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
4168

    
4169
            /* Check for additional signaled events */
4170
            for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
4171

    
4172
                /* Check if event is signaled */
4173
                ret2 = WaitForSingleObject(w->events[i], 0);
4174
                if(ret2 == WAIT_OBJECT_0) {
4175
                    if (w->func[i])
4176
                        w->func[i](w->opaque[i]);
4177
                } else if (ret2 == WAIT_TIMEOUT) {
4178
                } else {
4179
                    err = GetLastError();
4180
                    fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
4181
                }
4182
            }
4183
        } else if (ret == WAIT_TIMEOUT) {
4184
        } else {
4185
            err = GetLastError();
4186
            fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
4187
        }
4188
    }
4189

    
4190
    *timeout = 0;
4191
}
4192
#else
4193
static void host_main_loop_wait(int *timeout)
4194
{
4195
}
4196
#endif
4197

    
4198
void main_loop_wait(int timeout)
4199
{
4200
    IOHandlerRecord *ioh;
4201
    fd_set rfds, wfds, xfds;
4202
    int ret, nfds;
4203
    struct timeval tv;
4204

    
4205
    qemu_bh_update_timeout(&timeout);
4206

    
4207
    host_main_loop_wait(&timeout);
4208

    
4209
    /* poll any events */
4210
    /* XXX: separate device handlers from system ones */
4211
    nfds = -1;
4212
    FD_ZERO(&rfds);
4213
    FD_ZERO(&wfds);
4214
    FD_ZERO(&xfds);
4215
    for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4216
        if (ioh->deleted)
4217
            continue;
4218
        if (ioh->fd_read &&
4219
            (!ioh->fd_read_poll ||
4220
             ioh->fd_read_poll(ioh->opaque) != 0)) {
4221
            FD_SET(ioh->fd, &rfds);
4222
            if (ioh->fd > nfds)
4223
                nfds = ioh->fd;
4224
        }
4225
        if (ioh->fd_write) {
4226
            FD_SET(ioh->fd, &wfds);
4227
            if (ioh->fd > nfds)
4228
                nfds = ioh->fd;
4229
        }
4230
    }
4231

    
4232
    tv.tv_sec = timeout / 1000;
4233
    tv.tv_usec = (timeout % 1000) * 1000;
4234

    
4235
#if defined(CONFIG_SLIRP)
4236
    if (slirp_is_inited()) {
4237
        slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4238
    }
4239
#endif
4240
    qemu_mutex_unlock_iothread();
4241
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4242
    qemu_mutex_lock_iothread();
4243
    if (ret > 0) {
4244
        IOHandlerRecord **pioh;
4245

    
4246
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4247
            if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
4248
                ioh->fd_read(ioh->opaque);
4249
            }
4250
            if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
4251
                ioh->fd_write(ioh->opaque);
4252
            }
4253
        }
4254

    
4255
        /* remove deleted IO handlers */
4256
        pioh = &first_io_handler;
4257
        while (*pioh) {
4258
            ioh = *pioh;
4259
            if (ioh->deleted) {
4260
                *pioh = ioh->next;
4261
                qemu_free(ioh);
4262
            } else
4263
                pioh = &ioh->next;
4264
        }
4265
    }
4266
#if defined(CONFIG_SLIRP)
4267
    if (slirp_is_inited()) {
4268
        if (ret < 0) {
4269
            FD_ZERO(&rfds);
4270
            FD_ZERO(&wfds);
4271
            FD_ZERO(&xfds);
4272
        }
4273
        slirp_select_poll(&rfds, &wfds, &xfds);
4274
    }
4275
#endif
4276

    
4277
    /* rearm timer, if not periodic */
4278
    if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
4279
        alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
4280
        qemu_rearm_alarm_timer(alarm_timer);
4281
    }
4282

    
4283
    /* vm time timers */
4284
    if (vm_running) {
4285
        if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
4286
            qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4287
                qemu_get_clock(vm_clock));
4288
    }
4289

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

    
4294
    /* Check bottom-halves last in case any of the earlier events triggered
4295
       them.  */
4296
    qemu_bh_poll();
4297

    
4298
}
4299

    
4300
static int qemu_cpu_exec(CPUState *env)
4301
{
4302
    int ret;
4303
#ifdef CONFIG_PROFILER
4304
    int64_t ti;
4305
#endif
4306

    
4307
#ifdef CONFIG_PROFILER
4308
    ti = profile_getclock();
4309
#endif
4310
    if (use_icount) {
4311
        int64_t count;
4312
        int decr;
4313
        qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
4314
        env->icount_decr.u16.low = 0;
4315
        env->icount_extra = 0;
4316
        count = qemu_next_deadline();
4317
        count = (count + (1 << icount_time_shift) - 1)
4318
                >> icount_time_shift;
4319
        qemu_icount += count;
4320
        decr = (count > 0xffff) ? 0xffff : count;
4321
        count -= decr;
4322
        env->icount_decr.u16.low = decr;
4323
        env->icount_extra = count;
4324
    }
4325
    ret = cpu_exec(env);
4326
#ifdef CONFIG_PROFILER
4327
    qemu_time += profile_getclock() - ti;
4328
#endif
4329
    if (use_icount) {
4330
        /* Fold pending instructions back into the
4331
           instruction counter, and clear the interrupt flag.  */
4332
        qemu_icount -= (env->icount_decr.u16.low
4333
                        + env->icount_extra);
4334
        env->icount_decr.u32 = 0;
4335
        env->icount_extra = 0;
4336
    }
4337
    return ret;
4338
}
4339

    
4340
static void tcg_cpu_exec(void)
4341
{
4342
    int ret = 0;
4343

    
4344
    if (next_cpu == NULL)
4345
        next_cpu = first_cpu;
4346
    for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
4347
        CPUState *env = cur_cpu = next_cpu;
4348

    
4349
        if (!vm_running)
4350
            break;
4351
        if (timer_alarm_pending) {
4352
            timer_alarm_pending = 0;
4353
            break;
4354
        }
4355
        if (cpu_can_run(env))
4356
            ret = qemu_cpu_exec(env);
4357
        if (ret == EXCP_DEBUG) {
4358
            gdb_set_stop_cpu(env);
4359
            debug_requested = 1;
4360
            break;
4361
        }
4362
    }
4363
}
4364

    
4365
static int cpu_has_work(CPUState *env)
4366
{
4367
    if (env->stop)
4368
        return 1;
4369
    if (env->stopped)
4370
        return 0;
4371
    if (!env->halted)
4372
        return 1;
4373
    if (qemu_cpu_has_work(env))
4374
        return 1;
4375
    return 0;
4376
}
4377

    
4378
static int tcg_has_work(void)
4379
{
4380
    CPUState *env;
4381

    
4382
    for (env = first_cpu; env != NULL; env = env->next_cpu)
4383
        if (cpu_has_work(env))
4384
            return 1;
4385
    return 0;
4386
}
4387

    
4388
static int qemu_calculate_timeout(void)
4389
{
4390
    int timeout;
4391

    
4392
    if (!vm_running)
4393
        timeout = 5000;
4394
    else if (tcg_has_work())
4395
        timeout = 0;
4396
    else if (!use_icount)
4397
        timeout = 5000;
4398
    else {
4399
     /* XXX: use timeout computed from timers */
4400
        int64_t add;
4401
        int64_t delta;
4402
        /* Advance virtual time to the next event.  */
4403
        if (use_icount == 1) {
4404
            /* When not using an adaptive execution frequency
4405
               we tend to get badly out of sync with real time,
4406
               so just delay for a reasonable amount of time.  */
4407
            delta = 0;
4408
        } else {
4409
            delta = cpu_get_icount() - cpu_get_clock();
4410
        }
4411
        if (delta > 0) {
4412
            /* If virtual time is ahead of real time then just
4413
               wait for IO.  */
4414
            timeout = (delta / 1000000) + 1;
4415
        } else {
4416
            /* Wait for either IO to occur or the next
4417
               timer event.  */
4418
            add = qemu_next_deadline();
4419
            /* We advance the timer before checking for IO.
4420
               Limit the amount we advance so that early IO
4421
               activity won't get the guest too far ahead.  */
4422
            if (add > 10000000)
4423
                add = 10000000;
4424
            delta += add;
4425
            add = (add + (1 << icount_time_shift) - 1)
4426
                  >> icount_time_shift;
4427
            qemu_icount += add;
4428
            timeout = delta / 1000000;
4429
            if (timeout < 0)
4430
                timeout = 0;
4431
        }
4432
    }
4433

    
4434
    return timeout;
4435
}
4436

    
4437
static int vm_can_run(void)
4438
{
4439
    if (powerdown_requested)
4440
        return 0;
4441
    if (reset_requested)
4442
        return 0;
4443
    if (shutdown_requested)
4444
        return 0;
4445
    if (debug_requested)
4446
        return 0;
4447
    return 1;
4448
}
4449

    
4450
static void main_loop(void)
4451
{
4452
    int r;
4453

    
4454
#ifdef CONFIG_IOTHREAD
4455
    qemu_system_ready = 1;
4456
    qemu_cond_broadcast(&qemu_system_cond);
4457
#endif
4458

    
4459
    for (;;) {
4460
        do {
4461
#ifdef CONFIG_PROFILER
4462
            int64_t ti;
4463
#endif
4464
#ifndef CONFIG_IOTHREAD
4465
            tcg_cpu_exec();
4466
#endif
4467
#ifdef CONFIG_PROFILER
4468
            ti = profile_getclock();
4469
#endif
4470
#ifdef CONFIG_IOTHREAD
4471
            main_loop_wait(1000);
4472
#else
4473
            main_loop_wait(qemu_calculate_timeout());
4474
#endif
4475
#ifdef CONFIG_PROFILER
4476
            dev_time += profile_getclock() - ti;
4477
#endif
4478
        } while (vm_can_run());
4479

    
4480
        if (qemu_debug_requested())
4481
            vm_stop(EXCP_DEBUG);
4482
        if (qemu_shutdown_requested()) {
4483
            if (no_shutdown) {
4484
                vm_stop(0);
4485
                no_shutdown = 0;
4486
            } else
4487
                break;
4488
        }
4489
        if (qemu_reset_requested()) {
4490
            pause_all_vcpus();
4491
            qemu_system_reset();
4492
            resume_all_vcpus();
4493
        }
4494
        if (qemu_powerdown_requested())
4495
            qemu_system_powerdown();
4496
        if ((r = qemu_vmstop_requested()))
4497
            vm_stop(r);
4498
    }
4499
    pause_all_vcpus();
4500
}
4501

    
4502
static void version(void)
4503
{
4504
    printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4505
}
4506

    
4507
static void help(int exitcode)
4508
{
4509
    version();
4510
    printf("usage: %s [options] [disk_image]\n"
4511
           "\n"
4512
           "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4513
           "\n"
4514
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4515
           opt_help
4516
#define DEFHEADING(text) stringify(text) "\n"
4517
#include "qemu-options.h"
4518
#undef DEF
4519
#undef DEFHEADING
4520
#undef GEN_DOCS
4521
           "\n"
4522
           "During emulation, the following keys are useful:\n"
4523
           "ctrl-alt-f      toggle full screen\n"
4524
           "ctrl-alt-n      switch to virtual console 'n'\n"
4525
           "ctrl-alt        toggle mouse and keyboard grab\n"
4526
           "\n"
4527
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
4528
           ,
4529
           "qemu",
4530
           DEFAULT_RAM_SIZE,
4531
#ifndef _WIN32
4532
           DEFAULT_NETWORK_SCRIPT,
4533
           DEFAULT_NETWORK_DOWN_SCRIPT,
4534
#endif
4535
           DEFAULT_GDBSTUB_PORT,
4536
           "/tmp/qemu.log");
4537
    exit(exitcode);
4538
}
4539

    
4540
#define HAS_ARG 0x0001
4541

    
4542
enum {
4543
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4544
    opt_enum,
4545
#define DEFHEADING(text)
4546
#include "qemu-options.h"
4547
#undef DEF
4548
#undef DEFHEADING
4549
#undef GEN_DOCS
4550
};
4551

    
4552
typedef struct QEMUOption {
4553
    const char *name;
4554
    int flags;
4555
    int index;
4556
} QEMUOption;
4557

    
4558
static const QEMUOption qemu_options[] = {
4559
    { "h", 0, QEMU_OPTION_h },
4560
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4561
    { option, opt_arg, opt_enum },
4562
#define DEFHEADING(text)
4563
#include "qemu-options.h"
4564
#undef DEF
4565
#undef DEFHEADING
4566
#undef GEN_DOCS
4567
    { NULL },
4568
};
4569

    
4570
#ifdef HAS_AUDIO
4571
struct soundhw soundhw[] = {
4572
#ifdef HAS_AUDIO_CHOICE
4573
#if defined(TARGET_I386) || defined(TARGET_MIPS)
4574
    {
4575
        "pcspk",
4576
        "PC speaker",
4577
        0,
4578
        1,
4579
        { .init_isa = pcspk_audio_init }
4580
    },
4581
#endif
4582

    
4583
#ifdef CONFIG_SB16
4584
    {
4585
        "sb16",
4586
        "Creative Sound Blaster 16",
4587
        0,
4588
        1,
4589
        { .init_isa = SB16_init }
4590
    },
4591
#endif
4592

    
4593
#ifdef CONFIG_CS4231A
4594
    {
4595
        "cs4231a",
4596
        "CS4231A",
4597
        0,
4598
        1,
4599
        { .init_isa = cs4231a_init }
4600
    },
4601
#endif
4602

    
4603
#ifdef CONFIG_ADLIB
4604
    {
4605
        "adlib",
4606
#ifdef HAS_YMF262
4607
        "Yamaha YMF262 (OPL3)",
4608
#else
4609
        "Yamaha YM3812 (OPL2)",
4610
#endif
4611
        0,
4612
        1,
4613
        { .init_isa = Adlib_init }
4614
    },
4615
#endif
4616

    
4617
#ifdef CONFIG_GUS
4618
    {
4619
        "gus",
4620
        "Gravis Ultrasound GF1",
4621
        0,
4622
        1,
4623
        { .init_isa = GUS_init }
4624
    },
4625
#endif
4626

    
4627
#ifdef CONFIG_AC97
4628
    {
4629
        "ac97",
4630
        "Intel 82801AA AC97 Audio",
4631
        0,
4632
        0,
4633
        { .init_pci = ac97_init }
4634
    },
4635
#endif
4636

    
4637
#ifdef CONFIG_ES1370
4638
    {
4639
        "es1370",
4640
        "ENSONIQ AudioPCI ES1370",
4641
        0,
4642
        0,
4643
        { .init_pci = es1370_init }
4644
    },
4645
#endif
4646

    
4647
#endif /* HAS_AUDIO_CHOICE */
4648

    
4649
    { NULL, NULL, 0, 0, { NULL } }
4650
};
4651

    
4652
static void select_soundhw (const char *optarg)
4653
{
4654
    struct soundhw *c;
4655

    
4656
    if (*optarg == '?') {
4657
    show_valid_cards:
4658

    
4659
        printf ("Valid sound card names (comma separated):\n");
4660
        for (c = soundhw; c->name; ++c) {
4661
            printf ("%-11s %s\n", c->name, c->descr);
4662
        }
4663
        printf ("\n-soundhw all will enable all of the above\n");
4664
        exit (*optarg != '?');
4665
    }
4666
    else {
4667
        size_t l;
4668
        const char *p;
4669
        char *e;
4670
        int bad_card = 0;
4671

    
4672
        if (!strcmp (optarg, "all")) {
4673
            for (c = soundhw; c->name; ++c) {
4674
                c->enabled = 1;
4675
            }
4676
            return;
4677
        }
4678

    
4679
        p = optarg;
4680
        while (*p) {
4681
            e = strchr (p, ',');
4682
            l = !e ? strlen (p) : (size_t) (e - p);
4683

    
4684
            for (c = soundhw; c->name; ++c) {
4685
                if (!strncmp (c->name, p, l)) {
4686
                    c->enabled = 1;
4687
                    break;
4688
                }
4689
            }
4690

    
4691
            if (!c->name) {
4692
                if (l > 80) {
4693
                    fprintf (stderr,
4694
                             "Unknown sound card name (too big to show)\n");
4695
                }
4696
                else {
4697
                    fprintf (stderr, "Unknown sound card name `%.*s'\n",
4698
                             (int) l, p);
4699
                }
4700
                bad_card = 1;
4701
            }
4702
            p += l + (e != NULL);
4703
        }
4704

    
4705
        if (bad_card)
4706
            goto show_valid_cards;
4707
    }
4708
}
4709
#endif
4710

    
4711
static void select_vgahw (const char *p)
4712
{
4713
    const char *opts;
4714

    
4715
    cirrus_vga_enabled = 0;
4716
    std_vga_enabled = 0;
4717
    vmsvga_enabled = 0;
4718
    xenfb_enabled = 0;
4719
    if (strstart(p, "std", &opts)) {
4720
        std_vga_enabled = 1;
4721
    } else if (strstart(p, "cirrus", &opts)) {
4722
        cirrus_vga_enabled = 1;
4723
    } else if (strstart(p, "vmware", &opts)) {
4724
        vmsvga_enabled = 1;
4725
    } else if (strstart(p, "xenfb", &opts)) {
4726
        xenfb_enabled = 1;
4727
    } else if (!strstart(p, "none", &opts)) {
4728
    invalid_vga:
4729
        fprintf(stderr, "Unknown vga type: %s\n", p);
4730
        exit(1);
4731
    }
4732
    while (*opts) {
4733
        const char *nextopt;
4734

    
4735
        if (strstart(opts, ",retrace=", &nextopt)) {
4736
            opts = nextopt;
4737
            if (strstart(opts, "dumb", &nextopt))
4738
                vga_retrace_method = VGA_RETRACE_DUMB;
4739
            else if (strstart(opts, "precise", &nextopt))
4740
                vga_retrace_method = VGA_RETRACE_PRECISE;
4741
            else goto invalid_vga;
4742
        } else goto invalid_vga;
4743
        opts = nextopt;
4744
    }
4745
}
4746

    
4747
#ifdef _WIN32
4748
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4749
{
4750
    exit(STATUS_CONTROL_C_EXIT);
4751
    return TRUE;
4752
}
4753
#endif
4754

    
4755
int qemu_uuid_parse(const char *str, uint8_t *uuid)
4756
{
4757
    int ret;
4758

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

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

    
4766
    if(ret != 16)
4767
        return -1;
4768

    
4769
#ifdef TARGET_I386
4770
    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4771
#endif
4772

    
4773
    return 0;
4774
}
4775

    
4776
#define MAX_NET_CLIENTS 32
4777

    
4778
#ifndef _WIN32
4779

    
4780
static void termsig_handler(int signal)
4781
{
4782
    qemu_system_shutdown_request();
4783
}
4784

    
4785
static void termsig_setup(void)
4786
{
4787
    struct sigaction act;
4788

    
4789
    memset(&act, 0, sizeof(act));
4790
    act.sa_handler = termsig_handler;
4791
    sigaction(SIGINT,  &act, NULL);
4792
    sigaction(SIGHUP,  &act, NULL);
4793
    sigaction(SIGTERM, &act, NULL);
4794
}
4795

    
4796
#endif
4797

    
4798
int main(int argc, char **argv, char **envp)
4799
{
4800
    const char *gdbstub_dev = NULL;
4801
    uint32_t boot_devices_bitmap = 0;
4802
    int i;
4803
    int snapshot, linux_boot, net_boot;
4804
    const char *initrd_filename;
4805
    const char *kernel_filename, *kernel_cmdline;
4806
    const char *boot_devices = "";
4807
    DisplayState *ds;
4808
    DisplayChangeListener *dcl;
4809
    int cyls, heads, secs, translation;
4810
    const char *net_clients[MAX_NET_CLIENTS];
4811
    int nb_net_clients;
4812
    const char *bt_opts[MAX_BT_CMDLINE];
4813
    int nb_bt_opts;
4814
    int hda_index;
4815
    int optind;
4816
    const char *r, *optarg;
4817
    CharDriverState *monitor_hd = NULL;
4818
    const char *monitor_device;
4819
    const char *serial_devices[MAX_SERIAL_PORTS];
4820
    int serial_device_index;
4821
    const char *parallel_devices[MAX_PARALLEL_PORTS];
4822
    int parallel_device_index;
4823
    const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4824
    int virtio_console_index;
4825
    const char *loadvm = NULL;
4826
    QEMUMachine *machine;
4827
    const char *cpu_model;
4828
    const char *usb_devices[MAX_USB_CMDLINE];
4829
    int usb_devices_index;
4830
#ifndef _WIN32
4831
    int fds[2];
4832
#endif
4833
    int tb_size;
4834
    const char *pid_file = NULL;
4835
    const char *incoming = NULL;
4836
#ifndef _WIN32
4837
    int fd = 0;
4838
    struct passwd *pwd = NULL;
4839
    const char *chroot_dir = NULL;
4840
    const char *run_as = NULL;
4841
#endif
4842
    CPUState *env;
4843
    int show_vnc_port = 0;
4844

    
4845
    qemu_cache_utils_init(envp);
4846

    
4847
    LIST_INIT (&vm_change_state_head);
4848
#ifndef _WIN32
4849
    {
4850
        struct sigaction act;
4851
        sigfillset(&act.sa_mask);
4852
        act.sa_flags = 0;
4853
        act.sa_handler = SIG_IGN;
4854
        sigaction(SIGPIPE, &act, NULL);
4855
    }
4856
#else
4857
    SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4858
    /* Note: cpu_interrupt() is currently not SMP safe, so we force
4859
       QEMU to run on a single CPU */
4860
    {
4861
        HANDLE h;
4862
        DWORD mask, smask;
4863
        int i;
4864
        h = GetCurrentProcess();
4865
        if (GetProcessAffinityMask(h, &mask, &smask)) {
4866
            for(i = 0; i < 32; i++) {
4867
                if (mask & (1 << i))
4868
                    break;
4869
            }
4870
            if (i != 32) {
4871
                mask = 1 << i;
4872
                SetProcessAffinityMask(h, mask);
4873
            }
4874
        }
4875
    }
4876
#endif
4877

    
4878
    module_call_init(MODULE_INIT_MACHINE);
4879
    machine = find_default_machine();
4880
    cpu_model = NULL;
4881
    initrd_filename = NULL;
4882
    ram_size = 0;
4883
    snapshot = 0;
4884
    kernel_filename = NULL;
4885
    kernel_cmdline = "";
4886
    cyls = heads = secs = 0;
4887
    translation = BIOS_ATA_TRANSLATION_AUTO;
4888
    monitor_device = "vc:80Cx24C";
4889

    
4890
    serial_devices[0] = "vc:80Cx24C";
4891
    for(i = 1; i < MAX_SERIAL_PORTS; i++)
4892
        serial_devices[i] = NULL;
4893
    serial_device_index = 0;
4894

    
4895
    parallel_devices[0] = "vc:80Cx24C";
4896
    for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4897
        parallel_devices[i] = NULL;
4898
    parallel_device_index = 0;
4899

    
4900
    for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4901
        virtio_consoles[i] = NULL;
4902
    virtio_console_index = 0;
4903

    
4904
    for (i = 0; i < MAX_NODES; i++) {
4905
        node_mem[i] = 0;
4906
        node_cpumask[i] = 0;
4907
    }
4908

    
4909
    usb_devices_index = 0;
4910

    
4911
    nb_net_clients = 0;
4912
    nb_bt_opts = 0;
4913
    nb_drives = 0;
4914
    nb_drives_opt = 0;
4915
    nb_numa_nodes = 0;
4916
    hda_index = -1;
4917

    
4918
    nb_nics = 0;
4919

    
4920
    tb_size = 0;
4921
    autostart= 1;
4922

    
4923
    register_watchdogs();
4924

    
4925
    optind = 1;
4926
    for(;;) {
4927
        if (optind >= argc)
4928
            break;
4929
        r = argv[optind];
4930
        if (r[0] != '-') {
4931
            hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4932
        } else {
4933
            const QEMUOption *popt;
4934

    
4935
            optind++;
4936
            /* Treat --foo the same as -foo.  */
4937
            if (r[1] == '-')
4938
                r++;
4939
            popt = qemu_options;
4940
            for(;;) {
4941
                if (!popt->name) {
4942
                    fprintf(stderr, "%s: invalid option -- '%s'\n",
4943
                            argv[0], r);
4944
                    exit(1);
4945
                }
4946
                if (!strcmp(popt->name, r + 1))
4947
                    break;
4948
                popt++;
4949
            }
4950
            if (popt->flags & HAS_ARG) {
4951
                if (optind >= argc) {
4952
                    fprintf(stderr, "%s: option '%s' requires an argument\n",
4953
                            argv[0], r);
4954
                    exit(1);
4955
                }
4956
                optarg = argv[optind++];
4957
            } else {
4958
                optarg = NULL;
4959
            }
4960

    
4961
            switch(popt->index) {
4962
            case QEMU_OPTION_M:
4963
                machine = find_machine(optarg);
4964
                if (!machine) {
4965
                    QEMUMachine *m;
4966
                    printf("Supported machines are:\n");
4967
                    for(m = first_machine; m != NULL; m = m->next) {
4968
                        printf("%-10s %s%s\n",
4969
                               m->name, m->desc,
4970
                               m->is_default ? " (default)" : "");
4971
                    }
4972
                    exit(*optarg != '?');
4973
                }
4974
                break;
4975
            case QEMU_OPTION_cpu:
4976
                /* hw initialization will check this */
4977
                if (*optarg == '?') {
4978
/* XXX: implement xxx_cpu_list for targets that still miss it */
4979
#if defined(cpu_list)
4980
                    cpu_list(stdout, &fprintf);
4981
#endif
4982
                    exit(0);
4983
                } else {
4984
                    cpu_model = optarg;
4985
                }
4986
                break;
4987
            case QEMU_OPTION_initrd:
4988
                initrd_filename = optarg;
4989
                break;
4990
            case QEMU_OPTION_hda:
4991
                if (cyls == 0)
4992
                    hda_index = drive_add(optarg, HD_ALIAS, 0);
4993
                else
4994
                    hda_index = drive_add(optarg, HD_ALIAS
4995
                             ",cyls=%d,heads=%d,secs=%d%s",
4996
                             0, cyls, heads, secs,
4997
                             translation == BIOS_ATA_TRANSLATION_LBA ?
4998
                                 ",trans=lba" :
4999
                             translation == BIOS_ATA_TRANSLATION_NONE ?
5000
                                 ",trans=none" : "");
5001
                 break;
5002
            case QEMU_OPTION_hdb:
5003
            case QEMU_OPTION_hdc:
5004
            case QEMU_OPTION_hdd:
5005
                drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
5006
                break;
5007
            case QEMU_OPTION_drive:
5008
                drive_add(NULL, "%s", optarg);
5009
                break;
5010
            case QEMU_OPTION_mtdblock:
5011
                drive_add(optarg, MTD_ALIAS);
5012
                break;
<