1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27
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"
34
35#include "block/backup-top.h"
36
37typedef struct BDRVBackupTopState {
38 BlockCopyState *bcs;
39 BdrvChild *target;
40 bool active;
41 int64_t cluster_size;
42} BDRVBackupTopState;
43
44static coroutine_fn int backup_top_co_preadv(
45 BlockDriverState *bs, uint64_t offset, uint64_t bytes,
46 QEMUIOVector *qiov, int flags)
47{
48 return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);
49}
50
51static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset,
52 uint64_t bytes, BdrvRequestFlags flags)
53{
54 BDRVBackupTopState *s = bs->opaque;
55 uint64_t off, end;
56
57 if (flags & BDRV_REQ_WRITE_UNCHANGED) {
58 return 0;
59 }
60
61 off = QEMU_ALIGN_DOWN(offset, s->cluster_size);
62 end = QEMU_ALIGN_UP(offset + bytes, s->cluster_size);
63
64 return block_copy(s->bcs, off, end - off, NULL);
65}
66
67static int coroutine_fn backup_top_co_pdiscard(BlockDriverState *bs,
68 int64_t offset, int bytes)
69{
70 int ret = backup_top_cbw(bs, offset, bytes, 0);
71 if (ret < 0) {
72 return ret;
73 }
74
75 return bdrv_co_pdiscard(bs->backing, offset, bytes);
76}
77
78static int coroutine_fn backup_top_co_pwrite_zeroes(BlockDriverState *bs,
79 int64_t offset, int bytes, BdrvRequestFlags flags)
80{
81 int ret = backup_top_cbw(bs, offset, bytes, flags);
82 if (ret < 0) {
83 return ret;
84 }
85
86 return bdrv_co_pwrite_zeroes(bs->backing, offset, bytes, flags);
87}
88
89static coroutine_fn int backup_top_co_pwritev(BlockDriverState *bs,
90 uint64_t offset,
91 uint64_t bytes,
92 QEMUIOVector *qiov, int flags)
93{
94 int ret = backup_top_cbw(bs, offset, bytes, flags);
95 if (ret < 0) {
96 return ret;
97 }
98
99 return bdrv_co_pwritev(bs->backing, offset, bytes, qiov, flags);
100}
101
102static int coroutine_fn backup_top_co_flush(BlockDriverState *bs)
103{
104 if (!bs->backing) {
105 return 0;
106 }
107
108 return bdrv_co_flush(bs->backing->bs);
109}
110
111static void backup_top_refresh_filename(BlockDriverState *bs)
112{
113 if (bs->backing == NULL) {
114
115
116
117
118 return;
119 }
120 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
121 bs->backing->bs->filename);
122}
123
124static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
125 const BdrvChildRole *role,
126 BlockReopenQueue *reopen_queue,
127 uint64_t perm, uint64_t shared,
128 uint64_t *nperm, uint64_t *nshared)
129{
130 BDRVBackupTopState *s = bs->opaque;
131
132 if (!s->active) {
133
134
135
136
137
138
139
140 *nperm = 0;
141 *nshared = BLK_PERM_ALL;
142 return;
143 }
144
145 if (role == &child_file) {
146
147
148
149
150
151
152 *nshared = BLK_PERM_ALL;
153 *nperm = BLK_PERM_WRITE;
154 } else {
155
156 bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
157 nperm, nshared);
158
159 if (perm & BLK_PERM_WRITE) {
160 *nperm = *nperm | BLK_PERM_CONSISTENT_READ;
161 }
162 *nshared &= ~BLK_PERM_WRITE;
163 }
164}
165
166BlockDriver bdrv_backup_top_filter = {
167 .format_name = "backup-top",
168 .instance_size = sizeof(BDRVBackupTopState),
169
170 .bdrv_co_preadv = backup_top_co_preadv,
171 .bdrv_co_pwritev = backup_top_co_pwritev,
172 .bdrv_co_pwrite_zeroes = backup_top_co_pwrite_zeroes,
173 .bdrv_co_pdiscard = backup_top_co_pdiscard,
174 .bdrv_co_flush = backup_top_co_flush,
175
176 .bdrv_co_block_status = bdrv_co_block_status_from_backing,
177
178 .bdrv_refresh_filename = backup_top_refresh_filename,
179
180 .bdrv_child_perm = backup_top_child_perm,
181
182 .is_filter = true,
183};
184
185BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
186 BlockDriverState *target,
187 const char *filter_node_name,
188 uint64_t cluster_size,
189 BdrvRequestFlags write_flags,
190 BlockCopyState **bcs,
191 Error **errp)
192{
193 Error *local_err = NULL;
194 BDRVBackupTopState *state;
195 BlockDriverState *top = bdrv_new_open_driver(&bdrv_backup_top_filter,
196 filter_node_name,
197 BDRV_O_RDWR, errp);
198 bool appended = false;
199
200 if (!top) {
201 return NULL;
202 }
203
204 state = top->opaque;
205 top->total_sectors = source->total_sectors;
206 top->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
207 (BDRV_REQ_FUA & source->supported_write_flags);
208 top->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
209 ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
210 source->supported_zero_flags);
211
212 bdrv_ref(target);
213 state->target = bdrv_attach_child(top, target, "target", &child_file, errp);
214 if (!state->target) {
215 bdrv_unref(target);
216 bdrv_unref(top);
217 return NULL;
218 }
219
220 bdrv_drained_begin(source);
221
222 bdrv_ref(top);
223 bdrv_append(top, source, &local_err);
224 if (local_err) {
225 error_prepend(&local_err, "Cannot append backup-top filter: ");
226 goto fail;
227 }
228 appended = true;
229
230
231
232
233
234 state->active = true;
235 bdrv_child_refresh_perms(top, top->backing, &local_err);
236 if (local_err) {
237 error_prepend(&local_err,
238 "Cannot set permissions for backup-top filter: ");
239 goto fail;
240 }
241
242 state->cluster_size = cluster_size;
243 state->bcs = block_copy_state_new(top->backing, state->target,
244 cluster_size, write_flags, &local_err);
245 if (local_err) {
246 error_prepend(&local_err, "Cannot create block-copy-state: ");
247 goto fail;
248 }
249 *bcs = state->bcs;
250
251 bdrv_drained_end(source);
252
253 return top;
254
255fail:
256 if (appended) {
257 state->active = false;
258 bdrv_backup_top_drop(top);
259 } else {
260 bdrv_unref(top);
261 }
262
263 bdrv_drained_end(source);
264 error_propagate(errp, local_err);
265
266 return NULL;
267}
268
269void bdrv_backup_top_drop(BlockDriverState *bs)
270{
271 BDRVBackupTopState *s = bs->opaque;
272
273 bdrv_drained_begin(bs);
274
275 block_copy_state_free(s->bcs);
276
277 s->active = false;
278 bdrv_child_refresh_perms(bs, bs->backing, &error_abort);
279 bdrv_replace_node(bs, backing_bs(bs), &error_abort);
280 bdrv_set_backing_hd(bs, NULL, &error_abort);
281
282 bdrv_drained_end(bs);
283
284 bdrv_unref(bs);
285}
286