Statistics
| Branch: | Revision:

root / vl.c @ d9f75a4e

History | View | Annotate | Download (145.1 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/smbios.h"
142
#include "hw/xen.h"
143
#include "bt-host.h"
144
#include "net.h"
145
#include "monitor.h"
146
#include "console.h"
147
#include "sysemu.h"
148
#include "gdbstub.h"
149
#include "qemu-timer.h"
150
#include "qemu-char.h"
151
#include "cache-utils.h"
152
#include "block.h"
153
#include "dma.h"
154
#include "audio/audio.h"
155
#include "migration.h"
156
#include "kvm.h"
157
#include "balloon.h"
158

    
159
#include "disas.h"
160

    
161
#include "exec-all.h"
162

    
163
#include "qemu_socket.h"
164

    
165
#if defined(CONFIG_SLIRP)
166
#include "libslirp.h"
167
#endif
168

    
169
//#define DEBUG_UNUSED_IOPORT
170
//#define DEBUG_IOPORT
171
//#define DEBUG_NET
172
//#define DEBUG_SLIRP
173

    
174

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

    
181
#define DEFAULT_RAM_SIZE 128
182

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

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

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

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

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

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

    
287
uint8_t qemu_uuid[16];
288

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
438
/***********************************************************/
439

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

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

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

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

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

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

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

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

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

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

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

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

    
553
/***********************************************************/
554
/* keyboard/mouse */
555

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

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

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

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

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

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

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

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

    
593
    return s;
594
}
595

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

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

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

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

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

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

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

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

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

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

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

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

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

    
670
    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
671
}
672

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

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

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

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

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

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

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

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

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

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

    
743
#define QEMU_TIMER_BASE 1000000000LL
744

    
745
#ifdef WIN32
746

    
747
static int64_t clock_freq;
748

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

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

    
768
#else
769

    
770
static int use_rt_clock;
771

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

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

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

    
820
/***********************************************************/
821
/* guest cycle counter */
822

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

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

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

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

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

    
882
/***********************************************************/
883
/* timers */
884

    
885
#define QEMU_TIMER_REALTIME 0
886
#define QEMU_TIMER_VIRTUAL  1
887

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

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

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

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

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

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

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

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

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

    
930
static struct qemu_alarm_timer *alarm_timer;
931
#ifndef _WIN32
932
static int alarm_timer_rfd, alarm_timer_wfd;
933
#endif
934

    
935
#ifdef _WIN32
936

    
937
struct qemu_alarm_win32 {
938
    MMRESULT timerId;
939
    HANDLE host_alarm;
940
    unsigned int period;
941
} alarm_win32_data = {0, NULL, -1};
942

    
943
static int win32_start_timer(struct qemu_alarm_timer *t);
944
static void win32_stop_timer(struct qemu_alarm_timer *t);
945
static void win32_rearm_timer(struct qemu_alarm_timer *t);
946

    
947
#else
948

    
949
static int unix_start_timer(struct qemu_alarm_timer *t);
950
static void unix_stop_timer(struct qemu_alarm_timer *t);
951

    
952
#ifdef __linux__
953

    
954
static int dynticks_start_timer(struct qemu_alarm_timer *t);
955
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
956
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
957

    
958
static int hpet_start_timer(struct qemu_alarm_timer *t);
959
static void hpet_stop_timer(struct qemu_alarm_timer *t);
960

    
961
static int rtc_start_timer(struct qemu_alarm_timer *t);
962
static void rtc_stop_timer(struct qemu_alarm_timer *t);
963

    
964
#endif /* __linux__ */
965

    
966
#endif /* _WIN32 */
967

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

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

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

    
1004
static void icount_adjust_rt(void * opaque)
1005
{
1006
    qemu_mod_timer(icount_rt_timer,
1007
                   qemu_get_clock(rt_clock) + 1000);
1008
    icount_adjust();
1009
}
1010

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

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

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

    
1053
static void show_available_alarms(void)
1054
{
1055
    int i;
1056

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

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

    
1071
    if (!strcmp(opt, "?")) {
1072
        show_available_alarms();
1073
        exit(0);
1074
    }
1075

    
1076
    arg = strdup(opt);
1077

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

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

    
1091
        if (i < cur)
1092
            /* Ignore */
1093
            goto next;
1094

    
1095
        /* Swap */
1096
        tmp = alarm_timers[i];
1097
        alarm_timers[i] = alarm_timers[cur];
1098
        alarm_timers[cur] = tmp;
1099

    
1100
        cur++;
1101
next:
1102
        name = strtok(NULL, ",");
1103
    }
1104

    
1105
    free(arg);
1106

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

    
1117
QEMUClock *rt_clock;
1118
QEMUClock *vm_clock;
1119

    
1120
static QEMUTimer *active_timers[2];
1121

    
1122
static QEMUClock *qemu_new_clock(int type)
1123
{
1124
    QEMUClock *clock;
1125
    clock = qemu_mallocz(sizeof(QEMUClock));
1126
    clock->type = type;
1127
    return clock;
1128
}
1129

    
1130
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1131
{
1132
    QEMUTimer *ts;
1133

    
1134
    ts = qemu_mallocz(sizeof(QEMUTimer));
1135
    ts->clock = clock;
1136
    ts->cb = cb;
1137
    ts->opaque = opaque;
1138
    return ts;
1139
}
1140

    
1141
void qemu_free_timer(QEMUTimer *ts)
1142
{
1143
    qemu_free(ts);
1144
}
1145

    
1146
/* stop a timer, but do not dealloc it */
1147
void qemu_del_timer(QEMUTimer *ts)
1148
{
1149
    QEMUTimer **pt, *t;
1150

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

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

    
1172
    qemu_del_timer(ts);
1173

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

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

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

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

    
1218
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1219
{
1220
    QEMUTimer *ts;
1221

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

    
1230
        /* run the callback (the timer list can be modified) */
1231
        ts->cb(ts->opaque);
1232
    }
1233
}
1234

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

    
1250
static void init_timers(void)
1251
{
1252
    init_get_clock();
1253
    ticks_per_sec = QEMU_TIMER_BASE;
1254
    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1255
    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1256
}
1257

    
1258
/* save a timer */
1259
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1260
{
1261
    uint64_t expire_time;
1262

    
1263
    if (qemu_timer_pending(ts)) {
1264
        expire_time = ts->expire_time;
1265
    } else {
1266
        expire_time = -1;
1267
    }
1268
    qemu_put_be64(f, expire_time);
1269
}
1270

    
1271
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1272
{
1273
    uint64_t expire_time;
1274

    
1275
    expire_time = qemu_get_be64(f);
1276
    if (expire_time != -1) {
1277
        qemu_mod_timer(ts, expire_time);
1278
    } else {
1279
        qemu_del_timer(ts);
1280
    }
1281
}
1282

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

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

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

    
1353
#ifdef _WIN32
1354
        struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1355
        SetEvent(data->host_alarm);
1356
#else
1357
        static const char byte = 0;
1358
        write(alarm_timer_wfd, &byte, sizeof(byte));
1359
#endif
1360
        alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1361

    
1362
        if (env) {
1363
            /* stop the currently executing cpu because a timer occured */
1364
            cpu_exit(env);
1365
#ifdef CONFIG_KQEMU
1366
            if (env->kqemu_enabled) {
1367
                kqemu_cpu_interrupt(env);
1368
            }
1369
#endif
1370
        }
1371
        event_pending = 1;
1372
        qemu_notify_event();
1373
    }
1374
}
1375

    
1376
static int64_t qemu_next_deadline(void)
1377
{
1378
    int64_t delta;
1379

    
1380
    if (active_timers[QEMU_TIMER_VIRTUAL]) {
1381
        delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1382
                     qemu_get_clock(vm_clock);
1383
    } else {
1384
        /* To avoid problems with overflow limit this to 2^32.  */
1385
        delta = INT32_MAX;
1386
    }
1387

    
1388
    if (delta < 0)
1389
        delta = 0;
1390

    
1391
    return delta;
1392
}
1393

    
1394
#if defined(__linux__) || defined(_WIN32)
1395
static uint64_t qemu_next_deadline_dyntick(void)
1396
{
1397
    int64_t delta;
1398
    int64_t rtdelta;
1399

    
1400
    if (use_icount)
1401
        delta = INT32_MAX;
1402
    else
1403
        delta = (qemu_next_deadline() + 999) / 1000;
1404

    
1405
    if (active_timers[QEMU_TIMER_REALTIME]) {
1406
        rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1407
                 qemu_get_clock(rt_clock))*1000;
1408
        if (rtdelta < delta)
1409
            delta = rtdelta;
1410
    }
1411

    
1412
    if (delta < MIN_TIMER_REARM_US)
1413
        delta = MIN_TIMER_REARM_US;
1414

    
1415
    return delta;
1416
}
1417
#endif
1418

    
1419
#ifndef _WIN32
1420

    
1421
/* Sets a specific flag */
1422
static int fcntl_setfl(int fd, int flag)
1423
{
1424
    int flags;
1425

    
1426
    flags = fcntl(fd, F_GETFL);
1427
    if (flags == -1)
1428
        return -errno;
1429

    
1430
    if (fcntl(fd, F_SETFL, flags | flag) == -1)
1431
        return -errno;
1432

    
1433
    return 0;
1434
}
1435

    
1436
#if defined(__linux__)
1437

    
1438
#define RTC_FREQ 1024
1439

    
1440
static void enable_sigio_timer(int fd)
1441
{
1442
    struct sigaction act;
1443

    
1444
    /* timer signal */
1445
    sigfillset(&act.sa_mask);
1446
    act.sa_flags = 0;
1447
    act.sa_handler = host_alarm_handler;
1448

    
1449
    sigaction(SIGIO, &act, NULL);
1450
    fcntl_setfl(fd, O_ASYNC);
1451
    fcntl(fd, F_SETOWN, getpid());
1452
}
1453

    
1454
static int hpet_start_timer(struct qemu_alarm_timer *t)
1455
{
1456
    struct hpet_info info;
1457
    int r, fd;
1458

    
1459
    fd = open("/dev/hpet", O_RDONLY);
1460
    if (fd < 0)
1461
        return -1;
1462

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

    
1472
    /* Check capabilities */
1473
    r = ioctl(fd, HPET_INFO, &info);
1474
    if (r < 0)
1475
        goto fail;
1476

    
1477
    /* Enable periodic mode */
1478
    r = ioctl(fd, HPET_EPI, 0);
1479
    if (info.hi_flags && (r < 0))
1480
        goto fail;
1481

    
1482
    /* Enable interrupt */
1483
    r = ioctl(fd, HPET_IE_ON, 0);
1484
    if (r < 0)
1485
        goto fail;
1486

    
1487
    enable_sigio_timer(fd);
1488
    t->priv = (void *)(long)fd;
1489

    
1490
    return 0;
1491
fail:
1492
    close(fd);
1493
    return -1;
1494
}
1495

    
1496
static void hpet_stop_timer(struct qemu_alarm_timer *t)
1497
{
1498
    int fd = (long)t->priv;
1499

    
1500
    close(fd);
1501
}
1502

    
1503
static int rtc_start_timer(struct qemu_alarm_timer *t)
1504
{
1505
    int rtc_fd;
1506
    unsigned long current_rtc_freq = 0;
1507

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

    
1525
    enable_sigio_timer(rtc_fd);
1526

    
1527
    t->priv = (void *)(long)rtc_fd;
1528

    
1529
    return 0;
1530
}
1531

    
1532
static void rtc_stop_timer(struct qemu_alarm_timer *t)
1533
{
1534
    int rtc_fd = (long)t->priv;
1535

    
1536
    close(rtc_fd);
1537
}
1538

    
1539
static int dynticks_start_timer(struct qemu_alarm_timer *t)
1540
{
1541
    struct sigevent ev;
1542
    timer_t host_timer;
1543
    struct sigaction act;
1544

    
1545
    sigfillset(&act.sa_mask);
1546
    act.sa_flags = 0;
1547
    act.sa_handler = host_alarm_handler;
1548

    
1549
    sigaction(SIGALRM, &act, NULL);
1550

    
1551
    ev.sigev_value.sival_int = 0;
1552
    ev.sigev_notify = SIGEV_SIGNAL;
1553
    ev.sigev_signo = SIGALRM;
1554

    
1555
    if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1556
        perror("timer_create");
1557

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

    
1561
        return -1;
1562
    }
1563

    
1564
    t->priv = (void *)(long)host_timer;
1565

    
1566
    return 0;
1567
}
1568

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

    
1573
    timer_delete(host_timer);
1574
}
1575

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

    
1583
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1584
                !active_timers[QEMU_TIMER_VIRTUAL])
1585
        return;
1586

    
1587
    nearest_delta_us = qemu_next_deadline_dyntick();
1588

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

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

    
1610
#endif /* defined(__linux__) */
1611

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

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

    
1623
    sigaction(SIGALRM, &act, NULL);
1624

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

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

    
1635
    return 0;
1636
}
1637

    
1638
static void unix_stop_timer(struct qemu_alarm_timer *t)
1639
{
1640
    struct itimerval itv;
1641

    
1642
    memset(&itv, 0, sizeof(itv));
1643
    setitimer(ITIMER_REAL, &itv, NULL);
1644
}
1645

    
1646
#endif /* !defined(_WIN32) */
1647

    
1648
static void try_to_rearm_timer(void *opaque)
1649
{
1650
    struct qemu_alarm_timer *t = opaque;
1651
#ifndef _WIN32
1652
    ssize_t len;
1653

    
1654
    /* Drain the notify pipe */
1655
    do {
1656
        char buffer[512];
1657
        len = read(alarm_timer_rfd, buffer, sizeof(buffer));
1658
    } while ((len == -1 && errno == EINTR) || len > 0);
1659
#endif
1660

    
1661
    if (t->flags & ALARM_FLAG_EXPIRED) {
1662
        alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
1663
        qemu_rearm_alarm_timer(alarm_timer);
1664
    }
1665
}
1666

    
1667
#ifdef _WIN32
1668

    
1669
static int win32_start_timer(struct qemu_alarm_timer *t)
1670
{
1671
    TIMECAPS tc;
1672
    struct qemu_alarm_win32 *data = t->priv;
1673
    UINT flags;
1674

    
1675
    data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1676
    if (!data->host_alarm) {
1677
        perror("Failed CreateEvent");
1678
        return -1;
1679
    }
1680

    
1681
    memset(&tc, 0, sizeof(tc));
1682
    timeGetDevCaps(&tc, sizeof(tc));
1683

    
1684
    if (data->period < tc.wPeriodMin)
1685
        data->period = tc.wPeriodMin;
1686

    
1687
    timeBeginPeriod(data->period);
1688

    
1689
    flags = TIME_CALLBACK_FUNCTION;
1690
    if (alarm_has_dynticks(t))
1691
        flags |= TIME_ONESHOT;
1692
    else
1693
        flags |= TIME_PERIODIC;
1694

    
1695
    data->timerId = timeSetEvent(1,         // interval (ms)
1696
                        data->period,       // resolution
1697
                        host_alarm_handler, // function
1698
                        (DWORD)t,           // parameter
1699
                        flags);
1700

    
1701
    if (!data->timerId) {
1702
        perror("Failed to initialize win32 alarm timer");
1703

    
1704
        timeEndPeriod(data->period);
1705
        CloseHandle(data->host_alarm);
1706
        return -1;
1707
    }
1708

    
1709
    qemu_add_wait_object(data->host_alarm, try_to_rearm_timer, t);
1710

    
1711
    return 0;
1712
}
1713

    
1714
static void win32_stop_timer(struct qemu_alarm_timer *t)
1715
{
1716
    struct qemu_alarm_win32 *data = t->priv;
1717

    
1718
    timeKillEvent(data->timerId);
1719
    timeEndPeriod(data->period);
1720

    
1721
    CloseHandle(data->host_alarm);
1722
}
1723

    
1724
static void win32_rearm_timer(struct qemu_alarm_timer *t)
1725
{
1726
    struct qemu_alarm_win32 *data = t->priv;
1727
    uint64_t nearest_delta_us;
1728

    
1729
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1730
                !active_timers[QEMU_TIMER_VIRTUAL])
