1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/time.h>
15#include <linux/capability.h>
16#include <linux/fs.h>
17#include <linux/jbd.h>
18#include <linux/ext3_fs.h>
19#include <linux/ext3_jbd.h>
20#include <linux/quotaops.h>
21#include <linux/buffer_head.h>
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
40
41
42
43
44
45
46
47
48struct ext3_group_desc * ext3_get_group_desc(struct super_block * sb,
49 unsigned int block_group,
50 struct buffer_head ** bh)
51{
52 unsigned long group_desc;
53 unsigned long offset;
54 struct ext3_group_desc * desc;
55 struct ext3_sb_info *sbi = EXT3_SB(sb);
56
57 if (block_group >= sbi->s_groups_count) {
58 ext3_error (sb, "ext3_get_group_desc",
59 "block_group >= groups_count - "
60 "block_group = %d, groups_count = %lu",
61 block_group, sbi->s_groups_count);
62
63 return NULL;
64 }
65 smp_rmb();
66
67 group_desc = block_group >> EXT3_DESC_PER_BLOCK_BITS(sb);
68 offset = block_group & (EXT3_DESC_PER_BLOCK(sb) - 1);
69 if (!sbi->s_group_desc[group_desc]) {
70 ext3_error (sb, "ext3_get_group_desc",
71 "Group descriptor not loaded - "
72 "block_group = %d, group_desc = %lu, desc = %lu",
73 block_group, group_desc, offset);
74 return NULL;
75 }
76
77 desc = (struct ext3_group_desc *) sbi->s_group_desc[group_desc]->b_data;
78 if (bh)
79 *bh = sbi->s_group_desc[group_desc];
80 return desc + offset;
81}
82
83static int ext3_valid_block_bitmap(struct super_block *sb,
84 struct ext3_group_desc *desc,
85 unsigned int block_group,
86 struct buffer_head *bh)
87{
88 ext3_grpblk_t offset;
89 ext3_grpblk_t next_zero_bit;
90 ext3_fsblk_t bitmap_blk;
91 ext3_fsblk_t group_first_block;
92
93 group_first_block = ext3_group_first_block_no(sb, block_group);
94
95
96 bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
97 offset = bitmap_blk - group_first_block;
98 if (!ext3_test_bit(offset, bh->b_data))
99
100 goto err_out;
101
102
103 bitmap_blk = le32_to_cpu(desc->bg_inode_bitmap);
104 offset = bitmap_blk - group_first_block;
105 if (!ext3_test_bit(offset, bh->b_data))
106
107 goto err_out;
108
109
110 bitmap_blk = le32_to_cpu(desc->bg_inode_table);
111 offset = bitmap_blk - group_first_block;
112 next_zero_bit = ext3_find_next_zero_bit(bh->b_data,
113 offset + EXT3_SB(sb)->s_itb_per_group,
114 offset);
115 if (next_zero_bit >= offset + EXT3_SB(sb)->s_itb_per_group)
116
117 return 1;
118
119err_out:
120 ext3_error(sb, __func__,
121 "Invalid block bitmap - "
122 "block_group = %d, block = %lu",
123 block_group, bitmap_blk);
124 return 0;
125}
126
127
128
129
130
131
132
133
134
135
136
137static struct buffer_head *
138read_block_bitmap(struct super_block *sb, unsigned int block_group)
139{
140 struct ext3_group_desc * desc;
141 struct buffer_head * bh = NULL;
142 ext3_fsblk_t bitmap_blk;
143
144 desc = ext3_get_group_desc(sb, block_group, NULL);
145 if (!desc)
146 return NULL;
147 bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
148 bh = sb_getblk(sb, bitmap_blk);
149 if (unlikely(!bh)) {
150 ext3_error(sb, __func__,
151 "Cannot read block bitmap - "
152 "block_group = %d, block_bitmap = %u",
153 block_group, le32_to_cpu(desc->bg_block_bitmap));
154 return NULL;
155 }
156 if (likely(bh_uptodate_or_lock(bh)))
157 return bh;
158
159 if (bh_submit_read(bh) < 0) {
160 brelse(bh);
161 ext3_error(sb, __func__,
162 "Cannot read block bitmap - "
163 "block_group = %d, block_bitmap = %u",
164 block_group, le32_to_cpu(desc->bg_block_bitmap));
165 return NULL;
166 }
167 ext3_valid_block_bitmap(sb, desc, block_group, bh);
168
169
170
171
172 return bh;
173}
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195#if 1
196static void __rsv_window_dump(struct rb_root *root, int verbose,
197 const char *fn)
198{
199 struct rb_node *n;
200 struct ext3_reserve_window_node *rsv, *prev;
201 int bad;
202
203restart:
204 n = rb_first(root);
205 bad = 0;
206 prev = NULL;
207
208 printk("Block Allocation Reservation Windows Map (%s):\n", fn);
209 while (n) {
210 rsv = rb_entry(n, struct ext3_reserve_window_node, rsv_node);
211 if (verbose)
212 printk("reservation window 0x%p "
213 "start: %lu, end: %lu\n",
214 rsv, rsv->rsv_start, rsv->rsv_end);
215 if (rsv->rsv_start && rsv->rsv_start >= rsv->rsv_end) {
216 printk("Bad reservation %p (start >= end)\n",
217 rsv);
218 bad = 1;
219 }
220 if (prev && prev->rsv_end >= rsv->rsv_start) {
221 printk("Bad reservation %p (prev->end >= start)\n",
222 rsv);
223 bad = 1;
224 }
225 if (bad) {
226 if (!verbose) {
227 printk("Restarting reservation walk in verbose mode\n");
228 verbose = 1;
229 goto restart;
230 }
231 }
232 n = rb_next(n);
233 prev = rsv;
234 }
235 printk("Window map complete.\n");
236 BUG_ON(bad);
237}
238#define rsv_window_dump(root, verbose) \
239 __rsv_window_dump((root), (verbose), __func__)
240#else
241#define rsv_window_dump(root, verbose) do {} while (0)
242#endif
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260static int
261goal_in_my_reservation(struct ext3_reserve_window *rsv, ext3_grpblk_t grp_goal,
262 unsigned int group, struct super_block * sb)
263{
264 ext3_fsblk_t group_first_block, group_last_block;
265
266 group_first_block = ext3_group_first_block_no(sb, group);
267 group_last_block = group_first_block + (EXT3_BLOCKS_PER_GROUP(sb) - 1);
268
269 if ((rsv->_rsv_start > group_last_block) ||
270 (rsv->_rsv_end < group_first_block))
271 return 0;
272 if ((grp_goal >= 0) && ((grp_goal + group_first_block < rsv->_rsv_start)
273 || (grp_goal + group_first_block > rsv->_rsv_end)))
274 return 0;
275 return 1;
276}
277
278
279
280
281
282
283
284
285
286
287static struct ext3_reserve_window_node *
288search_reserve_window(struct rb_root *root, ext3_fsblk_t goal)
289{
290 struct rb_node *n = root->rb_node;
291 struct ext3_reserve_window_node *rsv;
292
293 if (!n)
294 return NULL;
295
296 do {
297 rsv = rb_entry(n, struct ext3_reserve_window_node, rsv_node);
298
299 if (goal < rsv->rsv_start)
300 n = n->rb_left;
301 else if (goal > rsv->rsv_end)
302 n = n->rb_right;
303 else
304 return rsv;
305 } while (n);
306
307
308
309
310
311
312 if (rsv->rsv_start > goal) {
313 n = rb_prev(&rsv->rsv_node);
314 rsv = rb_entry(n, struct ext3_reserve_window_node, rsv_node);
315 }
316 return rsv;
317}
318
319
320
321
322
323
324
325
326void ext3_rsv_window_add(struct super_block *sb,
327 struct ext3_reserve_window_node *rsv)
328{
329 struct rb_root *root = &EXT3_SB(sb)->s_rsv_window_root;
330 struct rb_node *node = &rsv->rsv_node;
331 ext3_fsblk_t start = rsv->rsv_start;
332
333 struct rb_node ** p = &root->rb_node;
334 struct rb_node * parent = NULL;
335 struct ext3_reserve_window_node *this;
336
337 while (*p)
338 {
339 parent = *p;
340 this = rb_entry(parent, struct ext3_reserve_window_node, rsv_node);
341
342 if (start < this->rsv_start)
343 p = &(*p)->rb_left;
344 else if (start > this->rsv_end)
345 p = &(*p)->rb_right;
346 else {
347 rsv_window_dump(root, 1);
348 BUG();
349 }
350 }
351
352 rb_link_node(node, parent, p);
353 rb_insert_color(node, root);
354}
355
356
357
358
359
360
361
362
363
364
365static void rsv_window_remove(struct super_block *sb,
366 struct ext3_reserve_window_node *rsv)
367{
368 rsv->rsv_start = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
369 rsv->rsv_end = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
370 rsv->rsv_alloc_hit = 0;
371 rb_erase(&rsv->rsv_node, &EXT3_SB(sb)->s_rsv_window_root);
372}
373
374
375
376
377
378
379
380static inline int rsv_is_empty(struct ext3_reserve_window *rsv)
381{
382
383 return rsv->_rsv_end == EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
384}
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407void ext3_init_block_alloc_info(struct inode *inode)
408{
409 struct ext3_inode_info *ei = EXT3_I(inode);
410 struct ext3_block_alloc_info *block_i = ei->i_block_alloc_info;
411 struct super_block *sb = inode->i_sb;
412
413 block_i = kmalloc(sizeof(*block_i), GFP_NOFS);
414 if (block_i) {
415 struct ext3_reserve_window_node *rsv = &block_i->rsv_window_node;
416
417 rsv->rsv_start = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
418 rsv->rsv_end = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
419
420
421
422
423
424
425 if (!test_opt(sb, RESERVATION))
426 rsv->rsv_goal_size = 0;
427 else
428 rsv->rsv_goal_size = EXT3_DEFAULT_RESERVE_BLOCKS;
429 rsv->rsv_alloc_hit = 0;
430 block_i->last_alloc_logical_block = 0;
431 block_i->last_alloc_physical_block = 0;
432 }
433 ei->i_block_alloc_info = block_i;
434}
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449void ext3_discard_reservation(struct inode *inode)
450{
451 struct ext3_inode_info *ei = EXT3_I(inode);
452 struct ext3_block_alloc_info *block_i = ei->i_block_alloc_info;
453 struct ext3_reserve_window_node *rsv;
454 spinlock_t *rsv_lock = &EXT3_SB(inode->i_sb)->s_rsv_window_lock;
455
456 if (!block_i)
457 return;
458
459 rsv = &block_i->rsv_window_node;
460 if (!rsv_is_empty(&rsv->rsv_window)) {
461 spin_lock(rsv_lock);
462 if (!rsv_is_empty(&rsv->rsv_window))
463 rsv_window_remove(inode->i_sb, rsv);
464 spin_unlock(rsv_lock);
465 }
466}
467
468
469
470
471
472
473
474
475
476void ext3_free_blocks_sb(handle_t *handle, struct super_block *sb,
477 ext3_fsblk_t block, unsigned long count,
478 unsigned long *pdquot_freed_blocks)
479{
480 struct buffer_head *bitmap_bh = NULL;
481 struct buffer_head *gd_bh;
482 unsigned long block_group;
483 ext3_grpblk_t bit;
484 unsigned long i;
485 unsigned long overflow;
486 struct ext3_group_desc * desc;
487 struct ext3_super_block * es;
488 struct ext3_sb_info *sbi;
489 int err = 0, ret;
490 ext3_grpblk_t group_freed;
491
492 *pdquot_freed_blocks = 0;
493 sbi = EXT3_SB(sb);
494 es = sbi->s_es;
495 if (block < le32_to_cpu(es->s_first_data_block) ||
496 block + count < block ||
497 block + count > le32_to_cpu(es->s_blocks_count)) {
498 ext3_error (sb, "ext3_free_blocks",
499 "Freeing blocks not in datazone - "
500 "block = "E3FSBLK", count = %lu", block, count);
501 goto error_return;
502 }
503
504 ext3_debug ("freeing block(s) %lu-%lu\n", block, block + count - 1);
505
506do_more:
507 overflow = 0;
508 block_group = (block - le32_to_cpu(es->s_first_data_block)) /
509 EXT3_BLOCKS_PER_GROUP(sb);
510 bit = (block - le32_to_cpu(es->s_first_data_block)) %
511 EXT3_BLOCKS_PER_GROUP(sb);
512
513
514
515
516 if (bit + count > EXT3_BLOCKS_PER_GROUP(sb)) {
517 overflow = bit + count - EXT3_BLOCKS_PER_GROUP(sb);
518 count -= overflow;
519 }
520 brelse(bitmap_bh);
521 bitmap_bh = read_block_bitmap(sb, block_group);
522 if (!bitmap_bh)
523 goto error_return;
524 desc = ext3_get_group_desc (sb, block_group, &gd_bh);
525 if (!desc)
526 goto error_return;
527
528 if (in_range (le32_to_cpu(desc->bg_block_bitmap), block, count) ||
529 in_range (le32_to_cpu(desc->bg_inode_bitmap), block, count) ||
530 in_range (block, le32_to_cpu(desc->bg_inode_table),
531 sbi->s_itb_per_group) ||
532 in_range (block + count - 1, le32_to_cpu(desc->bg_inode_table),
533 sbi->s_itb_per_group)) {
534 ext3_error (sb, "ext3_free_blocks",
535 "Freeing blocks in system zones - "
536 "Block = "E3FSBLK", count = %lu",
537 block, count);
538 goto error_return;
539 }
540
541
542
543
544
545
546 BUFFER_TRACE(bitmap_bh, "getting undo access");
547 err = ext3_journal_get_undo_access(handle, bitmap_bh);
548 if (err)
549 goto error_return;
550
551
552
553
554
555
556 BUFFER_TRACE(gd_bh, "get_write_access");
557 err = ext3_journal_get_write_access(handle, gd_bh);
558 if (err)
559 goto error_return;
560
561 jbd_lock_bh_state(bitmap_bh);
562
563 for (i = 0, group_freed = 0; i < count; i++) {
564
565
566
567#ifdef CONFIG_JBD_DEBUG
568 jbd_unlock_bh_state(bitmap_bh);
569 {
570 struct buffer_head *debug_bh;
571 debug_bh = sb_find_get_block(sb, block + i);
572 if (debug_bh) {
573 BUFFER_TRACE(debug_bh, "Deleted!");
574 if (!bh2jh(bitmap_bh)->b_committed_data)
575 BUFFER_TRACE(debug_bh,
576 "No commited data in bitmap");
577 BUFFER_TRACE2(debug_bh, bitmap_bh, "bitmap");
578 __brelse(debug_bh);
579 }
580 }
581 jbd_lock_bh_state(bitmap_bh);
582#endif
583 if (need_resched()) {
584 jbd_unlock_bh_state(bitmap_bh);
585 cond_resched();
586 jbd_lock_bh_state(bitmap_bh);
587 }
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606 BUFFER_TRACE(bitmap_bh, "set in b_committed_data");
607 J_ASSERT_BH(bitmap_bh,
608 bh2jh(bitmap_bh)->b_committed_data != NULL);
609 ext3_set_bit_atomic(sb_bgl_lock(sbi, block_group), bit + i,
610 bh2jh(bitmap_bh)->b_committed_data);
611
612
613
614
615
616
617 BUFFER_TRACE(bitmap_bh, "clear bit");
618 if (!ext3_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
619 bit + i, bitmap_bh->b_data)) {
620 jbd_unlock_bh_state(bitmap_bh);
621 ext3_error(sb, __func__,
622 "bit already cleared for block "E3FSBLK,
623 block + i);
624 jbd_lock_bh_state(bitmap_bh);
625 BUFFER_TRACE(bitmap_bh, "bit already cleared");
626 } else {
627 group_freed++;
628 }
629 }
630 jbd_unlock_bh_state(bitmap_bh);
631
632 spin_lock(sb_bgl_lock(sbi, block_group));
633 le16_add_cpu(&desc->bg_free_blocks_count, group_freed);
634 spin_unlock(sb_bgl_lock(sbi, block_group));
635 percpu_counter_add(&sbi->s_freeblocks_counter, count);
636
637
638 BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
639 err = ext3_journal_dirty_metadata(handle, bitmap_bh);
640
641
642 BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
643 ret = ext3_journal_dirty_metadata(handle, gd_bh);
644 if (!err) err = ret;
645 *pdquot_freed_blocks += group_freed;
646
647 if (overflow && !err) {
648 block += count;
649 count = overflow;
650 goto do_more;
651 }
652
653error_return:
654 brelse(bitmap_bh);
655 ext3_std_error(sb, err);
656 return;
657}
658
659
660
661
662
663
664
665
666void ext3_free_blocks(handle_t *handle, struct inode *inode,
667 ext3_fsblk_t block, unsigned long count)
668{
669 struct super_block * sb;
670 unsigned long dquot_freed_blocks;
671
672 sb = inode->i_sb;
673 if (!sb) {
674 printk ("ext3_free_blocks: nonexistent device");
675 return;
676 }
677 ext3_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks);
678 if (dquot_freed_blocks)
679 vfs_dq_free_block(inode, dquot_freed_blocks);
680 return;
681}
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703static int ext3_test_allocatable(ext3_grpblk_t nr, struct buffer_head *bh)
704{
705 int ret;
706 struct journal_head *jh = bh2jh(bh);
707
708 if (ext3_test_bit(nr, bh->b_data))
709 return 0;
710
711 jbd_lock_bh_state(bh);
712 if (!jh->b_committed_data)
713 ret = 1;
714 else
715 ret = !ext3_test_bit(nr, jh->b_committed_data);
716 jbd_unlock_bh_state(bh);
717 return ret;
718}
719
720
721
722
723
724
725
726
727
728
729
730static ext3_grpblk_t
731bitmap_search_next_usable_block(ext3_grpblk_t start, struct buffer_head *bh,
732 ext3_grpblk_t maxblocks)
733{
734 ext3_grpblk_t next;
735 struct journal_head *jh = bh2jh(bh);
736
737 while (start < maxblocks) {
738 next = ext3_find_next_zero_bit(bh->b_data, maxblocks, start);
739 if (next >= maxblocks)
740 return -1;
741 if (ext3_test_allocatable(next, bh))
742 return next;
743 jbd_lock_bh_state(bh);
744 if (jh->b_committed_data)
745 start = ext3_find_next_zero_bit(jh->b_committed_data,
746 maxblocks, next);
747 jbd_unlock_bh_state(bh);
748 }
749 return -1;
750}
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765static ext3_grpblk_t
766find_next_usable_block(ext3_grpblk_t start, struct buffer_head *bh,
767 ext3_grpblk_t maxblocks)
768{
769 ext3_grpblk_t here, next;
770 char *p, *r;
771
772 if (start > 0) {
773
774
775
776
777
778
779
780
781 ext3_grpblk_t end_goal = (start + 63) & ~63;
782 if (end_goal > maxblocks)
783 end_goal = maxblocks;
784 here = ext3_find_next_zero_bit(bh->b_data, end_goal, start);
785 if (here < end_goal && ext3_test_allocatable(here, bh))
786 return here;
787 ext3_debug("Bit not found near goal\n");
788 }
789
790 here = start;
791 if (here < 0)
792 here = 0;
793
794 p = ((char *)bh->b_data) + (here >> 3);
795 r = memscan(p, 0, ((maxblocks + 7) >> 3) - (here >> 3));
796 next = (r - ((char *)bh->b_data)) << 3;
797
798 if (next < maxblocks && next >= start && ext3_test_allocatable(next, bh))
799 return next;
800
801
802
803
804
805
806 here = bitmap_search_next_usable_block(here, bh, maxblocks);
807 return here;
808}
809
810
811
812
813
814
815
816
817
818
819
820
821static inline int
822claim_block(spinlock_t *lock, ext3_grpblk_t block, struct buffer_head *bh)
823{
824 struct journal_head *jh = bh2jh(bh);
825 int ret;
826
827 if (ext3_set_bit_atomic(lock, block, bh->b_data))
828 return 0;
829 jbd_lock_bh_state(bh);
830 if (jh->b_committed_data && ext3_test_bit(block,jh->b_committed_data)) {
831 ext3_clear_bit_atomic(lock, block, bh->b_data);
832 ret = 0;
833 } else {
834 ret = 1;
835 }
836 jbd_unlock_bh_state(bh);
837 return ret;
838}
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864static ext3_grpblk_t
865ext3_try_to_allocate(struct super_block *sb, handle_t *handle, int group,
866 struct buffer_head *bitmap_bh, ext3_grpblk_t grp_goal,
867 unsigned long *count, struct ext3_reserve_window *my_rsv)
868{
869 ext3_fsblk_t group_first_block;
870 ext3_grpblk_t start, end;
871 unsigned long num = 0;
872
873
874 if (my_rsv) {
875 group_first_block = ext3_group_first_block_no(sb, group);
876 if (my_rsv->_rsv_start >= group_first_block)
877 start = my_rsv->_rsv_start - group_first_block;
878 else
879
880 start = 0;
881 end = my_rsv->_rsv_end - group_first_block + 1;
882 if (end > EXT3_BLOCKS_PER_GROUP(sb))
883
884 end = EXT3_BLOCKS_PER_GROUP(sb);
885 if ((start <= grp_goal) && (grp_goal < end))
886 start = grp_goal;
887 else
888 grp_goal = -1;
889 } else {
890 if (grp_goal > 0)
891 start = grp_goal;
892 else
893 start = 0;
894 end = EXT3_BLOCKS_PER_GROUP(sb);
895 }
896
897 BUG_ON(start > EXT3_BLOCKS_PER_GROUP(sb));
898
899repeat:
900 if (grp_goal < 0 || !ext3_test_allocatable(grp_goal, bitmap_bh)) {
901 grp_goal = find_next_usable_block(start, bitmap_bh, end);
902 if (grp_goal < 0)
903 goto fail_access;
904 if (!my_rsv) {
905 int i;
906
907 for (i = 0; i < 7 && grp_goal > start &&
908 ext3_test_allocatable(grp_goal - 1,
909 bitmap_bh);
910 i++, grp_goal--)
911 ;
912 }
913 }
914 start = grp_goal;
915
916 if (!claim_block(sb_bgl_lock(EXT3_SB(sb), group),
917 grp_goal, bitmap_bh)) {
918
919
920
921
922 start++;
923 grp_goal++;
924 if (start >= end)
925 goto fail_access;
926 goto repeat;
927 }
928 num++;
929 grp_goal++;
930 while (num < *count && grp_goal < end
931 && ext3_test_allocatable(grp_goal, bitmap_bh)
932 && claim_block(sb_bgl_lock(EXT3_SB(sb), group),
933 grp_goal, bitmap_bh)) {
934 num++;
935 grp_goal++;
936 }
937 *count = num;
938 return grp_goal - num;
939fail_access:
940 *count = num;
941 return -1;
942}
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977static int find_next_reservable_window(
978 struct ext3_reserve_window_node *search_head,
979 struct ext3_reserve_window_node *my_rsv,
980 struct super_block * sb,
981 ext3_fsblk_t start_block,
982 ext3_fsblk_t last_block)
983{
984 struct rb_node *next;
985 struct ext3_reserve_window_node *rsv, *prev;
986 ext3_fsblk_t cur;
987 int size = my_rsv->rsv_goal_size;
988
989
990
991 cur = start_block;
992 rsv = search_head;
993 if (!rsv)
994 return -1;
995
996 while (1) {
997 if (cur <= rsv->rsv_end)
998 cur = rsv->rsv_end + 1;
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009 if (cur > last_block)
1010 return -1;
1011
1012 prev = rsv;
1013 next = rb_next(&rsv->rsv_node);
1014 rsv = rb_entry(next,struct ext3_reserve_window_node,rsv_node);
1015
1016
1017
1018
1019
1020 if (!next)
1021 break;
1022
1023 if (cur + size <= rsv->rsv_start) {
1024
1025
1026
1027
1028 break;
1029 }
1030 }
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042 if ((prev != my_rsv) && (!rsv_is_empty(&my_rsv->rsv_window)))
1043 rsv_window_remove(sb, my_rsv);
1044
1045
1046
1047
1048
1049
1050
1051
1052 my_rsv->rsv_start = cur;
1053 my_rsv->rsv_end = cur + size - 1;
1054 my_rsv->rsv_alloc_hit = 0;
1055
1056 if (prev != my_rsv)
1057 ext3_rsv_window_add(sb, my_rsv);
1058
1059 return 0;
1060}
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099static int alloc_new_reservation(struct ext3_reserve_window_node *my_rsv,
1100 ext3_grpblk_t grp_goal, struct super_block *sb,
1101 unsigned int group, struct buffer_head *bitmap_bh)
1102{
1103 struct ext3_reserve_window_node *search_head;
1104 ext3_fsblk_t group_first_block, group_end_block, start_block;
1105 ext3_grpblk_t first_free_block;
1106 struct rb_root *fs_rsv_root = &EXT3_SB(sb)->s_rsv_window_root;
1107 unsigned long size;
1108 int ret;
1109 spinlock_t *rsv_lock = &EXT3_SB(sb)->s_rsv_window_lock;
1110
1111 group_first_block = ext3_group_first_block_no(sb, group);
1112 group_end_block = group_first_block + (EXT3_BLOCKS_PER_GROUP(sb) - 1);
1113
1114 if (grp_goal < 0)
1115 start_block = group_first_block;
1116 else
1117 start_block = grp_goal + group_first_block;
1118
1119 size = my_rsv->rsv_goal_size;
1120
1121 if (!rsv_is_empty(&my_rsv->rsv_window)) {
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136 if ((my_rsv->rsv_start <= group_end_block) &&
1137 (my_rsv->rsv_end > group_end_block) &&
1138 (start_block >= my_rsv->rsv_start))
1139 return -1;
1140
1141 if ((my_rsv->rsv_alloc_hit >
1142 (my_rsv->rsv_end - my_rsv->rsv_start + 1) / 2)) {
1143
1144
1145
1146
1147
1148
1149 size = size * 2;
1150 if (size > EXT3_MAX_RESERVE_BLOCKS)
1151 size = EXT3_MAX_RESERVE_BLOCKS;
1152 my_rsv->rsv_goal_size= size;
1153 }
1154 }
1155
1156 spin_lock(rsv_lock);
1157
1158
1159
1160 search_head = search_reserve_window(fs_rsv_root, start_block);
1161
1162
1163
1164
1165
1166
1167
1168
1169retry:
1170 ret = find_next_reservable_window(search_head, my_rsv, sb,
1171 start_block, group_end_block);
1172
1173 if (ret == -1) {
1174 if (!rsv_is_empty(&my_rsv->rsv_window))
1175 rsv_window_remove(sb, my_rsv);
1176 spin_unlock(rsv_lock);
1177 return -1;
1178 }
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191 spin_unlock(rsv_lock);
1192 first_free_block = bitmap_search_next_usable_block(
1193 my_rsv->rsv_start - group_first_block,
1194 bitmap_bh, group_end_block - group_first_block + 1);
1195
1196 if (first_free_block < 0) {
1197
1198
1199
1200
1201 spin_lock(rsv_lock);
1202 if (!rsv_is_empty(&my_rsv->rsv_window))
1203 rsv_window_remove(sb, my_rsv);
1204 spin_unlock(rsv_lock);
1205 return -1;
1206 }
1207
1208 start_block = first_free_block + group_first_block;
1209
1210
1211
1212
1213 if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
1214 return 0;
1215
1216
1217
1218
1219
1220
1221 search_head = my_rsv;
1222 spin_lock(rsv_lock);
1223 goto retry;
1224}
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243static void try_to_extend_reservation(struct ext3_reserve_window_node *my_rsv,
1244 struct super_block *sb, int size)
1245{
1246 struct ext3_reserve_window_node *next_rsv;
1247 struct rb_node *next;
1248 spinlock_t *rsv_lock = &EXT3_SB(sb)->s_rsv_window_lock;
1249
1250 if (!spin_trylock(rsv_lock))
1251 return;
1252
1253 next = rb_next(&my_rsv->rsv_node);
1254
1255 if (!next)
1256 my_rsv->rsv_end += size;
1257 else {
1258 next_rsv = rb_entry(next, struct ext3_reserve_window_node, rsv_node);
1259
1260 if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
1261 my_rsv->rsv_end += size;
1262 else
1263 my_rsv->rsv_end = next_rsv->rsv_start - 1;
1264 }
1265 spin_unlock(rsv_lock);
1266}
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297static ext3_grpblk_t
1298ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
1299 unsigned int group, struct buffer_head *bitmap_bh,
1300 ext3_grpblk_t grp_goal,
1301 struct ext3_reserve_window_node * my_rsv,
1302 unsigned long *count, int *errp)
1303{
1304 ext3_fsblk_t group_first_block, group_last_block;
1305 ext3_grpblk_t ret = 0;
1306 int fatal;
1307 unsigned long num = *count;
1308
1309 *errp = 0;
1310
1311
1312
1313
1314
1315
1316 BUFFER_TRACE(bitmap_bh, "get undo access for new block");
1317 fatal = ext3_journal_get_undo_access(handle, bitmap_bh);
1318 if (fatal) {
1319 *errp = fatal;
1320 return -1;
1321 }
1322
1323
1324
1325
1326
1327
1328
1329 if (my_rsv == NULL ) {
1330 ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh,
1331 grp_goal, count, NULL);
1332 goto out;
1333 }
1334
1335
1336
1337
1338
1339
1340 group_first_block = ext3_group_first_block_no(sb, group);
1341 group_last_block = group_first_block + (EXT3_BLOCKS_PER_GROUP(sb) - 1);
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358 while (1) {
1359 if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
1360 !goal_in_my_reservation(&my_rsv->rsv_window,
1361 grp_goal, group, sb)) {
1362 if (my_rsv->rsv_goal_size < *count)
1363 my_rsv->rsv_goal_size = *count;
1364 ret = alloc_new_reservation(my_rsv, grp_goal, sb,
1365 group, bitmap_bh);
1366 if (ret < 0)
1367 break;
1368
1369 if (!goal_in_my_reservation(&my_rsv->rsv_window,
1370 grp_goal, group, sb))
1371 grp_goal = -1;
1372 } else if (grp_goal >= 0) {
1373 int curr = my_rsv->rsv_end -
1374 (grp_goal + group_first_block) + 1;
1375
1376 if (curr < *count)
1377 try_to_extend_reservation(my_rsv, sb,
1378 *count - curr);
1379 }
1380
1381 if ((my_rsv->rsv_start > group_last_block) ||
1382 (my_rsv->rsv_end < group_first_block)) {
1383 rsv_window_dump(&EXT3_SB(sb)->s_rsv_window_root, 1);
1384 BUG();
1385 }
1386 ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh,
1387 grp_goal, &num, &my_rsv->rsv_window);
1388 if (ret >= 0) {
1389 my_rsv->rsv_alloc_hit += num;
1390 *count = num;
1391 break;
1392 }
1393 num = *count;
1394 }
1395out:
1396 if (ret >= 0) {
1397 BUFFER_TRACE(bitmap_bh, "journal_dirty_metadata for "
1398 "bitmap block");
1399 fatal = ext3_journal_dirty_metadata(handle, bitmap_bh);
1400 if (fatal) {
1401 *errp = fatal;
1402 return -1;
1403 }
1404 return ret;
1405 }
1406
1407 BUFFER_TRACE(bitmap_bh, "journal_release_buffer");
1408 ext3_journal_release_buffer(handle, bitmap_bh);
1409 return ret;
1410}
1411
1412
1413
1414
1415
1416
1417
1418static int ext3_has_free_blocks(struct ext3_sb_info *sbi)
1419{
1420 ext3_fsblk_t free_blocks, root_blocks;
1421
1422 free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
1423 root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
1424 if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
1425 sbi->s_resuid != current_fsuid() &&
1426 (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
1427 return 0;
1428 }
1429 return 1;
1430}
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444int ext3_should_retry_alloc(struct super_block *sb, int *retries)
1445{
1446 if (!ext3_has_free_blocks(EXT3_SB(sb)) || (*retries)++ > 3)
1447 return 0;
1448
1449 jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
1450
1451 return journal_force_commit_nested(EXT3_SB(sb)->s_journal);
1452}
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
1469 ext3_fsblk_t goal, unsigned long *count, int *errp)
1470{
1471 struct buffer_head *bitmap_bh = NULL;
1472 struct buffer_head *gdp_bh;
1473 int group_no;
1474 int goal_group;
1475 ext3_grpblk_t grp_target_blk;
1476 ext3_grpblk_t grp_alloc_blk;
1477 ext3_fsblk_t ret_block;
1478 int bgi;
1479 int fatal = 0, err;
1480 int performed_allocation = 0;
1481 ext3_grpblk_t free_blocks;
1482 struct super_block *sb;
1483 struct ext3_group_desc *gdp;
1484 struct ext3_super_block *es;
1485 struct ext3_sb_info *sbi;
1486 struct ext3_reserve_window_node *my_rsv = NULL;
1487 struct ext3_block_alloc_info *block_i;
1488 unsigned short windowsz = 0;
1489#ifdef EXT3FS_DEBUG
1490 static int goal_hits, goal_attempts;
1491#endif
1492 unsigned long ngroups;
1493 unsigned long num = *count;
1494
1495 *errp = -ENOSPC;
1496 sb = inode->i_sb;
1497 if (!sb) {
1498 printk("ext3_new_block: nonexistent device");
1499 return 0;
1500 }
1501
1502
1503
1504
1505 if (vfs_dq_alloc_block(inode, num)) {
1506 *errp = -EDQUOT;
1507 return 0;
1508 }
1509
1510 sbi = EXT3_SB(sb);
1511 es = EXT3_SB(sb)->s_es;
1512 ext3_debug("goal=%lu.\n", goal);
1513
1514
1515
1516
1517
1518
1519
1520
1521 block_i = EXT3_I(inode)->i_block_alloc_info;
1522 if (block_i && ((windowsz = block_i->rsv_window_node.rsv_goal_size) > 0))
1523 my_rsv = &block_i->rsv_window_node;
1524
1525 if (!ext3_has_free_blocks(sbi)) {
1526 *errp = -ENOSPC;
1527 goto out;
1528 }
1529
1530
1531
1532
1533 if (goal < le32_to_cpu(es->s_first_data_block) ||
1534 goal >= le32_to_cpu(es->s_blocks_count))
1535 goal = le32_to_cpu(es->s_first_data_block);
1536 group_no = (goal - le32_to_cpu(es->s_first_data_block)) /
1537 EXT3_BLOCKS_PER_GROUP(sb);
1538 goal_group = group_no;
1539retry_alloc:
1540 gdp = ext3_get_group_desc(sb, group_no, &gdp_bh);
1541 if (!gdp)
1542 goto io_error;
1543
1544 free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
1545
1546
1547
1548
1549 if (my_rsv && (free_blocks < windowsz)
1550 && (free_blocks > 0)
1551 && (rsv_is_empty(&my_rsv->rsv_window)))
1552 my_rsv = NULL;
1553
1554 if (free_blocks > 0) {
1555 grp_target_blk = ((goal - le32_to_cpu(es->s_first_data_block)) %
1556 EXT3_BLOCKS_PER_GROUP(sb));
1557 bitmap_bh = read_block_bitmap(sb, group_no);
1558 if (!bitmap_bh)
1559 goto io_error;
1560 grp_alloc_blk = ext3_try_to_allocate_with_rsv(sb, handle,
1561 group_no, bitmap_bh, grp_target_blk,
1562 my_rsv, &num, &fatal);
1563 if (fatal)
1564 goto out;
1565 if (grp_alloc_blk >= 0)
1566 goto allocated;
1567 }
1568
1569 ngroups = EXT3_SB(sb)->s_groups_count;
1570 smp_rmb();
1571
1572
1573
1574
1575
1576 for (bgi = 0; bgi < ngroups; bgi++) {
1577 group_no++;
1578 if (group_no >= ngroups)
1579 group_no = 0;
1580 gdp = ext3_get_group_desc(sb, group_no, &gdp_bh);
1581 if (!gdp)
1582 goto io_error;
1583 free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
1584
1585
1586
1587
1588
1589 if (my_rsv && (free_blocks <= (windowsz/2)))
1590 continue;
1591
1592 brelse(bitmap_bh);
1593 bitmap_bh = read_block_bitmap(sb, group_no);
1594 if (!bitmap_bh)
1595 goto io_error;
1596
1597
1598
1599 grp_alloc_blk = ext3_try_to_allocate_with_rsv(sb, handle,
1600 group_no, bitmap_bh, -1, my_rsv,
1601 &num, &fatal);
1602 if (fatal)
1603 goto out;
1604 if (grp_alloc_blk >= 0)
1605 goto allocated;
1606 }
1607
1608
1609
1610
1611
1612
1613
1614 if (my_rsv) {
1615 my_rsv = NULL;
1616 windowsz = 0;
1617 group_no = goal_group;
1618 goto retry_alloc;
1619 }
1620
1621 *errp = -ENOSPC;
1622 goto out;
1623
1624allocated:
1625
1626 ext3_debug("using block group %d(%d)\n",
1627 group_no, gdp->bg_free_blocks_count);
1628
1629 BUFFER_TRACE(gdp_bh, "get_write_access");
1630 fatal = ext3_journal_get_write_access(handle, gdp_bh);
1631 if (fatal)
1632 goto out;
1633
1634 ret_block = grp_alloc_blk + ext3_group_first_block_no(sb, group_no);
1635
1636 if (in_range(le32_to_cpu(gdp->bg_block_bitmap), ret_block, num) ||
1637 in_range(le32_to_cpu(gdp->bg_inode_bitmap), ret_block, num) ||
1638 in_range(ret_block, le32_to_cpu(gdp->bg_inode_table),
1639 EXT3_SB(sb)->s_itb_per_group) ||
1640 in_range(ret_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
1641 EXT3_SB(sb)->s_itb_per_group)) {
1642 ext3_error(sb, "ext3_new_block",
1643 "Allocating block in system zone - "
1644 "blocks from "E3FSBLK", length %lu",
1645 ret_block, num);
1646
1647
1648
1649
1650 goto retry_alloc;
1651 }
1652
1653 performed_allocation = 1;
1654
1655#ifdef CONFIG_JBD_DEBUG
1656 {
1657 struct buffer_head *debug_bh;
1658
1659
1660 debug_bh = sb_find_get_block(sb, ret_block);
1661 if (debug_bh) {
1662 BUFFER_TRACE(debug_bh, "state when allocated");
1663 BUFFER_TRACE2(debug_bh, bitmap_bh, "bitmap state");
1664 brelse(debug_bh);
1665 }
1666 }
1667 jbd_lock_bh_state(bitmap_bh);
1668 spin_lock(sb_bgl_lock(sbi, group_no));
1669 if (buffer_jbd(bitmap_bh) && bh2jh(bitmap_bh)->b_committed_data) {
1670 int i;
1671
1672 for (i = 0; i < num; i++) {
1673 if (ext3_test_bit(grp_alloc_blk+i,
1674 bh2jh(bitmap_bh)->b_committed_data)) {
1675 printk("%s: block was unexpectedly set in "
1676 "b_committed_data\n", __func__);
1677 }
1678 }
1679 }
1680 ext3_debug("found bit %d\n", grp_alloc_blk);
1681 spin_unlock(sb_bgl_lock(sbi, group_no));
1682 jbd_unlock_bh_state(bitmap_bh);
1683#endif
1684
1685 if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
1686 ext3_error(sb, "ext3_new_block",
1687 "block("E3FSBLK") >= blocks count(%d) - "
1688 "block_group = %d, es == %p ", ret_block,
1689 le32_to_cpu(es->s_blocks_count), group_no, es);
1690 goto out;
1691 }
1692
1693
1694
1695
1696
1697
1698 ext3_debug("allocating block %lu. Goal hits %d of %d.\n",
1699 ret_block, goal_hits, goal_attempts);
1700
1701 spin_lock(sb_bgl_lock(sbi, group_no));
1702 le16_add_cpu(&gdp->bg_free_blocks_count, -num);
1703 spin_unlock(sb_bgl_lock(sbi, group_no));
1704 percpu_counter_sub(&sbi->s_freeblocks_counter, num);
1705
1706 BUFFER_TRACE(gdp_bh, "journal_dirty_metadata for group descriptor");
1707 err = ext3_journal_dirty_metadata(handle, gdp_bh);
1708 if (!fatal)
1709 fatal = err;
1710
1711 if (fatal)
1712 goto out;
1713
1714 *errp = 0;
1715 brelse(bitmap_bh);
1716 vfs_dq_free_block(inode, *count-num);
1717 *count = num;
1718 return ret_block;
1719
1720io_error:
1721 *errp = -EIO;
1722out:
1723 if (fatal) {
1724 *errp = fatal;
1725 ext3_std_error(sb, fatal);
1726 }
1727
1728
1729
1730 if (!performed_allocation)
1731 vfs_dq_free_block(inode, *count);
1732 brelse(bitmap_bh);
1733 return 0;
1734}
1735
1736ext3_fsblk_t ext3_new_block(handle_t *handle, struct inode *inode,
1737 ext3_fsblk_t goal, int *errp)
1738{
1739 unsigned long count = 1;
1740
1741 return ext3_new_blocks(handle, inode, goal, &count, errp);
1742}
1743
1744
1745
1746
1747
1748
1749
1750ext3_fsblk_t ext3_count_free_blocks(struct super_block *sb)
1751{
1752 ext3_fsblk_t desc_count;
1753 struct ext3_group_desc *gdp;
1754 int i;
1755 unsigned long ngroups = EXT3_SB(sb)->s_groups_count;
1756#ifdef EXT3FS_DEBUG
1757 struct ext3_super_block *es;
1758 ext3_fsblk_t bitmap_count;
1759 unsigned long x;
1760 struct buffer_head *bitmap_bh = NULL;
1761
1762 es = EXT3_SB(sb)->s_es;
1763 desc_count = 0;
1764 bitmap_count = 0;
1765 gdp = NULL;
1766
1767 smp_rmb();
1768 for (i = 0; i < ngroups; i++) {
1769 gdp = ext3_get_group_desc(sb, i, NULL);
1770 if (!gdp)
1771 continue;
1772 desc_count += le16_to_cpu(gdp->bg_free_blocks_count);
1773 brelse(bitmap_bh);
1774 bitmap_bh = read_block_bitmap(sb, i);
1775 if (bitmap_bh == NULL)
1776 continue;
1777
1778 x = ext3_count_free(bitmap_bh, sb->s_blocksize);
1779 printk("group %d: stored = %d, counted = %lu\n",
1780 i, le16_to_cpu(gdp->bg_free_blocks_count), x);
1781 bitmap_count += x;
1782 }
1783 brelse(bitmap_bh);
1784 printk("ext3_count_free_blocks: stored = "E3FSBLK
1785 ", computed = "E3FSBLK", "E3FSBLK"\n",
1786 le32_to_cpu(es->s_free_blocks_count),
1787 desc_count, bitmap_count);
1788 return bitmap_count;
1789#else
1790 desc_count = 0;
1791 smp_rmb();
1792 for (i = 0; i < ngroups; i++) {
1793 gdp = ext3_get_group_desc(sb, i, NULL);
1794 if (!gdp)
1795 continue;
1796 desc_count += le16_to_cpu(gdp->bg_free_blocks_count);
1797 }
1798
1799 return desc_count;
1800#endif
1801}
1802
1803static inline int test_root(int a, int b)
1804{
1805 int num = b;
1806
1807 while (a > num)
1808 num *= b;
1809 return num == a;
1810}
1811
1812static int ext3_group_sparse(int group)
1813{
1814 if (group <= 1)
1815 return 1;
1816 if (!(group & 1))
1817 return 0;
1818 return (test_root(group, 7) || test_root(group, 5) ||
1819 test_root(group, 3));
1820}
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830int ext3_bg_has_super(struct super_block *sb, int group)
1831{
1832 if (EXT3_HAS_RO_COMPAT_FEATURE(sb,
1833 EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
1834 !ext3_group_sparse(group))
1835 return 0;
1836 return 1;
1837}
1838
1839static unsigned long ext3_bg_num_gdb_meta(struct super_block *sb, int group)
1840{
1841 unsigned long metagroup = group / EXT3_DESC_PER_BLOCK(sb);
1842 unsigned long first = metagroup * EXT3_DESC_PER_BLOCK(sb);
1843 unsigned long last = first + EXT3_DESC_PER_BLOCK(sb) - 1;
1844
1845 if (group == first || group == first + 1 || group == last)
1846 return 1;
1847 return 0;
1848}
1849
1850static unsigned long ext3_bg_num_gdb_nometa(struct super_block *sb, int group)
1851{
1852 return ext3_bg_has_super(sb, group) ? EXT3_SB(sb)->s_gdb_count : 0;
1853}
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864unsigned long ext3_bg_num_gdb(struct super_block *sb, int group)
1865{
1866 unsigned long first_meta_bg =
1867 le32_to_cpu(EXT3_SB(sb)->s_es->s_first_meta_bg);
1868 unsigned long metagroup = group / EXT3_DESC_PER_BLOCK(sb);
1869
1870 if (!EXT3_HAS_INCOMPAT_FEATURE(sb,EXT3_FEATURE_INCOMPAT_META_BG) ||
1871 metagroup < first_meta_bg)
1872 return ext3_bg_num_gdb_nometa(sb,group);
1873
1874 return ext3_bg_num_gdb_meta(sb,group);
1875
1876}
1877