blob: e2126d70dff5bd5fce57506849a91ca1f0a2052e [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
Dave Kleikampac27a0e2006-10-11 01:20:50 -070024/*
25 * balloc.c contains the blocks allocation and deallocation routines
26 */
27
28/*
Andrew Morton72b64b52006-10-11 01:21:18 -070029 * Calculate the block group number and offset, given a block number
30 */
31void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
Avantika Mathurfd2d4292008-01-28 23:58:27 -050032 ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)
Andrew Morton72b64b52006-10-11 01:21:18 -070033{
Dave Kleikamp8c55e202007-05-24 13:04:54 -040034 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
Andrew Morton72b64b52006-10-11 01:21:18 -070035 ext4_grpblk_t offset;
36
Dave Kleikamp8c55e202007-05-24 13:04:54 -040037 blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
Andrew Mortonf4e5bc22006-10-11 01:21:19 -070038 offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb));
Andrew Morton72b64b52006-10-11 01:21:18 -070039 if (offsetp)
40 *offsetp = offset;
41 if (blockgrpp)
Dave Kleikamp8c55e202007-05-24 13:04:54 -040042 *blockgrpp = blocknr;
Andrew Morton72b64b52006-10-11 01:21:18 -070043
44}
45
Jose R. Santos0bf7e832008-06-03 14:07:29 -040046static int ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block,
47 ext4_group_t block_group)
48{
49 ext4_group_t actual_group;
Aneesh Kumar K.V74778272008-07-11 19:27:31 -040050 ext4_get_group_no_and_offset(sb, block, &actual_group, NULL);
Jose R. Santos0bf7e832008-06-03 14:07:29 -040051 if (actual_group == block_group)
52 return 1;
53 return 0;
54}
55
56static int ext4_group_used_meta_blocks(struct super_block *sb,
Theodore Ts'oe187c652009-02-06 16:23:37 -050057 ext4_group_t block_group,
58 struct ext4_group_desc *gdp)
Jose R. Santos0bf7e832008-06-03 14:07:29 -040059{
60 ext4_fsblk_t tmp;
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;
64
65 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
Jose R. Santos0bf7e832008-06-03 14:07:29 -040066 if (!ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp),
67 block_group))
68 used_blocks--;
69
70 if (!ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp),
71 block_group))
72 used_blocks--;
73
74 tmp = ext4_inode_table(sb, gdp);
75 for (; tmp < ext4_inode_table(sb, gdp) +
76 sbi->s_itb_per_group; tmp++) {
77 if (!ext4_block_in_group(sb, tmp, block_group))
78 used_blocks -= 1;
79 }
80 }
81 return used_blocks;
82}
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -040083
Andreas Dilger717d50e2007-10-16 18:38:25 -040084/* Initializes an uninitialized block bitmap if given, and returns the
85 * number of blocks free in the group. */
86unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
Avantika Mathurfd2d4292008-01-28 23:58:27 -050087 ext4_group_t block_group, struct ext4_group_desc *gdp)
Andreas Dilger717d50e2007-10-16 18:38:25 -040088{
Andreas Dilger717d50e2007-10-16 18:38:25 -040089 int bit, bit_max;
Theodore Ts'o8df96752009-05-01 08:50:38 -040090 ext4_group_t ngroups = ext4_get_groups_count(sb);
Andreas Dilger717d50e2007-10-16 18:38:25 -040091 unsigned free_blocks, group_blocks;
92 struct ext4_sb_info *sbi = EXT4_SB(sb);
93
94 if (bh) {
95 J_ASSERT_BH(bh, buffer_locked(bh));
96
97 /* If checksum is bad mark all blocks used to prevent allocation
98 * essentially implementing a per-group read-only flag. */
99 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
Harvey Harrison46e665e2008-04-17 10:38:59 -0400100 ext4_error(sb, __func__,
Theodore Ts'oa9df9a42009-01-05 22:18:16 -0500101 "Checksum bad for group %u", block_group);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500102 ext4_free_blks_set(sb, gdp, 0);
103 ext4_free_inodes_set(sb, gdp, 0);
104 ext4_itable_unused_set(sb, gdp, 0);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400105 memset(bh->b_data, 0xff, sb->s_blocksize);
106 return 0;
107 }
108 memset(bh->b_data, 0, sb->s_blocksize);
109 }
110
111 /* Check for superblock and gdt backups in this group */
112 bit_max = ext4_bg_has_super(sb, block_group);
113
114 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
115 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
116 sbi->s_desc_per_block) {
117 if (bit_max) {
118 bit_max += ext4_bg_num_gdb(sb, block_group);
119 bit_max +=
120 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
121 }
122 } else { /* For META_BG_BLOCK_GROUPS */
Akinobu Mita6afd6702008-07-11 19:27:31 -0400123 bit_max += ext4_bg_num_gdb(sb, block_group);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400124 }
125
Theodore Ts'o8df96752009-05-01 08:50:38 -0400126 if (block_group == ngroups - 1) {
Andreas Dilger717d50e2007-10-16 18:38:25 -0400127 /*
128 * Even though mke2fs always initialize first and last group
129 * if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need
130 * to make sure we calculate the right free blocks
131 */
132 group_blocks = ext4_blocks_count(sbi->s_es) -
133 le32_to_cpu(sbi->s_es->s_first_data_block) -
Theodore Ts'o8df96752009-05-01 08:50:38 -0400134 (EXT4_BLOCKS_PER_GROUP(sb) * (ngroups - 1));
Andreas Dilger717d50e2007-10-16 18:38:25 -0400135 } else {
136 group_blocks = EXT4_BLOCKS_PER_GROUP(sb);
137 }
138
139 free_blocks = group_blocks - bit_max;
140
141 if (bh) {
Jose R. Santos0bf7e832008-06-03 14:07:29 -0400142 ext4_fsblk_t start, tmp;
143 int flex_bg = 0;
Akinobu Mitad00a6d72008-04-17 10:38:59 -0400144
Andreas Dilger717d50e2007-10-16 18:38:25 -0400145 for (bit = 0; bit < bit_max; bit++)
146 ext4_set_bit(bit, bh->b_data);
147
Akinobu Mitad00a6d72008-04-17 10:38:59 -0400148 start = ext4_group_first_block_no(sb, block_group);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400149
Jose R. Santos0bf7e832008-06-03 14:07:29 -0400150 if (EXT4_HAS_INCOMPAT_FEATURE(sb,
151 EXT4_FEATURE_INCOMPAT_FLEX_BG))
152 flex_bg = 1;
Andreas Dilger717d50e2007-10-16 18:38:25 -0400153
Jose R. Santos0bf7e832008-06-03 14:07:29 -0400154 /* Set bits for block and inode bitmaps, and inode table */
155 tmp = ext4_block_bitmap(sb, gdp);
156 if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
157 ext4_set_bit(tmp - start, bh->b_data);
158
159 tmp = ext4_inode_bitmap(sb, gdp);
160 if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
161 ext4_set_bit(tmp - start, bh->b_data);
162
163 tmp = ext4_inode_table(sb, gdp);
164 for (; tmp < ext4_inode_table(sb, gdp) +
165 sbi->s_itb_per_group; tmp++) {
166 if (!flex_bg ||
167 ext4_block_in_group(sb, tmp, block_group))
168 ext4_set_bit(tmp - start, bh->b_data);
169 }
Andreas Dilger717d50e2007-10-16 18:38:25 -0400170 /*
171 * Also if the number of blocks within the group is
172 * less than the blocksize * 8 ( which is the size
173 * of bitmap ), set rest of the block bitmap to 1
174 */
175 mark_bitmap_end(group_blocks, sb->s_blocksize * 8, bh->b_data);
176 }
Theodore Ts'oe187c652009-02-06 16:23:37 -0500177 return free_blocks - ext4_group_used_meta_blocks(sb, block_group, gdp);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400178}
179
180
Andrew Morton72b64b52006-10-11 01:21:18 -0700181/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700182 * The free blocks are managed by bitmaps. A file system contains several
183 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
184 * block for inodes, N blocks for the inode table and data blocks.
185 *
186 * The file system contains group descriptors which are located after the
187 * super block. Each descriptor contains the number of the bitmap block and
188 * the free blocks count in the block. The descriptors are loaded in memory
Aneesh Kumar K.Ve6274322007-02-20 13:57:58 -0800189 * when a file system is mounted (see ext4_fill_super).
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700190 */
191
192
193#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
194
195/**
Mingming Cao617ba132006-10-11 01:20:53 -0700196 * ext4_get_group_desc() -- load group descriptor from disk
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700197 * @sb: super block
198 * @block_group: given block group
199 * @bh: pointer to the buffer head to store the block
200 * group descriptor
201 */
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400202struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500203 ext4_group_t block_group,
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400204 struct buffer_head **bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700205{
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500206 unsigned int group_desc;
207 unsigned int offset;
Theodore Ts'o8df96752009-05-01 08:50:38 -0400208 ext4_group_t ngroups = ext4_get_groups_count(sb);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400209 struct ext4_group_desc *desc;
Mingming Cao617ba132006-10-11 01:20:53 -0700210 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700211
Theodore Ts'o8df96752009-05-01 08:50:38 -0400212 if (block_group >= ngroups) {
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400213 ext4_error(sb, "ext4_get_group_desc",
214 "block_group >= groups_count - "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -0500215 "block_group = %u, groups_count = %u",
Theodore Ts'o8df96752009-05-01 08:50:38 -0400216 block_group, ngroups);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700217
218 return NULL;
219 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700220
Mingming Cao617ba132006-10-11 01:20:53 -0700221 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
222 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700223 if (!sbi->s_group_desc[group_desc]) {
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400224 ext4_error(sb, "ext4_get_group_desc",
225 "Group descriptor not loaded - "
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500226 "block_group = %u, group_desc = %u, desc = %u",
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400227 block_group, group_desc, offset);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700228 return NULL;
229 }
230
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -0700231 desc = (struct ext4_group_desc *)(
232 (__u8 *)sbi->s_group_desc[group_desc]->b_data +
233 offset * EXT4_DESC_SIZE(sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700234 if (bh)
235 *bh = sbi->s_group_desc[group_desc];
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -0700236 return desc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700237}
238
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500239static int ext4_valid_block_bitmap(struct super_block *sb,
240 struct ext4_group_desc *desc,
241 unsigned int block_group,
242 struct buffer_head *bh)
243{
244 ext4_grpblk_t offset;
245 ext4_grpblk_t next_zero_bit;
246 ext4_fsblk_t bitmap_blk;
247 ext4_fsblk_t group_first_block;
248
249 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
250 /* with FLEX_BG, the inode/block bitmaps and itable
251 * blocks may not be in the group at all
252 * so the bitmap validation will be skipped for those groups
253 * or it has to also read the block group where the bitmaps
254 * are located to verify they are set.
255 */
256 return 1;
257 }
258 group_first_block = ext4_group_first_block_no(sb, block_group);
259
260 /* check whether block bitmap block number is set */
261 bitmap_blk = ext4_block_bitmap(sb, desc);
262 offset = bitmap_blk - group_first_block;
263 if (!ext4_test_bit(offset, bh->b_data))
264 /* bad block bitmap */
265 goto err_out;
266
267 /* check whether the inode bitmap block number is set */
268 bitmap_blk = ext4_inode_bitmap(sb, desc);
269 offset = bitmap_blk - group_first_block;
270 if (!ext4_test_bit(offset, bh->b_data))
271 /* bad block bitmap */
272 goto err_out;
273
274 /* check whether the inode table block number is set */
275 bitmap_blk = ext4_inode_table(sb, desc);
276 offset = bitmap_blk - group_first_block;
277 next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
278 offset + EXT4_SB(sb)->s_itb_per_group,
279 offset);
280 if (next_zero_bit >= offset + EXT4_SB(sb)->s_itb_per_group)
281 /* good bitmap for inode tables */
282 return 1;
283
284err_out:
Harvey Harrison46e665e2008-04-17 10:38:59 -0400285 ext4_error(sb, __func__,
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500286 "Invalid block bitmap - "
287 "block_group = %d, block = %llu",
288 block_group, bitmap_blk);
289 return 0;
290}
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700291/**
Theodore Ts'o574ca172008-07-11 19:27:31 -0400292 * ext4_read_block_bitmap()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700293 * @sb: super block
294 * @block_group: given block group
295 *
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500296 * Read the bitmap for a given block_group,and validate the
297 * bits for block/inode/inode tables are set in the bitmaps
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700298 *
299 * Return buffer_head on success or NULL in case of failure.
300 */
Andreas Dilger717d50e2007-10-16 18:38:25 -0400301struct buffer_head *
Theodore Ts'o574ca172008-07-11 19:27:31 -0400302ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700303{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400304 struct ext4_group_desc *desc;
305 struct buffer_head *bh = NULL;
Aneesh Kumar K.V7c9e69f2007-10-16 23:27:02 -0700306 ext4_fsblk_t bitmap_blk;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700307
Andreas Dilger717d50e2007-10-16 18:38:25 -0400308 desc = ext4_get_group_desc(sb, block_group, NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700309 if (!desc)
Aneesh Kumar K.V7c9e69f2007-10-16 23:27:02 -0700310 return NULL;
311 bitmap_blk = ext4_block_bitmap(sb, desc);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500312 bh = sb_getblk(sb, bitmap_blk);
313 if (unlikely(!bh)) {
Harvey Harrison46e665e2008-04-17 10:38:59 -0400314 ext4_error(sb, __func__,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700315 "Cannot read block bitmap - "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -0500316 "block_group = %u, block_bitmap = %llu",
Eric Sandeene29d1cd2008-08-02 21:21:02 -0400317 block_group, bitmap_blk);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500318 return NULL;
319 }
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500320
321 if (bitmap_uptodate(bh))
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500322 return bh;
323
Frederic Bohec806e682008-10-10 08:09:18 -0400324 lock_buffer(bh);
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500325 if (bitmap_uptodate(bh)) {
326 unlock_buffer(bh);
327 return bh;
328 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400329 ext4_lock_group(sb, block_group);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500330 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
331 ext4_init_block_bitmap(sb, bh, block_group, desc);
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500332 set_bitmap_uptodate(bh);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500333 set_buffer_uptodate(bh);
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400334 ext4_unlock_group(sb, block_group);
Aneesh Kumar K.V3300bed2009-01-03 22:33:39 -0500335 unlock_buffer(bh);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500336 return bh;
337 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400338 ext4_unlock_group(sb, block_group);
Aneesh Kumar K.V2ccb5fb2009-01-05 21:49:55 -0500339 if (buffer_uptodate(bh)) {
340 /*
341 * if not uninit if bh is uptodate,
342 * bitmap is also uptodate
343 */
344 set_bitmap_uptodate(bh);
345 unlock_buffer(bh);
346 return bh;
347 }
348 /*
349 * submit the buffer_head for read. We can
350 * safely mark the bitmap as uptodate now.
351 * We do it here so the bitmap uptodate bit
352 * get set with buffer lock held.
353 */
354 set_bitmap_uptodate(bh);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500355 if (bh_submit_read(bh) < 0) {
356 put_bh(bh);
Harvey Harrison46e665e2008-04-17 10:38:59 -0400357 ext4_error(sb, __func__,
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500358 "Cannot read block bitmap - "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -0500359 "block_group = %u, block_bitmap = %llu",
Eric Sandeene29d1cd2008-08-02 21:21:02 -0400360 block_group, bitmap_blk);
Aneesh Kumar K.Vabcb2942008-01-28 23:58:27 -0500361 return NULL;
362 }
Aneesh Kumar K.V519deca2008-05-15 14:43:20 -0400363 ext4_valid_block_bitmap(sb, desc, block_group, bh);
364 /*
365 * file system mounted not to panic on error,
366 * continue with corrupt bitmap
367 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700368 return bh;
369}
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700370
371/**
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500372 * ext4_add_groupblocks() -- Add given blocks to an existing group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700373 * @handle: handle to this transaction
374 * @sb: super block
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500375 * @block: start physcial block to add to the block group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700376 * @count: number of blocks to free
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -0400377 *
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500378 * This marks the blocks as free in the bitmap. We ask the
379 * mballoc to reload the buddy after this by setting group
380 * EXT4_GROUP_INFO_NEED_INIT_BIT flag
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700381 */
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500382void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,
383 ext4_fsblk_t block, unsigned long count)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700384{
385 struct buffer_head *bitmap_bh = NULL;
386 struct buffer_head *gd_bh;
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500387 ext4_group_t block_group;
Mingming Cao617ba132006-10-11 01:20:53 -0700388 ext4_grpblk_t bit;
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500389 unsigned int i;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400390 struct ext4_group_desc *desc;
391 struct ext4_super_block *es;
Mingming Cao617ba132006-10-11 01:20:53 -0700392 struct ext4_sb_info *sbi;
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500393 int err = 0, ret, blk_free_count;
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500394 ext4_grpblk_t blocks_freed;
395 struct ext4_group_info *grp;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700396
Mingming Cao617ba132006-10-11 01:20:53 -0700397 sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700398 es = sbi->s_es;
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500399 ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700400
Mingming Cao3a5b2ec2006-10-11 01:21:05 -0700401 ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -0500402 grp = ext4_get_group_info(sb, block_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700403 /*
404 * Check to see if we are freeing blocks across a group
405 * boundary.
406 */
Mingming Cao617ba132006-10-11 01:20:53 -0700407 if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500408 goto error_return;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700409 }
Theodore Ts'o574ca172008-07-11 19:27:31 -0400410 bitmap_bh = ext4_read_block_bitmap(sb, block_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700411 if (!bitmap_bh)
412 goto error_return;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400413 desc = ext4_get_group_desc(sb, block_group, &gd_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700414 if (!desc)
415 goto error_return;
416
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700417 if (in_range(ext4_block_bitmap(sb, desc), block, count) ||
418 in_range(ext4_inode_bitmap(sb, desc), block, count) ||
419 in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
420 in_range(block + count - 1, ext4_inode_table(sb, desc),
Aneesh Kumar K.Vcb47dce2008-01-28 23:58:27 -0500421 sbi->s_itb_per_group)) {
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500422 ext4_error(sb, __func__,
423 "Adding blocks in system zones - "
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400424 "Block = %llu, count = %lu",
425 block, count);
Aneesh Kumar K.Vcb47dce2008-01-28 23:58:27 -0500426 goto error_return;
427 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700428
429 /*
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500430 * We are about to add blocks to the bitmap,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700431 * so we need undo access.
432 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700433 BUFFER_TRACE(bitmap_bh, "getting undo access");
Mingming Cao617ba132006-10-11 01:20:53 -0700434 err = ext4_journal_get_undo_access(handle, bitmap_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700435 if (err)
436 goto error_return;
437
438 /*
439 * We are about to modify some metadata. Call the journal APIs
440 * to unshare ->b_data if a currently-committing transaction is
441 * using it
442 */
443 BUFFER_TRACE(gd_bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700444 err = ext4_journal_get_write_access(handle, gd_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700445 if (err)
446 goto error_return;
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -0500447 /*
448 * make sure we don't allow a parallel init on other groups in the
449 * same buddy cache
450 */
451 down_write(&grp->alloc_sem);
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500452 for (i = 0, blocks_freed = 0; i < count; i++) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700453 BUFFER_TRACE(bitmap_bh, "clear bit");
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400454 if (!ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700455 bit + i, bitmap_bh->b_data)) {
Harvey Harrison46e665e2008-04-17 10:38:59 -0400456 ext4_error(sb, __func__,
Mingming Cao2ae02102006-10-11 01:21:11 -0700457 "bit already cleared for block %llu",
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700458 (ext4_fsblk_t)(block + i));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700459 BUFFER_TRACE(bitmap_bh, "bit already cleared");
460 } else {
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500461 blocks_freed++;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700462 }
463 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400464 ext4_lock_group(sb, block_group);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500465 blk_free_count = blocks_freed + ext4_free_blks_count(sb, desc);
466 ext4_free_blks_set(sb, desc, blk_free_count);
Andreas Dilger717d50e2007-10-16 18:38:25 -0400467 desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc);
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -0400468 ext4_unlock_group(sb, block_group);
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500469 percpu_counter_add(&sbi->s_freeblocks_counter, blocks_freed);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700470
Jose R. Santos772cb7c2008-07-11 19:27:31 -0400471 if (sbi->s_log_groups_per_flex) {
472 ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
Theodore Ts'o9f24e422009-03-04 19:09:10 -0500473 atomic_add(blocks_freed,
474 &sbi->s_flex_groups[flex_group].free_blocks);
Jose R. Santos772cb7c2008-07-11 19:27:31 -0400475 }
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -0500476 /*
477 * request to reload the buddy with the
478 * new bitmap information
479 */
480 set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &(grp->bb_state));
481 ext4_mb_update_group_info(grp, blocks_freed);
482 up_write(&grp->alloc_sem);
Jose R. Santos772cb7c2008-07-11 19:27:31 -0400483
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700484 /* We dirtied the bitmap block */
485 BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
Frank Mayhar03901312009-01-07 00:06:22 -0500486 err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700487
488 /* And the group descriptor block */
489 BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
Frank Mayhar03901312009-01-07 00:06:22 -0500490 ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500491 if (!err)
492 err = ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700493 sb->s_dirt = 1;
Aneesh Kumar K.Ve21675d2009-01-05 21:36:02 -0500494
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700495error_return:
496 brelse(bitmap_bh);
Mingming Cao617ba132006-10-11 01:20:53 -0700497 ext4_std_error(sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700498 return;
499}
500
501/**
Mingming Cao617ba132006-10-11 01:20:53 -0700502 * ext4_free_blocks() -- Free given blocks and update quota
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700503 * @handle: handle for this transaction
504 * @inode: inode
505 * @block: start physical block to free
506 * @count: number of blocks to count
Alex Tomasc9de5602008-01-29 00:19:52 -0500507 * @metadata: Are these metadata blocks
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700508 */
Mingming Cao617ba132006-10-11 01:20:53 -0700509void ext4_free_blocks(handle_t *handle, struct inode *inode,
Alex Tomasc9de5602008-01-29 00:19:52 -0500510 ext4_fsblk_t block, unsigned long count,
511 int metadata)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700512{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400513 struct super_block *sb;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700514 unsigned long dquot_freed_blocks;
515
Alex Tomasc9de5602008-01-29 00:19:52 -0500516 /* this isn't the right place to decide whether block is metadata
517 * inode.c/extents.c knows better, but for safety ... */
Aneesh Kumar K.Va1aebc12008-10-10 20:13:31 -0400518 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
519 metadata = 1;
520
521 /* We need to make sure we don't reuse
522 * block released untill the transaction commit.
523 * writeback mode have weak data consistency so
524 * don't force data as metadata when freeing block
525 * for writeback mode.
526 */
527 if (metadata == 0 && !ext4_should_writeback_data(inode))
Alex Tomasc9de5602008-01-29 00:19:52 -0500528 metadata = 1;
529
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700530 sb = inode->i_sb;
Alex Tomasc9de5602008-01-29 00:19:52 -0500531
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -0400532 ext4_mb_free_blocks(handle, inode, block, count,
533 metadata, &dquot_freed_blocks);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700534 if (dquot_freed_blocks)
Jan Karaa269eb12009-01-26 17:04:39 +0100535 vfs_dq_free_block(inode, dquot_freed_blocks);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700536 return;
537}
538
Eric Sandeen8c3bf8a2008-10-28 00:08:12 -0400539/**
540 * ext4_has_free_blocks()
541 * @sbi: in-core super block structure.
542 * @nblocks: number of needed blocks
543 *
544 * Check if filesystem has nblocks free & available for allocation.
545 * On success return 1, return 0 on failure.
546 */
547int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks)
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400548{
Eric Sandeena9960312008-10-28 00:08:17 -0400549 s64 free_blocks, dirty_blocks, root_blocks;
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400550 struct percpu_counter *fbc = &sbi->s_freeblocks_counter;
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400551 struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400552
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400553 free_blocks = percpu_counter_read_positive(fbc);
554 dirty_blocks = percpu_counter_read_positive(dbc);
Eric Sandeena9960312008-10-28 00:08:17 -0400555 root_blocks = ext4_r_blocks_count(sbi->s_es);
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400556
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400557 if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
558 EXT4_FREEBLOCKS_WATERMARK) {
Andrew Morton02d21162008-12-09 13:14:14 -0800559 free_blocks = percpu_counter_sum_positive(fbc);
560 dirty_blocks = percpu_counter_sum_positive(dbc);
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400561 if (dirty_blocks < 0) {
562 printk(KERN_CRIT "Dirty block accounting "
563 "went wrong %lld\n",
Alexander Beregalov8f72fbd2008-10-29 17:13:08 -0400564 (long long)dirty_blocks);
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400565 }
566 }
567 /* Check whether we have space after
Eric Sandeena9960312008-10-28 00:08:17 -0400568 * accounting for current dirty blocks & root reserved blocks.
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400569 */
Eric Sandeena9960312008-10-28 00:08:17 -0400570 if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks))
571 return 1;
Aneesh Kumar K.V5c791612008-10-08 23:12:24 -0400572
Eric Sandeena9960312008-10-28 00:08:17 -0400573 /* Hm, nope. Are (enough) root reserved blocks available? */
David Howells4c9c5442008-11-14 10:38:51 +1100574 if (sbi->s_resuid == current_fsuid() ||
Eric Sandeena9960312008-10-28 00:08:17 -0400575 ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||
576 capable(CAP_SYS_RESOURCE)) {
577 if (free_blocks >= (nblocks + dirty_blocks))
578 return 1;
579 }
580
581 return 0;
Aneesh Kumar K.Va30d5422008-10-09 10:56:23 -0400582}
Mingming Cao07031432008-07-11 19:27:31 -0400583
Eric Sandeen8c3bf8a2008-10-28 00:08:12 -0400584int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
585 s64 nblocks)
586{
587 if (ext4_has_free_blocks(sbi, nblocks)) {
588 percpu_counter_add(&sbi->s_dirtyblocks_counter, nblocks);
589 return 0;
590 } else
591 return -ENOSPC;
592}
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700593
594/**
Mingming Cao617ba132006-10-11 01:20:53 -0700595 * ext4_should_retry_alloc()
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700596 * @sb: super block
597 * @retries number of attemps has been made
598 *
Mingming Cao617ba132006-10-11 01:20:53 -0700599 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700600 * it is profitable to retry the operation, this function will wait
601 * for the current or commiting transaction to complete, and then
602 * return TRUE.
603 *
604 * if the total number of retries exceed three times, return FALSE.
605 */
Mingming Cao617ba132006-10-11 01:20:53 -0700606int ext4_should_retry_alloc(struct super_block *sb, int *retries)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700607{
Eric Sandeen8f64b322009-02-26 00:57:35 -0500608 if (!ext4_has_free_blocks(EXT4_SB(sb), 1) ||
609 (*retries)++ > 3 ||
610 !EXT4_SB(sb)->s_journal)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700611 return 0;
612
613 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
614
Mingming Caodab291a2006-10-11 01:21:01 -0700615 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700616}
617
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400618/*
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400619 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
620 *
621 * @handle: handle to this transaction
622 * @inode: file inode
623 * @goal: given target block(filesystem wide)
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500624 * @count: pointer to total number of blocks needed
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400625 * @errp: error code
626 *
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500627 * Return 1st allocated block number on success, *count stores total account
Aneesh Kumar K.V654b4902008-07-11 19:27:31 -0400628 * error stores in errp pointer
629 */
630ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
631 ext4_fsblk_t goal, unsigned long *count, int *errp)
632{
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500633 struct ext4_allocation_request ar;
Mingming Caod2a17632008-07-14 17:52:37 -0400634 ext4_fsblk_t ret;
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500635
636 memset(&ar, 0, sizeof(ar));
637 /* Fill with neighbour allocated blocks */
638 ar.inode = inode;
639 ar.goal = goal;
640 ar.len = count ? *count : 1;
641
642 ret = ext4_mb_new_blocks(handle, &ar, errp);
643 if (count)
644 *count = ar.len;
645
Mingming Caod2a17632008-07-14 17:52:37 -0400646 /*
647 * Account for the allocated meta blocks
648 */
Aneesh Kumar K.V166348d2008-09-08 23:08:40 -0400649 if (!(*errp) && EXT4_I(inode)->i_delalloc_reserved_flag) {
Mingming Caod2a17632008-07-14 17:52:37 -0400650 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
Theodore Ts'o97df5d12008-12-12 12:41:28 -0500651 EXT4_I(inode)->i_allocated_meta_blocks += ar.len;
Mingming Caod2a17632008-07-14 17:52:37 -0400652 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
653 }
654 return ret;
655}
656
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700657/**
Mingming Cao617ba132006-10-11 01:20:53 -0700658 * ext4_count_free_blocks() -- count filesystem free blocks
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700659 * @sb: superblock
660 *
661 * Adds up the number of free blocks from each block group.
662 */
Mingming Cao617ba132006-10-11 01:20:53 -0700663ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700664{
Mingming Cao617ba132006-10-11 01:20:53 -0700665 ext4_fsblk_t desc_count;
666 struct ext4_group_desc *gdp;
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500667 ext4_group_t i;
Theodore Ts'o8df96752009-05-01 08:50:38 -0400668 ext4_group_t ngroups = ext4_get_groups_count(sb);
Mingming Cao617ba132006-10-11 01:20:53 -0700669#ifdef EXT4FS_DEBUG
670 struct ext4_super_block *es;
671 ext4_fsblk_t bitmap_count;
Theodore Ts'o498e5f22008-11-05 00:14:04 -0500672 unsigned int x;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700673 struct buffer_head *bitmap_bh = NULL;
674
Mingming Cao617ba132006-10-11 01:20:53 -0700675 es = EXT4_SB(sb)->s_es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700676 desc_count = 0;
677 bitmap_count = 0;
678 gdp = NULL;
679
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700680 for (i = 0; i < ngroups; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -0700681 gdp = ext4_get_group_desc(sb, i, NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700682 if (!gdp)
683 continue;
Thadeu Lima de Souza Cascardo9fd97842009-01-26 19:26:26 -0500684 desc_count += ext4_free_blks_count(sb, gdp);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700685 brelse(bitmap_bh);
Theodore Ts'o574ca172008-07-11 19:27:31 -0400686 bitmap_bh = ext4_read_block_bitmap(sb, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700687 if (bitmap_bh == NULL)
688 continue;
689
Mingming Cao617ba132006-10-11 01:20:53 -0700690 x = ext4_count_free(bitmap_bh, sb->s_blocksize);
Thadeu Lima de Souza Cascardo9fd97842009-01-26 19:26:26 -0500691 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
692 i, ext4_free_blks_count(sb, gdp), x);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700693 bitmap_count += x;
694 }
695 brelse(bitmap_bh);
Theodore Ts'o47760042008-09-08 23:00:52 -0400696 printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu"
697 ", computed = %llu, %llu\n", ext4_free_blocks_count(es),
698 desc_count, bitmap_count);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700699 return bitmap_count;
700#else
701 desc_count = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700702 for (i = 0; i < ngroups; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -0700703 gdp = ext4_get_group_desc(sb, i, NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700704 if (!gdp)
705 continue;
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500706 desc_count += ext4_free_blks_count(sb, gdp);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700707 }
708
709 return desc_count;
710#endif
711}
712
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500713static inline int test_root(ext4_group_t a, int b)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700714{
715 int num = b;
716
717 while (a > num)
718 num *= b;
719 return num == a;
720}
721
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500722static int ext4_group_sparse(ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700723{
724 if (group <= 1)
725 return 1;
726 if (!(group & 1))
727 return 0;
728 return (test_root(group, 7) || test_root(group, 5) ||
729 test_root(group, 3));
730}
731
732/**
Mingming Cao617ba132006-10-11 01:20:53 -0700733 * ext4_bg_has_super - number of blocks used by the superblock in group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700734 * @sb: superblock for filesystem
735 * @group: group number to check
736 *
737 * Return the number of blocks used by the superblock (primary or backup)
738 * in this group. Currently this will be only 0 or 1.
739 */
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500740int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700741{
Mingming Cao617ba132006-10-11 01:20:53 -0700742 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
743 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
744 !ext4_group_sparse(group))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700745 return 0;
746 return 1;
747}
748
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500749static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
750 ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700751{
Mingming Cao617ba132006-10-11 01:20:53 -0700752 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500753 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
754 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700755
756 if (group == first || group == first + 1 || group == last)
757 return 1;
758 return 0;
759}
760
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500761static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
762 ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700763{
Akinobu Mita859cb932008-02-06 01:40:17 -0800764 return ext4_bg_has_super(sb, group) ? EXT4_SB(sb)->s_gdb_count : 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700765}
766
767/**
Mingming Cao617ba132006-10-11 01:20:53 -0700768 * ext4_bg_num_gdb - number of blocks used by the group table in group
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700769 * @sb: superblock for filesystem
770 * @group: group number to check
771 *
772 * Return the number of blocks used by the group descriptor table
773 * (primary or backup) in this group. In the future there may be a
774 * different number of descriptor blocks in each group.
775 */
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500776unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700777{
778 unsigned long first_meta_bg =
Mingming Cao617ba132006-10-11 01:20:53 -0700779 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
780 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700781
Mingming Cao617ba132006-10-11 01:20:53 -0700782 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700783 metagroup < first_meta_bg)
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400784 return ext4_bg_num_gdb_nometa(sb, group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700785
Mingming Cao617ba132006-10-11 01:20:53 -0700786 return ext4_bg_num_gdb_meta(sb,group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700787
788}
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -0400789