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