← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to sysemu.h

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
sysemu.h
8
8
 
9
9
extern int vm_running;
10
10
extern const char *qemu_name;
 
11
extern uint8_t qemu_uuid[];
 
12
#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
11
13
 
12
14
typedef struct vm_change_state_entry VMChangeStateEntry;
13
 
typedef void VMChangeStateHandler(void *opaque, int running);
14
 
typedef void VMStopHandler(void *opaque, int reason);
 
15
typedef void VMChangeStateHandler(void *opaque, int running, int reason);
15
16
 
16
17
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
17
18
                                                     void *opaque);
18
19
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e);
19
20
 
20
 
int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque);
21
 
void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque);
22
 
 
23
21
void vm_start(void);
24
22
void vm_stop(int reason);
25
23
 
30
28
void qemu_system_reset_request(void);
31
29
void qemu_system_shutdown_request(void);
32
30
void qemu_system_powerdown_request(void);
33
 
#if !defined(TARGET_SPARC)
 
31
int qemu_shutdown_requested(void);
 
32
int qemu_reset_requested(void);
 
33
int qemu_powerdown_requested(void);
 
34
#if !defined(TARGET_SPARC) && !defined(TARGET_I386)
34
35
// Please implement a power failure function to signal the OS
35
36
#define qemu_system_powerdown() do{}while(0)
36
37
#else
37
38
void qemu_system_powerdown(void);
38
39
#endif
39
 
 
40
 
void cpu_save(QEMUFile *f, void *opaque);
41
 
int cpu_load(QEMUFile *f, void *opaque, int version_id);
 
40
void qemu_system_reset(void);
42
41
 
43
42
void do_savevm(const char *name);
44
43
void do_loadvm(const char *name);
45
44
void do_delvm(const char *name);
46
45
void do_info_snapshots(void);
47
46
 
 
47
void qemu_announce_self(void);
 
48
 
48
49
void main_loop_wait(int timeout);
49
50
 
 
51
int qemu_savevm_state_begin(QEMUFile *f);
 
52
int qemu_savevm_state_iterate(QEMUFile *f);
 
53
int qemu_savevm_state_complete(QEMUFile *f);
 
54
int qemu_savevm_state(QEMUFile *f);
 
55
int qemu_loadvm_state(QEMUFile *f);
 
56
 
 
57
#ifdef _WIN32
50
58
/* Polling handling */
51
59
 
52
60
/* return TRUE if no sleep should be done afterwards */
55
63
int qemu_add_polling_cb(PollingFunc *func, void *opaque);
56
64
void qemu_del_polling_cb(PollingFunc *func, void *opaque);
57
65
 
58
 
#ifdef _WIN32
59
66
/* Wait objects handling */
60
67
typedef void WaitObjectFunc(void *opaque);
61
68
 
64
71
#endif
65
72
 
66
73
/* TAP win32 */
67
 
int tap_win32_init(VLANState *vlan, const char *ifname);
 
74
int tap_win32_init(VLANState *vlan, const char *model,
 
75
                   const char *name, const char *ifname);
68
76
 
69
77
/* SLIRP */
70
78
void do_info_slirp(void);
71
79
 
72
 
extern int ram_size;
73
80
extern int bios_size;
74
 
extern int rtc_utc;
75
 
extern int rtc_start_date;
76
81
extern int cirrus_vga_enabled;
 
82
extern int std_vga_enabled;
77
83
extern int vmsvga_enabled;
78
84
extern int graphic_width;
79
85
extern int graphic_height;
80
86
extern int graphic_depth;
 
87
extern int nographic;
81
88
extern const char *keyboard_layout;
82
89
extern int win2k_install_hack;
 
90
extern int rtc_td_hack;
83
91
extern int alt_grab;
84
92
extern int usb_enabled;
85
93
extern int smp_cpus;
87
95
extern int graphic_rotate;
88
96
extern int no_quit;
89
97
extern int semihosting_enabled;
90
 
extern int autostart;
91
98
extern int old_param;
92
99
extern const char *bootp_filename;
93
100
 
94
 
 
95
101
#ifdef USE_KQEMU
96
102
extern int kqemu_allowed;
97
103
#endif
100
106
extern const char *option_rom[MAX_OPTION_ROMS];
101
107
extern int nb_option_roms;
102
108
 
103
 
#ifdef TARGET_SPARC
 
109
#if defined(TARGET_SPARC) || defined(TARGET_PPC)
104
110
#define MAX_PROM_ENVS 128
105
111
extern const char *prom_envs[MAX_PROM_ENVS];
106
112
extern unsigned int nb_prom_envs;
107
113
#endif
108
114
 
109
 
/* XXX: make it dynamic */
110
 
#define MAX_BIOS_SIZE (4 * 1024 * 1024)
111
115
#if defined (TARGET_PPC)
112
116
#define BIOS_SIZE (1024 * 1024)
113
117
#elif defined (TARGET_SPARC64)
117
121
#endif
118
122
 
