Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
resize.c
Go to the documentation of this file.
1 /*
2  * linux/fs/ext4/resize.c
3  *
4  * Support for resizing an ext4 filesystem while it is mounted.
5  *
6  * Copyright (C) 2001, 2002 Andreas Dilger <[email protected]>
7  *
8  * This could probably be made into a module, because it is not often in use.
9  */
10 
11 
12 #define EXT4FS_DEBUG
13 
14 #include <linux/errno.h>
15 #include <linux/slab.h>
16 
17 #include "ext4_jbd2.h"
18 
20 {
21  int ret = 0;
22 
24  return -EPERM;
25 
26  /*
27  * We are not allowed to do online-resizing on a filesystem mounted
28  * with error, because it can destroy the filesystem easily.
29  */
30  if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
31  ext4_warning(sb, "There are errors in the filesystem, "
32  "so online resizing is not allowed\n");
33  return -EPERM;
34  }
35 
36  if (test_and_set_bit_lock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags))
37  ret = -EBUSY;
38 
39  return ret;
40 }
41 
43 {
44  clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags);
46 }
47 
48 static ext4_group_t ext4_meta_bg_first_group(struct super_block *sb,
50  return (group >> EXT4_DESC_PER_BLOCK_BITS(sb)) <<
51  EXT4_DESC_PER_BLOCK_BITS(sb);
52 }
53 
54 static ext4_fsblk_t ext4_meta_bg_first_block_no(struct super_block *sb,
55  ext4_group_t group) {
56  group = ext4_meta_bg_first_group(sb, group);
57  return ext4_group_first_block_no(sb, group);
58 }
59 
60 static ext4_grpblk_t ext4_group_overhead_blocks(struct super_block *sb,
61  ext4_group_t group) {
62  ext4_grpblk_t overhead;
63  overhead = ext4_bg_num_gdb(sb, group);
64  if (ext4_bg_has_super(sb, group))
65  overhead += 1 +
66  le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks);
67  return overhead;
68 }
69 
70 #define outside(b, first, last) ((b) < (first) || (b) >= (last))
71 #define inside(b, first, last) ((b) >= (first) && (b) < (last))
72 
73 static int verify_group_input(struct super_block *sb,
74  struct ext4_new_group_data *input)
75 {
76  struct ext4_sb_info *sbi = EXT4_SB(sb);
77  struct ext4_super_block *es = sbi->s_es;
78  ext4_fsblk_t start = ext4_blocks_count(es);
79  ext4_fsblk_t end = start + input->blocks_count;
80  ext4_group_t group = input->group;
81  ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group;
82  unsigned overhead = ext4_group_overhead_blocks(sb, group);
83  ext4_fsblk_t metaend = start + overhead;
84  struct buffer_head *bh = NULL;
85  ext4_grpblk_t free_blocks_count, offset;
86  int err = -EINVAL;
87 
88  input->free_blocks_count = free_blocks_count =
89  input->blocks_count - 2 - overhead - sbi->s_itb_per_group;
90 
91  if (test_opt(sb, DEBUG))
92  printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks "
93  "(%d free, %u reserved)\n",
94  ext4_bg_has_super(sb, input->group) ? "normal" :
95  "no-super", input->group, input->blocks_count,
96  free_blocks_count, input->reserved_blocks);
97 
98  ext4_get_group_no_and_offset(sb, start, NULL, &offset);
99  if (group != sbi->s_groups_count)
100  ext4_warning(sb, "Cannot add at group %u (only %u groups)",
101  input->group, sbi->s_groups_count);
102  else if (offset != 0)
103  ext4_warning(sb, "Last group not full");
104  else if (input->reserved_blocks > input->blocks_count / 5)
105  ext4_warning(sb, "Reserved blocks too high (%u)",
106  input->reserved_blocks);
107  else if (free_blocks_count < 0)
108  ext4_warning(sb, "Bad blocks count %u",
109  input->blocks_count);
110  else if (!(bh = sb_bread(sb, end - 1)))
111  ext4_warning(sb, "Cannot read last block (%llu)",
112  end - 1);
113  else if (outside(input->block_bitmap, start, end))
114  ext4_warning(sb, "Block bitmap not in group (block %llu)",
115  (unsigned long long)input->block_bitmap);
116  else if (outside(input->inode_bitmap, start, end))
117  ext4_warning(sb, "Inode bitmap not in group (block %llu)",
118  (unsigned long long)input->inode_bitmap);
119  else if (outside(input->inode_table, start, end) ||
120  outside(itend - 1, start, end))
121  ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)",
122  (unsigned long long)input->inode_table, itend - 1);
123  else if (input->inode_bitmap == input->block_bitmap)
124  ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)",
125  (unsigned long long)input->block_bitmap);
126  else if (inside(input->block_bitmap, input->inode_table, itend))
127  ext4_warning(sb, "Block bitmap (%llu) in inode table "
128  "(%llu-%llu)",
129  (unsigned long long)input->block_bitmap,
130  (unsigned long long)input->inode_table, itend - 1);
131  else if (inside(input->inode_bitmap, input->inode_table, itend))
132  ext4_warning(sb, "Inode bitmap (%llu) in inode table "
133  "(%llu-%llu)",
134  (unsigned long long)input->inode_bitmap,
135  (unsigned long long)input->inode_table, itend - 1);
136  else if (inside(input->block_bitmap, start, metaend))
137  ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)",
138  (unsigned long long)input->block_bitmap,
139  start, metaend - 1);
140  else if (inside(input->inode_bitmap, start, metaend))
141  ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)",
142  (unsigned long long)input->inode_bitmap,
143  start, metaend - 1);
144  else if (inside(input->inode_table, start, metaend) ||
145  inside(itend - 1, start, metaend))
146  ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table "
147  "(%llu-%llu)",
148  (unsigned long long)input->inode_table,
149  itend - 1, start, metaend - 1);
150  else
151  err = 0;
152  brelse(bh);
153 
154  return err;
155 }
156 
157 /*
158  * ext4_new_flex_group_data is used by 64bit-resize interface to add a flex
159  * group each time.
160  */
162  struct ext4_new_group_data *groups; /* new_group_data for groups
163  in the flex group */
164  __u16 *bg_flags; /* block group flags of groups
165  in @groups */
166  ext4_group_t count; /* number of groups in @groups
167  */
168 };
169 
170 /*
171  * alloc_flex_gd() allocates a ext4_new_flex_group_data with size of
172  * @flexbg_size.
173  *
174  * Returns NULL on failure otherwise address of the allocated structure.
175  */
176 static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned long flexbg_size)
177 {
178  struct ext4_new_flex_group_data *flex_gd;
179 
180  flex_gd = kmalloc(sizeof(*flex_gd), GFP_NOFS);
181  if (flex_gd == NULL)
182  goto out3;
183 
184  if (flexbg_size >= UINT_MAX / sizeof(struct ext4_new_flex_group_data))
185  goto out2;
186  flex_gd->count = flexbg_size;
187 
188  flex_gd->groups = kmalloc(sizeof(struct ext4_new_group_data) *
189  flexbg_size, GFP_NOFS);
190  if (flex_gd->groups == NULL)
191  goto out2;
192 
193  flex_gd->bg_flags = kmalloc(flexbg_size * sizeof(__u16), GFP_NOFS);
194  if (flex_gd->bg_flags == NULL)
195  goto out1;
196 
197  return flex_gd;
198 
199 out1:
200  kfree(flex_gd->groups);
201 out2:
202  kfree(flex_gd);
203 out3:
204  return NULL;
205 }
206 
207 static void free_flex_gd(struct ext4_new_flex_group_data *flex_gd)
208 {
209  kfree(flex_gd->bg_flags);
210  kfree(flex_gd->groups);
211  kfree(flex_gd);
212 }
213 
214 /*
215  * ext4_alloc_group_tables() allocates block bitmaps, inode bitmaps
216  * and inode tables for a flex group.
217  *
218  * This function is used by 64bit-resize. Note that this function allocates
219  * group tables from the 1st group of groups contained by @flexgd, which may
220  * be a partial of a flex group.
221  *
222  * @sb: super block of fs to which the groups belongs
223  *
224  * Returns 0 on a successful allocation of the metadata blocks in the
225  * block group.
226  */
227 static int ext4_alloc_group_tables(struct super_block *sb,
228  struct ext4_new_flex_group_data *flex_gd,
229  int flexbg_size)
230 {
231  struct ext4_new_group_data *group_data = flex_gd->groups;
232  ext4_fsblk_t start_blk;
233  ext4_fsblk_t last_blk;
234  ext4_group_t src_group;
235  ext4_group_t bb_index = 0;
236  ext4_group_t ib_index = 0;
237  ext4_group_t it_index = 0;
239  ext4_group_t last_group;
240  unsigned overhead;
241 
242  BUG_ON(flex_gd->count == 0 || group_data == NULL);
243 
244  src_group = group_data[0].group;
245  last_group = src_group + flex_gd->count - 1;
246 
247  BUG_ON((flexbg_size > 1) && ((src_group & ~(flexbg_size - 1)) !=
248  (last_group & ~(flexbg_size - 1))));
249 next_group:
250  group = group_data[0].group;
251  if (src_group >= group_data[0].group + flex_gd->count)
252  return -ENOSPC;
253  start_blk = ext4_group_first_block_no(sb, src_group);
254  last_blk = start_blk + group_data[src_group - group].blocks_count;
255 
256  overhead = ext4_group_overhead_blocks(sb, src_group);
257 
258  start_blk += overhead;
259 
260  /* We collect contiguous blocks as much as possible. */
261  src_group++;
262  for (; src_group <= last_group; src_group++) {
263  overhead = ext4_group_overhead_blocks(sb, src_group);
264  if (overhead != 0)
265  last_blk += group_data[src_group - group].blocks_count;
266  else
267  break;
268  }
269 
270  /* Allocate block bitmaps */
271  for (; bb_index < flex_gd->count; bb_index++) {
272  if (start_blk >= last_blk)
273  goto next_group;
274  group_data[bb_index].block_bitmap = start_blk++;
275  ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL);
276  group -= group_data[0].group;
277  group_data[group].free_blocks_count--;
278  if (flexbg_size > 1)
279  flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT;
280  }
281 
282  /* Allocate inode bitmaps */
283  for (; ib_index < flex_gd->count; ib_index++) {
284  if (start_blk >= last_blk)
285  goto next_group;
286  group_data[ib_index].inode_bitmap = start_blk++;
287  ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL);
288  group -= group_data[0].group;
289  group_data[group].free_blocks_count--;
290  if (flexbg_size > 1)
291  flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT;
292  }
293 
294  /* Allocate inode tables */
295  for (; it_index < flex_gd->count; it_index++) {
296  if (start_blk + EXT4_SB(sb)->s_itb_per_group > last_blk)
297  goto next_group;
298  group_data[it_index].inode_table = start_blk;
299  ext4_get_group_no_and_offset(sb, start_blk, &group, NULL);
300  group -= group_data[0].group;
301  group_data[group].free_blocks_count -=
302  EXT4_SB(sb)->s_itb_per_group;
303  if (flexbg_size > 1)
304  flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT;
305 
306  start_blk += EXT4_SB(sb)->s_itb_per_group;
307  }
308 
309  if (test_opt(sb, DEBUG)) {
310  int i;
311  group = group_data[0].group;
312 
313  printk(KERN_DEBUG "EXT4-fs: adding a flex group with "
314  "%d groups, flexbg size is %d:\n", flex_gd->count,
315  flexbg_size);
316 
317  for (i = 0; i < flex_gd->count; i++) {
318  printk(KERN_DEBUG "adding %s group %u: %u "
319  "blocks (%d free)\n",
320  ext4_bg_has_super(sb, group + i) ? "normal" :
321  "no-super", group + i,
322  group_data[i].blocks_count,
323  group_data[i].free_blocks_count);
324  }
325  }
326  return 0;
327 }
328 
329 static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
331 {
332  struct buffer_head *bh;
333  int err;
334 
335  bh = sb_getblk(sb, blk);
336  if (!bh)
337  return ERR_PTR(-EIO);
338  if ((err = ext4_journal_get_write_access(handle, bh))) {
339  brelse(bh);
340  bh = ERR_PTR(err);
341  } else {
342  memset(bh->b_data, 0, sb->s_blocksize);
343  set_buffer_uptodate(bh);
344  }
345 
346  return bh;
347 }
348 
349 /*
350  * If we have fewer than thresh credits, extend by EXT4_MAX_TRANS_DATA.
351  * If that fails, restart the transaction & regain write access for the
352  * buffer head which is used for block_bitmap modifications.
353  */
354 static int extend_or_restart_transaction(handle_t *handle, int thresh)
355 {
356  int err;
357 
358  if (ext4_handle_has_enough_credits(handle, thresh))
359  return 0;
360 
361  err = ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA);
362  if (err < 0)
363  return err;
364  if (err) {
365  err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA);
366  if (err)
367  return err;
368  }
369 
370  return 0;
371 }
372 
373 /*
374  * set_flexbg_block_bitmap() mark @count blocks starting from @block used.
375  *
376  * Helper function for ext4_setup_new_group_blocks() which set .
377  *
378  * @sb: super block
379  * @handle: journal handle
380  * @flex_gd: flex group data
381  */
382 static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle,
383  struct ext4_new_flex_group_data *flex_gd,
385 {
387 
388  ext4_debug("mark blocks [%llu/%u] used\n", block, count);
389  for (count2 = count; count > 0; count -= count2, block += count2) {
391  struct buffer_head *bh;
393  int err;
394 
395  ext4_get_group_no_and_offset(sb, block, &group, NULL);
396  start = ext4_group_first_block_no(sb, group);
397  group -= flex_gd->groups[0].group;
398 
399  count2 = sb->s_blocksize * 8 - (block - start);
400  if (count2 > count)
401  count2 = count;
402 
403  if (flex_gd->bg_flags[group] & EXT4_BG_BLOCK_UNINIT) {
404  BUG_ON(flex_gd->count > 1);
405  continue;
406  }
407 
408  err = extend_or_restart_transaction(handle, 1);
409  if (err)
410  return err;
411 
412  bh = sb_getblk(sb, flex_gd->groups[group].block_bitmap);
413  if (!bh)
414  return -EIO;
415 
416  err = ext4_journal_get_write_access(handle, bh);
417  if (err)
418  return err;
419  ext4_debug("mark block bitmap %#04llx (+%llu/%u)\n", block,
420  block - start, count2);
421  ext4_set_bits(bh->b_data, block - start, count2);
422 
423  err = ext4_handle_dirty_metadata(handle, NULL, bh);
424  if (unlikely(err))
425  return err;
426  brelse(bh);
427  }
428 
429  return 0;
430 }
431 
432 /*
433  * Set up the block and inode bitmaps, and the inode table for the new groups.
434  * This doesn't need to be part of the main transaction, since we are only
435  * changing blocks outside the actual filesystem. We still do journaling to
436  * ensure the recovery is correct in case of a failure just after resize.
437  * If any part of this fails, we simply abort the resize.
438  *
439  * setup_new_flex_group_blocks handles a flex group as follow:
440  * 1. copy super block and GDT, and initialize group tables if necessary.
441  * In this step, we only set bits in blocks bitmaps for blocks taken by
442  * super block and GDT.
443  * 2. allocate group tables in block bitmaps, that is, set bits in block
444  * bitmap for blocks taken by group tables.
445  */
446 static int setup_new_flex_group_blocks(struct super_block *sb,
447  struct ext4_new_flex_group_data *flex_gd)
448 {
449  int group_table_count[] = {1, 1, EXT4_SB(sb)->s_itb_per_group};
452  struct ext4_sb_info *sbi = EXT4_SB(sb);
453  struct ext4_super_block *es = sbi->s_es;
454  struct ext4_new_group_data *group_data = flex_gd->groups;
455  __u16 *bg_flags = flex_gd->bg_flags;
456  handle_t *handle;
458  struct buffer_head *bh = NULL;
459  int reserved_gdb, i, j, err = 0, err2;
460  int meta_bg;
461 
462  BUG_ON(!flex_gd->count || !group_data ||
463  group_data[0].group != sbi->s_groups_count);
464 
465  reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
467 
468  /* This transaction may be extended/restarted along the way */
470  if (IS_ERR(handle))
471  return PTR_ERR(handle);
472 
473  group = group_data[0].group;
474  for (i = 0; i < flex_gd->count; i++, group++) {
475  unsigned long gdblocks;
476  ext4_grpblk_t overhead;
477 
478  gdblocks = ext4_bg_num_gdb(sb, group);
479  start = ext4_group_first_block_no(sb, group);
480 
481  if (meta_bg == 0 && !ext4_bg_has_super(sb, group))
482  goto handle_itb;
483 
484  if (meta_bg == 1) {
485  ext4_group_t first_group;
486  first_group = ext4_meta_bg_first_group(sb, group);
487  if (first_group != group + 1 &&
488  first_group != group + EXT4_DESC_PER_BLOCK(sb) - 1)
489  goto handle_itb;
490  }
491 
492  block = start + ext4_bg_has_super(sb, group);
493  /* Copy all of the GDT blocks into the backup in this group */
494  for (j = 0; j < gdblocks; j++, block++) {
495  struct buffer_head *gdb;
496 
497  ext4_debug("update backup group %#04llx\n", block);
498  err = extend_or_restart_transaction(handle, 1);
499  if (err)
500  goto out;
501 
502  gdb = sb_getblk(sb, block);
503  if (!gdb) {
504  err = -EIO;
505  goto out;
506  }
507 
508  err = ext4_journal_get_write_access(handle, gdb);
509  if (err) {
510  brelse(gdb);
511  goto out;
512  }
513  memcpy(gdb->b_data, sbi->s_group_desc[j]->b_data,
514  gdb->b_size);
515  set_buffer_uptodate(gdb);
516 
517  err = ext4_handle_dirty_metadata(handle, NULL, gdb);
518  if (unlikely(err)) {
519  brelse(gdb);
520  goto out;
521  }
522  brelse(gdb);
523  }
524 
525  /* Zero out all of the reserved backup group descriptor
526  * table blocks
527  */
528  if (ext4_bg_has_super(sb, group)) {
529  err = sb_issue_zeroout(sb, gdblocks + start + 1,
530  reserved_gdb, GFP_NOFS);
531  if (err)
532  goto out;
533  }
534 
535 handle_itb:
536  /* Initialize group tables of the grop @group */
537  if (!(bg_flags[i] & EXT4_BG_INODE_ZEROED))
538  goto handle_bb;
539 
540  /* Zero out all of the inode table blocks */
541  block = group_data[i].inode_table;
542  ext4_debug("clear inode table blocks %#04llx -> %#04lx\n",
543  block, sbi->s_itb_per_group);
544  err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group,
545  GFP_NOFS);
546  if (err)
547  goto out;
548 
549 handle_bb:
550  if (bg_flags[i] & EXT4_BG_BLOCK_UNINIT)
551  goto handle_ib;
552 
553  /* Initialize block bitmap of the @group */
554  block = group_data[i].block_bitmap;
555  err = extend_or_restart_transaction(handle, 1);
556  if (err)
557  goto out;
558 
559  bh = bclean(handle, sb, block);
560  if (IS_ERR(bh)) {
561  err = PTR_ERR(bh);
562  goto out;
563  }
564  overhead = ext4_group_overhead_blocks(sb, group);
565  if (overhead != 0) {
566  ext4_debug("mark backup superblock %#04llx (+0)\n",
567  start);
568  ext4_set_bits(bh->b_data, 0, overhead);
569  }
570  ext4_mark_bitmap_end(group_data[i].blocks_count,
571  sb->s_blocksize * 8, bh->b_data);
572  err = ext4_handle_dirty_metadata(handle, NULL, bh);
573  if (err)
574  goto out;
575  brelse(bh);
576 
577 handle_ib:
578  if (bg_flags[i] & EXT4_BG_INODE_UNINIT)
579  continue;
580 
581  /* Initialize inode bitmap of the @group */
582  block = group_data[i].inode_bitmap;
583  err = extend_or_restart_transaction(handle, 1);
584  if (err)
585  goto out;
586  /* Mark unused entries in inode bitmap used */
587  bh = bclean(handle, sb, block);
588  if (IS_ERR(bh)) {
589  err = PTR_ERR(bh);
590  goto out;
591  }
592 
594  sb->s_blocksize * 8, bh->b_data);
595  err = ext4_handle_dirty_metadata(handle, NULL, bh);
596  if (err)
597  goto out;
598  brelse(bh);
599  }
600  bh = NULL;
601 
602  /* Mark group tables in block bitmap */
603  for (j = 0; j < GROUP_TABLE_COUNT; j++) {
604  count = group_table_count[j];
605  start = (&group_data[0].block_bitmap)[j];
606  block = start;
607  for (i = 1; i < flex_gd->count; i++) {
608  block += group_table_count[j];
609  if (block == (&group_data[i].block_bitmap)[j]) {
610  count += group_table_count[j];
611  continue;
612  }
613  err = set_flexbg_block_bitmap(sb, handle,
614  flex_gd, start, count);
615  if (err)
616  goto out;
617  count = group_table_count[j];
618  start = group_data[i].block_bitmap;
619  block = start;
620  }
621 
622  if (count) {
623  err = set_flexbg_block_bitmap(sb, handle,
624  flex_gd, start, count);
625  if (err)
626  goto out;
627  }
628  }
629 
630 out:
631  brelse(bh);
632  err2 = ext4_journal_stop(handle);
633  if (err2 && !err)
634  err = err2;
635 
636  return err;
637 }
638 
639 /*
640  * Iterate through the groups which hold BACKUP superblock/GDT copies in an
641  * ext4 filesystem. The counters should be initialized to 1, 5, and 7 before
642  * calling this for the first time. In a sparse filesystem it will be the
643  * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ...
644  * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ...
645  */
646 static unsigned ext4_list_backups(struct super_block *sb, unsigned *three,
647  unsigned *five, unsigned *seven)
648 {
649  unsigned *min = three;
650  int mult = 3;
651  unsigned ret;
652 
655  ret = *min;
656  *min += 1;
657  return ret;
658  }
659 
660  if (*five < *min) {
661  min = five;
662  mult = 5;
663  }
664  if (*seven < *min) {
665  min = seven;
666  mult = 7;
667  }
668 
669  ret = *min;
670  *min *= mult;
671 
672  return ret;
673 }
674 
675 /*
676  * Check that all of the backup GDT blocks are held in the primary GDT block.
677  * It is assumed that they are stored in group order. Returns the number of
678  * groups in current filesystem that have BACKUPS, or -ve error code.
679  */
680 static int verify_reserved_gdb(struct super_block *sb,
682  struct buffer_head *primary)
683 {
684  const ext4_fsblk_t blk = primary->b_blocknr;
685  unsigned three = 1;
686  unsigned five = 5;
687  unsigned seven = 7;
688  unsigned grp;
689  __le32 *p = (__le32 *)primary->b_data;
690  int gdbackups = 0;
691 
692  while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
693  if (le32_to_cpu(*p++) !=
694  grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
695  ext4_warning(sb, "reserved GDT %llu"
696  " missing grp %d (%llu)",
697  blk, grp,
698  grp *
700  blk);
701  return -EINVAL;
702  }
703  if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb))
704  return -EFBIG;
705  }
706 
707  return gdbackups;
708 }
709 
710 /*
711  * Called when we need to bring a reserved group descriptor table block into
712  * use from the resize inode. The primary copy of the new GDT block currently
713  * is an indirect block (under the double indirect block in the resize inode).
714  * The new backup GDT blocks will be stored as leaf blocks in this indirect
715  * block, in group order. Even though we know all the block numbers we need,
716  * we check to ensure that the resize inode has actually reserved these blocks.
717  *
718  * Don't need to update the block bitmaps because the blocks are still in use.
719  *
720  * We get all of the error cases out of the way, so that we are sure to not
721  * fail once we start modifying the data on disk, because JBD has no rollback.
722  */
723 static int add_new_gdb(handle_t *handle, struct inode *inode,
724  ext4_group_t group)
725 {
726  struct super_block *sb = inode->i_sb;
727  struct ext4_super_block *es = EXT4_SB(sb)->s_es;
728  unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
729  ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num;
730  struct buffer_head **o_group_desc, **n_group_desc;
731  struct buffer_head *dind;
732  struct buffer_head *gdb_bh;
733  int gdbackups;
734  struct ext4_iloc iloc;
735  __le32 *data;
736  int err;
737 
738  if (test_opt(sb, DEBUG))
740  "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n",
741  gdb_num);
742 
743  /*
744  * If we are not using the primary superblock/GDT copy don't resize,
745  * because the user tools have no way of handling this. Probably a
746  * bad time to do it anyways.
747  */
748  if (EXT4_SB(sb)->s_sbh->b_blocknr !=
749  le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
750  ext4_warning(sb, "won't resize using backup superblock at %llu",
751  (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
752  return -EPERM;
753  }
754 
755  gdb_bh = sb_bread(sb, gdblock);
756  if (!gdb_bh)
757  return -EIO;
758 
759  gdbackups = verify_reserved_gdb(sb, group, gdb_bh);
760  if (gdbackups < 0) {
761  err = gdbackups;
762  goto exit_bh;
763  }
764 
765  data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK;
766  dind = sb_bread(sb, le32_to_cpu(*data));
767  if (!dind) {
768  err = -EIO;
769  goto exit_bh;
770  }
771 
772  data = (__le32 *)dind->b_data;
773  if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
774  ext4_warning(sb, "new group %u GDT block %llu not reserved",
775  group, gdblock);
776  err = -EINVAL;
777  goto exit_dind;
778  }
779 
780  err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
781  if (unlikely(err))
782  goto exit_dind;
783 
784  err = ext4_journal_get_write_access(handle, gdb_bh);
785  if (unlikely(err))
786  goto exit_sbh;
787 
788  err = ext4_journal_get_write_access(handle, dind);
789  if (unlikely(err))
790  ext4_std_error(sb, err);
791 
792  /* ext4_reserve_inode_write() gets a reference on the iloc */
793  err = ext4_reserve_inode_write(handle, inode, &iloc);
794  if (unlikely(err))
795  goto exit_dindj;
796 
797  n_group_desc = ext4_kvmalloc((gdb_num + 1) *
798  sizeof(struct buffer_head *),
799  GFP_NOFS);
800  if (!n_group_desc) {
801  err = -ENOMEM;
802  ext4_warning(sb, "not enough memory for %lu groups",
803  gdb_num + 1);
804  goto exit_inode;
805  }
806 
807  /*
808  * Finally, we have all of the possible failures behind us...
809  *
810  * Remove new GDT block from inode double-indirect block and clear out
811  * the new GDT block for use (which also "frees" the backup GDT blocks
812  * from the reserved inode). We don't need to change the bitmaps for
813  * these blocks, because they are marked as in-use from being in the
814  * reserved inode, and will become GDT blocks (primary and backup).
815  */
816  data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)] = 0;
817  err = ext4_handle_dirty_metadata(handle, NULL, dind);
818  if (unlikely(err)) {
819  ext4_std_error(sb, err);
820  goto exit_inode;
821  }
822  inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9;
823  ext4_mark_iloc_dirty(handle, inode, &iloc);
824  memset(gdb_bh->b_data, 0, sb->s_blocksize);
825  err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh);
826  if (unlikely(err)) {
827  ext4_std_error(sb, err);
828  goto exit_inode;
829  }
830  brelse(dind);
831 
832  o_group_desc = EXT4_SB(sb)->s_group_desc;
833  memcpy(n_group_desc, o_group_desc,
834  EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *));
835  n_group_desc[gdb_num] = gdb_bh;
836  EXT4_SB(sb)->s_group_desc = n_group_desc;
837  EXT4_SB(sb)->s_gdb_count++;
838  ext4_kvfree(o_group_desc);
839 
840  le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
841  err = ext4_handle_dirty_super(handle, sb);
842  if (err)
843  ext4_std_error(sb, err);
844 
845  return err;
846 
847 exit_inode:
848  ext4_kvfree(n_group_desc);
849  /* ext4_handle_release_buffer(handle, iloc.bh); */
850  brelse(iloc.bh);
851 exit_dindj:
852  /* ext4_handle_release_buffer(handle, dind); */
853 exit_sbh:
854  /* ext4_handle_release_buffer(handle, EXT4_SB(sb)->s_sbh); */
855 exit_dind:
856  brelse(dind);
857 exit_bh:
858  brelse(gdb_bh);
859 
860  ext4_debug("leaving with error %d\n", err);
861  return err;
862 }
863 
864 /*
865  * add_new_gdb_meta_bg is the sister of add_new_gdb.
866  */
867 static int add_new_gdb_meta_bg(struct super_block *sb,
868  handle_t *handle, ext4_group_t group) {
869  ext4_fsblk_t gdblock;
870  struct buffer_head *gdb_bh;
871  struct buffer_head **o_group_desc, **n_group_desc;
872  unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
873  int err;
874 
875  gdblock = ext4_meta_bg_first_block_no(sb, group) +
876  ext4_bg_has_super(sb, group);
877  gdb_bh = sb_bread(sb, gdblock);
878  if (!gdb_bh)
879  return -EIO;
880  n_group_desc = ext4_kvmalloc((gdb_num + 1) *
881  sizeof(struct buffer_head *),
882  GFP_NOFS);
883  if (!n_group_desc) {
884  err = -ENOMEM;
885  ext4_warning(sb, "not enough memory for %lu groups",
886  gdb_num + 1);
887  return err;
888  }
889 
890  o_group_desc = EXT4_SB(sb)->s_group_desc;
891  memcpy(n_group_desc, o_group_desc,
892  EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *));
893  n_group_desc[gdb_num] = gdb_bh;
894  EXT4_SB(sb)->s_group_desc = n_group_desc;
895  EXT4_SB(sb)->s_gdb_count++;
896  ext4_kvfree(o_group_desc);
897  err = ext4_journal_get_write_access(handle, gdb_bh);
898  if (unlikely(err))
899  brelse(gdb_bh);
900  return err;
901 }
902 
903 /*
904  * Called when we are adding a new group which has a backup copy of each of
905  * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks.
906  * We need to add these reserved backup GDT blocks to the resize inode, so
907  * that they are kept for future resizing and not allocated to files.
908  *
909  * Each reserved backup GDT block will go into a different indirect block.
910  * The indirect blocks are actually the primary reserved GDT blocks,
911  * so we know in advance what their block numbers are. We only get the
912  * double-indirect block to verify it is pointing to the primary reserved
913  * GDT blocks so we don't overwrite a data block by accident. The reserved
914  * backup GDT blocks are stored in their reserved primary GDT block.
915  */
916 static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
917  ext4_group_t group)
918 {
919  struct super_block *sb = inode->i_sb;
920  int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks);
921  struct buffer_head **primary;
922  struct buffer_head *dind;
923  struct ext4_iloc iloc;
925  __le32 *data, *end;
926  int gdbackups = 0;
927  int res, i;
928  int err;
929 
930  primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS);
931  if (!primary)
932  return -ENOMEM;
933 
934  data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK;
935  dind = sb_bread(sb, le32_to_cpu(*data));
936  if (!dind) {
937  err = -EIO;
938  goto exit_free;
939  }
940 
941  blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count;
942  data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count %
943  EXT4_ADDR_PER_BLOCK(sb));
944  end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb);
945 
946  /* Get each reserved primary GDT block and verify it holds backups */
947  for (res = 0; res < reserved_gdb; res++, blk++) {
948  if (le32_to_cpu(*data) != blk) {
949  ext4_warning(sb, "reserved block %llu"
950  " not at offset %ld",
951  blk,
952  (long)(data - (__le32 *)dind->b_data));
953  err = -EINVAL;
954  goto exit_bh;
955  }
956  primary[res] = sb_bread(sb, blk);
957  if (!primary[res]) {
958  err = -EIO;
959  goto exit_bh;
960  }
961  gdbackups = verify_reserved_gdb(sb, group, primary[res]);
962  if (gdbackups < 0) {
963  brelse(primary[res]);
964  err = gdbackups;
965  goto exit_bh;
966  }
967  if (++data >= end)
968  data = (__le32 *)dind->b_data;
969  }
970 
971  for (i = 0; i < reserved_gdb; i++) {
972  if ((err = ext4_journal_get_write_access(handle, primary[i]))) {
973  /*
974  int j;
975  for (j = 0; j < i; j++)
976  ext4_handle_release_buffer(handle, primary[j]);
977  */
978  goto exit_bh;
979  }
980  }
981 
982  if ((err = ext4_reserve_inode_write(handle, inode, &iloc)))
983  goto exit_bh;
984 
985  /*
986  * Finally we can add each of the reserved backup GDT blocks from
987  * the new group to its reserved primary GDT block.
988  */
989  blk = group * EXT4_BLOCKS_PER_GROUP(sb);
990  for (i = 0; i < reserved_gdb; i++) {
991  int err2;
992  data = (__le32 *)primary[i]->b_data;
993  /* printk("reserving backup %lu[%u] = %lu\n",
994  primary[i]->b_blocknr, gdbackups,
995  blk + primary[i]->b_blocknr); */
996  data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr);
997  err2 = ext4_handle_dirty_metadata(handle, NULL, primary[i]);
998  if (!err)
999  err = err2;
1000  }
1001  inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9;
1002  ext4_mark_iloc_dirty(handle, inode, &iloc);
1003 
1004 exit_bh:
1005  while (--res >= 0)
1006  brelse(primary[res]);
1007  brelse(dind);
1008 
1009 exit_free:
1010  kfree(primary);
1011 
1012  return err;
1013 }
1014 
1015 /*
1016  * Update the backup copies of the ext4 metadata. These don't need to be part
1017  * of the main resize transaction, because e2fsck will re-write them if there
1018  * is a problem (basically only OOM will cause a problem). However, we
1019  * _should_ update the backups if possible, in case the primary gets trashed
1020  * for some reason and we need to run e2fsck from a backup superblock. The
1021  * important part is that the new block and inode counts are in the backup
1022  * superblocks, and the location of the new group metadata in the GDT backups.
1023  *
1024  * We do not need take the s_resize_lock for this, because these
1025  * blocks are not otherwise touched by the filesystem code when it is
1026  * mounted. We don't need to worry about last changing from
1027  * sbi->s_groups_count, because the worst that can happen is that we
1028  * do not copy the full number of backups at this time. The resize
1029  * which changed s_groups_count will backup again.
1030  */
1031 static void update_backups(struct super_block *sb, int blk_off, char *data,
1032  int size, int meta_bg)
1033 {
1034  struct ext4_sb_info *sbi = EXT4_SB(sb);
1036  const int bpg = EXT4_BLOCKS_PER_GROUP(sb);
1037  unsigned three = 1;
1038  unsigned five = 5;
1039  unsigned seven = 7;
1040  ext4_group_t group = 0;
1041  int rest = sb->s_blocksize - size;
1042  handle_t *handle;
1043  int err = 0, err2;
1044 
1046  if (IS_ERR(handle)) {
1047  group = 1;
1048  err = PTR_ERR(handle);
1049  goto exit_err;
1050  }
1051 
1052  if (meta_bg == 0) {
1053  group = ext4_list_backups(sb, &three, &five, &seven);
1054  last = sbi->s_groups_count;
1055  } else {
1056  group = ext4_meta_bg_first_group(sb, group) + 1;
1057  last = (ext4_group_t)(group + EXT4_DESC_PER_BLOCK(sb) - 2);
1058  }
1059 
1060  while (group < sbi->s_groups_count) {
1061  struct buffer_head *bh;
1062  ext4_fsblk_t backup_block;
1063 
1064  /* Out of journal space, and can't get more - abort - so sad */
1065  if (ext4_handle_valid(handle) &&
1066  handle->h_buffer_credits == 0 &&
1067  ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) &&
1068  (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA)))
1069  break;
1070 
1071  if (meta_bg == 0)
1072  backup_block = group * bpg + blk_off;
1073  else
1074  backup_block = (ext4_group_first_block_no(sb, group) +
1075  ext4_bg_has_super(sb, group));
1076 
1077  bh = sb_getblk(sb, backup_block);
1078  if (!bh) {
1079  err = -EIO;
1080  break;
1081  }
1082  ext4_debug("update metadata backup %llu(+%llu)\n",
1083  backup_block, backup_block -
1084  ext4_group_first_block_no(sb, group));
1085  if ((err = ext4_journal_get_write_access(handle, bh)))
1086  break;
1087  lock_buffer(bh);
1088  memcpy(bh->b_data, data, size);
1089  if (rest)
1090  memset(bh->b_data + size, 0, rest);
1091  set_buffer_uptodate(bh);
1092  unlock_buffer(bh);
1093  err = ext4_handle_dirty_metadata(handle, NULL, bh);
1094  if (unlikely(err))
1095  ext4_std_error(sb, err);
1096  brelse(bh);
1097 
1098  if (meta_bg == 0)
1099  group = ext4_list_backups(sb, &three, &five, &seven);
1100  else if (group == last)
1101  break;
1102  else
1103  group = last;
1104  }
1105  if ((err2 = ext4_journal_stop(handle)) && !err)
1106  err = err2;
1107 
1108  /*
1109  * Ugh! Need to have e2fsck write the backup copies. It is too
1110  * late to revert the resize, we shouldn't fail just because of
1111  * the backup copies (they are only needed in case of corruption).
1112  *
1113  * However, if we got here we have a journal problem too, so we
1114  * can't really start a transaction to mark the superblock.
1115  * Chicken out and just set the flag on the hope it will be written
1116  * to disk, and if not - we will simply wait until next fsck.
1117  */
1118 exit_err:
1119  if (err) {
1120  ext4_warning(sb, "can't update backup for group %u (err %d), "
1121  "forcing fsck on next reboot", group, err);
1122  sbi->s_mount_state &= ~EXT4_VALID_FS;
1123  sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
1124  mark_buffer_dirty(sbi->s_sbh);
1125  }
1126 }
1127 
1128 /*
1129  * ext4_add_new_descs() adds @count group descriptor of groups
1130  * starting at @group
1131  *
1132  * @handle: journal handle
1133  * @sb: super block
1134  * @group: the group no. of the first group desc to be added
1135  * @resize_inode: the resize inode
1136  * @count: number of group descriptors to be added
1137  */
1138 static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,
1139  ext4_group_t group, struct inode *resize_inode,
1140  ext4_group_t count)
1141 {
1142  struct ext4_sb_info *sbi = EXT4_SB(sb);
1143  struct ext4_super_block *es = sbi->s_es;
1144  struct buffer_head *gdb_bh;
1145  int i, gdb_off, gdb_num, err = 0;
1146  int meta_bg;
1147 
1149  for (i = 0; i < count; i++, group++) {
1150  int reserved_gdb = ext4_bg_has_super(sb, group) ?
1152 
1153  gdb_off = group % EXT4_DESC_PER_BLOCK(sb);
1154  gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
1155 
1156  /*
1157  * We will only either add reserved group blocks to a backup group
1158  * or remove reserved blocks for the first group in a new group block.
1159  * Doing both would be mean more complex code, and sane people don't
1160  * use non-sparse filesystems anymore. This is already checked above.
1161  */
1162  if (gdb_off) {
1163  gdb_bh = sbi->s_group_desc[gdb_num];
1164  err = ext4_journal_get_write_access(handle, gdb_bh);
1165 
1166  if (!err && reserved_gdb && ext4_bg_num_gdb(sb, group))
1167  err = reserve_backup_gdb(handle, resize_inode, group);
1168  } else if (meta_bg != 0) {
1169  err = add_new_gdb_meta_bg(sb, handle, group);
1170  } else {
1171  err = add_new_gdb(handle, resize_inode, group);
1172  }
1173  if (err)
1174  break;
1175  }
1176  return err;
1177 }
1178 
1179 static struct buffer_head *ext4_get_bitmap(struct super_block *sb, __u64 block)
1180 {
1181  struct buffer_head *bh = sb_getblk(sb, block);
1182  if (!bh)
1183  return NULL;
1184  if (!bh_uptodate_or_lock(bh)) {
1185  if (bh_submit_read(bh) < 0) {
1186  brelse(bh);
1187  return NULL;
1188  }
1189  }
1190 
1191  return bh;
1192 }
1193 
1194 static int ext4_set_bitmap_checksums(struct super_block *sb,
1195  ext4_group_t group,
1196  struct ext4_group_desc *gdp,
1197  struct ext4_new_group_data *group_data)
1198 {
1199  struct buffer_head *bh;
1200 
1203  return 0;
1204 
1205  bh = ext4_get_bitmap(sb, group_data->inode_bitmap);
1206  if (!bh)
1207  return -EIO;
1208  ext4_inode_bitmap_csum_set(sb, group, gdp, bh,
1209  EXT4_INODES_PER_GROUP(sb) / 8);
1210  brelse(bh);
1211 
1212  bh = ext4_get_bitmap(sb, group_data->block_bitmap);
1213  if (!bh)
1214  return -EIO;
1215  ext4_block_bitmap_csum_set(sb, group, gdp, bh);
1216  brelse(bh);
1217 
1218  return 0;
1219 }
1220 
1221 /*
1222  * ext4_setup_new_descs() will set up the group descriptor descriptors of a flex bg
1223  */
1224 static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb,
1225  struct ext4_new_flex_group_data *flex_gd)
1226 {
1227  struct ext4_new_group_data *group_data = flex_gd->groups;
1228  struct ext4_group_desc *gdp;
1229  struct ext4_sb_info *sbi = EXT4_SB(sb);
1230  struct buffer_head *gdb_bh;
1232  __u16 *bg_flags = flex_gd->bg_flags;
1233  int i, gdb_off, gdb_num, err = 0;
1234 
1235 
1236  for (i = 0; i < flex_gd->count; i++, group_data++, bg_flags++) {
1237  group = group_data->group;
1238 
1239  gdb_off = group % EXT4_DESC_PER_BLOCK(sb);
1240  gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
1241 
1242  /*
1243  * get_write_access() has been called on gdb_bh by ext4_add_new_desc().
1244  */
1245  gdb_bh = sbi->s_group_desc[gdb_num];
1246  /* Update group descriptor block for new group */
1247  gdp = (struct ext4_group_desc *)(gdb_bh->b_data +
1248  gdb_off * EXT4_DESC_SIZE(sb));
1249 
1250  memset(gdp, 0, EXT4_DESC_SIZE(sb));
1251  ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap);
1252  ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap);
1253  err = ext4_set_bitmap_checksums(sb, group, gdp, group_data);
1254  if (err) {
1255  ext4_std_error(sb, err);
1256  break;
1257  }
1258 
1259  ext4_inode_table_set(sb, gdp, group_data->inode_table);
1261  EXT4_B2C(sbi, group_data->free_blocks_count));
1263  if (ext4_has_group_desc_csum(sb))
1264  ext4_itable_unused_set(sb, gdp,
1265  EXT4_INODES_PER_GROUP(sb));
1266  gdp->bg_flags = cpu_to_le16(*bg_flags);
1267  ext4_group_desc_csum_set(sb, group, gdp);
1268 
1269  err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh);
1270  if (unlikely(err)) {
1271  ext4_std_error(sb, err);
1272  break;
1273  }
1274 
1275  /*
1276  * We can allocate memory for mb_alloc based on the new group
1277  * descriptor
1278  */
1279  err = ext4_mb_add_groupinfo(sb, group, gdp);
1280  if (err)
1281  break;
1282  }
1283  return err;
1284 }
1285 
1286 /*
1287  * ext4_update_super() updates the super block so that the newly added
1288  * groups can be seen by the filesystem.
1289  *
1290  * @sb: super block
1291  * @flex_gd: new added groups
1292  */
1293 static void ext4_update_super(struct super_block *sb,
1294  struct ext4_new_flex_group_data *flex_gd)
1295 {
1296  ext4_fsblk_t blocks_count = 0;
1297  ext4_fsblk_t free_blocks = 0;
1298  ext4_fsblk_t reserved_blocks = 0;
1299  struct ext4_new_group_data *group_data = flex_gd->groups;
1300  struct ext4_sb_info *sbi = EXT4_SB(sb);
1301  struct ext4_super_block *es = sbi->s_es;
1302  int i;
1303 
1304  BUG_ON(flex_gd->count == 0 || group_data == NULL);
1305  /*
1306  * Make the new blocks and inodes valid next. We do this before
1307  * increasing the group count so that once the group is enabled,
1308  * all of its blocks and inodes are already valid.
1309  *
1310  * We always allocate group-by-group, then block-by-block or
1311  * inode-by-inode within a group, so enabling these
1312  * blocks/inodes before the group is live won't actually let us
1313  * allocate the new space yet.
1314  */
1315  for (i = 0; i < flex_gd->count; i++) {
1316  blocks_count += group_data[i].blocks_count;
1317  free_blocks += group_data[i].free_blocks_count;
1318  }
1319 
1320  reserved_blocks = ext4_r_blocks_count(es) * 100;
1321  reserved_blocks = div64_u64(reserved_blocks, ext4_blocks_count(es));
1322  reserved_blocks *= blocks_count;
1323  do_div(reserved_blocks, 100);
1324 
1325  ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count);
1326  ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + free_blocks);
1327  le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) *
1328  flex_gd->count);
1329  le32_add_cpu(&es->s_free_inodes_count, EXT4_INODES_PER_GROUP(sb) *
1330  flex_gd->count);
1331 
1332  ext4_debug("free blocks count %llu", ext4_free_blocks_count(es));
1333  /*
1334  * We need to protect s_groups_count against other CPUs seeing
1335  * inconsistent state in the superblock.
1336  *
1337  * The precise rules we use are:
1338  *
1339  * * Writers must perform a smp_wmb() after updating all
1340  * dependent data and before modifying the groups count
1341  *
1342  * * Readers must perform an smp_rmb() after reading the groups
1343  * count and before reading any dependent data.
1344  *
1345  * NB. These rules can be relaxed when checking the group count
1346  * while freeing data, as we can only allocate from a block
1347  * group after serialising against the group count, and we can
1348  * only then free after serialising in turn against that
1349  * allocation.
1350  */
1351  smp_wmb();
1352 
1353  /* Update the global fs size fields */
1354  sbi->s_groups_count += flex_gd->count;
1355 
1356  /* Update the reserved block counts only once the new group is
1357  * active. */
1358  ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
1359  reserved_blocks);
1360 
1361  /* Update the free space counts */
1362  percpu_counter_add(&sbi->s_freeclusters_counter,
1363  EXT4_B2C(sbi, free_blocks));
1364  percpu_counter_add(&sbi->s_freeinodes_counter,
1365  EXT4_INODES_PER_GROUP(sb) * flex_gd->count);
1366 
1367  ext4_debug("free blocks count %llu",
1368  percpu_counter_read(&sbi->s_freeclusters_counter));
1371  sbi->s_log_groups_per_flex) {
1372  ext4_group_t flex_group;
1373  flex_group = ext4_flex_group(sbi, group_data[0].group);
1374  atomic_add(EXT4_B2C(sbi, free_blocks),
1375  &sbi->s_flex_groups[flex_group].free_clusters);
1376  atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count,
1377  &sbi->s_flex_groups[flex_group].free_inodes);
1378  }
1379 
1380  /*
1381  * Update the fs overhead information
1382  */
1384 
1385  if (test_opt(sb, DEBUG))
1386  printk(KERN_DEBUG "EXT4-fs: added group %u:"
1387  "%llu blocks(%llu free %llu reserved)\n", flex_gd->count,
1388  blocks_count, free_blocks, reserved_blocks);
1389 }
1390 
1391 /* Add a flex group to an fs. Ensure we handle all possible error conditions
1392  * _before_ we start modifying the filesystem, because we cannot abort the
1393  * transaction and not have it write the data to disk.
1394  */
1395 static int ext4_flex_group_add(struct super_block *sb,
1396  struct inode *resize_inode,
1397  struct ext4_new_flex_group_data *flex_gd)
1398 {
1399  struct ext4_sb_info *sbi = EXT4_SB(sb);
1400  struct ext4_super_block *es = sbi->s_es;
1401  ext4_fsblk_t o_blocks_count;
1402  ext4_grpblk_t last;
1404  handle_t *handle;
1405  unsigned reserved_gdb;
1406  int err = 0, err2 = 0, credit;
1407 
1408  BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags);
1409 
1410  reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
1411  o_blocks_count = ext4_blocks_count(es);
1412  ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1413  BUG_ON(last);
1414 
1415  err = setup_new_flex_group_blocks(sb, flex_gd);
1416  if (err)
1417  goto exit;
1418  /*
1419  * We will always be modifying at least the superblock and GDT
1420  * block. If we are adding a group past the last current GDT block,
1421  * we will also modify the inode and the dindirect block. If we
1422  * are adding a group with superblock/GDT backups we will also
1423  * modify each of the reserved GDT dindirect blocks.
1424  */
1425  credit = flex_gd->count * 4 + reserved_gdb;
1426  handle = ext4_journal_start_sb(sb, credit);
1427  if (IS_ERR(handle)) {
1428  err = PTR_ERR(handle);
1429  goto exit;
1430  }
1431 
1432  err = ext4_journal_get_write_access(handle, sbi->s_sbh);
1433  if (err)
1434  goto exit_journal;
1435 
1436  group = flex_gd->groups[0].group;
1437  BUG_ON(group != EXT4_SB(sb)->s_groups_count);
1438  err = ext4_add_new_descs(handle, sb, group,
1439  resize_inode, flex_gd->count);
1440  if (err)
1441  goto exit_journal;
1442 
1443  err = ext4_setup_new_descs(handle, sb, flex_gd);
1444  if (err)
1445  goto exit_journal;
1446 
1447  ext4_update_super(sb, flex_gd);
1448 
1449  err = ext4_handle_dirty_super(handle, sb);
1450 
1451 exit_journal:
1452  err2 = ext4_journal_stop(handle);
1453  if (!err)
1454  err = err2;
1455 
1456  if (!err) {
1457  int gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
1458  int gdb_num_end = ((group + flex_gd->count - 1) /
1459  EXT4_DESC_PER_BLOCK(sb));
1460  int meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb,
1462  sector_t old_gdb = 0;
1463 
1464  update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es,
1465  sizeof(struct ext4_super_block), 0);
1466  for (; gdb_num <= gdb_num_end; gdb_num++) {
1467  struct buffer_head *gdb_bh;
1468 
1469  gdb_bh = sbi->s_group_desc[gdb_num];
1470  if (old_gdb == gdb_bh->b_blocknr)
1471  continue;
1472  update_backups(sb, gdb_bh->b_blocknr, gdb_bh->b_data,
1473  gdb_bh->b_size, meta_bg);
1474  old_gdb = gdb_bh->b_blocknr;
1475  }
1476  }
1477 exit:
1478  return err;
1479 }
1480 
1481 static int ext4_setup_next_flex_gd(struct super_block *sb,
1482  struct ext4_new_flex_group_data *flex_gd,
1483  ext4_fsblk_t n_blocks_count,
1484  unsigned long flexbg_size)
1485 {
1486  struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1487  struct ext4_new_group_data *group_data = flex_gd->groups;
1488  ext4_fsblk_t o_blocks_count;
1489  ext4_group_t n_group;
1491  ext4_group_t last_group;
1492  ext4_grpblk_t last;
1493  ext4_grpblk_t blocks_per_group;
1494  unsigned long i;
1495 
1496  blocks_per_group = EXT4_BLOCKS_PER_GROUP(sb);
1497 
1498  o_blocks_count = ext4_blocks_count(es);
1499 
1500  if (o_blocks_count == n_blocks_count)
1501  return 0;
1502 
1503  ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1504  BUG_ON(last);
1505  ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last);
1506 
1507  last_group = group | (flexbg_size - 1);
1508  if (last_group > n_group)
1509  last_group = n_group;
1510 
1511  flex_gd->count = last_group - group + 1;
1512 
1513  for (i = 0; i < flex_gd->count; i++) {
1514  int overhead;
1515 
1516  group_data[i].group = group + i;
1517  group_data[i].blocks_count = blocks_per_group;
1518  overhead = ext4_group_overhead_blocks(sb, group + i);
1519  group_data[i].free_blocks_count = blocks_per_group - overhead;
1520  if (ext4_has_group_desc_csum(sb))
1521  flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT |
1523  else
1524  flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED;
1525  }
1526 
1527  if (last_group == n_group && ext4_has_group_desc_csum(sb))
1528  /* We need to initialize block bitmap of last group. */
1529  flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT;
1530 
1531  if ((last_group == n_group) && (last != blocks_per_group - 1)) {
1532  group_data[i - 1].blocks_count = last + 1;
1533  group_data[i - 1].free_blocks_count -= blocks_per_group-
1534  last - 1;
1535  }
1536 
1537  return 1;
1538 }
1539 
1540 /* Add group descriptor data to an existing or new group descriptor block.
1541  * Ensure we handle all possible error conditions _before_ we start modifying
1542  * the filesystem, because we cannot abort the transaction and not have it
1543  * write the data to disk.
1544  *
1545  * If we are on a GDT block boundary, we need to get the reserved GDT block.
1546  * Otherwise, we may need to add backup GDT blocks for a sparse group.
1547  *
1548  * We only need to hold the superblock lock while we are actually adding
1549  * in the new group's counts to the superblock. Prior to that we have
1550  * not really "added" the group at all. We re-check that we are still
1551  * adding in the last group in case things have changed since verifying.
1552  */
1554 {
1555  struct ext4_new_flex_group_data flex_gd;
1556  struct ext4_sb_info *sbi = EXT4_SB(sb);
1557  struct ext4_super_block *es = sbi->s_es;
1558  int reserved_gdb = ext4_bg_has_super(sb, input->group) ?
1560  struct inode *inode = NULL;
1561  int gdb_off, gdb_num;
1562  int err;
1563  __u16 bg_flags = 0;
1564 
1565  gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb);
1566  gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb);
1567 
1568  if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
1570  ext4_warning(sb, "Can't resize non-sparse filesystem further");
1571  return -EPERM;
1572  }
1573 
1574  if (ext4_blocks_count(es) + input->blocks_count <
1575  ext4_blocks_count(es)) {
1576  ext4_warning(sb, "blocks_count overflow");
1577  return -EINVAL;
1578  }
1579 
1581  le32_to_cpu(es->s_inodes_count)) {
1582  ext4_warning(sb, "inodes_count overflow");
1583  return -EINVAL;
1584  }
1585 
1586  if (reserved_gdb || gdb_off == 0) {
1587  if (!EXT4_HAS_COMPAT_FEATURE(sb,
1590  ext4_warning(sb,
1591  "No reserved GDT blocks, can't resize");
1592  return -EPERM;
1593  }
1594  inode = ext4_iget(sb, EXT4_RESIZE_INO);
1595  if (IS_ERR(inode)) {
1596  ext4_warning(sb, "Error opening resize inode");
1597  return PTR_ERR(inode);
1598  }
1599  }
1600 
1601 
1602  err = verify_group_input(sb, input);
1603  if (err)
1604  goto out;
1605 
1606  err = ext4_alloc_flex_bg_array(sb, input->group + 1);
1607  if (err)
1608  return err;
1609 
1610  err = ext4_mb_alloc_groupinfo(sb, input->group + 1);
1611  if (err)
1612  goto out;
1613 
1614  flex_gd.count = 1;
1615  flex_gd.groups = input;
1616  flex_gd.bg_flags = &bg_flags;
1617  err = ext4_flex_group_add(sb, inode, &flex_gd);
1618 out:
1619  iput(inode);
1620  return err;
1621 } /* ext4_group_add */
1622 
1623 /*
1624  * extend a group without checking assuming that checking has been done.
1625  */
1626 static int ext4_group_extend_no_check(struct super_block *sb,
1627  ext4_fsblk_t o_blocks_count, ext4_grpblk_t add)
1628 {
1629  struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1630  handle_t *handle;
1631  int err = 0, err2;
1632 
1633  /* We will update the superblock, one block bitmap, and
1634  * one group descriptor via ext4_group_add_blocks().
1635  */
1636  handle = ext4_journal_start_sb(sb, 3);
1637  if (IS_ERR(handle)) {
1638  err = PTR_ERR(handle);
1639  ext4_warning(sb, "error %d on journal start", err);
1640  return err;
1641  }
1642 
1643  err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
1644  if (err) {
1645  ext4_warning(sb, "error %d on journal write access", err);
1646  goto errout;
1647  }
1648 
1649  ext4_blocks_count_set(es, o_blocks_count + add);
1650  ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + add);
1651  ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
1652  o_blocks_count + add);
1653  /* We add the blocks to the bitmap and set the group need init bit */
1654  err = ext4_group_add_blocks(handle, sb, o_blocks_count, add);
1655  if (err)
1656  goto errout;
1657  ext4_handle_dirty_super(handle, sb);
1658  ext4_debug("freed blocks %llu through %llu\n", o_blocks_count,
1659  o_blocks_count + add);
1660 errout:
1661  err2 = ext4_journal_stop(handle);
1662  if (err2 && !err)
1663  err = err2;
1664 
1665  if (!err) {
1666  ext4_fsblk_t first_block;
1667  first_block = ext4_group_first_block_no(sb, 0);
1668  if (test_opt(sb, DEBUG))
1669  printk(KERN_DEBUG "EXT4-fs: extended group to %llu "
1670  "blocks\n", ext4_blocks_count(es));
1671  update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr - first_block,
1672  (char *)es, sizeof(struct ext4_super_block), 0);
1673  }
1674  return err;
1675 }
1676 
1677 /*
1678  * Extend the filesystem to the new number of blocks specified. This entry
1679  * point is only used to extend the current filesystem to the end of the last
1680  * existing group. It can be accessed via ioctl, or by "remount,resize=<size>"
1681  * for emergencies (because it has no dependencies on reserved blocks).
1682  *
1683  * If we _really_ wanted, we could use default values to call ext4_group_add()
1684  * allow the "remount" trick to work for arbitrary resizing, assuming enough
1685  * GDT blocks are reserved to grow to the desired size.
1686  */
1688  ext4_fsblk_t n_blocks_count)
1689 {
1690  ext4_fsblk_t o_blocks_count;
1691  ext4_grpblk_t last;
1693  struct buffer_head *bh;
1694  int err;
1696 
1697  o_blocks_count = ext4_blocks_count(es);
1698 
1699  if (test_opt(sb, DEBUG))
1700  ext4_msg(sb, KERN_DEBUG,
1701  "extending last group from %llu to %llu blocks",
1702  o_blocks_count, n_blocks_count);
1703 
1704  if (n_blocks_count == 0 || n_blocks_count == o_blocks_count)
1705  return 0;
1706 
1707  if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
1708  ext4_msg(sb, KERN_ERR,
1709  "filesystem too large to resize to %llu blocks safely",
1710  n_blocks_count);
1711  if (sizeof(sector_t) < 8)
1712  ext4_warning(sb, "CONFIG_LBDAF not enabled");
1713  return -EINVAL;
1714  }
1715 
1716  if (n_blocks_count < o_blocks_count) {
1717  ext4_warning(sb, "can't shrink FS - resize aborted");
1718  return -EINVAL;
1719  }
1720 
1721  /* Handle the remaining blocks in the last group only. */
1722  ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1723 
1724  if (last == 0) {
1725  ext4_warning(sb, "need to use ext2online to resize further");
1726  return -EPERM;
1727  }
1728 
1729  add = EXT4_BLOCKS_PER_GROUP(sb) - last;
1730 
1731  if (o_blocks_count + add < o_blocks_count) {
1732  ext4_warning(sb, "blocks_count overflow");
1733  return -EINVAL;
1734  }
1735 
1736  if (o_blocks_count + add > n_blocks_count)
1737  add = n_blocks_count - o_blocks_count;
1738 
1739  if (o_blocks_count + add < n_blocks_count)
1740  ext4_warning(sb, "will only finish group (%llu blocks, %u new)",
1741  o_blocks_count + add, add);
1742 
1743  /* See if the device is actually as big as what was requested */
1744  bh = sb_bread(sb, o_blocks_count + add - 1);
1745  if (!bh) {
1746  ext4_warning(sb, "can't read last block, resize aborted");
1747  return -ENOSPC;
1748  }
1749  brelse(bh);
1750 
1751  err = ext4_group_extend_no_check(sb, o_blocks_count, add);
1752  return err;
1753 } /* ext4_group_extend */
1754 
1755 
1756 static int num_desc_blocks(struct super_block *sb, ext4_group_t groups)
1757 {
1758  return (groups + EXT4_DESC_PER_BLOCK(sb) - 1) / EXT4_DESC_PER_BLOCK(sb);
1759 }
1760 
1761 /*
1762  * Release the resize inode and drop the resize_inode feature if there
1763  * are no more reserved gdt blocks, and then convert the file system
1764  * to enable meta_bg
1765  */
1766 static int ext4_convert_meta_bg(struct super_block *sb, struct inode *inode)
1767 {
1768  handle_t *handle;
1769  struct ext4_sb_info *sbi = EXT4_SB(sb);
1770  struct ext4_super_block *es = sbi->s_es;
1771  struct ext4_inode_info *ei = EXT4_I(inode);
1772  ext4_fsblk_t nr;
1773  int i, ret, err = 0;
1774  int credits = 1;
1775 
1776  ext4_msg(sb, KERN_INFO, "Converting file system to meta_bg");
1777  if (inode) {
1778  if (es->s_reserved_gdt_blocks) {
1779  ext4_error(sb, "Unexpected non-zero "
1780  "s_reserved_gdt_blocks");
1781  return -EPERM;
1782  }
1783 
1784  /* Do a quick sanity check of the resize inode */
1785  if (inode->i_blocks != 1 << (inode->i_blkbits - 9))
1786  goto invalid_resize_inode;
1787  for (i = 0; i < EXT4_N_BLOCKS; i++) {
1788  if (i == EXT4_DIND_BLOCK) {
1789  if (ei->i_data[i])
1790  continue;
1791  else
1792  goto invalid_resize_inode;
1793  }
1794  if (ei->i_data[i])
1795  goto invalid_resize_inode;
1796  }
1797  credits += 3; /* block bitmap, bg descriptor, resize inode */
1798  }
1799 
1800  handle = ext4_journal_start_sb(sb, credits);
1801  if (IS_ERR(handle))
1802  return PTR_ERR(handle);
1803 
1804  err = ext4_journal_get_write_access(handle, sbi->s_sbh);
1805  if (err)
1806  goto errout;
1807 
1810  sbi->s_es->s_first_meta_bg =
1811  cpu_to_le32(num_desc_blocks(sb, sbi->s_groups_count));
1812 
1813  err = ext4_handle_dirty_super(handle, sb);
1814  if (err) {
1815  ext4_std_error(sb, err);
1816  goto errout;
1817  }
1818 
1819  if (inode) {
1820  nr = le32_to_cpu(ei->i_data[EXT4_DIND_BLOCK]);
1821  ext4_free_blocks(handle, inode, NULL, nr, 1,
1824  ei->i_data[EXT4_DIND_BLOCK] = 0;
1825  inode->i_blocks = 0;
1826 
1827  err = ext4_mark_inode_dirty(handle, inode);
1828  if (err)
1829  ext4_std_error(sb, err);
1830  }
1831 
1832 errout:
1833  ret = ext4_journal_stop(handle);
1834  if (!err)
1835  err = ret;
1836  return ret;
1837 
1838 invalid_resize_inode:
1839  ext4_error(sb, "corrupted/inconsistent resize inode");
1840  return -EINVAL;
1841 }
1842 
1843 /*
1844  * ext4_resize_fs() resizes a fs to new size specified by @n_blocks_count
1845  *
1846  * @sb: super block of the fs to be resized
1847  * @n_blocks_count: the number of blocks resides in the resized fs
1848  */
1849 int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)
1850 {
1851  struct ext4_new_flex_group_data *flex_gd = NULL;
1852  struct ext4_sb_info *sbi = EXT4_SB(sb);
1853  struct ext4_super_block *es = sbi->s_es;
1854  struct buffer_head *bh;
1855  struct inode *resize_inode = NULL;
1857  unsigned long n_desc_blocks;
1858  unsigned long o_desc_blocks;
1859  ext4_group_t o_group;
1860  ext4_group_t n_group;
1861  ext4_fsblk_t o_blocks_count;
1862  ext4_fsblk_t n_blocks_count_retry = 0;
1863  unsigned long last_update_time = 0;
1864  int err = 0, flexbg_size = 1 << sbi->s_log_groups_per_flex;
1865  int meta_bg;
1866 
1867  /* See if the device is actually as big as what was requested */
1868  bh = sb_bread(sb, n_blocks_count - 1);
1869  if (!bh) {
1870  ext4_warning(sb, "can't read last block, resize aborted");
1871  return -ENOSPC;
1872  }
1873  brelse(bh);
1874 
1875 retry:
1876  o_blocks_count = ext4_blocks_count(es);
1877 
1878  ext4_msg(sb, KERN_INFO, "resizing filesystem from %llu "
1879  "to %llu blocks", o_blocks_count, n_blocks_count);
1880 
1881  if (n_blocks_count < o_blocks_count) {
1882  /* On-line shrinking not supported */
1883  ext4_warning(sb, "can't shrink FS - resize aborted");
1884  return -EINVAL;
1885  }
1886 
1887  if (n_blocks_count == o_blocks_count)
1888  /* Nothing need to do */
1889  return 0;
1890 
1891  ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &offset);
1892  ext4_get_group_no_and_offset(sb, o_blocks_count - 1, &o_group, &offset);
1893 
1894  n_desc_blocks = num_desc_blocks(sb, n_group + 1);
1895  o_desc_blocks = num_desc_blocks(sb, sbi->s_groups_count);
1896 
1898 
1900  if (meta_bg) {
1901  ext4_error(sb, "resize_inode and meta_bg enabled "
1902  "simultaneously");
1903  return -EINVAL;
1904  }
1905  if (n_desc_blocks > o_desc_blocks +
1907  n_blocks_count_retry = n_blocks_count;
1908  n_desc_blocks = o_desc_blocks +
1910  n_group = n_desc_blocks * EXT4_DESC_PER_BLOCK(sb);
1911  n_blocks_count = n_group * EXT4_BLOCKS_PER_GROUP(sb);
1912  n_group--; /* set to last group number */
1913  }
1914 
1915  if (!resize_inode)
1916  resize_inode = ext4_iget(sb, EXT4_RESIZE_INO);
1917  if (IS_ERR(resize_inode)) {
1918  ext4_warning(sb, "Error opening resize inode");
1919  return PTR_ERR(resize_inode);
1920  }
1921  }
1922 
1923  if ((!resize_inode && !meta_bg) || n_blocks_count == o_blocks_count) {
1924  err = ext4_convert_meta_bg(sb, resize_inode);
1925  if (err)
1926  goto out;
1927  if (resize_inode) {
1928  iput(resize_inode);
1929  resize_inode = NULL;
1930  }
1931  if (n_blocks_count_retry) {
1932  n_blocks_count = n_blocks_count_retry;
1933  n_blocks_count_retry = 0;
1934  goto retry;
1935  }
1936  }
1937 
1938  /* extend the last group */
1939  if (n_group == o_group)
1940  add = n_blocks_count - o_blocks_count;
1941  else
1942  add = EXT4_BLOCKS_PER_GROUP(sb) - (offset + 1);
1943  if (add > 0) {
1944  err = ext4_group_extend_no_check(sb, o_blocks_count, add);
1945  if (err)
1946  goto out;
1947  }
1948 
1949  if (ext4_blocks_count(es) == n_blocks_count)
1950  goto out;
1951 
1952  err = ext4_alloc_flex_bg_array(sb, n_group + 1);
1953  if (err)
1954  return err;
1955 
1956  err = ext4_mb_alloc_groupinfo(sb, n_group + 1);
1957  if (err)
1958  goto out;
1959 
1960  flex_gd = alloc_flex_gd(flexbg_size);
1961  if (flex_gd == NULL) {
1962  err = -ENOMEM;
1963  goto out;
1964  }
1965 
1966  /* Add flex groups. Note that a regular group is a
1967  * flex group with 1 group.
1968  */
1969  while (ext4_setup_next_flex_gd(sb, flex_gd, n_blocks_count,
1970  flexbg_size)) {
1971  if (jiffies - last_update_time > HZ * 10) {
1972  if (last_update_time)
1973  ext4_msg(sb, KERN_INFO,
1974  "resized to %llu blocks",
1975  ext4_blocks_count(es));
1976  last_update_time = jiffies;
1977  }
1978  if (ext4_alloc_group_tables(sb, flex_gd, flexbg_size) != 0)
1979  break;
1980  err = ext4_flex_group_add(sb, resize_inode, flex_gd);
1981  if (unlikely(err))
1982  break;
1983  }
1984 
1985  if (!err && n_blocks_count_retry) {
1986  n_blocks_count = n_blocks_count_retry;
1987  n_blocks_count_retry = 0;
1988  free_flex_gd(flex_gd);
1989  flex_gd = NULL;
1990  goto retry;
1991  }
1992 
1993 out:
1994  if (flex_gd)
1995  free_flex_gd(flex_gd);
1996  if (resize_inode != NULL)
1997  iput(resize_inode);
1998  ext4_msg(sb, KERN_INFO, "resized filesystem to %llu", n_blocks_count);
1999  return err;
2000 }