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 #include "dm-transaction-manager.h" 8 #include "dm-space-map.h" 9 #include "dm-space-map-disk.h" 10 #include "dm-space-map-metadata.h" 11 #include "dm-persistent-data-internal.h" 12 13 #include <linux/export.h> 14 #include <linux/mutex.h> 15 #include <linux/hash.h> 16 #include <linux/slab.h> 17 #include <linux/device-mapper.h> 18 19 #define DM_MSG_PREFIX "transaction manager" 20 21 /*----------------------------------------------------------------*/ 22 23 #define PREFETCH_SIZE 128 24 #define PREFETCH_BITS 7 25 #define PREFETCH_SENTINEL ((dm_block_t) -1ULL) 26 27 struct prefetch_set { 28 struct mutex lock; 29 dm_block_t blocks[PREFETCH_SIZE]; 30 }; 31 32 static unsigned int prefetch_hash(dm_block_t b) 33 { 34 return hash_64(b, PREFETCH_BITS); 35 } 36 37 static void prefetch_wipe(struct prefetch_set *p) 38 { 39 unsigned int i; 40 41 for (i = 0; i < PREFETCH_SIZE; i++) 42 p->blocks[i] = PREFETCH_SENTINEL; 43 } 44 45 static void prefetch_init(struct prefetch_set *p) 46 { 47 mutex_init(&p->lock); 48 prefetch_wipe(p); 49 } 50 51 static void prefetch_add(struct prefetch_set *p, dm_block_t b) 52 { 53 unsigned int h = prefetch_hash(b); 54 55 mutex_lock(&p->lock); 56 if (p->blocks[h] == PREFETCH_SENTINEL) 57 p->blocks[h] = b; 58 59 mutex_unlock(&p->lock); 60 } 61 62 static void prefetch_issue(struct prefetch_set *p, struct dm_block_manager *bm) 63 { 64 unsigned int i; 65 66 mutex_lock(&p->lock); 67 68 for (i = 0; i < PREFETCH_SIZE; i++) 69 if (p->blocks[i] != PREFETCH_SENTINEL) { 70 dm_bm_prefetch(bm, p->blocks[i]); 71 p->blocks[i] = PREFETCH_SENTINEL; 72 } 73 74 mutex_unlock(&p->lock); 75 } 76 77 /*----------------------------------------------------------------*/ 78 79 struct shadow_info { 80 struct hlist_node hlist; 81 dm_block_t where; 82 }; 83 84 /* 85 * It would be nice if we scaled with the size of transaction. 86 */ 87 #define DM_HASH_SIZE 256 88 #define DM_HASH_MASK (DM_HASH_SIZE - 1) 89 90 struct dm_transaction_manager { 91 int is_clone; 92 struct dm_transaction_manager *real; 93 94 struct dm_block_manager *bm; 95 struct dm_space_map *sm; 96 97 spinlock_t lock; 98 struct hlist_head buckets[DM_HASH_SIZE]; 99 100 struct prefetch_set prefetches; 101 }; 102 103 /*----------------------------------------------------------------*/ 104 105 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b) 106 { 107 int r = 0; 108 unsigned int bucket = dm_hash_block(b, DM_HASH_MASK); 109 struct shadow_info *si; 110 111 spin_lock(&tm->lock); 112 hlist_for_each_entry(si, tm->buckets + bucket, hlist) 113 if (si->where == b) { 114 r = 1; 115 break; 116 } 117 spin_unlock(&tm->lock); 118 119 return r; 120 } 121 122 /* 123 * This can silently fail if there's no memory. We're ok with this since 124 * creating redundant shadows causes no harm. 125 */ 126 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b) 127 { 128 unsigned int bucket; 129 struct shadow_info *si; 130 131 si = kmalloc(sizeof(*si), GFP_NOIO); 132 if (si) { 133 si->where = b; 134 bucket = dm_hash_block(b, DM_HASH_MASK); 135 spin_lock(&tm->lock); 136 hlist_add_head(&si->hlist, tm->buckets + bucket); 137 spin_unlock(&tm->lock); 138 } 139 } 140 141 static void wipe_shadow_table(struct dm_transaction_manager *tm) 142 { 143 struct shadow_info *si; 144 struct hlist_node *tmp; 145 struct hlist_head *bucket; 146 int i; 147 148 spin_lock(&tm->lock); 149 for (i = 0; i < DM_HASH_SIZE; i++) { 150 bucket = tm->buckets + i; 151 hlist_for_each_entry_safe(si, tmp, bucket, hlist) 152 kfree(si); 153 154 INIT_HLIST_HEAD(bucket); 155 } 156 157 spin_unlock(&tm->lock); 158 } 159 160 /*----------------------------------------------------------------*/ 161 162 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm, 163 struct dm_space_map *sm) 164 { 165 int i; 166 struct dm_transaction_manager *tm; 167 168 tm = kmalloc(sizeof(*tm), GFP_KERNEL); 169 if (!tm) 170 return ERR_PTR(-ENOMEM); 171 172 tm->is_clone = 0; 173 tm->real = NULL; 174 tm->bm = bm; 175 tm->sm = sm; 176 177 spin_lock_init(&tm->lock); 178 for (i = 0; i < DM_HASH_SIZE; i++) 179 INIT_HLIST_HEAD(tm->buckets + i); 180 181 prefetch_init(&tm->prefetches); 182 183 return tm; 184 } 185 186 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real) 187 { 188 struct dm_transaction_manager *tm; 189 190 tm = kmalloc(sizeof(*tm), GFP_KERNEL); 191 if (tm) { 192 tm->is_clone = 1; 193 tm->real = real; 194 } 195 196 return tm; 197 } 198 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone); 199 200 void dm_tm_destroy(struct dm_transaction_manager *tm) 201 { 202 if (!tm) 203 return; 204 205 if (!tm->is_clone) 206 wipe_shadow_table(tm); 207 208 kfree(tm); 209 } 210 EXPORT_SYMBOL_GPL(dm_tm_destroy); 211 212 int dm_tm_pre_commit(struct dm_transaction_manager *tm) 213 { 214 int r; 215 216 if (tm->is_clone) 217 return -EWOULDBLOCK; 218 219 r = dm_sm_commit(tm->sm); 220 if (r < 0) 221 return r; 222 223 return dm_bm_flush(tm->bm); 224 } 225 EXPORT_SYMBOL_GPL(dm_tm_pre_commit); 226 227 int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root) 228 { 229 if (tm->is_clone) 230 return -EWOULDBLOCK; 231 232 wipe_shadow_table(tm); 233 dm_bm_unlock(root); 234 235 return dm_bm_flush(tm->bm); 236 } 237 EXPORT_SYMBOL_GPL(dm_tm_commit); 238 239 int dm_tm_new_block(struct dm_transaction_manager *tm, 240 struct dm_block_validator *v, 241 struct dm_block **result) 242 { 243 int r; 244 dm_block_t new_block; 245 246 if (tm->is_clone) 247 return -EWOULDBLOCK; 248 249 r = dm_sm_new_block(tm->sm, &new_block); 250 if (r < 0) 251 return r; 252 253 r = dm_bm_write_lock_zero(tm->bm, new_block, v, result); 254 if (r < 0) { 255 dm_sm_dec_block(tm->sm, new_block); 256 return r; 257 } 258 259 /* 260 * New blocks count as shadows in that they don't need to be 261 * shadowed again. 262 */ 263 insert_shadow(tm, new_block); 264 265 return 0; 266 } 267 268 static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig, 269 struct dm_block_validator *v, 270 struct dm_block **result) 271 { 272 int r; 273 dm_block_t new; 274 struct dm_block *orig_block; 275 276 r = dm_sm_new_block(tm->sm, &new); 277 if (r < 0) 278 return r; 279 280 r = dm_sm_dec_block(tm->sm, orig); 281 if (r < 0) 282 return r; 283 284 r = dm_bm_read_lock(tm->bm, orig, v, &orig_block); 285 if (r < 0) 286 return r; 287 288 /* 289 * It would be tempting to use dm_bm_unlock_move here, but some 290 * code, such as the space maps, keeps using the old data structures 291 * secure in the knowledge they won't be changed until the next 292 * transaction. Using unlock_move would force a synchronous read 293 * since the old block would no longer be in the cache. 294 */ 295 r = dm_bm_write_lock_zero(tm->bm, new, v, result); 296 if (r) { 297 dm_bm_unlock(orig_block); 298 return r; 299 } 300 301 memcpy(dm_block_data(*result), dm_block_data(orig_block), 302 dm_bm_block_size(tm->bm)); 303 304 dm_bm_unlock(orig_block); 305 return r; 306 } 307 308 int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig, 309 struct dm_block_validator *v, struct dm_block **result, 310 int *inc_children) 311 { 312 int r; 313 314 if (tm->is_clone) 315 return -EWOULDBLOCK; 316 317 r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children); 318 if (r < 0) 319 return r; 320 321 if (is_shadow(tm, orig) && !*inc_children) 322 return dm_bm_write_lock(tm->bm, orig, v, result); 323 324 r = __shadow_block(tm, orig, v, result); 325 if (r < 0) 326 return r; 327 insert_shadow(tm, dm_block_location(*result)); 328 329 return r; 330 } 331 EXPORT_SYMBOL_GPL(dm_tm_shadow_block); 332 333 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b, 334 struct dm_block_validator *v, 335 struct dm_block **blk) 336 { 337 if (tm->is_clone) { 338 int r = dm_bm_read_try_lock(tm->real->bm, b, v, blk); 339 340 if (r == -EWOULDBLOCK) 341 prefetch_add(&tm->real->prefetches, b); 342 343 return r; 344 } 345 346 return dm_bm_read_lock(tm->bm, b, v, blk); 347 } 348 EXPORT_SYMBOL_GPL(dm_tm_read_lock); 349 350 void dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b) 351 { 352 dm_bm_unlock(b); 353 } 354 EXPORT_SYMBOL_GPL(dm_tm_unlock); 355 356 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b) 357 { 358 /* 359 * The non-blocking clone doesn't support this. 360 */ 361 BUG_ON(tm->is_clone); 362 363 dm_sm_inc_block(tm->sm, b); 364 } 365 EXPORT_SYMBOL_GPL(dm_tm_inc); 366 367 void dm_tm_inc_range(struct dm_transaction_manager *tm, dm_block_t b, dm_block_t e) 368 { 369 /* 370 * The non-blocking clone doesn't support this. 371 */ 372 BUG_ON(tm->is_clone); 373 374 dm_sm_inc_blocks(tm->sm, b, e); 375 } 376 EXPORT_SYMBOL_GPL(dm_tm_inc_range); 377 378 void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b) 379 { 380 /* 381 * The non-blocking clone doesn't support this. 382 */ 383 BUG_ON(tm->is_clone); 384 385 dm_sm_dec_block(tm->sm, b); 386 } 387 EXPORT_SYMBOL_GPL(dm_tm_dec); 388 389 void dm_tm_dec_range(struct dm_transaction_manager *tm, dm_block_t b, dm_block_t e) 390 { 391 /* 392 * The non-blocking clone doesn't support this. 393 */ 394 BUG_ON(tm->is_clone); 395 396 dm_sm_dec_blocks(tm->sm, b, e); 397 } 398 EXPORT_SYMBOL_GPL(dm_tm_dec_range); 399 400 void dm_tm_with_runs(struct dm_transaction_manager *tm, 401 const __le64 *value_le, unsigned int count, dm_tm_run_fn fn) 402 { 403 uint64_t b, begin, end; 404 bool in_run = false; 405 unsigned int i; 406 407 for (i = 0; i < count; i++, value_le++) { 408 b = le64_to_cpu(*value_le); 409 410 if (in_run) { 411 if (b == end) 412 end++; 413 else { 414 fn(tm, begin, end); 415 begin = b; 416 end = b + 1; 417 } 418 } else { 419 in_run = true; 420 begin = b; 421 end = b + 1; 422 } 423 } 424 425 if (in_run) 426 fn(tm, begin, end); 427 } 428 EXPORT_SYMBOL_GPL(dm_tm_with_runs); 429 430 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b, 431 uint32_t *result) 432 { 433 if (tm->is_clone) 434 return -EWOULDBLOCK; 435 436 return dm_sm_get_count(tm->sm, b, result); 437 } 438 439 int dm_tm_block_is_shared(struct dm_transaction_manager *tm, dm_block_t b, 440 int *result) 441 { 442 if (tm->is_clone) 443 return -EWOULDBLOCK; 444 445 return dm_sm_count_is_more_than_one(tm->sm, b, result); 446 } 447 448 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm) 449 { 450 return tm->bm; 451 } 452 453 void dm_tm_issue_prefetches(struct dm_transaction_manager *tm) 454 { 455 prefetch_issue(&tm->prefetches, tm->bm); 456 } 457 EXPORT_SYMBOL_GPL(dm_tm_issue_prefetches); 458 459 /*----------------------------------------------------------------*/ 460 461 static int dm_tm_create_internal(struct dm_block_manager *bm, 462 dm_block_t sb_location, 463 struct dm_transaction_manager **tm, 464 struct dm_space_map **sm, 465 int create, 466 void *sm_root, size_t sm_len) 467 { 468 int r; 469 470 *sm = dm_sm_metadata_init(); 471 if (IS_ERR(*sm)) 472 return PTR_ERR(*sm); 473 474 *tm = dm_tm_create(bm, *sm); 475 if (IS_ERR(*tm)) { 476 dm_sm_destroy(*sm); 477 return PTR_ERR(*tm); 478 } 479 480 if (create) { 481 r = dm_sm_metadata_create(*sm, *tm, dm_bm_nr_blocks(bm), 482 sb_location); 483 if (r) { 484 DMERR("couldn't create metadata space map"); 485 goto bad; 486 } 487 488 } else { 489 r = dm_sm_metadata_open(*sm, *tm, sm_root, sm_len); 490 if (r) { 491 DMERR("couldn't open metadata space map"); 492 goto bad; 493 } 494 } 495 496 return 0; 497 498 bad: 499 dm_tm_destroy(*tm); 500 dm_sm_destroy(*sm); 501 return r; 502 } 503 504 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location, 505 struct dm_transaction_manager **tm, 506 struct dm_space_map **sm) 507 { 508 return dm_tm_create_internal(bm, sb_location, tm, sm, 1, NULL, 0); 509 } 510 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm); 511 512 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location, 513 void *sm_root, size_t root_len, 514 struct dm_transaction_manager **tm, 515 struct dm_space_map **sm) 516 { 517 return dm_tm_create_internal(bm, sb_location, tm, sm, 0, sm_root, root_len); 518 } 519 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm); 520 521 /*----------------------------------------------------------------*/ 522