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#define MLOG_MASK_PREFIX ML_DISK_ALLOC 33#include <cluster/masklog.h> 34 35#include "ocfs2.h" 36 37#include "alloc.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 46#include "buffer_head_io.h" 47 48#define OCFS2_LOCAL_ALLOC(dinode) (&((dinode)->id2.i_lab)) 49 50static inline int ocfs2_local_alloc_window_bits(struct ocfs2_super *osb); 51 52static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc); 53 54static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, 55 struct ocfs2_dinode *alloc, 56 u32 numbits); 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 * Determine how large our local alloc window should be, in bits. 80 * 81 * These values (and the behavior in ocfs2_alloc_should_use_local) have 82 * been chosen so that most allocations, including new block groups go 83 * through local alloc. 84 */ 85static inline int ocfs2_local_alloc_window_bits(struct ocfs2_super *osb) 86{ 87 BUG_ON(osb->s_clustersize_bits < 12); 88 89 return 2048 >> (osb->s_clustersize_bits - 12); 90} 91 92/* 93 * Tell us whether a given allocation should use the local alloc 94 * file. Otherwise, it has to go to the main bitmap. 95 */ 96int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits) 97{ 98 int la_bits = ocfs2_local_alloc_window_bits(osb); 99 100 if (osb->local_alloc_state != OCFS2_LA_ENABLED) 101 return 0; 102 103 /* la_bits should be at least twice the size (in clusters) of 104 * a new block group. We want to be sure block group 105 * allocations go through the local alloc, so allow an 106 * allocation to take up to half the bitmap. */ 107 if (bits > (la_bits / 2)) 108 return 0; 109 110 return 1; 111} 112 113int ocfs2_load_local_alloc(struct ocfs2_super *osb) 114{ 115 int status = 0; 116 struct ocfs2_dinode *alloc = NULL; 117 struct buffer_head *alloc_bh = NULL; 118 u32 num_used; 119 struct inode *inode = NULL; 120 struct ocfs2_local_alloc *la; 121 122 mlog_entry_void(); 123 124 /* read the alloc off disk */ 125 inode = ocfs2_get_system_file_inode(osb, LOCAL_ALLOC_SYSTEM_INODE, 126 osb->slot_num); 127 if (!inode) { 128 status = -EINVAL; 129 mlog_errno(status); 130 goto bail; 131 } 132 133 status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, 134 &alloc_bh, 0, inode); 135 if (status < 0) { 136 mlog_errno(status); 137 goto bail; 138 } 139 140 alloc = (struct ocfs2_dinode *) alloc_bh->b_data; 141 la = OCFS2_LOCAL_ALLOC(alloc); 142 143 if (!(le32_to_cpu(alloc->i_flags) & 144 (OCFS2_LOCAL_ALLOC_FL|OCFS2_BITMAP_FL))) { 145 mlog(ML_ERROR, "Invalid local alloc inode, %llu\n", 146 (unsigned long long)OCFS2_I(inode)->ip_blkno); 147 status = -EINVAL; 148 goto bail; 149 } 150 151 if ((la->la_size == 0) || 152 (le16_to_cpu(la->la_size) > ocfs2_local_alloc_size(inode->i_sb))) { 153 mlog(ML_ERROR, "Local alloc size is invalid (la_size = %u)\n", 154 le16_to_cpu(la->la_size)); 155 status = -EINVAL; 156 goto bail; 157 } 158 159 /* do a little verification. */ 160 num_used = ocfs2_local_alloc_count_bits(alloc); 161 162 /* hopefully the local alloc has always been recovered before 163 * we load it. */ 164 if (num_used 165 || alloc->id1.bitmap1.i_used 166 || alloc->id1.bitmap1.i_total 167 || la->la_bm_off) 168 mlog(ML_ERROR, "Local alloc hasn't been recovered!\n" 169 "found = %u, set = %u, taken = %u, off = %u\n", 170 num_used, le32_to_cpu(alloc->id1.bitmap1.i_used), 171 le32_to_cpu(alloc->id1.bitmap1.i_total), 172 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off); 173 174 osb->local_alloc_bh = alloc_bh; 175 osb->local_alloc_state = OCFS2_LA_ENABLED; 176 177bail: 178 if (status < 0) 179 if (alloc_bh) 180 brelse(alloc_bh); 181 if (inode) 182 iput(inode); 183 184 mlog_exit(status); 185 return status; 186} 187 188/* 189 * return any unused bits to the bitmap and write out a clean 190 * local_alloc. 191 * 192 * local_alloc_bh is optional. If not passed, we will simply use the 193 * one off osb. If you do pass it however, be warned that it *will* be 194 * returned brelse'd and NULL'd out.*/ 195void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb) 196{ 197 int status; 198 handle_t *handle; 199 struct inode *local_alloc_inode = NULL; 200 struct buffer_head *bh = NULL; 201 struct buffer_head *main_bm_bh = NULL; 202 struct inode *main_bm_inode = NULL; 203 struct ocfs2_dinode *alloc_copy = NULL; 204 struct ocfs2_dinode *alloc = NULL; 205 206 mlog_entry_void(); 207 208 if (osb->local_alloc_state == OCFS2_LA_UNUSED) 209 goto out; 210 211 local_alloc_inode = 212 ocfs2_get_system_file_inode(osb, 213 LOCAL_ALLOC_SYSTEM_INODE, 214 osb->slot_num); 215 if (!local_alloc_inode) { 216 status = -ENOENT; 217 mlog_errno(status); 218 goto out; 219 } 220 221 osb->local_alloc_state = OCFS2_LA_DISABLED; 222 223 main_bm_inode = ocfs2_get_system_file_inode(osb, 224 GLOBAL_BITMAP_SYSTEM_INODE, 225 OCFS2_INVALID_SLOT); 226 if (!main_bm_inode) { 227 status = -EINVAL; 228 mlog_errno(status); 229 goto out; 230 } 231 232 mutex_lock(&main_bm_inode->i_mutex); 233 234 status = ocfs2_meta_lock(main_bm_inode, &main_bm_bh, 1); 235 if (status < 0) { 236 mlog_errno(status); 237 goto out_mutex; 238 } 239 240 /* WINDOW_MOVE_CREDITS is a bit heavy... */ 241 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 242 if (IS_ERR(handle)) { 243 mlog_errno(PTR_ERR(handle)); 244 handle = NULL; 245 goto out_unlock; 246 } 247 248 bh = osb->local_alloc_bh; 249 alloc = (struct ocfs2_dinode *) bh->b_data; 250 251 alloc_copy = kmalloc(bh->b_size, GFP_KERNEL); 252 if (!alloc_copy) { 253 status = -ENOMEM; 254 goto out_commit; 255 } 256 memcpy(alloc_copy, alloc, bh->b_size); 257 258 status = ocfs2_journal_access(handle, local_alloc_inode, bh, 259 OCFS2_JOURNAL_ACCESS_WRITE); 260 if (status < 0) { 261 mlog_errno(status); 262 goto out_commit; 263 } 264 265 ocfs2_clear_local_alloc(alloc); 266 267 status = ocfs2_journal_dirty(handle, bh); 268 if (status < 0) { 269 mlog_errno(status); 270 goto out_commit; 271 } 272 273 brelse(bh); 274 osb->local_alloc_bh = NULL; 275 osb->local_alloc_state = OCFS2_LA_UNUSED; 276 277 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy, 278 main_bm_inode, main_bm_bh); 279 if (status < 0) 280 mlog_errno(status); 281 282out_commit: 283 ocfs2_commit_trans(osb, handle); 284 285out_unlock: 286 if (main_bm_bh) 287 brelse(main_bm_bh); 288 289 ocfs2_meta_unlock(main_bm_inode, 1); 290 291out_mutex: 292 mutex_unlock(&main_bm_inode->i_mutex); 293 iput(main_bm_inode); 294 295out: 296 if (local_alloc_inode) 297 iput(local_alloc_inode); 298 299 if (alloc_copy) 300 kfree(alloc_copy); 301 302 mlog_exit_void(); 303} 304 305/* 306 * We want to free the bitmap bits outside of any recovery context as 307 * we'll need a cluster lock to do so, but we must clear the local 308 * alloc before giving up the recovered nodes journal. To solve this, 309 * we kmalloc a copy of the local alloc before it's change for the 310 * caller to process with ocfs2_complete_local_alloc_recovery 311 */ 312int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb, 313 int slot_num, 314 struct ocfs2_dinode **alloc_copy) 315{ 316 int status = 0; 317 struct buffer_head *alloc_bh = NULL; 318 struct inode *inode = NULL; 319 struct ocfs2_dinode *alloc; 320 321 mlog_entry("(slot_num = %d)\n", slot_num); 322 323 *alloc_copy = NULL; 324 325 inode = ocfs2_get_system_file_inode(osb, 326 LOCAL_ALLOC_SYSTEM_INODE, 327 slot_num); 328 if (!inode) { 329 status = -EINVAL; 330 mlog_errno(status); 331 goto bail; 332 } 333 334 mutex_lock(&inode->i_mutex); 335 336 status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, 337 &alloc_bh, 0, inode); 338 if (status < 0) { 339 mlog_errno(status); 340 goto bail; 341 } 342 343 *alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL); 344 if (!(*alloc_copy)) { 345 status = -ENOMEM; 346 goto bail; 347 } 348 memcpy((*alloc_copy), alloc_bh->b_data, alloc_bh->b_size); 349 350 alloc = (struct ocfs2_dinode *) alloc_bh->b_data; 351 ocfs2_clear_local_alloc(alloc); 352 353 status = ocfs2_write_block(osb, alloc_bh, inode); 354 if (status < 0) 355 mlog_errno(status); 356 357bail: 358 if ((status < 0) && (*alloc_copy)) { 359 kfree(*alloc_copy); 360 *alloc_copy = NULL; 361 } 362 363 if (alloc_bh) 364 brelse(alloc_bh); 365 366 if (inode) { 367 mutex_unlock(&inode->i_mutex); 368 iput(inode); 369 } 370 371 mlog_exit(status); 372 return status; 373} 374 375/* 376 * Step 2: By now, we've completed the journal recovery, we've stamped 377 * a clean local alloc on disk and dropped the node out of the 378 * recovery map. Dlm locks will no longer stall, so lets clear out the 379 * main bitmap. 380 */ 381int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb, 382 struct ocfs2_dinode *alloc) 383{ 384 int status; 385 handle_t *handle; 386 struct buffer_head *main_bm_bh = NULL; 387 struct inode *main_bm_inode; 388 389 mlog_entry_void(); 390 391 main_bm_inode = ocfs2_get_system_file_inode(osb, 392 GLOBAL_BITMAP_SYSTEM_INODE, 393 OCFS2_INVALID_SLOT); 394 if (!main_bm_inode) { 395 status = -EINVAL; 396 mlog_errno(status); 397 goto out; 398 } 399 400 mutex_lock(&main_bm_inode->i_mutex); 401 402 status = ocfs2_meta_lock(main_bm_inode, &main_bm_bh, 1); 403 if (status < 0) { 404 mlog_errno(status); 405 goto out_mutex; 406 } 407 408 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 409 if (IS_ERR(handle)) { 410 status = PTR_ERR(handle); 411 handle = NULL; 412 mlog_errno(status); 413 goto out_unlock; 414 } 415 416 /* we want the bitmap change to be recorded on disk asap */ 417 handle->h_sync = 1; 418 419 status = ocfs2_sync_local_to_main(osb, handle, alloc, 420 main_bm_inode, main_bm_bh); 421 if (status < 0) 422 mlog_errno(status); 423 424 ocfs2_commit_trans(osb, handle); 425 426out_unlock: 427 ocfs2_meta_unlock(main_bm_inode, 1); 428 429out_mutex: 430 mutex_unlock(&main_bm_inode->i_mutex); 431 432 if (main_bm_bh) 433 brelse(main_bm_bh); 434 435 iput(main_bm_inode); 436 437out: 438 mlog_exit(status); 439 return status; 440} 441 442/* 443 * make sure we've got at least bitswanted contiguous bits in the 444 * local alloc. You lose them when you drop i_mutex. 445 * 446 * We will add ourselves to the transaction passed in, but may start 447 * our own in order to shift windows. 448 */ 449int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb, 450 u32 bits_wanted, 451 struct ocfs2_alloc_context *ac) 452{ 453 int status; 454 struct ocfs2_dinode *alloc; 455 struct inode *local_alloc_inode; 456 unsigned int free_bits; 457 458 mlog_entry_void(); 459 460 BUG_ON(!ac); 461 462 local_alloc_inode = 463 ocfs2_get_system_file_inode(osb, 464 LOCAL_ALLOC_SYSTEM_INODE, 465 osb->slot_num); 466 if (!local_alloc_inode) { 467 status = -ENOENT; 468 mlog_errno(status); 469 goto bail; 470 } 471 472 mutex_lock(&local_alloc_inode->i_mutex); 473 474 if (osb->local_alloc_state != OCFS2_LA_ENABLED) { 475 status = -ENOSPC; 476 goto bail; 477 } 478 479 if (bits_wanted > ocfs2_local_alloc_window_bits(osb)) { 480 mlog(0, "Asking for more than my max window size!\n"); 481 status = -ENOSPC; 482 goto bail; 483 } 484 485 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 486 487 if (le32_to_cpu(alloc->id1.bitmap1.i_used) != 488 ocfs2_local_alloc_count_bits(alloc)) { 489 ocfs2_error(osb->sb, "local alloc inode %llu says it has " 490 "%u free bits, but a count shows %u", 491 (unsigned long long)le64_to_cpu(alloc->i_blkno), 492 le32_to_cpu(alloc->id1.bitmap1.i_used), 493 ocfs2_local_alloc_count_bits(alloc)); 494 status = -EIO; 495 goto bail; 496 } 497 498 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) - 499 le32_to_cpu(alloc->id1.bitmap1.i_used); 500 if (bits_wanted > free_bits) { 501 /* uhoh, window change time. */ 502 status = 503 ocfs2_local_alloc_slide_window(osb, local_alloc_inode); 504 if (status < 0) { 505 if (status != -ENOSPC) 506 mlog_errno(status); 507 goto bail; 508 } 509 } 510 511 ac->ac_inode = local_alloc_inode; 512 ac->ac_which = OCFS2_AC_USE_LOCAL; 513 get_bh(osb->local_alloc_bh); 514 ac->ac_bh = osb->local_alloc_bh; 515 status = 0; 516bail: 517 if (status < 0 && local_alloc_inode) 518 iput(local_alloc_inode); 519 520 mlog_exit(status); 521 return status; 522} 523 524int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb, 525 handle_t *handle, 526 struct ocfs2_alloc_context *ac, 527 u32 min_bits, 528 u32 *bit_off, 529 u32 *num_bits) 530{ 531 int status, start; 532 struct inode *local_alloc_inode; 533 u32 bits_wanted; 534 void *bitmap; 535 struct ocfs2_dinode *alloc; 536 struct ocfs2_local_alloc *la; 537 538 mlog_entry_void(); 539 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL); 540 541 bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given; 542 local_alloc_inode = ac->ac_inode; 543 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 544 la = OCFS2_LOCAL_ALLOC(alloc); 545 546 start = ocfs2_local_alloc_find_clear_bits(osb, alloc, bits_wanted); 547 if (start == -1) { 548 /* TODO: Shouldn't we just BUG here? */ 549 status = -ENOSPC; 550 mlog_errno(status); 551 goto bail; 552 } 553 554 bitmap = la->la_bitmap; 555 *bit_off = le32_to_cpu(la->la_bm_off) + start; 556 /* local alloc is always contiguous by nature -- we never 557 * delete bits from it! */ 558 *num_bits = bits_wanted; 559 560 status = ocfs2_journal_access(handle, local_alloc_inode, 561 osb->local_alloc_bh, 562 OCFS2_JOURNAL_ACCESS_WRITE); 563 if (status < 0) { 564 mlog_errno(status); 565 goto bail; 566 } 567 568 while(bits_wanted--) 569 ocfs2_set_bit(start++, bitmap); 570 571 alloc->id1.bitmap1.i_used = cpu_to_le32(*num_bits + 572 le32_to_cpu(alloc->id1.bitmap1.i_used)); 573 574 status = ocfs2_journal_dirty(handle, osb->local_alloc_bh); 575 if (status < 0) { 576 mlog_errno(status); 577 goto bail; 578 } 579 580 status = 0; 581bail: 582 mlog_exit(status); 583 return status; 584} 585 586static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc) 587{ 588 int i; 589 u8 *buffer; 590 u32 count = 0; 591 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 592 593 mlog_entry_void(); 594 595 buffer = la->la_bitmap; 596 for (i = 0; i < le16_to_cpu(la->la_size); i++) 597 count += hweight8(buffer[i]); 598 599 mlog_exit(count); 600 return count; 601} 602 603static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, 604 struct ocfs2_dinode *alloc, 605 u32 numbits) 606{ 607 int numfound, bitoff, left, startoff, lastzero; 608 void *bitmap = NULL; 609 610 mlog_entry("(numbits wanted = %u)\n", numbits); 611 612 if (!alloc->id1.bitmap1.i_total) { 613 mlog(0, "No bits in my window!\n"); 614 bitoff = -1; 615 goto bail; 616 } 617 618 bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap; 619 620 numfound = bitoff = startoff = 0; 621 lastzero = -1; 622 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 623 while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) { 624 if (bitoff == left) { 625 /* mlog(0, "bitoff (%d) == left", bitoff); */ 626 break; 627 } 628 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, " 629 "numfound = %d\n", bitoff, startoff, numfound);*/ 630 631 /* Ok, we found a zero bit... is it contig. or do we 632 * start over?*/ 633 if (bitoff == startoff) { 634 /* we found a zero */ 635 numfound++; 636 startoff++; 637 } else { 638 /* got a zero after some ones */ 639 numfound = 1; 640 startoff = bitoff+1; 641 } 642 /* we got everything we needed */ 643 if (numfound == numbits) { 644 /* mlog(0, "Found it all!\n"); */ 645 break; 646 } 647 } 648 649 mlog(0, "Exiting loop, bitoff = %d, numfound = %d\n", bitoff, 650 numfound); 651 652 if (numfound == numbits) 653 bitoff = startoff - numfound; 654 else 655 bitoff = -1; 656 657bail: 658 mlog_exit(bitoff); 659 return bitoff; 660} 661 662static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc) 663{ 664 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 665 int i; 666 mlog_entry_void(); 667 668 alloc->id1.bitmap1.i_total = 0; 669 alloc->id1.bitmap1.i_used = 0; 670 la->la_bm_off = 0; 671 for(i = 0; i < le16_to_cpu(la->la_size); i++) 672 la->la_bitmap[i] = 0; 673 674 mlog_exit_void(); 675} 676 677 678/* 679 * sync the local alloc to main bitmap. 680 * 681 * assumes you've already locked the main bitmap -- the bitmap inode 682 * passed is used for caching. 683 */ 684static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, 685 handle_t *handle, 686 struct ocfs2_dinode *alloc, 687 struct inode *main_bm_inode, 688 struct buffer_head *main_bm_bh) 689{ 690 int status = 0; 691 int bit_off, left, count, start; 692 u64 la_start_blk; 693 u64 blkno; 694 void *bitmap; 695 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 696 697 mlog_entry("total = %u, COUNT = %u, used = %u\n", 698 le32_to_cpu(alloc->id1.bitmap1.i_total), 699 ocfs2_local_alloc_count_bits(alloc), 700 le32_to_cpu(alloc->id1.bitmap1.i_used)); 701 702 if (!alloc->id1.bitmap1.i_total) { 703 mlog(0, "nothing to sync!\n"); 704 goto bail; 705 } 706 707 if (le32_to_cpu(alloc->id1.bitmap1.i_used) == 708 le32_to_cpu(alloc->id1.bitmap1.i_total)) { 709 mlog(0, "all bits were taken!\n"); 710 goto bail; 711 } 712 713 la_start_blk = ocfs2_clusters_to_blocks(osb->sb, 714 le32_to_cpu(la->la_bm_off)); 715 bitmap = la->la_bitmap; 716 start = count = bit_off = 0; 717 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 718 719 while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start)) 720 != -1) { 721 if ((bit_off < left) && (bit_off == start)) { 722 count++; 723 start++; 724 continue; 725 } 726 if (count) { 727 blkno = la_start_blk + 728 ocfs2_clusters_to_blocks(osb->sb, 729 start - count); 730 731 mlog(0, "freeing %u bits starting at local alloc bit " 732 "%u (la_start_blk = %llu, blkno = %llu)\n", 733 count, start - count, 734 (unsigned long long)la_start_blk, 735 (unsigned long long)blkno); 736 737 status = ocfs2_free_clusters(handle, main_bm_inode, 738 main_bm_bh, blkno, count); 739 if (status < 0) { 740 mlog_errno(status); 741 goto bail; 742 } 743 } 744 if (bit_off >= left) 745 break; 746 count = 1; 747 start = bit_off + 1; 748 } 749 750bail: 751 mlog_exit(status); 752 return status; 753} 754 755static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb, 756 struct ocfs2_alloc_context **ac, 757 struct inode **bitmap_inode, 758 struct buffer_head **bitmap_bh) 759{ 760 int status; 761 762 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 763 if (!(*ac)) { 764 status = -ENOMEM; 765 mlog_errno(status); 766 goto bail; 767 } 768 769 (*ac)->ac_bits_wanted = ocfs2_local_alloc_window_bits(osb); 770 771 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac); 772 if (status < 0) { 773 if (status != -ENOSPC) 774 mlog_errno(status); 775 goto bail; 776 } 777 778 *bitmap_inode = (*ac)->ac_inode; 779 igrab(*bitmap_inode); 780 *bitmap_bh = (*ac)->ac_bh; 781 get_bh(*bitmap_bh); 782 status = 0; 783bail: 784 if ((status < 0) && *ac) { 785 ocfs2_free_alloc_context(*ac); 786 *ac = NULL; 787 } 788 789 mlog_exit(status); 790 return status; 791} 792 793/* 794 * pass it the bitmap lock in lock_bh if you have it. 795 */ 796static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb, 797 handle_t *handle, 798 struct ocfs2_alloc_context *ac) 799{ 800 int status = 0; 801 u32 cluster_off, cluster_count; 802 struct ocfs2_dinode *alloc = NULL; 803 struct ocfs2_local_alloc *la; 804 805 mlog_entry_void(); 806 807 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 808 la = OCFS2_LOCAL_ALLOC(alloc); 809 810 if (alloc->id1.bitmap1.i_total) 811 mlog(0, "asking me to alloc a new window over a non-empty " 812 "one\n"); 813 814 mlog(0, "Allocating %u clusters for a new window.\n", 815 ocfs2_local_alloc_window_bits(osb)); 816 817 /* Instruct the allocation code to try the most recently used 818 * cluster group. We'll re-record the group used this pass 819 * below. */ 820 ac->ac_last_group = osb->la_last_gd; 821 822 /* we used the generic suballoc reserve function, but we set 823 * everything up nicely, so there's no reason why we can't use 824 * the more specific cluster api to claim bits. */ 825 status = ocfs2_claim_clusters(osb, handle, ac, 826 ocfs2_local_alloc_window_bits(osb), 827 &cluster_off, &cluster_count); 828 if (status < 0) { 829 if (status != -ENOSPC) 830 mlog_errno(status); 831 goto bail; 832 } 833 834 osb->la_last_gd = ac->ac_last_group; 835 836 la->la_bm_off = cpu_to_le32(cluster_off); 837 alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count); 838 /* just in case... In the future when we find space ourselves, 839 * we don't have to get all contiguous -- but we'll have to 840 * set all previously used bits in bitmap and update 841 * la_bits_set before setting the bits in the main bitmap. */ 842 alloc->id1.bitmap1.i_used = 0; 843 memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0, 844 le16_to_cpu(la->la_size)); 845 846 mlog(0, "New window allocated:\n"); 847 mlog(0, "window la_bm_off = %u\n", 848 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off); 849 mlog(0, "window bits = %u\n", le32_to_cpu(alloc->id1.bitmap1.i_total)); 850 851bail: 852 mlog_exit(status); 853 return status; 854} 855 856/* Note that we do *NOT* lock the local alloc inode here as 857 * it's been locked already for us. */ 858static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb, 859 struct inode *local_alloc_inode) 860{ 861 int status = 0; 862 struct buffer_head *main_bm_bh = NULL; 863 struct inode *main_bm_inode = NULL; 864 handle_t *handle = NULL; 865 struct ocfs2_dinode *alloc; 866 struct ocfs2_dinode *alloc_copy = NULL; 867 struct ocfs2_alloc_context *ac = NULL; 868 869 mlog_entry_void(); 870 871 /* This will lock the main bitmap for us. */ 872 status = ocfs2_local_alloc_reserve_for_window(osb, 873 &ac, 874 &main_bm_inode, 875 &main_bm_bh); 876 if (status < 0) { 877 if (status != -ENOSPC) 878 mlog_errno(status); 879 goto bail; 880 } 881 882 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 883 if (IS_ERR(handle)) { 884 status = PTR_ERR(handle); 885 handle = NULL; 886 mlog_errno(status); 887 goto bail; 888 } 889 890 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 891 892 /* We want to clear the local alloc before doing anything 893 * else, so that if we error later during this operation, 894 * local alloc shutdown won't try to double free main bitmap 895 * bits. Make a copy so the sync function knows which bits to 896 * free. */ 897 alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_KERNEL); 898 if (!alloc_copy) { 899 status = -ENOMEM; 900 mlog_errno(status); 901 goto bail; 902 } 903 memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size); 904 905 status = ocfs2_journal_access(handle, local_alloc_inode, 906 osb->local_alloc_bh, 907 OCFS2_JOURNAL_ACCESS_WRITE); 908 if (status < 0) { 909 mlog_errno(status); 910 goto bail; 911 } 912 913 ocfs2_clear_local_alloc(alloc); 914 915 status = ocfs2_journal_dirty(handle, osb->local_alloc_bh); 916 if (status < 0) { 917 mlog_errno(status); 918 goto bail; 919 } 920 921 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy, 922 main_bm_inode, main_bm_bh); 923 if (status < 0) { 924 mlog_errno(status); 925 goto bail; 926 } 927 928 status = ocfs2_local_alloc_new_window(osb, handle, ac); 929 if (status < 0) { 930 if (status != -ENOSPC) 931 mlog_errno(status); 932 goto bail; 933 } 934 935 atomic_inc(&osb->alloc_stats.moves); 936 937 status = 0; 938bail: 939 if (handle) 940 ocfs2_commit_trans(osb, handle); 941 942 if (main_bm_bh) 943 brelse(main_bm_bh); 944 945 if (main_bm_inode) 946 iput(main_bm_inode); 947 948 if (alloc_copy) 949 kfree(alloc_copy); 950 951 if (ac) 952 ocfs2_free_alloc_context(ac); 953 954 mlog_exit(status); 955 return status; 956} 957