Statistics
| Branch: | Revision:

root / qemu-file.h @ 93148aa5

History | View | Annotate | Download (7 kB)

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 its 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