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 51static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc); 52 53static 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 58static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc); 59 60static 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 66static 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 71static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb, 72 handle_t *handle, 73 struct ocfs2_alloc_context *ac); 74 75static 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 117unsigned 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 195void 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 222static 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 228void 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 241void 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 */ 258int 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; 277bail: 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 284int 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 358bail: 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.*/ 378void 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 463out_commit: 464 ocfs2_commit_trans(osb, handle); 465 466out_unlock: 467 brelse(main_bm_bh); 468 469 ocfs2_inode_unlock(main_bm_inode, 1); 470 471out_mutex: 472 mutex_unlock(&main_bm_inode->i_mutex); 473 iput(main_bm_inode); 474 475out: 476 if (local_alloc_inode) 477 iput(local_alloc_inode); 478 479 kfree(alloc_copy); 480} 481 482/* 483 * We want to free the bitmap bits outside of any recovery context as 484 * we'll need a cluster lock to do so, but we must clear the local 485 * alloc before giving up the recovered nodes journal. To solve this, 486 * we kmalloc a copy of the local alloc before it's change for the 487 * caller to process with ocfs2_complete_local_alloc_recovery 488 */ 489int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb, 490 int slot_num, 491 struct ocfs2_dinode **alloc_copy) 492{ 493 int status = 0; 494 struct buffer_head *alloc_bh = NULL; 495 struct inode *inode = NULL; 496 struct ocfs2_dinode *alloc; 497 498 trace_ocfs2_begin_local_alloc_recovery(slot_num); 499 500 *alloc_copy = NULL; 501 502 inode = ocfs2_get_system_file_inode(osb, 503 LOCAL_ALLOC_SYSTEM_INODE, 504 slot_num); 505 if (!inode) { 506 status = -EINVAL; 507 mlog_errno(status); 508 goto bail; 509 } 510 511 mutex_lock(&inode->i_mutex); 512 513 status = ocfs2_read_inode_block_full(inode, &alloc_bh, 514 OCFS2_BH_IGNORE_CACHE); 515 if (status < 0) { 516 mlog_errno(status); 517 goto bail; 518 } 519 520 *alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL); 521 if (!(*alloc_copy)) { 522 status = -ENOMEM; 523 goto bail; 524 } 525 memcpy((*alloc_copy), alloc_bh->b_data, alloc_bh->b_size); 526 527 alloc = (struct ocfs2_dinode *) alloc_bh->b_data; 528 ocfs2_clear_local_alloc(alloc); 529 530 ocfs2_compute_meta_ecc(osb->sb, alloc_bh->b_data, &alloc->i_check); 531 status = ocfs2_write_block(osb, alloc_bh, INODE_CACHE(inode)); 532 if (status < 0) 533 mlog_errno(status); 534 535bail: 536 if (status < 0) { 537 kfree(*alloc_copy); 538 *alloc_copy = NULL; 539 } 540 541 brelse(alloc_bh); 542 543 if (inode) { 544 mutex_unlock(&inode->i_mutex); 545 iput(inode); 546 } 547 548 if (status) 549 mlog_errno(status); 550 return status; 551} 552 553/* 554 * Step 2: By now, we've completed the journal recovery, we've stamped 555 * a clean local alloc on disk and dropped the node out of the 556 * recovery map. Dlm locks will no longer stall, so lets clear out the 557 * main bitmap. 558 */ 559int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb, 560 struct ocfs2_dinode *alloc) 561{ 562 int status; 563 handle_t *handle; 564 struct buffer_head *main_bm_bh = NULL; 565 struct inode *main_bm_inode; 566 567 main_bm_inode = ocfs2_get_system_file_inode(osb, 568 GLOBAL_BITMAP_SYSTEM_INODE, 569 OCFS2_INVALID_SLOT); 570 if (!main_bm_inode) { 571 status = -EINVAL; 572 mlog_errno(status); 573 goto out; 574 } 575 576 mutex_lock(&main_bm_inode->i_mutex); 577 578 status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1); 579 if (status < 0) { 580 mlog_errno(status); 581 goto out_mutex; 582 } 583 584 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 585 if (IS_ERR(handle)) { 586 status = PTR_ERR(handle); 587 handle = NULL; 588 mlog_errno(status); 589 goto out_unlock; 590 } 591 592 /* we want the bitmap change to be recorded on disk asap */ 593 handle->h_sync = 1; 594 595 status = ocfs2_sync_local_to_main(osb, handle, alloc, 596 main_bm_inode, main_bm_bh); 597 if (status < 0) 598 mlog_errno(status); 599 600 ocfs2_commit_trans(osb, handle); 601 602out_unlock: 603 ocfs2_inode_unlock(main_bm_inode, 1); 604 605out_mutex: 606 mutex_unlock(&main_bm_inode->i_mutex); 607 608 brelse(main_bm_bh); 609 610 iput(main_bm_inode); 611 612out: 613 if (!status) 614 ocfs2_init_steal_slots(osb); 615 if (status) 616 mlog_errno(status); 617 return status; 618} 619 620/* 621 * make sure we've got at least bits_wanted contiguous bits in the 622 * local alloc. You lose them when you drop i_mutex. 623 * 624 * We will add ourselves to the transaction passed in, but may start 625 * our own in order to shift windows. 626 */ 627int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb, 628 u32 bits_wanted, 629 struct ocfs2_alloc_context *ac) 630{ 631 int status; 632 struct ocfs2_dinode *alloc; 633 struct inode *local_alloc_inode; 634 unsigned int free_bits; 635 636 BUG_ON(!ac); 637 638 local_alloc_inode = 639 ocfs2_get_system_file_inode(osb, 640 LOCAL_ALLOC_SYSTEM_INODE, 641 osb->slot_num); 642 if (!local_alloc_inode) { 643 status = -ENOENT; 644 mlog_errno(status); 645 goto bail; 646 } 647 648 mutex_lock(&local_alloc_inode->i_mutex); 649 650 /* 651 * We must double check state and allocator bits because 652 * another process may have changed them while holding i_mutex. 653 */ 654 spin_lock(&osb->osb_lock); 655 if (!ocfs2_la_state_enabled(osb) || 656 (bits_wanted > osb->local_alloc_bits)) { 657 spin_unlock(&osb->osb_lock); 658 status = -ENOSPC; 659 goto bail; 660 } 661 spin_unlock(&osb->osb_lock); 662 663 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 664 665#ifdef CONFIG_OCFS2_DEBUG_FS 666 if (le32_to_cpu(alloc->id1.bitmap1.i_used) != 667 ocfs2_local_alloc_count_bits(alloc)) { 668 ocfs2_error(osb->sb, "local alloc inode %llu says it has " 669 "%u free bits, but a count shows %u", 670 (unsigned long long)le64_to_cpu(alloc->i_blkno), 671 le32_to_cpu(alloc->id1.bitmap1.i_used), 672 ocfs2_local_alloc_count_bits(alloc)); 673 status = -EIO; 674 goto bail; 675 } 676#endif 677 678 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) - 679 le32_to_cpu(alloc->id1.bitmap1.i_used); 680 if (bits_wanted > free_bits) { 681 /* uhoh, window change time. */ 682 status = 683 ocfs2_local_alloc_slide_window(osb, local_alloc_inode); 684 if (status < 0) { 685 if (status != -ENOSPC) 686 mlog_errno(status); 687 goto bail; 688 } 689 690 /* 691 * Under certain conditions, the window slide code 692 * might have reduced the number of bits available or 693 * disabled the the local alloc entirely. Re-check 694 * here and return -ENOSPC if necessary. 695 */ 696 status = -ENOSPC; 697 if (!ocfs2_la_state_enabled(osb)) 698 goto bail; 699 700 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) - 701 le32_to_cpu(alloc->id1.bitmap1.i_used); 702 if (bits_wanted > free_bits) 703 goto bail; 704 } 705 706 ac->ac_inode = local_alloc_inode; 707 /* We should never use localalloc from another slot */ 708 ac->ac_alloc_slot = osb->slot_num; 709 ac->ac_which = OCFS2_AC_USE_LOCAL; 710 get_bh(osb->local_alloc_bh); 711 ac->ac_bh = osb->local_alloc_bh; 712 status = 0; 713bail: 714 if (status < 0 && local_alloc_inode) { 715 mutex_unlock(&local_alloc_inode->i_mutex); 716 iput(local_alloc_inode); 717 } 718 719 trace_ocfs2_reserve_local_alloc_bits( 720 (unsigned long long)ac->ac_max_block, 721 bits_wanted, osb->slot_num, status); 722 723 if (status) 724 mlog_errno(status); 725 return status; 726} 727 728int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb, 729 handle_t *handle, 730 struct ocfs2_alloc_context *ac, 731 u32 bits_wanted, 732 u32 *bit_off, 733 u32 *num_bits) 734{ 735 int status, start; 736 struct inode *local_alloc_inode; 737 void *bitmap; 738 struct ocfs2_dinode *alloc; 739 struct ocfs2_local_alloc *la; 740 741 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL); 742 743 local_alloc_inode = ac->ac_inode; 744 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 745 la = OCFS2_LOCAL_ALLOC(alloc); 746 747 start = ocfs2_local_alloc_find_clear_bits(osb, alloc, &bits_wanted, 748 ac->ac_resv); 749 if (start == -1) { 750 /* TODO: Shouldn't we just BUG here? */ 751 status = -ENOSPC; 752 mlog_errno(status); 753 goto bail; 754 } 755 756 bitmap = la->la_bitmap; 757 *bit_off = le32_to_cpu(la->la_bm_off) + start; 758 *num_bits = bits_wanted; 759 760 status = ocfs2_journal_access_di(handle, 761 INODE_CACHE(local_alloc_inode), 762 osb->local_alloc_bh, 763 OCFS2_JOURNAL_ACCESS_WRITE); 764 if (status < 0) { 765 mlog_errno(status); 766 goto bail; 767 } 768 769 ocfs2_resmap_claimed_bits(&osb->osb_la_resmap, ac->ac_resv, start, 770 bits_wanted); 771 772 while(bits_wanted--) 773 ocfs2_set_bit(start++, bitmap); 774 775 le32_add_cpu(&alloc->id1.bitmap1.i_used, *num_bits); 776 ocfs2_journal_dirty(handle, osb->local_alloc_bh); 777 778bail: 779 if (status) 780 mlog_errno(status); 781 return status; 782} 783 784int ocfs2_free_local_alloc_bits(struct ocfs2_super *osb, 785 handle_t *handle, 786 struct ocfs2_alloc_context *ac, 787 u32 bit_off, 788 u32 num_bits) 789{ 790 int status, start; 791 u32 clear_bits; 792 struct inode *local_alloc_inode; 793 void *bitmap; 794 struct ocfs2_dinode *alloc; 795 struct ocfs2_local_alloc *la; 796 797 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL); 798 799 local_alloc_inode = ac->ac_inode; 800 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 801 la = OCFS2_LOCAL_ALLOC(alloc); 802 803 bitmap = la->la_bitmap; 804 start = bit_off - le32_to_cpu(la->la_bm_off); 805 clear_bits = num_bits; 806 807 status = ocfs2_journal_access_di(handle, 808 INODE_CACHE(local_alloc_inode), 809 osb->local_alloc_bh, 810 OCFS2_JOURNAL_ACCESS_WRITE); 811 if (status < 0) { 812 mlog_errno(status); 813 goto bail; 814 } 815 816 while (clear_bits--) 817 ocfs2_clear_bit(start++, bitmap); 818 819 le32_add_cpu(&alloc->id1.bitmap1.i_used, -num_bits); 820 ocfs2_journal_dirty(handle, osb->local_alloc_bh); 821 822bail: 823 return status; 824} 825 826static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc) 827{ 828 u32 count; 829 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 830 831 count = memweight(la->la_bitmap, le16_to_cpu(la->la_size)); 832 833 trace_ocfs2_local_alloc_count_bits(count); 834 return count; 835} 836 837static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, 838 struct ocfs2_dinode *alloc, 839 u32 *numbits, 840 struct ocfs2_alloc_reservation *resv) 841{ 842 int numfound, bitoff, left, startoff, lastzero; 843 int local_resv = 0; 844 struct ocfs2_alloc_reservation r; 845 void *bitmap = NULL; 846 struct ocfs2_reservation_map *resmap = &osb->osb_la_resmap; 847 848 if (!alloc->id1.bitmap1.i_total) { 849 bitoff = -1; 850 goto bail; 851 } 852 853 if (!resv) { 854 local_resv = 1; 855 ocfs2_resv_init_once(&r); 856 ocfs2_resv_set_type(&r, OCFS2_RESV_FLAG_TMP); 857 resv = &r; 858 } 859 860 numfound = *numbits; 861 if (ocfs2_resmap_resv_bits(resmap, resv, &bitoff, &numfound) == 0) { 862 if (numfound < *numbits) 863 *numbits = numfound; 864 goto bail; 865 } 866 867 /* 868 * Code error. While reservations are enabled, local 869 * allocation should _always_ go through them. 870 */ 871 BUG_ON(osb->osb_resv_level != 0); 872 873 /* 874 * Reservations are disabled. Handle this the old way. 875 */ 876 877 bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap; 878 879 numfound = bitoff = startoff = 0; 880 lastzero = -1; 881 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 882 while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) { 883 if (bitoff == left) { 884 /* mlog(0, "bitoff (%d) == left", bitoff); */ 885 break; 886 } 887 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, " 888 "numfound = %d\n", bitoff, startoff, numfound);*/ 889 890 /* Ok, we found a zero bit... is it contig. or do we 891 * start over?*/ 892 if (bitoff == startoff) { 893 /* we found a zero */ 894 numfound++; 895 startoff++; 896 } else { 897 /* got a zero after some ones */ 898 numfound = 1; 899 startoff = bitoff+1; 900 } 901 /* we got everything we needed */ 902 if (numfound == *numbits) { 903 /* mlog(0, "Found it all!\n"); */ 904 break; 905 } 906 } 907 908 trace_ocfs2_local_alloc_find_clear_bits_search_bitmap(bitoff, numfound); 909 910 if (numfound == *numbits) 911 bitoff = startoff - numfound; 912 else 913 bitoff = -1; 914 915bail: 916 if (local_resv) 917 ocfs2_resv_discard(resmap, resv); 918 919 trace_ocfs2_local_alloc_find_clear_bits(*numbits, 920 le32_to_cpu(alloc->id1.bitmap1.i_total), 921 bitoff, numfound); 922 923 return bitoff; 924} 925 926static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc) 927{ 928 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 929 int i; 930 931 alloc->id1.bitmap1.i_total = 0; 932 alloc->id1.bitmap1.i_used = 0; 933 la->la_bm_off = 0; 934 for(i = 0; i < le16_to_cpu(la->la_size); i++) 935 la->la_bitmap[i] = 0; 936} 937 938#if 0 939/* turn this on and uncomment below to aid debugging window shifts. */ 940static void ocfs2_verify_zero_bits(unsigned long *bitmap, 941 unsigned int start, 942 unsigned int count) 943{ 944 unsigned int tmp = count; 945 while(tmp--) { 946 if (ocfs2_test_bit(start + tmp, bitmap)) { 947 printk("ocfs2_verify_zero_bits: start = %u, count = " 948 "%u\n", start, count); 949 printk("ocfs2_verify_zero_bits: bit %u is set!", 950 start + tmp); 951 BUG(); 952 } 953 } 954} 955#endif 956 957/* 958 * sync the local alloc to main bitmap. 959 * 960 * assumes you've already locked the main bitmap -- the bitmap inode 961 * passed is used for caching. 962 */ 963static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, 964 handle_t *handle, 965 struct ocfs2_dinode *alloc, 966 struct inode *main_bm_inode, 967 struct buffer_head *main_bm_bh) 968{ 969 int status = 0; 970 int bit_off, left, count, start; 971 u64 la_start_blk; 972 u64 blkno; 973 void *bitmap; 974 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 975 976 trace_ocfs2_sync_local_to_main( 977 le32_to_cpu(alloc->id1.bitmap1.i_total), 978 le32_to_cpu(alloc->id1.bitmap1.i_used)); 979 980 if (!alloc->id1.bitmap1.i_total) { 981 goto bail; 982 } 983 984 if (le32_to_cpu(alloc->id1.bitmap1.i_used) == 985 le32_to_cpu(alloc->id1.bitmap1.i_total)) { 986 goto bail; 987 } 988 989 la_start_blk = ocfs2_clusters_to_blocks(osb->sb, 990 le32_to_cpu(la->la_bm_off)); 991 bitmap = la->la_bitmap; 992 start = count = bit_off = 0; 993 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 994 995 while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start)) 996 != -1) { 997 if ((bit_off < left) && (bit_off == start)) { 998 count++; 999 start++; 1000 continue; 1001 } 1002 if (count) { 1003 blkno = la_start_blk + 1004 ocfs2_clusters_to_blocks(osb->sb, 1005 start - count); 1006 1007 trace_ocfs2_sync_local_to_main_free( 1008 count, start - count, 1009 (unsigned long long)la_start_blk, 1010 (unsigned long long)blkno); 1011 1012 status = ocfs2_release_clusters(handle, 1013 main_bm_inode, 1014 main_bm_bh, blkno, 1015 count); 1016 if (status < 0) { 1017 mlog_errno(status); 1018 goto bail; 1019 } 1020 } 1021 if (bit_off >= left) 1022 break; 1023 count = 1; 1024 start = bit_off + 1; 1025 } 1026 1027bail: 1028 if (status) 1029 mlog_errno(status); 1030 return status; 1031} 1032 1033enum ocfs2_la_event { 1034 OCFS2_LA_EVENT_SLIDE, /* Normal window slide. */ 1035 OCFS2_LA_EVENT_FRAGMENTED, /* The global bitmap has 1036 * enough bits theoretically 1037 * free, but a contiguous 1038 * allocation could not be 1039 * found. */ 1040 OCFS2_LA_EVENT_ENOSPC, /* Global bitmap doesn't have 1041 * enough bits free to satisfy 1042 * our request. */ 1043}; 1044#define OCFS2_LA_ENABLE_INTERVAL (30 * HZ) 1045/* 1046 * Given an event, calculate the size of our next local alloc window. 1047 * 1048 * This should always be called under i_mutex of the local alloc inode 1049 * so that local alloc disabling doesn't race with processes trying to 1050 * use the allocator. 1051 * 1052 * Returns the state which the local alloc was left in. This value can 1053 * be ignored by some paths. 1054 */ 1055static int ocfs2_recalc_la_window(struct ocfs2_super *osb, 1056 enum ocfs2_la_event event) 1057{ 1058 unsigned int bits; 1059 int state; 1060 1061 spin_lock(&osb->osb_lock); 1062 if (osb->local_alloc_state == OCFS2_LA_DISABLED) { 1063 WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED); 1064 goto out_unlock; 1065 } 1066 1067 /* 1068 * ENOSPC and fragmentation are treated similarly for now. 1069 */ 1070 if (event == OCFS2_LA_EVENT_ENOSPC || 1071 event == OCFS2_LA_EVENT_FRAGMENTED) { 1072 /* 1073 * We ran out of contiguous space in the primary 1074 * bitmap. Drastically reduce the number of bits used 1075 * by local alloc until we have to disable it. 1076 */ 1077 bits = osb->local_alloc_bits >> 1; 1078 if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) { 1079 /* 1080 * By setting state to THROTTLED, we'll keep 1081 * the number of local alloc bits used down 1082 * until an event occurs which would give us 1083 * reason to assume the bitmap situation might 1084 * have changed. 1085 */ 1086 osb->local_alloc_state = OCFS2_LA_THROTTLED; 1087 osb->local_alloc_bits = bits; 1088 } else { 1089 osb->local_alloc_state = OCFS2_LA_DISABLED; 1090 } 1091 queue_delayed_work(ocfs2_wq, &osb->la_enable_wq, 1092 OCFS2_LA_ENABLE_INTERVAL); 1093 goto out_unlock; 1094 } 1095 1096 /* 1097 * Don't increase the size of the local alloc window until we 1098 * know we might be able to fulfill the request. Otherwise, we 1099 * risk bouncing around the global bitmap during periods of 1100 * low space. 1101 */ 1102 if (osb->local_alloc_state != OCFS2_LA_THROTTLED) 1103 osb->local_alloc_bits = osb->local_alloc_default_bits; 1104 1105out_unlock: 1106 state = osb->local_alloc_state; 1107 spin_unlock(&osb->osb_lock); 1108 1109 return state; 1110} 1111 1112static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb, 1113 struct ocfs2_alloc_context **ac, 1114 struct inode **bitmap_inode, 1115 struct buffer_head **bitmap_bh) 1116{ 1117 int status; 1118 1119 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 1120 if (!(*ac)) { 1121 status = -ENOMEM; 1122 mlog_errno(status); 1123 goto bail; 1124 } 1125 1126retry_enospc: 1127 (*ac)->ac_bits_wanted = osb->local_alloc_bits; 1128 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac); 1129 if (status == -ENOSPC) { 1130 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) == 1131 OCFS2_LA_DISABLED) 1132 goto bail; 1133 1134 ocfs2_free_ac_resource(*ac); 1135 memset(*ac, 0, sizeof(struct ocfs2_alloc_context)); 1136 goto retry_enospc; 1137 } 1138 if (status < 0) { 1139 mlog_errno(status); 1140 goto bail; 1141 } 1142 1143 *bitmap_inode = (*ac)->ac_inode; 1144 igrab(*bitmap_inode); 1145 *bitmap_bh = (*ac)->ac_bh; 1146 get_bh(*bitmap_bh); 1147 status = 0; 1148bail: 1149 if ((status < 0) && *ac) { 1150 ocfs2_free_alloc_context(*ac); 1151 *ac = NULL; 1152 } 1153 1154 if (status) 1155 mlog_errno(status); 1156 return status; 1157} 1158 1159/* 1160 * pass it the bitmap lock in lock_bh if you have it. 1161 */ 1162static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb, 1163 handle_t *handle, 1164 struct ocfs2_alloc_context *ac) 1165{ 1166 int status = 0; 1167 u32 cluster_off, cluster_count; 1168 struct ocfs2_dinode *alloc = NULL; 1169 struct ocfs2_local_alloc *la; 1170 1171 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 1172 la = OCFS2_LOCAL_ALLOC(alloc); 1173 1174 trace_ocfs2_local_alloc_new_window( 1175 le32_to_cpu(alloc->id1.bitmap1.i_total), 1176 osb->local_alloc_bits); 1177 1178 /* Instruct the allocation code to try the most recently used 1179 * cluster group. We'll re-record the group used this pass 1180 * below. */ 1181 ac->ac_last_group = osb->la_last_gd; 1182 1183 /* we used the generic suballoc reserve function, but we set 1184 * everything up nicely, so there's no reason why we can't use 1185 * the more specific cluster api to claim bits. */ 1186 status = ocfs2_claim_clusters(handle, ac, osb->local_alloc_bits, 1187 &cluster_off, &cluster_count); 1188 if (status == -ENOSPC) { 1189retry_enospc: 1190 /* 1191 * Note: We could also try syncing the journal here to 1192 * allow use of any free bits which the current 1193 * transaction can't give us access to. --Mark 1194 */ 1195 if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) == 1196 OCFS2_LA_DISABLED) 1197 goto bail; 1198 1199 ac->ac_bits_wanted = osb->local_alloc_bits; 1200 status = ocfs2_claim_clusters(handle, ac, 1201 osb->local_alloc_bits, 1202 &cluster_off, 1203 &cluster_count); 1204 if (status == -ENOSPC) 1205 goto retry_enospc; 1206 /* 1207 * We only shrunk the *minimum* number of in our 1208 * request - it's entirely possible that the allocator 1209 * might give us more than we asked for. 1210 */ 1211 if (status == 0) { 1212 spin_lock(&osb->osb_lock); 1213 osb->local_alloc_bits = cluster_count; 1214 spin_unlock(&osb->osb_lock); 1215 } 1216 } 1217 if (status < 0) { 1218 if (status != -ENOSPC) 1219 mlog_errno(status); 1220 goto bail; 1221 } 1222 1223 osb->la_last_gd = ac->ac_last_group; 1224 1225 la->la_bm_off = cpu_to_le32(cluster_off); 1226 alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count); 1227 /* just in case... In the future when we find space ourselves, 1228 * we don't have to get all contiguous -- but we'll have to 1229 * set all previously used bits in bitmap and update 1230 * la_bits_set before setting the bits in the main bitmap. */ 1231 alloc->id1.bitmap1.i_used = 0; 1232 memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0, 1233 le16_to_cpu(la->la_size)); 1234 1235 ocfs2_resmap_restart(&osb->osb_la_resmap, cluster_count, 1236 OCFS2_LOCAL_ALLOC(alloc)->la_bitmap); 1237 1238 trace_ocfs2_local_alloc_new_window_result( 1239 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off, 1240 le32_to_cpu(alloc->id1.bitmap1.i_total)); 1241 1242bail: 1243 if (status) 1244 mlog_errno(status); 1245 return status; 1246} 1247 1248/* Note that we do *NOT* lock the local alloc inode here as 1249 * it's been locked already for us. */ 1250static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb, 1251 struct inode *local_alloc_inode) 1252{ 1253 int status = 0; 1254 struct buffer_head *main_bm_bh = NULL; 1255 struct inode *main_bm_inode = NULL; 1256 handle_t *handle = NULL; 1257 struct ocfs2_dinode *alloc; 1258 struct ocfs2_dinode *alloc_copy = NULL; 1259 struct ocfs2_alloc_context *ac = NULL; 1260 1261 ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE); 1262 1263 /* This will lock the main bitmap for us. */ 1264 status = ocfs2_local_alloc_reserve_for_window(osb, 1265 &ac, 1266 &main_bm_inode, 1267 &main_bm_bh); 1268 if (status < 0) { 1269 if (status != -ENOSPC) 1270 mlog_errno(status); 1271 goto bail; 1272 } 1273 1274 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 1275 if (IS_ERR(handle)) { 1276 status = PTR_ERR(handle); 1277 handle = NULL; 1278 mlog_errno(status); 1279 goto bail; 1280 } 1281 1282 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 1283 1284 /* We want to clear the local alloc before doing anything 1285 * else, so that if we error later during this operation, 1286 * local alloc shutdown won't try to double free main bitmap 1287 * bits. Make a copy so the sync function knows which bits to 1288 * free. */ 1289 alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_NOFS); 1290 if (!alloc_copy) { 1291 status = -ENOMEM; 1292 mlog_errno(status); 1293 goto bail; 1294 } 1295 memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size); 1296 1297 status = ocfs2_journal_access_di(handle, 1298 INODE_CACHE(local_alloc_inode), 1299 osb->local_alloc_bh, 1300 OCFS2_JOURNAL_ACCESS_WRITE); 1301 if (status < 0) { 1302 mlog_errno(status); 1303 goto bail; 1304 } 1305 1306 ocfs2_clear_local_alloc(alloc); 1307 ocfs2_journal_dirty(handle, osb->local_alloc_bh); 1308 1309 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy, 1310 main_bm_inode, main_bm_bh); 1311 if (status < 0) { 1312 mlog_errno(status); 1313 goto bail; 1314 } 1315 1316 status = ocfs2_local_alloc_new_window(osb, handle, ac); 1317 if (status < 0) { 1318 if (status != -ENOSPC) 1319 mlog_errno(status); 1320 goto bail; 1321 } 1322 1323 atomic_inc(&osb->alloc_stats.moves); 1324 1325bail: 1326 if (handle) 1327 ocfs2_commit_trans(osb, handle); 1328 1329 brelse(main_bm_bh); 1330 1331 if (main_bm_inode) 1332 iput(main_bm_inode); 1333 1334 kfree(alloc_copy); 1335 1336 if (ac) 1337 ocfs2_free_alloc_context(ac); 1338 1339 if (status) 1340 mlog_errno(status); 1341 return status; 1342} 1343 1344