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
;
30 MigrationState
*migration_state
;
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 (s
->bytes_xfer
< s
->xfer_limit
&& offset
< s
->buffer_size
) {
81 ret
= s
->put_buffer(s
->migration_state
, 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
);
100 DPRINTF("flushed %zu of %zu byte(s)\n", offset
, s
->buffer_size
);
101 memmove(s
->buffer
, s
->buffer
+ offset
, s
->buffer_size
- offset
);
102 s
->buffer_size
-= offset
;
105 static int buffered_put_buffer(void *opaque
, const uint8_t *buf
, int64_t pos
, int size
)
107 QEMUFileBuffered
*s
= opaque
;
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;
122 DPRINTF("buffering %d bytes\n", size
- offset
);
123 buffered_append(s
, buf
, size
);
128 if (pos
== 0 && size
== 0) {
129 DPRINTF("file is ready\n");
130 if (!s
->freeze_output
&& s
->bytes_xfer
< s
->xfer_limit
) {
131 DPRINTF("notifying client\n");
132 s
->put_ready(s
->migration_state
);
139 static int buffered_close(void *opaque
)
141 QEMUFileBuffered
*s
= opaque
;
144 DPRINTF("closing\n");
146 s
->xfer_limit
= INT_MAX
;
147 while (!qemu_file_get_error(s
->file
) && s
->buffer_size
) {
149 if (s
->freeze_output
)
150 s
->wait_for_unfreeze(s
->migration_state
);
153 ret
= s
->close(s
->migration_state
);
155 qemu_del_timer(s
->timer
);
156 qemu_free_timer(s
->timer
);
164 * The meaning of the return values is:
165 * 0: We can continue sending
167 * negative: There has been an error
169 static int buffered_rate_limit(void *opaque
)
171 QEMUFileBuffered
*s
= opaque
;
174 ret
= qemu_file_get_error(s
->file
);
178 if (s
->freeze_output
)
181 if (s
->bytes_xfer
> s
->xfer_limit
)
187 static int64_t buffered_set_rate_limit(void *opaque
, int64_t new_rate
)
189 QEMUFileBuffered
*s
= opaque
;
190 if (qemu_file_get_error(s
->file
)) {
193 if (new_rate
> SIZE_MAX
) {
197 s
->xfer_limit
= new_rate
/ 10;
200 return s
->xfer_limit
;
203 static int64_t buffered_get_rate_limit(void *opaque
)
205 QEMUFileBuffered
*s
= opaque
;
207 return s
->xfer_limit
;
210 static void buffered_rate_tick(void *opaque
)
212 QEMUFileBuffered
*s
= opaque
;
214 if (qemu_file_get_error(s
->file
)) {
219 qemu_mod_timer(s
->timer
, qemu_get_clock_ms(rt_clock
) + 100);
221 if (s
->freeze_output
)
226 buffered_put_buffer(s
, NULL
, 0, 0);
229 QEMUFile
*qemu_fopen_ops_buffered(MigrationState
*migration_state
,
230 size_t bytes_per_sec
,
231 BufferedPutFunc
*put_buffer
,
232 BufferedPutReadyFunc
*put_ready
,
233 BufferedWaitForUnfreezeFunc
*wait_for_unfreeze
,
234 BufferedCloseFunc
*close
)
238 s
= g_malloc0(sizeof(*s
));
240 s
->migration_state
= migration_state
;
241 s
->xfer_limit
= bytes_per_sec
/ 10;
242 s
->put_buffer
= put_buffer
;
243 s
->put_ready
= put_ready
;
244 s
->wait_for_unfreeze
= wait_for_unfreeze
;
247 s
->file
= qemu_fopen_ops(s
, buffered_put_buffer
, NULL
,
248 buffered_close
, buffered_rate_limit
,
249 buffered_set_rate_limit
,
250 buffered_get_rate_limit
);
252 s
->timer
= qemu_new_timer_ms(rt_clock
, buffered_rate_tick
, s
);
254 qemu_mod_timer(s
->timer
, qemu_get_clock_ms(rt_clock
) + 100);