]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/md/persistent-data/dm-transaction-manager.c
hlist: drop the node parameter from iterators
[mirror_ubuntu-bionic-kernel.git] / drivers / md / persistent-data / dm-transaction-manager.c
1 /*
2 * Copyright (C) 2011 Red Hat, Inc.
3 *
4 * This file is released under the GPL.
5 */
6 #include "dm-transaction-manager.h"
7 #include "dm-space-map.h"
8 #include "dm-space-map-disk.h"
9 #include "dm-space-map-metadata.h"
10 #include "dm-persistent-data-internal.h"
11
12 #include <linux/export.h>
13 #include <linux/slab.h>
14 #include <linux/device-mapper.h>
15
16 #define DM_MSG_PREFIX "transaction manager"
17
18 /*----------------------------------------------------------------*/
19
20 struct shadow_info {
21 struct hlist_node hlist;
22 dm_block_t where;
23 };
24
25 /*
26 * It would be nice if we scaled with the size of transaction.
27 */
28 #define DM_HASH_SIZE 256
29 #define DM_HASH_MASK (DM_HASH_SIZE - 1)
30
31 struct dm_transaction_manager {
32 int is_clone;
33 struct dm_transaction_manager *real;
34
35 struct dm_block_manager *bm;
36 struct dm_space_map *sm;
37
38 spinlock_t lock;
39 struct hlist_head buckets[DM_HASH_SIZE];
40 };
41
42 /*----------------------------------------------------------------*/
43
44 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
45 {
46 int r = 0;
47 unsigned bucket = dm_hash_block(b, DM_HASH_MASK);
48 struct shadow_info *si;
49
50 spin_lock(&tm->lock);
51 hlist_for_each_entry(si, tm->buckets + bucket, hlist)
52 if (si->where == b) {
53 r = 1;
54 break;
55 }
56 spin_unlock(&tm->lock);
57
58 return r;
59 }
60
61 /*
62 * This can silently fail if there's no memory. We're ok with this since
63 * creating redundant shadows causes no harm.
64 */
65 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
66 {
67 unsigned bucket;
68 struct shadow_info *si;
69
70 si = kmalloc(sizeof(*si), GFP_NOIO);
71 if (si) {
72 si->where = b;
73 bucket = dm_hash_block(b, DM_HASH_MASK);
74 spin_lock(&tm->lock);
75 hlist_add_head(&si->hlist, tm->buckets + bucket);
76 spin_unlock(&tm->lock);
77 }
78 }
79
80 static void wipe_shadow_table(struct dm_transaction_manager *tm)
81 {
82 struct shadow_info *si;
83 struct hlist_node *tmp;
84 struct hlist_head *bucket;
85 int i;
86
87 spin_lock(&tm->lock);
88 for (i = 0; i < DM_HASH_SIZE; i++) {
89 bucket = tm->buckets + i;
90 hlist_for_each_entry_safe(si, tmp, bucket, hlist)
91 kfree(si);
92
93 INIT_HLIST_HEAD(bucket);
94 }
95
96 spin_unlock(&tm->lock);
97 }
98
99 /*----------------------------------------------------------------*/
100
101 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
102 struct dm_space_map *sm)
103 {
104 int i;
105 struct dm_transaction_manager *tm;
106
107 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
108 if (!tm)
109 return ERR_PTR(-ENOMEM);
110
111 tm->is_clone = 0;
112 tm->real = NULL;
113 tm->bm = bm;
114 tm->sm = sm;
115
116 spin_lock_init(&tm->lock);
117 for (i = 0; i < DM_HASH_SIZE; i++)
118 INIT_HLIST_HEAD(tm->buckets + i);
119
120 return tm;
121 }
122
123 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
124 {
125 struct dm_transaction_manager *tm;
126
127 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
128 if (tm) {
129 tm->is_clone = 1;
130 tm->real = real;
131 }
132
133 return tm;
134 }
135 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
136
137 void dm_tm_destroy(struct dm_transaction_manager *tm)
138 {
139 if (!tm->is_clone)
140 wipe_shadow_table(tm);
141
142 kfree(tm);
143 }
144 EXPORT_SYMBOL_GPL(dm_tm_destroy);
145
146 int dm_tm_pre_commit(struct dm_transaction_manager *tm)
147 {
148 int r;
149
150 if (tm->is_clone)
151 return -EWOULDBLOCK;
152
153 r = dm_sm_commit(tm->sm);
154 if (r < 0)
155 return r;
156
157 return 0;
158 }
159 EXPORT_SYMBOL_GPL(dm_tm_pre_commit);
160
161 int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
162 {
163 if (tm->is_clone)
164 return -EWOULDBLOCK;
165
166 wipe_shadow_table(tm);
167
168 return dm_bm_flush_and_unlock(tm->bm, root);
169 }
170 EXPORT_SYMBOL_GPL(dm_tm_commit);
171
172 int dm_tm_new_block(struct dm_transaction_manager *tm,
173 struct dm_block_validator *v,
174 struct dm_block **result)
175 {
176 int r;
177 dm_block_t new_block;
178
179 if (tm->is_clone)
180 return -EWOULDBLOCK;
181
182 r = dm_sm_new_block(tm->sm, &new_block);
183 if (r < 0)
184 return r;
185
186 r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
187 if (r < 0) {
188 dm_sm_dec_block(tm->sm, new_block);
189 return r;
190 }
191
192 /*
193 * New blocks count as shadows in that they don't need to be
194 * shadowed again.
195 */
196 insert_shadow(tm, new_block);
197
198 return 0;
199 }
200
201 static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
202 struct dm_block_validator *v,
203 struct dm_block **result)
204 {
205 int r;
206 dm_block_t new;
207 struct dm_block *orig_block;
208
209 r = dm_sm_new_block(tm->sm, &new);
210 if (r < 0)
211 return r;
212
213 r = dm_sm_dec_block(tm->sm, orig);
214 if (r < 0)
215 return r;
216
217 r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
218 if (r < 0)
219 return r;
220
221 /*
222 * It would be tempting to use dm_bm_unlock_move here, but some
223 * code, such as the space maps, keeps using the old data structures
224 * secure in the knowledge they won't be changed until the next
225 * transaction. Using unlock_move would force a synchronous read
226 * since the old block would no longer be in the cache.
227 */
228 r = dm_bm_write_lock_zero(tm->bm, new, v, result);
229 if (r) {
230 dm_bm_unlock(orig_block);
231 return r;
232 }
233
234 memcpy(dm_block_data(*result), dm_block_data(orig_block),
235 dm_bm_block_size(tm->bm));
236
237 dm_bm_unlock(orig_block);
238 return r;
239 }
240
241 int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
242 struct dm_block_validator *v, struct dm_block **result,
243 int *inc_children)
244 {
245 int r;
246
247 if (tm->is_clone)
248 return -EWOULDBLOCK;
249
250 r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
251 if (r < 0)
252 return r;
253
254 if (is_shadow(tm, orig) && !*inc_children)
255 return dm_bm_write_lock(tm->bm, orig, v, result);
256
257 r = __shadow_block(tm, orig, v, result);
258 if (r < 0)
259 return r;
260 insert_shadow(tm, dm_block_location(*result));
261
262 return r;
263 }
264 EXPORT_SYMBOL_GPL(dm_tm_shadow_block);
265
266 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
267 struct dm_block_validator *v,
268 struct dm_block **blk)
269 {
270 if (tm->is_clone)
271 return dm_bm_read_try_lock(tm->real->bm, b, v, blk);
272
273 return dm_bm_read_lock(tm->bm, b, v, blk);
274 }
275 EXPORT_SYMBOL_GPL(dm_tm_read_lock);
276
277 int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
278 {
279 return dm_bm_unlock(b);
280 }
281 EXPORT_SYMBOL_GPL(dm_tm_unlock);
282
283 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
284 {
285 /*
286 * The non-blocking clone doesn't support this.
287 */
288 BUG_ON(tm->is_clone);
289
290 dm_sm_inc_block(tm->sm, b);
291 }
292 EXPORT_SYMBOL_GPL(dm_tm_inc);
293
294 void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
295 {
296 /*
297 * The non-blocking clone doesn't support this.
298 */
299 BUG_ON(tm->is_clone);
300
301 dm_sm_dec_block(tm->sm, b);
302 }
303 EXPORT_SYMBOL_GPL(dm_tm_dec);
304
305 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
306 uint32_t *result)
307 {
308 if (tm->is_clone)
309 return -EWOULDBLOCK;
310
311 return dm_sm_get_count(tm->sm, b, result);
312 }
313
314 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
315 {
316 return tm->bm;
317 }
318
319 /*----------------------------------------------------------------*/
320
321 static int dm_tm_create_internal(struct dm_block_manager *bm,
322 dm_block_t sb_location,
323 struct dm_transaction_manager **tm,
324 struct dm_space_map **sm,
325 int create,
326 void *sm_root, size_t sm_len)
327 {
328 int r;
329
330 *sm = dm_sm_metadata_init();
331 if (IS_ERR(*sm))
332 return PTR_ERR(*sm);
333
334 *tm = dm_tm_create(bm, *sm);
335 if (IS_ERR(*tm)) {
336 dm_sm_destroy(*sm);
337 return PTR_ERR(*tm);
338 }
339
340 if (create) {
341 r = dm_sm_metadata_create(*sm, *tm, dm_bm_nr_blocks(bm),
342 sb_location);
343 if (r) {
344 DMERR("couldn't create metadata space map");
345 goto bad;
346 }
347
348 } else {
349 r = dm_sm_metadata_open(*sm, *tm, sm_root, sm_len);
350 if (r) {
351 DMERR("couldn't open metadata space map");
352 goto bad;
353 }
354 }
355
356 return 0;
357
358 bad:
359 dm_tm_destroy(*tm);
360 dm_sm_destroy(*sm);
361 return r;
362 }
363
364 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
365 struct dm_transaction_manager **tm,
366 struct dm_space_map **sm)
367 {
368 return dm_tm_create_internal(bm, sb_location, tm, sm, 1, NULL, 0);
369 }
370 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
371
372 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
373 void *sm_root, size_t root_len,
374 struct dm_transaction_manager **tm,
375 struct dm_space_map **sm)
376 {
377 return dm_tm_create_internal(bm, sb_location, tm, sm, 0, sm_root, root_len);
378 }
379 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);
380
381 /*----------------------------------------------------------------*/