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