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