1ac27a0ecSDave Kleikamp /* 2617ba13bSMingming Cao * linux/fs/ext4/resize.c 3ac27a0ecSDave Kleikamp * 4617ba13bSMingming Cao * Support for resizing an ext4 filesystem while it is mounted. 5ac27a0ecSDave Kleikamp * 6ac27a0ecSDave Kleikamp * Copyright (C) 2001, 2002 Andreas Dilger <adilger@clusterfs.com> 7ac27a0ecSDave Kleikamp * 8ac27a0ecSDave Kleikamp * This could probably be made into a module, because it is not often in use. 9ac27a0ecSDave Kleikamp */ 10ac27a0ecSDave Kleikamp 11ac27a0ecSDave Kleikamp 12617ba13bSMingming Cao #define EXT4FS_DEBUG 13ac27a0ecSDave Kleikamp 14ac27a0ecSDave Kleikamp #include <linux/errno.h> 15ac27a0ecSDave Kleikamp #include <linux/slab.h> 16ac27a0ecSDave Kleikamp 173dcf5451SChristoph Hellwig #include "ext4_jbd2.h" 18ac27a0ecSDave Kleikamp 19ac27a0ecSDave Kleikamp #define outside(b, first, last) ((b) < (first) || (b) >= (last)) 20ac27a0ecSDave Kleikamp #define inside(b, first, last) ((b) >= (first) && (b) < (last)) 21ac27a0ecSDave Kleikamp 22ac27a0ecSDave Kleikamp static int verify_group_input(struct super_block *sb, 23617ba13bSMingming Cao struct ext4_new_group_data *input) 24ac27a0ecSDave Kleikamp { 25617ba13bSMingming Cao struct ext4_sb_info *sbi = EXT4_SB(sb); 26617ba13bSMingming Cao struct ext4_super_block *es = sbi->s_es; 27bd81d8eeSLaurent Vivier ext4_fsblk_t start = ext4_blocks_count(es); 28617ba13bSMingming Cao ext4_fsblk_t end = start + input->blocks_count; 29fd2d4291SAvantika Mathur ext4_group_t group = input->group; 30617ba13bSMingming Cao ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group; 31617ba13bSMingming Cao unsigned overhead = ext4_bg_has_super(sb, group) ? 32617ba13bSMingming Cao (1 + ext4_bg_num_gdb(sb, group) + 33ac27a0ecSDave Kleikamp le16_to_cpu(es->s_reserved_gdt_blocks)) : 0; 34617ba13bSMingming Cao ext4_fsblk_t metaend = start + overhead; 35ac27a0ecSDave Kleikamp struct buffer_head *bh = NULL; 363a5b2ecdSMingming Cao ext4_grpblk_t free_blocks_count, offset; 37ac27a0ecSDave Kleikamp int err = -EINVAL; 38ac27a0ecSDave Kleikamp 39ac27a0ecSDave Kleikamp input->free_blocks_count = free_blocks_count = 40ac27a0ecSDave Kleikamp input->blocks_count - 2 - overhead - sbi->s_itb_per_group; 41ac27a0ecSDave Kleikamp 42ac27a0ecSDave Kleikamp if (test_opt(sb, DEBUG)) 43617ba13bSMingming Cao printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks " 44ac27a0ecSDave Kleikamp "(%d free, %u reserved)\n", 45617ba13bSMingming Cao ext4_bg_has_super(sb, input->group) ? "normal" : 46ac27a0ecSDave Kleikamp "no-super", input->group, input->blocks_count, 47ac27a0ecSDave Kleikamp free_blocks_count, input->reserved_blocks); 48ac27a0ecSDave Kleikamp 493a5b2ecdSMingming Cao ext4_get_group_no_and_offset(sb, start, NULL, &offset); 50ac27a0ecSDave Kleikamp if (group != sbi->s_groups_count) 5112062dddSEric Sandeen ext4_warning(sb, "Cannot add at group %u (only %u groups)", 52ac27a0ecSDave Kleikamp input->group, sbi->s_groups_count); 533a5b2ecdSMingming Cao else if (offset != 0) 5412062dddSEric Sandeen ext4_warning(sb, "Last group not full"); 55ac27a0ecSDave Kleikamp else if (input->reserved_blocks > input->blocks_count / 5) 5612062dddSEric Sandeen ext4_warning(sb, "Reserved blocks too high (%u)", 57ac27a0ecSDave Kleikamp input->reserved_blocks); 58ac27a0ecSDave Kleikamp else if (free_blocks_count < 0) 5912062dddSEric Sandeen ext4_warning(sb, "Bad blocks count %u", 60ac27a0ecSDave Kleikamp input->blocks_count); 61ac27a0ecSDave Kleikamp else if (!(bh = sb_bread(sb, end - 1))) 6212062dddSEric Sandeen ext4_warning(sb, "Cannot read last block (%llu)", 63ac27a0ecSDave Kleikamp end - 1); 64ac27a0ecSDave Kleikamp else if (outside(input->block_bitmap, start, end)) 6512062dddSEric Sandeen ext4_warning(sb, "Block bitmap not in group (block %llu)", 661939e49aSRandy Dunlap (unsigned long long)input->block_bitmap); 67ac27a0ecSDave Kleikamp else if (outside(input->inode_bitmap, start, end)) 6812062dddSEric Sandeen ext4_warning(sb, "Inode bitmap not in group (block %llu)", 691939e49aSRandy Dunlap (unsigned long long)input->inode_bitmap); 70ac27a0ecSDave Kleikamp else if (outside(input->inode_table, start, end) || 71ac27a0ecSDave Kleikamp outside(itend - 1, start, end)) 7212062dddSEric Sandeen ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)", 731939e49aSRandy Dunlap (unsigned long long)input->inode_table, itend - 1); 74ac27a0ecSDave Kleikamp else if (input->inode_bitmap == input->block_bitmap) 7512062dddSEric Sandeen ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)", 761939e49aSRandy Dunlap (unsigned long long)input->block_bitmap); 77ac27a0ecSDave Kleikamp else if (inside(input->block_bitmap, input->inode_table, itend)) 7812062dddSEric Sandeen ext4_warning(sb, "Block bitmap (%llu) in inode table " 7912062dddSEric Sandeen "(%llu-%llu)", 801939e49aSRandy Dunlap (unsigned long long)input->block_bitmap, 811939e49aSRandy Dunlap (unsigned long long)input->inode_table, itend - 1); 82ac27a0ecSDave Kleikamp else if (inside(input->inode_bitmap, input->inode_table, itend)) 8312062dddSEric Sandeen ext4_warning(sb, "Inode bitmap (%llu) in inode table " 8412062dddSEric Sandeen "(%llu-%llu)", 851939e49aSRandy Dunlap (unsigned long long)input->inode_bitmap, 861939e49aSRandy Dunlap (unsigned long long)input->inode_table, itend - 1); 87ac27a0ecSDave Kleikamp else if (inside(input->block_bitmap, start, metaend)) 8812062dddSEric Sandeen ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)", 891939e49aSRandy Dunlap (unsigned long long)input->block_bitmap, 901939e49aSRandy Dunlap start, metaend - 1); 91ac27a0ecSDave Kleikamp else if (inside(input->inode_bitmap, start, metaend)) 9212062dddSEric Sandeen ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)", 931939e49aSRandy Dunlap (unsigned long long)input->inode_bitmap, 941939e49aSRandy Dunlap start, metaend - 1); 95ac27a0ecSDave Kleikamp else if (inside(input->inode_table, start, metaend) || 96ac27a0ecSDave Kleikamp inside(itend - 1, start, metaend)) 9712062dddSEric Sandeen ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table " 9812062dddSEric Sandeen "(%llu-%llu)", 991939e49aSRandy Dunlap (unsigned long long)input->inode_table, 1001939e49aSRandy Dunlap itend - 1, start, metaend - 1); 101ac27a0ecSDave Kleikamp else 102ac27a0ecSDave Kleikamp err = 0; 103ac27a0ecSDave Kleikamp brelse(bh); 104ac27a0ecSDave Kleikamp 105ac27a0ecSDave Kleikamp return err; 106ac27a0ecSDave Kleikamp } 107ac27a0ecSDave Kleikamp 108ac27a0ecSDave Kleikamp static struct buffer_head *bclean(handle_t *handle, struct super_block *sb, 109617ba13bSMingming Cao ext4_fsblk_t blk) 110ac27a0ecSDave Kleikamp { 111ac27a0ecSDave Kleikamp struct buffer_head *bh; 112ac27a0ecSDave Kleikamp int err; 113ac27a0ecSDave Kleikamp 114ac27a0ecSDave Kleikamp bh = sb_getblk(sb, blk); 115ac27a0ecSDave Kleikamp if (!bh) 116ac27a0ecSDave Kleikamp return ERR_PTR(-EIO); 117617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, bh))) { 118ac27a0ecSDave Kleikamp brelse(bh); 119ac27a0ecSDave Kleikamp bh = ERR_PTR(err); 120ac27a0ecSDave Kleikamp } else { 121ac27a0ecSDave Kleikamp lock_buffer(bh); 122ac27a0ecSDave Kleikamp memset(bh->b_data, 0, sb->s_blocksize); 123ac27a0ecSDave Kleikamp set_buffer_uptodate(bh); 124ac27a0ecSDave Kleikamp unlock_buffer(bh); 125ac27a0ecSDave Kleikamp } 126ac27a0ecSDave Kleikamp 127ac27a0ecSDave Kleikamp return bh; 128ac27a0ecSDave Kleikamp } 129ac27a0ecSDave Kleikamp 130ac27a0ecSDave Kleikamp /* 13114904107SEric Sandeen * If we have fewer than thresh credits, extend by EXT4_MAX_TRANS_DATA. 13214904107SEric Sandeen * If that fails, restart the transaction & regain write access for the 13314904107SEric Sandeen * buffer head which is used for block_bitmap modifications. 13414904107SEric Sandeen */ 13514904107SEric Sandeen static int extend_or_restart_transaction(handle_t *handle, int thresh, 13614904107SEric Sandeen struct buffer_head *bh) 13714904107SEric Sandeen { 13814904107SEric Sandeen int err; 13914904107SEric Sandeen 1400390131bSFrank Mayhar if (ext4_handle_has_enough_credits(handle, thresh)) 14114904107SEric Sandeen return 0; 14214904107SEric Sandeen 14314904107SEric Sandeen err = ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA); 14414904107SEric Sandeen if (err < 0) 14514904107SEric Sandeen return err; 14614904107SEric Sandeen if (err) { 14714904107SEric Sandeen if ((err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA))) 14814904107SEric Sandeen return err; 14914904107SEric Sandeen if ((err = ext4_journal_get_write_access(handle, bh))) 15014904107SEric Sandeen return err; 15114904107SEric Sandeen } 15214904107SEric Sandeen 15314904107SEric Sandeen return 0; 15414904107SEric Sandeen } 15514904107SEric Sandeen 15614904107SEric Sandeen /* 157ac27a0ecSDave Kleikamp * Set up the block and inode bitmaps, and the inode table for the new group. 158ac27a0ecSDave Kleikamp * This doesn't need to be part of the main transaction, since we are only 159ac27a0ecSDave Kleikamp * changing blocks outside the actual filesystem. We still do journaling to 160ac27a0ecSDave Kleikamp * ensure the recovery is correct in case of a failure just after resize. 161ac27a0ecSDave Kleikamp * If any part of this fails, we simply abort the resize. 162ac27a0ecSDave Kleikamp */ 163ac27a0ecSDave Kleikamp static int setup_new_group_blocks(struct super_block *sb, 164617ba13bSMingming Cao struct ext4_new_group_data *input) 165ac27a0ecSDave Kleikamp { 166617ba13bSMingming Cao struct ext4_sb_info *sbi = EXT4_SB(sb); 167617ba13bSMingming Cao ext4_fsblk_t start = ext4_group_first_block_no(sb, input->group); 168617ba13bSMingming Cao int reserved_gdb = ext4_bg_has_super(sb, input->group) ? 169ac27a0ecSDave Kleikamp le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0; 170617ba13bSMingming Cao unsigned long gdblocks = ext4_bg_num_gdb(sb, input->group); 171ac27a0ecSDave Kleikamp struct buffer_head *bh; 172ac27a0ecSDave Kleikamp handle_t *handle; 173617ba13bSMingming Cao ext4_fsblk_t block; 174617ba13bSMingming Cao ext4_grpblk_t bit; 175ac27a0ecSDave Kleikamp int i; 176ac27a0ecSDave Kleikamp int err = 0, err2; 177ac27a0ecSDave Kleikamp 17814904107SEric Sandeen /* This transaction may be extended/restarted along the way */ 17914904107SEric Sandeen handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 18014904107SEric Sandeen 181ac27a0ecSDave Kleikamp if (IS_ERR(handle)) 182ac27a0ecSDave Kleikamp return PTR_ERR(handle); 183ac27a0ecSDave Kleikamp 18432ed5058STheodore Ts'o mutex_lock(&sbi->s_resize_lock); 185ac27a0ecSDave Kleikamp if (input->group != sbi->s_groups_count) { 186ac27a0ecSDave Kleikamp err = -EBUSY; 187ac27a0ecSDave Kleikamp goto exit_journal; 188ac27a0ecSDave Kleikamp } 189ac27a0ecSDave Kleikamp 190ac27a0ecSDave Kleikamp if (IS_ERR(bh = bclean(handle, sb, input->block_bitmap))) { 191ac27a0ecSDave Kleikamp err = PTR_ERR(bh); 192ac27a0ecSDave Kleikamp goto exit_journal; 193ac27a0ecSDave Kleikamp } 194ac27a0ecSDave Kleikamp 195617ba13bSMingming Cao if (ext4_bg_has_super(sb, input->group)) { 196c549a95dSEric Sandeen ext4_debug("mark backup superblock %#04llx (+0)\n", start); 197617ba13bSMingming Cao ext4_set_bit(0, bh->b_data); 198ac27a0ecSDave Kleikamp } 199ac27a0ecSDave Kleikamp 200ac27a0ecSDave Kleikamp /* Copy all of the GDT blocks into the backup in this group */ 201ac27a0ecSDave Kleikamp for (i = 0, bit = 1, block = start + 1; 202ac27a0ecSDave Kleikamp i < gdblocks; i++, block++, bit++) { 203ac27a0ecSDave Kleikamp struct buffer_head *gdb; 204ac27a0ecSDave Kleikamp 205c549a95dSEric Sandeen ext4_debug("update backup group %#04llx (+%d)\n", block, bit); 206ac27a0ecSDave Kleikamp 20714904107SEric Sandeen if ((err = extend_or_restart_transaction(handle, 1, bh))) 20814904107SEric Sandeen goto exit_bh; 20914904107SEric Sandeen 210ac27a0ecSDave Kleikamp gdb = sb_getblk(sb, block); 211ac27a0ecSDave Kleikamp if (!gdb) { 212ac27a0ecSDave Kleikamp err = -EIO; 213ac27a0ecSDave Kleikamp goto exit_bh; 214ac27a0ecSDave Kleikamp } 215617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, gdb))) { 216ac27a0ecSDave Kleikamp brelse(gdb); 217ac27a0ecSDave Kleikamp goto exit_bh; 218ac27a0ecSDave Kleikamp } 2195b615287SEric Sandeen lock_buffer(gdb); 2205b615287SEric Sandeen memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, gdb->b_size); 221ac27a0ecSDave Kleikamp set_buffer_uptodate(gdb); 2225b615287SEric Sandeen unlock_buffer(gdb); 2230390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, gdb); 224617ba13bSMingming Cao ext4_set_bit(bit, bh->b_data); 225ac27a0ecSDave Kleikamp brelse(gdb); 226ac27a0ecSDave Kleikamp } 227ac27a0ecSDave Kleikamp 228ac27a0ecSDave Kleikamp /* Zero out all of the reserved backup group descriptor table blocks */ 229a31437b8SLukas Czerner ext4_debug("clear inode table blocks %#04llx -> %#04llx\n", 230a31437b8SLukas Czerner block, sbi->s_itb_per_group); 231a31437b8SLukas Czerner err = sb_issue_zeroout(sb, gdblocks + start + 1, reserved_gdb, 232a107e5a3STheodore Ts'o GFP_NOFS); 233a31437b8SLukas Czerner if (err) 23414904107SEric Sandeen goto exit_bh; 2358a7411a2STheodore Ts'o for (i = 0, bit = gdblocks + 1; i < reserved_gdb; i++, bit++) 2368a7411a2STheodore Ts'o ext4_set_bit(bit, bh->b_data); 23714904107SEric Sandeen 238c549a95dSEric Sandeen ext4_debug("mark block bitmap %#04llx (+%llu)\n", input->block_bitmap, 239ac27a0ecSDave Kleikamp input->block_bitmap - start); 240617ba13bSMingming Cao ext4_set_bit(input->block_bitmap - start, bh->b_data); 241c549a95dSEric Sandeen ext4_debug("mark inode bitmap %#04llx (+%llu)\n", input->inode_bitmap, 242ac27a0ecSDave Kleikamp input->inode_bitmap - start); 243617ba13bSMingming Cao ext4_set_bit(input->inode_bitmap - start, bh->b_data); 244ac27a0ecSDave Kleikamp 245ac27a0ecSDave Kleikamp /* Zero out all of the inode table blocks */ 246a31437b8SLukas Czerner block = input->inode_table; 247a31437b8SLukas Czerner ext4_debug("clear inode table blocks %#04llx -> %#04llx\n", 248a31437b8SLukas Czerner block, sbi->s_itb_per_group); 249a107e5a3STheodore Ts'o err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group, GFP_NOFS); 250a31437b8SLukas Czerner if (err) 25114904107SEric Sandeen goto exit_bh; 2528a7411a2STheodore Ts'o for (i = 0, bit = input->inode_table - start; 2538a7411a2STheodore Ts'o i < sbi->s_itb_per_group; i++, bit++) 2548a7411a2STheodore Ts'o ext4_set_bit(bit, bh->b_data); 25514904107SEric Sandeen 25614904107SEric Sandeen if ((err = extend_or_restart_transaction(handle, 2, bh))) 25714904107SEric Sandeen goto exit_bh; 25814904107SEric Sandeen 25961d08673STheodore Ts'o ext4_mark_bitmap_end(input->blocks_count, sb->s_blocksize * 8, 26061d08673STheodore Ts'o bh->b_data); 2610390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, bh); 262ac27a0ecSDave Kleikamp brelse(bh); 263ac27a0ecSDave Kleikamp /* Mark unused entries in inode bitmap used */ 264c549a95dSEric Sandeen ext4_debug("clear inode bitmap %#04llx (+%llu)\n", 265ac27a0ecSDave Kleikamp input->inode_bitmap, input->inode_bitmap - start); 266ac27a0ecSDave Kleikamp if (IS_ERR(bh = bclean(handle, sb, input->inode_bitmap))) { 267ac27a0ecSDave Kleikamp err = PTR_ERR(bh); 268ac27a0ecSDave Kleikamp goto exit_journal; 269ac27a0ecSDave Kleikamp } 270ac27a0ecSDave Kleikamp 27161d08673STheodore Ts'o ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8, 272ac27a0ecSDave Kleikamp bh->b_data); 2730390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, bh); 274ac27a0ecSDave Kleikamp exit_bh: 275ac27a0ecSDave Kleikamp brelse(bh); 276ac27a0ecSDave Kleikamp 277ac27a0ecSDave Kleikamp exit_journal: 27832ed5058STheodore Ts'o mutex_unlock(&sbi->s_resize_lock); 279617ba13bSMingming Cao if ((err2 = ext4_journal_stop(handle)) && !err) 280ac27a0ecSDave Kleikamp err = err2; 281ac27a0ecSDave Kleikamp 282ac27a0ecSDave Kleikamp return err; 283ac27a0ecSDave Kleikamp } 284ac27a0ecSDave Kleikamp 285ac27a0ecSDave Kleikamp /* 286ac27a0ecSDave Kleikamp * Iterate through the groups which hold BACKUP superblock/GDT copies in an 287617ba13bSMingming Cao * ext4 filesystem. The counters should be initialized to 1, 5, and 7 before 288ac27a0ecSDave Kleikamp * calling this for the first time. In a sparse filesystem it will be the 289ac27a0ecSDave Kleikamp * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ... 290ac27a0ecSDave Kleikamp * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ... 291ac27a0ecSDave Kleikamp */ 292617ba13bSMingming Cao static unsigned ext4_list_backups(struct super_block *sb, unsigned *three, 293ac27a0ecSDave Kleikamp unsigned *five, unsigned *seven) 294ac27a0ecSDave Kleikamp { 295ac27a0ecSDave Kleikamp unsigned *min = three; 296ac27a0ecSDave Kleikamp int mult = 3; 297ac27a0ecSDave Kleikamp unsigned ret; 298ac27a0ecSDave Kleikamp 299617ba13bSMingming Cao if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 300617ba13bSMingming Cao EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 301ac27a0ecSDave Kleikamp ret = *min; 302ac27a0ecSDave Kleikamp *min += 1; 303ac27a0ecSDave Kleikamp return ret; 304ac27a0ecSDave Kleikamp } 305ac27a0ecSDave Kleikamp 306ac27a0ecSDave Kleikamp if (*five < *min) { 307ac27a0ecSDave Kleikamp min = five; 308ac27a0ecSDave Kleikamp mult = 5; 309ac27a0ecSDave Kleikamp } 310ac27a0ecSDave Kleikamp if (*seven < *min) { 311ac27a0ecSDave Kleikamp min = seven; 312ac27a0ecSDave Kleikamp mult = 7; 313ac27a0ecSDave Kleikamp } 314ac27a0ecSDave Kleikamp 315ac27a0ecSDave Kleikamp ret = *min; 316ac27a0ecSDave Kleikamp *min *= mult; 317ac27a0ecSDave Kleikamp 318ac27a0ecSDave Kleikamp return ret; 319ac27a0ecSDave Kleikamp } 320ac27a0ecSDave Kleikamp 321ac27a0ecSDave Kleikamp /* 322ac27a0ecSDave Kleikamp * Check that all of the backup GDT blocks are held in the primary GDT block. 323ac27a0ecSDave Kleikamp * It is assumed that they are stored in group order. Returns the number of 324ac27a0ecSDave Kleikamp * groups in current filesystem that have BACKUPS, or -ve error code. 325ac27a0ecSDave Kleikamp */ 326ac27a0ecSDave Kleikamp static int verify_reserved_gdb(struct super_block *sb, 327ac27a0ecSDave Kleikamp struct buffer_head *primary) 328ac27a0ecSDave Kleikamp { 329617ba13bSMingming Cao const ext4_fsblk_t blk = primary->b_blocknr; 330fd2d4291SAvantika Mathur const ext4_group_t end = EXT4_SB(sb)->s_groups_count; 331ac27a0ecSDave Kleikamp unsigned three = 1; 332ac27a0ecSDave Kleikamp unsigned five = 5; 333ac27a0ecSDave Kleikamp unsigned seven = 7; 334ac27a0ecSDave Kleikamp unsigned grp; 335ac27a0ecSDave Kleikamp __le32 *p = (__le32 *)primary->b_data; 336ac27a0ecSDave Kleikamp int gdbackups = 0; 337ac27a0ecSDave Kleikamp 338617ba13bSMingming Cao while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) { 339bd81d8eeSLaurent Vivier if (le32_to_cpu(*p++) != 340bd81d8eeSLaurent Vivier grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){ 34112062dddSEric Sandeen ext4_warning(sb, "reserved GDT %llu" 3422ae02107SMingming Cao " missing grp %d (%llu)", 343ac27a0ecSDave Kleikamp blk, grp, 344bd81d8eeSLaurent Vivier grp * 345bd81d8eeSLaurent Vivier (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) + 346bd81d8eeSLaurent Vivier blk); 347ac27a0ecSDave Kleikamp return -EINVAL; 348ac27a0ecSDave Kleikamp } 349617ba13bSMingming Cao if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb)) 350ac27a0ecSDave Kleikamp return -EFBIG; 351ac27a0ecSDave Kleikamp } 352ac27a0ecSDave Kleikamp 353ac27a0ecSDave Kleikamp return gdbackups; 354ac27a0ecSDave Kleikamp } 355ac27a0ecSDave Kleikamp 356ac27a0ecSDave Kleikamp /* 357ac27a0ecSDave Kleikamp * Called when we need to bring a reserved group descriptor table block into 358ac27a0ecSDave Kleikamp * use from the resize inode. The primary copy of the new GDT block currently 359ac27a0ecSDave Kleikamp * is an indirect block (under the double indirect block in the resize inode). 360ac27a0ecSDave Kleikamp * The new backup GDT blocks will be stored as leaf blocks in this indirect 361ac27a0ecSDave Kleikamp * block, in group order. Even though we know all the block numbers we need, 362ac27a0ecSDave Kleikamp * we check to ensure that the resize inode has actually reserved these blocks. 363ac27a0ecSDave Kleikamp * 364ac27a0ecSDave Kleikamp * Don't need to update the block bitmaps because the blocks are still in use. 365ac27a0ecSDave Kleikamp * 366ac27a0ecSDave Kleikamp * We get all of the error cases out of the way, so that we are sure to not 367ac27a0ecSDave Kleikamp * fail once we start modifying the data on disk, because JBD has no rollback. 368ac27a0ecSDave Kleikamp */ 369ac27a0ecSDave Kleikamp static int add_new_gdb(handle_t *handle, struct inode *inode, 370617ba13bSMingming Cao struct ext4_new_group_data *input, 371ac27a0ecSDave Kleikamp struct buffer_head **primary) 372ac27a0ecSDave Kleikamp { 373ac27a0ecSDave Kleikamp struct super_block *sb = inode->i_sb; 374617ba13bSMingming Cao struct ext4_super_block *es = EXT4_SB(sb)->s_es; 375617ba13bSMingming Cao unsigned long gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb); 376617ba13bSMingming Cao ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num; 377ac27a0ecSDave Kleikamp struct buffer_head **o_group_desc, **n_group_desc; 378ac27a0ecSDave Kleikamp struct buffer_head *dind; 379ac27a0ecSDave Kleikamp int gdbackups; 380617ba13bSMingming Cao struct ext4_iloc iloc; 381ac27a0ecSDave Kleikamp __le32 *data; 382ac27a0ecSDave Kleikamp int err; 383ac27a0ecSDave Kleikamp 384ac27a0ecSDave Kleikamp if (test_opt(sb, DEBUG)) 385ac27a0ecSDave Kleikamp printk(KERN_DEBUG 386617ba13bSMingming Cao "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n", 387ac27a0ecSDave Kleikamp gdb_num); 388ac27a0ecSDave Kleikamp 389ac27a0ecSDave Kleikamp /* 390ac27a0ecSDave Kleikamp * If we are not using the primary superblock/GDT copy don't resize, 391ac27a0ecSDave Kleikamp * because the user tools have no way of handling this. Probably a 392ac27a0ecSDave Kleikamp * bad time to do it anyways. 393ac27a0ecSDave Kleikamp */ 394617ba13bSMingming Cao if (EXT4_SB(sb)->s_sbh->b_blocknr != 395617ba13bSMingming Cao le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) { 39612062dddSEric Sandeen ext4_warning(sb, "won't resize using backup superblock at %llu", 397617ba13bSMingming Cao (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr); 398ac27a0ecSDave Kleikamp return -EPERM; 399ac27a0ecSDave Kleikamp } 400ac27a0ecSDave Kleikamp 401ac27a0ecSDave Kleikamp *primary = sb_bread(sb, gdblock); 402ac27a0ecSDave Kleikamp if (!*primary) 403ac27a0ecSDave Kleikamp return -EIO; 404ac27a0ecSDave Kleikamp 405ac27a0ecSDave Kleikamp if ((gdbackups = verify_reserved_gdb(sb, *primary)) < 0) { 406ac27a0ecSDave Kleikamp err = gdbackups; 407ac27a0ecSDave Kleikamp goto exit_bh; 408ac27a0ecSDave Kleikamp } 409ac27a0ecSDave Kleikamp 410617ba13bSMingming Cao data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; 411ac27a0ecSDave Kleikamp dind = sb_bread(sb, le32_to_cpu(*data)); 412ac27a0ecSDave Kleikamp if (!dind) { 413ac27a0ecSDave Kleikamp err = -EIO; 414ac27a0ecSDave Kleikamp goto exit_bh; 415ac27a0ecSDave Kleikamp } 416ac27a0ecSDave Kleikamp 417ac27a0ecSDave Kleikamp data = (__le32 *)dind->b_data; 418617ba13bSMingming Cao if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) { 41912062dddSEric Sandeen ext4_warning(sb, "new group %u GDT block %llu not reserved", 420ac27a0ecSDave Kleikamp input->group, gdblock); 421ac27a0ecSDave Kleikamp err = -EINVAL; 422ac27a0ecSDave Kleikamp goto exit_dind; 423ac27a0ecSDave Kleikamp } 424ac27a0ecSDave Kleikamp 425617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh))) 426ac27a0ecSDave Kleikamp goto exit_dind; 427ac27a0ecSDave Kleikamp 428617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, *primary))) 429ac27a0ecSDave Kleikamp goto exit_sbh; 430ac27a0ecSDave Kleikamp 431617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, dind))) 432ac27a0ecSDave Kleikamp goto exit_primary; 433ac27a0ecSDave Kleikamp 434617ba13bSMingming Cao /* ext4_reserve_inode_write() gets a reference on the iloc */ 435617ba13bSMingming Cao if ((err = ext4_reserve_inode_write(handle, inode, &iloc))) 436ac27a0ecSDave Kleikamp goto exit_dindj; 437ac27a0ecSDave Kleikamp 438ac27a0ecSDave Kleikamp n_group_desc = kmalloc((gdb_num + 1) * sizeof(struct buffer_head *), 439216553c4SJosef Bacik GFP_NOFS); 440ac27a0ecSDave Kleikamp if (!n_group_desc) { 441ac27a0ecSDave Kleikamp err = -ENOMEM; 44212062dddSEric Sandeen ext4_warning(sb, 443ac27a0ecSDave Kleikamp "not enough memory for %lu groups", gdb_num + 1); 444ac27a0ecSDave Kleikamp goto exit_inode; 445ac27a0ecSDave Kleikamp } 446ac27a0ecSDave Kleikamp 447ac27a0ecSDave Kleikamp /* 448ac27a0ecSDave Kleikamp * Finally, we have all of the possible failures behind us... 449ac27a0ecSDave Kleikamp * 450ac27a0ecSDave Kleikamp * Remove new GDT block from inode double-indirect block and clear out 451ac27a0ecSDave Kleikamp * the new GDT block for use (which also "frees" the backup GDT blocks 452ac27a0ecSDave Kleikamp * from the reserved inode). We don't need to change the bitmaps for 453ac27a0ecSDave Kleikamp * these blocks, because they are marked as in-use from being in the 454ac27a0ecSDave Kleikamp * reserved inode, and will become GDT blocks (primary and backup). 455ac27a0ecSDave Kleikamp */ 456617ba13bSMingming Cao data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)] = 0; 4570390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, dind); 458ac27a0ecSDave Kleikamp brelse(dind); 459ac27a0ecSDave Kleikamp inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9; 460617ba13bSMingming Cao ext4_mark_iloc_dirty(handle, inode, &iloc); 461ac27a0ecSDave Kleikamp memset((*primary)->b_data, 0, sb->s_blocksize); 4620390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, *primary); 463ac27a0ecSDave Kleikamp 464617ba13bSMingming Cao o_group_desc = EXT4_SB(sb)->s_group_desc; 465ac27a0ecSDave Kleikamp memcpy(n_group_desc, o_group_desc, 466617ba13bSMingming Cao EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); 467ac27a0ecSDave Kleikamp n_group_desc[gdb_num] = *primary; 468617ba13bSMingming Cao EXT4_SB(sb)->s_group_desc = n_group_desc; 469617ba13bSMingming Cao EXT4_SB(sb)->s_gdb_count++; 470ac27a0ecSDave Kleikamp kfree(o_group_desc); 471ac27a0ecSDave Kleikamp 472e8546d06SMarcin Slusarz le16_add_cpu(&es->s_reserved_gdt_blocks, -1); 4730390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh); 474ac27a0ecSDave Kleikamp 475ac27a0ecSDave Kleikamp return 0; 476ac27a0ecSDave Kleikamp 477ac27a0ecSDave Kleikamp exit_inode: 4782b2d6d01STheodore Ts'o /* ext4_journal_release_buffer(handle, iloc.bh); */ 479ac27a0ecSDave Kleikamp brelse(iloc.bh); 480ac27a0ecSDave Kleikamp exit_dindj: 4812b2d6d01STheodore Ts'o /* ext4_journal_release_buffer(handle, dind); */ 482ac27a0ecSDave Kleikamp exit_primary: 4832b2d6d01STheodore Ts'o /* ext4_journal_release_buffer(handle, *primary); */ 484ac27a0ecSDave Kleikamp exit_sbh: 4852b2d6d01STheodore Ts'o /* ext4_journal_release_buffer(handle, *primary); */ 486ac27a0ecSDave Kleikamp exit_dind: 487ac27a0ecSDave Kleikamp brelse(dind); 488ac27a0ecSDave Kleikamp exit_bh: 489ac27a0ecSDave Kleikamp brelse(*primary); 490ac27a0ecSDave Kleikamp 491617ba13bSMingming Cao ext4_debug("leaving with error %d\n", err); 492ac27a0ecSDave Kleikamp return err; 493ac27a0ecSDave Kleikamp } 494ac27a0ecSDave Kleikamp 495ac27a0ecSDave Kleikamp /* 496ac27a0ecSDave Kleikamp * Called when we are adding a new group which has a backup copy of each of 497ac27a0ecSDave Kleikamp * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks. 498ac27a0ecSDave Kleikamp * We need to add these reserved backup GDT blocks to the resize inode, so 499ac27a0ecSDave Kleikamp * that they are kept for future resizing and not allocated to files. 500ac27a0ecSDave Kleikamp * 501ac27a0ecSDave Kleikamp * Each reserved backup GDT block will go into a different indirect block. 502ac27a0ecSDave Kleikamp * The indirect blocks are actually the primary reserved GDT blocks, 503ac27a0ecSDave Kleikamp * so we know in advance what their block numbers are. We only get the 504ac27a0ecSDave Kleikamp * double-indirect block to verify it is pointing to the primary reserved 505ac27a0ecSDave Kleikamp * GDT blocks so we don't overwrite a data block by accident. The reserved 506ac27a0ecSDave Kleikamp * backup GDT blocks are stored in their reserved primary GDT block. 507ac27a0ecSDave Kleikamp */ 508ac27a0ecSDave Kleikamp static int reserve_backup_gdb(handle_t *handle, struct inode *inode, 509617ba13bSMingming Cao struct ext4_new_group_data *input) 510ac27a0ecSDave Kleikamp { 511ac27a0ecSDave Kleikamp struct super_block *sb = inode->i_sb; 512617ba13bSMingming Cao int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); 513ac27a0ecSDave Kleikamp struct buffer_head **primary; 514ac27a0ecSDave Kleikamp struct buffer_head *dind; 515617ba13bSMingming Cao struct ext4_iloc iloc; 516617ba13bSMingming Cao ext4_fsblk_t blk; 517ac27a0ecSDave Kleikamp __le32 *data, *end; 518ac27a0ecSDave Kleikamp int gdbackups = 0; 519ac27a0ecSDave Kleikamp int res, i; 520ac27a0ecSDave Kleikamp int err; 521ac27a0ecSDave Kleikamp 522216553c4SJosef Bacik primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS); 523ac27a0ecSDave Kleikamp if (!primary) 524ac27a0ecSDave Kleikamp return -ENOMEM; 525ac27a0ecSDave Kleikamp 526617ba13bSMingming Cao data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; 527ac27a0ecSDave Kleikamp dind = sb_bread(sb, le32_to_cpu(*data)); 528ac27a0ecSDave Kleikamp if (!dind) { 529ac27a0ecSDave Kleikamp err = -EIO; 530ac27a0ecSDave Kleikamp goto exit_free; 531ac27a0ecSDave Kleikamp } 532ac27a0ecSDave Kleikamp 533617ba13bSMingming Cao blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count; 53494460093SJosef Bacik data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count % 53594460093SJosef Bacik EXT4_ADDR_PER_BLOCK(sb)); 536617ba13bSMingming Cao end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb); 537ac27a0ecSDave Kleikamp 538ac27a0ecSDave Kleikamp /* Get each reserved primary GDT block and verify it holds backups */ 539ac27a0ecSDave Kleikamp for (res = 0; res < reserved_gdb; res++, blk++) { 540ac27a0ecSDave Kleikamp if (le32_to_cpu(*data) != blk) { 54112062dddSEric Sandeen ext4_warning(sb, "reserved block %llu" 542ac27a0ecSDave Kleikamp " not at offset %ld", 543ac27a0ecSDave Kleikamp blk, 544ac27a0ecSDave Kleikamp (long)(data - (__le32 *)dind->b_data)); 545ac27a0ecSDave Kleikamp err = -EINVAL; 546ac27a0ecSDave Kleikamp goto exit_bh; 547ac27a0ecSDave Kleikamp } 548ac27a0ecSDave Kleikamp primary[res] = sb_bread(sb, blk); 549ac27a0ecSDave Kleikamp if (!primary[res]) { 550ac27a0ecSDave Kleikamp err = -EIO; 551ac27a0ecSDave Kleikamp goto exit_bh; 552ac27a0ecSDave Kleikamp } 553ac27a0ecSDave Kleikamp if ((gdbackups = verify_reserved_gdb(sb, primary[res])) < 0) { 554ac27a0ecSDave Kleikamp brelse(primary[res]); 555ac27a0ecSDave Kleikamp err = gdbackups; 556ac27a0ecSDave Kleikamp goto exit_bh; 557ac27a0ecSDave Kleikamp } 558ac27a0ecSDave Kleikamp if (++data >= end) 559ac27a0ecSDave Kleikamp data = (__le32 *)dind->b_data; 560ac27a0ecSDave Kleikamp } 561ac27a0ecSDave Kleikamp 562ac27a0ecSDave Kleikamp for (i = 0; i < reserved_gdb; i++) { 563617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, primary[i]))) { 564ac27a0ecSDave Kleikamp /* 565ac27a0ecSDave Kleikamp int j; 566ac27a0ecSDave Kleikamp for (j = 0; j < i; j++) 567617ba13bSMingming Cao ext4_journal_release_buffer(handle, primary[j]); 568ac27a0ecSDave Kleikamp */ 569ac27a0ecSDave Kleikamp goto exit_bh; 570ac27a0ecSDave Kleikamp } 571ac27a0ecSDave Kleikamp } 572ac27a0ecSDave Kleikamp 573617ba13bSMingming Cao if ((err = ext4_reserve_inode_write(handle, inode, &iloc))) 574ac27a0ecSDave Kleikamp goto exit_bh; 575ac27a0ecSDave Kleikamp 576ac27a0ecSDave Kleikamp /* 577ac27a0ecSDave Kleikamp * Finally we can add each of the reserved backup GDT blocks from 578ac27a0ecSDave Kleikamp * the new group to its reserved primary GDT block. 579ac27a0ecSDave Kleikamp */ 580617ba13bSMingming Cao blk = input->group * EXT4_BLOCKS_PER_GROUP(sb); 581ac27a0ecSDave Kleikamp for (i = 0; i < reserved_gdb; i++) { 582ac27a0ecSDave Kleikamp int err2; 583ac27a0ecSDave Kleikamp data = (__le32 *)primary[i]->b_data; 584ac27a0ecSDave Kleikamp /* printk("reserving backup %lu[%u] = %lu\n", 585ac27a0ecSDave Kleikamp primary[i]->b_blocknr, gdbackups, 586ac27a0ecSDave Kleikamp blk + primary[i]->b_blocknr); */ 587ac27a0ecSDave Kleikamp data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr); 5880390131bSFrank Mayhar err2 = ext4_handle_dirty_metadata(handle, NULL, primary[i]); 589ac27a0ecSDave Kleikamp if (!err) 590ac27a0ecSDave Kleikamp err = err2; 591ac27a0ecSDave Kleikamp } 592ac27a0ecSDave Kleikamp inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9; 593617ba13bSMingming Cao ext4_mark_iloc_dirty(handle, inode, &iloc); 594ac27a0ecSDave Kleikamp 595ac27a0ecSDave Kleikamp exit_bh: 596ac27a0ecSDave Kleikamp while (--res >= 0) 597ac27a0ecSDave Kleikamp brelse(primary[res]); 598ac27a0ecSDave Kleikamp brelse(dind); 599ac27a0ecSDave Kleikamp 600ac27a0ecSDave Kleikamp exit_free: 601ac27a0ecSDave Kleikamp kfree(primary); 602ac27a0ecSDave Kleikamp 603ac27a0ecSDave Kleikamp return err; 604ac27a0ecSDave Kleikamp } 605ac27a0ecSDave Kleikamp 606ac27a0ecSDave Kleikamp /* 607617ba13bSMingming Cao * Update the backup copies of the ext4 metadata. These don't need to be part 608ac27a0ecSDave Kleikamp * of the main resize transaction, because e2fsck will re-write them if there 609ac27a0ecSDave Kleikamp * is a problem (basically only OOM will cause a problem). However, we 610ac27a0ecSDave Kleikamp * _should_ update the backups if possible, in case the primary gets trashed 611ac27a0ecSDave Kleikamp * for some reason and we need to run e2fsck from a backup superblock. The 612ac27a0ecSDave Kleikamp * important part is that the new block and inode counts are in the backup 613ac27a0ecSDave Kleikamp * superblocks, and the location of the new group metadata in the GDT backups. 614ac27a0ecSDave Kleikamp * 61532ed5058STheodore Ts'o * We do not need take the s_resize_lock for this, because these 61632ed5058STheodore Ts'o * blocks are not otherwise touched by the filesystem code when it is 61732ed5058STheodore Ts'o * mounted. We don't need to worry about last changing from 61832ed5058STheodore Ts'o * sbi->s_groups_count, because the worst that can happen is that we 61932ed5058STheodore Ts'o * do not copy the full number of backups at this time. The resize 62032ed5058STheodore Ts'o * which changed s_groups_count will backup again. 621ac27a0ecSDave Kleikamp */ 622ac27a0ecSDave Kleikamp static void update_backups(struct super_block *sb, 623ac27a0ecSDave Kleikamp int blk_off, char *data, int size) 624ac27a0ecSDave Kleikamp { 625617ba13bSMingming Cao struct ext4_sb_info *sbi = EXT4_SB(sb); 626fd2d4291SAvantika Mathur const ext4_group_t last = sbi->s_groups_count; 627617ba13bSMingming Cao const int bpg = EXT4_BLOCKS_PER_GROUP(sb); 628ac27a0ecSDave Kleikamp unsigned three = 1; 629ac27a0ecSDave Kleikamp unsigned five = 5; 630ac27a0ecSDave Kleikamp unsigned seven = 7; 631fd2d4291SAvantika Mathur ext4_group_t group; 632ac27a0ecSDave Kleikamp int rest = sb->s_blocksize - size; 633ac27a0ecSDave Kleikamp handle_t *handle; 634ac27a0ecSDave Kleikamp int err = 0, err2; 635ac27a0ecSDave Kleikamp 636617ba13bSMingming Cao handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 637ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 638ac27a0ecSDave Kleikamp group = 1; 639ac27a0ecSDave Kleikamp err = PTR_ERR(handle); 640ac27a0ecSDave Kleikamp goto exit_err; 641ac27a0ecSDave Kleikamp } 642ac27a0ecSDave Kleikamp 643617ba13bSMingming Cao while ((group = ext4_list_backups(sb, &three, &five, &seven)) < last) { 644ac27a0ecSDave Kleikamp struct buffer_head *bh; 645ac27a0ecSDave Kleikamp 646ac27a0ecSDave Kleikamp /* Out of journal space, and can't get more - abort - so sad */ 6470390131bSFrank Mayhar if (ext4_handle_valid(handle) && 6480390131bSFrank Mayhar handle->h_buffer_credits == 0 && 649617ba13bSMingming Cao ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) && 650617ba13bSMingming Cao (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA))) 651ac27a0ecSDave Kleikamp break; 652ac27a0ecSDave Kleikamp 653ac27a0ecSDave Kleikamp bh = sb_getblk(sb, group * bpg + blk_off); 654ac27a0ecSDave Kleikamp if (!bh) { 655ac27a0ecSDave Kleikamp err = -EIO; 656ac27a0ecSDave Kleikamp break; 657ac27a0ecSDave Kleikamp } 658617ba13bSMingming Cao ext4_debug("update metadata backup %#04lx\n", 659ac27a0ecSDave Kleikamp (unsigned long)bh->b_blocknr); 660617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, bh))) 661ac27a0ecSDave Kleikamp break; 662ac27a0ecSDave Kleikamp lock_buffer(bh); 663ac27a0ecSDave Kleikamp memcpy(bh->b_data, data, size); 664ac27a0ecSDave Kleikamp if (rest) 665ac27a0ecSDave Kleikamp memset(bh->b_data + size, 0, rest); 666ac27a0ecSDave Kleikamp set_buffer_uptodate(bh); 667ac27a0ecSDave Kleikamp unlock_buffer(bh); 6680390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, bh); 669ac27a0ecSDave Kleikamp brelse(bh); 670ac27a0ecSDave Kleikamp } 671617ba13bSMingming Cao if ((err2 = ext4_journal_stop(handle)) && !err) 672ac27a0ecSDave Kleikamp err = err2; 673ac27a0ecSDave Kleikamp 674ac27a0ecSDave Kleikamp /* 675ac27a0ecSDave Kleikamp * Ugh! Need to have e2fsck write the backup copies. It is too 676ac27a0ecSDave Kleikamp * late to revert the resize, we shouldn't fail just because of 677ac27a0ecSDave Kleikamp * the backup copies (they are only needed in case of corruption). 678ac27a0ecSDave Kleikamp * 679ac27a0ecSDave Kleikamp * However, if we got here we have a journal problem too, so we 680ac27a0ecSDave Kleikamp * can't really start a transaction to mark the superblock. 681ac27a0ecSDave Kleikamp * Chicken out and just set the flag on the hope it will be written 682ac27a0ecSDave Kleikamp * to disk, and if not - we will simply wait until next fsck. 683ac27a0ecSDave Kleikamp */ 684ac27a0ecSDave Kleikamp exit_err: 685ac27a0ecSDave Kleikamp if (err) { 68612062dddSEric Sandeen ext4_warning(sb, "can't update backup for group %u (err %d), " 687ac27a0ecSDave Kleikamp "forcing fsck on next reboot", group, err); 688617ba13bSMingming Cao sbi->s_mount_state &= ~EXT4_VALID_FS; 689617ba13bSMingming Cao sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS); 690ac27a0ecSDave Kleikamp mark_buffer_dirty(sbi->s_sbh); 691ac27a0ecSDave Kleikamp } 692ac27a0ecSDave Kleikamp } 693ac27a0ecSDave Kleikamp 694ac27a0ecSDave Kleikamp /* Add group descriptor data to an existing or new group descriptor block. 695ac27a0ecSDave Kleikamp * Ensure we handle all possible error conditions _before_ we start modifying 696ac27a0ecSDave Kleikamp * the filesystem, because we cannot abort the transaction and not have it 697ac27a0ecSDave Kleikamp * write the data to disk. 698ac27a0ecSDave Kleikamp * 699ac27a0ecSDave Kleikamp * If we are on a GDT block boundary, we need to get the reserved GDT block. 700ac27a0ecSDave Kleikamp * Otherwise, we may need to add backup GDT blocks for a sparse group. 701ac27a0ecSDave Kleikamp * 702ac27a0ecSDave Kleikamp * We only need to hold the superblock lock while we are actually adding 703ac27a0ecSDave Kleikamp * in the new group's counts to the superblock. Prior to that we have 704ac27a0ecSDave Kleikamp * not really "added" the group at all. We re-check that we are still 705ac27a0ecSDave Kleikamp * adding in the last group in case things have changed since verifying. 706ac27a0ecSDave Kleikamp */ 707617ba13bSMingming Cao int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) 708ac27a0ecSDave Kleikamp { 709617ba13bSMingming Cao struct ext4_sb_info *sbi = EXT4_SB(sb); 710617ba13bSMingming Cao struct ext4_super_block *es = sbi->s_es; 711617ba13bSMingming Cao int reserved_gdb = ext4_bg_has_super(sb, input->group) ? 712ac27a0ecSDave Kleikamp le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 713ac27a0ecSDave Kleikamp struct buffer_head *primary = NULL; 714617ba13bSMingming Cao struct ext4_group_desc *gdp; 715ac27a0ecSDave Kleikamp struct inode *inode = NULL; 716ac27a0ecSDave Kleikamp handle_t *handle; 717ac27a0ecSDave Kleikamp int gdb_off, gdb_num; 718ac27a0ecSDave Kleikamp int err, err2; 719ac27a0ecSDave Kleikamp 720617ba13bSMingming Cao gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb); 721617ba13bSMingming Cao gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); 722ac27a0ecSDave Kleikamp 723617ba13bSMingming Cao if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb, 724617ba13bSMingming Cao EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 72512062dddSEric Sandeen ext4_warning(sb, "Can't resize non-sparse filesystem further"); 726ac27a0ecSDave Kleikamp return -EPERM; 727ac27a0ecSDave Kleikamp } 728ac27a0ecSDave Kleikamp 729bd81d8eeSLaurent Vivier if (ext4_blocks_count(es) + input->blocks_count < 730bd81d8eeSLaurent Vivier ext4_blocks_count(es)) { 73112062dddSEric Sandeen ext4_warning(sb, "blocks_count overflow"); 732ac27a0ecSDave Kleikamp return -EINVAL; 733ac27a0ecSDave Kleikamp } 734ac27a0ecSDave Kleikamp 735617ba13bSMingming Cao if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < 736ac27a0ecSDave Kleikamp le32_to_cpu(es->s_inodes_count)) { 73712062dddSEric Sandeen ext4_warning(sb, "inodes_count overflow"); 738ac27a0ecSDave Kleikamp return -EINVAL; 739ac27a0ecSDave Kleikamp } 740ac27a0ecSDave Kleikamp 741ac27a0ecSDave Kleikamp if (reserved_gdb || gdb_off == 0) { 742617ba13bSMingming Cao if (!EXT4_HAS_COMPAT_FEATURE(sb, 74337609fd5SJosef Bacik EXT4_FEATURE_COMPAT_RESIZE_INODE) 74437609fd5SJosef Bacik || !le16_to_cpu(es->s_reserved_gdt_blocks)) { 74512062dddSEric Sandeen ext4_warning(sb, 746ac27a0ecSDave Kleikamp "No reserved GDT blocks, can't resize"); 747ac27a0ecSDave Kleikamp return -EPERM; 748ac27a0ecSDave Kleikamp } 7491d1fe1eeSDavid Howells inode = ext4_iget(sb, EXT4_RESIZE_INO); 7501d1fe1eeSDavid Howells if (IS_ERR(inode)) { 75112062dddSEric Sandeen ext4_warning(sb, "Error opening resize inode"); 7521d1fe1eeSDavid Howells return PTR_ERR(inode); 753ac27a0ecSDave Kleikamp } 754ac27a0ecSDave Kleikamp } 755ac27a0ecSDave Kleikamp 756920313a7SAneesh Kumar K.V 757ac27a0ecSDave Kleikamp if ((err = verify_group_input(sb, input))) 758ac27a0ecSDave Kleikamp goto exit_put; 759ac27a0ecSDave Kleikamp 760ac27a0ecSDave Kleikamp if ((err = setup_new_group_blocks(sb, input))) 761ac27a0ecSDave Kleikamp goto exit_put; 762ac27a0ecSDave Kleikamp 763ac27a0ecSDave Kleikamp /* 764ac27a0ecSDave Kleikamp * We will always be modifying at least the superblock and a GDT 765ac27a0ecSDave Kleikamp * block. If we are adding a group past the last current GDT block, 766ac27a0ecSDave Kleikamp * we will also modify the inode and the dindirect block. If we 767ac27a0ecSDave Kleikamp * are adding a group with superblock/GDT backups we will also 768ac27a0ecSDave Kleikamp * modify each of the reserved GDT dindirect blocks. 769ac27a0ecSDave Kleikamp */ 770617ba13bSMingming Cao handle = ext4_journal_start_sb(sb, 771617ba13bSMingming Cao ext4_bg_has_super(sb, input->group) ? 772ac27a0ecSDave Kleikamp 3 + reserved_gdb : 4); 773ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 774ac27a0ecSDave Kleikamp err = PTR_ERR(handle); 775ac27a0ecSDave Kleikamp goto exit_put; 776ac27a0ecSDave Kleikamp } 777ac27a0ecSDave Kleikamp 77832ed5058STheodore Ts'o mutex_lock(&sbi->s_resize_lock); 779ac27a0ecSDave Kleikamp if (input->group != sbi->s_groups_count) { 78012062dddSEric Sandeen ext4_warning(sb, "multiple resizers run on filesystem!"); 781ac27a0ecSDave Kleikamp err = -EBUSY; 782ac27a0ecSDave Kleikamp goto exit_journal; 783ac27a0ecSDave Kleikamp } 784ac27a0ecSDave Kleikamp 785617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, sbi->s_sbh))) 786ac27a0ecSDave Kleikamp goto exit_journal; 787ac27a0ecSDave Kleikamp 788ac27a0ecSDave Kleikamp /* 789ac27a0ecSDave Kleikamp * We will only either add reserved group blocks to a backup group 790ac27a0ecSDave Kleikamp * or remove reserved blocks for the first group in a new group block. 791ac27a0ecSDave Kleikamp * Doing both would be mean more complex code, and sane people don't 792ac27a0ecSDave Kleikamp * use non-sparse filesystems anymore. This is already checked above. 793ac27a0ecSDave Kleikamp */ 794ac27a0ecSDave Kleikamp if (gdb_off) { 795ac27a0ecSDave Kleikamp primary = sbi->s_group_desc[gdb_num]; 796617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, primary))) 797ac27a0ecSDave Kleikamp goto exit_journal; 798ac27a0ecSDave Kleikamp 799617ba13bSMingming Cao if (reserved_gdb && ext4_bg_num_gdb(sb, input->group) && 800ac27a0ecSDave Kleikamp (err = reserve_backup_gdb(handle, inode, input))) 801ac27a0ecSDave Kleikamp goto exit_journal; 802ac27a0ecSDave Kleikamp } else if ((err = add_new_gdb(handle, inode, input, &primary))) 803ac27a0ecSDave Kleikamp goto exit_journal; 804ac27a0ecSDave Kleikamp 805ac27a0ecSDave Kleikamp /* 806ac27a0ecSDave Kleikamp * OK, now we've set up the new group. Time to make it active. 807ac27a0ecSDave Kleikamp * 80832ed5058STheodore Ts'o * We do not lock all allocations via s_resize_lock 809ac27a0ecSDave Kleikamp * so we have to be safe wrt. concurrent accesses the group 810ac27a0ecSDave Kleikamp * data. So we need to be careful to set all of the relevant 811ac27a0ecSDave Kleikamp * group descriptor data etc. *before* we enable the group. 812ac27a0ecSDave Kleikamp * 813ac27a0ecSDave Kleikamp * The key field here is sbi->s_groups_count: as long as 814ac27a0ecSDave Kleikamp * that retains its old value, nobody is going to access the new 815ac27a0ecSDave Kleikamp * group. 816ac27a0ecSDave Kleikamp * 817ac27a0ecSDave Kleikamp * So first we update all the descriptor metadata for the new 818ac27a0ecSDave Kleikamp * group; then we update the total disk blocks count; then we 819ac27a0ecSDave Kleikamp * update the groups count to enable the group; then finally we 820ac27a0ecSDave Kleikamp * update the free space counts so that the system can start 821ac27a0ecSDave Kleikamp * using the new disk blocks. 822ac27a0ecSDave Kleikamp */ 823ac27a0ecSDave Kleikamp 824ac27a0ecSDave Kleikamp /* Update group descriptor block for new group */ 8252856922cSFrederic Bohe gdp = (struct ext4_group_desc *)((char *)primary->b_data + 8262856922cSFrederic Bohe gdb_off * EXT4_DESC_SIZE(sb)); 827ac27a0ecSDave Kleikamp 828fdff73f0STheodore Ts'o memset(gdp, 0, EXT4_DESC_SIZE(sb)); 8298fadc143SAlexandre Ratchov ext4_block_bitmap_set(sb, gdp, input->block_bitmap); /* LV FIXME */ 8308fadc143SAlexandre Ratchov ext4_inode_bitmap_set(sb, gdp, input->inode_bitmap); /* LV FIXME */ 8318fadc143SAlexandre Ratchov ext4_inode_table_set(sb, gdp, input->inode_table); /* LV FIXME */ 832560671a0SAneesh Kumar K.V ext4_free_blks_set(sb, gdp, input->free_blocks_count); 833560671a0SAneesh Kumar K.V ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb)); 834fdff73f0STheodore Ts'o gdp->bg_flags = cpu_to_le16(EXT4_BG_INODE_ZEROED); 835717d50e4SAndreas Dilger gdp->bg_checksum = ext4_group_desc_csum(sbi, input->group, gdp); 836ac27a0ecSDave Kleikamp 837ac27a0ecSDave Kleikamp /* 8385f21b0e6SFrederic Bohe * We can allocate memory for mb_alloc based on the new group 8395f21b0e6SFrederic Bohe * descriptor 8405f21b0e6SFrederic Bohe */ 841920313a7SAneesh Kumar K.V err = ext4_mb_add_groupinfo(sb, input->group, gdp); 84208c3a813SAneesh Kumar K.V if (err) 8435f21b0e6SFrederic Bohe goto exit_journal; 844c2ea3fdeSTheodore Ts'o 8455f21b0e6SFrederic Bohe /* 846ac27a0ecSDave Kleikamp * Make the new blocks and inodes valid next. We do this before 847ac27a0ecSDave Kleikamp * increasing the group count so that once the group is enabled, 848ac27a0ecSDave Kleikamp * all of its blocks and inodes are already valid. 849ac27a0ecSDave Kleikamp * 850ac27a0ecSDave Kleikamp * We always allocate group-by-group, then block-by-block or 851ac27a0ecSDave Kleikamp * inode-by-inode within a group, so enabling these 852ac27a0ecSDave Kleikamp * blocks/inodes before the group is live won't actually let us 853ac27a0ecSDave Kleikamp * allocate the new space yet. 854ac27a0ecSDave Kleikamp */ 855bd81d8eeSLaurent Vivier ext4_blocks_count_set(es, ext4_blocks_count(es) + 856ac27a0ecSDave Kleikamp input->blocks_count); 857e8546d06SMarcin Slusarz le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb)); 858ac27a0ecSDave Kleikamp 859ac27a0ecSDave Kleikamp /* 860ac27a0ecSDave Kleikamp * We need to protect s_groups_count against other CPUs seeing 861ac27a0ecSDave Kleikamp * inconsistent state in the superblock. 862ac27a0ecSDave Kleikamp * 863ac27a0ecSDave Kleikamp * The precise rules we use are: 864ac27a0ecSDave Kleikamp * 86532ed5058STheodore Ts'o * * Writers of s_groups_count *must* hold s_resize_lock 866ac27a0ecSDave Kleikamp * AND 867ac27a0ecSDave Kleikamp * * Writers must perform a smp_wmb() after updating all dependent 868ac27a0ecSDave Kleikamp * data and before modifying the groups count 869ac27a0ecSDave Kleikamp * 87032ed5058STheodore Ts'o * * Readers must hold s_resize_lock over the access 871ac27a0ecSDave Kleikamp * OR 872ac27a0ecSDave Kleikamp * * Readers must perform an smp_rmb() after reading the groups count 873ac27a0ecSDave Kleikamp * and before reading any dependent data. 874ac27a0ecSDave Kleikamp * 875ac27a0ecSDave Kleikamp * NB. These rules can be relaxed when checking the group count 876ac27a0ecSDave Kleikamp * while freeing data, as we can only allocate from a block 877ac27a0ecSDave Kleikamp * group after serialising against the group count, and we can 878ac27a0ecSDave Kleikamp * only then free after serialising in turn against that 879ac27a0ecSDave Kleikamp * allocation. 880ac27a0ecSDave Kleikamp */ 881ac27a0ecSDave Kleikamp smp_wmb(); 882ac27a0ecSDave Kleikamp 883ac27a0ecSDave Kleikamp /* Update the global fs size fields */ 884ac27a0ecSDave Kleikamp sbi->s_groups_count++; 885ac27a0ecSDave Kleikamp 8860390131bSFrank Mayhar ext4_handle_dirty_metadata(handle, NULL, primary); 887ac27a0ecSDave Kleikamp 888ac27a0ecSDave Kleikamp /* Update the reserved block counts only once the new group is 889ac27a0ecSDave Kleikamp * active. */ 890bd81d8eeSLaurent Vivier ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) + 891ac27a0ecSDave Kleikamp input->reserved_blocks); 892ac27a0ecSDave Kleikamp 893ac27a0ecSDave Kleikamp /* Update the free space counts */ 894aa0dff2dSPeter Zijlstra percpu_counter_add(&sbi->s_freeblocks_counter, 895ac27a0ecSDave Kleikamp input->free_blocks_count); 896aa0dff2dSPeter Zijlstra percpu_counter_add(&sbi->s_freeinodes_counter, 897617ba13bSMingming Cao EXT4_INODES_PER_GROUP(sb)); 898ac27a0ecSDave Kleikamp 89942007efdSEric Sandeen if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) && 90042007efdSEric Sandeen sbi->s_log_groups_per_flex) { 901c62a11fdSFrederic Bohe ext4_group_t flex_group; 902c62a11fdSFrederic Bohe flex_group = ext4_flex_group(sbi, input->group); 9039f24e420STheodore Ts'o atomic_add(input->free_blocks_count, 9049f24e420STheodore Ts'o &sbi->s_flex_groups[flex_group].free_blocks); 9059f24e420STheodore Ts'o atomic_add(EXT4_INODES_PER_GROUP(sb), 9069f24e420STheodore Ts'o &sbi->s_flex_groups[flex_group].free_inodes); 907c62a11fdSFrederic Bohe } 908c62a11fdSFrederic Bohe 909a0375156STheodore Ts'o ext4_handle_dirty_super(handle, sb); 910ac27a0ecSDave Kleikamp 911ac27a0ecSDave Kleikamp exit_journal: 91232ed5058STheodore Ts'o mutex_unlock(&sbi->s_resize_lock); 913617ba13bSMingming Cao if ((err2 = ext4_journal_stop(handle)) && !err) 914ac27a0ecSDave Kleikamp err = err2; 915ac27a0ecSDave Kleikamp if (!err) { 916ac27a0ecSDave Kleikamp update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es, 917617ba13bSMingming Cao sizeof(struct ext4_super_block)); 918ac27a0ecSDave Kleikamp update_backups(sb, primary->b_blocknr, primary->b_data, 919ac27a0ecSDave Kleikamp primary->b_size); 920ac27a0ecSDave Kleikamp } 921ac27a0ecSDave Kleikamp exit_put: 922ac27a0ecSDave Kleikamp iput(inode); 923ac27a0ecSDave Kleikamp return err; 924617ba13bSMingming Cao } /* ext4_group_add */ 925ac27a0ecSDave Kleikamp 9262b2d6d01STheodore Ts'o /* 9272b2d6d01STheodore Ts'o * Extend the filesystem to the new number of blocks specified. This entry 928ac27a0ecSDave Kleikamp * point is only used to extend the current filesystem to the end of the last 929ac27a0ecSDave Kleikamp * existing group. It can be accessed via ioctl, or by "remount,resize=<size>" 930ac27a0ecSDave Kleikamp * for emergencies (because it has no dependencies on reserved blocks). 931ac27a0ecSDave Kleikamp * 932617ba13bSMingming Cao * If we _really_ wanted, we could use default values to call ext4_group_add() 933ac27a0ecSDave Kleikamp * allow the "remount" trick to work for arbitrary resizing, assuming enough 934ac27a0ecSDave Kleikamp * GDT blocks are reserved to grow to the desired size. 935ac27a0ecSDave Kleikamp */ 936617ba13bSMingming Cao int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es, 937617ba13bSMingming Cao ext4_fsblk_t n_blocks_count) 938ac27a0ecSDave Kleikamp { 939617ba13bSMingming Cao ext4_fsblk_t o_blocks_count; 940617ba13bSMingming Cao ext4_grpblk_t last; 941617ba13bSMingming Cao ext4_grpblk_t add; 942ac27a0ecSDave Kleikamp struct buffer_head *bh; 943ac27a0ecSDave Kleikamp handle_t *handle; 944ac27a0ecSDave Kleikamp int err; 9455f21b0e6SFrederic Bohe ext4_group_t group; 946ac27a0ecSDave Kleikamp 947ac27a0ecSDave Kleikamp /* We don't need to worry about locking wrt other resizers just 948ac27a0ecSDave Kleikamp * yet: we're going to revalidate es->s_blocks_count after 94932ed5058STheodore Ts'o * taking the s_resize_lock below. */ 950bd81d8eeSLaurent Vivier o_blocks_count = ext4_blocks_count(es); 951ac27a0ecSDave Kleikamp 952ac27a0ecSDave Kleikamp if (test_opt(sb, DEBUG)) 9532ae02107SMingming Cao printk(KERN_DEBUG "EXT4-fs: extending last group from %llu uto %llu blocks\n", 954ac27a0ecSDave Kleikamp o_blocks_count, n_blocks_count); 955ac27a0ecSDave Kleikamp 956ac27a0ecSDave Kleikamp if (n_blocks_count == 0 || n_blocks_count == o_blocks_count) 957ac27a0ecSDave Kleikamp return 0; 958ac27a0ecSDave Kleikamp 959ac27a0ecSDave Kleikamp if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { 960617ba13bSMingming Cao printk(KERN_ERR "EXT4-fs: filesystem on %s:" 9612ae02107SMingming Cao " too large to resize to %llu blocks safely\n", 962ac27a0ecSDave Kleikamp sb->s_id, n_blocks_count); 963ac27a0ecSDave Kleikamp if (sizeof(sector_t) < 8) 96412062dddSEric Sandeen ext4_warning(sb, "CONFIG_LBDAF not enabled"); 965ac27a0ecSDave Kleikamp return -EINVAL; 966ac27a0ecSDave Kleikamp } 967ac27a0ecSDave Kleikamp 968ac27a0ecSDave Kleikamp if (n_blocks_count < o_blocks_count) { 96912062dddSEric Sandeen ext4_warning(sb, "can't shrink FS - resize aborted"); 970ac27a0ecSDave Kleikamp return -EBUSY; 971ac27a0ecSDave Kleikamp } 972ac27a0ecSDave Kleikamp 973ac27a0ecSDave Kleikamp /* Handle the remaining blocks in the last group only. */ 9745f21b0e6SFrederic Bohe ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 975ac27a0ecSDave Kleikamp 976ac27a0ecSDave Kleikamp if (last == 0) { 97712062dddSEric Sandeen ext4_warning(sb, "need to use ext2online to resize further"); 978ac27a0ecSDave Kleikamp return -EPERM; 979ac27a0ecSDave Kleikamp } 980ac27a0ecSDave Kleikamp 981617ba13bSMingming Cao add = EXT4_BLOCKS_PER_GROUP(sb) - last; 982ac27a0ecSDave Kleikamp 983ac27a0ecSDave Kleikamp if (o_blocks_count + add < o_blocks_count) { 98412062dddSEric Sandeen ext4_warning(sb, "blocks_count overflow"); 985ac27a0ecSDave Kleikamp return -EINVAL; 986ac27a0ecSDave Kleikamp } 987ac27a0ecSDave Kleikamp 988ac27a0ecSDave Kleikamp if (o_blocks_count + add > n_blocks_count) 989ac27a0ecSDave Kleikamp add = n_blocks_count - o_blocks_count; 990ac27a0ecSDave Kleikamp 991ac27a0ecSDave Kleikamp if (o_blocks_count + add < n_blocks_count) 99212062dddSEric Sandeen ext4_warning(sb, "will only finish group (%llu blocks, %u new)", 993ac27a0ecSDave Kleikamp o_blocks_count + add, add); 994ac27a0ecSDave Kleikamp 995ac27a0ecSDave Kleikamp /* See if the device is actually as big as what was requested */ 996ac27a0ecSDave Kleikamp bh = sb_bread(sb, o_blocks_count + add - 1); 997ac27a0ecSDave Kleikamp if (!bh) { 99812062dddSEric Sandeen ext4_warning(sb, "can't read last block, resize aborted"); 999ac27a0ecSDave Kleikamp return -ENOSPC; 1000ac27a0ecSDave Kleikamp } 1001ac27a0ecSDave Kleikamp brelse(bh); 1002ac27a0ecSDave Kleikamp 1003ac27a0ecSDave Kleikamp /* We will update the superblock, one block bitmap, and 1004617ba13bSMingming Cao * one group descriptor via ext4_free_blocks(). 1005ac27a0ecSDave Kleikamp */ 1006617ba13bSMingming Cao handle = ext4_journal_start_sb(sb, 3); 1007ac27a0ecSDave Kleikamp if (IS_ERR(handle)) { 1008ac27a0ecSDave Kleikamp err = PTR_ERR(handle); 100912062dddSEric Sandeen ext4_warning(sb, "error %d on journal start", err); 1010ac27a0ecSDave Kleikamp goto exit_put; 1011ac27a0ecSDave Kleikamp } 1012ac27a0ecSDave Kleikamp 101332ed5058STheodore Ts'o mutex_lock(&EXT4_SB(sb)->s_resize_lock); 1014bd81d8eeSLaurent Vivier if (o_blocks_count != ext4_blocks_count(es)) { 101512062dddSEric Sandeen ext4_warning(sb, "multiple resizers run on filesystem!"); 101632ed5058STheodore Ts'o mutex_unlock(&EXT4_SB(sb)->s_resize_lock); 10175606bf5dSAkinobu Mita ext4_journal_stop(handle); 1018ac27a0ecSDave Kleikamp err = -EBUSY; 1019ac27a0ecSDave Kleikamp goto exit_put; 1020ac27a0ecSDave Kleikamp } 1021ac27a0ecSDave Kleikamp 1022617ba13bSMingming Cao if ((err = ext4_journal_get_write_access(handle, 1023617ba13bSMingming Cao EXT4_SB(sb)->s_sbh))) { 102412062dddSEric Sandeen ext4_warning(sb, "error %d on journal write access", err); 102532ed5058STheodore Ts'o mutex_unlock(&EXT4_SB(sb)->s_resize_lock); 1026617ba13bSMingming Cao ext4_journal_stop(handle); 1027ac27a0ecSDave Kleikamp goto exit_put; 1028ac27a0ecSDave Kleikamp } 1029bd81d8eeSLaurent Vivier ext4_blocks_count_set(es, o_blocks_count + add); 103032ed5058STheodore Ts'o mutex_unlock(&EXT4_SB(sb)->s_resize_lock); 1031c549a95dSEric Sandeen ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count, 1032ac27a0ecSDave Kleikamp o_blocks_count + add); 1033e21675d4SAneesh Kumar K.V /* We add the blocks to the bitmap and set the group need init bit */ 1034e21675d4SAneesh Kumar K.V ext4_add_groupblocks(handle, sb, o_blocks_count, add); 1035a0375156STheodore Ts'o ext4_handle_dirty_super(handle, sb); 10362ae02107SMingming Cao ext4_debug("freed blocks %llu through %llu\n", o_blocks_count, 1037ac27a0ecSDave Kleikamp o_blocks_count + add); 1038617ba13bSMingming Cao if ((err = ext4_journal_stop(handle))) 1039ac27a0ecSDave Kleikamp goto exit_put; 10405f21b0e6SFrederic Bohe 1041ac27a0ecSDave Kleikamp if (test_opt(sb, DEBUG)) 1042bd81d8eeSLaurent Vivier printk(KERN_DEBUG "EXT4-fs: extended group to %llu blocks\n", 1043bd81d8eeSLaurent Vivier ext4_blocks_count(es)); 1044617ba13bSMingming Cao update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr, (char *)es, 1045617ba13bSMingming Cao sizeof(struct ext4_super_block)); 1046ac27a0ecSDave Kleikamp exit_put: 1047ac27a0ecSDave Kleikamp return err; 1048617ba13bSMingming Cao } /* ext4_group_extend */ 1049