Statistics
| Branch: | Revision:

root / vl.c @ c60e08d9

History | View | Annotate | Download (229.6 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 "hw/hw.h"
25
#include "hw/boards.h"
26
#include "hw/usb.h"
27
#include "hw/pcmcia.h"
28
#include "hw/pc.h"
29
#include "hw/audiodev.h"
30
#include "hw/isa.h"
31
#include "hw/baum.h"
32
#include "net.h"
33
#include "console.h"
34
#include "sysemu.h"
35
#include "gdbstub.h"
36
#include "qemu-timer.h"
37
#include "qemu-char.h"
38
#include "block.h"
39
#include "audio/audio.h"
40

    
41
#include <unistd.h>
42
#include <fcntl.h>
43
#include <signal.h>
44
#include <time.h>
45
#include <errno.h>
46
#include <sys/time.h>
47
#include <zlib.h>
48

    
49
#ifndef _WIN32
50
#include <sys/times.h>
51
#include <sys/wait.h>
52
#include <termios.h>
53
#include <sys/poll.h>
54
#include <sys/mman.h>
55
#include <sys/ioctl.h>
56
#include <sys/socket.h>
57
#include <netinet/in.h>
58
#include <dirent.h>
59
#include <netdb.h>
60
#include <sys/select.h>
61
#include <arpa/inet.h>
62
#ifdef _BSD
63
#include <sys/stat.h>
64
#ifndef __APPLE__
65
#include <libutil.h>
66
#endif
67
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
68
#include <freebsd/stdlib.h>
69
#else
70
#ifndef __sun__
71
#include <linux/if.h>
72
#include <linux/if_tun.h>
73
#include <pty.h>
74
#include <malloc.h>
75
#include <linux/rtc.h>
76

    
77
/* For the benefit of older linux systems which don't supply it,
78
   we use a local copy of hpet.h. */
79
/* #include <linux/hpet.h> */
80
#include "hpet.h"
81

    
82
#include <linux/ppdev.h>
83
#include <linux/parport.h>
84
#else
85
#include <sys/stat.h>
86
#include <sys/ethernet.h>
87
#include <sys/sockio.h>
88
#include <netinet/arp.h>
89
#include <netinet/in.h>
90
#include <netinet/in_systm.h>
91
#include <netinet/ip.h>
92
#include <netinet/ip_icmp.h> // must come after ip.h
93
#include <netinet/udp.h>
94
#include <netinet/tcp.h>
95
#include <net/if.h>
96
#include <syslog.h>
97
#include <stropts.h>
98
#endif
99
#endif
100
#else
101
#include <winsock2.h>
102
int inet_aton(const char *cp, struct in_addr *ia);
103
#endif
104

    
105
#if defined(CONFIG_SLIRP)
106
#include "libslirp.h"
107
#endif
108

    
109
#ifdef _WIN32
110
#include <malloc.h>
111
#include <sys/timeb.h>
112
#include <mmsystem.h>
113
#define getopt_long_only getopt_long
114
#define memalign(align, size) malloc(size)
115
#endif
116

    
117
#include "qemu_socket.h"
118

    
119
#ifdef CONFIG_SDL
120
#ifdef __APPLE__
121
#include <SDL/SDL.h>
122
#endif
123
#endif /* CONFIG_SDL */
124

    
125
#ifdef CONFIG_COCOA
126
#undef main
127
#define main qemu_main
128
#endif /* CONFIG_COCOA */
129

    
130
#include "disas.h"
131

    
132
#include "exec-all.h"
133

    
134
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
135
#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
136
#ifdef __sun__
137
#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
138
#else
139
#define SMBD_COMMAND "/usr/sbin/smbd"
140
#endif
141

    
142
//#define DEBUG_UNUSED_IOPORT
143
//#define DEBUG_IOPORT
144

    
145
#ifdef TARGET_PPC
146
#define DEFAULT_RAM_SIZE 144
147
#else
148
#define DEFAULT_RAM_SIZE 128
149
#endif
150
/* in ms */
151
#define GUI_REFRESH_INTERVAL 30
152

    
153
/* Max number of USB devices that can be specified on the commandline.  */
154
#define MAX_USB_CMDLINE 8
155

    
156
/* XXX: use a two level table to limit memory usage */
157
#define MAX_IOPORTS 65536
158

    
159
const char *bios_dir = CONFIG_QEMU_SHAREDIR;
160
const char *bios_name = NULL;
161
void *ioport_opaque[MAX_IOPORTS];
162
IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
163
IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
164
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
165
   to store the VM snapshots */
166
DriveInfo drives_table[MAX_DRIVES+1];
167
int nb_drives;
168
/* point to the block driver where the snapshots are managed */
169
BlockDriverState *bs_snapshots;
170
int vga_ram_size;
171
static DisplayState display_state;
172
int nographic;
173
int curses;
174
const char* keyboard_layout = NULL;
175
int64_t ticks_per_sec;
176
ram_addr_t ram_size;
177
int pit_min_timer_count = 0;
178
int nb_nics;
179
NICInfo nd_table[MAX_NICS];
180
int vm_running;
181
static int rtc_utc = 1;
182
static int rtc_date_offset = -1; /* -1 means no change */
183
int cirrus_vga_enabled = 1;
184
int vmsvga_enabled = 0;
185
#ifdef TARGET_SPARC
186
int graphic_width = 1024;
187
int graphic_height = 768;
188
int graphic_depth = 8;
189
#else
190
int graphic_width = 800;
191
int graphic_height = 600;
192
int graphic_depth = 15;
193
#endif
194
int full_screen = 0;
195
int no_frame = 0;
196
int no_quit = 0;
197
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
198
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
199
#ifdef TARGET_I386
200
int win2k_install_hack = 0;
201
#endif
202
int usb_enabled = 0;
203
static VLANState *first_vlan;
204
int smp_cpus = 1;
205
const char *vnc_display;
206
#if defined(TARGET_SPARC)
207
#define MAX_CPUS 16
208
#elif defined(TARGET_I386)
209
#define MAX_CPUS 255
210
#else
211
#define MAX_CPUS 1
212
#endif
213
int acpi_enabled = 1;
214
int fd_bootchk = 1;
215
int no_reboot = 0;
216
int no_shutdown = 0;
217
int cursor_hide = 1;
218
int graphic_rotate = 0;
219
int daemonize = 0;
220
const char *option_rom[MAX_OPTION_ROMS];
221
int nb_option_roms;
222
int semihosting_enabled = 0;
223
int autostart = 1;
224
#ifdef TARGET_ARM
225
int old_param = 0;
226
#endif
227
const char *qemu_name;
228
int alt_grab = 0;
229
#ifdef TARGET_SPARC
230
unsigned int nb_prom_envs = 0;
231
const char *prom_envs[MAX_PROM_ENVS];
232
#endif
233
int nb_drives_opt;
234
struct drive_opt {
235
    const char *file;
236
    char opt[1024];
237
} drives_opt[MAX_DRIVES];
238

    
239
static CPUState *cur_cpu;
240
static CPUState *next_cpu;
241
static int event_pending = 1;
242
/* Conversion factor from emulated instructions to virtual clock ticks.  */
243
static int icount_time_shift;
244
/* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
245
#define MAX_ICOUNT_SHIFT 10
246
/* Compensate for varying guest execution speed.  */
247
static int64_t qemu_icount_bias;
248
QEMUTimer *icount_rt_timer;
249
QEMUTimer *icount_vm_timer;
250

    
251
#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
252

    
253
/***********************************************************/
254
/* x86 ISA bus support */
255

    
256
target_phys_addr_t isa_mem_base = 0;
257
PicState2 *isa_pic;
258

    
259
static uint32_t default_ioport_readb(void *opaque, uint32_t address)
260
{
261
#ifdef DEBUG_UNUSED_IOPORT
262
    fprintf(stderr, "unused inb: port=0x%04x\n", address);
263
#endif
264
    return 0xff;
265
}
266

    
267
static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
268
{
269
#ifdef DEBUG_UNUSED_IOPORT
270
    fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
271
#endif
272
}
273

    
274
/* default is to make two byte accesses */
275
static uint32_t default_ioport_readw(void *opaque, uint32_t address)
276
{
277
    uint32_t data;
278
    data = ioport_read_table[0][address](ioport_opaque[address], address);
279
    address = (address + 1) & (MAX_IOPORTS - 1);
280
    data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
281
    return data;
282
}
283

    
284
static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
285
{
286
    ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
287
    address = (address + 1) & (MAX_IOPORTS - 1);
288
    ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
289
}
290

    
291
static uint32_t default_ioport_readl(void *opaque, uint32_t address)
292
{
293
#ifdef DEBUG_UNUSED_IOPORT
294
    fprintf(stderr, "unused inl: port=0x%04x\n", address);
295
#endif
296
    return 0xffffffff;
297
}
298

    
299
static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
300
{
301
#ifdef DEBUG_UNUSED_IOPORT
302
    fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
303
#endif
304
}
305

    
306
static void init_ioports(void)
307
{
308
    int i;
309

    
310
    for(i = 0; i < MAX_IOPORTS; i++) {
311
        ioport_read_table[0][i] = default_ioport_readb;
312
        ioport_write_table[0][i] = default_ioport_writeb;
313
        ioport_read_table[1][i] = default_ioport_readw;
314
        ioport_write_table[1][i] = default_ioport_writew;
315
        ioport_read_table[2][i] = default_ioport_readl;
316
        ioport_write_table[2][i] = default_ioport_writel;
317
    }
318
}
319

    
320
/* size is the word size in byte */
321
int register_ioport_read(int start, int length, int size,
322
                         IOPortReadFunc *func, void *opaque)
323
{
324
    int i, bsize;
325

    
326
    if (size == 1) {
327
        bsize = 0;
328
    } else if (size == 2) {
329
        bsize = 1;
330
    } else if (size == 4) {
331
        bsize = 2;
332
    } else {
333
        hw_error("register_ioport_read: invalid size");
334
        return -1;
335
    }
336
    for(i = start; i < start + length; i += size) {
337
        ioport_read_table[bsize][i] = func;
338
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
339
            hw_error("register_ioport_read: invalid opaque");
340
        ioport_opaque[i] = opaque;
341
    }
342
    return 0;
343
}
344

    
345
/* size is the word size in byte */
346
int register_ioport_write(int start, int length, int size,
347
                          IOPortWriteFunc *func, void *opaque)
348
{
349
    int i, bsize;
350

    
351
    if (size == 1) {
352
        bsize = 0;
353
    } else if (size == 2) {
354
        bsize = 1;
355
    } else if (size == 4) {
356
        bsize = 2;
357
    } else {
358
        hw_error("register_ioport_write: invalid size");
359
        return -1;
360
    }
361
    for(i = start; i < start + length; i += size) {
362
        ioport_write_table[bsize][i] = func;
363
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
364
            hw_error("register_ioport_write: invalid opaque");
365
        ioport_opaque[i] = opaque;
366
    }
367
    return 0;
368
}
369

    
370
void isa_unassign_ioport(int start, int length)
371
{
372
    int i;
373

    
374
    for(i = start; i < start + length; i++) {
375
        ioport_read_table[0][i] = default_ioport_readb;
376
        ioport_read_table[1][i] = default_ioport_readw;
377
        ioport_read_table[2][i] = default_ioport_readl;
378

    
379
        ioport_write_table[0][i] = default_ioport_writeb;
380
        ioport_write_table[1][i] = default_ioport_writew;
381
        ioport_write_table[2][i] = default_ioport_writel;
382
    }
383
}
384

    
385
/***********************************************************/
386

    
387
void cpu_outb(CPUState *env, int addr, int val)
388
{
389
#ifdef DEBUG_IOPORT
390
    if (loglevel & CPU_LOG_IOPORT)
391
        fprintf(logfile, "outb: %04x %02x\n", addr, val);
392
#endif
393
    ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
394
#ifdef USE_KQEMU
395
    if (env)
396
        env->last_io_time = cpu_get_time_fast();
397
#endif
398
}
399

    
400
void cpu_outw(CPUState *env, int addr, int val)
401
{
402
#ifdef DEBUG_IOPORT
403
    if (loglevel & CPU_LOG_IOPORT)
404
        fprintf(logfile, "outw: %04x %04x\n", addr, val);
405
#endif
406
    ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
407
#ifdef USE_KQEMU
408
    if (env)
409
        env->last_io_time = cpu_get_time_fast();
410
#endif
411
}
412

    
413
void cpu_outl(CPUState *env, int addr, int val)
414
{
415
#ifdef DEBUG_IOPORT
416
    if (loglevel & CPU_LOG_IOPORT)
417
        fprintf(logfile, "outl: %04x %08x\n", addr, val);
418
#endif
419
    ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
420
#ifdef USE_KQEMU
421
    if (env)
422
        env->last_io_time = cpu_get_time_fast();
423
#endif
424
}
425

    
426
int cpu_inb(CPUState *env, int addr)
427
{
428
    int val;
429
    val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
430
#ifdef DEBUG_IOPORT
431
    if (loglevel & CPU_LOG_IOPORT)
432
        fprintf(logfile, "inb : %04x %02x\n", addr, val);
433
#endif
434
#ifdef USE_KQEMU
435
    if (env)
436
        env->last_io_time = cpu_get_time_fast();
437
#endif
438
    return val;
439
}
440

    
441
int cpu_inw(CPUState *env, int addr)
442
{
443
    int val;
444
    val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
445
#ifdef DEBUG_IOPORT
446
    if (loglevel & CPU_LOG_IOPORT)
447
        fprintf(logfile, "inw : %04x %04x\n", addr, val);
448
#endif
449
#ifdef USE_KQEMU
450
    if (env)
451
        env->last_io_time = cpu_get_time_fast();
452
#endif
453
    return val;
454
}
455

    
456
int cpu_inl(CPUState *env, int addr)
457
{
458
    int val;
459
    val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
460
#ifdef DEBUG_IOPORT
461
    if (loglevel & CPU_LOG_IOPORT)
462
        fprintf(logfile, "inl : %04x %08x\n", addr, val);
463
#endif
464
#ifdef USE_KQEMU
465
    if (env)
466
        env->last_io_time = cpu_get_time_fast();
467
#endif
468
    return val;
469
}
470

    
471
/***********************************************************/
472
void hw_error(const char *fmt, ...)
473
{
474
    va_list ap;
475
    CPUState *env;
476

    
477
    va_start(ap, fmt);
478
    fprintf(stderr, "qemu: hardware error: ");
479
    vfprintf(stderr, fmt, ap);
480
    fprintf(stderr, "\n");
481
    for(env = first_cpu; env != NULL; env = env->next_cpu) {
482
        fprintf(stderr, "CPU #%d:\n", env->cpu_index);
483
#ifdef TARGET_I386
484
        cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
485
#else
486
        cpu_dump_state(env, stderr, fprintf, 0);
487
#endif
488
    }
489
    va_end(ap);
490
    abort();
491
}
492

    
493
/***********************************************************/
494
/* keyboard/mouse */
495

    
496
static QEMUPutKBDEvent *qemu_put_kbd_event;
497
static void *qemu_put_kbd_event_opaque;
498
static QEMUPutMouseEntry *qemu_put_mouse_event_head;
499
static QEMUPutMouseEntry *qemu_put_mouse_event_current;
500

    
501
void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
502
{
503
    qemu_put_kbd_event_opaque = opaque;
504
    qemu_put_kbd_event = func;
505
}
506

    
507
QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
508
                                                void *opaque, int absolute,
509
                                                const char *name)
510
{
511
    QEMUPutMouseEntry *s, *cursor;
512

    
513
    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
514
    if (!s)
515
        return NULL;
516

    
517
    s->qemu_put_mouse_event = func;
518
    s->qemu_put_mouse_event_opaque = opaque;
519
    s->qemu_put_mouse_event_absolute = absolute;
520
    s->qemu_put_mouse_event_name = qemu_strdup(name);
521
    s->next = NULL;
522

    
523
    if (!qemu_put_mouse_event_head) {
524
        qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
525
        return s;
526
    }
527

    
528
    cursor = qemu_put_mouse_event_head;
529
    while (cursor->next != NULL)
530
        cursor = cursor->next;
531

    
532
    cursor->next = s;
533
    qemu_put_mouse_event_current = s;
534

    
535
    return s;
536
}
537

    
538
void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
539
{
540
    QEMUPutMouseEntry *prev = NULL, *cursor;
541

    
542
    if (!qemu_put_mouse_event_head || entry == NULL)
543
        return;
544

    
545
    cursor = qemu_put_mouse_event_head;
546
    while (cursor != NULL && cursor != entry) {
547
        prev = cursor;
548
        cursor = cursor->next;
549
    }
550

    
551
    if (cursor == NULL) // does not exist or list empty
552
        return;
553
    else if (prev == NULL) { // entry is head
554
        qemu_put_mouse_event_head = cursor->next;
555
        if (qemu_put_mouse_event_current == entry)
556
            qemu_put_mouse_event_current = cursor->next;
557
        qemu_free(entry->qemu_put_mouse_event_name);
558
        qemu_free(entry);
559
        return;
560
    }
561

    
562
    prev->next = entry->next;
563

    
564
    if (qemu_put_mouse_event_current == entry)
565
        qemu_put_mouse_event_current = prev;
566

    
567
    qemu_free(entry->qemu_put_mouse_event_name);
568
    qemu_free(entry);
569
}
570

    
571
void kbd_put_keycode(int keycode)
572
{
573
    if (qemu_put_kbd_event) {
574
        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
575
    }
576
}
577

    
578
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
579
{
580
    QEMUPutMouseEvent *mouse_event;
581
    void *mouse_event_opaque;
582
    int width;
583

    
584
    if (!qemu_put_mouse_event_current) {
585
        return;
586
    }
587

    
588
    mouse_event =
589
        qemu_put_mouse_event_current->qemu_put_mouse_event;
590
    mouse_event_opaque =
591
        qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
592

    
593
    if (mouse_event) {
594
        if (graphic_rotate) {
595
            if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
596
                width = 0x7fff;
597
            else
598
                width = graphic_width - 1;
599
            mouse_event(mouse_event_opaque,
600
                                 width - dy, dx, dz, buttons_state);
601
        } else
602
            mouse_event(mouse_event_opaque,
603
                                 dx, dy, dz, buttons_state);
604
    }
605
}
606

    
607
int kbd_mouse_is_absolute(void)
608
{
609
    if (!qemu_put_mouse_event_current)
610
        return 0;
611

    
612
    return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
613
}
614

    
615
void do_info_mice(void)
616
{
617
    QEMUPutMouseEntry *cursor;
618
    int index = 0;
619

    
620
    if (!qemu_put_mouse_event_head) {
621
        term_printf("No mouse devices connected\n");
622
        return;
623
    }
624

    
625
    term_printf("Mouse devices available:\n");
626
    cursor = qemu_put_mouse_event_head;
627
    while (cursor != NULL) {
628
        term_printf("%c Mouse #%d: %s\n",
629
                    (cursor == qemu_put_mouse_event_current ? '*' : ' '),
630
                    index, cursor->qemu_put_mouse_event_name);
631
        index++;
632
        cursor = cursor->next;
633
    }
634
}
635

    
636
void do_mouse_set(int index)
637
{
638
    QEMUPutMouseEntry *cursor;
639
    int i = 0;
640

    
641
    if (!qemu_put_mouse_event_head) {
642
        term_printf("No mouse devices connected\n");
643
        return;
644
    }
645

    
646
    cursor = qemu_put_mouse_event_head;
647
    while (cursor != NULL && index != i) {
648
        i++;
649
        cursor = cursor->next;
650
    }
651

    
652
    if (cursor != NULL)
653
        qemu_put_mouse_event_current = cursor;
654
    else
655
        term_printf("Mouse at given index not found\n");
656
}
657

    
658
/* compute with 96 bit intermediate result: (a*b)/c */
659
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
660
{
661
    union {
662
        uint64_t ll;
663
        struct {
664
#ifdef WORDS_BIGENDIAN
665
            uint32_t high, low;
666
#else
667
            uint32_t low, high;
668
#endif
669
        } l;
670
    } u, res;
671
    uint64_t rl, rh;
672

    
673
    u.ll = a;
674
    rl = (uint64_t)u.l.low * (uint64_t)b;
675
    rh = (uint64_t)u.l.high * (uint64_t)b;
676
    rh += (rl >> 32);
677
    res.l.high = rh / c;
678
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
679
    return res.ll;
680
}
681

    
682
/***********************************************************/
683
/* real time host monotonic timer */
684

    
685
#define QEMU_TIMER_BASE 1000000000LL
686

    
687
#ifdef WIN32
688

    
689
static int64_t clock_freq;
690

    
691
static void init_get_clock(void)
692
{
693
    LARGE_INTEGER freq;
694
    int ret;
695
    ret = QueryPerformanceFrequency(&freq);
696
    if (ret == 0) {
697
        fprintf(stderr, "Could not calibrate ticks\n");
698
        exit(1);
699
    }
700
    clock_freq = freq.QuadPart;
701
}
702

    
703
static int64_t get_clock(void)
704
{
705
    LARGE_INTEGER ti;
706
    QueryPerformanceCounter(&ti);
707
    return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
708
}
709

    
710
#else
711

    
712
static int use_rt_clock;
713

    
714
static void init_get_clock(void)
715
{
716
    use_rt_clock = 0;
717
#if defined(__linux__)
718
    {
719
        struct timespec ts;
720
        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
721
            use_rt_clock = 1;
722
        }
723
    }
724
#endif
725
}
726

    
727
static int64_t get_clock(void)
728
{
729
#if defined(__linux__)
730
    if (use_rt_clock) {
731
        struct timespec ts;
732
        clock_gettime(CLOCK_MONOTONIC, &ts);
733
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
734
    } else
735
#endif
736
    {
737
        /* XXX: using gettimeofday leads to problems if the date
738
           changes, so it should be avoided. */
739
        struct timeval tv;
740
        gettimeofday(&tv, NULL);
741
        return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
742
    }
743
}
744
#endif
745

    
746
/* Return the virtual CPU time, based on the instruction counter.  */
747
static int64_t cpu_get_icount(void)
748
{
749
    int64_t icount;
750
    CPUState *env = cpu_single_env;;
751
    icount = qemu_icount;
752
    if (env) {
753
        if (!can_do_io(env))
754
            fprintf(stderr, "Bad clock read\n");
755
        icount -= (env->icount_decr.u16.low + env->icount_extra);
756
    }
757
    return qemu_icount_bias + (icount << icount_time_shift);
758
}
759

    
760
/***********************************************************/
761
/* guest cycle counter */
762

    
763
static int64_t cpu_ticks_prev;
764
static int64_t cpu_ticks_offset;
765
static int64_t cpu_clock_offset;
766
static int cpu_ticks_enabled;
767

    
768
/* return the host CPU cycle counter and handle stop/restart */
769
int64_t cpu_get_ticks(void)
770
{
771
    if (use_icount) {
772
        return cpu_get_icount();
773
    }
774
    if (!cpu_ticks_enabled) {
775
        return cpu_ticks_offset;
776
    } else {
777
        int64_t ticks;
778
        ticks = cpu_get_real_ticks();
779
        if (cpu_ticks_prev > ticks) {
780
            /* Note: non increasing ticks may happen if the host uses
781
               software suspend */
782
            cpu_ticks_offset += cpu_ticks_prev - ticks;
783
        }
784
        cpu_ticks_prev = ticks;
785
        return ticks + cpu_ticks_offset;
786
    }
787
}
788

    
789
/* return the host CPU monotonic timer and handle stop/restart */
790
static int64_t cpu_get_clock(void)
791
{
792
    int64_t ti;
793
    if (!cpu_ticks_enabled) {
794
        return cpu_clock_offset;
795
    } else {
796
        ti = get_clock();
797
        return ti + cpu_clock_offset;
798
    }
799
}
800

    
801
/* enable cpu_get_ticks() */
802
void cpu_enable_ticks(void)
803
{
804
    if (!cpu_ticks_enabled) {
805
        cpu_ticks_offset -= cpu_get_real_ticks();
806
        cpu_clock_offset -= get_clock();
807
        cpu_ticks_enabled = 1;
808
    }
809
}
810

    
811
/* disable cpu_get_ticks() : the clock is stopped. You must not call
812
   cpu_get_ticks() after that.  */
813
void cpu_disable_ticks(void)
814
{
815
    if (cpu_ticks_enabled) {
816
        cpu_ticks_offset = cpu_get_ticks();
817
        cpu_clock_offset = cpu_get_clock();
818
        cpu_ticks_enabled = 0;
819
    }
820
}
821

    
822
/***********************************************************/
823
/* timers */
824

    
825
#define QEMU_TIMER_REALTIME 0
826
#define QEMU_TIMER_VIRTUAL  1
827

    
828
struct QEMUClock {
829
    int type;
830
    /* XXX: add frequency */
831
};
832

    
833
struct QEMUTimer {
834
    QEMUClock *clock;
835
    int64_t expire_time;
836
    QEMUTimerCB *cb;
837
    void *opaque;
838
    struct QEMUTimer *next;
839
};
840

    
841
struct qemu_alarm_timer {
842
    char const *name;
843
    unsigned int flags;
844

    
845
    int (*start)(struct qemu_alarm_timer *t);
846
    void (*stop)(struct qemu_alarm_timer *t);
847
    void (*rearm)(struct qemu_alarm_timer *t);
848
    void *priv;
849
};
850

    
851
#define ALARM_FLAG_DYNTICKS  0x1
852
#define ALARM_FLAG_EXPIRED   0x2
853

    
854
static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
855
{
856
    return t->flags & ALARM_FLAG_DYNTICKS;
857
}
858

    
859
static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
860
{
861
    if (!alarm_has_dynticks(t))
862
        return;
863

    
864
    t->rearm(t);
865
}
866

    
867
/* TODO: MIN_TIMER_REARM_US should be optimized */
868
#define MIN_TIMER_REARM_US 250
869

    
870
static struct qemu_alarm_timer *alarm_timer;
871

    
872
#ifdef _WIN32
873

    
874
struct qemu_alarm_win32 {
875
    MMRESULT timerId;
876
    HANDLE host_alarm;
877
    unsigned int period;
878
} alarm_win32_data = {0, NULL, -1};
879

    
880
static int win32_start_timer(struct qemu_alarm_timer *t);
881
static void win32_stop_timer(struct qemu_alarm_timer *t);
882
static void win32_rearm_timer(struct qemu_alarm_timer *t);
883

    
884
#else
885

    
886
static int unix_start_timer(struct qemu_alarm_timer *t);
887
static void unix_stop_timer(struct qemu_alarm_timer *t);
888

    
889
#ifdef __linux__
890

    
891
static int dynticks_start_timer(struct qemu_alarm_timer *t);
892
static void dynticks_stop_timer(struct qemu_alarm_timer *t);
893
static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
894

    
895
static int hpet_start_timer(struct qemu_alarm_timer *t);
896
static void hpet_stop_timer(struct qemu_alarm_timer *t);
897

    
898
static int rtc_start_timer(struct qemu_alarm_timer *t);
899
static void rtc_stop_timer(struct qemu_alarm_timer *t);
900

    
901
#endif /* __linux__ */
902

    
903
#endif /* _WIN32 */
904

    
905
/* Correlation between real and virtual time is always going to be
906
   fairly approximate, so ignore small variation.
907
   When the guest is idle real and virtual time will be aligned in
908
   the IO wait loop.  */
