PPC: e500mc: add missing IVORs to bitmap
[qemu.git] / qemu-file.h
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #ifndef QEMU_FILE_H
25 #define QEMU_FILE_H 1
26
27 /* This function writes a chunk of data to a file at the given position.
28 * The pos argument can be ignored if the file is only being used for
29 * streaming. The handler should try to write all of the data it can.
30 */
31 typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
32 int64_t pos, int size);
33
34 /* Read a chunk of data from a file at the given position. The pos argument
35 * can be ignored if the file is only be used for streaming. The number of
36 * bytes actually read should be returned.
37 */
38 typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,
39 int64_t pos, int size);
40
41 /* Close a file
42 *
43 * Return negative error number on error, 0 or positive value on success.
44 *
45 * The meaning of return value on success depends on the specific back-end being
46 * used.
47 */
48 typedef int (QEMUFileCloseFunc)(void *opaque);
49
50 /* Called to determine if the file has exceeded it's bandwidth allocation. The
51 * bandwidth capping is a soft limit, not a hard limit.
52 */
53 typedef int (QEMUFileRateLimit)(void *opaque);
54
55 /* Called to change the current bandwidth allocation. This function must return
56 * the new actual bandwidth. It should be new_rate if everything goes ok, and
57 * the old rate otherwise
58 */
59 typedef int64_t (QEMUFileSetRateLimit)(void *opaque, int64_t new_rate);
60 typedef int64_t (QEMUFileGetRateLimit)(void *opaque);
61
62 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
63 QEMUFileGetBufferFunc *get_buffer,
64 QEMUFileCloseFunc *close,
65 QEMUFileRateLimit *rate_limit,
66 QEMUFileSetRateLimit *set_rate_limit,
67 QEMUFileGetRateLimit *get_rate_limit);
68 QEMUFile *qemu_fopen(const char *filename, const char *mode);
69 QEMUFile *qemu_fdopen(int fd, const char *mode);
70 QEMUFile *qemu_fopen_socket(int fd);
71 QEMUFile *qemu_popen(FILE *popen_file, const char *mode);
72 QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
73 int qemu_stdio_fd(QEMUFile *f);
74 void qemu_fflush(QEMUFile *f);
75 int qemu_fclose(QEMUFile *f);
76 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
77 void qemu_put_byte(QEMUFile *f, int v);
78
79 static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
80 {
81 qemu_put_byte(f, (int)v);
82 }
83
84 #define qemu_put_sbyte qemu_put_byte
85
86 void qemu_put_be16(QEMUFile *f, unsigned int v);
87 void qemu_put_be32(QEMUFile *f, unsigned int v);
88 void qemu_put_be64(QEMUFile *f, uint64_t v);
89 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
90 int qemu_get_byte(QEMUFile *f);
91
92 static inline unsigned int qemu_get_ubyte(QEMUFile *f)
93 {
94 return (unsigned int)qemu_get_byte(f);
95 }
96
97 #define qemu_get_sbyte qemu_get_byte
98
99 unsigned int qemu_get_be16(QEMUFile *f);
100 unsigned int qemu_get_be32(QEMUFile *f);
101 uint64_t qemu_get_be64(QEMUFile *f);
102
103 int qemu_file_rate_limit(QEMUFile *f);
104 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate);
105 int64_t qemu_file_get_rate_limit(QEMUFile *f);
106 int qemu_file_get_error(QEMUFile *f);
107 void qemu_file_set_error(QEMUFile *f, int error);
108
109 /* Try to send any outstanding data. This function is useful when output is
110 * halted due to rate limiting or EAGAIN errors occur as it can be used to
111 * resume output. */
112 void qemu_file_put_notify(QEMUFile *f);
113
114 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
115 {
116 qemu_put_be64(f, *pv);
117 }
118
119 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
120 {
121 qemu_put_be32(f, *pv);
122 }
123
124 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
125 {
126 qemu_put_be16(f, *pv);
127 }
128
129 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
130 {
131 qemu_put_byte(f, *pv);
132 }
133
134 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
135 {
136 *pv = qemu_get_be64(f);
137 }
138
139 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
140 {
141 *pv = qemu_get_be32(f);
142 }
143
144 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
145 {
146 *pv = qemu_get_be16(f);
147 }
148
149 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
150 {
151 *pv = qemu_get_byte(f);
152 }
153
154 // Signed versions for type safety
155 static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)
156 {
157 qemu_put_buffer(f, (const uint8_t *)buf, size);
158 }
159
160 static inline void qemu_put_sbe16(QEMUFile *f, int v)
161 {
162 qemu_put_be16(f, (unsigned int)v);
163 }
164
165 static inline void qemu_put_sbe32(QEMUFile *f, int v)
166 {
167 qemu_put_be32(f, (unsigned int)v);
168 }
169
170 static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
171 {
172 qemu_put_be64(f, (uint64_t)v);
173 }
174
175 static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)
176 {
177 return qemu_get_buffer(f, (uint8_t *)buf, size);
178 }
179
180 static inline int qemu_get_sbe16(QEMUFile *f)
181 {
182 return (int)qemu_get_be16(f);
183 }
184
185 static inline int qemu_get_sbe32(QEMUFile *f)
186 {
187 return (int)qemu_get_be32(f);
188 }
189
190 static inline int64_t qemu_get_sbe64(QEMUFile *f)
191 {
192 return (int64_t)qemu_get_be64(f);
193 }
194
195 static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
196 {
197 qemu_put_8s(f, (const uint8_t *)pv);
198 }
199
200 static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
201 {
202 qemu_put_be16s(f, (const uint16_t *)pv);
203 }
204
205 static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
206 {
207 qemu_put_be32s(f, (const uint32_t *)pv);
208 }
209
210 static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
211 {
212 qemu_put_be64s(f, (const uint64_t *)pv);
213 }
214
215 static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
216 {
217 qemu_get_8s(f, (uint8_t *)pv);
218 }
219
220 static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
221 {
222 qemu_get_be16s(f, (uint16_t *)pv);
223 }
224
225 static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
226 {
227 qemu_get_be32s(f, (uint32_t *)pv);
228 }
229
230 static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
231 {
232 qemu_get_be64s(f, (uint64_t *)pv);
233 }
234
235 int64_t qemu_ftell(QEMUFile *f);
236 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
237
238 #endif