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 
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_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
121 {
122 	return sm->inc_blocks(sm, b, e);
123 }
124 
125 static inline int dm_sm_inc_block(struct dm_space_map *sm, dm_block_t b)
126 {
127 	return dm_sm_inc_blocks(sm, b, b + 1);
128 }
129 
130 static inline int dm_sm_dec_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
131 {
132 	return sm->dec_blocks(sm, b, e);
133 }
134 
135 static inline int dm_sm_dec_block(struct dm_space_map *sm, dm_block_t b)
136 {
137 	return dm_sm_dec_blocks(sm, b, b + 1);
138 }
139 
140 static inline int dm_sm_new_block(struct dm_space_map *sm, dm_block_t *b)
141 {
142 	return sm->new_block(sm, b);
143 }
144 
145 static inline int dm_sm_root_size(struct dm_space_map *sm, size_t *result)
146 {
147 	return sm->root_size(sm, result);
148 }
149 
150 static inline int dm_sm_copy_root(struct dm_space_map *sm, void *copy_to_here_le, size_t len)
151 {
152 	return sm->copy_root(sm, copy_to_here_le, len);
153 }
154 
155 static inline int dm_sm_register_threshold_callback(struct dm_space_map *sm,
156 						    dm_block_t threshold,
157 						    dm_sm_threshold_fn fn,
158 						    void *context)
159 {
160 	if (sm->register_threshold_callback)
161 		return sm->register_threshold_callback(sm, threshold, fn, context);
162 
163 	return -EINVAL;
164 }
165 
166 
167 #endif	/* _LINUX_DM_SPACE_MAP_H */
168