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) || (*retries)++ > 3) 613 return 0; 614 615 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id); 616 617 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal); 618 } 619 620 /* 621 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks 622 * 623 * @handle: handle to this transaction 624 * @inode: file inode 625 * @goal: given target block(filesystem wide) 626 * @count: pointer to total number of blocks needed 627 * @errp: error code 628 * 629 * Return 1st allocated block number on success, *count stores total account 630 * error stores in errp pointer 631 */ 632 ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode, 633 ext4_fsblk_t goal, unsigned long *count, int *errp) 634 { 635 struct ext4_allocation_request ar; 636 ext4_fsblk_t ret; 637 638 memset(&ar, 0, sizeof(ar)); 639 /* Fill with neighbour allocated blocks */ 640 ar.inode = inode; 641 ar.goal = goal; 642 ar.len = count ? *count : 1; 643 644 ret = ext4_mb_new_blocks(handle, &ar, errp); 645 if (count) 646 *count = ar.len; 647 648 /* 649 * Account for the allocated meta blocks 650 */ 651 if (!(*errp) && EXT4_I(inode)->i_delalloc_reserved_flag) { 652 spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 653 EXT4_I(inode)->i_allocated_meta_blocks += ar.len; 654 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 655 } 656 return ret; 657 } 658 659 /** 660 * ext4_count_free_blocks() -- count filesystem free blocks 661 * @sb: superblock 662 * 663 * Adds up the number of free blocks from each block group. 664 */ 665 ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb) 666 { 667 ext4_fsblk_t desc_count; 668 struct ext4_group_desc *gdp; 669 ext4_group_t i; 670 ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count; 671 #ifdef EXT4FS_DEBUG 672 struct ext4_super_block *es; 673 ext4_fsblk_t bitmap_count; 674 unsigned int x; 675 struct buffer_head *bitmap_bh = NULL; 676 677 es = EXT4_SB(sb)->s_es; 678 desc_count = 0; 679 bitmap_count = 0; 680 gdp = NULL; 681 682 smp_rmb(); 683 for (i = 0; i < ngroups; i++) { 684 gdp = ext4_get_group_desc(sb, i, NULL); 685 if (!gdp) 686 continue; 687 desc_count += ext4_free_blks_count(sb, gdp); 688 brelse(bitmap_bh); 689 bitmap_bh = ext4_read_block_bitmap(sb, i); 690 if (bitmap_bh == NULL) 691 continue; 692 693 x = ext4_count_free(bitmap_bh, sb->s_blocksize); 694 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n", 695 i, ext4_free_blks_count(sb, gdp), x); 696 bitmap_count += x; 697 } 698 brelse(bitmap_bh); 699 printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu" 700 ", computed = %llu, %llu\n", ext4_free_blocks_count(es), 701 desc_count, bitmap_count); 702 return bitmap_count; 703 #else 704 desc_count = 0; 705 smp_rmb(); 706 for (i = 0; i < ngroups; i++) { 707 gdp = ext4_get_group_desc(sb, i, NULL); 708 if (!gdp) 709 continue; 710 desc_count += ext4_free_blks_count(sb, gdp); 711 } 712 713 return desc_count; 714 #endif 715 } 716 717 static inline int test_root(ext4_group_t a, int b) 718 { 719 int num = b; 720 721 while (a > num) 722 num *= b; 723 return num == a; 724 } 725 726 static int ext4_group_sparse(ext4_group_t group) 727 { 728 if (group <= 1) 729 return 1; 730 if (!(group & 1)) 731 return 0; 732 return (test_root(group, 7) || test_root(group, 5) || 733 test_root(group, 3)); 734 } 735 736 /** 737 * ext4_bg_has_super - number of blocks used by the superblock in group 738 * @sb: superblock for filesystem 739 * @group: group number to check 740 * 741 * Return the number of blocks used by the superblock (primary or backup) 742 * in this group. Currently this will be only 0 or 1. 743 */ 744 int ext4_bg_has_super(struct super_block *sb, ext4_group_t group) 745 { 746 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 747 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) && 748 !ext4_group_sparse(group)) 749 return 0; 750 return 1; 751 } 752 753 static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb, 754 ext4_group_t group) 755 { 756 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 757 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb); 758 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1; 759 760 if (group == first || group == first + 1 || group == last) 761 return 1; 762 return 0; 763 } 764 765 static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb, 766 ext4_group_t group) 767 { 768 return ext4_bg_has_super(sb, group) ? EXT4_SB(sb)->s_gdb_count : 0; 769 } 770 771 /** 772 * ext4_bg_num_gdb - number of blocks used by the group table in group 773 * @sb: superblock for filesystem 774 * @group: group number to check 775 * 776 * Return the number of blocks used by the group descriptor table 777 * (primary or backup) in this group. In the future there may be a 778 * different number of descriptor blocks in each group. 779 */ 780 unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group) 781 { 782 unsigned long first_meta_bg = 783 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 784 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 785 786 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) || 787 metagroup < first_meta_bg) 788 return ext4_bg_num_gdb_nometa(sb, group); 789 790 return ext4_bg_num_gdb_meta(sb,group); 791 792 } 793 794