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