This source file includes following definitions.
- ext4_get_group_number
- ext4_get_group_no_and_offset
- ext4_block_in_group
- ext4_num_overhead_clusters
- num_clusters_in_group
- ext4_init_block_bitmap
- ext4_free_clusters_after_init
- ext4_get_group_desc
- ext4_valid_block_bitmap
- ext4_validate_block_bitmap
- ext4_read_block_bitmap_nowait
- ext4_wait_block_bitmap
- ext4_read_block_bitmap
- ext4_has_free_clusters
- ext4_claim_free_clusters
- ext4_should_retry_alloc
- ext4_new_meta_blocks
- ext4_count_free_clusters
- test_root
- ext4_bg_has_super
- ext4_bg_num_gdb_meta
- ext4_bg_num_gdb_nometa
- ext4_bg_num_gdb
- ext4_num_base_meta_clusters
- ext4_inode_to_goal_block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 #include <linux/time.h>
16 #include <linux/capability.h>
17 #include <linux/fs.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
30
31
32
33
34
35 ext4_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))
41 group = (block -
42 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) >>
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
49
50
51
52
53 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 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
57 ext4_grpblk_t offset;
58
59 blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
60 offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb)) >>
61 EXT4_SB(sb)->s_cluster_bits;
62 if (offsetp)
63 *offsetp = offset;
64 if (blockgrpp)
65 *blockgrpp = blocknr;
66
67 }
68
69
70
71
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 actual_group = ext4_get_group_number(sb, block);
80 return (actual_group == block_group) ? 1 : 0;
81 }
82
83
84
85
86 static 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
97
98
99 num_clusters = ext4_num_base_meta_clusters(sb, block_group);
100
101
102
103
104
105
106
107
108
109
110
111
112
113 if (ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), block_group)) {
114 block_cluster = EXT4_B2C(sbi,
115 ext4_block_bitmap(sb, gdp) - start);
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,
126 ext4_inode_bitmap(sb, gdp) - start);
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)) {
138 c = EXT4_B2C(sbi, itbl_blk + i - start);
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;
148 }
149 }
150
151 if (block_cluster != -1)
152 num_clusters++;
153 if (inode_cluster != -1)
154 num_clusters++;
155
156 return num_clusters;
157 }
158
159 static unsigned int num_clusters_in_group(struct super_block *sb,
160 ext4_group_t block_group)
161 {
162 unsigned int blocks;
163
164 if (block_group == ext4_get_groups_count(sb) - 1) {
165
166
167
168
169
170
171 blocks = ext4_blocks_count(EXT4_SB(sb)->s_es) -
172 ext4_group_first_block_no(sb, block_group);
173 } else
174 blocks = EXT4_BLOCKS_PER_GROUP(sb);
175 return EXT4_NUM_B2C(EXT4_SB(sb), blocks);
176 }
177
178
179 static int ext4_init_block_bitmap(struct super_block *sb,
180 struct buffer_head *bh,
181 ext4_group_t block_group,
182 struct ext4_group_desc *gdp)
183 {
184 unsigned int bit, bit_max;
185 struct ext4_sb_info *sbi = EXT4_SB(sb);
186 ext4_fsblk_t start, tmp;
187
188 J_ASSERT_BH(bh, buffer_locked(bh));
189
190
191
192 if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
193 ext4_mark_group_bitmap_corrupted(sb, block_group,
194 EXT4_GROUP_INFO_BBITMAP_CORRUPT |
195 EXT4_GROUP_INFO_IBITMAP_CORRUPT);
196 return -EFSBADCRC;
197 }
198 memset(bh->b_data, 0, sb->s_blocksize);
199
200 bit_max = ext4_num_base_meta_clusters(sb, block_group);
201 if ((bit_max >> 3) >= bh->b_size)
202 return -EFSCORRUPTED;
203
204 for (bit = 0; bit < bit_max; bit++)
205 ext4_set_bit(bit, bh->b_data);
206
207 start = ext4_group_first_block_no(sb, block_group);
208
209
210 tmp = ext4_block_bitmap(sb, gdp);
211 if (ext4_block_in_group(sb, tmp, block_group))
212 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
213
214 tmp = ext4_inode_bitmap(sb, gdp);
215 if (ext4_block_in_group(sb, tmp, block_group))
216 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
217
218 tmp = ext4_inode_table(sb, gdp);
219 for (; tmp < ext4_inode_table(sb, gdp) +
220 sbi->s_itb_per_group; tmp++) {
221 if (ext4_block_in_group(sb, tmp, block_group))
222 ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
223 }
224
225
226
227
228
229
230 ext4_mark_bitmap_end(num_clusters_in_group(sb, block_group),
231 sb->s_blocksize * 8, bh->b_data);
232 return 0;
233 }
234
235
236
237
238 unsigned ext4_free_clusters_after_init(struct super_block *sb,
239 ext4_group_t block_group,
240 struct ext4_group_desc *gdp)
241 {
242 return num_clusters_in_group(sb, block_group) -
243 ext4_num_overhead_clusters(sb, block_group, gdp);
244 }
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264 struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
265 ext4_group_t block_group,
266 struct buffer_head **bh)
267 {
268 unsigned int group_desc;
269 unsigned int offset;
270 ext4_group_t ngroups = ext4_get_groups_count(sb);
271 struct ext4_group_desc *desc;
272 struct ext4_sb_info *sbi = EXT4_SB(sb);
273 struct buffer_head *bh_p;
274
275 if (block_group >= ngroups) {
276 ext4_error(sb, "block_group >= groups_count - block_group = %u,"
277 " groups_count = %u", block_group, ngroups);
278
279 return NULL;
280 }
281
282 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
283 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
284 bh_p = sbi_array_rcu_deref(sbi, s_group_desc, group_desc);
285
286
287
288
289
290
291 if (!bh_p) {
292 ext4_error(sb, "Group descriptor not loaded - "
293 "block_group = %u, group_desc = %u, desc = %u",
294 block_group, group_desc, offset);
295 return NULL;
296 }
297
298 desc = (struct ext4_group_desc *)(
299 (__u8 *)bh_p->b_data +
300 offset * EXT4_DESC_SIZE(sb));
301 if (bh)
302 *bh = bh_p;
303 return desc;
304 }
305
306
307
308
309
310 static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb,
311 struct ext4_group_desc *desc,
312 ext4_group_t block_group,
313 struct buffer_head *bh)
314 {
315 struct ext4_sb_info *sbi = EXT4_SB(sb);
316 ext4_grpblk_t offset;
317 ext4_grpblk_t next_zero_bit;
318 ext4_grpblk_t max_bit = EXT4_CLUSTERS_PER_GROUP(sb);
319 ext4_fsblk_t blk;
320 ext4_fsblk_t group_first_block;
321
322 if (ext4_has_feature_flex_bg(sb)) {
323
324
325
326
327
328
329 return 0;
330 }
331 group_first_block = ext4_group_first_block_no(sb, block_group);
332
333
334 blk = ext4_block_bitmap(sb, desc);
335 offset = blk - group_first_block;
336 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
337 !ext4_test_bit(EXT4_B2C(sbi, offset), bh->b_data))
338
339 return blk;
340
341
342 blk = ext4_inode_bitmap(sb, desc);
343 offset = blk - group_first_block;
344 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
345 !ext4_test_bit(EXT4_B2C(sbi, offset), bh->b_data))
346
347 return blk;
348
349
350 blk = ext4_inode_table(sb, desc);
351 offset = blk - group_first_block;
352 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
353 EXT4_B2C(sbi, offset + sbi->s_itb_per_group) >= max_bit)
354 return blk;
355 next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
356 EXT4_B2C(sbi, offset + sbi->s_itb_per_group),
357 EXT4_B2C(sbi, offset));
358 if (next_zero_bit <
359 EXT4_B2C(sbi, offset + sbi->s_itb_per_group))
360
361 return blk;
362 return 0;
363 }
364
365 static int ext4_validate_block_bitmap(struct super_block *sb,
366 struct ext4_group_desc *desc,
367 ext4_group_t block_group,
368 struct buffer_head *bh)
369 {
370 ext4_fsblk_t blk;
371 struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
372
373 if (buffer_verified(bh))
374 return 0;
375 if (EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
376 return -EFSCORRUPTED;
377
378 ext4_lock_group(sb, block_group);
379 if (buffer_verified(bh))
380 goto verified;
381 if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
382 desc, bh))) {
383 ext4_unlock_group(sb, block_group);
384 ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
385 ext4_mark_group_bitmap_corrupted(sb, block_group,
386 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
387 return -EFSBADCRC;
388 }
389 blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
390 if (unlikely(blk != 0)) {
391 ext4_unlock_group(sb, block_group);
392 ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
393 block_group, blk);
394 ext4_mark_group_bitmap_corrupted(sb, block_group,
395 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
396 return -EFSCORRUPTED;
397 }
398 set_buffer_verified(bh);
399 verified:
400 ext4_unlock_group(sb, block_group);
401 return 0;
402 }
403
404
405
406
407
408
409
410
411
412
413
414 struct buffer_head *
415 ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
416 {
417 struct ext4_group_desc *desc;
418 struct ext4_sb_info *sbi = EXT4_SB(sb);
419 struct buffer_head *bh;
420 ext4_fsblk_t bitmap_blk;
421 int err;
422
423 desc = ext4_get_group_desc(sb, block_group, NULL);
424 if (!desc)
425 return ERR_PTR(-EFSCORRUPTED);
426 bitmap_blk = ext4_block_bitmap(sb, desc);
427 if ((bitmap_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||
428 (bitmap_blk >= ext4_blocks_count(sbi->s_es))) {
429 ext4_error(sb, "Invalid block bitmap block %llu in "
430 "block_group %u", bitmap_blk, block_group);
431 ext4_mark_group_bitmap_corrupted(sb, block_group,
432 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
433 return ERR_PTR(-EFSCORRUPTED);
434 }
435 bh = sb_getblk(sb, bitmap_blk);
436 if (unlikely(!bh)) {
437 ext4_warning(sb, "Cannot get buffer for block bitmap - "
438 "block_group = %u, block_bitmap = %llu",
439 block_group, bitmap_blk);
440 return ERR_PTR(-ENOMEM);
441 }
442
443 if (bitmap_uptodate(bh))
444 goto verify;
445
446 lock_buffer(bh);
447 if (bitmap_uptodate(bh)) {
448 unlock_buffer(bh);
449 goto verify;
450 }
451 ext4_lock_group(sb, block_group);
452 if (ext4_has_group_desc_csum(sb) &&
453 (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))) {
454 if (block_group == 0) {
455 ext4_unlock_group(sb, block_group);
456 unlock_buffer(bh);
457 ext4_error(sb, "Block bitmap for bg 0 marked "
458 "uninitialized");
459 err = -EFSCORRUPTED;
460 goto out;
461 }
462 err = ext4_init_block_bitmap(sb, bh, block_group, desc);
463 set_bitmap_uptodate(bh);
464 set_buffer_uptodate(bh);
465 set_buffer_verified(bh);
466 ext4_unlock_group(sb, block_group);
467 unlock_buffer(bh);
468 if (err) {
469 ext4_error(sb, "Failed to init block bitmap for group "
470 "%u: %d", block_group, err);
471 goto out;
472 }
473 goto verify;
474 }
475 ext4_unlock_group(sb, block_group);
476 if (buffer_uptodate(bh)) {
477
478
479
480
481 set_bitmap_uptodate(bh);
482 unlock_buffer(bh);
483 goto verify;
484 }
485
486
487
488 set_buffer_new(bh);
489 trace_ext4_read_block_bitmap_load(sb, block_group);
490 bh->b_end_io = ext4_end_bitmap_read;
491 get_bh(bh);
492 submit_bh(REQ_OP_READ, REQ_META | REQ_PRIO, bh);
493 return bh;
494 verify:
495 err = ext4_validate_block_bitmap(sb, desc, block_group, bh);
496 if (err)
497 goto out;
498 return bh;
499 out:
500 put_bh(bh);
501 return ERR_PTR(err);
502 }
503
504
505 int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
506 struct buffer_head *bh)
507 {
508 struct ext4_group_desc *desc;
509
510 if (!buffer_new(bh))
511 return 0;
512 desc = ext4_get_group_desc(sb, block_group, NULL);
513 if (!desc)
514 return -EFSCORRUPTED;
515 wait_on_buffer(bh);
516 if (!buffer_uptodate(bh)) {
517 ext4_error(sb, "Cannot read block bitmap - "
518 "block_group = %u, block_bitmap = %llu",
519 block_group, (unsigned long long) bh->b_blocknr);
520 ext4_mark_group_bitmap_corrupted(sb, block_group,
521 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
522 return -EIO;
523 }
524 clear_buffer_new(bh);
525
526 return ext4_validate_block_bitmap(sb, desc, block_group, bh);
527 }
528
529 struct buffer_head *
530 ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
531 {
532 struct buffer_head *bh;
533 int err;
534
535 bh = ext4_read_block_bitmap_nowait(sb, block_group);
536 if (IS_ERR(bh))
537 return bh;
538 err = ext4_wait_block_bitmap(sb, block_group, bh);
539 if (err) {
540 put_bh(bh);
541 return ERR_PTR(err);
542 }
543 return bh;
544 }
545
546
547
548
549
550
551
552
553
554
555 static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
556 s64 nclusters, unsigned int flags)
557 {
558 s64 free_clusters, dirty_clusters, rsv, resv_clusters;
559 struct percpu_counter *fcc = &sbi->s_freeclusters_counter;
560 struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter;
561
562 free_clusters = percpu_counter_read_positive(fcc);
563 dirty_clusters = percpu_counter_read_positive(dcc);
564 resv_clusters = atomic64_read(&sbi->s_resv_clusters);
565
566
567
568
569
570 rsv = (ext4_r_blocks_count(sbi->s_es) >> sbi->s_cluster_bits) +
571 resv_clusters;
572
573 if (free_clusters - (nclusters + rsv + dirty_clusters) <
574 EXT4_FREECLUSTERS_WATERMARK) {
575 free_clusters = percpu_counter_sum_positive(fcc);
576 dirty_clusters = percpu_counter_sum_positive(dcc);
577 }
578
579
580
581 if (free_clusters >= (rsv + nclusters + dirty_clusters))
582 return 1;
583
584
585 if (uid_eq(sbi->s_resuid, current_fsuid()) ||
586 (!gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) && in_group_p(sbi->s_resgid)) ||
587 capable(CAP_SYS_RESOURCE) ||
588 (flags & EXT4_MB_USE_ROOT_BLOCKS)) {
589
590 if (free_clusters >= (nclusters + dirty_clusters +
591 resv_clusters))
592 return 1;
593 }
594
595 if (flags & EXT4_MB_USE_RESERVED) {
596 if (free_clusters >= (nclusters + dirty_clusters))
597 return 1;
598 }
599
600 return 0;
601 }
602
603 int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
604 s64 nclusters, unsigned int flags)
605 {
606 if (ext4_has_free_clusters(sbi, nclusters, flags)) {
607 percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters);
608 return 0;
609 } else
610 return -ENOSPC;
611 }
612
613
614
615
616
617
618
619
620
621
622
623 int ext4_should_retry_alloc(struct super_block *sb, int *retries)
624 {
625 if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||
626 (*retries)++ > 1 ||
627 !EXT4_SB(sb)->s_journal)
628 return 0;
629
630 smp_mb();
631 if (EXT4_SB(sb)->s_mb_free_pending == 0)
632 return 0;
633
634 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
635 jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
636 return 1;
637 }
638
639
640
641
642
643
644
645
646
647
648
649
650
651 ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
652 ext4_fsblk_t goal, unsigned int flags,
653 unsigned long *count, int *errp)
654 {
655 struct ext4_allocation_request ar;
656 ext4_fsblk_t ret;
657
658 memset(&ar, 0, sizeof(ar));
659
660 ar.inode = inode;
661 ar.goal = goal;
662 ar.len = count ? *count : 1;
663 ar.flags = flags;
664
665 ret = ext4_mb_new_blocks(handle, &ar, errp);
666 if (count)
667 *count = ar.len;
668
669
670
671
672 if (!(*errp) && (flags & EXT4_MB_DELALLOC_RESERVED)) {
673 dquot_alloc_block_nofail(inode,
674 EXT4_C2B(EXT4_SB(inode->i_sb), ar.len));
675 }
676 return ret;
677 }
678
679
680
681
682
683
684
685 ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb)
686 {
687 ext4_fsblk_t desc_count;
688 struct ext4_group_desc *gdp;
689 ext4_group_t i;
690 ext4_group_t ngroups = ext4_get_groups_count(sb);
691 struct ext4_group_info *grp;
692 #ifdef EXT4FS_DEBUG
693 struct ext4_super_block *es;
694 ext4_fsblk_t bitmap_count;
695 unsigned int x;
696 struct buffer_head *bitmap_bh = NULL;
697
698 es = EXT4_SB(sb)->s_es;
699 desc_count = 0;
700 bitmap_count = 0;
701 gdp = NULL;
702
703 for (i = 0; i < ngroups; i++) {
704 gdp = ext4_get_group_desc(sb, i, NULL);
705 if (!gdp)
706 continue;
707 grp = NULL;
708 if (EXT4_SB(sb)->s_group_info)
709 grp = ext4_get_group_info(sb, i);
710 if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
711 desc_count += ext4_free_group_clusters(sb, gdp);
712 brelse(bitmap_bh);
713 bitmap_bh = ext4_read_block_bitmap(sb, i);
714 if (IS_ERR(bitmap_bh)) {
715 bitmap_bh = NULL;
716 continue;
717 }
718
719 x = ext4_count_free(bitmap_bh->b_data,
720 EXT4_CLUSTERS_PER_GROUP(sb) / 8);
721 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
722 i, ext4_free_group_clusters(sb, gdp), x);
723 bitmap_count += x;
724 }
725 brelse(bitmap_bh);
726 printk(KERN_DEBUG "ext4_count_free_clusters: stored = %llu"
727 ", computed = %llu, %llu\n",
728 EXT4_NUM_B2C(EXT4_SB(sb), ext4_free_blocks_count(es)),
729 desc_count, bitmap_count);
730 return bitmap_count;
731 #else
732 desc_count = 0;
733 for (i = 0; i < ngroups; i++) {
734 gdp = ext4_get_group_desc(sb, i, NULL);
735 if (!gdp)
736 continue;
737 grp = NULL;
738 if (EXT4_SB(sb)->s_group_info)
739 grp = ext4_get_group_info(sb, i);
740 if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
741 desc_count += ext4_free_group_clusters(sb, gdp);
742 }
743
744 return desc_count;
745 #endif
746 }
747
748 static inline int test_root(ext4_group_t a, int b)
749 {
750 while (1) {
751 if (a < b)
752 return 0;
753 if (a == b)
754 return 1;
755 if ((a % b) != 0)
756 return 0;
757 a = a / b;
758 }
759 }
760
761
762
763
764
765
766
767
768
769 int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
770 {
771 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
772
773 if (group == 0)
774 return 1;
775 if (ext4_has_feature_sparse_super2(sb)) {
776 if (group == le32_to_cpu(es->s_backup_bgs[0]) ||
777 group == le32_to_cpu(es->s_backup_bgs[1]))
778 return 1;
779 return 0;
780 }
781 if ((group <= 1) || !ext4_has_feature_sparse_super(sb))
782 return 1;
783 if (!(group & 1))
784 return 0;
785 if (test_root(group, 3) || (test_root(group, 5)) ||
786 test_root(group, 7))
787 return 1;
788
789 return 0;
790 }
791
792 static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
793 ext4_group_t group)
794 {
795 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
796 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
797 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
798
799 if (group == first || group == first + 1 || group == last)
800 return 1;
801 return 0;
802 }
803
804 static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
805 ext4_group_t group)
806 {
807 if (!ext4_bg_has_super(sb, group))
808 return 0;
809
810 if (ext4_has_feature_meta_bg(sb))
811 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
812 else
813 return EXT4_SB(sb)->s_gdb_count;
814 }
815
816
817
818
819
820
821
822
823
824
825 unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
826 {
827 unsigned long first_meta_bg =
828 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
829 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
830
831 if (!ext4_has_feature_meta_bg(sb) || metagroup < first_meta_bg)
832 return ext4_bg_num_gdb_nometa(sb, group);
833
834 return ext4_bg_num_gdb_meta(sb,group);
835
836 }
837
838
839
840
841
842 static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
843 ext4_group_t block_group)
844 {
845 struct ext4_sb_info *sbi = EXT4_SB(sb);
846 unsigned num;
847
848
849 num = ext4_bg_has_super(sb, block_group);
850
851 if (!ext4_has_feature_meta_bg(sb) ||
852 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
853 sbi->s_desc_per_block) {
854 if (num) {
855 num += ext4_bg_num_gdb(sb, block_group);
856 num += le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
857 }
858 } else {
859 num += ext4_bg_num_gdb(sb, block_group);
860 }
861 return EXT4_NUM_B2C(sbi, num);
862 }
863
864
865
866
867
868
869
870 ext4_fsblk_t ext4_inode_to_goal_block(struct inode *inode)
871 {
872 struct ext4_inode_info *ei = EXT4_I(inode);
873 ext4_group_t block_group;
874 ext4_grpblk_t colour;
875 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
876 ext4_fsblk_t bg_start;
877 ext4_fsblk_t last_block;
878
879 block_group = ei->i_block_group;
880 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
881
882
883
884
885
886
887
888
889 block_group &= ~(flex_size-1);
890 if (S_ISREG(inode->i_mode))
891 block_group++;
892 }
893 bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
894 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
895
896
897
898
899
900 if (test_opt(inode->i_sb, DELALLOC))
901 return bg_start;
902
903 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
904 colour = (current->pid % 16) *
905 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
906 else
907 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
908 return bg_start + colour;
909 }
910