[mirror_qemu.git] / include / sysemu / sysemu.h

#ifndef SYSEMU_H
#define SYSEMU_H
/* Misc. things related to the system emulator.  */

#include "qemu/option.h"
#include "qemu/queue.h"
#include "qemu/timer.h"
#include "qapi-types.h"
#include "qemu/notify.h"
#include "qemu/main-loop.h"
#include "qemu/bitmap.h"
#include "qom/object.h"

/* vl.c */

extern const char *bios_name;

extern const char *qemu_name;
extern uint8_t qemu_uuid[];
extern bool qemu_uuid_set;
int qemu_uuid_parse(const char *str, uint8_t *uuid);

#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
#define UUID_NONE "00000000-0000-0000-0000-000000000000"

bool runstate_check(RunState state);
void runstate_set(RunState new_state);
int runstate_is_running(void);
bool runstate_needs_reset(void);
bool runstate_store(char *str, size_t size);
typedef struct vm_change_state_entry VMChangeStateEntry;
typedef void VMChangeStateHandler(void *opaque, int running, RunState state);

VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
                                                     void *opaque);
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
void vm_state_notify(int running, RunState state);

#define VMRESET_SILENT   false
#define VMRESET_REPORT   true

void vm_start(void);
int vm_stop(RunState state);
int vm_stop_force_state(RunState state);

typedef enum WakeupReason {
    /* Always keep QEMU_WAKEUP_REASON_NONE = 0 */
    QEMU_WAKEUP_REASON_NONE = 0,
    QEMU_WAKEUP_REASON_RTC,
    QEMU_WAKEUP_REASON_PMTIMER,
    QEMU_WAKEUP_REASON_OTHER,
} WakeupReason;

void qemu_system_reset_request(void);
void qemu_system_suspend_request(void);
void qemu_register_suspend_notifier(Notifier *notifier);
void qemu_system_wakeup_request(WakeupReason reason);
void qemu_system_wakeup_enable(WakeupReason reason, bool enabled);
void qemu_register_wakeup_notifier(Notifier *notifier);
void qemu_system_shutdown_request(void);
void qemu_system_powerdown_request(void);
void qemu_register_powerdown_notifier(Notifier *notifier);
void qemu_system_debug_request(void);
void qemu_system_vmstop_request(RunState reason);
void qemu_system_vmstop_request_prepare(void);
int qemu_shutdown_requested_get(void);
int qemu_reset_requested_get(void);
void qemu_system_killed(int signal, pid_t pid);
void qemu_devices_reset(void);
void qemu_system_reset(bool report);
void qemu_system_guest_panicked(void);
size_t qemu_target_page_bits(void);

void qemu_add_exit_notifier(Notifier *notify);
void qemu_remove_exit_notifier(Notifier *notify);

void qemu_add_machine_init_done_notifier(Notifier *notify);
void qemu_remove_machine_init_done_notifier(Notifier *notify);

void hmp_savevm(Monitor *mon, const QDict *qdict);
int load_vmstate(const char *name);
void hmp_delvm(Monitor *mon, const QDict *qdict);
void hmp_info_snapshots(Monitor *mon, const QDict *qdict);

void qemu_announce_self(void);

/* Subcommands for QEMU_VM_COMMAND */
enum qemu_vm_cmd {
    MIG_CMD_INVALID = 0,   /* Must be 0 */
    MIG_CMD_OPEN_RETURN_PATH,  /* Tell the dest to open the Return path */
    MIG_CMD_PING,              /* Request a PONG on the RP */

    MIG_CMD_POSTCOPY_ADVISE,       /* Prior to any page transfers, just
                                      warn we might want to do PC */
    MIG_CMD_POSTCOPY_LISTEN,       /* Start listening for incoming
                                      pages as it's running. */
    MIG_CMD_POSTCOPY_RUN,          /* Start execution */

