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