?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM GIC bug.
[qemu/mini2440.git] / vl.c
blobc30bb6b4d0c1576f961931390dbaa063b95cbe95
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2006 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 "vl.h"
25
26 #include <unistd.h>
27 #include <fcntl.h>
28 #include <signal.h>
29 #include <time.h>
30 #include <errno.h>
31 #include <sys/time.h>
32 #include <zlib.h>
33
34 #ifndef _WIN32
35 #include <sys/times.h>
36 #include <sys/wait.h>
37 #include <termios.h>
38 #include <sys/poll.h>
39 #include <sys/mman.h>
40 #include <sys/ioctl.h>
41 #include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <dirent.h>
44 #include <netdb.h>
45 #ifdef _BSD
46 #include <sys/stat.h>
47 #ifndef __APPLE__
48 #include <libutil.h>
49 #endif
50 #else
51 #ifndef __sun__
52 #include <linux/if.h>
53 #include <linux/if_tun.h>
54 #include <pty.h>
55 #include <malloc.h>
56 #include <linux/rtc.h>
57 #include <linux/ppdev.h>
58 #endif
59 #endif
60 #endif
61
62 #if defined(CONFIG_SLIRP)
63 #include "libslirp.h"
64 #endif
65
66 #ifdef _WIN32
67 #include <malloc.h>
68 #include <sys/timeb.h>
69 #include <windows.h>
70 #define getopt_long_only getopt_long
71 #define memalign(align, size) malloc(size)
72 #endif
73
74 #include "qemu_socket.h"
75
76 #ifdef CONFIG_SDL
77 #ifdef __APPLE__
78 #include <SDL/SDL.h>
79 #endif
80 #endif /* CONFIG_SDL */
81
82 #ifdef CONFIG_COCOA
83 #undef main
84 #define main qemu_main
85 #endif /* CONFIG_COCOA */
86
87 #include "disas.h"
88
89 #include "exec-all.h"
90
91 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
92
93 //#define DEBUG_UNUSED_IOPORT
94 //#define DEBUG_IOPORT
95
96 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
97
98 #ifdef TARGET_PPC
99 #define DEFAULT_RAM_SIZE 144
100 #else
101 #define DEFAULT_RAM_SIZE 128
102 #endif
103 /* in ms */
104 #define GUI_REFRESH_INTERVAL 30
105
106 /* Max number of USB devices that can be specified on the commandline. */
107 #define MAX_USB_CMDLINE 8
108
109 /* XXX: use a two level table to limit memory usage */
110 #define MAX_IOPORTS 65536
111
112 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
113 char phys_ram_file[1024];
114 void *ioport_opaque[MAX_IOPORTS];
115 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
116 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
117 /* Note: bs_table[MAX_DISKS] is a dummy block driver if none available
118 to store the VM snapshots */
119 BlockDriverState *bs_table[MAX_DISKS + 1], *fd_table[MAX_FD];
120 /* point to the block driver where the snapshots are managed */
121 BlockDriverState *bs_snapshots;
122 int vga_ram_size;
123 int bios_size;
124 static DisplayState display_state;
125 int nographic;
126 const char* keyboard_layout = NULL;
127 int64_t ticks_per_sec;
128 int boot_device = 'c';
129 int ram_size;
130 int pit_min_timer_count = 0;
131 int nb_nics;
132 NICInfo nd_table[MAX_NICS];
133 QEMUTimer *gui_timer;
134 int vm_running;
135 int rtc_utc = 1;
136 int cirrus_vga_enabled = 1;
137 #ifdef TARGET_SPARC
138 int graphic_width = 1024;
139 int graphic_height = 768;
140 #else
141 int graphic_width = 800;
142 int graphic_height = 600;
143 #endif
144 int graphic_depth = 15;
145 int full_screen = 0;
146 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
147 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
148 #ifdef TARGET_I386
149 int win2k_install_hack = 0;
150 #endif
151 int usb_enabled = 0;
152 static VLANState *first_vlan;
153 int smp_cpus = 1;
154 int vnc_display = -1;
155 #if defined(TARGET_SPARC)
156 #define MAX_CPUS 16
157 #elif defined(TARGET_I386)
158 #define MAX_CPUS 255
159 #else
160 #define MAX_CPUS 1
161 #endif
162 int acpi_enabled = 1;
163 int fd_bootchk = 1;
164
165 /***********************************************************/
166 /* x86 ISA bus support */
167
168 target_phys_addr_t isa_mem_base = 0;
169 PicState2 *isa_pic;
170
171 uint32_t default_ioport_readb(void *opaque, uint32_t address)
172 {
173 #ifdef DEBUG_UNUSED_IOPORT
174 fprintf(stderr, "inb: port=0x%04x\n", address);
175 #endif
176 return 0xff;
177 }
178
179 void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
180 {
181 #ifdef DEBUG_UNUSED_IOPORT
182 fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
183 #endif
184 }
185
186 /* default is to make two byte accesses */
187 uint32_t default_ioport_readw(void *opaque, uint32_t address)
188 {
189 uint32_t data;
190 data = ioport_read_table[0][address](ioport_opaque[address], address);
191 address = (address + 1) & (MAX_IOPORTS - 1);
192 data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
193 return data;
194 }
195
196 void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
197 {
198 ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
199 address = (address + 1) & (MAX_IOPORTS - 1);
200 ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
201 }
202
203 uint32_t default_ioport_readl(void *opaque, uint32_t address)
204 {
205 #ifdef DEBUG_UNUSED_IOPORT
206 fprintf(stderr, "inl: port=0x%04x\n", address);
207 #endif
208 return 0xffffffff;
209 }
210
211 void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
212 {
213 #ifdef DEBUG_UNUSED_IOPORT
214 fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
215 #endif
216 }
217
218 void init_ioports(void)
219 {
220 int i;
221
222 for(i = 0; i < MAX_IOPORTS; i++) {
223 ioport_read_table[0][i] = default_ioport_readb;
224 ioport_write_table[0][i] = default_ioport_writeb;
225 ioport_read_table[1][i] = default_ioport_readw;
226 ioport_write_table[1][i] = default_ioport_writew;
227 ioport_read_table[2][i] = default_ioport_readl;
228 ioport_write_table[2][i] = default_ioport_writel;
229 }
230 }
231
232 /* size is the word size in byte */
233 int register_ioport_read(int start, int length, int size,
234 IOPortReadFunc *func, void *opaque)
235 {
236 int i, bsize;
237
238 if (size == 1) {
239 bsize = 0;
240 } else if (size == 2) {
241 bsize = 1;
242 } else if (size == 4) {
243 bsize = 2;
244 } else {
245 hw_error("register_ioport_read: invalid size");
246 return -1;
247 }
248 for(i = start; i < start + length; i += size) {
249 ioport_read_table[bsize][i] = func;
250 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
251 hw_error("register_ioport_read: invalid opaque");
252 ioport_opaque[i] = opaque;
253 }
254 return 0;
255 }
256
257 /* size is the word size in byte */
258 int register_ioport_write(int start, int length, int size,
259 IOPortWriteFunc *func, void *opaque)
260 {
261 int i, bsize;
262
263 if (size == 1) {
264 bsize = 0;
265 } else if (size == 2) {
266 bsize = 1;
267 } else if (size == 4) {
268 bsize = 2;
269 } else {
270 hw_error("register_ioport_write: invalid size");
271 return -1;
272 }
273 for(i = start; i < start + length; i += size) {
274 ioport_write_table[bsize][i] = func;
275 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
276 hw_error("register_ioport_read: invalid opaque");
277 ioport_opaque[i] = opaque;
278 }
279 return 0;
280 }
281
282 void isa_unassign_ioport(int start, int length)
283 {
284 int i;
285
286 for(i = start; i < start + length; i++) {
287 ioport_read_table[0][i] = default_ioport_readb;
288 ioport_read_table[1][i] = default_ioport_readw;
289 ioport_read_table[2][i] = default_ioport_readl;
290
291 ioport_write_table[0][i] = default_ioport_writeb;
292 ioport_write_table[1][i] = default_ioport_writew;
293 ioport_write_table[2][i] = default_ioport_writel;
294 }
295 }
296
297 /***********************************************************/
298
299 void pstrcpy(char *buf, int buf_size, const char *str)
300 {
301 int c;
302 char *q = buf;
303
304 if (buf_size <= 0)
305 return;
306
307 for(;;) {
308 c = *str++;
309 if (c == 0 || q >= buf + buf_size - 1)
310 break;
311 *q++ = c;
312 }
313 *q = '\0';
314 }
315
316 /* strcat and truncate. */
317 char *pstrcat(char *buf, int buf_size, const char *s)
318 {
319 int len;
320 len = strlen(buf);
321 if (len < buf_size)
322 pstrcpy(buf + len, buf_size - len, s);
323 return buf;
324 }
325
326 int strstart(const char *str, const char *val, const char **ptr)
327 {
328 const char *p, *q;
329 p = str;
330 q = val;
331 while (*q != '\0') {
332 if (*p != *q)
333 return 0;
334 p++;
335 q++;
336 }
337 if (ptr)
338 *ptr = p;
339 return 1;
340 }
341
342 void cpu_outb(CPUState *env, int addr, int val)
343 {
344 #ifdef DEBUG_IOPORT
345 if (loglevel & CPU_LOG_IOPORT)
346 fprintf(logfile, "outb: %04x %02x\n", addr, val);
347 #endif
348 ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
349 #ifdef USE_KQEMU
350 if (env)
351 env->last_io_time = cpu_get_time_fast();
352 #endif
353 }
354
355 void cpu_outw(CPUState *env, int addr, int val)
356 {
357 #ifdef DEBUG_IOPORT
358 if (loglevel & CPU_LOG_IOPORT)
359 fprintf(logfile, "outw: %04x %04x\n", addr, val);
360 #endif
361 ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
362 #ifdef USE_KQEMU
363 if (env)
364 env->last_io_time = cpu_get_time_fast();
365 #endif
366 }
367
368 void cpu_outl(CPUState *env, int addr, int val)
369 {
370 #ifdef DEBUG_IOPORT
371 if (loglevel & CPU_LOG_IOPORT)
372 fprintf(logfile, "outl: %04x %08x\n", addr, val);
373 #endif
374 ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
375 #ifdef USE_KQEMU
376 if (env)
377 env->last_io_time = cpu_get_time_fast();
378 #endif
379 }
380
381 int cpu_inb(CPUState *env, int addr)
382 {
383 int val;
384 val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
385 #ifdef DEBUG_IOPORT
386 if (loglevel & CPU_LOG_IOPORT)
387 fprintf(logfile, "inb : %04x %02x\n", addr, val);
388 #endif
389 #ifdef USE_KQEMU
390 if (env)
391 env->last_io_time = cpu_get_time_fast();
392 #endif
393 return val;
394 }
395
396 int cpu_inw(CPUState *env, int addr)
397 {
398 int val;
399 val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
400 #ifdef DEBUG_IOPORT
401 if (loglevel & CPU_LOG_IOPORT)
402 fprintf(logfile, "inw : %04x %04x\n", addr, val);
403 #endif
404 #ifdef USE_KQEMU
405 if (env)
406 env->last_io_time = cpu_get_time_fast();
407 #endif
408 return val;
409 }
410
411 int cpu_inl(CPUState *env, int addr)
412 {
413 int val;
414 val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
415 #ifdef DEBUG_IOPORT
416 if (loglevel & CPU_LOG_IOPORT)
417 fprintf(logfile, "inl : %04x %08x\n", addr, val);
418 #endif
419 #ifdef USE_KQEMU
420 if (env)
421 env->last_io_time = cpu_get_time_fast();
422 #endif
423 return val;
424 }
425
426 /***********************************************************/
427 void hw_error(const char *fmt, ...)
428 {
429 va_list ap;
430 CPUState *env;
431
432 va_start(ap, fmt);
433 fprintf(stderr, "qemu: hardware error: ");
434 vfprintf(stderr, fmt, ap);
435 fprintf(stderr, "\n");
436 for(env = first_cpu; env != NULL; env = env->next_cpu) {
437 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
438 #ifdef TARGET_I386
439 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
440 #else
441 cpu_dump_state(env, stderr, fprintf, 0);
442 #endif
443 }
444 va_end(ap);
445 abort();
446 }
447
448 /***********************************************************/
449 /* keyboard/mouse */
450
451 static QEMUPutKBDEvent *qemu_put_kbd_event;
452 static void *qemu_put_kbd_event_opaque;
453 static QEMUPutMouseEvent *qemu_put_mouse_event;
454 static void *qemu_put_mouse_event_opaque;
455 static int qemu_put_mouse_event_absolute;
456
457 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
458 {
459 qemu_put_kbd_event_opaque = opaque;
460 qemu_put_kbd_event = func;
461 }
462
463 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque, int absolute)
464 {
465 qemu_put_mouse_event_opaque = opaque;
466 qemu_put_mouse_event = func;
467 qemu_put_mouse_event_absolute = absolute;
468 }
469
470 void kbd_put_keycode(int keycode)
471 {
472 if (qemu_put_kbd_event) {
473 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
474 }
475 }
476
477 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
478 {
479 if (qemu_put_mouse_event) {
480 qemu_put_mouse_event(qemu_put_mouse_event_opaque,
481 dx, dy, dz, buttons_state);
482 }
483 }
484
485 int kbd_mouse_is_absolute(void)
486 {
487 return qemu_put_mouse_event_absolute;
488 }
489
490 /* compute with 96 bit intermediate result: (a*b)/c */
491 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
492 {
493 union {
494 uint64_t ll;
495 struct {
496 #ifdef WORDS_BIGENDIAN
497 uint32_t high, low;
498 #else
499 uint32_t low, high;
500 #endif
501 } l;
502 } u, res;
503 uint64_t rl, rh;
504
505 u.ll = a;
506 rl = (uint64_t)u.l.low * (uint64_t)b;
507 rh = (uint64_t)u.l.high * (uint64_t)b;
508 rh += (rl >> 32);
509 res.l.high = rh / c;
510 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
511 return res.ll;
512 }
513
514 /***********************************************************/
515 /* real time host monotonic timer */
516
517 #define QEMU_TIMER_BASE 1000000000LL
518
519 #ifdef WIN32
520
521 static int64_t clock_freq;
522
523 static void init_get_clock(void)
524 {
525 LARGE_INTEGER freq;
526 int ret;
527 ret = QueryPerformanceFrequency(&freq);
528 if (ret == 0) {
529 fprintf(stderr, "Could not calibrate ticks\n");
530 exit(1);
531 }
532 clock_freq = freq.QuadPart;
533 }
534
535 static int64_t get_clock(void)
536 {
537 LARGE_INTEGER ti;
538 QueryPerformanceCounter(&ti);
539 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
540 }
541
542 #else
543
544 static int use_rt_clock;
545
546 static void init_get_clock(void)
547 {
548 use_rt_clock = 0;
549 #if defined(__linux__)
550 {
551 struct timespec ts;
552 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
553 use_rt_clock = 1;
554 }
555 }
556 #endif
557 }
558
559 static int64_t get_clock(void)
560 {
561 #if defined(__linux__)
562 if (use_rt_clock) {
563 struct timespec ts;
564 clock_gettime(CLOCK_MONOTONIC, &ts);
565 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
566 } else
567 #endif
568 {
569 /* XXX: using gettimeofday leads to problems if the date
570 changes, so it should be avoided. */
571 struct timeval tv;
572 gettimeofday(&tv, NULL);
573 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
574 }
575 }
576
577 #endif
578
579 /***********************************************************/
580 /* guest cycle counter */
581
582 static int64_t cpu_ticks_prev;
583 static int64_t cpu_ticks_offset;
584 static int64_t cpu_clock_offset;
585 static int cpu_ticks_enabled;
586
587 /* return the host CPU cycle counter and handle stop/restart */
588 int64_t cpu_get_ticks(void)
589 {
590 if (!cpu_ticks_enabled) {
591 return cpu_ticks_offset;
592 } else {
593 int64_t ticks;
594 ticks = cpu_get_real_ticks();
595 if (cpu_ticks_prev > ticks) {
596 /* Note: non increasing ticks may happen if the host uses
597 software suspend */
598 cpu_ticks_offset += cpu_ticks_prev - ticks;
599 }
600 cpu_ticks_prev = ticks;
601 return ticks + cpu_ticks_offset;
602 }
603 }
604
605 /* return the host CPU monotonic timer and handle stop/restart */
606 static int64_t cpu_get_clock(void)
607 {
608 int64_t ti;
609 if (!cpu_ticks_enabled) {
610 return cpu_clock_offset;
611 } else {
612 ti = get_clock();
613 return ti + cpu_clock_offset;
614 }
615 }
616
617 /* enable cpu_get_ticks() */
618 void cpu_enable_ticks(void)
619 {
620 if (!cpu_ticks_enabled) {
621 cpu_ticks_offset -= cpu_get_real_ticks();
622 cpu_clock_offset -= get_clock();
623 cpu_ticks_enabled = 1;
624 }
625 }
626
627 /* disable cpu_get_ticks() : the clock is stopped. You must not call
628 cpu_get_ticks() after that. */
629 void cpu_disable_ticks(void)
630 {
631 if (cpu_ticks_enabled) {
632 cpu_ticks_offset = cpu_get_ticks();
633 cpu_clock_offset = cpu_get_clock();
634 cpu_ticks_enabled = 0;
635 }
636 }
637
638 /***********************************************************/
639 /* timers */
640
641 #define QEMU_TIMER_REALTIME 0
642 #define QEMU_TIMER_VIRTUAL 1
643
644 struct QEMUClock {
645 int type;
646 /* XXX: add frequency */
647 };
648
649 struct QEMUTimer {
650 QEMUClock *clock;
651 int64_t expire_time;
652 QEMUTimerCB *cb;
653 void *opaque;
654 struct QEMUTimer *next;
655 };
656
657 QEMUClock *rt_clock;
658 QEMUClock *vm_clock;
659
660 static QEMUTimer *active_timers[2];
661 #ifdef _WIN32
662 static MMRESULT timerID;
663 static HANDLE host_alarm = NULL;
664 static unsigned int period = 1;
665 #else
666 /* frequency of the times() clock tick */
667 static int timer_freq;
668 #endif
669
670 QEMUClock *qemu_new_clock(int type)
671 {
672 QEMUClock *clock;
673 clock = qemu_mallocz(sizeof(QEMUClock));
674 if (!clock)
675 return NULL;
676 clock->type = type;
677 return clock;
678 }
679
680 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
681 {
682 QEMUTimer *ts;
683
684 ts = qemu_mallocz(sizeof(QEMUTimer));
685 ts->clock = clock;
686 ts->cb = cb;
687 ts->opaque = opaque;
688 return ts;
689 }
690
691 void qemu_free_timer(QEMUTimer *ts)
692 {
693 qemu_free(ts);
694 }
695
696 /* stop a timer, but do not dealloc it */
697 void qemu_del_timer(QEMUTimer *ts)
698 {
699 QEMUTimer **pt, *t;
700
701 /* NOTE: this code must be signal safe because
702 qemu_timer_expired() can be called from a signal. */
703 pt = &active_timers[ts->clock->type];
704 for(;;) {
705 t = *pt;
706 if (!t)
707 break;
708 if (t == ts) {
709 *pt = t->next;
710 break;
711 }
712 pt = &t->next;
713 }
714 }
715
716 /* modify the current timer so that it will be fired when current_time
717 >= expire_time. The corresponding callback will be called. */
718 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
719 {
720 QEMUTimer **pt, *t;
721
722 qemu_del_timer(ts);
723
724 /* add the timer in the sorted list */
725 /* NOTE: this code must be signal safe because
726 qemu_timer_expired() can be called from a signal. */
727 pt = &active_timers[ts->clock->type];
728 for(;;) {
729 t = *pt;
730 if (!t)
731 break;
732 if (t->expire_time > expire_time)
733 break;
734 pt = &t->next;
735 }
736 ts->expire_time = expire_time;
737 ts->next = *pt;
738 *pt = ts;
739 }
740
741 int qemu_timer_pending(QEMUTimer *ts)
742 {
743 QEMUTimer *t;
744 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
745 if (t == ts)
746 return 1;
747 }
748 return 0;
749 }
750
751 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
752 {
753 if (!timer_head)
754 return 0;
755 return (timer_head->expire_time <= current_time);
756 }
757
758 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
759 {
760 QEMUTimer *ts;
761
762 for(;;) {
763 ts = *ptimer_head;
764 if (!ts || ts->expire_time > current_time)
765 break;
766 /* remove timer from the list before calling the callback */
767 *ptimer_head = ts->next;
768 ts->next = NULL;
769
770 /* run the callback (the timer list can be modified) */
771 ts->cb(ts->opaque);
772 }
773 }
774
775 int64_t qemu_get_clock(QEMUClock *clock)
776 {
777 switch(clock->type) {
778 case QEMU_TIMER_REALTIME:
779 return get_clock() / 1000000;
780 default:
781 case QEMU_TIMER_VIRTUAL:
782 return cpu_get_clock();
783 }
784 }
785
786 static void init_timers(void)
787 {
788 init_get_clock();
789 ticks_per_sec = QEMU_TIMER_BASE;
790 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
791 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
792 }
793
794 /* save a timer */
795 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
796 {
797 uint64_t expire_time;
798
799 if (qemu_timer_pending(ts)) {
800 expire_time = ts->expire_time;
801 } else {
802 expire_time = -1;
803 }
804 qemu_put_be64(f, expire_time);
805 }
806
807 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
808 {
809 uint64_t expire_time;
810
811 expire_time = qemu_get_be64(f);
812 if (expire_time != -1) {
813 qemu_mod_timer(ts, expire_time);
814 } else {
815 qemu_del_timer(ts);
816 }
817 }
818
819 static void timer_save(QEMUFile *f, void *opaque)
820 {
821 if (cpu_ticks_enabled) {
822 hw_error("cannot save state if virtual timers are running");
823 }
824 qemu_put_be64s(f, &cpu_ticks_offset);
825 qemu_put_be64s(f, &ticks_per_sec);
826 qemu_put_be64s(f, &cpu_clock_offset);
827 }
828
829 static int timer_load(QEMUFile *f, void *opaque, int version_id)
830 {
831 if (version_id != 1 && version_id != 2)
832 return -EINVAL;
833 if (cpu_ticks_enabled) {
834 return -EINVAL;
835 }
836 qemu_get_be64s(f, &cpu_ticks_offset);
837 qemu_get_be64s(f, &ticks_per_sec);
838 if (version_id == 2) {
839 qemu_get_be64s(f, &cpu_clock_offset);
840 }
841 return 0;
842 }
843
844 #ifdef _WIN32
845 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
846 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
847 #else
848 static void host_alarm_handler(int host_signum)
849 #endif
850 {
851 #if 0
852 #define DISP_FREQ 1000
853 {
854 static int64_t delta_min = INT64_MAX;
855 static int64_t delta_max, delta_cum, last_clock, delta, ti;
856 static int count;
857 ti = qemu_get_clock(vm_clock);
858 if (last_clock != 0) {
859 delta = ti - last_clock;
860 if (delta < delta_min)
861 delta_min = delta;
862 if (delta > delta_max)
863 delta_max = delta;
864 delta_cum += delta;
865 if (++count == DISP_FREQ) {
866 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
867 muldiv64(delta_min, 1000000, ticks_per_sec),
868 muldiv64(delta_max, 1000000, ticks_per_sec),
869 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
870 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
871 count = 0;
872 delta_min = INT64_MAX;
873 delta_max = 0;
874 delta_cum = 0;
875 }
876 }
877 last_clock = ti;
878 }
879 #endif
880 if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
881 qemu_get_clock(vm_clock)) ||
882 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
883 qemu_get_clock(rt_clock))) {
884 #ifdef _WIN32
885 SetEvent(host_alarm);
886 #endif
887 CPUState *env = cpu_single_env;
888 if (env) {
889 /* stop the currently executing cpu because a timer occured */
890 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
891 #ifdef USE_KQEMU
892 if (env->kqemu_enabled) {
893 kqemu_cpu_interrupt(env);
894 }
895 #endif
896 }
897 }
898 }
899
900 #ifndef _WIN32
901
902 #if defined(__linux__)
903
904 #define RTC_FREQ 1024
905
906 static int rtc_fd;
907
908 static int start_rtc_timer(void)
909 {
910 rtc_fd = open("/dev/rtc", O_RDONLY);
911 if (rtc_fd < 0)
912 return -1;
913 if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
914 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
915 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
916 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
917 goto fail;
918 }
919 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
920 fail:
921 close(rtc_fd);
922 return -1;
923 }
924 pit_min_timer_count = PIT_FREQ / RTC_FREQ;
925 return 0;
926 }
927
928 #else
929
930 static int start_rtc_timer(void)
931 {
932 return -1;
933 }
934
935 #endif /* !defined(__linux__) */
936
937 #endif /* !defined(_WIN32) */
938
939 static void init_timer_alarm(void)
940 {
941 #ifdef _WIN32
942 {
943 int count=0;
944 TIMECAPS tc;
945
946 ZeroMemory(&tc, sizeof(TIMECAPS));
947 timeGetDevCaps(&tc, sizeof(TIMECAPS));
948 if (period < tc.wPeriodMin)
949 period = tc.wPeriodMin;
950 timeBeginPeriod(period);
951 timerID = timeSetEvent(1, // interval (ms)
952 period, // resolution
953 host_alarm_handler, // function
954 (DWORD)&count, // user parameter
955 TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
956 if( !timerID ) {
957 perror("failed timer alarm");
958 exit(1);
959 }
960 host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
961 if (!host_alarm) {
962 perror("failed CreateEvent");
963 exit(1);
964 }
965 qemu_add_wait_object(host_alarm, NULL, NULL);
966 }
967 pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
968 #else
969 {
970 struct sigaction act;
971 struct itimerval itv;
972
973 /* get times() syscall frequency */
974 timer_freq = sysconf(_SC_CLK_TCK);
975
976 /* timer signal */
977 sigfillset(&act.sa_mask);
978 act.sa_flags = 0;
979 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
980 act.sa_flags |= SA_ONSTACK;
981 #endif
982 act.sa_handler = host_alarm_handler;
983 sigaction(SIGALRM, &act, NULL);
984
985 itv.it_interval.tv_sec = 0;
986 itv.it_interval.tv_usec = 999; /* for i386 kernel 2.6 to get 1 ms */
987 itv.it_value.tv_sec = 0;
988 itv.it_value.tv_usec = 10 * 1000;
989 setitimer(ITIMER_REAL, &itv, NULL);
990 /* we probe the tick duration of the kernel to inform the user if
991 the emulated kernel requested a too high timer frequency */
992 getitimer(ITIMER_REAL, &itv);
993
994 #if defined(__linux__)
995 /* XXX: force /dev/rtc usage because even 2.6 kernels may not
996 have timers with 1 ms resolution. The correct solution will
997 be to use the POSIX real time timers available in recent
998 2.6 kernels */
999 if (itv.it_interval.tv_usec > 1000 || 1) {
1000 /* try to use /dev/rtc to have a faster timer */
1001 if (start_rtc_timer() < 0)
1002 goto use_itimer;
1003 /* disable itimer */
1004 itv.it_interval.tv_sec = 0;
1005 itv.it_interval.tv_usec = 0;
1006 itv.it_value.tv_sec = 0;
1007 itv.it_value.tv_usec = 0;
1008 setitimer(ITIMER_REAL, &itv, NULL);
1009
1010 /* use the RTC */
1011 sigaction(SIGIO, &act, NULL);
1012 fcntl(rtc_fd, F_SETFL, O_ASYNC);
1013 fcntl(rtc_fd, F_SETOWN, getpid());
1014 } else
1015 #endif /* defined(__linux__) */
1016 {
1017 use_itimer:
1018 pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec *
1019 PIT_FREQ) / 1000000;
1020 }
1021 }
1022 #endif
1023 }
1024
1025 void quit_timers(void)
1026 {
1027 #ifdef _WIN32
1028 timeKillEvent(timerID);
1029 timeEndPeriod(period);
1030 if (host_alarm) {
1031 CloseHandle(host_alarm);
1032 host_alarm = NULL;
1033 }
1034 #endif
1035 }
1036
1037 /***********************************************************/
1038 /* character device */
1039
1040 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1041 {
1042 return s->chr_write(s, buf, len);
1043 }
1044
1045 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1046 {
1047 if (!s->chr_ioctl)
1048 return -ENOTSUP;
1049 return s->chr_ioctl(s, cmd, arg);
1050 }
1051
1052 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1053 {
1054 char buf[4096];
1055 va_list ap;
1056 va_start(ap, fmt);
1057 vsnprintf(buf, sizeof(buf), fmt, ap);
1058 qemu_chr_write(s, buf, strlen(buf));
1059 va_end(ap);
1060 }
1061
1062 void qemu_chr_send_event(CharDriverState *s, int event)
1063 {
1064 if (s->chr_send_event)
1065 s->chr_send_event(s, event);
1066 }
1067
1068 void qemu_chr_add_read_handler(CharDriverState *s,
1069 IOCanRWHandler *fd_can_read,
1070 IOReadHandler *fd_read, void *opaque)
1071 {
1072 s->chr_add_read_handler(s, fd_can_read, fd_read, opaque);
1073 }
1074
1075 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event)
1076 {
1077 s->chr_event = chr_event;
1078 }
1079
1080 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1081 {
1082 return len;
1083 }
1084
1085 static void null_chr_add_read_handler(CharDriverState *chr,
1086 IOCanRWHandler *fd_can_read,
1087 IOReadHandler *fd_read, void *opaque)
1088 {
1089 }
1090
1091 CharDriverState *qemu_chr_open_null(void)
1092 {
1093 CharDriverState *chr;
1094
1095 chr = qemu_mallocz(sizeof(CharDriverState));
1096 if (!chr)
1097 return NULL;
1098 chr->chr_write = null_chr_write;
1099 chr->chr_add_read_handler = null_chr_add_read_handler;
1100 return chr;
1101 }
1102
1103 #ifdef _WIN32
1104
1105 static void socket_cleanup(void)
1106 {
1107 WSACleanup();
1108 }
1109
1110 static int socket_init(void)
1111 {
1112 WSADATA Data;
1113 int ret, err;
1114
1115 ret = WSAStartup(MAKEWORD(2,2), &Data);
1116 if (ret != 0) {
1117 err = WSAGetLastError();
1118 fprintf(stderr, "WSAStartup: %d\n", err);
1119 return -1;
1120 }
1121 atexit(socket_cleanup);
1122 return 0;
1123 }
1124
1125 static int send_all(int fd, const uint8_t *buf, int len1)
1126 {
1127 int ret, len;
1128
1129 len = len1;
1130 while (len > 0) {
1131 ret = send(fd, buf, len, 0);
1132 if (ret < 0) {
1133 int errno;
1134 errno = WSAGetLastError();
1135 if (errno != WSAEWOULDBLOCK) {
1136 return -1;
1137 }
1138 } else if (ret == 0) {
1139 break;
1140 } else {
1141 buf += ret;
1142 len -= ret;
1143 }
1144 }
1145 return len1 - len;
1146 }
1147
1148 void socket_set_nonblock(int fd)
1149 {
1150 unsigned long opt = 1;
1151 ioctlsocket(fd, FIONBIO, &opt);
1152 }
1153
1154 #else
1155
1156 static int unix_write(int fd, const uint8_t *buf, int len1)
1157 {
1158 int ret, len;
1159
1160 len = len1;
1161 while (len > 0) {
1162 ret = write(fd, buf, len);
1163 if (ret < 0) {
1164 if (errno != EINTR && errno != EAGAIN)
1165 return -1;
1166 } else if (ret == 0) {
1167 break;
1168 } else {
1169 buf += ret;
1170 len -= ret;
1171 }
1172 }
1173 return len1 - len;
1174 }
1175
1176 static inline int send_all(int fd, const uint8_t *buf, int len1)
1177 {
1178 return unix_write(fd, buf, len1);
1179 }
1180
1181 void socket_set_nonblock(int fd)
1182 {
1183 fcntl(fd, F_SETFL, O_NONBLOCK);
1184 }
1185 #endif /* !_WIN32 */
1186
1187 #ifndef _WIN32
1188
1189 typedef struct {
1190 int fd_in, fd_out;
1191 IOCanRWHandler *fd_can_read;
1192 IOReadHandler *fd_read;
1193 void *fd_opaque;
1194 int max_size;
1195 } FDCharDriver;
1196
1197 #define STDIO_MAX_CLIENTS 2
1198
1199 static int stdio_nb_clients;
1200 static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1201
1202 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1203 {
1204 FDCharDriver *s = chr->opaque;
1205 return unix_write(s->fd_out, buf, len);
1206 }
1207
1208 static int fd_chr_read_poll(void *opaque)
1209 {
1210 CharDriverState *chr = opaque;
1211 FDCharDriver *s = chr->opaque;
1212
1213 s->max_size = s->fd_can_read(s->fd_opaque);
1214 return s->max_size;
1215 }
1216
1217 static void fd_chr_read(void *opaque)
1218 {
1219 CharDriverState *chr = opaque;
1220 FDCharDriver *s = chr->opaque;
1221 int size, len;
1222 uint8_t buf[1024];
1223
1224 len = sizeof(buf);
1225 if (len > s->max_size)
1226 len = s->max_size;
1227 if (len == 0)
1228 return;
1229 size = read(s->fd_in, buf, len);
1230 if (size > 0) {
1231 s->fd_read(s->fd_opaque, buf, size);
1232 }
1233 }
1234
1235 static void fd_chr_add_read_handler(CharDriverState *chr,
1236 IOCanRWHandler *fd_can_read,
1237 IOReadHandler *fd_read, void *opaque)
1238 {
1239 FDCharDriver *s = chr->opaque;
1240
1241 if (s->fd_in >= 0) {
1242 s->fd_can_read = fd_can_read;
1243 s->fd_read = fd_read;
1244 s->fd_opaque = opaque;
1245 if (nographic && s->fd_in == 0) {
1246 } else {
1247 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
1248 fd_chr_read, NULL, chr);
1249 }
1250 }
1251 }
1252
1253 /* open a character device to a unix fd */
1254 CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1255 {
1256 CharDriverState *chr;
1257 FDCharDriver *s;
1258
1259 chr = qemu_mallocz(sizeof(CharDriverState));
1260 if (!chr)
1261 return NULL;
1262 s = qemu_mallocz(sizeof(FDCharDriver));
1263 if (!s) {
1264 free(chr);
1265 return NULL;
1266 }
1267 s->fd_in = fd_in;
1268 s->fd_out = fd_out;
1269 chr->opaque = s;
1270 chr->chr_write = fd_chr_write;
1271 chr->chr_add_read_handler = fd_chr_add_read_handler;
1272 return chr;
1273 }
1274
1275 CharDriverState *qemu_chr_open_file_out(const char *file_out)
1276 {
1277 int fd_out;
1278
1279 fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666);
1280 if (fd_out < 0)
1281 return NULL;
1282 return qemu_chr_open_fd(-1, fd_out);
1283 }
1284
1285 CharDriverState *qemu_chr_open_pipe(const char *filename)
1286 {
1287 int fd;
1288
1289 fd = open(filename, O_RDWR | O_BINARY);
1290 if (fd < 0)
1291 return NULL;
1292 return qemu_chr_open_fd(fd, fd);
1293 }
1294
1295
1296 /* for STDIO, we handle the case where several clients use it
1297 (nographic mode) */
1298
1299 #define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */
1300
1301 #define TERM_FIFO_MAX_SIZE 1
1302
1303 static int term_got_escape, client_index;
1304 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
1305 static int term_fifo_size;
1306 static int term_timestamps;
1307 static int64_t term_timestamps_start;
1308
1309 void term_print_help(void)
1310 {
1311 printf("\n"
1312 "C-a h print this help\n"
1313 "C-a x exit emulator\n"
1314 "C-a s save disk data back to file (if -snapshot)\n"
1315 "C-a b send break (magic sysrq)\n"
1316 "C-a t toggle console timestamps\n"
1317 "C-a c switch between console and monitor\n"
1318 "C-a C-a send C-a\n"
1319 );
1320 }
1321
1322 /* called when a char is received */
1323 static void stdio_received_byte(int ch)
1324 {
1325 if (term_got_escape) {
1326 term_got_escape = 0;
1327 switch(ch) {
1328 case 'h':
1329 term_print_help();
1330 break;
1331 case 'x':
1332 exit(0);
1333 break;
1334 case 's':
1335 {
1336 int i;
1337 for (i = 0; i < MAX_DISKS; i++) {
1338 if (bs_table[i])
1339 bdrv_commit(bs_table[i]);
1340 }
1341 }
1342 break;
1343 case 'b':
1344 if (client_index < stdio_nb_clients) {
1345 CharDriverState *chr;
1346 FDCharDriver *s;
1347
1348 chr = stdio_clients[client_index];
1349 s = chr->opaque;
1350 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
1351 }
1352 break;
1353 case 'c':
1354 client_index++;
1355 if (client_index >= stdio_nb_clients)
1356 client_index = 0;
1357 if (client_index == 0) {
1358 /* send a new line in the monitor to get the prompt */
1359 ch = '\r';
1360 goto send_char;
1361 }
1362 break;
1363 case 't':
1364 term_timestamps = !term_timestamps;
1365 term_timestamps_start = -1;
1366 break;
1367 case TERM_ESCAPE:
1368 goto send_char;
1369 }
1370 } else if (ch == TERM_ESCAPE) {
1371 term_got_escape = 1;
1372 } else {
1373 send_char:
1374 if (client_index < stdio_nb_clients) {
1375 uint8_t buf[1];
1376 CharDriverState *chr;
1377 FDCharDriver *s;
1378
1379 chr = stdio_clients[client_index];
1380 s = chr->opaque;
1381 if (s->fd_can_read(s->fd_opaque) > 0) {
1382 buf[0] = ch;
1383 s->fd_read(s->fd_opaque, buf, 1);
1384 } else if (term_fifo_size == 0) {
1385 term_fifo[term_fifo_size++] = ch;
1386 }
1387 }
1388 }
1389 }
1390
1391 static int stdio_read_poll(void *opaque)
1392 {
1393 CharDriverState *chr;
1394 FDCharDriver *s;
1395
1396 if (client_index < stdio_nb_clients) {
1397 chr = stdio_clients[client_index];
1398 s = chr->opaque;
1399 /* try to flush the queue if needed */
1400 if (term_fifo_size != 0 && s->fd_can_read(s->fd_opaque) > 0) {
1401 s->fd_read(s->fd_opaque, term_fifo, 1);
1402 term_fifo_size = 0;
1403 }
1404 /* see if we can absorb more chars */
1405 if (term_fifo_size == 0)
1406 return 1;
1407 else
1408 return 0;
1409 } else {
1410 return 1;
1411 }
1412 }
1413
1414 static void stdio_read(void *opaque)
1415 {
1416 int size;
1417 uint8_t buf[1];
1418
1419 size = read(0, buf, 1);
1420 if (size == 0) {
1421 /* stdin has been closed. Remove it from the active list. */
1422 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
1423 return;
1424 }
1425 if (size > 0)
1426 stdio_received_byte(buf[0]);
1427 }
1428
1429 static int stdio_write(CharDriverState *chr, const uint8_t *buf, int len)
1430 {
1431 FDCharDriver *s = chr->opaque;
1432 if (!term_timestamps) {
1433 return unix_write(s->fd_out, buf, len);
1434 } else {
1435 int i;
1436 char buf1[64];
1437
1438 for(i = 0; i < len; i++) {
1439 unix_write(s->fd_out, buf + i, 1);
1440 if (buf[i] == '\n') {
1441 int64_t ti;
1442 int secs;
1443
1444 ti = get_clock();
1445 if (term_timestamps_start == -1)
1446 term_timestamps_start = ti;
1447 ti -= term_timestamps_start;
1448 secs = ti / 1000000000;
1449 snprintf(buf1, sizeof(buf1),
1450 "[%02d:%02d:%02d.%03d] ",
1451 secs / 3600,
1452 (secs / 60) % 60,
1453 secs % 60,
1454 (int)((ti / 1000000) % 1000));
1455 unix_write(s->fd_out, buf1, strlen(buf1));
1456 }
1457 }
1458 return len;
1459 }
1460 }
1461
1462 /* init terminal so that we can grab keys */
1463 static struct termios oldtty;
1464 static int old_fd0_flags;
1465
1466 static void term_exit(void)
1467 {
1468 tcsetattr (0, TCSANOW, &oldtty);
1469 fcntl(0, F_SETFL, old_fd0_flags);
1470 }
1471
1472 static void term_init(void)
1473 {
1474 struct termios tty;
1475
1476 tcgetattr (0, &tty);
1477 oldtty = tty;
1478 old_fd0_flags = fcntl(0, F_GETFL);
1479
1480 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1481 |INLCR|IGNCR|ICRNL|IXON);
1482 tty.c_oflag |= OPOST;
1483 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1484 /* if graphical mode, we allow Ctrl-C handling */
1485 if (nographic)
1486 tty.c_lflag &= ~ISIG;
1487 tty.c_cflag &= ~(CSIZE|PARENB);
1488 tty.c_cflag |= CS8;
1489 tty.c_cc[VMIN] = 1;
1490 tty.c_cc[VTIME] = 0;
1491
1492 tcsetattr (0, TCSANOW, &tty);
1493
1494 atexit(term_exit);
1495
1496 fcntl(0, F_SETFL, O_NONBLOCK);
1497 }
1498
1499 CharDriverState *qemu_chr_open_stdio(void)
1500 {
1501 CharDriverState *chr;
1502
1503 if (nographic) {
1504 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
1505 return NULL;
1506 chr = qemu_chr_open_fd(0, 1);
1507 chr->chr_write = stdio_write;
1508 if (stdio_nb_clients == 0)
1509 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, NULL);
1510 client_index = stdio_nb_clients;
1511 } else {
1512 if (stdio_nb_clients != 0)
1513 return NULL;
1514 chr = qemu_chr_open_fd(0, 1);
1515 }
1516 stdio_clients[stdio_nb_clients++] = chr;
1517 if (stdio_nb_clients == 1) {
1518 /* set the terminal in raw mode */
1519 term_init();
1520 }
1521 return chr;
1522 }
1523
1524 #if defined(__linux__)
1525 CharDriverState *qemu_chr_open_pty(void)
1526 {
1527 struct termios tty;
1528 char slave_name[1024];
1529 int master_fd, slave_fd;
1530
1531 /* Not satisfying */
1532 if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
1533 return NULL;
1534 }
1535
1536 /* Disabling local echo and line-buffered output */
1537 tcgetattr (master_fd, &tty);
1538 tty.c_lflag &= ~(ECHO|ICANON|ISIG);
1539 tty.c_cc[VMIN] = 1;
1540 tty.c_cc[VTIME] = 0;
1541 tcsetattr (master_fd, TCSAFLUSH, &tty);
1542
1543 fprintf(stderr, "char device redirected to %s\n", slave_name);
1544 return qemu_chr_open_fd(master_fd, master_fd);
1545 }
1546
1547 static void tty_serial_init(int fd, int speed,
1548 int parity, int data_bits, int stop_bits)
1549 {
1550 struct termios tty;
1551 speed_t spd;
1552
1553 #if 0
1554 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1555 speed, parity, data_bits, stop_bits);
1556 #endif
1557 tcgetattr (fd, &tty);
1558
1559 switch(speed) {
1560 case 50:
1561 spd = B50;
1562 break;
1563 case 75:
1564 spd = B75;
1565 break;
1566 case 300:
1567 spd = B300;
1568 break;
1569 case 600:
1570 spd = B600;
1571 break;
1572 case 1200:
1573 spd = B1200;
1574 break;
1575 case 2400:
1576 spd = B2400;
1577 break;
1578 case 4800:
1579 spd = B4800;
1580 break;
1581 case 9600:
1582 spd = B9600;
1583 break;
1584 case 19200:
1585 spd = B19200;
1586 break;
1587 case 38400:
1588 spd = B38400;
1589 break;
1590 case 57600:
1591 spd = B57600;
1592 break;
1593 default:
1594 case 115200:
1595 spd = B115200;
1596 break;
1597 }
1598
1599 cfsetispeed(&tty, spd);
1600 cfsetospeed(&tty, spd);
1601
1602 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1603 |INLCR|IGNCR|ICRNL|IXON);
1604 tty.c_oflag |= OPOST;
1605 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1606 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
1607 switch(data_bits) {
1608 default:
1609 case 8:
1610 tty.c_cflag |= CS8;
1611 break;
1612 case 7:
1613 tty.c_cflag |= CS7;
1614 break;
1615 case 6:
1616 tty.c_cflag |= CS6;
1617 break;
1618 case 5:
1619 tty.c_cflag |= CS5;
1620 break;
1621 }
1622 switch(parity) {
1623 default:
1624 case 'N':
1625 break;
1626 case 'E':
1627 tty.c_cflag |= PARENB;
1628 break;
1629 case 'O':
1630 tty.c_cflag |= PARENB | PARODD;
1631 break;
1632 }
1633 if (stop_bits == 2)
1634 tty.c_cflag |= CSTOPB;
1635
1636 tcsetattr (fd, TCSANOW, &tty);
1637 }
1638
1639 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1640 {
1641 FDCharDriver *s = chr->opaque;
1642
1643 switch(cmd) {
1644 case CHR_IOCTL_SERIAL_SET_PARAMS:
1645 {
1646 QEMUSerialSetParams *ssp = arg;
1647 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1648 ssp->data_bits, ssp->stop_bits);
1649 }
1650 break;
1651 case CHR_IOCTL_SERIAL_SET_BREAK:
1652 {
1653 int enable = *(int *)arg;
1654 if (enable)
1655 tcsendbreak(s->fd_in, 1);
1656 }
1657 break;
1658 default:
1659 return -ENOTSUP;
1660 }
1661 return 0;
1662 }
1663
1664 CharDriverState *qemu_chr_open_tty(const char *filename)
1665 {
1666 CharDriverState *chr;
1667 int fd;
1668
1669 fd = open(filename, O_RDWR | O_NONBLOCK);
1670 if (fd < 0)
1671 return NULL;
1672 fcntl(fd, F_SETFL, O_NONBLOCK);
1673 tty_serial_init(fd, 115200, 'N', 8, 1);
1674 chr = qemu_chr_open_fd(fd, fd);
1675 if (!chr)
1676 return NULL;
1677 chr->chr_ioctl = tty_serial_ioctl;
1678 return chr;
1679 }
1680
1681 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1682 {
1683 int fd = (int)chr->opaque;
1684 uint8_t b;
1685
1686 switch(cmd) {
1687 case CHR_IOCTL_PP_READ_DATA:
1688 if (ioctl(fd, PPRDATA, &b) < 0)
1689 return -ENOTSUP;
1690 *(uint8_t *)arg = b;
1691 break;
1692 case CHR_IOCTL_PP_WRITE_DATA:
1693 b = *(uint8_t *)arg;
1694 if (ioctl(fd, PPWDATA, &b) < 0)
1695 return -ENOTSUP;
1696 break;
1697 case CHR_IOCTL_PP_READ_CONTROL:
1698 if (ioctl(fd, PPRCONTROL, &b) < 0)
1699 return -ENOTSUP;
1700 *(uint8_t *)arg = b;
1701 break;
1702 case CHR_IOCTL_PP_WRITE_CONTROL:
1703 b = *(uint8_t *)arg;
1704 if (ioctl(fd, PPWCONTROL, &b) < 0)
1705 return -ENOTSUP;
1706 break;
1707 case CHR_IOCTL_PP_READ_STATUS:
1708 if (ioctl(fd, PPRSTATUS, &b) < 0)
1709 return -ENOTSUP;
1710 *(uint8_t *)arg = b;
1711 break;
1712 default:
1713 return -ENOTSUP;
1714 }
1715 return 0;
1716 }
1717
1718 CharDriverState *qemu_chr_open_pp(const char *filename)
1719 {
1720 CharDriverState *chr;
1721 int fd;
1722
1723 fd = open(filename, O_RDWR);
1724 if (fd < 0)
1725 return NULL;
1726
1727 if (ioctl(fd, PPCLAIM) < 0) {
1728 close(fd);
1729 return NULL;
1730 }
1731
1732 chr = qemu_mallocz(sizeof(CharDriverState));
1733 if (!chr) {
1734 close(fd);
1735 return NULL;
1736 }
1737 chr->opaque = (void *)fd;
1738 chr->chr_write = null_chr_write;
1739 chr->chr_add_read_handler = null_chr_add_read_handler;
1740 chr->chr_ioctl = pp_ioctl;
1741 return chr;
1742 }
1743
1744 #else
1745 CharDriverState *qemu_chr_open_pty(void)
1746 {
1747 return NULL;
1748 }
1749 #endif
1750
1751 #endif /* !defined(_WIN32) */
1752
1753 #ifdef _WIN32
1754 typedef struct {
1755 IOCanRWHandler *fd_can_read;
1756 IOReadHandler *fd_read;
1757 void *win_opaque;
1758 int max_size;
1759 HANDLE hcom, hrecv, hsend;
1760 OVERLAPPED orecv, osend;
1761 BOOL fpipe;
1762 DWORD len;
1763 } WinCharState;
1764
1765 #define NSENDBUF 2048
1766 #define NRECVBUF 2048
1767 #define MAXCONNECT 1
1768 #define NTIMEOUT 5000
1769
1770 static int win_chr_poll(void *opaque);
1771 static int win_chr_pipe_poll(void *opaque);
1772
1773 static void win_chr_close2(WinCharState *s)
1774 {
1775 if (s->hsend) {
1776 CloseHandle(s->hsend);
1777 s->hsend = NULL;
1778 }
1779 if (s->hrecv) {
1780 CloseHandle(s->hrecv);
1781 s->hrecv = NULL;
1782 }
1783 if (s->hcom) {
1784 CloseHandle(s->hcom);
1785 s->hcom = NULL;
1786 }
1787 if (s->fpipe)
1788 qemu_del_polling_cb(win_chr_pipe_poll, s);
1789 else
1790 qemu_del_polling_cb(win_chr_poll, s);
1791 }
1792
1793 static void win_chr_close(CharDriverState *chr)
1794 {
1795 WinCharState *s = chr->opaque;
1796 win_chr_close2(s);
1797 }
1798
1799 static int win_chr_init(WinCharState *s, const char *filename)
1800 {
1801 COMMCONFIG comcfg;
1802 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
1803 COMSTAT comstat;
1804 DWORD size;
1805 DWORD err;
1806
1807 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1808 if (!s->hsend) {
1809 fprintf(stderr, "Failed CreateEvent\n");
1810 goto fail;
1811 }
1812 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1813 if (!s->hrecv) {
1814 fprintf(stderr, "Failed CreateEvent\n");
1815 goto fail;
1816 }
1817
1818 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
1819 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
1820 if (s->hcom == INVALID_HANDLE_VALUE) {
1821 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
1822 s->hcom = NULL;
1823 goto fail;
1824 }
1825
1826 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
1827 fprintf(stderr, "Failed SetupComm\n");
1828 goto fail;
1829 }
1830
1831 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
1832 size = sizeof(COMMCONFIG);
1833 GetDefaultCommConfig(filename, &comcfg, &size);
1834 comcfg.dcb.DCBlength = sizeof(DCB);
1835 CommConfigDialog(filename, NULL, &comcfg);
1836
1837 if (!SetCommState(s->hcom, &comcfg.dcb)) {
1838 fprintf(stderr, "Failed SetCommState\n");
1839 goto fail;
1840 }
1841
1842 if (!SetCommMask(s->hcom, EV_ERR)) {
1843 fprintf(stderr, "Failed SetCommMask\n");
1844 goto fail;
1845 }
1846
1847 cto.ReadIntervalTimeout = MAXDWORD;
1848 if (!SetCommTimeouts(s->hcom, &cto)) {
1849 fprintf(stderr, "Failed SetCommTimeouts\n");
1850 goto fail;
1851 }
1852
1853 if (!ClearCommError(s->hcom, &err, &comstat)) {
1854 fprintf(stderr, "Failed ClearCommError\n");
1855 goto fail;
1856 }
1857 qemu_add_polling_cb(win_chr_poll, s);
1858 return 0;
1859
1860 fail:
1861 win_chr_close2(s);
1862 return -1;
1863 }
1864
1865 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1866 {
1867 WinCharState *s = chr->opaque;
1868 DWORD len, ret, size, err;
1869
1870 len = len1;
1871 ZeroMemory(&s->osend, sizeof(s->osend));
1872 s->osend.hEvent = s->hsend;
1873 while (len > 0) {
1874 if (s->hsend)
1875 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
1876 else
1877 ret = WriteFile(s->hcom, buf, len, &size, NULL);
1878 if (!ret) {
1879 err = GetLastError();
1880 if (err == ERROR_IO_PENDING) {
1881 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
1882 if (ret) {
1883 buf += size;
1884 len -= size;
1885 } else {
1886 break;
1887 }
1888 } else {
1889 break;
1890 }
1891 } else {
1892 buf += size;
1893 len -= size;
1894 }
1895 }
1896 return len1 - len;
1897 }
1898
1899 static int win_chr_read_poll(WinCharState *s)
1900 {
1901 s->max_size = s->fd_can_read(s->win_opaque);
1902 return s->max_size;
1903 }
1904
1905 static void win_chr_readfile(WinCharState *s)
1906 {
1907 int ret, err;
1908 uint8_t buf[1024];
1909 DWORD size;
1910
1911 ZeroMemory(&s->orecv, sizeof(s->orecv));
1912 s->orecv.hEvent = s->hrecv;
1913 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
1914 if (!ret) {
1915 err = GetLastError();
1916 if (err == ERROR_IO_PENDING) {
1917 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
1918 }
1919 }
1920
1921 if (size > 0) {
1922 s->fd_read(s->win_opaque, buf, size);
1923 }
1924 }
1925
1926 static void win_chr_read(WinCharState *s)
1927 {
1928 if (s->len > s->max_size)
1929 s->len = s->max_size;
1930 if (s->len == 0)
1931 return;
1932
1933 win_chr_readfile(s);
1934 }
1935
1936 static int win_chr_poll(void *opaque)
1937 {
1938 WinCharState *s = opaque;
1939 COMSTAT status;
1940 DWORD comerr;
1941
1942 ClearCommError(s->hcom, &comerr, &status);
1943 if (status.cbInQue > 0) {
1944 s->len = status.cbInQue;
1945 win_chr_read_poll(s);
1946 win_chr_read(s);
1947 return 1;
1948 }
1949 return 0;
1950 }
1951
1952 static void win_chr_add_read_handler(CharDriverState *chr,
1953 IOCanRWHandler *fd_can_read,
1954 IOReadHandler *fd_read, void *opaque)
1955 {
1956 WinCharState *s = chr->opaque;
1957
1958 s->fd_can_read = fd_can_read;
1959 s->fd_read = fd_read;
1960 s->win_opaque = opaque;
1961 }
1962
1963 CharDriverState *qemu_chr_open_win(const char *filename)
1964 {
1965 CharDriverState *chr;
1966 WinCharState *s;
1967
1968 chr = qemu_mallocz(sizeof(CharDriverState));
1969 if (!chr)
1970 return NULL;
1971 s = qemu_mallocz(sizeof(WinCharState));
1972 if (!s) {
1973 free(chr);
1974 return NULL;
1975 }
1976 chr->opaque = s;
1977 chr->chr_write = win_chr_write;
1978 chr->chr_add_read_handler = win_chr_add_read_handler;
1979 chr->chr_close = win_chr_close;
1980
1981 if (win_chr_init(s, filename) < 0) {
1982 free(s);
1983 free(chr);
1984 return NULL;
1985 }
1986 return chr;
1987 }
1988
1989 static int win_chr_pipe_poll(void *opaque)
1990 {
1991 WinCharState *s = opaque;
1992 DWORD size;
1993
1994 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
1995 if (size > 0) {
1996 s->len = size;
1997 win_chr_read_poll(s);
1998 win_chr_read(s);
1999 return 1;
2000 }
2001 return 0;
2002 }
2003
2004 static int win_chr_pipe_init(WinCharState *s, const char *filename)
2005 {
2006 OVERLAPPED ov;
2007 int ret;
2008 DWORD size;
2009 char openname[256];
2010
2011 s->fpipe = TRUE;
2012
2013 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2014 if (!s->hsend) {
2015 fprintf(stderr, "Failed CreateEvent\n");
2016 goto fail;
2017 }
2018 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2019 if (!s->hrecv) {
2020 fprintf(stderr, "Failed CreateEvent\n");
2021 goto fail;
2022 }
2023
2024 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2025 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2026 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2027 PIPE_WAIT,
2028 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2029 if (s->hcom == INVALID_HANDLE_VALUE) {
2030 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2031 s->hcom = NULL;
2032 goto fail;
2033 }
2034
2035 ZeroMemory(&ov, sizeof(ov));
2036 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2037 ret = ConnectNamedPipe(s->hcom, &ov);
2038 if (ret) {
2039 fprintf(stderr, "Failed ConnectNamedPipe\n");
2040 goto fail;
2041 }
2042
2043 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2044 if (!ret) {
2045 fprintf(stderr, "Failed GetOverlappedResult\n");
2046 if (ov.hEvent) {
2047 CloseHandle(ov.hEvent);
2048 ov.hEvent = NULL;
2049 }
2050 goto fail;
2051 }
2052
2053 if (ov.hEvent) {
2054 CloseHandle(ov.hEvent);
2055 ov.hEvent = NULL;
2056 }
2057 qemu_add_polling_cb(win_chr_pipe_poll, s);
2058 return 0;
2059
2060 fail:
2061 win_chr_close2(s);
2062 return -1;
2063 }
2064
2065
2066 CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2067 {
2068 CharDriverState *chr;
2069 WinCharState *s;
2070
2071 chr = qemu_mallocz(sizeof(CharDriverState));
2072 if (!chr)
2073 return NULL;
2074 s = qemu_mallocz(sizeof(WinCharState));
2075 if (!s) {
2076 free(chr);
2077 return NULL;
2078 }
2079 chr->opaque = s;
2080 chr->chr_write = win_chr_write;
2081 chr->chr_add_read_handler = win_chr_add_read_handler;
2082 chr->chr_close = win_chr_close;
2083
2084 if (win_chr_pipe_init(s, filename) < 0) {
2085 free(s);
2086 free(chr);
2087 return NULL;
2088 }
2089 return chr;
2090 }
2091
2092 CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2093 {
2094 CharDriverState *chr;
2095 WinCharState *s;
2096
2097 chr = qemu_mallocz(sizeof(CharDriverState));
2098 if (!chr)
2099 return NULL;
2100 s = qemu_mallocz(sizeof(WinCharState));
2101 if (!s) {
2102 free(chr);
2103 return NULL;
2104 }
2105 s->hcom = fd_out;
2106 chr->opaque = s;
2107 chr->chr_write = win_chr_write;
2108 chr->chr_add_read_handler = win_chr_add_read_handler;
2109 return chr;
2110 }
2111
2112 CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2113 {
2114 HANDLE fd_out;
2115
2116 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2117 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2118 if (fd_out == INVALID_HANDLE_VALUE)
2119 return NULL;
2120
2121 return qemu_chr_open_win_file(fd_out);
2122 }
2123 #endif
2124
2125 /***********************************************************/
2126 /* UDP Net console */
2127
2128 typedef struct {
2129 IOCanRWHandler *fd_can_read;
2130 IOReadHandler *fd_read;
2131 void *fd_opaque;
2132 int fd;
2133 struct sockaddr_in daddr;
2134 char buf[1024];
2135 int bufcnt;
2136 int bufptr;
2137 int max_size;
2138 } NetCharDriver;
2139
2140 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2141 {
2142 NetCharDriver *s = chr->opaque;
2143
2144 return sendto(s->fd, buf, len, 0,
2145 (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2146 }
2147
2148 static int udp_chr_read_poll(void *opaque)
2149 {
2150 CharDriverState *chr = opaque;
2151 NetCharDriver *s = chr->opaque;
2152
2153 s->max_size = s->fd_can_read(s->fd_opaque);
2154
2155 /* If there were any stray characters in the queue process them
2156 * first
2157 */
2158 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2159 s->fd_read(s->fd_opaque, &s->buf[s->bufptr], 1);
2160 s->bufptr++;
2161 s->max_size = s->fd_can_read(s->fd_opaque);
2162 }
2163 return s->max_size;
2164 }
2165
2166 static void udp_chr_read(void *opaque)
2167 {
2168 CharDriverState *chr = opaque;
2169 NetCharDriver *s = chr->opaque;
2170
2171 if (s->max_size == 0)
2172 return;
2173 s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2174 s->bufptr = s->bufcnt;
2175 if (s->bufcnt <= 0)
2176 return;
2177
2178 s->bufptr = 0;
2179 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2180 s->fd_read(s->fd_opaque, &s->buf[s->bufptr], 1);
2181 s->bufptr++;
2182 s->max_size = s->fd_can_read(s->fd_opaque);
2183 }
2184 }
2185
2186 static void udp_chr_add_read_handler(CharDriverState *chr,
2187 IOCanRWHandler *fd_can_read,
2188 IOReadHandler *fd_read, void *opaque)
2189 {
2190 NetCharDriver *s = chr->opaque;
2191
2192 if (s->fd >= 0) {
2193 s->fd_can_read = fd_can_read;
2194 s->fd_read = fd_read;
2195 s->fd_opaque = opaque;
2196 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2197 udp_chr_read, NULL, chr);
2198 }
2199 }
2200
2201 int parse_host_port(struct sockaddr_in *saddr, const char *str);
2202 int parse_host_src_port(struct sockaddr_in *haddr,
2203 struct sockaddr_in *saddr,
2204 const char *str);
2205
2206 CharDriverState *qemu_chr_open_udp(const char *def)
2207 {
2208 CharDriverState *chr = NULL;
2209 NetCharDriver *s = NULL;
2210 int fd = -1;
2211 struct sockaddr_in saddr;
2212
2213 chr = qemu_mallocz(sizeof(CharDriverState));
2214 if (!chr)
2215 goto return_err;
2216 s = qemu_mallocz(sizeof(NetCharDriver));
2217 if (!s)
2218 goto return_err;
2219
2220 fd = socket(PF_INET, SOCK_DGRAM, 0);
2221 if (fd < 0) {
2222 perror("socket(PF_INET, SOCK_DGRAM)");
2223 goto return_err;
2224 }
2225
2226 if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
2227 printf("Could not parse: %s\n", def);
2228 goto return_err;
2229 }
2230
2231 if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
2232 {
2233 perror("bind");
2234 goto return_err;
2235 }
2236
2237 s->fd = fd;
2238 s->bufcnt = 0;
2239 s->bufptr = 0;
2240 chr->opaque = s;
2241 chr->chr_write = udp_chr_write;
2242 chr->chr_add_read_handler = udp_chr_add_read_handler;
2243 return chr;
2244
2245 return_err:
2246 if (chr)
2247 free(chr);
2248 if (s)
2249 free(s);
2250 if (fd >= 0)
2251 closesocket(fd);
2252 return NULL;
2253 }
2254
2255 /***********************************************************/
2256 /* TCP Net console */
2257
2258 typedef struct {
2259 IOCanRWHandler *fd_can_read;
2260 IOReadHandler *fd_read;
2261 void *fd_opaque;
2262 int fd, listen_fd;
2263 int connected;
2264 int max_size;
2265 int do_telnetopt;
2266 } TCPCharDriver;
2267
2268 static void tcp_chr_accept(void *opaque);
2269
2270 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2271 {
2272 TCPCharDriver *s = chr->opaque;
2273 if (s->connected) {
2274 return send_all(s->fd, buf, len);
2275 } else {
2276 /* XXX: indicate an error ? */
2277 return len;
2278 }
2279 }
2280
2281 static int tcp_chr_read_poll(void *opaque)
2282 {
2283 CharDriverState *chr = opaque;
2284 TCPCharDriver *s = chr->opaque;
2285 if (!s->connected)
2286 return 0;
2287 s->max_size = s->fd_can_read(s->fd_opaque);
2288 return s->max_size;
2289 }
2290
2291 #define IAC 255
2292 #define IAC_BREAK 243
2293 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
2294 TCPCharDriver *s,
2295 char *buf, int *size)
2296 {
2297 /* Handle any telnet client's basic IAC options to satisfy char by
2298 * char mode with no echo. All IAC options will be removed from
2299 * the buf and the do_telnetopt variable will be used to track the
2300 * state of the width of the IAC information.
2301 *
2302 * IAC commands come in sets of 3 bytes with the exception of the
2303 * "IAC BREAK" command and the double IAC.
2304 */
2305
2306 int i;
2307 int j = 0;
2308
2309 for (i = 0; i < *size; i++) {
2310 if (s->do_telnetopt > 1) {
2311 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
2312 /* Double IAC means send an IAC */
2313 if (j != i)
2314 buf[j] = buf[i];
2315 j++;
2316 s->do_telnetopt = 1;
2317 } else {
2318 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
2319 /* Handle IAC break commands by sending a serial break */
2320 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
2321 s->do_telnetopt++;
2322 }
2323 s->do_telnetopt++;
2324 }
2325 if (s->do_telnetopt >= 4) {
2326 s->do_telnetopt = 1;
2327 }
2328 } else {
2329 if ((unsigned char)buf[i] == IAC) {
2330 s->do_telnetopt = 2;
2331 } else {
2332 if (j != i)
2333 buf[j] = buf[i];
2334 j++;
2335 }
2336 }
2337 }
2338 *size = j;
2339 }
2340
2341 static void tcp_chr_read(void *opaque)
2342 {
2343 CharDriverState *chr = opaque;
2344 TCPCharDriver *s = chr->opaque;
2345 uint8_t buf[1024];
2346 int len, size;
2347
2348 if (!s->connected || s->max_size <= 0)
2349 return;
2350 len = sizeof(buf);
2351 if (len > s->max_size)
2352 len = s->max_size;
2353 size = recv(s->fd, buf, len, 0);
2354 if (size == 0) {
2355 /* connection closed */
2356 s->connected = 0;
2357 if (s->listen_fd >= 0) {
2358 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2359 }
2360 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2361 closesocket(s->fd);
2362 s->fd = -1;
2363 } else if (size > 0) {
2364 if (s->do_telnetopt)
2365 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
2366 if (size > 0)
2367 s->fd_read(s->fd_opaque, buf, size);
2368 }
2369 }
2370
2371 static void tcp_chr_add_read_handler(CharDriverState *chr,
2372 IOCanRWHandler *fd_can_read,
2373 IOReadHandler *fd_read, void *opaque)
2374 {
2375 TCPCharDriver *s = chr->opaque;
2376
2377 s->fd_can_read = fd_can_read;
2378 s->fd_read = fd_read;
2379 s->fd_opaque = opaque;
2380 }
2381
2382 static void tcp_chr_connect(void *opaque)
2383 {
2384 CharDriverState *chr = opaque;
2385 TCPCharDriver *s = chr->opaque;
2386
2387 s->connected = 1;
2388 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
2389 tcp_chr_read, NULL, chr);
2390 }
2391
2392 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
2393 static void tcp_chr_telnet_init(int fd)
2394 {
2395 char buf[3];
2396 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
2397 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
2398 send(fd, (char *)buf, 3, 0);
2399 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
2400 send(fd, (char *)buf, 3, 0);
2401 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
2402 send(fd, (char *)buf, 3, 0);
2403 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
2404 send(fd, (char *)buf, 3, 0);
2405 }
2406
2407 static void tcp_chr_accept(void *opaque)
2408 {
2409 CharDriverState *chr = opaque;
2410 TCPCharDriver *s = chr->opaque;
2411 struct sockaddr_in saddr;
2412 socklen_t len;
2413 int fd;
2414
2415 for(;;) {
2416 len = sizeof(saddr);
2417 fd = accept(s->listen_fd, (struct sockaddr *)&saddr, &len);
2418 if (fd < 0 && errno != EINTR) {
2419 return;
2420 } else if (fd >= 0) {
2421 if (s->do_telnetopt)
2422 tcp_chr_telnet_init(fd);
2423 break;
2424 }
2425 }
2426 socket_set_nonblock(fd);
2427 s->fd = fd;
2428 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
2429 tcp_chr_connect(chr);
2430 }
2431
2432 static void tcp_chr_close(CharDriverState *chr)
2433 {
2434 TCPCharDriver *s = chr->opaque;
2435 if (s->fd >= 0)
2436 closesocket(s->fd);
2437 if (s->listen_fd >= 0)
2438 closesocket(s->listen_fd);
2439 qemu_free(s);
2440 }
2441
2442 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
2443 int is_telnet)
2444 {
2445 CharDriverState *chr = NULL;
2446 TCPCharDriver *s = NULL;
2447 int fd = -1, ret, err, val;
2448 int is_listen = 0;
2449 int is_waitconnect = 1;
2450 const char *ptr;
2451 struct sockaddr_in saddr;
2452
2453 if (parse_host_port(&saddr, host_str) < 0)
2454 goto fail;
2455
2456 ptr = host_str;
2457 while((ptr = strchr(ptr,','))) {
2458 ptr++;
2459 if (!strncmp(ptr,"server",6)) {
2460 is_listen = 1;
2461 } else if (!strncmp(ptr,"nowait",6)) {
2462 is_waitconnect = 0;
2463 } else {
2464 printf("Unknown option: %s\n", ptr);
2465 goto fail;
2466 }
2467 }
2468 if (!is_listen)
2469 is_waitconnect = 0;
2470
2471 chr = qemu_mallocz(sizeof(CharDriverState));
2472 if (!chr)
2473 goto fail;
2474 s = qemu_mallocz(sizeof(TCPCharDriver));
2475 if (!s)
2476 goto fail;
2477
2478 fd = socket(PF_INET, SOCK_STREAM, 0);
2479 if (fd < 0)
2480 goto fail;
2481
2482 if (!is_waitconnect)
2483 socket_set_nonblock(fd);
2484
2485 s->connected = 0;
2486 s->fd = -1;
2487 s->listen_fd = -1;
2488 if (is_listen) {
2489 /* allow fast reuse */
2490 val = 1;
2491 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2492
2493 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2494 if (ret < 0)
2495 goto fail;
2496 ret = listen(fd, 0);
2497 if (ret < 0)
2498 goto fail;
2499 s->listen_fd = fd;
2500 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2501 if (is_telnet)
2502 s->do_telnetopt = 1;
2503 } else {
2504 for(;;) {
2505 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2506 if (ret < 0) {
2507 err = socket_error();
2508 if (err == EINTR || err == EWOULDBLOCK) {
2509 } else if (err == EINPROGRESS) {
2510 break;
2511 } else {
2512 goto fail;
2513 }
2514 } else {
2515 s->connected = 1;
2516 break;
2517 }
2518 }
2519 s->fd = fd;
2520 if (s->connected)
2521 tcp_chr_connect(chr);
2522 else
2523 qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
2524 }
2525
2526 chr->opaque = s;
2527 chr->chr_write = tcp_chr_write;
2528 chr->chr_add_read_handler = tcp_chr_add_read_handler;
2529 chr->chr_close = tcp_chr_close;
2530 if (is_listen && is_waitconnect) {
2531 printf("QEMU waiting for connection on: %s\n", host_str);
2532 tcp_chr_accept(chr);
2533 socket_set_nonblock(s->listen_fd);
2534 }
2535
2536 return chr;
2537 fail:
2538 if (fd >= 0)
2539 closesocket(fd);
2540 qemu_free(s);
2541 qemu_free(chr);
2542 return NULL;
2543 }
2544
2545 CharDriverState *qemu_chr_open(const char *filename)
2546 {
2547 const char *p;
2548
2549 if (!strcmp(filename, "vc")) {
2550 return text_console_init(&display_state);
2551 } else if (!strcmp(filename, "null")) {
2552 return qemu_chr_open_null();
2553 } else
2554 if (strstart(filename, "tcp:", &p)) {
2555 return qemu_chr_open_tcp(p, 0);
2556 } else
2557 if (strstart(filename, "telnet:", &p)) {
2558 return qemu_chr_open_tcp(p, 1);
2559 } else
2560 if (strstart(filename, "udp:", &p)) {
2561 return qemu_chr_open_udp(p);
2562 } else
2563 #ifndef _WIN32
2564 if (strstart(filename, "file:", &p)) {
2565 return qemu_chr_open_file_out(p);
2566 } else if (strstart(filename, "pipe:", &p)) {
2567 return qemu_chr_open_pipe(p);
2568 } else if (!strcmp(filename, "pty")) {
2569 return qemu_chr_open_pty();
2570 } else if (!strcmp(filename, "stdio")) {
2571 return qemu_chr_open_stdio();
2572 } else
2573 #endif
2574 #if defined(__linux__)
2575 if (strstart(filename, "/dev/parport", NULL)) {
2576 return qemu_chr_open_pp(filename);
2577 } else
2578 if (strstart(filename, "/dev/", NULL)) {
2579 return qemu_chr_open_tty(filename);
2580 } else
2581 #endif
2582 #ifdef _WIN32
2583 if (strstart(filename, "COM", NULL)) {
2584 return qemu_chr_open_win(filename);
2585 } else
2586 if (strstart(filename, "pipe:", &p)) {
2587 return qemu_chr_open_win_pipe(p);
2588 } else
2589 if (strstart(filename, "file:", &p)) {
2590 return qemu_chr_open_win_file_out(p);
2591 }
2592 #endif
2593 {
2594 return NULL;
2595 }
2596 }
2597
2598 void qemu_chr_close(CharDriverState *chr)
2599 {
2600 if (chr->chr_close)
2601 chr->chr_close(chr);
2602 }
2603
2604 /***********************************************************/
2605 /* network device redirectors */
2606
2607 void hex_dump(FILE *f, const uint8_t *buf, int size)
2608 {
2609 int len, i, j, c;
2610
2611 for(i=0;i<size;i+=16) {
2612 len = size - i;
2613 if (len > 16)
2614 len = 16;
2615 fprintf(f, "%08x ", i);
2616 for(j=0;j<16;j++) {
2617 if (j < len)
2618 fprintf(f, " %02x", buf[i+j]);
2619 else
2620 fprintf(f, " ");
2621 }
2622 fprintf(f, " ");
2623 for(j=0;j<len;j++) {
2624 c = buf[i+j];
2625 if (c < ' ' || c > '~')
2626 c = '.';
2627 fprintf(f, "%c", c);
2628 }
2629 fprintf(f, "\n");
2630 }
2631 }
2632
2633 static int parse_macaddr(uint8_t *macaddr, const char *p)
2634 {
2635 int i;
2636 for(i = 0; i < 6; i++) {
2637 macaddr[i] = strtol(p, (char **)&p, 16);
2638 if (i == 5) {
2639 if (*p != '\0')
2640 return -1;
2641 } else {
2642 if (*p != ':')
2643 return -1;
2644 p++;
2645 }
2646 }
2647 return 0;
2648 }
2649
2650 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
2651 {
2652 const char *p, *p1;
2653 int len;
2654 p = *pp;
2655 p1 = strchr(p, sep);
2656 if (!p1)
2657 return -1;
2658 len = p1 - p;
2659 p1++;
2660 if (buf_size > 0) {
2661 if (len > buf_size - 1)
2662 len = buf_size - 1;
2663 memcpy(buf, p, len);
2664 buf[len] = '\0';
2665 }
2666 *pp = p1;
2667 return 0;
2668 }
2669
2670 int parse_host_src_port(struct sockaddr_in *haddr,
2671 struct sockaddr_in *saddr,
2672 const char *input_str)
2673 {
2674 char *str = strdup(input_str);
2675 char *host_str = str;
2676 char *src_str;
2677 char *ptr;
2678
2679 /*
2680 * Chop off any extra arguments at the end of the string which
2681 * would start with a comma, then fill in the src port information
2682 * if it was provided else use the "any address" and "any port".
2683 */
2684 if ((ptr = strchr(str,',')))
2685 *ptr = '\0';
2686
2687 if ((src_str = strchr(input_str,'@'))) {
2688 *src_str = '\0';
2689 src_str++;
2690 }
2691
2692 if (parse_host_port(haddr, host_str) < 0)
2693 goto fail;
2694
2695 if (!src_str || *src_str == '\0')
2696 src_str = ":0";
2697
2698 if (parse_host_port(saddr, src_str) < 0)
2699 goto fail;
2700
2701 free(str);
2702 return(0);
2703
2704 fail:
2705 free(str);
2706 return -1;
2707 }
2708
2709 int parse_host_port(struct sockaddr_in *saddr, const char *str)
2710 {
2711 char buf[512];
2712 struct hostent *he;
2713 const char *p, *r;
2714 int port;
2715
2716 p = str;
2717 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2718 return -1;
2719 saddr->sin_family = AF_INET;
2720 if (buf[0] == '\0') {
2721 saddr->sin_addr.s_addr = 0;
2722 } else {
2723 if (isdigit(buf[0])) {
2724 if (!inet_aton(buf, &saddr->sin_addr))
2725 return -1;
2726 } else {
2727 if ((he = gethostbyname(buf)) == NULL)
2728 return - 1;
2729 saddr->sin_addr = *(struct in_addr *)he->h_addr;
2730 }
2731 }
2732 port = strtol(p, (char **)&r, 0);
2733 if (r == p)
2734 return -1;
2735 saddr->sin_port = htons(port);
2736 return 0;
2737 }
2738
2739 /* find or alloc a new VLAN */
2740 VLANState *qemu_find_vlan(int id)
2741 {
2742 VLANState **pvlan, *vlan;
2743 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
2744 if (vlan->id == id)
2745 return vlan;
2746 }
2747 vlan = qemu_mallocz(sizeof(VLANState));
2748 if (!vlan)
2749 return NULL;
2750 vlan->id = id;
2751 vlan->next = NULL;
2752 pvlan = &first_vlan;
2753 while (*pvlan != NULL)
2754 pvlan = &(*pvlan)->next;
2755 *pvlan = vlan;
2756 return vlan;
2757 }
2758
2759 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
2760 IOReadHandler *fd_read,
2761 IOCanRWHandler *fd_can_read,
2762 void *opaque)
2763 {
2764 VLANClientState *vc, **pvc;
2765 vc = qemu_mallocz(sizeof(VLANClientState));
2766 if (!vc)
2767 return NULL;
2768 vc->fd_read = fd_read;
2769 vc->fd_can_read = fd_can_read;
2770 vc->opaque = opaque;
2771 vc->vlan = vlan;
2772
2773 vc->next = NULL;
2774 pvc = &vlan->first_client;
2775 while (*pvc != NULL)
2776 pvc = &(*pvc)->next;
2777 *pvc = vc;
2778 return vc;
2779 }
2780
2781 int qemu_can_send_packet(VLANClientState *vc1)
2782 {
2783 VLANState *vlan = vc1->vlan;
2784 VLANClientState *vc;
2785
2786 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
2787 if (vc != vc1) {
2788 if (vc->fd_can_read && !vc->fd_can_read(vc->opaque))
2789 return 0;
2790 }
2791 }
2792 return 1;
2793 }
2794
2795 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
2796 {
2797 VLANState *vlan = vc1->vlan;
2798 VLANClientState *vc;
2799
2800 #if 0
2801 printf("vlan %d send:\n", vlan->id);
2802 hex_dump(stdout, buf, size);
2803 #endif
2804 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
2805 if (vc != vc1) {
2806 vc->fd_read(vc->opaque, buf, size);
2807 }
2808 }
2809 }
2810
2811 #if defined(CONFIG_SLIRP)
2812
2813 /* slirp network adapter */
2814
2815 static int slirp_inited;
2816 static VLANClientState *slirp_vc;
2817
2818 int slirp_can_output(void)
2819 {
2820 return !slirp_vc || qemu_can_send_packet(slirp_vc);
2821 }
2822
2823 void slirp_output(const uint8_t *pkt, int pkt_len)
2824 {
2825 #if 0
2826 printf("slirp output:\n");
2827 hex_dump(stdout, pkt, pkt_len);
2828 #endif
2829 if (!slirp_vc)
2830 return;
2831 qemu_send_packet(slirp_vc, pkt, pkt_len);
2832 }
2833
2834 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
2835 {
2836 #if 0
2837 printf("slirp input:\n");
2838 hex_dump(stdout, buf, size);
2839 #endif
2840 slirp_input(buf, size);
2841 }
2842
2843 static int net_slirp_init(VLANState *vlan)
2844 {
2845 if (!slirp_inited) {
2846 slirp_inited = 1;
2847 slirp_init();
2848 }
2849 slirp_vc = qemu_new_vlan_client(vlan,
2850 slirp_receive, NULL, NULL);
2851 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
2852 return 0;
2853 }
2854
2855 static void net_slirp_redir(const char *redir_str)
2856 {
2857 int is_udp;
2858 char buf[256], *r;
2859 const char *p;
2860 struct in_addr guest_addr;
2861 int host_port, guest_port;
2862
2863 if (!slirp_inited) {
2864 slirp_inited = 1;
2865 slirp_init();
2866 }
2867
2868 p = redir_str;
2869 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2870 goto fail;
2871 if (!strcmp(buf, "tcp")) {
2872 is_udp = 0;
2873 } else if (!strcmp(buf, "udp")) {
2874 is_udp = 1;
2875 } else {
2876 goto fail;
2877 }
2878
2879 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2880 goto fail;
2881 host_port = strtol(buf, &r, 0);
2882 if (r == buf)
2883 goto fail;
2884
2885 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2886 goto fail;
2887 if (buf[0] == '\0') {
2888 pstrcpy(buf, sizeof(buf), "10.0.2.15");
2889 }
2890 if (!inet_aton(buf, &guest_addr))
2891 goto fail;
2892
2893 guest_port = strtol(p, &r, 0);
2894 if (r == p)
2895 goto fail;
2896
2897 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
2898 fprintf(stderr, "qemu: could not set up redirection\n");
2899 exit(1);
2900 }
2901 return;
2902 fail:
2903 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
2904 exit(1);
2905 }
2906
2907 #ifndef _WIN32
2908
2909 char smb_dir[1024];
2910
2911 static void smb_exit(void)
2912 {
2913 DIR *d;
2914 struct dirent *de;
2915 char filename[1024];
2916
2917 /* erase all the files in the directory */
2918 d = opendir(smb_dir);
2919 for(;;) {
2920 de = readdir(d);
2921 if (!de)
2922 break;
2923 if (strcmp(de->d_name, ".") != 0 &&
2924 strcmp(de->d_name, "..") != 0) {
2925 snprintf(filename, sizeof(filename), "%s/%s",
2926 smb_dir, de->d_name);
2927 unlink(filename);
2928 }
2929 }
2930 closedir(d);
2931 rmdir(smb_dir);
2932 }
2933
2934 /* automatic user mode samba server configuration */
2935 void net_slirp_smb(const char *exported_dir)
2936 {
2937 char smb_conf[1024];
2938 char smb_cmdline[1024];
2939 FILE *f;
2940
2941 if (!slirp_inited) {
2942 slirp_inited = 1;
2943 slirp_init();
2944 }
2945
2946 /* XXX: better tmp dir construction */
2947 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
2948 if (mkdir(smb_dir, 0700) < 0) {
2949 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
2950 exit(1);
2951 }
2952 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
2953
2954 f = fopen(smb_conf, "w");
2955 if (!f) {
2956 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
2957 exit(1);
2958 }
2959 fprintf(f,
2960 "[global]\n"
2961 "private dir=%s\n"
2962 "smb ports=0\n"
2963 "socket address=127.0.0.1\n"
2964 "pid directory=%s\n"
2965 "lock directory=%s\n"
2966 "log file=%s/log.smbd\n"
2967 "smb passwd file=%s/smbpasswd\n"
2968 "security = share\n"
2969 "[qemu]\n"
2970 "path=%s\n"
2971 "read only=no\n"
2972 "guest ok=yes\n",
2973 smb_dir,
2974 smb_dir,
2975 smb_dir,
2976 smb_dir,
2977 smb_dir,
2978 exported_dir
2979 );
2980 fclose(f);
2981 atexit(smb_exit);
2982
2983 snprintf(smb_cmdline, sizeof(smb_cmdline), "/usr/sbin/smbd -s %s",
2984 smb_conf);
2985
2986 slirp_add_exec(0, smb_cmdline, 4, 139);
2987 }
2988
2989 #endif /* !defined(_WIN32) */
2990
2991 #endif /* CONFIG_SLIRP */
2992
2993 #if !defined(_WIN32)
2994
2995 typedef struct TAPState {
2996 VLANClientState *vc;
2997 int fd;
2998 } TAPState;
2999
3000 static void tap_receive(void *opaque, const uint8_t *buf, int size)
3001 {
3002 TAPState *s = opaque;
3003 int ret;
3004 for(;;) {
3005 ret = write(s->fd, buf, size);
3006 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3007 } else {
3008 break;
3009 }
3010 }
3011 }
3012
3013 static void tap_send(void *opaque)
3014 {
3015 TAPState *s = opaque;
3016 uint8_t buf[4096];
3017 int size;
3018
3019 size = read(s->fd, buf, sizeof(buf));
3020 if (size > 0) {
3021 qemu_send_packet(s->vc, buf, size);
3022 }
3023 }
3024
3025 /* fd support */
3026
3027 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3028 {
3029 TAPState *s;
3030
3031 s = qemu_mallocz(sizeof(TAPState));
3032 if (!s)
3033 return NULL;
3034 s->fd = fd;
3035 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3036 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3037 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3038 return s;
3039 }
3040
3041 #ifdef _BSD
3042 static int tap_open(char *ifname, int ifname_size)
3043 {
3044 int fd;
3045 char *dev;
3046 struct stat s;
3047
3048 fd = open("/dev/tap", O_RDWR);
3049 if (fd < 0) {
3050 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
3051 return -1;
3052 }
3053
3054 fstat(fd, &s);
3055 dev = devname(s.st_rdev, S_IFCHR);
3056 pstrcpy(ifname, ifname_size, dev);
3057
3058 fcntl(fd, F_SETFL, O_NONBLOCK);
3059 return fd;
3060 }
3061 #elif defined(__sun__)
3062 static int tap_open(char *ifname, int ifname_size)
3063 {
3064 fprintf(stderr, "warning: tap_open not yet implemented\n");
3065 return -1;
3066 }
3067 #else
3068 static int tap_open(char *ifname, int ifname_size)
3069 {
3070 struct ifreq ifr;
3071 int fd, ret;
3072
3073 fd = open("/dev/net/tun", O_RDWR);
3074 if (fd < 0) {
3075 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
3076 return -1;
3077 }
3078 memset(&ifr, 0, sizeof(ifr));
3079 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
3080 if (ifname[0] != '\0')
3081 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
3082 else
3083 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
3084 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
3085 if (ret != 0) {
3086 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
3087 close(fd);
3088 return -1;
3089 }
3090 pstrcpy(ifname, ifname_size, ifr.ifr_name);
3091 fcntl(fd, F_SETFL, O_NONBLOCK);
3092 return fd;
3093 }
3094 #endif
3095
3096 static int net_tap_init(VLANState *vlan, const char *ifname1,
3097 const char *setup_script)
3098 {
3099 TAPState *s;
3100 int pid, status, fd;
3101 char *args[3];
3102 char **parg;
3103 char ifname[128];
3104
3105 if (ifname1 != NULL)
3106 pstrcpy(ifname, sizeof(ifname), ifname1);
3107 else
3108 ifname[0] = '\0';
3109 fd = tap_open(ifname, sizeof(ifname));
3110 if (fd < 0)
3111 return -1;
3112
3113 if (!setup_script)
3114 setup_script = "";
3115 if (setup_script[0] != '\0') {
3116 /* try to launch network init script */
3117 pid = fork();
3118 if (pid >= 0) {
3119 if (pid == 0) {
3120 parg = args;
3121 *parg++ = (char *)setup_script;
3122 *parg++ = ifname;
3123 *parg++ = NULL;
3124 execv(setup_script, args);
3125 _exit(1);
3126 }
3127 while (waitpid(pid, &status, 0) != pid);
3128 if (!WIFEXITED(status) ||
3129 WEXITSTATUS(status) != 0) {
3130 fprintf(stderr, "%s: could not launch network script\n",
3131 setup_script);
3132 return -1;
3133 }
3134 }
3135 }
3136 s = net_tap_fd_init(vlan, fd);
3137 if (!s)
3138 return -1;
3139 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3140 "tap: ifname=%s setup_script=%s", ifname, setup_script);
3141 return 0;
3142 }
3143
3144 #endif /* !_WIN32 */
3145
3146 /* network connection */
3147 typedef struct NetSocketState {
3148 VLANClientState *vc;
3149 int fd;
3150 int state; /* 0 = getting length, 1 = getting data */
3151 int index;
3152 int packet_len;
3153 uint8_t buf[4096];
3154 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
3155 } NetSocketState;
3156
3157 typedef struct NetSocketListenState {
3158 VLANState *vlan;
3159 int fd;
3160 } NetSocketListenState;
3161
3162 /* XXX: we consider we can send the whole packet without blocking */
3163 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
3164 {
3165 NetSocketState *s = opaque;
3166 uint32_t len;
3167 len = htonl(size);
3168
3169 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
3170 send_all(s->fd, buf, size);
3171 }
3172
3173 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
3174 {
3175 NetSocketState *s = opaque;
3176 sendto(s->fd, buf, size, 0,
3177 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
3178 }
3179
3180 static void net_socket_send(void *opaque)
3181 {
3182 NetSocketState *s = opaque;
3183 int l, size, err;
3184 uint8_t buf1[4096];
3185 const uint8_t *buf;
3186
3187 size = recv(s->fd, buf1, sizeof(buf1), 0);
3188 if (size < 0) {
3189 err = socket_error();
3190 if (err != EWOULDBLOCK)
3191 goto eoc;
3192 } else if (size == 0) {
3193 /* end of connection */
3194 eoc:
3195 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3196 closesocket(s->fd);
3197 return;
3198 }
3199 buf = buf1;
3200 while (size > 0) {
3201 /* reassemble a packet from the network */
3202 switch(s->state) {
3203 case 0:
3204 l = 4 - s->index;
3205 if (l > size)
3206 l = size;
3207 memcpy(s->buf + s->index, buf, l);
3208 buf += l;
3209 size -= l;
3210 s->index += l;
3211 if (s->index == 4) {
3212 /* got length */
3213 s->packet_len = ntohl(*(uint32_t *)s->buf);
3214 s->index = 0;
3215 s->state = 1;
3216 }
3217 break;
3218 case 1:
3219 l = s->packet_len - s->index;
3220 if (l > size)
3221 l = size;
3222 memcpy(s->buf + s->index, buf, l);
3223 s->index += l;
3224 buf += l;
3225 size -= l;
3226 if (s->index >= s->packet_len) {
3227 qemu_send_packet(s->vc, s->buf, s->packet_len);
3228 s->index = 0;
3229 s->state = 0;
3230 }
3231 break;
3232 }
3233 }
3234 }
3235
3236 static void net_socket_send_dgram(void *opaque)
3237 {
3238 NetSocketState *s = opaque;
3239 int size;
3240
3241 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
3242 if (size < 0)
3243 return;
3244 if (size == 0) {
3245 /* end of connection */
3246 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3247 return;
3248 }
3249 qemu_send_packet(s->vc, s->buf, size);
3250 }
3251
3252 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
3253 {
3254 struct ip_mreq imr;
3255 int fd;
3256 int val, ret;
3257 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
3258 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
3259 inet_ntoa(mcastaddr->sin_addr),
3260 (int)ntohl(mcastaddr->sin_addr.s_addr));
3261 return -1;
3262
3263 }
3264 fd = socket(PF_INET, SOCK_DGRAM, 0);
3265 if (fd < 0) {
3266 perror("socket(PF_INET, SOCK_DGRAM)");
3267 return -1;
3268 }
3269
3270 val = 1;
3271 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
3272 (const char *)&val, sizeof(val));
3273 if (ret < 0) {
3274 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
3275 goto fail;
3276 }
3277
3278 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
3279 if (ret < 0) {
3280 perror("bind");
3281 goto fail;
3282 }
3283
3284 /* Add host to multicast group */
3285 imr.imr_multiaddr = mcastaddr->sin_addr;
3286 imr.imr_interface.s_addr = htonl(INADDR_ANY);
3287
3288 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
3289 (const char *)&imr, sizeof(struct ip_mreq));
3290 if (ret < 0) {
3291 perror("setsockopt(IP_ADD_MEMBERSHIP)");
3292 goto fail;
3293 }
3294
3295 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
3296 val = 1;
3297 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
3298 (const char *)&val, sizeof(val));
3299 if (ret < 0) {
3300 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
3301 goto fail;
3302 }
3303
3304 socket_set_nonblock(fd);
3305 return fd;
3306 fail:
3307 if (fd >= 0)
3308 closesocket(fd);
3309 return -1;
3310 }
3311
3312 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
3313 int is_connected)
3314 {
3315 struct sockaddr_in saddr;
3316 int newfd;
3317 socklen_t saddr_len;
3318 NetSocketState *s;
3319
3320 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
3321 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
3322 * by ONLY ONE process: we must "clone" this dgram socket --jjo
3323 */
3324
3325 if (is_connected) {
3326 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
3327 /* must be bound */
3328 if (saddr.sin_addr.s_addr==0) {
3329 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
3330 fd);
3331 return NULL;
3332 }
3333 /* clone dgram socket */
3334 newfd = net_socket_mcast_create(&saddr);
3335 if (newfd < 0) {
3336 /* error already reported by net_socket_mcast_create() */
3337 close(fd);
3338 return NULL;
3339 }
3340 /* clone newfd to fd, close newfd */
3341 dup2(newfd, fd);
3342 close(newfd);
3343
3344 } else {
3345 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
3346 fd, strerror(errno));
3347 return NULL;
3348 }
3349 }
3350
3351 s = qemu_mallocz(sizeof(NetSocketState));
3352 if (!s)
3353 return NULL;
3354 s->fd = fd;
3355
3356 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
3357 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
3358
3359 /* mcast: save bound address as dst */
3360 if (is_connected) s->dgram_dst=saddr;
3361
3362 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3363 "socket: fd=%d (%s mcast=%s:%d)",
3364 fd, is_connected? "cloned" : "",
3365 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3366 return s;
3367 }
3368
3369 static void net_socket_connect(void *opaque)
3370 {
3371 NetSocketState *s = opaque;
3372 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
3373 }
3374
3375 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
3376 int is_connected)
3377 {
3378 NetSocketState *s;
3379 s = qemu_mallocz(sizeof(NetSocketState));
3380 if (!s)
3381 return NULL;
3382 s->fd = fd;
3383 s->vc = qemu_new_vlan_client(vlan,
3384 net_socket_receive, NULL, s);
3385 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3386 "socket: fd=%d", fd);
3387 if (is_connected) {
3388 net_socket_connect(s);
3389 } else {
3390 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
3391 }
3392 return s;
3393 }
3394
3395 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
3396 int is_connected)
3397 {
3398 int so_type=-1, optlen=sizeof(so_type);
3399
3400 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
3401 fprintf(stderr, "qemu: error: setsockopt(SO_TYPE) for fd=%d failed\n", fd);
3402 return NULL;
3403 }
3404 switch(so_type) {
3405 case SOCK_DGRAM:
3406 return net_socket_fd_init_dgram(vlan, fd, is_connected);
3407 case SOCK_STREAM:
3408 return net_socket_fd_init_stream(vlan, fd, is_connected);
3409 default:
3410 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
3411 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
3412 return net_socket_fd_init_stream(vlan, fd, is_connected);
3413 }
3414 return NULL;
3415 }
3416
3417 static void net_socket_accept(void *opaque)
3418 {
3419 NetSocketListenState *s = opaque;
3420 NetSocketState *s1;
3421 struct sockaddr_in saddr;
3422 socklen_t len;
3423 int fd;
3424
3425 for(;;) {
3426 len = sizeof(saddr);
3427 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
3428 if (fd < 0 && errno != EINTR) {
3429 return;
3430 } else if (fd >= 0) {
3431 break;
3432 }
3433 }
3434 s1 = net_socket_fd_init(s->vlan, fd, 1);
3435 if (!s1) {
3436 closesocket(fd);
3437 } else {
3438 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
3439 "socket: connection from %s:%d",
3440 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3441 }
3442 }
3443
3444 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
3445 {
3446 NetSocketListenState *s;
3447 int fd, val, ret;
3448 struct sockaddr_in saddr;
3449
3450 if (parse_host_port(&saddr, host_str) < 0)
3451 return -1;
3452
3453 s = qemu_mallocz(sizeof(NetSocketListenState));
3454 if (!s)
3455 return -1;
3456
3457 fd = socket(PF_INET, SOCK_STREAM, 0);
3458 if (fd < 0) {
3459 perror("socket");
3460 return -1;
3461 }
3462 socket_set_nonblock(fd);
3463
3464 /* allow fast reuse */
3465 val = 1;
3466 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3467
3468 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
3469 if (ret < 0) {
3470 perror("bind");
3471 return -1;
3472 }
3473 ret = listen(fd, 0);
3474 if (ret < 0) {
3475 perror("listen");
3476 return -1;
3477 }
3478 s->vlan = vlan;
3479 s->fd = fd;
3480 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
3481 return 0;
3482 }
3483
3484 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
3485 {
3486 NetSocketState *s;
3487 int fd, connected, ret, err;
3488 struct sockaddr_in saddr;
3489
3490 if (parse_host_port(&saddr, host_str) < 0)
3491 return -1;
3492
3493 fd = socket(PF_INET, SOCK_STREAM, 0);
3494 if (fd < 0) {
3495 perror("socket");
3496 return -1;
3497 }
3498 socket_set_nonblock(fd);
3499
3500 connected = 0;
3501 for(;;) {
3502 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
3503 if (ret < 0) {
3504 err = socket_error();
3505 if (err == EINTR || err == EWOULDBLOCK) {
3506 } else if (err == EINPROGRESS) {
3507 break;
3508 } else {
3509 perror("connect");
3510 closesocket(fd);
3511 return -1;
3512 }
3513 } else {
3514 connected = 1;
3515 break;
3516 }
3517 }
3518 s = net_socket_fd_init(vlan, fd, connected);
3519 if (!s)
3520 return -1;
3521 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3522 "socket: connect to %s:%d",
3523 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3524 return 0;
3525 }
3526
3527 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
3528 {
3529 NetSocketState *s;
3530 int fd;
3531 struct sockaddr_in saddr;
3532
3533 if (parse_host_port(&saddr, host_str) < 0)
3534 return -1;
3535
3536
3537 fd = net_socket_mcast_create(&saddr);
3538 if (fd < 0)
3539 return -1;
3540
3541 s = net_socket_fd_init(vlan, fd, 0);
3542 if (!s)
3543 return -1;
3544
3545 s->dgram_dst = saddr;
3546
3547 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3548 "socket: mcast=%s:%d",
3549 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3550 return 0;
3551
3552 }
3553
3554 static int get_param_value(char *buf, int buf_size,
3555 const char *tag, const char *str)
3556 {
3557 const char *p;
3558 char *q;
3559 char option[128];
3560
3561 p = str;
3562 for(;;) {
3563 q = option;
3564 while (*p != '\0' && *p != '=') {
3565 if ((q - option) < sizeof(option) - 1)
3566 *q++ = *p;
3567 p++;
3568 }
3569 *q = '\0';
3570 if (*p != '=')
3571 break;
3572 p++;
3573 if (!strcmp(tag, option)) {
3574 q = buf;
3575 while (*p != '\0' && *p != ',') {
3576 if ((q - buf) < buf_size - 1)
3577 *q++ = *p;
3578 p++;
3579 }
3580 *q = '\0';
3581 return q - buf;
3582 } else {
3583 while (*p != '\0' && *p != ',') {
3584 p++;
3585 }
3586 }
3587 if (*p != ',')
3588 break;
3589 p++;
3590 }
3591 return 0;
3592 }
3593
3594 int net_client_init(const char *str)
3595 {
3596 const char *p;
3597 char *q;
3598 char device[64];
3599 char buf[1024];
3600 int vlan_id, ret;
3601 VLANState *vlan;
3602
3603 p = str;
3604 q = device;
3605 while (*p != '\0' && *p != ',') {
3606 if ((q - device) < sizeof(device) - 1)
3607 *q++ = *p;
3608 p++;
3609 }
3610 *q = '\0';
3611 if (*p == ',')
3612 p++;
3613 vlan_id = 0;
3614 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
3615 vlan_id = strtol(buf, NULL, 0);
3616 }
3617 vlan = qemu_find_vlan(vlan_id);
3618 if (!vlan) {
3619 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
3620 return -1;
3621 }
3622 if (!strcmp(device, "nic")) {
3623 NICInfo *nd;
3624 uint8_t *macaddr;
3625
3626 if (nb_nics >= MAX_NICS) {
3627 fprintf(stderr, "Too Many NICs\n");
3628 return -1;
3629 }
3630 nd = &nd_table[nb_nics];
3631 macaddr = nd->macaddr;
3632 macaddr[0] = 0x52;
3633 macaddr[1] = 0x54;
3634 macaddr[2] = 0x00;
3635 macaddr[3] = 0x12;
3636 macaddr[4] = 0x34;
3637 macaddr[5] = 0x56 + nb_nics;
3638
3639 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
3640 if (parse_macaddr(macaddr, buf) < 0) {
3641 fprintf(stderr, "invalid syntax for ethernet address\n");
3642 return -1;
3643 }
3644 }
3645 if (get_param_value(buf, sizeof(buf), "model", p)) {
3646 nd->model = strdup(buf);
3647 }
3648 nd->vlan = vlan;
3649 nb_nics++;
3650 ret = 0;
3651 } else
3652 if (!strcmp(device, "none")) {
3653 /* does nothing. It is needed to signal that no network cards
3654 are wanted */
3655 ret = 0;
3656 } else
3657 #ifdef CONFIG_SLIRP
3658 if (!strcmp(device, "user")) {
3659 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
3660 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
3661 }
3662 ret = net_slirp_init(vlan);
3663 } else
3664 #endif
3665 #ifdef _WIN32
3666 if (!strcmp(device, "tap")) {
3667 char ifname[64];
3668 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
3669 fprintf(stderr, "tap: no interface name\n");
3670 return -1;
3671 }
3672 ret = tap_win32_init(vlan, ifname);
3673 } else
3674 #else
3675 if (!strcmp(device, "tap")) {
3676 char ifname[64];
3677 char setup_script[1024];
3678 int fd;
3679 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
3680 fd = strtol(buf, NULL, 0);
3681 ret = -1;
3682 if (net_tap_fd_init(vlan, fd))
3683 ret = 0;
3684 } else {
3685 get_param_value(ifname, sizeof(ifname), "ifname", p);
3686 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
3687 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
3688 }
3689 ret = net_tap_init(vlan, ifname, setup_script);
3690 }
3691 } else
3692 #endif
3693 if (!strcmp(device, "socket")) {
3694 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
3695 int fd;
3696 fd = strtol(buf, NULL, 0);
3697 ret = -1;
3698 if (net_socket_fd_init(vlan, fd, 1))
3699 ret = 0;
3700 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
3701 ret = net_socket_listen_init(vlan, buf);
3702 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
3703 ret = net_socket_connect_init(vlan, buf);
3704 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
3705 ret = net_socket_mcast_init(vlan, buf);
3706 } else {
3707 fprintf(stderr, "Unknown socket options: %s\n", p);
3708 return -1;
3709 }
3710 } else
3711 {
3712 fprintf(stderr, "Unknown network device: %s\n", device);
3713 return -1;
3714 }
3715 if (ret < 0) {
3716 fprintf(stderr, "Could not initialize device '%s'\n", device);
3717 }
3718
3719 return ret;
3720 }
3721
3722 void do_info_network(void)
3723 {
3724 VLANState *vlan;
3725 VLANClientState *vc;
3726
3727 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3728 term_printf("VLAN %d devices:\n", vlan->id);
3729 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
3730 term_printf(" %s\n", vc->info_str);
3731 }
3732 }
3733
3734 /***********************************************************/
3735 /* USB devices */
3736
3737 static USBPort *used_usb_ports;
3738 static USBPort *free_usb_ports;
3739
3740 /* ??? Maybe change this to register a hub to keep track of the topology. */
3741 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
3742 usb_attachfn attach)
3743 {
3744 port->opaque = opaque;
3745 port->index = index;
3746 port->attach = attach;
3747 port->next = free_usb_ports;
3748 free_usb_ports = port;
3749 }
3750
3751 static int usb_device_add(const char *devname)
3752 {
3753 const char *p;
3754 USBDevice *dev;
3755 USBPort *port;
3756
3757 if (!free_usb_ports)
3758 return -1;
3759
3760 if (strstart(devname, "host:", &p)) {
3761 dev = usb_host_device_open(p);
3762 } else if (!strcmp(devname, "mouse")) {
3763 dev = usb_mouse_init();
3764 } else if (!strcmp(devname, "tablet")) {
3765 dev = usb_tablet_init();
3766 } else if (strstart(devname, "disk:", &p)) {
3767 dev = usb_msd_init(p);
3768 } else {
3769 return -1;
3770 }
3771 if (!dev)
3772 return -1;
3773
3774 /* Find a USB port to add the device to. */
3775 port = free_usb_ports;
3776 if (!port->next) {
3777 USBDevice *hub;
3778
3779 /* Create a new hub and chain it on. */
3780 free_usb_ports = NULL;
3781 port->next = used_usb_ports;
3782 used_usb_ports = port;
3783
3784 hub = usb_hub_init(VM_USB_HUB_SIZE);
3785 usb_attach(port, hub);
3786 port = free_usb_ports;
3787 }
3788
3789 free_usb_ports = port->next;
3790 port->next = used_usb_ports;
3791 used_usb_ports = port;
3792 usb_attach(port, dev);
3793 return 0;
3794 }
3795
3796 static int usb_device_del(const char *devname)
3797 {
3798 USBPort *port;
3799 USBPort **lastp;
3800 USBDevice *dev;
3801 int bus_num, addr;
3802 const char *p;
3803
3804 if (!used_usb_ports)
3805 return -1;
3806
3807 p = strchr(devname, '.');
3808 if (!p)
3809 return -1;
3810 bus_num = strtoul(devname, NULL, 0);
3811 addr = strtoul(p + 1, NULL, 0);
3812 if (bus_num != 0)
3813 return -1;
3814
3815 lastp = &used_usb_ports;
3816 port = used_usb_ports;
3817 while (port && port->dev->addr != addr) {
3818 lastp = &port->next;
3819 port = port->next;
3820 }
3821
3822 if (!port)
3823 return -1;
3824
3825 dev = port->dev;
3826 *lastp = port->next;
3827 usb_attach(port, NULL);
3828 dev->handle_destroy(dev);
3829 port->next = free_usb_ports;
3830 free_usb_ports = port;
3831 return 0;
3832 }
3833
3834 void do_usb_add(const char *devname)
3835 {
3836 int ret;
3837 ret = usb_device_add(devname);
3838 if (ret < 0)
3839 term_printf("Could not add USB device '%s'\n", devname);
3840 }
3841
3842 void do_usb_del(const char *devname)
3843 {
3844 int ret;
3845 ret = usb_device_del(devname);
3846 if (ret < 0)
3847 term_printf("Could not remove USB device '%s'\n", devname);
3848 }
3849
3850 void usb_info(void)
3851 {
3852 USBDevice *dev;
3853 USBPort *port;
3854 const char *speed_str;
3855
3856 if (!usb_enabled) {
3857 term_printf("USB support not enabled\n");
3858 return;
3859 }
3860
3861 for (port = used_usb_ports; port; port = port->next) {
3862 dev = port->dev;
3863 if (!dev)
3864 continue;
3865 switch(dev->speed) {
3866 case USB_SPEED_LOW:
3867 speed_str = "1.5";
3868 break;
3869 case USB_SPEED_FULL:
3870 speed_str = "12";
3871 break;
3872 case USB_SPEED_HIGH:
3873 speed_str = "480";
3874 break;
3875 default:
3876 speed_str = "?";
3877 break;
3878 }
3879 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
3880 0, dev->addr, speed_str, dev->devname);
3881 }
3882 }
3883
3884 /***********************************************************/
3885 /* pid file */
3886
3887 static char *pid_filename;
3888
3889 /* Remove PID file. Called on normal exit */
3890
3891 static void remove_pidfile(void)
3892 {
3893 unlink (pid_filename);
3894 }
3895
3896 static void create_pidfile(const char *filename)
3897 {
3898 struct stat pidstat;
3899 FILE *f;
3900
3901 /* Try to write our PID to the named file */
3902 if (stat(filename, &pidstat) < 0) {
3903 if (errno == ENOENT) {
3904 if ((f = fopen (filename, "w")) == NULL) {
3905 perror("Opening pidfile");
3906 exit(1);
3907 }
3908 fprintf(f, "%d\n", getpid());
3909 fclose(f);
3910 pid_filename = qemu_strdup(filename);
3911 if (!pid_filename) {
3912 fprintf(stderr, "Could not save PID filename");
3913 exit(1);
3914 }
3915 atexit(remove_pidfile);
3916 }
3917 } else {
3918 fprintf(stderr, "%s already exists. Remove it and try again.\n",
3919 filename);
3920 exit(1);
3921 }
3922 }
3923
3924 /***********************************************************/
3925 /* dumb display */
3926
3927 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
3928 {
3929 }
3930
3931 static void dumb_resize(DisplayState *ds, int w, int h)
3932 {
3933 }
3934
3935 static void dumb_refresh(DisplayState *ds)
3936 {
3937 vga_hw_update();
3938 }
3939
3940 void dumb_display_init(DisplayState *ds)
3941 {
3942 ds->data = NULL;
3943 ds->linesize = 0;
3944 ds->depth = 0;
3945 ds->dpy_update = dumb_update;
3946 ds->dpy_resize = dumb_resize;
3947 ds->dpy_refresh = dumb_refresh;
3948 }
3949
3950 /***********************************************************/
3951 /* I/O handling */
3952
3953 #define MAX_IO_HANDLERS 64
3954
3955 typedef struct IOHandlerRecord {
3956 int fd;
3957 IOCanRWHandler *fd_read_poll;
3958 IOHandler *fd_read;
3959 IOHandler *fd_write;
3960 void *opaque;
3961 /* temporary data */
3962 struct pollfd *ufd;
3963 struct IOHandlerRecord *next;
3964 } IOHandlerRecord;
3965
3966 static IOHandlerRecord *first_io_handler;
3967
3968 /* XXX: fd_read_poll should be suppressed, but an API change is
3969 necessary in the character devices to suppress fd_can_read(). */
3970 int qemu_set_fd_handler2(int fd,
3971 IOCanRWHandler *fd_read_poll,
3972 IOHandler *fd_read,
3973 IOHandler *fd_write,
3974 void *opaque)
3975 {
3976 IOHandlerRecord **pioh, *ioh;
3977
3978 if (!fd_read && !fd_write) {
3979 pioh = &first_io_handler;
3980 for(;;) {
3981 ioh = *pioh;
3982 if (ioh == NULL)
3983 break;
3984 if (ioh->fd == fd) {
3985 *pioh = ioh->next;
3986 qemu_free(ioh);
3987 break;
3988 }
3989 pioh = &ioh->next;
3990 }
3991 } else {
3992 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3993 if (ioh->fd == fd)
3994 goto found;
3995 }
3996 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
3997 if (!ioh)
3998 return -1;
3999 ioh->next = first_io_handler;
4000 first_io_handler = ioh;
4001 found:
4002 ioh->fd = fd;
4003 ioh->fd_read_poll = fd_read_poll;
4004 ioh->fd_read = fd_read;
4005 ioh->fd_write = fd_write;
4006 ioh->opaque = opaque;
4007 }
4008 return 0;
4009 }
4010
4011 int qemu_set_fd_handler(int fd,
4012 IOHandler *fd_read,
4013 IOHandler *fd_write,
4014 void *opaque)
4015 {
4016 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
4017 }
4018
4019 /***********************************************************/
4020 /* Polling handling */
4021
4022 typedef struct PollingEntry {
4023 PollingFunc *func;
4024 void *opaque;
4025 struct PollingEntry *next;
4026 } PollingEntry;
4027
4028 static PollingEntry *first_polling_entry;
4029
4030 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
4031 {
4032 PollingEntry **ppe, *pe;
4033 pe = qemu_mallocz(sizeof(PollingEntry));
4034 if (!pe)
4035 return -1;
4036 pe->func = func;
4037 pe->opaque = opaque;
4038 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
4039 *ppe = pe;
4040 return 0;
4041 }
4042
4043 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
4044 {
4045 PollingEntry **ppe, *pe;
4046 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
4047 pe = *ppe;
4048 if (pe->func == func && pe->opaque == opaque) {
4049 *ppe = pe->next;
4050 qemu_free(pe);
4051 break;
4052 }
4053 }
4054 }
4055
4056 #ifdef _WIN32
4057 /***********************************************************/
4058 /* Wait objects support */
4059 typedef struct WaitObjects {
4060 int num;
4061 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
4062 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
4063 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
4064 } WaitObjects;
4065
4066 static WaitObjects wait_objects = {0};
4067
4068 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
4069 {
4070 WaitObjects *w = &wait_objects;
4071
4072 if (w->num >= MAXIMUM_WAIT_OBJECTS)
4073 return -1;
4074 w->events[w->num] = handle;
4075 w->func[w->num] = func;
4076 w->opaque[w->num] = opaque;
4077 w->num++;
4078 return 0;
4079 }
4080
4081 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
4082 {
4083 int i, found;
4084 WaitObjects *w = &wait_objects;
4085
4086 found = 0;
4087 for (i = 0; i < w->num; i++) {
4088 if (w->events[i] == handle)
4089 found = 1;
4090 if (found) {
4091 w->events[i] = w->events[i + 1];
4092 w->func[i] = w->func[i + 1];
4093 w->opaque[i] = w->opaque[i + 1];
4094 }
4095 }
4096 if (found)
4097 w->num--;
4098 }
4099 #endif
4100
4101 /***********************************************************/
4102 /* savevm/loadvm support */
4103
4104 #define IO_BUF_SIZE 32768
4105
4106 struct QEMUFile {
4107 FILE *outfile;
4108 BlockDriverState *bs;
4109 int is_file;
4110 int is_writable;
4111 int64_t base_offset;
4112 int64_t buf_offset; /* start of buffer when writing, end of buffer
4113 when reading */
4114 int buf_index;
4115 int buf_size; /* 0 when writing */
4116 uint8_t buf[IO_BUF_SIZE];
4117 };
4118
4119 QEMUFile *qemu_fopen(const char *filename, const char *mode)
4120 {
4121 QEMUFile *f;
4122
4123 f = qemu_mallocz(sizeof(QEMUFile));
4124 if (!f)
4125 return NULL;
4126 if (!strcmp(mode, "wb")) {
4127 f->is_writable = 1;
4128 } else if (!strcmp(mode, "rb")) {
4129 f->is_writable = 0;
4130 } else {
4131 goto fail;
4132 }
4133 f->outfile = fopen(filename, mode);
4134 if (!f->outfile)
4135 goto fail;
4136 f->is_file = 1;
4137 return f;
4138 fail:
4139 if (f->outfile)
4140 fclose(f->outfile);
4141 qemu_free(f);
4142 return NULL;
4143 }
4144
4145 QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
4146 {
4147 QEMUFile *f;
4148
4149 f = qemu_mallocz(sizeof(QEMUFile));
4150 if (!f)
4151 return NULL;
4152 f->is_file = 0;
4153 f->bs = bs;
4154 f->is_writable = is_writable;
4155 f->base_offset = offset;
4156 return f;
4157 }
4158
4159 void qemu_fflush(QEMUFile *f)
4160 {
4161 if (!f->is_writable)
4162 return;
4163 if (f->buf_index > 0) {
4164 if (f->is_file) {
4165 fseek(f->outfile, f->buf_offset, SEEK_SET);
4166 fwrite(f->buf, 1, f->buf_index, f->outfile);
4167 } else {
4168 bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
4169 f->buf, f->buf_index);
4170 }
4171 f->buf_offset += f->buf_index;
4172 f->buf_index = 0;
4173 }
4174 }
4175
4176 static void qemu_fill_buffer(QEMUFile *f)
4177 {
4178 int len;
4179
4180 if (f->is_writable)
4181 return;
4182 if (f->is_file) {
4183 fseek(f->outfile, f->buf_offset, SEEK_SET);
4184 len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
4185 if (len < 0)
4186 len = 0;
4187 } else {
4188 len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
4189 f->buf, IO_BUF_SIZE);
4190 if (len < 0)
4191 len = 0;
4192 }
4193 f->buf_index = 0;
4194 f->buf_size = len;
4195 f->buf_offset += len;
4196 }
4197
4198 void qemu_fclose(QEMUFile *f)
4199 {
4200 if (f->is_writable)
4201 qemu_fflush(f);
4202 if (f->is_file) {
4203 fclose(f->outfile);
4204 }
4205 qemu_free(f);
4206 }
4207
4208 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
4209 {
4210 int l;
4211 while (size > 0) {
4212 l = IO_BUF_SIZE - f->buf_index;
4213 if (l > size)
4214 l = size;
4215 memcpy(f->buf + f->buf_index, buf, l);
4216 f->buf_index += l;
4217 buf += l;
4218 size -= l;
4219 if (f->buf_index >= IO_BUF_SIZE)
4220 qemu_fflush(f);
4221 }
4222 }
4223
4224 void qemu_put_byte(QEMUFile *f, int v)
4225 {
4226 f->buf[f->buf_index++] = v;
4227 if (f->buf_index >= IO_BUF_SIZE)
4228 qemu_fflush(f);
4229 }
4230
4231 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
4232 {
4233 int size, l;
4234
4235 size = size1;
4236 while (size > 0) {
4237 l = f->buf_size - f->buf_index;
4238 if (l == 0) {
4239 qemu_fill_buffer(f);
4240 l = f->buf_size - f->buf_index;
4241 if (l == 0)
4242 break;
4243 }
4244 if (l > size)
4245 l = size;
4246 memcpy(buf, f->buf + f->buf_index, l);
4247 f->buf_index += l;
4248 buf += l;
4249 size -= l;
4250 }
4251 return size1 - size;
4252 }
4253
4254 int qemu_get_byte(QEMUFile *f)
4255 {
4256 if (f->buf_index >= f->buf_size) {
4257 qemu_fill_buffer(f);
4258 if (f->buf_index >= f->buf_size)
4259 return 0;
4260 }
4261 return f->buf[f->buf_index++];
4262 }
4263
4264 int64_t qemu_ftell(QEMUFile *f)
4265 {
4266 return f->buf_offset - f->buf_size + f->buf_index;
4267 }
4268
4269 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
4270 {
4271 if (whence == SEEK_SET) {
4272 /* nothing to do */
4273 } else if (whence == SEEK_CUR) {
4274 pos += qemu_ftell(f);
4275 } else {
4276 /* SEEK_END not supported */
4277 return -1;
4278 }
4279 if (f->is_writable) {
4280 qemu_fflush(f);
4281 f->buf_offset = pos;
4282 } else {
4283 f->buf_offset = pos;
4284 f->buf_index = 0;
4285 f->buf_size = 0;
4286 }
4287 return pos;
4288 }
4289
4290 void qemu_put_be16(QEMUFile *f, unsigned int v)
4291 {
4292 qemu_put_byte(f, v >> 8);
4293 qemu_put_byte(f, v);
4294 }
4295
4296 void qemu_put_be32(QEMUFile *f, unsigned int v)
4297 {
4298 qemu_put_byte(f, v >> 24);
4299 qemu_put_byte(f, v >> 16);
4300 qemu_put_byte(f, v >> 8);
4301 qemu_put_byte(f, v);
4302 }
4303
4304 void qemu_put_be64(QEMUFile *f, uint64_t v)
4305 {
4306 qemu_put_be32(f, v >> 32);
4307 qemu_put_be32(f, v);
4308 }
4309
4310 unsigned int qemu_get_be16(QEMUFile *f)
4311 {
4312 unsigned int v;
4313 v = qemu_get_byte(f) << 8;
4314 v |= qemu_get_byte(f);
4315 return v;
4316 }
4317
4318 unsigned int qemu_get_be32(QEMUFile *f)
4319 {
4320 unsigned int v;
4321 v = qemu_get_byte(f) << 24;
4322 v |= qemu_get_byte(f) << 16;
4323 v |= qemu_get_byte(f) << 8;
4324 v |= qemu_get_byte(f);
4325 return v;
4326 }
4327
4328 uint64_t qemu_get_be64(QEMUFile *f)
4329 {
4330 uint64_t v;
4331 v = (uint64_t)qemu_get_be32(f) << 32;
4332 v |= qemu_get_be32(f);
4333 return v;
4334 }
4335
4336 typedef struct SaveStateEntry {
4337 char idstr[256];
4338 int instance_id;
4339 int version_id;
4340 SaveStateHandler *save_state;
4341 LoadStateHandler *load_state;
4342 void *opaque;
4343 struct SaveStateEntry *next;
4344 } SaveStateEntry;
4345
4346 static SaveStateEntry *first_se;
4347
4348 int register_savevm(const char *idstr,
4349 int instance_id,
4350 int version_id,
4351 SaveStateHandler *save_state,
4352 LoadStateHandler *load_state,
4353 void *opaque)
4354 {
4355 SaveStateEntry *se, **pse;
4356
4357 se = qemu_malloc(sizeof(SaveStateEntry));
4358 if (!se)
4359 return -1;
4360 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
4361 se->instance_id = instance_id;
4362 se->version_id = version_id;
4363 se->save_state = save_state;
4364 se->load_state = load_state;
4365 se->opaque = opaque;
4366 se->next = NULL;
4367
4368 /* add at the end of list */
4369 pse = &first_se;
4370 while (*pse != NULL)
4371 pse = &(*pse)->next;
4372 *pse = se;
4373 return 0;
4374 }
4375
4376 #define QEMU_VM_FILE_MAGIC 0x5145564d
4377 #define QEMU_VM_FILE_VERSION 0x00000002
4378
4379 int qemu_savevm_state(QEMUFile *f)
4380 {
4381 SaveStateEntry *se;
4382 int len, ret;
4383 int64_t cur_pos, len_pos, total_len_pos;
4384
4385 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
4386 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
4387 total_len_pos = qemu_ftell(f);
4388 qemu_put_be64(f, 0); /* total size */
4389
4390 for(se = first_se; se != NULL; se = se->next) {
4391 /* ID string */
4392 len = strlen(se->idstr);
4393 qemu_put_byte(f, len);
4394 qemu_put_buffer(f, se->idstr, len);
4395
4396 qemu_put_be32(f, se->instance_id);
4397 qemu_put_be32(f, se->version_id);
4398
4399 /* record size: filled later */
4400 len_pos = qemu_ftell(f);
4401 qemu_put_be32(f, 0);
4402
4403 se->save_state(f, se->opaque);
4404
4405 /* fill record size */
4406 cur_pos = qemu_ftell(f);
4407 len = cur_pos - len_pos - 4;
4408 qemu_fseek(f, len_pos, SEEK_SET);
4409 qemu_put_be32(f, len);
4410 qemu_fseek(f, cur_pos, SEEK_SET);
4411 }
4412 cur_pos = qemu_ftell(f);
4413 qemu_fseek(f, total_len_pos, SEEK_SET);
4414 qemu_put_be64(f, cur_pos - total_len_pos - 8);
4415 qemu_fseek(f, cur_pos, SEEK_SET);
4416
4417 ret = 0;
4418 return ret;
4419 }
4420
4421 static SaveStateEntry *find_se(const char *idstr, int instance_id)
4422 {
4423 SaveStateEntry *se;
4424
4425 for(se = first_se; se != NULL; se = se->next) {
4426 if (!strcmp(se->idstr, idstr) &&
4427 instance_id == se->instance_id)
4428 return se;
4429 }
4430 return NULL;
4431 }
4432
4433 int qemu_loadvm_state(QEMUFile *f)
4434 {
4435 SaveStateEntry *se;
4436 int len, ret, instance_id, record_len, version_id;
4437 int64_t total_len, end_pos, cur_pos;
4438 unsigned int v;
4439 char idstr[256];
4440
4441 v = qemu_get_be32(f);
4442 if (v != QEMU_VM_FILE_MAGIC)
4443 goto fail;
4444 v = qemu_get_be32(f);
4445 if (v != QEMU_VM_FILE_VERSION) {
4446 fail:
4447 ret = -1;
4448 goto the_end;
4449 }
4450 total_len = qemu_get_be64(f);
4451 end_pos = total_len + qemu_ftell(f);
4452 for(;;) {
4453 if (qemu_ftell(f) >= end_pos)
4454 break;
4455 len = qemu_get_byte(f);
4456 qemu_get_buffer(f, idstr, len);
4457 idstr[len] = '\0';
4458 instance_id = qemu_get_be32(f);
4459 version_id = qemu_get_be32(f);
4460 record_len = qemu_get_be32(f);
4461 #if 0
4462 printf("idstr=%s instance=0x%x version=%d len=%d\n",
4463 idstr, instance_id, version_id, record_len);
4464 #endif
4465 cur_pos = qemu_ftell(f);
4466 se = find_se(idstr, instance_id);
4467 if (!se) {
4468 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
4469 instance_id, idstr);
4470 } else {
4471 ret = se->load_state(f, se->opaque, version_id);
4472 if (ret < 0) {
4473 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
4474 instance_id, idstr);
4475 }
4476 }
4477 /* always seek to exact end of record */
4478 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
4479 }
4480 ret = 0;
4481 the_end:
4482 return ret;
4483 }
4484
4485 /* device can contain snapshots */
4486 static int bdrv_can_snapshot(BlockDriverState *bs)
4487 {
4488 return (bs &&
4489 !bdrv_is_removable(bs) &&
4490 !bdrv_is_read_only(bs));
4491 }
4492
4493 /* device must be snapshots in order to have a reliable snapshot */
4494 static int bdrv_has_snapshot(BlockDriverState *bs)
4495 {
4496 return (bs &&
4497 !bdrv_is_removable(bs) &&
4498 !bdrv_is_read_only(bs));
4499 }
4500
4501 static BlockDriverState *get_bs_snapshots(void)
4502 {
4503 BlockDriverState *bs;
4504 int i;
4505
4506 if (bs_snapshots)
4507 return bs_snapshots;
4508 for(i = 0; i <= MAX_DISKS; i++) {
4509 bs = bs_table[i];
4510 if (bdrv_can_snapshot(bs))
4511 goto ok;
4512 }
4513 return NULL;
4514 ok:
4515 bs_snapshots = bs;
4516 return bs;
4517 }
4518
4519 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
4520 const char *name)
4521 {
4522 QEMUSnapshotInfo *sn_tab, *sn;
4523 int nb_sns, i, ret;
4524
4525 ret = -ENOENT;
4526 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
4527 if (nb_sns < 0)
4528 return ret;
4529 for(i = 0; i < nb_sns; i++) {
4530 sn = &sn_tab[i];
4531 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
4532 *sn_info = *sn;
4533 ret = 0;
4534 break;
4535 }
4536 }
4537 qemu_free(sn_tab);
4538 return ret;
4539 }
4540
4541 void do_savevm(const char *name)
4542 {
4543 BlockDriverState *bs, *bs1;
4544 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
4545 int must_delete, ret, i;
4546 BlockDriverInfo bdi1, *bdi = &bdi1;
4547 QEMUFile *f;
4548 int saved_vm_running;
4549 #ifdef _WIN32
4550 struct _timeb tb;
4551 #else
4552 struct timeval tv;
4553 #endif
4554
4555 bs = get_bs_snapshots();
4556 if (!bs) {
4557 term_printf("No block device can accept snapshots\n");
4558 return;
4559 }
4560
4561 /* ??? Should this occur after vm_stop? */
4562 qemu_aio_flush();
4563
4564 saved_vm_running = vm_running;
4565 vm_stop(0);
4566
4567 must_delete = 0;
4568 if (name) {
4569 ret = bdrv_snapshot_find(bs, old_sn, name);
4570 if (ret >= 0) {
4571 must_delete = 1;
4572 }
4573 }
4574 memset(sn, 0, sizeof(*sn));
4575 if (must_delete) {
4576 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
4577 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
4578 } else {
4579 if (name)
4580 pstrcpy(sn->name, sizeof(sn->name), name);
4581 }
4582
4583 /* fill auxiliary fields */
4584 #ifdef _WIN32
4585 _ftime(&tb);
4586 sn->date_sec = tb.time;
4587 sn->date_nsec = tb.millitm * 1000000;
4588 #else
4589 gettimeofday(&tv, NULL);
4590 sn->date_sec = tv.tv_sec;
4591 sn->date_nsec = tv.tv_usec * 1000;
4592 #endif
4593 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
4594
4595 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
4596 term_printf("Device %s does not support VM state snapshots\n",
4597 bdrv_get_device_name(bs));
4598 goto the_end;
4599 }
4600
4601 /* save the VM state */
4602 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
4603 if (!f) {
4604 term_printf("Could not open VM state file\n");
4605 goto the_end;
4606 }
4607 ret = qemu_savevm_state(f);
4608 sn->vm_state_size = qemu_ftell(f);
4609 qemu_fclose(f);
4610 if (ret < 0) {
4611 term_printf("Error %d while writing VM\n", ret);
4612 goto the_end;
4613 }
4614
4615 /* create the snapshots */
4616
4617 for(i = 0; i < MAX_DISKS; i++) {
4618 bs1 = bs_table[i];
4619 if (bdrv_has_snapshot(bs1)) {
4620 if (must_delete) {
4621 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
4622 if (ret < 0) {
4623 term_printf("Error while deleting snapshot on '%s'\n",
4624 bdrv_get_device_name(bs1));
4625 }
4626 }
4627 ret = bdrv_snapshot_create(bs1, sn);
4628 if (ret < 0) {
4629 term_printf("Error while creating snapshot on '%s'\n",
4630 bdrv_get_device_name(bs1));
4631 }
4632 }
4633 }
4634
4635 the_end:
4636 if (saved_vm_running)
4637 vm_start();
4638 }
4639
4640 void do_loadvm(const char *name)
4641 {
4642 BlockDriverState *bs, *bs1;
4643 BlockDriverInfo bdi1, *bdi = &bdi1;
4644 QEMUFile *f;
4645 int i, ret;
4646 int saved_vm_running;
4647
4648 bs = get_bs_snapshots();
4649 if (!bs) {
4650 term_printf("No block device supports snapshots\n");
4651 return;
4652 }
4653
4654 /* Flush all IO requests so they don't interfere with the new state. */
4655 qemu_aio_flush();
4656
4657 saved_vm_running = vm_running;
4658 vm_stop(0);
4659
4660 for(i = 0; i <= MAX_DISKS; i++) {
4661 bs1 = bs_table[i];
4662 if (bdrv_has_snapshot(bs1)) {
4663 ret = bdrv_snapshot_goto(bs1, name);
4664 if (ret < 0) {
4665 if (bs != bs1)
4666 term_printf("Warning: ");
4667 switch(ret) {
4668 case -ENOTSUP:
4669 term_printf("Snapshots not supported on device '%s'\n",
4670 bdrv_get_device_name(bs1));
4671 break;
4672 case -ENOENT:
4673 term_printf("Could not find snapshot '%s' on device '%s'\n",
4674 name, bdrv_get_device_name(bs1));
4675 break;
4676 default:
4677 term_printf("Error %d while activating snapshot on '%s'\n",
4678 ret, bdrv_get_device_name(bs1));
4679 break;
4680 }
4681 /* fatal on snapshot block device */
4682 if (bs == bs1)
4683 goto the_end;
4684 }
4685 }
4686 }
4687
4688 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
4689 term_printf("Device %s does not support VM state snapshots\n",
4690 bdrv_get_device_name(bs));
4691 return;
4692 }
4693
4694 /* restore the VM state */
4695 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
4696 if (!f) {
4697 term_printf("Could not open VM state file\n");
4698 goto the_end;
4699 }
4700 ret = qemu_loadvm_state(f);
4701 qemu_fclose(f);
4702 if (ret < 0) {
4703 term_printf("Error %d while loading VM state\n", ret);
4704 }
4705 the_end:
4706 if (saved_vm_running)
4707 vm_start();
4708 }
4709
4710 void do_delvm(const char *name)
4711 {
4712 BlockDriverState *bs, *bs1;
4713 int i, ret;
4714
4715 bs = get_bs_snapshots();
4716 if (!bs) {
4717 term_printf("No block device supports snapshots\n");
4718 return;
4719 }
4720
4721 for(i = 0; i <= MAX_DISKS; i++) {
4722 bs1 = bs_table[i];
4723 if (bdrv_has_snapshot(bs1)) {
4724 ret = bdrv_snapshot_delete(bs1, name);
4725 if (ret < 0) {
4726 if (ret == -ENOTSUP)
4727 term_printf("Snapshots not supported on device '%s'\n",
4728 bdrv_get_device_name(bs1));
4729 else
4730 term_printf("Error %d while deleting snapshot on '%s'\n",
4731 ret, bdrv_get_device_name(bs1));
4732 }
4733 }
4734 }
4735 }
4736
4737 void do_info_snapshots(void)
4738 {
4739 BlockDriverState *bs, *bs1;
4740 QEMUSnapshotInfo *sn_tab, *sn;
4741 int nb_sns, i;
4742 char buf[256];
4743
4744 bs = get_bs_snapshots();
4745 if (!bs) {
4746 term_printf("No available block device supports snapshots\n");
4747 return;
4748 }
4749 term_printf("Snapshot devices:");
4750 for(i = 0; i <= MAX_DISKS; i++) {
4751 bs1 = bs_table[i];
4752 if (bdrv_has_snapshot(bs1)) {
4753 if (bs == bs1)
4754 term_printf(" %s", bdrv_get_device_name(bs1));
4755 }
4756 }
4757 term_printf("\n");
4758
4759 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
4760 if (nb_sns < 0) {
4761 term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
4762 return;
4763 }
4764 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
4765 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
4766 for(i = 0; i < nb_sns; i++) {
4767 sn = &sn_tab[i];
4768 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
4769 }
4770 qemu_free(sn_tab);
4771 }
4772
4773 /***********************************************************/
4774 /* cpu save/restore */
4775
4776 #if defined(TARGET_I386)
4777
4778 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
4779 {
4780 qemu_put_be32(f, dt->selector);
4781 qemu_put_betl(f, dt->base);
4782 qemu_put_be32(f, dt->limit);
4783 qemu_put_be32(f, dt->flags);
4784 }
4785
4786 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
4787 {
4788 dt->selector = qemu_get_be32(f);
4789 dt->base = qemu_get_betl(f);
4790 dt->limit = qemu_get_be32(f);
4791 dt->flags = qemu_get_be32(f);
4792 }
4793
4794 void cpu_save(QEMUFile *f, void *opaque)
4795 {
4796 CPUState *env = opaque;
4797 uint16_t fptag, fpus, fpuc, fpregs_format;
4798 uint32_t hflags;
4799 int i;
4800
4801 for(i = 0; i < CPU_NB_REGS; i++)
4802 qemu_put_betls(f, &env->regs[i]);
4803 qemu_put_betls(f, &env->eip);
4804 qemu_put_betls(f, &env->eflags);
4805 hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
4806 qemu_put_be32s(f, &hflags);
4807
4808 /* FPU */
4809 fpuc = env->fpuc;
4810 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
4811 fptag = 0;
4812 for(i = 0; i < 8; i++) {
4813 fptag |= ((!env->fptags[i]) << i);
4814 }
4815
4816 qemu_put_be16s(f, &fpuc);
4817 qemu_put_be16s(f, &fpus);
4818 qemu_put_be16s(f, &fptag);
4819
4820 #ifdef USE_X86LDOUBLE
4821 fpregs_format = 0;
4822 #else
4823 fpregs_format = 1;
4824 #endif
4825 qemu_put_be16s(f, &fpregs_format);
4826
4827 for(i = 0; i < 8; i++) {
4828 #ifdef USE_X86LDOUBLE
4829 {
4830 uint64_t mant;
4831 uint16_t exp;
4832 /* we save the real CPU data (in case of MMX usage only 'mant'
4833 contains the MMX register */
4834 cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
4835 qemu_put_be64(f, mant);
4836 qemu_put_be16(f, exp);
4837 }
4838 #else
4839 /* if we use doubles for float emulation, we save the doubles to
4840 avoid losing information in case of MMX usage. It can give
4841 problems if the image is restored on a CPU where long
4842 doubles are used instead. */
4843 qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
4844 #endif
4845 }
4846
4847 for(i = 0; i < 6; i++)
4848 cpu_put_seg(f, &env->segs[i]);
4849 cpu_put_seg(f, &env->ldt);
4850 cpu_put_seg(f, &env->tr);
4851 cpu_put_seg(f, &env->gdt);
4852 cpu_put_seg(f, &env->idt);
4853
4854 qemu_put_be32s(f, &env->sysenter_cs);
4855 qemu_put_be32s(f, &env->sysenter_esp);
4856 qemu_put_be32s(f, &env->sysenter_eip);
4857
4858 qemu_put_betls(f, &env->cr[0]);
4859 qemu_put_betls(f, &env->cr[2]);
4860 qemu_put_betls(f, &env->cr[3]);
4861 qemu_put_betls(f, &env->cr[4]);
4862
4863 for(i = 0; i < 8; i++)
4864 qemu_put_betls(f, &env->dr[i]);
4865
4866 /* MMU */
4867 qemu_put_be32s(f, &env->a20_mask);
4868
4869 /* XMM */
4870 qemu_put_be32s(f, &env->mxcsr);
4871 for(i = 0; i < CPU_NB_REGS; i++) {
4872 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
4873 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
4874 }
4875
4876 #ifdef TARGET_X86_64
4877 qemu_put_be64s(f, &env->efer);
4878 qemu_put_be64s(f, &env->star);
4879 qemu_put_be64s(f, &env->lstar);
4880 qemu_put_be64s(f, &env->cstar);
4881 qemu_put_be64s(f, &env->fmask);
4882 qemu_put_be64s(f, &env->kernelgsbase);
4883 #endif
4884 qemu_put_be32s(f, &env->smbase);
4885 }
4886
4887 #ifdef USE_X86LDOUBLE
4888 /* XXX: add that in a FPU generic layer */
4889 union x86_longdouble {
4890 uint64_t mant;
4891 uint16_t exp;
4892 };
4893
4894 #define MANTD1(fp) (fp & ((1LL << 52) - 1))
4895 #define EXPBIAS1 1023
4896 #define EXPD1(fp) ((fp >> 52) & 0x7FF)
4897 #define SIGND1(fp) ((fp >> 32) & 0x80000000)
4898
4899 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
4900 {
4901 int e;
4902 /* mantissa */
4903 p->mant = (MANTD1(temp) << 11) | (1LL << 63);
4904 /* exponent + sign */
4905 e = EXPD1(temp) - EXPBIAS1 + 16383;
4906 e |= SIGND1(temp) >> 16;
4907 p->exp = e;
4908 }
4909 #endif
4910
4911 int cpu_load(QEMUFile *f, void *opaque, int version_id)
4912 {
4913 CPUState *env = opaque;
4914 int i, guess_mmx;
4915 uint32_t hflags;
4916 uint16_t fpus, fpuc, fptag, fpregs_format;
4917
4918 if (version_id != 3 && version_id != 4)
4919 return -EINVAL;
4920 for(i = 0; i < CPU_NB_REGS; i++)
4921 qemu_get_betls(f, &env->regs[i]);
4922 qemu_get_betls(f, &env->eip);
4923 qemu_get_betls(f, &env->eflags);
4924 qemu_get_be32s(f, &hflags);
4925
4926 qemu_get_be16s(f, &fpuc);
4927 qemu_get_be16s(f, &fpus);
4928 qemu_get_be16s(f, &fptag);
4929 qemu_get_be16s(f, &fpregs_format);
4930
4931 /* NOTE: we cannot always restore the FPU state if the image come
4932 from a host with a different 'USE_X86LDOUBLE' define. We guess
4933 if we are in an MMX state to restore correctly in that case. */
4934 guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
4935 for(i = 0; i < 8; i++) {
4936 uint64_t mant;
4937 uint16_t exp;
4938
4939 switch(fpregs_format) {
4940 case 0:
4941 mant = qemu_get_be64(f);
4942 exp = qemu_get_be16(f);
4943 #ifdef USE_X86LDOUBLE
4944 env->fpregs[i].d = cpu_set_fp80(mant, exp);
4945 #else
4946 /* difficult case */
4947 if (guess_mmx)
4948 env->fpregs[i].mmx.MMX_Q(0) = mant;
4949 else
4950 env->fpregs[i].d = cpu_set_fp80(mant, exp);
4951 #endif
4952 break;
4953 case 1:
4954 mant = qemu_get_be64(f);
4955 #ifdef USE_X86LDOUBLE
4956 {
4957 union x86_longdouble *p;
4958 /* difficult case */
4959 p = (void *)&env->fpregs[i];
4960 if (guess_mmx) {
4961 p->mant = mant;
4962 p->exp = 0xffff;
4963 } else {
4964 fp64_to_fp80(p, mant);
4965 }
4966 }
4967 #else
4968 env->fpregs[i].mmx.MMX_Q(0) = mant;
4969 #endif
4970 break;
4971 default:
4972 return -EINVAL;
4973 }
4974 }
4975
4976 env->fpuc = fpuc;
4977 /* XXX: restore FPU round state */
4978 env->fpstt = (fpus >> 11) & 7;
4979 env->fpus = fpus & ~0x3800;
4980 fptag ^= 0xff;
4981 for(i = 0; i < 8; i++) {
4982 env->fptags[i] = (fptag >> i) & 1;
4983 }
4984
4985 for(i = 0; i < 6; i++)
4986 cpu_get_seg(f, &env->segs[i]);
4987 cpu_get_seg(f, &env->ldt);
4988 cpu_get_seg(f, &env->tr);
4989 cpu_get_seg(f, &env->gdt);
4990 cpu_get_seg(f, &env->idt);
4991
4992 qemu_get_be32s(f, &env->sysenter_cs);
4993 qemu_get_be32s(f, &env->sysenter_esp);
4994 qemu_get_be32s(f, &env->sysenter_eip);
4995
4996 qemu_get_betls(f, &env->cr[0]);
4997 qemu_get_betls(f, &env->cr[2]);
4998 qemu_get_betls(f, &env->cr[3]);
4999 qemu_get_betls(f, &env->cr[4]);
5000
5001 for(i = 0; i < 8; i++)
5002 qemu_get_betls(f, &env->dr[i]);
5003
5004 /* MMU */
5005 qemu_get_be32s(f, &env->a20_mask);
5006
5007 qemu_get_be32s(f, &env->mxcsr);
5008 for(i = 0; i < CPU_NB_REGS; i++) {
5009 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
5010 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
5011 }
5012
5013 #ifdef TARGET_X86_64
5014 qemu_get_be64s(f, &env->efer);
5015 qemu_get_be64s(f, &env->star);
5016 qemu_get_be64s(f, &env->lstar);
5017 qemu_get_be64s(f, &env->cstar);
5018 qemu_get_be64s(f, &env->fmask);
5019 qemu_get_be64s(f, &env->kernelgsbase);
5020 #endif
5021 if (version_id >= 4)
5022 qemu_get_be32s(f, &env->smbase);
5023
5024 /* XXX: compute hflags from scratch, except for CPL and IIF */
5025 env->hflags = hflags;
5026 tlb_flush(env, 1);
5027 return 0;
5028 }
5029
5030 #elif defined(TARGET_PPC)
5031 void cpu_save(QEMUFile *f, void *opaque)
5032 {
5033 }
5034
5035 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5036 {
5037 return 0;
5038 }
5039
5040 #elif defined(TARGET_MIPS)
5041 void cpu_save(QEMUFile *f, void *opaque)
5042 {
5043 }
5044
5045 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5046 {
5047 return 0;
5048 }
5049
5050 #elif defined(TARGET_SPARC)
5051 void cpu_save(QEMUFile *f, void *opaque)
5052 {
5053 CPUState *env = opaque;
5054 int i;
5055 uint32_t tmp;
5056
5057 for(i = 0; i < 8; i++)
5058 qemu_put_betls(f, &env->gregs[i]);
5059 for(i = 0; i < NWINDOWS * 16; i++)
5060 qemu_put_betls(f, &env->regbase[i]);
5061
5062 /* FPU */
5063 for(i = 0; i < TARGET_FPREGS; i++) {
5064 union {
5065 float32 f;
5066 uint32_t i;
5067 } u;
5068 u.f = env->fpr[i];
5069 qemu_put_be32(f, u.i);
5070 }
5071
5072 qemu_put_betls(f, &env->pc);
5073 qemu_put_betls(f, &env->npc);
5074 qemu_put_betls(f, &env->y);
5075 tmp = GET_PSR(env);
5076 qemu_put_be32(f, tmp);
5077 qemu_put_betls(f, &env->fsr);
5078 qemu_put_betls(f, &env->tbr);
5079 #ifndef TARGET_SPARC64
5080 qemu_put_be32s(f, &env->wim);
5081 /* MMU */
5082 for(i = 0; i < 16; i++)
5083 qemu_put_be32s(f, &env->mmuregs[i]);
5084 #endif
5085 }
5086
5087 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5088 {
5089 CPUState *env = opaque;
5090 int i;
5091 uint32_t tmp;
5092
5093 for(i = 0; i < 8; i++)
5094 qemu_get_betls(f, &env->gregs[i]);
5095 for(i = 0; i < NWINDOWS * 16; i++)
5096 qemu_get_betls(f, &env->regbase[i]);
5097
5098 /* FPU */
5099 for(i = 0; i < TARGET_FPREGS; i++) {
5100 union {
5101 float32 f;
5102 uint32_t i;
5103 } u;
5104 u.i = qemu_get_be32(f);
5105 env->fpr[i] = u.f;
5106 }
5107
5108 qemu_get_betls(f, &env->pc);
5109 qemu_get_betls(f, &env->npc);
5110 qemu_get_betls(f, &env->y);
5111 tmp = qemu_get_be32(f);
5112 env->cwp = 0; /* needed to ensure that the wrapping registers are
5113 correctly updated */
5114 PUT_PSR(env, tmp);
5115 qemu_get_betls(f, &env->fsr);
5116 qemu_get_betls(f, &env->tbr);
5117 #ifndef TARGET_SPARC64
5118 qemu_get_be32s(f, &env->wim);
5119 /* MMU */
5120 for(i = 0; i < 16; i++)
5121 qemu_get_be32s(f, &env->mmuregs[i]);
5122 #endif
5123 tlb_flush(env, 1);
5124 return 0;
5125 }
5126
5127 #elif defined(TARGET_ARM)
5128
5129 /* ??? Need to implement these. */
5130 void cpu_save(QEMUFile *f, void *opaque)
5131 {
5132 }
5133
5134 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5135 {
5136 return 0;
5137 }
5138
5139 #else
5140
5141 #warning No CPU save/restore functions
5142
5143 #endif
5144
5145 /***********************************************************/
5146 /* ram save/restore */
5147
5148 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
5149 {
5150 int v;
5151
5152 v = qemu_get_byte(f);
5153 switch(v) {
5154 case 0:
5155 if (qemu_get_buffer(f, buf, len) != len)
5156 return -EIO;
5157 break;
5158 case 1:
5159 v = qemu_get_byte(f);
5160 memset(buf, v, len);
5161 break;
5162 default:
5163 return -EINVAL;
5164 }
5165 return 0;
5166 }
5167
5168 static int ram_load_v1(QEMUFile *f, void *opaque)
5169 {
5170 int i, ret;
5171
5172 if (qemu_get_be32(f) != phys_ram_size)
5173 return -EINVAL;
5174 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
5175 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
5176 if (ret)
5177 return ret;
5178 }
5179 return 0;
5180 }
5181
5182 #define BDRV_HASH_BLOCK_SIZE 1024
5183 #define IOBUF_SIZE 4096
5184 #define RAM_CBLOCK_MAGIC 0xfabe
5185
5186 typedef struct RamCompressState {
5187 z_stream zstream;
5188 QEMUFile *f;
5189 uint8_t buf[IOBUF_SIZE];
5190 } RamCompressState;
5191
5192 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
5193 {
5194 int ret;
5195 memset(s, 0, sizeof(*s));
5196 s->f = f;
5197 ret = deflateInit2(&s->zstream, 1,
5198 Z_DEFLATED, 15,
5199 9, Z_DEFAULT_STRATEGY);
5200 if (ret != Z_OK)
5201 return -1;
5202 s->zstream.avail_out = IOBUF_SIZE;
5203 s->zstream.next_out = s->buf;
5204 return 0;
5205 }
5206
5207 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
5208 {
5209 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
5210 qemu_put_be16(s->f, len);
5211 qemu_put_buffer(s->f, buf, len);
5212 }
5213
5214 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
5215 {
5216 int ret;
5217
5218 s->zstream.avail_in = len;
5219 s->zstream.next_in = (uint8_t *)buf;
5220 while (s->zstream.avail_in > 0) {
5221 ret = deflate(&s->zstream, Z_NO_FLUSH);
5222 if (ret != Z_OK)
5223 return -1;
5224 if (s->zstream.avail_out == 0) {
5225 ram_put_cblock(s, s->buf, IOBUF_SIZE);
5226 s->zstream.avail_out = IOBUF_SIZE;
5227 s->zstream.next_out = s->buf;
5228 }
5229 }
5230 return 0;
5231 }
5232
5233 static void ram_compress_close(RamCompressState *s)
5234 {
5235 int len, ret;
5236
5237 /* compress last bytes */
5238 for(;;) {
5239 ret = deflate(&s->zstream, Z_FINISH);
5240 if (ret == Z_OK || ret == Z_STREAM_END) {
5241 len = IOBUF_SIZE - s->zstream.avail_out;
5242 if (len > 0) {
5243 ram_put_cblock(s, s->buf, len);
5244 }
5245 s->zstream.avail_out = IOBUF_SIZE;
5246 s->zstream.next_out = s->buf;
5247 if (ret == Z_STREAM_END)
5248 break;
5249 } else {
5250 goto fail;
5251 }
5252 }
5253 fail:
5254 deflateEnd(&s->zstream);
5255 }
5256
5257 typedef struct RamDecompressState {
5258 z_stream zstream;
5259 QEMUFile *f;
5260 uint8_t buf[IOBUF_SIZE];
5261 } RamDecompressState;
5262
5263 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
5264 {
5265 int ret;
5266 memset(s, 0, sizeof(*s));
5267 s->f = f;
5268 ret = inflateInit(&s->zstream);
5269 if (ret != Z_OK)
5270 return -1;
5271 return 0;
5272 }
5273
5274 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
5275 {
5276 int ret, clen;
5277
5278 s->zstream.avail_out = len;
5279 s->zstream.next_out = buf;
5280 while (s->zstream.avail_out > 0) {
5281 if (s->zstream.avail_in == 0) {
5282 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
5283 return -1;
5284 clen = qemu_get_be16(s->f);
5285 if (clen > IOBUF_SIZE)
5286 return -1;
5287 qemu_get_buffer(s->f, s->buf, clen);
5288 s->zstream.avail_in = clen;
5289 s->zstream.next_in = s->buf;
5290 }
5291 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
5292 if (ret != Z_OK && ret != Z_STREAM_END) {
5293 return -1;
5294 }
5295 }
5296 return 0;
5297 }
5298
5299 static void ram_decompress_close(RamDecompressState *s)
5300 {
5301 inflateEnd(&s->zstream);
5302 }
5303
5304 static void ram_save(QEMUFile *f, void *opaque)
5305 {
5306 int i;
5307 RamCompressState s1, *s = &s1;
5308 uint8_t buf[10];
5309
5310 qemu_put_be32(f, phys_ram_size);
5311 if (ram_compress_open(s, f) < 0)
5312 return;
5313 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
5314 #if 0
5315 if (tight_savevm_enabled) {
5316 int64_t sector_num;
5317 int j;
5318
5319 /* find if the memory block is available on a virtual
5320 block device */
5321 sector_num = -1;
5322 for(j = 0; j < MAX_DISKS; j++) {
5323 if (bs_table[j]) {
5324 sector_num = bdrv_hash_find(bs_table[j],
5325 phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
5326 if (sector_num >= 0)
5327 break;
5328 }
5329 }
5330 if (j == MAX_DISKS)
5331 goto normal_compress;
5332 buf[0] = 1;
5333 buf[1] = j;
5334 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
5335 ram_compress_buf(s, buf, 10);
5336 } else
5337 #endif
5338 {
5339 // normal_compress:
5340 buf[0] = 0;
5341 ram_compress_buf(s, buf, 1);
5342 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
5343 }
5344 }
5345 ram_compress_close(s);
5346 }
5347
5348 static int ram_load(QEMUFile *f, void *opaque, int version_id)
5349 {
5350 RamDecompressState s1, *s = &s1;
5351 uint8_t buf[10];
5352 int i;
5353
5354 if (version_id == 1)
5355 return ram_load_v1(f, opaque);
5356 if (version_id != 2)
5357 return -EINVAL;
5358 if (qemu_get_be32(f) != phys_ram_size)
5359 return -EINVAL;
5360 if (ram_decompress_open(s, f) < 0)
5361 return -EINVAL;
5362 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
5363 if (ram_decompress_buf(s, buf, 1) < 0) {
5364 fprintf(stderr, "Error while reading ram block header\n");
5365 goto error;
5366 }
5367 if (buf[0] == 0) {
5368 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
5369 fprintf(stderr, "Error while reading ram block address=0x%08x", i);
5370 goto error;
5371 }
5372 } else
5373 #if 0
5374 if (buf[0] == 1) {
5375 int bs_index;
5376 int64_t sector_num;
5377
5378 ram_decompress_buf(s, buf + 1, 9);
5379 bs_index = buf[1];
5380 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
5381 if (bs_index >= MAX_DISKS || bs_table[bs_index] == NULL) {
5382 fprintf(stderr, "Invalid block device index %d\n", bs_index);
5383 goto error;
5384 }
5385 if (bdrv_read(bs_table[bs_index], sector_num, phys_ram_base + i,
5386 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
5387 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
5388 bs_index, sector_num);
5389 goto error;
5390 }
5391 } else
5392 #endif
5393 {
5394 error:
5395 printf("Error block header\n");
5396 return -EINVAL;
5397 }
5398 }
5399 ram_decompress_close(s);
5400 return 0;
5401 }
5402
5403 /***********************************************************/
5404 /* bottom halves (can be seen as timers which expire ASAP) */
5405
5406 struct QEMUBH {
5407 QEMUBHFunc *cb;
5408 void *opaque;
5409 int scheduled;
5410 QEMUBH *next;
5411 };
5412
5413 static QEMUBH *first_bh = NULL;
5414
5415 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
5416 {
5417 QEMUBH *bh;
5418 bh = qemu_mallocz(sizeof(QEMUBH));
5419 if (!bh)
5420 return NULL;
5421 bh->cb = cb;
5422 bh->opaque = opaque;
5423 return bh;
5424 }
5425
5426 int qemu_bh_poll(void)
5427 {
5428 QEMUBH *bh, **pbh;
5429 int ret;
5430
5431 ret = 0;
5432 for(;;) {
5433 pbh = &first_bh;
5434 bh = *pbh;
5435 if (!bh)
5436 break;
5437 ret = 1;
5438 *pbh = bh->next;
5439 bh->scheduled = 0;
5440 bh->cb(bh->opaque);
5441 }
5442 return ret;
5443 }
5444
5445 void qemu_bh_schedule(QEMUBH *bh)
5446 {
5447 CPUState *env = cpu_single_env;
5448 if (bh->scheduled)
5449 return;
5450 bh->scheduled = 1;
5451 bh->next = first_bh;
5452 first_bh = bh;
5453
5454 /* stop the currently executing CPU to execute the BH ASAP */
5455 if (env) {
5456 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
5457 }
5458 }
5459
5460 void qemu_bh_cancel(QEMUBH *bh)
5461 {
5462 QEMUBH **pbh;
5463 if (bh->scheduled) {
5464 pbh = &first_bh;
5465 while (*pbh != bh)
5466 pbh = &(*pbh)->next;
5467 *pbh = bh->next;
5468 bh->scheduled = 0;
5469 }
5470 }
5471
5472 void qemu_bh_delete(QEMUBH *bh)
5473 {
5474 qemu_bh_cancel(bh);
5475 qemu_free(bh);
5476 }
5477
5478 /***********************************************************/
5479 /* machine registration */
5480
5481 QEMUMachine *first_machine = NULL;
5482
5483 int qemu_register_machine(QEMUMachine *m)
5484 {
5485 QEMUMachine **pm;
5486 pm = &first_machine;
5487 while (*pm != NULL)
5488 pm = &(*pm)->next;
5489 m->next = NULL;
5490 *pm = m;
5491 return 0;
5492 }
5493
5494 QEMUMachine *find_machine(const char *name)
5495 {
5496 QEMUMachine *m;
5497
5498 for(m = first_machine; m != NULL; m = m->next) {
5499 if (!strcmp(m->name, name))
5500 return m;
5501 }
5502 return NULL;
5503 }
5504
5505 /***********************************************************/
5506 /* main execution loop */
5507
5508 void gui_update(void *opaque)
5509 {
5510 display_state.dpy_refresh(&display_state);
5511 qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
5512 }
5513
5514 struct vm_change_state_entry {
5515 VMChangeStateHandler *cb;
5516 void *opaque;
5517 LIST_ENTRY (vm_change_state_entry) entries;
5518 };
5519
5520 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
5521
5522 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
5523 void *opaque)
5524 {
5525 VMChangeStateEntry *e;
5526
5527 e = qemu_mallocz(sizeof (*e));
5528 if (!e)
5529 return NULL;
5530
5531 e->cb = cb;
5532 e->opaque = opaque;
5533 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
5534 return e;
5535 }
5536
5537 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
5538 {
5539 LIST_REMOVE (e, entries);
5540 qemu_free (e);
5541 }
5542
5543 static void vm_state_notify(int running)
5544 {
5545 VMChangeStateEntry *e;
5546
5547 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
5548 e->cb(e->opaque, running);
5549 }
5550 }
5551
5552 /* XXX: support several handlers */
5553 static VMStopHandler *vm_stop_cb;
5554 static void *vm_stop_opaque;
5555
5556 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
5557 {
5558 vm_stop_cb = cb;
5559 vm_stop_opaque = opaque;
5560 return 0;
5561 }
5562
5563 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
5564 {
5565 vm_stop_cb = NULL;
5566 }
5567
5568 void vm_start(void)
5569 {
5570 if (!vm_running) {
5571 cpu_enable_ticks();
5572 vm_running = 1;
5573 vm_state_notify(1);
5574 }
5575 }
5576
5577 void vm_stop(int reason)
5578 {
5579 if (vm_running) {
5580 cpu_disable_ticks();
5581 vm_running = 0;
5582 if (reason != 0) {
5583 if (vm_stop_cb) {
5584 vm_stop_cb(vm_stop_opaque, reason);
5585 }
5586 }
5587 vm_state_notify(0);
5588 }
5589 }
5590
5591 /* reset/shutdown handler */
5592
5593 typedef struct QEMUResetEntry {
5594 QEMUResetHandler *func;
5595 void *opaque;
5596 struct QEMUResetEntry *next;
5597 } QEMUResetEntry;
5598
5599 static QEMUResetEntry *first_reset_entry;
5600 static int reset_requested;
5601 static int shutdown_requested;
5602 static int powerdown_requested;
5603
5604 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
5605 {
5606 QEMUResetEntry **pre, *re;
5607
5608 pre = &first_reset_entry;
5609 while (*pre != NULL)
5610 pre = &(*pre)->next;
5611 re = qemu_mallocz(sizeof(QEMUResetEntry));
5612 re->func = func;
5613 re->opaque = opaque;
5614 re->next = NULL;
5615 *pre = re;
5616 }
5617
5618 void qemu_system_reset(void)
5619 {
5620 QEMUResetEntry *re;
5621
5622 /* reset all devices */
5623 for(re = first_reset_entry; re != NULL; re = re->next) {
5624 re->func(re->opaque);
5625 }
5626 }
5627
5628 void qemu_system_reset_request(void)
5629 {
5630 reset_requested = 1;
5631 if (cpu_single_env)
5632 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5633 }
5634
5635 void qemu_system_shutdown_request(void)
5636 {
5637 shutdown_requested = 1;
5638 if (cpu_single_env)
5639 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5640 }
5641
5642 void qemu_system_powerdown_request(void)
5643 {
5644 powerdown_requested = 1;
5645 if (cpu_single_env)
5646 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5647 }
5648
5649 void main_loop_wait(int timeout)
5650 {
5651 IOHandlerRecord *ioh, *ioh_next;
5652 fd_set rfds, wfds, xfds;
5653 int ret, nfds;
5654 struct timeval tv;
5655 PollingEntry *pe;
5656
5657
5658 /* XXX: need to suppress polling by better using win32 events */
5659 ret = 0;
5660 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
5661 ret |= pe->func(pe->opaque);
5662 }
5663 #ifdef _WIN32
5664 if (ret == 0 && timeout > 0) {
5665 int err;
5666 WaitObjects *w = &wait_objects;
5667
5668 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
5669 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
5670 if (w->func[ret - WAIT_OBJECT_0])
5671 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
5672 } else if (ret == WAIT_TIMEOUT) {
5673 } else {
5674 err = GetLastError();
5675 fprintf(stderr, "Wait error %d %d\n", ret, err);
5676 }
5677 }
5678 #endif
5679 /* poll any events */
5680 /* XXX: separate device handlers from system ones */
5681 nfds = -1;
5682 FD_ZERO(&rfds);
5683 FD_ZERO(&wfds);
5684 FD_ZERO(&xfds);
5685 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5686 if (ioh->fd_read &&
5687 (!ioh->fd_read_poll ||
5688 ioh->fd_read_poll(ioh->opaque) != 0)) {
5689 FD_SET(ioh->fd, &rfds);
5690 if (ioh->fd > nfds)
5691 nfds = ioh->fd;
5692 }
5693 if (ioh->fd_write) {
5694 FD_SET(ioh->fd, &wfds);
5695 if (ioh->fd > nfds)
5696 nfds = ioh->fd;
5697 }
5698 }
5699
5700 tv.tv_sec = 0;
5701 #ifdef _WIN32
5702 tv.tv_usec = 0;
5703 #else
5704 tv.tv_usec = timeout * 1000;
5705 #endif
5706 #if defined(CONFIG_SLIRP)
5707 if (slirp_inited) {
5708 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
5709 }
5710 #endif
5711 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
5712 if (ret > 0) {
5713 /* XXX: better handling of removal */
5714 for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
5715 ioh_next = ioh->next;
5716 if (FD_ISSET(ioh->fd, &rfds)) {
5717 ioh->fd_read(ioh->opaque);
5718 }
5719 if (FD_ISSET(ioh->fd, &wfds)) {
5720 ioh->fd_write(ioh->opaque);
5721 }
5722 }
5723 }
5724 #if defined(CONFIG_SLIRP)
5725 if (slirp_inited) {
5726 if (ret < 0) {
5727 FD_ZERO(&rfds);
5728 FD_ZERO(&wfds);
5729 FD_ZERO(&xfds);
5730 }
5731 slirp_select_poll(&rfds, &wfds, &xfds);
5732 }
5733 #endif
5734 qemu_aio_poll();
5735 qemu_bh_poll();
5736
5737 if (vm_running) {
5738 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
5739 qemu_get_clock(vm_clock));
5740 /* run dma transfers, if any */
5741 DMA_run();
5742 }
5743
5744 /* real time timers */
5745 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
5746 qemu_get_clock(rt_clock));
5747 }
5748
5749 static CPUState *cur_cpu;
5750
5751 int main_loop(void)
5752 {
5753 int ret, timeout;
5754 #ifdef CONFIG_PROFILER
5755 int64_t ti;
5756 #endif
5757 CPUState *env;
5758
5759 cur_cpu = first_cpu;
5760 for(;;) {
5761 if (vm_running) {
5762
5763 env = cur_cpu;
5764 for(;;) {
5765 /* get next cpu */
5766 env = env->next_cpu;
5767 if (!env)
5768 env = first_cpu;
5769 #ifdef CONFIG_PROFILER
5770 ti = profile_getclock();
5771 #endif
5772 ret = cpu_exec(env);
5773 #ifdef CONFIG_PROFILER
5774 qemu_time += profile_getclock() - ti;
5775 #endif
5776 if (ret != EXCP_HALTED)
5777 break;
5778 /* all CPUs are halted ? */
5779 if (env == cur_cpu) {
5780 ret = EXCP_HLT;
5781 break;
5782 }
5783 }
5784 cur_cpu = env;
5785
5786 if (shutdown_requested) {
5787 ret = EXCP_INTERRUPT;
5788 break;
5789 }
5790 if (reset_requested) {
5791 reset_requested = 0;
5792 qemu_system_reset();
5793 ret = EXCP_INTERRUPT;
5794 }
5795 if (powerdown_requested) {
5796 powerdown_requested = 0;
5797 qemu_system_powerdown();
5798 ret = EXCP_INTERRUPT;
5799 }
5800 if (ret == EXCP_DEBUG) {
5801 vm_stop(EXCP_DEBUG);
5802 }
5803 /* if hlt instruction, we wait until the next IRQ */
5804 /* XXX: use timeout computed from timers */
5805 if (ret == EXCP_HLT)
5806 timeout = 10;
5807 else
5808 timeout = 0;
5809 } else {
5810 timeout = 10;
5811 }
5812 #ifdef CONFIG_PROFILER
5813 ti = profile_getclock();
5814 #endif
5815 main_loop_wait(timeout);
5816 #ifdef CONFIG_PROFILER
5817 dev_time += profile_getclock() - ti;
5818 #endif
5819 }
5820 cpu_disable_ticks();
5821 return ret;
5822 }
5823
5824 void help(void)
5825 {
5826 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2006 Fabrice Bellard\n"
5827 "usage: %s [options] [disk_image]\n"
5828 "\n"
5829 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
5830 "\n"
5831 "Standard options:\n"
5832 "-M machine select emulated machine (-M ? for list)\n"
5833 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
5834 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
5835 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
5836 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
5837 "-boot [a|c|d] boot on floppy (a), hard disk (c) or CD-ROM (d)\n"
5838 "-snapshot write to temporary files instead of disk image files\n"
5839 #ifdef TARGET_I386
5840 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
5841 #endif
5842 "-m megs set virtual RAM size to megs MB [default=%d]\n"
5843 "-smp n set the number of CPUs to 'n' [default=1]\n"
5844 "-nographic disable graphical output and redirect serial I/Os to console\n"
5845 #ifndef _WIN32
5846 "-k language use keyboard layout (for example \"fr\" for French)\n"
5847 #endif
5848 #ifdef HAS_AUDIO
5849 "-audio-help print list of audio drivers and their options\n"
5850 "-soundhw c1,... enable audio support\n"
5851 " and only specified sound cards (comma separated list)\n"
5852 " use -soundhw ? to get the list of supported cards\n"
5853 " use -soundhw all to enable all of them\n"
5854 #endif
5855 "-localtime set the real time clock to local time [default=utc]\n"
5856 "-full-screen start in full screen\n"
5857 #ifdef TARGET_I386
5858 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
5859 #endif
5860 "-usb enable the USB driver (will be the default soon)\n"
5861 "-usbdevice name add the host or guest USB device 'name'\n"
5862 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5863 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
5864 #endif
5865 "\n"
5866 "Network options:\n"
5867 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
5868 " create a new Network Interface Card and connect it to VLAN 'n'\n"
5869 #ifdef CONFIG_SLIRP
5870 "-net user[,vlan=n][,hostname=host]\n"
5871 " connect the user mode network stack to VLAN 'n' and send\n"
5872 " hostname 'host' to DHCP clients\n"
5873 #endif
5874 #ifdef _WIN32
5875 "-net tap[,vlan=n],ifname=name\n"
5876 " connect the host TAP network interface to VLAN 'n'\n"
5877 #else
5878 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file]\n"
5879 " connect the host TAP network interface to VLAN 'n' and use\n"
5880 " the network script 'file' (default=%s);\n"
5881 " use 'fd=h' to connect to an already opened TAP interface\n"
5882 #endif
5883 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
5884 " connect the vlan 'n' to another VLAN using a socket connection\n"
5885 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
5886 " connect the vlan 'n' to multicast maddr and port\n"
5887 "-net none use it alone to have zero network devices; if no -net option\n"
5888 " is provided, the default is '-net nic -net user'\n"
5889 "\n"
5890 #ifdef CONFIG_SLIRP
5891 "-tftp prefix allow tftp access to files starting with prefix [-net user]\n"
5892 #ifndef _WIN32
5893 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
5894 #endif
5895 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
5896 " redirect TCP or UDP connections from host to guest [-net user]\n"
5897 #endif
5898 "\n"
5899 "Linux boot specific:\n"
5900 "-kernel bzImage use 'bzImage' as kernel image\n"
5901 "-append cmdline use 'cmdline' as kernel command line\n"
5902 "-initrd file use 'file' as initial ram disk\n"
5903 "\n"
5904 "Debug/Expert options:\n"
5905 "-monitor dev redirect the monitor to char device 'dev'\n"
5906 "-serial dev redirect the serial port to char device 'dev'\n"
5907 "-parallel dev redirect the parallel port to char device 'dev'\n"
5908 "-pidfile file Write PID to 'file'\n"
5909 "-S freeze CPU at startup (use 'c' to start execution)\n"
5910 "-s wait gdb connection to port %d\n"
5911 "-p port change gdb connection port\n"
5912 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
5913 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
5914 " translation (t=none or lba) (usually qemu can guess them)\n"
5915 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
5916 #ifdef USE_KQEMU
5917 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
5918 "-no-kqemu disable KQEMU kernel module usage\n"
5919 #endif
5920 #ifdef USE_CODE_COPY
5921 "-no-code-copy disable code copy acceleration\n"
5922 #endif
5923 #ifdef TARGET_I386
5924 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
5925 " (default is CL-GD5446 PCI VGA)\n"
5926 "-no-acpi disable ACPI\n"
5927 #endif
5928 "-loadvm file start right away with a saved state (loadvm in monitor)\n"
5929 "-vnc display start a VNC server on display\n"
5930 "\n"
5931 "During emulation, the following keys are useful:\n"
5932 "ctrl-alt-f toggle full screen\n"
5933 "ctrl-alt-n switch to virtual console 'n'\n"
5934 "ctrl-alt toggle mouse and keyboard grab\n"
5935 "\n"
5936 "When using -nographic, press 'ctrl-a h' to get some help.\n"
5937 ,
5938 "qemu",
5939 DEFAULT_RAM_SIZE,
5940 #ifndef _WIN32
5941 DEFAULT_NETWORK_SCRIPT,
5942 #endif
5943 DEFAULT_GDBSTUB_PORT,
5944 "/tmp/qemu.log");
5945 exit(1);
5946 }
5947
5948 #define HAS_ARG 0x0001
5949
5950 enum {
5951 QEMU_OPTION_h,
5952
5953 QEMU_OPTION_M,
5954 QEMU_OPTION_fda,
5955 QEMU_OPTION_fdb,
5956 QEMU_OPTION_hda,
5957 QEMU_OPTION_hdb,
5958 QEMU_OPTION_hdc,
5959 QEMU_OPTION_hdd,
5960 QEMU_OPTION_cdrom,
5961 QEMU_OPTION_boot,
5962 QEMU_OPTION_snapshot,
5963 #ifdef TARGET_I386
5964 QEMU_OPTION_no_fd_bootchk,
5965 #endif
5966 QEMU_OPTION_m,
5967 QEMU_OPTION_nographic,
5968 #ifdef HAS_AUDIO
5969 QEMU_OPTION_audio_help,
5970 QEMU_OPTION_soundhw,
5971 #endif
5972
5973 QEMU_OPTION_net,
5974 QEMU_OPTION_tftp,
5975 QEMU_OPTION_smb,
5976 QEMU_OPTION_redir,
5977
5978 QEMU_OPTION_kernel,
5979 QEMU_OPTION_append,
5980 QEMU_OPTION_initrd,
5981
5982 QEMU_OPTION_S,
5983 QEMU_OPTION_s,
5984 QEMU_OPTION_p,
5985 QEMU_OPTION_d,
5986 QEMU_OPTION_hdachs,
5987 QEMU_OPTION_L,
5988 QEMU_OPTION_no_code_copy,
5989 QEMU_OPTION_k,
5990 QEMU_OPTION_localtime,
5991 QEMU_OPTION_cirrusvga,
5992 QEMU_OPTION_g,
5993 QEMU_OPTION_std_vga,
5994 QEMU_OPTION_monitor,
5995 QEMU_OPTION_serial,
5996 QEMU_OPTION_parallel,
5997 QEMU_OPTION_loadvm,
5998 QEMU_OPTION_full_screen,
5999 QEMU_OPTION_pidfile,
6000 QEMU_OPTION_no_kqemu,
6001 QEMU_OPTION_kernel_kqemu,
6002 QEMU_OPTION_win2k_hack,
6003 QEMU_OPTION_usb,
6004 QEMU_OPTION_usbdevice,
6005 QEMU_OPTION_smp,
6006 QEMU_OPTION_vnc,
6007 QEMU_OPTION_no_acpi,
6008 };
6009
6010 typedef struct QEMUOption {
6011 const char *name;
6012 int flags;
6013 int index;
6014 } QEMUOption;
6015
6016 const QEMUOption qemu_options[] = {
6017 { "h", 0, QEMU_OPTION_h },
6018
6019 { "M", HAS_ARG, QEMU_OPTION_M },
6020 { "fda", HAS_ARG, QEMU_OPTION_fda },
6021 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
6022 { "hda", HAS_ARG, QEMU_OPTION_hda },
6023 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
6024 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
6025 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
6026 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
6027 { "boot", HAS_ARG, QEMU_OPTION_boot },
6028 { "snapshot", 0, QEMU_OPTION_snapshot },
6029 #ifdef TARGET_I386
6030 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
6031 #endif
6032 { "m", HAS_ARG, QEMU_OPTION_m },
6033 { "nographic", 0, QEMU_OPTION_nographic },
6034 { "k", HAS_ARG, QEMU_OPTION_k },
6035 #ifdef HAS_AUDIO
6036 { "audio-help", 0, QEMU_OPTION_audio_help },
6037 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
6038 #endif
6039
6040 { "net", HAS_ARG, QEMU_OPTION_net},
6041 #ifdef CONFIG_SLIRP
6042 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
6043 #ifndef _WIN32
6044 { "smb", HAS_ARG, QEMU_OPTION_smb },
6045 #endif
6046 { "redir", HAS_ARG, QEMU_OPTION_redir },
6047 #endif
6048
6049 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
6050 { "append", HAS_ARG, QEMU_OPTION_append },
6051 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
6052
6053 { "S", 0, QEMU_OPTION_S },
6054 { "s", 0, QEMU_OPTION_s },
6055 { "p", HAS_ARG, QEMU_OPTION_p },
6056 { "d", HAS_ARG, QEMU_OPTION_d },
6057 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
6058 { "L", HAS_ARG, QEMU_OPTION_L },
6059 { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
6060 #ifdef USE_KQEMU
6061 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
6062 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
6063 #endif
6064 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
6065 { "g", 1, QEMU_OPTION_g },
6066 #endif
6067 { "localtime", 0, QEMU_OPTION_localtime },
6068 { "std-vga", 0, QEMU_OPTION_std_vga },
6069 { "monitor", 1, QEMU_OPTION_monitor },
6070 { "serial", 1, QEMU_OPTION_serial },
6071 { "parallel", 1, QEMU_OPTION_parallel },
6072 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
6073 { "full-screen", 0, QEMU_OPTION_full_screen },
6074 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
6075 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
6076 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
6077 { "smp", HAS_ARG, QEMU_OPTION_smp },
6078 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
6079
6080 /* temporary options */
6081 { "usb", 0, QEMU_OPTION_usb },
6082 { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
6083 { "no-acpi", 0, QEMU_OPTION_no_acpi },
6084 { NULL },
6085 };
6086
6087 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
6088
6089 /* this stack is only used during signal handling */
6090 #define SIGNAL_STACK_SIZE 32768
6091
6092 static uint8_t *signal_stack;
6093
6094 #endif
6095
6096 /* password input */
6097
6098 static BlockDriverState *get_bdrv(int index)
6099 {
6100 BlockDriverState *bs;
6101
6102 if (index < 4) {
6103 bs = bs_table[index];
6104 } else if (index < 6) {
6105 bs = fd_table[index - 4];
6106 } else {
6107 bs = NULL;
6108 }
6109 return bs;
6110 }
6111
6112 static void read_passwords(void)
6113 {
6114 BlockDriverState *bs;
6115 int i, j;
6116 char password[256];
6117
6118 for(i = 0; i < 6; i++) {
6119 bs = get_bdrv(i);
6120 if (bs && bdrv_is_encrypted(bs)) {
6121 term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
6122 for(j = 0; j < 3; j++) {
6123 monitor_readline("Password: ",
6124 1, password, sizeof(password));
6125 if (bdrv_set_key(bs, password) == 0)
6126 break;
6127 term_printf("invalid password\n");
6128 }
6129 }
6130 }
6131 }
6132
6133 /* XXX: currently we cannot use simultaneously different CPUs */
6134 void register_machines(void)
6135 {
6136 #if defined(TARGET_I386)
6137 qemu_register_machine(&pc_machine);
6138 qemu_register_machine(&isapc_machine);
6139 #elif defined(TARGET_PPC)
6140 qemu_register_machine(&heathrow_machine);
6141 qemu_register_machine(&core99_machine);
6142 qemu_register_machine(&prep_machine);
6143 #elif defined(TARGET_MIPS)
6144 qemu_register_machine(&mips_machine);
6145 #elif defined(TARGET_SPARC)
6146 #ifdef TARGET_SPARC64
6147 qemu_register_machine(&sun4u_machine);
6148 #else
6149 qemu_register_machine(&sun4m_machine);
6150 #endif
6151 #elif defined(TARGET_ARM)
6152 qemu_register_machine(&integratorcp926_machine);
6153 qemu_register_machine(&integratorcp1026_machine);
6154 qemu_register_machine(&versatilepb_machine);
6155 qemu_register_machine(&versatileab_machine);
6156 qemu_register_machine(&realview_machine);
6157 #elif defined(TARGET_SH4)
6158 qemu_register_machine(&shix_machine);
6159 #else
6160 #error unsupported CPU
6161 #endif
6162 }
6163
6164 #ifdef HAS_AUDIO
6165 struct soundhw soundhw[] = {
6166 #ifdef TARGET_I386
6167 {
6168 "pcspk",
6169 "PC speaker",
6170 0,
6171 1,
6172 { .init_isa = pcspk_audio_init }
6173 },
6174 #endif
6175 {
6176 "sb16",
6177 "Creative Sound Blaster 16",
6178 0,
6179 1,
6180 { .init_isa = SB16_init }
6181 },
6182
6183 #ifdef CONFIG_ADLIB
6184 {
6185 "adlib",
6186 #ifdef HAS_YMF262
6187 "Yamaha YMF262 (OPL3)",
6188 #else
6189 "Yamaha YM3812 (OPL2)",
6190 #endif
6191 0,
6192 1,
6193 { .init_isa = Adlib_init }
6194 },
6195 #endif
6196
6197 #ifdef CONFIG_GUS
6198 {
6199 "gus",
6200 "Gravis Ultrasound GF1",
6201 0,
6202 1,
6203 { .init_isa = GUS_init }
6204 },
6205 #endif
6206
6207 {
6208 "es1370",
6209 "ENSONIQ AudioPCI ES1370",
6210 0,
6211 0,
6212 { .init_pci = es1370_init }
6213 },
6214
6215 { NULL, NULL, 0, 0, { NULL } }
6216 };
6217
6218 static void select_soundhw (const char *optarg)
6219 {
6220 struct soundhw *c;
6221
6222 if (*optarg == '?') {
6223 show_valid_cards:
6224
6225 printf ("Valid sound card names (comma separated):\n");
6226 for (c = soundhw; c->name; ++c) {
6227 printf ("%-11s %s\n", c->name, c->descr);
6228 }
6229 printf ("\n-soundhw all will enable all of the above\n");
6230 exit (*optarg != '?');
6231 }
6232 else {
6233 size_t l;
6234 const char *p;
6235 char *e;
6236 int bad_card = 0;
6237
6238 if (!strcmp (optarg, "all")) {
6239 for (c = soundhw; c->name; ++c) {
6240 c->enabled = 1;
6241 }
6242 return;
6243 }
6244
6245 p = optarg;
6246 while (*p) {
6247 e = strchr (p, ',');
6248 l = !e ? strlen (p) : (size_t) (e - p);
6249
6250 for (c = soundhw; c->name; ++c) {
6251 if (!strncmp (c->name, p, l)) {
6252 c->enabled = 1;
6253 break;
6254 }
6255 }
6256
6257 if (!c->name) {
6258 if (l > 80) {
6259 fprintf (stderr,
6260 "Unknown sound card name (too big to show)\n");
6261 }
6262 else {
6263 fprintf (stderr, "Unknown sound card name `%.*s'\n",
6264 (int) l, p);
6265 }
6266 bad_card = 1;
6267 }
6268 p += l + (e != NULL);
6269 }
6270
6271 if (bad_card)
6272 goto show_valid_cards;
6273 }
6274 }
6275 #endif
6276
6277 #ifdef _WIN32
6278 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
6279 {
6280 exit(STATUS_CONTROL_C_EXIT);
6281 return TRUE;
6282 }
6283 #endif
6284
6285 #define MAX_NET_CLIENTS 32
6286
6287 int main(int argc, char **argv)
6288 {
6289 #ifdef CONFIG_GDBSTUB
6290 int use_gdbstub, gdbstub_port;
6291 #endif
6292 int i, cdrom_index;
6293 int snapshot, linux_boot;
6294 const char *initrd_filename;
6295 const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
6296 const char *kernel_filename, *kernel_cmdline;
6297 DisplayState *ds = &display_state;
6298 int cyls, heads, secs, translation;
6299 int start_emulation = 1;
6300 char net_clients[MAX_NET_CLIENTS][256];
6301 int nb_net_clients;
6302 int optind;
6303 const char *r, *optarg;
6304 CharDriverState *monitor_hd;
6305 char monitor_device[128];
6306 char serial_devices[MAX_SERIAL_PORTS][128];
6307 int serial_device_index;
6308 char parallel_devices[MAX_PARALLEL_PORTS][128];
6309 int parallel_device_index;
6310 const char *loadvm = NULL;
6311 QEMUMachine *machine;
6312 char usb_devices[MAX_USB_CMDLINE][128];
6313 int usb_devices_index;
6314
6315 LIST_INIT (&vm_change_state_head);
6316 #ifndef _WIN32
6317 {
6318 struct sigaction act;
6319 sigfillset(&act.sa_mask);
6320 act.sa_flags = 0;
6321 act.sa_handler = SIG_IGN;
6322 sigaction(SIGPIPE, &act, NULL);
6323 }
6324 #else
6325 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
6326 /* Note: cpu_interrupt() is currently not SMP safe, so we force
6327 QEMU to run on a single CPU */
6328 {
6329 HANDLE h;
6330 DWORD mask, smask;
6331 int i;
6332 h = GetCurrentProcess();
6333 if (GetProcessAffinityMask(h, &mask, &smask)) {
6334 for(i = 0; i < 32; i++) {
6335 if (mask & (1 << i))
6336 break;
6337 }
6338 if (i != 32) {
6339 mask = 1 << i;
6340 SetProcessAffinityMask(h, mask);
6341 }
6342 }
6343 }
6344 #endif
6345
6346 register_machines();
6347 machine = first_machine;
6348 initrd_filename = NULL;
6349 for(i = 0; i < MAX_FD; i++)
6350 fd_filename[i] = NULL;
6351 for(i = 0; i < MAX_DISKS; i++)
6352 hd_filename[i] = NULL;
6353 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
6354 vga_ram_size = VGA_RAM_SIZE;
6355 bios_size = BIOS_SIZE;
6356 #ifdef CONFIG_GDBSTUB
6357 use_gdbstub = 0;
6358 gdbstub_port = DEFAULT_GDBSTUB_PORT;
6359 #endif
6360 snapshot = 0;
6361 nographic = 0;
6362 kernel_filename = NULL;
6363 kernel_cmdline = "";
6364 #ifdef TARGET_PPC
6365 cdrom_index = 1;
6366 #else
6367 cdrom_index = 2;
6368 #endif
6369 cyls = heads = secs = 0;
6370 translation = BIOS_ATA_TRANSLATION_AUTO;
6371 pstrcpy(monitor_device, sizeof(monitor_device), "vc");
6372
6373 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
6374 for(i = 1; i < MAX_SERIAL_PORTS; i++)
6375 serial_devices[i][0] = '\0';
6376 serial_device_index = 0;
6377
6378 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
6379 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
6380 parallel_devices[i][0] = '\0';
6381 parallel_device_index = 0;
6382
6383 usb_devices_index = 0;
6384
6385 nb_net_clients = 0;
6386
6387 nb_nics = 0;
6388 /* default mac address of the first network interface */
6389
6390 optind = 1;
6391 for(;;) {
6392 if (optind >= argc)
6393 break;
6394 r = argv[optind];
6395 if (r[0] != '-') {
6396 hd_filename[0] = argv[optind++];
6397 } else {
6398 const QEMUOption *popt;
6399
6400 optind++;
6401 popt = qemu_options;
6402 for(;;) {
6403 if (!popt->name) {
6404 fprintf(stderr, "%s: invalid option -- '%s'\n",
6405 argv[0], r);
6406 exit(1);
6407 }
6408 if (!strcmp(popt->name, r + 1))
6409 break;
6410 popt++;
6411 }
6412 if (popt->flags & HAS_ARG) {
6413 if (optind >= argc) {
6414 fprintf(stderr, "%s: option '%s' requires an argument\n",
6415 argv[0], r);
6416 exit(1);
6417 }
6418 optarg = argv[optind++];
6419 } else {
6420 optarg = NULL;
6421 }
6422
6423 switch(popt->index) {
6424 case QEMU_OPTION_M:
6425 machine = find_machine(optarg);
6426 if (!machine) {
6427 QEMUMachine *m;
6428 printf("Supported machines are:\n");
6429 for(m = first_machine; m != NULL; m = m->next) {
6430 printf("%-10s %s%s\n",
6431 m->name, m->desc,
6432 m == first_machine ? " (default)" : "");
6433 }
6434 exit(1);
6435 }
6436 break;
6437 case QEMU_OPTION_initrd:
6438 initrd_filename = optarg;
6439 break;
6440 case QEMU_OPTION_hda:
6441 case QEMU_OPTION_hdb:
6442 case QEMU_OPTION_hdc:
6443 case QEMU_OPTION_hdd:
6444 {
6445 int hd_index;
6446 hd_index = popt->index - QEMU_OPTION_hda;
6447 hd_filename[hd_index] = optarg;
6448 if (hd_index == cdrom_index)
6449 cdrom_index = -1;
6450 }
6451 break;
6452 case QEMU_OPTION_snapshot:
6453 snapshot = 1;
6454 break;
6455 case QEMU_OPTION_hdachs:
6456 {
6457 const char *p;
6458 p = optarg;
6459 cyls = strtol(p, (char **)&p, 0);
6460 if (cyls < 1 || cyls > 16383)
6461 goto chs_fail;
6462 if (*p != ',')
6463 goto chs_fail;
6464 p++;
6465 heads = strtol(p, (char **)&p, 0);
6466 if (heads < 1 || heads > 16)
6467 goto chs_fail;
6468 if (*p != ',')
6469 goto chs_fail;
6470 p++;
6471 secs = strtol(p, (char **)&p, 0);
6472 if (secs < 1 || secs > 63)
6473 goto chs_fail;
6474 if (*p == ',') {
6475 p++;
6476 if (!strcmp(p, "none"))
6477 translation = BIOS_ATA_TRANSLATION_NONE;
6478 else if (!strcmp(p, "lba"))
6479 translation = BIOS_ATA_TRANSLATION_LBA;
6480 else if (!strcmp(p, "auto"))
6481 translation = BIOS_ATA_TRANSLATION_AUTO;
6482 else
6483 goto chs_fail;
6484 } else if (*p != '\0') {
6485 chs_fail:
6486 fprintf(stderr, "qemu: invalid physical CHS format\n");
6487 exit(1);
6488 }
6489 }
6490 break;
6491 case QEMU_OPTION_nographic:
6492 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
6493 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
6494 nographic = 1;
6495 break;
6496 case QEMU_OPTION_kernel:
6497 kernel_filename = optarg;
6498 break;
6499 case QEMU_OPTION_append:
6500 kernel_cmdline = optarg;
6501 break;
6502 case QEMU_OPTION_cdrom:
6503 if (cdrom_index >= 0) {
6504 hd_filename[cdrom_index] = optarg;
6505 }
6506 break;
6507 case QEMU_OPTION_boot:
6508 boot_device = optarg[0];
6509 if (boot_device != 'a' &&
6510 #ifdef TARGET_SPARC
6511 // Network boot
6512 boot_device != 'n' &&
6513 #endif
6514 boot_device != 'c' && boot_device != 'd') {
6515 fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
6516 exit(1);
6517 }
6518 break;
6519 case QEMU_OPTION_fda:
6520 fd_filename[0] = optarg;
6521 break;
6522 case QEMU_OPTION_fdb:
6523 fd_filename[1] = optarg;
6524 break;
6525 #ifdef TARGET_I386
6526 case QEMU_OPTION_no_fd_bootchk:
6527 fd_bootchk = 0;
6528 break;
6529 #endif
6530 case QEMU_OPTION_no_code_copy:
6531 code_copy_enabled = 0;
6532 break;
6533 case QEMU_OPTION_net:
6534 if (nb_net_clients >= MAX_NET_CLIENTS) {
6535 fprintf(stderr, "qemu: too many network clients\n");
6536 exit(1);
6537 }
6538 pstrcpy(net_clients[nb_net_clients],
6539 sizeof(net_clients[0]),
6540 optarg);
6541 nb_net_clients++;
6542 break;
6543 #ifdef CONFIG_SLIRP
6544 case QEMU_OPTION_tftp:
6545 tftp_prefix = optarg;
6546 break;
6547 #ifndef _WIN32
6548 case QEMU_OPTION_smb:
6549 net_slirp_smb(optarg);
6550 break;
6551 #endif
6552 case QEMU_OPTION_redir:
6553 net_slirp_redir(optarg);
6554 break;
6555 #endif
6556 #ifdef HAS_AUDIO
6557 case QEMU_OPTION_audio_help:
6558 AUD_help ();
6559 exit (0);
6560 break;
6561 case QEMU_OPTION_soundhw:
6562 select_soundhw (optarg);
6563 break;
6564 #endif
6565 case QEMU_OPTION_h:
6566 help();
6567 break;
6568 case QEMU_OPTION_m:
6569 ram_size = atoi(optarg) * 1024 * 1024;
6570 if (ram_size <= 0)
6571 help();
6572 if (ram_size > PHYS_RAM_MAX_SIZE) {
6573 fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
6574 PHYS_RAM_MAX_SIZE / (1024 * 1024));
6575 exit(1);
6576 }
6577 break;
6578 case QEMU_OPTION_d:
6579 {
6580 int mask;
6581 CPULogItem *item;
6582
6583 mask = cpu_str_to_log_mask(optarg);
6584 if (!mask) {
6585 printf("Log items (comma separated):\n");
6586 for(item = cpu_log_items; item->mask != 0; item++) {
6587 printf("%-10s %s\n", item->name, item->help);
6588 }
6589 exit(1);
6590 }
6591 cpu_set_log(mask);
6592 }
6593 break;
6594 #ifdef CONFIG_GDBSTUB
6595 case QEMU_OPTION_s:
6596 use_gdbstub = 1;
6597 break;
6598 case QEMU_OPTION_p:
6599 gdbstub_port = atoi(optarg);
6600 break;
6601 #endif
6602 case QEMU_OPTION_L:
6603 bios_dir = optarg;
6604 break;
6605 case QEMU_OPTION_S:
6606 start_emulation = 0;
6607 break;
6608 case QEMU_OPTION_k:
6609 keyboard_layout = optarg;
6610 break;
6611 case QEMU_OPTION_localtime:
6612 rtc_utc = 0;
6613 break;
6614 case QEMU_OPTION_cirrusvga:
6615 cirrus_vga_enabled = 1;
6616 break;
6617 case QEMU_OPTION_std_vga:
6618 cirrus_vga_enabled = 0;
6619 break;
6620 case QEMU_OPTION_g:
6621 {
6622 const char *p;
6623 int w, h, depth;
6624 p = optarg;
6625 w = strtol(p, (char **)&p, 10);
6626 if (w <= 0) {
6627 graphic_error:
6628 fprintf(stderr, "qemu: invalid resolution or depth\n");
6629 exit(1);
6630 }
6631 if (*p != 'x')
6632 goto graphic_error;
6633 p++;
6634 h = strtol(p, (char **)&p, 10);
6635 if (h <= 0)
6636 goto graphic_error;
6637 if (*p == 'x') {
6638 p++;
6639 depth = strtol(p, (char **)&p, 10);
6640 if (depth != 8 && depth != 15 && depth != 16 &&
6641 depth != 24 && depth != 32)
6642 goto graphic_error;
6643 } else if (*p == '\0') {
6644 depth = graphic_depth;
6645 } else {
6646 goto graphic_error;
6647 }
6648
6649 graphic_width = w;
6650 graphic_height = h;
6651 graphic_depth = depth;
6652 }
6653 break;
6654 case QEMU_OPTION_monitor:
6655 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
6656 break;
6657 case QEMU_OPTION_serial:
6658 if (serial_device_index >= MAX_SERIAL_PORTS) {
6659 fprintf(stderr, "qemu: too many serial ports\n");
6660 exit(1);
6661 }
6662 pstrcpy(serial_devices[serial_device_index],
6663 sizeof(serial_devices[0]), optarg);
6664 serial_device_index++;
6665 break;
6666 case QEMU_OPTION_parallel:
6667 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
6668 fprintf(stderr, "qemu: too many parallel ports\n");
6669 exit(1);
6670 }
6671 pstrcpy(parallel_devices[parallel_device_index],
6672 sizeof(parallel_devices[0]), optarg);
6673 parallel_device_index++;
6674 break;
6675 case QEMU_OPTION_loadvm:
6676 loadvm = optarg;
6677 break;
6678 case QEMU_OPTION_full_screen:
6679 full_screen = 1;
6680 break;
6681 case QEMU_OPTION_pidfile:
6682 create_pidfile(optarg);
6683 break;
6684 #ifdef TARGET_I386
6685 case QEMU_OPTION_win2k_hack:
6686 win2k_install_hack = 1;
6687 break;
6688 #endif
6689 #ifdef USE_KQEMU
6690 case QEMU_OPTION_no_kqemu:
6691 kqemu_allowed = 0;
6692 break;
6693 case QEMU_OPTION_kernel_kqemu:
6694 kqemu_allowed = 2;
6695 break;
6696 #endif
6697 case QEMU_OPTION_usb:
6698 usb_enabled = 1;
6699 break;
6700 case QEMU_OPTION_usbdevice:
6701 usb_enabled = 1;
6702 if (usb_devices_index >= MAX_USB_CMDLINE) {
6703 fprintf(stderr, "Too many USB devices\n");
6704 exit(1);
6705 }
6706 pstrcpy(usb_devices[usb_devices_index],
6707 sizeof(usb_devices[usb_devices_index]),
6708 optarg);
6709 usb_devices_index++;
6710 break;
6711 case QEMU_OPTION_smp:
6712 smp_cpus = atoi(optarg);
6713 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
6714 fprintf(stderr, "Invalid number of CPUs\n");
6715 exit(1);
6716 }
6717 break;
6718 case QEMU_OPTION_vnc:
6719 vnc_display = atoi(optarg);
6720 if (vnc_display < 0) {
6721 fprintf(stderr, "Invalid VNC display\n");
6722 exit(1);
6723 }
6724 break;
6725 case QEMU_OPTION_no_acpi:
6726 acpi_enabled = 0;
6727 break;
6728 }
6729 }
6730 }
6731
6732 #ifdef USE_KQEMU
6733 if (smp_cpus > 1)
6734 kqemu_allowed = 0;
6735 #endif
6736 linux_boot = (kernel_filename != NULL);
6737
6738 if (!linux_boot &&
6739 hd_filename[0] == '\0' &&
6740 (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') &&
6741 fd_filename[0] == '\0')
6742 help();
6743
6744 /* boot to cd by default if no hard disk */
6745 if (hd_filename[0] == '\0' && boot_device == 'c') {
6746 if (fd_filename[0] != '\0')
6747 boot_device = 'a';
6748 else
6749 boot_device = 'd';
6750 }
6751
6752 setvbuf(stdout, NULL, _IOLBF, 0);
6753
6754 init_timers();
6755 init_timer_alarm();
6756 qemu_aio_init();
6757
6758 #ifdef _WIN32
6759 socket_init();
6760 #endif
6761
6762 /* init network clients */
6763 if (nb_net_clients == 0) {
6764 /* if no clients, we use a default config */
6765 pstrcpy(net_clients[0], sizeof(net_clients[0]),
6766 "nic");
6767 pstrcpy(net_clients[1], sizeof(net_clients[0]),
6768 "user");
6769 nb_net_clients = 2;
6770 }
6771
6772 for(i = 0;i < nb_net_clients; i++) {
6773 if (net_client_init(net_clients[i]) < 0)
6774 exit(1);
6775 }
6776
6777 /* init the memory */
6778 phys_ram_size = ram_size + vga_ram_size + bios_size;
6779
6780 phys_ram_base = qemu_vmalloc(phys_ram_size);
6781 if (!phys_ram_base) {
6782 fprintf(stderr, "Could not allocate physical memory\n");
6783 exit(1);
6784 }
6785
6786 /* we always create the cdrom drive, even if no disk is there */
6787 bdrv_init();
6788 if (cdrom_index >= 0) {
6789 bs_table[cdrom_index] = bdrv_new("cdrom");
6790 bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM);
6791 }
6792
6793 /* open the virtual block devices */
6794 for(i = 0; i < MAX_DISKS; i++) {
6795 if (hd_filename[i]) {
6796 if (!bs_table[i]) {
6797 char buf[64];
6798 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
6799 bs_table[i] = bdrv_new(buf);
6800 }
6801 if (bdrv_open(bs_table[i], hd_filename[i], snapshot ? BDRV_O_SNAPSHOT : 0) < 0) {
6802 fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
6803 hd_filename[i]);
6804 exit(1);
6805 }
6806 if (i == 0 && cyls != 0) {
6807 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
6808 bdrv_set_translation_hint(bs_table[i], translation);
6809 }
6810 }
6811 }
6812
6813 /* we always create at least one floppy disk */
6814 fd_table[0] = bdrv_new("fda");
6815 bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
6816
6817 for(i = 0; i < MAX_FD; i++) {
6818 if (fd_filename[i]) {
6819 if (!fd_table[i]) {
6820 char buf[64];
6821 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
6822 fd_table[i] = bdrv_new(buf);
6823 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
6824 }
6825 if (fd_filename[i] != '\0') {
6826 if (bdrv_open(fd_table[i], fd_filename[i],
6827 snapshot ? BDRV_O_SNAPSHOT : 0) < 0) {
6828 fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
6829 fd_filename[i]);
6830 exit(1);
6831 }
6832 }
6833 }
6834 }
6835
6836 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
6837 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
6838
6839 init_ioports();
6840
6841 /* terminal init */
6842 if (nographic) {
6843 dumb_display_init(ds);
6844 } else if (vnc_display != -1) {
6845 vnc_display_init(ds, vnc_display);
6846 } else {
6847 #if defined(CONFIG_SDL)
6848 sdl_display_init(ds, full_screen);
6849 #elif defined(CONFIG_COCOA)
6850 cocoa_display_init(ds, full_screen);
6851 #else
6852 dumb_display_init(ds);
6853 #endif
6854 }
6855
6856 monitor_hd = qemu_chr_open(monitor_device);
6857 if (!monitor_hd) {
6858 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
6859 exit(1);
6860 }
6861 monitor_init(monitor_hd, !nographic);
6862
6863 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6864 const char *devname = serial_devices[i];
6865 if (devname[0] != '\0' && strcmp(devname, "none")) {
6866 serial_hds[i] = qemu_chr_open(devname);
6867 if (!serial_hds[i]) {
6868 fprintf(stderr, "qemu: could not open serial device '%s'\n",
6869 devname);
6870 exit(1);
6871 }
6872 if (!strcmp(devname, "vc"))
6873 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
6874 }
6875 }
6876
6877 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6878 const char *devname = parallel_devices[i];
6879 if (devname[0] != '\0' && strcmp(devname, "none")) {
6880 parallel_hds[i] = qemu_chr_open(devname);
6881 if (!parallel_hds[i]) {
6882 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
6883 devname);
6884 exit(1);
6885 }
6886 if (!strcmp(devname, "vc"))
6887 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6888 }
6889 }
6890
6891 machine->init(ram_size, vga_ram_size, boot_device,
6892 ds, fd_filename, snapshot,
6893 kernel_filename, kernel_cmdline, initrd_filename);
6894
6895 /* init USB devices */
6896 if (usb_enabled) {
6897 for(i = 0; i < usb_devices_index; i++) {
6898 if (usb_device_add(usb_devices[i]) < 0) {
6899 fprintf(stderr, "Warning: could not add USB device %s\n",
6900 usb_devices[i]);
6901 }
6902 }
6903 }
6904
6905 gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
6906 qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
6907
6908 #ifdef CONFIG_GDBSTUB
6909 if (use_gdbstub) {
6910 if (gdbserver_start(gdbstub_port) < 0) {
6911 fprintf(stderr, "Could not open gdbserver socket on port %d\n",
6912 gdbstub_port);
6913 exit(1);
6914 } else {
6915 printf("Waiting gdb connection on port %d\n", gdbstub_port);
6916 }
6917 } else
6918 #endif
6919 if (loadvm)
6920 do_loadvm(loadvm);
6921
6922 {
6923 /* XXX: simplify init */
6924 read_passwords();
6925 if (start_emulation) {
6926 vm_start();
6927 }
6928 }
6929 main_loop();
6930 quit_timers();
6931 return 0;
6932 }
Samsung s3c2440 and arm920t support for the mini2440 dev board