]>
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); | |
87ecb68b | 54 | void qemu_fflush(QEMUFile *f); |
5dafc53f | 55 | int qemu_fclose(QEMUFile *f); |
2ca83a8d BS |
56 | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size); |
57 | void qemu_put_byte(QEMUFile *f, int v); | |
b6c4f71f BS |
58 | |
59 | static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) | |
60 | { | |
61 | qemu_put_byte(f, (int)v); | |
62 | } | |
63 | ||
64 | #define qemu_put_sbyte qemu_put_byte | |
65 | ||
2ca83a8d BS |
66 | void qemu_put_be16(QEMUFile *f, unsigned int v); |
67 | void qemu_put_be32(QEMUFile *f, unsigned int v); | |
87ecb68b | 68 | void qemu_put_be64(QEMUFile *f, uint64_t v); |
2ca83a8d BS |
69 | int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size); |
70 | int qemu_get_byte(QEMUFile *f); | |
b6c4f71f BS |
71 | |
72 | static inline unsigned int qemu_get_ubyte(QEMUFile *f) | |
73 | { | |
74 | return (unsigned int)qemu_get_byte(f); | |
75 | } | |
76 | ||
77 | #define qemu_get_sbyte qemu_get_byte | |
78 | ||
2ca83a8d BS |
79 | unsigned int qemu_get_be16(QEMUFile *f); |
80 | unsigned int qemu_get_be32(QEMUFile *f); | |
87ecb68b | 81 | uint64_t qemu_get_be64(QEMUFile *f); |
5dafc53f | 82 | int qemu_file_rate_limit(QEMUFile *f); |
19629537 | 83 | size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate); |
871d2f07 | 84 | int qemu_file_has_error(QEMUFile *f); |
4dabe248 | 85 | void qemu_file_set_error(QEMUFile *f); |
5dafc53f AL |
86 | |
87 | /* Try to send any outstanding data. This function is useful when output is | |
88 | * halted due to rate limiting or EAGAIN errors occur as it can be used to | |
89 | * resume output. */ | |
90 | void qemu_file_put_notify(QEMUFile *f); | |
87ecb68b PB |
91 | |
92 | static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv) | |
93 | { | |
94 | qemu_put_be64(f, *pv); | |
95 | } | |
96 | ||
97 | static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv) | |
98 | { | |
99 | qemu_put_be32(f, *pv); | |
100 | } | |
101 | ||
102 | static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv) | |
103 | { | |
104 | qemu_put_be16(f, *pv); | |
105 | } | |
106 | ||
107 | static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv) | |
108 | { | |
109 | qemu_put_byte(f, *pv); | |
110 | } | |
111 | ||
112 | static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv) | |
113 | { | |
114 | *pv = qemu_get_be64(f); | |
115 | } | |
116 | ||
117 | static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv) | |
118 | { | |
119 | *pv = qemu_get_be32(f); | |
120 | } | |
121 | ||
122 | static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv) | |
123 | { | |
124 | *pv = qemu_get_be16(f); | |
125 | } | |
126 | ||
127 | static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv) | |
128 | { | |
129 | *pv = qemu_get_byte(f); | |
130 | } | |
131 | ||
b6c4f71f BS |
132 | // Signed versions for type safety |
133 | static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size) | |
134 | { | |
135 | qemu_put_buffer(f, (const uint8_t *)buf, size); | |
136 | } | |
137 | ||
138 | static inline void qemu_put_sbe16(QEMUFile *f, int v) | |
139 | { | |
140 | qemu_put_be16(f, (unsigned int)v); | |
141 | } | |
142 | ||
143 | static inline void qemu_put_sbe32(QEMUFile *f, int v) | |
144 | { | |
145 | qemu_put_be32(f, (unsigned int)v); | |
146 | } | |
147 | ||
148 | static inline void qemu_put_sbe64(QEMUFile *f, int64_t v) | |
149 | { | |
150 | qemu_put_be64(f, (uint64_t)v); | |
151 | } | |
152 | ||
153 | static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size) | |
154 | { | |
155 | return qemu_get_buffer(f, (uint8_t *)buf, size); | |
156 | } | |
157 | ||
158 | static inline int qemu_get_sbe16(QEMUFile *f) | |
159 | { | |
160 | return (int)qemu_get_be16(f); | |
161 | } | |
162 | ||
163 | static inline int qemu_get_sbe32(QEMUFile *f) | |
164 | { | |
165 | return (int)qemu_get_be32(f); | |
166 | } | |
167 | ||
168 | static inline int64_t qemu_get_sbe64(QEMUFile *f) | |
169 | { | |
170 | return (int64_t)qemu_get_be64(f); | |
171 | } | |
172 | ||
173 | static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv) | |
174 | { | |
175 | qemu_put_8s(f, (const uint8_t *)pv); | |
176 | } | |
177 | ||
178 | static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv) | |
179 | { | |
180 | qemu_put_be16s(f, (const uint16_t *)pv); | |
181 | } | |
182 | ||
183 | static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv) | |
184 | { | |
185 | qemu_put_be32s(f, (const uint32_t *)pv); | |
186 | } | |
187 | ||
188 | static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv) | |
189 | { | |
190 | qemu_put_be64s(f, (const uint64_t *)pv); | |
191 | } | |
192 | ||
193 | static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv) | |
194 | { | |
195 | qemu_get_8s(f, (uint8_t *)pv); | |
196 | } | |
197 | ||
198 | static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv) | |
199 | { | |
200 | qemu_get_be16s(f, (uint16_t *)pv); | |
201 | } | |
202 | ||
203 | static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv) | |
204 | { | |
205 | qemu_get_be32s(f, (uint32_t *)pv); | |
206 | } | |
207 | ||
208 | static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv) | |
209 | { | |
210 | qemu_get_be64s(f, (uint64_t *)pv); | |
211 | } | |
212 | ||
87ecb68b PB |
213 | #ifdef NEED_CPU_H |
214 | #if TARGET_LONG_BITS == 64 | |
215 | #define qemu_put_betl qemu_put_be64 | |
216 | #define qemu_get_betl qemu_get_be64 | |
217 | #define qemu_put_betls qemu_put_be64s | |
218 | #define qemu_get_betls qemu_get_be64s | |
b6c4f71f BS |
219 | #define qemu_put_sbetl qemu_put_sbe64 |
220 | #define qemu_get_sbetl qemu_get_sbe64 | |
221 | #define qemu_put_sbetls qemu_put_sbe64s | |
222 | #define qemu_get_sbetls qemu_get_sbe64s | |
87ecb68b PB |
223 | #else |
224 | #define qemu_put_betl qemu_put_be32 | |
225 | #define qemu_get_betl qemu_get_be32 | |
226 | #define qemu_put_betls qemu_put_be32s | |
227 | #define qemu_get_betls qemu_get_be32s | |
b6c4f71f BS |
228 | #define qemu_put_sbetl qemu_put_sbe32 |
229 | #define qemu_get_sbetl qemu_get_sbe32 | |
230 | #define qemu_put_sbetls qemu_put_sbe32s | |
231 | #define qemu_get_sbetls qemu_get_sbe32s | |
87ecb68b PB |
232 | #endif |
233 | #endif | |
234 | ||
235 | int64_t qemu_ftell(QEMUFile *f); | |
236 | int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence); | |
237 | ||
238 | typedef void SaveStateHandler(QEMUFile *f, void *opaque); | |
9366f418 | 239 | typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque); |
87ecb68b PB |
240 | typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id); |
241 | ||
242 | int register_savevm(const char *idstr, | |
243 | int instance_id, | |
244 | int version_id, | |
245 | SaveStateHandler *save_state, | |
246 | LoadStateHandler *load_state, | |
247 | void *opaque); | |
248 | ||
9366f418 AL |
249 | int register_savevm_live(const char *idstr, |
250 | int instance_id, | |
251 | int version_id, | |
252 | SaveLiveStateHandler *save_live_state, | |
253 | SaveStateHandler *save_state, | |
254 | LoadStateHandler *load_state, | |
255 | void *opaque); | |
256 | ||
41bd13af AL |
257 | void unregister_savevm(const char *idstr, void *opaque); |
258 | ||
87ecb68b PB |
259 | typedef void QEMUResetHandler(void *opaque); |
260 | ||
261 | void qemu_register_reset(QEMUResetHandler *func, void *opaque); | |
262 | ||
0ecdffbb AJ |
263 | /* handler to set the boot_device for a specific type of QEMUMachine */ |
264 | /* return 0 if success */ | |
3b4366de BS |
265 | typedef int QEMUBootSetHandler(void *opaque, const char *boot_device); |
266 | void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque); | |
0ecdffbb | 267 | |
87ecb68b PB |
268 | /* These should really be in isa.h, but are here to make pc.h happy. */ |
269 | typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data); | |
270 | typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address); | |
271 | ||
272 | #endif |