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