1731
        return;
1732

    
1733
    nearest_delta_us = qemu_next_deadline_dyntick();
1734
    nearest_delta_us /= 1000;
1735

    
1736
    timeKillEvent(data->timerId);
1737

    
1738
    data->timerId = timeSetEvent(1,
1739
                        data->period,
1740
                        host_alarm_handler,
1741
                        (DWORD)t,
1742
                        TIME_ONESHOT | TIME_PERIODIC);
1743

    
1744
    if (!data->timerId) {
1745
        perror("Failed to re-arm win32 alarm timer");
1746

    
1747
        timeEndPeriod(data->period);
1748
        CloseHandle(data->host_alarm);
1749
        exit(1);
1750
    }
1751
}
1752

    
1753
#endif /* _WIN32 */
1754

    
1755
static int init_timer_alarm(void)
1756
{
1757
    struct qemu_alarm_timer *t = NULL;
1758
    int i, err = -1;
1759

    
1760
#ifndef _WIN32
1761
    int fds[2];
1762

    
1763
    err = pipe(fds);
1764
    if (err == -1)
1765
        return -errno;
1766

    
1767
    err = fcntl_setfl(fds[0], O_NONBLOCK);
1768
    if (err < 0)
1769
        goto fail;
1770

    
1771
    err = fcntl_setfl(fds[1], O_NONBLOCK);
1772
    if (err < 0)
1773
        goto fail;
1774

    
1775
    alarm_timer_rfd = fds[0];
1776
    alarm_timer_wfd = fds[1];
1777
#endif
1778

    
1779
    for (i = 0; alarm_timers[i].name; i++) {
1780
        t = &alarm_timers[i];
1781

    
1782
        err = t->start(t);
1783
        if (!err)
1784
            break;
1785
    }
1786

    
1787
    if (err) {
1788
        err = -ENOENT;
1789
        goto fail;
1790
    }
1791

    
1792
#ifndef _WIN32
1793
    qemu_set_fd_handler2(alarm_timer_rfd, NULL,
1794
                         try_to_rearm_timer, NULL, t);
1795
#endif
1796

    
1797
    alarm_timer = t;
1798

    
1799
    return 0;
1800

    
1801
fail:
1802
#ifndef _WIN32
1803
    close(fds[0]);
1804
    close(fds[1]);
1805
#endif
1806
    return err;
1807
}
1808

    
1809
static void quit_timers(void)
1810
{
1811
    alarm_timer->stop(alarm_timer);
1812
    alarm_timer = NULL;
1813
}
1814

    
1815
/***********************************************************/
1816
/* host time/date access */
1817
void qemu_get_timedate(struct tm *tm, int offset)
1818
{
1819
    time_t ti;
1820
    struct tm *ret;
1821

    
1822
    time(&ti);
1823
    ti += offset;
1824
    if (rtc_date_offset == -1) {
1825
        if (rtc_utc)
1826
            ret = gmtime(&ti);
1827
        else
1828
            ret = localtime(&ti);
1829
    } else {
1830
        ti -= rtc_date_offset;
1831
        ret = gmtime(&ti);
1832
    }
1833

    
1834
    memcpy(tm, ret, sizeof(struct tm));
1835
}
1836

    
1837
int qemu_timedate_diff(struct tm *tm)
1838
{
1839
    time_t seconds;
1840

    
1841
    if (rtc_date_offset == -1)
1842
        if (rtc_utc)
1843
            seconds = mktimegm(tm);
1844
        else
1845
            seconds = mktime(tm);
1846
    else
1847
        seconds = mktimegm(tm) + rtc_date_offset;
1848

    
1849
    return seconds - time(NULL);
1850
}
1851

    
1852
#ifdef _WIN32
1853
static void socket_cleanup(void)
1854
{
1855
    WSACleanup();
1856
}
1857

    
1858
static int socket_init(void)
1859
{
1860
    WSADATA Data;
1861
    int ret, err;
1862

    
1863
    ret = WSAStartup(MAKEWORD(2,2), &Data);
1864
    if (ret != 0) {
1865
        err = WSAGetLastError();
1866
        fprintf(stderr, "WSAStartup: %d\n", err);
1867
        return -1;
1868
    }
1869
    atexit(socket_cleanup);
1870
    return 0;
1871
}
1872
#endif
1873

    
1874
const char *get_opt_name(char *buf, int buf_size, const char *p, char delim)
1875
{
1876
    char *q;
1877

    
1878
    q = buf;
1879
    while (*p != '\0' && *p != delim) {
1880
        if (q && (q - buf) < buf_size - 1)
1881
            *q++ = *p;
1882
        p++;
1883
    }
1884
    if (q)
1885
        *q = '\0';
1886

    
1887
    return p;
1888
}
1889

    
1890
const char *get_opt_value(char *buf, int buf_size, const char *p)
1891
{
1892
    char *q;
1893

    
1894
    q = buf;
1895
    while (*p != '\0') {
1896
        if (*p == ',') {
1897
            if (*(p + 1) != ',')
1898
                break;
1899
            p++;
1900
        }
1901
        if (q && (q - buf) < buf_size - 1)
1902
            *q++ = *p;
1903
        p++;
1904
    }
1905
    if (q)
1906
        *q = '\0';
1907

    
1908
    return p;
1909
}
1910

    
1911
int get_param_value(char *buf, int buf_size,
1912
                    const char *tag, const char *str)
1913
{
1914
    const char *p;
1915
    char option[128];
1916

    
1917
    p = str;
1918
    for(;;) {
1919
        p = get_opt_name(option, sizeof(option), p, '=');
1920
        if (*p != '=')
1921
            break;
1922
        p++;
1923
        if (!strcmp(tag, option)) {
1924
            (void)get_opt_value(buf, buf_size, p);
1925
            return strlen(buf);
1926
        } else {
1927
            p = get_opt_value(NULL, 0, p);
1928
        }
1929
        if (*p != ',')
1930
            break;
1931
        p++;
1932
    }
1933
    return 0;
1934
}
1935

    
1936
int check_params(char *buf, int buf_size,
1937
                 const char * const *params, const char *str)
1938
{
1939
    const char *p;
1940
    int i;
1941

    
1942
    p = str;
1943
    while (*p != '\0') {
1944
        p = get_opt_name(buf, buf_size, p, '=');
1945
        if (*p != '=')
1946
            return -1;
1947
        p++;
1948
        for(i = 0; params[i] != NULL; i++)
1949
            if (!strcmp(params[i], buf))
1950
                break;
1951
        if (params[i] == NULL)
1952
            return -1;
1953
        p = get_opt_value(NULL, 0, p);
1954
        if (*p != ',')
1955
            break;
1956
        p++;
1957
    }
1958
    return 0;
1959
}
1960

    
1961
/***********************************************************/
1962
/* Bluetooth support */
1963
static int nb_hcis;
1964
static int cur_hci;
1965
static struct HCIInfo *hci_table[MAX_NICS];
1966

    
1967
static struct bt_vlan_s {
1968
    struct bt_scatternet_s net;
1969
    int id;
1970
    struct bt_vlan_s *next;
1971
} *first_bt_vlan;
1972

    
1973
/* find or alloc a new bluetooth "VLAN" */
1974
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1975
{
1976
    struct bt_vlan_s **pvlan, *vlan;
1977
    for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1978
        if (vlan->id == id)
1979
            return &vlan->net;
1980
    }
1981
    vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1982
    vlan->id = id;
1983
    pvlan = &first_bt_vlan;
1984
    while (*pvlan != NULL)
1985
        pvlan = &(*pvlan)->next;
1986
    *pvlan = vlan;
1987
    return &vlan->net;
1988
}
1989

    
1990
static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1991
{
1992
}
1993

    
1994
static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1995
{
1996
    return -ENOTSUP;
1997
}
1998

    
1999
static struct HCIInfo null_hci = {
2000
    .cmd_send = null_hci_send,
2001
    .sco_send = null_hci_send,
2002
    .acl_send = null_hci_send,
2003
    .bdaddr_set = null_hci_addr_set,
2004
};
2005

    
2006
struct HCIInfo *qemu_next_hci(void)
2007
{
2008
    if (cur_hci == nb_hcis)
2009
        return &null_hci;
2010

    
2011
    return hci_table[cur_hci++];
2012
}
2013

    
2014
static struct HCIInfo *hci_init(const char *str)
2015
{
2016
    char *endp;
2017
    struct bt_scatternet_s *vlan = 0;
2018

    
2019
    if (!strcmp(str, "null"))
2020
        /* null */
2021
        return &null_hci;
2022
    else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
2023
        /* host[:hciN] */
2024
        return bt_host_hci(str[4] ? str + 5 : "hci0");
2025
    else if (!strncmp(str, "hci", 3)) {
2026
        /* hci[,vlan=n] */
2027
        if (str[3]) {
2028
            if (!strncmp(str + 3, ",vlan=", 6)) {
2029
                vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
2030
                if (*endp)
2031
                    vlan = 0;
2032
            }
2033
        } else
2034
            vlan = qemu_find_bt_vlan(0);
2035
        if (vlan)
2036
           return bt_new_hci(vlan);
2037
    }
2038

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

    
2041
    return 0;
2042
}
2043

    
2044
static int bt_hci_parse(const char *str)
2045
{
2046
    struct HCIInfo *hci;
2047
    bdaddr_t bdaddr;
2048

    
2049
    if (nb_hcis >= MAX_NICS) {
2050
        fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
2051
        return -1;
2052
    }
2053

    
2054
    hci = hci_init(str);
2055
    if (!hci)
2056
        return -1;
2057

    
2058
    bdaddr.b[0] = 0x52;
2059
    bdaddr.b[1] = 0x54;
2060
    bdaddr.b[2] = 0x00;
2061
    bdaddr.b[3] = 0x12;
2062
    bdaddr.b[4] = 0x34;
2063
    bdaddr.b[5] = 0x56 + nb_hcis;
2064
    hci->bdaddr_set(hci, bdaddr.b);
2065

    
2066
    hci_table[nb_hcis++] = hci;
2067

    
2068
    return 0;
2069
}
2070

    
2071
static void bt_vhci_add(int vlan_id)
2072
{
2073
    struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
2074

    
2075
    if (!vlan->slave)
2076
        fprintf(stderr, "qemu: warning: adding a VHCI to "
2077
                        "an empty scatternet %i\n", vlan_id);
2078

    
2079
    bt_vhci_init(bt_new_hci(vlan));
2080
}
2081

    
2082
static struct bt_device_s *bt_device_add(const char *opt)
2083
{
2084
    struct bt_scatternet_s *vlan;
2085
    int vlan_id = 0;
2086
    char *endp = strstr(opt, ",vlan=");
2087
    int len = (endp ? endp - opt : strlen(opt)) + 1;
2088
    char devname[10];
2089

    
2090
    pstrcpy(devname, MIN(sizeof(devname), len), opt);
2091

    
2092
    if (endp) {
2093
        vlan_id = strtol(endp + 6, &endp, 0);
2094
        if (*endp) {
2095
            fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2096
            return 0;
2097
        }
2098
    }
2099

    
2100
    vlan = qemu_find_bt_vlan(vlan_id);
2101

    
2102
    if (!vlan->slave)
2103
        fprintf(stderr, "qemu: warning: adding a slave device to "
2104
                        "an empty scatternet %i\n", vlan_id);
2105

    
2106
    if (!strcmp(devname, "keyboard"))
2107
        return bt_keyboard_init(vlan);
2108

    
2109
    fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2110
    return 0;
2111
}
2112

    
2113
static int bt_parse(const char *opt)
2114
{
2115
    const char *endp, *p;
2116
    int vlan;
2117

    
2118
    if (strstart(opt, "hci", &endp)) {
2119
        if (!*endp || *endp == ',') {
2120
            if (*endp)
2121
                if (!strstart(endp, ",vlan=", 0))
2122
                    opt = endp + 1;
2123

    
2124
            return bt_hci_parse(opt);
2125
       }
2126
    } else if (strstart(opt, "vhci", &endp)) {
2127
        if (!*endp || *endp == ',') {
2128
            if (*endp) {
2129
                if (strstart(endp, ",vlan=", &p)) {
2130
                    vlan = strtol(p, (char **) &endp, 0);
2131
                    if (*endp) {
2132
                        fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2133
                        return 1;
2134
                    }
2135
                } else {
2136
                    fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2137
                    return 1;
2138
                }
2139
            } else
2140
                vlan = 0;
2141

    
2142
            bt_vhci_add(vlan);
2143
            return 0;
2144
        }
2145
    } else if (strstart(opt, "device:", &endp))
2146
        return !bt_device_add(endp);
2147

    
2148
    fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2149
    return 1;
2150
}
2151

    
2152
/***********************************************************/
2153
/* QEMU Block devices */
2154

    
2155
#define HD_ALIAS "index=%d,media=disk"
2156
#define CDROM_ALIAS "index=2,media=cdrom"
2157
#define FD_ALIAS "index=%d,if=floppy"
2158
#define PFLASH_ALIAS "if=pflash"
2159
#define MTD_ALIAS "if=mtd"
2160
#define SD_ALIAS "index=0,if=sd"
2161

    
2162
static int drive_opt_get_free_idx(void)
2163
{
2164
    int index;
2165

    
2166
    for (index = 0; index < MAX_DRIVES; index++)
2167
        if (!drives_opt[index].used) {
2168
            drives_opt[index].used = 1;
2169
            return index;
2170
        }
2171

    
2172
    return -1;
2173
}
2174

    
2175
static int drive_get_free_idx(void)
2176
{
2177
    int index;
2178

    
2179
    for (index = 0; index < MAX_DRIVES; index++)
2180
        if (!drives_table[index].used) {
2181
            drives_table[index].used = 1;
2182
            return index;
2183
        }
2184

    
2185
    return -1;
2186
}
2187

    
2188
int drive_add(const char *file, const char *fmt, ...)
2189
{
2190
    va_list ap;
2191
    int index = drive_opt_get_free_idx();
2192

    
2193
    if (nb_drives_opt >= MAX_DRIVES || index == -1) {
2194
        fprintf(stderr, "qemu: too many drives\n");
2195
        return -1;
2196
    }
2197

    
2198
    drives_opt[index].file = file;
2199
    va_start(ap, fmt);
2200
    vsnprintf(drives_opt[index].opt,
2201
              sizeof(drives_opt[0].opt), fmt, ap);
2202
    va_end(ap);
2203

    
2204
    nb_drives_opt++;
2205
    return index;
2206
}
2207

    
2208
void drive_remove(int index)
2209
{
2210
    drives_opt[index].used = 0;
2211
    nb_drives_opt--;
2212
}
2213

    
2214
int drive_get_index(BlockInterfaceType type, int bus, int unit)
2215
{
2216
    int index;
2217

    
2218
    /* seek interface, bus and unit */
2219

    
2220
    for (index = 0; index < MAX_DRIVES; index++)
2221
        if (drives_table[index].type == type &&
2222
            drives_table[index].bus == bus &&
2223
            drives_table[index].unit == unit &&
2224
            drives_table[index].used)
2225
        return index;
2226

    
2227
    return -1;
2228
}
2229

    
2230
int drive_get_max_bus(BlockInterfaceType type)
2231
{
2232
    int max_bus;
2233
    int index;
2234

    
2235
    max_bus = -1;
2236
    for (index = 0; index < nb_drives; index++) {
2237
        if(drives_table[index].type == type &&
2238
           drives_table[index].bus > max_bus)
2239
            max_bus = drives_table[index].bus;
2240
    }
2241
    return max_bus;
2242
}
2243

    
2244
const char *drive_get_serial(BlockDriverState *bdrv)
2245
{
2246
    int index;
2247

    
2248
    for (index = 0; index < nb_drives; index++)
2249
        if (drives_table[index].bdrv == bdrv)
2250
            return drives_table[index].serial;
2251

    
2252
    return "\0";
2253
}
2254

    
2255
BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2256
{
2257
    int index;
2258

    
2259
    for (index = 0; index < nb_drives; index++)
2260
        if (drives_table[index].bdrv == bdrv)
2261
            return drives_table[index].onerror;
2262

    
2263
    return BLOCK_ERR_STOP_ENOSPC;
2264
}
2265

    
2266
static void bdrv_format_print(void *opaque, const char *name)
2267
{
2268
    fprintf(stderr, " %s", name);
2269
}
2270

    
2271
void drive_uninit(BlockDriverState *bdrv)
2272
{
2273
    int i;
2274

    
2275
    for (i = 0; i < MAX_DRIVES; i++)
2276
        if (drives_table[i].bdrv == bdrv) {
2277
            drives_table[i].bdrv = NULL;
2278
            drives_table[i].used = 0;
2279
            drive_remove(drives_table[i].drive_opt_idx);
2280
            nb_drives--;
2281
            break;
2282
        }
2283
}
2284

    
2285
int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
2286
{
2287
    char buf[128];
2288
    char file[1024];
2289
    char devname[128];
2290
    char serial[21];
2291
    const char *mediastr = "";
2292
    BlockInterfaceType type;
2293
    enum { MEDIA_DISK, MEDIA_CDROM } media;
2294
    int bus_id, unit_id;
2295
    int cyls, heads, secs, translation;
2296
    BlockDriverState *bdrv;
2297
    BlockDriver *drv = NULL;
2298
    QEMUMachine *machine = opaque;
2299
    int max_devs;
2300
    int index;
2301
    int cache;
2302
    int bdrv_flags, onerror;
2303
    int drives_table_idx;
2304
    char *str = arg->opt;
2305
    static const char * const params[] = { "bus", "unit", "if", "index",
2306
                                           "cyls", "heads", "secs", "trans",
2307
                                           "media", "snapshot", "file",
2308
                                           "cache", "format", "serial", "werror",
2309
                                           NULL };
2310

    
2311
    if (check_params(buf, sizeof(buf), params, str) < 0) {
2312
         fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
2313
                         buf, str);
2314
         return -1;
2315
    }
