Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Block Dirty Bitmap |
| 3 | * |
Eric Blake | 1b6cc57 | 2017-09-25 09:55:11 -0500 | [diff] [blame] | 4 | * Copyright (c) 2016-2017 Red Hat. Inc |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to deal |
| 8 | * in the Software without restriction, including without limitation the rights |
| 9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | * copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in |
| 14 | * all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | * THE SOFTWARE. |
| 23 | */ |
| 24 | #include "qemu/osdep.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 25 | #include "qapi/error.h" |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 26 | #include "trace.h" |
| 27 | #include "block/block_int.h" |
| 28 | #include "block/blockjob.h" |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 29 | #include "qemu/main-loop.h" |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 30 | |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 31 | struct BdrvDirtyBitmap { |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 32 | BlockDriverState *bs; |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 33 | HBitmap *bitmap; /* Dirty bitmap implementation */ |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 34 | bool busy; /* Bitmap is busy, it can't be used via QMP */ |
John Snow | 21d2376 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 35 | BdrvDirtyBitmap *successor; /* Anonymous child, if any. */ |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 36 | char *name; /* Optional non-empty unique ID */ |
Eric Blake | 993e652 | 2017-09-25 09:55:13 -0500 | [diff] [blame] | 37 | int64_t size; /* Size of the bitmap, in bytes */ |
Vladimir Sementsov-Ogievskiy | 8bfc932 | 2017-06-28 15:05:09 +0300 | [diff] [blame] | 38 | bool disabled; /* Bitmap is disabled. It ignores all writes to |
| 39 | the device */ |
Fam Zheng | dc162c8 | 2016-10-13 17:58:21 -0400 | [diff] [blame] | 40 | int active_iterators; /* How many iterators are active */ |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 41 | bool readonly; /* Bitmap is read-only. This field also |
| 42 | prevents the respective image from being |
| 43 | modified (i.e. blocks writes and discards). |
| 44 | Such operations must fail and both the image |
| 45 | and this bitmap must remain unchanged while |
| 46 | this flag is set. */ |
Vladimir Sementsov-Ogievskiy | a88b179 | 2017-06-28 15:05:17 +0300 | [diff] [blame] | 47 | bool persistent; /* bitmap must be saved to owner disk image */ |
John Snow | b0f4555 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 48 | bool inconsistent; /* bitmap is persistent, but inconsistent. |
| 49 | It cannot be used at all in any way, except |
| 50 | a QMP user can remove it. */ |
John Snow | c4e4b0f | 2019-07-29 16:35:54 -0400 | [diff] [blame] | 51 | bool skip_store; /* We are either migrating or deleting this |
| 52 | * bitmap; it should not be stored on the next |
| 53 | * inactivation. */ |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 54 | QLIST_ENTRY(BdrvDirtyBitmap) list; |
| 55 | }; |
| 56 | |
Fam Zheng | dc162c8 | 2016-10-13 17:58:21 -0400 | [diff] [blame] | 57 | struct BdrvDirtyBitmapIter { |
| 58 | HBitmapIter hbi; |
| 59 | BdrvDirtyBitmap *bitmap; |
| 60 | }; |
| 61 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 62 | static inline void bdrv_dirty_bitmaps_lock(BlockDriverState *bs) |
| 63 | { |
| 64 | qemu_mutex_lock(&bs->dirty_bitmap_mutex); |
| 65 | } |
| 66 | |
| 67 | static inline void bdrv_dirty_bitmaps_unlock(BlockDriverState *bs) |
| 68 | { |
| 69 | qemu_mutex_unlock(&bs->dirty_bitmap_mutex); |
| 70 | } |
| 71 | |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 72 | void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap) |
| 73 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 74 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap *bitmap) |
| 78 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 79 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 80 | } |
| 81 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 82 | /* Called with BQL or dirty_bitmap lock taken. */ |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 83 | BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, const char *name) |
| 84 | { |
| 85 | BdrvDirtyBitmap *bm; |
| 86 | |
| 87 | assert(name); |
| 88 | QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) { |
| 89 | if (bm->name && !strcmp(name, bm->name)) { |
| 90 | return bm; |
| 91 | } |
| 92 | } |
| 93 | return NULL; |
| 94 | } |
| 95 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 96 | /* Called with BQL taken. */ |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 97 | BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, |
| 98 | uint32_t granularity, |
| 99 | const char *name, |
| 100 | Error **errp) |
| 101 | { |
| 102 | int64_t bitmap_size; |
| 103 | BdrvDirtyBitmap *bitmap; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 104 | |
Eric Blake | 993e652 | 2017-09-25 09:55:13 -0500 | [diff] [blame] | 105 | assert(is_power_of_2(granularity) && granularity >= BDRV_SECTOR_SIZE); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 106 | |
Eric Blake | cf7c49c | 2019-11-13 20:46:33 -0600 | [diff] [blame] | 107 | if (name) { |
| 108 | if (bdrv_find_dirty_bitmap(bs, name)) { |
| 109 | error_setg(errp, "Bitmap already exists: %s", name); |
| 110 | return NULL; |
| 111 | } |
| 112 | if (strlen(name) > BDRV_BITMAP_MAX_NAME_SIZE) { |
| 113 | error_setg(errp, "Bitmap name too long: %s", name); |
| 114 | return NULL; |
| 115 | } |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 116 | } |
Eric Blake | 993e652 | 2017-09-25 09:55:13 -0500 | [diff] [blame] | 117 | bitmap_size = bdrv_getlength(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 118 | if (bitmap_size < 0) { |
| 119 | error_setg_errno(errp, -bitmap_size, "could not get length of device"); |
| 120 | errno = -bitmap_size; |
| 121 | return NULL; |
| 122 | } |
| 123 | bitmap = g_new0(BdrvDirtyBitmap, 1); |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 124 | bitmap->bs = bs; |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 125 | bitmap->bitmap = hbitmap_alloc(bitmap_size, ctz32(granularity)); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 126 | bitmap->size = bitmap_size; |
| 127 | bitmap->name = g_strdup(name); |
| 128 | bitmap->disabled = false; |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 129 | bdrv_dirty_bitmaps_lock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 130 | QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list); |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 131 | bdrv_dirty_bitmaps_unlock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 132 | return bitmap; |
| 133 | } |
| 134 | |
Fam Zheng | 15891fa | 2016-10-13 17:58:25 -0400 | [diff] [blame] | 135 | int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap) |
| 136 | { |
Eric Blake | 993e652 | 2017-09-25 09:55:13 -0500 | [diff] [blame] | 137 | return bitmap->size; |
Fam Zheng | 15891fa | 2016-10-13 17:58:25 -0400 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap) |
| 141 | { |
| 142 | return bitmap->name; |
| 143 | } |
| 144 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 145 | /* Called with BQL taken. */ |
John Snow | 50a4725 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 146 | bool bdrv_dirty_bitmap_has_successor(BdrvDirtyBitmap *bitmap) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 147 | { |
| 148 | return bitmap->successor; |
| 149 | } |
| 150 | |
John Snow | 3ae96d6 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 151 | static bool bdrv_dirty_bitmap_busy(const BdrvDirtyBitmap *bitmap) |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 152 | { |
| 153 | return bitmap->busy; |
John Snow | 993edc0 | 2018-10-29 16:23:16 -0400 | [diff] [blame] | 154 | } |
| 155 | |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 156 | void bdrv_dirty_bitmap_set_busy(BdrvDirtyBitmap *bitmap, bool busy) |
Vladimir Sementsov-Ogievskiy | 4f43e95 | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 157 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 158 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 159 | bitmap->busy = busy; |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 160 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | 4f43e95 | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 161 | } |
| 162 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 163 | /* Called with BQL taken. */ |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 164 | bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap) |
| 165 | { |
John Snow | 8b2e20f | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 166 | return !bitmap->disabled; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 167 | } |
| 168 | |
John Snow | 4db6ceb | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 169 | /* Called with BQL taken. */ |
| 170 | static bool bdrv_dirty_bitmap_recording(BdrvDirtyBitmap *bitmap) |
| 171 | { |
| 172 | return !bitmap->disabled || (bitmap->successor && |
| 173 | !bitmap->successor->disabled); |
| 174 | } |
| 175 | |
John Snow | 3ae96d6 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 176 | int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags, |
| 177 | Error **errp) |
| 178 | { |
| 179 | if ((flags & BDRV_BITMAP_BUSY) && bdrv_dirty_bitmap_busy(bitmap)) { |
| 180 | error_setg(errp, "Bitmap '%s' is currently in use by another" |
| 181 | " operation and cannot be used", bitmap->name); |
| 182 | return -1; |
| 183 | } |
| 184 | |
| 185 | if ((flags & BDRV_BITMAP_RO) && bdrv_dirty_bitmap_readonly(bitmap)) { |
| 186 | error_setg(errp, "Bitmap '%s' is readonly and cannot be modified", |
| 187 | bitmap->name); |
| 188 | return -1; |
| 189 | } |
| 190 | |
| 191 | if ((flags & BDRV_BITMAP_INCONSISTENT) && |
| 192 | bdrv_dirty_bitmap_inconsistent(bitmap)) { |
| 193 | error_setg(errp, "Bitmap '%s' is inconsistent and cannot be used", |
| 194 | bitmap->name); |
| 195 | error_append_hint(errp, "Try block-dirty-bitmap-remove to delete" |
Eric Blake | 94075c2 | 2021-07-09 10:39:49 -0500 | [diff] [blame] | 196 | " this bitmap from disk\n"); |
John Snow | 3ae96d6 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 197 | return -1; |
| 198 | } |
| 199 | |
| 200 | return 0; |
| 201 | } |
| 202 | |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 203 | /** |
| 204 | * Create a successor bitmap destined to replace this bitmap after an operation. |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 205 | * Requires that the bitmap is not marked busy and has no successor. |
John Snow | 8b2e20f | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 206 | * The successor will be enabled if the parent bitmap was. |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 207 | * Called with BQL taken. |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 208 | */ |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 209 | int bdrv_dirty_bitmap_create_successor(BdrvDirtyBitmap *bitmap, Error **errp) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 210 | { |
| 211 | uint64_t granularity; |
| 212 | BdrvDirtyBitmap *child; |
| 213 | |
John Snow | 3ae96d6 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 214 | if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY, errp)) { |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 215 | return -1; |
| 216 | } |
John Snow | 50a4725 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 217 | if (bdrv_dirty_bitmap_has_successor(bitmap)) { |
| 218 | error_setg(errp, "Cannot create a successor for a bitmap that already " |
| 219 | "has one"); |
| 220 | return -1; |
| 221 | } |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 222 | |
| 223 | /* Create an anonymous successor */ |
| 224 | granularity = bdrv_dirty_bitmap_granularity(bitmap); |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 225 | child = bdrv_create_dirty_bitmap(bitmap->bs, granularity, NULL, errp); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 226 | if (!child) { |
| 227 | return -1; |
| 228 | } |
| 229 | |
| 230 | /* Successor will be on or off based on our current state. */ |
| 231 | child->disabled = bitmap->disabled; |
John Snow | 8b2e20f | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 232 | bitmap->disabled = true; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 233 | |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 234 | /* Install the successor and mark the parent as busy */ |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 235 | bitmap->successor = child; |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 236 | bitmap->busy = true; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 237 | return 0; |
| 238 | } |
| 239 | |
Vladimir Sementsov-Ogievskiy | 92bcea4 | 2018-07-04 02:12:49 -0400 | [diff] [blame] | 240 | void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap) |
| 241 | { |
Vladimir Sementsov-Ogievskiy | 92bcea4 | 2018-07-04 02:12:49 -0400 | [diff] [blame] | 242 | bitmap->disabled = false; |
| 243 | } |
| 244 | |
Vladimir Sementsov-Ogievskiy | e73a265 | 2018-03-13 15:33:59 -0400 | [diff] [blame] | 245 | /* Called with BQL taken. */ |
| 246 | void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap) |
| 247 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 248 | assert(bitmap->bs == bitmap->successor->bs); |
| 249 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | 58f72b9 | 2018-07-04 02:12:49 -0400 | [diff] [blame] | 250 | bdrv_enable_dirty_bitmap_locked(bitmap->successor); |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 251 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | e73a265 | 2018-03-13 15:33:59 -0400 | [diff] [blame] | 252 | } |
| 253 | |
Paolo Bonzini | b133c27 | 2018-06-11 14:53:31 -0400 | [diff] [blame] | 254 | /* Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken. */ |
| 255 | static void bdrv_release_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap) |
Vladimir Sementsov-Ogievskiy | 604ab74 | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 256 | { |
Paolo Bonzini | b133c27 | 2018-06-11 14:53:31 -0400 | [diff] [blame] | 257 | assert(!bitmap->active_iterators); |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 258 | assert(!bdrv_dirty_bitmap_busy(bitmap)); |
John Snow | 50a4725 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 259 | assert(!bdrv_dirty_bitmap_has_successor(bitmap)); |
Paolo Bonzini | b133c27 | 2018-06-11 14:53:31 -0400 | [diff] [blame] | 260 | QLIST_REMOVE(bitmap, list); |
| 261 | hbitmap_free(bitmap->bitmap); |
| 262 | g_free(bitmap->name); |
| 263 | g_free(bitmap); |
Vladimir Sementsov-Ogievskiy | 604ab74 | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 264 | } |
| 265 | |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 266 | /** |
| 267 | * For a bitmap with a successor, yield our name to the successor, |
| 268 | * delete the old bitmap, and return a handle to the new bitmap. |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 269 | * Called with BQL taken. |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 270 | */ |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 271 | BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BdrvDirtyBitmap *bitmap, |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 272 | Error **errp) |
| 273 | { |
| 274 | char *name; |
| 275 | BdrvDirtyBitmap *successor = bitmap->successor; |
| 276 | |
| 277 | if (successor == NULL) { |
| 278 | error_setg(errp, "Cannot relinquish control if " |
| 279 | "there's no successor present"); |
| 280 | return NULL; |
| 281 | } |
| 282 | |
| 283 | name = bitmap->name; |
| 284 | bitmap->name = NULL; |
| 285 | successor->name = name; |
| 286 | bitmap->successor = NULL; |
Vladimir Sementsov-Ogievskiy | a88b179 | 2017-06-28 15:05:17 +0300 | [diff] [blame] | 287 | successor->persistent = bitmap->persistent; |
| 288 | bitmap->persistent = false; |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 289 | bitmap->busy = false; |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 290 | bdrv_release_dirty_bitmap(bitmap); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 291 | |
| 292 | return successor; |
| 293 | } |
| 294 | |
| 295 | /** |
| 296 | * In cases of failure where we can no longer safely delete the parent, |
| 297 | * we may wish to re-join the parent and child/successor. |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 298 | * The merged parent will be marked as not busy. |
John Snow | 8b2e20f | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 299 | * The marged parent will be enabled if and only if the successor was enabled. |
Vladimir Sementsov-Ogievskiy | 044ee8e | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 300 | * Called within bdrv_dirty_bitmap_lock..unlock and with BQL taken. |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 301 | */ |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 302 | BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap *parent, |
Vladimir Sementsov-Ogievskiy | 044ee8e | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 303 | Error **errp) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 304 | { |
Vladimir Sementsov-Ogievskiy | 044ee8e | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 305 | BdrvDirtyBitmap *successor = parent->successor; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 306 | |
| 307 | if (!successor) { |
| 308 | error_setg(errp, "Cannot reclaim a successor when none is present"); |
| 309 | return NULL; |
| 310 | } |
| 311 | |
Vladimir Sementsov-Ogievskiy | fa000f2 | 2018-10-29 16:23:15 -0400 | [diff] [blame] | 312 | if (!hbitmap_merge(parent->bitmap, successor->bitmap, parent->bitmap)) { |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 313 | error_setg(errp, "Merging of parent and successor bitmap failed"); |
| 314 | return NULL; |
| 315 | } |
John Snow | 8b2e20f | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 316 | |
| 317 | parent->disabled = successor->disabled; |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 318 | parent->busy = false; |
Paolo Bonzini | b133c27 | 2018-06-11 14:53:31 -0400 | [diff] [blame] | 319 | bdrv_release_dirty_bitmap_locked(successor); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 320 | parent->successor = NULL; |
| 321 | |
Vladimir Sementsov-Ogievskiy | 044ee8e | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 322 | return parent; |
| 323 | } |
| 324 | |
| 325 | /* Called with BQL taken. */ |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 326 | BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BdrvDirtyBitmap *parent, |
Vladimir Sementsov-Ogievskiy | 044ee8e | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 327 | Error **errp) |
| 328 | { |
| 329 | BdrvDirtyBitmap *ret; |
| 330 | |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 331 | bdrv_dirty_bitmaps_lock(parent->bs); |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 332 | ret = bdrv_reclaim_dirty_bitmap_locked(parent, errp); |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 333 | bdrv_dirty_bitmaps_unlock(parent->bs); |
Vladimir Sementsov-Ogievskiy | 604ab74 | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 334 | |
Vladimir Sementsov-Ogievskiy | 044ee8e | 2018-03-13 15:34:00 -0400 | [diff] [blame] | 335 | return ret; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | /** |
| 339 | * Truncates _all_ bitmaps attached to a BDS. |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 340 | * Called with BQL taken. |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 341 | */ |
Eric Blake | 1b6cc57 | 2017-09-25 09:55:11 -0500 | [diff] [blame] | 342 | void bdrv_dirty_bitmap_truncate(BlockDriverState *bs, int64_t bytes) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 343 | { |
| 344 | BdrvDirtyBitmap *bitmap; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 345 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 346 | bdrv_dirty_bitmaps_lock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 347 | QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) { |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 348 | assert(!bdrv_dirty_bitmap_busy(bitmap)); |
John Snow | 50a4725 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 349 | assert(!bdrv_dirty_bitmap_has_successor(bitmap)); |
Fam Zheng | dc162c8 | 2016-10-13 17:58:21 -0400 | [diff] [blame] | 350 | assert(!bitmap->active_iterators); |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 351 | hbitmap_truncate(bitmap->bitmap, bytes); |
Eric Blake | 993e652 | 2017-09-25 09:55:13 -0500 | [diff] [blame] | 352 | bitmap->size = bytes; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 353 | } |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 354 | bdrv_dirty_bitmaps_unlock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 355 | } |
| 356 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 357 | /* Called with BQL taken. */ |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 358 | void bdrv_release_dirty_bitmap(BdrvDirtyBitmap *bitmap) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 359 | { |
Vladimir Sementsov-Ogievskiy | 5deb6cb | 2019-09-16 17:19:09 +0300 | [diff] [blame] | 360 | BlockDriverState *bs = bitmap->bs; |
| 361 | |
Paolo Bonzini | b133c27 | 2018-06-11 14:53:31 -0400 | [diff] [blame] | 362 | bdrv_dirty_bitmaps_lock(bs); |
| 363 | bdrv_release_dirty_bitmap_locked(bitmap); |
| 364 | bdrv_dirty_bitmaps_unlock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | /** |
| 368 | * Release all named dirty bitmaps attached to a BDS (for use in bdrv_close()). |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 369 | * There must not be any busy bitmaps attached. |
Vladimir Sementsov-Ogievskiy | 56f364e | 2017-06-28 15:05:27 +0300 | [diff] [blame] | 370 | * This function does not remove persistent bitmaps from the storage. |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 371 | * Called with BQL taken. |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 372 | */ |
| 373 | void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs) |
| 374 | { |
Paolo Bonzini | b133c27 | 2018-06-11 14:53:31 -0400 | [diff] [blame] | 375 | BdrvDirtyBitmap *bm, *next; |
| 376 | |
| 377 | bdrv_dirty_bitmaps_lock(bs); |
| 378 | QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) { |
| 379 | if (bdrv_dirty_bitmap_name(bm)) { |
| 380 | bdrv_release_dirty_bitmap_locked(bm); |
| 381 | } |
| 382 | } |
| 383 | bdrv_dirty_bitmaps_unlock(bs); |
Vladimir Sementsov-Ogievskiy | 615b5dc | 2017-06-28 15:05:30 +0300 | [diff] [blame] | 384 | } |
| 385 | |
| 386 | /** |
Vladimir Sementsov-Ogievskiy | 56f364e | 2017-06-28 15:05:27 +0300 | [diff] [blame] | 387 | * Remove persistent dirty bitmap from the storage if it exists. |
| 388 | * Absence of bitmap is not an error, because we have the following scenario: |
| 389 | * BdrvDirtyBitmap can have .persistent = true but not yet saved and have no |
| 390 | * stored version. For such bitmap bdrv_remove_persistent_dirty_bitmap() should |
| 391 | * not fail. |
| 392 | * This function doesn't release corresponding BdrvDirtyBitmap. |
| 393 | */ |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 394 | static int coroutine_fn |
| 395 | bdrv_co_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name, |
| 396 | Error **errp) |
Vladimir Sementsov-Ogievskiy | 56f364e | 2017-06-28 15:05:27 +0300 | [diff] [blame] | 397 | { |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 398 | if (bs->drv && bs->drv->bdrv_co_remove_persistent_dirty_bitmap) { |
| 399 | return bs->drv->bdrv_co_remove_persistent_dirty_bitmap(bs, name, errp); |
Vladimir Sementsov-Ogievskiy | 56f364e | 2017-06-28 15:05:27 +0300 | [diff] [blame] | 400 | } |
Vladimir Sementsov-Ogievskiy | b56a1e3 | 2019-09-20 11:25:42 +0300 | [diff] [blame] | 401 | |
| 402 | return 0; |
Vladimir Sementsov-Ogievskiy | 56f364e | 2017-06-28 15:05:27 +0300 | [diff] [blame] | 403 | } |
| 404 | |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 405 | typedef struct BdrvRemovePersistentDirtyBitmapCo { |
| 406 | BlockDriverState *bs; |
| 407 | const char *name; |
| 408 | Error **errp; |
| 409 | int ret; |
| 410 | } BdrvRemovePersistentDirtyBitmapCo; |
| 411 | |
| 412 | static void coroutine_fn |
| 413 | bdrv_co_remove_persistent_dirty_bitmap_entry(void *opaque) |
| 414 | { |
| 415 | BdrvRemovePersistentDirtyBitmapCo *s = opaque; |
| 416 | |
| 417 | s->ret = bdrv_co_remove_persistent_dirty_bitmap(s->bs, s->name, s->errp); |
| 418 | aio_wait_kick(); |
| 419 | } |
| 420 | |
| 421 | int bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name, |
| 422 | Error **errp) |
| 423 | { |
| 424 | if (qemu_in_coroutine()) { |
| 425 | return bdrv_co_remove_persistent_dirty_bitmap(bs, name, errp); |
| 426 | } else { |
| 427 | Coroutine *co; |
| 428 | BdrvRemovePersistentDirtyBitmapCo s = { |
| 429 | .bs = bs, |
| 430 | .name = name, |
| 431 | .errp = errp, |
| 432 | .ret = -EINPROGRESS, |
| 433 | }; |
| 434 | |
| 435 | co = qemu_coroutine_create(bdrv_co_remove_persistent_dirty_bitmap_entry, |
| 436 | &s); |
| 437 | bdrv_coroutine_enter(bs, co); |
| 438 | BDRV_POLL_WHILE(bs, s.ret == -EINPROGRESS); |
| 439 | |
| 440 | return s.ret; |
| 441 | } |
| 442 | } |
| 443 | |
Eric Blake | ef893b5 | 2020-05-12 20:16:42 -0500 | [diff] [blame] | 444 | bool |
| 445 | bdrv_supports_persistent_dirty_bitmap(BlockDriverState *bs) |
| 446 | { |
| 447 | if (bs->drv && bs->drv->bdrv_supports_persistent_dirty_bitmap) { |
| 448 | return bs->drv->bdrv_supports_persistent_dirty_bitmap(bs); |
| 449 | } |
| 450 | return false; |
| 451 | } |
| 452 | |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 453 | static bool coroutine_fn |
| 454 | bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name, |
| 455 | uint32_t granularity, Error **errp) |
Vladimir Sementsov-Ogievskiy | 85cc8a4 | 2019-09-20 11:25:41 +0300 | [diff] [blame] | 456 | { |
| 457 | BlockDriver *drv = bs->drv; |
| 458 | |
| 459 | if (!drv) { |
| 460 | error_setg_errno(errp, ENOMEDIUM, |
| 461 | "Can't store persistent bitmaps to %s", |
| 462 | bdrv_get_device_or_node_name(bs)); |
| 463 | return false; |
| 464 | } |
| 465 | |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 466 | if (!drv->bdrv_co_can_store_new_dirty_bitmap) { |
Vladimir Sementsov-Ogievskiy | 85cc8a4 | 2019-09-20 11:25:41 +0300 | [diff] [blame] | 467 | error_setg_errno(errp, ENOTSUP, |
| 468 | "Can't store persistent bitmaps to %s", |
| 469 | bdrv_get_device_or_node_name(bs)); |
| 470 | return false; |
| 471 | } |
| 472 | |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 473 | return drv->bdrv_co_can_store_new_dirty_bitmap(bs, name, granularity, errp); |
| 474 | } |
| 475 | |
| 476 | typedef struct BdrvCanStoreNewDirtyBitmapCo { |
| 477 | BlockDriverState *bs; |
| 478 | const char *name; |
| 479 | uint32_t granularity; |
| 480 | Error **errp; |
| 481 | bool ret; |
| 482 | |
| 483 | bool in_progress; |
| 484 | } BdrvCanStoreNewDirtyBitmapCo; |
| 485 | |
| 486 | static void coroutine_fn bdrv_co_can_store_new_dirty_bitmap_entry(void *opaque) |
| 487 | { |
| 488 | BdrvCanStoreNewDirtyBitmapCo *s = opaque; |
| 489 | |
| 490 | s->ret = bdrv_co_can_store_new_dirty_bitmap(s->bs, s->name, s->granularity, |
| 491 | s->errp); |
| 492 | s->in_progress = false; |
| 493 | aio_wait_kick(); |
| 494 | } |
| 495 | |
| 496 | bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name, |
| 497 | uint32_t granularity, Error **errp) |
| 498 | { |
Emanuele Giuseppe Esposito | 384a48f | 2022-03-03 10:15:50 -0500 | [diff] [blame] | 499 | IO_CODE(); |
Vladimir Sementsov-Ogievskiy | d2c3080 | 2019-09-20 11:25:43 +0300 | [diff] [blame] | 500 | if (qemu_in_coroutine()) { |
| 501 | return bdrv_co_can_store_new_dirty_bitmap(bs, name, granularity, errp); |
| 502 | } else { |
| 503 | Coroutine *co; |
| 504 | BdrvCanStoreNewDirtyBitmapCo s = { |
| 505 | .bs = bs, |
| 506 | .name = name, |
| 507 | .granularity = granularity, |
| 508 | .errp = errp, |
| 509 | .in_progress = true, |
| 510 | }; |
| 511 | |
| 512 | co = qemu_coroutine_create(bdrv_co_can_store_new_dirty_bitmap_entry, |
| 513 | &s); |
| 514 | bdrv_coroutine_enter(bs, co); |
| 515 | BDRV_POLL_WHILE(bs, s.in_progress); |
| 516 | |
| 517 | return s.ret; |
| 518 | } |
Vladimir Sementsov-Ogievskiy | 85cc8a4 | 2019-09-20 11:25:41 +0300 | [diff] [blame] | 519 | } |
| 520 | |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 521 | void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap) |
| 522 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 523 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 524 | bitmap->disabled = true; |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 525 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 526 | } |
| 527 | |
| 528 | void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap) |
| 529 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 530 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | 92bcea4 | 2018-07-04 02:12:49 -0400 | [diff] [blame] | 531 | bdrv_enable_dirty_bitmap_locked(bitmap); |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 532 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 533 | } |
| 534 | |
| 535 | BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs) |
| 536 | { |
| 537 | BdrvDirtyBitmap *bm; |
| 538 | BlockDirtyInfoList *list = NULL; |
Eric Blake | c3033fd | 2021-01-13 16:10:12 -0600 | [diff] [blame] | 539 | BlockDirtyInfoList **tail = &list; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 540 | |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 541 | bdrv_dirty_bitmaps_lock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 542 | QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) { |
| 543 | BlockDirtyInfo *info = g_new0(BlockDirtyInfo, 1); |
Eric Blake | c3033fd | 2021-01-13 16:10:12 -0600 | [diff] [blame] | 544 | |
Eric Blake | 9a46dba | 2017-09-25 09:55:18 -0500 | [diff] [blame] | 545 | info->count = bdrv_get_dirty_count(bm); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 546 | info->granularity = bdrv_dirty_bitmap_granularity(bm); |
| 547 | info->has_name = !!bm->name; |
| 548 | info->name = g_strdup(bm->name); |
John Snow | 4db6ceb | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 549 | info->recording = bdrv_dirty_bitmap_recording(bm); |
John Snow | 27a1b30 | 2019-03-12 12:05:48 -0400 | [diff] [blame] | 550 | info->busy = bdrv_dirty_bitmap_busy(bm); |
Eric Blake | f67cf66 | 2019-02-19 17:49:43 -0500 | [diff] [blame] | 551 | info->persistent = bm->persistent; |
John Snow | b0f4555 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 552 | info->has_inconsistent = bm->inconsistent; |
| 553 | info->inconsistent = bm->inconsistent; |
Eric Blake | c3033fd | 2021-01-13 16:10:12 -0600 | [diff] [blame] | 554 | QAPI_LIST_APPEND(tail, info); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 555 | } |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 556 | bdrv_dirty_bitmaps_unlock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 557 | |
| 558 | return list; |
| 559 | } |
| 560 | |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 561 | /* Called within bdrv_dirty_bitmap_lock..unlock */ |
John Snow | 28636b8 | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 562 | bool bdrv_dirty_bitmap_get_locked(BdrvDirtyBitmap *bitmap, int64_t offset) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 563 | { |
John Snow | 28636b8 | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 564 | return hbitmap_get(bitmap->bitmap, offset); |
| 565 | } |
| 566 | |
| 567 | bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap *bitmap, int64_t offset) |
| 568 | { |
| 569 | bool ret; |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 570 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
John Snow | 28636b8 | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 571 | ret = bdrv_dirty_bitmap_get_locked(bitmap, offset); |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 572 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
John Snow | 28636b8 | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 573 | |
| 574 | return ret; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 575 | } |
| 576 | |
| 577 | /** |
| 578 | * Chooses a default granularity based on the existing cluster size, |
| 579 | * but clamped between [4K, 64K]. Defaults to 64K in the case that there |
| 580 | * is no cluster size information available. |
| 581 | */ |
| 582 | uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs) |
| 583 | { |
| 584 | BlockDriverInfo bdi; |
| 585 | uint32_t granularity; |
| 586 | |
| 587 | if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) { |
| 588 | granularity = MAX(4096, bdi.cluster_size); |
| 589 | granularity = MIN(65536, granularity); |
| 590 | } else { |
| 591 | granularity = 65536; |
| 592 | } |
| 593 | |
| 594 | return granularity; |
| 595 | } |
| 596 | |
Vladimir Sementsov-Ogievskiy | ba06ff1 | 2017-06-28 15:05:05 +0300 | [diff] [blame] | 597 | uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 598 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 599 | return 1U << hbitmap_granularity(bitmap->bitmap); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 600 | } |
| 601 | |
Eric Blake | 715a74d | 2017-09-25 09:55:16 -0500 | [diff] [blame] | 602 | BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 603 | { |
Fam Zheng | dc162c8 | 2016-10-13 17:58:21 -0400 | [diff] [blame] | 604 | BdrvDirtyBitmapIter *iter = g_new(BdrvDirtyBitmapIter, 1); |
Eric Blake | 715a74d | 2017-09-25 09:55:16 -0500 | [diff] [blame] | 605 | hbitmap_iter_init(&iter->hbi, bitmap->bitmap, 0); |
Fam Zheng | dc162c8 | 2016-10-13 17:58:21 -0400 | [diff] [blame] | 606 | iter->bitmap = bitmap; |
| 607 | bitmap->active_iterators++; |
| 608 | return iter; |
| 609 | } |
| 610 | |
| 611 | void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter) |
| 612 | { |
| 613 | if (!iter) { |
| 614 | return; |
| 615 | } |
| 616 | assert(iter->bitmap->active_iterators > 0); |
| 617 | iter->bitmap->active_iterators--; |
| 618 | g_free(iter); |
| 619 | } |
| 620 | |
| 621 | int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter) |
| 622 | { |
Vladimir Sementsov-Ogievskiy | 19c021e | 2019-01-15 18:26:50 -0500 | [diff] [blame] | 623 | return hbitmap_iter_next(&iter->hbi); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 624 | } |
| 625 | |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 626 | /* Called within bdrv_dirty_bitmap_lock..unlock */ |
| 627 | void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap, |
Eric Blake | e0d7f73 | 2017-09-25 09:55:20 -0500 | [diff] [blame] | 628 | int64_t offset, int64_t bytes) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 629 | { |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 630 | assert(!bdrv_dirty_bitmap_readonly(bitmap)); |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 631 | hbitmap_set(bitmap->bitmap, offset, bytes); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 632 | } |
| 633 | |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 634 | void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap, |
Eric Blake | e0d7f73 | 2017-09-25 09:55:20 -0500 | [diff] [blame] | 635 | int64_t offset, int64_t bytes) |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 636 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 637 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Eric Blake | e0d7f73 | 2017-09-25 09:55:20 -0500 | [diff] [blame] | 638 | bdrv_set_dirty_bitmap_locked(bitmap, offset, bytes); |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 639 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 640 | } |
| 641 | |
| 642 | /* Called within bdrv_dirty_bitmap_lock..unlock */ |
| 643 | void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap, |
Eric Blake | e0d7f73 | 2017-09-25 09:55:20 -0500 | [diff] [blame] | 644 | int64_t offset, int64_t bytes) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 645 | { |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 646 | assert(!bdrv_dirty_bitmap_readonly(bitmap)); |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 647 | hbitmap_reset(bitmap->bitmap, offset, bytes); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 648 | } |
| 649 | |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 650 | void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap, |
Eric Blake | e0d7f73 | 2017-09-25 09:55:20 -0500 | [diff] [blame] | 651 | int64_t offset, int64_t bytes) |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 652 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 653 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Eric Blake | e0d7f73 | 2017-09-25 09:55:20 -0500 | [diff] [blame] | 654 | bdrv_reset_dirty_bitmap_locked(bitmap, offset, bytes); |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 655 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Paolo Bonzini | b64bd51 | 2017-06-05 14:39:05 +0200 | [diff] [blame] | 656 | } |
| 657 | |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 658 | void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out) |
| 659 | { |
Emanuele Giuseppe Esposito | 967d790 | 2022-03-03 10:15:58 -0500 | [diff] [blame] | 660 | IO_CODE(); |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 661 | assert(!bdrv_dirty_bitmap_readonly(bitmap)); |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 662 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 663 | if (!out) { |
| 664 | hbitmap_reset_all(bitmap->bitmap); |
| 665 | } else { |
| 666 | HBitmap *backup = bitmap->bitmap; |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 667 | bitmap->bitmap = hbitmap_alloc(bitmap->size, |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 668 | hbitmap_granularity(backup)); |
| 669 | *out = backup; |
| 670 | } |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 671 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 672 | } |
| 673 | |
Vladimir Sementsov-Ogievskiy | 56bd662 | 2018-10-29 16:23:14 -0400 | [diff] [blame] | 674 | void bdrv_restore_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *backup) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 675 | { |
| 676 | HBitmap *tmp = bitmap->bitmap; |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 677 | assert(!bdrv_dirty_bitmap_readonly(bitmap)); |
Emanuele Giuseppe Esposito | b4ad82a | 2022-03-03 10:15:57 -0500 | [diff] [blame] | 678 | GLOBAL_STATE_CODE(); |
Vladimir Sementsov-Ogievskiy | 56bd662 | 2018-10-29 16:23:14 -0400 | [diff] [blame] | 679 | bitmap->bitmap = backup; |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 680 | hbitmap_free(tmp); |
| 681 | } |
| 682 | |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 683 | uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap, |
Eric Blake | 86f6ae6 | 2017-09-25 09:55:14 -0500 | [diff] [blame] | 684 | uint64_t offset, uint64_t bytes) |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 685 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 686 | return hbitmap_serialization_size(bitmap->bitmap, offset, bytes); |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 687 | } |
| 688 | |
| 689 | uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap) |
| 690 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 691 | return hbitmap_serialization_align(bitmap->bitmap); |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 692 | } |
| 693 | |
Vladimir Sementsov-Ogievskiy | 35f428b | 2021-02-24 13:47:02 +0300 | [diff] [blame] | 694 | /* Return the disk size covered by a chunk of serialized bitmap data. */ |
| 695 | uint64_t bdrv_dirty_bitmap_serialization_coverage(int serialized_chunk_size, |
| 696 | const BdrvDirtyBitmap *bitmap) |
| 697 | { |
| 698 | uint64_t granularity = bdrv_dirty_bitmap_granularity(bitmap); |
| 699 | uint64_t limit = granularity * (serialized_chunk_size << 3); |
| 700 | |
| 701 | assert(QEMU_IS_ALIGNED(limit, |
| 702 | bdrv_dirty_bitmap_serialization_align(bitmap))); |
| 703 | return limit; |
| 704 | } |
| 705 | |
| 706 | |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 707 | void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap, |
Eric Blake | 86f6ae6 | 2017-09-25 09:55:14 -0500 | [diff] [blame] | 708 | uint8_t *buf, uint64_t offset, |
| 709 | uint64_t bytes) |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 710 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 711 | hbitmap_serialize_part(bitmap->bitmap, buf, offset, bytes); |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 712 | } |
| 713 | |
| 714 | void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap, |
Eric Blake | 86f6ae6 | 2017-09-25 09:55:14 -0500 | [diff] [blame] | 715 | uint8_t *buf, uint64_t offset, |
| 716 | uint64_t bytes, bool finish) |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 717 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 718 | hbitmap_deserialize_part(bitmap->bitmap, buf, offset, bytes, finish); |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 719 | } |
| 720 | |
| 721 | void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap, |
Eric Blake | 86f6ae6 | 2017-09-25 09:55:14 -0500 | [diff] [blame] | 722 | uint64_t offset, uint64_t bytes, |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 723 | bool finish) |
| 724 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 725 | hbitmap_deserialize_zeroes(bitmap->bitmap, offset, bytes, finish); |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 726 | } |
| 727 | |
Vladimir Sementsov-Ogievskiy | 6bdc8b7 | 2017-06-28 15:05:06 +0300 | [diff] [blame] | 728 | void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap, |
Eric Blake | 86f6ae6 | 2017-09-25 09:55:14 -0500 | [diff] [blame] | 729 | uint64_t offset, uint64_t bytes, |
Vladimir Sementsov-Ogievskiy | 6bdc8b7 | 2017-06-28 15:05:06 +0300 | [diff] [blame] | 730 | bool finish) |
| 731 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 732 | hbitmap_deserialize_ones(bitmap->bitmap, offset, bytes, finish); |
Vladimir Sementsov-Ogievskiy | 6bdc8b7 | 2017-06-28 15:05:06 +0300 | [diff] [blame] | 733 | } |
| 734 | |
Vladimir Sementsov-Ogievskiy | 882c36f | 2016-10-13 17:58:28 -0400 | [diff] [blame] | 735 | void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap) |
| 736 | { |
| 737 | hbitmap_deserialize_finish(bitmap->bitmap); |
| 738 | } |
| 739 | |
Eric Blake | 0fdf1a4 | 2017-09-25 09:55:25 -0500 | [diff] [blame] | 740 | void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 741 | { |
| 742 | BdrvDirtyBitmap *bitmap; |
Emanuele Giuseppe Esposito | 967d790 | 2022-03-03 10:15:58 -0500 | [diff] [blame] | 743 | IO_CODE(); |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 744 | |
| 745 | if (QLIST_EMPTY(&bs->dirty_bitmaps)) { |
| 746 | return; |
| 747 | } |
| 748 | |
| 749 | bdrv_dirty_bitmaps_lock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 750 | QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) { |
| 751 | if (!bdrv_dirty_bitmap_enabled(bitmap)) { |
| 752 | continue; |
| 753 | } |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 754 | assert(!bdrv_dirty_bitmap_readonly(bitmap)); |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 755 | hbitmap_set(bitmap->bitmap, offset, bytes); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 756 | } |
Paolo Bonzini | 2119882 | 2017-06-05 14:39:03 +0200 | [diff] [blame] | 757 | bdrv_dirty_bitmaps_unlock(bs); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 758 | } |
| 759 | |
| 760 | /** |
Fam Zheng | dc162c8 | 2016-10-13 17:58:21 -0400 | [diff] [blame] | 761 | * Advance a BdrvDirtyBitmapIter to an arbitrary offset. |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 762 | */ |
Eric Blake | 715a74d | 2017-09-25 09:55:16 -0500 | [diff] [blame] | 763 | void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *iter, int64_t offset) |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 764 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 765 | hbitmap_iter_init(&iter->hbi, iter->hbi.hb, offset); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 766 | } |
| 767 | |
| 768 | int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap) |
| 769 | { |
Eric Blake | ca75962 | 2017-09-25 09:55:26 -0500 | [diff] [blame] | 770 | return hbitmap_count(bitmap->bitmap); |
Fam Zheng | ebab225 | 2016-03-08 12:44:55 +0800 | [diff] [blame] | 771 | } |
Fam Zheng | 6d3f404 | 2016-10-13 17:58:30 -0400 | [diff] [blame] | 772 | |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 773 | bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap) |
| 774 | { |
| 775 | return bitmap->readonly; |
| 776 | } |
| 777 | |
| 778 | /* Called with BQL taken. */ |
| 779 | void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap *bitmap, bool value) |
| 780 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 781 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 782 | bitmap->readonly = value; |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 783 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | d6883bc | 2017-06-28 15:05:10 +0300 | [diff] [blame] | 784 | } |
| 785 | |
| 786 | bool bdrv_has_readonly_bitmaps(BlockDriverState *bs) |
| 787 | { |
| 788 | BdrvDirtyBitmap *bm; |
| 789 | QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) { |
| 790 | if (bm->readonly) { |
| 791 | return true; |
| 792 | } |
| 793 | } |
| 794 | |
| 795 | return false; |
| 796 | } |
Vladimir Sementsov-Ogievskiy | a0319aa | 2017-06-28 15:05:15 +0300 | [diff] [blame] | 797 | |
Vladimir Sementsov-Ogievskiy | 7ae89a0 | 2020-05-22 01:06:44 +0300 | [diff] [blame] | 798 | bool bdrv_has_named_bitmaps(BlockDriverState *bs) |
| 799 | { |
| 800 | BdrvDirtyBitmap *bm; |
| 801 | |
| 802 | QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) { |
| 803 | if (bdrv_dirty_bitmap_name(bm)) { |
| 804 | return true; |
| 805 | } |
| 806 | } |
| 807 | |
| 808 | return false; |
| 809 | } |
| 810 | |
Vladimir Sementsov-Ogievskiy | a0319aa | 2017-06-28 15:05:15 +0300 | [diff] [blame] | 811 | /* Called with BQL taken. */ |
Eric Blake | 796a379 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 812 | void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap, bool persistent) |
Vladimir Sementsov-Ogievskiy | a88b179 | 2017-06-28 15:05:17 +0300 | [diff] [blame] | 813 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 814 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | a88b179 | 2017-06-28 15:05:17 +0300 | [diff] [blame] | 815 | bitmap->persistent = persistent; |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 816 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | a88b179 | 2017-06-28 15:05:17 +0300 | [diff] [blame] | 817 | } |
| 818 | |
Vladimir Sementsov-Ogievskiy | 9c98f14 | 2018-10-29 16:23:17 -0400 | [diff] [blame] | 819 | /* Called with BQL taken. */ |
John Snow | b0f4555 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 820 | void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap) |
| 821 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 822 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
John Snow | b0f4555 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 823 | assert(bitmap->persistent == true); |
| 824 | bitmap->inconsistent = true; |
| 825 | bitmap->disabled = true; |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 826 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
John Snow | b0f4555 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 827 | } |
| 828 | |
| 829 | /* Called with BQL taken. */ |
John Snow | c4e4b0f | 2019-07-29 16:35:54 -0400 | [diff] [blame] | 830 | void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap *bitmap, bool skip) |
Vladimir Sementsov-Ogievskiy | 9c98f14 | 2018-10-29 16:23:17 -0400 | [diff] [blame] | 831 | { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 832 | bdrv_dirty_bitmaps_lock(bitmap->bs); |
John Snow | c4e4b0f | 2019-07-29 16:35:54 -0400 | [diff] [blame] | 833 | bitmap->skip_store = skip; |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 834 | bdrv_dirty_bitmaps_unlock(bitmap->bs); |
Vladimir Sementsov-Ogievskiy | 9c98f14 | 2018-10-29 16:23:17 -0400 | [diff] [blame] | 835 | } |
| 836 | |
Eric Blake | 796a379 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 837 | bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap *bitmap) |
Vladimir Sementsov-Ogievskiy | a88b179 | 2017-06-28 15:05:17 +0300 | [diff] [blame] | 838 | { |
John Snow | c4e4b0f | 2019-07-29 16:35:54 -0400 | [diff] [blame] | 839 | return bitmap->persistent && !bitmap->skip_store; |
Vladimir Sementsov-Ogievskiy | a88b179 | 2017-06-28 15:05:17 +0300 | [diff] [blame] | 840 | } |
| 841 | |
John Snow | b0f4555 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 842 | bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap *bitmap) |
| 843 | { |
| 844 | return bitmap->inconsistent; |
| 845 | } |
| 846 | |
Vladimir Sementsov-Ogievskiy | ef9041a | 2019-09-16 17:19:11 +0300 | [diff] [blame] | 847 | BdrvDirtyBitmap *bdrv_dirty_bitmap_first(BlockDriverState *bs) |
Vladimir Sementsov-Ogievskiy | 3dd10a0 | 2017-06-28 15:05:18 +0300 | [diff] [blame] | 848 | { |
Vladimir Sementsov-Ogievskiy | ef9041a | 2019-09-16 17:19:11 +0300 | [diff] [blame] | 849 | return QLIST_FIRST(&bs->dirty_bitmaps); |
| 850 | } |
| 851 | |
| 852 | BdrvDirtyBitmap *bdrv_dirty_bitmap_next(BdrvDirtyBitmap *bitmap) |
| 853 | { |
| 854 | return QLIST_NEXT(bitmap, list); |
Vladimir Sementsov-Ogievskiy | 3dd10a0 | 2017-06-28 15:05:18 +0300 | [diff] [blame] | 855 | } |
Vladimir Sementsov-Ogievskiy | a3b5253 | 2017-06-28 15:05:25 +0300 | [diff] [blame] | 856 | |
| 857 | char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp) |
| 858 | { |
| 859 | return hbitmap_sha256(bitmap->bitmap, errp); |
| 860 | } |
Vladimir Sementsov-Ogievskiy | 56207df | 2017-10-12 16:53:09 +0300 | [diff] [blame] | 861 | |
Vladimir Sementsov-Ogievskiy | 9399c54 | 2020-02-05 14:20:37 +0300 | [diff] [blame] | 862 | int64_t bdrv_dirty_bitmap_next_dirty(BdrvDirtyBitmap *bitmap, int64_t offset, |
| 863 | int64_t bytes) |
| 864 | { |
| 865 | return hbitmap_next_dirty(bitmap->bitmap, offset, bytes); |
| 866 | } |
| 867 | |
Vladimir Sementsov-Ogievskiy | 642700f | 2020-02-05 14:20:36 +0300 | [diff] [blame] | 868 | int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, int64_t offset, |
| 869 | int64_t bytes) |
Vladimir Sementsov-Ogievskiy | 56207df | 2017-10-12 16:53:09 +0300 | [diff] [blame] | 870 | { |
Vladimir Sementsov-Ogievskiy | 76d570d | 2019-01-15 18:26:49 -0500 | [diff] [blame] | 871 | return hbitmap_next_zero(bitmap->bitmap, offset, bytes); |
Vladimir Sementsov-Ogievskiy | 56207df | 2017-10-12 16:53:09 +0300 | [diff] [blame] | 872 | } |
Vladimir Sementsov-Ogievskiy | b598e53 | 2018-06-11 14:53:32 -0400 | [diff] [blame] | 873 | |
Vladimir Sementsov-Ogievskiy | a78a1a4 | 2019-01-15 18:26:50 -0500 | [diff] [blame] | 874 | bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap, |
Vladimir Sementsov-Ogievskiy | 299ea9f | 2020-02-05 14:20:38 +0300 | [diff] [blame] | 875 | int64_t start, int64_t end, int64_t max_dirty_count, |
| 876 | int64_t *dirty_start, int64_t *dirty_count) |
Vladimir Sementsov-Ogievskiy | a78a1a4 | 2019-01-15 18:26:50 -0500 | [diff] [blame] | 877 | { |
Vladimir Sementsov-Ogievskiy | 299ea9f | 2020-02-05 14:20:38 +0300 | [diff] [blame] | 878 | return hbitmap_next_dirty_area(bitmap->bitmap, start, end, max_dirty_count, |
| 879 | dirty_start, dirty_count); |
Vladimir Sementsov-Ogievskiy | a78a1a4 | 2019-01-15 18:26:50 -0500 | [diff] [blame] | 880 | } |
| 881 | |
Vladimir Sementsov-Ogievskiy | a642647 | 2022-03-03 20:43:41 +0100 | [diff] [blame] | 882 | bool bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap, int64_t offset, |
| 883 | int64_t bytes, int64_t *count) |
| 884 | { |
| 885 | return hbitmap_status(bitmap->bitmap, offset, bytes, count); |
| 886 | } |
| 887 | |
John Snow | b7661ca | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 888 | /** |
| 889 | * bdrv_merge_dirty_bitmap: merge src into dest. |
| 890 | * Ensures permissions on bitmaps are reasonable; use for public API. |
| 891 | * |
| 892 | * @backup: If provided, make a copy of dest here prior to merge. |
Vladimir Sementsov-Ogievskiy | 34ffacb | 2022-03-03 20:43:35 +0100 | [diff] [blame] | 893 | * |
| 894 | * Returns true on success, false on failure. In case of failure bitmaps are |
| 895 | * untouched. |
John Snow | b7661ca | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 896 | */ |
Vladimir Sementsov-Ogievskiy | 34ffacb | 2022-03-03 20:43:35 +0100 | [diff] [blame] | 897 | bool bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src, |
Vladimir Sementsov-Ogievskiy | fa000f2 | 2018-10-29 16:23:15 -0400 | [diff] [blame] | 898 | HBitmap **backup, Error **errp) |
Vladimir Sementsov-Ogievskiy | b598e53 | 2018-06-11 14:53:32 -0400 | [diff] [blame] | 899 | { |
Vladimir Sementsov-Ogievskiy | 34ffacb | 2022-03-03 20:43:35 +0100 | [diff] [blame] | 900 | bool ret = false; |
Vladimir Sementsov-Ogievskiy | fa000f2 | 2018-10-29 16:23:15 -0400 | [diff] [blame] | 901 | |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 902 | bdrv_dirty_bitmaps_lock(dest->bs); |
| 903 | if (src->bs != dest->bs) { |
| 904 | bdrv_dirty_bitmaps_lock(src->bs); |
Vladimir Sementsov-Ogievskiy | eff0829 | 2019-05-28 19:33:31 -0400 | [diff] [blame] | 905 | } |
Vladimir Sementsov-Ogievskiy | b598e53 | 2018-06-11 14:53:32 -0400 | [diff] [blame] | 906 | |
John Snow | 3ae96d6 | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 907 | if (bdrv_dirty_bitmap_check(dest, BDRV_BITMAP_DEFAULT, errp)) { |
Vladimir Sementsov-Ogievskiy | 06bf500 | 2018-10-29 16:23:14 -0400 | [diff] [blame] | 908 | goto out; |
| 909 | } |
| 910 | |
John Snow | cb8e58e | 2019-03-12 12:05:49 -0400 | [diff] [blame] | 911 | if (bdrv_dirty_bitmap_check(src, BDRV_BITMAP_ALLOW_RO, errp)) { |
| 912 | goto out; |
| 913 | } |
Vladimir Sementsov-Ogievskiy | b598e53 | 2018-06-11 14:53:32 -0400 | [diff] [blame] | 914 | |
Vladimir Sementsov-Ogievskiy | fa000f2 | 2018-10-29 16:23:15 -0400 | [diff] [blame] | 915 | if (!hbitmap_can_merge(dest->bitmap, src->bitmap)) { |
Vladimir Sementsov-Ogievskiy | b598e53 | 2018-06-11 14:53:32 -0400 | [diff] [blame] | 916 | error_setg(errp, "Bitmaps are incompatible and can't be merged"); |
Vladimir Sementsov-Ogievskiy | 06bf500 | 2018-10-29 16:23:14 -0400 | [diff] [blame] | 917 | goto out; |
Vladimir Sementsov-Ogievskiy | b598e53 | 2018-06-11 14:53:32 -0400 | [diff] [blame] | 918 | } |
| 919 | |
John Snow | b7661ca | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 920 | ret = bdrv_dirty_bitmap_merge_internal(dest, src, backup, false); |
Vladimir Sementsov-Ogievskiy | fa000f2 | 2018-10-29 16:23:15 -0400 | [diff] [blame] | 921 | assert(ret); |
| 922 | |
Vladimir Sementsov-Ogievskiy | 06bf500 | 2018-10-29 16:23:14 -0400 | [diff] [blame] | 923 | out: |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 924 | bdrv_dirty_bitmaps_unlock(dest->bs); |
| 925 | if (src->bs != dest->bs) { |
| 926 | bdrv_dirty_bitmaps_unlock(src->bs); |
Vladimir Sementsov-Ogievskiy | eff0829 | 2019-05-28 19:33:31 -0400 | [diff] [blame] | 927 | } |
Vladimir Sementsov-Ogievskiy | 34ffacb | 2022-03-03 20:43:35 +0100 | [diff] [blame] | 928 | |
| 929 | return ret; |
Vladimir Sementsov-Ogievskiy | b598e53 | 2018-06-11 14:53:32 -0400 | [diff] [blame] | 930 | } |
John Snow | b7661ca | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 931 | |
| 932 | /** |
| 933 | * bdrv_dirty_bitmap_merge_internal: merge src into dest. |
| 934 | * Does NOT check bitmap permissions; not suitable for use as public API. |
| 935 | * |
| 936 | * @backup: If provided, make a copy of dest here prior to merge. |
| 937 | * @lock: If true, lock and unlock bitmaps on the way in/out. |
| 938 | * returns true if the merge succeeded; false if unattempted. |
| 939 | */ |
| 940 | bool bdrv_dirty_bitmap_merge_internal(BdrvDirtyBitmap *dest, |
| 941 | const BdrvDirtyBitmap *src, |
| 942 | HBitmap **backup, |
| 943 | bool lock) |
| 944 | { |
| 945 | bool ret; |
Emanuele Giuseppe Esposito | 967d790 | 2022-03-03 10:15:58 -0500 | [diff] [blame] | 946 | IO_CODE(); |
John Snow | b7661ca | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 947 | |
| 948 | assert(!bdrv_dirty_bitmap_readonly(dest)); |
| 949 | assert(!bdrv_dirty_bitmap_inconsistent(dest)); |
| 950 | assert(!bdrv_dirty_bitmap_inconsistent(src)); |
| 951 | |
| 952 | if (lock) { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 953 | bdrv_dirty_bitmaps_lock(dest->bs); |
| 954 | if (src->bs != dest->bs) { |
| 955 | bdrv_dirty_bitmaps_lock(src->bs); |
John Snow | b7661ca | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 956 | } |
| 957 | } |
| 958 | |
| 959 | if (backup) { |
| 960 | *backup = dest->bitmap; |
| 961 | dest->bitmap = hbitmap_alloc(dest->size, hbitmap_granularity(*backup)); |
| 962 | ret = hbitmap_merge(*backup, src->bitmap, dest->bitmap); |
| 963 | } else { |
| 964 | ret = hbitmap_merge(dest->bitmap, src->bitmap, dest->bitmap); |
| 965 | } |
| 966 | |
| 967 | if (lock) { |
Vladimir Sementsov-Ogievskiy | 1e63830 | 2019-09-16 17:19:10 +0300 | [diff] [blame] | 968 | bdrv_dirty_bitmaps_unlock(dest->bs); |
| 969 | if (src->bs != dest->bs) { |
| 970 | bdrv_dirty_bitmaps_unlock(src->bs); |
John Snow | b7661ca | 2019-07-29 16:35:53 -0400 | [diff] [blame] | 971 | } |
| 972 | } |
| 973 | |
| 974 | return ret; |
| 975 | } |