909
#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
910

    
911
static void icount_adjust(void)
912
{
913
    int64_t cur_time;
914
    int64_t cur_icount;
915
    int64_t delta;
916
    static int64_t last_delta;
917
    /* If the VM is not running, then do nothing.  */
918
    if (!vm_running)
919
        return;
920

    
921
    cur_time = cpu_get_clock();
922
    cur_icount = qemu_get_clock(vm_clock);
923
    delta = cur_icount - cur_time;
924
    /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
925
    if (delta > 0
926
        && last_delta + ICOUNT_WOBBLE < delta * 2
927
        && icount_time_shift > 0) {
928
        /* The guest is getting too far ahead.  Slow time down.  */
929
        icount_time_shift--;
930
    }
931
    if (delta < 0
932
        && last_delta - ICOUNT_WOBBLE > delta * 2
933
        && icount_time_shift < MAX_ICOUNT_SHIFT) {
934
        /* The guest is getting too far behind.  Speed time up.  */
935
        icount_time_shift++;
936
    }
937
    last_delta = delta;
938
    qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
939
}
940

    
941
static void icount_adjust_rt(void * opaque)
942
{
943
    qemu_mod_timer(icount_rt_timer,
944
                   qemu_get_clock(rt_clock) + 1000);
945
    icount_adjust();
946
}
947

    
948
static void icount_adjust_vm(void * opaque)
949
{
950
    qemu_mod_timer(icount_vm_timer,
951
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
952
    icount_adjust();
953
}
954

    
955
static void init_icount_adjust(void)
956
{
957
    /* Have both realtime and virtual time triggers for speed adjustment.
958
       The realtime trigger catches emulated time passing too slowly,
959
       the virtual time trigger catches emulated time passing too fast.
960
       Realtime triggers occur even when idle, so use them less frequently
961
       than VM triggers.  */
962
    icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
963
    qemu_mod_timer(icount_rt_timer,
964
                   qemu_get_clock(rt_clock) + 1000);
965
    icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
966
    qemu_mod_timer(icount_vm_timer,
967
                   qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
968
}
969

    
970
static struct qemu_alarm_timer alarm_timers[] = {
971
#ifndef _WIN32
972
#ifdef __linux__
973
    {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
974
     dynticks_stop_timer, dynticks_rearm_timer, NULL},
975
    /* HPET - if available - is preferred */
976
    {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
977
    /* ...otherwise try RTC */
978
    {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
979
#endif
980
    {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
981
#else
982
    {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
983
     win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
984
    {"win32", 0, win32_start_timer,
985
     win32_stop_timer, NULL, &alarm_win32_data},
986
#endif
987
    {NULL, }
988
};
989

    
990
static void show_available_alarms(void)
991
{
992
    int i;
993

    
994
    printf("Available alarm timers, in order of precedence:\n");
995
    for (i = 0; alarm_timers[i].name; i++)
996
        printf("%s\n", alarm_timers[i].name);
997
}
998

    
999
static void configure_alarms(char const *opt)
1000
{
1001
    int i;
1002
    int cur = 0;
1003
    int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
1004
    char *arg;
1005
    char *name;
1006
    struct qemu_alarm_timer tmp;
1007

    
1008
    if (!strcmp(opt, "?")) {
1009
        show_available_alarms();
1010
        exit(0);
1011
    }
1012

    
1013
    arg = strdup(opt);
1014

    
1015
    /* Reorder the array */
1016
    name = strtok(arg, ",");
1017
    while (name) {
1018
        for (i = 0; i < count && alarm_timers[i].name; i++) {
1019
            if (!strcmp(alarm_timers[i].name, name))
1020
                break;
1021
        }
1022

    
1023
        if (i == count) {
1024
            fprintf(stderr, "Unknown clock %s\n", name);
1025
            goto next;
1026
        }
1027

    
1028
        if (i < cur)
1029
            /* Ignore */
1030
            goto next;
1031

    
1032
        /* Swap */
1033
        tmp = alarm_timers[i];
1034
        alarm_timers[i] = alarm_timers[cur];
1035
        alarm_timers[cur] = tmp;
1036

    
1037
        cur++;
1038
next:
1039
        name = strtok(NULL, ",");
1040
    }
1041

    
1042
    free(arg);
1043

    
1044
    if (cur) {
1045
        /* Disable remaining timers */
1046
        for (i = cur; i < count; i++)
1047
            alarm_timers[i].name = NULL;
1048
    } else {
1049
        show_available_alarms();
1050
        exit(1);
1051
    }
1052
}
1053

    
1054
QEMUClock *rt_clock;
1055
QEMUClock *vm_clock;
1056

    
1057
static QEMUTimer *active_timers[2];
1058

    
1059
static QEMUClock *qemu_new_clock(int type)
1060
{
1061
    QEMUClock *clock;
1062
    clock = qemu_mallocz(sizeof(QEMUClock));
1063
    if (!clock)
1064
        return NULL;
1065
    clock->type = type;
1066
    return clock;
1067
}
1068

    
1069
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1070
{
1071
    QEMUTimer *ts;
1072

    
1073
    ts = qemu_mallocz(sizeof(QEMUTimer));
1074
    ts->clock = clock;
1075
    ts->cb = cb;
1076
    ts->opaque = opaque;
1077
    return ts;
1078
}
1079

    
1080
void qemu_free_timer(QEMUTimer *ts)
1081
{
1082
    qemu_free(ts);
1083
}
1084

    
1085
/* stop a timer, but do not dealloc it */
1086
void qemu_del_timer(QEMUTimer *ts)
1087
{
1088
    QEMUTimer **pt, *t;
1089

    
1090
    /* NOTE: this code must be signal safe because
1091
       qemu_timer_expired() can be called from a signal. */
1092
    pt = &active_timers[ts->clock->type];
1093
    for(;;) {
1094
        t = *pt;
1095
        if (!t)
1096
            break;
1097
        if (t == ts) {
1098
            *pt = t->next;
1099
            break;
1100
        }
1101
        pt = &t->next;
1102
    }
1103
}
1104

    
1105
/* modify the current timer so that it will be fired when current_time
1106
   >= expire_time. The corresponding callback will be called. */
1107
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1108
{
1109
    QEMUTimer **pt, *t;
1110

    
1111
    qemu_del_timer(ts);
1112

    
1113
    /* add the timer in the sorted list */
1114
    /* NOTE: this code must be signal safe because
1115
       qemu_timer_expired() can be called from a signal. */
1116
    pt = &active_timers[ts->clock->type];
1117
    for(;;) {
1118
        t = *pt;
1119
        if (!t)
1120
            break;
1121
        if (t->expire_time > expire_time)
1122
            break;
1123
        pt = &t->next;
1124
    }
1125
    ts->expire_time = expire_time;
1126
    ts->next = *pt;
1127
    *pt = ts;
1128

    
1129
    /* Rearm if necessary  */
1130
    if (pt == &active_timers[ts->clock->type]) {
1131
        if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1132
            qemu_rearm_alarm_timer(alarm_timer);
1133
        }
1134
        /* Interrupt execution to force deadline recalculation.  */
1135
        if (use_icount && cpu_single_env) {
1136
            cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1137
        }
1138
    }
1139
}
1140

    
1141
int qemu_timer_pending(QEMUTimer *ts)
1142
{
1143
    QEMUTimer *t;
1144
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1145
        if (t == ts)
1146
            return 1;
1147
    }
1148
    return 0;
1149
}
1150

    
1151
static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1152
{
1153
    if (!timer_head)
1154
        return 0;
1155
    return (timer_head->expire_time <= current_time);
1156
}
1157

    
1158
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1159
{
1160
    QEMUTimer *ts;
1161

    
1162
    for(;;) {
1163
        ts = *ptimer_head;
1164
        if (!ts || ts->expire_time > current_time)
1165
            break;
1166
        /* remove timer from the list before calling the callback */
1167
        *ptimer_head = ts->next;
1168
        ts->next = NULL;
1169

    
1170
        /* run the callback (the timer list can be modified) */
1171
        ts->cb(ts->opaque);
1172
    }
1173
}
1174

    
1175
int64_t qemu_get_clock(QEMUClock *clock)
1176
{
1177
    switch(clock->type) {
1178
    case QEMU_TIMER_REALTIME:
1179
        return get_clock() / 1000000;
1180
    default:
1181
    case QEMU_TIMER_VIRTUAL:
1182
        if (use_icount) {
1183
            return cpu_get_icount();
1184
        } else {
1185
            return cpu_get_clock();
1186
        }
1187
    }
1188
}
1189

    
1190
static void init_timers(void)
1191
{
1192
    init_get_clock();
1193
    ticks_per_sec = QEMU_TIMER_BASE;
1194
    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1195
    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1196
}
1197

    
1198
/* save a timer */
1199
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1200
{
1201
    uint64_t expire_time;
1202

    
1203
    if (qemu_timer_pending(ts)) {
1204
        expire_time = ts->expire_time;
1205
    } else {
1206
        expire_time = -1;
1207
    }
1208
    qemu_put_be64(f, expire_time);
1209
}
1210

    
1211
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1212
{
1213
    uint64_t expire_time;
1214

    
1215
    expire_time = qemu_get_be64(f);
1216
    if (expire_time != -1) {
1217
        qemu_mod_timer(ts, expire_time);
1218
    } else {
1219
        qemu_del_timer(ts);
1220
    }
1221
}
1222

    
1223
static void timer_save(QEMUFile *f, void *opaque)
1224
{
1225
    if (cpu_ticks_enabled) {
1226
        hw_error("cannot save state if virtual timers are running");
1227
    }
1228
    qemu_put_be64(f, cpu_ticks_offset);
1229
    qemu_put_be64(f, ticks_per_sec);
1230
    qemu_put_be64(f, cpu_clock_offset);
1231
}
1232

    
1233
static int timer_load(QEMUFile *f, void *opaque, int version_id)
1234
{
1235
    if (version_id != 1 && version_id != 2)
1236
        return -EINVAL;
1237
    if (cpu_ticks_enabled) {
1238
        return -EINVAL;
1239
    }
1240
    cpu_ticks_offset=qemu_get_be64(f);
1241
    ticks_per_sec=qemu_get_be64(f);
1242
    if (version_id == 2) {
1243
        cpu_clock_offset=qemu_get_be64(f);
1244
    }
1245
    return 0;
1246
}
1247

    
1248
#ifdef _WIN32
1249
void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1250
                                 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1251
#else
1252
static void host_alarm_handler(int host_signum)
1253
#endif
1254
{
1255
#if 0
1256
#define DISP_FREQ 1000
1257
    {
1258
        static int64_t delta_min = INT64_MAX;
1259
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
1260
        static int count;
1261
        ti = qemu_get_clock(vm_clock);
1262
        if (last_clock != 0) {
1263
            delta = ti - last_clock;
1264
            if (delta < delta_min)
1265
                delta_min = delta;
1266
            if (delta > delta_max)
1267
                delta_max = delta;
1268
            delta_cum += delta;
1269
            if (++count == DISP_FREQ) {
1270
                printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1271
                       muldiv64(delta_min, 1000000, ticks_per_sec),
1272
                       muldiv64(delta_max, 1000000, ticks_per_sec),
1273
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1274
                       (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1275
                count = 0;
1276
                delta_min = INT64_MAX;
1277
                delta_max = 0;
1278
                delta_cum = 0;
1279
            }
1280
        }
1281
        last_clock = ti;
1282
    }
1283
#endif
1284
    if (alarm_has_dynticks(alarm_timer) ||
1285
        (!use_icount &&
1286
            qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1287
                               qemu_get_clock(vm_clock))) ||
1288
        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1289
                           qemu_get_clock(rt_clock))) {
1290
#ifdef _WIN32
1291
        struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1292
        SetEvent(data->host_alarm);
1293
#endif
1294
        CPUState *env = next_cpu;
1295

    
1296
        alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1297

    
1298
        if (env) {
1299
            /* stop the currently executing cpu because a timer occured */
1300
            cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1301
#ifdef USE_KQEMU
1302
            if (env->kqemu_enabled) {
1303
                kqemu_cpu_interrupt(env);
1304
            }
1305
#endif
1306
        }
1307
        event_pending = 1;
1308
    }
1309
}
1310

    
1311
static int64_t qemu_next_deadline(void)
1312
{
1313
    int64_t delta;
1314

    
1315
    if (active_timers[QEMU_TIMER_VIRTUAL]) {
1316
        delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1317
                     qemu_get_clock(vm_clock);
1318
    } else {
1319
        /* To avoid problems with overflow limit this to 2^32.  */
1320
        delta = INT32_MAX;
1321
    }
1322

    
1323
    if (delta < 0)
1324
        delta = 0;
1325

    
1326
    return delta;
1327
}
1328

    
1329
static uint64_t qemu_next_deadline_dyntick(void)
1330
{
1331
    int64_t delta;
1332
    int64_t rtdelta;
1333

    
1334
    if (use_icount)
1335
        delta = INT32_MAX;
1336
    else
1337
        delta = (qemu_next_deadline() + 999) / 1000;
1338

    
1339
    if (active_timers[QEMU_TIMER_REALTIME]) {
1340
        rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1341
                 qemu_get_clock(rt_clock))*1000;
1342
        if (rtdelta < delta)
1343
            delta = rtdelta;
1344
    }
1345

    
1346
    if (delta < MIN_TIMER_REARM_US)
1347
        delta = MIN_TIMER_REARM_US;
1348

    
1349
    return delta;
1350
}
1351

    
1352
#ifndef _WIN32
1353

    
1354
#if defined(__linux__)
1355

    
1356
#define RTC_FREQ 1024
1357

    
1358
static void enable_sigio_timer(int fd)
1359
{
1360
    struct sigaction act;
1361

    
1362
    /* timer signal */
1363
    sigfillset(&act.sa_mask);
1364
    act.sa_flags = 0;
1365
    act.sa_handler = host_alarm_handler;
1366

    
1367
    sigaction(SIGIO, &act, NULL);
1368
    fcntl(fd, F_SETFL, O_ASYNC);
1369
    fcntl(fd, F_SETOWN, getpid());
1370
}
1371

    
1372
static int hpet_start_timer(struct qemu_alarm_timer *t)
1373
{
1374
    struct hpet_info info;
1375
    int r, fd;
1376

    
1377
    fd = open("/dev/hpet", O_RDONLY);
1378
    if (fd < 0)
1379
        return -1;
1380

    
1381
    /* Set frequency */
1382
    r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1383
    if (r < 0) {
1384
        fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1385
                "error, but for better emulation accuracy type:\n"
1386
                "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1387
        goto fail;
1388
    }
1389

    
1390
    /* Check capabilities */
1391
    r = ioctl(fd, HPET_INFO, &info);
1392
    if (r < 0)
1393
        goto fail;
1394

    
1395
    /* Enable periodic mode */
1396
    r = ioctl(fd, HPET_EPI, 0);
1397
    if (info.hi_flags && (r < 0))
1398
        goto fail;
1399

    
1400
    /* Enable interrupt */
1401
    r = ioctl(fd, HPET_IE_ON, 0);
1402
    if (r < 0)
1403
        goto fail;
1404

    
1405
    enable_sigio_timer(fd);
1406
    t->priv = (void *)(long)fd;
1407

    
1408
    return 0;
1409
fail:
1410
    close(fd);
1411
    return -1;
1412
}
1413

    
1414
static void hpet_stop_timer(struct qemu_alarm_timer *t)
1415
{
1416
    int fd = (long)t->priv;
1417

    
1418
    close(fd);
1419
}
1420

    
1421
static int rtc_start_timer(struct qemu_alarm_timer *t)
1422
{
1423
    int rtc_fd;
1424
    unsigned long current_rtc_freq = 0;
1425

    
1426
    TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1427
    if (rtc_fd < 0)
1428
        return -1;
1429
    ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1430
    if (current_rtc_freq != RTC_FREQ &&
1431
        ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1432
        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1433
                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1434
                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1435
        goto fail;
1436
    }
1437
    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1438
    fail:
1439
        close(rtc_fd);
1440
        return -1;
1441
    }
1442

    
1443
    enable_sigio_timer(rtc_fd);
1444

    
1445
    t->priv = (void *)(long)rtc_fd;
1446

    
1447
    return 0;
1448
}
1449

    
1450
static void rtc_stop_timer(struct qemu_alarm_timer *t)
1451
{
1452
    int rtc_fd = (long)t->priv;
1453

    
1454
    close(rtc_fd);
1455
}
1456

    
1457
static int dynticks_start_timer(struct qemu_alarm_timer *t)
1458
{
1459
    struct sigevent ev;
1460
    timer_t host_timer;
1461
    struct sigaction act;
1462

    
1463
    sigfillset(&act.sa_mask);
1464
    act.sa_flags = 0;
1465
    act.sa_handler = host_alarm_handler;
1466

    
1467
    sigaction(SIGALRM, &act, NULL);
1468

    
1469
    ev.sigev_value.sival_int = 0;
1470
    ev.sigev_notify = SIGEV_SIGNAL;
1471
    ev.sigev_signo = SIGALRM;
1472

    
1473
    if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1474
        perror("timer_create");
1475

    
1476
        /* disable dynticks */
1477
        fprintf(stderr, "Dynamic Ticks disabled\n");
1478

    
1479
        return -1;
1480
    }
1481

    
1482
    t->priv = (void *)host_timer;
1483

    
1484
    return 0;
1485
}
1486

    
1487
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1488
{
1489
    timer_t host_timer = (timer_t)t->priv;
1490

    
1491
    timer_delete(host_timer);
1492
}
1493

    
1494
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1495
{
1496
    timer_t host_timer = (timer_t)t->priv;
1497
    struct itimerspec timeout;
1498
    int64_t nearest_delta_us = INT64_MAX;
1499
    int64_t current_us;
1500

    
1501
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1502
                !active_timers[QEMU_TIMER_VIRTUAL])
1503
        return;
1504

    
1505
    nearest_delta_us = qemu_next_deadline_dyntick();
1506

    
1507
    /* check whether a timer is already running */
1508
    if (timer_gettime(host_timer, &timeout)) {
1509
        perror("gettime");
1510
        fprintf(stderr, "Internal timer error: aborting\n");
1511
        exit(1);
1512
    }
1513
    current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1514
    if (current_us && current_us <= nearest_delta_us)
1515
        return;
1516

    
1517
    timeout.it_interval.tv_sec = 0;
1518
    timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1519
    timeout.it_value.tv_sec =  nearest_delta_us / 1000000;
1520
    timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1521
    if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1522
        perror("settime");
1523
        fprintf(stderr, "Internal timer error: aborting\n");
1524
        exit(1);
1525
    }
1526
}
1527

    
1528
#endif /* defined(__linux__) */
1529

    
1530
static int unix_start_timer(struct qemu_alarm_timer *t)
1531
{
1532
    struct sigaction act;
1533
    struct itimerval itv;
1534
    int err;
1535

    
1536
    /* timer signal */
1537
    sigfillset(&act.sa_mask);
1538
    act.sa_flags = 0;
1539
    act.sa_handler = host_alarm_handler;
1540

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

    
1543
    itv.it_interval.tv_sec = 0;
1544
    /* for i386 kernel 2.6 to get 1 ms */
1545
    itv.it_interval.tv_usec = 999;
1546
    itv.it_value.tv_sec = 0;
1547
    itv.it_value.tv_usec = 10 * 1000;
1548

    
1549
    err = setitimer(ITIMER_REAL, &itv, NULL);
1550
    if (err)
1551
        return -1;
1552

    
1553
    return 0;
1554
}
1555

    
1556
static void unix_stop_timer(struct qemu_alarm_timer *t)
1557
{
1558
    struct itimerval itv;
1559

    
1560
    memset(&itv, 0, sizeof(itv));
1561
    setitimer(ITIMER_REAL, &itv, NULL);
1562
}
1563

    
1564
#endif /* !defined(_WIN32) */
1565

    
1566
#ifdef _WIN32
1567

    
1568
static int win32_start_timer(struct qemu_alarm_timer *t)
1569
{
1570
    TIMECAPS tc;
1571
    struct qemu_alarm_win32 *data = t->priv;
1572
    UINT flags;
1573

    
1574
    data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1575
    if (!data->host_alarm) {
1576
        perror("Failed CreateEvent");
1577
        return -1;
1578
    }
1579

    
1580
    memset(&tc, 0, sizeof(tc));
1581
    timeGetDevCaps(&tc, sizeof(tc));
1582

    
1583
    if (data->period < tc.wPeriodMin)
1584
        data->period = tc.wPeriodMin;
1585

    
1586
    timeBeginPeriod(data->period);
1587

    
1588
    flags = TIME_CALLBACK_FUNCTION;
1589
    if (alarm_has_dynticks(t))
1590
        flags |= TIME_ONESHOT;
1591
    else
1592
        flags |= TIME_PERIODIC;
1593

    
1594
    data->timerId = timeSetEvent(1,         // interval (ms)
1595
                        data->period,       // resolution
1596
                        host_alarm_handler, // function
1597
                        (DWORD)t,           // parameter
1598
                        flags);
1599

    
1600
    if (!data->timerId) {
1601
        perror("Failed to initialize win32 alarm timer");
1602

    
1603
        timeEndPeriod(data->period);
1604
        CloseHandle(data->host_alarm);
1605
        return -1;
1606
    }
1607

    
1608
    qemu_add_wait_object(data->host_alarm, NULL, NULL);
1609

    
1610
    return 0;
1611
}
1612

    
1613
static void win32_stop_timer(struct qemu_alarm_timer *t)
1614
{
1615
    struct qemu_alarm_win32 *data = t->priv;
1616

    
1617
    timeKillEvent(data->timerId);
1618
    timeEndPeriod(data->period);
1619

    
1620
    CloseHandle(data->host_alarm);
1621
}
1622

    
1623
static void win32_rearm_timer(struct qemu_alarm_timer *t)
1624
{
1625
    struct qemu_alarm_win32 *data = t->priv;
1626
    uint64_t nearest_delta_us;
1627

    
1628
    if (!active_timers[QEMU_TIMER_REALTIME] &&
1629
                !active_timers[QEMU_TIMER_VIRTUAL])
1630
        return;
1631

    
1632
    nearest_delta_us = qemu_next_deadline_dyntick();
1633
    nearest_delta_us /= 1000;
1634

    
1635
    timeKillEvent(data->timerId);
1636

    
1637
    data->timerId = timeSetEvent(1,
1638
                        data->period,
1639
                        host_alarm_handler,
1640
                        (DWORD)t,
1641
                        TIME_ONESHOT | TIME_PERIODIC);
1642

    
1643
    if (!data->timerId) {
1644
        perror("Failed to re-arm win32 alarm timer");
1645

    
1646
        timeEndPeriod(data->period);
1647
        CloseHandle(data->host_alarm);
1648
        exit(1);
1649
    }
1650
}
1651

    
1652
#endif /* _WIN32 */
1653

    
1654
static void init_timer_alarm(void)
1655
{
1656
    struct qemu_alarm_timer *t;
1657
    int i, err = -1;
1658

    
1659
    for (i = 0; alarm_timers[i].name; i++) {
1660
        t = &alarm_timers[i];
1661

    
1662
        err = t->start(t);
1663
        if (!err)
1664
            break;
1665
    }
1666

    
1667
    if (err) {
1668
        fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1669
        fprintf(stderr, "Terminating\n");
1670
        exit(1);
1671
    }
1672

    
1673
    alarm_timer = t;
1674
}
1675

    
1676
static void quit_timers(void)
1677
{
1678
    alarm_timer->stop(alarm_timer);
1679
    alarm_timer = NULL;
1680
}
1681

    
1682
/***********************************************************/
1683
/* host time/date access */
1684
void qemu_get_timedate(struct tm *tm, int offset)
1685
{
1686
    time_t ti;
1687
    struct tm *ret;
1688

    
1689
    time(&ti);
1690
    ti += offset;
1691
    if (rtc_date_offset == -1) {
1692
        if (rtc_utc)
1693
            ret = gmtime(&ti);
1694
        else
1695
            ret = localtime(&ti);
1696
    } else {
1697
        ti -= rtc_date_offset;
1698
        ret = gmtime(&ti);
1699
    }
1700

    
1701
    memcpy(tm, ret, sizeof(struct tm));
1702
}
1703

    
1704
int qemu_timedate_diff(struct tm *tm)
1705
{
1706
    time_t seconds;
1707

    
1708
    if (rtc_date_offset == -1)
1709
        if (rtc_utc)
1710
            seconds = mktimegm(tm);
1711
        else
1712
            seconds = mktime(tm);
1713
    else
1714
        seconds = mktimegm(tm) + rtc_date_offset;
1715

    
1716
    return seconds - time(NULL);
1717
}
1718

    
1719
/***********************************************************/
1720
/* character device */
1721

    
1722
static void qemu_chr_event(CharDriverState *s, int event)
1723
{
1724
    if (!s->chr_event)
1725
        return;
1726
    s->chr_event(s->handler_opaque, event);
1727
}
1728

    
1729
static void qemu_chr_reset_bh(void *opaque)
1730
{
1731
    CharDriverState *s = opaque;
1732
    qemu_chr_event(s, CHR_EVENT_RESET);
1733
    qemu_bh_delete(s->bh);
1734
    s->bh = NULL;
1735
}
1736

    
1737
void qemu_chr_reset(CharDriverState *s)
1738
{
1739
    if (s->bh == NULL) {
1740
        s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1741
        qemu_bh_schedule(s->bh);
1742
    }
1743
}
1744

    
1745
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1746
{
1747
    return s->chr_write(s, buf, len);
1748
}
1749

    
1750
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1751
{
1752
    if (!s->chr_ioctl)
1753
        return -ENOTSUP;
1754
    return s->chr_ioctl(s, cmd, arg);
1755
}
1756

    
1757
int qemu_chr_can_read(CharDriverState *s)
1758
{
1759
    if (!s->chr_can_read)
1760
        return 0;
1761
    return s->chr_can_read(s->handler_opaque);
1762
}
1763

    
1764
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1765
{
1766
    s->chr_read(s->handler_opaque, buf, len);
1767
}
1768

    
1769
void qemu_chr_accept_input(CharDriverState *s)
1770
{
1771
    if (s->chr_accept_input)
1772
        s->chr_accept_input(s);
1773
}
1774

    
1775
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1776
{
1777
    char buf[4096];
1778
    va_list ap;
1779
    va_start(ap, fmt);
1780
    vsnprintf(buf, sizeof(buf), fmt, ap);
1781
    qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1782
    va_end(ap);
1783
}
1784

    
1785
void qemu_chr_send_event(CharDriverState *s, int event)
1786
{
1787
    if (s->chr_send_event)
1788
        s->chr_send_event(s, event);
1789
}
1790

    
1791
void qemu_chr_add_handlers(CharDriverState *s,
1792
                           IOCanRWHandler *fd_can_read,
1793
                           IOReadHandler *fd_read,
1794
                           IOEventHandler *fd_event,
1795
                           void *opaque)
1796
{
1797
    s->chr_can_read = fd_can_read;
1798
    s->chr_read = fd_read;
1799
    s->chr_event = fd_event;
1800
    s->handler_opaque = opaque;
1801
    if (s->chr_update_read_handler)
1802
        s->chr_update_read_handler(s);
1803
}
1804

    
1805
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1806
{
1807
    return len;
1808
}
1809

    
1810
static CharDriverState *qemu_chr_open_null(void)
1811
{
1812
    CharDriverState *chr;
1813

    
1814
    chr = qemu_mallocz(sizeof(CharDriverState));
1815
    if (!chr)
1816
        return NULL;
1817
    chr->chr_write = null_chr_write;
1818
    return chr;
1819
}
1820

    
1821
/* MUX driver for serial I/O splitting */
1822
static int term_timestamps;
1823
static int64_t term_timestamps_start;
1824
#define MAX_MUX 4
1825
#define MUX_BUFFER_SIZE 32        /* Must be a power of 2.  */
1826
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1827
typedef struct {
1828
    IOCanRWHandler *chr_can_read[MAX_MUX];
1829
    IOReadHandler *chr_read[MAX_MUX];
1830
    IOEventHandler *chr_event[MAX_MUX];
1831
    void *ext_opaque[MAX_MUX];
1832
    CharDriverState *drv;
1833
    unsigned char buffer[MUX_BUFFER_SIZE];
1834
    int prod;
1835
    int cons;
1836
    int mux_cnt;
1837
    int term_got_escape;
1838
    int max_size;
1839
} MuxDriver;
1840

    
1841

    
1842
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1843
{
1844
    MuxDriver *d = chr->opaque;
1845
    int ret;
1846
    if (!term_timestamps) {
1847
        ret = d->drv->chr_write(d->drv, buf, len);
1848
    } else {
1849
        int i;
1850

    
1851
        ret = 0;
1852
        for(i = 0; i < len; i++) {
1853
            ret += d->drv->chr_write(d->drv, buf+i, 1);
1854
            if (buf[i] == '\n') {
1855
                char buf1[64];
1856
                int64_t ti;
1857
                int secs;
1858

    
1859
                ti = get_clock();
1860
                if (term_timestamps_start == -1)
1861
                    term_timestamps_start = ti;
1862
                ti -= term_timestamps_start;
1863
                secs = ti / 1000000000;
1864
                snprintf(buf1, sizeof(buf1),
1865
                         "[%02d:%02d:%02d.%03d] ",
1866
                         secs / 3600,
1867
                         (secs / 60) % 60,
1868
                         secs % 60,
1869
                         (int)((ti / 1000000) % 1000));
1870
                d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1871
            }
1872
        }
1873
    }
1874
    return ret;
1875
}
1876

    
1877
static char *mux_help[] = {
1878
    "% h    print this help\n\r",
1879
    "% x    exit emulator\n\r",
1880
    "% s    save disk data back to file (if -snapshot)\n\r",
1881
    "% t    toggle console timestamps\n\r"
1882
    "% b    send break (magic sysrq)\n\r",
1883
    "% c    switch between console and monitor\n\r",
1884
    "% %  sends %\n\r",
1885
    NULL
1886
};
1887

    
1888
static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1889
static void mux_print_help(CharDriverState *chr)
1890
{
1891
    int i, j;
1892
    char ebuf[15] = "Escape-Char";
1893
    char cbuf[50] = "\n\r";
1894

    
1895
    if (term_escape_char > 0 && term_escape_char < 26) {
1896
        sprintf(cbuf,"\n\r");
1897
        sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1898
    } else {
1899
        sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1900
            term_escape_char);
1901
    }
1902
    chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1903
    for (i = 0; mux_help[i] != NULL; i++) {
1904
        for (j=0; mux_help[i][j] != '\0'; j++) {
1905
            if (mux_help[i][j] == '%')
1906
                chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1907
            else
1908
                chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1909
        }
1910
    }
1911
}
1912

    
1913
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1914
{
1915
    if (d->term_got_escape) {
1916
        d->term_got_escape = 0;
1917
        if (ch == term_escape_char)
1918
            goto send_char;
1919
        switch(ch) {
1920
        case '?':
1921
        case 'h':
1922
            mux_print_help(chr);
1923
            break;
1924
        case 'x':
1925
            {
1926
                 char *term =  "QEMU: Terminated\n\r";
1927
                 chr->chr_write(chr,(uint8_t *)term,strlen(term));
1928
                 exit(0);
1929
                 break;
1930
            }
1931
        case 's':
1932
            {
1933
                int i;
1934
                for (i = 0; i < nb_drives; i++) {
1935
                        bdrv_commit(drives_table[i].bdrv);
1936
                }
1937
            }
1938
            break;
1939
        case 'b':
1940
            qemu_chr_event(chr, CHR_EVENT_BREAK);
1941
            break;
1942
        case 'c':
1943
            /* Switch to the next registered device */
1944
            chr->focus++;
1945
            if (chr->focus >= d->mux_cnt)
1946
                chr->focus = 0;
1947
            break;
1948
       case 't':
1949
           term_timestamps = !term_timestamps;
1950
           term_timestamps_start = -1;
1951
           break;
1952
        }
1953
    } else if (ch == term_escape_char) {
1954
        d->term_got_escape = 1;
1955
    } else {
1956
    send_char:
1957
        return 1;
1958
    }
1959
    return 0;
1960
}
1961

    
1962
static void mux_chr_accept_input(CharDriverState *chr)
1963
{
1964
    int m = chr->focus;
1965
    MuxDriver *d = chr->opaque;
1966

    
1967
    while (d->prod != d->cons &&
1968
           d->chr_can_read[m] &&
1969
           d->chr_can_read[m](d->ext_opaque[m])) {
1970
        d->chr_read[m](d->ext_opaque[m],
1971
                       &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
1972
    }
1973
}
1974

    
1975
static int mux_chr_can_read(void *opaque)
1976
{
1977
    CharDriverState *chr = opaque;
1978
    MuxDriver *d = chr->opaque;
1979

    
1980
    if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
1981
        return 1;
1982
    if (d->chr_can_read[chr->focus])
1983
        return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1984
    return 0;
1985
}
1986

    
1987
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1988
{
1989
    CharDriverState *chr = opaque;
1990
    MuxDriver *d = chr->opaque;
1991
    int m = chr->focus;
1992
    int i;
1993

    
1994
    mux_chr_accept_input (opaque);
1995

    
1996
    for(i = 0; i < size; i++)
1997
        if (mux_proc_byte(chr, d, buf[i])) {
1998
            if (d->prod == d->cons &&
1999
                d->chr_can_read[m] &&
2000
                d->chr_can_read[m](d->ext_opaque[m]))
2001
                d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
2002
            else
2003
                d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
2004
        }
2005
}
2006

    
2007
static void mux_chr_event(void *opaque, int event)
2008
{
2009
    CharDriverState *chr = opaque;
2010
    MuxDriver *d = chr->opaque;
2011
    int i;
2012

    
2013
    /* Send the event to all registered listeners */
2014
    for (i = 0; i < d->mux_cnt; i++)
2015
        if (d->chr_event[i])
2016
            d->chr_event[i](d->ext_opaque[i], event);
2017
}
2018

    
2019
static void mux_chr_update_read_handler(CharDriverState *chr)
2020
{
2021
    MuxDriver *d = chr->opaque;
2022

    
2023
    if (d->mux_cnt >= MAX_MUX) {
2024
        fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
2025
        return;
2026
    }
2027
    d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
2028
    d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
2029
    d->chr_read[d->mux_cnt] = chr->chr_read;
2030
    d->chr_event[d->mux_cnt] = chr->chr_event;
2031
    /* Fix up the real driver with mux routines */
2032
    if (d->mux_cnt == 0) {
2033
        qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
2034
                              mux_chr_event, chr);
2035
    }
2036
    chr->focus = d->mux_cnt;
2037
    d->mux_cnt++;
2038
}
2039

    
2040
static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
2041
{
2042
    CharDriverState *chr;
2043
    MuxDriver *d;
2044

    
2045
    chr = qemu_mallocz(sizeof(CharDriverState));
2046
    if (!chr)
2047
        return NULL;
2048
    d = qemu_mallocz(sizeof(MuxDriver));
2049
    if (!d) {
2050
        free(chr);
2051
        return NULL;
2052
    }
2053

    
2054
    chr->opaque = d;
2055
    d->drv = drv;
2056
    chr->focus = -1;
2057
    chr->chr_write = mux_chr_write;
2058
    chr->chr_update_read_handler = mux_chr_update_read_handler;
2059
    chr->chr_accept_input = mux_chr_accept_input;
2060
    return chr;
2061
}
2062

    
2063

    
2064
#ifdef _WIN32
2065

    
2066
static void socket_cleanup(void)
2067
{
2068
    WSACleanup();
2069
}
2070

    
2071
static int socket_init(void)
2072
{
2073
    WSADATA Data;
2074
    int ret, err;
2075

    
2076
    ret = WSAStartup(MAKEWORD(2,2), &Data);
2077
    if (ret != 0) {
2078
        err = WSAGetLastError();
2079
        fprintf(stderr, "WSAStartup: %d\n", err);
2080
        return -1;
2081
    }
2082
    atexit(socket_cleanup);
2083
    return 0;
2084
}
2085

    
2086
static int send_all(int fd, const uint8_t *buf, int len1)
2087
{
2088
    int ret, len;
2089

    
2090
    len = len1;
2091
    while (len > 0) {
2092
        ret = send(fd, buf, len, 0);
2093
        if (ret < 0) {
2094
            int errno;
2095
            errno = WSAGetLastError();
2096
            if (errno != WSAEWOULDBLOCK) {
2097
                return -1;
2098
            }
2099
        } else if (ret == 0) {
2100
            break;
2101
        } else {
2102
            buf += ret;
2103
            len -= ret;
2104
        }
2105
    }
2106
    return len1 - len;
2107
}
2108

    
2109
void socket_set_nonblock(int fd)
2110
{
2111
    unsigned long opt = 1;
2112
    ioctlsocket(fd, FIONBIO, &opt);
2113
}
2114

    
2115
#else
2116

    
2117
static int unix_write(int fd, const uint8_t *buf, int len1)
2118
{
2119
    int ret, len;
2120

    
2121
    len = len1;
2122
    while (len > 0) {
2123
        ret = write(fd, buf, len);
2124
        if (ret < 0) {
2125
            if (errno != EINTR && errno != EAGAIN)
2126
                return -1;
2127
        } else if (ret == 0) {
2128
            break;
2129
        } else {
2130
            buf += ret;
2131
            len -= ret;
2132
        }
2133
    }
2134
    return len1 - len;
2135
}
2136

    
2137
static inline int send_all(int fd, const uint8_t *buf, int len1)
2138
{
2139
    return unix_write(fd, buf, len1);
2140
}
2141

    
2142
void socket_set_nonblock(int fd)
2143
{
2144
    fcntl(fd, F_SETFL, O_NONBLOCK);
2145
}
2146
#endif /* !_WIN32 */
2147

    
2148
#ifndef _WIN32
2149

    
2150
typedef struct {
2151
    int fd_in, fd_out;
2152
    int max_size;
2153
} FDCharDriver;
2154

    
2155
#define STDIO_MAX_CLIENTS 1
2156
static int stdio_nb_clients = 0;
2157

    
2158
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2159
{
2160
    FDCharDriver *s = chr->opaque;
2161
    return unix_write(s->fd_out, buf, len);
2162
}
2163

    
2164
static int fd_chr_read_poll(void *opaque)
2165
{
2166
    CharDriverState *chr = opaque;
2167
    FDCharDriver *s = chr->opaque;
2168

    
2169
    s->max_size = qemu_chr_can_read(chr);
2170
    return s->max_size;
2171
}
2172

    
2173
static void fd_chr_read(void *opaque)
2174
{
2175
    CharDriverState *chr = opaque;
2176
    FDCharDriver *s = chr->opaque;
2177
    int size, len;
2178
    uint8_t buf[1024];
2179

    
2180
    len = sizeof(buf);
2181
    if (len > s->max_size)
2182
        len = s->max_size;
2183
    if (len == 0)
2184
        return;
2185
    size = read(s->fd_in, buf, len);
2186
    if (size == 0) {
2187
        /* FD has been closed. Remove it from the active list.  */
2188
        qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2189
        return;
2190
    }
2191
    if (size > 0) {
2192
        qemu_chr_read(chr, buf, size);
2193
    }
2194
}
2195

    
2196
static void fd_chr_update_read_handler(CharDriverState *chr)
2197
{
2198
    FDCharDriver *s = chr->opaque;
2199

    
2200
    if (s->fd_in >= 0) {
2201
        if (nographic && s->fd_in == 0) {
2202
        } else {
2203
            qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2204
                                 fd_chr_read, NULL, chr);
2205
        }
2206
    }
2207
}
2208

    
2209
static void fd_chr_close(struct CharDriverState *chr)
2210
{
2211
    FDCharDriver *s = chr->opaque;
2212

    
2213
    if (s->fd_in >= 0) {
2214
        if (nographic && s->fd_in == 0) {
2215
        } else {
2216
            qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2217
        }
2218
    }
2219

    
2220
    qemu_free(s);
2221
}
2222

    
2223
/* open a character device to a unix fd */
2224
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2225
{
2226
    CharDriverState *chr;
2227
    FDCharDriver *s;
2228

    
2229
    chr = qemu_mallocz(sizeof(CharDriverState));
2230
    if (!chr)
2231
        return NULL;
2232
    s = qemu_mallocz(sizeof(FDCharDriver));
2233
    if (!s) {
2234
        free(chr);
2235
        return NULL;
2236
    }
2237
    s->fd_in = fd_in;
2238
    s->fd_out = fd_out;
2239
    chr->opaque = s;
2240
    chr->chr_write = fd_chr_write;
2241
    chr->chr_update_read_handler = fd_chr_update_read_handler;
2242
    chr->chr_close = fd_chr_close;
2243

    
2244
    qemu_chr_reset(chr);
2245

    
2246
    return chr;
2247
}
2248

    
2249
static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2250
{
2251
    int fd_out;
2252

    
2253
    TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2254
    if (fd_out < 0)
2255
        return NULL;
2256
    return qemu_chr_open_fd(-1, fd_out);
2257
}
2258

    
2259
static CharDriverState *qemu_chr_open_pipe(const char *filename)
2260
{
2261
    int fd_in, fd_out;
2262
    char filename_in[256], filename_out[256];
2263

    
2264
    snprintf(filename_in, 256, "%s.in", filename);
2265
    snprintf(filename_out, 256, "%s.out", filename);
2266
    TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2267
    TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2268
    if (fd_in < 0 || fd_out < 0) {
2269
        if (fd_in >= 0)
2270
            close(fd_in);
2271
        if (fd_out >= 0)
2272
            close(fd_out);
2273
        TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2274
        if (fd_in < 0)
2275
            return NULL;
2276
    }
2277
    return qemu_chr_open_fd(fd_in, fd_out);
2278
}
2279

    
2280

    
2281
/* for STDIO, we handle the case where several clients use it
2282
   (nographic mode) */
2283

    
2284
#define TERM_FIFO_MAX_SIZE 1
2285

    
2286
static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2287
static int term_fifo_size;
2288

    
2289
static int stdio_read_poll(void *opaque)
2290
{
2291
    CharDriverState *chr = opaque;
2292

    
2293
    /* try to flush the queue if needed */
2294
    if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2295
        qemu_chr_read(chr, term_fifo, 1);
2296
        term_fifo_size = 0;
2297
    }
2298
    /* see if we can absorb more chars */
2299
    if (term_fifo_size == 0)
2300
        return 1;
2301
    else
2302
        return 0;
2303
}
2304

    
2305
static void stdio_read(void *opaque)
2306
{
2307
    int size;
2308
    uint8_t buf[1];
2309
    CharDriverState *chr = opaque;
2310

    
2311
    size = read(0, buf, 1);
2312
    if (size == 0) {
2313
        /* stdin has been closed. Remove it from the active list.  */
2314
        qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2315
        return;
2316
    }
2317
    if (size > 0) {
2318
        if (qemu_chr_can_read(chr) > 0) {
2319
            qemu_chr_read(chr, buf, 1);
2320
        } else if (term_fifo_size == 0) {
2321
            term_fifo[term_fifo_size++] = buf[0];
2322
        }
2323
    }
2324
}
2325

    
2326
/* init terminal so that we can grab keys */
2327
static struct termios oldtty;
2328
static int old_fd0_flags;
2329
static int term_atexit_done;
2330

    
2331
static void term_exit(void)
2332
{
2333
    tcsetattr (0, TCSANOW, &oldtty);
2334
    fcntl(0, F_SETFL, old_fd0_flags);
2335
}
2336

    
2337
static void term_init(void)
2338
{
2339
    struct termios tty;
2340

    
2341
    tcgetattr (0, &tty);
2342
    oldtty = tty;
2343
    old_fd0_flags = fcntl(0, F_GETFL);
2344

    
2345
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2346
                          |INLCR|IGNCR|ICRNL|IXON);
2347
    tty.c_oflag |= OPOST;
2348
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2349
    /* if graphical mode, we allow Ctrl-C handling */
2350
    if (nographic)
2351
        tty.c_lflag &= ~ISIG;
2352
    tty.c_cflag &= ~(CSIZE|PARENB);
2353
    tty.c_cflag |= CS8;
2354
    tty.c_cc[VMIN] = 1;
2355
    tty.c_cc[VTIME] = 0;
