blob: 97b970e7dd130abdcb86d4ece7c6526718e05cf0 [file] [log] [blame]
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001/*
Mingming Cao617ba132006-10-11 01:20:53 -07002 * linux/fs/ext4/balloc.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003 *
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>
Mingming Caodab291a2006-10-11 01:21:01 -070017#include <linux/jbd2.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070018#include <linux/quotaops.h>
19#include <linux/buffer_head.h>
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040020#include "ext4.h"
21#include "ext4_jbd2.h"
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -050022#include "mballoc.h"
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040023
Jiaying Zhang0562e0b2011-03-21 21:38:05 -040024#include <trace/events/ext4.h>
25
Dave Kleikampac27a0e2006-10-11 01:20:50 -070026/*
27 * balloc.c contains the blocks allocation and deallocation routines
28 */
29
30/*
Andrew Morton72b64b52006-10-11 01:21:18 -070031 * Calculate the block group number and offset, given a block number
32 */
33void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
Avantika Mathurfd2d4292008-01-28 23:58:27 -050034 ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)
Andrew Morton72b64b52006-10-11 01:21:18 -070035{
Dave Kleikamp8c55e202007-05-24 13:04:54 -040036 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
Andrew Morton72b64b52006-10-11 01:21:18 -070037 ext4_grpblk_t offset;
38
Dave Kleikamp8c55e202007-05-24 13:04:54 -040039 blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
Andrew Mortonf4e5bc22006-10-11 01:21:19 -070040 offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb));
Andrew Morton72b64b52006-10-11 01:21:18 -070041 if (offsetp)
42 *offsetp = offset;
43 if (blockgrpp)
Dave Kleikamp8c55e202007-05-24 13:04:54 -040044 *blockgrpp = blocknr;
Andrew Morton72b64b52006-10-11 01:21:18 -070045
46}
47
Jose R. Santos0bf7e832008-06-03 14:07:29 -040048static int ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block,
49 ext4_group_t block_group)
50{
51 ext4_group_t actual_group;
Aneesh Kumar K.V74778272008-07-11 19:27:31 -040052 ext4_get_group_no_and_offset(sb, block, &actual_group, NULL);
Jose R. Santos0bf7e832008-06-03 14:07:29 -040053 if (actual_group == block_group)
54 return 1;
55 return 0;
56}
57
58static int ext4_group_used_meta_blocks(struct super_block *sb,
Theodore Ts'oe187c652009-02-06 16:23:37 -050059 ext4_group_t block_group,
60 struct ext4_group_desc *gdp)
Jose R. Santos0bf7e832008-06-03 14:07:29 -040061{
62 ext4_fsblk_t tmp;
63 struct ext4_sb_info *sbi = EXT4_SB(sb);
64 /* block bitmap, inode bitmap, and inode table blocks */
65 int used_blocks = sbi->s_itb_per_group + 2;
66
67 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
Jose R. Santos0bf7e832008-06-03 14:07:29 -040068 if (!ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp),
69 block_group))
70 used_blocks--;
71
72 if (!ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp),
73 block_group))
74 used_blocks--;
75
76 tmp = ext4_inode_table(sb, gdp);
77 for (; tmp < ext4_inode_table(sb, gdp) +
78 sbi->s_itb_per_group; tmp++) {
79 if (!ext4_block_in_group(sb, tmp, block_group))
80 used_blocks -= 1;
81 }
82 }
83 return used_blocks;
84}
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -040085
Andreas Dilger717d50e2007-10-16 18:38:25 -040086/* Initializes an uninitialized block bitmap if given, and returns the
87 * number of blocks free in the group. */
88unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
Avantika Mathurfd2d4292008-01-28 23:58:27 -050089 ext4_group_t block_group, struct ext4_group_desc *gdp)
Andreas Dilger717d50e2007-10-16 18:38:25 -040090{
Andreas Dilger717d50e2007-10-16 18:38:25 -040091 int bit, bit_max;
Theodore Ts'o8df96752009-05-01 08:50:38 -040092 ext4_group_t ngroups = ext4_get_groups_count(sb);
Andreas Dilger717d50e2007-10-16 18:38:25 -040093 unsigned free_blocks, group_blocks;
94 struct ext4_sb_info *sbi = EXT4_SB(sb);
95
96 if (bh) {
97 J_ASSERT_BH(bh, buffer_locked(bh));
98
99 /* If checksum is bad mark all blocks used to prevent allocation
100 * essentially implementing a per-group read-only flag. */
101 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500102 ext4_error(sb, "Checksum bad for group %u",
103 block_group);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500104 ext4_free_blks_set(sb, gdp, 0);
105 ext4_free_inodes_set(sb, gdp, 0);
106 ext4_itable_unused_set(sb, gdp, 0);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400107 memset(bh->b_data, 0xff, sb->s_blocksize);
108 return 0;
109 }
110 memset(bh->b_data, 0, sb->s_blocksize);
111 }
112
113 /* Check for superblock and gdt backups in this group */
114 bit_max = ext4_bg_has_super(sb, block_group);
115
116 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
117 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
118 sbi->s_desc_per_block) {
119 if (bit_max) {
120 bit_max += ext4_bg_num_gdb(sb, block_group);
121 bit_max +=
122 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
123 }
124 } else { /* For META_BG_BLOCK_GROUPS */
Akinobu Mita6afd6702008-07-11 19:27:31 -0400125 bit_max += ext4_bg_num_gdb(sb, block_group);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400126 }
127
Theodore Ts'o8df96752009-05-01 08:50:38 -0400128 if (block_group == ngroups - 1) {
Andreas Dilger717d50e2007-10-16 18:38:25 -0400129 /*
130 * Even though mke2fs always initialize first and last group
131 * if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need
132 * to make sure we calculate the right free blocks
133 */
134 group_blocks = ext4_blocks_count(sbi->s_es) -
Akinobu Mita5661bd62010-03-03 23:53:39 -0500135 ext4_group_first_block_no(sb, ngroups - 1);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400136 } else {
137 group_blocks = EXT4_BLOCKS_PER_GROUP(sb);
138 }
139
140 free_blocks = group_blocks - bit_max;
141
142 if (bh) {
Jose R. Santos0bf7e832008-06-03 14:07:29 -0400143 ext4_fsblk_t start, tmp;
144 int flex_bg = 0;
Akinobu Mitad00a6d72008-04-17 10:38:59 -0400145
Andreas Dilger717d50e2007-10-16 18:38:25 -0400146 for (bit = 0; bit < bit_max; bit++)
147 ext4_set_bit(bit, bh->b_data);
148
Akinobu Mitad00a6d72008-04-17 10:38:59 -0400149 start = ext4_group_first_block_no(sb, block_group);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400150
Jose R. Santos0bf7e832008-06-03 14:07:29 -0400151 if (EXT4_HAS_INCOMPAT_FEATURE(sb,
152 EXT4_FEATURE_INCOMPAT_FLEX_BG))
153 flex_bg = 1;
Andreas Dilger717d50e2007-10-16 18:38:25 -0400154
Jose R. Santos0bf7e832008-06-03 14:07:29 -0400155 /* 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);
159
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);
163
164 tmp = ext4_inode_table(sb, gdp);
165 for (; tmp < ext4_inode_table(sb, gdp) +
166 sbi->s_itb_per_group; tmp++) {
167 if (!flex_bg ||
168 ext4_block_in_group(sb, tmp, block_group))
169 ext4_set_bit(tmp - start, bh->b_data);
170 }
Andreas Dilger717d50e2007-10-16 18:38:25 -0400171 /*
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
175 */
Theodore Ts'o61d08672010-10-27 21:30:15 -0400176 ext4_mark_bitmap_end(group_blocks, sb->s_blocksize * 8,
177 bh->b_data);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400178 }
Theodore Ts'oe187c652009-02-06 16:23:37 -0500179 return free_blocks - ext4_group_used_meta_blocks(sb, block_group, gdp);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400180}
181
182
Andrew Morton72b64b52006-10-11 01:21:18 -0700183/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700184 * The free blocks are managed by bitmaps. A file system contains several
185 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
186 * block for inodes, N blocks for the inode table and data blocks.
187 *
188 * The file system contains group descriptors which are located after the
189 * super block. Each descriptor contains the number of the bitmap block and
190 * the free blocks count in the block. The descriptors are loaded in memory
Aneesh Kumar K.Ve6274322007-02-20 13:57:58 -0800191 * when a file system is mounted (see ext4_fill_super).
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700192 */
193
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700194/**
Mingming Cao617ba132006-10-11 01:20:53 -0700195 * ext4_get_group_desc() -- load group descriptor from disk
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700196 * @sb: super block
197 * @block_group: given block group
198 * @bh: pointer to the buffer head to store the block
199 * group descriptor
200 */
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400201struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500202 ext4_group_t block_group,
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400203 struct buffer_head **bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700204{
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500205 unsigned int group_desc;
206 unsigned int offset;
Theodore Ts'o8df96752009-05-01 08:50:38 -0400207 ext4_group_t ngroups = ext4_get_groups_count(sb);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400208 struct ext4_group_desc *desc;
Mingming Cao617ba132006-10-11 01:20:53 -0700209 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700210
Theodore Ts'o8df96752009-05-01 08:50:38 -0400211 if (block_group >= ngroups) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500212 ext4_error(sb, "block_group >= groups_count - block_group = %u,"
213 " groups_count = %u", block_group, ngroups);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700214
215 return NULL;
216 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700217
Mingming Cao617ba132006-10-11 01:20:53 -0700218 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
219 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700220 if (!sbi->s_group_desc[group_desc]) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500221 ext4_error(sb, "Group descriptor not loaded - "
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500222 "block_group = %u, group_desc = %u, desc = %u",
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400223 block_group, group_desc, offset);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700224 return NULL;
225 }
226
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -0700227 desc = (struct ext4_group_desc *)(
228 (__u8 *)sbi->s_group_desc[group_desc]->b_data +
229 offset * EXT4_DESC_SIZE(sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700230 if (bh)
231 *bh = sbi->s_group_desc[group_desc];
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -0700232 return desc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700233}
234
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500235static int ext4_valid_block_bitmap(struct super_block *sb,
236 struct ext4_group_desc *desc,
237 unsigned int block_group,
238 struct buffer_head *bh)
239{
240 ext4_grpblk_t offset;
241 ext4_grpblk_t next_zero_bit;
242 ext4_fsblk_t bitmap_blk;
243 ext4_fsblk_t group_first_block;
244
245 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
246 /* with FLEX_BG, the inode/block bitmaps and itable
247 * blocks may not be in the group at all
248 * so the bitmap validation will be skipped for those groups
249 * or it has to also read the block group where the bitmaps
250 * are located to verify they are set.
251 */
252 return 1;
253 }
254 group_first_block = ext4_group_first_block_no(sb, block_group);
255
256 /* check whether block bitmap block number is set */
257 bitmap_blk = ext4_block_bitmap(sb, desc);
258 offset = bitmap_blk - group_first_block;
259 if (!ext4_test_bit(offset, bh->b_data))
260 /* bad block bitmap */
261 goto err_out;
262
263 /* check whether the inode bitmap block number is set */
264 bitmap_blk = ext4_inode_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 table block number is set */
271 bitmap_blk = ext4_inode_table(sb, desc);
272 offset = bitmap_blk - group_first_block;
273 next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
274 offset + EXT4_SB(sb)->s_itb_per_group,
275 offset);
276 if (next_zero_bit >= offset + EXT4_SB(sb)->s_itb_per_group)
277 /* good bitmap for inode tables */
278 return 1;
279
280err_out:
Eric Sandeen12062dd2010-02-15 14:19:27 -0500281 ext4_error(sb, "Invalid block bitmap - block_group = %d, block = %llu",
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500282 block_group, bitmap_blk);
283 return 0;
284}
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700285/**
Theodore Ts'o574ca172008-07-11 19:27:31 -0400286 * ext4_read_block_bitmap()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700287 * @sb: super block
288 * @block_group: given block group
289 *
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500290 * Read the bitmap for a given block_group,and validate the
291 * bits for block/inode/inode tables are set in the bitmaps
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700292 *
293 * Return buffer_head on success or NULL in case of failure.
294 */
Andreas Dilger717d50e2007-10-16 18:38:25 -0400295struct buffer_head *
Theodore Ts'o574ca172008-07-11 19:27:31 -0400296ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700297{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400298 struct ext4_group_desc *desc;
299 struct buffer_head *bh = NULL;
Aneesh Kumar K.V7c9e69f2007-10-16 23:27:02 -0700300 ext4_fsblk_t bitmap_blk;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700301
Andreas Dilger717d50e2007-10-16 18:38:25 -0400302 desc = ext4_get_group_desc(sb, block_group, NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700303 if (!desc)
Aneesh Kumar K.V7c9e69f2007-10-16 23:27:02 -0700304 return NULL;
305 bitmap_blk = ext4_block_bitmap(sb, desc);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500306 bh = sb_getblk(sb, bitmap_blk);
307 if (unlikely(!bh)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500308 ext4_error(sb, "Cannot read block bitmap - "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -0500309 "block_group = %u, block_bitmap = %llu",
Eric Sandeene29d1cd2008-08-02 21:21:02 -0400310 block_group, bitmap_blk);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500311 return NULL;
312 }
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500313
314 if (bitmap_uptodate(bh))
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500315 return bh;
316
Frederic Bohec806e682008-10-10 08:09:18 -0400317 lock_buffer(bh);
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500318 if (bitmap_uptodate(bh)) {
319 unlock_buffer(bh);
320 return bh;
321 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400322 ext4_lock_group(sb, block_group);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500323 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
324 ext4_init_block_bitmap(sb, bh, block_group, desc);
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500325 set_bitmap_uptodate(bh);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500326 set_buffer_uptodate(bh);
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400327 ext4_unlock_group(sb, block_group);
Aneesh Kumar K.V3300bed2009-01-03 22:33:39 -0500328 unlock_buffer(bh);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500329 return bh;
330 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400331 ext4_unlock_group(sb, block_group);
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500332 if (buffer_uptodate(bh)) {
333 /*
334 * if not uninit if bh is uptodate,
335 * bitmap is also uptodate
336 */
337 set_bitmap_uptodate(bh);
338 unlock_buffer(bh);
339 return bh;
340 }
341 /*
342 * submit the buffer_head for read. We can
343 * safely mark the bitmap as uptodate now.
344 * We do it here so the bitmap uptodate bit
345 * get set with buffer lock held.
346 */
Jiaying Zhang0562e0b2011-03-21 21:38:05 -0400347 trace_ext4_read_block_bitmap_load(sb, block_group);
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500348 set_bitmap_uptodate(bh);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500349 if (bh_submit_read(bh) < 0) {
350 put_bh(bh);
Eric Sandeen12062dd2010-02-15 14:19:27 -0500351 ext4_error(sb, "Cannot read block bitmap - "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -0500352 "block_group = %u, block_bitmap = %llu",
Eric Sandeene29d1cd2008-08-02 21:21:02 -0400353 block_group, bitmap_blk);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500354 return NULL;
355 }
Aneesh Kumar K.V519deca2008-05-15 14:43:20 -0400356 ext4_valid_block_bitmap(sb, desc, block_group, bh);
357 /*
358 * file system mounted not to panic on error,
359 * continue with corrupt bitmap
360 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700361 return bh;
362}
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700363
364/**
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500365 * ext4_add_groupblocks() -- Add given blocks to an existing group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700366 * @handle: handle to this transaction
367 * @sb: super block
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500368 * @block: start physcial block to add to the block group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700369 * @count: number of blocks to free
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -0400370 *
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500371 * This marks the blocks as free in the bitmap. We ask the
372 * mballoc to reload the buddy after this by setting group
373 * EXT4_GROUP_INFO_NEED_INIT_BIT flag
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700374 */
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500375void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,
376 ext4_fsblk_t block, unsigned long count)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700377{
378 struct buffer_head *bitmap_bh = NULL;
379 struct buffer_head *gd_bh;
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500380 ext4_group_t block_group;
Mingming Cao617ba132006-10-11 01:20:53 -0700381 ext4_grpblk_t bit;
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500382 unsigned int i;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400383 struct ext4_group_desc *desc;
Theodore Ts'oa0375152010-06-11 23:14:04 -0400384 struct ext4_sb_info *sbi = EXT4_SB(sb);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500385 int err = 0, ret, blk_free_count;
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500386 ext4_grpblk_t blocks_freed;
387 struct ext4_group_info *grp;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700388
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500389 ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700390
Mingming Cao3a5b2ec2006-10-11 01:21:05 -0700391 ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -0500392 grp = ext4_get_group_info(sb, block_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700393 /*
394 * Check to see if we are freeing blocks across a group
395 * boundary.
396 */
Mingming Cao617ba132006-10-11 01:20:53 -0700397 if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500398 goto error_return;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700399 }
Theodore Ts'o574ca172008-07-11 19:27:31 -0400400 bitmap_bh = ext4_read_block_bitmap(sb, block_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700401 if (!bitmap_bh)
402 goto error_return;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400403 desc = ext4_get_group_desc(sb, block_group, &gd_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700404 if (!desc)
405 goto error_return;
406
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700407 if (in_range(ext4_block_bitmap(sb, desc), block, count) ||
408 in_range(ext4_inode_bitmap(sb, desc), block, count) ||
409 in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
410 in_range(block + count - 1, ext4_inode_table(sb, desc),
Aneesh Kumar K.Vcb47dce2008-01-28 23:58:27 -0500411 sbi->s_itb_per_group)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500412 ext4_error(sb, "Adding blocks in system zones - "
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400413 "Block = %llu, count = %lu",
414 block, count);
Aneesh Kumar K.Vcb47dce2008-01-28 23:58:27 -0500415 goto error_return;
416 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700417
418 /*
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500419 * We are about to add blocks to the bitmap,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700420 * so we need undo access.
421 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700422 BUFFER_TRACE(bitmap_bh, "getting undo access");
Mingming Cao617ba132006-10-11 01:20:53 -0700423 err = ext4_journal_get_undo_access(handle, bitmap_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700424 if (err)
425 goto error_return;
426
427 /*
428 * We are about to modify some metadata. Call the journal APIs
429 * to unshare ->b_data if a currently-committing transaction is
430 * using it
431 */
432 BUFFER_TRACE(gd_bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700433 err = ext4_journal_get_write_access(handle, gd_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700434 if (err)
435 goto error_return;
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -0500436 /*
437 * make sure we don't allow a parallel init on other groups in the
438 * same buddy cache
439 */
440 down_write(&grp->alloc_sem);
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500441 for (i = 0, blocks_freed = 0; i < count; i++) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700442 BUFFER_TRACE(bitmap_bh, "clear bit");
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400443 if (!ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700444 bit + i, bitmap_bh->b_data)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500445 ext4_error(sb, "bit already cleared for block %llu",
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700446 (ext4_fsblk_t)(block + i));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700447 BUFFER_TRACE(bitmap_bh, "bit already cleared");
448 } else {
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500449 blocks_freed++;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700450 }
451 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400452 ext4_lock_group(sb, block_group);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500453 blk_free_count = blocks_freed + ext4_free_blks_count(sb, desc);
454 ext4_free_blks_set(sb, desc, blk_free_count);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400455 desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc);
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400456 ext4_unlock_group(sb, block_group);
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500457 percpu_counter_add(&sbi->s_freeblocks_counter, blocks_freed);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700458
Jose R. Santos772cb7c2008-07-11 19:27:31 -0400459 if (sbi->s_log_groups_per_flex) {
460 ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
Theodore Ts'o9f24e422009-03-04 19:09:10 -0500461 atomic_add(blocks_freed,
462 &sbi->s_flex_groups[flex_group].free_blocks);
Jose R. Santos772cb7c2008-07-11 19:27:31 -0400463 }
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -0500464 /*
465 * request to reload the buddy with the
466 * new bitmap information
467 */
468 set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &(grp->bb_state));
Eric Sandeen03731302009-08-17 23:51:29 -0400469 grp->bb_free += blocks_freed;
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -0500470 up_write(&grp->alloc_sem);
Jose R. Santos772cb7c2008-07-11 19:27:31 -0400471
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700472 /* We dirtied the bitmap block */
473 BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
Frank Mayhar03901312009-01-07 00:06:22 -0500474 err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700475
476 /* And the group descriptor block */
477 BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
Frank Mayhar03901312009-01-07 00:06:22 -0500478 ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500479 if (!err)
480 err = ret;
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500481
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700482error_return:
483 brelse(bitmap_bh);
Mingming Cao617ba132006-10-11 01:20:53 -0700484 ext4_std_error(sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700485 return;
486}
487
488/**
Eric Sandeen8c3bf8a2008-10-28 00:08:12 -0400489 * ext4_has_free_blocks()
490 * @sbi: in-core super block structure.
491 * @nblocks: number of needed blocks
492 *
493 * Check if filesystem has nblocks free & available for allocation.
494 * On success return 1, return 0 on failure.
495 */
Theodore Ts'o1f109d52010-10-27 21:30:14 -0400496static int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks)
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400497{
Eric Sandeena9960312008-10-28 00:08:17 -0400498 s64 free_blocks, dirty_blocks, root_blocks;
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400499 struct percpu_counter *fbc = &sbi->s_freeblocks_counter;
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400500 struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400501
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400502 free_blocks = percpu_counter_read_positive(fbc);
503 dirty_blocks = percpu_counter_read_positive(dbc);
Eric Sandeena9960312008-10-28 00:08:17 -0400504 root_blocks = ext4_r_blocks_count(sbi->s_es);
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400505
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400506 if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
507 EXT4_FREEBLOCKS_WATERMARK) {
Andrew Morton02d21162008-12-09 13:14:14 -0800508 free_blocks = percpu_counter_sum_positive(fbc);
509 dirty_blocks = percpu_counter_sum_positive(dbc);
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400510 if (dirty_blocks < 0) {
511 printk(KERN_CRIT "Dirty block accounting "
512 "went wrong %lld\n",
Alexander Beregalov8f72fbd2008-10-29 17:13:08 -0400513 (long long)dirty_blocks);
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400514 }
515 }
516 /* Check whether we have space after
Eric Sandeena9960312008-10-28 00:08:17 -0400517 * accounting for current dirty blocks & root reserved blocks.
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400518 */
Eric Sandeena9960312008-10-28 00:08:17 -0400519 if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks))
520 return 1;
Aneesh Kumar K.V5c791612008-10-08 23:12:24 -0400521
Eric Sandeena9960312008-10-28 00:08:17 -0400522 /* Hm, nope. Are (enough) root reserved blocks available? */
David Howells4c9c5442008-11-14 10:38:51 +1100523 if (sbi->s_resuid == current_fsuid() ||
Eric Sandeena9960312008-10-28 00:08:17 -0400524 ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||
525 capable(CAP_SYS_RESOURCE)) {
526 if (free_blocks >= (nblocks + dirty_blocks))
527 return 1;
528 }
529
530 return 0;
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400531}
Mingming Cao07031432008-07-11 19:27:31 -0400532
Eric Sandeen8c3bf8a2008-10-28 00:08:12 -0400533int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
534 s64 nblocks)
535{
536 if (ext4_has_free_blocks(sbi, nblocks)) {
537 percpu_counter_add(&sbi->s_dirtyblocks_counter, nblocks);
538 return 0;
539 } else
540 return -ENOSPC;
541}
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700542
543/**
Mingming Cao617ba132006-10-11 01:20:53 -0700544 * ext4_should_retry_alloc()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700545 * @sb: super block
546 * @retries number of attemps has been made
547 *
Mingming Cao617ba132006-10-11 01:20:53 -0700548 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700549 * it is profitable to retry the operation, this function will wait
550 * for the current or commiting transaction to complete, and then
551 * return TRUE.
552 *
553 * if the total number of retries exceed three times, return FALSE.
554 */
Mingming Cao617ba132006-10-11 01:20:53 -0700555int ext4_should_retry_alloc(struct super_block *sb, int *retries)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700556{
Eric Sandeen8f64b322009-02-26 00:57:35 -0500557 if (!ext4_has_free_blocks(EXT4_SB(sb), 1) ||
558 (*retries)++ > 3 ||
559 !EXT4_SB(sb)->s_journal)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700560 return 0;
561
562 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
563
Mingming Caodab291a2006-10-11 01:21:01 -0700564 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700565}
566
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400567/*
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400568 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
569 *
570 * @handle: handle to this transaction
571 * @inode: file inode
572 * @goal: given target block(filesystem wide)
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500573 * @count: pointer to total number of blocks needed
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400574 * @errp: error code
575 *
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500576 * Return 1st allocated block number on success, *count stores total account
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400577 * error stores in errp pointer
578 */
579ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
580 ext4_fsblk_t goal, unsigned long *count, int *errp)
581{
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500582 struct ext4_allocation_request ar;
Mingming Caod2a17632008-07-14 17:52:37 -0400583 ext4_fsblk_t ret;
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500584
585 memset(&ar, 0, sizeof(ar));
586 /* Fill with neighbour allocated blocks */
587 ar.inode = inode;
588 ar.goal = goal;
589 ar.len = count ? *count : 1;
590
591 ret = ext4_mb_new_blocks(handle, &ar, errp);
592 if (count)
593 *count = ar.len;
Mingming Caod2a17632008-07-14 17:52:37 -0400594 /*
Eric Sandeen72b8ab92010-05-16 11:00:00 -0400595 * Account for the allocated meta blocks. We will never
596 * fail EDQUOT for metdata, but we do account for it.
Mingming Caod2a17632008-07-14 17:52:37 -0400597 */
Theodore Ts'of2321092011-01-10 12:12:36 -0500598 if (!(*errp) &&
599 ext4_test_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED)) {
Mingming Caod2a17632008-07-14 17:52:37 -0400600 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500601 EXT4_I(inode)->i_allocated_meta_blocks += ar.len;
Mingming Caod2a17632008-07-14 17:52:37 -0400602 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
Eric Sandeen72b8ab92010-05-16 11:00:00 -0400603 dquot_alloc_block_nofail(inode, ar.len);
Mingming Caod2a17632008-07-14 17:52:37 -0400604 }
605 return ret;
606}
607
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700608/**
Mingming Cao617ba132006-10-11 01:20:53 -0700609 * ext4_count_free_blocks() -- count filesystem free blocks
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700610 * @sb: superblock
611 *
612 * Adds up the number of free blocks from each block group.
613 */
Mingming Cao617ba132006-10-11 01:20:53 -0700614ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700615{
Mingming Cao617ba132006-10-11 01:20:53 -0700616 ext4_fsblk_t desc_count;
617 struct ext4_group_desc *gdp;
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500618 ext4_group_t i;
Theodore Ts'o8df96752009-05-01 08:50:38 -0400619 ext4_group_t ngroups = ext4_get_groups_count(sb);
Mingming Cao617ba132006-10-11 01:20:53 -0700620#ifdef EXT4FS_DEBUG
621 struct ext4_super_block *es;
622 ext4_fsblk_t bitmap_count;
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500623 unsigned int x;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700624 struct buffer_head *bitmap_bh = NULL;
625
Mingming Cao617ba132006-10-11 01:20:53 -0700626 es = EXT4_SB(sb)->s_es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700627 desc_count = 0;
628 bitmap_count = 0;
629 gdp = NULL;
630
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700631 for (i = 0; i < ngroups; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -0700632 gdp = ext4_get_group_desc(sb, i, NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700633 if (!gdp)
634 continue;
Thadeu Lima de Souza Cascardo9fd97842009-01-26 19:26:26 -0500635 desc_count += ext4_free_blks_count(sb, gdp);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700636 brelse(bitmap_bh);
Theodore Ts'o574ca172008-07-11 19:27:31 -0400637 bitmap_bh = ext4_read_block_bitmap(sb, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700638 if (bitmap_bh == NULL)
639 continue;
640
Mingming Cao617ba132006-10-11 01:20:53 -0700641 x = ext4_count_free(bitmap_bh, sb->s_blocksize);
Thadeu Lima de Souza Cascardo9fd97842009-01-26 19:26:26 -0500642 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
643 i, ext4_free_blks_count(sb, gdp), x);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700644 bitmap_count += x;
645 }
646 brelse(bitmap_bh);
Theodore Ts'o47760042008-09-08 23:00:52 -0400647 printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu"
648 ", computed = %llu, %llu\n", ext4_free_blocks_count(es),
649 desc_count, bitmap_count);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700650 return bitmap_count;
651#else
652 desc_count = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700653 for (i = 0; i < ngroups; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -0700654 gdp = ext4_get_group_desc(sb, i, NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700655 if (!gdp)
656 continue;
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500657 desc_count += ext4_free_blks_count(sb, gdp);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700658 }
659
660 return desc_count;
661#endif
662}
663
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500664static inline int test_root(ext4_group_t a, int b)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700665{
666 int num = b;
667
668 while (a > num)
669 num *= b;
670 return num == a;
671}
672
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500673static int ext4_group_sparse(ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700674{
675 if (group <= 1)
676 return 1;
677 if (!(group & 1))
678 return 0;
679 return (test_root(group, 7) || test_root(group, 5) ||
680 test_root(group, 3));
681}
682
683/**
Mingming Cao617ba132006-10-11 01:20:53 -0700684 * ext4_bg_has_super - number of blocks used by the superblock in group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700685 * @sb: superblock for filesystem
686 * @group: group number to check
687 *
688 * Return the number of blocks used by the superblock (primary or backup)
689 * in this group. Currently this will be only 0 or 1.
690 */
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500691int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700692{
Mingming Cao617ba132006-10-11 01:20:53 -0700693 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
694 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
695 !ext4_group_sparse(group))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700696 return 0;
697 return 1;
698}
699
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500700static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
701 ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700702{
Mingming Cao617ba132006-10-11 01:20:53 -0700703 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500704 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
705 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700706
707 if (group == first || group == first + 1 || group == last)
708 return 1;
709 return 0;
710}
711
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500712static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
713 ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700714{
Theodore Ts'o8dadb192009-11-23 07:24:38 -0500715 if (!ext4_bg_has_super(sb, group))
716 return 0;
717
718 if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG))
719 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
720 else
721 return EXT4_SB(sb)->s_gdb_count;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700722}
723
724/**
Mingming Cao617ba132006-10-11 01:20:53 -0700725 * ext4_bg_num_gdb - number of blocks used by the group table in group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700726 * @sb: superblock for filesystem
727 * @group: group number to check
728 *
729 * Return the number of blocks used by the group descriptor table
730 * (primary or backup) in this group. In the future there may be a
731 * different number of descriptor blocks in each group.
732 */
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500733unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700734{
735 unsigned long first_meta_bg =
Mingming Cao617ba132006-10-11 01:20:53 -0700736 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
737 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700738
Mingming Cao617ba132006-10-11 01:20:53 -0700739 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700740 metagroup < first_meta_bg)
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400741 return ext4_bg_num_gdb_nometa(sb, group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700742
Mingming Cao617ba132006-10-11 01:20:53 -0700743 return ext4_bg_num_gdb_meta(sb,group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700744
745}
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -0400746