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