?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add "migration.h" to vl.c so that migrate_incoming is defined
[qemu-kvm/fedora.git] / vl.c
blobb84ddd52304c68cd13ddd3999f5e093fbcb80aeb
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2007 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "hw/hw.h"
25 #include "hw/boards.h"
26 #include "hw/usb.h"
27 #include "hw/pcmcia.h"
28 #include "hw/pc.h"
29 #include "hw/fdc.h"
30 #include "hw/audiodev.h"
31 #include "hw/isa.h"
32 #include "net.h"
33 #include "console.h"
34 #include "sysemu.h"
35 #include "gdbstub.h"
36 #include "qemu-timer.h"
37 #include "qemu-char.h"
38 #include "block.h"
39 #include "audio/audio.h"
40 #include "migration.h"
41 #include "qemu-kvm.h"
42
43 #include <unistd.h>
44 #include <fcntl.h>
45 #include <signal.h>
46 #include <time.h>
47 #include <errno.h>
48 #include <sys/time.h>
49 #include <zlib.h>
50
51 #ifndef _WIN32
52 #include <sys/times.h>
53 #include <sys/wait.h>
54 #include <termios.h>
55 #include <sys/poll.h>
56 #include <sys/mman.h>
57 #include <sys/ioctl.h>
58 #include <sys/socket.h>
59 #include <netinet/in.h>
60 #include <dirent.h>
61 #include <netdb.h>
62 #include <sys/select.h>
63 #include <arpa/inet.h>
64 #ifdef _BSD
65 #include <sys/stat.h>
66 #ifndef __APPLE__
67 #include <libutil.h>
68 #endif
69 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
70 #include <freebsd/stdlib.h>
71 #else
72 #ifndef __sun__
73 #include <linux/if.h>
74 #include <linux/if_tun.h>
75 #include <pty.h>
76 #include <malloc.h>
77 #include <linux/rtc.h>
78
79 /* For the benefit of older linux systems which don't supply it,
80 we use a local copy of hpet.h. */
81 /* #include <linux/hpet.h> */
82 #include "hpet.h"
83
84 #include <linux/ppdev.h>
85 #include <linux/parport.h>
86 #else
87 #include <sys/stat.h>
88 #include <sys/ethernet.h>
89 #include <sys/sockio.h>
90 #include <netinet/arp.h>
91 #include <netinet/in.h>
92 #include <netinet/in_systm.h>
93 #include <netinet/ip.h>
94 #include <netinet/ip_icmp.h> // must come after ip.h
95 #include <netinet/udp.h>
96 #include <netinet/tcp.h>
97 #include <net/if.h>
98 #include <syslog.h>
99 #include <stropts.h>
100 #endif
101 #endif
102 #else
103 #include <winsock2.h>
104 int inet_aton(const char *cp, struct in_addr *ia);
105 #endif
106
107 #if defined(CONFIG_SLIRP)
108 #include "libslirp.h"
109 #endif
110
111 #ifdef _WIN32
112 #include <malloc.h>
113 #include <sys/timeb.h>
114 #include <windows.h>
115 #define getopt_long_only getopt_long
116 #define memalign(align, size) malloc(size)
117 #endif
118
119 #include "qemu_socket.h"
120
121 #ifdef CONFIG_SDL
122 #ifdef __APPLE__
123 #include <SDL/SDL.h>
124 #endif
125 #endif /* CONFIG_SDL */
126
127 #ifdef CONFIG_COCOA
128 #undef main
129 #define main qemu_main
130 #endif /* CONFIG_COCOA */
131
132 #include "disas.h"
133
134 #include "exec-all.h"
135
136 #if USE_KVM
137 #include "qemu-kvm.h"
138 #endif
139
140 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
141 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
142 #ifdef __sun__
143 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
144 #else
145 #define SMBD_COMMAND "/usr/sbin/smbd"
146 #endif
147
148 //#define DEBUG_UNUSED_IOPORT
149 //#define DEBUG_IOPORT
150
151 #if HOST_LONG_BITS < 64
152 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
153 #else
154 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024 * 1024ULL)
155 #endif
156
157 #ifdef TARGET_PPC
158 #define DEFAULT_RAM_SIZE 144
159 #else
160 #define DEFAULT_RAM_SIZE 128
161 #endif
162 /* in ms */
163 #define GUI_REFRESH_INTERVAL 30
164
165 /* Max number of USB devices that can be specified on the commandline. */
166 #define MAX_USB_CMDLINE 8
167
168 /* XXX: use a two level table to limit memory usage */
169 #define MAX_IOPORTS 65536
170
171 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
172 const char *bios_name = NULL;
173 void *ioport_opaque[MAX_IOPORTS];
174 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
175 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
176 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
177 to store the VM snapshots */
178 DriveInfo drives_table[MAX_DRIVES+1];
179 int nb_drives;
180 /* point to the block driver where the snapshots are managed */
181 BlockDriverState *bs_snapshots;
182 int vga_ram_size;
183 static DisplayState display_state;
184 int nographic;
185 const char* keyboard_layout = NULL;
186 int64_t ticks_per_sec;
187 int64_t ram_size;
188 int pit_min_timer_count = 0;
189 int nb_nics;
190 NICInfo nd_table[MAX_NICS];
191 int vm_running;
192 int rtc_utc = 1;
193 int rtc_start_date = -1; /* -1 means now */
194 int cirrus_vga_enabled = 1;
195 int vmsvga_enabled = 0;
196 #ifdef TARGET_SPARC
197 int graphic_width = 1024;
198 int graphic_height = 768;
199 int graphic_depth = 8;
200 #else
201 int graphic_width = 800;
202 int graphic_height = 600;
203 int graphic_depth = 15;
204 #endif
205 int full_screen = 0;
206 int no_frame = 0;
207 int no_quit = 0;
208 int balloon_used = 0;
209 CharDriverState *vmchannel_hds[MAX_VMCHANNEL_DEVICES];
210 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
211 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
212 #ifdef TARGET_I386
213 int win2k_install_hack = 0;
214 #endif
215 int usb_enabled = 0;
216 static VLANState *first_vlan;
217 int smp_cpus = 1;
218 const char *vnc_display;
219 #if defined(TARGET_SPARC)
220 #define MAX_CPUS 16
221 #elif defined(TARGET_I386)
222 #define MAX_CPUS 255
223 #else
224 #define MAX_CPUS 1
225 #endif
226 int acpi_enabled = 1;
227 int fd_bootchk = 1;
228 int no_reboot = 0;
229 int cursor_hide = 1;
230 int graphic_rotate = 0;
231 int daemonize = 0;
232 const char *incoming;
233 const char *option_rom[MAX_OPTION_ROMS];
234 int nb_option_roms;
235 int semihosting_enabled = 0;
236 int autostart = 1;
237 int time_drift_fix = 0;
238 unsigned int kvm_shadow_memory = 0;
239 const char *cpu_vendor_string;
240 #ifdef TARGET_ARM
241 int old_param = 0;
242 #endif
243 const char *qemu_name;
244 int alt_grab = 0;
245 #ifdef TARGET_SPARC
246 unsigned int nb_prom_envs = 0;
247 const char *prom_envs[MAX_PROM_ENVS];
248 #endif
249 int nb_drives_opt;
250 char drives_opt[MAX_DRIVES][1024];
251
252 static CPUState *cur_cpu;
253 static CPUState *next_cpu;
254 static int event_pending = 1;
255
256 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
257
258 void decorate_application_name(char *appname, int max_len)
259 {
260 #if USE_KVM
261 if (kvm_allowed)
262 {
263 int remain = max_len - strlen(appname) - 1;
264
265 if (remain > 0)
266 strncat(appname, "/KVM", remain);
267 }
268 #endif
269 }
270
271 /***********************************************************/
272 /* x86 ISA bus support */
273
274 target_phys_addr_t isa_mem_base = 0;
275 PicState2 *isa_pic;
276
277 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
278 {
279 #ifdef DEBUG_UNUSED_IOPORT
280 fprintf(stderr, "unused inb: port=0x%04x\n", address);
281 #endif
282 return 0xff;
283 }
284
285 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
286 {
287 #ifdef DEBUG_UNUSED_IOPORT
288 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
289 #endif
290 }
291
292 /* default is to make two byte accesses */
293 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
294 {
295 uint32_t data;
296 data = ioport_read_table[0][address](ioport_opaque[address], address);
297 address = (address + 1) & (MAX_IOPORTS - 1);
298 data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
299 return data;
300 }
301
302 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
303 {
304 ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
305 address = (address + 1) & (MAX_IOPORTS - 1);
306 ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
307 }
308
309 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
310 {
311 #ifdef DEBUG_UNUSED_IOPORT
312 fprintf(stderr, "unused inl: port=0x%04x\n", address);
313 #endif
314 return 0xffffffff;
315 }
316
317 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
318 {
319 #ifdef DEBUG_UNUSED_IOPORT
320 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
321 #endif
322 }
323
324 static void init_ioports(void)
325 {
326 int i;
327
328 for(i = 0; i < MAX_IOPORTS; i++) {
329 ioport_read_table[0][i] = default_ioport_readb;
330 ioport_write_table[0][i] = default_ioport_writeb;
331 ioport_read_table[1][i] = default_ioport_readw;
332 ioport_write_table[1][i] = default_ioport_writew;
333 ioport_read_table[2][i] = default_ioport_readl;
334 ioport_write_table[2][i] = default_ioport_writel;
335 }
336 }
337
338 /* size is the word size in byte */
339 int register_ioport_read(int start, int length, int size,
340 IOPortReadFunc *func, void *opaque)
341 {
342 int i, bsize;
343
344 if (size == 1) {
345 bsize = 0;
346 } else if (size == 2) {
347 bsize = 1;
348 } else if (size == 4) {
349 bsize = 2;
350 } else {
351 hw_error("register_ioport_read: invalid size");
352 return -1;
353 }
354 for(i = start; i < start + length; i += size) {
355 ioport_read_table[bsize][i] = func;
356 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
357 hw_error("register_ioport_read: invalid opaque");
358 ioport_opaque[i] = opaque;
359 }
360 return 0;
361 }
362
363 /* size is the word size in byte */
364 int register_ioport_write(int start, int length, int size,
365 IOPortWriteFunc *func, void *opaque)
366 {
367 int i, bsize;
368
369 if (size == 1) {
370 bsize = 0;
371 } else if (size == 2) {
372 bsize = 1;
373 } else if (size == 4) {
374 bsize = 2;
375 } else {
376 hw_error("register_ioport_write: invalid size");
377 return -1;
378 }
379 for(i = start; i < start + length; i += size) {
380 ioport_write_table[bsize][i] = func;
381 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
382 hw_error("register_ioport_write: invalid opaque");
383 ioport_opaque[i] = opaque;
384 }
385 return 0;
386 }
387
388 void isa_unassign_ioport(int start, int length)
389 {
390 int i;
391
392 for(i = start; i < start + length; i++) {
393 ioport_read_table[0][i] = default_ioport_readb;
394 ioport_read_table[1][i] = default_ioport_readw;
395 ioport_read_table[2][i] = default_ioport_readl;
396
397 ioport_write_table[0][i] = default_ioport_writeb;
398 ioport_write_table[1][i] = default_ioport_writew;
399 ioport_write_table[2][i] = default_ioport_writel;
400 }
401 }
402
403 /***********************************************************/
404
405 void cpu_outb(CPUState *env, int addr, int val)
406 {
407 #ifdef DEBUG_IOPORT
408 if (loglevel & CPU_LOG_IOPORT)
409 fprintf(logfile, "outb: %04x %02x\n", addr, val);
410 #endif
411 ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
412 #ifdef USE_KQEMU
413 if (env)
414 env->last_io_time = cpu_get_time_fast();
415 #endif
416 }
417
418 void cpu_outw(CPUState *env, int addr, int val)
419 {
420 #ifdef DEBUG_IOPORT
421 if (loglevel & CPU_LOG_IOPORT)
422 fprintf(logfile, "outw: %04x %04x\n", addr, val);
423 #endif
424 ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
425 #ifdef USE_KQEMU
426 if (env)
427 env->last_io_time = cpu_get_time_fast();
428 #endif
429 }
430
431 void cpu_outl(CPUState *env, int addr, int val)
432 {
433 #ifdef DEBUG_IOPORT
434 if (loglevel & CPU_LOG_IOPORT)
435 fprintf(logfile, "outl: %04x %08x\n", addr, val);
436 #endif
437 ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
438 #ifdef USE_KQEMU
439 if (env)
440 env->last_io_time = cpu_get_time_fast();
441 #endif
442 }
443
444 int cpu_inb(CPUState *env, int addr)
445 {
446 int val;
447 val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
448 #ifdef DEBUG_IOPORT
449 if (loglevel & CPU_LOG_IOPORT)
450 fprintf(logfile, "inb : %04x %02x\n", addr, val);
451 #endif
452 #ifdef USE_KQEMU
453 if (env)
454 env->last_io_time = cpu_get_time_fast();
455 #endif
456 return val;
457 }
458
459 int cpu_inw(CPUState *env, int addr)
460 {
461 int val;
462 val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
463 #ifdef DEBUG_IOPORT
464 if (loglevel & CPU_LOG_IOPORT)
465 fprintf(logfile, "inw : %04x %04x\n", addr, val);
466 #endif
467 #ifdef USE_KQEMU
468 if (env)
469 env->last_io_time = cpu_get_time_fast();
470 #endif
471 return val;
472 }
473
474 int cpu_inl(CPUState *env, int addr)
475 {
476 int val;
477 val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
478 #ifdef DEBUG_IOPORT
479 if (loglevel & CPU_LOG_IOPORT)
480 fprintf(logfile, "inl : %04x %08x\n", addr, val);
481 #endif
482 #ifdef USE_KQEMU
483 if (env)
484 env->last_io_time = cpu_get_time_fast();
485 #endif
486 return val;
487 }
488
489 /***********************************************************/
490 void hw_error(const char *fmt, ...)
491 {
492 va_list ap;
493 CPUState *env;
494
495 va_start(ap, fmt);
496 fprintf(stderr, "qemu: hardware error: ");
497 vfprintf(stderr, fmt, ap);
498 fprintf(stderr, "\n");
499 for(env = first_cpu; env != NULL; env = env->next_cpu) {
500 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
501 #ifdef TARGET_I386
502 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
503 #else
504 cpu_dump_state(env, stderr, fprintf, 0);
505 #endif
506 }
507 va_end(ap);
508 abort();
509 }
510
511 /***********************************************************/
512 /* keyboard/mouse */
513
514 static QEMUPutKBDEvent *qemu_put_kbd_event;
515 static void *qemu_put_kbd_event_opaque;
516 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
517 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
518
519 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
520 {
521 qemu_put_kbd_event_opaque = opaque;
522 qemu_put_kbd_event = func;
523 }
524
525 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
526 void *opaque, int absolute,
527 const char *name)
528 {
529 QEMUPutMouseEntry *s, *cursor;
530
531 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
532 if (!s)
533 return NULL;
534
535 s->qemu_put_mouse_event = func;
536 s->qemu_put_mouse_event_opaque = opaque;
537 s->qemu_put_mouse_event_absolute = absolute;
538 s->qemu_put_mouse_event_name = qemu_strdup(name);
539 s->next = NULL;
540
541 if (!qemu_put_mouse_event_head) {
542 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
543 return s;
544 }
545
546 cursor = qemu_put_mouse_event_head;
547 while (cursor->next != NULL)
548 cursor = cursor->next;
549
550 cursor->next = s;
551 qemu_put_mouse_event_current = s;
552
553 return s;
554 }
555
556 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
557 {
558 QEMUPutMouseEntry *prev = NULL, *cursor;
559
560 if (!qemu_put_mouse_event_head || entry == NULL)
561 return;
562
563 cursor = qemu_put_mouse_event_head;
564 while (cursor != NULL && cursor != entry) {
565 prev = cursor;
566 cursor = cursor->next;
567 }
568
569 if (cursor == NULL) // does not exist or list empty
570 return;
571 else if (prev == NULL) { // entry is head
572 qemu_put_mouse_event_head = cursor->next;
573 if (qemu_put_mouse_event_current == entry)
574 qemu_put_mouse_event_current = cursor->next;
575 qemu_free(entry->qemu_put_mouse_event_name);
576 qemu_free(entry);
577 return;
578 }
579
580 prev->next = entry->next;
581
582 if (qemu_put_mouse_event_current == entry)
583 qemu_put_mouse_event_current = prev;
584
585 qemu_free(entry->qemu_put_mouse_event_name);
586 qemu_free(entry);
587 }
588
589 void kbd_put_keycode(int keycode)
590 {
591 if (qemu_put_kbd_event) {
592 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
593 }
594 }
595
596 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
597 {
598 QEMUPutMouseEvent *mouse_event;
599 void *mouse_event_opaque;
600 int width;
601
602 if (!qemu_put_mouse_event_current) {
603 return;
604 }
605
606 mouse_event =
607 qemu_put_mouse_event_current->qemu_put_mouse_event;
608 mouse_event_opaque =
609 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
610
611 if (mouse_event) {
612 if (graphic_rotate) {
613 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
614 width = 0x7fff;
615 else
616 width = graphic_width;
617 mouse_event(mouse_event_opaque,
618 width - dy, dx, dz, buttons_state);
619 } else
620 mouse_event(mouse_event_opaque,
621 dx, dy, dz, buttons_state);
622 }
623 }
624
625 int kbd_mouse_is_absolute(void)
626 {
627 if (!qemu_put_mouse_event_current)
628 return 0;
629
630 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
631 }
632
633 void do_info_mice(void)
634 {
635 QEMUPutMouseEntry *cursor;
636 int index = 0;
637
638 if (!qemu_put_mouse_event_head) {
639 term_printf("No mouse devices connected\n");
640 return;
641 }
642
643 term_printf("Mouse devices available:\n");
644 cursor = qemu_put_mouse_event_head;
645 while (cursor != NULL) {
646 term_printf("%c Mouse #%d: %s\n",
647 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
648 index, cursor->qemu_put_mouse_event_name);
649 index++;
650 cursor = cursor->next;
651 }
652 }
653
654 void do_mouse_set(int index)
655 {
656 QEMUPutMouseEntry *cursor;
657 int i = 0;
658
659 if (!qemu_put_mouse_event_head) {
660 term_printf("No mouse devices connected\n");
661 return;
662 }
663
664 cursor = qemu_put_mouse_event_head;
665 while (cursor != NULL && index != i) {
666 i++;
667 cursor = cursor->next;
668 }
669
670 if (cursor != NULL)
671 qemu_put_mouse_event_current = cursor;
672 else
673 term_printf("Mouse at given index not found\n");
674 }
675
676 /* compute with 96 bit intermediate result: (a*b)/c */
677 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
678 {
679 union {
680 uint64_t ll;
681 struct {
682 #ifdef WORDS_BIGENDIAN
683 uint32_t high, low;
684 #else
685 uint32_t low, high;
686 #endif
687 } l;
688 } u, res;
689 uint64_t rl, rh;
690
691 u.ll = a;
692 rl = (uint64_t)u.l.low * (uint64_t)b;
693 rh = (uint64_t)u.l.high * (uint64_t)b;
694 rh += (rl >> 32);
695 res.l.high = rh / c;
696 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
697 return res.ll;
698 }
699
700 /***********************************************************/
701 /* real time host monotonic timer */
702
703 #define QEMU_TIMER_BASE 1000000000LL
704
705 #ifdef WIN32
706
707 static int64_t clock_freq;
708
709 static void init_get_clock(void)
710 {
711 LARGE_INTEGER freq;
712 int ret;
713 ret = QueryPerformanceFrequency(&freq);
714 if (ret == 0) {
715 fprintf(stderr, "Could not calibrate ticks\n");
716 exit(1);
717 }
718 clock_freq = freq.QuadPart;
719 }
720
721 static int64_t get_clock(void)
722 {
723 LARGE_INTEGER ti;
724 QueryPerformanceCounter(&ti);
725 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
726 }
727
728 #else
729
730 static int use_rt_clock;
731
732 static void init_get_clock(void)
733 {
734 use_rt_clock = 0;
735 #if defined(__linux__)
736 {
737 struct timespec ts;
738 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
739 use_rt_clock = 1;
740 }
741 }
742 #endif
743 }
744
745 static int64_t get_clock(void)
746 {
747 #if defined(__linux__)
748 if (use_rt_clock) {
749 struct timespec ts;
750 clock_gettime(CLOCK_MONOTONIC, &ts);
751 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
752 } else
753 #endif
754 {
755 /* XXX: using gettimeofday leads to problems if the date
756 changes, so it should be avoided. */
757 struct timeval tv;
758 gettimeofday(&tv, NULL);
759 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
760 }
761 }
762
763 #endif
764
765 /***********************************************************/
766 /* guest cycle counter */
767
768 static int64_t cpu_ticks_prev;
769 static int64_t cpu_ticks_offset;
770 static int64_t cpu_clock_offset;
771 static int cpu_ticks_enabled;
772
773 /* return the host CPU cycle counter and handle stop/restart */
774 int64_t cpu_get_ticks(void)
775 {
776 if (!cpu_ticks_enabled) {
777 return cpu_ticks_offset;
778 } else {
779 int64_t ticks;
780 ticks = cpu_get_real_ticks();
781 if (cpu_ticks_prev > ticks) {
782 /* Note: non increasing ticks may happen if the host uses
783 software suspend */
784 cpu_ticks_offset += cpu_ticks_prev - ticks;
785 }
786 cpu_ticks_prev = ticks;
787 return ticks + cpu_ticks_offset;
788 }
789 }
790
791 /* return the host CPU monotonic timer and handle stop/restart */
792 static int64_t cpu_get_clock(void)
793 {
794 int64_t ti;
795 if (!cpu_ticks_enabled) {
796 return cpu_clock_offset;
797 } else {
798 ti = get_clock();
799 return ti + cpu_clock_offset;
800 }
801 }
802
803 /* enable cpu_get_ticks() */
804 void cpu_enable_ticks(void)
805 {
806 if (!cpu_ticks_enabled) {
807 cpu_ticks_offset -= cpu_get_real_ticks();
808 cpu_clock_offset -= get_clock();
809 cpu_ticks_enabled = 1;
810 }
811 }
812
813 /* disable cpu_get_ticks() : the clock is stopped. You must not call
814 cpu_get_ticks() after that. */
815 void cpu_disable_ticks(void)
816 {
817 if (cpu_ticks_enabled) {
818 cpu_ticks_offset = cpu_get_ticks();
819 cpu_clock_offset = cpu_get_clock();
820 cpu_ticks_enabled = 0;
821 }
822 }
823
824 /***********************************************************/
825 /* timers */
826
827 #define QEMU_TIMER_REALTIME 0
828 #define QEMU_TIMER_VIRTUAL 1
829
830 struct QEMUClock {
831 int type;
832 /* XXX: add frequency */
833 };
834
835 struct QEMUTimer {
836 QEMUClock *clock;
837 int64_t expire_time;
838 QEMUTimerCB *cb;
839 void *opaque;
840 struct QEMUTimer *next;
841 };
842
843 struct qemu_alarm_timer {
844 char const *name;
845 unsigned int flags;
846
847 int (*start)(struct qemu_alarm_timer *t);
848 void (*stop)(struct qemu_alarm_timer *t);
849 void (*rearm)(struct qemu_alarm_timer *t);
850 void *priv;
851 };
852
853 #define ALARM_FLAG_DYNTICKS 0x1
854
855 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
856 {
857 return t->flags & ALARM_FLAG_DYNTICKS;
858 }
859
860 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
861 {
862 if (!alarm_has_dynticks(t))
863 return;
864
865 t->rearm(t);
866 }
867
868 /* TODO: MIN_TIMER_REARM_US should be optimized */
869 #define MIN_TIMER_REARM_US 250
870
871 static struct qemu_alarm_timer *alarm_timer;
872
873 #ifdef _WIN32
874
875 struct qemu_alarm_win32 {
876 MMRESULT timerId;
877 HANDLE host_alarm;
878 unsigned int period;
879 } alarm_win32_data = {0, NULL, -1};
880
881 static int win32_start_timer(struct qemu_alarm_timer *t);
882 static void win32_stop_timer(struct qemu_alarm_timer *t);
883 static void win32_rearm_timer(struct qemu_alarm_timer *t);
884
885 #else
886
887 static int unix_start_timer(struct qemu_alarm_timer *t);
888 static void unix_stop_timer(struct qemu_alarm_timer *t);
889
890 #ifdef __linux__
891
892 static int dynticks_start_timer(struct qemu_alarm_timer *t);
893 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
894 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
895
896 static int hpet_start_timer(struct qemu_alarm_timer *t);
897 static void hpet_stop_timer(struct qemu_alarm_timer *t);
898
899 static int rtc_start_timer(struct qemu_alarm_timer *t);
900 static void rtc_stop_timer(struct qemu_alarm_timer *t);
901
902 #endif /* __linux__ */
903
904 #endif /* _WIN32 */
905
906 static struct qemu_alarm_timer alarm_timers[] = {
907 #ifndef _WIN32
908 #ifdef __linux__
909 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
910 dynticks_stop_timer, dynticks_rearm_timer, NULL},
911 /* HPET - if available - is preferred */
912 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
913 /* ...otherwise try RTC */
914 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
915 #endif
916 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
917 #else
918 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
919 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
920 {"win32", 0, win32_start_timer,
921 win32_stop_timer, NULL, &alarm_win32_data},
922 #endif
923 {NULL, }
924 };
925
926 static void show_available_alarms()
927 {
928 int i;
929
930 printf("Available alarm timers, in order of precedence:\n");
931 for (i = 0; alarm_timers[i].name; i++)
932 printf("%s\n", alarm_timers[i].name);
933 }
934
935 static void configure_alarms(char const *opt)
936 {
937 int i;
938 int cur = 0;
939 int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
940 char *arg;
941 char *name;
942
943 if (!strcmp(opt, "help")) {
944 show_available_alarms();
945 exit(0);
946 }
947
948 arg = strdup(opt);
949
950 /* Reorder the array */
951 name = strtok(arg, ",");
952 while (name) {
953 struct qemu_alarm_timer tmp;
954
955 for (i = 0; i < count && alarm_timers[i].name; i++) {
956 if (!strcmp(alarm_timers[i].name, name))
957 break;
958 }
959
960 if (i == count) {
961 fprintf(stderr, "Unknown clock %s\n", name);
962 goto next;
963 }
964
965 if (i < cur)
966 /* Ignore */
967 goto next;
968
969 /* Swap */
970 tmp = alarm_timers[i];
971 alarm_timers[i] = alarm_timers[cur];
972 alarm_timers[cur] = tmp;
973
974 cur++;
975 next:
976 name = strtok(NULL, ",");
977 }
978
979 free(arg);
980
981 if (cur) {
982 /* Disable remaining timers */
983 for (i = cur; i < count; i++)
984 alarm_timers[i].name = NULL;
985 }
986
987 /* debug */
988 show_available_alarms();
989 }
990
991 QEMUClock *rt_clock;
992 QEMUClock *vm_clock;
993
994 static QEMUTimer *active_timers[2];
995
996 static QEMUClock *qemu_new_clock(int type)
997 {
998 QEMUClock *clock;
999 clock = qemu_mallocz(sizeof(QEMUClock));
1000 if (!clock)
1001 return NULL;
1002 clock->type = type;
1003 return clock;
1004 }
1005
1006 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1007 {
1008 QEMUTimer *ts;
1009
1010 ts = qemu_mallocz(sizeof(QEMUTimer));
1011 ts->clock = clock;
1012 ts->cb = cb;
1013 ts->opaque = opaque;
1014 return ts;
1015 }
1016
1017 void qemu_free_timer(QEMUTimer *ts)
1018 {
1019 qemu_free(ts);
1020 }
1021
1022 /* stop a timer, but do not dealloc it */
1023 void qemu_del_timer(QEMUTimer *ts)
1024 {
1025 QEMUTimer **pt, *t;
1026
1027 /* NOTE: this code must be signal safe because
1028 qemu_timer_expired() can be called from a signal. */
1029 pt = &active_timers[ts->clock->type];
1030 for(;;) {
1031 t = *pt;
1032 if (!t)
1033 break;
1034 if (t == ts) {
1035 *pt = t->next;
1036 break;
1037 }
1038 pt = &t->next;
1039 }
1040 }
1041
1042 /* modify the current timer so that it will be fired when current_time
1043 >= expire_time. The corresponding callback will be called. */
1044 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1045 {
1046 QEMUTimer **pt, *t;
1047
1048 qemu_del_timer(ts);
1049
1050 /* add the timer in the sorted list */
1051 /* NOTE: this code must be signal safe because
1052 qemu_timer_expired() can be called from a signal. */
1053 pt = &active_timers[ts->clock->type];
1054 for(;;) {
1055 t = *pt;
1056 if (!t)
1057 break;
1058 if (t->expire_time > expire_time)
1059 break;
1060 pt = &t->next;
1061 }
1062 ts->expire_time = expire_time;
1063 ts->next = *pt;
1064 *pt = ts;
1065 }
1066
1067 int qemu_timer_pending(QEMUTimer *ts)
1068 {
1069 QEMUTimer *t;
1070 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1071 if (t == ts)
1072 return 1;
1073 }
1074 return 0;
1075 }
1076
1077 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1078 {
1079 if (!timer_head)
1080 return 0;
1081 return (timer_head->expire_time <= current_time);
1082 }
1083
1084 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1085 {
1086 QEMUTimer *ts;
1087
1088 for(;;) {
1089 ts = *ptimer_head;
1090 if (!ts || ts->expire_time > current_time)
1091 break;
1092 /* remove timer from the list before calling the callback */
1093 *ptimer_head = ts->next;
1094 ts->next = NULL;
1095
1096 /* run the callback (the timer list can be modified) */
1097 ts->cb(ts->opaque);
1098 }
1099 qemu_rearm_alarm_timer(alarm_timer);
1100 }
1101
1102 int64_t qemu_get_clock(QEMUClock *clock)
1103 {
1104 switch(clock->type) {
1105 case QEMU_TIMER_REALTIME:
1106 return get_clock() / 1000000;
1107 default:
1108 case QEMU_TIMER_VIRTUAL:
1109 return cpu_get_clock();
1110 }
1111 }
1112
1113 static void init_timers(void)
1114 {
1115 init_get_clock();
1116 ticks_per_sec = QEMU_TIMER_BASE;
1117 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1118 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1119 }
1120
1121 /* save a timer */
1122 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1123 {
1124 uint64_t expire_time;
1125
1126 if (qemu_timer_pending(ts)) {
1127 expire_time = ts->expire_time;
1128 } else {
1129 expire_time = -1;
1130 }
1131 qemu_put_be64(f, expire_time);
1132 }
1133
1134 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1135 {
1136 uint64_t expire_time;
1137
1138 expire_time = qemu_get_be64(f);
1139 if (expire_time != -1) {
1140 qemu_mod_timer(ts, expire_time);
1141 } else {
1142 qemu_del_timer(ts);
1143 }
1144 }
1145
1146 static void timer_save(QEMUFile *f, void *opaque)
1147 {
1148 if (cpu_ticks_enabled) {
1149 hw_error("cannot save state if virtual timers are running");
1150 }
1151 qemu_put_be64(f, cpu_ticks_offset);
1152 qemu_put_be64(f, ticks_per_sec);
1153 qemu_put_be64(f, cpu_clock_offset);
1154 }
1155
1156 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1157 {
1158 if (version_id != 1 && version_id != 2)
1159 return -EINVAL;
1160 if (cpu_ticks_enabled) {
1161 return -EINVAL;
1162 }
1163 cpu_ticks_offset=qemu_get_be64(f);
1164 ticks_per_sec=qemu_get_be64(f);
1165 if (version_id == 2) {
1166 cpu_clock_offset=qemu_get_be64(f);
1167 }
1168 return 0;
1169 }
1170
1171 #ifdef _WIN32
1172 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1173 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1174 #else
1175 static void host_alarm_handler(int host_signum)
1176 #endif
1177 {
1178 #if 0
1179 #define DISP_FREQ 1000
1180 {
1181 static int64_t delta_min = INT64_MAX;
1182 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1183 static int count;
1184 ti = qemu_get_clock(vm_clock);
1185 if (last_clock != 0) {
1186 delta = ti - last_clock;
1187 if (delta < delta_min)
1188 delta_min = delta;
1189 if (delta > delta_max)
1190 delta_max = delta;
1191 delta_cum += delta;
1192 if (++count == DISP_FREQ) {
1193 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1194 muldiv64(delta_min, 1000000, ticks_per_sec),
1195 muldiv64(delta_max, 1000000, ticks_per_sec),
1196 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1197 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1198 count = 0;
1199 delta_min = INT64_MAX;
1200 delta_max = 0;
1201 delta_cum = 0;
1202 }
1203 }
1204 last_clock = ti;
1205 }
1206 #endif
1207 if (1 ||
1208 alarm_has_dynticks(alarm_timer) ||
1209 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1210 qemu_get_clock(vm_clock)) ||
1211 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1212 qemu_get_clock(rt_clock))) {
1213 #ifdef _WIN32
1214 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1215 SetEvent(data->host_alarm);
1216 #endif
1217 CPUState *env = next_cpu;
1218
1219 if (env) {
1220 /* stop the currently executing cpu because a timer occured */
1221 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1222 #ifdef USE_KQEMU
1223 if (env->kqemu_enabled) {
1224 kqemu_cpu_interrupt(env);
1225 }
1226 #endif
1227 }
1228 event_pending = 1;
1229 }
1230 }
1231
1232 static uint64_t qemu_next_deadline(void)
1233 {
1234 int64_t nearest_delta_us = INT64_MAX;
1235 int64_t vmdelta_us;
1236
1237 if (active_timers[QEMU_TIMER_REALTIME])
1238 nearest_delta_us = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1239 qemu_get_clock(rt_clock))*1000;
1240
1241 if (active_timers[QEMU_TIMER_VIRTUAL]) {
1242 /* round up */
1243 vmdelta_us = (active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1244 qemu_get_clock(vm_clock)+999)/1000;
1245 if (vmdelta_us < nearest_delta_us)
1246 nearest_delta_us = vmdelta_us;
1247 }
1248
1249 /* Avoid arming the timer to negative, zero, or too low values */
1250 if (nearest_delta_us <= MIN_TIMER_REARM_US)
1251 nearest_delta_us = MIN_TIMER_REARM_US;
1252
1253 return nearest_delta_us;
1254 }
1255
1256 #ifndef _WIN32
1257
1258 #if defined(__linux__)
1259
1260 #define RTC_FREQ 1024
1261
1262 static void enable_sigio_timer(int fd)
1263 {
1264 struct sigaction act;
1265
1266 /* timer signal */
1267 sigfillset(&act.sa_mask);
1268 act.sa_flags = 0;
1269 act.sa_handler = host_alarm_handler;
1270
1271 sigaction(SIGIO, &act, NULL);
1272 fcntl(fd, F_SETFL, O_ASYNC);
1273 fcntl(fd, F_SETOWN, getpid());
1274 }
1275
1276 static int hpet_start_timer(struct qemu_alarm_timer *t)
1277 {
1278 struct hpet_info info;
1279 int r, fd;
1280
1281 fd = open("/dev/hpet", O_RDONLY);
1282 if (fd < 0)
1283 return -1;
1284
1285 /* Set frequency */
1286 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1287 if (r < 0) {
1288 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1289 "error, but for better emulation accuracy type:\n"
1290 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1291 goto fail;
1292 }
1293
1294 /* Check capabilities */
1295 r = ioctl(fd, HPET_INFO, &info);
1296 if (r < 0)
1297 goto fail;
1298
1299 /* Enable periodic mode */
1300 r = ioctl(fd, HPET_EPI, 0);
1301 if (info.hi_flags && (r < 0))
1302 goto fail;
1303
1304 /* Enable interrupt */
1305 r = ioctl(fd, HPET_IE_ON, 0);
1306 if (r < 0)
1307 goto fail;
1308
1309 enable_sigio_timer(fd);
1310 t->priv = (void *)(long)fd;
1311
1312 return 0;
1313 fail:
1314 close(fd);
1315 return -1;
1316 }
1317
1318 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1319 {
1320 int fd = (long)t->priv;
1321
1322 close(fd);
1323 }
1324
1325 static int rtc_start_timer(struct qemu_alarm_timer *t)
1326 {
1327 int rtc_fd;
1328
1329 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1330 if (rtc_fd < 0)
1331 return -1;
1332 if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1333 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1334 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1335 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1336 goto fail;
1337 }
1338 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1339 fail:
1340 close(rtc_fd);
1341 return -1;
1342 }
1343
1344 enable_sigio_timer(rtc_fd);
1345
1346 t->priv = (void *)(long)rtc_fd;
1347
1348 return 0;
1349 }
1350
1351 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1352 {
1353 int rtc_fd = (long)t->priv;
1354
1355 close(rtc_fd);
1356 }
1357
1358 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1359 {
1360 struct sigevent ev;
1361 timer_t host_timer;
1362 struct sigaction act;
1363
1364 sigfillset(&act.sa_mask);
1365 act.sa_flags = 0;
1366 act.sa_handler = host_alarm_handler;
1367
1368 sigaction(SIGALRM, &act, NULL);
1369
1370 ev.sigev_value.sival_int = 0;
1371 ev.sigev_notify = SIGEV_SIGNAL;
1372 ev.sigev_signo = SIGALRM;
1373
1374 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1375 perror("timer_create");
1376
1377 /* disable dynticks */
1378 fprintf(stderr, "Dynamic Ticks disabled\n");
1379
1380 return -1;
1381 }
1382
1383 t->priv = (void *)host_timer;
1384
1385 return 0;
1386 }
1387
1388 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1389 {
1390 timer_t host_timer = (timer_t)t->priv;
1391
1392 timer_delete(host_timer);
1393 }
1394
1395 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1396 {
1397 timer_t host_timer = (timer_t)t->priv;
1398 struct itimerspec timeout;
1399 int64_t nearest_delta_us = INT64_MAX;
1400 int64_t current_us;
1401
1402 if (!active_timers[QEMU_TIMER_REALTIME] &&
1403 !active_timers[QEMU_TIMER_VIRTUAL])
1404 return;
1405
1406 nearest_delta_us = qemu_next_deadline();
1407
1408 /* check whether a timer is already running */
1409 if (timer_gettime(host_timer, &timeout)) {
1410 perror("gettime");
1411 fprintf(stderr, "Internal timer error: aborting\n");
1412 exit(1);
1413 }
1414 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1415 if (current_us && current_us <= nearest_delta_us)
1416 return;
1417
1418 timeout.it_interval.tv_sec = 0;
1419 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1420 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1421 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1422 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1423 perror("settime");
1424 fprintf(stderr, "Internal timer error: aborting\n");
1425 exit(1);
1426 }
1427 }
1428
1429 #endif /* defined(__linux__) */
1430
1431 static int unix_start_timer(struct qemu_alarm_timer *t)
1432 {
1433 struct sigaction act;
1434 struct itimerval itv;
1435 int err;
1436
1437 /* timer signal */
1438 sigfillset(&act.sa_mask);
1439 act.sa_flags = 0;
1440 act.sa_handler = host_alarm_handler;
1441
1442 sigaction(SIGALRM, &act, NULL);
1443
1444 itv.it_interval.tv_sec = 0;
1445 /* for i386 kernel 2.6 to get 1 ms */
1446 itv.it_interval.tv_usec = 999;
1447 itv.it_value.tv_sec = 0;
1448 itv.it_value.tv_usec = 10 * 1000;
1449
1450 err = setitimer(ITIMER_REAL, &itv, NULL);
1451 if (err)
1452 return -1;
1453
1454 return 0;
1455 }
1456
1457 static void unix_stop_timer(struct qemu_alarm_timer *t)
1458 {
1459 struct itimerval itv;
1460
1461 memset(&itv, 0, sizeof(itv));
1462 setitimer(ITIMER_REAL, &itv, NULL);
1463 }
1464
1465 #endif /* !defined(_WIN32) */
1466
1467 #ifdef _WIN32
1468
1469 static int win32_start_timer(struct qemu_alarm_timer *t)
1470 {
1471 TIMECAPS tc;
1472 struct qemu_alarm_win32 *data = t->priv;
1473 UINT flags;
1474
1475 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1476 if (!data->host_alarm) {
1477 perror("Failed CreateEvent");
1478 return -1;
1479 }
1480
1481 memset(&tc, 0, sizeof(tc));
1482 timeGetDevCaps(&tc, sizeof(tc));
1483
1484 if (data->period < tc.wPeriodMin)
1485 data->period = tc.wPeriodMin;
1486
1487 timeBeginPeriod(data->period);
1488
1489 flags = TIME_CALLBACK_FUNCTION;
1490 if (alarm_has_dynticks(t))
1491 flags |= TIME_ONESHOT;
1492 else
1493 flags |= TIME_PERIODIC;
1494
1495 data->timerId = timeSetEvent(1, // interval (ms)
1496 data->period, // resolution
1497 host_alarm_handler, // function
1498 (DWORD)t, // parameter
1499 flags);
1500
1501 if (!data->timerId) {
1502 perror("Failed to initialize win32 alarm timer");
1503
1504 timeEndPeriod(data->period);
1505 CloseHandle(data->host_alarm);
1506 return -1;
1507 }
1508
1509 qemu_add_wait_object(data->host_alarm, NULL, NULL);
1510
1511 return 0;
1512 }
1513
1514 static void win32_stop_timer(struct qemu_alarm_timer *t)
1515 {
1516 struct qemu_alarm_win32 *data = t->priv;
1517
1518 timeKillEvent(data->timerId);
1519 timeEndPeriod(data->period);
1520
1521 CloseHandle(data->host_alarm);
1522 }
1523
1524 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1525 {
1526 struct qemu_alarm_win32 *data = t->priv;
1527 uint64_t nearest_delta_us;
1528
1529 if (!active_timers[QEMU_TIMER_REALTIME] &&
1530 !active_timers[QEMU_TIMER_VIRTUAL])
1531 return;
1532
1533 nearest_delta_us = qemu_next_deadline();
1534 nearest_delta_us /= 1000;
1535
1536 timeKillEvent(data->timerId);
1537
1538 data->timerId = timeSetEvent(1,
1539 data->period,
1540 host_alarm_handler,
1541 (DWORD)t,
1542 TIME_ONESHOT | TIME_PERIODIC);
1543
1544 if (!data->timerId) {
1545 perror("Failed to re-arm win32 alarm timer");
1546
1547 timeEndPeriod(data->period);
1548 CloseHandle(data->host_alarm);
1549 exit(1);
1550 }
1551 }
1552
1553 #endif /* _WIN32 */
1554
1555 static void init_timer_alarm(void)
1556 {
1557 struct qemu_alarm_timer *t;
1558 int i, err = -1;
1559
1560 for (i = 0; alarm_timers[i].name; i++) {
1561 t = &alarm_timers[i];
1562
1563 err = t->start(t);
1564 if (!err)
1565 break;
1566 }
1567
1568 if (err) {
1569 fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1570 fprintf(stderr, "Terminating\n");
1571 exit(1);
1572 }
1573
1574 alarm_timer = t;
1575 }
1576
1577 static void quit_timers(void)
1578 {
1579 alarm_timer->stop(alarm_timer);
1580 alarm_timer = NULL;
1581 }
1582
1583 /***********************************************************/
1584 /* character device */
1585
1586 static void qemu_chr_event(CharDriverState *s, int event)
1587 {
1588 if (!s->chr_event)
1589 return;
1590 s->chr_event(s->handler_opaque, event);
1591 }
1592
1593 static void qemu_chr_reset_bh(void *opaque)
1594 {
1595 CharDriverState *s = opaque;
1596 qemu_chr_event(s, CHR_EVENT_RESET);
1597 qemu_bh_delete(s->bh);
1598 s->bh = NULL;
1599 }
1600
1601 void qemu_chr_reset(CharDriverState *s)
1602 {
1603 if (s->bh == NULL) {
1604 s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1605 qemu_bh_schedule(s->bh);
1606 }
1607 }
1608
1609 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1610 {
1611 return s->chr_write(s, buf, len);
1612 }
1613
1614 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1615 {
1616 if (!s->chr_ioctl)
1617 return -ENOTSUP;
1618 return s->chr_ioctl(s, cmd, arg);
1619 }
1620
1621 int qemu_chr_can_read(CharDriverState *s)
1622 {
1623 if (!s->chr_can_read)
1624 return 0;
1625 return s->chr_can_read(s->handler_opaque);
1626 }
1627
1628 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1629 {
1630 s->chr_read(s->handler_opaque, buf, len);
1631 }
1632
1633 void qemu_chr_accept_input(CharDriverState *s)
1634 {
1635 if (s->chr_accept_input)
1636 s->chr_accept_input(s);
1637 }
1638
1639 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1640 {
1641 char buf[4096];
1642 va_list ap;
1643 va_start(ap, fmt);
1644 vsnprintf(buf, sizeof(buf), fmt, ap);
1645 qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1646 va_end(ap);
1647 }
1648
1649 void qemu_chr_send_event(CharDriverState *s, int event)
1650 {
1651 if (s->chr_send_event)
1652 s->chr_send_event(s, event);
1653 }
1654
1655 void qemu_chr_add_handlers(CharDriverState *s,
1656 IOCanRWHandler *fd_can_read,
1657 IOReadHandler *fd_read,
1658 IOEventHandler *fd_event,
1659 void *opaque)
1660 {
1661 s->chr_can_read = fd_can_read;
1662 s->chr_read = fd_read;
1663 s->chr_event = fd_event;
1664 s->handler_opaque = opaque;
1665 if (s->chr_update_read_handler)
1666 s->chr_update_read_handler(s);
1667 }
1668
1669 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1670 {
1671 return len;
1672 }
1673
1674 static CharDriverState *qemu_chr_open_null(void)
1675 {
1676 CharDriverState *chr;
1677
1678 chr = qemu_mallocz(sizeof(CharDriverState));
1679 if (!chr)
1680 return NULL;
1681 chr->chr_write = null_chr_write;
1682 return chr;
1683 }
1684
1685 /* MUX driver for serial I/O splitting */
1686 static int term_timestamps;
1687 static int64_t term_timestamps_start;
1688 #define MAX_MUX 4
1689 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1690 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1691 typedef struct {
1692 IOCanRWHandler *chr_can_read[MAX_MUX];
1693 IOReadHandler *chr_read[MAX_MUX];
1694 IOEventHandler *chr_event[MAX_MUX];
1695 void *ext_opaque[MAX_MUX];
1696 CharDriverState *drv;
1697 unsigned char buffer[MUX_BUFFER_SIZE];
1698 int prod;
1699 int cons;
1700 int mux_cnt;
1701 int term_got_escape;
1702 int max_size;
1703 } MuxDriver;
1704
1705
1706 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1707 {
1708 MuxDriver *d = chr->opaque;
1709 int ret;
1710 if (!term_timestamps) {
1711 ret = d->drv->chr_write(d->drv, buf, len);
1712 } else {
1713 int i;
1714
1715 ret = 0;
1716 for(i = 0; i < len; i++) {
1717 ret += d->drv->chr_write(d->drv, buf+i, 1);
1718 if (buf[i] == '\n') {
1719 char buf1[64];
1720 int64_t ti;
1721 int secs;
1722
1723 ti = get_clock();
1724 if (term_timestamps_start == -1)
1725 term_timestamps_start = ti;
1726 ti -= term_timestamps_start;
1727 secs = ti / 1000000000;
1728 snprintf(buf1, sizeof(buf1),
1729 "[%02d:%02d:%02d.%03d] ",
1730 secs / 3600,
1731 (secs / 60) % 60,
1732 secs % 60,
1733 (int)((ti / 1000000) % 1000));
1734 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1735 }
1736 }
1737 }
1738 return ret;
1739 }
1740
1741 static char *mux_help[] = {
1742 "% h print this help\n\r",
1743 "% x exit emulator\n\r",
1744 "% s save disk data back to file (if -snapshot)\n\r",
1745 "% t toggle console timestamps\n\r"
1746 "% b send break (magic sysrq)\n\r",
1747 "% c switch between console and monitor\n\r",
1748 "% % sends %\n\r",
1749 NULL
1750 };
1751
1752 static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1753 static void mux_print_help(CharDriverState *chr)
1754 {
1755 int i, j;
1756 char ebuf[15] = "Escape-Char";
1757 char cbuf[50] = "\n\r";
1758
1759 if (term_escape_char > 0 && term_escape_char < 26) {
1760 sprintf(cbuf,"\n\r");
1761 sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1762 } else {
1763 sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1764 term_escape_char);
1765 }
1766 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1767 for (i = 0; mux_help[i] != NULL; i++) {
1768 for (j=0; mux_help[i][j] != '\0'; j++) {
1769 if (mux_help[i][j] == '%')
1770 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1771 else
1772 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1773 }
1774 }
1775 }
1776
1777 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1778 {
1779 if (d->term_got_escape) {
1780 d->term_got_escape = 0;
1781 if (ch == term_escape_char)
1782 goto send_char;
1783 switch(ch) {
1784 case '?':
1785 case 'h':
1786 mux_print_help(chr);
1787 break;
1788 case 'x':
1789 {
1790 char *term = "QEMU: Terminated\n\r";
1791 chr->chr_write(chr,(uint8_t *)term,strlen(term));
1792 exit(0);
1793 break;
1794 }
1795 case 's':
1796 {
1797 int i;
1798 for (i = 0; i < nb_drives; i++) {
1799 bdrv_commit(drives_table[i].bdrv);
1800 }
1801 }
1802 break;
1803 case 'b':
1804 qemu_chr_event(chr, CHR_EVENT_BREAK);
1805 break;
1806 case 'c':
1807 /* Switch to the next registered device */
1808 chr->focus++;
1809 if (chr->focus >= d->mux_cnt)
1810 chr->focus = 0;
1811 break;
1812 case 't':
1813 term_timestamps = !term_timestamps;
1814 term_timestamps_start = -1;
1815 break;
1816 }
1817 } else if (ch == term_escape_char) {
1818 d->term_got_escape = 1;
1819 } else {
1820 send_char:
1821 return 1;
1822 }
1823 return 0;
1824 }
1825
1826 static void mux_chr_accept_input(CharDriverState *chr)
1827 {
1828 int m = chr->focus;
1829 MuxDriver *d = chr->opaque;
1830
1831 while (d->prod != d->cons &&
1832 d->chr_can_read[m] &&
1833 d->chr_can_read[m](d->ext_opaque[m])) {
1834 d->chr_read[m](d->ext_opaque[m],
1835 &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
1836 }
1837 }
1838
1839 static int mux_chr_can_read(void *opaque)
1840 {
1841 CharDriverState *chr = opaque;
1842 MuxDriver *d = chr->opaque;
1843
1844 if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
1845 return 1;
1846 if (d->chr_can_read[chr->focus])
1847 return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1848 return 0;
1849 }
1850
1851 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1852 {
1853 CharDriverState *chr = opaque;
1854 MuxDriver *d = chr->opaque;
1855 int m = chr->focus;
1856 int i;
1857
1858 mux_chr_accept_input (opaque);
1859
1860 for(i = 0; i < size; i++)
1861 if (mux_proc_byte(chr, d, buf[i])) {
1862 if (d->prod == d->cons &&
1863 d->chr_can_read[m] &&
1864 d->chr_can_read[m](d->ext_opaque[m]))
1865 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
1866 else
1867 d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
1868 }
1869 }
1870
1871 static void mux_chr_event(void *opaque, int event)
1872 {
1873 CharDriverState *chr = opaque;
1874 MuxDriver *d = chr->opaque;
1875 int i;
1876
1877 /* Send the event to all registered listeners */
1878 for (i = 0; i < d->mux_cnt; i++)
1879 if (d->chr_event[i])
1880 d->chr_event[i](d->ext_opaque[i], event);
1881 }
1882
1883 static void mux_chr_update_read_handler(CharDriverState *chr)
1884 {
1885 MuxDriver *d = chr->opaque;
1886
1887 if (d->mux_cnt >= MAX_MUX) {
1888 fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
1889 return;
1890 }
1891 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
1892 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
1893 d->chr_read[d->mux_cnt] = chr->chr_read;
1894 d->chr_event[d->mux_cnt] = chr->chr_event;
1895 /* Fix up the real driver with mux routines */
1896 if (d->mux_cnt == 0) {
1897 qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
1898 mux_chr_event, chr);
1899 }
1900 chr->focus = d->mux_cnt;
1901 d->mux_cnt++;
1902 }
1903
1904 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
1905 {
1906 CharDriverState *chr;
1907 MuxDriver *d;
1908
1909 chr = qemu_mallocz(sizeof(CharDriverState));
1910 if (!chr)
1911 return NULL;
1912 d = qemu_mallocz(sizeof(MuxDriver));
1913 if (!d) {
1914 free(chr);
1915 return NULL;
1916 }
1917
1918 chr->opaque = d;
1919 d->drv = drv;
1920 chr->focus = -1;
1921 chr->chr_write = mux_chr_write;
1922 chr->chr_update_read_handler = mux_chr_update_read_handler;
1923 chr->chr_accept_input = mux_chr_accept_input;
1924 return chr;
1925 }
1926
1927
1928 #ifdef _WIN32
1929
1930 static void socket_cleanup(void)
1931 {
1932 WSACleanup();
1933 }
1934
1935 static int socket_init(void)
1936 {
1937 WSADATA Data;
1938 int ret, err;
1939
1940 ret = WSAStartup(MAKEWORD(2,2), &Data);
1941 if (ret != 0) {
1942 err = WSAGetLastError();
1943 fprintf(stderr, "WSAStartup: %d\n", err);
1944 return -1;
1945 }
1946 atexit(socket_cleanup);
1947 return 0;
1948 }
1949
1950 static int send_all(int fd, const uint8_t *buf, int len1)
1951 {
1952 int ret, len;
1953
1954 len = len1;
1955 while (len > 0) {
1956 ret = send(fd, buf, len, 0);
1957 if (ret < 0) {
1958 int errno;
1959 errno = WSAGetLastError();
1960 if (errno != WSAEWOULDBLOCK) {
1961 return -1;
1962 }
1963 } else if (ret == 0) {
1964 break;
1965 } else {
1966 buf += ret;
1967 len -= ret;
1968 }
1969 }
1970 return len1 - len;
1971 }
1972
1973 void socket_set_nonblock(int fd)
1974 {
1975 unsigned long opt = 1;
1976 ioctlsocket(fd, FIONBIO, &opt);
1977 }
1978
1979 #else
1980
1981 static int unix_write(int fd, const uint8_t *buf, int len1)
1982 {
1983 int ret, len;
1984
1985 len = len1;
1986 while (len > 0) {
1987 ret = write(fd, buf, len);
1988 if (ret < 0) {
1989 if (errno != EINTR && errno != EAGAIN)
1990 return -1;
1991 } else if (ret == 0) {
1992 break;
1993 } else {
1994 buf += ret;
1995 len -= ret;
1996 }
1997 }
1998 return len1 - len;
1999 }
2000
2001 static inline int send_all(int fd, const uint8_t *buf, int len1)
2002 {
2003 return unix_write(fd, buf, len1);
2004 }
2005
2006 void socket_set_nonblock(int fd)
2007 {
2008 fcntl(fd, F_SETFL, O_NONBLOCK);
2009 }
2010 #endif /* !_WIN32 */
2011
2012 #ifndef _WIN32
2013
2014 typedef struct {
2015 int fd_in, fd_out;
2016 int max_size;
2017 } FDCharDriver;
2018
2019 #define STDIO_MAX_CLIENTS 1
2020 static int stdio_nb_clients = 0;
2021
2022 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2023 {
2024 FDCharDriver *s = chr->opaque;
2025 return unix_write(s->fd_out, buf, len);
2026 }
2027
2028 static int fd_chr_read_poll(void *opaque)
2029 {
2030 CharDriverState *chr = opaque;
2031 FDCharDriver *s = chr->opaque;
2032
2033 s->max_size = qemu_chr_can_read(chr);
2034 return s->max_size;
2035 }
2036
2037 static void fd_chr_read(void *opaque)
2038 {
2039 CharDriverState *chr = opaque;
2040 FDCharDriver *s = chr->opaque;
2041 int size, len;
2042 uint8_t buf[1024];
2043
2044 len = sizeof(buf);
2045 if (len > s->max_size)
2046 len = s->max_size;
2047 if (len == 0)
2048 return;
2049 size = read(s->fd_in, buf, len);
2050 if (size == 0) {
2051 /* FD has been closed. Remove it from the active list. */
2052 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2053 return;
2054 }
2055 if (size > 0) {
2056 qemu_chr_read(chr, buf, size);
2057 }
2058 }
2059
2060 static void fd_chr_update_read_handler(CharDriverState *chr)
2061 {
2062 FDCharDriver *s = chr->opaque;
2063
2064 if (s->fd_in >= 0) {
2065 if (nographic && s->fd_in == 0) {
2066 } else {
2067 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2068 fd_chr_read, NULL, chr);
2069 }
2070 }
2071 }
2072
2073 /* open a character device to a unix fd */
2074 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2075 {
2076 CharDriverState *chr;
2077 FDCharDriver *s;
2078
2079 chr = qemu_mallocz(sizeof(CharDriverState));
2080 if (!chr)
2081 return NULL;
2082 s = qemu_mallocz(sizeof(FDCharDriver));
2083 if (!s) {
2084 free(chr);
2085 return NULL;
2086 }
2087 s->fd_in = fd_in;
2088 s->fd_out = fd_out;
2089 chr->opaque = s;
2090 chr->chr_write = fd_chr_write;
2091 chr->chr_update_read_handler = fd_chr_update_read_handler;
2092
2093 qemu_chr_reset(chr);
2094
2095 return chr;
2096 }
2097
2098 static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2099 {
2100 int fd_out;
2101
2102 TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2103 if (fd_out < 0)
2104 return NULL;
2105 return qemu_chr_open_fd(-1, fd_out);
2106 }
2107
2108 static CharDriverState *qemu_chr_open_pipe(const char *filename)
2109 {
2110 int fd_in, fd_out;
2111 char filename_in[256], filename_out[256];
2112
2113 snprintf(filename_in, 256, "%s.in", filename);
2114 snprintf(filename_out, 256, "%s.out", filename);
2115 TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2116 TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2117 if (fd_in < 0 || fd_out < 0) {
2118 if (fd_in >= 0)
2119 close(fd_in);
2120 if (fd_out >= 0)
2121 close(fd_out);
2122 TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2123 if (fd_in < 0)
2124 return NULL;
2125 }
2126 return qemu_chr_open_fd(fd_in, fd_out);
2127 }
2128
2129
2130 /* for STDIO, we handle the case where several clients use it
2131 (nographic mode) */
2132
2133 #define TERM_FIFO_MAX_SIZE 1
2134
2135 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2136 static int term_fifo_size;
2137
2138 static int stdio_read_poll(void *opaque)
2139 {
2140 CharDriverState *chr = opaque;
2141
2142 /* try to flush the queue if needed */
2143 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2144 qemu_chr_read(chr, term_fifo, 1);
2145 term_fifo_size = 0;
2146 }
2147 /* see if we can absorb more chars */
2148 if (term_fifo_size == 0)
2149 return 1;
2150 else
2151 return 0;
2152 }
2153
2154 static void stdio_read(void *opaque)
2155 {
2156 int size;
2157 uint8_t buf[1];
2158 CharDriverState *chr = opaque;
2159
2160 size = read(0, buf, 1);
2161 if (size == 0) {
2162 /* stdin has been closed. Remove it from the active list. */
2163 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2164 return;
2165 }
2166 if (size > 0) {
2167 if (qemu_chr_can_read(chr) > 0) {
2168 qemu_chr_read(chr, buf, 1);
2169 } else if (term_fifo_size == 0) {
2170 term_fifo[term_fifo_size++] = buf[0];
2171 }
2172 }
2173 }
2174
2175 /* init terminal so that we can grab keys */
2176 static struct termios oldtty;
2177 static int old_fd0_flags;
2178
2179 static void term_exit(void)
2180 {
2181 tcsetattr (0, TCSANOW, &oldtty);
2182 fcntl(0, F_SETFL, old_fd0_flags);
2183 }
2184
2185 static void term_init(void)
2186 {
2187 struct termios tty;
2188
2189 tcgetattr (0, &tty);
2190 oldtty = tty;
2191 old_fd0_flags = fcntl(0, F_GETFL);
2192
2193 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2194 |INLCR|IGNCR|ICRNL|IXON);
2195 tty.c_oflag |= OPOST;
2196 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2197 /* if graphical mode, we allow Ctrl-C handling */
2198 if (nographic)
2199 tty.c_lflag &= ~ISIG;
2200 tty.c_cflag &= ~(CSIZE|PARENB);
2201 tty.c_cflag |= CS8;
2202 tty.c_cc[VMIN] = 1;
2203 tty.c_cc[VTIME] = 0;
2204
2205 tcsetattr (0, TCSANOW, &tty);
2206
2207 atexit(term_exit);
2208
2209 fcntl(0, F_SETFL, O_NONBLOCK);
2210 }
2211
2212 static CharDriverState *qemu_chr_open_stdio(void)
2213 {
2214 CharDriverState *chr;
2215
2216 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2217 return NULL;
2218 chr = qemu_chr_open_fd(0, 1);
2219 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2220 stdio_nb_clients++;
2221 term_init();
2222
2223 return chr;
2224 }
2225
2226 #if defined(__linux__) || defined(__sun__)
2227 static CharDriverState *qemu_chr_open_pty(void)
2228 {
2229 struct termios tty;
2230 char slave_name[1024];
2231 int master_fd, slave_fd;
2232
2233 #if defined(__linux__)
2234 /* Not satisfying */
2235 if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
2236 return NULL;
2237 }
2238 #endif
2239
2240 /* Disabling local echo and line-buffered output */
2241 tcgetattr (master_fd, &tty);
2242 tty.c_lflag &= ~(ECHO|ICANON|ISIG);
2243 tty.c_cc[VMIN] = 1;
2244 tty.c_cc[VTIME] = 0;
2245 tcsetattr (master_fd, TCSAFLUSH, &tty);
2246
2247 fprintf(stderr, "char device redirected to %s\n", slave_name);
2248 return qemu_chr_open_fd(master_fd, master_fd);
2249 }
2250
2251 static void tty_serial_init(int fd, int speed,
2252 int parity, int data_bits, int stop_bits)
2253 {
2254 struct termios tty;
2255 speed_t spd;
2256
2257 #if 0
2258 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2259 speed, parity, data_bits, stop_bits);
2260 #endif
2261 tcgetattr (fd, &tty);
2262
2263 switch(speed) {
2264 case 50:
2265 spd = B50;
2266 break;
2267 case 75:
2268 spd = B75;
2269 break;
2270 case 300:
2271 spd = B300;
2272 break;
2273 case 600:
2274 spd = B600;
2275 break;
2276 case 1200:
2277 spd = B1200;
2278 break;
2279 case 2400:
2280 spd = B2400;
2281 break;
2282 case 4800:
2283 spd = B4800;
2284 break;
2285 case 9600:
2286 spd = B9600;
2287 break;
2288 case 19200:
2289 spd = B19200;
2290 break;
2291 case 38400:
2292 spd = B38400;
2293 break;
2294 case 57600:
2295 spd = B57600;
2296 break;
2297 default:
2298 case 115200:
2299 spd = B115200;
2300 break;
2301 }
2302
2303 cfsetispeed(&tty, spd);
2304 cfsetospeed(&tty, spd);
2305
2306 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2307 |INLCR|IGNCR|ICRNL|IXON);
2308 tty.c_oflag |= OPOST;
2309 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2310 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2311 switch(data_bits) {
2312 default:
2313 case 8:
2314 tty.c_cflag |= CS8;
2315 break;
2316 case 7:
2317 tty.c_cflag |= CS7;
2318 break;
2319 case 6:
2320 tty.c_cflag |= CS6;
2321 break;
2322 case 5:
2323 tty.c_cflag |= CS5;
2324 break;
2325 }
2326 switch(parity) {
2327 default:
2328 case 'N':
2329 break;
2330 case 'E':
2331 tty.c_cflag |= PARENB;
2332 break;
2333 case 'O':
2334 tty.c_cflag |= PARENB | PARODD;
2335 break;
2336 }
2337 if (stop_bits == 2)
2338 tty.c_cflag |= CSTOPB;
2339
2340 tcsetattr (fd, TCSANOW, &tty);
2341 }
2342
2343 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2344 {
2345 FDCharDriver *s = chr->opaque;
2346
2347 switch(cmd) {
2348 case CHR_IOCTL_SERIAL_SET_PARAMS:
2349 {
2350 QEMUSerialSetParams *ssp = arg;
2351 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2352 ssp->data_bits, ssp->stop_bits);
2353 }
2354 break;
2355 case CHR_IOCTL_SERIAL_SET_BREAK:
2356 {
2357 int enable = *(int *)arg;
2358 if (enable)
2359 tcsendbreak(s->fd_in, 1);
2360 }
2361 break;
2362 default:
2363 return -ENOTSUP;
2364 }
2365 return 0;
2366 }
2367
2368 static CharDriverState *qemu_chr_open_tty(const char *filename)
2369 {
2370 CharDriverState *chr;
2371 int fd;
2372
2373 TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2374 fcntl(fd, F_SETFL, O_NONBLOCK);
2375 tty_serial_init(fd, 115200, 'N', 8, 1);
2376 chr = qemu_chr_open_fd(fd, fd);
2377 if (!chr) {
2378 close(fd);
2379 return NULL;
2380 }
2381 chr->chr_ioctl = tty_serial_ioctl;
2382 qemu_chr_reset(chr);
2383 return chr;
2384 }
2385 #else /* ! __linux__ && ! __sun__ */
2386 static CharDriverState *qemu_chr_open_pty(void)
2387 {
2388 return NULL;
2389 }
2390 #endif /* __linux__ || __sun__ */
2391
2392 #if defined(__linux__)
2393 typedef struct {
2394 int fd;
2395 int mode;
2396 } ParallelCharDriver;
2397
2398 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2399 {
2400 if (s->mode != mode) {
2401 int m = mode;
2402 if (ioctl(s->fd, PPSETMODE, &m) < 0)
2403 return 0;
2404 s->mode = mode;
2405 }
2406 return 1;
2407 }
2408
2409 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2410 {
2411 ParallelCharDriver *drv = chr->opaque;
2412 int fd = drv->fd;
2413 uint8_t b;
2414
2415 switch(cmd) {
2416 case CHR_IOCTL_PP_READ_DATA:
2417 if (ioctl(fd, PPRDATA, &b) < 0)
2418 return -ENOTSUP;
2419 *(uint8_t *)arg = b;
2420 break;
2421 case CHR_IOCTL_PP_WRITE_DATA:
2422 b = *(uint8_t *)arg;
2423 if (ioctl(fd, PPWDATA, &b) < 0)
2424 return -ENOTSUP;
2425 break;
2426 case CHR_IOCTL_PP_READ_CONTROL:
2427 if (ioctl(fd, PPRCONTROL, &b) < 0)
2428 return -ENOTSUP;
2429 /* Linux gives only the lowest bits, and no way to know data
2430 direction! For better compatibility set the fixed upper
2431 bits. */
2432 *(uint8_t *)arg = b | 0xc0;
2433 break;
2434 case CHR_IOCTL_PP_WRITE_CONTROL:
2435 b = *(uint8_t *)arg;
2436 if (ioctl(fd, PPWCONTROL, &b) < 0)
2437 return -ENOTSUP;
2438 break;
2439 case CHR_IOCTL_PP_READ_STATUS:
2440 if (ioctl(fd, PPRSTATUS, &b) < 0)
2441 return -ENOTSUP;
2442 *(uint8_t *)arg = b;
2443 break;
2444 case CHR_IOCTL_PP_EPP_READ_ADDR:
2445 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2446 struct ParallelIOArg *parg = arg;
2447 int n = read(fd, parg->buffer, parg->count);
2448 if (n != parg->count) {
2449 return -EIO;
2450 }
2451 }
2452 break;
2453 case CHR_IOCTL_PP_EPP_READ:
2454 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2455 struct ParallelIOArg *parg = arg;
2456 int n = read(fd, parg->buffer, parg->count);
2457 if (n != parg->count) {
2458 return -EIO;
2459 }
2460 }
2461 break;
2462 case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2463 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2464 struct ParallelIOArg *parg = arg;
2465 int n = write(fd, parg->buffer, parg->count);
2466 if (n != parg->count) {
2467 return -EIO;
2468 }
2469 }
2470 break;
2471 case CHR_IOCTL_PP_EPP_WRITE:
2472 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2473 struct ParallelIOArg *parg = arg;
2474 int n = write(fd, parg->buffer, parg->count);
2475 if (n != parg->count) {
2476 return -EIO;
2477 }
2478 }
2479 break;
2480 default:
2481 return -ENOTSUP;
2482 }
2483 return 0;
2484 }
2485
2486 static void pp_close(CharDriverState *chr)
2487 {
2488 ParallelCharDriver *drv = chr->opaque;
2489 int fd = drv->fd;
2490
2491 pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2492 ioctl(fd, PPRELEASE);
2493 close(fd);
2494 qemu_free(drv);
2495 }
2496
2497 static CharDriverState *qemu_chr_open_pp(const char *filename)
2498 {
2499 CharDriverState *chr;
2500 ParallelCharDriver *drv;
2501 int fd;
2502
2503 TFR(fd = open(filename, O_RDWR));
2504 if (fd < 0)
2505 return NULL;
2506
2507 if (ioctl(fd, PPCLAIM) < 0) {
2508 close(fd);
2509 return NULL;
2510 }
2511
2512 drv = qemu_mallocz(sizeof(ParallelCharDriver));
2513 if (!drv) {
2514 close(fd);
2515 return NULL;
2516 }
2517 drv->fd = fd;
2518 drv->mode = IEEE1284_MODE_COMPAT;
2519
2520 chr = qemu_mallocz(sizeof(CharDriverState));
2521 if (!chr) {
2522 qemu_free(drv);
2523 close(fd);
2524 return NULL;
2525 }
2526 chr->chr_write = null_chr_write;
2527 chr->chr_ioctl = pp_ioctl;
2528 chr->chr_close = pp_close;
2529 chr->opaque = drv;
2530
2531 qemu_chr_reset(chr);
2532
2533 return chr;
2534 }
2535 #endif /* __linux__ */
2536
2537 #else /* _WIN32 */
2538
2539 typedef struct {
2540 int max_size;
2541 HANDLE hcom, hrecv, hsend;
2542 OVERLAPPED orecv, osend;
2543 BOOL fpipe;
2544 DWORD len;
2545 } WinCharState;
2546
2547 #define NSENDBUF 2048
2548 #define NRECVBUF 2048
2549 #define MAXCONNECT 1
2550 #define NTIMEOUT 5000
2551
2552 static int win_chr_poll(void *opaque);
2553 static int win_chr_pipe_poll(void *opaque);
2554
2555 static void win_chr_close(CharDriverState *chr)
2556 {
2557 WinCharState *s = chr->opaque;
2558
2559 if (s->hsend) {
2560 CloseHandle(s->hsend);
2561 s->hsend = NULL;
2562 }
2563 if (s->hrecv) {
2564 CloseHandle(s->hrecv);
2565 s->hrecv = NULL;
2566 }
2567 if (s->hcom) {
2568 CloseHandle(s->hcom);
2569 s->hcom = NULL;
2570 }
2571 if (s->fpipe)
2572 qemu_del_polling_cb(win_chr_pipe_poll, chr);
2573 else
2574 qemu_del_polling_cb(win_chr_poll, chr);
2575 }
2576
2577 static int win_chr_init(CharDriverState *chr, const char *filename)
2578 {
2579 WinCharState *s = chr->opaque;
2580 COMMCONFIG comcfg;
2581 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2582 COMSTAT comstat;
2583 DWORD size;
2584 DWORD err;
2585
2586 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2587 if (!s->hsend) {
2588 fprintf(stderr, "Failed CreateEvent\n");
2589 goto fail;
2590 }
2591 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2592 if (!s->hrecv) {
2593 fprintf(stderr, "Failed CreateEvent\n");
2594 goto fail;
2595 }
2596
2597 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2598 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2599 if (s->hcom == INVALID_HANDLE_VALUE) {
2600 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2601 s->hcom = NULL;
2602 goto fail;
2603 }
2604
2605 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2606 fprintf(stderr, "Failed SetupComm\n");
2607 goto fail;
2608 }
2609
2610 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2611 size = sizeof(COMMCONFIG);
2612 GetDefaultCommConfig(filename, &comcfg, &size);
2613 comcfg.dcb.DCBlength = sizeof(DCB);
2614 CommConfigDialog(filename, NULL, &comcfg);
2615
2616 if (!SetCommState(s->hcom, &comcfg.dcb)) {
2617 fprintf(stderr, "Failed SetCommState\n");
2618 goto fail;
2619 }
2620
2621 if (!SetCommMask(s->hcom, EV_ERR)) {
2622 fprintf(stderr, "Failed SetCommMask\n");
2623 goto fail;
2624 }
2625
2626 cto.ReadIntervalTimeout = MAXDWORD;
2627 if (!SetCommTimeouts(s->hcom, &cto)) {
2628 fprintf(stderr, "Failed SetCommTimeouts\n");
2629 goto fail;
2630 }
2631
2632 if (!ClearCommError(s->hcom, &err, &comstat)) {
2633 fprintf(stderr, "Failed ClearCommError\n");
2634 goto fail;
2635 }
2636 qemu_add_polling_cb(win_chr_poll, chr);
2637 return 0;
2638
2639 fail:
2640 win_chr_close(chr);
2641 return -1;
2642 }
2643
2644 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2645 {
2646 WinCharState *s = chr->opaque;
2647 DWORD len, ret, size, err;
2648
2649 len = len1;
2650 ZeroMemory(&s->osend, sizeof(s->osend));
2651 s->osend.hEvent = s->hsend;
2652 while (len > 0) {
2653 if (s->hsend)
2654 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2655 else
2656 ret = WriteFile(s->hcom, buf, len, &size, NULL);
2657 if (!ret) {
2658 err = GetLastError();
2659 if (err == ERROR_IO_PENDING) {
2660 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2661 if (ret) {
2662 buf += size;
2663 len -= size;
2664 } else {
2665 break;
2666 }
2667 } else {
2668 break;
2669 }
2670 } else {
2671 buf += size;
2672 len -= size;
2673 }
2674 }
2675 return len1 - len;
2676 }
2677
2678 static int win_chr_read_poll(CharDriverState *chr)
2679 {
2680 WinCharState *s = chr->opaque;
2681
2682 s->max_size = qemu_chr_can_read(chr);
2683 return s->max_size;
2684 }
2685
2686 static void win_chr_readfile(CharDriverState *chr)
2687 {
2688 WinCharState *s = chr->opaque;
2689 int ret, err;
2690 uint8_t buf[1024];
2691 DWORD size;
2692
2693 ZeroMemory(&s->orecv, sizeof(s->orecv));
2694 s->orecv.hEvent = s->hrecv;
2695 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2696 if (!ret) {
2697 err = GetLastError();
2698 if (err == ERROR_IO_PENDING) {
2699 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2700 }
2701 }
2702
2703 if (size > 0) {
2704 qemu_chr_read(chr, buf, size);
2705 }
2706 }
2707
2708 static void win_chr_read(CharDriverState *chr)
2709 {
2710 WinCharState *s = chr->opaque;
2711
2712 if (s->len > s->max_size)
2713 s->len = s->max_size;
2714 if (s->len == 0)
2715 return;
2716
2717 win_chr_readfile(chr);
2718 }
2719
2720 static int win_chr_poll(void *opaque)
2721 {
2722 CharDriverState *chr = opaque;
2723 WinCharState *s = chr->opaque;
2724 COMSTAT status;
2725 DWORD comerr;
2726
2727 ClearCommError(s->hcom, &comerr, &status);
2728 if (status.cbInQue > 0) {
2729 s->len = status.cbInQue;
2730 win_chr_read_poll(chr);
2731 win_chr_read(chr);
2732 return 1;
2733 }
2734 return 0;
2735 }
2736
2737 static CharDriverState *qemu_chr_open_win(const char *filename)
2738 {
2739 CharDriverState *chr;
2740 WinCharState *s;
2741
2742 chr = qemu_mallocz(sizeof(CharDriverState));
2743 if (!chr)
2744 return NULL;
2745 s = qemu_mallocz(sizeof(WinCharState));
2746 if (!s) {
2747 free(chr);
2748 return NULL;
2749 }
2750 chr->opaque = s;
2751 chr->chr_write = win_chr_write;
2752 chr->chr_close = win_chr_close;
2753
2754 if (win_chr_init(chr, filename) < 0) {
2755 free(s);
2756 free(chr);
2757 return NULL;
2758 }
2759 qemu_chr_reset(chr);
2760 return chr;
2761 }
2762
2763 static int win_chr_pipe_poll(void *opaque)
2764 {
2765 CharDriverState *chr = opaque;
2766 WinCharState *s = chr->opaque;
2767 DWORD size;
2768
2769 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2770 if (size > 0) {
2771 s->len = size;
2772 win_chr_read_poll(chr);
2773 win_chr_read(chr);
2774 return 1;
2775 }
2776 return 0;
2777 }
2778
2779 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2780 {
2781 WinCharState *s = chr->opaque;
2782 OVERLAPPED ov;
2783 int ret;
2784 DWORD size;
2785 char openname[256];
2786
2787 s->fpipe = TRUE;
2788
2789 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2790 if (!s->hsend) {
2791 fprintf(stderr, "Failed CreateEvent\n");
2792 goto fail;
2793 }
2794 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2795 if (!s->hrecv) {
2796 fprintf(stderr, "Failed CreateEvent\n");
2797 goto fail;
2798 }
2799
2800 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2801 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2802 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2803 PIPE_WAIT,
2804 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2805 if (s->hcom == INVALID_HANDLE_VALUE) {
2806 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2807 s->hcom = NULL;
2808 goto fail;
2809 }
2810
2811 ZeroMemory(&ov, sizeof(ov));
2812 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2813 ret = ConnectNamedPipe(s->hcom, &ov);
2814 if (ret) {
2815 fprintf(stderr, "Failed ConnectNamedPipe\n");
2816 goto fail;
2817 }
2818
2819 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2820 if (!ret) {
2821 fprintf(stderr, "Failed GetOverlappedResult\n");
2822 if (ov.hEvent) {
2823 CloseHandle(ov.hEvent);
2824 ov.hEvent = NULL;
2825 }
2826 goto fail;
2827 }
2828
2829 if (ov.hEvent) {
2830 CloseHandle(ov.hEvent);
2831 ov.hEvent = NULL;
2832 }
2833 qemu_add_polling_cb(win_chr_pipe_poll, chr);
2834 return 0;
2835
2836 fail:
2837 win_chr_close(chr);
2838 return -1;
2839 }
2840
2841
2842 static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2843 {
2844 CharDriverState *chr;
2845 WinCharState *s;
2846
2847 chr = qemu_mallocz(sizeof(CharDriverState));
2848 if (!chr)
2849 return NULL;
2850 s = qemu_mallocz(sizeof(WinCharState));
2851 if (!s) {
2852 free(chr);
2853 return NULL;
2854 }
2855 chr->opaque = s;
2856 chr->chr_write = win_chr_write;
2857 chr->chr_close = win_chr_close;
2858
2859 if (win_chr_pipe_init(chr, filename) < 0) {
2860 free(s);
2861 free(chr);
2862 return NULL;
2863 }
2864 qemu_chr_reset(chr);
2865 return chr;
2866 }
2867
2868 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2869 {
2870 CharDriverState *chr;
2871 WinCharState *s;
2872
2873 chr = qemu_mallocz(sizeof(CharDriverState));
2874 if (!chr)
2875 return NULL;
2876 s = qemu_mallocz(sizeof(WinCharState));
2877 if (!s) {
2878 free(chr);
2879 return NULL;
2880 }
2881 s->hcom = fd_out;
2882 chr->opaque = s;
2883 chr->chr_write = win_chr_write;
2884 qemu_chr_reset(chr);
2885 return chr;
2886 }
2887
2888 static CharDriverState *qemu_chr_open_win_con(const char *filename)
2889 {
2890 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
2891 }
2892
2893 static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2894 {
2895 HANDLE fd_out;
2896
2897 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2898 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2899 if (fd_out == INVALID_HANDLE_VALUE)
2900 return NULL;
2901
2902 return qemu_chr_open_win_file(fd_out);
2903 }
2904 #endif /* !_WIN32 */
2905
2906 /***********************************************************/
2907 /* UDP Net console */
2908
2909 typedef struct {
2910 int fd;
2911 struct sockaddr_in daddr;
2912 uint8_t buf[1024];
2913 int bufcnt;
2914 int bufptr;
2915 int max_size;
2916 } NetCharDriver;
2917
2918 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2919 {
2920 NetCharDriver *s = chr->opaque;
2921
2922 return sendto(s->fd, buf, len, 0,
2923 (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2924 }
2925
2926 static int udp_chr_read_poll(void *opaque)
2927 {
2928 CharDriverState *chr = opaque;
2929 NetCharDriver *s = chr->opaque;
2930
2931 s->max_size = qemu_chr_can_read(chr);
2932
2933 /* If there were any stray characters in the queue process them
2934 * first
2935 */
2936 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2937 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2938 s->bufptr++;
2939 s->max_size = qemu_chr_can_read(chr);
2940 }
2941 return s->max_size;
2942 }
2943
2944 static void udp_chr_read(void *opaque)
2945 {
2946 CharDriverState *chr = opaque;
2947 NetCharDriver *s = chr->opaque;
2948
2949 if (s->max_size == 0)
2950 return;
2951 s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2952 s->bufptr = s->bufcnt;
2953 if (s->bufcnt <= 0)
2954 return;
2955
2956 s->bufptr = 0;
2957 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2958 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2959 s->bufptr++;
2960 s->max_size = qemu_chr_can_read(chr);
2961 }
2962 }
2963
2964 static void udp_chr_update_read_handler(CharDriverState *chr)
2965 {
2966 NetCharDriver *s = chr->opaque;
2967
2968 if (s->fd >= 0) {
2969 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2970 udp_chr_read, NULL, chr);
2971 }
2972 }
2973
2974 #ifndef _WIN32
2975 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
2976 #endif
2977 int parse_host_src_port(struct sockaddr_in *haddr,
2978 struct sockaddr_in *saddr,
2979 const char *str);
2980
2981 static CharDriverState *qemu_chr_open_udp(const char *def)
2982 {
2983 CharDriverState *chr = NULL;
2984 NetCharDriver *s = NULL;
2985 int fd = -1;
2986 struct sockaddr_in saddr;
2987
2988 chr = qemu_mallocz(sizeof(CharDriverState));
2989 if (!chr)
2990 goto return_err;
2991 s = qemu_mallocz(sizeof(NetCharDriver));
2992 if (!s)
2993 goto return_err;
2994
2995 fd = socket(PF_INET, SOCK_DGRAM, 0);
2996 if (fd < 0) {
2997 perror("socket(PF_INET, SOCK_DGRAM)");
2998 goto return_err;
2999 }
3000
3001 if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3002 printf("Could not parse: %s\n", def);
3003 goto return_err;
3004 }
3005
3006 if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3007 {
3008 perror("bind");
3009 goto return_err;
3010 }
3011
3012 s->fd = fd;
3013 s->bufcnt = 0;
3014 s->bufptr = 0;
3015 chr->opaque = s;
3016 chr->chr_write = udp_chr_write;
3017 chr->chr_update_read_handler = udp_chr_update_read_handler;
3018 return chr;
3019
3020 return_err:
3021 if (chr)
3022 free(chr);
3023 if (s)
3024 free(s);
3025 if (fd >= 0)
3026 closesocket(fd);
3027 return NULL;
3028 }
3029
3030 /***********************************************************/
3031 /* TCP Net console */
3032
3033 typedef struct {
3034 int fd, listen_fd;
3035 int connected;
3036 int max_size;
3037 int do_telnetopt;
3038 int do_nodelay;
3039 int is_unix;
3040 } TCPCharDriver;
3041
3042 static void tcp_chr_accept(void *opaque);
3043
3044 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3045 {
3046 TCPCharDriver *s = chr->opaque;
3047 if (s->connected) {
3048 return send_all(s->fd, buf, len);
3049 } else {
3050 /* XXX: indicate an error ? */
3051 return len;
3052 }
3053 }
3054
3055 static int tcp_chr_read_poll(void *opaque)
3056 {
3057 CharDriverState *chr = opaque;
3058 TCPCharDriver *s = chr->opaque;
3059 if (!s->connected)
3060 return 0;
3061 s->max_size = qemu_chr_can_read(chr);
3062 return s->max_size;
3063 }
3064
3065 #define IAC 255
3066 #define IAC_BREAK 243
3067 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3068 TCPCharDriver *s,
3069 uint8_t *buf, int *size)
3070 {
3071 /* Handle any telnet client's basic IAC options to satisfy char by
3072 * char mode with no echo. All IAC options will be removed from
3073 * the buf and the do_telnetopt variable will be used to track the
3074 * state of the width of the IAC information.
3075 *
3076 * IAC commands come in sets of 3 bytes with the exception of the
3077 * "IAC BREAK" command and the double IAC.
3078 */
3079
3080 int i;
3081 int j = 0;
3082
3083 for (i = 0; i < *size; i++) {
3084 if (s->do_telnetopt > 1) {
3085 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3086 /* Double IAC means send an IAC */
3087 if (j != i)
3088 buf[j] = buf[i];
3089 j++;
3090 s->do_telnetopt = 1;
3091 } else {
3092 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3093 /* Handle IAC break commands by sending a serial break */
3094 qemu_chr_event(chr, CHR_EVENT_BREAK);
3095 s->do_telnetopt++;
3096 }
3097 s->do_telnetopt++;
3098 }
3099 if (s->do_telnetopt >= 4) {
3100 s->do_telnetopt = 1;
3101 }
3102 } else {
3103 if ((unsigned char)buf[i] == IAC) {
3104 s->do_telnetopt = 2;
3105 } else {
3106 if (j != i)
3107 buf[j] = buf[i];
3108 j++;
3109 }
3110 }
3111 }
3112 *size = j;
3113 }
3114
3115 static void tcp_chr_read(void *opaque)
3116 {
3117 CharDriverState *chr = opaque;
3118 TCPCharDriver *s = chr->opaque;
3119 uint8_t buf[1024];
3120 int len, size;
3121
3122 if (!s->connected || s->max_size <= 0)
3123 return;
3124 len = sizeof(buf);
3125 if (len > s->max_size)
3126 len = s->max_size;
3127 size = recv(s->fd, buf, len, 0);
3128 if (size == 0) {
3129 /* connection closed */
3130 s->connected = 0;
3131 if (s->listen_fd >= 0) {
3132 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3133 }
3134 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3135 closesocket(s->fd);
3136 s->fd = -1;
3137 } else if (size > 0) {
3138 if (s->do_telnetopt)
3139 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3140 if (size > 0)
3141 qemu_chr_read(chr, buf, size);
3142 }
3143 }
3144
3145 static void tcp_chr_connect(void *opaque)
3146 {
3147 CharDriverState *chr = opaque;
3148 TCPCharDriver *s = chr->opaque;
3149
3150 s->connected = 1;
3151 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3152 tcp_chr_read, NULL, chr);
3153 qemu_chr_reset(chr);
3154 }
3155
3156 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3157 static void tcp_chr_telnet_init(int fd)
3158 {
3159 char buf[3];
3160 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3161 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3162 send(fd, (char *)buf, 3, 0);
3163 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3164 send(fd, (char *)buf, 3, 0);
3165 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3166 send(fd, (char *)buf, 3, 0);
3167 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3168 send(fd, (char *)buf, 3, 0);
3169 }
3170
3171 static void socket_set_nodelay(int fd)
3172 {
3173 int val = 1;
3174 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3175 }
3176
3177 static void tcp_chr_accept(void *opaque)
3178 {
3179 CharDriverState *chr = opaque;
3180 TCPCharDriver *s = chr->opaque;
3181 struct sockaddr_in saddr;
3182 #ifndef _WIN32
3183 struct sockaddr_un uaddr;
3184 #endif
3185 struct sockaddr *addr;
3186 socklen_t len;
3187 int fd;
3188
3189 for(;;) {
3190 #ifndef _WIN32
3191 if (s->is_unix) {
3192 len = sizeof(uaddr);
3193 addr = (struct sockaddr *)&uaddr;
3194 } else
3195 #endif
3196 {
3197 len = sizeof(saddr);
3198 addr = (struct sockaddr *)&saddr;
3199 }
3200 fd = accept(s->listen_fd, addr, &len);
3201 if (fd < 0 && errno != EINTR) {
3202 return;
3203 } else if (fd >= 0) {
3204 if (s->do_telnetopt)
3205 tcp_chr_telnet_init(fd);
3206 break;
3207 }
3208 }
3209 socket_set_nonblock(fd);
3210 if (s->do_nodelay)
3211 socket_set_nodelay(fd);
3212 s->fd = fd;
3213 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3214 tcp_chr_connect(chr);
3215 }
3216
3217 static void tcp_chr_close(CharDriverState *chr)
3218 {
3219 TCPCharDriver *s = chr->opaque;
3220 if (s->fd >= 0)
3221 closesocket(s->fd);
3222 if (s->listen_fd >= 0)
3223 closesocket(s->listen_fd);
3224 qemu_free(s);
3225 }
3226
3227 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3228 int is_telnet,
3229 int is_unix)
3230 {
3231 CharDriverState *chr = NULL;
3232 TCPCharDriver *s = NULL;
3233 int fd = -1, ret, err, val;
3234 int is_listen = 0;
3235 int is_waitconnect = 1;
3236 int do_nodelay = 0;
3237 const char *ptr;
3238 struct sockaddr_in saddr;
3239 #ifndef _WIN32
3240 struct sockaddr_un uaddr;
3241 #endif
3242 struct sockaddr *addr;
3243 socklen_t addrlen;
3244
3245 #ifndef _WIN32
3246 if (is_unix) {
3247 addr = (struct sockaddr *)&uaddr;
3248 addrlen = sizeof(uaddr);
3249 if (parse_unix_path(&uaddr, host_str) < 0)
3250 goto fail;
3251 } else
3252 #endif
3253 {
3254 addr = (struct sockaddr *)&saddr;
3255 addrlen = sizeof(saddr);
3256 if (parse_host_port(&saddr, host_str) < 0)
3257 goto fail;
3258 }
3259
3260 ptr = host_str;
3261 while((ptr = strchr(ptr,','))) {
3262 ptr++;
3263 if (!strncmp(ptr,"server",6)) {
3264 is_listen = 1;
3265 } else if (!strncmp(ptr,"nowait",6)) {
3266 is_waitconnect = 0;
3267 } else if (!strncmp(ptr,"nodelay",6)) {
3268 do_nodelay = 1;
3269 } else {
3270 printf("Unknown option: %s\n", ptr);
3271 goto fail;
3272 }
3273 }
3274 if (!is_listen)
3275 is_waitconnect = 0;
3276
3277 chr = qemu_mallocz(sizeof(CharDriverState));
3278 if (!chr)
3279 goto fail;
3280 s = qemu_mallocz(sizeof(TCPCharDriver));
3281 if (!s)
3282 goto fail;
3283
3284 #ifndef _WIN32
3285 if (is_unix)
3286 fd = socket(PF_UNIX, SOCK_STREAM, 0);
3287 else
3288 #endif
3289 fd = socket(PF_INET, SOCK_STREAM, 0);
3290
3291 if (fd < 0)
3292 goto fail;
3293
3294 if (!is_waitconnect)
3295 socket_set_nonblock(fd);
3296
3297 s->connected = 0;
3298 s->fd = -1;
3299 s->listen_fd = -1;
3300 s->is_unix = is_unix;
3301 s->do_nodelay = do_nodelay && !is_unix;
3302
3303 chr->opaque = s;
3304 chr->chr_write = tcp_chr_write;
3305 chr->chr_close = tcp_chr_close;
3306
3307 if (is_listen) {
3308 /* allow fast reuse */
3309 #ifndef _WIN32
3310 if (is_unix) {
3311 char path[109];
3312 strncpy(path, uaddr.sun_path, 108);
3313 path[108] = 0;
3314 unlink(path);
3315 } else
3316 #endif
3317 {
3318 val = 1;
3319 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3320 }
3321
3322 ret = bind(fd, addr, addrlen);
3323 if (ret < 0)
3324 goto fail;
3325
3326 ret = listen(fd, 0);
3327 if (ret < 0)
3328 goto fail;
3329
3330 s->listen_fd = fd;
3331 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3332 if (is_telnet)
3333 s->do_telnetopt = 1;
3334 } else {
3335 for(;;) {
3336 ret = connect(fd, addr, addrlen);
3337 if (ret < 0) {
3338 err = socket_error();
3339 if (err == EINTR || err == EWOULDBLOCK) {
3340 } else if (err == EINPROGRESS) {
3341 break;
3342 #ifdef _WIN32
3343 } else if (err == WSAEALREADY) {
3344 break;
3345 #endif
3346 } else {
3347 goto fail;
3348 }
3349 } else {
3350 s->connected = 1;
3351 break;
3352 }
3353 }
3354 s->fd = fd;
3355 socket_set_nodelay(fd);
3356 if (s->connected)
3357 tcp_chr_connect(chr);
3358 else
3359 qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3360 }
3361
3362 if (is_listen && is_waitconnect) {
3363 printf("QEMU waiting for connection on: %s\n", host_str);
3364 tcp_chr_accept(chr);
3365 socket_set_nonblock(s->listen_fd);
3366 }
3367
3368 return chr;
3369 fail:
3370 if (fd >= 0)
3371 closesocket(fd);
3372 qemu_free(s);
3373 qemu_free(chr);
3374 return NULL;
3375 }
3376
3377 CharDriverState *qemu_chr_open(const char *filename)
3378 {
3379 const char *p;
3380
3381 if (!strcmp(filename, "vc")) {
3382 return text_console_init(&display_state, 0);
3383 } else if (strstart(filename, "vc:", &p)) {
3384 return text_console_init(&display_state, p);
3385 } else if (!strcmp(filename, "null")) {
3386 return qemu_chr_open_null();
3387 } else
3388 if (strstart(filename, "tcp:", &p)) {
3389 return qemu_chr_open_tcp(p, 0, 0);
3390 } else
3391 if (strstart(filename, "telnet:", &p)) {
3392 return qemu_chr_open_tcp(p, 1, 0);
3393 } else
3394 if (strstart(filename, "udp:", &p)) {
3395 return qemu_chr_open_udp(p);
3396 } else
3397 if (strstart(filename, "mon:", &p)) {
3398 CharDriverState *drv = qemu_chr_open(p);
3399 if (drv) {
3400 drv = qemu_chr_open_mux(drv);
3401 monitor_init(drv, !nographic);
3402 return drv;
3403 }
3404 printf("Unable to open driver: %s\n", p);
3405 return 0;
3406 } else
3407 #ifndef _WIN32
3408 if (strstart(filename, "unix:", &p)) {
3409 return qemu_chr_open_tcp(p, 0, 1);
3410 } else if (strstart(filename, "file:", &p)) {
3411 return qemu_chr_open_file_out(p);
3412 } else if (strstart(filename, "pipe:", &p)) {
3413 return qemu_chr_open_pipe(p);
3414 } else if (!strcmp(filename, "pty")) {
3415 return qemu_chr_open_pty();
3416 } else if (!strcmp(filename, "stdio")) {
3417 return qemu_chr_open_stdio();
3418 } else
3419 #if defined(__linux__)
3420 if (strstart(filename, "/dev/parport", NULL)) {
3421 return qemu_chr_open_pp(filename);
3422 } else
3423 #endif
3424 #if defined(__linux__) || defined(__sun__)
3425 if (strstart(filename, "/dev/", NULL)) {
3426 return qemu_chr_open_tty(filename);
3427 } else
3428 #endif
3429 #else /* !_WIN32 */
3430 if (strstart(filename, "COM", NULL)) {
3431 return qemu_chr_open_win(filename);
3432 } else
3433 if (strstart(filename, "pipe:", &p)) {
3434 return qemu_chr_open_win_pipe(p);
3435 } else
3436 if (strstart(filename, "con:", NULL)) {
3437 return qemu_chr_open_win_con(filename);
3438 } else
3439 if (strstart(filename, "file:", &p)) {
3440 return qemu_chr_open_win_file_out(p);
3441 }
3442 #endif
3443 {
3444 return NULL;
3445 }
3446 }
3447
3448 void qemu_chr_close(CharDriverState *chr)
3449 {
3450 if (chr->chr_close)
3451 chr->chr_close(chr);
3452 }
3453
3454 /***********************************************************/
3455 /* network device redirectors */
3456
3457 __attribute__ (( unused ))
3458 static void hex_dump(FILE *f, const uint8_t *buf, int size)
3459 {
3460 int len, i, j, c;
3461
3462 for(i=0;i<size;i+=16) {
3463 len = size - i;
3464 if (len > 16)
3465 len = 16;
3466 fprintf(f, "%08x ", i);
3467 for(j=0;j<16;j++) {
3468 if (j < len)
3469 fprintf(f, " %02x", buf[i+j]);
3470 else
3471 fprintf(f, " ");
3472 }
3473 fprintf(f, " ");
3474 for(j=0;j<len;j++) {
3475 c = buf[i+j];
3476 if (c < ' ' || c > '~')
3477 c = '.';
3478 fprintf(f, "%c", c);
3479 }
3480 fprintf(f, "\n");
3481 }
3482 }
3483
3484 static int parse_macaddr(uint8_t *macaddr, const char *p)
3485 {
3486 int i;
3487 char *last_char;
3488 long int offset;
3489
3490 errno = 0;
3491 offset = strtol(p, &last_char, 0);
3492 if (0 == errno && '\0' == *last_char &&
3493 offset >= 0 && offset <= 0xFFFFFF) {
3494 macaddr[3] = (offset & 0xFF0000) >> 16;
3495 macaddr[4] = (offset & 0xFF00) >> 8;
3496 macaddr[5] = offset & 0xFF;
3497 return 0;
3498 } else {
3499 for(i = 0; i < 6; i++) {
3500 macaddr[i] = strtol(p, (char **)&p, 16);
3501 if (i == 5) {
3502 if (*p != '\0')
3503 return -1;
3504 } else {
3505 if (*p != ':' && *p != '-')
3506 return -1;
3507 p++;
3508 }
3509 }
3510 return 0;
3511 }
3512
3513 return -1;
3514 }
3515
3516 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3517 {
3518 const char *p, *p1;
3519 int len;
3520 p = *pp;
3521 p1 = strchr(p, sep);
3522 if (!p1)
3523 return -1;
3524 len = p1 - p;
3525 p1++;
3526 if (buf_size > 0) {
3527 if (len > buf_size - 1)
3528 len = buf_size - 1;
3529 memcpy(buf, p, len);
3530 buf[len] = '\0';
3531 }
3532 *pp = p1;
3533 return 0;
3534 }
3535
3536 int parse_host_src_port(struct sockaddr_in *haddr,
3537 struct sockaddr_in *saddr,
3538 const char *input_str)
3539 {
3540 char *str = strdup(input_str);
3541 char *host_str = str;
3542 char *src_str;
3543 char *ptr;
3544
3545 /*
3546 * Chop off any extra arguments at the end of the string which
3547 * would start with a comma, then fill in the src port information
3548 * if it was provided else use the "any address" and "any port".
3549 */
3550 if ((ptr = strchr(str,',')))
3551 *ptr = '\0';
3552
3553 if ((src_str = strchr(input_str,'@'))) {
3554 *src_str = '\0';
3555 src_str++;
3556 }
3557
3558 if (parse_host_port(haddr, host_str) < 0)
3559 goto fail;
3560
3561 if (!src_str || *src_str == '\0')
3562 src_str = ":0";
3563
3564 if (parse_host_port(saddr, src_str) < 0)
3565 goto fail;
3566
3567 free(str);
3568 return(0);
3569
3570 fail:
3571 free(str);
3572 return -1;
3573 }
3574
3575 int parse_host_port(struct sockaddr_in *saddr, const char *str)
3576 {
3577 char buf[512];
3578 struct hostent *he;
3579 const char *p, *r;
3580 int port;
3581
3582 p = str;
3583 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3584 return -1;
3585 saddr->sin_family = AF_INET;
3586 if (buf[0] == '\0') {
3587 saddr->sin_addr.s_addr = 0;
3588 } else {
3589 if (isdigit(buf[0])) {
3590 if (!inet_aton(buf, &saddr->sin_addr))
3591 return -1;
3592 } else {
3593 if ((he = gethostbyname(buf)) == NULL)
3594 return - 1;
3595 saddr->sin_addr = *(struct in_addr *)he->h_addr;
3596 }
3597 }
3598 port = strtol(p, (char **)&r, 0);
3599 if (r == p)
3600 return -1;
3601 saddr->sin_port = htons(port);
3602 return 0;
3603 }
3604
3605 #ifndef _WIN32
3606 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3607 {
3608 const char *p;
3609 int len;
3610
3611 len = MIN(108, strlen(str));
3612 p = strchr(str, ',');
3613 if (p)
3614 len = MIN(len, p - str);
3615
3616 memset(uaddr, 0, sizeof(*uaddr));
3617
3618 uaddr->sun_family = AF_UNIX;
3619 memcpy(uaddr->sun_path, str, len);
3620
3621 return 0;
3622 }
3623 #endif
3624
3625 /* find or alloc a new VLAN */
3626 VLANState *qemu_find_vlan(int id)
3627 {
3628 VLANState **pvlan, *vlan;
3629 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3630 if (vlan->id == id)
3631 return vlan;
3632 }
3633 vlan = qemu_mallocz(sizeof(VLANState));
3634 if (!vlan)
3635 return NULL;
3636 vlan->id = id;
3637 vlan->next = NULL;
3638 pvlan = &first_vlan;
3639 while (*pvlan != NULL)
3640 pvlan = &(*pvlan)->next;
3641 *pvlan = vlan;
3642 return vlan;
3643 }
3644
3645 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3646 IOReadHandler *fd_read,
3647 IOCanRWHandler *fd_can_read,
3648 void *opaque)
3649 {
3650 VLANClientState *vc, **pvc;
3651 vc = qemu_mallocz(sizeof(VLANClientState));
3652 if (!vc)
3653 return NULL;
3654 vc->fd_read = fd_read;
3655 vc->fd_can_read = fd_can_read;
3656 vc->opaque = opaque;
3657 vc->vlan = vlan;
3658
3659 vc->next = NULL;
3660 pvc = &vlan->first_client;
3661 while (*pvc != NULL)
3662 pvc = &(*pvc)->next;
3663 *pvc = vc;
3664 return vc;
3665 }
3666
3667 int qemu_can_send_packet(VLANClientState *vc1)
3668 {
3669 VLANState *vlan = vc1->vlan;
3670 VLANClientState *vc;
3671
3672 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3673 if (vc != vc1) {
3674 if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3675 return 1;
3676 }
3677 }
3678 return 0;
3679 }
3680
3681 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3682 {
3683 VLANState *vlan = vc1->vlan;
3684 VLANClientState *vc;
3685
3686 #if 0
3687 printf("vlan %d send:\n", vlan->id);
3688 hex_dump(stdout, buf, size);
3689 #endif
3690 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3691 if (vc != vc1) {
3692 vc->fd_read(vc->opaque, buf, size);
3693 }
3694 }
3695 }
3696
3697 #if defined(CONFIG_SLIRP)
3698
3699 /* slirp network adapter */
3700
3701 static int slirp_inited;
3702 static VLANClientState *slirp_vc;
3703
3704 int slirp_can_output(void)
3705 {
3706 return !slirp_vc || qemu_can_send_packet(slirp_vc);
3707 }
3708
3709 void slirp_output(const uint8_t *pkt, int pkt_len)
3710 {
3711 #if 0
3712 printf("slirp output:\n");
3713 hex_dump(stdout, pkt, pkt_len);
3714 #endif
3715 if (!slirp_vc)
3716 return;
3717 qemu_send_packet(slirp_vc, pkt, pkt_len);
3718 }
3719
3720 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3721 {
3722 #if 0
3723 printf("slirp input:\n");
3724 hex_dump(stdout, buf, size);
3725 #endif
3726 slirp_input(buf, size);
3727 }
3728
3729 static int net_slirp_init(VLANState *vlan)
3730 {
3731 if (!slirp_inited) {
3732 slirp_inited = 1;
3733 slirp_init();
3734 }
3735 slirp_vc = qemu_new_vlan_client(vlan,
3736 slirp_receive, NULL, NULL);
3737 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3738 return 0;
3739 }
3740
3741 static void net_slirp_redir(const char *redir_str)
3742 {
3743 int is_udp;
3744 char buf[256], *r;
3745 const char *p;
3746 struct in_addr guest_addr;
3747 int host_port, guest_port;
3748
3749 if (!slirp_inited) {
3750 slirp_inited = 1;
3751 slirp_init();
3752 }
3753
3754 p = redir_str;
3755 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3756 goto fail;
3757 if (!strcmp(buf, "tcp")) {
3758 is_udp = 0;
3759 } else if (!strcmp(buf, "udp")) {
3760 is_udp = 1;
3761 } else {
3762 goto fail;
3763 }
3764
3765 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3766 goto fail;
3767 host_port = strtol(buf, &r, 0);
3768 if (r == buf)
3769 goto fail;
3770
3771 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3772 goto fail;
3773 if (buf[0] == '\0') {
3774 pstrcpy(buf, sizeof(buf), "10.0.2.15");
3775 }
3776 if (!inet_aton(buf, &guest_addr))
3777 goto fail;
3778
3779 guest_port = strtol(p, &r, 0);
3780 if (r == p)
3781 goto fail;
3782
3783 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3784 fprintf(stderr, "qemu: could not set up redirection\n");
3785 exit(1);
3786 }
3787 return;
3788 fail:
3789 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3790 exit(1);
3791 }
3792
3793 #ifndef _WIN32
3794
3795 char smb_dir[1024];
3796
3797 static void smb_exit(void)
3798 {
3799 DIR *d;
3800 struct dirent *de;
3801 char filename[1024];
3802
3803 /* erase all the files in the directory */
3804 d = opendir(smb_dir);
3805 for(;;) {
3806 de = readdir(d);
3807 if (!de)
3808 break;
3809 if (strcmp(de->d_name, ".") != 0 &&
3810 strcmp(de->d_name, "..") != 0) {
3811 snprintf(filename, sizeof(filename), "%s/%s",
3812 smb_dir, de->d_name);
3813 unlink(filename);
3814 }
3815 }
3816 closedir(d);
3817 rmdir(smb_dir);
3818 }
3819
3820 /* automatic user mode samba server configuration */
3821 static void net_slirp_smb(const char *exported_dir)
3822 {
3823 char smb_conf[1024];
3824 char smb_cmdline[1024];
3825 FILE *f;
3826
3827 if (!slirp_inited) {
3828 slirp_inited = 1;
3829 slirp_init();
3830 }
3831
3832 /* XXX: better tmp dir construction */
3833 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3834 if (mkdir(smb_dir, 0700) < 0) {
3835 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3836 exit(1);
3837 }
3838 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3839
3840 f = fopen(smb_conf, "w");
3841 if (!f) {
3842 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3843 exit(1);
3844 }
3845 fprintf(f,
3846 "[global]\n"
3847 "private dir=%s\n"
3848 "smb ports=0\n"
3849 "socket address=127.0.0.1\n"
3850 "pid directory=%s\n"
3851 "lock directory=%s\n"
3852 "log file=%s/log.smbd\n"
3853 "smb passwd file=%s/smbpasswd\n"
3854 "security = share\n"
3855 "[qemu]\n"
3856 "path=%s\n"
3857 "read only=no\n"
3858 "guest ok=yes\n",
3859 smb_dir,
3860 smb_dir,
3861 smb_dir,
3862 smb_dir,
3863 smb_dir,
3864 exported_dir
3865 );
3866 fclose(f);
3867 atexit(smb_exit);
3868
3869 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3870 SMBD_COMMAND, smb_conf);
3871
3872 slirp_add_exec(0, smb_cmdline, 4, 139);
3873 }
3874
3875 #endif /* !defined(_WIN32) */
3876 void do_info_slirp(void)
3877 {
3878 slirp_stats();
3879 }
3880
3881 #endif /* CONFIG_SLIRP */
3882
3883 #if !defined(_WIN32)
3884
3885 typedef struct TAPState {
3886 VLANClientState *vc;
3887 int fd;
3888 char down_script[1024];
3889 } TAPState;
3890
3891 static void tap_receive(void *opaque, const uint8_t *buf, int size)
3892 {
3893 TAPState *s = opaque;
3894 int ret;
3895 for(;;) {
3896 ret = write(s->fd, buf, size);
3897 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3898 } else {
3899 break;
3900 }
3901 }
3902 }
3903
3904 static void tap_send(void *opaque)
3905 {
3906 TAPState *s = opaque;
3907 uint8_t buf[4096];
3908 int size;
3909
3910 #ifdef __sun__
3911 struct strbuf sbuf;
3912 int f = 0;
3913 sbuf.maxlen = sizeof(buf);
3914 sbuf.buf = buf;
3915 size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
3916 #else
3917 size = read(s->fd, buf, sizeof(buf));
3918 #endif
3919 if (size > 0) {
3920 qemu_send_packet(s->vc, buf, size);
3921 }
3922 }
3923
3924 /* fd support */
3925
3926 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3927 {
3928 TAPState *s;
3929
3930 s = qemu_mallocz(sizeof(TAPState));
3931 if (!s)
3932 return NULL;
3933 s->fd = fd;
3934 enable_sigio_timer(fd);
3935 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3936 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3937 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3938 return s;
3939 }
3940
3941 #if defined (_BSD) || defined (__FreeBSD_kernel__)
3942 static int tap_open(char *ifname, int ifname_size)
3943 {
3944 int fd;
3945 char *dev;
3946 struct stat s;
3947
3948 TFR(fd = open("/dev/tap", O_RDWR));
3949 if (fd < 0) {
3950 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
3951 return -1;
3952 }
3953
3954 fstat(fd, &s);
3955 dev = devname(s.st_rdev, S_IFCHR);
3956 pstrcpy(ifname, ifname_size, dev);
3957
3958 fcntl(fd, F_SETFL, O_NONBLOCK);
3959 return fd;
3960 }
3961 #elif defined(__sun__)
3962 #define TUNNEWPPA (('T'<<16) | 0x0001)
3963 /*
3964 * Allocate TAP device, returns opened fd.
3965 * Stores dev name in the first arg(must be large enough).
3966 */
3967 int tap_alloc(char *dev)
3968 {
3969 int tap_fd, if_fd, ppa = -1;
3970 static int ip_fd = 0;
3971 char *ptr;
3972
3973 static int arp_fd = 0;
3974 int ip_muxid, arp_muxid;
3975 struct strioctl strioc_if, strioc_ppa;
3976 int link_type = I_PLINK;;
3977 struct lifreq ifr;
3978 char actual_name[32] = "";
3979
3980 memset(&ifr, 0x0, sizeof(ifr));
3981
3982 if( *dev ){
3983 ptr = dev;
3984 while( *ptr && !isdigit((int)*ptr) ) ptr++;
3985 ppa = atoi(ptr);
3986 }
3987
3988 /* Check if IP device was opened */
3989 if( ip_fd )
3990 close(ip_fd);
3991
3992 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
3993 if (ip_fd < 0) {
3994 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
3995 return -1;
3996 }
3997
3998 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
3999 if (tap_fd < 0) {
4000 syslog(LOG_ERR, "Can't open /dev/tap");
4001 return -1;
4002 }
4003
4004 /* Assign a new PPA and get its unit number. */
4005 strioc_ppa.ic_cmd = TUNNEWPPA;
4006 strioc_ppa.ic_timout = 0;
4007 strioc_ppa.ic_len = sizeof(ppa);
4008 strioc_ppa.ic_dp = (char *)&ppa;
4009 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4010 syslog (LOG_ERR, "Can't assign new interface");
4011
4012 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4013 if (if_fd < 0) {
4014 syslog(LOG_ERR, "Can't open /dev/tap (2)");
4015 return -1;
4016 }
4017 if(ioctl(if_fd, I_PUSH, "ip") < 0){
4018 syslog(LOG_ERR, "Can't push IP module");
4019 return -1;
4020 }
4021
4022 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4023 syslog(LOG_ERR, "Can't get flags\n");
4024
4025 snprintf (actual_name, 32, "tap%d", ppa);
4026 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4027
4028 ifr.lifr_ppa = ppa;
4029 /* Assign ppa according to the unit number returned by tun device */
4030
4031 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4032 syslog (LOG_ERR, "Can't set PPA %d", ppa);
4033 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4034 syslog (LOG_ERR, "Can't get flags\n");
4035 /* Push arp module to if_fd */
4036 if (ioctl (if_fd, I_PUSH, "arp") < 0)
4037 syslog (LOG_ERR, "Can't push ARP module (2)");
4038
4039 /* Push arp module to ip_fd */
4040 if (ioctl (ip_fd, I_POP, NULL) < 0)
4041 syslog (LOG_ERR, "I_POP failed\n");
4042 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4043 syslog (LOG_ERR, "Can't push ARP module (3)\n");
4044 /* Open arp_fd */
4045 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4046 if (arp_fd < 0)
4047 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4048
4049 /* Set ifname to arp */
4050 strioc_if.ic_cmd = SIOCSLIFNAME;
4051 strioc_if.ic_timout = 0;
4052 strioc_if.ic_len = sizeof(ifr);
4053 strioc_if.ic_dp = (char *)&ifr;
4054 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4055 syslog (LOG_ERR, "Can't set ifname to arp\n");
4056 }
4057
4058 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4059 syslog(LOG_ERR, "Can't link TAP device to IP");
4060 return -1;
4061 }
4062
4063 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4064 syslog (LOG_ERR, "Can't link TAP device to ARP");
4065
4066 close (if_fd);
4067
4068 memset(&ifr, 0x0, sizeof(ifr));
4069 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4070 ifr.lifr_ip_muxid = ip_muxid;
4071 ifr.lifr_arp_muxid = arp_muxid;
4072
4073 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4074 {
4075 ioctl (ip_fd, I_PUNLINK , arp_muxid);
4076 ioctl (ip_fd, I_PUNLINK, ip_muxid);
4077 syslog (LOG_ERR, "Can't set multiplexor id");
4078 }
4079
4080 sprintf(dev, "tap%d", ppa);
4081 return tap_fd;
4082 }
4083
4084 static int tap_open(char *ifname, int ifname_size)
4085 {
4086 char dev[10]="";
4087 int fd;
4088 if( (fd = tap_alloc(dev)) < 0 ){
4089 fprintf(stderr, "Cannot allocate TAP device\n");
4090 return -1;
4091 }
4092 pstrcpy(ifname, ifname_size, dev);
4093 fcntl(fd, F_SETFL, O_NONBLOCK);
4094 return fd;
4095 }
4096 #else
4097 static int tap_open(char *ifname, int ifname_size)
4098 {
4099 struct ifreq ifr;
4100 int fd, ret;
4101
4102 TFR(fd = open("/dev/net/tun", O_RDWR));
4103 if (fd < 0) {
4104 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4105 return -1;
4106 }
4107 memset(&ifr, 0, sizeof(ifr));
4108 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4109 if (ifname[0] != '\0')
4110 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4111 else
4112 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4113 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4114 if (ret != 0) {
4115 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4116 close(fd);
4117 return -1;
4118 }
4119 pstrcpy(ifname, ifname_size, ifr.ifr_name);
4120 fcntl(fd, F_SETFL, O_NONBLOCK);
4121 return fd;
4122 }
4123 #endif
4124
4125 static int launch_script(const char *setup_script, const char *ifname, int fd)
4126 {
4127 int pid, status;
4128 char *args[3];
4129 char **parg;
4130
4131 /* try to launch network script */
4132 pid = fork();
4133 if (pid >= 0) {
4134 if (pid == 0) {
4135 int open_max = sysconf (_SC_OPEN_MAX), i;
4136 for (i = 0; i < open_max; i++)
4137 if (i != STDIN_FILENO &&
4138 i != STDOUT_FILENO &&
4139 i != STDERR_FILENO &&
4140 i != fd)
4141 close(i);
4142
4143 parg = args;
4144 *parg++ = (char *)setup_script;
4145 *parg++ = (char *)ifname;
4146 *parg++ = NULL;
4147 execv(setup_script, args);
4148 _exit(1);
4149 }
4150 while (waitpid(pid, &status, 0) != pid);
4151 if (!WIFEXITED(status) ||
4152 WEXITSTATUS(status) != 0) {
4153 fprintf(stderr, "%s: could not launch network script\n",
4154 setup_script);
4155 return -1;
4156 }
4157 }
4158 return 0;
4159 }
4160
4161 static int net_tap_init(VLANState *vlan, const char *ifname1,
4162 const char *setup_script, const char *down_script)
4163 {
4164 TAPState *s;
4165 int fd;
4166 char ifname[128];
4167
4168 if (ifname1 != NULL)
4169 pstrcpy(ifname, sizeof(ifname), ifname1);
4170 else
4171 ifname[0] = '\0';
4172 TFR(fd = tap_open(ifname, sizeof(ifname)));
4173 if (fd < 0)
4174 return -1;
4175
4176 if (!setup_script || !strcmp(setup_script, "no"))
4177 setup_script = "";
4178 if (setup_script[0] != '\0') {
4179 if (launch_script(setup_script, ifname, fd))
4180 return -1;
4181 }
4182 s = net_tap_fd_init(vlan, fd);
4183 if (!s)
4184 return -1;
4185 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4186 "tap: ifname=%s setup_script=%s", ifname, setup_script);
4187 if (down_script && strcmp(down_script, "no"))
4188 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4189 return 0;
4190 }
4191
4192 #endif /* !_WIN32 */
4193
4194 /* network connection */
4195 typedef struct NetSocketState {
4196 VLANClientState *vc;
4197 int fd;
4198 int state; /* 0 = getting length, 1 = getting data */
4199 int index;
4200 int packet_len;
4201 uint8_t buf[4096];
4202 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4203 } NetSocketState;
4204
4205 typedef struct NetSocketListenState {
4206 VLANState *vlan;
4207 int fd;
4208 } NetSocketListenState;
4209
4210 /* XXX: we consider we can send the whole packet without blocking */
4211 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4212 {
4213 NetSocketState *s = opaque;
4214 uint32_t len;
4215 len = htonl(size);
4216
4217 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4218 send_all(s->fd, buf, size);
4219 }
4220
4221 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4222 {
4223 NetSocketState *s = opaque;
4224 sendto(s->fd, buf, size, 0,
4225 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4226 }
4227
4228 static void net_socket_send(void *opaque)
4229 {
4230 NetSocketState *s = opaque;
4231 int l, size, err;
4232 uint8_t buf1[4096];
4233 const uint8_t *buf;
4234
4235 size = recv(s->fd, buf1, sizeof(buf1), 0);
4236 if (size < 0) {
4237 err = socket_error();
4238 if (err != EWOULDBLOCK)
4239 goto eoc;
4240 } else if (size == 0) {
4241 /* end of connection */
4242 eoc:
4243 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4244 closesocket(s->fd);
4245 return;
4246 }
4247 buf = buf1;
4248 while (size > 0) {
4249 /* reassemble a packet from the network */
4250 switch(s->state) {
4251 case 0:
4252 l = 4 - s->index;
4253 if (l > size)
4254 l = size;
4255 memcpy(s->buf + s->index, buf, l);
4256 buf += l;
4257 size -= l;
4258 s->index += l;
4259 if (s->index == 4) {
4260 /* got length */
4261 s->packet_len = ntohl(*(uint32_t *)s->buf);
4262 s->index = 0;
4263 s->state = 1;
4264 }
4265 break;
4266 case 1:
4267 l = s->packet_len - s->index;
4268 if (l > size)
4269 l = size;
4270 memcpy(s->buf + s->index, buf, l);
4271 s->index += l;
4272 buf += l;
4273 size -= l;
4274 if (s->index >= s->packet_len) {
4275 qemu_send_packet(s->vc, s->buf, s->packet_len);
4276 s->index = 0;
4277 s->state = 0;
4278 }
4279 break;
4280 }
4281 }
4282 }
4283
4284 static void net_socket_send_dgram(void *opaque)
4285 {
4286 NetSocketState *s = opaque;
4287 int size;
4288
4289 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4290 if (size < 0)
4291 return;
4292 if (size == 0) {
4293 /* end of connection */
4294 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4295 return;
4296 }
4297 qemu_send_packet(s->vc, s->buf, size);
4298 }
4299
4300 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4301 {
4302 struct ip_mreq imr;
4303 int fd;
4304 int val, ret;
4305 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4306 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4307 inet_ntoa(mcastaddr->sin_addr),
4308 (int)ntohl(mcastaddr->sin_addr.s_addr));
4309 return -1;
4310
4311 }
4312 fd = socket(PF_INET, SOCK_DGRAM, 0);
4313 if (fd < 0) {
4314 perror("socket(PF_INET, SOCK_DGRAM)");
4315 return -1;
4316 }
4317
4318 val = 1;
4319 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4320 (const char *)&val, sizeof(val));
4321 if (ret < 0) {
4322 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4323 goto fail;
4324 }
4325
4326 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4327 if (ret < 0) {
4328 perror("bind");
4329 goto fail;
4330 }
4331
4332 /* Add host to multicast group */
4333 imr.imr_multiaddr = mcastaddr->sin_addr;
4334 imr.imr_interface.s_addr = htonl(INADDR_ANY);
4335
4336 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4337 (const char *)&imr, sizeof(struct ip_mreq));
4338 if (ret < 0) {
4339 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4340 goto fail;
4341 }
4342
4343 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4344 val = 1;
4345 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4346 (const char *)&val, sizeof(val));
4347 if (ret < 0) {
4348 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4349 goto fail;
4350 }
4351
4352 socket_set_nonblock(fd);
4353 return fd;
4354 fail:
4355 if (fd >= 0)
4356 closesocket(fd);
4357 return -1;
4358 }
4359
4360 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4361 int is_connected)
4362 {
4363 struct sockaddr_in saddr;
4364 int newfd;
4365 socklen_t saddr_len;
4366 NetSocketState *s;
4367
4368 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4369 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4370 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4371 */
4372
4373 if (is_connected) {
4374 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4375 /* must be bound */
4376 if (saddr.sin_addr.s_addr==0) {
4377 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4378 fd);
4379 return NULL;
4380 }
4381 /* clone dgram socket */
4382 newfd = net_socket_mcast_create(&saddr);
4383 if (newfd < 0) {
4384 /* error already reported by net_socket_mcast_create() */
4385 close(fd);
4386 return NULL;
4387 }
4388 /* clone newfd to fd, close newfd */
4389 dup2(newfd, fd);
4390 close(newfd);
4391
4392 } else {
4393 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4394 fd, strerror(errno));
4395 return NULL;
4396 }
4397 }
4398
4399 s = qemu_mallocz(sizeof(NetSocketState));
4400 if (!s)
4401 return NULL;
4402 s->fd = fd;
4403
4404 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4405 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4406
4407 /* mcast: save bound address as dst */
4408 if (is_connected) s->dgram_dst=saddr;
4409
4410 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4411 "socket: fd=%d (%s mcast=%s:%d)",
4412 fd, is_connected? "cloned" : "",
4413 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4414 return s;
4415 }
4416
4417 static void net_socket_connect(void *opaque)
4418 {
4419 NetSocketState *s = opaque;
4420 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4421 }
4422
4423 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4424 int is_connected)
4425 {
4426 NetSocketState *s;
4427 s = qemu_mallocz(sizeof(NetSocketState));
4428 if (!s)
4429 return NULL;
4430 s->fd = fd;
4431 s->vc = qemu_new_vlan_client(vlan,
4432 net_socket_receive, NULL, s);
4433 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4434 "socket: fd=%d", fd);
4435 if (is_connected) {
4436 net_socket_connect(s);
4437 } else {
4438 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4439 }
4440 return s;
4441 }
4442
4443 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4444 int is_connected)
4445 {
4446 int so_type=-1, optlen=sizeof(so_type);
4447
4448 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
4449 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4450 return NULL;
4451 }
4452 switch(so_type) {
4453 case SOCK_DGRAM:
4454 return net_socket_fd_init_dgram(vlan, fd, is_connected);
4455 case SOCK_STREAM:
4456 return net_socket_fd_init_stream(vlan, fd, is_connected);
4457 default:
4458 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4459 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4460 return net_socket_fd_init_stream(vlan, fd, is_connected);
4461 }
4462 return NULL;
4463 }
4464
4465 static void net_socket_accept(void *opaque)
4466 {
4467 NetSocketListenState *s = opaque;
4468 NetSocketState *s1;
4469 struct sockaddr_in saddr;
4470 socklen_t len;
4471 int fd;
4472
4473 for(;;) {
4474 len = sizeof(saddr);
4475 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4476 if (fd < 0 && errno != EINTR) {
4477 return;
4478 } else if (fd >= 0) {
4479 break;
4480 }
4481 }
4482 s1 = net_socket_fd_init(s->vlan, fd, 1);
4483 if (!s1) {
4484 closesocket(fd);
4485 } else {
4486 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4487 "socket: connection from %s:%d",
4488 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4489 }
4490 }
4491
4492 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4493 {
4494 NetSocketListenState *s;
4495 int fd, val, ret;
4496 struct sockaddr_in saddr;
4497
4498 if (parse_host_port(&saddr, host_str) < 0)
4499 return -1;
4500
4501 s = qemu_mallocz(sizeof(NetSocketListenState));
4502 if (!s)
4503 return -1;
4504
4505 fd = socket(PF_INET, SOCK_STREAM, 0);
4506 if (fd < 0) {
4507 perror("socket");
4508 return -1;
4509 }
4510 socket_set_nonblock(fd);
4511
4512 /* allow fast reuse */
4513 val = 1;
4514 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4515
4516 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4517 if (ret < 0) {
4518 perror("bind");
4519 return -1;
4520 }
4521 ret = listen(fd, 0);
4522 if (ret < 0) {
4523 perror("listen");
4524 return -1;
4525 }
4526 s->vlan = vlan;
4527 s->fd = fd;
4528 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4529 return 0;
4530 }
4531
4532 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4533 {
4534 NetSocketState *s;
4535 int fd, connected, ret, err;
4536 struct sockaddr_in saddr;
4537
4538 if (parse_host_port(&saddr, host_str) < 0)
4539 return -1;
4540
4541 fd = socket(PF_INET, SOCK_STREAM, 0);
4542 if (fd < 0) {
4543 perror("socket");
4544 return -1;
4545 }
4546 socket_set_nonblock(fd);
4547
4548 connected = 0;
4549 for(;;) {
4550 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4551 if (ret < 0) {
4552 err = socket_error();
4553 if (err == EINTR || err == EWOULDBLOCK) {
4554 } else if (err == EINPROGRESS) {
4555 break;
4556 #ifdef _WIN32
4557 } else if (err == WSAEALREADY) {
4558 break;
4559 #endif
4560 } else {
4561 perror("connect");
4562 closesocket(fd);
4563 return -1;
4564 }
4565 } else {
4566 connected = 1;
4567 break;
4568 }
4569 }
4570 s = net_socket_fd_init(vlan, fd, connected);
4571 if (!s)
4572 return -1;
4573 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4574 "socket: connect to %s:%d",
4575 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4576 return 0;
4577 }
4578
4579 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4580 {
4581 NetSocketState *s;
4582 int fd;
4583 struct sockaddr_in saddr;
4584
4585 if (parse_host_port(&saddr, host_str) < 0)
4586 return -1;
4587
4588
4589 fd = net_socket_mcast_create(&saddr);
4590 if (fd < 0)
4591 return -1;
4592
4593 s = net_socket_fd_init(vlan, fd, 0);
4594 if (!s)
4595 return -1;
4596
4597 s->dgram_dst = saddr;
4598
4599 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4600 "socket: mcast=%s:%d",
4601 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4602 return 0;
4603
4604 }
4605
4606 static const char *get_word(char *buf, int buf_size, const char *p)
4607 {
4608 char *q;
4609 int substring;
4610
4611 substring = 0;
4612 q = buf;
4613 while (*p != '\0') {
4614 if (*p == '\\') {
4615 p++;
4616 if (*p == '\0')
4617 break;
4618 } else if (*p == '\"') {
4619 substring = !substring;
4620 p++;
4621 continue;
4622 } else if (!substring && (*p == ',' || *p == '='))
4623 break;
4624 if (q && (q - buf) < buf_size - 1)
4625 *q++ = *p;
4626 p++;
4627 }
4628 if (q)
4629 *q = '\0';
4630
4631 return p;
4632 }
4633
4634 static int get_param_value(char *buf, int buf_size,
4635 const char *tag, const char *str)
4636 {
4637 const char *p;
4638 char option[128];
4639
4640 p = str;
4641 for(;;) {
4642 p = get_word(option, sizeof(option), p);
4643 if (*p != '=')
4644 break;
4645 p++;
4646 if (!strcmp(tag, option)) {
4647 (void)get_word(buf, buf_size, p);
4648 return strlen(buf);
4649 } else {
4650 p = get_word(NULL, 0, p);
4651 }
4652 if (*p != ',')
4653 break;
4654 p++;
4655 }
4656 return 0;
4657 }
4658
4659 static int check_params(char *buf, int buf_size,
4660 char **params, const char *str)
4661 {
4662 const char *p;
4663 int i;
4664
4665 p = str;
4666 for(;;) {
4667 p = get_word(buf, buf_size, p);
4668 if (*p != '=')
4669 return -1;
4670 p++;
4671 for(i = 0; params[i] != NULL; i++)
4672 if (!strcmp(params[i], buf))
4673 break;
4674 if (params[i] == NULL)
4675 return -1;
4676 p = get_word(NULL, 0, p);
4677 if (*p != ',')
4678 break;
4679 p++;
4680 }
4681 return 0;
4682 }
4683
4684
4685 static int net_client_init(const char *str)
4686 {
4687 const char *p;
4688 char *q;
4689 char device[64];
4690 char buf[1024];
4691 int vlan_id, ret;
4692 VLANState *vlan;
4693
4694 p = str;
4695 q = device;
4696 while (*p != '\0' && *p != ',') {
4697 if ((q - device) < sizeof(device) - 1)
4698 *q++ = *p;
4699 p++;
4700 }
4701 *q = '\0';
4702 if (*p == ',')
4703 p++;
4704 vlan_id = 0;
4705 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4706 vlan_id = strtol(buf, NULL, 0);
4707 }
4708 vlan = qemu_find_vlan(vlan_id);
4709 if (!vlan) {
4710 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4711 return -1;
4712 }
4713 if (!strcmp(device, "nic")) {
4714 NICInfo *nd;
4715 uint8_t *macaddr;
4716
4717 if (nb_nics >= MAX_NICS) {
4718 fprintf(stderr, "Too Many NICs\n");
4719 return -1;
4720 }
4721 nd = &nd_table[nb_nics];
4722 macaddr = nd->macaddr;
4723 macaddr[0] = 0x52;
4724 macaddr[1] = 0x54;
4725 macaddr[2] = 0x00;
4726 macaddr[3] = 0x12;
4727 macaddr[4] = 0x34;
4728 macaddr[5] = 0x56 + nb_nics;
4729
4730 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4731 if (parse_macaddr(macaddr, buf) < 0) {
4732 fprintf(stderr, "invalid syntax for ethernet address\n");
4733 return -1;
4734 }
4735 }
4736 if (get_param_value(buf, sizeof(buf), "model", p)) {
4737 nd->model = strdup(buf);
4738 }
4739 nd->vlan = vlan;
4740 nb_nics++;
4741 vlan->nb_guest_devs++;
4742 ret = 0;
4743 } else
4744 if (!strcmp(device, "none")) {
4745 /* does nothing. It is needed to signal that no network cards
4746 are wanted */
4747 ret = 0;
4748 } else
4749 #ifdef CONFIG_SLIRP
4750 if (!strcmp(device, "user")) {
4751 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4752 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4753 }
4754 vlan->nb_host_devs++;
4755 ret = net_slirp_init(vlan);
4756 } else
4757 #endif
4758 #ifdef _WIN32
4759 if (!strcmp(device, "tap")) {
4760 char ifname[64];
4761 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4762 fprintf(stderr, "tap: no interface name\n");
4763 return -1;
4764 }
4765 vlan->nb_host_devs++;
4766 ret = tap_win32_init(vlan, ifname);
4767 } else
4768 #else
4769 if (!strcmp(device, "tap")) {
4770 char ifname[64];
4771 char setup_script[1024], down_script[1024];
4772 int fd;
4773 vlan->nb_host_devs++;
4774 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4775 fd = strtol(buf, NULL, 0);
4776 ret = -1;
4777 if (net_tap_fd_init(vlan, fd))
4778 ret = 0;
4779 } else {
4780 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4781 ifname[0] = '\0';
4782 }
4783 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
4784 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
4785 }
4786 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
4787 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
4788 }
4789 ret = net_tap_init(vlan, ifname, setup_script, down_script);
4790 }
4791 } else
4792 #endif
4793 if (!strcmp(device, "socket")) {
4794 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4795 int fd;
4796 fd = strtol(buf, NULL, 0);
4797 ret = -1;
4798 if (net_socket_fd_init(vlan, fd, 1))
4799 ret = 0;
4800 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
4801 ret = net_socket_listen_init(vlan, buf);
4802 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
4803 ret = net_socket_connect_init(vlan, buf);
4804 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
4805 ret = net_socket_mcast_init(vlan, buf);
4806 } else {
4807 fprintf(stderr, "Unknown socket options: %s\n", p);
4808 return -1;
4809 }
4810 vlan->nb_host_devs++;
4811 } else
4812 {
4813 fprintf(stderr, "Unknown network device: %s\n", device);
4814 return -1;
4815 }
4816 if (ret < 0) {
4817 fprintf(stderr, "Could not initialize device '%s'\n", device);
4818 }
4819
4820 return ret;
4821 }
4822
4823 void do_info_network(void)
4824 {
4825 VLANState *vlan;
4826 VLANClientState *vc;
4827
4828 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4829 term_printf("VLAN %d devices:\n", vlan->id);
4830 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4831 term_printf(" %s\n", vc->info_str);
4832 }
4833 }
4834
4835 #define HD_ALIAS "file=\"%s\",index=%d,media=disk"
4836 #ifdef TARGET_PPC
4837 #define CDROM_ALIAS "index=1,media=cdrom"
4838 #else
4839 #define CDROM_ALIAS "index=2,media=cdrom"
4840 #endif
4841 #define FD_ALIAS "index=%d,if=floppy"
4842 #define PFLASH_ALIAS "file=\"%s\",if=pflash"
4843 #define MTD_ALIAS "file=\"%s\",if=mtd"
4844 #define SD_ALIAS "index=0,if=sd"
4845
4846 static int drive_add(const char *fmt, ...)
4847 {
4848 va_list ap;
4849
4850 if (nb_drives_opt >= MAX_DRIVES) {
4851 fprintf(stderr, "qemu: too many drives\n");
4852 exit(1);
4853 }
4854
4855 va_start(ap, fmt);
4856 vsnprintf(drives_opt[nb_drives_opt], sizeof(drives_opt[0]), fmt, ap);
4857 va_end(ap);
4858
4859 return nb_drives_opt++;
4860 }
4861
4862 int drive_get_index(BlockInterfaceType interface, int bus, int unit)
4863 {
4864 int index;
4865
4866 /* seek interface, bus and unit */
4867
4868 for (index = 0; index < nb_drives; index++)
4869 if (drives_table[index].interface == interface &&
4870 drives_table[index].bus == bus &&
4871 drives_table[index].unit == unit)
4872 return index;
4873
4874 return -1;
4875 }
4876
4877 int drive_get_max_bus(BlockInterfaceType interface)
4878 {
4879 int max_bus;
4880 int index;
4881
4882 max_bus = -1;
4883 for (index = 0; index < nb_drives; index++) {
4884 if(drives_table[index].interface == interface &&
4885 drives_table[index].bus > max_bus)
4886 max_bus = drives_table[index].bus;
4887 }
4888 return max_bus;
4889 }
4890
4891 static int drive_init(const char *str, int snapshot, QEMUMachine *machine)
4892 {
4893 char buf[128];
4894 char file[1024];
4895 char devname[128];
4896 const char *mediastr = "";
4897 BlockInterfaceType interface;
4898 enum { MEDIA_DISK, MEDIA_CDROM } media;
4899 int bus_id, unit_id;
4900 int cyls, heads, secs, translation;
4901 BlockDriverState *bdrv;
4902 int max_devs;
4903 int index;
4904 char *params[] = { "bus", "unit", "if", "index", "cyls", "heads",
4905 "secs", "trans", "media", "snapshot", "file", NULL };
4906
4907 if (check_params(buf, sizeof(buf), params, str) < 0) {
4908 fprintf(stderr, "qemu: unknowm parameter '%s' in '%s'\n",
4909 buf, str);
4910 return -1;
4911 }
4912
4913 file[0] = 0;
4914 cyls = heads = secs = 0;
4915 bus_id = 0;
4916 unit_id = -1;
4917 translation = BIOS_ATA_TRANSLATION_AUTO;
4918 index = -1;
4919
4920 if (!strcmp(machine->name, "realview") ||
4921 !strcmp(machine->name, "SS-5") ||
4922 !strcmp(machine->name, "SS-10") ||
4923 !strcmp(machine->name, "SS-600MP") ||
4924 !strcmp(machine->name, "versatilepb") ||
4925 !strcmp(machine->name, "versatileab")) {
4926 interface = IF_SCSI;
4927 max_devs = MAX_SCSI_DEVS;
4928 strcpy(devname, "scsi");
4929 } else {
4930 interface = IF_IDE;
4931 max_devs = MAX_IDE_DEVS;
4932 strcpy(devname, "ide");
4933 }
4934 media = MEDIA_DISK;
4935
4936 /* extract parameters */
4937
4938 if (get_param_value(buf, sizeof(buf), "bus", str)) {
4939 bus_id = strtol(buf, NULL, 0);
4940 if (bus_id < 0) {
4941 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
4942 return -1;
4943 }
4944 }
4945
4946 if (get_param_value(buf, sizeof(buf), "unit", str)) {
4947 unit_id = strtol(buf, NULL, 0);
4948 if (unit_id < 0) {
4949 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
4950 return -1;
4951 }
4952 }
4953
4954 if (get_param_value(buf, sizeof(buf), "if", str)) {
4955 strncpy(devname, buf, sizeof(devname));
4956 if (!strcmp(buf, "ide")) {
4957 interface = IF_IDE;
4958 max_devs = MAX_IDE_DEVS;
4959 } else if (!strcmp(buf, "scsi")) {
4960 interface = IF_SCSI;
4961 max_devs = MAX_SCSI_DEVS;
4962 } else if (!strcmp(buf, "floppy")) {
4963 interface = IF_FLOPPY;
4964 max_devs = 0;
4965 } else if (!strcmp(buf, "pflash")) {
4966 interface = IF_PFLASH;
4967 max_devs = 0;
4968 } else if (!strcmp(buf, "mtd")) {
4969 interface = IF_MTD;
4970 max_devs = 0;
4971 } else if (!strcmp(buf, "sd")) {
4972 interface = IF_SD;
4973 max_devs = 0;
4974 } else {
4975 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
4976 return -1;
4977 }
4978 }
4979
4980 if (get_param_value(buf, sizeof(buf), "index", str)) {
4981 index = strtol(buf, NULL, 0);
4982 if (index < 0) {
4983 fprintf(stderr, "qemu: '%s' invalid index\n", str);
4984 return -1;
4985 }
4986 }
4987
4988 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
4989 cyls = strtol(buf, NULL, 0);
4990 }
4991
4992 if (get_param_value(buf, sizeof(buf), "heads", str)) {
4993 heads = strtol(buf, NULL, 0);
4994 }
4995
4996 if (get_param_value(buf, sizeof(buf), "secs", str)) {
4997 secs = strtol(buf, NULL, 0);
4998 }
4999
5000 if (cyls || heads || secs) {
5001 if (cyls < 1 || cyls > 16383) {
5002 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5003 return -1;
5004 }
5005 if (heads < 1 || heads > 16) {
5006 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5007 return -1;
5008 }
5009 if (secs < 1 || secs > 63) {
5010 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5011 return -1;
5012 }
5013 }
5014
5015 if (get_param_value(buf, sizeof(buf), "trans", str)) {
5016 if (!cyls) {
5017 fprintf(stderr,
5018 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5019 str);
5020 return -1;
5021 }
5022 if (!strcmp(buf, "none"))
5023 translation = BIOS_ATA_TRANSLATION_NONE;
5024 else if (!strcmp(buf, "lba"))
5025 translation = BIOS_ATA_TRANSLATION_LBA;
5026 else if (!strcmp(buf, "auto"))
5027 translation = BIOS_ATA_TRANSLATION_AUTO;
5028 else {
5029 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5030 return -1;
5031 }
5032 }
5033
5034 if (get_param_value(buf, sizeof(buf), "media", str)) {
5035 if (!strcmp(buf, "disk")) {
5036 media = MEDIA_DISK;
5037 } else if (!strcmp(buf, "cdrom")) {
5038 if (cyls || secs || heads) {
5039 fprintf(stderr,
5040 "qemu: '%s' invalid physical CHS format\n", str);
5041 return -1;
5042 }
5043 media = MEDIA_CDROM;
5044 } else {
5045 fprintf(stderr, "qemu: '%s' invalid media\n", str);
5046 return -1;
5047 }
5048 }
5049
5050 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5051 if (!strcmp(buf, "on"))
5052 snapshot = 1;
5053 else if (!strcmp(buf, "off"))
5054 snapshot = 0;
5055 else {
5056 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5057 return -1;
5058 }
5059 }
5060
5061 get_param_value(file, sizeof(file), "file", str);
5062
5063 /* compute bus and unit according index */
5064
5065 if (index != -1) {
5066 if (bus_id != 0 || unit_id != -1) {
5067 fprintf(stderr,
5068 "qemu: '%s' index cannot be used with bus and unit\n", str);
5069 return -1;
5070 }
5071 if (max_devs == 0)
5072 {
5073 unit_id = index;
5074 bus_id = 0;
5075 } else {
5076 unit_id = index % max_devs;
5077 bus_id = index / max_devs;
5078 }
5079 }
5080
5081 /* if user doesn't specify a unit_id,
5082 * try to find the first free
5083 */
5084
5085 if (unit_id == -1) {
5086 unit_id = 0;
5087 while (drive_get_index(interface, bus_id, unit_id) != -1) {
5088 unit_id++;
5089 if (max_devs && unit_id >= max_devs) {
5090 unit_id -= max_devs;
5091 bus_id++;
5092 }
5093 }
5094 }
5095
5096 /* check unit id */
5097
5098 if (max_devs && unit_id >= max_devs) {
5099 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5100 str, unit_id, max_devs - 1);
5101 return -1;
5102 }
5103
5104 /*
5105 * ignore multiple definitions
5106 */
5107
5108 if (drive_get_index(interface, bus_id, unit_id) != -1)
5109 return 0;
5110
5111 /* init */
5112
5113 if (interface == IF_IDE || interface == IF_SCSI)
5114 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5115 snprintf(buf, sizeof(buf), max_devs ? "%1$s%4$i%2$s%3$i" : "%s%s%i",
5116 devname, mediastr, unit_id, bus_id);
5117 bdrv = bdrv_new(buf);
5118 drives_table[nb_drives].bdrv = bdrv;
5119 drives_table[nb_drives].interface = interface;
5120 drives_table[nb_drives].bus = bus_id;
5121 drives_table[nb_drives].unit = unit_id;
5122 nb_drives++;
5123
5124 switch(interface) {
5125 case IF_IDE:
5126 case IF_SCSI:
5127 switch(media) {
5128 case MEDIA_DISK:
5129 if (cyls != 0) {
5130 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5131 bdrv_set_translation_hint(bdrv, translation);
5132 }
5133 break;
5134 case MEDIA_CDROM:
5135 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5136 break;
5137 }
5138 break;
5139 case IF_SD:
5140 /* FIXME: This isn't really a floppy, but it's a reasonable
5141 approximation. */
5142 case IF_FLOPPY:
5143 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5144 break;
5145 case IF_PFLASH:
5146 case IF_MTD:
5147 break;
5148 }
5149 if (!file[0])
5150 return 0;
5151 if (bdrv_open(bdrv, file, snapshot ? BDRV_O_SNAPSHOT : 0) < 0 ||
5152 qemu_key_check(bdrv, file)) {
5153 fprintf(stderr, "qemu: could not open disk image %s\n",
5154 file);
5155 return -1;
5156 }
5157 return 0;
5158 }
5159
5160 /***********************************************************/
5161 /* USB devices */
5162
5163 static USBPort *used_usb_ports;
5164 static USBPort *free_usb_ports;
5165
5166 /* ??? Maybe change this to register a hub to keep track of the topology. */
5167 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5168 usb_attachfn attach)
5169 {
5170 port->opaque = opaque;
5171 port->index = index;
5172 port->attach = attach;
5173 port->next = free_usb_ports;
5174 free_usb_ports = port;
5175 }
5176
5177 static int usb_device_add(const char *devname)
5178 {
5179 const char *p;
5180 USBDevice *dev;
5181 USBPort *port;
5182
5183 if (!free_usb_ports)
5184 return -1;
5185
5186 if (strstart(devname, "host:", &p)) {
5187 dev = usb_host_device_open(p);
5188 } else if (!strcmp(devname, "mouse")) {
5189 dev = usb_mouse_init();
5190 } else if (!strcmp(devname, "tablet")) {
5191 dev = usb_tablet_init();
5192 } else if (!strcmp(devname, "keyboard")) {
5193 dev = usb_keyboard_init();
5194 } else if (strstart(devname, "disk:", &p)) {
5195 dev = usb_msd_init(p);
5196 } else if (!strcmp(devname, "wacom-tablet")) {
5197 dev = usb_wacom_init();
5198 } else {
5199 return -1;
5200 }
5201 if (!dev)
5202 return -1;
5203
5204 /* Find a USB port to add the device to. */
5205 port = free_usb_ports;
5206 if (!port->next) {
5207 USBDevice *hub;
5208
5209 /* Create a new hub and chain it on. */
5210 free_usb_ports = NULL;
5211 port->next = used_usb_ports;
5212 used_usb_ports = port;
5213
5214 hub = usb_hub_init(VM_USB_HUB_SIZE);
5215 usb_attach(port, hub);
5216 port = free_usb_ports;
5217 }
5218
5219 free_usb_ports = port->next;
5220 port->next = used_usb_ports;
5221 used_usb_ports = port;
5222 usb_attach(port, dev);
5223 return 0;
5224 }
5225
5226 static int usb_device_del(const char *devname)
5227 {
5228 USBPort *port;
5229 USBPort **lastp;
5230 USBDevice *dev;
5231 int bus_num, addr;
5232 const char *p;
5233
5234 if (!used_usb_ports)
5235 return -1;
5236
5237 p = strchr(devname, '.');
5238 if (!p)
5239 return -1;
5240 bus_num = strtoul(devname, NULL, 0);
5241 addr = strtoul(p + 1, NULL, 0);
5242 if (bus_num != 0)
5243 return -1;
5244
5245 lastp = &used_usb_ports;
5246 port = used_usb_ports;
5247 while (port && port->dev->addr != addr) {
5248 lastp = &port->next;
5249 port = port->next;
5250 }
5251
5252 if (!port)
5253 return -1;
5254
5255 dev = port->dev;
5256 *lastp = port->next;
5257 usb_attach(port, NULL);
5258 dev->handle_destroy(dev);
5259 port->next = free_usb_ports;
5260 free_usb_ports = port;
5261 return 0;
5262 }
5263
5264 void do_usb_add(const char *devname)
5265 {
5266 int ret;
5267 ret = usb_device_add(devname);
5268 if (ret < 0)
5269 term_printf("Could not add USB device '%s'\n", devname);
5270 }
5271
5272 void do_usb_del(const char *devname)
5273 {
5274 int ret;
5275 ret = usb_device_del(devname);
5276 if (ret < 0)
5277 term_printf("Could not remove USB device '%s'\n", devname);
5278 }
5279
5280 void usb_info(void)
5281 {
5282 USBDevice *dev;
5283 USBPort *port;
5284 const char *speed_str;
5285
5286 if (!usb_enabled) {
5287 term_printf("USB support not enabled\n");
5288 return;
5289 }
5290
5291 for (port = used_usb_ports; port; port = port->next) {
5292 dev = port->dev;
5293 if (!dev)
5294 continue;
5295 switch(dev->speed) {
5296 case USB_SPEED_LOW:
5297 speed_str = "1.5";
5298 break;
5299 case USB_SPEED_FULL:
5300 speed_str = "12";
5301 break;
5302 case USB_SPEED_HIGH:
5303 speed_str = "480";
5304 break;
5305 default:
5306 speed_str = "?";
5307 break;
5308 }
5309 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5310 0, dev->addr, speed_str, dev->devname);
5311 }
5312 }
5313
5314 /***********************************************************/
5315 /* PCMCIA/Cardbus */
5316
5317 static struct pcmcia_socket_entry_s {
5318 struct pcmcia_socket_s *socket;
5319 struct pcmcia_socket_entry_s *next;
5320 } *pcmcia_sockets = 0;
5321
5322 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5323 {
5324 struct pcmcia_socket_entry_s *entry;
5325
5326 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5327 entry->socket = socket;
5328 entry->next = pcmcia_sockets;
5329 pcmcia_sockets = entry;
5330 }
5331
5332 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5333 {
5334 struct pcmcia_socket_entry_s *entry, **ptr;
5335
5336 ptr = &pcmcia_sockets;
5337 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5338 if (entry->socket == socket) {
5339 *ptr = entry->next;
5340 qemu_free(entry);
5341 }
5342 }
5343
5344 void pcmcia_info(void)
5345 {
5346 struct pcmcia_socket_entry_s *iter;
5347 if (!pcmcia_sockets)
5348 term_printf("No PCMCIA sockets\n");
5349
5350 for (iter = pcmcia_sockets; iter; iter = iter->next)
5351 term_printf("%s: %s\n", iter->socket->slot_string,
5352 iter->socket->attached ? iter->socket->card_string :
5353 "Empty");
5354 }
5355
5356 /***********************************************************/
5357 /* dumb display */
5358
5359 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
5360 {
5361 }
5362
5363 static void dumb_resize(DisplayState *ds, int w, int h)
5364 {
5365 }
5366
5367 static void dumb_refresh(DisplayState *ds)
5368 {
5369 #if defined(CONFIG_SDL)
5370 vga_hw_update();
5371 #endif
5372 }
5373
5374 static void dumb_display_init(DisplayState *ds)
5375 {
5376 ds->data = NULL;
5377 ds->linesize = 0;
5378 ds->depth = 0;
5379 ds->dpy_update = dumb_update;
5380 ds->dpy_resize = dumb_resize;
5381 ds->dpy_refresh = dumb_refresh;
5382 }
5383
5384 /***********************************************************/
5385 /* I/O handling */
5386
5387 #define MAX_IO_HANDLERS 64
5388
5389 typedef struct IOHandlerRecord {
5390 int fd;
5391 IOCanRWHandler *fd_read_poll;
5392 IOHandler *fd_read;
5393 IOHandler *fd_write;
5394 int deleted;
5395 void *opaque;
5396 /* temporary data */
5397 struct pollfd *ufd;
5398 struct IOHandlerRecord *next;
5399 } IOHandlerRecord;
5400
5401 static IOHandlerRecord *first_io_handler;
5402
5403 /* XXX: fd_read_poll should be suppressed, but an API change is
5404 necessary in the character devices to suppress fd_can_read(). */
5405 int qemu_set_fd_handler2(int fd,
5406 IOCanRWHandler *fd_read_poll,
5407 IOHandler *fd_read,
5408 IOHandler *fd_write,
5409 void *opaque)
5410 {
5411 IOHandlerRecord **pioh, *ioh;
5412
5413 if (!fd_read && !fd_write) {
5414 pioh = &first_io_handler;
5415 for(;;) {
5416 ioh = *pioh;
5417 if (ioh == NULL)
5418 break;
5419 if (ioh->fd == fd) {
5420 ioh->deleted = 1;
5421 break;
5422 }
5423 pioh = &ioh->next;
5424 }
5425 } else {
5426 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5427 if (ioh->fd == fd)
5428 goto found;
5429 }
5430 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
5431 if (!ioh)
5432 return -1;
5433 ioh->next = first_io_handler;
5434 first_io_handler = ioh;
5435 found:
5436 ioh->fd = fd;
5437 ioh->fd_read_poll = fd_read_poll;
5438 ioh->fd_read = fd_read;
5439 ioh->fd_write = fd_write;
5440 ioh->opaque = opaque;
5441 ioh->deleted = 0;
5442 }
5443 return 0;
5444 }
5445
5446 int qemu_set_fd_handler(int fd,
5447 IOHandler *fd_read,
5448 IOHandler *fd_write,
5449 void *opaque)
5450 {
5451 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
5452 }
5453
5454 /***********************************************************/
5455 /* Polling handling */
5456
5457 typedef struct PollingEntry {
5458 PollingFunc *func;
5459 void *opaque;
5460 struct PollingEntry *next;
5461 } PollingEntry;
5462
5463 static PollingEntry *first_polling_entry;
5464
5465 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
5466 {
5467 PollingEntry **ppe, *pe;
5468 pe = qemu_mallocz(sizeof(PollingEntry));
5469 if (!pe)
5470 return -1;
5471 pe->func = func;
5472 pe->opaque = opaque;
5473 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
5474 *ppe = pe;
5475 return 0;
5476 }
5477
5478 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
5479 {
5480 PollingEntry **ppe, *pe;
5481 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
5482 pe = *ppe;
5483 if (pe->func == func && pe->opaque == opaque) {
5484 *ppe = pe->next;
5485 qemu_free(pe);
5486 break;
5487 }
5488 }
5489 }
5490
5491 #ifdef _WIN32
5492 /***********************************************************/
5493 /* Wait objects support */
5494 typedef struct WaitObjects {
5495 int num;
5496 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
5497 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
5498 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
5499 } WaitObjects;
5500
5501 static WaitObjects wait_objects = {0};
5502
5503 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5504 {
5505 WaitObjects *w = &wait_objects;
5506
5507 if (w->num >= MAXIMUM_WAIT_OBJECTS)
5508 return -1;
5509 w->events[w->num] = handle;
5510 w->func[w->num] = func;
5511 w->opaque[w->num] = opaque;
5512 w->num++;
5513 return 0;
5514 }
5515
5516 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5517 {
5518 int i, found;
5519 WaitObjects *w = &wait_objects;
5520
5521 found = 0;
5522 for (i = 0; i < w->num; i++) {
5523 if (w->events[i] == handle)
5524 found = 1;
5525 if (found) {
5526 w->events[i] = w->events[i + 1];
5527 w->func[i] = w->func[i + 1];
5528 w->opaque[i] = w->opaque[i + 1];
5529 }
5530 }
5531 if (found)
5532 w->num--;
5533 }
5534 #endif
5535
5536 #define SELF_ANNOUNCE_ROUNDS 5
5537 #define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
5538 //#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
5539 #define EXPERIMENTAL_MAGIC 0xf1f23f4f
5540
5541 static int announce_self_create(uint8_t *buf,
5542 uint8_t *mac_addr)
5543 {
5544 uint32_t magic = EXPERIMENTAL_MAGIC;
5545 uint16_t proto = htons(ETH_P_EXPERIMENTAL);
5546
5547 /* FIXME: should we send a different packet (arp/rarp/ping)? */
5548
5549 memset(buf, 0xff, 6); /* h_dst */
5550 memcpy(buf + 6, mac_addr, 6); /* h_src */
5551 memcpy(buf + 12, &proto, 2); /* h_proto */
5552 memcpy(buf + 14, &magic, 4); /* magic */
5553
5554 return 18; /* len */
5555 }
5556
5557 static void qemu_announce_self(void)
5558 {
5559 int i, j, len;
5560 VLANState *vlan;
5561 VLANClientState *vc;
5562 uint8_t buf[256];
5563
5564 for (i = 0; i < nb_nics; i++) {
5565 len = announce_self_create(buf, nd_table[i].macaddr);
5566 vlan = nd_table[i].vlan;
5567 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
5568 if (vc->fd_read == tap_receive) /* send only if tap */
5569 for (j=0; j < SELF_ANNOUNCE_ROUNDS; j++)
5570 vc->fd_read(vc->opaque, buf, len);
5571 }
5572 }
5573 }
5574
5575 /***********************************************************/
5576 /* savevm/loadvm support */
5577
5578 #define IO_BUF_SIZE 32768
5579
5580 struct QEMUFile {
5581 QEMUFilePutBufferFunc *put_buffer;
5582 QEMUFileGetBufferFunc *get_buffer;
5583 QEMUFileCloseFunc *close;
5584 void *opaque;
5585
5586 int64_t buf_offset; /* start of buffer when writing, end of buffer
5587 when reading */
5588 int buf_index;
5589 int buf_size; /* 0 when writing */
5590 uint8_t buf[IO_BUF_SIZE];
5591 };
5592
5593 typedef struct QEMUFileFD
5594 {
5595 int fd;
5596 } QEMUFileFD;
5597
5598 static int fd_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
5599 {
5600 QEMUFileFD *s = opaque;
5601 int offset = 0;
5602 ssize_t len;
5603
5604 again:
5605 len = read(s->fd, buf + offset, size - offset);
5606 if (len == -1) {
5607 if (errno == EINTR || errno == EAGAIN)
5608 goto again;
5609 }
5610
5611 return len;
5612 }
5613
5614 QEMUFile *qemu_fopen_fd(int fd)
5615 {
5616 QEMUFileFD *s = qemu_mallocz(sizeof(QEMUFileFD));
5617 s->fd = fd;
5618 return qemu_fopen(s, NULL, fd_get_buffer, qemu_free);
5619 }
5620
5621 typedef struct QEMUFileUnix
5622 {
5623 FILE *outfile;
5624 } QEMUFileUnix;
5625
5626 static void file_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
5627 {
5628 QEMUFileUnix *s = opaque;
5629 fseek(s->outfile, pos, SEEK_SET);
5630 fwrite(buf, 1, size, s->outfile);
5631 }
5632
5633 static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
5634 {
5635 QEMUFileUnix *s = opaque;
5636 fseek(s->outfile, pos, SEEK_SET);
5637 return fread(buf, 1, size, s->outfile);
5638 }
5639
5640 static void file_close(void *opaque)
5641 {
5642 QEMUFileUnix *s = opaque;
5643 fclose(s->outfile);
5644 qemu_free(s);
5645 }
5646
5647 QEMUFile *qemu_fopen_file(const char *filename, const char *mode)
5648 {
5649 QEMUFileUnix *s;
5650
5651 s = qemu_mallocz(sizeof(QEMUFileUnix));
5652 if (!s)
5653 return NULL;
5654
5655 s->outfile = fopen(filename, mode);
5656 if (!s->outfile)
5657 goto fail;
5658
5659 if (!strcmp(mode, "wb"))
5660 return qemu_fopen(s, file_put_buffer, NULL, file_close);
5661 else if (!strcmp(mode, "rb"))
5662 return qemu_fopen(s, NULL, file_get_buffer, file_close);
5663
5664 fail:
5665 if (s->outfile)
5666 fclose(s->outfile);
5667 qemu_free(s);
5668 return NULL;
5669 }
5670
5671 typedef struct QEMUFileBdrv
5672 {
5673 BlockDriverState *bs;
5674 int64_t base_offset;
5675 } QEMUFileBdrv;
5676
5677 static void bdrv_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
5678 {
5679 QEMUFileBdrv *s = opaque;
5680 bdrv_pwrite(s->bs, s->base_offset + pos, buf, size);
5681 }
5682
5683 static int bdrv_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
5684 {
5685 QEMUFileBdrv *s = opaque;
5686 return bdrv_pread(s->bs, s->base_offset + pos, buf, size);
5687 }
5688
5689 QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5690 {
5691 QEMUFileBdrv *s;
5692
5693 s = qemu_mallocz(sizeof(QEMUFileBdrv));
5694 if (!s)
5695 return NULL;
5696
5697 s->bs = bs;
5698 s->base_offset = offset;
5699
5700 if (is_writable)
5701 return qemu_fopen(s, bdrv_put_buffer, NULL, qemu_free);
5702
5703 return qemu_fopen(s, NULL, bdrv_get_buffer, qemu_free);
5704 }
5705
5706 QEMUFile *qemu_fopen(void *opaque, QEMUFilePutBufferFunc *put_buffer,
5707 QEMUFileGetBufferFunc *get_buffer, QEMUFileCloseFunc *close)
5708 {
5709 QEMUFile *f;
5710
5711 f = qemu_mallocz(sizeof(QEMUFile));
5712 if (!f)
5713 return NULL;
5714
5715 f->opaque = opaque;
5716 f->put_buffer = put_buffer;
5717 f->get_buffer = get_buffer;
5718 f->close = close;
5719
5720 return f;
5721 }
5722
5723 void qemu_fflush(QEMUFile *f)
5724 {
5725 if (!f->put_buffer)
5726 return;
5727
5728 if (f->buf_index > 0) {
5729 f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
5730 f->buf_offset += f->buf_index;
5731 f->buf_index = 0;
5732 }
5733 }
5734
5735 static void qemu_fill_buffer(QEMUFile *f)
5736 {
5737 int len;
5738
5739 if (!f->get_buffer)
5740 return;
5741
5742 len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
5743 if (len < 0)
5744 len = 0;
5745
5746 f->buf_index = 0;
5747 f->buf_size = len;
5748 f->buf_offset += len;
5749 }
5750
5751 void qemu_fclose(QEMUFile *f)
5752 {
5753 qemu_fflush(f);
5754 if (f->close)
5755 f->close(f->opaque);
5756 qemu_free(f);
5757 }
5758
5759 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
5760 {
5761 int l;
5762 while (size > 0) {
5763 l = IO_BUF_SIZE - f->buf_index;
5764 if (l > size)
5765 l = size;
5766 memcpy(f->buf + f->buf_index, buf, l);
5767 f->buf_index += l;
5768 buf += l;
5769 size -= l;
5770 if (f->buf_index >= IO_BUF_SIZE)
5771 qemu_fflush(f);
5772 }
5773 }
5774
5775 void qemu_put_byte(QEMUFile *f, int v)
5776 {
5777 f->buf[f->buf_index++] = v;
5778 if (f->buf_index >= IO_BUF_SIZE)
5779 qemu_fflush(f);
5780 }
5781
5782 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
5783 {
5784 int size, l;
5785
5786 size = size1;
5787 while (size > 0) {
5788 l = f->buf_size - f->buf_index;
5789 if (l == 0) {
5790 qemu_fill_buffer(f);
5791 l = f->buf_size - f->buf_index;
5792 if (l == 0)
5793 break;
5794 }
5795 if (l > size)
5796 l = size;
5797 memcpy(buf, f->buf + f->buf_index, l);
5798 f->buf_index += l;
5799 buf += l;
5800 size -= l;
5801 }
5802 return size1 - size;
5803 }
5804
5805 int qemu_get_byte(QEMUFile *f)
5806 {
5807 if (f->buf_index >= f->buf_size) {
5808 qemu_fill_buffer(f);
5809 if (f->buf_index >= f->buf_size)
5810 return 0;
5811 }
5812 return f->buf[f->buf_index++];
5813 }
5814
5815 int64_t qemu_ftell(QEMUFile *f)
5816 {
5817 return f->buf_offset - f->buf_size + f->buf_index;
5818 }
5819
5820 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
5821 {
5822 if (whence == SEEK_SET) {
5823 /* nothing to do */
5824 } else if (whence == SEEK_CUR) {
5825 pos += qemu_ftell(f);
5826 } else {
5827 /* SEEK_END not supported */
5828 return -1;
5829 }
5830 if (f->put_buffer) {
5831 qemu_fflush(f);
5832 f->buf_offset = pos;
5833 } else {
5834 f->buf_offset = pos;
5835 f->buf_index = 0;
5836 f->buf_size = 0;
5837 }
5838 return pos;
5839 }
5840
5841 void qemu_put_be16(QEMUFile *f, unsigned int v)
5842 {
5843 qemu_put_byte(f, v >> 8);
5844 qemu_put_byte(f, v);
5845 }
5846
5847 void qemu_put_be32(QEMUFile *f, unsigned int v)
5848 {
5849 qemu_put_byte(f, v >> 24);
5850 qemu_put_byte(f, v >> 16);
5851 qemu_put_byte(f, v >> 8);
5852 qemu_put_byte(f, v);
5853 }
5854
5855 void qemu_put_be64(QEMUFile *f, uint64_t v)
5856 {
5857 qemu_put_be32(f, v >> 32);
5858 qemu_put_be32(f, v);
5859 }
5860
5861 unsigned int qemu_get_be16(QEMUFile *f)
5862 {
5863 unsigned int v;
5864 v = qemu_get_byte(f) << 8;
5865 v |= qemu_get_byte(f);
5866 return v;
5867 }
5868
5869 unsigned int qemu_get_be32(QEMUFile *f)
5870 {
5871 unsigned int v;
5872 v = qemu_get_byte(f) << 24;
5873 v |= qemu_get_byte(f) << 16;
5874 v |= qemu_get_byte(f) << 8;
5875 v |= qemu_get_byte(f);
5876 return v;
5877 }
5878
5879 uint64_t qemu_get_be64(QEMUFile *f)
5880 {
5881 uint64_t v;
5882 v = (uint64_t)qemu_get_be32(f) << 32;
5883 v |= qemu_get_be32(f);
5884 return v;
5885 }
5886
5887 typedef struct SaveStateEntry {
5888 char idstr[256];
5889 int instance_id;
5890 int version_id;
5891 SaveStateHandler *save_state;
5892 LoadStateHandler *load_state;
5893 void *opaque;
5894 struct SaveStateEntry *next;
5895 } SaveStateEntry;
5896
5897 static SaveStateEntry *first_se;
5898
5899 int register_savevm(const char *idstr,
5900 int instance_id,
5901 int version_id,
5902 SaveStateHandler *save_state,
5903 LoadStateHandler *load_state,
5904 void *opaque)
5905 {
5906 SaveStateEntry *se, **pse;
5907
5908 se = qemu_malloc(sizeof(SaveStateEntry));
5909 if (!se)
5910 return -1;
5911 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
5912 se->instance_id = instance_id;
5913 se->version_id = version_id;
5914 se->save_state = save_state;
5915 se->load_state = load_state;
5916 se->opaque = opaque;
5917 se->next = NULL;
5918
5919 /* add at the end of list */
5920 pse = &first_se;
5921 while (*pse != NULL)
5922 pse = &(*pse)->next;
5923 *pse = se;
5924 return 0;
5925 }
5926
5927 #define QEMU_VM_FILE_MAGIC 0x5145564d
5928 #define QEMU_VM_FILE_VERSION 0x00000002
5929
5930 static int qemu_savevm_state(QEMUFile *f)
5931 {
5932 SaveStateEntry *se;
5933 int len, ret;
5934 int64_t cur_pos, len_pos, total_len_pos;
5935
5936 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
5937 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
5938 total_len_pos = qemu_ftell(f);
5939 qemu_put_be64(f, 0); /* total size */
5940
5941 for(se = first_se; se != NULL; se = se->next) {
5942 /* ID string */
5943 len = strlen(se->idstr);
5944 qemu_put_byte(f, len);
5945 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
5946
5947 qemu_put_be32(f, se->instance_id);
5948 qemu_put_be32(f, se->version_id);
5949
5950 /* record size: filled later */
5951 len_pos = qemu_ftell(f);
5952 qemu_put_be32(f, 0);
5953 se->save_state(f, se->opaque);
5954
5955 /* fill record size */
5956 cur_pos = qemu_ftell(f);
5957 len = cur_pos - len_pos - 4;
5958 qemu_fseek(f, len_pos, SEEK_SET);
5959 qemu_put_be32(f, len);
5960 qemu_fseek(f, cur_pos, SEEK_SET);
5961 }
5962 cur_pos = qemu_ftell(f);
5963 qemu_fseek(f, total_len_pos, SEEK_SET);
5964 qemu_put_be64(f, cur_pos - total_len_pos - 8);
5965 qemu_fseek(f, cur_pos, SEEK_SET);
5966
5967 ret = 0;
5968 return ret;
5969 }
5970
5971 static SaveStateEntry *find_se(const char *idstr, int instance_id)
5972 {
5973 SaveStateEntry *se;
5974
5975 for(se = first_se; se != NULL; se = se->next) {
5976 if (!strcmp(se->idstr, idstr) &&
5977 instance_id == se->instance_id)
5978 return se;
5979 }
5980 return NULL;
5981 }
5982
5983 static int qemu_loadvm_state(QEMUFile *f)
5984 {
5985 SaveStateEntry *se;
5986 int len, ret, instance_id, record_len, version_id;
5987 int64_t total_len, end_pos, cur_pos;
5988 unsigned int v;
5989 char idstr[256];
5990
5991 v = qemu_get_be32(f);
5992 if (v != QEMU_VM_FILE_MAGIC)
5993 goto fail;
5994 v = qemu_get_be32(f);
5995 if (v != QEMU_VM_FILE_VERSION) {
5996 fail:
5997 ret = -1;
5998 goto the_end;
5999 }
6000 total_len = qemu_get_be64(f);
6001 end_pos = total_len + qemu_ftell(f);
6002 for(;;) {
6003 if (qemu_ftell(f) >= end_pos)
6004 break;
6005 len = qemu_get_byte(f);
6006 qemu_get_buffer(f, (uint8_t *)idstr, len);
6007 idstr[len] = '\0';
6008 instance_id = qemu_get_be32(f);
6009 version_id = qemu_get_be32(f);
6010 record_len = qemu_get_be32(f);
6011 #if 0
6012 printf("idstr=%s instance=0x%x version=%d len=%d\n",
6013 idstr, instance_id, version_id, record_len);
6014 #endif
6015 cur_pos = qemu_ftell(f);
6016 se = find_se(idstr, instance_id);
6017 if (!se) {
6018 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6019 instance_id, idstr);
6020 } else {
6021 ret = se->load_state(f, se->opaque, version_id);
6022 if (ret < 0) {
6023 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6024 instance_id, idstr);
6025 goto the_end;
6026 }
6027 }
6028 /* always seek to exact end of record */
6029 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
6030 }
6031 ret = 0;
6032 the_end:
6033 return ret;
6034 }
6035
6036 int qemu_live_savevm_state(QEMUFile *f)
6037 {
6038 SaveStateEntry *se;
6039 int len, ret;
6040
6041 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
6042 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
6043
6044 for(se = first_se; se != NULL; se = se->next) {
6045 len = strlen(se->idstr);
6046
6047 qemu_put_byte(f, len);
6048 qemu_put_buffer(f, se->idstr, len);
6049 qemu_put_be32(f, se->instance_id);
6050 qemu_put_be32(f, se->version_id);
6051
6052 se->save_state(f, se->opaque);
6053 }
6054
6055 qemu_put_byte(f, 0);
6056
6057 ret = 0;
6058 return ret;
6059 }
6060
6061 int qemu_live_loadvm_state(QEMUFile *f)
6062 {
6063 SaveStateEntry *se;
6064 int len, ret, instance_id, version_id;
6065 unsigned int v;
6066 char idstr[256];
6067
6068 v = qemu_get_be32(f);
6069 if (v != QEMU_VM_FILE_MAGIC)
6070 goto fail;
6071 v = qemu_get_be32(f);
6072 if (v != QEMU_VM_FILE_VERSION) {
6073 fail:
6074 ret = -1;
6075 goto the_end;
6076 }
6077
6078 for(;;) {
6079 len = qemu_get_byte(f);
6080 if (len == 0)
6081 break;
6082 qemu_get_buffer(f, idstr, len);
6083 idstr[len] = '\0';
6084 instance_id = qemu_get_be32(f);
6085 version_id = qemu_get_be32(f);
6086 se = find_se(idstr, instance_id);
6087 if (!se) {
6088 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6089 instance_id, idstr);
6090 } else {
6091 if (version_id > se->version_id) { /* src version > dst version */
6092 fprintf(stderr, "migration:version mismatch:%s:%d(s)>%d(d)\n",
6093 idstr, version_id, se->version_id);
6094 ret = -1;
6095 goto the_end;
6096 }
6097 ret = se->load_state(f, se->opaque, version_id);
6098 if (ret < 0) {
6099 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6100 instance_id, idstr);
6101 goto the_end;
6102 }
6103 }
6104 }
6105 ret = 0;
6106
6107 qemu_announce_self();
6108
6109 the_end:
6110 return ret;
6111 }
6112
6113 /* device can contain snapshots */
6114 static int bdrv_can_snapshot(BlockDriverState *bs)
6115 {
6116 return (bs &&
6117 !bdrv_is_removable(bs) &&
6118 !bdrv_is_read_only(bs));
6119 }
6120
6121 /* device must be snapshots in order to have a reliable snapshot */
6122 static int bdrv_has_snapshot(BlockDriverState *bs)
6123 {
6124 return (bs &&
6125 !bdrv_is_removable(bs) &&
6126 !bdrv_is_read_only(bs));
6127 }
6128
6129 static BlockDriverState *get_bs_snapshots(void)
6130 {
6131 BlockDriverState *bs;
6132 int i;
6133
6134 if (bs_snapshots)
6135 return bs_snapshots;
6136 for(i = 0; i <= nb_drives; i++) {
6137 bs = drives_table[i].bdrv;
6138 if (bdrv_can_snapshot(bs))
6139 goto ok;
6140 }
6141 return NULL;
6142 ok:
6143 bs_snapshots = bs;
6144 return bs;
6145 }
6146
6147 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6148 const char *name)
6149 {
6150 QEMUSnapshotInfo *sn_tab, *sn;
6151 int nb_sns, i, ret;
6152
6153 ret = -ENOENT;
6154 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6155 if (nb_sns < 0)
6156 return ret;
6157 for(i = 0; i < nb_sns; i++) {
6158 sn = &sn_tab[i];
6159 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6160 *sn_info = *sn;
6161 ret = 0;
6162 break;
6163 }
6164 }
6165 qemu_free(sn_tab);
6166 return ret;
6167 }
6168
6169 void do_savevm(const char *name)
6170 {
6171 BlockDriverState *bs, *bs1;
6172 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6173 int must_delete, ret, i;
6174 BlockDriverInfo bdi1, *bdi = &bdi1;
6175 QEMUFile *f;
6176 int saved_vm_running;
6177 #ifdef _WIN32
6178 struct _timeb tb;
6179 #else
6180 struct timeval tv;
6181 #endif
6182
6183 bs = get_bs_snapshots();
6184 if (!bs) {
6185 term_printf("No block device can accept snapshots\n");
6186 return;
6187 }
6188
6189 /* ??? Should this occur after vm_stop? */
6190 qemu_aio_flush();
6191
6192 saved_vm_running = vm_running;
6193 vm_stop(0);
6194
6195 must_delete = 0;
6196 if (name) {
6197 ret = bdrv_snapshot_find(bs, old_sn, name);
6198 if (ret >= 0) {
6199 must_delete = 1;
6200 }
6201 }
6202 memset(sn, 0, sizeof(*sn));
6203 if (must_delete) {
6204 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6205 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6206 } else {
6207 if (name)
6208 pstrcpy(sn->name, sizeof(sn->name), name);
6209 }
6210
6211 /* fill auxiliary fields */
6212 #ifdef _WIN32
6213 _ftime(&tb);
6214 sn->date_sec = tb.time;
6215 sn->date_nsec = tb.millitm * 1000000;
6216 #else
6217 gettimeofday(&tv, NULL);
6218 sn->date_sec = tv.tv_sec;
6219 sn->date_nsec = tv.tv_usec * 1000;
6220 #endif
6221 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6222
6223 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6224 term_printf("Device %s does not support VM state snapshots\n",
6225 bdrv_get_device_name(bs));
6226 goto the_end;
6227 }
6228
6229 /* save the VM state */
6230 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6231 if (!f) {
6232 term_printf("Could not open VM state file\n");
6233 goto the_end;
6234 }
6235 ret = qemu_savevm_state(f);
6236 sn->vm_state_size = qemu_ftell(f);
6237 qemu_fclose(f);
6238 if (ret < 0) {
6239 term_printf("Error %d while writing VM\n", ret);
6240 goto the_end;
6241 }
6242
6243 /* create the snapshots */
6244
6245 for(i = 0; i < nb_drives; i++) {
6246 bs1 = drives_table[i].bdrv;
6247 if (bdrv_has_snapshot(bs1)) {
6248 if (must_delete) {
6249 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6250 if (ret < 0) {
6251 term_printf("Error while deleting snapshot on '%s'\n",
6252 bdrv_get_device_name(bs1));
6253 }
6254 }
6255 ret = bdrv_snapshot_create(bs1, sn);
6256 if (ret < 0) {
6257 term_printf("Error while creating snapshot on '%s'\n",
6258 bdrv_get_device_name(bs1));
6259 }
6260 }
6261 }
6262
6263 the_end:
6264 if (saved_vm_running)
6265 vm_start();
6266 }
6267
6268 void do_loadvm(const char *name)
6269 {
6270 BlockDriverState *bs, *bs1;
6271 BlockDriverInfo bdi1, *bdi = &bdi1;
6272 QEMUFile *f;
6273 int i, ret;
6274 int saved_vm_running;
6275
6276 bs = get_bs_snapshots();
6277 if (!bs) {
6278 term_printf("No block device supports snapshots\n");
6279 return;
6280 }
6281
6282 /* Flush all IO requests so they don't interfere with the new state. */
6283 qemu_aio_flush();
6284
6285 saved_vm_running = vm_running;
6286 vm_stop(0);
6287
6288 for(i = 0; i <= nb_drives; i++) {
6289 bs1 = drives_table[i].bdrv;
6290 if (bdrv_has_snapshot(bs1)) {
6291 ret = bdrv_snapshot_goto(bs1, name);
6292 if (ret < 0) {
6293 if (bs != bs1)
6294 term_printf("Warning: ");
6295 switch(ret) {
6296 case -ENOTSUP:
6297 term_printf("Snapshots not supported on device '%s'\n",
6298 bdrv_get_device_name(bs1));
6299 break;
6300 case -ENOENT:
6301 term_printf("Could not find snapshot '%s' on device '%s'\n",
6302 name, bdrv_get_device_name(bs1));
6303 break;
6304 default:
6305 term_printf("Error %d while activating snapshot on '%s'\n",
6306 ret, bdrv_get_device_name(bs1));
6307 break;
6308 }
6309 /* fatal on snapshot block device */
6310 if (bs == bs1)
6311 goto the_end;
6312 }
6313 }
6314 }
6315
6316 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6317 term_printf("Device %s does not support VM state snapshots\n",
6318 bdrv_get_device_name(bs));
6319 return;
6320 }
6321
6322 /* restore the VM state */
6323 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6324 if (!f) {
6325 term_printf("Could not open VM state file\n");
6326 goto the_end;
6327 }
6328 ret = qemu_loadvm_state(f);
6329 qemu_fclose(f);
6330 if (ret < 0) {
6331 term_printf("Error %d while loading VM state\n", ret);
6332 }
6333 the_end:
6334 if (saved_vm_running)
6335 vm_start();
6336 }
6337
6338 void do_delvm(const char *name)
6339 {
6340 BlockDriverState *bs, *bs1;
6341 int i, ret;
6342
6343 bs = get_bs_snapshots();
6344 if (!bs) {
6345 term_printf("No block device supports snapshots\n");
6346 return;
6347 }
6348
6349 for(i = 0; i <= nb_drives; i++) {
6350 bs1 = drives_table[i].bdrv;
6351 if (bdrv_has_snapshot(bs1)) {
6352 ret = bdrv_snapshot_delete(bs1, name);
6353 if (ret < 0) {
6354 if (ret == -ENOTSUP)
6355 term_printf("Snapshots not supported on device '%s'\n",
6356 bdrv_get_device_name(bs1));
6357 else
6358 term_printf("Error %d while deleting snapshot on '%s'\n",
6359 ret, bdrv_get_device_name(bs1));
6360 }
6361 }
6362 }
6363 }
6364
6365 void do_info_snapshots(void)
6366 {
6367 BlockDriverState *bs, *bs1;
6368 QEMUSnapshotInfo *sn_tab, *sn;
6369 int nb_sns, i;
6370 char buf[256];
6371
6372 bs = get_bs_snapshots();
6373 if (!bs) {
6374 term_printf("No available block device supports snapshots\n");
6375 return;
6376 }
6377 term_printf("Snapshot devices:");
6378 for(i = 0; i <= nb_drives; i++) {
6379 bs1 = drives_table[i].bdrv;
6380 if (bdrv_has_snapshot(bs1)) {
6381 if (bs == bs1)
6382 term_printf(" %s", bdrv_get_device_name(bs1));
6383 }
6384 }
6385 term_printf("\n");
6386
6387 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6388 if (nb_sns < 0) {
6389 term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
6390 return;
6391 }
6392 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
6393 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
6394 for(i = 0; i < nb_sns; i++) {
6395 sn = &sn_tab[i];
6396 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
6397 }
6398 qemu_free(sn_tab);
6399 }
6400
6401 /***********************************************************/
6402 /* cpu save/restore */
6403
6404 #if defined(TARGET_I386)
6405
6406 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
6407 {
6408 qemu_put_be32(f, dt->selector);
6409 qemu_put_betl(f, dt->base);
6410 qemu_put_be32(f, dt->limit);
6411 qemu_put_be32(f, dt->flags);
6412 }
6413
6414 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
6415 {
6416 dt->selector = qemu_get_be32(f);
6417 dt->base = qemu_get_betl(f);
6418 dt->limit = qemu_get_be32(f);
6419 dt->flags = qemu_get_be32(f);
6420 }
6421
6422 void cpu_save(QEMUFile *f, void *opaque)
6423 {
6424 CPUState *env = opaque;
6425 uint16_t fptag, fpus, fpuc, fpregs_format;
6426 uint32_t hflags;
6427 int i;
6428
6429 #ifdef USE_KVM
6430 if (kvm_allowed)
6431 kvm_save_registers(env);
6432 #endif
6433
6434 for(i = 0; i < CPU_NB_REGS; i++)
6435 qemu_put_betls(f, &env->regs[i]);
6436 qemu_put_betls(f, &env->eip);
6437 qemu_put_betls(f, &env->eflags);
6438 hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
6439 qemu_put_be32s(f, &hflags);
6440
6441 /* FPU */
6442 fpuc = env->fpuc;
6443 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
6444 fptag = 0;
6445 for(i = 0; i < 8; i++) {
6446 fptag |= ((!env->fptags[i]) << i);
6447 }
6448
6449 qemu_put_be16s(f, &fpuc);
6450 qemu_put_be16s(f, &fpus);
6451 qemu_put_be16s(f, &fptag);
6452
6453 #ifdef USE_X86LDOUBLE
6454 fpregs_format = 0;
6455 #else
6456 fpregs_format = 1;
6457 #endif
6458 qemu_put_be16s(f, &fpregs_format);
6459
6460 for(i = 0; i < 8; i++) {
6461 #ifdef USE_X86LDOUBLE
6462 {
6463 uint64_t mant;
6464 uint16_t exp;
6465 /* we save the real CPU data (in case of MMX usage only 'mant'
6466 contains the MMX register */
6467 cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
6468 qemu_put_be64(f, mant);
6469 qemu_put_be16(f, exp);
6470 }
6471 #else
6472 /* if we use doubles for float emulation, we save the doubles to
6473 avoid losing information in case of MMX usage. It can give
6474 problems if the image is restored on a CPU where long
6475 doubles are used instead. */
6476 qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
6477 #endif
6478 }
6479
6480 for(i = 0; i < 6; i++)
6481 cpu_put_seg(f, &env->segs[i]);
6482 cpu_put_seg(f, &env->ldt);
6483 cpu_put_seg(f, &env->tr);
6484 cpu_put_seg(f, &env->gdt);
6485 cpu_put_seg(f, &env->idt);
6486
6487 qemu_put_be32s(f, &env->sysenter_cs);
6488 qemu_put_be32s(f, &env->sysenter_esp);
6489 qemu_put_be32s(f, &env->sysenter_eip);
6490
6491 qemu_put_betls(f, &env->cr[0]);
6492 qemu_put_betls(f, &env->cr[2]);
6493 qemu_put_betls(f, &env->cr[3]);
6494 qemu_put_betls(f, &env->cr[4]);
6495
6496 for(i = 0; i < 8; i++)
6497 qemu_put_betls(f, &env->dr[i]);
6498
6499 /* MMU */
6500 qemu_put_be32s(f, &env->a20_mask);
6501
6502 /* XMM */
6503 qemu_put_be32s(f, &env->mxcsr);
6504 for(i = 0; i < CPU_NB_REGS; i++) {
6505 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6506 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6507 }
6508
6509 #ifdef TARGET_X86_64
6510 qemu_put_be64s(f, &env->efer);
6511 qemu_put_be64s(f, &env->star);
6512 qemu_put_be64s(f, &env->lstar);
6513 qemu_put_be64s(f, &env->cstar);
6514 qemu_put_be64s(f, &env->fmask);
6515 qemu_put_be64s(f, &env->kernelgsbase);
6516 #endif
6517 qemu_put_be32s(f, &env->smbase);
6518
6519 #ifdef USE_KVM
6520 if (kvm_allowed) {
6521 for (i = 0; i < NR_IRQ_WORDS ; i++) {
6522 qemu_put_be32s(f, &env->kvm_interrupt_bitmap[i]);
6523 }
6524 qemu_put_be64s(f, &env->tsc);
6525 }
6526 #endif
6527
6528 }
6529
6530 #ifdef USE_X86LDOUBLE
6531 /* XXX: add that in a FPU generic layer */
6532 union x86_longdouble {
6533 uint64_t mant;
6534 uint16_t exp;
6535 };
6536
6537 #define MANTD1(fp) (fp & ((1LL << 52) - 1))
6538 #define EXPBIAS1 1023
6539 #define EXPD1(fp) ((fp >> 52) & 0x7FF)
6540 #define SIGND1(fp) ((fp >> 32) & 0x80000000)
6541
6542 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
6543 {
6544 int e;
6545 /* mantissa */
6546 p->mant = (MANTD1(temp) << 11) | (1LL << 63);
6547 /* exponent + sign */
6548 e = EXPD1(temp) - EXPBIAS1 + 16383;
6549 e |= SIGND1(temp) >> 16;
6550 p->exp = e;
6551 }
6552 #endif
6553
6554 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6555 {
6556 CPUState *env = opaque;
6557 int i, guess_mmx;
6558 uint32_t hflags;
6559 uint16_t fpus, fpuc, fptag, fpregs_format;
6560
6561 if (version_id != 3 && version_id != 4)
6562 return -EINVAL;
6563 for(i = 0; i < CPU_NB_REGS; i++)
6564 qemu_get_betls(f, &env->regs[i]);
6565 qemu_get_betls(f, &env->eip);
6566 qemu_get_betls(f, &env->eflags);
6567 qemu_get_be32s(f, &hflags);
6568
6569 qemu_get_be16s(f, &fpuc);
6570 qemu_get_be16s(f, &fpus);
6571 qemu_get_be16s(f, &fptag);
6572 qemu_get_be16s(f, &fpregs_format);
6573
6574 /* NOTE: we cannot always restore the FPU state if the image come
6575 from a host with a different 'USE_X86LDOUBLE' define. We guess
6576 if we are in an MMX state to restore correctly in that case. */
6577 guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
6578 for(i = 0; i < 8; i++) {
6579 uint64_t mant;
6580 uint16_t exp;
6581
6582 switch(fpregs_format) {
6583 case 0:
6584 mant = qemu_get_be64(f);
6585 exp = qemu_get_be16(f);
6586 #ifdef USE_X86LDOUBLE
6587 env->fpregs[i].d = cpu_set_fp80(mant, exp);
6588 #else
6589 /* difficult case */
6590 if (guess_mmx)
6591 env->fpregs[i].mmx.MMX_Q(0) = mant;
6592 else
6593 env->fpregs[i].d = cpu_set_fp80(mant, exp);
6594 #endif
6595 break;
6596 case 1:
6597 mant = qemu_get_be64(f);
6598 #ifdef USE_X86LDOUBLE
6599 {
6600 union x86_longdouble *p;
6601 /* difficult case */
6602 p = (void *)&env->fpregs[i];
6603 if (guess_mmx) {
6604 p->mant = mant;
6605 p->exp = 0xffff;
6606 } else {
6607 fp64_to_fp80(p, mant);
6608 }
6609 }
6610 #else
6611 env->fpregs[i].mmx.MMX_Q(0) = mant;
6612 #endif
6613 break;
6614 default:
6615 return -EINVAL;
6616 }
6617 }
6618
6619 env->fpuc = fpuc;
6620 /* XXX: restore FPU round state */
6621 env->fpstt = (fpus >> 11) & 7;
6622 env->fpus = fpus & ~0x3800;
6623 fptag ^= 0xff;
6624 for(i = 0; i < 8; i++) {
6625 env->fptags[i] = (fptag >> i) & 1;
6626 }
6627
6628 for(i = 0; i < 6; i++)
6629 cpu_get_seg(f, &env->segs[i]);
6630 cpu_get_seg(f, &env->ldt);
6631 cpu_get_seg(f, &env->tr);
6632 cpu_get_seg(f, &env->gdt);
6633 cpu_get_seg(f, &env->idt);
6634
6635 qemu_get_be32s(f, &env->sysenter_cs);
6636 qemu_get_be32s(f, &env->sysenter_esp);
6637 qemu_get_be32s(f, &env->sysenter_eip);
6638
6639 qemu_get_betls(f, &env->cr[0]);
6640 qemu_get_betls(f, &env->cr[2]);
6641 qemu_get_betls(f, &env->cr[3]);
6642 qemu_get_betls(f, &env->cr[4]);
6643
6644 for(i = 0; i < 8; i++)
6645 qemu_get_betls(f, &env->dr[i]);
6646
6647 /* MMU */
6648 qemu_get_be32s(f, &env->a20_mask);
6649
6650 qemu_get_be32s(f, &env->mxcsr);
6651 for(i = 0; i < CPU_NB_REGS; i++) {
6652 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6653 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6654 }
6655
6656 #ifdef TARGET_X86_64
6657 qemu_get_be64s(f, &env->efer);
6658 qemu_get_be64s(f, &env->star);
6659 qemu_get_be64s(f, &env->lstar);
6660 qemu_get_be64s(f, &env->cstar);
6661 qemu_get_be64s(f, &env->fmask);
6662 qemu_get_be64s(f, &env->kernelgsbase);
6663 #endif
6664 if (version_id >= 4)
6665 qemu_get_be32s(f, &env->smbase);
6666
6667 /* XXX: compute hflags from scratch, except for CPL and IIF */
6668 env->hflags = hflags;
6669 tlb_flush(env, 1);
6670 #ifdef USE_KVM
6671 if (kvm_allowed) {
6672 /* when in-kernel irqchip is used, HF_HALTED_MASK causes deadlock
6673 because no userspace IRQs will ever clear this flag */
6674 env->hflags &= ~HF_HALTED_MASK;
6675 for (i = 0; i < NR_IRQ_WORDS ; i++) {
6676 qemu_get_be32s(f, &env->kvm_interrupt_bitmap[i]);
6677 }
6678 qemu_get_be64s(f, &env->tsc);
6679 kvm_load_registers(env);
6680 }
6681 #endif
6682 return 0;
6683 }
6684
6685 #elif defined(TARGET_PPC)
6686 void cpu_save(QEMUFile *f, void *opaque)
6687 {
6688 }
6689
6690 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6691 {
6692 return 0;
6693 }
6694
6695 #elif defined(TARGET_MIPS)
6696 void cpu_save(QEMUFile *f, void *opaque)
6697 {
6698 }
6699
6700 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6701 {
6702 return 0;
6703 }
6704
6705 #elif defined(TARGET_SPARC)
6706 void cpu_save(QEMUFile *f, void *opaque)
6707 {
6708 CPUState *env = opaque;
6709 int i;
6710 uint32_t tmp;
6711
6712 for(i = 0; i < 8; i++)
6713 qemu_put_betls(f, &env->gregs[i]);
6714 for(i = 0; i < NWINDOWS * 16; i++)
6715 qemu_put_betls(f, &env->regbase[i]);
6716
6717 /* FPU */
6718 for(i = 0; i < TARGET_FPREGS; i++) {
6719 union {
6720 float32 f;
6721 uint32_t i;
6722 } u;
6723 u.f = env->fpr[i];
6724 qemu_put_be32(f, u.i);
6725 }
6726
6727 qemu_put_betls(f, &env->pc);
6728 qemu_put_betls(f, &env->npc);
6729 qemu_put_betls(f, &env->y);
6730 tmp = GET_PSR(env);
6731 qemu_put_be32(f, tmp);
6732 qemu_put_betls(f, &env->fsr);
6733 qemu_put_betls(f, &env->tbr);
6734 #ifndef TARGET_SPARC64
6735 qemu_put_be32s(f, &env->wim);
6736 /* MMU */
6737 for(i = 0; i < 16; i++)
6738 qemu_put_be32s(f, &env->mmuregs[i]);
6739 #endif
6740 }
6741
6742 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6743 {
6744 CPUState *env = opaque;
6745 int i;
6746 uint32_t tmp;
6747
6748 for(i = 0; i < 8; i++)
6749 qemu_get_betls(f, &env->gregs[i]);
6750 for(i = 0; i < NWINDOWS * 16; i++)
6751 qemu_get_betls(f, &env->regbase[i]);
6752
6753 /* FPU */
6754 for(i = 0; i < TARGET_FPREGS; i++) {
6755 union {
6756 float32 f;
6757 uint32_t i;
6758 } u;
6759 u.i = qemu_get_be32(f);
6760 env->fpr[i] = u.f;
6761 }
6762
6763 qemu_get_betls(f, &env->pc);
6764 qemu_get_betls(f, &env->npc);
6765 qemu_get_betls(f, &env->y);
6766 tmp = qemu_get_be32(f);
6767 env->cwp = 0; /* needed to ensure that the wrapping registers are
6768 correctly updated */
6769 PUT_PSR(env, tmp);
6770 qemu_get_betls(f, &env->fsr);
6771 qemu_get_betls(f, &env->tbr);
6772 #ifndef TARGET_SPARC64
6773 qemu_get_be32s(f, &env->wim);
6774 /* MMU */
6775 for(i = 0; i < 16; i++)
6776 qemu_get_be32s(f, &env->mmuregs[i]);
6777 #endif
6778 tlb_flush(env, 1);
6779 return 0;
6780 }
6781
6782 #elif defined(TARGET_ARM)
6783
6784 void cpu_save(QEMUFile *f, void *opaque)
6785 {
6786 int i;
6787 CPUARMState *env = (CPUARMState *)opaque;
6788
6789 for (i = 0; i < 16; i++) {
6790 qemu_put_be32(f, env->regs[i]);
6791 }
6792 qemu_put_be32(f, cpsr_read(env));
6793 qemu_put_be32(f, env->spsr);
6794 for (i = 0; i < 6; i++) {
6795 qemu_put_be32(f, env->banked_spsr[i]);
6796 qemu_put_be32(f, env->banked_r13[i]);
6797 qemu_put_be32(f, env->banked_r14[i]);
6798 }
6799 for (i = 0; i < 5; i++) {
6800 qemu_put_be32(f, env->usr_regs[i]);
6801 qemu_put_be32(f, env->fiq_regs[i]);
6802 }
6803 qemu_put_be32(f, env->cp15.c0_cpuid);
6804 qemu_put_be32(f, env->cp15.c0_cachetype);
6805 qemu_put_be32(f, env->cp15.c1_sys);
6806 qemu_put_be32(f, env->cp15.c1_coproc);
6807 qemu_put_be32(f, env->cp15.c1_xscaleauxcr);
6808 qemu_put_be32(f, env->cp15.c2_base0);
6809 qemu_put_be32(f, env->cp15.c2_base1);
6810 qemu_put_be32(f, env->cp15.c2_mask);
6811 qemu_put_be32(f, env->cp15.c2_data);
6812 qemu_put_be32(f, env->cp15.c2_insn);
6813 qemu_put_be32(f, env->cp15.c3);
6814 qemu_put_be32(f, env->cp15.c5_insn);
6815 qemu_put_be32(f, env->cp15.c5_data);
6816 for (i = 0; i < 8; i++) {
6817 qemu_put_be32(f, env->cp15.c6_region[i]);
6818 }
6819 qemu_put_be32(f, env->cp15.c6_insn);
6820 qemu_put_be32(f, env->cp15.c6_data);
6821 qemu_put_be32(f, env->cp15.c9_insn);
6822 qemu_put_be32(f, env->cp15.c9_data);
6823 qemu_put_be32(f, env->cp15.c13_fcse);
6824 qemu_put_be32(f, env->cp15.c13_context);
6825 qemu_put_be32(f, env->cp15.c13_tls1);
6826 qemu_put_be32(f, env->cp15.c13_tls2);
6827 qemu_put_be32(f, env->cp15.c13_tls3);
6828 qemu_put_be32(f, env->cp15.c15_cpar);
6829
6830 qemu_put_be32(f, env->features);
6831
6832 if (arm_feature(env, ARM_FEATURE_VFP)) {
6833 for (i = 0; i < 16; i++) {
6834 CPU_DoubleU u;
6835 u.d = env->vfp.regs[i];
6836 qemu_put_be32(f, u.l.upper);
6837 qemu_put_be32(f, u.l.lower);
6838 }
6839 for (i = 0; i < 16; i++) {
6840 qemu_put_be32(f, env->vfp.xregs[i]);
6841 }
6842
6843 /* TODO: Should use proper FPSCR access functions. */
6844 qemu_put_be32(f, env->vfp.vec_len);
6845 qemu_put_be32(f, env->vfp.vec_stride);
6846
6847 if (arm_feature(env, ARM_FEATURE_VFP3)) {
6848 for (i = 16; i < 32; i++) {
6849 CPU_DoubleU u;
6850 u.d = env->vfp.regs[i];
6851 qemu_put_be32(f, u.l.upper);
6852 qemu_put_be32(f, u.l.lower);
6853 }
6854 }
6855 }
6856
6857 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6858 for (i = 0; i < 16; i++) {
6859 qemu_put_be64(f, env->iwmmxt.regs[i]);
6860 }
6861 for (i = 0; i < 16; i++) {
6862 qemu_put_be32(f, env->iwmmxt.cregs[i]);
6863 }
6864 }
6865
6866 if (arm_feature(env, ARM_FEATURE_M)) {
6867 qemu_put_be32(f, env->v7m.other_sp);
6868 qemu_put_be32(f, env->v7m.vecbase);
6869 qemu_put_be32(f, env->v7m.basepri);
6870 qemu_put_be32(f, env->v7m.control);
6871 qemu_put_be32(f, env->v7m.current_sp);
6872 qemu_put_be32(f, env->v7m.exception);
6873 }
6874 }
6875
6876 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6877 {
6878 CPUARMState *env = (CPUARMState *)opaque;
6879 int i;
6880
6881 if (version_id != ARM_CPU_SAVE_VERSION)
6882 return -EINVAL;
6883
6884 for (i = 0; i < 16; i++) {
6885 env->regs[i] = qemu_get_be32(f);
6886 }
6887 cpsr_write(env, qemu_get_be32(f), 0xffffffff);
6888 env->spsr = qemu_get_be32(f);
6889 for (i = 0; i < 6; i++) {
6890 env->banked_spsr[i] = qemu_get_be32(f);
6891 env->banked_r13[i] = qemu_get_be32(f);
6892 env->banked_r14[i] = qemu_get_be32(f);
6893 }
6894 for (i = 0; i < 5; i++) {
6895 env->usr_regs[i] = qemu_get_be32(f);
6896 env->fiq_regs[i] = qemu_get_be32(f);
6897 }
6898 env->cp15.c0_cpuid = qemu_get_be32(f);
6899 env->cp15.c0_cachetype = qemu_get_be32(f);
6900 env->cp15.c1_sys = qemu_get_be32(f);
6901 env->cp15.c1_coproc = qemu_get_be32(f);
6902 env->cp15.c1_xscaleauxcr = qemu_get_be32(f);
6903 env->cp15.c2_base0 = qemu_get_be32(f);
6904 env->cp15.c2_base1 = qemu_get_be32(f);
6905 env->cp15.c2_mask = qemu_get_be32(f);
6906 env->cp15.c2_data = qemu_get_be32(f);
6907 env->cp15.c2_insn = qemu_get_be32(f);
6908 env->cp15.c3 = qemu_get_be32(f);
6909 env->cp15.c5_insn = qemu_get_be32(f);
6910 env->cp15.c5_data = qemu_get_be32(f);
6911 for (i = 0; i < 8; i++) {
6912 env->cp15.c6_region[i] = qemu_get_be32(f);
6913 }
6914 env->cp15.c6_insn = qemu_get_be32(f);
6915 env->cp15.c6_data = qemu_get_be32(f);
6916 env->cp15.c9_insn = qemu_get_be32(f);
6917 env->cp15.c9_data = qemu_get_be32(f);
6918 env->cp15.c13_fcse = qemu_get_be32(f);
6919 env->cp15.c13_context = qemu_get_be32(f);
6920 env->cp15.c13_tls1 = qemu_get_be32(f);
6921 env->cp15.c13_tls2 = qemu_get_be32(f);
6922 env->cp15.c13_tls3 = qemu_get_be32(f);
6923 env->cp15.c15_cpar = qemu_get_be32(f);
6924
6925 env->features = qemu_get_be32(f);
6926
6927 if (arm_feature(env, ARM_FEATURE_VFP)) {
6928 for (i = 0; i < 16; i++) {
6929 CPU_DoubleU u;
6930 u.l.upper = qemu_get_be32(f);
6931 u.l.lower = qemu_get_be32(f);
6932 env->vfp.regs[i] = u.d;
6933 }
6934 for (i = 0; i < 16; i++) {
6935 env->vfp.xregs[i] = qemu_get_be32(f);
6936 }
6937
6938 /* TODO: Should use proper FPSCR access functions. */
6939 env->vfp.vec_len = qemu_get_be32(f);
6940 env->vfp.vec_stride = qemu_get_be32(f);
6941
6942 if (arm_feature(env, ARM_FEATURE_VFP3)) {
6943 for (i = 0; i < 16; i++) {
6944 CPU_DoubleU u;
6945 u.l.upper = qemu_get_be32(f);
6946 u.l.lower = qemu_get_be32(f);
6947 env->vfp.regs[i] = u.d;
6948 }
6949 }
6950 }
6951
6952 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6953 for (i = 0; i < 16; i++) {
6954 env->iwmmxt.regs[i] = qemu_get_be64(f);
6955 }
6956 for (i = 0; i < 16; i++) {
6957 env->iwmmxt.cregs[i] = qemu_get_be32(f);
6958 }
6959 }
6960
6961 if (arm_feature(env, ARM_FEATURE_M)) {
6962 env->v7m.other_sp = qemu_get_be32(f);
6963 env->v7m.vecbase = qemu_get_be32(f);
6964 env->v7m.basepri = qemu_get_be32(f);
6965 env->v7m.control = qemu_get_be32(f);
6966 env->v7m.current_sp = qemu_get_be32(f);
6967 env->v7m.exception = qemu_get_be32(f);
6968 }
6969
6970 return 0;
6971 }
6972
6973 #elif defined(TARGET_IA64)
6974 void cpu_save(QEMUFile *f, void *opaque)
6975 {
6976 }
6977
6978 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6979 {
6980 return 0;
6981 }
6982 #else
6983
6984 //#warning No CPU save/restore functions
6985
6986 #endif
6987
6988 /***********************************************************/
6989 /* ram save/restore */
6990
6991 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
6992 {
6993 int v;
6994
6995 v = qemu_get_byte(f);
6996 switch(v) {
6997 case 0:
6998 if (qemu_get_buffer(f, buf, len) != len)
6999 return -EIO;
7000 break;
7001 case 1:
7002 v = qemu_get_byte(f);
7003 memset(buf, v, len);
7004 break;
7005 default:
7006 return -EINVAL;
7007 }
7008 return 0;
7009 }
7010
7011 static int ram_load_v1(QEMUFile *f, void *opaque)
7012 {
7013 int i, ret;
7014
7015 if (qemu_get_be32(f) != phys_ram_size)
7016 return -EINVAL;
7017 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
7018 #ifdef USE_KVM
7019 if (kvm_allowed && (i>=0xa0000) && (i<0xc0000)) /* do not access video-addresses */
7020 continue;
7021 #endif
7022 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
7023 if (ret)
7024 return ret;
7025 }
7026 return 0;
7027 }
7028
7029 #define BDRV_HASH_BLOCK_SIZE 1024
7030 #define IOBUF_SIZE 4096
7031 #define RAM_CBLOCK_MAGIC 0xfabe
7032
7033 typedef struct RamCompressState {
7034 z_stream zstream;
7035 QEMUFile *f;
7036 uint8_t buf[IOBUF_SIZE];
7037 } RamCompressState;
7038
7039 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
7040 {
7041 int ret;
7042 memset(s, 0, sizeof(*s));
7043 s->f = f;
7044 ret = deflateInit2(&s->zstream, 1,
7045 Z_DEFLATED, 15,
7046 9, Z_DEFAULT_STRATEGY);
7047 if (ret != Z_OK)
7048 return -1;
7049 s->zstream.avail_out = IOBUF_SIZE;
7050 s->zstream.next_out = s->buf;
7051 return 0;
7052 }
7053
7054 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
7055 {
7056 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
7057 qemu_put_be16(s->f, len);
7058 qemu_put_buffer(s->f, buf, len);
7059 }
7060
7061 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
7062 {
7063 int ret;
7064
7065 s->zstream.avail_in = len;
7066 s->zstream.next_in = (uint8_t *)buf;
7067 while (s->zstream.avail_in > 0) {
7068 ret = deflate(&s->zstream, Z_NO_FLUSH);
7069 if (ret != Z_OK)
7070 return -1;
7071 if (s->zstream.avail_out == 0) {
7072 ram_put_cblock(s, s->buf, IOBUF_SIZE);
7073 s->zstream.avail_out = IOBUF_SIZE;
7074 s->zstream.next_out = s->buf;
7075 }
7076 }
7077 return 0;
7078 }
7079
7080 static void ram_compress_close(RamCompressState *s)
7081 {
7082 int len, ret;
7083
7084 /* compress last bytes */
7085 for(;;) {
7086 ret = deflate(&s->zstream, Z_FINISH);
7087 if (ret == Z_OK || ret == Z_STREAM_END) {
7088 len = IOBUF_SIZE - s->zstream.avail_out;
7089 if (len > 0) {
7090 ram_put_cblock(s, s->buf, len);
7091 }
7092 s->zstream.avail_out = IOBUF_SIZE;
7093 s->zstream.next_out = s->buf;
7094 if (ret == Z_STREAM_END)
7095 break;
7096 } else {
7097 goto fail;
7098 }
7099 }
7100 fail:
7101 deflateEnd(&s->zstream);
7102 }
7103
7104 typedef struct RamDecompressState {
7105 z_stream zstream;
7106 QEMUFile *f;
7107 uint8_t buf[IOBUF_SIZE];
7108 } RamDecompressState;
7109
7110 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
7111 {
7112 int ret;
7113 memset(s, 0, sizeof(*s));
7114 s->f = f;
7115 ret = inflateInit(&s->zstream);
7116 if (ret != Z_OK)
7117 return -1;
7118 return 0;
7119 }
7120
7121 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
7122 {
7123 int ret, clen;
7124
7125 s->zstream.avail_out = len;
7126 s->zstream.next_out = buf;
7127 while (s->zstream.avail_out > 0) {
7128 if (s->zstream.avail_in == 0) {
7129 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
7130 return -1;
7131 clen = qemu_get_be16(s->f);
7132 if (clen > IOBUF_SIZE)
7133 return -1;
7134 qemu_get_buffer(s->f, s->buf, clen);
7135 s->zstream.avail_in = clen;
7136 s->zstream.next_in = s->buf;
7137 }
7138 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
7139 if (ret != Z_OK && ret != Z_STREAM_END) {
7140 return -1;
7141 }
7142 }
7143 return 0;
7144 }
7145
7146 static void ram_decompress_close(RamDecompressState *s)
7147 {
7148 inflateEnd(&s->zstream);
7149 }
7150
7151 static void ram_save_live(QEMUFile *f, void *opaque)
7152 {
7153 target_ulong addr;
7154
7155 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
7156 #ifdef USE_KVM
7157 if (kvm_allowed && (addr>=0xa0000) && (addr<0xc0000)) /* do not access video-addresses */
7158 continue;
7159 #endif
7160 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {
7161 qemu_put_be32(f, addr);
7162 qemu_put_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
7163 }
7164 }
7165 qemu_put_be32(f, 1);
7166 }
7167
7168 static void ram_save_static(QEMUFile *f, void *opaque)
7169 {
7170 int i;
7171 RamCompressState s1, *s = &s1;
7172 uint8_t buf[10];
7173
7174 qemu_put_be32(f, phys_ram_size);
7175 if (ram_compress_open(s, f) < 0)
7176 return;
7177 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7178 #ifdef USE_KVM
7179 if (kvm_allowed && (i>=0xa0000) && (i<0xc0000)) /* do not access video-addresses */
7180 continue;
7181 #endif
7182 #if 0
7183 if (tight_savevm_enabled) {
7184 int64_t sector_num;
7185 int j;
7186
7187 /* find if the memory block is available on a virtual
7188 block device */
7189 sector_num = -1;
7190 for(j = 0; j < nb_drives; j++) {
7191 sector_num = bdrv_hash_find(drives_table[j].bdrv,
7192 phys_ram_base + i,
7193 BDRV_HASH_BLOCK_SIZE);
7194 if (sector_num >= 0)
7195 break;
7196 }
7197 if (j == nb_drives)
7198 goto normal_compress;
7199 buf[0] = 1;
7200 buf[1] = j;
7201 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
7202 ram_compress_buf(s, buf, 10);
7203 } else
7204 #endif
7205 {
7206 // normal_compress:
7207 buf[0] = 0;
7208 ram_compress_buf(s, buf, 1);
7209 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
7210 }
7211 }
7212 ram_compress_close(s);
7213 }
7214
7215 static void ram_save(QEMUFile *f, void *opaque)
7216 {
7217 int in_migration = cpu_physical_memory_get_dirty_tracking();
7218
7219 qemu_put_byte(f, in_migration);
7220
7221 if (in_migration)
7222 ram_save_live(f, opaque);
7223 else
7224 ram_save_static(f, opaque);
7225 }
7226
7227 static int ram_load_live(QEMUFile *f, void *opaque)
7228 {
7229 target_ulong addr;
7230
7231 do {
7232 addr = qemu_get_be32(f);
7233 if (addr == 1)
7234 break;
7235
7236 qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
7237 } while (1);
7238
7239 return 0;
7240 }
7241
7242 static int ram_load_static(QEMUFile *f, void *opaque)
7243 {
7244 RamDecompressState s1, *s = &s1;
7245 uint8_t buf[10];
7246 int i;
7247
7248 if (qemu_get_be32(f) != phys_ram_size)
7249 return -EINVAL;
7250 if (ram_decompress_open(s, f) < 0)
7251 return -EINVAL;
7252 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7253 #ifdef USE_KVM
7254 if (kvm_allowed && (i>=0xa0000) && (i<0xc0000)) /* do not access video-addresses */
7255 continue;
7256 #endif
7257 if (ram_decompress_buf(s, buf, 1) < 0) {
7258 fprintf(stderr, "Error while reading ram block header\n");
7259 goto error;
7260 }
7261 if (buf[0] == 0) {
7262 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
7263 fprintf(stderr, "Error while reading ram block address=0x%08x", i);
7264 goto error;
7265 }
7266 } else
7267 #if 0
7268 if (buf[0] == 1) {
7269 int bs_index;
7270 int64_t sector_num;
7271
7272 ram_decompress_buf(s, buf + 1, 9);
7273 bs_index = buf[1];
7274 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
7275 if (bs_index >= nb_drives) {
7276 fprintf(stderr, "Invalid block device index %d\n", bs_index);
7277 goto error;
7278 }
7279 if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
7280 phys_ram_base + i,
7281 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
7282 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
7283 bs_index, sector_num);
7284 goto error;
7285 }
7286 } else
7287 #endif
7288 {
7289 error:
7290 printf("Error block header\n");
7291 return -EINVAL;
7292 }
7293 }
7294 ram_decompress_close(s);
7295 return 0;
7296 }
7297
7298 static int ram_load(QEMUFile *f, void *opaque, int version_id)
7299 {
7300 int ret;
7301
7302 switch (version_id) {
7303 case 1:
7304 ret = ram_load_v1(f, opaque);
7305 break;
7306 case 3:
7307 if (qemu_get_byte(f)) {
7308 ret = ram_load_live(f, opaque);
7309 break;
7310 }
7311 case 2:
7312 ret = ram_load_static(f, opaque);
7313 break;
7314 default:
7315 ret = -EINVAL;
7316 break;
7317 }
7318
7319 return ret;
7320 }
7321
7322 /***********************************************************/
7323 /* bottom halves (can be seen as timers which expire ASAP) */
7324
7325 struct QEMUBH {
7326 QEMUBHFunc *cb;
7327 void *opaque;
7328 int scheduled;
7329 QEMUBH *next;
7330 };
7331
7332 static QEMUBH *first_bh = NULL;
7333
7334 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
7335 {
7336 QEMUBH *bh;
7337 bh = qemu_mallocz(sizeof(QEMUBH));
7338 if (!bh)
7339 return NULL;
7340 bh->cb = cb;
7341 bh->opaque = opaque;
7342 return bh;
7343 }
7344
7345 int qemu_bh_poll(void)
7346 {
7347 QEMUBH *bh, **pbh;
7348 int ret;
7349
7350 ret = 0;
7351 for(;;) {
7352 pbh = &first_bh;
7353 bh = *pbh;
7354 if (!bh)
7355 break;
7356 ret = 1;
7357 *pbh = bh->next;
7358 bh->scheduled = 0;
7359 bh->cb(bh->opaque);
7360 }
7361 return ret;
7362 }
7363
7364 void qemu_bh_schedule(QEMUBH *bh)
7365 {
7366 CPUState *env = cpu_single_env;
7367 if (bh->scheduled)
7368 return;
7369 bh->scheduled = 1;
7370 bh->next = first_bh;
7371 first_bh = bh;
7372
7373 /* stop the currently executing CPU to execute the BH ASAP */
7374 if (env) {
7375 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
7376 }
7377 }
7378
7379 void qemu_bh_cancel(QEMUBH *bh)
7380 {
7381 QEMUBH **pbh;
7382 if (bh->scheduled) {
7383 pbh = &first_bh;
7384 while (*pbh != bh)
7385 pbh = &(*pbh)->next;
7386 *pbh = bh->next;
7387 bh->scheduled = 0;
7388 }
7389 }
7390
7391 void qemu_bh_delete(QEMUBH *bh)
7392 {
7393 qemu_bh_cancel(bh);
7394 qemu_free(bh);
7395 }
7396
7397 /***********************************************************/
7398 /* machine registration */
7399
7400 QEMUMachine *first_machine = NULL;
7401
7402 int qemu_register_machine(QEMUMachine *m)
7403 {
7404 QEMUMachine **pm;
7405 pm = &first_machine;
7406 while (*pm != NULL)
7407 pm = &(*pm)->next;
7408 m->next = NULL;
7409 *pm = m;
7410 return 0;
7411 }
7412
7413 static QEMUMachine *find_machine(const char *name)
7414 {
7415 QEMUMachine *m;
7416
7417 for(m = first_machine; m != NULL; m = m->next) {
7418 if (!strcmp(m->name, name))
7419 return m;
7420 }
7421 return NULL;
7422 }
7423
7424 /***********************************************************/
7425 /* main execution loop */
7426
7427 static void gui_update(void *opaque)
7428 {
7429 DisplayState *ds = opaque;
7430 ds->dpy_refresh(ds);
7431 qemu_mod_timer(ds->gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
7432 }
7433
7434 struct vm_change_state_entry {
7435 VMChangeStateHandler *cb;
7436 void *opaque;
7437 LIST_ENTRY (vm_change_state_entry) entries;
7438 };
7439
7440 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
7441
7442 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
7443 void *opaque)
7444 {
7445 VMChangeStateEntry *e;
7446
7447 e = qemu_mallocz(sizeof (*e));
7448 if (!e)
7449 return NULL;
7450
7451 e->cb = cb;
7452 e->opaque = opaque;
7453 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
7454 return e;
7455 }
7456
7457 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
7458 {
7459 LIST_REMOVE (e, entries);
7460 qemu_free (e);
7461 }
7462
7463 static void vm_state_notify(int running)
7464 {
7465 VMChangeStateEntry *e;
7466
7467 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
7468 e->cb(e->opaque, running);
7469 }
7470 }
7471
7472 /* XXX: support several handlers */
7473 static VMStopHandler *vm_stop_cb;
7474 static void *vm_stop_opaque;
7475
7476 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
7477 {
7478 vm_stop_cb = cb;
7479 vm_stop_opaque = opaque;
7480 return 0;
7481 }
7482
7483 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
7484 {
7485 vm_stop_cb = NULL;
7486 }
7487
7488 void vm_start(void)
7489 {
7490 if (!vm_running) {
7491 cpu_enable_ticks();
7492 vm_running = 1;
7493 vm_state_notify(1);
7494 qemu_rearm_alarm_timer(alarm_timer);
7495 }
7496 }
7497
7498 void vm_stop(int reason)
7499 {
7500 if (vm_running) {
7501 cpu_disable_ticks();
7502 vm_running = 0;
7503 if (reason != 0) {
7504 if (vm_stop_cb) {
7505 vm_stop_cb(vm_stop_opaque, reason);
7506 }
7507 }
7508 vm_state_notify(0);
7509 }
7510 }
7511
7512 /* reset/shutdown handler */
7513
7514 typedef struct QEMUResetEntry {
7515 QEMUResetHandler *func;
7516 void *opaque;
7517 struct QEMUResetEntry *next;
7518 } QEMUResetEntry;
7519
7520 static QEMUResetEntry *first_reset_entry;
7521 static int reset_requested;
7522 static int shutdown_requested;
7523 static int powerdown_requested;
7524
7525 int qemu_shutdown_requested(void)
7526 {
7527 int r = shutdown_requested;
7528 shutdown_requested = 0;
7529 return r;
7530 }
7531
7532 int qemu_reset_requested(void)
7533 {
7534 int r = reset_requested;
7535 reset_requested = 0;
7536 return r;
7537 }
7538
7539 int qemu_powerdown_requested(void)
7540 {
7541 int r = powerdown_requested;
7542 powerdown_requested = 0;
7543 return r;
7544 }
7545
7546 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
7547 {
7548 QEMUResetEntry **pre, *re;
7549
7550 pre = &first_reset_entry;
7551 while (*pre != NULL)
7552 pre = &(*pre)->next;
7553 re = qemu_mallocz(sizeof(QEMUResetEntry));
7554 re->func = func;
7555 re->opaque = opaque;
7556 re->next = NULL;
7557 *pre = re;
7558 }
7559
7560 void qemu_system_reset(void)
7561 {
7562 QEMUResetEntry *re;
7563
7564 /* reset all devices */
7565 for(re = first_reset_entry; re != NULL; re = re->next) {
7566 re->func(re->opaque);
7567 }
7568 }
7569
7570 void qemu_system_reset_request(void)
7571 {
7572 if (no_reboot) {
7573 shutdown_requested = 1;
7574 } else {
7575 reset_requested = 1;
7576 }
7577 if (cpu_single_env)
7578 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7579 }
7580
7581 void qemu_system_shutdown_request(void)
7582 {
7583 shutdown_requested = 1;
7584 if (cpu_single_env)
7585 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7586 }
7587
7588 void qemu_system_powerdown_request(void)
7589 {
7590 powerdown_requested = 1;
7591 if (cpu_single_env)
7592 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7593 }
7594
7595 void main_loop_wait(int timeout)
7596 {
7597 IOHandlerRecord *ioh;
7598 fd_set rfds, wfds, xfds;
7599 int ret, nfds;
7600 #ifdef _WIN32
7601 int ret2, i;
7602 #endif
7603 struct timeval tv;
7604 PollingEntry *pe;
7605
7606
7607 /* XXX: need to suppress polling by better using win32 events */
7608 ret = 0;
7609 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7610 ret |= pe->func(pe->opaque);
7611 }
7612 #ifdef _WIN32
7613 if (ret == 0) {
7614 int err;
7615 WaitObjects *w = &wait_objects;
7616
7617 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
7618 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7619 if (w->func[ret - WAIT_OBJECT_0])
7620 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
7621
7622 /* Check for additional signaled events */
7623 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
7624
7625 /* Check if event is signaled */
7626 ret2 = WaitForSingleObject(w->events[i], 0);
7627 if(ret2 == WAIT_OBJECT_0) {
7628 if (w->func[i])
7629 w->func[i](w->opaque[i]);
7630 } else if (ret2 == WAIT_TIMEOUT) {
7631 } else {
7632 err = GetLastError();
7633 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
7634 }
7635 }
7636 } else if (ret == WAIT_TIMEOUT) {
7637 } else {
7638 err = GetLastError();
7639 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
7640 }
7641 }
7642 #endif
7643 /* poll any events */
7644 /* XXX: separate device handlers from system ones */
7645 nfds = -1;
7646 FD_ZERO(&rfds);
7647 FD_ZERO(&wfds);
7648 FD_ZERO(&xfds);
7649 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7650 if (ioh->deleted)
7651 continue;
7652 if (ioh->fd_read &&
7653 (!ioh->fd_read_poll ||
7654 ioh->fd_read_poll(ioh->opaque) != 0)) {
7655 FD_SET(ioh->fd, &rfds);
7656 if (ioh->fd > nfds)
7657 nfds = ioh->fd;
7658 }
7659 if (ioh->fd_write) {
7660 FD_SET(ioh->fd, &wfds);
7661 if (ioh->fd > nfds)
7662 nfds = ioh->fd;
7663 }
7664 }
7665
7666 tv.tv_sec = 0;
7667 #ifdef _WIN32
7668 tv.tv_usec = 0;
7669 #else
7670 tv.tv_usec = timeout * 1000;
7671 #endif
7672 #if defined(CONFIG_SLIRP)
7673 if (slirp_inited) {
7674 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7675 }
7676 #endif
7677 moreio:
7678 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
7679 if (ret > 0) {
7680 IOHandlerRecord **pioh;
7681 int more = 0;
7682
7683 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7684 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
7685 ioh->fd_read(ioh->opaque);
7686 more = 1;
7687 }
7688 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
7689 ioh->fd_write(ioh->opaque);
7690 more = 1;
7691 }
7692 }
7693
7694 /* remove deleted IO handlers */
7695 pioh = &first_io_handler;
7696 while (*pioh) {
7697 ioh = *pioh;
7698 if (ioh->deleted) {
7699 *pioh = ioh->next;
7700 qemu_free(ioh);
7701 } else
7702 pioh = &ioh->next;
7703 }
7704 if (more)
7705 goto moreio;
7706 }
7707 #if defined(CONFIG_SLIRP)
7708 if (slirp_inited) {
7709 if (ret < 0) {
7710 FD_ZERO(&rfds);
7711 FD_ZERO(&wfds);
7712 FD_ZERO(&xfds);
7713 }
7714 slirp_select_poll(&rfds, &wfds, &xfds);
7715 }
7716 #endif
7717 qemu_aio_poll();
7718
7719 if (vm_running) {
7720 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
7721 qemu_get_clock(vm_clock));
7722 /* run dma transfers, if any */
7723 DMA_run();
7724 }
7725
7726 /* real time timers */
7727 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
7728 qemu_get_clock(rt_clock));
7729
7730 /* Check bottom-halves last in case any of the earlier events triggered
7731 them. */
7732 qemu_bh_poll();
7733
7734 }
7735
7736 static int main_loop(void)
7737 {
7738 int ret, timeout;
7739 #ifdef CONFIG_PROFILER
7740 int64_t ti;
7741 #endif
7742 CPUState *env;
7743
7744
7745 #ifdef USE_KVM
7746 if (kvm_allowed) {
7747 kvm_main_loop();
7748 cpu_disable_ticks();
7749 return 0;
7750 }
7751 #endif
7752 cur_cpu = first_cpu;
7753 next_cpu = cur_cpu->next_cpu ?: first_cpu;
7754 for(;;) {
7755 if (vm_running) {
7756
7757 for(;;) {
7758 /* get next cpu */
7759 env = next_cpu;
7760 #ifdef CONFIG_PROFILER
7761 ti = profile_getclock();
7762 #endif
7763 ret = cpu_exec(env);
7764 #ifdef CONFIG_PROFILER
7765 qemu_time += profile_getclock() - ti;
7766 #endif
7767 next_cpu = env->next_cpu ?: first_cpu;
7768 if (event_pending) {
7769 ret = EXCP_INTERRUPT;
7770 event_pending = 0;
7771 break;
7772 }
7773 if (ret == EXCP_HLT) {
7774 /* Give the next CPU a chance to run. */
7775 cur_cpu = env;
7776 continue;
7777 }
7778 if (ret != EXCP_HALTED)
7779 break;
7780 /* all CPUs are halted ? */
7781 if (env == cur_cpu)
7782 break;
7783 }
7784 cur_cpu = env;
7785
7786 if (shutdown_requested) {
7787 ret = EXCP_INTERRUPT;
7788 break;
7789 }
7790 if (reset_requested) {
7791 reset_requested = 0;
7792 qemu_system_reset();
7793 #ifdef USE_KVM
7794 if (kvm_allowed)
7795 kvm_load_registers(env);
7796 #endif
7797 ret = EXCP_INTERRUPT;
7798 }
7799 if (powerdown_requested) {
7800 powerdown_requested = 0;
7801 qemu_system_powerdown();
7802 ret = EXCP_INTERRUPT;
7803 }
7804 if (ret == EXCP_DEBUG) {
7805 vm_stop(EXCP_DEBUG);
7806 }
7807 /* If all cpus are halted then wait until the next IRQ */
7808 /* XXX: use timeout computed from timers */
7809 if (ret == EXCP_HALTED)
7810 timeout = 10;
7811 else
7812 timeout = 0;
7813 } else {
7814 timeout = 10;
7815 }
7816 #ifdef CONFIG_PROFILER
7817 ti = profile_getclock();
7818 #endif
7819 main_loop_wait(timeout);
7820 #ifdef CONFIG_PROFILER
7821 dev_time += profile_getclock() - ti;
7822 #endif
7823 }
7824 cpu_disable_ticks();
7825 return ret;
7826 }
7827
7828 static void help(int exitcode)
7829 {
7830 printf("QEMU PC emulator version " QEMU_VERSION " (" KVM_VERSION ")"
7831 ", Copyright (c) 2003-2007 Fabrice Bellard\n"
7832 "usage: %s [options] [disk_image]\n"
7833 "\n"
7834 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7835 "\n"
7836 "Standard options:\n"
7837 "-M machine select emulated machine (-M ? for list)\n"
7838 "-cpu cpu select CPU (-cpu ? for list)\n"
7839 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7840 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7841 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7842 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7843 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][index=i]\n"
7844 " [,cyls=c,heads=h,secs=s[,trans=t]][snapshot=on|off]\n"
7845 " use 'file' as a drive image\n"
7846 "-mtdblock file use 'file' as on-board Flash memory image\n"
7847 "-sd file use 'file' as SecureDigital card image\n"
7848 "-pflash file use 'file' as a parallel flash image\n"
7849 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7850 "-snapshot write to temporary files instead of disk image files\n"
7851 #ifdef CONFIG_SDL
7852 "-no-frame open SDL window without a frame and window decorations\n"
7853 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7854 "-no-quit disable SDL window close capability\n"
7855 #endif
7856 #ifdef TARGET_I386
7857 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7858 #endif
7859 "-m megs set virtual RAM size to megs MB [default=%d]\n"
7860 "-smp n set the number of CPUs to 'n' [default=1]\n"
7861 "-nographic disable graphical output and redirect serial I/Os to console\n"
7862 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7863 #ifndef _WIN32
7864 "-k language use keyboard layout (for example \"fr\" for French)\n"
7865 #endif
7866 #ifdef HAS_AUDIO
7867 "-audio-help print list of audio drivers and their options\n"
7868 "-soundhw c1,... enable audio support\n"
7869 " and only specified sound cards (comma separated list)\n"
7870 " use -soundhw ? to get the list of supported cards\n"
7871 " use -soundhw all to enable all of them\n"
7872 #endif
7873 "-localtime set the real time clock to local time [default=utc]\n"
7874 "-full-screen start in full screen\n"
7875 #ifdef TARGET_I386
7876 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7877 #endif
7878 "-usb enable the USB driver (will be the default soon)\n"
7879 "-usbdevice name add the host or guest USB device 'name'\n"
7880 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7881 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7882 #endif
7883 "-name string set the name of the guest\n"
7884 "\n"
7885 "Network options:\n"
7886 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7887 " create a new Network Interface Card and connect it to VLAN 'n'\n"
7888 #ifdef CONFIG_SLIRP
7889 "-net user[,vlan=n][,hostname=host]\n"
7890 " connect the user mode network stack to VLAN 'n' and send\n"
7891 " hostname 'host' to DHCP clients\n"
7892 #endif
7893 #ifdef _WIN32
7894 "-net tap[,vlan=n],ifname=name\n"
7895 " connect the host TAP network interface to VLAN 'n'\n"
7896 #else
7897 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7898 " connect the host TAP network interface to VLAN 'n' and use the\n"
7899 " network scripts 'file' (default=%s)\n"
7900 " and 'dfile' (default=%s);\n"
7901 " use '[down]script=no' to disable script execution;\n"
7902 " use 'fd=h' to connect to an already opened TAP interface\n"
7903 #endif
7904 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7905 " connect the vlan 'n' to another VLAN using a socket connection\n"
7906 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7907 " connect the vlan 'n' to multicast maddr and port\n"
7908 "-net none use it alone to have zero network devices; if no -net option\n"
7909 " is provided, the default is '-net nic -net user'\n"
7910 "\n"
7911 #ifdef CONFIG_SLIRP
7912 "-tftp dir allow tftp access to files in dir [-net user]\n"
7913 "-bootp file advertise file in BOOTP replies\n"
7914 #ifndef _WIN32
7915 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
7916 #endif
7917 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7918 " redirect TCP or UDP connections from host to guest [-net user]\n"
7919 #endif
7920 "\n"
7921 "Linux boot specific:\n"
7922 "-kernel bzImage use 'bzImage' as kernel image\n"
7923 "-append cmdline use 'cmdline' as kernel command line\n"
7924 "-initrd file use 'file' as initial ram disk\n"
7925 "\n"
7926 "Debug/Expert options:\n"
7927 "-monitor dev redirect the monitor to char device 'dev'\n"
7928 "-vmchannel di:DI,dev redirect the hypercall device with device id DI, to char device 'dev'\n"
7929 "-balloon dev redirect the balloon hypercall device to char device 'dev'\n"
7930 "-serial dev redirect the serial port to char device 'dev'\n"
7931 "-parallel dev redirect the parallel port to char device 'dev'\n"
7932 "-pidfile file Write PID to 'file'\n"
7933 "-S freeze CPU at startup (use 'c' to start execution)\n"
7934 "-s wait gdb connection to port\n"
7935 "-p port set gdb connection port [default=%s]\n"
7936 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
7937 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7938 " translation (t=none or lba) (usually qemu can guess them)\n"
7939 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
7940 #ifdef USE_KQEMU
7941 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7942 "-no-kqemu disable KQEMU kernel module usage\n"
7943 #endif
7944 #ifdef USE_KVM
7945 "-no-kvm disable KVM hardware virtualization\n"
7946 "-no-kvm-irqchip disable KVM kernel mode PIC/IOAPIC/LAPIC\n"
7947 #endif
7948 #ifdef TARGET_I386
7949 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
7950 " (default is CL-GD5446 PCI VGA)\n"
7951 "-no-acpi disable ACPI\n"
7952 #endif
7953 "-no-reboot exit instead of rebooting\n"
7954 "-loadvm file start right away with a saved state (loadvm in monitor)\n"
7955 "-vnc display start a VNC server on display\n"
7956 #ifndef _WIN32
7957 "-daemonize daemonize QEMU after initializing\n"
7958 #endif
7959 "-tdf inject timer interrupts that got lost\n"
7960 "-kvm-shadow-memory megs set the amount of shadow pages to be allocated\n"
7961 "-option-rom rom load a file, rom, into the option ROM space\n"
7962 #ifdef TARGET_SPARC
7963 "-prom-env variable=value set OpenBIOS nvram variables\n"
7964 #endif
7965 "-clock force the use of the given methods for timer alarm.\n"
7966 " To see what timers are available use -clock help\n"
7967 "\n"
7968 "During emulation, the following keys are useful:\n"
7969 "ctrl-alt-f toggle full screen\n"
7970 "ctrl-alt-n switch to virtual console 'n'\n"
7971 "ctrl-alt toggle mouse and keyboard grab\n"
7972 "\n"
7973 "When using -nographic, press 'ctrl-a h' to get some help.\n"
7974 ,
7975 "qemu",
7976 DEFAULT_RAM_SIZE,
7977 #ifndef _WIN32
7978 DEFAULT_NETWORK_SCRIPT,
7979 DEFAULT_NETWORK_DOWN_SCRIPT,
7980 #endif
7981 DEFAULT_GDBSTUB_PORT,
7982 "/tmp/qemu.log");
7983 exit(exitcode);
7984 }
7985
7986 #define HAS_ARG 0x0001
7987
7988 enum {
7989 QEMU_OPTION_h,
7990
7991 QEMU_OPTION_M,
7992 QEMU_OPTION_cpu,
7993 QEMU_OPTION_fda,
7994 QEMU_OPTION_fdb,
7995 QEMU_OPTION_hda,
7996 QEMU_OPTION_hdb,
7997 QEMU_OPTION_hdc,
7998 QEMU_OPTION_hdd,
7999 QEMU_OPTION_drive,
8000 QEMU_OPTION_cdrom,
8001 QEMU_OPTION_mtdblock,
8002 QEMU_OPTION_sd,
8003 QEMU_OPTION_pflash,
8004 QEMU_OPTION_boot,
8005 QEMU_OPTION_snapshot,
8006 #ifdef TARGET_I386
8007 QEMU_OPTION_no_fd_bootchk,
8008 #endif
8009 QEMU_OPTION_m,
8010 QEMU_OPTION_nographic,
8011 QEMU_OPTION_portrait,
8012 #ifdef HAS_AUDIO
8013 QEMU_OPTION_audio_help,
8014 QEMU_OPTION_soundhw,
8015 #endif
8016
8017 QEMU_OPTION_net,
8018 QEMU_OPTION_tftp,
8019 QEMU_OPTION_bootp,
8020 QEMU_OPTION_smb,
8021 QEMU_OPTION_redir,
8022
8023 QEMU_OPTION_kernel,
8024 QEMU_OPTION_append,
8025 QEMU_OPTION_initrd,
8026
8027 QEMU_OPTION_S,
8028 QEMU_OPTION_s,
8029 QEMU_OPTION_p,
8030 QEMU_OPTION_d,
8031 QEMU_OPTION_hdachs,
8032 QEMU_OPTION_L,
8033 QEMU_OPTION_bios,
8034 QEMU_OPTION_no_code_copy,
8035 QEMU_OPTION_k,
8036 QEMU_OPTION_localtime,
8037 QEMU_OPTION_cirrusvga,
8038 QEMU_OPTION_vmsvga,
8039 QEMU_OPTION_g,
8040 QEMU_OPTION_std_vga,
8041 QEMU_OPTION_echr,
8042 QEMU_OPTION_monitor,
8043 QEMU_OPTION_balloon,
8044 QEMU_OPTION_vmchannel,
8045 QEMU_OPTION_serial,
8046 QEMU_OPTION_parallel,
8047 QEMU_OPTION_loadvm,
8048 QEMU_OPTION_full_screen,
8049 QEMU_OPTION_no_frame,
8050 QEMU_OPTION_alt_grab,
8051 QEMU_OPTION_no_quit,
8052 QEMU_OPTION_pidfile,
8053 QEMU_OPTION_no_kqemu,
8054 QEMU_OPTION_kernel_kqemu,
8055 QEMU_OPTION_win2k_hack,
8056 QEMU_OPTION_usb,
8057 QEMU_OPTION_usbdevice,
8058 QEMU_OPTION_smp,
8059 QEMU_OPTION_vnc,
8060 QEMU_OPTION_no_acpi,
8061 QEMU_OPTION_no_kvm,
8062 QEMU_OPTION_no_kvm_irqchip,
8063 QEMU_OPTION_no_reboot,
8064 QEMU_OPTION_show_cursor,
8065 QEMU_OPTION_daemonize,
8066 QEMU_OPTION_option_rom,
8067 QEMU_OPTION_semihosting,
8068 QEMU_OPTION_cpu_vendor,
8069 QEMU_OPTION_name,
8070 QEMU_OPTION_prom_env,
8071 QEMU_OPTION_old_param,
8072 QEMU_OPTION_clock,
8073 QEMU_OPTION_startdate,
8074 QEMU_OPTION_incoming,
8075 QEMU_OPTION_tdf,
8076 QEMU_OPTION_kvm_shadow_memory,
8077 };
8078
8079 typedef struct QEMUOption {
8080 const char *name;
8081 int flags;
8082 int index;
8083 } QEMUOption;
8084
8085 const QEMUOption qemu_options[] = {
8086 { "h", 0, QEMU_OPTION_h },
8087 { "help", 0, QEMU_OPTION_h },
8088
8089 { "M", HAS_ARG, QEMU_OPTION_M },
8090 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
8091 { "fda", HAS_ARG, QEMU_OPTION_fda },
8092 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
8093 { "hda", HAS_ARG, QEMU_OPTION_hda },
8094 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
8095 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
8096 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
8097 { "drive", HAS_ARG, QEMU_OPTION_drive },
8098 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
8099 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
8100 { "sd", HAS_ARG, QEMU_OPTION_sd },
8101 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
8102 { "boot", HAS_ARG, QEMU_OPTION_boot },
8103 { "snapshot", 0, QEMU_OPTION_snapshot },
8104 #ifdef TARGET_I386
8105 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
8106 #endif
8107 { "m", HAS_ARG, QEMU_OPTION_m },
8108 { "nographic", 0, QEMU_OPTION_nographic },
8109 { "portrait", 0, QEMU_OPTION_portrait },
8110 { "k", HAS_ARG, QEMU_OPTION_k },
8111 #ifdef HAS_AUDIO
8112 { "audio-help", 0, QEMU_OPTION_audio_help },
8113 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
8114 #endif
8115
8116 { "net", HAS_ARG, QEMU_OPTION_net},
8117 #ifdef CONFIG_SLIRP
8118 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
8119 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
8120 #ifndef _WIN32
8121 { "smb", HAS_ARG, QEMU_OPTION_smb },
8122 #endif
8123 { "redir", HAS_ARG, QEMU_OPTION_redir },
8124 #endif
8125
8126 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
8127 { "append", HAS_ARG, QEMU_OPTION_append },
8128 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
8129
8130 { "S", 0, QEMU_OPTION_S },
8131 { "s", 0, QEMU_OPTION_s },
8132 { "p", HAS_ARG, QEMU_OPTION_p },
8133 { "d", HAS_ARG, QEMU_OPTION_d },
8134 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
8135 { "L", HAS_ARG, QEMU_OPTION_L },
8136 { "bios", HAS_ARG, QEMU_OPTION_bios },
8137 { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
8138 #ifdef USE_KQEMU
8139 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
8140 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
8141 #endif
8142 #ifdef USE_KVM
8143 { "no-kvm", 0, QEMU_OPTION_no_kvm },
8144 { "no-kvm-irqchip", 0, QEMU_OPTION_no_kvm_irqchip },
8145 #endif
8146 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8147 { "g", 1, QEMU_OPTION_g },
8148 #endif
8149 { "localtime", 0, QEMU_OPTION_localtime },
8150 { "std-vga", 0, QEMU_OPTION_std_vga },
8151 { "monitor", 1, QEMU_OPTION_monitor },
8152 { "balloon", 1, QEMU_OPTION_balloon },
8153 { "vmchannel", 1, QEMU_OPTION_vmchannel },
8154 { "echr", HAS_ARG, QEMU_OPTION_echr },
8155 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
8156 { "serial", HAS_ARG, QEMU_OPTION_serial },
8157 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
8158 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
8159 { "incoming", 1, QEMU_OPTION_incoming },
8160 { "full-screen", 0, QEMU_OPTION_full_screen },
8161 #ifdef CONFIG_SDL
8162 { "no-frame", 0, QEMU_OPTION_no_frame },
8163 { "alt-grab", 0, QEMU_OPTION_alt_grab },
8164 { "no-quit", 0, QEMU_OPTION_no_quit },
8165 #endif
8166 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
8167 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
8168 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
8169 { "smp", HAS_ARG, QEMU_OPTION_smp },
8170 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
8171
8172 /* temporary options */
8173 { "usb", 0, QEMU_OPTION_usb },
8174 { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
8175 { "vmwarevga", 0, QEMU_OPTION_vmsvga },
8176 { "no-acpi", 0, QEMU_OPTION_no_acpi },
8177 { "no-reboot", 0, QEMU_OPTION_no_reboot },
8178 { "show-cursor", 0, QEMU_OPTION_show_cursor },
8179 { "daemonize", 0, QEMU_OPTION_daemonize },
8180 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
8181 #if defined(TARGET_ARM) || defined(TARGET_M68K)
8182 { "semihosting", 0, QEMU_OPTION_semihosting },
8183 #endif
8184 { "tdf", 0, QEMU_OPTION_tdf }, /* enable time drift fix */
8185 { "kvm-shadow-memory", HAS_ARG, QEMU_OPTION_kvm_shadow_memory },
8186 { "name", HAS_ARG, QEMU_OPTION_name },
8187 #if defined(TARGET_SPARC)
8188 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
8189 #endif
8190 { "cpu-vendor", HAS_ARG, QEMU_OPTION_cpu_vendor },
8191 #if defined(TARGET_ARM)
8192 { "old-param", 0, QEMU_OPTION_old_param },
8193 #endif
8194 { "clock", HAS_ARG, QEMU_OPTION_clock },
8195 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
8196 { NULL },
8197 };
8198
8199 /* password input */
8200
8201 int qemu_key_check(BlockDriverState *bs, const char *name)
8202 {
8203 char password[256];
8204 int i;
8205
8206 if (!bdrv_is_encrypted(bs))
8207 return 0;
8208
8209 term_printf("%s is encrypted.\n", name);
8210 for(i = 0; i < 3; i++) {
8211 monitor_readline("Password: ", 1, password, sizeof(password));
8212 if (bdrv_set_key(bs, password) == 0)
8213 return 0;
8214 term_printf("invalid password\n");
8215 }
8216 return -EPERM;
8217 }
8218
8219 static BlockDriverState *get_bdrv(int index)
8220 {
8221 if (index > nb_drives)
8222 return NULL;
8223 return drives_table[index].bdrv;
8224 }
8225
8226 static void read_passwords(void)
8227 {
8228 BlockDriverState *bs;
8229 int i;
8230
8231 for(i = 0; i < 6; i++) {
8232 bs = get_bdrv(i);
8233 if (bs)
8234 qemu_key_check(bs, bdrv_get_device_name(bs));
8235 }
8236 }
8237
8238 /* XXX: currently we cannot use simultaneously different CPUs */
8239 static void register_machines(void)
8240 {
8241 #if defined(TARGET_I386)
8242 qemu_register_machine(&pc_machine);
8243 qemu_register_machine(&isapc_machine);
8244 #elif defined(TARGET_PPC)
8245 qemu_register_machine(&heathrow_machine);
8246 qemu_register_machine(&core99_machine);
8247 qemu_register_machine(&prep_machine);
8248 qemu_register_machine(&ref405ep_machine);
8249 qemu_register_machine(&taihu_machine);
8250 #elif defined(TARGET_MIPS)
8251 qemu_register_machine(&mips_machine);
8252 qemu_register_machine(&mips_malta_machine);
8253 qemu_register_machine(&mips_pica61_machine);
8254 qemu_register_machine(&mips_mipssim_machine);
8255 #elif defined(TARGET_SPARC)
8256 #ifdef TARGET_SPARC64
8257 qemu_register_machine(&sun4u_machine);
8258 #else
8259 qemu_register_machine(&ss5_machine);
8260 qemu_register_machine(&ss10_machine);
8261 qemu_register_machine(&ss600mp_machine);
8262 qemu_register_machine(&ss20_machine);
8263 #endif
8264 #elif defined(TARGET_ARM)
8265 qemu_register_machine(&integratorcp_machine);
8266 qemu_register_machine(&versatilepb_machine);
8267 qemu_register_machine(&versatileab_machine);
8268 qemu_register_machine(&realview_machine);
8269 qemu_register_machine(&akitapda_machine);
8270 qemu_register_machine(&spitzpda_machine);
8271 qemu_register_machine(&borzoipda_machine);
8272 qemu_register_machine(&terrierpda_machine);
8273 qemu_register_machine(&palmte_machine);
8274 qemu_register_machine(&lm3s811evb_machine);
8275 qemu_register_machine(&lm3s6965evb_machine);
8276 qemu_register_machine(&connex_machine);
8277 qemu_register_machine(&verdex_machine);
8278 qemu_register_machine(&mainstone2_machine);
8279 #elif defined(TARGET_SH4)
8280 qemu_register_machine(&shix_machine);
8281 qemu_register_machine(&r2d_machine);
8282 #elif defined(TARGET_ALPHA)
8283 /* XXX: TODO */
8284 #elif defined(TARGET_M68K)
8285 qemu_register_machine(&mcf5208evb_machine);
8286 qemu_register_machine(&an5206_machine);
8287 qemu_register_machine(&dummy_m68k_machine);
8288 #elif defined(TARGET_CRIS)
8289 qemu_register_machine(&bareetraxfs_machine);
8290 #elif defined(TARGET_IA64)
8291 qemu_register_machine(&ipf_machine);
8292 #else
8293 #error unsupported CPU
8294 #endif
8295 }
8296
8297 #ifdef HAS_AUDIO
8298 struct soundhw soundhw[] = {
8299 #ifdef HAS_AUDIO_CHOICE
8300 #ifdef TARGET_I386
8301 {
8302 "pcspk",
8303 "PC speaker",
8304 0,
8305 1,
8306 { .init_isa = pcspk_audio_init }
8307 },
8308 #endif
8309 {
8310 "sb16",
8311 "Creative Sound Blaster 16",
8312 0,
8313 1,
8314 { .init_isa = SB16_init }
8315 },
8316
8317 #ifdef CONFIG_ADLIB
8318 {
8319 "adlib",
8320 #ifdef HAS_YMF262
8321 "Yamaha YMF262 (OPL3)",
8322 #else
8323 "Yamaha YM3812 (OPL2)",
8324 #endif
8325 0,
8326 1,
8327 { .init_isa = Adlib_init }
8328 },
8329 #endif
8330
8331 #ifdef CONFIG_GUS
8332 {
8333 "gus",
8334 "Gravis Ultrasound GF1",
8335 0,
8336 1,
8337 { .init_isa = GUS_init }
8338 },
8339 #endif
8340
8341 {
8342 "es1370",
8343 "ENSONIQ AudioPCI ES1370",
8344 0,
8345 0,
8346 { .init_pci = es1370_init }
8347 },
8348 #endif
8349
8350 { NULL, NULL, 0, 0, { NULL } }
8351 };
8352
8353 static void select_soundhw (const char *optarg)
8354 {
8355 struct soundhw *c;
8356
8357 if (*optarg == '?') {
8358 show_valid_cards:
8359
8360 printf ("Valid sound card names (comma separated):\n");
8361 for (c = soundhw; c->name; ++c) {
8362 printf ("%-11s %s\n", c->name, c->descr);
8363 }
8364 printf ("\n-soundhw all will enable all of the above\n");
8365 exit (*optarg != '?');
8366 }
8367 else {
8368 size_t l;
8369 const char *p;
8370 char *e;
8371 int bad_card = 0;
8372
8373 if (!strcmp (optarg, "all")) {
8374 for (c = soundhw; c->name; ++c) {
8375 c->enabled = 1;
8376 }
8377 return;
8378 }
8379
8380 p = optarg;
8381 while (*p) {
8382 e = strchr (p, ',');
8383 l = !e ? strlen (p) : (size_t) (e - p);
8384
8385 for (c = soundhw; c->name; ++c) {
8386 if (!strncmp (c->name, p, l)) {
8387 c->enabled = 1;
8388 break;
8389 }
8390 }
8391
8392 if (!c->name) {
8393 if (l > 80) {
8394 fprintf (stderr,
8395 "Unknown sound card name (too big to show)\n");
8396 }
8397 else {
8398 fprintf (stderr, "Unknown sound card name `%.*s'\n",
8399 (int) l, p);
8400 }
8401 bad_card = 1;
8402 }
8403 p += l + (e != NULL);
8404 }
8405
8406 if (bad_card)
8407 goto show_valid_cards;
8408 }
8409 }
8410 #endif
8411
8412 #ifdef _WIN32
8413 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
8414 {
8415 exit(STATUS_CONTROL_C_EXIT);
8416 return TRUE;
8417 }
8418 #endif
8419
8420 #define MAX_NET_CLIENTS 32
8421
8422 static int saved_argc;
8423 static char **saved_argv;
8424
8425 void qemu_get_launch_info(int *argc, char ***argv, int *opt_daemonize, const char **opt_incoming)
8426 {
8427 *argc = saved_argc;
8428 *argv = saved_argv;
8429 *opt_daemonize = daemonize;
8430 *opt_incoming = incoming;
8431 }
8432
8433 int main(int argc, char **argv)
8434 {
8435 #ifdef CONFIG_GDBSTUB
8436 int use_gdbstub;
8437 const char *gdbstub_port;
8438 #endif
8439 uint32_t boot_devices_bitmap = 0;
8440 int i;
8441 int snapshot, linux_boot, net_boot;
8442 const char *initrd_filename;
8443 const char *kernel_filename, *kernel_cmdline;
8444 const char *boot_devices = "";
8445 DisplayState *ds = &display_state;
8446 int cyls, heads, secs, translation;
8447 char net_clients[MAX_NET_CLIENTS][256];
8448 int nb_net_clients;
8449 int hda_index;
8450 int optind;
8451 const char *r, *optarg;
8452 CharDriverState *monitor_hd;
8453 char monitor_device[128];
8454 char vmchannel_devices[MAX_VMCHANNEL_DEVICES][128];
8455 int vmchannel_device_index;
8456 char serial_devices[MAX_SERIAL_PORTS][128];
8457 int serial_device_index;
8458 char parallel_devices[MAX_PARALLEL_PORTS][128];
8459 int parallel_device_index;
8460 const char *loadvm = NULL;
8461 QEMUMachine *machine;
8462 const char *cpu_model;
8463 char usb_devices[MAX_USB_CMDLINE][128];
8464 int usb_devices_index;
8465 int fds[2];
8466 const char *pid_file = NULL;
8467 VLANState *vlan;
8468
8469 saved_argc = argc;
8470 saved_argv = argv;
8471
8472 LIST_INIT (&vm_change_state_head);
8473 #ifndef _WIN32
8474 {
8475 struct sigaction act;
8476 sigfillset(&act.sa_mask);
8477 act.sa_flags = 0;
8478 act.sa_handler = SIG_IGN;
8479 sigaction(SIGPIPE, &act, NULL);
8480 }
8481 #else
8482 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
8483 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8484 QEMU to run on a single CPU */
8485 {
8486 HANDLE h;
8487 DWORD mask, smask;
8488 int i;
8489 h = GetCurrentProcess();
8490 if (GetProcessAffinityMask(h, &mask, &smask)) {
8491 for(i = 0; i < 32; i++) {
8492 if (mask & (1 << i))
8493 break;
8494 }
8495 if (i != 32) {
8496 mask = 1 << i;
8497 SetProcessAffinityMask(h, mask);
8498 }
8499 }
8500 }
8501 #endif
8502
8503 register_machines();
8504 machine = first_machine;
8505 cpu_model = NULL;
8506 initrd_filename = NULL;
8507 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
8508 vga_ram_size = VGA_RAM_SIZE;
8509 #ifdef CONFIG_GDBSTUB
8510 use_gdbstub = 0;
8511 gdbstub_port = DEFAULT_GDBSTUB_PORT;
8512 #endif
8513 snapshot = 0;
8514 nographic = 0;
8515 kernel_filename = NULL;
8516 kernel_cmdline = "";
8517 cyls = heads = secs = 0;
8518 translation = BIOS_ATA_TRANSLATION_AUTO;
8519 pstrcpy(monitor_device, sizeof(monitor_device), "vc");
8520
8521 for(i = 0; i < MAX_VMCHANNEL_DEVICES; i++)
8522 vmchannel_devices[i][0] = '\0';
8523 vmchannel_device_index = 0;
8524
8525 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
8526 for(i = 1; i < MAX_SERIAL_PORTS; i++)
8527 serial_devices[i][0] = '\0';
8528 serial_device_index = 0;
8529
8530 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
8531 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
8532 parallel_devices[i][0] = '\0';
8533 parallel_device_index = 0;
8534
8535 usb_devices_index = 0;
8536
8537 nb_net_clients = 0;
8538 nb_drives = 0;
8539 nb_drives_opt = 0;
8540 hda_index = -1;
8541
8542 nb_nics = 0;
8543 /* default mac address of the first network interface */
8544
8545 optind = 1;
8546 for(;;) {
8547 if (optind >= argc)
8548 break;
8549 r = argv[optind];
8550 if (r[0] != '-') {
8551 hda_index = drive_add(HD_ALIAS, argv[optind++], 0);
8552 } else {
8553 const QEMUOption *popt;
8554
8555 optind++;
8556 /* Treat --foo the same as -foo. */
8557 if (r[1] == '-')
8558 r++;
8559 popt = qemu_options;
8560 for(;;) {
8561 if (!popt->name) {
8562 fprintf(stderr, "%s: invalid option -- '%s'\n",
8563 argv[0], r);
8564 exit(1);
8565 }
8566 if (!strcmp(popt->name, r + 1))
8567 break;
8568 popt++;
8569 }
8570 if (popt->flags & HAS_ARG) {
8571 if (optind >= argc) {
8572 fprintf(stderr, "%s: option '%s' requires an argument\n",
8573 argv[0], r);
8574 exit(1);
8575 }
8576 optarg = argv[optind++];
8577 } else {
8578 optarg = NULL;
8579 }
8580
8581 switch(popt->index) {
8582 case QEMU_OPTION_M:
8583 machine = find_machine(optarg);
8584 if (!machine) {
8585 QEMUMachine *m;
8586 printf("Supported machines are:\n");
8587 for(m = first_machine; m != NULL; m = m->next) {
8588 printf("%-10s %s%s\n",
8589 m->name, m->desc,
8590 m == first_machine ? " (default)" : "");
8591 }
8592 exit(*optarg != '?');
8593 }
8594 break;
8595 case QEMU_OPTION_cpu:
8596 /* hw initialization will check this */
8597 if (*optarg == '?') {
8598 /* XXX: implement xxx_cpu_list for targets that still miss it */
8599 #if defined(cpu_list)
8600 cpu_list(stdout, &fprintf);
8601 #endif
8602 exit(0);
8603 } else {
8604 cpu_model = optarg;
8605 }
8606 break;
8607 case QEMU_OPTION_initrd:
8608 initrd_filename = optarg;
8609 break;
8610 case QEMU_OPTION_hda:
8611 if (cyls == 0)
8612 hda_index = drive_add(HD_ALIAS, optarg, 0);
8613 else
8614 hda_index = drive_add(HD_ALIAS
8615 ",cyls=%d,heads=%d,secs=%d%s",
8616 optarg, 0, cyls, heads, secs,
8617 translation == BIOS_ATA_TRANSLATION_LBA ?
8618 ",trans=lba" :
8619 translation == BIOS_ATA_TRANSLATION_NONE ?
8620 ",trans=none" : "");
8621 break;
8622 case QEMU_OPTION_hdb:
8623 case QEMU_OPTION_hdc:
8624 case QEMU_OPTION_hdd:
8625 drive_add(HD_ALIAS, optarg, popt->index - QEMU_OPTION_hda);
8626 break;
8627 case QEMU_OPTION_drive:
8628 drive_add("%s", optarg);
8629 break;
8630 case QEMU_OPTION_mtdblock:
8631 drive_add(MTD_ALIAS, optarg);
8632 break;
8633 case QEMU_OPTION_sd:
8634 drive_add("file=\"%s\"," SD_ALIAS, optarg);
8635 break;
8636 case QEMU_OPTION_pflash:
8637 drive_add(PFLASH_ALIAS, optarg);
8638 break;
8639 case QEMU_OPTION_snapshot:
8640 snapshot = 1;
8641 break;
8642 case QEMU_OPTION_hdachs:
8643 {
8644 const char *p;
8645 p = optarg;
8646 cyls = strtol(p, (char **)&p, 0);
8647 if (cyls < 1 || cyls > 16383)
8648 goto chs_fail;
8649 if (*p != ',')
8650 goto chs_fail;
8651 p++;
8652 heads = strtol(p, (char **)&p, 0);
8653 if (heads < 1 || heads > 16)
8654 goto chs_fail;
8655 if (*p != ',')
8656 goto chs_fail;
8657 p++;
8658 secs = strtol(p, (char **)&p, 0);
8659 if (secs < 1 || secs > 63)
8660 goto chs_fail;
8661 if (*p == ',') {
8662 p++;
8663 if (!strcmp(p, "none"))
8664 translation = BIOS_ATA_TRANSLATION_NONE;
8665 else if (!strcmp(p, "lba"))
8666 translation = BIOS_ATA_TRANSLATION_LBA;
8667 else if (!strcmp(p, "auto"))
8668 translation = BIOS_ATA_TRANSLATION_AUTO;
8669 else
8670 goto chs_fail;
8671 } else if (*p != '\0') {
8672 chs_fail:
8673 fprintf(stderr, "qemu: invalid physical CHS format\n");
8674 exit(1);
8675 }
8676 if (hda_index != -1)
8677 snprintf(drives_opt[hda_index] +
8678 strlen(drives_opt[hda_index]),
8679 sizeof(drives_opt[0]) -
8680 strlen(drives_opt[hda_index]),
8681 ",cyls=%d,heads=%d,secs=%d%s",
8682 cyls, heads, secs,
8683 translation == BIOS_ATA_TRANSLATION_LBA ?
8684 ",trans=lba" :
8685 translation == BIOS_ATA_TRANSLATION_NONE ?
8686 ",trans=none" : "");
8687 }
8688 break;
8689 case QEMU_OPTION_nographic:
8690 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
8691 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "null");
8692 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
8693 nographic = 1;
8694 break;
8695 case QEMU_OPTION_portrait:
8696 graphic_rotate = 1;
8697 break;
8698 case QEMU_OPTION_kernel:
8699 kernel_filename = optarg;
8700 break;
8701 case QEMU_OPTION_append:
8702 kernel_cmdline = optarg;
8703 break;
8704 case QEMU_OPTION_cdrom:
8705 drive_add("file=\"%s\"," CDROM_ALIAS, optarg);
8706 break;
8707 case QEMU_OPTION_boot:
8708 boot_devices = optarg;
8709 /* We just do some generic consistency checks */
8710 {
8711 /* Could easily be extended to 64 devices if needed */
8712 const char *p;
8713
8714 boot_devices_bitmap = 0;
8715 for (p = boot_devices; *p != '\0'; p++) {
8716 /* Allowed boot devices are:
8717 * a b : floppy disk drives
8718 * c ... f : IDE disk drives
8719 * g ... m : machine implementation dependant drives
8720 * n ... p : network devices
8721 * It's up to each machine implementation to check
8722 * if the given boot devices match the actual hardware
8723 * implementation and firmware features.
8724 */
8725 if (*p < 'a' || *p > 'q') {
8726 fprintf(stderr, "Invalid boot device '%c'\n", *p);
8727 exit(1);
8728 }
8729 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8730 fprintf(stderr,
8731 "Boot device '%c' was given twice\n",*p);
8732 exit(1);
8733 }
8734 boot_devices_bitmap |= 1 << (*p - 'a');
8735 }
8736 }
8737 break;
8738 case QEMU_OPTION_fda:
8739 case QEMU_OPTION_fdb:
8740 drive_add("file=\"%s\"," FD_ALIAS, optarg,
8741 popt->index - QEMU_OPTION_fda);
8742 break;
8743 #ifdef TARGET_I386
8744 case QEMU_OPTION_no_fd_bootchk:
8745 fd_bootchk = 0;
8746 break;
8747 #endif
8748 case QEMU_OPTION_no_code_copy:
8749 code_copy_enabled = 0;
8750 break;
8751 case QEMU_OPTION_net:
8752 if (nb_net_clients >= MAX_NET_CLIENTS) {
8753 fprintf(stderr, "qemu: too many network clients\n");
8754 exit(1);
8755 }
8756 pstrcpy(net_clients[nb_net_clients],
8757 sizeof(net_clients[0]),
8758 optarg);
8759 nb_net_clients++;
8760 break;
8761 #ifdef CONFIG_SLIRP
8762 case QEMU_OPTION_tftp:
8763 tftp_prefix = optarg;
8764 break;
8765 case QEMU_OPTION_bootp:
8766 bootp_filename = optarg;
8767 break;
8768 #ifndef _WIN32
8769 case QEMU_OPTION_smb:
8770 net_slirp_smb(optarg);
8771 break;
8772 #endif
8773 case QEMU_OPTION_redir:
8774 net_slirp_redir(optarg);
8775 break;
8776 #endif
8777 #ifdef HAS_AUDIO
8778 case QEMU_OPTION_audio_help:
8779 AUD_help ();
8780 exit (0);
8781 break;
8782 case QEMU_OPTION_soundhw:
8783 select_soundhw (optarg);
8784 break;
8785 #endif
8786 case QEMU_OPTION_h:
8787 help(0);
8788 break;
8789 case QEMU_OPTION_m:
8790 ram_size = (int64_t)atoi(optarg) * 1024 * 1024;
8791 if (ram_size <= 0)
8792 help(1);
8793 if (ram_size > PHYS_RAM_MAX_SIZE) {
8794 fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
8795 PHYS_RAM_MAX_SIZE / (1024 * 1024));
8796 exit(1);
8797 }
8798 break;
8799 case QEMU_OPTION_d:
8800 {
8801 int mask;
8802 CPULogItem *item;
8803
8804 mask = cpu_str_to_log_mask(optarg);
8805 if (!mask) {
8806 printf("Log items (comma separated):\n");
8807 for(item = cpu_log_items; item->mask != 0; item++) {
8808 printf("%-10s %s\n", item->name, item->help);
8809 }
8810 exit(1);
8811 }
8812 cpu_set_log(mask);
8813 }
8814 break;
8815 #ifdef CONFIG_GDBSTUB
8816 case QEMU_OPTION_s:
8817 use_gdbstub = 1;
8818 break;
8819 case QEMU_OPTION_p:
8820 gdbstub_port = optarg;
8821 break;
8822 #endif
8823 case QEMU_OPTION_L:
8824 bios_dir = optarg;
8825 break;
8826 case QEMU_OPTION_bios:
8827 bios_name = optarg;
8828 break;
8829 case QEMU_OPTION_S:
8830 autostart = 0;
8831 break;
8832 case QEMU_OPTION_k:
8833 keyboard_layout = optarg;
8834 break;
8835 case QEMU_OPTION_localtime:
8836 rtc_utc = 0;
8837 break;
8838 case QEMU_OPTION_cirrusvga:
8839 cirrus_vga_enabled = 1;
8840 vmsvga_enabled = 0;
8841 break;
8842 case QEMU_OPTION_vmsvga:
8843 cirrus_vga_enabled = 0;
8844 vmsvga_enabled = 1;
8845 break;
8846 case QEMU_OPTION_std_vga:
8847 cirrus_vga_enabled = 0;
8848 vmsvga_enabled = 0;
8849 break;
8850 case QEMU_OPTION_g:
8851 {
8852 const char *p;
8853 int w, h, depth;
8854 p = optarg;
8855 w = strtol(p, (char **)&p, 10);
8856 if (w <= 0) {
8857 graphic_error:
8858 fprintf(stderr, "qemu: invalid resolution or depth\n");
8859 exit(1);
8860 }
8861 if (*p != 'x')
8862 goto graphic_error;
8863 p++;
8864 h = strtol(p, (char **)&p, 10);
8865 if (h <= 0)
8866 goto graphic_error;
8867 if (*p == 'x') {
8868 p++;
8869 depth = strtol(p, (char **)&p, 10);
8870 if (depth != 8 && depth != 15 && depth != 16 &&
8871 depth != 24 && depth != 32)
8872 goto graphic_error;
8873 } else if (*p == '\0') {
8874 depth = graphic_depth;
8875 } else {
8876 goto graphic_error;
8877 }
8878
8879 graphic_width = w;
8880 graphic_height = h;
8881 graphic_depth = depth;
8882 }
8883 break;
8884 case QEMU_OPTION_echr:
8885 {
8886 char *r;
8887 term_escape_char = strtol(optarg, &r, 0);
8888 if (r == optarg)
8889 printf("Bad argument to echr\n");
8890 break;
8891 }
8892 case QEMU_OPTION_monitor:
8893 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
8894 break;
8895 case QEMU_OPTION_balloon:
8896 if (vmchannel_device_index >= MAX_VMCHANNEL_DEVICES) {
8897 fprintf(stderr, "qemu: too many balloon/vmchannel devices\n");
8898 exit(1);
8899 }
8900 if (balloon_used) {
8901 fprintf(stderr, "qemu: only one balloon device can be used\n");
8902 exit(1);
8903 }
8904 sprintf(vmchannel_devices[vmchannel_device_index],"di:cdcd,%s", optarg);
8905 vmchannel_device_index++;
8906 balloon_used = 1;
8907 break;
8908 case QEMU_OPTION_vmchannel:
8909 if (vmchannel_device_index >= MAX_VMCHANNEL_DEVICES) {
8910 fprintf(stderr, "qemu: too many balloon/vmchannel devices\n");
8911 exit(1);
8912 }
8913 pstrcpy(vmchannel_devices[vmchannel_device_index],
8914 sizeof(vmchannel_devices[0]), optarg);
8915 vmchannel_device_index++;
8916 break;
8917 case QEMU_OPTION_serial:
8918 if (serial_device_index >= MAX_SERIAL_PORTS) {
8919 fprintf(stderr, "qemu: too many serial ports\n");
8920 exit(1);
8921 }
8922 pstrcpy(serial_devices[serial_device_index],
8923 sizeof(serial_devices[0]), optarg);
8924 serial_device_index++;
8925 break;
8926 case QEMU_OPTION_parallel:
8927 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8928 fprintf(stderr, "qemu: too many parallel ports\n");
8929 exit(1);
8930 }
8931 pstrcpy(parallel_devices[parallel_device_index],
8932 sizeof(parallel_devices[0]), optarg);
8933 parallel_device_index++;
8934 break;
8935 case QEMU_OPTION_loadvm:
8936 loadvm = optarg;
8937 break;
8938 case QEMU_OPTION_incoming:
8939 incoming = optarg;
8940 break;
8941 case QEMU_OPTION_full_screen:
8942 full_screen = 1;
8943 break;
8944 #ifdef CONFIG_SDL
8945 case QEMU_OPTION_no_frame:
8946 no_frame = 1;
8947 break;
8948 case QEMU_OPTION_alt_grab:
8949 alt_grab = 1;
8950 break;
8951 case QEMU_OPTION_no_quit:
8952 no_quit = 1;
8953 break;
8954 #endif
8955 case QEMU_OPTION_pidfile:
8956 pid_file = optarg;
8957 break;
8958 #ifdef TARGET_I386
8959 case QEMU_OPTION_win2k_hack:
8960 win2k_install_hack = 1;
8961 break;
8962 #endif
8963 #ifdef USE_KQEMU
8964 case QEMU_OPTION_no_kqemu:
8965 kqemu_allowed = 0;
8966 break;
8967 case QEMU_OPTION_kernel_kqemu:
8968 kqemu_allowed = 2;
8969 break;
8970 #endif
8971 #ifdef USE_KVM
8972 case QEMU_OPTION_no_kvm:
8973 kvm_allowed = 0;
8974 break;
8975 case QEMU_OPTION_no_kvm_irqchip:
8976 kvm_irqchip = 0;
8977 break;
8978 #endif
8979 case QEMU_OPTION_usb:
8980 usb_enabled = 1;
8981 break;
8982 case QEMU_OPTION_usbdevice:
8983 usb_enabled = 1;
8984 if (usb_devices_index >= MAX_USB_CMDLINE) {
8985 fprintf(stderr, "Too many USB devices\n");
8986 exit(1);
8987 }
8988 pstrcpy(usb_devices[usb_devices_index],
8989 sizeof(usb_devices[usb_devices_index]),
8990 optarg);
8991 usb_devices_index++;
8992 break;
8993 case QEMU_OPTION_smp:
8994 smp_cpus = atoi(optarg);
8995 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
8996 fprintf(stderr, "Invalid number of CPUs\n");
8997 exit(1);
8998 }
8999 break;
9000 case QEMU_OPTION_vnc:
9001 vnc_display = optarg;
9002 break;
9003 case QEMU_OPTION_no_acpi:
9004 acpi_enabled = 0;
9005 break;
9006 case QEMU_OPTION_no_reboot:
9007 no_reboot = 1;
9008 break;
9009 case QEMU_OPTION_show_cursor:
9010 cursor_hide = 0;
9011 break;
9012 case QEMU_OPTION_daemonize:
9013 daemonize = 1;
9014 break;
9015 case QEMU_OPTION_option_rom:
9016 if (nb_option_roms >= MAX_OPTION_ROMS) {
9017 fprintf(stderr, "Too many option ROMs\n");
9018 exit(1);
9019 }
9020 option_rom[nb_option_roms] = optarg;
9021 nb_option_roms++;
9022 break;
9023 case QEMU_OPTION_semihosting:
9024 semihosting_enabled = 1;
9025 break;
9026 case QEMU_OPTION_tdf:
9027 time_drift_fix = 1;
9028 break;
9029 case QEMU_OPTION_kvm_shadow_memory:
9030 kvm_shadow_memory = (int64_t)atoi(optarg) * 1024 * 1024 / 4096;
9031 break;
9032 case QEMU_OPTION_name:
9033 qemu_name = optarg;
9034 break;
9035 #ifdef TARGET_SPARC
9036 case QEMU_OPTION_prom_env:
9037 if (nb_prom_envs >= MAX_PROM_ENVS) {
9038 fprintf(stderr, "Too many prom variables\n");
9039 exit(1);
9040 }
9041 prom_envs[nb_prom_envs] = optarg;
9042 nb_prom_envs++;
9043 break;
9044 #endif
9045 case QEMU_OPTION_cpu_vendor:
9046 cpu_vendor_string = optarg;
9047 break;
9048 #ifdef TARGET_ARM
9049 case QEMU_OPTION_old_param:
9050 old_param = 1;
9051 #endif
9052 case QEMU_OPTION_clock:
9053 configure_alarms(optarg);
9054 break;
9055 case QEMU_OPTION_startdate:
9056 {
9057 struct tm tm;
9058 if (!strcmp(optarg, "now")) {
9059 rtc_start_date = -1;
9060 } else {
9061 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
9062 &tm.tm_year,
9063 &tm.tm_mon,
9064 &tm.tm_mday,
9065 &tm.tm_hour,
9066 &tm.tm_min,
9067 &tm.tm_sec) == 6) {
9068 /* OK */
9069 } else if (sscanf(optarg, "%d-%d-%d",
9070 &tm.tm_year,
9071 &tm.tm_mon,
9072 &tm.tm_mday) == 3) {
9073 tm.tm_hour = 0;
9074 tm.tm_min = 0;
9075 tm.tm_sec = 0;
9076 } else {
9077 goto date_fail;
9078 }
9079 tm.tm_year -= 1900;
9080 tm.tm_mon--;
9081 rtc_start_date = mktimegm(&tm);
9082 if (rtc_start_date == -1) {
9083 date_fail:
9084 fprintf(stderr, "Invalid date format. Valid format are:\n"
9085 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9086 exit(1);
9087 }
9088 }
9089 }
9090 break;
9091 }
9092 }
9093 }
9094
9095 #ifndef _WIN32
9096 if (daemonize) {
9097 pid_t pid;
9098
9099 if (pipe(fds) == -1)
9100 exit(1);
9101
9102 pid = fork();
9103 if (pid > 0) {
9104 uint8_t status;
9105 ssize_t len;
9106
9107 close(fds[1]);
9108
9109 again:
9110 len = read(fds[0], &status, 1);
9111 if (len == -1 && (errno == EINTR))
9112 goto again;
9113
9114 if (len != 1)
9115 exit(1);
9116 else if (status == 1) {
9117 fprintf(stderr, "Could not acquire pidfile\n");
9118 exit(1);
9119 } else
9120 exit(0);
9121 } else if (pid < 0)
9122 exit(1);
9123
9124 setsid();
9125
9126 pid = fork();
9127 if (pid > 0)
9128 exit(0);
9129 else if (pid < 0)
9130 exit(1);
9131
9132 umask(027);
9133
9134 signal(SIGTSTP, SIG_IGN);
9135 signal(SIGTTOU, SIG_IGN);
9136 signal(SIGTTIN, SIG_IGN);
9137 }
9138 #endif
9139
9140 #if USE_KVM
9141 if (kvm_allowed) {
9142 if (kvm_qemu_init() < 0) {
9143 fprintf(stderr, "Could not initialize KVM, will disable KVM support\n");
9144 kvm_allowed = 0;
9145 }
9146 }
9147 #endif
9148
9149 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
9150 if (daemonize) {
9151 uint8_t status = 1;
9152 write(fds[1], &status, 1);
9153 } else
9154 fprintf(stderr, "Could not acquire pid file\n");
9155 exit(1);
9156 }
9157
9158 #ifdef USE_KQEMU
9159 if (smp_cpus > 1)
9160 kqemu_allowed = 0;
9161 #endif
9162 linux_boot = (kernel_filename != NULL);
9163 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
9164
9165 /* XXX: this should not be: some embedded targets just have flash */
9166 if (!linux_boot && net_boot == 0 &&
9167 nb_drives_opt == 0)
9168 help(1);
9169
9170 /* boot to floppy or the default cd if no hard disk defined yet */
9171 if (!boot_devices[0]) {
9172 boot_devices = "cad";
9173 }
9174 setvbuf(stdout, NULL, _IOLBF, 0);
9175
9176 init_timers();
9177 init_timer_alarm();
9178 qemu_aio_init();
9179
9180 #ifdef _WIN32
9181 socket_init();
9182 #endif
9183
9184 /* init network clients */
9185 if (nb_net_clients == 0) {
9186 /* if no clients, we use a default config */
9187 pstrcpy(net_clients[0], sizeof(net_clients[0]),
9188 "nic");
9189 pstrcpy(net_clients[1], sizeof(net_clients[0]),
9190 "user");
9191 nb_net_clients = 2;
9192 }
9193
9194 for(i = 0;i < nb_net_clients; i++) {
9195 if (net_client_init(net_clients[i]) < 0)
9196 exit(1);
9197 }
9198 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9199 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
9200 continue;
9201 if (vlan->nb_guest_devs == 0) {
9202 fprintf(stderr, "Invalid vlan (%d) with no nics\n", vlan->id);
9203 exit(1);
9204 }
9205 if (vlan->nb_host_devs == 0)
9206 fprintf(stderr,
9207 "Warning: vlan %d is not connected to host network\n",
9208 vlan->id);
9209 }
9210
9211 #ifdef TARGET_I386
9212 /* XXX: this should be moved in the PC machine instantiation code */
9213 if (net_boot != 0) {
9214 int netroms = 0;
9215 for (i = 0; i < nb_nics && i < 4; i++) {
9216 const char *model = nd_table[i].model;
9217 char buf[1024];
9218 if (net_boot & (1 << i)) {
9219 if (model == NULL)
9220 model = "ne2k_pci";
9221 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
9222 if (get_image_size(buf) > 0) {
9223 if (nb_option_roms >= MAX_OPTION_ROMS) {
9224 fprintf(stderr, "Too many option ROMs\n");
9225 exit(1);
9226 }
9227 option_rom[nb_option_roms] = strdup(buf);
9228 nb_option_roms++;
9229 netroms++;
9230 }
9231 }
9232 }
9233 if (netroms == 0) {
9234 fprintf(stderr, "No valid PXE rom found for network device\n");
9235 exit(1);
9236 }
9237 }
9238 #endif
9239
9240 /* init the memory */
9241 phys_ram_size = ram_size + vga_ram_size + MAX_BIOS_SIZE;
9242
9243 #if USE_KVM
9244 /* Initialize kvm */
9245 #ifdef TARGET_IA64
9246 #define KVM_EXTRA_PAGES 0
9247 #else
9248 #define KVM_EXTRA_PAGES 3
9249 #endif
9250 if (kvm_allowed) {
9251 phys_ram_size += KVM_EXTRA_PAGES * TARGET_PAGE_SIZE;
9252 if (kvm_qemu_create_context() < 0) {
9253 fprintf(stderr, "Could not create KVM context\n");
9254 exit(1);
9255 }
9256 #ifdef KVM_CAP_USER_MEMORY
9257 {
9258 int ret;
9259
9260 ret = kvm_qemu_check_extension(KVM_CAP_USER_MEMORY);
9261 if (ret) {
9262 phys_ram_base = qemu_vmalloc(phys_ram_size);
9263 if (!phys_ram_base) {
9264 fprintf(stderr, "Could not allocate physical memory\n");
9265 exit(1);
9266 }
9267 }
9268 }
9269 #endif
9270 } else {
9271 phys_ram_base = qemu_vmalloc(phys_ram_size);
9272 if (!phys_ram_base) {
9273 fprintf(stderr, "Could not allocate physical memory\n");
9274 exit(1);
9275 }
9276 }
9277 #else
9278 phys_ram_base = qemu_vmalloc(phys_ram_size);
9279 if (!phys_ram_base) {
9280 fprintf(stderr, "Could not allocate physical memory\n");
9281 exit(1);
9282 }
9283 #endif
9284
9285 bdrv_init();
9286
9287 /* we always create the cdrom drive, even if no disk is there */
9288
9289 if (nb_drives_opt < MAX_DRIVES)
9290 drive_add(CDROM_ALIAS);
9291
9292 /* we always create at least one floppy */
9293
9294 if (nb_drives_opt < MAX_DRIVES)
9295 drive_add(FD_ALIAS, 0);
9296
9297 /* we always create one sd slot, even if no card is in it */
9298
9299 if (nb_drives_opt < MAX_DRIVES)
9300 drive_add(SD_ALIAS);
9301
9302 /* open the virtual block devices */
9303
9304 for(i = 0; i < nb_drives_opt; i++)
9305 if (drive_init(drives_opt[i], snapshot, machine) == -1)
9306 exit(1);
9307
9308 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
9309 register_savevm("ram", 0, 3, ram_save, ram_load, NULL);
9310
9311 init_ioports();
9312
9313 /* terminal init */
9314 memset(&display_state, 0, sizeof(display_state));
9315 if (nographic) {
9316 /* nearly nothing to do */
9317 dumb_display_init(ds);
9318 } else if (vnc_display != NULL) {
9319 vnc_display_init(ds);
9320 if (vnc_display_open(ds, vnc_display) < 0)
9321 exit(1);
9322 } else {
9323 #if defined(CONFIG_SDL)
9324 sdl_display_init(ds, full_screen, no_frame);
9325 #elif defined(CONFIG_COCOA)
9326 cocoa_display_init(ds, full_screen);
9327 #else
9328 dumb_display_init(ds);
9329 #endif
9330 }
9331
9332 /* Maintain compatibility with multiple stdio monitors */
9333 if (!strcmp(monitor_device,"stdio")) {
9334 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
9335 if (!strcmp(serial_devices[i],"mon:stdio")) {
9336 monitor_device[0] = '\0';
9337 break;
9338 } else if (!strcmp(serial_devices[i],"stdio")) {
9339 monitor_device[0] = '\0';
9340 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "mon:stdio");
9341 break;
9342 }
9343 }
9344 }
9345 if (monitor_device[0] != '\0') {
9346 monitor_hd = qemu_chr_open(monitor_device);
9347 if (!monitor_hd) {
9348 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
9349 exit(1);
9350 }
9351 monitor_init(monitor_hd, !nographic);
9352 }
9353
9354 for(i = 0; i < MAX_VMCHANNEL_DEVICES; i++) {
9355 const char *devname = vmchannel_devices[i];
9356 if (devname[0] != '\0' && strcmp(devname, "none")) {
9357 int devid;
9358 char *termn;
9359
9360 if (strstart(devname, "di:", &devname)) {
9361 devid = strtol(devname, &termn, 16);
9362 devname = termn + 1;
9363 }
9364 else {
9365 fprintf(stderr, "qemu: could not find vmchannel device id '%s'\n",
9366 devname);
9367 exit(1);
9368 }
9369 vmchannel_hds[i] = qemu_chr_open(devname);
9370 if (!vmchannel_hds[i]) {
9371 fprintf(stderr, "qemu: could not open vmchannel device '%s'\n",
9372 devname);
9373 exit(1);
9374 }
9375 vmchannel_init(vmchannel_hds[i], devid, i);
9376 }
9377 }
9378
9379 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
9380 const char *devname = serial_devices[i];
9381 if (devname[0] != '\0' && strcmp(devname, "none")) {
9382 serial_hds[i] = qemu_chr_open(devname);
9383 if (!serial_hds[i]) {
9384 fprintf(stderr, "qemu: could not open serial device '%s'\n",
9385 devname);
9386 exit(1);
9387 }
9388 if (strstart(devname, "vc", 0))
9389 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
9390 }
9391 }
9392
9393 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
9394 const char *devname = parallel_devices[i];
9395 if (devname[0] != '\0' && strcmp(devname, "none")) {
9396 parallel_hds[i] = qemu_chr_open(devname);
9397 if (!parallel_hds[i]) {
9398 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
9399 devname);
9400 exit(1);
9401 }
9402 if (strstart(devname, "vc", 0))
9403 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
9404 }
9405 }
9406
9407 machine->init(ram_size, vga_ram_size, boot_devices, ds,
9408 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
9409
9410 /* init USB devices */
9411 if (usb_enabled) {
9412 for(i = 0; i < usb_devices_index; i++) {
9413 if (usb_device_add(usb_devices[i]) < 0) {
9414 fprintf(stderr, "Warning: could not add USB device %s\n",
9415 usb_devices[i]);
9416 }
9417 }
9418 }
9419
9420 if (display_state.dpy_refresh) {
9421 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
9422 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
9423 }
9424
9425 #ifdef USE_KVM
9426 if (kvm_allowed)
9427 kvm_init_ap();
9428 #endif
9429
9430 #ifdef CONFIG_GDBSTUB
9431 if (use_gdbstub) {
9432 /* XXX: use standard host:port notation and modify options
9433 accordingly. */
9434 if (gdbserver_start(gdbstub_port) < 0) {
9435 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
9436 gdbstub_port);
9437 exit(1);
9438 }
9439 }
9440 #endif
9441 if (loadvm)
9442 do_loadvm(loadvm);
9443
9444 if (incoming) {
9445 int rc;
9446
9447 rc = migrate_incoming(incoming);
9448 if (rc != 0) {
9449 fprintf(stderr, "Migration failed rc=%d\n", rc);
9450 exit(rc);
9451 }
9452 }
9453
9454 {
9455 /* XXX: simplify init */
9456 read_passwords();
9457 if (autostart) {
9458 vm_start();
9459 }
9460 }
9461
9462 if (daemonize) {
9463 uint8_t status = 0;
9464 ssize_t len;
9465 int fd;
9466
9467 again1:
9468 len = write(fds[1], &status, 1);
9469 if (len == -1 && (errno == EINTR))
9470 goto again1;
9471
9472 if (len != 1)
9473 exit(1);
9474
9475 chdir("/");
9476 TFR(fd = open("/dev/null", O_RDWR));
9477 if (fd == -1)
9478 exit(1);
9479
9480 dup2(fd, 0);
9481 dup2(fd, 1);
9482 dup2(fd, 2);
9483
9484 close(fd);
9485 }
9486
9487 main_loop();
9488 quit_timers();
9489
9490 #if !defined(_WIN32)
9491 /* close network clients */
9492 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9493 VLANClientState *vc;
9494
9495 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
9496 if (vc->fd_read == tap_receive) {
9497 char ifname[64];
9498 TAPState *s = vc->opaque;
9499
9500 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
9501 s->down_script[0])
9502 launch_script(s->down_script, ifname, s->fd);
9503 }
9504 }
9505 }
9506 #endif
9507 return 0;
9508 }
Patches shipped by Fedora