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_blocks)(struct dm_space_map *sm, dm_block_t b, dm_block_t e);
50 int (*dec_blocks)(struct dm_space_map *sm, dm_block_t b, dm_block_t e);
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
dm_sm_destroy(struct dm_space_map * sm)77 static inline void dm_sm_destroy(struct dm_space_map *sm)
78 {
79 if (sm)
80 sm->destroy(sm);
81 }
82
dm_sm_extend(struct dm_space_map * sm,dm_block_t extra_blocks)83 static inline int dm_sm_extend(struct dm_space_map *sm, dm_block_t extra_blocks)
84 {
85 return sm->extend(sm, extra_blocks);
86 }
87
dm_sm_get_nr_blocks(struct dm_space_map * sm,dm_block_t * count)88 static inline int dm_sm_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count)
89 {
90 return sm->get_nr_blocks(sm, count);
91 }
92
dm_sm_get_nr_free(struct dm_space_map * sm,dm_block_t * count)93 static inline int dm_sm_get_nr_free(struct dm_space_map *sm, dm_block_t *count)
94 {
95 return sm->get_nr_free(sm, count);
96 }
97
dm_sm_get_count(struct dm_space_map * sm,dm_block_t b,uint32_t * result)98 static inline int dm_sm_get_count(struct dm_space_map *sm, dm_block_t b,
99 uint32_t *result)
100 {
101 return sm->get_count(sm, b, result);
102 }
103
dm_sm_count_is_more_than_one(struct dm_space_map * sm,dm_block_t b,int * result)104 static inline int dm_sm_count_is_more_than_one(struct dm_space_map *sm,
105 dm_block_t b, int *result)
106 {
107 return sm->count_is_more_than_one(sm, b, result);
108 }
109
dm_sm_set_count(struct dm_space_map * sm,dm_block_t b,uint32_t count)110 static inline int dm_sm_set_count(struct dm_space_map *sm, dm_block_t b,
111 uint32_t count)
112 {
113 return sm->set_count(sm, b, count);
114 }
115
dm_sm_commit(struct dm_space_map * sm)116 static inline int dm_sm_commit(struct dm_space_map *sm)
117 {
118 return sm->commit(sm);
119 }
120
dm_sm_inc_blocks(struct dm_space_map * sm,dm_block_t b,dm_block_t e)121 static inline int dm_sm_inc_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
122 {
123 return sm->inc_blocks(sm, b, e);
124 }
125
dm_sm_inc_block(struct dm_space_map * sm,dm_block_t b)126 static inline int dm_sm_inc_block(struct dm_space_map *sm, dm_block_t b)
127 {
128 return dm_sm_inc_blocks(sm, b, b + 1);
129 }
130
dm_sm_dec_blocks(struct dm_space_map * sm,dm_block_t b,dm_block_t e)131 static inline int dm_sm_dec_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
132 {
133 return sm->dec_blocks(sm, b, e);
134 }
135
dm_sm_dec_block(struct dm_space_map * sm,dm_block_t b)136 static inline int dm_sm_dec_block(struct dm_space_map *sm, dm_block_t b)
137 {
138 return dm_sm_dec_blocks(sm, b, b + 1);
139 }
140
dm_sm_new_block(struct dm_space_map * sm,dm_block_t * b)141 static inline int dm_sm_new_block(struct dm_space_map *sm, dm_block_t *b)
142 {
143 return sm->new_block(sm, b);
144 }
145
dm_sm_root_size(struct dm_space_map * sm,size_t * result)146 static inline int dm_sm_root_size(struct dm_space_map *sm, size_t *result)
147 {
148 return sm->root_size(sm, result);
149 }
150
dm_sm_copy_root(struct dm_space_map * sm,void * copy_to_here_le,size_t len)151 static inline int dm_sm_copy_root(struct dm_space_map *sm, void *copy_to_here_le, size_t len)
152 {
153 return sm->copy_root(sm, copy_to_here_le, len);
154 }
155
dm_sm_register_threshold_callback(struct dm_space_map * sm,dm_block_t threshold,dm_sm_threshold_fn fn,void * context)156 static inline int dm_sm_register_threshold_callback(struct dm_space_map *sm,
157 dm_block_t threshold,
158 dm_sm_threshold_fn fn,
159 void *context)
160 {
161 if (sm->register_threshold_callback)
162 return sm->register_threshold_callback(sm, threshold, fn, context);
163
164 return -EINVAL;
165 }
166
167
168 #endif /* _LINUX_DM_SPACE_MAP_H */
169