4 * Copyright Red Hat, Inc. 2012
7 * Paolo Bonzini <pbonzini@redhat.com>
9 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
10 * See the COPYING.LIB file in the top-level directory.
15 #include "block/blockjob.h"
16 #include "block/block_int.h"
17 #include "qemu/ratelimit.h"
18 #include "qemu/bitmap.h"
20 #define SLICE_TIME 100000000ULL /* ns */
21 #define MAX_IN_FLIGHT 16
23 /* The mirroring buffer is a list of granularity-sized chunks.
24 * Free chunks are organized in a list.
26 typedef struct MirrorBuffer
{
27 QSIMPLEQ_ENTRY(MirrorBuffer
) next
;
30 typedef struct MirrorBlockJob
{
33 BlockDriverState
*target
;
34 BlockDriverState
*base
;
35 /* The name of the graph node to replace */
37 /* The BDS to replace */
38 BlockDriverState
*to_replace
;
39 /* Used to block operations on the drive-mirror-replace target */
40 Error
*replace_blocker
;
42 BlockdevOnError on_source_error
, on_target_error
;
48 unsigned long *cow_bitmap
;
49 BdrvDirtyBitmap
*dirty_bitmap
;
52 QSIMPLEQ_HEAD(, MirrorBuffer
) buf_free
;
55 unsigned long *in_flight_bitmap
;
60 typedef struct MirrorOp
{
67 static BlockErrorAction
mirror_error_action(MirrorBlockJob
*s
, bool read
,
72 return block_job_error_action(&s
->common
, s
->common
.bs
,
73 s
->on_source_error
, true, error
);
75 return block_job_error_action(&s
->common
, s
->target
,
76 s
->on_target_error
, false, error
);
80 static void mirror_iteration_done(MirrorOp
*op
, int ret
)
82 MirrorBlockJob
*s
= op
->s
;
85 int i
, nb_chunks
, sectors_per_chunk
;
87 trace_mirror_iteration_done(s
, op
->sector_num
, op
->nb_sectors
, ret
);
91 for (i
= 0; i
< op
->qiov
.niov
; i
++) {
92 MirrorBuffer
*buf
= (MirrorBuffer
*) iov
[i
].iov_base
;
93 QSIMPLEQ_INSERT_TAIL(&s
->buf_free
, buf
, next
);
97 sectors_per_chunk
= s
->granularity
>> BDRV_SECTOR_BITS
;
98 chunk_num
= op
->sector_num
/ sectors_per_chunk
;
99 nb_chunks
= op
->nb_sectors
/ sectors_per_chunk
;
100 bitmap_clear(s
->in_flight_bitmap
, chunk_num
, nb_chunks
);
101 if (s
->cow_bitmap
&& ret
>= 0) {
102 bitmap_set(s
->cow_bitmap
, chunk_num
, nb_chunks
);
105 qemu_iovec_destroy(&op
->qiov
);
106 g_slice_free(MirrorOp
, op
);
108 /* Enter coroutine when it is not sleeping. The coroutine sleeps to
109 * rate-limit itself. The coroutine will eventually resume since there is
110 * a sleep timeout so don't wake it early.
112 if (s
->common
.busy
) {
113 qemu_coroutine_enter(s
->common
.co
, NULL
);
117 static void mirror_write_complete(void *opaque
, int ret
)
119 MirrorOp
*op
= opaque
;
120 MirrorBlockJob
*s
= op
->s
;
122 BlockDriverState
*source
= s
->common
.bs
;
123 BlockErrorAction action
;
125 bdrv_set_dirty(source
, op
->sector_num
, op
->nb_sectors
);
126 action
= mirror_error_action(s
, false, -ret
);
127 if (action
== BLOCK_ERROR_ACTION_REPORT
&& s
->ret
>= 0) {
131 mirror_iteration_done(op
, ret
);
134 static void mirror_read_complete(void *opaque
, int ret
)
136 MirrorOp
*op
= opaque
;
137 MirrorBlockJob
*s
= op
->s
;
139 BlockDriverState
*source
= s
->common
.bs
;
140 BlockErrorAction action
;
142 bdrv_set_dirty(source
, op
->sector_num
, op
->nb_sectors
);
143 action
= mirror_error_action(s
, true, -ret
);
144 if (action
== BLOCK_ERROR_ACTION_REPORT
&& s
->ret
>= 0) {
148 mirror_iteration_done(op
, ret
);
151 bdrv_aio_writev(s
->target
, op
->sector_num
, &op
->qiov
, op
->nb_sectors
,
152 mirror_write_complete
, op
);
155 static uint64_t coroutine_fn
mirror_iteration(MirrorBlockJob
*s
)
157 BlockDriverState
*source
= s
->common
.bs
;
158 int nb_sectors
, sectors_per_chunk
, nb_chunks
;
159 int64_t end
, sector_num
, next_chunk
, next_sector
, hbitmap_next_sector
;
163 s
->sector_num
= hbitmap_iter_next(&s
->hbi
);
164 if (s
->sector_num
< 0) {
165 bdrv_dirty_iter_init(source
, s
->dirty_bitmap
, &s
->hbi
);
166 s
->sector_num
= hbitmap_iter_next(&s
->hbi
);
167 trace_mirror_restart_iter(s
,
168 bdrv_get_dirty_count(source
, s
->dirty_bitmap
));
169 assert(s
->sector_num
>= 0);
172 hbitmap_next_sector
= s
->sector_num
;
173 sector_num
= s
->sector_num
;
174 sectors_per_chunk
= s
->granularity
>> BDRV_SECTOR_BITS
;
175 end
= s
->common
.len
>> BDRV_SECTOR_BITS
;
177 /* Extend the QEMUIOVector to include all adjacent blocks that will
178 * be copied in this operation.
180 * We have to do this if we have no backing file yet in the destination,
181 * and the cluster size is very large. Then we need to do COW ourselves.
182 * The first time a cluster is copied, copy it entirely. Note that,
183 * because both the granularity and the cluster size are powers of two,
184 * the number of sectors to copy cannot exceed one cluster.
186 * We also want to extend the QEMUIOVector to include more adjacent
187 * dirty blocks if possible, to limit the number of I/O operations and
188 * run efficiently even with a small granularity.
192 next_sector
= sector_num
;
193 next_chunk
= sector_num
/ sectors_per_chunk
;
195 /* Wait for I/O to this cluster (from a previous iteration) to be done. */
196 while (test_bit(next_chunk
, s
->in_flight_bitmap
)) {
197 trace_mirror_yield_in_flight(s
, sector_num
, s
->in_flight
);
198 qemu_coroutine_yield();
202 int added_sectors
, added_chunks
;
204 if (!bdrv_get_dirty(source
, s
->dirty_bitmap
, next_sector
) ||
205 test_bit(next_chunk
, s
->in_flight_bitmap
)) {
206 assert(nb_sectors
> 0);
210 added_sectors
= sectors_per_chunk
;
211 if (s
->cow_bitmap
&& !test_bit(next_chunk
, s
->cow_bitmap
)) {
212 bdrv_round_to_clusters(s
->target
,
213 next_sector
, added_sectors
,
214 &next_sector
, &added_sectors
);
216 /* On the first iteration, the rounding may make us copy
217 * sectors before the first dirty one.
219 if (next_sector
< sector_num
) {
220 assert(nb_sectors
== 0);
221 sector_num
= next_sector
;
222 next_chunk
= next_sector
/ sectors_per_chunk
;
226 added_sectors
= MIN(added_sectors
, end
- (sector_num
+ nb_sectors
));
227 added_chunks
= (added_sectors
+ sectors_per_chunk
- 1) / sectors_per_chunk
;
229 /* When doing COW, it may happen that there is not enough space for
230 * a full cluster. Wait if that is the case.
232 while (nb_chunks
== 0 && s
->buf_free_count
< added_chunks
) {
233 trace_mirror_yield_buf_busy(s
, nb_chunks
, s
->in_flight
);
234 qemu_coroutine_yield();
236 if (s
->buf_free_count
< nb_chunks
+ added_chunks
) {
237 trace_mirror_break_buf_busy(s
, nb_chunks
, s
->in_flight
);
241 /* We have enough free space to copy these sectors. */
242 bitmap_set(s
->in_flight_bitmap
, next_chunk
, added_chunks
);
244 nb_sectors
+= added_sectors
;
245 nb_chunks
+= added_chunks
;
246 next_sector
+= added_sectors
;
247 next_chunk
+= added_chunks
;
248 if (!s
->synced
&& s
->common
.speed
) {
249 delay_ns
= ratelimit_calculate_delay(&s
->limit
, added_sectors
);
253 } while (delay_ns
== 0 && next_sector
< end
);
255 /* Allocate a MirrorOp that is used as an AIO callback. */
256 op
= g_slice_new(MirrorOp
);
258 op
->sector_num
= sector_num
;
259 op
->nb_sectors
= nb_sectors
;
261 /* Now make a QEMUIOVector taking enough granularity-sized chunks
264 qemu_iovec_init(&op
->qiov
, nb_chunks
);
265 next_sector
= sector_num
;
266 while (nb_chunks
-- > 0) {
267 MirrorBuffer
*buf
= QSIMPLEQ_FIRST(&s
->buf_free
);
268 QSIMPLEQ_REMOVE_HEAD(&s
->buf_free
, next
);
270 qemu_iovec_add(&op
->qiov
, buf
, s
->granularity
);
272 /* Advance the HBitmapIter in parallel, so that we do not examine
273 * the same sector twice.
275 if (next_sector
> hbitmap_next_sector
276 && bdrv_get_dirty(source
, s
->dirty_bitmap
, next_sector
)) {
277 hbitmap_next_sector
= hbitmap_iter_next(&s
->hbi
);
280 next_sector
+= sectors_per_chunk
;
283 bdrv_reset_dirty(source
, sector_num
, nb_sectors
);
285 /* Copy the dirty cluster. */
287 trace_mirror_one_iteration(s
, sector_num
, nb_sectors
);
288 bdrv_aio_readv(source
, sector_num
, &op
->qiov
, nb_sectors
,
289 mirror_read_complete
, op
);
293 static void mirror_free_init(MirrorBlockJob
*s
)
295 int granularity
= s
->granularity
;
296 size_t buf_size
= s
->buf_size
;
297 uint8_t *buf
= s
->buf
;
299 assert(s
->buf_free_count
== 0);
300 QSIMPLEQ_INIT(&s
->buf_free
);
301 while (buf_size
!= 0) {
302 MirrorBuffer
*cur
= (MirrorBuffer
*)buf
;
303 QSIMPLEQ_INSERT_TAIL(&s
->buf_free
, cur
, next
);
305 buf_size
-= granularity
;
310 static void mirror_drain(MirrorBlockJob
*s
)
312 while (s
->in_flight
> 0) {
313 qemu_coroutine_yield();
317 static void coroutine_fn
mirror_run(void *opaque
)
319 MirrorBlockJob
*s
= opaque
;
320 BlockDriverState
*bs
= s
->common
.bs
;
321 int64_t sector_num
, end
, sectors_per_chunk
, length
;
322 uint64_t last_pause_ns
;
324 char backing_filename
[1024];
328 if (block_job_is_cancelled(&s
->common
)) {
332 s
->common
.len
= bdrv_getlength(bs
);
333 if (s
->common
.len
< 0) {
336 } else if (s
->common
.len
== 0) {
337 /* Report BLOCK_JOB_READY and wait for complete. */
338 block_job_event_ready(&s
->common
);
340 while (!block_job_is_cancelled(&s
->common
) && !s
->should_complete
) {
341 block_job_yield(&s
->common
);
343 s
->common
.cancelled
= false;
347 length
= DIV_ROUND_UP(s
->common
.len
, s
->granularity
);
348 s
->in_flight_bitmap
= bitmap_new(length
);
350 /* If we have no backing file yet in the destination, we cannot let
351 * the destination do COW. Instead, we copy sectors around the
352 * dirty data if needed. We need a bitmap to do that.
354 bdrv_get_backing_filename(s
->target
, backing_filename
,
355 sizeof(backing_filename
));
356 if (backing_filename
[0] && !s
->target
->backing_hd
) {
357 ret
= bdrv_get_info(s
->target
, &bdi
);
361 if (s
->granularity
< bdi
.cluster_size
) {
362 s
->buf_size
= MAX(s
->buf_size
, bdi
.cluster_size
);
363 s
->cow_bitmap
= bitmap_new(length
);
367 end
= s
->common
.len
>> BDRV_SECTOR_BITS
;
368 s
->buf
= qemu_blockalign(bs
, s
->buf_size
);
369 sectors_per_chunk
= s
->granularity
>> BDRV_SECTOR_BITS
;
372 if (!s
->is_none_mode
) {
373 /* First part, loop on the sectors and initialize the dirty bitmap. */
374 BlockDriverState
*base
= s
->base
;
375 for (sector_num
= 0; sector_num
< end
; ) {
376 int64_t next
= (sector_num
| (sectors_per_chunk
- 1)) + 1;
377 ret
= bdrv_is_allocated_above(bs
, base
,
378 sector_num
, next
- sector_num
, &n
);
386 bdrv_set_dirty(bs
, sector_num
, n
);
394 bdrv_dirty_iter_init(bs
, s
->dirty_bitmap
, &s
->hbi
);
395 last_pause_ns
= qemu_clock_get_ns(QEMU_CLOCK_REALTIME
);
397 uint64_t delay_ns
= 0;
399 bool should_complete
;
406 cnt
= bdrv_get_dirty_count(bs
, s
->dirty_bitmap
);
408 /* Note that even when no rate limit is applied we need to yield
409 * periodically with no pending I/O so that qemu_aio_flush() returns.
410 * We do so every SLICE_TIME nanoseconds, or when there is an error,
411 * or when the source is clean, whichever comes first.
413 if (qemu_clock_get_ns(QEMU_CLOCK_REALTIME
) - last_pause_ns
< SLICE_TIME
&&
414 s
->common
.iostatus
== BLOCK_DEVICE_IO_STATUS_OK
) {
415 if (s
->in_flight
== MAX_IN_FLIGHT
|| s
->buf_free_count
== 0 ||
416 (cnt
== 0 && s
->in_flight
> 0)) {
417 trace_mirror_yield(s
, s
->in_flight
, s
->buf_free_count
, cnt
);
418 qemu_coroutine_yield();
420 } else if (cnt
!= 0) {
421 delay_ns
= mirror_iteration(s
);
428 should_complete
= false;
429 if (s
->in_flight
== 0 && cnt
== 0) {
430 trace_mirror_before_flush(s
);
431 ret
= bdrv_flush(s
->target
);
433 if (mirror_error_action(s
, false, -ret
) ==
434 BLOCK_ERROR_ACTION_REPORT
) {
438 /* We're out of the streaming phase. From now on, if the job
439 * is cancelled we will actually complete all pending I/O and
440 * report completion. This way, block-job-cancel will leave
441 * the target in a consistent state.
443 s
->common
.offset
= end
* BDRV_SECTOR_SIZE
;
445 block_job_event_ready(&s
->common
);
449 should_complete
= s
->should_complete
||
450 block_job_is_cancelled(&s
->common
);
451 cnt
= bdrv_get_dirty_count(bs
, s
->dirty_bitmap
);
455 if (cnt
== 0 && should_complete
) {
456 /* The dirty bitmap is not updated while operations are pending.
457 * If we're about to exit, wait for pending operations before
458 * calling bdrv_get_dirty_count(bs), or we may exit while the
459 * source has dirty data to copy!
461 * Note that I/O can be submitted by the guest while
462 * mirror_populate runs.
464 trace_mirror_before_drain(s
, cnt
);
466 cnt
= bdrv_get_dirty_count(bs
, s
->dirty_bitmap
);
470 trace_mirror_before_sleep(s
, cnt
, s
->synced
, delay_ns
);
472 /* Publish progress */
473 s
->common
.offset
= (end
- cnt
) * BDRV_SECTOR_SIZE
;
474 block_job_sleep_ns(&s
->common
, QEMU_CLOCK_REALTIME
, delay_ns
);
475 if (block_job_is_cancelled(&s
->common
)) {
478 } else if (!should_complete
) {
479 delay_ns
= (s
->in_flight
== 0 && cnt
== 0 ? SLICE_TIME
: 0);
480 block_job_sleep_ns(&s
->common
, QEMU_CLOCK_REALTIME
, delay_ns
);
481 } else if (cnt
== 0) {
482 /* The two disks are in sync. Exit and report successful
485 assert(QLIST_EMPTY(&bs
->tracked_requests
));
486 s
->common
.cancelled
= false;
489 last_pause_ns
= qemu_clock_get_ns(QEMU_CLOCK_REALTIME
);
493 if (s
->in_flight
> 0) {
494 /* We get here only if something went wrong. Either the job failed,
495 * or it was cancelled prematurely so that we do not guarantee that
496 * the target is a copy of the source.
498 assert(ret
< 0 || (!s
->synced
&& block_job_is_cancelled(&s
->common
)));
502 assert(s
->in_flight
== 0);
504 g_free(s
->cow_bitmap
);
505 g_free(s
->in_flight_bitmap
);
506 bdrv_release_dirty_bitmap(bs
, s
->dirty_bitmap
);
507 bdrv_iostatus_disable(s
->target
);
508 if (s
->should_complete
&& ret
== 0) {
509 BlockDriverState
*to_replace
= s
->common
.bs
;
511 to_replace
= s
->to_replace
;
513 if (bdrv_get_flags(s
->target
) != bdrv_get_flags(to_replace
)) {
514 bdrv_reopen(s
->target
, bdrv_get_flags(to_replace
), NULL
);
516 bdrv_swap(s
->target
, to_replace
);
517 if (s
->common
.driver
->job_type
== BLOCK_JOB_TYPE_COMMIT
) {
518 /* drop the bs loop chain formed by the swap: break the loop then
519 * trigger the unref from the top one */
520 BlockDriverState
*p
= s
->base
->backing_hd
;
521 bdrv_set_backing_hd(s
->base
, NULL
);
526 bdrv_op_unblock_all(s
->to_replace
, s
->replace_blocker
);
527 error_free(s
->replace_blocker
);
528 bdrv_unref(s
->to_replace
);
531 bdrv_unref(s
->target
);
532 block_job_completed(&s
->common
, ret
);
535 static void mirror_set_speed(BlockJob
*job
, int64_t speed
, Error
**errp
)
537 MirrorBlockJob
*s
= container_of(job
, MirrorBlockJob
, common
);
540 error_set(errp
, QERR_INVALID_PARAMETER
, "speed");
543 ratelimit_set_speed(&s
->limit
, speed
/ BDRV_SECTOR_SIZE
, SLICE_TIME
);
546 static void mirror_iostatus_reset(BlockJob
*job
)
548 MirrorBlockJob
*s
= container_of(job
, MirrorBlockJob
, common
);
550 bdrv_iostatus_reset(s
->target
);
553 static void mirror_complete(BlockJob
*job
, Error
**errp
)
555 MirrorBlockJob
*s
= container_of(job
, MirrorBlockJob
, common
);
556 Error
*local_err
= NULL
;
559 ret
= bdrv_open_backing_file(s
->target
, NULL
, &local_err
);
561 error_propagate(errp
, local_err
);
565 error_set(errp
, QERR_BLOCK_JOB_NOT_READY
, job
->bs
->device_name
);
569 /* check the target bs is not blocked and block all operations on it */
571 s
->to_replace
= check_to_replace_node(s
->replaces
, &local_err
);
572 if (!s
->to_replace
) {
573 error_propagate(errp
, local_err
);
577 error_setg(&s
->replace_blocker
,
578 "block device is in use by block-job-complete");
579 bdrv_op_block_all(s
->to_replace
, s
->replace_blocker
);
580 bdrv_ref(s
->to_replace
);
583 s
->should_complete
= true;
584 block_job_resume(job
);
587 static const BlockJobDriver mirror_job_driver
= {
588 .instance_size
= sizeof(MirrorBlockJob
),
589 .job_type
= BLOCK_JOB_TYPE_MIRROR
,
590 .set_speed
= mirror_set_speed
,
591 .iostatus_reset
= mirror_iostatus_reset
,
592 .complete
= mirror_complete
,
595 static const BlockJobDriver commit_active_job_driver
= {
596 .instance_size
= sizeof(MirrorBlockJob
),
597 .job_type
= BLOCK_JOB_TYPE_COMMIT
,
598 .set_speed
= mirror_set_speed
,
600 = mirror_iostatus_reset
,
601 .complete
= mirror_complete
,
604 static void mirror_start_job(BlockDriverState
*bs
, BlockDriverState
*target
,
605 const char *replaces
,
606 int64_t speed
, int64_t granularity
,
608 BlockdevOnError on_source_error
,
609 BlockdevOnError on_target_error
,
610 BlockDriverCompletionFunc
*cb
,
611 void *opaque
, Error
**errp
,
612 const BlockJobDriver
*driver
,
613 bool is_none_mode
, BlockDriverState
*base
)
617 if (granularity
== 0) {
618 /* Choose the default granularity based on the target file's cluster
619 * size, clamped between 4k and 64k. */
621 if (bdrv_get_info(target
, &bdi
) >= 0 && bdi
.cluster_size
!= 0) {
622 granularity
= MAX(4096, bdi
.cluster_size
);
623 granularity
= MIN(65536, granularity
);
629 assert ((granularity
& (granularity
- 1)) == 0);
631 if ((on_source_error
== BLOCKDEV_ON_ERROR_STOP
||
632 on_source_error
== BLOCKDEV_ON_ERROR_ENOSPC
) &&
633 !bdrv_iostatus_is_enabled(bs
)) {
634 error_set(errp
, QERR_INVALID_PARAMETER
, "on-source-error");
639 s
= block_job_create(driver
, bs
, speed
, cb
, opaque
, errp
);
644 s
->replaces
= g_strdup(replaces
);
645 s
->on_source_error
= on_source_error
;
646 s
->on_target_error
= on_target_error
;
648 s
->is_none_mode
= is_none_mode
;
650 s
->granularity
= granularity
;
651 s
->buf_size
= MAX(buf_size
, granularity
);
653 s
->dirty_bitmap
= bdrv_create_dirty_bitmap(bs
, granularity
, errp
);
654 if (!s
->dirty_bitmap
) {
657 bdrv_set_enable_write_cache(s
->target
, true);
658 bdrv_set_on_error(s
->target
, on_target_error
, on_target_error
);
659 bdrv_iostatus_enable(s
->target
);
660 s
->common
.co
= qemu_coroutine_create(mirror_run
);
661 trace_mirror_start(bs
, s
, s
->common
.co
, opaque
);
662 qemu_coroutine_enter(s
->common
.co
, s
);
665 void mirror_start(BlockDriverState
*bs
, BlockDriverState
*target
,
666 const char *replaces
,
667 int64_t speed
, int64_t granularity
, int64_t buf_size
,
668 MirrorSyncMode mode
, BlockdevOnError on_source_error
,
669 BlockdevOnError on_target_error
,
670 BlockDriverCompletionFunc
*cb
,
671 void *opaque
, Error
**errp
)
674 BlockDriverState
*base
;
676 is_none_mode
= mode
== MIRROR_SYNC_MODE_NONE
;
677 base
= mode
== MIRROR_SYNC_MODE_TOP
? bs
->backing_hd
: NULL
;
678 mirror_start_job(bs
, target
, replaces
,
679 speed
, granularity
, buf_size
,
680 on_source_error
, on_target_error
, cb
, opaque
, errp
,
681 &mirror_job_driver
, is_none_mode
, base
);
684 void commit_active_start(BlockDriverState
*bs
, BlockDriverState
*base
,
686 BlockdevOnError on_error
,
687 BlockDriverCompletionFunc
*cb
,
688 void *opaque
, Error
**errp
)
690 int64_t length
, base_length
;
693 Error
*local_err
= NULL
;
695 orig_base_flags
= bdrv_get_flags(base
);
697 if (bdrv_reopen(base
, bs
->open_flags
, errp
)) {
701 length
= bdrv_getlength(bs
);
703 error_setg_errno(errp
, -length
,
704 "Unable to determine length of %s", bs
->filename
);
705 goto error_restore_flags
;
708 base_length
= bdrv_getlength(base
);
709 if (base_length
< 0) {
710 error_setg_errno(errp
, -base_length
,
711 "Unable to determine length of %s", base
->filename
);
712 goto error_restore_flags
;
715 if (length
> base_length
) {
716 ret
= bdrv_truncate(base
, length
);
718 error_setg_errno(errp
, -ret
,
719 "Top image %s is larger than base image %s, and "
720 "resize of base image failed",
721 bs
->filename
, base
->filename
);
722 goto error_restore_flags
;
727 mirror_start_job(bs
, base
, NULL
, speed
, 0, 0,
728 on_error
, on_error
, cb
, opaque
, &local_err
,
729 &commit_active_job_driver
, false, base
);
731 error_propagate(errp
, local_err
);
732 goto error_restore_flags
;
738 /* ignore error and errp for bdrv_reopen, because we want to propagate
739 * the original error */
740 bdrv_reopen(base
, orig_base_flags
, NULL
);