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 ac->ac_inode = local_alloc_inode; 475 ac->ac_which = OCFS2_AC_USE_LOCAL; 476 477 if (osb->local_alloc_state != OCFS2_LA_ENABLED) { 478 status = -ENOSPC; 479 goto bail; 480 } 481 482 if (bits_wanted > ocfs2_local_alloc_window_bits(osb)) { 483 mlog(0, "Asking for more than my max window size!\n"); 484 status = -ENOSPC; 485 goto bail; 486 } 487 488 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 489 490 if (le32_to_cpu(alloc->id1.bitmap1.i_used) != 491 ocfs2_local_alloc_count_bits(alloc)) { 492 ocfs2_error(osb->sb, "local alloc inode %llu says it has " 493 "%u free bits, but a count shows %u", 494 (unsigned long long)le64_to_cpu(alloc->i_blkno), 495 le32_to_cpu(alloc->id1.bitmap1.i_used), 496 ocfs2_local_alloc_count_bits(alloc)); 497 status = -EIO; 498 goto bail; 499 } 500 501 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) - 502 le32_to_cpu(alloc->id1.bitmap1.i_used); 503 if (bits_wanted > free_bits) { 504 /* uhoh, window change time. */ 505 status = 506 ocfs2_local_alloc_slide_window(osb, local_alloc_inode); 507 if (status < 0) { 508 if (status != -ENOSPC) 509 mlog_errno(status); 510 goto bail; 511 } 512 } 513 514 get_bh(osb->local_alloc_bh); 515 ac->ac_bh = osb->local_alloc_bh; 516 status = 0; 517 bail: 518 519 mlog_exit(status); 520 return status; 521 } 522 523 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb, 524 handle_t *handle, 525 struct ocfs2_alloc_context *ac, 526 u32 min_bits, 527 u32 *bit_off, 528 u32 *num_bits) 529 { 530 int status, start; 531 struct inode *local_alloc_inode; 532 u32 bits_wanted; 533 void *bitmap; 534 struct ocfs2_dinode *alloc; 535 struct ocfs2_local_alloc *la; 536 537 mlog_entry_void(); 538 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL); 539 540 bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given; 541 local_alloc_inode = ac->ac_inode; 542 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 543 la = OCFS2_LOCAL_ALLOC(alloc); 544 545 start = ocfs2_local_alloc_find_clear_bits(osb, alloc, bits_wanted); 546 if (start == -1) { 547 /* TODO: Shouldn't we just BUG here? */ 548 status = -ENOSPC; 549 mlog_errno(status); 550 goto bail; 551 } 552 553 bitmap = la->la_bitmap; 554 *bit_off = le32_to_cpu(la->la_bm_off) + start; 555 /* local alloc is always contiguous by nature -- we never 556 * delete bits from it! */ 557 *num_bits = bits_wanted; 558 559 status = ocfs2_journal_access(handle, local_alloc_inode, 560 osb->local_alloc_bh, 561 OCFS2_JOURNAL_ACCESS_WRITE); 562 if (status < 0) { 563 mlog_errno(status); 564 goto bail; 565 } 566 567 while(bits_wanted--) 568 ocfs2_set_bit(start++, bitmap); 569 570 alloc->id1.bitmap1.i_used = cpu_to_le32(*num_bits + 571 le32_to_cpu(alloc->id1.bitmap1.i_used)); 572 573 status = ocfs2_journal_dirty(handle, osb->local_alloc_bh); 574 if (status < 0) { 575 mlog_errno(status); 576 goto bail; 577 } 578 579 status = 0; 580 bail: 581 mlog_exit(status); 582 return status; 583 } 584 585 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc) 586 { 587 int i; 588 u8 *buffer; 589 u32 count = 0; 590 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 591 592 mlog_entry_void(); 593 594 buffer = la->la_bitmap; 595 for (i = 0; i < le16_to_cpu(la->la_size); i++) 596 count += hweight8(buffer[i]); 597 598 mlog_exit(count); 599 return count; 600 } 601 602 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb, 603 struct ocfs2_dinode *alloc, 604 u32 numbits) 605 { 606 int numfound, bitoff, left, startoff, lastzero; 607 void *bitmap = NULL; 608 609 mlog_entry("(numbits wanted = %u)\n", numbits); 610 611 if (!alloc->id1.bitmap1.i_total) { 612 mlog(0, "No bits in my window!\n"); 613 bitoff = -1; 614 goto bail; 615 } 616 617 bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap; 618 619 numfound = bitoff = startoff = 0; 620 lastzero = -1; 621 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 622 while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) { 623 if (bitoff == left) { 624 /* mlog(0, "bitoff (%d) == left", bitoff); */ 625 break; 626 } 627 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, " 628 "numfound = %d\n", bitoff, startoff, numfound);*/ 629 630 /* Ok, we found a zero bit... is it contig. or do we 631 * start over?*/ 632 if (bitoff == startoff) { 633 /* we found a zero */ 634 numfound++; 635 startoff++; 636 } else { 637 /* got a zero after some ones */ 638 numfound = 1; 639 startoff = bitoff+1; 640 } 641 /* we got everything we needed */ 642 if (numfound == numbits) { 643 /* mlog(0, "Found it all!\n"); */ 644 break; 645 } 646 } 647 648 mlog(0, "Exiting loop, bitoff = %d, numfound = %d\n", bitoff, 649 numfound); 650 651 if (numfound == numbits) 652 bitoff = startoff - numfound; 653 else 654 bitoff = -1; 655 656 bail: 657 mlog_exit(bitoff); 658 return bitoff; 659 } 660 661 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc) 662 { 663 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 664 int i; 665 mlog_entry_void(); 666 667 alloc->id1.bitmap1.i_total = 0; 668 alloc->id1.bitmap1.i_used = 0; 669 la->la_bm_off = 0; 670 for(i = 0; i < le16_to_cpu(la->la_size); i++) 671 la->la_bitmap[i] = 0; 672 673 mlog_exit_void(); 674 } 675 676 #if 0 677 /* turn this on and uncomment below to aid debugging window shifts. */ 678 static void ocfs2_verify_zero_bits(unsigned long *bitmap, 679 unsigned int start, 680 unsigned int count) 681 { 682 unsigned int tmp = count; 683 while(tmp--) { 684 if (ocfs2_test_bit(start + tmp, bitmap)) { 685 printk("ocfs2_verify_zero_bits: start = %u, count = " 686 "%u\n", start, count); 687 printk("ocfs2_verify_zero_bits: bit %u is set!", 688 start + tmp); 689 BUG(); 690 } 691 } 692 } 693 #endif 694 695 /* 696 * sync the local alloc to main bitmap. 697 * 698 * assumes you've already locked the main bitmap -- the bitmap inode 699 * passed is used for caching. 700 */ 701 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb, 702 handle_t *handle, 703 struct ocfs2_dinode *alloc, 704 struct inode *main_bm_inode, 705 struct buffer_head *main_bm_bh) 706 { 707 int status = 0; 708 int bit_off, left, count, start; 709 u64 la_start_blk; 710 u64 blkno; 711 void *bitmap; 712 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc); 713 714 mlog_entry("total = %u, COUNT = %u, used = %u\n", 715 le32_to_cpu(alloc->id1.bitmap1.i_total), 716 ocfs2_local_alloc_count_bits(alloc), 717 le32_to_cpu(alloc->id1.bitmap1.i_used)); 718 719 if (!alloc->id1.bitmap1.i_total) { 720 mlog(0, "nothing to sync!\n"); 721 goto bail; 722 } 723 724 if (le32_to_cpu(alloc->id1.bitmap1.i_used) == 725 le32_to_cpu(alloc->id1.bitmap1.i_total)) { 726 mlog(0, "all bits were taken!\n"); 727 goto bail; 728 } 729 730 la_start_blk = ocfs2_clusters_to_blocks(osb->sb, 731 le32_to_cpu(la->la_bm_off)); 732 bitmap = la->la_bitmap; 733 start = count = bit_off = 0; 734 left = le32_to_cpu(alloc->id1.bitmap1.i_total); 735 736 while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start)) 737 != -1) { 738 if ((bit_off < left) && (bit_off == start)) { 739 count++; 740 start++; 741 continue; 742 } 743 if (count) { 744 blkno = la_start_blk + 745 ocfs2_clusters_to_blocks(osb->sb, 746 start - count); 747 748 mlog(0, "freeing %u bits starting at local alloc bit " 749 "%u (la_start_blk = %llu, blkno = %llu)\n", 750 count, start - count, 751 (unsigned long long)la_start_blk, 752 (unsigned long long)blkno); 753 754 status = ocfs2_free_clusters(handle, main_bm_inode, 755 main_bm_bh, blkno, count); 756 if (status < 0) { 757 mlog_errno(status); 758 goto bail; 759 } 760 } 761 if (bit_off >= left) 762 break; 763 count = 1; 764 start = bit_off + 1; 765 } 766 767 bail: 768 mlog_exit(status); 769 return status; 770 } 771 772 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb, 773 struct ocfs2_alloc_context **ac, 774 struct inode **bitmap_inode, 775 struct buffer_head **bitmap_bh) 776 { 777 int status; 778 779 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 780 if (!(*ac)) { 781 status = -ENOMEM; 782 mlog_errno(status); 783 goto bail; 784 } 785 786 (*ac)->ac_bits_wanted = ocfs2_local_alloc_window_bits(osb); 787 788 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac); 789 if (status < 0) { 790 if (status != -ENOSPC) 791 mlog_errno(status); 792 goto bail; 793 } 794 795 *bitmap_inode = (*ac)->ac_inode; 796 igrab(*bitmap_inode); 797 *bitmap_bh = (*ac)->ac_bh; 798 get_bh(*bitmap_bh); 799 status = 0; 800 bail: 801 if ((status < 0) && *ac) { 802 ocfs2_free_alloc_context(*ac); 803 *ac = NULL; 804 } 805 806 mlog_exit(status); 807 return status; 808 } 809 810 /* 811 * pass it the bitmap lock in lock_bh if you have it. 812 */ 813 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb, 814 handle_t *handle, 815 struct ocfs2_alloc_context *ac) 816 { 817 int status = 0; 818 u32 cluster_off, cluster_count; 819 struct ocfs2_dinode *alloc = NULL; 820 struct ocfs2_local_alloc *la; 821 822 mlog_entry_void(); 823 824 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 825 la = OCFS2_LOCAL_ALLOC(alloc); 826 827 if (alloc->id1.bitmap1.i_total) 828 mlog(0, "asking me to alloc a new window over a non-empty " 829 "one\n"); 830 831 mlog(0, "Allocating %u clusters for a new window.\n", 832 ocfs2_local_alloc_window_bits(osb)); 833 834 /* Instruct the allocation code to try the most recently used 835 * cluster group. We'll re-record the group used this pass 836 * below. */ 837 ac->ac_last_group = osb->la_last_gd; 838 839 /* we used the generic suballoc reserve function, but we set 840 * everything up nicely, so there's no reason why we can't use 841 * the more specific cluster api to claim bits. */ 842 status = ocfs2_claim_clusters(osb, handle, ac, 843 ocfs2_local_alloc_window_bits(osb), 844 &cluster_off, &cluster_count); 845 if (status < 0) { 846 if (status != -ENOSPC) 847 mlog_errno(status); 848 goto bail; 849 } 850 851 osb->la_last_gd = ac->ac_last_group; 852 853 la->la_bm_off = cpu_to_le32(cluster_off); 854 alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count); 855 /* just in case... In the future when we find space ourselves, 856 * we don't have to get all contiguous -- but we'll have to 857 * set all previously used bits in bitmap and update 858 * la_bits_set before setting the bits in the main bitmap. */ 859 alloc->id1.bitmap1.i_used = 0; 860 memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0, 861 le16_to_cpu(la->la_size)); 862 863 mlog(0, "New window allocated:\n"); 864 mlog(0, "window la_bm_off = %u\n", 865 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off); 866 mlog(0, "window bits = %u\n", le32_to_cpu(alloc->id1.bitmap1.i_total)); 867 868 bail: 869 mlog_exit(status); 870 return status; 871 } 872 873 /* Note that we do *NOT* lock the local alloc inode here as 874 * it's been locked already for us. */ 875 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb, 876 struct inode *local_alloc_inode) 877 { 878 int status = 0; 879 struct buffer_head *main_bm_bh = NULL; 880 struct inode *main_bm_inode = NULL; 881 handle_t *handle = NULL; 882 struct ocfs2_dinode *alloc; 883 struct ocfs2_dinode *alloc_copy = NULL; 884 struct ocfs2_alloc_context *ac = NULL; 885 886 mlog_entry_void(); 887 888 /* This will lock the main bitmap for us. */ 889 status = ocfs2_local_alloc_reserve_for_window(osb, 890 &ac, 891 &main_bm_inode, 892 &main_bm_bh); 893 if (status < 0) { 894 if (status != -ENOSPC) 895 mlog_errno(status); 896 goto bail; 897 } 898 899 handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS); 900 if (IS_ERR(handle)) { 901 status = PTR_ERR(handle); 902 handle = NULL; 903 mlog_errno(status); 904 goto bail; 905 } 906 907 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data; 908 909 /* We want to clear the local alloc before doing anything 910 * else, so that if we error later during this operation, 911 * local alloc shutdown won't try to double free main bitmap 912 * bits. Make a copy so the sync function knows which bits to 913 * free. */ 914 alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_KERNEL); 915 if (!alloc_copy) { 916 status = -ENOMEM; 917 mlog_errno(status); 918 goto bail; 919 } 920 memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size); 921 922 status = ocfs2_journal_access(handle, local_alloc_inode, 923 osb->local_alloc_bh, 924 OCFS2_JOURNAL_ACCESS_WRITE); 925 if (status < 0) { 926 mlog_errno(status); 927 goto bail; 928 } 929 930 ocfs2_clear_local_alloc(alloc); 931 932 status = ocfs2_journal_dirty(handle, osb->local_alloc_bh); 933 if (status < 0) { 934 mlog_errno(status); 935 goto bail; 936 } 937 938 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy, 939 main_bm_inode, main_bm_bh); 940 if (status < 0) { 941 mlog_errno(status); 942 goto bail; 943 } 944 945 status = ocfs2_local_alloc_new_window(osb, handle, ac); 946 if (status < 0) { 947 if (status != -ENOSPC) 948 mlog_errno(status); 949 goto bail; 950 } 951 952 atomic_inc(&osb->alloc_stats.moves); 953 954 status = 0; 955 bail: 956 if (handle) 957 ocfs2_commit_trans(osb, handle); 958 959 if (main_bm_bh) 960 brelse(main_bm_bh); 961 962 if (main_bm_inode) 963 iput(main_bm_inode); 964 965 if (alloc_copy) 966 kfree(alloc_copy); 967 968 if (ac) 969 ocfs2_free_alloc_context(ac); 970 971 mlog_exit(status); 972 return status; 973 } 974 975