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 ); |
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 ) |
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, e: 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, e: 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 | |