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.
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
16 #include "qemu-common.h"
18 #include "qemu-timer.h"
19 #include "qemu-char.h"
20 #include "buffered_file.h"
22 //#define DEBUG_BUFFERED_FILE
24 typedef struct QEMUFileBuffered
26 BufferedPutFunc
*put_buffer
;
27 BufferedPutReadyFunc
*put_ready
;
28 BufferedWaitForUnfreezeFunc
*wait_for_unfreeze
;
29 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
)) {
53 DPRINTF("increasing buffer capacity from %zu by %zu\n",
54 s
->buffer_capacity
, size
+ 1024);
56 s
->buffer_capacity
+= size
+ 1024;
58 s
->buffer
= g_realloc(s
->buffer
, s
->buffer_capacity
);
61 memcpy(s
->buffer
+ s
->buffer_size
, buf
, size
);
62 s
->buffer_size
+= size
;
65 static void buffered_flush(QEMUFileBuffered
*s
)
70 error
= qemu_file_get_error(s
->file
);
72 DPRINTF("flush when error, bailing: %s\n", strerror(-error
));
76 DPRINTF("flushing %zu byte(s) of data\n", s
->buffer_size
);
78 while (offset
< s
->buffer_size
) {
81 ret
= s
->put_buffer(s
->opaque
, s
->buffer
+ offset
,
82 s
->buffer_size
- offset
);
84 DPRINTF("backend not ready, freezing\n");
90 DPRINTF("error flushing data, %zd\n", ret
);
91 qemu_file_set_error(s
->file
, ret
);
94 DPRINTF("flushed %zd byte(s)\n", ret
);
99 DPRINTF("flushed %zu of %zu byte(s)\n", offset
, s
->buffer_size
);
100 memmove(s
->buffer
, s
->buffer
+ offset
, s
->buffer_size
- offset
);
101 s
->buffer_size
-= offset
;
104 static int buffered_put_buffer(void *opaque
, const uint8_t *buf
, int64_t pos
, int size
)
106 QEMUFileBuffered
*s
= opaque
;
107 int offset
= 0, error
;
110 DPRINTF("putting %d bytes at %" PRId64
"\n", size
, pos
);
112 error
= qemu_file_get_error(s
->file
);
114 DPRINTF("flush when error, bailing: %s\n", strerror(-error
));
118 DPRINTF("unfreezing output\n");
119 s
->freeze_output
= 0;
123 while (!s
->freeze_output
&& offset
< size
) {
124 if (s
->bytes_xfer
> s
->xfer_limit
) {
125 DPRINTF("transfer limit exceeded when putting\n");
129 ret
= s
->put_buffer(s
->opaque
, buf
+ offset
, size
- offset
);
130 if (ret
== -EAGAIN
) {
131 DPRINTF("backend not ready, freezing\n");
132 s
->freeze_output
= 1;
137 DPRINTF("error putting\n");
138 qemu_file_set_error(s
->file
, ret
);
143 DPRINTF("put %zd byte(s)\n", ret
);
145 s
->bytes_xfer
+= ret
;
149 DPRINTF("buffering %d bytes\n", size
- offset
);
150 buffered_append(s
, buf
+ offset
, size
- offset
);
154 if (pos
== 0 && size
== 0) {
155 DPRINTF("file is ready\n");
156 if (s
->bytes_xfer
<= s
->xfer_limit
) {
157 DPRINTF("notifying client\n");
158 s
->put_ready(s
->opaque
);
165 static int buffered_close(void *opaque
)
167 QEMUFileBuffered
*s
= opaque
;
170 DPRINTF("closing\n");
172 while (!qemu_file_get_error(s
->file
) && s
->buffer_size
) {
174 if (s
->freeze_output
)
175 s
->wait_for_unfreeze(s
->opaque
);
178 ret
= s
->close(s
->opaque
);
180 qemu_del_timer(s
->timer
);
181 qemu_free_timer(s
->timer
);
189 * The meaning of the return values is:
190 * 0: We can continue sending
192 * negative: There has been an error
194 static int buffered_rate_limit(void *opaque
)
196 QEMUFileBuffered
*s
= opaque
;
199 ret
= qemu_file_get_error(s
->file
);
203 if (s
->freeze_output
)
206 if (s
->bytes_xfer
> s
->xfer_limit
)
212 static int64_t buffered_set_rate_limit(void *opaque
, int64_t new_rate
)
214 QEMUFileBuffered
*s
= opaque
;
215 if (qemu_file_get_error(s
->file
)) {
218 if (new_rate
> SIZE_MAX
) {
222 s
->xfer_limit
= new_rate
/ 10;
225 return s
->xfer_limit
;
228 static int64_t buffered_get_rate_limit(void *opaque
)
230 QEMUFileBuffered
*s
= opaque
;
232 return s
->xfer_limit
;
235 static void buffered_rate_tick(void *opaque
)
237 QEMUFileBuffered
*s
= opaque
;
239 if (qemu_file_get_error(s
->file
)) {
244 qemu_mod_timer(s
->timer
, qemu_get_clock_ms(rt_clock
) + 100);
246 if (s
->freeze_output
)
253 /* Add some checks around this */
254 s
->put_ready(s
->opaque
);
257 QEMUFile
*qemu_fopen_ops_buffered(void *opaque
,
258 size_t bytes_per_sec
,
259 BufferedPutFunc
*put_buffer
,
260 BufferedPutReadyFunc
*put_ready
,
261 BufferedWaitForUnfreezeFunc
*wait_for_unfreeze
,
262 BufferedCloseFunc
*close
)
266 s
= g_malloc0(sizeof(*s
));
269 s
->xfer_limit
= bytes_per_sec
/ 10;
270 s
->put_buffer
= put_buffer
;
271 s
->put_ready
= put_ready
;
272 s
->wait_for_unfreeze
= wait_for_unfreeze
;
275 s
->file
= qemu_fopen_ops(s
, buffered_put_buffer
, NULL
,
276 buffered_close
, buffered_rate_limit
,
277 buffered_set_rate_limit
,
278 buffered_get_rate_limit
);
280 s
->timer
= qemu_new_timer_ms(rt_clock
, buffered_rate_tick
, s
);
282 qemu_mod_timer(s
->timer
, qemu_get_clock_ms(rt_clock
) + 100);