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