]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/ext4/balloc.c
UBUNTU: Ubuntu-4.15.0-96.97
[mirror_ubuntu-bionic-kernel.git] / fs / ext4 / balloc.c
CommitLineData
b2441318 1// SPDX-License-Identifier: GPL-2.0
ac27a0ec 2/*
617ba13b 3 * linux/fs/ext4/balloc.c
ac27a0ec
DK
4 *
5 * Copyright (C) 1992, 1993, 1994, 1995
6 * Remy Card (card@masi.ibp.fr)
7 * Laboratoire MASI - Institut Blaise Pascal
8 * Universite Pierre et Marie Curie (Paris VI)
9 *
10 * Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993
11 * Big-endian to little-endian byte-swapping/bitmaps by
12 * David S. Miller (davem@caip.rutgers.edu), 1995
13 */
14
15#include <linux/time.h>
16#include <linux/capability.h>
17#include <linux/fs.h>
ac27a0ec
DK
18#include <linux/quotaops.h>
19#include <linux/buffer_head.h>
3dcf5451
CH
20#include "ext4.h"
21#include "ext4_jbd2.h"
e21675d4 22#include "mballoc.h"
3dcf5451 23
0562e0ba
JZ
24#include <trace/events/ext4.h>
25
5f163cc7
ES
26static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
27 ext4_group_t block_group);
ac27a0ec
DK
28/*
29 * balloc.c contains the blocks allocation and deallocation routines
30 */
31
bd86298e
LC
32/*
33 * Calculate block group number for a given block number
34 */
35ext4_group_t ext4_get_group_number(struct super_block *sb,
36 ext4_fsblk_t block)
37{
38 ext4_group_t group;
39
40 if (test_opt2(sb, STD_GROUP_SIZE))
960fd856
TT
41 group = (block -
42 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) >>
bd86298e
LC
43 (EXT4_BLOCK_SIZE_BITS(sb) + EXT4_CLUSTER_BITS(sb) + 3);
44 else
45 ext4_get_group_no_and_offset(sb, block, &group, NULL);
46 return group;
47}
48
72b64b59 49/*
3212a80a
TT
50 * Calculate the block group number and offset into the block/cluster
51 * allocation bitmap, given a block number
72b64b59
AM
52 */
53void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
fd2d4291 54 ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)
72b64b59 55{
8c55e204 56 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
72b64b59
AM
57 ext4_grpblk_t offset;
58
8c55e204 59 blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
3212a80a
TT
60 offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb)) >>
61 EXT4_SB(sb)->s_cluster_bits;
72b64b59
AM
62 if (offsetp)
63 *offsetp = offset;
64 if (blockgrpp)
8c55e204 65 *blockgrpp = blocknr;
72b64b59
AM
66
67}
68
68911009
LC
69/*
70 * Check whether the 'block' lives within the 'block_group'. Returns 1 if so
71 * and 0 otherwise.
72 */
73static inline int ext4_block_in_group(struct super_block *sb,
74 ext4_fsblk_t block,
75 ext4_group_t block_group)
0bf7e837
JS
76{
77 ext4_group_t actual_group;
68911009 78
bd86298e 79 actual_group = ext4_get_group_number(sb, block);
68911009 80 return (actual_group == block_group) ? 1 : 0;
0bf7e837
JS
81}
82
d5b8f310
TT
83/* Return the number of clusters used for file system metadata; this
84 * represents the overhead needed by the file system.
85 */
c197855e
SH
86static unsigned ext4_num_overhead_clusters(struct super_block *sb,
87 ext4_group_t block_group,
88 struct ext4_group_desc *gdp)
0bf7e837 89{
d5b8f310
TT
90 unsigned num_clusters;
91 int block_cluster = -1, inode_cluster = -1, itbl_cluster = -1, i, c;
92 ext4_fsblk_t start = ext4_group_first_block_no(sb, block_group);
93 ext4_fsblk_t itbl_blk;
0bf7e837 94 struct ext4_sb_info *sbi = EXT4_SB(sb);
0bf7e837 95
d5b8f310
TT
96 /* This is the number of clusters used by the superblock,
97 * block group descriptors, and reserved block group
98 * descriptor blocks */
99 num_clusters = ext4_num_base_meta_clusters(sb, block_group);
100
101 /*
102 * For the allocation bitmaps and inode table, we first need
103 * to check to see if the block is in the block group. If it
104 * is, then check to see if the cluster is already accounted
105 * for in the clusters used for the base metadata cluster, or
106 * if we can increment the base metadata cluster to include
107 * that block. Otherwise, we will have to track the cluster
108 * used for the allocation bitmap or inode table explicitly.
109 * Normally all of these blocks are contiguous, so the special
110 * case handling shouldn't be necessary except for *very*
111 * unusual file system layouts.
112 */
113 if (ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), block_group)) {
b0dd6b70
TT
114 block_cluster = EXT4_B2C(sbi,
115 ext4_block_bitmap(sb, gdp) - start);
d5b8f310
TT
116 if (block_cluster < num_clusters)
117 block_cluster = -1;
118 else if (block_cluster == num_clusters) {
119 num_clusters++;
120 block_cluster = -1;
121 }
122 }
123
124 if (ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp), block_group)) {
125 inode_cluster = EXT4_B2C(sbi,
b0dd6b70 126 ext4_inode_bitmap(sb, gdp) - start);
d5b8f310
TT
127 if (inode_cluster < num_clusters)
128 inode_cluster = -1;
129 else if (inode_cluster == num_clusters) {
130 num_clusters++;
131 inode_cluster = -1;
132 }
133 }
134
135 itbl_blk = ext4_inode_table(sb, gdp);
136 for (i = 0; i < sbi->s_itb_per_group; i++) {
137 if (ext4_block_in_group(sb, itbl_blk + i, block_group)) {
b0dd6b70 138 c = EXT4_B2C(sbi, itbl_blk + i - start);
d5b8f310
TT
139 if ((c < num_clusters) || (c == inode_cluster) ||
140 (c == block_cluster) || (c == itbl_cluster))
141 continue;
142 if (c == num_clusters) {
143 num_clusters++;
144 continue;
145 }
146 num_clusters++;
147 itbl_cluster = c;
0bf7e837
JS
148 }
149 }
d5b8f310
TT
150
151 if (block_cluster != -1)
152 num_clusters++;
153 if (inode_cluster != -1)
154 num_clusters++;
155
156 return num_clusters;
0bf7e837 157}
c2ea3fde 158
d5b8f310
TT
159static unsigned int num_clusters_in_group(struct super_block *sb,
160 ext4_group_t block_group)
49f7f9af 161{
d5b8f310
TT
162 unsigned int blocks;
163
49f7f9af
TT
164 if (block_group == ext4_get_groups_count(sb) - 1) {
165 /*
166 * Even though mke2fs always initializes the first and
167 * last group, just in case some other tool was used,
168 * we need to make sure we calculate the right free
169 * blocks.
170 */
d5b8f310 171 blocks = ext4_blocks_count(EXT4_SB(sb)->s_es) -
49f7f9af
TT
172 ext4_group_first_block_no(sb, block_group);
173 } else
d5b8f310
TT
174 blocks = EXT4_BLOCKS_PER_GROUP(sb);
175 return EXT4_NUM_B2C(EXT4_SB(sb), blocks);
49f7f9af
TT
176}
177
fd034a84 178/* Initializes an uninitialized block bitmap */
aef4885a 179static int ext4_init_block_bitmap(struct super_block *sb,
c197855e
SH
180 struct buffer_head *bh,
181 ext4_group_t block_group,
182 struct ext4_group_desc *gdp)
717d50e4 183{
d5b8f310 184 unsigned int bit, bit_max;
717d50e4 185 struct ext4_sb_info *sbi = EXT4_SB(sb);
fd034a84 186 ext4_fsblk_t start, tmp;
bdfb6ff4 187 struct ext4_group_info *grp;
fd034a84
TT
188
189 J_ASSERT_BH(bh, buffer_locked(bh));
190
191 /* If checksum is bad mark all blocks used to prevent allocation
192 * essentially implementing a per-group read-only flag. */
feb0ab32 193 if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
bdfb6ff4 194 grp = ext4_get_group_info(sb, block_group);
e43bb4e6
NJ
195 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
196 percpu_counter_sub(&sbi->s_freeclusters_counter,
197 grp->bb_free);
bdfb6ff4 198 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
e43bb4e6
NJ
199 if (!EXT4_MB_GRP_IBITMAP_CORRUPT(grp)) {
200 int count;
201 count = ext4_free_inodes_count(sb, gdp);
202 percpu_counter_sub(&sbi->s_freeinodes_counter,
203 count);
204 }
bdfb6ff4 205 set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
6a797d27 206 return -EFSBADCRC;
717d50e4 207 }
fd034a84 208 memset(bh->b_data, 0, sb->s_blocksize);
717d50e4 209
d5b8f310 210 bit_max = ext4_num_base_meta_clusters(sb, block_group);
5b9554dc
TT
211 if ((bit_max >> 3) >= bh->b_size)
212 return -EFSCORRUPTED;
213
fd034a84
TT
214 for (bit = 0; bit < bit_max; bit++)
215 ext4_set_bit(bit, bh->b_data);
d00a6d7b 216
fd034a84 217 start = ext4_group_first_block_no(sb, block_group);
717d50e4 218
fd034a84
TT
219 /* Set bits for block and inode bitmaps, and inode table */
220 tmp = ext4_block_bitmap(sb, gdp);
5422f818 221 if (ext4_block_in_group(sb, tmp, block_group))
d5b8f310 222 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
717d50e4 223
fd034a84 224 tmp = ext4_inode_bitmap(sb, gdp);
5422f818 225 if (ext4_block_in_group(sb, tmp, block_group))
d5b8f310 226 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
0bf7e837 227
fd034a84
TT
228 tmp = ext4_inode_table(sb, gdp);
229 for (; tmp < ext4_inode_table(sb, gdp) +
230 sbi->s_itb_per_group; tmp++) {
5422f818 231 if (ext4_block_in_group(sb, tmp, block_group))
d5b8f310 232 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
717d50e4 233 }
d5b8f310 234
fd034a84
TT
235 /*
236 * Also if the number of blocks within the group is less than
237 * the blocksize * 8 ( which is the size of bitmap ), set rest
238 * of the block bitmap to 1
239 */
d5b8f310 240 ext4_mark_bitmap_end(num_clusters_in_group(sb, block_group),
fd034a84 241 sb->s_blocksize * 8, bh->b_data);
aef4885a 242 return 0;
717d50e4
AD
243}
244
fd034a84
TT
245/* Return the number of free blocks in a block group. It is used when
246 * the block bitmap is uninitialized, so we can't just count the bits
247 * in the bitmap. */
cff1dfd7
TT
248unsigned ext4_free_clusters_after_init(struct super_block *sb,
249 ext4_group_t block_group,
250 struct ext4_group_desc *gdp)
fd034a84 251{
d5b8f310
TT
252 return num_clusters_in_group(sb, block_group) -
253 ext4_num_overhead_clusters(sb, block_group, gdp);
fd034a84 254}
717d50e4 255
ac27a0ec
DK
256/*
257 * The free blocks are managed by bitmaps. A file system contains several
258 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
259 * block for inodes, N blocks for the inode table and data blocks.
260 *
261 * The file system contains group descriptors which are located after the
262 * super block. Each descriptor contains the number of the bitmap block and
263 * the free blocks count in the block. The descriptors are loaded in memory
e627432c 264 * when a file system is mounted (see ext4_fill_super).
ac27a0ec
DK
265 */
266
ac27a0ec 267/**
617ba13b 268 * ext4_get_group_desc() -- load group descriptor from disk
ac27a0ec
DK
269 * @sb: super block
270 * @block_group: given block group
271 * @bh: pointer to the buffer head to store the block
272 * group descriptor
273 */
af5bc92d 274struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
fd2d4291 275 ext4_group_t block_group,
af5bc92d 276 struct buffer_head **bh)
ac27a0ec 277{
498e5f24
TT
278 unsigned int group_desc;
279 unsigned int offset;
8df9675f 280 ext4_group_t ngroups = ext4_get_groups_count(sb);
af5bc92d 281 struct ext4_group_desc *desc;
617ba13b 282 struct ext4_sb_info *sbi = EXT4_SB(sb);
ac27a0ec 283
8df9675f 284 if (block_group >= ngroups) {
12062ddd
ES
285 ext4_error(sb, "block_group >= groups_count - block_group = %u,"
286 " groups_count = %u", block_group, ngroups);
ac27a0ec
DK
287
288 return NULL;
289 }
ac27a0ec 290
617ba13b
MC
291 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
292 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
ac27a0ec 293 if (!sbi->s_group_desc[group_desc]) {
12062ddd 294 ext4_error(sb, "Group descriptor not loaded - "
498e5f24 295 "block_group = %u, group_desc = %u, desc = %u",
af5bc92d 296 block_group, group_desc, offset);
ac27a0ec
DK
297 return NULL;
298 }
299
0d1ee42f
AR
300 desc = (struct ext4_group_desc *)(
301 (__u8 *)sbi->s_group_desc[group_desc]->b_data +
302 offset * EXT4_DESC_SIZE(sb));
ac27a0ec
DK
303 if (bh)
304 *bh = sbi->s_group_desc[group_desc];
0d1ee42f 305 return desc;
ac27a0ec
DK
306}
307
7a4c5de2
TT
308/*
309 * Return the block number which was discovered to be invalid, or 0 if
310 * the block bitmap is valid.
311 */
312static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb,
313 struct ext4_group_desc *desc,
dbde0abe 314 ext4_group_t block_group,
7a4c5de2 315 struct buffer_head *bh)
abcb2947 316{
e674e5cb 317 struct ext4_sb_info *sbi = EXT4_SB(sb);
abcb2947
AK
318 ext4_grpblk_t offset;
319 ext4_grpblk_t next_zero_bit;
6b1ab264 320 ext4_grpblk_t max_bit = EXT4_CLUSTERS_PER_GROUP(sb);
7a4c5de2 321 ext4_fsblk_t blk;
abcb2947
AK
322 ext4_fsblk_t group_first_block;
323
e2b911c5 324 if (ext4_has_feature_flex_bg(sb)) {
abcb2947
AK
325 /* with FLEX_BG, the inode/block bitmaps and itable
326 * blocks may not be in the group at all
327 * so the bitmap validation will be skipped for those groups
328 * or it has to also read the block group where the bitmaps
329 * are located to verify they are set.
330 */
7a4c5de2 331 return 0;
abcb2947
AK
332 }
333 group_first_block = ext4_group_first_block_no(sb, block_group);
334
335 /* check whether block bitmap block number is set */
7a4c5de2
TT
336 blk = ext4_block_bitmap(sb, desc);
337 offset = blk - group_first_block;
6b1ab264 338 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
87899c61 339 !ext4_test_bit(EXT4_B2C(sbi, offset), bh->b_data))
abcb2947 340 /* bad block bitmap */
7a4c5de2 341 return blk;
abcb2947
AK
342
343 /* check whether the inode bitmap block number is set */
7a4c5de2
TT
344 blk = ext4_inode_bitmap(sb, desc);
345 offset = blk - group_first_block;
6b1ab264 346 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
87899c61 347 !ext4_test_bit(EXT4_B2C(sbi, offset), bh->b_data))
abcb2947 348 /* bad block bitmap */
7a4c5de2 349 return blk;
abcb2947
AK
350
351 /* check whether the inode table block number is set */
7a4c5de2
TT
352 blk = ext4_inode_table(sb, desc);
353 offset = blk - group_first_block;
6b1ab264
LC
354 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
355 EXT4_B2C(sbi, offset + sbi->s_itb_per_group) >= max_bit)
87899c61 356 return blk;
abcb2947 357 next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
e674e5cb
DW
358 EXT4_B2C(sbi, offset + EXT4_SB(sb)->s_itb_per_group),
359 EXT4_B2C(sbi, offset));
360 if (next_zero_bit <
361 EXT4_B2C(sbi, offset + EXT4_SB(sb)->s_itb_per_group))
7a4c5de2
TT
362 /* bad bitmap for inode tables */
363 return blk;
abcb2947
AK
364 return 0;
365}
fa77dcfa 366
9008a58e
DW
367static int ext4_validate_block_bitmap(struct super_block *sb,
368 struct ext4_group_desc *desc,
369 ext4_group_t block_group,
370 struct buffer_head *bh)
fa77dcfa 371{
7a4c5de2 372 ext4_fsblk_t blk;
163a203d 373 struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
e43bb4e6 374 struct ext4_sb_info *sbi = EXT4_SB(sb);
7a4c5de2 375
9008a58e
DW
376 if (buffer_verified(bh))
377 return 0;
378 if (EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
379 return -EFSCORRUPTED;
fa77dcfa
DW
380
381 ext4_lock_group(sb, block_group);
8df3cfc1
TT
382 if (buffer_verified(bh))
383 goto verified;
9008a58e
DW
384 if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
385 desc, bh))) {
7a4c5de2 386 ext4_unlock_group(sb, block_group);
9008a58e 387 ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
e43bb4e6
NJ
388 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
389 percpu_counter_sub(&sbi->s_freeclusters_counter,
390 grp->bb_free);
163a203d 391 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
9008a58e 392 return -EFSBADCRC;
7a4c5de2 393 }
9008a58e
DW
394 blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
395 if (unlikely(blk != 0)) {
7a4c5de2 396 ext4_unlock_group(sb, block_group);
9008a58e
DW
397 ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
398 block_group, blk);
e43bb4e6
NJ
399 if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
400 percpu_counter_sub(&sbi->s_freeclusters_counter,
401 grp->bb_free);
163a203d 402 set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
9008a58e 403 return -EFSCORRUPTED;
7a4c5de2
TT
404 }
405 set_buffer_verified(bh);
8df3cfc1 406verified:
fa77dcfa 407 ext4_unlock_group(sb, block_group);
9008a58e 408 return 0;
fa77dcfa
DW
409}
410
ac27a0ec 411/**
15b49132 412 * ext4_read_block_bitmap_nowait()
ac27a0ec
DK
413 * @sb: super block
414 * @block_group: given block group
415 *
abcb2947
AK
416 * Read the bitmap for a given block_group,and validate the
417 * bits for block/inode/inode tables are set in the bitmaps
ac27a0ec
DK
418 *
419 * Return buffer_head on success or NULL in case of failure.
420 */
717d50e4 421struct buffer_head *
813e5727 422ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
ac27a0ec 423{
af5bc92d 424 struct ext4_group_desc *desc;
87899c61 425 struct ext4_sb_info *sbi = EXT4_SB(sb);
813e5727 426 struct buffer_head *bh;
7c9e69fa 427 ext4_fsblk_t bitmap_blk;
9008a58e 428 int err;
ac27a0ec 429
717d50e4 430 desc = ext4_get_group_desc(sb, block_group, NULL);
ac27a0ec 431 if (!desc)
9008a58e 432 return ERR_PTR(-EFSCORRUPTED);
7c9e69fa 433 bitmap_blk = ext4_block_bitmap(sb, desc);
87899c61
TT
434 if ((bitmap_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||
435 (bitmap_blk >= ext4_blocks_count(sbi->s_es))) {
436 ext4_error(sb, "Invalid block bitmap block %llu in "
437 "block_group %u", bitmap_blk, block_group);
438 return ERR_PTR(-EFSCORRUPTED);
439 }
abcb2947
AK
440 bh = sb_getblk(sb, bitmap_blk);
441 if (unlikely(!bh)) {
5ab7e47d
WS
442 ext4_warning(sb, "Cannot get buffer for block bitmap - "
443 "block_group = %u, block_bitmap = %llu",
444 block_group, bitmap_blk);
9008a58e 445 return ERR_PTR(-ENOMEM);
abcb2947 446 }
2ccb5fb9
AK
447
448 if (bitmap_uptodate(bh))
fa77dcfa 449 goto verify;
abcb2947 450
c806e68f 451 lock_buffer(bh);
2ccb5fb9
AK
452 if (bitmap_uptodate(bh)) {
453 unlock_buffer(bh);
fa77dcfa 454 goto verify;
2ccb5fb9 455 }
955ce5f5 456 ext4_lock_group(sb, block_group);
f128f0f4
TT
457 if (ext4_has_group_desc_csum(sb) &&
458 (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))) {
459 if (block_group == 0) {
460 ext4_unlock_group(sb, block_group);
461 unlock_buffer(bh);
462 ext4_error(sb, "Block bitmap for bg 0 marked "
463 "uninitialized");
464 err = -EFSCORRUPTED;
465 goto out;
466 }
aef4885a 467 err = ext4_init_block_bitmap(sb, bh, block_group, desc);
2ccb5fb9 468 set_bitmap_uptodate(bh);
abcb2947 469 set_buffer_uptodate(bh);
555bc9b1 470 set_buffer_verified(bh);
955ce5f5 471 ext4_unlock_group(sb, block_group);
3300beda 472 unlock_buffer(bh);
05145bd7
JK
473 if (err) {
474 ext4_error(sb, "Failed to init block bitmap for group "
475 "%u: %d", block_group, err);
9008a58e 476 goto out;
05145bd7 477 }
41e5b7ed 478 goto verify;
717d50e4 479 }
955ce5f5 480 ext4_unlock_group(sb, block_group);
2ccb5fb9
AK
481 if (buffer_uptodate(bh)) {
482 /*
483 * if not uninit if bh is uptodate,
484 * bitmap is also uptodate
485 */
486 set_bitmap_uptodate(bh);
487 unlock_buffer(bh);
fa77dcfa 488 goto verify;
2ccb5fb9
AK
489 }
490 /*
813e5727 491 * submit the buffer_head for reading
2ccb5fb9 492 */
813e5727 493 set_buffer_new(bh);
0562e0ba 494 trace_ext4_read_block_bitmap_load(sb, block_group);
813e5727
TT
495 bh->b_end_io = ext4_end_bitmap_read;
496 get_bh(bh);
2a222ca9 497 submit_bh(REQ_OP_READ, REQ_META | REQ_PRIO, bh);
813e5727 498 return bh;
fa77dcfa 499verify:
9008a58e
DW
500 err = ext4_validate_block_bitmap(sb, desc, block_group, bh);
501 if (err)
502 goto out;
503 return bh;
504out:
48d9eb97 505 put_bh(bh);
9008a58e 506 return ERR_PTR(err);
813e5727
TT
507}
508
509/* Returns 0 on success, 1 on error */
510int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
511 struct buffer_head *bh)
512{
513 struct ext4_group_desc *desc;
514
515 if (!buffer_new(bh))
516 return 0;
517 desc = ext4_get_group_desc(sb, block_group, NULL);
518 if (!desc)
9008a58e 519 return -EFSCORRUPTED;
813e5727
TT
520 wait_on_buffer(bh);
521 if (!buffer_uptodate(bh)) {
12062ddd 522 ext4_error(sb, "Cannot read block bitmap - "
813e5727 523 "block_group = %u, block_bitmap = %llu",
d4dc462f 524 block_group, (unsigned long long) bh->b_blocknr);
9008a58e 525 return -EIO;
abcb2947 526 }
813e5727
TT
527 clear_buffer_new(bh);
528 /* Panic or remount fs read-only if block bitmap is invalid */
9008a58e 529 return ext4_validate_block_bitmap(sb, desc, block_group, bh);
813e5727
TT
530}
531
532struct buffer_head *
533ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
534{
535 struct buffer_head *bh;
9008a58e 536 int err;
813e5727
TT
537
538 bh = ext4_read_block_bitmap_nowait(sb, block_group);
9008a58e
DW
539 if (IS_ERR(bh))
540 return bh;
541 err = ext4_wait_block_bitmap(sb, block_group, bh);
542 if (err) {
813e5727 543 put_bh(bh);
9008a58e 544 return ERR_PTR(err);
813e5727 545 }
ac27a0ec
DK
546 return bh;
547}
ac27a0ec 548
8c3bf8a0 549/**
df55c99d 550 * ext4_has_free_clusters()
8c3bf8a0 551 * @sbi: in-core super block structure.
df55c99d
TT
552 * @nclusters: number of needed blocks
553 * @flags: flags from ext4_mb_new_blocks()
8c3bf8a0 554 *
df55c99d 555 * Check if filesystem has nclusters free & available for allocation.
8c3bf8a0
ES
556 * On success return 1, return 0 on failure.
557 */
df55c99d
TT
558static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
559 s64 nclusters, unsigned int flags)
a30d542a 560{
27dd4385 561 s64 free_clusters, dirty_clusters, rsv, resv_clusters;
57042651 562 struct percpu_counter *fcc = &sbi->s_freeclusters_counter;
df55c99d 563 struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter;
a30d542a 564
df55c99d
TT
565 free_clusters = percpu_counter_read_positive(fcc);
566 dirty_clusters = percpu_counter_read_positive(dcc);
27dd4385 567 resv_clusters = atomic64_read(&sbi->s_resv_clusters);
304e220f
LC
568
569 /*
570 * r_blocks_count should always be multiple of the cluster ratio so
571 * we are safe to do a plane bit shift only.
572 */
27dd4385
LC
573 rsv = (ext4_r_blocks_count(sbi->s_es) >> sbi->s_cluster_bits) +
574 resv_clusters;
a30d542a 575
27dd4385 576 if (free_clusters - (nclusters + rsv + dirty_clusters) <
df55c99d 577 EXT4_FREECLUSTERS_WATERMARK) {
304e220f 578 free_clusters = percpu_counter_sum_positive(fcc);
df55c99d 579 dirty_clusters = percpu_counter_sum_positive(dcc);
6bc6e63f 580 }
df55c99d
TT
581 /* Check whether we have space after accounting for current
582 * dirty clusters & root reserved clusters.
6bc6e63f 583 */
27dd4385 584 if (free_clusters >= (rsv + nclusters + dirty_clusters))
a996031c 585 return 1;
a30d542a 586
df55c99d 587 /* Hm, nope. Are (enough) root reserved clusters available? */
08cefc7a 588 if (uid_eq(sbi->s_resuid, current_fsuid()) ||
78a8da10
SF
589 (!gid_eq(sbi->s_resgid, make_kgid(sbi->s_sb->s_user_ns, 0)) && in_group_p(sbi->s_resgid)) ||
590 ns_capable(sbi->s_sb->s_user_ns, CAP_SYS_RESOURCE) ||
27dd4385 591 (flags & EXT4_MB_USE_ROOT_BLOCKS)) {
55f020db 592
27dd4385
LC
593 if (free_clusters >= (nclusters + dirty_clusters +
594 resv_clusters))
595 return 1;
596 }
597 /* No free blocks. Let's see if we can dip into reserved pool */
598 if (flags & EXT4_MB_USE_RESERVED) {
df55c99d 599 if (free_clusters >= (nclusters + dirty_clusters))
a996031c
ES
600 return 1;
601 }
602
603 return 0;
a30d542a
AK
604}
605
e7d5f315
TT
606int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
607 s64 nclusters, unsigned int flags)
ac27a0ec 608{
df55c99d 609 if (ext4_has_free_clusters(sbi, nclusters, flags)) {
e7d5f315 610 percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters);
16eb7295 611 return 0;
8c3bf8a0
ES
612 } else
613 return -ENOSPC;
a30d542a 614}
07031431 615
ac27a0ec 616/**
617ba13b 617 * ext4_should_retry_alloc()
ac27a0ec
DK
618 * @sb: super block
619 * @retries number of attemps has been made
620 *
617ba13b 621 * ext4_should_retry_alloc() is called when ENOSPC is returned, and if
ac27a0ec 622 * it is profitable to retry the operation, this function will wait
25985edc 623 * for the current or committing transaction to complete, and then
68fd9750 624 * return TRUE. We will only retry once.
ac27a0ec 625 */
617ba13b 626int ext4_should_retry_alloc(struct super_block *sb, int *retries)
ac27a0ec 627{
df55c99d 628 if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||
68fd9750 629 (*retries)++ > 1 ||
8f64b32e 630 !EXT4_SB(sb)->s_journal)
ac27a0ec
DK
631 return 0;
632
d08854f5 633 smp_mb();
68fd9750
TT
634 if (EXT4_SB(sb)->s_mb_free_pending == 0)
635 return 0;
636
637 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
638 jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
dbc427ce 639 return 1;
ac27a0ec
DK
640}
641
654b4908 642/*
d2a17637 643 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
654b4908
AK
644 *
645 * @handle: handle to this transaction
646 * @inode: file inode
647 * @goal: given target block(filesystem wide)
7b415bf6 648 * @count: pointer to total number of clusters needed
654b4908
AK
649 * @errp: error code
650 *
97df5d15 651 * Return 1st allocated block number on success, *count stores total account
d2a17637 652 * error stores in errp pointer
654b4908 653 */
d2a17637 654ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
55f020db
AH
655 ext4_fsblk_t goal, unsigned int flags,
656 unsigned long *count, int *errp)
654b4908 657{
97df5d15 658 struct ext4_allocation_request ar;
d2a17637 659 ext4_fsblk_t ret;
97df5d15
TT
660
661 memset(&ar, 0, sizeof(ar));
662 /* Fill with neighbour allocated blocks */
663 ar.inode = inode;
664 ar.goal = goal;
665 ar.len = count ? *count : 1;
55f020db 666 ar.flags = flags;
97df5d15
TT
667
668 ret = ext4_mb_new_blocks(handle, &ar, errp);
669 if (count)
670 *count = ar.len;
d2a17637 671 /*
72b8ab9d
ES
672 * Account for the allocated meta blocks. We will never
673 * fail EDQUOT for metdata, but we do account for it.
d2a17637 674 */
e3cf5d5d 675 if (!(*errp) && (flags & EXT4_MB_DELALLOC_RESERVED)) {
7b415bf6
AK
676 dquot_alloc_block_nofail(inode,
677 EXT4_C2B(EXT4_SB(inode->i_sb), ar.len));
d2a17637
MC
678 }
679 return ret;
654b4908
AK
680}
681
ac27a0ec 682/**
5dee5437 683 * ext4_count_free_clusters() -- count filesystem free clusters
ac27a0ec
DK
684 * @sb: superblock
685 *
5dee5437 686 * Adds up the number of free clusters from each block group.
ac27a0ec 687 */
5dee5437 688ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb)
ac27a0ec 689{
617ba13b
MC
690 ext4_fsblk_t desc_count;
691 struct ext4_group_desc *gdp;
fd2d4291 692 ext4_group_t i;
8df9675f 693 ext4_group_t ngroups = ext4_get_groups_count(sb);
2746f7a1 694 struct ext4_group_info *grp;
617ba13b
MC
695#ifdef EXT4FS_DEBUG
696 struct ext4_super_block *es;
697 ext4_fsblk_t bitmap_count;
498e5f24 698 unsigned int x;
ac27a0ec
DK
699 struct buffer_head *bitmap_bh = NULL;
700
617ba13b 701 es = EXT4_SB(sb)->s_es;
ac27a0ec
DK
702 desc_count = 0;
703 bitmap_count = 0;
704 gdp = NULL;
705
ac27a0ec 706 for (i = 0; i < ngroups; i++) {
617ba13b 707 gdp = ext4_get_group_desc(sb, i, NULL);
ac27a0ec
DK
708 if (!gdp)
709 continue;
2746f7a1
DW
710 grp = NULL;
711 if (EXT4_SB(sb)->s_group_info)
712 grp = ext4_get_group_info(sb, i);
713 if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
714 desc_count += ext4_free_group_clusters(sb, gdp);
ac27a0ec 715 brelse(bitmap_bh);
574ca174 716 bitmap_bh = ext4_read_block_bitmap(sb, i);
9008a58e
DW
717 if (IS_ERR(bitmap_bh)) {
718 bitmap_bh = NULL;
ac27a0ec 719 continue;
9008a58e 720 }
ac27a0ec 721
f6fb99ca 722 x = ext4_count_free(bitmap_bh->b_data,
036acea2 723 EXT4_CLUSTERS_PER_GROUP(sb) / 8);
9fd9784c 724 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
021b65bb 725 i, ext4_free_group_clusters(sb, gdp), x);
ac27a0ec
DK
726 bitmap_count += x;
727 }
728 brelse(bitmap_bh);
5dee5437
TT
729 printk(KERN_DEBUG "ext4_count_free_clusters: stored = %llu"
730 ", computed = %llu, %llu\n",
810da240 731 EXT4_NUM_B2C(EXT4_SB(sb), ext4_free_blocks_count(es)),
4776004f 732 desc_count, bitmap_count);
ac27a0ec
DK
733 return bitmap_count;
734#else
735 desc_count = 0;
ac27a0ec 736 for (i = 0; i < ngroups; i++) {
617ba13b 737 gdp = ext4_get_group_desc(sb, i, NULL);
ac27a0ec
DK
738 if (!gdp)
739 continue;
2746f7a1
DW
740 grp = NULL;
741 if (EXT4_SB(sb)->s_group_info)
742 grp = ext4_get_group_info(sb, i);
743 if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
744 desc_count += ext4_free_group_clusters(sb, gdp);
ac27a0ec
DK
745 }
746
747 return desc_count;
748#endif
749}
750
fd2d4291 751static inline int test_root(ext4_group_t a, int b)
ac27a0ec 752{
f4afb4f4
TT
753 while (1) {
754 if (a < b)
755 return 0;
756 if (a == b)
757 return 1;
758 if ((a % b) != 0)
759 return 0;
760 a = a / b;
761 }
ac27a0ec
DK
762}
763
ac27a0ec 764/**
617ba13b 765 * ext4_bg_has_super - number of blocks used by the superblock in group
ac27a0ec
DK
766 * @sb: superblock for filesystem
767 * @group: group number to check
768 *
769 * Return the number of blocks used by the superblock (primary or backup)
770 * in this group. Currently this will be only 0 or 1.
771 */
fd2d4291 772int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
ac27a0ec 773{
1beeef1b
DW
774 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
775
776 if (group == 0)
777 return 1;
e2b911c5 778 if (ext4_has_feature_sparse_super2(sb)) {
1beeef1b
DW
779 if (group == le32_to_cpu(es->s_backup_bgs[0]) ||
780 group == le32_to_cpu(es->s_backup_bgs[1]))
781 return 1;
782 return 0;
783 }
e2b911c5 784 if ((group <= 1) || !ext4_has_feature_sparse_super(sb))
1beeef1b
DW
785 return 1;
786 if (!(group & 1))
ac27a0ec 787 return 0;
1beeef1b
DW
788 if (test_root(group, 3) || (test_root(group, 5)) ||
789 test_root(group, 7))
790 return 1;
791
792 return 0;
ac27a0ec
DK
793}
794
fd2d4291
AM
795static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
796 ext4_group_t group)
ac27a0ec 797{
617ba13b 798 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
fd2d4291
AM
799 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
800 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
ac27a0ec
DK
801
802 if (group == first || group == first + 1 || group == last)
803 return 1;
804 return 0;
805}
806
fd2d4291
AM
807static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
808 ext4_group_t group)
ac27a0ec 809{
8dadb198
TT
810 if (!ext4_bg_has_super(sb, group))
811 return 0;
812
e2b911c5 813 if (ext4_has_feature_meta_bg(sb))
8dadb198
TT
814 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
815 else
816 return EXT4_SB(sb)->s_gdb_count;
ac27a0ec
DK
817}
818
819/**
617ba13b 820 * ext4_bg_num_gdb - number of blocks used by the group table in group
ac27a0ec
DK
821 * @sb: superblock for filesystem
822 * @group: group number to check
823 *
824 * Return the number of blocks used by the group descriptor table
825 * (primary or backup) in this group. In the future there may be a
826 * different number of descriptor blocks in each group.
827 */
fd2d4291 828unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
ac27a0ec
DK
829{
830 unsigned long first_meta_bg =
617ba13b
MC
831 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
832 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
ac27a0ec 833
e2b911c5 834 if (!ext4_has_feature_meta_bg(sb) || metagroup < first_meta_bg)
af5bc92d 835 return ext4_bg_num_gdb_nometa(sb, group);
ac27a0ec 836
617ba13b 837 return ext4_bg_num_gdb_meta(sb,group);
ac27a0ec
DK
838
839}
c2ea3fde 840
49f7f9af 841/*
d5b8f310 842 * This function returns the number of file system metadata clusters at
49f7f9af
TT
843 * the beginning of a block group, including the reserved gdt blocks.
844 */
5f163cc7 845static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
d5b8f310 846 ext4_group_t block_group)
49f7f9af
TT
847{
848 struct ext4_sb_info *sbi = EXT4_SB(sb);
d5b8f310 849 unsigned num;
49f7f9af
TT
850
851 /* Check for superblock and gdt backups in this group */
852 num = ext4_bg_has_super(sb, block_group);
853
e2b911c5 854 if (!ext4_has_feature_meta_bg(sb) ||
49f7f9af
TT
855 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
856 sbi->s_desc_per_block) {
857 if (num) {
858 num += ext4_bg_num_gdb(sb, block_group);
859 num += le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
860 }
861 } else { /* For META_BG_BLOCK_GROUPS */
862 num += ext4_bg_num_gdb(sb, block_group);
863 }
d5b8f310 864 return EXT4_NUM_B2C(sbi, num);
49f7f9af 865}
f86186b4
ES
866/**
867 * ext4_inode_to_goal_block - return a hint for block allocation
868 * @inode: inode for block allocation
869 *
870 * Return the ideal location to start allocating blocks for a
871 * newly created inode.
872 */
873ext4_fsblk_t ext4_inode_to_goal_block(struct inode *inode)
874{
875 struct ext4_inode_info *ei = EXT4_I(inode);
876 ext4_group_t block_group;
877 ext4_grpblk_t colour;
878 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
879 ext4_fsblk_t bg_start;
880 ext4_fsblk_t last_block;
881
882 block_group = ei->i_block_group;
883 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
884 /*
885 * If there are at least EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME
886 * block groups per flexgroup, reserve the first block
887 * group for directories and special files. Regular
888 * files will start at the second block group. This
889 * tends to speed up directory access and improves
890 * fsck times.
891 */
892 block_group &= ~(flex_size-1);
893 if (S_ISREG(inode->i_mode))
894 block_group++;
895 }
896 bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
897 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
898
899 /*
900 * If we are doing delayed allocation, we don't need take
901 * colour into account.
902 */
903 if (test_opt(inode->i_sb, DELALLOC))
904 return bg_start;
905
906 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
907 colour = (current->pid % 16) *
908 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
909 else
910 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
911 return bg_start + colour;
912}
913