Branch data Line data Source code
1 : : /*
2 : : * linux/fs/ext4/balloc.c
3 : : *
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>
17 : : #include <linux/jbd2.h>
18 : : #include <linux/quotaops.h>
19 : : #include <linux/buffer_head.h>
20 : : #include "ext4.h"
21 : : #include "ext4_jbd2.h"
22 : : #include "mballoc.h"
23 : :
24 : : #include <trace/events/ext4.h>
25 : :
26 : : static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
27 : : ext4_group_t block_group);
28 : : /*
29 : : * balloc.c contains the blocks allocation and deallocation routines
30 : : */
31 : :
32 : : /*
33 : : * Calculate block group number for a given block number
34 : : */
35 : 0 : ext4_group_t ext4_get_group_number(struct super_block *sb,
36 : : ext4_fsblk_t block)
37 : : {
38 : : ext4_group_t group;
39 : :
40 [ + - ]: 83063 : if (test_opt2(sb, STD_GROUP_SIZE))
41 : 83063 : group = (block -
42 : 166126 : le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) >>
43 : 83063 : (EXT4_BLOCK_SIZE_BITS(sb) + EXT4_CLUSTER_BITS(sb) + 3);
44 : : else
45 : 0 : ext4_get_group_no_and_offset(sb, block, &group, NULL);
46 : 83063 : return group;
47 : : }
48 : :
49 : : /*
50 : : * Calculate the block group number and offset into the block/cluster
51 : : * allocation bitmap, given a block number
52 : : */
53 : 0 : void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
54 : : ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)
55 : : {
56 : 562956 : struct ext4_super_block *es = EXT4_SB(sb)->s_es;
57 : : ext4_grpblk_t offset;
58 : :
59 : 562956 : blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
60 [ - + ][ # # ]: 562956 : offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb)) >>
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
61 : 562956 : EXT4_SB(sb)->s_cluster_bits;
62 [ + ]: 562956 : if (offsetp)
63 : 562985 : *offsetp = offset;
64 [ + ]: 562956 : if (blockgrpp)
65 : 563012 : *blockgrpp = blocknr;
66 : :
67 : 0 : }
68 : :
69 : : /*
70 : : * Check whether the 'block' lives within the 'block_group'. Returns 1 if so
71 : : * and 0 otherwise.
72 : : */
73 : : static inline int ext4_block_in_group(struct super_block *sb,
74 : : ext4_fsblk_t block,
75 : : ext4_group_t block_group)
76 : : {
77 : : ext4_group_t actual_group;
78 : :
79 : 60809 : actual_group = ext4_get_group_number(sb, block);
80 : : return (actual_group == block_group) ? 1 : 0;
81 : : }
82 : :
83 : : /* Return the number of clusters used for file system metadata; this
84 : : * represents the overhead needed by the file system.
85 : : */
86 : 0 : unsigned ext4_num_overhead_clusters(struct super_block *sb,
87 : : ext4_group_t block_group,
88 : : struct ext4_group_desc *gdp)
89 : : {
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;
94 : : struct ext4_sb_info *sbi = EXT4_SB(sb);
95 : :
96 : : /* This is the number of clusters used by the superblock,
97 : : * block group descriptors, and reserved block group
98 : : * descriptor blocks */
99 : 37 : 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 [ - + ]: 74 : if (ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), block_group)) {
114 : 0 : block_cluster = EXT4_B2C(sbi,
115 : : ext4_block_bitmap(sb, gdp) - start);
116 [ # # ]: 0 : if (block_cluster < num_clusters)
117 : : block_cluster = -1;
118 [ # # ]: 0 : else if (block_cluster == num_clusters) {
119 : 0 : num_clusters++;
120 : : block_cluster = -1;
121 : : }
122 : : }
123 : :
124 [ - + ]: 74 : if (ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp), block_group)) {
125 : 0 : inode_cluster = EXT4_B2C(sbi,
126 : : ext4_inode_bitmap(sb, gdp) - start);
127 [ # # ]: 0 : if (inode_cluster < num_clusters)
128 : : inode_cluster = -1;
129 [ # # ]: 0 : else if (inode_cluster == num_clusters) {
130 : 0 : num_clusters++;
131 : : inode_cluster = -1;
132 : : }
133 : : }
134 : :
135 : 37 : itbl_blk = ext4_inode_table(sb, gdp);
136 [ + + ]: 18870 : for (i = 0; i < sbi->s_itb_per_group; i++) {
137 [ - + ]: 18870 : if (ext4_block_in_group(sb, itbl_blk + i, block_group)) {
138 : 0 : c = EXT4_B2C(sbi, itbl_blk + i - start);
139 [ # # ]: 0 : if ((c < num_clusters) || (c == inode_cluster) ||
140 [ # # ]: 0 : (c == block_cluster) || (c == itbl_cluster))
141 : 0 : continue;
142 [ # # ]: 0 : if (c == num_clusters) {
143 : 0 : num_clusters++;
144 : 0 : continue;
145 : : }
146 : 0 : num_clusters++;
147 : : itbl_cluster = c;
148 : : }
149 : : }
150 : :
151 [ - + ]: 37 : if (block_cluster != -1)
152 : 0 : num_clusters++;
153 [ - + ]: 37 : if (inode_cluster != -1)
154 : 0 : num_clusters++;
155 : :
156 : 37 : return num_clusters;
157 : : }
158 : :
159 : 0 : static unsigned int num_clusters_in_group(struct super_block *sb,
160 : : ext4_group_t block_group)
161 : : {
162 : : unsigned int blocks;
163 : :
164 [ - + ]: 238 : 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 : : */
171 : 0 : blocks = ext4_blocks_count(EXT4_SB(sb)->s_es) -
172 : : ext4_group_first_block_no(sb, block_group);
173 : : } else
174 : 119 : blocks = EXT4_BLOCKS_PER_GROUP(sb);
175 : 119 : return EXT4_NUM_B2C(EXT4_SB(sb), blocks);
176 : : }
177 : :
178 : : /* Initializes an uninitialized block bitmap */
179 : 0 : void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
180 : : ext4_group_t block_group,
181 : : struct ext4_group_desc *gdp)
182 : : {
183 : : unsigned int bit, bit_max;
184 : : struct ext4_sb_info *sbi = EXT4_SB(sb);
185 : : ext4_fsblk_t start, tmp;
186 : : int flex_bg = 0;
187 : : struct ext4_group_info *grp;
188 : :
189 [ - + ]: 82 : 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. */
193 [ - + ]: 82 : if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
194 : 0 : ext4_error(sb, "Checksum bad for group %u", block_group);
195 : : grp = ext4_get_group_info(sb, block_group);
196 : 0 : set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
197 : 0 : set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT, &grp->bb_state);
198 : 0 : return;
199 : : }
200 [ + - ]: 82 : memset(bh->b_data, 0, sb->s_blocksize);
201 : :
202 : 82 : bit_max = ext4_num_base_meta_clusters(sb, block_group);
203 [ - + ]: 82 : for (bit = 0; bit < bit_max; bit++)
204 : 0 : ext4_set_bit(bit, bh->b_data);
205 : :
206 : : start = ext4_group_first_block_no(sb, block_group);
207 : :
208 [ + - ]: 82 : if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
209 : : flex_bg = 1;
210 : :
211 : : /* Set bits for block and inode bitmaps, and inode table */
212 : 82 : tmp = ext4_block_bitmap(sb, gdp);
213 [ + - - + ]: 164 : if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
214 : 0 : ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
215 : :
216 : 82 : tmp = ext4_inode_bitmap(sb, gdp);
217 [ + - - + ]: 164 : if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
218 : 0 : ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
219 : :
220 : 82 : tmp = ext4_inode_table(sb, gdp);
221 [ + + ]: 41820 : for (; tmp < ext4_inode_table(sb, gdp) +
222 : 41738 : sbi->s_itb_per_group; tmp++) {
223 [ + - - + ]: 83476 : if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
224 : 0 : ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
225 : : }
226 : :
227 : : /*
228 : : * Also if the number of blocks within the group is less than
229 : : * the blocksize * 8 ( which is the size of bitmap ), set rest
230 : : * of the block bitmap to 1
231 : : */
232 : 82 : ext4_mark_bitmap_end(num_clusters_in_group(sb, block_group),
233 : 82 : sb->s_blocksize * 8, bh->b_data);
234 : 82 : ext4_block_bitmap_csum_set(sb, block_group, gdp, bh);
235 : 82 : ext4_group_desc_csum_set(sb, block_group, gdp);
236 : : }
237 : :
238 : : /* Return the number of free blocks in a block group. It is used when
239 : : * the block bitmap is uninitialized, so we can't just count the bits
240 : : * in the bitmap. */
241 : 0 : unsigned ext4_free_clusters_after_init(struct super_block *sb,
242 : : ext4_group_t block_group,
243 : : struct ext4_group_desc *gdp)
244 : : {
245 : 37 : return num_clusters_in_group(sb, block_group) -
246 : 37 : ext4_num_overhead_clusters(sb, block_group, gdp);
247 : : }
248 : :
249 : : /*
250 : : * The free blocks are managed by bitmaps. A file system contains several
251 : : * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
252 : : * block for inodes, N blocks for the inode table and data blocks.
253 : : *
254 : : * The file system contains group descriptors which are located after the
255 : : * super block. Each descriptor contains the number of the bitmap block and
256 : : * the free blocks count in the block. The descriptors are loaded in memory
257 : : * when a file system is mounted (see ext4_fill_super).
258 : : */
259 : :
260 : : /**
261 : : * ext4_get_group_desc() -- load group descriptor from disk
262 : : * @sb: super block
263 : : * @block_group: given block group
264 : : * @bh: pointer to the buffer head to store the block
265 : : * group descriptor
266 : : */
267 : 0 : struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
268 : : ext4_group_t block_group,
269 : : struct buffer_head **bh)
270 : : {
271 : : unsigned int group_desc;
272 : : unsigned int offset;
273 : : ext4_group_t ngroups = ext4_get_groups_count(sb);
274 : : struct ext4_group_desc *desc;
275 : : struct ext4_sb_info *sbi = EXT4_SB(sb);
276 : :
277 [ - + ]: 27935692 : if (block_group >= ngroups) {
278 : 0 : ext4_error(sb, "block_group >= groups_count - block_group = %u,"
279 : : " groups_count = %u", block_group, ngroups);
280 : :
281 : 0 : return NULL;
282 : : }
283 : :
284 : 13967484 : group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
285 : 13967484 : offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
286 [ - + ]: 27935692 : if (!sbi->s_group_desc[group_desc]) {
287 : 0 : ext4_error(sb, "Group descriptor not loaded - "
288 : : "block_group = %u, group_desc = %u, desc = %u",
289 : : block_group, group_desc, offset);
290 : 0 : return NULL;
291 : : }
292 : :
293 : 13967484 : desc = (struct ext4_group_desc *)(
294 : 27934968 : (__u8 *)sbi->s_group_desc[group_desc]->b_data +
295 : 13967484 : offset * EXT4_DESC_SIZE(sb));
296 [ + + ]: 13967484 : if (bh)
297 : 1268554 : *bh = sbi->s_group_desc[group_desc];
298 : 13967484 : return desc;
299 : : }
300 : :
301 : : /*
302 : : * Return the block number which was discovered to be invalid, or 0 if
303 : : * the block bitmap is valid.
304 : : */
305 : 130 : static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb,
306 : : struct ext4_group_desc *desc,
307 : : ext4_group_t block_group,
308 : : struct buffer_head *bh)
309 : : {
310 : : ext4_grpblk_t offset;
311 : : ext4_grpblk_t next_zero_bit;
312 : : ext4_fsblk_t blk;
313 : : ext4_fsblk_t group_first_block;
314 : :
315 [ - + ]: 130 : if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
316 : : /* with FLEX_BG, the inode/block bitmaps and itable
317 : : * blocks may not be in the group at all
318 : : * so the bitmap validation will be skipped for those groups
319 : : * or it has to also read the block group where the bitmaps
320 : : * are located to verify they are set.
321 : : */
322 : : return 0;
323 : : }
324 : : group_first_block = ext4_group_first_block_no(sb, block_group);
325 : :
326 : : /* check whether block bitmap block number is set */
327 : 0 : blk = ext4_block_bitmap(sb, desc);
328 : 0 : offset = blk - group_first_block;
329 [ # # ]: 0 : if (!ext4_test_bit(offset, bh->b_data))
330 : : /* bad block bitmap */
331 : : return blk;
332 : :
333 : : /* check whether the inode bitmap block number is set */
334 : 0 : blk = ext4_inode_bitmap(sb, desc);
335 : 0 : offset = blk - group_first_block;
336 [ # # ]: 0 : if (!ext4_test_bit(offset, bh->b_data))
337 : : /* bad block bitmap */
338 : : return blk;
339 : :
340 : : /* check whether the inode table block number is set */
341 : 0 : blk = ext4_inode_table(sb, desc);
342 : 0 : offset = blk - group_first_block;
343 : 0 : next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
344 : 0 : offset + EXT4_SB(sb)->s_itb_per_group,
345 : : offset);
346 [ # # ]: 0 : if (next_zero_bit < offset + EXT4_SB(sb)->s_itb_per_group)
347 : : /* bad bitmap for inode tables */
348 : : return blk;
349 : : return 0;
350 : : }
351 : :
352 : 0 : void ext4_validate_block_bitmap(struct super_block *sb,
353 : : struct ext4_group_desc *desc,
354 : : ext4_group_t block_group,
355 : : struct buffer_head *bh)
356 : : {
357 : : ext4_fsblk_t blk;
358 : : struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
359 : :
360 [ + + ]: 367198 : if (buffer_verified(bh))
361 : : return;
362 : :
363 : : ext4_lock_group(sb, block_group);
364 : 130 : blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
365 [ - + ]: 130 : if (unlikely(blk != 0)) {
366 : : ext4_unlock_group(sb, block_group);
367 : 0 : ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
368 : : block_group, blk);
369 : 0 : set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
370 : 0 : return;
371 : : }
372 [ - + ]: 130 : if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
373 : : desc, bh))) {
374 : : ext4_unlock_group(sb, block_group);
375 : 0 : ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
376 : 0 : set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
377 : 0 : return;
378 : : }
379 : : set_buffer_verified(bh);
380 : : ext4_unlock_group(sb, block_group);
381 : : }
382 : :
383 : : /**
384 : : * ext4_read_block_bitmap_nowait()
385 : : * @sb: super block
386 : : * @block_group: given block group
387 : : *
388 : : * Read the bitmap for a given block_group,and validate the
389 : : * bits for block/inode/inode tables are set in the bitmaps
390 : : *
391 : : * Return buffer_head on success or NULL in case of failure.
392 : : */
393 : : struct buffer_head *
394 : 0 : ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
395 : : {
396 : : struct ext4_group_desc *desc;
397 : : struct buffer_head *bh;
398 : : ext4_fsblk_t bitmap_blk;
399 : :
400 : 367273 : desc = ext4_get_group_desc(sb, block_group, NULL);
401 [ + ]: 367269 : if (!desc)
402 : : return NULL;
403 : 367272 : bitmap_blk = ext4_block_bitmap(sb, desc);
404 : : bh = sb_getblk(sb, bitmap_blk);
405 [ - + ]: 367275 : if (unlikely(!bh)) {
406 : 0 : ext4_error(sb, "Cannot get buffer for block bitmap - "
407 : : "block_group = %u, block_bitmap = %llu",
408 : : block_group, bitmap_blk);
409 : 0 : return NULL;
410 : : }
411 : :
412 [ + + ]: 367275 : if (bitmap_uptodate(bh))
413 : : goto verify;
414 : :
415 : : lock_buffer(bh);
416 [ - + ]: 130 : if (bitmap_uptodate(bh)) {
417 : 0 : unlock_buffer(bh);
418 : 0 : goto verify;
419 : : }
420 : : ext4_lock_group(sb, block_group);
421 [ + + ]: 130 : if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
422 : 82 : ext4_init_block_bitmap(sb, bh, block_group, desc);
423 : : set_bitmap_uptodate(bh);
424 : : set_buffer_uptodate(bh);
425 : : ext4_unlock_group(sb, block_group);
426 : 82 : unlock_buffer(bh);
427 : 82 : return bh;
428 : : }
429 : : ext4_unlock_group(sb, block_group);
430 [ - + ]: 48 : if (buffer_uptodate(bh)) {
431 : : /*
432 : : * if not uninit if bh is uptodate,
433 : : * bitmap is also uptodate
434 : : */
435 : : set_bitmap_uptodate(bh);
436 : 0 : unlock_buffer(bh);
437 : 0 : goto verify;
438 : : }
439 : : /*
440 : : * submit the buffer_head for reading
441 : : */
442 : : set_buffer_new(bh);
443 : : trace_ext4_read_block_bitmap_load(sb, block_group);
444 : 48 : bh->b_end_io = ext4_end_bitmap_read;
445 : : get_bh(bh);
446 : 48 : submit_bh(READ | REQ_META | REQ_PRIO, bh);
447 : 48 : return bh;
448 : : verify:
449 : 367145 : ext4_validate_block_bitmap(sb, desc, block_group, bh);
450 [ - + ]: 367152 : if (buffer_verified(bh))
451 : : return bh;
452 : : put_bh(bh);
453 : 0 : return NULL;
454 : : }
455 : :
456 : : /* Returns 0 on success, 1 on error */
457 : 0 : int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
458 : : struct buffer_head *bh)
459 : : {
460 : : struct ext4_group_desc *desc;
461 : :
462 [ + + ]: 367274 : if (!buffer_new(bh))
463 : : return 0;
464 : 48 : desc = ext4_get_group_desc(sb, block_group, NULL);
465 [ + - ]: 48 : if (!desc)
466 : : return 1;
467 : : wait_on_buffer(bh);
468 [ - + ]: 48 : if (!buffer_uptodate(bh)) {
469 : 0 : ext4_error(sb, "Cannot read block bitmap - "
470 : : "block_group = %u, block_bitmap = %llu",
471 : : block_group, (unsigned long long) bh->b_blocknr);
472 : 0 : return 1;
473 : : }
474 : : clear_buffer_new(bh);
475 : : /* Panic or remount fs read-only if block bitmap is invalid */
476 : 48 : ext4_validate_block_bitmap(sb, desc, block_group, bh);
477 : : /* ...but check for error just in case errors=continue. */
478 : 48 : return !buffer_verified(bh);
479 : : }
480 : :
481 : : struct buffer_head *
482 : 0 : ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
483 : : {
484 : : struct buffer_head *bh;
485 : :
486 : 367007 : bh = ext4_read_block_bitmap_nowait(sb, block_group);
487 [ + ]: 367006 : if (!bh)
488 : : return NULL;
489 [ - + ]: 367016 : if (ext4_wait_block_bitmap(sb, block_group, bh)) {
490 : : put_bh(bh);
491 : 0 : return NULL;
492 : : }
493 : : return bh;
494 : : }
495 : :
496 : : /**
497 : : * ext4_has_free_clusters()
498 : : * @sbi: in-core super block structure.
499 : : * @nclusters: number of needed blocks
500 : : * @flags: flags from ext4_mb_new_blocks()
501 : : *
502 : : * Check if filesystem has nclusters free & available for allocation.
503 : : * On success return 1, return 0 on failure.
504 : : */
505 : 0 : static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
506 : : s64 nclusters, unsigned int flags)
507 : : {
508 : : s64 free_clusters, dirty_clusters, rsv, resv_clusters;
509 : 3896054 : struct percpu_counter *fcc = &sbi->s_freeclusters_counter;
510 : 3895733 : struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter;
511 : :
512 : : free_clusters = percpu_counter_read_positive(fcc);
513 : : dirty_clusters = percpu_counter_read_positive(dcc);
514 : 1947756 : resv_clusters = atomic64_read(&sbi->s_resv_clusters);
515 : :
516 : : /*
517 : : * r_blocks_count should always be multiple of the cluster ratio so
518 : : * we are safe to do a plane bit shift only.
519 : : */
520 : 3895286 : rsv = (ext4_r_blocks_count(sbi->s_es) >> sbi->s_cluster_bits) +
521 : : resv_clusters;
522 : :
523 [ - + ]: 1947643 : if (free_clusters - (nclusters + rsv + dirty_clusters) <
524 : 1947643 : EXT4_FREECLUSTERS_WATERMARK) {
525 : : free_clusters = percpu_counter_sum_positive(fcc);
526 : : dirty_clusters = percpu_counter_sum_positive(dcc);
527 : : }
528 : : /* Check whether we have space after accounting for current
529 : : * dirty clusters & root reserved clusters.
530 : : */
531 [ - + ]: 1947643 : if (free_clusters >= (rsv + nclusters + dirty_clusters))
532 : : return 1;
533 : :
534 : : /* Hm, nope. Are (enough) root reserved clusters available? */
535 [ # # ][ # # ]: 0 : if (uid_eq(sbi->s_resuid, current_fsuid()) ||
536 [ # # # # ]: 0 : (!gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) && in_group_p(sbi->s_resgid)) ||
537 [ # # ]: 0 : capable(CAP_SYS_RESOURCE) ||
538 : 0 : (flags & EXT4_MB_USE_ROOT_BLOCKS)) {
539 : :
540 [ # # ]: 0 : if (free_clusters >= (nclusters + dirty_clusters +
541 : : resv_clusters))
542 : : return 1;
543 : : }
544 : : /* No free blocks. Let's see if we can dip into reserved pool */
545 [ # # ]: 0 : if (flags & EXT4_MB_USE_RESERVED) {
546 [ # # ]: 0 : if (free_clusters >= (nclusters + dirty_clusters))
547 : : return 1;
548 : : }
549 : :
550 : 0 : return 0;
551 : : }
552 : :
553 : 0 : int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
554 : : s64 nclusters, unsigned int flags)
555 : : {
556 [ + + ]: 1947976 : if (ext4_has_free_clusters(sbi, nclusters, flags)) {
557 : 1947773 : percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters);
558 : 1947999 : return 0;
559 : : } else
560 : : return -ENOSPC;
561 : : }
562 : :
563 : : /**
564 : : * ext4_should_retry_alloc()
565 : : * @sb: super block
566 : : * @retries number of attemps has been made
567 : : *
568 : : * ext4_should_retry_alloc() is called when ENOSPC is returned, and if
569 : : * it is profitable to retry the operation, this function will wait
570 : : * for the current or committing transaction to complete, and then
571 : : * return TRUE.
572 : : *
573 : : * if the total number of retries exceed three times, return FALSE.
574 : : */
575 : 0 : int ext4_should_retry_alloc(struct super_block *sb, int *retries)
576 : : {
577 [ # # ][ # # ]: 0 : if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||
578 [ # # ]: 0 : (*retries)++ > 3 ||
579 : 0 : !EXT4_SB(sb)->s_journal)
580 : : return 0;
581 : :
582 : : jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
583 : :
584 : 0 : return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
585 : : }
586 : :
587 : : /*
588 : : * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
589 : : *
590 : : * @handle: handle to this transaction
591 : : * @inode: file inode
592 : : * @goal: given target block(filesystem wide)
593 : : * @count: pointer to total number of clusters needed
594 : : * @errp: error code
595 : : *
596 : : * Return 1st allocated block number on success, *count stores total account
597 : : * error stores in errp pointer
598 : : */
599 : 0 : ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
600 : : ext4_fsblk_t goal, unsigned int flags,
601 : : unsigned long *count, int *errp)
602 : : {
603 : : struct ext4_allocation_request ar;
604 : : ext4_fsblk_t ret;
605 : :
606 : 431 : memset(&ar, 0, sizeof(ar));
607 : : /* Fill with neighbour allocated blocks */
608 : 431 : ar.inode = inode;
609 : 431 : ar.goal = goal;
610 [ - + ]: 431 : ar.len = count ? *count : 1;
611 : 431 : ar.flags = flags;
612 : :
613 : 431 : ret = ext4_mb_new_blocks(handle, &ar, errp);
614 [ - + ]: 431 : if (count)
615 : 0 : *count = ar.len;
616 : : /*
617 : : * Account for the allocated meta blocks. We will never
618 : : * fail EDQUOT for metdata, but we do account for it.
619 : : */
620 [ + - ][ + + ]: 431 : if (!(*errp) &&
621 : : ext4_test_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED)) {
622 : : spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
623 : 427 : EXT4_I(inode)->i_allocated_meta_blocks += ar.len;
624 : : spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
625 : 427 : dquot_alloc_block_nofail(inode,
626 : 427 : EXT4_C2B(EXT4_SB(inode->i_sb), ar.len));
627 : : }
628 : 0 : return ret;
629 : : }
630 : :
631 : : /**
632 : : * ext4_count_free_clusters() -- count filesystem free clusters
633 : : * @sb: superblock
634 : : *
635 : : * Adds up the number of free clusters from each block group.
636 : : */
637 : 0 : ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb)
638 : : {
639 : : ext4_fsblk_t desc_count;
640 : : struct ext4_group_desc *gdp;
641 : : ext4_group_t i;
642 : : ext4_group_t ngroups = ext4_get_groups_count(sb);
643 : : struct ext4_group_info *grp;
644 : : #ifdef EXT4FS_DEBUG
645 : : struct ext4_super_block *es;
646 : : ext4_fsblk_t bitmap_count;
647 : : unsigned int x;
648 : : struct buffer_head *bitmap_bh = NULL;
649 : :
650 : : es = EXT4_SB(sb)->s_es;
651 : : desc_count = 0;
652 : : bitmap_count = 0;
653 : : gdp = NULL;
654 : :
655 : : for (i = 0; i < ngroups; i++) {
656 : : gdp = ext4_get_group_desc(sb, i, NULL);
657 : : if (!gdp)
658 : : continue;
659 : : grp = NULL;
660 : : if (EXT4_SB(sb)->s_group_info)
661 : : grp = ext4_get_group_info(sb, i);
662 : : if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
663 : : desc_count += ext4_free_group_clusters(sb, gdp);
664 : : brelse(bitmap_bh);
665 : : bitmap_bh = ext4_read_block_bitmap(sb, i);
666 : : if (bitmap_bh == NULL)
667 : : continue;
668 : :
669 : : x = ext4_count_free(bitmap_bh->b_data,
670 : : EXT4_BLOCKS_PER_GROUP(sb) / 8);
671 : : printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
672 : : i, ext4_free_group_clusters(sb, gdp), x);
673 : : bitmap_count += x;
674 : : }
675 : : brelse(bitmap_bh);
676 : : printk(KERN_DEBUG "ext4_count_free_clusters: stored = %llu"
677 : : ", computed = %llu, %llu\n",
678 : : EXT4_NUM_B2C(EXT4_SB(sb), ext4_free_blocks_count(es)),
679 : : desc_count, bitmap_count);
680 : : return bitmap_count;
681 : : #else
682 : : desc_count = 0;
683 [ # # ]: 0 : for (i = 0; i < ngroups; i++) {
684 : 0 : gdp = ext4_get_group_desc(sb, i, NULL);
685 [ # # ]: 0 : if (!gdp)
686 : 0 : continue;
687 : : grp = NULL;
688 [ # # ]: 0 : if (EXT4_SB(sb)->s_group_info)
689 : : grp = ext4_get_group_info(sb, i);
690 [ # # ][ # # ]: 0 : if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
691 : 0 : desc_count += ext4_free_group_clusters(sb, gdp);
692 : : }
693 : :
694 : 0 : return desc_count;
695 : : #endif
696 : : }
697 : :
698 : : static inline int test_root(ext4_group_t a, int b)
699 : : {
700 : : while (1) {
701 [ + + ][ + + ]: 336 : if (a < b)
[ + - ]
702 : : return 0;
703 [ + - ][ + - ]: 210 : if (a == b)
[ + - ]
704 : : return 1;
705 [ + + ][ + + ]: 210 : if ((a % b) != 0)
[ + + ]
706 : : return 0;
707 : 43 : a = a / b;
708 : : }
709 : : }
710 : :
711 : 0 : static int ext4_group_sparse(ext4_group_t group)
712 : : {
713 [ + - ]: 119 : if (group <= 1)
714 : : return 1;
715 [ + ]: 119 : if (!(group & 1))
716 : : return 0;
717 [ + - ][ + - ]: 174 : return (test_root(group, 7) || test_root(group, 5) ||
[ + - ]
718 : : test_root(group, 3));
719 : : }
720 : :
721 : : /**
722 : : * ext4_bg_has_super - number of blocks used by the superblock in group
723 : : * @sb: superblock for filesystem
724 : : * @group: group number to check
725 : : *
726 : : * Return the number of blocks used by the superblock (primary or backup)
727 : : * in this group. Currently this will be only 0 or 1.
728 : : */
729 : 0 : int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
730 : : {
731 [ + - ]: 119 : if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
732 [ - + ]: 119 : EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
733 : 119 : !ext4_group_sparse(group))
734 : : return 0;
735 : 0 : return 1;
736 : : }
737 : :
738 : : static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
739 : : ext4_group_t group)
740 : : {
741 : : unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
742 : 0 : ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
743 : 0 : ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
744 : :
745 [ # # ][ # # ]: 0 : if (group == first || group == first + 1 || group == last)
[ # # ]
746 : : return 1;
747 : : return 0;
748 : : }
749 : :
750 : 0 : static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
751 : : ext4_group_t group)
752 : : {
753 [ # # ]: 0 : if (!ext4_bg_has_super(sb, group))
754 : : return 0;
755 : :
756 [ # # ]: 0 : if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG))
757 : 0 : return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
758 : : else
759 : 0 : return EXT4_SB(sb)->s_gdb_count;
760 : : }
761 : :
762 : : /**
763 : : * ext4_bg_num_gdb - number of blocks used by the group table in group
764 : : * @sb: superblock for filesystem
765 : : * @group: group number to check
766 : : *
767 : : * Return the number of blocks used by the group descriptor table
768 : : * (primary or backup) in this group. In the future there may be a
769 : : * different number of descriptor blocks in each group.
770 : : */
771 : 0 : unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
772 : : {
773 : 0 : unsigned long first_meta_bg =
774 : 0 : le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
775 : 0 : unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
776 : :
777 [ # # ][ # # ]: 0 : if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) ||
778 : : metagroup < first_meta_bg)
779 : 0 : return ext4_bg_num_gdb_nometa(sb, group);
780 : :
781 : 0 : return ext4_bg_num_gdb_meta(sb,group);
782 : :
783 : : }
784 : :
785 : : /*
786 : : * This function returns the number of file system metadata clusters at
787 : : * the beginning of a block group, including the reserved gdt blocks.
788 : : */
789 : 0 : static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
790 : : ext4_group_t block_group)
791 : : {
792 : : struct ext4_sb_info *sbi = EXT4_SB(sb);
793 : : unsigned num;
794 : :
795 : : /* Check for superblock and gdt backups in this group */
796 : 119 : num = ext4_bg_has_super(sb, block_group);
797 : :
798 [ - + ][ # # ]: 119 : if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
799 : 0 : block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
800 : 0 : sbi->s_desc_per_block) {
801 [ - + ]: 119 : if (num) {
802 : 0 : num += ext4_bg_num_gdb(sb, block_group);
803 : 0 : num += le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
804 : : }
805 : : } else { /* For META_BG_BLOCK_GROUPS */
806 : 0 : num += ext4_bg_num_gdb(sb, block_group);
807 : : }
808 : 0 : return EXT4_NUM_B2C(sbi, num);
809 : : }
810 : : /**
811 : : * ext4_inode_to_goal_block - return a hint for block allocation
812 : : * @inode: inode for block allocation
813 : : *
814 : : * Return the ideal location to start allocating blocks for a
815 : : * newly created inode.
816 : : */
817 : 0 : ext4_fsblk_t ext4_inode_to_goal_block(struct inode *inode)
818 : : {
819 : : struct ext4_inode_info *ei = EXT4_I(inode);
820 : : ext4_group_t block_group;
821 : : ext4_grpblk_t colour;
822 : 67860 : int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
823 : : ext4_fsblk_t bg_start;
824 : : ext4_fsblk_t last_block;
825 : :
826 : 67860 : block_group = ei->i_block_group;
827 [ + - ]: 67860 : if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
828 : : /*
829 : : * If there are at least EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME
830 : : * block groups per flexgroup, reserve the first block
831 : : * group for directories and special files. Regular
832 : : * files will start at the second block group. This
833 : : * tends to speed up directory access and improves
834 : : * fsck times.
835 : : */
836 : 67860 : block_group &= ~(flex_size-1);
837 [ + + ]: 67860 : if (S_ISREG(inode->i_mode))
838 : 18423 : block_group++;
839 : : }
840 : : bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
841 : 135720 : last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
842 : :
843 : : /*
844 : : * If we are doing delayed allocation, we don't need take
845 : : * colour into account.
846 : : */
847 [ + - ]: 67860 : if (test_opt(inode->i_sb, DELALLOC))
848 : : return bg_start;
849 : :
850 [ # # ]: 67860 : if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
851 : 0 : colour = (current->pid % 16) *
852 : 0 : (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
853 : : else
854 : 0 : colour = (current->pid % 16) * ((last_block - bg_start) / 16);
855 : 0 : return bg_start + colour;
856 : : }
857 : :
|