119
123
typedef enum {
120
 
    IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD
 
124
    IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD, IF_VIRTIO
121
125
} BlockInterfaceType;
122
126
 
 
127
typedef enum {
 
128
    BLOCK_ERR_REPORT, BLOCK_ERR_IGNORE, BLOCK_ERR_STOP_ENOSPC,
 
129
    BLOCK_ERR_STOP_ANY
 
130
} BlockInterfaceErrorAction;
 
131
 
123
132
typedef struct DriveInfo {
124
133
    BlockDriverState *bdrv;
125
134
    BlockInterfaceType type;
126
135
    int bus;
127
136
    int unit;
 
137
    int used;
 
138
    int drive_opt_idx;
 
139
    BlockInterfaceErrorAction onerror;
 
140
    char serial[21];
128
141
} DriveInfo;
129
142
 
130
143
#define MAX_IDE_DEVS    2
131
144
#define MAX_SCSI_DEVS   7
132
145
#define MAX_DRIVES 32
133
146
 
134
 
int nb_drives;
135
 
DriveInfo drives_table[MAX_DRIVES+1];
 
147
extern int nb_drives;
 
148
extern DriveInfo drives_table[MAX_DRIVES+1];
136
149
 
137
150
extern int drive_get_index(BlockInterfaceType type, int bus, int unit);
138
151
extern int drive_get_max_bus(BlockInterfaceType type);
 
152
extern void drive_uninit(BlockDriverState *bdrv);
 
153
extern void drive_remove(int index);
 
154
extern const char *drive_get_serial(BlockDriverState *bdrv);
 
155
extern BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv);
 
156
 
 
157
struct drive_opt {
 
158
    const char *file;
 
159
    char opt[1024];
 
160
    int used;
 
161
};
 
162
 
 
163
extern struct drive_opt drives_opt[MAX_DRIVES];
 
164
extern int nb_drives_opt;
 
165
 
 
166
extern int drive_add(const char *file, const char *fmt, ...);
 
167
extern int drive_init(struct drive_opt *arg, int snapshot, void *machine);
 
168
 
 
169
/* acpi */
 
170
void qemu_system_hot_add_init(void);
 
171
void qemu_system_device_hot_add(int pcibus, int slot, int state);
 
172
 
 
173
/* device-hotplug */
 
174
 
 
175
typedef int (dev_match_fn)(void *dev_private, void *arg);
 
176
 
 
177
int add_init_drive(const char *opts);
 
178
void destroy_nic(dev_match_fn *match_fn, void *arg);
 
179
void destroy_bdrvs(dev_match_fn *match_fn, void *arg);
 
180
 
 
181
/* pci-hotplug */
 
182
void pci_device_hot_add(const char *pci_addr, const char *type, const char *opts);
 
183
void drive_hot_add(const char *pci_addr, const char *opts);
 
184
void pci_device_hot_remove(const char *pci_addr);
 
185
void pci_device_hot_remove_success(int pcibus, int slot);
139
186
 
140
187
/* serial ports */
141
188
 
149
196
 
150
197
extern CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
151
198
 
 
199
/* virtio consoles */
 
200
 
 
201
#define MAX_VIRTIO_CONSOLES 1
 
202
 
 
203
extern CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
 
204
 
 
205
#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
 
206
 
152
207
#ifdef NEED_CPU_H
153
208
/* loader.c */
154
209
int get_image_size(const char *filename);
155
 
int load_image(const char *filename, uint8_t *addr);
156
 
int load_elf(const char *filename, int64_t virt_to_phys_addend,
 
210
int load_image(const char *filename, uint8_t *addr); /* deprecated */
 
211
int load_image_targphys(const char *filename, target_phys_addr_t, int max_sz);
 
212
int load_elf(const char *filename, int64_t address_offset,
157
213
             uint64_t *pentry, uint64_t *lowaddr, uint64_t *highaddr);
158
 
int load_aout(const char *filename, uint8_t *addr);
159
 
int load_uboot(const char *filename, target_ulong *ep, int *is_linux);
 
214
int load_aout(const char *filename, target_phys_addr_t addr, int max_sz);
 
215
int load_uimage(const char *filename, target_ulong *ep, target_ulong *loadaddr,
 
216
                int *is_linux);
 
217
 
 
218
int fread_targphys(target_phys_addr_t dst_addr, size_t nbytes, FILE *f);
 
219
int fread_targphys_ok(target_phys_addr_t dst_addr, size_t nbytes, FILE *f);
 
220
int read_targphys(int fd, target_phys_addr_t dst_addr, size_t nbytes);
 
221
void pstrcpy_targphys(target_phys_addr_t dest, int buf_size,
 
222
                      const char *source);
160
223
#endif
161
224
 
162
225
#ifdef HAS_AUDIO
178
241
void do_usb_del(const char *devname);
179
242
void usb_info(void);
180
243
 
 
244
const char *get_opt_name(char *buf, int buf_size, const char *p);
 
245
const char *get_opt_value(char *buf, int buf_size, const char *p);
 
246
int get_param_value(char *buf, int buf_size,
 
247
                    const char *tag, const char *str);
 
248
int check_params(char *buf, int buf_size,
 
249
                 const char * const *params, const char *str);
 
250
 
181
251
#endif