]>
Commit | Line | Data |
---|---|---|
33fa2222 VSO |
1 | /* |
2 | * preallocate filter driver | |
3 | * | |
4 | * The driver performs preallocate operation: it is injected above | |
5 | * some node, and before each write over EOF it does additional preallocating | |
6 | * write-zeroes request. | |
7 | * | |
8 | * Copyright (c) 2020 Virtuozzo International GmbH. | |
9 | * | |
10 | * Author: | |
11 | * Sementsov-Ogievskiy Vladimir <vsementsov@virtuozzo.com> | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or modify | |
14 | * it under the terms of the GNU General Public License as published by | |
15 | * the Free Software Foundation; either version 2 of the License, or | |
16 | * (at your option) any later version. | |
17 | * | |
18 | * This program is distributed in the hope that it will be useful, | |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 | * GNU General Public License for more details. | |
22 | * | |
23 | * You should have received a copy of the GNU General Public License | |
24 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
25 | */ | |
26 | ||
27 | #include "qemu/osdep.h" | |
28 | ||
29 | #include "qapi/error.h" | |
30 | #include "qemu/module.h" | |
31 | #include "qemu/option.h" | |
32 | #include "qemu/units.h" | |
e2c1c34f | 33 | #include "block/block-io.h" |
33fa2222 VSO |
34 | #include "block/block_int.h" |
35 | ||
36 | ||
37 | typedef struct PreallocateOpts { | |
38 | int64_t prealloc_size; | |
39 | int64_t prealloc_align; | |
40 | } PreallocateOpts; | |
41 | ||
42 | typedef struct BDRVPreallocateState { | |
43 | PreallocateOpts opts; | |
44 | ||
45 | /* | |
46 | * Track real data end, to crop preallocation on close. If < 0 the status is | |
47 | * unknown. | |
48 | * | |
49 | * @data_end is a maximum of file size on open (or when we get write/resize | |
50 | * permissions) and all write request ends after it. So it's safe to | |
51 | * truncate to data_end if it is valid. | |
52 | */ | |
53 | int64_t data_end; | |
54 | ||
55 | /* | |
56 | * Start of trailing preallocated area which reads as zero. May be smaller | |
57 | * than data_end, if user does over-EOF write zero operation. If < 0 the | |
58 | * status is unknown. | |
59 | * | |
60 | * If both @zero_start and @file_end are valid, the region | |
61 | * [@zero_start, @file_end) is known to be preallocated zeroes. If @file_end | |
62 | * is not valid, @zero_start doesn't make much sense. | |
63 | */ | |
64 | int64_t zero_start; | |
65 | ||
66 | /* | |
67 | * Real end of file. Actually the cache for bdrv_getlength(bs->file->bs), | |
68 | * to avoid extra lseek() calls on each write operation. If < 0 the status | |
69 | * is unknown. | |
70 | */ | |
71 | int64_t file_end; | |
72 | ||
73 | /* | |
74 | * All three states @data_end, @zero_start and @file_end are guaranteed to | |
75 | * be invalid (< 0) when we don't have both exclusive BLK_PERM_RESIZE and | |
76 | * BLK_PERM_WRITE permissions on file child. | |
77 | */ | |
edcce17b KW |
78 | |
79 | /* Gives up the resize permission on children when parents don't need it */ | |
80 | QEMUBH *drop_resize_bh; | |
33fa2222 VSO |
81 | } BDRVPreallocateState; |
82 | ||
edcce17b KW |
83 | static int preallocate_drop_resize(BlockDriverState *bs, Error **errp); |
84 | static void preallocate_drop_resize_bh(void *opaque); | |
85 | ||
33fa2222 VSO |
86 | #define PREALLOCATE_OPT_PREALLOC_ALIGN "prealloc-align" |
87 | #define PREALLOCATE_OPT_PREALLOC_SIZE "prealloc-size" | |
88 | static QemuOptsList runtime_opts = { | |
89 | .name = "preallocate", | |
90 | .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), | |
91 | .desc = { | |
92 | { | |
93 | .name = PREALLOCATE_OPT_PREALLOC_ALIGN, | |
94 | .type = QEMU_OPT_SIZE, | |
95 | .help = "on preallocation, align file length to this number, " | |
96 | "default 1M", | |
97 | }, | |
98 | { | |
99 | .name = PREALLOCATE_OPT_PREALLOC_SIZE, | |
100 | .type = QEMU_OPT_SIZE, | |
101 | .help = "how much to preallocate, default 128M", | |
102 | }, | |
103 | { /* end of list */ } | |
104 | }, | |
105 | }; | |
106 | ||
107 | static bool preallocate_absorb_opts(PreallocateOpts *dest, QDict *options, | |
108 | BlockDriverState *child_bs, Error **errp) | |
109 | { | |
110 | QemuOpts *opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); | |
111 | ||
112 | if (!qemu_opts_absorb_qdict(opts, options, errp)) { | |
113 | return false; | |
114 | } | |
115 | ||
116 | dest->prealloc_align = | |
117 | qemu_opt_get_size(opts, PREALLOCATE_OPT_PREALLOC_ALIGN, 1 * MiB); | |
118 | dest->prealloc_size = | |
119 | qemu_opt_get_size(opts, PREALLOCATE_OPT_PREALLOC_SIZE, 128 * MiB); | |
120 | ||
121 | qemu_opts_del(opts); | |
122 | ||
123 | if (!QEMU_IS_ALIGNED(dest->prealloc_align, BDRV_SECTOR_SIZE)) { | |
124 | error_setg(errp, "prealloc-align parameter of preallocate filter " | |
125 | "is not aligned to %llu", BDRV_SECTOR_SIZE); | |
126 | return false; | |
127 | } | |
128 | ||
129 | if (!QEMU_IS_ALIGNED(dest->prealloc_align, | |
130 | child_bs->bl.request_alignment)) { | |
131 | error_setg(errp, "prealloc-align parameter of preallocate filter " | |
132 | "is not aligned to underlying node request alignment " | |
133 | "(%" PRIi32 ")", child_bs->bl.request_alignment); | |
134 | return false; | |
135 | } | |
136 | ||
137 | return true; | |
138 | } | |
139 | ||
140 | static int preallocate_open(BlockDriverState *bs, QDict *options, int flags, | |
141 | Error **errp) | |
142 | { | |
143 | BDRVPreallocateState *s = bs->opaque; | |
83930780 | 144 | int ret; |
33fa2222 | 145 | |
a4b740db KW |
146 | GLOBAL_STATE_CODE(); |
147 | ||
33fa2222 VSO |
148 | /* |
149 | * s->data_end and friends should be initialized on permission update. | |
150 | * For this to work, mark them invalid. | |
151 | */ | |
152 | s->file_end = s->zero_start = s->data_end = -EINVAL; | |
edcce17b | 153 | s->drop_resize_bh = qemu_bh_new(preallocate_drop_resize_bh, bs); |
33fa2222 | 154 | |
83930780 VSO |
155 | ret = bdrv_open_file_child(NULL, options, "file", bs, errp); |
156 | if (ret < 0) { | |
157 | return ret; | |
33fa2222 VSO |
158 | } |
159 | ||
a4b740db KW |
160 | GRAPH_RDLOCK_GUARD_MAINLOOP(); |
161 | ||
33fa2222 VSO |
162 | if (!preallocate_absorb_opts(&s->opts, options, bs->file->bs, errp)) { |
163 | return -EINVAL; | |
164 | } | |
165 | ||
166 | bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED | | |
167 | (BDRV_REQ_FUA & bs->file->bs->supported_write_flags); | |
168 | ||
169 | bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED | | |
170 | ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) & | |
171 | bs->file->bs->supported_zero_flags); | |
172 | ||
173 | return 0; | |
174 | } | |
175 | ||
1f051dcb KW |
176 | static int GRAPH_RDLOCK |
177 | preallocate_truncate_to_real_size(BlockDriverState *bs, Error **errp) | |
33fa2222 | 178 | { |
33fa2222 | 179 | BDRVPreallocateState *s = bs->opaque; |
01e28f60 | 180 | int ret; |
33fa2222 VSO |
181 | |
182 | if (s->file_end < 0) { | |
183 | s->file_end = bdrv_getlength(bs->file->bs); | |
184 | if (s->file_end < 0) { | |
01e28f60 KW |
185 | error_setg_errno(errp, -s->file_end, "Failed to get file length"); |
186 | return s->file_end; | |
33fa2222 VSO |
187 | } |
188 | } | |
189 | ||
190 | if (s->data_end < s->file_end) { | |
191 | ret = bdrv_truncate(bs->file, s->data_end, true, PREALLOC_MODE_OFF, 0, | |
192 | NULL); | |
01e28f60 KW |
193 | if (ret < 0) { |
194 | error_setg_errno(errp, -ret, "Failed to drop preallocation"); | |
195 | s->file_end = ret; | |
196 | return ret; | |
197 | } | |
198 | s->file_end = s->data_end; | |
199 | } | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
204 | static void preallocate_close(BlockDriverState *bs) | |
205 | { | |
206 | BDRVPreallocateState *s = bs->opaque; | |
207 | ||
1f051dcb KW |
208 | GLOBAL_STATE_CODE(); |
209 | GRAPH_RDLOCK_GUARD_MAINLOOP(); | |
210 | ||
edcce17b KW |
211 | qemu_bh_cancel(s->drop_resize_bh); |
212 | qemu_bh_delete(s->drop_resize_bh); | |
213 | ||
01e28f60 KW |
214 | if (s->data_end >= 0) { |
215 | preallocate_truncate_to_real_size(bs, NULL); | |
33fa2222 VSO |
216 | } |
217 | } | |
218 | ||
219 | ||
220 | /* | |
221 | * Handle reopen. | |
222 | * | |
223 | * We must implement reopen handlers, otherwise reopen just don't work. Handle | |
224 | * new options and don't care about preallocation state, as it is handled in | |
225 | * set/check permission handlers. | |
226 | */ | |
227 | ||
228 | static int preallocate_reopen_prepare(BDRVReopenState *reopen_state, | |
229 | BlockReopenQueue *queue, Error **errp) | |
230 | { | |
231 | PreallocateOpts *opts = g_new0(PreallocateOpts, 1); | |
edcce17b | 232 | int ret; |
33fa2222 | 233 | |
1f051dcb KW |
234 | GLOBAL_STATE_CODE(); |
235 | GRAPH_RDLOCK_GUARD_MAINLOOP(); | |
236 | ||
33fa2222 VSO |
237 | if (!preallocate_absorb_opts(opts, reopen_state->options, |
238 | reopen_state->bs->file->bs, errp)) { | |
239 | g_free(opts); | |
240 | return -EINVAL; | |
241 | } | |
242 | ||
edcce17b KW |
243 | /* |
244 | * Drop the preallocation already here if reopening read-only. The child | |
245 | * might also be reopened read-only and then scheduling a BH during the | |
246 | * permission update is too late. | |
247 | */ | |
248 | if ((reopen_state->flags & BDRV_O_RDWR) == 0) { | |
249 | ret = preallocate_drop_resize(reopen_state->bs, errp); | |
250 | if (ret < 0) { | |
251 | g_free(opts); | |
252 | return ret; | |
253 | } | |
254 | } | |
255 | ||
33fa2222 VSO |
256 | reopen_state->opaque = opts; |
257 | ||
258 | return 0; | |
259 | } | |
260 | ||
261 | static void preallocate_reopen_commit(BDRVReopenState *state) | |
262 | { | |
263 | BDRVPreallocateState *s = state->bs->opaque; | |
264 | ||
265 | s->opts = *(PreallocateOpts *)state->opaque; | |
266 | ||
267 | g_free(state->opaque); | |
268 | state->opaque = NULL; | |
269 | } | |
270 | ||
271 | static void preallocate_reopen_abort(BDRVReopenState *state) | |
272 | { | |
273 | g_free(state->opaque); | |
274 | state->opaque = NULL; | |
275 | } | |
276 | ||
b9b10c35 KW |
277 | static int coroutine_fn GRAPH_RDLOCK |
278 | preallocate_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes, | |
279 | QEMUIOVector *qiov, size_t qiov_offset, | |
280 | BdrvRequestFlags flags) | |
33fa2222 VSO |
281 | { |
282 | return bdrv_co_preadv_part(bs->file, offset, bytes, qiov, qiov_offset, | |
283 | flags); | |
284 | } | |
285 | ||
9a5a1c62 EGE |
286 | static int coroutine_fn GRAPH_RDLOCK |
287 | preallocate_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes) | |
33fa2222 VSO |
288 | { |
289 | return bdrv_co_pdiscard(bs->file, offset, bytes); | |
290 | } | |
291 | ||
292 | static bool can_write_resize(uint64_t perm) | |
293 | { | |
294 | return (perm & BLK_PERM_WRITE) && (perm & BLK_PERM_RESIZE); | |
295 | } | |
296 | ||
1f051dcb | 297 | static bool GRAPH_RDLOCK has_prealloc_perms(BlockDriverState *bs) |
33fa2222 VSO |
298 | { |
299 | BDRVPreallocateState *s = bs->opaque; | |
300 | ||
301 | if (can_write_resize(bs->file->perm)) { | |
302 | assert(!(bs->file->shared_perm & BLK_PERM_WRITE)); | |
303 | assert(!(bs->file->shared_perm & BLK_PERM_RESIZE)); | |
304 | return true; | |
305 | } | |
306 | ||
307 | assert(s->data_end < 0); | |
308 | assert(s->zero_start < 0); | |
309 | assert(s->file_end < 0); | |
310 | return false; | |
311 | } | |
312 | ||
313 | /* | |
314 | * Call on each write. Returns true if @want_merge_zero is true and the region | |
315 | * [offset, offset + bytes) is zeroed (as a result of this call or earlier | |
316 | * preallocation). | |
317 | * | |
318 | * want_merge_zero is used to merge write-zero request with preallocation in | |
319 | * one bdrv_co_pwrite_zeroes() call. | |
320 | */ | |
abaf8b75 KW |
321 | static bool coroutine_fn GRAPH_RDLOCK |
322 | handle_write(BlockDriverState *bs, int64_t offset, int64_t bytes, | |
323 | bool want_merge_zero) | |
33fa2222 VSO |
324 | { |
325 | BDRVPreallocateState *s = bs->opaque; | |
326 | int64_t end = offset + bytes; | |
327 | int64_t prealloc_start, prealloc_end; | |
328 | int ret; | |
45e62b46 VSO |
329 | uint32_t file_align = bs->file->bs->bl.request_alignment; |
330 | uint32_t prealloc_align = MAX(s->opts.prealloc_align, file_align); | |
331 | ||
332 | assert(QEMU_IS_ALIGNED(prealloc_align, file_align)); | |
33fa2222 VSO |
333 | |
334 | if (!has_prealloc_perms(bs)) { | |
335 | /* We don't have state neither should try to recover it */ | |
336 | return false; | |
337 | } | |
338 | ||
339 | if (s->data_end < 0) { | |
bd53086e | 340 | s->data_end = bdrv_co_getlength(bs->file->bs); |
33fa2222 VSO |
341 | if (s->data_end < 0) { |
342 | return false; | |
343 | } | |
344 | ||
345 | if (s->file_end < 0) { | |
346 | s->file_end = s->data_end; | |
347 | } | |
348 | } | |
349 | ||
350 | if (end <= s->data_end) { | |
351 | return false; | |
352 | } | |
353 | ||
354 | /* We have valid s->data_end, and request writes beyond it. */ | |
355 | ||
356 | s->data_end = end; | |
357 | if (s->zero_start < 0 || !want_merge_zero) { | |
358 | s->zero_start = end; | |
359 | } | |
360 | ||
361 | if (s->file_end < 0) { | |
bd53086e | 362 | s->file_end = bdrv_co_getlength(bs->file->bs); |
33fa2222 VSO |
363 | if (s->file_end < 0) { |
364 | return false; | |
365 | } | |
366 | } | |
367 | ||
368 | /* Now s->data_end, s->zero_start and s->file_end are valid. */ | |
369 | ||
370 | if (end <= s->file_end) { | |
371 | /* No preallocation needed. */ | |
372 | return want_merge_zero && offset >= s->zero_start; | |
373 | } | |
374 | ||
375 | /* Now we want new preallocation, as request writes beyond s->file_end. */ | |
376 | ||
45e62b46 VSO |
377 | prealloc_start = QEMU_ALIGN_UP( |
378 | want_merge_zero ? MIN(offset, s->file_end) : s->file_end, | |
379 | file_align); | |
380 | prealloc_end = QEMU_ALIGN_UP( | |
381 | MAX(prealloc_start, end) + s->opts.prealloc_size, | |
382 | prealloc_align); | |
383 | ||
384 | want_merge_zero = want_merge_zero && (prealloc_start <= offset); | |
33fa2222 VSO |
385 | |
386 | ret = bdrv_co_pwrite_zeroes( | |
387 | bs->file, prealloc_start, prealloc_end - prealloc_start, | |
388 | BDRV_REQ_NO_FALLBACK | BDRV_REQ_SERIALISING | BDRV_REQ_NO_WAIT); | |
389 | if (ret < 0) { | |
390 | s->file_end = ret; | |
391 | return false; | |
392 | } | |
393 | ||
394 | s->file_end = prealloc_end; | |
395 | return want_merge_zero; | |
396 | } | |
397 | ||
abaf8b75 KW |
398 | static int coroutine_fn GRAPH_RDLOCK |
399 | preallocate_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, | |
400 | int64_t bytes, BdrvRequestFlags flags) | |
33fa2222 VSO |
401 | { |
402 | bool want_merge_zero = | |
403 | !(flags & ~(BDRV_REQ_ZERO_WRITE | BDRV_REQ_NO_FALLBACK)); | |
404 | if (handle_write(bs, offset, bytes, want_merge_zero)) { | |
405 | return 0; | |
406 | } | |
407 | ||
408 | return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags); | |
409 | } | |
410 | ||
b9b10c35 KW |
411 | static int coroutine_fn GRAPH_RDLOCK |
412 | preallocate_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes, | |
413 | QEMUIOVector *qiov, size_t qiov_offset, | |
414 | BdrvRequestFlags flags) | |
33fa2222 VSO |
415 | { |
416 | handle_write(bs, offset, bytes, false); | |
417 | ||
418 | return bdrv_co_pwritev_part(bs->file, offset, bytes, qiov, qiov_offset, | |
419 | flags); | |
420 | } | |
421 | ||
c2b8e315 | 422 | static int coroutine_fn GRAPH_RDLOCK |
33fa2222 VSO |
423 | preallocate_co_truncate(BlockDriverState *bs, int64_t offset, |
424 | bool exact, PreallocMode prealloc, | |
425 | BdrvRequestFlags flags, Error **errp) | |
426 | { | |
427 | ERRP_GUARD(); | |
428 | BDRVPreallocateState *s = bs->opaque; | |
429 | int ret; | |
430 | ||
431 | if (s->data_end >= 0 && offset > s->data_end) { | |
432 | if (s->file_end < 0) { | |
bd53086e | 433 | s->file_end = bdrv_co_getlength(bs->file->bs); |
33fa2222 VSO |
434 | if (s->file_end < 0) { |
435 | error_setg(errp, "failed to get file length"); | |
436 | return s->file_end; | |
437 | } | |
438 | } | |
439 | ||
440 | if (prealloc == PREALLOC_MODE_FALLOC) { | |
441 | /* | |
442 | * If offset <= s->file_end, the task is already done, just | |
443 | * update s->data_end, to move part of "filter preallocation" | |
444 | * to "preallocation requested by user". | |
445 | * Otherwise just proceed to preallocate missing part. | |
446 | */ | |
447 | if (offset <= s->file_end) { | |
448 | s->data_end = offset; | |
449 | return 0; | |
450 | } | |
451 | } else { | |
452 | /* | |
453 | * We have to drop our preallocation, to | |
454 | * - avoid "Cannot use preallocation for shrinking files" in | |
455 | * case of offset < file_end | |
456 | * - give PREALLOC_MODE_OFF a chance to keep small disk | |
457 | * usage | |
458 | * - give PREALLOC_MODE_FULL a chance to actually write the | |
459 | * whole region as user expects | |
460 | */ | |
461 | if (s->file_end > s->data_end) { | |
462 | ret = bdrv_co_truncate(bs->file, s->data_end, true, | |
463 | PREALLOC_MODE_OFF, 0, errp); | |
464 | if (ret < 0) { | |
465 | s->file_end = ret; | |
466 | error_prepend(errp, "preallocate-filter: failed to drop " | |
467 | "write-zero preallocation: "); | |
468 | return ret; | |
469 | } | |
470 | s->file_end = s->data_end; | |
471 | } | |
472 | } | |
473 | ||
474 | s->data_end = offset; | |
475 | } | |
476 | ||
477 | ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp); | |
478 | if (ret < 0) { | |
479 | s->file_end = s->zero_start = s->data_end = ret; | |
480 | return ret; | |
481 | } | |
482 | ||
483 | if (has_prealloc_perms(bs)) { | |
484 | s->file_end = s->zero_start = s->data_end = offset; | |
485 | } | |
486 | return 0; | |
487 | } | |
488 | ||
88095349 | 489 | static int coroutine_fn GRAPH_RDLOCK preallocate_co_flush(BlockDriverState *bs) |
33fa2222 VSO |
490 | { |
491 | return bdrv_co_flush(bs->file->bs); | |
492 | } | |
493 | ||
8ab8140a KW |
494 | static int64_t coroutine_fn GRAPH_RDLOCK |
495 | preallocate_co_getlength(BlockDriverState *bs) | |
33fa2222 VSO |
496 | { |
497 | int64_t ret; | |
498 | BDRVPreallocateState *s = bs->opaque; | |
499 | ||
500 | if (s->data_end >= 0) { | |
501 | return s->data_end; | |
502 | } | |
503 | ||
c86422c5 | 504 | ret = bdrv_co_getlength(bs->file->bs); |
33fa2222 VSO |
505 | |
506 | if (has_prealloc_perms(bs)) { | |
507 | s->file_end = s->zero_start = s->data_end = ret; | |
508 | } | |
509 | ||
510 | return ret; | |
511 | } | |
512 | ||
1f051dcb KW |
513 | static int GRAPH_RDLOCK |
514 | preallocate_drop_resize(BlockDriverState *bs, Error **errp) | |
33fa2222 VSO |
515 | { |
516 | BDRVPreallocateState *s = bs->opaque; | |
edcce17b | 517 | int ret; |
33fa2222 | 518 | |
edcce17b KW |
519 | if (s->data_end < 0) { |
520 | return 0; | |
521 | } | |
522 | ||
523 | /* | |
524 | * Before switching children to be read-only, truncate them to remove | |
525 | * the preallocation and let them have the real size. | |
526 | */ | |
527 | ret = preallocate_truncate_to_real_size(bs, errp); | |
528 | if (ret < 0) { | |
529 | return ret; | |
33fa2222 VSO |
530 | } |
531 | ||
edcce17b KW |
532 | /* |
533 | * We'll drop our permissions and will allow other users to take write and | |
534 | * resize permissions (see preallocate_child_perm). Anyone will be able to | |
535 | * change the child, so mark all states invalid. We'll regain control if a | |
536 | * parent requests write access again. | |
537 | */ | |
538 | s->data_end = s->file_end = s->zero_start = -EINVAL; | |
539 | ||
edcce17b | 540 | bdrv_child_refresh_perms(bs, bs->file, NULL); |
edcce17b | 541 | |
33fa2222 VSO |
542 | return 0; |
543 | } | |
544 | ||
edcce17b KW |
545 | static void preallocate_drop_resize_bh(void *opaque) |
546 | { | |
1f051dcb KW |
547 | GLOBAL_STATE_CODE(); |
548 | GRAPH_RDLOCK_GUARD_MAINLOOP(); | |
549 | ||
edcce17b KW |
550 | /* |
551 | * In case of errors, we'll simply keep the exclusive lock on the image | |
552 | * indefinitely. | |
553 | */ | |
554 | preallocate_drop_resize(opaque, NULL); | |
555 | } | |
556 | ||
79a55866 KW |
557 | static void GRAPH_RDLOCK |
558 | preallocate_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared) | |
33fa2222 VSO |
559 | { |
560 | BDRVPreallocateState *s = bs->opaque; | |
561 | ||
562 | if (can_write_resize(perm)) { | |
edcce17b | 563 | qemu_bh_cancel(s->drop_resize_bh); |
33fa2222 VSO |
564 | if (s->data_end < 0) { |
565 | s->data_end = s->file_end = s->zero_start = | |
edcce17b | 566 | bs->file->bs->total_sectors * BDRV_SECTOR_SIZE; |
33fa2222 VSO |
567 | } |
568 | } else { | |
edcce17b | 569 | qemu_bh_schedule(s->drop_resize_bh); |
33fa2222 VSO |
570 | } |
571 | } | |
572 | ||
573 | static void preallocate_child_perm(BlockDriverState *bs, BdrvChild *c, | |
574 | BdrvChildRole role, BlockReopenQueue *reopen_queue, | |
575 | uint64_t perm, uint64_t shared, uint64_t *nperm, uint64_t *nshared) | |
576 | { | |
edcce17b KW |
577 | BDRVPreallocateState *s = bs->opaque; |
578 | ||
33fa2222 VSO |
579 | bdrv_default_perms(bs, c, role, reopen_queue, perm, shared, nperm, nshared); |
580 | ||
edcce17b KW |
581 | /* |
582 | * We need exclusive write and resize permissions on the child not only when | |
583 | * the parent can write to it, but also after the parent gave up write | |
584 | * permissions until preallocate_drop_resize() has completed. | |
585 | */ | |
586 | if (can_write_resize(perm) || s->data_end != -EINVAL) { | |
33fa2222 VSO |
587 | *nperm |= BLK_PERM_WRITE | BLK_PERM_RESIZE; |
588 | ||
589 | /* | |
590 | * Don't share, to keep our states s->file_end, s->data_end and | |
591 | * s->zero_start valid. | |
592 | */ | |
593 | *nshared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE); | |
594 | } | |
595 | } | |
596 | ||
9ea473fb | 597 | static BlockDriver bdrv_preallocate_filter = { |
33fa2222 VSO |
598 | .format_name = "preallocate", |
599 | .instance_size = sizeof(BDRVPreallocateState), | |
600 | ||
c86422c5 EGE |
601 | .bdrv_co_getlength = preallocate_co_getlength, |
602 | .bdrv_open = preallocate_open, | |
603 | .bdrv_close = preallocate_close, | |
33fa2222 VSO |
604 | |
605 | .bdrv_reopen_prepare = preallocate_reopen_prepare, | |
606 | .bdrv_reopen_commit = preallocate_reopen_commit, | |
607 | .bdrv_reopen_abort = preallocate_reopen_abort, | |
608 | ||
609 | .bdrv_co_preadv_part = preallocate_co_preadv_part, | |
610 | .bdrv_co_pwritev_part = preallocate_co_pwritev_part, | |
611 | .bdrv_co_pwrite_zeroes = preallocate_co_pwrite_zeroes, | |
612 | .bdrv_co_pdiscard = preallocate_co_pdiscard, | |
613 | .bdrv_co_flush = preallocate_co_flush, | |
614 | .bdrv_co_truncate = preallocate_co_truncate, | |
615 | ||
33fa2222 VSO |
616 | .bdrv_set_perm = preallocate_set_perm, |
617 | .bdrv_child_perm = preallocate_child_perm, | |
618 | ||
33fa2222 VSO |
619 | .is_filter = true, |
620 | }; | |
621 | ||
622 | static void bdrv_preallocate_init(void) | |
623 | { | |
624 | bdrv_register(&bdrv_preallocate_filter); | |
625 | } | |
626 | ||
627 | block_init(bdrv_preallocate_init); |