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 50 static inline int ocfs2_local_alloc_window_bits(struct ocfs2_super *osb); 51 52 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc); 53 54 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, 55 struct ocfs2_dinode *alloc, 56 u32 numbits); 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 * 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 */ 85 static 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 */ 96 int 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 113 int 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 177 bail: 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.*/ 195 void 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 282 out_commit: 283 ocfs2_commit_trans(osb, handle); 284 285 out_unlock: 286 if (main_bm_bh) 287 brelse(main_bm_bh); 288 289 ocfs2_meta_unlock(main_bm_inode, 1); 290 291 out_mutex: 292 mutex_unlock(&main_bm_inode->i_mutex); 293 iput(main_bm_inode); 294 295 out: 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 */ 312 int 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 357 bail: 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 */ 381 int 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 426 out_unlock: 427 ocfs2_meta_unlock(main_bm_inode, 1); 428 429 out_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 437 out: 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 */ 449 int 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; 516 bail: 517 if (status < 0 && local_alloc_inode) 518 iput(local_alloc_inode); 519 520 mlog_exit(status); 521 return status; 522 } 523 524 int 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; 581 bail: 582 mlog_exit(status); 583 return status; 584 } 585 586 static 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 603 static 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 657 bail: 658 mlog_exit(bitoff); 659 return bitoff; 660 } 661 662 static 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 #if 0 678 /* turn this on and uncomment below to aid debugging window shifts. */ 679 static void ocfs2_verify_zero_bits(unsigned long *bitmap, 680 unsigned int start, 681 unsigned int count) 682 { 683 unsigned int tmp = count; 684 while(tmp--) { 685 if (ocfs2_test_bit(start + tmp, bitmap)) { 686 printk("ocfs2_verify_zero_bits: start = %u, count = " 687 "%u\n", start, count); 688 printk("ocfs2_verify_zero_bits: bit %u is set!", 689 start + tmp); 690 BUG(); 691 } 692 } 693 } 694 #endif 695 696 /* 697 * sync the local alloc to main bitmap. 698 * 699 * assumes you've already locked the main bitmap -- the bitmap inode 700 * passed is used for caching. 701 */ 702 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, 703 handle_t *handle, 704 struct ocfs2_dinode *alloc, 705 struct inode *main_bm_inode, 706 struct buffer_head *main_bm_bh) 707 { 708 int status = 0; 709 int bit_off, left, count, start; 710 u64 la_start_blk; 711 u64 blkno; 712 void *bitmap; 713 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 714 715 mlog_entry("total = %u, COUNT = %u, used = %u\n", 716 le32_to_cpu(alloc->id1.bitmap1.i_total), 717 ocfs2_local_alloc_count_bits(alloc), 718 le32_to_cpu(alloc->id1.bitmap1.i_used)); 719 720 if (!alloc->id1.bitmap1.i_total) { 721 mlog(0, "nothing to sync!\n"); 722 goto bail; 723 } 724 725 if (le32_to_cpu(alloc->id1.bitmap1.i_used) == 726 le32_to_cpu(alloc->id1.bitmap1.i_total)) { 727 mlog(0, "all bits were taken!\n"); 728 goto bail; 729 } 730 731 la_start_blk = ocfs2_clusters_to_blocks(osb->sb, 732 le32_to_cpu(la->la_bm_off)); 733 bitmap = la->la_bitmap; 734 start = count = bit_off = 0; 735 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 736 737 while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start)) 738 != -1) { 739 if ((bit_off < left) && (bit_off == start)) { 740 count++; 741 start++; 742 continue; 743 } 744 if (count) { 745 blkno = la_start_blk + 746 ocfs2_clusters_to_blocks(osb->sb, 747 start - count); 748 749 mlog(0, "freeing %u bits starting at local alloc bit " 750 "%u (la_start_blk = %llu, blkno = %llu)\n", 751 count, start - count, 752 (unsigned long long)la_start_blk, 753 (unsigned long long)blkno); 754 755 status = ocfs2_free_clusters(handle, main_bm_inode, 756 main_bm_bh, blkno, count); 757 if (status < 0) { 758 mlog_errno(status); 759 goto bail; 760 } 761 } 762 if (bit_off >= left) 763 break; 764 count = 1; 765 start = bit_off + 1; 766 } 767 768 bail: 769 mlog_exit(status); 770 return status; 771 } 772 773 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb, 774 struct ocfs2_alloc_context **ac, 775 struct inode **bitmap_inode, 776 struct buffer_head **bitmap_bh) 777 { 778 int status; 779 780 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 781 if (!(*ac)) { 782 status = -ENOMEM; 783 mlog_errno(status); 784 goto bail; 785 } 786 787 (*ac)->ac_bits_wanted = ocfs2_local_alloc_window_bits(osb); 788 789 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac); 790 if (status < 0) { 791 if (status != -ENOSPC) 792 mlog_errno(status); 793 goto bail; 794 } 795 796 *bitmap_inode = (*ac)->ac_inode; 797 igrab(*bitmap_inode); 798 *bitmap_bh = (*ac)->ac_bh; 799 get_bh(*bitmap_bh); 800 status = 0; 801 bail: 802 if ((status < 0) && *ac) { 803 ocfs2_free_alloc_context(*ac); 804 *ac = NULL; 805 } 806 807 mlog_exit(status); 808 return status; 809 } 810 811 /* 812 * pass it the bitmap lock in lock_bh if you have it. 813 */ 814 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb, 815 handle_t *handle, 816 struct ocfs2_alloc_context *ac) 817 { 818 int status = 0; 819 u32 cluster_off, cluster_count; 820 struct ocfs2_dinode *alloc = NULL; 821 struct ocfs2_local_alloc *la; 822 823 mlog_entry_void(); 824 825 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 826 la = OCFS2_LOCAL_ALLOC(alloc); 827 828 if (alloc->id1.bitmap1.i_total) 829 mlog(0, "asking me to alloc a new window over a non-empty " 830 "one\n"); 831 832 mlog(0, "Allocating %u clusters for a new window.\n", 833 ocfs2_local_alloc_window_bits(osb)); 834 835 /* Instruct the allocation code to try the most recently used 836 * cluster group. We'll re-record the group used this pass 837 * below. */ 838 ac->ac_last_group = osb->la_last_gd; 839 840 /* we used the generic suballoc reserve function, but we set 841 * everything up nicely, so there's no reason why we can't use 842 * the more specific cluster api to claim bits. */ 843 status = ocfs2_claim_clusters(osb, handle, ac, 844 ocfs2_local_alloc_window_bits(osb), 845 &cluster_off, &cluster_count); 846 if (status < 0) { 847 if (status != -ENOSPC) 848 mlog_errno(status); 849 goto bail; 850 } 851 852 osb->la_last_gd = ac->ac_last_group; 853 854 la->la_bm_off = cpu_to_le32(cluster_off); 855 alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count); 856 /* just in case... In the future when we find space ourselves, 857 * we don't have to get all contiguous -- but we'll have to 858 * set all previously used bits in bitmap and update 859 * la_bits_set before setting the bits in the main bitmap. */ 860 alloc->id1.bitmap1.i_used = 0; 861 memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0, 862 le16_to_cpu(la->la_size)); 863 864 mlog(0, "New window allocated:\n"); 865 mlog(0, "window la_bm_off = %u\n", 866 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off); 867 mlog(0, "window bits = %u\n", le32_to_cpu(alloc->id1.bitmap1.i_total)); 868 869 bail: 870 mlog_exit(status); 871 return status; 872 } 873 874 /* Note that we do *NOT* lock the local alloc inode here as 875 * it's been locked already for us. */ 876 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb, 877 struct inode *local_alloc_inode) 878 { 879 int status = 0; 880 struct buffer_head *main_bm_bh = NULL; 881 struct inode *main_bm_inode = NULL; 882 handle_t *handle = NULL; 883 struct ocfs2_dinode *alloc; 884 struct ocfs2_dinode *alloc_copy = NULL; 885 struct ocfs2_alloc_context *ac = NULL; 886 887 mlog_entry_void(); 888 889 /* This will lock the main bitmap for us. */ 890 status = ocfs2_local_alloc_reserve_for_window(osb, 891 &ac, 892 &main_bm_inode, 893 &main_bm_bh); 894 if (status < 0) { 895 if (status != -ENOSPC) 896 mlog_errno(status); 897 goto bail; 898 } 899 900 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 901 if (IS_ERR(handle)) { 902 status = PTR_ERR(handle); 903 handle = NULL; 904 mlog_errno(status); 905 goto bail; 906 } 907 908 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 909 910 /* We want to clear the local alloc before doing anything 911 * else, so that if we error later during this operation, 912 * local alloc shutdown won't try to double free main bitmap 913 * bits. Make a copy so the sync function knows which bits to 914 * free. */ 915 alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_KERNEL); 916 if (!alloc_copy) { 917 status = -ENOMEM; 918 mlog_errno(status); 919 goto bail; 920 } 921 memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size); 922 923 status = ocfs2_journal_access(handle, local_alloc_inode, 924 osb->local_alloc_bh, 925 OCFS2_JOURNAL_ACCESS_WRITE); 926 if (status < 0) { 927 mlog_errno(status); 928 goto bail; 929 } 930 931 ocfs2_clear_local_alloc(alloc); 932 933 status = ocfs2_journal_dirty(handle, osb->local_alloc_bh); 934 if (status < 0) { 935 mlog_errno(status); 936 goto bail; 937 } 938 939 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy, 940 main_bm_inode, main_bm_bh); 941 if (status < 0) { 942 mlog_errno(status); 943 goto bail; 944 } 945 946 status = ocfs2_local_alloc_new_window(osb, handle, ac); 947 if (status < 0) { 948 if (status != -ENOSPC) 949 mlog_errno(status); 950 goto bail; 951 } 952 953 atomic_inc(&osb->alloc_stats.moves); 954 955 status = 0; 956 bail: 957 if (handle) 958 ocfs2_commit_trans(osb, handle); 959 960 if (main_bm_bh) 961 brelse(main_bm_bh); 962 963 if (main_bm_inode) 964 iput(main_bm_inode); 965 966 if (alloc_copy) 967 kfree(alloc_copy); 968 969 if (ac) 970 ocfs2_free_alloc_context(ac); 971 972 mlog_exit(status); 973 return status; 974 } 975 976