2316

    
2317
    file[0] = 0;
2318
    cyls = heads = secs = 0;
2319
    bus_id = 0;
2320
    unit_id = -1;
2321
    translation = BIOS_ATA_TRANSLATION_AUTO;
2322
    index = -1;
2323
    cache = 3;
2324

    
2325
    if (machine->use_scsi) {
2326
        type = IF_SCSI;
2327
        max_devs = MAX_SCSI_DEVS;
2328
        pstrcpy(devname, sizeof(devname), "scsi");
2329
    } else {
2330
        type = IF_IDE;
2331
        max_devs = MAX_IDE_DEVS;
2332
        pstrcpy(devname, sizeof(devname), "ide");
2333
    }
2334
    media = MEDIA_DISK;
2335

    
2336
    /* extract parameters */
2337

    
2338
    if (get_param_value(buf, sizeof(buf), "bus", str)) {
2339
        bus_id = strtol(buf, NULL, 0);
2340
        if (bus_id < 0) {
2341
            fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2342
            return -1;
2343
        }
2344
    }
2345

    
2346
    if (get_param_value(buf, sizeof(buf), "unit", str)) {
2347
        unit_id = strtol(buf, NULL, 0);
2348
        if (unit_id < 0) {
2349
            fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2350
            return -1;
2351
        }
2352
    }
2353

    
2354
    if (get_param_value(buf, sizeof(buf), "if", str)) {
2355
        pstrcpy(devname, sizeof(devname), buf);
2356
        if (!strcmp(buf, "ide")) {
2357
            type = IF_IDE;
2358
            max_devs = MAX_IDE_DEVS;
2359
        } else if (!strcmp(buf, "scsi")) {
2360
            type = IF_SCSI;
2361
            max_devs = MAX_SCSI_DEVS;
2362
        } else if (!strcmp(buf, "floppy")) {
2363
            type = IF_FLOPPY;
2364
            max_devs = 0;
2365
        } else if (!strcmp(buf, "pflash")) {
2366
            type = IF_PFLASH;
2367
            max_devs = 0;
2368
        } else if (!strcmp(buf, "mtd")) {
2369
            type = IF_MTD;
2370
            max_devs = 0;
2371
        } else if (!strcmp(buf, "sd")) {
2372
            type = IF_SD;
2373
            max_devs = 0;
2374
        } else if (!strcmp(buf, "virtio")) {
2375
            type = IF_VIRTIO;
2376
            max_devs = 0;
2377
        } else if (!strcmp(buf, "xen")) {
2378
            type = IF_XEN;
2379
            max_devs = 0;
2380
        } else {
2381
            fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2382
            return -1;
2383
        }
2384
    }
2385

    
2386
    if (get_param_value(buf, sizeof(buf), "index", str)) {
2387
        index = strtol(buf, NULL, 0);
2388
        if (index < 0) {
2389
            fprintf(stderr, "qemu: '%s' invalid index\n", str);
2390
            return -1;
2391
        }
2392
    }
2393

    
2394
    if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2395
        cyls = strtol(buf, NULL, 0);
2396
    }
2397

    
2398
    if (get_param_value(buf, sizeof(buf), "heads", str)) {
2399
        heads = strtol(buf, NULL, 0);
2400
    }
2401

    
2402
    if (get_param_value(buf, sizeof(buf), "secs", str)) {
2403
        secs = strtol(buf, NULL, 0);
2404
    }
2405

    
2406
    if (cyls || heads || secs) {
2407
        if (cyls < 1 || cyls > 16383) {
2408
            fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2409
            return -1;
2410
        }
2411
        if (heads < 1 || heads > 16) {
2412
            fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2413
            return -1;
2414
        }
2415
        if (secs < 1 || secs > 63) {
2416
            fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2417
            return -1;
2418
        }
2419
    }
2420

    
2421
    if (get_param_value(buf, sizeof(buf), "trans", str)) {
2422
        if (!cyls) {
2423
            fprintf(stderr,
2424
                    "qemu: '%s' trans must be used with cyls,heads and secs\n",
2425
                    str);
2426
            return -1;
2427
        }
2428
        if (!strcmp(buf, "none"))
2429
            translation = BIOS_ATA_TRANSLATION_NONE;
2430
        else if (!strcmp(buf, "lba"))
2431
            translation = BIOS_ATA_TRANSLATION_LBA;
2432
        else if (!strcmp(buf, "auto"))
2433
            translation = BIOS_ATA_TRANSLATION_AUTO;
2434
        else {
2435
            fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2436
            return -1;
2437
        }
2438
    }
2439

    
2440
    if (get_param_value(buf, sizeof(buf), "media", str)) {
2441
        if (!strcmp(buf, "disk")) {
2442
            media = MEDIA_DISK;
2443
        } else if (!strcmp(buf, "cdrom")) {
2444
            if (cyls || secs || heads) {
2445
                fprintf(stderr,
2446
                        "qemu: '%s' invalid physical CHS format\n", str);
2447
                return -1;
2448
            }
2449
            media = MEDIA_CDROM;
2450
        } else {
2451
            fprintf(stderr, "qemu: '%s' invalid media\n", str);
2452
            return -1;
2453
        }
2454
    }
2455

    
2456
    if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2457
        if (!strcmp(buf, "on"))
2458
            snapshot = 1;
2459
        else if (!strcmp(buf, "off"))
2460
            snapshot = 0;
2461
        else {
2462
            fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2463
            return -1;
2464
        }
2465
    }
2466

    
2467
    if (get_param_value(buf, sizeof(buf), "cache", str)) {
2468
        if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2469
            cache = 0;
2470
        else if (!strcmp(buf, "writethrough"))
2471
            cache = 1;
2472
        else if (!strcmp(buf, "writeback"))
2473
            cache = 2;
2474
        else {
2475
           fprintf(stderr, "qemu: invalid cache option\n");
2476
           return -1;
2477
        }
2478
    }
2479

    
2480
    if (get_param_value(buf, sizeof(buf), "format", str)) {
2481
       if (strcmp(buf, "?") == 0) {
2482
            fprintf(stderr, "qemu: Supported formats:");
2483
            bdrv_iterate_format(bdrv_format_print, NULL);
2484
            fprintf(stderr, "\n");
2485
            return -1;
2486
        }
2487
        drv = bdrv_find_format(buf);
2488
        if (!drv) {
2489
            fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2490
            return -1;
2491
        }
2492
    }
2493

    
2494
    if (arg->file == NULL)
2495
        get_param_value(file, sizeof(file), "file", str);
2496
    else
2497
        pstrcpy(file, sizeof(file), arg->file);
2498

    
2499
    if (!get_param_value(serial, sizeof(serial), "serial", str))
2500
            memset(serial, 0,  sizeof(serial));
2501

    
2502
    onerror = BLOCK_ERR_STOP_ENOSPC;
2503
    if (get_param_value(buf, sizeof(serial), "werror", str)) {
2504
        if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2505
            fprintf(stderr, "werror is no supported by this format\n");
2506
            return -1;
2507
        }
2508
        if (!strcmp(buf, "ignore"))
2509
            onerror = BLOCK_ERR_IGNORE;
2510
        else if (!strcmp(buf, "enospc"))
2511
            onerror = BLOCK_ERR_STOP_ENOSPC;
2512
        else if (!strcmp(buf, "stop"))
2513
            onerror = BLOCK_ERR_STOP_ANY;
2514
        else if (!strcmp(buf, "report"))
2515
            onerror = BLOCK_ERR_REPORT;
2516
        else {
2517
            fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2518
            return -1;
2519
        }
2520
    }
2521

    
2522
    /* compute bus and unit according index */
2523

    
2524
    if (index != -1) {
2525
        if (bus_id != 0 || unit_id != -1) {
2526
            fprintf(stderr,
2527
                    "qemu: '%s' index cannot be used with bus and unit\n", str);
2528
            return -1;
2529
        }
2530
        if (max_devs == 0)
2531
        {
2532
            unit_id = index;
2533
            bus_id = 0;
2534
        } else {
2535
            unit_id = index % max_devs;
2536
            bus_id = index / max_devs;
2537
        }
2538
    }
2539

    
2540
    /* if user doesn't specify a unit_id,
2541
     * try to find the first free
2542
     */
2543

    
2544
    if (unit_id == -1) {
2545
       unit_id = 0;
2546
       while (drive_get_index(type, bus_id, unit_id) != -1) {
2547
           unit_id++;
2548
           if (max_devs && unit_id >= max_devs) {
2549
               unit_id -= max_devs;
2550
               bus_id++;
2551
           }
2552
       }
2553
    }
2554

    
2555
    /* check unit id */
2556

    
2557
    if (max_devs && unit_id >= max_devs) {
2558
        fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2559
                        str, unit_id, max_devs - 1);
2560
        return -1;
2561
    }
2562

    
2563
    /*
2564
     * ignore multiple definitions
2565
     */
2566

    
2567
    if (drive_get_index(type, bus_id, unit_id) != -1)
2568
        return -2;
2569

    
2570
    /* init */
2571

    
2572
    if (type == IF_IDE || type == IF_SCSI)
2573
        mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2574
    if (max_devs)
2575
        snprintf(buf, sizeof(buf), "%s%i%s%i",
2576
                 devname, bus_id, mediastr, unit_id);
2577
    else
2578
        snprintf(buf, sizeof(buf), "%s%s%i",
2579
                 devname, mediastr, unit_id);
2580
    bdrv = bdrv_new(buf);
2581
    drives_table_idx = drive_get_free_idx();
2582
    drives_table[drives_table_idx].bdrv = bdrv;
2583
    drives_table[drives_table_idx].type = type;
2584
    drives_table[drives_table_idx].bus = bus_id;
2585
    drives_table[drives_table_idx].unit = unit_id;
2586
    drives_table[drives_table_idx].onerror = onerror;
2587
    drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
2588
    strncpy(drives_table[nb_drives].serial, serial, sizeof(serial));
2589
    nb_drives++;
2590

    
2591
    switch(type) {
2592
    case IF_IDE:
2593
    case IF_SCSI:
2594
    case IF_XEN:
2595
        switch(media) {
2596
        case MEDIA_DISK:
2597
            if (cyls != 0) {
2598
                bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2599
                bdrv_set_translation_hint(bdrv, translation);
2600
            }
2601
            break;
2602
        case MEDIA_CDROM:
2603
            bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2604
            break;
2605
        }
2606
        break;
2607
    case IF_SD:
2608
        /* FIXME: This isn't really a floppy, but it's a reasonable
2609
           approximation.  */
2610
    case IF_FLOPPY:
2611
        bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2612
        break;
2613
    case IF_PFLASH:
2614
    case IF_MTD:
2615
    case IF_VIRTIO:
2616
        break;
2617
    }
2618
    if (!file[0])
2619
        return -2;
2620
    bdrv_flags = 0;
2621
    if (snapshot) {
2622
        bdrv_flags |= BDRV_O_SNAPSHOT;
2623
        cache = 2; /* always use write-back with snapshot */
2624
    }
2625
    if (cache == 0) /* no caching */
2626
        bdrv_flags |= BDRV_O_NOCACHE;
2627
    else if (cache == 2) /* write-back */
2628
        bdrv_flags |= BDRV_O_CACHE_WB;
2629
    else if (cache == 3) /* not specified */