    MIG_CMD_POSTCOPY_RAM_DISCARD,  /* A list of pages to discard that
                                      were previously sent during
                                      precopy but are dirty. */
    MIG_CMD_PACKAGED,          /* Send a wrapped stream within this stream */
    MIG_CMD_MAX
};

#define MAX_VM_CMD_PACKAGED_SIZE (1ul << 24)

bool qemu_savevm_state_blocked(Error **errp);
void qemu_savevm_state_begin(QEMUFile *f,
                             const MigrationParams *params);
void qemu_savevm_state_header(QEMUFile *f);
int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy);
void qemu_savevm_state_cleanup(void);
void qemu_savevm_state_complete_postcopy(QEMUFile *f);
void qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only);
void qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size,
                               uint64_t *res_non_postcopiable,
                               uint64_t *res_postcopiable);
void qemu_savevm_command_send(QEMUFile *f, enum qemu_vm_cmd command,
                              uint16_t len, uint8_t *data);
void qemu_savevm_send_ping(QEMUFile *f, uint32_t value);
void qemu_savevm_send_open_return_path(QEMUFile *f);
int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len);
void qemu_savevm_send_postcopy_advise(QEMUFile *f);
void qemu_savevm_send_postcopy_listen(QEMUFile *f);
void qemu_savevm_send_postcopy_run(QEMUFile *f);

void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,
                                           uint16_t len,
                                           uint64_t *start_list,
                                           uint64_t *length_list);

int qemu_loadvm_state(QEMUFile *f);

extern int autostart;

typedef enum {
    VGA_NONE, VGA_STD, VGA_CIRRUS, VGA_VMWARE, VGA_XENFB, VGA_QXL,
    VGA_TCX, VGA_CG3, VGA_DEVICE, VGA_VIRTIO,
    VGA_TYPE_MAX,
} VGAInterfaceType;

extern int vga_interface_type;
#define xenfb_enabled (vga_interface_type == VGA_XENFB)

extern int graphic_width;
extern int graphic_height;
extern int graphic_depth;
extern int display_opengl;
extern const char *keyboard_layout;
extern int win2k_install_hack;
extern int alt_grab;
extern int ctrl_grab;
extern int smp_cpus;
extern int max_cpus;
extern int cursor_hide;
extern int graphic_rotate;
extern int no_quit;
extern int no_shutdown;
extern int old_param;
extern int boot_menu;
extern bool boot_strict;
extern uint8_t *boot_splash_filedata;
extern size_t boot_splash_filedata_size;
extern bool enable_mlock;
extern uint8_t qemu_extra_params_fw[2];
extern QEMUClockType rtc_clock;
extern const char *mem_path;
extern int mem_prealloc;

#define MAX_NODES 128
#define NUMA_NODE_UNASSIGNED MAX_NODES

/* The following shall be true for all CPUs:
 *   cpu->cpu_index < max_cpus <= MAX_CPUMASK_BITS
 *
 * Note that cpu->get_arch_id() may be larger than MAX_CPUMASK_BITS.
 */
#define MAX_CPUMASK_BITS 255

#define MAX_OPTION_ROMS 16
typedef struct QEMUOptionRom {
    const char *name;
    int32_t bootindex;
} QEMUOptionRom;
extern QEMUOptionRom option_rom[MAX_OPTION_ROMS];
extern int nb_option_roms;

#define MAX_PROM_ENVS 128
extern const char *prom_envs[MAX_PROM_ENVS];
extern unsigned int nb_prom_envs;

/* generic hotplug */
void hmp_drive_add(Monitor *mon, const QDict *qdict);

/* pcie aer error injection */
void hmp_pcie_aer_inject_error(Monitor *mon, const QDict *qdict);

/* serial ports */

#define MAX_SERIAL_PORTS 4

extern CharDriverState *serial_hds[MAX_SERIAL_PORTS];

/* parallel ports */

#define MAX_PARALLEL_PORTS 3

extern CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];

