vl.h

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