blob: 845d9841c91c244fcdea7e77eed5e40b5e726178 [file] [log] [blame]
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001/*
Mingming Cao617ba132006-10-11 01:20:53 -07002 * linux/fs/ext4/resize.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003 *
Mingming Cao617ba132006-10-11 01:20:53 -07004 * Support for resizing an ext4 filesystem while it is mounted.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07005 *
6 * Copyright (C) 2001, 2002 Andreas Dilger <adilger@clusterfs.com>
7 *
8 * This could probably be made into a module, because it is not often in use.
9 */
10
11
Mingming Cao617ba132006-10-11 01:20:53 -070012#define EXT4FS_DEBUG
Dave Kleikampac27a0e2006-10-11 01:20:50 -070013
Dave Kleikampac27a0e2006-10-11 01:20:50 -070014#include <linux/errno.h>
15#include <linux/slab.h>
16
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040017#include "ext4_jbd2.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070018
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -080019struct ext4_rcu_ptr {
20 struct rcu_head rcu;
21 void *ptr;
22};
23
24static void ext4_rcu_ptr_callback(struct rcu_head *head)
25{
26 struct ext4_rcu_ptr *ptr;
27
28 ptr = container_of(head, struct ext4_rcu_ptr, rcu);
29 kvfree(ptr->ptr);
30 kfree(ptr);
31}
32
33void ext4_kvfree_array_rcu(void *to_free)
34{
35 struct ext4_rcu_ptr *ptr = kzalloc(sizeof(*ptr), GFP_KERNEL);
36
37 if (ptr) {
38 ptr->ptr = to_free;
39 call_rcu(&ptr->rcu, ext4_rcu_ptr_callback);
40 return;
41 }
42 synchronize_rcu();
43 kvfree(to_free);
44}
45
Yongqiang Yang8f82f842011-07-26 21:35:44 -040046int ext4_resize_begin(struct super_block *sb)
47{
Theodore Ts'o4ba9e682018-09-03 22:25:01 -040048 struct ext4_sb_info *sbi = EXT4_SB(sb);
Yongqiang Yang8f82f842011-07-26 21:35:44 -040049 int ret = 0;
50
51 if (!capable(CAP_SYS_RESOURCE))
52 return -EPERM;
53
Yongqiang Yangce723c32011-07-26 21:39:09 -040054 /*
Theodore Ts'o011fa992014-12-26 23:58:21 -050055 * If we are not using the primary superblock/GDT copy don't resize,
56 * because the user tools have no way of handling this. Probably a
57 * bad time to do it anyways.
58 */
Theodore Ts'o4ba9e682018-09-03 22:25:01 -040059 if (EXT4_B2C(sbi, sbi->s_sbh->b_blocknr) !=
Theodore Ts'o011fa992014-12-26 23:58:21 -050060 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
61 ext4_warning(sb, "won't resize using backup superblock at %llu",
62 (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
63 return -EPERM;
64 }
65
66 /*
Yongqiang Yangce723c32011-07-26 21:39:09 -040067 * We are not allowed to do online-resizing on a filesystem mounted
68 * with error, because it can destroy the filesystem easily.
69 */
70 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
71 ext4_warning(sb, "There are errors in the filesystem, "
Jakub Wilk8d2ae1c2016-04-27 01:11:21 -040072 "so online resizing is not allowed");
Yongqiang Yangce723c32011-07-26 21:39:09 -040073 return -EPERM;
74 }
75
Yongqiang Yang8f82f842011-07-26 21:35:44 -040076 if (test_and_set_bit_lock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags))
77 ret = -EBUSY;
78
79 return ret;
80}
81
82void ext4_resize_end(struct super_block *sb)
83{
84 clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags);
Peter Zijlstra4e857c52014-03-17 18:06:10 +010085 smp_mb__after_atomic();
Yongqiang Yang8f82f842011-07-26 21:35:44 -040086}
87
Yongqiang Yang01f795f2012-09-05 01:33:50 -040088static ext4_group_t ext4_meta_bg_first_group(struct super_block *sb,
89 ext4_group_t group) {
90 return (group >> EXT4_DESC_PER_BLOCK_BITS(sb)) <<
91 EXT4_DESC_PER_BLOCK_BITS(sb);
92}
93
94static ext4_fsblk_t ext4_meta_bg_first_block_no(struct super_block *sb,
95 ext4_group_t group) {
96 group = ext4_meta_bg_first_group(sb, group);
97 return ext4_group_first_block_no(sb, group);
98}
99
100static ext4_grpblk_t ext4_group_overhead_blocks(struct super_block *sb,
101 ext4_group_t group) {
102 ext4_grpblk_t overhead;
103 overhead = ext4_bg_num_gdb(sb, group);
104 if (ext4_bg_has_super(sb, group))
105 overhead += 1 +
106 le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks);
107 return overhead;
108}
109
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700110#define outside(b, first, last) ((b) < (first) || (b) >= (last))
111#define inside(b, first, last) ((b) >= (first) && (b) < (last))
112
113static int verify_group_input(struct super_block *sb,
Mingming Cao617ba132006-10-11 01:20:53 -0700114 struct ext4_new_group_data *input)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700115{
Mingming Cao617ba132006-10-11 01:20:53 -0700116 struct ext4_sb_info *sbi = EXT4_SB(sb);
117 struct ext4_super_block *es = sbi->s_es;
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700118 ext4_fsblk_t start = ext4_blocks_count(es);
Mingming Cao617ba132006-10-11 01:20:53 -0700119 ext4_fsblk_t end = start + input->blocks_count;
Avantika Mathurfd2d4292008-01-28 23:58:27 -0500120 ext4_group_t group = input->group;
Mingming Cao617ba132006-10-11 01:20:53 -0700121 ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group;
Theodore Ts'ob302ef22013-06-06 11:14:31 -0400122 unsigned overhead;
123 ext4_fsblk_t metaend;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700124 struct buffer_head *bh = NULL;
Mingming Cao3a5b2ec2006-10-11 01:21:05 -0700125 ext4_grpblk_t free_blocks_count, offset;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700126 int err = -EINVAL;
127
Theodore Ts'ob302ef22013-06-06 11:14:31 -0400128 if (group != sbi->s_groups_count) {
129 ext4_warning(sb, "Cannot add at group %u (only %u groups)",
130 input->group, sbi->s_groups_count);
131 return -EINVAL;
132 }
133
134 overhead = ext4_group_overhead_blocks(sb, group);
135 metaend = start + overhead;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700136 input->free_blocks_count = free_blocks_count =
137 input->blocks_count - 2 - overhead - sbi->s_itb_per_group;
138
139 if (test_opt(sb, DEBUG))
Mingming Cao617ba132006-10-11 01:20:53 -0700140 printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks "
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700141 "(%d free, %u reserved)\n",
Mingming Cao617ba132006-10-11 01:20:53 -0700142 ext4_bg_has_super(sb, input->group) ? "normal" :
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700143 "no-super", input->group, input->blocks_count,
144 free_blocks_count, input->reserved_blocks);
145
Mingming Cao3a5b2ec2006-10-11 01:21:05 -0700146 ext4_get_group_no_and_offset(sb, start, NULL, &offset);
Theodore Ts'ob302ef22013-06-06 11:14:31 -0400147 if (offset != 0)
Eric Sandeen12062dd2010-02-15 14:19:27 -0500148 ext4_warning(sb, "Last group not full");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700149 else if (input->reserved_blocks > input->blocks_count / 5)
Eric Sandeen12062dd2010-02-15 14:19:27 -0500150 ext4_warning(sb, "Reserved blocks too high (%u)",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700151 input->reserved_blocks);
152 else if (free_blocks_count < 0)
Eric Sandeen12062dd2010-02-15 14:19:27 -0500153 ext4_warning(sb, "Bad blocks count %u",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700154 input->blocks_count);
155 else if (!(bh = sb_bread(sb, end - 1)))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500156 ext4_warning(sb, "Cannot read last block (%llu)",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700157 end - 1);
158 else if (outside(input->block_bitmap, start, end))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500159 ext4_warning(sb, "Block bitmap not in group (block %llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700160 (unsigned long long)input->block_bitmap);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700161 else if (outside(input->inode_bitmap, start, end))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500162 ext4_warning(sb, "Inode bitmap not in group (block %llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700163 (unsigned long long)input->inode_bitmap);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700164 else if (outside(input->inode_table, start, end) ||
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400165 outside(itend - 1, start, end))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500166 ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700167 (unsigned long long)input->inode_table, itend - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700168 else if (input->inode_bitmap == input->block_bitmap)
Eric Sandeen12062dd2010-02-15 14:19:27 -0500169 ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700170 (unsigned long long)input->block_bitmap);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700171 else if (inside(input->block_bitmap, input->inode_table, itend))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500172 ext4_warning(sb, "Block bitmap (%llu) in inode table "
173 "(%llu-%llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700174 (unsigned long long)input->block_bitmap,
175 (unsigned long long)input->inode_table, itend - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700176 else if (inside(input->inode_bitmap, input->inode_table, itend))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500177 ext4_warning(sb, "Inode bitmap (%llu) in inode table "
178 "(%llu-%llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700179 (unsigned long long)input->inode_bitmap,
180 (unsigned long long)input->inode_table, itend - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700181 else if (inside(input->block_bitmap, start, metaend))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500182 ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700183 (unsigned long long)input->block_bitmap,
184 start, metaend - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700185 else if (inside(input->inode_bitmap, start, metaend))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500186 ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700187 (unsigned long long)input->inode_bitmap,
188 start, metaend - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700189 else if (inside(input->inode_table, start, metaend) ||
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400190 inside(itend - 1, start, metaend))
Eric Sandeen12062dd2010-02-15 14:19:27 -0500191 ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table "
192 "(%llu-%llu)",
Randy Dunlap1939e492006-10-28 10:38:26 -0700193 (unsigned long long)input->inode_table,
194 itend - 1, start, metaend - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700195 else
196 err = 0;
197 brelse(bh);
198
199 return err;
200}
201
Yongqiang Yang28c7bac2012-01-03 23:22:50 -0500202/*
203 * ext4_new_flex_group_data is used by 64bit-resize interface to add a flex
204 * group each time.
205 */
206struct ext4_new_flex_group_data {
207 struct ext4_new_group_data *groups; /* new_group_data for groups
208 in the flex group */
209 __u16 *bg_flags; /* block group flags of groups
210 in @groups */
211 ext4_group_t count; /* number of groups in @groups
212 */
213};
214
215/*
216 * alloc_flex_gd() allocates a ext4_new_flex_group_data with size of
217 * @flexbg_size.
218 *
219 * Returns NULL on failure otherwise address of the allocated structure.
220 */
221static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned long flexbg_size)
222{
223 struct ext4_new_flex_group_data *flex_gd;
224
225 flex_gd = kmalloc(sizeof(*flex_gd), GFP_NOFS);
226 if (flex_gd == NULL)
227 goto out3;
228
Insu Yun46901762016-02-12 01:15:59 -0500229 if (flexbg_size >= UINT_MAX / sizeof(struct ext4_new_group_data))
Haogang Chen967ac8a2012-05-28 14:21:55 -0400230 goto out2;
Yongqiang Yang28c7bac2012-01-03 23:22:50 -0500231 flex_gd->count = flexbg_size;
232
233 flex_gd->groups = kmalloc(sizeof(struct ext4_new_group_data) *
234 flexbg_size, GFP_NOFS);
235 if (flex_gd->groups == NULL)
236 goto out2;
237
238 flex_gd->bg_flags = kmalloc(flexbg_size * sizeof(__u16), GFP_NOFS);
239 if (flex_gd->bg_flags == NULL)
240 goto out1;
241
242 return flex_gd;
243
244out1:
245 kfree(flex_gd->groups);
246out2:
247 kfree(flex_gd);
248out3:
249 return NULL;
250}
251
252static void free_flex_gd(struct ext4_new_flex_group_data *flex_gd)
253{
254 kfree(flex_gd->bg_flags);
255 kfree(flex_gd->groups);
256 kfree(flex_gd);
257}
258
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500259/*
260 * ext4_alloc_group_tables() allocates block bitmaps, inode bitmaps
261 * and inode tables for a flex group.
262 *
263 * This function is used by 64bit-resize. Note that this function allocates
264 * group tables from the 1st group of groups contained by @flexgd, which may
265 * be a partial of a flex group.
266 *
267 * @sb: super block of fs to which the groups belongs
Yongqiang Yang03c1c292012-09-05 01:21:50 -0400268 *
269 * Returns 0 on a successful allocation of the metadata blocks in the
270 * block group.
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500271 */
Yongqiang Yang03c1c292012-09-05 01:21:50 -0400272static int ext4_alloc_group_tables(struct super_block *sb,
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500273 struct ext4_new_flex_group_data *flex_gd,
274 int flexbg_size)
275{
276 struct ext4_new_group_data *group_data = flex_gd->groups;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500277 ext4_fsblk_t start_blk;
278 ext4_fsblk_t last_blk;
279 ext4_group_t src_group;
280 ext4_group_t bb_index = 0;
281 ext4_group_t ib_index = 0;
282 ext4_group_t it_index = 0;
283 ext4_group_t group;
284 ext4_group_t last_group;
285 unsigned overhead;
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500286 __u16 uninit_mask = (flexbg_size > 1) ? ~EXT4_BG_BLOCK_UNINIT : ~0;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500287
288 BUG_ON(flex_gd->count == 0 || group_data == NULL);
289
290 src_group = group_data[0].group;
291 last_group = src_group + flex_gd->count - 1;
292
293 BUG_ON((flexbg_size > 1) && ((src_group & ~(flexbg_size - 1)) !=
294 (last_group & ~(flexbg_size - 1))));
295next_group:
296 group = group_data[0].group;
Yongqiang Yang03c1c292012-09-05 01:21:50 -0400297 if (src_group >= group_data[0].group + flex_gd->count)
298 return -ENOSPC;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500299 start_blk = ext4_group_first_block_no(sb, src_group);
300 last_blk = start_blk + group_data[src_group - group].blocks_count;
301
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400302 overhead = ext4_group_overhead_blocks(sb, src_group);
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500303
304 start_blk += overhead;
305
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500306 /* We collect contiguous blocks as much as possible. */
307 src_group++;
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400308 for (; src_group <= last_group; src_group++) {
309 overhead = ext4_group_overhead_blocks(sb, src_group);
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500310 if (overhead == 0)
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500311 last_blk += group_data[src_group - group].blocks_count;
312 else
313 break;
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400314 }
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500315
316 /* Allocate block bitmaps */
317 for (; bb_index < flex_gd->count; bb_index++) {
318 if (start_blk >= last_blk)
319 goto next_group;
320 group_data[bb_index].block_bitmap = start_blk++;
Lukas Czernerbd862982013-04-03 23:32:34 -0400321 group = ext4_get_group_number(sb, start_blk - 1);
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500322 group -= group_data[0].group;
323 group_data[group].free_blocks_count--;
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500324 flex_gd->bg_flags[group] &= uninit_mask;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500325 }
326
327 /* Allocate inode bitmaps */
328 for (; ib_index < flex_gd->count; ib_index++) {
329 if (start_blk >= last_blk)
330 goto next_group;
331 group_data[ib_index].inode_bitmap = start_blk++;
Lukas Czernerbd862982013-04-03 23:32:34 -0400332 group = ext4_get_group_number(sb, start_blk - 1);
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500333 group -= group_data[0].group;
334 group_data[group].free_blocks_count--;
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500335 flex_gd->bg_flags[group] &= uninit_mask;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500336 }
337
338 /* Allocate inode tables */
339 for (; it_index < flex_gd->count; it_index++) {
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500340 unsigned int itb = EXT4_SB(sb)->s_itb_per_group;
341 ext4_fsblk_t next_group_start;
342
343 if (start_blk + itb > last_blk)
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500344 goto next_group;
345 group_data[it_index].inode_table = start_blk;
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500346 group = ext4_get_group_number(sb, start_blk);
347 next_group_start = ext4_group_first_block_no(sb, group + 1);
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500348 group -= group_data[0].group;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500349
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500350 if (start_blk + itb > next_group_start) {
351 flex_gd->bg_flags[group + 1] &= uninit_mask;
352 overhead = start_blk + itb - next_group_start;
353 group_data[group + 1].free_blocks_count -= overhead;
354 itb -= overhead;
355 }
356
357 group_data[group].free_blocks_count -= itb;
358 flex_gd->bg_flags[group] &= uninit_mask;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500359 start_blk += EXT4_SB(sb)->s_itb_per_group;
360 }
361
362 if (test_opt(sb, DEBUG)) {
363 int i;
364 group = group_data[0].group;
365
366 printk(KERN_DEBUG "EXT4-fs: adding a flex group with "
367 "%d groups, flexbg size is %d:\n", flex_gd->count,
368 flexbg_size);
369
370 for (i = 0; i < flex_gd->count; i++) {
371 printk(KERN_DEBUG "adding %s group %u: %u "
372 "blocks (%d free)\n",
373 ext4_bg_has_super(sb, group + i) ? "normal" :
374 "no-super", group + i,
375 group_data[i].blocks_count,
376 group_data[i].free_blocks_count);
377 }
378 }
Yongqiang Yang03c1c292012-09-05 01:21:50 -0400379 return 0;
Yongqiang Yang3fbea4b2012-01-03 23:44:38 -0500380}
381
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700382static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
Mingming Cao617ba132006-10-11 01:20:53 -0700383 ext4_fsblk_t blk)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700384{
385 struct buffer_head *bh;
386 int err;
387
388 bh = sb_getblk(sb, blk);
Wang Shilongaebf0242013-01-12 16:28:47 -0500389 if (unlikely(!bh))
Theodore Ts'o860d21e2013-01-12 16:19:36 -0500390 return ERR_PTR(-ENOMEM);
liang xie5d601252014-05-12 22:06:43 -0400391 BUFFER_TRACE(bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -0700392 if ((err = ext4_journal_get_write_access(handle, bh))) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700393 brelse(bh);
394 bh = ERR_PTR(err);
395 } else {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700396 memset(bh->b_data, 0, sb->s_blocksize);
397 set_buffer_uptodate(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700398 }
399
400 return bh;
401}
402
403/*
Eric Sandeen14904102007-10-16 18:38:25 -0400404 * If we have fewer than thresh credits, extend by EXT4_MAX_TRANS_DATA.
405 * If that fails, restart the transaction & regain write access for the
406 * buffer head which is used for block_bitmap modifications.
407 */
Yongqiang Yang6d40bc52011-07-26 22:24:41 -0400408static int extend_or_restart_transaction(handle_t *handle, int thresh)
Eric Sandeen14904102007-10-16 18:38:25 -0400409{
410 int err;
411
Frank Mayhar03901312009-01-07 00:06:22 -0500412 if (ext4_handle_has_enough_credits(handle, thresh))
Eric Sandeen14904102007-10-16 18:38:25 -0400413 return 0;
414
415 err = ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA);
416 if (err < 0)
417 return err;
418 if (err) {
Yongqiang Yang6d40bc52011-07-26 22:24:41 -0400419 err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA);
420 if (err)
Eric Sandeen14904102007-10-16 18:38:25 -0400421 return err;
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400422 }
Eric Sandeen14904102007-10-16 18:38:25 -0400423
424 return 0;
425}
426
427/*
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500428 * set_flexbg_block_bitmap() mark @count blocks starting from @block used.
429 *
430 * Helper function for ext4_setup_new_group_blocks() which set .
431 *
432 * @sb: super block
433 * @handle: journal handle
434 * @flex_gd: flex group data
435 */
436static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle,
437 struct ext4_new_flex_group_data *flex_gd,
438 ext4_fsblk_t block, ext4_group_t count)
439{
440 ext4_group_t count2;
441
442 ext4_debug("mark blocks [%llu/%u] used\n", block, count);
443 for (count2 = count; count > 0; count -= count2, block += count2) {
444 ext4_fsblk_t start;
445 struct buffer_head *bh;
446 ext4_group_t group;
447 int err;
448
Lukas Czernerbd862982013-04-03 23:32:34 -0400449 group = ext4_get_group_number(sb, block);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500450 start = ext4_group_first_block_no(sb, group);
451 group -= flex_gd->groups[0].group;
452
Theodore Ts'o3d2660d2014-02-15 22:42:25 -0500453 count2 = EXT4_BLOCKS_PER_GROUP(sb) - (block - start);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500454 if (count2 > count)
455 count2 = count;
456
457 if (flex_gd->bg_flags[group] & EXT4_BG_BLOCK_UNINIT) {
458 BUG_ON(flex_gd->count > 1);
459 continue;
460 }
461
462 err = extend_or_restart_transaction(handle, 1);
463 if (err)
464 return err;
465
466 bh = sb_getblk(sb, flex_gd->groups[group].block_bitmap);
Wang Shilongaebf0242013-01-12 16:28:47 -0500467 if (unlikely(!bh))
Theodore Ts'o860d21e2013-01-12 16:19:36 -0500468 return -ENOMEM;
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500469
liang xie5d601252014-05-12 22:06:43 -0400470 BUFFER_TRACE(bh, "get_write_access");
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500471 err = ext4_journal_get_write_access(handle, bh);
Vasily Averin771e8c72018-11-03 16:22:10 -0400472 if (err) {
473 brelse(bh);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500474 return err;
Vasily Averin771e8c72018-11-03 16:22:10 -0400475 }
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500476 ext4_debug("mark block bitmap %#04llx (+%llu/%u)\n", block,
477 block - start, count2);
478 ext4_set_bits(bh->b_data, block - start, count2);
479
480 err = ext4_handle_dirty_metadata(handle, NULL, bh);
Vasily Averin771e8c72018-11-03 16:22:10 -0400481 brelse(bh);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500482 if (unlikely(err))
483 return err;
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500484 }
485
486 return 0;
487}
488
489/*
490 * Set up the block and inode bitmaps, and the inode table for the new groups.
491 * This doesn't need to be part of the main transaction, since we are only
492 * changing blocks outside the actual filesystem. We still do journaling to
493 * ensure the recovery is correct in case of a failure just after resize.
494 * If any part of this fails, we simply abort the resize.
495 *
496 * setup_new_flex_group_blocks handles a flex group as follow:
497 * 1. copy super block and GDT, and initialize group tables if necessary.
498 * In this step, we only set bits in blocks bitmaps for blocks taken by
499 * super block and GDT.
500 * 2. allocate group tables in block bitmaps, that is, set bits in block
501 * bitmap for blocks taken by group tables.
502 */
503static int setup_new_flex_group_blocks(struct super_block *sb,
504 struct ext4_new_flex_group_data *flex_gd)
505{
506 int group_table_count[] = {1, 1, EXT4_SB(sb)->s_itb_per_group};
507 ext4_fsblk_t start;
508 ext4_fsblk_t block;
509 struct ext4_sb_info *sbi = EXT4_SB(sb);
510 struct ext4_super_block *es = sbi->s_es;
511 struct ext4_new_group_data *group_data = flex_gd->groups;
512 __u16 *bg_flags = flex_gd->bg_flags;
513 handle_t *handle;
514 ext4_group_t group, count;
515 struct buffer_head *bh = NULL;
516 int reserved_gdb, i, j, err = 0, err2;
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400517 int meta_bg;
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500518
519 BUG_ON(!flex_gd->count || !group_data ||
520 group_data[0].group != sbi->s_groups_count);
521
522 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400523 meta_bg = ext4_has_feature_meta_bg(sb);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500524
525 /* This transaction may be extended/restarted along the way */
Theodore Ts'o9924a922013-02-08 21:59:22 -0500526 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500527 if (IS_ERR(handle))
528 return PTR_ERR(handle);
529
530 group = group_data[0].group;
531 for (i = 0; i < flex_gd->count; i++, group++) {
532 unsigned long gdblocks;
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400533 ext4_grpblk_t overhead;
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500534
535 gdblocks = ext4_bg_num_gdb(sb, group);
536 start = ext4_group_first_block_no(sb, group);
537
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400538 if (meta_bg == 0 && !ext4_bg_has_super(sb, group))
Yongqiang Yang6df935a2012-09-05 01:25:50 -0400539 goto handle_itb;
540
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400541 if (meta_bg == 1) {
542 ext4_group_t first_group;
543 first_group = ext4_meta_bg_first_group(sb, group);
544 if (first_group != group + 1 &&
545 first_group != group + EXT4_DESC_PER_BLOCK(sb) - 1)
546 goto handle_itb;
547 }
548
549 block = start + ext4_bg_has_super(sb, group);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500550 /* Copy all of the GDT blocks into the backup in this group */
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400551 for (j = 0; j < gdblocks; j++, block++) {
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500552 struct buffer_head *gdb;
553
554 ext4_debug("update backup group %#04llx\n", block);
555 err = extend_or_restart_transaction(handle, 1);
556 if (err)
557 goto out;
558
559 gdb = sb_getblk(sb, block);
Wang Shilongaebf0242013-01-12 16:28:47 -0500560 if (unlikely(!gdb)) {
Theodore Ts'o860d21e2013-01-12 16:19:36 -0500561 err = -ENOMEM;
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500562 goto out;
563 }
564
liang xie5d601252014-05-12 22:06:43 -0400565 BUFFER_TRACE(gdb, "get_write_access");
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500566 err = ext4_journal_get_write_access(handle, gdb);
567 if (err) {
568 brelse(gdb);
569 goto out;
570 }
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800571 memcpy(gdb->b_data, sbi_array_rcu_deref(sbi,
572 s_group_desc, j)->b_data, gdb->b_size);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500573 set_buffer_uptodate(gdb);
574
575 err = ext4_handle_dirty_metadata(handle, NULL, gdb);
576 if (unlikely(err)) {
577 brelse(gdb);
578 goto out;
579 }
580 brelse(gdb);
581 }
582
583 /* Zero out all of the reserved backup group descriptor
584 * table blocks
585 */
586 if (ext4_bg_has_super(sb, group)) {
587 err = sb_issue_zeroout(sb, gdblocks + start + 1,
588 reserved_gdb, GFP_NOFS);
589 if (err)
590 goto out;
591 }
592
Yongqiang Yang6df935a2012-09-05 01:25:50 -0400593handle_itb:
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500594 /* Initialize group tables of the grop @group */
595 if (!(bg_flags[i] & EXT4_BG_INODE_ZEROED))
596 goto handle_bb;
597
598 /* Zero out all of the inode table blocks */
599 block = group_data[i].inode_table;
600 ext4_debug("clear inode table blocks %#04llx -> %#04lx\n",
601 block, sbi->s_itb_per_group);
602 err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group,
603 GFP_NOFS);
604 if (err)
605 goto out;
606
607handle_bb:
608 if (bg_flags[i] & EXT4_BG_BLOCK_UNINIT)
609 goto handle_ib;
610
611 /* Initialize block bitmap of the @group */
612 block = group_data[i].block_bitmap;
613 err = extend_or_restart_transaction(handle, 1);
614 if (err)
615 goto out;
616
617 bh = bclean(handle, sb, block);
618 if (IS_ERR(bh)) {
619 err = PTR_ERR(bh);
620 goto out;
621 }
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400622 overhead = ext4_group_overhead_blocks(sb, group);
623 if (overhead != 0) {
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500624 ext4_debug("mark backup superblock %#04llx (+0)\n",
625 start);
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400626 ext4_set_bits(bh->b_data, 0, overhead);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500627 }
628 ext4_mark_bitmap_end(group_data[i].blocks_count,
629 sb->s_blocksize * 8, bh->b_data);
630 err = ext4_handle_dirty_metadata(handle, NULL, bh);
Vasily Averin05821672018-11-03 16:13:17 -0400631 brelse(bh);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500632 if (err)
633 goto out;
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500634
635handle_ib:
636 if (bg_flags[i] & EXT4_BG_INODE_UNINIT)
637 continue;
638
639 /* Initialize inode bitmap of the @group */
640 block = group_data[i].inode_bitmap;
641 err = extend_or_restart_transaction(handle, 1);
642 if (err)
643 goto out;
644 /* Mark unused entries in inode bitmap used */
645 bh = bclean(handle, sb, block);
646 if (IS_ERR(bh)) {
647 err = PTR_ERR(bh);
648 goto out;
649 }
650
651 ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb),
652 sb->s_blocksize * 8, bh->b_data);
653 err = ext4_handle_dirty_metadata(handle, NULL, bh);
Vasily Averin05821672018-11-03 16:13:17 -0400654 brelse(bh);
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500655 if (err)
656 goto out;
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500657 }
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500658
659 /* Mark group tables in block bitmap */
660 for (j = 0; j < GROUP_TABLE_COUNT; j++) {
661 count = group_table_count[j];
662 start = (&group_data[0].block_bitmap)[j];
663 block = start;
664 for (i = 1; i < flex_gd->count; i++) {
665 block += group_table_count[j];
666 if (block == (&group_data[i].block_bitmap)[j]) {
667 count += group_table_count[j];
668 continue;
669 }
670 err = set_flexbg_block_bitmap(sb, handle,
671 flex_gd, start, count);
672 if (err)
673 goto out;
674 count = group_table_count[j];
Theodore Ts'ob93c9532014-02-15 21:33:13 -0500675 start = (&group_data[i].block_bitmap)[j];
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500676 block = start;
677 }
678
679 if (count) {
680 err = set_flexbg_block_bitmap(sb, handle,
681 flex_gd, start, count);
682 if (err)
683 goto out;
684 }
685 }
686
687out:
Yongqiang Yang33afdcc2012-01-03 23:32:52 -0500688 err2 = ext4_journal_stop(handle);
689 if (err2 && !err)
690 err = err2;
691
692 return err;
693}
694
695/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700696 * Iterate through the groups which hold BACKUP superblock/GDT copies in an
Mingming Cao617ba132006-10-11 01:20:53 -0700697 * ext4 filesystem. The counters should be initialized to 1, 5, and 7 before
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700698 * calling this for the first time. In a sparse filesystem it will be the
699 * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ...
700 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ...
701 */
Mingming Cao617ba132006-10-11 01:20:53 -0700702static unsigned ext4_list_backups(struct super_block *sb, unsigned *three,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700703 unsigned *five, unsigned *seven)
704{
705 unsigned *min = three;
706 int mult = 3;
707 unsigned ret;
708
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400709 if (!ext4_has_feature_sparse_super(sb)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700710 ret = *min;
711 *min += 1;
712 return ret;
713 }
714
715 if (*five < *min) {
716 min = five;
717 mult = 5;
718 }
719 if (*seven < *min) {
720 min = seven;
721 mult = 7;
722 }
723
724 ret = *min;
725 *min *= mult;
726
727 return ret;
728}
729
730/*
731 * Check that all of the backup GDT blocks are held in the primary GDT block.
732 * It is assumed that they are stored in group order. Returns the number of
733 * groups in current filesystem that have BACKUPS, or -ve error code.
734 */
735static int verify_reserved_gdb(struct super_block *sb,
Yongqiang Yangc72df9f2012-01-03 23:43:39 -0500736 ext4_group_t end,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700737 struct buffer_head *primary)
738{
Mingming Cao617ba132006-10-11 01:20:53 -0700739 const ext4_fsblk_t blk = primary->b_blocknr;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700740 unsigned three = 1;
741 unsigned five = 5;
742 unsigned seven = 7;
743 unsigned grp;
744 __le32 *p = (__le32 *)primary->b_data;
745 int gdbackups = 0;
746
Mingming Cao617ba132006-10-11 01:20:53 -0700747 while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700748 if (le32_to_cpu(*p++) !=
749 grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
Eric Sandeen12062dd2010-02-15 14:19:27 -0500750 ext4_warning(sb, "reserved GDT %llu"
Mingming Cao2ae02102006-10-11 01:21:11 -0700751 " missing grp %d (%llu)",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700752 blk, grp,
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700753 grp *
754 (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
755 blk);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700756 return -EINVAL;
757 }
Mingming Cao617ba132006-10-11 01:20:53 -0700758 if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700759 return -EFBIG;
760 }
761
762 return gdbackups;
763}
764
765/*
766 * Called when we need to bring a reserved group descriptor table block into
767 * use from the resize inode. The primary copy of the new GDT block currently
768 * is an indirect block (under the double indirect block in the resize inode).
769 * The new backup GDT blocks will be stored as leaf blocks in this indirect
770 * block, in group order. Even though we know all the block numbers we need,
771 * we check to ensure that the resize inode has actually reserved these blocks.
772 *
773 * Don't need to update the block bitmaps because the blocks are still in use.
774 *
775 * We get all of the error cases out of the way, so that we are sure to not
776 * fail once we start modifying the data on disk, because JBD has no rollback.
777 */
778static int add_new_gdb(handle_t *handle, struct inode *inode,
Yongqiang Yang2f919712011-07-27 21:16:33 -0400779 ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700780{
781 struct super_block *sb = inode->i_sb;
Mingming Cao617ba132006-10-11 01:20:53 -0700782 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
Yongqiang Yang2f919712011-07-27 21:16:33 -0400783 unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
Mingming Cao617ba132006-10-11 01:20:53 -0700784 ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700785 struct buffer_head **o_group_desc, **n_group_desc;
786 struct buffer_head *dind;
Yongqiang Yang2f919712011-07-27 21:16:33 -0400787 struct buffer_head *gdb_bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700788 int gdbackups;
Mingming Cao617ba132006-10-11 01:20:53 -0700789 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700790 __le32 *data;
791 int err;
792
793 if (test_opt(sb, DEBUG))
794 printk(KERN_DEBUG
Mingming Cao617ba132006-10-11 01:20:53 -0700795 "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700796 gdb_num);
797
Yongqiang Yang2f919712011-07-27 21:16:33 -0400798 gdb_bh = sb_bread(sb, gdblock);
799 if (!gdb_bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700800 return -EIO;
801
Yongqiang Yangc72df9f2012-01-03 23:43:39 -0500802 gdbackups = verify_reserved_gdb(sb, group, gdb_bh);
Yongqiang Yang2f919712011-07-27 21:16:33 -0400803 if (gdbackups < 0) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700804 err = gdbackups;
805 goto exit_bh;
806 }
807
Mingming Cao617ba132006-10-11 01:20:53 -0700808 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700809 dind = sb_bread(sb, le32_to_cpu(*data));
810 if (!dind) {
811 err = -EIO;
812 goto exit_bh;
813 }
814
815 data = (__le32 *)dind->b_data;
Mingming Cao617ba132006-10-11 01:20:53 -0700816 if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500817 ext4_warning(sb, "new group %u GDT block %llu not reserved",
Yongqiang Yang2f919712011-07-27 21:16:33 -0400818 group, gdblock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700819 err = -EINVAL;
820 goto exit_dind;
821 }
822
liang xie5d601252014-05-12 22:06:43 -0400823 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
Theodore Ts'ob4097142011-01-10 12:46:59 -0500824 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
825 if (unlikely(err))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700826 goto exit_dind;
827
liang xie5d601252014-05-12 22:06:43 -0400828 BUFFER_TRACE(gdb_bh, "get_write_access");
Yongqiang Yang2f919712011-07-27 21:16:33 -0400829 err = ext4_journal_get_write_access(handle, gdb_bh);
Theodore Ts'ob4097142011-01-10 12:46:59 -0500830 if (unlikely(err))
Eric Sandeen37be2f52012-11-08 11:22:46 -0500831 goto exit_dind;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700832
liang xie5d601252014-05-12 22:06:43 -0400833 BUFFER_TRACE(dind, "get_write_access");
Theodore Ts'ob4097142011-01-10 12:46:59 -0500834 err = ext4_journal_get_write_access(handle, dind);
835 if (unlikely(err))
836 ext4_std_error(sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700837
Mingming Cao617ba132006-10-11 01:20:53 -0700838 /* ext4_reserve_inode_write() gets a reference on the iloc */
Theodore Ts'ob4097142011-01-10 12:46:59 -0500839 err = ext4_reserve_inode_write(handle, inode, &iloc);
840 if (unlikely(err))
Eric Sandeen37be2f52012-11-08 11:22:46 -0500841 goto exit_dind;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700842
Theodore Ts'of18a5f22011-08-01 08:45:38 -0400843 n_group_desc = ext4_kvmalloc((gdb_num + 1) *
844 sizeof(struct buffer_head *),
845 GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700846 if (!n_group_desc) {
847 err = -ENOMEM;
Theodore Ts'of18a5f22011-08-01 08:45:38 -0400848 ext4_warning(sb, "not enough memory for %lu groups",
849 gdb_num + 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700850 goto exit_inode;
851 }
852
853 /*
854 * Finally, we have all of the possible failures behind us...
855 *
856 * Remove new GDT block from inode double-indirect block and clear out
857 * the new GDT block for use (which also "frees" the backup GDT blocks
858 * from the reserved inode). We don't need to change the bitmaps for
859 * these blocks, because they are marked as in-use from being in the
860 * reserved inode, and will become GDT blocks (primary and backup).
861 */
Mingming Cao617ba132006-10-11 01:20:53 -0700862 data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)] = 0;
Theodore Ts'ob4097142011-01-10 12:46:59 -0500863 err = ext4_handle_dirty_metadata(handle, NULL, dind);
864 if (unlikely(err)) {
865 ext4_std_error(sb, err);
866 goto exit_inode;
867 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700868 inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9;
Mingming Cao617ba132006-10-11 01:20:53 -0700869 ext4_mark_iloc_dirty(handle, inode, &iloc);
Yongqiang Yang2f919712011-07-27 21:16:33 -0400870 memset(gdb_bh->b_data, 0, sb->s_blocksize);
871 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh);
Theodore Ts'ob4097142011-01-10 12:46:59 -0500872 if (unlikely(err)) {
873 ext4_std_error(sb, err);
Theodore Ts'o11a2eb02018-11-06 17:18:17 -0500874 iloc.bh = NULL;
Theodore Ts'ob4097142011-01-10 12:46:59 -0500875 goto exit_inode;
876 }
877 brelse(dind);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700878
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800879 rcu_read_lock();
880 o_group_desc = rcu_dereference(EXT4_SB(sb)->s_group_desc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700881 memcpy(n_group_desc, o_group_desc,
Mingming Cao617ba132006-10-11 01:20:53 -0700882 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *));
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800883 rcu_read_unlock();
Yongqiang Yang2f919712011-07-27 21:16:33 -0400884 n_group_desc[gdb_num] = gdb_bh;
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800885 rcu_assign_pointer(EXT4_SB(sb)->s_group_desc, n_group_desc);
Mingming Cao617ba132006-10-11 01:20:53 -0700886 EXT4_SB(sb)->s_gdb_count++;
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800887 ext4_kvfree_array_rcu(o_group_desc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700888
Marcin Slusarze8546d02008-04-17 10:38:59 -0400889 le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
Artem Bityutskiyb50924c2012-07-22 20:37:31 -0400890 err = ext4_handle_dirty_super(handle, sb);
Theodore Ts'ob4097142011-01-10 12:46:59 -0500891 if (err)
892 ext4_std_error(sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700893
Theodore Ts'ob4097142011-01-10 12:46:59 -0500894 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700895
896exit_inode:
Al Virob93b41d2014-11-20 12:19:11 -0500897 kvfree(n_group_desc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700898 brelse(iloc.bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700899exit_dind:
900 brelse(dind);
901exit_bh:
Yongqiang Yang2f919712011-07-27 21:16:33 -0400902 brelse(gdb_bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700903
Mingming Cao617ba132006-10-11 01:20:53 -0700904 ext4_debug("leaving with error %d\n", err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700905 return err;
906}
907
908/*
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400909 * add_new_gdb_meta_bg is the sister of add_new_gdb.
910 */
911static int add_new_gdb_meta_bg(struct super_block *sb,
912 handle_t *handle, ext4_group_t group) {
913 ext4_fsblk_t gdblock;
914 struct buffer_head *gdb_bh;
915 struct buffer_head **o_group_desc, **n_group_desc;
916 unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
917 int err;
918
919 gdblock = ext4_meta_bg_first_block_no(sb, group) +
920 ext4_bg_has_super(sb, group);
921 gdb_bh = sb_bread(sb, gdblock);
922 if (!gdb_bh)
923 return -EIO;
924 n_group_desc = ext4_kvmalloc((gdb_num + 1) *
925 sizeof(struct buffer_head *),
926 GFP_NOFS);
927 if (!n_group_desc) {
Vasily Averinc484fd22018-11-03 16:50:08 -0400928 brelse(gdb_bh);
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400929 err = -ENOMEM;
930 ext4_warning(sb, "not enough memory for %lu groups",
931 gdb_num + 1);
932 return err;
933 }
934
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800935 rcu_read_lock();
936 o_group_desc = rcu_dereference(EXT4_SB(sb)->s_group_desc);
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400937 memcpy(n_group_desc, o_group_desc,
938 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *));
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800939 rcu_read_unlock();
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400940 n_group_desc[gdb_num] = gdb_bh;
Lukas Czerner75ac16e2019-03-15 00:15:32 -0400941
942 BUFFER_TRACE(gdb_bh, "get_write_access");
943 err = ext4_journal_get_write_access(handle, gdb_bh);
944 if (err) {
945 kvfree(n_group_desc);
946 brelse(gdb_bh);
947 return err;
948 }
949
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800950 rcu_assign_pointer(EXT4_SB(sb)->s_group_desc, n_group_desc);
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400951 EXT4_SB(sb)->s_gdb_count++;
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -0800952 ext4_kvfree_array_rcu(o_group_desc);
Yongqiang Yang01f795f2012-09-05 01:33:50 -0400953 return err;
954}
955
956/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700957 * Called when we are adding a new group which has a backup copy of each of
958 * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks.
959 * We need to add these reserved backup GDT blocks to the resize inode, so
960 * that they are kept for future resizing and not allocated to files.
961 *
962 * Each reserved backup GDT block will go into a different indirect block.
963 * The indirect blocks are actually the primary reserved GDT blocks,
964 * so we know in advance what their block numbers are. We only get the
965 * double-indirect block to verify it is pointing to the primary reserved
966 * GDT blocks so we don't overwrite a data block by accident. The reserved
967 * backup GDT blocks are stored in their reserved primary GDT block.
968 */
969static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
Yongqiang Yang668f4dc2011-07-27 21:23:13 -0400970 ext4_group_t group)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700971{
972 struct super_block *sb = inode->i_sb;
Mingming Cao617ba132006-10-11 01:20:53 -0700973 int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700974 struct buffer_head **primary;
975 struct buffer_head *dind;
Mingming Cao617ba132006-10-11 01:20:53 -0700976 struct ext4_iloc iloc;
977 ext4_fsblk_t blk;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700978 __le32 *data, *end;
979 int gdbackups = 0;
980 int res, i;
981 int err;
982
Josef Bacik216553c2008-04-29 22:02:02 -0400983 primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700984 if (!primary)
985 return -ENOMEM;
986
Mingming Cao617ba132006-10-11 01:20:53 -0700987 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700988 dind = sb_bread(sb, le32_to_cpu(*data));
989 if (!dind) {
990 err = -EIO;
991 goto exit_free;
992 }
993
Mingming Cao617ba132006-10-11 01:20:53 -0700994 blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count;
Josef Bacik94460092008-06-06 18:05:52 -0400995 data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count %
996 EXT4_ADDR_PER_BLOCK(sb));
Mingming Cao617ba132006-10-11 01:20:53 -0700997 end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700998
999 /* Get each reserved primary GDT block and verify it holds backups */
1000 for (res = 0; res < reserved_gdb; res++, blk++) {
1001 if (le32_to_cpu(*data) != blk) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001002 ext4_warning(sb, "reserved block %llu"
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001003 " not at offset %ld",
1004 blk,
1005 (long)(data - (__le32 *)dind->b_data));
1006 err = -EINVAL;
1007 goto exit_bh;
1008 }
1009 primary[res] = sb_bread(sb, blk);
1010 if (!primary[res]) {
1011 err = -EIO;
1012 goto exit_bh;
1013 }
Yongqiang Yangc72df9f2012-01-03 23:43:39 -05001014 gdbackups = verify_reserved_gdb(sb, group, primary[res]);
1015 if (gdbackups < 0) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001016 brelse(primary[res]);
1017 err = gdbackups;
1018 goto exit_bh;
1019 }
1020 if (++data >= end)
1021 data = (__le32 *)dind->b_data;
1022 }
1023
1024 for (i = 0; i < reserved_gdb; i++) {
liang xie5d601252014-05-12 22:06:43 -04001025 BUFFER_TRACE(primary[i], "get_write_access");
Eric Sandeen37be2f52012-11-08 11:22:46 -05001026 if ((err = ext4_journal_get_write_access(handle, primary[i])))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001027 goto exit_bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001028 }
1029
Mingming Cao617ba132006-10-11 01:20:53 -07001030 if ((err = ext4_reserve_inode_write(handle, inode, &iloc)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001031 goto exit_bh;
1032
1033 /*
1034 * Finally we can add each of the reserved backup GDT blocks from
1035 * the new group to its reserved primary GDT block.
1036 */
Yongqiang Yang668f4dc2011-07-27 21:23:13 -04001037 blk = group * EXT4_BLOCKS_PER_GROUP(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001038 for (i = 0; i < reserved_gdb; i++) {
1039 int err2;
1040 data = (__le32 *)primary[i]->b_data;
1041 /* printk("reserving backup %lu[%u] = %lu\n",
1042 primary[i]->b_blocknr, gdbackups,
1043 blk + primary[i]->b_blocknr); */
1044 data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr);
Frank Mayhar03901312009-01-07 00:06:22 -05001045 err2 = ext4_handle_dirty_metadata(handle, NULL, primary[i]);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001046 if (!err)
1047 err = err2;
1048 }
1049 inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9;
Mingming Cao617ba132006-10-11 01:20:53 -07001050 ext4_mark_iloc_dirty(handle, inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001051
1052exit_bh:
1053 while (--res >= 0)
1054 brelse(primary[res]);
1055 brelse(dind);
1056
1057exit_free:
1058 kfree(primary);
1059
1060 return err;
1061}
1062
1063/*
Mingming Cao617ba132006-10-11 01:20:53 -07001064 * Update the backup copies of the ext4 metadata. These don't need to be part
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001065 * of the main resize transaction, because e2fsck will re-write them if there
1066 * is a problem (basically only OOM will cause a problem). However, we
1067 * _should_ update the backups if possible, in case the primary gets trashed
1068 * for some reason and we need to run e2fsck from a backup superblock. The
1069 * important part is that the new block and inode counts are in the backup
1070 * superblocks, and the location of the new group metadata in the GDT backups.
1071 *
Theodore Ts'o32ed5052009-04-25 22:53:39 -04001072 * We do not need take the s_resize_lock for this, because these
1073 * blocks are not otherwise touched by the filesystem code when it is
1074 * mounted. We don't need to worry about last changing from
1075 * sbi->s_groups_count, because the worst that can happen is that we
1076 * do not copy the full number of backups at this time. The resize
1077 * which changed s_groups_count will backup again.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001078 */
Andy Leiserson904dad42015-10-18 00:36:29 -04001079static void update_backups(struct super_block *sb, sector_t blk_off, char *data,
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001080 int size, int meta_bg)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001081{
Mingming Cao617ba132006-10-11 01:20:53 -07001082 struct ext4_sb_info *sbi = EXT4_SB(sb);
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001083 ext4_group_t last;
Mingming Cao617ba132006-10-11 01:20:53 -07001084 const int bpg = EXT4_BLOCKS_PER_GROUP(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001085 unsigned three = 1;
1086 unsigned five = 5;
1087 unsigned seven = 7;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001088 ext4_group_t group = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001089 int rest = sb->s_blocksize - size;
1090 handle_t *handle;
1091 int err = 0, err2;
1092
Theodore Ts'o9924a922013-02-08 21:59:22 -05001093 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001094 if (IS_ERR(handle)) {
1095 group = 1;
1096 err = PTR_ERR(handle);
1097 goto exit_err;
1098 }
1099
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001100 if (meta_bg == 0) {
1101 group = ext4_list_backups(sb, &three, &five, &seven);
1102 last = sbi->s_groups_count;
1103 } else {
Andy Leiserson904dad42015-10-18 00:36:29 -04001104 group = ext4_get_group_number(sb, blk_off) + 1;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001105 last = (ext4_group_t)(group + EXT4_DESC_PER_BLOCK(sb) - 2);
1106 }
1107
1108 while (group < sbi->s_groups_count) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001109 struct buffer_head *bh;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001110 ext4_fsblk_t backup_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001111
1112 /* Out of journal space, and can't get more - abort - so sad */
Frank Mayhar03901312009-01-07 00:06:22 -05001113 if (ext4_handle_valid(handle) &&
1114 handle->h_buffer_credits == 0 &&
Mingming Cao617ba132006-10-11 01:20:53 -07001115 ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) &&
1116 (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001117 break;
1118
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001119 if (meta_bg == 0)
Jan Kara9378c672014-10-30 10:52:57 -04001120 backup_block = ((ext4_fsblk_t)group) * bpg + blk_off;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001121 else
1122 backup_block = (ext4_group_first_block_no(sb, group) +
1123 ext4_bg_has_super(sb, group));
1124
1125 bh = sb_getblk(sb, backup_block);
Wang Shilongaebf0242013-01-12 16:28:47 -05001126 if (unlikely(!bh)) {
Theodore Ts'o860d21e2013-01-12 16:19:36 -05001127 err = -ENOMEM;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001128 break;
1129 }
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001130 ext4_debug("update metadata backup %llu(+%llu)\n",
1131 backup_block, backup_block -
1132 ext4_group_first_block_no(sb, group));
liang xie5d601252014-05-12 22:06:43 -04001133 BUFFER_TRACE(bh, "get_write_access");
Vasily Averinb1341992018-11-03 17:11:19 -04001134 if ((err = ext4_journal_get_write_access(handle, bh))) {
1135 brelse(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001136 break;
Vasily Averinb1341992018-11-03 17:11:19 -04001137 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001138 lock_buffer(bh);
1139 memcpy(bh->b_data, data, size);
1140 if (rest)
1141 memset(bh->b_data + size, 0, rest);
1142 set_buffer_uptodate(bh);
1143 unlock_buffer(bh);
Theodore Ts'ob4097142011-01-10 12:46:59 -05001144 err = ext4_handle_dirty_metadata(handle, NULL, bh);
1145 if (unlikely(err))
1146 ext4_std_error(sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001147 brelse(bh);
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001148
1149 if (meta_bg == 0)
1150 group = ext4_list_backups(sb, &three, &five, &seven);
1151 else if (group == last)
1152 break;
1153 else
1154 group = last;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001155 }
Mingming Cao617ba132006-10-11 01:20:53 -07001156 if ((err2 = ext4_journal_stop(handle)) && !err)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001157 err = err2;
1158
1159 /*
1160 * Ugh! Need to have e2fsck write the backup copies. It is too
1161 * late to revert the resize, we shouldn't fail just because of
1162 * the backup copies (they are only needed in case of corruption).
1163 *
1164 * However, if we got here we have a journal problem too, so we
1165 * can't really start a transaction to mark the superblock.
1166 * Chicken out and just set the flag on the hope it will be written
1167 * to disk, and if not - we will simply wait until next fsck.
1168 */
1169exit_err:
1170 if (err) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001171 ext4_warning(sb, "can't update backup for group %u (err %d), "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001172 "forcing fsck on next reboot", group, err);
Mingming Cao617ba132006-10-11 01:20:53 -07001173 sbi->s_mount_state &= ~EXT4_VALID_FS;
1174 sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001175 mark_buffer_dirty(sbi->s_sbh);
1176 }
1177}
1178
Yongqiang Yangbb08c1e2012-01-03 23:20:50 -05001179/*
1180 * ext4_add_new_descs() adds @count group descriptor of groups
1181 * starting at @group
1182 *
1183 * @handle: journal handle
1184 * @sb: super block
1185 * @group: the group no. of the first group desc to be added
1186 * @resize_inode: the resize inode
1187 * @count: number of group descriptors to be added
1188 */
1189static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,
1190 ext4_group_t group, struct inode *resize_inode,
1191 ext4_group_t count)
1192{
1193 struct ext4_sb_info *sbi = EXT4_SB(sb);
1194 struct ext4_super_block *es = sbi->s_es;
1195 struct buffer_head *gdb_bh;
1196 int i, gdb_off, gdb_num, err = 0;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001197 int meta_bg;
Yongqiang Yangbb08c1e2012-01-03 23:20:50 -05001198
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001199 meta_bg = ext4_has_feature_meta_bg(sb);
Yongqiang Yangbb08c1e2012-01-03 23:20:50 -05001200 for (i = 0; i < count; i++, group++) {
1201 int reserved_gdb = ext4_bg_has_super(sb, group) ?
1202 le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
1203
1204 gdb_off = group % EXT4_DESC_PER_BLOCK(sb);
1205 gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
1206
1207 /*
1208 * We will only either add reserved group blocks to a backup group
1209 * or remove reserved blocks for the first group in a new group block.
1210 * Doing both would be mean more complex code, and sane people don't
1211 * use non-sparse filesystems anymore. This is already checked above.
1212 */
1213 if (gdb_off) {
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -08001214 gdb_bh = sbi_array_rcu_deref(sbi, s_group_desc,
1215 gdb_num);
liang xie5d601252014-05-12 22:06:43 -04001216 BUFFER_TRACE(gdb_bh, "get_write_access");
Yongqiang Yangbb08c1e2012-01-03 23:20:50 -05001217 err = ext4_journal_get_write_access(handle, gdb_bh);
1218
1219 if (!err && reserved_gdb && ext4_bg_num_gdb(sb, group))
1220 err = reserve_backup_gdb(handle, resize_inode, group);
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001221 } else if (meta_bg != 0) {
1222 err = add_new_gdb_meta_bg(sb, handle, group);
1223 } else {
Yongqiang Yangbb08c1e2012-01-03 23:20:50 -05001224 err = add_new_gdb(handle, resize_inode, group);
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001225 }
Yongqiang Yangbb08c1e2012-01-03 23:20:50 -05001226 if (err)
1227 break;
1228 }
1229 return err;
1230}
1231
Darrick J. Wong41a246d2012-04-29 18:33:10 -04001232static struct buffer_head *ext4_get_bitmap(struct super_block *sb, __u64 block)
1233{
1234 struct buffer_head *bh = sb_getblk(sb, block);
Wang Shilongaebf0242013-01-12 16:28:47 -05001235 if (unlikely(!bh))
Darrick J. Wong41a246d2012-04-29 18:33:10 -04001236 return NULL;
Dmitry Monakhov7f1468d2012-09-25 23:19:25 -04001237 if (!bh_uptodate_or_lock(bh)) {
1238 if (bh_submit_read(bh) < 0) {
1239 brelse(bh);
1240 return NULL;
1241 }
Darrick J. Wong41a246d2012-04-29 18:33:10 -04001242 }
Darrick J. Wong41a246d2012-04-29 18:33:10 -04001243
1244 return bh;
1245}
1246
1247static int ext4_set_bitmap_checksums(struct super_block *sb,
1248 ext4_group_t group,
1249 struct ext4_group_desc *gdp,
1250 struct ext4_new_group_data *group_data)
1251{
1252 struct buffer_head *bh;
1253
Dmitry Monakhov9aa5d322014-10-13 03:36:16 -04001254 if (!ext4_has_metadata_csum(sb))
Darrick J. Wong41a246d2012-04-29 18:33:10 -04001255 return 0;
1256
1257 bh = ext4_get_bitmap(sb, group_data->inode_bitmap);
1258 if (!bh)
1259 return -EIO;
1260 ext4_inode_bitmap_csum_set(sb, group, gdp, bh,
1261 EXT4_INODES_PER_GROUP(sb) / 8);
1262 brelse(bh);
1263
Darrick J. Wongfa77dcf2012-04-29 18:35:10 -04001264 bh = ext4_get_bitmap(sb, group_data->block_bitmap);
1265 if (!bh)
1266 return -EIO;
Tao Ma79f1ba42012-10-22 00:34:32 -04001267 ext4_block_bitmap_csum_set(sb, group, gdp, bh);
Darrick J. Wongfa77dcf2012-04-29 18:35:10 -04001268 brelse(bh);
1269
Darrick J. Wong41a246d2012-04-29 18:33:10 -04001270 return 0;
1271}
1272
Yongqiang Yang083f5b22012-01-03 23:37:31 -05001273/*
1274 * ext4_setup_new_descs() will set up the group descriptor descriptors of a flex bg
1275 */
1276static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb,
1277 struct ext4_new_flex_group_data *flex_gd)
1278{
1279 struct ext4_new_group_data *group_data = flex_gd->groups;
1280 struct ext4_group_desc *gdp;
1281 struct ext4_sb_info *sbi = EXT4_SB(sb);
1282 struct buffer_head *gdb_bh;
1283 ext4_group_t group;
1284 __u16 *bg_flags = flex_gd->bg_flags;
1285 int i, gdb_off, gdb_num, err = 0;
1286
1287
1288 for (i = 0; i < flex_gd->count; i++, group_data++, bg_flags++) {
1289 group = group_data->group;
1290
1291 gdb_off = group % EXT4_DESC_PER_BLOCK(sb);
1292 gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
1293
1294 /*
1295 * get_write_access() has been called on gdb_bh by ext4_add_new_desc().
1296 */
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -08001297 gdb_bh = sbi_array_rcu_deref(sbi, s_group_desc, gdb_num);
Yongqiang Yang083f5b22012-01-03 23:37:31 -05001298 /* Update group descriptor block for new group */
Theodore Ts'o2716b802012-05-28 17:47:52 -04001299 gdp = (struct ext4_group_desc *)(gdb_bh->b_data +
Yongqiang Yang083f5b22012-01-03 23:37:31 -05001300 gdb_off * EXT4_DESC_SIZE(sb));
1301
1302 memset(gdp, 0, EXT4_DESC_SIZE(sb));
1303 ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap);
1304 ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap);
Darrick J. Wong41a246d2012-04-29 18:33:10 -04001305 err = ext4_set_bitmap_checksums(sb, group, gdp, group_data);
1306 if (err) {
1307 ext4_std_error(sb, err);
1308 break;
1309 }
1310
Yongqiang Yang083f5b22012-01-03 23:37:31 -05001311 ext4_inode_table_set(sb, gdp, group_data->inode_table);
1312 ext4_free_group_clusters_set(sb, gdp,
Lukas Czerner810da242013-03-02 17:18:58 -05001313 EXT4_NUM_B2C(sbi, group_data->free_blocks_count));
Yongqiang Yang083f5b22012-01-03 23:37:31 -05001314 ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb));
Theodore Ts'o93f90522012-09-12 14:32:42 -04001315 if (ext4_has_group_desc_csum(sb))
1316 ext4_itable_unused_set(sb, gdp,
1317 EXT4_INODES_PER_GROUP(sb));
Yongqiang Yang083f5b22012-01-03 23:37:31 -05001318 gdp->bg_flags = cpu_to_le16(*bg_flags);
Darrick J. Wongfeb0ab32012-04-29 18:45:10 -04001319 ext4_group_desc_csum_set(sb, group, gdp);
Yongqiang Yang083f5b22012-01-03 23:37:31 -05001320
1321 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh);
1322 if (unlikely(err)) {
1323 ext4_std_error(sb, err);
1324 break;
1325 }
1326
1327 /*
1328 * We can allocate memory for mb_alloc based on the new group
1329 * descriptor
1330 */
1331 err = ext4_mb_add_groupinfo(sb, group, gdp);
1332 if (err)
1333 break;
1334 }
1335 return err;
1336}
1337
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001338/*
1339 * ext4_update_super() updates the super block so that the newly added
1340 * groups can be seen by the filesystem.
1341 *
1342 * @sb: super block
1343 * @flex_gd: new added groups
1344 */
1345static void ext4_update_super(struct super_block *sb,
1346 struct ext4_new_flex_group_data *flex_gd)
1347{
1348 ext4_fsblk_t blocks_count = 0;
1349 ext4_fsblk_t free_blocks = 0;
1350 ext4_fsblk_t reserved_blocks = 0;
1351 struct ext4_new_group_data *group_data = flex_gd->groups;
1352 struct ext4_sb_info *sbi = EXT4_SB(sb);
1353 struct ext4_super_block *es = sbi->s_es;
Theodore Ts'o8a991842012-07-22 20:23:31 -04001354 int i;
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001355
1356 BUG_ON(flex_gd->count == 0 || group_data == NULL);
1357 /*
1358 * Make the new blocks and inodes valid next. We do this before
1359 * increasing the group count so that once the group is enabled,
1360 * all of its blocks and inodes are already valid.
1361 *
1362 * We always allocate group-by-group, then block-by-block or
1363 * inode-by-inode within a group, so enabling these
1364 * blocks/inodes before the group is live won't actually let us
1365 * allocate the new space yet.
1366 */
1367 for (i = 0; i < flex_gd->count; i++) {
1368 blocks_count += group_data[i].blocks_count;
1369 free_blocks += group_data[i].free_blocks_count;
1370 }
1371
1372 reserved_blocks = ext4_r_blocks_count(es) * 100;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001373 reserved_blocks = div64_u64(reserved_blocks, ext4_blocks_count(es));
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001374 reserved_blocks *= blocks_count;
1375 do_div(reserved_blocks, 100);
1376
1377 ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count);
Darrick J. Wong636d7e2e2012-03-20 15:46:11 -04001378 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + free_blocks);
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001379 le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) *
1380 flex_gd->count);
Darrick J. Wong636d7e2e2012-03-20 15:46:11 -04001381 le32_add_cpu(&es->s_free_inodes_count, EXT4_INODES_PER_GROUP(sb) *
1382 flex_gd->count);
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001383
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001384 ext4_debug("free blocks count %llu", ext4_free_blocks_count(es));
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001385 /*
1386 * We need to protect s_groups_count against other CPUs seeing
1387 * inconsistent state in the superblock.
1388 *
1389 * The precise rules we use are:
1390 *
1391 * * Writers must perform a smp_wmb() after updating all
1392 * dependent data and before modifying the groups count
1393 *
1394 * * Readers must perform an smp_rmb() after reading the groups
1395 * count and before reading any dependent data.
1396 *
1397 * NB. These rules can be relaxed when checking the group count
1398 * while freeing data, as we can only allocate from a block
1399 * group after serialising against the group count, and we can
1400 * only then free after serialising in turn against that
1401 * allocation.
1402 */
1403 smp_wmb();
1404
1405 /* Update the global fs size fields */
1406 sbi->s_groups_count += flex_gd->count;
Theodore Ts'oc5c72d82013-04-21 20:19:43 -04001407 sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
1408 (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001409
1410 /* Update the reserved block counts only once the new group is
1411 * active. */
1412 ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
1413 reserved_blocks);
1414
1415 /* Update the free space counts */
1416 percpu_counter_add(&sbi->s_freeclusters_counter,
Lukas Czerner810da242013-03-02 17:18:58 -05001417 EXT4_NUM_B2C(sbi, free_blocks));
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001418 percpu_counter_add(&sbi->s_freeinodes_counter,
1419 EXT4_INODES_PER_GROUP(sb) * flex_gd->count);
1420
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001421 ext4_debug("free blocks count %llu",
1422 percpu_counter_read(&sbi->s_freeclusters_counter));
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001423 if (ext4_has_feature_flex_bg(sb) && sbi->s_log_groups_per_flex) {
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001424 ext4_group_t flex_group;
Suraj Jitindar Singh277bc962020-02-28 16:51:19 -08001425 struct flex_groups *fg;
1426
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001427 flex_group = ext4_flex_group(sbi, group_data[0].group);
Suraj Jitindar Singh277bc962020-02-28 16:51:19 -08001428 fg = sbi_array_rcu_deref(sbi, s_flex_groups, flex_group);
Theodore Ts'o90ba9832013-03-11 23:39:59 -04001429 atomic64_add(EXT4_NUM_B2C(sbi, free_blocks),
Suraj Jitindar Singh277bc962020-02-28 16:51:19 -08001430 &fg->free_clusters);
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001431 atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count,
Suraj Jitindar Singh277bc962020-02-28 16:51:19 -08001432 &fg->free_inodes);
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001433 }
1434
Theodore Ts'o952fc182012-07-09 16:27:05 -04001435 /*
1436 * Update the fs overhead information
1437 */
1438 ext4_calculate_overhead(sb);
1439
Yongqiang Yang2e10e2f2012-01-03 23:41:39 -05001440 if (test_opt(sb, DEBUG))
1441 printk(KERN_DEBUG "EXT4-fs: added group %u:"
1442 "%llu blocks(%llu free %llu reserved)\n", flex_gd->count,
1443 blocks_count, free_blocks, reserved_blocks);
1444}
1445
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001446/* Add a flex group to an fs. Ensure we handle all possible error conditions
1447 * _before_ we start modifying the filesystem, because we cannot abort the
1448 * transaction and not have it write the data to disk.
1449 */
1450static int ext4_flex_group_add(struct super_block *sb,
1451 struct inode *resize_inode,
1452 struct ext4_new_flex_group_data *flex_gd)
1453{
1454 struct ext4_sb_info *sbi = EXT4_SB(sb);
1455 struct ext4_super_block *es = sbi->s_es;
1456 ext4_fsblk_t o_blocks_count;
1457 ext4_grpblk_t last;
1458 ext4_group_t group;
1459 handle_t *handle;
1460 unsigned reserved_gdb;
1461 int err = 0, err2 = 0, credit;
1462
1463 BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags);
1464
1465 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
1466 o_blocks_count = ext4_blocks_count(es);
1467 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1468 BUG_ON(last);
1469
1470 err = setup_new_flex_group_blocks(sb, flex_gd);
1471 if (err)
1472 goto exit;
1473 /*
1474 * We will always be modifying at least the superblock and GDT
Jan Kara2c869b22015-05-02 23:58:32 -04001475 * blocks. If we are adding a group past the last current GDT block,
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001476 * we will also modify the inode and the dindirect block. If we
1477 * are adding a group with superblock/GDT backups we will also
1478 * modify each of the reserved GDT dindirect blocks.
1479 */
Jan Kara2c869b22015-05-02 23:58:32 -04001480 credit = 3; /* sb, resize inode, resize inode dindirect */
1481 /* GDT blocks */
1482 credit += 1 + DIV_ROUND_UP(flex_gd->count, EXT4_DESC_PER_BLOCK(sb));
1483 credit += reserved_gdb; /* Reserved GDT dindirect blocks */
Theodore Ts'o9924a922013-02-08 21:59:22 -05001484 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credit);
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001485 if (IS_ERR(handle)) {
1486 err = PTR_ERR(handle);
1487 goto exit;
1488 }
1489
liang xie5d601252014-05-12 22:06:43 -04001490 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001491 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
1492 if (err)
1493 goto exit_journal;
1494
1495 group = flex_gd->groups[0].group;
1496 BUG_ON(group != EXT4_SB(sb)->s_groups_count);
1497 err = ext4_add_new_descs(handle, sb, group,
1498 resize_inode, flex_gd->count);
1499 if (err)
1500 goto exit_journal;
1501
1502 err = ext4_setup_new_descs(handle, sb, flex_gd);
1503 if (err)
1504 goto exit_journal;
1505
1506 ext4_update_super(sb, flex_gd);
1507
1508 err = ext4_handle_dirty_super(handle, sb);
1509
1510exit_journal:
1511 err2 = ext4_journal_stop(handle);
1512 if (!err)
1513 err = err2;
1514
1515 if (!err) {
Yongqiang Yang2ebd1702012-09-05 01:27:50 -04001516 int gdb_num = group / EXT4_DESC_PER_BLOCK(sb);
1517 int gdb_num_end = ((group + flex_gd->count - 1) /
1518 EXT4_DESC_PER_BLOCK(sb));
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001519 int meta_bg = ext4_has_feature_meta_bg(sb);
Tao Ma0acdb882012-09-26 00:08:57 -04001520 sector_t old_gdb = 0;
Yongqiang Yang2ebd1702012-09-05 01:27:50 -04001521
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001522 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es,
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001523 sizeof(struct ext4_super_block), 0);
Yongqiang Yang2ebd1702012-09-05 01:27:50 -04001524 for (; gdb_num <= gdb_num_end; gdb_num++) {
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001525 struct buffer_head *gdb_bh;
Yongqiang Yang2ebd1702012-09-05 01:27:50 -04001526
Theodore Ts'oe9f47ea2020-02-28 16:51:17 -08001527 gdb_bh = sbi_array_rcu_deref(sbi, s_group_desc,
1528 gdb_num);
Tao Ma0acdb882012-09-26 00:08:57 -04001529 if (old_gdb == gdb_bh->b_blocknr)
1530 continue;
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001531 update_backups(sb, gdb_bh->b_blocknr, gdb_bh->b_data,
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001532 gdb_bh->b_size, meta_bg);
Tao Ma0acdb882012-09-26 00:08:57 -04001533 old_gdb = gdb_bh->b_blocknr;
Yongqiang Yang4bac1f82012-01-03 23:44:38 -05001534 }
1535 }
1536exit:
1537 return err;
1538}
1539
Yongqiang Yang19c52462012-01-04 17:09:44 -05001540static int ext4_setup_next_flex_gd(struct super_block *sb,
1541 struct ext4_new_flex_group_data *flex_gd,
1542 ext4_fsblk_t n_blocks_count,
1543 unsigned long flexbg_size)
1544{
1545 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1546 struct ext4_new_group_data *group_data = flex_gd->groups;
1547 ext4_fsblk_t o_blocks_count;
1548 ext4_group_t n_group;
1549 ext4_group_t group;
1550 ext4_group_t last_group;
1551 ext4_grpblk_t last;
1552 ext4_grpblk_t blocks_per_group;
1553 unsigned long i;
1554
1555 blocks_per_group = EXT4_BLOCKS_PER_GROUP(sb);
1556
1557 o_blocks_count = ext4_blocks_count(es);
1558
1559 if (o_blocks_count == n_blocks_count)
1560 return 0;
1561
1562 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1563 BUG_ON(last);
1564 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last);
1565
1566 last_group = group | (flexbg_size - 1);
1567 if (last_group > n_group)
1568 last_group = n_group;
1569
1570 flex_gd->count = last_group - group + 1;
1571
1572 for (i = 0; i < flex_gd->count; i++) {
1573 int overhead;
1574
1575 group_data[i].group = group + i;
1576 group_data[i].blocks_count = blocks_per_group;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001577 overhead = ext4_group_overhead_blocks(sb, group + i);
Yongqiang Yang19c52462012-01-04 17:09:44 -05001578 group_data[i].free_blocks_count = blocks_per_group - overhead;
Theodore Ts'o7f511862013-01-13 08:41:45 -05001579 if (ext4_has_group_desc_csum(sb)) {
Yongqiang Yang19c52462012-01-04 17:09:44 -05001580 flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT |
1581 EXT4_BG_INODE_UNINIT;
Theodore Ts'o7f511862013-01-13 08:41:45 -05001582 if (!test_opt(sb, INIT_INODE_TABLE))
1583 flex_gd->bg_flags[i] |= EXT4_BG_INODE_ZEROED;
1584 } else
Yongqiang Yang19c52462012-01-04 17:09:44 -05001585 flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED;
1586 }
1587
Darrick J. Wongfeb0ab32012-04-29 18:45:10 -04001588 if (last_group == n_group && ext4_has_group_desc_csum(sb))
Yongqiang Yang19c52462012-01-04 17:09:44 -05001589 /* We need to initialize block bitmap of last group. */
1590 flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT;
1591
1592 if ((last_group == n_group) && (last != blocks_per_group - 1)) {
1593 group_data[i - 1].blocks_count = last + 1;
1594 group_data[i - 1].free_blocks_count -= blocks_per_group-
1595 last - 1;
1596 }
1597
1598 return 1;
1599}
1600
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001601/* Add group descriptor data to an existing or new group descriptor block.
1602 * Ensure we handle all possible error conditions _before_ we start modifying
1603 * the filesystem, because we cannot abort the transaction and not have it
1604 * write the data to disk.
1605 *
1606 * If we are on a GDT block boundary, we need to get the reserved GDT block.
1607 * Otherwise, we may need to add backup GDT blocks for a sparse group.
1608 *
1609 * We only need to hold the superblock lock while we are actually adding
1610 * in the new group's counts to the superblock. Prior to that we have
1611 * not really "added" the group at all. We re-check that we are still
1612 * adding in the last group in case things have changed since verifying.
1613 */
Mingming Cao617ba132006-10-11 01:20:53 -07001614int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001615{
Yongqiang Yang61f296c2012-01-04 17:09:50 -05001616 struct ext4_new_flex_group_data flex_gd;
Mingming Cao617ba132006-10-11 01:20:53 -07001617 struct ext4_sb_info *sbi = EXT4_SB(sb);
1618 struct ext4_super_block *es = sbi->s_es;
1619 int reserved_gdb = ext4_bg_has_super(sb, input->group) ?
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001620 le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001621 struct inode *inode = NULL;
Jon Ernst03b40e32013-06-17 08:56:26 -04001622 int gdb_off;
Yongqiang Yang61f296c2012-01-04 17:09:50 -05001623 int err;
1624 __u16 bg_flags = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001625
Mingming Cao617ba132006-10-11 01:20:53 -07001626 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001627
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001628 if (gdb_off == 0 && !ext4_has_feature_sparse_super(sb)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001629 ext4_warning(sb, "Can't resize non-sparse filesystem further");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001630 return -EPERM;
1631 }
1632
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001633 if (ext4_blocks_count(es) + input->blocks_count <
1634 ext4_blocks_count(es)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001635 ext4_warning(sb, "blocks_count overflow");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001636 return -EINVAL;
1637 }
1638
Mingming Cao617ba132006-10-11 01:20:53 -07001639 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001640 le32_to_cpu(es->s_inodes_count)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001641 ext4_warning(sb, "inodes_count overflow");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001642 return -EINVAL;
1643 }
1644
1645 if (reserved_gdb || gdb_off == 0) {
ruippan (潘睿)c72f56c2018-12-04 01:04:12 -05001646 if (!ext4_has_feature_resize_inode(sb) ||
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001647 !le16_to_cpu(es->s_reserved_gdt_blocks)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001648 ext4_warning(sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001649 "No reserved GDT blocks, can't resize");
1650 return -EPERM;
1651 }
David Howells1d1fe1e2008-02-07 00:15:37 -08001652 inode = ext4_iget(sb, EXT4_RESIZE_INO);
1653 if (IS_ERR(inode)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001654 ext4_warning(sb, "Error opening resize inode");
David Howells1d1fe1e2008-02-07 00:15:37 -08001655 return PTR_ERR(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001656 }
1657 }
1658
Aneesh Kumar K.V920313a2009-01-05 21:36:19 -05001659
Yongqiang Yang61f296c2012-01-04 17:09:50 -05001660 err = verify_group_input(sb, input);
Aneesh Kumar K.V08c3a812009-09-09 23:50:17 -04001661 if (err)
Yongqiang Yang61f296c2012-01-04 17:09:50 -05001662 goto out;
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -04001663
Theodore Ts'o117fff12012-09-05 01:29:50 -04001664 err = ext4_alloc_flex_bg_array(sb, input->group + 1);
1665 if (err)
Theodore Ts'o7f511862013-01-13 08:41:45 -05001666 goto out;
Theodore Ts'o117fff12012-09-05 01:29:50 -04001667
Theodore Ts'o28623c22012-09-05 01:31:50 -04001668 err = ext4_mb_alloc_groupinfo(sb, input->group + 1);
1669 if (err)
1670 goto out;
1671
Yongqiang Yang61f296c2012-01-04 17:09:50 -05001672 flex_gd.count = 1;
1673 flex_gd.groups = input;
1674 flex_gd.bg_flags = &bg_flags;
1675 err = ext4_flex_group_add(sb, inode, &flex_gd);
1676out:
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001677 iput(inode);
1678 return err;
Mingming Cao617ba132006-10-11 01:20:53 -07001679} /* ext4_group_add */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001680
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001681/*
Yongqiang Yang18e31432012-01-03 23:18:50 -05001682 * extend a group without checking assuming that checking has been done.
1683 */
1684static int ext4_group_extend_no_check(struct super_block *sb,
1685 ext4_fsblk_t o_blocks_count, ext4_grpblk_t add)
1686{
1687 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1688 handle_t *handle;
1689 int err = 0, err2;
1690
1691 /* We will update the superblock, one block bitmap, and
1692 * one group descriptor via ext4_group_add_blocks().
1693 */
Theodore Ts'o9924a922013-02-08 21:59:22 -05001694 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, 3);
Yongqiang Yang18e31432012-01-03 23:18:50 -05001695 if (IS_ERR(handle)) {
1696 err = PTR_ERR(handle);
1697 ext4_warning(sb, "error %d on journal start", err);
1698 return err;
1699 }
1700
liang xie5d601252014-05-12 22:06:43 -04001701 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get_write_access");
Yongqiang Yang18e31432012-01-03 23:18:50 -05001702 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
1703 if (err) {
1704 ext4_warning(sb, "error %d on journal write access", err);
1705 goto errout;
1706 }
1707
1708 ext4_blocks_count_set(es, o_blocks_count + add);
Darrick J. Wong636d7e2e2012-03-20 15:46:11 -04001709 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + add);
Yongqiang Yang18e31432012-01-03 23:18:50 -05001710 ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
1711 o_blocks_count + add);
1712 /* We add the blocks to the bitmap and set the group need init bit */
1713 err = ext4_group_add_blocks(handle, sb, o_blocks_count, add);
1714 if (err)
1715 goto errout;
1716 ext4_handle_dirty_super(handle, sb);
1717 ext4_debug("freed blocks %llu through %llu\n", o_blocks_count,
1718 o_blocks_count + add);
1719errout:
1720 err2 = ext4_journal_stop(handle);
1721 if (err2 && !err)
1722 err = err2;
1723
1724 if (!err) {
1725 if (test_opt(sb, DEBUG))
1726 printk(KERN_DEBUG "EXT4-fs: extended group to %llu "
1727 "blocks\n", ext4_blocks_count(es));
Maarten ter Huurne6ca792e2013-07-01 08:12:08 -04001728 update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr,
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001729 (char *)es, sizeof(struct ext4_super_block), 0);
Yongqiang Yang18e31432012-01-03 23:18:50 -05001730 }
1731 return err;
1732}
1733
1734/*
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001735 * Extend the filesystem to the new number of blocks specified. This entry
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001736 * point is only used to extend the current filesystem to the end of the last
1737 * existing group. It can be accessed via ioctl, or by "remount,resize=<size>"
1738 * for emergencies (because it has no dependencies on reserved blocks).
1739 *
Mingming Cao617ba132006-10-11 01:20:53 -07001740 * If we _really_ wanted, we could use default values to call ext4_group_add()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001741 * allow the "remount" trick to work for arbitrary resizing, assuming enough
1742 * GDT blocks are reserved to grow to the desired size.
1743 */
Mingming Cao617ba132006-10-11 01:20:53 -07001744int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
1745 ext4_fsblk_t n_blocks_count)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001746{
Mingming Cao617ba132006-10-11 01:20:53 -07001747 ext4_fsblk_t o_blocks_count;
Mingming Cao617ba132006-10-11 01:20:53 -07001748 ext4_grpblk_t last;
1749 ext4_grpblk_t add;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001750 struct buffer_head *bh;
Yongqiang Yangd89651c2012-01-04 17:09:48 -05001751 int err;
Frederic Bohe5f21b0e2008-07-11 19:27:31 -04001752 ext4_group_t group;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001753
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001754 o_blocks_count = ext4_blocks_count(es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001755
1756 if (test_opt(sb, DEBUG))
Theodore Ts'o92b97812012-03-19 23:41:49 -04001757 ext4_msg(sb, KERN_DEBUG,
1758 "extending last group from %llu to %llu blocks",
1759 o_blocks_count, n_blocks_count);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001760
1761 if (n_blocks_count == 0 || n_blocks_count == o_blocks_count)
1762 return 0;
1763
1764 if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
Theodore Ts'o92b97812012-03-19 23:41:49 -04001765 ext4_msg(sb, KERN_ERR,
1766 "filesystem too large to resize to %llu blocks safely",
1767 n_blocks_count);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001768 if (sizeof(sector_t) < 8)
Eric Sandeen12062dd2010-02-15 14:19:27 -05001769 ext4_warning(sb, "CONFIG_LBDAF not enabled");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001770 return -EINVAL;
1771 }
1772
1773 if (n_blocks_count < o_blocks_count) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001774 ext4_warning(sb, "can't shrink FS - resize aborted");
Yongqiang Yang8f82f842011-07-26 21:35:44 -04001775 return -EINVAL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001776 }
1777
1778 /* Handle the remaining blocks in the last group only. */
Frederic Bohe5f21b0e2008-07-11 19:27:31 -04001779 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001780
1781 if (last == 0) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001782 ext4_warning(sb, "need to use ext2online to resize further");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001783 return -EPERM;
1784 }
1785
Mingming Cao617ba132006-10-11 01:20:53 -07001786 add = EXT4_BLOCKS_PER_GROUP(sb) - last;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001787
1788 if (o_blocks_count + add < o_blocks_count) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001789 ext4_warning(sb, "blocks_count overflow");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001790 return -EINVAL;
1791 }
1792
1793 if (o_blocks_count + add > n_blocks_count)
1794 add = n_blocks_count - o_blocks_count;
1795
1796 if (o_blocks_count + add < n_blocks_count)
Eric Sandeen12062dd2010-02-15 14:19:27 -05001797 ext4_warning(sb, "will only finish group (%llu blocks, %u new)",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001798 o_blocks_count + add, add);
1799
1800 /* See if the device is actually as big as what was requested */
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001801 bh = sb_bread(sb, o_blocks_count + add - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001802 if (!bh) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05001803 ext4_warning(sb, "can't read last block, resize aborted");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001804 return -ENOSPC;
1805 }
1806 brelse(bh);
1807
Yongqiang Yangd89651c2012-01-04 17:09:48 -05001808 err = ext4_group_extend_no_check(sb, o_blocks_count, add);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001809 return err;
Mingming Cao617ba132006-10-11 01:20:53 -07001810} /* ext4_group_extend */
Yongqiang Yang19c52462012-01-04 17:09:44 -05001811
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001812
1813static int num_desc_blocks(struct super_block *sb, ext4_group_t groups)
1814{
1815 return (groups + EXT4_DESC_PER_BLOCK(sb) - 1) / EXT4_DESC_PER_BLOCK(sb);
1816}
1817
1818/*
1819 * Release the resize inode and drop the resize_inode feature if there
1820 * are no more reserved gdt blocks, and then convert the file system
1821 * to enable meta_bg
1822 */
1823static int ext4_convert_meta_bg(struct super_block *sb, struct inode *inode)
1824{
1825 handle_t *handle;
1826 struct ext4_sb_info *sbi = EXT4_SB(sb);
1827 struct ext4_super_block *es = sbi->s_es;
Theodore Ts'o59e31c12012-09-19 00:55:56 -04001828 struct ext4_inode_info *ei = EXT4_I(inode);
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001829 ext4_fsblk_t nr;
1830 int i, ret, err = 0;
1831 int credits = 1;
1832
1833 ext4_msg(sb, KERN_INFO, "Converting file system to meta_bg");
Theodore Ts'o59e31c12012-09-19 00:55:56 -04001834 if (inode) {
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001835 if (es->s_reserved_gdt_blocks) {
1836 ext4_error(sb, "Unexpected non-zero "
1837 "s_reserved_gdt_blocks");
1838 return -EPERM;
1839 }
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001840
1841 /* Do a quick sanity check of the resize inode */
1842 if (inode->i_blocks != 1 << (inode->i_blkbits - 9))
1843 goto invalid_resize_inode;
1844 for (i = 0; i < EXT4_N_BLOCKS; i++) {
1845 if (i == EXT4_DIND_BLOCK) {
1846 if (ei->i_data[i])
1847 continue;
1848 else
1849 goto invalid_resize_inode;
1850 }
1851 if (ei->i_data[i])
1852 goto invalid_resize_inode;
1853 }
1854 credits += 3; /* block bitmap, bg descriptor, resize inode */
1855 }
1856
Theodore Ts'o9924a922013-02-08 21:59:22 -05001857 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credits);
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001858 if (IS_ERR(handle))
1859 return PTR_ERR(handle);
1860
liang xie5d601252014-05-12 22:06:43 -04001861 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001862 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
1863 if (err)
1864 goto errout;
1865
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001866 ext4_clear_feature_resize_inode(sb);
1867 ext4_set_feature_meta_bg(sb);
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001868 sbi->s_es->s_first_meta_bg =
1869 cpu_to_le32(num_desc_blocks(sb, sbi->s_groups_count));
1870
1871 err = ext4_handle_dirty_super(handle, sb);
1872 if (err) {
1873 ext4_std_error(sb, err);
1874 goto errout;
1875 }
1876
1877 if (inode) {
1878 nr = le32_to_cpu(ei->i_data[EXT4_DIND_BLOCK]);
1879 ext4_free_blocks(handle, inode, NULL, nr, 1,
1880 EXT4_FREE_BLOCKS_METADATA |
1881 EXT4_FREE_BLOCKS_FORGET);
1882 ei->i_data[EXT4_DIND_BLOCK] = 0;
1883 inode->i_blocks = 0;
1884
1885 err = ext4_mark_inode_dirty(handle, inode);
1886 if (err)
1887 ext4_std_error(sb, err);
1888 }
1889
1890errout:
1891 ret = ext4_journal_stop(handle);
1892 if (!err)
1893 err = ret;
1894 return ret;
1895
1896invalid_resize_inode:
1897 ext4_error(sb, "corrupted/inconsistent resize inode");
1898 return -EINVAL;
1899}
1900
Yongqiang Yang19c52462012-01-04 17:09:44 -05001901/*
1902 * ext4_resize_fs() resizes a fs to new size specified by @n_blocks_count
1903 *
1904 * @sb: super block of the fs to be resized
1905 * @n_blocks_count: the number of blocks resides in the resized fs
1906 */
1907int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)
1908{
1909 struct ext4_new_flex_group_data *flex_gd = NULL;
1910 struct ext4_sb_info *sbi = EXT4_SB(sb);
1911 struct ext4_super_block *es = sbi->s_es;
1912 struct buffer_head *bh;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001913 struct inode *resize_inode = NULL;
1914 ext4_grpblk_t add, offset;
Yongqiang Yang19c52462012-01-04 17:09:44 -05001915 unsigned long n_desc_blocks;
1916 unsigned long o_desc_blocks;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001917 ext4_group_t o_group;
1918 ext4_group_t n_group;
1919 ext4_fsblk_t o_blocks_count;
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001920 ext4_fsblk_t n_blocks_count_retry = 0;
Theodore Ts'o4da4a562012-09-13 10:24:21 -04001921 unsigned long last_update_time = 0;
Theodore Ts'o117fff12012-09-05 01:29:50 -04001922 int err = 0, flexbg_size = 1 << sbi->s_log_groups_per_flex;
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001923 int meta_bg;
Yongqiang Yang19c52462012-01-04 17:09:44 -05001924
Theodore Ts'o59e31c12012-09-19 00:55:56 -04001925 /* See if the device is actually as big as what was requested */
1926 bh = sb_bread(sb, n_blocks_count - 1);
1927 if (!bh) {
1928 ext4_warning(sb, "can't read last block, resize aborted");
1929 return -ENOSPC;
1930 }
1931 brelse(bh);
1932
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001933retry:
Yongqiang Yang19c52462012-01-04 17:09:44 -05001934 o_blocks_count = ext4_blocks_count(es);
1935
Theodore Ts'o59e31c12012-09-19 00:55:56 -04001936 ext4_msg(sb, KERN_INFO, "resizing filesystem from %llu "
1937 "to %llu blocks", o_blocks_count, n_blocks_count);
Yongqiang Yang19c52462012-01-04 17:09:44 -05001938
1939 if (n_blocks_count < o_blocks_count) {
1940 /* On-line shrinking not supported */
1941 ext4_warning(sb, "can't shrink FS - resize aborted");
1942 return -EINVAL;
1943 }
1944
1945 if (n_blocks_count == o_blocks_count)
1946 /* Nothing need to do */
1947 return 0;
1948
Lukas Czernerbd862982013-04-03 23:32:34 -04001949 n_group = ext4_get_group_number(sb, n_blocks_count - 1);
Jan Karae45ab2d2018-05-25 12:51:25 -04001950 if (n_group >= (0xFFFFFFFFUL / EXT4_INODES_PER_GROUP(sb))) {
Theodore Ts'o3f8a6412013-04-21 22:56:32 -04001951 ext4_warning(sb, "resize would cause inodes_count overflow");
1952 return -EINVAL;
1953 }
Lukas Czernera0ade1d2012-02-20 23:02:06 -05001954 ext4_get_group_no_and_offset(sb, o_blocks_count - 1, &o_group, &offset);
Yongqiang Yang19c52462012-01-04 17:09:44 -05001955
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001956 n_desc_blocks = num_desc_blocks(sb, n_group + 1);
1957 o_desc_blocks = num_desc_blocks(sb, sbi->s_groups_count);
Yongqiang Yang19c52462012-01-04 17:09:44 -05001958
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001959 meta_bg = ext4_has_feature_meta_bg(sb);
Yongqiang Yang19c52462012-01-04 17:09:44 -05001960
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04001961 if (ext4_has_feature_resize_inode(sb)) {
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001962 if (meta_bg) {
1963 ext4_error(sb, "resize_inode and meta_bg enabled "
1964 "simultaneously");
1965 return -EINVAL;
1966 }
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001967 if (n_desc_blocks > o_desc_blocks +
1968 le16_to_cpu(es->s_reserved_gdt_blocks)) {
1969 n_blocks_count_retry = n_blocks_count;
1970 n_desc_blocks = o_desc_blocks +
1971 le16_to_cpu(es->s_reserved_gdt_blocks);
1972 n_group = n_desc_blocks * EXT4_DESC_PER_BLOCK(sb);
Jerry Lee12353a02017-08-06 01:18:31 -04001973 n_blocks_count = (ext4_fsblk_t)n_group *
Jan Kara14a0bfd2019-02-11 13:30:32 -05001974 EXT4_BLOCKS_PER_GROUP(sb) +
1975 le32_to_cpu(es->s_first_data_block);
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001976 n_group--; /* set to last group number */
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001977 }
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001978
1979 if (!resize_inode)
1980 resize_inode = ext4_iget(sb, EXT4_RESIZE_INO);
Yongqiang Yang01f795f2012-09-05 01:33:50 -04001981 if (IS_ERR(resize_inode)) {
1982 ext4_warning(sb, "Error opening resize inode");
1983 return PTR_ERR(resize_inode);
1984 }
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001985 }
1986
Theodore Ts'o59e31c12012-09-19 00:55:56 -04001987 if ((!resize_inode && !meta_bg) || n_blocks_count == o_blocks_count) {
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04001988 err = ext4_convert_meta_bg(sb, resize_inode);
1989 if (err)
1990 goto out;
1991 if (resize_inode) {
1992 iput(resize_inode);
1993 resize_inode = NULL;
1994 }
1995 if (n_blocks_count_retry) {
1996 n_blocks_count = n_blocks_count_retry;
1997 n_blocks_count_retry = 0;
1998 goto retry;
1999 }
Yongqiang Yang19c52462012-01-04 17:09:44 -05002000 }
2001
Theodore Ts'o205dc0d2018-09-03 22:19:43 -04002002 /*
2003 * Make sure the last group has enough space so that it's
2004 * guaranteed to have enough space for all metadata blocks
2005 * that it might need to hold. (We might not need to store
2006 * the inode table blocks in the last block group, but there
2007 * will be cases where this might be needed.)
2008 */
2009 if ((ext4_group_first_block_no(sb, n_group) +
2010 ext4_group_overhead_blocks(sb, n_group) + 2 +
2011 sbi->s_itb_per_group + sbi->s_cluster_ratio) >= n_blocks_count) {
2012 n_blocks_count = ext4_group_first_block_no(sb, n_group);
2013 n_group--;
2014 n_blocks_count_retry = 0;
2015 if (resize_inode) {
2016 iput(resize_inode);
2017 resize_inode = NULL;
2018 }
2019 goto retry;
2020 }
2021
Lukas Czernera0ade1d2012-02-20 23:02:06 -05002022 /* extend the last group */
2023 if (n_group == o_group)
2024 add = n_blocks_count - o_blocks_count;
2025 else
2026 add = EXT4_BLOCKS_PER_GROUP(sb) - (offset + 1);
2027 if (add > 0) {
Yongqiang Yang19c52462012-01-04 17:09:44 -05002028 err = ext4_group_extend_no_check(sb, o_blocks_count, add);
2029 if (err)
2030 goto out;
2031 }
2032
Yongqiang Yangd7574ad2012-09-05 01:23:50 -04002033 if (ext4_blocks_count(es) == n_blocks_count)
Yongqiang Yang19c52462012-01-04 17:09:44 -05002034 goto out;
2035
Theodore Ts'o117fff12012-09-05 01:29:50 -04002036 err = ext4_alloc_flex_bg_array(sb, n_group + 1);
2037 if (err)
Vasily Averin142e0172018-11-06 16:16:01 -05002038 goto out;
Theodore Ts'o117fff12012-09-05 01:29:50 -04002039
Theodore Ts'o28623c22012-09-05 01:31:50 -04002040 err = ext4_mb_alloc_groupinfo(sb, n_group + 1);
2041 if (err)
2042 goto out;
2043
Yongqiang Yang19c52462012-01-04 17:09:44 -05002044 flex_gd = alloc_flex_gd(flexbg_size);
2045 if (flex_gd == NULL) {
2046 err = -ENOMEM;
2047 goto out;
2048 }
2049
2050 /* Add flex groups. Note that a regular group is a
2051 * flex group with 1 group.
2052 */
2053 while (ext4_setup_next_flex_gd(sb, flex_gd, n_blocks_count,
2054 flexbg_size)) {
Theodore Ts'o4da4a562012-09-13 10:24:21 -04002055 if (jiffies - last_update_time > HZ * 10) {
2056 if (last_update_time)
2057 ext4_msg(sb, KERN_INFO,
2058 "resized to %llu blocks",
2059 ext4_blocks_count(es));
2060 last_update_time = jiffies;
2061 }
Yongqiang Yang03c1c292012-09-05 01:21:50 -04002062 if (ext4_alloc_group_tables(sb, flex_gd, flexbg_size) != 0)
2063 break;
Yongqiang Yang19c52462012-01-04 17:09:44 -05002064 err = ext4_flex_group_add(sb, resize_inode, flex_gd);
2065 if (unlikely(err))
2066 break;
2067 }
2068
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04002069 if (!err && n_blocks_count_retry) {
2070 n_blocks_count = n_blocks_count_retry;
2071 n_blocks_count_retry = 0;
2072 free_flex_gd(flex_gd);
2073 flex_gd = NULL;
Vasily Averin8a6a7dd2018-11-06 16:20:40 -05002074 if (resize_inode) {
2075 iput(resize_inode);
2076 resize_inode = NULL;
2077 }
Theodore Ts'o1c6bd712012-09-13 10:19:24 -04002078 goto retry;
2079 }
2080
Yongqiang Yang19c52462012-01-04 17:09:44 -05002081out:
2082 if (flex_gd)
2083 free_flex_gd(flex_gd);
Yongqiang Yang01f795f2012-09-05 01:33:50 -04002084 if (resize_inode != NULL)
2085 iput(resize_inode);
Lukas Czerner39649022019-03-15 00:22:28 -04002086 if (err)
2087 ext4_warning(sb, "error (%d) occurred during "
2088 "file system resize", err);
2089 ext4_msg(sb, KERN_INFO, "resized filesystem to %llu",
2090 ext4_blocks_count(es));
Yongqiang Yang19c52462012-01-04 17:09:44 -05002091 return err;
2092}