void hmp_usb_add(Monitor *mon, const QDict *qdict);
void hmp_usb_del(Monitor *mon, const QDict *qdict);
void hmp_info_usb(Monitor *mon, const QDict *qdict);

void add_boot_device_path(int32_t bootindex, DeviceState *dev,
                          const char *suffix);
char *get_boot_devices_list(size_t *size, bool ignore_suffixes);

DeviceState *get_boot_device(uint32_t position);
void check_boot_index(int32_t bootindex, Error **errp);
void del_boot_device_path(DeviceState *dev, const char *suffix);
void device_add_bootindex_property(Object *obj, int32_t *bootindex,
                                   const char *name, const char *suffix,
                                   DeviceState *dev, Error **errp);
void restore_boot_order(void *opaque);
void validate_bootdevices(const char *devices, Error **errp);

/* handler to set the boot_device order for a specific type of MachineClass */
typedef void QEMUBootSetHandler(void *opaque, const char *boot_order,
                                Error **errp);
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque);
void qemu_boot_set(const char *boot_order, Error **errp);

QemuOpts *qemu_get_machine_opts(void);

bool defaults_enabled(void);

extern QemuOptsList qemu_legacy_drive_opts;
extern QemuOptsList qemu_common_drive_opts;
extern QemuOptsList qemu_drive_opts;
extern QemuOptsList qemu_chardev_opts;
extern QemuOptsList qemu_device_opts;
extern QemuOptsList qemu_netdev_opts;
extern QemuOptsList qemu_net_opts;
extern QemuOptsList qemu_global_opts;
extern QemuOptsList qemu_mon_opts;

#endif
Commit	Line	Data
87ecb68b PB	1	#ifndef SYSEMU_H
	2	#define SYSEMU_H
	3	/* Misc. things related to the system emulator. */
	4
1de7afc9 PB	5	#include "qemu/option.h"
	6	#include "qemu/queue.h"
	7	#include "qemu/timer.h"
1fa9a5e4	8	#include "qapi-types.h"
1de7afc9 PB	9	#include "qemu/notify.h"
1de7afc9 PB	10	#include "qemu/main-loop.h"
8c85901e	11	#include "qemu/bitmap.h"
dfabb8b9	12	#include "qom/object.h"
376253ec	13
87ecb68b	14	/* vl.c */
1dfb4dd9	15
87ecb68b	16	extern const char *bios_name;
5cea8590	17
87ecb68b	18	extern const char *qemu_name;
8fcb1b90	19	extern uint8_t qemu_uuid[];
fc3b3295	20	extern bool qemu_uuid_set;
c4be29ff	21	int qemu_uuid_parse(const char str, uint8_t uuid);
5accc840	22
8fcb1b90	23	#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
5accc840	24	#define UUID_NONE "00000000-0000-0000-0000-000000000000"
87ecb68b	25
f5bbfba1 LC	26	bool runstate_check(RunState state);
f5bbfba1 LC	27	void runstate_set(RunState new_state);
1354869c	28	int runstate_is_running(void);
ede085b3	29	bool runstate_needs_reset(void);
5e0f1940	30	bool runstate_store(char *str, size_t size);
87ecb68b	31	typedef struct vm_change_state_entry VMChangeStateEntry;
1dfb4dd9	32	typedef void VMChangeStateHandler(void *opaque, int running, RunState state);
87ecb68b PB	33
	34	VMChangeStateEntry qemu_add_vm_change_state_handler(VMChangeStateHandler cb,
	35	void *opaque);
	36	void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
1dfb4dd9	37	void vm_state_notify(int running, RunState state);
e07bbac5	38
e063eb1f JK	39	#define VMRESET_SILENT false
	40	#define VMRESET_REPORT true
	41
