Statistics
| Branch: | Revision:

root / vl.c @ 664e0f19

History | View | Annotate | Download (94.7 kB)

1
/*
2
 * QEMU System Emulator
3
 * 
4
 * Copyright (c) 2003-2004 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 "vl.h"
25

    
26
#include <unistd.h>
27
#include <fcntl.h>
28
#include <signal.h>
29
#include <time.h>
30
#include <errno.h>
31
#include <sys/time.h>
32

    
33
#ifndef _WIN32
34
#include <sys/times.h>
35
#include <sys/wait.h>
36
#include <termios.h>
37
#include <sys/poll.h>
38
#include <sys/mman.h>
39
#include <sys/ioctl.h>
40
#include <sys/socket.h>
41
#include <netinet/in.h>
42
#include <dirent.h>
43
#ifdef _BSD
44
#include <sys/stat.h>
45
#ifndef __APPLE__
46
#include <libutil.h>
47
#endif
48
#else
49
#include <linux/if.h>
50
#include <linux/if_tun.h>
51
#include <pty.h>
52
#include <malloc.h>
53
#include <linux/rtc.h>
54
#endif
55
#endif
56

    
57
#if defined(CONFIG_SLIRP)
58
#include "libslirp.h"
59
#endif
60

    
61
#ifdef _WIN32
62
#include <malloc.h>
63
#include <sys/timeb.h>
64
#include <windows.h>
65
#define getopt_long_only getopt_long
66
#define memalign(align, size) malloc(size)
67
#endif
68

    
69
#ifdef CONFIG_SDL
70
#ifdef __APPLE__
71
#include <SDL/SDL.h>
72
#endif
73
#endif /* CONFIG_SDL */
74

    
75
#include "disas.h"
76

    
77
#include "exec-all.h"
78

    
79
//#define DO_TB_FLUSH
80

    
81
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
82

    
83
//#define DEBUG_UNUSED_IOPORT
84
//#define DEBUG_IOPORT
85

    
86
#if !defined(CONFIG_SOFTMMU)
87
#define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024)
88
#else
89
#define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
90
#endif
91

    
92
#ifdef TARGET_PPC
93
#define DEFAULT_RAM_SIZE 144
94
#else
95
#define DEFAULT_RAM_SIZE 128
96
#endif
97
/* in ms */
98
#define GUI_REFRESH_INTERVAL 30
99

    
100
/* XXX: use a two level table to limit memory usage */
101
#define MAX_IOPORTS 65536
102

    
103
const char *bios_dir = CONFIG_QEMU_SHAREDIR;
104
char phys_ram_file[1024];
105
CPUState *global_env;
106
CPUState *cpu_single_env;
107
void *ioport_opaque[MAX_IOPORTS];
108
IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
109
IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
110
BlockDriverState *bs_table[MAX_DISKS], *fd_table[MAX_FD];
111
int vga_ram_size;
112
int bios_size;
113
static DisplayState display_state;
114
int nographic;
115
const char* keyboard_layout = NULL;
116
int64_t ticks_per_sec;
117
int boot_device = 'c';
118
int ram_size;
119
static char network_script[1024];
120
int pit_min_timer_count = 0;
121
int nb_nics;
122
NetDriverState nd_table[MAX_NICS];
123
QEMUTimer *gui_timer;
124
int vm_running;
125
int audio_enabled = 0;
126
int sb16_enabled = 1;
127
int adlib_enabled = 1;
128
int gus_enabled = 1;
129
int pci_enabled = 1;
130
int prep_enabled = 0;
131
int rtc_utc = 1;
132
int cirrus_vga_enabled = 1;
133
int graphic_width = 800;
134
int graphic_height = 600;
135
int graphic_depth = 15;
136
int full_screen = 0;
137
TextConsole *vga_console;
138
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
139

    
140
/***********************************************************/
141
/* x86 ISA bus support */
142

    
143
target_phys_addr_t isa_mem_base = 0;
144

    
145
uint32_t default_ioport_readb(void *opaque, uint32_t address)
146
{
147
#ifdef DEBUG_UNUSED_IOPORT
148
    fprintf(stderr, "inb: port=0x%04x\n", address);
149
#endif
150
    return 0xff;
151
}
152

    
153
void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
154
{
155
#ifdef DEBUG_UNUSED_IOPORT
156
    fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
157
#endif
158
}
159

    
160
/* default is to make two byte accesses */
161
uint32_t default_ioport_readw(void *opaque, uint32_t address)
162
{
163
    uint32_t data;
164
    data = ioport_read_table[0][address](ioport_opaque[address], address);
165
    address = (address + 1) & (MAX_IOPORTS - 1);
166
    data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
167
    return data;
168
}
169

    
170
void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
171
{
172
    ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
173
    address = (address + 1) & (MAX_IOPORTS - 1);
174
    ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
175
}
176

    
177
uint32_t default_ioport_readl(void *opaque, uint32_t address)
178
{
179
#ifdef DEBUG_UNUSED_IOPORT
180
    fprintf(stderr, "inl: port=0x%04x\n", address);
181
#endif
182
    return 0xffffffff;
183
}
184

    
185
void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
186
{
187
#ifdef DEBUG_UNUSED_IOPORT
188
    fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
189
#endif
190
}
191

    
192
void init_ioports(void)
193
{
194
    int i;
195

    
196
    for(i = 0; i < MAX_IOPORTS; i++) {
197
        ioport_read_table[0][i] = default_ioport_readb;
198
        ioport_write_table[0][i] = default_ioport_writeb;
199
        ioport_read_table[1][i] = default_ioport_readw;
200
        ioport_write_table[1][i] = default_ioport_writew;
201
        ioport_read_table[2][i] = default_ioport_readl;
202
        ioport_write_table[2][i] = default_ioport_writel;
203
    }
204
}
205

    
206
/* size is the word size in byte */
207
int register_ioport_read(int start, int length, int size, 
208
                         IOPortReadFunc *func, void *opaque)
209
{
210
    int i, bsize;
211

    
212
    if (size == 1) {
213
        bsize = 0;
214
    } else if (size == 2) {
215
        bsize = 1;
216
    } else if (size == 4) {
217
        bsize = 2;
218
    } else {
219
        hw_error("register_ioport_read: invalid size");
220
        return -1;
221
    }
222
    for(i = start; i < start + length; i += size) {
223
        ioport_read_table[bsize][i] = func;
224
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
225
            hw_error("register_ioport_read: invalid opaque");
226
        ioport_opaque[i] = opaque;
227
    }
228
    return 0;
229
}
230

    
231
/* size is the word size in byte */
232
int register_ioport_write(int start, int length, int size, 
233
                          IOPortWriteFunc *func, void *opaque)
234
{
235
    int i, bsize;
236

    
237
    if (size == 1) {
238
        bsize = 0;
239
    } else if (size == 2) {
240
        bsize = 1;
241
    } else if (size == 4) {
242
        bsize = 2;
243
    } else {
244
        hw_error("register_ioport_write: invalid size");
245
        return -1;
246
    }
247
    for(i = start; i < start + length; i += size) {
248
        ioport_write_table[bsize][i] = func;
249
        if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
250
            hw_error("register_ioport_read: invalid opaque");
251
        ioport_opaque[i] = opaque;
252
    }
253
    return 0;
254
}
255

    
256
void isa_unassign_ioport(int start, int length)
257
{
258
    int i;
259

    
260
    for(i = start; i < start + length; i++) {
261
        ioport_read_table[0][i] = default_ioport_readb;
262
        ioport_read_table[1][i] = default_ioport_readw;
263
        ioport_read_table[2][i] = default_ioport_readl;
264

    
265
        ioport_write_table[0][i] = default_ioport_writeb;
266
        ioport_write_table[1][i] = default_ioport_writew;
267
        ioport_write_table[2][i] = default_ioport_writel;
268
    }
269
}
270

    
271
/***********************************************************/
272

    
273
void pstrcpy(char *buf, int buf_size, const char *str)
274
{
275
    int c;
276
    char *q = buf;
277

    
278
    if (buf_size <= 0)
279
        return;
280

    
281
    for(;;) {
282
        c = *str++;
283
        if (c == 0 || q >= buf + buf_size - 1)
284
            break;
285
        *q++ = c;
286
    }
287
    *q = '\0';
288
}
289

    
290
/* strcat and truncate. */
291
char *pstrcat(char *buf, int buf_size, const char *s)
292
{
293
    int len;
294
    len = strlen(buf);
295
    if (len < buf_size) 
296
        pstrcpy(buf + len, buf_size - len, s);
297
    return buf;
298
}
299

    
300
int strstart(const char *str, const char *val, const char **ptr)
301
{
302
    const char *p, *q;
303
    p = str;
304
    q = val;
305
    while (*q != '\0') {
306
        if (*p != *q)
307
            return 0;
308
        p++;
309
        q++;
310
    }
311
    if (ptr)
312
        *ptr = p;
313
    return 1;
314
}
315

    
316
/* return the size or -1 if error */
317
int get_image_size(const char *filename)
318
{
319
    int fd, size;
320
    fd = open(filename, O_RDONLY | O_BINARY);
321
    if (fd < 0)
322
        return -1;
323
    size = lseek(fd, 0, SEEK_END);
324
    close(fd);
325
    return size;
326
}
327

    
328
/* return the size or -1 if error */
329
int load_image(const char *filename, uint8_t *addr)
330
{
331
    int fd, size;
332
    fd = open(filename, O_RDONLY | O_BINARY);
333
    if (fd < 0)
334
        return -1;
335
    size = lseek(fd, 0, SEEK_END);
336
    lseek(fd, 0, SEEK_SET);
337
    if (read(fd, addr, size) != size) {
338
        close(fd);
339
        return -1;
340
    }
341
    close(fd);
342
    return size;
343
}
344

    
345
void cpu_outb(CPUState *env, int addr, int val)
346
{
347
#ifdef DEBUG_IOPORT
348
    if (loglevel & CPU_LOG_IOPORT)
349
        fprintf(logfile, "outb: %04x %02x\n", addr, val);
350
#endif    
351
    ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
352
}
353

    
354
void cpu_outw(CPUState *env, int addr, int val)
355
{
356
#ifdef DEBUG_IOPORT
357
    if (loglevel & CPU_LOG_IOPORT)
358
        fprintf(logfile, "outw: %04x %04x\n", addr, val);
359
#endif    
360
    ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
361
}
362

    
363
void cpu_outl(CPUState *env, int addr, int val)
364
{
365
#ifdef DEBUG_IOPORT
366
    if (loglevel & CPU_LOG_IOPORT)
367
        fprintf(logfile, "outl: %04x %08x\n", addr, val);
368
#endif
369
    ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
370
}
371

    
372
int cpu_inb(CPUState *env, int addr)
373
{
374
    int val;
375
    val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
376
#ifdef DEBUG_IOPORT
377
    if (loglevel & CPU_LOG_IOPORT)
378
        fprintf(logfile, "inb : %04x %02x\n", addr, val);
379
#endif
380
    return val;
381
}
382

    
383
int cpu_inw(CPUState *env, int addr)
384
{
385
    int val;
386
    val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
387
#ifdef DEBUG_IOPORT
388
    if (loglevel & CPU_LOG_IOPORT)
389
        fprintf(logfile, "inw : %04x %04x\n", addr, val);
390
#endif
391
    return val;
392
}
393

    
394
int cpu_inl(CPUState *env, int addr)
395
{
396
    int val;
397
    val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
398
#ifdef DEBUG_IOPORT
399
    if (loglevel & CPU_LOG_IOPORT)
400
        fprintf(logfile, "inl : %04x %08x\n", addr, val);
401
#endif
402
    return val;
403
}
404

    
405
/***********************************************************/
406
void hw_error(const char *fmt, ...)
407
{
408
    va_list ap;
409

    
410
    va_start(ap, fmt);
411
    fprintf(stderr, "qemu: hardware error: ");
412
    vfprintf(stderr, fmt, ap);
413
    fprintf(stderr, "\n");
414
#ifdef TARGET_I386
415
    cpu_dump_state(global_env, stderr, fprintf, X86_DUMP_FPU | X86_DUMP_CCOP);
416
#else
417
    cpu_dump_state(global_env, stderr, fprintf, 0);
418
#endif
419
    va_end(ap);
420
    abort();
421
}
422

    
423
/***********************************************************/
424
/* keyboard/mouse */
425

    
426
static QEMUPutKBDEvent *qemu_put_kbd_event;
427
static void *qemu_put_kbd_event_opaque;
428
static QEMUPutMouseEvent *qemu_put_mouse_event;
429
static void *qemu_put_mouse_event_opaque;
430

    
431
void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
432
{
433
    qemu_put_kbd_event_opaque = opaque;
434
    qemu_put_kbd_event = func;
435
}
436

    
437
void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque)
438
{
439
    qemu_put_mouse_event_opaque = opaque;
440
    qemu_put_mouse_event = func;
441
}
442

    
443
void kbd_put_keycode(int keycode)
444
{
445
    if (qemu_put_kbd_event) {
446
        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
447
    }
448
}
449

    
450
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
451
{
452
    if (qemu_put_mouse_event) {
453
        qemu_put_mouse_event(qemu_put_mouse_event_opaque, 
454
                             dx, dy, dz, buttons_state);
455
    }
456
}
457

    
458
/***********************************************************/
459
/* timers */
460

    
461
#if defined(__powerpc__)
462

    
463
static inline uint32_t get_tbl(void) 
464
{
465
    uint32_t tbl;
466
    asm volatile("mftb %0" : "=r" (tbl));
467
    return tbl;
468
}
469

    
470
static inline uint32_t get_tbu(void) 
471
{
472
        uint32_t tbl;
473
        asm volatile("mftbu %0" : "=r" (tbl));
474
        return tbl;
475
}
476

    
477
int64_t cpu_get_real_ticks(void)
478
{
479
    uint32_t l, h, h1;
480
    /* NOTE: we test if wrapping has occurred */
481
    do {
482
        h = get_tbu();
483
        l = get_tbl();
484
        h1 = get_tbu();
485
    } while (h != h1);
486
    return ((int64_t)h << 32) | l;
487
}
488

    
489
#elif defined(__i386__)
490

    
491
int64_t cpu_get_real_ticks(void)
492
{
493
    int64_t val;
494
    asm volatile ("rdtsc" : "=A" (val));
495
    return val;
496
}
497

    
498
#elif defined(__x86_64__)
499

    
500
int64_t cpu_get_real_ticks(void)
501
{
502
    uint32_t low,high;
503
    int64_t val;
504
    asm volatile("rdtsc" : "=a" (low), "=d" (high));
505
    val = high;
506
    val <<= 32;
507
    val |= low;
508
    return val;
509
}
510

    
511
#else
512
#error unsupported CPU
513
#endif
514

    
515
static int64_t cpu_ticks_offset;
516
static int cpu_ticks_enabled;
517

    
518
static inline int64_t cpu_get_ticks(void)
519
{
520
    if (!cpu_ticks_enabled) {
521
        return cpu_ticks_offset;
522
    } else {
523
        return cpu_get_real_ticks() + cpu_ticks_offset;
524
    }
525
}
526

    
527
/* enable cpu_get_ticks() */
528
void cpu_enable_ticks(void)
529
{
530
    if (!cpu_ticks_enabled) {
531
        cpu_ticks_offset -= cpu_get_real_ticks();
532
        cpu_ticks_enabled = 1;
533
    }
534
}
535

    
536
/* disable cpu_get_ticks() : the clock is stopped. You must not call
537
   cpu_get_ticks() after that.  */
