| @@ -0,0 +1,276 @@ |
| | 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 "btrfs-tests.h" |
| | 22 | #include "../extent_io.h" |
| | 23 | |
| | 24 | #define PROCESS_UNLOCK (1 << 0) |
| | 25 | #define PROCESS_RELEASE (1 << 1) |
| | 26 | #define PROCESS_TEST_LOCKED (1 << 2) |
| | 27 | |
| | 28 | static noinline int process_page_range(struct inode *inode, u64 start, u64 end, |
| | 29 | unsigned long flags) |
| | 30 | { |
| | 31 | int ret; |
| | 32 | struct page *pages[16]; |
| | 33 | unsigned long index = start >> PAGE_CACHE_SHIFT; |
| | 34 | unsigned long end_index = end >> PAGE_CACHE_SHIFT; |
| | 35 | unsigned long nr_pages = end_index - index + 1; |
| | 36 | int i; |
| | 37 | int count = 0; |
| | 38 | int loops = 0; |
| | 39 | |
| | 40 | while (nr_pages > 0) { |
| | 41 | ret = find_get_pages_contig(inode->i_mapping, index, |
| | 42 | min_t(unsigned long, nr_pages, |
| | 43 | ARRAY_SIZE(pages)), pages); |
| | 44 | for (i = 0; i < ret; i++) { |
| | 45 | if (flags & PROCESS_TEST_LOCKED && |
| | 46 | !PageLocked(pages[i])) |
| | 47 | count++; |
| | 48 | if (flags & PROCESS_UNLOCK && PageLocked(pages[i])) |
| | 49 | unlock_page(pages[i]); |
| | 50 | page_cache_release(pages[i]); |
| | 51 | if (flags & PROCESS_RELEASE) |
| | 52 | page_cache_release(pages[i]); |
| | 53 | } |
| | 54 | nr_pages -= ret; |
| | 55 | index += ret; |
| | 56 | cond_resched(); |
| | 57 | loops++; |
| | 58 | if (loops > 100000) { |
| | 59 | printk(KERN_ERR "stuck in a loop, start %Lu, end %Lu, nr_pages %lu, ret %d\n", start, end, nr_pages, ret); |
| | 60 | break; |
| | 61 | } |
| | 62 | } |
| | 63 | return count; |
| | 64 | } |
| | 65 | |
| | 66 | static int test_find_delalloc(void) |
| | 67 | { |
| | 68 | struct inode *inode; |
| | 69 | struct extent_io_tree tmp; |
| | 70 | struct page *page; |
| | 71 | struct page *locked_page = NULL; |
| | 72 | unsigned long index = 0; |
| | 73 | u64 total_dirty = 256 * 1024 * 1024; |
| | 74 | u64 max_bytes = 128 * 1024 * 1024; |
| | 75 | u64 start, end, test_start; |
| | 76 | u64 found; |
| | 77 | int ret = -EINVAL; |
| | 78 | |
| | 79 | inode = btrfs_new_test_inode(); |
| | 80 | if (!inode) { |
| | 81 | test_msg("Failed to allocate test inode\n"); |
| | 82 | return -ENOMEM; |
| | 83 | } |
| | 84 | |
| | 85 | extent_io_tree_init(&tmp, &inode->i_data); |
| | 86 | |
| | 87 | /* |
| | 88 | * First go through and create and mark all of our pages dirty, we pin |
| | 89 | * everything to make sure our pages don't get evicted and screw up our |
| | 90 | * test. |
| | 91 | */ |
| | 92 | for (index = 0; index < (total_dirty >> PAGE_CACHE_SHIFT); index++) { |
| | 93 | page = find_or_create_page(inode->i_mapping, index, GFP_NOFS); |
| | 94 | if (!page) { |
| | 95 | test_msg("Failed to allocate test page\n"); |
| | 96 | ret = -ENOMEM; |
| | 97 | goto out; |
| | 98 | } |
| | 99 | SetPageDirty(page); |
| | 100 | if (index) { |
| | 101 | unlock_page(page); |
| | 102 | } else { |
| | 103 | page_cache_get(page); |
| | 104 | locked_page = page; |
| | 105 | } |
| | 106 | } |
| | 107 | |
| | 108 | /* Test this scenario |
| | 109 | * |--- delalloc ---| |
| | 110 | * |--- search ---| |
| | 111 | */ |
| | 112 | set_extent_delalloc(&tmp, 0, 4095, NULL, GFP_NOFS); |
| | 113 | start = 0; |
| | 114 | end = 0; |
| | 115 | found = find_lock_delalloc_range(inode, &tmp, locked_page, &start, |
| | 116 | &end, max_bytes); |
| | 117 | if (!found) { |
| | 118 | test_msg("Should have found at least one delalloc\n"); |
| | 119 | goto out_bits; |
| | 120 | } |
| | 121 | if (start != 0 || end != 4095) { |
| | 122 | test_msg("Expected start 0 end 4095, got start %Lu end %Lu\n", |
| | 123 | start, end); |
| | 124 | goto out_bits; |
| | 125 | } |
| | 126 | unlock_extent(&tmp, start, end); |
| | 127 | unlock_page(locked_page); |
| | 128 | page_cache_release(locked_page); |
| | 129 | |
| | 130 | /* |
| | 131 | * Test this scenario |
| | 132 | * |
| | 133 | * |--- delalloc ---| |
| | 134 | * |--- search ---| |
| | 135 | */ |
| | 136 | test_start = 64 * 1024 * 1024; |
| | 137 | locked_page = find_lock_page(inode->i_mapping, |
| | 138 | test_start >> PAGE_CACHE_SHIFT); |
| | 139 | if (!locked_page) { |
| | 140 | test_msg("Couldn't find the locked page\n"); |
| | 141 | goto out_bits; |
| | 142 | } |
| | 143 | set_extent_delalloc(&tmp, 4096, max_bytes - 1, NULL, GFP_NOFS); |
| | 144 | start = test_start; |
| | 145 | end = 0; |
| | 146 | found = find_lock_delalloc_range(inode, &tmp, locked_page, &start, |
| | 147 | &end, max_bytes); |
| | 148 | if (!found) { |
| | 149 | test_msg("Couldn't find delalloc in our range\n"); |
| | 150 | goto out_bits; |
| | 151 | } |
| | 152 | if (start != test_start || end != max_bytes - 1) { |
| | 153 | test_msg("Expected start %Lu end %Lu, got start %Lu, end " |
| | 154 | "%Lu\n", test_start, max_bytes - 1, start, end); |
| | 155 | goto out_bits; |
| | 156 | } |
| | 157 | if (process_page_range(inode, start, end, |
| | 158 | PROCESS_TEST_LOCKED | PROCESS_UNLOCK)) { |
| | 159 | test_msg("There were unlocked pages in the range\n"); |
| | 160 | goto out_bits; |
| | 161 | } |
| | 162 | unlock_extent(&tmp, start, end); |
| | 163 | /* locked_page was unlocked above */ |
| | 164 | page_cache_release(locked_page); |
| | 165 | |
| | 166 | /* |
| | 167 | * Test this scenario |
| | 168 | * |--- delalloc ---| |
| | 169 | * |--- search ---| |
| | 170 | */ |
| | 171 | test_start = max_bytes + 4096; |
| | 172 | locked_page = find_lock_page(inode->i_mapping, test_start >> |
| | 173 | PAGE_CACHE_SHIFT); |
| | 174 | if (!locked_page) { |
| | 175 | test_msg("Could'nt find the locked page\n"); |
| | 176 | goto out_bits; |
| | 177 | } |
| | 178 | start = test_start; |
| | 179 | end = 0; |
| | 180 | found = find_lock_delalloc_range(inode, &tmp, locked_page, &start, |
| | 181 | &end, max_bytes); |
| | 182 | if (found) { |
| | 183 | test_msg("Found range when we shouldn't have\n"); |
| | 184 | goto out_bits; |
| | 185 | } |
| | 186 | if (end != (u64)-1) { |
| | 187 | test_msg("Did not return the proper end offset\n"); |
| | 188 | goto out_bits; |
| | 189 | } |
| | 190 | |
| | 191 | /* |
| | 192 | * Test this scenario |
| | 193 | * [------- delalloc -------| |
| | 194 | * [max_bytes]|-- search--| |
| | 195 | * |
| | 196 | * We are re-using our test_start from above since it works out well. |
| | 197 | */ |
| | 198 | set_extent_delalloc(&tmp, max_bytes, total_dirty - 1, NULL, GFP_NOFS); |
| | 199 | start = test_start; |
| | 200 | end = 0; |
| | 201 | found = find_lock_delalloc_range(inode, &tmp, locked_page, &start, |
| | 202 | &end, max_bytes); |
| | 203 | if (!found) { |
| | 204 | test_msg("Didn't find our range\n"); |
| | 205 | goto out_bits; |
| | 206 | } |
| | 207 | if (start != test_start || end != total_dirty - 1) { |
| | 208 | test_msg("Expected start %Lu end %Lu, got start %Lu end %Lu\n", |
| | 209 | test_start, total_dirty - 1, start, end); |
| | 210 | goto out_bits; |
| | 211 | } |
| | 212 | if (process_page_range(inode, start, end, |
| | 213 | PROCESS_TEST_LOCKED | PROCESS_UNLOCK)) { |
| | 214 | test_msg("Pages in range were not all locked\n"); |
| | 215 | goto out_bits; |
| | 216 | } |
| | 217 | unlock_extent(&tmp, start, end); |
| | 218 | |
| | 219 | /* |
| | 220 | * Now to test where we run into a page that is no longer dirty in the |
| | 221 | * range we want to find. |
| | 222 | */ |
| | 223 | page = find_get_page(inode->i_mapping, (max_bytes + (1 * 1024 * 1024)) |
| | 224 | >> PAGE_CACHE_SHIFT); |
| | 225 | if (!page) { |
| | 226 | test_msg("Couldn't find our page\n"); |
| | 227 | goto out_bits; |
| | 228 | } |
| | 229 | ClearPageDirty(page); |
| | 230 | page_cache_release(page); |
| | 231 | |
| | 232 | /* We unlocked it in the previous test */ |
| | 233 | lock_page(locked_page); |
| | 234 | start = test_start; |
| | 235 | end = 0; |
| | 236 | /* |
| | 237 | * Currently if we fail to find dirty pages in the delalloc range we |
| | 238 | * will adjust max_bytes down to PAGE_CACHE_SIZE and then re-search. If |
| | 239 | * this changes at any point in the future we will need to fix this |
| | 240 | * tests expected behavior. |
| | 241 | */ |
| | 242 | found = find_lock_delalloc_range(inode, &tmp, locked_page, &start, |
| | 243 | &end, max_bytes); |
| | 244 | if (!found) { |
| | 245 | test_msg("Didn't find our range\n"); |
| | 246 | goto out_bits; |
| | 247 | } |
| | 248 | if (start != test_start && end != test_start + PAGE_CACHE_SIZE - 1) { |
| | 249 | test_msg("Expected start %Lu end %Lu, got start %Lu end %Lu\n", |
| | 250 | test_start, test_start + PAGE_CACHE_SIZE - 1, start, |
| | 251 | end); |
| | 252 | goto out_bits; |
| | 253 | } |
| | 254 | if (process_page_range(inode, start, end, PROCESS_TEST_LOCKED | |
| | 255 | PROCESS_UNLOCK)) { |
| | 256 | test_msg("Pages in range were not all locked\n"); |
| | 257 | goto out_bits; |
| | 258 | } |
| | 259 | ret = 0; |
| | 260 | out_bits: |
| | 261 | clear_extent_bits(&tmp, 0, total_dirty - 1, |
| | 262 | (unsigned long)-1, GFP_NOFS); |
| | 263 | out: |
| | 264 | if (locked_page) |
| | 265 | page_cache_release(locked_page); |
| | 266 | process_page_range(inode, 0, total_dirty - 1, |
| | 267 | PROCESS_UNLOCK | PROCESS_RELEASE); |
| | 268 | iput(inode); |
| | 269 | return ret; |
| | 270 | } |
| | 271 | |
| | 272 | int btrfs_test_extent_io(void) |
| | 273 | { |
| | 274 | test_msg("Running find delalloc tests\n"); |
| | 275 | return test_find_delalloc(); |
| | 276 | } |