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