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