87ecb68b	42	void vm_start(void);
56983463 KW	43	int vm_stop(RunState state);
56983463 KW	44	int vm_stop_force_state(RunState state);
87ecb68b	45
95b363b5	46	typedef enum WakeupReason {
4bc78a87 LJ	47	/* Always keep QEMU_WAKEUP_REASON_NONE = 0 */
4bc78a87 LJ	48	QEMU_WAKEUP_REASON_NONE = 0,
62aeb0f7	49	QEMU_WAKEUP_REASON_RTC,
6595abc0	50	QEMU_WAKEUP_REASON_PMTIMER,
4bc78a87	51	QEMU_WAKEUP_REASON_OTHER,
95b363b5 GH	52	} WakeupReason;
95b363b5 GH	53
87ecb68b	54	void qemu_system_reset_request(void);
95b363b5 GH	55	void qemu_system_suspend_request(void);
	56	void qemu_register_suspend_notifier(Notifier *notifier);
	57	void qemu_system_wakeup_request(WakeupReason reason);
	58	void qemu_system_wakeup_enable(WakeupReason reason, bool enabled);
	59	void qemu_register_wakeup_notifier(Notifier *notifier);
87ecb68b PB	60	void qemu_system_shutdown_request(void);
87ecb68b PB	61	void qemu_system_powerdown_request(void);
a9552c8e	62	void qemu_register_powerdown_notifier(Notifier *notifier);
8cf71710	63	void qemu_system_debug_request(void);
1dfb4dd9	64	void qemu_system_vmstop_request(RunState reason);
74892d24	65	void qemu_system_vmstop_request_prepare(void);
1291eb35 AP	66	int qemu_shutdown_requested_get(void);
1291eb35 AP	67	int qemu_reset_requested_get(void);
f64622c4	68	void qemu_system_killed(int signal, pid_t pid);
be522029	69	void qemu_devices_reset(void);
e063eb1f	70	void qemu_system_reset(bool report);
5f5b5942	71	void qemu_system_guest_panicked(void);
038629a6	72	size_t qemu_target_page_bits(void);
87ecb68b	73
fd42deeb GH	74	void qemu_add_exit_notifier(Notifier *notify);
	75	void qemu_remove_exit_notifier(Notifier *notify);
	76
4cab946a	77	void qemu_add_machine_init_done_notifier(Notifier *notify);
b86eacb8	78	void qemu_remove_machine_init_done_notifier(Notifier *notify);
4cab946a	79
3e5a50d6	80	void hmp_savevm(Monitor mon, const QDict qdict);
03cd4655	81	int load_vmstate(const char *name);
3e5a50d6	82	void hmp_delvm(Monitor mon, const QDict qdict);
1ce6be24	83	void hmp_info_snapshots(Monitor mon, const QDict qdict);
87ecb68b	84
210f41ba AL	85	void qemu_announce_self(void);
210f41ba AL	86
c76ca188 DDAG	87	/* Subcommands for QEMU_VM_COMMAND */
	88	enum qemu_vm_cmd {
	89	MIG_CMD_INVALID = 0, /* Must be 0 */
2e37701e DDAG	90	MIG_CMD_OPEN_RETURN_PATH, /* Tell the dest to open the Return path */
2e37701e DDAG	91	MIG_CMD_PING, /* Request a PONG on the RP */
093e3c42 DDAG	92
	93	MIG_CMD_POSTCOPY_ADVISE, /* Prior to any page transfers, just
	94	warn we might want to do PC */
	95	MIG_CMD_POSTCOPY_LISTEN, /* Start listening for incoming
	96	pages as it's running. */
	97	MIG_CMD_POSTCOPY_RUN, /* Start execution */
	98
	99	MIG_CMD_POSTCOPY_RAM_DISCARD, /* A list of pages to discard that
	100	were previously sent during
	101	precopy but are dirty. */
11cf1d98	102	MIG_CMD_PACKAGED, /* Send a wrapped stream within this stream */
c76ca188 DDAG	103	MIG_CMD_MAX
	104	};
	105
