2 * copy-before-write filter driver
4 * The driver performs Copy-Before-Write (CBW) operation: it is injected above
5 * some node, and before each write it copies _old_ data to the target node.
7 * Copyright (c) 2018-2021 Virtuozzo International GmbH.
10 * Sementsov-Ogievskiy Vladimir <vsementsov@virtuozzo.com>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program. If not, see <http://www.gnu.org/licenses/>.
26 #include "qemu/osdep.h"
28 #include "sysemu/block-backend.h"
29 #include "qemu/cutils.h"
30 #include "qapi/error.h"
31 #include "block/block_int.h"
32 #include "block/qdict.h"
33 #include "block/block-copy.h"
35 #include "block/copy-before-write.h"
37 typedef struct BDRVCopyBeforeWriteState
{
40 } BDRVCopyBeforeWriteState
;
42 static coroutine_fn
int cbw_co_preadv(
43 BlockDriverState
*bs
, uint64_t offset
, uint64_t bytes
,
44 QEMUIOVector
*qiov
, int flags
)
46 return bdrv_co_preadv(bs
->backing
, offset
, bytes
, qiov
, flags
);
49 static coroutine_fn
int cbw_do_copy_before_write(BlockDriverState
*bs
,
50 uint64_t offset
, uint64_t bytes
, BdrvRequestFlags flags
)
52 BDRVCopyBeforeWriteState
*s
= bs
->opaque
;
54 int64_t cluster_size
= block_copy_cluster_size(s
->bcs
);
56 if (flags
& BDRV_REQ_WRITE_UNCHANGED
) {
60 off
= QEMU_ALIGN_DOWN(offset
, cluster_size
);
61 end
= QEMU_ALIGN_UP(offset
+ bytes
, cluster_size
);
63 return block_copy(s
->bcs
, off
, end
- off
, true);
66 static int coroutine_fn
cbw_co_pdiscard(BlockDriverState
*bs
,
67 int64_t offset
, int bytes
)
69 int ret
= cbw_do_copy_before_write(bs
, offset
, bytes
, 0);
74 return bdrv_co_pdiscard(bs
->backing
, offset
, bytes
);
77 static int coroutine_fn
cbw_co_pwrite_zeroes(BlockDriverState
*bs
,
78 int64_t offset
, int bytes
, BdrvRequestFlags flags
)
80 int ret
= cbw_do_copy_before_write(bs
, offset
, bytes
, flags
);
85 return bdrv_co_pwrite_zeroes(bs
->backing
, offset
, bytes
, flags
);
88 static coroutine_fn
int cbw_co_pwritev(BlockDriverState
*bs
,
91 QEMUIOVector
*qiov
, int flags
)
93 int ret
= cbw_do_copy_before_write(bs
, offset
, bytes
, flags
);
98 return bdrv_co_pwritev(bs
->backing
, offset
, bytes
, qiov
, flags
);
101 static int coroutine_fn
cbw_co_flush(BlockDriverState
*bs
)
107 return bdrv_co_flush(bs
->backing
->bs
);
110 static void cbw_refresh_filename(BlockDriverState
*bs
)
112 if (bs
->backing
== NULL
) {
114 * we can be here after failed bdrv_attach_child in
115 * bdrv_set_backing_hd
119 pstrcpy(bs
->exact_filename
, sizeof(bs
->exact_filename
),
120 bs
->backing
->bs
->filename
);
123 static void cbw_child_perm(BlockDriverState
*bs
, BdrvChild
*c
,
125 BlockReopenQueue
*reopen_queue
,
126 uint64_t perm
, uint64_t shared
,
127 uint64_t *nperm
, uint64_t *nshared
)
129 if (!(role
& BDRV_CHILD_FILTERED
)) {
133 * Share write to target (child_file), to not interfere
134 * with guest writes to its disk which may be in target backing chain.
135 * Can't resize during a backup block job because we check the size
138 *nshared
= BLK_PERM_ALL
& ~BLK_PERM_RESIZE
;
139 *nperm
= BLK_PERM_WRITE
;
142 bdrv_default_perms(bs
, c
, role
, reopen_queue
,
143 perm
, shared
, nperm
, nshared
);
145 if (perm
& BLK_PERM_WRITE
) {
146 *nperm
= *nperm
| BLK_PERM_CONSISTENT_READ
;
148 *nshared
&= ~(BLK_PERM_WRITE
| BLK_PERM_RESIZE
);
152 BlockDriver bdrv_cbw_filter
= {
153 .format_name
= "copy-before-write",
154 .instance_size
= sizeof(BDRVCopyBeforeWriteState
),
156 .bdrv_co_preadv
= cbw_co_preadv
,
157 .bdrv_co_pwritev
= cbw_co_pwritev
,
158 .bdrv_co_pwrite_zeroes
= cbw_co_pwrite_zeroes
,
159 .bdrv_co_pdiscard
= cbw_co_pdiscard
,
160 .bdrv_co_flush
= cbw_co_flush
,
162 .bdrv_refresh_filename
= cbw_refresh_filename
,
164 .bdrv_child_perm
= cbw_child_perm
,
169 BlockDriverState
*bdrv_cbw_append(BlockDriverState
*source
,
170 BlockDriverState
*target
,
171 const char *filter_node_name
,
173 BlockCopyState
**bcs
,
178 BDRVCopyBeforeWriteState
*state
;
179 BlockDriverState
*top
;
180 bool appended
= false;
182 assert(source
->total_sectors
== target
->total_sectors
);
184 top
= bdrv_new_open_driver(&bdrv_cbw_filter
, filter_node_name
,
191 top
->total_sectors
= source
->total_sectors
;
192 top
->supported_write_flags
= BDRV_REQ_WRITE_UNCHANGED
|
193 (BDRV_REQ_FUA
& source
->supported_write_flags
);
194 top
->supported_zero_flags
= BDRV_REQ_WRITE_UNCHANGED
|
195 ((BDRV_REQ_FUA
| BDRV_REQ_MAY_UNMAP
| BDRV_REQ_NO_FALLBACK
) &
196 source
->supported_zero_flags
);
199 state
->target
= bdrv_attach_child(top
, target
, "target", &child_of_bds
,
200 BDRV_CHILD_DATA
, errp
);
201 if (!state
->target
) {
207 bdrv_drained_begin(source
);
209 ret
= bdrv_append(top
, source
, errp
);
211 error_prepend(errp
, "Cannot append copy-before-write filter: ");
216 state
->bcs
= block_copy_state_new(top
->backing
, state
->target
,
217 false, compress
, errp
);
219 error_prepend(errp
, "Cannot create block-copy-state: ");
224 bdrv_drained_end(source
);
235 bdrv_drained_end(source
);
240 void bdrv_cbw_drop(BlockDriverState
*bs
)
242 BDRVCopyBeforeWriteState
*s
= bs
->opaque
;
244 bdrv_drop_filter(bs
, &error_abort
);
246 block_copy_state_free(s
->bcs
);