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
,
59 struct ext4_group_desc
*gdp
)
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;
66 if (EXT4_HAS_INCOMPAT_FEATURE(sb
, EXT4_FEATURE_INCOMPAT_FLEX_BG
)) {
67 if (!ext4_block_in_group(sb
, ext4_block_bitmap(sb
, gdp
),
71 if (!ext4_block_in_group(sb
, ext4_inode_bitmap(sb
, gdp
),
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
))
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
)
91 ext4_group_t ngroups
= ext4_get_groups_count(sb
);
92 unsigned free_blocks
, group_blocks
;
93 struct ext4_sb_info
*sbi
= EXT4_SB(sb
);
96 J_ASSERT_BH(bh
, buffer_locked(bh
));
98 /* If checksum is bad mark all blocks used to prevent allocation
99 * essentially implementing a per-group read-only flag. */
100 if (!ext4_group_desc_csum_verify(sbi
, block_group
, gdp
)) {
101 ext4_error(sb
, __func__
,
102 "Checksum bad for group %u", block_group
);
103 ext4_free_blks_set(sb
, gdp
, 0);
104 ext4_free_inodes_set(sb
, gdp
, 0);
105 ext4_itable_unused_set(sb
, gdp
, 0);
106 memset(bh
->b_data
, 0xff, sb
->s_blocksize
);
109 memset(bh
->b_data
, 0, sb
->s_blocksize
);
112 /* Check for superblock and gdt backups in this group */
113 bit_max
= ext4_bg_has_super(sb
, block_group
);
115 if (!EXT4_HAS_INCOMPAT_FEATURE(sb
, EXT4_FEATURE_INCOMPAT_META_BG
) ||
116 block_group
< le32_to_cpu(sbi
->s_es
->s_first_meta_bg
) *
117 sbi
->s_desc_per_block
) {
119 bit_max
+= ext4_bg_num_gdb(sb
, block_group
);
121 le16_to_cpu(sbi
->s_es
->s_reserved_gdt_blocks
);
123 } else { /* For META_BG_BLOCK_GROUPS */
124 bit_max
+= ext4_bg_num_gdb(sb
, block_group
);
127 if (block_group
== ngroups
- 1) {
129 * Even though mke2fs always initialize first and last group
130 * if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need
131 * to make sure we calculate the right free blocks
133 group_blocks
= ext4_blocks_count(sbi
->s_es
) -
134 le32_to_cpu(sbi
->s_es
->s_first_data_block
) -
135 (EXT4_BLOCKS_PER_GROUP(sb
) * (ngroups
- 1));
137 group_blocks
= EXT4_BLOCKS_PER_GROUP(sb
);
140 free_blocks
= group_blocks
- bit_max
;
143 ext4_fsblk_t start
, tmp
;
146 for (bit
= 0; bit
< bit_max
; bit
++)
147 ext4_set_bit(bit
, bh
->b_data
);
149 start
= ext4_group_first_block_no(sb
, block_group
);
151 if (EXT4_HAS_INCOMPAT_FEATURE(sb
,
152 EXT4_FEATURE_INCOMPAT_FLEX_BG
))
155 /* Set bits for block and inode bitmaps, and inode table */
156 tmp
= ext4_block_bitmap(sb
, gdp
);
157 if (!flex_bg
|| ext4_block_in_group(sb
, tmp
, block_group
))
158 ext4_set_bit(tmp
- start
, bh
->b_data
);
160 tmp
= ext4_inode_bitmap(sb
, gdp
);
161 if (!flex_bg
|| ext4_block_in_group(sb
, tmp
, block_group
))
162 ext4_set_bit(tmp
- start
, bh
->b_data
);
164 tmp
= ext4_inode_table(sb
, gdp
);
165 for (; tmp
< ext4_inode_table(sb
, gdp
) +
166 sbi
->s_itb_per_group
; tmp
++) {
168 ext4_block_in_group(sb
, tmp
, block_group
))
169 ext4_set_bit(tmp
- start
, bh
->b_data
);
172 * Also if the number of blocks within the group is
173 * less than the blocksize * 8 ( which is the size
174 * of bitmap ), set rest of the block bitmap to 1
176 mark_bitmap_end(group_blocks
, sb
->s_blocksize
* 8, bh
->b_data
);
178 return free_blocks
- ext4_group_used_meta_blocks(sb
, block_group
, gdp
);
183 * The free blocks are managed by bitmaps. A file system contains several
184 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
185 * block for inodes, N blocks for the inode table and data blocks.
187 * The file system contains group descriptors which are located after the
188 * super block. Each descriptor contains the number of the bitmap block and
189 * the free blocks count in the block. The descriptors are loaded in memory
190 * when a file system is mounted (see ext4_fill_super).
194 #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
197 * ext4_get_group_desc() -- load group descriptor from disk
199 * @block_group: given block group
200 * @bh: pointer to the buffer head to store the block
203 struct ext4_group_desc
* ext4_get_group_desc(struct super_block
*sb
,
204 ext4_group_t block_group
,
205 struct buffer_head
**bh
)
207 unsigned int group_desc
;
209 ext4_group_t ngroups
= ext4_get_groups_count(sb
);
210 struct ext4_group_desc
*desc
;
211 struct ext4_sb_info
*sbi
= EXT4_SB(sb
);
213 if (block_group
>= ngroups
) {
214 ext4_error(sb
, "ext4_get_group_desc",
215 "block_group >= groups_count - "
216 "block_group = %u, groups_count = %u",
217 block_group
, ngroups
);
222 group_desc
= block_group
>> EXT4_DESC_PER_BLOCK_BITS(sb
);
223 offset
= block_group
& (EXT4_DESC_PER_BLOCK(sb
) - 1);
224 if (!sbi
->s_group_desc
[group_desc
]) {
225 ext4_error(sb
, "ext4_get_group_desc",
226 "Group descriptor not loaded - "
227 "block_group = %u, group_desc = %u, desc = %u",
228 block_group
, group_desc
, offset
);
232 desc
= (struct ext4_group_desc
*)(
233 (__u8
*)sbi
->s_group_desc
[group_desc
]->b_data
+
234 offset
* EXT4_DESC_SIZE(sb
));
236 *bh
= sbi
->s_group_desc
[group_desc
];
240 static int ext4_valid_block_bitmap(struct super_block
*sb
,
241 struct ext4_group_desc
*desc
,
242 unsigned int block_group
,
243 struct buffer_head
*bh
)
245 ext4_grpblk_t offset
;
246 ext4_grpblk_t next_zero_bit
;
247 ext4_fsblk_t bitmap_blk
;
248 ext4_fsblk_t group_first_block
;
250 if (EXT4_HAS_INCOMPAT_FEATURE(sb
, EXT4_FEATURE_INCOMPAT_FLEX_BG
)) {
251 /* with FLEX_BG, the inode/block bitmaps and itable
252 * blocks may not be in the group at all
253 * so the bitmap validation will be skipped for those groups
254 * or it has to also read the block group where the bitmaps
255 * are located to verify they are set.
259 group_first_block
= ext4_group_first_block_no(sb
, block_group
);
261 /* check whether block bitmap block number is set */
262 bitmap_blk
= ext4_block_bitmap(sb
, desc
);
263 offset
= bitmap_blk
- group_first_block
;
264 if (!ext4_test_bit(offset
, bh
->b_data
))
265 /* bad block bitmap */
268 /* check whether the inode bitmap block number is set */
269 bitmap_blk
= ext4_inode_bitmap(sb
, desc
);
270 offset
= bitmap_blk
- group_first_block
;
271 if (!ext4_test_bit(offset
, bh
->b_data
))
272 /* bad block bitmap */
275 /* check whether the inode table block number is set */
276 bitmap_blk
= ext4_inode_table(sb
, desc
);
277 offset
= bitmap_blk
- group_first_block
;
278 next_zero_bit
= ext4_find_next_zero_bit(bh
->b_data
,
279 offset
+ EXT4_SB(sb
)->s_itb_per_group
,
281 if (next_zero_bit
>= offset
+ EXT4_SB(sb
)->s_itb_per_group
)
282 /* good bitmap for inode tables */
286 ext4_error(sb
, __func__
,
287 "Invalid block bitmap - "
288 "block_group = %d, block = %llu",
289 block_group
, bitmap_blk
);
293 * ext4_read_block_bitmap()
295 * @block_group: given block group
297 * Read the bitmap for a given block_group,and validate the
298 * bits for block/inode/inode tables are set in the bitmaps
300 * Return buffer_head on success or NULL in case of failure.
303 ext4_read_block_bitmap(struct super_block
*sb
, ext4_group_t block_group
)
305 struct ext4_group_desc
*desc
;
306 struct buffer_head
*bh
= NULL
;
307 ext4_fsblk_t bitmap_blk
;
309 desc
= ext4_get_group_desc(sb
, block_group
, NULL
);
312 bitmap_blk
= ext4_block_bitmap(sb
, desc
);
313 bh
= sb_getblk(sb
, bitmap_blk
);
315 ext4_error(sb
, __func__
,
316 "Cannot read block bitmap - "
317 "block_group = %u, block_bitmap = %llu",
318 block_group
, bitmap_blk
);
322 if (bitmap_uptodate(bh
))
326 if (bitmap_uptodate(bh
)) {
330 spin_lock(sb_bgl_lock(EXT4_SB(sb
), block_group
));
331 if (desc
->bg_flags
& cpu_to_le16(EXT4_BG_BLOCK_UNINIT
)) {
332 ext4_init_block_bitmap(sb
, bh
, block_group
, desc
);
333 set_bitmap_uptodate(bh
);
334 set_buffer_uptodate(bh
);
335 spin_unlock(sb_bgl_lock(EXT4_SB(sb
), block_group
));
339 spin_unlock(sb_bgl_lock(EXT4_SB(sb
), block_group
));
340 if (buffer_uptodate(bh
)) {
342 * if not uninit if bh is uptodate,
343 * bitmap is also uptodate
345 set_bitmap_uptodate(bh
);
350 * submit the buffer_head for read. We can
351 * safely mark the bitmap as uptodate now.
352 * We do it here so the bitmap uptodate bit
353 * get set with buffer lock held.
355 set_bitmap_uptodate(bh
);
356 if (bh_submit_read(bh
) < 0) {
358 ext4_error(sb
, __func__
,
359 "Cannot read block bitmap - "
360 "block_group = %u, block_bitmap = %llu",
361 block_group
, bitmap_blk
);
364 ext4_valid_block_bitmap(sb
, desc
, block_group
, bh
);
366 * file system mounted not to panic on error,
367 * continue with corrupt bitmap
373 * ext4_add_groupblocks() -- Add given blocks to an existing group
374 * @handle: handle to this transaction
376 * @block: start physcial block to add to the block group
377 * @count: number of blocks to free
379 * This marks the blocks as free in the bitmap. We ask the
380 * mballoc to reload the buddy after this by setting group
381 * EXT4_GROUP_INFO_NEED_INIT_BIT flag
383 void ext4_add_groupblocks(handle_t
*handle
, struct super_block
*sb
,
384 ext4_fsblk_t block
, unsigned long count
)
386 struct buffer_head
*bitmap_bh
= NULL
;
387 struct buffer_head
*gd_bh
;
388 ext4_group_t block_group
;
391 struct ext4_group_desc
*desc
;
392 struct ext4_super_block
*es
;
393 struct ext4_sb_info
*sbi
;
394 int err
= 0, ret
, blk_free_count
;
395 ext4_grpblk_t blocks_freed
;
396 struct ext4_group_info
*grp
;
400 ext4_debug("Adding block(s) %llu-%llu\n", block
, block
+ count
- 1);
402 ext4_get_group_no_and_offset(sb
, block
, &block_group
, &bit
);
403 grp
= ext4_get_group_info(sb
, block_group
);
405 * Check to see if we are freeing blocks across a group
408 if (bit
+ count
> EXT4_BLOCKS_PER_GROUP(sb
)) {
411 bitmap_bh
= ext4_read_block_bitmap(sb
, block_group
);
414 desc
= ext4_get_group_desc(sb
, block_group
, &gd_bh
);
418 if (in_range(ext4_block_bitmap(sb
, desc
), block
, count
) ||
419 in_range(ext4_inode_bitmap(sb
, desc
), block
, count
) ||
420 in_range(block
, ext4_inode_table(sb
, desc
), sbi
->s_itb_per_group
) ||
421 in_range(block
+ count
- 1, ext4_inode_table(sb
, desc
),
422 sbi
->s_itb_per_group
)) {
423 ext4_error(sb
, __func__
,
424 "Adding blocks in system zones - "
425 "Block = %llu, count = %lu",
431 * We are about to add blocks to the bitmap,
432 * so we need undo access.
434 BUFFER_TRACE(bitmap_bh
, "getting undo access");
435 err
= ext4_journal_get_undo_access(handle
, bitmap_bh
);
440 * We are about to modify some metadata. Call the journal APIs
441 * to unshare ->b_data if a currently-committing transaction is
444 BUFFER_TRACE(gd_bh
, "get_write_access");
445 err
= ext4_journal_get_write_access(handle
, gd_bh
);
449 * make sure we don't allow a parallel init on other groups in the
452 down_write(&grp
->alloc_sem
);
453 for (i
= 0, blocks_freed
= 0; i
< count
; i
++) {
454 BUFFER_TRACE(bitmap_bh
, "clear bit");
455 if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi
, block_group
),
456 bit
+ i
, bitmap_bh
->b_data
)) {
457 ext4_error(sb
, __func__
,
458 "bit already cleared for block %llu",
459 (ext4_fsblk_t
)(block
+ i
));
460 BUFFER_TRACE(bitmap_bh
, "bit already cleared");
465 spin_lock(sb_bgl_lock(sbi
, block_group
));
466 blk_free_count
= blocks_freed
+ ext4_free_blks_count(sb
, desc
);
467 ext4_free_blks_set(sb
, desc
, blk_free_count
);
468 desc
->bg_checksum
= ext4_group_desc_csum(sbi
, block_group
, desc
);
469 spin_unlock(sb_bgl_lock(sbi
, block_group
));
470 percpu_counter_add(&sbi
->s_freeblocks_counter
, blocks_freed
);
472 if (sbi
->s_log_groups_per_flex
) {
473 ext4_group_t flex_group
= ext4_flex_group(sbi
, block_group
);
474 atomic_add(blocks_freed
,
475 &sbi
->s_flex_groups
[flex_group
].free_blocks
);
478 * request to reload the buddy with the
479 * new bitmap information
481 set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT
, &(grp
->bb_state
));
482 ext4_mb_update_group_info(grp
, blocks_freed
);
483 up_write(&grp
->alloc_sem
);
485 /* We dirtied the bitmap block */
486 BUFFER_TRACE(bitmap_bh
, "dirtied bitmap block");
487 err
= ext4_handle_dirty_metadata(handle
, NULL
, bitmap_bh
);
489 /* And the group descriptor block */
490 BUFFER_TRACE(gd_bh
, "dirtied group descriptor block");
491 ret
= ext4_handle_dirty_metadata(handle
, NULL
, gd_bh
);
498 ext4_std_error(sb
, err
);
503 * ext4_free_blocks() -- Free given blocks and update quota
504 * @handle: handle for this transaction
506 * @block: start physical block to free
507 * @count: number of blocks to count
508 * @metadata: Are these metadata blocks
510 void ext4_free_blocks(handle_t
*handle
, struct inode
*inode
,
511 ext4_fsblk_t block
, unsigned long count
,
514 struct super_block
*sb
;
515 unsigned long dquot_freed_blocks
;
517 /* this isn't the right place to decide whether block is metadata
518 * inode.c/extents.c knows better, but for safety ... */
519 if (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
))
522 /* We need to make sure we don't reuse
523 * block released untill the transaction commit.
524 * writeback mode have weak data consistency so
525 * don't force data as metadata when freeing block
526 * for writeback mode.
528 if (metadata
== 0 && !ext4_should_writeback_data(inode
))
533 ext4_mb_free_blocks(handle
, inode
, block
, count
,
534 metadata
, &dquot_freed_blocks
);
535 if (dquot_freed_blocks
)
536 vfs_dq_free_block(inode
, dquot_freed_blocks
);
541 * ext4_has_free_blocks()
542 * @sbi: in-core super block structure.
543 * @nblocks: number of needed blocks
545 * Check if filesystem has nblocks free & available for allocation.
546 * On success return 1, return 0 on failure.
548 int ext4_has_free_blocks(struct ext4_sb_info
*sbi
, s64 nblocks
)
550 s64 free_blocks
, dirty_blocks
, root_blocks
;
551 struct percpu_counter
*fbc
= &sbi
->s_freeblocks_counter
;
552 struct percpu_counter
*dbc
= &sbi
->s_dirtyblocks_counter
;
554 free_blocks
= percpu_counter_read_positive(fbc
);
555 dirty_blocks
= percpu_counter_read_positive(dbc
);
556 root_blocks
= ext4_r_blocks_count(sbi
->s_es
);
558 if (free_blocks
- (nblocks
+ root_blocks
+ dirty_blocks
) <
559 EXT4_FREEBLOCKS_WATERMARK
) {
560 free_blocks
= percpu_counter_sum_positive(fbc
);
561 dirty_blocks
= percpu_counter_sum_positive(dbc
);
562 if (dirty_blocks
< 0) {
563 printk(KERN_CRIT
"Dirty block accounting "
565 (long long)dirty_blocks
);
568 /* Check whether we have space after
569 * accounting for current dirty blocks & root reserved blocks.
571 if (free_blocks
>= ((root_blocks
+ nblocks
) + dirty_blocks
))
574 /* Hm, nope. Are (enough) root reserved blocks available? */
575 if (sbi
->s_resuid
== current_fsuid() ||
576 ((sbi
->s_resgid
!= 0) && in_group_p(sbi
->s_resgid
)) ||
577 capable(CAP_SYS_RESOURCE
)) {
578 if (free_blocks
>= (nblocks
+ dirty_blocks
))
585 int ext4_claim_free_blocks(struct ext4_sb_info
*sbi
,
588 if (ext4_has_free_blocks(sbi
, nblocks
)) {
589 percpu_counter_add(&sbi
->s_dirtyblocks_counter
, nblocks
);
596 * ext4_should_retry_alloc()
598 * @retries number of attemps has been made
600 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if
601 * it is profitable to retry the operation, this function will wait
602 * for the current or commiting transaction to complete, and then
605 * if the total number of retries exceed three times, return FALSE.
607 int ext4_should_retry_alloc(struct super_block
*sb
, int *retries
)
609 if (!ext4_has_free_blocks(EXT4_SB(sb
), 1) ||
611 !EXT4_SB(sb
)->s_journal
)
614 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb
->s_id
);
616 return jbd2_journal_force_commit_nested(EXT4_SB(sb
)->s_journal
);
620 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
622 * @handle: handle to this transaction
624 * @goal: given target block(filesystem wide)
625 * @count: pointer to total number of blocks needed
628 * Return 1st allocated block number on success, *count stores total account
629 * error stores in errp pointer
631 ext4_fsblk_t
ext4_new_meta_blocks(handle_t
*handle
, struct inode
*inode
,
632 ext4_fsblk_t goal
, unsigned long *count
, int *errp
)
634 struct ext4_allocation_request ar
;
637 memset(&ar
, 0, sizeof(ar
));
638 /* Fill with neighbour allocated blocks */
641 ar
.len
= count
? *count
: 1;
643 ret
= ext4_mb_new_blocks(handle
, &ar
, errp
);
648 * Account for the allocated meta blocks
650 if (!(*errp
) && EXT4_I(inode
)->i_delalloc_reserved_flag
) {
651 spin_lock(&EXT4_I(inode
)->i_block_reservation_lock
);
652 EXT4_I(inode
)->i_allocated_meta_blocks
+= ar
.len
;
653 spin_unlock(&EXT4_I(inode
)->i_block_reservation_lock
);
659 * ext4_count_free_blocks() -- count filesystem free blocks
662 * Adds up the number of free blocks from each block group.
664 ext4_fsblk_t
ext4_count_free_blocks(struct super_block
*sb
)
666 ext4_fsblk_t desc_count
;
667 struct ext4_group_desc
*gdp
;
669 ext4_group_t ngroups
= ext4_get_groups_count(sb
);
671 struct ext4_super_block
*es
;
672 ext4_fsblk_t bitmap_count
;
674 struct buffer_head
*bitmap_bh
= NULL
;
676 es
= EXT4_SB(sb
)->s_es
;
681 for (i
= 0; i
< ngroups
; i
++) {
682 gdp
= ext4_get_group_desc(sb
, i
, NULL
);
685 desc_count
+= ext4_free_blks_count(sb
, gdp
);
687 bitmap_bh
= ext4_read_block_bitmap(sb
, i
);
688 if (bitmap_bh
== NULL
)
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
);
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
);
703 for (i
= 0; i
< ngroups
; i
++) {
704 gdp
= ext4_get_group_desc(sb
, i
, NULL
);
707 desc_count
+= ext4_free_blks_count(sb
, gdp
);
714 static inline int test_root(ext4_group_t a
, int b
)
723 static int ext4_group_sparse(ext4_group_t group
)
729 return (test_root(group
, 7) || test_root(group
, 5) ||
730 test_root(group
, 3));
734 * ext4_bg_has_super - number of blocks used by the superblock in group
735 * @sb: superblock for filesystem
736 * @group: group number to check
738 * Return the number of blocks used by the superblock (primary or backup)
739 * in this group. Currently this will be only 0 or 1.
741 int ext4_bg_has_super(struct super_block
*sb
, ext4_group_t group
)
743 if (EXT4_HAS_RO_COMPAT_FEATURE(sb
,
744 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER
) &&
745 !ext4_group_sparse(group
))
750 static unsigned long ext4_bg_num_gdb_meta(struct super_block
*sb
,
753 unsigned long metagroup
= group
/ EXT4_DESC_PER_BLOCK(sb
);
754 ext4_group_t first
= metagroup
* EXT4_DESC_PER_BLOCK(sb
);
755 ext4_group_t last
= first
+ EXT4_DESC_PER_BLOCK(sb
) - 1;
757 if (group
== first
|| group
== first
+ 1 || group
== last
)
762 static unsigned long ext4_bg_num_gdb_nometa(struct super_block
*sb
,
765 return ext4_bg_has_super(sb
, group
) ? EXT4_SB(sb
)->s_gdb_count
: 0;
769 * ext4_bg_num_gdb - number of blocks used by the group table in group
770 * @sb: superblock for filesystem
771 * @group: group number to check
773 * Return the number of blocks used by the group descriptor table
774 * (primary or backup) in this group. In the future there may be a
775 * different number of descriptor blocks in each group.
777 unsigned long ext4_bg_num_gdb(struct super_block
*sb
, ext4_group_t group
)
779 unsigned long first_meta_bg
=
780 le32_to_cpu(EXT4_SB(sb
)->s_es
->s_first_meta_bg
);
781 unsigned long metagroup
= group
/ EXT4_DESC_PER_BLOCK(sb
);
783 if (!EXT4_HAS_INCOMPAT_FEATURE(sb
,EXT4_FEATURE_INCOMPAT_META_BG
) ||
784 metagroup
< first_meta_bg
)
785 return ext4_bg_num_gdb_nometa(sb
, group
);
787 return ext4_bg_num_gdb_meta(sb
,group
);