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