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