]>
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 | ||
5e5a94b6 | 27 | #include "block/accounting.h" |
737e150e | 28 | #include "block/block.h" |
7719f3c9 | 29 | #include "block/aio-wait.h" |
1de7afc9 | 30 | #include "qemu/queue.h" |
10817bf0 | 31 | #include "qemu/coroutine.h" |
f7946da2 | 32 | #include "qemu/stats64.h" |
1de7afc9 | 33 | #include "qemu/timer.h" |
8f0720ec | 34 | #include "qemu/hbitmap.h" |
f364ec65 | 35 | #include "block/snapshot.h" |
cc0681c4 | 36 | #include "qemu/throttle.h" |
faf07963 | 37 | |
bfe8043e | 38 | #define BLOCK_FLAG_LAZY_REFCOUNTS 8 |
ec36ba14 | 39 | |
bfe8043e SH |
40 | #define BLOCK_OPT_SIZE "size" |
41 | #define BLOCK_OPT_ENCRYPT "encryption" | |
0cb8d47b | 42 | #define BLOCK_OPT_ENCRYPT_FORMAT "encrypt.format" |
bfe8043e | 43 | #define BLOCK_OPT_COMPAT6 "compat6" |
f249924e | 44 | #define BLOCK_OPT_HWVERSION "hwversion" |
bfe8043e SH |
45 | #define BLOCK_OPT_BACKING_FILE "backing_file" |
46 | #define BLOCK_OPT_BACKING_FMT "backing_fmt" | |
47 | #define BLOCK_OPT_CLUSTER_SIZE "cluster_size" | |
48 | #define BLOCK_OPT_TABLE_SIZE "table_size" | |
49 | #define BLOCK_OPT_PREALLOC "preallocation" | |
50 | #define BLOCK_OPT_SUBFMT "subformat" | |
51 | #define BLOCK_OPT_COMPAT_LEVEL "compat" | |
52 | #define BLOCK_OPT_LAZY_REFCOUNTS "lazy_refcounts" | |
7f2039f6 | 53 | #define BLOCK_OPT_ADAPTER_TYPE "adapter_type" |
b3af018f | 54 | #define BLOCK_OPT_REDUNDANCY "redundancy" |
4ab15590 | 55 | #define BLOCK_OPT_NOCOW "nocow" |
876eb1b0 | 56 | #define BLOCK_OPT_OBJECT_SIZE "object_size" |
06d05fa7 | 57 | #define BLOCK_OPT_REFCOUNT_BITS "refcount_bits" |
dcc98687 | 58 | #define BLOCK_OPT_DATA_FILE "data_file" |
6c3944dc | 59 | #define BLOCK_OPT_DATA_FILE_RAW "data_file_raw" |
0e7e1989 | 60 | |
7cddd372 KW |
61 | #define BLOCK_PROBE_BUF_SIZE 512 |
62 | ||
ebde595c FZ |
63 | enum BdrvTrackedRequestType { |
64 | BDRV_TRACKED_READ, | |
65 | BDRV_TRACKED_WRITE, | |
ebde595c | 66 | BDRV_TRACKED_DISCARD, |
1bc5f09f | 67 | BDRV_TRACKED_TRUNCATE, |
ebde595c FZ |
68 | }; |
69 | ||
d616b224 SH |
70 | typedef struct BdrvTrackedRequest { |
71 | BlockDriverState *bs; | |
793ed47a | 72 | int64_t offset; |
22931a15 | 73 | uint64_t bytes; |
ebde595c | 74 | enum BdrvTrackedRequestType type; |
7327145f | 75 | |
2dbafdc0 | 76 | bool serialising; |
7327145f | 77 | int64_t overlap_offset; |
22931a15 | 78 | uint64_t overlap_bytes; |
7327145f | 79 | |
d616b224 SH |
80 | QLIST_ENTRY(BdrvTrackedRequest) list; |
81 | Coroutine *co; /* owner, used for deadlock detection */ | |
82 | CoQueue wait_queue; /* coroutines blocked on this request */ | |
6460440f KW |
83 | |
84 | struct BdrvTrackedRequest *waiting_for; | |
d616b224 SH |
85 | } BdrvTrackedRequest; |
86 | ||
ea2384d3 FB |
87 | struct BlockDriver { |
88 | const char *format_name; | |
89 | int instance_size; | |
f6186f49 | 90 | |
5a612c00 MP |
91 | /* set to true if the BlockDriver is a block filter. Block filters pass |
92 | * certain callbacks that refer to data (see block.c) to their bs->file if | |
93 | * the driver doesn't implement them. Drivers that do not wish to forward | |
94 | * must implement them and return -ENOTSUP. | |
95 | */ | |
b5042a36 BC |
96 | bool is_filter; |
97 | /* for snapshots block filter like Quorum can implement the | |
98 | * following recursive callback. | |
212a5a8f BC |
99 | * It's purpose is to recurse on the filter children while calling |
100 | * bdrv_recurse_is_first_non_filter on them. | |
101 | * For a sample implementation look in the future Quorum block filter. | |
f6186f49 | 102 | */ |
212a5a8f BC |
103 | bool (*bdrv_recurse_is_first_non_filter)(BlockDriverState *bs, |
104 | BlockDriverState *candidate); | |
f6186f49 | 105 | |
ea2384d3 | 106 | int (*bdrv_probe)(const uint8_t *buf, int buf_size, const char *filename); |
508c7cb3 | 107 | int (*bdrv_probe_device)(const char *filename); |
c2ad1b0c KW |
108 | |
109 | /* Any driver implementing this callback is expected to be able to handle | |
110 | * NULL file names in its .bdrv_open() implementation */ | |
6963a30d | 111 | void (*bdrv_parse_filename)(const char *filename, QDict *options, Error **errp); |
030be321 BC |
112 | /* Drivers not implementing bdrv_parse_filename nor bdrv_open should have |
113 | * this field set to true, except ones that are defined only by their | |
114 | * child's bs. | |
115 | * An example of the last type will be the quorum block driver. | |
116 | */ | |
117 | bool bdrv_needs_filename; | |
e971aa12 | 118 | |
8ee79e70 KW |
119 | /* Set if a driver can support backing files */ |
120 | bool supports_backing; | |
121 | ||
e971aa12 JC |
122 | /* For handling image reopen for split or non-split files */ |
123 | int (*bdrv_reopen_prepare)(BDRVReopenState *reopen_state, | |
124 | BlockReopenQueue *queue, Error **errp); | |
125 | void (*bdrv_reopen_commit)(BDRVReopenState *reopen_state); | |
126 | void (*bdrv_reopen_abort)(BDRVReopenState *reopen_state); | |
5365f44d | 127 | void (*bdrv_join_options)(QDict *options, QDict *old_options); |
e971aa12 | 128 | |
015a1036 HR |
129 | int (*bdrv_open)(BlockDriverState *bs, QDict *options, int flags, |
130 | Error **errp); | |
1e486cf3 FR |
131 | |
132 | /* Protocol drivers should implement this instead of bdrv_open */ | |
015a1036 HR |
133 | int (*bdrv_file_open)(BlockDriverState *bs, QDict *options, int flags, |
134 | Error **errp); | |
e2731add | 135 | void (*bdrv_close)(BlockDriverState *bs); |
b0292b85 | 136 | int coroutine_fn (*bdrv_co_create)(BlockdevCreateOptions *opts, |
efc75e2a | 137 | Error **errp); |
b0292b85 KW |
138 | int coroutine_fn (*bdrv_co_create_opts)(const char *filename, |
139 | QemuOpts *opts, | |
140 | Error **errp); | |
95389c86 | 141 | int (*bdrv_make_empty)(BlockDriverState *bs); |
91af7014 | 142 | |
998b3a1e HR |
143 | /* |
144 | * Refreshes the bs->exact_filename field. If that is impossible, | |
145 | * bs->exact_filename has to be left empty. | |
146 | */ | |
147 | void (*bdrv_refresh_filename)(BlockDriverState *bs); | |
91af7014 | 148 | |
abc521a9 HR |
149 | /* |
150 | * Gathers the open options for all children into @target. | |
151 | * A simple format driver (without backing file support) might | |
152 | * implement this function like this: | |
153 | * | |
154 | * QINCREF(bs->file->bs->full_open_options); | |
155 | * qdict_put(target, "file", bs->file->bs->full_open_options); | |
156 | * | |
157 | * If not specified, the generic implementation will simply put | |
158 | * all children's options under their respective name. | |
159 | * | |
160 | * @backing_overridden is true when bs->backing seems not to be | |
161 | * the child that would result from opening bs->backing_file. | |
162 | * Therefore, if it is true, the backing child's options should be | |
163 | * gathered; otherwise, there is no need since the backing child | |
164 | * is the one implied by the image header. | |
165 | * | |
166 | * Note that ideally this function would not be needed. Every | |
167 | * block driver which implements it is probably doing something | |
168 | * shady regarding its runtime option structure. | |
169 | */ | |
170 | void (*bdrv_gather_child_options)(BlockDriverState *bs, QDict *target, | |
171 | bool backing_overridden); | |
172 | ||
1e89d0f9 HR |
173 | /* |
174 | * Returns an allocated string which is the directory name of this BDS: It | |
175 | * will be used to make relative filenames absolute by prepending this | |
176 | * function's return value to them. | |
177 | */ | |
178 | char *(*bdrv_dirname)(BlockDriverState *bs, Error **errp); | |
179 | ||
83f64091 | 180 | /* aio */ |
e31f6864 EB |
181 | BlockAIOCB *(*bdrv_aio_preadv)(BlockDriverState *bs, |
182 | uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags, | |
183 | BlockCompletionFunc *cb, void *opaque); | |
e31f6864 EB |
184 | BlockAIOCB *(*bdrv_aio_pwritev)(BlockDriverState *bs, |
185 | uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags, | |
186 | BlockCompletionFunc *cb, void *opaque); | |
7c84b1b8 | 187 | BlockAIOCB *(*bdrv_aio_flush)(BlockDriverState *bs, |
097310b5 | 188 | BlockCompletionFunc *cb, void *opaque); |
4da444a0 | 189 | BlockAIOCB *(*bdrv_aio_pdiscard)(BlockDriverState *bs, |
f5a5ca79 | 190 | int64_t offset, int bytes, |
097310b5 | 191 | BlockCompletionFunc *cb, void *opaque); |
83f64091 | 192 | |
da1fa91d KW |
193 | int coroutine_fn (*bdrv_co_readv)(BlockDriverState *bs, |
194 | int64_t sector_num, int nb_sectors, QEMUIOVector *qiov); | |
64182a6b DB |
195 | |
196 | /** | |
197 | * @offset: position in bytes to read at | |
198 | * @bytes: number of bytes to read | |
199 | * @qiov: the buffers to fill with read data | |
200 | * @flags: currently unused, always 0 | |
201 | * | |
202 | * @offset and @bytes will be a multiple of 'request_alignment', | |
203 | * but the length of individual @qiov elements does not have to | |
204 | * be a multiple. | |
205 | * | |
206 | * @bytes will always equal the total size of @qiov, and will be | |
207 | * no larger than 'max_transfer'. | |
208 | * | |
209 | * The buffer in @qiov may point directly to guest memory. | |
210 | */ | |
3fb06697 KW |
211 | int coroutine_fn (*bdrv_co_preadv)(BlockDriverState *bs, |
212 | uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags); | |
ac850bf0 VSO |
213 | int coroutine_fn (*bdrv_co_preadv_part)(BlockDriverState *bs, |
214 | uint64_t offset, uint64_t bytes, | |
215 | QEMUIOVector *qiov, size_t qiov_offset, int flags); | |
da1fa91d | 216 | int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs, |
93f5e6d8 | 217 | int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int flags); |
64182a6b DB |
218 | /** |
219 | * @offset: position in bytes to write at | |
220 | * @bytes: number of bytes to write | |
221 | * @qiov: the buffers containing data to write | |
222 | * @flags: zero or more bits allowed by 'supported_write_flags' | |
223 | * | |
224 | * @offset and @bytes will be a multiple of 'request_alignment', | |
225 | * but the length of individual @qiov elements does not have to | |
226 | * be a multiple. | |
227 | * | |
228 | * @bytes will always equal the total size of @qiov, and will be | |
229 | * no larger than 'max_transfer'. | |
230 | * | |
231 | * The buffer in @qiov may point directly to guest memory. | |
232 | */ | |
3fb06697 KW |
233 | int coroutine_fn (*bdrv_co_pwritev)(BlockDriverState *bs, |
234 | uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags); | |
ac850bf0 VSO |
235 | int coroutine_fn (*bdrv_co_pwritev_part)(BlockDriverState *bs, |
236 | uint64_t offset, uint64_t bytes, | |
237 | QEMUIOVector *qiov, size_t qiov_offset, int flags); | |
93f5e6d8 | 238 | |
f08f2dda SH |
239 | /* |
240 | * Efficiently zero a region of the disk image. Typically an image format | |
241 | * would use a compact metadata representation to implement this. This | |
465fe887 EB |
242 | * function pointer may be NULL or return -ENOSUP and .bdrv_co_writev() |
243 | * will be called instead. | |
f08f2dda | 244 | */ |
d05aa8bb | 245 | int coroutine_fn (*bdrv_co_pwrite_zeroes)(BlockDriverState *bs, |
f5a5ca79 | 246 | int64_t offset, int bytes, BdrvRequestFlags flags); |
47a5486d | 247 | int coroutine_fn (*bdrv_co_pdiscard)(BlockDriverState *bs, |
f5a5ca79 | 248 | int64_t offset, int bytes); |
4c41cb49 | 249 | |
fcc67678 FZ |
250 | /* Map [offset, offset + nbytes) range onto a child of @bs to copy from, |
251 | * and invoke bdrv_co_copy_range_from(child, ...), or invoke | |
252 | * bdrv_co_copy_range_to() if @bs is the leaf child to copy data from. | |
253 | * | |
254 | * See the comment of bdrv_co_copy_range for the parameter and return value | |
255 | * semantics. | |
256 | */ | |
257 | int coroutine_fn (*bdrv_co_copy_range_from)(BlockDriverState *bs, | |
258 | BdrvChild *src, | |
259 | uint64_t offset, | |
260 | BdrvChild *dst, | |
261 | uint64_t dst_offset, | |
262 | uint64_t bytes, | |
67b51fb9 VSO |
263 | BdrvRequestFlags read_flags, |
264 | BdrvRequestFlags write_flags); | |
fcc67678 FZ |
265 | |
266 | /* Map [offset, offset + nbytes) range onto a child of bs to copy data to, | |
267 | * and invoke bdrv_co_copy_range_to(child, src, ...), or perform the copy | |
268 | * operation if @bs is the leaf and @src has the same BlockDriver. Return | |
269 | * -ENOTSUP if @bs is the leaf but @src has a different BlockDriver. | |
270 | * | |
271 | * See the comment of bdrv_co_copy_range for the parameter and return value | |
272 | * semantics. | |
273 | */ | |
274 | int coroutine_fn (*bdrv_co_copy_range_to)(BlockDriverState *bs, | |
275 | BdrvChild *src, | |
276 | uint64_t src_offset, | |
277 | BdrvChild *dst, | |
278 | uint64_t dst_offset, | |
279 | uint64_t bytes, | |
67b51fb9 VSO |
280 | BdrvRequestFlags read_flags, |
281 | BdrvRequestFlags write_flags); | |
fcc67678 | 282 | |
4c41cb49 | 283 | /* |
298a1665 EB |
284 | * Building block for bdrv_block_status[_above] and |
285 | * bdrv_is_allocated[_above]. The driver should answer only | |
86a3d5c6 EB |
286 | * according to the current layer, and should only need to set |
287 | * BDRV_BLOCK_DATA, BDRV_BLOCK_ZERO, BDRV_BLOCK_OFFSET_VALID, | |
288 | * and/or BDRV_BLOCK_RAW; if the current layer defers to a backing | |
289 | * layer, the result should be 0 (and not BDRV_BLOCK_ZERO). See | |
290 | * block.h for the overall meaning of the bits. As a hint, the | |
291 | * flag want_zero is true if the caller cares more about precise | |
292 | * mappings (favor accurate _OFFSET_VALID/_ZERO) or false for | |
293 | * overall allocation (favor larger *pnum, perhaps by reporting | |
294 | * _DATA instead of _ZERO). The block layer guarantees input | |
295 | * clamped to bdrv_getlength() and aligned to request_alignment, | |
296 | * as well as non-NULL pnum, map, and file; in turn, the driver | |
297 | * must return an error or set pnum to an aligned non-zero value. | |
4c41cb49 | 298 | */ |
86a3d5c6 EB |
299 | int coroutine_fn (*bdrv_co_block_status)(BlockDriverState *bs, |
300 | bool want_zero, int64_t offset, int64_t bytes, int64_t *pnum, | |
301 | int64_t *map, BlockDriverState **file); | |
da1fa91d | 302 | |
0f15423c AL |
303 | /* |
304 | * Invalidate any cached meta-data. | |
305 | */ | |
2b148f39 PB |
306 | void coroutine_fn (*bdrv_co_invalidate_cache)(BlockDriverState *bs, |
307 | Error **errp); | |
76b1c7fe | 308 | int (*bdrv_inactivate)(BlockDriverState *bs); |
0f15423c | 309 | |
c32b82af PD |
310 | /* |
311 | * Flushes all data for all layers by calling bdrv_co_flush for underlying | |
312 | * layers, if needed. This function is needed for deterministic | |
313 | * synchronization of the flush finishing callback. | |
314 | */ | |
315 | int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs); | |
316 | ||
c68b89ac KW |
317 | /* |
318 | * Flushes all data that was already written to the OS all the way down to | |
c1bb86cd | 319 | * the disk (for example file-posix.c calls fsync()). |
c68b89ac KW |
320 | */ |
321 | int coroutine_fn (*bdrv_co_flush_to_disk)(BlockDriverState *bs); | |
322 | ||
eb489bb1 KW |
323 | /* |
324 | * Flushes all internal caches to the OS. The data may still sit in a | |
325 | * writeback cache of the host OS, but it will survive a crash of the qemu | |
326 | * process. | |
327 | */ | |
328 | int coroutine_fn (*bdrv_co_flush_to_os)(BlockDriverState *bs); | |
329 | ||
1e486cf3 FR |
330 | /* |
331 | * Drivers setting this field must be able to work with just a plain | |
332 | * filename with '<protocol_name>:' as a prefix, and no other options. | |
333 | * Options may be extracted from the filename by implementing | |
334 | * bdrv_parse_filename. | |
335 | */ | |
83f64091 | 336 | const char *protocol_name; |
061ca8a3 KW |
337 | int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset, |
338 | PreallocMode prealloc, Error **errp); | |
b94a2610 | 339 | |
83f64091 | 340 | int64_t (*bdrv_getlength)(BlockDriverState *bs); |
b94a2610 | 341 | bool has_variable_length; |
4a1d5e1f | 342 | int64_t (*bdrv_get_allocated_file_size)(BlockDriverState *bs); |
90880ff1 SH |
343 | BlockMeasureInfo *(*bdrv_measure)(QemuOpts *opts, BlockDriverState *in_bs, |
344 | Error **errp); | |
b94a2610 | 345 | |
29a298af PB |
346 | int coroutine_fn (*bdrv_co_pwritev_compressed)(BlockDriverState *bs, |
347 | uint64_t offset, uint64_t bytes, QEMUIOVector *qiov); | |
ac850bf0 VSO |
348 | int coroutine_fn (*bdrv_co_pwritev_compressed_part)(BlockDriverState *bs, |
349 | uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, | |
350 | size_t qiov_offset); | |
29a298af | 351 | |
5fafdf24 | 352 | int (*bdrv_snapshot_create)(BlockDriverState *bs, |
faea38e7 | 353 | QEMUSnapshotInfo *sn_info); |
5fafdf24 | 354 | int (*bdrv_snapshot_goto)(BlockDriverState *bs, |
faea38e7 | 355 | const char *snapshot_id); |
a89d89d3 WX |
356 | int (*bdrv_snapshot_delete)(BlockDriverState *bs, |
357 | const char *snapshot_id, | |
358 | const char *name, | |
359 | Error **errp); | |
5fafdf24 | 360 | int (*bdrv_snapshot_list)(BlockDriverState *bs, |
faea38e7 | 361 | QEMUSnapshotInfo **psn_info); |
51ef6727 | 362 | int (*bdrv_snapshot_load_tmp)(BlockDriverState *bs, |
7b4c4781 WX |
363 | const char *snapshot_id, |
364 | const char *name, | |
365 | Error **errp); | |
faea38e7 | 366 | int (*bdrv_get_info)(BlockDriverState *bs, BlockDriverInfo *bdi); |
1bf6e9ca AS |
367 | ImageInfoSpecific *(*bdrv_get_specific_info)(BlockDriverState *bs, |
368 | Error **errp); | |
d9245599 | 369 | BlockStatsSpecific *(*bdrv_get_specific_stats)(BlockDriverState *bs); |
83f64091 | 370 | |
1a8ae822 KW |
371 | int coroutine_fn (*bdrv_save_vmstate)(BlockDriverState *bs, |
372 | QEMUIOVector *qiov, | |
373 | int64_t pos); | |
374 | int coroutine_fn (*bdrv_load_vmstate)(BlockDriverState *bs, | |
375 | QEMUIOVector *qiov, | |
376 | int64_t pos); | |
178e08a5 | 377 | |
756e6736 KW |
378 | int (*bdrv_change_backing_file)(BlockDriverState *bs, |
379 | const char *backing_file, const char *backing_fmt); | |
380 | ||
19cb3738 | 381 | /* removable device specific */ |
e031f750 | 382 | bool (*bdrv_is_inserted)(BlockDriverState *bs); |
f36f3949 | 383 | void (*bdrv_eject)(BlockDriverState *bs, bool eject_flag); |
025e849a | 384 | void (*bdrv_lock_medium)(BlockDriverState *bs, bool locked); |
3b46e624 | 385 | |
985a03b0 | 386 | /* to control generic scsi devices */ |
7c84b1b8 | 387 | BlockAIOCB *(*bdrv_aio_ioctl)(BlockDriverState *bs, |
221f715d | 388 | unsigned long int req, void *buf, |
097310b5 | 389 | BlockCompletionFunc *cb, void *opaque); |
16a389dc KW |
390 | int coroutine_fn (*bdrv_co_ioctl)(BlockDriverState *bs, |
391 | unsigned long int req, void *buf); | |
985a03b0 | 392 | |
0e7e1989 | 393 | /* List of options for creating images, terminated by name == NULL */ |
83d0521a | 394 | QemuOptsList *create_opts; |
8a2ce0bc AG |
395 | /* |
396 | * If this driver supports reopening images this contains a | |
397 | * NULL-terminated list of the runtime options that can be | |
398 | * modified. If an option in this list is unspecified during | |
399 | * reopen then it _must_ be reset to its default value or return | |
400 | * an error. | |
401 | */ | |
402 | const char *const *mutable_opts; | |
5eb45639 | 403 | |
9ac228e0 KW |
404 | /* |
405 | * Returns 0 for completed check, -errno for internal errors. | |
406 | * The check results are stored in result. | |
407 | */ | |
2fd61638 PB |
408 | int coroutine_fn (*bdrv_co_check)(BlockDriverState *bs, |
409 | BdrvCheckResult *result, | |
410 | BdrvCheckMode fix); | |
e97fc193 | 411 | |
77485434 | 412 | int (*bdrv_amend_options)(BlockDriverState *bs, QemuOpts *opts, |
8b13976d | 413 | BlockDriverAmendStatusCB *status_cb, |
d1402b50 HR |
414 | void *cb_opaque, |
415 | Error **errp); | |
6f176b48 | 416 | |
a31939e6 | 417 | void (*bdrv_debug_event)(BlockDriverState *bs, BlkdebugEvent event); |
8b9b0cc2 | 418 | |
41c695c7 KW |
419 | /* TODO Better pass a option string/QDict/QemuOpts to add any rule? */ |
420 | int (*bdrv_debug_breakpoint)(BlockDriverState *bs, const char *event, | |
421 | const char *tag); | |
4cc70e93 FZ |
422 | int (*bdrv_debug_remove_breakpoint)(BlockDriverState *bs, |
423 | const char *tag); | |
41c695c7 KW |
424 | int (*bdrv_debug_resume)(BlockDriverState *bs, const char *tag); |
425 | bool (*bdrv_debug_is_suspended)(BlockDriverState *bs, const char *tag); | |
426 | ||
3baca891 | 427 | void (*bdrv_refresh_limits)(BlockDriverState *bs, Error **errp); |
d34682cd | 428 | |
336c1c12 KW |
429 | /* |
430 | * Returns 1 if newly created images are guaranteed to contain only | |
431 | * zeros, 0 otherwise. | |
ceaca56f | 432 | * Must return 0 if .bdrv_has_zero_init_truncate() returns 0. |
336c1c12 KW |
433 | */ |
434 | int (*bdrv_has_zero_init)(BlockDriverState *bs); | |
12c09b8c | 435 | |
ceaca56f HR |
436 | /* |
437 | * Returns 1 if new areas added by growing the image with | |
438 | * PREALLOC_MODE_OFF contain only zeros, 0 otherwise. | |
439 | */ | |
440 | int (*bdrv_has_zero_init_truncate)(BlockDriverState *bs); | |
441 | ||
dcd04228 SH |
442 | /* Remove fd handlers, timers, and other event loop callbacks so the event |
443 | * loop is no longer in use. Called with no in-flight requests and in | |
444 | * depth-first traversal order with parents before child nodes. | |
445 | */ | |
446 | void (*bdrv_detach_aio_context)(BlockDriverState *bs); | |
447 | ||
448 | /* Add fd handlers, timers, and other event loop callbacks so I/O requests | |
449 | * can be processed again. Called with no in-flight requests and in | |
450 | * depth-first traversal order with child nodes before parent nodes. | |
451 | */ | |
452 | void (*bdrv_attach_aio_context)(BlockDriverState *bs, | |
453 | AioContext *new_context); | |
454 | ||
448ad91d ML |
455 | /* io queue for linux-aio */ |
456 | void (*bdrv_io_plug)(BlockDriverState *bs); | |
457 | void (*bdrv_io_unplug)(BlockDriverState *bs); | |
448ad91d | 458 | |
892b7de8 ET |
459 | /** |
460 | * Try to get @bs's logical and physical block size. | |
461 | * On success, store them in @bsz and return zero. | |
462 | * On failure, return negative errno. | |
463 | */ | |
464 | int (*bdrv_probe_blocksizes)(BlockDriverState *bs, BlockSizes *bsz); | |
465 | /** | |
466 | * Try to get @bs's geometry (cyls, heads, sectors) | |
467 | * On success, store them in @geo and return 0. | |
468 | * On failure return -errno. | |
469 | * Only drivers that want to override guest geometry implement this | |
470 | * callback; see hd_geometry_guess(). | |
471 | */ | |
472 | int (*bdrv_probe_geometry)(BlockDriverState *bs, HDGeometry *geo); | |
473 | ||
67da1dc5 | 474 | /** |
f8ea8dac | 475 | * bdrv_co_drain_begin is called if implemented in the beginning of a |
481cad48 MP |
476 | * drain operation to drain and stop any internal sources of requests in |
477 | * the driver. | |
478 | * bdrv_co_drain_end is called if implemented at the end of the drain. | |
479 | * | |
480 | * They should be used by the driver to e.g. manage scheduled I/O | |
481 | * requests, or toggle an internal state. After the end of the drain new | |
482 | * requests will continue normally. | |
67da1dc5 | 483 | */ |
f8ea8dac | 484 | void coroutine_fn (*bdrv_co_drain_begin)(BlockDriverState *bs); |
481cad48 | 485 | void coroutine_fn (*bdrv_co_drain_end)(BlockDriverState *bs); |
67da1dc5 | 486 | |
e06018ad WC |
487 | void (*bdrv_add_child)(BlockDriverState *parent, BlockDriverState *child, |
488 | Error **errp); | |
489 | void (*bdrv_del_child)(BlockDriverState *parent, BdrvChild *child, | |
490 | Error **errp); | |
491 | ||
33a610c3 KW |
492 | /** |
493 | * Informs the block driver that a permission change is intended. The | |
494 | * driver checks whether the change is permissible and may take other | |
495 | * preparations for the change (e.g. get file system locks). This operation | |
496 | * is always followed either by a call to either .bdrv_set_perm or | |
497 | * .bdrv_abort_perm_update. | |
498 | * | |
499 | * Checks whether the requested set of cumulative permissions in @perm | |
500 | * can be granted for accessing @bs and whether no other users are using | |
501 | * permissions other than those given in @shared (both arguments take | |
502 | * BLK_PERM_* bitmasks). | |
503 | * | |
504 | * If both conditions are met, 0 is returned. Otherwise, -errno is returned | |
505 | * and errp is set to an error describing the conflict. | |
506 | */ | |
507 | int (*bdrv_check_perm)(BlockDriverState *bs, uint64_t perm, | |
508 | uint64_t shared, Error **errp); | |
509 | ||
510 | /** | |
511 | * Called to inform the driver that the set of cumulative set of used | |
512 | * permissions for @bs has changed to @perm, and the set of sharable | |
513 | * permission to @shared. The driver can use this to propagate changes to | |
514 | * its children (i.e. request permissions only if a parent actually needs | |
515 | * them). | |
516 | * | |
517 | * This function is only invoked after bdrv_check_perm(), so block drivers | |
518 | * may rely on preparations made in their .bdrv_check_perm implementation. | |
519 | */ | |
520 | void (*bdrv_set_perm)(BlockDriverState *bs, uint64_t perm, uint64_t shared); | |
521 | ||
522 | /* | |
523 | * Called to inform the driver that after a previous bdrv_check_perm() | |
524 | * call, the permission update is not performed and any preparations made | |
525 | * for it (e.g. taken file locks) need to be undone. | |
526 | * | |
527 | * This function can be called even for nodes that never saw a | |
528 | * bdrv_check_perm() call. It is a no-op then. | |
529 | */ | |
530 | void (*bdrv_abort_perm_update)(BlockDriverState *bs); | |
531 | ||
532 | /** | |
533 | * Returns in @nperm and @nshared the permissions that the driver for @bs | |
534 | * needs on its child @c, based on the cumulative permissions requested by | |
535 | * the parents in @parent_perm and @parent_shared. | |
536 | * | |
537 | * If @c is NULL, return the permissions for attaching a new child for the | |
538 | * given @role. | |
e0995dc3 KW |
539 | * |
540 | * If @reopen_queue is non-NULL, don't return the currently needed | |
541 | * permissions, but those that will be needed after applying the | |
542 | * @reopen_queue. | |
33a610c3 KW |
543 | */ |
544 | void (*bdrv_child_perm)(BlockDriverState *bs, BdrvChild *c, | |
545 | const BdrvChildRole *role, | |
e0995dc3 | 546 | BlockReopenQueue *reopen_queue, |
33a610c3 KW |
547 | uint64_t parent_perm, uint64_t parent_shared, |
548 | uint64_t *nperm, uint64_t *nshared); | |
549 | ||
cb9ff6c2 VSO |
550 | /** |
551 | * Bitmaps should be marked as 'IN_USE' in the image on reopening image | |
552 | * as rw. This handler should realize it. It also should unset readonly | |
553 | * field of BlockDirtyBitmap's in case of success. | |
554 | */ | |
555 | int (*bdrv_reopen_bitmaps_rw)(BlockDriverState *bs, Error **errp); | |
67b792f5 VSO |
556 | bool (*bdrv_can_store_new_dirty_bitmap)(BlockDriverState *bs, |
557 | const char *name, | |
558 | uint32_t granularity, | |
559 | Error **errp); | |
56f364e6 VSO |
560 | void (*bdrv_remove_persistent_dirty_bitmap)(BlockDriverState *bs, |
561 | const char *name, | |
562 | Error **errp); | |
cb9ff6c2 | 563 | |
23d0ba93 FZ |
564 | /** |
565 | * Register/unregister a buffer for I/O. For example, when the driver is | |
566 | * interested to know the memory areas that will later be used in iovs, so | |
567 | * that it can do IOMMU mapping with VFIO etc., in order to get better | |
568 | * performance. In the case of VFIO drivers, this callback is used to do | |
569 | * DMA mapping for hot buffers. | |
570 | */ | |
571 | void (*bdrv_register_buf)(BlockDriverState *bs, void *host, size_t size); | |
572 | void (*bdrv_unregister_buf)(BlockDriverState *bs, void *host); | |
8a22f02a | 573 | QLIST_ENTRY(BlockDriver) list; |
2654267c HR |
574 | |
575 | /* Pointer to a NULL-terminated array of names of strong options | |
576 | * that can be specified for bdrv_open(). A strong option is one | |
577 | * that changes the data of a BDS. | |
578 | * If this pointer is NULL, the array is considered empty. | |
579 | * "filename" and "driver" are always considered strong. */ | |
580 | const char *const *strong_runtime_opts; | |
ea2384d3 FB |
581 | }; |
582 | ||
ac850bf0 VSO |
583 | static inline bool block_driver_can_compress(BlockDriver *drv) |
584 | { | |
585 | return drv->bdrv_co_pwritev_compressed || | |
586 | drv->bdrv_co_pwritev_compressed_part; | |
587 | } | |
588 | ||
fe81c2cc | 589 | typedef struct BlockLimits { |
a5b8dd2c EB |
590 | /* Alignment requirement, in bytes, for offset/length of I/O |
591 | * requests. Must be a power of 2 less than INT_MAX; defaults to | |
592 | * 1 for drivers with modern byte interfaces, and to 512 | |
593 | * otherwise. */ | |
594 | uint32_t request_alignment; | |
595 | ||
b8d0a980 EB |
596 | /* Maximum number of bytes that can be discarded at once (since it |
597 | * is signed, it must be < 2G, if set). Must be multiple of | |
b9f7855a EB |
598 | * pdiscard_alignment, but need not be power of 2. May be 0 if no |
599 | * inherent 32-bit limit */ | |
600 | int32_t max_pdiscard; | |
601 | ||
b8d0a980 EB |
602 | /* Optimal alignment for discard requests in bytes. A power of 2 |
603 | * is best but not mandatory. Must be a multiple of | |
604 | * bl.request_alignment, and must be less than max_pdiscard if | |
605 | * that is set. May be 0 if bl.request_alignment is good enough */ | |
b9f7855a | 606 | uint32_t pdiscard_alignment; |
fe81c2cc | 607 | |
b8d0a980 EB |
608 | /* Maximum number of bytes that can zeroized at once (since it is |
609 | * signed, it must be < 2G, if set). Must be multiple of | |
29cc6a68 | 610 | * pwrite_zeroes_alignment. May be 0 if no inherent 32-bit limit */ |
cf081fca | 611 | int32_t max_pwrite_zeroes; |
fe81c2cc | 612 | |
b8d0a980 EB |
613 | /* Optimal alignment for write zeroes requests in bytes. A power |
614 | * of 2 is best but not mandatory. Must be a multiple of | |
615 | * bl.request_alignment, and must be less than max_pwrite_zeroes | |
616 | * if that is set. May be 0 if bl.request_alignment is good | |
617 | * enough */ | |
cf081fca | 618 | uint32_t pwrite_zeroes_alignment; |
7337acaf | 619 | |
b8d0a980 EB |
620 | /* Optimal transfer length in bytes. A power of 2 is best but not |
621 | * mandatory. Must be a multiple of bl.request_alignment, or 0 if | |
622 | * no preferred size */ | |
5def6b80 EB |
623 | uint32_t opt_transfer; |
624 | ||
b8d0a980 EB |
625 | /* Maximal transfer length in bytes. Need not be power of 2, but |
626 | * must be multiple of opt_transfer and bl.request_alignment, or 0 | |
627 | * for no 32-bit limit. For now, anything larger than INT_MAX is | |
628 | * clamped down. */ | |
5def6b80 | 629 | uint32_t max_transfer; |
2647fab5 | 630 | |
a5b8dd2c | 631 | /* memory alignment, in bytes so that no bounce buffer is needed */ |
4196d2f0 DL |
632 | size_t min_mem_alignment; |
633 | ||
a5b8dd2c | 634 | /* memory alignment, in bytes, for bounce buffer */ |
339064d5 | 635 | size_t opt_mem_alignment; |
bd44feb7 SH |
636 | |
637 | /* maximum number of iovec elements */ | |
638 | int max_iov; | |
fe81c2cc PL |
639 | } BlockLimits; |
640 | ||
fbe40ff7 FZ |
641 | typedef struct BdrvOpBlocker BdrvOpBlocker; |
642 | ||
33384421 HR |
643 | typedef struct BdrvAioNotifier { |
644 | void (*attached_aio_context)(AioContext *new_context, void *opaque); | |
645 | void (*detach_aio_context)(void *opaque); | |
646 | ||
647 | void *opaque; | |
e8a095da | 648 | bool deleted; |
33384421 HR |
649 | |
650 | QLIST_ENTRY(BdrvAioNotifier) list; | |
651 | } BdrvAioNotifier; | |
652 | ||
f3930ed0 | 653 | struct BdrvChildRole { |
5fe31c25 KW |
654 | /* If true, bdrv_replace_node() doesn't change the node this BdrvChild |
655 | * points to. */ | |
26de9438 KW |
656 | bool stay_at_node; |
657 | ||
6cd5c9d7 KW |
658 | /* If true, the parent is a BlockDriverState and bdrv_next_all_states() |
659 | * will return it. This information is used for drain_all, where every node | |
660 | * will be drained separately, so the drain only needs to be propagated to | |
661 | * non-BDS parents. */ | |
662 | bool parent_is_bds; | |
663 | ||
8e2160e2 KW |
664 | void (*inherit_options)(int *child_flags, QDict *child_options, |
665 | int parent_flags, QDict *parent_options); | |
c2066af0 | 666 | |
5c8cab48 KW |
667 | void (*change_media)(BdrvChild *child, bool load); |
668 | void (*resize)(BdrvChild *child); | |
669 | ||
4c265bf9 KW |
670 | /* Returns a name that is supposedly more useful for human users than the |
671 | * node name for identifying the node in question (in particular, a BB | |
672 | * name), or NULL if the parent can't provide a better name. */ | |
d4a7f45e | 673 | const char *(*get_name)(BdrvChild *child); |
4c265bf9 | 674 | |
b5411555 KW |
675 | /* Returns a malloced string that describes the parent of the child for a |
676 | * human reader. This could be a node-name, BlockBackend name, qdev ID or | |
677 | * QOM path of the device owning the BlockBackend, job type and ID etc. The | |
678 | * caller is responsible for freeing the memory. */ | |
d4a7f45e | 679 | char *(*get_parent_desc)(BdrvChild *child); |
b5411555 | 680 | |
c2066af0 KW |
681 | /* |
682 | * If this pair of functions is implemented, the parent doesn't issue new | |
683 | * requests after returning from .drained_begin() until .drained_end() is | |
684 | * called. | |
685 | * | |
4be6a6d1 KW |
686 | * These functions must not change the graph (and therefore also must not |
687 | * call aio_poll(), which could change the graph indirectly). | |
688 | * | |
e037c09c HR |
689 | * If drained_end() schedules background operations, it must atomically |
690 | * increment *drained_end_counter for each such operation and atomically | |
691 | * decrement it once the operation has settled. | |
692 | * | |
c2066af0 KW |
693 | * Note that this can be nested. If drained_begin() was called twice, new |
694 | * I/O is allowed only after drained_end() was called twice, too. | |
695 | */ | |
696 | void (*drained_begin)(BdrvChild *child); | |
e037c09c | 697 | void (*drained_end)(BdrvChild *child, int *drained_end_counter); |
db95dbba | 698 | |
89bd0305 KW |
699 | /* |
700 | * Returns whether the parent has pending requests for the child. This | |
701 | * callback is polled after .drained_begin() has been called until all | |
702 | * activity on the child has stopped. | |
703 | */ | |
704 | bool (*drained_poll)(BdrvChild *child); | |
705 | ||
cfa1a572 KW |
706 | /* Notifies the parent that the child has been activated/inactivated (e.g. |
707 | * when migration is completing) and it can start/stop requesting | |
708 | * permissions and doing I/O on it. */ | |
4417ab7a | 709 | void (*activate)(BdrvChild *child, Error **errp); |
cfa1a572 | 710 | int (*inactivate)(BdrvChild *child); |
4417ab7a | 711 | |
db95dbba KW |
712 | void (*attach)(BdrvChild *child); |
713 | void (*detach)(BdrvChild *child); | |
6858eba0 KW |
714 | |
715 | /* Notifies the parent that the filename of its child has changed (e.g. | |
716 | * because the direct child was removed from the backing chain), so that it | |
717 | * can update its reference. */ | |
718 | int (*update_filename)(BdrvChild *child, BlockDriverState *new_base, | |
719 | const char *filename, Error **errp); | |
5d231849 KW |
720 | |
721 | bool (*can_set_aio_ctx)(BdrvChild *child, AioContext *ctx, | |
722 | GSList **ignore, Error **errp); | |
53a7d041 | 723 | void (*set_aio_ctx)(BdrvChild *child, AioContext *ctx, GSList **ignore); |
f3930ed0 KW |
724 | }; |
725 | ||
726 | extern const BdrvChildRole child_file; | |
727 | extern const BdrvChildRole child_format; | |
91ef3825 | 728 | extern const BdrvChildRole child_backing; |
f3930ed0 | 729 | |
b4b059f6 | 730 | struct BdrvChild { |
6e93e7c4 | 731 | BlockDriverState *bs; |
260fecf1 | 732 | char *name; |
6e93e7c4 | 733 | const BdrvChildRole *role; |
22aa8b24 | 734 | void *opaque; |
d5e6f437 KW |
735 | |
736 | /** | |
737 | * Granted permissions for operating on this BdrvChild (BLK_PERM_* bitmask) | |
738 | */ | |
739 | uint64_t perm; | |
740 | ||
741 | /** | |
742 | * Permissions that can still be granted to other users of @bs while this | |
743 | * BdrvChild is still attached to it. (BLK_PERM_* bitmask) | |
744 | */ | |
745 | uint64_t shared_perm; | |
746 | ||
f962e961 VSO |
747 | /* backup of permissions during permission update procedure */ |
748 | bool has_backup_perm; | |
749 | uint64_t backup_perm; | |
750 | uint64_t backup_shared_perm; | |
751 | ||
2cad1ebe AG |
752 | /* |
753 | * This link is frozen: the child can neither be replaced nor | |
754 | * detached from the parent. | |
755 | */ | |
756 | bool frozen; | |
757 | ||
804db8ea HR |
758 | /* |
759 | * How many times the parent of this child has been drained | |
760 | * (through role->drained_*). | |
761 | * Usually, this is equal to bs->quiesce_counter (potentially | |
762 | * reduced by bdrv_drain_all_count). It may differ while the | |
763 | * child is entering or leaving a drained section. | |
764 | */ | |
765 | int parent_quiesce_counter; | |
766 | ||
6e93e7c4 | 767 | QLIST_ENTRY(BdrvChild) next; |
d42a8a93 | 768 | QLIST_ENTRY(BdrvChild) next_parent; |
b4b059f6 | 769 | }; |
6e93e7c4 | 770 | |
8802d1fd JC |
771 | /* |
772 | * Note: the function bdrv_append() copies and swaps contents of | |
773 | * BlockDriverStates, so if you add new fields to this struct, please | |
774 | * inspect bdrv_append() to determine if the new fields need to be | |
775 | * copied as well. | |
776 | */ | |
ea2384d3 | 777 | struct BlockDriverState { |
91bcea48 PB |
778 | /* Protected by big QEMU lock or read-only after opening. No special |
779 | * locking needed during I/O... | |
780 | */ | |
4dca4b63 | 781 | int open_flags; /* flags used to open the file, re-used for re-open */ |
54115412 EB |
782 | bool read_only; /* if true, the media is read only */ |
783 | bool encrypted; /* if true, the media is encrypted */ | |
54115412 EB |
784 | bool sg; /* if true, the device is a /dev/sg* */ |
785 | bool probed; /* if true, format was probed rather than specified */ | |
5a9347c6 | 786 | bool force_share; /* if true, always allow all shared permissions */ |
d3c8c674 | 787 | bool implicit; /* if true, this filter node was automatically inserted */ |
54115412 | 788 | |
19cb3738 | 789 | BlockDriver *drv; /* NULL means no media */ |
ea2384d3 FB |
790 | void *opaque; |
791 | ||
dcd04228 | 792 | AioContext *aio_context; /* event loop used for fd handlers, timers, etc */ |
33384421 HR |
793 | /* long-running tasks intended to always use the same AioContext as this |
794 | * BDS may register themselves in this list to be notified of changes | |
795 | * regarding this BDS's context */ | |
796 | QLIST_HEAD(, BdrvAioNotifier) aio_notifiers; | |
e8a095da | 797 | bool walking_aio_notifiers; /* to make removal during iteration safe */ |
dcd04228 | 798 | |
9a29e18f JC |
799 | char filename[PATH_MAX]; |
800 | char backing_file[PATH_MAX]; /* if non zero, the image is a diff of | |
801 | this file image */ | |
998c2019 HR |
802 | /* The backing filename indicated by the image header; if we ever |
803 | * open this file, then this is replaced by the resulting BDS's | |
804 | * filename (i.e. after a bdrv_refresh_filename() run). */ | |
805 | char auto_backing_file[PATH_MAX]; | |
5eb45639 | 806 | char backing_format[16]; /* if non-zero and backing_file exists */ |
19cb3738 | 807 | |
91af7014 | 808 | QDict *full_open_options; |
9a29e18f | 809 | char exact_filename[PATH_MAX]; |
91af7014 | 810 | |
760e0063 | 811 | BdrvChild *backing; |
9a4f4c31 | 812 | BdrvChild *file; |
66f82cee | 813 | |
fe81c2cc PL |
814 | /* I/O Limits */ |
815 | BlockLimits bl; | |
816 | ||
c1e3489d HR |
817 | /* Flags honored during pwrite (so far: BDRV_REQ_FUA, |
818 | * BDRV_REQ_WRITE_UNCHANGED). | |
819 | * If a driver does not support BDRV_REQ_WRITE_UNCHANGED, those | |
820 | * writes will be issued as normal writes without the flag set. | |
821 | * This is important to note for drivers that do not explicitly | |
822 | * request a WRITE permission for their children and instead take | |
823 | * the same permissions as their parent did (this is commonly what | |
824 | * block filters do). Such drivers have to be aware that the | |
825 | * parent may have taken a WRITE_UNCHANGED permission only and is | |
826 | * issuing such requests. Drivers either must make sure that | |
827 | * these requests do not result in plain WRITE accesses (usually | |
828 | * by supporting BDRV_REQ_WRITE_UNCHANGED, and then forwarding | |
829 | * every incoming write request as-is, including potentially that | |
830 | * flag), or they have to explicitly take the WRITE permission for | |
831 | * their children. */ | |
4df863f3 | 832 | unsigned int supported_write_flags; |
d05aa8bb | 833 | /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA, |
c1e3489d | 834 | * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */ |
465fe887 | 835 | unsigned int supported_zero_flags; |
c25f53b0 | 836 | |
dc364f4c BC |
837 | /* the following member gives a name to every node on the bs graph. */ |
838 | char node_name[32]; | |
839 | /* element of the list of named nodes building the graph */ | |
840 | QTAILQ_ENTRY(BlockDriverState) node_list; | |
2c1d04e0 HR |
841 | /* element of the list of all BlockDriverStates (all_bdrv_states) */ |
842 | QTAILQ_ENTRY(BlockDriverState) bs_list; | |
9c4218e9 HR |
843 | /* element of the list of monitor-owned BDS */ |
844 | QTAILQ_ENTRY(BlockDriverState) monitor_list; | |
9fcb0251 | 845 | int refcnt; |
dbffbdcf | 846 | |
fbe40ff7 FZ |
847 | /* operation blockers */ |
848 | QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX]; | |
849 | ||
bddcec37 KW |
850 | /* The node that this node inherited default options from (and a reopen on |
851 | * which can affect this node by changing these defaults). This is always a | |
852 | * parent node of this node. */ | |
853 | BlockDriverState *inherits_from; | |
6e93e7c4 | 854 | QLIST_HEAD(, BdrvChild) children; |
d42a8a93 | 855 | QLIST_HEAD(, BdrvChild) parents; |
6e93e7c4 | 856 | |
de9c0cec | 857 | QDict *options; |
145f598e | 858 | QDict *explicit_options; |
465bee1d | 859 | BlockdevDetectZeroesOptions detect_zeroes; |
826b6ca0 FZ |
860 | |
861 | /* The error object in use for blocking operations on backing_hd */ | |
862 | Error *backing_blocker; | |
e2462113 | 863 | |
91bcea48 PB |
864 | /* Protected by AioContext lock */ |
865 | ||
91bcea48 | 866 | /* If we are reading a disk image, give its size in sectors. |
5e22479a JQ |
867 | * Generally read-only; it is written to by load_snapshot and |
868 | * save_snaphost, but the block layer is quiescent during those. | |
91bcea48 PB |
869 | */ |
870 | int64_t total_sectors; | |
871 | ||
872 | /* Callback before write request is processed */ | |
873 | NotifierWithReturnList before_write_notifiers; | |
874 | ||
e2462113 FR |
875 | /* threshold limit for writes, in bytes. "High water mark". */ |
876 | uint64_t write_threshold_offset; | |
877 | NotifierWithReturn write_threshold_notifier; | |
51288d79 | 878 | |
2119882c PB |
879 | /* Writing to the list requires the BQL _and_ the dirty_bitmap_mutex. |
880 | * Reading from the list can be done with either the BQL or the | |
b64bd51e PB |
881 | * dirty_bitmap_mutex. Modifying a bitmap only requires |
882 | * dirty_bitmap_mutex. */ | |
2119882c | 883 | QemuMutex dirty_bitmap_mutex; |
91bcea48 PB |
884 | QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps; |
885 | ||
f7946da2 PB |
886 | /* Offset after the highest byte written to */ |
887 | Stat64 wr_highest_offset; | |
888 | ||
d3faa13e PB |
889 | /* If true, copy read backing sectors into image. Can be >1 if more |
890 | * than one client has requested copy-on-read. Accessed with atomic | |
891 | * ops. | |
892 | */ | |
893 | int copy_on_read; | |
894 | ||
20fc71b2 PB |
895 | /* number of in-flight requests; overall and serialising. |
896 | * Accessed with atomic ops. | |
897 | */ | |
898 | unsigned int in_flight; | |
899 | unsigned int serialising_in_flight; | |
900 | ||
850d54a2 PB |
901 | /* counter for nested bdrv_io_plug. |
902 | * Accessed with atomic ops. | |
903 | */ | |
904 | unsigned io_plugged; | |
905 | ||
91bcea48 PB |
906 | /* do we need to tell the quest if we have a volatile write cache? */ |
907 | int enable_write_cache; | |
908 | ||
414c2ec3 | 909 | /* Accessed with atomic ops. */ |
51288d79 | 910 | int quiesce_counter; |
d736f119 KW |
911 | int recursive_quiesce_counter; |
912 | ||
47fec599 | 913 | unsigned int write_gen; /* Current data generation */ |
3783fa3d PB |
914 | |
915 | /* Protected by reqs_lock. */ | |
916 | CoMutex reqs_lock; | |
917 | QLIST_HEAD(, BdrvTrackedRequest) tracked_requests; | |
918 | CoQueue flush_queue; /* Serializing flush queue */ | |
919 | bool active_flush_req; /* Flush request in flight? */ | |
920 | ||
921 | /* Only read/written by whoever has set active_flush_req to true. */ | |
922 | unsigned int flushed_gen; /* Flushed write generation */ | |
e5182c1c HR |
923 | |
924 | /* BdrvChild links to this node may never be frozen */ | |
925 | bool never_freeze; | |
ea2384d3 FB |
926 | }; |
927 | ||
281d22d8 HR |
928 | struct BlockBackendRootState { |
929 | int open_flags; | |
930 | bool read_only; | |
931 | BlockdevDetectZeroesOptions detect_zeroes; | |
281d22d8 HR |
932 | }; |
933 | ||
274fccee HR |
934 | typedef enum BlockMirrorBackingMode { |
935 | /* Reuse the existing backing chain from the source for the target. | |
936 | * - sync=full: Set backing BDS to NULL. | |
937 | * - sync=top: Use source's backing BDS. | |
938 | * - sync=none: Use source as the backing BDS. */ | |
939 | MIRROR_SOURCE_BACKING_CHAIN, | |
940 | ||
941 | /* Open the target's backing chain completely anew */ | |
942 | MIRROR_OPEN_BACKING_CHAIN, | |
943 | ||
944 | /* Do not change the target's backing BDS after job completion */ | |
945 | MIRROR_LEAVE_BACKING_CHAIN, | |
946 | } BlockMirrorBackingMode; | |
947 | ||
760e0063 KW |
948 | static inline BlockDriverState *backing_bs(BlockDriverState *bs) |
949 | { | |
950 | return bs->backing ? bs->backing->bs : NULL; | |
951 | } | |
952 | ||
5f535a94 HR |
953 | |
954 | /* Essential block drivers which must always be statically linked into qemu, and | |
955 | * which therefore can be accessed without using bdrv_find_format() */ | |
956 | extern BlockDriver bdrv_file; | |
957 | extern BlockDriver bdrv_raw; | |
958 | extern BlockDriver bdrv_qcow2; | |
959 | ||
a03ef88f | 960 | int coroutine_fn bdrv_co_preadv(BdrvChild *child, |
1bf1cbc9 KW |
961 | int64_t offset, unsigned int bytes, QEMUIOVector *qiov, |
962 | BdrvRequestFlags flags); | |
1acc3466 VSO |
963 | int coroutine_fn bdrv_co_preadv_part(BdrvChild *child, |
964 | int64_t offset, unsigned int bytes, | |
965 | QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags); | |
a03ef88f | 966 | int coroutine_fn bdrv_co_pwritev(BdrvChild *child, |
a8823a3b KW |
967 | int64_t offset, unsigned int bytes, QEMUIOVector *qiov, |
968 | BdrvRequestFlags flags); | |
1acc3466 VSO |
969 | int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child, |
970 | int64_t offset, unsigned int bytes, | |
971 | QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags); | |
1bf1cbc9 | 972 | |
371420e2 VSO |
973 | static inline int coroutine_fn bdrv_co_pread(BdrvChild *child, |
974 | int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags) | |
975 | { | |
976 | QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); | |
977 | ||
978 | return bdrv_co_preadv(child, offset, bytes, &qiov, flags); | |
979 | } | |
980 | ||
981 | static inline int coroutine_fn bdrv_co_pwrite(BdrvChild *child, | |
982 | int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags) | |
983 | { | |
984 | QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes); | |
985 | ||
986 | return bdrv_co_pwritev(child, offset, bytes, &qiov, flags); | |
987 | } | |
988 | ||
0f12264e | 989 | extern unsigned int bdrv_drain_all_count; |
d736f119 KW |
990 | void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent); |
991 | void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent); | |
992 | ||
eba25057 | 993 | int get_tmp_filename(char *filename, int size); |
38f3ef57 KW |
994 | BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, |
995 | const char *filename); | |
95389c86 | 996 | |
03c320d8 HR |
997 | void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix, |
998 | QDict *options); | |
999 | ||
0563e191 | 1000 | |
d616b224 SH |
1001 | /** |
1002 | * bdrv_add_before_write_notifier: | |
1003 | * | |
1004 | * Register a callback that is invoked before write requests are processed but | |
1005 | * after any throttling or waiting for overlapping requests. | |
1006 | */ | |
1007 | void bdrv_add_before_write_notifier(BlockDriverState *bs, | |
1008 | NotifierWithReturn *notifier); | |
1009 | ||
33384421 HR |
1010 | /** |
1011 | * bdrv_add_aio_context_notifier: | |
1012 | * | |
1013 | * If a long-running job intends to be always run in the same AioContext as a | |
1014 | * certain BDS, it may use this function to be notified of changes regarding the | |
1015 | * association of the BDS to an AioContext. | |
1016 | * | |
1017 | * attached_aio_context() is called after the target BDS has been attached to a | |
1018 | * new AioContext; detach_aio_context() is called before the target BDS is being | |
1019 | * detached from its old AioContext. | |
1020 | */ | |
1021 | void bdrv_add_aio_context_notifier(BlockDriverState *bs, | |
1022 | void (*attached_aio_context)(AioContext *new_context, void *opaque), | |
1023 | void (*detach_aio_context)(void *opaque), void *opaque); | |
1024 | ||
1025 | /** | |
1026 | * bdrv_remove_aio_context_notifier: | |
1027 | * | |
1028 | * Unsubscribe of change notifications regarding the BDS's AioContext. The | |
1029 | * parameters given here have to be the same as those given to | |
1030 | * bdrv_add_aio_context_notifier(). | |
1031 | */ | |
1032 | void bdrv_remove_aio_context_notifier(BlockDriverState *bs, | |
1033 | void (*aio_context_attached)(AioContext *, | |
1034 | void *), | |
1035 | void (*aio_context_detached)(void *), | |
1036 | void *opaque); | |
1037 | ||
c9d1a561 PB |
1038 | /** |
1039 | * bdrv_wakeup: | |
1040 | * @bs: The BlockDriverState for which an I/O operation has been completed. | |
1041 | * | |
1042 | * Wake up the main thread if it is waiting on BDRV_POLL_WHILE. During | |
1043 | * synchronous I/O on a BlockDriverState that is attached to another | |
1044 | * I/O thread, the main thread lets the I/O thread's event loop run, | |
1045 | * waiting for the I/O operation to complete. A bdrv_wakeup will wake | |
1046 | * up the main thread if necessary. | |
1047 | * | |
1048 | * Manual calls to bdrv_wakeup are rarely necessary, because | |
1049 | * bdrv_dec_in_flight already calls it. | |
1050 | */ | |
1051 | void bdrv_wakeup(BlockDriverState *bs); | |
1052 | ||
508c7cb3 CH |
1053 | #ifdef _WIN32 |
1054 | int is_windows_drive(const char *filename); | |
1055 | #endif | |
1056 | ||
dc534f8f PB |
1057 | /** |
1058 | * stream_start: | |
2323322e AG |
1059 | * @job_id: The id of the newly-created job, or %NULL to use the |
1060 | * device name of @bs. | |
dc534f8f PB |
1061 | * @bs: Block device to operate on. |
1062 | * @base: Block device that will become the new base, or %NULL to | |
1063 | * flatten the whole backing file chain onto @bs. | |
29338003 AG |
1064 | * @backing_file_str: The file name that will be written to @bs as the |
1065 | * the new backing file if the job completes. Ignored if @base is %NULL. | |
cf6320df JS |
1066 | * @creation_flags: Flags that control the behavior of the Job lifetime. |
1067 | * See @BlockJobCreateFlags | |
c83c66c3 | 1068 | * @speed: The maximum speed, in bytes per second, or 0 for unlimited. |
1d809098 | 1069 | * @on_error: The action to take upon error. |
fd7f8c65 | 1070 | * @errp: Error object. |
dc534f8f PB |
1071 | * |
1072 | * Start a streaming operation on @bs. Clusters that are unallocated | |
1073 | * in @bs, but allocated in any image between @base and @bs (both | |
1074 | * exclusive) will be written to @bs. At the end of a successful | |
1075 | * streaming job, the backing file of @bs will be changed to | |
29338003 AG |
1076 | * @backing_file_str in the written image and to @base in the live |
1077 | * BlockDriverState. | |
dc534f8f | 1078 | */ |
2323322e AG |
1079 | void stream_start(const char *job_id, BlockDriverState *bs, |
1080 | BlockDriverState *base, const char *backing_file_str, | |
cf6320df JS |
1081 | int creation_flags, int64_t speed, |
1082 | BlockdevOnError on_error, Error **errp); | |
4f1043b4 | 1083 | |
747ff602 JC |
1084 | /** |
1085 | * commit_start: | |
fd62c609 AG |
1086 | * @job_id: The id of the newly-created job, or %NULL to use the |
1087 | * device name of @bs. | |
03544a6e FZ |
1088 | * @bs: Active block device. |
1089 | * @top: Top block device to be committed. | |
1090 | * @base: Block device that will be written into, and become the new top. | |
5360782d JS |
1091 | * @creation_flags: Flags that control the behavior of the Job lifetime. |
1092 | * See @BlockJobCreateFlags | |
747ff602 JC |
1093 | * @speed: The maximum speed, in bytes per second, or 0 for unlimited. |
1094 | * @on_error: The action to take upon error. | |
54e26900 | 1095 | * @backing_file_str: String to use as the backing file in @top's overlay |
0db832f4 KW |
1096 | * @filter_node_name: The node name that should be assigned to the filter |
1097 | * driver that the commit job inserts into the graph above @top. NULL means | |
1098 | * that a node name should be autogenerated. | |
747ff602 JC |
1099 | * @errp: Error object. |
1100 | * | |
1101 | */ | |
fd62c609 | 1102 | void commit_start(const char *job_id, BlockDriverState *bs, |
5360782d JS |
1103 | BlockDriverState *base, BlockDriverState *top, |
1104 | int creation_flags, int64_t speed, | |
8254b6d9 | 1105 | BlockdevOnError on_error, const char *backing_file_str, |
0db832f4 | 1106 | const char *filter_node_name, Error **errp); |
03544a6e FZ |
1107 | /** |
1108 | * commit_active_start: | |
fd62c609 AG |
1109 | * @job_id: The id of the newly-created job, or %NULL to use the |
1110 | * device name of @bs. | |
03544a6e FZ |
1111 | * @bs: Active block device to be committed. |
1112 | * @base: Block device that will be written into, and become the new top. | |
47970dfb JS |
1113 | * @creation_flags: Flags that control the behavior of the Job lifetime. |
1114 | * See @BlockJobCreateFlags | |
03544a6e FZ |
1115 | * @speed: The maximum speed, in bytes per second, or 0 for unlimited. |
1116 | * @on_error: The action to take upon error. | |
0db832f4 KW |
1117 | * @filter_node_name: The node name that should be assigned to the filter |
1118 | * driver that the commit job inserts into the graph above @bs. NULL means that | |
1119 | * a node name should be autogenerated. | |
03544a6e FZ |
1120 | * @cb: Completion function for the job. |
1121 | * @opaque: Opaque pointer value passed to @cb. | |
b49f7ead | 1122 | * @auto_complete: Auto complete the job. |
78bbd910 | 1123 | * @errp: Error object. |
03544a6e FZ |
1124 | * |
1125 | */ | |
cc19f177 VSO |
1126 | BlockJob *commit_active_start(const char *job_id, BlockDriverState *bs, |
1127 | BlockDriverState *base, int creation_flags, | |
1128 | int64_t speed, BlockdevOnError on_error, | |
1129 | const char *filter_node_name, | |
1130 | BlockCompletionFunc *cb, void *opaque, | |
1131 | bool auto_complete, Error **errp); | |
893f7eba PB |
1132 | /* |
1133 | * mirror_start: | |
71aa9867 AG |
1134 | * @job_id: The id of the newly-created job, or %NULL to use the |
1135 | * device name of @bs. | |
893f7eba PB |
1136 | * @bs: Block device to operate on. |
1137 | * @target: Block device to write to. | |
09158f00 BC |
1138 | * @replaces: Block graph node name to replace once the mirror is done. Can |
1139 | * only be used when full mirroring is selected. | |
a1999b33 JS |
1140 | * @creation_flags: Flags that control the behavior of the Job lifetime. |
1141 | * See @BlockJobCreateFlags | |
893f7eba | 1142 | * @speed: The maximum speed, in bytes per second, or 0 for unlimited. |
eee13dfe | 1143 | * @granularity: The chosen granularity for the dirty bitmap. |
08e4ed6c | 1144 | * @buf_size: The amount of data that can be in flight at one time. |
893f7eba | 1145 | * @mode: Whether to collapse all images in the chain to the target. |
274fccee | 1146 | * @backing_mode: How to establish the target's backing chain after completion. |
cdf3bc93 | 1147 | * @zero_target: Whether the target should be explicitly zero-initialized |
b952b558 PB |
1148 | * @on_source_error: The action to take upon error reading from the source. |
1149 | * @on_target_error: The action to take upon error writing to the target. | |
0fc9f8ea | 1150 | * @unmap: Whether to unmap target where source sectors only contain zeroes. |
6cdbceb1 KW |
1151 | * @filter_node_name: The node name that should be assigned to the filter |
1152 | * driver that the mirror job inserts into the graph above @bs. NULL means that | |
1153 | * a node name should be autogenerated. | |
481debaa | 1154 | * @copy_mode: When to trigger writes to the target. |
893f7eba PB |
1155 | * @errp: Error object. |
1156 | * | |
1157 | * Start a mirroring operation on @bs. Clusters that are allocated | |
e7e4f9f9 | 1158 | * in @bs will be written to @target until the job is cancelled or |
893f7eba PB |
1159 | * manually completed. At the end of a successful mirroring job, |
1160 | * @bs will be switched to read from @target. | |
1161 | */ | |
71aa9867 AG |
1162 | void mirror_start(const char *job_id, BlockDriverState *bs, |
1163 | BlockDriverState *target, const char *replaces, | |
a1999b33 JS |
1164 | int creation_flags, int64_t speed, |
1165 | uint32_t granularity, int64_t buf_size, | |
274fccee | 1166 | MirrorSyncMode mode, BlockMirrorBackingMode backing_mode, |
cdf3bc93 | 1167 | bool zero_target, |
274fccee | 1168 | BlockdevOnError on_source_error, |
b952b558 | 1169 | BlockdevOnError on_target_error, |
481debaa HR |
1170 | bool unmap, const char *filter_node_name, |
1171 | MirrorCopyMode copy_mode, Error **errp); | |
893f7eba | 1172 | |
98d2c6f2 | 1173 | /* |
111049a4 | 1174 | * backup_job_create: |
70559d49 AG |
1175 | * @job_id: The id of the newly-created job, or %NULL to use the |
1176 | * device name of @bs. | |
98d2c6f2 DM |
1177 | * @bs: Block device to operate on. |
1178 | * @target: Block device to write to. | |
1179 | * @speed: The maximum speed, in bytes per second, or 0 for unlimited. | |
fc5d3f84 | 1180 | * @sync_mode: What parts of the disk image should be copied to the destination. |
c8b56501 JS |
1181 | * @sync_bitmap: The dirty bitmap if sync_mode is 'bitmap' or 'incremental' |
1182 | * @bitmap_mode: The bitmap synchronization policy to use. | |
98d2c6f2 DM |
1183 | * @on_source_error: The action to take upon error reading from the source. |
1184 | * @on_target_error: The action to take upon error writing to the target. | |
47970dfb JS |
1185 | * @creation_flags: Flags that control the behavior of the Job lifetime. |
1186 | * See @BlockJobCreateFlags | |
98d2c6f2 DM |
1187 | * @cb: Completion function for the job. |
1188 | * @opaque: Opaque pointer value passed to @cb. | |
78f51fde | 1189 | * @txn: Transaction that this job is part of (may be NULL). |
98d2c6f2 | 1190 | * |
111049a4 | 1191 | * Create a backup operation on @bs. Clusters in @bs are written to @target |
98d2c6f2 DM |
1192 | * until the job is cancelled or manually completed. |
1193 | */ | |
111049a4 JS |
1194 | BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, |
1195 | BlockDriverState *target, int64_t speed, | |
1196 | MirrorSyncMode sync_mode, | |
1197 | BdrvDirtyBitmap *sync_bitmap, | |
c8b56501 | 1198 | BitmapSyncMode bitmap_mode, |
111049a4 | 1199 | bool compress, |
00e30f05 | 1200 | const char *filter_node_name, |
111049a4 JS |
1201 | BlockdevOnError on_source_error, |
1202 | BlockdevOnError on_target_error, | |
1203 | int creation_flags, | |
1204 | BlockCompletionFunc *cb, void *opaque, | |
62c9e416 | 1205 | JobTxn *txn, Error **errp); |
98d2c6f2 | 1206 | |
abb21ac3 KW |
1207 | void hmp_drive_add_node(Monitor *mon, const char *optstr); |
1208 | ||
f21d96d0 KW |
1209 | BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, |
1210 | const char *child_name, | |
36fe1331 | 1211 | const BdrvChildRole *child_role, |
132ada80 | 1212 | AioContext *ctx, |
d5e6f437 KW |
1213 | uint64_t perm, uint64_t shared_perm, |
1214 | void *opaque, Error **errp); | |
f21d96d0 KW |
1215 | void bdrv_root_unref_child(BdrvChild *child); |
1216 | ||
c1087f12 HR |
1217 | /** |
1218 | * Sets a BdrvChild's permissions. Avoid if the parent is a BDS; use | |
1219 | * bdrv_child_refresh_perms() instead and make the parent's | |
1220 | * .bdrv_child_perm() implementation return the correct values. | |
1221 | */ | |
33a610c3 KW |
1222 | int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared, |
1223 | Error **errp); | |
1224 | ||
c1087f12 HR |
1225 | /** |
1226 | * Calls bs->drv->bdrv_child_perm() and updates the child's permission | |
1227 | * masks with the result. | |
1228 | * Drivers should invoke this function whenever an event occurs that | |
1229 | * makes their .bdrv_child_perm() implementation return different | |
1230 | * values than before, but which will not result in the block layer | |
1231 | * automatically refreshing the permissions. | |
1232 | */ | |
1233 | int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp); | |
1234 | ||
6a1b9ee1 KW |
1235 | /* Default implementation for BlockDriver.bdrv_child_perm() that can be used by |
1236 | * block filters: Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED and RESIZE to | |
1237 | * all children */ | |
1238 | void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c, | |
1239 | const BdrvChildRole *role, | |
e0995dc3 | 1240 | BlockReopenQueue *reopen_queue, |
6a1b9ee1 KW |
1241 | uint64_t perm, uint64_t shared, |
1242 | uint64_t *nperm, uint64_t *nshared); | |
1243 | ||
6b1a044a KW |
1244 | /* Default implementation for BlockDriver.bdrv_child_perm() that can be used by |
1245 | * (non-raw) image formats: Like above for bs->backing, but for bs->file it | |
1246 | * requires WRITE | RESIZE for read-write images, always requires | |
1247 | * CONSISTENT_READ and doesn't share WRITE. */ | |
1248 | void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c, | |
1249 | const BdrvChildRole *role, | |
e0995dc3 | 1250 | BlockReopenQueue *reopen_queue, |
6b1a044a KW |
1251 | uint64_t perm, uint64_t shared, |
1252 | uint64_t *nperm, uint64_t *nshared); | |
33a610c3 | 1253 | |
f7cc69b3 | 1254 | /* |
3e4d0e72 | 1255 | * Default implementation for drivers to pass bdrv_co_block_status() to |
f7cc69b3 MP |
1256 | * their file. |
1257 | */ | |
3e4d0e72 EB |
1258 | int coroutine_fn bdrv_co_block_status_from_file(BlockDriverState *bs, |
1259 | bool want_zero, | |
1260 | int64_t offset, | |
1261 | int64_t bytes, | |
1262 | int64_t *pnum, | |
1263 | int64_t *map, | |
1264 | BlockDriverState **file); | |
f7cc69b3 | 1265 | /* |
3e4d0e72 | 1266 | * Default implementation for drivers to pass bdrv_co_block_status() to |
f7cc69b3 MP |
1267 | * their backing file. |
1268 | */ | |
3e4d0e72 EB |
1269 | int coroutine_fn bdrv_co_block_status_from_backing(BlockDriverState *bs, |
1270 | bool want_zero, | |
1271 | int64_t offset, | |
1272 | int64_t bytes, | |
1273 | int64_t *pnum, | |
1274 | int64_t *map, | |
1275 | BlockDriverState **file); | |
1f0c461b | 1276 | const char *bdrv_get_parent_name(const BlockDriverState *bs); |
39829a01 | 1277 | void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp); |
a7f53e26 | 1278 | bool blk_dev_has_removable_media(BlockBackend *blk); |
8f3a73bc | 1279 | bool blk_dev_has_tray(BlockBackend *blk); |
a7f53e26 MA |
1280 | void blk_dev_eject_request(BlockBackend *blk, bool force); |
1281 | bool blk_dev_is_tray_open(BlockBackend *blk); | |
1282 | bool blk_dev_is_medium_locked(BlockBackend *blk); | |
a7f53e26 | 1283 | |
0fdf1a4f | 1284 | void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes); |
e0c47b6c | 1285 | |
df9a681d | 1286 | void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out); |
56bd6624 | 1287 | void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *backup); |
b7661ca5 JS |
1288 | bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap *dest, |
1289 | const BdrvDirtyBitmap *src, | |
1290 | HBitmap **backup, bool lock); | |
df9a681d | 1291 | |
99723548 PB |
1292 | void bdrv_inc_in_flight(BlockDriverState *bs); |
1293 | void bdrv_dec_in_flight(BlockDriverState *bs); | |
1294 | ||
9c4218e9 HR |
1295 | void blockdev_close_all_bdrv_states(void); |
1296 | ||
fcc67678 FZ |
1297 | int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset, |
1298 | BdrvChild *dst, uint64_t dst_offset, | |
67b51fb9 VSO |
1299 | uint64_t bytes, |
1300 | BdrvRequestFlags read_flags, | |
1301 | BdrvRequestFlags write_flags); | |
fcc67678 FZ |
1302 | int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, uint64_t src_offset, |
1303 | BdrvChild *dst, uint64_t dst_offset, | |
67b51fb9 VSO |
1304 | uint64_t bytes, |
1305 | BdrvRequestFlags read_flags, | |
1306 | BdrvRequestFlags write_flags); | |
fcc67678 | 1307 | |
3d9f2d2a KW |
1308 | int refresh_total_sectors(BlockDriverState *bs, int64_t hint); |
1309 | ||
ea2384d3 | 1310 | #endif /* BLOCK_INT_H */ |