2356

    
2357
    tcsetattr (0, TCSANOW, &tty);
2358

    
2359
    if (!term_atexit_done++)
2360
        atexit(term_exit);
2361

    
2362
    fcntl(0, F_SETFL, O_NONBLOCK);
2363
}
2364

    
2365
static void qemu_chr_close_stdio(struct CharDriverState *chr)
2366
{
2367
    term_exit();
2368
    stdio_nb_clients--;
2369
    qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2370
    fd_chr_close(chr);
2371
}
2372

    
2373
static CharDriverState *qemu_chr_open_stdio(void)
2374
{
2375
    CharDriverState *chr;
2376

    
2377
    if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2378
        return NULL;
2379
    chr = qemu_chr_open_fd(0, 1);
2380
    chr->chr_close = qemu_chr_close_stdio;
2381
    qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2382
    stdio_nb_clients++;
2383
    term_init();
2384

    
2385
    return chr;
2386
}
2387

    
2388
#ifdef __sun__
2389
/* Once Solaris has openpty(), this is going to be removed. */
2390
int openpty(int *amaster, int *aslave, char *name,
2391
            struct termios *termp, struct winsize *winp)
2392
{
2393
        const char *slave;
2394
        int mfd = -1, sfd = -1;
2395

    
2396
        *amaster = *aslave = -1;
2397

    
2398
        mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
2399
        if (mfd < 0)
2400
                goto err;
2401

    
2402
        if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
2403
                goto err;
2404

    
2405
        if ((slave = ptsname(mfd)) == NULL)
2406
                goto err;
2407

    
2408
        if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
2409
                goto err;
2410

    
2411
        if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
2412
            (termp != NULL && tcgetattr(sfd, termp) < 0))
2413
                goto err;
2414

    
2415
        if (amaster)
2416
                *amaster = mfd;
2417
        if (aslave)
2418
                *aslave = sfd;
2419
        if (winp)
2420
                ioctl(sfd, TIOCSWINSZ, winp);
2421

    
2422
        return 0;
2423

    
2424
err:
2425
        if (sfd != -1)
2426
                close(sfd);
2427
        close(mfd);
2428
        return -1;
2429
}
2430

    
2431
void cfmakeraw (struct termios *termios_p)
2432
{
2433
        termios_p->c_iflag &=
2434
                ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2435
        termios_p->c_oflag &= ~OPOST;
2436
        termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2437
        termios_p->c_cflag &= ~(CSIZE|PARENB);
2438
        termios_p->c_cflag |= CS8;
2439

    
2440
        termios_p->c_cc[VMIN] = 0;
2441
        termios_p->c_cc[VTIME] = 0;
2442
}
2443
#endif
2444

    
2445
#if defined(__linux__) || defined(__sun__)
2446
static CharDriverState *qemu_chr_open_pty(void)
2447
{
2448
    struct termios tty;
2449
    int master_fd, slave_fd;
2450

    
2451
    if (openpty(&master_fd, &slave_fd, NULL, NULL, NULL) < 0) {
2452
        return NULL;
2453
    }
2454

    
2455
    /* Set raw attributes on the pty. */
2456
    cfmakeraw(&tty);
2457
    tcsetattr(slave_fd, TCSAFLUSH, &tty);
2458

    
2459
    fprintf(stderr, "char device redirected to %s\n", ptsname(master_fd));
2460
    return qemu_chr_open_fd(master_fd, master_fd);
2461
}
2462

    
2463
static void tty_serial_init(int fd, int speed,
2464
                            int parity, int data_bits, int stop_bits)
2465
{
2466
    struct termios tty;
2467
    speed_t spd;
2468

    
2469
#if 0
2470
    printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2471
           speed, parity, data_bits, stop_bits);
2472
#endif
2473
    tcgetattr (fd, &tty);
2474

    
2475
#define MARGIN 1.1
2476
    if (speed <= 50 * MARGIN)
2477
        spd = B50;
2478
    else if (speed <= 75 * MARGIN)
2479
        spd = B75;
2480
    else if (speed <= 300 * MARGIN)
2481
        spd = B300;
2482
    else if (speed <= 600 * MARGIN)
2483
        spd = B600;
2484
    else if (speed <= 1200 * MARGIN)
2485
        spd = B1200;
2486
    else if (speed <= 2400 * MARGIN)
2487
        spd = B2400;
2488
    else if (speed <= 4800 * MARGIN)
2489
        spd = B4800;
2490
    else if (speed <= 9600 * MARGIN)
2491
        spd = B9600;
2492
    else if (speed <= 19200 * MARGIN)
2493
        spd = B19200;
2494
    else if (speed <= 38400 * MARGIN)
2495
        spd = B38400;
2496
    else if (speed <= 57600 * MARGIN)
2497
        spd = B57600;
2498
    else if (speed <= 115200 * MARGIN)
2499
        spd = B115200;
2500
    else
2501
        spd = B115200;
2502

    
2503
    cfsetispeed(&tty, spd);
2504
    cfsetospeed(&tty, spd);
2505

    
2506
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2507
                          |INLCR|IGNCR|ICRNL|IXON);
2508
    tty.c_oflag |= OPOST;
2509
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2510
    tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2511
    switch(data_bits) {
2512
    default:
2513
    case 8:
2514
        tty.c_cflag |= CS8;
2515
        break;
2516
    case 7:
2517
        tty.c_cflag |= CS7;
2518
        break;
2519
    case 6:
2520
        tty.c_cflag |= CS6;
2521
        break;
2522
    case 5:
2523
        tty.c_cflag |= CS5;
2524
        break;
2525
    }
2526
    switch(parity) {
2527
    default:
2528
    case 'N':
2529
        break;
2530
    case 'E':
2531
        tty.c_cflag |= PARENB;
2532
        break;
2533
    case 'O':
2534
        tty.c_cflag |= PARENB | PARODD;
2535
        break;
2536
    }
2537
    if (stop_bits == 2)
2538
        tty.c_cflag |= CSTOPB;
2539

    
2540
    tcsetattr (fd, TCSANOW, &tty);
2541
}
2542

    
2543
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2544
{
2545
    FDCharDriver *s = chr->opaque;
2546

    
2547
    switch(cmd) {
2548
    case CHR_IOCTL_SERIAL_SET_PARAMS:
2549
        {
2550
            QEMUSerialSetParams *ssp = arg;
2551
            tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2552
                            ssp->data_bits, ssp->stop_bits);
2553
        }
2554
        break;
2555
    case CHR_IOCTL_SERIAL_SET_BREAK:
2556
        {
2557
            int enable = *(int *)arg;
2558
            if (enable)
2559
                tcsendbreak(s->fd_in, 1);
2560
        }
2561
        break;
2562
    default:
2563
        return -ENOTSUP;
2564
    }
2565
    return 0;
2566
}
2567

    
2568
static CharDriverState *qemu_chr_open_tty(const char *filename)
2569
{
2570
    CharDriverState *chr;
2571
    int fd;
2572

    
2573
    TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2574
    fcntl(fd, F_SETFL, O_NONBLOCK);
2575
    tty_serial_init(fd, 115200, 'N', 8, 1);
2576
    chr = qemu_chr_open_fd(fd, fd);
2577
    if (!chr) {
2578
        close(fd);
2579
        return NULL;
2580
    }
2581
    chr->chr_ioctl = tty_serial_ioctl;
2582
    qemu_chr_reset(chr);
2583
    return chr;
2584
}
2585
#else  /* ! __linux__ && ! __sun__ */
2586
static CharDriverState *qemu_chr_open_pty(void)
2587
{
2588
    return NULL;
2589
}
2590
#endif /* __linux__ || __sun__ */
2591

    
2592
#if defined(__linux__)
2593
typedef struct {
2594
    int fd;
2595
    int mode;
2596
} ParallelCharDriver;
2597

    
2598
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2599
{
2600
    if (s->mode != mode) {
2601
        int m = mode;
2602
        if (ioctl(s->fd, PPSETMODE, &m) < 0)
2603
            return 0;
2604
        s->mode = mode;
2605
    }
2606
    return 1;
2607
}
2608

    
2609
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2610
{
2611
    ParallelCharDriver *drv = chr->opaque;
2612
    int fd = drv->fd;
2613
    uint8_t b;
2614

    
2615
    switch(cmd) {
2616
    case CHR_IOCTL_PP_READ_DATA:
2617
        if (ioctl(fd, PPRDATA, &b) < 0)
2618
            return -ENOTSUP;
2619
        *(uint8_t *)arg = b;
2620
        break;
2621
    case CHR_IOCTL_PP_WRITE_DATA:
2622
        b = *(uint8_t *)arg;
2623
        if (ioctl(fd, PPWDATA, &b) < 0)
2624
            return -ENOTSUP;
2625
        break;
2626
    case CHR_IOCTL_PP_READ_CONTROL:
2627
        if (ioctl(fd, PPRCONTROL, &b) < 0)
2628
            return -ENOTSUP;
2629
        /* Linux gives only the lowest bits, and no way to know data
2630
           direction! For better compatibility set the fixed upper
2631
           bits. */
2632
        *(uint8_t *)arg = b | 0xc0;
2633
        break;
2634
    case CHR_IOCTL_PP_WRITE_CONTROL:
2635
        b = *(uint8_t *)arg;
2636
        if (ioctl(fd, PPWCONTROL, &b) < 0)
2637
            return -ENOTSUP;
2638
        break;
2639
    case CHR_IOCTL_PP_READ_STATUS:
2640
        if (ioctl(fd, PPRSTATUS, &b) < 0)
2641
            return -ENOTSUP;
2642
        *(uint8_t *)arg = b;
2643
        break;
2644
    case CHR_IOCTL_PP_EPP_READ_ADDR:
2645
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2646
            struct ParallelIOArg *parg = arg;
2647
            int n = read(fd, parg->buffer, parg->count);
2648
            if (n != parg->count) {
2649
                return -EIO;
2650
            }
2651
        }
2652
        break;
2653
    case CHR_IOCTL_PP_EPP_READ:
2654
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2655
            struct ParallelIOArg *parg = arg;
2656
            int n = read(fd, parg->buffer, parg->count);
2657
            if (n != parg->count) {
2658
                return -EIO;
2659
            }
2660
        }
2661
        break;
2662
    case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2663
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2664
            struct ParallelIOArg *parg = arg;
2665
            int n = write(fd, parg->buffer, parg->count);
2666
            if (n != parg->count) {
2667
                return -EIO;
2668
            }
2669
        }
2670
        break;
2671
    case CHR_IOCTL_PP_EPP_WRITE:
2672
        if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2673
            struct ParallelIOArg *parg = arg;
2674
            int n = write(fd, parg->buffer, parg->count);
2675
            if (n != parg->count) {
2676
                return -EIO;
2677
            }
2678
        }
2679
        break;
2680
    default:
2681
        return -ENOTSUP;
2682
    }
2683
    return 0;
2684
}
2685

    
2686
static void pp_close(CharDriverState *chr)
2687
{
2688
    ParallelCharDriver *drv = chr->opaque;
2689
    int fd = drv->fd;
2690

    
2691
    pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2692
    ioctl(fd, PPRELEASE);
2693
    close(fd);
2694
    qemu_free(drv);
2695
}
2696

    
2697
static CharDriverState *qemu_chr_open_pp(const char *filename)
2698
{
2699
    CharDriverState *chr;
2700
    ParallelCharDriver *drv;
2701
    int fd;
2702

    
2703
    TFR(fd = open(filename, O_RDWR));
2704
    if (fd < 0)
2705
        return NULL;
2706

    
2707
    if (ioctl(fd, PPCLAIM) < 0) {
2708
        close(fd);
2709
        return NULL;
2710
    }
2711

    
2712
    drv = qemu_mallocz(sizeof(ParallelCharDriver));
2713
    if (!drv) {
2714
        close(fd);
2715
        return NULL;
2716
    }
2717
    drv->fd = fd;
2718
    drv->mode = IEEE1284_MODE_COMPAT;
2719

    
2720
    chr = qemu_mallocz(sizeof(CharDriverState));
2721
    if (!chr) {
2722
        qemu_free(drv);
2723
        close(fd);
2724
        return NULL;
2725
    }
2726
    chr->chr_write = null_chr_write;
2727
    chr->chr_ioctl = pp_ioctl;
2728
    chr->chr_close = pp_close;
2729
    chr->opaque = drv;
2730

    
2731
    qemu_chr_reset(chr);
2732

    
2733
    return chr;
2734
}
2735
#endif /* __linux__ */
2736

    
2737
#else /* _WIN32 */
2738

    
2739
typedef struct {
2740
    int max_size;
2741
    HANDLE hcom, hrecv, hsend;
2742
    OVERLAPPED orecv, osend;
2743
    BOOL fpipe;
2744
    DWORD len;
2745
} WinCharState;
2746

    
2747
#define NSENDBUF 2048
2748
#define NRECVBUF 2048
2749
#define MAXCONNECT 1
2750
#define NTIMEOUT 5000
2751

    
2752
static int win_chr_poll(void *opaque);
2753
static int win_chr_pipe_poll(void *opaque);
2754

    
2755
static void win_chr_close(CharDriverState *chr)
2756
{
2757
    WinCharState *s = chr->opaque;
2758

    
2759
    if (s->hsend) {
2760
        CloseHandle(s->hsend);
2761
        s->hsend = NULL;
2762
    }
2763
    if (s->hrecv) {
2764
        CloseHandle(s->hrecv);
2765
        s->hrecv = NULL;
2766
    }
2767
    if (s->hcom) {
2768
        CloseHandle(s->hcom);
2769
        s->hcom = NULL;
2770
    }
2771
    if (s->fpipe)
2772
        qemu_del_polling_cb(win_chr_pipe_poll, chr);
2773
    else
2774
        qemu_del_polling_cb(win_chr_poll, chr);
2775
}
2776

    
2777
static int win_chr_init(CharDriverState *chr, const char *filename)
2778
{
2779
    WinCharState *s = chr->opaque;
2780
    COMMCONFIG comcfg;
2781
    COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2782
    COMSTAT comstat;
2783
    DWORD size;
2784
    DWORD err;
2785

    
2786
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2787
    if (!s->hsend) {
2788
        fprintf(stderr, "Failed CreateEvent\n");
2789
        goto fail;
2790
    }
2791
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2792
    if (!s->hrecv) {
2793
        fprintf(stderr, "Failed CreateEvent\n");
2794
        goto fail;
2795
    }
2796

    
2797
    s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2798
                      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2799
    if (s->hcom == INVALID_HANDLE_VALUE) {
2800
        fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2801
        s->hcom = NULL;
2802
        goto fail;
2803
    }
2804

    
2805
    if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2806
        fprintf(stderr, "Failed SetupComm\n");
2807
        goto fail;
2808
    }
2809

    
2810
    ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2811
    size = sizeof(COMMCONFIG);
2812
    GetDefaultCommConfig(filename, &comcfg, &size);
2813
    comcfg.dcb.DCBlength = sizeof(DCB);
2814
    CommConfigDialog(filename, NULL, &comcfg);
2815

    
2816
    if (!SetCommState(s->hcom, &comcfg.dcb)) {
2817
        fprintf(stderr, "Failed SetCommState\n");
2818
        goto fail;
2819
    }
2820

    
2821
    if (!SetCommMask(s->hcom, EV_ERR)) {
2822
        fprintf(stderr, "Failed SetCommMask\n");
2823
        goto fail;
2824
    }
2825

    
2826
    cto.ReadIntervalTimeout = MAXDWORD;
2827
    if (!SetCommTimeouts(s->hcom, &cto)) {
2828
        fprintf(stderr, "Failed SetCommTimeouts\n");
2829
        goto fail;
2830
    }
2831

    
2832
    if (!ClearCommError(s->hcom, &err, &comstat)) {
2833
        fprintf(stderr, "Failed ClearCommError\n");
2834
        goto fail;
2835
    }
2836
    qemu_add_polling_cb(win_chr_poll, chr);
2837
    return 0;
2838

    
2839
 fail:
2840
    win_chr_close(chr);
2841
    return -1;
2842
}
2843

    
2844
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2845
{
2846
    WinCharState *s = chr->opaque;
2847
    DWORD len, ret, size, err;
2848

    
2849
    len = len1;
2850
    ZeroMemory(&s->osend, sizeof(s->osend));
2851
    s->osend.hEvent = s->hsend;
2852
    while (len > 0) {
2853
        if (s->hsend)
2854
            ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2855
        else
2856
            ret = WriteFile(s->hcom, buf, len, &size, NULL);
2857
        if (!ret) {
2858
            err = GetLastError();
2859
            if (err == ERROR_IO_PENDING) {
2860
                ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2861
                if (ret) {
2862
                    buf += size;
2863
                    len -= size;
2864
                } else {
2865
                    break;
2866
                }
2867
            } else {
2868
                break;
2869
            }
2870
        } else {
2871
            buf += size;
2872
            len -= size;
2873
        }
2874
    }
2875
    return len1 - len;
2876
}
2877

    
2878
static int win_chr_read_poll(CharDriverState *chr)
2879
{
2880
    WinCharState *s = chr->opaque;
2881

    
2882
    s->max_size = qemu_chr_can_read(chr);
2883
    return s->max_size;
2884
}
2885

    
2886
static void win_chr_readfile(CharDriverState *chr)
2887
{
2888
    WinCharState *s = chr->opaque;
2889
    int ret, err;
2890
    uint8_t buf[1024];
2891
    DWORD size;
2892

    
2893
    ZeroMemory(&s->orecv, sizeof(s->orecv));
2894
    s->orecv.hEvent = s->hrecv;
2895
    ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2896
    if (!ret) {
2897
        err = GetLastError();
2898
        if (err == ERROR_IO_PENDING) {
2899
            ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2900
        }
2901
    }
2902

    
2903
    if (size > 0) {
2904
        qemu_chr_read(chr, buf, size);
2905
    }
2906
}
2907

    
2908
static void win_chr_read(CharDriverState *chr)
2909
{
2910
    WinCharState *s = chr->opaque;
2911

    
2912
    if (s->len > s->max_size)
2913
        s->len = s->max_size;
2914
    if (s->len == 0)
2915
        return;
2916

    
2917
    win_chr_readfile(chr);
2918
}
2919

    
2920
static int win_chr_poll(void *opaque)
2921
{
2922
    CharDriverState *chr = opaque;
2923
    WinCharState *s = chr->opaque;
2924
    COMSTAT status;
2925
    DWORD comerr;
2926

    
2927
    ClearCommError(s->hcom, &comerr, &status);
2928
    if (status.cbInQue > 0) {
2929
        s->len = status.cbInQue;
2930
        win_chr_read_poll(chr);
2931
        win_chr_read(chr);
2932
        return 1;
2933
    }
2934
    return 0;
2935
}
2936

    
2937
static CharDriverState *qemu_chr_open_win(const char *filename)
2938
{
2939
    CharDriverState *chr;
2940
    WinCharState *s;
2941

    
2942
    chr = qemu_mallocz(sizeof(CharDriverState));
2943
    if (!chr)
2944
        return NULL;
2945
    s = qemu_mallocz(sizeof(WinCharState));
2946
    if (!s) {
2947
        free(chr);
2948
        return NULL;
2949
    }
2950
    chr->opaque = s;
2951
    chr->chr_write = win_chr_write;
2952
    chr->chr_close = win_chr_close;
2953

    
2954
    if (win_chr_init(chr, filename) < 0) {
2955
        free(s);
2956
        free(chr);
2957
        return NULL;
2958
    }
2959
    qemu_chr_reset(chr);
2960
    return chr;
2961
}
2962

    
2963
static int win_chr_pipe_poll(void *opaque)
2964
{
2965
    CharDriverState *chr = opaque;
2966
    WinCharState *s = chr->opaque;
2967
    DWORD size;
2968

    
2969
    PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2970
    if (size > 0) {
2971
        s->len = size;
2972
        win_chr_read_poll(chr);
2973
        win_chr_read(chr);
2974
        return 1;
2975
    }
2976
    return 0;
2977
}
2978

    
2979
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2980
{
2981
    WinCharState *s = chr->opaque;
2982
    OVERLAPPED ov;
2983
    int ret;
2984
    DWORD size;
2985
    char openname[256];
2986

    
2987
    s->fpipe = TRUE;
2988

    
2989
    s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2990
    if (!s->hsend) {
2991
        fprintf(stderr, "Failed CreateEvent\n");
2992
        goto fail;
2993
    }
2994
    s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2995
    if (!s->hrecv) {
2996
        fprintf(stderr, "Failed CreateEvent\n");
2997
        goto fail;
2998
    }
2999

    
3000
    snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
3001
    s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
3002
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
3003
                              PIPE_WAIT,
3004
                              MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
3005
    if (s->hcom == INVALID_HANDLE_VALUE) {
3006
        fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3007
        s->hcom = NULL;
3008
        goto fail;
3009
    }
3010

    
3011
    ZeroMemory(&ov, sizeof(ov));
3012
    ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
3013
    ret = ConnectNamedPipe(s->hcom, &ov);
3014
    if (ret) {
3015
        fprintf(stderr, "Failed ConnectNamedPipe\n");
3016
        goto fail;
3017
    }
3018

    
3019
    ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
3020
    if (!ret) {
3021
        fprintf(stderr, "Failed GetOverlappedResult\n");
3022
        if (ov.hEvent) {
3023
            CloseHandle(ov.hEvent);
3024
            ov.hEvent = NULL;
3025
        }
3026
        goto fail;
3027
    }
3028

    
3029
    if (ov.hEvent) {
3030
        CloseHandle(ov.hEvent);
3031
        ov.hEvent = NULL;
3032
    }
3033
    qemu_add_polling_cb(win_chr_pipe_poll, chr);
3034
    return 0;
3035

    
3036
 fail:
3037
    win_chr_close(chr);
3038
    return -1;
3039
}
3040

    
3041

    
3042
static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
3043
{
3044
    CharDriverState *chr;
3045
    WinCharState *s;
3046

    
3047
    chr = qemu_mallocz(sizeof(CharDriverState));
3048
    if (!chr)
3049
        return NULL;
3050
    s = qemu_mallocz(sizeof(WinCharState));
3051
    if (!s) {
3052
        free(chr);
3053
        return NULL;
3054
    }
3055
    chr->opaque = s;
3056
    chr->chr_write = win_chr_write;
3057
    chr->chr_close = win_chr_close;
3058

    
3059
    if (win_chr_pipe_init(chr, filename) < 0) {
3060
        free(s);
3061
        free(chr);
3062
        return NULL;
3063
    }
3064
    qemu_chr_reset(chr);
3065
    return chr;
3066
}
3067

    
3068
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
3069
{
3070
    CharDriverState *chr;
3071
    WinCharState *s;
3072

    
3073
    chr = qemu_mallocz(sizeof(CharDriverState));
3074
    if (!chr)
3075
        return NULL;
3076
    s = qemu_mallocz(sizeof(WinCharState));
3077
    if (!s) {
3078
        free(chr);
3079
        return NULL;
3080
    }
3081
    s->hcom = fd_out;
3082
    chr->opaque = s;
3083
    chr->chr_write = win_chr_write;
3084
    qemu_chr_reset(chr);
3085
    return chr;
3086
}
3087

    
3088
static CharDriverState *qemu_chr_open_win_con(const char *filename)
3089
{
3090
    return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
3091
}
3092

    
3093
static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
3094
{
3095
    HANDLE fd_out;
3096

    
3097
    fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
3098
                        OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3099
    if (fd_out == INVALID_HANDLE_VALUE)
3100
        return NULL;
3101

    
3102
    return qemu_chr_open_win_file(fd_out);
3103
}
3104
#endif /* !_WIN32 */
3105

    
3106
/***********************************************************/
3107
/* UDP Net console */
3108

    
3109
typedef struct {
3110
    int fd;
3111
    struct sockaddr_in daddr;
3112
    uint8_t buf[1024];
3113
    int bufcnt;
3114
    int bufptr;
3115
    int max_size;
3116
} NetCharDriver;
3117

    
3118
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3119
{
3120
    NetCharDriver *s = chr->opaque;
3121

    
3122
    return sendto(s->fd, buf, len, 0,
3123
                  (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
3124
}
3125

    
3126
static int udp_chr_read_poll(void *opaque)
3127
{
3128
    CharDriverState *chr = opaque;
3129
    NetCharDriver *s = chr->opaque;
3130

    
3131
    s->max_size = qemu_chr_can_read(chr);
3132

    
3133
    /* If there were any stray characters in the queue process them
3134
     * first
3135
     */
3136
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3137
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3138
        s->bufptr++;
3139
        s->max_size = qemu_chr_can_read(chr);
3140
    }
3141
    return s->max_size;
3142
}
3143

    
3144
static void udp_chr_read(void *opaque)
3145
{
3146
    CharDriverState *chr = opaque;
3147
    NetCharDriver *s = chr->opaque;
3148

    
3149
    if (s->max_size == 0)
3150
        return;
3151
    s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
3152
    s->bufptr = s->bufcnt;
3153
    if (s->bufcnt <= 0)
3154
        return;
3155

    
3156
    s->bufptr = 0;
3157
    while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3158
        qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3159
        s->bufptr++;
3160
        s->max_size = qemu_chr_can_read(chr);
3161
    }
3162
}
3163

    
3164
static void udp_chr_update_read_handler(CharDriverState *chr)
3165
{
3166
    NetCharDriver *s = chr->opaque;
3167

    
3168
    if (s->fd >= 0) {
3169
        qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3170
                             udp_chr_read, NULL, chr);
3171
    }
3172
}
3173

    
3174
int parse_host_port(struct sockaddr_in *saddr, const char *str);
3175
#ifndef _WIN32
3176
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3177
#endif
3178
int parse_host_src_port(struct sockaddr_in *haddr,
3179
                        struct sockaddr_in *saddr,
3180
                        const char *str);
3181

    
3182
static CharDriverState *qemu_chr_open_udp(const char *def)
3183
{
3184
    CharDriverState *chr = NULL;
3185
    NetCharDriver *s = NULL;
3186
    int fd = -1;
3187
    struct sockaddr_in saddr;
3188

    
3189
    chr = qemu_mallocz(sizeof(CharDriverState));
3190
    if (!chr)
3191
        goto return_err;
3192
    s = qemu_mallocz(sizeof(NetCharDriver));
3193
    if (!s)
3194
        goto return_err;
3195

    
3196
    fd = socket(PF_INET, SOCK_DGRAM, 0);
3197
    if (fd < 0) {
3198
        perror("socket(PF_INET, SOCK_DGRAM)");
3199
        goto return_err;
3200
    }
3201

    
3202
    if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3203
        printf("Could not parse: %s\n", def);
3204
        goto return_err;
3205
    }
3206

    
3207
    if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3208
    {
3209
        perror("bind");
3210
        goto return_err;
3211
    }
3212

    
3213
    s->fd = fd;
3214
    s->bufcnt = 0;
3215
    s->bufptr = 0;
3216
    chr->opaque = s;
3217
    chr->chr_write = udp_chr_write;
3218
    chr->chr_update_read_handler = udp_chr_update_read_handler;
3219
    return chr;
3220

    
3221
return_err:
3222
    if (chr)
3223
        free(chr);
3224
    if (s)
3225
        free(s);
3226
    if (fd >= 0)
3227
        closesocket(fd);
3228
    return NULL;
3229
}
3230

    
3231
/***********************************************************/
3232
/* TCP Net console */
3233

    
3234
typedef struct {
3235
    int fd, listen_fd;
3236
    int connected;
3237
    int max_size;
3238
    int do_telnetopt;
3239
    int do_nodelay;
3240
    int is_unix;
3241
} TCPCharDriver;
3242

    
3243
static void tcp_chr_accept(void *opaque);
3244

    
3245
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3246
{
3247
    TCPCharDriver *s = chr->opaque;
3248
    if (s->connected) {
3249
        return send_all(s->fd, buf, len);
3250
    } else {
3251
        /* XXX: indicate an error ? */
3252
        return len;
3253
    }
3254
}
3255

    
3256
static int tcp_chr_read_poll(void *opaque)
3257
{
3258
    CharDriverState *chr = opaque;
3259
    TCPCharDriver *s = chr->opaque;
3260
    if (!s->connected)
3261
        return 0;
3262
    s->max_size = qemu_chr_can_read(chr);
3263
    return s->max_size;
3264
}
3265

    
3266
#define IAC 255
3267
#define IAC_BREAK 243
3268
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3269
                                      TCPCharDriver *s,
3270
                                      uint8_t *buf, int *size)
3271
{
3272
    /* Handle any telnet client's basic IAC options to satisfy char by
3273
     * char mode with no echo.  All IAC options will be removed from
3274
     * the buf and the do_telnetopt variable will be used to track the
3275
     * state of the width of the IAC information.
3276
     *
3277
     * IAC commands come in sets of 3 bytes with the exception of the
3278
     * "IAC BREAK" command and the double IAC.
3279
     */
3280

    
3281
    int i;
3282
    int j = 0;
3283

    
3284
    for (i = 0; i < *size; i++) {
3285
        if (s->do_telnetopt > 1) {
3286
            if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3287
                /* Double IAC means send an IAC */
3288
                if (j != i)
3289
                    buf[j] = buf[i];
3290
                j++;
3291
                s->do_telnetopt = 1;
3292
            } else {
3293
                if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3294
                    /* Handle IAC break commands by sending a serial break */
3295
                    qemu_chr_event(chr, CHR_EVENT_BREAK);
3296
                    s->do_telnetopt++;
3297
                }
3298
                s->do_telnetopt++;
3299
            }
3300
            if (s->do_telnetopt >= 4) {
3301
                s->do_telnetopt = 1;
3302
            }
3303
        } else {
3304
            if ((unsigned char)buf[i] == IAC) {
3305
                s->do_telnetopt = 2;
3306
            } else {
3307
                if (j != i)
3308
                    buf[j] = buf[i];
3309
                j++;
3310
            }
3311
        }
3312
    }
3313
    *size = j;
3314
}
3315

    
3316
static void tcp_chr_read(void *opaque)
3317
{
3318
    CharDriverState *chr = opaque;
3319
    TCPCharDriver *s = chr->opaque;
3320
    uint8_t buf[1024];
3321
    int len, size;
3322

    
3323
    if (!s->connected || s->max_size <= 0)
3324
        return;
3325
    len = sizeof(buf);
3326
    if (len > s->max_size)
3327
        len = s->max_size;
3328
    size = recv(s->fd, buf, len, 0);
3329
    if (size == 0) {
3330
        /* connection closed */
3331
        s->connected = 0;
3332
        if (s->listen_fd >= 0) {
3333
            qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3334
        }
3335
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3336
        closesocket(s->fd);
3337
        s->fd = -1;
3338
    } else if (size > 0) {
3339
        if (s->do_telnetopt)
3340
            tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3341
        if (size > 0)
3342
            qemu_chr_read(chr, buf, size);
3343
    }
3344
}
3345

    
3346
static void tcp_chr_connect(void *opaque)
3347
{
3348
    CharDriverState *chr = opaque;
3349
    TCPCharDriver *s = chr->opaque;
3350

    
3351
    s->connected = 1;
3352
    qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3353
                         tcp_chr_read, NULL, chr);
3354
    qemu_chr_reset(chr);
3355
}
3356

    
3357
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3358
static void tcp_chr_telnet_init(int fd)
3359
{
3360
    char buf[3];
3361
    /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3362
    IACSET(buf, 0xff, 0xfb, 0x01);  /* IAC WILL ECHO */
3363
    send(fd, (char *)buf, 3, 0);
3364
    IACSET(buf, 0xff, 0xfb, 0x03);  /* IAC WILL Suppress go ahead */
3365
    send(fd, (char *)buf, 3, 0);
3366
    IACSET(buf, 0xff, 0xfb, 0x00);  /* IAC WILL Binary */
3367
    send(fd, (char *)buf, 3, 0);
3368
    IACSET(buf, 0xff, 0xfd, 0x00);  /* IAC DO Binary */
3369
    send(fd, (char *)buf, 3, 0);
3370
}
3371

    
3372
static void socket_set_nodelay(int fd)
3373
{
3374
    int val = 1;
3375
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3376
}
3377

    
3378
static void tcp_chr_accept(void *opaque)
3379
{
3380
    CharDriverState *chr = opaque;
3381
    TCPCharDriver *s = chr->opaque;
3382
    struct sockaddr_in saddr;
3383
#ifndef _WIN32
3384
    struct sockaddr_un uaddr;
3385
#endif
3386
    struct sockaddr *addr;
3387
    socklen_t len;
3388
    int fd;
3389

    
3390
    for(;;) {
3391
#ifndef _WIN32
3392
        if (s->is_unix) {
3393
            len = sizeof(uaddr);
3394
            addr = (struct sockaddr *)&uaddr;
3395
        } else
3396
#endif
3397
        {
3398
            len = sizeof(saddr);
3399
            addr = (struct sockaddr *)&saddr;
3400
        }
3401
        fd = accept(s->listen_fd, addr, &len);
3402
        if (fd < 0 && errno != EINTR) {
3403
            return;
3404
        } else if (fd >= 0) {
3405
            if (s->do_telnetopt)
3406
                tcp_chr_telnet_init(fd);
3407
            break;
3408
        }
3409
    }
3410
    socket_set_nonblock(fd);
3411
    if (s->do_nodelay)
3412
        socket_set_nodelay(fd);
3413
    s->fd = fd;
3414
    qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3415
    tcp_chr_connect(chr);
3416
}
3417

    
3418
static void tcp_chr_close(CharDriverState *chr)
3419
{
3420
    TCPCharDriver *s = chr->opaque;
3421
    if (s->fd >= 0)
3422
        closesocket(s->fd);
3423
    if (s->listen_fd >= 0)
3424
        closesocket(s->listen_fd);
3425
    qemu_free(s);
3426
}
3427

    
3428
static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3429
                                          int is_telnet,
3430
                                          int is_unix)
