« back to all changes in this revision
Viewing changes to vl.c
- browse files at revision 8472
- compare with another revision
- download diff
- download tarball
- view history from revision 8472
- Committer: Blue Swirl
- Date: 2009-08-31 15:14:40 UTC
- Revision ID: git-v1:528e93a9787ccfc59582a44035f5f342caf5b84f
Fix breakage due to __thread
Thread-local storage is not supported on all hosts.
Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
Thread-local storage is not supported on all hosts.
Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
- files added:
- .gitignore
- block
- bsd-user
- bsd-user/freebsd
- bsd-user/i386
- bsd-user/netbsd
- bsd-user/openbsd
- bsd-user/sparc
- bsd-user/sparc64
- bsd-user/x86_64
- gdb-xml
- hw/ide
- linux-user/microblaze
- pc-bios/bios-pq
- pc-bios/keymaps
- pc-bios/optionrom
- pc-bios/vgabios-pq
- target-microblaze
- tcg/ppc64
- tests/alpha
- files removed:
- audio/sys-queue.h
- keymaps
- files modified:
- COPYING
added
removed
vl.c
21
21
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
22
* THE SOFTWARE.
23
23
*/
24
#include "hw/hw.h"
25
#include "hw/boards.h"
26
#include "hw/usb.h"
27
#include "hw/pcmcia.h"
28
#include "hw/pc.h"
29
#include "hw/audiodev.h"
30
#include "hw/isa.h"
31
#include "hw/baum.h"
32
#include "net.h"
33
#include "console.h"
34
#include "sysemu.h"
35
#include "gdbstub.h"
36
#include "qemu-timer.h"
37
#include "qemu-char.h"
38
#include "block.h"
39
#include "audio/audio.h"
40
41
24
#include <unistd.h>
42
25
#include <fcntl.h>
43
26
#include <signal.h>
46
29
#include <sys/time.h>
47
30
#include <zlib.h>
48
31
32
/* Needed early for CONFIG_BSD etc. */
33
#include "config-host.h"
34
/* Needed early to override system queue definitions on BSD */
35
#include "sys-queue.h"
36
49
37
#ifndef _WIN32
38
#include <libgen.h>
39
#include <pwd.h>
50
40
#include <sys/times.h>
51
41
#include <sys/wait.h>
52
42
#include <termios.h>
53
#include <sys/poll.h>
54
43
#include <sys/mman.h>
55
44
#include <sys/ioctl.h>
45
#include <sys/resource.h>
56
46
#include <sys/socket.h>
57
47
#include <netinet/in.h>
48
#include <net/if.h>
49
#if defined(__NetBSD__)
50
#include <net/if_tap.h>
51
#endif
52
#ifdef __linux__
53
#include <linux/if_tun.h>
54
#endif
55
#include <arpa/inet.h>
58
56
#include <dirent.h>
59
57
#include <netdb.h>
60
58
#include <sys/select.h>
61
#include <arpa/inet.h>
62
#ifdef _BSD
59
#ifdef CONFIG_BSD
63
60
#include <sys/stat.h>
64
#ifndef __APPLE__
61
#if defined(__FreeBSD__) || defined(__DragonFly__)
65
62
#include <libutil.h>
63
#else
64
#include <util.h>
66
65
#endif
67
66
#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
68
67
#include <freebsd/stdlib.h>
69
68
#else
70
#ifndef __sun__
71
#include <linux/if.h>
72
#include <linux/if_tun.h>
69
#ifdef __linux__
73
70
#include <pty.h>
74
71
#include <malloc.h>
75
72
#include <linux/rtc.h>
73
#include <sys/prctl.h>
76
74
77
75
/* For the benefit of older linux systems which don't supply it,
78
76
we use a local copy of hpet.h. */
81
79
82
80
#include <linux/ppdev.h>
83
81
#include <linux/parport.h>
84
#else
82
#endif
83
#ifdef __sun__
85
84
#include <sys/stat.h>
86
85
#include <sys/ethernet.h>
87
86
#include <sys/sockio.h>
97
96
#include <stropts.h>
98
97
#endif
99
98
#endif
100
#else
101
#include <winsock2.h>
102
int inet_aton(const char *cp, struct in_addr *ia);
103
#endif
104
105
#if defined(CONFIG_SLIRP)
106
#include "libslirp.h"
99
#endif
100
101
#if defined(__OpenBSD__)
102
#include <util.h>
103
#endif
104
105
#if defined(CONFIG_VDE)
106
#include <libvdeplug.h>
107
107
#endif
108
108
109
109
#ifdef _WIN32
110
#include <malloc.h>
111
#include <sys/timeb.h>
110
#include <windows.h>
112
111
#include <mmsystem.h>
113
#define getopt_long_only getopt_long
114
#define memalign(align, size) malloc(size)
115
112
#endif
116
113
117
#include "qemu_socket.h"
118
119
114
#ifdef CONFIG_SDL
120
#ifdef __APPLE__
121
#include <SDL/SDL.h>
115
#if defined(__APPLE__) || defined(main)
116
#include <SDL.h>
117
int qemu_main(int argc, char **argv, char **envp);
118
int main(int argc, char **argv)
119
{
120
return qemu_main(argc, argv, NULL);
121
}
122
#undef main
123
#define main qemu_main
122
124
#endif
123
125
#endif /* CONFIG_SDL */
124
126
127
129
#define main qemu_main
128
130
#endif /* CONFIG_COCOA */
129
131
132
#include "hw/hw.h"
133
#include "hw/boards.h"
134
#include "hw/usb.h"
135
#include "hw/pcmcia.h"
136
#include "hw/pc.h"
137
#include "hw/audiodev.h"
138
#include "hw/isa.h"
139
#include "hw/baum.h"
140
#include "hw/bt.h"
141
#include "hw/watchdog.h"
142
#include "hw/smbios.h"
143
#include "hw/xen.h"
144
#include "hw/qdev.h"
145
#include "bt-host.h"
146
#include "net.h"
147
#include "monitor.h"
148
#include "console.h"
149
#include "sysemu.h"
150
#include "gdbstub.h"
151
#include "qemu-timer.h"
152
#include "qemu-char.h"
153
#include "cache-utils.h"
154
#include "block.h"
155
#include "dma.h"
156
#include "audio/audio.h"
157
#include "migration.h"
158
#include "kvm.h"
159
#include "balloon.h"
160
#include "qemu-option.h"
161
#include "qemu-config.h"
162
130
163
#include "disas.h"
131
164
132
165
#include "exec-all.h"
133
166
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
//#define DEBUG_UNUSED_IOPORT
143
//#define DEBUG_IOPORT
144
145
#ifdef TARGET_PPC
146
#define DEFAULT_RAM_SIZE 144
147
#else
167
#include "qemu_socket.h"
168
169
#include "slirp/libslirp.h"
170
171
//#define DEBUG_NET
172
//#define DEBUG_SLIRP
173
148
174
#define DEFAULT_RAM_SIZE 128
149
#endif
150
/* in ms */
151
#define GUI_REFRESH_INTERVAL 30
152
153
/* Max number of USB devices that can be specified on the commandline. */
154
#define MAX_USB_CMDLINE 8
155
156
/* XXX: use a two level table to limit memory usage */
157
#define MAX_IOPORTS 65536
158
159
const char *bios_dir = CONFIG_QEMU_SHAREDIR;
175
176
static const char *data_dir;
160
177
const char *bios_name = NULL;
161
void *ioport_opaque[MAX_IOPORTS];
162
IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
163
IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
164
178
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
165
179
to store the VM snapshots */
166
DriveInfo drives_table[MAX_DRIVES+1];
167
int nb_drives;
168
/* point to the block driver where the snapshots are managed */
169
BlockDriverState *bs_snapshots;
170
int vga_ram_size;
171
static DisplayState display_state;
172
int nographic;
173
int curses;
180
struct drivelist drives = TAILQ_HEAD_INITIALIZER(drives);
181
struct driveoptlist driveopts = TAILQ_HEAD_INITIALIZER(driveopts);
182
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
183
static DisplayState *display_state;
184
DisplayType display_type = DT_DEFAULT;
174
185
const char* keyboard_layout = NULL;
175
186
int64_t ticks_per_sec;
176
187
ram_addr_t ram_size;
177
int pit_min_timer_count = 0;
178
188
int nb_nics;
179
189
NICInfo nd_table[MAX_NICS];
180
190
int vm_running;
191
int autostart;
181
192
static int rtc_utc = 1;
182
193
static int rtc_date_offset = -1; /* -1 means no change */
183
int cirrus_vga_enabled = 1;
184
int vmsvga_enabled = 0;
194
int vga_interface_type = VGA_CIRRUS;
185
195
#ifdef TARGET_SPARC
186
196
int graphic_width = 1024;
187
197
int graphic_height = 768;
191
201
int graphic_height = 600;
192
202
int graphic_depth = 15;
193
203
#endif
194
int full_screen = 0;
195
int no_frame = 0;
204
static int full_screen = 0;
205
#ifdef CONFIG_SDL
206
static int no_frame = 0;
207
#endif
196
208
int no_quit = 0;
197
209
CharDriverState *serial_hds[MAX_SERIAL_PORTS];
198
210
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
211
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
199
212
#ifdef TARGET_I386
200
213
int win2k_install_hack = 0;
214
int rtc_td_hack = 0;
201
215
#endif
202
216
int usb_enabled = 0;
203
static VLANState *first_vlan;
217
int singlestep = 0;
204
218
int smp_cpus = 1;
219
int max_cpus = 0;
220
int smp_cores = 1;
221
int smp_threads = 1;
205
222
const char *vnc_display;
206
#if defined(TARGET_SPARC)
207
#define MAX_CPUS 16
208
#elif defined(TARGET_I386)
209
#define MAX_CPUS 255
210
#else
211
#define MAX_CPUS 1
212
#endif
213
223
int acpi_enabled = 1;
224
int no_hpet = 0;
214
225
int fd_bootchk = 1;
215
226
int no_reboot = 0;
216
227
int no_shutdown = 0;
217
228
int cursor_hide = 1;
218
229
int graphic_rotate = 0;
230
uint8_t irq0override = 1;
231
#ifndef _WIN32
219
232
int daemonize = 0;
233
#endif
234
const char *watchdog;
220
235
const char *option_rom[MAX_OPTION_ROMS];
221
236
int nb_option_roms;
222
237
int semihosting_enabled = 0;
223
int autostart = 1;
224
238
#ifdef TARGET_ARM
225
239
int old_param = 0;
226
240
#endif
227
241
const char *qemu_name;
228
242
int alt_grab = 0;
229
#ifdef TARGET_SPARC
243
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
230
244
unsigned int nb_prom_envs = 0;
231
245
const char *prom_envs[MAX_PROM_ENVS];
232
246
#endif
233
int nb_drives_opt;
234
struct drive_opt {
235
const char *file;
236
char opt[1024];
237
} drives_opt[MAX_DRIVES];
247
int boot_menu;
248
249
int nb_numa_nodes;
250
uint64_t node_mem[MAX_NODES];
251
uint64_t node_cpumask[MAX_NODES];
238
252
239
253
static CPUState *cur_cpu;
240
254
static CPUState *next_cpu;
241
static int event_pending = 1;
242
243
#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
255
static int timer_alarm_pending = 1;
256
/* Conversion factor from emulated instructions to virtual clock ticks. */
257
static int icount_time_shift;
258
/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
259
#define MAX_ICOUNT_SHIFT 10
260
/* Compensate for varying guest execution speed. */
261
static int64_t qemu_icount_bias;
262
static QEMUTimer *icount_rt_timer;
263
static QEMUTimer *icount_vm_timer;
264
static QEMUTimer *nographic_timer;
265
266
uint8_t qemu_uuid[16];
267
268
static QEMUBootSetHandler *boot_set_handler;
269
static void *boot_set_opaque;
244
270
245
271
/***********************************************************/
246
272
/* x86 ISA bus support */
248
274
target_phys_addr_t isa_mem_base = 0;
249
275
PicState2 *isa_pic;
250
276
251
static uint32_t default_ioport_readb(void *opaque, uint32_t address)
252
{
253
#ifdef DEBUG_UNUSED_IOPORT
254
fprintf(stderr, "unused inb: port=0x%04x\n", address);
255
#endif
256
return 0xff;
257
}
258
259
static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
260
{
261
#ifdef DEBUG_UNUSED_IOPORT
262
fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
263
#endif
264
}
265
266
/* default is to make two byte accesses */
267
static uint32_t default_ioport_readw(void *opaque, uint32_t address)
268
{
269
uint32_t data;
270
data = ioport_read_table[0][address](ioport_opaque[address], address);
271
address = (address + 1) & (MAX_IOPORTS - 1);
272
data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
273
return data;
274
}
275
276
static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
277
{
278
ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
279
address = (address + 1) & (MAX_IOPORTS - 1);
280
ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
281
}
282
283
static uint32_t default_ioport_readl(void *opaque, uint32_t address)
284
{
285
#ifdef DEBUG_UNUSED_IOPORT
286
fprintf(stderr, "unused inl: port=0x%04x\n", address);
287
#endif
288
return 0xffffffff;
289
}
290
291
static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
292
{
293
#ifdef DEBUG_UNUSED_IOPORT
294
fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
295
#endif
296
}
297
298
static void init_ioports(void)
299
{
300
int i;
301
302
for(i = 0; i < MAX_IOPORTS; i++) {
303
ioport_read_table[0][i] = default_ioport_readb;
304
ioport_write_table[0][i] = default_ioport_writeb;
305
ioport_read_table[1][i] = default_ioport_readw;
306
ioport_write_table[1][i] = default_ioport_writew;
307
ioport_read_table[2][i] = default_ioport_readl;
308
ioport_write_table[2][i] = default_ioport_writel;
309
}
310
}
311
312
/* size is the word size in byte */
313
int register_ioport_read(int start, int length, int size,
314
IOPortReadFunc *func, void *opaque)
315
{
316
int i, bsize;
317
318
if (size == 1) {
319
bsize = 0;
320
} else if (size == 2) {
321
bsize = 1;
322
} else if (size == 4) {
323
bsize = 2;
324
} else {
325
hw_error("register_ioport_read: invalid size");
326
return -1;
327
}
328
for(i = start; i < start + length; i += size) {
329
ioport_read_table[bsize][i] = func;
330
if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
331
hw_error("register_ioport_read: invalid opaque");
332
ioport_opaque[i] = opaque;
333
}
334
return 0;
335
}
336
337
/* size is the word size in byte */
338
int register_ioport_write(int start, int length, int size,
339
IOPortWriteFunc *func, void *opaque)
340
{
341
int i, bsize;
342
343
if (size == 1) {
344
bsize = 0;
345
} else if (size == 2) {
346
bsize = 1;
347
} else if (size == 4) {
348
bsize = 2;
349
} else {
350
hw_error("register_ioport_write: invalid size");
351
return -1;
352
}
353
for(i = start; i < start + length; i += size) {
354
ioport_write_table[bsize][i] = func;
355
if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
356
hw_error("register_ioport_write: invalid opaque");
357
ioport_opaque[i] = opaque;
358
}
359
return 0;
360
}
361
362
void isa_unassign_ioport(int start, int length)
363
{
364
int i;
365
366
for(i = start; i < start + length; i++) {
367
ioport_read_table[0][i] = default_ioport_readb;
368
ioport_read_table[1][i] = default_ioport_readw;
369
ioport_read_table[2][i] = default_ioport_readl;
370
371
ioport_write_table[0][i] = default_ioport_writeb;
372
ioport_write_table[1][i] = default_ioport_writew;
373
ioport_write_table[2][i] = default_ioport_writel;
374
}
375
}
376
377
/***********************************************************/
378
379
void cpu_outb(CPUState *env, int addr, int val)
380
{
381
#ifdef DEBUG_IOPORT
382
if (loglevel & CPU_LOG_IOPORT)
383
fprintf(logfile, "outb: %04x %02x\n", addr, val);
384
#endif
385
ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
386
#ifdef USE_KQEMU
387
if (env)
388
env->last_io_time = cpu_get_time_fast();
389
#endif
390
}
391
392
void cpu_outw(CPUState *env, int addr, int val)
393
{
394
#ifdef DEBUG_IOPORT
395
if (loglevel & CPU_LOG_IOPORT)
396
fprintf(logfile, "outw: %04x %04x\n", addr, val);
397
#endif
398
ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
399
#ifdef USE_KQEMU
400
if (env)
401
env->last_io_time = cpu_get_time_fast();
402
#endif
403
}
404
405
void cpu_outl(CPUState *env, int addr, int val)
406
{
407
#ifdef DEBUG_IOPORT
408
if (loglevel & CPU_LOG_IOPORT)
409
fprintf(logfile, "outl: %04x %08x\n", addr, val);
410
#endif
411
ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
412
#ifdef USE_KQEMU
413
if (env)
414
env->last_io_time = cpu_get_time_fast();
415
#endif
416
}
417
418
int cpu_inb(CPUState *env, int addr)
419
{
420
int val;
421
val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
422
#ifdef DEBUG_IOPORT
423
if (loglevel & CPU_LOG_IOPORT)
424
fprintf(logfile, "inb : %04x %02x\n", addr, val);
425
#endif
426
#ifdef USE_KQEMU
427
if (env)
428
env->last_io_time = cpu_get_time_fast();
429
#endif
430
return val;
431
}
432
433
int cpu_inw(CPUState *env, int addr)
434
{
435
int val;
436
val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
437
#ifdef DEBUG_IOPORT
438
if (loglevel & CPU_LOG_IOPORT)
439
fprintf(logfile, "inw : %04x %04x\n", addr, val);
440
#endif
441
#ifdef USE_KQEMU
442
if (env)
443
env->last_io_time = cpu_get_time_fast();
444
#endif
445
return val;
446
}
447
448
int cpu_inl(CPUState *env, int addr)
449
{
450
int val;
451
val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
452
#ifdef DEBUG_IOPORT
453
if (loglevel & CPU_LOG_IOPORT)
454
fprintf(logfile, "inl : %04x %08x\n", addr, val);
455
#endif
456
#ifdef USE_KQEMU
457
if (env)
458
env->last_io_time = cpu_get_time_fast();
459
#endif
460
return val;
461
}
462
463
277
/***********************************************************/
464
278
void hw_error(const char *fmt, ...)
465
279
{
482
296
abort();
483
297
}
484
298
299
static void set_proc_name(const char *s)
300
{
301
#if defined(__linux__) && defined(PR_SET_NAME)
302
char name[16];
303
if (!s)
304
return;
305
name[sizeof(name) - 1] = 0;
306
strncpy(name, s, sizeof(name));
307
/* Could rewrite argv[0] too, but that's a bit more complicated.
308
This simple way is enough for `top'. */
309
prctl(PR_SET_NAME, name);
310
#endif
311
}
312
313
/***************/
314
/* ballooning */
315
316
static QEMUBalloonEvent *qemu_balloon_event;
317
void *qemu_balloon_event_opaque;
318
319
void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
320
{
321
qemu_balloon_event = func;
322
qemu_balloon_event_opaque = opaque;
323
}
324
325
void qemu_balloon(ram_addr_t target)
326
{
327
if (qemu_balloon_event)
328
qemu_balloon_event(qemu_balloon_event_opaque, target);
329
}
330
331
ram_addr_t qemu_balloon_status(void)
332
{
333
if (qemu_balloon_event)
334
return qemu_balloon_event(qemu_balloon_event_opaque, 0);
335
return 0;
336
}
337
485
338
/***********************************************************/
486
339
/* keyboard/mouse */
487
340
503
356
QEMUPutMouseEntry *s, *cursor;
504
357
505
358
s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
506
if (!s)
507
return NULL;
508
359
509
360
s->qemu_put_mouse_event = func;
510
361
s->qemu_put_mouse_event_opaque = opaque;
604
455
return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
605
456
}
606
457
607
void do_info_mice(void)
458
void do_info_mice(Monitor *mon)
608
459
{
609
460
QEMUPutMouseEntry *cursor;
610
461
int index = 0;
611
462
612
463
if (!qemu_put_mouse_event_head) {
613
term_printf("No mouse devices connected\n");
464
monitor_printf(mon, "No mouse devices connected\n");
614
465
return;
615
466
}
616
467
617
term_printf("Mouse devices available:\n");
468
monitor_printf(mon, "Mouse devices available:\n");
618
469
cursor = qemu_put_mouse_event_head;
619
470
while (cursor != NULL) {
620
term_printf("%c Mouse #%d: %s\n",
621
(cursor == qemu_put_mouse_event_current ? '*' : ' '),
622
index, cursor->qemu_put_mouse_event_name);
471
monitor_printf(mon, "%c Mouse #%d: %s\n",
472
(cursor == qemu_put_mouse_event_current ? '*' : ' '),
473
index, cursor->qemu_put_mouse_event_name);
623
474
index++;
624
475
cursor = cursor->next;
625
476
}
626
477
}
627
478
628
void do_mouse_set(int index)
479
void do_mouse_set(Monitor *mon, int index)
629
480
{
630
481
QEMUPutMouseEntry *cursor;
631
482
int i = 0;
632
483
633
484
if (!qemu_put_mouse_event_head) {
634
term_printf("No mouse devices connected\n");
485
monitor_printf(mon, "No mouse devices connected\n");
635
486
return;
636
487
}
637
488
644
495
if (cursor != NULL)
645
496
qemu_put_mouse_event_current = cursor;
646
497
else
647
term_printf("Mouse at given index not found\n");
498
monitor_printf(mon, "Mouse at given index not found\n");
648
499
}
649
500
650
501
/* compute with 96 bit intermediate result: (a*b)/c */
653
504
union {
654
505
uint64_t ll;
655
506
struct {
656
#ifdef WORDS_BIGENDIAN
507
#ifdef HOST_WORDS_BIGENDIAN
657
508
uint32_t high, low;
658
509
#else
659
510
uint32_t low, high;
706
557
static void init_get_clock(void)
707
558
{
708
559
use_rt_clock = 0;
709
#if defined(__linux__)
560
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
561
|| defined(__DragonFly__)
710
562
{
711
563
struct timespec ts;
712
564
if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
718
570
719
571
static int64_t get_clock(void)
720
572
{
721
#if defined(__linux__)
573
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
574
|| defined(__DragonFly__)
722
575
if (use_rt_clock) {
723
576
struct timespec ts;
724
577
clock_gettime(CLOCK_MONOTONIC, &ts);
733
586
return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
734
587
}
735
588
}
736
737
589
#endif
738
590
591
/* Return the virtual CPU time, based on the instruction counter. */
592
static int64_t cpu_get_icount(void)
593
{
594
int64_t icount;
595
CPUState *env = cpu_single_env;;
596
icount = qemu_icount;
597
if (env) {
598
if (!can_do_io(env))
599
fprintf(stderr, "Bad clock read\n");
600
icount -= (env->icount_decr.u16.low + env->icount_extra);
601
}
602
return qemu_icount_bias + (icount << icount_time_shift);
603
}
604
739
605
/***********************************************************/
740
606
/* guest cycle counter */
741
607
747
613
/* return the host CPU cycle counter and handle stop/restart */
748
614
int64_t cpu_get_ticks(void)
749
615
{
616
if (use_icount) {
617
return cpu_get_icount();
618
}
750
619
if (!cpu_ticks_enabled) {
751
620
return cpu_ticks_offset;
752
621
} else {
829
698
830
699
static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
831
700
{
832
return t->flags & ALARM_FLAG_DYNTICKS;
701
return t && (t->flags & ALARM_FLAG_DYNTICKS);
833
702
}
834
703
835
704
static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
849
718
850
719
struct qemu_alarm_win32 {
851
720
MMRESULT timerId;
852
HANDLE host_alarm;
853
721
unsigned int period;
854
} alarm_win32_data = {0, NULL, -1};
722
} alarm_win32_data = {0, -1};
855
723
856
724
static int win32_start_timer(struct qemu_alarm_timer *t);
857
725
static void win32_stop_timer(struct qemu_alarm_timer *t);
878
746
879
747
#endif /* _WIN32 */
880
748
749
/* Correlation between real and virtual time is always going to be
750
fairly approximate, so ignore small variation.
751
When the guest is idle real and virtual time will be aligned in
752
the IO wait loop. */
753
#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
754
755
static void icount_adjust(void)
756
{
757
int64_t cur_time;
758
int64_t cur_icount;
759
int64_t delta;
760
static int64_t last_delta;
761
/* If the VM is not running, then do nothing. */
762
if (!vm_running)
763
return;
764
765
cur_time = cpu_get_clock();
766
cur_icount = qemu_get_clock(vm_clock);
767
delta = cur_icount - cur_time;
768
/* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
769
if (delta > 0
770
&& last_delta + ICOUNT_WOBBLE < delta * 2
771
&& icount_time_shift > 0) {
772
/* The guest is getting too far ahead. Slow time down. */
773
icount_time_shift--;
774
}
775
if (delta < 0
776
&& last_delta - ICOUNT_WOBBLE > delta * 2
777
&& icount_time_shift < MAX_ICOUNT_SHIFT) {
778
/* The guest is getting too far behind. Speed time up. */
779
icount_time_shift++;
780
}
781
last_delta = delta;
782
qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
783
}
784
785
static void icount_adjust_rt(void * opaque)
786
{
787
qemu_mod_timer(icount_rt_timer,
788
qemu_get_clock(rt_clock) + 1000);
789
icount_adjust();
790
}
791
792
static void icount_adjust_vm(void * opaque)
793
{
794
qemu_mod_timer(icount_vm_timer,
795
qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
796
icount_adjust();
797
}
798
799
static void init_icount_adjust(void)
800
{
801
/* Have both realtime and virtual time triggers for speed adjustment.
802
The realtime trigger catches emulated time passing too slowly,
803
the virtual time trigger catches emulated time passing too fast.
804
Realtime triggers occur even when idle, so use them less frequently
805
than VM triggers. */
806
icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
807
qemu_mod_timer(icount_rt_timer,
808
qemu_get_clock(rt_clock) + 1000);
809
icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
810
qemu_mod_timer(icount_vm_timer,
811
qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
812
}
813
881
814
static struct qemu_alarm_timer alarm_timers[] = {
882
815
#ifndef _WIN32
883
816
#ifdef __linux__
911
844
{
912
845
int i;
913
846
int cur = 0;
914
int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
847
int count = ARRAY_SIZE(alarm_timers) - 1;
915
848
char *arg;
916
849
char *name;
850
struct qemu_alarm_timer tmp;
917
851
918
852
if (!strcmp(opt, "?")) {
919
853
show_available_alarms();
925
859
/* Reorder the array */
926
860
name = strtok(arg, ",");
927
861
while (name) {
928
struct qemu_alarm_timer tmp;
929
930
862
for (i = 0; i < count && alarm_timers[i].name; i++) {
931
863
if (!strcmp(alarm_timers[i].name, name))
932
864
break;
954
886
free(arg);
955
887
956
888
if (cur) {
957
/* Disable remaining timers */
889
/* Disable remaining timers */
958
890
for (i = cur; i < count; i++)
959
891
alarm_timers[i].name = NULL;
960
892
} else {
972
904
{
973
905
QEMUClock *clock;
974
906
clock = qemu_mallocz(sizeof(QEMUClock));
975
if (!clock)
976
return NULL;
977
907
clock->type = type;
978
908
return clock;
979
909
}
1039
969
*pt = ts;
1040
970
1041
971
/* Rearm if necessary */
1042
if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0 &&
1043
pt == &active_timers[ts->clock->type])
1044
qemu_rearm_alarm_timer(alarm_timer);
972
if (pt == &active_timers[ts->clock->type]) {
973
if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
974
qemu_rearm_alarm_timer(alarm_timer);
975
}
976
/* Interrupt execution to force deadline recalculation. */
977
if (use_icount)
978
qemu_notify_event();
979
}
1045
980
}
1046
981
1047
982
int qemu_timer_pending(QEMUTimer *ts)
1054
989
return 0;
1055
990
}
1056
991
1057
static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
992
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1058
993
{
1059
994
if (!timer_head)
1060
995
return 0;
1085
1020
return get_clock() / 1000000;
1086
1021
default:
1087
1022
case QEMU_TIMER_VIRTUAL:
1088
return cpu_get_clock();
1023
if (use_icount) {
1024
return cpu_get_icount();
1025
} else {
1026
return cpu_get_clock();
1027
}
1089
1028
}
1090
1029
}
1091
1030
1147
1086
return 0;
1148
1087
}
1149
1088
1089
static void qemu_event_increment(void);
1090
1150
1091
#ifdef _WIN32
1151
void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1152
DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1092
static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1093
DWORD_PTR dwUser, DWORD_PTR dw1,
1094
DWORD_PTR dw2)
1153
1095
#else
1154
1096
static void host_alarm_handler(int host_signum)
1155
1097
#endif
1184
1126
}
1185
1127
#endif
1186
1128
if (alarm_has_dynticks(alarm_timer) ||
1187
qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1188
qemu_get_clock(vm_clock)) ||
1129
(!use_icount &&
1130
qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1131
qemu_get_clock(vm_clock))) ||
1189
1132
qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1190
1133
qemu_get_clock(rt_clock))) {
1191
#ifdef _WIN32
1192
struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1193
SetEvent(data->host_alarm);
1194
#endif
1195
CPUState *env = next_cpu;
1196
1197
alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1198
1199
if (env) {
1134
qemu_event_increment();
1135
if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1136
1137
#ifndef CONFIG_IOTHREAD
1138
if (next_cpu) {
1200
1139
/* stop the currently executing cpu because a timer occured */
1201
cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1202
#ifdef USE_KQEMU
1203
if (env->kqemu_enabled) {
1204
kqemu_cpu_interrupt(env);
1205
}
1140
cpu_exit(next_cpu);
1141
}
1206
1142
#endif
1207
}
1208
event_pending = 1;
1143
timer_alarm_pending = 1;
1144
qemu_notify_event();
1209
1145
}
1210
1146
}
1211
1147
1212
static uint64_t qemu_next_deadline(void)
1148
static int64_t qemu_next_deadline(void)
1213
1149
{
1214
int64_t nearest_delta_us = INT64_MAX;
1215
int64_t vmdelta_us;
1216
1217
if (active_timers[QEMU_TIMER_REALTIME])
1218
nearest_delta_us = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1219
qemu_get_clock(rt_clock))*1000;
1150
int64_t delta;
1220
1151
1221
1152
if (active_timers[QEMU_TIMER_VIRTUAL]) {
1222
/* round up */
1223
vmdelta_us = (active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1224
qemu_get_clock(vm_clock)+999)/1000;
1225
if (vmdelta_us < nearest_delta_us)
1226
nearest_delta_us = vmdelta_us;
1227
}
1228
1229
/* Avoid arming the timer to negative, zero, or too low values */
1230
if (nearest_delta_us <= MIN_TIMER_REARM_US)
1231
nearest_delta_us = MIN_TIMER_REARM_US;
1232
1233
return nearest_delta_us;
1234
}
1153
delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1154
qemu_get_clock(vm_clock);
1155
} else {
1156
/* To avoid problems with overflow limit this to 2^32. */
1157
delta = INT32_MAX;
1158
}
1159
1160
if (delta < 0)
1161
delta = 0;
1162
1163
return delta;
1164
}
1165
1166
#if defined(__linux__) || defined(_WIN32)
1167
static uint64_t qemu_next_deadline_dyntick(void)
1168
{
1169
int64_t delta;
1170
int64_t rtdelta;
1171
1172
if (use_icount)
1173
delta = INT32_MAX;
1174
else
1175
delta = (qemu_next_deadline() + 999) / 1000;
1176
1177
if (active_timers[QEMU_TIMER_REALTIME]) {
1178
rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1179
qemu_get_clock(rt_clock))*1000;
1180
if (rtdelta < delta)
1181
delta = rtdelta;
1182
}
1183
1184
if (delta < MIN_TIMER_REARM_US)
1185
delta = MIN_TIMER_REARM_US;
1186
1187
return delta;
1188
}
1189
#endif
1235
1190
1236
1191
#ifndef _WIN32
1237
1192
1193
/* Sets a specific flag */
1194
static int fcntl_setfl(int fd, int flag)
1195
{
1196
int flags;
1197
1198
flags = fcntl(fd, F_GETFL);
1199
if (flags == -1)
1200
return -errno;
1201
1202
if (fcntl(fd, F_SETFL, flags | flag) == -1)
1203
return -errno;
1204
1205
return 0;
1206
}
1207
1238
1208
#if defined(__linux__)
1239
1209
1240
1210
#define RTC_FREQ 1024
1249
1219
act.sa_handler = host_alarm_handler;
1250
1220
1251
1221
sigaction(SIGIO, &act, NULL);
1252
fcntl(fd, F_SETFL, O_ASYNC);
1222
fcntl_setfl(fd, O_ASYNC);
1253
1223
fcntl(fd, F_SETOWN, getpid());
1254
1224
}
1255
1225
1350
1320
1351
1321
sigaction(SIGALRM, &act, NULL);
1352
1322
1323
/*
1324
* Initialize ev struct to 0 to avoid valgrind complaining
1325
* about uninitialized data in timer_create call
1326
*/
1327
memset(&ev, 0, sizeof(ev));
1353
1328
ev.sigev_value.sival_int = 0;
1354
1329
ev.sigev_notify = SIGEV_SIGNAL;
1355
1330
ev.sigev_signo = SIGALRM;
1363
1338
return -1;
1364
1339
}
1365
1340
1366
t->priv = (void *)host_timer;
1341
t->priv = (void *)(long)host_timer;
1367
1342
1368
1343
return 0;
1369
1344
}
1370
1345
1371
1346
static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1372
1347
{
1373
timer_t host_timer = (timer_t)t->priv;
1348
timer_t host_timer = (timer_t)(long)t->priv;
1374
1349
1375
1350
timer_delete(host_timer);
1376
1351
}
1377
1352
1378
1353
static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1379
1354
{
1380
timer_t host_timer = (timer_t)t->priv;
1355
timer_t host_timer = (timer_t)(long)t->priv;
1381
1356
struct itimerspec timeout;
1382
1357
int64_t nearest_delta_us = INT64_MAX;
1383
1358
int64_t current_us;
1386
1361
!active_timers[QEMU_TIMER_VIRTUAL])
1387
1362
return;
1388
1363
1389
nearest_delta_us = qemu_next_deadline();
1364
nearest_delta_us = qemu_next_deadline_dyntick();
1390
1365
1391
1366
/* check whether a timer is already running */
1392
1367
if (timer_gettime(host_timer, &timeout)) {
1447
1422
1448
1423
#endif /* !defined(_WIN32) */
1449
1424
1425
1450
1426
#ifdef _WIN32
1451
1427
1452
1428
static int win32_start_timer(struct qemu_alarm_timer *t)
1455
1431
struct qemu_alarm_win32 *data = t->priv;
1456
1432
UINT flags;
1457
1433
1458
data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1459
if (!data->host_alarm) {
1460
perror("Failed CreateEvent");
1461
return -1;
1462
}
1463
1464
1434
memset(&tc, 0, sizeof(tc));
1465
1435
timeGetDevCaps(&tc, sizeof(tc));
1466
1436
1483
1453
1484
1454
if (!data->timerId) {
1485
1455
perror("Failed to initialize win32 alarm timer");
1486
1487
1456
timeEndPeriod(data->period);
1488
CloseHandle(data->host_alarm);
1489
1457
return -1;
1490
1458
}
1491
1459
1492
qemu_add_wait_object(data->host_alarm, NULL, NULL);
1493
1494
1460
return 0;
1495
1461
}
1496
1462
1500
1466
1501
1467
timeKillEvent(data->timerId);
1502
1468
timeEndPeriod(data->period);
1503
1504
CloseHandle(data->host_alarm);
1505
1469
}
1506
1470
1507
1471
static void win32_rearm_timer(struct qemu_alarm_timer *t)
1513
1477
!active_timers[QEMU_TIMER_VIRTUAL])
1514
1478
return;
1515
1479
1516
nearest_delta_us = qemu_next_deadline();
1480
nearest_delta_us = qemu_next_deadline_dyntick();
1517
1481
nearest_delta_us /= 1000;
1518
1482
1519
1483
timeKillEvent(data->timerId);
1528
1492
perror("Failed to re-arm win32 alarm timer");
1529
1493
1530
1494
timeEndPeriod(data->period);
1531
CloseHandle(data->host_alarm);
1532
1495
exit(1);
1533
1496
}
1534
1497
}
1535
1498
1536
1499
#endif /* _WIN32 */
1537
1500
1538
static void init_timer_alarm(void)
1501
static int init_timer_alarm(void)
1539
1502
{
1540
struct qemu_alarm_timer *t;
1503
struct qemu_alarm_timer *t = NULL;
1541
1504
int i, err = -1;
1542
1505
1543
1506
for (i = 0; alarm_timers[i].name; i++) {
1549
1512
}
1550
1513
1551
1514
if (err) {
1552
fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1553
fprintf(stderr, "Terminating\n");
1554
exit(1);
1515
err = -ENOENT;
1516
goto fail;
1555
1517
}
1556
1518
1557
1519
alarm_timer = t;
1520
1521
return 0;
1522
1523
fail:
1524
return err;
1558
1525
}
1559
1526
1560
1527
static void quit_timers(void)
1600
1567
return seconds - time(NULL);
1601
1568
}
1602
1569
1603
/***********************************************************/
1604
/* character device */
1605
1606
static void qemu_chr_event(CharDriverState *s, int event)
1607
{
1608
if (!s->chr_event)
1609
return;
1610
s->chr_event(s->handler_opaque, event);
1611
}
1612
1613
static void qemu_chr_reset_bh(void *opaque)
1614
{
1615
CharDriverState *s = opaque;
1616
qemu_chr_event(s, CHR_EVENT_RESET);
1617
qemu_bh_delete(s->bh);
1618
s->bh = NULL;
1619
}
1620
1621
void qemu_chr_reset(CharDriverState *s)
1622
{
1623
if (s->bh == NULL) {
1624
s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1625
qemu_bh_schedule(s->bh);
1626
}
1627
}
1628
1629
int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1630
{
1631
return s->chr_write(s, buf, len);
1632
}
1633
1634
int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1635
{
1636
if (!s->chr_ioctl)
1637
return -ENOTSUP;
1638
return s->chr_ioctl(s, cmd, arg);
1639
}
1640
1641
int qemu_chr_can_read(CharDriverState *s)
1642
{
1643
if (!s->chr_can_read)
1644
return 0;
1645
return s->chr_can_read(s->handler_opaque);
1646
}
1647
1648
void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1649
{
1650
s->chr_read(s->handler_opaque, buf, len);
1651
}
1652
1653
void qemu_chr_accept_input(CharDriverState *s)
1654
{
1655
if (s->chr_accept_input)
1656
s->chr_accept_input(s);
1657
}
1658
1659
void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1660
{
1661
char buf[4096];
1662
va_list ap;
1663
va_start(ap, fmt);
1664
vsnprintf(buf, sizeof(buf), fmt, ap);
1665
qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1666
va_end(ap);
1667
}
1668
1669
void qemu_chr_send_event(CharDriverState *s, int event)
1670
{
1671
if (s->chr_send_event)
1672
s->chr_send_event(s, event);
1673
}
1674
1675
void qemu_chr_add_handlers(CharDriverState *s,
1676
IOCanRWHandler *fd_can_read,
1677
IOReadHandler *fd_read,
1678
IOEventHandler *fd_event,
1679
void *opaque)
1680
{
1681
s->chr_can_read = fd_can_read;
1682
s->chr_read = fd_read;
1683
s->chr_event = fd_event;
1684
s->handler_opaque = opaque;
1685
if (s->chr_update_read_handler)
1686
s->chr_update_read_handler(s);
1687
}
1688
1689
static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1690
{
1691
return len;
1692
}
1693
1694
static CharDriverState *qemu_chr_open_null(void)
1695
{
1696
CharDriverState *chr;
1697
1698
chr = qemu_mallocz(sizeof(CharDriverState));
1699
if (!chr)
1700
return NULL;
1701
chr->chr_write = null_chr_write;
1702
return chr;
1703
}
1704
1705
/* MUX driver for serial I/O splitting */
1706
static int term_timestamps;
1707
static int64_t term_timestamps_start;
1708
#define MAX_MUX 4
1709
#define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1710
#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1711
typedef struct {
1712
IOCanRWHandler *chr_can_read[MAX_MUX];
1713
IOReadHandler *chr_read[MAX_MUX];
1714
IOEventHandler *chr_event[MAX_MUX];
1715
void *ext_opaque[MAX_MUX];
1716
CharDriverState *drv;
1717
unsigned char buffer[MUX_BUFFER_SIZE];
1718
int prod;
1719
int cons;
1720
int mux_cnt;
1721
int term_got_escape;
1722
int max_size;
1723
} MuxDriver;
1724
1725
1726
static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1727
{
1728
MuxDriver *d = chr->opaque;
1729
int ret;
1730
if (!term_timestamps) {
1731
ret = d->drv->chr_write(d->drv, buf, len);
1732
} else {
1733
int i;
1734
1735
ret = 0;
1736
for(i = 0; i < len; i++) {
1737
ret += d->drv->chr_write(d->drv, buf+i, 1);
1738
if (buf[i] == '\n') {
1739
char buf1[64];
1740
int64_t ti;
1741
int secs;
1742
1743
ti = get_clock();
1744
if (term_timestamps_start == -1)
1745
term_timestamps_start = ti;
1746
ti -= term_timestamps_start;
1747
secs = ti / 1000000000;
1748
snprintf(buf1, sizeof(buf1),
1749
"[%02d:%02d:%02d.%03d] ",
1750
secs / 3600,
1751
(secs / 60) % 60,
1752
secs % 60,
1753
(int)((ti / 1000000) % 1000));
1754
d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1755
}
1756
}
1757
}
1758
return ret;
1759
}
1760
1761
static char *mux_help[] = {
1762
"% h print this help\n\r",
1763
"% x exit emulator\n\r",
1764
"% s save disk data back to file (if -snapshot)\n\r",
1765
"% t toggle console timestamps\n\r"
1766
"% b send break (magic sysrq)\n\r",
1767
"% c switch between console and monitor\n\r",
1768
"% % sends %\n\r",
1769
NULL
1770
};
1771
1772
static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1773
static void mux_print_help(CharDriverState *chr)
1774
{
1775
int i, j;
1776
char ebuf[15] = "Escape-Char";
1777
char cbuf[50] = "\n\r";
1778
1779
if (term_escape_char > 0 && term_escape_char < 26) {
1780
sprintf(cbuf,"\n\r");
1781
sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1782
} else {
1783
sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1784
term_escape_char);
1785
}
1786
chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1787
for (i = 0; mux_help[i] != NULL; i++) {
1788
for (j=0; mux_help[i][j] != '\0'; j++) {
1789
if (mux_help[i][j] == '%')
1790
chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1791
else
1792
chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1793
}
1794
}
1795
}
1796
1797
static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1798
{
1799
if (d->term_got_escape) {
1800
d->term_got_escape = 0;
1801
if (ch == term_escape_char)
1802
goto send_char;
1803
switch(ch) {
1804
case '?':
1805
case 'h':
1806
mux_print_help(chr);
1807
break;
1808
case 'x':
1809
{
1810
char *term = "QEMU: Terminated\n\r";
1811
chr->chr_write(chr,(uint8_t *)term,strlen(term));
1812
exit(0);
1813
break;
1814
}
1815
case 's':
1816
{
1817
int i;
1818
for (i = 0; i < nb_drives; i++) {
1819
bdrv_commit(drives_table[i].bdrv);
1820
}
1821
}
1822
break;
1823
case 'b':
1824
qemu_chr_event(chr, CHR_EVENT_BREAK);
1825
break;
1826
case 'c':
1827
/* Switch to the next registered device */
1828
chr->focus++;
1829
if (chr->focus >= d->mux_cnt)
1830
chr->focus = 0;
1831
break;
1832
case 't':
1833
term_timestamps = !term_timestamps;
1834
term_timestamps_start = -1;
1835
break;
1836
}
1837
} else if (ch == term_escape_char) {
1838
d->term_got_escape = 1;
1839
} else {
1840
send_char:
1841
return 1;
1842
}
1843
return 0;
1844
}
1845
1846
static void mux_chr_accept_input(CharDriverState *chr)
1847
{
1848
int m = chr->focus;
1849
MuxDriver *d = chr->opaque;
1850
1851
while (d->prod != d->cons &&
1852
d->chr_can_read[m] &&
1853
d->chr_can_read[m](d->ext_opaque[m])) {
1854
d->chr_read[m](d->ext_opaque[m],
1855
&d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
1856
}
1857
}
1858
1859
static int mux_chr_can_read(void *opaque)
1860
{
1861
CharDriverState *chr = opaque;
1862
MuxDriver *d = chr->opaque;
1863
1864
if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
1865
return 1;
1866
if (d->chr_can_read[chr->focus])
1867
return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1868
return 0;
1869
}
1870
1871
static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1872
{
1873
CharDriverState *chr = opaque;
1874
MuxDriver *d = chr->opaque;
1875
int m = chr->focus;
1876
int i;
1877
1878
mux_chr_accept_input (opaque);
1879
1880
for(i = 0; i < size; i++)
1881
if (mux_proc_byte(chr, d, buf[i])) {
1882
if (d->prod == d->cons &&
1883
d->chr_can_read[m] &&
1884
d->chr_can_read[m](d->ext_opaque[m]))
1885
d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
1886
else
1887
d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
1888
}
1889
}
1890
1891
static void mux_chr_event(void *opaque, int event)
1892
{
1893
CharDriverState *chr = opaque;
1894
MuxDriver *d = chr->opaque;
1895
int i;
1896
1897
/* Send the event to all registered listeners */
1898
for (i = 0; i < d->mux_cnt; i++)
1899
if (d->chr_event[i])
1900
d->chr_event[i](d->ext_opaque[i], event);
1901
}
1902
1903
static void mux_chr_update_read_handler(CharDriverState *chr)
1904
{
1905
MuxDriver *d = chr->opaque;
1906
1907
if (d->mux_cnt >= MAX_MUX) {
1908
fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
1909
return;
1910
}
1911
d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
1912
d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
1913
d->chr_read[d->mux_cnt] = chr->chr_read;
1914
d->chr_event[d->mux_cnt] = chr->chr_event;
1915
/* Fix up the real driver with mux routines */
1916
if (d->mux_cnt == 0) {
1917
qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
1918
mux_chr_event, chr);
1919
}
1920
chr->focus = d->mux_cnt;
1921
d->mux_cnt++;
1922
}
1923
1924
static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
1925
{
1926
CharDriverState *chr;
1927
MuxDriver *d;
1928
1929
chr = qemu_mallocz(sizeof(CharDriverState));
1930
if (!chr)
1931
return NULL;
1932
d = qemu_mallocz(sizeof(MuxDriver));
1933
if (!d) {
1934
free(chr);
1935
return NULL;
1936
}
1937
1938
chr->opaque = d;
1939
d->drv = drv;
1940
chr->focus = -1;
1941
chr->chr_write = mux_chr_write;
1942
chr->chr_update_read_handler = mux_chr_update_read_handler;
1943
chr->chr_accept_input = mux_chr_accept_input;
1944
return chr;
1945
}
1946
1947
1948
1570
#ifdef _WIN32
1949
1950
1571
static void socket_cleanup(void)
1951
1572
{
1952
1573
WSACleanup();
1966
1587
atexit(socket_cleanup);
1967
1588
return 0;
1968
1589
}
1969
1970
static int send_all(int fd, const uint8_t *buf, int len1)
1971
{
1972
int ret, len;
1973
1974
len = len1;
1975
while (len > 0) {
1976
ret = send(fd, buf, len, 0);
1977
if (ret < 0) {
1978
int errno;
1979
errno = WSAGetLastError();
1980
if (errno != WSAEWOULDBLOCK) {
1981
return -1;
1982
}
1983
} else if (ret == 0) {
1984
break;
1985
} else {
1986
buf += ret;
1987
len -= ret;
1988
}
1989
}
1990
return len1 - len;
1991
}
1992
1993
void socket_set_nonblock(int fd)
1994
{
1995
unsigned long opt = 1;
1996
ioctlsocket(fd, FIONBIO, &opt);
1997
}
1998
1999
#else
2000
2001
static int unix_write(int fd, const uint8_t *buf, int len1)
2002
{
2003
int ret, len;
2004
2005
len = len1;
2006
while (len > 0) {
2007
ret = write(fd, buf, len);
2008
if (ret < 0) {
2009
if (errno != EINTR && errno != EAGAIN)
2010
return -1;
2011
} else if (ret == 0) {
2012
break;
2013
} else {
2014
buf += ret;
2015
len -= ret;
2016
}
2017
}
2018
return len1 - len;
2019
}
2020
2021
static inline int send_all(int fd, const uint8_t *buf, int len1)
2022
{
2023
return unix_write(fd, buf, len1);
2024
}
2025
2026
void socket_set_nonblock(int fd)
2027
{
2028
fcntl(fd, F_SETFL, O_NONBLOCK);
2029
}
2030
#endif /* !_WIN32 */
2031
2032
#ifndef _WIN32
2033
2034
typedef struct {
2035
int fd_in, fd_out;
2036
int max_size;
2037
} FDCharDriver;
2038
2039
#define STDIO_MAX_CLIENTS 1
2040
static int stdio_nb_clients = 0;
2041
2042
static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2043
{
2044
FDCharDriver *s = chr->opaque;
2045
return unix_write(s->fd_out, buf, len);
2046
}
2047
2048
static int fd_chr_read_poll(void *opaque)
2049
{
2050
CharDriverState *chr = opaque;
2051
FDCharDriver *s = chr->opaque;
2052
2053
s->max_size = qemu_chr_can_read(chr);
2054
return s->max_size;
2055
}
2056
2057
static void fd_chr_read(void *opaque)
2058
{
2059
CharDriverState *chr = opaque;
2060
FDCharDriver *s = chr->opaque;
2061
int size, len;
2062
uint8_t buf[1024];
2063
2064
len = sizeof(buf);
2065
if (len > s->max_size)
2066
len = s->max_size;
2067
if (len == 0)
2068
return;
2069
size = read(s->fd_in, buf, len);
2070
if (size == 0) {
2071
/* FD has been closed. Remove it from the active list. */
2072
qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2073
return;
2074
}
2075
if (size > 0) {
2076
qemu_chr_read(chr, buf, size);
2077
}
2078
}
2079
2080
static void fd_chr_update_read_handler(CharDriverState *chr)
2081
{
2082
FDCharDriver *s = chr->opaque;
2083
2084
if (s->fd_in >= 0) {
2085
if (nographic && s->fd_in == 0) {
2086
} else {
2087
qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2088
fd_chr_read, NULL, chr);
2089
}
2090
}
2091
}
2092
2093
static void fd_chr_close(struct CharDriverState *chr)
2094
{
2095
FDCharDriver *s = chr->opaque;
2096
2097
if (s->fd_in >= 0) {
2098
if (nographic && s->fd_in == 0) {
2099
} else {
2100
qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2101
}
2102
}
2103
2104
qemu_free(s);
2105
}
2106
2107
/* open a character device to a unix fd */
2108
static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2109
{
2110
CharDriverState *chr;
2111
FDCharDriver *s;
2112
2113
chr = qemu_mallocz(sizeof(CharDriverState));
2114
if (!chr)
2115
return NULL;
2116
s = qemu_mallocz(sizeof(FDCharDriver));
2117
if (!s) {
2118
free(chr);
2119
return NULL;
2120
}
2121
s->fd_in = fd_in;
2122
s->fd_out = fd_out;
2123
chr->opaque = s;
2124
chr->chr_write = fd_chr_write;
2125
chr->chr_update_read_handler = fd_chr_update_read_handler;
2126
chr->chr_close = fd_chr_close;
2127
2128
qemu_chr_reset(chr);
2129
2130
return chr;
2131
}
2132
2133
static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2134
{
2135
int fd_out;
2136
2137
TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2138
if (fd_out < 0)
2139
return NULL;
2140
return qemu_chr_open_fd(-1, fd_out);
2141
}
2142
2143
static CharDriverState *qemu_chr_open_pipe(const char *filename)
2144
{
2145
int fd_in, fd_out;
2146
char filename_in[256], filename_out[256];
2147
2148
snprintf(filename_in, 256, "%s.in", filename);
2149
snprintf(filename_out, 256, "%s.out", filename);
2150
TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2151
TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2152
if (fd_in < 0 || fd_out < 0) {
2153
if (fd_in >= 0)
2154
close(fd_in);
2155
if (fd_out >= 0)
2156
close(fd_out);
2157
TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2158
if (fd_in < 0)
2159
return NULL;
2160
}
2161
return qemu_chr_open_fd(fd_in, fd_out);
2162
}
2163
2164
2165
/* for STDIO, we handle the case where several clients use it
2166
(nographic mode) */
2167
2168
#define TERM_FIFO_MAX_SIZE 1
2169
2170
static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2171
static int term_fifo_size;
2172
2173
static int stdio_read_poll(void *opaque)
2174
{
2175
CharDriverState *chr = opaque;
2176
2177
/* try to flush the queue if needed */
2178
if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2179
qemu_chr_read(chr, term_fifo, 1);
2180
term_fifo_size = 0;
2181
}
2182
/* see if we can absorb more chars */
2183
if (term_fifo_size == 0)
2184
return 1;
2185
else
2186
return 0;
2187
}
2188
2189
static void stdio_read(void *opaque)
2190
{
2191
int size;
2192
uint8_t buf[1];
2193
CharDriverState *chr = opaque;
2194
2195
size = read(0, buf, 1);
2196
if (size == 0) {
2197
/* stdin has been closed. Remove it from the active list. */
2198
qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2199
return;
2200
}
2201
if (size > 0) {
2202
if (qemu_chr_can_read(chr) > 0) {
2203
qemu_chr_read(chr, buf, 1);
2204
} else if (term_fifo_size == 0) {
2205
term_fifo[term_fifo_size++] = buf[0];
2206
}
2207
}
2208
}
2209
2210
/* init terminal so that we can grab keys */
2211
static struct termios oldtty;
2212
static int old_fd0_flags;
2213
static int term_atexit_done;
2214
2215
static void term_exit(void)
2216
{
2217
tcsetattr (0, TCSANOW, &oldtty);
2218
fcntl(0, F_SETFL, old_fd0_flags);
2219
}
2220
2221
static void term_init(void)
2222
{
2223
struct termios tty;
2224
2225
tcgetattr (0, &tty);
2226
oldtty = tty;
2227
old_fd0_flags = fcntl(0, F_GETFL);
2228
2229
tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2230
|INLCR|IGNCR|ICRNL|IXON);
2231
tty.c_oflag |= OPOST;
2232
tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2233
/* if graphical mode, we allow Ctrl-C handling */
2234
if (nographic)
2235
tty.c_lflag &= ~ISIG;
2236
tty.c_cflag &= ~(CSIZE|PARENB);
2237
tty.c_cflag |= CS8;
2238
tty.c_cc[VMIN] = 1;
2239
tty.c_cc[VTIME] = 0;
2240
2241
tcsetattr (0, TCSANOW, &tty);
2242
2243
if (!term_atexit_done++)
2244
atexit(term_exit);
2245
2246
fcntl(0, F_SETFL, O_NONBLOCK);
2247
}
2248
2249
static void qemu_chr_close_stdio(struct CharDriverState *chr)
2250
{
2251
term_exit();
2252
stdio_nb_clients--;
2253
qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2254
fd_chr_close(chr);
2255
}
2256
2257
static CharDriverState *qemu_chr_open_stdio(void)
2258
{
2259
CharDriverState *chr;
2260
2261
if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2262
return NULL;
2263
chr = qemu_chr_open_fd(0, 1);
2264
chr->chr_close = qemu_chr_close_stdio;
2265
qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2266
stdio_nb_clients++;
2267
term_init();
2268
2269
return chr;
2270
}
2271
2272
#ifdef __sun__
2273
/* Once Solaris has openpty(), this is going to be removed. */
2274
int openpty(int *amaster, int *aslave, char *name,
2275
struct termios *termp, struct winsize *winp)
2276
{
2277
const char *slave;
2278
int mfd = -1, sfd = -1;
2279
2280
*amaster = *aslave = -1;
2281
2282
mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
2283
if (mfd < 0)
2284
goto err;
2285
2286
if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
2287
goto err;
2288
2289
if ((slave = ptsname(mfd)) == NULL)
2290
goto err;
2291
2292
if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
2293
goto err;
2294
2295
if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
2296
(termp != NULL && tcgetattr(sfd, termp) < 0))
2297
goto err;
2298
2299
if (amaster)
2300
*amaster = mfd;
2301
if (aslave)
2302
*aslave = sfd;
2303
if (winp)
2304
ioctl(sfd, TIOCSWINSZ, winp);
2305
2306
return 0;
2307
2308
err:
2309
if (sfd != -1)
2310
close(sfd);
2311
close(mfd);
2312
return -1;
2313
}
2314
2315
void cfmakeraw (struct termios *termios_p)
2316
{
2317
termios_p->c_iflag &=
2318
~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2319
termios_p->c_oflag &= ~OPOST;
2320
termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2321
termios_p->c_cflag &= ~(CSIZE|PARENB);
2322
termios_p->c_cflag |= CS8;
2323
2324
termios_p->c_cc[VMIN] = 0;
2325
termios_p->c_cc[VTIME] = 0;
2326
}
2327
#endif
2328
2329
#if defined(__linux__) || defined(__sun__)
2330
static CharDriverState *qemu_chr_open_pty(void)
2331
{
2332
struct termios tty;
2333
int master_fd, slave_fd;
2334
2335
if (openpty(&master_fd, &slave_fd, NULL, NULL, NULL) < 0) {
2336
return NULL;
2337
}
2338
2339
/* Set raw attributes on the pty. */
2340
cfmakeraw(&tty);
2341
tcsetattr(slave_fd, TCSAFLUSH, &tty);
2342
2343
fprintf(stderr, "char device redirected to %s\n", ptsname(master_fd));
2344
return qemu_chr_open_fd(master_fd, master_fd);
2345
}
2346
2347
static void tty_serial_init(int fd, int speed,
2348
int parity, int data_bits, int stop_bits)
2349
{
2350
struct termios tty;
2351
speed_t spd;
2352
2353
#if 0
2354
printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2355
speed, parity, data_bits, stop_bits);
2356
#endif
2357
tcgetattr (fd, &tty);
2358
2359
#define MARGIN 1.1
2360
if (speed <= 50 * MARGIN)
2361
spd = B50;
2362
else if (speed <= 75 * MARGIN)
2363
spd = B75;
2364
else if (speed <= 300 * MARGIN)
2365
spd = B300;
2366
else if (speed <= 600 * MARGIN)
2367
spd = B600;
2368
else if (speed <= 1200 * MARGIN)
2369
spd = B1200;
2370
else if (speed <= 2400 * MARGIN)
2371
spd = B2400;
2372
else if (speed <= 4800 * MARGIN)
2373
spd = B4800;
2374
else if (speed <= 9600 * MARGIN)
2375
spd = B9600;
2376
else if (speed <= 19200 * MARGIN)
2377
spd = B19200;
2378
else if (speed <= 38400 * MARGIN)
2379
spd = B38400;
2380
else if (speed <= 57600 * MARGIN)
2381
spd = B57600;
2382
else if (speed <= 115200 * MARGIN)
2383
spd = B115200;
2384
else
2385
spd = B115200;
2386
2387
cfsetispeed(&tty, spd);
2388
cfsetospeed(&tty, spd);
2389
2390
tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2391
|INLCR|IGNCR|ICRNL|IXON);
2392
tty.c_oflag |= OPOST;
2393
tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2394
tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2395
switch(data_bits) {
2396
default:
2397
case 8:
2398
tty.c_cflag |= CS8;
2399
break;
2400
case 7:
2401
tty.c_cflag |= CS7;
2402
break;
2403
case 6:
2404
tty.c_cflag |= CS6;
2405
break;
2406
case 5:
2407
tty.c_cflag |= CS5;
2408
break;
2409
}
2410
switch(parity) {
2411
default:
2412
case 'N':
2413
break;
2414
case 'E':
2415
tty.c_cflag |= PARENB;
2416
break;
2417
case 'O':
2418
tty.c_cflag |= PARENB | PARODD;
2419
break;
2420
}
2421
if (stop_bits == 2)
2422
tty.c_cflag |= CSTOPB;
2423
2424
tcsetattr (fd, TCSANOW, &tty);
2425
}
2426
2427
static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2428
{
2429
FDCharDriver *s = chr->opaque;
2430
2431
switch(cmd) {
2432
case CHR_IOCTL_SERIAL_SET_PARAMS:
2433
{
2434
QEMUSerialSetParams *ssp = arg;
2435
tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2436
ssp->data_bits, ssp->stop_bits);
2437
}
2438
break;
2439
case CHR_IOCTL_SERIAL_SET_BREAK:
2440
{
2441
int enable = *(int *)arg;
2442
if (enable)
2443
tcsendbreak(s->fd_in, 1);
2444
}
2445
break;
2446
default:
2447
return -ENOTSUP;
2448
}
2449
return 0;
2450
}
2451
2452
static CharDriverState *qemu_chr_open_tty(const char *filename)
2453
{
2454
CharDriverState *chr;
2455
int fd;
2456
2457
TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2458
fcntl(fd, F_SETFL, O_NONBLOCK);
2459
tty_serial_init(fd, 115200, 'N', 8, 1);
2460
chr = qemu_chr_open_fd(fd, fd);
2461
if (!chr) {
2462
close(fd);
2463
return NULL;
2464
}
2465
chr->chr_ioctl = tty_serial_ioctl;
2466
qemu_chr_reset(chr);
2467
return chr;
2468
}
2469
#else /* ! __linux__ && ! __sun__ */
2470
static CharDriverState *qemu_chr_open_pty(void)
2471
{
2472
return NULL;
2473
}
2474
#endif /* __linux__ || __sun__ */
2475
2476
#if defined(__linux__)
2477
typedef struct {
2478
int fd;
2479
int mode;
2480
} ParallelCharDriver;
2481
2482
static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2483
{
2484
if (s->mode != mode) {
2485
int m = mode;
2486
if (ioctl(s->fd, PPSETMODE, &m) < 0)
2487
return 0;
2488
s->mode = mode;
2489
}
2490
return 1;
2491
}
2492
2493
static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2494
{
2495
ParallelCharDriver *drv = chr->opaque;
2496
int fd = drv->fd;
2497
uint8_t b;
2498
2499
switch(cmd) {
2500
case CHR_IOCTL_PP_READ_DATA:
2501
if (ioctl(fd, PPRDATA, &b) < 0)
2502
return -ENOTSUP;
2503
*(uint8_t *)arg = b;
2504
break;
2505
case CHR_IOCTL_PP_WRITE_DATA:
2506
b = *(uint8_t *)arg;
2507
if (ioctl(fd, PPWDATA, &b) < 0)
2508
return -ENOTSUP;
2509
break;
2510
case CHR_IOCTL_PP_READ_CONTROL:
2511
if (ioctl(fd, PPRCONTROL, &b) < 0)
2512
return -ENOTSUP;
2513
/* Linux gives only the lowest bits, and no way to know data
2514
direction! For better compatibility set the fixed upper
2515
bits. */
2516
*(uint8_t *)arg = b | 0xc0;
2517
break;
2518
case CHR_IOCTL_PP_WRITE_CONTROL:
2519
b = *(uint8_t *)arg;
2520
if (ioctl(fd, PPWCONTROL, &b) < 0)
2521
return -ENOTSUP;
2522
break;
2523
case CHR_IOCTL_PP_READ_STATUS:
2524
if (ioctl(fd, PPRSTATUS, &b) < 0)
2525
return -ENOTSUP;
2526
*(uint8_t *)arg = b;
2527
break;
2528
case CHR_IOCTL_PP_EPP_READ_ADDR:
2529
if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2530
struct ParallelIOArg *parg = arg;
2531
int n = read(fd, parg->buffer, parg->count);
2532
if (n != parg->count) {
2533
return -EIO;
2534
}
2535
}
2536
break;
2537
case CHR_IOCTL_PP_EPP_READ:
2538
if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2539
struct ParallelIOArg *parg = arg;
2540
int n = read(fd, parg->buffer, parg->count);
2541
if (n != parg->count) {
2542
return -EIO;
2543
}
2544
}
2545
break;
2546
case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2547
if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2548
struct ParallelIOArg *parg = arg;
2549
int n = write(fd, parg->buffer, parg->count);
2550
if (n != parg->count) {
2551
return -EIO;
2552
}
2553
}
2554
break;
2555
case CHR_IOCTL_PP_EPP_WRITE:
2556
if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2557
struct ParallelIOArg *parg = arg;
2558
int n = write(fd, parg->buffer, parg->count);
2559
if (n != parg->count) {
2560
return -EIO;
2561
}
2562
}
2563
break;
2564
default:
2565
return -ENOTSUP;
2566
}
2567
return 0;
2568
}
2569
2570
static void pp_close(CharDriverState *chr)
2571
{
2572
ParallelCharDriver *drv = chr->opaque;
2573
int fd = drv->fd;
2574
2575
pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2576
ioctl(fd, PPRELEASE);
2577
close(fd);
2578
qemu_free(drv);
2579
}
2580
2581
static CharDriverState *qemu_chr_open_pp(const char *filename)
2582
{
2583
CharDriverState *chr;
2584
ParallelCharDriver *drv;
2585
int fd;
2586
2587
TFR(fd = open(filename, O_RDWR));
2588
if (fd < 0)
2589
return NULL;
2590
2591
if (ioctl(fd, PPCLAIM) < 0) {
2592
close(fd);
2593
return NULL;
2594
}
2595
2596
drv = qemu_mallocz(sizeof(ParallelCharDriver));
2597
if (!drv) {
2598
close(fd);
2599
return NULL;
2600
}
2601
drv->fd = fd;
2602
drv->mode = IEEE1284_MODE_COMPAT;
2603
2604
chr = qemu_mallocz(sizeof(CharDriverState));
2605
if (!chr) {
2606
qemu_free(drv);
2607
close(fd);
2608
return NULL;
2609
}
2610
chr->chr_write = null_chr_write;
2611
chr->chr_ioctl = pp_ioctl;
2612
chr->chr_close = pp_close;
2613
chr->opaque = drv;
2614
2615
qemu_chr_reset(chr);
2616
2617
return chr;
2618
}
2619
#endif /* __linux__ */
2620
2621
#else /* _WIN32 */
2622
2623
typedef struct {
2624
int max_size;
2625
HANDLE hcom, hrecv, hsend;
2626
OVERLAPPED orecv, osend;
2627
BOOL fpipe;
2628
DWORD len;
2629
} WinCharState;
2630
2631
#define NSENDBUF 2048
2632
#define NRECVBUF 2048
2633
#define MAXCONNECT 1
2634
#define NTIMEOUT 5000
2635
2636
static int win_chr_poll(void *opaque);
2637
static int win_chr_pipe_poll(void *opaque);
2638
2639
static void win_chr_close(CharDriverState *chr)
2640
{
2641
WinCharState *s = chr->opaque;
2642
2643
if (s->hsend) {
2644
CloseHandle(s->hsend);
2645
s->hsend = NULL;
2646
}
2647
if (s->hrecv) {
2648
CloseHandle(s->hrecv);
2649
s->hrecv = NULL;
2650
}
2651
if (s->hcom) {
2652
CloseHandle(s->hcom);
2653
s->hcom = NULL;
2654
}
2655
if (s->fpipe)
2656
qemu_del_polling_cb(win_chr_pipe_poll, chr);
2657
else
2658
qemu_del_polling_cb(win_chr_poll, chr);
2659
}
2660
2661
static int win_chr_init(CharDriverState *chr, const char *filename)
2662
{
2663
WinCharState *s = chr->opaque;
2664
COMMCONFIG comcfg;
2665
COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2666
COMSTAT comstat;
2667
DWORD size;
2668
DWORD err;
2669
2670
s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2671
if (!s->hsend) {
2672
fprintf(stderr, "Failed CreateEvent\n");
2673
goto fail;
2674
}
2675
s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2676
if (!s->hrecv) {
2677
fprintf(stderr, "Failed CreateEvent\n");
2678
goto fail;
2679
}
2680
2681
s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2682
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2683
if (s->hcom == INVALID_HANDLE_VALUE) {
2684
fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2685
s->hcom = NULL;
2686
goto fail;
2687
}
2688
2689
if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2690
fprintf(stderr, "Failed SetupComm\n");
2691
goto fail;
2692
}
2693
2694
ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2695
size = sizeof(COMMCONFIG);
2696
GetDefaultCommConfig(filename, &comcfg, &size);
2697
comcfg.dcb.DCBlength = sizeof(DCB);
2698
CommConfigDialog(filename, NULL, &comcfg);
2699
2700
if (!SetCommState(s->hcom, &comcfg.dcb)) {
2701
fprintf(stderr, "Failed SetCommState\n");
2702
goto fail;
2703
}
2704
2705
if (!SetCommMask(s->hcom, EV_ERR)) {
2706
fprintf(stderr, "Failed SetCommMask\n");
2707
goto fail;
2708
}
2709
2710
cto.ReadIntervalTimeout = MAXDWORD;
2711
if (!SetCommTimeouts(s->hcom, &cto)) {
2712
fprintf(stderr, "Failed SetCommTimeouts\n");
2713
goto fail;
2714
}
2715
2716
if (!ClearCommError(s->hcom, &err, &comstat)) {
2717
fprintf(stderr, "Failed ClearCommError\n");
2718
goto fail;
2719
}
2720
qemu_add_polling_cb(win_chr_poll, chr);
2721
return 0;
2722
2723
fail:
2724
win_chr_close(chr);
2725
return -1;
2726
}
2727
2728
static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2729
{
2730
WinCharState *s = chr->opaque;
2731
DWORD len, ret, size, err;
2732
2733
len = len1;
2734
ZeroMemory(&s->osend, sizeof(s->osend));
2735
s->osend.hEvent = s->hsend;
2736
while (len > 0) {
2737
if (s->hsend)
2738
ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2739
else
2740
ret = WriteFile(s->hcom, buf, len, &size, NULL);
2741
if (!ret) {
2742
err = GetLastError();
2743
if (err == ERROR_IO_PENDING) {
2744
ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2745
if (ret) {
2746
buf += size;
2747
len -= size;
2748
} else {
2749
break;
2750
}
2751
} else {
2752
break;
2753
}
2754
} else {
2755
buf += size;
2756
len -= size;
2757
}
2758
}
2759
return len1 - len;
2760
}
2761
2762
static int win_chr_read_poll(CharDriverState *chr)
2763
{
2764
WinCharState *s = chr->opaque;
2765
2766
s->max_size = qemu_chr_can_read(chr);
2767
return s->max_size;
2768
}
2769
2770
static void win_chr_readfile(CharDriverState *chr)
2771
{
2772
WinCharState *s = chr->opaque;
2773
int ret, err;
2774
uint8_t buf[1024];
2775
DWORD size;
2776
2777
ZeroMemory(&s->orecv, sizeof(s->orecv));
2778
s->orecv.hEvent = s->hrecv;
2779
ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2780
if (!ret) {
2781
err = GetLastError();
2782
if (err == ERROR_IO_PENDING) {
2783
ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2784
}
2785
}
2786
2787
if (size > 0) {
2788
qemu_chr_read(chr, buf, size);
2789
}
2790
}
2791
2792
static void win_chr_read(CharDriverState *chr)
2793
{
2794
WinCharState *s = chr->opaque;
2795
2796
if (s->len > s->max_size)
2797
s->len = s->max_size;
2798
if (s->len == 0)
2799
return;
2800
2801
win_chr_readfile(chr);
2802
}
2803
2804
static int win_chr_poll(void *opaque)
2805
{
2806
CharDriverState *chr = opaque;
2807
WinCharState *s = chr->opaque;
2808
COMSTAT status;
2809
DWORD comerr;
2810
2811
ClearCommError(s->hcom, &comerr, &status);
2812
if (status.cbInQue > 0) {
2813
s->len = status.cbInQue;
2814
win_chr_read_poll(chr);
2815
win_chr_read(chr);
2816
return 1;
2817
}
2818
return 0;
2819
}
2820
2821
static CharDriverState *qemu_chr_open_win(const char *filename)
2822
{
2823
CharDriverState *chr;
2824
WinCharState *s;
2825
2826
chr = qemu_mallocz(sizeof(CharDriverState));
2827
if (!chr)
2828
return NULL;
2829
s = qemu_mallocz(sizeof(WinCharState));
2830
if (!s) {
2831
free(chr);
2832
return NULL;
2833
}
2834
chr->opaque = s;
2835
chr->chr_write = win_chr_write;
2836
chr->chr_close = win_chr_close;
2837
2838
if (win_chr_init(chr, filename) < 0) {
2839
free(s);
2840
free(chr);
2841
return NULL;
2842
}
2843
qemu_chr_reset(chr);
2844
return chr;
2845
}
2846
2847
static int win_chr_pipe_poll(void *opaque)
2848
{
2849
CharDriverState *chr = opaque;
2850
WinCharState *s = chr->opaque;
2851
DWORD size;
2852
2853
PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2854
if (size > 0) {
2855
s->len = size;
2856
win_chr_read_poll(chr);
2857
win_chr_read(chr);
2858
return 1;
2859
}
2860
return 0;
2861
}
2862
2863
static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2864
{
2865
WinCharState *s = chr->opaque;
2866
OVERLAPPED ov;
2867
int ret;
2868
DWORD size;
2869
char openname[256];
2870
2871
s->fpipe = TRUE;
2872
2873
s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2874
if (!s->hsend) {
2875
fprintf(stderr, "Failed CreateEvent\n");
2876
goto fail;
2877
}
2878
s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2879
if (!s->hrecv) {
2880
fprintf(stderr, "Failed CreateEvent\n");
2881
goto fail;
2882
}
2883
2884
snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2885
s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2886
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2887
PIPE_WAIT,
2888
MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2889
if (s->hcom == INVALID_HANDLE_VALUE) {
2890
fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2891
s->hcom = NULL;
2892
goto fail;
2893
}
2894
2895
ZeroMemory(&ov, sizeof(ov));
2896
ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2897
ret = ConnectNamedPipe(s->hcom, &ov);
2898
if (ret) {
2899
fprintf(stderr, "Failed ConnectNamedPipe\n");
2900
goto fail;
2901
}
2902
2903
ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2904
if (!ret) {
2905
fprintf(stderr, "Failed GetOverlappedResult\n");
2906
if (ov.hEvent) {
2907
CloseHandle(ov.hEvent);
2908
ov.hEvent = NULL;
2909
}
2910
goto fail;
2911
}
2912
2913
if (ov.hEvent) {
2914
CloseHandle(ov.hEvent);
2915
ov.hEvent = NULL;
2916
}
2917
qemu_add_polling_cb(win_chr_pipe_poll, chr);
2918
return 0;
2919
2920
fail:
2921
win_chr_close(chr);
2922
return -1;
2923
}
2924
2925
2926
static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2927
{
2928
CharDriverState *chr;
2929
WinCharState *s;
2930
2931
chr = qemu_mallocz(sizeof(CharDriverState));
2932
if (!chr)
2933
return NULL;
2934
s = qemu_mallocz(sizeof(WinCharState));
2935
if (!s) {
2936
free(chr);
2937
return NULL;
2938
}
2939
chr->opaque = s;
2940
chr->chr_write = win_chr_write;
2941
chr->chr_close = win_chr_close;
2942
2943
if (win_chr_pipe_init(chr, filename) < 0) {
2944
free(s);
2945
free(chr);
2946
return NULL;
2947
}
2948
qemu_chr_reset(chr);
2949
return chr;
2950
}
2951
2952
static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2953
{
2954
CharDriverState *chr;
2955
WinCharState *s;
2956
2957
chr = qemu_mallocz(sizeof(CharDriverState));
2958
if (!chr)
2959
return NULL;
2960
s = qemu_mallocz(sizeof(WinCharState));
2961
if (!s) {
2962
free(chr);
2963
return NULL;
2964
}
2965
s->hcom = fd_out;
2966
chr->opaque = s;
2967
chr->chr_write = win_chr_write;
2968
qemu_chr_reset(chr);
2969
return chr;
2970
}
2971
2972
static CharDriverState *qemu_chr_open_win_con(const char *filename)
2973
{
2974
return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
2975
}
2976
2977
static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2978
{
2979
HANDLE fd_out;
2980
2981
fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2982
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2983
if (fd_out == INVALID_HANDLE_VALUE)
2984
return NULL;
2985
2986
return qemu_chr_open_win_file(fd_out);
2987
}
2988
#endif /* !_WIN32 */
2989
2990
/***********************************************************/
2991
/* UDP Net console */
2992
2993
typedef struct {
2994
int fd;
2995
struct sockaddr_in daddr;
2996
uint8_t buf[1024];
2997
int bufcnt;
2998
int bufptr;
2999
int max_size;
3000
} NetCharDriver;
3001
3002
static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3003
{
3004
NetCharDriver *s = chr->opaque;
3005
3006
return sendto(s->fd, buf, len, 0,
3007
(struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
3008
}
3009
3010
static int udp_chr_read_poll(void *opaque)
3011
{
3012
CharDriverState *chr = opaque;
3013
NetCharDriver *s = chr->opaque;
3014
3015
s->max_size = qemu_chr_can_read(chr);
3016
3017
/* If there were any stray characters in the queue process them
3018
* first
3019
*/
3020
while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3021
qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3022
s->bufptr++;
3023
s->max_size = qemu_chr_can_read(chr);
3024
}
3025
return s->max_size;
3026
}
3027
3028
static void udp_chr_read(void *opaque)
3029
{
3030
CharDriverState *chr = opaque;
3031
NetCharDriver *s = chr->opaque;
3032
3033
if (s->max_size == 0)
3034
return;
3035
s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
3036
s->bufptr = s->bufcnt;
3037
if (s->bufcnt <= 0)
3038
return;
3039
3040
s->bufptr = 0;
3041
while (s->max_size > 0 && s->bufptr < s->bufcnt) {
3042
qemu_chr_read(chr, &s->buf[s->bufptr], 1);
3043
s->bufptr++;
3044
s->max_size = qemu_chr_can_read(chr);
3045
}
3046
}
3047
3048
static void udp_chr_update_read_handler(CharDriverState *chr)
3049
{
3050
NetCharDriver *s = chr->opaque;
3051
3052
if (s->fd >= 0) {
3053
qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3054
udp_chr_read, NULL, chr);
3055
}
3056
}
3057
3058
int parse_host_port(struct sockaddr_in *saddr, const char *str);
3059
#ifndef _WIN32
3060
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3061
#endif
3062
int parse_host_src_port(struct sockaddr_in *haddr,
3063
struct sockaddr_in *saddr,
3064
const char *str);
3065
3066
static CharDriverState *qemu_chr_open_udp(const char *def)
3067
{
3068
CharDriverState *chr = NULL;
3069
NetCharDriver *s = NULL;
3070
int fd = -1;
3071
struct sockaddr_in saddr;
3072
3073
chr = qemu_mallocz(sizeof(CharDriverState));
3074
if (!chr)
3075
goto return_err;
3076
s = qemu_mallocz(sizeof(NetCharDriver));
3077
if (!s)
3078
goto return_err;
3079
3080
fd = socket(PF_INET, SOCK_DGRAM, 0);
3081
if (fd < 0) {
3082
perror("socket(PF_INET, SOCK_DGRAM)");
3083
goto return_err;
3084
}
3085
3086
if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3087
printf("Could not parse: %s\n", def);
3088
goto return_err;
3089
}
3090
3091
if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3092
{
3093
perror("bind");
3094
goto return_err;
3095
}
3096
3097
s->fd = fd;
3098
s->bufcnt = 0;
3099
s->bufptr = 0;
3100
chr->opaque = s;
3101
chr->chr_write = udp_chr_write;
3102
chr->chr_update_read_handler = udp_chr_update_read_handler;
3103
return chr;
3104
3105
return_err:
3106
if (chr)
3107
free(chr);
3108
if (s)
3109
free(s);
3110
if (fd >= 0)
3111
closesocket(fd);
3112
return NULL;
3113
}
3114
3115
/***********************************************************/
3116
/* TCP Net console */
3117
3118
typedef struct {
3119
int fd, listen_fd;
3120
int connected;
3121
int max_size;
3122
int do_telnetopt;
3123
int do_nodelay;
3124
int is_unix;
3125
} TCPCharDriver;
3126
3127
static void tcp_chr_accept(void *opaque);
3128
3129
static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3130
{
3131
TCPCharDriver *s = chr->opaque;
3132
if (s->connected) {
3133
return send_all(s->fd, buf, len);
3134
} else {
3135
/* XXX: indicate an error ? */
3136
return len;
3137
}
3138
}
3139
3140
static int tcp_chr_read_poll(void *opaque)
3141
{
3142
CharDriverState *chr = opaque;
3143
TCPCharDriver *s = chr->opaque;
3144
if (!s->connected)
3145
return 0;
3146
s->max_size = qemu_chr_can_read(chr);
3147
return s->max_size;
3148
}
3149
3150
#define IAC 255
3151
#define IAC_BREAK 243
3152
static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3153
TCPCharDriver *s,
3154
uint8_t *buf, int *size)
3155
{
3156
/* Handle any telnet client's basic IAC options to satisfy char by
3157
* char mode with no echo. All IAC options will be removed from
3158
* the buf and the do_telnetopt variable will be used to track the
3159
* state of the width of the IAC information.
3160
*
3161
* IAC commands come in sets of 3 bytes with the exception of the
3162
* "IAC BREAK" command and the double IAC.
3163
*/
3164
3165
int i;
3166
int j = 0;
3167
3168
for (i = 0; i < *size; i++) {
3169
if (s->do_telnetopt > 1) {
3170
if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3171
/* Double IAC means send an IAC */
3172
if (j != i)
3173
buf[j] = buf[i];
3174
j++;
3175
s->do_telnetopt = 1;
3176
} else {
3177
if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3178
/* Handle IAC break commands by sending a serial break */
3179
qemu_chr_event(chr, CHR_EVENT_BREAK);
3180
s->do_telnetopt++;
3181
}
3182
s->do_telnetopt++;
3183
}
3184
if (s->do_telnetopt >= 4) {
3185
s->do_telnetopt = 1;
3186
}
3187
} else {
3188
if ((unsigned char)buf[i] == IAC) {
3189
s->do_telnetopt = 2;
3190
} else {
3191
if (j != i)
3192
buf[j] = buf[i];
3193
j++;
3194
}
3195
}
3196
}
3197
*size = j;
3198
}
3199
3200
static void tcp_chr_read(void *opaque)
3201
{
3202
CharDriverState *chr = opaque;
3203
TCPCharDriver *s = chr->opaque;
3204
uint8_t buf[1024];
3205
int len, size;
3206
3207
if (!s->connected || s->max_size <= 0)
3208
return;
3209
len = sizeof(buf);
3210
if (len > s->max_size)
3211
len = s->max_size;
3212
size = recv(s->fd, buf, len, 0);
3213
if (size == 0) {
3214
/* connection closed */
3215
s->connected = 0;
3216
if (s->listen_fd >= 0) {
3217
qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3218
}
3219
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3220
closesocket(s->fd);
3221
s->fd = -1;
3222
} else if (size > 0) {
3223
if (s->do_telnetopt)
3224
tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3225
if (size > 0)
3226
qemu_chr_read(chr, buf, size);
3227
}
3228
}
3229
3230
static void tcp_chr_connect(void *opaque)
3231
{
3232
CharDriverState *chr = opaque;
3233
TCPCharDriver *s = chr->opaque;
3234
3235
s->connected = 1;
3236
qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3237
tcp_chr_read, NULL, chr);
3238
qemu_chr_reset(chr);
3239
}
3240
3241
#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3242
static void tcp_chr_telnet_init(int fd)
3243
{
3244
char buf[3];
3245
/* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3246
IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3247
send(fd, (char *)buf, 3, 0);
3248
IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3249
send(fd, (char *)buf, 3, 0);
3250
IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3251
send(fd, (char *)buf, 3, 0);
3252
IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3253
send(fd, (char *)buf, 3, 0);
3254
}
3255
3256
static void socket_set_nodelay(int fd)
3257
{
3258
int val = 1;
3259
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3260
}
3261
3262
static void tcp_chr_accept(void *opaque)
3263
{
3264
CharDriverState *chr = opaque;
3265
TCPCharDriver *s = chr->opaque;
3266
struct sockaddr_in saddr;
3267
#ifndef _WIN32
3268
struct sockaddr_un uaddr;
3269
#endif
3270
struct sockaddr *addr;
3271
socklen_t len;
3272
int fd;
3273
3274
for(;;) {
3275
#ifndef _WIN32
3276
if (s->is_unix) {
3277
len = sizeof(uaddr);
3278
addr = (struct sockaddr *)&uaddr;
3279
} else
3280
#endif
3281
{
3282
len = sizeof(saddr);
3283
addr = (struct sockaddr *)&saddr;
3284
}
3285
fd = accept(s->listen_fd, addr, &len);
3286
if (fd < 0 && errno != EINTR) {
3287
return;
3288
} else if (fd >= 0) {
3289
if (s->do_telnetopt)
3290
tcp_chr_telnet_init(fd);
3291
break;
3292
}
3293
}
3294
socket_set_nonblock(fd);
3295
if (s->do_nodelay)
3296
socket_set_nodelay(fd);
3297
s->fd = fd;
3298
qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3299
tcp_chr_connect(chr);
3300
}
3301
3302
static void tcp_chr_close(CharDriverState *chr)
3303
{
3304
TCPCharDriver *s = chr->opaque;
3305
if (s->fd >= 0)
3306
closesocket(s->fd);
3307
if (s->listen_fd >= 0)
3308
closesocket(s->listen_fd);
3309
qemu_free(s);
3310
}
3311
3312
static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3313
int is_telnet,
3314
int is_unix)
3315
{
3316
CharDriverState *chr = NULL;
3317
TCPCharDriver *s = NULL;
3318
int fd = -1, ret, err, val;
3319
int is_listen = 0;
3320
int is_waitconnect = 1;
3321
int do_nodelay = 0;
3322
const char *ptr;
3323
struct sockaddr_in saddr;
3324
#ifndef _WIN32
3325
struct sockaddr_un uaddr;
3326
#endif
3327
struct sockaddr *addr;
3328
socklen_t addrlen;
3329
3330
#ifndef _WIN32
3331
if (is_unix) {
3332
addr = (struct sockaddr *)&uaddr;
3333
addrlen = sizeof(uaddr);
3334
if (parse_unix_path(&uaddr, host_str) < 0)
3335
goto fail;
3336
} else
3337
#endif
3338
{
3339
addr = (struct sockaddr *)&saddr;
3340
addrlen = sizeof(saddr);
3341
if (parse_host_port(&saddr, host_str) < 0)
3342
goto fail;
3343
}
3344
3345
ptr = host_str;
3346
while((ptr = strchr(ptr,','))) {
3347
ptr++;
3348
if (!strncmp(ptr,"server",6)) {
3349
is_listen = 1;
3350
} else if (!strncmp(ptr,"nowait",6)) {
3351
is_waitconnect = 0;
3352
} else if (!strncmp(ptr,"nodelay",6)) {
3353
do_nodelay = 1;
3354
} else {
3355
printf("Unknown option: %s\n", ptr);
3356
goto fail;
3357
}
3358
}
3359
if (!is_listen)
3360
is_waitconnect = 0;
3361
3362
chr = qemu_mallocz(sizeof(CharDriverState));
3363
if (!chr)
3364
goto fail;
3365
s = qemu_mallocz(sizeof(TCPCharDriver));
3366
if (!s)
3367
goto fail;
3368
3369
#ifndef _WIN32
3370
if (is_unix)
3371
fd = socket(PF_UNIX, SOCK_STREAM, 0);
3372
else
3373
#endif
3374
fd = socket(PF_INET, SOCK_STREAM, 0);
3375
3376
if (fd < 0)
3377
goto fail;
3378
3379
if (!is_waitconnect)
3380
socket_set_nonblock(fd);
3381
3382
s->connected = 0;
3383
s->fd = -1;
3384
s->listen_fd = -1;
3385
s->is_unix = is_unix;
3386
s->do_nodelay = do_nodelay && !is_unix;
3387
3388
chr->opaque = s;
3389
chr->chr_write = tcp_chr_write;
3390
chr->chr_close = tcp_chr_close;
3391
3392
if (is_listen) {
3393
/* allow fast reuse */
3394
#ifndef _WIN32
3395
if (is_unix) {
3396
char path[109];
3397
strncpy(path, uaddr.sun_path, 108);
3398
path[108] = 0;
3399
unlink(path);
3400
} else
3401
#endif
3402
{
3403
val = 1;
3404
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3405
}
3406
3407
ret = bind(fd, addr, addrlen);
3408
if (ret < 0)
3409
goto fail;
3410
3411
ret = listen(fd, 0);
3412
if (ret < 0)
3413
goto fail;
3414
3415
s->listen_fd = fd;
3416
qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3417
if (is_telnet)
3418
s->do_telnetopt = 1;
3419
} else {
3420
for(;;) {
3421
ret = connect(fd, addr, addrlen);
3422
if (ret < 0) {
3423
err = socket_error();
3424
if (err == EINTR || err == EWOULDBLOCK) {
3425
} else if (err == EINPROGRESS) {
3426
break;
3427
#ifdef _WIN32
3428
} else if (err == WSAEALREADY) {
3429
break;
3430
#endif
3431
} else {
3432
goto fail;
3433
}
3434
} else {
3435
s->connected = 1;
3436
break;
3437
}
3438
}
3439
s->fd = fd;
3440
socket_set_nodelay(fd);
3441
if (s->connected)
3442
tcp_chr_connect(chr);
3443
else
3444
qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3445
}
3446
3447
if (is_listen && is_waitconnect) {
3448
printf("QEMU waiting for connection on: %s\n", host_str);
3449
tcp_chr_accept(chr);
3450
socket_set_nonblock(s->listen_fd);
3451
}
3452
3453
return chr;
3454
fail:
3455
if (fd >= 0)
3456
closesocket(fd);
3457
qemu_free(s);
3458
qemu_free(chr);
3459
return NULL;
3460
}
3461
3462
CharDriverState *qemu_chr_open(const char *filename)
3463
{
3464
const char *p;
3465
3466
if (!strcmp(filename, "vc")) {
3467
return text_console_init(&display_state, 0);
3468
} else if (strstart(filename, "vc:", &p)) {
3469
return text_console_init(&display_state, p);
3470
} else if (!strcmp(filename, "null")) {
3471
return qemu_chr_open_null();
3472
} else
3473
if (strstart(filename, "tcp:", &p)) {
3474
return qemu_chr_open_tcp(p, 0, 0);
3475
} else
3476
if (strstart(filename, "telnet:", &p)) {
3477
return qemu_chr_open_tcp(p, 1, 0);
3478
} else
3479
if (strstart(filename, "udp:", &p)) {
3480
return qemu_chr_open_udp(p);
3481
} else
3482
if (strstart(filename, "mon:", &p)) {
3483
CharDriverState *drv = qemu_chr_open(p);
3484
if (drv) {
3485
drv = qemu_chr_open_mux(drv);
3486
monitor_init(drv, !nographic);
3487
return drv;
3488
}
3489
printf("Unable to open driver: %s\n", p);
3490
return 0;
3491
} else
3492
#ifndef _WIN32
3493
if (strstart(filename, "unix:", &p)) {
3494
return qemu_chr_open_tcp(p, 0, 1);
3495
} else if (strstart(filename, "file:", &p)) {
3496
return qemu_chr_open_file_out(p);
3497
} else if (strstart(filename, "pipe:", &p)) {
3498
return qemu_chr_open_pipe(p);
3499
} else if (!strcmp(filename, "pty")) {
3500
return qemu_chr_open_pty();
3501
} else if (!strcmp(filename, "stdio")) {
3502
return qemu_chr_open_stdio();
3503
} else
3504
#if defined(__linux__)
3505
if (strstart(filename, "/dev/parport", NULL)) {
3506
return qemu_chr_open_pp(filename);
3507
} else
3508
#endif
3509
#if defined(__linux__) || defined(__sun__)
3510
if (strstart(filename, "/dev/", NULL)) {
3511
return qemu_chr_open_tty(filename);
3512
} else
3513
#endif
3514
#else /* !_WIN32 */
3515
if (strstart(filename, "COM", NULL)) {
3516
return qemu_chr_open_win(filename);
3517
} else
3518
if (strstart(filename, "pipe:", &p)) {
3519
return qemu_chr_open_win_pipe(p);
3520
} else
3521
if (strstart(filename, "con:", NULL)) {
3522
return qemu_chr_open_win_con(filename);
3523
} else
3524
if (strstart(filename, "file:", &p)) {
3525
return qemu_chr_open_win_file_out(p);
3526
} else
3527
#endif
3528
#ifdef CONFIG_BRLAPI
3529
if (!strcmp(filename, "braille")) {
3530
return chr_baum_init();
3531
} else
3532
#endif
3533
{
3534
return NULL;
3535
}
3536
}
3537
3538
void qemu_chr_close(CharDriverState *chr)
3539
{
3540
if (chr->chr_close)
3541
chr->chr_close(chr);
3542
qemu_free(chr);
3543
}
3544
3545
/***********************************************************/
3546
/* network device redirectors */
3547
3548
__attribute__ (( unused ))
3549
static void hex_dump(FILE *f, const uint8_t *buf, int size)
3550
{
3551
int len, i, j, c;
3552
3553
for(i=0;i<size;i+=16) {
3554
len = size - i;
3555
if (len > 16)
3556
len = 16;
3557
fprintf(f, "%08x ", i);
3558
for(j=0;j<16;j++) {
3559
if (j < len)
3560
fprintf(f, " %02x", buf[i+j]);
3561
else
3562
fprintf(f, " ");
3563
}
3564
fprintf(f, " ");
3565
for(j=0;j<len;j++) {
3566
c = buf[i+j];
3567
if (c < ' ' || c > '~')
3568
c = '.';
3569
fprintf(f, "%c", c);
3570
}
3571
fprintf(f, "\n");
3572
}
3573
}
3574
3575
static int parse_macaddr(uint8_t *macaddr, const char *p)
3576
{
3577
int i;
3578
char *last_char;
3579
long int offset;
3580
3581
errno = 0;
3582
offset = strtol(p, &last_char, 0);
3583
if (0 == errno && '\0' == *last_char &&
3584
offset >= 0 && offset <= 0xFFFFFF) {
3585
macaddr[3] = (offset & 0xFF0000) >> 16;
3586
macaddr[4] = (offset & 0xFF00) >> 8;
3587
macaddr[5] = offset & 0xFF;
3588
return 0;
3589
} else {
3590
for(i = 0; i < 6; i++) {
3591
macaddr[i] = strtol(p, (char **)&p, 16);
3592
if (i == 5) {
3593
if (*p != '\0')
3594
return -1;
3595
} else {
3596
if (*p != ':' && *p != '-')
3597
return -1;
3598
p++;
3599
}
3600
}
3601
return 0;
3602
}
3603
3604
return -1;
3605
}
3606
3607
static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3608
{
3609
const char *p, *p1;
3610
int len;
3611
p = *pp;
3612
p1 = strchr(p, sep);
3613
if (!p1)
3614
return -1;
3615
len = p1 - p;
3616
p1++;
3617
if (buf_size > 0) {
3618
if (len > buf_size - 1)
3619
len = buf_size - 1;
3620
memcpy(buf, p, len);
3621
buf[len] = '\0';
3622
}
3623
*pp = p1;
3624
return 0;
3625
}
3626
3627
int parse_host_src_port(struct sockaddr_in *haddr,
3628
struct sockaddr_in *saddr,
3629
const char *input_str)
3630
{
3631
char *str = strdup(input_str);
3632
char *host_str = str;
3633
char *src_str;
3634
char *ptr;
3635
3636
/*
3637
* Chop off any extra arguments at the end of the string which
3638
* would start with a comma, then fill in the src port information
3639
* if it was provided else use the "any address" and "any port".
3640
*/
3641
if ((ptr = strchr(str,',')))
3642
*ptr = '\0';
3643
3644
if ((src_str = strchr(input_str,'@'))) {
3645
*src_str = '\0';
3646
src_str++;
3647
}
3648
3649
if (parse_host_port(haddr, host_str) < 0)
3650
goto fail;
3651
3652
if (!src_str || *src_str == '\0')
3653
src_str = ":0";
3654
3655
if (parse_host_port(saddr, src_str) < 0)
3656
goto fail;
3657
3658
free(str);
3659
return(0);
3660
3661
fail:
3662
free(str);
3663
return -1;
3664
}
3665
3666
int parse_host_port(struct sockaddr_in *saddr, const char *str)
3667
{
3668
char buf[512];
3669
struct hostent *he;
3670
const char *p, *r;
3671
int port;
3672
3673
p = str;
3674
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3675
return -1;
3676
saddr->sin_family = AF_INET;
3677
if (buf[0] == '\0') {
3678
saddr->sin_addr.s_addr = 0;
3679
} else {
3680
if (isdigit(buf[0])) {
3681
if (!inet_aton(buf, &saddr->sin_addr))
3682
return -1;
3683
} else {
3684
if ((he = gethostbyname(buf)) == NULL)
3685
return - 1;
3686
saddr->sin_addr = *(struct in_addr *)he->h_addr;
3687
}
3688
}
3689
port = strtol(p, (char **)&r, 0);
3690
if (r == p)
3691
return -1;
3692
saddr->sin_port = htons(port);
3693
return 0;
3694
}
3695
3696
#ifndef _WIN32
3697
static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3698
{
3699
const char *p;
3700
int len;
3701
3702
len = MIN(108, strlen(str));
3703
p = strchr(str, ',');
3704
if (p)
3705
len = MIN(len, p - str);
3706
3707
memset(uaddr, 0, sizeof(*uaddr));
3708
3709
uaddr->sun_family = AF_UNIX;
3710
memcpy(uaddr->sun_path, str, len);
3711
3712
return 0;
3713
}
3714
#endif
3715
3716
/* find or alloc a new VLAN */
3717
VLANState *qemu_find_vlan(int id)
3718
{
3719
VLANState **pvlan, *vlan;
3720
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1590
#endif
1591
1592
/***********************************************************/
1593
/* Bluetooth support */
1594
static int nb_hcis;
1595
static int cur_hci;
1596
static struct HCIInfo *hci_table[MAX_NICS];
1597
1598
static struct bt_vlan_s {
1599
struct bt_scatternet_s net;
1600
int id;
1601
struct bt_vlan_s *next;
1602
} *first_bt_vlan;
1603
1604
/* find or alloc a new bluetooth "VLAN" */
1605
static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1606
{
1607
struct bt_vlan_s **pvlan, *vlan;
1608
for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
3721
1609
if (vlan->id == id)
3722
return vlan;
1610
return &vlan->net;
3723
1611
}
3724
vlan = qemu_mallocz(sizeof(VLANState));
3725
if (!vlan)
3726
return NULL;
1612
vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
3727
1613
vlan->id = id;
3728
vlan->next = NULL;
3729
pvlan = &first_vlan;
1614
pvlan = &first_bt_vlan;
3730
1615
while (*pvlan != NULL)
3731
1616
pvlan = &(*pvlan)->next;
3732
1617
*pvlan = vlan;
3733
return vlan;
3734
}
3735
3736
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3737
IOReadHandler *fd_read,
3738
IOCanRWHandler *fd_can_read,
3739
void *opaque)
3740
{
3741
VLANClientState *vc, **pvc;
3742
vc = qemu_mallocz(sizeof(VLANClientState));
3743
if (!vc)
3744
return NULL;
3745
vc->fd_read = fd_read;
3746
vc->fd_can_read = fd_can_read;
3747
vc->opaque = opaque;
3748
vc->vlan = vlan;
3749
3750
vc->next = NULL;
3751
pvc = &vlan->first_client;
3752
while (*pvc != NULL)
3753
pvc = &(*pvc)->next;
3754
*pvc = vc;
3755
return vc;
3756
}
3757
3758
int qemu_can_send_packet(VLANClientState *vc1)
3759
{
3760
VLANState *vlan = vc1->vlan;
3761
VLANClientState *vc;
3762
3763
for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3764
if (vc != vc1) {
3765
if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3766
return 1;
3767
}
3768
}
3769
return 0;
3770
}
3771
3772
void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3773
{
3774
VLANState *vlan = vc1->vlan;
3775
VLANClientState *vc;
3776
3777
#if 0
3778
printf("vlan %d send:\n", vlan->id);
3779
hex_dump(stdout, buf, size);
3780
#endif
3781
for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3782
if (vc != vc1) {
3783
vc->fd_read(vc->opaque, buf, size);
3784
}
3785
}
3786
}
3787
3788
#if defined(CONFIG_SLIRP)
3789
3790
/* slirp network adapter */
3791
3792
static int slirp_inited;
3793
static VLANClientState *slirp_vc;
3794
3795
int slirp_can_output(void)
3796
{
3797
return !slirp_vc || qemu_can_send_packet(slirp_vc);
3798
}
3799
3800
void slirp_output(const uint8_t *pkt, int pkt_len)
3801
{
3802
#if 0
3803
printf("slirp output:\n");
3804
hex_dump(stdout, pkt, pkt_len);
3805
#endif
3806
if (!slirp_vc)
3807
return;
3808
qemu_send_packet(slirp_vc, pkt, pkt_len);
3809
}
3810
3811
static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3812
{
3813
#if 0
3814
printf("slirp input:\n");
3815
hex_dump(stdout, buf, size);
3816
#endif
3817
slirp_input(buf, size);
3818
}
3819
3820
static int net_slirp_init(VLANState *vlan)
3821
{
3822
if (!slirp_inited) {
3823
slirp_inited = 1;
3824
slirp_init();
3825
}
3826
slirp_vc = qemu_new_vlan_client(vlan,
3827
slirp_receive, NULL, NULL);
3828
snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3829
return 0;
3830
}
3831
3832
static void net_slirp_redir(const char *redir_str)
3833
{
3834
int is_udp;
3835
char buf[256], *r;
3836
const char *p;
3837
struct in_addr guest_addr;
3838
int host_port, guest_port;
3839
3840
if (!slirp_inited) {
3841
slirp_inited = 1;
3842
slirp_init();
3843
}
3844
3845
p = redir_str;
3846
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3847
goto fail;
3848
if (!strcmp(buf, "tcp")) {
3849
is_udp = 0;
3850
} else if (!strcmp(buf, "udp")) {
3851
is_udp = 1;
3852
} else {
3853
goto fail;
3854
}
3855
3856
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3857
goto fail;
3858
host_port = strtol(buf, &r, 0);
3859
if (r == buf)
3860
goto fail;
3861
3862
if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3863
goto fail;
3864
if (buf[0] == '\0') {
3865
pstrcpy(buf, sizeof(buf), "10.0.2.15");
3866
}
3867
if (!inet_aton(buf, &guest_addr))
3868
goto fail;
3869
3870
guest_port = strtol(p, &r, 0);
3871
if (r == p)
3872
goto fail;
3873
3874
if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3875
fprintf(stderr, "qemu: could not set up redirection\n");
3876
exit(1);
3877
}
3878
return;
3879
fail:
3880
fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3881
exit(1);
3882
}
3883
3884
#ifndef _WIN32
3885
3886
char smb_dir[1024];
3887
3888
static void erase_dir(char *dir_name)
3889
{
3890
DIR *d;
3891
struct dirent *de;
3892
char filename[1024];
3893
3894
/* erase all the files in the directory */
3895
if ((d = opendir(dir_name)) != 0) {
3896
for(;;) {
3897
de = readdir(d);
3898
if (!de)
3899
break;
3900
if (strcmp(de->d_name, ".") != 0 &&
3901
strcmp(de->d_name, "..") != 0) {
3902
snprintf(filename, sizeof(filename), "%s/%s",
3903
smb_dir, de->d_name);
3904
if (unlink(filename) != 0) /* is it a directory? */
3905
erase_dir(filename);
3906
}
3907
}
3908
closedir(d);
3909
rmdir(dir_name);
3910
}
3911
}
3912
3913
/* automatic user mode samba server configuration */
3914
static void smb_exit(void)
3915
{
3916
erase_dir(smb_dir);
3917
}
3918
3919
/* automatic user mode samba server configuration */
3920
static void net_slirp_smb(const char *exported_dir)
3921
{
3922
char smb_conf[1024];
3923
char smb_cmdline[1024];
3924
FILE *f;
3925
3926
if (!slirp_inited) {
3927
slirp_inited = 1;
3928
slirp_init();
3929
}
3930
3931
/* XXX: better tmp dir construction */
3932
snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3933
if (mkdir(smb_dir, 0700) < 0) {
3934
fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3935
exit(1);
3936
}
3937
snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3938
3939
f = fopen(smb_conf, "w");
3940
if (!f) {
3941
fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3942
exit(1);
3943
}
3944
fprintf(f,
3945
"[global]\n"
3946
"private dir=%s\n"
3947
"smb ports=0\n"
3948
"socket address=127.0.0.1\n"
3949
"pid directory=%s\n"
3950
"lock directory=%s\n"
3951
"log file=%s/log.smbd\n"
3952
"smb passwd file=%s/smbpasswd\n"
3953
"security = share\n"
3954
"[qemu]\n"
3955
"path=%s\n"
3956
"read only=no\n"
3957
"guest ok=yes\n",
3958
smb_dir,
3959
smb_dir,
3960
smb_dir,
3961
smb_dir,
3962
smb_dir,
3963
exported_dir
3964
);
3965
fclose(f);
3966
atexit(smb_exit);
3967
3968
snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3969
SMBD_COMMAND, smb_conf);
3970
3971
slirp_add_exec(0, smb_cmdline, 4, 139);
3972
}
3973
3974
#endif /* !defined(_WIN32) */
3975
void do_info_slirp(void)
3976
{
3977
slirp_stats();
3978
}
3979
3980
#endif /* CONFIG_SLIRP */
3981
3982
#if !defined(_WIN32)
3983
3984
typedef struct TAPState {
3985
VLANClientState *vc;
3986
int fd;
3987
char down_script[1024];
3988
} TAPState;
3989
3990
static void tap_receive(void *opaque, const uint8_t *buf, int size)
3991
{
3992
TAPState *s = opaque;
3993
int ret;
3994
for(;;) {
3995
ret = write(s->fd, buf, size);
3996
if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3997
} else {
3998
break;
3999
}
4000
}
4001
}
4002
4003
static void tap_send(void *opaque)
4004
{
4005
TAPState *s = opaque;
4006
uint8_t buf[4096];
4007
int size;
4008
4009
#ifdef __sun__
4010
struct strbuf sbuf;
4011
int f = 0;
4012
sbuf.maxlen = sizeof(buf);
4013
sbuf.buf = buf;
4014
size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
4015
#else
4016
size = read(s->fd, buf, sizeof(buf));
4017
#endif
4018
if (size > 0) {
4019
qemu_send_packet(s->vc, buf, size);
4020
}
4021
}
4022
4023
/* fd support */
4024
4025
static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
4026
{
4027
TAPState *s;
4028
4029
s = qemu_mallocz(sizeof(TAPState));
4030
if (!s)
4031
return NULL;
4032
s->fd = fd;
4033
s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
4034
qemu_set_fd_handler(s->fd, tap_send, NULL, s);
4035
snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
4036
return s;
4037
}
4038
4039
#if defined (_BSD) || defined (__FreeBSD_kernel__)
4040
static int tap_open(char *ifname, int ifname_size)
4041
{
4042
int fd;
4043
char *dev;
4044
struct stat s;
4045
4046
TFR(fd = open("/dev/tap", O_RDWR));
4047
if (fd < 0) {
4048
fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
4049
return -1;
4050
}
4051
4052
fstat(fd, &s);
4053
dev = devname(s.st_rdev, S_IFCHR);
4054
pstrcpy(ifname, ifname_size, dev);
4055
4056
fcntl(fd, F_SETFL, O_NONBLOCK);
4057
return fd;
4058
}
4059
#elif defined(__sun__)
4060
#define TUNNEWPPA (('T'<<16) | 0x0001)
4061
/*
4062
* Allocate TAP device, returns opened fd.
4063
* Stores dev name in the first arg(must be large enough).
4064
*/
4065
int tap_alloc(char *dev)
4066
{
4067
int tap_fd, if_fd, ppa = -1;
4068
static int ip_fd = 0;
4069
char *ptr;
4070
4071
static int arp_fd = 0;
4072
int ip_muxid, arp_muxid;
4073
struct strioctl strioc_if, strioc_ppa;
4074
int link_type = I_PLINK;;
4075
struct lifreq ifr;
4076
char actual_name[32] = "";
4077
4078
memset(&ifr, 0x0, sizeof(ifr));
4079
4080
if( *dev ){
4081
ptr = dev;
4082
while( *ptr && !isdigit((int)*ptr) ) ptr++;
4083
ppa = atoi(ptr);
4084
}
4085
4086
/* Check if IP device was opened */
4087
if( ip_fd )
4088
close(ip_fd);
4089
4090
TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4091
if (ip_fd < 0) {
4092
syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4093
return -1;
4094
}
4095
4096
TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4097
if (tap_fd < 0) {
4098
syslog(LOG_ERR, "Can't open /dev/tap");
4099
return -1;
4100
}
4101
4102
/* Assign a new PPA and get its unit number. */
4103
strioc_ppa.ic_cmd = TUNNEWPPA;
4104
strioc_ppa.ic_timout = 0;
4105
strioc_ppa.ic_len = sizeof(ppa);
4106
strioc_ppa.ic_dp = (char *)&ppa;
4107
if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4108
syslog (LOG_ERR, "Can't assign new interface");
4109
4110
TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4111
if (if_fd < 0) {
4112
syslog(LOG_ERR, "Can't open /dev/tap (2)");
4113
return -1;
4114
}
4115
if(ioctl(if_fd, I_PUSH, "ip") < 0){
4116
syslog(LOG_ERR, "Can't push IP module");
4117
return -1;
4118
}
4119
4120
if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4121
syslog(LOG_ERR, "Can't get flags\n");
4122
4123
snprintf (actual_name, 32, "tap%d", ppa);
4124
strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4125
4126
ifr.lifr_ppa = ppa;
4127
/* Assign ppa according to the unit number returned by tun device */
4128
4129
if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4130
syslog (LOG_ERR, "Can't set PPA %d", ppa);
4131
if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4132
syslog (LOG_ERR, "Can't get flags\n");
4133
/* Push arp module to if_fd */
4134
if (ioctl (if_fd, I_PUSH, "arp") < 0)
4135
syslog (LOG_ERR, "Can't push ARP module (2)");
4136
4137
/* Push arp module to ip_fd */
4138
if (ioctl (ip_fd, I_POP, NULL) < 0)
4139
syslog (LOG_ERR, "I_POP failed\n");
4140
if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4141
syslog (LOG_ERR, "Can't push ARP module (3)\n");
4142
/* Open arp_fd */
4143
TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4144
if (arp_fd < 0)
4145
syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4146
4147
/* Set ifname to arp */
4148
strioc_if.ic_cmd = SIOCSLIFNAME;
4149
strioc_if.ic_timout = 0;
4150
strioc_if.ic_len = sizeof(ifr);
4151
strioc_if.ic_dp = (char *)𝔦
4152
if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4153
syslog (LOG_ERR, "Can't set ifname to arp\n");
4154
}
4155
4156
if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4157
syslog(LOG_ERR, "Can't link TAP device to IP");
4158
return -1;
4159
}
4160
4161
if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4162
syslog (LOG_ERR, "Can't link TAP device to ARP");
4163
4164
close (if_fd);
4165
4166
memset(&ifr, 0x0, sizeof(ifr));
4167
strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4168
ifr.lifr_ip_muxid = ip_muxid;
4169
ifr.lifr_arp_muxid = arp_muxid;
4170
4171
if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4172
{
4173
ioctl (ip_fd, I_PUNLINK , arp_muxid);
4174
ioctl (ip_fd, I_PUNLINK, ip_muxid);
4175
syslog (LOG_ERR, "Can't set multiplexor id");
4176
}
4177
4178
sprintf(dev, "tap%d", ppa);
4179
return tap_fd;
4180
}
4181
4182
static int tap_open(char *ifname, int ifname_size)
4183
{
4184
char dev[10]="";
4185
int fd;
4186
if( (fd = tap_alloc(dev)) < 0 ){
4187
fprintf(stderr, "Cannot allocate TAP device\n");
4188
return -1;
4189
}
4190
pstrcpy(ifname, ifname_size, dev);
4191
fcntl(fd, F_SETFL, O_NONBLOCK);
4192
return fd;
4193
}
4194
#else
4195
static int tap_open(char *ifname, int ifname_size)
4196
{
4197
struct ifreq ifr;
4198
int fd, ret;
4199
4200
TFR(fd = open("/dev/net/tun", O_RDWR));
4201
if (fd < 0) {
4202
fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4203
return -1;
4204
}
4205
memset(&ifr, 0, sizeof(ifr));
4206
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4207
if (ifname[0] != '\0')
4208
pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4209
else
4210
pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4211
ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4212
if (ret != 0) {
4213
fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4214
close(fd);
4215
return -1;
4216
}
4217
pstrcpy(ifname, ifname_size, ifr.ifr_name);
4218
fcntl(fd, F_SETFL, O_NONBLOCK);
4219
return fd;
4220
}
4221
#endif
4222
4223
static int launch_script(const char *setup_script, const char *ifname, int fd)
4224
{
4225
int pid, status;
4226
char *args[3];
4227
char **parg;
4228
4229
/* try to launch network script */
4230
pid = fork();
4231
if (pid >= 0) {
4232
if (pid == 0) {
4233
int open_max = sysconf (_SC_OPEN_MAX), i;
4234
for (i = 0; i < open_max; i++)
4235
if (i != STDIN_FILENO &&
4236
i != STDOUT_FILENO &&
4237
i != STDERR_FILENO &&
4238
i != fd)
4239
close(i);
4240
4241
parg = args;
4242
*parg++ = (char *)setup_script;
4243
*parg++ = (char *)ifname;
4244
*parg++ = NULL;
4245
execv(setup_script, args);
4246
_exit(1);
4247
}
4248
while (waitpid(pid, &status, 0) != pid);
4249
if (!WIFEXITED(status) ||
4250
WEXITSTATUS(status) != 0) {
4251
fprintf(stderr, "%s: could not launch network script\n",
4252
setup_script);
4253
return -1;
4254
}
4255
}
4256
return 0;
4257
}
4258
4259
static int net_tap_init(VLANState *vlan, const char *ifname1,
4260
const char *setup_script, const char *down_script)
4261
{
4262
TAPState *s;
4263
int fd;
4264
char ifname[128];
4265
4266
if (ifname1 != NULL)
4267
pstrcpy(ifname, sizeof(ifname), ifname1);
4268
else
4269
ifname[0] = '\0';
4270
TFR(fd = tap_open(ifname, sizeof(ifname)));
4271
if (fd < 0)
4272
return -1;
4273
4274
if (!setup_script || !strcmp(setup_script, "no"))
4275
setup_script = "";
4276
if (setup_script[0] != '\0') {
4277
if (launch_script(setup_script, ifname, fd))
4278
return -1;
4279
}
4280
s = net_tap_fd_init(vlan, fd);
4281
if (!s)
4282
return -1;
4283
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4284
"tap: ifname=%s setup_script=%s", ifname, setup_script);
4285
if (down_script && strcmp(down_script, "no"))
4286
snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4287
return 0;
4288
}
4289
4290
#endif /* !_WIN32 */
4291
4292
/* network connection */
4293
typedef struct NetSocketState {
4294
VLANClientState *vc;
4295
int fd;
4296
int state; /* 0 = getting length, 1 = getting data */
4297
int index;
4298
int packet_len;
4299
uint8_t buf[4096];
4300
struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4301
} NetSocketState;
4302
4303
typedef struct NetSocketListenState {
4304
VLANState *vlan;
4305
int fd;
4306
} NetSocketListenState;
4307
4308
/* XXX: we consider we can send the whole packet without blocking */
4309
static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4310
{
4311
NetSocketState *s = opaque;
4312
uint32_t len;
4313
len = htonl(size);
4314
4315
send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4316
send_all(s->fd, buf, size);
4317
}
4318
4319
static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4320
{
4321
NetSocketState *s = opaque;
4322
sendto(s->fd, buf, size, 0,
4323
(struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4324
}
4325
4326
static void net_socket_send(void *opaque)
4327
{
4328
NetSocketState *s = opaque;
4329
int l, size, err;
4330
uint8_t buf1[4096];
4331
const uint8_t *buf;
4332
4333
size = recv(s->fd, buf1, sizeof(buf1), 0);
4334
if (size < 0) {
4335
err = socket_error();
4336
if (err != EWOULDBLOCK)
4337
goto eoc;
4338
} else if (size == 0) {
4339
/* end of connection */
4340
eoc:
4341
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4342
closesocket(s->fd);
4343
return;
4344
}
4345
buf = buf1;
4346
while (size > 0) {
4347
/* reassemble a packet from the network */
4348
switch(s->state) {
4349
case 0:
4350
l = 4 - s->index;
4351
if (l > size)
4352
l = size;
4353
memcpy(s->buf + s->index, buf, l);
4354
buf += l;
4355
size -= l;
4356
s->index += l;
4357
if (s->index == 4) {
4358
/* got length */
4359
s->packet_len = ntohl(*(uint32_t *)s->buf);
4360
s->index = 0;
4361
s->state = 1;
4362
}
4363
break;
4364
case 1:
4365
l = s->packet_len - s->index;
4366
if (l > size)
4367
l = size;
4368
memcpy(s->buf + s->index, buf, l);
4369
s->index += l;
4370
buf += l;
4371
size -= l;
4372
if (s->index >= s->packet_len) {
4373
qemu_send_packet(s->vc, s->buf, s->packet_len);
4374
s->index = 0;
4375
s->state = 0;
4376
}
4377
break;
4378
}
4379
}
4380
}
4381
4382
static void net_socket_send_dgram(void *opaque)
4383
{
4384
NetSocketState *s = opaque;
4385
int size;
4386
4387
size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4388
if (size < 0)
4389
return;
4390
if (size == 0) {
4391
/* end of connection */
4392
qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4393
return;
4394
}
4395
qemu_send_packet(s->vc, s->buf, size);
4396
}
4397
4398
static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4399
{
4400
struct ip_mreq imr;
4401
int fd;
4402
int val, ret;
4403
if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4404
fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4405
inet_ntoa(mcastaddr->sin_addr),
4406
(int)ntohl(mcastaddr->sin_addr.s_addr));
4407
return -1;
4408
4409
}
4410
fd = socket(PF_INET, SOCK_DGRAM, 0);
4411
if (fd < 0) {
4412
perror("socket(PF_INET, SOCK_DGRAM)");
4413
return -1;
4414
}
4415
4416
val = 1;
4417
ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4418
(const char *)&val, sizeof(val));
4419
if (ret < 0) {
4420
perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4421
goto fail;
4422
}
4423
4424
ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4425
if (ret < 0) {
4426
perror("bind");
4427
goto fail;
4428
}
4429
4430
/* Add host to multicast group */
4431
imr.imr_multiaddr = mcastaddr->sin_addr;
4432
imr.imr_interface.s_addr = htonl(INADDR_ANY);
4433
4434
ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4435
(const char *)&imr, sizeof(struct ip_mreq));
4436
if (ret < 0) {
4437
perror("setsockopt(IP_ADD_MEMBERSHIP)");
4438
goto fail;
4439
}
4440
4441
/* Force mcast msgs to loopback (eg. several QEMUs in same host */
4442
val = 1;
4443
ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4444
(const char *)&val, sizeof(val));
4445
if (ret < 0) {
4446
perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4447
goto fail;
4448
}
4449
4450
socket_set_nonblock(fd);
4451
return fd;
4452
fail:
4453
if (fd >= 0)
4454
closesocket(fd);
4455
return -1;
4456
}
4457
4458
static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4459
int is_connected)
4460
{
4461
struct sockaddr_in saddr;
4462
int newfd;
4463
socklen_t saddr_len;
4464
NetSocketState *s;
4465
4466
/* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4467
* Because this may be "shared" socket from a "master" process, datagrams would be recv()
4468
* by ONLY ONE process: we must "clone" this dgram socket --jjo
4469
*/
4470
4471
if (is_connected) {
4472
if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4473
/* must be bound */
4474
if (saddr.sin_addr.s_addr==0) {
4475
fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4476
fd);
4477
return NULL;
4478
}
4479
/* clone dgram socket */
4480
newfd = net_socket_mcast_create(&saddr);
4481
if (newfd < 0) {
4482
/* error already reported by net_socket_mcast_create() */
4483
close(fd);
4484
return NULL;
4485
}
4486
/* clone newfd to fd, close newfd */
4487
dup2(newfd, fd);
4488
close(newfd);
4489
4490
} else {
4491
fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4492
fd, strerror(errno));
4493
return NULL;
4494
}
4495
}
4496
4497
s = qemu_mallocz(sizeof(NetSocketState));
4498
if (!s)
4499
return NULL;
4500
s->fd = fd;
4501
4502
s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4503
qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4504
4505
/* mcast: save bound address as dst */
4506
if (is_connected) s->dgram_dst=saddr;
4507
4508
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4509
"socket: fd=%d (%s mcast=%s:%d)",
4510
fd, is_connected? "cloned" : "",
4511
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4512
return s;
4513
}
4514
4515
static void net_socket_connect(void *opaque)
4516
{
4517
NetSocketState *s = opaque;
4518
qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4519
}
4520
4521
static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4522
int is_connected)
4523
{
4524
NetSocketState *s;
4525
s = qemu_mallocz(sizeof(NetSocketState));
4526
if (!s)
4527
return NULL;
4528
s->fd = fd;
4529
s->vc = qemu_new_vlan_client(vlan,
4530
net_socket_receive, NULL, s);
4531
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4532
"socket: fd=%d", fd);
4533
if (is_connected) {
4534
net_socket_connect(s);
4535
} else {
4536
qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4537
}
4538
return s;
4539
}
4540
4541
static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4542
int is_connected)
4543
{
4544
int so_type=-1, optlen=sizeof(so_type);
4545
4546
if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4547
(socklen_t *)&optlen)< 0) {
4548
fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4549
return NULL;
4550
}
4551
switch(so_type) {
4552
case SOCK_DGRAM:
4553
return net_socket_fd_init_dgram(vlan, fd, is_connected);
4554
case SOCK_STREAM:
4555
return net_socket_fd_init_stream(vlan, fd, is_connected);
4556
default:
4557
/* who knows ... this could be a eg. a pty, do warn and continue as stream */
4558
fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4559
return net_socket_fd_init_stream(vlan, fd, is_connected);
4560
}
4561
return NULL;
4562
}
4563
4564
static void net_socket_accept(void *opaque)
4565
{
4566
NetSocketListenState *s = opaque;
4567
NetSocketState *s1;
4568
struct sockaddr_in saddr;
4569
socklen_t len;
4570
int fd;
4571
4572
for(;;) {
4573
len = sizeof(saddr);
4574
fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4575
if (fd < 0 && errno != EINTR) {
4576
return;
4577
} else if (fd >= 0) {
4578
break;
4579
}
4580
}
4581
s1 = net_socket_fd_init(s->vlan, fd, 1);
4582
if (!s1) {
4583
closesocket(fd);
4584
} else {
4585
snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4586
"socket: connection from %s:%d",
4587
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4588
}
4589
}
4590
4591
static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4592
{
4593
NetSocketListenState *s;
4594
int fd, val, ret;
4595
struct sockaddr_in saddr;
4596
4597
if (parse_host_port(&saddr, host_str) < 0)
4598
return -1;
4599
4600
s = qemu_mallocz(sizeof(NetSocketListenState));
4601
if (!s)
4602
return -1;
4603
4604
fd = socket(PF_INET, SOCK_STREAM, 0);
4605
if (fd < 0) {
4606
perror("socket");
4607
return -1;
4608
}
4609
socket_set_nonblock(fd);
4610
4611
/* allow fast reuse */
4612
val = 1;
4613
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4614
4615
ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4616
if (ret < 0) {
4617
perror("bind");
4618
return -1;
4619
}
4620
ret = listen(fd, 0);
4621
if (ret < 0) {
4622
perror("listen");
4623
return -1;
4624
}
4625
s->vlan = vlan;
4626
s->fd = fd;
4627
qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4628
return 0;
4629
}
4630
4631
static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4632
{
4633
NetSocketState *s;
4634
int fd, connected, ret, err;
4635
struct sockaddr_in saddr;
4636
4637
if (parse_host_port(&saddr, host_str) < 0)
4638
return -1;
4639
4640
fd = socket(PF_INET, SOCK_STREAM, 0);
4641
if (fd < 0) {
4642
perror("socket");
4643
return -1;
4644
}
4645
socket_set_nonblock(fd);
4646
4647
connected = 0;
4648
for(;;) {
4649
ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4650
if (ret < 0) {
4651
err = socket_error();
4652
if (err == EINTR || err == EWOULDBLOCK) {
4653
} else if (err == EINPROGRESS) {
4654
break;
4655
#ifdef _WIN32
4656
} else if (err == WSAEALREADY) {
4657
break;
4658
#endif
4659
} else {
4660
perror("connect");
4661
closesocket(fd);
4662
return -1;
4663
}
4664
} else {
4665
connected = 1;
4666
break;
4667
}
4668
}
4669
s = net_socket_fd_init(vlan, fd, connected);
4670
if (!s)
4671
return -1;
4672
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4673
"socket: connect to %s:%d",
4674
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4675
return 0;
4676
}
4677
4678
static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4679
{
4680
NetSocketState *s;
4681
int fd;
4682
struct sockaddr_in saddr;
4683
4684
if (parse_host_port(&saddr, host_str) < 0)
4685
return -1;
4686
4687
4688
fd = net_socket_mcast_create(&saddr);
4689
if (fd < 0)
4690
return -1;
4691
4692
s = net_socket_fd_init(vlan, fd, 0);
4693
if (!s)
4694
return -1;
4695
4696
s->dgram_dst = saddr;
4697
4698
snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4699
"socket: mcast=%s:%d",
4700
inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4701
return 0;
4702
4703
}
4704
4705
static const char *get_opt_name(char *buf, int buf_size, const char *p)
4706
{
4707
char *q;
4708
4709
q = buf;
4710
while (*p != '\0' && *p != '=') {
4711
if (q && (q - buf) < buf_size - 1)
4712
*q++ = *p;
4713
p++;
4714
}
4715
if (q)
4716
*q = '\0';
4717
4718
return p;
4719
}
4720
4721
static const char *get_opt_value(char *buf, int buf_size, const char *p)
4722
{
4723
char *q;
4724
4725
q = buf;
4726
while (*p != '\0') {
4727
if (*p == ',') {
4728
if (*(p + 1) != ',')
4729
break;
4730
p++;
4731
}
4732
if (q && (q - buf) < buf_size - 1)
4733
*q++ = *p;
4734
p++;
4735
}
4736
if (q)
4737
*q = '\0';
4738
4739
return p;
4740
}
4741
4742
static int get_param_value(char *buf, int buf_size,
4743
const char *tag, const char *str)
4744
{
4745
const char *p;
4746
char option[128];
4747
4748
p = str;
4749
for(;;) {
4750
p = get_opt_name(option, sizeof(option), p);
4751
if (*p != '=')
4752
break;
4753
p++;
4754
if (!strcmp(tag, option)) {
4755
(void)get_opt_value(buf, buf_size, p);
4756
return strlen(buf);
4757
} else {
4758
p = get_opt_value(NULL, 0, p);
4759
}
4760
if (*p != ',')
4761
break;
4762
p++;
4763
}
4764
return 0;
4765
}
4766
4767
static int check_params(char *buf, int buf_size,
4768
char **params, const char *str)
4769
{
4770
const char *p;
4771
int i;
4772
4773
p = str;
4774
for(;;) {
4775
p = get_opt_name(buf, buf_size, p);
4776
if (*p != '=')
4777
return -1;
4778
p++;
4779
for(i = 0; params[i] != NULL; i++)
4780
if (!strcmp(params[i], buf))
4781
break;
4782
if (params[i] == NULL)
4783
return -1;
4784
p = get_opt_value(NULL, 0, p);
4785
if (*p != ',')
4786
break;
4787
p++;
4788
}
4789
return 0;
4790
}
4791
4792
4793
static int net_client_init(const char *str)
4794
{
4795
const char *p;
4796
char *q;
4797
char device[64];
4798
char buf[1024];
4799
int vlan_id, ret;
4800
VLANState *vlan;
4801
4802
p = str;
4803
q = device;
4804
while (*p != '\0' && *p != ',') {
4805
if ((q - device) < sizeof(device) - 1)
4806
*q++ = *p;
4807
p++;
4808
}
4809
*q = '\0';
4810
if (*p == ',')
4811
p++;
4812
vlan_id = 0;
4813
if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4814
vlan_id = strtol(buf, NULL, 0);
4815
}
4816
vlan = qemu_find_vlan(vlan_id);
4817
if (!vlan) {
4818
fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4819
return -1;
4820
}
4821
if (!strcmp(device, "nic")) {
4822
NICInfo *nd;
4823
uint8_t *macaddr;
4824
4825
if (nb_nics >= MAX_NICS) {
4826
fprintf(stderr, "Too Many NICs\n");
4827
return -1;
4828
}
4829
nd = &nd_table[nb_nics];
4830
macaddr = nd->macaddr;
4831
macaddr[0] = 0x52;
4832
macaddr[1] = 0x54;
4833
macaddr[2] = 0x00;
4834
macaddr[3] = 0x12;
4835
macaddr[4] = 0x34;
4836
macaddr[5] = 0x56 + nb_nics;
4837
4838
if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4839
if (parse_macaddr(macaddr, buf) < 0) {
4840
fprintf(stderr, "invalid syntax for ethernet address\n");
4841
return -1;
4842
}
4843
}
4844
if (get_param_value(buf, sizeof(buf), "model", p)) {
4845
nd->model = strdup(buf);
4846
}
4847
nd->vlan = vlan;
4848
nb_nics++;
4849
vlan->nb_guest_devs++;
4850
ret = 0;
4851
} else
4852
if (!strcmp(device, "none")) {
4853
/* does nothing. It is needed to signal that no network cards
4854
are wanted */
4855
ret = 0;
4856
} else
4857
#ifdef CONFIG_SLIRP
4858
if (!strcmp(device, "user")) {
4859
if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4860
pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4861
}
4862
vlan->nb_host_devs++;
4863
ret = net_slirp_init(vlan);
4864
} else
4865
#endif
4866
#ifdef _WIN32
4867
if (!strcmp(device, "tap")) {
4868
char ifname[64];
4869
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4870
fprintf(stderr, "tap: no interface name\n");
4871
return -1;
4872
}
4873
vlan->nb_host_devs++;
4874
ret = tap_win32_init(vlan, ifname);
4875
} else
4876
#else
4877
if (!strcmp(device, "tap")) {
4878
char ifname[64];
4879
char setup_script[1024], down_script[1024];
4880
int fd;
4881
vlan->nb_host_devs++;
4882
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4883
fd = strtol(buf, NULL, 0);
4884
fcntl(fd, F_SETFL, O_NONBLOCK);
4885
ret = -1;
4886
if (net_tap_fd_init(vlan, fd))
4887
ret = 0;
4888
} else {
4889
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4890
ifname[0] = '\0';
4891
}
4892
if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
4893
pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
4894
}
4895
if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
4896
pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
4897
}
4898
ret = net_tap_init(vlan, ifname, setup_script, down_script);
4899
}
4900
} else
4901
#endif
4902
if (!strcmp(device, "socket")) {
4903
if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4904
int fd;
4905
fd = strtol(buf, NULL, 0);
4906
ret = -1;
4907
if (net_socket_fd_init(vlan, fd, 1))
4908
ret = 0;
4909
} else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
4910
ret = net_socket_listen_init(vlan, buf);
4911
} else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
4912
ret = net_socket_connect_init(vlan, buf);
4913
} else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
4914
ret = net_socket_mcast_init(vlan, buf);
4915
} else {
4916
fprintf(stderr, "Unknown socket options: %s\n", p);
4917
return -1;
4918
}
4919
vlan->nb_host_devs++;
4920
} else
4921
{
4922
fprintf(stderr, "Unknown network device: %s\n", device);
4923
return -1;
4924
}
4925
if (ret < 0) {
4926
fprintf(stderr, "Could not initialize device '%s'\n", device);
4927
}
4928
4929
return ret;
4930
}
4931
4932
void do_info_network(void)
4933
{
4934
VLANState *vlan;
4935
VLANClientState *vc;
4936
4937
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4938
term_printf("VLAN %d devices:\n", vlan->id);
4939
for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4940
term_printf(" %s\n", vc->info_str);
4941
}
4942
}
1618
return &vlan->net;
1619
}
1620
1621
static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1622
{
1623
}
1624
1625
static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1626
{
1627
return -ENOTSUP;
1628
}
1629
1630
static struct HCIInfo null_hci = {
1631
.cmd_send = null_hci_send,
1632
.sco_send = null_hci_send,
1633
.acl_send = null_hci_send,
1634
.bdaddr_set = null_hci_addr_set,
1635
};
1636
1637
struct HCIInfo *qemu_next_hci(void)
1638
{
1639
if (cur_hci == nb_hcis)
1640
return &null_hci;
1641
1642
return hci_table[cur_hci++];
1643
}
1644
1645
static struct HCIInfo *hci_init(const char *str)
1646
{
1647
char *endp;
1648
struct bt_scatternet_s *vlan = 0;
1649
1650
if (!strcmp(str, "null"))
1651
/* null */
1652
return &null_hci;
1653
else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1654
/* host[:hciN] */
1655
return bt_host_hci(str[4] ? str + 5 : "hci0");
1656
else if (!strncmp(str, "hci", 3)) {
1657
/* hci[,vlan=n] */
1658
if (str[3]) {
1659
if (!strncmp(str + 3, ",vlan=", 6)) {
1660
vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1661
if (*endp)
1662
vlan = 0;
1663
}
1664
} else
1665
vlan = qemu_find_bt_vlan(0);
1666
if (vlan)
1667
return bt_new_hci(vlan);
1668
}
1669
1670
fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
1671
1672
return 0;
1673
}
1674
1675
static int bt_hci_parse(const char *str)
1676
{
1677
struct HCIInfo *hci;
1678
bdaddr_t bdaddr;
1679
1680
if (nb_hcis >= MAX_NICS) {
1681
fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
1682
return -1;
1683
}
1684
1685
hci = hci_init(str);
1686
if (!hci)
1687
return -1;
1688
1689
bdaddr.b[0] = 0x52;
1690
bdaddr.b[1] = 0x54;
1691
bdaddr.b[2] = 0x00;
1692
bdaddr.b[3] = 0x12;
1693
bdaddr.b[4] = 0x34;
1694
bdaddr.b[5] = 0x56 + nb_hcis;
1695
hci->bdaddr_set(hci, bdaddr.b);
1696
1697
hci_table[nb_hcis++] = hci;
1698
1699
return 0;
1700
}
1701
1702
static void bt_vhci_add(int vlan_id)
1703
{
1704
struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1705
1706
if (!vlan->slave)
1707
fprintf(stderr, "qemu: warning: adding a VHCI to "
1708
"an empty scatternet %i\n", vlan_id);
1709
1710
bt_vhci_init(bt_new_hci(vlan));
1711
}
1712
1713
static struct bt_device_s *bt_device_add(const char *opt)
1714
{
1715
struct bt_scatternet_s *vlan;
1716
int vlan_id = 0;
1717
char *endp = strstr(opt, ",vlan=");
1718
int len = (endp ? endp - opt : strlen(opt)) + 1;
1719
char devname[10];
1720
1721
pstrcpy(devname, MIN(sizeof(devname), len), opt);
1722
1723
if (endp) {
1724
vlan_id = strtol(endp + 6, &endp, 0);
1725
if (*endp) {
1726
fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
1727
return 0;
1728
}
1729
}
1730
1731
vlan = qemu_find_bt_vlan(vlan_id);
1732
1733
if (!vlan->slave)
1734
fprintf(stderr, "qemu: warning: adding a slave device to "
1735
"an empty scatternet %i\n", vlan_id);
1736
1737
if (!strcmp(devname, "keyboard"))
1738
return bt_keyboard_init(vlan);
1739
1740
fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
1741
return 0;
1742
}
1743
1744
static int bt_parse(const char *opt)
1745
{
1746
const char *endp, *p;
1747
int vlan;
1748
1749
if (strstart(opt, "hci", &endp)) {
1750
if (!*endp || *endp == ',') {
1751
if (*endp)
1752
if (!strstart(endp, ",vlan=", 0))
1753
opt = endp + 1;
1754
1755
return bt_hci_parse(opt);
1756
}
1757
} else if (strstart(opt, "vhci", &endp)) {
1758
if (!*endp || *endp == ',') {
1759
if (*endp) {
1760
if (strstart(endp, ",vlan=", &p)) {
1761
vlan = strtol(p, (char **) &endp, 0);
1762
if (*endp) {
1763
fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
1764
return 1;
1765
}
1766
} else {
1767
fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
1768
return 1;
1769
}
1770
} else
1771
vlan = 0;
1772
1773
bt_vhci_add(vlan);
1774
return 0;
1775
}
1776
} else if (strstart(opt, "device:", &endp))
1777
return !bt_device_add(endp);
1778
1779
fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
1780
return 1;
1781
}
1782
1783
/***********************************************************/
1784
/* QEMU Block devices */
4943
1785
4944
1786
#define HD_ALIAS "index=%d,media=disk"
4945
#ifdef TARGET_PPC
4946
#define CDROM_ALIAS "index=1,media=cdrom"
4947
#else
4948
1787
#define CDROM_ALIAS "index=2,media=cdrom"
4949
#endif
4950
1788
#define FD_ALIAS "index=%d,if=floppy"
4951
1789
#define PFLASH_ALIAS "if=pflash"
4952
1790
#define MTD_ALIAS "if=mtd"
4953
1791
#define SD_ALIAS "index=0,if=sd"
4954
1792
4955
static int drive_add(const char *file, const char *fmt, ...)
1793
QemuOpts *drive_add(const char *file, const char *fmt, ...)
4956
1794
{
4957
1795
va_list ap;
4958
4959
if (nb_drives_opt >= MAX_DRIVES) {
4960
fprintf(stderr, "qemu: too many drives\n");
4961
exit(1);
4962
}
4963
4964
drives_opt[nb_drives_opt].file = file;
1796
char optstr[1024];
1797
QemuOpts *opts;
1798
4965
1799
va_start(ap, fmt);
4966
vsnprintf(drives_opt[nb_drives_opt].opt,
4967
sizeof(drives_opt[0].opt), fmt, ap);
1800
vsnprintf(optstr, sizeof(optstr), fmt, ap);
4968
1801
va_end(ap);
4969
1802
4970
return nb_drives_opt++;
1803
opts = qemu_opts_parse(&qemu_drive_opts, optstr, NULL);
1804
if (!opts) {
1805
fprintf(stderr, "%s: huh? duplicate? (%s)\n",
1806
__FUNCTION__, optstr);
1807
return NULL;
1808
}
1809
if (file)
1810
qemu_opt_set(opts, "file", file);
1811
return opts;
4971
1812
}
4972
1813
4973
int drive_get_index(BlockInterfaceType type, int bus, int unit)
1814
DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
4974
1815
{
4975
int index;
1816
DriveInfo *dinfo;
4976
1817
4977
1818
/* seek interface, bus and unit */
4978
1819
4979
for (index = 0; index < nb_drives; index++)
4980
if (drives_table[index].type == type &&
4981
drives_table[index].bus == bus &&
4982
drives_table[index].unit == unit)
4983
return index;
4984
4985
return -1;
1820
TAILQ_FOREACH(dinfo, &drives, next) {
1821
if (dinfo->type == type &&
1822
dinfo->bus == bus &&
1823
dinfo->unit == unit)
1824
return dinfo;
1825
}
1826
1827
return NULL;
1828
}
1829
1830
DriveInfo *drive_get_by_id(const char *id)
1831
{
1832
DriveInfo *dinfo;
1833
1834
TAILQ_FOREACH(dinfo, &drives, next) {
1835
if (strcmp(id, dinfo->id))
1836
continue;
1837
return dinfo;
1838
}
1839
return NULL;
4986
1840
}
4987
1841
4988
1842
int drive_get_max_bus(BlockInterfaceType type)
4989
1843
{
4990
1844
int max_bus;
4991
int index;
1845
DriveInfo *dinfo;
4992
1846
4993
1847
max_bus = -1;
4994
for (index = 0; index < nb_drives; index++) {
4995
if(drives_table[index].type == type &&
4996
drives_table[index].bus > max_bus)
4997
max_bus = drives_table[index].bus;
1848
TAILQ_FOREACH(dinfo, &drives, next) {
1849
if(dinfo->type == type &&
1850
dinfo->bus > max_bus)
1851
max_bus = dinfo->bus;
4998
1852
}
4999
1853
return max_bus;
5000
1854
}
5001
1855
1856
const char *drive_get_serial(BlockDriverState *bdrv)
1857
{
1858
DriveInfo *dinfo;
1859
1860
TAILQ_FOREACH(dinfo, &drives, next) {
1861
if (dinfo->bdrv == bdrv)
1862
return dinfo->serial;
1863
}
1864
1865
return "\0";
1866
}
1867
1868
BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
1869
{
1870
DriveInfo *dinfo;
1871
1872
TAILQ_FOREACH(dinfo, &drives, next) {
1873
if (dinfo->bdrv == bdrv)
1874
return dinfo->onerror;
1875
}
1876
1877
return BLOCK_ERR_STOP_ENOSPC;
1878
}
1879
5002
1880
static void bdrv_format_print(void *opaque, const char *name)
5003
1881
{
5004
1882
fprintf(stderr, " %s", name);
5005
1883
}
5006
1884
5007
static int drive_init(struct drive_opt *arg, int snapshot,
5008
QEMUMachine *machine)
5009
{
5010
char buf[128];
5011
char file[1024];
1885
void drive_uninit(BlockDriverState *bdrv)
1886
{
1887
DriveInfo *dinfo;
1888
1889
TAILQ_FOREACH(dinfo, &drives, next) {
1890
if (dinfo->bdrv != bdrv)
1891
continue;
1892
qemu_opts_del(dinfo->opts);
1893
TAILQ_REMOVE(&drives, dinfo, next);
1894
qemu_free(dinfo);
1895
break;
1896
}
1897
}
1898
1899
DriveInfo *drive_init(QemuOpts *opts, void *opaque,
1900
int *fatal_error)
1901
{
1902
const char *buf;
1903
const char *file = NULL;
5012
1904
char devname[128];
1905
const char *serial;
5013
1906
const char *mediastr = "";
5014
1907
BlockInterfaceType type;
5015
1908
enum { MEDIA_DISK, MEDIA_CDROM } media;
5016
1909
int bus_id, unit_id;
5017
1910
int cyls, heads, secs, translation;
5018
BlockDriverState *bdrv;
5019
1911
BlockDriver *drv = NULL;
1912
QEMUMachine *machine = opaque;
5020
1913
int max_devs;
5021
1914
int index;
5022
1915
int cache;
5023
int bdrv_flags;
5024
char *str = arg->opt;
5025
char *params[] = { "bus", "unit", "if", "index", "cyls", "heads",
5026
"secs", "trans", "media", "snapshot", "file",
5027
"cache", "format", NULL };
5028
5029
if (check_params(buf, sizeof(buf), params, str) < 0) {
5030
fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
5031
buf, str);
5032
return -1;
5033
}
5034
5035
file[0] = 0;
5036
cyls = heads = secs = 0;
5037
bus_id = 0;
5038
unit_id = -1;
1916
int aio = 0;
1917
int bdrv_flags, onerror;
1918
const char *devaddr;
1919
DriveInfo *dinfo;
1920
int snapshot = 0;
1921
1922
*fatal_error = 1;
1923
5039
1924
translation = BIOS_ATA_TRANSLATION_AUTO;
5040
index = -1;
5041
1925
cache = 1;
5042
1926
5043
if (!strcmp(machine->name, "realview") ||
5044
!strcmp(machine->name, "SS-5") ||
5045
!strcmp(machine->name, "SS-10") ||
5046
!strcmp(machine->name, "SS-600MP") ||
5047
!strcmp(machine->name, "versatilepb") ||
5048
!strcmp(machine->name, "versatileab")) {
1927
if (machine->use_scsi) {
5049
1928
type = IF_SCSI;
5050
1929
max_devs = MAX_SCSI_DEVS;
5051
strcpy(devname, "scsi");
1930
pstrcpy(devname, sizeof(devname), "scsi");
5052
1931
} else {
5053
1932
type = IF_IDE;
5054
1933
max_devs = MAX_IDE_DEVS;
5055
strcpy(devname, "ide");
1934
pstrcpy(devname, sizeof(devname), "ide");
5056
1935
}
5057
1936
media = MEDIA_DISK;
5058
1937
5059
1938
/* extract parameters */
5060
5061
if (get_param_value(buf, sizeof(buf), "bus", str)) {
5062
bus_id = strtol(buf, NULL, 0);
5063
if (bus_id < 0) {
5064
fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
5065
return -1;
5066
}
5067
}
5068
5069
if (get_param_value(buf, sizeof(buf), "unit", str)) {
5070
unit_id = strtol(buf, NULL, 0);
5071
if (unit_id < 0) {
5072
fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
5073
return -1;
5074
}
5075
}
5076
5077
if (get_param_value(buf, sizeof(buf), "if", str)) {
5078
strncpy(devname, buf, sizeof(devname));
1939
bus_id = qemu_opt_get_number(opts, "bus", 0);
1940
unit_id = qemu_opt_get_number(opts, "unit", -1);
1941
index = qemu_opt_get_number(opts, "index", -1);
1942
1943
cyls = qemu_opt_get_number(opts, "cyls", 0);
1944
heads = qemu_opt_get_number(opts, "heads", 0);
1945
secs = qemu_opt_get_number(opts, "secs", 0);
1946
1947
snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
1948
1949
file = qemu_opt_get(opts, "file");
1950
serial = qemu_opt_get(opts, "serial");
1951
1952
if ((buf = qemu_opt_get(opts, "if")) != NULL) {
1953
pstrcpy(devname, sizeof(devname), buf);
5079
1954
if (!strcmp(buf, "ide")) {
5080
1955
type = IF_IDE;
5081
1956
max_devs = MAX_IDE_DEVS;
5094
1969
} else if (!strcmp(buf, "sd")) {
5095
1970
type = IF_SD;
5096
1971
max_devs = 0;
1972
} else if (!strcmp(buf, "virtio")) {
1973
type = IF_VIRTIO;
1974
max_devs = 0;
1975
} else if (!strcmp(buf, "xen")) {
1976
type = IF_XEN;
1977
max_devs = 0;
1978
} else if (!strcmp(buf, "none")) {
1979
type = IF_NONE;
1980
max_devs = 0;
5097
1981
} else {
5098
fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5099
return -1;
5100
}
5101
}
5102
5103
if (get_param_value(buf, sizeof(buf), "index", str)) {
5104
index = strtol(buf, NULL, 0);
5105
if (index < 0) {
5106
fprintf(stderr, "qemu: '%s' invalid index\n", str);
5107
return -1;
5108
}
5109
}
5110
5111
if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5112
cyls = strtol(buf, NULL, 0);
5113
}
5114
5115
if (get_param_value(buf, sizeof(buf), "heads", str)) {
5116
heads = strtol(buf, NULL, 0);
5117
}
5118
5119
if (get_param_value(buf, sizeof(buf), "secs", str)) {
5120
secs = strtol(buf, NULL, 0);
1982
fprintf(stderr, "qemu: unsupported bus type '%s'\n", buf);
1983
return NULL;
1984
}
5121
1985
}
5122
1986
5123
1987
if (cyls || heads || secs) {
5124
1988
if (cyls < 1 || cyls > 16383) {
5125
fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5126
return -1;
1989
fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
1990
return NULL;
5127
1991
}
5128
1992
if (heads < 1 || heads > 16) {
5129
fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5130
return -1;
1993
fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
1994
return NULL;
5131
1995
}
5132
1996
if (secs < 1 || secs > 63) {
5133
fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5134
return -1;
1997
fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
1998
return NULL;
5135
1999
}
5136
2000
}
5137
2001
5138
if (get_param_value(buf, sizeof(buf), "trans", str)) {
2002
if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
5139
2003
if (!cyls) {
5140
2004
fprintf(stderr,
5141
2005
"qemu: '%s' trans must be used with cyls,heads and secs\n",
5142
str);
5143
return -1;
2006
buf);
2007
return NULL;
5144
2008
}
5145
2009
if (!strcmp(buf, "none"))
5146
2010
translation = BIOS_ATA_TRANSLATION_NONE;
5149
2013
else if (!strcmp(buf, "auto"))
5150
2014
translation = BIOS_ATA_TRANSLATION_AUTO;
5151
2015
else {
5152
fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5153
return -1;
2016
fprintf(stderr, "qemu: '%s' invalid translation type\n", buf);
2017
return NULL;
5154
2018
}
5155
2019
}
5156
2020
5157
if (get_param_value(buf, sizeof(buf), "media", str)) {
2021
if ((buf = qemu_opt_get(opts, "media")) != NULL) {
5158
2022
if (!strcmp(buf, "disk")) {
5159
2023
media = MEDIA_DISK;
5160
2024
} else if (!strcmp(buf, "cdrom")) {
5161
2025
if (cyls || secs || heads) {
5162
2026
fprintf(stderr,
5163
"qemu: '%s' invalid physical CHS format\n", str);
5164
return -1;
2027
"qemu: '%s' invalid physical CHS format\n", buf);
2028
return NULL;
5165
2029
}
5166
2030
media = MEDIA_CDROM;
5167
2031
} else {
5168
fprintf(stderr, "qemu: '%s' invalid media\n", str);
5169
return -1;
5170
}
5171
}
5172
5173
if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5174
if (!strcmp(buf, "on"))
5175
snapshot = 1;
5176
else if (!strcmp(buf, "off"))
5177
snapshot = 0;
5178
else {
5179
fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5180
return -1;
5181
}
5182
}
5183
5184
if (get_param_value(buf, sizeof(buf), "cache", str)) {
5185
if (!strcmp(buf, "off"))
2032
fprintf(stderr, "qemu: '%s' invalid media\n", buf);
2033
return NULL;
2034
}
2035
}
2036
2037
if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
2038
if (!strcmp(buf, "off") || !strcmp(buf, "none"))
5186
2039
cache = 0;
5187
else if (!strcmp(buf, "on"))
2040
else if (!strcmp(buf, "writethrough"))
5188
2041
cache = 1;
2042
else if (!strcmp(buf, "writeback"))
2043
cache = 2;
5189
2044
else {
5190
2045
fprintf(stderr, "qemu: invalid cache option\n");
5191
return -1;
5192
}
5193
}
5194
5195
if (get_param_value(buf, sizeof(buf), "format", str)) {
2046
return NULL;
2047
}
2048
}
2049
2050
#ifdef CONFIG_LINUX_AIO
2051
if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
2052
if (!strcmp(buf, "threads"))
2053
aio = 0;
2054
else if (!strcmp(buf, "native"))
2055
aio = 1;
2056
else {
2057
fprintf(stderr, "qemu: invalid aio option\n");
2058
return NULL;
2059
}
2060
}
2061
#endif
2062
2063
if ((buf = qemu_opt_get(opts, "format")) != NULL) {
5196
2064
if (strcmp(buf, "?") == 0) {
5197
2065
fprintf(stderr, "qemu: Supported formats:");
5198
2066
bdrv_iterate_format(bdrv_format_print, NULL);
5199
2067
fprintf(stderr, "\n");
5200
return -1;
2068
return NULL;
5201
2069
}
5202
2070
drv = bdrv_find_format(buf);
5203
2071
if (!drv) {
5204
2072
fprintf(stderr, "qemu: '%s' invalid format\n", buf);
5205
return -1;
5206
}
5207
}
5208
5209
if (arg->file == NULL)
5210
get_param_value(file, sizeof(file), "file", str);
5211
else
5212
pstrcpy(file, sizeof(file), arg->file);
2073
return NULL;
2074
}
2075
}
2076
2077
onerror = BLOCK_ERR_STOP_ENOSPC;
2078
if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
2079
if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2080
fprintf(stderr, "werror is no supported by this format\n");
2081
return NULL;
2082
}
2083
if (!strcmp(buf, "ignore"))
2084
onerror = BLOCK_ERR_IGNORE;
2085
else if (!strcmp(buf, "enospc"))
2086
onerror = BLOCK_ERR_STOP_ENOSPC;
2087
else if (!strcmp(buf, "stop"))
2088
onerror = BLOCK_ERR_STOP_ANY;
2089
else if (!strcmp(buf, "report"))
2090
onerror = BLOCK_ERR_REPORT;
2091
else {
2092
fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2093
return NULL;
2094
}
2095
}
2096
2097
if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
2098
if (type != IF_VIRTIO) {
2099
fprintf(stderr, "addr is not supported\n");
2100
return NULL;
2101
}
2102
}
5213
2103
5214
2104
/* compute bus and unit according index */
5215
2105
5216
2106
if (index != -1) {
5217
2107
if (bus_id != 0 || unit_id != -1) {
5218
2108
fprintf(stderr,
5219
"qemu: '%s' index cannot be used with bus and unit\n", str);
5220
return -1;
2109
"qemu: index cannot be used with bus and unit\n");
2110
return NULL;
5221
2111
}
5222
2112
if (max_devs == 0)
5223
2113
{
5235
2125
5236
2126
if (unit_id == -1) {
5237
2127
unit_id = 0;
5238
while (drive_get_index(type, bus_id, unit_id) != -1) {
2128
while (drive_get(type, bus_id, unit_id) != NULL) {
5239
2129
unit_id++;
5240
2130
if (max_devs && unit_id >= max_devs) {
5241
2131
unit_id -= max_devs;
5247
2137
/* check unit id */
5248
2138
5249
2139
if (max_devs && unit_id >= max_devs) {
5250
fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5251
str, unit_id, max_devs - 1);
5252
return -1;
2140
fprintf(stderr, "qemu: unit %d too big (max is %d)\n",
2141
unit_id, max_devs - 1);
2142
return NULL;
5253
2143
}
5254
2144
5255
2145
/*
5256
2146
* ignore multiple definitions
5257
2147
*/
5258
2148
5259
if (drive_get_index(type, bus_id, unit_id) != -1)
5260
return 0;
2149
if (drive_get(type, bus_id, unit_id) != NULL) {
2150
*fatal_error = 0;
2151
return NULL;
2152
}
5261
2153
5262
2154
/* init */
5263
2155
5264
if (type == IF_IDE || type == IF_SCSI)
5265
mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5266
if (max_devs)
5267
snprintf(buf, sizeof(buf), "%s%i%s%i",
5268
devname, bus_id, mediastr, unit_id);
5269
else
5270
snprintf(buf, sizeof(buf), "%s%s%i",
5271
devname, mediastr, unit_id);
5272
bdrv = bdrv_new(buf);
5273
drives_table[nb_drives].bdrv = bdrv;
5274
drives_table[nb_drives].type = type;
5275
drives_table[nb_drives].bus = bus_id;
5276
drives_table[nb_drives].unit = unit_id;
5277
nb_drives++;
2156
dinfo = qemu_mallocz(sizeof(*dinfo));
2157
if ((buf = qemu_opts_id(opts)) != NULL) {
2158
dinfo->id = qemu_strdup(buf);
2159
} else {
2160
/* no id supplied -> create one */
2161
dinfo->id = qemu_mallocz(32);
2162
if (type == IF_IDE || type == IF_SCSI)
2163
mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2164
if (max_devs)
2165
snprintf(dinfo->id, 32, "%s%i%s%i",
2166
devname, bus_id, mediastr, unit_id);
2167
else
2168
snprintf(dinfo->id, 32, "%s%s%i",
2169
devname, mediastr, unit_id);
2170
}
2171
dinfo->bdrv = bdrv_new(dinfo->id);
2172
dinfo->devaddr = devaddr;
2173
dinfo->type = type;
2174
dinfo->bus = bus_id;
2175
dinfo->unit = unit_id;
2176
dinfo->onerror = onerror;
2177
dinfo->opts = opts;
2178
if (serial)
2179
strncpy(dinfo->serial, serial, sizeof(serial));
2180
TAILQ_INSERT_TAIL(&drives, dinfo, next);
5278
2181
5279
2182
switch(type) {
5280
2183
case IF_IDE:
5281
2184
case IF_SCSI:
2185
case IF_XEN:
5282
2186
switch(media) {
5283
2187
case MEDIA_DISK:
5284
2188
if (cyls != 0) {
5285
bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5286
bdrv_set_translation_hint(bdrv, translation);
2189
bdrv_set_geometry_hint(dinfo->bdrv, cyls, heads, secs);
2190
bdrv_set_translation_hint(dinfo->bdrv, translation);
5287
2191
}
5288
2192
break;
5289
2193
case MEDIA_CDROM:
5290
bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2194
bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM);
5291
2195
break;
5292
2196
}
5293
2197
break;
5295
2199
/* FIXME: This isn't really a floppy, but it's a reasonable
5296
2200
approximation. */
5297
2201
case IF_FLOPPY:
5298
bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2202
bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY);
5299
2203
break;
5300
2204
case IF_PFLASH:
5301
2205
case IF_MTD:
5302
break;
5303
}
5304
if (!file[0])
5305
return 0;
2206
case IF_NONE:
2207
break;
2208
case IF_VIRTIO:
2209
/* add virtio block device */
2210
opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
2211
qemu_opt_set(opts, "driver", "virtio-blk-pci");
2212
qemu_opt_set(opts, "drive", dinfo->id);
2213
if (devaddr)
2214
qemu_opt_set(opts, "addr", devaddr);
2215
break;
2216
case IF_COUNT:
2217
abort();
2218
}
2219
if (!file) {
2220
*fatal_error = 0;
2221
return NULL;
2222
}
5306
2223
bdrv_flags = 0;
5307
if (snapshot)
2224
if (snapshot) {
5308
2225
bdrv_flags |= BDRV_O_SNAPSHOT;
5309
if (!cache)
5310
bdrv_flags |= BDRV_O_DIRECT;
5311
if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
2226
cache = 2; /* always use write-back with snapshot */
2227
}
2228
if (cache == 0) /* no caching */
2229
bdrv_flags |= BDRV_O_NOCACHE;
2230
else if (cache == 2) /* write-back */
2231
bdrv_flags |= BDRV_O_CACHE_WB;
2232
2233
if (aio == 1) {
2234
bdrv_flags |= BDRV_O_NATIVE_AIO;
2235
} else {
2236
bdrv_flags &= ~BDRV_O_NATIVE_AIO;
2237
}
2238
2239
if (bdrv_open2(dinfo->bdrv, file, bdrv_flags, drv) < 0) {
5312
2240
fprintf(stderr, "qemu: could not open disk image %s\n",
5313
2241
file);
5314
return -1;
5315
}
5316
return 0;
2242
return NULL;
2243
}
2244
2245
if (bdrv_key_required(dinfo->bdrv))
2246
autostart = 0;
2247
*fatal_error = 0;
2248
return dinfo;
2249
}
2250
2251
static int drive_init_func(QemuOpts *opts, void *opaque)
2252
{
2253
QEMUMachine *machine = opaque;
2254
int fatal_error = 0;
2255
2256
if (drive_init(opts, machine, &fatal_error) == NULL) {
2257
if (fatal_error)
2258
return 1;
2259
}
2260
return 0;
2261
}
2262
2263
static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
2264
{
2265
if (NULL == qemu_opt_get(opts, "snapshot")) {
2266
qemu_opt_set(opts, "snapshot", "on");
2267
}
2268
return 0;
2269
}
2270
2271
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
2272
{
2273
boot_set_handler = func;
2274
boot_set_opaque = opaque;
2275
}
2276
2277
int qemu_boot_set(const char *boot_devices)
2278
{
2279
if (!boot_set_handler) {
2280
return -EINVAL;
2281
}
2282
return boot_set_handler(boot_set_opaque, boot_devices);
2283
}
2284
2285
static int parse_bootdevices(char *devices)
2286
{
2287
/* We just do some generic consistency checks */
2288
const char *p;
2289
int bitmap = 0;
2290
2291
for (p = devices; *p != '\0'; p++) {
2292
/* Allowed boot devices are:
2293
* a-b: floppy disk drives
2294
* c-f: IDE disk drives
2295
* g-m: machine implementation dependant drives
2296
* n-p: network devices
2297
* It's up to each machine implementation to check if the given boot
2298
* devices match the actual hardware implementation and firmware
2299
* features.
2300
*/
2301
if (*p < 'a' || *p > 'p') {
2302
fprintf(stderr, "Invalid boot device '%c'\n", *p);
2303
exit(1);
2304
}
2305
if (bitmap & (1 << (*p - 'a'))) {
2306
fprintf(stderr, "Boot device '%c' was given twice\n", *p);
2307
exit(1);
2308
}
2309
bitmap |= 1 << (*p - 'a');
2310
}
2311
return bitmap;
2312
}
2313
2314
static void restore_boot_devices(void *opaque)
2315
{
2316
char *standard_boot_devices = opaque;
2317
2318
qemu_boot_set(standard_boot_devices);
2319
2320
qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
2321
qemu_free(standard_boot_devices);
2322
}
2323
2324
static void numa_add(const char *optarg)
2325
{
2326
char option[128];
2327
char *endptr;
2328
unsigned long long value, endvalue;
2329
int nodenr;
2330
2331
optarg = get_opt_name(option, 128, optarg, ',') + 1;
2332
if (!strcmp(option, "node")) {
2333
if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2334
nodenr = nb_numa_nodes;
2335
} else {
2336
nodenr = strtoull(option, NULL, 10);
2337
}
2338
2339
if (get_param_value(option, 128, "mem", optarg) == 0) {
2340
node_mem[nodenr] = 0;
2341
} else {
2342
value = strtoull(option, &endptr, 0);
2343
switch (*endptr) {
2344
case 0: case 'M': case 'm':
2345
value <<= 20;
2346
break;
2347
case 'G': case 'g':
2348
value <<= 30;
2349
break;
2350
}
2351
node_mem[nodenr] = value;
2352
}
2353
if (get_param_value(option, 128, "cpus", optarg) == 0) {
2354
node_cpumask[nodenr] = 0;
2355
} else {
2356
value = strtoull(option, &endptr, 10);
2357
if (value >= 64) {
2358
value = 63;
2359
fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2360
} else {
2361
if (*endptr == '-') {
2362
endvalue = strtoull(endptr+1, &endptr, 10);
2363
if (endvalue >= 63) {
2364
endvalue = 62;
2365
fprintf(stderr,
2366
"only 63 CPUs in NUMA mode supported.\n");
2367
}
2368
value = (1 << (endvalue + 1)) - (1 << value);
2369
} else {
2370
value = 1 << value;
2371
}
2372
}
2373
node_cpumask[nodenr] = value;
2374
}
2375
nb_numa_nodes++;
2376
}
2377
return;
2378
}
2379
2380
static void smp_parse(const char *optarg)
2381
{
2382
int smp, sockets = 0, threads = 0, cores = 0;
2383
char *endptr;
2384
char option[128];
2385
2386
smp = strtoul(optarg, &endptr, 10);
2387
if (endptr != optarg) {
2388
if (*endptr == ',') {
2389
endptr++;
2390
}
2391
}
2392
if (get_param_value(option, 128, "sockets", endptr) != 0)
2393
sockets = strtoull(option, NULL, 10);
2394
if (get_param_value(option, 128, "cores", endptr) != 0)
2395
cores = strtoull(option, NULL, 10);
2396
if (get_param_value(option, 128, "threads", endptr) != 0)
2397
threads = strtoull(option, NULL, 10);
2398
if (get_param_value(option, 128, "maxcpus", endptr) != 0)
2399
max_cpus = strtoull(option, NULL, 10);
2400
2401
/* compute missing values, prefer sockets over cores over threads */
2402
if (smp == 0 || sockets == 0) {
2403
sockets = sockets > 0 ? sockets : 1;
2404
cores = cores > 0 ? cores : 1;
2405
threads = threads > 0 ? threads : 1;
2406
if (smp == 0) {
2407
smp = cores * threads * sockets;
2408
} else {
2409
sockets = smp / (cores * threads);
2410
}
2411
} else {
2412
if (cores == 0) {
2413
threads = threads > 0 ? threads : 1;
2414
cores = smp / (sockets * threads);
2415
} else {
2416
if (sockets == 0) {
2417
sockets = smp / (cores * threads);
2418
} else {
2419
threads = smp / (cores * sockets);
2420
}
2421
}
2422
}
2423
smp_cpus = smp;
2424
smp_cores = cores > 0 ? cores : 1;
2425
smp_threads = threads > 0 ? threads : 1;
2426
if (max_cpus == 0)
2427
max_cpus = smp_cpus;
5317
2428
}
5318
2429
5319
2430
/***********************************************************/
5333
2444
free_usb_ports = port;
5334
2445
}
5335
2446
5336
static int usb_device_add(const char *devname)
2447
int usb_device_add_dev(USBDevice *dev)
2448
{
2449
USBPort *port;
2450
2451
/* Find a USB port to add the device to. */
2452
port = free_usb_ports;
2453
if (!port->next) {
2454
USBDevice *hub;
2455
2456
/* Create a new hub and chain it on. */
2457
free_usb_ports = NULL;
2458
port->next = used_usb_ports;
2459
used_usb_ports = port;
2460
2461
hub = usb_hub_init(VM_USB_HUB_SIZE);
2462
usb_attach(port, hub);
2463
port = free_usb_ports;
2464
}
2465
2466
free_usb_ports = port->next;
2467
port->next = used_usb_ports;
2468
used_usb_ports = port;
2469
usb_attach(port, dev);
2470
return 0;
2471
}
2472
2473
static void usb_msd_password_cb(void *opaque, int err)
2474
{
2475
USBDevice *dev = opaque;
2476
2477
if (!err)
2478
usb_device_add_dev(dev);
2479
else
2480
dev->handle_destroy(dev);
2481
}
2482
2483
static int usb_device_add(const char *devname, int is_hotplug)
5337
2484
{
5338
2485
const char *p;
5339
2486
USBDevice *dev;
5340
USBPort *port;
5341
2487
5342
2488
if (!free_usb_ports)
5343
2489
return -1;
5351
2497
} else if (!strcmp(devname, "keyboard")) {
5352
2498
dev = usb_keyboard_init();
5353
2499
} else if (strstart(devname, "disk:", &p)) {
2500
BlockDriverState *bs;
2501
5354
2502
dev = usb_msd_init(p);
2503
if (!dev)
2504
return -1;
2505
bs = usb_msd_get_bdrv(dev);
2506
if (bdrv_key_required(bs)) {
2507
autostart = 0;
2508
if (is_hotplug) {
2509
monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
2510
dev);
2511
return 0;
2512
}
2513
}
5355
2514
} else if (!strcmp(devname, "wacom-tablet")) {
5356
2515
dev = usb_wacom_init();
5357
2516
} else if (strstart(devname, "serial:", &p)) {
5360
2519
} else if (!strcmp(devname, "braille")) {
5361
2520
dev = usb_baum_init();
5362
2521
#endif
2522
} else if (strstart(devname, "net:", &p)) {
2523
int nic = nb_nics;
2524
2525
if (net_client_init(NULL, "nic", p) < 0)
2526
return -1;
2527
nd_table[nic].model = "usb";
2528
dev = usb_net_init(&nd_table[nic]);
2529
} else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2530
dev = usb_bt_init(devname[2] ? hci_init(p) :
2531
bt_new_hci(qemu_find_bt_vlan(0)));
5363
2532
} else {
5364
2533
return -1;
5365
2534
}
5366
2535
if (!dev)
5367
2536
return -1;
5368
2537
5369
/* Find a USB port to add the device to. */
5370
port = free_usb_ports;
5371
if (!port->next) {
5372
USBDevice *hub;
5373
5374
/* Create a new hub and chain it on. */
5375
free_usb_ports = NULL;
5376
port->next = used_usb_ports;
5377
used_usb_ports = port;
5378
5379
hub = usb_hub_init(VM_USB_HUB_SIZE);
5380
usb_attach(port, hub);
5381
port = free_usb_ports;
5382
}
5383
5384
free_usb_ports = port->next;
5385
port->next = used_usb_ports;
5386
used_usb_ports = port;
5387
usb_attach(port, dev);
5388
return 0;
2538
return usb_device_add_dev(dev);
5389
2539
}
5390
2540
5391
static int usb_device_del(const char *devname)
2541
int usb_device_del_addr(int bus_num, int addr)
5392
2542
{
5393
2543
USBPort *port;
5394
2544
USBPort **lastp;
5395
2545
USBDevice *dev;
5396
int bus_num, addr;
5397
const char *p;
5398
2546
5399
2547
if (!used_usb_ports)
5400
2548
return -1;
5401
2549
5402
p = strchr(devname, '.');
5403
if (!p)
5404
return -1;
5405
bus_num = strtoul(devname, NULL, 0);
5406
addr = strtoul(p + 1, NULL, 0);
5407
2550
if (bus_num != 0)
5408
2551
return -1;
5409
2552
5426
2569
return 0;
5427
2570
}
5428
2571
5429
void do_usb_add(const char *devname)
5430
{
5431
int ret;
5432
ret = usb_device_add(devname);
5433
if (ret < 0)
5434
term_printf("Could not add USB device '%s'\n", devname);
5435
}
5436
5437
void do_usb_del(const char *devname)
5438
{
5439
int ret;
5440
ret = usb_device_del(devname);
5441
if (ret < 0)
5442
term_printf("Could not remove USB device '%s'\n", devname);
5443
}
5444
5445
void usb_info(void)
2572
static int usb_device_del(const char *devname)
2573
{
2574
int bus_num, addr;
2575
const char *p;
2576
2577
if (strstart(devname, "host:", &p))
2578
return usb_host_device_close(p);
2579
2580
if (!used_usb_ports)
2581
return -1;
2582
2583
p = strchr(devname, '.');
2584
if (!p)
2585
return -1;
2586
bus_num = strtoul(devname, NULL, 0);
2587
addr = strtoul(p + 1, NULL, 0);
2588
2589
return usb_device_del_addr(bus_num, addr);
2590
}
2591
2592
static int usb_parse(const char *cmdline)
2593
{
2594
return usb_device_add(cmdline, 0);
2595
}
2596
2597
void do_usb_add(Monitor *mon, const char *devname)
2598
{
2599
usb_device_add(devname, 1);
2600
}
2601
2602
void do_usb_del(Monitor *mon, const char *devname)
2603
{
2604
usb_device_del(devname);
2605
}
2606
2607
void usb_info(Monitor *mon)
5446
2608
{
5447
2609
USBDevice *dev;
5448
2610
USBPort *port;
5449
2611
const char *speed_str;
5450
2612
5451
2613
if (!usb_enabled) {
5452
term_printf("USB support not enabled\n");
2614
monitor_printf(mon, "USB support not enabled\n");
5453
2615
return;
5454
2616
}
5455
2617
5471
2633
speed_str = "?";
5472
2634
break;
5473
2635
}
5474
term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5475
0, dev->addr, speed_str, dev->devname);
2636
monitor_printf(mon, " Device %d.%d, Speed %s Mb/s, Product %s\n",
2637
0, dev->addr, speed_str, dev->devname);
5476
2638
}
5477
2639
}
5478
2640
5480
2642
/* PCMCIA/Cardbus */
5481
2643
5482
2644
static struct pcmcia_socket_entry_s {
5483
struct pcmcia_socket_s *socket;
2645
PCMCIASocket *socket;
5484
2646
struct pcmcia_socket_entry_s *next;
5485
2647
} *pcmcia_sockets = 0;
5486
2648
5487
void pcmcia_socket_register(struct pcmcia_socket_s *socket)
2649
void pcmcia_socket_register(PCMCIASocket *socket)
5488
2650
{
5489
2651
struct pcmcia_socket_entry_s *entry;
5490
2652
5494
2656
pcmcia_sockets = entry;
5495
2657
}
5496
2658
5497
void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
2659
void pcmcia_socket_unregister(PCMCIASocket *socket)
5498
2660
{
5499
2661
struct pcmcia_socket_entry_s *entry, **ptr;
5500
2662
5506
2668
}
5507
2669
}
5508
2670
5509
void pcmcia_info(void)
2671
void pcmcia_info(Monitor *mon)
5510
2672
{
5511
2673
struct pcmcia_socket_entry_s *iter;
2674
5512
2675
if (!pcmcia_sockets)
5513
term_printf("No PCMCIA sockets\n");
2676
monitor_printf(mon, "No PCMCIA sockets\n");
5514
2677
5515
2678
for (iter = pcmcia_sockets; iter; iter = iter->next)
5516
term_printf("%s: %s\n", iter->socket->slot_string,
5517
iter->socket->attached ? iter->socket->card_string :
5518
"Empty");
2679
monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2680
iter->socket->attached ? iter->socket->card_string :
2681
"Empty");
5519
2682
}
5520
2683
5521
2684
/***********************************************************/
2685
/* register display */
2686
2687
struct DisplayAllocator default_allocator = {
2688
defaultallocator_create_displaysurface,
2689
defaultallocator_resize_displaysurface,
2690
defaultallocator_free_displaysurface
2691
};
2692
2693
void register_displaystate(DisplayState *ds)
2694
{
2695
DisplayState **s;
2696
s = &display_state;
2697
while (*s != NULL)
2698
s = &(*s)->next;
2699
ds->next = NULL;
2700
*s = ds;
2701
}
2702
2703
DisplayState *get_displaystate(void)
2704
{
2705
return display_state;
2706
}
2707
2708
DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2709
{
2710
if(ds->allocator == &default_allocator) ds->allocator = da;
2711
return ds->allocator;
2712
}
2713
5522
2714
/* dumb display */
5523
2715
5524
static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
5525
{
5526
}
5527
5528
static void dumb_resize(DisplayState *ds, int w, int h)
5529
{
5530
}
5531
5532
static void dumb_refresh(DisplayState *ds)
5533
{
5534
#if defined(CONFIG_SDL)
5535
vga_hw_update();
5536
#endif
5537
}
5538
5539
static void dumb_display_init(DisplayState *ds)
5540
{
5541
ds->data = NULL;
5542
ds->linesize = 0;
5543
ds->depth = 0;
5544
ds->dpy_update = dumb_update;
5545
ds->dpy_resize = dumb_resize;
5546
ds->dpy_refresh = dumb_refresh;
2716
static void dumb_display_init(void)
2717
{
2718
DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2719
ds->allocator = &default_allocator;
2720
ds->surface = qemu_create_displaysurface(ds, 640, 480);
2721
register_displaystate(ds);
5547
2722
}
5548
2723
5549
2724
/***********************************************************/
5550
2725
/* I/O handling */
5551
2726
5552
#define MAX_IO_HANDLERS 64
5553
5554
2727
typedef struct IOHandlerRecord {
5555
2728
int fd;
5556
2729
IOCanRWHandler *fd_read_poll;
5593
2766
goto found;
5594
2767
}
5595
2768
ioh = qemu_mallocz(sizeof(IOHandlerRecord));
5596
if (!ioh)
5597
return -1;
5598
2769
ioh->next = first_io_handler;
5599
2770
first_io_handler = ioh;
5600
2771
found:
5616
2787
return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
5617
2788
}
5618
2789
2790
#ifdef _WIN32
5619
2791
/***********************************************************/
5620
2792
/* Polling handling */
5621
2793
5631
2803
{
5632
2804
PollingEntry **ppe, *pe;
5633
2805
pe = qemu_mallocz(sizeof(PollingEntry));
5634
if (!pe)
5635
return -1;
5636
2806
pe->func = func;
5637
2807
pe->opaque = opaque;
5638
2808
for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
5653
2823
}
5654
2824
}
5655
2825
5656
#ifdef _WIN32
5657
2826
/***********************************************************/
5658
2827
/* Wait objects support */
5659
2828
typedef struct WaitObjects {
5699
2868
#endif
5700
2869
5701
2870
/***********************************************************/
5702
/* savevm/loadvm support */
5703
5704
#define IO_BUF_SIZE 32768
5705
5706
struct QEMUFile {
5707
FILE *outfile;
5708
BlockDriverState *bs;
5709
int is_file;
5710
int is_writable;
5711
int64_t base_offset;
5712
int64_t buf_offset; /* start of buffer when writing, end of buffer
5713
when reading */
5714
int buf_index;
5715
int buf_size; /* 0 when writing */
5716
uint8_t buf[IO_BUF_SIZE];
5717
};
5718
5719
QEMUFile *qemu_fopen(const char *filename, const char *mode)
5720
{
5721
QEMUFile *f;
5722
5723
f = qemu_mallocz(sizeof(QEMUFile));
5724
if (!f)
5725
return NULL;
5726
if (!strcmp(mode, "wb")) {
5727
f->is_writable = 1;
5728
} else if (!strcmp(mode, "rb")) {
5729
f->is_writable = 0;
5730
} else {
5731
goto fail;
5732
}
5733
f->outfile = fopen(filename, mode);
5734
if (!f->outfile)
5735
goto fail;
5736
f->is_file = 1;
5737
return f;
5738
fail:
5739
if (f->outfile)
5740
fclose(f->outfile);
5741
qemu_free(f);
5742
return NULL;
5743
}
5744
5745
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5746
{
5747
QEMUFile *f;
5748
5749
f = qemu_mallocz(sizeof(QEMUFile));
5750
if (!f)
5751
return NULL;
5752
f->is_file = 0;
5753
f->bs = bs;
5754
f->is_writable = is_writable;
5755
f->base_offset = offset;
5756
return f;
5757
}
5758
5759
void qemu_fflush(QEMUFile *f)
5760
{
5761
if (!f->is_writable)
5762
return;
5763
if (f->buf_index > 0) {
5764
if (f->is_file) {
5765
fseek(f->outfile, f->buf_offset, SEEK_SET);
5766
fwrite(f->buf, 1, f->buf_index, f->outfile);
5767
} else {
5768
bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
5769
f->buf, f->buf_index);
5770
}
5771
f->buf_offset += f->buf_index;
5772
f->buf_index = 0;
5773
}
5774
}
5775
5776
static void qemu_fill_buffer(QEMUFile *f)
5777
{
5778
int len;
5779
5780
if (f->is_writable)
5781
return;
5782
if (f->is_file) {
5783
fseek(f->outfile, f->buf_offset, SEEK_SET);
5784
len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
5785
if (len < 0)
5786
len = 0;
5787
} else {
5788
len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
5789
f->buf, IO_BUF_SIZE);
5790
if (len < 0)
5791
len = 0;
5792
}
5793
f->buf_index = 0;
5794
f->buf_size = len;
5795
f->buf_offset += len;
5796
}
5797
5798
void qemu_fclose(QEMUFile *f)
5799
{
5800
if (f->is_writable)
5801
qemu_fflush(f);
5802
if (f->is_file) {
5803
fclose(f->outfile);
5804
}
5805
qemu_free(f);
5806
}
5807
5808
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
5809
{
5810
int l;
5811
while (size > 0) {
5812
l = IO_BUF_SIZE - f->buf_index;
5813
if (l > size)
5814
l = size;
5815
memcpy(f->buf + f->buf_index, buf, l);
5816
f->buf_index += l;
5817
buf += l;
5818
size -= l;
5819
if (f->buf_index >= IO_BUF_SIZE)
5820
qemu_fflush(f);
5821
}
5822
}
5823
5824
void qemu_put_byte(QEMUFile *f, int v)
5825
{
5826
f->buf[f->buf_index++] = v;
5827
if (f->buf_index >= IO_BUF_SIZE)
5828
qemu_fflush(f);
5829
}
5830
5831
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
5832
{
5833
int size, l;
5834
5835
size = size1;
5836
while (size > 0) {
5837
l = f->buf_size - f->buf_index;
5838
if (l == 0) {
5839
qemu_fill_buffer(f);
5840
l = f->buf_size - f->buf_index;
5841
if (l == 0)
5842
break;
5843
}
5844
if (l > size)
5845
l = size;
5846
memcpy(buf, f->buf + f->buf_index, l);
5847
f->buf_index += l;
5848
buf += l;
5849
size -= l;
5850
}
5851
return size1 - size;
5852
}
5853
5854
int qemu_get_byte(QEMUFile *f)
5855
{
5856
if (f->buf_index >= f->buf_size) {
5857
qemu_fill_buffer(f);
5858
if (f->buf_index >= f->buf_size)
5859
return 0;
5860
}
5861
return f->buf[f->buf_index++];
5862
}
5863
5864
int64_t qemu_ftell(QEMUFile *f)
5865
{
5866
return f->buf_offset - f->buf_size + f->buf_index;
5867
}
5868
5869
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
5870
{
5871
if (whence == SEEK_SET) {
5872
/* nothing to do */
5873
} else if (whence == SEEK_CUR) {
5874
pos += qemu_ftell(f);
5875
} else {
5876
/* SEEK_END not supported */
5877
return -1;
5878
}
5879
if (f->is_writable) {
5880
qemu_fflush(f);
5881
f->buf_offset = pos;
5882
} else {
5883
f->buf_offset = pos;
5884
f->buf_index = 0;
5885
f->buf_size = 0;
5886
}
5887
return pos;
5888
}
5889
5890
void qemu_put_be16(QEMUFile *f, unsigned int v)
5891
{
5892
qemu_put_byte(f, v >> 8);
5893
qemu_put_byte(f, v);
5894
}
5895
5896
void qemu_put_be32(QEMUFile *f, unsigned int v)
5897
{
5898
qemu_put_byte(f, v >> 24);
5899
qemu_put_byte(f, v >> 16);
5900
qemu_put_byte(f, v >> 8);
5901
qemu_put_byte(f, v);
5902
}
5903
5904
void qemu_put_be64(QEMUFile *f, uint64_t v)
5905
{
5906
qemu_put_be32(f, v >> 32);
5907
qemu_put_be32(f, v);
5908
}
5909
5910
unsigned int qemu_get_be16(QEMUFile *f)
5911
{
5912
unsigned int v;
5913
v = qemu_get_byte(f) << 8;
5914
v |= qemu_get_byte(f);
5915
return v;
5916
}
5917
5918
unsigned int qemu_get_be32(QEMUFile *f)
5919
{
5920
unsigned int v;
5921
v = qemu_get_byte(f) << 24;
5922
v |= qemu_get_byte(f) << 16;
5923
v |= qemu_get_byte(f) << 8;
5924
v |= qemu_get_byte(f);
5925
return v;
5926
}
5927
5928
uint64_t qemu_get_be64(QEMUFile *f)
5929
{
5930
uint64_t v;
5931
v = (uint64_t)qemu_get_be32(f) << 32;
5932
v |= qemu_get_be32(f);
5933
return v;
5934
}
5935
5936
typedef struct SaveStateEntry {
5937
char idstr[256];
5938
int instance_id;
5939
int version_id;
5940
SaveStateHandler *save_state;
5941
LoadStateHandler *load_state;
5942
void *opaque;
5943
struct SaveStateEntry *next;
5944
} SaveStateEntry;
5945
5946
static SaveStateEntry *first_se;
5947
5948
int register_savevm(const char *idstr,
5949
int instance_id,
5950
int version_id,
5951
SaveStateHandler *save_state,
5952
LoadStateHandler *load_state,
5953
void *opaque)
5954
{
5955
SaveStateEntry *se, **pse;
5956
5957
se = qemu_malloc(sizeof(SaveStateEntry));
5958
if (!se)
5959
return -1;
5960
pstrcpy(se->idstr, sizeof(se->idstr), idstr);
5961
se->instance_id = instance_id;
5962
se->version_id = version_id;
5963
se->save_state = save_state;
5964
se->load_state = load_state;
5965
se->opaque = opaque;
5966
se->next = NULL;
5967
5968
/* add at the end of list */
5969
pse = &first_se;
5970
while (*pse != NULL)
5971
pse = &(*pse)->next;
5972
*pse = se;
5973
return 0;
5974
}
5975
5976
#define QEMU_VM_FILE_MAGIC 0x5145564d
5977
#define QEMU_VM_FILE_VERSION 0x00000002
5978
5979
static int qemu_savevm_state(QEMUFile *f)
5980
{
5981
SaveStateEntry *se;
5982
int len, ret;
5983
int64_t cur_pos, len_pos, total_len_pos;
5984
5985
qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
5986
qemu_put_be32(f, QEMU_VM_FILE_VERSION);
5987
total_len_pos = qemu_ftell(f);
5988
qemu_put_be64(f, 0); /* total size */
5989
5990
for(se = first_se; se != NULL; se = se->next) {
5991
/* ID string */
5992
len = strlen(se->idstr);
5993
qemu_put_byte(f, len);
5994
qemu_put_buffer(f, (uint8_t *)se->idstr, len);
5995
5996
qemu_put_be32(f, se->instance_id);
5997
qemu_put_be32(f, se->version_id);
5998
5999
/* record size: filled later */
6000
len_pos = qemu_ftell(f);
6001
qemu_put_be32(f, 0);
6002
se->save_state(f, se->opaque);
6003
6004
/* fill record size */
6005
cur_pos = qemu_ftell(f);
6006
len = cur_pos - len_pos - 4;
6007
qemu_fseek(f, len_pos, SEEK_SET);
6008
qemu_put_be32(f, len);
6009
qemu_fseek(f, cur_pos, SEEK_SET);
6010
}
6011
cur_pos = qemu_ftell(f);
6012
qemu_fseek(f, total_len_pos, SEEK_SET);
6013
qemu_put_be64(f, cur_pos - total_len_pos - 8);
6014
qemu_fseek(f, cur_pos, SEEK_SET);
6015
6016
ret = 0;
6017
return ret;
6018
}
6019
6020
static SaveStateEntry *find_se(const char *idstr, int instance_id)
6021
{
6022
SaveStateEntry *se;
6023
6024
for(se = first_se; se != NULL; se = se->next) {
6025
if (!strcmp(se->idstr, idstr) &&
6026
instance_id == se->instance_id)
6027
return se;
6028
}
6029
return NULL;
6030
}
6031
6032
static int qemu_loadvm_state(QEMUFile *f)
6033
{
6034
SaveStateEntry *se;
6035
int len, ret, instance_id, record_len, version_id;
6036
int64_t total_len, end_pos, cur_pos;
6037
unsigned int v;
6038
char idstr[256];
6039
6040
v = qemu_get_be32(f);
6041
if (v != QEMU_VM_FILE_MAGIC)
6042
goto fail;
6043
v = qemu_get_be32(f);
6044
if (v != QEMU_VM_FILE_VERSION) {
6045
fail:
6046
ret = -1;
6047
goto the_end;
6048
}
6049
total_len = qemu_get_be64(f);
6050
end_pos = total_len + qemu_ftell(f);
6051
for(;;) {
6052
if (qemu_ftell(f) >= end_pos)
6053
break;
6054
len = qemu_get_byte(f);
6055
qemu_get_buffer(f, (uint8_t *)idstr, len);
6056
idstr[len] = '\0';
6057
instance_id = qemu_get_be32(f);
6058
version_id = qemu_get_be32(f);
6059
record_len = qemu_get_be32(f);
6060
#if 0
6061
printf("idstr=%s instance=0x%x version=%d len=%d\n",
6062
idstr, instance_id, version_id, record_len);
6063
#endif
6064
cur_pos = qemu_ftell(f);
6065
se = find_se(idstr, instance_id);
6066
if (!se) {
6067
fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6068
instance_id, idstr);
6069
} else {
6070
ret = se->load_state(f, se->opaque, version_id);
6071
if (ret < 0) {
6072
fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6073
instance_id, idstr);
6074
}
6075
}
6076
/* always seek to exact end of record */
6077
qemu_fseek(f, cur_pos + record_len, SEEK_SET);
6078
}
6079
ret = 0;
6080
the_end:
6081
return ret;
6082
}
6083
6084
/* device can contain snapshots */
6085
static int bdrv_can_snapshot(BlockDriverState *bs)
6086
{
6087
return (bs &&
6088
!bdrv_is_removable(bs) &&
6089
!bdrv_is_read_only(bs));
6090
}
6091
6092
/* device must be snapshots in order to have a reliable snapshot */
6093
static int bdrv_has_snapshot(BlockDriverState *bs)
6094
{
6095
return (bs &&
6096
!bdrv_is_removable(bs) &&
6097
!bdrv_is_read_only(bs));
6098
}
6099
6100
static BlockDriverState *get_bs_snapshots(void)
6101
{
6102
BlockDriverState *bs;
6103
int i;
6104
6105
if (bs_snapshots)
6106
return bs_snapshots;
6107
for(i = 0; i <= nb_drives; i++) {
6108
bs = drives_table[i].bdrv;
6109
if (bdrv_can_snapshot(bs))
6110
goto ok;
6111
}
6112
return NULL;
6113
ok:
6114
bs_snapshots = bs;
6115
return bs;
6116
}
6117
6118
static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6119
const char *name)
6120
{
6121
QEMUSnapshotInfo *sn_tab, *sn;
6122
int nb_sns, i, ret;
6123
6124
ret = -ENOENT;
6125
nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6126
if (nb_sns < 0)
6127
return ret;
6128
for(i = 0; i < nb_sns; i++) {
6129
sn = &sn_tab[i];
6130
if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6131
*sn_info = *sn;
6132
ret = 0;
6133
break;
6134
}
6135
}
6136
qemu_free(sn_tab);
6137
return ret;
6138
}
6139
6140
void do_savevm(const char *name)
6141
{
6142
BlockDriverState *bs, *bs1;
6143
QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6144
int must_delete, ret, i;
6145
BlockDriverInfo bdi1, *bdi = &bdi1;
6146
QEMUFile *f;
6147
int saved_vm_running;
6148
#ifdef _WIN32
6149
struct _timeb tb;
6150
#else
6151
struct timeval tv;
6152
#endif
6153
6154
bs = get_bs_snapshots();
6155
if (!bs) {
6156
term_printf("No block device can accept snapshots\n");
6157
return;
6158
}
6159
6160
/* ??? Should this occur after vm_stop? */
6161
qemu_aio_flush();
6162
6163
saved_vm_running = vm_running;
6164
vm_stop(0);
6165
6166
must_delete = 0;
6167
if (name) {
6168
ret = bdrv_snapshot_find(bs, old_sn, name);
6169
if (ret >= 0) {
6170
must_delete = 1;
6171
}
6172
}
6173
memset(sn, 0, sizeof(*sn));
6174
if (must_delete) {
6175
pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6176
pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6177
} else {
6178
if (name)
6179
pstrcpy(sn->name, sizeof(sn->name), name);
6180
}
6181
6182
/* fill auxiliary fields */
6183
#ifdef _WIN32
6184
_ftime(&tb);
6185
sn->date_sec = tb.time;
6186
sn->date_nsec = tb.millitm * 1000000;
6187
#else
6188
gettimeofday(&tv, NULL);
6189
sn->date_sec = tv.tv_sec;
6190
sn->date_nsec = tv.tv_usec * 1000;
6191
#endif
6192
sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6193
6194
if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6195
term_printf("Device %s does not support VM state snapshots\n",
6196
bdrv_get_device_name(bs));
6197
goto the_end;
6198
}
6199
6200
/* save the VM state */
6201
f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6202
if (!f) {
6203
term_printf("Could not open VM state file\n");
6204
goto the_end;
6205
}
6206
ret = qemu_savevm_state(f);
6207
sn->vm_state_size = qemu_ftell(f);
6208
qemu_fclose(f);
6209
if (ret < 0) {
6210
term_printf("Error %d while writing VM\n", ret);
6211
goto the_end;
6212
}
6213
6214
/* create the snapshots */
6215
6216
for(i = 0; i < nb_drives; i++) {
6217
bs1 = drives_table[i].bdrv;
6218
if (bdrv_has_snapshot(bs1)) {
6219
if (must_delete) {
6220
ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6221
if (ret < 0) {
6222
term_printf("Error while deleting snapshot on '%s'\n",
6223
bdrv_get_device_name(bs1));
6224
}
6225
}
6226
ret = bdrv_snapshot_create(bs1, sn);
6227
if (ret < 0) {
6228
term_printf("Error while creating snapshot on '%s'\n",
6229
bdrv_get_device_name(bs1));
6230
}
6231
}
6232
}
6233
6234
the_end:
6235
if (saved_vm_running)
6236
vm_start();
6237
}
6238
6239
void do_loadvm(const char *name)
6240
{
6241
BlockDriverState *bs, *bs1;
6242
BlockDriverInfo bdi1, *bdi = &bdi1;
6243
QEMUFile *f;
6244
int i, ret;
6245
int saved_vm_running;
6246
6247
bs = get_bs_snapshots();
6248
if (!bs) {
6249
term_printf("No block device supports snapshots\n");
6250
return;
6251
}
6252
6253
/* Flush all IO requests so they don't interfere with the new state. */
6254
qemu_aio_flush();
6255
6256
saved_vm_running = vm_running;
6257
vm_stop(0);
6258
6259
for(i = 0; i <= nb_drives; i++) {
6260
bs1 = drives_table[i].bdrv;
6261
if (bdrv_has_snapshot(bs1)) {
6262
ret = bdrv_snapshot_goto(bs1, name);
6263
if (ret < 0) {
6264
if (bs != bs1)
6265
term_printf("Warning: ");
6266
switch(ret) {
6267
case -ENOTSUP:
6268
term_printf("Snapshots not supported on device '%s'\n",
6269
bdrv_get_device_name(bs1));
6270
break;
6271
case -ENOENT:
6272
term_printf("Could not find snapshot '%s' on device '%s'\n",
6273
name, bdrv_get_device_name(bs1));
6274
break;
6275
default:
6276
term_printf("Error %d while activating snapshot on '%s'\n",
6277
ret, bdrv_get_device_name(bs1));
6278
break;
6279
}
6280
/* fatal on snapshot block device */
6281
if (bs == bs1)
6282
goto the_end;
6283
}
6284
}
6285
}
6286
6287
if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6288
term_printf("Device %s does not support VM state snapshots\n",
6289
bdrv_get_device_name(bs));
6290
return;
6291
}
6292
6293
/* restore the VM state */
6294
f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6295
if (!f) {
6296
term_printf("Could not open VM state file\n");
6297
goto the_end;
6298
}
6299
ret = qemu_loadvm_state(f);
6300
qemu_fclose(f);
6301
if (ret < 0) {
6302
term_printf("Error %d while loading VM state\n", ret);
6303
}
6304
the_end:
6305
if (saved_vm_running)
6306
vm_start();
6307
}
6308
6309
void do_delvm(const char *name)
6310
{
6311
BlockDriverState *bs, *bs1;
6312
int i, ret;
6313
6314
bs = get_bs_snapshots();
6315
if (!bs) {
6316
term_printf("No block device supports snapshots\n");
6317
return;
6318
}
6319
6320
for(i = 0; i <= nb_drives; i++) {
6321
bs1 = drives_table[i].bdrv;
6322
if (bdrv_has_snapshot(bs1)) {
6323
ret = bdrv_snapshot_delete(bs1, name);
6324
if (ret < 0) {
6325
if (ret == -ENOTSUP)
6326
term_printf("Snapshots not supported on device '%s'\n",
6327
bdrv_get_device_name(bs1));
6328
else
6329
term_printf("Error %d while deleting snapshot on '%s'\n",
6330
ret, bdrv_get_device_name(bs1));
6331
}
6332
}
6333
}
6334
}
6335
6336
void do_info_snapshots(void)
6337
{
6338
BlockDriverState *bs, *bs1;
6339
QEMUSnapshotInfo *sn_tab, *sn;
6340
int nb_sns, i;
6341
char buf[256];
6342
6343
bs = get_bs_snapshots();
6344
if (!bs) {
6345
term_printf("No available block device supports snapshots\n");
6346
return;
6347
}
6348
term_printf("Snapshot devices:");
6349
for(i = 0; i <= nb_drives; i++) {
6350
bs1 = drives_table[i].bdrv;
6351
if (bdrv_has_snapshot(bs1)) {
6352
if (bs == bs1)
6353
term_printf(" %s", bdrv_get_device_name(bs1));
6354
}
6355
}
6356
term_printf("\n");
6357
6358
nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6359
if (nb_sns < 0) {
6360
term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
6361
return;
6362
}
6363
term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
6364
term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
6365
for(i = 0; i < nb_sns; i++) {
6366
sn = &sn_tab[i];
6367
term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
6368
}
6369
qemu_free(sn_tab);
6370
}
6371
6372
/***********************************************************/
6373
2871
/* ram save/restore */
6374
2872
6375
2873
static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
6389
2887
default:
6390
2888
return -EINVAL;
6391
2889
}
2890
2891
if (qemu_file_has_error(f))
2892
return -EIO;
2893
6392
2894
return 0;
6393
2895
}
6394
2896
6397
2899
int ret;
6398
2900
ram_addr_t i;
6399
2901
6400
if (qemu_get_be32(f) != phys_ram_size)
2902
if (qemu_get_be32(f) != last_ram_offset)
6401
2903
return -EINVAL;
6402
for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
6403
ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
2904
for(i = 0; i < last_ram_offset; i+= TARGET_PAGE_SIZE) {
2905
ret = ram_get_page(f, qemu_get_ram_ptr(i), TARGET_PAGE_SIZE);
6404
2906
if (ret)
6405
2907
return ret;
6406
2908
}
6411
2913
#define IOBUF_SIZE 4096
6412
2914
#define RAM_CBLOCK_MAGIC 0xfabe
6413
2915
6414
typedef struct RamCompressState {
6415
z_stream zstream;
6416
QEMUFile *f;
6417
uint8_t buf[IOBUF_SIZE];
6418
} RamCompressState;
6419
6420
static int ram_compress_open(RamCompressState *s, QEMUFile *f)
6421
{
6422
int ret;
6423
memset(s, 0, sizeof(*s));
6424
s->f = f;
6425
ret = deflateInit2(&s->zstream, 1,
6426
Z_DEFLATED, 15,
6427
9, Z_DEFAULT_STRATEGY);
6428
if (ret != Z_OK)
6429
return -1;
6430
s->zstream.avail_out = IOBUF_SIZE;
6431
s->zstream.next_out = s->buf;
6432
return 0;
6433
}
6434
6435
static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
6436
{
6437
qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
6438
qemu_put_be16(s->f, len);
6439
qemu_put_buffer(s->f, buf, len);
6440
}
6441
6442
static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
6443
{
6444
int ret;
6445
6446
s->zstream.avail_in = len;
6447
s->zstream.next_in = (uint8_t *)buf;
6448
while (s->zstream.avail_in > 0) {
6449
ret = deflate(&s->zstream, Z_NO_FLUSH);
6450
if (ret != Z_OK)
6451
return -1;
6452
if (s->zstream.avail_out == 0) {
6453
ram_put_cblock(s, s->buf, IOBUF_SIZE);
6454
s->zstream.avail_out = IOBUF_SIZE;
6455
s->zstream.next_out = s->buf;
6456
}
6457
}
6458
return 0;
6459
}
6460
6461
static void ram_compress_close(RamCompressState *s)
6462
{
6463
int len, ret;
6464
6465
/* compress last bytes */
6466
for(;;) {
6467
ret = deflate(&s->zstream, Z_FINISH);
6468
if (ret == Z_OK || ret == Z_STREAM_END) {
6469
len = IOBUF_SIZE - s->zstream.avail_out;
6470
if (len > 0) {
6471
ram_put_cblock(s, s->buf, len);
6472
}
6473
s->zstream.avail_out = IOBUF_SIZE;
6474
s->zstream.next_out = s->buf;
6475
if (ret == Z_STREAM_END)
6476
break;
6477
} else {
6478
goto fail;
6479
}
6480
}
6481
fail:
6482
deflateEnd(&s->zstream);
6483
}
6484
6485
2916
typedef struct RamDecompressState {
6486
2917
z_stream zstream;
6487
2918
QEMUFile *f;
6529
2960
inflateEnd(&s->zstream);
6530
2961
}
6531
2962
6532
static void ram_save(QEMUFile *f, void *opaque)
6533
{
6534
ram_addr_t i;
6535
RamCompressState s1, *s = &s1;
6536
uint8_t buf[10];
6537
6538
qemu_put_be32(f, phys_ram_size);
6539
if (ram_compress_open(s, f) < 0)
6540
return;
6541
for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6542
#if 0
6543
if (tight_savevm_enabled) {
6544
int64_t sector_num;
6545
int j;
6546
6547
/* find if the memory block is available on a virtual
6548
block device */
6549
sector_num = -1;
6550
for(j = 0; j < nb_drives; j++) {
6551
sector_num = bdrv_hash_find(drives_table[j].bdrv,
6552
phys_ram_base + i,
6553
BDRV_HASH_BLOCK_SIZE);
6554
if (sector_num >= 0)
6555
break;
2963
#define RAM_SAVE_FLAG_FULL 0x01
2964
#define RAM_SAVE_FLAG_COMPRESS 0x02
2965
#define RAM_SAVE_FLAG_MEM_SIZE 0x04
2966
#define RAM_SAVE_FLAG_PAGE 0x08
2967
#define RAM_SAVE_FLAG_EOS 0x10
2968
2969
static int is_dup_page(uint8_t *page, uint8_t ch)
2970
{
2971
uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
2972
uint32_t *array = (uint32_t *)page;
2973
int i;
2974
2975
for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
2976
if (array[i] != val)
2977
return 0;
2978
}
2979
2980
return 1;
2981
}
2982
2983
static int ram_save_block(QEMUFile *f)
2984
{
2985
static ram_addr_t current_addr = 0;
2986
ram_addr_t saved_addr = current_addr;
2987
ram_addr_t addr = 0;
2988
int found = 0;
2989
2990
while (addr < last_ram_offset) {
2991
if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
2992
uint8_t *p;
2993
2994
cpu_physical_memory_reset_dirty(current_addr,
2995
current_addr + TARGET_PAGE_SIZE,
2996
MIGRATION_DIRTY_FLAG);
2997
2998
p = qemu_get_ram_ptr(current_addr);
2999
3000
if (is_dup_page(p, *p)) {
3001
qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3002
qemu_put_byte(f, *p);
3003
} else {
3004
qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3005
qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
6556
3006
}
6557
if (j == nb_drives)
6558
goto normal_compress;
6559
buf[0] = 1;
6560
buf[1] = j;
6561
cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
6562
ram_compress_buf(s, buf, 10);
6563
} else
6564
#endif
6565
{
6566
// normal_compress:
6567
buf[0] = 0;
6568
ram_compress_buf(s, buf, 1);
6569
ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
6570
}
6571
}
6572
ram_compress_close(s);
6573
}
6574
6575
static int ram_load(QEMUFile *f, void *opaque, int version_id)
3007
3008
found = 1;
3009
break;
3010
}
3011
addr += TARGET_PAGE_SIZE;
3012
current_addr = (saved_addr + addr) % last_ram_offset;
3013
}
3014
3015
return found;
3016
}
3017
3018
static uint64_t bytes_transferred = 0;
3019
3020
static ram_addr_t ram_save_remaining(void)
3021
{
3022
ram_addr_t addr;
3023
ram_addr_t count = 0;
3024
3025
for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3026
if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3027
count++;
3028
}
3029
3030
return count;
3031
}
3032
3033
uint64_t ram_bytes_remaining(void)
3034
{
3035
return ram_save_remaining() * TARGET_PAGE_SIZE;
3036
}
3037
3038
uint64_t ram_bytes_transferred(void)
3039
{
3040
return bytes_transferred;
3041
}
3042
3043
uint64_t ram_bytes_total(void)
3044
{
3045
return last_ram_offset;
3046
}
3047
3048
static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3049
{
3050
ram_addr_t addr;
3051
uint64_t bytes_transferred_last;
3052
double bwidth = 0;
3053
uint64_t expected_time = 0;
3054
3055
if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
3056
qemu_file_set_error(f);
3057
return 0;
3058
}
3059
3060
if (stage == 1) {
3061
/* Make sure all dirty bits are set */
3062
for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3063
if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3064
cpu_physical_memory_set_dirty(addr);
3065
}
3066
3067
/* Enable dirty memory tracking */
3068
cpu_physical_memory_set_dirty_tracking(1);
3069
3070
qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
3071
}
3072
3073
bytes_transferred_last = bytes_transferred;
3074
bwidth = get_clock();
3075
3076
while (!qemu_file_rate_limit(f)) {
3077
int ret;
3078
3079
ret = ram_save_block(f);
3080
bytes_transferred += ret * TARGET_PAGE_SIZE;
3081
if (ret == 0) /* no more blocks */
3082
break;
3083
}
3084
3085
bwidth = get_clock() - bwidth;
3086
bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
3087
3088
/* if we haven't transferred anything this round, force expected_time to a
3089
* a very high value, but without crashing */
3090
if (bwidth == 0)
3091
bwidth = 0.000001;
3092
3093
/* try transferring iterative blocks of memory */
3094
3095
if (stage == 3) {
3096
3097
/* flush all remaining blocks regardless of rate limiting */
3098
while (ram_save_block(f) != 0) {
3099
bytes_transferred += TARGET_PAGE_SIZE;
3100
}
3101
cpu_physical_memory_set_dirty_tracking(0);
3102
}
3103
3104
qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3105
3106
expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
3107
3108
return (stage == 2) && (expected_time <= migrate_max_downtime());
3109
}
3110
3111
static int ram_load_dead(QEMUFile *f, void *opaque)
6576
3112
{
6577
3113
RamDecompressState s1, *s = &s1;
6578
3114
uint8_t buf[10];
6579
3115
ram_addr_t i;
6580
3116
6581
if (version_id == 1)
6582
return ram_load_v1(f, opaque);
6583
if (version_id != 2)
6584
return -EINVAL;
6585
if (qemu_get_be32(f) != phys_ram_size)
6586
return -EINVAL;
6587
3117
if (ram_decompress_open(s, f) < 0)
6588
3118
return -EINVAL;
6589
for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
3119
for(i = 0; i < last_ram_offset; i+= BDRV_HASH_BLOCK_SIZE) {
6590
3120
if (ram_decompress_buf(s, buf, 1) < 0) {
6591
3121
fprintf(stderr, "Error while reading ram block header\n");
6592
3122
goto error;
6593
3123
}
6594
3124
if (buf[0] == 0) {
6595
if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
3125
if (ram_decompress_buf(s, qemu_get_ram_ptr(i),
3126
BDRV_HASH_BLOCK_SIZE) < 0) {
6596
3127
fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
6597
3128
goto error;
6598
3129
}
6599
} else
6600
#if 0
6601
if (buf[0] == 1) {
6602
int bs_index;
6603
int64_t sector_num;
6604
6605
ram_decompress_buf(s, buf + 1, 9);
6606
bs_index = buf[1];
6607
sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
6608
if (bs_index >= nb_drives) {
6609
fprintf(stderr, "Invalid block device index %d\n", bs_index);
6610
goto error;
6611
}
6612
if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
6613
phys_ram_base + i,
6614
BDRV_HASH_BLOCK_SIZE / 512) < 0) {
6615
fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
6616
bs_index, sector_num);
6617
goto error;
6618
}
6619
} else
6620
#endif
6621
{
3130
} else {
6622
3131
error:
6623
3132
printf("Error block header\n");
6624
3133
return -EINVAL;
6625
3134
}
6626
3135
}
6627
3136
ram_decompress_close(s);
6628
return 0;
3137
3138
return 0;
3139
}
3140
3141
static int ram_load(QEMUFile *f, void *opaque, int version_id)
3142
{
3143
ram_addr_t addr;
3144
int flags;
3145
3146
if (version_id == 1)
3147
return ram_load_v1(f, opaque);
3148
3149
if (version_id == 2) {
3150
if (qemu_get_be32(f) != last_ram_offset)
3151
return -EINVAL;
3152
return ram_load_dead(f, opaque);
3153
}
3154
3155
if (version_id != 3)
3156
return -EINVAL;
3157
3158
do {
3159
addr = qemu_get_be64(f);
3160
3161
flags = addr & ~TARGET_PAGE_MASK;
3162
addr &= TARGET_PAGE_MASK;
3163
3164
if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3165
if (addr != last_ram_offset)
3166
return -EINVAL;
3167
}
3168
3169
if (flags & RAM_SAVE_FLAG_FULL) {
3170
if (ram_load_dead(f, opaque) < 0)
3171
return -EINVAL;
3172
}
3173
3174
if (flags & RAM_SAVE_FLAG_COMPRESS) {
3175
uint8_t ch = qemu_get_byte(f);
3176
memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
3177
#ifndef _WIN32
3178
if (ch == 0 &&
3179
(!kvm_enabled() || kvm_has_sync_mmu())) {
3180
madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
3181
}
3182
#endif
3183
} else if (flags & RAM_SAVE_FLAG_PAGE)
3184
qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
3185
} while (!(flags & RAM_SAVE_FLAG_EOS));
3186
3187
return 0;
3188
}
3189
3190
void qemu_service_io(void)
3191
{
3192
qemu_notify_event();
6629
3193
}
6630
3194
6631
3195
/***********************************************************/
6635
3199
QEMUBHFunc *cb;
6636
3200
void *opaque;
6637
3201
int scheduled;
3202
int idle;
3203
int deleted;
6638
3204
QEMUBH *next;
6639
3205
};
6640
3206
6644
3210
{
6645
3211
QEMUBH *bh;
6646
3212
bh = qemu_mallocz(sizeof(QEMUBH));
6647
if (!bh)
6648
return NULL;
6649
3213
bh->cb = cb;
6650
3214
bh->opaque = opaque;
3215
bh->next = first_bh;
3216
first_bh = bh;
6651
3217
return bh;
6652
3218
}
6653
3219
6654
3220
int qemu_bh_poll(void)
6655
3221
{
6656
QEMUBH *bh, **pbh;
3222
QEMUBH *bh, **bhp;
6657
3223
int ret;
6658
3224
6659
3225
ret = 0;
6660
for(;;) {
6661
pbh = &first_bh;
6662
bh = *pbh;
6663
if (!bh)
6664
break;
6665
ret = 1;
6666
*pbh = bh->next;
6667
bh->scheduled = 0;
6668
bh->cb(bh->opaque);
6669
}
3226
for (bh = first_bh; bh; bh = bh->next) {
3227
if (!bh->deleted && bh->scheduled) {
3228
bh->scheduled = 0;
3229
if (!bh->idle)
3230
ret = 1;
3231
bh->idle = 0;
3232
bh->cb(bh->opaque);
3233
}
3234
}
3235
3236
/* remove deleted bhs */
3237
bhp = &first_bh;
3238
while (*bhp) {
3239
bh = *bhp;
3240
if (bh->deleted) {
3241
*bhp = bh->next;
3242
qemu_free(bh);
3243
} else
3244
bhp = &bh->next;
3245
}
3246
6670
3247
return ret;
6671
3248
}
6672
3249
3250
void qemu_bh_schedule_idle(QEMUBH *bh)
3251
{
3252
if (bh->scheduled)
3253
return;
3254
bh->scheduled = 1;
3255
bh->idle = 1;
3256
}
3257
6673
3258
void qemu_bh_schedule(QEMUBH *bh)
6674
3259
{
6675
CPUState *env = cpu_single_env;
6676
3260
if (bh->scheduled)
6677
3261
return;
6678
3262
bh->scheduled = 1;
6679
bh->next = first_bh;
6680
first_bh = bh;
6681
3263
bh->idle = 0;
6682
3264
/* stop the currently executing CPU to execute the BH ASAP */
6683
if (env) {
6684
cpu_interrupt(env, CPU_INTERRUPT_EXIT);
6685
}
3265
qemu_notify_event();
6686
3266
}
6687
3267
6688
3268
void qemu_bh_cancel(QEMUBH *bh)
6689
3269
{
6690
QEMUBH **pbh;
6691
if (bh->scheduled) {
6692
pbh = &first_bh;
6693
while (*pbh != bh)
6694
pbh = &(*pbh)->next;
6695
*pbh = bh->next;
6696
bh->scheduled = 0;
6697
}
3270
bh->scheduled = 0;
6698
3271
}
6699
3272
6700
3273
void qemu_bh_delete(QEMUBH *bh)
6701
3274
{
6702
qemu_bh_cancel(bh);
6703
qemu_free(bh);
3275
bh->scheduled = 0;
3276
bh->deleted = 1;
3277
}
3278
3279
static void qemu_bh_update_timeout(int *timeout)
3280
{
3281
QEMUBH *bh;
3282
3283
for (bh = first_bh; bh; bh = bh->next) {
3284
if (!bh->deleted && bh->scheduled) {
3285
if (bh->idle) {
3286
/* idle bottom halves will be polled at least
3287
* every 10ms */
3288
*timeout = MIN(10, *timeout);
3289
} else {
3290
/* non-idle bottom halves will be executed
3291
* immediately */
3292
*timeout = 0;
3293
break;
3294
}
3295
}
3296
}
6704
3297
}
6705
3298
6706
3299
/***********************************************************/
6707
3300
/* machine registration */
6708
3301
6709
QEMUMachine *first_machine = NULL;
3302
static QEMUMachine *first_machine = NULL;
3303
QEMUMachine *current_machine = NULL;
6710
3304
6711
3305
int qemu_register_machine(QEMUMachine *m)
6712
3306
{
6726
3320
for(m = first_machine; m != NULL; m = m->next) {
6727
3321
if (!strcmp(m->name, name))
6728
3322
return m;
3323
if (m->alias && !strcmp(m->alias, name))
3324
return m;
3325
}
3326
return NULL;
3327
}
3328
3329
static QEMUMachine *find_default_machine(void)
3330
{
3331
QEMUMachine *m;
3332
3333
for(m = first_machine; m != NULL; m = m->next) {
3334
if (m->is_default) {
3335
return m;
3336
}
6729
3337
}
6730
3338
return NULL;
6731
3339
}
6735
3343
6736
3344
static void gui_update(void *opaque)
6737
3345
{
3346
uint64_t interval = GUI_REFRESH_INTERVAL;
6738
3347
DisplayState *ds = opaque;
6739
ds->dpy_refresh(ds);
6740
qemu_mod_timer(ds->gui_timer,
6741
(ds->gui_timer_interval ?
6742
ds->gui_timer_interval :
6743
GUI_REFRESH_INTERVAL)
6744
+ qemu_get_clock(rt_clock));
3348
DisplayChangeListener *dcl = ds->listeners;
3349
3350
dpy_refresh(ds);
3351
3352
while (dcl != NULL) {
3353
if (dcl->gui_timer_interval &&
3354
dcl->gui_timer_interval < interval)
3355
interval = dcl->gui_timer_interval;
3356
dcl = dcl->next;
3357
}
3358
qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3359
}
3360
3361
static void nographic_update(void *opaque)
3362
{
3363
uint64_t interval = GUI_REFRESH_INTERVAL;
3364
3365
qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
6745
3366
}
6746
3367
6747
3368
struct vm_change_state_entry {
6758
3379
VMChangeStateEntry *e;
6759
3380
6760
3381
e = qemu_mallocz(sizeof (*e));
6761
if (!e)
6762
return NULL;
6763
3382
6764
3383
e->cb = cb;
6765
3384
e->opaque = opaque;
6773
3392
qemu_free (e);
6774
3393
}
6775
3394
6776
static void vm_state_notify(int running)
3395
static void vm_state_notify(int running, int reason)
6777
3396
{
6778
3397
VMChangeStateEntry *e;
6779
3398
6780
3399
for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
6781
e->cb(e->opaque, running);
3400
e->cb(e->opaque, running, reason);
6782
3401
}
6783
3402
}
6784
3403
6785
/* XXX: support several handlers */
6786
static VMStopHandler *vm_stop_cb;
6787
static void *vm_stop_opaque;
6788
6789
int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
6790
{
6791
vm_stop_cb = cb;
6792
vm_stop_opaque = opaque;
6793
return 0;
6794
}
6795
6796
void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
6797
{
6798
vm_stop_cb = NULL;
6799
}
3404
static void resume_all_vcpus(void);
3405
static void pause_all_vcpus(void);
6800
3406
6801
3407
void vm_start(void)
6802
3408
{
6803
3409
if (!vm_running) {
6804
3410
cpu_enable_ticks();
6805
3411
vm_running = 1;
6806
vm_state_notify(1);
3412
vm_state_notify(1, 0);
6807
3413
qemu_rearm_alarm_timer(alarm_timer);
6808
}
6809
}
6810
6811
void vm_stop(int reason)
6812
{
6813
if (vm_running) {
6814
cpu_disable_ticks();
6815
vm_running = 0;
6816
if (reason != 0) {
6817
if (vm_stop_cb) {
6818
vm_stop_cb(vm_stop_opaque, reason);
6819
}
6820
}
6821
vm_state_notify(0);
3414
resume_all_vcpus();
6822
3415
}
6823
3416
}
6824
3417
6825
3418
/* reset/shutdown handler */
6826
3419
6827
3420
typedef struct QEMUResetEntry {
3421
TAILQ_ENTRY(QEMUResetEntry) entry;
6828
3422
QEMUResetHandler *func;
6829
3423
void *opaque;
6830
struct QEMUResetEntry *next;
6831
3424
} QEMUResetEntry;
6832
3425
6833
static QEMUResetEntry *first_reset_entry;
3426
static TAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
3427
TAILQ_HEAD_INITIALIZER(reset_handlers);
6834
3428
static int reset_requested;
6835
3429
static int shutdown_requested;
6836
3430
static int powerdown_requested;
3431
static int debug_requested;
3432
static int vmstop_requested;
6837
3433
6838
3434
int qemu_shutdown_requested(void)
6839
3435
{
6856
3452
return r;
6857
3453
}
6858
3454
3455
static int qemu_debug_requested(void)
3456
{
3457
int r = debug_requested;
3458
debug_requested = 0;
3459
return r;
3460
}
3461
3462
static int qemu_vmstop_requested(void)
3463
{
3464
int r = vmstop_requested;
3465
vmstop_requested = 0;
3466
return r;
3467
}
3468
3469
static void do_vm_stop(int reason)
3470
{
3471
if (vm_running) {
3472
cpu_disable_ticks();
3473
vm_running = 0;
3474
pause_all_vcpus();
3475
vm_state_notify(0, reason);
3476
}
3477
}
3478
6859
3479
void qemu_register_reset(QEMUResetHandler *func, void *opaque)
6860
3480
{
6861
QEMUResetEntry **pre, *re;
3481
QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
6862
3482
6863
pre = &first_reset_entry;
6864
while (*pre != NULL)
6865
pre = &(*pre)->next;
6866
re = qemu_mallocz(sizeof(QEMUResetEntry));
6867
3483
re->func = func;
6868
3484
re->opaque = opaque;
6869
re->next = NULL;
6870
*pre = re;
3485
TAILQ_INSERT_TAIL(&reset_handlers, re, entry);
3486
}
3487
3488
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
3489
{
3490
QEMUResetEntry *re;
3491
3492
TAILQ_FOREACH(re, &reset_handlers, entry) {
3493
if (re->func == func && re->opaque == opaque) {
3494
TAILQ_REMOVE(&reset_handlers, re, entry);
3495
qemu_free(re);
3496
return;
3497
}
3498
}
6871
3499
}
6872
3500
6873
3501
void qemu_system_reset(void)
6874
3502
{
6875
QEMUResetEntry *re;
3503
QEMUResetEntry *re, *nre;
6876
3504
6877
3505
/* reset all devices */
6878
for(re = first_reset_entry; re != NULL; re = re->next) {
3506
TAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
6879
3507
re->func(re->opaque);
6880
3508
}
6881
3509
}
6887
3515
} else {
6888
3516
reset_requested = 1;
6889
3517
}
6890
if (cpu_single_env)
6891
cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3518
qemu_notify_event();
6892
3519
}
6893
3520
6894
3521
void qemu_system_shutdown_request(void)
6895
3522
{
6896
3523
shutdown_requested = 1;
6897
if (cpu_single_env)
6898
cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3524
qemu_notify_event();
6899
3525
}
6900
3526
6901
3527
void qemu_system_powerdown_request(void)
6902
3528
{
6903
3529
powerdown_requested = 1;
3530
qemu_notify_event();
3531
}
3532
3533
#ifdef CONFIG_IOTHREAD
3534
static void qemu_system_vmstop_request(int reason)
3535
{
3536
vmstop_requested = reason;
3537
qemu_notify_event();
3538
}
3539
#endif
3540
3541
#ifndef _WIN32
3542
static int io_thread_fd = -1;
3543
3544
static void qemu_event_increment(void)
3545
{
3546
static const char byte = 0;
3547
3548
if (io_thread_fd == -1)
3549
return;
3550
3551
write(io_thread_fd, &byte, sizeof(byte));
3552
}
3553
3554
static void qemu_event_read(void *opaque)
3555
{
3556
int fd = (unsigned long)opaque;
3557
ssize_t len;
3558
3559
/* Drain the notify pipe */
3560
do {
3561
char buffer[512];
3562
len = read(fd, buffer, sizeof(buffer));
3563
} while ((len == -1 && errno == EINTR) || len > 0);
3564
}
3565
3566
static int qemu_event_init(void)
3567
{
3568
int err;
3569
int fds[2];
3570
3571
err = pipe(fds);
3572
if (err == -1)
3573
return -errno;
3574
3575
err = fcntl_setfl(fds[0], O_NONBLOCK);
3576
if (err < 0)
3577
goto fail;
3578
3579
err = fcntl_setfl(fds[1], O_NONBLOCK);
3580
if (err < 0)
3581
goto fail;
3582
3583
qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3584
(void *)(unsigned long)fds[0]);
3585
3586
io_thread_fd = fds[1];
3587
return 0;
3588
3589
fail:
3590
close(fds[0]);
3591
close(fds[1]);
3592
return err;
3593
}
3594
#else
3595
HANDLE qemu_event_handle;
3596
3597
static void dummy_event_handler(void *opaque)
3598
{
3599
}
3600
3601
static int qemu_event_init(void)
3602
{
3603
qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3604
if (!qemu_event_handle) {
3605
perror("Failed CreateEvent");
3606
return -1;
3607
}
3608
qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3609
return 0;
3610
}
3611
3612
static void qemu_event_increment(void)
3613
{
3614
SetEvent(qemu_event_handle);
3615
}
3616
#endif
3617
3618
static int cpu_can_run(CPUState *env)
3619
{
3620
if (env->stop)
3621
return 0;
3622
if (env->stopped)
3623
return 0;
3624
return 1;
3625
}
3626
3627
#ifndef CONFIG_IOTHREAD
3628
static int qemu_init_main_loop(void)
3629
{
3630
return qemu_event_init();
3631
}
3632
3633
void qemu_init_vcpu(void *_env)
3634
{
3635
CPUState *env = _env;
3636
3637
if (kvm_enabled())
3638
kvm_init_vcpu(env);
3639
env->nr_cores = smp_cores;
3640
env->nr_threads = smp_threads;
3641
return;
3642
}
3643
3644
int qemu_cpu_self(void *env)
3645
{
3646
return 1;
3647
}
3648
3649
static void resume_all_vcpus(void)
3650
{
3651
}
3652
3653
static void pause_all_vcpus(void)
3654
{
3655
}
3656
3657
void qemu_cpu_kick(void *env)
3658
{
3659
return;
3660
}
3661
3662
void qemu_notify_event(void)
3663
{
3664
CPUState *env = cpu_single_env;
3665
3666
if (env) {
3667
cpu_exit(env);
3668
}
3669
}
3670
3671
#define qemu_mutex_lock_iothread() do { } while (0)
3672
#define qemu_mutex_unlock_iothread() do { } while (0)
3673
3674
void vm_stop(int reason)
3675
{
3676
do_vm_stop(reason);
3677
}
3678
3679
#else /* CONFIG_IOTHREAD */
3680
3681
#include "qemu-thread.h"
3682
3683
QemuMutex qemu_global_mutex;
3684
static QemuMutex qemu_fair_mutex;
3685
3686
static QemuThread io_thread;
3687
3688
static QemuThread *tcg_cpu_thread;
3689
static QemuCond *tcg_halt_cond;
3690
3691
static int qemu_system_ready;
3692
/* cpu creation */
3693
static QemuCond qemu_cpu_cond;
3694
/* system init */
3695
static QemuCond qemu_system_cond;
3696
static QemuCond qemu_pause_cond;
3697
3698
static void block_io_signals(void);
3699
static void unblock_io_signals(void);
3700
static int tcg_has_work(void);
3701
3702
static int qemu_init_main_loop(void)
3703
{
3704
int ret;
3705
3706
ret = qemu_event_init();
3707
if (ret)
3708
return ret;
3709
3710
qemu_cond_init(&qemu_pause_cond);
3711
qemu_mutex_init(&qemu_fair_mutex);
3712
qemu_mutex_init(&qemu_global_mutex);
3713
qemu_mutex_lock(&qemu_global_mutex);
3714
3715
unblock_io_signals();
3716
qemu_thread_self(&io_thread);
3717
3718
return 0;
3719
}
3720
3721
static void qemu_wait_io_event(CPUState *env)
3722
{
3723
while (!tcg_has_work())
3724
qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3725
3726
qemu_mutex_unlock(&qemu_global_mutex);
3727
3728
/*
3729
* Users of qemu_global_mutex can be starved, having no chance
3730
* to acquire it since this path will get to it first.
3731
* So use another lock to provide fairness.
3732
*/
3733
qemu_mutex_lock(&qemu_fair_mutex);
3734
qemu_mutex_unlock(&qemu_fair_mutex);
3735
3736
qemu_mutex_lock(&qemu_global_mutex);
3737
if (env->stop) {
3738
env->stop = 0;
3739
env->stopped = 1;
3740
qemu_cond_signal(&qemu_pause_cond);
3741
}
3742
}
3743
3744
static int qemu_cpu_exec(CPUState *env);
3745
3746
static void *kvm_cpu_thread_fn(void *arg)
3747
{
3748
CPUState *env = arg;
3749
3750
block_io_signals();
3751
qemu_thread_self(env->thread);
3752
3753
/* signal CPU creation */
3754
qemu_mutex_lock(&qemu_global_mutex);
3755
env->created = 1;
3756
qemu_cond_signal(&qemu_cpu_cond);
3757
3758
/* and wait for machine initialization */
3759
while (!qemu_system_ready)
3760
qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3761
3762
while (1) {
3763
if (cpu_can_run(env))
3764
qemu_cpu_exec(env);
3765
qemu_wait_io_event(env);
3766
}
3767
3768
return NULL;
3769
}
3770
3771
static void tcg_cpu_exec(void);
3772
3773
static void *tcg_cpu_thread_fn(void *arg)
3774
{
3775
CPUState *env = arg;
3776
3777
block_io_signals();
3778
qemu_thread_self(env->thread);
3779
3780
/* signal CPU creation */
3781
qemu_mutex_lock(&qemu_global_mutex);
3782
for (env = first_cpu; env != NULL; env = env->next_cpu)
3783
env->created = 1;
3784
qemu_cond_signal(&qemu_cpu_cond);
3785
3786
/* and wait for machine initialization */
3787
while (!qemu_system_ready)
3788
qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3789
3790
while (1) {
3791
tcg_cpu_exec();
3792
qemu_wait_io_event(cur_cpu);
3793
}
3794
3795
return NULL;
3796
}
3797
3798
void qemu_cpu_kick(void *_env)
3799
{
3800
CPUState *env = _env;
3801
qemu_cond_broadcast(env->halt_cond);
3802
if (kvm_enabled())
3803
qemu_thread_signal(env->thread, SIGUSR1);
3804
}
3805
3806
int qemu_cpu_self(void *env)
3807
{
3808
return (cpu_single_env != NULL);
3809
}
3810
3811
static void cpu_signal(int sig)
3812
{
6904
3813
if (cpu_single_env)
6905
cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
6906
}
6907
6908
/* boot_set handler */
6909
QEMUBootSetHandler *qemu_boot_set_handler = NULL;
6910
6911
void qemu_register_boot_set(QEMUBootSetHandler *func)
6912
{
6913
qemu_boot_set_handler = func;
6914
}
6915
6916
void main_loop_wait(int timeout)
6917
{
6918
IOHandlerRecord *ioh;
6919
fd_set rfds, wfds, xfds;
6920
int ret, nfds;
3814
cpu_exit(cpu_single_env);
3815
}
3816
3817
static void block_io_signals(void)
3818
{
3819
sigset_t set;
3820
struct sigaction sigact;
3821
3822
sigemptyset(&set);
3823
sigaddset(&set, SIGUSR2);
3824
sigaddset(&set, SIGIO);
3825
sigaddset(&set, SIGALRM);
3826
pthread_sigmask(SIG_BLOCK, &set, NULL);
3827
3828
sigemptyset(&set);
3829
sigaddset(&set, SIGUSR1);
3830
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3831
3832
memset(&sigact, 0, sizeof(sigact));
3833
sigact.sa_handler = cpu_signal;
3834
sigaction(SIGUSR1, &sigact, NULL);
3835
}
3836
3837
static void unblock_io_signals(void)
3838
{
3839
sigset_t set;
3840
3841
sigemptyset(&set);
3842
sigaddset(&set, SIGUSR2);
3843
sigaddset(&set, SIGIO);
3844
sigaddset(&set, SIGALRM);
3845
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3846
3847
sigemptyset(&set);
3848
sigaddset(&set, SIGUSR1);
3849
pthread_sigmask(SIG_BLOCK, &set, NULL);
3850
}
3851
3852
static void qemu_signal_lock(unsigned int msecs)
3853
{
3854
qemu_mutex_lock(&qemu_fair_mutex);
3855
3856
while (qemu_mutex_trylock(&qemu_global_mutex)) {
3857
qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
3858
if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
3859
break;
3860
}
3861
qemu_mutex_unlock(&qemu_fair_mutex);
3862
}
3863
3864
static void qemu_mutex_lock_iothread(void)
3865
{
3866
if (kvm_enabled()) {
3867
qemu_mutex_lock(&qemu_fair_mutex);
3868
qemu_mutex_lock(&qemu_global_mutex);
3869
qemu_mutex_unlock(&qemu_fair_mutex);
3870
} else
3871
qemu_signal_lock(100);
3872
}
3873
3874
static void qemu_mutex_unlock_iothread(void)
3875
{
3876
qemu_mutex_unlock(&qemu_global_mutex);
3877
}
3878
3879
static int all_vcpus_paused(void)
3880
{
3881
CPUState *penv = first_cpu;
3882
3883
while (penv) {
3884
if (!penv->stopped)
3885
return 0;
3886
penv = (CPUState *)penv->next_cpu;
3887
}
3888
3889
return 1;
3890
}
3891
3892
static void pause_all_vcpus(void)
3893
{
3894
CPUState *penv = first_cpu;
3895
3896
while (penv) {
3897
penv->stop = 1;
3898
qemu_thread_signal(penv->thread, SIGUSR1);
3899
qemu_cpu_kick(penv);
3900
penv = (CPUState *)penv->next_cpu;
3901
}
3902
3903
while (!all_vcpus_paused()) {
3904
qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
3905
penv = first_cpu;
3906
while (penv) {
3907
qemu_thread_signal(penv->thread, SIGUSR1);
3908
penv = (CPUState *)penv->next_cpu;
3909
}
3910
}
3911
}
3912
3913
static void resume_all_vcpus(void)
3914
{
3915
CPUState *penv = first_cpu;
3916
3917
while (penv) {
3918
penv->stop = 0;
3919
penv->stopped = 0;
3920
qemu_thread_signal(penv->thread, SIGUSR1);
3921
qemu_cpu_kick(penv);
3922
penv = (CPUState *)penv->next_cpu;
3923
}
3924
}
3925
3926
static void tcg_init_vcpu(void *_env)
3927
{
3928
CPUState *env = _env;
3929
/* share a single thread for all cpus with TCG */
3930
if (!tcg_cpu_thread) {
3931
env->thread = qemu_mallocz(sizeof(QemuThread));
3932
env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3933
qemu_cond_init(env->halt_cond);
3934
qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
3935
while (env->created == 0)
3936
qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3937
tcg_cpu_thread = env->thread;
3938
tcg_halt_cond = env->halt_cond;
3939
} else {
3940
env->thread = tcg_cpu_thread;
3941
env->halt_cond = tcg_halt_cond;
3942
}
3943
}
3944
3945
static void kvm_start_vcpu(CPUState *env)
3946
{
3947
kvm_init_vcpu(env);
3948
env->thread = qemu_mallocz(sizeof(QemuThread));
3949
env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3950
qemu_cond_init(env->halt_cond);
3951
qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
3952
while (env->created == 0)
3953
qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3954
}
3955
3956
void qemu_init_vcpu(void *_env)
3957
{
3958
CPUState *env = _env;
3959
3960
if (kvm_enabled())
3961
kvm_start_vcpu(env);
3962
else
3963
tcg_init_vcpu(env);
3964
env->nr_cores = smp_cores;
3965
env->nr_threads = smp_threads;
3966
}
3967
3968
void qemu_notify_event(void)
3969
{
3970
qemu_event_increment();
3971
}
3972
3973
void vm_stop(int reason)
3974
{
3975
QemuThread me;
3976
qemu_thread_self(&me);
3977
3978
if (!qemu_thread_equal(&me, &io_thread)) {
3979
qemu_system_vmstop_request(reason);
3980
/*
3981
* FIXME: should not return to device code in case
3982
* vm_stop() has been requested.
3983
*/
3984
if (cpu_single_env) {
3985
cpu_exit(cpu_single_env);
3986
cpu_single_env->stop = 1;
3987
}
3988
return;
3989
}
3990
do_vm_stop(reason);
3991
}
3992
3993
#endif
3994
3995
6921
3996
#ifdef _WIN32
6922
int ret2, i;
6923
#endif
6924
struct timeval tv;
3997
static void host_main_loop_wait(int *timeout)
3998
{
3999
int ret, ret2, i;
6925
4000
PollingEntry *pe;
6926
4001
6927
4002
6930
4005
for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
6931
4006
ret |= pe->func(pe->opaque);
6932
4007
}
6933
#ifdef _WIN32
6934
4008
if (ret == 0) {
6935
4009
int err;
6936
4010
WaitObjects *w = &wait_objects;
6937
4011
6938
ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
4012
ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
6939
4013
if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
6940
4014
if (w->func[ret - WAIT_OBJECT_0])
6941
4015
w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
6960
4034
fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
6961
4035
}
6962
4036
}
4037
4038
*timeout = 0;
4039
}
4040
#else
4041
static void host_main_loop_wait(int *timeout)
4042
{
4043
}
6963
4044
#endif
4045
4046
void main_loop_wait(int timeout)
4047
{
4048
IOHandlerRecord *ioh;
4049
fd_set rfds, wfds, xfds;
4050
int ret, nfds;
4051
struct timeval tv;
4052
4053
qemu_bh_update_timeout(&timeout);
4054
4055
host_main_loop_wait(&timeout);
4056
6964
4057
/* poll any events */
6965
4058
/* XXX: separate device handlers from system ones */
6966
4059
nfds = -1;
6984
4077
}
6985
4078
}
6986
4079
6987
tv.tv_sec = 0;
6988
#ifdef _WIN32
6989
tv.tv_usec = 0;
6990
#else
6991
tv.tv_usec = timeout * 1000;
6992
#endif
6993
#if defined(CONFIG_SLIRP)
6994
if (slirp_inited) {
6995
slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
6996
}
6997
#endif
4080
tv.tv_sec = timeout / 1000;
4081
tv.tv_usec = (timeout % 1000) * 1000;
4082
4083
slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4084
4085
qemu_mutex_unlock_iothread();
6998
4086
ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4087
qemu_mutex_lock_iothread();
6999
4088
if (ret > 0) {
7000
4089
IOHandlerRecord **pioh;
7001
4090
7019
4108
pioh = &ioh->next;
7020
4109
}
7021
4110
}
7022
#if defined(CONFIG_SLIRP)
7023
if (slirp_inited) {
7024
if (ret < 0) {
7025
FD_ZERO(&rfds);
7026
FD_ZERO(&wfds);
7027
FD_ZERO(&xfds);
7028
}
7029
slirp_select_poll(&rfds, &wfds, &xfds);
4111
4112
slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
4113
4114
/* rearm timer, if not periodic */
4115
if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
4116
alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
4117
qemu_rearm_alarm_timer(alarm_timer);
7030
4118
}
7031
#endif
7032
qemu_aio_poll();
7033
4119
4120
/* vm time timers */
7034
4121
if (vm_running) {
7035
if (likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
7036
qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
7037
qemu_get_clock(vm_clock));
7038
/* run dma transfers, if any */
7039
DMA_run();
4122
if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
4123
qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4124
qemu_get_clock(vm_clock));
7040
4125
}
7041
4126
7042
4127
/* real time timers */
7043
4128
qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
7044
4129
qemu_get_clock(rt_clock));
7045
4130
7046
if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7047
alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7048
qemu_rearm_alarm_timer(alarm_timer);
7049
}
7050
7051
4131
/* Check bottom-halves last in case any of the earlier events triggered
7052
4132
them. */
7053
4133
qemu_bh_poll();
7054
4134
7055
4135
}
7056
4136
7057
static int main_loop(void)
4137
static int qemu_cpu_exec(CPUState *env)
7058
4138
{
7059
int ret, timeout;
4139
int ret;
7060
4140
#ifdef CONFIG_PROFILER
7061
4141
int64_t ti;
7062
4142
#endif
4143
4144
#ifdef CONFIG_PROFILER
4145
ti = profile_getclock();
4146
#endif
4147
if (use_icount) {
4148
int64_t count;
4149
int decr;
4150
qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
4151
env->icount_decr.u16.low = 0;
4152
env->icount_extra = 0;
4153
count = qemu_next_deadline();
4154
count = (count + (1 << icount_time_shift) - 1)
4155
>> icount_time_shift;
4156
qemu_icount += count;
4157
decr = (count > 0xffff) ? 0xffff : count;
4158
count -= decr;
4159
env->icount_decr.u16.low = decr;
4160
env->icount_extra = count;
4161
}
4162
ret = cpu_exec(env);
4163
#ifdef CONFIG_PROFILER
4164
qemu_time += profile_getclock() - ti;
4165
#endif
4166
if (use_icount) {
4167
/* Fold pending instructions back into the
4168
instruction counter, and clear the interrupt flag. */
4169
qemu_icount -= (env->icount_decr.u16.low
4170
+ env->icount_extra);
4171
env->icount_decr.u32 = 0;
4172
env->icount_extra = 0;
4173
}
4174
return ret;
4175
}
4176
4177
static void tcg_cpu_exec(void)
4178
{
4179
int ret = 0;
4180
4181
if (next_cpu == NULL)
4182
next_cpu = first_cpu;
4183
for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
4184
CPUState *env = cur_cpu = next_cpu;
4185
4186
if (!vm_running)
4187
break;
4188
if (timer_alarm_pending) {
4189
timer_alarm_pending = 0;
4190
break;
4191
}
4192
if (cpu_can_run(env))
4193
ret = qemu_cpu_exec(env);
4194
if (ret == EXCP_DEBUG) {
4195
gdb_set_stop_cpu(env);
4196
debug_requested = 1;
4197
break;
4198
}
4199
}
4200
}
4201
4202
static int cpu_has_work(CPUState *env)
4203
{
4204
if (env->stop)
4205
return 1;
4206
if (env->stopped)
4207
return 0;
4208
if (!env->halted)
4209
return 1;
4210
if (qemu_cpu_has_work(env))
4211
return 1;
4212
return 0;
4213
}
4214
4215
static int tcg_has_work(void)
4216
{
7063
4217
CPUState *env;
7064
4218
7065
cur_cpu = first_cpu;
7066
next_cpu = cur_cpu->next_cpu ?: first_cpu;
7067
for(;;) {
7068
if (vm_running) {
7069
7070
for(;;) {
7071
/* get next cpu */
7072
env = next_cpu;
7073
#ifdef CONFIG_PROFILER
7074
ti = profile_getclock();
7075
#endif
7076
ret = cpu_exec(env);
7077
#ifdef CONFIG_PROFILER
7078
qemu_time += profile_getclock() - ti;
7079
#endif
7080
next_cpu = env->next_cpu ?: first_cpu;
7081
if (event_pending && likely(ret != EXCP_DEBUG)) {
7082
ret = EXCP_INTERRUPT;
7083
event_pending = 0;
7084
break;
7085
}
7086
if (ret == EXCP_HLT) {
7087
/* Give the next CPU a chance to run. */
7088
cur_cpu = env;
7089
continue;
7090
}
7091
if (ret != EXCP_HALTED)
7092
break;
7093
/* all CPUs are halted ? */
7094
if (env == cur_cpu)
7095
break;
7096
}
7097
cur_cpu = env;
7098
7099
if (shutdown_requested) {
7100
ret = EXCP_INTERRUPT;
7101
if (no_shutdown) {
7102
vm_stop(0);
7103
no_shutdown = 0;
7104
}
7105
else
7106
break;
7107
}
7108
if (reset_requested) {
7109
reset_requested = 0;
7110
qemu_system_reset();
7111
ret = EXCP_INTERRUPT;
7112
}
7113
if (powerdown_requested) {
7114
powerdown_requested = 0;
7115
qemu_system_powerdown();
7116
ret = EXCP_INTERRUPT;
7117
}
7118
if (unlikely(ret == EXCP_DEBUG)) {
7119
vm_stop(EXCP_DEBUG);
7120
}
7121
/* If all cpus are halted then wait until the next IRQ */
7122
/* XXX: use timeout computed from timers */
7123
if (ret == EXCP_HALTED)
7124
timeout = 10;
7125
else
4219
for (env = first_cpu; env != NULL; env = env->next_cpu)
4220
if (cpu_has_work(env))
4221
return 1;
4222
return 0;
4223
}
4224
4225
static int qemu_calculate_timeout(void)
4226
{
4227
#ifndef CONFIG_IOTHREAD
4228
int timeout;
4229
4230
if (!vm_running)
4231
timeout = 5000;
4232
else if (tcg_has_work())
4233
timeout = 0;
4234
else if (!use_icount)
4235
timeout = 5000;
4236
else {
4237
/* XXX: use timeout computed from timers */
4238
int64_t add;
4239
int64_t delta;
4240
/* Advance virtual time to the next event. */
4241
if (use_icount == 1) {
4242
/* When not using an adaptive execution frequency
4243
we tend to get badly out of sync with real time,
4244
so just delay for a reasonable amount of time. */
4245
delta = 0;
4246
} else {
4247
delta = cpu_get_icount() - cpu_get_clock();
4248
}
4249
if (delta > 0) {
4250
/* If virtual time is ahead of real time then just
4251
wait for IO. */
4252
timeout = (delta / 1000000) + 1;
4253
} else {
4254
/* Wait for either IO to occur or the next
4255
timer event. */
4256
add = qemu_next_deadline();
4257
/* We advance the timer before checking for IO.
4258
Limit the amount we advance so that early IO
4259
activity won't get the guest too far ahead. */
4260
if (add > 10000000)
4261
add = 10000000;
4262
delta += add;
4263
add = (add + (1 << icount_time_shift) - 1)
4264
>> icount_time_shift;
4265
qemu_icount += add;
4266
timeout = delta / 1000000;
4267
if (timeout < 0)
7126
4268
timeout = 0;
7127
} else {
7128
timeout = 10;
7129
}
7130
#ifdef CONFIG_PROFILER
7131
ti = profile_getclock();
7132
#endif
7133
main_loop_wait(timeout);
7134
#ifdef CONFIG_PROFILER
7135
dev_time += profile_getclock() - ti;
7136
#endif
7137
}
7138
cpu_disable_ticks();
7139
return ret;
4269
}
4270
}
4271
4272
return timeout;
4273
#else /* CONFIG_IOTHREAD */
4274
return 1000;
4275
#endif
4276
}
4277
4278
static int vm_can_run(void)
4279
{
4280
if (powerdown_requested)
4281
return 0;
4282
if (reset_requested)
4283
return 0;
4284
if (shutdown_requested)
4285
return 0;
4286
if (debug_requested)
4287
return 0;
4288
return 1;
4289
}
4290
4291
qemu_irq qemu_system_powerdown;
4292
4293
static void main_loop(void)
4294
{
4295
int r;
4296
4297
#ifdef CONFIG_IOTHREAD
4298
qemu_system_ready = 1;
4299
qemu_cond_broadcast(&qemu_system_cond);
4300
#endif
4301
4302
for (;;) {
4303
do {
4304
#ifdef CONFIG_PROFILER
4305
int64_t ti;
4306
#endif
4307
#ifndef CONFIG_IOTHREAD
4308
tcg_cpu_exec();
4309
#endif
4310
#ifdef CONFIG_PROFILER
4311
ti = profile_getclock();
4312
#endif
4313
main_loop_wait(qemu_calculate_timeout());
4314
#ifdef CONFIG_PROFILER
4315
dev_time += profile_getclock() - ti;
4316
#endif
4317
} while (vm_can_run());
4318
4319
if (qemu_debug_requested())
4320
vm_stop(EXCP_DEBUG);
4321
if (qemu_shutdown_requested()) {
4322
if (no_shutdown) {
4323
vm_stop(0);
4324
no_shutdown = 0;
4325
} else
4326
break;
4327
}
4328
if (qemu_reset_requested()) {
4329
pause_all_vcpus();
4330
qemu_system_reset();
4331
resume_all_vcpus();
4332
}
4333
if (qemu_powerdown_requested()) {
4334
qemu_irq_raise(qemu_system_powerdown);
4335
}
4336
if ((r = qemu_vmstop_requested()))
4337
vm_stop(r);
4338
}
4339
pause_all_vcpus();
4340
}
4341
4342
static void version(void)
4343
{
4344
printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
7140
4345
}
7141
4346
7142
4347
static void help(int exitcode)
7143
4348
{
7144
printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
7145
"usage: %s [options] [disk_image]\n"
4349
version();
4350
printf("usage: %s [options] [disk_image]\n"
7146
4351
"\n"
7147
4352
"'disk_image' is a raw hard image image for IDE hard disk 0\n"
7148
4353
"\n"
7149
"Standard options:\n"
7150
"-M machine select emulated machine (-M ? for list)\n"
7151
"-cpu cpu select CPU (-cpu ? for list)\n"
7152
"-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7153
"-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7154
"-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7155
"-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7156
"-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7157
" [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7158
" [,cache=on|off][,format=f]\n"
7159
" use 'file' as a drive image\n"
7160
"-mtdblock file use 'file' as on-board Flash memory image\n"
7161
"-sd file use 'file' as SecureDigital card image\n"
7162
"-pflash file use 'file' as a parallel flash image\n"
7163
"-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7164
"-snapshot write to temporary files instead of disk image files\n"
7165
#ifdef CONFIG_SDL
7166
"-no-frame open SDL window without a frame and window decorations\n"
7167
"-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7168
"-no-quit disable SDL window close capability\n"
7169
#endif
7170
#ifdef TARGET_I386
7171
"-no-fd-bootchk disable boot signature checking for floppy disks\n"
7172
#endif
7173
"-m megs set virtual RAM size to megs MB [default=%d]\n"
7174
"-smp n set the number of CPUs to 'n' [default=1]\n"
7175
"-nographic disable graphical output and redirect serial I/Os to console\n"
7176
"-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7177
#ifndef _WIN32
7178
"-k language use keyboard layout (for example \"fr\" for French)\n"
7179
#endif
7180
#ifdef HAS_AUDIO
7181
"-audio-help print list of audio drivers and their options\n"
7182
"-soundhw c1,... enable audio support\n"
7183
" and only specified sound cards (comma separated list)\n"
7184
" use -soundhw ? to get the list of supported cards\n"
7185
" use -soundhw all to enable all of them\n"
7186
#endif
7187
"-localtime set the real time clock to local time [default=utc]\n"
7188
"-full-screen start in full screen\n"
7189
#ifdef TARGET_I386
7190
"-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7191
#endif
7192
"-usb enable the USB driver (will be the default soon)\n"
7193
"-usbdevice name add the host or guest USB device 'name'\n"
7194
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7195
"-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7196
#endif
7197
"-name string set the name of the guest\n"
7198
"\n"
7199
"Network options:\n"
7200
"-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7201
" create a new Network Interface Card and connect it to VLAN 'n'\n"
7202
#ifdef CONFIG_SLIRP
7203
"-net user[,vlan=n][,hostname=host]\n"
7204
" connect the user mode network stack to VLAN 'n' and send\n"
7205
" hostname 'host' to DHCP clients\n"
7206
#endif
7207
#ifdef _WIN32
7208
"-net tap[,vlan=n],ifname=name\n"
7209
" connect the host TAP network interface to VLAN 'n'\n"
7210
#else
7211
"-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7212
" connect the host TAP network interface to VLAN 'n' and use the\n"
7213
" network scripts 'file' (default=%s)\n"
7214
" and 'dfile' (default=%s);\n"
7215
" use '[down]script=no' to disable script execution;\n"
7216
" use 'fd=h' to connect to an already opened TAP interface\n"
7217
#endif
7218
"-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7219
" connect the vlan 'n' to another VLAN using a socket connection\n"
7220
"-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7221
" connect the vlan 'n' to multicast maddr and port\n"
7222
"-net none use it alone to have zero network devices; if no -net option\n"
7223
" is provided, the default is '-net nic -net user'\n"
7224
"\n"
7225
#ifdef CONFIG_SLIRP
7226
"-tftp dir allow tftp access to files in dir [-net user]\n"
7227
"-bootp file advertise file in BOOTP replies\n"
7228
#ifndef _WIN32
7229
"-smb dir allow SMB access to files in 'dir' [-net user]\n"
7230
#endif
7231
"-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7232
" redirect TCP or UDP connections from host to guest [-net user]\n"
7233
#endif
7234
"\n"
7235
"Linux boot specific:\n"
7236
"-kernel bzImage use 'bzImage' as kernel image\n"
7237
"-append cmdline use 'cmdline' as kernel command line\n"
7238
"-initrd file use 'file' as initial ram disk\n"
7239
"\n"
7240
"Debug/Expert options:\n"
7241
"-monitor dev redirect the monitor to char device 'dev'\n"
7242
"-serial dev redirect the serial port to char device 'dev'\n"
7243
"-parallel dev redirect the parallel port to char device 'dev'\n"
7244
"-pidfile file Write PID to 'file'\n"
7245
"-S freeze CPU at startup (use 'c' to start execution)\n"
7246
"-s wait gdb connection to port\n"
7247
"-p port set gdb connection port [default=%s]\n"
7248
"-d item1,... output log to %s (use -d ? for a list of log items)\n"
7249
"-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7250
" translation (t=none or lba) (usually qemu can guess them)\n"
7251
"-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
7252
#ifdef USE_KQEMU
7253
"-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7254
"-no-kqemu disable KQEMU kernel module usage\n"
7255
#endif
7256
#ifdef TARGET_I386
7257
"-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
7258
" (default is CL-GD5446 PCI VGA)\n"
7259
"-no-acpi disable ACPI\n"
7260
#endif
7261
#ifdef CONFIG_CURSES
7262
"-curses use a curses/ncurses interface instead of SDL\n"
7263
#endif
7264
"-no-reboot exit instead of rebooting\n"
7265
"-no-shutdown stop before shutdown\n"
7266
"-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
7267
"-vnc display start a VNC server on display\n"
7268
#ifndef _WIN32
7269
"-daemonize daemonize QEMU after initializing\n"
7270
#endif
7271
"-option-rom rom load a file, rom, into the option ROM space\n"
7272
#ifdef TARGET_SPARC
7273
"-prom-env variable=value set OpenBIOS nvram variables\n"
7274
#endif
7275
"-clock force the use of the given methods for timer alarm.\n"
7276
" To see what timers are available use -clock ?\n"
7277
"-startdate select initial date of the clock\n"
4354
#define DEF(option, opt_arg, opt_enum, opt_help) \
4355
opt_help
4356
#define DEFHEADING(text) stringify(text) "\n"
4357
#include "qemu-options.h"
4358
#undef DEF
4359
#undef DEFHEADING
4360
#undef GEN_DOCS
7278
4361
"\n"
7279
4362
"During emulation, the following keys are useful:\n"
7280
4363
"ctrl-alt-f toggle full screen\n"
7297
4380
#define HAS_ARG 0x0001
7298
4381
7299
4382
enum {
7300
QEMU_OPTION_h,
7301
7302
QEMU_OPTION_M,
7303
QEMU_OPTION_cpu,
7304
QEMU_OPTION_fda,
7305
QEMU_OPTION_fdb,
7306
QEMU_OPTION_hda,
7307
QEMU_OPTION_hdb,
7308
QEMU_OPTION_hdc,
7309
QEMU_OPTION_hdd,
7310
QEMU_OPTION_drive,
7311
QEMU_OPTION_cdrom,
7312
QEMU_OPTION_mtdblock,
7313
QEMU_OPTION_sd,
7314
QEMU_OPTION_pflash,
7315
QEMU_OPTION_boot,
7316
QEMU_OPTION_snapshot,
7317
#ifdef TARGET_I386
7318
QEMU_OPTION_no_fd_bootchk,
7319
#endif
7320
QEMU_OPTION_m,
7321
QEMU_OPTION_nographic,
7322
QEMU_OPTION_portrait,
7323
#ifdef HAS_AUDIO
7324
QEMU_OPTION_audio_help,
7325
QEMU_OPTION_soundhw,
7326
#endif
7327
7328
QEMU_OPTION_net,
7329
QEMU_OPTION_tftp,
7330
QEMU_OPTION_bootp,
7331
QEMU_OPTION_smb,
7332
QEMU_OPTION_redir,
7333
7334
QEMU_OPTION_kernel,
7335
QEMU_OPTION_append,
7336
QEMU_OPTION_initrd,
7337
7338
QEMU_OPTION_S,
7339
QEMU_OPTION_s,
7340
QEMU_OPTION_p,
7341
QEMU_OPTION_d,
7342
QEMU_OPTION_hdachs,
7343
QEMU_OPTION_L,
7344
QEMU_OPTION_bios,
7345
QEMU_OPTION_k,
7346
QEMU_OPTION_localtime,
7347
QEMU_OPTION_cirrusvga,
7348
QEMU_OPTION_vmsvga,
7349
QEMU_OPTION_g,
7350
QEMU_OPTION_std_vga,
7351
QEMU_OPTION_echr,
7352
QEMU_OPTION_monitor,
7353
QEMU_OPTION_serial,
7354
QEMU_OPTION_parallel,
7355
QEMU_OPTION_loadvm,
7356
QEMU_OPTION_full_screen,
7357
QEMU_OPTION_no_frame,
7358
QEMU_OPTION_alt_grab,
7359
QEMU_OPTION_no_quit,
7360
QEMU_OPTION_pidfile,
7361
QEMU_OPTION_no_kqemu,
7362
QEMU_OPTION_kernel_kqemu,
7363
QEMU_OPTION_win2k_hack,
7364
QEMU_OPTION_usb,
7365
QEMU_OPTION_usbdevice,
7366
QEMU_OPTION_smp,
7367
QEMU_OPTION_vnc,
7368
QEMU_OPTION_no_acpi,
7369
QEMU_OPTION_curses,
7370
QEMU_OPTION_no_reboot,
7371
QEMU_OPTION_no_shutdown,
7372
QEMU_OPTION_show_cursor,
7373
QEMU_OPTION_daemonize,
7374
QEMU_OPTION_option_rom,
7375
QEMU_OPTION_semihosting,
7376
QEMU_OPTION_name,
7377
QEMU_OPTION_prom_env,
7378
QEMU_OPTION_old_param,
7379
QEMU_OPTION_clock,
7380
QEMU_OPTION_startdate,
7381
QEMU_OPTION_tb_size,
4383
#define DEF(option, opt_arg, opt_enum, opt_help) \
4384
opt_enum,
4385
#define DEFHEADING(text)
4386
#include "qemu-options.h"
4387
#undef DEF
4388
#undef DEFHEADING
4389
#undef GEN_DOCS
7382
4390
};
7383
4391
7384
4392
typedef struct QEMUOption {
7387
4395
int index;
7388
4396
} QEMUOption;
7389
4397
7390
const QEMUOption qemu_options[] = {
4398
static const QEMUOption qemu_options[] = {
7391
4399
{ "h", 0, QEMU_OPTION_h },
7392
{ "help", 0, QEMU_OPTION_h },
7393
7394
{ "M", HAS_ARG, QEMU_OPTION_M },
7395
{ "cpu", HAS_ARG, QEMU_OPTION_cpu },
7396
{ "fda", HAS_ARG, QEMU_OPTION_fda },
7397
{ "fdb", HAS_ARG, QEMU_OPTION_fdb },
7398
{ "hda", HAS_ARG, QEMU_OPTION_hda },
7399
{ "hdb", HAS_ARG, QEMU_OPTION_hdb },
7400
{ "hdc", HAS_ARG, QEMU_OPTION_hdc },
7401
{ "hdd", HAS_ARG, QEMU_OPTION_hdd },
7402
{ "drive", HAS_ARG, QEMU_OPTION_drive },
7403
{ "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
7404
{ "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
7405
{ "sd", HAS_ARG, QEMU_OPTION_sd },
7406
{ "pflash", HAS_ARG, QEMU_OPTION_pflash },
7407
{ "boot", HAS_ARG, QEMU_OPTION_boot },
7408
{ "snapshot", 0, QEMU_OPTION_snapshot },
7409
#ifdef TARGET_I386
7410
{ "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
7411
#endif
7412
{ "m", HAS_ARG, QEMU_OPTION_m },
7413
{ "nographic", 0, QEMU_OPTION_nographic },
7414
{ "portrait", 0, QEMU_OPTION_portrait },
7415
{ "k", HAS_ARG, QEMU_OPTION_k },
7416
#ifdef HAS_AUDIO
7417
{ "audio-help", 0, QEMU_OPTION_audio_help },
7418
{ "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
7419
#endif
7420
7421
{ "net", HAS_ARG, QEMU_OPTION_net},
7422
#ifdef CONFIG_SLIRP
7423
{ "tftp", HAS_ARG, QEMU_OPTION_tftp },
7424
{ "bootp", HAS_ARG, QEMU_OPTION_bootp },
7425
#ifndef _WIN32
7426
{ "smb", HAS_ARG, QEMU_OPTION_smb },
7427
#endif
7428
{ "redir", HAS_ARG, QEMU_OPTION_redir },
7429
#endif
7430
7431
{ "kernel", HAS_ARG, QEMU_OPTION_kernel },
7432
{ "append", HAS_ARG, QEMU_OPTION_append },
7433
{ "initrd", HAS_ARG, QEMU_OPTION_initrd },
7434
7435
{ "S", 0, QEMU_OPTION_S },
7436
{ "s", 0, QEMU_OPTION_s },
7437
{ "p", HAS_ARG, QEMU_OPTION_p },
7438
{ "d", HAS_ARG, QEMU_OPTION_d },
7439
{ "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
7440
{ "L", HAS_ARG, QEMU_OPTION_L },
7441
{ "bios", HAS_ARG, QEMU_OPTION_bios },
7442
#ifdef USE_KQEMU
7443
{ "no-kqemu", 0, QEMU_OPTION_no_kqemu },
7444
{ "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
7445
#endif
7446
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7447
{ "g", 1, QEMU_OPTION_g },
7448
#endif
7449
{ "localtime", 0, QEMU_OPTION_localtime },
7450
{ "std-vga", 0, QEMU_OPTION_std_vga },
7451
{ "echr", HAS_ARG, QEMU_OPTION_echr },
7452
{ "monitor", HAS_ARG, QEMU_OPTION_monitor },
7453
{ "serial", HAS_ARG, QEMU_OPTION_serial },
7454
{ "parallel", HAS_ARG, QEMU_OPTION_parallel },
7455
{ "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
7456
{ "full-screen", 0, QEMU_OPTION_full_screen },
7457
#ifdef CONFIG_SDL
7458
{ "no-frame", 0, QEMU_OPTION_no_frame },
7459
{ "alt-grab", 0, QEMU_OPTION_alt_grab },
7460
{ "no-quit", 0, QEMU_OPTION_no_quit },
7461
#endif
7462
{ "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
7463
{ "win2k-hack", 0, QEMU_OPTION_win2k_hack },
7464
{ "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
7465
{ "smp", HAS_ARG, QEMU_OPTION_smp },
7466
{ "vnc", HAS_ARG, QEMU_OPTION_vnc },
7467
#ifdef CONFIG_CURSES
7468
{ "curses", 0, QEMU_OPTION_curses },
7469
#endif
7470
7471
/* temporary options */
7472
{ "usb", 0, QEMU_OPTION_usb },
7473
{ "cirrusvga", 0, QEMU_OPTION_cirrusvga },
7474
{ "vmwarevga", 0, QEMU_OPTION_vmsvga },
7475
{ "no-acpi", 0, QEMU_OPTION_no_acpi },
7476
{ "no-reboot", 0, QEMU_OPTION_no_reboot },
7477
{ "no-shutdown", 0, QEMU_OPTION_no_shutdown },
7478
{ "show-cursor", 0, QEMU_OPTION_show_cursor },
7479
{ "daemonize", 0, QEMU_OPTION_daemonize },
7480
{ "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
7481
#if defined(TARGET_ARM) || defined(TARGET_M68K)
7482
{ "semihosting", 0, QEMU_OPTION_semihosting },
7483
#endif
7484
{ "name", HAS_ARG, QEMU_OPTION_name },
7485
#if defined(TARGET_SPARC)
7486
{ "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
7487
#endif
7488
#if defined(TARGET_ARM)
7489
{ "old-param", 0, QEMU_OPTION_old_param },
7490
#endif
7491
{ "clock", HAS_ARG, QEMU_OPTION_clock },
7492
{ "startdate", HAS_ARG, QEMU_OPTION_startdate },
7493
{ "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
4400
#define DEF(option, opt_arg, opt_enum, opt_help) \
4401
{ option, opt_arg, opt_enum },
4402
#define DEFHEADING(text)
4403
#include "qemu-options.h"
4404
#undef DEF
4405
#undef DEFHEADING
4406
#undef GEN_DOCS
7494
4407
{ NULL },
7495
4408
};
7496
4409
7497
/* password input */
7498
7499
int qemu_key_check(BlockDriverState *bs, const char *name)
7500
{
7501
char password[256];
7502
int i;
7503
7504
if (!bdrv_is_encrypted(bs))
7505
return 0;
7506
7507
term_printf("%s is encrypted.\n", name);
7508
for(i = 0; i < 3; i++) {
7509
monitor_readline("Password: ", 1, password, sizeof(password));
7510
if (bdrv_set_key(bs, password) == 0)
7511
return 0;
7512
term_printf("invalid password\n");
7513
}
7514
return -EPERM;
7515
}
7516
7517
static BlockDriverState *get_bdrv(int index)
7518
{
7519
if (index > nb_drives)
7520
return NULL;
7521
return drives_table[index].bdrv;
7522
}
7523
7524
static void read_passwords(void)
7525
{
7526
BlockDriverState *bs;
7527
int i;
7528
7529
for(i = 0; i < 6; i++) {
7530
bs = get_bdrv(i);
7531
if (bs)
7532
qemu_key_check(bs, bdrv_get_device_name(bs));
7533
}
7534
}
7535
7536
4410
#ifdef HAS_AUDIO
7537
4411
struct soundhw soundhw[] = {
7538
4412
#ifdef HAS_AUDIO_CHOICE
7545
4419
{ .init_isa = pcspk_audio_init }
7546
4420
},
7547
4421
#endif
4422
4423
#ifdef CONFIG_SB16
7548
4424
{
7549
4425
"sb16",
7550
4426
"Creative Sound Blaster 16",
7552
4428
1,
7553
4429
{ .init_isa = SB16_init }
7554
4430
},
4431
#endif
4432
4433
#ifdef CONFIG_CS4231A
4434
{
4435
"cs4231a",
4436
"CS4231A",
4437
0,
4438
1,
4439
{ .init_isa = cs4231a_init }
4440
},
4441
#endif
7555
4442
7556
4443
#ifdef CONFIG_ADLIB
7557
4444
{
7587
4474
},
7588
4475
#endif
7589
4476
4477
#ifdef CONFIG_ES1370
7590
4478
{
7591
4479
"es1370",
7592
4480
"ENSONIQ AudioPCI ES1370",
7596
4484
},
7597
4485
#endif
7598
4486
4487
#endif /* HAS_AUDIO_CHOICE */
4488
7599
4489
{ NULL, NULL, 0, 0, { NULL } }
7600
4490
};
7601
4491
7658
4548
}
7659
4549
#endif
7660
4550
4551
static void select_vgahw (const char *p)
4552
{
4553
const char *opts;
4554
4555
vga_interface_type = VGA_NONE;
4556
if (strstart(p, "std", &opts)) {
4557
vga_interface_type = VGA_STD;
4558
} else if (strstart(p, "cirrus", &opts)) {
4559
vga_interface_type = VGA_CIRRUS;
4560
} else if (strstart(p, "vmware", &opts)) {
4561
vga_interface_type = VGA_VMWARE;
4562
} else if (strstart(p, "xenfb", &opts)) {
4563
vga_interface_type = VGA_XENFB;
4564
} else if (!strstart(p, "none", &opts)) {
4565
invalid_vga:
4566
fprintf(stderr, "Unknown vga type: %s\n", p);
4567
exit(1);
4568
}
4569
while (*opts) {
4570
const char *nextopt;
4571
4572
if (strstart(opts, ",retrace=", &nextopt)) {
4573
opts = nextopt;
4574
if (strstart(opts, "dumb", &nextopt))
4575
vga_retrace_method = VGA_RETRACE_DUMB;
4576
else if (strstart(opts, "precise", &nextopt))
4577
vga_retrace_method = VGA_RETRACE_PRECISE;
4578
else goto invalid_vga;
4579
} else goto invalid_vga;
4580
opts = nextopt;
4581
}
4582
}
4583
4584
#ifdef TARGET_I386
4585
static int balloon_parse(const char *arg)
4586
{
4587
QemuOpts *opts;
4588
4589
if (strcmp(arg, "none") == 0) {
4590
return 0;
4591
}
4592
4593
if (!strncmp(arg, "virtio", 6)) {
4594
if (arg[6] == ',') {
4595
/* have params -> parse them */
4596
opts = qemu_opts_parse(&qemu_device_opts, arg+7, NULL);
4597
if (!opts)
4598
return -1;
4599
} else {
4600
/* create empty opts */
4601
opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4602
}
4603
qemu_opt_set(opts, "driver", "virtio-balloon-pci");
4604
return 0;
4605
}
4606
4607
return -1;
4608
}
4609
#endif
4610
7661
4611
#ifdef _WIN32
7662
4612
static BOOL WINAPI qemu_ctrl_handler(DWORD type)
7663
4613
{
7666
4616
}
7667
4617
#endif
7668
4618
4619
int qemu_uuid_parse(const char *str, uint8_t *uuid)
4620
{
4621
int ret;
4622
4623
if(strlen(str) != 36)
4624
return -1;
4625
4626
ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4627
&uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4628
&uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4629
4630
if(ret != 16)
4631
return -1;
4632
4633
#ifdef TARGET_I386
4634
smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4635
#endif
4636
4637
return 0;
4638
}
4639
7669
4640
#define MAX_NET_CLIENTS 32
7670
4641
7671
int main(int argc, char **argv)
7672
{
7673
#ifdef CONFIG_GDBSTUB
7674
int use_gdbstub;
7675
const char *gdbstub_port;
7676
#endif
4642
#ifndef _WIN32
4643
4644
static void termsig_handler(int signal)
4645
{
4646
qemu_system_shutdown_request();
4647
}
4648
4649
static void sigchld_handler(int signal)
4650
{
4651
waitpid(-1, NULL, WNOHANG);
4652
}
4653
4654
static void sighandler_setup(void)
4655
{
4656
struct sigaction act;
4657
4658
memset(&act, 0, sizeof(act));
4659
act.sa_handler = termsig_handler;
4660
sigaction(SIGINT, &act, NULL);
4661
sigaction(SIGHUP, &act, NULL);
4662
sigaction(SIGTERM, &act, NULL);
4663
4664
act.sa_handler = sigchld_handler;
4665
act.sa_flags = SA_NOCLDSTOP;
4666
sigaction(SIGCHLD, &act, NULL);
4667
}
4668
4669
#endif
4670
4671
#ifdef _WIN32
4672
/* Look for support files in the same directory as the executable. */
4673
static char *find_datadir(const char *argv0)
4674
{
4675
char *p;
4676
char buf[MAX_PATH];
4677
DWORD len;
4678
4679
len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4680
if (len == 0) {
4681
return NULL;
4682
}
4683
4684
buf[len] = 0;
4685
p = buf + len - 1;
4686
while (p != buf && *p != '\\')
4687
p--;
4688
*p = 0;
4689
if (access(buf, R_OK) == 0) {
4690
return qemu_strdup(buf);
4691
}
4692
return NULL;
4693
}
4694
#else /* !_WIN32 */
4695
4696
/* Find a likely location for support files using the location of the binary.
4697
For installed binaries this will be "$bindir/../share/qemu". When
4698
running from the build tree this will be "$bindir/../pc-bios". */
4699
#define SHARE_SUFFIX "/share/qemu"
4700
#define BUILD_SUFFIX "/pc-bios"
4701
static char *find_datadir(const char *argv0)
4702
{
4703
char *dir;
4704
char *p = NULL;
4705
char *res;
4706
#ifdef PATH_MAX
4707
char buf[PATH_MAX];
4708
#endif
4709
size_t max_len;
4710
4711
#if defined(__linux__)
4712
{
4713
int len;
4714
len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4715
if (len > 0) {
4716
buf[len] = 0;
4717
p = buf;
4718
}
4719
}
4720
#elif defined(__FreeBSD__)
4721
{
4722
int len;
4723
len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4724
if (len > 0) {
4725
buf[len] = 0;
4726
p = buf;
4727
}
4728
}
4729
#endif
4730
/* If we don't have any way of figuring out the actual executable
4731
location then try argv[0]. */
4732
if (!p) {
4733
#ifdef PATH_MAX
4734
p = buf;
4735
#endif
4736
p = realpath(argv0, p);
4737
if (!p) {
4738
return NULL;
4739
}
4740
}
4741
dir = dirname(p);
4742
dir = dirname(dir);
4743
4744
max_len = strlen(dir) +
4745
MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4746
res = qemu_mallocz(max_len);
4747
snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4748
if (access(res, R_OK)) {
4749
snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4750
if (access(res, R_OK)) {
4751
qemu_free(res);
4752
res = NULL;
4753
}
4754
}
4755
#ifndef PATH_MAX
4756
free(p);
4757
#endif
4758
return res;
4759
}
4760
#undef SHARE_SUFFIX
4761
#undef BUILD_SUFFIX
4762
#endif
4763
4764
char *qemu_find_file(int type, const char *name)
4765
{
4766
int len;
4767
const char *subdir;
4768
char *buf;
4769
4770
/* If name contains path separators then try it as a straight path. */
4771
if ((strchr(name, '/') || strchr(name, '\\'))
4772
&& access(name, R_OK) == 0) {
4773
return strdup(name);
4774
}
4775
switch (type) {
4776
case QEMU_FILE_TYPE_BIOS:
4777
subdir = "";
4778
break;
4779
case QEMU_FILE_TYPE_KEYMAP:
4780
subdir = "keymaps/";
4781
break;
4782
default:
4783
abort();
4784
}
4785
len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4786
buf = qemu_mallocz(len);
4787
snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4788
if (access(buf, R_OK)) {
4789
qemu_free(buf);
4790
return NULL;
4791
}
4792
return buf;
4793
}
4794
4795
static int device_init_func(QemuOpts *opts, void *opaque)
4796
{
4797
DeviceState *dev;
4798
4799
dev = qdev_device_add(opts);
4800
if (!dev)
4801
return -1;
4802
return 0;
4803
}
4804
4805
struct device_config {
4806
enum {
4807
DEV_USB, /* -usbdevice */
4808
DEV_BT, /* -bt */
4809
} type;
4810
const char *cmdline;
4811
TAILQ_ENTRY(device_config) next;
4812
};
4813
TAILQ_HEAD(, device_config) device_configs = TAILQ_HEAD_INITIALIZER(device_configs);
4814
4815
static void add_device_config(int type, const char *cmdline)
4816
{
4817
struct device_config *conf;
4818
4819
conf = qemu_mallocz(sizeof(*conf));
4820
conf->type = type;
4821
conf->cmdline = cmdline;
4822
TAILQ_INSERT_TAIL(&device_configs, conf, next);
4823
}
4824
4825
static int foreach_device_config(int type, int (*func)(const char *cmdline))
4826
{
4827
struct device_config *conf;
4828
int rc;
4829
4830
TAILQ_FOREACH(conf, &device_configs, next) {
4831
if (conf->type != type)
4832
continue;
4833
rc = func(conf->cmdline);
4834
if (0 != rc)
4835
return rc;
4836
}
4837
return 0;
4838
}
4839
4840
int main(int argc, char **argv, char **envp)
4841
{
4842
const char *gdbstub_dev = NULL;
7677
4843
uint32_t boot_devices_bitmap = 0;
7678
4844
int i;
7679
4845
int snapshot, linux_boot, net_boot;
7680
4846
const char *initrd_filename;
7681
4847
const char *kernel_filename, *kernel_cmdline;
7682
const char *boot_devices = "";
7683
DisplayState *ds = &display_state;
4848
char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4849
DisplayState *ds;
4850
DisplayChangeListener *dcl;
7684
4851
int cyls, heads, secs, translation;
7685
4852
const char *net_clients[MAX_NET_CLIENTS];
7686
4853
int nb_net_clients;
7687
int hda_index;
4854
QemuOpts *hda_opts = NULL, *opts;
7688
4855
int optind;
7689
4856
const char *r, *optarg;
7690
CharDriverState *monitor_hd;
4857
CharDriverState *monitor_hd = NULL;
7691
4858
const char *monitor_device;
7692
4859
const char *serial_devices[MAX_SERIAL_PORTS];
7693
4860
int serial_device_index;
7694
4861
const char *parallel_devices[MAX_PARALLEL_PORTS];
7695
4862
int parallel_device_index;
4863
const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4864
int virtio_console_index;
7696
4865
const char *loadvm = NULL;
7697
4866
QEMUMachine *machine;
7698
4867
const char *cpu_model;
7699
const char *usb_devices[MAX_USB_CMDLINE];
7700
int usb_devices_index;
4868
#ifndef _WIN32
7701
4869
int fds[2];
4870
#endif
7702
4871
int tb_size;
7703
4872
const char *pid_file = NULL;
7704
VLANState *vlan;
4873
const char *incoming = NULL;
4874
#ifndef _WIN32
4875
int fd = 0;
4876
struct passwd *pwd = NULL;
4877
const char *chroot_dir = NULL;
4878
const char *run_as = NULL;
4879
#endif
4880
CPUState *env;
4881
int show_vnc_port = 0;
4882
4883
qemu_errors_to_file(stderr);
4884
qemu_cache_utils_init(envp);
7705
4885
7706
4886
LIST_INIT (&vm_change_state_head);
7707
4887
#ifndef _WIN32
7734
4914
}
7735
4915
#endif
7736
4916
7737
register_machines();
7738
machine = first_machine;
4917
module_call_init(MODULE_INIT_MACHINE);
4918
machine = find_default_machine();
7739
4919
cpu_model = NULL;
7740
4920
initrd_filename = NULL;
7741
4921
ram_size = 0;
7742
vga_ram_size = VGA_RAM_SIZE;
7743
#ifdef CONFIG_GDBSTUB
7744
use_gdbstub = 0;
7745
gdbstub_port = DEFAULT_GDBSTUB_PORT;
7746
#endif
7747
4922
snapshot = 0;
7748
nographic = 0;
7749
curses = 0;
7750
4923
kernel_filename = NULL;
7751
4924
kernel_cmdline = "";
7752
4925
cyls = heads = secs = 0;
7753
4926
translation = BIOS_ATA_TRANSLATION_AUTO;
7754
monitor_device = "vc:800x600";
4927
monitor_device = "vc:80Cx24C";
7755
4928
7756
4929
serial_devices[0] = "vc:80Cx24C";
7757
4930
for(i = 1; i < MAX_SERIAL_PORTS; i++)
7758
4931
serial_devices[i] = NULL;
7759
4932
serial_device_index = 0;
7760
4933
7761
parallel_devices[0] = "vc:640x480";
4934
parallel_devices[0] = "vc:80Cx24C";
7762
4935
for(i = 1; i < MAX_PARALLEL_PORTS; i++)
7763
4936
parallel_devices[i] = NULL;
7764
4937
parallel_device_index = 0;
7765
4938
7766
usb_devices_index = 0;
4939
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4940
virtio_consoles[i] = NULL;
4941
virtio_console_index = 0;
4942
4943
for (i = 0; i < MAX_NODES; i++) {
4944
node_mem[i] = 0;
4945
node_cpumask[i] = 0;
4946
}
7767
4947
7768
4948
nb_net_clients = 0;
7769
nb_drives = 0;
7770
nb_drives_opt = 0;
7771
hda_index = -1;
7772
4949
nb_numa_nodes = 0;
7773
4950
nb_nics = 0;
7774
4951
7775
4952
tb_size = 0;
7776
4953
autostart= 1;
4954
7777
4955
optind = 1;
7778
4956
for(;;) {
7779
4957
if (optind >= argc)
7780
4958
break;
7781
4959
r = argv[optind];
7782
4960
if (r[0] != '-') {
7783
hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4961
hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
7784
4962
} else {
7785
4963
const QEMUOption *popt;
7786
4964
7817
4995
QEMUMachine *m;
7818
4996
printf("Supported machines are:\n");
7819
4997
for(m = first_machine; m != NULL; m = m->next) {
4998
if (m->alias)
4999
printf("%-10s %s (alias of %s)\n",
5000
m->alias, m->desc, m->name);
7820
5001
printf("%-10s %s%s\n",
7821
5002
m->name, m->desc,
7822
m == first_machine ? " (default)" : "");
5003
m->is_default ? " (default)" : "");
7823
5004
}
7824
5005
exit(*optarg != '?');
7825
5006
}
7841
5022
break;
7842
5023
case QEMU_OPTION_hda:
7843
5024
if (cyls == 0)
7844
hda_index = drive_add(optarg, HD_ALIAS, 0);
5025
hda_opts = drive_add(optarg, HD_ALIAS, 0);
7845
5026
else
7846
hda_index = drive_add(optarg, HD_ALIAS
5027
hda_opts = drive_add(optarg, HD_ALIAS
7847
5028
",cyls=%d,heads=%d,secs=%d%s",
7848
5029
0, cyls, heads, secs,
7849
5030
translation == BIOS_ATA_TRANSLATION_LBA ?
7859
5040
case QEMU_OPTION_drive:
7860
5041
drive_add(NULL, "%s", optarg);
7861
5042
break;
5043
case QEMU_OPTION_set:
5044
if (qemu_set_option(optarg) != 0)
5045
exit(1);
5046
break;
7862
5047
case QEMU_OPTION_mtdblock:
7863
5048
drive_add(optarg, MTD_ALIAS);
7864
5049
break;
7905
5090
fprintf(stderr, "qemu: invalid physical CHS format\n");
7906
5091
exit(1);
7907
5092
}
7908
if (hda_index != -1)
7909
snprintf(drives_opt[hda_index].opt,
7910
sizeof(drives_opt[hda_index].opt),
7911
HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
7912
0, cyls, heads, secs,
7913
translation == BIOS_ATA_TRANSLATION_LBA ?
7914
",trans=lba" :
7915
translation == BIOS_ATA_TRANSLATION_NONE ?
7916
",trans=none" : "");
7917
}
5093
if (hda_opts != NULL) {
5094
char num[16];
5095
snprintf(num, sizeof(num), "%d", cyls);
5096
qemu_opt_set(hda_opts, "cyls", num);
5097
snprintf(num, sizeof(num), "%d", heads);
5098
qemu_opt_set(hda_opts, "heads", num);
5099
snprintf(num, sizeof(num), "%d", secs);
5100
qemu_opt_set(hda_opts, "secs", num);
5101
if (translation == BIOS_ATA_TRANSLATION_LBA)
5102
qemu_opt_set(hda_opts, "trans", "lba");
5103
if (translation == BIOS_ATA_TRANSLATION_NONE)
5104
qemu_opt_set(hda_opts, "trans", "none");
5105
}
5106
}
5107
break;
5108
case QEMU_OPTION_numa:
5109
if (nb_numa_nodes >= MAX_NODES) {
5110
fprintf(stderr, "qemu: too many NUMA nodes\n");
5111
exit(1);
5112
}
5113
numa_add(optarg);
7918
5114
break;
7919
5115
case QEMU_OPTION_nographic:
7920
serial_devices[0] = "stdio";
7921
parallel_devices[0] = "null";
7922
monitor_device = "stdio";
7923
nographic = 1;
5116
display_type = DT_NOGRAPHIC;
7924
5117
break;
7925
5118
#ifdef CONFIG_CURSES
7926
5119
case QEMU_OPTION_curses:
7927
curses = 1;
5120
display_type = DT_CURSES;
7928
5121
break;
7929
5122
#endif
7930
5123
case QEMU_OPTION_portrait:
7940
5133
drive_add(optarg, CDROM_ALIAS);
7941
5134
break;
7942
5135
case QEMU_OPTION_boot:
7943
boot_devices = optarg;
7944
/* We just do some generic consistency checks */
7945
5136
{
7946
/* Could easily be extended to 64 devices if needed */
7947
const char *p;
7948
7949
boot_devices_bitmap = 0;
7950
for (p = boot_devices; *p != '\0'; p++) {
7951
/* Allowed boot devices are:
7952
* a b : floppy disk drives
7953
* c ... f : IDE disk drives
7954
* g ... m : machine implementation dependant drives
7955
* n ... p : network devices
7956
* It's up to each machine implementation to check
7957
* if the given boot devices match the actual hardware
7958
* implementation and firmware features.
7959
*/
7960
if (*p < 'a' || *p > 'q') {
7961
fprintf(stderr, "Invalid boot device '%c'\n", *p);
7962
exit(1);
7963
}
7964
if (boot_devices_bitmap & (1 << (*p - 'a'))) {
7965
fprintf(stderr,
7966
"Boot device '%c' was given twice\n",*p);
7967
exit(1);
7968
}
7969
boot_devices_bitmap |= 1 << (*p - 'a');
5137
static const char * const params[] = {
5138
"order", "once", "menu", NULL
5139
};
5140
char buf[sizeof(boot_devices)];
5141
char *standard_boot_devices;
5142
int legacy = 0;
5143
5144
if (!strchr(optarg, '=')) {
5145
legacy = 1;
5146
pstrcpy(buf, sizeof(buf), optarg);
5147
} else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
5148
fprintf(stderr,
5149
"qemu: unknown boot parameter '%s' in '%s'\n",
5150
buf, optarg);
5151
exit(1);
5152
}
5153
5154
if (legacy ||
5155
get_param_value(buf, sizeof(buf), "order", optarg)) {
5156
boot_devices_bitmap = parse_bootdevices(buf);
5157
pstrcpy(boot_devices, sizeof(boot_devices), buf);
5158
}
5159
if (!legacy) {
5160
if (get_param_value(buf, sizeof(buf),
5161
"once", optarg)) {
5162
boot_devices_bitmap |= parse_bootdevices(buf);
5163
standard_boot_devices = qemu_strdup(boot_devices);
5164
pstrcpy(boot_devices, sizeof(boot_devices), buf);
5165
qemu_register_reset(restore_boot_devices,
5166
standard_boot_devices);
5167
}
5168
if (get_param_value(buf, sizeof(buf),
5169
"menu", optarg)) {
5170
if (!strcmp(buf, "on")) {
5171
boot_menu = 1;
5172
} else if (!strcmp(buf, "off")) {
5173
boot_menu = 0;
5174
} else {
5175
fprintf(stderr,
5176
"qemu: invalid option value '%s'\n",
5177
buf);
5178
exit(1);
5179
}
5180
}
7970
5181
}
7971
5182
}
7972
5183
break;
7989
5200
break;
7990
5201
#ifdef CONFIG_SLIRP
7991
5202
case QEMU_OPTION_tftp:
7992
tftp_prefix = optarg;
5203
legacy_tftp_prefix = optarg;
7993
5204
break;
7994
5205
case QEMU_OPTION_bootp:
7995
bootp_filename = optarg;
5206
legacy_bootp_filename = optarg;
7996
5207
break;
7997
5208
#ifndef _WIN32
7998
5209
case QEMU_OPTION_smb:
7999
net_slirp_smb(optarg);
5210
net_slirp_smb(optarg);
8000
5211
break;
8001
5212
#endif
8002
5213
case QEMU_OPTION_redir:
8003
5214
net_slirp_redir(optarg);
8004
5215
break;
8005
5216
#endif
5217
case QEMU_OPTION_bt:
5218
add_device_config(DEV_BT, optarg);
5219
break;
8006
5220
#ifdef HAS_AUDIO
8007
5221
case QEMU_OPTION_audio_help:
8008
5222
AUD_help ();
8015
5229
case QEMU_OPTION_h:
8016
5230
help(0);
8017
5231
break;
5232
case QEMU_OPTION_version:
5233
version();
5234
exit(0);
5235
break;
8018
5236
case QEMU_OPTION_m: {
8019
5237
uint64_t value;
8020
5238
char *ptr;
8033
5251
}
8034
5252
8035
5253
/* On 32-bit hosts, QEMU is limited by virtual address space */
8036
if (value > (2047 << 20)
8037
#ifndef USE_KQEMU
8038
&& HOST_LONG_BITS == 32
8039
#endif
8040
) {
5254
if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
8041
5255
fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
8042
5256
exit(1);
8043
5257
}
8051
5265
case QEMU_OPTION_d:
8052
5266
{
8053
5267
int mask;
8054
CPULogItem *item;
5268
const CPULogItem *item;
8055
5269
8056
5270
mask = cpu_str_to_log_mask(optarg);
8057
5271
if (!mask) {
8064
5278
cpu_set_log(mask);
8065
5279
}
8066
5280
break;
8067
#ifdef CONFIG_GDBSTUB
8068
5281
case QEMU_OPTION_s:
8069
use_gdbstub = 1;
8070
break;
8071
case QEMU_OPTION_p:
8072
gdbstub_port = optarg;
8073
break;
8074
#endif
5282
gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5283
break;
5284
case QEMU_OPTION_gdb:
5285
gdbstub_dev = optarg;
5286
break;
8075
5287
case QEMU_OPTION_L:
8076
bios_dir = optarg;
5288
data_dir = optarg;
8077
5289
break;
8078
5290
case QEMU_OPTION_bios:
8079
5291
bios_name = optarg;
8080
5292
break;
5293
case QEMU_OPTION_singlestep:
5294
singlestep = 1;
5295
break;
8081
5296
case QEMU_OPTION_S:
8082
5297
autostart = 0;
8083
5298
break;
5299
#ifndef _WIN32
8084
5300
case QEMU_OPTION_k:
8085
5301
keyboard_layout = optarg;
8086
5302
break;
5303
#endif
8087
5304
case QEMU_OPTION_localtime:
8088
5305
rtc_utc = 0;
8089
5306
break;
8090
case QEMU_OPTION_cirrusvga:
8091
cirrus_vga_enabled = 1;
8092
vmsvga_enabled = 0;
8093
break;
8094
case QEMU_OPTION_vmsvga:
8095
cirrus_vga_enabled = 0;
8096
vmsvga_enabled = 1;
8097
break;
8098
case QEMU_OPTION_std_vga:
8099
cirrus_vga_enabled = 0;
8100
vmsvga_enabled = 0;
8101
break;
5307
case QEMU_OPTION_vga:
5308
select_vgahw (optarg);
5309
break;
5310
#if defined(TARGET_PPC) || defined(TARGET_SPARC)
8102
5311
case QEMU_OPTION_g:
8103
5312
{
8104
5313
const char *p;
8133
5342
graphic_depth = depth;
8134
5343
}
8135
5344
break;
5345
#endif
8136
5346
case QEMU_OPTION_echr:
8137
5347
{
8138
5348
char *r;
8152
5362
serial_devices[serial_device_index] = optarg;
8153
5363
serial_device_index++;
8154
5364
break;
5365
case QEMU_OPTION_watchdog:
5366
if (watchdog) {
5367
fprintf(stderr,
5368
"qemu: only one watchdog option may be given\n");
5369
return 1;
5370
}
5371
watchdog = optarg;
5372
break;
5373
case QEMU_OPTION_watchdog_action:
5374
if (select_watchdog_action(optarg) == -1) {
5375
fprintf(stderr, "Unknown -watchdog-action parameter\n");
5376
exit(1);
5377
}
5378
break;
5379
case QEMU_OPTION_virtiocon:
5380
if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5381
fprintf(stderr, "qemu: too many virtio consoles\n");
5382
exit(1);
5383
}
5384
virtio_consoles[virtio_console_index] = optarg;
5385
virtio_console_index++;
5386
break;
8155
5387
case QEMU_OPTION_parallel:
8156
5388
if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8157
5389
fprintf(stderr, "qemu: too many parallel ports\n");
8176
5408
case QEMU_OPTION_no_quit:
8177
5409
no_quit = 1;
8178
5410
break;
5411
case QEMU_OPTION_sdl:
5412
display_type = DT_SDL;
5413
break;
8179
5414
#endif
8180
5415
case QEMU_OPTION_pidfile:
8181
5416
pid_file = optarg;
8184
5419
case QEMU_OPTION_win2k_hack:
8185
5420
win2k_install_hack = 1;
8186
5421
break;
5422
case QEMU_OPTION_rtc_td_hack:
5423
rtc_td_hack = 1;
5424
break;
5425
case QEMU_OPTION_acpitable:
5426
if(acpi_table_add(optarg) < 0) {
5427
fprintf(stderr, "Wrong acpi table provided\n");
5428
exit(1);
5429
}
5430
break;
5431
case QEMU_OPTION_smbios:
5432
if(smbios_entry_add(optarg) < 0) {
5433
fprintf(stderr, "Wrong smbios provided\n");
5434
exit(1);
5435
}
5436
break;
8187
5437
#endif
8188
#ifdef USE_KQEMU
8189
case QEMU_OPTION_no_kqemu:
8190
kqemu_allowed = 0;
8191
break;
8192
case QEMU_OPTION_kernel_kqemu:
8193
kqemu_allowed = 2;
5438
#ifdef CONFIG_KVM
5439
case QEMU_OPTION_enable_kvm:
5440
kvm_allowed = 1;
8194
5441
break;
8195
5442
#endif
8196
5443
case QEMU_OPTION_usb:
8198
5445
break;
8199
5446
case QEMU_OPTION_usbdevice:
8200
5447
usb_enabled = 1;
8201
if (usb_devices_index >= MAX_USB_CMDLINE) {
8202
fprintf(stderr, "Too many USB devices\n");
5448
add_device_config(DEV_USB, optarg);
5449
break;
5450
case QEMU_OPTION_device:
5451
opts = qemu_opts_parse(&qemu_device_opts, optarg, "driver");
5452
if (!opts) {
5453
fprintf(stderr, "parse error: %s\n", optarg);
8203
5454
exit(1);
8204
5455
}
8205
usb_devices[usb_devices_index] = optarg;
8206
usb_devices_index++;
8207
5456
break;
8208
5457
case QEMU_OPTION_smp:
8209
smp_cpus = atoi(optarg);
8210
if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
5458
smp_parse(optarg);
5459
if (smp_cpus < 1) {
8211
5460
fprintf(stderr, "Invalid number of CPUs\n");
8212
5461
exit(1);
8213
5462
}
5463
if (max_cpus < smp_cpus) {
5464
fprintf(stderr, "maxcpus must be equal to or greater than "
5465
"smp\n");
5466
exit(1);
5467
}
5468
if (max_cpus > 255) {
5469
fprintf(stderr, "Unsupported number of maxcpus\n");
5470
exit(1);
5471
}
8214
5472
break;
8215
5473
case QEMU_OPTION_vnc:
5474
display_type = DT_VNC;
8216
5475
vnc_display = optarg;
8217
5476
break;
5477
#ifdef TARGET_I386
8218
5478
case QEMU_OPTION_no_acpi:
8219
5479
acpi_enabled = 0;
8220
5480
break;
5481
case QEMU_OPTION_no_hpet:
5482
no_hpet = 1;
5483
break;
5484
case QEMU_OPTION_balloon:
5485
if (balloon_parse(optarg) < 0) {
5486
fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5487
exit(1);
5488
}
5489
break;
5490
#endif
8221
5491
case QEMU_OPTION_no_reboot:
8222
5492
no_reboot = 1;
8223
5493
break;
8227
5497
case QEMU_OPTION_show_cursor:
8228
5498
cursor_hide = 0;
8229
5499
break;
5500
case QEMU_OPTION_uuid:
5501
if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5502
fprintf(stderr, "Fail to parse UUID string."
5503
" Wrong format.\n");
5504
exit(1);
5505
}
5506
break;
5507
#ifndef _WIN32
8230
5508
case QEMU_OPTION_daemonize:
8231
5509
daemonize = 1;
8232
5510
break;
5511
#endif
8233
5512
case QEMU_OPTION_option_rom:
8234
5513
if (nb_option_roms >= MAX_OPTION_ROMS) {
8235
5514
fprintf(stderr, "Too many option ROMs\n");
8238
5517
option_rom[nb_option_roms] = optarg;
8239
5518
nb_option_roms++;
8240
5519
break;
5520
#if defined(TARGET_ARM) || defined(TARGET_M68K)
8241
5521
case QEMU_OPTION_semihosting:
8242
5522
semihosting_enabled = 1;
8243
5523
break;
5524
#endif
8244
5525
case QEMU_OPTION_name:
8245
qemu_name = optarg;
5526
qemu_name = qemu_strdup(optarg);
5527
{
5528
char *p = strchr(qemu_name, ',');
5529
if (p != NULL) {
5530
*p++ = 0;
5531
if (strncmp(p, "process=", 8)) {
5532
fprintf(stderr, "Unknown subargument %s to -name", p);
5533
exit(1);
5534
}
5535
p += 8;
5536
set_proc_name(p);
5537
}
5538
}
8246
5539
break;
8247
#ifdef TARGET_SPARC
5540
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
8248
5541
case QEMU_OPTION_prom_env:
8249
5542
if (nb_prom_envs >= MAX_PROM_ENVS) {
8250
5543
fprintf(stderr, "Too many prom variables\n");
8305
5598
if (tb_size < 0)
8306
5599
tb_size = 0;
8307
5600
break;
5601
case QEMU_OPTION_icount:
5602
use_icount = 1;
5603
if (strcmp(optarg, "auto") == 0) {
5604
icount_time_shift = -1;
5605
} else {
5606
icount_time_shift = strtol(optarg, NULL, 0);
5607
}
5608
break;
5609
case QEMU_OPTION_incoming:
5610
incoming = optarg;
5611
break;
5612
#ifndef _WIN32
5613
case QEMU_OPTION_chroot:
5614
chroot_dir = optarg;
5615
break;
5616
case QEMU_OPTION_runas:
5617
run_as = optarg;
5618
break;
5619
#endif
5620
#ifdef CONFIG_XEN
5621
case QEMU_OPTION_xen_domid:
5622
xen_domid = atoi(optarg);
5623
break;
5624
case QEMU_OPTION_xen_create:
5625
xen_mode = XEN_CREATE;
5626
break;
5627
case QEMU_OPTION_xen_attach:
5628
xen_mode = XEN_ATTACH;
5629
break;
5630
#endif
8308
5631
}
8309
5632
}
8310
5633
}
8311
5634
5635
/* If no data_dir is specified then try to find it relative to the
5636
executable path. */
5637
if (!data_dir) {
5638
data_dir = find_datadir(argv[0]);
5639
}
5640
/* If all else fails use the install patch specified when building. */
5641
if (!data_dir) {
5642
data_dir = CONFIG_QEMU_SHAREDIR;
5643
}
5644
5645
/*
5646
* Default to max_cpus = smp_cpus, in case the user doesn't
5647
* specify a max_cpus value.
5648
*/
5649
if (!max_cpus)
5650
max_cpus = smp_cpus;
5651
5652
machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5653
if (smp_cpus > machine->max_cpus) {
5654
fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5655
"supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5656
machine->max_cpus);
5657
exit(1);
5658
}
5659
5660
if (display_type == DT_NOGRAPHIC) {
5661
if (serial_device_index == 0)
5662
serial_devices[0] = "stdio";
5663
if (parallel_device_index == 0)
5664
parallel_devices[0] = "null";
5665
if (strncmp(monitor_device, "vc", 2) == 0)
5666
monitor_device = "stdio";
5667
}
5668
8312
5669
#ifndef _WIN32
8313
if (daemonize && !nographic && vnc_display == NULL) {
8314
fprintf(stderr, "Can only daemonize if using -nographic or -vnc\n");
8315
daemonize = 0;
8316
}
8317
8318
5670
if (daemonize) {
8319
5671
pid_t pid;
8320
5672
8352
5704
exit(1);
8353
5705
8354
5706
umask(027);
8355
chdir("/");
8356
5707
8357
5708
signal(SIGTSTP, SIG_IGN);
8358
5709
signal(SIGTTOU, SIG_IGN);
8359
5710
signal(SIGTTIN, SIG_IGN);
8360
5711
}
8361
#endif
8362
5712
8363
5713
if (pid_file && qemu_create_pidfile(pid_file) != 0) {
8364
5714
if (daemonize) {
8368
5718
fprintf(stderr, "Could not acquire pid file\n");
8369
5719
exit(1);
8370
5720
}
5721
#endif
8371
5722
8372
#ifdef USE_KQEMU
8373
if (smp_cpus > 1)
8374
kqemu_allowed = 0;
8375
#endif
5723
if (qemu_init_main_loop()) {
5724
fprintf(stderr, "qemu_init_main_loop failed\n");
5725
exit(1);
5726
}
8376
5727
linux_boot = (kernel_filename != NULL);
8377
net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
8378
8379
/* XXX: this should not be: some embedded targets just have flash */
8380
if (!linux_boot && net_boot == 0 &&
8381
nb_drives_opt == 0)
8382
help(1);
8383
8384
/* boot to floppy or the default cd if no hard disk defined yet */
8385
if (!boot_devices[0]) {
8386
boot_devices = "cad";
8387
}
5728
5729
if (!linux_boot && *kernel_cmdline != '\0') {
5730
fprintf(stderr, "-append only allowed with -kernel option\n");
5731
exit(1);
5732
}
5733
5734
if (!linux_boot && initrd_filename != NULL) {
5735
fprintf(stderr, "-initrd only allowed with -kernel option\n");
5736
exit(1);
5737
}
5738
5739
#ifndef _WIN32
5740
/* Win32 doesn't support line-buffering and requires size >= 2 */
8388
5741
setvbuf(stdout, NULL, _IOLBF, 0);
5742
#endif
8389
5743
8390
5744
init_timers();
8391
init_timer_alarm();
8392
qemu_aio_init();
5745
if (init_timer_alarm() < 0) {
5746
fprintf(stderr, "could not initialize alarm timer\n");
5747
exit(1);
5748
}
5749
if (use_icount && icount_time_shift < 0) {
5750
use_icount = 2;
5751
/* 125MIPS seems a reasonable initial guess at the guest speed.
5752
It will be corrected fairly quickly anyway. */
5753
icount_time_shift = 3;
5754
init_icount_adjust();
5755
}
8393
5756
8394
5757
#ifdef _WIN32
8395
5758
socket_init();
8398
5761
/* init network clients */
8399
5762
if (nb_net_clients == 0) {
8400
5763
/* if no clients, we use a default config */
8401
net_clients[0] = "nic";
8402
net_clients[1] = "user";
8403
nb_net_clients = 2;
5764
net_clients[nb_net_clients++] = "nic";
5765
#ifdef CONFIG_SLIRP
5766
net_clients[nb_net_clients++] = "user";
5767
#endif
8404
5768
}
8405
5769
8406
5770
for(i = 0;i < nb_net_clients; i++) {
8407
if (net_client_init(net_clients[i]) < 0)
8408
exit(1);
8409
}
8410
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8411
if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
8412
continue;
8413
if (vlan->nb_guest_devs == 0) {
8414
fprintf(stderr, "Invalid vlan (%d) with no nics\n", vlan->id);
8415
exit(1);
8416
}
8417
if (vlan->nb_host_devs == 0)
8418
fprintf(stderr,
8419
"Warning: vlan %d is not connected to host network\n",
8420
vlan->id);
8421
}
8422
8423
#ifdef TARGET_I386
8424
/* XXX: this should be moved in the PC machine instantiation code */
8425
if (net_boot != 0) {
8426
int netroms = 0;
8427
for (i = 0; i < nb_nics && i < 4; i++) {
8428
const char *model = nd_table[i].model;
8429
char buf[1024];
8430
if (net_boot & (1 << i)) {
8431
if (model == NULL)
8432
model = "ne2k_pci";
8433
snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
8434
if (get_image_size(buf) > 0) {
8435
if (nb_option_roms >= MAX_OPTION_ROMS) {
8436
fprintf(stderr, "Too many option ROMs\n");
8437
exit(1);
8438
}
8439
option_rom[nb_option_roms] = strdup(buf);
8440
nb_option_roms++;
8441
netroms++;
8442
}
8443
}
8444
}
8445
if (netroms == 0) {
8446
fprintf(stderr, "No valid PXE rom found for network device\n");
8447
exit(1);
8448
}
8449
}
8450
#endif
5771
if (net_client_parse(net_clients[i]) < 0)
5772
exit(1);
5773
}
5774
5775
net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5776
net_set_boot_mask(net_boot);
5777
5778
net_client_check();
5779
5780
/* init the bluetooth world */
5781
if (foreach_device_config(DEV_BT, bt_parse))
5782
exit(1);
8451
5783
8452
5784
/* init the memory */
8453
phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
8454
8455
if (machine->ram_require & RAMSIZE_FIXED) {
8456
if (ram_size > 0) {
8457
if (ram_size < phys_ram_size) {
8458
fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
8459
machine->name, (unsigned long long) phys_ram_size);
8460
exit(-1);
8461
}
8462
8463
phys_ram_size = ram_size;
8464
} else
8465
ram_size = phys_ram_size;
8466
} else {
8467
if (ram_size == 0)
8468
ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
8469
8470
phys_ram_size += ram_size;
8471
}
8472
8473
phys_ram_base = qemu_vmalloc(phys_ram_size);
8474
if (!phys_ram_base) {
8475
fprintf(stderr, "Could not allocate physical memory\n");
8476
exit(1);
8477
}
5785
if (ram_size == 0)
5786
ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
8478
5787
8479
5788
/* init the dynamic translator */
8480
5789
cpu_exec_init_all(tb_size * 1024 * 1024);
8482
5791
bdrv_init();
8483
5792
8484
5793
/* we always create the cdrom drive, even if no disk is there */
8485
8486
if (nb_drives_opt < MAX_DRIVES)
8487
drive_add(NULL, CDROM_ALIAS);
5794
drive_add(NULL, CDROM_ALIAS);
8488
5795
8489
5796
/* we always create at least one floppy */
8490
8491
if (nb_drives_opt < MAX_DRIVES)
8492
drive_add(NULL, FD_ALIAS, 0);
5797
drive_add(NULL, FD_ALIAS, 0);
8493
5798
8494
5799
/* we always create one sd slot, even if no card is in it */
8495
8496
if (nb_drives_opt < MAX_DRIVES)
8497
drive_add(NULL, SD_ALIAS);
5800
drive_add(NULL, SD_ALIAS);
8498
5801
8499
5802
/* open the virtual block devices */
8500
8501
for(i = 0; i < nb_drives_opt; i++)
8502
if (drive_init(&drives_opt[i], snapshot, machine) == -1)
8503
exit(1);
5803
if (snapshot)
5804
qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
5805
if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
5806
exit(1);
8504
5807
8505
5808
register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
8506
register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8507
8508
init_ioports();
8509
8510
/* terminal init */
8511
memset(&display_state, 0, sizeof(display_state));
8512
if (nographic) {
8513
if (curses) {
8514
fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
8515
exit(1);
8516
}
8517
/* nearly nothing to do */
8518
dumb_display_init(ds);
8519
} else if (vnc_display != NULL) {
8520
vnc_display_init(ds);
8521
if (vnc_display_open(ds, vnc_display) < 0)
8522
exit(1);
8523
} else
8524
#if defined(CONFIG_CURSES)
8525
if (curses) {
8526
curses_display_init(ds, full_screen);
8527
} else
8528
#endif
8529
{
8530
#if defined(CONFIG_SDL)
8531
sdl_display_init(ds, full_screen, no_frame);
8532
#elif defined(CONFIG_COCOA)
8533
cocoa_display_init(ds, full_screen);
8534
#else
8535
dumb_display_init(ds);
8536
#endif
8537
}
5809
register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5810
5811
#ifndef _WIN32
5812
/* must be after terminal init, SDL library changes signal handlers */
5813
sighandler_setup();
5814
#endif
8538
5815
8539
5816
/* Maintain compatibility with multiple stdio monitors */
8540
5817
if (!strcmp(monitor_device,"stdio")) {
8550
5827
}
8551
5828
}
8552
5829
}
5830
5831
if (nb_numa_nodes > 0) {
5832
int i;
5833
5834
if (nb_numa_nodes > smp_cpus) {
5835
nb_numa_nodes = smp_cpus;
5836
}
5837
5838
/* If no memory size if given for any node, assume the default case
5839
* and distribute the available memory equally across all nodes
5840
*/
5841
for (i = 0; i < nb_numa_nodes; i++) {
5842
if (node_mem[i] != 0)
5843
break;
5844
}
5845
if (i == nb_numa_nodes) {
5846
uint64_t usedmem = 0;
5847
5848
/* On Linux, the each node's border has to be 8MB aligned,
5849
* the final node gets the rest.
5850
*/
5851
for (i = 0; i < nb_numa_nodes - 1; i++) {
5852
node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5853
usedmem += node_mem[i];
5854
}
5855
node_mem[i] = ram_size - usedmem;
5856
}
5857
5858
for (i = 0; i < nb_numa_nodes; i++) {
5859
if (node_cpumask[i] != 0)
5860
break;
5861
}
5862
/* assigning the VCPUs round-robin is easier to implement, guest OSes
5863
* must cope with this anyway, because there are BIOSes out there in
5864
* real machines which also use this scheme.
5865
*/
5866
if (i == nb_numa_nodes) {
5867
for (i = 0; i < smp_cpus; i++) {
5868
node_cpumask[i % nb_numa_nodes] |= 1 << i;
5869
}
5870
}
5871
}
5872
5873
if (kvm_enabled()) {
5874
int ret;
5875
5876
ret = kvm_init(smp_cpus);
5877
if (ret < 0) {
5878
fprintf(stderr, "failed to initialize KVM\n");
5879
exit(1);
5880
}
5881
}
5882
8553
5883
if (monitor_device) {
8554
monitor_hd = qemu_chr_open(monitor_device);
5884
monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
8555
5885
if (!monitor_hd) {
8556
5886
fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
8557
5887
exit(1);
8558
5888
}
8559
monitor_init(monitor_hd, !nographic);
8560
5889
}
8561
5890
8562
5891
for(i = 0; i < MAX_SERIAL_PORTS; i++) {
8563
5892
const char *devname = serial_devices[i];
8564
5893
if (devname && strcmp(devname, "none")) {
8565
serial_hds[i] = qemu_chr_open(devname);
5894
char label[32];
5895
snprintf(label, sizeof(label), "serial%d", i);
5896
serial_hds[i] = qemu_chr_open(label, devname, NULL);
8566
5897
if (!serial_hds[i]) {
8567
5898
fprintf(stderr, "qemu: could not open serial device '%s'\n",
8568
5899
devname);
8569
5900
exit(1);
8570
5901
}
8571
if (strstart(devname, "vc", 0))
8572
qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8573
5902
}
8574
5903
}
8575
5904
8576
5905
for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
8577
5906
const char *devname = parallel_devices[i];
8578
5907
if (devname && strcmp(devname, "none")) {
8579
parallel_hds[i] = qemu_chr_open(devname);
5908
char label[32];
5909
snprintf(label, sizeof(label), "parallel%d", i);
5910
parallel_hds[i] = qemu_chr_open(label, devname, NULL);
8580
5911
if (!parallel_hds[i]) {
8581
5912
fprintf(stderr, "qemu: could not open parallel device '%s'\n",
8582
5913
devname);
8583
5914
exit(1);
8584
5915
}
8585
if (strstart(devname, "vc", 0))
8586
qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
8587
}
8588
}
8589
8590
machine->init(ram_size, vga_ram_size, boot_devices, ds,
5916
}
5917
}
5918
5919
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5920
const char *devname = virtio_consoles[i];
5921
if (devname && strcmp(devname, "none")) {
5922
char label[32];
5923
snprintf(label, sizeof(label), "virtcon%d", i);
5924
virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5925
if (!virtcon_hds[i]) {
5926
fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5927
devname);
5928
exit(1);
5929
}
5930
}
5931
}
5932
5933
module_call_init(MODULE_INIT_DEVICE);
5934
5935
if (watchdog) {
5936
i = select_watchdog(watchdog);
5937
if (i > 0)
5938
exit (i == 1 ? 1 : 0);
5939
}
5940
5941
if (machine->compat_props) {
5942
qdev_prop_register_compat(machine->compat_props);
5943
}
5944
machine->init(ram_size, boot_devices,
8591
5945
kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
8592
5946
5947
5948
for (env = first_cpu; env != NULL; env = env->next_cpu) {
5949
for (i = 0; i < nb_numa_nodes; i++) {
5950
if (node_cpumask[i] & (1 << env->cpu_index)) {
5951
env->numa_node = i;
5952
}
5953
}
5954
}
5955
5956
current_machine = machine;
5957
8593
5958
/* init USB devices */
8594
5959
if (usb_enabled) {
8595
for(i = 0; i < usb_devices_index; i++) {
8596
if (usb_device_add(usb_devices[i]) < 0) {
8597
fprintf(stderr, "Warning: could not add USB device %s\n",
8598
usb_devices[i]);
8599
}
8600
}
8601
}
8602
8603
if (display_state.dpy_refresh) {
8604
display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
8605
qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
8606
}
8607
8608
#ifdef CONFIG_GDBSTUB
8609
if (use_gdbstub) {
8610
/* XXX: use standard host:port notation and modify options
8611
accordingly. */
8612
if (gdbserver_start(gdbstub_port) < 0) {
8613
fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
8614
gdbstub_port);
5960
foreach_device_config(DEV_USB, usb_parse);
5961
}
5962
5963
/* init generic devices */
5964
if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5965
exit(1);
5966
5967
if (!display_state)
5968
dumb_display_init();
5969
/* just use the first displaystate for the moment */
5970
ds = display_state;
5971
5972
if (display_type == DT_DEFAULT) {
5973
#if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5974
display_type = DT_SDL;
5975
#else
5976
display_type = DT_VNC;
5977
vnc_display = "localhost:0,to=99";
5978
show_vnc_port = 1;
5979
#endif
5980
}
5981
5982
5983
switch (display_type) {
5984
case DT_NOGRAPHIC:
5985
break;
5986
#if defined(CONFIG_CURSES)
5987
case DT_CURSES:
5988
curses_display_init(ds, full_screen);
5989
break;
5990
#endif
5991
#if defined(CONFIG_SDL)
5992
case DT_SDL:
5993
sdl_display_init(ds, full_screen, no_frame);
5994
break;
5995
#elif defined(CONFIG_COCOA)
5996
case DT_SDL:
5997
cocoa_display_init(ds, full_screen);
5998
break;
5999
#endif
6000
case DT_VNC:
6001
vnc_display_init(ds);
6002
if (vnc_display_open(ds, vnc_display) < 0)
8615
6003
exit(1);
8616
}
8617
}
8618
#endif
8619
8620
if (loadvm)
8621
do_loadvm(loadvm);
8622
8623
{
8624
/* XXX: simplify init */
8625
read_passwords();
8626
if (autostart) {
8627
vm_start();
8628
}
8629
}
8630
6004
6005
if (show_vnc_port) {
6006
printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
6007
}
6008
break;
6009
default:
6010
break;
6011
}
6012
dpy_resize(ds);
6013
6014
dcl = ds->listeners;
6015
while (dcl != NULL) {
6016
if (dcl->dpy_refresh != NULL) {
6017
ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
6018
qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
6019
}
6020
dcl = dcl->next;
6021
}
6022
6023
if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
6024
nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
6025
qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
6026
}
6027
6028
text_consoles_set_display(display_state);
6029
qemu_chr_initial_reset();
6030
6031
if (monitor_device && monitor_hd)
6032
monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
6033
6034
for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6035
const char *devname = serial_devices[i];
6036
if (devname && strcmp(devname, "none")) {
6037
if (strstart(devname, "vc", 0))
6038
qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
6039
}
6040
}
6041
6042
for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6043
const char *devname = parallel_devices[i];
6044
if (devname && strcmp(devname, "none")) {
6045
if (strstart(devname, "vc", 0))
6046
qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6047
}
6048
}
6049
6050
for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6051
const char *devname = virtio_consoles[i];
6052
if (virtcon_hds[i] && devname) {
6053
if (strstart(devname, "vc", 0))
6054
qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
6055
}
6056
}
6057
6058
if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
6059
fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
6060
gdbstub_dev);
6061
exit(1);
6062
}
6063
6064
if (loadvm) {
6065
if (load_vmstate(cur_mon, loadvm) < 0) {
6066
autostart = 0;
6067
}
6068
}
6069
6070
if (incoming) {
6071
qemu_start_incoming_migration(incoming);
6072
} else if (autostart) {
6073
vm_start();
6074
}
6075
6076
#ifndef _WIN32
8631
6077
if (daemonize) {
8632
6078
uint8_t status = 0;
8633
6079
ssize_t len;
8634
int fd;
8635
6080
8636
6081
again1:
8637
6082
len = write(fds[1], &status, 1);
8641
6086
if (len != 1)
8642
6087
exit(1);
8643
6088
6089
chdir("/");
8644
6090
TFR(fd = open("/dev/null", O_RDWR));
8645
6091
if (fd == -1)
8646
6092
exit(1);
8647
8648
dup2(fd, 0);
8649
dup2(fd, 1);
8650
dup2(fd, 2);
8651
8652
close(fd);
8653
}
6093
}
6094
6095
if (run_as) {
6096
pwd = getpwnam(run_as);
6097
if (!pwd) {
6098
fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6099
exit(1);
6100
}
6101
}
6102
6103
if (chroot_dir) {
6104
if (chroot(chroot_dir) < 0) {
6105
fprintf(stderr, "chroot failed\n");
6106
exit(1);
6107
}
6108
chdir("/");
6109
}
6110
6111
if (run_as) {
6112
if (setgid(pwd->pw_gid) < 0) {
6113
fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6114
exit(1);
6115
}
6116
if (setuid(pwd->pw_uid) < 0) {
6117
fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6118
exit(1);
6119
}
6120
if (setuid(0) != -1) {
6121
fprintf(stderr, "Dropping privileges failed\n");
6122
exit(1);
6123
}
6124
}
6125
6126
if (daemonize) {
6127
dup2(fd, 0);
6128
dup2(fd, 1);
6129
dup2(fd, 2);
6130
6131
close(fd);
6132
}
6133
#endif
8654
6134
8655
6135
main_loop();
8656
6136
quit_timers();
8657
8658
#if !defined(_WIN32)
8659
/* close network clients */
8660
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8661
VLANClientState *vc;
8662
8663
for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
8664
if (vc->fd_read == tap_receive) {
8665
char ifname[64];
8666
TAPState *s = vc->opaque;
8667
8668
if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
8669
s->down_script[0])
8670
launch_script(s->down_script, ifname, s->fd);
8671
}
8672
}
8673
}
8674
#endif
6137
net_cleanup();
6138
8675
6139
return 0;
8676
6140
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1