2630
        bdrv_flags |= BDRV_O_CACHE_DEF;
2631
    if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) {
2632
        fprintf(stderr, "qemu: could not open disk image %s\n",
2633
                        file);
2634
        return -1;
2635
    }
2636
    if (bdrv_key_required(bdrv))
2637
        autostart = 0;
2638
    return drives_table_idx;
2639
}
2640

    
2641
static void numa_add(const char *optarg)
2642
{
2643
    char option[128];
2644
    char *endptr;
2645
    unsigned long long value, endvalue;
2646
    int nodenr;
2647

    
2648
    optarg = get_opt_name(option, 128, optarg, ',') + 1;
2649
    if (!strcmp(option, "node")) {
2650
        if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2651
            nodenr = nb_numa_nodes;
2652
        } else {
2653
            nodenr = strtoull(option, NULL, 10);
2654
        }
2655

    
2656
        if (get_param_value(option, 128, "mem", optarg) == 0) {
2657
            node_mem[nodenr] = 0;
2658
        } else {
2659
            value = strtoull(option, &endptr, 0);
2660
            switch (*endptr) {
2661
            case 0: case 'M': case 'm':
2662
                value <<= 20;
2663
                break;
2664
            case 'G': case 'g':
2665
                value <<= 30;
2666
                break;
2667
            }
2668
            node_mem[nodenr] = value;
2669
        }
2670
        if (get_param_value(option, 128, "cpus", optarg) == 0) {
2671
            node_cpumask[nodenr] = 0;
2672
        } else {
2673
            value = strtoull(option, &endptr, 10);
2674
            if (value >= 64) {
2675
                value = 63;
2676
                fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2677
            } else {
2678
                if (*endptr == '-') {
2679
                    endvalue = strtoull(endptr+1, &endptr, 10);
2680
                    if (endvalue >= 63) {
2681
                        endvalue = 62;
2682
                        fprintf(stderr,
2683
                            "only 63 CPUs in NUMA mode supported.\n");
2684
                    }
2685
                    value = (1 << (endvalue + 1)) - (1 << value);
2686
                } else {
2687
                    value = 1 << value;
2688
                }
2689
            }
2690
            node_cpumask[nodenr] = value;
2691
        }
2692
        nb_numa_nodes++;
2693
    }
2694
    return;
2695
}
2696

    
2697
/***********************************************************/
2698
/* USB devices */
2699

    
2700
static USBPort *used_usb_ports;
2701
static USBPort *free_usb_ports;
2702

    
2703
/* ??? Maybe change this to register a hub to keep track of the topology.  */
2704
void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2705
                            usb_attachfn attach)
2706
{
2707
    port->opaque = opaque;
2708
    port->index = index;
2709
    port->attach = attach;
2710
    port->next = free_usb_ports;
2711
    free_usb_ports = port;
2712
}
2713

    
2714
int usb_device_add_dev(USBDevice *dev)
2715
{
2716
    USBPort *port;
2717

    
2718
    /* Find a USB port to add the device to.  */
2719
    port = free_usb_ports;
2720
    if (!port->next) {
2721
        USBDevice *hub;
2722

    
2723
        /* Create a new hub and chain it on.  */
2724
        free_usb_ports = NULL;
2725
        port->next = used_usb_ports;
2726
        used_usb_ports = port;
2727

    
2728
        hub = usb_hub_init(VM_USB_HUB_SIZE);
2729
        usb_attach(port, hub);
2730
        port = free_usb_ports;
2731
    }
2732

    
2733
    free_usb_ports = port->next;
2734
    port->next = used_usb_ports;
2735
    used_usb_ports = port;
2736
    usb_attach(port, dev);
2737
    return 0;
2738
}
2739

    
2740
static void usb_msd_password_cb(void *opaque, int err)
2741
{
2742
    USBDevice *dev = opaque;
2743

    
2744
    if (!err)
2745
        usb_device_add_dev(dev);
2746
    else
2747
        dev->handle_destroy(dev);
2748
}
2749

    
2750
static int usb_device_add(const char *devname, int is_hotplug)
2751
{
2752
    const char *p;
2753
    USBDevice *dev;
2754

    
2755
    if (!free_usb_ports)
2756
        return -1;
2757

    
2758
    if (strstart(devname, "host:", &p)) {
2759
        dev = usb_host_device_open(p);
2760
    } else if (!strcmp(devname, "mouse")) {
2761
        dev = usb_mouse_init();
2762
    } else if (!strcmp(devname, "tablet")) {
2763
        dev = usb_tablet_init();
2764
    } else if (!strcmp(devname, "keyboard")) {
2765
        dev = usb_keyboard_init();
2766
    } else if (strstart(devname, "disk:", &p)) {
2767
        BlockDriverState *bs;
2768

    
2769
        dev = usb_msd_init(p);
2770
        if (!dev)
2771
            return -1;
2772
        bs = usb_msd_get_bdrv(dev);
2773
        if (bdrv_key_required(bs)) {
2774
            autostart = 0;
2775
            if (is_hotplug) {
2776
                monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
2777
                                            dev);
2778
                return 0;
2779
            }
2780
        }
2781
    } else if (!strcmp(devname, "wacom-tablet")) {
2782
        dev = usb_wacom_init();
2783
    } else if (strstart(devname, "serial:", &p)) {
2784
        dev = usb_serial_init(p);
2785
#ifdef CONFIG_BRLAPI
2786
    } else if (!strcmp(devname, "braille")) {
2787
        dev = usb_baum_init();
2788
#endif
2789
    } else if (strstart(devname, "net:", &p)) {
2790
        int nic = nb_nics;
2791

    
2792
        if (net_client_init("nic", p) < 0)
2793
            return -1;
2794
        nd_table[nic].model = "usb";
2795
        dev = usb_net_init(&nd_table[nic]);
2796
    } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2797
        dev = usb_bt_init(devname[2] ? hci_init(p) :
2798
                        bt_new_hci(qemu_find_bt_vlan(0)));
2799
    } else {
2800
        return -1;
2801
    }
2802
    if (!dev)
2803
        return -1;
2804

    
2805
    return usb_device_add_dev(dev);
2806
}
2807

    
2808
int usb_device_del_addr(int bus_num, int addr)
2809
{
2810
    USBPort *port;
2811
    USBPort **lastp;
2812
    USBDevice *dev;
2813

    
2814
    if (!used_usb_ports)
2815
        return -1;
2816

    
2817
    if (bus_num != 0)
2818
        return -1;
2819

    
2820
    lastp = &used_usb_ports;
2821
    port = used_usb_ports;
2822
    while (port && port->dev->addr != addr) {
2823
        lastp = &port->next;
2824
        port = port->next;
2825
    }
2826

    
2827
    if (!port)
2828
        return -1;
2829

    
2830
    dev = port->dev;
2831
    *lastp = port->next;
2832
    usb_attach(port, NULL);
2833
    dev->handle_destroy(dev);
2834
    port->next = free_usb_ports;
2835
    free_usb_ports = port;
2836
    return 0;
2837
}
2838

    
2839
static int usb_device_del(const char *devname)
2840
{
2841
    int bus_num, addr;
2842
    const char *p;
2843

    
2844
    if (strstart(devname, "host:", &p))
2845
        return usb_host_device_close(p);
2846

    
2847
    if (!used_usb_ports)
2848
        return -1;
2849

    
2850
    p = strchr(devname, '.');
2851
    if (!p)
2852
        return -1;
2853
    bus_num = strtoul(devname, NULL, 0);
2854
    addr = strtoul(p + 1, NULL, 0);
2855

    
2856
    return usb_device_del_addr(bus_num, addr);
2857
}
2858

    
2859
void do_usb_add(Monitor *mon, const char *devname)
2860
{
2861
    usb_device_add(devname, 1);
2862
}
2863

    
2864
void do_usb_del(Monitor *mon, const char *devname)
2865
{
2866
    usb_device_del(devname);
2867
}
2868

    
2869
void usb_info(Monitor *mon)
2870
{
2871
    USBDevice *dev;
2872
    USBPort *port;
2873
    const char *speed_str;
2874

    
2875
    if (!usb_enabled) {
2876
        monitor_printf(mon, "USB support not enabled\n");
2877
        return;
2878
    }
2879

    
2880
    for (port = used_usb_ports; port; port = port->next) {
2881
        dev = port->dev;
2882
        if (!dev)
2883
            continue;
2884
        switch(dev->speed) {
2885
        case USB_SPEED_LOW:
2886
            speed_str = "1.5";
2887
            break;
2888
        case USB_SPEED_FULL:
2889
            speed_str = "12";
2890
            break;
2891
        case USB_SPEED_HIGH:
2892
            speed_str = "480";
2893
            break;
2894
        default:
2895
            speed_str = "?";
2896
            break;
2897
        }
2898
        monitor_printf(mon, "  Device %d.%d, Speed %s Mb/s, Product %s\n",
2899
                       0, dev->addr, speed_str, dev->devname);
2900
    }
2901
}
2902

    
2903
/***********************************************************/
2904
/* PCMCIA/Cardbus */
2905

    
2906
static struct pcmcia_socket_entry_s {
2907
    struct pcmcia_socket_s *socket;
2908
    struct pcmcia_socket_entry_s *next;
2909
} *pcmcia_sockets = 0;
2910

    
2911
void pcmcia_socket_register(struct pcmcia_socket_s *socket)
2912
{
2913
    struct pcmcia_socket_entry_s *entry;
2914

    
2915
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2916
    entry->socket = socket;
2917
    entry->next = pcmcia_sockets;
2918
    pcmcia_sockets = entry;
2919
}
2920

    
2921
void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
2922
{
2923
    struct pcmcia_socket_entry_s *entry, **ptr;
2924

    
2925
    ptr = &pcmcia_sockets;
2926
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2927
        if (entry->socket == socket) {
2928
            *ptr = entry->next;
2929
            qemu_free(entry);
2930
        }
2931
}
2932

    
2933
void pcmcia_info(Monitor *mon)
2934
{
2935
    struct pcmcia_socket_entry_s *iter;
2936

    
2937
    if (!pcmcia_sockets)
2938
        monitor_printf(mon, "No PCMCIA sockets\n");
2939

    
2940
    for (iter = pcmcia_sockets; iter; iter = iter->next)
2941
        monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2942
                       iter->socket->attached ? iter->socket->card_string :
2943
                       "Empty");
2944
}
2945

    
2946
/***********************************************************/
2947
/* register display */
2948

    
2949
struct DisplayAllocator default_allocator = {
2950
    defaultallocator_create_displaysurface,
2951
    defaultallocator_resize_displaysurface,
2952
    defaultallocator_free_displaysurface
2953
};
2954

    
2955
void register_displaystate(DisplayState *ds)
2956
{
2957
    DisplayState **s;
2958
    s = &display_state;
2959
    while (*s != NULL)
2960
        s = &(*s)->next;
2961
    ds->next = NULL;
2962
    *s = ds;
2963
}
2964

    
2965
DisplayState *get_displaystate(void)
2966
{
2967
    return display_state;
2968
}
2969

    
2970
DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2971
{
2972
    if(ds->allocator ==  &default_allocator) ds->allocator = da;
2973
    return ds->allocator;
2974
}
2975

    
2976
/* dumb display */
2977

    
2978
static void dumb_display_init(void)
2979
{
2980
    DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2981
    ds->allocator = &default_allocator;
2982
    ds->surface = qemu_create_displaysurface(ds, 640, 480);
2983
    register_displaystate(ds);
2984
}
2985

    
2986
/***********************************************************/
2987
/* I/O handling */
2988

    
2989
typedef struct IOHandlerRecord {
2990
    int fd;
2991
    IOCanRWHandler *fd_read_poll;
2992
    IOHandler *fd_read;
2993
    IOHandler *fd_write;
2994
    int deleted;
2995
    void *opaque;
2996
    /* temporary data */
2997
    struct pollfd *ufd;
2998
    struct IOHandlerRecord *next;
2999
} IOHandlerRecord;
3000

    
3001
static IOHandlerRecord *first_io_handler;
3002

    
3003
/* XXX: fd_read_poll should be suppressed, but an API change is
3004
   necessary in the character devices to suppress fd_can_read(). */
3005
int qemu_set_fd_handler2(int fd,
3006
                         IOCanRWHandler *fd_read_poll,
3007
                         IOHandler *fd_read,
3008
                         IOHandler *fd_write,
3009
                         void *opaque)
3010
{
3011
    IOHandlerRecord **pioh, *ioh;
3012

    
3013
    if (!fd_read && !fd_write) {
3014
        pioh = &first_io_handler;
3015
        for(;;) {
3016
            ioh = *pioh;
3017
            if (ioh == NULL)
3018
                break;
3019
            if (ioh->fd == fd) {
3020
                ioh->deleted = 1;
3021
                break;
3022
            }
3023
            pioh = &ioh->next;
3024
        }
3025
    } else {
3026
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3027
            if (ioh->fd == fd)
3028
                goto found;
3029
        }
3030
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
3031
        ioh->next = first_io_handler;
3032
        first_io_handler = ioh;
3033
    found:
3034
        ioh->fd = fd;
3035
        ioh->fd_read_poll = fd_read_poll;
3036
        ioh->fd_read = fd_read;
3037
        ioh->fd_write = fd_write;
3038
        ioh->opaque = opaque;
3039
        ioh->deleted = 0;
3040
    }
3041
    return 0;
3042
}
3043

    
3044
int qemu_set_fd_handler(int fd,
3045
                        IOHandler *fd_read,
3046
                        IOHandler *fd_write,
3047
                        void *opaque)
3048
{
3049
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
3050
}
3051

    
3052
#ifdef _WIN32
3053
/***********************************************************/
3054
/* Polling handling */
3055

    
3056
typedef struct PollingEntry {
3057
    PollingFunc *func;
3058
    void *opaque;
3059
    struct PollingEntry *next;
3060
} PollingEntry;
3061

    
3062
static PollingEntry *first_polling_entry;
3063

    
3064
int qemu_add_polling_cb(PollingFunc *func, void *opaque)
3065
{
3066
    PollingEntry **ppe, *pe;
3067
    pe = qemu_mallocz(sizeof(PollingEntry));
3068
    pe->func = func;
3069
    pe->opaque = opaque;
3070
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
3071
    *ppe = pe;
3072
    return 0;
3073
}
3074

    
3075
void qemu_del_polling_cb(PollingFunc *func, void *opaque)
3076
{
3077
    PollingEntry **ppe, *pe;
3078
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
3079
        pe = *ppe;
3080
        if (pe->func == func && pe->opaque == opaque) {
3081
            *ppe = pe->next;
3082
            qemu_free(pe);
3083
            break;
3084
        }
3085
    }
