Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
balloc.c
Go to the documentation of this file.
1 /*
2  * linux/fs/ext4/balloc.c
3  *
4  * Copyright (C) 1992, 1993, 1994, 1995
5  * Remy Card ([email protected])
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  *
9  * Enhanced block allocation by Stephen Tweedie ([email protected]), 1993
10  * Big-endian to little-endian byte-swapping/bitmaps by
11  * David S. Miller ([email protected]), 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,
28 /*
29  * balloc.c contains the blocks allocation and deallocation routines
30  */
31 
32 /*
33  * Calculate the block group number and offset into the block/cluster
34  * allocation bitmap, given a block number
35  */
37  ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)
38 {
39  struct ext4_super_block *es = EXT4_SB(sb)->s_es;
41 
42  blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
43  offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb)) >>
44  EXT4_SB(sb)->s_cluster_bits;
45  if (offsetp)
46  *offsetp = offset;
47  if (blockgrpp)
48  *blockgrpp = blocknr;
49 
50 }
51 
52 static int ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block,
54 {
55  ext4_group_t actual_group;
56  ext4_get_group_no_and_offset(sb, block, &actual_group, NULL);
57  if (actual_group == block_group)
58  return 1;
59  return 0;
60 }
61 
62 /* Return the number of clusters used for file system metadata; this
63  * represents the overhead needed by the file system.
64  */
66  ext4_group_t block_group,
67  struct ext4_group_desc *gdp)
68 {
69  unsigned num_clusters;
70  int block_cluster = -1, inode_cluster = -1, itbl_cluster = -1, i, c;
71  ext4_fsblk_t start = ext4_group_first_block_no(sb, block_group);
72  ext4_fsblk_t itbl_blk;
73  struct ext4_sb_info *sbi = EXT4_SB(sb);
74 
75  /* This is the number of clusters used by the superblock,
76  * block group descriptors, and reserved block group
77  * descriptor blocks */
78  num_clusters = ext4_num_base_meta_clusters(sb, block_group);
79 
80  /*
81  * For the allocation bitmaps and inode table, we first need
82  * to check to see if the block is in the block group. If it
83  * is, then check to see if the cluster is already accounted
84  * for in the clusters used for the base metadata cluster, or
85  * if we can increment the base metadata cluster to include
86  * that block. Otherwise, we will have to track the cluster
87  * used for the allocation bitmap or inode table explicitly.
88  * Normally all of these blocks are contiguous, so the special
89  * case handling shouldn't be necessary except for *very*
90  * unusual file system layouts.
91  */
92  if (ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), block_group)) {
93  block_cluster = EXT4_B2C(sbi,
94  ext4_block_bitmap(sb, gdp) - start);
95  if (block_cluster < num_clusters)
96  block_cluster = -1;
97  else if (block_cluster == num_clusters) {
98  num_clusters++;
99  block_cluster = -1;
100  }
101  }
102 
103  if (ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp), block_group)) {
104  inode_cluster = EXT4_B2C(sbi,
105  ext4_inode_bitmap(sb, gdp) - start);
106  if (inode_cluster < num_clusters)
107  inode_cluster = -1;
108  else if (inode_cluster == num_clusters) {
109  num_clusters++;
110  inode_cluster = -1;
111  }
112  }
113 
114  itbl_blk = ext4_inode_table(sb, gdp);
115  for (i = 0; i < sbi->s_itb_per_group; i++) {
116  if (ext4_block_in_group(sb, itbl_blk + i, block_group)) {
117  c = EXT4_B2C(sbi, itbl_blk + i - start);
118  if ((c < num_clusters) || (c == inode_cluster) ||
119  (c == block_cluster) || (c == itbl_cluster))
120  continue;
121  if (c == num_clusters) {
122  num_clusters++;
123  continue;
124  }
125  num_clusters++;
126  itbl_cluster = c;
127  }
128  }
129 
130  if (block_cluster != -1)
131  num_clusters++;
132  if (inode_cluster != -1)
133  num_clusters++;
134 
135  return num_clusters;
136 }
137 
138 static unsigned int num_clusters_in_group(struct super_block *sb,
139  ext4_group_t block_group)
140 {
141  unsigned int blocks;
142 
143  if (block_group == ext4_get_groups_count(sb) - 1) {
144  /*
145  * Even though mke2fs always initializes the first and
146  * last group, just in case some other tool was used,
147  * we need to make sure we calculate the right free
148  * blocks.
149  */
150  blocks = ext4_blocks_count(EXT4_SB(sb)->s_es) -
151  ext4_group_first_block_no(sb, block_group);
152  } else
153  blocks = EXT4_BLOCKS_PER_GROUP(sb);
154  return EXT4_NUM_B2C(EXT4_SB(sb), blocks);
155 }
156 
157 /* Initializes an uninitialized block bitmap */
158 void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
159  ext4_group_t block_group,
160  struct ext4_group_desc *gdp)
161 {
162  unsigned int bit, bit_max;
163  struct ext4_sb_info *sbi = EXT4_SB(sb);
165  int flex_bg = 0;
166 
167  J_ASSERT_BH(bh, buffer_locked(bh));
168 
169  /* If checksum is bad mark all blocks used to prevent allocation
170  * essentially implementing a per-group read-only flag. */
171  if (!ext4_group_desc_csum_verify(sb, block_group, gdp)) {
172  ext4_error(sb, "Checksum bad for group %u", block_group);
173  ext4_free_group_clusters_set(sb, gdp, 0);
174  ext4_free_inodes_set(sb, gdp, 0);
175  ext4_itable_unused_set(sb, gdp, 0);
176  memset(bh->b_data, 0xff, sb->s_blocksize);
177  ext4_block_bitmap_csum_set(sb, block_group, gdp, bh);
178  return;
179  }
180  memset(bh->b_data, 0, sb->s_blocksize);
181 
182  bit_max = ext4_num_base_meta_clusters(sb, block_group);
183  for (bit = 0; bit < bit_max; bit++)
184  ext4_set_bit(bit, bh->b_data);
185 
186  start = ext4_group_first_block_no(sb, block_group);
187 
189  flex_bg = 1;
190 
191  /* Set bits for block and inode bitmaps, and inode table */
192  tmp = ext4_block_bitmap(sb, gdp);
193  if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
194  ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
195 
196  tmp = ext4_inode_bitmap(sb, gdp);
197  if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
198  ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
199 
200  tmp = ext4_inode_table(sb, gdp);
201  for (; tmp < ext4_inode_table(sb, gdp) +
202  sbi->s_itb_per_group; tmp++) {
203  if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
204  ext4_set_bit(EXT4_B2C(sbi, tmp - start), bh->b_data);
205  }
206 
207  /*
208  * Also if the number of blocks within the group is less than
209  * the blocksize * 8 ( which is the size of bitmap ), set rest
210  * of the block bitmap to 1
211  */
212  ext4_mark_bitmap_end(num_clusters_in_group(sb, block_group),
213  sb->s_blocksize * 8, bh->b_data);
214  ext4_block_bitmap_csum_set(sb, block_group, gdp, bh);
215  ext4_group_desc_csum_set(sb, block_group, gdp);
216 }
217 
218 /* Return the number of free blocks in a block group. It is used when
219  * the block bitmap is uninitialized, so we can't just count the bits
220  * in the bitmap. */
222  ext4_group_t block_group,
223  struct ext4_group_desc *gdp)
224 {
225  return num_clusters_in_group(sb, block_group) -
226  ext4_num_overhead_clusters(sb, block_group, gdp);
227 }
228 
229 /*
230  * The free blocks are managed by bitmaps. A file system contains several
231  * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
232  * block for inodes, N blocks for the inode table and data blocks.
233  *
234  * The file system contains group descriptors which are located after the
235  * super block. Each descriptor contains the number of the bitmap block and
236  * the free blocks count in the block. The descriptors are loaded in memory
237  * when a file system is mounted (see ext4_fill_super).
238  */
239 
248  ext4_group_t block_group,
249  struct buffer_head **bh)
250 {
251  unsigned int group_desc;
252  unsigned int offset;
253  ext4_group_t ngroups = ext4_get_groups_count(sb);
254  struct ext4_group_desc *desc;
255  struct ext4_sb_info *sbi = EXT4_SB(sb);
256 
257  if (block_group >= ngroups) {
258  ext4_error(sb, "block_group >= groups_count - block_group = %u,"
259  " groups_count = %u", block_group, ngroups);
260 
261  return NULL;
262  }
263 
264  group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
265  offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
266  if (!sbi->s_group_desc[group_desc]) {
267  ext4_error(sb, "Group descriptor not loaded - "
268  "block_group = %u, group_desc = %u, desc = %u",
269  block_group, group_desc, offset);
270  return NULL;
271  }
272 
273  desc = (struct ext4_group_desc *)(
274  (__u8 *)sbi->s_group_desc[group_desc]->b_data +
275  offset * EXT4_DESC_SIZE(sb));
276  if (bh)
277  *bh = sbi->s_group_desc[group_desc];
278  return desc;
279 }
280 
281 /*
282  * Return the block number which was discovered to be invalid, or 0 if
283  * the block bitmap is valid.
284  */
285 static ext4_fsblk_t ext4_valid_block_bitmap(struct super_block *sb,
286  struct ext4_group_desc *desc,
287  unsigned int block_group,
288  struct buffer_head *bh)
289 {
291  ext4_grpblk_t next_zero_bit;
293  ext4_fsblk_t group_first_block;
294 
296  /* with FLEX_BG, the inode/block bitmaps and itable
297  * blocks may not be in the group at all
298  * so the bitmap validation will be skipped for those groups
299  * or it has to also read the block group where the bitmaps
300  * are located to verify they are set.
301  */
302  return 0;
303  }
304  group_first_block = ext4_group_first_block_no(sb, block_group);
305 
306  /* check whether block bitmap block number is set */
307  blk = ext4_block_bitmap(sb, desc);
308  offset = blk - group_first_block;
309  if (!ext4_test_bit(offset, bh->b_data))
310  /* bad block bitmap */
311  return blk;
312 
313  /* check whether the inode bitmap block number is set */
314  blk = ext4_inode_bitmap(sb, desc);
315  offset = blk - group_first_block;
316  if (!ext4_test_bit(offset, bh->b_data))
317  /* bad block bitmap */
318  return blk;
319 
320  /* check whether the inode table block number is set */
321  blk = ext4_inode_table(sb, desc);
322  offset = blk - group_first_block;
323  next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
324  offset + EXT4_SB(sb)->s_itb_per_group,
325  offset);
326  if (next_zero_bit < offset + EXT4_SB(sb)->s_itb_per_group)
327  /* bad bitmap for inode tables */
328  return blk;
329  return 0;
330 }
331 
333  struct ext4_group_desc *desc,
334  unsigned int block_group,
335  struct buffer_head *bh)
336 {
338 
339  if (buffer_verified(bh))
340  return;
341 
342  ext4_lock_group(sb, block_group);
343  blk = ext4_valid_block_bitmap(sb, desc, block_group, bh);
344  if (unlikely(blk != 0)) {
345  ext4_unlock_group(sb, block_group);
346  ext4_error(sb, "bg %u: block %llu: invalid block bitmap",
347  block_group, blk);
348  return;
349  }
350  if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,
351  desc, bh))) {
352  ext4_unlock_group(sb, block_group);
353  ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);
354  return;
355  }
356  set_buffer_verified(bh);
357  ext4_unlock_group(sb, block_group);
358 }
359 
370 struct buffer_head *
372 {
373  struct ext4_group_desc *desc;
374  struct buffer_head *bh;
375  ext4_fsblk_t bitmap_blk;
376 
377  desc = ext4_get_group_desc(sb, block_group, NULL);
378  if (!desc)
379  return NULL;
380  bitmap_blk = ext4_block_bitmap(sb, desc);
381  bh = sb_getblk(sb, bitmap_blk);
382  if (unlikely(!bh)) {
383  ext4_error(sb, "Cannot get buffer for block bitmap - "
384  "block_group = %u, block_bitmap = %llu",
385  block_group, bitmap_blk);
386  return NULL;
387  }
388 
389  if (bitmap_uptodate(bh))
390  goto verify;
391 
392  lock_buffer(bh);
393  if (bitmap_uptodate(bh)) {
394  unlock_buffer(bh);
395  goto verify;
396  }
397  ext4_lock_group(sb, block_group);
399  ext4_init_block_bitmap(sb, bh, block_group, desc);
400  set_bitmap_uptodate(bh);
401  set_buffer_uptodate(bh);
402  ext4_unlock_group(sb, block_group);
403  unlock_buffer(bh);
404  return bh;
405  }
406  ext4_unlock_group(sb, block_group);
407  if (buffer_uptodate(bh)) {
408  /*
409  * if not uninit if bh is uptodate,
410  * bitmap is also uptodate
411  */
412  set_bitmap_uptodate(bh);
413  unlock_buffer(bh);
414  goto verify;
415  }
416  /*
417  * submit the buffer_head for reading
418  */
419  set_buffer_new(bh);
420  trace_ext4_read_block_bitmap_load(sb, block_group);
421  bh->b_end_io = ext4_end_bitmap_read;
422  get_bh(bh);
423  submit_bh(READ, bh);
424  return bh;
425 verify:
426  ext4_validate_block_bitmap(sb, desc, block_group, bh);
427  return bh;
428 }
429 
430 /* Returns 0 on success, 1 on error */
431 int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
432  struct buffer_head *bh)
433 {
434  struct ext4_group_desc *desc;
435 
436  if (!buffer_new(bh))
437  return 0;
438  desc = ext4_get_group_desc(sb, block_group, NULL);
439  if (!desc)
440  return 1;
441  wait_on_buffer(bh);
442  if (!buffer_uptodate(bh)) {
443  ext4_error(sb, "Cannot read block bitmap - "
444  "block_group = %u, block_bitmap = %llu",
445  block_group, (unsigned long long) bh->b_blocknr);
446  return 1;
447  }
448  clear_buffer_new(bh);
449  /* Panic or remount fs read-only if block bitmap is invalid */
450  ext4_validate_block_bitmap(sb, desc, block_group, bh);
451  return 0;
452 }
453 
454 struct buffer_head *
456 {
457  struct buffer_head *bh;
458 
459  bh = ext4_read_block_bitmap_nowait(sb, block_group);
460  if (ext4_wait_block_bitmap(sb, block_group, bh)) {
461  put_bh(bh);
462  return NULL;
463  }
464  return bh;
465 }
466 
476 static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
477  s64 nclusters, unsigned int flags)
478 {
479  s64 free_clusters, dirty_clusters, root_clusters;
480  struct percpu_counter *fcc = &sbi->s_freeclusters_counter;
481  struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter;
482 
483  free_clusters = percpu_counter_read_positive(fcc);
484  dirty_clusters = percpu_counter_read_positive(dcc);
485  root_clusters = EXT4_B2C(sbi, ext4_r_blocks_count(sbi->s_es));
486 
487  if (free_clusters - (nclusters + root_clusters + dirty_clusters) <
488  EXT4_FREECLUSTERS_WATERMARK) {
489  free_clusters = EXT4_C2B(sbi, percpu_counter_sum_positive(fcc));
490  dirty_clusters = percpu_counter_sum_positive(dcc);
491  }
492  /* Check whether we have space after accounting for current
493  * dirty clusters & root reserved clusters.
494  */
495  if (free_clusters >= ((root_clusters + nclusters) + dirty_clusters))
496  return 1;
497 
498  /* Hm, nope. Are (enough) root reserved clusters available? */
499  if (uid_eq(sbi->s_resuid, current_fsuid()) ||
500  (!gid_eq(sbi->s_resgid, GLOBAL_ROOT_GID) && in_group_p(sbi->s_resgid)) ||
502  (flags & EXT4_MB_USE_ROOT_BLOCKS)) {
503 
504  if (free_clusters >= (nclusters + dirty_clusters))
505  return 1;
506  }
507 
508  return 0;
509 }
510 
511 int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
512  s64 nclusters, unsigned int flags)
513 {
514  if (ext4_has_free_clusters(sbi, nclusters, flags)) {
515  percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters);
516  return 0;
517  } else
518  return -ENOSPC;
519 }
520 
534 {
535  if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||
536  (*retries)++ > 3 ||
537  !EXT4_SB(sb)->s_journal)
538  return 0;
539 
540  jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
541 
543 }
544 
545 /*
546  * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
547  *
548  * @handle: handle to this transaction
549  * @inode: file inode
550  * @goal: given target block(filesystem wide)
551  * @count: pointer to total number of clusters needed
552  * @errp: error code
553  *
554  * Return 1st allocated block number on success, *count stores total account
555  * error stores in errp pointer
556  */
558  ext4_fsblk_t goal, unsigned int flags,
559  unsigned long *count, int *errp)
560 {
561  struct ext4_allocation_request ar;
563 
564  memset(&ar, 0, sizeof(ar));
565  /* Fill with neighbour allocated blocks */
566  ar.inode = inode;
567  ar.goal = goal;
568  ar.len = count ? *count : 1;
569  ar.flags = flags;
570 
571  ret = ext4_mb_new_blocks(handle, &ar, errp);
572  if (count)
573  *count = ar.len;
574  /*
575  * Account for the allocated meta blocks. We will never
576  * fail EDQUOT for metdata, but we do account for it.
577  */
578  if (!(*errp) &&
579  ext4_test_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED)) {
580  spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
581  EXT4_I(inode)->i_allocated_meta_blocks += ar.len;
582  spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
583  dquot_alloc_block_nofail(inode,
584  EXT4_C2B(EXT4_SB(inode->i_sb), ar.len));
585  }
586  return ret;
587 }
588 
596 {
598  struct ext4_group_desc *gdp;
599  ext4_group_t i;
600  ext4_group_t ngroups = ext4_get_groups_count(sb);
601 #ifdef EXT4FS_DEBUG
602  struct ext4_super_block *es;
603  ext4_fsblk_t bitmap_count;
604  unsigned int x;
605  struct buffer_head *bitmap_bh = NULL;
606 
607  es = EXT4_SB(sb)->s_es;
608  desc_count = 0;
609  bitmap_count = 0;
610  gdp = NULL;
611 
612  for (i = 0; i < ngroups; i++) {
613  gdp = ext4_get_group_desc(sb, i, NULL);
614  if (!gdp)
615  continue;
616  desc_count += ext4_free_group_clusters(sb, gdp);
617  brelse(bitmap_bh);
618  bitmap_bh = ext4_read_block_bitmap(sb, i);
619  if (bitmap_bh == NULL)
620  continue;
621 
622  x = ext4_count_free(bitmap_bh->b_data,
623  EXT4_BLOCKS_PER_GROUP(sb) / 8);
624  printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
625  i, ext4_free_group_clusters(sb, gdp), x);
626  bitmap_count += x;
627  }
628  brelse(bitmap_bh);
629  printk(KERN_DEBUG "ext4_count_free_clusters: stored = %llu"
630  ", computed = %llu, %llu\n",
631  EXT4_B2C(EXT4_SB(sb), ext4_free_blocks_count(es)),
632  desc_count, bitmap_count);
633  return bitmap_count;
634 #else
635  desc_count = 0;
636  for (i = 0; i < ngroups; i++) {
637  gdp = ext4_get_group_desc(sb, i, NULL);
638  if (!gdp)
639  continue;
640  desc_count += ext4_free_group_clusters(sb, gdp);
641  }
642 
643  return desc_count;
644 #endif
645 }
646 
647 static inline int test_root(ext4_group_t a, int b)
648 {
649  int num = b;
650 
651  while (a > num)
652  num *= b;
653  return num == a;
654 }
655 
656 static int ext4_group_sparse(ext4_group_t group)
657 {
658  if (group <= 1)
659  return 1;
660  if (!(group & 1))
661  return 0;
662  return (test_root(group, 7) || test_root(group, 5) ||
663  test_root(group, 3));
664 }
665 
675 {
678  !ext4_group_sparse(group))
679  return 0;
680  return 1;
681 }
682 
683 static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
684  ext4_group_t group)
685 {
686  unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
687  ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
688  ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
689 
690  if (group == first || group == first + 1 || group == last)
691  return 1;
692  return 0;
693 }
694 
695 static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
696  ext4_group_t group)
697 {
698  if (!ext4_bg_has_super(sb, group))
699  return 0;
700 
702  return le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
703  else
704  return EXT4_SB(sb)->s_gdb_count;
705 }
706 
716 unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
717 {
718  unsigned long first_meta_bg =
719  le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
720  unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
721 
723  metagroup < first_meta_bg)
724  return ext4_bg_num_gdb_nometa(sb, group);
725 
726  return ext4_bg_num_gdb_meta(sb,group);
727 
728 }
729 
730 /*
731  * This function returns the number of file system metadata clusters at
732  * the beginning of a block group, including the reserved gdt blocks.
733  */
734 static unsigned ext4_num_base_meta_clusters(struct super_block *sb,
735  ext4_group_t block_group)
736 {
737  struct ext4_sb_info *sbi = EXT4_SB(sb);
738  unsigned num;
739 
740  /* Check for superblock and gdt backups in this group */
741  num = ext4_bg_has_super(sb, block_group);
742 
744  block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
745  sbi->s_desc_per_block) {
746  if (num) {
747  num += ext4_bg_num_gdb(sb, block_group);
748  num += le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
749  }
750  } else { /* For META_BG_BLOCK_GROUPS */
751  num += ext4_bg_num_gdb(sb, block_group);
752  }
753  return EXT4_NUM_B2C(sbi, num);
754 }
763 {
764  struct ext4_inode_info *ei = EXT4_I(inode);
766  ext4_grpblk_t colour;
767  int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
768  ext4_fsblk_t bg_start;
769  ext4_fsblk_t last_block;
770 
771  block_group = ei->i_block_group;
772  if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
773  /*
774  * If there are at least EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME
775  * block groups per flexgroup, reserve the first block
776  * group for directories and special files. Regular
777  * files will start at the second block group. This
778  * tends to speed up directory access and improves
779  * fsck times.
780  */
781  block_group &= ~(flex_size-1);
782  if (S_ISREG(inode->i_mode))
783  block_group++;
784  }
785  bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
786  last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
787 
788  /*
789  * If we are doing delayed allocation, we don't need take
790  * colour into account.
791  */
792  if (test_opt(inode->i_sb, DELALLOC))
793  return bg_start;
794 
795  if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
796  colour = (current->pid % 16) *
797  (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
798  else
799  colour = (current->pid % 16) * ((last_block - bg_start) / 16);
800  return bg_start + colour;
801 }
802