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