538
void cpu_disable_ticks(void)
539
{
540
    if (cpu_ticks_enabled) {
541
        cpu_ticks_offset = cpu_get_ticks();
542
        cpu_ticks_enabled = 0;
543
    }
544
}
545

    
546
static int64_t get_clock(void)
547
{
548
#ifdef _WIN32
549
    struct _timeb tb;
550
    _ftime(&tb);
551
    return ((int64_t)tb.time * 1000 + (int64_t)tb.millitm) * 1000;
552
#else
553
    struct timeval tv;
554
    gettimeofday(&tv, NULL);
555
    return tv.tv_sec * 1000000LL + tv.tv_usec;
556
#endif
557
}
558

    
559
void cpu_calibrate_ticks(void)
560
{
561
    int64_t usec, ticks;
562

    
563
    usec = get_clock();
564
    ticks = cpu_get_real_ticks();
565
#ifdef _WIN32
566
    Sleep(50);
567
#else
568
    usleep(50 * 1000);
569
#endif
570
    usec = get_clock() - usec;
571
    ticks = cpu_get_real_ticks() - ticks;
572
    ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec;
573
}
574

    
575
/* compute with 96 bit intermediate result: (a*b)/c */
576
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
577
{
578
    union {
579
        uint64_t ll;
580
        struct {
581
#ifdef WORDS_BIGENDIAN
582
            uint32_t high, low;
583
#else
584
            uint32_t low, high;
585
#endif            
586
        } l;
587
    } u, res;
588
    uint64_t rl, rh;
589

    
590
    u.ll = a;
591
    rl = (uint64_t)u.l.low * (uint64_t)b;
592
    rh = (uint64_t)u.l.high * (uint64_t)b;
593
    rh += (rl >> 32);
594
    res.l.high = rh / c;
595
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
596
    return res.ll;
597
}
598

    
599
#define QEMU_TIMER_REALTIME 0
600
#define QEMU_TIMER_VIRTUAL  1
601

    
602
struct QEMUClock {
603
    int type;
604
    /* XXX: add frequency */
605
};
606

    
607
struct QEMUTimer {
608
    QEMUClock *clock;
609
    int64_t expire_time;
610
    QEMUTimerCB *cb;
611
    void *opaque;
612
    struct QEMUTimer *next;
613
};
614

    
615
QEMUClock *rt_clock;
616
QEMUClock *vm_clock;
617

    
618
static QEMUTimer *active_timers[2];
619
#ifdef _WIN32
620
static MMRESULT timerID;
621
#else
622
/* frequency of the times() clock tick */
623
static int timer_freq;
624
#endif
625

    
626
QEMUClock *qemu_new_clock(int type)
627
{
628
    QEMUClock *clock;
629
    clock = qemu_mallocz(sizeof(QEMUClock));
630
    if (!clock)
631
        return NULL;
632
    clock->type = type;
633
    return clock;
634
}
635

    
636
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
637
{
638
    QEMUTimer *ts;
639

    
640
    ts = qemu_mallocz(sizeof(QEMUTimer));
641
    ts->clock = clock;
642
    ts->cb = cb;
643
    ts->opaque = opaque;
644
    return ts;
645
}
646

    
647
void qemu_free_timer(QEMUTimer *ts)
648
{
649
    qemu_free(ts);
650
}
651

    
652
/* stop a timer, but do not dealloc it */
653
void qemu_del_timer(QEMUTimer *ts)
654
{
655
    QEMUTimer **pt, *t;
656

    
657
    /* NOTE: this code must be signal safe because
658
       qemu_timer_expired() can be called from a signal. */
659
    pt = &active_timers[ts->clock->type];
660
    for(;;) {
661
        t = *pt;
662
        if (!t)
663
            break;
664
        if (t == ts) {
665
            *pt = t->next;
666
            break;
667
        }
668
        pt = &t->next;
669
    }
670
}
671

    
672
/* modify the current timer so that it will be fired when current_time
673
   >= expire_time. The corresponding callback will be called. */
674
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
675
{
676
    QEMUTimer **pt, *t;
677

    
678
    qemu_del_timer(ts);
679

    
680
    /* add the timer in the sorted list */
681
    /* NOTE: this code must be signal safe because
682
       qemu_timer_expired() can be called from a signal. */
683
    pt = &active_timers[ts->clock->type];
684
    for(;;) {
685
        t = *pt;
686
        if (!t)
687
            break;
688
        if (t->expire_time > expire_time) 
689
            break;
690
        pt = &t->next;
691
    }
692
    ts->expire_time = expire_time;
693
    ts->next = *pt;
694
    *pt = ts;
695
}
696

    
697
int qemu_timer_pending(QEMUTimer *ts)
698
{
699
    QEMUTimer *t;
700
    for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
701
        if (t == ts)
702
            return 1;
703
    }
704
    return 0;
705
}
706

    
707
static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
708
{
709
    if (!timer_head)
710
        return 0;
711
    return (timer_head->expire_time <= current_time);
712
}
713

    
714
static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
715
{
716
    QEMUTimer *ts;
717
    
718
    for(;;) {
719
        ts = *ptimer_head;
720
        if (!ts || ts->expire_time > current_time)
721
            break;
722
        /* remove timer from the list before calling the callback */
723
        *ptimer_head = ts->next;
724
        ts->next = NULL;
725
        
726
        /* run the callback (the timer list can be modified) */
727
        ts->cb(ts->opaque);
728
    }
729
}
730

    
731
int64_t qemu_get_clock(QEMUClock *clock)
732
{
733
    switch(clock->type) {
734
    case QEMU_TIMER_REALTIME:
735
#ifdef _WIN32
736
        return GetTickCount();
737
#else
738
        {
739
            struct tms tp;
740

    
741
            /* Note that using gettimeofday() is not a good solution
742
               for timers because its value change when the date is
743
               modified. */
744
            if (timer_freq == 100) {
745
                return times(&tp) * 10;
746
            } else {
747
                return ((int64_t)times(&tp) * 1000) / timer_freq;
748
            }
749
        }
750
#endif
751
    default:
752
    case QEMU_TIMER_VIRTUAL:
753
        return cpu_get_ticks();
754
    }
755
}
756

    
757
/* save a timer */
758
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
759
{
760
    uint64_t expire_time;
761

    
762
    if (qemu_timer_pending(ts)) {
763
        expire_time = ts->expire_time;
764
    } else {
765
        expire_time = -1;
766
    }
767
    qemu_put_be64(f, expire_time);
768
}
769

    
770
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
771
{
772
    uint64_t expire_time;
773

    
774
    expire_time = qemu_get_be64(f);
775
    if (expire_time != -1) {
776
        qemu_mod_timer(ts, expire_time);
777
    } else {
778
        qemu_del_timer(ts);
779
    }
780
}
781

    
782
static void timer_save(QEMUFile *f, void *opaque)
783
{
784
    if (cpu_ticks_enabled) {
785
        hw_error("cannot save state if virtual timers are running");
786
    }
787
    qemu_put_be64s(f, &cpu_ticks_offset);
788
    qemu_put_be64s(f, &ticks_per_sec);
789
}
790

    
791
static int timer_load(QEMUFile *f, void *opaque, int version_id)
792
{
793
    if (version_id != 1)
794
        return -EINVAL;
795
    if (cpu_ticks_enabled) {
796
        return -EINVAL;
797
    }
798
    qemu_get_be64s(f, &cpu_ticks_offset);
799
    qemu_get_be64s(f, &ticks_per_sec);
800
    return 0;
801
}
802

    
803
#ifdef _WIN32
804
void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg, 
805
                                 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
806
#else
807
static void host_alarm_handler(int host_signum)
808
#endif
809
{
810
#if 0
811
#define DISP_FREQ 1000
812
    {
813
        static int64_t delta_min = INT64_MAX;
814
        static int64_t delta_max, delta_cum, last_clock, delta, ti;
815
        static int count;
816
        ti = qemu_get_clock(vm_clock);
817
        if (last_clock != 0) {
818
            delta = ti - last_clock;
819
            if (delta < delta_min)
820
                delta_min = delta;
821
            if (delta > delta_max)
822
                delta_max = delta;
823
            delta_cum += delta;
824
            if (++count == DISP_FREQ) {
825
                printf("timer: min=%lld us max=%lld us avg=%lld us avg_freq=%0.3f Hz\n",
826
                       muldiv64(delta_min, 1000000, ticks_per_sec),
827
                       muldiv64(delta_max, 1000000, ticks_per_sec),
828
                       muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
829
                       (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
830
                count = 0;
831
                delta_min = INT64_MAX;
832
                delta_max = 0;
833
                delta_cum = 0;
834
            }
835
        }
836
        last_clock = ti;
837
    }
838
#endif
839
    if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
840
                           qemu_get_clock(vm_clock)) ||
841
        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
842
                           qemu_get_clock(rt_clock))) {
843
        /* stop the cpu because a timer occured */
844
        cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
845
    }
846
}
847

    
848
#ifndef _WIN32
849

    
850
#if defined(__linux__)
851

    
852
#define RTC_FREQ 1024
853

    
854
static int rtc_fd;
855

    
856
static int start_rtc_timer(void)
857
{
858
    rtc_fd = open("/dev/rtc", O_RDONLY);
859
    if (rtc_fd < 0)
860
        return -1;
861
    if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
862
        fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
863
                "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
864
                "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
865
        goto fail;
866
    }
867
    if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
868
    fail:
869
        close(rtc_fd);
870
        return -1;
871
    }
872
    pit_min_timer_count = PIT_FREQ / RTC_FREQ;
873
    return 0;
874
}
875

    
876
#else
877

    
878
static int start_rtc_timer(void)
879
{
880
    return -1;
881
}
882

    
883
#endif /* !defined(__linux__) */
884

    
885
#endif /* !defined(_WIN32) */
886

    
887
static void init_timers(void)
888
{
889
    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
890
    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
891

    
892
#ifdef _WIN32
893
    {
894
        int count=0;
895
        timerID = timeSetEvent(10,    // interval (ms)
896
                               0,     // resolution
897
                               host_alarm_handler, // function
898
                               (DWORD)&count,  // user parameter
899
                               TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
900
         if( !timerID ) {
901
            perror("failed timer alarm");
902
            exit(1);
903
         }
904
    }
905
    pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
906
#else
907
    {
908
        struct sigaction act;
909
        struct itimerval itv;
910
        
911
        /* get times() syscall frequency */
912
        timer_freq = sysconf(_SC_CLK_TCK);
913
        
914
        /* timer signal */
915
        sigfillset(&act.sa_mask);
916
        act.sa_flags = 0;
917
#if defined (TARGET_I386) && defined(USE_CODE_COPY)
918
        act.sa_flags |= SA_ONSTACK;
919
#endif
920
        act.sa_handler = host_alarm_handler;
921
        sigaction(SIGALRM, &act, NULL);
922

    
923
        itv.it_interval.tv_sec = 0;
924
        itv.it_interval.tv_usec = 1000;
925
        itv.it_value.tv_sec = 0;
926
        itv.it_value.tv_usec = 10 * 1000;
927
        setitimer(ITIMER_REAL, &itv, NULL);
928
        /* we probe the tick duration of the kernel to inform the user if
929
           the emulated kernel requested a too high timer frequency */
930
        getitimer(ITIMER_REAL, &itv);
931

    
932
#if defined(__linux__)
933
        if (itv.it_interval.tv_usec > 1000) {
934
            /* try to use /dev/rtc to have a faster timer */
935
            if (start_rtc_timer() < 0)
936
                goto use_itimer;
937
            /* disable itimer */
938
            itv.it_interval.tv_sec = 0;
939
            itv.it_interval.tv_usec = 0;
940
            itv.it_value.tv_sec = 0;
941
            itv.it_value.tv_usec = 0;
942
            setitimer(ITIMER_REAL, &itv, NULL);
943

    
944
            /* use the RTC */
945
            sigaction(SIGIO, &act, NULL);
946
            fcntl(rtc_fd, F_SETFL, O_ASYNC);
947
            fcntl(rtc_fd, F_SETOWN, getpid());
948
        } else 
949
#endif /* defined(__linux__) */
950
        {
951
        use_itimer:
952
            pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec * 
953
                                   PIT_FREQ) / 1000000;
954
        }
955
    }
956
#endif
957
}
958

    
959
void quit_timers(void)
960
{
961
#ifdef _WIN32
962
    timeKillEvent(timerID);
963
#endif
964
}
965

    
966
/***********************************************************/
967
/* character device */
968

    
969
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
970
{
971
    return s->chr_write(s, buf, len);
972
}
973

    
974
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
975
{
976
    char buf[4096];
977
    va_list ap;
978
    va_start(ap, fmt);
979
    vsnprintf(buf, sizeof(buf), fmt, ap);
980
    qemu_chr_write(s, buf, strlen(buf));
981
    va_end(ap);
982
}
983

    
984
void qemu_chr_send_event(CharDriverState *s, int event)
985
{
986
    if (s->chr_send_event)
987
        s->chr_send_event(s, event);
988
}
989

    
990
void qemu_chr_add_read_handler(CharDriverState *s, 
991
                               IOCanRWHandler *fd_can_read, 
992
                               IOReadHandler *fd_read, void *opaque)
993
{
994
    s->chr_add_read_handler(s, fd_can_read, fd_read, opaque);
995
}
996
             
997
void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event)
998
{
999
    s->chr_event = chr_event;
1000
}
1001

    
1002
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1003
{
1004
    return len;
1005
}
1006

    
1007
static void null_chr_add_read_handler(CharDriverState *chr, 
1008
                                    IOCanRWHandler *fd_can_read, 
1009
                                    IOReadHandler *fd_read, void *opaque)
1010
{
1011
}
1012

    
1013
CharDriverState *qemu_chr_open_null(void)
1014
{
1015
    CharDriverState *chr;
1016

    
1017
    chr = qemu_mallocz(sizeof(CharDriverState));
1018
    if (!chr)
1019
        return NULL;
1020
    chr->chr_write = null_chr_write;
1021
    chr->chr_add_read_handler = null_chr_add_read_handler;
1022
    return chr;
1023
}
1024

    
1025
#ifndef _WIN32
1026

    
1027
typedef struct {
1028
    int fd_in, fd_out;
1029
    /* for nographic stdio only */
1030
    IOCanRWHandler *fd_can_read; 
1031
    IOReadHandler *fd_read;
1032
    void *fd_opaque;
1033
} FDCharDriver;
1034

    
1035
#define STDIO_MAX_CLIENTS 2
1036

    
1037
static int stdio_nb_clients;
1038
static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1039

    
1040
static int unix_write(int fd, const uint8_t *buf, int len1)
1041
{
1042
    int ret, len;
1043

    
1044
    len = len1;
1045
    while (len > 0) {
1046
        ret = write(fd, buf, len);
1047
        if (ret < 0) {
1048
            if (errno != EINTR && errno != EAGAIN)
1049
                return -1;
1050
        } else if (ret == 0) {
1051
            break;
1052
        } else {
1053
            buf += ret;
1054
            len -= ret;
1055
        }
1056
    }
1057
    return len1 - len;
1058
}
1059

    
1060
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1061
{
1062
    FDCharDriver *s = chr->opaque;
1063
    return unix_write(s->fd_out, buf, len);
1064
}
1065

    
1066
static void fd_chr_add_read_handler(CharDriverState *chr, 
1067
                                    IOCanRWHandler *fd_can_read, 
1068
                                    IOReadHandler *fd_read, void *opaque)
