drivers/md/persistent-data/dm-space-map.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (C) 2011 Red Hat, Inc.
   4  *
   5  * This file is released under the GPL.
   6  */
   7
   8 #ifndef _LINUX_DM_SPACE_MAP_H
   9 #define _LINUX_DM_SPACE_MAP_H
  10
  11 #include "dm-block-manager.h"
  12
  13 typedef void (*dm_sm_threshold_fn)(void *context);
  14
  15 /*
  16  * struct dm_space_map keeps a record of how many times each block in a device
  17  * is referenced.  It needs to be fixed on disk as part of the transaction.
  18  */
  19 struct dm_space_map {
  20         void (*destroy)(struct dm_space_map *sm);
  21
  22         /*
  23          * You must commit before allocating the newly added space.
  24          */
  25         int (*extend)(struct dm_space_map *sm, dm_block_t extra_blocks);
  26
  27         /*
  28          * Extensions do not appear in this count until after commit has
  29          * been called.
  30          */
  31         int (*get_nr_blocks)(struct dm_space_map *sm, dm_block_t *count);
  32
  33         /*
  34          * Space maps must never allocate a block from the previous
  35          * transaction, in case we need to rollback.  This complicates the
  36          * semantics of get_nr_free(), it should return the number of blocks
  37          * that are available for allocation _now_.  For instance you may
  38          * have blocks with a zero reference count that will not be
  39          * available for allocation until after the next commit.
  40          */
  41         int (*get_nr_free)(struct dm_space_map *sm, dm_block_t *count);
  42
  43         int (*get_count)(struct dm_space_map *sm, dm_block_t b, uint32_t *result);
  44         int (*count_is_more_than_one)(struct dm_space_map *sm, dm_block_t b,
  45                                       int *result);
  46         int (*set_count)(struct dm_space_map *sm, dm_block_t b, uint32_t count);
  47
  48         int (*commit)(struct dm_space_map *sm);
  49
  50         int (*inc_blocks)(struct dm_space_map *sm, dm_block_t b, dm_block_t e);
  51         int (*dec_blocks)(struct dm_space_map *sm, dm_block_t b, dm_block_t e);
  52
  53         /*
  54          * new_block will increment the returned block.
  55          */
  56         int (*new_block)(struct dm_space_map *sm, dm_block_t *b);
  57
  58         /*
  59          * The root contains all the information needed to fix the space map.
  60          * Generally this info is small, so squirrel it away in a disk block
  61          * along with other info.
  62          */
  63         int (*root_size)(struct dm_space_map *sm, size_t *result);
  64         int (*copy_root)(struct dm_space_map *sm, void *copy_to_here_le, size_t len);
  65
  66         /*
  67          * You can register one threshold callback which is edge-triggered
  68          * when the free space in the space map drops below the threshold.
  69          */
  70         int (*register_threshold_callback)(struct dm_space_map *sm,
  71                                            dm_block_t threshold,
  72                                            dm_sm_threshold_fn fn,
  73                                            void *context);
  74 };
  75
  76 /*----------------------------------------------------------------*/
  77
  78 static inline void dm_sm_destroy(struct dm_space_map *sm)
  79 {
  80         if (sm)
  81                 sm->destroy(sm);
  82 }
  83
  84 static inline int dm_sm_extend(struct dm_space_map *sm, dm_block_t extra_blocks)
  85 {
  86         return sm->extend(sm, extra_blocks);
  87 }
  88
  89 static inline int dm_sm_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count)
  90 {
  91         return sm->get_nr_blocks(sm, count);
  92 }
  93
  94 static inline int dm_sm_get_nr_free(struct dm_space_map *sm, dm_block_t *count)
  95 {
  96         return sm->get_nr_free(sm, count);
  97 }
  98
  99 static inline int dm_sm_get_count(struct dm_space_map *sm, dm_block_t b,
 100                                   uint32_t *result)
 101 {
 102         return sm->get_count(sm, b, result);
 103 }
 104
 105 static inline int dm_sm_count_is_more_than_one(struct dm_space_map *sm,
 106                                                dm_block_t b, int *result)
 107 {
 108         return sm->count_is_more_than_one(sm, b, result);
 109 }
 110
 111 static inline int dm_sm_set_count(struct dm_space_map *sm, dm_block_t b,
 112                                   uint32_t count)
 113 {
 114         return sm->set_count(sm, b, count);
 115 }
 116
 117 static inline int dm_sm_commit(struct dm_space_map *sm)
 118 {
 119         return sm->commit(sm);
 120 }
 121
 122 static inline int dm_sm_inc_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
 123 {
 124         return sm->inc_blocks(sm, b, e);
 125 }
 126
 127 static inline int dm_sm_inc_block(struct dm_space_map *sm, dm_block_t b)
 128 {
 129         return dm_sm_inc_blocks(sm, b, b + 1);
 130 }
 131
 132 static inline int dm_sm_dec_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
 133 {
 134         return sm->dec_blocks(sm, b, e);
 135 }
 136
 137 static inline int dm_sm_dec_block(struct dm_space_map *sm, dm_block_t b)
 138 {
 139         return dm_sm_dec_blocks(sm, b, b + 1);
 140 }
 141
 142 static inline int dm_sm_new_block(struct dm_space_map *sm, dm_block_t *b)
 143 {
 144         return sm->new_block(sm, b);
 145 }
 146
 147 static inline int dm_sm_root_size(struct dm_space_map *sm, size_t *result)
 148 {
 149         return sm->root_size(sm, result);
 150 }
 151
 152 static inline int dm_sm_copy_root(struct dm_space_map *sm, void *copy_to_here_le, size_t len)
 153 {
 154         return sm->copy_root(sm, copy_to_here_le, len);
 155 }
 156
 157 static inline int dm_sm_register_threshold_callback(struct dm_space_map *sm,
 158                                                     dm_block_t threshold,
 159                                                     dm_sm_threshold_fn fn,
 160                                                     void *context)
 161 {
 162         if (sm->register_threshold_callback)
 163                 return sm->register_threshold_callback(sm, threshold, fn, context);
 164
 165         return -EINVAL;
 166 }
 167
 168
 169 #endif  /* _LINUX_DM_SPACE_MAP_H */