1 /*
2  * QEMU block dirty bitmap QMP commands
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * This work is licensed under the terms of the GNU GPL, version 2 or
7  * later.  See the COPYING file in the top-level directory.
8  *
9  * This file incorporates work covered by the following copyright and
10  * permission notice:
11  *
12  * Copyright (c) 2003-2008 Fabrice Bellard
13  *
14  * Permission is hereby granted, free of charge, to any person obtaining a copy
15  * of this software and associated documentation files (the "Software"), to deal
16  * in the Software without restriction, including without limitation the rights
17  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
18  * copies of the Software, and to permit persons to whom the Software is
19  * furnished to do so, subject to the following conditions:
20  *
21  * The above copyright notice and this permission notice shall be included in
22  * all copies or substantial portions of the Software.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
30  * THE SOFTWARE.
31  */
32 
33 #include "qemu/osdep.h"
34 
35 #include "block/block-io.h"
36 #include "block/block_int.h"
37 #include "block/dirty-bitmap.h"
38 #include "qapi/qapi-commands-block.h"
39 #include "qapi/error.h"
40 
41 /**
42  * block_dirty_bitmap_lookup:
43  * Return a dirty bitmap (if present), after validating
44  * the node reference and bitmap names.
45  *
46  * @node: The name of the BDS node to search for bitmaps
47  * @name: The name of the bitmap to search for
48  * @pbs: Output pointer for BDS lookup, if desired. Can be NULL.
49  * @errp: Output pointer for error information. Can be NULL.
50  *
51  * @return: A bitmap object on success, or NULL on failure.
52  */
53 BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,
54                                            const char *name,
55                                            BlockDriverState **pbs,
56                                            Error **errp)
57 {
58     BlockDriverState *bs;
59     BdrvDirtyBitmap *bitmap;
60 
61     GLOBAL_STATE_CODE();
62 
63     if (!node) {
64         error_setg(errp, "Node cannot be NULL");
65         return NULL;
66     }
67     if (!name) {
68         error_setg(errp, "Bitmap name cannot be NULL");
69         return NULL;
70     }
71     bs = bdrv_lookup_bs(node, node, NULL);
72     if (!bs) {
73         error_setg(errp, "Node '%s' not found", node);
74         return NULL;
75     }
76 
77     bitmap = bdrv_find_dirty_bitmap(bs, name);
78     if (!bitmap) {
79         error_setg(errp, "Dirty bitmap '%s' not found", name);
80         return NULL;
81     }
82 
83     if (pbs) {
84         *pbs = bs;
85     }
86 
87     return bitmap;
88 }
89 
90 void qmp_block_dirty_bitmap_add(const char *node, const char *name,
91                                 bool has_granularity, uint32_t granularity,
92                                 bool has_persistent, bool persistent,
93                                 bool has_disabled, bool disabled,
94                                 Error **errp)
95 {
96     BlockDriverState *bs;
97     BdrvDirtyBitmap *bitmap;
98 
99     if (!name || name[0] == '\0') {
100         error_setg(errp, "Bitmap name cannot be empty");
101         return;
102     }
103 
104     bs = bdrv_lookup_bs(node, node, errp);
105     if (!bs) {
106         return;
107     }
108 
109     if (has_granularity) {
110         if (granularity < 512 || !is_power_of_2(granularity)) {
111             error_setg(errp, "Granularity must be power of 2 "
112                              "and at least 512");
113             return;
114         }
115     } else {
116         /* Default to cluster size, if available: */
117         granularity = bdrv_get_default_bitmap_granularity(bs);
118     }
119 
120     if (!has_persistent) {
121         persistent = false;
122     }
123 
124     if (!has_disabled) {
125         disabled = false;
126     }
127 
128     if (persistent &&
129         !bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp))
130     {
131         return;
132     }
133 
134     bitmap = bdrv_create_dirty_bitmap(bs, granularity, name, errp);
135     if (bitmap == NULL) {
136         return;
137     }
138 
139     if (disabled) {
140         bdrv_disable_dirty_bitmap(bitmap);
141     }
142 
143     bdrv_dirty_bitmap_set_persistence(bitmap, persistent);
144 }
145 
146 BdrvDirtyBitmap *block_dirty_bitmap_remove(const char *node, const char *name,
147                                            bool release,
148                                            BlockDriverState **bitmap_bs,
149                                            Error **errp)
150 {
151     BlockDriverState *bs;
152     BdrvDirtyBitmap *bitmap;
153 
154     GLOBAL_STATE_CODE();
155 
156     bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
157     if (!bitmap || !bs) {
158         return NULL;
159     }
160 
161     if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY | BDRV_BITMAP_RO,
162                                 errp)) {
163         return NULL;
164     }
165 
166     if (bdrv_dirty_bitmap_get_persistence(bitmap) &&
167         bdrv_remove_persistent_dirty_bitmap(bs, name, errp) < 0)
168     {
169         return NULL;
170     }
171 
172     if (release) {
173         bdrv_release_dirty_bitmap(bitmap);
174     }
175 
176     if (bitmap_bs) {
177         *bitmap_bs = bs;
178     }
179 
180     return release ? NULL : bitmap;
181 }
182 
183 void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
184                                    Error **errp)
185 {
186     block_dirty_bitmap_remove(node, name, true, NULL, errp);
187 }
188 
189 /**
190  * Completely clear a bitmap, for the purposes of synchronizing a bitmap
191  * immediately after a full backup operation.
192  */
193 void qmp_block_dirty_bitmap_clear(const char *node, const char *name,
194                                   Error **errp)
195 {
196     BdrvDirtyBitmap *bitmap;
197     BlockDriverState *bs;
198 
199     bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
200     if (!bitmap || !bs) {
201         return;
202     }
203 
204     if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) {
205         return;
206     }
207 
208     bdrv_clear_dirty_bitmap(bitmap, NULL);
209 }
210 
211 void qmp_block_dirty_bitmap_enable(const char *node, const char *name,
212                                    Error **errp)
213 {
214     BlockDriverState *bs;
215     BdrvDirtyBitmap *bitmap;
216 
217     bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
218     if (!bitmap) {
219         return;
220     }
221 
222     if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
223         return;
224     }
225 
226     bdrv_enable_dirty_bitmap(bitmap);
227 }
228 
229 void qmp_block_dirty_bitmap_disable(const char *node, const char *name,
230                                     Error **errp)
231 {
232     BlockDriverState *bs;
233     BdrvDirtyBitmap *bitmap;
234 
235     bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp);
236     if (!bitmap) {
237         return;
238     }
239 
240     if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) {
241         return;
242     }
243 
244     bdrv_disable_dirty_bitmap(bitmap);
245 }
246 
247 BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *dst_node,
248                                           const char *dst_bitmap,
249                                           BlockDirtyBitmapOrStrList *bms,
250                                           HBitmap **backup, Error **errp)
251 {
252     BlockDriverState *bs;
253     BdrvDirtyBitmap *dst, *src;
254     BlockDirtyBitmapOrStrList *lst;
255     const char *src_node, *src_bitmap;
256     HBitmap *local_backup = NULL;
257 
258     GLOBAL_STATE_CODE();
259 
260     dst = block_dirty_bitmap_lookup(dst_node, dst_bitmap, &bs, errp);
261     if (!dst) {
262         return NULL;
263     }
264 
265     for (lst = bms; lst; lst = lst->next) {
266         switch (lst->value->type) {
267         case QTYPE_QSTRING:
268             src_bitmap = lst->value->u.local;
269             src = bdrv_find_dirty_bitmap(bs, src_bitmap);
270             if (!src) {
271                 error_setg(errp, "Dirty bitmap '%s' not found", src_bitmap);
272                 goto fail;
273             }
274             break;
275         case QTYPE_QDICT:
276             src_node = lst->value->u.external.node;
277             src_bitmap = lst->value->u.external.name;
278             src = block_dirty_bitmap_lookup(src_node, src_bitmap, NULL, errp);
279             if (!src) {
280                 goto fail;
281             }
282             break;
283         default:
284             abort();
285         }
286 
287         /* We do backup only for first merge operation */
288         if (!bdrv_merge_dirty_bitmap(dst, src,
289                                      local_backup ? NULL : &local_backup,
290                                      errp))
291         {
292             goto fail;
293         }
294     }
295 
296     if (backup) {
297         *backup = local_backup;
298     } else {
299         hbitmap_free(local_backup);
300     }
301 
302     return dst;
303 
304 fail:
305     if (local_backup) {
306         bdrv_restore_dirty_bitmap(dst, local_backup);
307     }
308 
309     return NULL;
310 }
311 
312 void qmp_block_dirty_bitmap_merge(const char *node, const char *target,
313                                   BlockDirtyBitmapOrStrList *bitmaps,
314                                   Error **errp)
315 {
316     block_dirty_bitmap_merge(node, target, bitmaps, NULL, errp);
317 }
318