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