drivers/md/dm-thin-metadata.c

   1 /*
   2  * Copyright (C) 2011 Red Hat, Inc.
   3  *
   4  * This file is released under the GPL.
   5  */
   6
   7 #include "dm-thin-metadata.h"
   8 #include "persistent-data/dm-btree.h"
   9 #include "persistent-data/dm-space-map.h"
  10 #include "persistent-data/dm-space-map-disk.h"
  11 #include "persistent-data/dm-transaction-manager.h"
  12
  13 #include <linux/list.h>
  14 #include <linux/device-mapper.h>
  15 #include <linux/workqueue.h>
  16
  17 /*--------------------------------------------------------------------------
  18  * As far as the metadata goes, there is:
  19  *
  20  * - A superblock in block zero, taking up fewer than 512 bytes for
  21  *   atomic writes.
  22  *
  23  * - A space map managing the metadata blocks.
  24  *
  25  * - A space map managing the data blocks.
  26  *
  27  * - A btree mapping our internal thin dev ids onto struct disk_device_details.
  28  *
  29  * - A hierarchical btree, with 2 levels which effectively maps (thin
  30  *   dev id, virtual block) -> block_time.  Block time is a 64-bit
  31  *   field holding the time in the low 24 bits, and block in the top 48
  32  *   bits.
  33  *
  34  * BTrees consist solely of btree_nodes, that fill a block.  Some are
  35  * internal nodes, as such their values are a __le64 pointing to other
  36  * nodes.  Leaf nodes can store data of any reasonable size (ie. much
  37  * smaller than the block size).  The nodes consist of the header,
  38  * followed by an array of keys, followed by an array of values.  We have
  39  * to binary search on the keys so they're all held together to help the
  40  * cpu cache.
  41  *
  42  * Space maps have 2 btrees:
  43  *
  44  * - One maps a uint64_t onto a struct index_entry.  Which points to a
  45  *   bitmap block, and has some details about how many free entries there
  46  *   are etc.
  47  *
  48  * - The bitmap blocks have a header (for the checksum).  Then the rest
  49  *   of the block is pairs of bits.  With the meaning being:
  50  *
  51  *   0 - ref count is 0
  52  *   1 - ref count is 1
  53  *   2 - ref count is 2
  54  *   3 - ref count is higher than 2
  55  *
  56  * - If the count is higher than 2 then the ref count is entered in a
  57  *   second btree that directly maps the block_address to a uint32_t ref
  58  *   count.
  59  *
  60  * The space map metadata variant doesn't have a bitmaps btree.  Instead
  61  * it has one single blocks worth of index_entries.  This avoids
  62  * recursive issues with the bitmap btree needing to allocate space in
  63  * order to insert.  With a small data block size such as 64k the
  64  * metadata support data devices that are hundreds of terrabytes.
  65  *
  66  * The space maps allocate space linearly from front to back.  Space that
  67  * is freed in a transaction is never recycled within that transaction.
  68  * To try and avoid fragmenting _free_ space the allocator always goes
  69  * back and fills in gaps.
  70  *
  71  * All metadata io is in THIN_METADATA_BLOCK_SIZE sized/aligned chunks
  72  * from the block manager.
  73  *--------------------------------------------------------------------------*/
  74
  75 #define DM_MSG_PREFIX   "thin metadata"
  76
  77 #define THIN_SUPERBLOCK_MAGIC 27022010
  78 #define THIN_SUPERBLOCK_LOCATION 0
  79 #define THIN_VERSION 1
  80 #define THIN_METADATA_CACHE_SIZE 64
  81 #define SECTOR_TO_BLOCK_SHIFT 3
  82
  83 /*
  84  *  3 for btree insert +
  85  *  2 for btree lookup used within space map
  86  */
  87 #define THIN_MAX_CONCURRENT_LOCKS 5
  88
  89 /* This should be plenty */
  90 #define SPACE_MAP_ROOT_SIZE 128
  91
  92 /*
  93  * Little endian on-disk superblock and device details.
  94  */
  95 struct thin_disk_superblock {
  96         __le32 csum;    /* Checksum of superblock except for this field. */
  97         __le32 flags;
  98         __le64 blocknr; /* This block number, dm_block_t. */
  99
 100         __u8 uuid[16];
 101         __le64 magic;
 102         __le32 version;
 103         __le32 time;
 104
 105         __le64 trans_id;
 106
 107         /*
 108          * Root held by userspace transactions.
 109          */
 110         __le64 held_root;
 111
 112         __u8 data_space_map_root[SPACE_MAP_ROOT_SIZE];
 113         __u8 metadata_space_map_root[SPACE_MAP_ROOT_SIZE];
 114
 115         /*
 116          * 2-level btree mapping (dev_id, (dev block, time)) -> data block
 117          */
 118         __le64 data_mapping_root;
 119
 120         /*
 121          * Device detail root mapping dev_id -> device_details
 122          */
 123         __le64 device_details_root;
 124
 125         __le32 data_block_size;         /* In 512-byte sectors. */
 126
 127         __le32 metadata_block_size;     /* In 512-byte sectors. */
 128         __le64 metadata_nr_blocks;
 129
 130         __le32 compat_flags;
 131         __le32 compat_ro_flags;
 132         __le32 incompat_flags;
 133 } __packed;
 134
 135 struct disk_device_details {
 136         __le64 mapped_blocks;
 137         __le64 transaction_id;          /* When created. */
 138         __le32 creation_time;
 139         __le32 snapshotted_time;
 140 } __packed;
 141
 142 struct dm_pool_metadata {
 143         struct hlist_node hash;
 144
 145         struct block_device *bdev;
 146         struct dm_block_manager *bm;
 147         struct dm_space_map *metadata_sm;
 148         struct dm_space_map *data_sm;
 149         struct dm_transaction_manager *tm;
 150         struct dm_transaction_manager *nb_tm;
 151
 152         /*
 153          * Two-level btree.
 154          * First level holds thin_dev_t.
 155          * Second level holds mappings.
 156          */
 157         struct dm_btree_info info;
 158
 159         /*
 160          * Non-blocking version of the above.
 161          */
 162         struct dm_btree_info nb_info;
 163
 164         /*
 165          * Just the top level for deleting whole devices.
 166          */
 167         struct dm_btree_info tl_info;
 168
 169         /*
 170          * Just the bottom level for creating new devices.
 171          */
 172         struct dm_btree_info bl_info;
 173
 174         /*
 175          * Describes the device details btree.
 176          */
 177         struct dm_btree_info details_info;
 178
 179         struct rw_semaphore root_lock;
 180         uint32_t time;
 181         int need_commit;
 182         dm_block_t root;
 183         dm_block_t details_root;
 184         struct list_head thin_devices;
 185         uint64_t trans_id;
 186         unsigned long flags;
 187         sector_t data_block_size;
 188 };
 189
 190 struct dm_thin_device {
 191         struct list_head list;
 192         struct dm_pool_metadata *pmd;
 193         dm_thin_id id;
 194
 195         int open_count;
 196         int changed;
 197         uint64_t mapped_blocks;
 198         uint64_t transaction_id;
 199         uint32_t creation_time;
 200         uint32_t snapshotted_time;
 201 };
 202
 203 /*----------------------------------------------------------------
 204  * superblock validator
 205  *--------------------------------------------------------------*/
 206
 207 #define SUPERBLOCK_CSUM_XOR 160774
 208
 209 static void sb_prepare_for_write(struct dm_block_validator *v,
 210                                  struct dm_block *b,
 211                                  size_t block_size)
 212 {
 213         struct thin_disk_superblock *disk_super = dm_block_data(b);
 214
 215         disk_super->blocknr = cpu_to_le64(dm_block_location(b));
 216         disk_super->csum = cpu_to_le32(dm_bm_checksum(&disk_super->flags,
 217                                                       block_size - sizeof(__le32),
 218                                                       SUPERBLOCK_CSUM_XOR));
 219 }
 220
 221 static int sb_check(struct dm_block_validator *v,
 222                     struct dm_block *b,
 223                     size_t block_size)
 224 {
 225         struct thin_disk_superblock *disk_super = dm_block_data(b);
 226         __le32 csum_le;
 227
 228         if (dm_block_location(b) != le64_to_cpu(disk_super->blocknr)) {
 229                 DMERR("sb_check failed: blocknr %llu: "
 230                       "wanted %llu", le64_to_cpu(disk_super->blocknr),
 231                       (unsigned long long)dm_block_location(b));
 232                 return -ENOTBLK;
 233         }
 234
 235         if (le64_to_cpu(disk_super->magic) != THIN_SUPERBLOCK_MAGIC) {
 236                 DMERR("sb_check failed: magic %llu: "
 237                       "wanted %llu", le64_to_cpu(disk_super->magic),
 238                       (unsigned long long)THIN_SUPERBLOCK_MAGIC);
 239                 return -EILSEQ;
 240         }
 241
 242         csum_le = cpu_to_le32(dm_bm_checksum(&disk_super->flags,
 243                                              block_size - sizeof(__le32),
 244                                              SUPERBLOCK_CSUM_XOR));
 245         if (csum_le != disk_super->csum) {
 246                 DMERR("sb_check failed: csum %u: wanted %u",
 247                       le32_to_cpu(csum_le), le32_to_cpu(disk_super->csum));
 248                 return -EILSEQ;
 249         }
 250
 251         return 0;
 252 }
 253
 254 static struct dm_block_validator sb_validator = {
 255         .name = "superblock",
 256         .prepare_for_write = sb_prepare_for_write,
 257         .check = sb_check
 258 };
 259
 260 /*----------------------------------------------------------------
 261  * Methods for the btree value types
 262  *--------------------------------------------------------------*/
 263
 264 static uint64_t pack_block_time(dm_block_t b, uint32_t t)
 265 {
 266         return (b << 24) | t;
 267 }
 268
 269 static void unpack_block_time(uint64_t v, dm_block_t *b, uint32_t *t)
 270 {
 271         *b = v >> 24;
 272         *t = v & ((1 << 24) - 1);
 273 }
 274
 275 static void data_block_inc(void *context, void *value_le)
 276 {
 277         struct dm_space_map *sm = context;
 278         __le64 v_le;
 279         uint64_t b;
 280         uint32_t t;
 281
 282         memcpy(&v_le, value_le, sizeof(v_le));
 283         unpack_block_time(le64_to_cpu(v_le), &b, &t);
 284         dm_sm_inc_block(sm, b);
 285 }
 286
 287 static void data_block_dec(void *context, void *value_le)
 288 {
 289         struct dm_space_map *sm = context;
 290         __le64 v_le;
 291         uint64_t b;
 292         uint32_t t;
 293
 294         memcpy(&v_le, value_le, sizeof(v_le));
 295         unpack_block_time(le64_to_cpu(v_le), &b, &t);
 296         dm_sm_dec_block(sm, b);
 297 }
 298
 299 static int data_block_equal(void *context, void *value1_le, void *value2_le)
 300 {
 301         __le64 v1_le, v2_le;
 302         uint64_t b1, b2;
 303         uint32_t t;
 304
 305         memcpy(&v1_le, value1_le, sizeof(v1_le));
 306         memcpy(&v2_le, value2_le, sizeof(v2_le));
 307         unpack_block_time(le64_to_cpu(v1_le), &b1, &t);
 308         unpack_block_time(le64_to_cpu(v2_le), &b2, &t);
 309
 310         return b1 == b2;
 311 }
 312
 313 static void subtree_inc(void *context, void *value)
 314 {
 315         struct dm_btree_info *info = context;
 316         __le64 root_le;
 317         uint64_t root;
 318
 319         memcpy(&root_le, value, sizeof(root_le));
 320         root = le64_to_cpu(root_le);
 321         dm_tm_inc(info->tm, root);
 322 }
 323
 324 static void subtree_dec(void *context, void *value)
 325 {
 326         struct dm_btree_info *info = context;
 327         __le64 root_le;
 328         uint64_t root;
 329
 330         memcpy(&root_le, value, sizeof(root_le));
 331         root = le64_to_cpu(root_le);
 332         if (dm_btree_del(info, root))
 333                 DMERR("btree delete failed\n");
 334 }
 335
 336 static int subtree_equal(void *context, void *value1_le, void *value2_le)
 337 {
 338         __le64 v1_le, v2_le;
 339         memcpy(&v1_le, value1_le, sizeof(v1_le));
 340         memcpy(&v2_le, value2_le, sizeof(v2_le));
 341
 342         return v1_le == v2_le;
 343 }
 344
 345 /*----------------------------------------------------------------*/
 346
 347 static int superblock_all_zeroes(struct dm_block_manager *bm, int *result)
 348 {
 349         int r;
 350         unsigned i;
 351         struct dm_block *b;
 352         __le64 *data_le, zero = cpu_to_le64(0);
 353         unsigned block_size = dm_bm_block_size(bm) / sizeof(__le64);
 354
 355         /*
 356          * We can't use a validator here - it may be all zeroes.
 357          */
 358         r = dm_bm_read_lock(bm, THIN_SUPERBLOCK_LOCATION, NULL, &b);
 359         if (r)
 360                 return r;
 361
 362         data_le = dm_block_data(b);
 363         *result = 1;
 364         for (i = 0; i < block_size; i++) {
 365                 if (data_le[i] != zero) {
 366                         *result = 0;
 367                         break;
 368                 }
 369         }
 370
 371         return dm_bm_unlock(b);
 372 }
 373
 374 static void __setup_btree_details(struct dm_pool_metadata *pmd)
 375 {
 376         pmd->info.tm = pmd->tm;
 377         pmd->info.levels = 2;
 378         pmd->info.value_type.context = pmd->data_sm;
 379         pmd->info.value_type.size = sizeof(__le64);
 380         pmd->info.value_type.inc = data_block_inc;
 381         pmd->info.value_type.dec = data_block_dec;
 382         pmd->info.value_type.equal = data_block_equal;
 383
 384         memcpy(&pmd->nb_info, &pmd->info, sizeof(pmd->nb_info));
 385         pmd->nb_info.tm = pmd->nb_tm;
 386
 387         pmd->tl_info.tm = pmd->tm;
 388         pmd->tl_info.levels = 1;
 389         pmd->tl_info.value_type.context = &pmd->info;
 390         pmd->tl_info.value_type.size = sizeof(__le64);
 391         pmd->tl_info.value_type.inc = subtree_inc;
 392         pmd->tl_info.value_type.dec = subtree_dec;
 393         pmd->tl_info.value_type.equal = subtree_equal;
 394
 395         pmd->bl_info.tm = pmd->tm;
 396         pmd->bl_info.levels = 1;
 397         pmd->bl_info.value_type.context = pmd->data_sm;
 398         pmd->bl_info.value_type.size = sizeof(__le64);
 399         pmd->bl_info.value_type.inc = data_block_inc;
 400         pmd->bl_info.value_type.dec = data_block_dec;
 401         pmd->bl_info.value_type.equal = data_block_equal;
 402
 403         pmd->details_info.tm = pmd->tm;
 404         pmd->details_info.levels = 1;
 405         pmd->details_info.value_type.context = NULL;
 406         pmd->details_info.value_type.size = sizeof(struct disk_device_details);
 407         pmd->details_info.value_type.inc = NULL;
 408         pmd->details_info.value_type.dec = NULL;
 409         pmd->details_info.value_type.equal = NULL;
 410 }
 411
 412 static int init_pmd(struct dm_pool_metadata *pmd,
 413                     struct dm_block_manager *bm,
 414                     dm_block_t nr_blocks, int create)
 415 {
 416         int r;
 417         struct dm_space_map *sm, *data_sm;
 418         struct dm_transaction_manager *tm;
 419         struct dm_block *sblock;
 420
 421         if (create) {
 422                 r = dm_tm_create_with_sm(bm, THIN_SUPERBLOCK_LOCATION,
 423                                          &sb_validator, &tm, &sm, &sblock);
 424                 if (r < 0) {
 425                         DMERR("tm_create_with_sm failed");
 426                         return r;
 427                 }
 428
 429                 data_sm = dm_sm_disk_create(tm, nr_blocks);
 430                 if (IS_ERR(data_sm)) {
 431                         DMERR("sm_disk_create failed");
 432                         dm_tm_unlock(tm, sblock);
 433                         r = PTR_ERR(data_sm);
 434                         goto bad;
 435                 }
 436         } else {
 437                 struct thin_disk_superblock *disk_super = NULL;
 438                 size_t space_map_root_offset =
 439                         offsetof(struct thin_disk_superblock, metadata_space_map_root);
 440
 441                 r = dm_tm_open_with_sm(bm, THIN_SUPERBLOCK_LOCATION,
 442                                        &sb_validator, space_map_root_offset,
 443                                        SPACE_MAP_ROOT_SIZE, &tm, &sm, &sblock);
 444                 if (r < 0) {
 445                         DMERR("tm_open_with_sm failed");
 446                         return r;
 447                 }
 448
 449                 disk_super = dm_block_data(sblock);
 450                 data_sm = dm_sm_disk_open(tm, disk_super->data_space_map_root,
 451                                           sizeof(disk_super->data_space_map_root));
 452                 if (IS_ERR(data_sm)) {
 453                         DMERR("sm_disk_open failed");
 454                         r = PTR_ERR(data_sm);
 455                         goto bad;
 456                 }
 457         }
 458
 459
 460         r = dm_tm_unlock(tm, sblock);
 461         if (r < 0) {
 462                 DMERR("couldn't unlock superblock");
 463                 goto bad_data_sm;
 464         }
 465
 466         pmd->bm = bm;
 467         pmd->metadata_sm = sm;
 468         pmd->data_sm = data_sm;
 469         pmd->tm = tm;
 470         pmd->nb_tm = dm_tm_create_non_blocking_clone(tm);
 471         if (!pmd->nb_tm) {
 472                 DMERR("could not create clone tm");
 473                 r = -ENOMEM;
 474                 goto bad_data_sm;
 475         }
 476
 477         __setup_btree_details(pmd);
 478         pmd->root = 0;
 479
 480         init_rwsem(&pmd->root_lock);
 481         pmd->time = 0;
 482         pmd->need_commit = 0;
 483         pmd->details_root = 0;
 484         pmd->trans_id = 0;
 485         pmd->flags = 0;
 486         INIT_LIST_HEAD(&pmd->thin_devices);
 487
 488         return 0;
 489
 490 bad_data_sm:
 491         dm_sm_destroy(data_sm);
 492 bad:
 493         dm_tm_destroy(tm);
 494         dm_sm_destroy(sm);
 495
 496         return r;
 497 }
 498
 499 static int __begin_transaction(struct dm_pool_metadata *pmd)
 500 {
 501         int r;
 502         u32 features;
 503         struct thin_disk_superblock *disk_super;
 504         struct dm_block *sblock;
 505
 506         /*
 507          * __maybe_commit_transaction() resets these
 508          */
 509         WARN_ON(pmd->need_commit);
 510
 511         /*
 512          * We re-read the superblock every time.  Shouldn't need to do this
 513          * really.
 514          */
 515         r = dm_bm_read_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
 516                             &sb_validator, &sblock);
 517         if (r)
 518                 return r;
 519
 520         disk_super = dm_block_data(sblock);
 521         pmd->time = le32_to_cpu(disk_super->time);
 522         pmd->root = le64_to_cpu(disk_super->data_mapping_root);
 523         pmd->details_root = le64_to_cpu(disk_super->device_details_root);
 524         pmd->trans_id = le64_to_cpu(disk_super->trans_id);
 525         pmd->flags = le32_to_cpu(disk_super->flags);
 526         pmd->data_block_size = le32_to_cpu(disk_super->data_block_size);
 527
 528         features = le32_to_cpu(disk_super->incompat_flags) & ~THIN_FEATURE_INCOMPAT_SUPP;
 529         if (features) {
 530                 DMERR("could not access metadata due to "
 531                       "unsupported optional features (%lx).",
 532                       (unsigned long)features);
 533                 r = -EINVAL;
 534                 goto out;
 535         }
 536
 537         /*
 538          * Check for read-only metadata to skip the following RDWR checks.
 539          */
 540         if (get_disk_ro(pmd->bdev->bd_disk))
 541                 goto out;
 542
 543         features = le32_to_cpu(disk_super->compat_ro_flags) & ~THIN_FEATURE_COMPAT_RO_SUPP;
 544         if (features) {
 545                 DMERR("could not access metadata RDWR due to "
 546                       "unsupported optional features (%lx).",
 547                       (unsigned long)features);
 548                 r = -EINVAL;
 549         }
 550
 551 out:
 552         dm_bm_unlock(sblock);
 553         return r;
 554 }
 555
 556 static int __write_changed_details(struct dm_pool_metadata *pmd)
 557 {
 558         int r;
 559         struct dm_thin_device *td, *tmp;
 560         struct disk_device_details details;
 561         uint64_t key;
 562
 563         list_for_each_entry_safe(td, tmp, &pmd->thin_devices, list) {
 564                 if (!td->changed)
 565                         continue;
 566
 567                 key = td->id;
 568
 569                 details.mapped_blocks = cpu_to_le64(td->mapped_blocks);
 570                 details.transaction_id = cpu_to_le64(td->transaction_id);
 571                 details.creation_time = cpu_to_le32(td->creation_time);
 572                 details.snapshotted_time = cpu_to_le32(td->snapshotted_time);
 573                 __dm_bless_for_disk(&details);
 574
 575                 r = dm_btree_insert(&pmd->details_info, pmd->details_root,
 576                                     &key, &details, &pmd->details_root);
 577                 if (r)
 578                         return r;
 579
 580                 if (td->open_count)
 581                         td->changed = 0;
 582                 else {
 583                         list_del(&td->list);
 584                         kfree(td);
 585                 }
 586
 587                 pmd->need_commit = 1;
 588         }
 589
 590         return 0;
 591 }
 592
 593 static int __commit_transaction(struct dm_pool_metadata *pmd)
 594 {
 595         /*
 596          * FIXME: Associated pool should be made read-only on failure.
 597          */
 598         int r;
 599         size_t metadata_len, data_len;
 600         struct thin_disk_superblock *disk_super;
 601         struct dm_block *sblock;
 602
 603         /*
 604          * We need to know if the thin_disk_superblock exceeds a 512-byte sector.
 605          */
 606         BUILD_BUG_ON(sizeof(struct thin_disk_superblock) > 512);
 607
 608         r = __write_changed_details(pmd);
 609         if (r < 0)
 610                 return r;
 611
 612         if (!pmd->need_commit)
 613                 return r;
 614
 615         r = dm_sm_commit(pmd->data_sm);
 616         if (r < 0)
 617                 return r;
 618
 619         r = dm_tm_pre_commit(pmd->tm);
 620         if (r < 0)
 621                 return r;
 622
 623         r = dm_sm_root_size(pmd->metadata_sm, &metadata_len);
 624         if (r < 0)
 625                 return r;
 626
 627         r = dm_sm_root_size(pmd->data_sm, &data_len);
 628         if (r < 0)
 629                 return r;
 630
 631         r = dm_bm_write_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
 632                              &sb_validator, &sblock);
 633         if (r)
 634                 return r;
 635
 636         disk_super = dm_block_data(sblock);
 637         disk_super->time = cpu_to_le32(pmd->time);
 638         disk_super->data_mapping_root = cpu_to_le64(pmd->root);
 639         disk_super->device_details_root = cpu_to_le64(pmd->details_root);
 640         disk_super->trans_id = cpu_to_le64(pmd->trans_id);
 641         disk_super->flags = cpu_to_le32(pmd->flags);
 642
 643         r = dm_sm_copy_root(pmd->metadata_sm, &disk_super->metadata_space_map_root,
 644                             metadata_len);
 645         if (r < 0)
 646                 goto out_locked;
 647
 648         r = dm_sm_copy_root(pmd->data_sm, &disk_super->data_space_map_root,
 649                             data_len);
 650         if (r < 0)
 651                 goto out_locked;
 652
 653         r = dm_tm_commit(pmd->tm, sblock);
 654         if (!r)
 655                 pmd->need_commit = 0;
 656
 657         return r;
 658
 659 out_locked:
 660         dm_bm_unlock(sblock);
 661         return r;
 662 }
 663
 664 struct dm_pool_metadata *dm_pool_metadata_open(struct block_device *bdev,
 665                                                sector_t data_block_size)
 666 {
 667         int r;
 668         struct thin_disk_superblock *disk_super;
 669         struct dm_pool_metadata *pmd;
 670         sector_t bdev_size = i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
 671         struct dm_block_manager *bm;
 672         int create;
 673         struct dm_block *sblock;
 674
 675         pmd = kmalloc(sizeof(*pmd), GFP_KERNEL);
 676         if (!pmd) {
 677                 DMERR("could not allocate metadata struct");
 678                 return ERR_PTR(-ENOMEM);
 679         }
 680
 681         bm = dm_block_manager_create(bdev, THIN_METADATA_BLOCK_SIZE,
 682                                      THIN_METADATA_CACHE_SIZE,
 683                                      THIN_MAX_CONCURRENT_LOCKS);
 684         if (!bm) {
 685                 DMERR("could not create block manager");
 686                 kfree(pmd);
 687                 return ERR_PTR(-ENOMEM);
 688         }
 689
 690         r = superblock_all_zeroes(bm, &create);
 691         if (r) {
 692                 dm_block_manager_destroy(bm);
 693                 kfree(pmd);
 694                 return ERR_PTR(r);
 695         }
 696
 697
 698         r = init_pmd(pmd, bm, 0, create);
 699         if (r) {
 700                 dm_block_manager_destroy(bm);
 701                 kfree(pmd);
 702                 return ERR_PTR(r);
 703         }
 704         pmd->bdev = bdev;
 705
 706         if (!create) {
 707                 r = __begin_transaction(pmd);
 708                 if (r < 0)
 709                         goto bad;
 710                 return pmd;
 711         }
 712
 713         /*
 714          * Create.
 715          */
 716         r = dm_bm_write_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
 717                              &sb_validator, &sblock);
 718         if (r)
 719                 goto bad;
 720
 721         if (bdev_size > THIN_METADATA_MAX_SECTORS)
 722                 bdev_size = THIN_METADATA_MAX_SECTORS;
 723
 724         disk_super = dm_block_data(sblock);
 725         disk_super->magic = cpu_to_le64(THIN_SUPERBLOCK_MAGIC);
 726         disk_super->version = cpu_to_le32(THIN_VERSION);
 727         disk_super->time = 0;
 728         disk_super->metadata_block_size = cpu_to_le32(THIN_METADATA_BLOCK_SIZE >> SECTOR_SHIFT);
 729         disk_super->metadata_nr_blocks = cpu_to_le64(bdev_size >> SECTOR_TO_BLOCK_SHIFT);
 730         disk_super->data_block_size = cpu_to_le32(data_block_size);
 731
 732         r = dm_bm_unlock(sblock);
 733         if (r < 0)
 734                 goto bad;
 735
 736         r = dm_btree_empty(&pmd->info, &pmd->root);
 737         if (r < 0)
 738                 goto bad;
 739
 740         r = dm_btree_empty(&pmd->details_info, &pmd->details_root);
 741         if (r < 0) {
 742                 DMERR("couldn't create devices root");
 743                 goto bad;
 744         }
 745
 746         pmd->flags = 0;
 747         pmd->need_commit = 1;
 748         r = dm_pool_commit_metadata(pmd);
 749         if (r < 0) {
 750                 DMERR("%s: dm_pool_commit_metadata() failed, error = %d",
 751                       __func__, r);
 752                 goto bad;
 753         }
 754
 755         return pmd;
 756
 757 bad:
 758         if (dm_pool_metadata_close(pmd) < 0)
 759                 DMWARN("%s: dm_pool_metadata_close() failed.", __func__);
 760         return ERR_PTR(r);
 761 }
 762
 763 int dm_pool_metadata_close(struct dm_pool_metadata *pmd)
 764 {
 765         int r;
 766         unsigned open_devices = 0;
 767         struct dm_thin_device *td, *tmp;
 768
 769         down_read(&pmd->root_lock);
 770         list_for_each_entry_safe(td, tmp, &pmd->thin_devices, list) {
 771                 if (td->open_count)
 772                         open_devices++;
 773                 else {
 774                         list_del(&td->list);
 775                         kfree(td);
 776                 }
 777         }
 778         up_read(&pmd->root_lock);
 779
 780         if (open_devices) {
 781                 DMERR("attempt to close pmd when %u device(s) are still open",
 782                        open_devices);
 783                 return -EBUSY;
 784         }
 785
 786         r = __commit_transaction(pmd);
 787         if (r < 0)
 788                 DMWARN("%s: __commit_transaction() failed, error = %d",
 789                        __func__, r);
 790
 791         dm_tm_destroy(pmd->tm);
 792         dm_tm_destroy(pmd->nb_tm);
 793         dm_block_manager_destroy(pmd->bm);
 794         dm_sm_destroy(pmd->metadata_sm);
 795         dm_sm_destroy(pmd->data_sm);
 796         kfree(pmd);
 797
 798         return 0;
 799 }
 800
 801 /*
 802  * __open_device: Returns @td corresponding to device with id @dev,
 803  * creating it if @create is set and incrementing @td->open_count.
 804  * On failure, @td is undefined.
 805  */
 806 static int __open_device(struct dm_pool_metadata *pmd,
 807                          dm_thin_id dev, int create,
 808                          struct dm_thin_device **td)
 809 {
 810         int r, changed = 0;
 811         struct dm_thin_device *td2;
 812         uint64_t key = dev;
 813         struct disk_device_details details_le;
 814
 815         /*
 816          * If the device is already open, return it.
 817          */
 818         list_for_each_entry(td2, &pmd->thin_devices, list)
 819                 if (td2->id == dev) {
 820                         /*
 821                          * May not create an already-open device.
 822                          */
 823                         if (create)
 824                                 return -EEXIST;
 825
 826                         td2->open_count++;
 827                         *td = td2;
 828                         return 0;
 829                 }
 830
 831         /*
 832          * Check the device exists.
 833          */
 834         r = dm_btree_lookup(&pmd->details_info, pmd->details_root,
 835                             &key, &details_le);
 836         if (r) {
 837                 if (r != -ENODATA || !create)
 838                         return r;
 839
 840                 /*
 841                  * Create new device.
 842                  */
 843                 changed = 1;
 844                 details_le.mapped_blocks = 0;
 845                 details_le.transaction_id = cpu_to_le64(pmd->trans_id);
 846                 details_le.creation_time = cpu_to_le32(pmd->time);
 847                 details_le.snapshotted_time = cpu_to_le32(pmd->time);
 848         }
 849
 850         *td = kmalloc(sizeof(**td), GFP_NOIO);
 851         if (!*td)
 852                 return -ENOMEM;
 853
 854         (*td)->pmd = pmd;
 855         (*td)->id = dev;
 856         (*td)->open_count = 1;
 857         (*td)->changed = changed;
 858         (*td)->mapped_blocks = le64_to_cpu(details_le.mapped_blocks);
 859         (*td)->transaction_id = le64_to_cpu(details_le.transaction_id);
 860         (*td)->creation_time = le32_to_cpu(details_le.creation_time);
 861         (*td)->snapshotted_time = le32_to_cpu(details_le.snapshotted_time);
 862
 863         list_add(&(*td)->list, &pmd->thin_devices);
 864
 865         return 0;
 866 }
 867
 868 static void __close_device(struct dm_thin_device *td)
 869 {
 870         --td->open_count;
 871 }
 872
 873 static int __create_thin(struct dm_pool_metadata *pmd,
 874                          dm_thin_id dev)
 875 {
 876         int r;
 877         dm_block_t dev_root;
 878         uint64_t key = dev;
 879         struct disk_device_details details_le;
 880         struct dm_thin_device *td;
 881         __le64 value;
 882
 883         r = dm_btree_lookup(&pmd->details_info, pmd->details_root,
 884                             &key, &details_le);
 885         if (!r)
 886                 return -EEXIST;
 887
 888         /*
 889          * Create an empty btree for the mappings.
 890          */
 891         r = dm_btree_empty(&pmd->bl_info, &dev_root);
 892         if (r)
 893                 return r;
 894
 895         /*
 896          * Insert it into the main mapping tree.
 897          */
 898         value = cpu_to_le64(dev_root);
 899         __dm_bless_for_disk(&value);
 900         r = dm_btree_insert(&pmd->tl_info, pmd->root, &key, &value, &pmd->root);
 901         if (r) {
 902                 dm_btree_del(&pmd->bl_info, dev_root);
 903                 return r;
 904         }
 905
 906         r = __open_device(pmd, dev, 1, &td);
 907         if (r) {
 908                 dm_btree_remove(&pmd->tl_info, pmd->root, &key, &pmd->root);
 909                 dm_btree_del(&pmd->bl_info, dev_root);
 910                 return r;
 911         }
 912         __close_device(td);
 913
 914         return r;
 915 }
 916
 917 int dm_pool_create_thin(struct dm_pool_metadata *pmd, dm_thin_id dev)
 918 {
 919         int r;
 920
 921         down_write(&pmd->root_lock);
 922         r = __create_thin(pmd, dev);
 923         up_write(&pmd->root_lock);
 924
 925         return r;
 926 }
 927
 928 static int __set_snapshot_details(struct dm_pool_metadata *pmd,
 929                                   struct dm_thin_device *snap,
 930                                   dm_thin_id origin, uint32_t time)
 931 {
 932         int r;
 933         struct dm_thin_device *td;
 934
 935         r = __open_device(pmd, origin, 0, &td);
 936         if (r)
 937                 return r;
 938
 939         td->changed = 1;
 940         td->snapshotted_time = time;
 941
 942         snap->mapped_blocks = td->mapped_blocks;
 943         snap->snapshotted_time = time;
 944         __close_device(td);
 945
 946         return 0;
 947 }
 948
 949 static int __create_snap(struct dm_pool_metadata *pmd,
 950                          dm_thin_id dev, dm_thin_id origin)
 951 {
 952         int r;
 953         dm_block_t origin_root;
 954         uint64_t key = origin, dev_key = dev;
 955         struct dm_thin_device *td;
 956         struct disk_device_details details_le;
 957         __le64 value;
 958
 959         /* check this device is unused */
 960         r = dm_btree_lookup(&pmd->details_info, pmd->details_root,
 961                             &dev_key, &details_le);
 962         if (!r)
 963                 return -EEXIST;
 964
 965         /* find the mapping tree for the origin */
 966         r = dm_btree_lookup(&pmd->tl_info, pmd->root, &key, &value);
 967         if (r)
 968                 return r;
 969         origin_root = le64_to_cpu(value);
 970
 971         /* clone the origin, an inc will do */
 972         dm_tm_inc(pmd->tm, origin_root);
 973
 974         /* insert into the main mapping tree */
 975         value = cpu_to_le64(origin_root);
 976         __dm_bless_for_disk(&value);
 977         key = dev;
 978         r = dm_btree_insert(&pmd->tl_info, pmd->root, &key, &value, &pmd->root);
 979         if (r) {
 980                 dm_tm_dec(pmd->tm, origin_root);
 981                 return r;
 982         }
 983
 984         pmd->time++;
 985
 986         r = __open_device(pmd, dev, 1, &td);
 987         if (r)
 988                 goto bad;
 989
 990         r = __set_snapshot_details(pmd, td, origin, pmd->time);
 991         __close_device(td);
 992
 993         if (r)
 994                 goto bad;
 995
 996         return 0;
 997
 998 bad:
 999         dm_btree_remove(&pmd->tl_info, pmd->root, &key, &pmd->root);
1000         dm_btree_remove(&pmd->details_info, pmd->details_root,
1001                         &key, &pmd->details_root);
1002         return r;
1003 }
1004
1005 int dm_pool_create_snap(struct dm_pool_metadata *pmd,
1006                                  dm_thin_id dev,
1007                                  dm_thin_id origin)
1008 {
1009         int r;
1010
1011         down_write(&pmd->root_lock);
1012         r = __create_snap(pmd, dev, origin);
1013         up_write(&pmd->root_lock);
1014
1015         return r;
1016 }
1017
1018 static int __delete_device(struct dm_pool_metadata *pmd, dm_thin_id dev)
1019 {
1020         int r;
1021         uint64_t key = dev;
1022         struct dm_thin_device *td;
1023
1024         /* TODO: failure should mark the transaction invalid */
1025         r = __open_device(pmd, dev, 0, &td);
1026         if (r)
1027                 return r;
1028
1029         if (td->open_count > 1) {
1030                 __close_device(td);
1031                 return -EBUSY;
1032         }
1033
1034         list_del(&td->list);
1035         kfree(td);
1036         r = dm_btree_remove(&pmd->details_info, pmd->details_root,
1037                             &key, &pmd->details_root);
1038         if (r)
1039                 return r;
1040
1041         r = dm_btree_remove(&pmd->tl_info, pmd->root, &key, &pmd->root);
1042         if (r)
1043                 return r;
1044
1045         pmd->need_commit = 1;
1046
1047         return 0;
1048 }
1049
1050 int dm_pool_delete_thin_device(struct dm_pool_metadata *pmd,
1051                                dm_thin_id dev)
1052 {
1053         int r;
1054
1055         down_write(&pmd->root_lock);
1056         r = __delete_device(pmd, dev);
1057         up_write(&pmd->root_lock);
1058
1059         return r;
1060 }
1061
1062 int dm_pool_set_metadata_transaction_id(struct dm_pool_metadata *pmd,
1063                                         uint64_t current_id,
1064                                         uint64_t new_id)
1065 {
1066         down_write(&pmd->root_lock);
1067         if (pmd->trans_id != current_id) {
1068                 up_write(&pmd->root_lock);
1069                 DMERR("mismatched transaction id");
1070                 return -EINVAL;
1071         }
1072
1073         pmd->trans_id = new_id;
1074         pmd->need_commit = 1;
1075         up_write(&pmd->root_lock);
1076
1077         return 0;
1078 }
1079
1080 int dm_pool_get_metadata_transaction_id(struct dm_pool_metadata *pmd,
1081                                         uint64_t *result)
1082 {
1083         down_read(&pmd->root_lock);
1084         *result = pmd->trans_id;
1085         up_read(&pmd->root_lock);
1086
1087         return 0;
1088 }
1089
1090 static int __reserve_metadata_snap(struct dm_pool_metadata *pmd)
1091 {
1092         int r, inc;
1093         struct thin_disk_superblock *disk_super;
1094         struct dm_block *copy, *sblock;
1095         dm_block_t held_root;
1096
1097         /*
1098          * Copy the superblock.
1099          */
1100         dm_sm_inc_block(pmd->metadata_sm, THIN_SUPERBLOCK_LOCATION);
1101         r = dm_tm_shadow_block(pmd->tm, THIN_SUPERBLOCK_LOCATION,
1102                                &sb_validator, &copy, &inc);
1103         if (r)
1104                 return r;
1105
1106         BUG_ON(!inc);
1107
1108         held_root = dm_block_location(copy);
1109         disk_super = dm_block_data(copy);
1110
1111         if (le64_to_cpu(disk_super->held_root)) {
1112                 DMWARN("Pool metadata snapshot already exists: release this before taking another.");
1113
1114                 dm_tm_dec(pmd->tm, held_root);
1115                 dm_tm_unlock(pmd->tm, copy);
1116                 pmd->need_commit = 1;
1117
1118                 return -EBUSY;
1119         }
1120
1121         /*
1122          * Wipe the spacemap since we're not publishing this.
1123          */
1124         memset(&disk_super->data_space_map_root, 0,
1125                sizeof(disk_super->data_space_map_root));
1126         memset(&disk_super->metadata_space_map_root, 0,
1127                sizeof(disk_super->metadata_space_map_root));
1128
1129         /*
1130          * Increment the data structures that need to be preserved.
1131          */
1132         dm_tm_inc(pmd->tm, le64_to_cpu(disk_super->data_mapping_root));
1133         dm_tm_inc(pmd->tm, le64_to_cpu(disk_super->device_details_root));
1134         dm_tm_unlock(pmd->tm, copy);
1135
1136         /*
1137          * Write the held root into the superblock.
1138          */
1139         r = dm_bm_write_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
1140                              &sb_validator, &sblock);
1141         if (r) {
1142                 dm_tm_dec(pmd->tm, held_root);
1143                 pmd->need_commit = 1;
1144                 return r;
1145         }
1146
1147         disk_super = dm_block_data(sblock);
1148         disk_super->held_root = cpu_to_le64(held_root);
1149         dm_bm_unlock(sblock);
1150
1151         pmd->need_commit = 1;
1152
1153         return 0;
1154 }
1155
1156 int dm_pool_reserve_metadata_snap(struct dm_pool_metadata *pmd)
1157 {
1158         int r;
1159
1160         down_write(&pmd->root_lock);
1161         r = __reserve_metadata_snap(pmd);
1162         up_write(&pmd->root_lock);
1163
1164         return r;
1165 }
1166
1167 static int __release_metadata_snap(struct dm_pool_metadata *pmd)
1168 {
1169         int r;
1170         struct thin_disk_superblock *disk_super;
1171         struct dm_block *sblock, *copy;
1172         dm_block_t held_root;
1173
1174         r = dm_bm_write_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
1175                              &sb_validator, &sblock);
1176         if (r)
1177                 return r;
1178
1179         disk_super = dm_block_data(sblock);
1180         held_root = le64_to_cpu(disk_super->held_root);
1181         disk_super->held_root = cpu_to_le64(0);
1182         pmd->need_commit = 1;
1183
1184         dm_bm_unlock(sblock);
1185
1186         if (!held_root) {
1187                 DMWARN("No pool metadata snapshot found: nothing to release.");
1188                 return -EINVAL;
1189         }
1190
1191         r = dm_tm_read_lock(pmd->tm, held_root, &sb_validator, &copy);
1192         if (r)
1193                 return r;
1194
1195         disk_super = dm_block_data(copy);
1196         dm_sm_dec_block(pmd->metadata_sm, le64_to_cpu(disk_super->data_mapping_root));
1197         dm_sm_dec_block(pmd->metadata_sm, le64_to_cpu(disk_super->device_details_root));
1198         dm_sm_dec_block(pmd->metadata_sm, held_root);
1199
1200         return dm_tm_unlock(pmd->tm, copy);
1201 }
1202
1203 int dm_pool_release_metadata_snap(struct dm_pool_metadata *pmd)
1204 {
1205         int r;
1206
1207         down_write(&pmd->root_lock);
1208         r = __release_metadata_snap(pmd);
1209         up_write(&pmd->root_lock);
1210
1211         return r;
1212 }
1213
1214 static int __get_metadata_snap(struct dm_pool_metadata *pmd,
1215                                dm_block_t *result)
1216 {
1217         int r;
1218         struct thin_disk_superblock *disk_super;
1219         struct dm_block *sblock;
1220
1221         r = dm_bm_read_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
1222                             &sb_validator, &sblock);
1223         if (r)
1224                 return r;
1225
1226         disk_super = dm_block_data(sblock);
1227         *result = le64_to_cpu(disk_super->held_root);
1228
1229         return dm_bm_unlock(sblock);
1230 }
1231
1232 int dm_pool_get_metadata_snap(struct dm_pool_metadata *pmd,
1233                               dm_block_t *result)
1234 {
1235         int r;
1236
1237         down_read(&pmd->root_lock);
1238         r = __get_metadata_snap(pmd, result);
1239         up_read(&pmd->root_lock);
1240
1241         return r;
1242 }
1243
1244 int dm_pool_open_thin_device(struct dm_pool_metadata *pmd, dm_thin_id dev,
1245                              struct dm_thin_device **td)
1246 {
1247         int r;
1248
1249         down_write(&pmd->root_lock);
1250         r = __open_device(pmd, dev, 0, td);
1251         up_write(&pmd->root_lock);
1252
1253         return r;
1254 }
1255
1256 int dm_pool_close_thin_device(struct dm_thin_device *td)
1257 {
1258         down_write(&td->pmd->root_lock);
1259         __close_device(td);
1260         up_write(&td->pmd->root_lock);
1261
1262         return 0;
1263 }
1264
1265 dm_thin_id dm_thin_dev_id(struct dm_thin_device *td)
1266 {
1267         return td->id;
1268 }
1269
1270 static bool __snapshotted_since(struct dm_thin_device *td, uint32_t time)
1271 {
1272         return td->snapshotted_time > time;
1273 }
1274
1275 int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block,
1276                        int can_block, struct dm_thin_lookup_result *result)
1277 {
1278         int r;
1279         uint64_t block_time = 0;
1280         __le64 value;
1281         struct dm_pool_metadata *pmd = td->pmd;
1282         dm_block_t keys[2] = { td->id, block };
1283
1284         if (can_block) {
1285                 down_read(&pmd->root_lock);
1286                 r = dm_btree_lookup(&pmd->info, pmd->root, keys, &value);
1287                 if (!r)
1288                         block_time = le64_to_cpu(value);
1289                 up_read(&pmd->root_lock);
1290
1291         } else if (down_read_trylock(&pmd->root_lock)) {
1292                 r = dm_btree_lookup(&pmd->nb_info, pmd->root, keys, &value);
1293                 if (!r)
1294                         block_time = le64_to_cpu(value);
1295                 up_read(&pmd->root_lock);
1296
1297         } else
1298                 return -EWOULDBLOCK;
1299
1300         if (!r) {
1301                 dm_block_t exception_block;
1302                 uint32_t exception_time;
1303                 unpack_block_time(block_time, &exception_block,
1304                                   &exception_time);
1305                 result->block = exception_block;
1306                 result->shared = __snapshotted_since(td, exception_time);
1307         }
1308
1309         return r;
1310 }
1311
1312 static int __insert(struct dm_thin_device *td, dm_block_t block,
1313                     dm_block_t data_block)
1314 {
1315         int r, inserted;
1316         __le64 value;
1317         struct dm_pool_metadata *pmd = td->pmd;
1318         dm_block_t keys[2] = { td->id, block };
1319
1320         pmd->need_commit = 1;
1321         value = cpu_to_le64(pack_block_time(data_block, pmd->time));
1322         __dm_bless_for_disk(&value);
1323
1324         r = dm_btree_insert_notify(&pmd->info, pmd->root, keys, &value,
1325                                    &pmd->root, &inserted);
1326         if (r)
1327                 return r;
1328
1329         if (inserted) {
1330                 td->mapped_blocks++;
1331                 td->changed = 1;
1332         }
1333
1334         return 0;
1335 }
1336
1337 int dm_thin_insert_block(struct dm_thin_device *td, dm_block_t block,
1338                          dm_block_t data_block)
1339 {
1340         int r;
1341
1342         down_write(&td->pmd->root_lock);
1343         r = __insert(td, block, data_block);
1344         up_write(&td->pmd->root_lock);
1345
1346         return r;
1347 }
1348
1349 static int __remove(struct dm_thin_device *td, dm_block_t block)
1350 {
1351         int r;
1352         struct dm_pool_metadata *pmd = td->pmd;
1353         dm_block_t keys[2] = { td->id, block };
1354
1355         r = dm_btree_remove(&pmd->info, pmd->root, keys, &pmd->root);
1356         if (r)
1357                 return r;
1358
1359         td->mapped_blocks--;
1360         td->changed = 1;
1361         pmd->need_commit = 1;
1362
1363         return 0;
1364 }
1365
1366 int dm_thin_remove_block(struct dm_thin_device *td, dm_block_t block)
1367 {
1368         int r;
1369
1370         down_write(&td->pmd->root_lock);
1371         r = __remove(td, block);
1372         up_write(&td->pmd->root_lock);
1373
1374         return r;
1375 }
1376
1377 int dm_pool_alloc_data_block(struct dm_pool_metadata *pmd, dm_block_t *result)
1378 {
1379         int r;
1380
1381         down_write(&pmd->root_lock);
1382
1383         r = dm_sm_new_block(pmd->data_sm, result);
1384         pmd->need_commit = 1;
1385
1386         up_write(&pmd->root_lock);
1387
1388         return r;
1389 }
1390
1391 int dm_pool_commit_metadata(struct dm_pool_metadata *pmd)
1392 {
1393         int r;
1394
1395         down_write(&pmd->root_lock);
1396
1397         r = __commit_transaction(pmd);
1398         if (r <= 0)
1399                 goto out;
1400
1401         /*
1402          * Open the next transaction.
1403          */
1404         r = __begin_transaction(pmd);
1405 out:
1406         up_write(&pmd->root_lock);
1407         return r;
1408 }
1409
1410 int dm_pool_get_free_block_count(struct dm_pool_metadata *pmd, dm_block_t *result)
1411 {
1412         int r;
1413
1414         down_read(&pmd->root_lock);
1415         r = dm_sm_get_nr_free(pmd->data_sm, result);
1416         up_read(&pmd->root_lock);
1417
1418         return r;
1419 }
1420
1421 int dm_pool_get_free_metadata_block_count(struct dm_pool_metadata *pmd,
1422                                           dm_block_t *result)
1423 {
1424         int r;
1425
1426         down_read(&pmd->root_lock);
1427         r = dm_sm_get_nr_free(pmd->metadata_sm, result);
1428         up_read(&pmd->root_lock);
1429
1430         return r;
1431 }
1432
1433 int dm_pool_get_metadata_dev_size(struct dm_pool_metadata *pmd,
1434                                   dm_block_t *result)
1435 {
1436         int r;
1437
1438         down_read(&pmd->root_lock);
1439         r = dm_sm_get_nr_blocks(pmd->metadata_sm, result);
1440         up_read(&pmd->root_lock);
1441
1442         return r;
1443 }
1444
1445 int dm_pool_get_data_block_size(struct dm_pool_metadata *pmd, sector_t *result)
1446 {
1447         down_read(&pmd->root_lock);
1448         *result = pmd->data_block_size;
1449         up_read(&pmd->root_lock);
1450
1451         return 0;
1452 }
1453
1454 int dm_pool_get_data_dev_size(struct dm_pool_metadata *pmd, dm_block_t *result)
1455 {
1456         int r;
1457
1458         down_read(&pmd->root_lock);
1459         r = dm_sm_get_nr_blocks(pmd->data_sm, result);
1460         up_read(&pmd->root_lock);
1461
1462         return r;
1463 }
1464
1465 int dm_thin_get_mapped_count(struct dm_thin_device *td, dm_block_t *result)
1466 {
1467         struct dm_pool_metadata *pmd = td->pmd;
1468
1469         down_read(&pmd->root_lock);
1470         *result = td->mapped_blocks;
1471         up_read(&pmd->root_lock);
1472
1473         return 0;
1474 }
1475
1476 static int __highest_block(struct dm_thin_device *td, dm_block_t *result)
1477 {
1478         int r;
1479         __le64 value_le;
1480         dm_block_t thin_root;
1481         struct dm_pool_metadata *pmd = td->pmd;
1482
1483         r = dm_btree_lookup(&pmd->tl_info, pmd->root, &td->id, &value_le);
1484         if (r)
1485                 return r;
1486
1487         thin_root = le64_to_cpu(value_le);
1488
1489         return dm_btree_find_highest_key(&pmd->bl_info, thin_root, result);
1490 }
1491
1492 int dm_thin_get_highest_mapped_block(struct dm_thin_device *td,
1493                                      dm_block_t *result)
1494 {
1495         int r;
1496         struct dm_pool_metadata *pmd = td->pmd;
1497
1498         down_read(&pmd->root_lock);
1499         r = __highest_block(td, result);
1500         up_read(&pmd->root_lock);
1501
1502         return r;
1503 }
1504
1505 static int __resize_data_dev(struct dm_pool_metadata *pmd, dm_block_t new_count)
1506 {
1507         int r;
1508         dm_block_t old_count;
1509
1510         r = dm_sm_get_nr_blocks(pmd->data_sm, &old_count);
1511         if (r)
1512                 return r;
1513
1514         if (new_count == old_count)
1515                 return 0;
1516
1517         if (new_count < old_count) {
1518                 DMERR("cannot reduce size of data device");
1519                 return -EINVAL;
1520         }
1521
1522         r = dm_sm_extend(pmd->data_sm, new_count - old_count);
1523         if (!r)
1524                 pmd->need_commit = 1;
1525
1526         return r;
1527 }
1528
1529 int dm_pool_resize_data_dev(struct dm_pool_metadata *pmd, dm_block_t new_count)
1530 {
1531         int r;
1532
1533         down_write(&pmd->root_lock);
1534         r = __resize_data_dev(pmd, new_count);
1535         up_write(&pmd->root_lock);
1536
1537         return r;
1538 }