2 * QEMU buffered QEMUFile
4 * Copyright IBM, Corp. 2008
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
14 #include "qemu-common.h"
16 #include "qemu-timer.h"
18 #include "qemu-char.h"
19 #include "buffered_file.h"
21 //#define DEBUG_BUFFERED_FILE
23 typedef struct QEMUFileBuffered
25 BufferedPutFunc
*put_buffer
;
26 BufferedPutReadyFunc
*put_ready
;
27 BufferedWaitForUnfreezeFunc
*wait_for_unfreeze
;
28 BufferedCloseFunc
*close
;
37 size_t buffer_capacity
;
41 #ifdef DEBUG_BUFFERED_FILE
42 #define DPRINTF(fmt, ...) \
43 do { printf("buffered-file: " fmt, ## __VA_ARGS__); } while (0)
45 #define DPRINTF(fmt, ...) \
49 static void buffered_append(QEMUFileBuffered
*s
,
50 const uint8_t *buf
, size_t size
)
52 if (size
> (s
->buffer_capacity
- s
->buffer_size
)) {
55 DPRINTF("increasing buffer capacity from %zu by %zu\n",
56 s
->buffer_capacity
, size
+ 1024);
58 s
->buffer_capacity
+= size
+ 1024;
60 tmp
= qemu_realloc(s
->buffer
, s
->buffer_capacity
);
62 fprintf(stderr
, "qemu file buffer expansion failed\n");
69 memcpy(s
->buffer
+ s
->buffer_size
, buf
, size
);
70 s
->buffer_size
+= size
;
73 static void buffered_flush(QEMUFileBuffered
*s
)
78 DPRINTF("flush when error, bailing\n");
82 DPRINTF("flushing %zu byte(s) of data\n", s
->buffer_size
);
84 while (offset
< s
->buffer_size
) {
87 ret
= s
->put_buffer(s
->opaque
, s
->buffer
+ offset
,
88 s
->buffer_size
- offset
);
90 DPRINTF("backend not ready, freezing\n");
96 DPRINTF("error flushing data, %zd\n", ret
);
100 DPRINTF("flushed %zd byte(s)\n", ret
);
105 DPRINTF("flushed %zu of %zu byte(s)\n", offset
, s
->buffer_size
);
106 memmove(s
->buffer
, s
->buffer
+ offset
, s
->buffer_size
- offset
);
107 s
->buffer_size
-= offset
;
110 static int buffered_put_buffer(void *opaque
, const uint8_t *buf
, int64_t pos
, int size
)
112 QEMUFileBuffered
*s
= opaque
;
116 DPRINTF("putting %d bytes at %" PRId64
"\n", size
, pos
);
119 DPRINTF("flush when error, bailing\n");
123 DPRINTF("unfreezing output\n");
124 s
->freeze_output
= 0;
128 while (!s
->freeze_output
&& offset
< size
) {
129 if (s
->bytes_xfer
> s
->xfer_limit
) {
130 DPRINTF("transfer limit exceeded when putting\n");
134 ret
= s
->put_buffer(s
->opaque
, buf
+ offset
, size
- offset
);
135 if (ret
== -EAGAIN
) {
136 DPRINTF("backend not ready, freezing\n");
137 s
->freeze_output
= 1;
142 DPRINTF("error putting\n");
148 DPRINTF("put %zd byte(s)\n", ret
);
150 s
->bytes_xfer
+= ret
;
154 DPRINTF("buffering %d bytes\n", size
- offset
);
155 buffered_append(s
, buf
+ offset
, size
- offset
);
159 if (pos
== 0 && size
== 0) {
160 DPRINTF("file is ready\n");
161 if (s
->bytes_xfer
<= s
->xfer_limit
) {
162 DPRINTF("notifying client\n");
163 s
->put_ready(s
->opaque
);
170 static int buffered_close(void *opaque
)
172 QEMUFileBuffered
*s
= opaque
;
175 DPRINTF("closing\n");
177 while (!s
->has_error
&& s
->buffer_size
) {
179 if (s
->freeze_output
)
180 s
->wait_for_unfreeze(s
);
183 ret
= s
->close(s
->opaque
);
185 qemu_del_timer(s
->timer
);
186 qemu_free_timer(s
->timer
);
187 qemu_free(s
->buffer
);
193 static int buffered_rate_limit(void *opaque
)
195 QEMUFileBuffered
*s
= opaque
;
200 if (s
->freeze_output
)
203 if (s
->bytes_xfer
> s
->xfer_limit
)
209 static int64_t buffered_set_rate_limit(void *opaque
, int64_t new_rate
)
211 QEMUFileBuffered
*s
= opaque
;
215 if (new_rate
> SIZE_MAX
) {
219 s
->xfer_limit
= new_rate
/ 10;
222 return s
->xfer_limit
;
225 static int64_t buffered_get_rate_limit(void *opaque
)
227 QEMUFileBuffered
*s
= opaque
;
229 return s
->xfer_limit
;
232 static void buffered_rate_tick(void *opaque
)
234 QEMUFileBuffered
*s
= opaque
;
241 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 100);
243 if (s
->freeze_output
)
250 /* Add some checks around this */
251 s
->put_ready(s
->opaque
);
254 QEMUFile
*qemu_fopen_ops_buffered(void *opaque
,
255 size_t bytes_per_sec
,
256 BufferedPutFunc
*put_buffer
,
257 BufferedPutReadyFunc
*put_ready
,
258 BufferedWaitForUnfreezeFunc
*wait_for_unfreeze
,
259 BufferedCloseFunc
*close
)
263 s
= qemu_mallocz(sizeof(*s
));
266 s
->xfer_limit
= bytes_per_sec
/ 10;
267 s
->put_buffer
= put_buffer
;
268 s
->put_ready
= put_ready
;
269 s
->wait_for_unfreeze
= wait_for_unfreeze
;
272 s
->file
= qemu_fopen_ops(s
, buffered_put_buffer
, NULL
,
273 buffered_close
, buffered_rate_limit
,
274 buffered_set_rate_limit
,
275 buffered_get_rate_limit
);
277 s
->timer
= qemu_new_timer(rt_clock
, buffered_rate_tick
, s
);
279 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 100);