]>
Commit | Line | Data |
---|---|---|
87ecb68b PB |
1 | /* Declarations for use by hardware emulation. */ |
2 | #ifndef QEMU_HW_H | |
3 | #define QEMU_HW_H | |
4 | ||
5 | #include "qemu-common.h" | |
6 | #include "irq.h" | |
7 | ||
8 | /* VM Load/Save */ | |
9 | ||
5dafc53f AL |
10 | /* This function writes a chunk of data to a file at the given position. |
11 | * The pos argument can be ignored if the file is only being used for | |
12 | * streaming. The handler should try to write all of the data it can. | |
13 | */ | |
871d2f07 AL |
14 | typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf, |
15 | int64_t pos, int size); | |
5dafc53f AL |
16 | |
17 | /* Read a chunk of data from a file at the given position. The pos argument | |
18 | * can be ignored if the file is only be used for streaming. The number of | |
19 | * bytes actually read should be returned. | |
20 | */ | |
21 | typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf, | |
22 | int64_t pos, int size); | |
23 | ||
24 | /* Close a file and return an error code */ | |
25 | typedef int (QEMUFileCloseFunc)(void *opaque); | |
26 | ||
27 | /* Called to determine if the file has exceeded it's bandwidth allocation. The | |
28 | * bandwidth capping is a soft limit, not a hard limit. | |
29 | */ | |
30 | typedef int (QEMUFileRateLimit)(void *opaque); | |
31 | ||
32 | QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer, | |
33 | QEMUFileGetBufferFunc *get_buffer, | |
34 | QEMUFileCloseFunc *close, | |
35 | QEMUFileRateLimit *rate_limit); | |
87ecb68b | 36 | QEMUFile *qemu_fopen(const char *filename, const char *mode); |
c1d36665 | 37 | QEMUFile *qemu_fopen_socket(int fd); |
065e2813 AL |
38 | QEMUFile *qemu_popen(FILE *popen_file, const char *mode); |
39 | QEMUFile *qemu_popen_cmd(const char *command, const char *mode); | |
71c55593 | 40 | int qemu_popen_fd(QEMUFile *f); |
87ecb68b | 41 | void qemu_fflush(QEMUFile *f); |
5dafc53f | 42 | int qemu_fclose(QEMUFile *f); |
2ca83a8d BS |
43 | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size); |
44 | void qemu_put_byte(QEMUFile *f, int v); | |
b6c4f71f BS |
45 | |
46 | static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) | |
47 | { | |
48 | qemu_put_byte(f, (int)v); | |
49 | } | |
50 | ||
51 | #define qemu_put_sbyte qemu_put_byte | |
52 | ||
2ca83a8d BS |
53 | void qemu_put_be16(QEMUFile *f, unsigned int v); |
54 | void qemu_put_be32(QEMUFile *f, unsigned int v); | |
87ecb68b | 55 | void qemu_put_be64(QEMUFile *f, uint64_t v); |
2ca83a8d BS |
56 | int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size); |
57 | int qemu_get_byte(QEMUFile *f); | |
b6c4f71f BS |
58 | |
59 | static inline unsigned int qemu_get_ubyte(QEMUFile *f) | |
60 | { | |
61 | return (unsigned int)qemu_get_byte(f); | |
62 | } | |
63 | ||
64 | #define qemu_get_sbyte qemu_get_byte | |
65 | ||
2ca83a8d BS |
66 | unsigned int qemu_get_be16(QEMUFile *f); |
67 | unsigned int qemu_get_be32(QEMUFile *f); | |
87ecb68b | 68 | uint64_t qemu_get_be64(QEMUFile *f); |
5dafc53f | 69 | int qemu_file_rate_limit(QEMUFile *f); |
871d2f07 | 70 | int qemu_file_has_error(QEMUFile *f); |
da0ac2bc | 71 | void qemu_file_set_error(QEMUFile *f); |
5dafc53f AL |
72 | |
73 | /* Try to send any outstanding data. This function is useful when output is | |
74 | * halted due to rate limiting or EAGAIN errors occur as it can be used to | |
75 | * resume output. */ | |
76 | void qemu_file_put_notify(QEMUFile *f); | |
87ecb68b PB |
77 | |
78 | static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv) | |
79 | { | |
80 | qemu_put_be64(f, *pv); | |
81 | } | |
82 | ||
83 | static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv) | |
84 | { | |
85 | qemu_put_be32(f, *pv); | |
86 | } | |
87 | ||
88 | static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv) | |
89 | { | |
90 | qemu_put_be16(f, *pv); | |
91 | } | |
92 | ||
93 | static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv) | |
94 | { | |
95 | qemu_put_byte(f, *pv); | |
96 | } | |
97 | ||
98 | static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv) | |
99 | { | |
100 | *pv = qemu_get_be64(f); | |
101 | } | |
102 | ||
103 | static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv) | |
104 | { | |
105 | *pv = qemu_get_be32(f); | |
106 | } | |
107 | ||
108 | static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv) | |
109 | { | |
110 | *pv = qemu_get_be16(f); | |
111 | } | |
112 | ||
113 | static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv) | |
114 | { | |
115 | *pv = qemu_get_byte(f); | |
116 | } | |
117 | ||
b6c4f71f BS |
118 | // Signed versions for type safety |
119 | static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size) | |
120 | { | |
121 | qemu_put_buffer(f, (const uint8_t *)buf, size); | |
122 | } | |
123 | ||
124 | static inline void qemu_put_sbe16(QEMUFile *f, int v) | |
125 | { | |
126 | qemu_put_be16(f, (unsigned int)v); | |
127 | } | |
128 | ||
129 | static inline void qemu_put_sbe32(QEMUFile *f, int v) | |
130 | { | |
131 | qemu_put_be32(f, (unsigned int)v); | |
132 | } | |
133 | ||
134 | static inline void qemu_put_sbe64(QEMUFile *f, int64_t v) | |
135 | { | |
136 | qemu_put_be64(f, (uint64_t)v); | |
137 | } | |
138 | ||
139 | static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size) | |
140 | { | |
141 | return qemu_get_buffer(f, (uint8_t *)buf, size); | |
142 | } | |
143 | ||
144 | static inline int qemu_get_sbe16(QEMUFile *f) | |
145 | { | |
146 | return (int)qemu_get_be16(f); | |
147 | } | |
148 | ||
149 | static inline int qemu_get_sbe32(QEMUFile *f) | |
150 | { | |
151 | return (int)qemu_get_be32(f); | |
152 | } | |
153 | ||
154 | static inline int64_t qemu_get_sbe64(QEMUFile *f) | |
155 | { | |
156 | return (int64_t)qemu_get_be64(f); | |
157 | } | |
158 | ||
159 | static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv) | |
160 | { | |
161 | qemu_put_8s(f, (const uint8_t *)pv); | |
162 | } | |
163 | ||
164 | static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv) | |
165 | { | |
166 | qemu_put_be16s(f, (const uint16_t *)pv); | |
167 | } | |
168 | ||
169 | static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv) | |
170 | { | |
171 | qemu_put_be32s(f, (const uint32_t *)pv); | |
172 | } | |
173 | ||
174 | static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv) | |
175 | { | |
176 | qemu_put_be64s(f, (const uint64_t *)pv); | |
177 | } | |
178 | ||
179 | static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv) | |
180 | { | |
181 | qemu_get_8s(f, (uint8_t *)pv); | |
182 | } | |
183 | ||
184 | static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv) | |
185 | { | |
186 | qemu_get_be16s(f, (uint16_t *)pv); | |
187 | } | |
188 | ||
189 | static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv) | |
190 | { | |
191 | qemu_get_be32s(f, (uint32_t *)pv); | |
192 | } | |
193 | ||
194 | static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv) | |
195 | { | |
196 | qemu_get_be64s(f, (uint64_t *)pv); | |
197 | } | |
198 | ||
87ecb68b PB |
199 | #ifdef NEED_CPU_H |
200 | #if TARGET_LONG_BITS == 64 | |
201 | #define qemu_put_betl qemu_put_be64 | |
202 | #define qemu_get_betl qemu_get_be64 | |
203 | #define qemu_put_betls qemu_put_be64s | |
204 | #define qemu_get_betls qemu_get_be64s | |
b6c4f71f BS |
205 | #define qemu_put_sbetl qemu_put_sbe64 |
206 | #define qemu_get_sbetl qemu_get_sbe64 | |
207 | #define qemu_put_sbetls qemu_put_sbe64s | |
208 | #define qemu_get_sbetls qemu_get_sbe64s | |
87ecb68b PB |
209 | #else |
210 | #define qemu_put_betl qemu_put_be32 | |
211 | #define qemu_get_betl qemu_get_be32 | |
212 | #define qemu_put_betls qemu_put_be32s | |
213 | #define qemu_get_betls qemu_get_be32s | |
b6c4f71f BS |
214 | #define qemu_put_sbetl qemu_put_sbe32 |
215 | #define qemu_get_sbetl qemu_get_sbe32 | |
216 | #define qemu_put_sbetls qemu_put_sbe32s | |
217 | #define qemu_get_sbetls qemu_get_sbe32s | |
87ecb68b PB |
218 | #endif |
219 | #endif | |
220 | ||
221 | int64_t qemu_ftell(QEMUFile *f); | |
222 | int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence); | |
223 | ||
224 | typedef void SaveStateHandler(QEMUFile *f, void *opaque); | |
9366f418 | 225 | typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque); |
87ecb68b PB |
226 | typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id); |
227 | ||
228 | int register_savevm(const char *idstr, | |
229 | int instance_id, | |
230 | int version_id, | |
231 | SaveStateHandler *save_state, | |
232 | LoadStateHandler *load_state, | |
233 | void *opaque); | |
234 | ||
9366f418 AL |
235 | int register_savevm_live(const char *idstr, |
236 | int instance_id, | |
237 | int version_id, | |
238 | SaveLiveStateHandler *save_live_state, | |
239 | SaveStateHandler *save_state, | |
240 | LoadStateHandler *load_state, | |
241 | void *opaque); | |
242 | ||
00f56b3d AL |
243 | void unregister_savevm(const char *idstr, void *opaque); |
244 | ||
87ecb68b PB |
245 | typedef void QEMUResetHandler(void *opaque); |
246 | ||
247 | void qemu_register_reset(QEMUResetHandler *func, void *opaque); | |
248 | ||
0ecdffbb AJ |
249 | /* handler to set the boot_device for a specific type of QEMUMachine */ |
250 | /* return 0 if success */ | |
3b4366de BS |
251 | typedef int QEMUBootSetHandler(void *opaque, const char *boot_device); |
252 | void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque); | |
0ecdffbb | 253 | |
87ecb68b PB |
254 | /* These should really be in isa.h, but are here to make pc.h happy. */ |
255 | typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data); | |
256 | typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address); | |
257 | ||
258 | #endif |