1069
{
1070
    FDCharDriver *s = chr->opaque;
1071

    
1072
    if (nographic && s->fd_in == 0) {
1073
        s->fd_can_read = fd_can_read;
1074
        s->fd_read = fd_read;
1075
        s->fd_opaque = opaque;
1076
    } else {
1077
        qemu_add_fd_read_handler(s->fd_in, fd_can_read, fd_read, opaque);
1078
    }
1079
}
1080

    
1081
/* open a character device to a unix fd */
1082
CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1083
{
1084
    CharDriverState *chr;
1085
    FDCharDriver *s;
1086

    
1087
    chr = qemu_mallocz(sizeof(CharDriverState));
1088
    if (!chr)
1089
        return NULL;
1090
    s = qemu_mallocz(sizeof(FDCharDriver));
1091
    if (!s) {
1092
        free(chr);
1093
        return NULL;
1094
    }
1095
    s->fd_in = fd_in;
1096
    s->fd_out = fd_out;
1097
    chr->opaque = s;
1098
    chr->chr_write = fd_chr_write;
1099
    chr->chr_add_read_handler = fd_chr_add_read_handler;
1100
    return chr;
1101
}
1102

    
1103
/* for STDIO, we handle the case where several clients use it
1104
   (nographic mode) */
1105

    
1106
#define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */
1107

    
1108
static int term_got_escape, client_index;
1109

    
1110
void term_print_help(void)
1111
{
1112
    printf("\n"
1113
           "C-a h    print this help\n"
1114
           "C-a x    exit emulator\n"
1115
           "C-a s    save disk data back to file (if -snapshot)\n"
1116
           "C-a b    send break (magic sysrq)\n"
1117
           "C-a c    switch between console and monitor\n"
1118
           "C-a C-a  send C-a\n"
1119
           );
1120
}
1121

    
1122
/* called when a char is received */
1123
static void stdio_received_byte(int ch)
1124
{
1125
    if (term_got_escape) {
1126
        term_got_escape = 0;
1127
        switch(ch) {
1128
        case 'h':
1129
            term_print_help();
1130
            break;
1131
        case 'x':
1132
            exit(0);
1133
            break;
1134
        case 's': 
1135
            {
1136
                int i;
1137
                for (i = 0; i < MAX_DISKS; i++) {
1138
                    if (bs_table[i])
1139
                        bdrv_commit(bs_table[i]);
1140
                }
1141
            }
1142
            break;
1143
        case 'b':
1144
            if (client_index < stdio_nb_clients) {
1145
                CharDriverState *chr;
1146
                FDCharDriver *s;
1147

    
1148
                chr = stdio_clients[client_index];
1149
                s = chr->opaque;
1150
                chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
1151
            }
1152
            break;
1153
        case 'c':
1154
            client_index++;
1155
            if (client_index >= stdio_nb_clients)
1156
                client_index = 0;
1157
            if (client_index == 0) {
1158
                /* send a new line in the monitor to get the prompt */
1159
                ch = '\r';
1160
                goto send_char;
1161
            }
1162
            break;
1163
        case TERM_ESCAPE:
1164
            goto send_char;
1165
        }
1166
    } else if (ch == TERM_ESCAPE) {
1167
        term_got_escape = 1;
1168
    } else {
1169
    send_char:
1170
        if (client_index < stdio_nb_clients) {
1171
            uint8_t buf[1];
1172
            CharDriverState *chr;
1173
            FDCharDriver *s;
1174
            
1175
            chr = stdio_clients[client_index];
1176
            s = chr->opaque;
1177
            buf[0] = ch;
1178
            /* XXX: should queue the char if the device is not
1179
               ready */
1180
            if (s->fd_can_read(s->fd_opaque) > 0) 
1181
                s->fd_read(s->fd_opaque, buf, 1);
1182
        }
1183
    }
1184
}
1185

    
1186
static int stdio_can_read(void *opaque)
1187
{
1188
    /* XXX: not strictly correct */
1189
    return 1;
1190
}
1191

    
1192
static void stdio_read(void *opaque, const uint8_t *buf, int size)
1193
{
1194
    int i;
1195
    for(i = 0; i < size; i++)
1196
        stdio_received_byte(buf[i]);
1197
}
1198

    
1199
/* init terminal so that we can grab keys */
1200
static struct termios oldtty;
1201
static int old_fd0_flags;
1202

    
1203
static void term_exit(void)
1204
{
1205
    tcsetattr (0, TCSANOW, &oldtty);
1206
    fcntl(0, F_SETFL, old_fd0_flags);
1207
}
1208

    
1209
static void term_init(void)
1210
{
1211
    struct termios tty;
1212

    
1213
    tcgetattr (0, &tty);
1214
    oldtty = tty;
1215
    old_fd0_flags = fcntl(0, F_GETFL);
1216

    
1217
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1218
                          |INLCR|IGNCR|ICRNL|IXON);
1219
    tty.c_oflag |= OPOST;
1220
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1221
    /* if graphical mode, we allow Ctrl-C handling */
1222
    if (nographic)
1223
        tty.c_lflag &= ~ISIG;
1224
    tty.c_cflag &= ~(CSIZE|PARENB);
1225
    tty.c_cflag |= CS8;
1226
    tty.c_cc[VMIN] = 1;
1227
    tty.c_cc[VTIME] = 0;
1228
    
1229
    tcsetattr (0, TCSANOW, &tty);
1230

    
1231
    atexit(term_exit);
1232

    
1233
    fcntl(0, F_SETFL, O_NONBLOCK);
1234
}
1235

    
1236
CharDriverState *qemu_chr_open_stdio(void)
1237
{
1238
    CharDriverState *chr;
1239

    
1240
    if (nographic) {
1241
        if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
1242
            return NULL;
1243
        chr = qemu_chr_open_fd(0, 1);
1244
        if (stdio_nb_clients == 0)
1245
            qemu_add_fd_read_handler(0, stdio_can_read, stdio_read, NULL);
1246
        client_index = stdio_nb_clients;
1247
    } else {
1248
        if (stdio_nb_clients != 0)
1249
            return NULL;
1250
        chr = qemu_chr_open_fd(0, 1);
1251
    }
1252
    stdio_clients[stdio_nb_clients++] = chr;
1253
    if (stdio_nb_clients == 1) {
1254
        /* set the terminal in raw mode */
1255
        term_init();
1256
    }
1257
    return chr;
1258
}
1259

    
1260
#if defined(__linux__)
1261
CharDriverState *qemu_chr_open_pty(void)
1262
{
1263
    char slave_name[1024];
1264
    int master_fd, slave_fd;
1265
    
1266
    /* Not satisfying */
1267
    if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
1268
        return NULL;
1269
    }
1270
    fprintf(stderr, "char device redirected to %s\n", slave_name);
1271
    return qemu_chr_open_fd(master_fd, master_fd);
1272
}
1273
#else
1274
CharDriverState *qemu_chr_open_pty(void)
1275
{
1276
    return NULL;
1277
}
1278
#endif
1279

    
1280
#endif /* !defined(_WIN32) */
1281

    
1282
CharDriverState *qemu_chr_open(const char *filename)
1283
{
1284
    if (!strcmp(filename, "vc")) {
1285
        return text_console_init(&display_state);
1286
    } else if (!strcmp(filename, "null")) {
1287
        return qemu_chr_open_null();
1288
    } else 
1289
#ifndef _WIN32
1290
    if (!strcmp(filename, "pty")) {
1291
        return qemu_chr_open_pty();
1292
    } else if (!strcmp(filename, "stdio")) {
1293
        return qemu_chr_open_stdio();
1294
    } else 
1295
#endif
1296
    {
1297
        return NULL;
1298
    }
1299
}
1300

    
1301
/***********************************************************/
1302
/* Linux network device redirectors */
1303

    
1304
void hex_dump(FILE *f, const uint8_t *buf, int size)
1305
{
1306
    int len, i, j, c;
1307

    
1308
    for(i=0;i<size;i+=16) {
1309
        len = size - i;
1310
        if (len > 16)
1311
            len = 16;
1312
        fprintf(f, "%08x ", i);
1313
        for(j=0;j<16;j++) {
1314
            if (j < len)
1315
                fprintf(f, " %02x", buf[i+j]);
1316
            else
1317
                fprintf(f, "   ");
1318
        }
1319
        fprintf(f, " ");
1320
        for(j=0;j<len;j++) {
1321
            c = buf[i+j];
1322
            if (c < ' ' || c > '~')
1323
                c = '.';
1324
            fprintf(f, "%c", c);
1325
        }
1326
        fprintf(f, "\n");
1327
    }
1328
}
1329

    
1330
void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1331
{
1332
    nd->send_packet(nd, buf, size);
1333
}
1334

    
1335
void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read, 
1336
                          IOReadHandler *fd_read, void *opaque)
1337
{
1338
    nd->add_read_packet(nd, fd_can_read, fd_read, opaque);
1339
}
1340

    
1341
/* dummy network adapter */
1342

    
1343
static void dummy_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1344
{
1345
}
1346

    
1347
static void dummy_add_read_packet(NetDriverState *nd, 
1348
                                  IOCanRWHandler *fd_can_read, 
1349
                                  IOReadHandler *fd_read, void *opaque)
1350
{
1351
}
1352

    
1353
static int net_dummy_init(NetDriverState *nd)
1354
{
1355
    nd->send_packet = dummy_send_packet;
1356
    nd->add_read_packet = dummy_add_read_packet;
1357
    pstrcpy(nd->ifname, sizeof(nd->ifname), "dummy");
1358
    return 0;
1359
}
1360

    
1361
#if defined(CONFIG_SLIRP)
1362

    
1363
/* slirp network adapter */
1364

    
1365
static void *slirp_fd_opaque;
1366
static IOCanRWHandler *slirp_fd_can_read;
1367
static IOReadHandler *slirp_fd_read;
1368
static int slirp_inited;
1369

    
1370
int slirp_can_output(void)
1371
{
1372
    return slirp_fd_can_read(slirp_fd_opaque);
1373
}
1374

    
1375
void slirp_output(const uint8_t *pkt, int pkt_len)
1376
{
1377
#if 0
1378
    printf("output:\n");
1379
    hex_dump(stdout, pkt, pkt_len);
1380
#endif
1381
    slirp_fd_read(slirp_fd_opaque, pkt, pkt_len);
1382
}
1383

    
1384
static void slirp_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1385
{
1386
#if 0
1387
    printf("input:\n");
1388
    hex_dump(stdout, buf, size);
1389
#endif
1390
    slirp_input(buf, size);
1391
}
1392

    
1393
static void slirp_add_read_packet(NetDriverState *nd, 
1394
                                  IOCanRWHandler *fd_can_read, 
1395
                                  IOReadHandler *fd_read, void *opaque)
1396
{
1397
    slirp_fd_opaque = opaque;
1398
    slirp_fd_can_read = fd_can_read;
1399
    slirp_fd_read = fd_read;
1400
}
1401

    
1402
static int net_slirp_init(NetDriverState *nd)
1403
{
1404
    if (!slirp_inited) {
1405
        slirp_inited = 1;
1406
        slirp_init();
1407
    }
1408
    nd->send_packet = slirp_send_packet;
1409
    nd->add_read_packet = slirp_add_read_packet;
1410
    pstrcpy(nd->ifname, sizeof(nd->ifname), "slirp");
1411
    return 0;
1412
}
1413

    
1414
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
1415
{
1416
    const char *p, *p1;
1417
    int len;
1418
    p = *pp;
1419
    p1 = strchr(p, sep);
1420
    if (!p1)
1421
        return -1;
1422
    len = p1 - p;
1423
    p1++;
1424
    if (buf_size > 0) {
1425
        if (len > buf_size - 1)
1426
            len = buf_size - 1;
1427
        memcpy(buf, p, len);
1428
        buf[len] = '\0';
1429
    }
1430
    *pp = p1;
1431
    return 0;
1432
}
1433

    
1434
static void net_slirp_redir(const char *redir_str)
1435
{
1436
    int is_udp;
1437
    char buf[256], *r;
1438
    const char *p;
1439
    struct in_addr guest_addr;
1440
    int host_port, guest_port;
1441
    
1442
    if (!slirp_inited) {
1443
        slirp_inited = 1;
1444
        slirp_init();
1445
    }
1446

    
1447
    p = redir_str;
1448
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1449
        goto fail;
1450
    if (!strcmp(buf, "tcp")) {
1451
        is_udp = 0;
1452
    } else if (!strcmp(buf, "udp")) {
1453
        is_udp = 1;
1454
    } else {
1455
        goto fail;
1456
    }
1457

    
1458
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1459
        goto fail;
1460
    host_port = strtol(buf, &r, 0);
1461
    if (r == buf)
1462
        goto fail;
1463

    
1464
    if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1465
        goto fail;
1466
    if (buf[0] == '\0') {
1467
        pstrcpy(buf, sizeof(buf), "10.0.2.15");
1468
    }
1469
    if (!inet_aton(buf, &guest_addr))
1470
        goto fail;
1471
    
1472
    guest_port = strtol(p, &r, 0);
1473
    if (r == p)
1474
        goto fail;
1475
    
1476
    if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
1477
        fprintf(stderr, "qemu: could not set up redirection\n");
1478
        exit(1);
1479
    }
1480
    return;
1481
 fail:
1482
    fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
1483
    exit(1);
1484
}
1485
    