3431
{
3432
    CharDriverState *chr = NULL;
3433
    TCPCharDriver *s = NULL;
3434
    int fd = -1, ret, err, val;
3435
    int is_listen = 0;
3436
    int is_waitconnect = 1;
3437
    int do_nodelay = 0;
3438
    const char *ptr;
3439
    struct sockaddr_in saddr;
3440
#ifndef _WIN32
3441
    struct sockaddr_un uaddr;
3442
#endif
3443
    struct sockaddr *addr;
3444
    socklen_t addrlen;
3445

    
3446
#ifndef _WIN32
3447
    if (is_unix) {
3448
        addr = (struct sockaddr *)&uaddr;
3449
        addrlen = sizeof(uaddr);
3450
        if (parse_unix_path(&uaddr, host_str) < 0)
3451
            goto fail;
3452
    } else
3453
#endif
3454
    {
3455
        addr = (struct sockaddr *)&saddr;
3456
        addrlen = sizeof(saddr);
3457
        if (parse_host_port(&saddr, host_str) < 0)
3458
            goto fail;
3459
    }
3460

    
3461
    ptr = host_str;
3462
    while((ptr = strchr(ptr,','))) {
3463
        ptr++;
3464
        if (!strncmp(ptr,"server",6)) {
3465
            is_listen = 1;
3466
        } else if (!strncmp(ptr,"nowait",6)) {
3467
            is_waitconnect = 0;
3468
        } else if (!strncmp(ptr,"nodelay",6)) {
3469
            do_nodelay = 1;
3470
        } else {
3471
            printf("Unknown option: %s\n", ptr);
3472
            goto fail;
3473
        }
3474
    }
3475
    if (!is_listen)
3476
        is_waitconnect = 0;
3477

    
3478
    chr = qemu_mallocz(sizeof(CharDriverState));
3479
    if (!chr)
3480
        goto fail;
3481
    s = qemu_mallocz(sizeof(TCPCharDriver));
3482
    if (!s)
3483
        goto fail;
3484

    
3485
#ifndef _WIN32
3486
    if (is_unix)
3487
        fd = socket(PF_UNIX, SOCK_STREAM, 0);
3488
    else
3489
#endif
3490
        fd = socket(PF_INET, SOCK_STREAM, 0);
3491

    
3492
    if (fd < 0)
3493
        goto fail;
3494

    
3495
    if (!is_waitconnect)
3496
        socket_set_nonblock(fd);
3497

    
3498
    s->connected = 0;
3499
    s->fd = -1;
3500
    s->listen_fd = -1;
3501
    s->is_unix = is_unix;
3502
    s->do_nodelay = do_nodelay && !is_unix;
3503

    
3504
    chr->opaque = s;
3505
    chr->chr_write = tcp_chr_write;
3506
    chr->chr_close = tcp_chr_close;
3507

    
3508
    if (is_listen) {
3509
        /* allow fast reuse */
3510
#ifndef _WIN32
3511
        if (is_unix) {
3512
            char path[109];
3513
            pstrcpy(path, sizeof(path), uaddr.sun_path);
3514
            unlink(path);
3515
        } else
3516
#endif
3517
        {
3518
            val = 1;
3519
            setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3520
        }
3521

    
3522
        ret = bind(fd, addr, addrlen);
3523
        if (ret < 0)
3524
            goto fail;
3525

    
3526
        ret = listen(fd, 0);
3527
        if (ret < 0)
3528
            goto fail;
3529

    
3530
        s->listen_fd = fd;
3531
        qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3532
        if (is_telnet)
3533
            s->do_telnetopt = 1;
3534
    } else {
3535
        for(;;) {
3536
            ret = connect(fd, addr, addrlen);
3537
            if (ret < 0) {
3538
                err = socket_error();
3539
                if (err == EINTR || err == EWOULDBLOCK) {
3540
                } else if (err == EINPROGRESS) {
3541
                    break;
3542
#ifdef _WIN32
3543
                } else if (err == WSAEALREADY) {
3544
                    break;
3545
#endif
3546
                } else {
3547
                    goto fail;
3548
                }
3549
            } else {
3550
                s->connected = 1;
3551
                break;
3552
            }
3553
        }
3554
        s->fd = fd;
3555
        socket_set_nodelay(fd);
3556
        if (s->connected)
3557
            tcp_chr_connect(chr);
3558
        else
3559
            qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3560
    }
3561

    
3562
    if (is_listen && is_waitconnect) {
3563
        printf("QEMU waiting for connection on: %s\n", host_str);
3564
        tcp_chr_accept(chr);
3565
        socket_set_nonblock(s->listen_fd);
3566
    }
3567

    
3568
    return chr;
3569
 fail:
3570
    if (fd >= 0)
3571
        closesocket(fd);
3572
    qemu_free(s);
3573
    qemu_free(chr);
3574
    return NULL;
3575
}
3576

    
3577
CharDriverState *qemu_chr_open(const char *filename)
3578
{
3579
    const char *p;
3580

    
3581
    if (!strcmp(filename, "vc")) {
3582
        return text_console_init(&display_state, 0);
3583
    } else if (strstart(filename, "vc:", &p)) {
3584
        return text_console_init(&display_state, p);
3585
    } else if (!strcmp(filename, "null")) {
3586
        return qemu_chr_open_null();
3587
    } else
3588
    if (strstart(filename, "tcp:", &p)) {
3589
        return qemu_chr_open_tcp(p, 0, 0);
3590
    } else
3591
    if (strstart(filename, "telnet:", &p)) {
3592
        return qemu_chr_open_tcp(p, 1, 0);
3593
    } else
3594
    if (strstart(filename, "udp:", &p)) {
3595
        return qemu_chr_open_udp(p);
3596
    } else
3597
    if (strstart(filename, "mon:", &p)) {
3598
        CharDriverState *drv = qemu_chr_open(p);
3599
        if (drv) {
3600
            drv = qemu_chr_open_mux(drv);
3601
            monitor_init(drv, !nographic);
3602
            return drv;
3603
        }
3604
        printf("Unable to open driver: %s\n", p);
3605
        return 0;
3606
    } else
3607
#ifndef _WIN32
3608
    if (strstart(filename, "unix:", &p)) {
3609
        return qemu_chr_open_tcp(p, 0, 1);
3610
    } else if (strstart(filename, "file:", &p)) {
3611
        return qemu_chr_open_file_out(p);
3612
    } else if (strstart(filename, "pipe:", &p)) {
3613
        return qemu_chr_open_pipe(p);
3614
    } else if (!strcmp(filename, "pty")) {
3615
        return qemu_chr_open_pty();
3616
    } else if (!strcmp(filename, "stdio")) {
3617
        return qemu_chr_open_stdio();
3618
    } else
3619
#if defined(__linux__)
3620
    if (strstart(filename, "/dev/parport", NULL)) {
3621
        return qemu_chr_open_pp(filename);
3622
    } else
3623
#endif
3624
#if defined(__linux__) || defined(__sun__)
3625
    if (strstart(filename, "/dev/", NULL)) {
3626
        return qemu_chr_open_tty(filename);
3627
    } else
3628
#endif
3629
#else /* !_WIN32 */
3630
    if (strstart(filename, "COM", NULL)) {
3631
        return qemu_chr_open_win(filename);
3632
    } else
3633
    if (strstart(filename, "pipe:", &p)) {
3634
        return qemu_chr_open_win_pipe(p);
3635
    } else
3636
    if (strstart(filename, "con:", NULL)) {
3637
        return qemu_chr_open_win_con(filename);
3638
    } else
3639
    if (strstart(filename, "file:", &p)) {
3640
        return qemu_chr_open_win_file_out(p);
3641
    } else
3642
#endif
3643
#ifdef CONFIG_BRLAPI
3644
    if (!strcmp(filename, "braille")) {
3645
        return chr_baum_init();
3646
    } else
3647
#endif
3648
    {
3649
        return NULL;
3650
    }
3651
}
3652

    
3653
void qemu_chr_close(CharDriverState *chr)
3654
{
3655
    if (chr->chr_close)
3656
        chr->chr_close(chr);
3657
    qemu_free(chr);
3658
}
3659

    
3660
/***********************************************************/
3661
/* network device redirectors */
3662

    
3663
__attribute__ (( unused ))
3664
static void hex_dump(FILE *f, const uint8_t *buf, int size)
3665
{
3666
    int len, i, j, c;
3667

    
3668
    for(i=0;i<size;i+=16) {
3669
        len = size - i;
3670
        if (len > 16)
3671
            len = 16;
3672
        fprintf(f, "%08x ", i);
3673
        for(j=0;j<16;j++) {
3674
            if (j < len)
3675
                fprintf(f, " %02x", buf[i+j]);
3676
            else
3677
                fprintf(f, "   ");
3678
        }
3679
        fprintf(f, " ");
3680
        for(j=0;j<len;j++) {
3681
            c = buf[i+j];
3682
            if (c < ' ' || c > '~')
3683
                c = '.';
3684
            fprintf(f, "%c", c);
3685
        }
3686
        fprintf(f, "\n");
3687
    }
3688
}
3689

    
3690
static int parse_macaddr(uint8_t *macaddr, const char *p)
3691
{
3692
    int i;
3693
    char *last_char;
3694
    long int offset;
3695

    
3696
    errno = 0;
3697
    offset = strtol(p, &last_char, 0);    
3698
    if (0 == errno && '\0' == *last_char &&
3699
            offset >= 0 && offset <= 0xFFFFFF) {
3700
        macaddr[3] = (offset & 0xFF0000) >> 16;
3701
        macaddr[4] = (offset & 0xFF00) >> 8;
3702
        macaddr[5] = offset & 0xFF;
3703
        return 0;
3704
    } else {
3705
        for(i = 0; i < 6; i++) {
3706
            macaddr[i] = strtol(p, (char **)&p, 16);
3707
            if (i == 5) {
3708
                if (*p != '\0')
3709
                    return -1;
3710
            } else {
3711
                if (*p != ':' && *p != '-')
3712
                    return -1;
3713
                p++;
3714
            }
3715
        }
3716
        return 0;    
3717
    }
3718

    
3719
    return -1;
3720
}
3721

    
3722
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3723
{
3724
    const char *p, *p1;
3725
    int len;
3726
    p = *pp;
3727
    p1 = strchr(p, sep);
3728
    if (!p1)
3729
        return -1;
3730
    len = p1 - p;
3731
    p1++;
3732
    if (buf_size > 0) {
3733
        if (len > buf_size - 1)
3734
            len = buf_size - 1;
3735
        memcpy(buf, p, len);
3736
        buf[len] = '\0';
3737
    }
3738
    *pp = p1;
3739
    return 0;
3740
}
3741

    
3742
int parse_host_src_port(struct sockaddr_in *haddr,
3743
                        struct sockaddr_in *saddr,
3744
                        const char *input_str)
3745
{
3746
    char *str = strdup(input_str);
3747
    char *host_str = str;
3748
    char *src_str;
3749
    char *ptr;
3750

    
3751
    /*
3752
     * Chop off any extra arguments at the end of the string which
3753
     * would start with a comma, then fill in the src port information
3754
     * if it was provided else use the "any address" and "any port".
3755
     */
3756
    if ((ptr = strchr(str,',')))
3757
        *ptr = '\0';
3758

    
3759
    if ((src_str = strchr(input_str,'@'))) {
3760
        *src_str = '\0';
3761
        src_str++;
3762
    }
3763

    
3764
    if (parse_host_port(haddr, host_str) < 0)
3765
        goto fail;
3766

    
3767
    if (!src_str || *src_str == '\0')
3768
        src_str = ":0";
3769

    
3770
    if (parse_host_port(saddr, src_str) < 0)
3771
        goto fail;
3772

    
3773
    free(str);
3774
    return(0);
3775

    
3776
fail:
3777
    free(str);
3778
    return -1;
3779
}
3780

    
3781
int parse_host_port(struct sockaddr_in *saddr, const char *str)
3782
{
3783
    char buf[512];
3784
    struct hostent *he;
3785
    const char *p, *r;
3786
    int port;
3787

    
3788
    p = str;
3789
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3790
        return -1;
3791
    saddr->sin_family = AF_INET;
3792
    if (buf[0] == '\0') {
3793
        saddr->sin_addr.s_addr = 0;
3794
    } else {
3795
        if (isdigit(buf[0])) {
3796
            if (!inet_aton(buf, &saddr->sin_addr))
3797
                return -1;
3798
        } else {
3799
            if ((he = gethostbyname(buf)) == NULL)
3800
                return - 1;
3801
            saddr->sin_addr = *(struct in_addr *)he->h_addr;
3802
        }
3803
    }
3804
    port = strtol(p, (char **)&r, 0);
3805
    if (r == p)
3806
        return -1;
3807
    saddr->sin_port = htons(port);
3808
    return 0;
3809
}
3810

    
3811
#ifndef _WIN32
3812
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3813
{
3814
    const char *p;
3815
    int len;
3816

    
3817
    len = MIN(108, strlen(str));
3818
    p = strchr(str, ',');
3819
    if (p)
3820
        len = MIN(len, p - str);
3821

    
3822
    memset(uaddr, 0, sizeof(*uaddr));
3823

    
3824
    uaddr->sun_family = AF_UNIX;
3825
    memcpy(uaddr->sun_path, str, len);
3826

    
3827
    return 0;
3828
}
3829
#endif
3830

    
3831
/* find or alloc a new VLAN */
3832
VLANState *qemu_find_vlan(int id)
3833
{
3834
    VLANState **pvlan, *vlan;
3835
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3836
        if (vlan->id == id)
3837
            return vlan;
3838
    }
3839
    vlan = qemu_mallocz(sizeof(VLANState));
3840
    if (!vlan)
3841
        return NULL;
3842
    vlan->id = id;
3843
    vlan->next = NULL;
3844
    pvlan = &first_vlan;
3845
    while (*pvlan != NULL)
3846
        pvlan = &(*pvlan)->next;
3847
    *pvlan = vlan;
3848
    return vlan;
3849
}
3850

    
3851
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3852
                                      IOReadHandler *fd_read,
3853
                                      IOCanRWHandler *fd_can_read,
3854
                                      void *opaque)
3855
{
3856
    VLANClientState *vc, **pvc;
3857
    vc = qemu_mallocz(sizeof(VLANClientState));
3858
    if (!vc)
3859
        return NULL;
3860
    vc->fd_read = fd_read;
3861
    vc->fd_can_read = fd_can_read;
3862
    vc->opaque = opaque;
3863
    vc->vlan = vlan;
3864

    
3865
    vc->next = NULL;
3866
    pvc = &vlan->first_client;
3867
    while (*pvc != NULL)
3868
        pvc = &(*pvc)->next;
3869
    *pvc = vc;
3870
    return vc;
3871
}
3872

    
3873
int qemu_can_send_packet(VLANClientState *vc1)
3874
{
3875
    VLANState *vlan = vc1->vlan;
3876
    VLANClientState *vc;
3877

    
3878
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3879
        if (vc != vc1) {
3880
            if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3881
                return 1;
3882
        }
3883
    }
3884
    return 0;
3885
}
3886

    
3887
void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3888
{
3889
    VLANState *vlan = vc1->vlan;
3890
    VLANClientState *vc;
3891

    
3892
#if 0
3893
    printf("vlan %d send:\n", vlan->id);
3894
    hex_dump(stdout, buf, size);
3895
#endif
3896
    for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3897
        if (vc != vc1) {
3898
            vc->fd_read(vc->opaque, buf, size);
3899
        }
3900
    }
3901
}
3902

    
3903
#if defined(CONFIG_SLIRP)
3904

    
3905
/* slirp network adapter */
3906

    
3907
static int slirp_inited;
3908
static VLANClientState *slirp_vc;
3909

    
3910
int slirp_can_output(void)
3911
{
3912
    return !slirp_vc || qemu_can_send_packet(slirp_vc);
3913
}
3914

    
3915
void slirp_output(const uint8_t *pkt, int pkt_len)
3916
{
3917
#if 0
3918
    printf("slirp output:\n");
3919
    hex_dump(stdout, pkt, pkt_len);
3920
#endif
3921
    if (!slirp_vc)
3922
        return;
3923
    qemu_send_packet(slirp_vc, pkt, pkt_len);
3924
}
3925

    
3926
static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3927
{
3928
#if 0
3929
    printf("slirp input:\n");
3930
    hex_dump(stdout, buf, size);
3931
#endif
3932
    slirp_input(buf, size);
3933
}
3934

    
3935
static int net_slirp_init(VLANState *vlan)
3936
{
3937
    if (!slirp_inited) {
3938
        slirp_inited = 1;
3939
        slirp_init();
3940
    }
3941
    slirp_vc = qemu_new_vlan_client(vlan,
3942
                                    slirp_receive, NULL, NULL);
3943
    snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3944
    return 0;
3945
}
3946

    
3947
static void net_slirp_redir(const char *redir_str)
3948
{
3949
    int is_udp;
3950
    char buf[256], *r;
3951
    const char *p;
3952
    struct in_addr guest_addr;
3953
    int host_port, guest_port;
3954

    
3955
    if (!slirp_inited) {
3956
        slirp_inited = 1;
3957
        slirp_init();
3958
    }
3959

    
3960
    p = redir_str;
3961
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3962
        goto fail;
3963
    if (!strcmp(buf, "tcp")) {
3964
        is_udp = 0;
3965
    } else if (!strcmp(buf, "udp")) {
3966
        is_udp = 1;
3967
    } else {
3968
        goto fail;
3969
    }
3970

    
3971
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3972
        goto fail;
3973
    host_port = strtol(buf, &r, 0);
3974
    if (r == buf)
3975
        goto fail;
3976

    
3977
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3978
        goto fail;
3979
    if (buf[0] == '\0') {
3980
        pstrcpy(buf, sizeof(buf), "10.0.2.15");
3981
    }
3982
    if (!inet_aton(buf, &guest_addr))
3983
        goto fail;
3984

    
3985
    guest_port = strtol(p, &r, 0);
3986
    if (r == p)
3987
        goto fail;
3988

    
3989
    if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3990
        fprintf(stderr, "qemu: could not set up redirection\n");
3991
        exit(1);
3992
    }
3993
    return;
3994
 fail:
3995
    fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3996
    exit(1);
3997
}
3998

    
3999
#ifndef _WIN32
4000

    
4001
char smb_dir[1024];
4002

    
4003
static void erase_dir(char *dir_name)
4004
{
4005
    DIR *d;
4006
    struct dirent *de;
4007
    char filename[1024];
4008

    
4009
    /* erase all the files in the directory */
4010
    if ((d = opendir(dir_name)) != 0) {
4011
        for(;;) {
4012
            de = readdir(d);
4013
            if (!de)
4014
                break;
4015
            if (strcmp(de->d_name, ".") != 0 &&
4016
                strcmp(de->d_name, "..") != 0) {
4017
                snprintf(filename, sizeof(filename), "%s/%s",
4018
                         smb_dir, de->d_name);
4019
                if (unlink(filename) != 0)  /* is it a directory? */
4020
                    erase_dir(filename);
4021
            }
4022
        }
4023
        closedir(d);
4024
        rmdir(dir_name);
4025
    }
4026
}
4027

    
4028
/* automatic user mode samba server configuration */
4029
static void smb_exit(void)
4030
{
4031
    erase_dir(smb_dir);
4032
}
4033

    
4034
/* automatic user mode samba server configuration */
4035
static void net_slirp_smb(const char *exported_dir)
4036
{
4037
    char smb_conf[1024];
4038
    char smb_cmdline[1024];
4039
    FILE *f;
4040

    
4041
    if (!slirp_inited) {
4042
        slirp_inited = 1;
4043
        slirp_init();
4044
    }
4045

    
4046
    /* XXX: better tmp dir construction */
4047
    snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
4048
    if (mkdir(smb_dir, 0700) < 0) {
4049
        fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
4050
        exit(1);
4051
    }
4052
    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
4053

    
4054
    f = fopen(smb_conf, "w");
4055
    if (!f) {
4056
        fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
4057
        exit(1);
4058
    }
4059
    fprintf(f,
4060
            "[global]\n"
4061
            "private dir=%s\n"
4062
            "smb ports=0\n"
4063
            "socket address=127.0.0.1\n"
4064
            "pid directory=%s\n"
4065
            "lock directory=%s\n"
4066
            "log file=%s/log.smbd\n"
4067
            "smb passwd file=%s/smbpasswd\n"
4068
            "security = share\n"
4069
            "[qemu]\n"
4070
            "path=%s\n"
4071
            "read only=no\n"
4072
            "guest ok=yes\n",
4073
            smb_dir,
4074
            smb_dir,
4075
            smb_dir,
4076
            smb_dir,
4077
            smb_dir,
4078
            exported_dir
4079
            );
4080
    fclose(f);
4081
    atexit(smb_exit);
4082

    
4083
    snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
4084
             SMBD_COMMAND, smb_conf);
4085

    
4086
    slirp_add_exec(0, smb_cmdline, 4, 139);
4087
}
4088

    
4089
#endif /* !defined(_WIN32) */
4090
void do_info_slirp(void)
4091
{
4092
    slirp_stats();
4093
}
4094

    
4095
#endif /* CONFIG_SLIRP */
4096

    
4097
#if !defined(_WIN32)
4098

    
4099
typedef struct TAPState {
4100
    VLANClientState *vc;
4101
    int fd;
4102
    char down_script[1024];
4103
} TAPState;
4104

    
4105
static void tap_receive(void *opaque, const uint8_t *buf, int size)
4106
{
4107
    TAPState *s = opaque;
4108
    int ret;
4109
    for(;;) {
4110
        ret = write(s->fd, buf, size);
4111
        if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
4112
        } else {
4113
            break;
4114
        }
4115
    }
4116
}
4117

    
4118
static void tap_send(void *opaque)
4119
{
4120
    TAPState *s = opaque;
4121
    uint8_t buf[4096];
4122
    int size;
4123

    
4124
#ifdef __sun__
4125
    struct strbuf sbuf;
4126
    int f = 0;
4127
    sbuf.maxlen = sizeof(buf);
4128
    sbuf.buf = buf;
4129
    size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
4130
#else
4131
    size = read(s->fd, buf, sizeof(buf));
4132
#endif
4133
    if (size > 0) {
4134
        qemu_send_packet(s->vc, buf, size);
4135
    }
4136
}
4137

    
4138
/* fd support */
4139

    
4140
static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
4141
{
4142
    TAPState *s;
4143

    
4144
    s = qemu_mallocz(sizeof(TAPState));
4145
    if (!s)
4146
        return NULL;
4147
    s->fd = fd;
4148
    s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
4149
    qemu_set_fd_handler(s->fd, tap_send, NULL, s);
4150
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
4151
    return s;
4152
}
4153

    
4154
#if defined (_BSD) || defined (__FreeBSD_kernel__)
4155
static int tap_open(char *ifname, int ifname_size)
4156
{
4157
    int fd;
4158
    char *dev;
4159
    struct stat s;
4160

    
4161
    TFR(fd = open("/dev/tap", O_RDWR));
4162
    if (fd < 0) {
4163
        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
4164
        return -1;
4165
    }
4166

    
4167
    fstat(fd, &s);
4168
    dev = devname(s.st_rdev, S_IFCHR);
4169
    pstrcpy(ifname, ifname_size, dev);
4170

    
4171
    fcntl(fd, F_SETFL, O_NONBLOCK);
4172
    return fd;
4173
}
4174
#elif defined(__sun__)
4175
#define TUNNEWPPA       (('T'<<16) | 0x0001)
4176
/*
4177
 * Allocate TAP device, returns opened fd.
4178
 * Stores dev name in the first arg(must be large enough).
4179
 */
4180
int tap_alloc(char *dev)
4181
{
4182
    int tap_fd, if_fd, ppa = -1;
4183
    static int ip_fd = 0;
4184
    char *ptr;
4185

    
4186
    static int arp_fd = 0;
4187
    int ip_muxid, arp_muxid;
4188
    struct strioctl  strioc_if, strioc_ppa;
4189
    int link_type = I_PLINK;;
4190
    struct lifreq ifr;
4191
    char actual_name[32] = "";
4192

    
4193
    memset(&ifr, 0x0, sizeof(ifr));
4194

    
4195
    if( *dev ){
4196
       ptr = dev;
4197
       while( *ptr && !isdigit((int)*ptr) ) ptr++;
4198
       ppa = atoi(ptr);
4199
    }
4200

    
4201
    /* Check if IP device was opened */
4202
    if( ip_fd )
4203
       close(ip_fd);
4204

    
4205
    TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4206
    if (ip_fd < 0) {
4207
       syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4208
       return -1;
4209
    }
4210

    
4211
    TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4212
    if (tap_fd < 0) {
4213
       syslog(LOG_ERR, "Can't open /dev/tap");
4214
       return -1;
4215
    }
4216

    
4217
    /* Assign a new PPA and get its unit number. */
4218
    strioc_ppa.ic_cmd = TUNNEWPPA;
4219
    strioc_ppa.ic_timout = 0;
4220
    strioc_ppa.ic_len = sizeof(ppa);
4221
    strioc_ppa.ic_dp = (char *)&ppa;
4222
    if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4223
       syslog (LOG_ERR, "Can't assign new interface");
4224

    
4225
    TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4226
    if (if_fd < 0) {
4227
       syslog(LOG_ERR, "Can't open /dev/tap (2)");
4228
       return -1;
4229
    }
4230
    if(ioctl(if_fd, I_PUSH, "ip") < 0){
4231
       syslog(LOG_ERR, "Can't push IP module");
4232
       return -1;
4233
    }
4234

    
4235
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4236
        syslog(LOG_ERR, "Can't get flags\n");
4237

    
4238
    snprintf (actual_name, 32, "tap%d", ppa);
4239
    strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4240

    
4241
    ifr.lifr_ppa = ppa;
4242
    /* Assign ppa according to the unit number returned by tun device */
4243

    
4244
    if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4245
        syslog (LOG_ERR, "Can't set PPA %d", ppa);
4246
    if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4247
        syslog (LOG_ERR, "Can't get flags\n");
4248
    /* Push arp module to if_fd */
4249
    if (ioctl (if_fd, I_PUSH, "arp") < 0)
4250
        syslog (LOG_ERR, "Can't push ARP module (2)");
4251

    
4252
    /* Push arp module to ip_fd */
4253
    if (ioctl (ip_fd, I_POP, NULL) < 0)
4254
        syslog (LOG_ERR, "I_POP failed\n");
4255
    if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4256
        syslog (LOG_ERR, "Can't push ARP module (3)\n");
4257
    /* Open arp_fd */
4258
    TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4259
    if (arp_fd < 0)
4260
       syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4261

    
4262
    /* Set ifname to arp */
4263
    strioc_if.ic_cmd = SIOCSLIFNAME;
4264
    strioc_if.ic_timout = 0;
4265
    strioc_if.ic_len = sizeof(ifr);
4266
    strioc_if.ic_dp = (char *)&ifr;
4267
    if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4268
        syslog (LOG_ERR, "Can't set ifname to arp\n");
4269
    }
4270

    
4271
    if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4272
       syslog(LOG_ERR, "Can't link TAP device to IP");
4273
       return -1;
4274
    }
4275

    
4276
    if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4277
        syslog (LOG_ERR, "Can't link TAP device to ARP");
4278

    
4279
    close (if_fd);
4280

    
4281
    memset(&ifr, 0x0, sizeof(ifr));
4282
    strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4283
    ifr.lifr_ip_muxid  = ip_muxid;
4284
    ifr.lifr_arp_muxid = arp_muxid;
4285

    
4286
    if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4287
    {
4288
      ioctl (ip_fd, I_PUNLINK , arp_muxid);
4289
      ioctl (ip_fd, I_PUNLINK, ip_muxid);
4290
      syslog (LOG_ERR, "Can't set multiplexor id");
4291
    }
4292

    
4293
    sprintf(dev, "tap%d", ppa);
4294
    return tap_fd;
4295
}
4296

    
4297
static int tap_open(char *ifname, int ifname_size)
4298
{
4299
    char  dev[10]="";
4300
    int fd;
4301
    if( (fd = tap_alloc(dev)) < 0 ){
4302
       fprintf(stderr, "Cannot allocate TAP device\n");
4303
       return -1;
4304
    }
4305
    pstrcpy(ifname, ifname_size, dev);
4306
    fcntl(fd, F_SETFL, O_NONBLOCK);
4307
    return fd;
4308
}
4309
#else
4310
static int tap_open(char *ifname, int ifname_size)
4311
{
4312
    struct ifreq ifr;
4313
    int fd, ret;
4314

    
4315
    TFR(fd = open("/dev/net/tun", O_RDWR));
4316
    if (fd < 0) {
4317
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4318
        return -1;
4319
    }
4320
    memset(&ifr, 0, sizeof(ifr));
4321
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4322
    if (ifname[0] != '\0')
4323
        pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4324
    else
4325
        pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4326
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4327
    if (ret != 0) {
4328
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4329
        close(fd);
4330
        return -1;
4331
    }
4332
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
4333
    fcntl(fd, F_SETFL, O_NONBLOCK);
4334
    return fd;
4335
}
4336
#endif
4337

    
4338
static int launch_script(const char *setup_script, const char *ifname, int fd)
4339
{
4340
    int pid, status;
4341
    char *args[3];
4342
    char **parg;
4343

    
4344
        /* try to launch network script */
4345
        pid = fork();
4346
        if (pid >= 0) {
4347
            if (pid == 0) {
4348
                int open_max = sysconf (_SC_OPEN_MAX), i;
4349
                for (i = 0; i < open_max; i++)
4350
                    if (i != STDIN_FILENO &&
4351
                        i != STDOUT_FILENO &&
4352
                        i != STDERR_FILENO &&
4353
                        i != fd)
4354
                        close(i);
4355

    
4356
                parg = args;
4357
                *parg++ = (char *)setup_script;
4358
                *parg++ = (char *)ifname;
4359
                *parg++ = NULL;
4360
                execv(setup_script, args);
4361
                _exit(1);
4362
            }
4363
            while (waitpid(pid, &status, 0) != pid);
4364
            if (!WIFEXITED(status) ||
4365
                WEXITSTATUS(status) != 0) {
4366
                fprintf(stderr, "%s: could not launch network script\n",
4367
                        setup_script);
4368
                return -1;
4369
            }
4370
        }
4371
    return 0;
4372
}
4373

    
4374
static int net_tap_init(VLANState *vlan, const char *ifname1,
4375
                        const char *setup_script, const char *down_script)
4376
{
4377
    TAPState *s;
4378
    int fd;
4379
    char ifname[128];
4380

    
4381
    if (ifname1 != NULL)
4382
        pstrcpy(ifname, sizeof(ifname), ifname1);
4383
    else
4384
        ifname[0] = '\0';
4385
    TFR(fd = tap_open(ifname, sizeof(ifname)));
4386
    if (fd < 0)
4387
        return -1;
4388

    
4389
    if (!setup_script || !strcmp(setup_script, "no"))
4390
        setup_script = "";
4391
    if (setup_script[0] != '\0') {
4392
        if (launch_script(setup_script, ifname, fd))
4393
            return -1;
4394
    }
4395
    s = net_tap_fd_init(vlan, fd);
4396
    if (!s)
4397
        return -1;
4398
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4399
             "tap: ifname=%s setup_script=%s", ifname, setup_script);
4400
    if (down_script && strcmp(down_script, "no"))
4401
        snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4402
    return 0;
4403
}
4404

    
4405
#endif /* !_WIN32 */
4406

    
4407
/* network connection */
4408
typedef struct NetSocketState {
4409
    VLANClientState *vc;
4410
    int fd;
4411
    int state; /* 0 = getting length, 1 = getting data */
4412
    int index;
4413
    int packet_len;
4414
    uint8_t buf[4096];
4415
    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4416
} NetSocketState;
4417

    
4418
typedef struct NetSocketListenState {
4419
    VLANState *vlan;
4420
    int fd;
4421
} NetSocketListenState;
4422

    
4423
/* XXX: we consider we can send the whole packet without blocking */
4424
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4425
{
4426
    NetSocketState *s = opaque;
4427
    uint32_t len;
4428
    len = htonl(size);
4429

    
4430
    send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4431
    send_all(s->fd, buf, size);
4432
}
4433

    
4434
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4435
{
4436
    NetSocketState *s = opaque;
4437
    sendto(s->fd, buf, size, 0,
4438
           (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4439
}
4440

    
4441
static void net_socket_send(void *opaque)
4442
{
4443
    NetSocketState *s = opaque;
4444
    int l, size, err;
4445
    uint8_t buf1[4096];
4446
    const uint8_t *buf;
4447

    
4448
    size = recv(s->fd, buf1, sizeof(buf1), 0);
4449
    if (size < 0) {
4450
        err = socket_error();
4451
        if (err != EWOULDBLOCK)
4452
            goto eoc;
4453
    } else if (size == 0) {
4454
        /* end of connection */
4455
    eoc:
4456
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4457
        closesocket(s->fd);
4458
        return;
4459
    }
4460
    buf = buf1;
4461
    while (size > 0) {
4462
        /* reassemble a packet from the network */
4463
        switch(s->state) {
4464
        case 0:
4465
            l = 4 - s->index;
4466
            if (l > size)
4467
                l = size;
4468
            memcpy(s->buf + s->index, buf, l);
4469
            buf += l;
4470
            size -= l;
4471
            s->index += l;
4472
            if (s->index == 4) {
4473
                /* got length */
4474
                s->packet_len = ntohl(*(uint32_t *)s->buf);
4475
                s->index = 0;
4476
                s->state = 1;
4477
            }
4478
            break;
4479
        case 1:
4480
            l = s->packet_len - s->index;
4481
            if (l > size)
4482
                l = size;
4483
            memcpy(s->buf + s->index, buf, l);
4484
            s->index += l;
4485
            buf += l;
4486
            size -= l;
4487
            if (s->index >= s->packet_len) {
4488
                qemu_send_packet(s->vc, s->buf, s->packet_len);
4489
                s->index = 0;
4490
                s->state = 0;
4491
            }
4492
            break;
4493
        }
4494
    }
4495
}
4496

    
4497
static void net_socket_send_dgram(void *opaque)
4498
{
4499
    NetSocketState *s = opaque;
4500
    int size;
4501

    
4502
    size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4503
    if (size < 0)
4504
        return;
4505
    if (size == 0) {
4506
        /* end of connection */
4507
        qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4508
        return;
4509
    }
4510
    qemu_send_packet(s->vc, s->buf, size);
4511
}
4512

    
4513
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4514
{
4515
    struct ip_mreq imr;
4516
    int fd;
4517
    int val, ret;
4518
    if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4519
        fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4520
                inet_ntoa(mcastaddr->sin_addr),
4521
                (int)ntohl(mcastaddr->sin_addr.s_addr));
4522
        return -1;
4523

    
4524
    }
4525
    fd = socket(PF_INET, SOCK_DGRAM, 0);
4526
    if (fd < 0) {
4527
        perror("socket(PF_INET, SOCK_DGRAM)");
4528
        return -1;
4529
    }
4530

    
4531
    val = 1;
4532
    ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4533
                   (const char *)&val, sizeof(val));
4534
    if (ret < 0) {
4535
        perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4536
        goto fail;
4537
    }
4538

    
4539
    ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4540
    if (ret < 0) {
4541
        perror("bind");
4542
        goto fail;
4543
    }
4544

    
4545
    /* Add host to multicast group */
4546
    imr.imr_multiaddr = mcastaddr->sin_addr;
4547
    imr.imr_interface.s_addr = htonl(INADDR_ANY);
4548

    
4549
    ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4550
                     (const char *)&imr, sizeof(struct ip_mreq));
4551
    if (ret < 0) {
4552
        perror("setsockopt(IP_ADD_MEMBERSHIP)");
4553
        goto fail;
4554
    }
4555

    
4556
    /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4557
    val = 1;
4558
    ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4559
                   (const char *)&val, sizeof(val));
4560
    if (ret < 0) {
4561
        perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4562
        goto fail;
4563
    }
4564

    
4565
    socket_set_nonblock(fd);
4566
    return fd;
4567
fail:
4568
    if (fd >= 0)
4569
        closesocket(fd);
4570
    return -1;
4571
}
4572

    
4573
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4574
                                          int is_connected)
4575
{
4576
    struct sockaddr_in saddr;
4577
    int newfd;
4578
    socklen_t saddr_len;
4579
    NetSocketState *s;
4580

    
4581
    /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4582
     * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4583
     * by ONLY ONE process: we must "clone" this dgram socket --jjo
4584
     */
4585

    
4586
    if (is_connected) {
4587
        if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4588
            /* must be bound */
4589
            if (saddr.sin_addr.s_addr==0) {
4590
                fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4591
                        fd);
4592
                return NULL;
4593
            }
4594
            /* clone dgram socket */
4595
            newfd = net_socket_mcast_create(&saddr);
4596
            if (newfd < 0) {
4597
                /* error already reported by net_socket_mcast_create() */
4598
                close(fd);
4599
                return NULL;
4600
            }
4601
            /* clone newfd to fd, close newfd */
4602
            dup2(newfd, fd);
4603
            close(newfd);
4604

    
4605
        } else {
4606
            fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4607
                    fd, strerror(errno));
4608
            return NULL;
4609
        }
4610
    }
4611

    
4612
    s = qemu_mallocz(sizeof(NetSocketState));
4613
    if (!s)
4614
        return NULL;
4615
    s->fd = fd;
4616

    
4617
    s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4618
    qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4619

    
4620
    /* mcast: save bound address as dst */
4621
    if (is_connected) s->dgram_dst=saddr;
4622

    
4623
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4624
            "socket: fd=%d (%s mcast=%s:%d)",
4625
            fd, is_connected? "cloned" : "",
4626
            inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4627
    return s;
