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

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