3086
}
3087

    
3088
/***********************************************************/
3089
/* Wait objects support */
3090
typedef struct WaitObjects {
3091
    int num;
3092
    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
3093
    WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
3094
    void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
3095
} WaitObjects;
3096

    
3097
static WaitObjects wait_objects = {0};
3098

    
3099
int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3100
{
3101
    WaitObjects *w = &wait_objects;
3102

    
3103
    if (w->num >= MAXIMUM_WAIT_OBJECTS)
3104
        return -1;
3105
    w->events[w->num] = handle;
3106
    w->func[w->num] = func;
3107
    w->opaque[w->num] = opaque;
3108
    w->num++;
3109
    return 0;
3110
}
3111

    
3112
void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3113
{
3114
    int i, found;
3115
    WaitObjects *w = &wait_objects;
3116

    
3117
    found = 0;
3118
    for (i = 0; i < w->num; i++) {
3119
        if (w->events[i] == handle)
3120
            found = 1;
3121
        if (found) {
3122
            w->events[i] = w->events[i + 1];
3123
            w->func[i] = w->func[i + 1];
3124
            w->opaque[i] = w->opaque[i + 1];
3125
        }
3126
    }
3127
    if (found)
3128
        w->num--;
3129
}
3130
#endif
3131

    
3132
/***********************************************************/
3133
/* ram save/restore */
3134

    
3135
static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3136
{
3137
    int v;
3138

    
3139
    v = qemu_get_byte(f);
3140
    switch(v) {
3141
    case 0:
3142
        if (qemu_get_buffer(f, buf, len) != len)
3143
            return -EIO;
3144
        break;
3145
    case 1:
3146
        v = qemu_get_byte(f);
3147
        memset(buf, v, len);
3148
        break;
3149
    default:
3150
        return -EINVAL;
3151
    }
3152

    
3153
    if (qemu_file_has_error(f))
3154
        return -EIO;
3155

    
3156
    return 0;
3157
}
3158

    
3159
static int ram_load_v1(QEMUFile *f, void *opaque)
3160
{
3161
    int ret;
3162
    ram_addr_t i;
3163

    
3164
    if (qemu_get_be32(f) != last_ram_offset)
3165
        return -EINVAL;
3166
    for(i = 0; i < last_ram_offset; i+= TARGET_PAGE_SIZE) {
3167
        ret = ram_get_page(f, qemu_get_ram_ptr(i), TARGET_PAGE_SIZE);
3168
        if (ret)
3169
            return ret;
3170
    }
3171
    return 0;
3172
}
3173

    
3174
#define BDRV_HASH_BLOCK_SIZE 1024
3175
#define IOBUF_SIZE 4096
3176
#define RAM_CBLOCK_MAGIC 0xfabe
3177

    
3178
typedef struct RamDecompressState {
3179
    z_stream zstream;
3180
    QEMUFile *f;
3181
    uint8_t buf[IOBUF_SIZE];
3182
} RamDecompressState;
3183

    
3184
static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3185
{
3186
    int ret;
3187
    memset(s, 0, sizeof(*s));
3188
    s->f = f;
3189
    ret = inflateInit(&s->zstream);
3190
    if (ret != Z_OK)
3191
        return -1;
3192
    return 0;
3193
}
3194

    
3195
static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3196
{
3197
    int ret, clen;
3198

    
3199
    s->zstream.avail_out = len;
3200
    s->zstream.next_out = buf;
3201
    while (s->zstream.avail_out > 0) {
3202
        if (s->zstream.avail_in == 0) {
3203
            if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3204
                return -1;
3205
            clen = qemu_get_be16(s->f);
3206
            if (clen > IOBUF_SIZE)
3207
                return -1;
3208
            qemu_get_buffer(s->f, s->buf, clen);
3209
            s->zstream.avail_in = clen;
3210
            s->zstream.next_in = s->buf;
3211
        }
3212
        ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3213
        if (ret != Z_OK && ret != Z_STREAM_END) {
3214
            return -1;
3215
        }
3216
    }
3217
    return 0;
3218
}
3219

    
3220
static void ram_decompress_close(RamDecompressState *s)
3221
{
3222
    inflateEnd(&s->zstream);
3223
}
3224

    
3225
#define RAM_SAVE_FLAG_FULL        0x01
3226
#define RAM_SAVE_FLAG_COMPRESS        0x02
3227
#define RAM_SAVE_FLAG_MEM_SIZE        0x04
3228
#define RAM_SAVE_FLAG_PAGE        0x08
3229
#define RAM_SAVE_FLAG_EOS        0x10
3230

    
3231
static int is_dup_page(uint8_t *page, uint8_t ch)
3232
{
3233
    uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3234
    uint32_t *array = (uint32_t *)page;
3235
    int i;
3236

    
3237
    for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3238
        if (array[i] != val)
3239
            return 0;
3240
    }
3241

    
3242
    return 1;
3243
}
3244

    
3245
static int ram_save_block(QEMUFile *f)
3246
{
3247
    static ram_addr_t current_addr = 0;
3248
    ram_addr_t saved_addr = current_addr;
3249
    ram_addr_t addr = 0;
3250
    int found = 0;
3251

    
3252
    while (addr < last_ram_offset) {
3253
        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3254
            uint8_t *p;
3255

    
3256
            cpu_physical_memory_reset_dirty(current_addr,
3257
                                            current_addr + TARGET_PAGE_SIZE,
3258
                                            MIGRATION_DIRTY_FLAG);
3259

    
3260
            p = qemu_get_ram_ptr(current_addr);
3261

    
3262
            if (is_dup_page(p, *p)) {
3263
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3264
                qemu_put_byte(f, *p);
3265
            } else {
3266
                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3267
                qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
3268
            }
3269

    
3270
            found = 1;
3271
            break;
3272
        }
3273
        addr += TARGET_PAGE_SIZE;
3274
        current_addr = (saved_addr + addr) % last_ram_offset;
3275
    }
3276

    
3277
    return found;
3278
}
3279

    
3280
static ram_addr_t ram_save_threshold = 10;
3281

    
3282
static ram_addr_t ram_save_remaining(void)
3283
{
3284
    ram_addr_t addr;
3285
    ram_addr_t count = 0;
3286

    
3287
    for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3288
        if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3289
            count++;
3290
    }
3291

    
3292
    return count;
3293
}
3294

    
3295
static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3296
{
3297
    ram_addr_t addr;
3298

    
3299
    if (stage == 1) {
3300
        /* Make sure all dirty bits are set */
3301
        for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3302
            if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3303
                cpu_physical_memory_set_dirty(addr);
3304
        }
3305
        
3306
        /* Enable dirty memory tracking */
3307
        cpu_physical_memory_set_dirty_tracking(1);
3308

    
3309
        qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
3310
    }
3311

    
3312
    while (!qemu_file_rate_limit(f)) {
3313
        int ret;
3314

    
3315
        ret = ram_save_block(f);
3316
        if (ret == 0) /* no more blocks */
3317
            break;
3318
    }
3319

    
3320
    /* try transferring iterative blocks of memory */
3321

    
3322
    if (stage == 3) {
3323

    
3324
        /* flush all remaining blocks regardless of rate limiting */
3325
        while (ram_save_block(f) != 0);
3326
        cpu_physical_memory_set_dirty_tracking(0);
3327
    }
3328

    
3329
    qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3330

    
3331
    return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3332
}
3333

    
3334
static int ram_load_dead(QEMUFile *f, void *opaque)
3335
{
3336
    RamDecompressState s1, *s = &s1;
3337
    uint8_t buf[10];
3338
    ram_addr_t i;
3339

    
3340
    if (ram_decompress_open(s, f) < 0)
3341
        return -EINVAL;
3342
    for(i = 0; i < last_ram_offset; i+= BDRV_HASH_BLOCK_SIZE) {
3343
        if (ram_decompress_buf(s, buf, 1) < 0) {
3344
            fprintf(stderr, "Error while reading ram block header\n");
3345
            goto error;
3346
        }
3347
        if (buf[0] == 0) {
3348
            if (ram_decompress_buf(s, qemu_get_ram_ptr(i),
3349
                                   BDRV_HASH_BLOCK_SIZE) < 0) {
3350
                fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3351
                goto error;
3352
            }
3353
        } else {
3354
        error:
3355
            printf("Error block header\n");
3356
            return -EINVAL;
3357
        }
3358
    }
3359
    ram_decompress_close(s);
3360

    
3361
    return 0;
3362
}
3363

    
3364
static int ram_load(QEMUFile *f, void *opaque, int version_id)
3365
{
3366
    ram_addr_t addr;
3367
    int flags;
3368

    
3369
    if (version_id == 1)
3370
        return ram_load_v1(f, opaque);
3371

    
3372
    if (version_id == 2) {
3373
        if (qemu_get_be32(f) != last_ram_offset)
3374
            return -EINVAL;
3375
        return ram_load_dead(f, opaque);
3376
    }
3377

    
3378
    if (version_id != 3)
3379
        return -EINVAL;
3380

    
3381
    do {
3382
        addr = qemu_get_be64(f);
3383

    
3384
        flags = addr & ~TARGET_PAGE_MASK;
3385
        addr &= TARGET_PAGE_MASK;
3386

    
3387
        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3388
            if (addr != last_ram_offset)
3389
                return -EINVAL;
3390
        }
3391

    
3392
        if (flags & RAM_SAVE_FLAG_FULL) {
3393
            if (ram_load_dead(f, opaque) < 0)
3394
                return -EINVAL;
3395
        }
3396
        
3397
        if (flags & RAM_SAVE_FLAG_COMPRESS) {
3398
            uint8_t ch = qemu_get_byte(f);
3399
            memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
3400
        } else if (flags & RAM_SAVE_FLAG_PAGE)
3401
            qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
3402
    } while (!(flags & RAM_SAVE_FLAG_EOS));
3403

    
3404
    return 0;
3405
}
3406

    
3407
void qemu_service_io(void)
3408
{
3409
    qemu_notify_event();
3410
}
3411

    
3412
/***********************************************************/
3413
/* bottom halves (can be seen as timers which expire ASAP) */
3414

    
3415
struct QEMUBH {
3416
    QEMUBHFunc *cb;
3417
    void *opaque;
3418
    int scheduled;
3419
    int idle;
3420
    int deleted;
3421
    QEMUBH *next;
3422
};
3423

    
3424
static QEMUBH *first_bh = NULL;
3425

    
3426
QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3427
{
3428
    QEMUBH *bh;
3429
    bh = qemu_mallocz(sizeof(QEMUBH));
3430
    bh->cb = cb;
3431
    bh->opaque = opaque;
3432
    bh->next = first_bh;
3433
    first_bh = bh;
3434
    return bh;
3435
}
3436

    
3437
int qemu_bh_poll(void)
3438
{
3439
    QEMUBH *bh, **bhp;
3440
    int ret;
3441

    
3442
    ret = 0;
3443
    for (bh = first_bh; bh; bh = bh->next) {
3444
        if (!bh->deleted && bh->scheduled) {
3445
            bh->scheduled = 0;
3446
            if (!bh->idle)
3447
                ret = 1;
3448
            bh->idle = 0;
3449
            bh->cb(bh->opaque);
3450
        }
3451
    }
3452

    
3453
    /* remove deleted bhs */
3454
    bhp = &first_bh;
3455
    while (*bhp) {
3456
        bh = *bhp;
3457
        if (bh->deleted) {
3458
            *bhp = bh->next;
3459
            qemu_free(bh);
3460
        } else
3461
            bhp = &bh->next;
3462
    }
3463

    
3464
    return ret;
3465
}
3466

    
3467
void qemu_bh_schedule_idle(QEMUBH *bh)
3468
{
3469
    if (bh->scheduled)
3470
        return;
3471
    bh->scheduled = 1;
3472
    bh->idle = 1;
3473
}
3474

    
3475
void qemu_bh_schedule(QEMUBH *bh)
3476
{
3477
    if (bh->scheduled)
3478
        return;
3479
    bh->scheduled = 1;
3480
    bh->idle = 0;
3481
    /* stop the currently executing CPU to execute the BH ASAP */
3482
    qemu_notify_event();
3483
}
3484

    
3485
void qemu_bh_cancel(QEMUBH *bh)
3486
{
3487
    bh->scheduled = 0;
3488
}
3489

    
3490
void qemu_bh_delete(QEMUBH *bh)
3491
{
3492
    bh->scheduled = 0;
3493
    bh->deleted = 1;
3494
}
3495

    
3496
static void qemu_bh_update_timeout(int *timeout)
3497
{
3498
    QEMUBH *bh;
3499

    
3500
    for (bh = first_bh; bh; bh = bh->next) {
3501
        if (!bh->deleted && bh->scheduled) {
3502
            if (bh->idle) {
3503
                /* idle bottom halves will be polled at least
3504
                 * every 10ms */
3505
                *timeout = MIN(10, *timeout);
3506
            } else {
3507
                /* non-idle bottom halves will be executed
3508
                 * immediately */
3509
                *timeout = 0;
3510
                break;
3511
            }
3512
        }
3513
    }
3514
}
3515

    
3516
/***********************************************************/
3517
/* machine registration */
3518

    
3519
static QEMUMachine *first_machine = NULL;
3520
QEMUMachine *current_machine = NULL;
3521

    
3522
int qemu_register_machine(QEMUMachine *m)
3523
{
3524
    QEMUMachine **pm;
3525
    pm = &first_machine;
3526
    while (*pm != NULL)
3527
        pm = &(*pm)->next;
3528
    m->next = NULL;
3529
    *pm = m;
3530
    return 0;
3531
}
3532

    
3533
static QEMUMachine *find_machine(const char *name)
3534
{
3535
    QEMUMachine *m;
3536

    
3537
    for(m = first_machine; m != NULL; m = m->next) {
3538
        if (!strcmp(m->name, name))
3539
            return m;
3540
    }
3541
    return NULL;
3542
}
3543

    
3544
/***********************************************************/
3545
/* main execution loop */
3546

    
3547
static void gui_update(void *opaque)
3548
{
3549
    uint64_t interval = GUI_REFRESH_INTERVAL;
3550
    DisplayState *ds = opaque;
3551
    DisplayChangeListener *dcl = ds->listeners;
3552

    
3553
    dpy_refresh(ds);
3554

    
3555
    while (dcl != NULL) {
3556
        if (dcl->gui_timer_interval &&
3557
            dcl->gui_timer_interval < interval)
3558
            interval = dcl->gui_timer_interval;
3559
        dcl = dcl->next;
3560
    }
3561
    qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3562
}
3563

    
3564
static void nographic_update(void *opaque)
3565
{
3566
    uint64_t interval = GUI_REFRESH_INTERVAL;
3567

    
3568
    qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3569
}
3570

    
3571
struct vm_change_state_entry {
3572
    VMChangeStateHandler *cb;
3573
    void *opaque;
3574
    LIST_ENTRY (vm_change_state_entry) entries;
3575
};
3576

    
3577
static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3578

    
3579
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3580
                                                     void *opaque)
3581
{
3582
    VMChangeStateEntry *e;
3583

    
3584
    e = qemu_mallocz(sizeof (*e));
3585

    
3586
    e->cb = cb;
3587
    e->opaque = opaque;
3588
    LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3589
    return e;
3590
}
3591

    
3592
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3593
{
3594
    LIST_REMOVE (e, entries);
3595
    qemu_free (e);
3596
}
3597

    
3598
static void vm_state_notify(int running, int reason)
3599
{
3600
    VMChangeStateEntry *e;
3601

    
3602
    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3603
        e->cb(e->opaque, running, reason);
3604
    }