4628
}
4629

    
4630
static void net_socket_connect(void *opaque)
4631
{
4632
    NetSocketState *s = opaque;
4633
    qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4634
}
4635

    
4636
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4637
                                          int is_connected)
4638
{
4639
    NetSocketState *s;
4640
    s = qemu_mallocz(sizeof(NetSocketState));
4641
    if (!s)
4642
        return NULL;
4643
    s->fd = fd;
4644
    s->vc = qemu_new_vlan_client(vlan,
4645
                                 net_socket_receive, NULL, s);
4646
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4647
             "socket: fd=%d", fd);
4648
    if (is_connected) {
4649
        net_socket_connect(s);
4650
    } else {
4651
        qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4652
    }
4653
    return s;
4654
}
4655

    
4656
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4657
                                          int is_connected)
4658
{
4659
    int so_type=-1, optlen=sizeof(so_type);
4660

    
4661
    if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4662
        (socklen_t *)&optlen)< 0) {
4663
        fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4664
        return NULL;
4665
    }
4666
    switch(so_type) {
4667
    case SOCK_DGRAM:
4668
        return net_socket_fd_init_dgram(vlan, fd, is_connected);
4669
    case SOCK_STREAM:
4670
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4671
    default:
4672
        /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4673
        fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4674
        return net_socket_fd_init_stream(vlan, fd, is_connected);
4675
    }
4676
    return NULL;
4677
}
4678

    
4679
static void net_socket_accept(void *opaque)
4680
{
4681
    NetSocketListenState *s = opaque;
4682
    NetSocketState *s1;
4683
    struct sockaddr_in saddr;
4684
    socklen_t len;
4685
    int fd;
4686

    
4687
    for(;;) {
4688
        len = sizeof(saddr);
4689
        fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4690
        if (fd < 0 && errno != EINTR) {
4691
            return;
4692
        } else if (fd >= 0) {
4693
            break;
4694
        }
4695
    }
4696
    s1 = net_socket_fd_init(s->vlan, fd, 1);
4697
    if (!s1) {
4698
        closesocket(fd);
4699
    } else {
4700
        snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4701
                 "socket: connection from %s:%d",
4702
                 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4703
    }
4704
}
4705

    
4706
static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4707
{
4708
    NetSocketListenState *s;
4709
    int fd, val, ret;
4710
    struct sockaddr_in saddr;
4711

    
4712
    if (parse_host_port(&saddr, host_str) < 0)
4713
        return -1;
4714

    
4715
    s = qemu_mallocz(sizeof(NetSocketListenState));
4716
    if (!s)
4717
        return -1;
4718

    
4719
    fd = socket(PF_INET, SOCK_STREAM, 0);
4720
    if (fd < 0) {
4721
        perror("socket");
4722
        return -1;
4723
    }
4724
    socket_set_nonblock(fd);
4725

    
4726
    /* allow fast reuse */
4727
    val = 1;
4728
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4729

    
4730
    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4731
    if (ret < 0) {
4732
        perror("bind");
4733
        return -1;
4734
    }
4735
    ret = listen(fd, 0);
4736
    if (ret < 0) {
4737
        perror("listen");
4738
        return -1;
4739
    }
4740
    s->vlan = vlan;
4741
    s->fd = fd;
4742
    qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4743
    return 0;
4744
}
4745

    
4746
static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4747
{
4748
    NetSocketState *s;
4749
    int fd, connected, ret, err;
4750
    struct sockaddr_in saddr;
4751

    
4752
    if (parse_host_port(&saddr, host_str) < 0)
4753
        return -1;
4754

    
4755
    fd = socket(PF_INET, SOCK_STREAM, 0);
4756
    if (fd < 0) {
4757
        perror("socket");
4758
        return -1;
4759
    }
4760
    socket_set_nonblock(fd);
4761

    
4762
    connected = 0;
4763
    for(;;) {
4764
        ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4765
        if (ret < 0) {
4766
            err = socket_error();
4767
            if (err == EINTR || err == EWOULDBLOCK) {
4768
            } else if (err == EINPROGRESS) {
4769
                break;
4770
#ifdef _WIN32
4771
            } else if (err == WSAEALREADY) {
4772
                break;
4773
#endif
4774
            } else {
4775
                perror("connect");
4776
                closesocket(fd);
4777
                return -1;
4778
            }
4779
        } else {
4780
            connected = 1;
4781
            break;
4782
        }
4783
    }
4784
    s = net_socket_fd_init(vlan, fd, connected);
4785
    if (!s)
4786
        return -1;
4787
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4788
             "socket: connect to %s:%d",
4789
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4790
    return 0;
4791
}
4792

    
4793
static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4794
{
4795
    NetSocketState *s;
4796
    int fd;
4797
    struct sockaddr_in saddr;
4798

    
4799
    if (parse_host_port(&saddr, host_str) < 0)
4800
        return -1;
4801

    
4802

    
4803
    fd = net_socket_mcast_create(&saddr);
4804
    if (fd < 0)
4805
        return -1;
4806

    
4807
    s = net_socket_fd_init(vlan, fd, 0);
4808
    if (!s)
4809
        return -1;
4810

    
4811
    s->dgram_dst = saddr;
4812

    
4813
    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4814
             "socket: mcast=%s:%d",
4815
             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4816
    return 0;
4817

    
4818
}
4819

    
4820
static const char *get_opt_name(char *buf, int buf_size, const char *p)
4821
{
4822
    char *q;
4823

    
4824
    q = buf;
4825
    while (*p != '\0' && *p != '=') {
4826
        if (q && (q - buf) < buf_size - 1)
4827
            *q++ = *p;
4828
        p++;
4829
    }
4830
    if (q)
4831
        *q = '\0';
4832

    
4833
    return p;
4834
}
4835

    
4836
static const char *get_opt_value(char *buf, int buf_size, const char *p)
4837
{
4838
    char *q;
4839

    
4840
    q = buf;
4841
    while (*p != '\0') {
4842
        if (*p == ',') {
4843
            if (*(p + 1) != ',')
4844
                break;
4845
            p++;
4846
        }
4847
        if (q && (q - buf) < buf_size - 1)
4848
            *q++ = *p;
4849
        p++;
4850
    }
4851
    if (q)
4852
        *q = '\0';
4853

    
4854
    return p;
4855
}
4856

    
4857
static int get_param_value(char *buf, int buf_size,
4858
                           const char *tag, const char *str)
4859
{
4860
    const char *p;
4861
    char option[128];
4862

    
4863
    p = str;
4864
    for(;;) {
4865
        p = get_opt_name(option, sizeof(option), p);
4866
        if (*p != '=')
4867
            break;
4868
        p++;
4869
        if (!strcmp(tag, option)) {
4870
            (void)get_opt_value(buf, buf_size, p);
4871
            return strlen(buf);
4872
        } else {
4873
            p = get_opt_value(NULL, 0, p);
4874
        }
4875
        if (*p != ',')
4876
            break;
4877
        p++;
4878
    }
4879
    return 0;
4880
}
4881

    
4882
static int check_params(char *buf, int buf_size,
4883
                        char **params, const char *str)
4884
{
4885
    const char *p;
4886
    int i;
4887

    
4888
    p = str;
4889
    for(;;) {
4890
        p = get_opt_name(buf, buf_size, p);
4891
        if (*p != '=')
4892
            return -1;
4893
        p++;
4894
        for(i = 0; params[i] != NULL; i++)
4895
            if (!strcmp(params[i], buf))
4896
                break;
4897
        if (params[i] == NULL)
4898
            return -1;
4899
        p = get_opt_value(NULL, 0, p);
4900
        if (*p != ',')
4901
            break;
4902
        p++;
4903
    }
4904
    return 0;
4905
}
4906

    
4907

    
4908
static int net_client_init(const char *str)
4909
{
4910
    const char *p;
4911
    char *q;
4912
    char device[64];
4913
    char buf[1024];
4914
    int vlan_id, ret;
4915
    VLANState *vlan;
4916

    
4917
    p = str;
4918
    q = device;
4919
    while (*p != '\0' && *p != ',') {
4920
        if ((q - device) < sizeof(device) - 1)
4921
            *q++ = *p;
4922
        p++;
4923
    }
4924
    *q = '\0';
4925
    if (*p == ',')
4926
        p++;
4927
    vlan_id = 0;
4928
    if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4929
        vlan_id = strtol(buf, NULL, 0);
4930
    }
4931
    vlan = qemu_find_vlan(vlan_id);
4932
    if (!vlan) {
4933
        fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4934
        return -1;
4935
    }
4936
    if (!strcmp(device, "nic")) {
4937
        NICInfo *nd;
4938
        uint8_t *macaddr;
4939

    
4940
        if (nb_nics >= MAX_NICS) {
4941
            fprintf(stderr, "Too Many NICs\n");
4942
            return -1;
4943
        }
4944
        nd = &nd_table[nb_nics];
4945
        macaddr = nd->macaddr;
4946
        macaddr[0] = 0x52;
4947
        macaddr[1] = 0x54;
4948
        macaddr[2] = 0x00;
4949
        macaddr[3] = 0x12;
4950
        macaddr[4] = 0x34;
4951
        macaddr[5] = 0x56 + nb_nics;
4952

    
4953
        if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4954
            if (parse_macaddr(macaddr, buf) < 0) {
4955
                fprintf(stderr, "invalid syntax for ethernet address\n");
4956
                return -1;
4957
            }
4958
        }
4959
        if (get_param_value(buf, sizeof(buf), "model", p)) {
4960
            nd->model = strdup(buf);
4961
        }
4962
        nd->vlan = vlan;
4963
        nb_nics++;
4964
        vlan->nb_guest_devs++;
4965
        ret = 0;
4966
    } else
4967
    if (!strcmp(device, "none")) {
4968
        /* does nothing. It is needed to signal that no network cards
4969
           are wanted */
4970
        ret = 0;
4971
    } else
4972
#ifdef CONFIG_SLIRP
4973
    if (!strcmp(device, "user")) {
4974
        if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4975
            pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4976
        }
4977
        vlan->nb_host_devs++;
4978
        ret = net_slirp_init(vlan);
4979
    } else
4980
#endif
4981
#ifdef _WIN32
4982
    if (!strcmp(device, "tap")) {
4983
        char ifname[64];
4984
        if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4985
            fprintf(stderr, "tap: no interface name\n");
4986
            return -1;
4987
        }
4988
        vlan->nb_host_devs++;
4989
        ret = tap_win32_init(vlan, ifname);
4990
    } else
4991
#else
4992
    if (!strcmp(device, "tap")) {
4993
        char ifname[64];
4994
        char setup_script[1024], down_script[1024];
4995
        int fd;
4996
        vlan->nb_host_devs++;
4997
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4998
            fd = strtol(buf, NULL, 0);
4999
            fcntl(fd, F_SETFL, O_NONBLOCK);
5000
            ret = -1;
5001
            if (net_tap_fd_init(vlan, fd))
5002
                ret = 0;
5003
        } else {
5004
            if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
5005
                ifname[0] = '\0';
5006
            }
5007
            if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
5008
                pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
5009
            }
5010
            if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
5011
                pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
5012
            }
5013
            ret = net_tap_init(vlan, ifname, setup_script, down_script);
5014
        }
5015
    } else
5016
#endif
5017
    if (!strcmp(device, "socket")) {
5018
        if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
5019
            int fd;
5020
            fd = strtol(buf, NULL, 0);
5021
            ret = -1;
5022
            if (net_socket_fd_init(vlan, fd, 1))
5023
                ret = 0;
5024
        } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
5025
            ret = net_socket_listen_init(vlan, buf);
5026
        } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
5027
            ret = net_socket_connect_init(vlan, buf);
5028
        } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
5029
            ret = net_socket_mcast_init(vlan, buf);
5030
        } else {
5031
            fprintf(stderr, "Unknown socket options: %s\n", p);
5032
            return -1;
5033
        }
5034
        vlan->nb_host_devs++;
5035
    } else
5036
    {
5037
        fprintf(stderr, "Unknown network device: %s\n", device);
5038
        return -1;
5039
    }
5040
    if (ret < 0) {
5041
        fprintf(stderr, "Could not initialize device '%s'\n", device);
5042
    }
5043

    
5044
    return ret;
5045
}
5046

    
5047
void do_info_network(void)
5048
{
5049
    VLANState *vlan;
5050
    VLANClientState *vc;
5051

    
5052
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
5053
        term_printf("VLAN %d devices:\n", vlan->id);
5054
        for(vc = vlan->first_client; vc != NULL; vc = vc->next)
5055
            term_printf("  %s\n", vc->info_str);
5056
    }
5057
}
5058

    
5059
#define HD_ALIAS "index=%d,media=disk"
5060
#ifdef TARGET_PPC
5061
#define CDROM_ALIAS "index=1,media=cdrom"
5062
#else
5063
#define CDROM_ALIAS "index=2,media=cdrom"
5064
#endif
5065
#define FD_ALIAS "index=%d,if=floppy"
5066
#define PFLASH_ALIAS "if=pflash"
5067
#define MTD_ALIAS "if=mtd"
5068
#define SD_ALIAS "index=0,if=sd"
5069

    
5070
static int drive_add(const char *file, const char *fmt, ...)
5071
{
5072
    va_list ap;
5073

    
5074
    if (nb_drives_opt >= MAX_DRIVES) {
5075
        fprintf(stderr, "qemu: too many drives\n");
5076
        exit(1);
5077
    }
5078

    
5079
    drives_opt[nb_drives_opt].file = file;
5080
    va_start(ap, fmt);
5081
    vsnprintf(drives_opt[nb_drives_opt].opt,
5082
              sizeof(drives_opt[0].opt), fmt, ap);
5083
    va_end(ap);
5084

    
5085
    return nb_drives_opt++;
5086
}
5087

    
5088
int drive_get_index(BlockInterfaceType type, int bus, int unit)
5089
{
5090
    int index;
5091

    
5092
    /* seek interface, bus and unit */
5093

    
5094
    for (index = 0; index < nb_drives; index++)
5095
        if (drives_table[index].type == type &&
5096
            drives_table[index].bus == bus &&
5097
            drives_table[index].unit == unit)
5098
        return index;
5099

    
5100
    return -1;
5101
}
5102

    
5103
int drive_get_max_bus(BlockInterfaceType type)
5104
{
5105
    int max_bus;
5106
    int index;
5107

    
5108
    max_bus = -1;
5109
    for (index = 0; index < nb_drives; index++) {
5110
        if(drives_table[index].type == type &&
5111
           drives_table[index].bus > max_bus)
5112
            max_bus = drives_table[index].bus;
5113
    }
5114
    return max_bus;
5115
}
5116

    
5117
static void bdrv_format_print(void *opaque, const char *name)
5118
{
5119
    fprintf(stderr, " %s", name);
5120
}
5121

    
5122
static int drive_init(struct drive_opt *arg, int snapshot,
5123
                      QEMUMachine *machine)
5124
{
5125
    char buf[128];
5126
    char file[1024];
5127
    char devname[128];
5128
    const char *mediastr = "";
5129
    BlockInterfaceType type;
5130
    enum { MEDIA_DISK, MEDIA_CDROM } media;
5131
    int bus_id, unit_id;
5132
    int cyls, heads, secs, translation;
5133
    BlockDriverState *bdrv;
5134
    BlockDriver *drv = NULL;
5135
    int max_devs;
5136
    int index;
5137
    int cache;
5138
    int bdrv_flags;
5139
    char *str = arg->opt;
5140
    char *params[] = { "bus", "unit", "if", "index", "cyls", "heads",
5141
                       "secs", "trans", "media", "snapshot", "file",
5142
                       "cache", "format", NULL };
5143

    
5144
    if (check_params(buf, sizeof(buf), params, str) < 0) {
5145
         fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
5146
                         buf, str);
5147
         return -1;
5148
    }
5149

    
5150
    file[0] = 0;
5151
    cyls = heads = secs = 0;
5152
    bus_id = 0;
5153
    unit_id = -1;
5154
    translation = BIOS_ATA_TRANSLATION_AUTO;
5155
    index = -1;
5156
    cache = 1;
5157

    
5158
    if (!strcmp(machine->name, "realview") ||
5159
        !strcmp(machine->name, "SS-5") ||
5160
        !strcmp(machine->name, "SS-10") ||
5161
        !strcmp(machine->name, "SS-600MP") ||
5162
        !strcmp(machine->name, "versatilepb") ||
5163
        !strcmp(machine->name, "versatileab")) {
5164
        type = IF_SCSI;
5165
        max_devs = MAX_SCSI_DEVS;
5166
        strcpy(devname, "scsi");
5167
    } else {
5168
        type = IF_IDE;
5169
        max_devs = MAX_IDE_DEVS;
5170
        strcpy(devname, "ide");
5171
    }
5172
    media = MEDIA_DISK;
5173

    
5174
    /* extract parameters */
5175

    
5176
    if (get_param_value(buf, sizeof(buf), "bus", str)) {
5177
        bus_id = strtol(buf, NULL, 0);
5178
        if (bus_id < 0) {
5179
            fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
5180
            return -1;
5181
        }
5182
    }
5183

    
5184
    if (get_param_value(buf, sizeof(buf), "unit", str)) {
5185
        unit_id = strtol(buf, NULL, 0);
5186
        if (unit_id < 0) {
5187
            fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
5188
            return -1;
5189
        }
5190
    }
5191

    
5192
    if (get_param_value(buf, sizeof(buf), "if", str)) {
5193
        pstrcpy(devname, sizeof(devname), buf);
5194
        if (!strcmp(buf, "ide")) {
5195
            type = IF_IDE;
5196
            max_devs = MAX_IDE_DEVS;
5197
        } else if (!strcmp(buf, "scsi")) {
5198
            type = IF_SCSI;
5199
            max_devs = MAX_SCSI_DEVS;
5200
        } else if (!strcmp(buf, "floppy")) {
5201
            type = IF_FLOPPY;
5202
            max_devs = 0;
5203
        } else if (!strcmp(buf, "pflash")) {
5204
            type = IF_PFLASH;
5205
            max_devs = 0;
5206
        } else if (!strcmp(buf, "mtd")) {
5207
            type = IF_MTD;
5208
            max_devs = 0;
5209
        } else if (!strcmp(buf, "sd")) {
5210
            type = IF_SD;
5211
            max_devs = 0;
5212
        } else {
5213
            fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5214
            return -1;
5215
        }
5216
    }
5217

    
5218
    if (get_param_value(buf, sizeof(buf), "index", str)) {
5219
        index = strtol(buf, NULL, 0);
5220
        if (index < 0) {
5221
            fprintf(stderr, "qemu: '%s' invalid index\n", str);
5222
            return -1;
5223
        }
5224
    }
5225

    
5226
    if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5227
        cyls = strtol(buf, NULL, 0);
5228
    }
5229

    
5230
    if (get_param_value(buf, sizeof(buf), "heads", str)) {
5231
        heads = strtol(buf, NULL, 0);
5232
    }
5233

    
5234
    if (get_param_value(buf, sizeof(buf), "secs", str)) {
5235
        secs = strtol(buf, NULL, 0);
5236
    }
5237

    
5238
    if (cyls || heads || secs) {
5239
        if (cyls < 1 || cyls > 16383) {
5240
            fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5241
            return -1;
5242
        }
5243
        if (heads < 1 || heads > 16) {
5244
            fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5245
            return -1;
5246
        }
5247
        if (secs < 1 || secs > 63) {
5248
            fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5249
            return -1;
5250
        }
5251
    }
5252

    
5253
    if (get_param_value(buf, sizeof(buf), "trans", str)) {
5254
        if (!cyls) {
5255
            fprintf(stderr,
5256
                    "qemu: '%s' trans must be used with cyls,heads and secs\n",
5257
                    str);
5258
            return -1;
5259
        }
5260
        if (!strcmp(buf, "none"))
5261
            translation = BIOS_ATA_TRANSLATION_NONE;
5262
        else if (!strcmp(buf, "lba"))
5263
            translation = BIOS_ATA_TRANSLATION_LBA;
5264
        else if (!strcmp(buf, "auto"))
5265
            translation = BIOS_ATA_TRANSLATION_AUTO;
5266
        else {
5267
            fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5268
            return -1;
5269
        }
5270
    }
5271

    
5272
    if (get_param_value(buf, sizeof(buf), "media", str)) {
5273
        if (!strcmp(buf, "disk")) {
5274
            media = MEDIA_DISK;
5275
        } else if (!strcmp(buf, "cdrom")) {
5276
            if (cyls || secs || heads) {
5277
                fprintf(stderr,
5278
                        "qemu: '%s' invalid physical CHS format\n", str);
5279
                return -1;
5280
            }
5281
            media = MEDIA_CDROM;
5282
        } else {
5283
            fprintf(stderr, "qemu: '%s' invalid media\n", str);
5284
            return -1;
5285
        }
5286
    }
5287

    
5288
    if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5289
        if (!strcmp(buf, "on"))
5290
            snapshot = 1;
5291
        else if (!strcmp(buf, "off"))
5292
            snapshot = 0;
5293
        else {
5294
            fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5295
            return -1;
5296
        }
5297
    }
5298

    
5299
    if (get_param_value(buf, sizeof(buf), "cache", str)) {
5300
        if (!strcmp(buf, "off"))
5301
            cache = 0;
5302
        else if (!strcmp(buf, "on"))
5303
            cache = 1;
5304
        else {
5305
           fprintf(stderr, "qemu: invalid cache option\n");
5306
           return -1;
5307
        }
5308
    }
5309

    
5310
    if (get_param_value(buf, sizeof(buf), "format", str)) {
5311
       if (strcmp(buf, "?") == 0) {
5312
            fprintf(stderr, "qemu: Supported formats:");
5313
            bdrv_iterate_format(bdrv_format_print, NULL);
5314
            fprintf(stderr, "\n");
5315
            return -1;
5316
        }
5317
        drv = bdrv_find_format(buf);
5318
        if (!drv) {
5319
            fprintf(stderr, "qemu: '%s' invalid format\n", buf);
5320
            return -1;
5321
        }
5322
    }
5323

    
5324
    if (arg->file == NULL)
5325
        get_param_value(file, sizeof(file), "file", str);
5326
    else
5327
        pstrcpy(file, sizeof(file), arg->file);
5328

    
5329
    /* compute bus and unit according index */
5330

    
5331
    if (index != -1) {
5332
        if (bus_id != 0 || unit_id != -1) {
5333
            fprintf(stderr,
5334
                    "qemu: '%s' index cannot be used with bus and unit\n", str);
5335
            return -1;
5336
        }
5337
        if (max_devs == 0)
5338
        {
5339
            unit_id = index;
5340
            bus_id = 0;
5341
        } else {
5342
            unit_id = index % max_devs;
5343
            bus_id = index / max_devs;
5344
        }
5345
    }
5346

    
5347
    /* if user doesn't specify a unit_id,
5348
     * try to find the first free
5349
     */
5350

    
5351
    if (unit_id == -1) {
5352
       unit_id = 0;
5353
       while (drive_get_index(type, bus_id, unit_id) != -1) {
5354
           unit_id++;
5355
           if (max_devs && unit_id >= max_devs) {
5356
               unit_id -= max_devs;
5357
               bus_id++;
5358
           }
5359
       }
5360
    }
5361

    
5362
    /* check unit id */
5363

    
5364
    if (max_devs && unit_id >= max_devs) {
5365
        fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5366
                        str, unit_id, max_devs - 1);
5367
        return -1;
5368
    }
5369

    
5370
    /*
5371
     * ignore multiple definitions
5372
     */
5373

    
5374
    if (drive_get_index(type, bus_id, unit_id) != -1)
5375
        return 0;
5376

    
5377
    /* init */
5378

    
5379
    if (type == IF_IDE || type == IF_SCSI)
5380
        mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5381
    if (max_devs)
5382
        snprintf(buf, sizeof(buf), "%s%i%s%i",
5383
                 devname, bus_id, mediastr, unit_id);
5384
    else
5385
        snprintf(buf, sizeof(buf), "%s%s%i",
5386
                 devname, mediastr, unit_id);
5387
    bdrv = bdrv_new(buf);
5388
    drives_table[nb_drives].bdrv = bdrv;
5389
    drives_table[nb_drives].type = type;
5390
    drives_table[nb_drives].bus = bus_id;
5391
    drives_table[nb_drives].unit = unit_id;
5392
    nb_drives++;
5393

    
5394
    switch(type) {
5395
    case IF_IDE:
5396
    case IF_SCSI:
5397
        switch(media) {
5398
        case MEDIA_DISK:
5399
            if (cyls != 0) {
5400
                bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5401
                bdrv_set_translation_hint(bdrv, translation);
5402
            }
5403
            break;
5404
        case MEDIA_CDROM:
5405
            bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5406
            break;
5407
        }
5408
        break;
5409
    case IF_SD:
5410
        /* FIXME: This isn't really a floppy, but it's a reasonable
5411
           approximation.  */
5412
    case IF_FLOPPY:
5413
        bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5414
        break;
5415
    case IF_PFLASH:
5416
    case IF_MTD:
5417
        break;
5418
    }
5419
    if (!file[0])
5420
        return 0;
5421
    bdrv_flags = 0;
5422
    if (snapshot)
5423
        bdrv_flags |= BDRV_O_SNAPSHOT;
5424
    if (!cache)
5425
        bdrv_flags |= BDRV_O_DIRECT;
5426
    if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
5427
        fprintf(stderr, "qemu: could not open disk image %s\n",
5428
                        file);
5429
        return -1;
5430
    }
5431
    return 0;
5432
}
5433

    
5434
/***********************************************************/
5435
/* USB devices */
5436

    
5437
static USBPort *used_usb_ports;
5438
static USBPort *free_usb_ports;
5439

    
5440
/* ??? Maybe change this to register a hub to keep track of the topology.  */
5441
void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5442
                            usb_attachfn attach)
5443
{
5444
    port->opaque = opaque;
5445
    port->index = index;
5446
    port->attach = attach;
5447
    port->next = free_usb_ports;
5448
    free_usb_ports = port;
5449
}
5450

    
5451
static int usb_device_add(const char *devname)
5452
{
5453
    const char *p;
5454
    USBDevice *dev;
5455
    USBPort *port;
5456

    
5457
    if (!free_usb_ports)
5458
        return -1;
5459

    
5460
    if (strstart(devname, "host:", &p)) {
5461
        dev = usb_host_device_open(p);
5462
    } else if (!strcmp(devname, "mouse")) {
5463
        dev = usb_mouse_init();
5464
    } else if (!strcmp(devname, "tablet")) {
5465
        dev = usb_tablet_init();
5466
    } else if (!strcmp(devname, "keyboard")) {
5467
        dev = usb_keyboard_init();
5468
    } else if (strstart(devname, "disk:", &p)) {
5469
        dev = usb_msd_init(p);
5470
    } else if (!strcmp(devname, "wacom-tablet")) {
5471
        dev = usb_wacom_init();
5472
    } else if (strstart(devname, "serial:", &p)) {
5473
        dev = usb_serial_init(p);
5474
#ifdef CONFIG_BRLAPI
5475
    } else if (!strcmp(devname, "braille")) {
5476
        dev = usb_baum_init();
5477
#endif
5478
    } else {
5479
        return -1;
5480
    }
5481
    if (!dev)
5482
        return -1;
5483

    
5484
    /* Find a USB port to add the device to.  */
5485
    port = free_usb_ports;
5486
    if (!port->next) {
5487
        USBDevice *hub;
5488

    
5489
        /* Create a new hub and chain it on.  */
5490
        free_usb_ports = NULL;
5491
        port->next = used_usb_ports;
5492
        used_usb_ports = port;
5493

    
5494
        hub = usb_hub_init(VM_USB_HUB_SIZE);
5495
        usb_attach(port, hub);
5496
        port = free_usb_ports;
5497
    }
5498

    
5499
    free_usb_ports = port->next;
5500
    port->next = used_usb_ports;
5501
    used_usb_ports = port;
5502
    usb_attach(port, dev);
5503
    return 0;
5504
}
5505

    
5506
static int usb_device_del(const char *devname)
5507
{
5508
    USBPort *port;
5509
    USBPort **lastp;
5510
    USBDevice *dev;
5511
    int bus_num, addr;
5512
    const char *p;
5513

    
5514
    if (!used_usb_ports)
5515
        return -1;
5516

    
5517
    p = strchr(devname, '.');
5518
    if (!p)
5519
        return -1;
5520
    bus_num = strtoul(devname, NULL, 0);
5521
    addr = strtoul(p + 1, NULL, 0);
5522
    if (bus_num != 0)
5523
        return -1;
5524

    
5525
    lastp = &used_usb_ports;
5526
    port = used_usb_ports;
5527
    while (port && port->dev->addr != addr) {
5528
        lastp = &port->next;
5529
        port = port->next;
5530
    }
5531

    
5532
    if (!port)
5533
        return -1;
5534

    
5535
    dev = port->dev;
5536
    *lastp = port->next;
5537
    usb_attach(port, NULL);
5538
    dev->handle_destroy(dev);
5539
    port->next = free_usb_ports;
5540
    free_usb_ports = port;
5541
    return 0;
5542
}
5543

    
5544
void do_usb_add(const char *devname)
5545
{
5546
    int ret;
5547
    ret = usb_device_add(devname);
5548
    if (ret < 0)
5549
        term_printf("Could not add USB device '%s'\n", devname);
5550
}
5551

    
5552
void do_usb_del(const char *devname)
5553
{
5554
    int ret;
5555
    ret = usb_device_del(devname);
5556
    if (ret < 0)
5557
        term_printf("Could not remove USB device '%s'\n", devname);
5558
}
5559

    
5560
void usb_info(void)
5561
{
5562
    USBDevice *dev;
5563
    USBPort *port;
5564
    const char *speed_str;
5565

    
5566
    if (!usb_enabled) {
5567
        term_printf("USB support not enabled\n");
5568
        return;
5569
    }
5570

    
5571
    for (port = used_usb_ports; port; port = port->next) {
5572
        dev = port->dev;
5573
        if (!dev)
5574
            continue;
5575
        switch(dev->speed) {
5576
        case USB_SPEED_LOW:
5577
            speed_str = "1.5";
5578
            break;
5579
        case USB_SPEED_FULL:
5580
            speed_str = "12";
5581
            break;
5582
        case USB_SPEED_HIGH:
5583
            speed_str = "480";
5584
            break;
5585
        default:
5586
            speed_str = "?";
5587
            break;
5588
        }
5589
        term_printf("  Device %d.%d, Speed %s Mb/s, Product %s\n",
5590
                    0, dev->addr, speed_str, dev->devname);
5591
    }
5592
}
5593

    
5594
/***********************************************************/
5595
/* PCMCIA/Cardbus */
5596

    
5597
static struct pcmcia_socket_entry_s {
5598
    struct pcmcia_socket_s *socket;
5599
    struct pcmcia_socket_entry_s *next;
5600
} *pcmcia_sockets = 0;
5601

    
5602
void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5603
{
5604
    struct pcmcia_socket_entry_s *entry;
5605

    
5606
    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5607
    entry->socket = socket;
5608
    entry->next = pcmcia_sockets;
5609
    pcmcia_sockets = entry;
5610
}
5611

    
5612
void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5613
{
5614
    struct pcmcia_socket_entry_s *entry, **ptr;
5615

    
5616
    ptr = &pcmcia_sockets;
5617
    for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5618
        if (entry->socket == socket) {
5619
            *ptr = entry->next;
5620
            qemu_free(entry);
5621
        }
5622
}
5623

    
5624
void pcmcia_info(void)
5625
{
5626
    struct pcmcia_socket_entry_s *iter;
5627
    if (!pcmcia_sockets)
5628
        term_printf("No PCMCIA sockets\n");
5629

    
5630
    for (iter = pcmcia_sockets; iter; iter = iter->next)
5631
        term_printf("%s: %s\n", iter->socket->slot_string,
5632
                    iter->socket->attached ? iter->socket->card_string :
5633
                    "Empty");
5634
}
5635

    
5636
/***********************************************************/
5637
/* dumb display */
5638

    
5639
static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
5640
{
5641
}
5642

    
5643
static void dumb_resize(DisplayState *ds, int w, int h)
5644
{
5645
}
5646

    
5647
static void dumb_refresh(DisplayState *ds)
5648
{
5649
#if defined(CONFIG_SDL)
5650
    vga_hw_update();
5651
#endif
5652
}
5653

    
5654
static void dumb_display_init(DisplayState *ds)
5655
{
5656
    ds->data = NULL;
5657
    ds->linesize = 0;
5658
    ds->depth = 0;
5659
    ds->dpy_update = dumb_update;
5660
    ds->dpy_resize = dumb_resize;
5661
    ds->dpy_refresh = dumb_refresh;
5662
}
5663

    
5664
/***********************************************************/
5665
/* I/O handling */
5666

    
5667
#define MAX_IO_HANDLERS 64
5668

    
5669
typedef struct IOHandlerRecord {
5670
    int fd;
5671
    IOCanRWHandler *fd_read_poll;
5672
    IOHandler *fd_read;
5673
    IOHandler *fd_write;
5674
    int deleted;
5675
    void *opaque;
5676
    /* temporary data */
5677
    struct pollfd *ufd;
5678
    struct IOHandlerRecord *next;
5679
} IOHandlerRecord;
5680

    
5681
static IOHandlerRecord *first_io_handler;
5682

    
5683
/* XXX: fd_read_poll should be suppressed, but an API change is
5684
   necessary in the character devices to suppress fd_can_read(). */
5685
int qemu_set_fd_handler2(int fd,
5686
                         IOCanRWHandler *fd_read_poll,
5687
                         IOHandler *fd_read,
5688
                         IOHandler *fd_write,
5689
                         void *opaque)
5690
{
5691
    IOHandlerRecord **pioh, *ioh;
5692

    
5693
    if (!fd_read && !fd_write) {
5694
        pioh = &first_io_handler;
5695
        for(;;) {
5696
            ioh = *pioh;
5697
            if (ioh == NULL)
5698
                break;
5699
            if (ioh->fd == fd) {
5700
                ioh->deleted = 1;
5701
                break;
5702
            }
5703
            pioh = &ioh->next;
5704
        }
5705
    } else {
5706
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5707
            if (ioh->fd == fd)
5708
                goto found;
5709
        }
5710
        ioh = qemu_mallocz(sizeof(IOHandlerRecord));
5711
        if (!ioh)
5712
            return -1;
5713
        ioh->next = first_io_handler;
5714
        first_io_handler = ioh;
5715
    found:
5716
        ioh->fd = fd;
5717
        ioh->fd_read_poll = fd_read_poll;
5718
        ioh->fd_read = fd_read;
5719
        ioh->fd_write = fd_write;
5720
        ioh->opaque = opaque;
5721
        ioh->deleted = 0;
5722
    }
5723
    return 0;
5724
}
5725

    
5726
int qemu_set_fd_handler(int fd,
5727
                        IOHandler *fd_read,
5728
                        IOHandler *fd_write,
5729
                        void *opaque)
5730
{
5731
    return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
5732
}
5733

    
5734
/***********************************************************/
5735
/* Polling handling */
5736

    
5737
typedef struct PollingEntry {
5738
    PollingFunc *func;
5739
    void *opaque;
5740
    struct PollingEntry *next;
5741
} PollingEntry;
5742

    
5743
static PollingEntry *first_polling_entry;
5744

    
5745
int qemu_add_polling_cb(PollingFunc *func, void *opaque)
5746
{
5747
    PollingEntry **ppe, *pe;
5748
    pe = qemu_mallocz(sizeof(PollingEntry));
5749
    if (!pe)
5750
        return -1;
5751
    pe->func = func;
5752
    pe->opaque = opaque;
5753
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
5754
    *ppe = pe;
5755
    return 0;
5756
}
5757

    
5758
void qemu_del_polling_cb(PollingFunc *func, void *opaque)
5759
{
5760
    PollingEntry **ppe, *pe;
5761
    for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
5762
        pe = *ppe;
5763
        if (pe->func == func && pe->opaque == opaque) {
5764
            *ppe = pe->next;
5765
            qemu_free(pe);
5766
            break;
5767
        }
5768
    }