11cf1d98 DDAG	106	#define MAX_VM_CMD_PACKAGED_SIZE (1ul << 24)
11cf1d98 DDAG	107
e1c37d0e	108	bool qemu_savevm_state_blocked(Error **errp);
47c8c17a PB	109	void qemu_savevm_state_begin(QEMUFile *f,
47c8c17a PB	110	const MigrationParams *params);
f796baa1	111	void qemu_savevm_state_header(QEMUFile *f);
35ecd943	112	int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy);
ea7415fa	113	void qemu_savevm_state_cleanup(void);
763c906b	114	void qemu_savevm_state_complete_postcopy(QEMUFile *f);
1c0d249d	115	void qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only);
c31b098f DDAG	116	void qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size,
	117	uint64_t *res_non_postcopiable,
	118	uint64_t *res_postcopiable);
c76ca188 DDAG	119	void qemu_savevm_command_send(QEMUFile *f, enum qemu_vm_cmd command,
c76ca188 DDAG	120	uint16_t len, uint8_t *data);
2e37701e DDAG	121	void qemu_savevm_send_ping(QEMUFile *f, uint32_t value);
2e37701e DDAG	122	void qemu_savevm_send_open_return_path(QEMUFile *f);
61b67d47	123	int qemu_savevm_send_packaged(QEMUFile f, const uint8_t buf, size_t len);
093e3c42 DDAG	124	void qemu_savevm_send_postcopy_advise(QEMUFile *f);
	125	void qemu_savevm_send_postcopy_listen(QEMUFile *f);
	126	void qemu_savevm_send_postcopy_run(QEMUFile *f);
	127
	128	void qemu_savevm_send_postcopy_ram_discard(QEMUFile f, const char name,
	129	uint16_t len,
	130	uint64_t *start_list,
	131	uint64_t *length_list);
	132
9366f418 AL	133	int qemu_loadvm_state(QEMUFile *f);
9366f418 AL	134
d399f677	135	extern int autostart;
86176759 ZA	136
86176759 ZA	137	typedef enum {
a19cbfb3	138	VGA_NONE, VGA_STD, VGA_CIRRUS, VGA_VMWARE, VGA_XENFB, VGA_QXL,
a94f0c5c	139	VGA_TCX, VGA_CG3, VGA_DEVICE, VGA_VIRTIO,
8c9a2b71	140	VGA_TYPE_MAX,
86176759 ZA	141	} VGAInterfaceType;
	142
	143	extern int vga_interface_type;
86176759	144	#define xenfb_enabled (vga_interface_type == VGA_XENFB)
86176759	145
87ecb68b PB	146	extern int graphic_width;
	147	extern int graphic_height;
	148	extern int graphic_depth;
da076ffe	149	extern int display_opengl;
87ecb68b PB	150	extern const char *keyboard_layout;
	151	extern int win2k_install_hack;
	152	extern int alt_grab;
0ca9f8a4	153	extern int ctrl_grab;
87ecb68b	154	extern int smp_cpus;
6be68d7e	155	extern int max_cpus;
87ecb68b PB	156	extern int cursor_hide;
	157	extern int graphic_rotate;
	158	extern int no_quit;
a691d41a	159	extern int no_shutdown;
87ecb68b	160	extern int old_param;
95387491	161	extern int boot_menu;
bc74112f	162	extern bool boot_strict;
3d3b8303	163	extern uint8_t *boot_splash_filedata;
d09acb9b	164	extern size_t boot_splash_filedata_size;
58b7c17e	165	extern bool enable_mlock;
3d3b8303	166	extern uint8_t qemu_extra_params_fw[2];
884f17c2	167	extern QEMUClockType rtc_clock;
e1c57ab8 PB	168	extern const char *mem_path;
e1c57ab8 PB	169	extern int mem_prealloc;
87ecb68b	170
45e30bf3	171	#define MAX_NODES 128
6a3042b2	172	#define NUMA_NODE_UNASSIGNED MAX_NODES
d2995916 EH	173
	174	/* The following shall be true for all CPUs:
	175	* cpu->cpu_index < max_cpus <= MAX_CPUMASK_BITS
	176	*
	177	* Note that cpu->get_arch_id() may be larger than MAX_CPUMASK_BITS.
	178	*/
