1 /* 2 * linux/fs/ext4/balloc.c 3 * 4 * Copyright (C) 1992, 1993, 1994, 1995 5 * Remy Card (card@masi.ibp.fr) 6 * Laboratoire MASI - Institut Blaise Pascal 7 * Universite Pierre et Marie Curie (Paris VI) 8 * 9 * Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993 10 * Big-endian to little-endian byte-swapping/bitmaps by 11 * David S. Miller (davem@caip.rutgers.edu), 1995 12 */ 13 14 #include <linux/time.h> 15 #include <linux/capability.h> 16 #include <linux/fs.h> 17 #include <linux/jbd2.h> 18 #include <linux/quotaops.h> 19 #include <linux/buffer_head.h> 20 #include "ext4.h" 21 #include "ext4_jbd2.h" 22 #include "mballoc.h" 23 24 /* 25 * balloc.c contains the blocks allocation and deallocation routines 26 */ 27 28 /* 29 * Calculate the block group number and offset, given a block number 30 */ 31 void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr, 32 ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp) 33 { 34 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 35 ext4_grpblk_t offset; 36 37 blocknr = blocknr - le32_to_cpu(es->s_first_data_block); 38 offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb)); 39 if (offsetp) 40 *offsetp = offset; 41 if (blockgrpp) 42 *blockgrpp = blocknr; 43 44 } 45 46 static int ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block, 47 ext4_group_t block_group) 48 { 49 ext4_group_t actual_group; 50 ext4_get_group_no_and_offset(sb, block, &actual_group, NULL); 51 if (actual_group == block_group) 52 return 1; 53 return 0; 54 } 55 56 static int ext4_group_used_meta_blocks(struct super_block *sb, 57 ext4_group_t block_group, 58 struct ext4_group_desc *gdp) 59 { 60 ext4_fsblk_t tmp; 61 struct ext4_sb_info *sbi = EXT4_SB(sb); 62 /* block bitmap, inode bitmap, and inode table blocks */ 63 int used_blocks = sbi->s_itb_per_group + 2; 64 65 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { 66 if (!ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), 67 block_group)) 68 used_blocks--; 69 70 if (!ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp), 71 block_group)) 72 used_blocks--; 73 74 tmp = ext4_inode_table(sb, gdp); 75 for (; tmp < ext4_inode_table(sb, gdp) + 76 sbi->s_itb_per_group; tmp++) { 77 if (!ext4_block_in_group(sb, tmp, block_group)) 78 used_blocks -= 1; 79 } 80 } 81 return used_blocks; 82 } 83 84 /* Initializes an uninitialized block bitmap if given, and returns the 85 * number of blocks free in the group. */ 86 unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh, 87 ext4_group_t block_group, struct ext4_group_desc *gdp) 88 { 89 int bit, bit_max; 90 ext4_group_t ngroups = ext4_get_groups_count(sb); 91 unsigned free_blocks, group_blocks; 92 struct ext4_sb_info *sbi = EXT4_SB(sb); 93 94 if (bh) { 95 J_ASSERT_BH(bh, buffer_locked(bh)); 96 97 /* If checksum is bad mark all blocks used to prevent allocation 98 * essentially implementing a per-group read-only flag. */ 99 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) { 100 ext4_error(sb, __func__, 101 "Checksum bad for group %u", block_group); 102 ext4_free_blks_set(sb, gdp, 0); 103 ext4_free_inodes_set(sb, gdp, 0); 104 ext4_itable_unused_set(sb, gdp, 0); 105 memset(bh->b_data, 0xff, sb->s_blocksize); 106 return 0; 107 } 108 memset(bh->b_data, 0, sb->s_blocksize); 109 } 110 111 /* Check for superblock and gdt backups in this group */ 112 bit_max = ext4_bg_has_super(sb, block_group); 113 114 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) || 115 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) * 116 sbi->s_desc_per_block) { 117 if (bit_max) { 118 bit_max += ext4_bg_num_gdb(sb, block_group); 119 bit_max += 120 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks); 121 } 122 } else { /* For META_BG_BLOCK_GROUPS */ 123 bit_max += ext4_bg_num_gdb(sb, block_group); 124 } 125 126 if (block_group == ngroups - 1) { 127 /* 128 * Even though mke2fs always initialize first and last group 129 * if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need 130 * to make sure we calculate the right free blocks 131 */ 132 group_blocks = ext4_blocks_count(sbi->s_es) - 133 le32_to_cpu(sbi->s_es->s_first_data_block) - 134 (EXT4_BLOCKS_PER_GROUP(sb) * (ngroups - 1)); 135 } else { 136 group_blocks = EXT4_BLOCKS_PER_GROUP(sb); 137 } 138 139 free_blocks = group_blocks - bit_max; 140 141 if (bh) { 142 ext4_fsblk_t start, tmp; 143 int flex_bg = 0; 144 145 for (bit = 0; bit < bit_max; bit++) 146 ext4_set_bit(bit, bh->b_data); 147 148 start = ext4_group_first_block_no(sb, block_group); 149 150 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 151 EXT4_FEATURE_INCOMPAT_FLEX_BG)) 152 flex_bg = 1; 153 154 /* Set bits for block and inode bitmaps, and inode table */ 155 tmp = ext4_block_bitmap(sb, gdp); 156 if (!flex_bg || ext4_block_in_group(sb, tmp, block_group)) 157 ext4_set_bit(tmp - start, bh->b_data); 158 159 tmp = ext4_inode_bitmap(sb, gdp); 160 if (!flex_bg || ext4_block_in_group(sb, tmp, block_group)) 161 ext4_set_bit(tmp - start, bh->b_data); 162 163 tmp = ext4_inode_table(sb, gdp); 164 for (; tmp < ext4_inode_table(sb, gdp) + 165 sbi->s_itb_per_group; tmp++) { 166 if (!flex_bg || 167 ext4_block_in_group(sb, tmp, block_group)) 168 ext4_set_bit(tmp - start, bh->b_data); 169 } 170 /* 171 * Also if the number of blocks within the group is 172 * less than the blocksize * 8 ( which is the size 173 * of bitmap ), set rest of the block bitmap to 1 174 */ 175 mark_bitmap_end(group_blocks, sb->s_blocksize * 8, bh->b_data); 176 } 177 return free_blocks - ext4_group_used_meta_blocks(sb, block_group, gdp); 178 } 179 180 181 /* 182 * The free blocks are managed by bitmaps. A file system contains several 183 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap 184 * block for inodes, N blocks for the inode table and data blocks. 185 * 186 * The file system contains group descriptors which are located after the 187 * super block. Each descriptor contains the number of the bitmap block and 188 * the free blocks count in the block. The descriptors are loaded in memory 189 * when a file system is mounted (see ext4_fill_super). 190 */ 191 192 193 #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1) 194 195 /** 196 * ext4_get_group_desc() -- load group descriptor from disk 197 * @sb: super block 198 * @block_group: given block group 199 * @bh: pointer to the buffer head to store the block 200 * group descriptor 201 */ 202 struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb, 203 ext4_group_t block_group, 204 struct buffer_head **bh) 205 { 206 unsigned int group_desc; 207 unsigned int offset; 208 ext4_group_t ngroups = ext4_get_groups_count(sb); 209 struct ext4_group_desc *desc; 210 struct ext4_sb_info *sbi = EXT4_SB(sb); 211 212 if (block_group >= ngroups) { 213 ext4_error(sb, "ext4_get_group_desc", 214 "block_group >= groups_count - " 215 "block_group = %u, groups_count = %u", 216 block_group, ngroups); 217 218 return NULL; 219 } 220 221 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb); 222 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1); 223 if (!sbi->s_group_desc[group_desc]) { 224 ext4_error(sb, "ext4_get_group_desc", 225 "Group descriptor not loaded - " 226 "block_group = %u, group_desc = %u, desc = %u", 227 block_group, group_desc, offset); 228 return NULL; 229 } 230 231 desc = (struct ext4_group_desc *)( 232 (__u8 *)sbi->s_group_desc[group_desc]->b_data + 233 offset * EXT4_DESC_SIZE(sb)); 234 if (bh) 235 *bh = sbi->s_group_desc[group_desc]; 236 return desc; 237 } 238 239 static int ext4_valid_block_bitmap(struct super_block *sb, 240 struct ext4_group_desc *desc, 241 unsigned int block_group, 242 struct buffer_head *bh) 243 { 244 ext4_grpblk_t offset; 245 ext4_grpblk_t next_zero_bit; 246 ext4_fsblk_t bitmap_blk; 247 ext4_fsblk_t group_first_block; 248 249 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { 250 /* with FLEX_BG, the inode/block bitmaps and itable 251 * blocks may not be in the group at all 252 * so the bitmap validation will be skipped for those groups 253 * or it has to also read the block group where the bitmaps 254 * are located to verify they are set. 255 */ 256 return 1; 257 } 258 group_first_block = ext4_group_first_block_no(sb, block_group); 259 260 /* check whether block bitmap block number is set */ 261 bitmap_blk = ext4_block_bitmap(sb, desc); 262 offset = bitmap_blk - group_first_block; 263 if (!ext4_test_bit(offset, bh->b_data)) 264 /* bad block bitmap */ 265 goto err_out; 266 267 /* check whether the inode bitmap block number is set */ 268 bitmap_blk = ext4_inode_bitmap(sb, desc); 269 offset = bitmap_blk - group_first_block; 270 if (!ext4_test_bit(offset, bh->b_data)) 271 /* bad block bitmap */ 272 goto err_out; 273 274 /* check whether the inode table block number is set */ 275 bitmap_blk = ext4_inode_table(sb, desc); 276 offset = bitmap_blk - group_first_block; 277 next_zero_bit = ext4_find_next_zero_bit(bh->b_data, 278 offset + EXT4_SB(sb)->s_itb_per_group, 279 offset); 280 if (next_zero_bit >= offset + EXT4_SB(sb)->s_itb_per_group) 281 /* good bitmap for inode tables */ 282 return 1; 283 284 err_out: 285 ext4_error(sb, __func__, 286 "Invalid block bitmap - " 287 "block_group = %d, block = %llu", 288 block_group, bitmap_blk); 289 return 0; 290 } 291 /** 292 * ext4_read_block_bitmap() 293 * @sb: super block 294 * @block_group: given block group 295 * 296 * Read the bitmap for a given block_group,and validate the 297 * bits for block/inode/inode tables are set in the bitmaps 298 * 299 * Return buffer_head on success or NULL in case of failure. 300 */ 301 struct buffer_head * 302 ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group) 303 { 304 struct ext4_group_desc *desc; 305 struct buffer_head *bh = NULL; 306 ext4_fsblk_t bitmap_blk; 307 308 desc = ext4_get_group_desc(sb, block_group, NULL); 309 if (!desc) 310 return NULL; 311 bitmap_blk = ext4_block_bitmap(sb, desc); 312 bh = sb_getblk(sb, bitmap_blk); 313 if (unlikely(!bh)) { 314 ext4_error(sb, __func__, 315 "Cannot read block bitmap - " 316 "block_group = %u, block_bitmap = %llu", 317 block_group, bitmap_blk); 318 return NULL; 319 } 320 321 if (bitmap_uptodate(bh)) 322 return bh; 323 324 lock_buffer(bh); 325 if (bitmap_uptodate(bh)) { 326 unlock_buffer(bh); 327 return bh; 328 } 329 ext4_lock_group(sb, block_group); 330 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) { 331 ext4_init_block_bitmap(sb, bh, block_group, desc); 332 set_bitmap_uptodate(bh); 333 set_buffer_uptodate(bh); 334 ext4_unlock_group(sb, block_group); 335 unlock_buffer(bh); 336 return bh; 337 } 338 ext4_unlock_group(sb, block_group); 339 if (buffer_uptodate(bh)) { 340 /* 341 * if not uninit if bh is uptodate, 342 * bitmap is also uptodate 343 */ 344 set_bitmap_uptodate(bh); 345 unlock_buffer(bh); 346 return bh; 347 } 348 /* 349 * submit the buffer_head for read. We can 350 * safely mark the bitmap as uptodate now. 351 * We do it here so the bitmap uptodate bit 352 * get set with buffer lock held. 353 */ 354 set_bitmap_uptodate(bh); 355 if (bh_submit_read(bh) < 0) { 356 put_bh(bh); 357 ext4_error(sb, __func__, 358 "Cannot read block bitmap - " 359 "block_group = %u, block_bitmap = %llu", 360 block_group, bitmap_blk); 361 return NULL; 362 } 363 ext4_valid_block_bitmap(sb, desc, block_group, bh); 364 /* 365 * file system mounted not to panic on error, 366 * continue with corrupt bitmap 367 */ 368 return bh; 369 } 370 371 /** 372 * ext4_add_groupblocks() -- Add given blocks to an existing group 373 * @handle: handle to this transaction 374 * @sb: super block 375 * @block: start physcial block to add to the block group 376 * @count: number of blocks to free 377 * 378 * This marks the blocks as free in the bitmap. We ask the 379 * mballoc to reload the buddy after this by setting group 380 * EXT4_GROUP_INFO_NEED_INIT_BIT flag 381 */ 382 void ext4_add_groupblocks(handle_t *handle, struct super_block *sb, 383 ext4_fsblk_t block, unsigned long count) 384 { 385 struct buffer_head *bitmap_bh = NULL; 386 struct buffer_head *gd_bh; 387 ext4_group_t block_group; 388 ext4_grpblk_t bit; 389 unsigned int i; 390 struct ext4_group_desc *desc; 391 struct ext4_super_block *es; 392 struct ext4_sb_info *sbi; 393 int err = 0, ret, blk_free_count; 394 ext4_grpblk_t blocks_freed; 395 struct ext4_group_info *grp; 396 397 sbi = EXT4_SB(sb); 398 es = sbi->s_es; 399 ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1); 400 401 ext4_get_group_no_and_offset(sb, block, &block_group, &bit); 402 grp = ext4_get_group_info(sb, block_group); 403 /* 404 * Check to see if we are freeing blocks across a group 405 * boundary. 406 */ 407 if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) { 408 goto error_return; 409 } 410 bitmap_bh = ext4_read_block_bitmap(sb, block_group); 411 if (!bitmap_bh) 412 goto error_return; 413 desc = ext4_get_group_desc(sb, block_group, &gd_bh); 414 if (!desc) 415 goto error_return; 416 417 if (in_range(ext4_block_bitmap(sb, desc), block, count) || 418 in_range(ext4_inode_bitmap(sb, desc), block, count) || 419 in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) || 420 in_range(block + count - 1, ext4_inode_table(sb, desc), 421 sbi->s_itb_per_group)) { 422 ext4_error(sb, __func__, 423 "Adding blocks in system zones - " 424 "Block = %llu, count = %lu", 425 block, count); 426 goto error_return; 427 } 428 429 /* 430 * We are about to add blocks to the bitmap, 431 * so we need undo access. 432 */ 433 BUFFER_TRACE(bitmap_bh, "getting undo access"); 434 err = ext4_journal_get_undo_access(handle, bitmap_bh); 435 if (err) 436 goto error_return; 437 438 /* 439 * We are about to modify some metadata. Call the journal APIs 440 * to unshare ->b_data if a currently-committing transaction is 441 * using it 442 */ 443 BUFFER_TRACE(gd_bh, "get_write_access"); 444 err = ext4_journal_get_write_access(handle, gd_bh); 445 if (err) 446 goto error_return; 447 /* 448 * make sure we don't allow a parallel init on other groups in the 449 * same buddy cache 450 */ 451 down_write(&grp->alloc_sem); 452 for (i = 0, blocks_freed = 0; i < count; i++) { 453 BUFFER_TRACE(bitmap_bh, "clear bit"); 454 if (!ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group), 455 bit + i, bitmap_bh->b_data)) { 456 ext4_error(sb, __func__, 457 "bit already cleared for block %llu", 458 (ext4_fsblk_t)(block + i)); 459 BUFFER_TRACE(bitmap_bh, "bit already cleared"); 460 } else { 461 blocks_freed++; 462 } 463 } 464 ext4_lock_group(sb, block_group); 465 blk_free_count = blocks_freed + ext4_free_blks_count(sb, desc); 466 ext4_free_blks_set(sb, desc, blk_free_count); 467 desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc); 468 ext4_unlock_group(sb, block_group); 469 percpu_counter_add(&sbi->s_freeblocks_counter, blocks_freed); 470 471 if (sbi->s_log_groups_per_flex) { 472 ext4_group_t flex_group = ext4_flex_group(sbi, block_group); 473 atomic_add(blocks_freed, 474 &sbi->s_flex_groups[flex_group].free_blocks); 475 } 476 /* 477 * request to reload the buddy with the 478 * new bitmap information 479 */ 480 set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &(grp->bb_state)); 481 grp->bb_free += blocks_freed; 482 up_write(&grp->alloc_sem); 483 484 /* We dirtied the bitmap block */ 485 BUFFER_TRACE(bitmap_bh, "dirtied bitmap block"); 486 err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh); 487 488 /* And the group descriptor block */ 489 BUFFER_TRACE(gd_bh, "dirtied group descriptor block"); 490 ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh); 491 if (!err) 492 err = ret; 493 sb->s_dirt = 1; 494 495 error_return: 496 brelse(bitmap_bh); 497 ext4_std_error(sb, err); 498 return; 499 } 500 501 /** 502 * ext4_has_free_blocks() 503 * @sbi: in-core super block structure. 504 * @nblocks: number of needed blocks 505 * 506 * Check if filesystem has nblocks free & available for allocation. 507 * On success return 1, return 0 on failure. 508 */ 509 int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks) 510 { 511 s64 free_blocks, dirty_blocks, root_blocks; 512 struct percpu_counter *fbc = &sbi->s_freeblocks_counter; 513 struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter; 514 515 free_blocks = percpu_counter_read_positive(fbc); 516 dirty_blocks = percpu_counter_read_positive(dbc); 517 root_blocks = ext4_r_blocks_count(sbi->s_es); 518 519 if (free_blocks - (nblocks + root_blocks + dirty_blocks) < 520 EXT4_FREEBLOCKS_WATERMARK) { 521 free_blocks = percpu_counter_sum_positive(fbc); 522 dirty_blocks = percpu_counter_sum_positive(dbc); 523 if (dirty_blocks < 0) { 524 printk(KERN_CRIT "Dirty block accounting " 525 "went wrong %lld\n", 526 (long long)dirty_blocks); 527 } 528 } 529 /* Check whether we have space after 530 * accounting for current dirty blocks & root reserved blocks. 531 */ 532 if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks)) 533 return 1; 534 535 /* Hm, nope. Are (enough) root reserved blocks available? */ 536 if (sbi->s_resuid == current_fsuid() || 537 ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) || 538 capable(CAP_SYS_RESOURCE)) { 539 if (free_blocks >= (nblocks + dirty_blocks)) 540 return 1; 541 } 542 543 return 0; 544 } 545 546 int ext4_claim_free_blocks(struct ext4_sb_info *sbi, 547 s64 nblocks) 548 { 549 if (ext4_has_free_blocks(sbi, nblocks)) { 550 percpu_counter_add(&sbi->s_dirtyblocks_counter, nblocks); 551 return 0; 552 } else 553 return -ENOSPC; 554 } 555 556 /** 557 * ext4_should_retry_alloc() 558 * @sb: super block 559 * @retries number of attemps has been made 560 * 561 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if 562 * it is profitable to retry the operation, this function will wait 563 * for the current or commiting transaction to complete, and then 564 * return TRUE. 565 * 566 * if the total number of retries exceed three times, return FALSE. 567 */ 568 int ext4_should_retry_alloc(struct super_block *sb, int *retries) 569 { 570 if (!ext4_has_free_blocks(EXT4_SB(sb), 1) || 571 (*retries)++ > 3 || 572 !EXT4_SB(sb)->s_journal) 573 return 0; 574 575 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id); 576 577 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal); 578 } 579 580 /* 581 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks 582 * 583 * @handle: handle to this transaction 584 * @inode: file inode 585 * @goal: given target block(filesystem wide) 586 * @count: pointer to total number of blocks needed 587 * @errp: error code 588 * 589 * Return 1st allocated block number on success, *count stores total account 590 * error stores in errp pointer 591 */ 592 ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode, 593 ext4_fsblk_t goal, unsigned long *count, int *errp) 594 { 595 struct ext4_allocation_request ar; 596 ext4_fsblk_t ret; 597 598 memset(&ar, 0, sizeof(ar)); 599 /* Fill with neighbour allocated blocks */ 600 ar.inode = inode; 601 ar.goal = goal; 602 ar.len = count ? *count : 1; 603 604 ret = ext4_mb_new_blocks(handle, &ar, errp); 605 if (count) 606 *count = ar.len; 607 608 /* 609 * Account for the allocated meta blocks 610 */ 611 if (!(*errp) && EXT4_I(inode)->i_delalloc_reserved_flag) { 612 spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 613 EXT4_I(inode)->i_allocated_meta_blocks += ar.len; 614 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 615 } 616 return ret; 617 } 618 619 /** 620 * ext4_count_free_blocks() -- count filesystem free blocks 621 * @sb: superblock 622 * 623 * Adds up the number of free blocks from each block group. 624 */ 625 ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb) 626 { 627 ext4_fsblk_t desc_count; 628 struct ext4_group_desc *gdp; 629 ext4_group_t i; 630 ext4_group_t ngroups = ext4_get_groups_count(sb); 631 #ifdef EXT4FS_DEBUG 632 struct ext4_super_block *es; 633 ext4_fsblk_t bitmap_count; 634 unsigned int x; 635 struct buffer_head *bitmap_bh = NULL; 636 637 es = EXT4_SB(sb)->s_es; 638 desc_count = 0; 639 bitmap_count = 0; 640 gdp = NULL; 641 642 for (i = 0; i < ngroups; i++) { 643 gdp = ext4_get_group_desc(sb, i, NULL); 644 if (!gdp) 645 continue; 646 desc_count += ext4_free_blks_count(sb, gdp); 647 brelse(bitmap_bh); 648 bitmap_bh = ext4_read_block_bitmap(sb, i); 649 if (bitmap_bh == NULL) 650 continue; 651 652 x = ext4_count_free(bitmap_bh, sb->s_blocksize); 653 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n", 654 i, ext4_free_blks_count(sb, gdp), x); 655 bitmap_count += x; 656 } 657 brelse(bitmap_bh); 658 printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu" 659 ", computed = %llu, %llu\n", ext4_free_blocks_count(es), 660 desc_count, bitmap_count); 661 return bitmap_count; 662 #else 663 desc_count = 0; 664 for (i = 0; i < ngroups; i++) { 665 gdp = ext4_get_group_desc(sb, i, NULL); 666 if (!gdp) 667 continue; 668 desc_count += ext4_free_blks_count(sb, gdp); 669 } 670 671 return desc_count; 672 #endif 673 } 674 675 static inline int test_root(ext4_group_t a, int b) 676 { 677 int num = b; 678 679 while (a > num) 680 num *= b; 681 return num == a; 682 } 683 684 static int ext4_group_sparse(ext4_group_t group) 685 { 686 if (group <= 1) 687 return 1; 688 if (!(group & 1)) 689 return 0; 690 return (test_root(group, 7) || test_root(group, 5) || 691 test_root(group, 3)); 692 } 693 694 /** 695 * ext4_bg_has_super - number of blocks used by the superblock in group 696 * @sb: superblock for filesystem 697 * @group: group number to check 698 * 699 * Return the number of blocks used by the superblock (primary or backup) 700 * in this group. Currently this will be only 0 or 1. 701 */ 702 int ext4_bg_has_super(struct super_block *sb, ext4_group_t group) 703 { 704 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 705 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) && 706 !ext4_group_sparse(group)) 707 return 0; 708 return 1; 709 } 710 711 static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb, 712 ext4_group_t group) 713 { 714 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 715 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb); 716 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1; 717 718 if (group == first || group == first + 1 || group == last) 719 return 1; 720 return 0; 721 } 722 723 static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb, 724 ext4_group_t group) 725 { 726 if (!ext4_bg_has_super(sb, group)) 727 return 0; 728 729 if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG)) 730 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 731 else 732 return EXT4_SB(sb)->s_gdb_count; 733 } 734 735 /** 736 * ext4_bg_num_gdb - number of blocks used by the group table in group 737 * @sb: superblock for filesystem 738 * @group: group number to check 739 * 740 * Return the number of blocks used by the group descriptor table 741 * (primary or backup) in this group. In the future there may be a 742 * different number of descriptor blocks in each group. 743 */ 744 unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group) 745 { 746 unsigned long first_meta_bg = 747 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 748 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 749 750 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) || 751 metagroup < first_meta_bg) 752 return ext4_bg_num_gdb_nometa(sb, group); 753 754 return ext4_bg_num_gdb_meta(sb,group); 755 756 } 757 758