5769
}
5770

    
5771
#ifdef _WIN32
5772
/***********************************************************/
5773
/* Wait objects support */
5774
typedef struct WaitObjects {
5775
    int num;
5776
    HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
5777
    WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
5778
    void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
5779
} WaitObjects;
5780

    
5781
static WaitObjects wait_objects = {0};
5782

    
5783
int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5784
{
5785
    WaitObjects *w = &wait_objects;
5786

    
5787
    if (w->num >= MAXIMUM_WAIT_OBJECTS)
5788
        return -1;
5789
    w->events[w->num] = handle;
5790
    w->func[w->num] = func;
5791
    w->opaque[w->num] = opaque;
5792
    w->num++;
5793
    return 0;
5794
}
5795

    
5796
void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5797
{
5798
    int i, found;
5799
    WaitObjects *w = &wait_objects;
5800

    
5801
    found = 0;
5802
    for (i = 0; i < w->num; i++) {
5803
        if (w->events[i] == handle)
5804
            found = 1;
5805
        if (found) {
5806
            w->events[i] = w->events[i + 1];
5807
            w->func[i] = w->func[i + 1];
5808
            w->opaque[i] = w->opaque[i + 1];
5809
        }
5810
    }
5811
    if (found)
5812
        w->num--;
5813
}
5814
#endif
5815

    
5816
/***********************************************************/
5817
/* savevm/loadvm support */
5818

    
5819
#define IO_BUF_SIZE 32768
5820

    
5821
struct QEMUFile {
5822
    FILE *outfile;
5823
    BlockDriverState *bs;
5824
    int is_file;
5825
    int is_writable;
5826
    int64_t base_offset;
5827
    int64_t buf_offset; /* start of buffer when writing, end of buffer
5828
                           when reading */
5829
    int buf_index;
5830
    int buf_size; /* 0 when writing */
5831
    uint8_t buf[IO_BUF_SIZE];
5832
};
5833

    
5834
QEMUFile *qemu_fopen(const char *filename, const char *mode)
5835
{
5836
    QEMUFile *f;
5837

    
5838
    f = qemu_mallocz(sizeof(QEMUFile));
5839
    if (!f)
5840
        return NULL;
5841
    if (!strcmp(mode, "wb")) {
5842
        f->is_writable = 1;
5843
    } else if (!strcmp(mode, "rb")) {
5844
        f->is_writable = 0;
5845
    } else {
5846
        goto fail;
5847
    }
5848
    f->outfile = fopen(filename, mode);
5849
    if (!f->outfile)
5850
        goto fail;
5851
    f->is_file = 1;
5852
    return f;
5853
 fail:
5854
    if (f->outfile)
5855
        fclose(f->outfile);
5856
    qemu_free(f);
5857
    return NULL;
5858
}
5859

    
5860
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5861
{
5862
    QEMUFile *f;
5863

    
5864
    f = qemu_mallocz(sizeof(QEMUFile));
5865
    if (!f)
5866
        return NULL;
5867
    f->is_file = 0;
5868
    f->bs = bs;
5869
    f->is_writable = is_writable;
5870
    f->base_offset = offset;
5871
    return f;
5872
}
5873

    
5874
void qemu_fflush(QEMUFile *f)
5875
{
5876
    if (!f->is_writable)
5877
        return;
5878
    if (f->buf_index > 0) {
5879
        if (f->is_file) {
5880
            fseek(f->outfile, f->buf_offset, SEEK_SET);
5881
            fwrite(f->buf, 1, f->buf_index, f->outfile);
5882
        } else {
5883
            bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
5884
                        f->buf, f->buf_index);
5885
        }
5886
        f->buf_offset += f->buf_index;
5887
        f->buf_index = 0;
5888
    }
5889
}
5890

    
5891
static void qemu_fill_buffer(QEMUFile *f)
5892
{
5893
    int len;
5894

    
5895
    if (f->is_writable)
5896
        return;
5897
    if (f->is_file) {
5898
        fseek(f->outfile, f->buf_offset, SEEK_SET);
5899
        len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
5900
        if (len < 0)
5901
            len = 0;
5902
    } else {
5903
        len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
5904
                         f->buf, IO_BUF_SIZE);
5905
        if (len < 0)
5906
            len = 0;
5907
    }
5908
    f->buf_index = 0;
5909
    f->buf_size = len;
5910
    f->buf_offset += len;
5911
}
5912

    
5913
void qemu_fclose(QEMUFile *f)
5914
{
5915
    if (f->is_writable)
5916
        qemu_fflush(f);
5917
    if (f->is_file) {
5918
        fclose(f->outfile);
5919
    }
5920
    qemu_free(f);
5921
}
5922

    
5923
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
5924
{
5925
    int l;
5926
    while (size > 0) {
5927
        l = IO_BUF_SIZE - f->buf_index;
5928
        if (l > size)
5929
            l = size;
5930
        memcpy(f->buf + f->buf_index, buf, l);
5931
        f->buf_index += l;
5932
        buf += l;
5933
        size -= l;
5934
        if (f->buf_index >= IO_BUF_SIZE)
5935
            qemu_fflush(f);
5936
    }
5937
}
5938

    
5939
void qemu_put_byte(QEMUFile *f, int v)
5940
{
5941
    f->buf[f->buf_index++] = v;
5942
    if (f->buf_index >= IO_BUF_SIZE)
5943
        qemu_fflush(f);
5944
}
5945

    
5946
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
5947
{
5948
    int size, l;
5949

    
5950
    size = size1;
5951
    while (size > 0) {
5952
        l = f->buf_size - f->buf_index;
5953
        if (l == 0) {
5954
            qemu_fill_buffer(f);
5955
            l = f->buf_size - f->buf_index;
5956
            if (l == 0)
5957
                break;
5958
        }
5959
        if (l > size)
5960
            l = size;
5961
        memcpy(buf, f->buf + f->buf_index, l);
5962
        f->buf_index += l;
5963
        buf += l;
5964
        size -= l;
5965
    }
5966
    return size1 - size;
5967
}
5968

    
5969
int qemu_get_byte(QEMUFile *f)
5970
{
5971
    if (f->buf_index >= f->buf_size) {
5972
        qemu_fill_buffer(f);
5973
        if (f->buf_index >= f->buf_size)
5974
            return 0;
5975
    }
5976
    return f->buf[f->buf_index++];
5977
}
5978

    
5979
int64_t qemu_ftell(QEMUFile *f)
5980
{
5981
    return f->buf_offset - f->buf_size + f->buf_index;
5982
}
5983

    
5984
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
5985
{
5986
    if (whence == SEEK_SET) {
5987
        /* nothing to do */
5988
    } else if (whence == SEEK_CUR) {
5989
        pos += qemu_ftell(f);
5990
    } else {
5991
        /* SEEK_END not supported */
5992
        return -1;
5993
    }
5994
    if (f->is_writable) {
5995
        qemu_fflush(f);
5996
        f->buf_offset = pos;
5997
    } else {
5998
        f->buf_offset = pos;
5999
        f->buf_index = 0;
6000
        f->buf_size = 0;
6001
    }
6002
    return pos;
6003
}
6004

    
6005
void qemu_put_be16(QEMUFile *f, unsigned int v)
6006
{
6007
    qemu_put_byte(f, v >> 8);
6008
    qemu_put_byte(f, v);
6009
}
6010

    
6011
void qemu_put_be32(QEMUFile *f, unsigned int v)
6012
{
6013
    qemu_put_byte(f, v >> 24);
6014
    qemu_put_byte(f, v >> 16);
6015
    qemu_put_byte(f, v >> 8);
6016
    qemu_put_byte(f, v);
6017
}
6018

    
6019
void qemu_put_be64(QEMUFile *f, uint64_t v)
6020
{
6021
    qemu_put_be32(f, v >> 32);
6022
    qemu_put_be32(f, v);
6023
}
6024

    
6025
unsigned int qemu_get_be16(QEMUFile *f)
6026
{
6027
    unsigned int v;
6028
    v = qemu_get_byte(f) << 8;
6029
    v |= qemu_get_byte(f);
6030
    return v;
6031
}
6032

    
6033
unsigned int qemu_get_be32(QEMUFile *f)
6034
{
6035
    unsigned int v;
6036
    v = qemu_get_byte(f) << 24;
6037
    v |= qemu_get_byte(f) << 16;
6038
    v |= qemu_get_byte(f) << 8;
6039
    v |= qemu_get_byte(f);
6040
    return v;
6041
}
6042

    
6043
uint64_t qemu_get_be64(QEMUFile *f)
6044
{
6045
    uint64_t v;
6046
    v = (uint64_t)qemu_get_be32(f) << 32;
6047
    v |= qemu_get_be32(f);
6048
    return v;
6049
}
6050

    
6051
typedef struct SaveStateEntry {
6052
    char idstr[256];
6053
    int instance_id;
6054
    int version_id;
6055
    SaveStateHandler *save_state;
6056
    LoadStateHandler *load_state;
6057
    void *opaque;
6058
    struct SaveStateEntry *next;
6059
} SaveStateEntry;
6060

    
6061
static SaveStateEntry *first_se;
6062

    
6063
int register_savevm(const char *idstr,
6064
                    int instance_id,
6065
                    int version_id,
6066
                    SaveStateHandler *save_state,
6067
                    LoadStateHandler *load_state,
6068
                    void *opaque)
6069
{
6070
    SaveStateEntry *se, **pse;
6071

    
6072
    se = qemu_malloc(sizeof(SaveStateEntry));
6073
    if (!se)
6074
        return -1;
6075
    pstrcpy(se->idstr, sizeof(se->idstr), idstr);
6076
    se->instance_id = instance_id;
6077
    se->version_id = version_id;
6078
    se->save_state = save_state;
6079
    se->load_state = load_state;
6080
    se->opaque = opaque;
6081
    se->next = NULL;
6082

    
6083
    /* add at the end of list */
6084
    pse = &first_se;
6085
    while (*pse != NULL)
6086
        pse = &(*pse)->next;
6087
    *pse = se;
6088
    return 0;
6089
}
6090

    
6091
#define QEMU_VM_FILE_MAGIC   0x5145564d
6092
#define QEMU_VM_FILE_VERSION 0x00000002
6093

    
6094
static int qemu_savevm_state(QEMUFile *f)
6095
{
6096
    SaveStateEntry *se;
6097
    int len, ret;
6098
    int64_t cur_pos, len_pos, total_len_pos;
6099

    
6100
    qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
6101
    qemu_put_be32(f, QEMU_VM_FILE_VERSION);
6102
    total_len_pos = qemu_ftell(f);
6103
    qemu_put_be64(f, 0); /* total size */
6104

    
6105
    for(se = first_se; se != NULL; se = se->next) {
6106
        if (se->save_state == NULL)
6107
            /* this one has a loader only, for backwards compatibility */
6108
            continue;
6109

    
6110
        /* ID string */
6111
        len = strlen(se->idstr);
6112
        qemu_put_byte(f, len);
6113
        qemu_put_buffer(f, (uint8_t *)se->idstr, len);
6114

    
6115
        qemu_put_be32(f, se->instance_id);
6116
        qemu_put_be32(f, se->version_id);
6117

    
6118
        /* record size: filled later */
6119
        len_pos = qemu_ftell(f);
6120
        qemu_put_be32(f, 0);
6121
        se->save_state(f, se->opaque);
6122

    
6123
        /* fill record size */
6124
        cur_pos = qemu_ftell(f);
6125
        len = cur_pos - len_pos - 4;
6126
        qemu_fseek(f, len_pos, SEEK_SET);
6127
        qemu_put_be32(f, len);
6128
        qemu_fseek(f, cur_pos, SEEK_SET);
6129
    }
6130
    cur_pos = qemu_ftell(f);
6131
    qemu_fseek(f, total_len_pos, SEEK_SET);
6132
    qemu_put_be64(f, cur_pos - total_len_pos - 8);
6133
    qemu_fseek(f, cur_pos, SEEK_SET);
6134

    
6135
    ret = 0;
6136
    return ret;
6137
}
6138

    
6139
static SaveStateEntry *find_se(const char *idstr, int instance_id)
6140
{
6141
    SaveStateEntry *se;
6142

    
6143
    for(se = first_se; se != NULL; se = se->next) {
6144
        if (!strcmp(se->idstr, idstr) &&
6145
            instance_id == se->instance_id)
6146
            return se;
6147
    }
6148
    return NULL;
6149
}
6150

    
6151
static int qemu_loadvm_state(QEMUFile *f)
6152
{
6153
    SaveStateEntry *se;
6154
    int len, ret, instance_id, record_len, version_id;
6155
    int64_t total_len, end_pos, cur_pos;
6156
    unsigned int v;
6157
    char idstr[256];
6158

    
6159
    v = qemu_get_be32(f);
6160
    if (v != QEMU_VM_FILE_MAGIC)
6161
        goto fail;
6162
    v = qemu_get_be32(f);
6163
    if (v != QEMU_VM_FILE_VERSION) {
6164
    fail:
6165
        ret = -1;
6166
        goto the_end;
6167
    }
6168
    total_len = qemu_get_be64(f);
6169
    end_pos = total_len + qemu_ftell(f);
6170
    for(;;) {
6171
        if (qemu_ftell(f) >= end_pos)
6172
            break;
6173
        len = qemu_get_byte(f);
6174
        qemu_get_buffer(f, (uint8_t *)idstr, len);
6175
        idstr[len] = '\0';
6176
        instance_id = qemu_get_be32(f);
6177
        version_id = qemu_get_be32(f);
6178
        record_len = qemu_get_be32(f);
6179
#if 0
6180
        printf("idstr=%s instance=0x%x version=%d len=%d\n",
6181
               idstr, instance_id, version_id, record_len);
6182
#endif
6183
        cur_pos = qemu_ftell(f);
6184
        se = find_se(idstr, instance_id);
6185
        if (!se) {
6186
            fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6187
                    instance_id, idstr);
6188
        } else {
6189
            ret = se->load_state(f, se->opaque, version_id);
6190
            if (ret < 0) {
6191
                fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6192
                        instance_id, idstr);
6193
            }
6194
        }
6195
        /* always seek to exact end of record */
6196
        qemu_fseek(f, cur_pos + record_len, SEEK_SET);
6197
    }
6198
    ret = 0;
6199
 the_end:
6200
    return ret;
6201
}
6202

    
6203
/* device can contain snapshots */
6204
static int bdrv_can_snapshot(BlockDriverState *bs)
6205
{
6206
    return (bs &&
6207
            !bdrv_is_removable(bs) &&
6208
            !bdrv_is_read_only(bs));
6209
}
6210

    
6211
/* device must be snapshots in order to have a reliable snapshot */
6212
static int bdrv_has_snapshot(BlockDriverState *bs)
6213
{
6214
    return (bs &&
6215
            !bdrv_is_removable(bs) &&
6216
            !bdrv_is_read_only(bs));
6217
}
6218

    
6219
static BlockDriverState *get_bs_snapshots(void)
6220
{
6221
    BlockDriverState *bs;
6222
    int i;
6223

    
6224
    if (bs_snapshots)
6225
        return bs_snapshots;
6226
    for(i = 0; i <= nb_drives; i++) {
6227
        bs = drives_table[i].bdrv;
6228
        if (bdrv_can_snapshot(bs))
6229
            goto ok;
6230
    }
6231
    return NULL;
6232
 ok:
6233
    bs_snapshots = bs;
6234
    return bs;
6235
}
6236

    
6237
static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6238
                              const char *name)
6239
{
6240
    QEMUSnapshotInfo *sn_tab, *sn;
6241
    int nb_sns, i, ret;
6242

    
6243
    ret = -ENOENT;
6244
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6245
    if (nb_sns < 0)
6246
        return ret;
6247
    for(i = 0; i < nb_sns; i++) {
6248
        sn = &sn_tab[i];
6249
        if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6250
            *sn_info = *sn;
6251
            ret = 0;
6252
            break;
6253
        }
6254
    }
6255
    qemu_free(sn_tab);
6256
    return ret;
6257
}
6258

    
6259
void do_savevm(const char *name)
6260
{
6261
    BlockDriverState *bs, *bs1;
6262
    QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6263
    int must_delete, ret, i;
6264
    BlockDriverInfo bdi1, *bdi = &bdi1;
6265
    QEMUFile *f;
6266
    int saved_vm_running;
6267
#ifdef _WIN32
6268
    struct _timeb tb;
6269
#else
6270
    struct timeval tv;
6271
#endif
6272

    
6273
    bs = get_bs_snapshots();
6274
    if (!bs) {
6275
        term_printf("No block device can accept snapshots\n");
6276
        return;
6277
    }
6278

    
6279
    /* ??? Should this occur after vm_stop?  */
6280
    qemu_aio_flush();
6281

    
6282
    saved_vm_running = vm_running;
6283
    vm_stop(0);
6284

    
6285
    must_delete = 0;
6286
    if (name) {
6287
        ret = bdrv_snapshot_find(bs, old_sn, name);
6288
        if (ret >= 0) {
6289
            must_delete = 1;
6290
        }
6291
    }
6292
    memset(sn, 0, sizeof(*sn));
6293
    if (must_delete) {
6294
        pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6295
        pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6296
    } else {
6297
        if (name)
6298
            pstrcpy(sn->name, sizeof(sn->name), name);
6299
    }
6300

    
6301
    /* fill auxiliary fields */
6302
#ifdef _WIN32
6303
    _ftime(&tb);
6304
    sn->date_sec = tb.time;
6305
    sn->date_nsec = tb.millitm * 1000000;
6306
#else
6307
    gettimeofday(&tv, NULL);
6308
    sn->date_sec = tv.tv_sec;
6309
    sn->date_nsec = tv.tv_usec * 1000;
6310
#endif
6311
    sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6312

    
6313
    if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6314
        term_printf("Device %s does not support VM state snapshots\n",
6315
                    bdrv_get_device_name(bs));
6316
        goto the_end;
6317
    }
6318

    
6319
    /* save the VM state */
6320
    f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6321
    if (!f) {
6322
        term_printf("Could not open VM state file\n");
6323
        goto the_end;
6324
    }
6325
    ret = qemu_savevm_state(f);
6326
    sn->vm_state_size = qemu_ftell(f);
6327
    qemu_fclose(f);
6328
    if (ret < 0) {
6329
        term_printf("Error %d while writing VM\n", ret);
6330
        goto the_end;
6331
    }
6332

    
6333
    /* create the snapshots */
6334

    
6335
    for(i = 0; i < nb_drives; i++) {
6336
        bs1 = drives_table[i].bdrv;
6337
        if (bdrv_has_snapshot(bs1)) {
6338
            if (must_delete) {
6339
                ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6340
                if (ret < 0) {
6341
                    term_printf("Error while deleting snapshot on '%s'\n",
6342
                                bdrv_get_device_name(bs1));
6343
                }
6344
            }
6345
            ret = bdrv_snapshot_create(bs1, sn);
6346
            if (ret < 0) {
6347
                term_printf("Error while creating snapshot on '%s'\n",
6348
                            bdrv_get_device_name(bs1));
6349
            }
6350
        }
6351
    }
6352

    
6353
 the_end:
6354
    if (saved_vm_running)
6355
        vm_start();
6356
}
6357

    
6358
void do_loadvm(const char *name)
6359
{
6360
    BlockDriverState *bs, *bs1;
6361
    BlockDriverInfo bdi1, *bdi = &bdi1;
6362
    QEMUFile *f;
6363
    int i, ret;
6364
    int saved_vm_running;
6365

    
6366
    bs = get_bs_snapshots();
6367
    if (!bs) {
6368
        term_printf("No block device supports snapshots\n");
6369
        return;
6370
    }
6371

    
6372
    /* Flush all IO requests so they don't interfere with the new state.  */
6373
    qemu_aio_flush();
6374

    
6375
    saved_vm_running = vm_running;
6376
    vm_stop(0);
6377

    
6378
    for(i = 0; i <= nb_drives; i++) {
6379
        bs1 = drives_table[i].bdrv;
6380
        if (bdrv_has_snapshot(bs1)) {
6381
            ret = bdrv_snapshot_goto(bs1, name);
6382
            if (ret < 0) {
6383
                if (bs != bs1)
6384
                    term_printf("Warning: ");
6385
                switch(ret) {
6386
                case -ENOTSUP:
6387
                    term_printf("Snapshots not supported on device '%s'\n",
6388
                                bdrv_get_device_name(bs1));
6389
                    break;
6390
                case -ENOENT:
6391
                    term_printf("Could not find snapshot '%s' on device '%s'\n",
6392
                                name, bdrv_get_device_name(bs1));
6393
                    break;
6394
                default:
6395
                    term_printf("Error %d while activating snapshot on '%s'\n",
6396
                                ret, bdrv_get_device_name(bs1));
6397
                    break;
6398
                }
6399
                /* fatal on snapshot block device */
6400
                if (bs == bs1)
6401
                    goto the_end;
6402
            }
6403
        }
6404
    }
6405

    
6406
    if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6407
        term_printf("Device %s does not support VM state snapshots\n",
6408
                    bdrv_get_device_name(bs));
6409
        return;
6410
    }
6411

    
6412
    /* restore the VM state */
6413
    f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6414
    if (!f) {
6415
        term_printf("Could not open VM state file\n");
6416
        goto the_end;
6417
    }
6418
    ret = qemu_loadvm_state(f);
6419
    qemu_fclose(f);
6420
    if (ret < 0) {
6421
        term_printf("Error %d while loading VM state\n", ret);
6422
    }
6423
 the_end:
6424
    if (saved_vm_running)
6425
        vm_start();
6426
}
6427

    
6428
void do_delvm(const char *name)
6429
{
6430
    BlockDriverState *bs, *bs1;
6431
    int i, ret;
6432

    
6433
    bs = get_bs_snapshots();
6434
    if (!bs) {
6435
        term_printf("No block device supports snapshots\n");
6436
        return;
6437
    }
6438

    
6439
    for(i = 0; i <= nb_drives; i++) {
6440
        bs1 = drives_table[i].bdrv;
6441
        if (bdrv_has_snapshot(bs1)) {
6442
            ret = bdrv_snapshot_delete(bs1, name);
6443
            if (ret < 0) {
6444
                if (ret == -ENOTSUP)
6445
                    term_printf("Snapshots not supported on device '%s'\n",
6446
                                bdrv_get_device_name(bs1));
6447
                else
6448
                    term_printf("Error %d while deleting snapshot on '%s'\n",
6449
                                ret, bdrv_get_device_name(bs1));
6450
            }
6451
        }
6452
    }
6453
}
6454

    
6455
void do_info_snapshots(void)
6456
{
6457
    BlockDriverState *bs, *bs1;
6458
    QEMUSnapshotInfo *sn_tab, *sn;
6459
    int nb_sns, i;
6460
    char buf[256];
6461

    
6462
    bs = get_bs_snapshots();
6463
    if (!bs) {
6464
        term_printf("No available block device supports snapshots\n");
6465
        return;
6466
    }
6467
    term_printf("Snapshot devices:");
6468
    for(i = 0; i <= nb_drives; i++) {
6469
        bs1 = drives_table[i].bdrv;
6470
        if (bdrv_has_snapshot(bs1)) {
6471
            if (bs == bs1)
6472
                term_printf(" %s", bdrv_get_device_name(bs1));
6473
        }
6474
    }
6475
    term_printf("\n");
6476

    
6477
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6478
    if (nb_sns < 0) {
6479
        term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
6480
        return;
6481
    }
6482
    term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
6483
    term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
6484
    for(i = 0; i < nb_sns; i++) {
6485
        sn = &sn_tab[i];
6486
        term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
6487
    }
6488
    qemu_free(sn_tab);
6489
}
6490

    
6491
/***********************************************************/
6492
/* ram save/restore */
6493

    
6494
static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
6495
{
6496
    int v;
6497

    
6498
    v = qemu_get_byte(f);
6499
    switch(v) {
6500
    case 0:
6501
        if (qemu_get_buffer(f, buf, len) != len)
6502
            return -EIO;
6503
        break;
6504
    case 1:
6505
        v = qemu_get_byte(f);
6506
        memset(buf, v, len);
6507
        break;
6508
    default:
6509
        return -EINVAL;
6510
    }
6511
    return 0;
6512
}
6513

    
6514
static int ram_load_v1(QEMUFile *f, void *opaque)
6515
{
6516
    int ret;
6517
    ram_addr_t i;
6518

    
6519
    if (qemu_get_be32(f) != phys_ram_size)
6520
        return -EINVAL;
6521
    for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
6522
        ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
6523
        if (ret)
6524
            return ret;
6525
    }
6526
    return 0;
6527
}
6528

    
6529
#define BDRV_HASH_BLOCK_SIZE 1024
6530
#define IOBUF_SIZE 4096
6531
#define RAM_CBLOCK_MAGIC 0xfabe
6532

    
6533
typedef struct RamCompressState {
6534
    z_stream zstream;
6535
    QEMUFile *f;
6536
    uint8_t buf[IOBUF_SIZE];
6537
} RamCompressState;
6538

    
6539
static int ram_compress_open(RamCompressState *s, QEMUFile *f)
6540
{
6541
    int ret;
6542
    memset(s, 0, sizeof(*s));
6543
    s->f = f;
6544
    ret = deflateInit2(&s->zstream, 1,
6545
                       Z_DEFLATED, 15,
6546
                       9, Z_DEFAULT_STRATEGY);
6547
    if (ret != Z_OK)
6548
        return -1;
6549
    s->zstream.avail_out = IOBUF_SIZE;
6550
    s->zstream.next_out = s->buf;
6551
    return 0;
6552
}
6553

    
6554
static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
6555
{
6556
    qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
6557
    qemu_put_be16(s->f, len);
6558
    qemu_put_buffer(s->f, buf, len);
6559
}
6560

    
6561
static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
6562
{
6563
    int ret;
6564

    
6565
    s->zstream.avail_in = len;
6566
    s->zstream.next_in = (uint8_t *)buf;
6567
    while (s->zstream.avail_in > 0) {
6568
        ret = deflate(&s->zstream, Z_NO_FLUSH);
6569
        if (ret != Z_OK)
6570
            return -1;
6571
        if (s->zstream.avail_out == 0) {
6572
            ram_put_cblock(s, s->buf, IOBUF_SIZE);
6573
            s->zstream.avail_out = IOBUF_SIZE;
6574
            s->zstream.next_out = s->buf;
6575
        }
6576
    }
6577
    return 0;
6578
}
6579

    
6580
static void ram_compress_close(RamCompressState *s)
6581
{
6582
    int len, ret;
6583

    
6584
    /* compress last bytes */
6585
    for(;;) {
6586
        ret = deflate(&s->zstream, Z_FINISH);
6587
        if (ret == Z_OK || ret == Z_STREAM_END) {
6588
            len = IOBUF_SIZE - s->zstream.avail_out;
6589
            if (len > 0) {
6590
                ram_put_cblock(s, s->buf, len);
6591
            }
6592
            s->zstream.avail_out = IOBUF_SIZE;
6593
            s->zstream.next_out = s->buf;
6594
            if (ret == Z_STREAM_END)
6595
                break;
6596
        } else {
6597
            goto fail;
6598
        }
6599
    }
6600
fail:
6601
    deflateEnd(&s->zstream);
6602
}
6603

    
6604
typedef struct RamDecompressState {
6605
    z_stream zstream;
6606
    QEMUFile *f;
6607
    uint8_t buf[IOBUF_SIZE];
6608
} RamDecompressState;
6609

    
6610
static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
6611
{
6612
    int ret;
6613
    memset(s, 0, sizeof(*s));
6614
    s->f = f;
6615
    ret = inflateInit(&s->zstream);
6616
    if (ret != Z_OK)
6617
        return -1;
6618
    return 0;
6619
}
6620

    
6621
static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
6622
{
6623
    int ret, clen;
6624

    
6625
    s->zstream.avail_out = len;
6626
    s->zstream.next_out = buf;
6627
    while (s->zstream.avail_out > 0) {
6628
        if (s->zstream.avail_in == 0) {
6629
            if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
6630
                return -1;
6631
            clen = qemu_get_be16(s->f);
6632
            if (clen > IOBUF_SIZE)
6633
                return -1;
6634
            qemu_get_buffer(s->f, s->buf, clen);
6635
            s->zstream.avail_in = clen;
6636
            s->zstream.next_in = s->buf;
6637
        }
6638
        ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
6639
        if (ret != Z_OK && ret != Z_STREAM_END) {
6640
            return -1;
6641
        }
6642
    }
6643
    return 0;
6644
}
6645

    
6646
static void ram_decompress_close(RamDecompressState *s)
6647
{
6648
    inflateEnd(&s->zstream);
6649
}
6650

    
6651
static void ram_save(QEMUFile *f, void *opaque)
6652
{
6653
    ram_addr_t i;
6654
    RamCompressState s1, *s = &s1;
6655
    uint8_t buf[10];
6656

    
6657
    qemu_put_be32(f, phys_ram_size);
6658
    if (ram_compress_open(s, f) < 0)
6659
        return;
6660
    for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6661
#if 0
6662
        if (tight_savevm_enabled) {
6663
            int64_t sector_num;
6664
            int j;
6665

6666
            /* find if the memory block is available on a virtual
6667
               block device */
6668
            sector_num = -1;
6669
            for(j = 0; j < nb_drives; j++) {
6670
                sector_num = bdrv_hash_find(drives_table[j].bdrv,
6671
                                            phys_ram_base + i,
6672
                                            BDRV_HASH_BLOCK_SIZE);
6673
                if (sector_num >= 0)
6674
                    break;
6675
            }
6676
            if (j == nb_drives)
6677
                goto normal_compress;
6678
            buf[0] = 1;
6679
            buf[1] = j;
6680
            cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
6681
            ram_compress_buf(s, buf, 10);
6682
        } else
6683
#endif
6684
        {
6685
            //        normal_compress:
6686
            buf[0] = 0;
6687
            ram_compress_buf(s, buf, 1);
6688
            ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
6689
        }
6690
    }
6691
    ram_compress_close(s);
6692
}
6693

    
6694
static int ram_load(QEMUFile *f, void *opaque, int version_id)
6695
{
6696
    RamDecompressState s1, *s = &s1;
6697
    uint8_t buf[10];
6698
    ram_addr_t i;
6699

    
6700
    if (version_id == 1)
6701
        return ram_load_v1(f, opaque);
6702
    if (version_id != 2)
6703
        return -EINVAL;
6704
    if (qemu_get_be32(f) != phys_ram_size)
6705
        return -EINVAL;
6706
    if (ram_decompress_open(s, f) < 0)
6707
        return -EINVAL;
6708
    for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6709
        if (ram_decompress_buf(s, buf, 1) < 0) {
6710
            fprintf(stderr, "Error while reading ram block header\n");
6711
            goto error;
6712
        }
6713
        if (buf[0] == 0) {
6714
            if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
6715
                fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
6716
                goto error;
6717
            }
6718
        } else
6719
#if 0
6720
        if (buf[0] == 1) {
6721
            int bs_index;
6722
            int64_t sector_num;
6723

6724
            ram_decompress_buf(s, buf + 1, 9);
6725
            bs_index = buf[1];
6726
            sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
6727
            if (bs_index >= nb_drives) {
6728
                fprintf(stderr, "Invalid block device index %d\n", bs_index);
6729
                goto error;
6730
            }
6731
            if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
6732
                          phys_ram_base + i,
6733
                          BDRV_HASH_BLOCK_SIZE / 512) < 0) {
6734
                fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
6735
                        bs_index, sector_num);
6736
                goto error;
6737
            }
6738
        } else
6739
#endif
6740
        {
6741
        error:
6742
            printf("Error block header\n");
6743
            return -EINVAL;
6744
        }
6745
    }
6746
    ram_decompress_close(s);
6747
    return 0;
6748
}
6749

    
6750
/***********************************************************/
6751
/* bottom halves (can be seen as timers which expire ASAP) */
6752

    
6753
struct QEMUBH {
6754
    QEMUBHFunc *cb;
6755
    void *opaque;
6756
    int scheduled;
6757
    QEMUBH *next;
6758
};
6759

    
6760
static QEMUBH *first_bh = NULL;
6761

    
6762
QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
6763
{
6764
    QEMUBH *bh;
6765
    bh = qemu_mallocz(sizeof(QEMUBH));
6766
    if (!bh)
6767
        return NULL;
6768
    bh->cb = cb;
6769
    bh->opaque = opaque;
6770
    return bh;
6771
}
6772

    
6773
int qemu_bh_poll(void)
6774
{
6775
    QEMUBH *bh, **pbh;
6776
    int ret;
6777

    
6778
    ret = 0;
6779
    for(;;) {
6780
        pbh = &first_bh;
6781
        bh = *pbh;
6782
        if (!bh)
6783
            break;
6784
        ret = 1;
6785
        *pbh = bh->next;
6786
        bh->scheduled = 0;
6787
        bh->cb(bh->opaque);
6788
    }
6789
    return ret;
6790
}
6791

    
6792
void qemu_bh_schedule(QEMUBH *bh)
6793
{
6794
    CPUState *env = cpu_single_env;
6795
    if (bh->scheduled)
6796
        return;
6797
    bh->scheduled = 1;
6798
    bh->next = first_bh;
6799
    first_bh = bh;
6800

    
6801
    /* stop the currently executing CPU to execute the BH ASAP */
6802
    if (env) {
6803
        cpu_interrupt(env, CPU_INTERRUPT_EXIT);
6804
    }
6805
}
6806

    
6807
void qemu_bh_cancel(QEMUBH *bh)
6808
{
6809
    QEMUBH **pbh;
6810
    if (bh->scheduled) {
6811
        pbh = &first_bh;
6812
        while (*pbh != bh)
6813
            pbh = &(*pbh)->next;
6814
        *pbh = bh->next;
6815
        bh->scheduled = 0;
6816
    }
6817
}
6818

    
6819
void qemu_bh_delete(QEMUBH *bh)
6820
{
6821
    qemu_bh_cancel(bh);
6822
    qemu_free(bh);
6823
}
6824

    
6825
/***********************************************************/
6826
/* machine registration */
6827

    
6828
QEMUMachine *first_machine = NULL;
6829

    
6830
int qemu_register_machine(QEMUMachine *m)
6831
{
6832
    QEMUMachine **pm;
6833
    pm = &first_machine;
6834
    while (*pm != NULL)
6835
        pm = &(*pm)->next;
6836
    m->next = NULL;
6837
    *pm = m;
6838
    return 0;
6839
}
6840

    
6841
static QEMUMachine *find_machine(const char *name)
6842
{
6843
    QEMUMachine *m;
6844

    
6845
    for(m = first_machine; m != NULL; m = m->next) {
6846
        if (!strcmp(m->name, name))
6847
            return m;
6848
    }
6849
    return NULL;
6850
}
6851

    
6852
/***********************************************************/
6853
/* main execution loop */
6854

    
6855
static void gui_update(void *opaque)
6856
{
6857
    DisplayState *ds = opaque;
6858
    ds->dpy_refresh(ds);
6859
    qemu_mod_timer(ds->gui_timer,
6860
        (ds->gui_timer_interval ?
6861
            ds->gui_timer_interval :
6862
            GUI_REFRESH_INTERVAL)
6863
        + qemu_get_clock(rt_clock));
6864
}
6865

    
6866
struct vm_change_state_entry {
6867
    VMChangeStateHandler *cb;
6868
    void *opaque;
6869
    LIST_ENTRY (vm_change_state_entry) entries;
6870
};
6871

    
6872
static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
6873

    
6874
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
6875
                                                     void *opaque)
