]>
Commit | Line | Data |
---|---|---|
701a8f76 PB |
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 | ||
70eb6330 PB |
50 | /* Called to return the OS file descriptor associated to the QEMUFile. |
51 | */ | |
52 | typedef int (QEMUFileGetFD)(void *opaque); | |
53 | ||
d913829f OW |
54 | /* |
55 | * This function writes an iovec to file. | |
56 | */ | |
57 | typedef ssize_t (QEMUFileWritevBufferFunc)(void *opaque, struct iovec *iov, | |
05fcc848 | 58 | int iovcnt, int64_t pos); |
d913829f | 59 | |
9229bf3c PB |
60 | typedef struct QEMUFileOps { |
61 | QEMUFilePutBufferFunc *put_buffer; | |
62 | QEMUFileGetBufferFunc *get_buffer; | |
63 | QEMUFileCloseFunc *close; | |
70eb6330 | 64 | QEMUFileGetFD *get_fd; |
d913829f | 65 | QEMUFileWritevBufferFunc *writev_buffer; |
9229bf3c PB |
66 | } QEMUFileOps; |
67 | ||
68 | QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops); | |
701a8f76 PB |
69 | QEMUFile *qemu_fopen(const char *filename, const char *mode); |
70 | QEMUFile *qemu_fdopen(int fd, const char *mode); | |
0cc3f3cc | 71 | QEMUFile *qemu_fopen_socket(int fd, const char *mode); |
701a8f76 | 72 | QEMUFile *qemu_popen_cmd(const char *command, const char *mode); |
70eb6330 | 73 | int qemu_get_fd(QEMUFile *f); |
701a8f76 | 74 | int qemu_fclose(QEMUFile *f); |
ad55ab42 | 75 | int64_t qemu_ftell(QEMUFile *f); |
701a8f76 PB |
76 | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size); |
77 | void qemu_put_byte(QEMUFile *f, int v); | |
6181ec24 OW |
78 | /* |
79 | * put_buffer without copying the buffer. | |
80 | * The buffer should be available till it is sent asynchronously. | |
81 | */ | |
82 | void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size); | |
701a8f76 PB |
83 | |
84 | static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) | |
85 | { | |
86 | qemu_put_byte(f, (int)v); | |
87 | } | |
88 | ||
89 | #define qemu_put_sbyte qemu_put_byte | |
90 | ||
91 | void qemu_put_be16(QEMUFile *f, unsigned int v); | |
92 | void qemu_put_be32(QEMUFile *f, unsigned int v); | |
93 | void qemu_put_be64(QEMUFile *f, uint64_t v); | |
94 | int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size); | |
95 | int qemu_get_byte(QEMUFile *f); | |
96 | ||
97 | static inline unsigned int qemu_get_ubyte(QEMUFile *f) | |
98 | { | |
99 | return (unsigned int)qemu_get_byte(f); | |
100 | } | |
101 | ||
102 | #define qemu_get_sbyte qemu_get_byte | |
103 | ||
104 | unsigned int qemu_get_be16(QEMUFile *f); | |
105 | unsigned int qemu_get_be32(QEMUFile *f); | |
106 | uint64_t qemu_get_be64(QEMUFile *f); | |
107 | ||
108 | int qemu_file_rate_limit(QEMUFile *f); | |
1964a397 PB |
109 | void qemu_file_reset_rate_limit(QEMUFile *f); |
110 | void qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate); | |
701a8f76 PB |
111 | int64_t qemu_file_get_rate_limit(QEMUFile *f); |
112 | int qemu_file_get_error(QEMUFile *f); | |
701a8f76 | 113 | |
701a8f76 PB |
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 | } | |
701a8f76 | 234 | #endif |