1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * localalloc.c 5 * 6 * Node local data allocation 7 * 8 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public 21 * License along with this program; if not, write to the 22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23 * Boston, MA 021110-1307, USA. 24 */ 25 26 #include <linux/fs.h> 27 #include <linux/types.h> 28 #include <linux/slab.h> 29 #include <linux/highmem.h> 30 #include <linux/bitops.h> 31 32 #include <cluster/masklog.h> 33 34 #include "ocfs2.h" 35 36 #include "alloc.h" 37 #include "blockcheck.h" 38 #include "dlmglue.h" 39 #include "inode.h" 40 #include "journal.h" 41 #include "localalloc.h" 42 #include "suballoc.h" 43 #include "super.h" 44 #include "sysfile.h" 45 #include "ocfs2_trace.h" 46 47 #include "buffer_head_io.h" 48 49 #define OCFS2_LOCAL_ALLOC(dinode) (&((dinode)->id2.i_lab)) 50 51 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc); 52 53 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, 54 struct ocfs2_dinode *alloc, 55 u32 *numbits, 56 struct ocfs2_alloc_reservation *resv); 57 58 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc); 59 60 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, 61 handle_t *handle, 62 struct ocfs2_dinode *alloc, 63 struct inode *main_bm_inode, 64 struct buffer_head *main_bm_bh); 65 66 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb, 67 struct ocfs2_alloc_context **ac, 68 struct inode **bitmap_inode, 69 struct buffer_head **bitmap_bh); 70 71 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb, 72 handle_t *handle, 73 struct ocfs2_alloc_context *ac); 74 75 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb, 76 struct inode *local_alloc_inode); 77 78 /* 79 * ocfs2_la_default_mb() - determine a default size, in megabytes of 80 * the local alloc. 81 * 82 * Generally, we'd like to pick as large a local alloc as 83 * possible. Performance on large workloads tends to scale 84 * proportionally to la size. In addition to that, the reservations 85 * code functions more efficiently as it can reserve more windows for 86 * write. 87 * 88 * Some things work against us when trying to choose a large local alloc: 89 * 90 * - We need to ensure our sizing is picked to leave enough space in 91 * group descriptors for other allocations (such as block groups, 92 * etc). Picking default sizes which are a multiple of 4 could help 93 * - block groups are allocated in 2mb and 4mb chunks. 94 * 95 * - Likewise, we don't want to starve other nodes of bits on small 96 * file systems. This can easily be taken care of by limiting our 97 * default to a reasonable size (256M) on larger cluster sizes. 98 * 99 * - Some file systems can't support very large sizes - 4k and 8k in 100 * particular are limited to less than 128 and 256 megabytes respectively. 101 * 102 * The following reference table shows group descriptor and local 103 * alloc maximums at various cluster sizes (4k blocksize) 104 * 105 * csize: 4K group: 126M la: 121M 106 * csize: 8K group: 252M la: 243M 107 * csize: 16K group: 504M la: 486M 108 * csize: 32K group: 1008M la: 972M 109 * csize: 64K group: 2016M la: 1944M 110 * csize: 128K group: 4032M la: 3888M 111 * csize: 256K group: 8064M la: 7776M 112 * csize: 512K group: 16128M la: 15552M 113 * csize: 1024K group: 32256M la: 31104M 114 */ 115 #define OCFS2_LA_MAX_DEFAULT_MB 256 116 #define OCFS2_LA_OLD_DEFAULT 8 117 unsigned int ocfs2_la_default_mb(struct ocfs2_super *osb) 118 { 119 unsigned int la_mb; 120 unsigned int gd_mb; 121 unsigned int la_max_mb; 122 unsigned int megs_per_slot; 123 struct super_block *sb = osb->sb; 124 125 gd_mb = ocfs2_clusters_to_megabytes(osb->sb, 126 8 * ocfs2_group_bitmap_size(sb, 0, osb->s_feature_incompat)); 127 128 /* 129 * This takes care of files systems with very small group 130 * descriptors - 512 byte blocksize at cluster sizes lower 131 * than 16K and also 1k blocksize with 4k cluster size. 132 */ 133 if ((sb->s_blocksize == 512 && osb->s_clustersize <= 8192) 134 || (sb->s_blocksize == 1024 && osb->s_clustersize == 4096)) 135 return OCFS2_LA_OLD_DEFAULT; 136 137 /* 138 * Leave enough room for some block groups and make the final 139 * value we work from a multiple of 4. 140 */ 141 gd_mb -= 16; 142 gd_mb &= 0xFFFFFFFB; 143 144 la_mb = gd_mb; 145 146 /* 147 * Keep window sizes down to a reasonable default 148 */ 149 if (la_mb > OCFS2_LA_MAX_DEFAULT_MB) { 150 /* 151 * Some clustersize / blocksize combinations will have 152 * given us a larger than OCFS2_LA_MAX_DEFAULT_MB 153 * default size, but get poor distribution when 154 * limited to exactly 256 megabytes. 155 * 156 * As an example, 16K clustersize at 4K blocksize 157 * gives us a cluster group size of 504M. Paring the 158 * local alloc size down to 256 however, would give us 159 * only one window and around 200MB left in the 160 * cluster group. Instead, find the first size below 161 * 256 which would give us an even distribution. 162 * 163 * Larger cluster group sizes actually work out pretty 164 * well when pared to 256, so we don't have to do this 165 * for any group that fits more than two 166 * OCFS2_LA_MAX_DEFAULT_MB windows. 167 */ 168 if (gd_mb > (2 * OCFS2_LA_MAX_DEFAULT_MB)) 169 la_mb = 256; 170 else { 171 unsigned int gd_mult = gd_mb; 172 173 while (gd_mult > 256) 174 gd_mult = gd_mult >> 1; 175 176 la_mb = gd_mult; 177 } 178 } 179 180 megs_per_slot = osb->osb_clusters_at_boot / osb->max_slots; 181 megs_per_slot = ocfs2_clusters_to_megabytes(osb->sb, megs_per_slot); 182 /* Too many nodes, too few disk clusters. */ 183 if (megs_per_slot < la_mb) 184 la_mb = megs_per_slot; 185 186 /* We can't store more bits than we can in a block. */ 187 la_max_mb = ocfs2_clusters_to_megabytes(osb->sb, 188 ocfs2_local_alloc_size(sb) * 8); 189 if (la_mb > la_max_mb) 190 la_mb = la_max_mb; 191 192 return la_mb; 193 } 194 195 void ocfs2_la_set_sizes(struct ocfs2_super *osb, int requested_mb) 196 { 197 struct super_block *sb = osb->sb; 198 unsigned int la_default_mb = ocfs2_la_default_mb(osb); 199 unsigned int la_max_mb; 200 201 la_max_mb = ocfs2_clusters_to_megabytes(sb, 202 ocfs2_local_alloc_size(sb) * 8); 203 204 trace_ocfs2_la_set_sizes(requested_mb, la_max_mb, la_default_mb); 205 206 if (requested_mb == -1) { 207 /* No user request - use defaults */ 208 osb->local_alloc_default_bits = 209 ocfs2_megabytes_to_clusters(sb, la_default_mb); 210 } else if (requested_mb > la_max_mb) { 211 /* Request is too big, we give the maximum available */ 212 osb->local_alloc_default_bits = 213 ocfs2_megabytes_to_clusters(sb, la_max_mb); 214 } else { 215 osb->local_alloc_default_bits = 216 ocfs2_megabytes_to_clusters(sb, requested_mb); 217 } 218 219 osb->local_alloc_bits = osb->local_alloc_default_bits; 220 } 221 222 static inline int ocfs2_la_state_enabled(struct ocfs2_super *osb) 223 { 224 return (osb->local_alloc_state == OCFS2_LA_THROTTLED || 225 osb->local_alloc_state == OCFS2_LA_ENABLED); 226 } 227 228 void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb, 229 unsigned int num_clusters) 230 { 231 spin_lock(&osb->osb_lock); 232 if (osb->local_alloc_state == OCFS2_LA_DISABLED || 233 osb->local_alloc_state == OCFS2_LA_THROTTLED) 234 if (num_clusters >= osb->local_alloc_default_bits) { 235 cancel_delayed_work(&osb->la_enable_wq); 236 osb->local_alloc_state = OCFS2_LA_ENABLED; 237 } 238 spin_unlock(&osb->osb_lock); 239 } 240 241 void ocfs2_la_enable_worker(struct work_struct *work) 242 { 243 struct ocfs2_super *osb = 244 container_of(work, struct ocfs2_super, 245 la_enable_wq.work); 246 spin_lock(&osb->osb_lock); 247 osb->local_alloc_state = OCFS2_LA_ENABLED; 248 spin_unlock(&osb->osb_lock); 249 } 250 251 /* 252 * Tell us whether a given allocation should use the local alloc 253 * file. Otherwise, it has to go to the main bitmap. 254 * 255 * This function does semi-dirty reads of local alloc size and state! 256 * This is ok however, as the values are re-checked once under mutex. 257 */ 258 int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits) 259 { 260 int ret = 0; 261 int la_bits; 262 263 spin_lock(&osb->osb_lock); 264 la_bits = osb->local_alloc_bits; 265 266 if (!ocfs2_la_state_enabled(osb)) 267 goto bail; 268 269 /* la_bits should be at least twice the size (in clusters) of 270 * a new block group. We want to be sure block group 271 * allocations go through the local alloc, so allow an 272 * allocation to take up to half the bitmap. */ 273 if (bits > (la_bits / 2)) 274 goto bail; 275 276 ret = 1; 277 bail: 278 trace_ocfs2_alloc_should_use_local( 279 (unsigned long long)bits, osb->local_alloc_state, la_bits, ret); 280 spin_unlock(&osb->osb_lock); 281 return ret; 282 } 283 284 int ocfs2_load_local_alloc(struct ocfs2_super *osb) 285 { 286 int status = 0; 287 struct ocfs2_dinode *alloc = NULL; 288 struct buffer_head *alloc_bh = NULL; 289 u32 num_used; 290 struct inode *inode = NULL; 291 struct ocfs2_local_alloc *la; 292 293 if (osb->local_alloc_bits == 0) 294 goto bail; 295 296 if (osb->local_alloc_bits >= osb->bitmap_cpg) { 297 mlog(ML_NOTICE, "Requested local alloc window %d is larger " 298 "than max possible %u. Using defaults.\n", 299 osb->local_alloc_bits, (osb->bitmap_cpg - 1)); 300 osb->local_alloc_bits = 301 ocfs2_megabytes_to_clusters(osb->sb, 302 ocfs2_la_default_mb(osb)); 303 } 304 305 /* read the alloc off disk */ 306 inode = ocfs2_get_system_file_inode(osb, LOCAL_ALLOC_SYSTEM_INODE, 307 osb->slot_num); 308 if (!inode) { 309 status = -EINVAL; 310 mlog_errno(status); 311 goto bail; 312 } 313 314 status = ocfs2_read_inode_block_full(inode, &alloc_bh, 315 OCFS2_BH_IGNORE_CACHE); 316 if (status < 0) { 317 mlog_errno(status); 318 goto bail; 319 } 320 321 alloc = (struct ocfs2_dinode *) alloc_bh->b_data; 322 la = OCFS2_LOCAL_ALLOC(alloc); 323 324 if (!(le32_to_cpu(alloc->i_flags) & 325 (OCFS2_LOCAL_ALLOC_FL|OCFS2_BITMAP_FL))) { 326 mlog(ML_ERROR, "Invalid local alloc inode, %llu\n", 327 (unsigned long long)OCFS2_I(inode)->ip_blkno); 328 status = -EINVAL; 329 goto bail; 330 } 331 332 if ((la->la_size == 0) || 333 (le16_to_cpu(la->la_size) > ocfs2_local_alloc_size(inode->i_sb))) { 334 mlog(ML_ERROR, "Local alloc size is invalid (la_size = %u)\n", 335 le16_to_cpu(la->la_size)); 336 status = -EINVAL; 337 goto bail; 338 } 339 340 /* do a little verification. */ 341 num_used = ocfs2_local_alloc_count_bits(alloc); 342 343 /* hopefully the local alloc has always been recovered before 344 * we load it. */ 345 if (num_used 346 || alloc->id1.bitmap1.i_used 347 || alloc->id1.bitmap1.i_total 348 || la->la_bm_off) 349 mlog(ML_ERROR, "Local alloc hasn't been recovered!\n" 350 "found = %u, set = %u, taken = %u, off = %u\n", 351 num_used, le32_to_cpu(alloc->id1.bitmap1.i_used), 352 le32_to_cpu(alloc->id1.bitmap1.i_total), 353 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off); 354 355 osb->local_alloc_bh = alloc_bh; 356 osb->local_alloc_state = OCFS2_LA_ENABLED; 357 358 bail: 359 if (status < 0) 360 brelse(alloc_bh); 361 if (inode) 362 iput(inode); 363 364 trace_ocfs2_load_local_alloc(osb->local_alloc_bits); 365 366 if (status) 367 mlog_errno(status); 368 return status; 369 } 370 371 /* 372 * return any unused bits to the bitmap and write out a clean 373 * local_alloc. 374 * 375 * local_alloc_bh is optional. If not passed, we will simply use the 376 * one off osb. If you do pass it however, be warned that it *will* be 377 * returned brelse'd and NULL'd out.*/ 378 void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb) 379 { 380 int status; 381 handle_t *handle; 382 struct inode *local_alloc_inode = NULL; 383 struct buffer_head *bh = NULL; 384 struct buffer_head *main_bm_bh = NULL; 385 struct inode *main_bm_inode = NULL; 386 struct ocfs2_dinode *alloc_copy = NULL; 387 struct ocfs2_dinode *alloc = NULL; 388 389 cancel_delayed_work(&osb->la_enable_wq); 390 flush_workqueue(ocfs2_wq); 391 392 if (osb->local_alloc_state == OCFS2_LA_UNUSED) 393 goto out; 394 395 local_alloc_inode = 396 ocfs2_get_system_file_inode(osb, 397 LOCAL_ALLOC_SYSTEM_INODE, 398 osb->slot_num); 399 if (!local_alloc_inode) { 400 status = -ENOENT; 401 mlog_errno(status); 402 goto out; 403 } 404 405 osb->local_alloc_state = OCFS2_LA_DISABLED; 406 407 ocfs2_resmap_uninit(&osb->osb_la_resmap); 408 409 main_bm_inode = ocfs2_get_system_file_inode(osb, 410 GLOBAL_BITMAP_SYSTEM_INODE, 411 OCFS2_INVALID_SLOT); 412 if (!main_bm_inode) { 413 status = -EINVAL; 414 mlog_errno(status); 415 goto out; 416 } 417 418 mutex_lock(&main_bm_inode->i_mutex); 419 420 status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1); 421 if (status < 0) { 422 mlog_errno(status); 423 goto out_mutex; 424 } 425 426 /* WINDOW_MOVE_CREDITS is a bit heavy... */ 427 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 428 if (IS_ERR(handle)) { 429 mlog_errno(PTR_ERR(handle)); 430 handle = NULL; 431 goto out_unlock; 432 } 433 434 bh = osb->local_alloc_bh; 435 alloc = (struct ocfs2_dinode *) bh->b_data; 436 437 alloc_copy = kmalloc(bh->b_size, GFP_NOFS); 438 if (!alloc_copy) { 439 status = -ENOMEM; 440 goto out_commit; 441 } 442 memcpy(alloc_copy, alloc, bh->b_size); 443 444 status = ocfs2_journal_access_di(handle, INODE_CACHE(local_alloc_inode), 445 bh, OCFS2_JOURNAL_ACCESS_WRITE); 446 if (status < 0) { 447 mlog_errno(status); 448 goto out_commit; 449 } 450 451 ocfs2_clear_local_alloc(alloc); 452 ocfs2_journal_dirty(handle, bh); 453 454 brelse(bh); 455 osb->local_alloc_bh = NULL; 456 osb->local_alloc_state = OCFS2_LA_UNUSED; 457 458 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy, 459 main_bm_inode, main_bm_bh); 460 if (status < 0) 461 mlog_errno(status); 462 463 out_commit: 464 ocfs2_commit_trans(osb, handle); 465 466 out_unlock: 467 brelse(main_bm_bh); 468 469 ocfs2_inode_unlock(main_bm_inode, 1); 470 471 out_mutex: 472 mutex_unlock(&main_bm_inode->i_mutex); 473 iput(main_bm_inode); 474 475 out: 476 if (local_alloc_inode) 477 iput(local_alloc_inode); 478 479 if (alloc_copy) 480 kfree(alloc_copy); 481 } 482 483 /* 484 * We want to free the bitmap bits outside of any recovery context as 485 * we'll need a cluster lock to do so, but we must clear the local 486 * alloc before giving up the recovered nodes journal. To solve this, 487 * we kmalloc a copy of the local alloc before it's change for the 488 * caller to process with ocfs2_complete_local_alloc_recovery 489 */ 490 int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb, 491 int slot_num, 492 struct ocfs2_dinode **alloc_copy) 493 { 494 int status = 0; 495 struct buffer_head *alloc_bh = NULL; 496 struct inode *inode = NULL; 497 struct ocfs2_dinode *alloc; 498 499 trace_ocfs2_begin_local_alloc_recovery(slot_num); 500 501 *alloc_copy = NULL; 502 503 inode = ocfs2_get_system_file_inode(osb, 504 LOCAL_ALLOC_SYSTEM_INODE, 505 slot_num); 506 if (!inode) { 507 status = -EINVAL; 508 mlog_errno(status); 509 goto bail; 510 } 511 512 mutex_lock(&inode->i_mutex); 513 514 status = ocfs2_read_inode_block_full(inode, &alloc_bh, 515 OCFS2_BH_IGNORE_CACHE); 516 if (status < 0) { 517 mlog_errno(status); 518 goto bail; 519 } 520 521 *alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL); 522 if (!(*alloc_copy)) { 523 status = -ENOMEM; 524 goto bail; 525 } 526 memcpy((*alloc_copy), alloc_bh->b_data, alloc_bh->b_size); 527 528 alloc = (struct ocfs2_dinode *) alloc_bh->b_data; 529 ocfs2_clear_local_alloc(alloc); 530 531 ocfs2_compute_meta_ecc(osb->sb, alloc_bh->b_data, &alloc->i_check); 532 status = ocfs2_write_block(osb, alloc_bh, INODE_CACHE(inode)); 533 if (status < 0) 534 mlog_errno(status); 535 536 bail: 537 if ((status < 0) && (*alloc_copy)) { 538 kfree(*alloc_copy); 539 *alloc_copy = NULL; 540 } 541 542 brelse(alloc_bh); 543 544 if (inode) { 545 mutex_unlock(&inode->i_mutex); 546 iput(inode); 547 } 548 549 if (status) 550 mlog_errno(status); 551 return status; 552 } 553 554 /* 555 * Step 2: By now, we've completed the journal recovery, we've stamped 556 * a clean local alloc on disk and dropped the node out of the 557 * recovery map. Dlm locks will no longer stall, so lets clear out the 558 * main bitmap. 559 */ 560 int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb, 561 struct ocfs2_dinode *alloc) 562 { 563 int status; 564 handle_t *handle; 565 struct buffer_head *main_bm_bh = NULL; 566 struct inode *main_bm_inode; 567 568 main_bm_inode = ocfs2_get_system_file_inode(osb, 569 GLOBAL_BITMAP_SYSTEM_INODE, 570 OCFS2_INVALID_SLOT); 571 if (!main_bm_inode) { 572 status = -EINVAL; 573 mlog_errno(status); 574 goto out; 575 } 576 577 mutex_lock(&main_bm_inode->i_mutex); 578 579 status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1); 580 if (status < 0) { 581 mlog_errno(status); 582 goto out_mutex; 583 } 584 585 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 586 if (IS_ERR(handle)) { 587 status = PTR_ERR(handle); 588 handle = NULL; 589 mlog_errno(status); 590 goto out_unlock; 591 } 592 593 /* we want the bitmap change to be recorded on disk asap */ 594 handle->h_sync = 1; 595 596 status = ocfs2_sync_local_to_main(osb, handle, alloc, 597 main_bm_inode, main_bm_bh); 598 if (status < 0) 599 mlog_errno(status); 600 601 ocfs2_commit_trans(osb, handle); 602 603 out_unlock: 604 ocfs2_inode_unlock(main_bm_inode, 1); 605 606 out_mutex: 607 mutex_unlock(&main_bm_inode->i_mutex); 608 609 brelse(main_bm_bh); 610 611 iput(main_bm_inode); 612 613 out: 614 if (!status) 615 ocfs2_init_steal_slots(osb); 616 if (status) 617 mlog_errno(status); 618 return status; 619 } 620 621 /* 622 * make sure we've got at least bits_wanted contiguous bits in the 623 * local alloc. You lose them when you drop i_mutex. 624 * 625 * We will add ourselves to the transaction passed in, but may start 626 * our own in order to shift windows. 627 */ 628 int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb, 629 u32 bits_wanted, 630 struct ocfs2_alloc_context *ac) 631 { 632 int status; 633 struct ocfs2_dinode *alloc; 634 struct inode *local_alloc_inode; 635 unsigned int free_bits; 636 637 BUG_ON(!ac); 638 639 local_alloc_inode = 640 ocfs2_get_system_file_inode(osb, 641 LOCAL_ALLOC_SYSTEM_INODE, 642 osb->slot_num); 643 if (!local_alloc_inode) { 644 status = -ENOENT; 645 mlog_errno(status); 646 goto bail; 647 } 648 649 mutex_lock(&local_alloc_inode->i_mutex); 650 651 /* 652 * We must double check state and allocator bits because 653 * another process may have changed them while holding i_mutex. 654 */ 655 spin_lock(&osb->osb_lock); 656 if (!ocfs2_la_state_enabled(osb) || 657 (bits_wanted > osb->local_alloc_bits)) { 658 spin_unlock(&osb->osb_lock); 659 status = -ENOSPC; 660 goto bail; 661 } 662 spin_unlock(&osb->osb_lock); 663 664 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 665 666 #ifdef CONFIG_OCFS2_DEBUG_FS 667 if (le32_to_cpu(alloc->id1.bitmap1.i_used) != 668 ocfs2_local_alloc_count_bits(alloc)) { 669 ocfs2_error(osb->sb, "local alloc inode %llu says it has " 670 "%u free bits, but a count shows %u", 671 (unsigned long long)le64_to_cpu(alloc->i_blkno), 672 le32_to_cpu(alloc->id1.bitmap1.i_used), 673 ocfs2_local_alloc_count_bits(alloc)); 674 status = -EIO; 675 goto bail; 676 } 677 #endif 678 679 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) - 680 le32_to_cpu(alloc->id1.bitmap1.i_used); 681 if (bits_wanted > free_bits) { 682 /* uhoh, window change time. */ 683 status = 684 ocfs2_local_alloc_slide_window(osb, local_alloc_inode); 685 if (status < 0) { 686 if (status != -ENOSPC) 687 mlog_errno(status); 688 goto bail; 689 } 690 691 /* 692 * Under certain conditions, the window slide code 693 * might have reduced the number of bits available or 694 * disabled the the local alloc entirely. Re-check 695 * here and return -ENOSPC if necessary. 696 */ 697 status = -ENOSPC; 698 if (!ocfs2_la_state_enabled(osb)) 699 goto bail; 700 701 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) - 702 le32_to_cpu(alloc->id1.bitmap1.i_used); 703 if (bits_wanted > free_bits) 704 goto bail; 705 } 706 707 ac->ac_inode = local_alloc_inode; 708 /* We should never use localalloc from another slot */ 709 ac->ac_alloc_slot = osb->slot_num; 710 ac->ac_which = OCFS2_AC_USE_LOCAL; 711 get_bh(osb->local_alloc_bh); 712 ac->ac_bh = osb->local_alloc_bh; 713 status = 0; 714 bail: 715 if (status < 0 && local_alloc_inode) { 716 mutex_unlock(&local_alloc_inode->i_mutex); 717 iput(local_alloc_inode); 718 } 719 720 trace_ocfs2_reserve_local_alloc_bits( 721 (unsigned long long)ac->ac_max_block, 722 bits_wanted, osb->slot_num, status); 723 724 if (status) 725 mlog_errno(status); 726 return status; 727 } 728 729 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb, 730 handle_t *handle, 731 struct ocfs2_alloc_context *ac, 732 u32 bits_wanted, 733 u32 *bit_off, 734 u32 *num_bits) 735 { 736 int status, start; 737 struct inode *local_alloc_inode; 738 void *bitmap; 739 struct ocfs2_dinode *alloc; 740 struct ocfs2_local_alloc *la; 741 742 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL); 743 744 local_alloc_inode = ac->ac_inode; 745 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 746 la = OCFS2_LOCAL_ALLOC(alloc); 747 748 start = ocfs2_local_alloc_find_clear_bits(osb, alloc, &bits_wanted, 749 ac->ac_resv); 750 if (start == -1) { 751 /* TODO: Shouldn't we just BUG here? */ 752 status = -ENOSPC; 753 mlog_errno(status); 754 goto bail; 755 } 756 757 bitmap = la->la_bitmap; 758 *bit_off = le32_to_cpu(la->la_bm_off) + start; 759 *num_bits = bits_wanted; 760 761 status = ocfs2_journal_access_di(handle, 762 INODE_CACHE(local_alloc_inode), 763 osb->local_alloc_bh, 764 OCFS2_JOURNAL_ACCESS_WRITE); 765 if (status < 0) { 766 mlog_errno(status); 767 goto bail; 768 } 769 770 ocfs2_resmap_claimed_bits(&osb->osb_la_resmap, ac->ac_resv, start, 771 bits_wanted); 772 773 while(bits_wanted--) 774 ocfs2_set_bit(start++, bitmap); 775 776 le32_add_cpu(&alloc->id1.bitmap1.i_used, *num_bits); 777 ocfs2_journal_dirty(handle, osb->local_alloc_bh); 778 779 bail: 780 if (status) 781 mlog_errno(status); 782 return status; 783 } 784 785 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc) 786 { 787 int i; 788 u8 *buffer; 789 u32 count = 0; 790 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 791 792 buffer = la->la_bitmap; 793 for (i = 0; i < le16_to_cpu(la->la_size); i++) 794 count += hweight8(buffer[i]); 795 796 trace_ocfs2_local_alloc_count_bits(count); 797 return count; 798 } 799 800 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, 801 struct ocfs2_dinode *alloc, 802 u32 *numbits, 803 struct ocfs2_alloc_reservation *resv) 804 { 805 int numfound, bitoff, left, startoff, lastzero; 806 int local_resv = 0; 807 struct ocfs2_alloc_reservation r; 808 void *bitmap = NULL; 809 struct ocfs2_reservation_map *resmap = &osb->osb_la_resmap; 810 811 if (!alloc->id1.bitmap1.i_total) { 812 bitoff = -1; 813 goto bail; 814 } 815 816 if (!resv) { 817 local_resv = 1; 818 ocfs2_resv_init_once(&r); 819 ocfs2_resv_set_type(&r, OCFS2_RESV_FLAG_TMP); 820 resv = &r; 821 } 822 823 numfound = *numbits; 824 if (ocfs2_resmap_resv_bits(resmap, resv, &bitoff, &numfound) == 0) { 825 if (numfound < *numbits) 826 *numbits = numfound; 827 goto bail; 828 } 829 830 /* 831 * Code error. While reservations are enabled, local 832 * allocation should _always_ go through them. 833 */ 834 BUG_ON(osb->osb_resv_level != 0); 835 836 /* 837 * Reservations are disabled. Handle this the old way. 838 */ 839 840 bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap; 841 842 numfound = bitoff = startoff = 0; 843 lastzero = -1; 844 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 845 while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) { 846 if (bitoff == left) { 847 /* mlog(0, "bitoff (%d) == left", bitoff); */ 848 break; 849 } 850 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, " 851 "numfound = %d\n", bitoff, startoff, numfound);*/ 852 853 /* Ok, we found a zero bit... is it contig. or do we 854 * start over?*/ 855 if (bitoff == startoff) { 856 /* we found a zero */ 857 numfound++; 858 startoff++; 859 } else { 860 /* got a zero after some ones */ 861 numfound = 1; 862 startoff = bitoff+1; 863 } 864 /* we got everything we needed */ 865 if (numfound == *numbits) { 866 /* mlog(0, "Found it all!\n"); */ 867 break; 868 } 869 } 870 871 trace_ocfs2_local_alloc_find_clear_bits_search_bitmap(bitoff, numfound); 872 873 if (numfound == *numbits) 874 bitoff = startoff - numfound; 875 else 876 bitoff = -1; 877 878 bail: 879 if (local_resv) 880 ocfs2_resv_discard(resmap, resv); 881 882 trace_ocfs2_local_alloc_find_clear_bits(*numbits, 883 le32_to_cpu(alloc->id1.bitmap1.i_total), 884 bitoff, numfound); 885 886 return bitoff; 887 } 888 889 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc) 890 { 891 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 892 int i; 893 894 alloc->id1.bitmap1.i_total = 0; 895 alloc->id1.bitmap1.i_used = 0; 896 la->la_bm_off = 0; 897 for(i = 0; i < le16_to_cpu(la->la_size); i++) 898 la->la_bitmap[i] = 0; 899 } 900 901 #if 0 902 /* turn this on and uncomment below to aid debugging window shifts. */ 903 static void ocfs2_verify_zero_bits(unsigned long *bitmap, 904 unsigned int start, 905 unsigned int count) 906 { 907 unsigned int tmp = count; 908 while(tmp--) { 909 if (ocfs2_test_bit(start + tmp, bitmap)) { 910 printk("ocfs2_verify_zero_bits: start = %u, count = " 911 "%u\n", start, count); 912 printk("ocfs2_verify_zero_bits: bit %u is set!", 913 start + tmp); 914 BUG(); 915 } 916 } 917 } 918 #endif 919 920 /* 921 * sync the local alloc to main bitmap. 922 * 923 * assumes you've already locked the main bitmap -- the bitmap inode 924 * passed is used for caching. 925 */ 926 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, 927 handle_t *handle, 928 struct ocfs2_dinode *alloc, 929 struct inode *main_bm_inode, 930 struct buffer_head *main_bm_bh) 931 { 932 int status = 0; 933 int bit_off, left, count, start; 934 u64 la_start_blk; 935 u64 blkno; 936 void *bitmap; 937 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 938 939 trace_ocfs2_sync_local_to_main( 940 le32_to_cpu(alloc->id1.bitmap1.i_total), 941 le32_to_cpu(alloc->id1.bitmap1.i_used)); 942 943 if (!alloc->id1.bitmap1.i_total) { 944 goto bail; 945 } 946 947 if (le32_to_cpu(alloc->id1.bitmap1.i_used) == 948 le32_to_cpu(alloc->id1.bitmap1.i_total)) { 949 goto bail; 950 } 951 952 la_start_blk = ocfs2_clusters_to_blocks(osb->sb, 953 le32_to_cpu(la->la_bm_off)); 954 bitmap = la->la_bitmap; 955 start = count = bit_off = 0; 956 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 957 958 while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start)) 959 != -1) { 960 if ((bit_off < left) && (bit_off == start)) { 961 count++; 962 start++; 963 continue; 964 } 965 if (count) { 966 blkno = la_start_blk + 967 ocfs2_clusters_to_blocks(osb->sb, 968 start - count); 969 970 trace_ocfs2_sync_local_to_main_free( 971 count, start - count, 972 (unsigned long long)la_start_blk, 973 (unsigned long long)blkno); 974 975 status = ocfs2_release_clusters(handle, 976 main_bm_inode, 977 main_bm_bh, blkno, 978 count); 979 if (status < 0) { 980 mlog_errno(status); 981 goto bail; 982 } 983 } 984 if (bit_off >= left) 985 break; 986 count = 1; 987 start = bit_off + 1; 988 } 989 990 bail: 991 if (status) 992 mlog_errno(status); 993 return status; 994 } 995 996 enum ocfs2_la_event { 997 OCFS2_LA_EVENT_SLIDE, /* Normal window slide. */ 998 OCFS2_LA_EVENT_FRAGMENTED, /* The global bitmap has 999 * enough bits theoretically 1000 * free, but a contiguous 1001 * allocation could not be 1002 * found. */ 1003 OCFS2_LA_EVENT_ENOSPC, /* Global bitmap doesn't have 1004 * enough bits free to satisfy 1005 * our request. */ 1006 }; 1007 #define OCFS2_LA_ENABLE_INTERVAL (30 * HZ) 1008 /* 1009 * Given an event, calculate the size of our next local alloc window. 1010 * 1011 * This should always be called under i_mutex of the local alloc inode 1012 * so that local alloc disabling doesn't race with processes trying to 1013 * use the allocator. 1014 * 1015 * Returns the state which the local alloc was left in. This value can 1016 * be ignored by some paths. 1017 */ 1018 static int ocfs2_recalc_la_window(struct ocfs2_super *osb, 1019 enum ocfs2_la_event event) 1020 { 1021 unsigned int bits; 1022 int state; 1023 1024 spin_lock(&osb->osb_lock); 1025 if (osb->local_alloc_state == OCFS2_LA_DISABLED) { 1026 WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED); 1027 goto out_unlock; 1028 } 1029 1030 /* 1031 * ENOSPC and fragmentation are treated similarly for now. 1032 */ 1033 if (event == OCFS2_LA_EVENT_ENOSPC || 1034 event == OCFS2_LA_EVENT_FRAGMENTED) { 1035 /* 1036 * We ran out of contiguous space in the primary 1037 * bitmap. Drastically reduce the number of bits used 1038 * by local alloc until we have to disable it. 1039 */ 1040 bits = osb->local_alloc_bits >> 1; 1041 if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) { 1042 /* 1043 * By setting state to THROTTLED, we'll keep 1044 * the number of local alloc bits used down 1045 * until an event occurs which would give us 1046 * reason to assume the bitmap situation might 1047 * have changed. 1048 */ 1049 osb->local_alloc_state = OCFS2_LA_THROTTLED; 1050 osb->local_alloc_bits = bits; 1051 } else { 1052 osb->local_alloc_state = OCFS2_LA_DISABLED; 1053 } 1054 queue_delayed_work(ocfs2_wq, &osb->la_enable_wq, 1055 OCFS2_LA_ENABLE_INTERVAL); 1056 goto out_unlock; 1057 } 1058 1059 /* 1060 * Don't increase the size of the local alloc window until we 1061 * know we might be able to fulfill the request. Otherwise, we 1062 * risk bouncing around the global bitmap during periods of 1063 * low space. 1064 */ 1065 if (osb->local_alloc_state != OCFS2_LA_THROTTLED) 1066 osb->local_alloc_bits = osb->local_alloc_default_bits; 1067 1068 out_unlock: 1069 state = osb->local_alloc_state; 1070 spin_unlock(&osb->osb_lock); 1071 1072 return state; 1073 } 1074 1075 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb, 1076 struct ocfs2_alloc_context **ac, 1077 struct inode **bitmap_inode, 1078 struct buffer_head **bitmap_bh) 1079 { 1080 int status; 1081 1082 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 1083 if (!(*ac)) { 1084 status = -ENOMEM; 1085 mlog_errno(status); 1086 goto bail; 1087 } 1088 1089 retry_enospc: 1090 (*ac)->ac_bits_wanted = osb->local_alloc_default_bits; 1091 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac); 1092 if (status == -ENOSPC) { 1093 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) == 1094 OCFS2_LA_DISABLED) 1095 goto bail; 1096 1097 ocfs2_free_ac_resource(*ac); 1098 memset(*ac, 0, sizeof(struct ocfs2_alloc_context)); 1099 goto retry_enospc; 1100 } 1101 if (status < 0) { 1102 mlog_errno(status); 1103 goto bail; 1104 } 1105 1106 *bitmap_inode = (*ac)->ac_inode; 1107 igrab(*bitmap_inode); 1108 *bitmap_bh = (*ac)->ac_bh; 1109 get_bh(*bitmap_bh); 1110 status = 0; 1111 bail: 1112 if ((status < 0) && *ac) { 1113 ocfs2_free_alloc_context(*ac); 1114 *ac = NULL; 1115 } 1116 1117 if (status) 1118 mlog_errno(status); 1119 return status; 1120 } 1121 1122 /* 1123 * pass it the bitmap lock in lock_bh if you have it. 1124 */ 1125 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb, 1126 handle_t *handle, 1127 struct ocfs2_alloc_context *ac) 1128 { 1129 int status = 0; 1130 u32 cluster_off, cluster_count; 1131 struct ocfs2_dinode *alloc = NULL; 1132 struct ocfs2_local_alloc *la; 1133 1134 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 1135 la = OCFS2_LOCAL_ALLOC(alloc); 1136 1137 trace_ocfs2_local_alloc_new_window( 1138 le32_to_cpu(alloc->id1.bitmap1.i_total), 1139 osb->local_alloc_bits); 1140 1141 /* Instruct the allocation code to try the most recently used 1142 * cluster group. We'll re-record the group used this pass 1143 * below. */ 1144 ac->ac_last_group = osb->la_last_gd; 1145 1146 /* we used the generic suballoc reserve function, but we set 1147 * everything up nicely, so there's no reason why we can't use 1148 * the more specific cluster api to claim bits. */ 1149 status = ocfs2_claim_clusters(handle, ac, osb->local_alloc_bits, 1150 &cluster_off, &cluster_count); 1151 if (status == -ENOSPC) { 1152 retry_enospc: 1153 /* 1154 * Note: We could also try syncing the journal here to 1155 * allow use of any free bits which the current 1156 * transaction can't give us access to. --Mark 1157 */ 1158 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) == 1159 OCFS2_LA_DISABLED) 1160 goto bail; 1161 1162 ac->ac_bits_wanted = osb->local_alloc_default_bits; 1163 status = ocfs2_claim_clusters(handle, ac, 1164 osb->local_alloc_bits, 1165 &cluster_off, 1166 &cluster_count); 1167 if (status == -ENOSPC) 1168 goto retry_enospc; 1169 /* 1170 * We only shrunk the *minimum* number of in our 1171 * request - it's entirely possible that the allocator 1172 * might give us more than we asked for. 1173 */ 1174 if (status == 0) { 1175 spin_lock(&osb->osb_lock); 1176 osb->local_alloc_bits = cluster_count; 1177 spin_unlock(&osb->osb_lock); 1178 } 1179 } 1180 if (status < 0) { 1181 if (status != -ENOSPC) 1182 mlog_errno(status); 1183 goto bail; 1184 } 1185 1186 osb->la_last_gd = ac->ac_last_group; 1187 1188 la->la_bm_off = cpu_to_le32(cluster_off); 1189 alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count); 1190 /* just in case... In the future when we find space ourselves, 1191 * we don't have to get all contiguous -- but we'll have to 1192 * set all previously used bits in bitmap and update 1193 * la_bits_set before setting the bits in the main bitmap. */ 1194 alloc->id1.bitmap1.i_used = 0; 1195 memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0, 1196 le16_to_cpu(la->la_size)); 1197 1198 ocfs2_resmap_restart(&osb->osb_la_resmap, cluster_count, 1199 OCFS2_LOCAL_ALLOC(alloc)->la_bitmap); 1200 1201 trace_ocfs2_local_alloc_new_window_result( 1202 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off, 1203 le32_to_cpu(alloc->id1.bitmap1.i_total)); 1204 1205 bail: 1206 if (status) 1207 mlog_errno(status); 1208 return status; 1209 } 1210 1211 /* Note that we do *NOT* lock the local alloc inode here as 1212 * it's been locked already for us. */ 1213 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb, 1214 struct inode *local_alloc_inode) 1215 { 1216 int status = 0; 1217 struct buffer_head *main_bm_bh = NULL; 1218 struct inode *main_bm_inode = NULL; 1219 handle_t *handle = NULL; 1220 struct ocfs2_dinode *alloc; 1221 struct ocfs2_dinode *alloc_copy = NULL; 1222 struct ocfs2_alloc_context *ac = NULL; 1223 1224 ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE); 1225 1226 /* This will lock the main bitmap for us. */ 1227 status = ocfs2_local_alloc_reserve_for_window(osb, 1228 &ac, 1229 &main_bm_inode, 1230 &main_bm_bh); 1231 if (status < 0) { 1232 if (status != -ENOSPC) 1233 mlog_errno(status); 1234 goto bail; 1235 } 1236 1237 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 1238 if (IS_ERR(handle)) { 1239 status = PTR_ERR(handle); 1240 handle = NULL; 1241 mlog_errno(status); 1242 goto bail; 1243 } 1244 1245 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 1246 1247 /* We want to clear the local alloc before doing anything 1248 * else, so that if we error later during this operation, 1249 * local alloc shutdown won't try to double free main bitmap 1250 * bits. Make a copy so the sync function knows which bits to 1251 * free. */ 1252 alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_NOFS); 1253 if (!alloc_copy) { 1254 status = -ENOMEM; 1255 mlog_errno(status); 1256 goto bail; 1257 } 1258 memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size); 1259 1260 status = ocfs2_journal_access_di(handle, 1261 INODE_CACHE(local_alloc_inode), 1262 osb->local_alloc_bh, 1263 OCFS2_JOURNAL_ACCESS_WRITE); 1264 if (status < 0) { 1265 mlog_errno(status); 1266 goto bail; 1267 } 1268 1269 ocfs2_clear_local_alloc(alloc); 1270 ocfs2_journal_dirty(handle, osb->local_alloc_bh); 1271 1272 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy, 1273 main_bm_inode, main_bm_bh); 1274 if (status < 0) { 1275 mlog_errno(status); 1276 goto bail; 1277 } 1278 1279 status = ocfs2_local_alloc_new_window(osb, handle, ac); 1280 if (status < 0) { 1281 if (status != -ENOSPC) 1282 mlog_errno(status); 1283 goto bail; 1284 } 1285 1286 atomic_inc(&osb->alloc_stats.moves); 1287 1288 bail: 1289 if (handle) 1290 ocfs2_commit_trans(osb, handle); 1291 1292 brelse(main_bm_bh); 1293 1294 if (main_bm_inode) 1295 iput(main_bm_inode); 1296 1297 if (alloc_copy) 1298 kfree(alloc_copy); 1299 1300 if (ac) 1301 ocfs2_free_alloc_context(ac); 1302 1303 if (status) 1304 mlog_errno(status); 1305 return status; 1306 } 1307 1308