// SPDX-License-Identifier: GPL-2.0 /* * linux / fs / ext4 / resize . c * * Support for resizing an ext4 filesystem while it is mounted . * * Copyright ( C ) 2001 , 2002 Andreas Dilger < adilger @ clusterfs . com > * * This could probably be made into a module , because it is not often in use . #include <linux/errno.h>#include <linux/slab.h>#include <linux/jiffies.h>#include "ext4_jbd2.h" struct ext4_rcu_ptr {struct rcu_head rcu;void *ptr;static void ext4_rcu_ptr_callback(struct rcu_head *head)struct ext4_rcu_ptr *ptr;struct ext4_rcu_ptr, rcu);void ext4_kvfree_array_rcu(void *to_free)struct ext4_rcu_ptr *ptr = kzalloc(sizeof (*ptr), GFP_KERNEL);if (ptr) {return ;int ext4_resize_begin(struct super_block *sb)struct ext4_sb_info *sbi = EXT4_SB(sb);int ret = 0 ;if (!capable(CAP_SYS_RESOURCE))return -EPERM;/* * If the reserved GDT blocks is non - zero , the resize_inode feature * should always be set . if (sbi->s_es->s_reserved_gdt_blocks &&"resize_inode disabled but reserved GDT blocks non-zero" );return -EFSCORRUPTED;/* * If we are not using the primary superblock / GDT copy don ' t resize , * because the user tools have no way of handling this . Probably a * bad time to do it anyways . if (EXT4_B2C(sbi, sbi->s_sbh->b_blocknr) !="won't resize using backup superblock at %llu" ,unsigned long long )sbi->s_sbh->b_blocknr);return -EPERM;/* * We are not allowed to do online - resizing on a filesystem mounted * with error , because it can destroy the filesystem easily . if (sbi->s_mount_state & EXT4_ERROR_FS) {"There are errors in the filesystem, " "so online resizing is not allowed" );return -EPERM;if (ext4_has_feature_sparse_super2(sb)) {"Online resizing not supported with sparse_super2" );return -EOPNOTSUPP;if (test_and_set_bit_lock(EXT4_FLAGS_RESIZING,return ret;int ext4_resize_end(struct super_block *sb, bool update_backups)if (update_backups)return ext4_update_overhead(sb, true );return 0 ;static ext4_grpblk_t ext4_group_overhead_blocks(struct super_block *sb,if (ext4_bg_has_super(sb, group))1 +return overhead;#define outside(b, first, last) ((b) < (first) || (b) >= (last))#define inside(b, first, last) ((b) >= (first) && (b) < (last))static int verify_group_input(struct super_block *sb,struct ext4_new_group_data *input)struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;unsigned overhead;struct buffer_head *bh = NULL;int err = -EINVAL;if (group != sbi->s_groups_count) {"Cannot add at group %u (only %u groups)" ,return -EINVAL;2 - overhead -if (test_opt(sb, DEBUG))"EXT4-fs: adding %s group %u: %u blocks " "(%d free, %u reserved)\n" ,"normal" :"no-super" , input->group, input->blocks_count,if (offset != 0 )"Last group not full" );else if (input->reserved_blocks > input->blocks_count / 5 )"Reserved blocks too high (%u)" ,else if (free_blocks_count < 0 )"Bad blocks count %u" ,else if (IS_ERR(bh = ext4_sb_bread(sb, end - 1 , 0 ))) {"Cannot read last block (%llu)" ,1 );else if (outside(input->block_bitmap, start, end))"Block bitmap not in group (block %llu)" ,unsigned long long )input->block_bitmap);else if (outside(input->inode_bitmap, start, end))"Inode bitmap not in group (block %llu)" ,unsigned long long )input->inode_bitmap);else if (outside(input->inode_table, start, end) ||1 , start, end))"Inode table not in group (blocks %llu-%llu)" ,unsigned long long )input->inode_table, itend - 1 );else if (input->inode_bitmap == input->block_bitmap)"Block bitmap same as inode bitmap (%llu)" ,unsigned long long )input->block_bitmap);else if (inside(input->block_bitmap, input->inode_table, itend))"Block bitmap (%llu) in inode table " "(%llu-%llu)" ,unsigned long long )input->block_bitmap,unsigned long long )input->inode_table, itend - 1 );else if (inside(input->inode_bitmap, input->inode_table, itend))"Inode bitmap (%llu) in inode table " "(%llu-%llu)" ,unsigned long long )input->inode_bitmap,unsigned long long )input->inode_table, itend - 1 );else if (inside(input->block_bitmap, start, metaend))"Block bitmap (%llu) in GDT table (%llu-%llu)" ,unsigned long long )input->block_bitmap,1 );else if (inside(input->inode_bitmap, start, metaend))"Inode bitmap (%llu) in GDT table (%llu-%llu)" ,unsigned long long )input->inode_bitmap,1 );else if (inside(input->inode_table, start, metaend) ||1 , start, metaend))"Inode table (%llu-%llu) overlaps GDT table " "(%llu-%llu)" ,unsigned long long )input->inode_table,1 , start, metaend - 1 );else 0 ;return err;/* * ext4_new_flex_group_data is used by 64 bit - resize interface to add a flex * group each time . struct ext4_new_flex_group_data {struct ext4_new_group_data *groups; /* new_group_data for groups /* block group flags of groups /* number of allocated /* number of groups in @groups /* * Avoiding memory allocation failures due to too many groups added each time . #define MAX_RESIZE_BG 16384 /* * alloc_flex_gd ( ) allocates an ext4_new_flex_group_data that satisfies the * resizing from @ o_group to @ n_group , its size is typically @ flexbg_size . * * Returns NULL on failure otherwise address of the allocated structure . static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned int flexbg_size,unsigned int max_resize_bg;struct ext4_new_flex_group_data *flex_gd;sizeof (*flex_gd), GFP_NOFS);if (flex_gd == NULL)goto out3;/* Avoid allocating large 'groups' array if not needed */ 1 );if (n_group <= last_group)1 << fls(n_group - o_group);else if (n_group - last_group < flex_gd->resize_bg)1 << max(fls(last_group - o_group),if (WARN_ON_ONCE(flex_gd->resize_bg > max_resize_bg))sizeof (struct ext4_new_group_data),if (flex_gd->groups == NULL)goto out2;sizeof (__u16),if (flex_gd->bg_flags == NULL)goto out1;return flex_gd;return NULL;static void free_flex_gd(struct ext4_new_flex_group_data *flex_gd)/* * ext4_alloc_group_tables ( ) allocates block bitmaps , inode bitmaps * and inode tables for a flex group . * * This function is used by 64 bit - resize . Note that this function allocates * group tables from the 1 st group of groups contained by @ flexgd , which may * be a partial of a flex group . * * @ sb : super block of fs to which the groups belongs * * Returns 0 on a successful allocation of the metadata blocks in the * block group . static int ext4_alloc_group_tables(struct super_block *sb,struct ext4_new_flex_group_data *flex_gd,unsigned int flexbg_size)struct ext4_new_group_data *group_data = flex_gd->groups;0 ;0 ;0 ;unsigned overhead;1 ) ? ~EXT4_BG_BLOCK_UNINIT : ~0 ;int i;0 || group_data == NULL);0 ].group;1 ;1 ) && ((src_group & ~(flexbg_size - 1 )) !=1 ))));0 ].group;if (src_group >= group_data[0 ].group + flex_gd->count)return -ENOSPC;/* We collect contiguous blocks as much as possible. */ for (; src_group <= last_group; src_group++) {if (overhead == 0 )else break ;/* Allocate block bitmaps */ for (; bb_index < flex_gd->count; bb_index++) {if (start_blk >= last_blk)goto next_group;1 );0 ].group;/* Allocate inode bitmaps */ for (; ib_index < flex_gd->count; ib_index++) {if (start_blk >= last_blk)goto next_group;1 );0 ].group;/* Allocate inode tables */ for (; it_index < flex_gd->count; it_index++) {unsigned int itb = EXT4_SB(sb)->s_itb_per_group;if (start_blk + itb > last_blk)goto next_group;1 );0 ].group;if (start_blk + itb > next_group_start) {1 ] &= uninit_mask;1 ].mdata_blocks += overhead;/* Update free clusters count to exclude metadata blocks */ for (i = 0 ; i < flex_gd->count; i++) {if (test_opt(sb, DEBUG)) {int i;0 ].group;"EXT4-fs: adding a flex group with " "%u groups, flexbg size is %u:\n" , flex_gd->count,for (i = 0 ; i < flex_gd->count; i++) {"adding %s group %u: %u blocks (%u free, %u mdata blocks)\n" ,"normal" :"no-super" , group + i,return 0 ;static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,struct buffer_head *bh;int err;if (unlikely(!bh))return ERR_PTR(-ENOMEM);"get_write_access" );if (err) {else {0 , sb->s_blocksize);return bh;static int ext4_resize_ensure_credits_batch(handle_t *handle, int credits)return ext4_journal_ensure_credits_fn(handle, credits,0 , 0 );/* * set_flexbg_block_bitmap ( ) mark clusters [ @ first_cluster , @ last_cluster ] used . * * Helper function for ext4_setup_new_group_blocks ( ) which set . * * @ sb : super block * @ handle : journal handle * @ flex_gd : flex group data static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle,struct ext4_new_flex_group_data *flex_gd,struct ext4_sb_info *sbi = EXT4_SB(sb);1 ;"mark clusters [%llu-%llu] used\n" , first_cluster,for (; count > 0 ; count -= count2, first_cluster += count2) {struct buffer_head *bh;int err;0 ].group;if (count2 > count)if (flex_gd->bg_flags[group] & EXT4_BG_BLOCK_UNINIT) {1 );continue ;1 );if (err < 0 )return err;if (unlikely(!bh))return -ENOMEM;"get_write_access" );if (err) {return err;"mark block bitmap %#04llx (+%llu/%u)\n" ,if (unlikely(err))return err;return 0 ;/* * Set up the block and inode bitmaps , and the inode table for the new groups . * This doesn ' t need to be part of the main transaction , since we are only * changing blocks outside the actual filesystem . We still do journaling to * ensure the recovery is correct in case of a failure just after resize . * If any part of this fails , we simply abort the resize . * * setup_new_flex_group_blocks handles a flex group as follow : * 1 . copy super block and GDT , and initialize group tables if necessary . * In this step , we only set bits in blocks bitmaps for blocks taken by * super block and GDT . * 2 . allocate group tables in block bitmaps , that is , set bits in block * bitmap for blocks taken by group tables . static int setup_new_flex_group_blocks(struct super_block *sb,struct ext4_new_flex_group_data *flex_gd)int group_table_count[] = {1 , 1 , EXT4_SB(sb)->s_itb_per_group};struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;struct ext4_new_group_data *group_data = flex_gd->groups;struct buffer_head *bh = NULL;int reserved_gdb, i, j, err = 0 , err2;int meta_bg;0 ].group != sbi->s_groups_count);/* This transaction may be extended/restarted along the way */ if (IS_ERR(handle))return PTR_ERR(handle);0 ].group;for (i = 0 ; i < flex_gd->count; i++, group++) {unsigned long gdblocks;if (meta_bg == 0 && !ext4_bg_has_super(sb, group))goto handle_itb;if (meta_bg == 1 )goto handle_itb;/* Copy all of the GDT blocks into the backup in this group */ for (j = 0 ; j < gdblocks; j++, block++) {struct buffer_head *gdb;"update backup group %#04llx\n" , block);1 );if (err < 0 )goto out;if (unlikely(!gdb)) {goto out;"get_write_access" );if (err) {goto out;if (unlikely(err)) {goto out;/* Zero out all of the reserved backup group descriptor * table blocks if (ext4_bg_has_super(sb, group)) {1 ,if (err)goto out;/* Initialize group tables of the group @group */ if (!(bg_flags[i] & EXT4_BG_INODE_ZEROED))goto handle_bb;/* Zero out all of the inode table blocks */ "clear inode table blocks %#04llx -> %#04lx\n" ,if (err)goto out;if (bg_flags[i] & EXT4_BG_BLOCK_UNINIT)goto handle_ib;/* Initialize block bitmap of the @group */ 1 );if (err < 0 )goto out;if (IS_ERR(bh)) {goto out;if (overhead != 0 ) {"mark backup superblock %#04llx (+0)\n" ,0 ,8 , bh->b_data);if (err)goto out;if (bg_flags[i] & EXT4_BG_INODE_UNINIT)continue ;/* Initialize inode bitmap of the @group */ 1 );if (err < 0 )goto out;/* Mark unused entries in inode bitmap used */ if (IS_ERR(bh)) {goto out;8 , bh->b_data);if (err)goto out;/* Mark group tables in block bitmap */ for (j = 0 ; j < GROUP_TABLE_COUNT; j++) {0 ].block_bitmap)[j];for (i = 1 ; i < flex_gd->count; i++) {if (block == (&group_data[i].block_bitmap)[j]) {continue ;1 ));if (err)goto out;1 ));if (err)goto out;if (err2 && !err)return err;/* * Iterate through the groups which hold BACKUP superblock / GDT copies in an * ext4 filesystem . The counters should be initialized to 1 , 5 , and 7 before * calling this for the first time . In a sparse filesystem it will be the * sequence of powers of 3 , 5 , and 7 : 1 , 3 , 5 , 7 , 9 , 25 , 27 , 49 , 81 , . . . * For a non - sparse filesystem it will be every group : 1 , 2 , 3 , 4 , . . . unsigned int ext4_list_backups(struct super_block *sb, unsigned int *three,unsigned int *five, unsigned int *seven)struct ext4_super_block *es = EXT4_SB(sb)->s_es;unsigned int *min = three;int mult = 3 ;unsigned int ret;if (ext4_has_feature_sparse_super2(sb)) {do {if (*min > 2 )return UINT_MAX;1 ]);1 ;while (!ret);return ret;if (!ext4_has_feature_sparse_super(sb)) {1 ;return ret;if (*five < *min) {5 ;if (*seven < *min) {7 ;return ret;/* * Check that all of the backup GDT blocks are held in the primary GDT block . * It is assumed that they are stored in group order . Returns the number of * groups in current filesystem that have BACKUPS , or - ve error code . static int verify_reserved_gdb(struct super_block *sb,struct buffer_head *primary)const ext4_fsblk_t blk = primary->b_blocknr;unsigned three = 1 ;unsigned five = 5 ;unsigned seven = 7 ;unsigned grp;int gdbackups = 0 ;while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {if (le32_to_cpu(*p++) !="reserved GDT %llu" " missing grp %d (%llu)" ,return -EINVAL;if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb))return -EFBIG;return gdbackups;/* * Called when we need to bring a reserved group descriptor table block into * use from the resize inode . The primary copy of the new GDT block currently * is an indirect block ( under the double indirect block in the resize inode ) . * The new backup GDT blocks will be stored as leaf blocks in this indirect * block , in group order . Even though we know all the block numbers we need , * we check to ensure that the resize inode has actually reserved these blocks . * * Don ' t need to update the block bitmaps because the blocks are still in use . * * We get all of the error cases out of the way , so that we are sure to not * fail once we start modifying the data on disk , because JBD has no rollback . static int add_new_gdb(handle_t *handle, struct inode *inode,struct super_block *sb = inode->i_sb;struct ext4_super_block *es = EXT4_SB(sb)->s_es;unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb);1 + gdb_num;struct buffer_head **o_group_desc, **n_group_desc = NULL;struct buffer_head *dind = NULL;struct buffer_head *gdb_bh = NULL;int gdbackups;struct ext4_iloc iloc = { .bh = NULL };int err;if (test_opt(sb, DEBUG))"EXT4-fs: ext4_add_new_gdb: adding group block %lu\n" ,0 );if (IS_ERR(gdb_bh))return PTR_ERR(gdb_bh);if (gdbackups < 0 ) {goto errout;0 );if (IS_ERR(dind)) {goto errout;if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {"new group %u GDT block %llu not reserved" ,goto errout;"get_write_access" );if (unlikely(err))goto errout;"get_write_access" );if (unlikely(err))goto errout;"get_write_access" );if (unlikely(err)) {goto errout;/* ext4_reserve_inode_write() gets a reference on the iloc */ if (unlikely(err))goto errout;1 ) * sizeof (struct buffer_head *),if (!n_group_desc) {"not enough memory for %lu groups" ,1 );goto errout;/* * Finally , we have all of the possible failures behind us . . . * * Remove new GDT block from inode double - indirect block and clear out * the new GDT block for use ( which also " frees " the backup GDT blocks * from the reserved inode ) . We don ' t need to change the bitmaps for * these blocks , because they are marked as in - use from being in the * reserved inode , and will become GDT blocks ( primary and backup ) . 0 ;if (unlikely(err)) {goto errout;1 ) * sb->s_blocksize >>9 - EXT4_SB(sb)->s_cluster_bits);0 , sb->s_blocksize);if (unlikely(err)) {goto errout;sizeof (struct buffer_head *));1 );if (err)return err;"leaving with error %d\n" , err);return err;/* * If there is no available space in the existing block group descriptors for * the new block group and there are no reserved block group descriptors , then * the meta_bg feature will get enabled , and es - > s_first_meta_bg will get set * to the first block group that is managed using meta_bg and s_first_meta_bg * must be a multiple of EXT4_DESC_PER_BLOCK ( sb ) . * This function will be called when first group of meta_bg is added to bring * new group descriptors block of new added meta_bg . static int add_new_gdb_meta_bg(struct super_block *sb,struct buffer_head *gdb_bh;struct buffer_head **o_group_desc, **n_group_desc;unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb);int err;0 );if (IS_ERR(gdb_bh))return PTR_ERR(gdb_bh);1 ) * sizeof (struct buffer_head *),if (!n_group_desc) {"not enough memory for %lu groups" ,1 );return err;sizeof (struct buffer_head *));"get_write_access" );if (err) {return err;return err;/* * Called when we are adding a new group which has a backup copy of each of * the GDT blocks ( i . e . sparse group ) and there are reserved GDT blocks . * We need to add these reserved backup GDT blocks to the resize inode , so * that they are kept for future resizing and not allocated to files . * * Each reserved backup GDT block will go into a different indirect block . * The indirect blocks are actually the primary reserved GDT blocks , * so we know in advance what their block numbers are . We only get the * double - indirect block to verify it is pointing to the primary reserved * GDT blocks so we don ' t overwrite a data block by accident . The reserved * backup GDT blocks are stored in their reserved primary GDT block . static int reserve_backup_gdb(handle_t *handle, struct inode *inode,struct super_block *sb = inode->i_sb;int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks);int cluster_bits = EXT4_SB(sb)->s_cluster_bits;struct buffer_head **primary;struct buffer_head *dind;struct ext4_iloc iloc;int gdbackups = 0 ;int res, i;int err;sizeof (*primary), GFP_NOFS);if (!primary)return -ENOMEM;0 );if (IS_ERR(dind)) {goto exit_free;1 + EXT4_SB(sb)->s_gdb_count;/* Get each reserved primary GDT block and verify it holds backups */ for (res = 0 ; res < reserved_gdb; res++, blk++) {if (le32_to_cpu(*data) != blk) {"reserved block %llu" " not at offset %ld" ,long )(data - (__le32 *)dind->b_data));goto exit_bh;0 );if (IS_ERR(primary[res])) {goto exit_bh;if (gdbackups < 0 ) {goto exit_bh;if (++data >= end)for (i = 0 ; i < reserved_gdb; i++) {"get_write_access" );if ((err = ext4_journal_get_write_access(handle, sb, primary[i],goto exit_bh;if ((err = ext4_reserve_inode_write(handle, inode, &iloc)))goto exit_bh;/* * Finally we can add each of the reserved backup GDT blocks from * the new group to its reserved primary GDT block . for (i = 0 ; i < reserved_gdb; i++) {int err2;if (!err)9 - cluster_bits);while (--res >= 0 )return err;static inline void ext4_set_block_group_nr(struct super_block *sb, char *data,struct ext4_super_block *es = (struct ext4_super_block *) data;if (ext4_has_feature_metadata_csum(sb))/* * Update the backup copies of the ext4 metadata . These don ' t need to be part * of the main resize transaction , because e2fsck will re - write them if there * is a problem ( basically only OOM will cause a problem ) . However , we * _ should_ update the backups if possible , in case the primary gets trashed * for some reason and we need to run e2fsck from a backup superblock . The * important part is that the new block and inode counts are in the backup * superblocks , and the location of the new group metadata in the GDT backups . * * We do not need take the s_resize_lock for this , because these * blocks are not otherwise touched by the filesystem code when it is * mounted . We don ' t need to worry about last changing from * sbi - > s_groups_count , because the worst that can happen is that we * do not copy the full number of backups at this time . The resize * which changed s_groups_count will backup again . static void update_backups(struct super_block *sb, sector_t blk_off, char *data,int size, int meta_bg)struct ext4_sb_info *sbi = EXT4_SB(sb);const int bpg = EXT4_BLOCKS_PER_GROUP(sb);unsigned three = 1 ;unsigned five = 5 ;unsigned seven = 7 ;0 ;int rest = sb->s_blocksize - size;int err = 0 , err2;if (IS_ERR(handle)) {1 ;goto exit_err;if (meta_bg == 0 ) {else {1 ;2 );while (group < sbi->s_groups_count) {struct buffer_head *bh;int has_super = ext4_bg_has_super(sb, group);/* Out of journal space, and can't get more - abort - so sad */ 1 );if (err < 0 )break ;if (meta_bg == 0 )else if (unlikely(!bh)) {break ;"update metadata backup %llu(+%llu)\n" ,"get_write_access" );if ((err = ext4_journal_get_write_access(handle, sb, bh,break ;if (rest)0 , rest);if (has_super && (backup_block == first_block))if (unlikely(err))if (meta_bg == 0 )else if (group == last)break ;else if ((err2 = ext4_journal_stop(handle)) && !err)/* * Ugh ! Need to have e2fsck write the backup copies . It is too * late to revert the resize , we shouldn ' t fail just because of * the backup copies ( they are only needed in case of corruption ) . * * However , if we got here we have a journal problem too , so we * can ' t really start a transaction to mark the superblock . * Chicken out and just set the flag on the hope it will be written * to disk , and if not - we will simply wait until next fsck . if (err) {"can't update backup for group %u (err %d), " "forcing fsck on next reboot" , group, err);/* * ext4_add_new_descs ( ) adds @ count group descriptor of groups * starting at @ group * * @ handle : journal handle * @ sb : super block * @ group : the group no . of the first group desc to be added * @ resize_inode : the resize inode * @ count : number of group descriptors to be added static int ext4_add_new_descs(handle_t *handle, struct super_block *sb,struct inode *resize_inode,struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;struct buffer_head *gdb_bh;int i, gdb_off, gdb_num, err = 0 ;int meta_bg;for (i = 0 ; i < count; i++, group++) {int reserved_gdb = ext4_bg_has_super(sb, group) ?0 ;/* * We will only either add reserved group blocks to a backup group * or remove reserved blocks for the first group in a new group block . * Doing both would be mean more complex code , and sane people don ' t * use non - sparse filesystems anymore . This is already checked above . if (gdb_off) {"get_write_access" );if (!err && reserved_gdb && ext4_bg_num_gdb(sb, group))else if (meta_bg != 0 ) {else {if (err)break ;return err;static struct buffer_head *ext4_get_bitmap(struct super_block *sb, __u64 block)struct buffer_head *bh = sb_getblk(sb, block);if (unlikely(!bh))return NULL;if (!bh_uptodate_or_lock(bh)) {if (ext4_read_bh(bh, 0 , NULL, false ) < 0 ) {return NULL;return bh;static int ext4_set_bitmap_checksums(struct super_block *sb,struct ext4_group_desc *gdp,struct ext4_new_group_data *group_data)struct buffer_head *bh;if (!ext4_has_feature_metadata_csum(sb))return 0 ;if (!bh)return -EIO;if (!bh)return -EIO;return 0 ;/* * ext4_setup_new_descs ( ) will set up the group descriptor descriptors of a flex bg static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb,struct ext4_new_flex_group_data *flex_gd)struct ext4_new_group_data *group_data = flex_gd->groups;struct ext4_group_desc *gdp;struct ext4_sb_info *sbi = EXT4_SB(sb);struct buffer_head *gdb_bh;int i, gdb_off, gdb_num, err = 0 ;for (i = 0 ; i < flex_gd->count; i++, group_data++, bg_flags++) {/* * get_write_access ( ) has been called on gdb_bh by ext4_add_new_desc ( ) . /* Update group descriptor block for new group */ struct ext4_group_desc *)(gdb_bh->b_data +0 , EXT4_DESC_SIZE(sb));if (err) {break ;if (ext4_has_group_desc_csum(sb))if (unlikely(err)) {break ;/* * We can allocate memory for mb_alloc based on the new group * descriptor if (err)break ;return err;static void ext4_add_overhead(struct super_block *sb,const ext4_fsblk_t overhead)struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;/* * ext4_update_super ( ) updates the super block so that the newly added * groups can be seen by the filesystem . * * @ sb : super block * @ flex_gd : new added groups static void ext4_update_super(struct super_block *sb,struct ext4_new_flex_group_data *flex_gd)0 ;0 ;0 ;struct ext4_new_group_data *group_data = flex_gd->groups;struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;int i;0 || group_data == NULL);/* * Make the new blocks and inodes valid next . We do this before * increasing the group count so that once the group is enabled , * all of its blocks and inodes are already valid . * * We always allocate group - by - group , then block - by - block or * inode - by - inode within a group , so enabling these * blocks / inodes before the group is live won ' t actually let us * allocate the new space yet . for (i = 0 ; i < flex_gd->count; i++) {100 ;100 );"free blocks count %llu" , ext4_free_blocks_count(es));/* * We need to protect s_groups_count against other CPUs seeing * inconsistent state in the superblock . * * The precise rules we use are : * * * Writers must perform a smp_wmb ( ) after updating all * dependent data and before modifying the groups count * * * Readers must perform an smp_rmb ( ) after reading the groups * count and before reading any dependent data . * * NB . These rules can be relaxed when checking the group count * while freeing data , as we can only allocate from a block * group after serialising against the group count , and we can * only then free after serialising in turn against that * allocation . /* Update the global fs size fields */ /* Update the reserved block counts only once the new group is /* Update the free space counts */ "free blocks count %llu" ,if (ext4_has_feature_flex_bg(sb) && sbi->s_log_groups_per_flex) {struct flex_groups *fg;0 ].group);/* * Update the fs overhead information . * * For bigalloc , if the superblock already has a properly calculated * overhead , update it with a value based on numbers already computed * above for the newly allocated capacity . if (ext4_has_feature_bigalloc(sb) && (sbi->s_overhead != 0 ))else if (test_opt(sb, DEBUG))"EXT4-fs: added group %u:" "%llu blocks(%llu free %llu reserved)\n" , flex_gd->count,/* Add a flex group to an fs. Ensure we handle all possible error conditions * _ before_ we start modifying the filesystem , because we cannot abort the * transaction and not have it write the data to disk . static int ext4_flex_group_add(struct super_block *sb,struct inode *resize_inode,struct ext4_new_flex_group_data *flex_gd)struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;unsigned reserved_gdb;int err = 0 , err2 = 0 , credit;if (err)goto exit ;/* * We will always be modifying at least the superblock and GDT * blocks . If we are adding a group past the last current GDT block , * we will also modify the inode and the dindirect block . If we * are adding a group with superblock / GDT backups we will also * modify each of the reserved GDT dindirect blocks . 3 ; /* sb, resize inode, resize inode dindirect */ /* GDT blocks */ 1 + DIV_ROUND_UP(flex_gd->count, EXT4_DESC_PER_BLOCK(sb));/* Reserved GDT dindirect blocks */ if (IS_ERR(handle)) {goto exit ;"get_write_access" );if (err)goto exit_journal;0 ].group;if (err)goto exit_journal;if (err)goto exit_journal;if (!err)if (!err) {int gdb_num = group / EXT4_DESC_PER_BLOCK(sb);int gdb_num_end = ((group + flex_gd->count - 1 ) /int meta_bg = ext4_has_feature_meta_bg(sb) &&0 : sbi->s_sbh->b_blocknr -0 );0 ),char *)es, sizeof (struct ext4_super_block), 0 );for (; gdb_num <= gdb_num_end; gdb_num++) {struct buffer_head *gdb_bh;exit :return err;static int ext4_setup_next_flex_gd(struct super_block *sb,struct ext4_new_flex_group_data *flex_gd,struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;struct ext4_new_group_data *group_data = flex_gd->groups;unsigned long i;if (o_blocks_count == n_blocks_count)return 0 ;1 , &n_group, &last);1 );if (last_group > n_group)1 ;for (i = 0 ; i < flex_gd->count; i++) {int overhead;if (ext4_has_group_desc_csum(sb)) {if (!test_opt(sb, INIT_INODE_TABLE))else if (last_group == n_group && ext4_has_group_desc_csum(sb))/* We need to initialize block bitmap of last group. */ 1 ] &= ~EXT4_BG_BLOCK_UNINIT;if ((last_group == n_group) && (last != clusters_per_group - 1 )) {1 ].blocks_count = EXT4_C2B(sbi, last + 1 );1 ].free_clusters_count -= clusters_per_group -1 ;return 1 ;/* Add group descriptor data to an existing or new group descriptor block. * Ensure we handle all possible error conditions _ before_ we start modifying * the filesystem , because we cannot abort the transaction and not have it * write the data to disk . * * If we are on a GDT block boundary , we need to get the reserved GDT block . * Otherwise , we may need to add backup GDT blocks for a sparse group . * * We only need to hold the superblock lock while we are actually adding * in the new group ' s counts to the superblock . Prior to that we have * not really " added " the group at all . We re - check that we are still * adding in the last group in case things have changed since verifying . int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)struct ext4_new_flex_group_data flex_gd;struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;int reserved_gdb = ext4_bg_has_super(sb, input->group) ?0 ;struct inode *inode = NULL;int gdb_off;int err;0 ;if (gdb_off == 0 && !ext4_has_feature_sparse_super(sb)) {"Can't resize non-sparse filesystem further" );return -EPERM;if (ext4_blocks_count(es) + input->blocks_count <"blocks_count overflow" );return -EINVAL;if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <"inodes_count overflow" );return -EINVAL;if (reserved_gdb || gdb_off == 0 ) {if (!ext4_has_feature_resize_inode(sb) ||"No reserved GDT blocks, can't resize" );return -EPERM;if (IS_ERR(inode)) {"Error opening resize inode" );return PTR_ERR(inode);if (err)goto out;1 );if (err)goto out;1 );if (err)goto out;1 ;return err;/* ext4_group_add */ /* * extend a group without checking assuming that checking has been done . static int ext4_group_extend_no_check(struct super_block *sb,struct ext4_super_block *es = EXT4_SB(sb)->s_es;int err = 0 , err2;/* We will update the superblock, one block bitmap, and * one group descriptor via ext4_group_add_blocks ( ) . 3 );if (IS_ERR(handle)) {"error %d on journal start" , err);return err;"get_write_access" );if (err) {"error %d on journal write access" , err);goto errout;"freeing blocks %llu through %llu\n" , o_blocks_count,/* We add the blocks to the bitmap and set the group need init bit */ if (err)goto errout;"freed blocks %llu through %llu\n" , o_blocks_count,if (err2 && !err)if (!err) {if (test_opt(sb, DEBUG))"EXT4-fs: extended group to %llu " "blocks\n" , ext4_blocks_count(es));0 ),char *)es, sizeof (struct ext4_super_block), 0 );return err;/* * Extend the filesystem to the new number of blocks specified . This entry * point is only used to extend the current filesystem to the end of the last * existing group . It can be accessed via ioctl , or by " remount , resize = < size > " * for emergencies ( because it has no dependencies on reserved blocks ) . * * If we _ really_ wanted , we could use default values to call ext4_group_add ( ) * allow the " remount " trick to work for arbitrary resizing , assuming enough * GDT blocks are reserved to grow to the desired size . int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,struct buffer_head *bh;if (test_opt(sb, DEBUG))"extending last group from %llu to %llu blocks" ,if (n_blocks_count == 0 || n_blocks_count == o_blocks_count)return 0 ;if (n_blocks_count > (sector_t)(~0 ULL) >> (sb->s_blocksize_bits - 9 )) {"filesystem too large to resize to %llu blocks safely" ,return -EINVAL;if (n_blocks_count < o_blocks_count) {"can't shrink FS - resize aborted" );return -EINVAL;/* Handle the remaining blocks in the last group only. */ if (last == 0 ) {"need to use ext2online to resize further" );return -EPERM;if (o_blocks_count + add < o_blocks_count) {"blocks_count overflow" );return -EINVAL;if (o_blocks_count + add > n_blocks_count)if (o_blocks_count + add < n_blocks_count)"will only finish group (%llu blocks, %u new)" ,/* See if the device is actually as big as what was requested */ 1 , 0 );if (IS_ERR(bh)) {"can't read last block, resize aborted" );return -ENOSPC;return ext4_group_extend_no_check(sb, o_blocks_count, add);/* ext4_group_extend */ static int num_desc_blocks(struct super_block *sb, ext4_group_t groups)return (groups + EXT4_DESC_PER_BLOCK(sb) - 1 ) / EXT4_DESC_PER_BLOCK(sb);/* * Release the resize inode and drop the resize_inode feature if there * are no more reserved gdt blocks , and then convert the file system * to enable meta_bg static int ext4_convert_meta_bg(struct super_block *sb, struct inode *inode)struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;struct ext4_inode_info *ei = EXT4_I(inode);int i, ret, err = 0 ;int credits = 1 ;"Converting file system to meta_bg" );if (inode) {if (es->s_reserved_gdt_blocks) {"Unexpected non-zero " "s_reserved_gdt_blocks" );return -EPERM;/* Do a quick sanity check of the resize inode */ if (inode->i_blocks != 1 << (inode->i_blkbits -9 - sbi->s_cluster_bits)))goto invalid_resize_inode;for (i = 0 ; i < EXT4_N_BLOCKS; i++) {if (i == EXT4_DIND_BLOCK) {if (ei->i_data[i])continue ;else goto invalid_resize_inode;if (ei->i_data[i])goto invalid_resize_inode;3 ; /* block bitmap, bg descriptor, resize inode */ if (IS_ERR(handle))return PTR_ERR(handle);"get_write_access" );if (err)goto errout;if (err) {goto errout;if (inode) {1 ,0 ;0 ;if (err)return err ? err : ret;"corrupted/inconsistent resize inode" );return -EINVAL;/* * ext4_resize_fs ( ) resizes a fs to new size specified by @ n_blocks_count * * @ sb : super block of the fs to be resized * @ n_blocks_count : the number of blocks resides in the resized fs int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)struct ext4_new_flex_group_data *flex_gd = NULL;struct ext4_sb_info *sbi = EXT4_SB(sb);struct ext4_super_block *es = sbi->s_es;struct buffer_head *bh;struct inode *resize_inode = NULL;unsigned long n_desc_blocks;unsigned long o_desc_blocks;0 ;unsigned long last_update_time = 0 ;int err = 0 ;int meta_bg;unsigned int flexbg_size = ext4_flex_bg_size(sbi);/* See if the device is actually as big as what was requested */ 1 , 0 );if (IS_ERR(bh)) {"can't read last block, resize aborted" );return -ENOSPC;/* * For bigalloc , trim the requested size to the nearest cluster * boundary to avoid creating an unusable filesystem . We do this * silently , instead of returning an error , to avoid breaking * callers that blindly resize the filesystem to the full size of * the underlying block device . if (ext4_has_feature_bigalloc(sb))1 << EXT4_CLUSTER_BITS(sb)) - 1 );"resizing filesystem from %llu " "to %llu blocks" , o_blocks_count, n_blocks_count);if (n_blocks_count < o_blocks_count) {/* On-line shrinking not supported */ "can't shrink FS - resize aborted" );return -EINVAL;if (n_blocks_count == o_blocks_count)/* Nothing need to do */ return 0 ;1 );if (n_group >= (0 xFFFFFFFFUL / EXT4_INODES_PER_GROUP(sb))) {"resize would cause inodes_count overflow" );return -EINVAL;1 , &o_group, &offset);1 );if (ext4_has_feature_resize_inode(sb)) {if (meta_bg) {"resize_inode and meta_bg enabled " "simultaneously" );return -EINVAL;if (n_desc_blocks > o_desc_blocks +/* set to last group number */ if (!resize_inode)if (IS_ERR(resize_inode)) {"Error opening resize inode" );return PTR_ERR(resize_inode);if ((!resize_inode && !meta_bg && n_desc_blocks > o_desc_blocks) || n_blocks_count == o_blocks_count) {if (err)goto out;if (resize_inode) {if (n_blocks_count_retry) {0 ;goto retry;/* * Make sure the last group has enough space so that it ' s * guaranteed to have enough space for all metadata blocks * that it might need to hold . ( We might not need to store * the inode table blocks in the last block group , but there * will be cases where this might be needed . ) if ((ext4_group_first_block_no(sb, n_group) +2 +0 ;if (resize_inode) {goto retry;/* extend the last group */ if (n_group == o_group)else 1 ));if (add > 0 ) {if (err)goto out;if (ext4_blocks_count(es) == n_blocks_count && n_blocks_count_retry == 0 )goto out;1 );if (err)goto out;1 );if (err)goto out;if (flex_gd == NULL) {goto out;/* Add flex groups. Note that a regular group is a * flex group with 1 group . while (ext4_setup_next_flex_gd(sb, flex_gd, n_blocks_count)) {if (time_is_before_jiffies(last_update_time + HZ * 10 )) {if (last_update_time)"resized to %llu blocks" ,if (ext4_alloc_group_tables(sb, flex_gd, flexbg_size) != 0 )break ;if (unlikely(err))break ;if (!err && n_blocks_count_retry) {0 ;if (resize_inode) {goto retry;if (flex_gd)if (resize_inode != NULL)if (err)"error (%d) occurred during " "file system resize" , err);"resized filesystem to %llu" ,return err;
Messung V0.5 in Prozent C=97 H=77 G=87
¤ Dauer der Verarbeitung: 0.33 Sekunden
(vorverarbeitet am 2026-09-29)
¤ *© Formatika GbR, Deutschland