6876
{
6877
    VMChangeStateEntry *e;
6878

    
6879
    e = qemu_mallocz(sizeof (*e));
6880
    if (!e)
6881
        return NULL;
6882

    
6883
    e->cb = cb;
6884
    e->opaque = opaque;
6885
    LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
6886
    return e;
6887
}
6888

    
6889
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
6890
{
6891
    LIST_REMOVE (e, entries);
6892
    qemu_free (e);
6893
}
6894

    
6895
static void vm_state_notify(int running)
6896
{
6897
    VMChangeStateEntry *e;
6898

    
6899
    for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
6900
        e->cb(e->opaque, running);
6901
    }
6902
}
6903

    
6904
/* XXX: support several handlers */
6905
static VMStopHandler *vm_stop_cb;
6906
static void *vm_stop_opaque;
6907

    
6908
int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
6909
{
6910
    vm_stop_cb = cb;
6911
    vm_stop_opaque = opaque;
6912
    return 0;
6913
}
6914

    
6915
void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
6916
{
6917
    vm_stop_cb = NULL;
6918
}
6919

    
6920
void vm_start(void)
6921
{
6922
    if (!vm_running) {
6923
        cpu_enable_ticks();
6924
        vm_running = 1;
6925
        vm_state_notify(1);
6926
        qemu_rearm_alarm_timer(alarm_timer);
6927
    }
6928
}
6929

    
6930
void vm_stop(int reason)
6931
{
6932
    if (vm_running) {
6933
        cpu_disable_ticks();
6934
        vm_running = 0;
6935
        if (reason != 0) {
6936
            if (vm_stop_cb) {
6937
                vm_stop_cb(vm_stop_opaque, reason);
6938
            }
6939
        }
6940
        vm_state_notify(0);
6941
    }
6942
}
6943

    
6944
/* reset/shutdown handler */
6945

    
6946
typedef struct QEMUResetEntry {
6947
    QEMUResetHandler *func;
6948
    void *opaque;
6949
    struct QEMUResetEntry *next;
6950
} QEMUResetEntry;
6951

    
6952
static QEMUResetEntry *first_reset_entry;
6953
static int reset_requested;
6954
static int shutdown_requested;
6955
static int powerdown_requested;
6956

    
6957
int qemu_shutdown_requested(void)
6958
{
6959
    int r = shutdown_requested;
6960
    shutdown_requested = 0;
6961
    return r;
6962
}
6963

    
6964
int qemu_reset_requested(void)
6965
{
6966
    int r = reset_requested;
6967
    reset_requested = 0;
6968
    return r;
6969
}
6970

    
6971
int qemu_powerdown_requested(void)
6972
{
6973
    int r = powerdown_requested;
6974
    powerdown_requested = 0;
6975
    return r;
6976
}
6977

    
6978
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
6979
{
6980
    QEMUResetEntry **pre, *re;
6981

    
6982
    pre = &first_reset_entry;
6983
    while (*pre != NULL)
6984
        pre = &(*pre)->next;
6985
    re = qemu_mallocz(sizeof(QEMUResetEntry));
6986
    re->func = func;
6987
    re->opaque = opaque;
6988
    re->next = NULL;
6989
    *pre = re;
6990
}
6991

    
6992
void qemu_system_reset(void)
6993
{
6994
    QEMUResetEntry *re;
6995

    
6996
    /* reset all devices */
6997
    for(re = first_reset_entry; re != NULL; re = re->next) {
6998
        re->func(re->opaque);
6999
    }
7000
}
7001

    
7002
void qemu_system_reset_request(void)
7003
{
7004
    if (no_reboot) {
7005
        shutdown_requested = 1;
7006
    } else {
7007
        reset_requested = 1;
7008
    }
7009
    if (cpu_single_env)
7010
        cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7011
}
7012

    
7013
void qemu_system_shutdown_request(void)
7014
{
7015
    shutdown_requested = 1;
7016
    if (cpu_single_env)
7017
        cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7018
}
7019

    
7020
void qemu_system_powerdown_request(void)
7021
{
7022
    powerdown_requested = 1;
7023
    if (cpu_single_env)
7024
        cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7025
}
7026

    
7027
void main_loop_wait(int timeout)
7028
{
7029
    IOHandlerRecord *ioh;
7030
    fd_set rfds, wfds, xfds;
7031
    int ret, nfds;
7032
#ifdef _WIN32
7033
    int ret2, i;
7034
#endif
7035
    struct timeval tv;
7036
    PollingEntry *pe;
7037

    
7038

    
7039
    /* XXX: need to suppress polling by better using win32 events */
7040
    ret = 0;
7041
    for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7042
        ret |= pe->func(pe->opaque);
7043
    }
7044
#ifdef _WIN32
7045
    if (ret == 0) {
7046
        int err;
7047
        WaitObjects *w = &wait_objects;
7048

    
7049
        ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
7050
        if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7051
            if (w->func[ret - WAIT_OBJECT_0])
7052
                w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
7053

    
7054
            /* Check for additional signaled events */
7055
            for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
7056

    
7057
                /* Check if event is signaled */
7058
                ret2 = WaitForSingleObject(w->events[i], 0);
7059
                if(ret2 == WAIT_OBJECT_0) {
7060
                    if (w->func[i])
7061
                        w->func[i](w->opaque[i]);
7062
                } else if (ret2 == WAIT_TIMEOUT) {
7063
                } else {
7064
                    err = GetLastError();
7065
                    fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
7066
                }
7067
            }
7068
        } else if (ret == WAIT_TIMEOUT) {
7069
        } else {
7070
            err = GetLastError();
7071
            fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
7072
        }
7073
    }
7074
#endif
7075
    /* poll any events */
7076
    /* XXX: separate device handlers from system ones */
7077
    nfds = -1;
7078
    FD_ZERO(&rfds);
7079
    FD_ZERO(&wfds);
7080
    FD_ZERO(&xfds);
7081
    for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7082
        if (ioh->deleted)
7083
            continue;
7084
        if (ioh->fd_read &&
7085
            (!ioh->fd_read_poll ||
7086
             ioh->fd_read_poll(ioh->opaque) != 0)) {
7087
            FD_SET(ioh->fd, &rfds);
7088
            if (ioh->fd > nfds)
7089
                nfds = ioh->fd;
7090
        }
7091
        if (ioh->fd_write) {
7092
            FD_SET(ioh->fd, &wfds);
7093
            if (ioh->fd > nfds)
7094
                nfds = ioh->fd;
7095
        }
7096
    }
7097

    
7098
    tv.tv_sec = 0;
7099
#ifdef _WIN32
7100
    tv.tv_usec = 0;
7101
#else
7102
    tv.tv_usec = timeout * 1000;
7103
#endif
7104
#if defined(CONFIG_SLIRP)
7105
    if (slirp_inited) {
7106
        slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7107
    }
7108
#endif
7109
    ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
7110
    if (ret > 0) {
7111
        IOHandlerRecord **pioh;
7112

    
7113
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7114
            if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
7115
                ioh->fd_read(ioh->opaque);
7116
            }
7117
            if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
7118
                ioh->fd_write(ioh->opaque);
7119
            }
7120
        }
7121

    
7122
        /* remove deleted IO handlers */
7123
        pioh = &first_io_handler;
7124
        while (*pioh) {
7125
            ioh = *pioh;
7126
            if (ioh->deleted) {
7127
                *pioh = ioh->next;
7128
                qemu_free(ioh);
7129
            } else
7130
                pioh = &ioh->next;
7131
        }
7132
    }
7133
#if defined(CONFIG_SLIRP)
7134
    if (slirp_inited) {
7135
        if (ret < 0) {
7136
            FD_ZERO(&rfds);
7137
            FD_ZERO(&wfds);
7138
            FD_ZERO(&xfds);
7139
        }
7140
        slirp_select_poll(&rfds, &wfds, &xfds);
7141
    }
7142
#endif
7143
    qemu_aio_poll();
7144

    
7145
    if (vm_running) {
7146
        if (likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
7147
        qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
7148
                        qemu_get_clock(vm_clock));
7149
        /* run dma transfers, if any */
7150
        DMA_run();
7151
    }
7152

    
7153
    /* real time timers */
7154
    qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
7155
                    qemu_get_clock(rt_clock));
7156

    
7157
    if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7158
        alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7159
        qemu_rearm_alarm_timer(alarm_timer);
7160
    }
7161

    
7162
    /* Check bottom-halves last in case any of the earlier events triggered
7163
       them.  */
7164
    qemu_bh_poll();
7165

    
7166
}
7167

    
7168
static int main_loop(void)
7169
{
7170
    int ret, timeout;
7171
#ifdef CONFIG_PROFILER
7172
    int64_t ti;
7173
#endif
7174
    CPUState *env;
7175

    
7176
    cur_cpu = first_cpu;
7177
    next_cpu = cur_cpu->next_cpu ?: first_cpu;
7178
    for(;;) {
7179
        if (vm_running) {
7180

    
7181
            for(;;) {
7182
                /* get next cpu */
7183
                env = next_cpu;
7184
#ifdef CONFIG_PROFILER
7185
                ti = profile_getclock();
7186
#endif
7187
                if (use_icount) {
7188
                    int64_t count;
7189
                    int decr;
7190
                    qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
7191
                    env->icount_decr.u16.low = 0;
7192
                    env->icount_extra = 0;
7193
                    count = qemu_next_deadline();
7194
                    count = (count + (1 << icount_time_shift) - 1)
7195
                            >> icount_time_shift;
7196
                    qemu_icount += count;
7197
                    decr = (count > 0xffff) ? 0xffff : count;
7198
                    count -= decr;
7199
                    env->icount_decr.u16.low = decr;
7200
                    env->icount_extra = count;
7201
                }
7202
                ret = cpu_exec(env);
7203
#ifdef CONFIG_PROFILER
7204
                qemu_time += profile_getclock() - ti;
7205
#endif
7206
                if (use_icount) {
7207
                    /* Fold pending instructions back into the
7208
                       instruction counter, and clear the interrupt flag.  */
7209
                    qemu_icount -= (env->icount_decr.u16.low
7210
                                    + env->icount_extra);
7211
                    env->icount_decr.u32 = 0;
7212
                    env->icount_extra = 0;
7213
                }
7214
                next_cpu = env->next_cpu ?: first_cpu;
7215
                if (event_pending && likely(ret != EXCP_DEBUG)) {
7216
                    ret = EXCP_INTERRUPT;
7217
                    event_pending = 0;
7218
                    break;
7219
                }
7220
                if (ret == EXCP_HLT) {
7221
                    /* Give the next CPU a chance to run.  */
7222
                    cur_cpu = env;
7223
                    continue;
7224
                }
7225
                if (ret != EXCP_HALTED)
7226
                    break;
7227
                /* all CPUs are halted ? */
7228
                if (env == cur_cpu)
7229
                    break;
7230
            }
7231
            cur_cpu = env;
7232

    
7233
            if (shutdown_requested) {
7234
                ret = EXCP_INTERRUPT;
7235
                if (no_shutdown) {
7236
                    vm_stop(0);
7237
                    no_shutdown = 0;
7238
                }
7239
                else
7240
                    break;
7241
            }
7242
            if (reset_requested) {
7243
                reset_requested = 0;
7244
                qemu_system_reset();
7245
                ret = EXCP_INTERRUPT;
7246
            }
7247
            if (powerdown_requested) {
7248
                powerdown_requested = 0;
7249
                qemu_system_powerdown();
7250
                ret = EXCP_INTERRUPT;
7251
            }
7252
            if (unlikely(ret == EXCP_DEBUG)) {
7253
                vm_stop(EXCP_DEBUG);
7254
            }
7255
            /* If all cpus are halted then wait until the next IRQ */
7256
            /* XXX: use timeout computed from timers */
7257
            if (ret == EXCP_HALTED) {
7258
                if (use_icount) {
7259
                    int64_t add;
7260
                    int64_t delta;
7261
                    /* Advance virtual time to the next event.  */
7262
                    if (use_icount == 1) {
7263
                        /* When not using an adaptive execution frequency
7264
                           we tend to get badly out of sync with real time,
7265
                           so just delay for a reasonable amount of time.  */
7266
                        delta = 0;
7267
                    } else {
7268
                        delta = cpu_get_icount() - cpu_get_clock();
7269
                    }
7270
                    if (delta > 0) {
7271
                        /* If virtual time is ahead of real time then just
7272
                           wait for IO.  */
7273
                        timeout = (delta / 1000000) + 1;
7274
                    } else {
7275
                        /* Wait for either IO to occur or the next
7276
                           timer event.  */
7277
                        add = qemu_next_deadline();
7278
                        /* We advance the timer before checking for IO.
7279
                           Limit the amount we advance so that early IO
7280
                           activity won't get the guest too far ahead.  */
7281
                        if (add > 10000000)
7282
                            add = 10000000;
7283
                        delta += add;
7284
                        add = (add + (1 << icount_time_shift) - 1)
7285
                              >> icount_time_shift;
7286
                        qemu_icount += add;
7287
                        timeout = delta / 1000000;
7288
                        if (timeout < 0)
7289
                            timeout = 0;
7290
                    }
7291
                } else {
7292
                    timeout = 10;
7293
                }
7294
            } else {
7295
                timeout = 0;
7296
            }
7297
        } else {
7298
            timeout = 10;
7299
        }
7300
#ifdef CONFIG_PROFILER
7301
        ti = profile_getclock();
7302
#endif
7303
        main_loop_wait(timeout);
7304
#ifdef CONFIG_PROFILER
7305
        dev_time += profile_getclock() - ti;
7306
#endif
7307
    }
7308
    cpu_disable_ticks();
7309
    return ret;
7310
}
7311

    
7312
static void help(int exitcode)
7313
{
7314
    printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
7315
           "usage: %s [options] [disk_image]\n"
7316
           "\n"
7317
           "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7318
           "\n"
7319
           "Standard options:\n"
7320
           "-M machine      select emulated machine (-M ? for list)\n"
7321
           "-cpu cpu        select CPU (-cpu ? for list)\n"
7322
           "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
7323
           "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
7324
           "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
7325
           "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7326
           "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7327
           "       [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7328
           "       [,cache=on|off][,format=f]\n"
7329
           "                use 'file' as a drive image\n"
7330
           "-mtdblock file  use 'file' as on-board Flash memory image\n"
7331
           "-sd file        use 'file' as SecureDigital card image\n"
7332
           "-pflash file    use 'file' as a parallel flash image\n"
7333
           "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7334
           "-snapshot       write to temporary files instead of disk image files\n"
7335
#ifdef CONFIG_SDL
7336
           "-no-frame       open SDL window without a frame and window decorations\n"
7337
           "-alt-grab       use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7338
           "-no-quit        disable SDL window close capability\n"
7339
#endif
7340
#ifdef TARGET_I386
7341
           "-no-fd-bootchk  disable boot signature checking for floppy disks\n"
7342
#endif
7343
           "-m megs         set virtual RAM size to megs MB [default=%d]\n"
7344
           "-smp n          set the number of CPUs to 'n' [default=1]\n"
7345
           "-nographic      disable graphical output and redirect serial I/Os to console\n"
7346
           "-portrait       rotate graphical output 90 deg left (only PXA LCD)\n"
7347
#ifndef _WIN32
7348
           "-k language     use keyboard layout (for example \"fr\" for French)\n"
7349
#endif
7350
#ifdef HAS_AUDIO
7351
           "-audio-help     print list of audio drivers and their options\n"
7352
           "-soundhw c1,... enable audio support\n"
7353
           "                and only specified sound cards (comma separated list)\n"
7354
           "                use -soundhw ? to get the list of supported cards\n"
7355
           "                use -soundhw all to enable all of them\n"
7356
#endif
7357
           "-localtime      set the real time clock to local time [default=utc]\n"
7358
           "-full-screen    start in full screen\n"
7359
#ifdef TARGET_I386
7360
           "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n"
7361
#endif
7362
           "-usb            enable the USB driver (will be the default soon)\n"
7363
           "-usbdevice name add the host or guest USB device 'name'\n"
7364
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7365
           "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"
7366
#endif
7367
           "-name string    set the name of the guest\n"
7368
           "\n"
7369
           "Network options:\n"
7370
           "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7371
           "                create a new Network Interface Card and connect it to VLAN 'n'\n"
7372
#ifdef CONFIG_SLIRP
7373
           "-net user[,vlan=n][,hostname=host]\n"
7374
           "                connect the user mode network stack to VLAN 'n' and send\n"
7375
           "                hostname 'host' to DHCP clients\n"
7376
#endif
7377
#ifdef _WIN32
7378
           "-net tap[,vlan=n],ifname=name\n"
7379
           "                connect the host TAP network interface to VLAN 'n'\n"
7380
#else
7381
           "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7382
           "                connect the host TAP network interface to VLAN 'n' and use the\n"
7383
           "                network scripts 'file' (default=%s)\n"
7384
           "                and 'dfile' (default=%s);\n"
7385
           "                use '[down]script=no' to disable script execution;\n"
7386
           "                use 'fd=h' to connect to an already opened TAP interface\n"
7387
#endif
7388
           "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7389
           "                connect the vlan 'n' to another VLAN using a socket connection\n"
7390
           "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7391
           "                connect the vlan 'n' to multicast maddr and port\n"
7392
           "-net none       use it alone to have zero network devices; if no -net option\n"
7393
           "                is provided, the default is '-net nic -net user'\n"
7394
           "\n"
7395
#ifdef CONFIG_SLIRP
7396
           "-tftp dir       allow tftp access to files in dir [-net user]\n"
7397
           "-bootp file     advertise file in BOOTP replies\n"
7398
#ifndef _WIN32
7399
           "-smb dir        allow SMB access to files in 'dir' [-net user]\n"
7400
#endif
7401
           "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7402
           "                redirect TCP or UDP connections from host to guest [-net user]\n"
7403
#endif
7404
           "\n"
7405
           "Linux boot specific:\n"
7406
           "-kernel bzImage use 'bzImage' as kernel image\n"
7407
           "-append cmdline use 'cmdline' as kernel command line\n"
7408
           "-initrd file    use 'file' as initial ram disk\n"
7409
           "\n"
7410
           "Debug/Expert options:\n"
7411
           "-monitor dev    redirect the monitor to char device 'dev'\n"
7412
           "-serial dev     redirect the serial port to char device 'dev'\n"
7413
           "-parallel dev   redirect the parallel port to char device 'dev'\n"
7414
           "-pidfile file   Write PID to 'file'\n"
7415
           "-S              freeze CPU at startup (use 'c' to start execution)\n"
7416
           "-s              wait gdb connection to port\n"
7417
           "-p port         set gdb connection port [default=%s]\n"
7418
           "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
7419
           "-hdachs c,h,s[,t]  force hard disk 0 physical geometry and the optional BIOS\n"
7420
           "                translation (t=none or lba) (usually qemu can guess them)\n"
7421
           "-L path         set the directory for the BIOS, VGA BIOS and keymaps\n"
7422
#ifdef USE_KQEMU
7423
           "-kernel-kqemu   enable KQEMU full virtualization (default is user mode only)\n"
7424
           "-no-kqemu       disable KQEMU kernel module usage\n"
7425
#endif
7426
#ifdef TARGET_I386
7427
           "-std-vga        simulate a standard VGA card with VESA Bochs Extensions\n"
7428
           "                (default is CL-GD5446 PCI VGA)\n"
7429
           "-no-acpi        disable ACPI\n"
7430
#endif
7431
#ifdef CONFIG_CURSES
7432
           "-curses         use a curses/ncurses interface instead of SDL\n"
7433
#endif
7434
           "-no-reboot      exit instead of rebooting\n"
7435
           "-no-shutdown    stop before shutdown\n"
7436
           "-loadvm [tag|id]  start right away with a saved state (loadvm in monitor)\n"
7437
           "-vnc display    start a VNC server on display\n"
7438
#ifndef _WIN32
7439
           "-daemonize      daemonize QEMU after initializing\n"
7440
#endif
7441
           "-option-rom rom load a file, rom, into the option ROM space\n"
7442
#ifdef TARGET_SPARC
7443
           "-prom-env variable=value  set OpenBIOS nvram variables\n"
7444
#endif
7445
           "-clock          force the use of the given methods for timer alarm.\n"
7446
           "                To see what timers are available use -clock ?\n"
7447
           "-startdate      select initial date of the clock\n"
7448
           "-icount [N|auto]\n"
7449
           "                Enable virtual instruction counter with 2^N clock ticks per instruction\n"
7450
           "\n"
7451
           "During emulation, the following keys are useful:\n"
7452
           "ctrl-alt-f      toggle full screen\n"
7453
           "ctrl-alt-n      switch to virtual console 'n'\n"
7454
           "ctrl-alt        toggle mouse and keyboard grab\n"
7455
           "\n"
7456
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
7457
           ,
7458
           "qemu",
7459
           DEFAULT_RAM_SIZE,
7460
#ifndef _WIN32
7461
           DEFAULT_NETWORK_SCRIPT,
7462
           DEFAULT_NETWORK_DOWN_SCRIPT,
7463
#endif
7464
           DEFAULT_GDBSTUB_PORT,
7465
           "/tmp/qemu.log");
7466
    exit(exitcode);