1486
#ifndef _WIN32
1487

    
1488
char smb_dir[1024];
1489

    
1490
static void smb_exit(void)
1491
{
1492
    DIR *d;
1493
    struct dirent *de;
1494
    char filename[1024];
1495

    
1496
    /* erase all the files in the directory */
1497
    d = opendir(smb_dir);
1498
    for(;;) {
1499
        de = readdir(d);
1500
        if (!de)
1501
            break;
1502
        if (strcmp(de->d_name, ".") != 0 &&
1503
            strcmp(de->d_name, "..") != 0) {
1504
            snprintf(filename, sizeof(filename), "%s/%s", 
1505
                     smb_dir, de->d_name);
1506
            unlink(filename);
1507
        }
1508
    }
1509
    closedir(d);
1510
    rmdir(smb_dir);
1511
}
1512

    
1513
/* automatic user mode samba server configuration */
1514
void net_slirp_smb(const char *exported_dir)
1515
{
1516
    char smb_conf[1024];
1517
    char smb_cmdline[1024];
1518
    FILE *f;
1519

    
1520
    if (!slirp_inited) {
1521
        slirp_inited = 1;
1522
        slirp_init();
1523
    }
1524

    
1525
    /* XXX: better tmp dir construction */
1526
    snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
1527
    if (mkdir(smb_dir, 0700) < 0) {
1528
        fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
1529
        exit(1);
1530
    }
1531
    snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
1532
    
1533
    f = fopen(smb_conf, "w");
1534
    if (!f) {
1535
        fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
1536
        exit(1);
1537
    }
1538
    fprintf(f, 
1539
            "[global]\n"
1540
            "pid directory=%s\n"
1541
            "lock directory=%s\n"
1542
            "log file=%s/log.smbd\n"
1543
            "smb passwd file=%s/smbpasswd\n"
1544
            "security = share\n"
1545
            "[qemu]\n"
1546
            "path=%s\n"
1547
            "read only=no\n"
1548
            "guest ok=yes\n",
1549
            smb_dir,
1550
            smb_dir,
1551
            smb_dir,
1552
            smb_dir,
1553
            exported_dir
1554
            );
1555
    fclose(f);
1556
    atexit(smb_exit);
1557

    
1558
    snprintf(smb_cmdline, sizeof(smb_cmdline), "/usr/sbin/smbd -s %s",
1559
             smb_conf);
1560
    
1561
    slirp_add_exec(0, smb_cmdline, 4, 139);
1562
}
1563

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

    
1566
#endif /* CONFIG_SLIRP */
1567

    
1568
#if !defined(_WIN32)
1569
#ifdef _BSD
1570
static int tun_open(char *ifname, int ifname_size)
1571
{
1572
    int fd;
1573
    char *dev;
1574
    struct stat s;
1575

    
1576
    fd = open("/dev/tap", O_RDWR);
1577
    if (fd < 0) {
1578
        fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
1579
        return -1;
1580
    }
1581

    
1582
    fstat(fd, &s);
1583
    dev = devname(s.st_rdev, S_IFCHR);
1584
    pstrcpy(ifname, ifname_size, dev);
1585

    
1586
    fcntl(fd, F_SETFL, O_NONBLOCK);
1587
    return fd;
1588
}
1589
#else
1590
static int tun_open(char *ifname, int ifname_size)
1591
{
1592
    struct ifreq ifr;
1593
    int fd, ret;
1594
    
1595
    fd = open("/dev/net/tun", O_RDWR);
1596
    if (fd < 0) {
1597
        fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1598
        return -1;
1599
    }
1600
    memset(&ifr, 0, sizeof(ifr));
1601
    ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1602
    pstrcpy(ifr.ifr_name, IFNAMSIZ, "tun%d");
1603
    ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1604
    if (ret != 0) {
1605
        fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1606
        close(fd);
1607
        return -1;
1608
    }
1609
    printf("Connected to host network interface: %s\n", ifr.ifr_name);
1610
    pstrcpy(ifname, ifname_size, ifr.ifr_name);
1611
    fcntl(fd, F_SETFL, O_NONBLOCK);
1612
    return fd;
1613
}
1614
#endif
1615

    
1616
static void tun_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1617
{
1618
    write(nd->fd, buf, size);
1619
}
1620

    
1621
static void tun_add_read_packet(NetDriverState *nd, 
1622
                                IOCanRWHandler *fd_can_read, 
1623
                                IOReadHandler *fd_read, void *opaque)
1624
{
1625
    qemu_add_fd_read_handler(nd->fd, fd_can_read, fd_read, opaque);
1626
}
1627

    
1628
static int net_tun_init(NetDriverState *nd)
1629
{
1630
    int pid, status;
1631
    char *args[3];
1632
    char **parg;
1633

    
1634
    nd->fd = tun_open(nd->ifname, sizeof(nd->ifname));
1635
    if (nd->fd < 0)
1636
        return -1;
1637

    
1638
    /* try to launch network init script */
1639
    pid = fork();
1640
    if (pid >= 0) {
1641
        if (pid == 0) {
1642
            parg = args;
1643
            *parg++ = network_script;
1644
            *parg++ = nd->ifname;
1645
            *parg++ = NULL;
1646
            execv(network_script, args);
1647
            exit(1);
1648
        }
1649
        while (waitpid(pid, &status, 0) != pid);
1650
        if (!WIFEXITED(status) ||
1651
            WEXITSTATUS(status) != 0) {
1652
            fprintf(stderr, "%s: could not launch network script\n",
1653
                    network_script);
1654
        }
1655
    }
1656
    nd->send_packet = tun_send_packet;
1657
    nd->add_read_packet = tun_add_read_packet;
1658
    return 0;
1659
}
1660

    
1661
static int net_fd_init(NetDriverState *nd, int fd)
1662
{
1663
    nd->fd = fd;
1664
    nd->send_packet = tun_send_packet;
1665
    nd->add_read_packet = tun_add_read_packet;
1666
    pstrcpy(nd->ifname, sizeof(nd->ifname), "tunfd");
1667
    return 0;
1668
}
1669

    
1670
#endif /* !_WIN32 */
1671

    
1672
/***********************************************************/
1673
/* pid file */
1674

    
1675
static char *pid_filename;
1676

    
1677
/* Remove PID file. Called on normal exit */
1678

    
1679
static void remove_pidfile(void) 
1680
{
1681
    unlink (pid_filename);
1682
}
1683

    
1684
static void create_pidfile(const char *filename)
1685
{
1686
    struct stat pidstat;
1687
    FILE *f;
1688

    
1689
    /* Try to write our PID to the named file */
1690
    if (stat(filename, &pidstat) < 0) {
1691
        if (errno == ENOENT) {
1692
            if ((f = fopen (filename, "w")) == NULL) {
1693
                perror("Opening pidfile");
1694
                exit(1);
1695
            }
1696
            fprintf(f, "%d\n", getpid());
1697
            fclose(f);
1698
            pid_filename = qemu_strdup(filename);
1699
            if (!pid_filename) {
1700
                fprintf(stderr, "Could not save PID filename");
1701
                exit(1);
1702
            }
1703
            atexit(remove_pidfile);
1704
        }
1705
    } else {
1706
        fprintf(stderr, "%s already exists. Remove it and try again.\n", 
1707
                filename);
1708
        exit(1);
1709
    }
1710
}
1711

    
1712
/***********************************************************/
1713
/* dumb display */
1714

    
1715
static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
1716
{
1717
}
1718

    
1719
static void dumb_resize(DisplayState *ds, int w, int h)
1720
{
1721
}
1722

    
1723
static void dumb_refresh(DisplayState *ds)
1724
{
1725
    vga_update_display();
1726
}
1727

    
1728
void dumb_display_init(DisplayState *ds)
1729
{
1730
    ds->data = NULL;
1731
    ds->linesize = 0;
1732
    ds->depth = 0;
1733
    ds->dpy_update = dumb_update;
1734
    ds->dpy_resize = dumb_resize;
1735
    ds->dpy_refresh = dumb_refresh;
1736
}
1737

    
1738
#if !defined(CONFIG_SOFTMMU)
1739
/***********************************************************/
1740
/* cpu signal handler */
1741
static void host_segv_handler(int host_signum, siginfo_t *info, 
1742
                              void *puc)
1743
{
1744
    if (cpu_signal_handler(host_signum, info, puc))
1745
        return;
1746
    if (stdio_nb_clients > 0)
1747
        term_exit();
1748
    abort();
1749
}
1750
#endif
1751

    
1752
/***********************************************************/
1753
/* I/O handling */
1754

    
1755
#define MAX_IO_HANDLERS 64
1756

    
1757
typedef struct IOHandlerRecord {
1758
    int fd;
1759
    IOCanRWHandler *fd_can_read;
1760
    IOReadHandler *fd_read;
1761
    void *opaque;
1762
    /* temporary data */
1763
    struct pollfd *ufd;
1764
    int max_size;
1765
    struct IOHandlerRecord *next;
1766
} IOHandlerRecord;
1767

    
1768
static IOHandlerRecord *first_io_handler;
1769

    
1770
int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read, 
1771
                             IOReadHandler *fd_read, void *opaque)
1772
{
1773
    IOHandlerRecord *ioh;
1774

    
1775
    ioh = qemu_mallocz(sizeof(IOHandlerRecord));
1776
    if (!ioh)
1777
        return -1;
1778
    ioh->fd = fd;
1779
    ioh->fd_can_read = fd_can_read;
1780
    ioh->fd_read = fd_read;
1781
    ioh->opaque = opaque;
1782
    ioh->next = first_io_handler;
1783
    first_io_handler = ioh;
1784
    return 0;
1785
}
1786

    
1787
void qemu_del_fd_read_handler(int fd)
1788
{
1789
    IOHandlerRecord **pioh, *ioh;
1790

    
1791
    pioh = &first_io_handler;
1792
    for(;;) {
1793
        ioh = *pioh;
1794
        if (ioh == NULL)
1795
            break;
1796
        if (ioh->fd == fd) {
1797
            *pioh = ioh->next;
1798
            break;
1799
        }
1800
        pioh = &ioh->next;
1801
    }
1802
}
1803

    
1804
/***********************************************************/
1805
/* savevm/loadvm support */
1806

    
1807
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
1808
{
1809
    fwrite(buf, 1, size, f);
1810
}
1811

    
1812
void qemu_put_byte(QEMUFile *f, int v)
1813
{
1814
    fputc(v, f);
1815
}
1816

    
1817
void qemu_put_be16(QEMUFile *f, unsigned int v)
1818
{
1819
    qemu_put_byte(f, v >> 8);
1820
    qemu_put_byte(f, v);
1821
}
1822

    
1823
void qemu_put_be32(QEMUFile *f, unsigned int v)
1824
{
1825
    qemu_put_byte(f, v >> 24);
1826
    qemu_put_byte(f, v >> 16);
1827
    qemu_put_byte(f, v >> 8);
1828
    qemu_put_byte(f, v);
1829
}
1830

    
1831
void qemu_put_be64(QEMUFile *f, uint64_t v)
1832
{
1833
    qemu_put_be32(f, v >> 32);
1834
    qemu_put_be32(f, v);
1835
}
1836

    
1837
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
1838
{
1839
    return fread(buf, 1, size, f);
1840
}
1841

    
1842
int qemu_get_byte(QEMUFile *f)
1843
{
1844
    int v;
1845
    v = fgetc(f);
1846
    if (v == EOF)
1847
        return 0;
1848
    else
1849
        return v;
1850
}
1851

    
1852
unsigned int qemu_get_be16(QEMUFile *f)
1853
{
1854
    unsigned int v;
1855
    v = qemu_get_byte(f) << 8;
1856
    v |= qemu_get_byte(f);
1857
    return v;
1858
}
1859

    
1860
unsigned int qemu_get_be32(QEMUFile *f)
1861
{
1862
    unsigned int v;
1863
    v = qemu_get_byte(f) << 24;
1864
    v |= qemu_get_byte(f) << 16;
1865
    v |= qemu_get_byte(f) << 8;
1866
    v |= qemu_get_byte(f);
1867
    return v;
1868
}
1869

    
1870
uint64_t qemu_get_be64(QEMUFile *f)
1871
{
1872
    uint64_t v;
1873
    v = (uint64_t)qemu_get_be32(f) << 32;
1874
    v |= qemu_get_be32(f);
1875
    return v;
1876
}
1877

    
1878
int64_t qemu_ftell(QEMUFile *f)
1879
{
1880
    return ftell(f);
1881
}
1882

    
1883
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
1884
{
1885
    if (fseek(f, pos, whence) < 0)
1886
        return -1;
1887
    return ftell(f);
1888
}
1889

    
1890
typedef struct SaveStateEntry {
1891
    char idstr[256];
1892
    int instance_id;
1893
    int version_id;
1894
    SaveStateHandler *save_state;
1895
    LoadStateHandler *load_state;
1896
    void *opaque;
1897
    struct SaveStateEntry *next;
1898
} SaveStateEntry;
1899

    
1900
static SaveStateEntry *first_se;
1901

    
1902
int register_savevm(const char *idstr, 
1903
                    int instance_id, 
1904
                    int version_id,
1905
                    SaveStateHandler *save_state,
1906
                    LoadStateHandler *load_state,
1907
                    void *opaque)
1908
{
1909
    SaveStateEntry *se, **pse;
1910

    
1911
    se = qemu_malloc(sizeof(SaveStateEntry));
1912
    if (!se)
1913
        return -1;
1914
    pstrcpy(se->idstr, sizeof(se->idstr), idstr);
1915
    se->instance_id = instance_id;
1916
    se->version_id = version_id;
1917
    se->save_state = save_state;
1918
    se->load_state = load_state;
1919
    se->opaque = opaque;
1920
    se->next = NULL;
1921

    
1922
    /* add at the end of list */
1923
    pse = &first_se;
1924
    while (*pse != NULL)
1925
        pse = &(*pse)->next;
1926
    *pse = se;
1927
    return 0;
1928
}
1929

    
1930
#define QEMU_VM_FILE_MAGIC   0x5145564d
1931
#define QEMU_VM_FILE_VERSION 0x00000001
1932

    
1933
int qemu_savevm(const char *filename)
1934
{
1935
    SaveStateEntry *se;
1936
    QEMUFile *f;
1937
    int len, len_pos, cur_pos, saved_vm_running, ret;
1938

    
1939
    saved_vm_running = vm_running;
1940
    vm_stop(0);
1941

    
1942
    f = fopen(filename, "wb");
1943
    if (!f) {
1944
        ret = -1;
1945
        goto the_end;
1946
    }
1947

    
1948
    qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1949
    qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1950

    
1951
    for(se = first_se; se != NULL; se = se->next) {
1952
        /* ID string */
1953
        len = strlen(se->idstr);
1954
        qemu_put_byte(f, len);
1955
        qemu_put_buffer(f, se->idstr, len);
1956

    
1957
        qemu_put_be32(f, se->instance_id);
1958
        qemu_put_be32(f, se->version_id);
1959

    
1960
        /* record size: filled later */
1961
        len_pos = ftell(f);
1962
        qemu_put_be32(f, 0);
1963
        
1964
        se->save_state(f, se->opaque);
1965

    
1966
        /* fill record size */
1967
        cur_pos = ftell(f);
1968
        len = ftell(f) - len_pos - 4;
1969
        fseek(f, len_pos, SEEK_SET);
1970
        qemu_put_be32(f, len);
1971
        fseek(f, cur_pos, SEEK_SET);
1972
    }
1973

    
1974
    fclose(f);
1975
    ret = 0;
1976
 the_end:
1977
    if (saved_vm_running)
1978
        vm_start();
1979
    return ret;
1980
}
1981

    
1982
static SaveStateEntry *find_se(const char *idstr, int instance_id)
1983
{
1984
    SaveStateEntry *se;
1985

    
1986
    for(se = first_se; se != NULL; se = se->next) {
1987
        if (!strcmp(se->idstr, idstr) && 
1988
            instance_id == se->instance_id)
1989
            return se;
1990
    }
1991
    return NULL;
1992
}
1993

    
1994
int qemu_loadvm(const char *filename)
1995
{
1996
    SaveStateEntry *se;
1997
    QEMUFile *f;
1998
    int len, cur_pos, ret, instance_id, record_len, version_id;
1999
    int saved_vm_running;
2000
    unsigned int v;
2001
    char idstr[256];
2002
    
2003
    saved_vm_running = vm_running;
2004
    vm_stop(0);
2005

    
2006
    f = fopen(filename, "rb");
2007
    if (!f) {
2008
        ret = -1;
2009
        goto the_end;
2010
    }
2011

    
2012
    v = qemu_get_be32(f);
2013
    if (v != QEMU_VM_FILE_MAGIC)
2014
        goto fail;
2015
    v = qemu_get_be32(f);
2016
    if (v != QEMU_VM_FILE_VERSION) {
2017
    fail:
2018
        fclose(f);
2019
        ret = -1;
2020
        goto the_end;
2021
    }
2022
    for(;;) {
2023
#if defined (DO_TB_FLUSH)
2024
        tb_flush(global_env);
2025
#endif
2026
        len = qemu_get_byte(f);
2027
        if (feof(f))
2028
            break;
2029
        qemu_get_buffer(f, idstr, len);
2030
        idstr[len] = '\0';
2031
        instance_id = qemu_get_be32(f);
2032
        version_id = qemu_get_be32(f);
2033
        record_len = qemu_get_be32(f);
2034
#if 0
2035
        printf("idstr=%s instance=0x%x version=%d len=%d\n", 
2036
               idstr, instance_id, version_id, record_len);
2037
#endif
2038
        cur_pos = ftell(f);
2039
        se = find_se(idstr, instance_id);
2040
        if (!se) {
2041
            fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n", 
2042
                    instance_id, idstr);
2043
        } else {
2044
            ret = se->load_state(f, se->opaque, version_id);
2045
            if (ret < 0) {
2046
                fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n", 
2047
                        instance_id, idstr);
2048
            }
2049
        }
