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