ee785fed	179	#define MAX_CPUMASK_BITS 255
d2995916	180
87ecb68b	181	#define MAX_OPTION_ROMS 16
2e55e842 GN	182	typedef struct QEMUOptionRom {
	183	const char *name;
	184	int32_t bootindex;
	185	} QEMUOptionRom;
	186	extern QEMUOptionRom option_rom[MAX_OPTION_ROMS];
87ecb68b PB	187	extern int nb_option_roms;
87ecb68b PB	188
87ecb68b PB	189	#define MAX_PROM_ENVS 128
	190	extern const char *prom_envs[MAX_PROM_ENVS];
	191	extern unsigned int nb_prom_envs;
87ecb68b	192
dd97aa8a	193	/* generic hotplug */
3e5a50d6	194	void hmp_drive_add(Monitor mon, const QDict qdict);
dd97aa8a	195
2ae63bda	196	/* pcie aer error injection */
04e00c92	197	void hmp_pcie_aer_inject_error(Monitor mon, const QDict qdict);
2ae63bda	198
87ecb68b PB	199	/* serial ports */
	200
	201	#define MAX_SERIAL_PORTS 4
	202
	203	extern CharDriverState *serial_hds[MAX_SERIAL_PORTS];
	204
	205	/* parallel ports */
	206
	207	#define MAX_PARALLEL_PORTS 3
	208
	209	extern CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
	210
3e5a50d6 MA	211	void hmp_usb_add(Monitor mon, const QDict qdict);
3e5a50d6 MA	212	void hmp_usb_del(Monitor mon, const QDict qdict);
1ce6be24	213	void hmp_info_usb(Monitor mon, const QDict qdict);
87ecb68b	214
1ca4d09a GN	215	void add_boot_device_path(int32_t bootindex, DeviceState *dev,
1ca4d09a GN	216	const char *suffix);
30e32af7	217	char get_boot_devices_list(size_t size, bool ignore_suffixes);
094b287f	218
7dc5af55	219	DeviceState *get_boot_device(uint32_t position);
694fb857	220	void check_boot_index(int32_t bootindex, Error **errp);
9d27572d	221	void del_boot_device_path(DeviceState dev, const char suffix);
12da3097 GA	222	void device_add_bootindex_property(Object obj, int32_t bootindex,
	223	const char name, const char suffix,
	224	DeviceState dev, Error *errp);
9816833d	225	void restore_boot_order(void *opaque);
703008e8	226	void validate_bootdevices(const char devices, Error *errp);
9816833d	227
3b53e45f	228	/* handler to set the boot_device order for a specific type of MachineClass */
ddcd5531 GA	229	typedef void QEMUBootSetHandler(void opaque, const char boot_order,
ddcd5531 GA	230	Error **errp);
9816833d	231	void qemu_register_boot_set(QEMUBootSetHandler func, void opaque);
f1839938	232	void qemu_boot_set(const char boot_order, Error *errp);
7dc5af55	233
7f9d6e54 MA	234	QemuOpts *qemu_get_machine_opts(void);
7f9d6e54 MA	235
f8b6f8ed	236	bool defaults_enabled(void);
094b287f	237
968854c8 AK	238	extern QemuOptsList qemu_legacy_drive_opts;
968854c8 AK	239	extern QemuOptsList qemu_common_drive_opts;
4d454574 PB	240	extern QemuOptsList qemu_drive_opts;
	241	extern QemuOptsList qemu_chardev_opts;
	242	extern QemuOptsList qemu_device_opts;
	243	extern QemuOptsList qemu_netdev_opts;
	244	extern QemuOptsList qemu_net_opts;
	245	extern QemuOptsList qemu_global_opts;
	246	extern QemuOptsList qemu_mon_opts;
	247
87ecb68b	248	#endif