2050
        /* always seek to exact end of record */
2051
        qemu_fseek(f, cur_pos + record_len, SEEK_SET);
2052
    }
2053
    fclose(f);
2054
    ret = 0;
2055
 the_end:
2056
    if (saved_vm_running)
2057
        vm_start();
2058
    return ret;
2059
}
2060

    
2061
/***********************************************************/
2062
/* cpu save/restore */
2063

    
2064
#if defined(TARGET_I386)
2065

    
2066
static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
2067
{
2068
    qemu_put_be32(f, dt->selector);
2069
    qemu_put_betl(f, dt->base);
2070
    qemu_put_be32(f, dt->limit);
2071
    qemu_put_be32(f, dt->flags);
2072
}
2073

    
2074
static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
2075
{
2076
    dt->selector = qemu_get_be32(f);
2077
    dt->base = qemu_get_betl(f);
2078
    dt->limit = qemu_get_be32(f);
2079
    dt->flags = qemu_get_be32(f);
2080
}
2081

    
2082
void cpu_save(QEMUFile *f, void *opaque)
2083
{
2084
    CPUState *env = opaque;
2085
    uint16_t fptag, fpus, fpuc, fpregs_format;
2086
    uint32_t hflags;
2087
    int i;
2088
    
2089
    for(i = 0; i < CPU_NB_REGS; i++)
2090
        qemu_put_betls(f, &env->regs[i]);
2091
    qemu_put_betls(f, &env->eip);
2092
    qemu_put_betls(f, &env->eflags);
2093
    hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
2094
    qemu_put_be32s(f, &hflags);
2095
    
2096
    /* FPU */
2097
    fpuc = env->fpuc;
2098
    fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
2099
    fptag = 0;
2100
    for(i = 0; i < 8; i++) {
2101
        fptag |= ((!env->fptags[i]) << i);
2102
    }
2103
    
2104
    qemu_put_be16s(f, &fpuc);
2105
    qemu_put_be16s(f, &fpus);
2106
    qemu_put_be16s(f, &fptag);
2107

    
2108
#ifdef USE_X86LDOUBLE
2109
    fpregs_format = 0;
2110
#else
2111
    fpregs_format = 1;
2112
#endif
2113
    qemu_put_be16s(f, &fpregs_format);
2114
    
2115
    for(i = 0; i < 8; i++) {
2116
        uint64_t mant;
2117
        uint16_t exp;
2118
#ifdef USE_X86LDOUBLE
2119
        /* we save the real CPU data (in case of MMX usage only 'mant'
2120
           contains the MMX register */
2121
        cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
2122
        qemu_put_be64(f, mant);
2123
        qemu_put_be16(f, exp);
2124
#else
2125
        /* if we use doubles for float emulation, we save the doubles to
2126
           avoid losing information in case of MMX usage. It can give
2127
           problems if the image is restored on a CPU where long
2128
           doubles are used instead. */
2129
        qemu_put_be64(f, env->fpregs[i].xmm.MMX_Q(0));
2130
#endif
2131
    }
2132

    
2133
    for(i = 0; i < 6; i++)
2134
        cpu_put_seg(f, &env->segs[i]);
2135
    cpu_put_seg(f, &env->ldt);
2136
    cpu_put_seg(f, &env->tr);
2137
    cpu_put_seg(f, &env->gdt);
2138
    cpu_put_seg(f, &env->idt);
2139
    
2140
    qemu_put_be32s(f, &env->sysenter_cs);
2141
    qemu_put_be32s(f, &env->sysenter_esp);
2142
    qemu_put_be32s(f, &env->sysenter_eip);
2143
    
2144
    qemu_put_betls(f, &env->cr[0]);
2145
    qemu_put_betls(f, &env->cr[2]);
2146
    qemu_put_betls(f, &env->cr[3]);
2147
    qemu_put_betls(f, &env->cr[4]);
2148
    
2149
    for(i = 0; i < 8; i++)
2150
        qemu_put_betls(f, &env->dr[i]);
2151

    
2152
    /* MMU */
2153
    qemu_put_be32s(f, &env->a20_mask);
2154

    
2155
    /* XMM */
2156
    qemu_put_be32s(f, &env->mxcsr);
2157
    for(i = 0; i < CPU_NB_REGS; i++) {
2158
        qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
2159
        qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
2160
    }
2161

    
2162
#ifdef TARGET_X86_64
2163
    qemu_put_be64s(f, &env->efer);
2164
    qemu_put_be64s(f, &env->star);
2165
    qemu_put_be64s(f, &env->lstar);
2166
    qemu_put_be64s(f, &env->cstar);
2167
    qemu_put_be64s(f, &env->fmask);
2168
    qemu_put_be64s(f, &env->kernelgsbase);
2169
#endif
2170
}
2171

    
2172
/* XXX: add that in a FPU generic layer */
2173
union x86_longdouble {
2174
    uint64_t mant;
2175
    uint16_t exp;
2176
};
2177

    
2178
#define MANTD1(fp)        (fp & ((1LL << 52) - 1))
2179
#define EXPBIAS1 1023
2180
#define EXPD1(fp)        ((fp >> 52) & 0x7FF)
2181
#define SIGND1(fp)        ((fp >> 32) & 0x80000000)
2182

    
2183
static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
2184
{
2185
    int e;
2186
    /* mantissa */
2187
    p->mant = (MANTD1(temp) << 11) | (1LL << 63);
2188
    /* exponent + sign */
2189
    e = EXPD1(temp) - EXPBIAS1 + 16383;
2190
    e |= SIGND1(temp) >> 16;
2191
    p->exp = e;
2192
}
2193

    
2194
int cpu_load(QEMUFile *f, void *opaque, int version_id)
2195
{
2196
    CPUState *env = opaque;
2197
    int i, guess_mmx;
2198
    uint32_t hflags;
2199
    uint16_t fpus, fpuc, fptag, fpregs_format;
2200

    
2201
    if (version_id != 3)
2202
        return -EINVAL;
2203
    for(i = 0; i < CPU_NB_REGS; i++)
2204
        qemu_get_betls(f, &env->regs[i]);
2205
    qemu_get_betls(f, &env->eip);
2206
    qemu_get_betls(f, &env->eflags);
2207
    qemu_get_be32s(f, &hflags);
2208

    
2209
    qemu_get_be16s(f, &fpuc);
2210
    qemu_get_be16s(f, &fpus);
2211
    qemu_get_be16s(f, &fptag);
2212
    qemu_get_be16s(f, &fpregs_format);
2213
    
2214
    /* NOTE: we cannot always restore the FPU state if the image come
2215
       from a host with a different 'USE_X86LDOUBLE' define. We guess
2216
       if we are in an MMX state to restore correctly in that case. */
2217
    guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
2218
    for(i = 0; i < 8; i++) {
2219
        uint64_t mant;
2220
        uint16_t exp;
2221
        union x86_longdouble *p;
2222
        
2223
        switch(fpregs_format) {
2224
        case 0:
2225
            mant = qemu_get_be64(f);
2226
            exp = qemu_get_be16(f);
2227
#ifdef USE_X86LDOUBLE
2228
            env->fpregs[i].d = cpu_set_fp80(mant, exp);
2229
#else
2230
            /* difficult case */
2231
            if (guess_mmx)
2232
                env->fpregs[i].xmm.MMX_Q(0) = mant;
2233
            else
2234
                env->fpregs[i].d = cpu_set_fp80(mant, exp);
2235
#endif
2236
            break;
2237
        case 1:
2238
            mant = qemu_get_be64(f);
2239
#ifdef USE_X86LDOUBLE
2240
            /* difficult case */
2241
            p = (void *)&env->fpregs[i];
2242
            if (guess_mmx) {
2243
                p->mant = mant;
2244
                p->exp = 0xffff;
2245
            } else {
2246
                fp64_to_fp80(p, mant);
2247
            }
2248
#else
2249
            env->fpregs[i].xmm.MMX_Q(0) = mant;
2250
#endif            
2251
            break;
2252
        default:
2253
            return -EINVAL;
2254
        }
2255
    }
2256

    
2257
    env->fpuc = fpuc;
2258
    env->fpstt = (fpus >> 11) & 7;
2259
    env->fpus = fpus & ~0x3800;
2260
    fptag ^= 0xff;
2261
    for(i = 0; i < 8; i++) {
2262
        env->fptags[i] = (fptag >> i) & 1;
2263
    }
2264
    
2265
    for(i = 0; i < 6; i++)
2266
        cpu_get_seg(f, &env->segs[i]);
2267
    cpu_get_seg(f, &env->ldt);
2268
    cpu_get_seg(f, &env->tr);
2269
    cpu_get_seg(f, &env->gdt);
2270
    cpu_get_seg(f, &env->idt);
2271
    
2272
    qemu_get_be32s(f, &env->sysenter_cs);
2273
    qemu_get_be32s(f, &env->sysenter_esp);
2274
    qemu_get_be32s(f, &env->sysenter_eip);
2275
    
2276
    qemu_get_betls(f, &env->cr[0]);
2277
    qemu_get_betls(f, &env->cr[2]);
2278
    qemu_get_betls(f, &env->cr[3]);
2279
    qemu_get_betls(f, &env->cr[4]);
2280
    
2281
    for(i = 0; i < 8; i++)
2282
        qemu_get_betls(f, &env->dr[i]);
2283

    
2284
    /* MMU */
2285
    qemu_get_be32s(f, &env->a20_mask);
2286

    
2287
    qemu_get_be32s(f, &env->mxcsr);
2288
    for(i = 0; i < CPU_NB_REGS; i++) {
2289
        qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
2290
        qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
2291
    }
2292

    
2293
#ifdef TARGET_X86_64
2294
    qemu_get_be64s(f, &env->efer);
2295
    qemu_get_be64s(f, &env->star);
2296
    qemu_get_be64s(f, &env->lstar);
2297
    qemu_get_be64s(f, &env->cstar);
2298
    qemu_get_be64s(f, &env->fmask);
2299
    qemu_get_be64s(f, &env->kernelgsbase);
2300
#endif
2301

    
2302
    /* XXX: compute hflags from scratch, except for CPL and IIF */
2303
    env->hflags = hflags;
2304
    tlb_flush(env, 1);
2305
    return 0;
2306
}
2307

    
2308
#elif defined(TARGET_PPC)
2309
void cpu_save(QEMUFile *f, void *opaque)
2310
{
2311
}
2312

    
2313
int cpu_load(QEMUFile *f, void *opaque, int version_id)
2314
{
2315
    return 0;
2316
}
2317
#elif defined(TARGET_SPARC)
2318
void cpu_save(QEMUFile *f, void *opaque)
2319
{
2320
    CPUState *env = opaque;
2321
    int i;
2322
    uint32_t tmp;
2323

    
2324
    for(i = 1; i < 8; i++)
2325
        qemu_put_be32s(f, &env->gregs[i]);
2326
    tmp = env->regwptr - env->regbase;
2327
    qemu_put_be32s(f, &tmp);
2328
    for(i = 1; i < NWINDOWS * 16 + 8; i++)
2329
        qemu_put_be32s(f, &env->regbase[i]);
2330

    
2331
    /* FPU */
2332
    for(i = 0; i < 32; i++) {
2333
        uint64_t mant;
2334
        uint16_t exp;
2335
        cpu_get_fp64(&mant, &exp, env->fpr[i]);
2336
        qemu_put_be64(f, mant);
2337
        qemu_put_be16(f, exp);
2338
    }
2339
    qemu_put_be32s(f, &env->pc);
2340
    qemu_put_be32s(f, &env->npc);
2341
    qemu_put_be32s(f, &env->y);
2342
    tmp = GET_PSR(env);
2343
    qemu_put_be32s(f, &tmp);
2344
    qemu_put_be32s(f, &env->fsr);
2345
    qemu_put_be32s(f, &env->cwp);
2346
    qemu_put_be32s(f, &env->wim);
2347
    qemu_put_be32s(f, &env->tbr);
2348
    /* MMU */
2349
    for(i = 0; i < 16; i++)
2350
        qemu_put_be32s(f, &env->mmuregs[i]);
2351
}
2352

    
2353
int cpu_load(QEMUFile *f, void *opaque, int version_id)
2354
{
2355
    CPUState *env = opaque;
2356
    int i;
2357
    uint32_t tmp;
2358

    
2359
    for(i = 1; i < 8; i++)
2360
        qemu_get_be32s(f, &env->gregs[i]);
2361
    qemu_get_be32s(f, &tmp);
2362
    env->regwptr = env->regbase + tmp;
2363
    for(i = 1; i < NWINDOWS * 16 + 8; i++)
2364
        qemu_get_be32s(f, &env->regbase[i]);
2365

    
2366
    /* FPU */
2367
    for(i = 0; i < 32; i++) {
2368
        uint64_t mant;
2369
        uint16_t exp;
2370

    
2371
        qemu_get_be64s(f, &mant);
2372
        qemu_get_be16s(f, &exp);
2373
        env->fpr[i] = cpu_put_fp64(mant, exp);
2374
    }
2375
    qemu_get_be32s(f, &env->pc);
2376
    qemu_get_be32s(f, &env->npc);
2377
    qemu_get_be32s(f, &env->y);
2378
    qemu_get_be32s(f, &tmp);
2379
    PUT_PSR(env, tmp);
2380
    qemu_get_be32s(f, &env->fsr);
2381
    qemu_get_be32s(f, &env->cwp);
2382
    qemu_get_be32s(f, &env->wim);
2383
    qemu_get_be32s(f, &env->tbr);
2384
    /* MMU */
2385
    for(i = 0; i < 16; i++)
2386
        qemu_get_be32s(f, &env->mmuregs[i]);
2387
    tlb_flush(env, 1);
2388
    return 0;
2389
}
2390
#else
2391

    
2392
#warning No CPU save/restore functions
2393

    
2394
#endif
2395

    
2396
/***********************************************************/
2397
/* ram save/restore */
2398

    
2399
/* we just avoid storing empty pages */
2400
static void ram_put_page(QEMUFile *f, const uint8_t *buf, int len)
2401
{
2402
    int i, v;
2403

    
2404
    v = buf[0];
2405
    for(i = 1; i < len; i++) {
2406
        if (buf[i] != v)
2407
            goto normal_save;
2408
    }
2409
    qemu_put_byte(f, 1);
2410
    qemu_put_byte(f, v);
2411
    return;
2412
 normal_save:
2413
    qemu_put_byte(f, 0); 
2414
    qemu_put_buffer(f, buf, len);
2415
}
2416

    
2417
static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
2418
{
2419
    int v;
2420

    
2421
    v = qemu_get_byte(f);
2422
    switch(v) {
2423
    case 0:
2424
        if (qemu_get_buffer(f, buf, len) != len)
2425
            return -EIO;
2426
        break;
2427
    case 1:
2428
        v = qemu_get_byte(f);
2429
        memset(buf, v, len);
2430
        break;
2431
    default:
2432
        return -EINVAL;
2433
    }
2434
    return 0;
2435
}
2436

    
2437
static void ram_save(QEMUFile *f, void *opaque)
2438
{
2439
    int i;
2440
    qemu_put_be32(f, phys_ram_size);
2441
    for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
2442
        ram_put_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
2443
    }
