]>
Commit | Line | Data |
---|---|---|
ea2384d3 FB |
1 | /* |
2 | * QEMU System Emulator block driver | |
5fafdf24 | 3 | * |
ea2384d3 | 4 | * Copyright (c) 2003 Fabrice Bellard |
5fafdf24 | 5 | * |
ea2384d3 FB |
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 BLOCK_INT_H | |
25 | #define BLOCK_INT_H | |
26 | ||
faf07963 | 27 | #include "block.h" |
0e7e1989 | 28 | #include "qemu-option.h" |
1b7bdbc1 | 29 | #include "qemu-queue.h" |
da1fa91d | 30 | #include "qemu-coroutine.h" |
c488c7f6 | 31 | #include "qemu-timer.h" |
b2023818 | 32 | #include "qapi-types.h" |
9aeaddff | 33 | #include "qerror.h" |
faf07963 | 34 | |
bfe8043e SH |
35 | #define BLOCK_FLAG_ENCRYPT 1 |
36 | #define BLOCK_FLAG_COMPAT6 4 | |
37 | #define BLOCK_FLAG_LAZY_REFCOUNTS 8 | |
ec36ba14 | 38 | |
0563e191 ZYW |
39 | #define BLOCK_IO_LIMIT_READ 0 |
40 | #define BLOCK_IO_LIMIT_WRITE 1 | |
41 | #define BLOCK_IO_LIMIT_TOTAL 2 | |
42 | ||
43 | #define BLOCK_IO_SLICE_TIME 100000000 | |
98f90dba | 44 | #define NANOSECONDS_PER_SECOND 1000000000.0 |
0563e191 | 45 | |
bfe8043e SH |
46 | #define BLOCK_OPT_SIZE "size" |
47 | #define BLOCK_OPT_ENCRYPT "encryption" | |
48 | #define BLOCK_OPT_COMPAT6 "compat6" | |
49 | #define BLOCK_OPT_BACKING_FILE "backing_file" | |
50 | #define BLOCK_OPT_BACKING_FMT "backing_fmt" | |
51 | #define BLOCK_OPT_CLUSTER_SIZE "cluster_size" | |
52 | #define BLOCK_OPT_TABLE_SIZE "table_size" | |
53 | #define BLOCK_OPT_PREALLOC "preallocation" | |
54 | #define BLOCK_OPT_SUBFMT "subformat" | |
55 | #define BLOCK_OPT_COMPAT_LEVEL "compat" | |
56 | #define BLOCK_OPT_LAZY_REFCOUNTS "lazy_refcounts" | |
0e7e1989 | 57 | |
dbffbdcf SH |
58 | typedef struct BdrvTrackedRequest BdrvTrackedRequest; |
59 | ||
0563e191 ZYW |
60 | typedef struct BlockIOLimit { |
61 | int64_t bps[3]; | |
62 | int64_t iops[3]; | |
63 | } BlockIOLimit; | |
64 | ||
65 | typedef struct BlockIOBaseValue { | |
66 | uint64_t bytes[2]; | |
67 | uint64_t ios[2]; | |
68 | } BlockIOBaseValue; | |
69 | ||
eeec61f2 | 70 | typedef struct BlockJob BlockJob; |
dc534f8f PB |
71 | |
72 | /** | |
73 | * BlockJobType: | |
74 | * | |
75 | * A class type for block job objects. | |
76 | */ | |
eeec61f2 SH |
77 | typedef struct BlockJobType { |
78 | /** Derived BlockJob struct size */ | |
79 | size_t instance_size; | |
80 | ||
81 | /** String describing the operation, part of query-block-jobs QMP API */ | |
82 | const char *job_type; | |
83 | ||
84 | /** Optional callback for job types that support setting a speed limit */ | |
882ec7ce | 85 | void (*set_speed)(BlockJob *job, int64_t speed, Error **errp); |
eeec61f2 SH |
86 | } BlockJobType; |
87 | ||
88 | /** | |
dc534f8f PB |
89 | * BlockJob: |
90 | * | |
91 | * Long-running operation on a BlockDriverState. | |
eeec61f2 SH |
92 | */ |
93 | struct BlockJob { | |
dc534f8f | 94 | /** The job type, including the job vtable. */ |
eeec61f2 | 95 | const BlockJobType *job_type; |
dc534f8f PB |
96 | |
97 | /** The block device on which the job is operating. */ | |
eeec61f2 | 98 | BlockDriverState *bs; |
dc534f8f | 99 | |
fa4478d5 PB |
100 | /** |
101 | * The coroutine that executes the job. If not NULL, it is | |
102 | * reentered when busy is false and the job is cancelled. | |
103 | */ | |
104 | Coroutine *co; | |
105 | ||
dc534f8f PB |
106 | /** |
107 | * Set to true if the job should cancel itself. The flag must | |
108 | * always be tested just before toggling the busy flag from false | |
4513eafe PB |
109 | * to true. After a job has been cancelled, it should only yield |
110 | * if #qemu_aio_wait will ("sooner or later") reenter the coroutine. | |
dc534f8f | 111 | */ |
eeec61f2 | 112 | bool cancelled; |
dc534f8f PB |
113 | |
114 | /** | |
115 | * Set to false by the job while it is in a quiescent state, where | |
4513eafe PB |
116 | * no I/O is pending and the job has yielded on any condition |
117 | * that is not detected by #qemu_aio_wait, such as a timer. | |
dc534f8f | 118 | */ |
3e914655 | 119 | bool busy; |
eeec61f2 | 120 | |
dc534f8f | 121 | /** Offset that is published by the query-block-jobs QMP API */ |
eeec61f2 | 122 | int64_t offset; |
dc534f8f PB |
123 | |
124 | /** Length that is published by the query-block-jobs QMP API */ | |
eeec61f2 | 125 | int64_t len; |
dc534f8f PB |
126 | |
127 | /** Speed that was set with @block_job_set_speed. */ | |
eeec61f2 SH |
128 | int64_t speed; |
129 | ||
dc534f8f | 130 | /** The completion function that will be called when the job completes. */ |
eeec61f2 | 131 | BlockDriverCompletionFunc *cb; |
dc534f8f PB |
132 | |
133 | /** The opaque value that is passed to the completion function. */ | |
eeec61f2 SH |
134 | void *opaque; |
135 | }; | |
136 | ||
ea2384d3 FB |
137 | struct BlockDriver { |
138 | const char *format_name; | |
139 | int instance_size; | |
140 | int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename); | |
508c7cb3 | 141 | int (*bdrv_probe_device)(const char *filename); |
e971aa12 JC |
142 | |
143 | /* For handling image reopen for split or non-split files */ | |
144 | int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state, | |
145 | BlockReopenQueue *queue, Error **errp); | |
146 | void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state); | |
147 | void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state); | |
148 | ||
66f82cee KW |
149 | int (*bdrv_open)(BlockDriverState *bs, int flags); |
150 | int (*bdrv_file_open)(BlockDriverState *bs, const char *filename, int flags); | |
5fafdf24 | 151 | int (*bdrv_read)(BlockDriverState *bs, int64_t sector_num, |
ea2384d3 | 152 | uint8_t *buf, int nb_sectors); |
5fafdf24 | 153 | int (*bdrv_write)(BlockDriverState *bs, int64_t sector_num, |
ea2384d3 | 154 | const uint8_t *buf, int nb_sectors); |
e2731add | 155 | void (*bdrv_close)(BlockDriverState *bs); |
e023b2e2 | 156 | void (*bdrv_rebind)(BlockDriverState *bs); |
0e7e1989 | 157 | int (*bdrv_create)(const char *filename, QEMUOptionParameter *options); |
ea2384d3 | 158 | int (*bdrv_set_key)(BlockDriverState *bs, const char *key); |
95389c86 | 159 | int (*bdrv_make_empty)(BlockDriverState *bs); |
83f64091 | 160 | /* aio */ |
f141eafe AL |
161 | BlockDriverAIOCB *(*bdrv_aio_readv)(BlockDriverState *bs, |
162 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
ce1a14dc | 163 | BlockDriverCompletionFunc *cb, void *opaque); |
f141eafe AL |
164 | BlockDriverAIOCB *(*bdrv_aio_writev)(BlockDriverState *bs, |
165 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
ce1a14dc | 166 | BlockDriverCompletionFunc *cb, void *opaque); |
b2e12bc6 CH |
167 | BlockDriverAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, |
168 | BlockDriverCompletionFunc *cb, void *opaque); | |
4265d620 PB |
169 | BlockDriverAIOCB *(*bdrv_aio_discard)(BlockDriverState *bs, |
170 | int64_t sector_num, int nb_sectors, | |
171 | BlockDriverCompletionFunc *cb, void *opaque); | |
83f64091 | 172 | |
da1fa91d KW |
173 | int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs, |
174 | int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); | |
175 | int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs, | |
176 | int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); | |
f08f2dda SH |
177 | /* |
178 | * Efficiently zero a region of the disk image. Typically an image format | |
179 | * would use a compact metadata representation to implement this. This | |
180 | * function pointer may be NULL and .bdrv_co_writev() will be called | |
181 | * instead. | |
182 | */ | |
183 | int coroutine_fn (*bdrv_co_write_zeroes)(BlockDriverState *bs, | |
184 | int64_t sector_num, int nb_sectors); | |
4265d620 PB |
185 | int coroutine_fn (*bdrv_co_discard)(BlockDriverState *bs, |
186 | int64_t sector_num, int nb_sectors); | |
376ae3f1 SH |
187 | int coroutine_fn (*bdrv_co_is_allocated)(BlockDriverState *bs, |
188 | int64_t sector_num, int nb_sectors, int *pnum); | |
da1fa91d | 189 | |
0f15423c AL |
190 | /* |
191 | * Invalidate any cached meta-data. | |
192 | */ | |
193 | void (*bdrv_invalidate_cache)(BlockDriverState *bs); | |
194 | ||
c68b89ac KW |
195 | /* |
196 | * Flushes all data that was already written to the OS all the way down to | |
197 | * the disk (for example raw-posix calls fsync()). | |
198 | */ | |
199 | int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs); | |
200 | ||
eb489bb1 KW |
201 | /* |
202 | * Flushes all internal caches to the OS. The data may still sit in a | |
203 | * writeback cache of the host OS, but it will survive a crash of the qemu | |
204 | * process. | |
205 | */ | |
206 | int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs); | |
207 | ||
83f64091 | 208 | const char *protocol_name; |
83f64091 FB |
209 | int (*bdrv_truncate)(BlockDriverState *bs, int64_t offset); |
210 | int64_t (*bdrv_getlength)(BlockDriverState *bs); | |
4a1d5e1f | 211 | int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); |
5fafdf24 | 212 | int (*bdrv_write_compressed)(BlockDriverState *bs, int64_t sector_num, |
faea38e7 FB |
213 | const uint8_t *buf, int nb_sectors); |
214 | ||
5fafdf24 | 215 | int (*bdrv_snapshot_create)(BlockDriverState *bs, |
faea38e7 | 216 | QEMUSnapshotInfo *sn_info); |
5fafdf24 | 217 | int (*bdrv_snapshot_goto)(BlockDriverState *bs, |
faea38e7 FB |
218 | const char *snapshot_id); |
219 | int (*bdrv_snapshot_delete)(BlockDriverState *bs, const char *snapshot_id); | |
5fafdf24 | 220 | int (*bdrv_snapshot_list)(BlockDriverState *bs, |
faea38e7 | 221 | QEMUSnapshotInfo **psn_info); |
51ef6727 | 222 | int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs, |
223 | const char *snapshot_name); | |
faea38e7 | 224 | int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi); |
83f64091 | 225 | |
45566e9c CH |
226 | int (*bdrv_save_vmstate)(BlockDriverState *bs, const uint8_t *buf, |
227 | int64_t pos, int size); | |
228 | int (*bdrv_load_vmstate)(BlockDriverState *bs, uint8_t *buf, | |
229 | int64_t pos, int size); | |
178e08a5 | 230 | |
756e6736 KW |
231 | int (*bdrv_change_backing_file)(BlockDriverState *bs, |
232 | const char *backing_file, const char *backing_fmt); | |
233 | ||
19cb3738 FB |
234 | /* removable device specific */ |
235 | int (*bdrv_is_inserted)(BlockDriverState *bs); | |
236 | int (*bdrv_media_changed)(BlockDriverState *bs); | |
f36f3949 | 237 | void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag); |
025e849a | 238 | void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked); |
3b46e624 | 239 | |
985a03b0 TS |
240 | /* to control generic scsi devices */ |
241 | int (*bdrv_ioctl)(BlockDriverState *bs, unsigned long int req, void *buf); | |
221f715d AL |
242 | BlockDriverAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, |
243 | unsigned long int req, void *buf, | |
244 | BlockDriverCompletionFunc *cb, void *opaque); | |
985a03b0 | 245 | |
0e7e1989 KW |
246 | /* List of options for creating images, terminated by name == NULL */ |
247 | QEMUOptionParameter *create_options; | |
248 | ||
5eb45639 | 249 | |
9ac228e0 KW |
250 | /* |
251 | * Returns 0 for completed check, -errno for internal errors. | |
252 | * The check results are stored in result. | |
253 | */ | |
4534ff54 KW |
254 | int (*bdrv_check)(BlockDriverState* bs, BdrvCheckResult *result, |
255 | BdrvCheckMode fix); | |
e97fc193 | 256 | |
8b9b0cc2 KW |
257 | void (*bdrv_debug_event)(BlockDriverState *bs, BlkDebugEvent event); |
258 | ||
336c1c12 KW |
259 | /* |
260 | * Returns 1 if newly created images are guaranteed to contain only | |
261 | * zeros, 0 otherwise. | |
262 | */ | |
263 | int (*bdrv_has_zero_init)(BlockDriverState *bs); | |
12c09b8c | 264 | |
8a22f02a | 265 | QLIST_ENTRY(BlockDriver) list; |
ea2384d3 FB |
266 | }; |
267 | ||
8802d1fd JC |
268 | /* |
269 | * Note: the function bdrv_append() copies and swaps contents of | |
270 | * BlockDriverStates, so if you add new fields to this struct, please | |
271 | * inspect bdrv_append() to determine if the new fields need to be | |
272 | * copied as well. | |
273 | */ | |
ea2384d3 | 274 | struct BlockDriverState { |
d15a771d FB |
275 | int64_t total_sectors; /* if we are reading a disk image, give its |
276 | size in sectors */ | |
ea2384d3 | 277 | int read_only; /* if true, the media is read only */ |
4dca4b63 | 278 | int open_flags; /* flags used to open the file, re-used for re-open */ |
ea2384d3 | 279 | int encrypted; /* if true, the media is encrypted */ |
c0f4ce77 | 280 | int valid_key; /* if true, a valid encryption key has been set */ |
985a03b0 | 281 | int sg; /* if true, the device is a /dev/sg* */ |
53fec9d3 SH |
282 | int copy_on_read; /* if true, copy read backing sectors into image |
283 | note this is a reference count */ | |
ea2384d3 | 284 | |
19cb3738 | 285 | BlockDriver *drv; /* NULL means no media */ |
ea2384d3 FB |
286 | void *opaque; |
287 | ||
fa879d62 MA |
288 | void *dev; /* attached device model, if any */ |
289 | /* TODO change to DeviceState when all users are qdevified */ | |
0e49de52 MA |
290 | const BlockDevOps *dev_ops; |
291 | void *dev_opaque; | |
18846dee | 292 | |
ea2384d3 FB |
293 | char filename[1024]; |
294 | char backing_file[1024]; /* if non zero, the image is a diff of | |
295 | this file image */ | |
5eb45639 | 296 | char backing_format[16]; /* if non-zero and backing_file exists */ |
ea2384d3 | 297 | int is_temporary; |
19cb3738 | 298 | |
ea2384d3 | 299 | BlockDriverState *backing_hd; |
66f82cee KW |
300 | BlockDriverState *file; |
301 | ||
470c0504 SH |
302 | /* number of in-flight copy-on-read requests */ |
303 | unsigned int copy_on_read_in_flight; | |
304 | ||
0563e191 ZYW |
305 | /* the time for latest disk I/O */ |
306 | int64_t slice_time; | |
307 | int64_t slice_start; | |
308 | int64_t slice_end; | |
309 | BlockIOLimit io_limits; | |
310 | BlockIOBaseValue io_base; | |
311 | CoQueue throttled_reqs; | |
312 | QEMUTimer *block_timer; | |
313 | bool io_limits_enabled; | |
314 | ||
a36e69dd | 315 | /* I/O stats (display with "info blockstats"). */ |
a597e79c CH |
316 | uint64_t nr_bytes[BDRV_MAX_IOTYPE]; |
317 | uint64_t nr_ops[BDRV_MAX_IOTYPE]; | |
c488c7f6 | 318 | uint64_t total_time_ns[BDRV_MAX_IOTYPE]; |
294cc35f | 319 | uint64_t wr_highest_sector; |
a36e69dd | 320 | |
71d0770c AL |
321 | /* Whether the disk can expand beyond total_sectors */ |
322 | int growable; | |
323 | ||
e268ca52 AL |
324 | /* the memory alignment required for the buffers handled by this driver */ |
325 | int buffer_alignment; | |
326 | ||
e900a7b7 CH |
327 | /* do we need to tell the quest if we have a volatile write cache? */ |
328 | int enable_write_cache; | |
329 | ||
ea2384d3 FB |
330 | /* NOTE: the following infos are only hints for real hardware |
331 | drivers. They are not used by the block driver */ | |
abd7f68d | 332 | BlockErrorAction on_read_error, on_write_error; |
d6bf279e | 333 | bool iostatus_enabled; |
b2023818 | 334 | BlockDeviceIoStatus iostatus; |
ea2384d3 | 335 | char device_name[32]; |
c6d22830 | 336 | unsigned long *dirty_bitmap; |
aaa0eb75 | 337 | int64_t dirty_count; |
db593f25 | 338 | int in_use; /* users other than guest access, eg. block migration */ |
1b7bdbc1 | 339 | QTAILQ_ENTRY(BlockDriverState) list; |
dbffbdcf SH |
340 | |
341 | QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; | |
eeec61f2 SH |
342 | |
343 | /* long-running background operation */ | |
344 | BlockJob *job; | |
e971aa12 | 345 | |
ea2384d3 FB |
346 | }; |
347 | ||
eba25057 | 348 | int get_tmp_filename(char *filename, int size); |
95389c86 | 349 | |
0563e191 ZYW |
350 | void bdrv_set_io_limits(BlockDriverState *bs, |
351 | BlockIOLimit *io_limits); | |
352 | ||
508c7cb3 CH |
353 | #ifdef _WIN32 |
354 | int is_windows_drive(const char *filename); | |
355 | #endif | |
356 | ||
dc534f8f PB |
357 | /** |
358 | * block_job_create: | |
359 | * @job_type: The class object for the newly-created job. | |
360 | * @bs: The block | |
c83c66c3 | 361 | * @speed: The maximum speed, in bytes per second, or 0 for unlimited. |
dc534f8f PB |
362 | * @cb: Completion function for the job. |
363 | * @opaque: Opaque pointer value passed to @cb. | |
fd7f8c65 | 364 | * @errp: Error object. |
dc534f8f PB |
365 | * |
366 | * Create a new long-running block device job and return it. The job | |
367 | * will call @cb asynchronously when the job completes. Note that | |
368 | * @bs may have been closed at the time the @cb it is called. If | |
369 | * this is the case, the job may be reported as either cancelled or | |
370 | * completed. | |
371 | * | |
372 | * This function is not part of the public job interface; it should be | |
373 | * called from a wrapper that is specific to the job type. | |
374 | */ | |
eeec61f2 | 375 | void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, |
c83c66c3 SH |
376 | int64_t speed, BlockDriverCompletionFunc *cb, |
377 | void *opaque, Error **errp); | |
dc534f8f | 378 | |
4513eafe PB |
379 | /** |
380 | * block_job_sleep_ns: | |
381 | * @job: The job that calls the function. | |
382 | * @clock: The clock to sleep on. | |
383 | * @ns: How many nanoseconds to stop for. | |
384 | * | |
385 | * Put the job to sleep (assuming that it wasn't canceled) for @ns | |
386 | * nanoseconds. Canceling the job will interrupt the wait immediately. | |
387 | */ | |
388 | void block_job_sleep_ns(BlockJob *job, QEMUClock *clock, int64_t ns); | |
389 | ||
dc534f8f PB |
390 | /** |
391 | * block_job_complete: | |
392 | * @job: The job being completed. | |
393 | * @ret: The status code. | |
394 | * | |
395 | * Call the completion function that was registered at creation time, and | |
396 | * free @job. | |
397 | */ | |
eeec61f2 | 398 | void block_job_complete(BlockJob *job, int ret); |
dc534f8f PB |
399 | |
400 | /** | |
401 | * block_job_set_speed: | |
402 | * @job: The job to set the speed for. | |
403 | * @speed: The new value | |
9e6636c7 | 404 | * @errp: Error object. |
dc534f8f PB |
405 | * |
406 | * Set a rate-limiting parameter for the job; the actual meaning may | |
407 | * vary depending on the job type. | |
408 | */ | |
882ec7ce | 409 | void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp); |
dc534f8f PB |
410 | |
411 | /** | |
412 | * block_job_cancel: | |
413 | * @job: The job to be canceled. | |
414 | * | |
415 | * Asynchronously cancel the specified job. | |
416 | */ | |
eeec61f2 | 417 | void block_job_cancel(BlockJob *job); |
dc534f8f PB |
418 | |
419 | /** | |
420 | * block_job_is_cancelled: | |
421 | * @job: The job being queried. | |
422 | * | |
423 | * Returns whether the job is scheduled for cancellation. | |
424 | */ | |
eeec61f2 | 425 | bool block_job_is_cancelled(BlockJob *job); |
dc534f8f PB |
426 | |
427 | /** | |
428 | * block_job_cancel: | |
429 | * @job: The job to be canceled. | |
430 | * | |
431 | * Asynchronously cancel the job and wait for it to reach a quiescent | |
432 | * state. Note that the completion callback will still be called | |
433 | * asynchronously, hence it is *not* valid to call #bdrv_delete | |
434 | * immediately after #block_job_cancel_sync. Users of block jobs | |
435 | * will usually protect the BlockDriverState objects with a reference | |
436 | * count, should this be a concern. | |
fa4478d5 PB |
437 | * |
438 | * Returns the return value from the job if the job actually completed | |
439 | * during the call, or -ECANCELED if it was canceled. | |
dc534f8f | 440 | */ |
fa4478d5 | 441 | int block_job_cancel_sync(BlockJob *job); |
eeec61f2 | 442 | |
dc534f8f PB |
443 | /** |
444 | * stream_start: | |
445 | * @bs: Block device to operate on. | |
446 | * @base: Block device that will become the new base, or %NULL to | |
447 | * flatten the whole backing file chain onto @bs. | |
448 | * @base_id: The file name that will be written to @bs as the new | |
449 | * backing file if the job completes. Ignored if @base is %NULL. | |
c83c66c3 | 450 | * @speed: The maximum speed, in bytes per second, or 0 for unlimited. |
dc534f8f PB |
451 | * @cb: Completion function for the job. |
452 | * @opaque: Opaque pointer value passed to @cb. | |
fd7f8c65 | 453 | * @errp: Error object. |
dc534f8f PB |
454 | * |
455 | * Start a streaming operation on @bs. Clusters that are unallocated | |
456 | * in @bs, but allocated in any image between @base and @bs (both | |
457 | * exclusive) will be written to @bs. At the end of a successful | |
458 | * streaming job, the backing file of @bs will be changed to | |
459 | * @base_id in the written image and to @base in the live BlockDriverState. | |
460 | */ | |
fd7f8c65 | 461 | void stream_start(BlockDriverState *bs, BlockDriverState *base, |
c83c66c3 SH |
462 | const char *base_id, int64_t speed, |
463 | BlockDriverCompletionFunc *cb, | |
fd7f8c65 | 464 | void *opaque, Error **errp); |
4f1043b4 | 465 | |
ea2384d3 | 466 | #endif /* BLOCK_INT_H */ |