3605
}
3606

    
3607
void vm_start(void)
3608
{
3609
    if (!vm_running) {
3610
        cpu_enable_ticks();
3611
        vm_running = 1;
3612
        vm_state_notify(1, 0);
3613
        qemu_rearm_alarm_timer(alarm_timer);
3614
    }
3615
}
3616

    
3617
void vm_stop(int reason)
3618
{
3619
    if (vm_running) {
3620
        cpu_disable_ticks();
3621
        vm_running = 0;
3622
        vm_state_notify(0, reason);
3623
    }
3624
}
3625

    
3626
/* reset/shutdown handler */
3627

    
3628
typedef struct QEMUResetEntry {
3629
    QEMUResetHandler *func;
3630
    void *opaque;
3631
    struct QEMUResetEntry *next;
3632
} QEMUResetEntry;
3633

    
3634
static QEMUResetEntry *first_reset_entry;
3635
static int reset_requested;
3636
static int shutdown_requested;
3637
static int powerdown_requested;
3638

    
3639
int qemu_shutdown_requested(void)
3640
{
3641
    int r = shutdown_requested;
3642
    shutdown_requested = 0;
3643
    return r;
3644
}
3645

    
3646
int qemu_reset_requested(void)
3647
{
3648
    int r = reset_requested;
3649
    reset_requested = 0;
3650
    return r;
3651
}
3652

    
3653
int qemu_powerdown_requested(void)
3654
{
3655
    int r = powerdown_requested;
3656
    powerdown_requested = 0;
3657
    return r;
3658
}
3659

    
3660
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3661
{
3662
    QEMUResetEntry **pre, *re;
3663

    
3664
    pre = &first_reset_entry;
3665
    while (*pre != NULL)
3666
        pre = &(*pre)->next;
3667
    re = qemu_mallocz(sizeof(QEMUResetEntry));
3668
    re->func = func;
3669
    re->opaque = opaque;
3670
    re->next = NULL;
3671
    *pre = re;
3672
}
3673

    
3674
void qemu_system_reset(void)
3675
{
3676
    QEMUResetEntry *re;
3677

    
3678
    /* reset all devices */
3679
    for(re = first_reset_entry; re != NULL; re = re->next) {
3680
        re->func(re->opaque);
3681
    }
3682
    if (kvm_enabled())
3683
        kvm_sync_vcpus();
3684
}
3685

    
3686
void qemu_system_reset_request(void)
3687
{
3688
    if (no_reboot) {
3689
        shutdown_requested = 1;
3690
    } else {
3691
        reset_requested = 1;
3692
    }
3693
    qemu_notify_event();
3694
}
3695

    
3696
void qemu_system_shutdown_request(void)
3697
{
3698
    shutdown_requested = 1;
3699
    qemu_notify_event();
3700
}
3701

    
3702
void qemu_system_powerdown_request(void)
3703
{
3704
    powerdown_requested = 1;
3705
    qemu_notify_event();
3706
}
3707

    
3708
void qemu_notify_event(void)
3709
{
3710
    CPUState *env = cpu_single_env;
3711

    
3712
    if (env) {
3713
        cpu_exit(env);
3714
#ifdef USE_KQEMU
3715
        if (env->kqemu_enabled)
3716
            kqemu_cpu_interrupt(env);
3717
#endif
3718
     }
3719
}
3720

    
3721
#ifdef _WIN32
3722
static void host_main_loop_wait(int *timeout)
3723
{
3724
    int ret, ret2, i;
3725
    PollingEntry *pe;
3726

    
3727

    
3728
    /* XXX: need to suppress polling by better using win32 events */
3729
    ret = 0;
3730
    for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3731
        ret |= pe->func(pe->opaque);
3732
    }
3733
    if (ret == 0) {
3734
        int err;
3735
        WaitObjects *w = &wait_objects;
3736

    
3737
        ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3738
        if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3739
            if (w->func[ret - WAIT_OBJECT_0])
3740
                w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3741

    
3742
            /* Check for additional signaled events */
3743
            for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3744

    
3745
                /* Check if event is signaled */
3746
                ret2 = WaitForSingleObject(w->events[i], 0);
3747
                if(ret2 == WAIT_OBJECT_0) {
3748
                    if (w->func[i])
3749
                        w->func[i](w->opaque[i]);
3750
                } else if (ret2 == WAIT_TIMEOUT) {
3751
                } else {
3752
                    err = GetLastError();
3753
                    fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3754
                }
3755
            }
3756
        } else if (ret == WAIT_TIMEOUT) {
3757
        } else {
3758
            err = GetLastError();
3759
            fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3760
        }
3761
    }
3762

    
3763
    *timeout = 0;
3764
}
3765
#else
3766
static void host_main_loop_wait(int *timeout)
3767
{
3768
}
3769
#endif
3770

    
3771
void main_loop_wait(int timeout)
3772
{
3773
    IOHandlerRecord *ioh;
3774
    fd_set rfds, wfds, xfds;
3775
    int ret, nfds;
3776
    struct timeval tv;
3777

    
3778
    qemu_bh_update_timeout(&timeout);
3779

    
3780
    host_main_loop_wait(&timeout);
3781

    
3782
    /* poll any events */
3783
    /* XXX: separate device handlers from system ones */
3784
    nfds = -1;
3785
    FD_ZERO(&rfds);
3786
    FD_ZERO(&wfds);
3787
    FD_ZERO(&xfds);
3788
    for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3789
        if (ioh->deleted)
3790
            continue;
3791
        if (ioh->fd_read &&
3792
            (!ioh->fd_read_poll ||
3793
             ioh->fd_read_poll(ioh->opaque) != 0)) {
3794
            FD_SET(ioh->fd, &rfds);
3795
            if (ioh->fd > nfds)
3796
                nfds = ioh->fd;
3797
        }
3798
        if (ioh->fd_write) {
3799
            FD_SET(ioh->fd, &wfds);
3800
            if (ioh->fd > nfds)
3801
                nfds = ioh->fd;
3802
        }
3803
    }
3804

    
3805
    tv.tv_sec = timeout / 1000;
3806
    tv.tv_usec = (timeout % 1000) * 1000;
3807

    
3808
#if defined(CONFIG_SLIRP)
3809
    if (slirp_is_inited()) {
3810
        slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3811
    }
3812
#endif
3813
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3814
    if (ret > 0) {
3815
        IOHandlerRecord **pioh;
3816

    
3817
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3818
            if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3819
                ioh->fd_read(ioh->opaque);
3820
            }
3821
            if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3822
                ioh->fd_write(ioh->opaque);
3823
            }
3824
        }
3825

    
3826
        /* remove deleted IO handlers */
3827
        pioh = &first_io_handler;
3828
        while (*pioh) {
3829
            ioh = *pioh;
3830
            if (ioh->deleted) {
3831
                *pioh = ioh->next;
3832
                qemu_free(ioh);
3833
            } else
3834
                pioh = &ioh->next;
3835
        }
3836
    }
3837
#if defined(CONFIG_SLIRP)
3838
    if (slirp_is_inited()) {
3839
        if (ret < 0) {
3840
            FD_ZERO(&rfds);
3841
            FD_ZERO(&wfds);
3842
            FD_ZERO(&xfds);
3843
        }
3844
        slirp_select_poll(&rfds, &wfds, &xfds);
3845
    }
3846
#endif
3847

    
3848
    /* vm time timers */
3849
    if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3850
        qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
3851
                        qemu_get_clock(vm_clock));
3852

    
3853
    /* real time timers */
3854
    qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
3855
                    qemu_get_clock(rt_clock));
3856

    
3857
    /* Check bottom-halves last in case any of the earlier events triggered
3858
       them.  */
3859
    qemu_bh_poll();