2444
}
2445

    
2446
static int ram_load(QEMUFile *f, void *opaque, int version_id)
2447
{
2448
    int i, ret;
2449

    
2450
    if (version_id != 1)
2451
        return -EINVAL;
2452
    if (qemu_get_be32(f) != phys_ram_size)
2453
        return -EINVAL;
2454
    for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
2455
        ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
2456
        if (ret)
2457
            return ret;
2458
    }
2459
    return 0;
2460
}
2461

    
2462
/***********************************************************/
2463
/* main execution loop */
2464

    
2465
void gui_update(void *opaque)
2466
{
2467
    display_state.dpy_refresh(&display_state);
2468
    qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
2469
}
2470

    
2471
/* XXX: support several handlers */
2472
VMStopHandler *vm_stop_cb;
2473
VMStopHandler *vm_stop_opaque;
2474

    
2475
int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
2476
{
2477
    vm_stop_cb = cb;
2478
    vm_stop_opaque = opaque;
2479
    return 0;
2480
}
2481

    
2482
void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
2483
{
2484
    vm_stop_cb = NULL;
2485
}
2486

    
2487
void vm_start(void)
2488
{
2489
    if (!vm_running) {
2490
        cpu_enable_ticks();
2491
        vm_running = 1;
2492
    }
2493
}
2494

    
2495
void vm_stop(int reason) 
2496
{
2497
    if (vm_running) {
2498
        cpu_disable_ticks();
2499
        vm_running = 0;
2500
        if (reason != 0) {
2501
            if (vm_stop_cb) {
2502
                vm_stop_cb(vm_stop_opaque, reason);
2503
            }
2504
        }
2505
    }
2506
}
2507

    
2508
/* reset/shutdown handler */
2509

    
2510
typedef struct QEMUResetEntry {
2511
    QEMUResetHandler *func;
2512
    void *opaque;
2513
    struct QEMUResetEntry *next;
2514
} QEMUResetEntry;
2515

    
2516
static QEMUResetEntry *first_reset_entry;
2517
static int reset_requested;
2518
static int shutdown_requested;
2519

    
2520
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
2521
{
2522
    QEMUResetEntry **pre, *re;
2523

    
2524
    pre = &first_reset_entry;
2525
    while (*pre != NULL)
2526
        pre = &(*pre)->next;
2527
    re = qemu_mallocz(sizeof(QEMUResetEntry));
2528
    re->func = func;
2529
    re->opaque = opaque;
2530
    re->next = NULL;
2531
    *pre = re;
2532
}
2533

    
2534
void qemu_system_reset(void)
2535
{
2536
    QEMUResetEntry *re;
2537

    
2538
    /* reset all devices */
2539
    for(re = first_reset_entry; re != NULL; re = re->next) {
2540
        re->func(re->opaque);
2541
    }
2542
}
2543

    
2544
void qemu_system_reset_request(void)
2545
{
2546
    reset_requested = 1;
2547
    cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
2548
}
2549

    
2550
void qemu_system_shutdown_request(void)
2551
{
2552
    shutdown_requested = 1;
2553
    cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
2554
}
2555

    
2556
static void main_cpu_reset(void *opaque)
2557
{
2558
#if defined(TARGET_I386) || defined(TARGET_SPARC)
2559
    CPUState *env = opaque;
2560
    cpu_reset(env);
2561
#endif
2562
}
2563

    
2564
void main_loop_wait(int timeout)
2565
{
2566
#ifndef _WIN32
2567
    struct pollfd ufds[MAX_IO_HANDLERS + 1], *pf;
2568
    IOHandlerRecord *ioh, *ioh_next;
2569
    uint8_t buf[4096];
2570
    int n, max_size;
2571
#endif
2572
    int ret;
2573

    
2574
#ifdef _WIN32
2575
        if (timeout > 0)
2576
            Sleep(timeout);
2577
#else
2578
        /* poll any events */
2579
        /* XXX: separate device handlers from system ones */
2580
        pf = ufds;
2581
        for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2582
            if (!ioh->fd_can_read) {
2583
                max_size = 0;
2584
                pf->fd = ioh->fd;
2585
                pf->events = POLLIN;
2586
                ioh->ufd = pf;
2587
                pf++;
2588
            } else {
2589
                max_size = ioh->fd_can_read(ioh->opaque);
2590
                if (max_size > 0) {
2591
                    if (max_size > sizeof(buf))
2592
                        max_size = sizeof(buf);
2593
                    pf->fd = ioh->fd;
2594
                    pf->events = POLLIN;
2595
                    ioh->ufd = pf;
2596
                    pf++;
2597
                } else {
2598
                    ioh->ufd = NULL;
2599
                }
2600
            }
2601
            ioh->max_size = max_size;
2602
        }
2603
        
2604
        ret = poll(ufds, pf - ufds, timeout);
2605
        if (ret > 0) {
2606
            /* XXX: better handling of removal */
2607
            for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
2608
                ioh_next = ioh->next;
2609
                pf = ioh->ufd;
2610
                if (pf) {
2611
                    if (pf->revents & POLLIN) {
2612
                        if (ioh->max_size == 0) {
2613
                            /* just a read event */
2614
                            ioh->fd_read(ioh->opaque, NULL, 0);
2615
                        } else {
2616
                            n = read(ioh->fd, buf, ioh->max_size);
2617
                            if (n >= 0) {
2618
                                ioh->fd_read(ioh->opaque, buf, n);
2619
                            } else if (errno != EAGAIN) {
2620
                                ioh->fd_read(ioh->opaque, NULL, -errno);
2621
                            }
2622
                        }
2623
                    }
2624
                }
2625
            }
2626
        }
2627
#endif /* !defined(_WIN32) */
2628
#if defined(CONFIG_SLIRP)
2629
        /* XXX: merge with poll() */
2630
        if (slirp_inited) {
2631
            fd_set rfds, wfds, xfds;
2632
            int nfds;
2633
            struct timeval tv;
2634

    
2635
            nfds = -1;
2636
            FD_ZERO(&rfds);
2637
            FD_ZERO(&wfds);
2638
            FD_ZERO(&xfds);
2639
            slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
2640
            tv.tv_sec = 0;
2641
            tv.tv_usec = 0;
2642
            ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
2643
            if (ret >= 0) {
2644
                slirp_select_poll(&rfds, &wfds, &xfds);
2645
            }
2646
        }
2647
#endif
2648

    
2649
        if (vm_running) {
2650
            qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL], 
2651
                            qemu_get_clock(vm_clock));
2652
            /* run dma transfers, if any */
2653
            DMA_run();
2654
        }
2655

    
2656
        /* real time timers */
2657
        qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME], 
2658
                        qemu_get_clock(rt_clock));
2659
}
2660

    
2661
int main_loop(void)
2662
{
2663
    int ret, timeout;
2664
    CPUState *env = global_env;
2665

    
2666
    for(;;) {
2667
        if (vm_running) {
2668
            ret = cpu_exec(env);
2669
            if (shutdown_requested) {
2670
                ret = EXCP_INTERRUPT; 
2671
                break;
2672
            }
2673
            if (reset_requested) {
2674
                reset_requested = 0;
2675
                qemu_system_reset();
2676
                ret = EXCP_INTERRUPT; 
2677
            }
2678
            if (ret == EXCP_DEBUG) {
2679
                vm_stop(EXCP_DEBUG);
2680
            }
2681
            /* if hlt instruction, we wait until the next IRQ */
2682
            /* XXX: use timeout computed from timers */
2683
            if (ret == EXCP_HLT) 
2684
                timeout = 10;
2685
            else
2686
                timeout = 0;
2687
        } else {
2688
            timeout = 10;
2689
        }
2690
        main_loop_wait(timeout);
2691
    }
2692
    cpu_disable_ticks();
2693
    return ret;
2694
}
2695

    
2696
void help(void)
2697
{
2698
    printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2004 Fabrice Bellard\n"
2699
           "usage: %s [options] [disk_image]\n"
2700
           "\n"
2701
           "'disk_image' is a raw hard image image for IDE hard disk 0\n"
2702
           "\n"
2703
           "Standard options:\n"
2704
           "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
2705
           "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
2706
           "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
2707
           "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
2708
           "-boot [a|c|d]   boot on floppy (a), hard disk (c) or CD-ROM (d)\n"
2709
           "-snapshot       write to temporary files instead of disk image files\n"
2710
           "-m megs         set virtual RAM size to megs MB [default=%d]\n"
2711
           "-nographic      disable graphical output and redirect serial I/Os to console\n"
2712
#ifndef _WIN32
2713
           "-k language     use keyboard layout (for example \"fr\" for French)\n"
2714
#endif
2715
           "-enable-audio   enable audio support\n"
2716
           "-localtime      set the real time clock to local time [default=utc]\n"
2717
           "-full-screen    start in full screen\n"
2718
#ifdef TARGET_PPC
2719
           "-prep           Simulate a PREP system (default is PowerMAC)\n"
2720
           "-g WxH[xDEPTH]  Set the initial VGA graphic mode\n"
2721
#endif
2722
           "\n"
2723
           "Network options:\n"
2724
           "-nics n         simulate 'n' network cards [default=1]\n"
2725
           "-macaddr addr   set the mac address of the first interface\n"
2726
           "-n script       set tap/tun network init script [default=%s]\n"
2727
           "-tun-fd fd      use this fd as already opened tap/tun interface\n"
2728
#ifdef CONFIG_SLIRP
2729
           "-user-net       use user mode network stack [default if no tap/tun script]\n"
2730
           "-tftp prefix    allow tftp access to files starting with prefix [-user-net]\n"
2731
#ifndef _WIN32
2732
           "-smb dir        allow SMB access to files in 'dir' [-user-net]\n"
2733
#endif
2734
           "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
2735
           "                redirect TCP or UDP connections from host to guest [-user-net]\n"
2736
#endif
2737
           "-dummy-net      use dummy network stack\n"
2738
           "\n"
2739
           "Linux boot specific:\n"
2740
           "-kernel bzImage use 'bzImage' as kernel image\n"
2741
           "-append cmdline use 'cmdline' as kernel command line\n"
2742
           "-initrd file    use 'file' as initial ram disk\n"
2743
           "\n"
2744
           "Debug/Expert options:\n"
2745
           "-monitor dev    redirect the monitor to char device 'dev'\n"
2746
           "-serial dev     redirect the serial port to char device 'dev'\n"
2747
           "-pidfile file   Write PID to 'file'\n"
2748
           "-S              freeze CPU at startup (use 'c' to start execution)\n"
2749
           "-s              wait gdb connection to port %d\n"
2750
           "-p port         change gdb connection port\n"
2751
           "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
2752
           "-hdachs c,h,s[,t]  force hard disk 0 physical geometry and the optional BIOS\n"
2753
           "                translation (t=none or lba) (usually qemu can guess them)\n"
2754
           "-L path         set the directory for the BIOS and VGA BIOS\n"
2755
#ifdef USE_CODE_COPY
2756
           "-no-code-copy   disable code copy acceleration\n"
2757
#endif
2758
#ifdef TARGET_I386
2759
           "-isa            simulate an ISA-only system (default is PCI system)\n"
2760
           "-std-vga        simulate a standard VGA card with VESA Bochs Extensions\n"
2761
           "                (default is CL-GD5446 PCI VGA)\n"
2762
#endif
2763
           "-loadvm file    start right away with a saved state (loadvm in monitor)\n"
2764
           "\n"
2765
           "During emulation, the following keys are useful:\n"
2766
           "ctrl-alt-f      toggle full screen\n"
2767
           "ctrl-alt-n      switch to virtual console 'n'\n"
2768
           "ctrl-alt        toggle mouse and keyboard grab\n"
2769
           "\n"
2770
           "When using -nographic, press 'ctrl-a h' to get some help.\n"
2771
           ,
2772
#ifdef CONFIG_SOFTMMU
2773
           "qemu",
2774
#else
2775
           "qemu-fast",
2776
#endif
2777
           DEFAULT_RAM_SIZE,
2778
           DEFAULT_NETWORK_SCRIPT,
2779
           DEFAULT_GDBSTUB_PORT,
2780
           "/tmp/qemu.log");
2781
#ifndef CONFIG_SOFTMMU
2782
    printf("\n"
2783
           "NOTE: this version of QEMU is faster but it needs slightly patched OSes to\n"
2784
           "work. Please use the 'qemu' executable to have a more accurate (but slower)\n"
2785
           "PC emulation.\n");
2786
#endif
2787
    exit(1);
