?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kvm web: migration problems (removed usbdevice + windows crushes, added NFS)
[qemu-kvm/fedora.git] / vl.h
blob9917afa5c0515c8df9b499cf67d236b6a17d254b
1 /*
2 * QEMU System Emulator header
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #ifndef VL_H
25 #define VL_H
26
27 /* we put basic includes here to avoid repeating them in device drivers */
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <stdarg.h>
31 #include <string.h>
32 #include <inttypes.h>
33 #include <limits.h>
34 #include <time.h>
35 #include <ctype.h>
36 #include <errno.h>
37 #include <unistd.h>
38 #include <fcntl.h>
39 #include <sys/stat.h>
40
41 #ifndef O_LARGEFILE
42 #define O_LARGEFILE 0
43 #endif
44 #ifndef O_BINARY
45 #define O_BINARY 0
46 #endif
47
48 #ifdef _WIN32
49 #include <windows.h>
50 #define fsync _commit
51 #define lseek _lseeki64
52 #define ENOTSUP 4096
53 extern int qemu_ftruncate64(int, int64_t);
54 #define ftruncate qemu_ftruncate64
55
56
57 static inline char *realpath(const char *path, char *resolved_path)
58 {
59 _fullpath(resolved_path, path, _MAX_PATH);
60 return resolved_path;
61 }
62
63 #define PRId64 "I64d"
64 #define PRIx64 "I64x"
65 #define PRIu64 "I64u"
66 #define PRIo64 "I64o"
67 #endif
68
69 #ifdef QEMU_TOOL
70
71 /* we use QEMU_TOOL in the command line tools which do not depend on
72 the target CPU type */
73 #include "config-host.h"
74 #include <setjmp.h>
75 #include "osdep.h"
76 #include "bswap.h"
77
78 #else
79
80 #include "audio/audio.h"
81 #include "cpu.h"
82 #include "gdbstub.h"
83
84 #endif /* !defined(QEMU_TOOL) */
85
86 #ifndef glue
87 #define xglue(x, y) x ## y
88 #define glue(x, y) xglue(x, y)
89 #define stringify(s) tostring(s)
90 #define tostring(s) #s
91 #endif
92
93 #ifndef MIN
94 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
95 #endif
96 #ifndef MAX
97 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
98 #endif
99
100 /* vl.c */
101 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
102
103 void hw_error(const char *fmt, ...);
104
105 extern const char *bios_dir;
106
107 void pstrcpy(char *buf, int buf_size, const char *str);
108 char *pstrcat(char *buf, int buf_size, const char *s);
109 int strstart(const char *str, const char *val, const char **ptr);
110
111 extern int vm_running;
112
113 typedef struct vm_change_state_entry VMChangeStateEntry;
114 typedef void VMChangeStateHandler(void *opaque, int running);
115 typedef void VMStopHandler(void *opaque, int reason);
116
117 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
118 void *opaque);
119 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
120
121 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque);
122 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque);
123
124 void vm_start(void);
125 void vm_stop(int reason);
126
127 typedef void QEMUResetHandler(void *opaque);
128
129 void qemu_register_reset(QEMUResetHandler *func, void *opaque);
130 void qemu_system_reset_request(void);
131 void qemu_system_shutdown_request(void);
132 void qemu_system_powerdown_request(void);
133 #if !defined(TARGET_SPARC)
134 // Please implement a power failure function to signal the OS
135 #define qemu_system_powerdown() do{}while(0)
136 #else
137 void qemu_system_powerdown(void);
138 #endif
139
140 void main_loop_wait(int timeout);
141
142 extern int ram_size;
143 extern int bios_size;
144 extern int rtc_utc;
145 extern int cirrus_vga_enabled;
146 extern int graphic_width;
147 extern int graphic_height;
148 extern int graphic_depth;
149 extern const char *keyboard_layout;
150 extern int kqemu_allowed;
151 extern int kvm_allowed;
152 extern int win2k_install_hack;
153 extern int usb_enabled;
154 extern int smp_cpus;
155
156 /* XXX: make it dynamic */
157 #if defined (TARGET_PPC) || defined (TARGET_SPARC64)
158 #define BIOS_SIZE ((512 + 32) * 1024)
159 #elif defined(TARGET_MIPS)
160 #define BIOS_SIZE (128 * 1024)
161 #else
162 #define BIOS_SIZE ((256 + 64) * 1024)
163 #endif
164
165 #if USE_KVM
166 #define KVM_EXTRA_PAGES 3
167 #endif
168
169 /* keyboard/mouse support */
170
171 #define MOUSE_EVENT_LBUTTON 0x01
172 #define MOUSE_EVENT_RBUTTON 0x02
173 #define MOUSE_EVENT_MBUTTON 0x04
174
175 typedef void QEMUPutKBDEvent(void *opaque, int keycode);
176 typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state);
177
178 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque);
179 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque, int absolute);
180
181 void kbd_put_keycode(int keycode);
182 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
183 int kbd_mouse_is_absolute(void);
184
185 /* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
186 constants) */
187 #define QEMU_KEY_ESC1(c) ((c) | 0xe100)
188 #define QEMU_KEY_BACKSPACE 0x007f
189 #define QEMU_KEY_UP QEMU_KEY_ESC1('A')
190 #define QEMU_KEY_DOWN QEMU_KEY_ESC1('B')
191 #define QEMU_KEY_RIGHT QEMU_KEY_ESC1('C')
192 #define QEMU_KEY_LEFT QEMU_KEY_ESC1('D')
193 #define QEMU_KEY_HOME QEMU_KEY_ESC1(1)
194 #define QEMU_KEY_END QEMU_KEY_ESC1(4)
195 #define QEMU_KEY_PAGEUP QEMU_KEY_ESC1(5)
196 #define QEMU_KEY_PAGEDOWN QEMU_KEY_ESC1(6)
197 #define QEMU_KEY_DELETE QEMU_KEY_ESC1(3)
198
199 #define QEMU_KEY_CTRL_UP 0xe400
200 #define QEMU_KEY_CTRL_DOWN 0xe401
201 #define QEMU_KEY_CTRL_LEFT 0xe402
202 #define QEMU_KEY_CTRL_RIGHT 0xe403
203 #define QEMU_KEY_CTRL_HOME 0xe404
204 #define QEMU_KEY_CTRL_END 0xe405
205 #define QEMU_KEY_CTRL_PAGEUP 0xe406
206 #define QEMU_KEY_CTRL_PAGEDOWN 0xe407
207
208 void kbd_put_keysym(int keysym);
209
210 /* async I/O support */
211
212 typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
213 typedef int IOCanRWHandler(void *opaque);
214 typedef void IOHandler(void *opaque);
215
216 int qemu_set_fd_handler2(int fd,
217 IOCanRWHandler *fd_read_poll,
218 IOHandler *fd_read,
219 IOHandler *fd_write,
220 void *opaque);
221 int qemu_set_fd_handler(int fd,
222 IOHandler *fd_read,
223 IOHandler *fd_write,
224 void *opaque);
225
226 /* Polling handling */
227
228 /* return TRUE if no sleep should be done afterwards */
229 typedef int PollingFunc(void *opaque);
230
231 int qemu_add_polling_cb(PollingFunc *func, void *opaque);
232 void qemu_del_polling_cb(PollingFunc *func, void *opaque);
233
234 #ifdef _WIN32
235 /* Wait objects handling */
236 typedef void WaitObjectFunc(void *opaque);
237
238 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
239 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
240 #endif
241
242 /* character device */
243
244 #define CHR_EVENT_BREAK 0 /* serial break char */
245 #define CHR_EVENT_FOCUS 1 /* focus to this terminal (modal input needed) */
246
247
248
249 #define CHR_IOCTL_SERIAL_SET_PARAMS 1
250 typedef struct {
251 int speed;
252 int parity;
253 int data_bits;
254 int stop_bits;
255 } QEMUSerialSetParams;
256
257 #define CHR_IOCTL_SERIAL_SET_BREAK 2
258
259 #define CHR_IOCTL_PP_READ_DATA 3
260 #define CHR_IOCTL_PP_WRITE_DATA 4
261 #define CHR_IOCTL_PP_READ_CONTROL 5
262 #define CHR_IOCTL_PP_WRITE_CONTROL 6
263 #define CHR_IOCTL_PP_READ_STATUS 7
264
265 typedef void IOEventHandler(void *opaque, int event);
266
267 typedef struct CharDriverState {
268 int (*chr_write)(struct CharDriverState *s, const uint8_t *buf, int len);
269 void (*chr_add_read_handler)(struct CharDriverState *s,
270 IOCanRWHandler *fd_can_read,
271 IOReadHandler *fd_read, void *opaque);
272 int (*chr_ioctl)(struct CharDriverState *s, int cmd, void *arg);
273 IOEventHandler *chr_event;
274 void (*chr_send_event)(struct CharDriverState *chr, int event);
275 void (*chr_close)(struct CharDriverState *chr);
276 void *opaque;
277 } CharDriverState;
278
279 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...);
280 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len);
281 void qemu_chr_send_event(CharDriverState *s, int event);
282 void qemu_chr_add_read_handler(CharDriverState *s,
283 IOCanRWHandler *fd_can_read,
284 IOReadHandler *fd_read, void *opaque);
285 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event);
286 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg);
287
288 /* consoles */
289
290 typedef struct DisplayState DisplayState;
291 typedef struct TextConsole TextConsole;
292
293 typedef void (*vga_hw_update_ptr)(void *);
294 typedef void (*vga_hw_invalidate_ptr)(void *);
295 typedef void (*vga_hw_screen_dump_ptr)(void *, const char *);
296
297 TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,
298 vga_hw_invalidate_ptr invalidate,
299 vga_hw_screen_dump_ptr screen_dump,
300 void *opaque);
301 void vga_hw_update(void);
302 void vga_hw_invalidate(void);
303 void vga_hw_screen_dump(const char *filename);
304
305 int is_graphic_console(void);
306 CharDriverState *text_console_init(DisplayState *ds);
307 void console_select(unsigned int index);
308
309 /* serial ports */
310
311 #define MAX_SERIAL_PORTS 4
312
313 extern CharDriverState *serial_hds[MAX_SERIAL_PORTS];
314
315 /* parallel ports */
316
317 #define MAX_PARALLEL_PORTS 3
318
319 extern CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
320
321 /* VLANs support */
322
323 typedef struct VLANClientState VLANClientState;
324
325 struct VLANClientState {
326 IOReadHandler *fd_read;
327 /* Packets may still be sent if this returns zero. It's used to
328 rate-limit the slirp code. */
329 IOCanRWHandler *fd_can_read;
330 void *opaque;
331 struct VLANClientState *next;
332 struct VLANState *vlan;
333 char info_str[256];
334 };
335
336 typedef struct VLANState {
337 int id;
338 VLANClientState *first_client;
339 struct VLANState *next;
340 } VLANState;
341
342 VLANState *qemu_find_vlan(int id);
343 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
344 IOReadHandler *fd_read,
345 IOCanRWHandler *fd_can_read,
346 void *opaque);
347 int qemu_can_send_packet(VLANClientState *vc);
348 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size);
349 void qemu_handler_true(void *opaque);
350
351 void do_info_network(void);
352
353 /* TAP win32 */
354 int tap_win32_init(VLANState *vlan, const char *ifname);
355 void tap_win32_poll(void);
356
357 /* NIC info */
358
359 #define MAX_NICS 8
360
361 typedef struct NICInfo {
362 uint8_t macaddr[6];
363 const char *model;
364 VLANState *vlan;
365 } NICInfo;
366
367 extern int nb_nics;
368 extern NICInfo nd_table[MAX_NICS];
369
370 /* timers */
371
372 typedef struct QEMUClock QEMUClock;
373 typedef struct QEMUTimer QEMUTimer;
374 typedef void QEMUTimerCB(void *opaque);
375
376 /* The real time clock should be used only for stuff which does not
377 change the virtual machine state, as it is run even if the virtual
378 machine is stopped. The real time clock has a frequency of 1000
379 Hz. */
380 extern QEMUClock *rt_clock;
381
382 /* The virtual clock is only run during the emulation. It is stopped
383 when the virtual machine is stopped. Virtual timers use a high
384 precision clock, usually cpu cycles (use ticks_per_sec). */
385 extern QEMUClock *vm_clock;
386
387 int64_t qemu_get_clock(QEMUClock *clock);
388
389 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
390 void qemu_free_timer(QEMUTimer *ts);
391 void qemu_del_timer(QEMUTimer *ts);
392 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
393 int qemu_timer_pending(QEMUTimer *ts);
394
395 extern int64_t ticks_per_sec;
396 extern int pit_min_timer_count;
397
398 int64_t cpu_get_ticks(void);
399 void cpu_enable_ticks(void);
400 void cpu_disable_ticks(void);
401
402 /* VM Load/Save */
403
404 //typedef FILE QEMUFile;
405 typedef struct QEMUFile_s QEMUFile;
406 struct QEMUFile_s {
407 void *opaque;
408 int (*open)(QEMUFile *f, const char *filename, const char *flags);
409 void (*close)(QEMUFile *f);
410 void (*put_byte)(QEMUFile *f, int v);
411 int (*get_byte)(QEMUFile *f);
412 void (*put_buffer)(QEMUFile *f, const uint8_t *buf, int size);
413 int (*get_buffer)(QEMUFile *f, uint8_t *buf, int size);
414 int64_t (*tell)(QEMUFile *f);
415 int64_t (*seek)(QEMUFile *f, int64_t pos, int whence);
416 int (*eof)(QEMUFile *f);
417 };
418
419 extern QEMUFile qemu_savevm_method_file;
420 extern QEMUFile qemu_savevm_method_socket;
421
422 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
423 void qemu_put_byte(QEMUFile *f, int v);
424 void qemu_put_be16(QEMUFile *f, unsigned int v);
425 void qemu_put_be32(QEMUFile *f, unsigned int v);
426 void qemu_put_be64(QEMUFile *f, uint64_t v);
427 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
428 int qemu_get_byte(QEMUFile *f);
429 unsigned int qemu_get_be16(QEMUFile *f);
430 unsigned int qemu_get_be32(QEMUFile *f);
431 uint64_t qemu_get_be64(QEMUFile *f);
432
433 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
434 {
435 qemu_put_be64(f, *pv);
436 }
437
438 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
439 {
440 qemu_put_be32(f, *pv);
441 }
442
443 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
444 {
445 qemu_put_be16(f, *pv);
446 }
447
448 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
449 {
450 qemu_put_byte(f, *pv);
451 }
452
453 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
454 {
455 *pv = qemu_get_be64(f);
456 }
457
458 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
459 {
460 *pv = qemu_get_be32(f);
461 }
462
463 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
464 {
465 *pv = qemu_get_be16(f);
466 }
467
468 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
469 {
470 *pv = qemu_get_byte(f);
471 }
472
473 #if TARGET_LONG_BITS == 64
474 #define qemu_put_betl qemu_put_be64
475 #define qemu_get_betl qemu_get_be64
476 #define qemu_put_betls qemu_put_be64s
477 #define qemu_get_betls qemu_get_be64s
478 #else
479 #define qemu_put_betl qemu_put_be32
480 #define qemu_get_betl qemu_get_be32
481 #define qemu_put_betls qemu_put_be32s
482 #define qemu_get_betls qemu_get_be32s
483 #endif
484
485 int64_t qemu_ftell(QEMUFile *f);
486 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
487
488 typedef void SaveStateHandler(QEMUFile *f, void *opaque);
489 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
490
491 int qemu_loadvm(const char *filename, QEMUFile *f);
492 int qemu_savevm(const char *filename, QEMUFile *f);
493 int register_savevm(const char *idstr,
494 int instance_id,
495 int version_id,
496 SaveStateHandler *save_state,
497 LoadStateHandler *load_state,
498 void *opaque);
499 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
500 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
501
502 void cpu_save(QEMUFile *f, void *opaque);
503 int cpu_load(QEMUFile *f, void *opaque, int version_id);
504
505 /* block.c */
506 typedef struct BlockDriverState BlockDriverState;
507 typedef struct BlockDriver BlockDriver;
508
509 extern BlockDriver bdrv_raw;
510 extern BlockDriver bdrv_cow;
511 extern BlockDriver bdrv_qcow;
512 extern BlockDriver bdrv_vmdk;
513 extern BlockDriver bdrv_cloop;
514 extern BlockDriver bdrv_dmg;
515 extern BlockDriver bdrv_bochs;
516 extern BlockDriver bdrv_vpc;
517 extern BlockDriver bdrv_vvfat;
518
519 void bdrv_init(void);
520 BlockDriver *bdrv_find_format(const char *format_name);
521 int bdrv_create(BlockDriver *drv,
522 const char *filename, int64_t size_in_sectors,
523 const char *backing_file, int flags);
524 BlockDriverState *bdrv_new(const char *device_name);
525 void bdrv_delete(BlockDriverState *bs);
526 int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot);
527 int bdrv_open2(BlockDriverState *bs, const char *filename, int snapshot,
528 BlockDriver *drv);
529 void bdrv_close(BlockDriverState *bs);
530 int bdrv_read(BlockDriverState *bs, int64_t sector_num,
531 uint8_t *buf, int nb_sectors);
532 int bdrv_write(BlockDriverState *bs, int64_t sector_num,
533 const uint8_t *buf, int nb_sectors);
534 void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
535 int bdrv_commit(BlockDriverState *bs);
536 void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
537 /* Ensure contents are flushed to disk. */
538 void bdrv_flush(BlockDriverState *bs);
539
540 #define BDRV_TYPE_HD 0
541 #define BDRV_TYPE_CDROM 1
542 #define BDRV_TYPE_FLOPPY 2
543 #define BIOS_ATA_TRANSLATION_AUTO 0
544 #define BIOS_ATA_TRANSLATION_NONE 1
545 #define BIOS_ATA_TRANSLATION_LBA 2
546
547 void bdrv_set_geometry_hint(BlockDriverState *bs,
548 int cyls, int heads, int secs);
549 void bdrv_set_type_hint(BlockDriverState *bs, int type);
550 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
551 void bdrv_get_geometry_hint(BlockDriverState *bs,
552 int *pcyls, int *pheads, int *psecs);
553 int bdrv_get_type_hint(BlockDriverState *bs);
554 int bdrv_get_translation_hint(BlockDriverState *bs);
555 int bdrv_is_removable(BlockDriverState *bs);
556 int bdrv_is_read_only(BlockDriverState *bs);
557 int bdrv_is_inserted(BlockDriverState *bs);
558 int bdrv_is_locked(BlockDriverState *bs);
559 void bdrv_set_locked(BlockDriverState *bs, int locked);
560 void bdrv_set_change_cb(BlockDriverState *bs,
561 void (*change_cb)(void *opaque), void *opaque);
562 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
563 void bdrv_info(void);
564 BlockDriverState *bdrv_find(const char *name);
565 void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
566 int bdrv_is_encrypted(BlockDriverState *bs);
567 int bdrv_set_key(BlockDriverState *bs, const char *key);
568 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
569 void *opaque);
570 const char *bdrv_get_device_name(BlockDriverState *bs);
571
572 int qcow_get_cluster_size(BlockDriverState *bs);
573 int qcow_compress_cluster(BlockDriverState *bs, int64_t sector_num,
574 const uint8_t *buf);
575
576 #ifndef QEMU_TOOL
577
578 typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size,
579 int boot_device,
580 DisplayState *ds, const char **fd_filename, int snapshot,
581 const char *kernel_filename, const char *kernel_cmdline,
582 const char *initrd_filename);
583
584 typedef struct QEMUMachine {
585 const char *name;
586 const char *desc;
587 QEMUMachineInitFunc *init;
588 struct QEMUMachine *next;
589 } QEMUMachine;
590
591 int qemu_register_machine(QEMUMachine *m);
592
593 typedef void SetIRQFunc(void *opaque, int irq_num, int level);
594 typedef void IRQRequestFunc(void *opaque, int level);
595
596 /* ISA bus */
597
598 extern target_phys_addr_t isa_mem_base;
599
600 typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
601 typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
602
603 int register_ioport_read(int start, int length, int size,
604 IOPortReadFunc *func, void *opaque);
605 int register_ioport_write(int start, int length, int size,
606 IOPortWriteFunc *func, void *opaque);
607 void isa_unassign_ioport(int start, int length);
608
609 /* PCI bus */
610
611 extern target_phys_addr_t pci_mem_base;
612
613 typedef struct PCIBus PCIBus;
614 typedef struct PCIDevice PCIDevice;
615
616 typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
617 uint32_t address, uint32_t data, int len);
618 typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
619 uint32_t address, int len);
620 typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
621 uint32_t addr, uint32_t size, int type);
622
623 #define PCI_ADDRESS_SPACE_MEM 0x00
624 #define PCI_ADDRESS_SPACE_IO 0x01
625 #define PCI_ADDRESS_SPACE_MEM_PREFETCH 0x08
626
627 typedef struct PCIIORegion {
628 uint32_t addr; /* current PCI mapping address. -1 means not mapped */
629 uint32_t size;
630 uint8_t type;
631 PCIMapIORegionFunc *map_func;
632 } PCIIORegion;
633
634 #define PCI_ROM_SLOT 6
635 #define PCI_NUM_REGIONS 7
636
637 #define PCI_DEVICES_MAX 64
638
639 #define PCI_VENDOR_ID 0x00 /* 16 bits */
640 #define PCI_DEVICE_ID 0x02 /* 16 bits */
641 #define PCI_COMMAND 0x04 /* 16 bits */
642 #define PCI_COMMAND_IO 0x1 /* Enable response in I/O space */
643 #define PCI_COMMAND_MEMORY 0x2 /* Enable response in Memory space */
644 #define PCI_CLASS_DEVICE 0x0a /* Device class */
645 #define PCI_INTERRUPT_LINE 0x3c /* 8 bits */
646 #define PCI_INTERRUPT_PIN 0x3d /* 8 bits */
647 #define PCI_MIN_GNT 0x3e /* 8 bits */
648 #define PCI_MAX_LAT 0x3f /* 8 bits */
649
650 struct PCIDevice {
651 /* PCI config space */
652 uint8_t config[256];
653
654 /* the following fields are read only */
655 PCIBus *bus;
656 int devfn;
657 char name[64];
658 PCIIORegion io_regions[PCI_NUM_REGIONS];
659
660 /* do not access the following fields */
661 PCIConfigReadFunc *config_read;
662 PCIConfigWriteFunc *config_write;
663 /* ??? This is a PC-specific hack, and should be removed. */
664 int irq_index;
665 };
666
667 PCIDevice *pci_register_device(PCIBus *bus, const char *name,
668 int instance_size, int devfn,
669 PCIConfigReadFunc *config_read,
670 PCIConfigWriteFunc *config_write);
671
672 void pci_register_io_region(PCIDevice *pci_dev, int region_num,
673 uint32_t size, int type,
674 PCIMapIORegionFunc *map_func);
675
676 void pci_set_irq(PCIDevice *pci_dev, int irq_num, int level);
677
678 uint32_t pci_default_read_config(PCIDevice *d,
679 uint32_t address, int len);
680 void pci_default_write_config(PCIDevice *d,
681 uint32_t address, uint32_t val, int len);
682 void generic_pci_save(QEMUFile* f, void *opaque);
683 int generic_pci_load(QEMUFile* f, void *opaque, int version_id);
684
685 typedef void (*pci_set_irq_fn)(PCIDevice *pci_dev, void *pic,
686 int irq_num, int level);
687 PCIBus *pci_register_bus(pci_set_irq_fn set_irq, void *pic, int devfn_min);
688
689 void pci_nic_init(PCIBus *bus, NICInfo *nd);
690 void pci_data_write(void *opaque, uint32_t addr, uint32_t val, int len);
691 uint32_t pci_data_read(void *opaque, uint32_t addr, int len);
692 int pci_bus_num(PCIBus *s);
693 void pci_for_each_device(void (*fn)(PCIDevice *d));
694
695 void pci_info(void);
696
697 /* prep_pci.c */
698 PCIBus *pci_prep_init(void);
699
700 /* grackle_pci.c */
701 PCIBus *pci_grackle_init(uint32_t base, void *pic);
702
703 /* unin_pci.c */
704 PCIBus *pci_pmac_init(void *pic);
705
706 /* apb_pci.c */
707 PCIBus *pci_apb_init(target_ulong special_base, target_ulong mem_base,
708 void *pic);
709
710 PCIBus *pci_vpb_init(void *pic);
711
712 /* piix_pci.c */
713 PCIBus *i440fx_init(void);
714 int piix3_init(PCIBus *bus);
715 void pci_bios_init(void);
716
717 /* openpic.c */
718 typedef struct openpic_t openpic_t;
719 void openpic_set_irq(void *opaque, int n_IRQ, int level);
720 openpic_t *openpic_init (PCIBus *bus, int *pmem_index, int nb_cpus,
721 CPUState **envp);
722
723 /* heathrow_pic.c */
724 typedef struct HeathrowPICS HeathrowPICS;
725 void heathrow_pic_set_irq(void *opaque, int num, int level);
726 HeathrowPICS *heathrow_pic_init(int *pmem_index);
727
728 #ifdef HAS_AUDIO
729 struct soundhw {
730 const char *name;
731 const char *descr;
732 int enabled;
733 int isa;
734 union {
735 int (*init_isa) (AudioState *s);
736 int (*init_pci) (PCIBus *bus, AudioState *s);
737 } init;
738 };
739
740 extern struct soundhw soundhw[];
741 #endif
742
743 /* vga.c */
744
745 #define VGA_RAM_SIZE (8192 * 1024)
746
747 struct DisplayState {
748 uint8_t *data;
749 int linesize;
750 int depth;
751 int bgr; /* BGR color order instead of RGB. Only valid for depth == 32 */
752 int width;
753 int height;
754 void *opaque;
755
756 void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
757 void (*dpy_resize)(struct DisplayState *s, int w, int h);
758 void (*dpy_refresh)(struct DisplayState *s);
759 void (*dpy_copy)(struct DisplayState *s, int src_x, int src_y, int dst_x, int dst_y, int w, int h);
760 };
761
762 static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
763 {
764 s->dpy_update(s, x, y, w, h);
765 }
766
767 static inline void dpy_resize(DisplayState *s, int w, int h)
768 {
769 s->dpy_resize(s, w, h);
770 }
771
772 int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
773 unsigned long vga_ram_offset, int vga_ram_size,
774 unsigned long vga_bios_offset, int vga_bios_size);
775
776 /* cirrus_vga.c */
777 void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base,
778 unsigned long vga_ram_offset, int vga_ram_size);
779 void isa_cirrus_vga_init(DisplayState *ds, uint8_t *vga_ram_base,
780 unsigned long vga_ram_offset, int vga_ram_size);
781
782 /* sdl.c */
783 void sdl_display_init(DisplayState *ds, int full_screen);
784
785 /* cocoa.m */
786 void cocoa_display_init(DisplayState *ds, int full_screen);
787
788 /* vnc.c */
789 void vnc_display_init(DisplayState *ds, int display);
790
791 /* ide.c */
792 #define MAX_DISKS 4
793
794 extern BlockDriverState *bs_table[MAX_DISKS];
795
796 void isa_ide_init(int iobase, int iobase2, int irq,
797 BlockDriverState *hd0, BlockDriverState *hd1);
798 void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
799 int secondary_ide_enabled);
800 void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn);
801 int pmac_ide_init (BlockDriverState **hd_table,
802 SetIRQFunc *set_irq, void *irq_opaque, int irq);
803
804 /* cdrom.c */
805 int cdrom_read_toc(int nb_sectors, uint8_t *buf, int msf, int start_track);
806 int cdrom_read_toc_raw(int nb_sectors, uint8_t *buf, int msf, int session_num);
807
808 /* es1370.c */
809 int es1370_init (PCIBus *bus, AudioState *s);
810
811 /* sb16.c */
812 int SB16_init (AudioState *s);
813
814 /* adlib.c */
815 int Adlib_init (AudioState *s);
816
817 /* gus.c */
818 int GUS_init (AudioState *s);
819
820 /* dma.c */
821 typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
822 int DMA_get_channel_mode (int nchan);
823 int DMA_read_memory (int nchan, void *buf, int pos, int size);
824 int DMA_write_memory (int nchan, void *buf, int pos, int size);
825 void DMA_hold_DREQ (int nchan);
826 void DMA_release_DREQ (int nchan);
827 void DMA_schedule(int nchan);
828 void DMA_run (void);
829 void DMA_init (int high_page_enable);
830 void DMA_register_channel (int nchan,
831 DMA_transfer_handler transfer_handler,
832 void *opaque);
833 /* fdc.c */
834 #define MAX_FD 2
835 extern BlockDriverState *fd_table[MAX_FD];
836
837 typedef struct fdctrl_t fdctrl_t;
838
839 fdctrl_t *fdctrl_init (int irq_lvl, int dma_chann, int mem_mapped,
840 uint32_t io_base,
841 BlockDriverState **fds);
842 int fdctrl_get_drive_type(fdctrl_t *fdctrl, int drive_num);
843
844 /* ne2000.c */
845
846 void isa_ne2000_init(int base, int irq, NICInfo *nd);
847 void pci_ne2000_init(PCIBus *bus, NICInfo *nd);
848
849 /* rtl8139.c */
850
851 void pci_rtl8139_init(PCIBus *bus, NICInfo *nd);
852
853 /* pcnet.c */
854
855 void pci_pcnet_init(PCIBus *bus, NICInfo *nd);
856
857 /* pckbd.c */
858
859 void kbd_init(void);
860
861 /* mc146818rtc.c */
862
863 typedef struct RTCState RTCState;
864
865 RTCState *rtc_init(int base, int irq);
866 void rtc_set_memory(RTCState *s, int addr, int val);
867 void rtc_set_date(RTCState *s, const struct tm *tm);
868
869 /* serial.c */
870
871 typedef struct SerialState SerialState;
872 SerialState *serial_init(SetIRQFunc *set_irq, void *opaque,
873 int base, int irq, CharDriverState *chr);
874 SerialState *serial_mm_init (SetIRQFunc *set_irq, void *opaque,
875 target_ulong base, int it_shift,
876 int irq, CharDriverState *chr);
877
878 /* parallel.c */
879
880 typedef struct ParallelState ParallelState;
881 ParallelState *parallel_init(int base, int irq, CharDriverState *chr);
882
883 /* i8259.c */
884
885 typedef struct PicState2 PicState2;
886 extern PicState2 *isa_pic;
887 void pic_set_irq(int irq, int level);
888 void pic_set_irq_new(void *opaque, int irq, int level);
889 PicState2 *pic_init(IRQRequestFunc *irq_request, void *irq_request_opaque);
890 void pic_set_alt_irq_func(PicState2 *s, SetIRQFunc *alt_irq_func,
891 void *alt_irq_opaque);
892 int pic_read_irq(PicState2 *s);
893 void pic_update_irq(PicState2 *s);
894 uint32_t pic_intack_read(PicState2 *s);
895 void pic_info(void);
896 void irq_info(void);
897
898 /* APIC */
899 typedef struct IOAPICState IOAPICState;
900
901 int apic_init(CPUState *env);
902 int apic_get_interrupt(CPUState *env);
903 IOAPICState *ioapic_init(void);
904 void ioapic_set_irq(void *opaque, int vector, int level);
905
906 /* i8254.c */
907
908 #define PIT_FREQ 1193182
909
910 typedef struct PITState PITState;
911
912 PITState *pit_init(int base, int irq);
913 void pit_set_gate(PITState *pit, int channel, int val);
914 int pit_get_gate(PITState *pit, int channel);
915 int pit_get_initial_count(PITState *pit, int channel);
916 int pit_get_mode(PITState *pit, int channel);
917 int pit_get_out(PITState *pit, int channel, int64_t current_time);
918
919 /* pcspk.c */
920 void pcspk_init(PITState *);
921 int pcspk_audio_init(AudioState *);
922
923 /* acpi.c */
924 extern int acpi_enabled;
925 void piix4_pm_init(PCIBus *bus, int devfn);
926 void acpi_bios_init(void);
927
928 /* pc.c */
929 extern QEMUMachine pc_machine;
930 extern QEMUMachine isapc_machine;
931 extern int fd_bootchk;
932
933 void ioport_set_a20(int enable);
934 int ioport_get_a20(void);
935
936 /* ppc.c */
937 extern QEMUMachine prep_machine;
938 extern QEMUMachine core99_machine;
939 extern QEMUMachine heathrow_machine;
940
941 /* mips_r4k.c */
942 extern QEMUMachine mips_machine;
943
944 /* shix.c */
945 extern QEMUMachine shix_machine;
946
947 #ifdef TARGET_PPC
948 ppc_tb_t *cpu_ppc_tb_init (CPUState *env, uint32_t freq);
949 #endif
950 void PREP_debug_write (void *opaque, uint32_t addr, uint32_t val);
951
952 extern CPUWriteMemoryFunc *PPC_io_write[];
953 extern CPUReadMemoryFunc *PPC_io_read[];
954 void PPC_debug_write (void *opaque, uint32_t addr, uint32_t val);
955
956 /* sun4m.c */
957 extern QEMUMachine sun4m_machine;
958 uint32_t iommu_translate(uint32_t addr);
959 void pic_set_irq_cpu(int irq, int level, unsigned int cpu);
960
961 /* iommu.c */
962 void *iommu_init(uint32_t addr);
963 uint32_t iommu_translate_local(void *opaque, uint32_t addr);
964
965 /* lance.c */
966 void lance_init(NICInfo *nd, int irq, uint32_t leaddr, uint32_t ledaddr);
967
968 /* tcx.c */
969 void tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
970 unsigned long vram_offset, int vram_size, int width, int height);
971
972 /* slavio_intctl.c */
973 void *slavio_intctl_init();
974 void slavio_intctl_set_cpu(void *opaque, unsigned int cpu, CPUState *env);
975 void slavio_pic_info(void *opaque);
976 void slavio_irq_info(void *opaque);
977 void slavio_pic_set_irq(void *opaque, int irq, int level);
978 void slavio_pic_set_irq_cpu(void *opaque, int irq, int level, unsigned int cpu);
979
980 /* loader.c */
981 int get_image_size(const char *filename);
982 int load_image(const char *filename, uint8_t *addr);
983 int load_elf(const char *filename, int64_t virt_to_phys_addend, uint64_t *pentry);
984 int load_aout(const char *filename, uint8_t *addr);
985
986 /* slavio_timer.c */
987 void slavio_timer_init(uint32_t addr, int irq, int mode, unsigned int cpu);
988
989 /* slavio_serial.c */
990 SerialState *slavio_serial_init(int base, int irq, CharDriverState *chr1, CharDriverState *chr2);
991 void slavio_serial_ms_kbd_init(int base, int irq);
992
993 /* slavio_misc.c */
994 void *slavio_misc_init(uint32_t base, int irq);
995 void slavio_set_power_fail(void *opaque, int power_failing);
996
997 /* esp.c */
998 void esp_init(BlockDriverState **bd, int irq, uint32_t espaddr, uint32_t espdaddr);
999
1000 /* sun4u.c */
1001 extern QEMUMachine sun4u_machine;
1002
1003 /* NVRAM helpers */
1004 #include "hw/m48t59.h"
1005
1006 void NVRAM_set_byte (m48t59_t *nvram, uint32_t addr, uint8_t value);
1007 uint8_t NVRAM_get_byte (m48t59_t *nvram, uint32_t addr);
1008 void NVRAM_set_word (m48t59_t *nvram, uint32_t addr, uint16_t value);
1009 uint16_t NVRAM_get_word (m48t59_t *nvram, uint32_t addr);
1010 void NVRAM_set_lword (m48t59_t *nvram, uint32_t addr, uint32_t value);
1011 uint32_t NVRAM_get_lword (m48t59_t *nvram, uint32_t addr);
1012 void NVRAM_set_string (m48t59_t *nvram, uint32_t addr,
1013 const unsigned char *str, uint32_t max);
1014 int NVRAM_get_string (m48t59_t *nvram, uint8_t *dst, uint16_t addr, int max);
1015 void NVRAM_set_crc (m48t59_t *nvram, uint32_t addr,
1016 uint32_t start, uint32_t count);
1017 int PPC_NVRAM_set_params (m48t59_t *nvram, uint16_t NVRAM_size,
1018 const unsigned char *arch,
1019 uint32_t RAM_size, int boot_device,
1020 uint32_t kernel_image, uint32_t kernel_size,
1021 const char *cmdline,
1022 uint32_t initrd_image, uint32_t initrd_size,
1023 uint32_t NVRAM_image,
1024 int width, int height, int depth);
1025
1026 /* adb.c */
1027
1028 #define MAX_ADB_DEVICES 16
1029
1030 #define ADB_MAX_OUT_LEN 16
1031
1032 typedef struct ADBDevice ADBDevice;
1033
1034 /* hypercall.c */
1035
1036 void pci_hypercall_init(PCIBus *bus);
1037 void vmchannel_init(CharDriverState *hd);
1038
1039 /* buf = NULL means polling */
1040 typedef int ADBDeviceRequest(ADBDevice *d, uint8_t *buf_out,
1041 const uint8_t *buf, int len);
1042 typedef int ADBDeviceReset(ADBDevice *d);
1043
1044 struct ADBDevice {
1045 struct ADBBusState *bus;
1046 int devaddr;
1047 int handler;
1048 ADBDeviceRequest *devreq;
1049 ADBDeviceReset *devreset;
1050 void *opaque;
1051 };
1052
1053 typedef struct ADBBusState {
1054 ADBDevice devices[MAX_ADB_DEVICES];
1055 int nb_devices;
1056 int poll_index;
1057 } ADBBusState;
1058
1059 int adb_request(ADBBusState *s, uint8_t *buf_out,
1060 const uint8_t *buf, int len);
1061 int adb_poll(ADBBusState *s, uint8_t *buf_out);
1062
1063 ADBDevice *adb_register_device(ADBBusState *s, int devaddr,
1064 ADBDeviceRequest *devreq,
1065 ADBDeviceReset *devreset,
1066 void *opaque);
1067 void adb_kbd_init(ADBBusState *bus);
1068 void adb_mouse_init(ADBBusState *bus);
1069
1070 /* cuda.c */
1071
1072 extern ADBBusState adb_bus;
1073 int cuda_init(SetIRQFunc *set_irq, void *irq_opaque, int irq);
1074
1075 #include "hw/usb.h"
1076
1077 /* usb ports of the VM */
1078
1079 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
1080 usb_attachfn attach);
1081
1082 #define VM_USB_HUB_SIZE 8
1083
1084 void do_usb_add(const char *devname);
1085 void do_usb_del(const char *devname);
1086 void usb_info(void);
1087
1088 /* scsi-disk.c */
1089 typedef struct SCSIDevice SCSIDevice;
1090 typedef void (*scsi_completionfn)(void *, uint32_t, int);
1091
1092 SCSIDevice *scsi_disk_init(BlockDriverState *bdrv,
1093 scsi_completionfn completion,
1094 void *opaque);
1095 void scsi_disk_destroy(SCSIDevice *s);
1096
1097 int32_t scsi_send_command(SCSIDevice *s, uint32_t tag, uint8_t *buf, int lun);
1098 int scsi_read_data(SCSIDevice *s, uint8_t *data, uint32_t len);
1099 int scsi_write_data(SCSIDevice *s, uint8_t *data, uint32_t len);
1100
1101 /* lsi53c895a.c */
1102 void lsi_scsi_attach(void *opaque, BlockDriverState *bd, int id);
1103 void *lsi_scsi_init(PCIBus *bus, int devfn);
1104
1105 /* integratorcp.c */
1106 extern QEMUMachine integratorcp926_machine;
1107 extern QEMUMachine integratorcp1026_machine;
1108
1109 /* versatilepb.c */
1110 extern QEMUMachine versatilepb_machine;
1111 extern QEMUMachine versatileab_machine;
1112
1113 /* ps2.c */
1114 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg);
1115 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg);
1116 void ps2_write_mouse(void *, int val);
1117 void ps2_write_keyboard(void *, int val);
1118 uint32_t ps2_read_data(void *);
1119 void ps2_queue(void *, int b);
1120 void ps2_keyboard_set_translation(void *opaque, int mode);
1121
1122 /* smc91c111.c */
1123 void smc91c111_init(NICInfo *, uint32_t, void *, int);
1124
1125 /* pl110.c */
1126 void *pl110_init(DisplayState *ds, uint32_t base, void *pic, int irq, int);
1127
1128 /* pl011.c */
1129 void pl011_init(uint32_t base, void *pic, int irq, CharDriverState *chr);
1130
1131 /* pl050.c */
1132 void pl050_init(uint32_t base, void *pic, int irq, int is_mouse);
1133
1134 /* pl080.c */
1135 void *pl080_init(uint32_t base, void *pic, int irq);
1136
1137 /* pl190.c */
1138 void *pl190_init(uint32_t base, void *parent, int irq, int fiq);
1139
1140 /* arm-timer.c */
1141 void sp804_init(uint32_t base, void *pic, int irq);
1142 void icp_pit_init(uint32_t base, void *pic, int irq);
1143
1144 /* arm_boot.c */
1145
1146 void arm_load_kernel(int ram_size, const char *kernel_filename,
1147 const char *kernel_cmdline, const char *initrd_filename,
1148 int board_id);
1149
1150 /* sh7750.c */
1151 struct SH7750State;
1152
1153 struct SH7750State *sh7750_init(CPUState * cpu);
1154
1155 typedef struct {
1156 /* The callback will be triggered if any of the designated lines change */
1157 uint16_t portamask_trigger;
1158 uint16_t portbmask_trigger;
1159 /* Return 0 if no action was taken */
1160 int (*port_change_cb) (uint16_t porta, uint16_t portb,
1161 uint16_t * periph_pdtra,
1162 uint16_t * periph_portdira,
1163 uint16_t * periph_pdtrb,
1164 uint16_t * periph_portdirb);
1165 } sh7750_io_device;
1166
1167 int sh7750_register_io_device(struct SH7750State *s,
1168 sh7750_io_device * device);
1169 /* tc58128.c */
1170 int tc58128_init(struct SH7750State *s, char *zone1, char *zone2);
1171
1172 /* NOR flash devices */
1173 typedef struct pflash_t pflash_t;
1174
1175 pflash_t *pflash_register (target_ulong base, ram_addr_t off,
1176 BlockDriverState *bs,
1177 target_ulong sector_len, int nb_blocs, int width,
1178 uint16_t id0, uint16_t id1,
1179 uint16_t id2, uint16_t id3);
1180
1181 #endif /* defined(QEMU_TOOL) */
1182
1183 /* monitor.c */
1184 void monitor_init(CharDriverState *hd, int show_banner);
1185 void term_puts(const char *str);
1186 void term_vprintf(const char *fmt, va_list ap);
1187 void term_printf(const char *fmt, ...) __attribute__ ((__format__ (__printf__, 1, 2)));
1188 void term_flush(void);
1189 void term_print_help(void);
1190 void monitor_readline(const char *prompt, int is_password,
1191 char *buf, int buf_size);
1192
1193 /* readline.c */
1194 typedef void ReadLineFunc(void *opaque, const char *str);
1195
1196 extern int completion_index;
1197 void add_completion(const char *str);
1198 void readline_handle_byte(int ch);
1199 void readline_find_completion(const char *cmdline);
1200 const char *readline_get_history(unsigned int index);
1201 void readline_start(const char *prompt, int is_password,
1202 ReadLineFunc *readline_func, void *opaque);
1203
1204 void kqemu_record_dump(void);
1205
1206 #endif /* VL_H */
Patches shipped by Fedora