?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make various generated structures static
[qemu/mini2440.git] / vl.c
blobc94fdc02b6dca4ef25d508d4adca28f8c6b33a2a
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "hw/hw.h"
25 #include "hw/boards.h"
26 #include "hw/usb.h"
27 #include "hw/pcmcia.h"
28 #include "hw/pc.h"
29 #include "hw/audiodev.h"
30 #include "hw/isa.h"
31 #include "hw/baum.h"
32 #include "hw/bt.h"
33 #include "net.h"
34 #include "console.h"
35 #include "sysemu.h"
36 #include "gdbstub.h"
37 #include "qemu-timer.h"
38 #include "qemu-char.h"
39 #include "block.h"
40 #include "audio/audio.h"
41
42 #include <unistd.h>
43 #include <fcntl.h>
44 #include <signal.h>
45 #include <time.h>
46 #include <errno.h>
47 #include <sys/time.h>
48 #include <zlib.h>
49
50 #ifndef _WIN32
51 #include <sys/times.h>
52 #include <sys/wait.h>
53 #include <termios.h>
54 #include <sys/poll.h>
55 #include <sys/mman.h>
56 #include <sys/ioctl.h>
57 #include <sys/socket.h>
58 #include <netinet/in.h>
59 #include <dirent.h>
60 #include <netdb.h>
61 #include <sys/select.h>
62 #include <arpa/inet.h>
63 #ifdef _BSD
64 #include <sys/stat.h>
65 #if !defined(__APPLE__) && !defined(__OpenBSD__)
66 #include <libutil.h>
67 #endif
68 #ifdef __OpenBSD__
69 #include <net/if.h>
70 #endif
71 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
72 #include <freebsd/stdlib.h>
73 #else
74 #ifdef __linux__
75 #include <linux/if.h>
76 #include <linux/if_tun.h>
77 #include <pty.h>
78 #include <malloc.h>
79 #include <linux/rtc.h>
80
81 /* For the benefit of older linux systems which don't supply it,
82 we use a local copy of hpet.h. */
83 /* #include <linux/hpet.h> */
84 #include "hpet.h"
85
86 #include <linux/ppdev.h>
87 #include <linux/parport.h>
88 #endif
89 #ifdef __sun__
90 #include <sys/stat.h>
91 #include <sys/ethernet.h>
92 #include <sys/sockio.h>
93 #include <netinet/arp.h>
94 #include <netinet/in.h>
95 #include <netinet/in_systm.h>
96 #include <netinet/ip.h>
97 #include <netinet/ip_icmp.h> // must come after ip.h
98 #include <netinet/udp.h>
99 #include <netinet/tcp.h>
100 #include <net/if.h>
101 #include <syslog.h>
102 #include <stropts.h>
103 #endif
104 #endif
105 #endif
106
107 #include "qemu_socket.h"
108
109 #if defined(CONFIG_SLIRP)
110 #include "libslirp.h"
111 #endif
112
113 #if defined(__OpenBSD__)
114 #include <util.h>
115 #endif
116
117 #if defined(CONFIG_VDE)
118 #include <libvdeplug.h>
119 #endif
120
121 #ifdef _WIN32
122 #include <malloc.h>
123 #include <sys/timeb.h>
124 #include <mmsystem.h>
125 #define getopt_long_only getopt_long
126 #define memalign(align, size) malloc(size)
127 #endif
128
129 #ifdef CONFIG_SDL
130 #ifdef __APPLE__
131 #include <SDL/SDL.h>
132 #endif
133 #endif /* CONFIG_SDL */
134
135 #ifdef CONFIG_COCOA
136 #undef main
137 #define main qemu_main
138 #endif /* CONFIG_COCOA */
139
140 #include "disas.h"
141
142 #include "exec-all.h"
143
144 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
145 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
146 #ifdef __sun__
147 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
148 #else
149 #define SMBD_COMMAND "/usr/sbin/smbd"
150 #endif
151
152 //#define DEBUG_UNUSED_IOPORT
153 //#define DEBUG_IOPORT
154 //#define DEBUG_NET
155 //#define DEBUG_SLIRP
156
157 #ifdef TARGET_PPC
158 #define DEFAULT_RAM_SIZE 144
159 #else
160 #define DEFAULT_RAM_SIZE 128
161 #endif
162
163 /* Max number of USB devices that can be specified on the commandline. */
164 #define MAX_USB_CMDLINE 8
165
166 /* XXX: use a two level table to limit memory usage */
167 #define MAX_IOPORTS 65536
168
169 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
170 const char *bios_name = NULL;
171 static void *ioport_opaque[MAX_IOPORTS];
172 static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
173 static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
174 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
175 to store the VM snapshots */
176 DriveInfo drives_table[MAX_DRIVES+1];
177 int nb_drives;
178 /* point to the block driver where the snapshots are managed */
179 static BlockDriverState *bs_snapshots;
180 static int vga_ram_size;
181 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
182 static DisplayState display_state;
183 int nographic;
184 static int curses;
185 const char* keyboard_layout = NULL;
186 int64_t ticks_per_sec;
187 ram_addr_t ram_size;
188 int nb_nics;
189 NICInfo nd_table[MAX_NICS];
190 int vm_running;
191 static int rtc_utc = 1;
192 static int rtc_date_offset = -1; /* -1 means no change */
193 int cirrus_vga_enabled = 1;
194 int vmsvga_enabled = 0;
195 #ifdef TARGET_SPARC
196 int graphic_width = 1024;
197 int graphic_height = 768;
198 int graphic_depth = 8;
199 #else
200 int graphic_width = 800;
201 int graphic_height = 600;
202 int graphic_depth = 15;
203 #endif
204 static int full_screen = 0;
205 static int no_frame = 0;
206 int no_quit = 0;
207 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
208 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
209 #ifdef TARGET_I386
210 int win2k_install_hack = 0;
211 #endif
212 int usb_enabled = 0;
213 static VLANState *first_vlan;
214 int smp_cpus = 1;
215 const char *vnc_display;
216 #if defined(TARGET_SPARC)
217 #define MAX_CPUS 16
218 #elif defined(TARGET_I386)
219 #define MAX_CPUS 255
220 #else
221 #define MAX_CPUS 1
222 #endif
223 int acpi_enabled = 1;
224 int fd_bootchk = 1;
225 int no_reboot = 0;
226 int no_shutdown = 0;
227 int cursor_hide = 1;
228 int graphic_rotate = 0;
229 int daemonize = 0;
230 const char *option_rom[MAX_OPTION_ROMS];
231 int nb_option_roms;
232 int semihosting_enabled = 0;
233 #ifdef TARGET_ARM
234 int old_param = 0;
235 #endif
236 const char *qemu_name;
237 int alt_grab = 0;
238 #ifdef TARGET_SPARC
239 unsigned int nb_prom_envs = 0;
240 const char *prom_envs[MAX_PROM_ENVS];
241 #endif
242 static int nb_drives_opt;
243 static struct drive_opt {
244 const char *file;
245 char opt[1024];
246 } drives_opt[MAX_DRIVES];
247
248 static CPUState *cur_cpu;
249 static CPUState *next_cpu;
250 static int event_pending = 1;
251 /* Conversion factor from emulated instructions to virtual clock ticks. */
252 static int icount_time_shift;
253 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
254 #define MAX_ICOUNT_SHIFT 10
255 /* Compensate for varying guest execution speed. */
256 static int64_t qemu_icount_bias;
257 static QEMUTimer *icount_rt_timer;
258 static QEMUTimer *icount_vm_timer;
259
260 uint8_t qemu_uuid[16];
261
262 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
263
264 /***********************************************************/
265 /* x86 ISA bus support */
266
267 target_phys_addr_t isa_mem_base = 0;
268 PicState2 *isa_pic;
269
270 static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
271 static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
272
273 static uint32_t ioport_read(int index, uint32_t address)
274 {
275 static IOPortReadFunc *default_func[3] = {
276 default_ioport_readb,
277 default_ioport_readw,
278 default_ioport_readl
279 };
280 IOPortReadFunc *func = ioport_read_table[index][address];
281 if (!func)
282 func = default_func[index];
283 return func(ioport_opaque[address], address);
284 }
285
286 static void ioport_write(int index, uint32_t address, uint32_t data)
287 {
288 static IOPortWriteFunc *default_func[3] = {
289 default_ioport_writeb,
290 default_ioport_writew,
291 default_ioport_writel
292 };
293 IOPortWriteFunc *func = ioport_write_table[index][address];
294 if (!func)
295 func = default_func[index];
296 func(ioport_opaque[address], address, data);
297 }
298
299 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
300 {
301 #ifdef DEBUG_UNUSED_IOPORT
302 fprintf(stderr, "unused inb: port=0x%04x\n", address);
303 #endif
304 return 0xff;
305 }
306
307 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
308 {
309 #ifdef DEBUG_UNUSED_IOPORT
310 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
311 #endif
312 }
313
314 /* default is to make two byte accesses */
315 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
316 {
317 uint32_t data;
318 data = ioport_read(0, address);
319 address = (address + 1) & (MAX_IOPORTS - 1);
320 data |= ioport_read(0, address) << 8;
321 return data;
322 }
323
324 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
325 {
326 ioport_write(0, address, data & 0xff);
327 address = (address + 1) & (MAX_IOPORTS - 1);
328 ioport_write(0, address, (data >> 8) & 0xff);
329 }
330
331 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
332 {
333 #ifdef DEBUG_UNUSED_IOPORT
334 fprintf(stderr, "unused inl: port=0x%04x\n", address);
335 #endif
336 return 0xffffffff;
337 }
338
339 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
340 {
341 #ifdef DEBUG_UNUSED_IOPORT
342 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
343 #endif
344 }
345
346 /* size is the word size in byte */
347 int register_ioport_read(int start, int length, int size,
348 IOPortReadFunc *func, void *opaque)
349 {
350 int i, bsize;
351
352 if (size == 1) {
353 bsize = 0;
354 } else if (size == 2) {
355 bsize = 1;
356 } else if (size == 4) {
357 bsize = 2;
358 } else {
359 hw_error("register_ioport_read: invalid size");
360 return -1;
361 }
362 for(i = start; i < start + length; i += size) {
363 ioport_read_table[bsize][i] = func;
364 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
365 hw_error("register_ioport_read: invalid opaque");
366 ioport_opaque[i] = opaque;
367 }
368 return 0;
369 }
370
371 /* size is the word size in byte */
372 int register_ioport_write(int start, int length, int size,
373 IOPortWriteFunc *func, void *opaque)
374 {
375 int i, bsize;
376
377 if (size == 1) {
378 bsize = 0;
379 } else if (size == 2) {
380 bsize = 1;
381 } else if (size == 4) {
382 bsize = 2;
383 } else {
384 hw_error("register_ioport_write: invalid size");
385 return -1;
386 }
387 for(i = start; i < start + length; i += size) {
388 ioport_write_table[bsize][i] = func;
389 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
390 hw_error("register_ioport_write: invalid opaque");
391 ioport_opaque[i] = opaque;
392 }
393 return 0;
394 }
395
396 void isa_unassign_ioport(int start, int length)
397 {
398 int i;
399
400 for(i = start; i < start + length; i++) {
401 ioport_read_table[0][i] = default_ioport_readb;
402 ioport_read_table[1][i] = default_ioport_readw;
403 ioport_read_table[2][i] = default_ioport_readl;
404
405 ioport_write_table[0][i] = default_ioport_writeb;
406 ioport_write_table[1][i] = default_ioport_writew;
407 ioport_write_table[2][i] = default_ioport_writel;
408 }
409 }
410
411 /***********************************************************/
412
413 void cpu_outb(CPUState *env, int addr, int val)
414 {
415 #ifdef DEBUG_IOPORT
416 if (loglevel & CPU_LOG_IOPORT)
417 fprintf(logfile, "outb: %04x %02x\n", addr, val);
418 #endif
419 ioport_write(0, addr, val);
420 #ifdef USE_KQEMU
421 if (env)
422 env->last_io_time = cpu_get_time_fast();
423 #endif
424 }
425
426 void cpu_outw(CPUState *env, int addr, int val)
427 {
428 #ifdef DEBUG_IOPORT
429 if (loglevel & CPU_LOG_IOPORT)
430 fprintf(logfile, "outw: %04x %04x\n", addr, val);
431 #endif
432 ioport_write(1, addr, val);
433 #ifdef USE_KQEMU
434 if (env)
435 env->last_io_time = cpu_get_time_fast();
436 #endif
437 }
438
439 void cpu_outl(CPUState *env, int addr, int val)
440 {
441 #ifdef DEBUG_IOPORT
442 if (loglevel & CPU_LOG_IOPORT)
443 fprintf(logfile, "outl: %04x %08x\n", addr, val);
444 #endif
445 ioport_write(2, addr, val);
446 #ifdef USE_KQEMU
447 if (env)
448 env->last_io_time = cpu_get_time_fast();
449 #endif
450 }
451
452 int cpu_inb(CPUState *env, int addr)
453 {
454 int val;
455 val = ioport_read(0, addr);
456 #ifdef DEBUG_IOPORT
457 if (loglevel & CPU_LOG_IOPORT)
458 fprintf(logfile, "inb : %04x %02x\n", addr, val);
459 #endif
460 #ifdef USE_KQEMU
461 if (env)
462 env->last_io_time = cpu_get_time_fast();
463 #endif
464 return val;
465 }
466
467 int cpu_inw(CPUState *env, int addr)
468 {
469 int val;
470 val = ioport_read(1, addr);
471 #ifdef DEBUG_IOPORT
472 if (loglevel & CPU_LOG_IOPORT)
473 fprintf(logfile, "inw : %04x %04x\n", addr, val);
474 #endif
475 #ifdef USE_KQEMU
476 if (env)
477 env->last_io_time = cpu_get_time_fast();
478 #endif
479 return val;
480 }
481
482 int cpu_inl(CPUState *env, int addr)
483 {
484 int val;
485 val = ioport_read(2, addr);
486 #ifdef DEBUG_IOPORT
487 if (loglevel & CPU_LOG_IOPORT)
488 fprintf(logfile, "inl : %04x %08x\n", addr, val);
489 #endif
490 #ifdef USE_KQEMU
491 if (env)
492 env->last_io_time = cpu_get_time_fast();
493 #endif
494 return val;
495 }
496
497 /***********************************************************/
498 void hw_error(const char *fmt, ...)
499 {
500 va_list ap;
501 CPUState *env;
502
503 va_start(ap, fmt);
504 fprintf(stderr, "qemu: hardware error: ");
505 vfprintf(stderr, fmt, ap);
506 fprintf(stderr, "\n");
507 for(env = first_cpu; env != NULL; env = env->next_cpu) {
508 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
509 #ifdef TARGET_I386
510 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
511 #else
512 cpu_dump_state(env, stderr, fprintf, 0);
513 #endif
514 }
515 va_end(ap);
516 abort();
517 }
518
519 /***********************************************************/
520 /* keyboard/mouse */
521
522 static QEMUPutKBDEvent *qemu_put_kbd_event;
523 static void *qemu_put_kbd_event_opaque;
524 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
525 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
526
527 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
528 {
529 qemu_put_kbd_event_opaque = opaque;
530 qemu_put_kbd_event = func;
531 }
532
533 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
534 void *opaque, int absolute,
535 const char *name)
536 {
537 QEMUPutMouseEntry *s, *cursor;
538
539 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
540 if (!s)
541 return NULL;
542
543 s->qemu_put_mouse_event = func;
544 s->qemu_put_mouse_event_opaque = opaque;
545 s->qemu_put_mouse_event_absolute = absolute;
546 s->qemu_put_mouse_event_name = qemu_strdup(name);
547 s->next = NULL;
548
549 if (!qemu_put_mouse_event_head) {
550 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
551 return s;
552 }
553
554 cursor = qemu_put_mouse_event_head;
555 while (cursor->next != NULL)
556 cursor = cursor->next;
557
558 cursor->next = s;
559 qemu_put_mouse_event_current = s;
560
561 return s;
562 }
563
564 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
565 {
566 QEMUPutMouseEntry *prev = NULL, *cursor;
567
568 if (!qemu_put_mouse_event_head || entry == NULL)
569 return;
570
571 cursor = qemu_put_mouse_event_head;
572 while (cursor != NULL && cursor != entry) {
573 prev = cursor;
574 cursor = cursor->next;
575 }
576
577 if (cursor == NULL) // does not exist or list empty
578 return;
579 else if (prev == NULL) { // entry is head
580 qemu_put_mouse_event_head = cursor->next;
581 if (qemu_put_mouse_event_current == entry)
582 qemu_put_mouse_event_current = cursor->next;
583 qemu_free(entry->qemu_put_mouse_event_name);
584 qemu_free(entry);
585 return;
586 }
587
588 prev->next = entry->next;
589
590 if (qemu_put_mouse_event_current == entry)
591 qemu_put_mouse_event_current = prev;
592
593 qemu_free(entry->qemu_put_mouse_event_name);
594 qemu_free(entry);
595 }
596
597 void kbd_put_keycode(int keycode)
598 {
599 if (qemu_put_kbd_event) {
600 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
601 }
602 }
603
604 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
605 {
606 QEMUPutMouseEvent *mouse_event;
607 void *mouse_event_opaque;
608 int width;
609
610 if (!qemu_put_mouse_event_current) {
611 return;
612 }
613
614 mouse_event =
615 qemu_put_mouse_event_current->qemu_put_mouse_event;
616 mouse_event_opaque =
617 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
618
619 if (mouse_event) {
620 if (graphic_rotate) {
621 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
622 width = 0x7fff;
623 else
624 width = graphic_width - 1;
625 mouse_event(mouse_event_opaque,
626 width - dy, dx, dz, buttons_state);
627 } else
628 mouse_event(mouse_event_opaque,
629 dx, dy, dz, buttons_state);
630 }
631 }
632
633 int kbd_mouse_is_absolute(void)
634 {
635 if (!qemu_put_mouse_event_current)
636 return 0;
637
638 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
639 }
640
641 void do_info_mice(void)
642 {
643 QEMUPutMouseEntry *cursor;
644 int index = 0;
645
646 if (!qemu_put_mouse_event_head) {
647 term_printf("No mouse devices connected\n");
648 return;
649 }
650
651 term_printf("Mouse devices available:\n");
652 cursor = qemu_put_mouse_event_head;
653 while (cursor != NULL) {
654 term_printf("%c Mouse #%d: %s\n",
655 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
656 index, cursor->qemu_put_mouse_event_name);
657 index++;
658 cursor = cursor->next;
659 }
660 }
661
662 void do_mouse_set(int index)
663 {
664 QEMUPutMouseEntry *cursor;
665 int i = 0;
666
667 if (!qemu_put_mouse_event_head) {
668 term_printf("No mouse devices connected\n");
669 return;
670 }
671
672 cursor = qemu_put_mouse_event_head;
673 while (cursor != NULL && index != i) {
674 i++;
675 cursor = cursor->next;
676 }
677
678 if (cursor != NULL)
679 qemu_put_mouse_event_current = cursor;
680 else
681 term_printf("Mouse at given index not found\n");
682 }
683
684 /* compute with 96 bit intermediate result: (a*b)/c */
685 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
686 {
687 union {
688 uint64_t ll;
689 struct {
690 #ifdef WORDS_BIGENDIAN
691 uint32_t high, low;
692 #else
693 uint32_t low, high;
694 #endif
695 } l;
696 } u, res;
697 uint64_t rl, rh;
698
699 u.ll = a;
700 rl = (uint64_t)u.l.low * (uint64_t)b;
701 rh = (uint64_t)u.l.high * (uint64_t)b;
702 rh += (rl >> 32);
703 res.l.high = rh / c;
704 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
705 return res.ll;
706 }
707
708 /***********************************************************/
709 /* real time host monotonic timer */
710
711 #define QEMU_TIMER_BASE 1000000000LL
712
713 #ifdef WIN32
714
715 static int64_t clock_freq;
716
717 static void init_get_clock(void)
718 {
719 LARGE_INTEGER freq;
720 int ret;
721 ret = QueryPerformanceFrequency(&freq);
722 if (ret == 0) {
723 fprintf(stderr, "Could not calibrate ticks\n");
724 exit(1);
725 }
726 clock_freq = freq.QuadPart;
727 }
728
729 static int64_t get_clock(void)
730 {
731 LARGE_INTEGER ti;
732 QueryPerformanceCounter(&ti);
733 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
734 }
735
736 #else
737
738 static int use_rt_clock;
739
740 static void init_get_clock(void)
741 {
742 use_rt_clock = 0;
743 #if defined(__linux__)
744 {
745 struct timespec ts;
746 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
747 use_rt_clock = 1;
748 }
749 }
750 #endif
751 }
752
753 static int64_t get_clock(void)
754 {
755 #if defined(__linux__)
756 if (use_rt_clock) {
757 struct timespec ts;
758 clock_gettime(CLOCK_MONOTONIC, &ts);
759 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
760 } else
761 #endif
762 {
763 /* XXX: using gettimeofday leads to problems if the date
764 changes, so it should be avoided. */
765 struct timeval tv;
766 gettimeofday(&tv, NULL);
767 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
768 }
769 }
770 #endif
771
772 /* Return the virtual CPU time, based on the instruction counter. */
773 static int64_t cpu_get_icount(void)
774 {
775 int64_t icount;
776 CPUState *env = cpu_single_env;;
777 icount = qemu_icount;
778 if (env) {
779 if (!can_do_io(env))
780 fprintf(stderr, "Bad clock read\n");
781 icount -= (env->icount_decr.u16.low + env->icount_extra);
782 }
783 return qemu_icount_bias + (icount << icount_time_shift);
784 }
785
786 /***********************************************************/
787 /* guest cycle counter */
788
789 static int64_t cpu_ticks_prev;
790 static int64_t cpu_ticks_offset;
791 static int64_t cpu_clock_offset;
792 static int cpu_ticks_enabled;
793
794 /* return the host CPU cycle counter and handle stop/restart */
795 int64_t cpu_get_ticks(void)
796 {
797 if (use_icount) {
798 return cpu_get_icount();
799 }
800 if (!cpu_ticks_enabled) {
801 return cpu_ticks_offset;
802 } else {
803 int64_t ticks;
804 ticks = cpu_get_real_ticks();
805 if (cpu_ticks_prev > ticks) {
806 /* Note: non increasing ticks may happen if the host uses
807 software suspend */
808 cpu_ticks_offset += cpu_ticks_prev - ticks;
809 }
810 cpu_ticks_prev = ticks;
811 return ticks + cpu_ticks_offset;
812 }
813 }
814
815 /* return the host CPU monotonic timer and handle stop/restart */
816 static int64_t cpu_get_clock(void)
817 {
818 int64_t ti;
819 if (!cpu_ticks_enabled) {
820 return cpu_clock_offset;
821 } else {
822 ti = get_clock();
823 return ti + cpu_clock_offset;
824 }
825 }
826
827 /* enable cpu_get_ticks() */
828 void cpu_enable_ticks(void)
829 {
830 if (!cpu_ticks_enabled) {
831 cpu_ticks_offset -= cpu_get_real_ticks();
832 cpu_clock_offset -= get_clock();
833 cpu_ticks_enabled = 1;
834 }
835 }
836
837 /* disable cpu_get_ticks() : the clock is stopped. You must not call
838 cpu_get_ticks() after that. */
839 void cpu_disable_ticks(void)
840 {
841 if (cpu_ticks_enabled) {
842 cpu_ticks_offset = cpu_get_ticks();
843 cpu_clock_offset = cpu_get_clock();
844 cpu_ticks_enabled = 0;
845 }
846 }
847
848 /***********************************************************/
849 /* timers */
850
851 #define QEMU_TIMER_REALTIME 0
852 #define QEMU_TIMER_VIRTUAL 1
853
854 struct QEMUClock {
855 int type;
856 /* XXX: add frequency */
857 };
858
859 struct QEMUTimer {
860 QEMUClock *clock;
861 int64_t expire_time;
862 QEMUTimerCB *cb;
863 void *opaque;
864 struct QEMUTimer *next;
865 };
866
867 struct qemu_alarm_timer {
868 char const *name;
869 unsigned int flags;
870
871 int (*start)(struct qemu_alarm_timer *t);
872 void (*stop)(struct qemu_alarm_timer *t);
873 void (*rearm)(struct qemu_alarm_timer *t);
874 void *priv;
875 };
876
877 #define ALARM_FLAG_DYNTICKS 0x1
878 #define ALARM_FLAG_EXPIRED 0x2
879
880 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
881 {
882 return t->flags & ALARM_FLAG_DYNTICKS;
883 }
884
885 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
886 {
887 if (!alarm_has_dynticks(t))
888 return;
889
890 t->rearm(t);
891 }
892
893 /* TODO: MIN_TIMER_REARM_US should be optimized */
894 #define MIN_TIMER_REARM_US 250
895
896 static struct qemu_alarm_timer *alarm_timer;
897
898 #ifdef _WIN32
899
900 struct qemu_alarm_win32 {
901 MMRESULT timerId;
902 HANDLE host_alarm;
903 unsigned int period;
904 } alarm_win32_data = {0, NULL, -1};
905
906 static int win32_start_timer(struct qemu_alarm_timer *t);
907 static void win32_stop_timer(struct qemu_alarm_timer *t);
908 static void win32_rearm_timer(struct qemu_alarm_timer *t);
909
910 #else
911
912 static int unix_start_timer(struct qemu_alarm_timer *t);
913 static void unix_stop_timer(struct qemu_alarm_timer *t);
914
915 #ifdef __linux__
916
917 static int dynticks_start_timer(struct qemu_alarm_timer *t);
918 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
919 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
920
921 static int hpet_start_timer(struct qemu_alarm_timer *t);
922 static void hpet_stop_timer(struct qemu_alarm_timer *t);
923
924 static int rtc_start_timer(struct qemu_alarm_timer *t);
925 static void rtc_stop_timer(struct qemu_alarm_timer *t);
926
927 #endif /* __linux__ */
928
929 #endif /* _WIN32 */
930
931 /* Correlation between real and virtual time is always going to be
932 fairly approximate, so ignore small variation.
933 When the guest is idle real and virtual time will be aligned in
934 the IO wait loop. */
935 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
936
937 static void icount_adjust(void)
938 {
939 int64_t cur_time;
940 int64_t cur_icount;
941 int64_t delta;
942 static int64_t last_delta;
943 /* If the VM is not running, then do nothing. */
944 if (!vm_running)
945 return;
946
947 cur_time = cpu_get_clock();
948 cur_icount = qemu_get_clock(vm_clock);
949 delta = cur_icount - cur_time;
950 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
951 if (delta > 0
952 && last_delta + ICOUNT_WOBBLE < delta * 2
953 && icount_time_shift > 0) {
954 /* The guest is getting too far ahead. Slow time down. */
955 icount_time_shift--;
956 }
957 if (delta < 0
958 && last_delta - ICOUNT_WOBBLE > delta * 2
959 && icount_time_shift < MAX_ICOUNT_SHIFT) {
960 /* The guest is getting too far behind. Speed time up. */
961 icount_time_shift++;
962 }
963 last_delta = delta;
964 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
965 }
966
967 static void icount_adjust_rt(void * opaque)
968 {
969 qemu_mod_timer(icount_rt_timer,
970 qemu_get_clock(rt_clock) + 1000);
971 icount_adjust();
972 }
973
974 static void icount_adjust_vm(void * opaque)
975 {
976 qemu_mod_timer(icount_vm_timer,
977 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
978 icount_adjust();
979 }
980
981 static void init_icount_adjust(void)
982 {
983 /* Have both realtime and virtual time triggers for speed adjustment.
984 The realtime trigger catches emulated time passing too slowly,
985 the virtual time trigger catches emulated time passing too fast.
986 Realtime triggers occur even when idle, so use them less frequently
987 than VM triggers. */
988 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
989 qemu_mod_timer(icount_rt_timer,
990 qemu_get_clock(rt_clock) + 1000);
991 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
992 qemu_mod_timer(icount_vm_timer,
993 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
994 }
995
996 static struct qemu_alarm_timer alarm_timers[] = {
997 #ifndef _WIN32
998 #ifdef __linux__
999 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1000 dynticks_stop_timer, dynticks_rearm_timer, NULL},
1001 /* HPET - if available - is preferred */
1002 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1003 /* ...otherwise try RTC */
1004 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1005 #endif
1006 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1007 #else
1008 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1009 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1010 {"win32", 0, win32_start_timer,
1011 win32_stop_timer, NULL, &alarm_win32_data},
1012 #endif
1013 {NULL, }
1014 };
1015
1016 static void show_available_alarms(void)
1017 {
1018 int i;
1019
1020 printf("Available alarm timers, in order of precedence:\n");
1021 for (i = 0; alarm_timers[i].name; i++)
1022 printf("%s\n", alarm_timers[i].name);
1023 }
1024
1025 static void configure_alarms(char const *opt)
1026 {
1027 int i;
1028 int cur = 0;
1029 int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
1030 char *arg;
1031 char *name;
1032 struct qemu_alarm_timer tmp;
1033
1034 if (!strcmp(opt, "?")) {
1035 show_available_alarms();
1036 exit(0);
1037 }
1038
1039 arg = strdup(opt);
1040
1041 /* Reorder the array */
1042 name = strtok(arg, ",");
1043 while (name) {
1044 for (i = 0; i < count && alarm_timers[i].name; i++) {
1045 if (!strcmp(alarm_timers[i].name, name))
1046 break;
1047 }
1048
1049 if (i == count) {
1050 fprintf(stderr, "Unknown clock %s\n", name);
1051 goto next;
1052 }
1053
1054 if (i < cur)
1055 /* Ignore */
1056 goto next;
1057
1058 /* Swap */
1059 tmp = alarm_timers[i];
1060 alarm_timers[i] = alarm_timers[cur];
1061 alarm_timers[cur] = tmp;
1062
1063 cur++;
1064 next:
1065 name = strtok(NULL, ",");
1066 }
1067
1068 free(arg);
1069
1070 if (cur) {
1071 /* Disable remaining timers */
1072 for (i = cur; i < count; i++)
1073 alarm_timers[i].name = NULL;
1074 } else {
1075 show_available_alarms();
1076 exit(1);
1077 }
1078 }
1079
1080 QEMUClock *rt_clock;
1081 QEMUClock *vm_clock;
1082
1083 static QEMUTimer *active_timers[2];
1084
1085 static QEMUClock *qemu_new_clock(int type)
1086 {
1087 QEMUClock *clock;
1088 clock = qemu_mallocz(sizeof(QEMUClock));
1089 if (!clock)
1090 return NULL;
1091 clock->type = type;
1092 return clock;
1093 }
1094
1095 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1096 {
1097 QEMUTimer *ts;
1098
1099 ts = qemu_mallocz(sizeof(QEMUTimer));
1100 ts->clock = clock;
1101 ts->cb = cb;
1102 ts->opaque = opaque;
1103 return ts;
1104 }
1105
1106 void qemu_free_timer(QEMUTimer *ts)
1107 {
1108 qemu_free(ts);
1109 }
1110
1111 /* stop a timer, but do not dealloc it */
1112 void qemu_del_timer(QEMUTimer *ts)
1113 {
1114 QEMUTimer **pt, *t;
1115
1116 /* NOTE: this code must be signal safe because
1117 qemu_timer_expired() can be called from a signal. */
1118 pt = &active_timers[ts->clock->type];
1119 for(;;) {
1120 t = *pt;
1121 if (!t)
1122 break;
1123 if (t == ts) {
1124 *pt = t->next;
1125 break;
1126 }
1127 pt = &t->next;
1128 }
1129 }
1130
1131 /* modify the current timer so that it will be fired when current_time
1132 >= expire_time. The corresponding callback will be called. */
1133 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1134 {
1135 QEMUTimer **pt, *t;
1136
1137 qemu_del_timer(ts);
1138
1139 /* add the timer in the sorted list */
1140 /* NOTE: this code must be signal safe because
1141 qemu_timer_expired() can be called from a signal. */
1142 pt = &active_timers[ts->clock->type];
1143 for(;;) {
1144 t = *pt;
1145 if (!t)
1146 break;
1147 if (t->expire_time > expire_time)
1148 break;
1149 pt = &t->next;
1150 }
1151 ts->expire_time = expire_time;
1152 ts->next = *pt;
1153 *pt = ts;
1154
1155 /* Rearm if necessary */
1156 if (pt == &active_timers[ts->clock->type]) {
1157 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1158 qemu_rearm_alarm_timer(alarm_timer);
1159 }
1160 /* Interrupt execution to force deadline recalculation. */
1161 if (use_icount && cpu_single_env) {
1162 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1163 }
1164 }
1165 }
1166
1167 int qemu_timer_pending(QEMUTimer *ts)
1168 {
1169 QEMUTimer *t;
1170 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1171 if (t == ts)
1172 return 1;
1173 }
1174 return 0;
1175 }
1176
1177 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1178 {
1179 if (!timer_head)
1180 return 0;
1181 return (timer_head->expire_time <= current_time);
1182 }
1183
1184 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1185 {
1186 QEMUTimer *ts;
1187
1188 for(;;) {
1189 ts = *ptimer_head;
1190 if (!ts || ts->expire_time > current_time)
1191 break;
1192 /* remove timer from the list before calling the callback */
1193 *ptimer_head = ts->next;
1194 ts->next = NULL;
1195
1196 /* run the callback (the timer list can be modified) */
1197 ts->cb(ts->opaque);
1198 }
1199 }
1200
1201 int64_t qemu_get_clock(QEMUClock *clock)
1202 {
1203 switch(clock->type) {
1204 case QEMU_TIMER_REALTIME:
1205 return get_clock() / 1000000;
1206 default:
1207 case QEMU_TIMER_VIRTUAL:
1208 if (use_icount) {
1209 return cpu_get_icount();
1210 } else {
1211 return cpu_get_clock();
1212 }
1213 }
1214 }
1215
1216 static void init_timers(void)
1217 {
1218 init_get_clock();
1219 ticks_per_sec = QEMU_TIMER_BASE;
1220 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1221 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1222 }
1223
1224 /* save a timer */
1225 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1226 {
1227 uint64_t expire_time;
1228
1229 if (qemu_timer_pending(ts)) {
1230 expire_time = ts->expire_time;
1231 } else {
1232 expire_time = -1;
1233 }
1234 qemu_put_be64(f, expire_time);
1235 }
1236
1237 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1238 {
1239 uint64_t expire_time;
1240
1241 expire_time = qemu_get_be64(f);
1242 if (expire_time != -1) {
1243 qemu_mod_timer(ts, expire_time);
1244 } else {
1245 qemu_del_timer(ts);
1246 }
1247 }
1248
1249 static void timer_save(QEMUFile *f, void *opaque)
1250 {
1251 if (cpu_ticks_enabled) {
1252 hw_error("cannot save state if virtual timers are running");
1253 }
1254 qemu_put_be64(f, cpu_ticks_offset);
1255 qemu_put_be64(f, ticks_per_sec);
1256 qemu_put_be64(f, cpu_clock_offset);
1257 }
1258
1259 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1260 {
1261 if (version_id != 1 && version_id != 2)
1262 return -EINVAL;
1263 if (cpu_ticks_enabled) {
1264 return -EINVAL;
1265 }
1266 cpu_ticks_offset=qemu_get_be64(f);
1267 ticks_per_sec=qemu_get_be64(f);
1268 if (version_id == 2) {
1269 cpu_clock_offset=qemu_get_be64(f);
1270 }
1271 return 0;
1272 }
1273
1274 #ifdef _WIN32
1275 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1276 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1277 #else
1278 static void host_alarm_handler(int host_signum)
1279 #endif
1280 {
1281 #if 0
1282 #define DISP_FREQ 1000
1283 {
1284 static int64_t delta_min = INT64_MAX;
1285 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1286 static int count;
1287 ti = qemu_get_clock(vm_clock);
1288 if (last_clock != 0) {
1289 delta = ti - last_clock;
1290 if (delta < delta_min)
1291 delta_min = delta;
1292 if (delta > delta_max)
1293 delta_max = delta;
1294 delta_cum += delta;
1295 if (++count == DISP_FREQ) {
1296 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1297 muldiv64(delta_min, 1000000, ticks_per_sec),
1298 muldiv64(delta_max, 1000000, ticks_per_sec),
1299 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1300 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1301 count = 0;
1302 delta_min = INT64_MAX;
1303 delta_max = 0;
1304 delta_cum = 0;
1305 }
1306 }
1307 last_clock = ti;
1308 }
1309 #endif
1310 if (alarm_has_dynticks(alarm_timer) ||
1311 (!use_icount &&
1312 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1313 qemu_get_clock(vm_clock))) ||
1314 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1315 qemu_get_clock(rt_clock))) {
1316 #ifdef _WIN32
1317 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1318 SetEvent(data->host_alarm);
1319 #endif
1320 CPUState *env = next_cpu;
1321
1322 alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1323
1324 if (env) {
1325 /* stop the currently executing cpu because a timer occured */
1326 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1327 #ifdef USE_KQEMU
1328 if (env->kqemu_enabled) {
1329 kqemu_cpu_interrupt(env);
1330 }
1331 #endif
1332 }
1333 event_pending = 1;
1334 }
1335 }
1336
1337 static int64_t qemu_next_deadline(void)
1338 {
1339 int64_t delta;
1340
1341 if (active_timers[QEMU_TIMER_VIRTUAL]) {
1342 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1343 qemu_get_clock(vm_clock);
1344 } else {
1345 /* To avoid problems with overflow limit this to 2^32. */
1346 delta = INT32_MAX;
1347 }
1348
1349 if (delta < 0)
1350 delta = 0;
1351
1352 return delta;
1353 }
1354
1355 #if defined(__linux__) || defined(_WIN32)
1356 static uint64_t qemu_next_deadline_dyntick(void)
1357 {
1358 int64_t delta;
1359 int64_t rtdelta;
1360
1361 if (use_icount)
1362 delta = INT32_MAX;
1363 else
1364 delta = (qemu_next_deadline() + 999) / 1000;
1365
1366 if (active_timers[QEMU_TIMER_REALTIME]) {
1367 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1368 qemu_get_clock(rt_clock))*1000;
1369 if (rtdelta < delta)
1370 delta = rtdelta;
1371 }
1372
1373 if (delta < MIN_TIMER_REARM_US)
1374 delta = MIN_TIMER_REARM_US;
1375
1376 return delta;
1377 }
1378 #endif
1379
1380 #ifndef _WIN32
1381
1382 #if defined(__linux__)
1383
1384 #define RTC_FREQ 1024
1385
1386 static void enable_sigio_timer(int fd)
1387 {
1388 struct sigaction act;
1389
1390 /* timer signal */
1391 sigfillset(&act.sa_mask);
1392 act.sa_flags = 0;
1393 act.sa_handler = host_alarm_handler;
1394
1395 sigaction(SIGIO, &act, NULL);
1396 fcntl(fd, F_SETFL, O_ASYNC);
1397 fcntl(fd, F_SETOWN, getpid());
1398 }
1399
1400 static int hpet_start_timer(struct qemu_alarm_timer *t)
1401 {
1402 struct hpet_info info;
1403 int r, fd;
1404
1405 fd = open("/dev/hpet", O_RDONLY);
1406 if (fd < 0)
1407 return -1;
1408
1409 /* Set frequency */
1410 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1411 if (r < 0) {
1412 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1413 "error, but for better emulation accuracy type:\n"
1414 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1415 goto fail;
1416 }
1417
1418 /* Check capabilities */
1419 r = ioctl(fd, HPET_INFO, &info);
1420 if (r < 0)
1421 goto fail;
1422
1423 /* Enable periodic mode */
1424 r = ioctl(fd, HPET_EPI, 0);
1425 if (info.hi_flags && (r < 0))
1426 goto fail;
1427
1428 /* Enable interrupt */
1429 r = ioctl(fd, HPET_IE_ON, 0);
1430 if (r < 0)
1431 goto fail;
1432
1433 enable_sigio_timer(fd);
1434 t->priv = (void *)(long)fd;
1435
1436 return 0;
1437 fail:
1438 close(fd);
1439 return -1;
1440 }
1441
1442 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1443 {
1444 int fd = (long)t->priv;
1445
1446 close(fd);
1447 }
1448
1449 static int rtc_start_timer(struct qemu_alarm_timer *t)
1450 {
1451 int rtc_fd;
1452 unsigned long current_rtc_freq = 0;
1453
1454 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1455 if (rtc_fd < 0)
1456 return -1;
1457 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1458 if (current_rtc_freq != RTC_FREQ &&
1459 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1460 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1461 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1462 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1463 goto fail;
1464 }
1465 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1466 fail:
1467 close(rtc_fd);
1468 return -1;
1469 }
1470
1471 enable_sigio_timer(rtc_fd);
1472
1473 t->priv = (void *)(long)rtc_fd;
1474
1475 return 0;
1476 }
1477
1478 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1479 {
1480 int rtc_fd = (long)t->priv;
1481
1482 close(rtc_fd);
1483 }
1484
1485 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1486 {
1487 struct sigevent ev;
1488 timer_t host_timer;
1489 struct sigaction act;
1490
1491 sigfillset(&act.sa_mask);
1492 act.sa_flags = 0;
1493 act.sa_handler = host_alarm_handler;
1494
1495 sigaction(SIGALRM, &act, NULL);
1496
1497 ev.sigev_value.sival_int = 0;
1498 ev.sigev_notify = SIGEV_SIGNAL;
1499 ev.sigev_signo = SIGALRM;
1500
1501 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1502 perror("timer_create");
1503
1504 /* disable dynticks */
1505 fprintf(stderr, "Dynamic Ticks disabled\n");
1506
1507 return -1;
1508 }
1509
1510 t->priv = (void *)host_timer;
1511
1512 return 0;
1513 }
1514
1515 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1516 {
1517 timer_t host_timer = (timer_t)t->priv;
1518
1519 timer_delete(host_timer);
1520 }
1521
1522 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1523 {
1524 timer_t host_timer = (timer_t)t->priv;
1525 struct itimerspec timeout;
1526 int64_t nearest_delta_us = INT64_MAX;
1527 int64_t current_us;
1528
1529 if (!active_timers[QEMU_TIMER_REALTIME] &&
1530 !active_timers[QEMU_TIMER_VIRTUAL])
1531 return;
1532
1533 nearest_delta_us = qemu_next_deadline_dyntick();
1534
1535 /* check whether a timer is already running */
1536 if (timer_gettime(host_timer, &timeout)) {
1537 perror("gettime");
1538 fprintf(stderr, "Internal timer error: aborting\n");
1539 exit(1);
1540 }
1541 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1542 if (current_us && current_us <= nearest_delta_us)
1543 return;
1544
1545 timeout.it_interval.tv_sec = 0;
1546 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1547 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1548 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1549 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1550 perror("settime");
1551 fprintf(stderr, "Internal timer error: aborting\n");
1552 exit(1);
1553 }
1554 }
1555
1556 #endif /* defined(__linux__) */
1557
1558 static int unix_start_timer(struct qemu_alarm_timer *t)
1559 {
1560 struct sigaction act;
1561 struct itimerval itv;
1562 int err;
1563
1564 /* timer signal */
1565 sigfillset(&act.sa_mask);
1566 act.sa_flags = 0;
1567 act.sa_handler = host_alarm_handler;
1568
1569 sigaction(SIGALRM, &act, NULL);
1570
1571 itv.it_interval.tv_sec = 0;
1572 /* for i386 kernel 2.6 to get 1 ms */
1573 itv.it_interval.tv_usec = 999;
1574 itv.it_value.tv_sec = 0;
1575 itv.it_value.tv_usec = 10 * 1000;
1576
1577 err = setitimer(ITIMER_REAL, &itv, NULL);
1578 if (err)
1579 return -1;
1580
1581 return 0;
1582 }
1583
1584 static void unix_stop_timer(struct qemu_alarm_timer *t)
1585 {
1586 struct itimerval itv;
1587
1588 memset(&itv, 0, sizeof(itv));
1589 setitimer(ITIMER_REAL, &itv, NULL);
1590 }
1591
1592 #endif /* !defined(_WIN32) */
1593
1594 #ifdef _WIN32
1595
1596 static int win32_start_timer(struct qemu_alarm_timer *t)
1597 {
1598 TIMECAPS tc;
1599 struct qemu_alarm_win32 *data = t->priv;
1600 UINT flags;
1601
1602 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1603 if (!data->host_alarm) {
1604 perror("Failed CreateEvent");
1605 return -1;
1606 }
1607
1608 memset(&tc, 0, sizeof(tc));
1609 timeGetDevCaps(&tc, sizeof(tc));
1610
1611 if (data->period < tc.wPeriodMin)
1612 data->period = tc.wPeriodMin;
1613
1614 timeBeginPeriod(data->period);
1615
1616 flags = TIME_CALLBACK_FUNCTION;
1617 if (alarm_has_dynticks(t))
1618 flags |= TIME_ONESHOT;
1619 else
1620 flags |= TIME_PERIODIC;
1621
1622 data->timerId = timeSetEvent(1, // interval (ms)
1623 data->period, // resolution
1624 host_alarm_handler, // function
1625 (DWORD)t, // parameter
1626 flags);
1627
1628 if (!data->timerId) {
1629 perror("Failed to initialize win32 alarm timer");
1630
1631 timeEndPeriod(data->period);
1632 CloseHandle(data->host_alarm);
1633 return -1;
1634 }
1635
1636 qemu_add_wait_object(data->host_alarm, NULL, NULL);
1637
1638 return 0;
1639 }
1640
1641 static void win32_stop_timer(struct qemu_alarm_timer *t)
1642 {
1643 struct qemu_alarm_win32 *data = t->priv;
1644
1645 timeKillEvent(data->timerId);
1646 timeEndPeriod(data->period);
1647
1648 CloseHandle(data->host_alarm);
1649 }
1650
1651 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1652 {
1653 struct qemu_alarm_win32 *data = t->priv;
1654 uint64_t nearest_delta_us;
1655
1656 if (!active_timers[QEMU_TIMER_REALTIME] &&
1657 !active_timers[QEMU_TIMER_VIRTUAL])
1658 return;
1659
1660 nearest_delta_us = qemu_next_deadline_dyntick();
1661 nearest_delta_us /= 1000;
1662
1663 timeKillEvent(data->timerId);
1664
1665 data->timerId = timeSetEvent(1,
1666 data->period,
1667 host_alarm_handler,
1668 (DWORD)t,
1669 TIME_ONESHOT | TIME_PERIODIC);
1670
1671 if (!data->timerId) {
1672 perror("Failed to re-arm win32 alarm timer");
1673
1674 timeEndPeriod(data->period);
1675 CloseHandle(data->host_alarm);
1676 exit(1);
1677 }
1678 }
1679
1680 #endif /* _WIN32 */
1681
1682 static void init_timer_alarm(void)
1683 {
1684 struct qemu_alarm_timer *t = NULL;
1685 int i, err = -1;
1686
1687 for (i = 0; alarm_timers[i].name; i++) {
1688 t = &alarm_timers[i];
1689
1690 err = t->start(t);
1691 if (!err)
1692 break;
1693 }
1694
1695 if (err) {
1696 fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1697 fprintf(stderr, "Terminating\n");
1698 exit(1);
1699 }
1700
1701 alarm_timer = t;
1702 }
1703
1704 static void quit_timers(void)
1705 {
1706 alarm_timer->stop(alarm_timer);
1707 alarm_timer = NULL;
1708 }
1709
1710 /***********************************************************/
1711 /* host time/date access */
1712 void qemu_get_timedate(struct tm *tm, int offset)
1713 {
1714 time_t ti;
1715 struct tm *ret;
1716
1717 time(&ti);
1718 ti += offset;
1719 if (rtc_date_offset == -1) {
1720 if (rtc_utc)
1721 ret = gmtime(&ti);
1722 else
1723 ret = localtime(&ti);
1724 } else {
1725 ti -= rtc_date_offset;
1726 ret = gmtime(&ti);
1727 }
1728
1729 memcpy(tm, ret, sizeof(struct tm));
1730 }
1731
1732 int qemu_timedate_diff(struct tm *tm)
1733 {
1734 time_t seconds;
1735
1736 if (rtc_date_offset == -1)
1737 if (rtc_utc)
1738 seconds = mktimegm(tm);
1739 else
1740 seconds = mktime(tm);
1741 else
1742 seconds = mktimegm(tm) + rtc_date_offset;
1743
1744 return seconds - time(NULL);
1745 }
1746
1747 /***********************************************************/
1748 /* character device */
1749
1750 static void qemu_chr_event(CharDriverState *s, int event)
1751 {
1752 if (!s->chr_event)
1753 return;
1754 s->chr_event(s->handler_opaque, event);
1755 }
1756
1757 static void qemu_chr_reset_bh(void *opaque)
1758 {
1759 CharDriverState *s = opaque;
1760 qemu_chr_event(s, CHR_EVENT_RESET);
1761 qemu_bh_delete(s->bh);
1762 s->bh = NULL;
1763 }
1764
1765 void qemu_chr_reset(CharDriverState *s)
1766 {
1767 if (s->bh == NULL) {
1768 s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1769 qemu_bh_schedule(s->bh);
1770 }
1771 }
1772
1773 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1774 {
1775 return s->chr_write(s, buf, len);
1776 }
1777
1778 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1779 {
1780 if (!s->chr_ioctl)
1781 return -ENOTSUP;
1782 return s->chr_ioctl(s, cmd, arg);
1783 }
1784
1785 int qemu_chr_can_read(CharDriverState *s)
1786 {
1787 if (!s->chr_can_read)
1788 return 0;
1789 return s->chr_can_read(s->handler_opaque);
1790 }
1791
1792 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1793 {
1794 s->chr_read(s->handler_opaque, buf, len);
1795 }
1796
1797 void qemu_chr_accept_input(CharDriverState *s)
1798 {
1799 if (s->chr_accept_input)
1800 s->chr_accept_input(s);
1801 }
1802
1803 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1804 {
1805 char buf[4096];
1806 va_list ap;
1807 va_start(ap, fmt);
1808 vsnprintf(buf, sizeof(buf), fmt, ap);
1809 qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1810 va_end(ap);
1811 }
1812
1813 void qemu_chr_send_event(CharDriverState *s, int event)
1814 {
1815 if (s->chr_send_event)
1816 s->chr_send_event(s, event);
1817 }
1818
1819 void qemu_chr_add_handlers(CharDriverState *s,
1820 IOCanRWHandler *fd_can_read,
1821 IOReadHandler *fd_read,
1822 IOEventHandler *fd_event,
1823 void *opaque)
1824 {
1825 s->chr_can_read = fd_can_read;
1826 s->chr_read = fd_read;
1827 s->chr_event = fd_event;
1828 s->handler_opaque = opaque;
1829 if (s->chr_update_read_handler)
1830 s->chr_update_read_handler(s);
1831 }
1832
1833 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1834 {
1835 return len;
1836 }
1837
1838 static CharDriverState *qemu_chr_open_null(void)
1839 {
1840 CharDriverState *chr;
1841
1842 chr = qemu_mallocz(sizeof(CharDriverState));
1843 if (!chr)
1844 return NULL;
1845 chr->chr_write = null_chr_write;
1846 return chr;
1847 }
1848
1849 /* MUX driver for serial I/O splitting */
1850 static int term_timestamps;
1851 static int64_t term_timestamps_start;
1852 #define MAX_MUX 4
1853 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1854 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1855 typedef struct {
1856 IOCanRWHandler *chr_can_read[MAX_MUX];
1857 IOReadHandler *chr_read[MAX_MUX];
1858 IOEventHandler *chr_event[MAX_MUX];
1859 void *ext_opaque[MAX_MUX];
1860 CharDriverState *drv;
1861 unsigned char buffer[MUX_BUFFER_SIZE];
1862 int prod;
1863 int cons;
1864 int mux_cnt;
1865 int term_got_escape;
1866 int max_size;
1867 } MuxDriver;
1868
1869
1870 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1871 {
1872 MuxDriver *d = chr->opaque;
1873 int ret;
1874 if (!term_timestamps) {
1875 ret = d->drv->chr_write(d->drv, buf, len);
1876 } else {
1877 int i;
1878
1879 ret = 0;
1880 for(i = 0; i < len; i++) {
1881 ret += d->drv->chr_write(d->drv, buf+i, 1);
1882 if (buf[i] == '\n') {
1883 char buf1[64];
1884 int64_t ti;
1885 int secs;
1886
1887 ti = get_clock();
1888 if (term_timestamps_start == -1)
1889 term_timestamps_start = ti;
1890 ti -= term_timestamps_start;
1891 secs = ti / 1000000000;
1892 snprintf(buf1, sizeof(buf1),
1893 "[%02d:%02d:%02d.%03d] ",
1894 secs / 3600,
1895 (secs / 60) % 60,
1896 secs % 60,
1897 (int)((ti / 1000000) % 1000));
1898 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1899 }
1900 }
1901 }
1902 return ret;
1903 }
1904
1905 static const char * const mux_help[] = {
1906 "% h print this help\n\r",
1907 "% x exit emulator\n\r",
1908 "% s save disk data back to file (if -snapshot)\n\r",
1909 "% t toggle console timestamps\n\r"
1910 "% b send break (magic sysrq)\n\r",
1911 "% c switch between console and monitor\n\r",
1912 "% % sends %\n\r",
1913 NULL
1914 };
1915
1916 static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1917 static void mux_print_help(CharDriverState *chr)
1918 {
1919 int i, j;
1920 char ebuf[15] = "Escape-Char";
1921 char cbuf[50] = "\n\r";
1922
1923 if (term_escape_char > 0 && term_escape_char < 26) {
1924 snprintf(cbuf, sizeof(cbuf), "\n\r");
1925 snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
1926 } else {
1927 snprintf(cbuf, sizeof(cbuf),
1928 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1929 term_escape_char);
1930 }
1931 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1932 for (i = 0; mux_help[i] != NULL; i++) {
1933 for (j=0; mux_help[i][j] != '\0'; j++) {
1934 if (mux_help[i][j] == '%')
1935 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1936 else
1937 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1938 }
1939 }
1940 }
1941
1942 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1943 {
1944 if (d->term_got_escape) {
1945 d->term_got_escape = 0;
1946 if (ch == term_escape_char)
1947 goto send_char;
1948 switch(ch) {
1949 case '?':
1950 case 'h':
1951 mux_print_help(chr);
1952 break;
1953 case 'x':
1954 {
1955 const char *term = "QEMU: Terminated\n\r";
1956 chr->chr_write(chr,(uint8_t *)term,strlen(term));
1957 exit(0);
1958 break;
1959 }
1960 case 's':
1961 {
1962 int i;
1963 for (i = 0; i < nb_drives; i++) {
1964 bdrv_commit(drives_table[i].bdrv);
1965 }
1966 }
1967 break;
1968 case 'b':
1969 qemu_chr_event(chr, CHR_EVENT_BREAK);
1970 break;
1971 case 'c':
1972 /* Switch to the next registered device */
1973 chr->focus++;
1974 if (chr->focus >= d->mux_cnt)
1975 chr->focus = 0;
1976 break;
1977 case 't':
1978 term_timestamps = !term_timestamps;
1979 term_timestamps_start = -1;
1980 break;
1981 }
1982 } else if (ch == term_escape_char) {
1983 d->term_got_escape = 1;
1984 } else {
1985 send_char:
1986 return 1;
1987 }
1988 return 0;
1989 }
1990
1991 static void mux_chr_accept_input(CharDriverState *chr)
1992 {
1993 int m = chr->focus;
1994 MuxDriver *d = chr->opaque;
1995
1996 while (d->prod != d->cons &&
1997 d->chr_can_read[m] &&
1998 d->chr_can_read[m](d->ext_opaque[m])) {
1999 d->chr_read[m](d->ext_opaque[m],
2000 &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
2001 }
2002 }
2003
2004 static int mux_chr_can_read(void *opaque)
2005 {
2006 CharDriverState *chr = opaque;
2007 MuxDriver *d = chr->opaque;
2008
2009 if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
2010 return 1;
2011 if (d->chr_can_read[chr->focus])
2012 return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
2013 return 0;
2014 }
2015
2016 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
2017 {
2018 CharDriverState *chr = opaque;
2019 MuxDriver *d = chr->opaque;
2020 int m = chr->focus;
2021 int i;
2022
2023 mux_chr_accept_input (opaque);
2024
2025 for(i = 0; i < size; i++)
2026 if (mux_proc_byte(chr, d, buf[i])) {
2027 if (d->prod == d->cons &&
2028 d->chr_can_read[m] &&
2029 d->chr_can_read[m](d->ext_opaque[m]))
2030 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
2031 else
2032 d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
2033 }
2034 }
2035
2036 static void mux_chr_event(void *opaque, int event)
2037 {
2038 CharDriverState *chr = opaque;
2039 MuxDriver *d = chr->opaque;
2040 int i;
2041
2042 /* Send the event to all registered listeners */
2043 for (i = 0; i < d->mux_cnt; i++)
2044 if (d->chr_event[i])
2045 d->chr_event[i](d->ext_opaque[i], event);
2046 }
2047
2048 static void mux_chr_update_read_handler(CharDriverState *chr)
2049 {
2050 MuxDriver *d = chr->opaque;
2051
2052 if (d->mux_cnt >= MAX_MUX) {
2053 fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
2054 return;
2055 }
2056 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
2057 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
2058 d->chr_read[d->mux_cnt] = chr->chr_read;
2059 d->chr_event[d->mux_cnt] = chr->chr_event;
2060 /* Fix up the real driver with mux routines */
2061 if (d->mux_cnt == 0) {
2062 qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
2063 mux_chr_event, chr);
2064 }
2065 chr->focus = d->mux_cnt;
2066 d->mux_cnt++;
2067 }
2068
2069 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
2070 {
2071 CharDriverState *chr;
2072 MuxDriver *d;
2073
2074 chr = qemu_mallocz(sizeof(CharDriverState));
2075 if (!chr)
2076 return NULL;
2077 d = qemu_mallocz(sizeof(MuxDriver));
2078 if (!d) {
2079 free(chr);
2080 return NULL;
2081 }
2082
2083 chr->opaque = d;
2084 d->drv = drv;
2085 chr->focus = -1;
2086 chr->chr_write = mux_chr_write;
2087 chr->chr_update_read_handler = mux_chr_update_read_handler;
2088 chr->chr_accept_input = mux_chr_accept_input;
2089 return chr;
2090 }
2091
2092
2093 #ifdef _WIN32
2094
2095 static void socket_cleanup(void)
2096 {
2097 WSACleanup();
2098 }
2099
2100 static int socket_init(void)
2101 {
2102 WSADATA Data;
2103 int ret, err;
2104
2105 ret = WSAStartup(MAKEWORD(2,2), &Data);
2106 if (ret != 0) {
2107 err = WSAGetLastError();
2108 fprintf(stderr, "WSAStartup: %d\n", err);
2109 return -1;
2110 }
2111 atexit(socket_cleanup);
2112 return 0;
2113 }
2114
2115 static int send_all(int fd, const uint8_t *buf, int len1)
2116 {
2117 int ret, len;
2118
2119 len = len1;
2120 while (len > 0) {
2121 ret = send(fd, buf, len, 0);
2122 if (ret < 0) {
2123 int errno;
2124 errno = WSAGetLastError();
2125 if (errno != WSAEWOULDBLOCK) {
2126 return -1;
2127 }
2128 } else if (ret == 0) {
2129 break;
2130 } else {
2131 buf += ret;
2132 len -= ret;
2133 }
2134 }
2135 return len1 - len;
2136 }
2137
2138 #else
2139
2140 static int unix_write(int fd, const uint8_t *buf, int len1)
2141 {
2142 int ret, len;
2143
2144 len = len1;
2145 while (len > 0) {
2146 ret = write(fd, buf, len);
2147 if (ret < 0) {
2148 if (errno != EINTR && errno != EAGAIN)
2149 return -1;
2150 } else if (ret == 0) {
2151 break;
2152 } else {
2153 buf += ret;
2154 len -= ret;
2155 }
2156 }
2157 return len1 - len;
2158 }
2159
2160 static inline int send_all(int fd, const uint8_t *buf, int len1)
2161 {
2162 return unix_write(fd, buf, len1);
2163 }
2164 #endif /* !_WIN32 */
2165
2166 #ifndef _WIN32
2167
2168 typedef struct {
2169 int fd_in, fd_out;
2170 int max_size;
2171 } FDCharDriver;
2172
2173 #define STDIO_MAX_CLIENTS 1
2174 static int stdio_nb_clients = 0;
2175
2176 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2177 {
2178 FDCharDriver *s = chr->opaque;
2179 return unix_write(s->fd_out, buf, len);
2180 }
2181
2182 static int fd_chr_read_poll(void *opaque)
2183 {
2184 CharDriverState *chr = opaque;
2185 FDCharDriver *s = chr->opaque;
2186
2187 s->max_size = qemu_chr_can_read(chr);
2188 return s->max_size;
2189 }
2190
2191 static void fd_chr_read(void *opaque)
2192 {
2193 CharDriverState *chr = opaque;
2194 FDCharDriver *s = chr->opaque;
2195 int size, len;
2196 uint8_t buf[1024];
2197
2198 len = sizeof(buf);
2199 if (len > s->max_size)
2200 len = s->max_size;
2201 if (len == 0)
2202 return;
2203 size = read(s->fd_in, buf, len);
2204 if (size == 0) {
2205 /* FD has been closed. Remove it from the active list. */
2206 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2207 return;
2208 }
2209 if (size > 0) {
2210 qemu_chr_read(chr, buf, size);
2211 }
2212 }
2213
2214 static void fd_chr_update_read_handler(CharDriverState *chr)
2215 {
2216 FDCharDriver *s = chr->opaque;
2217
2218 if (s->fd_in >= 0) {
2219 if (nographic && s->fd_in == 0) {
2220 } else {
2221 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2222 fd_chr_read, NULL, chr);
2223 }
2224 }
2225 }
2226
2227 static void fd_chr_close(struct CharDriverState *chr)
2228 {
2229 FDCharDriver *s = chr->opaque;
2230
2231 if (s->fd_in >= 0) {
2232 if (nographic && s->fd_in == 0) {
2233 } else {
2234 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2235 }
2236 }
2237
2238 qemu_free(s);
2239 }
2240
2241 /* open a character device to a unix fd */
2242 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2243 {
2244 CharDriverState *chr;
2245 FDCharDriver *s;
2246
2247 chr = qemu_mallocz(sizeof(CharDriverState));
2248 if (!chr)
2249 return NULL;
2250 s = qemu_mallocz(sizeof(FDCharDriver));
2251 if (!s) {
2252 free(chr);
2253 return NULL;
2254 }
2255 s->fd_in = fd_in;
2256 s->fd_out = fd_out;
2257 chr->opaque = s;
2258 chr->chr_write = fd_chr_write;
2259 chr->chr_update_read_handler = fd_chr_update_read_handler;
2260 chr->chr_close = fd_chr_close;
2261
2262 qemu_chr_reset(chr);
2263
2264 return chr;
2265 }
2266
2267 static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2268 {
2269 int fd_out;
2270
2271 TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2272 if (fd_out < 0)
2273 return NULL;
2274 return qemu_chr_open_fd(-1, fd_out);
2275 }
2276
2277 static CharDriverState *qemu_chr_open_pipe(const char *filename)
2278 {
2279 int fd_in, fd_out;
2280 char filename_in[256], filename_out[256];
2281
2282 snprintf(filename_in, 256, "%s.in", filename);
2283 snprintf(filename_out, 256, "%s.out", filename);
2284 TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2285 TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2286 if (fd_in < 0 || fd_out < 0) {
2287 if (fd_in >= 0)
2288 close(fd_in);
2289 if (fd_out >= 0)
2290 close(fd_out);
2291 TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2292 if (fd_in < 0)
2293 return NULL;
2294 }
2295 return qemu_chr_open_fd(fd_in, fd_out);
2296 }
2297
2298
2299 /* for STDIO, we handle the case where several clients use it
2300 (nographic mode) */
2301
2302 #define TERM_FIFO_MAX_SIZE 1
2303
2304 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2305 static int term_fifo_size;
2306
2307 static int stdio_read_poll(void *opaque)
2308 {
2309 CharDriverState *chr = opaque;
2310
2311 /* try to flush the queue if needed */
2312 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2313 qemu_chr_read(chr, term_fifo, 1);
2314 term_fifo_size = 0;
2315 }
2316 /* see if we can absorb more chars */
2317 if (term_fifo_size == 0)
2318 return 1;
2319 else
2320 return 0;
2321 }
2322
2323 static void stdio_read(void *opaque)
2324 {
2325 int size;
2326 uint8_t buf[1];
2327 CharDriverState *chr = opaque;
2328
2329 size = read(0, buf, 1);
2330 if (size == 0) {
2331 /* stdin has been closed. Remove it from the active list. */
2332 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2333 return;
2334 }
2335 if (size > 0) {
2336 if (qemu_chr_can_read(chr) > 0) {
2337 qemu_chr_read(chr, buf, 1);
2338 } else if (term_fifo_size == 0) {
2339 term_fifo[term_fifo_size++] = buf[0];
2340 }
2341 }
2342 }
2343
2344 /* init terminal so that we can grab keys */
2345 static struct termios oldtty;
2346 static int old_fd0_flags;
2347 static int term_atexit_done;
2348
2349 static void term_exit(void)
2350 {
2351 tcsetattr (0, TCSANOW, &oldtty);
2352 fcntl(0, F_SETFL, old_fd0_flags);
2353 }
2354
2355 static void term_init(void)
2356 {
2357 struct termios tty;
2358
2359 tcgetattr (0, &tty);
2360 oldtty = tty;
2361 old_fd0_flags = fcntl(0, F_GETFL);
2362
2363 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2364 |INLCR|IGNCR|ICRNL|IXON);
2365 tty.c_oflag |= OPOST;
2366 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2367 /* if graphical mode, we allow Ctrl-C handling */
2368 if (nographic)
2369 tty.c_lflag &= ~ISIG;
2370 tty.c_cflag &= ~(CSIZE|PARENB);
2371 tty.c_cflag |= CS8;
2372 tty.c_cc[VMIN] = 1;
2373 tty.c_cc[VTIME] = 0;
2374
2375 tcsetattr (0, TCSANOW, &tty);
2376
2377 if (!term_atexit_done++)
2378 atexit(term_exit);
2379
2380 fcntl(0, F_SETFL, O_NONBLOCK);
2381 }
2382
2383 static void qemu_chr_close_stdio(struct CharDriverState *chr)
2384 {
2385 term_exit();
2386 stdio_nb_clients--;
2387 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2388 fd_chr_close(chr);
2389 }
2390
2391 static CharDriverState *qemu_chr_open_stdio(void)
2392 {
2393 CharDriverState *chr;
2394
2395 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2396 return NULL;
2397 chr = qemu_chr_open_fd(0, 1);
2398 chr->chr_close = qemu_chr_close_stdio;
2399 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2400 stdio_nb_clients++;
2401 term_init();
2402
2403 return chr;
2404 }
2405
2406 #ifdef __sun__
2407 /* Once Solaris has openpty(), this is going to be removed. */
2408 int openpty(int *amaster, int *aslave, char *name,
2409 struct termios *termp, struct winsize *winp)
2410 {
2411 const char *slave;
2412 int mfd = -1, sfd = -1;
2413
2414 *amaster = *aslave = -1;
2415
2416 mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
2417 if (mfd < 0)
2418 goto err;
2419
2420 if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
2421 goto err;
2422
2423 if ((slave = ptsname(mfd)) == NULL)
2424 goto err;
2425
2426 if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
2427 goto err;
2428
2429 if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
2430 (termp != NULL && tcgetattr(sfd, termp) < 0))
2431 goto err;
2432
2433 if (amaster)
2434 *amaster = mfd;
2435 if (aslave)
2436 *aslave = sfd;
2437 if (winp)
2438 ioctl(sfd, TIOCSWINSZ, winp);
2439
2440 return 0;
2441
2442 err:
2443 if (sfd != -1)
2444 close(sfd);
2445 close(mfd);
2446 return -1;
2447 }
2448
2449 void cfmakeraw (struct termios *termios_p)
2450 {
2451 termios_p->c_iflag &=
2452 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2453 termios_p->c_oflag &= ~OPOST;
2454 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2455 termios_p->c_cflag &= ~(CSIZE|PARENB);
2456 termios_p->c_cflag |= CS8;
2457
2458 termios_p->c_cc[VMIN] = 0;
2459 termios_p->c_cc[VTIME] = 0;
2460 }
2461 #endif
2462
2463 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2464 || defined(__NetBSD__) || defined(__OpenBSD__)
2465
2466 typedef struct {
2467 int fd;
2468 int connected;
2469 int polling;
2470 int read_bytes;
2471 QEMUTimer *timer;
2472 } PtyCharDriver;
2473
2474 static void pty_chr_update_read_handler(CharDriverState *chr);
2475 static void pty_chr_state(CharDriverState *chr, int connected);
2476
2477 static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2478 {
2479 PtyCharDriver *s = chr->opaque;
2480
2481 if (!s->connected) {
2482 /* guest sends data, check for (re-)connect */
2483 pty_chr_update_read_handler(chr);
2484 return 0;
2485 }
2486 return unix_write(s->fd, buf, len);
2487 }
2488
2489 static int pty_chr_read_poll(void *opaque)
2490 {
2491 CharDriverState *chr = opaque;
2492 PtyCharDriver *s = chr->opaque;
2493
2494 s->read_bytes = qemu_chr_can_read(chr);
2495 return s->read_bytes;
2496 }
2497
2498 static void pty_chr_read(void *opaque)
2499 {
2500 CharDriverState *chr = opaque;
2501 PtyCharDriver *s = chr->opaque;
2502 int size, len;
2503 uint8_t buf[1024];
2504
2505 len = sizeof(buf);
2506 if (len > s->read_bytes)
2507 len = s->read_bytes;
2508 if (len == 0)
2509 return;
2510 size = read(s->fd, buf, len);
2511 if ((size == -1 && errno == EIO) ||
2512 (size == 0)) {
2513 pty_chr_state(chr, 0);
2514 return;
2515 }
2516 if (size > 0) {
2517 pty_chr_state(chr, 1);
2518 qemu_chr_read(chr, buf, size);
2519 }
2520 }
2521
2522 static void pty_chr_update_read_handler(CharDriverState *chr)
2523 {
2524 PtyCharDriver *s = chr->opaque;
2525
2526 qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
2527 pty_chr_read, NULL, chr);
2528 s->polling = 1;
2529 /*
2530 * Short timeout here: just need wait long enougth that qemu makes
2531 * it through the poll loop once. When reconnected we want a
2532 * short timeout so we notice it almost instantly. Otherwise
2533 * read() gives us -EIO instantly, making pty_chr_state() reset the
2534 * timeout to the normal (much longer) poll interval before the
2535 * timer triggers.
2536 */
2537 qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
2538 }
2539
2540 static void pty_chr_state(CharDriverState *chr, int connected)
2541 {
2542 PtyCharDriver *s = chr->opaque;
2543
2544 if (!connected) {
2545 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2546 s->connected = 0;
2547 s->polling = 0;
2548 /* (re-)connect poll interval for idle guests: once per second.
2549 * We check more frequently in case the guests sends data to
2550 * the virtual device linked to our pty. */
2551 qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
2552 } else {
2553 if (!s->connected)
2554 qemu_chr_reset(chr);
2555 s->connected = 1;
2556 }
2557 }
2558
2559 static void pty_chr_timer(void *opaque)
2560 {
2561 struct CharDriverState *chr = opaque;
2562 PtyCharDriver *s = chr->opaque;
2563
2564 if (s->connected)
2565 return;
2566 if (s->polling) {
2567 /* If we arrive here without polling being cleared due
2568 * read returning -EIO, then we are (re-)connected */
2569 pty_chr_state(chr, 1);
2570 return;
2571 }
2572
2573 /* Next poll ... */
2574 pty_chr_update_read_handler(chr);
2575 }
2576
2577 static void pty_chr_close(struct CharDriverState *chr)
2578 {
2579 PtyCharDriver *s = chr->opaque;
2580
2581 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2582 close(s->fd);
2583 qemu_free(s);
2584 }
2585
2586 static CharDriverState *qemu_chr_open_pty(void)
2587 {
2588 CharDriverState *chr;
2589 PtyCharDriver *s;
2590 struct termios tty;
2591 int slave_fd;
2592 #if defined(__OpenBSD__)
2593 char pty_name[PATH_MAX];
2594 #define q_ptsname(x) pty_name
2595 #else
2596 char *pty_name = NULL;
2597 #define q_ptsname(x) ptsname(x)
2598 #endif
2599
2600 chr = qemu_mallocz(sizeof(CharDriverState));
2601 if (!chr)
2602 return NULL;
2603 s = qemu_mallocz(sizeof(PtyCharDriver));
2604 if (!s) {
2605 qemu_free(chr);
2606 return NULL;
2607 }
2608
2609 if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
2610 return NULL;
2611 }
2612
2613 /* Set raw attributes on the pty. */
2614 cfmakeraw(&tty);
2615 tcsetattr(slave_fd, TCSAFLUSH, &tty);
2616 close(slave_fd);
2617
2618 fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
2619
2620 chr->opaque = s;
2621 chr->chr_write = pty_chr_write;
2622 chr->chr_update_read_handler = pty_chr_update_read_handler;
2623 chr->chr_close = pty_chr_close;
2624
2625 s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
2626
2627 return chr;
2628 }
2629
2630 static void tty_serial_init(int fd, int speed,
2631 int parity, int data_bits, int stop_bits)
2632 {
2633 struct termios tty;
2634 speed_t spd;
2635
2636 #if 0
2637 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2638 speed, parity, data_bits, stop_bits);
2639 #endif
2640 tcgetattr (fd, &tty);
2641
2642 #define MARGIN 1.1
2643 if (speed <= 50 * MARGIN)
2644 spd = B50;
2645 else if (speed <= 75 * MARGIN)
2646 spd = B75;
2647 else if (speed <= 300 * MARGIN)
2648 spd = B300;
2649 else if (speed <= 600 * MARGIN)
2650 spd = B600;
2651 else if (speed <= 1200 * MARGIN)
2652 spd = B1200;
2653 else if (speed <= 2400 * MARGIN)
2654 spd = B2400;
2655 else if (speed <= 4800 * MARGIN)
2656 spd = B4800;
2657 else if (speed <= 9600 * MARGIN)
2658 spd = B9600;
2659 else if (speed <= 19200 * MARGIN)
2660 spd = B19200;
2661 else if (speed <= 38400 * MARGIN)
2662 spd = B38400;
2663 else if (speed <= 57600 * MARGIN)
2664 spd = B57600;
2665 else if (speed <= 115200 * MARGIN)
2666 spd = B115200;
2667 else
2668 spd = B115200;
2669
2670 cfsetispeed(&tty, spd);
2671 cfsetospeed(&tty, spd);
2672
2673 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2674 |INLCR|IGNCR|ICRNL|IXON);
2675 tty.c_oflag |= OPOST;
2676 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2677 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2678 switch(data_bits) {
2679 default:
2680 case 8:
2681 tty.c_cflag |= CS8;
2682 break;
2683 case 7:
2684 tty.c_cflag |= CS7;
2685 break;
2686 case 6:
2687 tty.c_cflag |= CS6;
2688 break;
2689 case 5:
2690 tty.c_cflag |= CS5;
2691 break;
2692 }
2693 switch(parity) {
2694 default:
2695 case 'N':
2696 break;
2697 case 'E':
2698 tty.c_cflag |= PARENB;
2699 break;
2700 case 'O':
2701 tty.c_cflag |= PARENB | PARODD;
2702 break;
2703 }
2704 if (stop_bits == 2)
2705 tty.c_cflag |= CSTOPB;
2706
2707 tcsetattr (fd, TCSANOW, &tty);
2708 }
2709
2710 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2711 {
2712 FDCharDriver *s = chr->opaque;
2713
2714 switch(cmd) {
2715 case CHR_IOCTL_SERIAL_SET_PARAMS:
2716 {
2717 QEMUSerialSetParams *ssp = arg;
2718 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2719 ssp->data_bits, ssp->stop_bits);
2720 }
2721 break;
2722 case CHR_IOCTL_SERIAL_SET_BREAK:
2723 {
2724 int enable = *(int *)arg;
2725 if (enable)
2726 tcsendbreak(s->fd_in, 1);
2727 }
2728 break;
2729 case CHR_IOCTL_SERIAL_GET_TIOCM:
2730 {
2731 int sarg = 0;
2732 int *targ = (int *)arg;
2733 ioctl(s->fd_in, TIOCMGET, &sarg);
2734 *targ = 0;
2735 if (sarg | TIOCM_CTS)
2736 *targ |= CHR_TIOCM_CTS;
2737 if (sarg | TIOCM_CAR)
2738 *targ |= CHR_TIOCM_CAR;
2739 if (sarg | TIOCM_DSR)
2740 *targ |= CHR_TIOCM_DSR;
2741 if (sarg | TIOCM_RI)
2742 *targ |= CHR_TIOCM_RI;
2743 if (sarg | TIOCM_DTR)
2744 *targ |= CHR_TIOCM_DTR;
2745 if (sarg | TIOCM_RTS)
2746 *targ |= CHR_TIOCM_RTS;
2747 }
2748 break;
2749 case CHR_IOCTL_SERIAL_SET_TIOCM:
2750 {
2751 int sarg = *(int *)arg;
2752 int targ = 0;
2753 if (sarg | CHR_TIOCM_DTR)
2754 targ |= TIOCM_DTR;
2755 if (sarg | CHR_TIOCM_RTS)
2756 targ |= TIOCM_RTS;
2757 ioctl(s->fd_in, TIOCMSET, &targ);
2758 }
2759 break;
2760 default:
2761 return -ENOTSUP;
2762 }
2763 return 0;
2764 }
2765
2766 static CharDriverState *qemu_chr_open_tty(const char *filename)
2767 {
2768 CharDriverState *chr;
2769 int fd;
2770
2771 TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2772 tty_serial_init(fd, 115200, 'N', 8, 1);
2773 chr = qemu_chr_open_fd(fd, fd);
2774 if (!chr) {
2775 close(fd);
2776 return NULL;
2777 }
2778 chr->chr_ioctl = tty_serial_ioctl;
2779 qemu_chr_reset(chr);
2780 return chr;
2781 }
2782 #else /* ! __linux__ && ! __sun__ */
2783 static CharDriverState *qemu_chr_open_pty(void)
2784 {
2785 return NULL;
2786 }
2787 #endif /* __linux__ || __sun__ */
2788
2789 #if defined(__linux__)
2790 typedef struct {
2791 int fd;
2792 int mode;
2793 } ParallelCharDriver;
2794
2795 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2796 {
2797 if (s->mode != mode) {
2798 int m = mode;
2799 if (ioctl(s->fd, PPSETMODE, &m) < 0)
2800 return 0;
2801 s->mode = mode;
2802 }
2803 return 1;
2804 }
2805
2806 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2807 {
2808 ParallelCharDriver *drv = chr->opaque;
2809 int fd = drv->fd;
2810 uint8_t b;
2811
2812 switch(cmd) {
2813 case CHR_IOCTL_PP_READ_DATA:
2814 if (ioctl(fd, PPRDATA, &b) < 0)
2815 return -ENOTSUP;
2816 *(uint8_t *)arg = b;
2817 break;
2818 case CHR_IOCTL_PP_WRITE_DATA:
2819 b = *(uint8_t *)arg;
2820 if (ioctl(fd, PPWDATA, &b) < 0)
2821 return -ENOTSUP;
2822 break;
2823 case CHR_IOCTL_PP_READ_CONTROL:
2824 if (ioctl(fd, PPRCONTROL, &b) < 0)
2825 return -ENOTSUP;
2826 /* Linux gives only the lowest bits, and no way to know data
2827 direction! For better compatibility set the fixed upper
2828 bits. */
2829 *(uint8_t *)arg = b | 0xc0;
2830 break;
2831 case CHR_IOCTL_PP_WRITE_CONTROL:
2832 b = *(uint8_t *)arg;
2833 if (ioctl(fd, PPWCONTROL, &b) < 0)
2834 return -ENOTSUP;
2835 break;
2836 case CHR_IOCTL_PP_READ_STATUS:
2837 if (ioctl(fd, PPRSTATUS, &b) < 0)
2838 return -ENOTSUP;
2839 *(uint8_t *)arg = b;
2840 break;
2841 case CHR_IOCTL_PP_DATA_DIR:
2842 if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
2843 return -ENOTSUP;
2844 break;
2845 case CHR_IOCTL_PP_EPP_READ_ADDR:
2846 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2847 struct ParallelIOArg *parg = arg;
2848 int n = read(fd, parg->buffer, parg->count);
2849 if (n != parg->count) {
2850 return -EIO;
2851 }
2852 }
2853 break;
2854 case CHR_IOCTL_PP_EPP_READ:
2855 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2856 struct ParallelIOArg *parg = arg;
2857 int n = read(fd, parg->buffer, parg->count);
2858 if (n != parg->count) {
2859 return -EIO;
2860 }
2861 }
2862 break;
2863 case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2864 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2865 struct ParallelIOArg *parg = arg;
2866 int n = write(fd, parg->buffer, parg->count);
2867 if (n != parg->count) {
2868 return -EIO;
2869 }
2870 }
2871 break;
2872 case CHR_IOCTL_PP_EPP_WRITE:
2873 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2874 struct ParallelIOArg *parg = arg;
2875 int n = write(fd, parg->buffer, parg->count);
2876 if (n != parg->count) {
2877 return -EIO;
2878 }
2879 }
2880 break;
2881 default:
2882 return -ENOTSUP;
2883 }
2884 return 0;
2885 }
2886
2887 static void pp_close(CharDriverState *chr)
2888 {
2889 ParallelCharDriver *drv = chr->opaque;
2890 int fd = drv->fd;
2891
2892 pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2893 ioctl(fd, PPRELEASE);
2894 close(fd);
2895 qemu_free(drv);
2896 }
2897
2898 static CharDriverState *qemu_chr_open_pp(const char *filename)
2899 {
2900 CharDriverState *chr;
2901 ParallelCharDriver *drv;
2902 int fd;
2903
2904 TFR(fd = open(filename, O_RDWR));
2905 if (fd < 0)
2906 return NULL;
2907
2908 if (ioctl(fd, PPCLAIM) < 0) {
2909 close(fd);
2910 return NULL;
2911 }
2912
2913 drv = qemu_mallocz(sizeof(ParallelCharDriver));
2914 if (!drv) {
2915 close(fd);
2916 return NULL;
2917 }
2918 drv->fd = fd;
2919 drv->mode = IEEE1284_MODE_COMPAT;
2920
2921 chr = qemu_mallocz(sizeof(CharDriverState));
2922 if (!chr) {
2923 qemu_free(drv);
2924 close(fd);
2925 return NULL;
2926 }
2927 chr->chr_write = null_chr_write;
2928 chr->chr_ioctl = pp_ioctl;
2929 chr->chr_close = pp_close;
2930 chr->opaque = drv;
2931
2932 qemu_chr_reset(chr);
2933
2934 return chr;
2935 }
2936 #endif /* __linux__ */
2937
2938 #else /* _WIN32 */
2939
2940 typedef struct {
2941 int max_size;
2942 HANDLE hcom, hrecv, hsend;
2943 OVERLAPPED orecv, osend;
2944 BOOL fpipe;
2945 DWORD len;
2946 } WinCharState;
2947
2948 #define NSENDBUF 2048
2949 #define NRECVBUF 2048
2950 #define MAXCONNECT 1
2951 #define NTIMEOUT 5000
2952
2953 static int win_chr_poll(void *opaque);
2954 static int win_chr_pipe_poll(void *opaque);
2955
2956 static void win_chr_close(CharDriverState *chr)
2957 {
2958 WinCharState *s = chr->opaque;
2959
2960 if (s->hsend) {
2961 CloseHandle(s->hsend);
2962 s->hsend = NULL;
2963 }
2964 if (s->hrecv) {
2965 CloseHandle(s->hrecv);
2966 s->hrecv = NULL;
2967 }
2968 if (s->hcom) {
2969 CloseHandle(s->hcom);
2970 s->hcom = NULL;
2971 }
2972 if (s->fpipe)
2973 qemu_del_polling_cb(win_chr_pipe_poll, chr);
2974 else
2975 qemu_del_polling_cb(win_chr_poll, chr);
2976 }
2977
2978 static int win_chr_init(CharDriverState *chr, const char *filename)
2979 {
2980 WinCharState *s = chr->opaque;
2981 COMMCONFIG comcfg;
2982 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2983 COMSTAT comstat;
2984 DWORD size;
2985 DWORD err;
2986
2987 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2988 if (!s->hsend) {
2989 fprintf(stderr, "Failed CreateEvent\n");
2990 goto fail;
2991 }
2992 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2993 if (!s->hrecv) {
2994 fprintf(stderr, "Failed CreateEvent\n");
2995 goto fail;
2996 }
2997
2998 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2999 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
3000 if (s->hcom == INVALID_HANDLE_VALUE) {
3001 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
3002 s->hcom = NULL;
3003 goto fail;
3004 }
3005
3006 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
3007 fprintf(stderr, "Failed SetupComm\n");
3008 goto fail;
3009 }
3010
3011 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
3012 size = sizeof(COMMCONFIG);
3013 GetDefaultCommConfig(filename, &comcfg, &size);
3014 comcfg.dcb.DCBlength = sizeof(DCB);
3015 CommConfigDialog(filename, NULL, &comcfg);
3016
3017 if (!SetCommState(s->hcom, &comcfg.dcb)) {
3018 fprintf(stderr, "Failed SetCommState\n");
3019 goto fail;
3020 }
3021
3022 if (!SetCommMask(s->hcom, EV_ERR)) {
3023 fprintf(stderr, "Failed SetCommMask\n");
3024 goto fail;
3025 }
3026
3027 cto.ReadIntervalTimeout = MAXDWORD;
3028 if (!SetCommTimeouts(s->hcom, &cto)) {
3029 fprintf(stderr, "Failed SetCommTimeouts\n");
3030 goto fail;
3031 }
3032
3033 if (!ClearCommError(s->hcom, &err, &comstat)) {
3034 fprintf(stderr, "Failed ClearCommError\n");
3035 goto fail;
3036 }
3037 qemu_add_polling_cb(win_chr_poll, chr);
3038 return 0;
3039
3040 fail:
3041 win_chr_close(chr);
3042 return -1;
3043 }
3044
3045 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
3046 {
3047 WinCharState *s = chr->opaque;
3048 DWORD len, ret, size, err;
3049
3050 len = len1;
3051 ZeroMemory(&s->osend, sizeof(s->osend));
3052 s->osend.hEvent = s->hsend;
3053 while (len > 0) {
3054 if (s->hsend)
3055 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
3056 else
3057 ret = WriteFile(s->hcom, buf, len, &size, NULL);
3058 if (!ret) {
3059 err = GetLastError();
3060 if (err == ERROR_IO_PENDING) {
3061 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
3062 if (ret) {
3063 buf += size;
3064 len -= size;
3065 } else {
3066 break;
3067 }
3068 } else {
3069 break;
3070 }
3071 } else {
3072 buf += size;
3073 len -= size;
3074 }
3075 }
3076 return len1 - len;
3077 }
3078
3079 static int win_chr_read_poll(CharDriverState *chr)
3080 {
3081 WinCharState *s = chr->opaque;
3082
3083 s->max_size = qemu_chr_can_read(chr);
3084 return s->max_size;
3085 }
3086
3087 static void win_chr_readfile(CharDriverState *chr)
3088 {
3089 WinCharState *s = chr->opaque;
3090 int ret, err;
3091 uint8_t buf[1024];
3092 DWORD size;
3093
3094 ZeroMemory(&s->orecv, sizeof(s->orecv));
3095 s->orecv.hEvent = s->hrecv;
3096 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
3097 if (!ret) {
3098 err = GetLastError();
3099 if (err == ERROR_IO_PENDING) {
3100 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
3101 }
3102 }
3103
3104 if (size > 0) {
3105 qemu_chr_read(chr, buf, size);
3106 }
3107 }
3108
3109 static void win_chr_read(CharDriverState *chr)
3110 {
3111 WinCharState *s = chr->opaque;
3112
3113 if (s->len > s->max_size)
3114 s->len = s->max_size;
3115 if (s->len == 0)
3116 return;
3117
3118 win_chr_readfile(chr);
3119 }
3120
3121 static int win_chr_poll(void *opaque)
3122 {
3123 CharDriverState *chr = opaque;
3124 WinCharState *s = chr->opaque;
3125 COMSTAT status;
3126 DWORD comerr;
3127
3128 ClearCommError(s->hcom, &comerr, &status);
3129 if (status.cbInQue > 0) {
3130 s->len = status.cbInQue;
3131 win_chr_read_poll(chr);
3132 win_chr_read(chr);
3133 return 1;
3134 }
3135 return 0;
3136 }
3137
3138 static CharDriverState *qemu_chr_open_win(const char *filename)
3139 {
3140 CharDriverState *chr;
3141 WinCharState *s;
3142
3143 chr = qemu_mallocz(sizeof(CharDriverState));
3144 if (!chr)
3145 return NULL;
3146 s = qemu_mallocz(sizeof(WinCharState));
3147 if (!s) {
3148 free(chr);
3149 return NULL;
3150 }
3151 chr->opaque = s;
3152 chr->chr_write = win_chr_write;
3153 chr->chr_close = win_chr_close;
3154
3155 if (win_chr_init(chr, filename) < 0) {
3156 free(s);
3157 free(chr);
3158 return NULL;
3159 }
3160 qemu_chr_reset(chr);
3161 return chr;
3162 }
3163
3164 static int win_chr_pipe_poll(void *opaque)
3165 {
3166 CharDriverState *chr = opaque;
3167 WinCharState *s = chr->opaque;
3168 DWORD size;
3169
3170 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
3171 if (size > 0) {
3172 s->len = size;
3173 win_chr_read_poll(chr);
3174 win_chr_read(chr);
3175 return 1;
3176 }
3177 return 0;
3178 }
3179
3180 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
3181 {
3182 WinCharState *s = chr->opaque;
3183 OVERLAPPED ov;
3184 int ret;
3185 DWORD size;
3186 char openname[256];
3187
3188 s->fpipe = TRUE;
3189
3190 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
3191 if (!s->hsend) {
3192 fprintf(stderr, "Failed CreateEvent\n");
3193 goto fail;
3194 }
3195 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
3196 if (!s->hrecv) {
3197 fprintf(stderr, "Failed CreateEvent\n");
3198 goto fail;
3199 }
3200
3201 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
3202 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
3203 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
3204 PIPE_WAIT,
3205 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
3206 if (s->hcom == INVALID_HANDLE_VALUE) {
3207 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3208 s->hcom = NULL;
3209 goto fail;
3210 }
3211
3212 ZeroMemory(&ov, sizeof(ov));
3213 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
3214 ret = ConnectNamedPipe(s->hcom, &ov);
3215 if (ret) {
3216 fprintf(stderr, "Failed ConnectNamedPipe\n");
3217 goto fail;
3218 }
3219
3220 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
3221 if (!ret) {
3222 fprintf(stderr, "Failed GetOverlappedResult\n");
3223 if (ov.hEvent) {
3224 CloseHandle(ov.hEvent);
3225 ov.hEvent = NULL;
3226 }
3227 goto fail;
3228 }
3229
3230 if (ov.hEvent) {
3231 CloseHandle(ov.hEvent);
3232 ov.hEvent = NULL;
3233 }
3234 qemu_add_polling_cb(win_chr_pipe_poll, chr);
3235 return 0;
3236
3237 fail:
3238 win_chr_close(chr);
3239 return -1;
3240 }
3241
3242
3243 static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
3244 {
3245 CharDriverState *chr;
3246 WinCharState *s;
3247
3248 chr = qemu_mallocz(sizeof(CharDriverState));
3249 if (!chr)
3250 return NULL;
3251 s = qemu_mallocz(sizeof(WinCharState));
3252 if (!s) {
3253 free(chr);
3254 return NULL;
3255 }
3256 chr->opaque = s;
3257 chr->chr_write = win_chr_write;
3258 chr->chr_close = win_chr_close;
3259
3260 if (win_chr_pipe_init(chr, filename) < 0) {
3261 free(s);
3262 free(chr);
3263 return NULL;
3264 }
3265 qemu_chr_reset(chr);
3266 return chr;
3267 }
3268
3269 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
3270 {
3271 CharDriverState *chr;
3272 WinCharState *s;
3273
3274 chr = qemu_mallocz(sizeof(CharDriverState));
3275 if (!chr)
3276 return NULL;
3277 s = qemu_mallocz(sizeof(WinCharState));
3278 if (!s) {
3279 free(chr);
3280 return NULL;
3281 }
3282 s->hcom = fd_out;
3283 chr->opaque = s;
3284 chr->chr_write = win_chr_write;
3285 qemu_chr_reset(chr);
3286 return chr;
3287 }
3288
3289 static CharDriverState *qemu_chr_open_win_con(const char *filename)
3290 {
3291 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
3292 }
3293
3294 static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
3295 {
3296 HANDLE fd_out;
3297
3298 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
3299 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3300 if (fd_out == INVALID_HANDLE_VALUE)
3301 return NULL;
3302
3303 return qemu_chr_open_win_file(fd_out);
3304 }
3305 #endif /* !_WIN32 */
3306
3307 /***********************************************************/
3308 /* UDP Net console */
3309
3310 typedef struct {
3311 int fd;
3312 struct sockaddr_in daddr;
3313 uint8_t buf[1024];
3314 int bufcnt;
3315 int bufptr;
3316 int max_size;
3317 } NetCharDriver;
3318
3319 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3320 {
3321 NetCharDriver *s = chr->opaque;
3322
3323 return sendto(s->fd, buf, len, 0,
3324 (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
3325 }
3326
3327 static int udp_chr_read_poll(void *opaque)
3328 {
3329 CharDriverState *chr = opaque;
3330 NetCharDriver *s = chr->opaque;
3331
3332 s->max_size = qemu_chr_can_read(chr);
3333
3334 /* If there were any stray characters in the queue process them
3335 * first
3336 */
3337 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3338 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3339 s->bufptr++;
3340 s->max_size = qemu_chr_can_read(chr);
3341 }
3342 return s->max_size;
3343 }
3344
3345 static void udp_chr_read(void *opaque)
3346 {
3347 CharDriverState *chr = opaque;
3348 NetCharDriver *s = chr->opaque;
3349
3350 if (s->max_size == 0)
3351 return;
3352 s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
3353 s->bufptr = s->bufcnt;
3354 if (s->bufcnt <= 0)
3355 return;
3356
3357 s->bufptr = 0;
3358 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3359 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3360 s->bufptr++;
3361 s->max_size = qemu_chr_can_read(chr);
3362 }
3363 }
3364
3365 static void udp_chr_update_read_handler(CharDriverState *chr)
3366 {
3367 NetCharDriver *s = chr->opaque;
3368
3369 if (s->fd >= 0) {
3370 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3371 udp_chr_read, NULL, chr);
3372 }
3373 }
3374
3375 int parse_host_port(struct sockaddr_in *saddr, const char *str);
3376 #ifndef _WIN32
3377 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3378 #endif
3379 int parse_host_src_port(struct sockaddr_in *haddr,
3380 struct sockaddr_in *saddr,
3381 const char *str);
3382
3383 static CharDriverState *qemu_chr_open_udp(const char *def)
3384 {
3385 CharDriverState *chr = NULL;
3386 NetCharDriver *s = NULL;
3387 int fd = -1;
3388 struct sockaddr_in saddr;
3389
3390 chr = qemu_mallocz(sizeof(CharDriverState));
3391 if (!chr)
3392 goto return_err;
3393 s = qemu_mallocz(sizeof(NetCharDriver));
3394 if (!s)
3395 goto return_err;
3396
3397 fd = socket(PF_INET, SOCK_DGRAM, 0);
3398 if (fd < 0) {
3399 perror("socket(PF_INET, SOCK_DGRAM)");
3400 goto return_err;
3401 }
3402
3403 if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3404 printf("Could not parse: %s\n", def);
3405 goto return_err;
3406 }
3407
3408 if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3409 {
3410 perror("bind");
3411 goto return_err;
3412 }
3413
3414 s->fd = fd;
3415 s->bufcnt = 0;
3416 s->bufptr = 0;
3417 chr->opaque = s;
3418 chr->chr_write = udp_chr_write;
3419 chr->chr_update_read_handler = udp_chr_update_read_handler;
3420 return chr;
3421
3422 return_err:
3423 if (chr)
3424 free(chr);
3425 if (s)
3426 free(s);
3427 if (fd >= 0)
3428 closesocket(fd);
3429 return NULL;
3430 }
3431
3432 /***********************************************************/
3433 /* TCP Net console */
3434
3435 typedef struct {
3436 int fd, listen_fd;
3437 int connected;
3438 int max_size;
3439 int do_telnetopt;
3440 int do_nodelay;
3441 int is_unix;
3442 } TCPCharDriver;
3443
3444 static void tcp_chr_accept(void *opaque);
3445
3446 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3447 {
3448 TCPCharDriver *s = chr->opaque;
3449 if (s->connected) {
3450 return send_all(s->fd, buf, len);
3451 } else {
3452 /* XXX: indicate an error ? */
3453 return len;
3454 }
3455 }
3456
3457 static int tcp_chr_read_poll(void *opaque)
3458 {
3459 CharDriverState *chr = opaque;
3460 TCPCharDriver *s = chr->opaque;
3461 if (!s->connected)
3462 return 0;
3463 s->max_size = qemu_chr_can_read(chr);
3464 return s->max_size;
3465 }
3466
3467 #define IAC 255
3468 #define IAC_BREAK 243
3469 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3470 TCPCharDriver *s,
3471 uint8_t *buf, int *size)
3472 {
3473 /* Handle any telnet client's basic IAC options to satisfy char by
3474 * char mode with no echo. All IAC options will be removed from
3475 * the buf and the do_telnetopt variable will be used to track the
3476 * state of the width of the IAC information.
3477 *
3478 * IAC commands come in sets of 3 bytes with the exception of the
3479 * "IAC BREAK" command and the double IAC.
3480 */
3481
3482 int i;
3483 int j = 0;
3484
3485 for (i = 0; i < *size; i++) {
3486 if (s->do_telnetopt > 1) {
3487 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3488 /* Double IAC means send an IAC */
3489 if (j != i)
3490 buf[j] = buf[i];
3491 j++;
3492 s->do_telnetopt = 1;
3493 } else {
3494 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3495 /* Handle IAC break commands by sending a serial break */
3496 qemu_chr_event(chr, CHR_EVENT_BREAK);
3497 s->do_telnetopt++;
3498 }
3499 s->do_telnetopt++;
3500 }
3501 if (s->do_telnetopt >= 4) {
3502 s->do_telnetopt = 1;
3503 }
3504 } else {
3505 if ((unsigned char)buf[i] == IAC) {
3506 s->do_telnetopt = 2;
3507 } else {
3508 if (j != i)
3509 buf[j] = buf[i];
3510 j++;
3511 }
3512 }
3513 }
3514 *size = j;
3515 }
3516
3517 static void tcp_chr_read(void *opaque)
3518 {
3519 CharDriverState *chr = opaque;
3520 TCPCharDriver *s = chr->opaque;
3521 uint8_t buf[1024];
3522 int len, size;
3523
3524 if (!s->connected || s->max_size <= 0)
3525 return;
3526 len = sizeof(buf);
3527 if (len > s->max_size)
3528 len = s->max_size;
3529 size = recv(s->fd, buf, len, 0);
3530 if (size == 0) {
3531 /* connection closed */
3532 s->connected = 0;
3533 if (s->listen_fd >= 0) {
3534 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3535 }
3536 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3537 closesocket(s->fd);
3538 s->fd = -1;
3539 } else if (size > 0) {
3540 if (s->do_telnetopt)
3541 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3542 if (size > 0)
3543 qemu_chr_read(chr, buf, size);
3544 }
3545 }
3546
3547 static void tcp_chr_connect(void *opaque)
3548 {
3549 CharDriverState *chr = opaque;
3550 TCPCharDriver *s = chr->opaque;
3551
3552 s->connected = 1;
3553 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3554 tcp_chr_read, NULL, chr);
3555 qemu_chr_reset(chr);
3556 }
3557
3558 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3559 static void tcp_chr_telnet_init(int fd)
3560 {
3561 char buf[3];
3562 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3563 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3564 send(fd, (char *)buf, 3, 0);
3565 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3566 send(fd, (char *)buf, 3, 0);
3567 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3568 send(fd, (char *)buf, 3, 0);
3569 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3570 send(fd, (char *)buf, 3, 0);
3571 }
3572
3573 static void socket_set_nodelay(int fd)
3574 {
3575 int val = 1;
3576 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3577 }
3578
3579 static void tcp_chr_accept(void *opaque)
3580 {
3581 CharDriverState *chr = opaque;
3582 TCPCharDriver *s = chr->opaque;
3583 struct sockaddr_in saddr;
3584 #ifndef _WIN32
3585 struct sockaddr_un uaddr;
3586 #endif
3587 struct sockaddr *addr;
3588 socklen_t len;
3589 int fd;
3590
3591 for(;;) {
3592 #ifndef _WIN32
3593 if (s->is_unix) {
3594 len = sizeof(uaddr);
3595 addr = (struct sockaddr *)&uaddr;
3596 } else
3597 #endif
3598 {
3599 len = sizeof(saddr);
3600 addr = (struct sockaddr *)&saddr;
3601 }
3602 fd = accept(s->listen_fd, addr, &len);
3603 if (fd < 0 && errno != EINTR) {
3604 return;
3605 } else if (fd >= 0) {
3606 if (s->do_telnetopt)
3607 tcp_chr_telnet_init(fd);
3608 break;
3609 }
3610 }
3611 socket_set_nonblock(fd);
3612 if (s->do_nodelay)
3613 socket_set_nodelay(fd);
3614 s->fd = fd;
3615 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3616 tcp_chr_connect(chr);
3617 }
3618
3619 static void tcp_chr_close(CharDriverState *chr)
3620 {
3621 TCPCharDriver *s = chr->opaque;
3622 if (s->fd >= 0)
3623 closesocket(s->fd);
3624 if (s->listen_fd >= 0)
3625 closesocket(s->listen_fd);
3626 qemu_free(s);
3627 }
3628
3629 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3630 int is_telnet,
3631 int is_unix)
3632 {
3633 CharDriverState *chr = NULL;
3634 TCPCharDriver *s = NULL;
3635 int fd = -1, ret, err, val;
3636 int is_listen = 0;
3637 int is_waitconnect = 1;
3638 int do_nodelay = 0;
3639 const char *ptr;
3640 struct sockaddr_in saddr;
3641 #ifndef _WIN32
3642 struct sockaddr_un uaddr;
3643 #endif
3644 struct sockaddr *addr;
3645 socklen_t addrlen;
3646
3647 #ifndef _WIN32
3648 if (is_unix) {
3649 addr = (struct sockaddr *)&uaddr;
3650 addrlen = sizeof(uaddr);
3651 if (parse_unix_path(&uaddr, host_str) < 0)
3652 goto fail;
3653 } else
3654 #endif
3655 {
3656 addr = (struct sockaddr *)&saddr;
3657 addrlen = sizeof(saddr);
3658 if (parse_host_port(&saddr, host_str) < 0)
3659 goto fail;
3660 }
3661
3662 ptr = host_str;
3663 while((ptr = strchr(ptr,','))) {
3664 ptr++;
3665 if (!strncmp(ptr,"server",6)) {
3666 is_listen = 1;
3667 } else if (!strncmp(ptr,"nowait",6)) {
3668 is_waitconnect = 0;
3669 } else if (!strncmp(ptr,"nodelay",6)) {
3670 do_nodelay = 1;
3671 } else {
3672 printf("Unknown option: %s\n", ptr);
3673 goto fail;
3674 }
3675 }
3676 if (!is_listen)
3677 is_waitconnect = 0;
3678
3679 chr = qemu_mallocz(sizeof(CharDriverState));
3680 if (!chr)
3681 goto fail;
3682 s = qemu_mallocz(sizeof(TCPCharDriver));
3683 if (!s)
3684 goto fail;
3685
3686 #ifndef _WIN32
3687 if (is_unix)
3688 fd = socket(PF_UNIX, SOCK_STREAM, 0);
3689 else
3690 #endif
3691 fd = socket(PF_INET, SOCK_STREAM, 0);
3692
3693 if (fd < 0)
3694 goto fail;
3695
3696 if (!is_waitconnect)
3697 socket_set_nonblock(fd);
3698
3699 s->connected = 0;
3700 s->fd = -1;
3701 s->listen_fd = -1;
3702 s->is_unix = is_unix;
3703 s->do_nodelay = do_nodelay && !is_unix;
3704
3705 chr->opaque = s;
3706 chr->chr_write = tcp_chr_write;
3707 chr->chr_close = tcp_chr_close;
3708
3709 if (is_listen) {
3710 /* allow fast reuse */
3711 #ifndef _WIN32
3712 if (is_unix) {
3713 char path[109];
3714 pstrcpy(path, sizeof(path), uaddr.sun_path);
3715 unlink(path);
3716 } else
3717 #endif
3718 {
3719 val = 1;
3720 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3721 }
3722
3723 ret = bind(fd, addr, addrlen);
3724 if (ret < 0)
3725 goto fail;
3726
3727 ret = listen(fd, 0);
3728 if (ret < 0)
3729 goto fail;
3730
3731 s->listen_fd = fd;
3732 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3733 if (is_telnet)
3734 s->do_telnetopt = 1;
3735 } else {
3736 for(;;) {
3737 ret = connect(fd, addr, addrlen);
3738 if (ret < 0) {
3739 err = socket_error();
3740 if (err == EINTR || err == EWOULDBLOCK) {
3741 } else if (err == EINPROGRESS) {
3742 break;
3743 #ifdef _WIN32
3744 } else if (err == WSAEALREADY) {
3745 break;
3746 #endif
3747 } else {
3748 goto fail;
3749 }
3750 } else {
3751 s->connected = 1;
3752 break;
3753 }
3754 }
3755 s->fd = fd;
3756 socket_set_nodelay(fd);
3757 if (s->connected)
3758 tcp_chr_connect(chr);
3759 else
3760 qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3761 }
3762
3763 if (is_listen && is_waitconnect) {
3764 printf("QEMU waiting for connection on: %s\n", host_str);
3765 tcp_chr_accept(chr);
3766 socket_set_nonblock(s->listen_fd);
3767 }
3768
3769 return chr;
3770 fail:
3771 if (fd >= 0)
3772 closesocket(fd);
3773 qemu_free(s);
3774 qemu_free(chr);
3775 return NULL;
3776 }
3777
3778 CharDriverState *qemu_chr_open(const char *filename)
3779 {
3780 const char *p;
3781
3782 if (!strcmp(filename, "vc")) {
3783 return text_console_init(&display_state, 0);
3784 } else if (strstart(filename, "vc:", &p)) {
3785 return text_console_init(&display_state, p);
3786 } else if (!strcmp(filename, "null")) {
3787 return qemu_chr_open_null();
3788 } else
3789 if (strstart(filename, "tcp:", &p)) {
3790 return qemu_chr_open_tcp(p, 0, 0);
3791 } else
3792 if (strstart(filename, "telnet:", &p)) {
3793 return qemu_chr_open_tcp(p, 1, 0);
3794 } else
3795 if (strstart(filename, "udp:", &p)) {
3796 return qemu_chr_open_udp(p);
3797 } else
3798 if (strstart(filename, "mon:", &p)) {
3799 CharDriverState *drv = qemu_chr_open(p);
3800 if (drv) {
3801 drv = qemu_chr_open_mux(drv);
3802 monitor_init(drv, !nographic);
3803 return drv;
3804 }
3805 printf("Unable to open driver: %s\n", p);
3806 return 0;
3807 } else
3808 #ifndef _WIN32
3809 if (strstart(filename, "unix:", &p)) {
3810 return qemu_chr_open_tcp(p, 0, 1);
3811 } else if (strstart(filename, "file:", &p)) {
3812 return qemu_chr_open_file_out(p);
3813 } else if (strstart(filename, "pipe:", &p)) {
3814 return qemu_chr_open_pipe(p);
3815 } else if (!strcmp(filename, "pty")) {
3816 return qemu_chr_open_pty();
3817 } else if (!strcmp(filename, "stdio")) {
3818 return qemu_chr_open_stdio();
3819 } else
3820 #if defined(__linux__)
3821 if (strstart(filename, "/dev/parport", NULL)) {
3822 return qemu_chr_open_pp(filename);
3823 } else
3824 #endif
3825 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
3826 || defined(__NetBSD__) || defined(__OpenBSD__)
3827 if (strstart(filename, "/dev/", NULL)) {
3828 return qemu_chr_open_tty(filename);
3829 } else
3830 #endif
3831 #else /* !_WIN32 */
3832 if (strstart(filename, "COM", NULL)) {
3833 return qemu_chr_open_win(filename);
3834 } else
3835 if (strstart(filename, "pipe:", &p)) {
3836 return qemu_chr_open_win_pipe(p);
3837 } else
3838 if (strstart(filename, "con:", NULL)) {
3839 return qemu_chr_open_win_con(filename);
3840 } else
3841 if (strstart(filename, "file:", &p)) {
3842 return qemu_chr_open_win_file_out(p);
3843 } else
3844 #endif
3845 #ifdef CONFIG_BRLAPI
3846 if (!strcmp(filename, "braille")) {
3847 return chr_baum_init();
3848 } else
3849 #endif
3850 {
3851 return NULL;
3852 }
3853 }
3854
3855 void qemu_chr_close(CharDriverState *chr)
3856 {
3857 if (chr->chr_close)
3858 chr->chr_close(chr);
3859 qemu_free(chr);
3860 }
3861
3862 /***********************************************************/
3863 /* network device redirectors */
3864
3865 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
3866 static void hex_dump(FILE *f, const uint8_t *buf, int size)
3867 {
3868 int len, i, j, c;
3869
3870 for(i=0;i<size;i+=16) {
3871 len = size - i;
3872 if (len > 16)
3873 len = 16;
3874 fprintf(f, "%08x ", i);
3875 for(j=0;j<16;j++) {
3876 if (j < len)
3877 fprintf(f, " %02x", buf[i+j]);
3878 else
3879 fprintf(f, " ");
3880 }
3881 fprintf(f, " ");
3882 for(j=0;j<len;j++) {
3883 c = buf[i+j];
3884 if (c < ' ' || c > '~')
3885 c = '.';
3886 fprintf(f, "%c", c);
3887 }
3888 fprintf(f, "\n");
3889 }
3890 }
3891 #endif
3892
3893 static int parse_macaddr(uint8_t *macaddr, const char *p)
3894 {
3895 int i;
3896 char *last_char;
3897 long int offset;
3898
3899 errno = 0;
3900 offset = strtol(p, &last_char, 0);
3901 if (0 == errno && '\0' == *last_char &&
3902 offset >= 0 && offset <= 0xFFFFFF) {
3903 macaddr[3] = (offset & 0xFF0000) >> 16;
3904 macaddr[4] = (offset & 0xFF00) >> 8;
3905 macaddr[5] = offset & 0xFF;
3906 return 0;
3907 } else {
3908 for(i = 0; i < 6; i++) {
3909 macaddr[i] = strtol(p, (char **)&p, 16);
3910 if (i == 5) {
3911 if (*p != '\0')
3912 return -1;
3913 } else {
3914 if (*p != ':' && *p != '-')
3915 return -1;
3916 p++;
3917 }
3918 }
3919 return 0;
3920 }
3921
3922 return -1;
3923 }
3924
3925 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3926 {
3927 const char *p, *p1;
3928 int len;
3929 p = *pp;
3930 p1 = strchr(p, sep);
3931 if (!p1)
3932 return -1;
3933 len = p1 - p;
3934 p1++;
3935 if (buf_size > 0) {
3936 if (len > buf_size - 1)
3937 len = buf_size - 1;
3938 memcpy(buf, p, len);
3939 buf[len] = '\0';
3940 }
3941 *pp = p1;
3942 return 0;
3943 }
3944
3945 int parse_host_src_port(struct sockaddr_in *haddr,
3946 struct sockaddr_in *saddr,
3947 const char *input_str)
3948 {
3949 char *str = strdup(input_str);
3950 char *host_str = str;
3951 char *src_str;
3952 const char *src_str2;
3953 char *ptr;
3954
3955 /*
3956 * Chop off any extra arguments at the end of the string which
3957 * would start with a comma, then fill in the src port information
3958 * if it was provided else use the "any address" and "any port".
3959 */
3960 if ((ptr = strchr(str,',')))
3961 *ptr = '\0';
3962
3963 if ((src_str = strchr(input_str,'@'))) {
3964 *src_str = '\0';
3965 src_str++;
3966 }
3967
3968 if (parse_host_port(haddr, host_str) < 0)
3969 goto fail;
3970
3971 src_str2 = src_str;
3972 if (!src_str || *src_str == '\0')
3973 src_str2 = ":0";
3974
3975 if (parse_host_port(saddr, src_str2) < 0)
3976 goto fail;
3977
3978 free(str);
3979 return(0);
3980
3981 fail:
3982 free(str);
3983 return -1;
3984 }
3985
3986 int parse_host_port(struct sockaddr_in *saddr, const char *str)
3987 {
3988 char buf[512];
3989 struct hostent *he;
3990 const char *p, *r;
3991 int port;
3992
3993 p = str;
3994 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3995 return -1;
3996 saddr->sin_family = AF_INET;
3997 if (buf[0] == '\0') {
3998 saddr->sin_addr.s_addr = 0;
3999 } else {
4000 if (isdigit(buf[0])) {
4001 if (!inet_aton(buf, &saddr->sin_addr))
4002 return -1;
4003 } else {
4004 if ((he = gethostbyname(buf)) == NULL)
4005 return - 1;
4006 saddr->sin_addr = *(struct in_addr *)he->h_addr;
4007 }
4008 }
4009 port = strtol(p, (char **)&r, 0);
4010 if (r == p)
4011 return -1;
4012 saddr->sin_port = htons(port);
4013 return 0;
4014 }
4015
4016 #ifndef _WIN32
4017 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
4018 {
4019 const char *p;
4020 int len;
4021
4022 len = MIN(108, strlen(str));
4023 p = strchr(str, ',');
4024 if (p)
4025 len = MIN(len, p - str);
4026
4027 memset(uaddr, 0, sizeof(*uaddr));
4028
4029 uaddr->sun_family = AF_UNIX;
4030 memcpy(uaddr->sun_path, str, len);
4031
4032 return 0;
4033 }
4034 #endif
4035
4036 /* find or alloc a new VLAN */
4037 VLANState *qemu_find_vlan(int id)
4038 {
4039 VLANState **pvlan, *vlan;
4040 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4041 if (vlan->id == id)
4042 return vlan;
4043 }
4044 vlan = qemu_mallocz(sizeof(VLANState));
4045 if (!vlan)
4046 return NULL;
4047 vlan->id = id;
4048 vlan->next = NULL;
4049 pvlan = &first_vlan;
4050 while (*pvlan != NULL)
4051 pvlan = &(*pvlan)->next;
4052 *pvlan = vlan;
4053 return vlan;
4054 }
4055
4056 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
4057 IOReadHandler *fd_read,
4058 IOCanRWHandler *fd_can_read,
4059 void *opaque)
4060 {
4061 VLANClientState *vc, **pvc;
4062 vc = qemu_mallocz(sizeof(VLANClientState));
4063 if (!vc)
4064 return NULL;
4065 vc->fd_read = fd_read;
4066 vc->fd_can_read = fd_can_read;
4067 vc->opaque = opaque;
4068 vc->vlan = vlan;
4069
4070 vc->next = NULL;
4071 pvc = &vlan->first_client;
4072 while (*pvc != NULL)
4073 pvc = &(*pvc)->next;
4074 *pvc = vc;
4075 return vc;
4076 }
4077
4078 void qemu_del_vlan_client(VLANClientState *vc)
4079 {
4080 VLANClientState **pvc = &vc->vlan->first_client;
4081
4082 while (*pvc != NULL)
4083 if (*pvc == vc) {
4084 *pvc = vc->next;
4085 free(vc);
4086 break;
4087 } else
4088 pvc = &(*pvc)->next;
4089 }
4090
4091 int qemu_can_send_packet(VLANClientState *vc1)
4092 {
4093 VLANState *vlan = vc1->vlan;
4094 VLANClientState *vc;
4095
4096 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4097 if (vc != vc1) {
4098 if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
4099 return 1;
4100 }
4101 }
4102 return 0;
4103 }
4104
4105 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
4106 {
4107 VLANState *vlan = vc1->vlan;
4108 VLANClientState *vc;
4109
4110 #ifdef DEBUG_NET
4111 printf("vlan %d send:\n", vlan->id);
4112 hex_dump(stdout, buf, size);
4113 #endif
4114 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4115 if (vc != vc1) {
4116 vc->fd_read(vc->opaque, buf, size);
4117 }
4118 }
4119 }
4120
4121 #if defined(CONFIG_SLIRP)
4122
4123 /* slirp network adapter */
4124
4125 static int slirp_inited;
4126 static VLANClientState *slirp_vc;
4127
4128 int slirp_can_output(void)
4129 {
4130 return !slirp_vc || qemu_can_send_packet(slirp_vc);
4131 }
4132
4133 void slirp_output(const uint8_t *pkt, int pkt_len)
4134 {
4135 #ifdef DEBUG_SLIRP
4136 printf("slirp output:\n");
4137 hex_dump(stdout, pkt, pkt_len);
4138 #endif
4139 if (!slirp_vc)
4140 return;
4141 qemu_send_packet(slirp_vc, pkt, pkt_len);
4142 }
4143
4144 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
4145 {
4146 #ifdef DEBUG_SLIRP
4147 printf("slirp input:\n");
4148 hex_dump(stdout, buf, size);
4149 #endif
4150 slirp_input(buf, size);
4151 }
4152
4153 static int net_slirp_init(VLANState *vlan)
4154 {
4155 if (!slirp_inited) {
4156 slirp_inited = 1;
4157 slirp_init();
4158 }
4159 slirp_vc = qemu_new_vlan_client(vlan,
4160 slirp_receive, NULL, NULL);
4161 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
4162 return 0;
4163 }
4164
4165 static void net_slirp_redir(const char *redir_str)
4166 {
4167 int is_udp;
4168 char buf[256], *r;
4169 const char *p;
4170 struct in_addr guest_addr;
4171 int host_port, guest_port;
4172
4173 if (!slirp_inited) {
4174 slirp_inited = 1;
4175 slirp_init();
4176 }
4177
4178 p = redir_str;
4179 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4180 goto fail;
4181 if (!strcmp(buf, "tcp")) {
4182 is_udp = 0;
4183 } else if (!strcmp(buf, "udp")) {
4184 is_udp = 1;
4185 } else {
4186 goto fail;
4187 }
4188
4189 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4190 goto fail;
4191 host_port = strtol(buf, &r, 0);
4192 if (r == buf)
4193 goto fail;
4194
4195 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4196 goto fail;
4197 if (buf[0] == '\0') {
4198 pstrcpy(buf, sizeof(buf), "10.0.2.15");
4199 }
4200 if (!inet_aton(buf, &guest_addr))
4201 goto fail;
4202
4203 guest_port = strtol(p, &r, 0);
4204 if (r == p)
4205 goto fail;
4206
4207 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
4208 fprintf(stderr, "qemu: could not set up redirection\n");
4209 exit(1);
4210 }
4211 return;
4212 fail:
4213 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4214 exit(1);
4215 }
4216
4217 #ifndef _WIN32
4218
4219 static char smb_dir[1024];
4220
4221 static void erase_dir(char *dir_name)
4222 {
4223 DIR *d;
4224 struct dirent *de;
4225 char filename[1024];
4226
4227 /* erase all the files in the directory */
4228 if ((d = opendir(dir_name)) != 0) {
4229 for(;;) {
4230 de = readdir(d);
4231 if (!de)
4232 break;
4233 if (strcmp(de->d_name, ".") != 0 &&
4234 strcmp(de->d_name, "..") != 0) {
4235 snprintf(filename, sizeof(filename), "%s/%s",
4236 smb_dir, de->d_name);
4237 if (unlink(filename) != 0) /* is it a directory? */
4238 erase_dir(filename);
4239 }
4240 }
4241 closedir(d);
4242 rmdir(dir_name);
4243 }
4244 }
4245
4246 /* automatic user mode samba server configuration */
4247 static void smb_exit(void)
4248 {
4249 erase_dir(smb_dir);
4250 }
4251
4252 /* automatic user mode samba server configuration */
4253 static void net_slirp_smb(const char *exported_dir)
4254 {
4255 char smb_conf[1024];
4256 char smb_cmdline[1024];
4257 FILE *f;
4258
4259 if (!slirp_inited) {
4260 slirp_inited = 1;
4261 slirp_init();
4262 }
4263
4264 /* XXX: better tmp dir construction */
4265 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
4266 if (mkdir(smb_dir, 0700) < 0) {
4267 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
4268 exit(1);
4269 }
4270 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
4271
4272 f = fopen(smb_conf, "w");
4273 if (!f) {
4274 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
4275 exit(1);
4276 }
4277 fprintf(f,
4278 "[global]\n"
4279 "private dir=%s\n"
4280 "smb ports=0\n"
4281 "socket address=127.0.0.1\n"
4282 "pid directory=%s\n"
4283 "lock directory=%s\n"
4284 "log file=%s/log.smbd\n"
4285 "smb passwd file=%s/smbpasswd\n"
4286 "security = share\n"
4287 "[qemu]\n"
4288 "path=%s\n"
4289 "read only=no\n"
4290 "guest ok=yes\n",
4291 smb_dir,
4292 smb_dir,
4293 smb_dir,
4294 smb_dir,
4295 smb_dir,
4296 exported_dir
4297 );
4298 fclose(f);
4299 atexit(smb_exit);
4300
4301 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
4302 SMBD_COMMAND, smb_conf);
4303
4304 slirp_add_exec(0, smb_cmdline, 4, 139);
4305 }
4306
4307 #endif /* !defined(_WIN32) */
4308 void do_info_slirp(void)
4309 {
4310 slirp_stats();
4311 }
4312
4313 #endif /* CONFIG_SLIRP */
4314
4315 #if !defined(_WIN32)
4316
4317 typedef struct TAPState {
4318 VLANClientState *vc;
4319 int fd;
4320 char down_script[1024];
4321 } TAPState;
4322
4323 static void tap_receive(void *opaque, const uint8_t *buf, int size)
4324 {
4325 TAPState *s = opaque;
4326 int ret;
4327 for(;;) {
4328 ret = write(s->fd, buf, size);
4329 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
4330 } else {
4331 break;
4332 }
4333 }
4334 }
4335
4336 static void tap_send(void *opaque)
4337 {
4338 TAPState *s = opaque;
4339 uint8_t buf[4096];
4340 int size;
4341
4342 #ifdef __sun__
4343 struct strbuf sbuf;
4344 int f = 0;
4345 sbuf.maxlen = sizeof(buf);
4346 sbuf.buf = buf;
4347 size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
4348 #else
4349 size = read(s->fd, buf, sizeof(buf));
4350 #endif
4351 if (size > 0) {
4352 qemu_send_packet(s->vc, buf, size);
4353 }
4354 }
4355
4356 /* fd support */
4357
4358 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
4359 {
4360 TAPState *s;
4361
4362 s = qemu_mallocz(sizeof(TAPState));
4363 if (!s)
4364 return NULL;
4365 s->fd = fd;
4366 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
4367 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
4368 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
4369 return s;
4370 }
4371
4372 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4373 static int tap_open(char *ifname, int ifname_size)
4374 {
4375 int fd;
4376 char *dev;
4377 struct stat s;
4378
4379 TFR(fd = open("/dev/tap", O_RDWR));
4380 if (fd < 0) {
4381 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
4382 return -1;
4383 }
4384
4385 fstat(fd, &s);
4386 dev = devname(s.st_rdev, S_IFCHR);
4387 pstrcpy(ifname, ifname_size, dev);
4388
4389 fcntl(fd, F_SETFL, O_NONBLOCK);
4390 return fd;
4391 }
4392 #elif defined(__sun__)
4393 #define TUNNEWPPA (('T'<<16) | 0x0001)
4394 /*
4395 * Allocate TAP device, returns opened fd.
4396 * Stores dev name in the first arg(must be large enough).
4397 */
4398 int tap_alloc(char *dev, size_t dev_size)
4399 {
4400 int tap_fd, if_fd, ppa = -1;
4401 static int ip_fd = 0;
4402 char *ptr;
4403
4404 static int arp_fd = 0;
4405 int ip_muxid, arp_muxid;
4406 struct strioctl strioc_if, strioc_ppa;
4407 int link_type = I_PLINK;;
4408 struct lifreq ifr;
4409 char actual_name[32] = "";
4410
4411 memset(&ifr, 0x0, sizeof(ifr));
4412
4413 if( *dev ){
4414 ptr = dev;
4415 while( *ptr && !isdigit((int)*ptr) ) ptr++;
4416 ppa = atoi(ptr);
4417 }
4418
4419 /* Check if IP device was opened */
4420 if( ip_fd )
4421 close(ip_fd);
4422
4423 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4424 if (ip_fd < 0) {
4425 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4426 return -1;
4427 }
4428
4429 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4430 if (tap_fd < 0) {
4431 syslog(LOG_ERR, "Can't open /dev/tap");
4432 return -1;
4433 }
4434
4435 /* Assign a new PPA and get its unit number. */
4436 strioc_ppa.ic_cmd = TUNNEWPPA;
4437 strioc_ppa.ic_timout = 0;
4438 strioc_ppa.ic_len = sizeof(ppa);
4439 strioc_ppa.ic_dp = (char *)&ppa;
4440 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4441 syslog (LOG_ERR, "Can't assign new interface");
4442
4443 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4444 if (if_fd < 0) {
4445 syslog(LOG_ERR, "Can't open /dev/tap (2)");
4446 return -1;
4447 }
4448 if(ioctl(if_fd, I_PUSH, "ip") < 0){
4449 syslog(LOG_ERR, "Can't push IP module");
4450 return -1;
4451 }
4452
4453 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4454 syslog(LOG_ERR, "Can't get flags\n");
4455
4456 snprintf (actual_name, 32, "tap%d", ppa);
4457 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4458
4459 ifr.lifr_ppa = ppa;
4460 /* Assign ppa according to the unit number returned by tun device */
4461
4462 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4463 syslog (LOG_ERR, "Can't set PPA %d", ppa);
4464 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4465 syslog (LOG_ERR, "Can't get flags\n");
4466 /* Push arp module to if_fd */
4467 if (ioctl (if_fd, I_PUSH, "arp") < 0)
4468 syslog (LOG_ERR, "Can't push ARP module (2)");
4469
4470 /* Push arp module to ip_fd */
4471 if (ioctl (ip_fd, I_POP, NULL) < 0)
4472 syslog (LOG_ERR, "I_POP failed\n");
4473 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4474 syslog (LOG_ERR, "Can't push ARP module (3)\n");
4475 /* Open arp_fd */
4476 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4477 if (arp_fd < 0)
4478 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4479
4480 /* Set ifname to arp */
4481 strioc_if.ic_cmd = SIOCSLIFNAME;
4482 strioc_if.ic_timout = 0;
4483 strioc_if.ic_len = sizeof(ifr);
4484 strioc_if.ic_dp = (char *)&ifr;
4485 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4486 syslog (LOG_ERR, "Can't set ifname to arp\n");
4487 }
4488
4489 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4490 syslog(LOG_ERR, "Can't link TAP device to IP");
4491 return -1;
4492 }
4493
4494 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4495 syslog (LOG_ERR, "Can't link TAP device to ARP");
4496
4497 close (if_fd);
4498
4499 memset(&ifr, 0x0, sizeof(ifr));
4500 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4501 ifr.lifr_ip_muxid = ip_muxid;
4502 ifr.lifr_arp_muxid = arp_muxid;
4503
4504 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4505 {
4506 ioctl (ip_fd, I_PUNLINK , arp_muxid);
4507 ioctl (ip_fd, I_PUNLINK, ip_muxid);
4508 syslog (LOG_ERR, "Can't set multiplexor id");
4509 }
4510
4511 snprintf(dev, dev_size, "tap%d", ppa);
4512 return tap_fd;
4513 }
4514
4515 static int tap_open(char *ifname, int ifname_size)
4516 {
4517 char dev[10]="";
4518 int fd;
4519 if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
4520 fprintf(stderr, "Cannot allocate TAP device\n");
4521 return -1;
4522 }
4523 pstrcpy(ifname, ifname_size, dev);
4524 fcntl(fd, F_SETFL, O_NONBLOCK);
4525 return fd;
4526 }
4527 #else
4528 static int tap_open(char *ifname, int ifname_size)
4529 {
4530 struct ifreq ifr;
4531 int fd, ret;
4532
4533 TFR(fd = open("/dev/net/tun", O_RDWR));
4534 if (fd < 0) {
4535 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4536 return -1;
4537 }
4538 memset(&ifr, 0, sizeof(ifr));
4539 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4540 if (ifname[0] != '\0')
4541 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4542 else
4543 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4544 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4545 if (ret != 0) {
4546 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4547 close(fd);
4548 return -1;
4549 }
4550 pstrcpy(ifname, ifname_size, ifr.ifr_name);
4551 fcntl(fd, F_SETFL, O_NONBLOCK);
4552 return fd;
4553 }
4554 #endif
4555
4556 static int launch_script(const char *setup_script, const char *ifname, int fd)
4557 {
4558 int pid, status;
4559 char *args[3];
4560 char **parg;
4561
4562 /* try to launch network script */
4563 pid = fork();
4564 if (pid >= 0) {
4565 if (pid == 0) {
4566 int open_max = sysconf (_SC_OPEN_MAX), i;
4567 for (i = 0; i < open_max; i++)
4568 if (i != STDIN_FILENO &&
4569 i != STDOUT_FILENO &&
4570 i != STDERR_FILENO &&
4571 i != fd)
4572 close(i);
4573
4574 parg = args;
4575 *parg++ = (char *)setup_script;
4576 *parg++ = (char *)ifname;
4577 *parg++ = NULL;
4578 execv(setup_script, args);
4579 _exit(1);
4580 }
4581 while (waitpid(pid, &status, 0) != pid);
4582 if (!WIFEXITED(status) ||
4583 WEXITSTATUS(status) != 0) {
4584 fprintf(stderr, "%s: could not launch network script\n",
4585 setup_script);
4586 return -1;
4587 }
4588 }
4589 return 0;
4590 }
4591
4592 static int net_tap_init(VLANState *vlan, const char *ifname1,
4593 const char *setup_script, const char *down_script)
4594 {
4595 TAPState *s;
4596 int fd;
4597 char ifname[128];
4598
4599 if (ifname1 != NULL)
4600 pstrcpy(ifname, sizeof(ifname), ifname1);
4601 else
4602 ifname[0] = '\0';
4603 TFR(fd = tap_open(ifname, sizeof(ifname)));
4604 if (fd < 0)
4605 return -1;
4606
4607 if (!setup_script || !strcmp(setup_script, "no"))
4608 setup_script = "";
4609 if (setup_script[0] != '\0') {
4610 if (launch_script(setup_script, ifname, fd))
4611 return -1;
4612 }
4613 s = net_tap_fd_init(vlan, fd);
4614 if (!s)
4615 return -1;
4616 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4617 "tap: ifname=%s setup_script=%s", ifname, setup_script);
4618 if (down_script && strcmp(down_script, "no"))
4619 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4620 return 0;
4621 }
4622
4623 #endif /* !_WIN32 */
4624
4625 #if defined(CONFIG_VDE)
4626 typedef struct VDEState {
4627 VLANClientState *vc;
4628 VDECONN *vde;
4629 } VDEState;
4630
4631 static void vde_to_qemu(void *opaque)
4632 {
4633 VDEState *s = opaque;
4634 uint8_t buf[4096];
4635 int size;
4636
4637 size = vde_recv(s->vde, buf, sizeof(buf), 0);
4638 if (size > 0) {
4639 qemu_send_packet(s->vc, buf, size);
4640 }
4641 }
4642
4643 static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
4644 {
4645 VDEState *s = opaque;
4646 int ret;
4647 for(;;) {
4648 ret = vde_send(s->vde, buf, size, 0);
4649 if (ret < 0 && errno == EINTR) {
4650 } else {
4651 break;
4652 }
4653 }
4654 }
4655
4656 static int net_vde_init(VLANState *vlan, const char *sock, int port,
4657 const char *group, int mode)
4658 {
4659 VDEState *s;
4660 char *init_group = strlen(group) ? (char *)group : NULL;
4661 char *init_sock = strlen(sock) ? (char *)sock : NULL;
4662
4663 struct vde_open_args args = {
4664 .port = port,
4665 .group = init_group,
4666 .mode = mode,
4667 };
4668
4669 s = qemu_mallocz(sizeof(VDEState));
4670 if (!s)
4671 return -1;
4672 s->vde = vde_open(init_sock, "QEMU", &args);
4673 if (!s->vde){
4674 free(s);
4675 return -1;
4676 }
4677 s->vc = qemu_new_vlan_client(vlan, vde_from_qemu, NULL, s);
4678 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
4679 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
4680 sock, vde_datafd(s->vde));
4681 return 0;
4682 }
4683 #endif
4684
4685 /* network connection */
4686 typedef struct NetSocketState {
4687 VLANClientState *vc;
4688 int fd;
4689 int state; /* 0 = getting length, 1 = getting data */
4690 int index;
4691 int packet_len;
4692 uint8_t buf[4096];
4693 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4694 } NetSocketState;
4695
4696 typedef struct NetSocketListenState {
4697 VLANState *vlan;
4698 int fd;
4699 } NetSocketListenState;
4700
4701 /* XXX: we consider we can send the whole packet without blocking */
4702 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4703 {
4704 NetSocketState *s = opaque;
4705 uint32_t len;
4706 len = htonl(size);
4707
4708 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4709 send_all(s->fd, buf, size);
4710 }
4711
4712 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4713 {
4714 NetSocketState *s = opaque;
4715 sendto(s->fd, buf, size, 0,
4716 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4717 }
4718
4719 static void net_socket_send(void *opaque)
4720 {
4721 NetSocketState *s = opaque;
4722 int l, size, err;
4723 uint8_t buf1[4096];
4724 const uint8_t *buf;
4725
4726 size = recv(s->fd, buf1, sizeof(buf1), 0);
4727 if (size < 0) {
4728 err = socket_error();
4729 if (err != EWOULDBLOCK)
4730 goto eoc;
4731 } else if (size == 0) {
4732 /* end of connection */
4733 eoc:
4734 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4735 closesocket(s->fd);
4736 return;
4737 }
4738 buf = buf1;
4739 while (size > 0) {
4740 /* reassemble a packet from the network */
4741 switch(s->state) {
4742 case 0:
4743 l = 4 - s->index;
4744 if (l > size)
4745 l = size;
4746 memcpy(s->buf + s->index, buf, l);
4747 buf += l;
4748 size -= l;
4749 s->index += l;
4750 if (s->index == 4) {
4751 /* got length */
4752 s->packet_len = ntohl(*(uint32_t *)s->buf);
4753 s->index = 0;
4754 s->state = 1;
4755 }
4756 break;
4757 case 1:
4758 l = s->packet_len - s->index;
4759 if (l > size)
4760 l = size;
4761 memcpy(s->buf + s->index, buf, l);
4762 s->index += l;
4763 buf += l;
4764 size -= l;
4765 if (s->index >= s->packet_len) {
4766 qemu_send_packet(s->vc, s->buf, s->packet_len);
4767 s->index = 0;
4768 s->state = 0;
4769 }
4770 break;
4771 }
4772 }
4773 }
4774
4775 static void net_socket_send_dgram(void *opaque)
4776 {
4777 NetSocketState *s = opaque;
4778 int size;
4779
4780 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4781 if (size < 0)
4782 return;
4783 if (size == 0) {
4784 /* end of connection */
4785 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4786 return;
4787 }
4788 qemu_send_packet(s->vc, s->buf, size);
4789 }
4790
4791 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4792 {
4793 struct ip_mreq imr;
4794 int fd;
4795 int val, ret;
4796 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4797 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4798 inet_ntoa(mcastaddr->sin_addr),
4799 (int)ntohl(mcastaddr->sin_addr.s_addr));
4800 return -1;
4801
4802 }
4803 fd = socket(PF_INET, SOCK_DGRAM, 0);
4804 if (fd < 0) {
4805 perror("socket(PF_INET, SOCK_DGRAM)");
4806 return -1;
4807 }
4808
4809 val = 1;
4810 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4811 (const char *)&val, sizeof(val));
4812 if (ret < 0) {
4813 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4814 goto fail;
4815 }
4816
4817 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4818 if (ret < 0) {
4819 perror("bind");
4820 goto fail;
4821 }
4822
4823 /* Add host to multicast group */
4824 imr.imr_multiaddr = mcastaddr->sin_addr;
4825 imr.imr_interface.s_addr = htonl(INADDR_ANY);
4826
4827 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4828 (const char *)&imr, sizeof(struct ip_mreq));
4829 if (ret < 0) {
4830 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4831 goto fail;
4832 }
4833
4834 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4835 val = 1;
4836 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4837 (const char *)&val, sizeof(val));
4838 if (ret < 0) {
4839 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4840 goto fail;
4841 }
4842
4843 socket_set_nonblock(fd);
4844 return fd;
4845 fail:
4846 if (fd >= 0)
4847 closesocket(fd);
4848 return -1;
4849 }
4850
4851 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4852 int is_connected)
4853 {
4854 struct sockaddr_in saddr;
4855 int newfd;
4856 socklen_t saddr_len;
4857 NetSocketState *s;
4858
4859 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4860 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4861 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4862 */
4863
4864 if (is_connected) {
4865 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4866 /* must be bound */
4867 if (saddr.sin_addr.s_addr==0) {
4868 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4869 fd);
4870 return NULL;
4871 }
4872 /* clone dgram socket */
4873 newfd = net_socket_mcast_create(&saddr);
4874 if (newfd < 0) {
4875 /* error already reported by net_socket_mcast_create() */
4876 close(fd);
4877 return NULL;
4878 }
4879 /* clone newfd to fd, close newfd */
4880 dup2(newfd, fd);
4881 close(newfd);
4882
4883 } else {
4884 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4885 fd, strerror(errno));
4886 return NULL;
4887 }
4888 }
4889
4890 s = qemu_mallocz(sizeof(NetSocketState));
4891 if (!s)
4892 return NULL;
4893 s->fd = fd;
4894
4895 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4896 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4897
4898 /* mcast: save bound address as dst */
4899 if (is_connected) s->dgram_dst=saddr;
4900
4901 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4902 "socket: fd=%d (%s mcast=%s:%d)",
4903 fd, is_connected? "cloned" : "",
4904 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4905 return s;
4906 }
4907
4908 static void net_socket_connect(void *opaque)
4909 {
4910 NetSocketState *s = opaque;
4911 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4912 }
4913
4914 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4915 int is_connected)
4916 {
4917 NetSocketState *s;
4918 s = qemu_mallocz(sizeof(NetSocketState));
4919 if (!s)
4920 return NULL;
4921 s->fd = fd;
4922 s->vc = qemu_new_vlan_client(vlan,
4923 net_socket_receive, NULL, s);
4924 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4925 "socket: fd=%d", fd);
4926 if (is_connected) {
4927 net_socket_connect(s);
4928 } else {
4929 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4930 }
4931 return s;
4932 }
4933
4934 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4935 int is_connected)
4936 {
4937 int so_type=-1, optlen=sizeof(so_type);
4938
4939 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4940 (socklen_t *)&optlen)< 0) {
4941 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4942 return NULL;
4943 }
4944 switch(so_type) {
4945 case SOCK_DGRAM:
4946 return net_socket_fd_init_dgram(vlan, fd, is_connected);
4947 case SOCK_STREAM:
4948 return net_socket_fd_init_stream(vlan, fd, is_connected);
4949 default:
4950 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4951 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4952 return net_socket_fd_init_stream(vlan, fd, is_connected);
4953 }
4954 return NULL;
4955 }
4956
4957 static void net_socket_accept(void *opaque)
4958 {
4959 NetSocketListenState *s = opaque;
4960 NetSocketState *s1;
4961 struct sockaddr_in saddr;
4962 socklen_t len;
4963 int fd;
4964
4965 for(;;) {
4966 len = sizeof(saddr);
4967 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4968 if (fd < 0 && errno != EINTR) {
4969 return;
4970 } else if (fd >= 0) {
4971 break;
4972 }
4973 }
4974 s1 = net_socket_fd_init(s->vlan, fd, 1);
4975 if (!s1) {
4976 closesocket(fd);
4977 } else {
4978 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4979 "socket: connection from %s:%d",
4980 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4981 }
4982 }
4983
4984 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4985 {
4986 NetSocketListenState *s;
4987 int fd, val, ret;
4988 struct sockaddr_in saddr;
4989
4990 if (parse_host_port(&saddr, host_str) < 0)
4991 return -1;
4992
4993 s = qemu_mallocz(sizeof(NetSocketListenState));
4994 if (!s)
4995 return -1;
4996
4997 fd = socket(PF_INET, SOCK_STREAM, 0);
4998 if (fd < 0) {
4999 perror("socket");
5000 return -1;
5001 }
5002 socket_set_nonblock(fd);
5003
5004 /* allow fast reuse */
5005 val = 1;
5006 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
5007
5008 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
5009 if (ret < 0) {
5010 perror("bind");
5011 return -1;
5012 }
5013 ret = listen(fd, 0);
5014 if (ret < 0) {
5015 perror("listen");
5016 return -1;
5017 }
5018 s->vlan = vlan;
5019 s->fd = fd;
5020 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
5021 return 0;
5022 }
5023
5024 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
5025 {
5026 NetSocketState *s;
5027 int fd, connected, ret, err;
5028 struct sockaddr_in saddr;
5029
5030 if (parse_host_port(&saddr, host_str) < 0)
5031 return -1;
5032
5033 fd = socket(PF_INET, SOCK_STREAM, 0);
5034 if (fd < 0) {
5035 perror("socket");
5036 return -1;
5037 }
5038 socket_set_nonblock(fd);
5039
5040 connected = 0;
5041 for(;;) {
5042 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
5043 if (ret < 0) {
5044 err = socket_error();
5045 if (err == EINTR || err == EWOULDBLOCK) {
5046 } else if (err == EINPROGRESS) {
5047 break;
5048 #ifdef _WIN32
5049 } else if (err == WSAEALREADY) {
5050 break;
5051 #endif
5052 } else {
5053 perror("connect");
5054 closesocket(fd);
5055 return -1;
5056 }
5057 } else {
5058 connected = 1;
5059 break;
5060 }
5061 }
5062 s = net_socket_fd_init(vlan, fd, connected);
5063 if (!s)
5064 return -1;
5065 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
5066 "socket: connect to %s:%d",
5067 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
5068 return 0;
5069 }
5070
5071 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
5072 {
5073 NetSocketState *s;
5074 int fd;
5075 struct sockaddr_in saddr;
5076
5077 if (parse_host_port(&saddr, host_str) < 0)
5078 return -1;
5079
5080
5081 fd = net_socket_mcast_create(&saddr);
5082 if (fd < 0)
5083 return -1;
5084
5085 s = net_socket_fd_init(vlan, fd, 0);
5086 if (!s)
5087 return -1;
5088
5089 s->dgram_dst = saddr;
5090
5091 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
5092 "socket: mcast=%s:%d",
5093 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
5094 return 0;
5095
5096 }
5097
5098 static const char *get_opt_name(char *buf, int buf_size, const char *p)
5099 {
5100 char *q;
5101
5102 q = buf;
5103 while (*p != '\0' && *p != '=') {
5104 if (q && (q - buf) < buf_size - 1)
5105 *q++ = *p;
5106 p++;
5107 }
5108 if (q)
5109 *q = '\0';
5110
5111 return p;
5112 }
5113
5114 static const char *get_opt_value(char *buf, int buf_size, const char *p)
5115 {
5116 char *q;
5117
5118 q = buf;
5119 while (*p != '\0') {
5120 if (*p == ',') {
5121 if (*(p + 1) != ',')
5122 break;
5123 p++;
5124 }
5125 if (q && (q - buf) < buf_size - 1)
5126 *q++ = *p;
5127 p++;
5128 }
5129 if (q)
5130 *q = '\0';
5131
5132 return p;
5133 }
5134
5135 static int get_param_value(char *buf, int buf_size,
5136 const char *tag, const char *str)
5137 {
5138 const char *p;
5139 char option[128];
5140
5141 p = str;
5142 for(;;) {
5143 p = get_opt_name(option, sizeof(option), p);
5144 if (*p != '=')
5145 break;
5146 p++;
5147 if (!strcmp(tag, option)) {
5148 (void)get_opt_value(buf, buf_size, p);
5149 return strlen(buf);
5150 } else {
5151 p = get_opt_value(NULL, 0, p);
5152 }
5153 if (*p != ',')
5154 break;
5155 p++;
5156 }
5157 return 0;
5158 }
5159
5160 static int check_params(char *buf, int buf_size,
5161 const char * const *params, const char *str)
5162 {
5163 const char *p;
5164 int i;
5165
5166 p = str;
5167 for(;;) {
5168 p = get_opt_name(buf, buf_size, p);
5169 if (*p != '=')
5170 return -1;
5171 p++;
5172 for(i = 0; params[i] != NULL; i++)
5173 if (!strcmp(params[i], buf))
5174 break;
5175 if (params[i] == NULL)
5176 return -1;
5177 p = get_opt_value(NULL, 0, p);
5178 if (*p != ',')
5179 break;
5180 p++;
5181 }
5182 return 0;
5183 }
5184
5185 static int net_client_init(const char *device, const char *p)
5186 {
5187 char buf[1024];
5188 int vlan_id, ret;
5189 VLANState *vlan;
5190
5191 vlan_id = 0;
5192 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
5193 vlan_id = strtol(buf, NULL, 0);
5194 }
5195 vlan = qemu_find_vlan(vlan_id);
5196 if (!vlan) {
5197 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
5198 return -1;
5199 }
5200 if (!strcmp(device, "nic")) {
5201 NICInfo *nd;
5202 uint8_t *macaddr;
5203
5204 if (nb_nics >= MAX_NICS) {
5205 fprintf(stderr, "Too Many NICs\n");
5206 return -1;
5207 }
5208 nd = &nd_table[nb_nics];
5209 macaddr = nd->macaddr;
5210 macaddr[0] = 0x52;
5211 macaddr[1] = 0x54;
5212 macaddr[2] = 0x00;
5213 macaddr[3] = 0x12;
5214 macaddr[4] = 0x34;
5215 macaddr[5] = 0x56 + nb_nics;
5216
5217 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
5218 if (parse_macaddr(macaddr, buf) < 0) {
5219 fprintf(stderr, "invalid syntax for ethernet address\n");
5220 return -1;
5221 }
5222 }
5223 if (get_param_value(buf, sizeof(buf), "model", p)) {
5224 nd->model = strdup(buf);
5225 }
5226 nd->vlan = vlan;
5227 nb_nics++;
5228 vlan->nb_guest_devs++;
5229 ret = 0;
5230 } else
5231 if (!strcmp(device, "none")) {
5232 /* does nothing. It is needed to signal that no network cards
5233 are wanted */
5234 ret = 0;
5235 } else
5236 #ifdef CONFIG_SLIRP
5237 if (!strcmp(device, "user")) {
5238 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
5239 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
5240 }
5241 vlan->nb_host_devs++;
5242 ret = net_slirp_init(vlan);
5243 } else
5244 #endif
5245 #ifdef _WIN32
5246 if (!strcmp(device, "tap")) {
5247 char ifname[64];
5248 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
5249 fprintf(stderr, "tap: no interface name\n");
5250 return -1;
5251 }
5252 vlan->nb_host_devs++;
5253 ret = tap_win32_init(vlan, ifname);
5254 } else
5255 #else
5256 if (!strcmp(device, "tap")) {
5257 char ifname[64];
5258 char setup_script[1024], down_script[1024];
5259 int fd;
5260 vlan->nb_host_devs++;
5261 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
5262 fd = strtol(buf, NULL, 0);
5263 fcntl(fd, F_SETFL, O_NONBLOCK);
5264 ret = -1;
5265 if (net_tap_fd_init(vlan, fd))
5266 ret = 0;
5267 } else {
5268 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
5269 ifname[0] = '\0';
5270 }
5271 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
5272 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
5273 }
5274 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
5275 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
5276 }
5277 ret = net_tap_init(vlan, ifname, setup_script, down_script);
5278 }
5279 } else
5280 #endif
5281 if (!strcmp(device, "socket")) {
5282 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
5283 int fd;
5284 fd = strtol(buf, NULL, 0);
5285 ret = -1;
5286 if (net_socket_fd_init(vlan, fd, 1))
5287 ret = 0;
5288 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
5289 ret = net_socket_listen_init(vlan, buf);
5290 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
5291 ret = net_socket_connect_init(vlan, buf);
5292 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
5293 ret = net_socket_mcast_init(vlan, buf);
5294 } else {
5295 fprintf(stderr, "Unknown socket options: %s\n", p);
5296 return -1;
5297 }
5298 vlan->nb_host_devs++;
5299 } else
5300 #ifdef CONFIG_VDE
5301 if (!strcmp(device, "vde")) {
5302 char vde_sock[1024], vde_group[512];
5303 int vde_port, vde_mode;
5304 vlan->nb_host_devs++;
5305 if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
5306 vde_sock[0] = '\0';
5307 }
5308 if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
5309 vde_port = strtol(buf, NULL, 10);
5310 } else {
5311 vde_port = 0;
5312 }
5313 if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
5314 vde_group[0] = '\0';
5315 }
5316 if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
5317 vde_mode = strtol(buf, NULL, 8);
5318 } else {
5319 vde_mode = 0700;
5320 }
5321 ret = net_vde_init(vlan, vde_sock, vde_port, vde_group, vde_mode);
5322 } else
5323 #endif
5324 {
5325 fprintf(stderr, "Unknown network device: %s\n", device);
5326 return -1;
5327 }
5328 if (ret < 0) {
5329 fprintf(stderr, "Could not initialize device '%s'\n", device);
5330 }
5331
5332 return ret;
5333 }
5334
5335 static int net_client_parse(const char *str)
5336 {
5337 const char *p;
5338 char *q;
5339 char device[64];
5340
5341 p = str;
5342 q = device;
5343 while (*p != '\0' && *p != ',') {
5344 if ((q - device) < sizeof(device) - 1)
5345 *q++ = *p;
5346 p++;
5347 }
5348 *q = '\0';
5349 if (*p == ',')
5350 p++;
5351
5352 return net_client_init(device, p);
5353 }
5354
5355 void do_info_network(void)
5356 {
5357 VLANState *vlan;
5358 VLANClientState *vc;
5359
5360 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
5361 term_printf("VLAN %d devices:\n", vlan->id);
5362 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
5363 term_printf(" %s\n", vc->info_str);
5364 }
5365 }
5366
5367 /***********************************************************/
5368 /* Bluetooth support */
5369 static int nb_hcis;
5370 static int cur_hci;
5371 static struct HCIInfo *hci_table[MAX_NICS];
5372 static struct bt_vlan_s {
5373 struct bt_scatternet_s net;
5374 int id;
5375 struct bt_vlan_s *next;
5376 } *first_bt_vlan;
5377
5378 /* find or alloc a new bluetooth "VLAN" */
5379 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
5380 {
5381 struct bt_vlan_s **pvlan, *vlan;
5382 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
5383 if (vlan->id == id)
5384 return &vlan->net;
5385 }
5386 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
5387 vlan->id = id;
5388 pvlan = &first_bt_vlan;
5389 while (*pvlan != NULL)
5390 pvlan = &(*pvlan)->next;
5391 *pvlan = vlan;
5392 return &vlan->net;
5393 }
5394
5395 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
5396 {
5397 }
5398
5399 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
5400 {
5401 return -ENOTSUP;
5402 }
5403
5404 static struct HCIInfo null_hci = {
5405 .cmd_send = null_hci_send,
5406 .sco_send = null_hci_send,
5407 .acl_send = null_hci_send,
5408 .bdaddr_set = null_hci_addr_set,
5409 };
5410
5411 struct HCIInfo *qemu_next_hci(void)
5412 {
5413 if (cur_hci == nb_hcis)
5414 return &null_hci;
5415
5416 return hci_table[cur_hci++];
5417 }
5418
5419 /***********************************************************/
5420 /* QEMU Block devices */
5421
5422 #define HD_ALIAS "index=%d,media=disk"
5423 #ifdef TARGET_PPC
5424 #define CDROM_ALIAS "index=1,media=cdrom"
5425 #else
5426 #define CDROM_ALIAS "index=2,media=cdrom"
5427 #endif
5428 #define FD_ALIAS "index=%d,if=floppy"
5429 #define PFLASH_ALIAS "if=pflash"
5430 #define MTD_ALIAS "if=mtd"
5431 #define SD_ALIAS "index=0,if=sd"
5432
5433 static int drive_add(const char *file, const char *fmt, ...)
5434 {
5435 va_list ap;
5436
5437 if (nb_drives_opt >= MAX_DRIVES) {
5438 fprintf(stderr, "qemu: too many drives\n");
5439 exit(1);
5440 }
5441
5442 drives_opt[nb_drives_opt].file = file;
5443 va_start(ap, fmt);
5444 vsnprintf(drives_opt[nb_drives_opt].opt,
5445 sizeof(drives_opt[0].opt), fmt, ap);
5446 va_end(ap);
5447
5448 return nb_drives_opt++;
5449 }
5450
5451 int drive_get_index(BlockInterfaceType type, int bus, int unit)
5452 {
5453 int index;
5454
5455 /* seek interface, bus and unit */
5456
5457 for (index = 0; index < nb_drives; index++)
5458 if (drives_table[index].type == type &&
5459 drives_table[index].bus == bus &&
5460 drives_table[index].unit == unit)
5461 return index;
5462
5463 return -1;
5464 }
5465
5466 int drive_get_max_bus(BlockInterfaceType type)
5467 {
5468 int max_bus;
5469 int index;
5470
5471 max_bus = -1;
5472 for (index = 0; index < nb_drives; index++) {
5473 if(drives_table[index].type == type &&
5474 drives_table[index].bus > max_bus)
5475 max_bus = drives_table[index].bus;
5476 }
5477 return max_bus;
5478 }
5479
5480 static void bdrv_format_print(void *opaque, const char *name)
5481 {
5482 fprintf(stderr, " %s", name);
5483 }
5484
5485 static int drive_init(struct drive_opt *arg, int snapshot,
5486 QEMUMachine *machine)
5487 {
5488 char buf[128];
5489 char file[1024];
5490 char devname[128];
5491 const char *mediastr = "";
5492 BlockInterfaceType type;
5493 enum { MEDIA_DISK, MEDIA_CDROM } media;
5494 int bus_id, unit_id;
5495 int cyls, heads, secs, translation;
5496 BlockDriverState *bdrv;
5497 BlockDriver *drv = NULL;
5498 int max_devs;
5499 int index;
5500 int cache;
5501 int bdrv_flags;
5502 char *str = arg->opt;
5503 static const char * const params[] = { "bus", "unit", "if", "index",
5504 "cyls", "heads", "secs", "trans",
5505 "media", "snapshot", "file",
5506 "cache", "format", NULL };
5507
5508 if (check_params(buf, sizeof(buf), params, str) < 0) {
5509 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
5510 buf, str);
5511 return -1;
5512 }
5513
5514 file[0] = 0;
5515 cyls = heads = secs = 0;
5516 bus_id = 0;
5517 unit_id = -1;
5518 translation = BIOS_ATA_TRANSLATION_AUTO;
5519 index = -1;
5520 cache = 1;
5521
5522 if (machine->use_scsi) {
5523 type = IF_SCSI;
5524 max_devs = MAX_SCSI_DEVS;
5525 pstrcpy(devname, sizeof(devname), "scsi");
5526 } else {
5527 type = IF_IDE;
5528 max_devs = MAX_IDE_DEVS;
5529 pstrcpy(devname, sizeof(devname), "ide");
5530 }
5531 media = MEDIA_DISK;
5532
5533 /* extract parameters */
5534
5535 if (get_param_value(buf, sizeof(buf), "bus", str)) {
5536 bus_id = strtol(buf, NULL, 0);
5537 if (bus_id < 0) {
5538 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
5539 return -1;
5540 }
5541 }
5542
5543 if (get_param_value(buf, sizeof(buf), "unit", str)) {
5544 unit_id = strtol(buf, NULL, 0);
5545 if (unit_id < 0) {
5546 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
5547 return -1;
5548 }
5549 }
5550
5551 if (get_param_value(buf, sizeof(buf), "if", str)) {
5552 pstrcpy(devname, sizeof(devname), buf);
5553 if (!strcmp(buf, "ide")) {
5554 type = IF_IDE;
5555 max_devs = MAX_IDE_DEVS;
5556 } else if (!strcmp(buf, "scsi")) {
5557 type = IF_SCSI;
5558 max_devs = MAX_SCSI_DEVS;
5559 } else if (!strcmp(buf, "floppy")) {
5560 type = IF_FLOPPY;
5561 max_devs = 0;
5562 } else if (!strcmp(buf, "pflash")) {
5563 type = IF_PFLASH;
5564 max_devs = 0;
5565 } else if (!strcmp(buf, "mtd")) {
5566 type = IF_MTD;
5567 max_devs = 0;
5568 } else if (!strcmp(buf, "sd")) {
5569 type = IF_SD;
5570 max_devs = 0;
5571 } else {
5572 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5573 return -1;
5574 }
5575 }
5576
5577 if (get_param_value(buf, sizeof(buf), "index", str)) {
5578 index = strtol(buf, NULL, 0);
5579 if (index < 0) {
5580 fprintf(stderr, "qemu: '%s' invalid index\n", str);
5581 return -1;
5582 }
5583 }
5584
5585 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5586 cyls = strtol(buf, NULL, 0);
5587 }
5588
5589 if (get_param_value(buf, sizeof(buf), "heads", str)) {
5590 heads = strtol(buf, NULL, 0);
5591 }
5592
5593 if (get_param_value(buf, sizeof(buf), "secs", str)) {
5594 secs = strtol(buf, NULL, 0);
5595 }
5596
5597 if (cyls || heads || secs) {
5598 if (cyls < 1 || cyls > 16383) {
5599 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5600 return -1;
5601 }
5602 if (heads < 1 || heads > 16) {
5603 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5604 return -1;
5605 }
5606 if (secs < 1 || secs > 63) {
5607 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5608 return -1;
5609 }
5610 }
5611
5612 if (get_param_value(buf, sizeof(buf), "trans", str)) {
5613 if (!cyls) {
5614 fprintf(stderr,
5615 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5616 str);
5617 return -1;
5618 }
5619 if (!strcmp(buf, "none"))
5620 translation = BIOS_ATA_TRANSLATION_NONE;
5621 else if (!strcmp(buf, "lba"))
5622 translation = BIOS_ATA_TRANSLATION_LBA;
5623 else if (!strcmp(buf, "auto"))
5624 translation = BIOS_ATA_TRANSLATION_AUTO;
5625 else {
5626 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5627 return -1;
5628 }
5629 }
5630
5631 if (get_param_value(buf, sizeof(buf), "media", str)) {
5632 if (!strcmp(buf, "disk")) {
5633 media = MEDIA_DISK;
5634 } else if (!strcmp(buf, "cdrom")) {
5635 if (cyls || secs || heads) {
5636 fprintf(stderr,
5637 "qemu: '%s' invalid physical CHS format\n", str);
5638 return -1;
5639 }
5640 media = MEDIA_CDROM;
5641 } else {
5642 fprintf(stderr, "qemu: '%s' invalid media\n", str);
5643 return -1;
5644 }
5645 }
5646
5647 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5648 if (!strcmp(buf, "on"))
5649 snapshot = 1;
5650 else if (!strcmp(buf, "off"))
5651 snapshot = 0;
5652 else {
5653 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5654 return -1;
5655 }
5656 }
5657
5658 if (get_param_value(buf, sizeof(buf), "cache", str)) {
5659 if (!strcmp(buf, "off"))
5660 cache = 0;
5661 else if (!strcmp(buf, "on"))
5662 cache = 1;
5663 else {
5664 fprintf(stderr, "qemu: invalid cache option\n");
5665 return -1;
5666 }
5667 }
5668
5669 if (get_param_value(buf, sizeof(buf), "format", str)) {
5670 if (strcmp(buf, "?") == 0) {
5671 fprintf(stderr, "qemu: Supported formats:");
5672 bdrv_iterate_format(bdrv_format_print, NULL);
5673 fprintf(stderr, "\n");
5674 return -1;
5675 }
5676 drv = bdrv_find_format(buf);
5677 if (!drv) {
5678 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
5679 return -1;
5680 }
5681 }
5682
5683 if (arg->file == NULL)
5684 get_param_value(file, sizeof(file), "file", str);
5685 else
5686 pstrcpy(file, sizeof(file), arg->file);
5687
5688 /* compute bus and unit according index */
5689
5690 if (index != -1) {
5691 if (bus_id != 0 || unit_id != -1) {
5692 fprintf(stderr,
5693 "qemu: '%s' index cannot be used with bus and unit\n", str);
5694 return -1;
5695 }
5696 if (max_devs == 0)
5697 {
5698 unit_id = index;
5699 bus_id = 0;
5700 } else {
5701 unit_id = index % max_devs;
5702 bus_id = index / max_devs;
5703 }
5704 }
5705
5706 /* if user doesn't specify a unit_id,
5707 * try to find the first free
5708 */
5709
5710 if (unit_id == -1) {
5711 unit_id = 0;
5712 while (drive_get_index(type, bus_id, unit_id) != -1) {
5713 unit_id++;
5714 if (max_devs && unit_id >= max_devs) {
5715 unit_id -= max_devs;
5716 bus_id++;
5717 }
5718 }
5719 }
5720
5721 /* check unit id */
5722
5723 if (max_devs && unit_id >= max_devs) {
5724 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5725 str, unit_id, max_devs - 1);
5726 return -1;
5727 }
5728
5729 /*
5730 * ignore multiple definitions
5731 */
5732
5733 if (drive_get_index(type, bus_id, unit_id) != -1)
5734 return 0;
5735
5736 /* init */
5737
5738 if (type == IF_IDE || type == IF_SCSI)
5739 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5740 if (max_devs)
5741 snprintf(buf, sizeof(buf), "%s%i%s%i",
5742 devname, bus_id, mediastr, unit_id);
5743 else
5744 snprintf(buf, sizeof(buf), "%s%s%i",
5745 devname, mediastr, unit_id);
5746 bdrv = bdrv_new(buf);
5747 drives_table[nb_drives].bdrv = bdrv;
5748 drives_table[nb_drives].type = type;
5749 drives_table[nb_drives].bus = bus_id;
5750 drives_table[nb_drives].unit = unit_id;
5751 nb_drives++;
5752
5753 switch(type) {
5754 case IF_IDE:
5755 case IF_SCSI:
5756 switch(media) {
5757 case MEDIA_DISK:
5758 if (cyls != 0) {
5759 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5760 bdrv_set_translation_hint(bdrv, translation);
5761 }
5762 break;
5763 case MEDIA_CDROM:
5764 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5765 break;
5766 }
5767 break;
5768 case IF_SD:
5769 /* FIXME: This isn't really a floppy, but it's a reasonable
5770 approximation. */
5771 case IF_FLOPPY:
5772 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5773 break;
5774 case IF_PFLASH:
5775 case IF_MTD:
5776 break;
5777 }
5778 if (!file[0])
5779 return 0;
5780 bdrv_flags = 0;
5781 if (snapshot)
5782 bdrv_flags |= BDRV_O_SNAPSHOT;
5783 if (!cache)
5784 bdrv_flags |= BDRV_O_DIRECT;
5785 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
5786 fprintf(stderr, "qemu: could not open disk image %s\n",
5787 file);
5788 return -1;
5789 }
5790 return 0;
5791 }
5792
5793 /***********************************************************/
5794 /* USB devices */
5795
5796 static USBPort *used_usb_ports;
5797 static USBPort *free_usb_ports;
5798
5799 /* ??? Maybe change this to register a hub to keep track of the topology. */
5800 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5801 usb_attachfn attach)
5802 {
5803 port->opaque = opaque;
5804 port->index = index;
5805 port->attach = attach;
5806 port->next = free_usb_ports;
5807 free_usb_ports = port;
5808 }
5809
5810 int usb_device_add_dev(USBDevice *dev)
5811 {
5812 USBPort *port;
5813
5814 /* Find a USB port to add the device to. */
5815 port = free_usb_ports;
5816 if (!port->next) {
5817 USBDevice *hub;
5818
5819 /* Create a new hub and chain it on. */
5820 free_usb_ports = NULL;
5821 port->next = used_usb_ports;
5822 used_usb_ports = port;
5823
5824 hub = usb_hub_init(VM_USB_HUB_SIZE);
5825 usb_attach(port, hub);
5826 port = free_usb_ports;
5827 }
5828
5829 free_usb_ports = port->next;
5830 port->next = used_usb_ports;
5831 used_usb_ports = port;
5832 usb_attach(port, dev);
5833 return 0;
5834 }
5835
5836 static int usb_device_add(const char *devname)
5837 {
5838 const char *p;
5839 USBDevice *dev;
5840
5841 if (!free_usb_ports)
5842 return -1;
5843
5844 if (strstart(devname, "host:", &p)) {
5845 dev = usb_host_device_open(p);
5846 } else if (!strcmp(devname, "mouse")) {
5847 dev = usb_mouse_init();
5848 } else if (!strcmp(devname, "tablet")) {
5849 dev = usb_tablet_init();
5850 } else if (!strcmp(devname, "keyboard")) {
5851 dev = usb_keyboard_init();
5852 } else if (strstart(devname, "disk:", &p)) {
5853 dev = usb_msd_init(p);
5854 } else if (!strcmp(devname, "wacom-tablet")) {
5855 dev = usb_wacom_init();
5856 } else if (strstart(devname, "serial:", &p)) {
5857 dev = usb_serial_init(p);
5858 #ifdef CONFIG_BRLAPI
5859 } else if (!strcmp(devname, "braille")) {
5860 dev = usb_baum_init();
5861 #endif
5862 } else if (strstart(devname, "net:", &p)) {
5863 int nic = nb_nics;
5864
5865 if (net_client_init("nic", p) < 0)
5866 return -1;
5867 nd_table[nic].model = "usb";
5868 dev = usb_net_init(&nd_table[nic]);
5869 } else {
5870 return -1;
5871 }
5872 if (!dev)
5873 return -1;
5874
5875 return usb_device_add_dev(dev);
5876 }
5877
5878 int usb_device_del_addr(int bus_num, int addr)
5879 {
5880 USBPort *port;
5881 USBPort **lastp;
5882 USBDevice *dev;
5883
5884 if (!used_usb_ports)
5885 return -1;
5886
5887 if (bus_num != 0)
5888 return -1;
5889
5890 lastp = &used_usb_ports;
5891 port = used_usb_ports;
5892 while (port && port->dev->addr != addr) {
5893 lastp = &port->next;
5894 port = port->next;
5895 }
5896
5897 if (!port)
5898 return -1;
5899
5900 dev = port->dev;
5901 *lastp = port->next;
5902 usb_attach(port, NULL);
5903 dev->handle_destroy(dev);
5904 port->next = free_usb_ports;
5905 free_usb_ports = port;
5906 return 0;
5907 }
5908
5909 static int usb_device_del(const char *devname)
5910 {
5911 int bus_num, addr;
5912 const char *p;
5913
5914 if (strstart(devname, "host:", &p))
5915 return usb_host_device_close(p);
5916
5917 if (!used_usb_ports)
5918 return -1;
5919
5920 p = strchr(devname, '.');
5921 if (!p)
5922 return -1;
5923 bus_num = strtoul(devname, NULL, 0);
5924 addr = strtoul(p + 1, NULL, 0);
5925
5926 return usb_device_del_addr(bus_num, addr);
5927 }
5928
5929 void do_usb_add(const char *devname)
5930 {
5931 usb_device_add(devname);
5932 }
5933
5934 void do_usb_del(const char *devname)
5935 {
5936 usb_device_del(devname);
5937 }
5938
5939 void usb_info(void)
5940 {
5941 USBDevice *dev;
5942 USBPort *port;
5943 const char *speed_str;
5944
5945 if (!usb_enabled) {
5946 term_printf("USB support not enabled\n");
5947 return;
5948 }
5949
5950 for (port = used_usb_ports; port; port = port->next) {
5951 dev = port->dev;
5952 if (!dev)
5953 continue;
5954 switch(dev->speed) {
5955 case USB_SPEED_LOW:
5956 speed_str = "1.5";
5957 break;
5958 case USB_SPEED_FULL:
5959 speed_str = "12";
5960 break;
5961 case USB_SPEED_HIGH:
5962 speed_str = "480";
5963 break;
5964 default:
5965 speed_str = "?";
5966 break;
5967 }
5968 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5969 0, dev->addr, speed_str, dev->devname);
5970 }
5971 }
5972
5973 /***********************************************************/
5974 /* PCMCIA/Cardbus */
5975
5976 static struct pcmcia_socket_entry_s {
5977 struct pcmcia_socket_s *socket;
5978 struct pcmcia_socket_entry_s *next;
5979 } *pcmcia_sockets = 0;
5980
5981 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5982 {
5983 struct pcmcia_socket_entry_s *entry;
5984
5985 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5986 entry->socket = socket;
5987 entry->next = pcmcia_sockets;
5988 pcmcia_sockets = entry;
5989 }
5990
5991 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5992 {
5993 struct pcmcia_socket_entry_s *entry, **ptr;
5994
5995 ptr = &pcmcia_sockets;
5996 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5997 if (entry->socket == socket) {
5998 *ptr = entry->next;
5999 qemu_free(entry);
6000 }
6001 }
6002
6003 void pcmcia_info(void)
6004 {
6005 struct pcmcia_socket_entry_s *iter;
6006 if (!pcmcia_sockets)
6007 term_printf("No PCMCIA sockets\n");
6008
6009 for (iter = pcmcia_sockets; iter; iter = iter->next)
6010 term_printf("%s: %s\n", iter->socket->slot_string,
6011 iter->socket->attached ? iter->socket->card_string :
6012 "Empty");
6013 }
6014
6015 /***********************************************************/
6016 /* dumb display */
6017
6018 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
6019 {
6020 }
6021
6022 static void dumb_resize(DisplayState *ds, int w, int h)
6023 {
6024 }
6025
6026 static void dumb_refresh(DisplayState *ds)
6027 {
6028 #if defined(CONFIG_SDL)
6029 vga_hw_update();
6030 #endif
6031 }
6032
6033 static void dumb_display_init(DisplayState *ds)
6034 {
6035 ds->data = NULL;
6036 ds->linesize = 0;
6037 ds->depth = 0;
6038 ds->dpy_update = dumb_update;
6039 ds->dpy_resize = dumb_resize;
6040 ds->dpy_refresh = dumb_refresh;
6041 ds->gui_timer_interval = 500;
6042 ds->idle = 1;
6043 }
6044
6045 /***********************************************************/
6046 /* I/O handling */
6047
6048 #define MAX_IO_HANDLERS 64
6049
6050 typedef struct IOHandlerRecord {
6051 int fd;
6052 IOCanRWHandler *fd_read_poll;
6053 IOHandler *fd_read;
6054 IOHandler *fd_write;
6055 int deleted;
6056 void *opaque;
6057 /* temporary data */
6058 struct pollfd *ufd;
6059 struct IOHandlerRecord *next;
6060 } IOHandlerRecord;
6061
6062 static IOHandlerRecord *first_io_handler;
6063
6064 /* XXX: fd_read_poll should be suppressed, but an API change is
6065 necessary in the character devices to suppress fd_can_read(). */
6066 int qemu_set_fd_handler2(int fd,
6067 IOCanRWHandler *fd_read_poll,
6068 IOHandler *fd_read,
6069 IOHandler *fd_write,
6070 void *opaque)
6071 {
6072 IOHandlerRecord **pioh, *ioh;
6073
6074 if (!fd_read && !fd_write) {
6075 pioh = &first_io_handler;
6076 for(;;) {
6077 ioh = *pioh;
6078 if (ioh == NULL)
6079 break;
6080 if (ioh->fd == fd) {
6081 ioh->deleted = 1;
6082 break;
6083 }
6084 pioh = &ioh->next;
6085 }
6086 } else {
6087 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6088 if (ioh->fd == fd)
6089 goto found;
6090 }
6091 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
6092 if (!ioh)
6093 return -1;
6094 ioh->next = first_io_handler;
6095 first_io_handler = ioh;
6096 found:
6097 ioh->fd = fd;
6098 ioh->fd_read_poll = fd_read_poll;
6099 ioh->fd_read = fd_read;
6100 ioh->fd_write = fd_write;
6101 ioh->opaque = opaque;
6102 ioh->deleted = 0;
6103 }
6104 return 0;
6105 }
6106
6107 int qemu_set_fd_handler(int fd,
6108 IOHandler *fd_read,
6109 IOHandler *fd_write,
6110 void *opaque)
6111 {
6112 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
6113 }
6114
6115 /***********************************************************/
6116 /* Polling handling */
6117
6118 typedef struct PollingEntry {
6119 PollingFunc *func;
6120 void *opaque;
6121 struct PollingEntry *next;
6122 } PollingEntry;
6123
6124 static PollingEntry *first_polling_entry;
6125
6126 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
6127 {
6128 PollingEntry **ppe, *pe;
6129 pe = qemu_mallocz(sizeof(PollingEntry));
6130 if (!pe)
6131 return -1;
6132 pe->func = func;
6133 pe->opaque = opaque;
6134 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
6135 *ppe = pe;
6136 return 0;
6137 }
6138
6139 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
6140 {
6141 PollingEntry **ppe, *pe;
6142 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
6143 pe = *ppe;
6144 if (pe->func == func && pe->opaque == opaque) {
6145 *ppe = pe->next;
6146 qemu_free(pe);
6147 break;
6148 }
6149 }
6150 }
6151
6152 #ifdef _WIN32
6153 /***********************************************************/
6154 /* Wait objects support */
6155 typedef struct WaitObjects {
6156 int num;
6157 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
6158 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
6159 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
6160 } WaitObjects;
6161
6162 static WaitObjects wait_objects = {0};
6163
6164 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
6165 {
6166 WaitObjects *w = &wait_objects;
6167
6168 if (w->num >= MAXIMUM_WAIT_OBJECTS)
6169 return -1;
6170 w->events[w->num] = handle;
6171 w->func[w->num] = func;
6172 w->opaque[w->num] = opaque;
6173 w->num++;
6174 return 0;
6175 }
6176
6177 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
6178 {
6179 int i, found;
6180 WaitObjects *w = &wait_objects;
6181
6182 found = 0;
6183 for (i = 0; i < w->num; i++) {
6184 if (w->events[i] == handle)
6185 found = 1;
6186 if (found) {
6187 w->events[i] = w->events[i + 1];
6188 w->func[i] = w->func[i + 1];
6189 w->opaque[i] = w->opaque[i + 1];
6190 }
6191 }
6192 if (found)
6193 w->num--;
6194 }
6195 #endif
6196
6197 /***********************************************************/
6198 /* savevm/loadvm support */
6199
6200 #define IO_BUF_SIZE 32768
6201
6202 struct QEMUFile {
6203 QEMUFilePutBufferFunc *put_buffer;
6204 QEMUFileGetBufferFunc *get_buffer;
6205 QEMUFileCloseFunc *close;
6206 QEMUFileRateLimit *rate_limit;
6207 void *opaque;
6208
6209 int64_t buf_offset; /* start of buffer when writing, end of buffer
6210 when reading */
6211 int buf_index;
6212 int buf_size; /* 0 when writing */
6213 uint8_t buf[IO_BUF_SIZE];
6214 };
6215
6216 typedef struct QEMUFileFD
6217 {
6218 int fd;
6219 QEMUFile *file;
6220 } QEMUFileFD;
6221
6222 static void fd_put_notify(void *opaque)
6223 {
6224 QEMUFileFD *s = opaque;
6225
6226 /* Remove writable callback and do a put notify */
6227 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
6228 qemu_file_put_notify(s->file);
6229 }
6230
6231 static void fd_put_buffer(void *opaque, const uint8_t *buf,
6232 int64_t pos, int size)
6233 {
6234 QEMUFileFD *s = opaque;
6235 ssize_t len;
6236
6237 do {
6238 len = write(s->fd, buf, size);
6239 } while (len == -1 && errno == EINTR);
6240
6241 if (len == -1)
6242 len = -errno;
6243
6244 /* When the fd becomes writable again, register a callback to do
6245 * a put notify */
6246 if (len == -EAGAIN)
6247 qemu_set_fd_handler2(s->fd, NULL, NULL, fd_put_notify, s);
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 static 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 static 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 int autostart;
8505
8506 LIST_INIT (&vm_change_state_head);
8507 #ifndef _WIN32
8508 {
8509 struct sigaction act;
8510 sigfillset(&act.sa_mask);
8511 act.sa_flags = 0;
8512 act.sa_handler = SIG_IGN;
8513 sigaction(SIGPIPE, &act, NULL);
8514 }
8515 #else
8516 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
8517 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8518 QEMU to run on a single CPU */
8519 {
8520 HANDLE h;
8521 DWORD mask, smask;
8522 int i;
8523 h = GetCurrentProcess();
8524 if (GetProcessAffinityMask(h, &mask, &smask)) {
8525 for(i = 0; i < 32; i++) {
8526 if (mask & (1 << i))
8527 break;
8528 }
8529 if (i != 32) {
8530 mask = 1 << i;
8531 SetProcessAffinityMask(h, mask);
8532 }
8533 }
8534 }
8535 #endif
8536
8537 register_machines();
8538 machine = first_machine;
8539 cpu_model = NULL;
8540 initrd_filename = NULL;
8541 ram_size = 0;
8542 vga_ram_size = VGA_RAM_SIZE;
8543 #ifdef CONFIG_GDBSTUB
8544 use_gdbstub = 0;
8545 gdbstub_port = DEFAULT_GDBSTUB_PORT;
8546 #endif
8547 snapshot = 0;
8548 nographic = 0;
8549 curses = 0;
8550 kernel_filename = NULL;
8551 kernel_cmdline = "";
8552 cyls = heads = secs = 0;
8553 translation = BIOS_ATA_TRANSLATION_AUTO;
8554 monitor_device = "vc";
8555
8556 serial_devices[0] = "vc:80Cx24C";
8557 for(i = 1; i < MAX_SERIAL_PORTS; i++)
8558 serial_devices[i] = NULL;
8559 serial_device_index = 0;
8560
8561 parallel_devices[0] = "vc:640x480";
8562 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
8563 parallel_devices[i] = NULL;
8564 parallel_device_index = 0;
8565
8566 usb_devices_index = 0;
8567
8568 nb_net_clients = 0;
8569 nb_drives = 0;
8570 nb_drives_opt = 0;
8571 hda_index = -1;
8572
8573 nb_nics = 0;
8574
8575 tb_size = 0;
8576 autostart= 1;
8577
8578 optind = 1;
8579 for(;;) {
8580 if (optind >= argc)
8581 break;
8582 r = argv[optind];
8583 if (r[0] != '-') {
8584 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
8585 } else {
8586 const QEMUOption *popt;
8587
8588 optind++;
8589 /* Treat --foo the same as -foo. */
8590 if (r[1] == '-')
8591 r++;
8592 popt = qemu_options;
8593 for(;;) {
8594 if (!popt->name) {
8595 fprintf(stderr, "%s: invalid option -- '%s'\n",
8596 argv[0], r);
8597 exit(1);
8598 }
8599 if (!strcmp(popt->name, r + 1))
8600 break;
8601 popt++;
8602 }
8603 if (popt->flags & HAS_ARG) {
8604 if (optind >= argc) {
8605 fprintf(stderr, "%s: option '%s' requires an argument\n",
8606 argv[0], r);
8607 exit(1);
8608 }
8609 optarg = argv[optind++];
8610 } else {
8611 optarg = NULL;
8612 }
8613
8614 switch(popt->index) {
8615 case QEMU_OPTION_M:
8616 machine = find_machine(optarg);
8617 if (!machine) {
8618 QEMUMachine *m;
8619 printf("Supported machines are:\n");
8620 for(m = first_machine; m != NULL; m = m->next) {
8621 printf("%-10s %s%s\n",
8622 m->name, m->desc,
8623 m == first_machine ? " (default)" : "");
8624 }
8625 exit(*optarg != '?');
8626 }
8627 break;
8628 case QEMU_OPTION_cpu:
8629 /* hw initialization will check this */
8630 if (*optarg == '?') {
8631 /* XXX: implement xxx_cpu_list for targets that still miss it */
8632 #if defined(cpu_list)
8633 cpu_list(stdout, &fprintf);
8634 #endif
8635 exit(0);
8636 } else {
8637 cpu_model = optarg;
8638 }
8639 break;
8640 case QEMU_OPTION_initrd:
8641 initrd_filename = optarg;
8642 break;
8643 case QEMU_OPTION_hda:
8644 if (cyls == 0)
8645 hda_index = drive_add(optarg, HD_ALIAS, 0);
8646 else
8647 hda_index = drive_add(optarg, HD_ALIAS
8648 ",cyls=%d,heads=%d,secs=%d%s",
8649 0, cyls, heads, secs,
8650 translation == BIOS_ATA_TRANSLATION_LBA ?
8651 ",trans=lba" :
8652 translation == BIOS_ATA_TRANSLATION_NONE ?
8653 ",trans=none" : "");
8654 break;
8655 case QEMU_OPTION_hdb:
8656 case QEMU_OPTION_hdc:
8657 case QEMU_OPTION_hdd:
8658 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
8659 break;
8660 case QEMU_OPTION_drive:
8661 drive_add(NULL, "%s", optarg);
8662 break;
8663 case QEMU_OPTION_mtdblock:
8664 drive_add(optarg, MTD_ALIAS);
8665 break;
8666 case QEMU_OPTION_sd:
8667 drive_add(optarg, SD_ALIAS);
8668 break;
8669 case QEMU_OPTION_pflash:
8670 drive_add(optarg, PFLASH_ALIAS);
8671 break;
8672 case QEMU_OPTION_snapshot:
8673 snapshot = 1;
8674 break;
8675 case QEMU_OPTION_hdachs:
8676 {
8677 const char *p;
8678 p = optarg;
8679 cyls = strtol(p, (char **)&p, 0);
8680 if (cyls < 1 || cyls > 16383)
8681 goto chs_fail;
8682 if (*p != ',')
8683 goto chs_fail;
8684 p++;
8685 heads = strtol(p, (char **)&p, 0);
8686 if (heads < 1 || heads > 16)
8687 goto chs_fail;
8688 if (*p != ',')
8689 goto chs_fail;
8690 p++;
8691 secs = strtol(p, (char **)&p, 0);
8692 if (secs < 1 || secs > 63)
8693 goto chs_fail;
8694 if (*p == ',') {
8695 p++;
8696 if (!strcmp(p, "none"))
8697 translation = BIOS_ATA_TRANSLATION_NONE;
8698 else if (!strcmp(p, "lba"))
8699 translation = BIOS_ATA_TRANSLATION_LBA;
8700 else if (!strcmp(p, "auto"))
8701 translation = BIOS_ATA_TRANSLATION_AUTO;
8702 else
8703 goto chs_fail;
8704 } else if (*p != '\0') {
8705 chs_fail:
8706 fprintf(stderr, "qemu: invalid physical CHS format\n");
8707 exit(1);
8708 }
8709 if (hda_index != -1)
8710 snprintf(drives_opt[hda_index].opt,
8711 sizeof(drives_opt[hda_index].opt),
8712 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
8713 0, cyls, heads, secs,
8714 translation == BIOS_ATA_TRANSLATION_LBA ?
8715 ",trans=lba" :
8716 translation == BIOS_ATA_TRANSLATION_NONE ?
8717 ",trans=none" : "");
8718 }
8719 break;
8720 case QEMU_OPTION_nographic:
8721 nographic = 1;
8722 break;
8723 #ifdef CONFIG_CURSES
8724 case QEMU_OPTION_curses:
8725 curses = 1;
8726 break;
8727 #endif
8728 case QEMU_OPTION_portrait:
8729 graphic_rotate = 1;
8730 break;
8731 case QEMU_OPTION_kernel:
8732 kernel_filename = optarg;
8733 break;
8734 case QEMU_OPTION_append:
8735 kernel_cmdline = optarg;
8736 break;
8737 case QEMU_OPTION_cdrom:
8738 drive_add(optarg, CDROM_ALIAS);
8739 break;
8740 case QEMU_OPTION_boot:
8741 boot_devices = optarg;
8742 /* We just do some generic consistency checks */
8743 {
8744 /* Could easily be extended to 64 devices if needed */
8745 const char *p;
8746
8747 boot_devices_bitmap = 0;
8748 for (p = boot_devices; *p != '\0'; p++) {
8749 /* Allowed boot devices are:
8750 * a b : floppy disk drives
8751 * c ... f : IDE disk drives
8752 * g ... m : machine implementation dependant drives
8753 * n ... p : network devices
8754 * It's up to each machine implementation to check
8755 * if the given boot devices match the actual hardware
8756 * implementation and firmware features.
8757 */
8758 if (*p < 'a' || *p > 'q') {
8759 fprintf(stderr, "Invalid boot device '%c'\n", *p);
8760 exit(1);
8761 }
8762 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8763 fprintf(stderr,
8764 "Boot device '%c' was given twice\n",*p);
8765 exit(1);
8766 }
8767 boot_devices_bitmap |= 1 << (*p - 'a');
8768 }
8769 }
8770 break;
8771 case QEMU_OPTION_fda:
8772 case QEMU_OPTION_fdb:
8773 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
8774 break;
8775 #ifdef TARGET_I386
8776 case QEMU_OPTION_no_fd_bootchk:
8777 fd_bootchk = 0;
8778 break;
8779 #endif
8780 case QEMU_OPTION_net:
8781 if (nb_net_clients >= MAX_NET_CLIENTS) {
8782 fprintf(stderr, "qemu: too many network clients\n");
8783 exit(1);
8784 }
8785 net_clients[nb_net_clients] = optarg;
8786 nb_net_clients++;
8787 break;
8788 #ifdef CONFIG_SLIRP
8789 case QEMU_OPTION_tftp:
8790 tftp_prefix = optarg;
8791 break;
8792 case QEMU_OPTION_bootp:
8793 bootp_filename = optarg;
8794 break;
8795 #ifndef _WIN32
8796 case QEMU_OPTION_smb:
8797 net_slirp_smb(optarg);
8798 break;
8799 #endif
8800 case QEMU_OPTION_redir:
8801 net_slirp_redir(optarg);
8802 break;
8803 #endif
8804 #ifdef HAS_AUDIO
8805 case QEMU_OPTION_audio_help:
8806 AUD_help ();
8807 exit (0);
8808 break;
8809 case QEMU_OPTION_soundhw:
8810 select_soundhw (optarg);
8811 break;
8812 #endif
8813 case QEMU_OPTION_h:
8814 help(0);
8815 break;
8816 case QEMU_OPTION_m: {
8817 uint64_t value;
8818 char *ptr;
8819
8820 value = strtoul(optarg, &ptr, 10);
8821 switch (*ptr) {
8822 case 0: case 'M': case 'm':
8823 value <<= 20;
8824 break;
8825 case 'G': case 'g':
8826 value <<= 30;
8827 break;
8828 default:
8829 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
8830 exit(1);
8831 }
8832
8833 /* On 32-bit hosts, QEMU is limited by virtual address space */
8834 if (value > (2047 << 20)
8835 #ifndef USE_KQEMU
8836 && HOST_LONG_BITS == 32
8837 #endif
8838 ) {
8839 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
8840 exit(1);
8841 }
8842 if (value != (uint64_t)(ram_addr_t)value) {
8843 fprintf(stderr, "qemu: ram size too large\n");
8844 exit(1);
8845 }
8846 ram_size = value;
8847 break;
8848 }
8849 case QEMU_OPTION_d:
8850 {
8851 int mask;
8852 const CPULogItem *item;
8853
8854 mask = cpu_str_to_log_mask(optarg);
8855 if (!mask) {
8856 printf("Log items (comma separated):\n");
8857 for(item = cpu_log_items; item->mask != 0; item++) {
8858 printf("%-10s %s\n", item->name, item->help);
8859 }
8860 exit(1);
8861 }
8862 cpu_set_log(mask);
8863 }
8864 break;
8865 #ifdef CONFIG_GDBSTUB
8866 case QEMU_OPTION_s:
8867 use_gdbstub = 1;
8868 break;
8869 case QEMU_OPTION_p:
8870 gdbstub_port = optarg;
8871 break;
8872 #endif
8873 case QEMU_OPTION_L:
8874 bios_dir = optarg;
8875 break;
8876 case QEMU_OPTION_bios:
8877 bios_name = optarg;
8878 break;
8879 case QEMU_OPTION_S:
8880 autostart = 0;
8881 break;
8882 case QEMU_OPTION_k:
8883 keyboard_layout = optarg;
8884 break;
8885 case QEMU_OPTION_localtime:
8886 rtc_utc = 0;
8887 break;
8888 case QEMU_OPTION_vga:
8889 select_vgahw (optarg);
8890 break;
8891 case QEMU_OPTION_g:
8892 {
8893 const char *p;
8894 int w, h, depth;
8895 p = optarg;
8896 w = strtol(p, (char **)&p, 10);
8897 if (w <= 0) {
8898 graphic_error:
8899 fprintf(stderr, "qemu: invalid resolution or depth\n");
8900 exit(1);
8901 }
8902 if (*p != 'x')
8903 goto graphic_error;
8904 p++;
8905 h = strtol(p, (char **)&p, 10);
8906 if (h <= 0)
8907 goto graphic_error;
8908 if (*p == 'x') {
8909 p++;
8910 depth = strtol(p, (char **)&p, 10);
8911 if (depth != 8 && depth != 15 && depth != 16 &&
8912 depth != 24 && depth != 32)
8913 goto graphic_error;
8914 } else if (*p == '\0') {
8915 depth = graphic_depth;
8916 } else {
8917 goto graphic_error;
8918 }
8919
8920 graphic_width = w;
8921 graphic_height = h;
8922 graphic_depth = depth;
8923 }
8924 break;
8925 case QEMU_OPTION_echr:
8926 {
8927 char *r;
8928 term_escape_char = strtol(optarg, &r, 0);
8929 if (r == optarg)
8930 printf("Bad argument to echr\n");
8931 break;
8932 }
8933 case QEMU_OPTION_monitor:
8934 monitor_device = optarg;
8935 break;
8936 case QEMU_OPTION_serial:
8937 if (serial_device_index >= MAX_SERIAL_PORTS) {
8938 fprintf(stderr, "qemu: too many serial ports\n");
8939 exit(1);
8940 }
8941 serial_devices[serial_device_index] = optarg;
8942 serial_device_index++;
8943 break;
8944 case QEMU_OPTION_parallel:
8945 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8946 fprintf(stderr, "qemu: too many parallel ports\n");
8947 exit(1);
8948 }
8949 parallel_devices[parallel_device_index] = optarg;
8950 parallel_device_index++;
8951 break;
8952 case QEMU_OPTION_loadvm:
8953 loadvm = optarg;
8954 break;
8955 case QEMU_OPTION_full_screen:
8956 full_screen = 1;
8957 break;
8958 #ifdef CONFIG_SDL
8959 case QEMU_OPTION_no_frame:
8960 no_frame = 1;
8961 break;
8962 case QEMU_OPTION_alt_grab:
8963 alt_grab = 1;
8964 break;
8965 case QEMU_OPTION_no_quit:
8966 no_quit = 1;
8967 break;
8968 #endif
8969 case QEMU_OPTION_pidfile:
8970 pid_file = optarg;
8971 break;
8972 #ifdef TARGET_I386
8973 case QEMU_OPTION_win2k_hack:
8974 win2k_install_hack = 1;
8975 break;
8976 #endif
8977 #ifdef USE_KQEMU
8978 case QEMU_OPTION_no_kqemu:
8979 kqemu_allowed = 0;
8980 break;
8981 case QEMU_OPTION_kernel_kqemu:
8982 kqemu_allowed = 2;
8983 break;
8984 #endif
8985 case QEMU_OPTION_usb:
8986 usb_enabled = 1;
8987 break;
8988 case QEMU_OPTION_usbdevice:
8989 usb_enabled = 1;
8990 if (usb_devices_index >= MAX_USB_CMDLINE) {
8991 fprintf(stderr, "Too many USB devices\n");
8992 exit(1);
8993 }
8994 usb_devices[usb_devices_index] = optarg;
8995 usb_devices_index++;
8996 break;
8997 case QEMU_OPTION_smp:
8998 smp_cpus = atoi(optarg);
8999 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
9000 fprintf(stderr, "Invalid number of CPUs\n");
9001 exit(1);
9002 }
9003 break;
9004 case QEMU_OPTION_vnc:
9005 vnc_display = optarg;
9006 break;
9007 case QEMU_OPTION_no_acpi:
9008 acpi_enabled = 0;
9009 break;
9010 case QEMU_OPTION_no_reboot:
9011 no_reboot = 1;
9012 break;
9013 case QEMU_OPTION_no_shutdown:
9014 no_shutdown = 1;
9015 break;
9016 case QEMU_OPTION_show_cursor:
9017 cursor_hide = 0;
9018 break;
9019 case QEMU_OPTION_uuid:
9020 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
9021 fprintf(stderr, "Fail to parse UUID string."
9022 " Wrong format.\n");
9023 exit(1);
9024 }
9025 break;
9026 case QEMU_OPTION_daemonize:
9027 daemonize = 1;
9028 break;
9029 case QEMU_OPTION_option_rom:
9030 if (nb_option_roms >= MAX_OPTION_ROMS) {
9031 fprintf(stderr, "Too many option ROMs\n");
9032 exit(1);
9033 }
9034 option_rom[nb_option_roms] = optarg;
9035 nb_option_roms++;
9036 break;
9037 case QEMU_OPTION_semihosting:
9038 semihosting_enabled = 1;
9039 break;
9040 case QEMU_OPTION_name:
9041 qemu_name = optarg;
9042 break;
9043 #ifdef TARGET_SPARC
9044 case QEMU_OPTION_prom_env:
9045 if (nb_prom_envs >= MAX_PROM_ENVS) {
9046 fprintf(stderr, "Too many prom variables\n");
9047 exit(1);
9048 }
9049 prom_envs[nb_prom_envs] = optarg;
9050 nb_prom_envs++;
9051 break;
9052 #endif
9053 #ifdef TARGET_ARM
9054 case QEMU_OPTION_old_param:
9055 old_param = 1;
9056 break;
9057 #endif
9058 case QEMU_OPTION_clock:
9059 configure_alarms(optarg);
9060 break;
9061 case QEMU_OPTION_startdate:
9062 {
9063 struct tm tm;
9064 time_t rtc_start_date;
9065 if (!strcmp(optarg, "now")) {
9066 rtc_date_offset = -1;
9067 } else {
9068 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
9069 &tm.tm_year,
9070 &tm.tm_mon,
9071 &tm.tm_mday,
9072 &tm.tm_hour,
9073 &tm.tm_min,
9074 &tm.tm_sec) == 6) {
9075 /* OK */
9076 } else if (sscanf(optarg, "%d-%d-%d",
9077 &tm.tm_year,
9078 &tm.tm_mon,
9079 &tm.tm_mday) == 3) {
9080 tm.tm_hour = 0;
9081 tm.tm_min = 0;
9082 tm.tm_sec = 0;
9083 } else {
9084 goto date_fail;
9085 }
9086 tm.tm_year -= 1900;
9087 tm.tm_mon--;
9088 rtc_start_date = mktimegm(&tm);
9089 if (rtc_start_date == -1) {
9090 date_fail:
9091 fprintf(stderr, "Invalid date format. Valid format are:\n"
9092 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9093 exit(1);
9094 }
9095 rtc_date_offset = time(NULL) - rtc_start_date;
9096 }
9097 }
9098 break;
9099 case QEMU_OPTION_tb_size:
9100 tb_size = strtol(optarg, NULL, 0);
9101 if (tb_size < 0)
9102 tb_size = 0;
9103 break;
9104 case QEMU_OPTION_icount:
9105 use_icount = 1;
9106 if (strcmp(optarg, "auto") == 0) {
9107 icount_time_shift = -1;
9108 } else {
9109 icount_time_shift = strtol(optarg, NULL, 0);
9110 }
9111 break;
9112 }
9113 }
9114 }
9115
9116 if (nographic) {
9117 if (serial_device_index == 0)
9118 serial_devices[0] = "stdio";
9119 if (parallel_device_index == 0)
9120 parallel_devices[0] = "null";
9121 if (strncmp(monitor_device, "vc", 2) == 0)
9122 monitor_device = "stdio";
9123 }
9124
9125 #ifndef _WIN32
9126 if (daemonize) {
9127 pid_t pid;
9128
9129 if (pipe(fds) == -1)
9130 exit(1);
9131
9132 pid = fork();
9133 if (pid > 0) {
9134 uint8_t status;
9135 ssize_t len;
9136
9137 close(fds[1]);
9138
9139 again:
9140 len = read(fds[0], &status, 1);
9141 if (len == -1 && (errno == EINTR))
9142 goto again;
9143
9144 if (len != 1)
9145 exit(1);
9146 else if (status == 1) {
9147 fprintf(stderr, "Could not acquire pidfile\n");
9148 exit(1);
9149 } else
9150 exit(0);
9151 } else if (pid < 0)
9152 exit(1);
9153
9154 setsid();
9155
9156 pid = fork();
9157 if (pid > 0)
9158 exit(0);
9159 else if (pid < 0)
9160 exit(1);
9161
9162 umask(027);
9163
9164 signal(SIGTSTP, SIG_IGN);
9165 signal(SIGTTOU, SIG_IGN);
9166 signal(SIGTTIN, SIG_IGN);
9167 }
9168 #endif
9169
9170 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
9171 if (daemonize) {
9172 uint8_t status = 1;
9173 write(fds[1], &status, 1);
9174 } else
9175 fprintf(stderr, "Could not acquire pid file\n");
9176 exit(1);
9177 }
9178
9179 #ifdef USE_KQEMU
9180 if (smp_cpus > 1)
9181 kqemu_allowed = 0;
9182 #endif
9183 linux_boot = (kernel_filename != NULL);
9184 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
9185
9186 if (!linux_boot && net_boot == 0 &&
9187 !machine->nodisk_ok && nb_drives_opt == 0)
9188 help(1);
9189
9190 if (!linux_boot && *kernel_cmdline != '\0') {
9191 fprintf(stderr, "-append only allowed with -kernel option\n");
9192 exit(1);
9193 }
9194
9195 if (!linux_boot && initrd_filename != NULL) {
9196 fprintf(stderr, "-initrd only allowed with -kernel option\n");
9197 exit(1);
9198 }
9199
9200 /* boot to floppy or the default cd if no hard disk defined yet */
9201 if (!boot_devices[0]) {
9202 boot_devices = "cad";
9203 }
9204 setvbuf(stdout, NULL, _IOLBF, 0);
9205
9206 init_timers();
9207 init_timer_alarm();
9208 if (use_icount && icount_time_shift < 0) {
9209 use_icount = 2;
9210 /* 125MIPS seems a reasonable initial guess at the guest speed.
9211 It will be corrected fairly quickly anyway. */
9212 icount_time_shift = 3;
9213 init_icount_adjust();
9214 }
9215
9216 #ifdef _WIN32
9217 socket_init();
9218 #endif
9219
9220 /* init network clients */
9221 if (nb_net_clients == 0) {
9222 /* if no clients, we use a default config */
9223 net_clients[nb_net_clients++] = "nic";
9224 #ifdef CONFIG_SLIRP
9225 net_clients[nb_net_clients++] = "user";
9226 #endif
9227 }
9228
9229 for(i = 0;i < nb_net_clients; i++) {
9230 if (net_client_parse(net_clients[i]) < 0)
9231 exit(1);
9232 }
9233 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9234 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
9235 continue;
9236 if (vlan->nb_guest_devs == 0)
9237 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
9238 if (vlan->nb_host_devs == 0)
9239 fprintf(stderr,
9240 "Warning: vlan %d is not connected to host network\n",
9241 vlan->id);
9242 }
9243
9244 #ifdef TARGET_I386
9245 /* XXX: this should be moved in the PC machine instantiation code */
9246 if (net_boot != 0) {
9247 int netroms = 0;
9248 for (i = 0; i < nb_nics && i < 4; i++) {
9249 const char *model = nd_table[i].model;
9250 char buf[1024];
9251 if (net_boot & (1 << i)) {
9252 if (model == NULL)
9253 model = "ne2k_pci";
9254 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
9255 if (get_image_size(buf) > 0) {
9256 if (nb_option_roms >= MAX_OPTION_ROMS) {
9257 fprintf(stderr, "Too many option ROMs\n");
9258 exit(1);
9259 }
9260 option_rom[nb_option_roms] = strdup(buf);
9261 nb_option_roms++;
9262 netroms++;
9263 }
9264 }
9265 }
9266 if (netroms == 0) {
9267 fprintf(stderr, "No valid PXE rom found for network device\n");
9268 exit(1);
9269 }
9270 }
9271 #endif
9272
9273 /* init the memory */
9274 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
9275
9276 if (machine->ram_require & RAMSIZE_FIXED) {
9277 if (ram_size > 0) {
9278 if (ram_size < phys_ram_size) {
9279 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
9280 machine->name, (unsigned long long) phys_ram_size);
9281 exit(-1);
9282 }
9283
9284 phys_ram_size = ram_size;
9285 } else
9286 ram_size = phys_ram_size;
9287 } else {
9288 if (ram_size == 0)
9289 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
9290
9291 phys_ram_size += ram_size;
9292 }
9293
9294 phys_ram_base = qemu_vmalloc(phys_ram_size);
9295 if (!phys_ram_base) {
9296 fprintf(stderr, "Could not allocate physical memory\n");
9297 exit(1);
9298 }
9299
9300 /* init the dynamic translator */
9301 cpu_exec_init_all(tb_size * 1024 * 1024);
9302
9303 bdrv_init();
9304
9305 /* we always create the cdrom drive, even if no disk is there */
9306
9307 if (nb_drives_opt < MAX_DRIVES)
9308 drive_add(NULL, CDROM_ALIAS);
9309
9310 /* we always create at least one floppy */
9311
9312 if (nb_drives_opt < MAX_DRIVES)
9313 drive_add(NULL, FD_ALIAS, 0);
9314
9315 /* we always create one sd slot, even if no card is in it */
9316
9317 if (nb_drives_opt < MAX_DRIVES)
9318 drive_add(NULL, SD_ALIAS);
9319
9320 /* open the virtual block devices */
9321
9322 for(i = 0; i < nb_drives_opt; i++)
9323 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
9324 exit(1);
9325
9326 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
9327 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
9328
9329 /* terminal init */
9330 memset(&display_state, 0, sizeof(display_state));
9331 if (nographic) {
9332 if (curses) {
9333 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
9334 exit(1);
9335 }
9336 /* nearly nothing to do */
9337 dumb_display_init(ds);
9338 } else if (vnc_display != NULL) {
9339 vnc_display_init(ds);
9340 if (vnc_display_open(ds, vnc_display) < 0)
9341 exit(1);
9342 } else
9343 #if defined(CONFIG_CURSES)
9344 if (curses) {
9345 curses_display_init(ds, full_screen);
9346 } else
9347 #endif
9348 {
9349 #if defined(CONFIG_SDL)
9350 sdl_display_init(ds, full_screen, no_frame);
9351 #elif defined(CONFIG_COCOA)
9352 cocoa_display_init(ds, full_screen);
9353 #else
9354 dumb_display_init(ds);
9355 #endif
9356 }
9357
9358 #ifndef _WIN32
9359 /* must be after terminal init, SDL library changes signal handlers */
9360 termsig_setup();
9361 #endif
9362
9363 /* Maintain compatibility with multiple stdio monitors */
9364 if (!strcmp(monitor_device,"stdio")) {
9365 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
9366 const char *devname = serial_devices[i];
9367 if (devname && !strcmp(devname,"mon:stdio")) {
9368 monitor_device = NULL;
9369 break;
9370 } else if (devname && !strcmp(devname,"stdio")) {
9371 monitor_device = NULL;
9372 serial_devices[i] = "mon:stdio";
9373 break;
9374 }
9375 }
9376 }
9377 if (monitor_device) {
9378 monitor_hd = qemu_chr_open(monitor_device);
9379 if (!monitor_hd) {
9380 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
9381 exit(1);
9382 }
9383 monitor_init(monitor_hd, !nographic);
9384 }
9385
9386 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
9387 const char *devname = serial_devices[i];
9388 if (devname && strcmp(devname, "none")) {
9389 serial_hds[i] = qemu_chr_open(devname);
9390 if (!serial_hds[i]) {
9391 fprintf(stderr, "qemu: could not open serial device '%s'\n",
9392 devname);
9393 exit(1);
9394 }
9395 if (strstart(devname, "vc", 0))
9396 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
9397 }
9398 }
9399
9400 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
9401 const char *devname = parallel_devices[i];
9402 if (devname && strcmp(devname, "none")) {
9403 parallel_hds[i] = qemu_chr_open(devname);
9404 if (!parallel_hds[i]) {
9405 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
9406 devname);
9407 exit(1);
9408 }
9409 if (strstart(devname, "vc", 0))
9410 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
9411 }
9412 }
9413
9414 machine->init(ram_size, vga_ram_size, boot_devices, ds,
9415 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
9416
9417 /* init USB devices */
9418 if (usb_enabled) {
9419 for(i = 0; i < usb_devices_index; i++) {
9420 if (usb_device_add(usb_devices[i]) < 0) {
9421 fprintf(stderr, "Warning: could not add USB device %s\n",
9422 usb_devices[i]);
9423 }
9424 }
9425 }
9426
9427 if (display_state.dpy_refresh) {
9428 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
9429 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
9430 }
9431
9432 #ifdef CONFIG_GDBSTUB
9433 if (use_gdbstub) {
9434 /* XXX: use standard host:port notation and modify options
9435 accordingly. */
9436 if (gdbserver_start(gdbstub_port) < 0) {
9437 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
9438 gdbstub_port);
9439 exit(1);
9440 }
9441 }
9442 #endif
9443
9444 if (loadvm)
9445 do_loadvm(loadvm);
9446
9447 {
9448 /* XXX: simplify init */
9449 read_passwords();
9450 if (autostart) {
9451 vm_start();
9452 }
9453 }
9454
9455 if (daemonize) {
9456 uint8_t status = 0;
9457 ssize_t len;
9458 int fd;
9459
9460 again1:
9461 len = write(fds[1], &status, 1);
9462 if (len == -1 && (errno == EINTR))
9463 goto again1;
9464
9465 if (len != 1)
9466 exit(1);
9467
9468 chdir("/");
9469 TFR(fd = open("/dev/null", O_RDWR));
9470 if (fd == -1)
9471 exit(1);
9472
9473 dup2(fd, 0);
9474 dup2(fd, 1);
9475 dup2(fd, 2);
9476
9477 close(fd);
9478 }
9479
9480 main_loop();
9481 quit_timers();
9482
9483 #if !defined(_WIN32)
9484 /* close network clients */
9485 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9486 VLANClientState *vc;
9487
9488 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
9489 if (vc->fd_read == tap_receive) {
9490 char ifname[64];
9491 TAPState *s = vc->opaque;
9492
9493 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
9494 s->down_script[0])
9495 launch_script(s->down_script, ifname, s->fd);
9496 }
9497 #if defined(CONFIG_VDE)
9498 if (vc->fd_read == vde_from_qemu) {
9499 VDEState *s = vc->opaque;
9500 vde_close(s->vde);
9501 }
9502 #endif
9503 }
9504 }
9505 #endif
9506 return 0;
9507 }
Samsung s3c2440 and arm920t support for the mini2440 dev board