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 } 277