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 | #include "dm-space-map-common.h" |
9 | #include "dm-space-map-disk.h" |
10 | #include "dm-space-map.h" |
11 | #include "dm-transaction-manager.h" |
12 | |
13 | #include <linux/list.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/export.h> |
16 | #include <linux/device-mapper.h> |
17 | |
18 | #define DM_MSG_PREFIX "space map disk" |
19 | |
20 | /*----------------------------------------------------------------*/ |
21 | |
22 | /* |
23 | * Space map interface. |
24 | */ |
25 | struct sm_disk { |
26 | struct dm_space_map sm; |
27 | |
28 | struct ll_disk ll; |
29 | struct ll_disk old_ll; |
30 | |
31 | dm_block_t begin; |
32 | dm_block_t nr_allocated_this_transaction; |
33 | }; |
34 | |
35 | static void sm_disk_destroy(struct dm_space_map *sm) |
36 | { |
37 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
38 | |
39 | kfree(objp: smd); |
40 | } |
41 | |
42 | static int sm_disk_extend(struct dm_space_map *sm, dm_block_t ) |
43 | { |
44 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
45 | |
46 | return sm_ll_extend(ll: &smd->ll, extra_blocks); |
47 | } |
48 | |
49 | static int sm_disk_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count) |
50 | { |
51 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
52 | |
53 | *count = smd->old_ll.nr_blocks; |
54 | |
55 | return 0; |
56 | } |
57 | |
58 | static int sm_disk_get_nr_free(struct dm_space_map *sm, dm_block_t *count) |
59 | { |
60 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
61 | |
62 | *count = (smd->old_ll.nr_blocks - smd->old_ll.nr_allocated) - smd->nr_allocated_this_transaction; |
63 | |
64 | return 0; |
65 | } |
66 | |
67 | static int sm_disk_get_count(struct dm_space_map *sm, dm_block_t b, |
68 | uint32_t *result) |
69 | { |
70 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
71 | |
72 | return sm_ll_lookup(ll: &smd->ll, b, result); |
73 | } |
74 | |
75 | static int sm_disk_count_is_more_than_one(struct dm_space_map *sm, dm_block_t b, |
76 | int *result) |
77 | { |
78 | int r; |
79 | uint32_t count; |
80 | |
81 | r = sm_disk_get_count(sm, b, result: &count); |
82 | if (r) |
83 | return r; |
84 | |
85 | *result = count > 1; |
86 | |
87 | return 0; |
88 | } |
89 | |
90 | static int sm_disk_set_count(struct dm_space_map *sm, dm_block_t b, |
91 | uint32_t count) |
92 | { |
93 | int r; |
94 | int32_t nr_allocations; |
95 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
96 | |
97 | r = sm_ll_insert(ll: &smd->ll, b, ref_count: count, nr_allocations: &nr_allocations); |
98 | if (!r) |
99 | smd->nr_allocated_this_transaction += nr_allocations; |
100 | |
101 | return r; |
102 | } |
103 | |
104 | static int sm_disk_inc_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e) |
105 | { |
106 | int r; |
107 | int32_t nr_allocations; |
108 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
109 | |
110 | r = sm_ll_inc(ll: &smd->ll, b, e, nr_allocations: &nr_allocations); |
111 | if (!r) |
112 | smd->nr_allocated_this_transaction += nr_allocations; |
113 | |
114 | return r; |
115 | } |
116 | |
117 | static int sm_disk_dec_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e) |
118 | { |
119 | int r; |
120 | int32_t nr_allocations; |
121 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
122 | |
123 | r = sm_ll_dec(ll: &smd->ll, b, e, nr_allocations: &nr_allocations); |
124 | if (!r) |
125 | smd->nr_allocated_this_transaction += nr_allocations; |
126 | |
127 | return r; |
128 | } |
129 | |
130 | static int sm_disk_new_block(struct dm_space_map *sm, dm_block_t *b) |
131 | { |
132 | int r; |
133 | int32_t nr_allocations; |
134 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
135 | |
136 | /* |
137 | * Any block we allocate has to be free in both the old and current ll. |
138 | */ |
139 | r = sm_ll_find_common_free_block(old_ll: &smd->old_ll, new_ll: &smd->ll, begin: smd->begin, end: smd->ll.nr_blocks, result: b); |
140 | if (r == -ENOSPC) |
141 | /* |
142 | * There's no free block between smd->begin and the end of the metadata device. |
143 | * We search before smd->begin in case something has been freed. |
144 | */ |
145 | r = sm_ll_find_common_free_block(old_ll: &smd->old_ll, new_ll: &smd->ll, begin: 0, end: smd->begin, result: b); |
146 | |
147 | if (r) |
148 | return r; |
149 | |
150 | smd->begin = *b + 1; |
151 | r = sm_ll_inc(ll: &smd->ll, b: *b, e: *b + 1, nr_allocations: &nr_allocations); |
152 | if (!r) |
153 | smd->nr_allocated_this_transaction += nr_allocations; |
154 | |
155 | return r; |
156 | } |
157 | |
158 | static int sm_disk_commit(struct dm_space_map *sm) |
159 | { |
160 | int r; |
161 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
162 | |
163 | r = sm_ll_commit(ll: &smd->ll); |
164 | if (r) |
165 | return r; |
166 | |
167 | memcpy(&smd->old_ll, &smd->ll, sizeof(smd->old_ll)); |
168 | smd->nr_allocated_this_transaction = 0; |
169 | |
170 | return 0; |
171 | } |
172 | |
173 | static int sm_disk_root_size(struct dm_space_map *sm, size_t *result) |
174 | { |
175 | *result = sizeof(struct disk_sm_root); |
176 | |
177 | return 0; |
178 | } |
179 | |
180 | static int sm_disk_copy_root(struct dm_space_map *sm, void *where_le, size_t max) |
181 | { |
182 | struct sm_disk *smd = container_of(sm, struct sm_disk, sm); |
183 | struct disk_sm_root root_le; |
184 | |
185 | root_le.nr_blocks = cpu_to_le64(smd->ll.nr_blocks); |
186 | root_le.nr_allocated = cpu_to_le64(smd->ll.nr_allocated); |
187 | root_le.bitmap_root = cpu_to_le64(smd->ll.bitmap_root); |
188 | root_le.ref_count_root = cpu_to_le64(smd->ll.ref_count_root); |
189 | |
190 | if (max < sizeof(root_le)) |
191 | return -ENOSPC; |
192 | |
193 | memcpy(where_le, &root_le, sizeof(root_le)); |
194 | |
195 | return 0; |
196 | } |
197 | |
198 | /*----------------------------------------------------------------*/ |
199 | |
200 | static struct dm_space_map ops = { |
201 | .destroy = sm_disk_destroy, |
202 | .extend = sm_disk_extend, |
203 | .get_nr_blocks = sm_disk_get_nr_blocks, |
204 | .get_nr_free = sm_disk_get_nr_free, |
205 | .get_count = sm_disk_get_count, |
206 | .count_is_more_than_one = sm_disk_count_is_more_than_one, |
207 | .set_count = sm_disk_set_count, |
208 | .inc_blocks = sm_disk_inc_blocks, |
209 | .dec_blocks = sm_disk_dec_blocks, |
210 | .new_block = sm_disk_new_block, |
211 | .commit = sm_disk_commit, |
212 | .root_size = sm_disk_root_size, |
213 | .copy_root = sm_disk_copy_root, |
214 | .register_threshold_callback = NULL |
215 | }; |
216 | |
217 | struct dm_space_map *dm_sm_disk_create(struct dm_transaction_manager *tm, |
218 | dm_block_t nr_blocks) |
219 | { |
220 | int r; |
221 | struct sm_disk *smd; |
222 | |
223 | smd = kmalloc(size: sizeof(*smd), GFP_KERNEL); |
224 | if (!smd) |
225 | return ERR_PTR(error: -ENOMEM); |
226 | |
227 | smd->begin = 0; |
228 | smd->nr_allocated_this_transaction = 0; |
229 | memcpy(&smd->sm, &ops, sizeof(smd->sm)); |
230 | |
231 | r = sm_ll_new_disk(ll: &smd->ll, tm); |
232 | if (r) |
233 | goto bad; |
234 | |
235 | r = sm_ll_extend(ll: &smd->ll, extra_blocks: nr_blocks); |
236 | if (r) |
237 | goto bad; |
238 | |
239 | r = sm_disk_commit(sm: &smd->sm); |
240 | if (r) |
241 | goto bad; |
242 | |
243 | return &smd->sm; |
244 | |
245 | bad: |
246 | kfree(objp: smd); |
247 | return ERR_PTR(error: r); |
248 | } |
249 | EXPORT_SYMBOL_GPL(dm_sm_disk_create); |
250 | |
251 | struct dm_space_map *dm_sm_disk_open(struct dm_transaction_manager *tm, |
252 | void *root_le, size_t len) |
253 | { |
254 | int r; |
255 | struct sm_disk *smd; |
256 | |
257 | smd = kmalloc(size: sizeof(*smd), GFP_KERNEL); |
258 | if (!smd) |
259 | return ERR_PTR(error: -ENOMEM); |
260 | |
261 | smd->begin = 0; |
262 | smd->nr_allocated_this_transaction = 0; |
263 | memcpy(&smd->sm, &ops, sizeof(smd->sm)); |
264 | |
265 | r = sm_ll_open_disk(ll: &smd->ll, tm, root_le, len); |
266 | if (r) |
267 | goto bad; |
268 | |
269 | r = sm_disk_commit(sm: &smd->sm); |
270 | if (r) |
271 | goto bad; |
272 | |
273 | return &smd->sm; |
274 | |
275 | bad: |
276 | kfree(objp: smd); |
277 | return ERR_PTR(error: r); |
278 | } |
279 | EXPORT_SYMBOL_GPL(dm_sm_disk_open); |
280 | |
281 | /*----------------------------------------------------------------*/ |
282 | |