« back to all changes in this revision
Viewing changes to vl.c
- browse files at revision 6.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 6.1.1
- Committer: Bazaar Package Importer
- Author(s): Aurelien Jarno, Aurelien Jarno
- Date: 2009-03-07 06:20:34 UTC
- mfrom: (1.1.9 upstream)
- mto: This revision was merged to the branch mainline in revision 7.
- Revision ID: james.westby@ubuntu.com-20090307062034-i3pead4mw653v2el
Tags: 0.10.0-1
[ Aurelien Jarno ]
* New upstream release:
- Fix fr-be keyboard mapping (closes: bug#514462).
- Fix stat64 structure on ppc-linux-user (closes: bug#470231).
- Add a chroot option (closes: bug#415996).
- Add evdev support (closes: bug#513210).
- Fix loop on symlinks in user mode (closes: bug#297572).
- Bump depends on openbios-sparc.
- Depends on openbios-ppc.
- Update 12_signal_powerpc_support.patch.
- Update 21_net_soopts.patch.
- Drop 44_socklen_t_check.patch (merged upstream).
- Drop 49_null_check.patch (merged upstream).
- Update 64_ppc_asm_constraints.patch.
- Drop security/CVE-2008-0928-fedora.patch (merged upstream).
- Drop security/CVE-2007-5730.patch (merged upstream).
* patches/80_stable-branch.patch: add patches from stable branch:
- Fix race condition between signal handler/execution loop (closes:
bug#474386, bug#501731).
* debian/copyright: update.
* Compile and install .dtb files:
- debian/control: build-depends on device-tree-compiler.
- debian/patches/81_compile_dtb.patch: new patch from upstream.
- debian/rules: compile and install bamboo.dtb and mpc8544.dtb.
* New upstream release:
- Fix fr-be keyboard mapping (closes: bug#514462).
- Fix stat64 structure on ppc-linux-user (closes: bug#470231).
- Add a chroot option (closes: bug#415996).
- Add evdev support (closes: bug#513210).
- Fix loop on symlinks in user mode (closes: bug#297572).
- Bump depends on openbios-sparc.
- Depends on openbios-ppc.
- Update 12_signal_powerpc_support.patch.
- Update 21_net_soopts.patch.
- Drop 44_socklen_t_check.patch (merged upstream).
- Drop 49_null_check.patch (merged upstream).
- Update 64_ppc_asm_constraints.patch.
- Drop security/CVE-2008-0928-fedora.patch (merged upstream).
- Drop security/CVE-2007-5730.patch (merged upstream).
* patches/80_stable-branch.patch: add patches from stable branch:
- Fix race condition between signal handler/execution loop (closes:
bug#474386, bug#501731).
* debian/copyright: update.
* Compile and install .dtb files:
- debian/control: build-depends on device-tree-compiler.
- debian/patches/81_compile_dtb.patch: new patch from upstream.
- debian/rules: compile and install bamboo.dtb and mpc8544.dtb.
- files added:
- MAINTAINERS
- bsd-user
- bsd-user/freebsd
- bsd-user/netbsd
- bsd-user/openbsd
- bsd-user/sparc
- bsd-user/sparc64
- debian/patches/security
- gdb-xml
- linux-user/arm/nwfpe
- pc-bios/bios-pq
- pc-bios/vgabios-pq
- tcg
- tcg/arm
- tcg/hppa
- tcg/i386
- tcg/ppc
- tcg/ppc64
- tcg/sparc
- tcg/x86_64
- tests/alpha
- files removed:
- audio/sys-queue.h
- linux-user/ppc64
- target-arm/nwfpe
- files modified:
- COPYING
- linux-user/elfload32.c *
added
removed
vl.c
26
26
#include "hw/usb.h"
27
27
#include "hw/pcmcia.h"
28
28
#include "hw/pc.h"
29
#include "hw/fdc.h"
30
29
#include "hw/audiodev.h"
31
30
#include "hw/isa.h"
31
#include "hw/baum.h"
32
#include "hw/bt.h"
32
33
#include "net.h"
33
34
#include "console.h"
34
35
#include "sysemu.h"
35
36
#include "gdbstub.h"
36
37
#include "qemu-timer.h"
37
38
#include "qemu-char.h"
39
#include "cache-utils.h"
38
40
#include "block.h"
39
41
#include "audio/audio.h"
42
#include "migration.h"
43
#include "kvm.h"
44
#include "balloon.h"
40
45
41
46
#include <unistd.h>
42
47
#include <fcntl.h>
47
52
#include <zlib.h>
48
53
49
54
#ifndef _WIN32
55
#include <pwd.h>
50
56
#include <sys/times.h>
51
57
#include <sys/wait.h>
52
58
#include <termios.h>
53
#include <sys/poll.h>
54
59
#include <sys/mman.h>
55
60
#include <sys/ioctl.h>
61
#include <sys/resource.h>
56
62
#include <sys/socket.h>
57
63
#include <netinet/in.h>
64
#include <net/if.h>
65
#if defined(__NetBSD__)
66
#include <net/if_tap.h>
67
#endif
68
#ifdef __linux__
69
#include <linux/if_tun.h>
70
#endif
71
#include <arpa/inet.h>
58
72
#include <dirent.h>
59
73
#include <netdb.h>
60
74
#include <sys/select.h>
61
#include <arpa/inet.h>
62
75
#ifdef _BSD
63
76
#include <sys/stat.h>
64
#ifndef __APPLE__
77
#ifdef __FreeBSD__
65
78
#include <libutil.h>
79
#else
80
#include <util.h>
66
81
#endif
67
82
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
68
83
#include <freebsd/stdlib.h>
69
84
#else
70
#ifndef __sun__
71
#include <linux/if.h>
72
#include <linux/if_tun.h>
85
#ifdef __linux__
73
86
#include <pty.h>
74
87
#include <malloc.h>
75
88
#include <linux/rtc.h>
81
94
82
95
#include <linux/ppdev.h>
83
96
#include <linux/parport.h>
84
#else
97
#endif
98
#ifdef __sun__
85
99
#include <sys/stat.h>
86
100
#include <sys/ethernet.h>
87
101
#include <sys/sockio.h>
97
111
#include <stropts.h>
98
112
#endif
99
113
#endif
100
#else
101
#include <winsock2.h>
102
int inet_aton(const char *cp, struct in_addr *ia);
103
114
#endif
104
115
116
#include "qemu_socket.h"
117
105
118
#if defined(CONFIG_SLIRP)
106
119
#include "libslirp.h"
107
120
#endif
108
121
122
#if defined(__OpenBSD__)
123
#include <util.h>
124
#endif
125
126
#if defined(CONFIG_VDE)
127
#include <libvdeplug.h>
128
#endif
129
109
130
#ifdef _WIN32
110
131
#include <malloc.h>
111
132
#include <sys/timeb.h>
114
135
#define memalign(align, size) malloc(size)
115
136
#endif
116
137
117
#include "qemu_socket.h"
118
119
138
#ifdef CONFIG_SDL
120
139
#ifdef __APPLE__
121
140
#include <SDL/SDL.h>
141
int qemu_main(int argc, char **argv, char **envp);
142
int main(int argc, char **argv)
143
{
144
qemu_main(argc, argv, NULL);
145
}
146
#undef main
147
#define main qemu_main
122
148
#endif
123
149
#endif /* CONFIG_SDL */
124
150
131
157
132
158
#include "exec-all.h"
133
159
134
#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
135
#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
136
#ifdef __sun__
137
#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
138
#else
139
#define SMBD_COMMAND "/usr/sbin/smbd"
140
#endif
141
142
160
//#define DEBUG_UNUSED_IOPORT
143
161
//#define DEBUG_IOPORT
144
145
#define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
146
147
#ifdef TARGET_PPC
148
#define DEFAULT_RAM_SIZE 144
162
//#define DEBUG_NET
163
//#define DEBUG_SLIRP
164
165
166
#ifdef DEBUG_IOPORT
167
# define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
149
168
#else
169
# define LOG_IOPORT(...) do { } while (0)
170
#endif
171
150
172
#define DEFAULT_RAM_SIZE 128
151
#endif
152
/* in ms */
153
#define GUI_REFRESH_INTERVAL 30
154
173
155
174
/* Max number of USB devices that can be specified on the commandline. */
156
175
#define MAX_USB_CMDLINE 8
157
176
177
/* Max number of bluetooth switches on the commandline. */
178
#define MAX_BT_CMDLINE 10
179
158
180
/* XXX: use a two level table to limit memory usage */
159
181
#define MAX_IOPORTS 65536
160
182
161
183
const char *bios_dir = CONFIG_QEMU_SHAREDIR;
162
184
const char *bios_name = NULL;
163
void *ioport_opaque[MAX_IOPORTS];
164
IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
165
IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
185
static void *ioport_opaque[MAX_IOPORTS];
186
static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
187
static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
166
188
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
167
189
to store the VM snapshots */
168
190
DriveInfo drives_table[MAX_DRIVES+1];
169
191
int nb_drives;
170
/* point to the block driver where the snapshots are managed */
171
BlockDriverState *bs_snapshots;
172
int vga_ram_size;
173
static DisplayState display_state;
192
static int vga_ram_size;
193
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
194
static DisplayState *display_state;
174
195
int nographic;
196
static int curses;
197
static int sdl;
175
198
const char* keyboard_layout = NULL;
176
199
int64_t ticks_per_sec;
177
int ram_size;
178
int pit_min_timer_count = 0;
200
ram_addr_t ram_size;
179
201
int nb_nics;
180
202
NICInfo nd_table[MAX_NICS];
181
203
int vm_running;
182
int rtc_utc = 1;
183
int rtc_start_date = -1; /* -1 means now */
204
static int rtc_utc = 1;
205
static int rtc_date_offset = -1; /* -1 means no change */
184
206
int cirrus_vga_enabled = 1;
207
int std_vga_enabled = 0;
185
208
int vmsvga_enabled = 0;
186
209
#ifdef TARGET_SPARC
187
210
int graphic_width = 1024;
192
215
int graphic_height = 600;
193
216
int graphic_depth = 15;
194
217
#endif
195
int full_screen = 0;
196
int no_frame = 0;
218
static int full_screen = 0;
219
#ifdef CONFIG_SDL
220
static int no_frame = 0;
221
#endif
197
222
int no_quit = 0;
198
223
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
199
224
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
225
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
200
226
#ifdef TARGET_I386
201
227
int win2k_install_hack = 0;
228
int rtc_td_hack = 0;
202
229
#endif
203
230
int usb_enabled = 0;
204
static VLANState *first_vlan;
205
231
int smp_cpus = 1;
206
232
const char *vnc_display;
207
#if defined(TARGET_SPARC)
208
#define MAX_CPUS 16
209
#elif defined(TARGET_I386)
210
#define MAX_CPUS 255
211
#else
212
#define MAX_CPUS 1
213
#endif
214
233
int acpi_enabled = 1;
234
int no_hpet = 0;
215
235
int fd_bootchk = 1;
216
236
int no_reboot = 0;
237
int no_shutdown = 0;
217
238
int cursor_hide = 1;
218
239
int graphic_rotate = 0;
219
240
int daemonize = 0;
220
241
const char *option_rom[MAX_OPTION_ROMS];
221
242
int nb_option_roms;
222
243
int semihosting_enabled = 0;
223
int autostart = 1;
224
244
#ifdef TARGET_ARM
225
245
int old_param = 0;
226
246
#endif
227
247
const char *qemu_name;
228
248
int alt_grab = 0;
229
#ifdef TARGET_SPARC
249
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
230
250
unsigned int nb_prom_envs = 0;
231
251
const char *prom_envs[MAX_PROM_ENVS];
232
252
#endif
233
253
int nb_drives_opt;
234
char drives_opt[MAX_DRIVES][1024];
254
struct drive_opt drives_opt[MAX_DRIVES];
235
255
236
256
static CPUState *cur_cpu;
237
257
static CPUState *next_cpu;
238
258
static int event_pending = 1;
259
/* Conversion factor from emulated instructions to virtual clock ticks. */
260
static int icount_time_shift;
261
/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
262
#define MAX_ICOUNT_SHIFT 10
263
/* Compensate for varying guest execution speed. */
264
static int64_t qemu_icount_bias;
265
static QEMUTimer *icount_rt_timer;
266
static QEMUTimer *icount_vm_timer;
267
static QEMUTimer *nographic_timer;
239
268
240
#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
269
uint8_t qemu_uuid[16];
241
270
242
271
/***********************************************************/
243
272
/* x86 ISA bus support */
245
274
target_phys_addr_t isa_mem_base = 0;
246
275
PicState2 *isa_pic;
247
276
277
static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
278
static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
279
280
static uint32_t ioport_read(int index, uint32_t address)
281
{
282
static IOPortReadFunc *default_func[3] = {
283
default_ioport_readb,
284
default_ioport_readw,
285
default_ioport_readl
286
};
287
IOPortReadFunc *func = ioport_read_table[index][address];
288
if (!func)
289
func = default_func[index];
290
return func(ioport_opaque[address], address);
291
}
292
293
static void ioport_write(int index, uint32_t address, uint32_t data)
294
{
295
static IOPortWriteFunc *default_func[3] = {
296
default_ioport_writeb,
297
default_ioport_writew,
298
default_ioport_writel
299
};
300
IOPortWriteFunc *func = ioport_write_table[index][address];
301
if (!func)
302
func = default_func[index];
303
func(ioport_opaque[address], address, data);
304
}
305
248
306
static uint32_t default_ioport_readb(void *opaque, uint32_t address)
249
307
{
250
308
#ifdef DEBUG_UNUSED_IOPORT
264
322
static uint32_t default_ioport_readw(void *opaque, uint32_t address)
265
323
{
266
324
uint32_t data;
267
data = ioport_read_table[0][address](ioport_opaque[address], address);
325
data = ioport_read(0, address);
268
326
address = (address + 1) & (MAX_IOPORTS - 1);
269
data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
327
data |= ioport_read(0, address) << 8;
270
328
return data;
271
329
}
272
330
273
331
static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
274
332
{
275
ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
333
ioport_write(0, address, data & 0xff);
276
334
address = (address + 1) & (MAX_IOPORTS - 1);
277
ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
335
ioport_write(0, address, (data >> 8) & 0xff);
278
336
}
279
337
280
338
static uint32_t default_ioport_readl(void *opaque, uint32_t address)
292
350
#endif
293
351
}
294
352
295
static void init_ioports(void)
296
{
297
int i;
298
299
for(i = 0; i < MAX_IOPORTS; i++) {
300
ioport_read_table[0][i] = default_ioport_readb;
301
ioport_write_table[0][i] = default_ioport_writeb;
302
ioport_read_table[1][i] = default_ioport_readw;
303
ioport_write_table[1][i] = default_ioport_writew;
304
ioport_read_table[2][i] = default_ioport_readl;
305
ioport_write_table[2][i] = default_ioport_writel;
306
}
307
}
308
309
353
/* size is the word size in byte */
310
354
int register_ioport_read(int start, int length, int size,
311
355
IOPortReadFunc *func, void *opaque)
368
412
ioport_write_table[0][i] = default_ioport_writeb;
369
413
ioport_write_table[1][i] = default_ioport_writew;
370
414
ioport_write_table[2][i] = default_ioport_writel;
415
416
ioport_opaque[i] = NULL;
371
417
}
372
418
}
373
419
375
421
376
422
void cpu_outb(CPUState *env, int addr, int val)
377
423
{
378
#ifdef DEBUG_IOPORT
379
if (loglevel & CPU_LOG_IOPORT)
380
fprintf(logfile, "outb: %04x %02x\n", addr, val);
381
#endif
382
ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
424
LOG_IOPORT("outb: %04x %02x\n", addr, val);
425
ioport_write(0, addr, val);
383
426
#ifdef USE_KQEMU
384
427
if (env)
385
428
env->last_io_time = cpu_get_time_fast();
388
431
389
432
void cpu_outw(CPUState *env, int addr, int val)
390
433
{
391
#ifdef DEBUG_IOPORT
392
if (loglevel & CPU_LOG_IOPORT)
393
fprintf(logfile, "outw: %04x %04x\n", addr, val);
394
#endif
395
ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
434
LOG_IOPORT("outw: %04x %04x\n", addr, val);
435
ioport_write(1, addr, val);
396
436
#ifdef USE_KQEMU
397
437
if (env)
398
438
env->last_io_time = cpu_get_time_fast();
401
441
402
442
void cpu_outl(CPUState *env, int addr, int val)
403
443
{
404
#ifdef DEBUG_IOPORT
405
if (loglevel & CPU_LOG_IOPORT)
406
fprintf(logfile, "outl: %04x %08x\n", addr, val);
407
#endif
408
ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
444
LOG_IOPORT("outl: %04x %08x\n", addr, val);
445
ioport_write(2, addr, val);
409
446
#ifdef USE_KQEMU
410
447
if (env)
411
448
env->last_io_time = cpu_get_time_fast();
415
452
int cpu_inb(CPUState *env, int addr)
416
453
{
417
454
int val;
418
val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
419
#ifdef DEBUG_IOPORT
420
if (loglevel & CPU_LOG_IOPORT)
421
fprintf(logfile, "inb : %04x %02x\n", addr, val);
422
#endif
455
val = ioport_read(0, addr);
456
LOG_IOPORT("inb : %04x %02x\n", addr, val);
423
457
#ifdef USE_KQEMU
424
458
if (env)
425
459
env->last_io_time = cpu_get_time_fast();
430
464
int cpu_inw(CPUState *env, int addr)
431
465
{
432
466
int val;
433
val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
434
#ifdef DEBUG_IOPORT
435
if (loglevel & CPU_LOG_IOPORT)
436
fprintf(logfile, "inw : %04x %04x\n", addr, val);
437
#endif
467
val = ioport_read(1, addr);
468
LOG_IOPORT("inw : %04x %04x\n", addr, val);
438
469
#ifdef USE_KQEMU
439
470
if (env)
440
471
env->last_io_time = cpu_get_time_fast();
445
476
int cpu_inl(CPUState *env, int addr)
446
477
{
447
478
int val;
448
val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
449
#ifdef DEBUG_IOPORT
450
if (loglevel & CPU_LOG_IOPORT)
451
fprintf(logfile, "inl : %04x %08x\n", addr, val);
452
#endif
479
val = ioport_read(2, addr);
480
LOG_IOPORT("inl : %04x %08x\n", addr, val);
453
481
#ifdef USE_KQEMU
454
482
if (env)
455
483
env->last_io_time = cpu_get_time_fast();
478
506
va_end(ap);
479
507
abort();
480
508
}
509
510
/***************/
511
/* ballooning */
512
513
static QEMUBalloonEvent *qemu_balloon_event;
514
void *qemu_balloon_event_opaque;
515
516
void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
517
{
518
qemu_balloon_event = func;
519
qemu_balloon_event_opaque = opaque;
520
}
521
522
void qemu_balloon(ram_addr_t target)
523
{
524
if (qemu_balloon_event)
525
qemu_balloon_event(qemu_balloon_event_opaque, target);
526
}
527
528
ram_addr_t qemu_balloon_status(void)
529
{
530
if (qemu_balloon_event)
531
return qemu_balloon_event(qemu_balloon_event_opaque, 0);
532
return 0;
533
}
481
534
482
535
/***********************************************************/
483
536
/* keyboard/mouse */
500
553
QEMUPutMouseEntry *s, *cursor;
501
554
502
555
s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
503
if (!s)
504
return NULL;
505
556
506
557
s->qemu_put_mouse_event = func;
507
558
s->qemu_put_mouse_event_opaque = opaque;
584
635
if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
585
636
width = 0x7fff;
586
637
else
587
width = graphic_width;
638
width = graphic_width - 1;
588
639
mouse_event(mouse_event_opaque,
589
640
width - dy, dx, dz, buttons_state);
590
641
} else
703
754
static void init_get_clock(void)
704
755
{
705
756
use_rt_clock = 0;
706
#if defined(__linux__)
757
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
707
758
{
708
759
struct timespec ts;
709
760
if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
715
766
716
767
static int64_t get_clock(void)
717
768
{
718
#if defined(__linux__)
769
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
719
770
if (use_rt_clock) {
720
771
struct timespec ts;
721
772
clock_gettime(CLOCK_MONOTONIC, &ts);
730
781
return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
731
782
}
732
783
}
733
734
784
#endif
735
785
786
/* Return the virtual CPU time, based on the instruction counter. */
787
static int64_t cpu_get_icount(void)
788
{
789
int64_t icount;
790
CPUState *env = cpu_single_env;;
791
icount = qemu_icount;
792
if (env) {
793
if (!can_do_io(env))
794
fprintf(stderr, "Bad clock read\n");
795
icount -= (env->icount_decr.u16.low + env->icount_extra);
796
}
797
return qemu_icount_bias + (icount << icount_time_shift);
798
}
799
736
800
/***********************************************************/
737
801
/* guest cycle counter */
738
802
744
808
/* return the host CPU cycle counter and handle stop/restart */
745
809
int64_t cpu_get_ticks(void)
746
810
{
811
if (use_icount) {
812
return cpu_get_icount();
813
}
747
814
if (!cpu_ticks_enabled) {
748
815
return cpu_ticks_offset;
749
816
} else {
841
908
#define MIN_TIMER_REARM_US 250
842
909
843
910
static struct qemu_alarm_timer *alarm_timer;
911
#ifndef _WIN32
912
static int alarm_timer_rfd, alarm_timer_wfd;
913
#endif
844
914
845
915
#ifdef _WIN32
846
916
875
945
876
946
#endif /* _WIN32 */
877
947
948
/* Correlation between real and virtual time is always going to be
949
fairly approximate, so ignore small variation.
950
When the guest is idle real and virtual time will be aligned in
951
the IO wait loop. */
952
#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
953
954
static void icount_adjust(void)
955
{
956
int64_t cur_time;
957
int64_t cur_icount;
958
int64_t delta;
959
static int64_t last_delta;
960
/* If the VM is not running, then do nothing. */
961
if (!vm_running)
962
return;
963
964
cur_time = cpu_get_clock();
965
cur_icount = qemu_get_clock(vm_clock);
966
delta = cur_icount - cur_time;
967
/* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
968
if (delta > 0
969
&& last_delta + ICOUNT_WOBBLE < delta * 2
970
&& icount_time_shift > 0) {
971
/* The guest is getting too far ahead. Slow time down. */
972
icount_time_shift--;
973
}
974
if (delta < 0
975
&& last_delta - ICOUNT_WOBBLE > delta * 2
976
&& icount_time_shift < MAX_ICOUNT_SHIFT) {
977
/* The guest is getting too far behind. Speed time up. */
978
icount_time_shift++;
979
}
980
last_delta = delta;
981
qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
982
}
983
984
static void icount_adjust_rt(void * opaque)
985
{
986
qemu_mod_timer(icount_rt_timer,
987
qemu_get_clock(rt_clock) + 1000);
988
icount_adjust();
989
}
990
991
static void icount_adjust_vm(void * opaque)
992
{
993
qemu_mod_timer(icount_vm_timer,
994
qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
995
icount_adjust();
996
}
997
998
static void init_icount_adjust(void)
999
{
1000
/* Have both realtime and virtual time triggers for speed adjustment.
1001
The realtime trigger catches emulated time passing too slowly,
1002
the virtual time trigger catches emulated time passing too fast.
1003
Realtime triggers occur even when idle, so use them less frequently
1004
than VM triggers. */
1005
icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
1006
qemu_mod_timer(icount_rt_timer,
1007
qemu_get_clock(rt_clock) + 1000);
1008
icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
1009
qemu_mod_timer(icount_vm_timer,
1010
qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1011
}
1012
878
1013
static struct qemu_alarm_timer alarm_timers[] = {
879
1014
#ifndef _WIN32
880
1015
#ifdef __linux__
895
1030
{NULL, }
896
1031
};
897
1032
898
static void show_available_alarms()
1033
static void show_available_alarms(void)
899
1034
{
900
1035
int i;
901
1036
908
1043
{
909
1044
int i;
910
1045
int cur = 0;
911
int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
1046
int count = ARRAY_SIZE(alarm_timers) - 1;
912
1047
char *arg;
913
1048
char *name;
1049
struct qemu_alarm_timer tmp;
914
1050
915
if (!strcmp(opt, "help")) {
1051
if (!strcmp(opt, "?")) {
916
1052
show_available_alarms();
917
1053
exit(0);
918
1054
}
922
1058
/* Reorder the array */
923
1059
name = strtok(arg, ",");
924
1060
while (name) {
925
struct qemu_alarm_timer tmp;
926
927
1061
for (i = 0; i < count && alarm_timers[i].name; i++) {
928
1062
if (!strcmp(alarm_timers[i].name, name))
929
1063
break;
951
1085
free(arg);
952
1086
953
1087
if (cur) {
954
/* Disable remaining timers */
1088
/* Disable remaining timers */
955
1089
for (i = cur; i < count; i++)
956
1090
alarm_timers[i].name = NULL;
1091
} else {
1092
show_available_alarms();
1093
exit(1);
957
1094
}
958
959
/* debug */
960
show_available_alarms();
961
1095
}
962
1096
963
1097
QEMUClock *rt_clock;
969
1103
{
970
1104
QEMUClock *clock;
971
1105
clock = qemu_mallocz(sizeof(QEMUClock));
972
if (!clock)
973
return NULL;
974
1106
clock->type = type;
975
1107
return clock;
976
1108
}
1036
1168
*pt = ts;
1037
1169
1038
1170
/* Rearm if necessary */
1039
if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0 &&
1040
pt == &active_timers[ts->clock->type])
1041
qemu_rearm_alarm_timer(alarm_timer);
1171
if (pt == &active_timers[ts->clock->type]) {
1172
if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1173
qemu_rearm_alarm_timer(alarm_timer);
1174
}
1175
/* Interrupt execution to force deadline recalculation. */
1176
if (use_icount && cpu_single_env) {
1177
cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1178
}
1179
}
1042
1180
}
1043
1181
1044
1182
int qemu_timer_pending(QEMUTimer *ts)
1082
1220
return get_clock() / 1000000;
1083
1221
default:
1084
1222
case QEMU_TIMER_VIRTUAL:
1085
return cpu_get_clock();
1223
if (use_icount) {
1224
return cpu_get_icount();
1225
} else {
1226
return cpu_get_clock();
1227
}
1086
1228
}
1087
1229
}
1088
1230
1181
1323
}
1182
1324
#endif
1183
1325
if (alarm_has_dynticks(alarm_timer) ||
1184
qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1185
qemu_get_clock(vm_clock)) ||
1326
(!use_icount &&
1327
qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1328
qemu_get_clock(vm_clock))) ||
1186
1329
qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1187
1330
qemu_get_clock(rt_clock))) {
1331
CPUState *env = next_cpu;
1332
1188
1333
#ifdef _WIN32
1189
1334
struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1190
1335
SetEvent(data->host_alarm);
1336
#else
1337
static const char byte = 0;
1338
write(alarm_timer_wfd, &byte, sizeof(byte));
1191
1339
#endif
1192
CPUState *env = next_cpu;
1193
1194
1340
alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1195
1341
1196
1342
if (env) {
1206
1352
}
1207
1353
}
1208
1354
1209
static uint64_t qemu_next_deadline(void)
1355
static int64_t qemu_next_deadline(void)
1210
1356
{
1211
int64_t nearest_delta_us = INT64_MAX;
1212
int64_t vmdelta_us;
1213
1214
if (active_timers[QEMU_TIMER_REALTIME])
1215
nearest_delta_us = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1216
qemu_get_clock(rt_clock))*1000;
1357
int64_t delta;
1217
1358
1218
1359
if (active_timers[QEMU_TIMER_VIRTUAL]) {
1219
/* round up */
1220
vmdelta_us = (active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1221
qemu_get_clock(vm_clock)+999)/1000;
1222
if (vmdelta_us < nearest_delta_us)
1223
nearest_delta_us = vmdelta_us;
1224
}
1225
1226
/* Avoid arming the timer to negative, zero, or too low values */
1227
if (nearest_delta_us <= MIN_TIMER_REARM_US)
1228
nearest_delta_us = MIN_TIMER_REARM_US;
1229
1230
return nearest_delta_us;
1231
}
1360
delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1361
qemu_get_clock(vm_clock);
1362
} else {
1363
/* To avoid problems with overflow limit this to 2^32. */
1364
delta = INT32_MAX;
1365
}
1366
1367
if (delta < 0)
1368
delta = 0;
1369
1370
return delta;
1371
}
1372
1373
#if defined(__linux__) || defined(_WIN32)
1374
static uint64_t qemu_next_deadline_dyntick(void)
1375
{
1376
int64_t delta;
1377
int64_t rtdelta;
1378
1379
if (use_icount)
1380
delta = INT32_MAX;
1381
else
1382
delta = (qemu_next_deadline() + 999) / 1000;
1383
1384
if (active_timers[QEMU_TIMER_REALTIME]) {
1385
rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1386
qemu_get_clock(rt_clock))*1000;
1387
if (rtdelta < delta)
1388
delta = rtdelta;
1389
}
1390
1391
if (delta < MIN_TIMER_REARM_US)
1392
delta = MIN_TIMER_REARM_US;
1393
1394
return delta;
1395
}
1396
#endif
1232
1397
1233
1398
#ifndef _WIN32
1234
1399
1400
/* Sets a specific flag */
1401
static int fcntl_setfl(int fd, int flag)
1402
{
1403
int flags;
1404
1405
flags = fcntl(fd, F_GETFL);
1406
if (flags == -1)
1407
return -errno;
1408
1409
if (fcntl(fd, F_SETFL, flags | flag) == -1)
1410
return -errno;
1411
1412
return 0;
1413
}
1414
1235
1415
#if defined(__linux__)
1236
1416
1237
1417
#define RTC_FREQ 1024
1246
1426
act.sa_handler = host_alarm_handler;
1247
1427
1248
1428
sigaction(SIGIO, &act, NULL);
1249
fcntl(fd, F_SETFL, O_ASYNC);
1429
fcntl_setfl(fd, O_ASYNC);
1250
1430
fcntl(fd, F_SETOWN, getpid());
1251
1431
}
1252
1432
1302
1482
static int rtc_start_timer(struct qemu_alarm_timer *t)
1303
1483
{
1304
1484
int rtc_fd;
1485
unsigned long current_rtc_freq = 0;
1305
1486
1306
1487
TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1307
1488
if (rtc_fd < 0)
1308
1489
return -1;
1309
if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1490
ioctl(rtc_fd, RTC_IRQP_READ, ¤t_rtc_freq);
1491
if (current_rtc_freq != RTC_FREQ &&
1492
ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1310
1493
fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1311
1494
"error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1312
1495
"type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1357
1540
return -1;
1358
1541
}
1359
1542
1360
t->priv = (void *)host_timer;
1543
t->priv = (void *)(long)host_timer;
1361
1544
1362
1545
return 0;
1363
1546
}
1364
1547
1365
1548
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1366
1549
{
1367
timer_t host_timer = (timer_t)t->priv;
1550
timer_t host_timer = (timer_t)(long)t->priv;
1368
1551
1369
1552
timer_delete(host_timer);
1370
1553
}
1371
1554
1372
1555
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1373
1556
{
1374
timer_t host_timer = (timer_t)t->priv;
1557
timer_t host_timer = (timer_t)(long)t->priv;
1375
1558
struct itimerspec timeout;
1376
1559
int64_t nearest_delta_us = INT64_MAX;
1377
1560
int64_t current_us;
1380
1563
!active_timers[QEMU_TIMER_VIRTUAL])
1381
1564
return;
1382
1565
1383
nearest_delta_us = qemu_next_deadline();
1566
nearest_delta_us = qemu_next_deadline_dyntick();
1384
1567
1385
1568
/* check whether a timer is already running */
1386
1569
if (timer_gettime(host_timer, &timeout)) {
1441
1624
1442
1625
#endif /* !defined(_WIN32) */
1443
1626
1627
static void try_to_rearm_timer(void *opaque)
1628
{
1629
struct qemu_alarm_timer *t = opaque;
1630
#ifndef _WIN32
1631
ssize_t len;
1632
1633
/* Drain the notify pipe */
1634
do {
1635
char buffer[512];
1636
len = read(alarm_timer_rfd, buffer, sizeof(buffer));
1637
} while ((len == -1 && errno == EINTR) || len > 0);
1638
#endif
1639
1640
if (t->flags & ALARM_FLAG_EXPIRED) {
1641
alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
1642
qemu_rearm_alarm_timer(alarm_timer);
1643
}
1644
}
1645
1444
1646
#ifdef _WIN32
1445
1647
1446
1648
static int win32_start_timer(struct qemu_alarm_timer *t)
1483
1685
return -1;
1484
1686
}
1485
1687
1486
qemu_add_wait_object(data->host_alarm, NULL, NULL);
1688
qemu_add_wait_object(data->host_alarm, try_to_rearm_timer, t);
1487
1689
1488
1690
return 0;
1489
1691
}
1507
1709
!active_timers[QEMU_TIMER_VIRTUAL])
1508
1710
return;
1509
1711
1510
nearest_delta_us = qemu_next_deadline();
1712
nearest_delta_us = qemu_next_deadline_dyntick();
1511
1713
nearest_delta_us /= 1000;
1512
1714
1513
1715
timeKillEvent(data->timerId);
1529
1731
1530
1732
#endif /* _WIN32 */
1531
1733
1532
static void init_timer_alarm(void)
1734
static int init_timer_alarm(void)
1533
1735
{
1534
struct qemu_alarm_timer *t;
1736
struct qemu_alarm_timer *t = NULL;
1535
1737
int i, err = -1;
1536
1738
1739
#ifndef _WIN32
1740
int fds[2];
1741
1742
err = pipe(fds);
1743
if (err == -1)
1744
return -errno;
1745
1746
err = fcntl_setfl(fds[0], O_NONBLOCK);
1747
if (err < 0)
1748
goto fail;
1749
1750
err = fcntl_setfl(fds[1], O_NONBLOCK);
1751
if (err < 0)
1752
goto fail;
1753
1754
alarm_timer_rfd = fds[0];
1755
alarm_timer_wfd = fds[1];
1756
#endif
1757
1537
1758
for (i = 0; alarm_timers[i].name; i++) {
1538
1759
t = &alarm_timers[i];
1539
1760
1543
1764
}
1544
1765
1545
1766
if (err) {
1546
fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1547
fprintf(stderr, "Terminating\n");
1548
exit(1);
1767
err = -ENOENT;
1768
goto fail;
1549
1769
}
1550
1770
1771
#ifndef _WIN32
1772
qemu_set_fd_handler2(alarm_timer_rfd, NULL,
1773
try_to_rearm_timer, NULL, t);
1774
#endif
1775
1551
1776
alarm_timer = t;
1777
1778
return 0;
1779
1780
fail:
1781
#ifndef _WIN32
1782
close(fds[0]);
1783
close(fds[1]);
1784
#endif
1785
return err;
1552
1786
}
1553
1787
1554
1788
static void quit_timers(void)
1558
1792
}
1559
1793
1560
1794
/***********************************************************/
1561
/* character device */
1562
1563
static void qemu_chr_event(CharDriverState *s, int event)
1564
{
1565
if (!s->chr_event)
1566
return;
1567
s->chr_event(s->handler_opaque, event);
1568
}
1569
1570
static void qemu_chr_reset_bh(void *opaque)
1571
{
1572
CharDriverState *s = opaque;
1573
qemu_chr_event(s, CHR_EVENT_RESET);
1574
qemu_bh_delete(s->bh);
1575
s->bh = NULL;
1576
}
1577
1578
void qemu_chr_reset(CharDriverState *s)
1579
{
1580
if (s->bh == NULL) {
1581
s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1582
qemu_bh_schedule(s->bh);
1583
}
1584
}
1585
1586
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1587
{
1588
return s->chr_write(s, buf, len);
1589
}
1590
1591
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1592
{
1593
if (!s->chr_ioctl)
1594
return -ENOTSUP;
1595
return s->chr_ioctl(s, cmd, arg);
1596
}
1597
1598
int qemu_chr_can_read(CharDriverState *s)
1599
{
1600
if (!s->chr_can_read)
1601
return 0;
1602
return s->chr_can_read(s->handler_opaque);
1603
}
1604
1605
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1606
{
1607
s->chr_read(s->handler_opaque, buf, len);
1608
}
1609
1610
void qemu_chr_accept_input(CharDriverState *s)
1611
{
1612
if (s->chr_accept_input)
1613
s->chr_accept_input(s);
1614
}
1615
1616
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1617
{
1618
char buf[4096];
1619
va_list ap;
1620
va_start(ap, fmt);
1621
vsnprintf(buf, sizeof(buf), fmt, ap);
1622
qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1623
va_end(ap);
1624
}
1625
1626
void qemu_chr_send_event(CharDriverState *s, int event)
1627
{
1628
if (s->chr_send_event)
1629
s->chr_send_event(s, event);
1630
}
1631
1632
void qemu_chr_add_handlers(CharDriverState *s,
1633
IOCanRWHandler *fd_can_read,
1634
IOReadHandler *fd_read,
1635
IOEventHandler *fd_event,
1636
void *opaque)
1637
{
1638
s->chr_can_read = fd_can_read;
1639
s->chr_read = fd_read;
1640
s->chr_event = fd_event;
1641
s->handler_opaque = opaque;
1642
if (s->chr_update_read_handler)
1643
s->chr_update_read_handler(s);
1644
}
1645
1646
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1647
{
1648
return len;
1649
}
1650
1651
static CharDriverState *qemu_chr_open_null(void)
1652
{
1653
CharDriverState *chr;
1654
1655
chr = qemu_mallocz(sizeof(CharDriverState));
1656
if (!chr)
1657
return NULL;
1658
chr->chr_write = null_chr_write;
1659
return chr;
1660
}
1661
1662
/* MUX driver for serial I/O splitting */
1663
static int term_timestamps;
1664
static int64_t term_timestamps_start;
1665
#define MAX_MUX 4
1666
#define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1667
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1668
typedef struct {
1669
IOCanRWHandler *chr_can_read[MAX_MUX];
1670
IOReadHandler *chr_read[MAX_MUX];
1671
IOEventHandler *chr_event[MAX_MUX];
1672
void *ext_opaque[MAX_MUX];
1673
CharDriverState *drv;
1674
unsigned char buffer[MUX_BUFFER_SIZE];
1675
int prod;
1676
int cons;
1677
int mux_cnt;
1678
int term_got_escape;
1679
int max_size;
1680
} MuxDriver;
1681
1682
1683
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1684
{
1685
MuxDriver *d = chr->opaque;
1686
int ret;
1687
if (!term_timestamps) {
1688
ret = d->drv->chr_write(d->drv, buf, len);
1689
} else {
1690
int i;
1691
1692
ret = 0;
1693
for(i = 0; i < len; i++) {
1694
ret += d->drv->chr_write(d->drv, buf+i, 1);
1695
if (buf[i] == '\n') {
1696
char buf1[64];
1697
int64_t ti;
1698
int secs;
1699
1700
ti = get_clock();
1701
if (term_timestamps_start == -1)
1702
term_timestamps_start = ti;
1703
ti -= term_timestamps_start;
1704
secs = ti / 1000000000;
1705
snprintf(buf1, sizeof(buf1),
1706
"[%02d:%02d:%02d.%03d] ",
1707
secs / 3600,
1708
(secs / 60) % 60,
1709
secs % 60,
1710
(int)((ti / 1000000) % 1000));
1711
d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1712
}
1713
}
1714
}
1715
return ret;
1716
}
1717
1718
static char *mux_help[] = {
1719
"% h print this help\n\r",
1720
"% x exit emulator\n\r",
1721
"% s save disk data back to file (if -snapshot)\n\r",
1722
"% t toggle console timestamps\n\r"
1723
"% b send break (magic sysrq)\n\r",
1724
"% c switch between console and monitor\n\r",
1725
"% % sends %\n\r",
1726
NULL
1727
};
1728
1729
static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1730
static void mux_print_help(CharDriverState *chr)
1731
{
1732
int i, j;
1733
char ebuf[15] = "Escape-Char";
1734
char cbuf[50] = "\n\r";
1735
1736
if (term_escape_char > 0 && term_escape_char < 26) {
1737
sprintf(cbuf,"\n\r");
1738
sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1739
} else {
1740
sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1741
term_escape_char);
1742
}
1743
chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1744
for (i = 0; mux_help[i] != NULL; i++) {
1745
for (j=0; mux_help[i][j] != '\0'; j++) {
1746
if (mux_help[i][j] == '%')
1747
chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1748
else
1749
chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1750
}
1751
}
1752
}
1753
1754
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1755
{
1756
if (d->term_got_escape) {
1757
d->term_got_escape = 0;
1758
if (ch == term_escape_char)
1759
goto send_char;
1760
switch(ch) {
1761
case '?':
1762
case 'h':
1763
mux_print_help(chr);
1764
break;
1765
case 'x':
1766
{
1767
char *term = "QEMU: Terminated\n\r";
1768
chr->chr_write(chr,(uint8_t *)term,strlen(term));
1769
exit(0);
1770
break;
1771
}
1772
case 's':
1773
{
1774
int i;
1775
for (i = 0; i < nb_drives; i++) {
1776
bdrv_commit(drives_table[i].bdrv);
1777
}
1778
}
1779
break;
1780
case 'b':
1781
qemu_chr_event(chr, CHR_EVENT_BREAK);
1782
break;
1783
case 'c':
1784
/* Switch to the next registered device */
1785
chr->focus++;
1786
if (chr->focus >= d->mux_cnt)
1787
chr->focus = 0;
1788
break;
1789
case 't':
1790
term_timestamps = !term_timestamps;
1791
term_timestamps_start = -1;
1792
break;
1793
}
1794
} else if (ch == term_escape_char) {
1795
d->term_got_escape = 1;
1796
} else {
1797
send_char:
1798
return 1;
1799
}
1800
return 0;
1801
}
1802
1803
static void mux_chr_accept_input(CharDriverState *chr)
1804
{
1805
int m = chr->focus;
1806
MuxDriver *d = chr->opaque;
1807
1808
while (d->prod != d->cons &&
1809
d->chr_can_read[m] &&
1810
d->chr_can_read[m](d->ext_opaque[m])) {
1811
d->chr_read[m](d->ext_opaque[m],
1812
&d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
1813
}
1814
}
1815
1816
static int mux_chr_can_read(void *opaque)
1817
{
1818
CharDriverState *chr = opaque;
1819
MuxDriver *d = chr->opaque;
1820
1821
if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
1822
return 1;
1823
if (d->chr_can_read[chr->focus])
1824
return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1825
return 0;
1826
}
1827
1828
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1829
{
1830
CharDriverState *chr = opaque;
1831
MuxDriver *d = chr->opaque;
1832
int m = chr->focus;
1833
int i;
1834
1835
mux_chr_accept_input (opaque);
1836
1837
for(i = 0; i < size; i++)
1838
if (mux_proc_byte(chr, d, buf[i])) {
1839
if (d->prod == d->cons &&
1840
d->chr_can_read[m] &&
1841
d->chr_can_read[m](d->ext_opaque[m]))
1842
d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
1843
else
1844
d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
1845
}
1846
}
1847
1848
static void mux_chr_event(void *opaque, int event)
1849
{
1850
CharDriverState *chr = opaque;
1851
MuxDriver *d = chr->opaque;
1852
int i;
1853
1854
/* Send the event to all registered listeners */
1855
for (i = 0; i < d->mux_cnt; i++)
1856
if (d->chr_event[i])
1857
d->chr_event[i](d->ext_opaque[i], event);
1858
}
1859
1860
static void mux_chr_update_read_handler(CharDriverState *chr)
1861
{
1862
MuxDriver *d = chr->opaque;
1863
1864
if (d->mux_cnt >= MAX_MUX) {
1865
fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
1866
return;
1867
}
1868
d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
1869
d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
1870
d->chr_read[d->mux_cnt] = chr->chr_read;
1871
d->chr_event[d->mux_cnt] = chr->chr_event;
1872
/* Fix up the real driver with mux routines */
1873
if (d->mux_cnt == 0) {
1874
qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
1875
mux_chr_event, chr);
1876
}
1877
chr->focus = d->mux_cnt;
1878
d->mux_cnt++;
1879
}
1880
1881
static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
1882
{
1883
CharDriverState *chr;
1884
MuxDriver *d;
1885
1886
chr = qemu_mallocz(sizeof(CharDriverState));
1887
if (!chr)
1888
return NULL;
1889
d = qemu_mallocz(sizeof(MuxDriver));
1890
if (!d) {
1891
free(chr);
1892
return NULL;
1893
}
1894
1895
chr->opaque = d;
1896
d->drv = drv;
1897
chr->focus = -1;
1898
chr->chr_write = mux_chr_write;
1899
chr->chr_update_read_handler = mux_chr_update_read_handler;
1900
chr->chr_accept_input = mux_chr_accept_input;
1901
return chr;
1902
}
1903
1795
/* host time/date access */
1796
void qemu_get_timedate(struct tm *tm, int offset)
1797
{
1798
time_t ti;
1799
struct tm *ret;
1800
1801
time(&ti);
1802
ti += offset;
1803
if (rtc_date_offset == -1) {
1804
if (rtc_utc)
1805
ret = gmtime(&ti);
1806
else
1807
ret = localtime(&ti);
1808
} else {
1809
ti -= rtc_date_offset;
1810
ret = gmtime(&ti);
1811
}
1812
1813
memcpy(tm, ret, sizeof(struct tm));
1814
}
1815
1816
int qemu_timedate_diff(struct tm *tm)
1817
{
1818
time_t seconds;
1819
1820
if (rtc_date_offset == -1)
1821
if (rtc_utc)
1822
seconds = mktimegm(tm);
1823
else
1824
seconds = mktime(tm);
1825
else
1826
seconds = mktimegm(tm) + rtc_date_offset;
1827
1828
return seconds - time(NULL);
1829
}
1904
1830
1905
1831
#ifdef _WIN32
1906
1907
1832
static void socket_cleanup(void)
1908
1833
{
1909
1834
WSACleanup();
1923
1848
atexit(socket_cleanup);
1924
1849
return 0;
1925
1850
}
1926
1927
static int send_all(int fd, const uint8_t *buf, int len1)
1928
{
1929
int ret, len;
1930
1931
len = len1;
1932
while (len > 0) {
1933
ret = send(fd, buf, len, 0);
1934
if (ret < 0) {
1935
int errno;
1936
errno = WSAGetLastError();
1937
if (errno != WSAEWOULDBLOCK) {
1938
return -1;
1939
}
1940
} else if (ret == 0) {
1941
break;
1942
} else {
1943
buf += ret;
1944
len -= ret;
1945
}
1946
}
1947
return len1 - len;
1948
}
1949
1950
void socket_set_nonblock(int fd)
1951
{
1952
unsigned long opt = 1;
1953
ioctlsocket(fd, FIONBIO, &opt);
1954
}
1955
1956
#else
1957
1958
static int unix_write(int fd, const uint8_t *buf, int len1)
1959
{
1960
int ret, len;
1961
1962
len = len1;
1963
while (len > 0) {
1964
ret = write(fd, buf, len);
1965
if (ret < 0) {
1966
if (errno != EINTR && errno != EAGAIN)
1967
return -1;
1968
} else if (ret == 0) {
1969
break;
1970
} else {
1971
buf += ret;
1972
len -= ret;
1973
}
1974
}
1975
return len1 - len;
1976
}
1977
1978
static inline int send_all(int fd, const uint8_t *buf, int len1)
1979
{
1980
return unix_write(fd, buf, len1);
1981
}
1982
1983
void socket_set_nonblock(int fd)
1984
{
1985
fcntl(fd, F_SETFL, O_NONBLOCK);
1986
}
1987
#endif /* !_WIN32 */
1988
1989
#ifndef _WIN32
1990
1991
typedef struct {
1992
int fd_in, fd_out;
1993
int max_size;
1994
} FDCharDriver;
1995
1996
#define STDIO_MAX_CLIENTS 1
1997
static int stdio_nb_clients = 0;
1998
1999
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2000
{
2001
FDCharDriver *s = chr->opaque;
2002
return unix_write(s->fd_out, buf, len);
2003
}
2004
2005
static int fd_chr_read_poll(void *opaque)
2006
{
2007
CharDriverState *chr = opaque;
2008
FDCharDriver *s = chr->opaque;
2009
2010
s->max_size = qemu_chr_can_read(chr);
2011
return s->max_size;
2012
}
2013
2014
static void fd_chr_read(void *opaque)
2015
{
2016
CharDriverState *chr = opaque;
2017
FDCharDriver *s = chr->opaque;
2018
int size, len;
2019
uint8_t buf[1024];
2020
2021
len = sizeof(buf);
2022
if (len > s->max_size)
2023
len = s->max_size;
2024
if (len == 0)
2025
return;
2026
size = read(s->fd_in, buf, len);
2027
if (size == 0) {
2028
/* FD has been closed. Remove it from the active list. */
2029
qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2030
return;
2031
}
2032
if (size > 0) {
2033
qemu_chr_read(chr, buf, size);
2034
}
2035
}
2036
2037
static void fd_chr_update_read_handler(CharDriverState *chr)
2038
{
2039
FDCharDriver *s = chr->opaque;
2040
2041
if (s->fd_in >= 0) {
2042
if (nographic && s->fd_in == 0) {
2043
} else {
2044
qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2045
fd_chr_read, NULL, chr);
2046
}
2047
}
2048
}
2049
2050
/* open a character device to a unix fd */
2051
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2052
{
2053
CharDriverState *chr;
2054
FDCharDriver *s;
2055
2056
chr = qemu_mallocz(sizeof(CharDriverState));
2057
if (!chr)
2058
return NULL;
2059
s = qemu_mallocz(sizeof(FDCharDriver));
2060
if (!s) {
2061
free(chr);
2062
return NULL;
2063
}
2064
s->fd_in = fd_in;
2065
s->fd_out = fd_out;
2066
chr->opaque = s;
2067
chr->chr_write = fd_chr_write;
2068
chr->chr_update_read_handler = fd_chr_update_read_handler;
2069
2070
qemu_chr_reset(chr);
2071
2072
return chr;
2073
}
2074
2075
static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2076
{
2077
int fd_out;
2078
2079
TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2080
if (fd_out < 0)
2081
return NULL;
2082
return qemu_chr_open_fd(-1, fd_out);
2083
}
2084
2085
static CharDriverState *qemu_chr_open_pipe(const char *filename)
2086
{
2087
int fd_in, fd_out;
2088
char filename_in[256], filename_out[256];
2089
2090
snprintf(filename_in, 256, "%s.in", filename);
2091
snprintf(filename_out, 256, "%s.out", filename);
2092
TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2093
TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2094
if (fd_in < 0 || fd_out < 0) {
2095
if (fd_in >= 0)
2096
close(fd_in);
2097
if (fd_out >= 0)
2098
close(fd_out);
2099
TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2100
if (fd_in < 0)
2101
return NULL;
2102
}
2103
return qemu_chr_open_fd(fd_in, fd_out);
2104
}
2105
2106
2107
/* for STDIO, we handle the case where several clients use it
2108
(nographic mode) */
2109
2110
#define TERM_FIFO_MAX_SIZE 1
2111
2112
static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2113
static int term_fifo_size;
2114
2115
static int stdio_read_poll(void *opaque)
2116
{
2117
CharDriverState *chr = opaque;
2118
2119
/* try to flush the queue if needed */
2120
if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2121
qemu_chr_read(chr, term_fifo, 1);
2122
term_fifo_size = 0;
2123
}
2124
/* see if we can absorb more chars */
2125
if (term_fifo_size == 0)
2126
return 1;
2127
else
2128
return 0;
2129
}
2130
2131
static void stdio_read(void *opaque)
2132
{
2133
int size;
2134
uint8_t buf[1];
2135
CharDriverState *chr = opaque;
2136
2137
size = read(0, buf, 1);
2138
if (size == 0) {
2139
/* stdin has been closed. Remove it from the active list. */
2140
qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2141
return;
2142
}
2143
if (size > 0) {
2144
if (qemu_chr_can_read(chr) > 0) {
2145
qemu_chr_read(chr, buf, 1);
2146
} else if (term_fifo_size == 0) {
2147
term_fifo[term_fifo_size++] = buf[0];
2148
}
2149
}
2150
}
2151
2152
/* init terminal so that we can grab keys */
2153
static struct termios oldtty;
2154
static int old_fd0_flags;
2155
2156
static void term_exit(void)
2157
{
2158
tcsetattr (0, TCSANOW, &oldtty);
2159
fcntl(0, F_SETFL, old_fd0_flags);
2160
}
2161
2162
static void term_init(void)
2163
{
2164
struct termios tty;
2165
2166
tcgetattr (0, &tty);
2167
oldtty = tty;
2168
old_fd0_flags = fcntl(0, F_GETFL);
2169
2170
tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2171
|INLCR|IGNCR|ICRNL|IXON);
2172
tty.c_oflag |= OPOST;
2173
tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2174
/* if graphical mode, we allow Ctrl-C handling */
2175
if (nographic)
2176
tty.c_lflag &= ~ISIG;
2177
tty.c_cflag &= ~(CSIZE|PARENB);
2178
tty.c_cflag |= CS8;
2179
tty.c_cc[VMIN] = 1;
2180
tty.c_cc[VTIME] = 0;
2181
2182
tcsetattr (0, TCSANOW, &tty);
2183
2184
atexit(term_exit);
2185
2186
fcntl(0, F_SETFL, O_NONBLOCK);
2187
}
2188
2189
static CharDriverState *qemu_chr_open_stdio(void)
2190
{
2191
CharDriverState *chr;
2192
2193
if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2194
return NULL;
2195
chr = qemu_chr_open_fd(0, 1);
2196
qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2197
stdio_nb_clients++;
2198
term_init();
2199
2200
return chr;
2201
}
2202
2203
#if defined(__linux__) || defined(__sun__)
2204
static CharDriverState *qemu_chr_open_pty(void)
2205
{
2206
struct termios tty;
2207
char slave_name[1024];
2208
int master_fd, slave_fd;
2209
2210
#if defined(__linux__)
2211
/* Not satisfying */
2212
if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
2213
return NULL;
2214
}
2215
#endif
2216
2217
/* Disabling local echo and line-buffered output */
2218
tcgetattr (master_fd, &tty);
2219
tty.c_lflag &= ~(ECHO|ICANON|ISIG);
2220
tty.c_cc[VMIN] = 1;
2221
tty.c_cc[VTIME] = 0;
2222
tcsetattr (master_fd, TCSAFLUSH, &tty);
2223
2224
fprintf(stderr, "char device redirected to %s\n", slave_name);
2225
return qemu_chr_open_fd(master_fd, master_fd);
2226
}
2227
2228
static void tty_serial_init(int fd, int speed,
2229
int parity, int data_bits, int stop_bits)
2230
{
2231
struct termios tty;
2232
speed_t spd;
2233
2234
#if 0
2235
printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2236
speed, parity, data_bits, stop_bits);
2237
#endif
2238
tcgetattr (fd, &tty);
2239
2240
switch(speed) {
2241
case 50:
2242
spd = B50;
2243
break;
2244
case 75:
2245
spd = B75;
2246
break;
2247
case 300:
2248
spd = B300;
2249
break;
2250
case 600:
2251
spd = B600;
2252
break;
2253
case 1200:
2254
spd = B1200;
2255
break;
2256
case 2400:
2257
spd = B2400;
2258
break;
2259
case 4800:
2260
spd = B4800;
2261
break;
2262
case 9600:
2263
spd = B9600;
2264
break;
2265
case 19200:
2266
spd = B19200;
2267
break;
2268
case 38400:
2269
spd = B38400;
2270
break;
2271
case 57600:
2272
spd = B57600;
2273
break;
2274
default:
2275
case 115200:
2276
spd = B115200;
2277
break;
2278
}
2279
2280
cfsetispeed(&tty, spd);
2281
cfsetospeed(&tty, spd);
2282
2283
tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2284
|INLCR|IGNCR|ICRNL|IXON);
2285
tty.c_oflag |= OPOST;
2286
tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2287
tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2288
switch(data_bits) {
2289
default:
2290
case 8:
2291
tty.c_cflag |= CS8;
2292
break;
2293
case 7:
2294
tty.c_cflag |= CS7;
2295
break;
2296
case 6:
2297
tty.c_cflag |= CS6;
2298
break;
2299
case 5:
2300
tty.c_cflag |= CS5;
2301
break;
2302
}
2303
switch(parity) {
2304
default:
2305
case 'N':
2306
break;
2307
case 'E':
2308
tty.c_cflag |= PARENB;
2309
break;
2310
case 'O':
2311
tty.c_cflag |= PARENB | PARODD;
2312
break;
2313
}
2314
if (stop_bits == 2)
2315
tty.c_cflag |= CSTOPB;
2316
2317
tcsetattr (fd, TCSANOW, &tty);
2318
}
2319
2320
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2321
{
2322
FDCharDriver *s = chr->opaque;
2323
2324
switch(cmd) {
2325
case CHR_IOCTL_SERIAL_SET_PARAMS:
2326
{
2327
QEMUSerialSetParams *ssp = arg;
2328
tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2329
ssp->data_bits, ssp->stop_bits);
2330
}
2331
break;
2332
case CHR_IOCTL_SERIAL_SET_BREAK:
2333
{
2334
int enable = *(int *)arg;
2335
if (enable)
2336
tcsendbreak(s->fd_in, 1);
2337
}
2338
break;
2339
default:
2340
return -ENOTSUP;
2341
}
2342
return 0;
2343
}
2344
2345
static CharDriverState *qemu_chr_open_tty(const char *filename)
2346
{
2347
CharDriverState *chr;
2348
int fd;
2349
2350
TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2351
fcntl(fd, F_SETFL, O_NONBLOCK);
2352
tty_serial_init(fd, 115200, 'N', 8, 1);
2353
chr = qemu_chr_open_fd(fd, fd);
2354
if (!chr) {
2355
close(fd);
2356
return NULL;
2357
}
2358
chr->chr_ioctl = tty_serial_ioctl;
2359
qemu_chr_reset(chr);
2360
return chr;
2361
}
2362
#else /* ! __linux__ && ! __sun__ */
2363
static CharDriverState *qemu_chr_open_pty(void)
2364
{
2365
return NULL;
2366
}
2367
#endif /* __linux__ || __sun__ */
2368
2369
#if defined(__linux__)
2370
typedef struct {
2371
int fd;
2372
int mode;
2373
} ParallelCharDriver;
2374
2375
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2376
{
2377
if (s->mode != mode) {
2378
int m = mode;
2379
if (ioctl(s->fd, PPSETMODE, &m) < 0)
2380
return 0;
2381
s->mode = mode;
2382
}
2383
return 1;
2384
}
2385
2386
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2387
{
2388
ParallelCharDriver *drv = chr->opaque;
2389
int fd = drv->fd;
2390
uint8_t b;
2391
2392
switch(cmd) {
2393
case CHR_IOCTL_PP_READ_DATA:
2394
if (ioctl(fd, PPRDATA, &b) < 0)
2395
return -ENOTSUP;
2396
*(uint8_t *)arg = b;
2397
break;
2398
case CHR_IOCTL_PP_WRITE_DATA:
2399
b = *(uint8_t *)arg;
2400
if (ioctl(fd, PPWDATA, &b) < 0)
2401
return -ENOTSUP;
2402
break;
2403
case CHR_IOCTL_PP_READ_CONTROL:
2404
if (ioctl(fd, PPRCONTROL, &b) < 0)
2405
return -ENOTSUP;
2406
/* Linux gives only the lowest bits, and no way to know data
2407
direction! For better compatibility set the fixed upper
2408
bits. */
2409
*(uint8_t *)arg = b | 0xc0;
2410
break;
2411
case CHR_IOCTL_PP_WRITE_CONTROL:
2412
b = *(uint8_t *)arg;
2413
if (ioctl(fd, PPWCONTROL, &b) < 0)
2414
return -ENOTSUP;
2415
break;
2416
case CHR_IOCTL_PP_READ_STATUS:
2417
if (ioctl(fd, PPRSTATUS, &b) < 0)
2418
return -ENOTSUP;
2419
*(uint8_t *)arg = b;
2420
break;
2421
case CHR_IOCTL_PP_EPP_READ_ADDR:
2422
if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2423
struct ParallelIOArg *parg = arg;
2424
int n = read(fd, parg->buffer, parg->count);
2425
if (n != parg->count) {
2426
return -EIO;
2427
}
2428
}
2429
break;
2430
case CHR_IOCTL_PP_EPP_READ:
2431
if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2432
struct ParallelIOArg *parg = arg;
2433
int n = read(fd, parg->buffer, parg->count);
2434
if (n != parg->count) {
2435
return -EIO;
2436
}
2437
}
2438
break;
2439
case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2440
if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2441
struct ParallelIOArg *parg = arg;
2442
int n = write(fd, parg->buffer, parg->count);
2443
if (n != parg->count) {
2444
return -EIO;
2445
}
2446
}
2447
break;
2448
case CHR_IOCTL_PP_EPP_WRITE:
2449
if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2450
struct ParallelIOArg *parg = arg;
2451
int n = write(fd, parg->buffer, parg->count);
2452
if (n != parg->count) {
2453
return -EIO;
2454
}
2455
}
2456
break;
2457
default:
2458
return -ENOTSUP;
2459
}
2460
return 0;
2461
}
2462
2463
static void pp_close(CharDriverState *chr)
2464
{
2465
ParallelCharDriver *drv = chr->opaque;
2466
int fd = drv->fd;
2467
2468
pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2469
ioctl(fd, PPRELEASE);
2470
close(fd);
2471
qemu_free(drv);
2472
}
2473
2474
static CharDriverState *qemu_chr_open_pp(const char *filename)
2475
{
2476
CharDriverState *chr;
2477
ParallelCharDriver *drv;
2478
int fd;
2479
2480
TFR(fd = open(filename, O_RDWR));
2481
if (fd < 0)
2482
return NULL;
2483
2484
if (ioctl(fd, PPCLAIM) < 0) {
2485
close(fd);
2486
return NULL;
2487
}
2488
2489
drv = qemu_mallocz(sizeof(ParallelCharDriver));
2490
if (!drv) {
2491
close(fd);
2492
return NULL;
2493
}
2494
drv->fd = fd;
2495
drv->mode = IEEE1284_MODE_COMPAT;
2496
2497
chr = qemu_mallocz(sizeof(CharDriverState));
2498
if (!chr) {
2499
qemu_free(drv);
2500
close(fd);
2501
return NULL;
2502
}
2503
chr->chr_write = null_chr_write;
2504
chr->chr_ioctl = pp_ioctl;
2505
chr->chr_close = pp_close;
2506
chr->opaque = drv;
2507
2508
qemu_chr_reset(chr);
2509
2510
return chr;
2511
}
2512
#endif /* __linux__ */
2513
2514
#else /* _WIN32 */
2515
2516
typedef struct {
2517
int max_size;
2518
HANDLE hcom, hrecv, hsend;
2519
OVERLAPPED orecv, osend;
2520
BOOL fpipe;
2521
DWORD len;
2522
} WinCharState;
2523
2524
#define NSENDBUF 2048
2525
#define NRECVBUF 2048
2526
#define MAXCONNECT 1
2527
#define NTIMEOUT 5000
2528
2529
static int win_chr_poll(void *opaque);
2530
static int win_chr_pipe_poll(void *opaque);
2531
2532
static void win_chr_close(CharDriverState *chr)
2533
{
2534
WinCharState *s = chr->opaque;
2535
2536
if (s->hsend) {
2537
CloseHandle(s->hsend);
2538
s->hsend = NULL;
2539
}
2540
if (s->hrecv) {
2541
CloseHandle(s->hrecv);
2542
s->hrecv = NULL;
2543
}
2544
if (s->hcom) {
2545
CloseHandle(s->hcom);
2546
s->hcom = NULL;
2547
}
2548
if (s->fpipe)
2549
qemu_del_polling_cb(win_chr_pipe_poll, chr);
2550
else
2551
qemu_del_polling_cb(win_chr_poll, chr);
2552
}
2553
2554
static int win_chr_init(CharDriverState *chr, const char *filename)
2555
{
2556
WinCharState *s = chr->opaque;
2557
COMMCONFIG comcfg;
2558
COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2559
COMSTAT comstat;
2560
DWORD size;
2561
DWORD err;
2562
2563
s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2564
if (!s->hsend) {
2565
fprintf(stderr, "Failed CreateEvent\n");
2566
goto fail;
2567
}
2568
s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2569
if (!s->hrecv) {
2570
fprintf(stderr, "Failed CreateEvent\n");
2571
goto fail;
2572
}
2573
2574
s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2575
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2576
if (s->hcom == INVALID_HANDLE_VALUE) {
2577
fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2578
s->hcom = NULL;
2579
goto fail;
2580
}
2581
2582
if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2583
fprintf(stderr, "Failed SetupComm\n");
2584
goto fail;
2585
}
2586
2587
ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2588
size = sizeof(COMMCONFIG);
2589
GetDefaultCommConfig(filename, &comcfg, &size);
2590
comcfg.dcb.DCBlength = sizeof(DCB);
2591
CommConfigDialog(filename, NULL, &comcfg);
2592
2593
if (!SetCommState(s->hcom, &comcfg.dcb)) {
2594
fprintf(stderr, "Failed SetCommState\n");
2595
goto fail;
2596
}
2597
2598
if (!SetCommMask(s->hcom, EV_ERR)) {
2599
fprintf(stderr, "Failed SetCommMask\n");
2600
goto fail;
2601
}
2602
2603
cto.ReadIntervalTimeout = MAXDWORD;
2604
if (!SetCommTimeouts(s->hcom, &cto)) {
2605
fprintf(stderr, "Failed SetCommTimeouts\n");
2606
goto fail;
2607
}
2608
2609
if (!ClearCommError(s->hcom, &err, &comstat)) {
2610
fprintf(stderr, "Failed ClearCommError\n");
2611
goto fail;
2612
}
2613
qemu_add_polling_cb(win_chr_poll, chr);
2614
return 0;
2615
2616
fail:
2617
win_chr_close(chr);
2618
return -1;
2619
}
2620
2621
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2622
{
2623
WinCharState *s = chr->opaque;
2624
DWORD len, ret, size, err;
2625
2626
len = len1;
2627
ZeroMemory(&s->osend, sizeof(s->osend));
2628
s->osend.hEvent = s->hsend;
2629
while (len > 0) {
2630
if (s->hsend)
2631
ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2632
else
2633
ret = WriteFile(s->hcom, buf, len, &size, NULL);
2634
if (!ret) {
2635
err = GetLastError();
2636
if (err == ERROR_IO_PENDING) {
2637
ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2638
if (ret) {
2639
buf += size;
2640
len -= size;
2641
} else {
2642
break;
2643
}
2644
} else {
2645
break;
2646
}
2647
} else {
2648
buf += size;
2649
len -= size;
2650
}
2651
}
2652
return len1 - len;
2653
}
2654
2655
static int win_chr_read_poll(CharDriverState *chr)
2656
{
2657
WinCharState *s = chr->opaque;
2658
2659
s->max_size = qemu_chr_can_read(chr);
2660
return s->max_size;
2661
}
2662
2663
static void win_chr_readfile(CharDriverState *chr)
2664
{
2665
WinCharState *s = chr->opaque;
2666
int ret, err;
2667
uint8_t buf[1024];
2668
DWORD size;
2669
2670
ZeroMemory(&s->orecv, sizeof(s->orecv));
2671
s->orecv.hEvent = s->hrecv;
2672
ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2673
if (!ret) {
2674
err = GetLastError();
2675
if (err == ERROR_IO_PENDING) {
2676
ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2677
}
2678
}
2679
2680
if (size > 0) {
2681
qemu_chr_read(chr, buf, size);
2682
}
2683
}
2684
2685
static void win_chr_read(CharDriverState *chr)
2686
{
2687
WinCharState *s = chr->opaque;
2688
2689
if (s->len > s->max_size)
2690
s->len = s->max_size;
2691
if (s->len == 0)
2692
return;
2693
2694
win_chr_readfile(chr);
2695
}
2696
2697
static int win_chr_poll(void *opaque)
2698
{
2699
CharDriverState *chr = opaque;
2700
WinCharState *s = chr->opaque;
2701
COMSTAT status;
2702
DWORD comerr;
2703
2704
ClearCommError(s->hcom, &comerr, &status);
2705
if (status.cbInQue > 0) {
2706
s->len = status.cbInQue;
2707
win_chr_read_poll(chr);
2708
win_chr_read(chr);
2709
return 1;
2710
}
2711
return 0;
2712
}
2713
2714
static CharDriverState *qemu_chr_open_win(const char *filename)
2715
{
2716
CharDriverState *chr;
2717
WinCharState *s;
2718
2719
chr = qemu_mallocz(sizeof(CharDriverState));
2720
if (!chr)
2721
return NULL;
2722
s = qemu_mallocz(sizeof(WinCharState));
2723
if (!s) {
2724
free(chr);
2725
return NULL;
2726
}
2727
chr->opaque = s;
2728
chr->chr_write = win_chr_write;
2729
chr->chr_close = win_chr_close;
2730
2731
if (win_chr_init(chr, filename) < 0) {
2732
free(s);
2733
free(chr);
2734
return NULL;
2735
}
2736
qemu_chr_reset(chr);
2737
return chr;
2738
}
2739
2740
static int win_chr_pipe_poll(void *opaque)
2741
{
2742
CharDriverState *chr = opaque;
2743
WinCharState *s = chr->opaque;
2744
DWORD size;
2745
2746
PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2747
if (size > 0) {
2748
s->len = size;
2749
win_chr_read_poll(chr);
2750
win_chr_read(chr);
2751
return 1;
2752
}
2753
return 0;
2754
}
2755
2756
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2757
{
2758
WinCharState *s = chr->opaque;
2759
OVERLAPPED ov;
2760
int ret;
2761
DWORD size;
2762
char openname[256];
2763
2764
s->fpipe = TRUE;
2765
2766
s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2767
if (!s->hsend) {
2768
fprintf(stderr, "Failed CreateEvent\n");
2769
goto fail;
2770
}
2771
s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2772
if (!s->hrecv) {
2773
fprintf(stderr, "Failed CreateEvent\n");
2774
goto fail;
2775
}
2776
2777
snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2778
s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2779
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2780
PIPE_WAIT,
2781
MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2782
if (s->hcom == INVALID_HANDLE_VALUE) {
2783
fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2784
s->hcom = NULL;
2785
goto fail;
2786
}
2787
2788
ZeroMemory(&ov, sizeof(ov));
2789
ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2790
ret = ConnectNamedPipe(s->hcom, &ov);
2791
if (ret) {
2792
fprintf(stderr, "Failed ConnectNamedPipe\n");
2793
goto fail;
2794
}
2795
2796
ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2797
if (!ret) {
2798
fprintf(stderr, "Failed GetOverlappedResult\n");
2799
if (ov.hEvent) {
2800
CloseHandle(ov.hEvent);
2801
ov.hEvent = NULL;
2802
}
2803
goto fail;
2804
}
2805
2806
if (ov.hEvent) {
2807
CloseHandle(ov.hEvent);
2808
ov.hEvent = NULL;
2809
}
2810
qemu_add_polling_cb(win_chr_pipe_poll, chr);
2811
return 0;
2812
2813
fail:
2814
win_chr_close(chr);
2815
return -1;
2816
}
2817
2818
2819
static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2820
{
2821
CharDriverState *chr;
2822
WinCharState *s;
2823
2824
chr = qemu_mallocz(sizeof(CharDriverState));
2825
if (!chr)
2826
return NULL;
2827
s = qemu_mallocz(sizeof(WinCharState));
2828
if (!s) {
2829
free(chr);
2830
return NULL;
2831
}
2832
chr->opaque = s;
2833
chr->chr_write = win_chr_write;
2834
chr->chr_close = win_chr_close;
2835
2836
if (win_chr_pipe_init(chr, filename) < 0) {
2837
free(s);
2838
free(chr);
2839
return NULL;
2840
}
2841
qemu_chr_reset(chr);
2842
return chr;
2843
}
2844
2845
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2846
{
2847
CharDriverState *chr;
2848
WinCharState *s;
2849
2850
chr = qemu_mallocz(sizeof(CharDriverState));
2851
if (!chr)
2852
return NULL;
2853
s = qemu_mallocz(sizeof(WinCharState));
2854
if (!s) {
2855
free(chr);
2856
return NULL;
2857
}
2858
s->hcom = fd_out;
2859
chr->opaque = s;
2860
chr->chr_write = win_chr_write;
2861
qemu_chr_reset(chr);
2862
return chr;
2863
}
2864
2865
static CharDriverState *qemu_chr_open_win_con(const char *filename)
2866
{
2867
return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
2868
}
2869
2870
static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2871
{
2872
HANDLE fd_out;
2873
2874
fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2875
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2876
if (fd_out == INVALID_HANDLE_VALUE)
2877
return NULL;
2878
2879
return qemu_chr_open_win_file(fd_out);
2880
}
2881
#endif /* !_WIN32 */
2882
2883
/***********************************************************/
2884
/* UDP Net console */
2885
2886
typedef struct {
2887
int fd;
2888
struct sockaddr_in daddr;
2889
uint8_t buf[1024];
2890
int bufcnt;
2891
int bufptr;
2892
int max_size;
2893
} NetCharDriver;
2894
2895
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2896
{
2897
NetCharDriver *s = chr->opaque;
2898
2899
return sendto(s->fd, buf, len, 0,
2900
(struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2901
}
2902
2903
static int udp_chr_read_poll(void *opaque)
2904
{
2905
CharDriverState *chr = opaque;
2906
NetCharDriver *s = chr->opaque;
2907
2908
s->max_size = qemu_chr_can_read(chr);
2909
2910
/* If there were any stray characters in the queue process them
2911
* first
2912
*/
2913
while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2914
qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2915
s->bufptr++;
2916
s->max_size = qemu_chr_can_read(chr);
2917
}
2918
return s->max_size;
2919
}
2920
2921
static void udp_chr_read(void *opaque)
2922
{
2923
CharDriverState *chr = opaque;
2924
NetCharDriver *s = chr->opaque;
2925
2926
if (s->max_size == 0)
2927
return;
2928
s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2929
s->bufptr = s->bufcnt;
2930
if (s->bufcnt <= 0)
2931
return;
2932
2933
s->bufptr = 0;
2934
while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2935
qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2936
s->bufptr++;
2937
s->max_size = qemu_chr_can_read(chr);
2938
}
2939
}
2940
2941
static void udp_chr_update_read_handler(CharDriverState *chr)
2942
{
2943
NetCharDriver *s = chr->opaque;
2944
2945
if (s->fd >= 0) {
2946
qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2947
udp_chr_read, NULL, chr);
2948
}
2949
}
2950
2951
int parse_host_port(struct sockaddr_in *saddr, const char *str);
2952
#ifndef _WIN32
2953
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
2954
#endif
2955
int parse_host_src_port(struct sockaddr_in *haddr,
2956
struct sockaddr_in *saddr,
2957
const char *str);
2958
2959
static CharDriverState *qemu_chr_open_udp(const char *def)
2960
{
2961
CharDriverState *chr = NULL;
2962
NetCharDriver *s = NULL;
2963
int fd = -1;
2964
struct sockaddr_in saddr;
2965
2966
chr = qemu_mallocz(sizeof(CharDriverState));
2967
if (!chr)
2968
goto return_err;
2969
s = qemu_mallocz(sizeof(NetCharDriver));
2970
if (!s)
2971
goto return_err;
2972
2973
fd = socket(PF_INET, SOCK_DGRAM, 0);
2974
if (fd < 0) {
2975
perror("socket(PF_INET, SOCK_DGRAM)");
2976
goto return_err;
2977
}
2978
2979
if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
2980
printf("Could not parse: %s\n", def);
2981
goto return_err;
2982
}
2983
2984
if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
2985
{
2986
perror("bind");
2987
goto return_err;
2988
}
2989
2990
s->fd = fd;
2991
s->bufcnt = 0;
2992
s->bufptr = 0;
2993
chr->opaque = s;
2994
chr->chr_write = udp_chr_write;
2995
chr->chr_update_read_handler = udp_chr_update_read_handler;
2996
return chr;
2997
2998
return_err:
2999
if (chr)
3000
free(chr);
3001
if (s)
3002
free(s);
3003
if (fd >= 0)
3004
closesocket(fd);
3005
return NULL;
3006
}
3007
3008
/***********************************************************/
3009
/* TCP Net console */
3010
3011
typedef struct {
3012
int fd, listen_fd;
3013
int connected;
3014
int max_size;
3015
int do_telnetopt;
3016
int do_nodelay;
3017
int is_unix;
3018
} TCPCharDriver;
3019
3020
static void tcp_chr_accept(void *opaque);
3021
3022
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3023
{
3024
TCPCharDriver *s = chr->opaque;
3025
if (s->connected) {
3026
return send_all(s->fd, buf, len);
3027
} else {
3028
/* XXX: indicate an error ? */
3029
return len;
3030
}
3031
}
3032
3033
static int tcp_chr_read_poll(void *opaque)
3034
{
3035
CharDriverState *chr = opaque;
3036
TCPCharDriver *s = chr->opaque;
3037
if (!s->connected)
3038
return 0;
3039
s->max_size = qemu_chr_can_read(chr);
3040
return s->max_size;
3041
}
3042
3043
#define IAC 255
3044
#define IAC_BREAK 243
3045
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3046
TCPCharDriver *s,
3047
uint8_t *buf, int *size)
3048
{
3049
/* Handle any telnet client's basic IAC options to satisfy char by
3050
* char mode with no echo. All IAC options will be removed from
3051
* the buf and the do_telnetopt variable will be used to track the
3052
* state of the width of the IAC information.
3053
*
3054
* IAC commands come in sets of 3 bytes with the exception of the
3055
* "IAC BREAK" command and the double IAC.
3056
*/
3057
3058
int i;
3059
int j = 0;
3060
3061
for (i = 0; i < *size; i++) {
3062
if (s->do_telnetopt > 1) {
3063
if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3064
/* Double IAC means send an IAC */
3065
if (j != i)
3066
buf[j] = buf[i];
3067
j++;
3068
s->do_telnetopt = 1;
3069
} else {
3070
if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3071
/* Handle IAC break commands by sending a serial break */
3072
qemu_chr_event(chr, CHR_EVENT_BREAK);
3073
s->do_telnetopt++;
3074
}
3075
s->do_telnetopt++;
3076
}
3077
if (s->do_telnetopt >= 4) {
3078
s->do_telnetopt = 1;
3079
}
3080
} else {
3081
if ((unsigned char)buf[i] == IAC) {
3082
s->do_telnetopt = 2;
3083
} else {
3084
if (j != i)
3085
buf[j] = buf[i];
3086
j++;
3087
}
3088
}
3089
}
3090
*size = j;
3091
}
3092
3093
static void tcp_chr_read(void *opaque)
3094
{
3095
CharDriverState *chr = opaque;
3096
TCPCharDriver *s = chr->opaque;
3097
uint8_t buf[1024];
3098
int len, size;
3099
3100
if (!s->connected || s->max_size <= 0)
3101
return;
3102
len = sizeof(buf);
3103
if (len > s->max_size)
3104
len = s->max_size;
3105
size = recv(s->fd, buf, len, 0);
3106
if (size == 0) {
3107
/* connection closed */
3108
s->connected = 0;
3109
if (s->listen_fd >= 0) {
3110
qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3111
}
3112
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3113
closesocket(s->fd);
3114
s->fd = -1;
3115
} else if (size > 0) {
3116
if (s->do_telnetopt)
3117
tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3118
if (size > 0)
3119
qemu_chr_read(chr, buf, size);
3120
}
3121
}
3122
3123
static void tcp_chr_connect(void *opaque)
3124
{
3125
CharDriverState *chr = opaque;
3126
TCPCharDriver *s = chr->opaque;
3127
3128
s->connected = 1;
3129
qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3130
tcp_chr_read, NULL, chr);
3131
qemu_chr_reset(chr);
3132
}
3133
3134
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3135
static void tcp_chr_telnet_init(int fd)
3136
{
3137
char buf[3];
3138
/* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3139
IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3140
send(fd, (char *)buf, 3, 0);
3141
IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3142
send(fd, (char *)buf, 3, 0);
3143
IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3144
send(fd, (char *)buf, 3, 0);
3145
IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3146
send(fd, (char *)buf, 3, 0);
3147
}
3148
3149
static void socket_set_nodelay(int fd)
3150
{
3151
int val = 1;
3152
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3153
}
3154
3155
static void tcp_chr_accept(void *opaque)
3156
{
3157
CharDriverState *chr = opaque;
3158
TCPCharDriver *s = chr->opaque;
3159
struct sockaddr_in saddr;
3160
#ifndef _WIN32
3161
struct sockaddr_un uaddr;
3162
#endif
3163
struct sockaddr *addr;
3164
socklen_t len;
3165
int fd;
3166
3167
for(;;) {
3168
#ifndef _WIN32
3169
if (s->is_unix) {
3170
len = sizeof(uaddr);
3171
addr = (struct sockaddr *)&uaddr;
3172
} else
3173
#endif
3174
{
3175
len = sizeof(saddr);
3176
addr = (struct sockaddr *)&saddr;
3177
}
3178
fd = accept(s->listen_fd, addr, &len);
3179
if (fd < 0 && errno != EINTR) {
3180
return;
3181
} else if (fd >= 0) {
3182
if (s->do_telnetopt)
3183
tcp_chr_telnet_init(fd);
3184
break;
3185
}
3186
}
3187
socket_set_nonblock(fd);
3188
if (s->do_nodelay)
3189
socket_set_nodelay(fd);
3190
s->fd = fd;
3191
qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3192
tcp_chr_connect(chr);
3193
}
3194
3195
static void tcp_chr_close(CharDriverState *chr)
3196
{
3197
TCPCharDriver *s = chr->opaque;
3198
if (s->fd >= 0)
3199
closesocket(s->fd);
3200
if (s->listen_fd >= 0)
3201
closesocket(s->listen_fd);
3202
qemu_free(s);
3203
}
3204
3205
static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3206
int is_telnet,
3207
int is_unix)
3208
{
3209
CharDriverState *chr = NULL;
3210
TCPCharDriver *s = NULL;
3211
int fd = -1, ret, err, val;
3212
int is_listen = 0;
3213
int is_waitconnect = 1;
3214
int do_nodelay = 0;
3215
const char *ptr;
3216
struct sockaddr_in saddr;
3217
#ifndef _WIN32
3218
struct sockaddr_un uaddr;
3219
#endif
3220
struct sockaddr *addr;
3221
socklen_t addrlen;
3222
3223
#ifndef _WIN32
3224
if (is_unix) {
3225
addr = (struct sockaddr *)&uaddr;
3226
addrlen = sizeof(uaddr);
3227
if (parse_unix_path(&uaddr, host_str) < 0)
3228
goto fail;
3229
} else
3230
#endif
3231
{
3232
addr = (struct sockaddr *)&saddr;
3233
addrlen = sizeof(saddr);
3234
if (parse_host_port(&saddr, host_str) < 0)
3235
goto fail;
3236
}
3237
3238
ptr = host_str;
3239
while((ptr = strchr(ptr,','))) {
3240
ptr++;
3241
if (!strncmp(ptr,"server",6)) {
3242
is_listen = 1;
3243
} else if (!strncmp(ptr,"nowait",6)) {
3244
is_waitconnect = 0;
3245
} else if (!strncmp(ptr,"nodelay",6)) {
3246
do_nodelay = 1;
3247
} else {
3248
printf("Unknown option: %s\n", ptr);
3249
goto fail;
3250
}
3251
}
3252
if (!is_listen)
3253
is_waitconnect = 0;
3254
3255
chr = qemu_mallocz(sizeof(CharDriverState));
3256
if (!chr)
3257
goto fail;
3258
s = qemu_mallocz(sizeof(TCPCharDriver));
3259
if (!s)
3260
goto fail;
3261
3262
#ifndef _WIN32
3263
if (is_unix)
3264
fd = socket(PF_UNIX, SOCK_STREAM, 0);
3265
else
3266
#endif
3267
fd = socket(PF_INET, SOCK_STREAM, 0);
3268
3269
if (fd < 0)
3270
goto fail;
3271
3272
if (!is_waitconnect)
3273
socket_set_nonblock(fd);
3274
3275
s->connected = 0;
3276
s->fd = -1;
3277
s->listen_fd = -1;
3278
s->is_unix = is_unix;
3279
s->do_nodelay = do_nodelay && !is_unix;
3280
3281
chr->opaque = s;
3282
chr->chr_write = tcp_chr_write;
3283
chr->chr_close = tcp_chr_close;
3284
3285
if (is_listen) {
3286
/* allow fast reuse */
3287
#ifndef _WIN32
3288
if (is_unix) {
3289
char path[109];
3290
strncpy(path, uaddr.sun_path, 108);
3291
path[108] = 0;
3292
unlink(path);
3293
} else
3294
#endif
3295
{
3296
val = 1;
3297
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3298
}
3299
3300
ret = bind(fd, addr, addrlen);
3301
if (ret < 0)
3302
goto fail;
3303
3304
ret = listen(fd, 0);
3305
if (ret < 0)
3306
goto fail;
3307
3308
s->listen_fd = fd;
3309
qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3310
if (is_telnet)
3311
s->do_telnetopt = 1;
3312
} else {
3313
for(;;) {
3314
ret = connect(fd, addr, addrlen);
3315
if (ret < 0) {
3316
err = socket_error();
3317
if (err == EINTR || err == EWOULDBLOCK) {
3318
} else if (err == EINPROGRESS) {
3319
break;
3320
#ifdef _WIN32
3321
} else if (err == WSAEALREADY) {
3322
break;
3323
#endif
3324
} else {
3325
goto fail;
3326
}
3327
} else {
3328
s->connected = 1;
3329
break;
3330
}
3331
}
3332
s->fd = fd;
3333
socket_set_nodelay(fd);
3334
if (s->connected)
3335
tcp_chr_connect(chr);
3336
else
3337
qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3338
}
3339
3340
if (is_listen && is_waitconnect) {
3341
printf("QEMU waiting for connection on: %s\n", host_str);
3342
tcp_chr_accept(chr);
3343
socket_set_nonblock(s->listen_fd);
3344
}
3345
3346
return chr;
3347
fail:
3348
if (fd >= 0)
3349
closesocket(fd);
3350
qemu_free(s);
3351
qemu_free(chr);
3352
return NULL;
3353
}
3354
3355
CharDriverState *qemu_chr_open(const char *filename)
3356
{
3357
const char *p;
3358
3359
if (!strcmp(filename, "vc")) {
3360
return text_console_init(&display_state, 0);
3361
} else if (strstart(filename, "vc:", &p)) {
3362
return text_console_init(&display_state, p);
3363
} else if (!strcmp(filename, "null")) {
3364
return qemu_chr_open_null();
3365
} else
3366
if (strstart(filename, "tcp:", &p)) {
3367
return qemu_chr_open_tcp(p, 0, 0);
3368
} else
3369
if (strstart(filename, "telnet:", &p)) {
3370
return qemu_chr_open_tcp(p, 1, 0);
3371
} else
3372
if (strstart(filename, "udp:", &p)) {
3373
return qemu_chr_open_udp(p);
3374
} else
3375
if (strstart(filename, "mon:", &p)) {
3376
CharDriverState *drv = qemu_chr_open(p);
3377
if (drv) {
3378
drv = qemu_chr_open_mux(drv);
3379
monitor_init(drv, !nographic);
3380
return drv;
3381
}
3382
printf("Unable to open driver: %s\n", p);
3383
return 0;
3384
} else
3385
#ifndef _WIN32
3386
if (strstart(filename, "unix:", &p)) {
3387
return qemu_chr_open_tcp(p, 0, 1);
3388
} else if (strstart(filename, "file:", &p)) {
3389
return qemu_chr_open_file_out(p);
3390
} else if (strstart(filename, "pipe:", &p)) {
3391
return qemu_chr_open_pipe(p);
3392
} else if (!strcmp(filename, "pty")) {
3393
return qemu_chr_open_pty();
3394
} else if (!strcmp(filename, "stdio")) {
3395
return qemu_chr_open_stdio();
3396
} else
3397
#if defined(__linux__)
3398
if (strstart(filename, "/dev/parport", NULL)) {
3399
return qemu_chr_open_pp(filename);
3400
} else
3401
#endif
3402
#if defined(__linux__) || defined(__sun__)
3403
if (strstart(filename, "/dev/", NULL)) {
3404
return qemu_chr_open_tty(filename);
3405
} else
3406
#endif
3407
#else /* !_WIN32 */
3408
if (strstart(filename, "COM", NULL)) {
3409
return qemu_chr_open_win(filename);
3410
} else
3411
if (strstart(filename, "pipe:", &p)) {
3412
return qemu_chr_open_win_pipe(p);
3413
} else
3414
if (strstart(filename, "con:", NULL)) {
3415
return qemu_chr_open_win_con(filename);
3416
} else
3417
if (strstart(filename, "file:", &p)) {
3418
return qemu_chr_open_win_file_out(p);
3419
}
3420
#endif
3421
{
3422
return NULL;
3423
}
3424
}
3425
3426
void qemu_chr_close(CharDriverState *chr)
3427
{
3428
if (chr->chr_close)
3429
chr->chr_close(chr);
3430
}
3431
3432
/***********************************************************/
3433
/* network device redirectors */
3434
3435
__attribute__ (( unused ))
3436
static void hex_dump(FILE *f, const uint8_t *buf, int size)
3437
{
3438
int len, i, j, c;
3439
3440
for(i=0;i<size;i+=16) {
3441
len = size - i;
3442
if (len > 16)
3443
len = 16;
3444
fprintf(f, "%08x ", i);
3445
for(j=0;j<16;j++) {
3446
if (j < len)
3447
fprintf(f, " %02x", buf[i+j]);
3448
else
3449
fprintf(f, " ");
3450
}
3451
fprintf(f, " ");
3452
for(j=0;j<len;j++) {
3453
c = buf[i+j];
3454
if (c < ' ' || c > '~')
3455
c = '.';
3456
fprintf(f, "%c", c);
3457
}
3458
fprintf(f, "\n");
3459
}
3460
}
3461
3462
static int parse_macaddr(uint8_t *macaddr, const char *p)
3463
{
3464
int i;
3465
char *last_char;
3466
long int offset;
3467
3468
errno = 0;
3469
offset = strtol(p, &last_char, 0);
3470
if (0 == errno && '\0' == *last_char &&
3471
offset >= 0 && offset <= 0xFFFFFF) {
3472
macaddr[3] = (offset & 0xFF0000) >> 16;
3473
macaddr[4] = (offset & 0xFF00) >> 8;
3474
macaddr[5] = offset & 0xFF;
3475
return 0;
3476
} else {
3477
for(i = 0; i < 6; i++) {
3478
macaddr[i] = strtol(p, (char **)&p, 16);
3479
if (i == 5) {
3480
if (*p != '\0')
3481
return -1;
3482
} else {
3483
if (*p != ':' && *p != '-')
3484
return -1;
3485
p++;
3486
}
3487
}
3488
return 0;
3489
}
3490
3491
return -1;
3492
}
3493
3494
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3495
{
3496
const char *p, *p1;
3497
int len;
3498
p = *pp;
3499
p1 = strchr(p, sep);
3500
if (!p1)
3501
return -1;
3502
len = p1 - p;
3503
p1++;
3504
if (buf_size > 0) {
3505
if (len > buf_size - 1)
3506
len = buf_size - 1;
3507
memcpy(buf, p, len);
3508
buf[len] = '\0';
3509
}
3510
*pp = p1;
3511
return 0;
3512
}
3513
3514
int parse_host_src_port(struct sockaddr_in *haddr,
3515
struct sockaddr_in *saddr,
3516
const char *input_str)
3517
{
3518
char *str = strdup(input_str);
3519
char *host_str = str;
3520
char *src_str;
3521
char *ptr;
3522
3523
/*
3524
* Chop off any extra arguments at the end of the string which
3525
* would start with a comma, then fill in the src port information
3526
* if it was provided else use the "any address" and "any port".
3527
*/
3528
if ((ptr = strchr(str,',')))
3529
*ptr = '\0';
3530
3531
if ((src_str = strchr(input_str,'@'))) {
3532
*src_str = '\0';
3533
src_str++;
3534
}
3535
3536
if (parse_host_port(haddr, host_str) < 0)
3537
goto fail;
3538
3539
if (!src_str || *src_str == '\0')
3540
src_str = ":0";
3541
3542
if (parse_host_port(saddr, src_str) < 0)
3543
goto fail;
3544
3545
free(str);
3546
return(0);
3547
3548
fail:
3549
free(str);
3550
return -1;
3551
}
3552
3553
int parse_host_port(struct sockaddr_in *saddr, const char *str)
3554
{
3555
char buf[512];
3556
struct hostent *he;
3557
const char *p, *r;
3558
int port;
3559
3560
p = str;
3561
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3562
return -1;
3563
saddr->sin_family = AF_INET;
3564
if (buf[0] == '\0') {
3565
saddr->sin_addr.s_addr = 0;
3566
} else {
3567
if (isdigit(buf[0])) {
3568
if (!inet_aton(buf, &saddr->sin_addr))
3569
return -1;
3570
} else {
3571
if ((he = gethostbyname(buf)) == NULL)
3572
return - 1;
3573
saddr->sin_addr = *(struct in_addr *)he->h_addr;
3574
}
3575
}
3576
port = strtol(p, (char **)&r, 0);
3577
if (r == p)
3578
return -1;
3579
saddr->sin_port = htons(port);
3580
return 0;
3581
}
3582
3583
#ifndef _WIN32
3584
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3585
{
3586
const char *p;
3587
int len;
3588
3589
len = MIN(108, strlen(str));
3590
p = strchr(str, ',');
3591
if (p)
3592
len = MIN(len, p - str);
3593
3594
memset(uaddr, 0, sizeof(*uaddr));
3595
3596
uaddr->sun_family = AF_UNIX;
3597
memcpy(uaddr->sun_path, str, len);
3598
3599
return 0;
3600
}
3601
#endif
3602
3603
/* find or alloc a new VLAN */
3604
VLANState *qemu_find_vlan(int id)
3605
{
3606
VLANState **pvlan, *vlan;
3607
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3608
if (vlan->id == id)
3609
return vlan;
3610
}
3611
vlan = qemu_mallocz(sizeof(VLANState));
3612
if (!vlan)
3613
return NULL;
3614
vlan->id = id;
3615
vlan->next = NULL;
3616
pvlan = &first_vlan;
3617
while (*pvlan != NULL)
3618
pvlan = &(*pvlan)->next;
3619
*pvlan = vlan;
3620
return vlan;
3621
}
3622
3623
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3624
IOReadHandler *fd_read,
3625
IOCanRWHandler *fd_can_read,
3626
void *opaque)
3627
{
3628
VLANClientState *vc, **pvc;
3629
vc = qemu_mallocz(sizeof(VLANClientState));
3630
if (!vc)
3631
return NULL;
3632
vc->fd_read = fd_read;
3633
vc->fd_can_read = fd_can_read;
3634
vc->opaque = opaque;
3635
vc->vlan = vlan;
3636
3637
vc->next = NULL;
3638
pvc = &vlan->first_client;
3639
while (*pvc != NULL)
3640
pvc = &(*pvc)->next;
3641
*pvc = vc;
3642
return vc;
3643
}
3644
3645
int qemu_can_send_packet(VLANClientState *vc1)
3646
{
3647
VLANState *vlan = vc1->vlan;
3648
VLANClientState *vc;
3649
3650
for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3651
if (vc != vc1) {
3652
if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3653
return 1;
3654
}
3655
}
3656
return 0;
3657
}
3658
3659
void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3660
{
3661
VLANState *vlan = vc1->vlan;
3662
VLANClientState *vc;
3663
3664
#if 0
3665
printf("vlan %d send:\n", vlan->id);
3666
hex_dump(stdout, buf, size);
3667
#endif
3668
for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3669
if (vc != vc1) {
3670
vc->fd_read(vc->opaque, buf, size);
3671
}
3672
}
3673
}
3674
3675
#if defined(CONFIG_SLIRP)
3676
3677
/* slirp network adapter */
3678
3679
static int slirp_inited;
3680
static VLANClientState *slirp_vc;
3681
3682
int slirp_can_output(void)
3683
{
3684
return !slirp_vc || qemu_can_send_packet(slirp_vc);
3685
}
3686
3687
void slirp_output(const uint8_t *pkt, int pkt_len)
3688
{
3689
#if 0
3690
printf("slirp output:\n");
3691
hex_dump(stdout, pkt, pkt_len);
3692
#endif
3693
if (!slirp_vc)
3694
return;
3695
qemu_send_packet(slirp_vc, pkt, pkt_len);
3696
}
3697
3698
static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3699
{
3700
#if 0
3701
printf("slirp input:\n");
3702
hex_dump(stdout, buf, size);
3703
#endif
3704
slirp_input(buf, size);
3705
}
3706
3707
static int net_slirp_init(VLANState *vlan)
3708
{
3709
if (!slirp_inited) {
3710
slirp_inited = 1;
3711
slirp_init();
3712
}
3713
slirp_vc = qemu_new_vlan_client(vlan,
3714
slirp_receive, NULL, NULL);
3715
snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3716
return 0;
3717
}
3718
3719
static void net_slirp_redir(const char *redir_str)
3720
{
3721
int is_udp;
3722
char buf[256], *r;
3723
const char *p;
3724
struct in_addr guest_addr;
3725
int host_port, guest_port;
3726
3727
if (!slirp_inited) {
3728
slirp_inited = 1;
3729
slirp_init();
3730
}
3731
3732
p = redir_str;
3733
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3734
goto fail;
3735
if (!strcmp(buf, "tcp")) {
3736
is_udp = 0;
3737
} else if (!strcmp(buf, "udp")) {
3738
is_udp = 1;
3739
} else {
3740
goto fail;
3741
}
3742
3743
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3744
goto fail;
3745
host_port = strtol(buf, &r, 0);
3746
if (r == buf)
3747
goto fail;
3748
3749
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3750
goto fail;
3751
if (buf[0] == '\0') {
3752
pstrcpy(buf, sizeof(buf), "10.0.2.15");
3753
}
3754
if (!inet_aton(buf, &guest_addr))
3755
goto fail;
3756
3757
guest_port = strtol(p, &r, 0);
3758
if (r == p)
3759
goto fail;
3760
3761
if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3762
fprintf(stderr, "qemu: could not set up redirection\n");
3763
exit(1);
3764
}
3765
return;
3766
fail:
3767
fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3768
exit(1);
3769
}
3770
3771
#ifndef _WIN32
3772
3773
char smb_dir[1024];
3774
3775
static void smb_exit(void)
3776
{
3777
DIR *d;
3778
struct dirent *de;
3779
char filename[1024];
3780
3781
/* erase all the files in the directory */
3782
d = opendir(smb_dir);
3783
for(;;) {
3784
de = readdir(d);
3785
if (!de)
3786
break;
3787
if (strcmp(de->d_name, ".") != 0 &&
3788
strcmp(de->d_name, "..") != 0) {
3789
snprintf(filename, sizeof(filename), "%s/%s",
3790
smb_dir, de->d_name);
3791
unlink(filename);
3792
}
3793
}
3794
closedir(d);
3795
rmdir(smb_dir);
3796
}
3797
3798
/* automatic user mode samba server configuration */
3799
static void net_slirp_smb(const char *exported_dir)
3800
{
3801
char smb_conf[1024];
3802
char smb_cmdline[1024];
3803
FILE *f;
3804
3805
if (!slirp_inited) {
3806
slirp_inited = 1;
3807
slirp_init();
3808
}
3809
3810
/* XXX: better tmp dir construction */
3811
snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3812
if (mkdir(smb_dir, 0700) < 0) {
3813
fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3814
exit(1);
3815
}
3816
snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3817
3818
f = fopen(smb_conf, "w");
3819
if (!f) {
3820
fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3821
exit(1);
3822
}
3823
fprintf(f,
3824
"[global]\n"
3825
"private dir=%s\n"
3826
"smb ports=0\n"
3827
"socket address=127.0.0.1\n"
3828
"pid directory=%s\n"
3829
"lock directory=%s\n"
3830
"log file=%s/log.smbd\n"
3831
"smb passwd file=%s/smbpasswd\n"
3832
"security = share\n"
3833
"[qemu]\n"
3834
"path=%s\n"
3835
"read only=no\n"
3836
"guest ok=yes\n",
3837
smb_dir,
3838
smb_dir,
3839
smb_dir,
3840
smb_dir,
3841
smb_dir,
3842
exported_dir
3843
);
3844
fclose(f);
3845
atexit(smb_exit);
3846
3847
snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3848
SMBD_COMMAND, smb_conf);
3849
3850
slirp_add_exec(0, smb_cmdline, 4, 139);
3851
}
3852
3853
#endif /* !defined(_WIN32) */
3854
void do_info_slirp(void)
3855
{
3856
slirp_stats();
3857
}
3858
3859
#endif /* CONFIG_SLIRP */
3860
3861
#if !defined(_WIN32)
3862
3863
typedef struct TAPState {
3864
VLANClientState *vc;
3865
int fd;
3866
char down_script[1024];
3867
} TAPState;
3868
3869
static void tap_receive(void *opaque, const uint8_t *buf, int size)
3870
{
3871
TAPState *s = opaque;
3872
int ret;
3873
for(;;) {
3874
ret = write(s->fd, buf, size);
3875
if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3876
} else {
3877
break;
3878
}
3879
}
3880
}
3881
3882
static void tap_send(void *opaque)
3883
{
3884
TAPState *s = opaque;
3885
uint8_t buf[4096];
3886
int size;
3887
3888
#ifdef __sun__
3889
struct strbuf sbuf;
3890
int f = 0;
3891
sbuf.maxlen = sizeof(buf);
3892
sbuf.buf = buf;
3893
size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
3894
#else
3895
size = read(s->fd, buf, sizeof(buf));
3896
#endif
3897
if (size > 0) {
3898
qemu_send_packet(s->vc, buf, size);
3899
}
3900
}
3901
3902
/* fd support */
3903
3904
static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3905
{
3906
TAPState *s;
3907
3908
s = qemu_mallocz(sizeof(TAPState));
3909
if (!s)
3910
return NULL;
3911
s->fd = fd;
3912
s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3913
qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3914
snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3915
return s;
3916
}
3917
3918
#if defined (_BSD) || defined (__FreeBSD_kernel__)
3919
static int tap_open(char *ifname, int ifname_size)
3920
{
3921
int fd;
3922
char *dev;
3923
struct stat s;
3924
3925
TFR(fd = open("/dev/tap", O_RDWR));
3926
if (fd < 0) {
3927
fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
3928
return -1;
3929
}
3930
3931
fstat(fd, &s);
3932
dev = devname(s.st_rdev, S_IFCHR);
3933
pstrcpy(ifname, ifname_size, dev);
3934
3935
fcntl(fd, F_SETFL, O_NONBLOCK);
3936
return fd;
3937
}
3938
#elif defined(__sun__)
3939
#define TUNNEWPPA (('T'<<16) | 0x0001)
3940
/*
3941
* Allocate TAP device, returns opened fd.
3942
* Stores dev name in the first arg(must be large enough).
3943
*/
3944
int tap_alloc(char *dev)
3945
{
3946
int tap_fd, if_fd, ppa = -1;
3947
static int ip_fd = 0;
3948
char *ptr;
3949
3950
static int arp_fd = 0;
3951
int ip_muxid, arp_muxid;
3952
struct strioctl strioc_if, strioc_ppa;
3953
int link_type = I_PLINK;;
3954
struct lifreq ifr;
3955
char actual_name[32] = "";
3956
3957
memset(&ifr, 0x0, sizeof(ifr));
3958
3959
if( *dev ){
3960
ptr = dev;
3961
while( *ptr && !isdigit((int)*ptr) ) ptr++;
3962
ppa = atoi(ptr);
3963
}
3964
3965
/* Check if IP device was opened */
3966
if( ip_fd )
3967
close(ip_fd);
3968
3969
TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
3970
if (ip_fd < 0) {
3971
syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
3972
return -1;
3973
}
3974
3975
TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
3976
if (tap_fd < 0) {
3977
syslog(LOG_ERR, "Can't open /dev/tap");
3978
return -1;
3979
}
3980
3981
/* Assign a new PPA and get its unit number. */
3982
strioc_ppa.ic_cmd = TUNNEWPPA;
3983
strioc_ppa.ic_timout = 0;
3984
strioc_ppa.ic_len = sizeof(ppa);
3985
strioc_ppa.ic_dp = (char *)&ppa;
3986
if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
3987
syslog (LOG_ERR, "Can't assign new interface");
3988
3989
TFR(if_fd = open("/dev/tap", O_RDWR, 0));
3990
if (if_fd < 0) {
3991
syslog(LOG_ERR, "Can't open /dev/tap (2)");
3992
return -1;
3993
}
3994
if(ioctl(if_fd, I_PUSH, "ip") < 0){
3995
syslog(LOG_ERR, "Can't push IP module");
3996
return -1;
3997
}
3998
3999
if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4000
syslog(LOG_ERR, "Can't get flags\n");
4001
4002
snprintf (actual_name, 32, "tap%d", ppa);
4003
strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4004
4005
ifr.lifr_ppa = ppa;
4006
/* Assign ppa according to the unit number returned by tun device */
4007
4008
if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4009
syslog (LOG_ERR, "Can't set PPA %d", ppa);
4010
if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4011
syslog (LOG_ERR, "Can't get flags\n");
4012
/* Push arp module to if_fd */
4013
if (ioctl (if_fd, I_PUSH, "arp") < 0)
4014
syslog (LOG_ERR, "Can't push ARP module (2)");
4015
4016
/* Push arp module to ip_fd */
4017
if (ioctl (ip_fd, I_POP, NULL) < 0)
4018
syslog (LOG_ERR, "I_POP failed\n");
4019
if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4020
syslog (LOG_ERR, "Can't push ARP module (3)\n");
4021
/* Open arp_fd */
4022
TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4023
if (arp_fd < 0)
4024
syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4025
4026
/* Set ifname to arp */
4027
strioc_if.ic_cmd = SIOCSLIFNAME;
4028
strioc_if.ic_timout = 0;
4029
strioc_if.ic_len = sizeof(ifr);
4030
strioc_if.ic_dp = (char *)𝔦
4031
if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4032
syslog (LOG_ERR, "Can't set ifname to arp\n");
4033
}
4034
4035
if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4036
syslog(LOG_ERR, "Can't link TAP device to IP");
4037
return -1;
4038
}
4039
4040
if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4041
syslog (LOG_ERR, "Can't link TAP device to ARP");
4042
4043
close (if_fd);
4044
4045
memset(&ifr, 0x0, sizeof(ifr));
4046
strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4047
ifr.lifr_ip_muxid = ip_muxid;
4048
ifr.lifr_arp_muxid = arp_muxid;
4049
4050
if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4051
{
4052
ioctl (ip_fd, I_PUNLINK , arp_muxid);
4053
ioctl (ip_fd, I_PUNLINK, ip_muxid);
4054
syslog (LOG_ERR, "Can't set multiplexor id");
4055
}
4056
4057
sprintf(dev, "tap%d", ppa);
4058
return tap_fd;
4059
}
4060
4061
static int tap_open(char *ifname, int ifname_size)
4062
{
4063
char dev[10]="";
4064
int fd;
4065
if( (fd = tap_alloc(dev)) < 0 ){
4066
fprintf(stderr, "Cannot allocate TAP device\n");
4067
return -1;
4068
}
4069
pstrcpy(ifname, ifname_size, dev);
4070
fcntl(fd, F_SETFL, O_NONBLOCK);
4071
return fd;
4072
}
4073
#else
4074
static int tap_open(char *ifname, int ifname_size)
4075
{
4076
struct ifreq ifr;
4077
int fd, ret;
4078
4079
TFR(fd = open("/dev/net/tun", O_RDWR));
4080
if (fd < 0) {
4081
fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4082
return -1;
4083
}
4084
memset(&ifr, 0, sizeof(ifr));
4085
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4086
if (ifname[0] != '\0')
4087
pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4088
else
4089
pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4090
ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4091
if (ret != 0) {
4092
fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4093
close(fd);
4094
return -1;
4095
}
4096
pstrcpy(ifname, ifname_size, ifr.ifr_name);
4097
fcntl(fd, F_SETFL, O_NONBLOCK);
4098
return fd;
4099
}
4100
#endif
4101
4102
static int launch_script(const char *setup_script, const char *ifname, int fd)
4103
{
4104
int pid, status;
4105
char *args[3];
4106
char **parg;
4107
4108
/* try to launch network script */
4109
pid = fork();
4110
if (pid >= 0) {
4111
if (pid == 0) {
4112
int open_max = sysconf (_SC_OPEN_MAX), i;
4113
for (i = 0; i < open_max; i++)
4114
if (i != STDIN_FILENO &&
4115
i != STDOUT_FILENO &&
4116
i != STDERR_FILENO &&
4117
i != fd)
4118
close(i);
4119
4120
parg = args;
4121
*parg++ = (char *)setup_script;
4122
*parg++ = (char *)ifname;
4123
*parg++ = NULL;
4124
execv(setup_script, args);
4125
_exit(1);
4126
}
4127
while (waitpid(pid, &status, 0) != pid);
4128
if (!WIFEXITED(status) ||
4129
WEXITSTATUS(status) != 0) {
4130
fprintf(stderr, "%s: could not launch network script\n",
4131
setup_script);
4132
return -1;
4133
}
4134
}
4135
return 0;
4136
}
4137
4138
static int net_tap_init(VLANState *vlan, const char *ifname1,
4139
const char *setup_script, const char *down_script)
4140
{
4141
TAPState *s;
4142
int fd;
4143
char ifname[128];
4144
4145
if (ifname1 != NULL)
4146
pstrcpy(ifname, sizeof(ifname), ifname1);
4147
else
4148
ifname[0] = '\0';
4149
TFR(fd = tap_open(ifname, sizeof(ifname)));
4150
if (fd < 0)
4151
return -1;
4152
4153
if (!setup_script || !strcmp(setup_script, "no"))
4154
setup_script = "";
4155
if (setup_script[0] != '\0') {
4156
if (launch_script(setup_script, ifname, fd))
4157
return -1;
4158
}
4159
s = net_tap_fd_init(vlan, fd);
4160
if (!s)
4161
return -1;
4162
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4163
"tap: ifname=%s setup_script=%s", ifname, setup_script);
4164
if (down_script && strcmp(down_script, "no"))
4165
snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4166
return 0;
4167
}
4168
4169
#endif /* !_WIN32 */
4170
4171
/* network connection */
4172
typedef struct NetSocketState {
4173
VLANClientState *vc;
4174
int fd;
4175
int state; /* 0 = getting length, 1 = getting data */
4176
int index;
4177
int packet_len;
4178
uint8_t buf[4096];
4179
struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4180
} NetSocketState;
4181
4182
typedef struct NetSocketListenState {
4183
VLANState *vlan;
4184
int fd;
4185
} NetSocketListenState;
4186
4187
/* XXX: we consider we can send the whole packet without blocking */
4188
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4189
{
4190
NetSocketState *s = opaque;
4191
uint32_t len;
4192
len = htonl(size);
4193
4194
send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4195
send_all(s->fd, buf, size);
4196
}
4197
4198
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4199
{
4200
NetSocketState *s = opaque;
4201
sendto(s->fd, buf, size, 0,
4202
(struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4203
}
4204
4205
static void net_socket_send(void *opaque)
4206
{
4207
NetSocketState *s = opaque;
4208
int l, size, err;
4209
uint8_t buf1[4096];
4210
const uint8_t *buf;
4211
4212
size = recv(s->fd, buf1, sizeof(buf1), 0);
4213
if (size < 0) {
4214
err = socket_error();
4215
if (err != EWOULDBLOCK)
4216
goto eoc;
4217
} else if (size == 0) {
4218
/* end of connection */
4219
eoc:
4220
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4221
closesocket(s->fd);
4222
return;
4223
}
4224
buf = buf1;
4225
while (size > 0) {
4226
/* reassemble a packet from the network */
4227
switch(s->state) {
4228
case 0:
4229
l = 4 - s->index;
4230
if (l > size)
4231
l = size;
4232
memcpy(s->buf + s->index, buf, l);
4233
buf += l;
4234
size -= l;
4235
s->index += l;
4236
if (s->index == 4) {
4237
/* got length */
4238
s->packet_len = ntohl(*(uint32_t *)s->buf);
4239
s->index = 0;
4240
s->state = 1;
4241
}
4242
break;
4243
case 1:
4244
l = s->packet_len - s->index;
4245
if (l > size)
4246
l = size;
4247
memcpy(s->buf + s->index, buf, l);
4248
s->index += l;
4249
buf += l;
4250
size -= l;
4251
if (s->index >= s->packet_len) {
4252
qemu_send_packet(s->vc, s->buf, s->packet_len);
4253
s->index = 0;
4254
s->state = 0;
4255
}
4256
break;
4257
}
4258
}
4259
}
4260
4261
static void net_socket_send_dgram(void *opaque)
4262
{
4263
NetSocketState *s = opaque;
4264
int size;
4265
4266
size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4267
if (size < 0)
4268
return;
4269
if (size == 0) {
4270
/* end of connection */
4271
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4272
return;
4273
}
4274
qemu_send_packet(s->vc, s->buf, size);
4275
}
4276
4277
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4278
{
4279
struct ip_mreq imr;
4280
int fd;
4281
int val, ret;
4282
if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4283
fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4284
inet_ntoa(mcastaddr->sin_addr),
4285
(int)ntohl(mcastaddr->sin_addr.s_addr));
4286
return -1;
4287
4288
}
4289
fd = socket(PF_INET, SOCK_DGRAM, 0);
4290
if (fd < 0) {
4291
perror("socket(PF_INET, SOCK_DGRAM)");
4292
return -1;
4293
}
4294
4295
val = 1;
4296
ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4297
(const char *)&val, sizeof(val));
4298
if (ret < 0) {
4299
perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4300
goto fail;
4301
}
4302
4303
ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4304
if (ret < 0) {
4305
perror("bind");
4306
goto fail;
4307
}
4308
4309
/* Add host to multicast group */
4310
imr.imr_multiaddr = mcastaddr->sin_addr;
4311
imr.imr_interface.s_addr = htonl(INADDR_ANY);
4312
4313
ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4314
(const char *)&imr, sizeof(struct ip_mreq));
4315
if (ret < 0) {
4316
perror("setsockopt(IP_ADD_MEMBERSHIP)");
4317
goto fail;
4318
}
4319
4320
/* Force mcast msgs to loopback (eg. several QEMUs in same host */
4321
val = 1;
4322
ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4323
(const char *)&val, sizeof(val));
4324
if (ret < 0) {
4325
perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4326
goto fail;
4327
}
4328
4329
socket_set_nonblock(fd);
4330
return fd;
4331
fail:
4332
if (fd >= 0)
4333
closesocket(fd);
4334
return -1;
4335
}
4336
4337
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4338
int is_connected)
4339
{
4340
struct sockaddr_in saddr;
4341
int newfd;
4342
socklen_t saddr_len;
4343
NetSocketState *s;
4344
4345
/* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4346
* Because this may be "shared" socket from a "master" process, datagrams would be recv()
4347
* by ONLY ONE process: we must "clone" this dgram socket --jjo
4348
*/
4349
4350
if (is_connected) {
4351
if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4352
/* must be bound */
4353
if (saddr.sin_addr.s_addr==0) {
4354
fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4355
fd);
4356
return NULL;
4357
}
4358
/* clone dgram socket */
4359
newfd = net_socket_mcast_create(&saddr);
4360
if (newfd < 0) {
4361
/* error already reported by net_socket_mcast_create() */
4362
close(fd);
4363
return NULL;
4364
}
4365
/* clone newfd to fd, close newfd */
4366
dup2(newfd, fd);
4367
close(newfd);
4368
4369
} else {
4370
fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4371
fd, strerror(errno));
4372
return NULL;
4373
}
4374
}
4375
4376
s = qemu_mallocz(sizeof(NetSocketState));
4377
if (!s)
4378
return NULL;
4379
s->fd = fd;
4380
4381
s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4382
qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4383
4384
/* mcast: save bound address as dst */
4385
if (is_connected) s->dgram_dst=saddr;
4386
4387
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4388
"socket: fd=%d (%s mcast=%s:%d)",
4389
fd, is_connected? "cloned" : "",
4390
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4391
return s;
4392
}
4393
4394
static void net_socket_connect(void *opaque)
4395
{
4396
NetSocketState *s = opaque;
4397
qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4398
}
4399
4400
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4401
int is_connected)
4402
{
4403
NetSocketState *s;
4404
s = qemu_mallocz(sizeof(NetSocketState));
4405
if (!s)
4406
return NULL;
4407
s->fd = fd;
4408
s->vc = qemu_new_vlan_client(vlan,
4409
net_socket_receive, NULL, s);
4410
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4411
"socket: fd=%d", fd);
4412
if (is_connected) {
4413
net_socket_connect(s);
4414
} else {
4415
qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4416
}
4417
return s;
4418
}
4419
4420
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4421
int is_connected)
4422
{
4423
int so_type=-1, optlen=sizeof(so_type);
4424
4425
if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4426
(socklen_t *)&optlen)< 0) {
4427
fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4428
return NULL;
4429
}
4430
switch(so_type) {
4431
case SOCK_DGRAM:
4432
return net_socket_fd_init_dgram(vlan, fd, is_connected);
4433
case SOCK_STREAM:
4434
return net_socket_fd_init_stream(vlan, fd, is_connected);
4435
default:
4436
/* who knows ... this could be a eg. a pty, do warn and continue as stream */
4437
fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4438
return net_socket_fd_init_stream(vlan, fd, is_connected);
4439
}
4440
return NULL;
4441
}
4442
4443
static void net_socket_accept(void *opaque)
4444
{
4445
NetSocketListenState *s = opaque;
4446
NetSocketState *s1;
4447
struct sockaddr_in saddr;
4448
socklen_t len;
4449
int fd;
4450
4451
for(;;) {
4452
len = sizeof(saddr);
4453
fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4454
if (fd < 0 && errno != EINTR) {
4455
return;
4456
} else if (fd >= 0) {
4457
break;
4458
}
4459
}
4460
s1 = net_socket_fd_init(s->vlan, fd, 1);
4461
if (!s1) {
4462
closesocket(fd);
4463
} else {
4464
snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4465
"socket: connection from %s:%d",
4466
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4467
}
4468
}
4469
4470
static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4471
{
4472
NetSocketListenState *s;
4473
int fd, val, ret;
4474
struct sockaddr_in saddr;
4475
4476
if (parse_host_port(&saddr, host_str) < 0)
4477
return -1;
4478
4479
s = qemu_mallocz(sizeof(NetSocketListenState));
4480
if (!s)
4481
return -1;
4482
4483
fd = socket(PF_INET, SOCK_STREAM, 0);
4484
if (fd < 0) {
4485
perror("socket");
4486
return -1;
4487
}
4488
socket_set_nonblock(fd);
4489
4490
/* allow fast reuse */
4491
val = 1;
4492
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4493
4494
ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4495
if (ret < 0) {
4496
perror("bind");
4497
return -1;
4498
}
4499
ret = listen(fd, 0);
4500
if (ret < 0) {
4501
perror("listen");
4502
return -1;
4503
}
4504
s->vlan = vlan;
4505
s->fd = fd;
4506
qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4507
return 0;
4508
}
4509
4510
static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4511
{
4512
NetSocketState *s;
4513
int fd, connected, ret, err;
4514
struct sockaddr_in saddr;
4515
4516
if (parse_host_port(&saddr, host_str) < 0)
4517
return -1;
4518
4519
fd = socket(PF_INET, SOCK_STREAM, 0);
4520
if (fd < 0) {
4521
perror("socket");
4522
return -1;
4523
}
4524
socket_set_nonblock(fd);
4525
4526
connected = 0;
4527
for(;;) {
4528
ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4529
if (ret < 0) {
4530
err = socket_error();
4531
if (err == EINTR || err == EWOULDBLOCK) {
4532
} else if (err == EINPROGRESS) {
4533
break;
4534
#ifdef _WIN32
4535
} else if (err == WSAEALREADY) {
4536
break;
4537
#endif
4538
} else {
4539
perror("connect");
4540
closesocket(fd);
4541
return -1;
4542
}
4543
} else {
4544
connected = 1;
4545
break;
4546
}
4547
}
4548
s = net_socket_fd_init(vlan, fd, connected);
4549
if (!s)
4550
return -1;
4551
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4552
"socket: connect to %s:%d",
4553
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4554
return 0;
4555
}
4556
4557
static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4558
{
4559
NetSocketState *s;
4560
int fd;
4561
struct sockaddr_in saddr;
4562
4563
if (parse_host_port(&saddr, host_str) < 0)
4564
return -1;
4565
4566
4567
fd = net_socket_mcast_create(&saddr);
4568
if (fd < 0)
4569
return -1;
4570
4571
s = net_socket_fd_init(vlan, fd, 0);
4572
if (!s)
4573
return -1;
4574
4575
s->dgram_dst = saddr;
4576
4577
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4578
"socket: mcast=%s:%d",
4579
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4580
return 0;
4581
4582
}
4583
4584
static const char *get_word(char *buf, int buf_size, const char *p)
4585
{
4586
char *q;
4587
int substring;
4588
4589
substring = 0;
1851
#endif
1852
1853
const char *get_opt_name(char *buf, int buf_size, const char *p)
1854
{
1855
char *q;
1856
1857
q = buf;
1858
while (*p != '\0' && *p != '=') {
1859
if (q && (q - buf) < buf_size - 1)
1860
*q++ = *p;
1861
p++;
1862
}
1863
if (q)
1864
*q = '\0';
1865
1866
return p;
1867
}
1868
1869
const char *get_opt_value(char *buf, int buf_size, const char *p)
1870
{
1871
char *q;
1872
4590
1873
q = buf;
4591
1874
while (*p != '\0') {
4592
if (*p == '\\') {
4593
p++;
4594
if (*p == '\0')
1875
if (*p == ',') {
1876
if (*(p + 1) != ',')
4595
1877
break;
4596
} else if (*p == '\"') {
4597
substring = !substring;
4598
1878
p++;
4599
continue;
4600
} else if (!substring && (*p == ',' || *p == '='))
4601
break;
1879
}
4602
1880
if (q && (q - buf) < buf_size - 1)
4603
1881
*q++ = *p;
4604
1882
p++;
4609
1887
return p;
4610
1888
}
4611
1889
4612
static int get_param_value(char *buf, int buf_size,
4613
const char *tag, const char *str)
1890
int get_param_value(char *buf, int buf_size,
1891
const char *tag, const char *str)
4614
1892
{
4615
1893
const char *p;
4616
1894
char option[128];
4617
1895
4618
1896
p = str;
4619
1897
for(;;) {
4620
p = get_word(option, sizeof(option), p);
1898
p = get_opt_name(option, sizeof(option), p);
4621
1899
if (*p != '=')
4622
1900
break;
4623
1901
p++;
4624
1902
if (!strcmp(tag, option)) {
4625
(void)get_word(buf, buf_size, p);
1903
(void)get_opt_value(buf, buf_size, p);
4626
1904
return strlen(buf);
4627
1905
} else {
4628
p = get_word(NULL, 0, p);
1906
p = get_opt_value(NULL, 0, p);
4629
1907
}
4630
1908
if (*p != ',')
4631
1909
break;
4634
1912
return 0;
4635
1913
}
4636
1914
4637
static int check_params(char *buf, int buf_size,
4638
char **params, const char *str)
1915
int check_params(char *buf, int buf_size,
1916
const char * const *params, const char *str)
4639
1917
{
4640
1918
const char *p;
4641
1919
int i;
4642
1920
4643
1921
p = str;
4644
1922
for(;;) {
4645
p = get_word(buf, buf_size, p);
1923
p = get_opt_name(buf, buf_size, p);
4646
1924
if (*p != '=')
4647
1925
return -1;
4648
1926
p++;
4651
1929
break;
4652
1930
if (params[i] == NULL)
4653
1931
return -1;
4654
p = get_word(NULL, 0, p);
1932
p = get_opt_value(NULL, 0, p);
4655
1933
if (*p != ',')
4656
1934
break;
4657
1935
p++;
4659
1937
return 0;
4660
1938
}
4661
1939
4662
4663
static int net_client_init(const char *str)
4664
{
4665
const char *p;
4666
char *q;
4667
char device[64];
4668
char buf[1024];
4669
int vlan_id, ret;
4670
VLANState *vlan;
4671
4672
p = str;
4673
q = device;
4674
while (*p != '\0' && *p != ',') {
4675
if ((q - device) < sizeof(device) - 1)
4676
*q++ = *p;
4677
p++;
4678
}
4679
*q = '\0';
4680
if (*p == ',')
4681
p++;
4682
vlan_id = 0;
4683
if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4684
vlan_id = strtol(buf, NULL, 0);
4685
}
4686
vlan = qemu_find_vlan(vlan_id);
4687
if (!vlan) {
4688
fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4689
return -1;
4690
}
4691
if (!strcmp(device, "nic")) {
4692
NICInfo *nd;
4693
uint8_t *macaddr;
4694
4695
if (nb_nics >= MAX_NICS) {
4696
fprintf(stderr, "Too Many NICs\n");
4697
return -1;
4698
}
4699
nd = &nd_table[nb_nics];
4700
macaddr = nd->macaddr;
4701
macaddr[0] = 0x52;
4702
macaddr[1] = 0x54;
4703
macaddr[2] = 0x00;
4704
macaddr[3] = 0x12;
4705
macaddr[4] = 0x34;
4706
macaddr[5] = 0x56 + nb_nics;
4707
4708
if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4709
if (parse_macaddr(macaddr, buf) < 0) {
4710
fprintf(stderr, "invalid syntax for ethernet address\n");
4711
return -1;
4712
}
4713
}
4714
if (get_param_value(buf, sizeof(buf), "model", p)) {
4715
nd->model = strdup(buf);
4716
}
4717
nd->vlan = vlan;
4718
nb_nics++;
4719
vlan->nb_guest_devs++;
4720
ret = 0;
4721
} else
4722
if (!strcmp(device, "none")) {
4723
/* does nothing. It is needed to signal that no network cards
4724
are wanted */
4725
ret = 0;
4726
} else
4727
#ifdef CONFIG_SLIRP
4728
if (!strcmp(device, "user")) {
4729
if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4730
pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4731
}
4732
vlan->nb_host_devs++;
4733
ret = net_slirp_init(vlan);
4734
} else
4735
#endif
4736
#ifdef _WIN32
4737
if (!strcmp(device, "tap")) {
4738
char ifname[64];
4739
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4740
fprintf(stderr, "tap: no interface name\n");
4741
return -1;
4742
}
4743
vlan->nb_host_devs++;
4744
ret = tap_win32_init(vlan, ifname);
4745
} else
4746
#else
4747
if (!strcmp(device, "tap")) {
4748
char ifname[64];
4749
char setup_script[1024], down_script[1024];
4750
int fd;
4751
vlan->nb_host_devs++;
4752
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4753
fd = strtol(buf, NULL, 0);
4754
ret = -1;
4755
if (net_tap_fd_init(vlan, fd))
4756
ret = 0;
4757
} else {
4758
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4759
ifname[0] = '\0';
4760
}
4761
if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
4762
pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
4763
}
4764
if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
4765
pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
4766
}
4767
ret = net_tap_init(vlan, ifname, setup_script, down_script);
4768
}
4769
} else
4770
#endif
4771
if (!strcmp(device, "socket")) {
4772
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4773
int fd;
4774
fd = strtol(buf, NULL, 0);
4775
ret = -1;
4776
if (net_socket_fd_init(vlan, fd, 1))
4777
ret = 0;
4778
} else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
4779
ret = net_socket_listen_init(vlan, buf);
4780
} else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
4781
ret = net_socket_connect_init(vlan, buf);
4782
} else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
4783
ret = net_socket_mcast_init(vlan, buf);
4784
} else {
4785
fprintf(stderr, "Unknown socket options: %s\n", p);
4786
return -1;
4787
}
4788
vlan->nb_host_devs++;
4789
} else
4790
{
4791
fprintf(stderr, "Unknown network device: %s\n", device);
4792
return -1;
4793
}
4794
if (ret < 0) {
4795
fprintf(stderr, "Could not initialize device '%s'\n", device);
4796
}
4797
4798
return ret;
4799
}
4800
4801
void do_info_network(void)
4802
{
4803
VLANState *vlan;
4804
VLANClientState *vc;
4805
4806
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4807
term_printf("VLAN %d devices:\n", vlan->id);
4808
for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4809
term_printf(" %s\n", vc->info_str);
4810
}
4811
}
4812
4813
#define HD_ALIAS "file=\"%s\",index=%d,media=disk"
1940
/***********************************************************/
1941
/* Bluetooth support */
1942
static int nb_hcis;
1943
static int cur_hci;
1944
static struct HCIInfo *hci_table[MAX_NICS];
1945
1946
static struct bt_vlan_s {
1947
struct bt_scatternet_s net;
1948
int id;
1949
struct bt_vlan_s *next;
1950
} *first_bt_vlan;
1951
1952
/* find or alloc a new bluetooth "VLAN" */
1953
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1954
{
1955
struct bt_vlan_s **pvlan, *vlan;
1956
for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1957
if (vlan->id == id)
1958
return &vlan->net;
1959
}
1960
vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1961
vlan->id = id;
1962
pvlan = &first_bt_vlan;
1963
while (*pvlan != NULL)
1964
pvlan = &(*pvlan)->next;
1965
*pvlan = vlan;
1966
return &vlan->net;
1967
}
1968
1969
static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1970
{
1971
}
1972
1973
static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1974
{
1975
return -ENOTSUP;
1976
}
1977
1978
static struct HCIInfo null_hci = {
1979
.cmd_send = null_hci_send,
1980
.sco_send = null_hci_send,
1981
.acl_send = null_hci_send,
1982
.bdaddr_set = null_hci_addr_set,
1983
};
1984
1985
struct HCIInfo *qemu_next_hci(void)
1986
{
1987
if (cur_hci == nb_hcis)
1988
return &null_hci;
1989
1990
return hci_table[cur_hci++];
1991
}
1992
1993
static struct HCIInfo *hci_init(const char *str)
1994
{
1995
char *endp;
1996
struct bt_scatternet_s *vlan = 0;
1997
1998
if (!strcmp(str, "null"))
1999
/* null */
2000
return &null_hci;
2001
else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
2002
/* host[:hciN] */
2003
return bt_host_hci(str[4] ? str + 5 : "hci0");
2004
else if (!strncmp(str, "hci", 3)) {
2005
/* hci[,vlan=n] */
2006
if (str[3]) {
2007
if (!strncmp(str + 3, ",vlan=", 6)) {
2008
vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
2009
if (*endp)
2010
vlan = 0;
2011
}
2012
} else
2013
vlan = qemu_find_bt_vlan(0);
2014
if (vlan)
2015
return bt_new_hci(vlan);
2016
}
2017
2018
fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
2019
2020
return 0;
2021
}
2022
2023
static int bt_hci_parse(const char *str)
2024
{
2025
struct HCIInfo *hci;
2026
bdaddr_t bdaddr;
2027
2028
if (nb_hcis >= MAX_NICS) {
2029
fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
2030
return -1;
2031
}
2032
2033
hci = hci_init(str);
2034
if (!hci)
2035
return -1;
2036
2037
bdaddr.b[0] = 0x52;
2038
bdaddr.b[1] = 0x54;
2039
bdaddr.b[2] = 0x00;
2040
bdaddr.b[3] = 0x12;
2041
bdaddr.b[4] = 0x34;
2042
bdaddr.b[5] = 0x56 + nb_hcis;
2043
hci->bdaddr_set(hci, bdaddr.b);
2044
2045
hci_table[nb_hcis++] = hci;
2046
2047
return 0;
2048
}
2049
2050
static void bt_vhci_add(int vlan_id)
2051
{
2052
struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
2053
2054
if (!vlan->slave)
2055
fprintf(stderr, "qemu: warning: adding a VHCI to "
2056
"an empty scatternet %i\n", vlan_id);
2057
2058
bt_vhci_init(bt_new_hci(vlan));
2059
}
2060
2061
static struct bt_device_s *bt_device_add(const char *opt)
2062
{
2063
struct bt_scatternet_s *vlan;
2064
int vlan_id = 0;
2065
char *endp = strstr(opt, ",vlan=");
2066
int len = (endp ? endp - opt : strlen(opt)) + 1;
2067
char devname[10];
2068
2069
pstrcpy(devname, MIN(sizeof(devname), len), opt);
2070
2071
if (endp) {
2072
vlan_id = strtol(endp + 6, &endp, 0);
2073
if (*endp) {
2074
fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2075
return 0;
2076
}
2077
}
2078
2079
vlan = qemu_find_bt_vlan(vlan_id);
2080
2081
if (!vlan->slave)
2082
fprintf(stderr, "qemu: warning: adding a slave device to "
2083
"an empty scatternet %i\n", vlan_id);
2084
2085
if (!strcmp(devname, "keyboard"))
2086
return bt_keyboard_init(vlan);
2087
2088
fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2089
return 0;
2090
}
2091
2092
static int bt_parse(const char *opt)
2093
{
2094
const char *endp, *p;
2095
int vlan;
2096
2097
if (strstart(opt, "hci", &endp)) {
2098
if (!*endp || *endp == ',') {
2099
if (*endp)
2100
if (!strstart(endp, ",vlan=", 0))
2101
opt = endp + 1;
2102
2103
return bt_hci_parse(opt);
2104
}
2105
} else if (strstart(opt, "vhci", &endp)) {
2106
if (!*endp || *endp == ',') {
2107
if (*endp) {
2108
if (strstart(endp, ",vlan=", &p)) {
2109
vlan = strtol(p, (char **) &endp, 0);
2110
if (*endp) {
2111
fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2112
return 1;
2113
}
2114
} else {
2115
fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2116
return 1;
2117
}
2118
} else
2119
vlan = 0;
2120
2121
bt_vhci_add(vlan);
2122
return 0;
2123
}
2124
} else if (strstart(opt, "device:", &endp))
2125
return !bt_device_add(endp);
2126
2127
fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2128
return 1;
2129
}
2130
2131
/***********************************************************/
2132
/* QEMU Block devices */
2133
2134
#define HD_ALIAS "index=%d,media=disk"
4814
2135
#ifdef TARGET_PPC
4815
2136
#define CDROM_ALIAS "index=1,media=cdrom"
4816
2137
#else
4817
2138
#define CDROM_ALIAS "index=2,media=cdrom"
4818
2139
#endif
4819
2140
#define FD_ALIAS "index=%d,if=floppy"
4820
#define PFLASH_ALIAS "file=\"%s\",if=pflash"
4821
#define MTD_ALIAS "file=\"%s\",if=mtd"
2141
#define PFLASH_ALIAS "if=pflash"
2142
#define MTD_ALIAS "if=mtd"
4822
2143
#define SD_ALIAS "index=0,if=sd"
4823
2144
4824
static int drive_add(const char *fmt, ...)
2145
static int drive_opt_get_free_idx(void)
2146
{
2147
int index;
2148
2149
for (index = 0; index < MAX_DRIVES; index++)
2150
if (!drives_opt[index].used) {
2151
drives_opt[index].used = 1;
2152
return index;
2153
}
2154
2155
return -1;
2156
}
2157
2158
static int drive_get_free_idx(void)
2159
{
2160
int index;
2161
2162
for (index = 0; index < MAX_DRIVES; index++)
2163
if (!drives_table[index].used) {
2164
drives_table[index].used = 1;
2165
return index;
2166
}
2167
2168
return -1;
2169
}
2170
2171
int drive_add(const char *file, const char *fmt, ...)
4825
2172
{
4826
2173
va_list ap;
2174
int index = drive_opt_get_free_idx();
4827
2175
4828
if (nb_drives_opt >= MAX_DRIVES) {
2176
if (nb_drives_opt >= MAX_DRIVES || index == -1) {
4829
2177
fprintf(stderr, "qemu: too many drives\n");
4830
exit(1);
2178
return -1;
4831
2179
}
4832
2180
2181
drives_opt[index].file = file;
4833
2182
va_start(ap, fmt);
4834
vsnprintf(drives_opt[nb_drives_opt], sizeof(drives_opt[0]), fmt, ap);
2183
vsnprintf(drives_opt[index].opt,
2184
sizeof(drives_opt[0].opt), fmt, ap);
4835
2185
va_end(ap);
4836
2186
4837
return nb_drives_opt++;
2187
nb_drives_opt++;
2188
return index;
2189
}
2190
2191
void drive_remove(int index)
2192
{
2193
drives_opt[index].used = 0;
2194
nb_drives_opt--;
4838
2195
}
4839
2196
4840
2197
int drive_get_index(BlockInterfaceType type, int bus, int unit)
4843
2200
4844
2201
/* seek interface, bus and unit */
4845
2202
4846
for (index = 0; index < nb_drives; index++)
2203
for (index = 0; index < MAX_DRIVES; index++)
4847
2204
if (drives_table[index].type == type &&
4848
2205
drives_table[index].bus == bus &&
4849
drives_table[index].unit == unit)
2206
drives_table[index].unit == unit &&
2207
drives_table[index].used)
4850
2208
return index;
4851
2209
4852
2210
return -1;
4866
2224
return max_bus;
4867
2225
}
4868
2226
4869
static int drive_init(const char *str, int snapshot, QEMUMachine *machine)
2227
const char *drive_get_serial(BlockDriverState *bdrv)
2228
{
2229
int index;
2230
2231
for (index = 0; index < nb_drives; index++)
2232
if (drives_table[index].bdrv == bdrv)
2233
return drives_table[index].serial;
2234
2235
return "\0";
2236
}
2237
2238
BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2239
{
2240
int index;
2241
2242
for (index = 0; index < nb_drives; index++)
2243
if (drives_table[index].bdrv == bdrv)
2244
return drives_table[index].onerror;
2245
2246
return BLOCK_ERR_STOP_ENOSPC;
2247
}
2248
2249
static void bdrv_format_print(void *opaque, const char *name)
2250
{
2251
fprintf(stderr, " %s", name);
2252
}
2253
2254
void drive_uninit(BlockDriverState *bdrv)
2255
{
2256
int i;
2257
2258
for (i = 0; i < MAX_DRIVES; i++)
2259
if (drives_table[i].bdrv == bdrv) {
2260
drives_table[i].bdrv = NULL;
2261
drives_table[i].used = 0;
2262
drive_remove(drives_table[i].drive_opt_idx);
2263
nb_drives--;
2264
break;
2265
}
2266
}
2267
2268
int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
4870
2269
{
4871
2270
char buf[128];
4872
2271
char file[1024];
4873
2272
char devname[128];
2273
char serial[21];
4874
2274
const char *mediastr = "";
4875
2275
BlockInterfaceType type;
4876
2276
enum { MEDIA_DISK, MEDIA_CDROM } media;
4877
2277
int bus_id, unit_id;
4878
2278
int cyls, heads, secs, translation;
4879
2279
BlockDriverState *bdrv;
2280
BlockDriver *drv = NULL;
2281
QEMUMachine *machine = opaque;
4880
2282
int max_devs;
4881
2283
int index;
4882
2284
int cache;
4883
int bdrv_flags;
4884
char *params[] = { "bus", "unit", "if", "index", "cyls", "heads",
4885
"secs", "trans", "media", "snapshot", "file",
4886
"cache", NULL };
2285
int bdrv_flags, onerror;
2286
int drives_table_idx;
2287
char *str = arg->opt;
2288
static const char * const params[] = { "bus", "unit", "if", "index",
2289
"cyls", "heads", "secs", "trans",
2290
"media", "snapshot", "file",
2291
"cache", "format", "serial", "werror",
2292
NULL };
4887
2293
4888
2294
if (check_params(buf, sizeof(buf), params, str) < 0) {
4889
fprintf(stderr, "qemu: unknowm parameter '%s' in '%s'\n",
2295
fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
4890
2296
buf, str);
4891
2297
return -1;
4892
2298
}
4897
2303
unit_id = -1;
4898
2304
translation = BIOS_ATA_TRANSLATION_AUTO;
4899
2305
index = -1;
4900
cache = 1;
2306
cache = 3;
4901
2307
4902
if (!strcmp(machine->name, "realview") ||
4903
!strcmp(machine->name, "SS-5") ||
4904
!strcmp(machine->name, "SS-10") ||
4905
!strcmp(machine->name, "SS-600MP") ||
4906
!strcmp(machine->name, "versatilepb") ||
4907
!strcmp(machine->name, "versatileab")) {
2308
if (machine->use_scsi) {
4908
2309
type = IF_SCSI;
4909
2310
max_devs = MAX_SCSI_DEVS;
4910
strcpy(devname, "scsi");
2311
pstrcpy(devname, sizeof(devname), "scsi");
4911
2312
} else {
4912
2313
type = IF_IDE;
4913
2314
max_devs = MAX_IDE_DEVS;
4914
strcpy(devname, "ide");
2315
pstrcpy(devname, sizeof(devname), "ide");
4915
2316
}
4916
2317
media = MEDIA_DISK;
4917
2318
4934
2335
}
4935
2336
4936
2337
if (get_param_value(buf, sizeof(buf), "if", str)) {
4937
strncpy(devname, buf, sizeof(devname));
2338
pstrcpy(devname, sizeof(devname), buf);
4938
2339
if (!strcmp(buf, "ide")) {
4939
2340
type = IF_IDE;
4940
2341
max_devs = MAX_IDE_DEVS;
4953
2354
} else if (!strcmp(buf, "sd")) {
4954
2355
type = IF_SD;
4955
2356
max_devs = 0;
4956
} else {
2357
} else if (!strcmp(buf, "virtio")) {
2358
type = IF_VIRTIO;
2359
max_devs = 0;
2360
} else {
4957
2361
fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
4958
2362
return -1;
4959
2363
}
5041
2445
}
5042
2446
5043
2447
if (get_param_value(buf, sizeof(buf), "cache", str)) {
5044
if (!strcmp(buf, "off"))
2448
if (!strcmp(buf, "off") || !strcmp(buf, "none"))
5045
2449
cache = 0;
5046
else if (!strcmp(buf, "on"))
2450
else if (!strcmp(buf, "writethrough"))
5047
2451
cache = 1;
2452
else if (!strcmp(buf, "writeback"))
2453
cache = 2;
5048
2454
else {
5049
2455
fprintf(stderr, "qemu: invalid cache option\n");
5050
2456
return -1;
5051
2457
}
5052
2458
}
5053
2459
5054
get_param_value(file, sizeof(file), "file", str);
2460
if (get_param_value(buf, sizeof(buf), "format", str)) {
2461
if (strcmp(buf, "?") == 0) {
2462
fprintf(stderr, "qemu: Supported formats:");
2463
bdrv_iterate_format(bdrv_format_print, NULL);
2464
fprintf(stderr, "\n");
2465
return -1;
2466
}
2467
drv = bdrv_find_format(buf);
2468
if (!drv) {
2469
fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2470
return -1;
2471
}
2472
}
2473
2474
if (arg->file == NULL)
2475
get_param_value(file, sizeof(file), "file", str);
2476
else
2477
pstrcpy(file, sizeof(file), arg->file);
2478
2479
if (!get_param_value(serial, sizeof(serial), "serial", str))
2480
memset(serial, 0, sizeof(serial));
2481
2482
onerror = BLOCK_ERR_STOP_ENOSPC;
2483
if (get_param_value(buf, sizeof(serial), "werror", str)) {
2484
if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2485
fprintf(stderr, "werror is no supported by this format\n");
2486
return -1;
2487
}
2488
if (!strcmp(buf, "ignore"))
2489
onerror = BLOCK_ERR_IGNORE;
2490
else if (!strcmp(buf, "enospc"))
2491
onerror = BLOCK_ERR_STOP_ENOSPC;
2492
else if (!strcmp(buf, "stop"))
2493
onerror = BLOCK_ERR_STOP_ANY;
2494
else if (!strcmp(buf, "report"))
2495
onerror = BLOCK_ERR_REPORT;
2496
else {
2497
fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2498
return -1;
2499
}
2500
}
5055
2501
5056
2502
/* compute bus and unit according index */
5057
2503
5099
2545
*/
5100
2546
5101
2547
if (drive_get_index(type, bus_id, unit_id) != -1)
5102
return 0;
2548
return -2;
5103
2549
5104
2550
/* init */
5105
2551
5112
2558
snprintf(buf, sizeof(buf), "%s%s%i",
5113
2559
devname, mediastr, unit_id);
5114
2560
bdrv = bdrv_new(buf);
5115
drives_table[nb_drives].bdrv = bdrv;
5116
drives_table[nb_drives].type = type;
5117
drives_table[nb_drives].bus = bus_id;
5118
drives_table[nb_drives].unit = unit_id;
2561
drives_table_idx = drive_get_free_idx();
2562
drives_table[drives_table_idx].bdrv = bdrv;
2563
drives_table[drives_table_idx].type = type;
2564
drives_table[drives_table_idx].bus = bus_id;
2565
drives_table[drives_table_idx].unit = unit_id;
2566
drives_table[drives_table_idx].onerror = onerror;
2567
drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
2568
strncpy(drives_table[nb_drives].serial, serial, sizeof(serial));
5119
2569
nb_drives++;
5120
2570
5121
2571
switch(type) {
5141
2591
break;
5142
2592
case IF_PFLASH:
5143
2593
case IF_MTD:
2594
case IF_VIRTIO:
5144
2595
break;
5145
2596
}
5146
2597
if (!file[0])
5147
return 0;
2598
return -2;
5148
2599
bdrv_flags = 0;
5149
if (snapshot)
2600
if (snapshot) {
5150
2601
bdrv_flags |= BDRV_O_SNAPSHOT;
5151
if (!cache)
5152
bdrv_flags |= BDRV_O_DIRECT;
5153
if (bdrv_open(bdrv, file, bdrv_flags) < 0 || qemu_key_check(bdrv, file)) {
2602
cache = 2; /* always use write-back with snapshot */
2603
}
2604
if (cache == 0) /* no caching */
2605
bdrv_flags |= BDRV_O_NOCACHE;
2606
else if (cache == 2) /* write-back */
2607
bdrv_flags |= BDRV_O_CACHE_WB;
2608
else if (cache == 3) /* not specified */
2609
bdrv_flags |= BDRV_O_CACHE_DEF;
2610
if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
5154
2611
fprintf(stderr, "qemu: could not open disk image %s\n",
5155
2612
file);
5156
2613
return -1;
5157
2614
}
5158
return 0;
2615
return drives_table_idx;
5159
2616
}
5160
2617
5161
2618
/***********************************************************/
5175
2632
free_usb_ports = port;
5176
2633
}
5177
2634
2635
int usb_device_add_dev(USBDevice *dev)
2636
{
2637
USBPort *port;
2638
2639
/* Find a USB port to add the device to. */
2640
port = free_usb_ports;
2641
if (!port->next) {
2642
USBDevice *hub;
2643
2644
/* Create a new hub and chain it on. */
2645
free_usb_ports = NULL;
2646
port->next = used_usb_ports;
2647
used_usb_ports = port;
2648
2649
hub = usb_hub_init(VM_USB_HUB_SIZE);
2650
usb_attach(port, hub);
2651
port = free_usb_ports;
2652
}
2653
2654
free_usb_ports = port->next;
2655
port->next = used_usb_ports;
2656
used_usb_ports = port;
2657
usb_attach(port, dev);
2658
return 0;
2659
}
2660
5178
2661
static int usb_device_add(const char *devname)
5179
2662
{
5180
2663
const char *p;
5181
2664
USBDevice *dev;
5182
USBPort *port;
5183
2665
5184
2666
if (!free_usb_ports)
5185
2667
return -1;
5196
2678
dev = usb_msd_init(p);
5197
2679
} else if (!strcmp(devname, "wacom-tablet")) {
5198
2680
dev = usb_wacom_init();
2681
} else if (strstart(devname, "serial:", &p)) {
2682
dev = usb_serial_init(p);
2683
#ifdef CONFIG_BRLAPI
2684
} else if (!strcmp(devname, "braille")) {
2685
dev = usb_baum_init();
2686
#endif
2687
} else if (strstart(devname, "net:", &p)) {
2688
int nic = nb_nics;
2689
2690
if (net_client_init("nic", p) < 0)
2691
return -1;
2692
nd_table[nic].model = "usb";
2693
dev = usb_net_init(&nd_table[nic]);
2694
} else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2695
dev = usb_bt_init(devname[2] ? hci_init(p) :
2696
bt_new_hci(qemu_find_bt_vlan(0)));
5199
2697
} else {
5200
2698
return -1;
5201
2699
}
5202
2700
if (!dev)
5203
2701
return -1;
5204
2702
5205
/* Find a USB port to add the device to. */
5206
port = free_usb_ports;
5207
if (!port->next) {
5208
USBDevice *hub;
5209
5210
/* Create a new hub and chain it on. */
5211
free_usb_ports = NULL;
5212
port->next = used_usb_ports;
5213
used_usb_ports = port;
5214
5215
hub = usb_hub_init(VM_USB_HUB_SIZE);
5216
usb_attach(port, hub);
5217
port = free_usb_ports;
5218
}
5219
5220
free_usb_ports = port->next;
5221
port->next = used_usb_ports;
5222
used_usb_ports = port;
5223
usb_attach(port, dev);
5224
return 0;
2703
return usb_device_add_dev(dev);
5225
2704
}
5226
2705
5227
static int usb_device_del(const char *devname)
2706
int usb_device_del_addr(int bus_num, int addr)
5228
2707
{
5229
2708
USBPort *port;
5230
2709
USBPort **lastp;
5231
2710
USBDevice *dev;
5232
int bus_num, addr;
5233
const char *p;
5234
2711
5235
2712
if (!used_usb_ports)
5236
2713
return -1;
5237
2714
5238
p = strchr(devname, '.');
5239
if (!p)
5240
return -1;
5241
bus_num = strtoul(devname, NULL, 0);
5242
addr = strtoul(p + 1, NULL, 0);
5243
2715
if (bus_num != 0)
5244
2716
return -1;
5245
2717
5262
2734
return 0;
5263
2735
}
5264
2736
2737
static int usb_device_del(const char *devname)
2738
{
2739
int bus_num, addr;
2740
const char *p;
2741
2742
if (strstart(devname, "host:", &p))
2743
return usb_host_device_close(p);
2744
2745
if (!used_usb_ports)
2746
return -1;
2747
2748
p = strchr(devname, '.');
2749
if (!p)
2750
return -1;
2751
bus_num = strtoul(devname, NULL, 0);
2752
addr = strtoul(p + 1, NULL, 0);
2753
2754
return usb_device_del_addr(bus_num, addr);
2755
}
2756
5265
2757
void do_usb_add(const char *devname)
5266
2758
{
5267
int ret;
5268
ret = usb_device_add(devname);
5269
if (ret < 0)
5270
term_printf("Could not add USB device '%s'\n", devname);
2759
usb_device_add(devname);
5271
2760
}
5272
2761
5273
2762
void do_usb_del(const char *devname)
5274
2763
{
5275
int ret;
5276
ret = usb_device_del(devname);
5277
if (ret < 0)
5278
term_printf("Could not remove USB device '%s'\n", devname);
2764
usb_device_del(devname);
5279
2765
}
5280
2766
5281
2767
void usb_info(void)
5355
2841
}
5356
2842
5357
2843
/***********************************************************/
2844
/* register display */
2845
2846
void register_displaystate(DisplayState *ds)
2847
{
2848
DisplayState **s;
2849
s = &display_state;
2850
while (*s != NULL)
2851
s = &(*s)->next;
2852
ds->next = NULL;
2853
*s = ds;
2854
}
2855
2856
DisplayState *get_displaystate(void)
2857
{
2858
return display_state;
2859
}
2860
5358
2861
/* dumb display */
5359
2862
5360
static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
5361
{
5362
}
5363
5364
static void dumb_resize(DisplayState *ds, int w, int h)
5365
{
5366
}
5367
5368
static void dumb_refresh(DisplayState *ds)
5369
{
5370
#if defined(CONFIG_SDL)
5371
vga_hw_update();
5372
#endif
5373
}
5374
5375
static void dumb_display_init(DisplayState *ds)
5376
{
5377
ds->data = NULL;
5378
ds->linesize = 0;
5379
ds->depth = 0;
5380
ds->dpy_update = dumb_update;
5381
ds->dpy_resize = dumb_resize;
5382
ds->dpy_refresh = dumb_refresh;
2863
static void dumb_display_init(void)
2864
{
2865
DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2866
ds->surface = qemu_create_displaysurface(640, 480, 32, 640 * 4);
2867
register_displaystate(ds);
5383
2868
}
5384
2869
5385
2870
/***********************************************************/
5429
2914
goto found;
5430
2915
}
5431
2916
ioh = qemu_mallocz(sizeof(IOHandlerRecord));
5432
if (!ioh)
5433
return -1;
5434
2917
ioh->next = first_io_handler;
5435
2918
first_io_handler = ioh;
5436
2919
found:
5452
2935
return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
5453
2936
}
5454
2937
2938
#ifdef _WIN32
5455
2939
/***********************************************************/
5456
2940
/* Polling handling */
5457
2941
5467
2951
{
5468
2952
PollingEntry **ppe, *pe;
5469
2953
pe = qemu_mallocz(sizeof(PollingEntry));
5470
if (!pe)
5471
return -1;
5472
2954
pe->func = func;
5473
2955
pe->opaque = opaque;
5474
2956
for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
5489
2971
}
5490
2972
}
5491
2973
5492
#ifdef _WIN32
5493
2974
/***********************************************************/
5494
2975
/* Wait objects support */
5495
2976
typedef struct WaitObjects {
5535
3016
#endif
5536
3017
5537
3018
/***********************************************************/
5538
/* savevm/loadvm support */
5539
5540
#define IO_BUF_SIZE 32768
5541
5542
struct QEMUFile {
5543
FILE *outfile;
5544
BlockDriverState *bs;
5545
int is_file;
5546
int is_writable;
5547
int64_t base_offset;
5548
int64_t buf_offset; /* start of buffer when writing, end of buffer
5549
when reading */
5550
int buf_index;
5551
int buf_size; /* 0 when writing */
5552
uint8_t buf[IO_BUF_SIZE];
5553
};
5554
5555
QEMUFile *qemu_fopen(const char *filename, const char *mode)
5556
{
5557
QEMUFile *f;
5558
5559
f = qemu_mallocz(sizeof(QEMUFile));
5560
if (!f)
5561
return NULL;
5562
if (!strcmp(mode, "wb")) {
5563
f->is_writable = 1;
5564
} else if (!strcmp(mode, "rb")) {
5565
f->is_writable = 0;
5566
} else {
5567
goto fail;
5568
}
5569
f->outfile = fopen(filename, mode);
5570
if (!f->outfile)
5571
goto fail;
5572
f->is_file = 1;
5573
return f;
5574
fail:
5575
if (f->outfile)
5576
fclose(f->outfile);
5577
qemu_free(f);
5578
return NULL;
5579
}
5580
5581
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5582
{
5583
QEMUFile *f;
5584
5585
f = qemu_mallocz(sizeof(QEMUFile));
5586
if (!f)
5587
return NULL;
5588
f->is_file = 0;
5589
f->bs = bs;
5590
f->is_writable = is_writable;
5591
f->base_offset = offset;
5592
return f;
5593
}
5594
5595
void qemu_fflush(QEMUFile *f)
5596
{
5597
if (!f->is_writable)
5598
return;
5599
if (f->buf_index > 0) {
5600
if (f->is_file) {
5601
fseek(f->outfile, f->buf_offset, SEEK_SET);
5602
fwrite(f->buf, 1, f->buf_index, f->outfile);
5603
} else {
5604
bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
5605
f->buf, f->buf_index);
5606
}
5607
f->buf_offset += f->buf_index;
5608
f->buf_index = 0;
5609
}
5610
}
5611
5612
static void qemu_fill_buffer(QEMUFile *f)
5613
{
5614
int len;
5615
5616
if (f->is_writable)
5617
return;
5618
if (f->is_file) {
5619
fseek(f->outfile, f->buf_offset, SEEK_SET);
5620
len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
5621
if (len < 0)
5622
len = 0;
5623
} else {
5624
len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
5625
f->buf, IO_BUF_SIZE);
5626
if (len < 0)
5627
len = 0;
5628
}
5629
f->buf_index = 0;
5630
f->buf_size = len;
5631
f->buf_offset += len;
5632
}
5633
5634
void qemu_fclose(QEMUFile *f)
5635
{
5636
if (f->is_writable)
5637
qemu_fflush(f);
5638
if (f->is_file) {
5639
fclose(f->outfile);
5640
}
5641
qemu_free(f);
5642
}
5643
5644
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
5645
{
5646
int l;
5647
while (size > 0) {
5648
l = IO_BUF_SIZE - f->buf_index;
5649
if (l > size)
5650
l = size;
5651
memcpy(f->buf + f->buf_index, buf, l);
5652
f->buf_index += l;
5653
buf += l;
5654
size -= l;
5655
if (f->buf_index >= IO_BUF_SIZE)
5656
qemu_fflush(f);
5657
}
5658
}
5659
5660
void qemu_put_byte(QEMUFile *f, int v)
5661
{
5662
f->buf[f->buf_index++] = v;
5663
if (f->buf_index >= IO_BUF_SIZE)
5664
qemu_fflush(f);
5665
}
5666
5667
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
5668
{
5669
int size, l;
5670
5671
size = size1;
5672
while (size > 0) {
5673
l = f->buf_size - f->buf_index;
5674
if (l == 0) {
5675
qemu_fill_buffer(f);
5676
l = f->buf_size - f->buf_index;
5677
if (l == 0)
5678
break;
5679
}
5680
if (l > size)
5681
l = size;
5682
memcpy(buf, f->buf + f->buf_index, l);
5683
f->buf_index += l;
5684
buf += l;
5685
size -= l;
5686
}
5687
return size1 - size;
5688
}
5689
5690
int qemu_get_byte(QEMUFile *f)
5691
{
5692
if (f->buf_index >= f->buf_size) {
5693
qemu_fill_buffer(f);
5694
if (f->buf_index >= f->buf_size)
5695
return 0;
5696
}
5697
return f->buf[f->buf_index++];
5698
}
5699
5700
int64_t qemu_ftell(QEMUFile *f)
5701
{
5702
return f->buf_offset - f->buf_size + f->buf_index;
5703
}
5704
5705
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
5706
{
5707
if (whence == SEEK_SET) {
5708
/* nothing to do */
5709
} else if (whence == SEEK_CUR) {
5710
pos += qemu_ftell(f);
5711
} else {
5712
/* SEEK_END not supported */
5713
return -1;
5714
}
5715
if (f->is_writable) {
5716
qemu_fflush(f);
5717
f->buf_offset = pos;
5718
} else {
5719
f->buf_offset = pos;
5720
f->buf_index = 0;
5721
f->buf_size = 0;
5722
}
5723
return pos;
5724
}
5725
5726
void qemu_put_be16(QEMUFile *f, unsigned int v)
5727
{
5728
qemu_put_byte(f, v >> 8);
5729
qemu_put_byte(f, v);
5730
}
5731
5732
void qemu_put_be32(QEMUFile *f, unsigned int v)
5733
{
5734
qemu_put_byte(f, v >> 24);
5735
qemu_put_byte(f, v >> 16);
5736
qemu_put_byte(f, v >> 8);
5737
qemu_put_byte(f, v);
5738
}
5739
5740
void qemu_put_be64(QEMUFile *f, uint64_t v)
5741
{
5742
qemu_put_be32(f, v >> 32);
5743
qemu_put_be32(f, v);
5744
}
5745
5746
unsigned int qemu_get_be16(QEMUFile *f)
5747
{
5748
unsigned int v;
5749
v = qemu_get_byte(f) << 8;
5750
v |= qemu_get_byte(f);
5751
return v;
5752
}
5753
5754
unsigned int qemu_get_be32(QEMUFile *f)
5755
{
5756
unsigned int v;
5757
v = qemu_get_byte(f) << 24;
5758
v |= qemu_get_byte(f) << 16;
5759
v |= qemu_get_byte(f) << 8;
5760
v |= qemu_get_byte(f);
5761
return v;
5762
}
5763
5764
uint64_t qemu_get_be64(QEMUFile *f)
5765
{
5766
uint64_t v;
5767
v = (uint64_t)qemu_get_be32(f) << 32;
5768
v |= qemu_get_be32(f);
5769
return v;
5770
}
5771
5772
typedef struct SaveStateEntry {
5773
char idstr[256];
5774
int instance_id;
5775
int version_id;
5776
SaveStateHandler *save_state;
5777
LoadStateHandler *load_state;
5778
void *opaque;
5779
struct SaveStateEntry *next;
5780
} SaveStateEntry;
5781
5782
static SaveStateEntry *first_se;
5783
5784
int register_savevm(const char *idstr,
5785
int instance_id,
5786
int version_id,
5787
SaveStateHandler *save_state,
5788
LoadStateHandler *load_state,
5789
void *opaque)
5790
{
5791
SaveStateEntry *se, **pse;
5792
5793
se = qemu_malloc(sizeof(SaveStateEntry));
5794
if (!se)
5795
return -1;
5796
pstrcpy(se->idstr, sizeof(se->idstr), idstr);
5797
se->instance_id = instance_id;
5798
se->version_id = version_id;
5799
se->save_state = save_state;
5800
se->load_state = load_state;
5801
se->opaque = opaque;
5802
se->next = NULL;
5803
5804
/* add at the end of list */
5805
pse = &first_se;
5806
while (*pse != NULL)
5807
pse = &(*pse)->next;
5808
*pse = se;
5809
return 0;
5810
}
5811
5812
#define QEMU_VM_FILE_MAGIC 0x5145564d
5813
#define QEMU_VM_FILE_VERSION 0x00000002
5814
5815
static int qemu_savevm_state(QEMUFile *f)
5816
{
5817
SaveStateEntry *se;
5818
int len, ret;
5819
int64_t cur_pos, len_pos, total_len_pos;
5820
5821
qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
5822
qemu_put_be32(f, QEMU_VM_FILE_VERSION);
5823
total_len_pos = qemu_ftell(f);
5824
qemu_put_be64(f, 0); /* total size */
5825
5826
for(se = first_se; se != NULL; se = se->next) {
5827
/* ID string */
5828
len = strlen(se->idstr);
5829
qemu_put_byte(f, len);
5830
qemu_put_buffer(f, (uint8_t *)se->idstr, len);
5831
5832
qemu_put_be32(f, se->instance_id);
5833
qemu_put_be32(f, se->version_id);
5834
5835
/* record size: filled later */
5836
len_pos = qemu_ftell(f);
5837
qemu_put_be32(f, 0);
5838
se->save_state(f, se->opaque);
5839
5840
/* fill record size */
5841
cur_pos = qemu_ftell(f);
5842
len = cur_pos - len_pos - 4;
5843
qemu_fseek(f, len_pos, SEEK_SET);
5844
qemu_put_be32(f, len);
5845
qemu_fseek(f, cur_pos, SEEK_SET);
5846
}
5847
cur_pos = qemu_ftell(f);
5848
qemu_fseek(f, total_len_pos, SEEK_SET);
5849
qemu_put_be64(f, cur_pos - total_len_pos - 8);
5850
qemu_fseek(f, cur_pos, SEEK_SET);
5851
5852
ret = 0;
5853
return ret;
5854
}
5855
5856
static SaveStateEntry *find_se(const char *idstr, int instance_id)
5857
{
5858
SaveStateEntry *se;
5859
5860
for(se = first_se; se != NULL; se = se->next) {
5861
if (!strcmp(se->idstr, idstr) &&
5862
instance_id == se->instance_id)
5863
return se;
5864
}
5865
return NULL;
5866
}
5867
5868
static int qemu_loadvm_state(QEMUFile *f)
5869
{
5870
SaveStateEntry *se;
5871
int len, ret, instance_id, record_len, version_id;
5872
int64_t total_len, end_pos, cur_pos;
5873
unsigned int v;
5874
char idstr[256];
5875
5876
v = qemu_get_be32(f);
5877
if (v != QEMU_VM_FILE_MAGIC)
5878
goto fail;
5879
v = qemu_get_be32(f);
5880
if (v != QEMU_VM_FILE_VERSION) {
5881
fail:
5882
ret = -1;
5883
goto the_end;
5884
}
5885
total_len = qemu_get_be64(f);
5886
end_pos = total_len + qemu_ftell(f);
5887
for(;;) {
5888
if (qemu_ftell(f) >= end_pos)
5889
break;
5890
len = qemu_get_byte(f);
5891
qemu_get_buffer(f, (uint8_t *)idstr, len);
5892
idstr[len] = '\0';
5893
instance_id = qemu_get_be32(f);
5894
version_id = qemu_get_be32(f);
5895
record_len = qemu_get_be32(f);
5896
#if 0
5897
printf("idstr=%s instance=0x%x version=%d len=%d\n",
5898
idstr, instance_id, version_id, record_len);
5899
#endif
5900
cur_pos = qemu_ftell(f);
5901
se = find_se(idstr, instance_id);
5902
if (!se) {
5903
fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
5904
instance_id, idstr);
5905
} else {
5906
ret = se->load_state(f, se->opaque, version_id);
5907
if (ret < 0) {
5908
fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
5909
instance_id, idstr);
5910
}
5911
}
5912
/* always seek to exact end of record */
5913
qemu_fseek(f, cur_pos + record_len, SEEK_SET);
5914
}
5915
ret = 0;
5916
the_end:
5917
return ret;
5918
}
5919
5920
/* device can contain snapshots */
5921
static int bdrv_can_snapshot(BlockDriverState *bs)
5922
{
5923
return (bs &&
5924
!bdrv_is_removable(bs) &&
5925
!bdrv_is_read_only(bs));
5926
}
5927
5928
/* device must be snapshots in order to have a reliable snapshot */
5929
static int bdrv_has_snapshot(BlockDriverState *bs)
5930
{
5931
return (bs &&
5932
!bdrv_is_removable(bs) &&
5933
!bdrv_is_read_only(bs));
5934
}
5935
5936
static BlockDriverState *get_bs_snapshots(void)
5937
{
5938
BlockDriverState *bs;
5939
int i;
5940
5941
if (bs_snapshots)
5942
return bs_snapshots;
5943
for(i = 0; i <= nb_drives; i++) {
5944
bs = drives_table[i].bdrv;
5945
if (bdrv_can_snapshot(bs))
5946
goto ok;
5947
}
5948
return NULL;
5949
ok:
5950
bs_snapshots = bs;
5951
return bs;
5952
}
5953
5954
static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
5955
const char *name)
5956
{
5957
QEMUSnapshotInfo *sn_tab, *sn;
5958
int nb_sns, i, ret;
5959
5960
ret = -ENOENT;
5961
nb_sns = bdrv_snapshot_list(bs, &sn_tab);
5962
if (nb_sns < 0)
5963
return ret;
5964
for(i = 0; i < nb_sns; i++) {
5965
sn = &sn_tab[i];
5966
if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
5967
*sn_info = *sn;
5968
ret = 0;
5969
break;
5970
}
5971
}
5972
qemu_free(sn_tab);
5973
return ret;
5974
}
5975
5976
void do_savevm(const char *name)
5977
{
5978
BlockDriverState *bs, *bs1;
5979
QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
5980
int must_delete, ret, i;
5981
BlockDriverInfo bdi1, *bdi = &bdi1;
5982
QEMUFile *f;
5983
int saved_vm_running;
5984
#ifdef _WIN32
5985
struct _timeb tb;
5986
#else
5987
struct timeval tv;
5988
#endif
5989
5990
bs = get_bs_snapshots();
5991
if (!bs) {
5992
term_printf("No block device can accept snapshots\n");
5993
return;
5994
}
5995
5996
/* ??? Should this occur after vm_stop? */
5997
qemu_aio_flush();
5998
5999
saved_vm_running = vm_running;
6000
vm_stop(0);
6001
6002
must_delete = 0;
6003
if (name) {
6004
ret = bdrv_snapshot_find(bs, old_sn, name);
6005
if (ret >= 0) {
6006
must_delete = 1;
6007
}
6008
}
6009
memset(sn, 0, sizeof(*sn));
6010
if (must_delete) {
6011
pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6012
pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6013
} else {
6014
if (name)
6015
pstrcpy(sn->name, sizeof(sn->name), name);
6016
}
6017
6018
/* fill auxiliary fields */
6019
#ifdef _WIN32
6020
_ftime(&tb);
6021
sn->date_sec = tb.time;
6022
sn->date_nsec = tb.millitm * 1000000;
6023
#else
6024
gettimeofday(&tv, NULL);
6025
sn->date_sec = tv.tv_sec;
6026
sn->date_nsec = tv.tv_usec * 1000;
6027
#endif
6028
sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6029
6030
if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6031
term_printf("Device %s does not support VM state snapshots\n",
6032
bdrv_get_device_name(bs));
6033
goto the_end;
6034
}
6035
6036
/* save the VM state */
6037
f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6038
if (!f) {
6039
term_printf("Could not open VM state file\n");
6040
goto the_end;
6041
}
6042
ret = qemu_savevm_state(f);
6043
sn->vm_state_size = qemu_ftell(f);
6044
qemu_fclose(f);
6045
if (ret < 0) {
6046
term_printf("Error %d while writing VM\n", ret);
6047
goto the_end;
6048
}
6049
6050
/* create the snapshots */
6051
6052
for(i = 0; i < nb_drives; i++) {
6053
bs1 = drives_table[i].bdrv;
6054
if (bdrv_has_snapshot(bs1)) {
6055
if (must_delete) {
6056
ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6057
if (ret < 0) {
6058
term_printf("Error while deleting snapshot on '%s'\n",
6059
bdrv_get_device_name(bs1));
6060
}
6061
}
6062
ret = bdrv_snapshot_create(bs1, sn);
6063
if (ret < 0) {
6064
term_printf("Error while creating snapshot on '%s'\n",
6065
bdrv_get_device_name(bs1));
6066
}
6067
}
6068
}
6069
6070
the_end:
6071
if (saved_vm_running)
6072
vm_start();
6073
}
6074
6075
void do_loadvm(const char *name)
6076
{
6077
BlockDriverState *bs, *bs1;
6078
BlockDriverInfo bdi1, *bdi = &bdi1;
6079
QEMUFile *f;
6080
int i, ret;
6081
int saved_vm_running;
6082
6083
bs = get_bs_snapshots();
6084
if (!bs) {
6085
term_printf("No block device supports snapshots\n");
6086
return;
6087
}
6088
6089
/* Flush all IO requests so they don't interfere with the new state. */
6090
qemu_aio_flush();
6091
6092
saved_vm_running = vm_running;
6093
vm_stop(0);
6094
6095
for(i = 0; i <= nb_drives; i++) {
6096
bs1 = drives_table[i].bdrv;
6097
if (bdrv_has_snapshot(bs1)) {
6098
ret = bdrv_snapshot_goto(bs1, name);
6099
if (ret < 0) {
6100
if (bs != bs1)
6101
term_printf("Warning: ");
6102
switch(ret) {
6103
case -ENOTSUP:
6104
term_printf("Snapshots not supported on device '%s'\n",
6105
bdrv_get_device_name(bs1));
6106
break;
6107
case -ENOENT:
6108
term_printf("Could not find snapshot '%s' on device '%s'\n",
6109
name, bdrv_get_device_name(bs1));
6110
break;
6111
default:
6112
term_printf("Error %d while activating snapshot on '%s'\n",
6113
ret, bdrv_get_device_name(bs1));
6114
break;
6115
}
6116
/* fatal on snapshot block device */
6117
if (bs == bs1)
6118
goto the_end;
6119
}
6120
}
6121
}
6122
6123
if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6124
term_printf("Device %s does not support VM state snapshots\n",
6125
bdrv_get_device_name(bs));
6126
return;
6127
}
6128
6129
/* restore the VM state */
6130
f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6131
if (!f) {
6132
term_printf("Could not open VM state file\n");
6133
goto the_end;
6134
}
6135
ret = qemu_loadvm_state(f);
6136
qemu_fclose(f);
6137
if (ret < 0) {
6138
term_printf("Error %d while loading VM state\n", ret);
6139
}
6140
the_end:
6141
if (saved_vm_running)
6142
vm_start();
6143
}
6144
6145
void do_delvm(const char *name)
6146
{
6147
BlockDriverState *bs, *bs1;
6148
int i, ret;
6149
6150
bs = get_bs_snapshots();
6151
if (!bs) {
6152
term_printf("No block device supports snapshots\n");
6153
return;
6154
}
6155
6156
for(i = 0; i <= nb_drives; i++) {
6157
bs1 = drives_table[i].bdrv;
6158
if (bdrv_has_snapshot(bs1)) {
6159
ret = bdrv_snapshot_delete(bs1, name);
6160
if (ret < 0) {
6161
if (ret == -ENOTSUP)
6162
term_printf("Snapshots not supported on device '%s'\n",
6163
bdrv_get_device_name(bs1));
6164
else
6165
term_printf("Error %d while deleting snapshot on '%s'\n",
6166
ret, bdrv_get_device_name(bs1));
6167
}
6168
}
6169
}
6170
}
6171
6172
void do_info_snapshots(void)
6173
{
6174
BlockDriverState *bs, *bs1;
6175
QEMUSnapshotInfo *sn_tab, *sn;
6176
int nb_sns, i;
6177
char buf[256];
6178
6179
bs = get_bs_snapshots();
6180
if (!bs) {
6181
term_printf("No available block device supports snapshots\n");
6182
return;
6183
}
6184
term_printf("Snapshot devices:");
6185
for(i = 0; i <= nb_drives; i++) {
6186
bs1 = drives_table[i].bdrv;
6187
if (bdrv_has_snapshot(bs1)) {
6188
if (bs == bs1)
6189
term_printf(" %s", bdrv_get_device_name(bs1));
6190
}
6191
}
6192
term_printf("\n");
6193
6194
nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6195
if (nb_sns < 0) {
6196
term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
6197
return;
6198
}
6199
term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
6200
term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
6201
for(i = 0; i < nb_sns; i++) {
6202
sn = &sn_tab[i];
6203
term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
6204
}
6205
qemu_free(sn_tab);
6206
}
6207
6208
/***********************************************************/
6209
/* cpu save/restore */
6210
6211
#if defined(TARGET_I386)
6212
6213
static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
6214
{
6215
qemu_put_be32(f, dt->selector);
6216
qemu_put_betl(f, dt->base);
6217
qemu_put_be32(f, dt->limit);
6218
qemu_put_be32(f, dt->flags);
6219
}
6220
6221
static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
6222
{
6223
dt->selector = qemu_get_be32(f);
6224
dt->base = qemu_get_betl(f);
6225
dt->limit = qemu_get_be32(f);
6226
dt->flags = qemu_get_be32(f);
6227
}
6228
6229
void cpu_save(QEMUFile *f, void *opaque)
6230
{
6231
CPUState *env = opaque;
6232
uint16_t fptag, fpus, fpuc, fpregs_format;
6233
uint32_t hflags;
6234
int i;
6235
6236
for(i = 0; i < CPU_NB_REGS; i++)
6237
qemu_put_betls(f, &env->regs[i]);
6238
qemu_put_betls(f, &env->eip);
6239
qemu_put_betls(f, &env->eflags);
6240
hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
6241
qemu_put_be32s(f, &hflags);
6242
6243
/* FPU */
6244
fpuc = env->fpuc;
6245
fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
6246
fptag = 0;
6247
for(i = 0; i < 8; i++) {
6248
fptag |= ((!env->fptags[i]) << i);
6249
}
6250
6251
qemu_put_be16s(f, &fpuc);
6252
qemu_put_be16s(f, &fpus);
6253
qemu_put_be16s(f, &fptag);
6254
6255
#ifdef USE_X86LDOUBLE
6256
fpregs_format = 0;
6257
#else
6258
fpregs_format = 1;
6259
#endif
6260
qemu_put_be16s(f, &fpregs_format);
6261
6262
for(i = 0; i < 8; i++) {
6263
#ifdef USE_X86LDOUBLE
6264
{
6265
uint64_t mant;
6266
uint16_t exp;
6267
/* we save the real CPU data (in case of MMX usage only 'mant'
6268
contains the MMX register */
6269
cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
6270
qemu_put_be64(f, mant);
6271
qemu_put_be16(f, exp);
6272
}
6273
#else
6274
/* if we use doubles for float emulation, we save the doubles to
6275
avoid losing information in case of MMX usage. It can give
6276
problems if the image is restored on a CPU where long
6277
doubles are used instead. */
6278
qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
6279
#endif
6280
}
6281
6282
for(i = 0; i < 6; i++)
6283
cpu_put_seg(f, &env->segs[i]);
6284
cpu_put_seg(f, &env->ldt);
6285
cpu_put_seg(f, &env->tr);
6286
cpu_put_seg(f, &env->gdt);
6287
cpu_put_seg(f, &env->idt);
6288
6289
qemu_put_be32s(f, &env->sysenter_cs);
6290
qemu_put_be32s(f, &env->sysenter_esp);
6291
qemu_put_be32s(f, &env->sysenter_eip);
6292
6293
qemu_put_betls(f, &env->cr[0]);
6294
qemu_put_betls(f, &env->cr[2]);
6295
qemu_put_betls(f, &env->cr[3]);
6296
qemu_put_betls(f, &env->cr[4]);
6297
6298
for(i = 0; i < 8; i++)
6299
qemu_put_betls(f, &env->dr[i]);
6300
6301
/* MMU */
6302
qemu_put_be32s(f, &env->a20_mask);
6303
6304
/* XMM */
6305
qemu_put_be32s(f, &env->mxcsr);
6306
for(i = 0; i < CPU_NB_REGS; i++) {
6307
qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6308
qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6309
}
6310
6311
#ifdef TARGET_X86_64
6312
qemu_put_be64s(f, &env->efer);
6313
qemu_put_be64s(f, &env->star);
6314
qemu_put_be64s(f, &env->lstar);
6315
qemu_put_be64s(f, &env->cstar);
6316
qemu_put_be64s(f, &env->fmask);
6317
qemu_put_be64s(f, &env->kernelgsbase);
6318
#endif
6319
qemu_put_be32s(f, &env->smbase);
6320
}
6321
6322
#ifdef USE_X86LDOUBLE
6323
/* XXX: add that in a FPU generic layer */
6324
union x86_longdouble {
6325
uint64_t mant;
6326
uint16_t exp;
6327
};
6328
6329
#define MANTD1(fp) (fp & ((1LL << 52) - 1))
6330
#define EXPBIAS1 1023
6331
#define EXPD1(fp) ((fp >> 52) & 0x7FF)
6332
#define SIGND1(fp) ((fp >> 32) & 0x80000000)
6333
6334
static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
6335
{
6336
int e;
6337
/* mantissa */
6338
p->mant = (MANTD1(temp) << 11) | (1LL << 63);
6339
/* exponent + sign */
6340
e = EXPD1(temp) - EXPBIAS1 + 16383;
6341
e |= SIGND1(temp) >> 16;
6342
p->exp = e;
6343
}
6344
#endif
6345
6346
int cpu_load(QEMUFile *f, void *opaque, int version_id)
6347
{
6348
CPUState *env = opaque;
6349
int i, guess_mmx;
6350
uint32_t hflags;
6351
uint16_t fpus, fpuc, fptag, fpregs_format;
6352
6353
if (version_id != 3 && version_id != 4)
6354
return -EINVAL;
6355
for(i = 0; i < CPU_NB_REGS; i++)
6356
qemu_get_betls(f, &env->regs[i]);
6357
qemu_get_betls(f, &env->eip);
6358
qemu_get_betls(f, &env->eflags);
6359
qemu_get_be32s(f, &hflags);
6360
6361
qemu_get_be16s(f, &fpuc);
6362
qemu_get_be16s(f, &fpus);
6363
qemu_get_be16s(f, &fptag);
6364
qemu_get_be16s(f, &fpregs_format);
6365
6366
/* NOTE: we cannot always restore the FPU state if the image come
6367
from a host with a different 'USE_X86LDOUBLE' define. We guess
6368
if we are in an MMX state to restore correctly in that case. */
6369
guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
6370
for(i = 0; i < 8; i++) {
6371
uint64_t mant;
6372
uint16_t exp;
6373
6374
switch(fpregs_format) {
6375
case 0:
6376
mant = qemu_get_be64(f);
6377
exp = qemu_get_be16(f);
6378
#ifdef USE_X86LDOUBLE
6379
env->fpregs[i].d = cpu_set_fp80(mant, exp);
6380
#else
6381
/* difficult case */
6382
if (guess_mmx)
6383
env->fpregs[i].mmx.MMX_Q(0) = mant;
6384
else
6385
env->fpregs[i].d = cpu_set_fp80(mant, exp);
6386
#endif
6387
break;
6388
case 1:
6389
mant = qemu_get_be64(f);
6390
#ifdef USE_X86LDOUBLE
6391
{
6392
union x86_longdouble *p;
6393
/* difficult case */
6394
p = (void *)&env->fpregs[i];
6395
if (guess_mmx) {
6396
p->mant = mant;
6397
p->exp = 0xffff;
6398
} else {
6399
fp64_to_fp80(p, mant);
6400
}
6401
}
6402
#else
6403
env->fpregs[i].mmx.MMX_Q(0) = mant;
6404
#endif
6405
break;
6406
default:
6407
return -EINVAL;
6408
}
6409
}
6410
6411
env->fpuc = fpuc;
6412
/* XXX: restore FPU round state */
6413
env->fpstt = (fpus >> 11) & 7;
6414
env->fpus = fpus & ~0x3800;
6415
fptag ^= 0xff;
6416
for(i = 0; i < 8; i++) {
6417
env->fptags[i] = (fptag >> i) & 1;
6418
}
6419
6420
for(i = 0; i < 6; i++)
6421
cpu_get_seg(f, &env->segs[i]);
6422
cpu_get_seg(f, &env->ldt);
6423
cpu_get_seg(f, &env->tr);
6424
cpu_get_seg(f, &env->gdt);
6425
cpu_get_seg(f, &env->idt);
6426
6427
qemu_get_be32s(f, &env->sysenter_cs);
6428
qemu_get_be32s(f, &env->sysenter_esp);
6429
qemu_get_be32s(f, &env->sysenter_eip);
6430
6431
qemu_get_betls(f, &env->cr[0]);
6432
qemu_get_betls(f, &env->cr[2]);
6433
qemu_get_betls(f, &env->cr[3]);
6434
qemu_get_betls(f, &env->cr[4]);
6435
6436
for(i = 0; i < 8; i++)
6437
qemu_get_betls(f, &env->dr[i]);
6438
6439
/* MMU */
6440
qemu_get_be32s(f, &env->a20_mask);
6441
6442
qemu_get_be32s(f, &env->mxcsr);
6443
for(i = 0; i < CPU_NB_REGS; i++) {
6444
qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6445
qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6446
}
6447
6448
#ifdef TARGET_X86_64
6449
qemu_get_be64s(f, &env->efer);
6450
qemu_get_be64s(f, &env->star);
6451
qemu_get_be64s(f, &env->lstar);
6452
qemu_get_be64s(f, &env->cstar);
6453
qemu_get_be64s(f, &env->fmask);
6454
qemu_get_be64s(f, &env->kernelgsbase);
6455
#endif
6456
if (version_id >= 4)
6457
qemu_get_be32s(f, &env->smbase);
6458
6459
/* XXX: compute hflags from scratch, except for CPL and IIF */
6460
env->hflags = hflags;
6461
tlb_flush(env, 1);
6462
return 0;
6463
}
6464
6465
#elif defined(TARGET_PPC)
6466
void cpu_save(QEMUFile *f, void *opaque)
6467
{
6468
}
6469
6470
int cpu_load(QEMUFile *f, void *opaque, int version_id)
6471
{
6472
return 0;
6473
}
6474
6475
#elif defined(TARGET_MIPS)
6476
void cpu_save(QEMUFile *f, void *opaque)
6477
{
6478
}
6479
6480
int cpu_load(QEMUFile *f, void *opaque, int version_id)
6481
{
6482
return 0;
6483
}
6484
6485
#elif defined(TARGET_SPARC)
6486
void cpu_save(QEMUFile *f, void *opaque)
6487
{
6488
CPUState *env = opaque;
6489
int i;
6490
uint32_t tmp;
6491
6492
for(i = 0; i < 8; i++)
6493
qemu_put_betls(f, &env->gregs[i]);
6494
for(i = 0; i < NWINDOWS * 16; i++)
6495
qemu_put_betls(f, &env->regbase[i]);
6496
6497
/* FPU */
6498
for(i = 0; i < TARGET_FPREGS; i++) {
6499
union {
6500
float32 f;
6501
uint32_t i;
6502
} u;
6503
u.f = env->fpr[i];
6504
qemu_put_be32(f, u.i);
6505
}
6506
6507
qemu_put_betls(f, &env->pc);
6508
qemu_put_betls(f, &env->npc);
6509
qemu_put_betls(f, &env->y);
6510
tmp = GET_PSR(env);
6511
qemu_put_be32(f, tmp);
6512
qemu_put_betls(f, &env->fsr);
6513
qemu_put_betls(f, &env->tbr);
6514
#ifndef TARGET_SPARC64
6515
qemu_put_be32s(f, &env->wim);
6516
/* MMU */
6517
for(i = 0; i < 16; i++)
6518
qemu_put_be32s(f, &env->mmuregs[i]);
6519
#endif
6520
}
6521
6522
int cpu_load(QEMUFile *f, void *opaque, int version_id)
6523
{
6524
CPUState *env = opaque;
6525
int i;
6526
uint32_t tmp;
6527
6528
for(i = 0; i < 8; i++)
6529
qemu_get_betls(f, &env->gregs[i]);
6530
for(i = 0; i < NWINDOWS * 16; i++)
6531
qemu_get_betls(f, &env->regbase[i]);
6532
6533
/* FPU */
6534
for(i = 0; i < TARGET_FPREGS; i++) {
6535
union {
6536
float32 f;
6537
uint32_t i;
6538
} u;
6539
u.i = qemu_get_be32(f);
6540
env->fpr[i] = u.f;
6541
}
6542
6543
qemu_get_betls(f, &env->pc);
6544
qemu_get_betls(f, &env->npc);
6545
qemu_get_betls(f, &env->y);
6546
tmp = qemu_get_be32(f);
6547
env->cwp = 0; /* needed to ensure that the wrapping registers are
6548
correctly updated */
6549
PUT_PSR(env, tmp);
6550
qemu_get_betls(f, &env->fsr);
6551
qemu_get_betls(f, &env->tbr);
6552
#ifndef TARGET_SPARC64
6553
qemu_get_be32s(f, &env->wim);
6554
/* MMU */
6555
for(i = 0; i < 16; i++)
6556
qemu_get_be32s(f, &env->mmuregs[i]);
6557
#endif
6558
tlb_flush(env, 1);
6559
return 0;
6560
}
6561
6562
#elif defined(TARGET_ARM)
6563
6564
void cpu_save(QEMUFile *f, void *opaque)
6565
{
6566
int i;
6567
CPUARMState *env = (CPUARMState *)opaque;
6568
6569
for (i = 0; i < 16; i++) {
6570
qemu_put_be32(f, env->regs[i]);
6571
}
6572
qemu_put_be32(f, cpsr_read(env));
6573
qemu_put_be32(f, env->spsr);
6574
for (i = 0; i < 6; i++) {
6575
qemu_put_be32(f, env->banked_spsr[i]);
6576
qemu_put_be32(f, env->banked_r13[i]);
6577
qemu_put_be32(f, env->banked_r14[i]);
6578
}
6579
for (i = 0; i < 5; i++) {
6580
qemu_put_be32(f, env->usr_regs[i]);
6581
qemu_put_be32(f, env->fiq_regs[i]);
6582
}
6583
qemu_put_be32(f, env->cp15.c0_cpuid);
6584
qemu_put_be32(f, env->cp15.c0_cachetype);
6585
qemu_put_be32(f, env->cp15.c1_sys);
6586
qemu_put_be32(f, env->cp15.c1_coproc);
6587
qemu_put_be32(f, env->cp15.c1_xscaleauxcr);
6588
qemu_put_be32(f, env->cp15.c2_base0);
6589
qemu_put_be32(f, env->cp15.c2_base1);
6590
qemu_put_be32(f, env->cp15.c2_mask);
6591
qemu_put_be32(f, env->cp15.c2_data);
6592
qemu_put_be32(f, env->cp15.c2_insn);
6593
qemu_put_be32(f, env->cp15.c3);
6594
qemu_put_be32(f, env->cp15.c5_insn);
6595
qemu_put_be32(f, env->cp15.c5_data);
6596
for (i = 0; i < 8; i++) {
6597
qemu_put_be32(f, env->cp15.c6_region[i]);
6598
}
6599
qemu_put_be32(f, env->cp15.c6_insn);
6600
qemu_put_be32(f, env->cp15.c6_data);
6601
qemu_put_be32(f, env->cp15.c9_insn);
6602
qemu_put_be32(f, env->cp15.c9_data);
6603
qemu_put_be32(f, env->cp15.c13_fcse);
6604
qemu_put_be32(f, env->cp15.c13_context);
6605
qemu_put_be32(f, env->cp15.c13_tls1);
6606
qemu_put_be32(f, env->cp15.c13_tls2);
6607
qemu_put_be32(f, env->cp15.c13_tls3);
6608
qemu_put_be32(f, env->cp15.c15_cpar);
6609
6610
qemu_put_be32(f, env->features);
6611
6612
if (arm_feature(env, ARM_FEATURE_VFP)) {
6613
for (i = 0; i < 16; i++) {
6614
CPU_DoubleU u;
6615
u.d = env->vfp.regs[i];
6616
qemu_put_be32(f, u.l.upper);
6617
qemu_put_be32(f, u.l.lower);
6618
}
6619
for (i = 0; i < 16; i++) {
6620
qemu_put_be32(f, env->vfp.xregs[i]);
6621
}
6622
6623
/* TODO: Should use proper FPSCR access functions. */
6624
qemu_put_be32(f, env->vfp.vec_len);
6625
qemu_put_be32(f, env->vfp.vec_stride);
6626
6627
if (arm_feature(env, ARM_FEATURE_VFP3)) {
6628
for (i = 16; i < 32; i++) {
6629
CPU_DoubleU u;
6630
u.d = env->vfp.regs[i];
6631
qemu_put_be32(f, u.l.upper);
6632
qemu_put_be32(f, u.l.lower);
6633
}
6634
}
6635
}
6636
6637
if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6638
for (i = 0; i < 16; i++) {
6639
qemu_put_be64(f, env->iwmmxt.regs[i]);
6640
}
6641
for (i = 0; i < 16; i++) {
6642
qemu_put_be32(f, env->iwmmxt.cregs[i]);
6643
}
6644
}
6645
6646
if (arm_feature(env, ARM_FEATURE_M)) {
6647
qemu_put_be32(f, env->v7m.other_sp);
6648
qemu_put_be32(f, env->v7m.vecbase);
6649
qemu_put_be32(f, env->v7m.basepri);
6650
qemu_put_be32(f, env->v7m.control);
6651
qemu_put_be32(f, env->v7m.current_sp);
6652
qemu_put_be32(f, env->v7m.exception);
6653
}
6654
}
6655
6656
int cpu_load(QEMUFile *f, void *opaque, int version_id)
6657
{
6658
CPUARMState *env = (CPUARMState *)opaque;
6659
int i;
6660
6661
if (version_id != ARM_CPU_SAVE_VERSION)
6662
return -EINVAL;
6663
6664
for (i = 0; i < 16; i++) {
6665
env->regs[i] = qemu_get_be32(f);
6666
}
6667
cpsr_write(env, qemu_get_be32(f), 0xffffffff);
6668
env->spsr = qemu_get_be32(f);
6669
for (i = 0; i < 6; i++) {
6670
env->banked_spsr[i] = qemu_get_be32(f);
6671
env->banked_r13[i] = qemu_get_be32(f);
6672
env->banked_r14[i] = qemu_get_be32(f);
6673
}
6674
for (i = 0; i < 5; i++) {
6675
env->usr_regs[i] = qemu_get_be32(f);
6676
env->fiq_regs[i] = qemu_get_be32(f);
6677
}
6678
env->cp15.c0_cpuid = qemu_get_be32(f);
6679
env->cp15.c0_cachetype = qemu_get_be32(f);
6680
env->cp15.c1_sys = qemu_get_be32(f);
6681
env->cp15.c1_coproc = qemu_get_be32(f);
6682
env->cp15.c1_xscaleauxcr = qemu_get_be32(f);
6683
env->cp15.c2_base0 = qemu_get_be32(f);
6684
env->cp15.c2_base1 = qemu_get_be32(f);
6685
env->cp15.c2_mask = qemu_get_be32(f);
6686
env->cp15.c2_data = qemu_get_be32(f);
6687
env->cp15.c2_insn = qemu_get_be32(f);
6688
env->cp15.c3 = qemu_get_be32(f);
6689
env->cp15.c5_insn = qemu_get_be32(f);
6690
env->cp15.c5_data = qemu_get_be32(f);
6691
for (i = 0; i < 8; i++) {
6692
env->cp15.c6_region[i] = qemu_get_be32(f);
6693
}
6694
env->cp15.c6_insn = qemu_get_be32(f);
6695
env->cp15.c6_data = qemu_get_be32(f);
6696
env->cp15.c9_insn = qemu_get_be32(f);
6697
env->cp15.c9_data = qemu_get_be32(f);
6698
env->cp15.c13_fcse = qemu_get_be32(f);
6699
env->cp15.c13_context = qemu_get_be32(f);
6700
env->cp15.c13_tls1 = qemu_get_be32(f);
6701
env->cp15.c13_tls2 = qemu_get_be32(f);
6702
env->cp15.c13_tls3 = qemu_get_be32(f);
6703
env->cp15.c15_cpar = qemu_get_be32(f);
6704
6705
env->features = qemu_get_be32(f);
6706
6707
if (arm_feature(env, ARM_FEATURE_VFP)) {
6708
for (i = 0; i < 16; i++) {
6709
CPU_DoubleU u;
6710
u.l.upper = qemu_get_be32(f);
6711
u.l.lower = qemu_get_be32(f);
6712
env->vfp.regs[i] = u.d;
6713
}
6714
for (i = 0; i < 16; i++) {
6715
env->vfp.xregs[i] = qemu_get_be32(f);
6716
}
6717
6718
/* TODO: Should use proper FPSCR access functions. */
6719
env->vfp.vec_len = qemu_get_be32(f);
6720
env->vfp.vec_stride = qemu_get_be32(f);
6721
6722
if (arm_feature(env, ARM_FEATURE_VFP3)) {
6723
for (i = 0; i < 16; i++) {
6724
CPU_DoubleU u;
6725
u.l.upper = qemu_get_be32(f);
6726
u.l.lower = qemu_get_be32(f);
6727
env->vfp.regs[i] = u.d;
6728
}
6729
}
6730
}
6731
6732
if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6733
for (i = 0; i < 16; i++) {
6734
env->iwmmxt.regs[i] = qemu_get_be64(f);
6735
}
6736
for (i = 0; i < 16; i++) {
6737
env->iwmmxt.cregs[i] = qemu_get_be32(f);
6738
}
6739
}
6740
6741
if (arm_feature(env, ARM_FEATURE_M)) {
6742
env->v7m.other_sp = qemu_get_be32(f);
6743
env->v7m.vecbase = qemu_get_be32(f);
6744
env->v7m.basepri = qemu_get_be32(f);
6745
env->v7m.control = qemu_get_be32(f);
6746
env->v7m.current_sp = qemu_get_be32(f);
6747
env->v7m.exception = qemu_get_be32(f);
6748
}
6749
6750
return 0;
6751
}
6752
6753
#else
6754
6755
//#warning No CPU save/restore functions
6756
6757
#endif
6758
6759
/***********************************************************/
6760
3019
/* ram save/restore */
6761
3020
6762
3021
static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
6776
3035
default:
6777
3036
return -EINVAL;
6778
3037
}
3038
3039
if (qemu_file_has_error(f))
3040
return -EIO;
3041
6779
3042
return 0;
6780
3043
}
6781
3044
6782
3045
static int ram_load_v1(QEMUFile *f, void *opaque)
6783
3046
{
6784
int i, ret;
3047
int ret;
3048
ram_addr_t i;
6785
3049
6786
3050
if (qemu_get_be32(f) != phys_ram_size)
6787
3051
return -EINVAL;
6797
3061
#define IOBUF_SIZE 4096
6798
3062
#define RAM_CBLOCK_MAGIC 0xfabe
6799
3063
6800
typedef struct RamCompressState {
6801
z_stream zstream;
6802
QEMUFile *f;
6803
uint8_t buf[IOBUF_SIZE];
6804
} RamCompressState;
6805
6806
static int ram_compress_open(RamCompressState *s, QEMUFile *f)
6807
{
6808
int ret;
6809
memset(s, 0, sizeof(*s));
6810
s->f = f;
6811
ret = deflateInit2(&s->zstream, 1,
6812
Z_DEFLATED, 15,
6813
9, Z_DEFAULT_STRATEGY);
6814
if (ret != Z_OK)
6815
return -1;
6816
s->zstream.avail_out = IOBUF_SIZE;
6817
s->zstream.next_out = s->buf;
6818
return 0;
6819
}
6820
6821
static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
6822
{
6823
qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
6824
qemu_put_be16(s->f, len);
6825
qemu_put_buffer(s->f, buf, len);
6826
}
6827
6828
static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
6829
{
6830
int ret;
6831
6832
s->zstream.avail_in = len;
6833
s->zstream.next_in = (uint8_t *)buf;
6834
while (s->zstream.avail_in > 0) {
6835
ret = deflate(&s->zstream, Z_NO_FLUSH);
6836
if (ret != Z_OK)
6837
return -1;
6838
if (s->zstream.avail_out == 0) {
6839
ram_put_cblock(s, s->buf, IOBUF_SIZE);
6840
s->zstream.avail_out = IOBUF_SIZE;
6841
s->zstream.next_out = s->buf;
6842
}
6843
}
6844
return 0;
6845
}
6846
6847
static void ram_compress_close(RamCompressState *s)
6848
{
6849
int len, ret;
6850
6851
/* compress last bytes */
6852
for(;;) {
6853
ret = deflate(&s->zstream, Z_FINISH);
6854
if (ret == Z_OK || ret == Z_STREAM_END) {
6855
len = IOBUF_SIZE - s->zstream.avail_out;
6856
if (len > 0) {
6857
ram_put_cblock(s, s->buf, len);
6858
}
6859
s->zstream.avail_out = IOBUF_SIZE;
6860
s->zstream.next_out = s->buf;
6861
if (ret == Z_STREAM_END)
6862
break;
6863
} else {
6864
goto fail;
6865
}
6866
}
6867
fail:
6868
deflateEnd(&s->zstream);
6869
}
6870
6871
3064
typedef struct RamDecompressState {
6872
3065
z_stream zstream;
6873
3066
QEMUFile *f;
6915
3108
inflateEnd(&s->zstream);
6916
3109
}
6917
3110
6918
static void ram_save(QEMUFile *f, void *opaque)
3111
#define RAM_SAVE_FLAG_FULL 0x01
3112
#define RAM_SAVE_FLAG_COMPRESS 0x02
3113
#define RAM_SAVE_FLAG_MEM_SIZE 0x04
3114
#define RAM_SAVE_FLAG_PAGE 0x08
3115
#define RAM_SAVE_FLAG_EOS 0x10
3116
3117
static int is_dup_page(uint8_t *page, uint8_t ch)
6919
3118
{
3119
uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3120
uint32_t *array = (uint32_t *)page;
6920
3121
int i;
6921
RamCompressState s1, *s = &s1;
6922
uint8_t buf[10];
6923
6924
qemu_put_be32(f, phys_ram_size);
6925
if (ram_compress_open(s, f) < 0)
6926
return;
6927
for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6928
#if 0
6929
if (tight_savevm_enabled) {
6930
int64_t sector_num;
6931
int j;
6932
6933
/* find if the memory block is available on a virtual
6934
block device */
6935
sector_num = -1;
6936
for(j = 0; j < nb_drives; j++) {
6937
sector_num = bdrv_hash_find(drives_table[j].bdrv,
6938
phys_ram_base + i,
6939
BDRV_HASH_BLOCK_SIZE);
6940
if (sector_num >= 0)
6941
break;
3122
3123
for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3124
if (array[i] != val)
3125
return 0;
3126
}
3127
3128
return 1;
3129
}
3130
3131
static int ram_save_block(QEMUFile *f)
3132
{
3133
static ram_addr_t current_addr = 0;
3134
ram_addr_t saved_addr = current_addr;
3135
ram_addr_t addr = 0;
3136
int found = 0;
3137
3138
while (addr < phys_ram_size) {
3139
if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3140
uint8_t ch;
3141
3142
cpu_physical_memory_reset_dirty(current_addr,
3143
current_addr + TARGET_PAGE_SIZE,
3144
MIGRATION_DIRTY_FLAG);
3145
3146
ch = *(phys_ram_base + current_addr);
3147
3148
if (is_dup_page(phys_ram_base + current_addr, ch)) {
3149
qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3150
qemu_put_byte(f, ch);
3151
} else {
3152
qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3153
qemu_put_buffer(f, phys_ram_base + current_addr, TARGET_PAGE_SIZE);
6942
3154
}
6943
if (j == nb_drives)
6944
goto normal_compress;
6945
buf[0] = 1;
6946
buf[1] = j;
6947
cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
6948
ram_compress_buf(s, buf, 10);
6949
} else
6950
#endif
6951
{
6952
// normal_compress:
6953
buf[0] = 0;
6954
ram_compress_buf(s, buf, 1);
6955
ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
6956
}
6957
}
6958
ram_compress_close(s);
6959
}
6960
6961
static int ram_load(QEMUFile *f, void *opaque, int version_id)
3155
3156
found = 1;
3157
break;
3158
}
3159
addr += TARGET_PAGE_SIZE;
3160
current_addr = (saved_addr + addr) % phys_ram_size;
3161
}
3162
3163
return found;
3164
}
3165
3166
static ram_addr_t ram_save_threshold = 10;
3167
3168
static ram_addr_t ram_save_remaining(void)
3169
{
3170
ram_addr_t addr;
3171
ram_addr_t count = 0;
3172
3173
for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3174
if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3175
count++;
3176
}
3177
3178
return count;
3179
}
3180
3181
static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3182
{
3183
ram_addr_t addr;
3184
3185
if (stage == 1) {
3186
/* Make sure all dirty bits are set */
3187
for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3188
if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3189
cpu_physical_memory_set_dirty(addr);
3190
}
3191
3192
/* Enable dirty memory tracking */
3193
cpu_physical_memory_set_dirty_tracking(1);
3194
3195
qemu_put_be64(f, phys_ram_size | RAM_SAVE_FLAG_MEM_SIZE);
3196
}
3197
3198
while (!qemu_file_rate_limit(f)) {
3199
int ret;
3200
3201
ret = ram_save_block(f);
3202
if (ret == 0) /* no more blocks */
3203
break;
3204
}
3205
3206
/* try transferring iterative blocks of memory */
3207
3208
if (stage == 3) {
3209
cpu_physical_memory_set_dirty_tracking(0);
3210
3211
/* flush all remaining blocks regardless of rate limiting */
3212
while (ram_save_block(f) != 0);
3213
}
3214
3215
qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3216
3217
return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3218
}
3219
3220
static int ram_load_dead(QEMUFile *f, void *opaque)
6962
3221
{
6963
3222
RamDecompressState s1, *s = &s1;
6964
3223
uint8_t buf[10];
6965
int i;
3224
ram_addr_t i;
6966
3225
6967
if (version_id == 1)
6968
return ram_load_v1(f, opaque);
6969
if (version_id != 2)
6970
return -EINVAL;
6971
if (qemu_get_be32(f) != phys_ram_size)
6972
return -EINVAL;
6973
3226
if (ram_decompress_open(s, f) < 0)
6974
3227
return -EINVAL;
6975
3228
for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6979
3232
}
6980
3233
if (buf[0] == 0) {
6981
3234
if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
6982
fprintf(stderr, "Error while reading ram block address=0x%08x", i);
6983
goto error;
6984
}
6985
} else
6986
#if 0
6987
if (buf[0] == 1) {
6988
int bs_index;
6989
int64_t sector_num;
6990
6991
ram_decompress_buf(s, buf + 1, 9);
6992
bs_index = buf[1];
6993
sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
6994
if (bs_index >= nb_drives) {
6995
fprintf(stderr, "Invalid block device index %d\n", bs_index);
6996
goto error;
6997
}
6998
if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
6999
phys_ram_base + i,
7000
BDRV_HASH_BLOCK_SIZE / 512) < 0) {
7001
fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
7002
bs_index, sector_num);
7003
goto error;
7004
}
7005
} else
7006
#endif
7007
{
3235
fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3236
goto error;
3237
}
3238
} else {
7008
3239
error:
7009
3240
printf("Error block header\n");
7010
3241
return -EINVAL;
7011
3242
}
7012
3243
}
7013
3244
ram_decompress_close(s);
7014
return 0;
3245
3246
return 0;
3247
}
3248
3249
static int ram_load(QEMUFile *f, void *opaque, int version_id)
3250
{
3251
ram_addr_t addr;
3252
int flags;
3253
3254
if (version_id == 1)
3255
return ram_load_v1(f, opaque);
3256
3257
if (version_id == 2) {
3258
if (qemu_get_be32(f) != phys_ram_size)
3259
return -EINVAL;
3260
return ram_load_dead(f, opaque);
3261
}
3262
3263
if (version_id != 3)
3264
return -EINVAL;
3265
3266
do {
3267
addr = qemu_get_be64(f);
3268
3269
flags = addr & ~TARGET_PAGE_MASK;
3270
addr &= TARGET_PAGE_MASK;
3271
3272
if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3273
if (addr != phys_ram_size)
3274
return -EINVAL;
3275
}
3276
3277
if (flags & RAM_SAVE_FLAG_FULL) {
3278
if (ram_load_dead(f, opaque) < 0)
3279
return -EINVAL;
3280
}
3281
3282
if (flags & RAM_SAVE_FLAG_COMPRESS) {
3283
uint8_t ch = qemu_get_byte(f);
3284
memset(phys_ram_base + addr, ch, TARGET_PAGE_SIZE);
3285
} else if (flags & RAM_SAVE_FLAG_PAGE)
3286
qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
3287
} while (!(flags & RAM_SAVE_FLAG_EOS));
3288
3289
return 0;
3290
}
3291
3292
void qemu_service_io(void)
3293
{
3294
CPUState *env = cpu_single_env;
3295
if (env) {
3296
cpu_interrupt(env, CPU_INTERRUPT_EXIT);
3297
#ifdef USE_KQEMU
3298
if (env->kqemu_enabled) {
3299
kqemu_cpu_interrupt(env);
3300
}
3301
#endif
3302
}
7015
3303
}
7016
3304
7017
3305
/***********************************************************/
7021
3309
QEMUBHFunc *cb;
7022
3310
void *opaque;
7023
3311
int scheduled;
3312
int idle;
3313
int deleted;
7024
3314
QEMUBH *next;
7025
3315
};
7026
3316
7030
3320
{
7031
3321
QEMUBH *bh;
7032
3322
bh = qemu_mallocz(sizeof(QEMUBH));
7033
if (!bh)
7034
return NULL;
7035
3323
bh->cb = cb;
7036
3324
bh->opaque = opaque;
3325
bh->next = first_bh;
3326
first_bh = bh;
7037
3327
return bh;
7038
3328
}
7039
3329
7040
3330
int qemu_bh_poll(void)
7041
3331
{
7042
QEMUBH *bh, **pbh;
3332
QEMUBH *bh, **bhp;
7043
3333
int ret;
7044
3334
7045
3335
ret = 0;
7046
for(;;) {
7047
pbh = &first_bh;
7048
bh = *pbh;
7049
if (!bh)
7050
break;
7051
ret = 1;
7052
*pbh = bh->next;
7053
bh->scheduled = 0;
7054
bh->cb(bh->opaque);
7055
}
3336
for (bh = first_bh; bh; bh = bh->next) {
3337
if (!bh->deleted && bh->scheduled) {
3338
bh->scheduled = 0;
3339
if (!bh->idle)
3340
ret = 1;
3341
bh->idle = 0;
3342
bh->cb(bh->opaque);
3343
}
3344
}
3345
3346
/* remove deleted bhs */
3347
bhp = &first_bh;
3348
while (*bhp) {
3349
bh = *bhp;
3350
if (bh->deleted) {
3351
*bhp = bh->next;
3352
qemu_free(bh);
3353
} else
3354
bhp = &bh->next;
3355
}
3356
7056
3357
return ret;
7057
3358
}
7058
3359
3360
void qemu_bh_schedule_idle(QEMUBH *bh)
3361
{
3362
if (bh->scheduled)
3363
return;
3364
bh->scheduled = 1;
3365
bh->idle = 1;
3366
}
3367
7059
3368
void qemu_bh_schedule(QEMUBH *bh)
7060
3369
{
7061
3370
CPUState *env = cpu_single_env;
7062
3371
if (bh->scheduled)
7063
3372
return;
7064
3373
bh->scheduled = 1;
7065
bh->next = first_bh;
7066
first_bh = bh;
7067
3374
bh->idle = 0;
7068
3375
/* stop the currently executing CPU to execute the BH ASAP */
7069
3376
if (env) {
7070
3377
cpu_interrupt(env, CPU_INTERRUPT_EXIT);
7073
3380
7074
3381
void qemu_bh_cancel(QEMUBH *bh)
7075
3382
{
7076
QEMUBH **pbh;
7077
if (bh->scheduled) {
7078
pbh = &first_bh;
7079
while (*pbh != bh)
7080
pbh = &(*pbh)->next;
7081
*pbh = bh->next;
7082
bh->scheduled = 0;
7083
}
3383
bh->scheduled = 0;
7084
3384
}
7085
3385
7086
3386
void qemu_bh_delete(QEMUBH *bh)
7087
3387
{
7088
qemu_bh_cancel(bh);
7089
qemu_free(bh);
3388
bh->scheduled = 0;
3389
bh->deleted = 1;
3390
}
3391
3392
static void qemu_bh_update_timeout(int *timeout)
3393
{
3394
QEMUBH *bh;
3395
3396
for (bh = first_bh; bh; bh = bh->next) {
3397
if (!bh->deleted && bh->scheduled) {
3398
if (bh->idle) {
3399
/* idle bottom halves will be polled at least
3400
* every 10ms */
3401
*timeout = MIN(10, *timeout);
3402
} else {
3403
/* non-idle bottom halves will be executed
3404
* immediately */
3405
*timeout = 0;
3406
break;
3407
}
3408
}
3409
}
7090
3410
}
7091
3411
7092
3412
/***********************************************************/
7093
3413
/* machine registration */
7094
3414
7095
QEMUMachine *first_machine = NULL;
3415
static QEMUMachine *first_machine = NULL;
3416
QEMUMachine *current_machine = NULL;
7096
3417
7097
3418
int qemu_register_machine(QEMUMachine *m)
7098
3419
{
7121
3442
7122
3443
static void gui_update(void *opaque)
7123
3444
{
3445
uint64_t interval = GUI_REFRESH_INTERVAL;
7124
3446
DisplayState *ds = opaque;
7125
ds->dpy_refresh(ds);
7126
qemu_mod_timer(ds->gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
3447
DisplayChangeListener *dcl = ds->listeners;
3448
3449
dpy_refresh(ds);
3450
3451
while (dcl != NULL) {
3452
if (dcl->gui_timer_interval &&
3453
dcl->gui_timer_interval < interval)
3454
interval = dcl->gui_timer_interval;
3455
dcl = dcl->next;
3456
}
3457
qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3458
}
3459
3460
static void nographic_update(void *opaque)
3461
{
3462
uint64_t interval = GUI_REFRESH_INTERVAL;
3463
3464
qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
7127
3465
}
7128
3466
7129
3467
struct vm_change_state_entry {
7140
3478
VMChangeStateEntry *e;
7141
3479
7142
3480
e = qemu_mallocz(sizeof (*e));
7143
if (!e)
7144
return NULL;
7145
3481
7146
3482
e->cb = cb;
7147
3483
e->opaque = opaque;
7155
3491
qemu_free (e);
7156
3492
}
7157
3493
7158
static void vm_state_notify(int running)
3494
static void vm_state_notify(int running, int reason)
7159
3495
{
7160
3496
VMChangeStateEntry *e;
7161
3497
7162
3498
for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
7163
e->cb(e->opaque, running);
3499
e->cb(e->opaque, running, reason);
7164
3500
}
7165
3501
}
7166
3502
7167
/* XXX: support several handlers */
7168
static VMStopHandler *vm_stop_cb;
7169
static void *vm_stop_opaque;
7170
7171
int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
7172
{
7173
vm_stop_cb = cb;
7174
vm_stop_opaque = opaque;
7175
return 0;
7176
}
7177
7178
void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
7179
{
7180
vm_stop_cb = NULL;
7181
}
7182
7183
3503
void vm_start(void)
7184
3504
{
7185
3505
if (!vm_running) {
7186
3506
cpu_enable_ticks();
7187
3507
vm_running = 1;
7188
vm_state_notify(1);
3508
vm_state_notify(1, 0);
7189
3509
qemu_rearm_alarm_timer(alarm_timer);
7190
3510
}
7191
3511
}
7195
3515
if (vm_running) {
7196
3516
cpu_disable_ticks();
7197
3517
vm_running = 0;
7198
if (reason != 0) {
7199
if (vm_stop_cb) {
7200
vm_stop_cb(vm_stop_opaque, reason);
7201
}
7202
}
7203
vm_state_notify(0);
3518
vm_state_notify(0, reason);
7204
3519
}
7205
3520
}
7206
3521
7217
3532
static int shutdown_requested;
7218
3533
static int powerdown_requested;
7219
3534
3535
int qemu_shutdown_requested(void)
3536
{
3537
int r = shutdown_requested;
3538
shutdown_requested = 0;
3539
return r;
3540
}
3541
3542
int qemu_reset_requested(void)
3543
{
3544
int r = reset_requested;
3545
reset_requested = 0;
3546
return r;
3547
}
3548
3549
int qemu_powerdown_requested(void)
3550
{
3551
int r = powerdown_requested;
3552
powerdown_requested = 0;
3553
return r;
3554
}
3555
7220
3556
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
7221
3557
{
7222
3558
QEMUResetEntry **pre, *re;
7231
3567
*pre = re;
7232
3568
}
7233
3569
7234
static void qemu_system_reset(void)
3570
void qemu_system_reset(void)
7235
3571
{
7236
3572
QEMUResetEntry *re;
7237
3573
7266
3602
cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7267
3603
}
7268
3604
7269
void main_loop_wait(int timeout)
3605
#ifdef _WIN32
3606
static void host_main_loop_wait(int *timeout)
7270
3607
{
7271
IOHandlerRecord *ioh;
7272
fd_set rfds, wfds, xfds;
7273
int ret, nfds;
7274
#ifdef _WIN32
7275
int ret2, i;
7276
#endif
7277
struct timeval tv;
3608
int ret, ret2, i;
7278
3609
PollingEntry *pe;
7279
3610
7280
3611
7283
3614
for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7284
3615
ret |= pe->func(pe->opaque);
7285
3616
}
7286
#ifdef _WIN32
7287
3617
if (ret == 0) {
7288
3618
int err;
7289
3619
WaitObjects *w = &wait_objects;
7290
3620
7291
ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
3621
ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
7292
3622
if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7293
3623
if (w->func[ret - WAIT_OBJECT_0])
7294
3624
w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
7313
3643
fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
7314
3644
}
7315
3645
}
3646
3647
*timeout = 0;
3648
}
3649
#else
3650
static void host_main_loop_wait(int *timeout)
3651
{
3652
}
7316
3653
#endif
3654
3655
void main_loop_wait(int timeout)
3656
{
3657
IOHandlerRecord *ioh;
3658
fd_set rfds, wfds, xfds;
3659
int ret, nfds;
3660
struct timeval tv;
3661
3662
qemu_bh_update_timeout(&timeout);
3663
3664
host_main_loop_wait(&timeout);
3665
7317
3666
/* poll any events */
7318
3667
/* XXX: separate device handlers from system ones */
7319
3668
nfds = -1;
7337
3686
}
7338
3687
}
7339
3688
7340
tv.tv_sec = 0;
7341
#ifdef _WIN32
7342
tv.tv_usec = 0;
7343
#else
7344
tv.tv_usec = timeout * 1000;
7345
#endif
3689
tv.tv_sec = timeout / 1000;
3690
tv.tv_usec = (timeout % 1000) * 1000;
3691
7346
3692
#if defined(CONFIG_SLIRP)
7347
if (slirp_inited) {
3693
if (slirp_is_inited()) {
7348
3694
slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7349
3695
}
7350
3696
#endif
7373
3719
}
7374
3720
}
7375
3721
#if defined(CONFIG_SLIRP)
7376
if (slirp_inited) {
3722
if (slirp_is_inited()) {
7377
3723
if (ret < 0) {
7378
3724
FD_ZERO(&rfds);
7379
3725
FD_ZERO(&wfds);
7382
3728
slirp_select_poll(&rfds, &wfds, &xfds);
7383
3729
}
7384
3730
#endif
7385
qemu_aio_poll();
7386
3731
7387
if (vm_running) {
3732
/* vm time timers */
3733
if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
7388
3734
qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
7389
3735
qemu_get_clock(vm_clock));
7390
/* run dma transfers, if any */
7391
DMA_run();
7392
}
7393
3736
7394
3737
/* real time timers */
7395
3738
qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
7396
3739
qemu_get_clock(rt_clock));
7397
3740
7398
if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7399
alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7400
qemu_rearm_alarm_timer(alarm_timer);
7401
}
7402
7403
3741
/* Check bottom-halves last in case any of the earlier events triggered
7404
3742
them. */
7405
3743
qemu_bh_poll();
7425
3763
#ifdef CONFIG_PROFILER
7426
3764
ti = profile_getclock();
7427
3765
#endif
3766
if (use_icount) {
3767
int64_t count;
3768
int decr;
3769
qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3770
env->icount_decr.u16.low = 0;
3771
env->icount_extra = 0;
3772
count = qemu_next_deadline();
3773
count = (count + (1 << icount_time_shift) - 1)
3774
>> icount_time_shift;
3775
qemu_icount += count;
3776
decr = (count > 0xffff) ? 0xffff : count;
3777
count -= decr;
3778
env->icount_decr.u16.low = decr;
3779
env->icount_extra = count;
3780
}
7428
3781
ret = cpu_exec(env);
7429
3782
#ifdef CONFIG_PROFILER
7430
3783
qemu_time += profile_getclock() - ti;
7431
3784
#endif
3785
if (use_icount) {
3786
/* Fold pending instructions back into the
3787
instruction counter, and clear the interrupt flag. */
3788
qemu_icount -= (env->icount_decr.u16.low
3789
+ env->icount_extra);
3790
env->icount_decr.u32 = 0;
3791
env->icount_extra = 0;
3792
}
7432
3793
next_cpu = env->next_cpu ?: first_cpu;
7433
if (event_pending) {
3794
if (event_pending && likely(ret != EXCP_DEBUG)) {
7434
3795
ret = EXCP_INTERRUPT;
7435
3796
event_pending = 0;
7436
3797
break;
7450
3811
7451
3812
if (shutdown_requested) {
7452
3813
ret = EXCP_INTERRUPT;
7453
break;
3814
if (no_shutdown) {
3815
vm_stop(0);
3816
no_shutdown = 0;
3817
}
3818
else
3819
break;
7454
3820
}
7455
3821
if (reset_requested) {
7456
3822
reset_requested = 0;
7462
3828
qemu_system_powerdown();
7463
3829
ret = EXCP_INTERRUPT;
7464
3830
}
7465
if (ret == EXCP_DEBUG) {
3831
if (unlikely(ret == EXCP_DEBUG)) {
3832
gdb_set_stop_cpu(cur_cpu);
7466
3833
vm_stop(EXCP_DEBUG);
7467
3834
}
7468
3835
/* If all cpus are halted then wait until the next IRQ */
7469
3836
/* XXX: use timeout computed from timers */
7470
if (ret == EXCP_HALTED)
7471
timeout = 10;
7472
else
3837
if (ret == EXCP_HALTED) {
3838
if (use_icount) {
3839
int64_t add;
3840
int64_t delta;
3841
/* Advance virtual time to the next event. */
3842
if (use_icount == 1) {
3843
/* When not using an adaptive execution frequency
3844
we tend to get badly out of sync with real time,
3845
so just delay for a reasonable amount of time. */
3846
delta = 0;
3847
} else {
3848
delta = cpu_get_icount() - cpu_get_clock();
3849
}
3850
if (delta > 0) {
3851
/* If virtual time is ahead of real time then just
3852
wait for IO. */
3853
timeout = (delta / 1000000) + 1;
3854
} else {
3855
/* Wait for either IO to occur or the next
3856
timer event. */
3857
add = qemu_next_deadline();
3858
/* We advance the timer before checking for IO.
3859
Limit the amount we advance so that early IO
3860
activity won't get the guest too far ahead. */
3861
if (add > 10000000)
3862
add = 10000000;
3863
delta += add;
3864
add = (add + (1 << icount_time_shift) - 1)
3865
>> icount_time_shift;
3866
qemu_icount += add;
3867
timeout = delta / 1000000;
3868
if (timeout < 0)
3869
timeout = 0;
3870
}
3871
} else {
3872
timeout = 5000;
3873
}
3874
} else {
7473
3875
timeout = 0;
3876
}
7474
3877
} else {
7475
timeout = 10;
3878
if (shutdown_requested) {
3879
ret = EXCP_INTERRUPT;
3880
break;
3881
}
3882
timeout = 5000;
7476
3883
}
7477
3884
#ifdef CONFIG_PROFILER
7478
3885
ti = profile_getclock();
7488
3895
7489
3896
static void help(int exitcode)
7490
3897
{
3898
/* Please keep in synch with QEMU_OPTION_ enums, qemu_options[]
3899
and qemu-doc.texi */
7491
3900
printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
7492
3901
"usage: %s [options] [disk_image]\n"
7493
3902
"\n"
7494
3903
"'disk_image' is a raw hard image image for IDE hard disk 0\n"
7495
3904
"\n"
7496
3905
"Standard options:\n"
3906
"-h or -help display this help and exit\n"
7497
3907
"-M machine select emulated machine (-M ? for list)\n"
7498
3908
"-cpu cpu select CPU (-cpu ? for list)\n"
3909
"-smp n set the number of CPUs to 'n' [default=1]\n"
7499
3910
"-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7500
3911
"-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7501
3912
"-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7502
3913
"-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7503
"-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][index=i]\n"
7504
" [,cyls=c,heads=h,secs=s[,trans=t]][snapshot=on|off]"
7505
" [,cache=on|off]\n"
3914
"-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
3915
" [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
3916
" [,cache=writethrough|writeback|none][,format=f][,serial=s]\n"
7506
3917
" use 'file' as a drive image\n"
7507
3918
"-mtdblock file use 'file' as on-board Flash memory image\n"
7508
3919
"-sd file use 'file' as SecureDigital card image\n"
7509
3920
"-pflash file use 'file' as a parallel flash image\n"
7510
3921
"-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7511
3922
"-snapshot write to temporary files instead of disk image files\n"
7512
#ifdef CONFIG_SDL
7513
"-no-frame open SDL window without a frame and window decorations\n"
7514
"-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7515
"-no-quit disable SDL window close capability\n"
7516
#endif
7517
#ifdef TARGET_I386
7518
"-no-fd-bootchk disable boot signature checking for floppy disks\n"
7519
#endif
7520
3923
"-m megs set virtual RAM size to megs MB [default=%d]\n"
7521
"-smp n set the number of CPUs to 'n' [default=1]\n"
7522
"-nographic disable graphical output and redirect serial I/Os to console\n"
7523
"-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7524
3924
#ifndef _WIN32
7525
3925
"-k language use keyboard layout (for example \"fr\" for French)\n"
7526
3926
#endif
7531
3931
" use -soundhw ? to get the list of supported cards\n"
7532
3932
" use -soundhw all to enable all of them\n"
7533
3933
#endif
7534
"-localtime set the real time clock to local time [default=utc]\n"
7535
"-full-screen start in full screen\n"
7536
#ifdef TARGET_I386
7537
"-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7538
#endif
7539
3934
"-usb enable the USB driver (will be the default soon)\n"
7540
3935
"-usbdevice name add the host or guest USB device 'name'\n"
3936
"-name string set the name of the guest\n"
3937
"-uuid %%08x-%%04x-%%04x-%%04x-%%012x\n"
3938
" specify machine UUID\n"
3939
"\n"
3940
"Display options:\n"
3941
"-nographic disable graphical output and redirect serial I/Os to console\n"
3942
#ifdef CONFIG_CURSES
3943
"-curses use a curses/ncurses interface instead of SDL\n"
3944
#endif
3945
#ifdef CONFIG_SDL
3946
"-no-frame open SDL window without a frame and window decorations\n"
3947
"-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
3948
"-no-quit disable SDL window close capability\n"
3949
"-sdl enable SDL\n"
3950
#endif
3951
"-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
3952
"-vga [std|cirrus|vmware|none]\n"
3953
" select video card type\n"
3954
"-full-screen start in full screen\n"
7541
3955
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7542
3956
"-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7543
3957
#endif
7544
"-name string set the name of the guest\n"
3958
"-vnc display start a VNC server on display\n"
7545
3959
"\n"
7546
3960
"Network options:\n"
7547
"-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
3961
"-net nic[,vlan=n][,macaddr=addr][,model=type][,name=str]\n"
7548
3962
" create a new Network Interface Card and connect it to VLAN 'n'\n"
7549
3963
#ifdef CONFIG_SLIRP
7550
"-net user[,vlan=n][,hostname=host]\n"
3964
"-net user[,vlan=n][,name=str][,hostname=host]\n"
7551
3965
" connect the user mode network stack to VLAN 'n' and send\n"
7552
3966
" hostname 'host' to DHCP clients\n"
7553
3967
#endif
7554
3968
#ifdef _WIN32
7555
"-net tap[,vlan=n],ifname=name\n"
3969
"-net tap[,vlan=n][,name=str],ifname=name\n"
7556
3970
" connect the host TAP network interface to VLAN 'n'\n"
7557
3971
#else
7558
"-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
3972
"-net tap[,vlan=n][,name=str][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7559
3973
" connect the host TAP network interface to VLAN 'n' and use the\n"
7560
3974
" network scripts 'file' (default=%s)\n"
7561
3975
" and 'dfile' (default=%s);\n"
7562
3976
" use '[down]script=no' to disable script execution;\n"
7563
3977
" use 'fd=h' to connect to an already opened TAP interface\n"
7564
3978
#endif
7565
"-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
3979
"-net socket[,vlan=n][,name=str][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7566
3980
" connect the vlan 'n' to another VLAN using a socket connection\n"
7567
"-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
3981
"-net socket[,vlan=n][,name=str][,fd=h][,mcast=maddr:port]\n"
7568
3982
" connect the vlan 'n' to multicast maddr and port\n"
3983
#ifdef CONFIG_VDE
3984
"-net vde[,vlan=n][,name=str][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
3985
" connect the vlan 'n' to port 'n' of a vde switch running\n"
3986
" on host and listening for incoming connections on 'socketpath'.\n"
3987
" Use group 'groupname' and mode 'octalmode' to change default\n"
3988
" ownership and permissions for communication port.\n"
3989
#endif
7569
3990
"-net none use it alone to have zero network devices; if no -net option\n"
7570
3991
" is provided, the default is '-net nic -net user'\n"
7571
"\n"
7572
3992
#ifdef CONFIG_SLIRP
7573
3993
"-tftp dir allow tftp access to files in dir [-net user]\n"
7574
3994
"-bootp file advertise file in BOOTP replies\n"
7579
3999
" redirect TCP or UDP connections from host to guest [-net user]\n"
7580
4000
#endif
7581
4001
"\n"
4002
"-bt hci,null dumb bluetooth HCI - doesn't respond to commands\n"
4003
"-bt hci,host[:id]\n"
4004
" use host's HCI with the given name\n"
4005
"-bt hci[,vlan=n]\n"
4006
" emulate a standard HCI in virtual scatternet 'n'\n"
4007
"-bt vhci[,vlan=n]\n"
4008
" add host computer to virtual scatternet 'n' using VHCI\n"
4009
"-bt device:dev[,vlan=n]\n"
4010
" emulate a bluetooth device 'dev' in scatternet 'n'\n"
4011
"\n"
4012
#ifdef TARGET_I386
4013
"\n"
4014
"i386 target only:\n"
4015
"-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
4016
"-rtc-td-hack use it to fix time drift in Windows ACPI HAL\n"
4017
"-no-fd-bootchk disable boot signature checking for floppy disks\n"
4018
"-no-acpi disable ACPI\n"
4019
"-no-hpet disable HPET\n"
4020
"-acpitable [sig=str][,rev=n][,oem_id=str][,oem_table_id=str][,oem_rev=n][,asl_compiler_id=str][,asl_compiler_rev=n][,data=file1[:file2]...]\n"
4021
" ACPI table description\n"
4022
#endif
7582
4023
"Linux boot specific:\n"
7583
4024
"-kernel bzImage use 'bzImage' as kernel image\n"
7584
4025
"-append cmdline use 'cmdline' as kernel command line\n"
7585
4026
"-initrd file use 'file' as initial ram disk\n"
7586
4027
"\n"
7587
4028
"Debug/Expert options:\n"
7588
"-monitor dev redirect the monitor to char device 'dev'\n"
7589
4029
"-serial dev redirect the serial port to char device 'dev'\n"
7590
4030
"-parallel dev redirect the parallel port to char device 'dev'\n"
7591
"-pidfile file Write PID to 'file'\n"
4031
"-monitor dev redirect the monitor to char device 'dev'\n"
4032
"-pidfile file write PID to 'file'\n"
7592
4033
"-S freeze CPU at startup (use 'c' to start execution)\n"
7593
4034
"-s wait gdb connection to port\n"
7594
4035
"-p port set gdb connection port [default=%s]\n"
7595
4036
"-d item1,... output log to %s (use -d ? for a list of log items)\n"
7596
"-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
4037
"-hdachs c,h,s[,t]\n"
4038
" force hard disk 0 physical geometry and the optional BIOS\n"
7597
4039
" translation (t=none or lba) (usually qemu can guess them)\n"
7598
4040
"-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
4041
"-bios file set the filename for the BIOS\n"
7599
4042
#ifdef USE_KQEMU
7600
4043
"-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7601
4044
"-no-kqemu disable KQEMU kernel module usage\n"
7602
4045
#endif
7603
#ifdef TARGET_I386
7604
"-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
7605
" (default is CL-GD5446 PCI VGA)\n"
7606
"-no-acpi disable ACPI\n"
4046
#ifdef CONFIG_KVM
4047
"-enable-kvm enable KVM full virtualization support\n"
7607
4048
#endif
7608
4049
"-no-reboot exit instead of rebooting\n"
7609
"-loadvm file start right away with a saved state (loadvm in monitor)\n"
7610
"-vnc display start a VNC server on display\n"
4050
"-no-shutdown stop before shutdown\n"
4051
"-loadvm [tag|id]\n"
4052
" start right away with a saved state (loadvm in monitor)\n"
7611
4053
#ifndef _WIN32
7612
4054
"-daemonize daemonize QEMU after initializing\n"
7613
4055
#endif
7614
4056
"-option-rom rom load a file, rom, into the option ROM space\n"
7615
#ifdef TARGET_SPARC
7616
"-prom-env variable=value set OpenBIOS nvram variables\n"
4057
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
4058
"-prom-env variable=value\n"
4059
" set OpenBIOS nvram variables\n"
7617
4060
#endif
7618
4061
"-clock force the use of the given methods for timer alarm.\n"
7619
" To see what timers are available use -clock help\n"
4062
" To see what timers are available use -clock ?\n"
4063
"-localtime set the real time clock to local time [default=utc]\n"
4064
"-startdate select initial date of the clock\n"
4065
"-icount [N|auto]\n"
4066
" enable virtual instruction counter with 2^N clock ticks per instruction\n"
4067
"-echr chr set terminal escape character instead of ctrl-a\n"
4068
"-virtioconsole c\n"
4069
" set virtio console\n"
4070
"-show-cursor show cursor\n"
4071
#if defined(TARGET_ARM) || defined(TARGET_M68K)
4072
"-semihosting semihosting mode\n"
4073
#endif
4074
#if defined(TARGET_ARM)
4075
"-old-param old param mode\n"
4076
#endif
4077
"-tb-size n set TB size\n"
4078
"-incoming p prepare for incoming migration, listen on port p\n"
4079
#ifndef _WIN32
4080
"-chroot dir Chroot to dir just before starting the VM.\n"
4081
"-runas user Change to user id user just before starting the VM.\n"
4082
#endif
7620
4083
"\n"
7621
4084
"During emulation, the following keys are useful:\n"
7622
4085
"ctrl-alt-f toggle full screen\n"
7639
4102
#define HAS_ARG 0x0001
7640
4103
7641
4104
enum {
4105
/* Please keep in synch with help, qemu_options[] and
4106
qemu-doc.texi */
4107
/* Standard options: */
7642
4108
QEMU_OPTION_h,
7643
7644
4109
QEMU_OPTION_M,
7645
4110
QEMU_OPTION_cpu,
4111
QEMU_OPTION_smp,
7646
4112
QEMU_OPTION_fda,
7647
4113
QEMU_OPTION_fdb,
7648
4114
QEMU_OPTION_hda,
7649
4115
QEMU_OPTION_hdb,
7650
4116
QEMU_OPTION_hdc,
7651
4117
QEMU_OPTION_hdd,
4118
QEMU_OPTION_cdrom,
7652
4119
QEMU_OPTION_drive,
7653
QEMU_OPTION_cdrom,
7654
4120
QEMU_OPTION_mtdblock,
7655
4121
QEMU_OPTION_sd,
7656
4122
QEMU_OPTION_pflash,
7657
4123
QEMU_OPTION_boot,
7658
4124
QEMU_OPTION_snapshot,
7659
#ifdef TARGET_I386
7660
QEMU_OPTION_no_fd_bootchk,
7661
#endif
7662
4125
QEMU_OPTION_m,
4126
QEMU_OPTION_k,
4127
QEMU_OPTION_audio_help,
4128
QEMU_OPTION_soundhw,
4129
QEMU_OPTION_usb,
4130
QEMU_OPTION_usbdevice,
4131
QEMU_OPTION_name,
4132
QEMU_OPTION_uuid,
4133
4134
/* Display options: */
7663
4135
QEMU_OPTION_nographic,
4136
QEMU_OPTION_curses,
4137
QEMU_OPTION_no_frame,
4138
QEMU_OPTION_alt_grab,
4139
QEMU_OPTION_no_quit,
4140
QEMU_OPTION_sdl,
7664
4141
QEMU_OPTION_portrait,
7665
#ifdef HAS_AUDIO
7666
QEMU_OPTION_audio_help,
7667
QEMU_OPTION_soundhw,
7668
#endif
4142
QEMU_OPTION_vga,
4143
QEMU_OPTION_full_screen,
4144
QEMU_OPTION_g,
4145
QEMU_OPTION_vnc,
7669
4146
4147
/* Network options: */
7670
4148
QEMU_OPTION_net,
7671
4149
QEMU_OPTION_tftp,
7672
4150
QEMU_OPTION_bootp,
7673
4151
QEMU_OPTION_smb,
7674
4152
QEMU_OPTION_redir,
7675
4153
QEMU_OPTION_bt,
4154
4155
/* i386 target only: */
4156
QEMU_OPTION_win2k_hack,
4157
QEMU_OPTION_rtc_td_hack,
4158
QEMU_OPTION_no_fd_bootchk,
4159
QEMU_OPTION_no_acpi,
4160
QEMU_OPTION_no_hpet,
4161
QEMU_OPTION_acpitable,
4162
4163
/* Linux boot specific: */
7676
4164
QEMU_OPTION_kernel,
7677
4165
QEMU_OPTION_append,
7678
4166
QEMU_OPTION_initrd,
7679
4167
4168
/* Debug/Expert options: */
4169
QEMU_OPTION_serial,
4170
QEMU_OPTION_parallel,
4171
QEMU_OPTION_monitor,
4172
QEMU_OPTION_pidfile,
7680
4173
QEMU_OPTION_S,
7681
4174
QEMU_OPTION_s,
7682
4175
QEMU_OPTION_p,
7684
4177
QEMU_OPTION_hdachs,
7685
4178
QEMU_OPTION_L,
7686
4179
QEMU_OPTION_bios,
7687
QEMU_OPTION_no_code_copy,
7688
QEMU_OPTION_k,
7689
QEMU_OPTION_localtime,
7690
QEMU_OPTION_cirrusvga,
7691
QEMU_OPTION_vmsvga,
7692
QEMU_OPTION_g,
7693
QEMU_OPTION_std_vga,
7694
QEMU_OPTION_echr,
7695
QEMU_OPTION_monitor,
7696
QEMU_OPTION_serial,
7697
QEMU_OPTION_parallel,
7698
QEMU_OPTION_loadvm,
7699
QEMU_OPTION_full_screen,
7700
QEMU_OPTION_no_frame,
7701
QEMU_OPTION_alt_grab,
7702
QEMU_OPTION_no_quit,
7703
QEMU_OPTION_pidfile,
4180
QEMU_OPTION_kernel_kqemu,
7704
4181
QEMU_OPTION_no_kqemu,
7705
QEMU_OPTION_kernel_kqemu,
7706
QEMU_OPTION_win2k_hack,
7707
QEMU_OPTION_usb,
7708
QEMU_OPTION_usbdevice,
7709
QEMU_OPTION_smp,
7710
QEMU_OPTION_vnc,
7711
QEMU_OPTION_no_acpi,
4182
QEMU_OPTION_enable_kvm,
7712
4183
QEMU_OPTION_no_reboot,
7713
QEMU_OPTION_show_cursor,
4184
QEMU_OPTION_no_shutdown,
4185
QEMU_OPTION_loadvm,
7714
4186
QEMU_OPTION_daemonize,
7715
4187
QEMU_OPTION_option_rom,
7716
QEMU_OPTION_semihosting,
7717
QEMU_OPTION_name,
7718
4188
QEMU_OPTION_prom_env,
7719
QEMU_OPTION_old_param,
7720
4189
QEMU_OPTION_clock,
4190
QEMU_OPTION_localtime,
7721
4191
QEMU_OPTION_startdate,
4192
QEMU_OPTION_icount,
4193
QEMU_OPTION_echr,
4194
QEMU_OPTION_virtiocon,
4195
QEMU_OPTION_show_cursor,
4196
QEMU_OPTION_semihosting,
4197
QEMU_OPTION_old_param,
4198
QEMU_OPTION_tb_size,
4199
QEMU_OPTION_incoming,
4200
QEMU_OPTION_chroot,
4201
QEMU_OPTION_runas,
7722
4202
};
7723
4203
7724
4204
typedef struct QEMUOption {
7727
4207
int index;
7728
4208
} QEMUOption;
7729
4209
7730
const QEMUOption qemu_options[] = {
4210
static const QEMUOption qemu_options[] = {
4211
/* Please keep in synch with help, QEMU_OPTION_ enums, and
4212
qemu-doc.texi */
4213
/* Standard options: */
7731
4214
{ "h", 0, QEMU_OPTION_h },
7732
4215
{ "help", 0, QEMU_OPTION_h },
7733
7734
4216
{ "M", HAS_ARG, QEMU_OPTION_M },
7735
4217
{ "cpu", HAS_ARG, QEMU_OPTION_cpu },
4218
{ "smp", HAS_ARG, QEMU_OPTION_smp },
7736
4219
{ "fda", HAS_ARG, QEMU_OPTION_fda },
7737
4220
{ "fdb", HAS_ARG, QEMU_OPTION_fdb },
7738
4221
{ "hda", HAS_ARG, QEMU_OPTION_hda },
7739
4222
{ "hdb", HAS_ARG, QEMU_OPTION_hdb },
7740
4223
{ "hdc", HAS_ARG, QEMU_OPTION_hdc },
7741
4224
{ "hdd", HAS_ARG, QEMU_OPTION_hdd },
4225
{ "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
7742
4226
{ "drive", HAS_ARG, QEMU_OPTION_drive },
7743
{ "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
7744
4227
{ "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
7745
4228
{ "sd", HAS_ARG, QEMU_OPTION_sd },
7746
4229
{ "pflash", HAS_ARG, QEMU_OPTION_pflash },
7747
4230
{ "boot", HAS_ARG, QEMU_OPTION_boot },
7748
4231
{ "snapshot", 0, QEMU_OPTION_snapshot },
7749
#ifdef TARGET_I386
7750
{ "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
7751
#endif
7752
4232
{ "m", HAS_ARG, QEMU_OPTION_m },
7753
{ "nographic", 0, QEMU_OPTION_nographic },
7754
{ "portrait", 0, QEMU_OPTION_portrait },
4233
#ifndef _WIN32
7755
4234
{ "k", HAS_ARG, QEMU_OPTION_k },
4235
#endif
7756
4236
#ifdef HAS_AUDIO
7757
4237
{ "audio-help", 0, QEMU_OPTION_audio_help },
7758
4238
{ "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
7759
4239
#endif
7760
4240
{ "usb", 0, QEMU_OPTION_usb },
4241
{ "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
4242
{ "name", HAS_ARG, QEMU_OPTION_name },
4243
{ "uuid", HAS_ARG, QEMU_OPTION_uuid },
4244
4245
/* Display options: */
4246
{ "nographic", 0, QEMU_OPTION_nographic },
4247
#ifdef CONFIG_CURSES
4248
{ "curses", 0, QEMU_OPTION_curses },
4249
#endif
4250
#ifdef CONFIG_SDL
4251
{ "no-frame", 0, QEMU_OPTION_no_frame },
4252
{ "alt-grab", 0, QEMU_OPTION_alt_grab },
4253
{ "no-quit", 0, QEMU_OPTION_no_quit },
4254
{ "sdl", 0, QEMU_OPTION_sdl },
4255
#endif
4256
{ "portrait", 0, QEMU_OPTION_portrait },
4257
{ "vga", HAS_ARG, QEMU_OPTION_vga },
4258
{ "full-screen", 0, QEMU_OPTION_full_screen },
4259
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
4260
{ "g", 1, QEMU_OPTION_g },
4261
#endif
4262
{ "vnc", HAS_ARG, QEMU_OPTION_vnc },
4263
4264
/* Network options: */
7761
4265
{ "net", HAS_ARG, QEMU_OPTION_net},
7762
4266
#ifdef CONFIG_SLIRP
7763
4267
{ "tftp", HAS_ARG, QEMU_OPTION_tftp },
7767
4271
#endif
7768
4272
{ "redir", HAS_ARG, QEMU_OPTION_redir },
7769
4273
#endif
4274
{ "bt", HAS_ARG, QEMU_OPTION_bt },
4275
#ifdef TARGET_I386
4276
/* i386 target only: */
4277
{ "win2k-hack", 0, QEMU_OPTION_win2k_hack },
4278
{ "rtc-td-hack", 0, QEMU_OPTION_rtc_td_hack },
4279
{ "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
4280
{ "no-acpi", 0, QEMU_OPTION_no_acpi },
4281
{ "no-hpet", 0, QEMU_OPTION_no_hpet },
4282
{ "acpitable", HAS_ARG, QEMU_OPTION_acpitable },
4283
#endif
7770
4284
4285
/* Linux boot specific: */
7771
4286
{ "kernel", HAS_ARG, QEMU_OPTION_kernel },
7772
4287
{ "append", HAS_ARG, QEMU_OPTION_append },
7773
4288
{ "initrd", HAS_ARG, QEMU_OPTION_initrd },
7774
4289
4290
/* Debug/Expert options: */
4291
{ "serial", HAS_ARG, QEMU_OPTION_serial },
4292
{ "parallel", HAS_ARG, QEMU_OPTION_parallel },
4293
{ "monitor", HAS_ARG, QEMU_OPTION_monitor },
4294
{ "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
7775
4295
{ "S", 0, QEMU_OPTION_S },
7776
4296
{ "s", 0, QEMU_OPTION_s },
7777
4297
{ "p", HAS_ARG, QEMU_OPTION_p },
7779
4299
{ "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
7780
4300
{ "L", HAS_ARG, QEMU_OPTION_L },
7781
4301
{ "bios", HAS_ARG, QEMU_OPTION_bios },
7782
{ "no-code-copy", 0, QEMU_OPTION_no_code_copy },
7783
4302
#ifdef USE_KQEMU
4303
{ "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
7784
4304
{ "no-kqemu", 0, QEMU_OPTION_no_kqemu },
7785
{ "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
7786
#endif
7787
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7788
{ "g", 1, QEMU_OPTION_g },
7789
#endif
7790
{ "localtime", 0, QEMU_OPTION_localtime },
7791
{ "std-vga", 0, QEMU_OPTION_std_vga },
7792
{ "echr", HAS_ARG, QEMU_OPTION_echr },
7793
{ "monitor", HAS_ARG, QEMU_OPTION_monitor },
7794
{ "serial", HAS_ARG, QEMU_OPTION_serial },
7795
{ "parallel", HAS_ARG, QEMU_OPTION_parallel },
4305
#endif
4306
#ifdef CONFIG_KVM
4307
{ "enable-kvm", 0, QEMU_OPTION_enable_kvm },
4308
#endif
4309
{ "no-reboot", 0, QEMU_OPTION_no_reboot },
4310
{ "no-shutdown", 0, QEMU_OPTION_no_shutdown },
7796
4311
{ "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
7797
{ "full-screen", 0, QEMU_OPTION_full_screen },
7798
#ifdef CONFIG_SDL
7799
{ "no-frame", 0, QEMU_OPTION_no_frame },
7800
{ "alt-grab", 0, QEMU_OPTION_alt_grab },
7801
{ "no-quit", 0, QEMU_OPTION_no_quit },
7802
#endif
7803
{ "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
7804
{ "win2k-hack", 0, QEMU_OPTION_win2k_hack },
7805
{ "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
7806
{ "smp", HAS_ARG, QEMU_OPTION_smp },
7807
{ "vnc", HAS_ARG, QEMU_OPTION_vnc },
7808
7809
/* temporary options */
7810
{ "usb", 0, QEMU_OPTION_usb },
7811
{ "cirrusvga", 0, QEMU_OPTION_cirrusvga },
7812
{ "vmwarevga", 0, QEMU_OPTION_vmsvga },
7813
{ "no-acpi", 0, QEMU_OPTION_no_acpi },
7814
{ "no-reboot", 0, QEMU_OPTION_no_reboot },
7815
{ "show-cursor", 0, QEMU_OPTION_show_cursor },
7816
4312
{ "daemonize", 0, QEMU_OPTION_daemonize },
7817
4313
{ "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
7818
#if defined(TARGET_ARM) || defined(TARGET_M68K)
7819
{ "semihosting", 0, QEMU_OPTION_semihosting },
7820
#endif
7821
{ "name", HAS_ARG, QEMU_OPTION_name },
7822
#if defined(TARGET_SPARC)
4314
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
7823
4315
{ "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
7824
4316
#endif
7825
#if defined(TARGET_ARM)
7826
{ "old-param", 0, QEMU_OPTION_old_param },
7827
#endif
7828
4317
{ "clock", HAS_ARG, QEMU_OPTION_clock },
4318
{ "localtime", 0, QEMU_OPTION_localtime },
7829
4319
{ "startdate", HAS_ARG, QEMU_OPTION_startdate },
4320
{ "icount", HAS_ARG, QEMU_OPTION_icount },
4321
{ "echr", HAS_ARG, QEMU_OPTION_echr },
4322
{ "virtioconsole", HAS_ARG, QEMU_OPTION_virtiocon },
4323
{ "show-cursor", 0, QEMU_OPTION_show_cursor },
4324
#if defined(TARGET_ARM) || defined(TARGET_M68K)
4325
{ "semihosting", 0, QEMU_OPTION_semihosting },
4326
#endif
4327
#if defined(TARGET_ARM)
4328
{ "old-param", 0, QEMU_OPTION_old_param },
4329
#endif
4330
{ "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
4331
{ "incoming", HAS_ARG, QEMU_OPTION_incoming },
4332
{ "chroot", HAS_ARG, QEMU_OPTION_chroot },
4333
{ "runas", HAS_ARG, QEMU_OPTION_runas },
7830
4334
{ NULL },
7831
4335
};
7832
4336
7869
4373
}
7870
4374
}
7871
4375
7872
/* XXX: currently we cannot use simultaneously different CPUs */
7873
static void register_machines(void)
7874
{
7875
#if defined(TARGET_I386)
7876
qemu_register_machine(&pc_machine);
7877
qemu_register_machine(&isapc_machine);
7878
#elif defined(TARGET_PPC)
7879
qemu_register_machine(&heathrow_machine);
7880
qemu_register_machine(&core99_machine);
7881
qemu_register_machine(&prep_machine);
7882
qemu_register_machine(&ref405ep_machine);
7883
qemu_register_machine(&taihu_machine);
7884
#elif defined(TARGET_MIPS)
7885
qemu_register_machine(&mips_machine);
7886
qemu_register_machine(&mips_malta_machine);
7887
qemu_register_machine(&mips_pica61_machine);
7888
qemu_register_machine(&mips_mipssim_machine);
7889
#elif defined(TARGET_SPARC)
7890
#ifdef TARGET_SPARC64
7891
qemu_register_machine(&sun4u_machine);
7892
#else
7893
qemu_register_machine(&ss5_machine);
7894
qemu_register_machine(&ss10_machine);
7895
qemu_register_machine(&ss600mp_machine);
7896
qemu_register_machine(&ss20_machine);
7897
qemu_register_machine(&ss2_machine);
7898
qemu_register_machine(&ss1000_machine);
7899
qemu_register_machine(&ss2000_machine);
7900
#endif
7901
#elif defined(TARGET_ARM)
7902
qemu_register_machine(&integratorcp_machine);
7903
qemu_register_machine(&versatilepb_machine);
7904
qemu_register_machine(&versatileab_machine);
7905
qemu_register_machine(&realview_machine);
7906
qemu_register_machine(&akitapda_machine);
7907
qemu_register_machine(&spitzpda_machine);
7908
qemu_register_machine(&borzoipda_machine);
7909
qemu_register_machine(&terrierpda_machine);
7910
qemu_register_machine(&palmte_machine);
7911
qemu_register_machine(&lm3s811evb_machine);
7912
qemu_register_machine(&lm3s6965evb_machine);
7913
qemu_register_machine(&connex_machine);
7914
qemu_register_machine(&verdex_machine);
7915
qemu_register_machine(&mainstone2_machine);
7916
#elif defined(TARGET_SH4)
7917
qemu_register_machine(&shix_machine);
7918
qemu_register_machine(&r2d_machine);
7919
#elif defined(TARGET_ALPHA)
7920
/* XXX: TODO */
7921
#elif defined(TARGET_M68K)
7922
qemu_register_machine(&mcf5208evb_machine);
7923
qemu_register_machine(&an5206_machine);
7924
qemu_register_machine(&dummy_m68k_machine);
7925
#elif defined(TARGET_CRIS)
7926
qemu_register_machine(&bareetraxfs_machine);
7927
#else
7928
#error unsupported CPU
7929
#endif
7930
}
7931
7932
4376
#ifdef HAS_AUDIO
7933
4377
struct soundhw soundhw[] = {
7934
4378
#ifdef HAS_AUDIO_CHOICE
7935
#ifdef TARGET_I386
4379
#if defined(TARGET_I386) || defined(TARGET_MIPS)
7936
4380
{
7937
4381
"pcspk",
7938
4382
"PC speaker",
7941
4385
{ .init_isa = pcspk_audio_init }
7942
4386
},
7943
4387
#endif
4388
4389
#ifdef CONFIG_SB16
7944
4390
{
7945
4391
"sb16",
7946
4392
"Creative Sound Blaster 16",
7948
4394
1,
7949
4395
{ .init_isa = SB16_init }
7950
4396
},
4397
#endif
4398
4399
#ifdef CONFIG_CS4231A
4400
{
4401
"cs4231a",
4402
"CS4231A",
4403
0,
4404
1,
4405
{ .init_isa = cs4231a_init }
4406
},
4407
#endif
7951
4408
7952
4409
#ifdef CONFIG_ADLIB
7953
4410
{
7973
4430
},
7974
4431
#endif
7975
4432
4433
#ifdef CONFIG_AC97
4434
{
4435
"ac97",
4436
"Intel 82801AA AC97 Audio",
4437
0,
4438
0,
4439
{ .init_pci = ac97_init }
4440
},
4441
#endif
4442
4443
#ifdef CONFIG_ES1370
7976
4444
{
7977
4445
"es1370",
7978
4446
"ENSONIQ AudioPCI ES1370",
7982
4450
},
7983
4451
#endif
7984
4452
4453
#endif /* HAS_AUDIO_CHOICE */
4454
7985
4455
{ NULL, NULL, 0, 0, { NULL } }
7986
4456
};
7987
4457
8044
4514
}
8045
4515
#endif
8046
4516
4517
static void select_vgahw (const char *p)
4518
{
4519
const char *opts;
4520
4521
if (strstart(p, "std", &opts)) {
4522
std_vga_enabled = 1;
4523
cirrus_vga_enabled = 0;
4524
vmsvga_enabled = 0;
4525
} else if (strstart(p, "cirrus", &opts)) {
4526
cirrus_vga_enabled = 1;
4527
std_vga_enabled = 0;
4528
vmsvga_enabled = 0;
4529
} else if (strstart(p, "vmware", &opts)) {
4530
cirrus_vga_enabled = 0;
4531
std_vga_enabled = 0;
4532
vmsvga_enabled = 1;
4533
} else if (strstart(p, "none", &opts)) {
4534
cirrus_vga_enabled = 0;
4535
std_vga_enabled = 0;
4536
vmsvga_enabled = 0;
4537
} else {
4538
invalid_vga:
4539
fprintf(stderr, "Unknown vga type: %s\n", p);
4540
exit(1);
4541
}
4542
while (*opts) {
4543
const char *nextopt;
4544
4545
if (strstart(opts, ",retrace=", &nextopt)) {
4546
opts = nextopt;
4547
if (strstart(opts, "dumb", &nextopt))
4548
vga_retrace_method = VGA_RETRACE_DUMB;
4549
else if (strstart(opts, "precise", &nextopt))
4550
vga_retrace_method = VGA_RETRACE_PRECISE;
4551
else goto invalid_vga;
4552
} else goto invalid_vga;
4553
opts = nextopt;
4554
}
4555
}
4556
8047
4557
#ifdef _WIN32
8048
4558
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
8049
4559
{
8052
4562
}
8053
4563
#endif
8054
4564
4565
static int qemu_uuid_parse(const char *str, uint8_t *uuid)
4566
{
4567
int ret;
4568
4569
if(strlen(str) != 36)
4570
return -1;
4571
4572
ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4573
&uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4574
&uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4575
4576
if(ret != 16)
4577
return -1;
4578
4579
return 0;
4580
}
4581
8055
4582
#define MAX_NET_CLIENTS 32
8056
4583
8057
int main(int argc, char **argv)
4584
#ifndef _WIN32
4585
4586
static void termsig_handler(int signal)
4587
{
4588
qemu_system_shutdown_request();
4589
}
4590
4591
static void termsig_setup(void)
4592
{
4593
struct sigaction act;
4594
4595
memset(&act, 0, sizeof(act));
4596
act.sa_handler = termsig_handler;
4597
sigaction(SIGINT, &act, NULL);
4598
sigaction(SIGHUP, &act, NULL);
4599
sigaction(SIGTERM, &act, NULL);
4600
}
4601
4602
#endif
4603
4604
int main(int argc, char **argv, char **envp)
8058
4605
{
8059
4606
#ifdef CONFIG_GDBSTUB
8060
4607
int use_gdbstub;
8066
4613
const char *initrd_filename;
8067
4614
const char *kernel_filename, *kernel_cmdline;
8068
4615
const char *boot_devices = "";
8069
DisplayState *ds = &display_state;
4616
DisplayState *ds;
4617
DisplayChangeListener *dcl;
8070
4618
int cyls, heads, secs, translation;
8071
char net_clients[MAX_NET_CLIENTS][256];
4619
const char *net_clients[MAX_NET_CLIENTS];
8072
4620
int nb_net_clients;
4621
const char *bt_opts[MAX_BT_CMDLINE];
4622
int nb_bt_opts;
8073
4623
int hda_index;
8074
4624
int optind;
8075
4625
const char *r, *optarg;
8076
CharDriverState *monitor_hd;
8077
char monitor_device[128];
8078
char serial_devices[MAX_SERIAL_PORTS][128];
4626
CharDriverState *monitor_hd = NULL;
4627
const char *monitor_device;
4628
const char *serial_devices[MAX_SERIAL_PORTS];
8079
4629
int serial_device_index;
8080
char parallel_devices[MAX_PARALLEL_PORTS][128];
4630
const char *parallel_devices[MAX_PARALLEL_PORTS];
8081
4631
int parallel_device_index;
4632
const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4633
int virtio_console_index;
8082
4634
const char *loadvm = NULL;
8083
4635
QEMUMachine *machine;
8084
4636
const char *cpu_model;
8085
char usb_devices[MAX_USB_CMDLINE][128];
4637
const char *usb_devices[MAX_USB_CMDLINE];
8086
4638
int usb_devices_index;
8087
4639
int fds[2];
4640
int tb_size;
8088
4641
const char *pid_file = NULL;
8089
VLANState *vlan;
4642
int autostart;
4643
const char *incoming = NULL;
4644
int fd = 0;
4645
struct passwd *pwd = NULL;
4646
const char *chroot_dir = NULL;
4647
const char *run_as = NULL;
4648
4649
qemu_cache_utils_init(envp);
8090
4650
8091
4651
LIST_INIT (&vm_change_state_head);
8092
4652
#ifndef _WIN32
8123
4683
machine = first_machine;
8124
4684
cpu_model = NULL;
8125
4685
initrd_filename = NULL;
8126
ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
4686
ram_size = 0;
8127
4687
vga_ram_size = VGA_RAM_SIZE;
8128
4688
#ifdef CONFIG_GDBSTUB
8129
4689
use_gdbstub = 0;
8131
4691
#endif
8132
4692
snapshot = 0;
8133
4693
nographic = 0;
4694
curses = 0;
8134
4695
kernel_filename = NULL;
8135
4696
kernel_cmdline = "";
8136
4697
cyls = heads = secs = 0;
8137
4698
translation = BIOS_ATA_TRANSLATION_AUTO;
8138
pstrcpy(monitor_device, sizeof(monitor_device), "vc");
4699
monitor_device = "vc";
8139
4700
8140
pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
4701
serial_devices[0] = "vc:80Cx24C";
8141
4702
for(i = 1; i < MAX_SERIAL_PORTS; i++)
8142
serial_devices[i][0] = '\0';
4703
serial_devices[i] = NULL;
8143
4704
serial_device_index = 0;
8144
4705
8145
pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
4706
parallel_devices[0] = "vc:80Cx24C";
8146
4707
for(i = 1; i < MAX_PARALLEL_PORTS; i++)
8147
parallel_devices[i][0] = '\0';
4708
parallel_devices[i] = NULL;
8148
4709
parallel_device_index = 0;
8149
4710
4711
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4712
virtio_consoles[i] = NULL;
4713
virtio_console_index = 0;
4714
8150
4715
usb_devices_index = 0;
8151
4716
8152
4717
nb_net_clients = 0;
4718
nb_bt_opts = 0;
8153
4719
nb_drives = 0;
8154
4720
nb_drives_opt = 0;
8155
4721
hda_index = -1;
8156
4722
8157
4723
nb_nics = 0;
8158
/* default mac address of the first network interface */
4724
4725
tb_size = 0;
4726
autostart= 1;
8159
4727
8160
4728
optind = 1;
8161
4729
for(;;) {
8163
4731
break;
8164
4732
r = argv[optind];
8165
4733
if (r[0] != '-') {
8166
hda_index = drive_add(HD_ALIAS, argv[optind++], 0);
4734
hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
8167
4735
} else {
8168
4736
const QEMUOption *popt;
8169
4737
8224
4792
break;
8225
4793
case QEMU_OPTION_hda:
8226
4794
if (cyls == 0)
8227
hda_index = drive_add(HD_ALIAS, optarg, 0);
4795
hda_index = drive_add(optarg, HD_ALIAS, 0);
8228
4796
else
8229
hda_index = drive_add(HD_ALIAS
4797
hda_index = drive_add(optarg, HD_ALIAS
8230
4798
",cyls=%d,heads=%d,secs=%d%s",
8231
optarg, 0, cyls, heads, secs,
4799
0, cyls, heads, secs,
8232
4800
translation == BIOS_ATA_TRANSLATION_LBA ?
8233
4801
",trans=lba" :
8234
4802
translation == BIOS_ATA_TRANSLATION_NONE ?
8237
4805
case QEMU_OPTION_hdb:
8238
4806
case QEMU_OPTION_hdc:
8239
4807
case QEMU_OPTION_hdd:
8240
drive_add(HD_ALIAS, optarg, popt->index - QEMU_OPTION_hda);
4808
drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
8241
4809
break;
8242
4810
case QEMU_OPTION_drive:
8243
drive_add("%s", optarg);
4811
drive_add(NULL, "%s", optarg);
8244
4812
break;
8245
4813
case QEMU_OPTION_mtdblock:
8246
drive_add(MTD_ALIAS, optarg);
4814
drive_add(optarg, MTD_ALIAS);
8247
4815
break;
8248
4816
case QEMU_OPTION_sd:
8249
drive_add("file=\"%s\"," SD_ALIAS, optarg);
4817
drive_add(optarg, SD_ALIAS);
8250
4818
break;
8251
4819
case QEMU_OPTION_pflash:
8252
drive_add(PFLASH_ALIAS, optarg);
4820
drive_add(optarg, PFLASH_ALIAS);
8253
4821
break;
8254
4822
case QEMU_OPTION_snapshot:
8255
4823
snapshot = 1;
8289
4857
exit(1);
8290
4858
}
8291
4859
if (hda_index != -1)
8292
snprintf(drives_opt[hda_index] +
8293
strlen(drives_opt[hda_index]),
8294
sizeof(drives_opt[0]) -
8295
strlen(drives_opt[hda_index]),
8296
",cyls=%d,heads=%d,secs=%d%s",
8297
cyls, heads, secs,
4860
snprintf(drives_opt[hda_index].opt,
4861
sizeof(drives_opt[hda_index].opt),
4862
HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4863
0, cyls, heads, secs,
8298
4864
translation == BIOS_ATA_TRANSLATION_LBA ?
8299
4865
",trans=lba" :
8300
4866
translation == BIOS_ATA_TRANSLATION_NONE ?
8302
4868
}
8303
4869
break;
8304
4870
case QEMU_OPTION_nographic:
8305
pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
8306
pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "null");
8307
pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
8308
4871
nographic = 1;
8309
4872
break;
4873
#ifdef CONFIG_CURSES
4874
case QEMU_OPTION_curses:
4875
curses = 1;
4876
break;
4877
#endif
8310
4878
case QEMU_OPTION_portrait:
8311
4879
graphic_rotate = 1;
8312
4880
break;
8317
4885
kernel_cmdline = optarg;
8318
4886
break;
8319
4887
case QEMU_OPTION_cdrom:
8320
drive_add("file=\"%s\"," CDROM_ALIAS, optarg);
4888
drive_add(optarg, CDROM_ALIAS);
8321
4889
break;
8322
4890
case QEMU_OPTION_boot:
8323
4891
boot_devices = optarg;
8352
4920
break;
8353
4921
case QEMU_OPTION_fda:
8354
4922
case QEMU_OPTION_fdb:
8355
drive_add("file=\"%s\"," FD_ALIAS, optarg,
8356
popt->index - QEMU_OPTION_fda);
4923
drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
8357
4924
break;
8358
4925
#ifdef TARGET_I386
8359
4926
case QEMU_OPTION_no_fd_bootchk:
8360
4927
fd_bootchk = 0;
8361
4928
break;
8362
4929
#endif
8363
case QEMU_OPTION_no_code_copy:
8364
code_copy_enabled = 0;
8365
break;
8366
4930
case QEMU_OPTION_net:
8367
4931
if (nb_net_clients >= MAX_NET_CLIENTS) {
8368
4932
fprintf(stderr, "qemu: too many network clients\n");
8369
4933
exit(1);
8370
4934
}
8371
pstrcpy(net_clients[nb_net_clients],
8372
sizeof(net_clients[0]),
8373
optarg);
4935
net_clients[nb_net_clients] = optarg;
8374
4936
nb_net_clients++;
8375
4937
break;
8376
4938
#ifdef CONFIG_SLIRP
8389
4951
net_slirp_redir(optarg);
8390
4952
break;
8391
4953
#endif
4954
case QEMU_OPTION_bt:
4955
if (nb_bt_opts >= MAX_BT_CMDLINE) {
4956
fprintf(stderr, "qemu: too many bluetooth options\n");
4957
exit(1);
4958
}
4959
bt_opts[nb_bt_opts++] = optarg;
4960
break;
8392
4961
#ifdef HAS_AUDIO
8393
4962
case QEMU_OPTION_audio_help:
8394
4963
AUD_help ();
8401
4970
case QEMU_OPTION_h:
8402
4971
help(0);
8403
4972
break;
8404
case QEMU_OPTION_m:
8405
ram_size = atoi(optarg) * 1024 * 1024;
8406
if (ram_size <= 0)
8407
help(1);
8408
if (ram_size > PHYS_RAM_MAX_SIZE) {
8409
fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
8410
PHYS_RAM_MAX_SIZE / (1024 * 1024));
8411
exit(1);
8412
}
4973
case QEMU_OPTION_m: {
4974
uint64_t value;
4975
char *ptr;
4976
4977
value = strtoul(optarg, &ptr, 10);
4978
switch (*ptr) {
4979
case 0: case 'M': case 'm':
4980
value <<= 20;
4981
break;
4982
case 'G': case 'g':
4983
value <<= 30;
4984
break;
4985
default:
4986
fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4987
exit(1);
4988
}
4989
4990
/* On 32-bit hosts, QEMU is limited by virtual address space */
4991
if (value > (2047 << 20)
4992
#ifndef USE_KQEMU
4993
&& HOST_LONG_BITS == 32
4994
#endif
4995
) {
4996
fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4997
exit(1);
4998
}
4999
if (value != (uint64_t)(ram_addr_t)value) {
5000
fprintf(stderr, "qemu: ram size too large\n");
5001
exit(1);
5002
}
5003
ram_size = value;
8413
5004
break;
5005
}
8414
5006
case QEMU_OPTION_d:
8415
5007
{
8416
5008
int mask;
8417
CPULogItem *item;
5009
const CPULogItem *item;
8418
5010
8419
5011
mask = cpu_str_to_log_mask(optarg);
8420
5012
if (!mask) {
8450
5042
case QEMU_OPTION_localtime:
8451
5043
rtc_utc = 0;
8452
5044
break;
8453
case QEMU_OPTION_cirrusvga:
8454
cirrus_vga_enabled = 1;
8455
vmsvga_enabled = 0;
8456
break;
8457
case QEMU_OPTION_vmsvga:
8458
cirrus_vga_enabled = 0;
8459
vmsvga_enabled = 1;
8460
break;
8461
case QEMU_OPTION_std_vga:
8462
cirrus_vga_enabled = 0;
8463
vmsvga_enabled = 0;
5045
case QEMU_OPTION_vga:
5046
select_vgahw (optarg);
8464
5047
break;
8465
5048
case QEMU_OPTION_g:
8466
5049
{
8505
5088
break;
8506
5089
}
8507
5090
case QEMU_OPTION_monitor:
8508
pstrcpy(monitor_device, sizeof(monitor_device), optarg);
5091
monitor_device = optarg;
8509
5092
break;
8510
5093
case QEMU_OPTION_serial:
8511
5094
if (serial_device_index >= MAX_SERIAL_PORTS) {
8512
5095
fprintf(stderr, "qemu: too many serial ports\n");
8513
5096
exit(1);
8514
5097
}
8515
pstrcpy(serial_devices[serial_device_index],
8516
sizeof(serial_devices[0]), optarg);
5098
serial_devices[serial_device_index] = optarg;
8517
5099
serial_device_index++;
8518
5100
break;
5101
case QEMU_OPTION_virtiocon:
5102
if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5103
fprintf(stderr, "qemu: too many virtio consoles\n");
5104
exit(1);
5105
}
5106
virtio_consoles[virtio_console_index] = optarg;
5107
virtio_console_index++;
5108
break;
8519
5109
case QEMU_OPTION_parallel:
8520
5110
if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8521
5111
fprintf(stderr, "qemu: too many parallel ports\n");
8522
5112
exit(1);
8523
5113
}
8524
pstrcpy(parallel_devices[parallel_device_index],
8525
sizeof(parallel_devices[0]), optarg);
5114
parallel_devices[parallel_device_index] = optarg;
8526
5115
parallel_device_index++;
8527
5116
break;
8528
5117
case QEMU_OPTION_loadvm:
8541
5130
case QEMU_OPTION_no_quit:
8542
5131
no_quit = 1;
8543
5132
break;
5133
case QEMU_OPTION_sdl:
5134
sdl = 1;
5135
break;
8544
5136
#endif
8545
5137
case QEMU_OPTION_pidfile:
8546
5138
pid_file = optarg;
8549
5141
case QEMU_OPTION_win2k_hack:
8550
5142
win2k_install_hack = 1;
8551
5143
break;
5144
case QEMU_OPTION_rtc_td_hack:
5145
rtc_td_hack = 1;
5146
break;
5147
case QEMU_OPTION_acpitable:
5148
if(acpi_table_add(optarg) < 0) {
5149
fprintf(stderr, "Wrong acpi table provided\n");
5150
exit(1);
5151
}
5152
break;
8552
5153
#endif
8553
5154
#ifdef USE_KQEMU
8554
5155
case QEMU_OPTION_no_kqemu:
8558
5159
kqemu_allowed = 2;
8559
5160
break;
8560
5161
#endif
5162
#ifdef CONFIG_KVM
5163
case QEMU_OPTION_enable_kvm:
5164
kvm_allowed = 1;
5165
#ifdef USE_KQEMU
5166
kqemu_allowed = 0;
5167
#endif
5168
break;
5169
#endif
8561
5170
case QEMU_OPTION_usb:
8562
5171
usb_enabled = 1;
8563
5172
break;
8567
5176
fprintf(stderr, "Too many USB devices\n");
8568
5177
exit(1);
8569
5178
}
8570
pstrcpy(usb_devices[usb_devices_index],
8571
sizeof(usb_devices[usb_devices_index]),
8572
optarg);
5179
usb_devices[usb_devices_index] = optarg;
8573
5180
usb_devices_index++;
8574
5181
break;
8575
5182
case QEMU_OPTION_smp:
8576
5183
smp_cpus = atoi(optarg);
8577
if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
5184
if (smp_cpus < 1) {
8578
5185
fprintf(stderr, "Invalid number of CPUs\n");
8579
5186
exit(1);
8580
5187
}
8585
5192
case QEMU_OPTION_no_acpi:
8586
5193
acpi_enabled = 0;
8587
5194
break;
5195
case QEMU_OPTION_no_hpet:
5196
no_hpet = 1;
5197
break;
8588
5198
case QEMU_OPTION_no_reboot:
8589
5199
no_reboot = 1;
8590
5200
break;
5201
case QEMU_OPTION_no_shutdown:
5202
no_shutdown = 1;
5203
break;
8591
5204
case QEMU_OPTION_show_cursor:
8592
5205
cursor_hide = 0;
8593
5206
break;
5207
case QEMU_OPTION_uuid:
5208
if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5209
fprintf(stderr, "Fail to parse UUID string."
5210
" Wrong format.\n");
5211
exit(1);
5212
}
5213
break;
8594
5214
case QEMU_OPTION_daemonize:
8595
5215
daemonize = 1;
8596
5216
break;
8608
5228
case QEMU_OPTION_name:
8609
5229
qemu_name = optarg;
8610
5230
break;
8611
#ifdef TARGET_SPARC
5231
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
8612
5232
case QEMU_OPTION_prom_env:
8613
5233
if (nb_prom_envs >= MAX_PROM_ENVS) {
8614
5234
fprintf(stderr, "Too many prom variables\n");
8621
5241
#ifdef TARGET_ARM
8622
5242
case QEMU_OPTION_old_param:
8623
5243
old_param = 1;
5244
break;
8624
5245
#endif
8625
5246
case QEMU_OPTION_clock:
8626
5247
configure_alarms(optarg);
8628
5249
case QEMU_OPTION_startdate:
8629
5250
{
8630
5251
struct tm tm;
5252
time_t rtc_start_date;
8631
5253
if (!strcmp(optarg, "now")) {
8632
rtc_start_date = -1;
5254
rtc_date_offset = -1;
8633
5255
} else {
8634
5256
if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
8635
5257
&tm.tm_year,
8658
5280
"'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
8659
5281
exit(1);
8660
5282
}
5283
rtc_date_offset = time(NULL) - rtc_start_date;
8661
5284
}
8662
5285
}
8663
5286
break;
5287
case QEMU_OPTION_tb_size:
5288
tb_size = strtol(optarg, NULL, 0);
5289
if (tb_size < 0)
5290
tb_size = 0;
5291
break;
5292
case QEMU_OPTION_icount:
5293
use_icount = 1;
5294
if (strcmp(optarg, "auto") == 0) {
5295
icount_time_shift = -1;
5296
} else {
5297
icount_time_shift = strtol(optarg, NULL, 0);
5298
}
5299
break;
5300
case QEMU_OPTION_incoming:
5301
incoming = optarg;
5302
break;
5303
case QEMU_OPTION_chroot:
5304
chroot_dir = optarg;
5305
break;
5306
case QEMU_OPTION_runas:
5307
run_as = optarg;
5308
break;
8664
5309
}
8665
5310
}
8666
5311
}
8667
5312
5313
#if defined(CONFIG_KVM) && defined(USE_KQEMU)
5314
if (kvm_allowed && kqemu_allowed) {
5315
fprintf(stderr,
5316
"You can not enable both KVM and kqemu at the same time\n");
5317
exit(1);
5318
}
5319
#endif
5320
5321
machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5322
if (smp_cpus > machine->max_cpus) {
5323
fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5324
"supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5325
machine->max_cpus);
5326
exit(1);
5327
}
5328
5329
if (nographic) {
5330
if (serial_device_index == 0)
5331
serial_devices[0] = "stdio";
5332
if (parallel_device_index == 0)
5333
parallel_devices[0] = "null";
5334
if (strncmp(monitor_device, "vc", 2) == 0)
5335
monitor_device = "stdio";
5336
}
5337
8668
5338
#ifndef _WIN32
8669
if (daemonize && !nographic && vnc_display == NULL) {
8670
fprintf(stderr, "Can only daemonize if using -nographic or -vnc\n");
8671
daemonize = 0;
8672
}
8673
8674
5339
if (daemonize) {
8675
5340
pid_t pid;
8676
5341
8708
5373
exit(1);
8709
5374
8710
5375
umask(027);
8711
chdir("/");
8712
5376
8713
5377
signal(SIGTSTP, SIG_IGN);
8714
5378
signal(SIGTTOU, SIG_IGN);
8732
5396
linux_boot = (kernel_filename != NULL);
8733
5397
net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
8734
5398
8735
/* XXX: this should not be: some embedded targets just have flash */
8736
5399
if (!linux_boot && net_boot == 0 &&
8737
nb_drives_opt == 0)
5400
!machine->nodisk_ok && nb_drives_opt == 0)
8738
5401
help(1);
8739
5402
5403
if (!linux_boot && *kernel_cmdline != '\0') {
5404
fprintf(stderr, "-append only allowed with -kernel option\n");
5405
exit(1);
5406
}
5407
5408
if (!linux_boot && initrd_filename != NULL) {
5409
fprintf(stderr, "-initrd only allowed with -kernel option\n");
5410
exit(1);
5411
}
5412
8740
5413
/* boot to floppy or the default cd if no hard disk defined yet */
8741
5414
if (!boot_devices[0]) {
8742
5415
boot_devices = "cad";
8744
5417
setvbuf(stdout, NULL, _IOLBF, 0);
8745
5418
8746
5419
init_timers();
8747
init_timer_alarm();
8748
qemu_aio_init();
5420
if (init_timer_alarm() < 0) {
5421
fprintf(stderr, "could not initialize alarm timer\n");
5422
exit(1);
5423
}
5424
if (use_icount && icount_time_shift < 0) {
5425
use_icount = 2;
5426
/* 125MIPS seems a reasonable initial guess at the guest speed.
5427
It will be corrected fairly quickly anyway. */
5428
icount_time_shift = 3;
5429
init_icount_adjust();
5430
}
8749
5431
8750
5432
#ifdef _WIN32
8751
5433
socket_init();
8754
5436
/* init network clients */
8755
5437
if (nb_net_clients == 0) {
8756
5438
/* if no clients, we use a default config */
8757
pstrcpy(net_clients[0], sizeof(net_clients[0]),
8758
"nic");
8759
pstrcpy(net_clients[1], sizeof(net_clients[0]),
8760
"user");
8761
nb_net_clients = 2;
5439
net_clients[nb_net_clients++] = "nic";
5440
#ifdef CONFIG_SLIRP
5441
net_clients[nb_net_clients++] = "user";
5442
#endif
8762
5443
}
8763
5444
8764
5445
for(i = 0;i < nb_net_clients; i++) {
8765
if (net_client_init(net_clients[i]) < 0)
8766
exit(1);
8767
}
8768
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8769
if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
8770
continue;
8771
if (vlan->nb_guest_devs == 0) {
8772
fprintf(stderr, "Invalid vlan (%d) with no nics\n", vlan->id);
8773
exit(1);
8774
}
8775
if (vlan->nb_host_devs == 0)
8776
fprintf(stderr,
8777
"Warning: vlan %d is not connected to host network\n",
8778
vlan->id);
8779
}
5446
if (net_client_parse(net_clients[i]) < 0)
5447
exit(1);
5448
}
5449
net_client_check();
8780
5450
8781
5451
#ifdef TARGET_I386
8782
5452
/* XXX: this should be moved in the PC machine instantiation code */
8807
5477
}
8808
5478
#endif
8809
5479
5480
/* init the bluetooth world */
5481
for (i = 0; i < nb_bt_opts; i++)
5482
if (bt_parse(bt_opts[i]))
5483
exit(1);
5484
8810
5485
/* init the memory */
8811
phys_ram_size = ram_size + vga_ram_size + MAX_BIOS_SIZE;
5486
phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
5487
5488
if (machine->ram_require & RAMSIZE_FIXED) {
5489
if (ram_size > 0) {
5490
if (ram_size < phys_ram_size) {
5491
fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
5492
machine->name, (unsigned long long) phys_ram_size);
5493
exit(-1);
5494
}
5495
5496
phys_ram_size = ram_size;
5497
} else
5498
ram_size = phys_ram_size;
5499
} else {
5500
if (ram_size == 0)
5501
ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5502
5503
phys_ram_size += ram_size;
5504
}
8812
5505
8813
5506
phys_ram_base = qemu_vmalloc(phys_ram_size);
8814
5507
if (!phys_ram_base) {
8816
5509
exit(1);
8817
5510
}
8818
5511
5512
/* init the dynamic translator */
5513
cpu_exec_init_all(tb_size * 1024 * 1024);
5514
8819
5515
bdrv_init();
8820
5516
8821
5517
/* we always create the cdrom drive, even if no disk is there */
8822
5518
8823
5519
if (nb_drives_opt < MAX_DRIVES)
8824
drive_add(CDROM_ALIAS);
5520
drive_add(NULL, CDROM_ALIAS);
8825
5521
8826
5522
/* we always create at least one floppy */
8827
5523
8828
5524
if (nb_drives_opt < MAX_DRIVES)
8829
drive_add(FD_ALIAS, 0);
5525
drive_add(NULL, FD_ALIAS, 0);
8830
5526
8831
5527
/* we always create one sd slot, even if no card is in it */
8832
5528
8833
5529
if (nb_drives_opt < MAX_DRIVES)
8834
drive_add(SD_ALIAS);
5530
drive_add(NULL, SD_ALIAS);
8835
5531
8836
5532
/* open the virtual block devices */
8837
5533
8838
5534
for(i = 0; i < nb_drives_opt; i++)
8839
if (drive_init(drives_opt[i], snapshot, machine) == -1)
5535
if (drive_init(&drives_opt[i], snapshot, machine) == -1)
8840
5536
exit(1);
8841
5537
8842
5538
register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
8843
register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8844
8845
init_ioports();
8846
8847
/* terminal init */
8848
memset(&display_state, 0, sizeof(display_state));
8849
if (nographic) {
8850
/* nearly nothing to do */
8851
dumb_display_init(ds);
8852
} else if (vnc_display != NULL) {
8853
vnc_display_init(ds);
8854
if (vnc_display_open(ds, vnc_display) < 0)
8855
exit(1);
8856
} else {
8857
#if defined(CONFIG_SDL)
8858
sdl_display_init(ds, full_screen, no_frame);
8859
#elif defined(CONFIG_COCOA)
8860
cocoa_display_init(ds, full_screen);
8861
#else
8862
dumb_display_init(ds);
5539
register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5540
5541
#ifndef _WIN32
5542
/* must be after terminal init, SDL library changes signal handlers */
5543
termsig_setup();
8863
5544
#endif
8864
}
8865
5545
8866
5546
/* Maintain compatibility with multiple stdio monitors */
8867
5547
if (!strcmp(monitor_device,"stdio")) {
8868
5548
for (i = 0; i < MAX_SERIAL_PORTS; i++) {
8869
if (!strcmp(serial_devices[i],"mon:stdio")) {
8870
monitor_device[0] = '\0';
5549
const char *devname = serial_devices[i];
5550
if (devname && !strcmp(devname,"mon:stdio")) {
5551
monitor_device = NULL;
8871
5552
break;
8872
} else if (!strcmp(serial_devices[i],"stdio")) {
8873
monitor_device[0] = '\0';
8874
pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "mon:stdio");
5553
} else if (devname && !strcmp(devname,"stdio")) {
5554
monitor_device = NULL;
5555
serial_devices[i] = "mon:stdio";
8875
5556
break;
8876
5557
}
8877
5558
}
8878
5559
}
8879
if (monitor_device[0] != '\0') {
8880
monitor_hd = qemu_chr_open(monitor_device);
5560
5561
if (kvm_enabled()) {
5562
int ret;
5563
5564
ret = kvm_init(smp_cpus);
5565
if (ret < 0) {
5566
fprintf(stderr, "failed to initialize KVM\n");
5567
exit(1);
5568
}
5569
}
5570
5571
if (monitor_device) {
5572
monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
8881
5573
if (!monitor_hd) {
8882
5574
fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
8883
5575
exit(1);
8884
5576
}
8885
monitor_init(monitor_hd, !nographic);
8886
5577
}
8887
5578
8888
5579
for(i = 0; i < MAX_SERIAL_PORTS; i++) {
8889
5580
const char *devname = serial_devices[i];
8890
if (devname[0] != '\0' && strcmp(devname, "none")) {
8891
serial_hds[i] = qemu_chr_open(devname);
5581
if (devname && strcmp(devname, "none")) {
5582
char label[32];
5583
snprintf(label, sizeof(label), "serial%d", i);
5584
serial_hds[i] = qemu_chr_open(label, devname, NULL);
8892
5585
if (!serial_hds[i]) {
8893
5586
fprintf(stderr, "qemu: could not open serial device '%s'\n",
8894
5587
devname);
8895
5588
exit(1);
8896
5589
}
8897
if (strstart(devname, "vc", 0))
8898
qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8899
5590
}
8900
5591
}
8901
5592
8902
5593
for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
8903
5594
const char *devname = parallel_devices[i];
8904
if (devname[0] != '\0' && strcmp(devname, "none")) {
8905
parallel_hds[i] = qemu_chr_open(devname);
5595
if (devname && strcmp(devname, "none")) {
5596
char label[32];
5597
snprintf(label, sizeof(label), "parallel%d", i);
5598
parallel_hds[i] = qemu_chr_open(label, devname, NULL);
8906
5599
if (!parallel_hds[i]) {
8907
5600
fprintf(stderr, "qemu: could not open parallel device '%s'\n",
8908
5601
devname);
8909
5602
exit(1);
8910
5603
}
8911
if (strstart(devname, "vc", 0))
8912
qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
8913
}
8914
}
8915
8916
machine->init(ram_size, vga_ram_size, boot_devices, ds,
5604
}
5605
}
5606
5607
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5608
const char *devname = virtio_consoles[i];
5609
if (devname && strcmp(devname, "none")) {
5610
char label[32];
5611
snprintf(label, sizeof(label), "virtcon%d", i);
5612
virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5613
if (!virtcon_hds[i]) {
5614
fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5615
devname);
5616
exit(1);
5617
}
5618
}
5619
}
5620
5621
machine->init(ram_size, vga_ram_size, boot_devices,
8917
5622
kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
8918
5623
5624
current_machine = machine;
5625
5626
/* Set KVM's vcpu state to qemu's initial CPUState. */
5627
if (kvm_enabled()) {
5628
int ret;
5629
5630
ret = kvm_sync_vcpus();
5631
if (ret < 0) {
5632
fprintf(stderr, "failed to initialize vcpus\n");
5633
exit(1);
5634
}
5635
}
5636
8919
5637
/* init USB devices */
8920
5638
if (usb_enabled) {
8921
5639
for(i = 0; i < usb_devices_index; i++) {
8926
5644
}
8927
5645
}
8928
5646
8929
if (display_state.dpy_refresh) {
8930
display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
8931
qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
5647
if (!display_state)
5648
dumb_display_init();
5649
/* just use the first displaystate for the moment */
5650
ds = display_state;
5651
/* terminal init */
5652
if (nographic) {
5653
if (curses) {
5654
fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5655
exit(1);
5656
}
5657
} else {
5658
#if defined(CONFIG_CURSES)
5659
if (curses) {
5660
/* At the moment curses cannot be used with other displays */
5661
curses_display_init(ds, full_screen);
5662
} else
5663
#endif
5664
{
5665
if (vnc_display != NULL) {
5666
vnc_display_init(ds);
5667
if (vnc_display_open(ds, vnc_display) < 0)
5668
exit(1);
5669
}
5670
#if defined(CONFIG_SDL)
5671
if (sdl || !vnc_display)
5672
sdl_display_init(ds, full_screen, no_frame);
5673
#elif defined(CONFIG_COCOA)
5674
if (sdl || !vnc_display)
5675
cocoa_display_init(ds, full_screen);
5676
#endif
5677
}
5678
}
5679
dpy_resize(ds);
5680
5681
dcl = ds->listeners;
5682
while (dcl != NULL) {
5683
if (dcl->dpy_refresh != NULL) {
5684
ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5685
qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5686
}
5687
dcl = dcl->next;
5688
}
5689
5690
if (nographic || (vnc_display && !sdl)) {
5691
nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5692
qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5693
}
5694
5695
text_consoles_set_display(display_state);
5696
5697
if (monitor_device && monitor_hd)
5698
monitor_init(monitor_hd, !nographic);
5699
5700
for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5701
const char *devname = serial_devices[i];
5702
if (devname && strcmp(devname, "none")) {
5703
char label[32];
5704
snprintf(label, sizeof(label), "serial%d", i);
5705
if (strstart(devname, "vc", 0))
5706
qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5707
}
5708
}
5709
5710
for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5711
const char *devname = parallel_devices[i];
5712
if (devname && strcmp(devname, "none")) {
5713
char label[32];
5714
snprintf(label, sizeof(label), "parallel%d", i);
5715
if (strstart(devname, "vc", 0))
5716
qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5717
}
5718
}
5719
5720
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5721
const char *devname = virtio_consoles[i];
5722
if (virtcon_hds[i] && devname) {
5723
char label[32];
5724
snprintf(label, sizeof(label), "virtcon%d", i);
5725
if (strstart(devname, "vc", 0))
5726
qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5727
}
8932
5728
}
8933
5729
8934
5730
#ifdef CONFIG_GDBSTUB
8946
5742
if (loadvm)
8947
5743
do_loadvm(loadvm);
8948
5744
5745
if (incoming) {
5746
autostart = 0; /* fixme how to deal with -daemonize */
5747
qemu_start_incoming_migration(incoming);
5748
}
5749
8949
5750
{
8950
5751
/* XXX: simplify init */
8951
5752
read_passwords();
8957
5758
if (daemonize) {
8958
5759
uint8_t status = 0;
8959
5760
ssize_t len;
8960
int fd;
8961
5761
8962
5762
again1:
8963
5763
len = write(fds[1], &status, 1);
8967
5767
if (len != 1)
8968
5768
exit(1);
8969
5769
5770
chdir("/");
8970
5771
TFR(fd = open("/dev/null", O_RDWR));
8971
5772
if (fd == -1)
8972
5773
exit(1);
8973
8974
dup2(fd, 0);
8975
dup2(fd, 1);
8976
dup2(fd, 2);
8977
8978
close(fd);
5774
}
5775
5776
#ifndef _WIN32
5777
if (run_as) {
5778
pwd = getpwnam(run_as);
5779
if (!pwd) {
5780
fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5781
exit(1);
5782
}
5783
}
5784
5785
if (chroot_dir) {
5786
if (chroot(chroot_dir) < 0) {
5787
fprintf(stderr, "chroot failed\n");
5788
exit(1);
5789
}
5790
chdir("/");
5791
}
5792
5793
if (run_as) {
5794
if (setgid(pwd->pw_gid) < 0) {
5795
fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5796
exit(1);
5797
}
5798
if (setuid(pwd->pw_uid) < 0) {
5799
fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5800
exit(1);
5801
}
5802
if (setuid(0) != -1) {
5803
fprintf(stderr, "Dropping privileges failed\n");
5804
exit(1);
5805
}
5806
}
5807
#endif
5808
5809
if (daemonize) {
5810
dup2(fd, 0);
5811
dup2(fd, 1);
5812
dup2(fd, 2);
5813
5814
close(fd);
8979
5815
}
8980
5816
8981
5817
main_loop();
8982
5818
quit_timers();
8983
8984
#if !defined(_WIN32)
8985
/* close network clients */
8986
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8987
VLANClientState *vc;
8988
8989
for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
8990
if (vc->fd_read == tap_receive) {
8991
char ifname[64];
8992
TAPState *s = vc->opaque;
8993
8994
if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
8995
s->down_script[0])
8996
launch_script(s->down_script, ifname, s->fd);
8997
}
8998
}
8999
}
9000
#endif
5819
net_cleanup();
5820
9001
5821
return 0;
9002
5822
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1