2788
}
2789

    
2790
#define HAS_ARG 0x0001
2791

    
2792
enum {
2793
    QEMU_OPTION_h,
2794

    
2795
    QEMU_OPTION_fda,
2796
    QEMU_OPTION_fdb,
2797
    QEMU_OPTION_hda,
2798
    QEMU_OPTION_hdb,
2799
    QEMU_OPTION_hdc,
2800
    QEMU_OPTION_hdd,
2801
    QEMU_OPTION_cdrom,
2802
    QEMU_OPTION_boot,
2803
    QEMU_OPTION_snapshot,
2804
    QEMU_OPTION_m,
2805
    QEMU_OPTION_nographic,
2806
    QEMU_OPTION_enable_audio,
2807

    
2808
    QEMU_OPTION_nics,
2809
    QEMU_OPTION_macaddr,
2810
    QEMU_OPTION_n,
2811
    QEMU_OPTION_tun_fd,
2812
    QEMU_OPTION_user_net,
2813
    QEMU_OPTION_tftp,
2814
    QEMU_OPTION_smb,
2815
    QEMU_OPTION_redir,
2816
    QEMU_OPTION_dummy_net,
2817

    
2818
    QEMU_OPTION_kernel,
2819
    QEMU_OPTION_append,
2820
    QEMU_OPTION_initrd,
2821

    
2822
    QEMU_OPTION_S,
2823
    QEMU_OPTION_s,
2824
    QEMU_OPTION_p,
2825
    QEMU_OPTION_d,
2826
    QEMU_OPTION_hdachs,
2827
    QEMU_OPTION_L,
2828
    QEMU_OPTION_no_code_copy,
2829
    QEMU_OPTION_pci,
2830
    QEMU_OPTION_isa,
2831
    QEMU_OPTION_prep,
2832
    QEMU_OPTION_k,
2833
    QEMU_OPTION_localtime,
2834
    QEMU_OPTION_cirrusvga,
2835
    QEMU_OPTION_g,
2836
    QEMU_OPTION_std_vga,
2837
    QEMU_OPTION_monitor,
2838
    QEMU_OPTION_serial,
2839
    QEMU_OPTION_loadvm,
2840
    QEMU_OPTION_full_screen,
2841
    QEMU_OPTION_pidfile,
2842
};
2843

    
2844
typedef struct QEMUOption {
2845
    const char *name;
2846
    int flags;
2847
    int index;
2848
} QEMUOption;
2849

    
2850
const QEMUOption qemu_options[] = {
2851
    { "h", 0, QEMU_OPTION_h },
2852

    
2853
    { "fda", HAS_ARG, QEMU_OPTION_fda },
2854
    { "fdb", HAS_ARG, QEMU_OPTION_fdb },
2855
    { "hda", HAS_ARG, QEMU_OPTION_hda },
2856
    { "hdb", HAS_ARG, QEMU_OPTION_hdb },
2857
    { "hdc", HAS_ARG, QEMU_OPTION_hdc },
2858
    { "hdd", HAS_ARG, QEMU_OPTION_hdd },
2859
    { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
2860
    { "boot", HAS_ARG, QEMU_OPTION_boot },
2861
    { "snapshot", 0, QEMU_OPTION_snapshot },
2862
    { "m", HAS_ARG, QEMU_OPTION_m },
2863
    { "nographic", 0, QEMU_OPTION_nographic },
2864
    { "k", HAS_ARG, QEMU_OPTION_k },
2865
    { "enable-audio", 0, QEMU_OPTION_enable_audio },
2866

    
2867
    { "nics", HAS_ARG, QEMU_OPTION_nics},
2868
    { "macaddr", HAS_ARG, QEMU_OPTION_macaddr},
2869
    { "n", HAS_ARG, QEMU_OPTION_n },
2870
    { "tun-fd", HAS_ARG, QEMU_OPTION_tun_fd },
2871
#ifdef CONFIG_SLIRP
2872
    { "user-net", 0, QEMU_OPTION_user_net },
2873
    { "tftp", HAS_ARG, QEMU_OPTION_tftp },
2874
#ifndef _WIN32
2875
    { "smb", HAS_ARG, QEMU_OPTION_smb },
2876
#endif
2877
    { "redir", HAS_ARG, QEMU_OPTION_redir },
2878
#endif
2879
    { "dummy-net", 0, QEMU_OPTION_dummy_net },
2880

    
2881
    { "kernel", HAS_ARG, QEMU_OPTION_kernel },
2882
    { "append", HAS_ARG, QEMU_OPTION_append },
2883
    { "initrd", HAS_ARG, QEMU_OPTION_initrd },
2884

    
2885
    { "S", 0, QEMU_OPTION_S },
2886
    { "s", 0, QEMU_OPTION_s },
2887
    { "p", HAS_ARG, QEMU_OPTION_p },
2888
    { "d", HAS_ARG, QEMU_OPTION_d },
2889
    { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
2890
    { "L", HAS_ARG, QEMU_OPTION_L },
2891
    { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
2892
#ifdef TARGET_PPC
2893
    { "prep", 0, QEMU_OPTION_prep },
2894
    { "g", 1, QEMU_OPTION_g },
2895
#endif
2896
    { "localtime", 0, QEMU_OPTION_localtime },
2897
    { "isa", 0, QEMU_OPTION_isa },
2898
    { "std-vga", 0, QEMU_OPTION_std_vga },
2899
    { "monitor", 1, QEMU_OPTION_monitor },
2900
    { "serial", 1, QEMU_OPTION_serial },
2901
    { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
2902
    { "full-screen", 0, QEMU_OPTION_full_screen },
2903
    { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
2904

    
2905
    /* temporary options */
2906
    { "pci", 0, QEMU_OPTION_pci },
2907
    { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
2908
    { NULL },
2909
};
2910

    
2911
#if defined (TARGET_I386) && defined(USE_CODE_COPY)
2912

    
2913
/* this stack is only used during signal handling */
2914
#define SIGNAL_STACK_SIZE 32768
2915

    
2916
static uint8_t *signal_stack;
2917

    
2918
#endif
2919

    
2920
/* password input */
2921

    
2922
static BlockDriverState *get_bdrv(int index)
2923
{
2924
    BlockDriverState *bs;
2925

    
2926
    if (index < 4) {
2927
        bs = bs_table[index];
2928
    } else if (index < 6) {
2929
        bs = fd_table[index - 4];
2930
    } else {
2931
        bs = NULL;
2932
    }
2933
    return bs;
2934
}
2935

    
2936
static void read_passwords(void)
2937
{
2938
    BlockDriverState *bs;
2939
    int i, j;
2940
    char password[256];
2941

    
2942
    for(i = 0; i < 6; i++) {
2943
        bs = get_bdrv(i);
2944
        if (bs && bdrv_is_encrypted(bs)) {
2945
            term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
2946
            for(j = 0; j < 3; j++) {
2947
                monitor_readline("Password: ", 
2948
                                 1, password, sizeof(password));
2949
                if (bdrv_set_key(bs, password) == 0)
2950
                    break;
2951
                term_printf("invalid password\n");
2952
            }
2953
        }
2954
    }
2955
}
2956

    
2957
#define NET_IF_TUN   0
2958
#define NET_IF_USER  1
2959
#define NET_IF_DUMMY 2
2960

    
2961
int main(int argc, char **argv)
2962
{
2963
#ifdef CONFIG_GDBSTUB
2964
    int use_gdbstub, gdbstub_port;
2965
#endif
2966
    int i, has_cdrom;
2967
    int snapshot, linux_boot;
2968
    CPUState *env;
2969
    const char *initrd_filename;
2970
    const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
2971
    const char *kernel_filename, *kernel_cmdline;
2972
    DisplayState *ds = &display_state;
2973
    int cyls, heads, secs, translation;
2974
    int start_emulation = 1;
2975
    uint8_t macaddr[6];
2976
    int net_if_type, nb_tun_fds, tun_fds[MAX_NICS];
2977
    int optind;
2978
    const char *r, *optarg;
2979
    CharDriverState *monitor_hd;
2980
    char monitor_device[128];
2981
    char serial_devices[MAX_SERIAL_PORTS][128];
2982
    int serial_device_index;
2983
    const char *loadvm = NULL;
2984
    
2985
#if !defined(CONFIG_SOFTMMU)
2986
    /* we never want that malloc() uses mmap() */
2987
    mallopt(M_MMAP_THRESHOLD, 4096 * 1024);
2988
#endif
2989
    initrd_filename = NULL;
2990
    for(i = 0; i < MAX_FD; i++)
2991
        fd_filename[i] = NULL;
2992
    for(i = 0; i < MAX_DISKS; i++)
2993
        hd_filename[i] = NULL;
2994
    ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
2995
    vga_ram_size = VGA_RAM_SIZE;
2996
    bios_size = BIOS_SIZE;
2997
    pstrcpy(network_script, sizeof(network_script), DEFAULT_NETWORK_SCRIPT);
2998
#ifdef CONFIG_GDBSTUB
2999
    use_gdbstub = 0;
3000
    gdbstub_port = DEFAULT_GDBSTUB_PORT;
3001
#endif
3002
    snapshot = 0;
3003
    nographic = 0;
3004
    kernel_filename = NULL;
3005
    kernel_cmdline = "";
3006
    has_cdrom = 1;
3007
    cyls = heads = secs = 0;
3008
    translation = BIOS_ATA_TRANSLATION_AUTO;
3009
    pstrcpy(monitor_device, sizeof(monitor_device), "vc");
3010

    
3011
    pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
3012
    for(i = 1; i < MAX_SERIAL_PORTS; i++)
3013
        serial_devices[i][0] = '\0';
3014
    serial_device_index = 0;
3015
    
3016
    nb_tun_fds = 0;
3017
    net_if_type = -1;
3018
    nb_nics = 1;
3019
    /* default mac address of the first network interface */
3020
    macaddr[0] = 0x52;
3021
    macaddr[1] = 0x54;
3022
    macaddr[2] = 0x00;
3023
    macaddr[3] = 0x12;
3024
    macaddr[4] = 0x34;
3025
    macaddr[5] = 0x56;
3026
    
3027
    optind = 1;
3028
    for(;;) {
3029
        if (optind >= argc)
3030
            break;
3031
        r = argv[optind];
3032
        if (r[0] != '-') {
3033
            hd_filename[0] = argv[optind++];
3034
        } else {
3035
            const QEMUOption *popt;
3036

    
3037
            optind++;
3038
            popt = qemu_options;
3039
            for(;;) {
3040
                if (!popt->name) {
3041
                    fprintf(stderr, "%s: invalid option -- '%s'\n", 
3042
                            argv[0], r);
3043
                    exit(1);
3044
                }
3045
                if (!strcmp(popt->name, r + 1))
3046
                    break;
3047
                popt++;
3048
            }
3049
            if (popt->flags & HAS_ARG) {
3050
                if (optind >= argc) {
3051
                    fprintf(stderr, "%s: option '%s' requires an argument\n",
3052
                            argv[0], r);
3053
                    exit(1);
3054
                }
3055
                optarg = argv[optind++];
3056
            } else {
3057
                optarg = NULL;
3058
            }
3059

    
3060
            switch(popt->index) {
3061
            case QEMU_OPTION_initrd:
3062
                initrd_filename = optarg;
3063
                break;
3064
            case QEMU_OPTION_hda:
3065
                hd_filename[0] = optarg;
3066
                break;
3067
            case QEMU_OPTION_hdb:
3068
                hd_filename[1] = optarg;
3069
                break;
3070
            case QEMU_OPTION_snapshot:
3071
                snapshot = 1;
3072
                break;
3073
            case QEMU_OPTION_hdachs:
3074
                {
3075
                    const char *p;
3076
                    p = optarg;
3077
                    cyls = strtol(p, (char **)&p, 0);
3078
                    if (cyls < 1 || cyls > 16383)
3079
                        goto chs_fail;
3080
                    if (*p != ',')
3081
                        goto chs_fail;
3082
                    p++;
3083
                    heads = strtol(p, (char **)&p, 0);
3084
                    if (heads < 1 || heads > 16)
3085
                        goto chs_fail;
3086
                    if (*p != ',')
3087
                        goto chs_fail;
3088
                    p++;
3089
                    secs = strtol(p, (char **)&p, 0);
3090
                    if (secs < 1 || secs > 63)
3091
                        goto chs_fail;
3092
                    if (*p == ',') {
3093
                        p++;
3094
                        if (!strcmp(p, "none"))
3095
                            translation = BIOS_ATA_TRANSLATION_NONE;
3096
                        else if (!strcmp(p, "lba"))
3097
                            translation = BIOS_ATA_TRANSLATION_LBA;
3098
                        else if (!strcmp(p, "auto"))
3099
                            translation = BIOS_ATA_TRANSLATION_AUTO;
3100
                        else
3101
                            goto chs_fail;
3102
                    } else if (*p != '\0') {
3103
                    chs_fail:
3104
                        fprintf(stderr, "qemu: invalid physical CHS format\n");
3105
                        exit(1);
3106
                    }
3107
                }
3108
                break;
3109
            case QEMU_OPTION_nographic:
3110
                pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
3111
                pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
3112
                nographic = 1;
3113
                break;
3114
            case QEMU_OPTION_kernel:
3115
                kernel_filename = optarg;
3116
                break;
3117
            case QEMU_OPTION_append:
3118
                kernel_cmdline = optarg;
3119
                break;
3120
            case QEMU_OPTION_tun_fd:
3121
                {
3122
                    const char *p;
3123
                    int fd;
3124
                    net_if_type = NET_IF_TUN;
3125
                    if (nb_tun_fds < MAX_NICS) {
3126
                        fd = strtol(optarg, (char **)&p, 0);
3127
                        if (*p != '\0') {
3128
                            fprintf(stderr, "qemu: invalid fd for network interface %d\n", nb_tun_fds);
3129
                            exit(1);
3130
                        }
3131
                        tun_fds[nb_tun_fds++] = fd;
3132
                    }
3133
                }
3134
                break;
3135
            case QEMU_OPTION_hdc:
3136
                hd_filename[2] = optarg;
3137
                has_cdrom = 0;
3138
                break;
3139
            case QEMU_OPTION_hdd:
3140
                hd_filename[3] = optarg;
3141
                break;
3142
            case QEMU_OPTION_cdrom:
3143
                hd_filename[2] = optarg;
3144
                has_cdrom = 1;
3145
                break;
3146
            case QEMU_OPTION_boot:
3147
                boot_device = optarg[0];
3148
                if (boot_device != 'a' && 
3149
                    boot_device != 'c' && boot_device != 'd') {
3150
                    fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
3151
                    exit(1);
3152
                }
3153
                break;
3154
            case QEMU_OPTION_fda:
3155
                fd_filename[0] = optarg;
3156
                break;
3157
            case QEMU_OPTION_fdb:
3158
                fd_filename[1] = optarg;
3159
                break;
3160
            case QEMU_OPTION_no_code_copy:
3161
                code_copy_enabled = 0;
3162
                break;
3163
            case QEMU_OPTION_nics:
3164
                nb_nics = atoi(optarg);
3165
                if (nb_nics < 0 || nb_nics > MAX_NICS) {
3166
                    fprintf(stderr, "qemu: invalid number of network interfaces\n");
3167
                    exit(1);
3168
                }
3169
                break;
3170
            case QEMU_OPTION_macaddr:
3171
                {
3172
                    const char *p;
3173
                    int i;
3174
                    p = optarg;
3175
                    for(i = 0; i < 6; i++) {
3176
                        macaddr[i] = strtol(p, (char **)&p, 16);
3177
                        if (i == 5) {
3178
                            if (*p != '\0') 
3179
                                goto macaddr_error;
3180
                        } else {
3181
                            if (*p != ':') {
3182
                            macaddr_error:
3183
                                fprintf(stderr, "qemu: invalid syntax for ethernet address\n");
3184
                                exit(1);
3185
                            }
3186
                            p++;
3187
                        }
3188
                    }
3189
                }
3190
                break;
3191
#ifdef CONFIG_SLIRP
3192
            case QEMU_OPTION_tftp:
3193
                tftp_prefix = optarg;
3194
                break;
3195
#ifndef _WIN32
3196
            case QEMU_OPTION_smb:
3197
                net_slirp_smb(optarg);
3198
                break;
3199
#endif
3200
            case QEMU_OPTION_user_net:
3201
                net_if_type = NET_IF_USER;
3202
                break;
3203
            case QEMU_OPTION_redir:
3204
                net_slirp_redir(optarg);                
3205
                break;
3206
#endif
3207
            case QEMU_OPTION_dummy_net:
3208
                net_if_type = NET_IF_DUMMY;
3209
                break;
3210
            case QEMU_OPTION_enable_audio:
3211
                audio_enabled = 1;
3212
                break;
3213
            case QEMU_OPTION_h:
3214
                help();
3215
                break;
3216
            case QEMU_OPTION_m:
3217
                ram_size = atoi(optarg) * 1024 * 1024;
3218
                if (ram_size <= 0)
3219
                    help();
3220
                if (ram_size > PHYS_RAM_MAX_SIZE) {
3221
                    fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
3222
                            PHYS_RAM_MAX_SIZE / (1024 * 1024));
3223
                    exit(1);
3224
                }
3225
                break;
3226
            case QEMU_OPTION_d:
3227
                {
3228
                    int mask;
3229
                    CPULogItem *item;
3230
                    
3231
                    mask = cpu_str_to_log_mask(optarg);
3232
                    if (!mask) {
3233
                        printf("Log items (comma separated):\n");
3234
                    for(item = cpu_log_items; item->mask != 0; item++) {
3235
                        printf("%-10s %s\n", item->name, item->help);
3236
                    }
3237
                    exit(1);
3238
                    }
3239
                    cpu_set_log(mask);
3240
                }
3241
                break;
3242
            case QEMU_OPTION_n:
3243
                pstrcpy(network_script, sizeof(network_script), optarg);
3244
                break;
3245
#ifdef CONFIG_GDBSTUB
3246
            case QEMU_OPTION_s:
3247
                use_gdbstub = 1;
3248
                break;
3249
            case QEMU_OPTION_p:
3250
                gdbstub_port = atoi(optarg);
3251
                break;
3252
#endif
3253
            case QEMU_OPTION_L:
3254
                bios_dir = optarg;
3255
                break;
3256
            case QEMU_OPTION_S:
3257
                start_emulation = 0;
3258
                break;
3259
            case QEMU_OPTION_pci:
3260
                pci_enabled = 1;
3261
                break;
3262
            case QEMU_OPTION_isa:
3263
                pci_enabled = 0;
3264
                break;
3265
            case QEMU_OPTION_prep:
3266
                prep_enabled = 1;
3267
                break;
3268
            case QEMU_OPTION_k:
3269
                keyboard_layout = optarg;
3270
                break;
3271
            case QEMU_OPTION_localtime:
3272
                rtc_utc = 0;
3273
                break;
3274
            case QEMU_OPTION_cirrusvga:
3275
                cirrus_vga_enabled = 1;
3276
                break;
3277
            case QEMU_OPTION_std_vga:
3278
                cirrus_vga_enabled = 0;
3279
                break;
3280
            case QEMU_OPTION_g:
3281
                {
3282
                    const char *p;
3283
                    int w, h, depth;
3284
                    p = optarg;
3285
                    w = strtol(p, (char **)&p, 10);
3286
                    if (w <= 0) {
3287
                    graphic_error:
3288
                        fprintf(stderr, "qemu: invalid resolution or depth\n");
3289
                        exit(1);
3290
                    }
3291
                    if (*p != 'x')
3292
                        goto graphic_error;
3293
                    p++;
3294
                    h = strtol(p, (char **)&p, 10);
3295
                    if (h <= 0)
3296
                        goto graphic_error;
3297
                    if (*p == 'x') {
3298
                        p++;
3299
                        depth = strtol(p, (char **)&p, 10);
3300
                        if (depth != 8 && depth != 15 && depth != 16 && 
3301
                            depth != 24 && depth != 32)
3302
                            goto graphic_error;
3303
                    } else if (*p == '\0') {
3304
                        depth = graphic_depth;
3305
                    } else {
3306
                        goto graphic_error;
3307
                    }
3308
                    
3309
                    graphic_width = w;
3310
                    graphic_height = h;
3311
                    graphic_depth = depth;
3312
                }
3313
                break;
3314
            case QEMU_OPTION_monitor:
3315
                pstrcpy(monitor_device, sizeof(monitor_device), optarg);
3316
                break;
3317
            case QEMU_OPTION_serial:
3318
                if (serial_device_index >= MAX_SERIAL_PORTS) {
3319
                    fprintf(stderr, "qemu: too many serial ports\n");
3320
                    exit(1);
3321
                }
3322
                pstrcpy(serial_devices[serial_device_index], 
3323
                        sizeof(serial_devices[0]), optarg);
3324
                serial_device_index++;
3325
                break;
3326
            case QEMU_OPTION_loadvm:
3327
                loadvm = optarg;
3328
                break;
3329
            case QEMU_OPTION_full_screen:
3330
                full_screen = 1;
3331
                break;
3332
            case QEMU_OPTION_pidfile:
3333
                create_pidfile(optarg);
3334
                break;
3335
            }
3336
        }
3337
    }
3338

    
3339
    linux_boot = (kernel_filename != NULL);
3340
        
3341
    if (!linux_boot && hd_filename[0] == '\0' && hd_filename[2] == '\0' &&
3342
        fd_filename[0] == '\0')
3343
        help();
3344
    
3345
    /* boot to cd by default if no hard disk */
3346
    if (hd_filename[0] == '\0' && boot_device == 'c') {
3347
        if (fd_filename[0] != '\0')
3348
            boot_device = 'a';
3349
        else
3350
            boot_device = 'd';
3351
    }
3352

    
3353
#if !defined(CONFIG_SOFTMMU)
3354
    /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
3355
    {
3356
        static uint8_t stdout_buf[4096];
3357
        setvbuf(stdout, stdout_buf, _IOLBF, sizeof(stdout_buf));
3358
    }
3359
#else
3360
    setvbuf(stdout, NULL, _IOLBF, 0);
3361
#endif
3362

    
3363
    /* init host network redirectors */
3364
    if (net_if_type == -1) {
3365
        net_if_type = NET_IF_TUN;
3366
#if defined(CONFIG_SLIRP)
3367
        if (access(network_script, R_OK) < 0) {
3368
            net_if_type = NET_IF_USER;
3369
        }
3370
#endif
3371
    }
3372

    
3373
    for(i = 0; i < nb_nics; i++) {
3374
        NetDriverState *nd = &nd_table[i];
3375
        nd->index = i;
3376
        /* init virtual mac address */
3377
        nd->macaddr[0] = macaddr[0];
3378
        nd->macaddr[1] = macaddr[1];
3379
        nd->macaddr[2] = macaddr[2];
3380
        nd->macaddr[3] = macaddr[3];
3381
        nd->macaddr[4] = macaddr[4];
3382
        nd->macaddr[5] = macaddr[5] + i;
3383
        switch(net_if_type) {
3384
#if defined(CONFIG_SLIRP)
3385
        case NET_IF_USER:
3386
            net_slirp_init(nd);
3387
            break;
3388
#endif
3389
#if !defined(_WIN32)
3390
        case NET_IF_TUN:
3391
            if (i < nb_tun_fds) {
3392
                net_fd_init(nd, tun_fds[i]);
3393
            } else {
3394
                if (net_tun_init(nd) < 0)
3395
                    net_dummy_init(nd);
3396
            }
3397
            break;
3398
#endif
3399
        case NET_IF_DUMMY:
3400
        default:
3401
            net_dummy_init(nd);
3402
            break;
3403
        }
3404
    }
3405

    
3406
    /* init the memory */
3407
    phys_ram_size = ram_size + vga_ram_size + bios_size;
3408

    
3409
#ifdef CONFIG_SOFTMMU
3410
#ifdef _BSD
3411
    /* mallocs are always aligned on BSD. valloc is better for correctness */
3412
    phys_ram_base = valloc(phys_ram_size);
3413
#else
3414
    phys_ram_base = memalign(TARGET_PAGE_SIZE, phys_ram_size);
3415
#endif
3416
    if (!phys_ram_base) {
3417
        fprintf(stderr, "Could not allocate physical memory\n");
3418
        exit(1);
3419
    }
3420
#else
3421
    /* as we must map the same page at several addresses, we must use
3422
       a fd */
3423
    {
3424
        const char *tmpdir;
3425

    
3426
        tmpdir = getenv("QEMU_TMPDIR");
3427
        if (!tmpdir)
3428
            tmpdir = "/tmp";
3429
        snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/vlXXXXXX", tmpdir);
3430
        if (mkstemp(phys_ram_file) < 0) {
3431
            fprintf(stderr, "Could not create temporary memory file '%s'\n", 
3432
                    phys_ram_file);
3433
            exit(1);
3434
        }
3435
        phys_ram_fd = open(phys_ram_file, O_CREAT | O_TRUNC | O_RDWR, 0600);
3436
        if (phys_ram_fd < 0) {
3437
            fprintf(stderr, "Could not open temporary memory file '%s'\n", 
3438
                    phys_ram_file);
3439
            exit(1);
3440
        }
3441
        ftruncate(phys_ram_fd, phys_ram_size);
3442
        unlink(phys_ram_file);
3443
        phys_ram_base = mmap(get_mmap_addr(phys_ram_size), 
3444
                             phys_ram_size, 
3445
                             PROT_WRITE | PROT_READ, MAP_SHARED | MAP_FIXED, 
3446
                             phys_ram_fd, 0);
3447
        if (phys_ram_base == MAP_FAILED) {
3448
            fprintf(stderr, "Could not map physical memory\n");
3449
            exit(1);
3450
        }
3451
    }
3452
#endif
3453

    
3454
    /* we always create the cdrom drive, even if no disk is there */
3455
    bdrv_init();
3456
    if (has_cdrom) {
3457
        bs_table[2] = bdrv_new("cdrom");
3458
        bdrv_set_type_hint(bs_table[2], BDRV_TYPE_CDROM);
3459
    }
3460

    
3461
    /* open the virtual block devices */
3462
    for(i = 0; i < MAX_DISKS; i++) {
3463
        if (hd_filename[i]) {
3464
            if (!bs_table[i]) {
3465
                char buf[64];
3466
                snprintf(buf, sizeof(buf), "hd%c", i + 'a');
3467
                bs_table[i] = bdrv_new(buf);
3468
            }
3469
            if (bdrv_open(bs_table[i], hd_filename[i], snapshot) < 0) {
3470
                fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
3471
                        hd_filename[i]);
3472
                exit(1);
3473
            }
3474
            if (i == 0 && cyls != 0) {
3475
                bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
3476
                bdrv_set_translation_hint(bs_table[i], translation);
3477
            }
3478
        }
3479
    }
3480

    
3481
    /* we always create at least one floppy disk */
3482
    fd_table[0] = bdrv_new("fda");
3483
    bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
3484

    
3485
    for(i = 0; i < MAX_FD; i++) {
3486
        if (fd_filename[i]) {
3487
            if (!fd_table[i]) {
3488
                char buf[64];
3489
                snprintf(buf, sizeof(buf), "fd%c", i + 'a');
3490
                fd_table[i] = bdrv_new(buf);
3491
                bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
3492
            }
3493
            if (fd_filename[i] != '\0') {
3494
                if (bdrv_open(fd_table[i], fd_filename[i], snapshot) < 0) {
3495
                    fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
3496
                            fd_filename[i]);
3497
                    exit(1);
3498
                }
3499
            }
3500
        }
3501
    }
3502

    
3503
    /* init CPU state */
3504
    env = cpu_init();
3505
    global_env = env;
3506
    cpu_single_env = env;
3507

    
3508
    register_savevm("timer", 0, 1, timer_save, timer_load, env);
3509
    register_savevm("cpu", 0, 3, cpu_save, cpu_load, env);
3510
    register_savevm("ram", 0, 1, ram_save, ram_load, NULL);
3511
    qemu_register_reset(main_cpu_reset, global_env);
3512

    
3513
    init_ioports();
3514
    cpu_calibrate_ticks();
3515

    
3516
    /* terminal init */
3517
    if (nographic) {
3518
        dumb_display_init(ds);
3519
    } else {
3520
#ifdef CONFIG_SDL
3521
        sdl_display_init(ds, full_screen);
3522
#else
3523
        dumb_display_init(ds);
3524
#endif
3525
    }
3526

    
3527
    vga_console = graphic_console_init(ds);
3528
    
3529
    monitor_hd = qemu_chr_open(monitor_device);
3530
    if (!monitor_hd) {
3531
        fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
3532
        exit(1);
3533
    }
3534
    monitor_init(monitor_hd, !nographic);
3535

    
3536
    for(i = 0; i < MAX_SERIAL_PORTS; i++) {
3537
        if (serial_devices[i][0] != '\0') {
3538
            serial_hds[i] = qemu_chr_open(serial_devices[i]);
3539
            if (!serial_hds[i]) {
3540
                fprintf(stderr, "qemu: could not open serial device '%s'\n", 
3541
                        serial_devices[i]);
3542
                exit(1);
3543
            }
3544
            if (!strcmp(serial_devices[i], "vc"))
3545
                qemu_chr_printf(serial_hds[i], "serial%d console\n", i);
3546
        }
3547
    }
3548

    
3549
    /* setup cpu signal handlers for MMU / self modifying code handling */
3550
#if !defined(CONFIG_SOFTMMU)
3551
    
3552
#if defined (TARGET_I386) && defined(USE_CODE_COPY)
3553
    {
3554
        stack_t stk;
3555
        signal_stack = memalign(16, SIGNAL_STACK_SIZE);
3556
        stk.ss_sp = signal_stack;
3557
        stk.ss_size = SIGNAL_STACK_SIZE;
3558
        stk.ss_flags = 0;
3559

    
3560
        if (sigaltstack(&stk, NULL) < 0) {
3561
            perror("sigaltstack");
3562
            exit(1);
3563
        }
3564
    }
3565
#endif
3566
    {
3567
        struct sigaction act;
3568
        
3569
        sigfillset(&act.sa_mask);
3570
        act.sa_flags = SA_SIGINFO;
3571
#if defined (TARGET_I386) && defined(USE_CODE_COPY)
3572
        act.sa_flags |= SA_ONSTACK;
3573
#endif
3574
        act.sa_sigaction = host_segv_handler;
3575
        sigaction(SIGSEGV, &act, NULL);
3576
        sigaction(SIGBUS, &act, NULL);
3577
#if defined (TARGET_I386) && defined(USE_CODE_COPY)
3578
        sigaction(SIGFPE, &act, NULL);
3579
#endif
3580
    }
3581
#endif
3582

    
3583
#ifndef _WIN32
3584
    {
3585
        struct sigaction act;
3586
        sigfillset(&act.sa_mask);
3587
        act.sa_flags = 0;
3588
        act.sa_handler = SIG_IGN;
3589
        sigaction(SIGPIPE, &act, NULL);
3590
    }
3591
#endif
3592
    init_timers();
3593

    
3594
#if defined(TARGET_I386)
3595
    pc_init(ram_size, vga_ram_size, boot_device,
3596
            ds, fd_filename, snapshot,
3597
            kernel_filename, kernel_cmdline, initrd_filename);
3598
#elif defined(TARGET_PPC)
3599
    ppc_init(ram_size, vga_ram_size, boot_device,
3600
             ds, fd_filename, snapshot,
3601
             kernel_filename, kernel_cmdline, initrd_filename);
3602
#elif defined(TARGET_SPARC)
3603
    sun4m_init(ram_size, vga_ram_size, boot_device,
3604
            ds, fd_filename, snapshot,
3605
            kernel_filename, kernel_cmdline, initrd_filename);
3606
#endif
3607

    
3608
    gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
3609
    qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
3610

    
3611
#ifdef CONFIG_GDBSTUB
3612
    if (use_gdbstub) {
3613
        if (gdbserver_start(gdbstub_port) < 0) {
3614
            fprintf(stderr, "Could not open gdbserver socket on port %d\n", 
3615
                    gdbstub_port);
3616
            exit(1);
3617
        } else {
3618
            printf("Waiting gdb connection on port %d\n", gdbstub_port);
3619
        }
3620
    } else 
3621
#endif
3622
    if (loadvm)
3623
        qemu_loadvm(loadvm);
3624

    
3625
    {
3626
        /* XXX: simplify init */
3627
        read_passwords();
3628
        if (start_emulation) {
3629
            vm_start();
3630
        }
3631
    }
3632
    main_loop();
3633
    quit_timers();
3634
    return 0;
3635
}