?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update sparc bios image (Blue Swirl).
[qemu/mini2440.git] / vl.c
blobd422fedcf0f7c3751ed5593338ba8996dcdaa9e7
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 }
4885
4886 #ifdef USE_X86LDOUBLE
4887 /* XXX: add that in a FPU generic layer */
4888 union x86_longdouble {
4889 uint64_t mant;
4890 uint16_t exp;
4891 };
4892
4893 #define MANTD1(fp) (fp & ((1LL << 52) - 1))
4894 #define EXPBIAS1 1023
4895 #define EXPD1(fp) ((fp >> 52) & 0x7FF)
4896 #define SIGND1(fp) ((fp >> 32) & 0x80000000)
4897
4898 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
4899 {
4900 int e;
4901 /* mantissa */
4902 p->mant = (MANTD1(temp) << 11) | (1LL << 63);
4903 /* exponent + sign */
4904 e = EXPD1(temp) - EXPBIAS1 + 16383;
4905 e |= SIGND1(temp) >> 16;
4906 p->exp = e;
4907 }
4908 #endif
4909
4910 int cpu_load(QEMUFile *f, void *opaque, int version_id)
4911 {
4912 CPUState *env = opaque;
4913 int i, guess_mmx;
4914 uint32_t hflags;
4915 uint16_t fpus, fpuc, fptag, fpregs_format;
4916
4917 if (version_id != 3)
4918 return -EINVAL;
4919 for(i = 0; i < CPU_NB_REGS; i++)
4920 qemu_get_betls(f, &env->regs[i]);
4921 qemu_get_betls(f, &env->eip);
4922 qemu_get_betls(f, &env->eflags);
4923 qemu_get_be32s(f, &hflags);
4924
4925 qemu_get_be16s(f, &fpuc);
4926 qemu_get_be16s(f, &fpus);
4927 qemu_get_be16s(f, &fptag);
4928 qemu_get_be16s(f, &fpregs_format);
4929
4930 /* NOTE: we cannot always restore the FPU state if the image come
4931 from a host with a different 'USE_X86LDOUBLE' define. We guess
4932 if we are in an MMX state to restore correctly in that case. */
4933 guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
4934 for(i = 0; i < 8; i++) {
4935 uint64_t mant;
4936 uint16_t exp;
4937
4938 switch(fpregs_format) {
4939 case 0:
4940 mant = qemu_get_be64(f);
4941 exp = qemu_get_be16(f);
4942 #ifdef USE_X86LDOUBLE
4943 env->fpregs[i].d = cpu_set_fp80(mant, exp);
4944 #else
4945 /* difficult case */
4946 if (guess_mmx)
4947 env->fpregs[i].mmx.MMX_Q(0) = mant;
4948 else
4949 env->fpregs[i].d = cpu_set_fp80(mant, exp);
4950 #endif
4951 break;
4952 case 1:
4953 mant = qemu_get_be64(f);
4954 #ifdef USE_X86LDOUBLE
4955 {
4956 union x86_longdouble *p;
4957 /* difficult case */
4958 p = (void *)&env->fpregs[i];
4959 if (guess_mmx) {
4960 p->mant = mant;
4961 p->exp = 0xffff;
4962 } else {
4963 fp64_to_fp80(p, mant);
4964 }
4965 }
4966 #else
4967 env->fpregs[i].mmx.MMX_Q(0) = mant;
4968 #endif
4969 break;
4970 default:
4971 return -EINVAL;
4972 }
4973 }
4974
4975 env->fpuc = fpuc;
4976 /* XXX: restore FPU round state */
4977 env->fpstt = (fpus >> 11) & 7;
4978 env->fpus = fpus & ~0x3800;
4979 fptag ^= 0xff;
4980 for(i = 0; i < 8; i++) {
4981 env->fptags[i] = (fptag >> i) & 1;
4982 }
4983
4984 for(i = 0; i < 6; i++)
4985 cpu_get_seg(f, &env->segs[i]);
4986 cpu_get_seg(f, &env->ldt);
4987 cpu_get_seg(f, &env->tr);
4988 cpu_get_seg(f, &env->gdt);
4989 cpu_get_seg(f, &env->idt);
4990
4991 qemu_get_be32s(f, &env->sysenter_cs);
4992 qemu_get_be32s(f, &env->sysenter_esp);
4993 qemu_get_be32s(f, &env->sysenter_eip);
4994
4995 qemu_get_betls(f, &env->cr[0]);
4996 qemu_get_betls(f, &env->cr[2]);
4997 qemu_get_betls(f, &env->cr[3]);
4998 qemu_get_betls(f, &env->cr[4]);
4999
5000 for(i = 0; i < 8; i++)
5001 qemu_get_betls(f, &env->dr[i]);
5002
5003 /* MMU */
5004 qemu_get_be32s(f, &env->a20_mask);
5005
5006 qemu_get_be32s(f, &env->mxcsr);
5007 for(i = 0; i < CPU_NB_REGS; i++) {
5008 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
5009 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
5010 }
5011
5012 #ifdef TARGET_X86_64
5013 qemu_get_be64s(f, &env->efer);
5014 qemu_get_be64s(f, &env->star);
5015 qemu_get_be64s(f, &env->lstar);
5016 qemu_get_be64s(f, &env->cstar);
5017 qemu_get_be64s(f, &env->fmask);
5018 qemu_get_be64s(f, &env->kernelgsbase);
5019 #endif
5020
5021 /* XXX: compute hflags from scratch, except for CPL and IIF */
5022 env->hflags = hflags;
5023 tlb_flush(env, 1);
5024 return 0;
5025 }
5026
5027 #elif defined(TARGET_PPC)
5028 void cpu_save(QEMUFile *f, void *opaque)
5029 {
5030 }
5031
5032 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5033 {
5034 return 0;
5035 }
5036
5037 #elif defined(TARGET_MIPS)
5038 void cpu_save(QEMUFile *f, void *opaque)
5039 {
5040 }
5041
5042 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5043 {
5044 return 0;
5045 }
5046
5047 #elif defined(TARGET_SPARC)
5048 void cpu_save(QEMUFile *f, void *opaque)
5049 {
5050 CPUState *env = opaque;
5051 int i;
5052 uint32_t tmp;
5053
5054 for(i = 0; i < 8; i++)
5055 qemu_put_betls(f, &env->gregs[i]);
5056 for(i = 0; i < NWINDOWS * 16; i++)
5057 qemu_put_betls(f, &env->regbase[i]);
5058
5059 /* FPU */
5060 for(i = 0; i < TARGET_FPREGS; i++) {
5061 union {
5062 float32 f;
5063 uint32_t i;
5064 } u;
5065 u.f = env->fpr[i];
5066 qemu_put_be32(f, u.i);
5067 }
5068
5069 qemu_put_betls(f, &env->pc);
5070 qemu_put_betls(f, &env->npc);
5071 qemu_put_betls(f, &env->y);
5072 tmp = GET_PSR(env);
5073 qemu_put_be32(f, tmp);
5074 qemu_put_betls(f, &env->fsr);
5075 qemu_put_betls(f, &env->tbr);
5076 #ifndef TARGET_SPARC64
5077 qemu_put_be32s(f, &env->wim);
5078 /* MMU */
5079 for(i = 0; i < 16; i++)
5080 qemu_put_be32s(f, &env->mmuregs[i]);
5081 #endif
5082 }
5083
5084 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5085 {
5086 CPUState *env = opaque;
5087 int i;
5088 uint32_t tmp;
5089
5090 for(i = 0; i < 8; i++)
5091 qemu_get_betls(f, &env->gregs[i]);
5092 for(i = 0; i < NWINDOWS * 16; i++)
5093 qemu_get_betls(f, &env->regbase[i]);
5094
5095 /* FPU */
5096 for(i = 0; i < TARGET_FPREGS; i++) {
5097 union {
5098 float32 f;
5099 uint32_t i;
5100 } u;
5101 u.i = qemu_get_be32(f);
5102 env->fpr[i] = u.f;
5103 }
5104
5105 qemu_get_betls(f, &env->pc);
5106 qemu_get_betls(f, &env->npc);
5107 qemu_get_betls(f, &env->y);
5108 tmp = qemu_get_be32(f);
5109 env->cwp = 0; /* needed to ensure that the wrapping registers are
5110 correctly updated */
5111 PUT_PSR(env, tmp);
5112 qemu_get_betls(f, &env->fsr);
5113 qemu_get_betls(f, &env->tbr);
5114 #ifndef TARGET_SPARC64
5115 qemu_get_be32s(f, &env->wim);
5116 /* MMU */
5117 for(i = 0; i < 16; i++)
5118 qemu_get_be32s(f, &env->mmuregs[i]);
5119 #endif
5120 tlb_flush(env, 1);
5121 return 0;
5122 }
5123
5124 #elif defined(TARGET_ARM)
5125
5126 /* ??? Need to implement these. */
5127 void cpu_save(QEMUFile *f, void *opaque)
5128 {
5129 }
5130
5131 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5132 {
5133 return 0;
5134 }
5135
5136 #else
5137
5138 #warning No CPU save/restore functions
5139
5140 #endif
5141
5142 /***********************************************************/
5143 /* ram save/restore */
5144
5145 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
5146 {
5147 int v;
5148
5149 v = qemu_get_byte(f);
5150 switch(v) {
5151 case 0:
5152 if (qemu_get_buffer(f, buf, len) != len)
5153 return -EIO;
5154 break;
5155 case 1:
5156 v = qemu_get_byte(f);
5157 memset(buf, v, len);
5158 break;
5159 default:
5160 return -EINVAL;
5161 }
5162 return 0;
5163 }
5164
5165 static int ram_load_v1(QEMUFile *f, void *opaque)
5166 {
5167 int i, ret;
5168
5169 if (qemu_get_be32(f) != phys_ram_size)
5170 return -EINVAL;
5171 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
5172 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
5173 if (ret)
5174 return ret;
5175 }
5176 return 0;
5177 }
5178
5179 #define BDRV_HASH_BLOCK_SIZE 1024
5180 #define IOBUF_SIZE 4096
5181 #define RAM_CBLOCK_MAGIC 0xfabe
5182
5183 typedef struct RamCompressState {
5184 z_stream zstream;
5185 QEMUFile *f;
5186 uint8_t buf[IOBUF_SIZE];
5187 } RamCompressState;
5188
5189 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
5190 {
5191 int ret;
5192 memset(s, 0, sizeof(*s));
5193 s->f = f;
5194 ret = deflateInit2(&s->zstream, 1,
5195 Z_DEFLATED, 15,
5196 9, Z_DEFAULT_STRATEGY);
5197 if (ret != Z_OK)
5198 return -1;
5199 s->zstream.avail_out = IOBUF_SIZE;
5200 s->zstream.next_out = s->buf;
5201 return 0;
5202 }
5203
5204 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
5205 {
5206 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
5207 qemu_put_be16(s->f, len);
5208 qemu_put_buffer(s->f, buf, len);
5209 }
5210
5211 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
5212 {
5213 int ret;
5214
5215 s->zstream.avail_in = len;
5216 s->zstream.next_in = (uint8_t *)buf;
5217 while (s->zstream.avail_in > 0) {
5218 ret = deflate(&s->zstream, Z_NO_FLUSH);
5219 if (ret != Z_OK)
5220 return -1;
5221 if (s->zstream.avail_out == 0) {
5222 ram_put_cblock(s, s->buf, IOBUF_SIZE);
5223 s->zstream.avail_out = IOBUF_SIZE;
5224 s->zstream.next_out = s->buf;
5225 }
5226 }
5227 return 0;
5228 }
5229
5230 static void ram_compress_close(RamCompressState *s)
5231 {
5232 int len, ret;
5233
5234 /* compress last bytes */
5235 for(;;) {
5236 ret = deflate(&s->zstream, Z_FINISH);
5237 if (ret == Z_OK || ret == Z_STREAM_END) {
5238 len = IOBUF_SIZE - s->zstream.avail_out;
5239 if (len > 0) {
5240 ram_put_cblock(s, s->buf, len);
5241 }
5242 s->zstream.avail_out = IOBUF_SIZE;
5243 s->zstream.next_out = s->buf;
5244 if (ret == Z_STREAM_END)
5245 break;
5246 } else {
5247 goto fail;
5248 }
5249 }
5250 fail:
5251 deflateEnd(&s->zstream);
5252 }
5253
5254 typedef struct RamDecompressState {
5255 z_stream zstream;
5256 QEMUFile *f;
5257 uint8_t buf[IOBUF_SIZE];
5258 } RamDecompressState;
5259
5260 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
5261 {
5262 int ret;
5263 memset(s, 0, sizeof(*s));
5264 s->f = f;
5265 ret = inflateInit(&s->zstream);
5266 if (ret != Z_OK)
5267 return -1;
5268 return 0;
5269 }
5270
5271 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
5272 {
5273 int ret, clen;
5274
5275 s->zstream.avail_out = len;
5276 s->zstream.next_out = buf;
5277 while (s->zstream.avail_out > 0) {
5278 if (s->zstream.avail_in == 0) {
5279 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
5280 return -1;
5281 clen = qemu_get_be16(s->f);
5282 if (clen > IOBUF_SIZE)
5283 return -1;
5284 qemu_get_buffer(s->f, s->buf, clen);
5285 s->zstream.avail_in = clen;
5286 s->zstream.next_in = s->buf;
5287 }
5288 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
5289 if (ret != Z_OK && ret != Z_STREAM_END) {
5290 return -1;
5291 }
5292 }
5293 return 0;
5294 }
5295
5296 static void ram_decompress_close(RamDecompressState *s)
5297 {
5298 inflateEnd(&s->zstream);
5299 }
5300
5301 static void ram_save(QEMUFile *f, void *opaque)
5302 {
5303 int i;
5304 RamCompressState s1, *s = &s1;
5305 uint8_t buf[10];
5306
5307 qemu_put_be32(f, phys_ram_size);
5308 if (ram_compress_open(s, f) < 0)
5309 return;
5310 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
5311 #if 0
5312 if (tight_savevm_enabled) {
5313 int64_t sector_num;
5314 int j;
5315
5316 /* find if the memory block is available on a virtual
5317 block device */
5318 sector_num = -1;
5319 for(j = 0; j < MAX_DISKS; j++) {
5320 if (bs_table[j]) {
5321 sector_num = bdrv_hash_find(bs_table[j],
5322 phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
5323 if (sector_num >= 0)
5324 break;
5325 }
5326 }
5327 if (j == MAX_DISKS)
5328 goto normal_compress;
5329 buf[0] = 1;
5330 buf[1] = j;
5331 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
5332 ram_compress_buf(s, buf, 10);
5333 } else
5334 #endif
5335 {
5336 // normal_compress:
5337 buf[0] = 0;
5338 ram_compress_buf(s, buf, 1);
5339 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
5340 }
5341 }
5342 ram_compress_close(s);
5343 }
5344
5345 static int ram_load(QEMUFile *f, void *opaque, int version_id)
5346 {
5347 RamDecompressState s1, *s = &s1;
5348 uint8_t buf[10];
5349 int i;
5350
5351 if (version_id == 1)
5352 return ram_load_v1(f, opaque);
5353 if (version_id != 2)
5354 return -EINVAL;
5355 if (qemu_get_be32(f) != phys_ram_size)
5356 return -EINVAL;
5357 if (ram_decompress_open(s, f) < 0)
5358 return -EINVAL;
5359 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
5360 if (ram_decompress_buf(s, buf, 1) < 0) {
5361 fprintf(stderr, "Error while reading ram block header\n");
5362 goto error;
5363 }
5364 if (buf[0] == 0) {
5365 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
5366 fprintf(stderr, "Error while reading ram block address=0x%08x", i);
5367 goto error;
5368 }
5369 } else
5370 #if 0
5371 if (buf[0] == 1) {
5372 int bs_index;
5373 int64_t sector_num;
5374
5375 ram_decompress_buf(s, buf + 1, 9);
5376 bs_index = buf[1];
5377 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
5378 if (bs_index >= MAX_DISKS || bs_table[bs_index] == NULL) {
5379 fprintf(stderr, "Invalid block device index %d\n", bs_index);
5380 goto error;
5381 }
5382 if (bdrv_read(bs_table[bs_index], sector_num, phys_ram_base + i,
5383 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
5384 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
5385 bs_index, sector_num);
5386 goto error;
5387 }
5388 } else
5389 #endif
5390 {
5391 error:
5392 printf("Error block header\n");
5393 return -EINVAL;
5394 }
5395 }
5396 ram_decompress_close(s);
5397 return 0;
5398 }
5399
5400 /***********************************************************/
5401 /* bottom halves (can be seen as timers which expire ASAP) */
5402
5403 struct QEMUBH {
5404 QEMUBHFunc *cb;
5405 void *opaque;
5406 int scheduled;
5407 QEMUBH *next;
5408 };
5409
5410 static QEMUBH *first_bh = NULL;
5411
5412 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
5413 {
5414 QEMUBH *bh;
5415 bh = qemu_mallocz(sizeof(QEMUBH));
5416 if (!bh)
5417 return NULL;
5418 bh->cb = cb;
5419 bh->opaque = opaque;
5420 return bh;
5421 }
5422
5423 int qemu_bh_poll(void)
5424 {
5425 QEMUBH *bh, **pbh;
5426 int ret;
5427
5428 ret = 0;
5429 for(;;) {
5430 pbh = &first_bh;
5431 bh = *pbh;
5432 if (!bh)
5433 break;
5434 ret = 1;
5435 *pbh = bh->next;
5436 bh->scheduled = 0;
5437 bh->cb(bh->opaque);
5438 }
5439 return ret;
5440 }
5441
5442 void qemu_bh_schedule(QEMUBH *bh)
5443 {
5444 CPUState *env = cpu_single_env;
5445 if (bh->scheduled)
5446 return;
5447 bh->scheduled = 1;
5448 bh->next = first_bh;
5449 first_bh = bh;
5450
5451 /* stop the currently executing CPU to execute the BH ASAP */
5452 if (env) {
5453 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
5454 }
5455 }
5456
5457 void qemu_bh_cancel(QEMUBH *bh)
5458 {
5459 QEMUBH **pbh;
5460 if (bh->scheduled) {
5461 pbh = &first_bh;
5462 while (*pbh != bh)
5463 pbh = &(*pbh)->next;
5464 *pbh = bh->next;
5465 bh->scheduled = 0;
5466 }
5467 }
5468
5469 void qemu_bh_delete(QEMUBH *bh)
5470 {
5471 qemu_bh_cancel(bh);
5472 qemu_free(bh);
5473 }
5474
5475 /***********************************************************/
5476 /* machine registration */
5477
5478 QEMUMachine *first_machine = NULL;
5479
5480 int qemu_register_machine(QEMUMachine *m)
5481 {
5482 QEMUMachine **pm;
5483 pm = &first_machine;
5484 while (*pm != NULL)
5485 pm = &(*pm)->next;
5486 m->next = NULL;
5487 *pm = m;
5488 return 0;
5489 }
5490
5491 QEMUMachine *find_machine(const char *name)
5492 {
5493 QEMUMachine *m;
5494
5495 for(m = first_machine; m != NULL; m = m->next) {
5496 if (!strcmp(m->name, name))
5497 return m;
5498 }
5499 return NULL;
5500 }
5501
5502 /***********************************************************/
5503 /* main execution loop */
5504
5505 void gui_update(void *opaque)
5506 {
5507 display_state.dpy_refresh(&display_state);
5508 qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
5509 }
5510
5511 struct vm_change_state_entry {
5512 VMChangeStateHandler *cb;
5513 void *opaque;
5514 LIST_ENTRY (vm_change_state_entry) entries;
5515 };
5516
5517 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
5518
5519 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
5520 void *opaque)
5521 {
5522 VMChangeStateEntry *e;
5523
5524 e = qemu_mallocz(sizeof (*e));
5525 if (!e)
5526 return NULL;
5527
5528 e->cb = cb;
5529 e->opaque = opaque;
5530 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
5531 return e;
5532 }
5533
5534 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
5535 {
5536 LIST_REMOVE (e, entries);
5537 qemu_free (e);
5538 }
5539
5540 static void vm_state_notify(int running)
5541 {
5542 VMChangeStateEntry *e;
5543
5544 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
5545 e->cb(e->opaque, running);
5546 }
5547 }
5548
5549 /* XXX: support several handlers */
5550 static VMStopHandler *vm_stop_cb;
5551 static void *vm_stop_opaque;
5552
5553 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
5554 {
5555 vm_stop_cb = cb;
5556 vm_stop_opaque = opaque;
5557 return 0;
5558 }
5559
5560 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
5561 {
5562 vm_stop_cb = NULL;
5563 }
5564
5565 void vm_start(void)
5566 {
5567 if (!vm_running) {
5568 cpu_enable_ticks();
5569 vm_running = 1;
5570 vm_state_notify(1);
5571 }
5572 }
5573
5574 void vm_stop(int reason)
5575 {
5576 if (vm_running) {
5577 cpu_disable_ticks();
5578 vm_running = 0;
5579 if (reason != 0) {
5580 if (vm_stop_cb) {
5581 vm_stop_cb(vm_stop_opaque, reason);
5582 }
5583 }
5584 vm_state_notify(0);
5585 }
5586 }
5587
5588 /* reset/shutdown handler */
5589
5590 typedef struct QEMUResetEntry {
5591 QEMUResetHandler *func;
5592 void *opaque;
5593 struct QEMUResetEntry *next;
5594 } QEMUResetEntry;
5595
5596 static QEMUResetEntry *first_reset_entry;
5597 static int reset_requested;
5598 static int shutdown_requested;
5599 static int powerdown_requested;
5600
5601 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
5602 {
5603 QEMUResetEntry **pre, *re;
5604
5605 pre = &first_reset_entry;
5606 while (*pre != NULL)
5607 pre = &(*pre)->next;
5608 re = qemu_mallocz(sizeof(QEMUResetEntry));
5609 re->func = func;
5610 re->opaque = opaque;
5611 re->next = NULL;
5612 *pre = re;
5613 }
5614
5615 void qemu_system_reset(void)
5616 {
5617 QEMUResetEntry *re;
5618
5619 /* reset all devices */
5620 for(re = first_reset_entry; re != NULL; re = re->next) {
5621 re->func(re->opaque);
5622 }
5623 }
5624
5625 void qemu_system_reset_request(void)
5626 {
5627 reset_requested = 1;
5628 if (cpu_single_env)
5629 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5630 }
5631
5632 void qemu_system_shutdown_request(void)
5633 {
5634 shutdown_requested = 1;
5635 if (cpu_single_env)
5636 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5637 }
5638
5639 void qemu_system_powerdown_request(void)
5640 {
5641 powerdown_requested = 1;
5642 if (cpu_single_env)
5643 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5644 }
5645
5646 void main_loop_wait(int timeout)
5647 {
5648 IOHandlerRecord *ioh, *ioh_next;
5649 fd_set rfds, wfds, xfds;
5650 int ret, nfds;
5651 struct timeval tv;
5652 PollingEntry *pe;
5653
5654
5655 /* XXX: need to suppress polling by better using win32 events */
5656 ret = 0;
5657 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
5658 ret |= pe->func(pe->opaque);
5659 }
5660 #ifdef _WIN32
5661 if (ret == 0 && timeout > 0) {
5662 int err;
5663 WaitObjects *w = &wait_objects;
5664
5665 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
5666 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
5667 if (w->func[ret - WAIT_OBJECT_0])
5668 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
5669 } else if (ret == WAIT_TIMEOUT) {
5670 } else {
5671 err = GetLastError();
5672 fprintf(stderr, "Wait error %d %d\n", ret, err);
5673 }
5674 }
5675 #endif
5676 /* poll any events */
5677 /* XXX: separate device handlers from system ones */
5678 nfds = -1;
5679 FD_ZERO(&rfds);
5680 FD_ZERO(&wfds);
5681 FD_ZERO(&xfds);
5682 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5683 if (ioh->fd_read &&
5684 (!ioh->fd_read_poll ||
5685 ioh->fd_read_poll(ioh->opaque) != 0)) {
5686 FD_SET(ioh->fd, &rfds);
5687 if (ioh->fd > nfds)
5688 nfds = ioh->fd;
5689 }
5690 if (ioh->fd_write) {
5691 FD_SET(ioh->fd, &wfds);
5692 if (ioh->fd > nfds)
5693 nfds = ioh->fd;
5694 }
5695 }
5696
5697 tv.tv_sec = 0;
5698 #ifdef _WIN32
5699 tv.tv_usec = 0;
5700 #else
5701 tv.tv_usec = timeout * 1000;
5702 #endif
5703 #if defined(CONFIG_SLIRP)
5704 if (slirp_inited) {
5705 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
5706 }
5707 #endif
5708 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
5709 if (ret > 0) {
5710 /* XXX: better handling of removal */
5711 for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
5712 ioh_next = ioh->next;
5713 if (FD_ISSET(ioh->fd, &rfds)) {
5714 ioh->fd_read(ioh->opaque);
5715 }
5716 if (FD_ISSET(ioh->fd, &wfds)) {
5717 ioh->fd_write(ioh->opaque);
5718 }
5719 }
5720 }
5721 #if defined(CONFIG_SLIRP)
5722 if (slirp_inited) {
5723 if (ret < 0) {
5724 FD_ZERO(&rfds);
5725 FD_ZERO(&wfds);
5726 FD_ZERO(&xfds);
5727 }
5728 slirp_select_poll(&rfds, &wfds, &xfds);
5729 }
5730 #endif
5731 qemu_aio_poll();
5732 qemu_bh_poll();
5733
5734 if (vm_running) {
5735 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
5736 qemu_get_clock(vm_clock));
5737 /* run dma transfers, if any */
5738 DMA_run();
5739 }
5740
5741 /* real time timers */
5742 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
5743 qemu_get_clock(rt_clock));
5744 }
5745
5746 static CPUState *cur_cpu;
5747
5748 int main_loop(void)
5749 {
5750 int ret, timeout;
5751 #ifdef CONFIG_PROFILER
5752 int64_t ti;
5753 #endif
5754 CPUState *env;
5755
5756 cur_cpu = first_cpu;
5757 for(;;) {
5758 if (vm_running) {
5759
5760 env = cur_cpu;
5761 for(;;) {
5762 /* get next cpu */
5763 env = env->next_cpu;
5764 if (!env)
5765 env = first_cpu;
5766 #ifdef CONFIG_PROFILER
5767 ti = profile_getclock();
5768 #endif
5769 ret = cpu_exec(env);
5770 #ifdef CONFIG_PROFILER
5771 qemu_time += profile_getclock() - ti;
5772 #endif
5773 if (ret != EXCP_HALTED)
5774 break;
5775 /* all CPUs are halted ? */
5776 if (env == cur_cpu) {
5777 ret = EXCP_HLT;
5778 break;
5779 }
5780 }
5781 cur_cpu = env;
5782
5783 if (shutdown_requested) {
5784 ret = EXCP_INTERRUPT;
5785 break;
5786 }
5787 if (reset_requested) {
5788 reset_requested = 0;
5789 qemu_system_reset();
5790 ret = EXCP_INTERRUPT;
5791 }
5792 if (powerdown_requested) {
5793 powerdown_requested = 0;
5794 qemu_system_powerdown();
5795 ret = EXCP_INTERRUPT;
5796 }
5797 if (ret == EXCP_DEBUG) {
5798 vm_stop(EXCP_DEBUG);
5799 }
5800 /* if hlt instruction, we wait until the next IRQ */
5801 /* XXX: use timeout computed from timers */
5802 if (ret == EXCP_HLT)
5803 timeout = 10;
5804 else
5805 timeout = 0;
5806 } else {
5807 timeout = 10;
5808 }
5809 #ifdef CONFIG_PROFILER
5810 ti = profile_getclock();
5811 #endif
5812 main_loop_wait(timeout);
5813 #ifdef CONFIG_PROFILER
5814 dev_time += profile_getclock() - ti;
5815 #endif
5816 }
5817 cpu_disable_ticks();
5818 return ret;
5819 }
5820
5821 void help(void)
5822 {
5823 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2006 Fabrice Bellard\n"
5824 "usage: %s [options] [disk_image]\n"
5825 "\n"
5826 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
5827 "\n"
5828 "Standard options:\n"
5829 "-M machine select emulated machine (-M ? for list)\n"
5830 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
5831 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
5832 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
5833 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
5834 "-boot [a|c|d] boot on floppy (a), hard disk (c) or CD-ROM (d)\n"
5835 "-snapshot write to temporary files instead of disk image files\n"
5836 #ifdef TARGET_I386
5837 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
5838 #endif
5839 "-m megs set virtual RAM size to megs MB [default=%d]\n"
5840 "-smp n set the number of CPUs to 'n' [default=1]\n"
5841 "-nographic disable graphical output and redirect serial I/Os to console\n"
5842 #ifndef _WIN32
5843 "-k language use keyboard layout (for example \"fr\" for French)\n"
5844 #endif
5845 #ifdef HAS_AUDIO
5846 "-audio-help print list of audio drivers and their options\n"
5847 "-soundhw c1,... enable audio support\n"
5848 " and only specified sound cards (comma separated list)\n"
5849 " use -soundhw ? to get the list of supported cards\n"
5850 " use -soundhw all to enable all of them\n"
5851 #endif
5852 "-localtime set the real time clock to local time [default=utc]\n"
5853 "-full-screen start in full screen\n"
5854 #ifdef TARGET_I386
5855 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
5856 #endif
5857 "-usb enable the USB driver (will be the default soon)\n"
5858 "-usbdevice name add the host or guest USB device 'name'\n"
5859 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5860 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
5861 #endif
5862 "\n"
5863 "Network options:\n"
5864 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
5865 " create a new Network Interface Card and connect it to VLAN 'n'\n"
5866 #ifdef CONFIG_SLIRP
5867 "-net user[,vlan=n][,hostname=host]\n"
5868 " connect the user mode network stack to VLAN 'n' and send\n"
5869 " hostname 'host' to DHCP clients\n"
5870 #endif
5871 #ifdef _WIN32
5872 "-net tap[,vlan=n],ifname=name\n"
5873 " connect the host TAP network interface to VLAN 'n'\n"
5874 #else
5875 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file]\n"
5876 " connect the host TAP network interface to VLAN 'n' and use\n"
5877 " the network script 'file' (default=%s);\n"
5878 " use 'fd=h' to connect to an already opened TAP interface\n"
5879 #endif
5880 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
5881 " connect the vlan 'n' to another VLAN using a socket connection\n"
5882 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
5883 " connect the vlan 'n' to multicast maddr and port\n"
5884 "-net none use it alone to have zero network devices; if no -net option\n"
5885 " is provided, the default is '-net nic -net user'\n"
5886 "\n"
5887 #ifdef CONFIG_SLIRP
5888 "-tftp prefix allow tftp access to files starting with prefix [-net user]\n"
5889 #ifndef _WIN32
5890 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
5891 #endif
5892 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
5893 " redirect TCP or UDP connections from host to guest [-net user]\n"
5894 #endif
5895 "\n"
5896 "Linux boot specific:\n"
5897 "-kernel bzImage use 'bzImage' as kernel image\n"
5898 "-append cmdline use 'cmdline' as kernel command line\n"
5899 "-initrd file use 'file' as initial ram disk\n"
5900 "\n"
5901 "Debug/Expert options:\n"
5902 "-monitor dev redirect the monitor to char device 'dev'\n"
5903 "-serial dev redirect the serial port to char device 'dev'\n"
5904 "-parallel dev redirect the parallel port to char device 'dev'\n"
5905 "-pidfile file Write PID to 'file'\n"
5906 "-S freeze CPU at startup (use 'c' to start execution)\n"
5907 "-s wait gdb connection to port %d\n"
5908 "-p port change gdb connection port\n"
5909 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
5910 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
5911 " translation (t=none or lba) (usually qemu can guess them)\n"
5912 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
5913 #ifdef USE_KQEMU
5914 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
5915 "-no-kqemu disable KQEMU kernel module usage\n"
5916 #endif
5917 #ifdef USE_CODE_COPY
5918 "-no-code-copy disable code copy acceleration\n"
5919 #endif
5920 #ifdef TARGET_I386
5921 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
5922 " (default is CL-GD5446 PCI VGA)\n"
5923 "-no-acpi disable ACPI\n"
5924 #endif
5925 "-loadvm file start right away with a saved state (loadvm in monitor)\n"
5926 "-vnc display start a VNC server on display\n"
5927 "\n"
5928 "During emulation, the following keys are useful:\n"
5929 "ctrl-alt-f toggle full screen\n"
5930 "ctrl-alt-n switch to virtual console 'n'\n"
5931 "ctrl-alt toggle mouse and keyboard grab\n"
5932 "\n"
5933 "When using -nographic, press 'ctrl-a h' to get some help.\n"
5934 ,
5935 "qemu",
5936 DEFAULT_RAM_SIZE,
5937 #ifndef _WIN32
5938 DEFAULT_NETWORK_SCRIPT,
5939 #endif
5940 DEFAULT_GDBSTUB_PORT,
5941 "/tmp/qemu.log");
5942 exit(1);
5943 }
5944
5945 #define HAS_ARG 0x0001
5946
5947 enum {
5948 QEMU_OPTION_h,
5949
5950 QEMU_OPTION_M,
5951 QEMU_OPTION_fda,
5952 QEMU_OPTION_fdb,
5953 QEMU_OPTION_hda,
5954 QEMU_OPTION_hdb,
5955 QEMU_OPTION_hdc,
5956 QEMU_OPTION_hdd,
5957 QEMU_OPTION_cdrom,
5958 QEMU_OPTION_boot,
5959 QEMU_OPTION_snapshot,
5960 #ifdef TARGET_I386
5961 QEMU_OPTION_no_fd_bootchk,
5962 #endif
5963 QEMU_OPTION_m,
5964 QEMU_OPTION_nographic,
5965 #ifdef HAS_AUDIO
5966 QEMU_OPTION_audio_help,
5967 QEMU_OPTION_soundhw,
5968 #endif
5969
5970 QEMU_OPTION_net,
5971 QEMU_OPTION_tftp,
5972 QEMU_OPTION_smb,
5973 QEMU_OPTION_redir,
5974
5975 QEMU_OPTION_kernel,
5976 QEMU_OPTION_append,
5977 QEMU_OPTION_initrd,
5978
5979 QEMU_OPTION_S,
5980 QEMU_OPTION_s,
5981 QEMU_OPTION_p,
5982 QEMU_OPTION_d,
5983 QEMU_OPTION_hdachs,
5984 QEMU_OPTION_L,
5985 QEMU_OPTION_no_code_copy,
5986 QEMU_OPTION_k,
5987 QEMU_OPTION_localtime,
5988 QEMU_OPTION_cirrusvga,
5989 QEMU_OPTION_g,
5990 QEMU_OPTION_std_vga,
5991 QEMU_OPTION_monitor,
5992 QEMU_OPTION_serial,
5993 QEMU_OPTION_parallel,
5994 QEMU_OPTION_loadvm,
5995 QEMU_OPTION_full_screen,
5996 QEMU_OPTION_pidfile,
5997 QEMU_OPTION_no_kqemu,
5998 QEMU_OPTION_kernel_kqemu,
5999 QEMU_OPTION_win2k_hack,
6000 QEMU_OPTION_usb,
6001 QEMU_OPTION_usbdevice,
6002 QEMU_OPTION_smp,
6003 QEMU_OPTION_vnc,
6004 QEMU_OPTION_no_acpi,
6005 };
6006
6007 typedef struct QEMUOption {
6008 const char *name;
6009 int flags;
6010 int index;
6011 } QEMUOption;
6012
6013 const QEMUOption qemu_options[] = {
6014 { "h", 0, QEMU_OPTION_h },
6015
6016 { "M", HAS_ARG, QEMU_OPTION_M },
6017 { "fda", HAS_ARG, QEMU_OPTION_fda },
6018 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
6019 { "hda", HAS_ARG, QEMU_OPTION_hda },
6020 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
6021 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
6022 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
6023 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
6024 { "boot", HAS_ARG, QEMU_OPTION_boot },
6025 { "snapshot", 0, QEMU_OPTION_snapshot },
6026 #ifdef TARGET_I386
6027 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
6028 #endif
6029 { "m", HAS_ARG, QEMU_OPTION_m },
6030 { "nographic", 0, QEMU_OPTION_nographic },
6031 { "k", HAS_ARG, QEMU_OPTION_k },
6032 #ifdef HAS_AUDIO
6033 { "audio-help", 0, QEMU_OPTION_audio_help },
6034 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
6035 #endif
6036
6037 { "net", HAS_ARG, QEMU_OPTION_net},
6038 #ifdef CONFIG_SLIRP
6039 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
6040 #ifndef _WIN32
6041 { "smb", HAS_ARG, QEMU_OPTION_smb },
6042 #endif
6043 { "redir", HAS_ARG, QEMU_OPTION_redir },
6044 #endif
6045
6046 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
6047 { "append", HAS_ARG, QEMU_OPTION_append },
6048 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
6049
6050 { "S", 0, QEMU_OPTION_S },
6051 { "s", 0, QEMU_OPTION_s },
6052 { "p", HAS_ARG, QEMU_OPTION_p },
6053 { "d", HAS_ARG, QEMU_OPTION_d },
6054 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
6055 { "L", HAS_ARG, QEMU_OPTION_L },
6056 { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
6057 #ifdef USE_KQEMU
6058 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
6059 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
6060 #endif
6061 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
6062 { "g", 1, QEMU_OPTION_g },
6063 #endif
6064 { "localtime", 0, QEMU_OPTION_localtime },
6065 { "std-vga", 0, QEMU_OPTION_std_vga },
6066 { "monitor", 1, QEMU_OPTION_monitor },
6067 { "serial", 1, QEMU_OPTION_serial },
6068 { "parallel", 1, QEMU_OPTION_parallel },
6069 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
6070 { "full-screen", 0, QEMU_OPTION_full_screen },
6071 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
6072 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
6073 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
6074 { "smp", HAS_ARG, QEMU_OPTION_smp },
6075 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
6076
6077 /* temporary options */
6078 { "usb", 0, QEMU_OPTION_usb },
6079 { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
6080 { "no-acpi", 0, QEMU_OPTION_no_acpi },
6081 { NULL },
6082 };
6083
6084 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
6085
6086 /* this stack is only used during signal handling */
6087 #define SIGNAL_STACK_SIZE 32768
6088
6089 static uint8_t *signal_stack;
6090
6091 #endif
6092
6093 /* password input */
6094
6095 static BlockDriverState *get_bdrv(int index)
6096 {
6097 BlockDriverState *bs;
6098
6099 if (index < 4) {
6100 bs = bs_table[index];
6101 } else if (index < 6) {
6102 bs = fd_table[index - 4];
6103 } else {
6104 bs = NULL;
6105 }
6106 return bs;
6107 }
6108
6109 static void read_passwords(void)
6110 {
6111 BlockDriverState *bs;
6112 int i, j;
6113 char password[256];
6114
6115 for(i = 0; i < 6; i++) {
6116 bs = get_bdrv(i);
6117 if (bs && bdrv_is_encrypted(bs)) {
6118 term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
6119 for(j = 0; j < 3; j++) {
6120 monitor_readline("Password: ",
6121 1, password, sizeof(password));
6122 if (bdrv_set_key(bs, password) == 0)
6123 break;
6124 term_printf("invalid password\n");
6125 }
6126 }
6127 }
6128 }
6129
6130 /* XXX: currently we cannot use simultaneously different CPUs */
6131 void register_machines(void)
6132 {
6133 #if defined(TARGET_I386)
6134 qemu_register_machine(&pc_machine);
6135 qemu_register_machine(&isapc_machine);
6136 #elif defined(TARGET_PPC)
6137 qemu_register_machine(&heathrow_machine);
6138 qemu_register_machine(&core99_machine);
6139 qemu_register_machine(&prep_machine);
6140 #elif defined(TARGET_MIPS)
6141 qemu_register_machine(&mips_machine);
6142 #elif defined(TARGET_SPARC)
6143 #ifdef TARGET_SPARC64
6144 qemu_register_machine(&sun4u_machine);
6145 #else
6146 qemu_register_machine(&sun4m_machine);
6147 #endif
6148 #elif defined(TARGET_ARM)
6149 qemu_register_machine(&integratorcp926_machine);
6150 qemu_register_machine(&integratorcp1026_machine);
6151 qemu_register_machine(&versatilepb_machine);
6152 qemu_register_machine(&versatileab_machine);
6153 #elif defined(TARGET_SH4)
6154 qemu_register_machine(&shix_machine);
6155 #else
6156 #error unsupported CPU
6157 #endif
6158 }
6159
6160 #ifdef HAS_AUDIO
6161 struct soundhw soundhw[] = {
6162 #ifdef TARGET_I386
6163 {
6164 "pcspk",
6165 "PC speaker",
6166 0,
6167 1,
6168 { .init_isa = pcspk_audio_init }
6169 },
6170 #endif
6171 {
6172 "sb16",
6173 "Creative Sound Blaster 16",
6174 0,
6175 1,
6176 { .init_isa = SB16_init }
6177 },
6178
6179 #ifdef CONFIG_ADLIB
6180 {
6181 "adlib",
6182 #ifdef HAS_YMF262
6183 "Yamaha YMF262 (OPL3)",
6184 #else
6185 "Yamaha YM3812 (OPL2)",
6186 #endif
6187 0,
6188 1,
6189 { .init_isa = Adlib_init }
6190 },
6191 #endif
6192
6193 #ifdef CONFIG_GUS
6194 {
6195 "gus",
6196 "Gravis Ultrasound GF1",
6197 0,
6198 1,
6199 { .init_isa = GUS_init }
6200 },
6201 #endif
6202
6203 {
6204 "es1370",
6205 "ENSONIQ AudioPCI ES1370",
6206 0,
6207 0,
6208 { .init_pci = es1370_init }
6209 },
6210
6211 { NULL, NULL, 0, 0, { NULL } }
6212 };
6213
6214 static void select_soundhw (const char *optarg)
6215 {
6216 struct soundhw *c;
6217
6218 if (*optarg == '?') {
6219 show_valid_cards:
6220
6221 printf ("Valid sound card names (comma separated):\n");
6222 for (c = soundhw; c->name; ++c) {
6223 printf ("%-11s %s\n", c->name, c->descr);
6224 }
6225 printf ("\n-soundhw all will enable all of the above\n");
6226 exit (*optarg != '?');
6227 }
6228 else {
6229 size_t l;
6230 const char *p;
6231 char *e;
6232 int bad_card = 0;
6233
6234 if (!strcmp (optarg, "all")) {
6235 for (c = soundhw; c->name; ++c) {
6236 c->enabled = 1;
6237 }
6238 return;
6239 }
6240
6241 p = optarg;
6242 while (*p) {
6243 e = strchr (p, ',');
6244 l = !e ? strlen (p) : (size_t) (e - p);
6245
6246 for (c = soundhw; c->name; ++c) {
6247 if (!strncmp (c->name, p, l)) {
6248 c->enabled = 1;
6249 break;
6250 }
6251 }
6252
6253 if (!c->name) {
6254 if (l > 80) {
6255 fprintf (stderr,
6256 "Unknown sound card name (too big to show)\n");
6257 }
6258 else {
6259 fprintf (stderr, "Unknown sound card name `%.*s'\n",
6260 (int) l, p);
6261 }
6262 bad_card = 1;
6263 }
6264 p += l + (e != NULL);
6265 }
6266
6267 if (bad_card)
6268 goto show_valid_cards;
6269 }
6270 }
6271 #endif
6272
6273 #ifdef _WIN32
6274 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
6275 {
6276 exit(STATUS_CONTROL_C_EXIT);
6277 return TRUE;
6278 }
6279 #endif
6280
6281 #define MAX_NET_CLIENTS 32
6282
6283 int main(int argc, char **argv)
6284 {
6285 #ifdef CONFIG_GDBSTUB
6286 int use_gdbstub, gdbstub_port;
6287 #endif
6288 int i, cdrom_index;
6289 int snapshot, linux_boot;
6290 const char *initrd_filename;
6291 const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
6292 const char *kernel_filename, *kernel_cmdline;
6293 DisplayState *ds = &display_state;
6294 int cyls, heads, secs, translation;
6295 int start_emulation = 1;
6296 char net_clients[MAX_NET_CLIENTS][256];
6297 int nb_net_clients;
6298 int optind;
6299 const char *r, *optarg;
6300 CharDriverState *monitor_hd;
6301 char monitor_device[128];
6302 char serial_devices[MAX_SERIAL_PORTS][128];
6303 int serial_device_index;
6304 char parallel_devices[MAX_PARALLEL_PORTS][128];
6305 int parallel_device_index;
6306 const char *loadvm = NULL;
6307 QEMUMachine *machine;
6308 char usb_devices[MAX_USB_CMDLINE][128];
6309 int usb_devices_index;
6310
6311 LIST_INIT (&vm_change_state_head);
6312 #ifndef _WIN32
6313 {
6314 struct sigaction act;
6315 sigfillset(&act.sa_mask);
6316 act.sa_flags = 0;
6317 act.sa_handler = SIG_IGN;
6318 sigaction(SIGPIPE, &act, NULL);
6319 }
6320 #else
6321 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
6322 /* Note: cpu_interrupt() is currently not SMP safe, so we force
6323 QEMU to run on a single CPU */
6324 {
6325 HANDLE h;
6326 DWORD mask, smask;
6327 int i;
6328 h = GetCurrentProcess();
6329 if (GetProcessAffinityMask(h, &mask, &smask)) {
6330 for(i = 0; i < 32; i++) {
6331 if (mask & (1 << i))
6332 break;
6333 }
6334 if (i != 32) {
6335 mask = 1 << i;
6336 SetProcessAffinityMask(h, mask);
6337 }
6338 }
6339 }
6340 #endif
6341
6342 register_machines();
6343 machine = first_machine;
6344 initrd_filename = NULL;
6345 for(i = 0; i < MAX_FD; i++)
6346 fd_filename[i] = NULL;
6347 for(i = 0; i < MAX_DISKS; i++)
6348 hd_filename[i] = NULL;
6349 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
6350 vga_ram_size = VGA_RAM_SIZE;
6351 bios_size = BIOS_SIZE;
6352 #ifdef CONFIG_GDBSTUB
6353 use_gdbstub = 0;
6354 gdbstub_port = DEFAULT_GDBSTUB_PORT;
6355 #endif
6356 snapshot = 0;
6357 nographic = 0;
6358 kernel_filename = NULL;
6359 kernel_cmdline = "";
6360 #ifdef TARGET_PPC
6361 cdrom_index = 1;
6362 #else
6363 cdrom_index = 2;
6364 #endif
6365 cyls = heads = secs = 0;
6366 translation = BIOS_ATA_TRANSLATION_AUTO;
6367 pstrcpy(monitor_device, sizeof(monitor_device), "vc");
6368
6369 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
6370 for(i = 1; i < MAX_SERIAL_PORTS; i++)
6371 serial_devices[i][0] = '\0';
6372 serial_device_index = 0;
6373
6374 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
6375 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
6376 parallel_devices[i][0] = '\0';
6377 parallel_device_index = 0;
6378
6379 usb_devices_index = 0;
6380
6381 nb_net_clients = 0;
6382
6383 nb_nics = 0;
6384 /* default mac address of the first network interface */
6385
6386 optind = 1;
6387 for(;;) {
6388 if (optind >= argc)
6389 break;
6390 r = argv[optind];
6391 if (r[0] != '-') {
6392 hd_filename[0] = argv[optind++];
6393 } else {
6394 const QEMUOption *popt;
6395
6396 optind++;
6397 popt = qemu_options;
6398 for(;;) {
6399 if (!popt->name) {
6400 fprintf(stderr, "%s: invalid option -- '%s'\n",
6401 argv[0], r);
6402 exit(1);
6403 }
6404 if (!strcmp(popt->name, r + 1))
6405 break;
6406 popt++;
6407 }
6408 if (popt->flags & HAS_ARG) {
6409 if (optind >= argc) {
6410 fprintf(stderr, "%s: option '%s' requires an argument\n",
6411 argv[0], r);
6412 exit(1);
6413 }
6414 optarg = argv[optind++];
6415 } else {
6416 optarg = NULL;
6417 }
6418
6419 switch(popt->index) {
6420 case QEMU_OPTION_M:
6421 machine = find_machine(optarg);
6422 if (!machine) {
6423 QEMUMachine *m;
6424 printf("Supported machines are:\n");
6425 for(m = first_machine; m != NULL; m = m->next) {
6426 printf("%-10s %s%s\n",
6427 m->name, m->desc,
6428 m == first_machine ? " (default)" : "");
6429 }
6430 exit(1);
6431 }
6432 break;
6433 case QEMU_OPTION_initrd:
6434 initrd_filename = optarg;
6435 break;
6436 case QEMU_OPTION_hda:
6437 case QEMU_OPTION_hdb:
6438 case QEMU_OPTION_hdc:
6439 case QEMU_OPTION_hdd:
6440 {
6441 int hd_index;
6442 hd_index = popt->index - QEMU_OPTION_hda;
6443 hd_filename[hd_index] = optarg;
6444 if (hd_index == cdrom_index)
6445 cdrom_index = -1;
6446 }
6447 break;
6448 case QEMU_OPTION_snapshot:
6449 snapshot = 1;
6450 break;
6451 case QEMU_OPTION_hdachs:
6452 {
6453 const char *p;
6454 p = optarg;
6455 cyls = strtol(p, (char **)&p, 0);
6456 if (cyls < 1 || cyls > 16383)
6457 goto chs_fail;
6458 if (*p != ',')
6459 goto chs_fail;
6460 p++;
6461 heads = strtol(p, (char **)&p, 0);
6462 if (heads < 1 || heads > 16)
6463 goto chs_fail;
6464 if (*p != ',')
6465 goto chs_fail;
6466 p++;
6467 secs = strtol(p, (char **)&p, 0);
6468 if (secs < 1 || secs > 63)
6469 goto chs_fail;
6470 if (*p == ',') {
6471 p++;
6472 if (!strcmp(p, "none"))
6473 translation = BIOS_ATA_TRANSLATION_NONE;
6474 else if (!strcmp(p, "lba"))
6475 translation = BIOS_ATA_TRANSLATION_LBA;
6476 else if (!strcmp(p, "auto"))
6477 translation = BIOS_ATA_TRANSLATION_AUTO;
6478 else
6479 goto chs_fail;
6480 } else if (*p != '\0') {
6481 chs_fail:
6482 fprintf(stderr, "qemu: invalid physical CHS format\n");
6483 exit(1);
6484 }
6485 }
6486 break;
6487 case QEMU_OPTION_nographic:
6488 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
6489 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
6490 nographic = 1;
6491 break;
6492 case QEMU_OPTION_kernel:
6493 kernel_filename = optarg;
6494 break;
6495 case QEMU_OPTION_append:
6496 kernel_cmdline = optarg;
6497 break;
6498 case QEMU_OPTION_cdrom:
6499 if (cdrom_index >= 0) {
6500 hd_filename[cdrom_index] = optarg;
6501 }
6502 break;
6503 case QEMU_OPTION_boot:
6504 boot_device = optarg[0];
6505 if (boot_device != 'a' &&
6506 #ifdef TARGET_SPARC
6507 // Network boot
6508 boot_device != 'n' &&
6509 #endif
6510 boot_device != 'c' && boot_device != 'd') {
6511 fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
6512 exit(1);
6513 }
6514 break;
6515 case QEMU_OPTION_fda:
6516 fd_filename[0] = optarg;
6517 break;
6518 case QEMU_OPTION_fdb:
6519 fd_filename[1] = optarg;
6520 break;
6521 #ifdef TARGET_I386
6522 case QEMU_OPTION_no_fd_bootchk:
6523 fd_bootchk = 0;
6524 break;
6525 #endif
6526 case QEMU_OPTION_no_code_copy:
6527 code_copy_enabled = 0;
6528 break;
6529 case QEMU_OPTION_net:
6530 if (nb_net_clients >= MAX_NET_CLIENTS) {
6531 fprintf(stderr, "qemu: too many network clients\n");
6532 exit(1);
6533 }
6534 pstrcpy(net_clients[nb_net_clients],
6535 sizeof(net_clients[0]),
6536 optarg);
6537 nb_net_clients++;
6538 break;
6539 #ifdef CONFIG_SLIRP
6540 case QEMU_OPTION_tftp:
6541 tftp_prefix = optarg;
6542 break;
6543 #ifndef _WIN32
6544 case QEMU_OPTION_smb:
6545 net_slirp_smb(optarg);
6546 break;
6547 #endif
6548 case QEMU_OPTION_redir:
6549 net_slirp_redir(optarg);
6550 break;
6551 #endif
6552 #ifdef HAS_AUDIO
6553 case QEMU_OPTION_audio_help:
6554 AUD_help ();
6555 exit (0);
6556 break;
6557 case QEMU_OPTION_soundhw:
6558 select_soundhw (optarg);
6559 break;
6560 #endif
6561 case QEMU_OPTION_h:
6562 help();
6563 break;
6564 case QEMU_OPTION_m:
6565 ram_size = atoi(optarg) * 1024 * 1024;
6566 if (ram_size <= 0)
6567 help();
6568 if (ram_size > PHYS_RAM_MAX_SIZE) {
6569 fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
6570 PHYS_RAM_MAX_SIZE / (1024 * 1024));
6571 exit(1);
6572 }
6573 break;
6574 case QEMU_OPTION_d:
6575 {
6576 int mask;
6577 CPULogItem *item;
6578
6579 mask = cpu_str_to_log_mask(optarg);
6580 if (!mask) {
6581 printf("Log items (comma separated):\n");
6582 for(item = cpu_log_items; item->mask != 0; item++) {
6583 printf("%-10s %s\n", item->name, item->help);
6584 }
6585 exit(1);
6586 }
6587 cpu_set_log(mask);
6588 }
6589 break;
6590 #ifdef CONFIG_GDBSTUB
6591 case QEMU_OPTION_s:
6592 use_gdbstub = 1;
6593 break;
6594 case QEMU_OPTION_p:
6595 gdbstub_port = atoi(optarg);
6596 break;
6597 #endif
6598 case QEMU_OPTION_L:
6599 bios_dir = optarg;
6600 break;
6601 case QEMU_OPTION_S:
6602 start_emulation = 0;
6603 break;
6604 case QEMU_OPTION_k:
6605 keyboard_layout = optarg;
6606 break;
6607 case QEMU_OPTION_localtime:
6608 rtc_utc = 0;
6609 break;
6610 case QEMU_OPTION_cirrusvga:
6611 cirrus_vga_enabled = 1;
6612 break;
6613 case QEMU_OPTION_std_vga:
6614 cirrus_vga_enabled = 0;
6615 break;
6616 case QEMU_OPTION_g:
6617 {
6618 const char *p;
6619 int w, h, depth;
6620 p = optarg;
6621 w = strtol(p, (char **)&p, 10);
6622 if (w <= 0) {
6623 graphic_error:
6624 fprintf(stderr, "qemu: invalid resolution or depth\n");
6625 exit(1);
6626 }
6627 if (*p != 'x')
6628 goto graphic_error;
6629 p++;
6630 h = strtol(p, (char **)&p, 10);
6631 if (h <= 0)
6632 goto graphic_error;
6633 if (*p == 'x') {
6634 p++;
6635 depth = strtol(p, (char **)&p, 10);
6636 if (depth != 8 && depth != 15 && depth != 16 &&
6637 depth != 24 && depth != 32)
6638 goto graphic_error;
6639 } else if (*p == '\0') {
6640 depth = graphic_depth;
6641 } else {
6642 goto graphic_error;
6643 }
6644
6645 graphic_width = w;
6646 graphic_height = h;
6647 graphic_depth = depth;
6648 }
6649 break;
6650 case QEMU_OPTION_monitor:
6651 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
6652 break;
6653 case QEMU_OPTION_serial:
6654 if (serial_device_index >= MAX_SERIAL_PORTS) {
6655 fprintf(stderr, "qemu: too many serial ports\n");
6656 exit(1);
6657 }
6658 pstrcpy(serial_devices[serial_device_index],
6659 sizeof(serial_devices[0]), optarg);
6660 serial_device_index++;
6661 break;
6662 case QEMU_OPTION_parallel:
6663 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
6664 fprintf(stderr, "qemu: too many parallel ports\n");
6665 exit(1);
6666 }
6667 pstrcpy(parallel_devices[parallel_device_index],
6668 sizeof(parallel_devices[0]), optarg);
6669 parallel_device_index++;
6670 break;
6671 case QEMU_OPTION_loadvm:
6672 loadvm = optarg;
6673 break;
6674 case QEMU_OPTION_full_screen:
6675 full_screen = 1;
6676 break;
6677 case QEMU_OPTION_pidfile:
6678 create_pidfile(optarg);
6679 break;
6680 #ifdef TARGET_I386
6681 case QEMU_OPTION_win2k_hack:
6682 win2k_install_hack = 1;
6683 break;
6684 #endif
6685 #ifdef USE_KQEMU
6686 case QEMU_OPTION_no_kqemu:
6687 kqemu_allowed = 0;
6688 break;
6689 case QEMU_OPTION_kernel_kqemu:
6690 kqemu_allowed = 2;
6691 break;
6692 #endif
6693 case QEMU_OPTION_usb:
6694 usb_enabled = 1;
6695 break;
6696 case QEMU_OPTION_usbdevice:
6697 usb_enabled = 1;
6698 if (usb_devices_index >= MAX_USB_CMDLINE) {
6699 fprintf(stderr, "Too many USB devices\n");
6700 exit(1);
6701 }
6702 pstrcpy(usb_devices[usb_devices_index],
6703 sizeof(usb_devices[usb_devices_index]),
6704 optarg);
6705 usb_devices_index++;
6706 break;
6707 case QEMU_OPTION_smp:
6708 smp_cpus = atoi(optarg);
6709 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
6710 fprintf(stderr, "Invalid number of CPUs\n");
6711 exit(1);
6712 }
6713 break;
6714 case QEMU_OPTION_vnc:
6715 vnc_display = atoi(optarg);
6716 if (vnc_display < 0) {
6717 fprintf(stderr, "Invalid VNC display\n");
6718 exit(1);
6719 }
6720 break;
6721 case QEMU_OPTION_no_acpi:
6722 acpi_enabled = 0;
6723 break;
6724 }
6725 }
6726 }
6727
6728 #ifdef USE_KQEMU
6729 if (smp_cpus > 1)
6730 kqemu_allowed = 0;
6731 #endif
6732 linux_boot = (kernel_filename != NULL);
6733
6734 if (!linux_boot &&
6735 hd_filename[0] == '\0' &&
6736 (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') &&
6737 fd_filename[0] == '\0')
6738 help();
6739
6740 /* boot to cd by default if no hard disk */
6741 if (hd_filename[0] == '\0' && boot_device == 'c') {
6742 if (fd_filename[0] != '\0')
6743 boot_device = 'a';
6744 else
6745 boot_device = 'd';
6746 }
6747
6748 setvbuf(stdout, NULL, _IOLBF, 0);
6749
6750 init_timers();
6751 init_timer_alarm();
6752 qemu_aio_init();
6753
6754 #ifdef _WIN32
6755 socket_init();
6756 #endif
6757
6758 /* init network clients */
6759 if (nb_net_clients == 0) {
6760 /* if no clients, we use a default config */
6761 pstrcpy(net_clients[0], sizeof(net_clients[0]),
6762 "nic");
6763 pstrcpy(net_clients[1], sizeof(net_clients[0]),
6764 "user");
6765 nb_net_clients = 2;
6766 }
6767
6768 for(i = 0;i < nb_net_clients; i++) {
6769 if (net_client_init(net_clients[i]) < 0)
6770 exit(1);
6771 }
6772
6773 /* init the memory */
6774 phys_ram_size = ram_size + vga_ram_size + bios_size;
6775
6776 phys_ram_base = qemu_vmalloc(phys_ram_size);
6777 if (!phys_ram_base) {
6778 fprintf(stderr, "Could not allocate physical memory\n");
6779 exit(1);
6780 }
6781
6782 /* we always create the cdrom drive, even if no disk is there */
6783 bdrv_init();
6784 if (cdrom_index >= 0) {
6785 bs_table[cdrom_index] = bdrv_new("cdrom");
6786 bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM);
6787 }
6788
6789 /* open the virtual block devices */
6790 for(i = 0; i < MAX_DISKS; i++) {
6791 if (hd_filename[i]) {
6792 if (!bs_table[i]) {
6793 char buf[64];
6794 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
6795 bs_table[i] = bdrv_new(buf);
6796 }
6797 if (bdrv_open(bs_table[i], hd_filename[i], snapshot ? BDRV_O_SNAPSHOT : 0) < 0) {
6798 fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
6799 hd_filename[i]);
6800 exit(1);
6801 }
6802 if (i == 0 && cyls != 0) {
6803 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
6804 bdrv_set_translation_hint(bs_table[i], translation);
6805 }
6806 }
6807 }
6808
6809 /* we always create at least one floppy disk */
6810 fd_table[0] = bdrv_new("fda");
6811 bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
6812
6813 for(i = 0; i < MAX_FD; i++) {
6814 if (fd_filename[i]) {
6815 if (!fd_table[i]) {
6816 char buf[64];
6817 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
6818 fd_table[i] = bdrv_new(buf);
6819 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
6820 }
6821 if (fd_filename[i] != '\0') {
6822 if (bdrv_open(fd_table[i], fd_filename[i],
6823 snapshot ? BDRV_O_SNAPSHOT : 0) < 0) {
6824 fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
6825 fd_filename[i]);
6826 exit(1);
6827 }
6828 }
6829 }
6830 }
6831
6832 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
6833 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
6834
6835 init_ioports();
6836
6837 /* terminal init */
6838 if (nographic) {
6839 dumb_display_init(ds);
6840 } else if (vnc_display != -1) {
6841 vnc_display_init(ds, vnc_display);
6842 } else {
6843 #if defined(CONFIG_SDL)
6844 sdl_display_init(ds, full_screen);
6845 #elif defined(CONFIG_COCOA)
6846 cocoa_display_init(ds, full_screen);
6847 #else
6848 dumb_display_init(ds);
6849 #endif
6850 }
6851
6852 monitor_hd = qemu_chr_open(monitor_device);
6853 if (!monitor_hd) {
6854 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
6855 exit(1);
6856 }
6857 monitor_init(monitor_hd, !nographic);
6858
6859 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6860 const char *devname = serial_devices[i];
6861 if (devname[0] != '\0' && strcmp(devname, "none")) {
6862 serial_hds[i] = qemu_chr_open(devname);
6863 if (!serial_hds[i]) {
6864 fprintf(stderr, "qemu: could not open serial device '%s'\n",
6865 devname);
6866 exit(1);
6867 }
6868 if (!strcmp(devname, "vc"))
6869 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
6870 }
6871 }
6872
6873 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6874 const char *devname = parallel_devices[i];
6875 if (devname[0] != '\0' && strcmp(devname, "none")) {
6876 parallel_hds[i] = qemu_chr_open(devname);
6877 if (!parallel_hds[i]) {
6878 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
6879 devname);
6880 exit(1);
6881 }
6882 if (!strcmp(devname, "vc"))
6883 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6884 }
6885 }
6886
6887 machine->init(ram_size, vga_ram_size, boot_device,
6888 ds, fd_filename, snapshot,
6889 kernel_filename, kernel_cmdline, initrd_filename);
6890
6891 /* init USB devices */
6892 if (usb_enabled) {
6893 for(i = 0; i < usb_devices_index; i++) {
6894 if (usb_device_add(usb_devices[i]) < 0) {
6895 fprintf(stderr, "Warning: could not add USB device %s\n",
6896 usb_devices[i]);
6897 }
6898 }
6899 }
6900
6901 gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
6902 qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
6903
6904 #ifdef CONFIG_GDBSTUB
6905 if (use_gdbstub) {
6906 if (gdbserver_start(gdbstub_port) < 0) {
6907 fprintf(stderr, "Could not open gdbserver socket on port %d\n",
6908 gdbstub_port);
6909 exit(1);
6910 } else {
6911 printf("Waiting gdb connection on port %d\n", gdbstub_port);
6912 }
6913 } else
6914 #endif
6915 if (loadvm)
6916 do_loadvm(loadvm);
6917
6918 {
6919 /* XXX: simplify init */
6920 read_passwords();
6921 if (start_emulation) {
6922 vm_start();
6923 }
6924 }
6925 main_loop();
6926 quit_timers();
6927 return 0;
6928 }
Samsung s3c2440 and arm920t support for the mini2440 dev board