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
26static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
27 ext4_group_t block_group);
28
29
30
31
32
33
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))
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
53void 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
73static 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
86static 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
159static 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
179static 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
238unsigned 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
264struct 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
274 if (block_group >= ngroups) {
275 ext4_error(sb, "block_group >= groups_count - block_group = %u,"
276 " groups_count = %u", block_group, ngroups);
277
278 return NULL;
279 }
280
281 group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
282 offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
283 if (!sbi->s_group_desc[group_desc]) {
284 ext4_error(sb, "Group descriptor not loaded - "
285 "block_group = %u, group_desc = %u, desc = %u",
286 block_group, group_desc, offset);
287 return NULL;
288 }
289
290 desc = (struct ext4_group_desc *)(
291 (__u8 *)sbi->s_group_desc[group_desc]->b_data +
292 offset * EXT4_DESC_SIZE(sb));
293 if (bh)
294 *bh = sbi->s_group_desc[group_desc];
295 return desc;
296}
297
298
299
300
301
302static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb,
303 struct ext4_group_desc *desc,
304 ext4_group_t block_group,
305 struct buffer_head *bh)
306{
307 struct ext4_sb_info *sbi = EXT4_SB(sb);
308 ext4_grpblk_t offset;
309 ext4_grpblk_t next_zero_bit;
310 ext4_grpblk_t max_bit = EXT4_CLUSTERS_PER_GROUP(sb);
311 ext4_fsblk_t blk;
312 ext4_fsblk_t group_first_block;
313
314 if (ext4_has_feature_flex_bg(sb)) {
315
316
317
318
319
320
321 return 0;
322 }
323 group_first_block = ext4_group_first_block_no(sb, block_group);
324
325
326 blk = ext4_block_bitmap(sb, desc);
327 offset = blk - group_first_block;
328 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
329 !ext4_test_bit(EXT4_B2C(sbi, offset), bh->b_data))
330
331 return blk;
332
333
334 blk = ext4_inode_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_table(sb, desc);
343 offset = blk - group_first_block;
344 if (offset < 0 || EXT4_B2C(sbi, offset) >= max_bit ||
345 EXT4_B2C(sbi, offset + sbi->s_itb_per_group) >= max_bit)
346 return blk;
347 next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
348 EXT4_B2C(sbi, offset + sbi->s_itb_per_group),
349 EXT4_B2C(sbi, offset));
350 if (next_zero_bit <
351 EXT4_B2C(sbi, offset + sbi->s_itb_per_group))
352
353 return blk;
354 return 0;
355}
356
357static int ext4_validate_block_bitmap(struct super_block *sb,
358 struct ext4_group_desc *desc,
359 ext4_group_t block_group,
360 struct buffer_head *bh)
361{
362 ext4_fsblk_t blk;
363 struct ext4_group_info *grp = ext4_get_group_info(sb, block_group);
364
365 if (buffer_verified(bh))
366 return 0;
367 if (EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
368 return -EFSCORRUPTED;
369
370 ext4_lock_group(sb, block_group);
371 if (buffer_verified(bh))
372 goto verified;
373 if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
374 desc, bh))) {
375 ext4_unlock_group(sb, block_group);
376 ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
377 ext4_mark_group_bitmap_corrupted(sb, block_group,
378 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
379 return -EFSBADCRC;
380 }
381 blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
382 if (unlikely(blk != 0)) {
383 ext4_unlock_group(sb, block_group);
384 ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
385 block_group, blk);
386 ext4_mark_group_bitmap_corrupted(sb, block_group,
387 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
388 return -EFSCORRUPTED;
389 }
390 set_buffer_verified(bh);
391verified:
392 ext4_unlock_group(sb, block_group);
393 return 0;
394}
395
396
397
398
399
400
401
402
403
404
405
406struct buffer_head *
407ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
408{
409 struct ext4_group_desc *desc;
410 struct ext4_sb_info *sbi = EXT4_SB(sb);
411 struct buffer_head *bh;
412 ext4_fsblk_t bitmap_blk;
413 int err;
414
415 desc = ext4_get_group_desc(sb, block_group, NULL);
416 if (!desc)
417 return ERR_PTR(-EFSCORRUPTED);
418 bitmap_blk = ext4_block_bitmap(sb, desc);
419 if ((bitmap_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||
420 (bitmap_blk >= ext4_blocks_count(sbi->s_es))) {
421 ext4_error(sb, "Invalid block bitmap block %llu in "
422 "block_group %u", bitmap_blk, block_group);
423 ext4_mark_group_bitmap_corrupted(sb, block_group,
424 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
425 return ERR_PTR(-EFSCORRUPTED);
426 }
427 bh = sb_getblk(sb, bitmap_blk);
428 if (unlikely(!bh)) {
429 ext4_warning(sb, "Cannot get buffer for block bitmap - "
430 "block_group = %u, block_bitmap = %llu",
431 block_group, bitmap_blk);
432 return ERR_PTR(-ENOMEM);
433 }
434
435 if (bitmap_uptodate(bh))
436 goto verify;
437
438 lock_buffer(bh);
439 if (bitmap_uptodate(bh)) {
440 unlock_buffer(bh);
441 goto verify;
442 }
443 ext4_lock_group(sb, block_group);
444 if (ext4_has_group_desc_csum(sb) &&
445 (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))) {
446 if (block_group == 0) {
447 ext4_unlock_group(sb, block_group);
448 unlock_buffer(bh);
449 ext4_error(sb, "Block bitmap for bg 0 marked "
450 "uninitialized");
451 err = -EFSCORRUPTED;
452 goto out;
453 }
454 err = ext4_init_block_bitmap(sb, bh, block_group, desc);
455 set_bitmap_uptodate(bh);
456 set_buffer_uptodate(bh);
457 set_buffer_verified(bh);
458 ext4_unlock_group(sb, block_group);
459 unlock_buffer(bh);
460 if (err) {
461 ext4_error(sb, "Failed to init block bitmap for group "
462 "%u: %d", block_group, err);
463 goto out;
464 }
465 goto verify;
466 }
467 ext4_unlock_group(sb, block_group);
468 if (buffer_uptodate(bh)) {
469
470
471
472
473 set_bitmap_uptodate(bh);
474 unlock_buffer(bh);
475 goto verify;
476 }
477
478
479
480 set_buffer_new(bh);
481 trace_ext4_read_block_bitmap_load(sb, block_group);
482 bh->b_end_io = ext4_end_bitmap_read;
483 get_bh(bh);
484 submit_bh(REQ_OP_READ, REQ_META | REQ_PRIO, bh);
485 return bh;
486verify:
487 err = ext4_validate_block_bitmap(sb, desc, block_group, bh);
488 if (err)
489 goto out;
490 return bh;
491out:
492 put_bh(bh);
493 return ERR_PTR(err);
494}
495
496
497int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
498 struct buffer_head *bh)
499{
500 struct ext4_group_desc *desc;
501
502 if (!buffer_new(bh))
503 return 0;
504 desc = ext4_get_group_desc(sb, block_group, NULL);
505 if (!desc)
506 return -EFSCORRUPTED;
507 wait_on_buffer(bh);
508 if (!buffer_uptodate(bh)) {
509 ext4_error(sb, "Cannot read block bitmap - "
510 "block_group = %u, block_bitmap = %llu",
511 block_group, (unsigned long long) bh->b_blocknr);
512 ext4_mark_group_bitmap_corrupted(sb, block_group,
513 EXT4_GROUP_INFO_BBITMAP_CORRUPT);
514 return -EIO;
515 }
516 clear_buffer_new(bh);
517
518 return ext4_validate_block_bitmap(sb, desc, block_group, bh);
519}
520
521struct buffer_head *
522ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
523{
524 struct buffer_head *bh;
525 int err;
526
527 bh = ext4_read_block_bitmap_nowait(sb, block_group);
528 if (IS_ERR(bh))
529 return bh;
530 err = ext4_wait_block_bitmap(sb, block_group, bh);
531 if (err) {
532 put_bh(bh);
533 return ERR_PTR(err);
534 }
535 return bh;
536}
537
538
539
540
541
542
543
544
545
546
547static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
548 s64 nclusters, unsigned int flags)
549{
550 s64 free_clusters, dirty_clusters, rsv, resv_clusters;
551 struct percpu_counter *fcc = &sbi->s_freeclusters_counter;
552 struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter;
553
554 free_clusters = percpu_counter_read_positive(fcc);
555 dirty_clusters = percpu_counter_read_positive(dcc);
556 resv_clusters = atomic64_read(&sbi->s_resv_clusters);
557
558
559
560
561
562 rsv = (ext4_r_blocks_count(sbi->s_es) >> sbi->s_cluster_bits) +
563 resv_clusters;
564
565 if (free_clusters - (nclusters + rsv + dirty_clusters) <
566 EXT4_FREECLUSTERS_WATERMARK) {
567 free_clusters = percpu_counter_sum_positive(fcc);
568 dirty_clusters = percpu_counter_sum_positive(dcc);
569 }
570
571
572
573 if (free_clusters >= (rsv + nclusters + dirty_clusters))
574 return 1;
575
576
577 if (uid_eq(sbi->s_resuid, current_fsuid()) ||
578 (!gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) && in_group_p(sbi->s_resgid)) ||
579 capable(CAP_SYS_RESOURCE) ||
580 (flags & EXT4_MB_USE_ROOT_BLOCKS)) {
581
582 if (free_clusters >= (nclusters + dirty_clusters +
583 resv_clusters))
584 return 1;
585 }
586
587 if (flags & EXT4_MB_USE_RESERVED) {
588 if (free_clusters >= (nclusters + dirty_clusters))
589 return 1;
590 }
591
592 return 0;
593}
594
595int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
596 s64 nclusters, unsigned int flags)
597{
598 if (ext4_has_free_clusters(sbi, nclusters, flags)) {
599 percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters);
600 return 0;
601 } else
602 return -ENOSPC;
603}
604
605
606
607
608
609
610
611
612
613
614
615int ext4_should_retry_alloc(struct super_block *sb, int *retries)
616{
617 if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||
618 (*retries)++ > 1 ||
619 !EXT4_SB(sb)->s_journal)
620 return 0;
621
622 smp_mb();
623 if (EXT4_SB(sb)->s_mb_free_pending == 0)
624 return 0;
625
626 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
627 jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
628 return 1;
629}
630
631
632
633
634
635
636
637
638
639
640
641
642
643ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
644 ext4_fsblk_t goal, unsigned int flags,
645 unsigned long *count, int *errp)
646{
647 struct ext4_allocation_request ar;
648 ext4_fsblk_t ret;
649
650 memset(&ar, 0, sizeof(ar));
651
652 ar.inode = inode;
653 ar.goal = goal;
654 ar.len = count ? *count : 1;
655 ar.flags = flags;
656
657 ret = ext4_mb_new_blocks(handle, &ar, errp);
658 if (count)
659 *count = ar.len;
660
661
662
663
664 if (!(*errp) && (flags & EXT4_MB_DELALLOC_RESERVED)) {
665 dquot_alloc_block_nofail(inode,
666 EXT4_C2B(EXT4_SB(inode->i_sb), ar.len));
667 }
668 return ret;
669}
670
671
672
673
674
675
676
677ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb)
678{
679 ext4_fsblk_t desc_count;
680 struct ext4_group_desc *gdp;
681 ext4_group_t i;
682 ext4_group_t ngroups = ext4_get_groups_count(sb);
683 struct ext4_group_info *grp;
684#ifdef EXT4FS_DEBUG
685 struct ext4_super_block *es;
686 ext4_fsblk_t bitmap_count;
687 unsigned int x;
688 struct buffer_head *bitmap_bh = NULL;
689
690 es = EXT4_SB(sb)->s_es;
691 desc_count = 0;
692 bitmap_count = 0;
693 gdp = NULL;
694
695 for (i = 0; i < ngroups; i++) {
696 gdp = ext4_get_group_desc(sb, i, NULL);
697 if (!gdp)
698 continue;
699 grp = NULL;
700 if (EXT4_SB(sb)->s_group_info)
701 grp = ext4_get_group_info(sb, i);
702 if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
703 desc_count += ext4_free_group_clusters(sb, gdp);
704 brelse(bitmap_bh);
705 bitmap_bh = ext4_read_block_bitmap(sb, i);
706 if (IS_ERR(bitmap_bh)) {
707 bitmap_bh = NULL;
708 continue;
709 }
710
711 x = ext4_count_free(bitmap_bh->b_data,
712 EXT4_CLUSTERS_PER_GROUP(sb) / 8);
713 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
714 i, ext4_free_group_clusters(sb, gdp), x);
715 bitmap_count += x;
716 }
717 brelse(bitmap_bh);
718 printk(KERN_DEBUG "ext4_count_free_clusters: stored = %llu"
719 ", computed = %llu, %llu\n",
720 EXT4_NUM_B2C(EXT4_SB(sb), ext4_free_blocks_count(es)),
721 desc_count, bitmap_count);
722 return bitmap_count;
723#else
724 desc_count = 0;
725 for (i = 0; i < ngroups; i++) {
726 gdp = ext4_get_group_desc(sb, i, NULL);
727 if (!gdp)
728 continue;
729 grp = NULL;
730 if (EXT4_SB(sb)->s_group_info)
731 grp = ext4_get_group_info(sb, i);
732 if (!grp || !EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
733 desc_count += ext4_free_group_clusters(sb, gdp);
734 }
735
736 return desc_count;
737#endif
738}
739
740static inline int test_root(ext4_group_t a, int b)
741{
742 while (1) {
743 if (a < b)
744 return 0;
745 if (a == b)
746 return 1;
747 if ((a % b) != 0)
748 return 0;
749 a = a / b;
750 }
751}
752
753
754
755
756
757
758
759
760
761int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
762{
763 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
764
765 if (group == 0)
766 return 1;
767 if (ext4_has_feature_sparse_super2(sb)) {
768 if (group == le32_to_cpu(es->s_backup_bgs[0]) ||
769 group == le32_to_cpu(es->s_backup_bgs[1]))
770 return 1;
771 return 0;
772 }
773 if ((group <= 1) || !ext4_has_feature_sparse_super(sb))
774 return 1;
775 if (!(group & 1))
776 return 0;
777 if (test_root(group, 3) || (test_root(group, 5)) ||
778 test_root(group, 7))
779 return 1;
780
781 return 0;
782}
783
784static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
785 ext4_group_t group)
786{
787 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
788 ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
789 ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
790
791 if (group == first || group == first + 1 || group == last)
792 return 1;
793 return 0;
794}
795
796static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
797 ext4_group_t group)
798{
799 if (!ext4_bg_has_super(sb, group))
800 return 0;
801
802 if (ext4_has_feature_meta_bg(sb))
803 return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
804 else
805 return EXT4_SB(sb)->s_gdb_count;
806}
807
808
809
810
811
812
813
814
815
816
817unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
818{
819 unsigned long first_meta_bg =
820 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
821 unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
822
823 if (!ext4_has_feature_meta_bg(sb) || metagroup < first_meta_bg)
824 return ext4_bg_num_gdb_nometa(sb, group);
825
826 return ext4_bg_num_gdb_meta(sb,group);
827
828}
829
830
831
832
833
834static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
835 ext4_group_t block_group)
836{
837 struct ext4_sb_info *sbi = EXT4_SB(sb);
838 unsigned num;
839
840
841 num = ext4_bg_has_super(sb, block_group);
842
843 if (!ext4_has_feature_meta_bg(sb) ||
844 block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
845 sbi->s_desc_per_block) {
846 if (num) {
847 num += ext4_bg_num_gdb(sb, block_group);
848 num += le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
849 }
850 } else {
851 num += ext4_bg_num_gdb(sb, block_group);
852 }
853 return EXT4_NUM_B2C(sbi, num);
854}
855
856
857
858
859
860
861
862ext4_fsblk_t ext4_inode_to_goal_block(struct inode *inode)
863{
864 struct ext4_inode_info *ei = EXT4_I(inode);
865 ext4_group_t block_group;
866 ext4_grpblk_t colour;
867 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
868 ext4_fsblk_t bg_start;
869 ext4_fsblk_t last_block;
870
871 block_group = ei->i_block_group;
872 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
873
874
875
876
877
878
879
880
881 block_group &= ~(flex_size-1);
882 if (S_ISREG(inode->i_mode))
883 block_group++;
884 }
885 bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
886 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
887
888
889
890
891
892 if (test_opt(inode->i_sb, DELALLOC))
893 return bg_start;
894
895 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
896 colour = (current->pid % 16) *
897 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
898 else
899 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
900 return bg_start + colour;
901}
902
903