7467
}
7468

    
7469
#define HAS_ARG 0x0001
7470

    
7471
enum {
7472
    QEMU_OPTION_h,
7473

    
7474
    QEMU_OPTION_M,
7475
    QEMU_OPTION_cpu,
7476
    QEMU_OPTION_fda,
7477
    QEMU_OPTION_fdb,
7478
    QEMU_OPTION_hda,
7479
    QEMU_OPTION_hdb,
7480
    QEMU_OPTION_hdc,
7481
    QEMU_OPTION_hdd,
7482
    QEMU_OPTION_drive,
7483
    QEMU_OPTION_cdrom,
7484
    QEMU_OPTION_mtdblock,
7485
    QEMU_OPTION_sd,
7486
    QEMU_OPTION_pflash,
7487
    QEMU_OPTION_boot,
7488
    QEMU_OPTION_snapshot,
7489
#ifdef TARGET_I386
7490
    QEMU_OPTION_no_fd_bootchk,
7491
#endif
7492
    QEMU_OPTION_m,
7493
    QEMU_OPTION_nographic,
7494
    QEMU_OPTION_portrait,
7495
#ifdef HAS_AUDIO
7496
    QEMU_OPTION_audio_help,
7497
    QEMU_OPTION_soundhw,
7498
#endif
7499

    
7500
    QEMU_OPTION_net,
7501
    QEMU_OPTION_tftp,
7502
    QEMU_OPTION_bootp,
7503
    QEMU_OPTION_smb,
7504
    QEMU_OPTION_redir,
7505

    
7506
    QEMU_OPTION_kernel,
7507
    QEMU_OPTION_append,
7508
    QEMU_OPTION_initrd,
7509

    
7510
    QEMU_OPTION_S,
7511
    QEMU_OPTION_s,
7512
    QEMU_OPTION_p,
7513
    QEMU_OPTION_d,
7514
    QEMU_OPTION_hdachs,
7515
    QEMU_OPTION_L,
7516
    QEMU_OPTION_bios,
7517
    QEMU_OPTION_k,
7518
    QEMU_OPTION_localtime,
7519
    QEMU_OPTION_cirrusvga,
7520
    QEMU_OPTION_vmsvga,
7521
    QEMU_OPTION_g,
7522
    QEMU_OPTION_std_vga,
7523
    QEMU_OPTION_echr,
7524
    QEMU_OPTION_monitor,
7525
    QEMU_OPTION_serial,
7526
    QEMU_OPTION_parallel,
7527
    QEMU_OPTION_loadvm,
7528
    QEMU_OPTION_full_screen,
7529
    QEMU_OPTION_no_frame,
7530
    QEMU_OPTION_alt_grab,
7531
    QEMU_OPTION_no_quit,
7532
    QEMU_OPTION_pidfile,
7533
    QEMU_OPTION_no_kqemu,
7534
    QEMU_OPTION_kernel_kqemu,
7535
    QEMU_OPTION_win2k_hack,
7536
    QEMU_OPTION_usb,
7537
    QEMU_OPTION_usbdevice,
7538
    QEMU_OPTION_smp,
7539
    QEMU_OPTION_vnc,
7540
    QEMU_OPTION_no_acpi,
7541
    QEMU_OPTION_curses,
7542
    QEMU_OPTION_no_reboot,
7543
    QEMU_OPTION_no_shutdown,
7544
    QEMU_OPTION_show_cursor,
7545
    QEMU_OPTION_daemonize,
7546
    QEMU_OPTION_option_rom,
7547
    QEMU_OPTION_semihosting,
7548
    QEMU_OPTION_name,
7549
    QEMU_OPTION_prom_env,
7550
    QEMU_OPTION_old_param,
7551
    QEMU_OPTION_clock,
7552
    QEMU_OPTION_startdate,
7553
    QEMU_OPTION_tb_size,
7554
    QEMU_OPTION_icount,
7555
};
7556

    
7557
typedef struct QEMUOption {
7558
    const char *name;
7559
    int flags;
7560
    int index;
7561
} QEMUOption;
7562

    
7563
const QEMUOption qemu_options[] = {
7564
    { "h", 0, QEMU_OPTION_h },
7565
    { "help", 0, QEMU_OPTION_h },
7566

    
7567
    { "M", HAS_ARG, QEMU_OPTION_M },
7568
    { "cpu", HAS_ARG, QEMU_OPTION_cpu },
7569
    { "fda", HAS_ARG, QEMU_OPTION_fda },
7570
    { "fdb", HAS_ARG, QEMU_OPTION_fdb },
7571
    { "hda", HAS_ARG, QEMU_OPTION_hda },
7572
    { "hdb", HAS_ARG, QEMU_OPTION_hdb },
7573
    { "hdc", HAS_ARG, QEMU_OPTION_hdc },
7574
    { "hdd", HAS_ARG, QEMU_OPTION_hdd },
7575
    { "drive", HAS_ARG, QEMU_OPTION_drive },
7576
    { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
7577
    { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
7578
    { "sd", HAS_ARG, QEMU_OPTION_sd },
7579
    { "pflash", HAS_ARG, QEMU_OPTION_pflash },
7580
    { "boot", HAS_ARG, QEMU_OPTION_boot },
7581
    { "snapshot", 0, QEMU_OPTION_snapshot },
7582
#ifdef TARGET_I386
7583
    { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
7584
#endif
7585
    { "m", HAS_ARG, QEMU_OPTION_m },
7586
    { "nographic", 0, QEMU_OPTION_nographic },
7587
    { "portrait", 0, QEMU_OPTION_portrait },
7588
    { "k", HAS_ARG, QEMU_OPTION_k },
7589
#ifdef HAS_AUDIO
7590
    { "audio-help", 0, QEMU_OPTION_audio_help },
7591
    { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
7592
#endif
7593

    
7594
    { "net", HAS_ARG, QEMU_OPTION_net},
7595
#ifdef CONFIG_SLIRP
7596
    { "tftp", HAS_ARG, QEMU_OPTION_tftp },
7597
    { "bootp", HAS_ARG, QEMU_OPTION_bootp },
7598
#ifndef _WIN32
7599
    { "smb", HAS_ARG, QEMU_OPTION_smb },
7600
#endif
7601
    { "redir", HAS_ARG, QEMU_OPTION_redir },
7602
#endif
7603

    
7604
    { "kernel", HAS_ARG, QEMU_OPTION_kernel },
7605
    { "append", HAS_ARG, QEMU_OPTION_append },
7606
    { "initrd", HAS_ARG, QEMU_OPTION_initrd },
7607

    
7608
    { "S", 0, QEMU_OPTION_S },
7609
    { "s", 0, QEMU_OPTION_s },
7610
    { "p", HAS_ARG, QEMU_OPTION_p },
7611
    { "d", HAS_ARG, QEMU_OPTION_d },
7612
    { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
7613
    { "L", HAS_ARG, QEMU_OPTION_L },
7614
    { "bios", HAS_ARG, QEMU_OPTION_bios },
7615
#ifdef USE_KQEMU
7616
    { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
7617
    { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
7618
#endif
7619
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7620
    { "g", 1, QEMU_OPTION_g },
7621
#endif
7622
    { "localtime", 0, QEMU_OPTION_localtime },
7623
    { "std-vga", 0, QEMU_OPTION_std_vga },
7624
    { "echr", HAS_ARG, QEMU_OPTION_echr },
7625
    { "monitor", HAS_ARG, QEMU_OPTION_monitor },
7626
    { "serial", HAS_ARG, QEMU_OPTION_serial },
7627
    { "parallel", HAS_ARG, QEMU_OPTION_parallel },
7628
    { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
7629
    { "full-screen", 0, QEMU_OPTION_full_screen },
7630
#ifdef CONFIG_SDL
7631
    { "no-frame", 0, QEMU_OPTION_no_frame },
7632
    { "alt-grab", 0, QEMU_OPTION_alt_grab },
7633
    { "no-quit", 0, QEMU_OPTION_no_quit },
7634
#endif
7635
    { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
7636
    { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
7637
    { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
7638
    { "smp", HAS_ARG, QEMU_OPTION_smp },
7639
    { "vnc", HAS_ARG, QEMU_OPTION_vnc },
7640
#ifdef CONFIG_CURSES
7641
    { "curses", 0, QEMU_OPTION_curses },
7642
#endif
7643

    
7644
    /* temporary options */
7645
    { "usb", 0, QEMU_OPTION_usb },
7646
    { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
7647
    { "vmwarevga", 0, QEMU_OPTION_vmsvga },
7648
    { "no-acpi", 0, QEMU_OPTION_no_acpi },
7649
    { "no-reboot", 0, QEMU_OPTION_no_reboot },
7650
    { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
7651
    { "show-cursor", 0, QEMU_OPTION_show_cursor },
7652
    { "daemonize", 0, QEMU_OPTION_daemonize },
7653
    { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
7654
#if defined(TARGET_ARM) || defined(TARGET_M68K)
7655
    { "semihosting", 0, QEMU_OPTION_semihosting },
7656
#endif
7657
    { "name", HAS_ARG, QEMU_OPTION_name },
7658
#if defined(TARGET_SPARC)
7659
    { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
7660
#endif
7661
#if defined(TARGET_ARM)
7662
    { "old-param", 0, QEMU_OPTION_old_param },
7663
#endif
7664
    { "clock", HAS_ARG, QEMU_OPTION_clock },
7665
    { "startdate", HAS_ARG, QEMU_OPTION_startdate },
7666
    { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
7667
    { "icount", HAS_ARG, QEMU_OPTION_icount },
7668
    { NULL },
7669
};
7670

    
7671
/* password input */
7672

    
7673
int qemu_key_check(BlockDriverState *bs, const char *name)
7674
{
7675
    char password[256];
7676
    int i;
7677

    
7678
    if (!bdrv_is_encrypted(bs))
7679
        return 0;
7680

    
7681
    term_printf("%s is encrypted.\n", name);
7682
    for(i = 0; i < 3; i++) {
7683
        monitor_readline("Password: ", 1, password, sizeof(password));
7684
        if (bdrv_set_key(bs, password) == 0)
7685
            return 0;
7686
        term_printf("invalid password\n");
7687
    }
7688
    return -EPERM;
7689
}
7690

    
7691
static BlockDriverState *get_bdrv(int index)
7692
{
7693
    if (index > nb_drives)
7694
        return NULL;
7695
    return drives_table[index].bdrv;
7696
}
7697

    
7698
static void read_passwords(void)
7699
{
7700
    BlockDriverState *bs;
7701
    int i;
7702

    
7703
    for(i = 0; i < 6; i++) {
7704
        bs = get_bdrv(i);
7705
        if (bs)
7706
            qemu_key_check(bs, bdrv_get_device_name(bs));
7707
    }
7708
}
7709

    
7710
#ifdef HAS_AUDIO
7711
struct soundhw soundhw[] = {
7712
#ifdef HAS_AUDIO_CHOICE
7713
#if defined(TARGET_I386) || defined(TARGET_MIPS)
7714
    {
7715
        "pcspk",
7716
        "PC speaker",
7717
        0,
7718
        1,
7719
        { .init_isa = pcspk_audio_init }
7720
    },
7721
#endif
7722
    {
7723
        "sb16",
7724
        "Creative Sound Blaster 16",
7725
        0,
7726
        1,
7727
        { .init_isa = SB16_init }
7728
    },
7729

    
7730
#ifdef CONFIG_CS4231A
7731
    {
7732
        "cs4231a",
7733
        "CS4231A",
7734
        0,
7735
        1,
7736
        { .init_isa = cs4231a_init }
7737
    },
7738
#endif
7739

    
7740
#ifdef CONFIG_ADLIB
7741
    {
7742
        "adlib",
7743
#ifdef HAS_YMF262
7744
        "Yamaha YMF262 (OPL3)",
7745
#else
7746
        "Yamaha YM3812 (OPL2)",
7747
#endif
7748
        0,
7749
        1,
7750
        { .init_isa = Adlib_init }
7751
    },
7752
#endif
7753

    
7754
#ifdef CONFIG_GUS
7755
    {
7756
        "gus",
7757
        "Gravis Ultrasound GF1",
7758
        0,
7759
        1,
7760
        { .init_isa = GUS_init }
7761
    },
7762
#endif
7763

    
7764
#ifdef CONFIG_AC97
7765
    {
7766
        "ac97",
7767
        "Intel 82801AA AC97 Audio",
7768
        0,
7769
        0,
7770
        { .init_pci = ac97_init }
7771
    },
7772
#endif
7773

    
7774
    {
7775
        "es1370",
7776
        "ENSONIQ AudioPCI ES1370",
7777
        0,
7778
        0,
7779
        { .init_pci = es1370_init }
7780
    },
7781
#endif
7782

    
7783
    { NULL, NULL, 0, 0, { NULL } }
7784
};
7785

    
7786
static void select_soundhw (const char *optarg)
7787
{
7788
    struct soundhw *c;
7789

    
7790
    if (*optarg == '?') {
7791
    show_valid_cards:
7792

    
7793
        printf ("Valid sound card names (comma separated):\n");
7794
        for (c = soundhw; c->name; ++c) {
7795
            printf ("%-11s %s\n", c->name, c->descr);
7796
        }
7797
        printf ("\n-soundhw all will enable all of the above\n");
7798
        exit (*optarg != '?');
7799
    }
7800
    else {
7801
        size_t l;
7802
        const char *p;
7803
        char *e;
7804
        int bad_card = 0;
7805

    
7806
        if (!strcmp (optarg, "all")) {
7807
            for (c = soundhw; c->name; ++c) {
7808
                c->enabled = 1;
7809
            }
7810
            return;
7811
        }
7812

    
7813
        p = optarg;
7814
        while (*p) {
7815
            e = strchr (p, ',');
7816
            l = !e ? strlen (p) : (size_t) (e - p);
7817

    
7818
            for (c = soundhw; c->name; ++c) {
7819
                if (!strncmp (c->name, p, l)) {
7820
                    c->enabled = 1;
7821
                    break;
7822
                }
7823
            }
7824

    
7825
            if (!c->name) {
7826
                if (l > 80) {
7827
                    fprintf (stderr,
7828
                             "Unknown sound card name (too big to show)\n");
7829
                }
7830
                else {
7831
                    fprintf (stderr, "Unknown sound card name `%.*s'\n",
7832
                             (int) l, p);
7833
                }
7834
                bad_card = 1;
7835
            }
7836
            p += l + (e != NULL);
7837
        }
7838

    
7839
        if (bad_card)
7840
            goto show_valid_cards;
7841
    }
7842
}
7843
#endif
7844

    
7845
#ifdef _WIN32
7846
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
7847
{
7848
    exit(STATUS_CONTROL_C_EXIT);
7849
    return TRUE;
7850
}
7851
#endif
7852

    
7853
#define MAX_NET_CLIENTS 32
7854

    
7855
int main(int argc, char **argv)
7856
{
7857
#ifdef CONFIG_GDBSTUB
7858
    int use_gdbstub;
7859
    const char *gdbstub_port;
7860
#endif
7861
    uint32_t boot_devices_bitmap = 0;
7862
    int i;
7863
    int snapshot, linux_boot, net_boot;
7864
    const char *initrd_filename;
7865
    const char *kernel_filename, *kernel_cmdline;
7866
    const char *boot_devices = "";
7867
    DisplayState *ds = &display_state;
7868
    int cyls, heads, secs, translation;
7869
    const char *net_clients[MAX_NET_CLIENTS];
7870
    int nb_net_clients;
7871
    int hda_index;
7872
    int optind;
7873
    const char *r, *optarg;
7874
    CharDriverState *monitor_hd;
7875
    const char *monitor_device;
7876
    const char *serial_devices[MAX_SERIAL_PORTS];
7877
    int serial_device_index;
7878
    const char *parallel_devices[MAX_PARALLEL_PORTS];
7879
    int parallel_device_index;
7880
    const char *loadvm = NULL;
7881
    QEMUMachine *machine;
7882
    const char *cpu_model;
7883
    const char *usb_devices[MAX_USB_CMDLINE];
7884
    int usb_devices_index;
7885
    int fds[2];
7886
    int tb_size;
7887
    const char *pid_file = NULL;
7888
    VLANState *vlan;
7889

    
7890
    LIST_INIT (&vm_change_state_head);
7891
#ifndef _WIN32
7892
    {
7893
        struct sigaction act;
7894
        sigfillset(&act.sa_mask);
7895
        act.sa_flags = 0;
7896
        act.sa_handler = SIG_IGN;
7897
        sigaction(SIGPIPE, &act, NULL);
7898
    }
7899
#else
7900
    SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
7901
    /* Note: cpu_interrupt() is currently not SMP safe, so we force
7902
       QEMU to run on a single CPU */
7903
    {
7904
        HANDLE h;
7905
        DWORD mask, smask;
7906
        int i;
7907
        h = GetCurrentProcess();
7908
        if (GetProcessAffinityMask(h, &mask, &smask)) {
7909
            for(i = 0; i < 32; i++) {
7910
                if (mask & (1 << i))
7911
                    break;
7912
            }
7913
            if (i != 32) {
7914
                mask = 1 << i;
7915
                SetProcessAffinityMask(h, mask);
7916
            }
7917
        }
7918
    }
7919
#endif
7920

    
7921
    register_machines();
7922
    machine = first_machine;
7923
    cpu_model = NULL;
7924
    initrd_filename = NULL;
7925
    ram_size = 0;
7926
    vga_ram_size = VGA_RAM_SIZE;
7927
#ifdef CONFIG_GDBSTUB
7928
    use_gdbstub = 0;
7929
    gdbstub_port = DEFAULT_GDBSTUB_PORT;
7930
#endif
7931
    snapshot = 0;
7932
    nographic = 0;
7933
    curses = 0;
7934
    kernel_filename = NULL;
7935
    kernel_cmdline = "";
7936
    cyls = heads = secs = 0;
7937
    translation = BIOS_ATA_TRANSLATION_AUTO;
7938
    monitor_device = "vc";
7939

    
7940
    serial_devices[0] = "vc:80Cx24C";
7941
    for(i = 1; i < MAX_SERIAL_PORTS; i++)
7942
        serial_devices[i] = NULL;
7943
    serial_device_index = 0;
7944

    
7945
    parallel_devices[0] = "vc:640x480";
7946
    for(i = 1; i < MAX_PARALLEL_PORTS; i++)
7947
        parallel_devices[i] = NULL;
7948
    parallel_device_index = 0;
7949

    
7950
    usb_devices_index = 0;
7951

    
7952
    nb_net_clients = 0;
7953
    nb_drives = 0;
7954
    nb_drives_opt = 0;
7955
    hda_index = -1;
7956

    
7957
    nb_nics = 0;
7958

    
7959
    tb_size = 0;
7960
    
7961
    optind = 1;
7962
    for(;;) {
7963
        if (optind >= argc)
7964
            break;
7965
        r = argv[optind];
7966
        if (r[0] != '-') {
7967
            hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
7968
        } else {
7969
            const QEMUOption *popt;
7970

    
7971
            optind++;
7972
            /* Treat --foo the same as -foo.  */
7973
            if (r[1] == '-')
7974
                r++;
7975
            popt = qemu_options;
7976
            for(;;) {
7977
                if (!popt->name) {
7978
                    fprintf(stderr, "%s: invalid option -- '%s'\n",
7979
                            argv[0], r);
7980
                    exit(1);
7981
                }
7982
                if (!strcmp(popt->name, r + 1))
7983
                    break;
7984
                popt++;
7985
            }
7986
            if (popt->flags & HAS_ARG) {
7987
                if (optind >= argc) {
7988
                    fprintf(stderr, "%s: option '%s' requires an argument\n",
7989
                            argv[0], r);
7990
                    exit(1);
7991
                }
7992
                optarg = argv[optind++];
7993
            } else {
7994
                optarg = NULL;
7995
            }
7996

    
7997
            switch(popt->index) {
7998
            case QEMU_OPTION_M:
7999
                machine = find_machine(optarg);
8000
                if (!machine) {
8001
                    QEMUMachine *m;
8002
                    printf("Supported machines are:\n");
8003
                    for(m = first_machine; m != NULL; m = m->next) {
8004
                        printf("%-10s %s%s\n",
8005
                               m->name, m->desc,
8006
                               m == first_machine ? " (default)" : "");
8007
                    }
8008
                    exit(*optarg != '?');
8009
                }
8010
                break;
8011
            case QEMU_OPTION_cpu:
8012
                /* hw initialization will check this */
8013
                if (*optarg == '?') {
8014
/* XXX: implement xxx_cpu_list for targets that still miss it */
8015
#if defined(cpu_list)
8016
                    cpu_list(stdout, &fprintf);
8017
#endif
8018
                    exit(0);
8019
                } else {
8020
                    cpu_model = optarg;
8021
                }
8022
                break;
8023
            case QEMU_OPTION_initrd:
8024
                initrd_filename = optarg;
8025
                break;
8026
            case QEMU_OPTION_hda:
8027
                if (cyls == 0)
8028
                    hda_index = drive_add(optarg, HD_ALIAS, 0);
8029
                else
8030
                    hda_index = drive_add(optarg, HD_ALIAS
8031
                             ",cyls=%d,heads=%d,secs=%d%s",
8032
                             0, cyls, heads, secs,
8033
                             translation == BIOS_ATA_TRANSLATION_LBA ?
8034
                                 ",trans=lba" :
8035
                             translation == BIOS_ATA_TRANSLATION_NONE ?
8036
                                 ",trans=none" : "");
8037
                 break;
8038
            case QEMU_OPTION_hdb:
8039
            case QEMU_OPTION_hdc:
8040
            case QEMU_OPTION_hdd:
8041
                drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
8042
                break;
8043
            case QEMU_OPTION_drive:
8044
                drive_add(NULL, "%s", optarg);
8045
                break;
8046
            case QEMU_OPTION_mtdblock:
8047
                drive_add(optarg, MTD_ALIAS);
8048
                break;
8049
            case QEMU_OPTION_sd:
8050
                drive_add(optarg, SD_ALIAS);
8051
                break;
8052
            case QEMU_OPTION_pflash:
8053
                drive_add(optarg, PFLASH_ALIAS);
8054
                break;
8055
            case QEMU_OPTION_snapshot:
8056
                snapshot = 1;
8057
                break;
8058
            case QEMU_OPTION_hdachs:
8059
                {
8060
                    const char *p;
8061
                    p = optarg;
8062
                    cyls = strtol(p, (char **)&p, 0);
8063
                    if (cyls < 1 || cyls > 16383)
8064
                        goto chs_fail;
8065
                    if (*p != ',')
8066
                        goto chs_fail;
8067
                    p++;
8068
                    heads = strtol(p, (char **)&p, 0);
8069
                    if (heads < 1 || heads > 16)
8070
                        goto chs_fail;
8071
                    if (*p != ',')
8072
                        goto chs_fail;
8073
                    p++;
8074
                    secs = strtol(p, (char **)&p, 0);
8075
                    if (secs < 1 || secs > 63)
8076
                        goto chs_fail;
8077
                    if (*p == ',') {
8078
                        p++;
8079
                        if (!strcmp(p, "none"))
8080
                            translation = BIOS_ATA_TRANSLATION_NONE;
8081
                        else if (!strcmp(p, "lba"))
8082
                            translation = BIOS_ATA_TRANSLATION_LBA;
8083
                        else if (!strcmp(p, "auto"))
8084
                            translation = BIOS_ATA_TRANSLATION_AUTO;
8085
                        else
8086
                            goto chs_fail;
8087
                    } else if (*p != '\0') {
8088
                    chs_fail:
8089
                        fprintf(stderr, "qemu: invalid physical CHS format\n");
8090
                        exit(1);
8091
                    }
8092
                    if (hda_index != -1)
8093
                        snprintf(drives_opt[hda_index].opt,
8094
                                 sizeof(drives_opt[hda_index].opt),
8095
                                 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
8096
                                 0, cyls, heads, secs,
8097
                                 translation == BIOS_ATA_TRANSLATION_LBA ?
8098
                                         ",trans=lba" :
8099
                                 translation == BIOS_ATA_TRANSLATION_NONE ?
8100
                                     ",trans=none" : "");
8101
                }
8102
                break;
8103
            case QEMU_OPTION_nographic:
8104
                serial_devices[0] = "stdio";
8105
                parallel_devices[0] = "null";
8106
                monitor_device = "stdio";
8107
                nographic = 1;
8108
                break;
8109
#ifdef CONFIG_CURSES
8110
            case QEMU_OPTION_curses:
8111
                curses = 1;
8112
                break;
8113
#endif
8114
            case QEMU_OPTION_portrait:
8115
                graphic_rotate = 1;
8116
                break;
8117
            case QEMU_OPTION_kernel:
8118
                kernel_filename = optarg;
8119
                break;
8120
            case QEMU_OPTION_append:
8121
                kernel_cmdline = optarg;
8122
                break;
8123
            case QEMU_OPTION_cdrom:
8124
                drive_add(optarg, CDROM_ALIAS);
8125
                break;
8126
            case QEMU_OPTION_boot:
8127
                boot_devices = optarg;
8128
                /* We just do some generic consistency checks */
8129
                {
8130
                    /* Could easily be extended to 64 devices if needed */
8131
                    const char *p;
8132
                    
8133
                    boot_devices_bitmap = 0;
8134
                    for (p = boot_devices; *p != '\0'; p++) {
8135
                        /* Allowed boot devices are:
8136
                         * a b     : floppy disk drives
8137
                         * c ... f : IDE disk drives
8138
                         * g ... m : machine implementation dependant drives
8139
                         * n ... p : network devices
8140
                         * It's up to each machine implementation to check
8141
                         * if the given boot devices match the actual hardware
8142
                         * implementation and firmware features.
8143
                         */
8144
                        if (*p < 'a' || *p > 'q') {
8145
                            fprintf(stderr, "Invalid boot device '%c'\n", *p);
8146
                            exit(1);
8147
                        }
8148
                        if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8149
                            fprintf(stderr,
8150
                                    "Boot device '%c' was given twice\n",*p);
8151
                            exit(1);
8152
                        }
8153
                        boot_devices_bitmap |= 1 << (*p - 'a');
8154
                    }
8155
                }
8156
                break;
8157
            case QEMU_OPTION_fda:
8158
            case QEMU_OPTION_fdb:
8159
                drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
8160
                break;
8161
#ifdef TARGET_I386
8162
            case QEMU_OPTION_no_fd_bootchk:
8163
                fd_bootchk = 0;
8164
                break;
8165
#endif
8166
            case QEMU_OPTION_net:
8167
                if (nb_net_clients >= MAX_NET_CLIENTS) {
8168
                    fprintf(stderr, "qemu: too many network clients\n");
8169
                    exit(1);
8170
                }
8171
                net_clients[nb_net_clients] = optarg;
8172
                nb_net_clients++;
8173
                break;
8174
#ifdef CONFIG_SLIRP
8175
            case QEMU_OPTION_tftp:
8176
                tftp_prefix = optarg;
8177
                break;
8178
            case QEMU_OPTION_bootp:
8179
                bootp_filename = optarg;
8180
                break;
8181
#ifndef _WIN32
8182
            case QEMU_OPTION_smb:
8183
                net_slirp_smb(optarg);
8184
                break;
8185
#endif
8186
            case QEMU_OPTION_redir:
8187
                net_slirp_redir(optarg);
8188
                break;
8189
#endif
8190
#ifdef HAS_AUDIO
8191
            case QEMU_OPTION_audio_help:
8192
                AUD_help ();
8193
                exit (0);
8194
                break;
8195
            case QEMU_OPTION_soundhw:
8196
                select_soundhw (optarg);
8197
                break;
8198
#endif
8199
            case QEMU_OPTION_h:
8200
                help(0);
8201
                break;
8202
            case QEMU_OPTION_m: {
8203
                uint64_t value;
8204
                char *ptr;
8205

    
8206
                value = strtoul(optarg, &ptr, 10);
8207
                switch (*ptr) {
8208
                case 0: case 'M': case 'm':
8209
                    value <<= 20;
8210
                    break;
8211
                case 'G': case 'g':
8212
                    value <<= 30;
8213
                    break;
8214
                default:
8215
                    fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
8216
                    exit(1);
8217
                }
8218

    
8219
                /* On 32-bit hosts, QEMU is limited by virtual address space */
8220
                if (value > (2047 << 20)
8221
#ifndef USE_KQEMU
8222
                    && HOST_LONG_BITS == 32
8223
#endif
8224
                    ) {
8225
                    fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
8226
                    exit(1);
8227
                }
8228
                if (value != (uint64_t)(ram_addr_t)value) {
8229
                    fprintf(stderr, "qemu: ram size too large\n");
8230
                    exit(1);
8231
                }
8232
                ram_size = value;
8233
                break;
8234
            }
8235
            case QEMU_OPTION_d:
8236
                {
8237
                    int mask;
8238
                    CPULogItem *item;
8239

    
8240
                    mask = cpu_str_to_log_mask(optarg);
8241
                    if (!mask) {
8242
                        printf("Log items (comma separated):\n");
8243
                    for(item = cpu_log_items; item->mask != 0; item++) {
8244
                        printf("%-10s %s\n", item->name, item->help);
8245
                    }
8246
                    exit(1);
8247
                    }
8248
                    cpu_set_log(mask);
8249
                }
8250
                break;
8251
#ifdef CONFIG_GDBSTUB
8252
            case QEMU_OPTION_s:
8253
                use_gdbstub = 1;
8254
                break;
8255
            case QEMU_OPTION_p:
8256
                gdbstub_port = optarg;
8257
                break;
8258
#endif
8259
            case QEMU_OPTION_L:
8260
                bios_dir = optarg;
8261
                break;
8262
            case QEMU_OPTION_bios:
8263
                bios_name = optarg;
8264
                break;
8265
            case QEMU_OPTION_S:
8266
                autostart = 0;
8267
                break;
8268
            case QEMU_OPTION_k:
8269
                keyboard_layout = optarg;
8270
                break;
8271
            case QEMU_OPTION_localtime:
8272
                rtc_utc = 0;
8273
                break;
8274
            case QEMU_OPTION_cirrusvga:
8275
                cirrus_vga_enabled = 1;
8276
                vmsvga_enabled = 0;
8277
                break;
8278
            case QEMU_OPTION_vmsvga:
8279
                cirrus_vga_enabled = 0;
8280
                vmsvga_enabled = 1;
8281
                break;
8282
            case QEMU_OPTION_std_vga:
8283
                cirrus_vga_enabled = 0;
8284
                vmsvga_enabled = 0;
8285
                break;
8286
            case QEMU_OPTION_g:
8287
                {
8288
                    const char *p;
8289
                    int w, h, depth;
8290
                    p = optarg;
8291
                    w = strtol(p, (char **)&p, 10);
8292
                    if (w <= 0) {
8293
                    graphic_error:
8294
                        fprintf(stderr, "qemu: invalid resolution or depth\n");
8295
                        exit(1);
8296
                    }
8297
                    if (*p != 'x')
8298
                        goto graphic_error;
8299
                    p++;
8300
                    h = strtol(p, (char **)&p, 10);
8301
                    if (h <= 0)
8302
                        goto graphic_error;
8303
                    if (*p == 'x') {
8304
                        p++;
8305
                        depth = strtol(p, (char **)&p, 10);
8306
                        if (depth != 8 && depth != 15 && depth != 16 &&
8307
                            depth != 24 && depth != 32)
8308
                            goto graphic_error;
8309
                    } else if (*p == '\0') {
8310
                        depth = graphic_depth;
8311
                    } else {
8312
                        goto graphic_error;
8313
                    }
8314

    
8315
                    graphic_width = w;
8316
                    graphic_height = h;
8317
                    graphic_depth = depth;
8318
                }
8319
                break;
8320
            case QEMU_OPTION_echr:
8321
                {
8322
                    char *r;
8323
                    term_escape_char = strtol(optarg, &r, 0);
8324
                    if (r == optarg)
8325
                        printf("Bad argument to echr\n");
8326
                    break;
8327
                }
8328
            case QEMU_OPTION_monitor:
8329
                monitor_device = optarg;
8330
                break;
8331
            case QEMU_OPTION_serial:
8332
                if (serial_device_index >= MAX_SERIAL_PORTS) {
8333
                    fprintf(stderr, "qemu: too many serial ports\n");
8334
                    exit(1);
8335
                }
8336
                serial_devices[serial_device_index] = optarg;
8337
                serial_device_index++;
8338
                break;
8339
            case QEMU_OPTION_parallel:
8340
                if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8341
                    fprintf(stderr, "qemu: too many parallel ports\n");
8342
                    exit(1);
8343
                }
8344
                parallel_devices[parallel_device_index] = optarg;
8345
                parallel_device_index++;
8346
                break;
8347
            case QEMU_OPTION_loadvm:
8348
                loadvm = optarg;
8349
                break;
8350
            case QEMU_OPTION_full_screen:
8351
                full_screen = 1;
8352
                break;
8353
#ifdef CONFIG_SDL
8354
            case QEMU_OPTION_no_frame:
8355
                no_frame = 1;
8356
                break;
8357
            case QEMU_OPTION_alt_grab:
8358
                alt_grab = 1;
8359
                break;
8360
            case QEMU_OPTION_no_quit:
8361
                no_quit = 1;
8362
                break;
8363
#endif
8364
            case QEMU_OPTION_pidfile:
8365
                pid_file = optarg;
8366
                break;
8367
#ifdef TARGET_I386
8368
            case QEMU_OPTION_win2k_hack:
8369
                win2k_install_hack = 1;
8370
                break;
8371
#endif
8372
#ifdef USE_KQEMU
8373
            case QEMU_OPTION_no_kqemu:
8374
                kqemu_allowed = 0;
8375
                break;
8376
            case QEMU_OPTION_kernel_kqemu:
8377
                kqemu_allowed = 2;
8378
                break;
8379
#endif
8380
            case QEMU_OPTION_usb:
8381
                usb_enabled = 1;
8382
                break;
8383
            case QEMU_OPTION_usbdevice:
8384
                usb_enabled = 1;
8385
                if (usb_devices_index >= MAX_USB_CMDLINE) {
8386
                    fprintf(stderr, "Too many USB devices\n");
8387
                    exit(1);
8388
                }
8389
                usb_devices[usb_devices_index] = optarg;
8390
                usb_devices_index++;
8391
                break;
8392
            case QEMU_OPTION_smp:
8393
                smp_cpus = atoi(optarg);
8394
                if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
8395
                    fprintf(stderr, "Invalid number of CPUs\n");
8396
                    exit(1);
8397
                }
8398
                break;
8399
            case QEMU_OPTION_vnc:
8400
                vnc_display = optarg;
8401
                break;
8402
            case QEMU_OPTION_no_acpi:
8403
                acpi_enabled = 0;
8404
                break;
8405
            case QEMU_OPTION_no_reboot:
8406
                no_reboot = 1;
8407
                break;
8408
            case QEMU_OPTION_no_shutdown:
8409
                no_shutdown = 1;
8410
                break;
8411
            case QEMU_OPTION_show_cursor:
8412
                cursor_hide = 0;
8413
                break;
8414
            case QEMU_OPTION_daemonize:
8415
                daemonize = 1;
8416
                break;
8417
            case QEMU_OPTION_option_rom:
8418
                if (nb_option_roms >= MAX_OPTION_ROMS) {
8419
                    fprintf(stderr, "Too many option ROMs\n");
8420
                    exit(1);
8421
                }
8422
                option_rom[nb_option_roms] = optarg;
8423
                nb_option_roms++;
8424
                break;
8425
            case QEMU_OPTION_semihosting:
8426
                semihosting_enabled = 1;
8427
                break;
8428
            case QEMU_OPTION_name:
8429
                qemu_name = optarg;
8430
                break;
8431
#ifdef TARGET_SPARC
8432
            case QEMU_OPTION_prom_env:
8433
                if (nb_prom_envs >= MAX_PROM_ENVS) {
8434
                    fprintf(stderr, "Too many prom variables\n");
8435
                    exit(1);
8436
                }
8437
                prom_envs[nb_prom_envs] = optarg;
8438
                nb_prom_envs++;
8439
                break;
8440
#endif
8441
#ifdef TARGET_ARM
8442
            case QEMU_OPTION_old_param:
8443
                old_param = 1;
8444
                break;
8445
#endif
8446
            case QEMU_OPTION_clock:
8447
                configure_alarms(optarg);
8448
                break;
8449
            case QEMU_OPTION_startdate:
8450
                {
8451
                    struct tm tm;
8452
                    time_t rtc_start_date;
8453
                    if (!strcmp(optarg, "now")) {
8454
                        rtc_date_offset = -1;
8455
                    } else {
8456
                        if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
8457
                               &tm.tm_year,
8458
                               &tm.tm_mon,
8459
                               &tm.tm_mday,
8460
                               &tm.tm_hour,
8461
                               &tm.tm_min,
8462
                               &tm.tm_sec) == 6) {
8463
                            /* OK */
8464
                        } else if (sscanf(optarg, "%d-%d-%d",
8465
                                          &tm.tm_year,
8466
                                          &tm.tm_mon,
8467
                                          &tm.tm_mday) == 3) {
8468
                            tm.tm_hour = 0;
8469
                            tm.tm_min = 0;
8470
                            tm.tm_sec = 0;
8471
                        } else {
8472
                            goto date_fail;
8473
                        }
8474
                        tm.tm_year -= 1900;
8475
                        tm.tm_mon--;
8476
                        rtc_start_date = mktimegm(&tm);
8477
                        if (rtc_start_date == -1) {
8478
                        date_fail:
8479
                            fprintf(stderr, "Invalid date format. Valid format are:\n"
8480
                                    "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
8481
                            exit(1);
8482
                        }
8483
                        rtc_date_offset = time(NULL) - rtc_start_date;
8484
                    }
8485
                }
8486
                break;
8487
            case QEMU_OPTION_tb_size:
8488
                tb_size = strtol(optarg, NULL, 0);
8489
                if (tb_size < 0)
8490
                    tb_size = 0;
8491
                break;
8492
            case QEMU_OPTION_icount:
8493
                use_icount = 1;
8494
                if (strcmp(optarg, "auto") == 0) {
8495
                    icount_time_shift = -1;
8496
                } else {
8497
                    icount_time_shift = strtol(optarg, NULL, 0);
8498
                }
8499
                break;
8500
            }
8501
        }
8502
    }
8503

    
8504
#ifndef _WIN32
8505
    if (daemonize && !nographic && vnc_display == NULL) {
8506
        fprintf(stderr, "Can only daemonize if using -nographic or -vnc\n");
8507
        daemonize = 0;
8508
    }
8509

    
8510
    if (daemonize) {
8511
        pid_t pid;
8512

    
8513
        if (pipe(fds) == -1)
8514
            exit(1);
8515

    
8516
        pid = fork();
8517
        if (pid > 0) {
8518
            uint8_t status;
8519
            ssize_t len;
8520

    
8521
            close(fds[1]);
8522

    
8523
        again:
8524
            len = read(fds[0], &status, 1);
8525
            if (len == -1 && (errno == EINTR))
8526
                goto again;
8527

    
8528
            if (len != 1)
8529
                exit(1);
8530
            else if (status == 1) {
8531
                fprintf(stderr, "Could not acquire pidfile\n");
8532
                exit(1);
8533
            } else
8534
                exit(0);
8535
        } else if (pid < 0)
8536
            exit(1);
8537

    
8538
        setsid();
8539

    
8540
        pid = fork();
8541
        if (pid > 0)
8542
            exit(0);
8543
        else if (pid < 0)
8544
            exit(1);
8545

    
8546
        umask(027);
8547
        chdir("/");
8548

    
8549
        signal(SIGTSTP, SIG_IGN);
8550
        signal(SIGTTOU, SIG_IGN);
8551
        signal(SIGTTIN, SIG_IGN);
8552
    }
8553
#endif
8554

    
8555
    if (pid_file && qemu_create_pidfile(pid_file) != 0) {
8556
        if (daemonize) {
8557
            uint8_t status = 1;
8558
            write(fds[1], &status, 1);
8559
        } else
8560
            fprintf(stderr, "Could not acquire pid file\n");
8561
        exit(1);
8562
    }
8563

    
8564
#ifdef USE_KQEMU
8565
    if (smp_cpus > 1)
8566
        kqemu_allowed = 0;
8567
#endif
8568
    linux_boot = (kernel_filename != NULL);
8569
    net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
8570

    
8571
    /* XXX: this should not be: some embedded targets just have flash */
8572
    if (!linux_boot && net_boot == 0 &&
8573
        nb_drives_opt == 0)
8574
        help(1);
8575

    
8576
    /* boot to floppy or the default cd if no hard disk defined yet */
8577
    if (!boot_devices[0]) {
8578
        boot_devices = "cad";
8579
    }
8580
    setvbuf(stdout, NULL, _IOLBF, 0);
8581

    
8582
    init_timers();
8583
    init_timer_alarm();
8584
    qemu_aio_init();
8585
    if (use_icount && icount_time_shift < 0) {
8586
        use_icount = 2;
8587
        /* 125MIPS seems a reasonable initial guess at the guest speed.
8588
           It will be corrected fairly quickly anyway.  */
8589
        icount_time_shift = 3;
8590
        init_icount_adjust();
8591
    }
8592

    
8593
#ifdef _WIN32
8594
    socket_init();
8595
#endif
8596

    
8597
    /* init network clients */
8598
    if (nb_net_clients == 0) {
8599
        /* if no clients, we use a default config */
8600
        net_clients[0] = "nic";
8601
        net_clients[1] = "user";
8602
        nb_net_clients = 2;
8603
    }
8604

    
8605
    for(i = 0;i < nb_net_clients; i++) {
8606
        if (net_client_init(net_clients[i]) < 0)
8607
            exit(1);
8608
    }
8609
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8610
        if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
8611
            continue;
8612
        if (vlan->nb_guest_devs == 0) {
8613
            fprintf(stderr, "Invalid vlan (%d) with no nics\n", vlan->id);
8614
            exit(1);
8615
        }
8616
        if (vlan->nb_host_devs == 0)
8617
            fprintf(stderr,
8618
                    "Warning: vlan %d is not connected to host network\n",
8619
                    vlan->id);
8620
    }
8621

    
8622
#ifdef TARGET_I386
8623
    /* XXX: this should be moved in the PC machine instantiation code */
8624
    if (net_boot != 0) {
8625
        int netroms = 0;
8626
        for (i = 0; i < nb_nics && i < 4; i++) {
8627
            const char *model = nd_table[i].model;
8628
            char buf[1024];
8629
            if (net_boot & (1 << i)) {
8630
                if (model == NULL)
8631
                    model = "ne2k_pci";
8632
                snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
8633
                if (get_image_size(buf) > 0) {
8634
                    if (nb_option_roms >= MAX_OPTION_ROMS) {
8635
                        fprintf(stderr, "Too many option ROMs\n");
8636
                        exit(1);
8637
                    }
8638
                    option_rom[nb_option_roms] = strdup(buf);
8639
                    nb_option_roms++;
8640
                    netroms++;
8641
                }
8642
            }
8643
        }
8644
        if (netroms == 0) {
8645
            fprintf(stderr, "No valid PXE rom found for network device\n");
8646
            exit(1);
8647
        }
8648
    }
8649
#endif
8650

    
8651
    /* init the memory */
8652
    phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
8653

    
8654
    if (machine->ram_require & RAMSIZE_FIXED) {
8655
        if (ram_size > 0) {
8656
            if (ram_size < phys_ram_size) {
8657
                fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
8658
                                machine->name, (unsigned long long) phys_ram_size);
8659
                exit(-1);
8660
            }
8661

    
8662
            phys_ram_size = ram_size;
8663
        } else
8664
            ram_size = phys_ram_size;
8665
    } else {
8666
        if (ram_size == 0)
8667
            ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
8668

    
8669
        phys_ram_size += ram_size;
8670
    }
8671

    
8672
    phys_ram_base = qemu_vmalloc(phys_ram_size);
8673
    if (!phys_ram_base) {
8674
        fprintf(stderr, "Could not allocate physical memory\n");
8675
        exit(1);
8676
    }
8677

    
8678
    /* init the dynamic translator */
8679
    cpu_exec_init_all(tb_size * 1024 * 1024);
8680

    
8681
    bdrv_init();
8682

    
8683
    /* we always create the cdrom drive, even if no disk is there */
8684

    
8685
    if (nb_drives_opt < MAX_DRIVES)
8686
        drive_add(NULL, CDROM_ALIAS);
8687

    
8688
    /* we always create at least one floppy */
8689

    
8690
    if (nb_drives_opt < MAX_DRIVES)
8691
        drive_add(NULL, FD_ALIAS, 0);
8692

    
8693
    /* we always create one sd slot, even if no card is in it */
8694

    
8695
    if (nb_drives_opt < MAX_DRIVES)
8696
        drive_add(NULL, SD_ALIAS);
8697

    
8698
    /* open the virtual block devices */
8699

    
8700
    for(i = 0; i < nb_drives_opt; i++)
8701
        if (drive_init(&drives_opt[i], snapshot, machine) == -1)
8702
            exit(1);
8703

    
8704
    register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
8705
    register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8706

    
8707
    init_ioports();
8708

    
8709
    /* terminal init */
8710
    memset(&display_state, 0, sizeof(display_state));
8711
    if (nographic) {
8712
        if (curses) {
8713
            fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
8714
            exit(1);
8715
        }
8716
        /* nearly nothing to do */
8717
        dumb_display_init(ds);
8718
    } else if (vnc_display != NULL) {
8719
        vnc_display_init(ds);
8720
        if (vnc_display_open(ds, vnc_display) < 0)
8721
            exit(1);
8722
    } else
8723
#if defined(CONFIG_CURSES)
8724
    if (curses) {
8725
        curses_display_init(ds, full_screen);
8726
    } else
8727
#endif
8728
    {
8729
#if defined(CONFIG_SDL)
8730
        sdl_display_init(ds, full_screen, no_frame);
8731
#elif defined(CONFIG_COCOA)
8732
        cocoa_display_init(ds, full_screen);
8733
#else
8734
        dumb_display_init(ds);
8735
#endif
8736
    }
8737

    
8738
    /* Maintain compatibility with multiple stdio monitors */
8739
    if (!strcmp(monitor_device,"stdio")) {
8740
        for (i = 0; i < MAX_SERIAL_PORTS; i++) {
8741
            const char *devname = serial_devices[i];
8742
            if (devname && !strcmp(devname,"mon:stdio")) {
8743
                monitor_device = NULL;
8744
                break;
8745
            } else if (devname && !strcmp(devname,"stdio")) {
8746
                monitor_device = NULL;
8747
                serial_devices[i] = "mon:stdio";
8748
                break;
8749
            }
8750
        }
8751
    }
8752
    if (monitor_device) {
8753
        monitor_hd = qemu_chr_open(monitor_device);
8754
        if (!monitor_hd) {
8755
            fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
8756
            exit(1);
8757
        }
8758
        monitor_init(monitor_hd, !nographic);
8759
    }
8760

    
8761
    for(i = 0; i < MAX_SERIAL_PORTS; i++) {
8762
        const char *devname = serial_devices[i];
8763
        if (devname && strcmp(devname, "none")) {
8764
            serial_hds[i] = qemu_chr_open(devname);
8765
            if (!serial_hds[i]) {
8766
                fprintf(stderr, "qemu: could not open serial device '%s'\n",
8767
                        devname);
8768
                exit(1);
8769
            }
8770
            if (strstart(devname, "vc", 0))
8771
                qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8772
        }
8773
    }
8774

    
8775
    for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
8776
        const char *devname = parallel_devices[i];
8777
        if (devname && strcmp(devname, "none")) {
8778
            parallel_hds[i] = qemu_chr_open(devname);
8779
            if (!parallel_hds[i]) {
8780
                fprintf(stderr, "qemu: could not open parallel device '%s'\n",
8781
                        devname);
8782
                exit(1);
8783
            }
8784
            if (strstart(devname, "vc", 0))
8785
                qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
8786
        }
8787
    }
8788

    
8789
    machine->init(ram_size, vga_ram_size, boot_devices, ds,
8790
                  kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
8791

    
8792
    /* init USB devices */
8793
    if (usb_enabled) {
8794
        for(i = 0; i < usb_devices_index; i++) {
8795
            if (usb_device_add(usb_devices[i]) < 0) {
8796
                fprintf(stderr, "Warning: could not add USB device %s\n",
8797
                        usb_devices[i]);
8798
            }
8799
        }
8800
    }
8801

    
8802
    if (display_state.dpy_refresh) {
8803
        display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
8804
        qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
8805
    }
8806

    
8807
#ifdef CONFIG_GDBSTUB
8808
    if (use_gdbstub) {
8809
        /* XXX: use standard host:port notation and modify options
8810
           accordingly. */
8811
        if (gdbserver_start(gdbstub_port) < 0) {
8812
            fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
8813
                    gdbstub_port);
8814
            exit(1);
8815
        }
8816
    }
8817
#endif
8818

    
8819
    if (loadvm)
8820
        do_loadvm(loadvm);
8821

    
8822
    {
8823
        /* XXX: simplify init */
8824
        read_passwords();
8825
        if (autostart) {
8826
            vm_start();
8827
        }
8828
    }
8829

    
8830
    if (daemonize) {
8831
        uint8_t status = 0;
8832
        ssize_t len;
8833
        int fd;
8834

    
8835
    again1:
8836
        len = write(fds[1], &status, 1);
8837
        if (len == -1 && (errno == EINTR))
8838
            goto again1;
8839

    
8840
        if (len != 1)
8841
            exit(1);
8842

    
8843
        TFR(fd = open("/dev/null", O_RDWR));
8844
        if (fd == -1)
8845
            exit(1);
8846

    
8847
        dup2(fd, 0);
8848
        dup2(fd, 1);
8849
        dup2(fd, 2);
8850

    
8851
        close(fd);
8852
    }
8853

    
8854
    main_loop();
8855
    quit_timers();
8856

    
8857
#if !defined(_WIN32)
8858
    /* close network clients */
8859
    for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8860
        VLANClientState *vc;
8861

    
8862
        for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
8863
            if (vc->fd_read == tap_receive) {
8864
                char ifname[64];
8865
                TAPState *s = vc->opaque;
8866

    
8867
                if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
8868
                    s->down_script[0])
8869
                    launch_script(s->down_script, ifname, s->fd);
8870
            }
8871
        }
8872
    }
8873
#endif
8874
    return 0;
8875
}