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 */ 170