qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

dirty-bitmap.h (6731B)


      1 #ifndef BLOCK_DIRTY_BITMAP_H
      2 #define BLOCK_DIRTY_BITMAP_H
      3 
      4 #include "qapi/qapi-types-block-core.h"
      5 #include "qemu/hbitmap.h"
      6 
      7 typedef enum BitmapCheckFlags {
      8     BDRV_BITMAP_BUSY = 1,
      9     BDRV_BITMAP_RO = 2,
     10     BDRV_BITMAP_INCONSISTENT = 4,
     11 } BitmapCheckFlags;
     12 
     13 #define BDRV_BITMAP_DEFAULT (BDRV_BITMAP_BUSY | BDRV_BITMAP_RO |        \
     14                              BDRV_BITMAP_INCONSISTENT)
     15 #define BDRV_BITMAP_ALLOW_RO (BDRV_BITMAP_BUSY | BDRV_BITMAP_INCONSISTENT)
     16 
     17 #define BDRV_BITMAP_MAX_NAME_SIZE 1023
     18 
     19 bool bdrv_supports_persistent_dirty_bitmap(BlockDriverState *bs);
     20 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs,
     21                                           uint32_t granularity,
     22                                           const char *name,
     23                                           Error **errp);
     24 int bdrv_dirty_bitmap_create_successor(BdrvDirtyBitmap *bitmap,
     25                                        Error **errp);
     26 BdrvDirtyBitmap *bdrv_dirty_bitmap_abdicate(BdrvDirtyBitmap *bitmap,
     27                                             Error **errp);
     28 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap(BdrvDirtyBitmap *bitmap,
     29                                            Error **errp);
     30 void bdrv_dirty_bitmap_enable_successor(BdrvDirtyBitmap *bitmap);
     31 BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs,
     32                                         const char *name);
     33 int bdrv_dirty_bitmap_check(const BdrvDirtyBitmap *bitmap, uint32_t flags,
     34                             Error **errp);
     35 void bdrv_release_dirty_bitmap(BdrvDirtyBitmap *bitmap);
     36 void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs);
     37 int bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,
     38                                         Error **errp);
     39 void bdrv_disable_dirty_bitmap(BdrvDirtyBitmap *bitmap);
     40 void bdrv_enable_dirty_bitmap(BdrvDirtyBitmap *bitmap);
     41 void bdrv_enable_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap);
     42 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs);
     43 uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs);
     44 uint32_t bdrv_dirty_bitmap_granularity(const BdrvDirtyBitmap *bitmap);
     45 bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap);
     46 bool bdrv_dirty_bitmap_has_successor(BdrvDirtyBitmap *bitmap);
     47 const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap);
     48 int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap);
     49 void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
     50                            int64_t offset, int64_t bytes);
     51 void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
     52                              int64_t offset, int64_t bytes);
     53 BdrvDirtyBitmapIter *bdrv_dirty_iter_new(BdrvDirtyBitmap *bitmap);
     54 void bdrv_dirty_iter_free(BdrvDirtyBitmapIter *iter);
     55 
     56 uint64_t bdrv_dirty_bitmap_serialization_size(const BdrvDirtyBitmap *bitmap,
     57                                               uint64_t offset, uint64_t bytes);
     58 uint64_t bdrv_dirty_bitmap_serialization_align(const BdrvDirtyBitmap *bitmap);
     59 uint64_t bdrv_dirty_bitmap_serialization_coverage(int serialized_chunk_size,
     60         const BdrvDirtyBitmap *bitmap);
     61 void bdrv_dirty_bitmap_serialize_part(const BdrvDirtyBitmap *bitmap,
     62                                       uint8_t *buf, uint64_t offset,
     63                                       uint64_t bytes);
     64 void bdrv_dirty_bitmap_deserialize_part(BdrvDirtyBitmap *bitmap,
     65                                         uint8_t *buf, uint64_t offset,
     66                                         uint64_t bytes, bool finish);
     67 void bdrv_dirty_bitmap_deserialize_zeroes(BdrvDirtyBitmap *bitmap,
     68                                           uint64_t offset, uint64_t bytes,
     69                                           bool finish);
     70 void bdrv_dirty_bitmap_deserialize_ones(BdrvDirtyBitmap *bitmap,
     71                                         uint64_t offset, uint64_t bytes,
     72                                         bool finish);
     73 void bdrv_dirty_bitmap_deserialize_finish(BdrvDirtyBitmap *bitmap);
     74 
     75 void bdrv_dirty_bitmap_set_readonly(BdrvDirtyBitmap *bitmap, bool value);
     76 void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap,
     77                                        bool persistent);
     78 void bdrv_dirty_bitmap_set_inconsistent(BdrvDirtyBitmap *bitmap);
     79 void bdrv_dirty_bitmap_set_busy(BdrvDirtyBitmap *bitmap, bool busy);
     80 bool bdrv_merge_dirty_bitmap(BdrvDirtyBitmap *dest, const BdrvDirtyBitmap *src,
     81                              HBitmap **backup, Error **errp);
     82 void bdrv_dirty_bitmap_skip_store(BdrvDirtyBitmap *bitmap, bool skip);
     83 bool bdrv_dirty_bitmap_get(BdrvDirtyBitmap *bitmap, int64_t offset);
     84 
     85 /* Functions that require manual locking.  */
     86 void bdrv_dirty_bitmap_lock(BdrvDirtyBitmap *bitmap);
     87 void bdrv_dirty_bitmap_unlock(BdrvDirtyBitmap *bitmap);
     88 bool bdrv_dirty_bitmap_get_locked(BdrvDirtyBitmap *bitmap, int64_t offset);
     89 void bdrv_set_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
     90                                   int64_t offset, int64_t bytes);
     91 void bdrv_reset_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
     92                                     int64_t offset, int64_t bytes);
     93 int64_t bdrv_dirty_iter_next(BdrvDirtyBitmapIter *iter);
     94 void bdrv_set_dirty_iter(BdrvDirtyBitmapIter *hbi, int64_t offset);
     95 int64_t bdrv_get_dirty_count(BdrvDirtyBitmap *bitmap);
     96 void bdrv_dirty_bitmap_truncate(BlockDriverState *bs, int64_t bytes);
     97 bool bdrv_dirty_bitmap_readonly(const BdrvDirtyBitmap *bitmap);
     98 bool bdrv_has_readonly_bitmaps(BlockDriverState *bs);
     99 bool bdrv_has_named_bitmaps(BlockDriverState *bs);
    100 bool bdrv_dirty_bitmap_get_autoload(const BdrvDirtyBitmap *bitmap);
    101 bool bdrv_dirty_bitmap_get_persistence(BdrvDirtyBitmap *bitmap);
    102 bool bdrv_dirty_bitmap_inconsistent(const BdrvDirtyBitmap *bitmap);
    103 
    104 BdrvDirtyBitmap *bdrv_dirty_bitmap_first(BlockDriverState *bs);
    105 BdrvDirtyBitmap *bdrv_dirty_bitmap_next(BdrvDirtyBitmap *bitmap);
    106 #define FOR_EACH_DIRTY_BITMAP(bs, bitmap) \
    107 for (bitmap = bdrv_dirty_bitmap_first(bs); bitmap; \
    108      bitmap = bdrv_dirty_bitmap_next(bitmap))
    109 
    110 char *bdrv_dirty_bitmap_sha256(const BdrvDirtyBitmap *bitmap, Error **errp);
    111 int64_t bdrv_dirty_bitmap_next_dirty(BdrvDirtyBitmap *bitmap, int64_t offset,
    112                                      int64_t bytes);
    113 int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, int64_t offset,
    114                                     int64_t bytes);
    115 bool bdrv_dirty_bitmap_next_dirty_area(BdrvDirtyBitmap *bitmap,
    116         int64_t start, int64_t end, int64_t max_dirty_count,
    117         int64_t *dirty_start, int64_t *dirty_count);
    118 bool bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap, int64_t offset,
    119                               int64_t bytes, int64_t *count);
    120 BdrvDirtyBitmap *bdrv_reclaim_dirty_bitmap_locked(BdrvDirtyBitmap *bitmap,
    121                                                   Error **errp);
    122 
    123 #endif