fs/btrfs/tests/inode-tests.c

   1 /*
   2  * Copyright (C) 2013 Fusion IO.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include "btrfs-tests.h"
  20 #include "../ctree.h"
  21 #include "../btrfs_inode.h"
  22 #include "../disk-io.h"
  23 #include "../extent_io.h"
  24 #include "../volumes.h"
  25
  26 static void insert_extent(struct btrfs_root *root, u64 start, u64 len,
  27                           u64 ram_bytes, u64 offset, u64 disk_bytenr,
  28                           u64 disk_len, u32 type, u8 compression, int slot)
  29 {
  30         struct btrfs_path path;
  31         struct btrfs_file_extent_item *fi;
  32         struct extent_buffer *leaf = root->node;
  33         struct btrfs_key key;
  34         u32 value_len = sizeof(struct btrfs_file_extent_item);
  35
  36         if (type == BTRFS_FILE_EXTENT_INLINE)
  37                 value_len += len;
  38         memset(&path, 0, sizeof(path));
  39
  40         path.nodes[0] = leaf;
  41         path.slots[0] = slot;
  42
  43         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
  44         key.type = BTRFS_EXTENT_DATA_KEY;
  45         key.offset = start;
  46
  47         setup_items_for_insert(root, &path, &key, &value_len, value_len,
  48                                value_len + sizeof(struct btrfs_item), 1);
  49         fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
  50         btrfs_set_file_extent_generation(leaf, fi, 1);
  51         btrfs_set_file_extent_type(leaf, fi, type);
  52         btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
  53         btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_len);
  54         btrfs_set_file_extent_offset(leaf, fi, offset);
  55         btrfs_set_file_extent_num_bytes(leaf, fi, len);
  56         btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
  57         btrfs_set_file_extent_compression(leaf, fi, compression);
  58         btrfs_set_file_extent_encryption(leaf, fi, 0);
  59         btrfs_set_file_extent_other_encoding(leaf, fi, 0);
  60 }
  61
  62 static void insert_inode_item_key(struct btrfs_root *root)
  63 {
  64         struct btrfs_path path;
  65         struct extent_buffer *leaf = root->node;
  66         struct btrfs_key key;
  67         u32 value_len = 0;
  68
  69         memset(&path, 0, sizeof(path));
  70
  71         path.nodes[0] = leaf;
  72         path.slots[0] = 0;
  73
  74         key.objectid = BTRFS_INODE_ITEM_KEY;
  75         key.type = BTRFS_INODE_ITEM_KEY;
  76         key.offset = 0;
  77
  78         setup_items_for_insert(root, &path, &key, &value_len, value_len,
  79                                value_len + sizeof(struct btrfs_item), 1);
  80 }
  81
  82 /*
  83  * Build the most complicated map of extents the earth has ever seen.  We want
  84  * this so we can test all of the corner cases of btrfs_get_extent.  Here is a
  85  * diagram of how the extents will look though this may not be possible we still
  86  * want to make sure everything acts normally (the last number is not inclusive)
  87  *
  88  * [0 - 5][5 -  6][6 - 10][10 - 4096][  4096 - 8192 ][8192 - 12288]
  89  * [hole ][inline][ hole ][ regular ][regular1 split][    hole    ]
  90  *
  91  * [ 12288 - 20480][20480 - 24576][  24576 - 28672  ][28672 - 36864][36864 - 45056]
  92  * [regular1 split][   prealloc1 ][prealloc1 written][   prealloc1 ][ compressed  ]
  93  *
  94  * [45056 - 49152][49152-53248][53248-61440][61440-65536][     65536+81920   ]
  95  * [ compressed1 ][  regular  ][compressed1][  regular  ][ hole but no extent]
  96  *
  97  * [81920-86016]
  98  * [  regular  ]
  99  */
 100 static void setup_file_extents(struct btrfs_root *root)
 101 {
 102         int slot = 0;
 103         u64 disk_bytenr = 1 * 1024 * 1024;
 104         u64 offset = 0;
 105
 106         /* First we want a hole */
 107         insert_extent(root, offset, 5, 5, 0, 0, 0, BTRFS_FILE_EXTENT_REG, 0,
 108                       slot);
 109         slot++;
 110         offset += 5;
 111
 112         /*
 113          * Now we want an inline extent, I don't think this is possible but hey
 114          * why not?  Also keep in mind if we have an inline extent it counts as
 115          * the whole first page.  If we were to expand it we would have to cow
 116          * and we wouldn't have an inline extent anymore.
 117          */
 118         insert_extent(root, offset, 1, 1, 0, 0, 0, BTRFS_FILE_EXTENT_INLINE, 0,
 119                       slot);
 120         slot++;
 121         offset = 4096;
 122
 123         /* Now another hole */
 124         insert_extent(root, offset, 4, 4, 0, 0, 0, BTRFS_FILE_EXTENT_REG, 0,
 125                       slot);
 126         slot++;
 127         offset += 4;
 128
 129         /* Now for a regular extent */
 130         insert_extent(root, offset, 4095, 4095, 0, disk_bytenr, 4096,
 131                       BTRFS_FILE_EXTENT_REG, 0, slot);
 132         slot++;
 133         disk_bytenr += 4096;
 134         offset += 4095;
 135
 136         /*
 137          * Now for 3 extents that were split from a hole punch so we test
 138          * offsets properly.
 139          */
 140         insert_extent(root, offset, 4096, 16384, 0, disk_bytenr, 16384,
 141                       BTRFS_FILE_EXTENT_REG, 0, slot);
 142         slot++;
 143         offset += 4096;
 144         insert_extent(root, offset, 4096, 4096, 0, 0, 0, BTRFS_FILE_EXTENT_REG,
 145                       0, slot);
 146         slot++;
 147         offset += 4096;
 148         insert_extent(root, offset, 8192, 16384, 8192, disk_bytenr, 16384,
 149                       BTRFS_FILE_EXTENT_REG, 0, slot);
 150         slot++;
 151         offset += 8192;
 152         disk_bytenr += 16384;
 153
 154         /* Now for a unwritten prealloc extent */
 155         insert_extent(root, offset, 4096, 4096, 0, disk_bytenr, 4096,
 156                       BTRFS_FILE_EXTENT_PREALLOC, 0, slot);
 157         slot++;
 158         offset += 4096;
 159
 160         /*
 161          * We want to jack up disk_bytenr a little more so the em stuff doesn't
 162          * merge our records.
 163          */
 164         disk_bytenr += 8192;
 165
 166         /*
 167          * Now for a partially written prealloc extent, basically the same as
 168          * the hole punch example above.  Ram_bytes never changes when you mark
 169          * extents written btw.
 170          */
 171         insert_extent(root, offset, 4096, 16384, 0, disk_bytenr, 16384,
 172                       BTRFS_FILE_EXTENT_PREALLOC, 0, slot);
 173         slot++;
 174         offset += 4096;
 175         insert_extent(root, offset, 4096, 16384, 4096, disk_bytenr, 16384,
 176                       BTRFS_FILE_EXTENT_REG, 0, slot);
 177         slot++;
 178         offset += 4096;
 179         insert_extent(root, offset, 8192, 16384, 8192, disk_bytenr, 16384,
 180                       BTRFS_FILE_EXTENT_PREALLOC, 0, slot);
 181         slot++;
 182         offset += 8192;
 183         disk_bytenr += 16384;
 184
 185         /* Now a normal compressed extent */
 186         insert_extent(root, offset, 8192, 8192, 0, disk_bytenr, 4096,
 187                       BTRFS_FILE_EXTENT_REG, BTRFS_COMPRESS_ZLIB, slot);
 188         slot++;
 189         offset += 8192;
 190         /* No merges */
 191         disk_bytenr += 8192;
 192
 193         /* Now a split compressed extent */
 194         insert_extent(root, offset, 4096, 16384, 0, disk_bytenr, 4096,
 195                       BTRFS_FILE_EXTENT_REG, BTRFS_COMPRESS_ZLIB, slot);
 196         slot++;
 197         offset += 4096;
 198         insert_extent(root, offset, 4096, 4096, 0, disk_bytenr + 4096, 4096,
 199                       BTRFS_FILE_EXTENT_REG, 0, slot);
 200         slot++;
 201         offset += 4096;
 202         insert_extent(root, offset, 8192, 16384, 8192, disk_bytenr, 4096,
 203                       BTRFS_FILE_EXTENT_REG, BTRFS_COMPRESS_ZLIB, slot);
 204         slot++;
 205         offset += 8192;
 206         disk_bytenr += 8192;
 207
 208         /* Now extents that have a hole but no hole extent */
 209         insert_extent(root, offset, 4096, 4096, 0, disk_bytenr, 4096,
 210                       BTRFS_FILE_EXTENT_REG, 0, slot);
 211         slot++;
 212         offset += 16384;
 213         disk_bytenr += 4096;
 214         insert_extent(root, offset, 4096, 4096, 0, disk_bytenr, 4096,
 215                       BTRFS_FILE_EXTENT_REG, 0, slot);
 216 }
 217
 218 static unsigned long prealloc_only = 0;
 219 static unsigned long compressed_only = 0;
 220 static unsigned long vacancy_only = 0;
 221
 222 static noinline int test_btrfs_get_extent(void)
 223 {
 224         struct inode *inode = NULL;
 225         struct btrfs_root *root = NULL;
 226         struct extent_map *em = NULL;
 227         u64 orig_start;
 228         u64 disk_bytenr;
 229         u64 offset;
 230         int ret = -ENOMEM;
 231
 232         inode = btrfs_new_test_inode();
 233         if (!inode) {
 234                 test_msg("Couldn't allocate inode\n");
 235                 return ret;
 236         }
 237
 238         BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
 239         BTRFS_I(inode)->location.objectid = BTRFS_FIRST_FREE_OBJECTID;
 240         BTRFS_I(inode)->location.offset = 0;
 241
 242         root = btrfs_alloc_dummy_root();
 243         if (IS_ERR(root)) {
 244                 test_msg("Couldn't allocate root\n");
 245                 goto out;
 246         }
 247
 248         /*
 249          * We do this since btrfs_get_extent wants to assign em->bdev to
 250          * root->fs_info->fs_devices->latest_bdev.
 251          */
 252         root->fs_info = btrfs_alloc_dummy_fs_info();
 253         if (!root->fs_info) {
 254                 test_msg("Couldn't allocate dummy fs info\n");
 255                 goto out;
 256         }
 257
 258         root->node = alloc_dummy_extent_buffer(NULL, 4096);
 259         if (!root->node) {
 260                 test_msg("Couldn't allocate dummy buffer\n");
 261                 goto out;
 262         }
 263
 264         /*
 265          * We will just free a dummy node if it's ref count is 2 so we need an
 266          * extra ref so our searches don't accidently release our page.
 267          */
 268         extent_buffer_get(root->node);
 269         btrfs_set_header_nritems(root->node, 0);
 270         btrfs_set_header_level(root->node, 0);
 271         ret = -EINVAL;
 272
 273         /* First with no extents */
 274         BTRFS_I(inode)->root = root;
 275         em = btrfs_get_extent(inode, NULL, 0, 0, 4096, 0);
 276         if (IS_ERR(em)) {
 277                 em = NULL;
 278                 test_msg("Got an error when we shouldn't have\n");
 279                 goto out;
 280         }
 281         if (em->block_start != EXTENT_MAP_HOLE) {
 282                 test_msg("Expected a hole, got %llu\n", em->block_start);
 283                 goto out;
 284         }
 285         if (!test_bit(EXTENT_FLAG_VACANCY, &em->flags)) {
 286                 test_msg("Vacancy flag wasn't set properly\n");
 287                 goto out;
 288         }
 289         free_extent_map(em);
 290         btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
 291
 292         /*
 293          * All of the magic numbers are based on the mapping setup in
 294          * setup_file_extents, so if you change anything there you need to
 295          * update the comment and update the expected values below.
 296          */
 297         setup_file_extents(root);
 298
 299         em = btrfs_get_extent(inode, NULL, 0, 0, (u64)-1, 0);
 300         if (IS_ERR(em)) {
 301                 test_msg("Got an error when we shouldn't have\n");
 302                 goto out;
 303         }
 304         if (em->block_start != EXTENT_MAP_HOLE) {
 305                 test_msg("Expected a hole, got %llu\n", em->block_start);
 306                 goto out;
 307         }
 308         if (em->start != 0 || em->len != 5) {
 309                 test_msg("Unexpected extent wanted start 0 len 5, got start "
 310                          "%llu len %llu\n", em->start, em->len);
 311                 goto out;
 312         }
 313         if (em->flags != 0) {
 314                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 315                 goto out;
 316         }
 317         offset = em->start + em->len;
 318         free_extent_map(em);
 319
 320         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 321         if (IS_ERR(em)) {
 322                 test_msg("Got an error when we shouldn't have\n");
 323                 goto out;
 324         }
 325         if (em->block_start != EXTENT_MAP_INLINE) {
 326                 test_msg("Expected an inline, got %llu\n", em->block_start);
 327                 goto out;
 328         }
 329         if (em->start != offset || em->len != 4091) {
 330                 test_msg("Unexpected extent wanted start %llu len 1, got start "
 331                          "%llu len %llu\n", offset, em->start, em->len);
 332                 goto out;
 333         }
 334         if (em->flags != 0) {
 335                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 336                 goto out;
 337         }
 338         /*
 339          * We don't test anything else for inline since it doesn't get set
 340          * unless we have a page for it to write into.  Maybe we should change
 341          * this?
 342          */
 343         offset = em->start + em->len;
 344         free_extent_map(em);
 345
 346         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 347         if (IS_ERR(em)) {
 348                 test_msg("Got an error when we shouldn't have\n");
 349                 goto out;
 350         }
 351         if (em->block_start != EXTENT_MAP_HOLE) {
 352                 test_msg("Expected a hole, got %llu\n", em->block_start);
 353                 goto out;
 354         }
 355         if (em->start != offset || em->len != 4) {
 356                 test_msg("Unexpected extent wanted start %llu len 4, got start "
 357                          "%llu len %llu\n", offset, em->start, em->len);
 358                 goto out;
 359         }
 360         if (em->flags != 0) {
 361                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 362                 goto out;
 363         }
 364         offset = em->start + em->len;
 365         free_extent_map(em);
 366
 367         /* Regular extent */
 368         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 369         if (IS_ERR(em)) {
 370                 test_msg("Got an error when we shouldn't have\n");
 371                 goto out;
 372         }
 373         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 374                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 375                 goto out;
 376         }
 377         if (em->start != offset || em->len != 4095) {
 378                 test_msg("Unexpected extent wanted start %llu len 4095, got "
 379                          "start %llu len %llu\n", offset, em->start, em->len);
 380                 goto out;
 381         }
 382         if (em->flags != 0) {
 383                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 384                 goto out;
 385         }
 386         if (em->orig_start != em->start) {
 387                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 388                          em->orig_start);
 389                 goto out;
 390         }
 391         offset = em->start + em->len;
 392         free_extent_map(em);
 393
 394         /* The next 3 are split extents */
 395         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 396         if (IS_ERR(em)) {
 397                 test_msg("Got an error when we shouldn't have\n");
 398                 goto out;
 399         }
 400         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 401                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 402                 goto out;
 403         }
 404         if (em->start != offset || em->len != 4096) {
 405                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 406                          "start %llu len %llu\n", offset, em->start, em->len);
 407                 goto out;
 408         }
 409         if (em->flags != 0) {
 410                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 411                 goto out;
 412         }
 413         if (em->orig_start != em->start) {
 414                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 415                          em->orig_start);
 416                 goto out;
 417         }
 418         disk_bytenr = em->block_start;
 419         orig_start = em->start;
 420         offset = em->start + em->len;
 421         free_extent_map(em);
 422
 423         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 424         if (IS_ERR(em)) {
 425                 test_msg("Got an error when we shouldn't have\n");
 426                 goto out;
 427         }
 428         if (em->block_start != EXTENT_MAP_HOLE) {
 429                 test_msg("Expected a hole, got %llu\n", em->block_start);
 430                 goto out;
 431         }
 432         if (em->start != offset || em->len != 4096) {
 433                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 434                          "start %llu len %llu\n", offset, em->start, em->len);
 435                 goto out;
 436         }
 437         if (em->flags != 0) {
 438                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 439                 goto out;
 440         }
 441         offset = em->start + em->len;
 442         free_extent_map(em);
 443
 444         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 445         if (IS_ERR(em)) {
 446                 test_msg("Got an error when we shouldn't have\n");
 447                 goto out;
 448         }
 449         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 450                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 451                 goto out;
 452         }
 453         if (em->start != offset || em->len != 8192) {
 454                 test_msg("Unexpected extent wanted start %llu len 8192, got "
 455                          "start %llu len %llu\n", offset, em->start, em->len);
 456                 goto out;
 457         }
 458         if (em->flags != 0) {
 459                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 460                 goto out;
 461         }
 462         if (em->orig_start != orig_start) {
 463                 test_msg("Wrong orig offset, want %llu, have %llu\n",
 464                          orig_start, em->orig_start);
 465                 goto out;
 466         }
 467         disk_bytenr += (em->start - orig_start);
 468         if (em->block_start != disk_bytenr) {
 469                 test_msg("Wrong block start, want %llu, have %llu\n",
 470                          disk_bytenr, em->block_start);
 471                 goto out;
 472         }
 473         offset = em->start + em->len;
 474         free_extent_map(em);
 475
 476         /* Prealloc extent */
 477         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 478         if (IS_ERR(em)) {
 479                 test_msg("Got an error when we shouldn't have\n");
 480                 goto out;
 481         }
 482         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 483                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 484                 goto out;
 485         }
 486         if (em->start != offset || em->len != 4096) {
 487                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 488                          "start %llu len %llu\n", offset, em->start, em->len);
 489                 goto out;
 490         }
 491         if (em->flags != prealloc_only) {
 492                 test_msg("Unexpected flags set, want %lu have %lu\n",
 493                          prealloc_only, em->flags);
 494                 goto out;
 495         }
 496         if (em->orig_start != em->start) {
 497                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 498                          em->orig_start);
 499                 goto out;
 500         }
 501         offset = em->start + em->len;
 502         free_extent_map(em);
 503
 504         /* The next 3 are a half written prealloc extent */
 505         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 506         if (IS_ERR(em)) {
 507                 test_msg("Got an error when we shouldn't have\n");
 508                 goto out;
 509         }
 510         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 511                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 512                 goto out;
 513         }
 514         if (em->start != offset || em->len != 4096) {
 515                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 516                          "start %llu len %llu\n", offset, em->start, em->len);
 517                 goto out;
 518         }
 519         if (em->flags != prealloc_only) {
 520                 test_msg("Unexpected flags set, want %lu have %lu\n",
 521                          prealloc_only, em->flags);
 522                 goto out;
 523         }
 524         if (em->orig_start != em->start) {
 525                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 526                          em->orig_start);
 527                 goto out;
 528         }
 529         disk_bytenr = em->block_start;
 530         orig_start = em->start;
 531         offset = em->start + em->len;
 532         free_extent_map(em);
 533
 534         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 535         if (IS_ERR(em)) {
 536                 test_msg("Got an error when we shouldn't have\n");
 537                 goto out;
 538         }
 539         if (em->block_start >= EXTENT_MAP_HOLE) {
 540                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 541                 goto out;
 542         }
 543         if (em->start != offset || em->len != 4096) {
 544                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 545                          "start %llu len %llu\n", offset, em->start, em->len);
 546                 goto out;
 547         }
 548         if (em->flags != 0) {
 549                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 550                 goto out;
 551         }
 552         if (em->orig_start != orig_start) {
 553                 test_msg("Unexpected orig offset, wanted %llu, have %llu\n",
 554                          orig_start, em->orig_start);
 555                 goto out;
 556         }
 557         if (em->block_start != (disk_bytenr + (em->start - em->orig_start))) {
 558                 test_msg("Unexpected block start, wanted %llu, have %llu\n",
 559                          disk_bytenr + (em->start - em->orig_start),
 560                          em->block_start);
 561                 goto out;
 562         }
 563         offset = em->start + em->len;
 564         free_extent_map(em);
 565
 566         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 567         if (IS_ERR(em)) {
 568                 test_msg("Got an error when we shouldn't have\n");
 569                 goto out;
 570         }
 571         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 572                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 573                 goto out;
 574         }
 575         if (em->start != offset || em->len != 8192) {
 576                 test_msg("Unexpected extent wanted start %llu len 8192, got "
 577                          "start %llu len %llu\n", offset, em->start, em->len);
 578                 goto out;
 579         }
 580         if (em->flags != prealloc_only) {
 581                 test_msg("Unexpected flags set, want %lu have %lu\n",
 582                          prealloc_only, em->flags);
 583                 goto out;
 584         }
 585         if (em->orig_start != orig_start) {
 586                 test_msg("Wrong orig offset, want %llu, have %llu\n", orig_start,
 587                          em->orig_start);
 588                 goto out;
 589         }
 590         if (em->block_start != (disk_bytenr + (em->start - em->orig_start))) {
 591                 test_msg("Unexpected block start, wanted %llu, have %llu\n",
 592                          disk_bytenr + (em->start - em->orig_start),
 593                          em->block_start);
 594                 goto out;
 595         }
 596         offset = em->start + em->len;
 597         free_extent_map(em);
 598
 599         /* Now for the compressed extent */
 600         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 601         if (IS_ERR(em)) {
 602                 test_msg("Got an error when we shouldn't have\n");
 603                 goto out;
 604         }
 605         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 606                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 607                 goto out;
 608         }
 609         if (em->start != offset || em->len != 8192) {
 610                 test_msg("Unexpected extent wanted start %llu len 8192, got "
 611                          "start %llu len %llu\n", offset, em->start, em->len);
 612                 goto out;
 613         }
 614         if (em->flags != compressed_only) {
 615                 test_msg("Unexpected flags set, want %lu have %lu\n",
 616                          compressed_only, em->flags);
 617                 goto out;
 618         }
 619         if (em->orig_start != em->start) {
 620                 test_msg("Wrong orig offset, want %llu, have %llu\n",
 621                          em->start, em->orig_start);
 622                 goto out;
 623         }
 624         if (em->compress_type != BTRFS_COMPRESS_ZLIB) {
 625                 test_msg("Unexpected compress type, wanted %d, got %d\n",
 626                          BTRFS_COMPRESS_ZLIB, em->compress_type);
 627                 goto out;
 628         }
 629         offset = em->start + em->len;
 630         free_extent_map(em);
 631
 632         /* Split compressed extent */
 633         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 634         if (IS_ERR(em)) {
 635                 test_msg("Got an error when we shouldn't have\n");
 636                 goto out;
 637         }
 638         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 639                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 640                 goto out;
 641         }
 642         if (em->start != offset || em->len != 4096) {
 643                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 644                          "start %llu len %llu\n", offset, em->start, em->len);
 645                 goto out;
 646         }
 647         if (em->flags != compressed_only) {
 648                 test_msg("Unexpected flags set, want %lu have %lu\n",
 649                          compressed_only, em->flags);
 650                 goto out;
 651         }
 652         if (em->orig_start != em->start) {
 653                 test_msg("Wrong orig offset, want %llu, have %llu\n",
 654                          em->start, em->orig_start);
 655                 goto out;
 656         }
 657         if (em->compress_type != BTRFS_COMPRESS_ZLIB) {
 658                 test_msg("Unexpected compress type, wanted %d, got %d\n",
 659                          BTRFS_COMPRESS_ZLIB, em->compress_type);
 660                 goto out;
 661         }
 662         disk_bytenr = em->block_start;
 663         orig_start = em->start;
 664         offset = em->start + em->len;
 665         free_extent_map(em);
 666
 667         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 668         if (IS_ERR(em)) {
 669                 test_msg("Got an error when we shouldn't have\n");
 670                 goto out;
 671         }
 672         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 673                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 674                 goto out;
 675         }
 676         if (em->start != offset || em->len != 4096) {
 677                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 678                          "start %llu len %llu\n", offset, em->start, em->len);
 679                 goto out;
 680         }
 681         if (em->flags != 0) {
 682                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 683                 goto out;
 684         }
 685         if (em->orig_start != em->start) {
 686                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 687                          em->orig_start);
 688                 goto out;
 689         }
 690         offset = em->start + em->len;
 691         free_extent_map(em);
 692
 693         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 694         if (IS_ERR(em)) {
 695                 test_msg("Got an error when we shouldn't have\n");
 696                 goto out;
 697         }
 698         if (em->block_start != disk_bytenr) {
 699                 test_msg("Block start does not match, want %llu got %llu\n",
 700                          disk_bytenr, em->block_start);
 701                 goto out;
 702         }
 703         if (em->start != offset || em->len != 8192) {
 704                 test_msg("Unexpected extent wanted start %llu len 8192, got "
 705                          "start %llu len %llu\n", offset, em->start, em->len);
 706                 goto out;
 707         }
 708         if (em->flags != compressed_only) {
 709                 test_msg("Unexpected flags set, want %lu have %lu\n",
 710                          compressed_only, em->flags);
 711                 goto out;
 712         }
 713         if (em->orig_start != orig_start) {
 714                 test_msg("Wrong orig offset, want %llu, have %llu\n",
 715                          em->start, orig_start);
 716                 goto out;
 717         }
 718         if (em->compress_type != BTRFS_COMPRESS_ZLIB) {
 719                 test_msg("Unexpected compress type, wanted %d, got %d\n",
 720                          BTRFS_COMPRESS_ZLIB, em->compress_type);
 721                 goto out;
 722         }
 723         offset = em->start + em->len;
 724         free_extent_map(em);
 725
 726         /* A hole between regular extents but no hole extent */
 727         em = btrfs_get_extent(inode, NULL, 0, offset + 6, 4096, 0);
 728         if (IS_ERR(em)) {
 729                 test_msg("Got an error when we shouldn't have\n");
 730                 goto out;
 731         }
 732         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 733                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 734                 goto out;
 735         }
 736         if (em->start != offset || em->len != 4096) {
 737                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 738                          "start %llu len %llu\n", offset, em->start, em->len);
 739                 goto out;
 740         }
 741         if (em->flags != 0) {
 742                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 743                 goto out;
 744         }
 745         if (em->orig_start != em->start) {
 746                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 747                          em->orig_start);
 748                 goto out;
 749         }
 750         offset = em->start + em->len;
 751         free_extent_map(em);
 752
 753         em = btrfs_get_extent(inode, NULL, 0, offset, 4096 * 1024, 0);
 754         if (IS_ERR(em)) {
 755                 test_msg("Got an error when we shouldn't have\n");
 756                 goto out;
 757         }
 758         if (em->block_start != EXTENT_MAP_HOLE) {
 759                 test_msg("Expected a hole extent, got %llu\n", em->block_start);
 760                 goto out;
 761         }
 762         /*
 763          * Currently we just return a length that we requested rather than the
 764          * length of the actual hole, if this changes we'll have to change this
 765          * test.
 766          */
 767         if (em->start != offset || em->len != 12288) {
 768                 test_msg("Unexpected extent wanted start %llu len 12288, got "
 769                          "start %llu len %llu\n", offset, em->start, em->len);
 770                 goto out;
 771         }
 772         if (em->flags != vacancy_only) {
 773                 test_msg("Unexpected flags set, want %lu have %lu\n",
 774                          vacancy_only, em->flags);
 775                 goto out;
 776         }
 777         if (em->orig_start != em->start) {
 778                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 779                          em->orig_start);
 780                 goto out;
 781         }
 782         offset = em->start + em->len;
 783         free_extent_map(em);
 784
 785         em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
 786         if (IS_ERR(em)) {
 787                 test_msg("Got an error when we shouldn't have\n");
 788                 goto out;
 789         }
 790         if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 791                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 792                 goto out;
 793         }
 794         if (em->start != offset || em->len != 4096) {
 795                 test_msg("Unexpected extent wanted start %llu len 4096, got "
 796                          "start %llu len %llu\n", offset, em->start, em->len);
 797                 goto out;
 798         }
 799         if (em->flags != 0) {
 800                 test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
 801                 goto out;
 802         }
 803         if (em->orig_start != em->start) {
 804                 test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
 805                          em->orig_start);
 806                 goto out;
 807         }
 808         ret = 0;
 809 out:
 810         if (!IS_ERR(em))
 811                 free_extent_map(em);
 812         iput(inode);
 813         btrfs_free_dummy_root(root);
 814         return ret;
 815 }
 816
 817 static int test_hole_first(void)
 818 {
 819         struct inode *inode = NULL;
 820         struct btrfs_root *root = NULL;
 821         struct extent_map *em = NULL;
 822         int ret = -ENOMEM;
 823
 824         inode = btrfs_new_test_inode();
 825         if (!inode) {
 826                 test_msg("Couldn't allocate inode\n");
 827                 return ret;
 828         }
 829
 830         BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
 831         BTRFS_I(inode)->location.objectid = BTRFS_FIRST_FREE_OBJECTID;
 832         BTRFS_I(inode)->location.offset = 0;
 833
 834         root = btrfs_alloc_dummy_root();
 835         if (IS_ERR(root)) {
 836                 test_msg("Couldn't allocate root\n");
 837                 goto out;
 838         }
 839
 840         root->fs_info = btrfs_alloc_dummy_fs_info();
 841         if (!root->fs_info) {
 842                 test_msg("Couldn't allocate dummy fs info\n");
 843                 goto out;
 844         }
 845
 846         root->node = alloc_dummy_extent_buffer(NULL, 4096);
 847         if (!root->node) {
 848                 test_msg("Couldn't allocate dummy buffer\n");
 849                 goto out;
 850         }
 851
 852         extent_buffer_get(root->node);
 853         btrfs_set_header_nritems(root->node, 0);
 854         btrfs_set_header_level(root->node, 0);
 855         BTRFS_I(inode)->root = root;
 856         ret = -EINVAL;
 857
 858         /*
 859          * Need a blank inode item here just so we don't confuse
 860          * btrfs_get_extent.
 861          */
 862         insert_inode_item_key(root);
 863         insert_extent(root, 4096, 4096, 4096, 0, 4096, 4096,
 864                       BTRFS_FILE_EXTENT_REG, 0, 1);
 865         em = btrfs_get_extent(inode, NULL, 0, 0, 8192, 0);
 866         if (IS_ERR(em)) {
 867                 test_msg("Got an error when we shouldn't have\n");
 868                 goto out;
 869         }
 870         if (em->block_start != EXTENT_MAP_HOLE) {
 871                 test_msg("Expected a hole, got %llu\n", em->block_start);
 872                 goto out;
 873         }
 874         if (em->start != 0 || em->len != 4096) {
 875                 test_msg("Unexpected extent wanted start 0 len 4096, got start "
 876                          "%llu len %llu\n", em->start, em->len);
 877                 goto out;
 878         }
 879         if (em->flags != vacancy_only) {
 880                 test_msg("Wrong flags, wanted %lu, have %lu\n", vacancy_only,
 881                          em->flags);
 882                 goto out;
 883         }
 884         free_extent_map(em);
 885
 886         em = btrfs_get_extent(inode, NULL, 0, 4096, 8192, 0);
 887         if (IS_ERR(em)) {
 888                 test_msg("Got an error when we shouldn't have\n");
 889                 goto out;
 890         }
 891         if (em->block_start != 4096) {
 892                 test_msg("Expected a real extent, got %llu\n", em->block_start);
 893                 goto out;
 894         }
 895         if (em->start != 4096 || em->len != 4096) {
 896                 test_msg("Unexpected extent wanted start 4096 len 4096, got "
 897                          "start %llu len %llu\n", em->start, em->len);
 898                 goto out;
 899         }
 900         if (em->flags != 0) {
 901                 test_msg("Unexpected flags set, wanted 0 got %lu\n",
 902                          em->flags);
 903                 goto out;
 904         }
 905         ret = 0;
 906 out:
 907         if (!IS_ERR(em))
 908                 free_extent_map(em);
 909         iput(inode);
 910         btrfs_free_dummy_root(root);
 911         return ret;
 912 }
 913
 914 static int test_extent_accounting(void)
 915 {
 916         struct inode *inode = NULL;
 917         struct btrfs_root *root = NULL;
 918         int ret = -ENOMEM;
 919
 920         inode = btrfs_new_test_inode();
 921         if (!inode) {
 922                 test_msg("Couldn't allocate inode\n");
 923                 return ret;
 924         }
 925
 926         root = btrfs_alloc_dummy_root();
 927         if (IS_ERR(root)) {
 928                 test_msg("Couldn't allocate root\n");
 929                 goto out;
 930         }
 931
 932         root->fs_info = btrfs_alloc_dummy_fs_info();
 933         if (!root->fs_info) {
 934                 test_msg("Couldn't allocate dummy fs info\n");
 935                 goto out;
 936         }
 937
 938         BTRFS_I(inode)->root = root;
 939         btrfs_test_inode_set_ops(inode);
 940
 941         /* [BTRFS_MAX_EXTENT_SIZE] */
 942         BTRFS_I(inode)->outstanding_extents++;
 943         ret = btrfs_set_extent_delalloc(inode, 0, BTRFS_MAX_EXTENT_SIZE - 1,
 944                                         NULL);
 945         if (ret) {
 946                 test_msg("btrfs_set_extent_delalloc returned %d\n", ret);
 947                 goto out;
 948         }
 949         if (BTRFS_I(inode)->outstanding_extents != 1) {
 950                 ret = -EINVAL;
 951                 test_msg("Miscount, wanted 1, got %u\n",
 952                          BTRFS_I(inode)->outstanding_extents);
 953                 goto out;
 954         }
 955
 956         /* [BTRFS_MAX_EXTENT_SIZE][4k] */
 957         BTRFS_I(inode)->outstanding_extents++;
 958         ret = btrfs_set_extent_delalloc(inode, BTRFS_MAX_EXTENT_SIZE,
 959                                         BTRFS_MAX_EXTENT_SIZE + 4095, NULL);
 960         if (ret) {
 961                 test_msg("btrfs_set_extent_delalloc returned %d\n", ret);
 962                 goto out;
 963         }
 964         if (BTRFS_I(inode)->outstanding_extents != 2) {
 965                 ret = -EINVAL;
 966                 test_msg("Miscount, wanted 2, got %u\n",
 967                          BTRFS_I(inode)->outstanding_extents);
 968                 goto out;
 969         }
 970
 971         /* [BTRFS_MAX_EXTENT_SIZE/2][4K HOLE][the rest] */
 972         ret = clear_extent_bit(&BTRFS_I(inode)->io_tree,
 973                                BTRFS_MAX_EXTENT_SIZE >> 1,
 974                                (BTRFS_MAX_EXTENT_SIZE >> 1) + 4095,
 975                                EXTENT_DELALLOC | EXTENT_DIRTY |
 976                                EXTENT_UPTODATE | EXTENT_DO_ACCOUNTING, 0, 0,
 977                                NULL, GFP_NOFS);
 978         if (ret) {
 979                 test_msg("clear_extent_bit returned %d\n", ret);
 980                 goto out;
 981         }
 982         if (BTRFS_I(inode)->outstanding_extents != 2) {
 983                 ret = -EINVAL;
 984                 test_msg("Miscount, wanted 2, got %u\n",
 985                          BTRFS_I(inode)->outstanding_extents);
 986                 goto out;
 987         }
 988
 989         /* [BTRFS_MAX_EXTENT_SIZE][4K] */
 990         BTRFS_I(inode)->outstanding_extents++;
 991         ret = btrfs_set_extent_delalloc(inode, BTRFS_MAX_EXTENT_SIZE >> 1,
 992                                         (BTRFS_MAX_EXTENT_SIZE >> 1) + 4095,
 993                                         NULL);
 994         if (ret) {
 995                 test_msg("btrfs_set_extent_delalloc returned %d\n", ret);
 996                 goto out;
 997         }
 998         if (BTRFS_I(inode)->outstanding_extents != 2) {
 999                 ret = -EINVAL;
1000                 test_msg("Miscount, wanted 2, got %u\n",
1001                          BTRFS_I(inode)->outstanding_extents);
1002                 goto out;
1003         }
1004
1005         /*
1006          * [BTRFS_MAX_EXTENT_SIZE+4K][4K HOLE][BTRFS_MAX_EXTENT_SIZE+4K]
1007          *
1008          * I'm artificially adding 2 to outstanding_extents because in the
1009          * buffered IO case we'd add things up as we go, but I don't feel like
1010          * doing that here, this isn't the interesting case we want to test.
1011          */
1012         BTRFS_I(inode)->outstanding_extents += 2;
1013         ret = btrfs_set_extent_delalloc(inode, BTRFS_MAX_EXTENT_SIZE + 8192,
1014                                         (BTRFS_MAX_EXTENT_SIZE << 1) + 12287,
1015                                         NULL);
1016         if (ret) {
1017                 test_msg("btrfs_set_extent_delalloc returned %d\n", ret);
1018                 goto out;
1019         }
1020         if (BTRFS_I(inode)->outstanding_extents != 4) {
1021                 ret = -EINVAL;
1022                 test_msg("Miscount, wanted 4, got %u\n",
1023                          BTRFS_I(inode)->outstanding_extents);
1024                 goto out;
1025         }
1026
1027         /* [BTRFS_MAX_EXTENT_SIZE+4k][4k][BTRFS_MAX_EXTENT_SIZE+4k] */
1028         BTRFS_I(inode)->outstanding_extents++;
1029         ret = btrfs_set_extent_delalloc(inode, BTRFS_MAX_EXTENT_SIZE+4096,
1030                                         BTRFS_MAX_EXTENT_SIZE+8191, NULL);
1031         if (ret) {
1032                 test_msg("btrfs_set_extent_delalloc returned %d\n", ret);
1033                 goto out;
1034         }
1035         if (BTRFS_I(inode)->outstanding_extents != 3) {
1036                 ret = -EINVAL;
1037                 test_msg("Miscount, wanted 3, got %u\n",
1038                          BTRFS_I(inode)->outstanding_extents);
1039                 goto out;
1040         }
1041
1042         /* [BTRFS_MAX_EXTENT_SIZE+4k][4K HOLE][BTRFS_MAX_EXTENT_SIZE+4k] */
1043         ret = clear_extent_bit(&BTRFS_I(inode)->io_tree,
1044                                BTRFS_MAX_EXTENT_SIZE+4096,
1045                                BTRFS_MAX_EXTENT_SIZE+8191,
1046                                EXTENT_DIRTY | EXTENT_DELALLOC |
1047                                EXTENT_DO_ACCOUNTING | EXTENT_UPTODATE, 0, 0,
1048                                NULL, GFP_NOFS);
1049         if (ret) {
1050                 test_msg("clear_extent_bit returned %d\n", ret);
1051                 goto out;
1052         }
1053         if (BTRFS_I(inode)->outstanding_extents != 4) {
1054                 ret = -EINVAL;
1055                 test_msg("Miscount, wanted 4, got %u\n",
1056                          BTRFS_I(inode)->outstanding_extents);
1057                 goto out;
1058         }
1059
1060         /*
1061          * Refill the hole again just for good measure, because I thought it
1062          * might fail and I'd rather satisfy my paranoia at this point.
1063          */
1064         BTRFS_I(inode)->outstanding_extents++;
1065         ret = btrfs_set_extent_delalloc(inode, BTRFS_MAX_EXTENT_SIZE+4096,
1066                                         BTRFS_MAX_EXTENT_SIZE+8191, NULL);
1067         if (ret) {
1068                 test_msg("btrfs_set_extent_delalloc returned %d\n", ret);
1069                 goto out;
1070         }
1071         if (BTRFS_I(inode)->outstanding_extents != 3) {
1072                 ret = -EINVAL;
1073                 test_msg("Miscount, wanted 3, got %u\n",
1074                          BTRFS_I(inode)->outstanding_extents);
1075                 goto out;
1076         }
1077
1078         /* Empty */
1079         ret = clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, (u64)-1,
1080                                EXTENT_DIRTY | EXTENT_DELALLOC |
1081                                EXTENT_DO_ACCOUNTING | EXTENT_UPTODATE, 0, 0,
1082                                NULL, GFP_NOFS);
1083         if (ret) {
1084                 test_msg("clear_extent_bit returned %d\n", ret);
1085                 goto out;
1086         }
1087         if (BTRFS_I(inode)->outstanding_extents) {
1088                 ret = -EINVAL;
1089                 test_msg("Miscount, wanted 0, got %u\n",
1090                          BTRFS_I(inode)->outstanding_extents);
1091                 goto out;
1092         }
1093         ret = 0;
1094 out:
1095         if (ret)
1096                 clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, (u64)-1,
1097                                  EXTENT_DIRTY | EXTENT_DELALLOC |
1098                                  EXTENT_DO_ACCOUNTING | EXTENT_UPTODATE, 0, 0,
1099                                  NULL, GFP_NOFS);
1100         iput(inode);
1101         btrfs_free_dummy_root(root);
1102         return ret;
1103 }
1104
1105 int btrfs_test_inodes(void)
1106 {
1107         int ret;
1108
1109         set_bit(EXTENT_FLAG_COMPRESSED, &compressed_only);
1110         set_bit(EXTENT_FLAG_VACANCY, &vacancy_only);
1111         set_bit(EXTENT_FLAG_PREALLOC, &prealloc_only);
1112
1113         test_msg("Running btrfs_get_extent tests\n");
1114         ret = test_btrfs_get_extent();
1115         if (ret)
1116                 return ret;
1117         test_msg("Running hole first btrfs_get_extent test\n");
1118         ret = test_hole_first();
1119         if (ret)
1120                 return ret;
1121         test_msg("Running outstanding_extents tests\n");
1122         return test_extent_accounting();
1123 }