LCOV - code coverage report
Current view: top level - fs/ext4 - resize.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 817 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 30 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14