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 #include <trace/events/ext4.h> 25 26 static unsigned ext4_num_base_meta_clusters(struct super_block *sb, 27 ext4_group_t block_group); 28 /* 29 * balloc.c contains the blocks allocation and deallocation routines 30 */ 31 32 /* 33 * Calculate the block group number and offset into the block/cluster 34 * allocation bitmap, given a block number 35 */ 36 void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr, 37 ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp) 38 { 39 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 40 ext4_grpblk_t offset; 41 42 blocknr = blocknr - le32_to_cpu(es->s_first_data_block); 43 offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb)) >> 44 EXT4_SB(sb)->s_cluster_bits; 45 if (offsetp) 46 *offsetp = offset; 47 if (blockgrpp) 48 *blockgrpp = blocknr; 49 50 } 51 52 static int ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block, 53 ext4_group_t block_group) 54 { 55 ext4_group_t actual_group; 56 ext4_get_group_no_and_offset(sb, block, &actual_group, NULL); 57 if (actual_group == block_group) 58 return 1; 59 return 0; 60 } 61 62 /* Return the number of clusters used for file system metadata; this 63 * represents the overhead needed by the file system. 64 */ 65 unsigned ext4_num_overhead_clusters(struct super_block *sb, 66 ext4_group_t block_group, 67 struct ext4_group_desc *gdp) 68 { 69 unsigned num_clusters; 70 int block_cluster = -1, inode_cluster = -1, itbl_cluster = -1, i, c; 71 ext4_fsblk_t start = ext4_group_first_block_no(sb, block_group); 72 ext4_fsblk_t itbl_blk; 73 struct ext4_sb_info *sbi = EXT4_SB(sb); 74 75 /* This is the number of clusters used by the superblock, 76 * block group descriptors, and reserved block group 77 * descriptor blocks */ 78 num_clusters = ext4_num_base_meta_clusters(sb, block_group); 79 80 /* 81 * For the allocation bitmaps and inode table, we first need 82 * to check to see if the block is in the block group. If it 83 * is, then check to see if the cluster is already accounted 84 * for in the clusters used for the base metadata cluster, or 85 * if we can increment the base metadata cluster to include 86 * that block. Otherwise, we will have to track the cluster 87 * used for the allocation bitmap or inode table explicitly. 88 * Normally all of these blocks are contiguous, so the special 89 * case handling shouldn't be necessary except for *very* 90 * unusual file system layouts. 91 */ 92 if (ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), block_group)) { 93 block_cluster = EXT4_B2C(sbi, (start - 94 ext4_block_bitmap(sb, gdp))); 95 if (block_cluster < num_clusters) 96 block_cluster = -1; 97 else if (block_cluster == num_clusters) { 98 num_clusters++; 99 block_cluster = -1; 100 } 101 } 102 103 if (ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp), block_group)) { 104 inode_cluster = EXT4_B2C(sbi, 105 start - ext4_inode_bitmap(sb, gdp)); 106 if (inode_cluster < num_clusters) 107 inode_cluster = -1; 108 else if (inode_cluster == num_clusters) { 109 num_clusters++; 110 inode_cluster = -1; 111 } 112 } 113 114 itbl_blk = ext4_inode_table(sb, gdp); 115 for (i = 0; i < sbi->s_itb_per_group; i++) { 116 if (ext4_block_in_group(sb, itbl_blk + i, block_group)) { 117 c = EXT4_B2C(sbi, start - itbl_blk + i); 118 if ((c < num_clusters) || (c == inode_cluster) || 119 (c == block_cluster) || (c == itbl_cluster)) 120 continue; 121 if (c == num_clusters) { 122 num_clusters++; 123 continue; 124 } 125 num_clusters++; 126 itbl_cluster = c; 127 } 128 } 129 130 if (block_cluster != -1) 131 num_clusters++; 132 if (inode_cluster != -1) 133 num_clusters++; 134 135 return num_clusters; 136 } 137 138 static unsigned int num_clusters_in_group(struct super_block *sb, 139 ext4_group_t block_group) 140 { 141 unsigned int blocks; 142 143 if (block_group == ext4_get_groups_count(sb) - 1) { 144 /* 145 * Even though mke2fs always initializes the first and 146 * last group, just in case some other tool was used, 147 * we need to make sure we calculate the right free 148 * blocks. 149 */ 150 blocks = ext4_blocks_count(EXT4_SB(sb)->s_es) - 151 ext4_group_first_block_no(sb, block_group); 152 } else 153 blocks = EXT4_BLOCKS_PER_GROUP(sb); 154 return EXT4_NUM_B2C(EXT4_SB(sb), blocks); 155 } 156 157 /* Initializes an uninitialized block bitmap */ 158 void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh, 159 ext4_group_t block_group, 160 struct ext4_group_desc *gdp) 161 { 162 unsigned int bit, bit_max; 163 struct ext4_sb_info *sbi = EXT4_SB(sb); 164 ext4_fsblk_t start, tmp; 165 int flex_bg = 0; 166 167 J_ASSERT_BH(bh, buffer_locked(bh)); 168 169 /* If checksum is bad mark all blocks used to prevent allocation 170 * essentially implementing a per-group read-only flag. */ 171 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) { 172 ext4_error(sb, "Checksum bad for group %u", block_group); 173 ext4_free_group_clusters_set(sb, gdp, 0); 174 ext4_free_inodes_set(sb, gdp, 0); 175 ext4_itable_unused_set(sb, gdp, 0); 176 memset(bh->b_data, 0xff, sb->s_blocksize); 177 return; 178 } 179 memset(bh->b_data, 0, sb->s_blocksize); 180 181 bit_max = ext4_num_base_meta_clusters(sb, block_group); 182 for (bit = 0; bit < bit_max; bit++) 183 ext4_set_bit(bit, bh->b_data); 184 185 start = ext4_group_first_block_no(sb, block_group); 186 187 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) 188 flex_bg = 1; 189 190 /* Set bits for block and inode bitmaps, and inode table */ 191 tmp = ext4_block_bitmap(sb, gdp); 192 if (!flex_bg || ext4_block_in_group(sb, tmp, block_group)) 193 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data); 194 195 tmp = ext4_inode_bitmap(sb, gdp); 196 if (!flex_bg || ext4_block_in_group(sb, tmp, block_group)) 197 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data); 198 199 tmp = ext4_inode_table(sb, gdp); 200 for (; tmp < ext4_inode_table(sb, gdp) + 201 sbi->s_itb_per_group; tmp++) { 202 if (!flex_bg || ext4_block_in_group(sb, tmp, block_group)) 203 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data); 204 } 205 206 /* 207 * Also if the number of blocks within the group is less than 208 * the blocksize * 8 ( which is the size of bitmap ), set rest 209 * of the block bitmap to 1 210 */ 211 ext4_mark_bitmap_end(num_clusters_in_group(sb, block_group), 212 sb->s_blocksize * 8, bh->b_data); 213 } 214 215 /* Return the number of free blocks in a block group. It is used when 216 * the block bitmap is uninitialized, so we can't just count the bits 217 * in the bitmap. */ 218 unsigned ext4_free_clusters_after_init(struct super_block *sb, 219 ext4_group_t block_group, 220 struct ext4_group_desc *gdp) 221 { 222 return num_clusters_in_group(sb, block_group) - 223 ext4_num_overhead_clusters(sb, block_group, gdp); 224 } 225 226 /* 227 * The free blocks are managed by bitmaps. A file system contains several 228 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap 229 * block for inodes, N blocks for the inode table and data blocks. 230 * 231 * The file system contains group descriptors which are located after the 232 * super block. Each descriptor contains the number of the bitmap block and 233 * the free blocks count in the block. The descriptors are loaded in memory 234 * when a file system is mounted (see ext4_fill_super). 235 */ 236 237 /** 238 * ext4_get_group_desc() -- load group descriptor from disk 239 * @sb: super block 240 * @block_group: given block group 241 * @bh: pointer to the buffer head to store the block 242 * group descriptor 243 */ 244 struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb, 245 ext4_group_t block_group, 246 struct buffer_head **bh) 247 { 248 unsigned int group_desc; 249 unsigned int offset; 250 ext4_group_t ngroups = ext4_get_groups_count(sb); 251 struct ext4_group_desc *desc; 252 struct ext4_sb_info *sbi = EXT4_SB(sb); 253 254 if (block_group >= ngroups) { 255 ext4_error(sb, "block_group >= groups_count - block_group = %u," 256 " groups_count = %u", block_group, ngroups); 257 258 return NULL; 259 } 260 261 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb); 262 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1); 263 if (!sbi->s_group_desc[group_desc]) { 264 ext4_error(sb, "Group descriptor not loaded - " 265 "block_group = %u, group_desc = %u, desc = %u", 266 block_group, group_desc, offset); 267 return NULL; 268 } 269 270 desc = (struct ext4_group_desc *)( 271 (__u8 *)sbi->s_group_desc[group_desc]->b_data + 272 offset * EXT4_DESC_SIZE(sb)); 273 if (bh) 274 *bh = sbi->s_group_desc[group_desc]; 275 return desc; 276 } 277 278 static int ext4_valid_block_bitmap(struct super_block *sb, 279 struct ext4_group_desc *desc, 280 unsigned int block_group, 281 struct buffer_head *bh) 282 { 283 ext4_grpblk_t offset; 284 ext4_grpblk_t next_zero_bit; 285 ext4_fsblk_t bitmap_blk; 286 ext4_fsblk_t group_first_block; 287 288 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { 289 /* with FLEX_BG, the inode/block bitmaps and itable 290 * blocks may not be in the group at all 291 * so the bitmap validation will be skipped for those groups 292 * or it has to also read the block group where the bitmaps 293 * are located to verify they are set. 294 */ 295 return 1; 296 } 297 group_first_block = ext4_group_first_block_no(sb, block_group); 298 299 /* check whether block bitmap block number is set */ 300 bitmap_blk = ext4_block_bitmap(sb, desc); 301 offset = bitmap_blk - group_first_block; 302 if (!ext4_test_bit(offset, bh->b_data)) 303 /* bad block bitmap */ 304 goto err_out; 305 306 /* check whether the inode bitmap block number is set */ 307 bitmap_blk = ext4_inode_bitmap(sb, desc); 308 offset = bitmap_blk - group_first_block; 309 if (!ext4_test_bit(offset, bh->b_data)) 310 /* bad block bitmap */ 311 goto err_out; 312 313 /* check whether the inode table block number is set */ 314 bitmap_blk = ext4_inode_table(sb, desc); 315 offset = bitmap_blk - group_first_block; 316 next_zero_bit = ext4_find_next_zero_bit(bh->b_data, 317 offset + EXT4_SB(sb)->s_itb_per_group, 318 offset); 319 if (next_zero_bit >= offset + EXT4_SB(sb)->s_itb_per_group) 320 /* good bitmap for inode tables */ 321 return 1; 322 323 err_out: 324 ext4_error(sb, "Invalid block bitmap - block_group = %d, block = %llu", 325 block_group, bitmap_blk); 326 return 0; 327 } 328 /** 329 * ext4_read_block_bitmap() 330 * @sb: super block 331 * @block_group: given block group 332 * 333 * Read the bitmap for a given block_group,and validate the 334 * bits for block/inode/inode tables are set in the bitmaps 335 * 336 * Return buffer_head on success or NULL in case of failure. 337 */ 338 struct buffer_head * 339 ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group) 340 { 341 struct ext4_group_desc *desc; 342 struct buffer_head *bh = NULL; 343 ext4_fsblk_t bitmap_blk; 344 345 desc = ext4_get_group_desc(sb, block_group, NULL); 346 if (!desc) 347 return NULL; 348 bitmap_blk = ext4_block_bitmap(sb, desc); 349 bh = sb_getblk(sb, bitmap_blk); 350 if (unlikely(!bh)) { 351 ext4_error(sb, "Cannot read block bitmap - " 352 "block_group = %u, block_bitmap = %llu", 353 block_group, bitmap_blk); 354 return NULL; 355 } 356 357 if (bitmap_uptodate(bh)) 358 return bh; 359 360 lock_buffer(bh); 361 if (bitmap_uptodate(bh)) { 362 unlock_buffer(bh); 363 return bh; 364 } 365 ext4_lock_group(sb, block_group); 366 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) { 367 ext4_init_block_bitmap(sb, bh, block_group, desc); 368 set_bitmap_uptodate(bh); 369 set_buffer_uptodate(bh); 370 ext4_unlock_group(sb, block_group); 371 unlock_buffer(bh); 372 return bh; 373 } 374 ext4_unlock_group(sb, block_group); 375 if (buffer_uptodate(bh)) { 376 /* 377 * if not uninit if bh is uptodate, 378 * bitmap is also uptodate 379 */ 380 set_bitmap_uptodate(bh); 381 unlock_buffer(bh); 382 return bh; 383 } 384 /* 385 * submit the buffer_head for read. We can 386 * safely mark the bitmap as uptodate now. 387 * We do it here so the bitmap uptodate bit 388 * get set with buffer lock held. 389 */ 390 trace_ext4_read_block_bitmap_load(sb, block_group); 391 set_bitmap_uptodate(bh); 392 if (bh_submit_read(bh) < 0) { 393 put_bh(bh); 394 ext4_error(sb, "Cannot read block bitmap - " 395 "block_group = %u, block_bitmap = %llu", 396 block_group, bitmap_blk); 397 return NULL; 398 } 399 ext4_valid_block_bitmap(sb, desc, block_group, bh); 400 /* 401 * file system mounted not to panic on error, 402 * continue with corrupt bitmap 403 */ 404 return bh; 405 } 406 407 /** 408 * ext4_has_free_clusters() 409 * @sbi: in-core super block structure. 410 * @nclusters: number of needed blocks 411 * @flags: flags from ext4_mb_new_blocks() 412 * 413 * Check if filesystem has nclusters free & available for allocation. 414 * On success return 1, return 0 on failure. 415 */ 416 static int ext4_has_free_clusters(struct ext4_sb_info *sbi, 417 s64 nclusters, unsigned int flags) 418 { 419 s64 free_clusters, dirty_clusters, root_clusters; 420 struct percpu_counter *fcc = &sbi->s_freeclusters_counter; 421 struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter; 422 423 free_clusters = percpu_counter_read_positive(fcc); 424 dirty_clusters = percpu_counter_read_positive(dcc); 425 root_clusters = EXT4_B2C(sbi, ext4_r_blocks_count(sbi->s_es)); 426 427 if (free_clusters - (nclusters + root_clusters + dirty_clusters) < 428 EXT4_FREECLUSTERS_WATERMARK) { 429 free_clusters = EXT4_C2B(sbi, percpu_counter_sum_positive(fcc)); 430 dirty_clusters = percpu_counter_sum_positive(dcc); 431 } 432 /* Check whether we have space after accounting for current 433 * dirty clusters & root reserved clusters. 434 */ 435 if (free_clusters >= ((root_clusters + nclusters) + dirty_clusters)) 436 return 1; 437 438 /* Hm, nope. Are (enough) root reserved clusters available? */ 439 if (sbi->s_resuid == current_fsuid() || 440 ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) || 441 capable(CAP_SYS_RESOURCE) || 442 (flags & EXT4_MB_USE_ROOT_BLOCKS)) { 443 444 if (free_clusters >= (nclusters + dirty_clusters)) 445 return 1; 446 } 447 448 return 0; 449 } 450 451 int ext4_claim_free_clusters(struct ext4_sb_info *sbi, 452 s64 nclusters, unsigned int flags) 453 { 454 if (ext4_has_free_clusters(sbi, nclusters, flags)) { 455 percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters); 456 return 0; 457 } else 458 return -ENOSPC; 459 } 460 461 /** 462 * ext4_should_retry_alloc() 463 * @sb: super block 464 * @retries number of attemps has been made 465 * 466 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if 467 * it is profitable to retry the operation, this function will wait 468 * for the current or committing transaction to complete, and then 469 * return TRUE. 470 * 471 * if the total number of retries exceed three times, return FALSE. 472 */ 473 int ext4_should_retry_alloc(struct super_block *sb, int *retries) 474 { 475 if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) || 476 (*retries)++ > 3 || 477 !EXT4_SB(sb)->s_journal) 478 return 0; 479 480 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id); 481 482 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal); 483 } 484 485 /* 486 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks 487 * 488 * @handle: handle to this transaction 489 * @inode: file inode 490 * @goal: given target block(filesystem wide) 491 * @count: pointer to total number of clusters needed 492 * @errp: error code 493 * 494 * Return 1st allocated block number on success, *count stores total account 495 * error stores in errp pointer 496 */ 497 ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode, 498 ext4_fsblk_t goal, unsigned int flags, 499 unsigned long *count, int *errp) 500 { 501 struct ext4_allocation_request ar; 502 ext4_fsblk_t ret; 503 504 memset(&ar, 0, sizeof(ar)); 505 /* Fill with neighbour allocated blocks */ 506 ar.inode = inode; 507 ar.goal = goal; 508 ar.len = count ? *count : 1; 509 ar.flags = flags; 510 511 ret = ext4_mb_new_blocks(handle, &ar, errp); 512 if (count) 513 *count = ar.len; 514 /* 515 * Account for the allocated meta blocks. We will never 516 * fail EDQUOT for metdata, but we do account for it. 517 */ 518 if (!(*errp) && 519 ext4_test_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED)) { 520 spin_lock(&EXT4_I(inode)->i_block_reservation_lock); 521 EXT4_I(inode)->i_allocated_meta_blocks += ar.len; 522 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 523 dquot_alloc_block_nofail(inode, 524 EXT4_C2B(EXT4_SB(inode->i_sb), ar.len)); 525 } 526 return ret; 527 } 528 529 /** 530 * ext4_count_free_clusters() -- count filesystem free clusters 531 * @sb: superblock 532 * 533 * Adds up the number of free clusters from each block group. 534 */ 535 ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb) 536 { 537 ext4_fsblk_t desc_count; 538 struct ext4_group_desc *gdp; 539 ext4_group_t i; 540 ext4_group_t ngroups = ext4_get_groups_count(sb); 541 #ifdef EXT4FS_DEBUG 542 struct ext4_super_block *es; 543 ext4_fsblk_t bitmap_count; 544 unsigned int x; 545 struct buffer_head *bitmap_bh = NULL; 546 547 es = EXT4_SB(sb)->s_es; 548 desc_count = 0; 549 bitmap_count = 0; 550 gdp = NULL; 551 552 for (i = 0; i < ngroups; i++) { 553 gdp = ext4_get_group_desc(sb, i, NULL); 554 if (!gdp) 555 continue; 556 desc_count += ext4_free_group_clusters(sb, gdp); 557 brelse(bitmap_bh); 558 bitmap_bh = ext4_read_block_bitmap(sb, i); 559 if (bitmap_bh == NULL) 560 continue; 561 562 x = ext4_count_free(bitmap_bh, sb->s_blocksize); 563 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n", 564 i, ext4_free_group_clusters(sb, gdp), x); 565 bitmap_count += x; 566 } 567 brelse(bitmap_bh); 568 printk(KERN_DEBUG "ext4_count_free_clusters: stored = %llu" 569 ", computed = %llu, %llu\n", 570 EXT4_B2C(EXT4_SB(sb), ext4_free_blocks_count(es)), 571 desc_count, bitmap_count); 572 return bitmap_count; 573 #else 574 desc_count = 0; 575 for (i = 0; i < ngroups; i++) { 576 gdp = ext4_get_group_desc(sb, i, NULL); 577 if (!gdp) 578 continue; 579 desc_count += ext4_free_group_clusters(sb, gdp); 580 } 581 582 return desc_count; 583 #endif 584 } 585 586 static inline int test_root(ext4_group_t a, int b) 587 { 588 int num = b; 589 590 while (a > num) 591 num *= b; 592 return num == a; 593 } 594 595 static int ext4_group_sparse(ext4_group_t group) 596 { 597 if (group <= 1) 598 return 1; 599 if (!(group & 1)) 600 return 0; 601 return (test_root(group, 7) || test_root(group, 5) || 602 test_root(group, 3)); 603 } 604 605 /** 606 * ext4_bg_has_super - number of blocks used by the superblock in group 607 * @sb: superblock for filesystem 608 * @group: group number to check 609 * 610 * Return the number of blocks used by the superblock (primary or backup) 611 * in this group. Currently this will be only 0 or 1. 612 */ 613 int ext4_bg_has_super(struct super_block *sb, ext4_group_t group) 614 { 615 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 616 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) && 617 !ext4_group_sparse(group)) 618 return 0; 619 return 1; 620 } 621 622 static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb, 623 ext4_group_t group) 624 { 625 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 626 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb); 627 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1; 628 629 if (group == first || group == first + 1 || group == last) 630 return 1; 631 return 0; 632 } 633 634 static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb, 635 ext4_group_t group) 636 { 637 if (!ext4_bg_has_super(sb, group)) 638 return 0; 639 640 if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG)) 641 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 642 else 643 return EXT4_SB(sb)->s_gdb_count; 644 } 645 646 /** 647 * ext4_bg_num_gdb - number of blocks used by the group table in group 648 * @sb: superblock for filesystem 649 * @group: group number to check 650 * 651 * Return the number of blocks used by the group descriptor table 652 * (primary or backup) in this group. In the future there may be a 653 * different number of descriptor blocks in each group. 654 */ 655 unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group) 656 { 657 unsigned long first_meta_bg = 658 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg); 659 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb); 660 661 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) || 662 metagroup < first_meta_bg) 663 return ext4_bg_num_gdb_nometa(sb, group); 664 665 return ext4_bg_num_gdb_meta(sb,group); 666 667 } 668 669 /* 670 * This function returns the number of file system metadata clusters at 671 * the beginning of a block group, including the reserved gdt blocks. 672 */ 673 static unsigned ext4_num_base_meta_clusters(struct super_block *sb, 674 ext4_group_t block_group) 675 { 676 struct ext4_sb_info *sbi = EXT4_SB(sb); 677 unsigned num; 678 679 /* Check for superblock and gdt backups in this group */ 680 num = ext4_bg_has_super(sb, block_group); 681 682 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) || 683 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) * 684 sbi->s_desc_per_block) { 685 if (num) { 686 num += ext4_bg_num_gdb(sb, block_group); 687 num += le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks); 688 } 689 } else { /* For META_BG_BLOCK_GROUPS */ 690 num += ext4_bg_num_gdb(sb, block_group); 691 } 692 return EXT4_NUM_B2C(sbi, num); 693 } 694 /** 695 * ext4_inode_to_goal_block - return a hint for block allocation 696 * @inode: inode for block allocation 697 * 698 * Return the ideal location to start allocating blocks for a 699 * newly created inode. 700 */ 701 ext4_fsblk_t ext4_inode_to_goal_block(struct inode *inode) 702 { 703 struct ext4_inode_info *ei = EXT4_I(inode); 704 ext4_group_t block_group; 705 ext4_grpblk_t colour; 706 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb)); 707 ext4_fsblk_t bg_start; 708 ext4_fsblk_t last_block; 709 710 block_group = ei->i_block_group; 711 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) { 712 /* 713 * If there are at least EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME 714 * block groups per flexgroup, reserve the first block 715 * group for directories and special files. Regular 716 * files will start at the second block group. This 717 * tends to speed up directory access and improves 718 * fsck times. 719 */ 720 block_group &= ~(flex_size-1); 721 if (S_ISREG(inode->i_mode)) 722 block_group++; 723 } 724 bg_start = ext4_group_first_block_no(inode->i_sb, block_group); 725 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1; 726 727 /* 728 * If we are doing delayed allocation, we don't need take 729 * colour into account. 730 */ 731 if (test_opt(inode->i_sb, DELALLOC)) 732 return bg_start; 733 734 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block) 735 colour = (current->pid % 16) * 736 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16); 737 else 738 colour = (current->pid % 16) * ((last_block - bg_start) / 16); 739 return bg_start + colour; 740 } 741 742