2 * linux/fs/ext4/balloc.c
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)
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
14 #include <linux/time.h>
15 #include <linux/capability.h>
17 #include <linux/jbd2.h>
18 #include <linux/quotaops.h>
19 #include <linux/buffer_head.h>
21 #include "ext4_jbd2.h"
26 * balloc.c contains the blocks allocation and deallocation routines
30 * Calculate the block group number and offset, given a block number
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
)
35 struct ext4_super_block
*es
= EXT4_SB(sb
)->s_es
;
38 blocknr
= blocknr
- le32_to_cpu(es
->s_first_data_block
);
39 offset
= do_div(blocknr
, EXT4_BLOCKS_PER_GROUP(sb
));
47 static int ext4_block_in_group(struct super_block
*sb
, ext4_fsblk_t block
,
48 ext4_group_t block_group
)
50 ext4_group_t actual_group
;
51 ext4_get_group_no_and_offset(sb
, block
, &actual_group
, NULL
);
52 if (actual_group
== block_group
)
57 static int ext4_group_used_meta_blocks(struct super_block
*sb
,
58 ext4_group_t block_group
)
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;
65 if (EXT4_HAS_INCOMPAT_FEATURE(sb
, EXT4_FEATURE_INCOMPAT_FLEX_BG
)) {
66 struct ext4_group_desc
*gdp
;
67 struct buffer_head
*bh
;
69 gdp
= ext4_get_group_desc(sb
, block_group
, &bh
);
70 if (!ext4_block_in_group(sb
, ext4_block_bitmap(sb
, gdp
),
74 if (!ext4_block_in_group(sb
, ext4_inode_bitmap(sb
, gdp
),
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
))
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
)
94 unsigned free_blocks
, group_blocks
;
95 struct ext4_sb_info
*sbi
= EXT4_SB(sb
);
98 J_ASSERT_BH(bh
, buffer_locked(bh
));
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
);
111 memset(bh
->b_data
, 0, sb
->s_blocksize
);
114 /* Check for superblock and gdt backups in this group */
115 bit_max
= ext4_bg_has_super(sb
, block_group
);
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
) {
121 bit_max
+= ext4_bg_num_gdb(sb
, block_group
);
123 le16_to_cpu(sbi
->s_es
->s_reserved_gdt_blocks
);
125 } else { /* For META_BG_BLOCK_GROUPS */
126 bit_max
+= ext4_bg_num_gdb(sb
, block_group
);
129 if (block_group
== sbi
->s_groups_count
- 1) {
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
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));
139 group_blocks
= EXT4_BLOCKS_PER_GROUP(sb
);
142 free_blocks
= group_blocks
- bit_max
;
145 ext4_fsblk_t start
, tmp
;
148 for (bit
= 0; bit
< bit_max
; bit
++)
149 ext4_set_bit(bit
, bh
->b_data
);
151 start
= ext4_group_first_block_no(sb
, block_group
);
153 if (EXT4_HAS_INCOMPAT_FEATURE(sb
,
154 EXT4_FEATURE_INCOMPAT_FLEX_BG
))
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
);
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
);
166 tmp
= ext4_inode_table(sb
, gdp
);
167 for (; tmp
< ext4_inode_table(sb
, gdp
) +
168 sbi
->s_itb_per_group
; tmp
++) {
170 ext4_block_in_group(sb
, tmp
, block_group
))
171 ext4_set_bit(tmp
- start
, bh
->b_data
);
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
178 mark_bitmap_end(group_blocks
, sb
->s_blocksize
* 8, bh
->b_data
);
180 return free_blocks
- ext4_group_used_meta_blocks(sb
, block_group
);
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.
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).
196 #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
199 * ext4_get_group_desc() -- load group descriptor from disk
201 * @block_group: given block group
202 * @bh: pointer to the buffer head to store the block
205 struct ext4_group_desc
* ext4_get_group_desc(struct super_block
*sb
,
206 ext4_group_t block_group
,
207 struct buffer_head
**bh
)
209 unsigned int group_desc
;
211 struct ext4_group_desc
*desc
;
212 struct ext4_sb_info
*sbi
= EXT4_SB(sb
);
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
);
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
);
234 desc
= (struct ext4_group_desc
*)(
235 (__u8
*)sbi
->s_group_desc
[group_desc
]->b_data
+
236 offset
* EXT4_DESC_SIZE(sb
));
238 *bh
= sbi
->s_group_desc
[group_desc
];
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
)
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
;
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.
261 group_first_block
= ext4_group_first_block_no(sb
, block_group
);
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 */
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 */
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
,
283 if (next_zero_bit
>= offset
+ EXT4_SB(sb
)->s_itb_per_group
)
284 /* good bitmap for inode tables */
288 ext4_error(sb
, __func__
,
289 "Invalid block bitmap - "
290 "block_group = %d, block = %llu",
291 block_group
, bitmap_blk
);
295 * ext4_read_block_bitmap()
297 * @block_group: given block group
299 * Read the bitmap for a given block_group,and validate the
300 * bits for block/inode/inode tables are set in the bitmaps
302 * Return buffer_head on success or NULL in case of failure.
305 ext4_read_block_bitmap(struct super_block
*sb
, ext4_group_t block_group
)
307 struct ext4_group_desc
*desc
;
308 struct buffer_head
*bh
= NULL
;
309 ext4_fsblk_t bitmap_blk
;
311 desc
= ext4_get_group_desc(sb
, block_group
, NULL
);
314 bitmap_blk
= ext4_block_bitmap(sb
, desc
);
315 bh
= sb_getblk(sb
, bitmap_blk
);
317 ext4_error(sb
, __func__
,
318 "Cannot read block bitmap - "
319 "block_group = %u, block_bitmap = %llu",
320 block_group
, bitmap_blk
);
323 if (buffer_uptodate(bh
) &&
324 !(desc
->bg_flags
& cpu_to_le16(EXT4_BG_BLOCK_UNINIT
)))
328 spin_lock(sb_bgl_lock(EXT4_SB(sb
), block_group
));
329 if (desc
->bg_flags
& cpu_to_le16(EXT4_BG_BLOCK_UNINIT
)) {
330 ext4_init_block_bitmap(sb
, bh
, block_group
, desc
);
331 set_buffer_uptodate(bh
);
333 spin_unlock(sb_bgl_lock(EXT4_SB(sb
), block_group
));
336 spin_unlock(sb_bgl_lock(EXT4_SB(sb
), block_group
));
337 if (bh_submit_read(bh
) < 0) {
339 ext4_error(sb
, __func__
,
340 "Cannot read block bitmap - "
341 "block_group = %u, block_bitmap = %llu",
342 block_group
, bitmap_blk
);
345 ext4_valid_block_bitmap(sb
, desc
, block_group
, bh
);
347 * file system mounted not to panic on error,
348 * continue with corrupt bitmap
354 * ext4_add_groupblocks() -- Add given blocks to an existing group
355 * @handle: handle to this transaction
357 * @block: start physcial block to add to the block group
358 * @count: number of blocks to free
360 * This marks the blocks as free in the bitmap. We ask the
361 * mballoc to reload the buddy after this by setting group
362 * EXT4_GROUP_INFO_NEED_INIT_BIT flag
364 void ext4_add_groupblocks(handle_t
*handle
, struct super_block
*sb
,
365 ext4_fsblk_t block
, unsigned long count
)
367 struct buffer_head
*bitmap_bh
= NULL
;
368 struct buffer_head
*gd_bh
;
369 ext4_group_t block_group
;
372 struct ext4_group_desc
*desc
;
373 struct ext4_super_block
*es
;
374 struct ext4_sb_info
*sbi
;
375 int err
= 0, ret
, blk_free_count
;
376 ext4_grpblk_t blocks_freed
;
377 struct ext4_group_info
*grp
;
381 ext4_debug("Adding block(s) %llu-%llu\n", block
, block
+ count
- 1);
383 ext4_get_group_no_and_offset(sb
, block
, &block_group
, &bit
);
384 grp
= ext4_get_group_info(sb
, block_group
);
386 * Check to see if we are freeing blocks across a group
389 if (bit
+ count
> EXT4_BLOCKS_PER_GROUP(sb
)) {
392 bitmap_bh
= ext4_read_block_bitmap(sb
, block_group
);
395 desc
= ext4_get_group_desc(sb
, block_group
, &gd_bh
);
399 if (in_range(ext4_block_bitmap(sb
, desc
), block
, count
) ||
400 in_range(ext4_inode_bitmap(sb
, desc
), block
, count
) ||
401 in_range(block
, ext4_inode_table(sb
, desc
), sbi
->s_itb_per_group
) ||
402 in_range(block
+ count
- 1, ext4_inode_table(sb
, desc
),
403 sbi
->s_itb_per_group
)) {
404 ext4_error(sb
, __func__
,
405 "Adding blocks in system zones - "
406 "Block = %llu, count = %lu",
412 * We are about to add blocks to the bitmap,
413 * so we need undo access.
415 BUFFER_TRACE(bitmap_bh
, "getting undo access");
416 err
= ext4_journal_get_undo_access(handle
, bitmap_bh
);
421 * We are about to modify some metadata. Call the journal APIs
422 * to unshare ->b_data if a currently-committing transaction is
425 BUFFER_TRACE(gd_bh
, "get_write_access");
426 err
= ext4_journal_get_write_access(handle
, gd_bh
);
430 * make sure we don't allow a parallel init on other groups in the
433 down_write(&grp
->alloc_sem
);
434 for (i
= 0, blocks_freed
= 0; i
< count
; i
++) {
435 BUFFER_TRACE(bitmap_bh
, "clear bit");
436 if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi
, block_group
),
437 bit
+ i
, bitmap_bh
->b_data
)) {
438 ext4_error(sb
, __func__
,
439 "bit already cleared for block %llu",
440 (ext4_fsblk_t
)(block
+ i
));
441 BUFFER_TRACE(bitmap_bh
, "bit already cleared");
446 spin_lock(sb_bgl_lock(sbi
, block_group
));
447 blk_free_count
= blocks_freed
+ ext4_free_blks_count(sb
, desc
);
448 ext4_free_blks_set(sb
, desc
, blk_free_count
);
449 desc
->bg_checksum
= ext4_group_desc_csum(sbi
, block_group
, desc
);
450 spin_unlock(sb_bgl_lock(sbi
, block_group
));
451 percpu_counter_add(&sbi
->s_freeblocks_counter
, blocks_freed
);
453 if (sbi
->s_log_groups_per_flex
) {
454 ext4_group_t flex_group
= ext4_flex_group(sbi
, block_group
);
455 spin_lock(sb_bgl_lock(sbi
, flex_group
));
456 sbi
->s_flex_groups
[flex_group
].free_blocks
+= blocks_freed
;
457 spin_unlock(sb_bgl_lock(sbi
, flex_group
));
460 * request to reload the buddy with the
461 * new bitmap information
463 set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT
, &(grp
->bb_state
));
464 ext4_mb_update_group_info(grp
, blocks_freed
);
465 up_write(&grp
->alloc_sem
);
467 /* We dirtied the bitmap block */
468 BUFFER_TRACE(bitmap_bh
, "dirtied bitmap block");
469 err
= ext4_handle_dirty_metadata(handle
, NULL
, bitmap_bh
);
471 /* And the group descriptor block */
472 BUFFER_TRACE(gd_bh
, "dirtied group descriptor block");
473 ret
= ext4_handle_dirty_metadata(handle
, NULL
, gd_bh
);
480 ext4_std_error(sb
, err
);
485 * ext4_free_blocks() -- Free given blocks and update quota
486 * @handle: handle for this transaction
488 * @block: start physical block to free
489 * @count: number of blocks to count
490 * @metadata: Are these metadata blocks
492 void ext4_free_blocks(handle_t
*handle
, struct inode
*inode
,
493 ext4_fsblk_t block
, unsigned long count
,
496 struct super_block
*sb
;
497 unsigned long dquot_freed_blocks
;
499 /* this isn't the right place to decide whether block is metadata
500 * inode.c/extents.c knows better, but for safety ... */
501 if (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
))
504 /* We need to make sure we don't reuse
505 * block released untill the transaction commit.
506 * writeback mode have weak data consistency so
507 * don't force data as metadata when freeing block
508 * for writeback mode.
510 if (metadata
== 0 && !ext4_should_writeback_data(inode
))
515 ext4_mb_free_blocks(handle
, inode
, block
, count
,
516 metadata
, &dquot_freed_blocks
);
517 if (dquot_freed_blocks
)
518 DQUOT_FREE_BLOCK(inode
, dquot_freed_blocks
);
523 * ext4_has_free_blocks()
524 * @sbi: in-core super block structure.
525 * @nblocks: number of needed blocks
527 * Check if filesystem has nblocks free & available for allocation.
528 * On success return 1, return 0 on failure.
530 int ext4_has_free_blocks(struct ext4_sb_info
*sbi
, s64 nblocks
)
532 s64 free_blocks
, dirty_blocks
, root_blocks
;
533 struct percpu_counter
*fbc
= &sbi
->s_freeblocks_counter
;
534 struct percpu_counter
*dbc
= &sbi
->s_dirtyblocks_counter
;
536 free_blocks
= percpu_counter_read_positive(fbc
);
537 dirty_blocks
= percpu_counter_read_positive(dbc
);
538 root_blocks
= ext4_r_blocks_count(sbi
->s_es
);
540 if (free_blocks
- (nblocks
+ root_blocks
+ dirty_blocks
) <
541 EXT4_FREEBLOCKS_WATERMARK
) {
542 free_blocks
= percpu_counter_sum_positive(fbc
);
543 dirty_blocks
= percpu_counter_sum_positive(dbc
);
544 if (dirty_blocks
< 0) {
545 printk(KERN_CRIT
"Dirty block accounting "
547 (long long)dirty_blocks
);
550 /* Check whether we have space after
551 * accounting for current dirty blocks & root reserved blocks.
553 if (free_blocks
>= ((root_blocks
+ nblocks
) + dirty_blocks
))
556 /* Hm, nope. Are (enough) root reserved blocks available? */
557 if (sbi
->s_resuid
== current_fsuid() ||
558 ((sbi
->s_resgid
!= 0) && in_group_p(sbi
->s_resgid
)) ||
559 capable(CAP_SYS_RESOURCE
)) {
560 if (free_blocks
>= (nblocks
+ dirty_blocks
))
567 int ext4_claim_free_blocks(struct ext4_sb_info
*sbi
,
570 if (ext4_has_free_blocks(sbi
, nblocks
)) {
571 percpu_counter_add(&sbi
->s_dirtyblocks_counter
, nblocks
);
578 * ext4_should_retry_alloc()
580 * @retries number of attemps has been made
582 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if
583 * it is profitable to retry the operation, this function will wait
584 * for the current or commiting transaction to complete, and then
587 * if the total number of retries exceed three times, return FALSE.
589 int ext4_should_retry_alloc(struct super_block
*sb
, int *retries
)
591 if (!ext4_has_free_blocks(EXT4_SB(sb
), 1) || (*retries
)++ > 3)
594 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb
->s_id
);
596 return jbd2_journal_force_commit_nested(EXT4_SB(sb
)->s_journal
);
600 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
602 * @handle: handle to this transaction
604 * @goal: given target block(filesystem wide)
605 * @count: pointer to total number of blocks needed
608 * Return 1st allocated block number on success, *count stores total account
609 * error stores in errp pointer
611 ext4_fsblk_t
ext4_new_meta_blocks(handle_t
*handle
, struct inode
*inode
,
612 ext4_fsblk_t goal
, unsigned long *count
, int *errp
)
614 struct ext4_allocation_request ar
;
617 memset(&ar
, 0, sizeof(ar
));
618 /* Fill with neighbour allocated blocks */
621 ar
.len
= count
? *count
: 1;
623 ret
= ext4_mb_new_blocks(handle
, &ar
, errp
);
628 * Account for the allocated meta blocks
630 if (!(*errp
) && EXT4_I(inode
)->i_delalloc_reserved_flag
) {
631 spin_lock(&EXT4_I(inode
)->i_block_reservation_lock
);
632 EXT4_I(inode
)->i_allocated_meta_blocks
+= ar
.len
;
633 spin_unlock(&EXT4_I(inode
)->i_block_reservation_lock
);
639 * ext4_count_free_blocks() -- count filesystem free blocks
642 * Adds up the number of free blocks from each block group.
644 ext4_fsblk_t
ext4_count_free_blocks(struct super_block
*sb
)
646 ext4_fsblk_t desc_count
;
647 struct ext4_group_desc
*gdp
;
649 ext4_group_t ngroups
= EXT4_SB(sb
)->s_groups_count
;
651 struct ext4_super_block
*es
;
652 ext4_fsblk_t bitmap_count
;
654 struct buffer_head
*bitmap_bh
= NULL
;
656 es
= EXT4_SB(sb
)->s_es
;
662 for (i
= 0; i
< ngroups
; i
++) {
663 gdp
= ext4_get_group_desc(sb
, i
, NULL
);
666 desc_count
+= le16_to_cpu(gdp
->bg_free_blocks_count
);
668 bitmap_bh
= ext4_read_block_bitmap(sb
, i
);
669 if (bitmap_bh
== NULL
)
672 x
= ext4_count_free(bitmap_bh
, sb
->s_blocksize
);
673 printk(KERN_DEBUG
"group %lu: stored = %d, counted = %u\n",
674 i
, le16_to_cpu(gdp
->bg_free_blocks_count
), x
);
678 printk(KERN_DEBUG
"ext4_count_free_blocks: stored = %llu"
679 ", computed = %llu, %llu\n", ext4_free_blocks_count(es
),
680 desc_count
, bitmap_count
);
685 for (i
= 0; i
< ngroups
; i
++) {
686 gdp
= ext4_get_group_desc(sb
, i
, NULL
);
689 desc_count
+= ext4_free_blks_count(sb
, gdp
);
696 static inline int test_root(ext4_group_t a
, int b
)
705 static int ext4_group_sparse(ext4_group_t group
)
711 return (test_root(group
, 7) || test_root(group
, 5) ||
712 test_root(group
, 3));
716 * ext4_bg_has_super - number of blocks used by the superblock in group
717 * @sb: superblock for filesystem
718 * @group: group number to check
720 * Return the number of blocks used by the superblock (primary or backup)
721 * in this group. Currently this will be only 0 or 1.
723 int ext4_bg_has_super(struct super_block
*sb
, ext4_group_t group
)
725 if (EXT4_HAS_RO_COMPAT_FEATURE(sb
,
726 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER
) &&
727 !ext4_group_sparse(group
))
732 static unsigned long ext4_bg_num_gdb_meta(struct super_block
*sb
,
735 unsigned long metagroup
= group
/ EXT4_DESC_PER_BLOCK(sb
);
736 ext4_group_t first
= metagroup
* EXT4_DESC_PER_BLOCK(sb
);
737 ext4_group_t last
= first
+ EXT4_DESC_PER_BLOCK(sb
) - 1;
739 if (group
== first
|| group
== first
+ 1 || group
== last
)
744 static unsigned long ext4_bg_num_gdb_nometa(struct super_block
*sb
,
747 return ext4_bg_has_super(sb
, group
) ? EXT4_SB(sb
)->s_gdb_count
: 0;
751 * ext4_bg_num_gdb - number of blocks used by the group table in group
752 * @sb: superblock for filesystem
753 * @group: group number to check
755 * Return the number of blocks used by the group descriptor table
756 * (primary or backup) in this group. In the future there may be a
757 * different number of descriptor blocks in each group.
759 unsigned long ext4_bg_num_gdb(struct super_block
*sb
, ext4_group_t group
)
761 unsigned long first_meta_bg
=
762 le32_to_cpu(EXT4_SB(sb
)->s_es
->s_first_meta_bg
);
763 unsigned long metagroup
= group
/ EXT4_DESC_PER_BLOCK(sb
);
765 if (!EXT4_HAS_INCOMPAT_FEATURE(sb
,EXT4_FEATURE_INCOMPAT_META_BG
) ||
766 metagroup
< first_meta_bg
)
767 return ext4_bg_num_gdb_nometa(sb
, group
);
769 return ext4_bg_num_gdb_meta(sb
,group
);