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 struct ext4_group_desc *gdp) 60 { 61 ext4_fsblk_t tmp; 62 struct ext4_sb_info *sbi = EXT4_SB(sb); 63 /* block bitmap, inode bitmap, and inode table blocks */ 64 int used_blocks = sbi->s_itb_per_group + 2; 65 66 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { 67 if (!ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), 68 block_group)) 69 used_blocks--; 70 71 if (!ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp), 72 block_group)) 73 used_blocks--; 74 75 tmp = ext4_inode_table(sb, gdp); 76 for (; tmp < ext4_inode_table(sb, gdp) + 77 sbi->s_itb_per_group; tmp++) { 78 if (!ext4_block_in_group(sb, tmp, block_group)) 79 used_blocks -= 1; 80 } 81 } 82 return used_blocks; 83 } 84 85 /* Initializes an uninitialized block bitmap if given, and returns the 86 * number of blocks free in the group. */ 87 unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh, 88 ext4_group_t block_group, struct ext4_group_desc *gdp) 89 { 90 int bit, bit_max; 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 == sbi->s_groups_count - 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) * (sbi->s_groups_count - 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 struct ext4_group_desc *desc; 209 struct ext4_sb_info *sbi = EXT4_SB(sb); 210 211 if (block_group >= sbi->s_groups_count) { 212 ext4_error(sb, "ext4_get_group_desc", 213 "block_group >= groups_count - " 214 "block_group = %u, groups_count = %u", 215 block_group, sbi->s_groups_count); 216 217 return NULL; 218 } 219 smp_rmb(); 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 spin_lock(sb_bgl_lock(EXT4_SB(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 spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group)); 335 unlock_buffer(bh); 336 return bh; 337 } 338 spin_unlock(sb_bgl_lock(EXT4_SB(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(sb_bgl_lock(sbi, 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 spin_lock(sb_bgl_lock(sbi, 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 spin_unlock(sb_bgl_lock(sbi, 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 ext4_mb_update_group_info(grp, 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_free_blocks() -- Free given blocks and update quota 503 * @handle: handle for this transaction 504 * @inode: inode 505 * @block: start physical block to free 506 * @count: number of blocks to count 507 * @metadata: Are these metadata blocks 508 */ 509 void ext4_free_blocks(handle_t *handle, struct inode *inode, 510 ext4_fsblk_t block, unsigned long count, 511 int metadata) 512 { 513 struct super_block *sb; 514 unsigned long dquot_freed_blocks; 515 516 /* this isn't the right place to decide whether block is metadata 517 * inode.c/extents.c knows better, but for safety ... */ 518 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) 519 metadata = 1; 520 521 /* We need to make sure we don't reuse 522 * block released untill the transaction commit. 523 * writeback mode have weak data consistency so 524 * don't force data as metadata when freeing block 525 * for writeback mode. 526 */ 527 if (metadata == 0 && !ext4_should_writeback_data(inode)) 528 metadata = 1; 529 530 sb = inode->i_sb; 531 532 ext4_mb_free_blocks(handle, inode, block, count, 533 metadata, &dquot_freed_blocks); 534 if (dquot_freed_blocks) 535 vfs_dq_free_block(inode, dquot_freed_blocks); 536 return; 537 } 538 539 /** 540 * ext4_has_free_blocks() 541 * @sbi: in-core super block structure. 542 * @nblocks: number of needed blocks 543 * 544 * Check if filesystem has nblocks free & available for allocation. 545 * On success return 1, return 0 on failure. 546 */ 547 int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks) 548 { 549 s64 free_blocks, dirty_blocks, root_blocks; 550 struct percpu_counter *fbc = &sbi->s_freeblocks_counter; 551 struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter; 552 553 free_blocks = percpu_counter_read_positive(fbc); 554 dirty_blocks = percpu_counter_read_positive(dbc); 555 root_blocks = ext4_r_blocks_count(sbi->s_es); 556 557 if (free_blocks - (nblocks + root_blocks + dirty_blocks) < 558 EXT4_FREEBLOCKS_WATERMARK) { 559 free_blocks = percpu_counter_sum_positive(fbc); 560 dirty_blocks = percpu_counter_sum_positive(dbc); 561 if (dirty_blocks < 0) { 562 printk(KERN_CRIT "Dirty block accounting " 563 "went wrong %lld\n", 564 (long long)dirty_blocks); 565 } 566 } 567 /* Check whether we have space after 568 * accounting for current dirty blocks & root reserved blocks. 569 */ 570 if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks)) 571 return 1; 572 573 /* Hm, nope. Are (enough) root reserved blocks available? */ 574 if (sbi->s_resuid == current_fsuid() || 575 ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) || 576 capable(CAP_SYS_RESOURCE)) { 577 if (free_blocks >= (nblocks + dirty_blocks)) 578 return 1; 579 } 580 581 return 0; 582 } 583 584 int ext4_claim_free_blocks(struct ext4_sb_info *sbi, 585 s64 nblocks) 586 { 587 if (ext4_has_free_blocks(sbi, nblocks)) { 588 percpu_counter_add(&sbi->s_dirtyblocks_counter, nblocks); 589 return 0; 590 } else 591 return -ENOSPC; 592 } 593 594 /** 595 * ext4_should_retry_alloc() 596 * @sb: super block 597 * @retries number of attemps has been made 598 * 599 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if 600 * it is profitable to retry the operation, this function will wait 601 * for the current or commiting transaction to complete, and then 602 * return TRUE. 603 * 604 * if the total number of retries exceed three times, return FALSE. 605 */ 606 int ext4_should_retry_alloc(struct super_block *sb, int *retries) 607 { 608 if (!ext4_has_free_blocks(EXT4_SB(sb), 1) || 609 (*retries)++ > 3 || 610 !EXT4_SB(sb)->s_journal) 611 return 0; 612 613 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id); 614 615 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal); 616 } 617 618 /* 619 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks 620 * 621 * @handle: handle to this transaction 622 * @inode: file inode 623 * @goal: given target block(filesystem wide) 624 * @count: pointer to total number of blocks needed 625 * @errp: error code 626 * 627 * Return 1st allocated block number on success, *count stores total account 628 * error stores in errp pointer 629 */ 630 ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode, 631 ext4_fsblk_t goal, unsigned long *count, int *errp) 632 { 633 struct ext4_allocation_request ar; 634 ext4_fsblk_t ret; 635 636 memset(&ar, 0, sizeof(ar)); 637 /* Fill with neighbour allocated blocks */ 638 ar.inode = inode; 639 ar.goal = goal; 640 ar.len = count ? *count : 1; 641 642 ret = ext4_mb_new_blocks(handle, &ar, errp); 643 if (count) 644 *count = ar.len; 645 646 /* 647 * Account for the allocated meta blocks 648 */ 649 if (!(*errp) && EXT4_I(inode)->i_delalloc_reserved_flag) { 650 spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 651 EXT4_I(inode)->i_allocated_meta_blocks += ar.len; 652 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 653 } 654 return ret; 655 } 656 657 /** 658 * ext4_count_free_blocks() -- count filesystem free blocks 659 * @sb: superblock 660 * 661 * Adds up the number of free blocks from each block group. 662 */ 663 ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb) 664 { 665 ext4_fsblk_t desc_count; 666 struct ext4_group_desc *gdp; 667 ext4_group_t i; 668 ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count; 669 #ifdef EXT4FS_DEBUG 670 struct ext4_super_block *es; 671 ext4_fsblk_t bitmap_count; 672 unsigned int x; 673 struct buffer_head *bitmap_bh = NULL; 674 675 es = EXT4_SB(sb)->s_es; 676 desc_count = 0; 677 bitmap_count = 0; 678 gdp = NULL; 679 680 smp_rmb(); 681 for (i = 0; i < ngroups; i++) { 682 gdp = ext4_get_group_desc(sb, i, NULL); 683 if (!gdp) 684 continue; 685 desc_count += ext4_free_blks_count(sb, gdp); 686 brelse(bitmap_bh); 687 bitmap_bh = ext4_read_block_bitmap(sb, i); 688 if (bitmap_bh == NULL) 689 continue; 690 691 x = ext4_count_free(bitmap_bh, sb->s_blocksize); 692 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n", 693 i, ext4_free_blks_count(sb, gdp), x); 694 bitmap_count += x; 695 } 696 brelse(bitmap_bh); 697 printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu" 698 ", computed = %llu, %llu\n", ext4_free_blocks_count(es), 699 desc_count, bitmap_count); 700 return bitmap_count; 701 #else 702 desc_count = 0; 703 smp_rmb(); 704 for (i = 0; i < ngroups; i++) { 705 gdp = ext4_get_group_desc(sb, i, NULL); 706 if (!gdp) 707 continue; 708 desc_count += ext4_free_blks_count(sb, gdp); 709 } 710 711 return desc_count; 712 #endif 713 } 714 715 static inline int test_root(ext4_group_t a, int b) 716 { 717 int num = b; 718 719 while (a > num) 720 num *= b; 721 return num == a; 722 } 723 724 static int ext4_group_sparse(ext4_group_t group) 725 { 726 if (group <= 1) 727 return 1; 728 if (!(group & 1)) 729 return 0; 730 return (test_root(group, 7) || test_root(group, 5) || 731 test_root(group, 3)); 732 } 733 734 /** 735 * ext4_bg_has_super - number of blocks used by the superblock in group 736 * @sb: superblock for filesystem 737 * @group: group number to check 738 * 739 * Return the number of blocks used by the superblock (primary or backup) 740 * in this group. Currently this will be only 0 or 1. 741 */ 742 int ext4_bg_has_super(struct super_block *sb, ext4_group_t group) 743 { 744 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 745 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) && 746 !ext4_group_sparse(group)) 747 return 0; 748 return 1; 749 } 750 751 static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb, 752 ext4_group_t group) 753 { 754 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 755 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb); 756 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1; 757 758 if (group == first || group == first + 1 || group == last) 759 return 1; 760 return 0; 761 } 762 763 static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb, 764 ext4_group_t group) 765 { 766 return ext4_bg_has_super(sb, group) ? EXT4_SB(sb)->s_gdb_count : 0; 767 } 768 769 /** 770 * ext4_bg_num_gdb - number of blocks used by the group table in group 771 * @sb: superblock for filesystem 772 * @group: group number to check 773 * 774 * Return the number of blocks used by the group descriptor table 775 * (primary or backup) in this group. In the future there may be a 776 * different number of descriptor blocks in each group. 777 */ 778 unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group) 779 { 780 unsigned long first_meta_bg = 781 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 782 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 783 784 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) || 785 metagroup < first_meta_bg) 786 return ext4_bg_num_gdb_nometa(sb, group); 787 788 return ext4_bg_num_gdb_meta(sb,group); 789 790 } 791 792