fs/btrfs/tests/extent-io-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 <linux/pagemap.h>
  20 #include <linux/sched.h>
  21 #include <linux/slab.h>
  22 #include <linux/sizes.h>
  23 #include "btrfs-tests.h"
  24 #include "../extent_io.h"
  25
  26 #define PROCESS_UNLOCK          (1 << 0)
  27 #define PROCESS_RELEASE         (1 << 1)
  28 #define PROCESS_TEST_LOCKED     (1 << 2)
  29
  30 static noinline int process_page_range(struct inode *inode, u64 start, u64 end,
  31                                        unsigned long flags)
  32 {
  33         int ret;
  34         struct page *pages[16];
  35         unsigned long index = start >> PAGE_CACHE_SHIFT;
  36         unsigned long end_index = end >> PAGE_CACHE_SHIFT;
  37         unsigned long nr_pages = end_index - index + 1;
  38         int i;
  39         int count = 0;
  40         int loops = 0;
  41
  42         while (nr_pages > 0) {
  43                 ret = find_get_pages_contig(inode->i_mapping, index,
  44                                      min_t(unsigned long, nr_pages,
  45                                      ARRAY_SIZE(pages)), pages);
  46                 for (i = 0; i < ret; i++) {
  47                         if (flags & PROCESS_TEST_LOCKED &&
  48                             !PageLocked(pages[i]))
  49                                 count++;
  50                         if (flags & PROCESS_UNLOCK && PageLocked(pages[i]))
  51                                 unlock_page(pages[i]);
  52                         page_cache_release(pages[i]);
  53                         if (flags & PROCESS_RELEASE)
  54                                 page_cache_release(pages[i]);
  55                 }
  56                 nr_pages -= ret;
  57                 index += ret;
  58                 cond_resched();
  59                 loops++;
  60                 if (loops > 100000) {
  61                         printk(KERN_ERR "stuck in a loop, start %Lu, end %Lu, nr_pages %lu, ret %d\n", start, end, nr_pages, ret);
  62                         break;
  63                 }
  64         }
  65         return count;
  66 }
  67
  68 static int test_find_delalloc(void)
  69 {
  70         struct inode *inode;
  71         struct extent_io_tree tmp;
  72         struct page *page;
  73         struct page *locked_page = NULL;
  74         unsigned long index = 0;
  75         u64 total_dirty = SZ_256M;
  76         u64 max_bytes = SZ_128M;
  77         u64 start, end, test_start;
  78         u64 found;
  79         int ret = -EINVAL;
  80
  81         test_msg("Running find delalloc tests\n");
  82
  83         inode = btrfs_new_test_inode();
  84         if (!inode) {
  85                 test_msg("Failed to allocate test inode\n");
  86                 return -ENOMEM;
  87         }
  88
  89         extent_io_tree_init(&tmp, &inode->i_data);
  90
  91         /*
  92          * First go through and create and mark all of our pages dirty, we pin
  93          * everything to make sure our pages don't get evicted and screw up our
  94          * test.
  95          */
  96         for (index = 0; index < (total_dirty >> PAGE_CACHE_SHIFT); index++) {
  97                 page = find_or_create_page(inode->i_mapping, index, GFP_KERNEL);
  98                 if (!page) {
  99                         test_msg("Failed to allocate test page\n");
 100                         ret = -ENOMEM;
 101                         goto out;
 102                 }
 103                 SetPageDirty(page);
 104                 if (index) {
 105                         unlock_page(page);
 106                 } else {
 107                         page_cache_get(page);
 108                         locked_page = page;
 109                 }
 110         }
 111
 112         /* Test this scenario
 113          * |--- delalloc ---|
 114          * |---  search  ---|
 115          */
 116         set_extent_delalloc(&tmp, 0, 4095, NULL, GFP_KERNEL);
 117         start = 0;
 118         end = 0;
 119         found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
 120                                          &end, max_bytes);
 121         if (!found) {
 122                 test_msg("Should have found at least one delalloc\n");
 123                 goto out_bits;
 124         }
 125         if (start != 0 || end != 4095) {
 126                 test_msg("Expected start 0 end 4095, got start %Lu end %Lu\n",
 127                          start, end);
 128                 goto out_bits;
 129         }
 130         unlock_extent(&tmp, start, end);
 131         unlock_page(locked_page);
 132         page_cache_release(locked_page);
 133
 134         /*
 135          * Test this scenario
 136          *
 137          * |--- delalloc ---|
 138          *           |--- search ---|
 139          */
 140         test_start = SZ_64M;
 141         locked_page = find_lock_page(inode->i_mapping,
 142                                      test_start >> PAGE_CACHE_SHIFT);
 143         if (!locked_page) {
 144                 test_msg("Couldn't find the locked page\n");
 145                 goto out_bits;
 146         }
 147         set_extent_delalloc(&tmp, 4096, max_bytes - 1, NULL, GFP_KERNEL);
 148         start = test_start;
 149         end = 0;
 150         found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
 151                                          &end, max_bytes);
 152         if (!found) {
 153                 test_msg("Couldn't find delalloc in our range\n");
 154                 goto out_bits;
 155         }
 156         if (start != test_start || end != max_bytes - 1) {
 157                 test_msg("Expected start %Lu end %Lu, got start %Lu, end "
 158                          "%Lu\n", test_start, max_bytes - 1, start, end);
 159                 goto out_bits;
 160         }
 161         if (process_page_range(inode, start, end,
 162                                PROCESS_TEST_LOCKED | PROCESS_UNLOCK)) {
 163                 test_msg("There were unlocked pages in the range\n");
 164                 goto out_bits;
 165         }
 166         unlock_extent(&tmp, start, end);
 167         /* locked_page was unlocked above */
 168         page_cache_release(locked_page);
 169
 170         /*
 171          * Test this scenario
 172          * |--- delalloc ---|
 173          *                    |--- search ---|
 174          */
 175         test_start = max_bytes + 4096;
 176         locked_page = find_lock_page(inode->i_mapping, test_start >>
 177                                      PAGE_CACHE_SHIFT);
 178         if (!locked_page) {
 179                 test_msg("Could'nt find the locked page\n");
 180                 goto out_bits;
 181         }
 182         start = test_start;
 183         end = 0;
 184         found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
 185                                          &end, max_bytes);
 186         if (found) {
 187                 test_msg("Found range when we shouldn't have\n");
 188                 goto out_bits;
 189         }
 190         if (end != (u64)-1) {
 191                 test_msg("Did not return the proper end offset\n");
 192                 goto out_bits;
 193         }
 194
 195         /*
 196          * Test this scenario
 197          * [------- delalloc -------|
 198          * [max_bytes]|-- search--|
 199          *
 200          * We are re-using our test_start from above since it works out well.
 201          */
 202         set_extent_delalloc(&tmp, max_bytes, total_dirty - 1, NULL, GFP_KERNEL);
 203         start = test_start;
 204         end = 0;
 205         found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
 206                                          &end, max_bytes);
 207         if (!found) {
 208                 test_msg("Didn't find our range\n");
 209                 goto out_bits;
 210         }
 211         if (start != test_start || end != total_dirty - 1) {
 212                 test_msg("Expected start %Lu end %Lu, got start %Lu end %Lu\n",
 213                          test_start, total_dirty - 1, start, end);
 214                 goto out_bits;
 215         }
 216         if (process_page_range(inode, start, end,
 217                                PROCESS_TEST_LOCKED | PROCESS_UNLOCK)) {
 218                 test_msg("Pages in range were not all locked\n");
 219                 goto out_bits;
 220         }
 221         unlock_extent(&tmp, start, end);
 222
 223         /*
 224          * Now to test where we run into a page that is no longer dirty in the
 225          * range we want to find.
 226          */
 227         page = find_get_page(inode->i_mapping,
 228                              (max_bytes + SZ_1M) >> PAGE_CACHE_SHIFT);
 229         if (!page) {
 230                 test_msg("Couldn't find our page\n");
 231                 goto out_bits;
 232         }
 233         ClearPageDirty(page);
 234         page_cache_release(page);
 235
 236         /* We unlocked it in the previous test */
 237         lock_page(locked_page);
 238         start = test_start;
 239         end = 0;
 240         /*
 241          * Currently if we fail to find dirty pages in the delalloc range we
 242          * will adjust max_bytes down to PAGE_CACHE_SIZE and then re-search.  If
 243          * this changes at any point in the future we will need to fix this
 244          * tests expected behavior.
 245          */
 246         found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
 247                                          &end, max_bytes);
 248         if (!found) {
 249                 test_msg("Didn't find our range\n");
 250                 goto out_bits;
 251         }
 252         if (start != test_start && end != test_start + PAGE_CACHE_SIZE - 1) {
 253                 test_msg("Expected start %Lu end %Lu, got start %Lu end %Lu\n",
 254                          test_start, test_start + PAGE_CACHE_SIZE - 1, start,
 255                          end);
 256                 goto out_bits;
 257         }
 258         if (process_page_range(inode, start, end, PROCESS_TEST_LOCKED |
 259                                PROCESS_UNLOCK)) {
 260                 test_msg("Pages in range were not all locked\n");
 261                 goto out_bits;
 262         }
 263         ret = 0;
 264 out_bits:
 265         clear_extent_bits(&tmp, 0, total_dirty - 1, (unsigned)-1, GFP_KERNEL);
 266 out:
 267         if (locked_page)
 268                 page_cache_release(locked_page);
 269         process_page_range(inode, 0, total_dirty - 1,
 270                            PROCESS_UNLOCK | PROCESS_RELEASE);
 271         iput(inode);
 272         return ret;
 273 }
 274
 275 static int __test_eb_bitmaps(unsigned long *bitmap, struct extent_buffer *eb,
 276                              unsigned long len)
 277 {
 278         unsigned long i, x;
 279
 280         memset(bitmap, 0, len);
 281         memset_extent_buffer(eb, 0, 0, len);
 282         if (memcmp_extent_buffer(eb, bitmap, 0, len) != 0) {
 283                 test_msg("Bitmap was not zeroed\n");
 284                 return -EINVAL;
 285         }
 286
 287         bitmap_set(bitmap, 0, len * BITS_PER_BYTE);
 288         extent_buffer_bitmap_set(eb, 0, 0, len * BITS_PER_BYTE);
 289         if (memcmp_extent_buffer(eb, bitmap, 0, len) != 0) {
 290                 test_msg("Setting all bits failed\n");
 291                 return -EINVAL;
 292         }
 293
 294         bitmap_clear(bitmap, 0, len * BITS_PER_BYTE);
 295         extent_buffer_bitmap_clear(eb, 0, 0, len * BITS_PER_BYTE);
 296         if (memcmp_extent_buffer(eb, bitmap, 0, len) != 0) {
 297                 test_msg("Clearing all bits failed\n");
 298                 return -EINVAL;
 299         }
 300
 301         bitmap_set(bitmap, (PAGE_CACHE_SIZE - sizeof(long) / 2) * BITS_PER_BYTE,
 302                    sizeof(long) * BITS_PER_BYTE);
 303         extent_buffer_bitmap_set(eb, PAGE_CACHE_SIZE - sizeof(long) / 2, 0,
 304                                  sizeof(long) * BITS_PER_BYTE);
 305         if (memcmp_extent_buffer(eb, bitmap, 0, len) != 0) {
 306                 test_msg("Setting straddling pages failed\n");
 307                 return -EINVAL;
 308         }
 309
 310         bitmap_set(bitmap, 0, len * BITS_PER_BYTE);
 311         bitmap_clear(bitmap,
 312                      (PAGE_CACHE_SIZE - sizeof(long) / 2) * BITS_PER_BYTE,
 313                      sizeof(long) * BITS_PER_BYTE);
 314         extent_buffer_bitmap_set(eb, 0, 0, len * BITS_PER_BYTE);
 315         extent_buffer_bitmap_clear(eb, PAGE_CACHE_SIZE - sizeof(long) / 2, 0,
 316                                    sizeof(long) * BITS_PER_BYTE);
 317         if (memcmp_extent_buffer(eb, bitmap, 0, len) != 0) {
 318                 test_msg("Clearing straddling pages failed\n");
 319                 return -EINVAL;
 320         }
 321
 322         /*
 323          * Generate a wonky pseudo-random bit pattern for the sake of not using
 324          * something repetitive that could miss some hypothetical off-by-n bug.
 325          */
 326         x = 0;
 327         for (i = 0; i < len / sizeof(long); i++) {
 328                 x = (0x19660dULL * (u64)x + 0x3c6ef35fULL) & 0xffffffffUL;
 329                 bitmap[i] = x;
 330         }
 331         write_extent_buffer(eb, bitmap, 0, len);
 332
 333         for (i = 0; i < len * BITS_PER_BYTE; i++) {
 334                 int bit, bit1;
 335
 336                 bit = !!test_bit(i, bitmap);
 337                 bit1 = !!extent_buffer_test_bit(eb, 0, i);
 338                 if (bit1 != bit) {
 339                         test_msg("Testing bit pattern failed\n");
 340                         return -EINVAL;
 341                 }
 342
 343                 bit1 = !!extent_buffer_test_bit(eb, i / BITS_PER_BYTE,
 344                                                 i % BITS_PER_BYTE);
 345                 if (bit1 != bit) {
 346                         test_msg("Testing bit pattern with offset failed\n");
 347                         return -EINVAL;
 348                 }
 349         }
 350
 351         return 0;
 352 }
 353
 354 static int test_eb_bitmaps(void)
 355 {
 356         unsigned long len = PAGE_CACHE_SIZE * 4;
 357         unsigned long *bitmap;
 358         struct extent_buffer *eb;
 359         int ret;
 360
 361         test_msg("Running extent buffer bitmap tests\n");
 362
 363         bitmap = kmalloc(len, GFP_KERNEL);
 364         if (!bitmap) {
 365                 test_msg("Couldn't allocate test bitmap\n");
 366                 return -ENOMEM;
 367         }
 368
 369         eb = __alloc_dummy_extent_buffer(NULL, 0, len);
 370         if (!eb) {
 371                 test_msg("Couldn't allocate test extent buffer\n");
 372                 kfree(bitmap);
 373                 return -ENOMEM;
 374         }
 375
 376         ret = __test_eb_bitmaps(bitmap, eb, len);
 377         if (ret)
 378                 goto out;
 379
 380         /* Do it over again with an extent buffer which isn't page-aligned. */
 381         free_extent_buffer(eb);
 382         eb = __alloc_dummy_extent_buffer(NULL, PAGE_CACHE_SIZE / 2, len);
 383         if (!eb) {
 384                 test_msg("Couldn't allocate test extent buffer\n");
 385                 kfree(bitmap);
 386                 return -ENOMEM;
 387         }
 388
 389         ret = __test_eb_bitmaps(bitmap, eb, len);
 390 out:
 391         free_extent_buffer(eb);
 392         kfree(bitmap);
 393         return ret;
 394 }
 395
 396 int btrfs_test_extent_io(void)
 397 {
 398         int ret;
 399
 400         test_msg("Running extent I/O tests\n");
 401
 402         ret = test_find_delalloc();
 403         if (ret)
 404                 goto out;
 405
 406         ret = test_eb_bitmaps();
 407 out:
 408         test_msg("Extent I/O tests finished\n");
 409         return ret;
 410 }