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