3860

    
3861
}
3862

    
3863
static int main_loop(void)
3864
{
3865
    int ret, timeout;
3866
#ifdef CONFIG_PROFILER
3867
    int64_t ti;
3868
#endif
3869
    CPUState *env;
3870

    
3871
    cur_cpu = first_cpu;
3872
    next_cpu = cur_cpu->next_cpu ?: first_cpu;
3873
    for(;;) {
3874
        if (vm_running) {
3875

    
3876
            for(;;) {
3877
                /* get next cpu */
3878
                env = next_cpu;
3879
#ifdef CONFIG_PROFILER
3880
                ti = profile_getclock();
3881
#endif
3882
                if (use_icount) {
3883
                    int64_t count;
3884
                    int decr;
3885
                    qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3886
                    env->icount_decr.u16.low = 0;
3887
                    env->icount_extra = 0;
3888
                    count = qemu_next_deadline();
3889
                    count = (count + (1 << icount_time_shift) - 1)
3890
                            >> icount_time_shift;
3891
                    qemu_icount += count;
3892
                    decr = (count > 0xffff) ? 0xffff : count;
3893
                    count -= decr;
3894
                    env->icount_decr.u16.low = decr;
3895
                    env->icount_extra = count;
3896
                }
3897
                ret = cpu_exec(env);
3898
#ifdef CONFIG_PROFILER
3899
                qemu_time += profile_getclock() - ti;
3900
#endif
3901
                if (use_icount) {
3902
                    /* Fold pending instructions back into the
3903
                       instruction counter, and clear the interrupt flag.  */
3904
                    qemu_icount -= (env->icount_decr.u16.low
3905
                                    + env->icount_extra);
3906
                    env->icount_decr.u32 = 0;
3907
                    env->icount_extra = 0;
3908
                }
3909
                next_cpu = env->next_cpu ?: first_cpu;
3910
                if (event_pending && likely(ret != EXCP_DEBUG)) {
3911
                    ret = EXCP_INTERRUPT;
3912
                    event_pending = 0;
3913
                    break;
3914
                }
3915
                if (ret == EXCP_HLT) {
3916
                    /* Give the next CPU a chance to run.  */
3917
                    cur_cpu = env;
3918
                    continue;
3919
                }
3920
                if (ret != EXCP_HALTED)
3921
                    break;
3922
                /* all CPUs are halted ? */
3923
                if (env == cur_cpu)
3924
                    break;
3925
            }
3926
            cur_cpu = env;
3927

    
3928
            if (shutdown_requested) {
3929
                ret = EXCP_INTERRUPT;
3930
                if (no_shutdown) {
3931
                    vm_stop(0);
3932
                    no_shutdown = 0;
3933
                }
3934
                else
3935
                    break;
3936
            }
3937
            if (reset_requested) {
3938
                reset_requested = 0;
3939
                qemu_system_reset();
3940
                ret = EXCP_INTERRUPT;
3941
            }
3942
            if (powerdown_requested) {
3943
                powerdown_requested = 0;
3944
                qemu_system_powerdown();
3945
                ret = EXCP_INTERRUPT;
3946
            }
3947
            if (unlikely(ret == EXCP_DEBUG)) {
3948
                gdb_set_stop_cpu(cur_cpu);
3949
                vm_stop(EXCP_DEBUG);
3950
            }
3951
            /* If all cpus are halted then wait until the next IRQ */
3952
            /* XXX: use timeout computed from timers */
3953
            if (ret == EXCP_HALTED) {
3954
                if (use_icount) {
3955
                    int64_t add;
3956
                    int64_t delta;
3957
                    /* Advance virtual time to the next event.  */
3958
                    if (use_icount == 1) {
3959
                        /* When not using an adaptive execution frequency
3960
                           we tend to get badly out of sync with real time,
3961
                           so just delay for a reasonable amount of time.  */
3962
                        delta = 0;
3963
                    } else {
3964
                        delta = cpu_get_icount() - cpu_get_clock();
3965
                    }
3966
                    if (delta > 0) {
3967
                        /* If virtual time is ahead of real time then just
3968
                           wait for IO.  */
3969
                        timeout = (delta / 1000000) + 1;
3970
                    } else {
3971
                        /* Wait for either IO to occur or the next
3972
                           timer event.  */
3973
                        add = qemu_next_deadline();
3974
                        /* We advance the timer before checking for IO.
3975
                           Limit the amount we advance so that early IO
3976
                           activity won't get the guest too far ahead.  */
3977
                        if (add > 10000000)
3978
                            add = 10000000;
3979
                        delta += add;
3980
                        add = (add + (1 << icount_time_shift) - 1)
3981
                              >> icount_time_shift;
3982
                        qemu_icount += add;
3983
                        timeout = delta / 1000000;
3984
                        if (timeout < 0)
3985
                            timeout = 0;
3986
                    }
3987
                } else {
3988
                    timeout = 5000;
3989
                }
3990
            } else {
3991
                timeout = 0;
3992
            }
3993
        } else {
3994
            if (shutdown_requested) {
3995
                ret = EXCP_INTERRUPT;
3996
                break;
3997
            }
3998
            timeout = 5000;
3999
        }
4000
#ifdef CONFIG_PROFILER
4001
        ti = profile_getclock();
4002
#endif
4003
        main_loop_wait(timeout);
4004
#ifdef CONFIG_PROFILER
4005
        dev_time += profile_getclock() - ti;
4006
#endif
4007
    }
4008
    cpu_disable_ticks();
4009
    return ret;
4010
}
4011

    
4012
static void version(void)
4013
{
4014
    printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4015
}
4016

    
4017
static void help(int exitcode)
4018
{
4019
    version();
4020
    printf("usage: %s [options] [disk_image]\n"
4021
           "\n"
4022
           "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4023
           "\n"
4024
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4025
           opt_help
4026
#define DEFHEADING(text) stringify(text) "\n"
4027
#include "qemu-options.h"
4028
#undef DEF
4029
#undef DEFHEADING
4030
#undef GEN_DOCS
4031
           "\n"
4032
           "During emulation, the following keys are useful:\n"
4033
           "ctrl-alt-f      toggle full screen\n"
4034
           "ctrl-alt-n      switch to virtual console 'n'\n"
4035
           "ctrl-alt        toggle mouse and keyboard grab\n"
4036
           "\n"
4037
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
4038
           ,
4039
           "qemu",
4040
           DEFAULT_RAM_SIZE,
4041
#ifndef _WIN32
4042
           DEFAULT_NETWORK_SCRIPT,
4043
           DEFAULT_NETWORK_DOWN_SCRIPT,
4044
#endif
4045
           DEFAULT_GDBSTUB_PORT,
4046
           "/tmp/qemu.log");
4047
    exit(exitcode);
4048
}
4049

    
4050
#define HAS_ARG 0x0001
4051

    
4052
enum {
4053
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4054
    opt_enum,
4055
#define DEFHEADING(text)
4056
#include "qemu-options.h"
4057
#undef DEF
4058
#undef DEFHEADING
4059
#undef GEN_DOCS
4060
};
4061

    
4062
typedef struct QEMUOption {
4063
    const char *name;
4064
    int flags;
4065
    int index;
4066
} QEMUOption;
4067

    
4068
static const QEMUOption qemu_options[] = {
4069
    { "h", 0, QEMU_OPTION_h },
4070
#define DEF(option, opt_arg, opt_enum, opt_help)        \
4071
    { option, opt_arg, opt_enum },
4072
#define DEFHEADING(text)
4073
#include "qemu-options.h"
4074
#undef DEF
4075
#undef DEFHEADING
4076
#undef GEN_DOCS
4077
    { NULL },
4078
};
4079

    
4080
#ifdef HAS_AUDIO
4081
struct soundhw soundhw[] = {
4082
#ifdef HAS_AUDIO_CHOICE
4083
#if defined(TARGET_I386) || defined(TARGET_MIPS)
4084
    {
4085
        "pcspk",
4086
        "PC speaker",
4087
        0,
4088
        1,
4089
        { .init_isa = pcspk_audio_init }
4090
    },
4091
#endif
4092

    
4093
#ifdef CONFIG_SB16
4094
    {
4095
        "sb16",
4096
        "Creative Sound Blaster 16",
4097
        0,
4098
        1,
4099
        { .init_isa = SB16_init }
4100
    },
4101
#endif
4102

    
4103
#ifdef CONFIG_CS4231A
4104
    {
4105
        "cs4231a",
4106
        "CS4231A",
4107
        0,
4108
        1,
4109
        { .init_isa = cs4231a_init }
4110
    },
4111
#endif
4112

    
4113
#ifdef CONFIG_ADLIB
4114
    {
4115
        "adlib",
4116
#ifdef HAS_YMF262
4117
        "Yamaha YMF262 (OPL3)",
4118
#else
4119
        "Yamaha YM3812 (OPL2)",
4120
#endif
4121
        0,
4122
        1,
4123
        { .init_isa = Adlib_init }
4124
    },
4125
#endif
4126

    
4127
#ifdef CONFIG_GUS
4128
    {
4129
        "gus",
4130
        "Gravis Ultrasound GF1",
4131
        0,
4132
        1,
4133
        { .init_isa = GUS_init }
4134
    },
4135
#endif
4136

    
4137
#ifdef CONFIG_AC97
4138
    {
4139
        "ac97",
4140
        "Intel 82801AA AC97 Audio",
4141
        0,
4142
        0,
4143
        { .init_pci = ac97_init }
4144
    },
4145
#endif
4146

    
4147
#ifdef CONFIG_ES1370
4148
    {
4149
        "es1370",
4150
        "ENSONIQ AudioPCI ES1370",
4151
        0,
4152
        0,
4153
        { .init_pci = es1370_init }
4154
    },
4155
#endif
4156

    
4157
#endif /* HAS_AUDIO_CHOICE */
4158

    
4159
    { NULL, NULL, 0, 0, { NULL } }
4160
};
4161

    
4162
static void select_soundhw (const char *optarg)
4163
{
4164
    struct soundhw *c;
4165

    
4166
    if (*optarg == '?') {
4167
    show_valid_cards:
4168

    
4169
        printf ("Valid sound card names (comma separated):\n");
4170
        for (c = soundhw; c->name; ++c) {
4171
            printf ("%-11s %s\n", c->name, c->descr);
4172
        }
4173
        printf ("\n-soundhw all will enable all of the above\n");
4174
        exit (*optarg != '?');
4175
    }
4176
    else {
4177
        size_t l;
4178
        const char *p;
4179
        char *e;
4180
        int bad_card = 0;
4181

    
4182
        if (!strcmp (optarg, "all")) {
4183
            for (c = soundhw; c->name; ++c) {
4184
                c->enabled = 1;
4185
            }
4186
            return;
4187
        }
4188

    
4189
        p = optarg;
4190
        while (*p) {
4191
            e = strchr (p, ',');
4192
            l = !e ? strlen (p) : (size_t) (e - p);
4193

    
4194
            for (c = soundhw; c->name; ++c) {
4195
                if (!strncmp (c->name, p, l)) {
4196
                    c->enabled = 1;
4197
                    break;
4198
                }
4199
            }
4200

    
4201
            if (!c->name) {
4202
                if (l > 80) {
4203
                    fprintf (stderr,
4204
                             "Unknown sound card name (too big to show)\n");
4205
                }
4206
                else {
4207
                    fprintf (stderr, "Unknown sound card name `%.*s'\n",
4208
                             (int) l, p);
4209
                }
4210
                bad_card = 1;
4211
            }
4212
            p += l + (e != NULL);
4213
        }
4214

    
4215
        if (bad_card)
4216
            goto show_valid_cards;
4217
    }
4218
}
4219
#endif
4220

    
4221
static void select_vgahw (const char *p)
4222
{
4223
    const char *opts;
4224

    
4225
    cirrus_vga_enabled = 0;
4226
    std_vga_enabled = 0;
4227
    vmsvga_enabled = 0;
4228
    xenfb_enabled = 0;
4229
    if (strstart(p, "std", &opts)) {
4230
        std_vga_enabled = 1;
4231
    } else if (strstart(p, "cirrus", &opts)) {
4232
        cirrus_vga_enabled = 1;
4233
    } else if (strstart(p, "vmware", &opts)) {
4234
        vmsvga_enabled = 1;
4235
    } else if (strstart(p, "xenfb", &opts)) {
4236
        xenfb_enabled = 1;
4237
    } else if (!strstart(p, "none", &opts)) {
4238
    invalid_vga:
4239
        fprintf(stderr, "Unknown vga type: %s\n", p);
4240
        exit(1);
4241
    }
4242
    while (*opts) {
4243
        const char *nextopt;
4244

    
4245
        if (strstart(opts, ",retrace=", &nextopt)) {
4246
            opts = nextopt;
4247
            if (strstart(opts, "dumb", &nextopt))
4248
                vga_retrace_method = VGA_RETRACE_DUMB;
4249
            else if (strstart(opts, "precise", &nextopt))
4250
                vga_retrace_method = VGA_RETRACE_PRECISE;
4251
            else goto invalid_vga;
4252
        } else goto invalid_vga;
4253
        opts = nextopt;
4254
    }
4255
}
4256

    
4257
#ifdef _WIN32
4258
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4259
{
4260
    exit(STATUS_CONTROL_C_EXIT);
4261
    return TRUE;
4262
}
4263
#endif
4264

    
4265
int qemu_uuid_parse(const char *str, uint8_t *uuid)
4266
{
4267
    int ret;
4268

    
4269
    if(strlen(str) != 36)
4270
        return -1;
4271

    
4272
    ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4273
            &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4274
            &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4275

    
4276
    if(ret != 16)
4277
        return -1;
4278

    
4279
#ifdef TARGET_I386
4280
    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4281
#endif
4282

    
4283
    return 0;
4284
}
4285

    
4286
#define MAX_NET_CLIENTS 32
4287

    
4288
#ifndef _WIN32
4289

    
4290
static void termsig_handler(int signal)
4291
{
4292
    qemu_system_shutdown_request();
4293
}
4294

    
4295
static void termsig_setup(void)
4296
{
4297
    struct sigaction act;
4298

    
4299
    memset(&act, 0, sizeof(act));
4300
    act.sa_handler = termsig_handler;
4301
    sigaction(SIGINT,  &act, NULL);
4302
    sigaction(SIGHUP,  &act, NULL);
4303
    sigaction(SIGTERM, &act, NULL);
4304
}
4305

    
4306
#endif
4307

    
4308
int main(int argc, char **argv, char **envp)
4309
{
4310
#ifdef CONFIG_GDBSTUB
4311
    const char *gdbstub_dev = NULL;
4312
#endif
4313
    uint32_t boot_devices_bitmap = 0;
4314
    int i;
4315
    int snapshot, linux_boot, net_boot;
4316
    const char *initrd_filename;
4317
    const char *kernel_filename, *kernel_cmdline;
4318
    const char *boot_devices = "";
4319
    DisplayState *ds;
4320
    DisplayChangeListener *dcl;
4321
    int cyls, heads, secs, translation;
4322
    const char *net_clients[MAX_NET_CLIENTS];
4323
    int nb_net_clients;
4324
    const char *bt_opts[MAX_BT_CMDLINE];
4325
    int nb_bt_opts;
4326
    int hda_index;
4327
    int optind;
4328
    const char *r, *optarg;
4329
    CharDriverState *monitor_hd = NULL;
4330
    const char *monitor_device;
4331
    const char *serial_devices[MAX_SERIAL_PORTS];
4332
    int serial_device_index;
4333
    const char *parallel_devices[MAX_PARALLEL_PORTS];
4334
    int parallel_device_index;
4335
    const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4336
    int virtio_console_index;
4337
    const char *loadvm = NULL;
4338
    QEMUMachine *machine;
4339
    const char *cpu_model;
4340
    const char *usb_devices[MAX_USB_CMDLINE];
4341
    int usb_devices_index;
4342
#ifndef _WIN32
4343
    int fds[2];
4344
#endif
4345
    int tb_size;
4346
    const char *pid_file = NULL;
4347
    const char *incoming = NULL;
4348
#ifndef _WIN32
4349
    int fd = 0;
4350
    struct passwd *pwd = NULL;
4351
    const char *chroot_dir = NULL;
4352
    const char *run_as = NULL;
4353
#endif
4354
    CPUState *env;
4355

    
4356
    qemu_cache_utils_init(envp);
4357

    
4358
    LIST_INIT (&vm_change_state_head);
4359
#ifndef _WIN32
4360
    {
4361
        struct sigaction act;
4362
        sigfillset(&act.sa_mask);
4363
        act.sa_flags = 0;
4364
        act.sa_handler = SIG_IGN;
4365
        sigaction(SIGPIPE, &act, NULL);
4366
    }
4367
#else
4368
    SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4369
    /* Note: cpu_interrupt() is currently not SMP safe, so we force
4370
       QEMU to run on a single CPU */
4371
    {
4372
        HANDLE h;
4373
        DWORD mask, smask;
4374
        int i;
4375
        h = GetCurrentProcess();
4376
        if (GetProcessAffinityMask(h, &mask, &smask)) {
4377
            for(i = 0; i < 32; i++) {
4378
                if (mask & (1 << i))
4379
                    break;
4380
            }
4381
            if (i != 32) {
4382
                mask = 1 << i;
4383
                SetProcessAffinityMask(h, mask);
4384
            }
4385
        }
4386
    }
4387
#endif
4388

    
4389
    register_machines();
4390
    machine = first_machine;
4391
    cpu_model = NULL;
4392
    initrd_filename = NULL;
4393
    ram_size = 0;
4394
    vga_ram_size = VGA_RAM_SIZE;
4395
    snapshot = 0;
4396
    nographic = 0;
4397
    curses = 0;
4398
    kernel_filename = NULL;
4399
    kernel_cmdline = "";
4400
    cyls = heads = secs = 0;
4401
    translation = BIOS_ATA_TRANSLATION_AUTO;
4402
    monitor_device = "vc:80Cx24C";
4403

    
4404
    serial_devices[0] = "vc:80Cx24C";
4405
    for(i = 1; i < MAX_SERIAL_PORTS; i++)
4406
        serial_devices[i] = NULL;
4407
    serial_device_index = 0;
4408

    
4409
    parallel_devices[0] = "vc:80Cx24C";
4410
    for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4411
        parallel_devices[i] = NULL;
4412
    parallel_device_index = 0;
4413

    
4414
    for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4415
        virtio_consoles[i] = NULL;
4416
    virtio_console_index = 0;
4417

    
4418
    for (i = 0; i < MAX_NODES; i++) {
4419
        node_mem[i] = 0;
4420
        node_cpumask[i] = 0;
4421
    }
4422

    
4423
    usb_devices_index = 0;
4424

    
4425
    nb_net_clients = 0;
4426
    nb_bt_opts = 0;
4427
    nb_drives = 0;
4428
    nb_drives_opt = 0;
4429
    nb_numa_nodes = 0;
4430
    hda_index = -1;
4431

    
4432
    nb_nics = 0;
4433

    
4434
    tb_size = 0;
4435
    autostart= 1;
4436

    
4437
    optind = 1;
4438
    for(;;) {
4439
        if (optind >= argc)
4440
            break;
4441
        r = argv[optind];
4442
        if (r[0] != '-') {
4443
            hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4444
        } else {
4445
            const QEMUOption *popt;
4446

    
4447
            optind++;
4448
            /* Treat --foo the same as -foo.  */
4449
            if (r[1] == '-')
4450
                r++;
4451
            popt = qemu_options;
4452
            for(;;) {
4453
                if (!popt->name) {
4454
                    fprintf(stderr, "%s: invalid option -- '%s'\n",
4455
                            argv[0], r);
4456
                    exit(1);
4457
                }
4458
                if (!strcmp(popt->name, r + 1))
4459
                    break;
4460
                popt++;
4461
            }
4462
            if (popt->flags & HAS_ARG) {
4463
                if (optind >= argc) {
4464
                    fprintf(stderr, "%s: option '%s' requires an argument\n",
4465
                            argv[0], r);
4466
                    exit(1);
4467
                }
4468
                optarg = argv[optind++];
4469
            } else {
4470
                optarg = NULL;
4471
            }
4472

    
4473
            switch(popt->index) {
4474
            case QEMU_OPTION_M:
4475
                machine = find_machine(optarg);
4476
                if (!machine) {
4477
                    QEMUMachine *m;
4478
                    printf("Supported machines are:\n");
4479
                    for(m = first_machine; m != NULL; m = m->next) {
4480
                        printf("%-10s %s%s\n",
4481
                               m->name, m->desc,
4482
                               m == first_machine ? " (default)" : "");
4483
                    }
4484
                    exit(*optarg != '?');
4485
                }
4486
                break;
4487
            case QEMU_OPTION_cpu:
4488
                /* hw initialization will check this */
4489
                if (*optarg == '?') {
4490
/* XXX: implement xxx_cpu_list for targets that still miss it */
4491
#if defined(cpu_list)
4492
                    cpu_list(stdout, &fprintf);
4493
#endif
4494
                    exit(0);
4495
                } else {
4496
                    cpu_model = optarg;
4497
                }
4498
                break;
4499
            case QEMU_OPTION_initrd:
4500
                initrd_filename = optarg;
4501
                break;
4502
            case QEMU_OPTION_hda:
4503
                if (cyls == 0)
4504
                    hda_index = drive_add(optarg, HD_ALIAS, 0);
4505
                else
4506
                    hda_index = drive_add(optarg, HD_ALIAS
4507
                             ",cyls=%d,heads=%d,secs=%d%s",
4508
                             0, cyls, heads, secs,
4509
                             translation == BIOS_ATA_TRANSLATION_LBA ?
4510
                                 ",trans=lba" :
4511
                             translation == BIOS_ATA_TRANSLATION_NONE ?
4512
                                 ",trans=none" : "");
4513
                 break;
4514
            case QEMU_OPTION_hdb:
4515
            case QEMU_OPTION_hdc:
4516
            case QEMU_OPTION_hdd:
4517
                drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4518
                break;
4519
            case QEMU_OPTION_drive:
4520
                drive_add(NULL, "%s", optarg);
4521
                break;
4522
            case QEMU_OPTION_mtdblock:
4523
                drive_add(optarg, MTD_ALIAS);
4524
                break;
4525
            case QEMU_OPTION_sd:
4526
                drive_add(optarg, SD_ALIAS);
4527
                break;
4528
            case QEMU_OPTION_pflash:
4529
                drive_add(optarg, PFLASH_ALIAS);
4530
                break;
4531
            case QEMU_OPTION_snapshot:
4532
                snapshot = 1;
4533
                break;
4534
            case QEMU_OPTION_hdachs:
4535
                {
4536
                    const char *p;
4537
                    p = optarg;
4538
                    cyls = strtol(p, (char **)&p, 0);
4539
                    if (cyls < 1 || cyls > 16383)
4540
                        goto chs_fail;
4541
                    if (*p != ',')
4542
                        goto chs_fail;
4543
                    p++;
4544
                    heads = strtol(p, (char **)&p, 0);
4545
                    if (heads < 1 || heads > 16)
4546
                        goto chs_fail;
4547
                    if (*p != ',')
4548
                        goto chs_fail;
4549
                    p++;
4550
                    secs = strtol(p, (char **)&p, 0);
4551
                    if (secs < 1 || secs > 63)
4552
                        goto chs_fail;
4553
                    if (*p == ',') {
4554
                        p++;
4555
                        if (!strcmp(p, "none"))
4556
                            translation = BIOS_ATA_TRANSLATION_NONE;
4557
                        else if (!strcmp(p, "lba"))
4558
                            translation = BIOS_ATA_TRANSLATION_LBA;
4559
                        else if (!strcmp(p, "auto"))
4560
                            translation = BIOS_ATA_TRANSLATION_AUTO;
4561
                        else
4562
                            goto chs_fail;
4563
                    } else if (*p != '\0') {
4564
                    chs_fail:
4565
                        fprintf(stderr, "qemu: invalid physical CHS format\n");
4566
                        exit(1);
4567
                    }
4568
                    if (hda_index != -1)
4569
                        snprintf(drives_opt[hda_index].opt,
4570
                                 sizeof(drives_opt[hda_index].opt),
4571
                                 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4572
                                 0, cyls, heads, secs,
4573
                                 translation == BIOS_ATA_TRANSLATION_LBA ?
4574
                                         ",trans=lba" :
4575
                                 translation == BIOS_ATA_TRANSLATION_NONE ?
4576
                                     ",trans=none" : "");
4577
                }
4578
                break;
4579
            case QEMU_OPTION_numa:
4580
                if (nb_numa_nodes >= MAX_NODES) {
4581
                    fprintf(stderr, "qemu: too many NUMA nodes\n");
4582
                    exit(1);
4583
                }
4584
                numa_add(optarg);
4585
                break;
4586
            case QEMU_OPTION_nographic:
4587
                nographic = 1;
4588
                break;
4589
#ifdef CONFIG_CURSES
4590
            case QEMU_OPTION_curses:
4591
                curses = 1;
4592
                break;
4593
#endif
4594
            case QEMU_OPTION_portrait:
4595
                graphic_rotate = 1;
4596
                break;
4597
            case QEMU_OPTION_kernel:
4598
                kernel_filename = optarg;
4599
                break;
4600
            case QEMU_OPTION_append:
4601
                kernel_cmdline = optarg;
4602
                break;
4603
            case QEMU_OPTION_cdrom:
4604
                drive_add(optarg, CDROM_ALIAS);
4605
                break;
4606
            case QEMU_OPTION_boot:
4607
                boot_devices = optarg;
4608
                /* We just do some generic consistency checks */
4609
                {
4610
                    /* Could easily be extended to 64 devices if needed */
4611
                    const char *p;
4612
                    
4613
                    boot_devices_bitmap = 0;
4614
                    for (p = boot_devices; *p != '\0'; p++) {
4615
                        /* Allowed boot devices are:
4616
                         * a b     : floppy disk drives
4617
                         * c ... f : IDE disk drives
4618
                         * g ... m : machine implementation dependant drives
4619
                         * n ... p : network devices
4620
                         * It's up to each machine implementation to check
4621
                         * if the given boot devices match the actual hardware
4622
                         * implementation and firmware features.
4623
                         */
4624
                        if (*p < 'a' || *p > 'q') {
4625
                            fprintf(stderr, "Invalid boot device '%c'\n", *p);
4626
                            exit(1);
4627
                        }
4628
                        if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4629
                            fprintf(stderr,
4630
                                    "Boot device '%c' was given twice\n",*p);
4631
                            exit(1);
4632
                        }
4633
                        boot_devices_bitmap |= 1 << (*p - 'a');
4634
                    }
4635
                }
4636
                break;
4637
            case QEMU_OPTION_fda:
4638
            case QEMU_OPTION_fdb:
4639
                drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4640
                break;
4641
#ifdef TARGET_I386
4642
            case QEMU_OPTION_no_fd_bootchk:
4643
                fd_bootchk = 0;
4644
                break;
4645
#endif
4646
            case QEMU_OPTION_net:
4647
                if (nb_net_clients >= MAX_NET_CLIENTS) {
4648
                    fprintf(stderr, "qemu: too many network clients\n");
4649
                    exit(1);
4650
                }
4651
                net_clients[nb_net_clients] = optarg;
4652
                nb_net_clients++;
4653
                break;
4654
#ifdef CONFIG_SLIRP
4655
            case QEMU_OPTION_tftp:
4656
                tftp_prefix = optarg;
4657
                break;
4658
            case QEMU_OPTION_bootp:
4659
                bootp_filename = optarg;
4660
                break;
4661
#ifndef _WIN32
4662
            case QEMU_OPTION_smb:
4663
                net_slirp_smb(optarg);
4664
                break;
4665
#endif
4666
            case QEMU_OPTION_redir:
4667
                net_slirp_redir(NULL, optarg);
4668
                break;
4669
#endif
4670
            case QEMU_OPTION_bt:
4671
                if (nb_bt_opts >= MAX_BT_CMDLINE) {
4672
                    fprintf(stderr, "qemu: too many bluetooth options\n");
4673
                    exit(1);
4674
                }
4675
                bt_opts[nb_bt_opts++] = optarg;
4676
                break;
4677
#ifdef HAS_AUDIO
4678
            case QEMU_OPTION_audio_help:
4679
                AUD_help ();
4680
                exit (0);
4681
                break;
4682
            case QEMU_OPTION_soundhw:
4683
                select_soundhw (optarg);
4684
                break;
4685
#endif
4686
            case QEMU_OPTION_h:
4687
                help(0);
4688
                break;
4689
            case QEMU_OPTION_version:
4690
                version();
4691
                exit(0);
4692
                break;
4693
            case QEMU_OPTION_m: {
4694
                uint64_t value;
4695
                char *ptr;
4696

    
4697
                value = strtoul(optarg, &ptr, 10);
4698
                switch (*ptr) {
4699
                case 0: case 'M': case 'm':
4700
                    value <<= 20;
4701
                    break;
4702
                case 'G': case 'g':
4703
                    value <<= 30;
4704
                    break;
4705
                default:
4706
                    fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4707
                    exit(1);
4708
                }
4709

    
4710
                /* On 32-bit hosts, QEMU is limited by virtual address space */
4711
                if (value > (2047 << 20)
4712
#ifndef CONFIG_KQEMU
4713
                    && HOST_LONG_BITS == 32
4714
#endif
4715
                    ) {
4716
                    fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4717
                    exit(1);
4718
                }
4719
                if (value != (uint64_t)(ram_addr_t)value) {
4720
                    fprintf(stderr, "qemu: ram size too large\n");
4721
                    exit(1);
4722
                }
4723
                ram_size = value;
4724
                break;
4725
            }
4726
            case QEMU_OPTION_d:
4727
                {
4728
                    int mask;
4729
                    const CPULogItem *item;
4730

    
4731
                    mask = cpu_str_to_log_mask(optarg);
4732
                    if (!mask) {
4733
                        printf("Log items (comma separated):\n");
4734
                    for(item = cpu_log_items; item->mask != 0; item++) {
4735
                        printf("%-10s %s\n", item->name, item->help);
4736
                    }
4737
                    exit(1);
4738
                    }
4739
                    cpu_set_log(mask);
4740
                }
4741
                break;
4742
#ifdef CONFIG_GDBSTUB
4743
            case QEMU_OPTION_s:
4744
                gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
4745
                break;
4746
            case QEMU_OPTION_gdb:
4747
                gdbstub_dev = optarg;
4748
                break;
4749
#endif
4750
            case QEMU_OPTION_L:
4751
                bios_dir = optarg;
4752
                break;
4753
            case QEMU_OPTION_bios:
4754
                bios_name = optarg;
4755
                break;
4756
            case QEMU_OPTION_singlestep:
4757
                singlestep = 1;
4758
                break;
4759
            case QEMU_OPTION_S:
4760
                autostart = 0;
4761
                break;
4762
#ifndef _WIN32
4763
            case QEMU_OPTION_k:
4764
                keyboard_layout = optarg;
4765
                break;
4766
#endif
4767
            case QEMU_OPTION_localtime:
4768
                rtc_utc = 0;
4769
                break;
4770
            case QEMU_OPTION_vga:
4771
                select_vgahw (optarg);
4772
                break;
4773
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
4774
            case QEMU_OPTION_g:
4775
                {
4776
                    const char *p;
4777
                    int w, h, depth;
4778
                    p = optarg;
4779
                    w = strtol(p, (char **)&p, 10);
4780
                    if (w <= 0) {
4781
                    graphic_error:
4782
                        fprintf(stderr, "qemu: invalid resolution or depth\n");
4783
                        exit(1);
4784
                    }
4785
                    if (*p != 'x')
4786
                        goto graphic_error;
4787
                    p++;
4788
                    h = strtol(p, (char **)&p, 10);
4789
                    if (h <= 0)
4790
                        goto graphic_error;
4791
                    if (*p == 'x') {
4792
                        p++;
4793
                        depth = strtol(p, (char **)&p, 10);
4794
                        if (depth != 8 && depth != 15 && depth != 16 &&
4795
                            depth != 24 && depth != 32)
4796
                            goto graphic_error;
4797
                    } else if (*p == '\0') {
4798
                        depth = graphic_depth;
4799
                    } else {
4800
                        goto graphic_error;
4801
                    }
4802

    
4803
                    graphic_width = w;
4804
                    graphic_height = h;
4805
                    graphic_depth = depth;
4806
                }
4807
                break;
4808
#endif
4809
            case QEMU_OPTION_echr:
4810
                {
4811
                    char *r;
4812
                    term_escape_char = strtol(optarg, &r, 0);
4813
                    if (r == optarg)
4814
                        printf("Bad argument to echr\n");
4815
                    break;
4816
                }
4817
            case QEMU_OPTION_monitor:
4818
                monitor_device = optarg;
4819
                break;
4820
            case QEMU_OPTION_serial:
4821
                if (serial_device_index >= MAX_SERIAL_PORTS) {
4822
                    fprintf(stderr, "qemu: too many serial ports\n");
4823
                    exit(1);
4824
                }
4825
                serial_devices[serial_device_index] = optarg;
4826
                serial_device_index++;
4827
                break;
4828
            case QEMU_OPTION_virtiocon:
4829
                if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
4830
                    fprintf(stderr, "qemu: too many virtio consoles\n");
4831
                    exit(1);
4832
                }
4833
                virtio_consoles[virtio_console_index] = optarg;
4834
                virtio_console_index++;
4835
                break;
4836
            case QEMU_OPTION_parallel:
4837
                if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4838
                    fprintf(stderr, "qemu: too many parallel ports\n");
4839
                    exit(1);
4840
                }
4841
                parallel_devices[parallel_device_index] = optarg;
4842
                parallel_device_index++;
4843
                break;
4844
            case QEMU_OPTION_loadvm:
4845
                loadvm = optarg;
4846
                break;
4847
            case QEMU_OPTION_full_screen:
4848
                full_screen = 1;
4849
                break;
4850
#ifdef CONFIG_SDL
4851
            case QEMU_OPTION_no_frame:
4852
                no_frame = 1;
4853
                break;
4854
            case QEMU_OPTION_alt_grab:
4855
                alt_grab = 1;
4856
                break;
4857
            case QEMU_OPTION_no_quit:
4858
                no_quit = 1;
4859
                break;
4860
            case QEMU_OPTION_sdl:
4861
                sdl = 1;
4862
                break;
4863
#endif
4864
            case QEMU_OPTION_pidfile:
4865
                pid_file = optarg;
4866
                break;
4867
#ifdef TARGET_I386
4868
            case QEMU_OPTION_win2k_hack:
4869
                win2k_install_hack = 1;
4870
                break;
4871
            case QEMU_OPTION_rtc_td_hack:
4872
                rtc_td_hack = 1;
4873
                break;
4874
            case QEMU_OPTION_acpitable:
4875
                if(acpi_table_add(optarg) < 0) {
4876
                    fprintf(stderr, "Wrong acpi table provided\n");
4877
                    exit(1);
4878
                }
4879
                break;
4880
            case QEMU_OPTION_smbios:
4881
                if(smbios_entry_add(optarg) < 0) {
4882
                    fprintf(stderr, "Wrong smbios provided\n");
4883
                    exit(1);
4884
                }
4885
                break;
4886
#endif
4887
#ifdef CONFIG_KQEMU
4888
            case QEMU_OPTION_no_kqemu:
4889
                kqemu_allowed = 0;
4890
                break;
4891
            case QEMU_OPTION_kernel_kqemu:
4892
                kqemu_allowed = 2;
4893
                break;
4894
#endif
4895
#ifdef CONFIG_KVM
4896
            case QEMU_OPTION_enable_kvm:
4897
                kvm_allowed = 1;
4898
#ifdef CONFIG_KQEMU
4899
                kqemu_allowed = 0;
4900
#endif
4901
                break;
4902
#endif
4903
            case QEMU_OPTION_usb:
4904
                usb_enabled = 1;
4905
                break;
4906
            case QEMU_OPTION_usbdevice:
4907
                usb_enabled = 1;
4908
                if (usb_devices_index >= MAX_USB_CMDLINE) {
4909
                    fprintf(stderr, "Too many USB devices\n");
4910
                    exit(1);
4911
                }
4912
                usb_devices[usb_devices_index] = optarg;
4913
                usb_devices_index++;
4914
                break;
4915
            case QEMU_OPTION_smp:
4916
                smp_cpus = atoi(optarg);
4917
                if (smp_cpus < 1) {
4918
                    fprintf(stderr, "Invalid number of CPUs\n");
4919
                    exit(1);
4920
                }
4921
                break;
4922
            case QEMU_OPTION_vnc:
4923
                vnc_display = optarg;
4924
                break;
4925
#ifdef TARGET_I386
4926
            case QEMU_OPTION_no_acpi:
4927
                acpi_enabled = 0;
4928
                break;
4929
            case QEMU_OPTION_no_hpet:
4930
                no_hpet = 1;
4931
                break;
4932
#endif
4933
            case QEMU_OPTION_no_reboot:
4934
                no_reboot = 1;
4935
                break;
4936
            case QEMU_OPTION_no_shutdown:
4937
                no_shutdown = 1;
4938
                break;
4939
            case QEMU_OPTION_show_cursor:
4940
                cursor_hide = 0;
4941
                break;
4942
            case QEMU_OPTION_uuid:
4943
                if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
4944
                    fprintf(stderr, "Fail to parse UUID string."