1 /* 2 * linux/fs/ext4/resize.c 3 * 4 * Support for resizing an ext4 filesystem while it is mounted. 5 * 6 * Copyright (C) 2001, 2002 Andreas Dilger <adilger@clusterfs.com> 7 * 8 * This could probably be made into a module, because it is not often in use. 9 */ 10 11 12 #define EXT4FS_DEBUG 13 14 #include <linux/errno.h> 15 #include <linux/slab.h> 16 17 #include "ext4_jbd2.h" 18 19 int ext4_resize_begin(struct super_block *sb) 20 { 21 int ret = 0; 22 23 if (!capable(CAP_SYS_RESOURCE)) 24 return -EPERM; 25 26 /* 27 * We are not allowed to do online-resizing on a filesystem mounted 28 * with error, because it can destroy the filesystem easily. 29 */ 30 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) { 31 ext4_warning(sb, "There are errors in the filesystem, " 32 "so online resizing is not allowed\n"); 33 return -EPERM; 34 } 35 36 if (test_and_set_bit_lock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags)) 37 ret = -EBUSY; 38 39 return ret; 40 } 41 42 void ext4_resize_end(struct super_block *sb) 43 { 44 clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags); 45 smp_mb__after_clear_bit(); 46 } 47 48 #define outside(b, first, last) ((b) < (first) || (b) >= (last)) 49 #define inside(b, first, last) ((b) >= (first) && (b) < (last)) 50 51 static int verify_group_input(struct super_block *sb, 52 struct ext4_new_group_data *input) 53 { 54 struct ext4_sb_info *sbi = EXT4_SB(sb); 55 struct ext4_super_block *es = sbi->s_es; 56 ext4_fsblk_t start = ext4_blocks_count(es); 57 ext4_fsblk_t end = start + input->blocks_count; 58 ext4_group_t group = input->group; 59 ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group; 60 unsigned overhead = ext4_bg_has_super(sb, group) ? 61 (1 + ext4_bg_num_gdb(sb, group) + 62 le16_to_cpu(es->s_reserved_gdt_blocks)) : 0; 63 ext4_fsblk_t metaend = start + overhead; 64 struct buffer_head *bh = NULL; 65 ext4_grpblk_t free_blocks_count, offset; 66 int err = -EINVAL; 67 68 input->free_blocks_count = free_blocks_count = 69 input->blocks_count - 2 - overhead - sbi->s_itb_per_group; 70 71 if (test_opt(sb, DEBUG)) 72 printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks " 73 "(%d free, %u reserved)\n", 74 ext4_bg_has_super(sb, input->group) ? "normal" : 75 "no-super", input->group, input->blocks_count, 76 free_blocks_count, input->reserved_blocks); 77 78 ext4_get_group_no_and_offset(sb, start, NULL, &offset); 79 if (group != sbi->s_groups_count) 80 ext4_warning(sb, "Cannot add at group %u (only %u groups)", 81 input->group, sbi->s_groups_count); 82 else if (offset != 0) 83 ext4_warning(sb, "Last group not full"); 84 else if (input->reserved_blocks > input->blocks_count / 5) 85 ext4_warning(sb, "Reserved blocks too high (%u)", 86 input->reserved_blocks); 87 else if (free_blocks_count < 0) 88 ext4_warning(sb, "Bad blocks count %u", 89 input->blocks_count); 90 else if (!(bh = sb_bread(sb, end - 1))) 91 ext4_warning(sb, "Cannot read last block (%llu)", 92 end - 1); 93 else if (outside(input->block_bitmap, start, end)) 94 ext4_warning(sb, "Block bitmap not in group (block %llu)", 95 (unsigned long long)input->block_bitmap); 96 else if (outside(input->inode_bitmap, start, end)) 97 ext4_warning(sb, "Inode bitmap not in group (block %llu)", 98 (unsigned long long)input->inode_bitmap); 99 else if (outside(input->inode_table, start, end) || 100 outside(itend - 1, start, end)) 101 ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)", 102 (unsigned long long)input->inode_table, itend - 1); 103 else if (input->inode_bitmap == input->block_bitmap) 104 ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)", 105 (unsigned long long)input->block_bitmap); 106 else if (inside(input->block_bitmap, input->inode_table, itend)) 107 ext4_warning(sb, "Block bitmap (%llu) in inode table " 108 "(%llu-%llu)", 109 (unsigned long long)input->block_bitmap, 110 (unsigned long long)input->inode_table, itend - 1); 111 else if (inside(input->inode_bitmap, input->inode_table, itend)) 112 ext4_warning(sb, "Inode bitmap (%llu) in inode table " 113 "(%llu-%llu)", 114 (unsigned long long)input->inode_bitmap, 115 (unsigned long long)input->inode_table, itend - 1); 116 else if (inside(input->block_bitmap, start, metaend)) 117 ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)", 118 (unsigned long long)input->block_bitmap, 119 start, metaend - 1); 120 else if (inside(input->inode_bitmap, start, metaend)) 121 ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)", 122 (unsigned long long)input->inode_bitmap, 123 start, metaend - 1); 124 else if (inside(input->inode_table, start, metaend) || 125 inside(itend - 1, start, metaend)) 126 ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table " 127 "(%llu-%llu)", 128 (unsigned long long)input->inode_table, 129 itend - 1, start, metaend - 1); 130 else 131 err = 0; 132 brelse(bh); 133 134 return err; 135 } 136 137 static struct buffer_head *bclean(handle_t *handle, struct super_block *sb, 138 ext4_fsblk_t blk) 139 { 140 struct buffer_head *bh; 141 int err; 142 143 bh = sb_getblk(sb, blk); 144 if (!bh) 145 return ERR_PTR(-EIO); 146 if ((err = ext4_journal_get_write_access(handle, bh))) { 147 brelse(bh); 148 bh = ERR_PTR(err); 149 } else { 150 memset(bh->b_data, 0, sb->s_blocksize); 151 set_buffer_uptodate(bh); 152 } 153 154 return bh; 155 } 156 157 /* 158 * If we have fewer than thresh credits, extend by EXT4_MAX_TRANS_DATA. 159 * If that fails, restart the transaction & regain write access for the 160 * buffer head which is used for block_bitmap modifications. 161 */ 162 static int extend_or_restart_transaction(handle_t *handle, int thresh) 163 { 164 int err; 165 166 if (ext4_handle_has_enough_credits(handle, thresh)) 167 return 0; 168 169 err = ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA); 170 if (err < 0) 171 return err; 172 if (err) { 173 err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA); 174 if (err) 175 return err; 176 } 177 178 return 0; 179 } 180 181 /* 182 * Set up the block and inode bitmaps, and the inode table for the new group. 183 * This doesn't need to be part of the main transaction, since we are only 184 * changing blocks outside the actual filesystem. We still do journaling to 185 * ensure the recovery is correct in case of a failure just after resize. 186 * If any part of this fails, we simply abort the resize. 187 */ 188 static int setup_new_group_blocks(struct super_block *sb, 189 struct ext4_new_group_data *input) 190 { 191 struct ext4_sb_info *sbi = EXT4_SB(sb); 192 ext4_fsblk_t start = ext4_group_first_block_no(sb, input->group); 193 int reserved_gdb = ext4_bg_has_super(sb, input->group) ? 194 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0; 195 unsigned long gdblocks = ext4_bg_num_gdb(sb, input->group); 196 struct buffer_head *bh; 197 handle_t *handle; 198 ext4_fsblk_t block; 199 ext4_grpblk_t bit; 200 int i; 201 int err = 0, err2; 202 203 /* This transaction may be extended/restarted along the way */ 204 handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 205 206 if (IS_ERR(handle)) 207 return PTR_ERR(handle); 208 209 BUG_ON(input->group != sbi->s_groups_count); 210 211 /* Copy all of the GDT blocks into the backup in this group */ 212 for (i = 0, bit = 1, block = start + 1; 213 i < gdblocks; i++, block++, bit++) { 214 struct buffer_head *gdb; 215 216 ext4_debug("update backup group %#04llx (+%d)\n", block, bit); 217 err = extend_or_restart_transaction(handle, 1); 218 if (err) 219 goto exit_journal; 220 221 gdb = sb_getblk(sb, block); 222 if (!gdb) { 223 err = -EIO; 224 goto exit_journal; 225 } 226 if ((err = ext4_journal_get_write_access(handle, gdb))) { 227 brelse(gdb); 228 goto exit_journal; 229 } 230 memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, gdb->b_size); 231 set_buffer_uptodate(gdb); 232 err = ext4_handle_dirty_metadata(handle, NULL, gdb); 233 if (unlikely(err)) { 234 brelse(gdb); 235 goto exit_journal; 236 } 237 brelse(gdb); 238 } 239 240 /* Zero out all of the reserved backup group descriptor table blocks */ 241 ext4_debug("clear inode table blocks %#04llx -> %#04lx\n", 242 block, sbi->s_itb_per_group); 243 err = sb_issue_zeroout(sb, gdblocks + start + 1, reserved_gdb, 244 GFP_NOFS); 245 if (err) 246 goto exit_journal; 247 248 err = extend_or_restart_transaction(handle, 2); 249 if (err) 250 goto exit_journal; 251 252 bh = bclean(handle, sb, input->block_bitmap); 253 if (IS_ERR(bh)) { 254 err = PTR_ERR(bh); 255 goto exit_journal; 256 } 257 258 if (ext4_bg_has_super(sb, input->group)) { 259 ext4_debug("mark backup group tables %#04llx (+0)\n", start); 260 ext4_set_bits(bh->b_data, 0, gdblocks + reserved_gdb + 1); 261 } 262 263 ext4_debug("mark block bitmap %#04llx (+%llu)\n", input->block_bitmap, 264 input->block_bitmap - start); 265 ext4_set_bit(input->block_bitmap - start, bh->b_data); 266 ext4_debug("mark inode bitmap %#04llx (+%llu)\n", input->inode_bitmap, 267 input->inode_bitmap - start); 268 ext4_set_bit(input->inode_bitmap - start, bh->b_data); 269 270 /* Zero out all of the inode table blocks */ 271 block = input->inode_table; 272 ext4_debug("clear inode table blocks %#04llx -> %#04lx\n", 273 block, sbi->s_itb_per_group); 274 err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group, GFP_NOFS); 275 if (err) 276 goto exit_bh; 277 ext4_set_bits(bh->b_data, input->inode_table - start, 278 sbi->s_itb_per_group); 279 280 281 ext4_mark_bitmap_end(input->blocks_count, sb->s_blocksize * 8, 282 bh->b_data); 283 err = ext4_handle_dirty_metadata(handle, NULL, bh); 284 if (unlikely(err)) { 285 ext4_std_error(sb, err); 286 goto exit_bh; 287 } 288 brelse(bh); 289 /* Mark unused entries in inode bitmap used */ 290 ext4_debug("clear inode bitmap %#04llx (+%llu)\n", 291 input->inode_bitmap, input->inode_bitmap - start); 292 if (IS_ERR(bh = bclean(handle, sb, input->inode_bitmap))) { 293 err = PTR_ERR(bh); 294 goto exit_journal; 295 } 296 297 ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8, 298 bh->b_data); 299 err = ext4_handle_dirty_metadata(handle, NULL, bh); 300 if (unlikely(err)) 301 ext4_std_error(sb, err); 302 exit_bh: 303 brelse(bh); 304 305 exit_journal: 306 if ((err2 = ext4_journal_stop(handle)) && !err) 307 err = err2; 308 309 return err; 310 } 311 312 /* 313 * Iterate through the groups which hold BACKUP superblock/GDT copies in an 314 * ext4 filesystem. The counters should be initialized to 1, 5, and 7 before 315 * calling this for the first time. In a sparse filesystem it will be the 316 * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ... 317 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ... 318 */ 319 static unsigned ext4_list_backups(struct super_block *sb, unsigned *three, 320 unsigned *five, unsigned *seven) 321 { 322 unsigned *min = three; 323 int mult = 3; 324 unsigned ret; 325 326 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 327 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 328 ret = *min; 329 *min += 1; 330 return ret; 331 } 332 333 if (*five < *min) { 334 min = five; 335 mult = 5; 336 } 337 if (*seven < *min) { 338 min = seven; 339 mult = 7; 340 } 341 342 ret = *min; 343 *min *= mult; 344 345 return ret; 346 } 347 348 /* 349 * Check that all of the backup GDT blocks are held in the primary GDT block. 350 * It is assumed that they are stored in group order. Returns the number of 351 * groups in current filesystem that have BACKUPS, or -ve error code. 352 */ 353 static int verify_reserved_gdb(struct super_block *sb, 354 struct buffer_head *primary) 355 { 356 const ext4_fsblk_t blk = primary->b_blocknr; 357 const ext4_group_t end = EXT4_SB(sb)->s_groups_count; 358 unsigned three = 1; 359 unsigned five = 5; 360 unsigned seven = 7; 361 unsigned grp; 362 __le32 *p = (__le32 *)primary->b_data; 363 int gdbackups = 0; 364 365 while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) { 366 if (le32_to_cpu(*p++) != 367 grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){ 368 ext4_warning(sb, "reserved GDT %llu" 369 " missing grp %d (%llu)", 370 blk, grp, 371 grp * 372 (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) + 373 blk); 374 return -EINVAL; 375 } 376 if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb)) 377 return -EFBIG; 378 } 379 380 return gdbackups; 381 } 382 383 /* 384 * Called when we need to bring a reserved group descriptor table block into 385 * use from the resize inode. The primary copy of the new GDT block currently 386 * is an indirect block (under the double indirect block in the resize inode). 387 * The new backup GDT blocks will be stored as leaf blocks in this indirect 388 * block, in group order. Even though we know all the block numbers we need, 389 * we check to ensure that the resize inode has actually reserved these blocks. 390 * 391 * Don't need to update the block bitmaps because the blocks are still in use. 392 * 393 * We get all of the error cases out of the way, so that we are sure to not 394 * fail once we start modifying the data on disk, because JBD has no rollback. 395 */ 396 static int add_new_gdb(handle_t *handle, struct inode *inode, 397 ext4_group_t group) 398 { 399 struct super_block *sb = inode->i_sb; 400 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 401 unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 402 ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num; 403 struct buffer_head **o_group_desc, **n_group_desc; 404 struct buffer_head *dind; 405 struct buffer_head *gdb_bh; 406 int gdbackups; 407 struct ext4_iloc iloc; 408 __le32 *data; 409 int err; 410 411 if (test_opt(sb, DEBUG)) 412 printk(KERN_DEBUG 413 "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n", 414 gdb_num); 415 416 /* 417 * If we are not using the primary superblock/GDT copy don't resize, 418 * because the user tools have no way of handling this. Probably a 419 * bad time to do it anyways. 420 */ 421 if (EXT4_SB(sb)->s_sbh->b_blocknr != 422 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) { 423 ext4_warning(sb, "won't resize using backup superblock at %llu", 424 (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr); 425 return -EPERM; 426 } 427 428 gdb_bh = sb_bread(sb, gdblock); 429 if (!gdb_bh) 430 return -EIO; 431 432 gdbackups = verify_reserved_gdb(sb, gdb_bh); 433 if (gdbackups < 0) { 434 err = gdbackups; 435 goto exit_bh; 436 } 437 438 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; 439 dind = sb_bread(sb, le32_to_cpu(*data)); 440 if (!dind) { 441 err = -EIO; 442 goto exit_bh; 443 } 444 445 data = (__le32 *)dind->b_data; 446 if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) { 447 ext4_warning(sb, "new group %u GDT block %llu not reserved", 448 group, gdblock); 449 err = -EINVAL; 450 goto exit_dind; 451 } 452 453 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); 454 if (unlikely(err)) 455 goto exit_dind; 456 457 err = ext4_journal_get_write_access(handle, gdb_bh); 458 if (unlikely(err)) 459 goto exit_sbh; 460 461 err = ext4_journal_get_write_access(handle, dind); 462 if (unlikely(err)) 463 ext4_std_error(sb, err); 464 465 /* ext4_reserve_inode_write() gets a reference on the iloc */ 466 err = ext4_reserve_inode_write(handle, inode, &iloc); 467 if (unlikely(err)) 468 goto exit_dindj; 469 470 n_group_desc = ext4_kvmalloc((gdb_num + 1) * 471 sizeof(struct buffer_head *), 472 GFP_NOFS); 473 if (!n_group_desc) { 474 err = -ENOMEM; 475 ext4_warning(sb, "not enough memory for %lu groups", 476 gdb_num + 1); 477 goto exit_inode; 478 } 479 480 /* 481 * Finally, we have all of the possible failures behind us... 482 * 483 * Remove new GDT block from inode double-indirect block and clear out 484 * the new GDT block for use (which also "frees" the backup GDT blocks 485 * from the reserved inode). We don't need to change the bitmaps for 486 * these blocks, because they are marked as in-use from being in the 487 * reserved inode, and will become GDT blocks (primary and backup). 488 */ 489 data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)] = 0; 490 err = ext4_handle_dirty_metadata(handle, NULL, dind); 491 if (unlikely(err)) { 492 ext4_std_error(sb, err); 493 goto exit_inode; 494 } 495 inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9; 496 ext4_mark_iloc_dirty(handle, inode, &iloc); 497 memset(gdb_bh->b_data, 0, sb->s_blocksize); 498 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh); 499 if (unlikely(err)) { 500 ext4_std_error(sb, err); 501 goto exit_inode; 502 } 503 brelse(dind); 504 505 o_group_desc = EXT4_SB(sb)->s_group_desc; 506 memcpy(n_group_desc, o_group_desc, 507 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); 508 n_group_desc[gdb_num] = gdb_bh; 509 EXT4_SB(sb)->s_group_desc = n_group_desc; 510 EXT4_SB(sb)->s_gdb_count++; 511 ext4_kvfree(o_group_desc); 512 513 le16_add_cpu(&es->s_reserved_gdt_blocks, -1); 514 err = ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh); 515 if (err) 516 ext4_std_error(sb, err); 517 518 return err; 519 520 exit_inode: 521 ext4_kvfree(n_group_desc); 522 /* ext4_handle_release_buffer(handle, iloc.bh); */ 523 brelse(iloc.bh); 524 exit_dindj: 525 /* ext4_handle_release_buffer(handle, dind); */ 526 exit_sbh: 527 /* ext4_handle_release_buffer(handle, EXT4_SB(sb)->s_sbh); */ 528 exit_dind: 529 brelse(dind); 530 exit_bh: 531 brelse(gdb_bh); 532 533 ext4_debug("leaving with error %d\n", err); 534 return err; 535 } 536 537 /* 538 * Called when we are adding a new group which has a backup copy of each of 539 * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks. 540 * We need to add these reserved backup GDT blocks to the resize inode, so 541 * that they are kept for future resizing and not allocated to files. 542 * 543 * Each reserved backup GDT block will go into a different indirect block. 544 * The indirect blocks are actually the primary reserved GDT blocks, 545 * so we know in advance what their block numbers are. We only get the 546 * double-indirect block to verify it is pointing to the primary reserved 547 * GDT blocks so we don't overwrite a data block by accident. The reserved 548 * backup GDT blocks are stored in their reserved primary GDT block. 549 */ 550 static int reserve_backup_gdb(handle_t *handle, struct inode *inode, 551 ext4_group_t group) 552 { 553 struct super_block *sb = inode->i_sb; 554 int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); 555 struct buffer_head **primary; 556 struct buffer_head *dind; 557 struct ext4_iloc iloc; 558 ext4_fsblk_t blk; 559 __le32 *data, *end; 560 int gdbackups = 0; 561 int res, i; 562 int err; 563 564 primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS); 565 if (!primary) 566 return -ENOMEM; 567 568 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; 569 dind = sb_bread(sb, le32_to_cpu(*data)); 570 if (!dind) { 571 err = -EIO; 572 goto exit_free; 573 } 574 575 blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count; 576 data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count % 577 EXT4_ADDR_PER_BLOCK(sb)); 578 end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb); 579 580 /* Get each reserved primary GDT block and verify it holds backups */ 581 for (res = 0; res < reserved_gdb; res++, blk++) { 582 if (le32_to_cpu(*data) != blk) { 583 ext4_warning(sb, "reserved block %llu" 584 " not at offset %ld", 585 blk, 586 (long)(data - (__le32 *)dind->b_data)); 587 err = -EINVAL; 588 goto exit_bh; 589 } 590 primary[res] = sb_bread(sb, blk); 591 if (!primary[res]) { 592 err = -EIO; 593 goto exit_bh; 594 } 595 if ((gdbackups = verify_reserved_gdb(sb, primary[res])) < 0) { 596 brelse(primary[res]); 597 err = gdbackups; 598 goto exit_bh; 599 } 600 if (++data >= end) 601 data = (__le32 *)dind->b_data; 602 } 603 604 for (i = 0; i < reserved_gdb; i++) { 605 if ((err = ext4_journal_get_write_access(handle, primary[i]))) { 606 /* 607 int j; 608 for (j = 0; j < i; j++) 609 ext4_handle_release_buffer(handle, primary[j]); 610 */ 611 goto exit_bh; 612 } 613 } 614 615 if ((err = ext4_reserve_inode_write(handle, inode, &iloc))) 616 goto exit_bh; 617 618 /* 619 * Finally we can add each of the reserved backup GDT blocks from 620 * the new group to its reserved primary GDT block. 621 */ 622 blk = group * EXT4_BLOCKS_PER_GROUP(sb); 623 for (i = 0; i < reserved_gdb; i++) { 624 int err2; 625 data = (__le32 *)primary[i]->b_data; 626 /* printk("reserving backup %lu[%u] = %lu\n", 627 primary[i]->b_blocknr, gdbackups, 628 blk + primary[i]->b_blocknr); */ 629 data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr); 630 err2 = ext4_handle_dirty_metadata(handle, NULL, primary[i]); 631 if (!err) 632 err = err2; 633 } 634 inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9; 635 ext4_mark_iloc_dirty(handle, inode, &iloc); 636 637 exit_bh: 638 while (--res >= 0) 639 brelse(primary[res]); 640 brelse(dind); 641 642 exit_free: 643 kfree(primary); 644 645 return err; 646 } 647 648 /* 649 * Update the backup copies of the ext4 metadata. These don't need to be part 650 * of the main resize transaction, because e2fsck will re-write them if there 651 * is a problem (basically only OOM will cause a problem). However, we 652 * _should_ update the backups if possible, in case the primary gets trashed 653 * for some reason and we need to run e2fsck from a backup superblock. The 654 * important part is that the new block and inode counts are in the backup 655 * superblocks, and the location of the new group metadata in the GDT backups. 656 * 657 * We do not need take the s_resize_lock for this, because these 658 * blocks are not otherwise touched by the filesystem code when it is 659 * mounted. We don't need to worry about last changing from 660 * sbi->s_groups_count, because the worst that can happen is that we 661 * do not copy the full number of backups at this time. The resize 662 * which changed s_groups_count will backup again. 663 */ 664 static void update_backups(struct super_block *sb, 665 int blk_off, char *data, int size) 666 { 667 struct ext4_sb_info *sbi = EXT4_SB(sb); 668 const ext4_group_t last = sbi->s_groups_count; 669 const int bpg = EXT4_BLOCKS_PER_GROUP(sb); 670 unsigned three = 1; 671 unsigned five = 5; 672 unsigned seven = 7; 673 ext4_group_t group; 674 int rest = sb->s_blocksize - size; 675 handle_t *handle; 676 int err = 0, err2; 677 678 handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 679 if (IS_ERR(handle)) { 680 group = 1; 681 err = PTR_ERR(handle); 682 goto exit_err; 683 } 684 685 while ((group = ext4_list_backups(sb, &three, &five, &seven)) < last) { 686 struct buffer_head *bh; 687 688 /* Out of journal space, and can't get more - abort - so sad */ 689 if (ext4_handle_valid(handle) && 690 handle->h_buffer_credits == 0 && 691 ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) && 692 (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA))) 693 break; 694 695 bh = sb_getblk(sb, group * bpg + blk_off); 696 if (!bh) { 697 err = -EIO; 698 break; 699 } 700 ext4_debug("update metadata backup %#04lx\n", 701 (unsigned long)bh->b_blocknr); 702 if ((err = ext4_journal_get_write_access(handle, bh))) 703 break; 704 lock_buffer(bh); 705 memcpy(bh->b_data, data, size); 706 if (rest) 707 memset(bh->b_data + size, 0, rest); 708 set_buffer_uptodate(bh); 709 unlock_buffer(bh); 710 err = ext4_handle_dirty_metadata(handle, NULL, bh); 711 if (unlikely(err)) 712 ext4_std_error(sb, err); 713 brelse(bh); 714 } 715 if ((err2 = ext4_journal_stop(handle)) && !err) 716 err = err2; 717 718 /* 719 * Ugh! Need to have e2fsck write the backup copies. It is too 720 * late to revert the resize, we shouldn't fail just because of 721 * the backup copies (they are only needed in case of corruption). 722 * 723 * However, if we got here we have a journal problem too, so we 724 * can't really start a transaction to mark the superblock. 725 * Chicken out and just set the flag on the hope it will be written 726 * to disk, and if not - we will simply wait until next fsck. 727 */ 728 exit_err: 729 if (err) { 730 ext4_warning(sb, "can't update backup for group %u (err %d), " 731 "forcing fsck on next reboot", group, err); 732 sbi->s_mount_state &= ~EXT4_VALID_FS; 733 sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS); 734 mark_buffer_dirty(sbi->s_sbh); 735 } 736 } 737 738 /* Add group descriptor data to an existing or new group descriptor block. 739 * Ensure we handle all possible error conditions _before_ we start modifying 740 * the filesystem, because we cannot abort the transaction and not have it 741 * write the data to disk. 742 * 743 * If we are on a GDT block boundary, we need to get the reserved GDT block. 744 * Otherwise, we may need to add backup GDT blocks for a sparse group. 745 * 746 * We only need to hold the superblock lock while we are actually adding 747 * in the new group's counts to the superblock. Prior to that we have 748 * not really "added" the group at all. We re-check that we are still 749 * adding in the last group in case things have changed since verifying. 750 */ 751 int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) 752 { 753 struct ext4_sb_info *sbi = EXT4_SB(sb); 754 struct ext4_super_block *es = sbi->s_es; 755 int reserved_gdb = ext4_bg_has_super(sb, input->group) ? 756 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 757 struct buffer_head *primary = NULL; 758 struct ext4_group_desc *gdp; 759 struct inode *inode = NULL; 760 handle_t *handle; 761 int gdb_off, gdb_num; 762 int err, err2; 763 764 gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb); 765 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); 766 767 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb, 768 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 769 ext4_warning(sb, "Can't resize non-sparse filesystem further"); 770 return -EPERM; 771 } 772 773 if (ext4_blocks_count(es) + input->blocks_count < 774 ext4_blocks_count(es)) { 775 ext4_warning(sb, "blocks_count overflow"); 776 return -EINVAL; 777 } 778 779 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < 780 le32_to_cpu(es->s_inodes_count)) { 781 ext4_warning(sb, "inodes_count overflow"); 782 return -EINVAL; 783 } 784 785 if (reserved_gdb || gdb_off == 0) { 786 if (!EXT4_HAS_COMPAT_FEATURE(sb, 787 EXT4_FEATURE_COMPAT_RESIZE_INODE) 788 || !le16_to_cpu(es->s_reserved_gdt_blocks)) { 789 ext4_warning(sb, 790 "No reserved GDT blocks, can't resize"); 791 return -EPERM; 792 } 793 inode = ext4_iget(sb, EXT4_RESIZE_INO); 794 if (IS_ERR(inode)) { 795 ext4_warning(sb, "Error opening resize inode"); 796 return PTR_ERR(inode); 797 } 798 } 799 800 801 if ((err = verify_group_input(sb, input))) 802 goto exit_put; 803 804 if ((err = setup_new_group_blocks(sb, input))) 805 goto exit_put; 806 807 /* 808 * We will always be modifying at least the superblock and a GDT 809 * block. If we are adding a group past the last current GDT block, 810 * we will also modify the inode and the dindirect block. If we 811 * are adding a group with superblock/GDT backups we will also 812 * modify each of the reserved GDT dindirect blocks. 813 */ 814 handle = ext4_journal_start_sb(sb, 815 ext4_bg_has_super(sb, input->group) ? 816 3 + reserved_gdb : 4); 817 if (IS_ERR(handle)) { 818 err = PTR_ERR(handle); 819 goto exit_put; 820 } 821 822 if ((err = ext4_journal_get_write_access(handle, sbi->s_sbh))) 823 goto exit_journal; 824 825 /* 826 * We will only either add reserved group blocks to a backup group 827 * or remove reserved blocks for the first group in a new group block. 828 * Doing both would be mean more complex code, and sane people don't 829 * use non-sparse filesystems anymore. This is already checked above. 830 */ 831 if (gdb_off) { 832 primary = sbi->s_group_desc[gdb_num]; 833 if ((err = ext4_journal_get_write_access(handle, primary))) 834 goto exit_journal; 835 836 if (reserved_gdb && ext4_bg_num_gdb(sb, input->group)) { 837 err = reserve_backup_gdb(handle, inode, input->group); 838 if (err) 839 goto exit_journal; 840 } 841 } else { 842 /* 843 * Note that we can access new group descriptor block safely 844 * only if add_new_gdb() succeeds. 845 */ 846 err = add_new_gdb(handle, inode, input->group); 847 if (err) 848 goto exit_journal; 849 primary = sbi->s_group_desc[gdb_num]; 850 } 851 852 /* 853 * OK, now we've set up the new group. Time to make it active. 854 * 855 * so we have to be safe wrt. concurrent accesses the group 856 * data. So we need to be careful to set all of the relevant 857 * group descriptor data etc. *before* we enable the group. 858 * 859 * The key field here is sbi->s_groups_count: as long as 860 * that retains its old value, nobody is going to access the new 861 * group. 862 * 863 * So first we update all the descriptor metadata for the new 864 * group; then we update the total disk blocks count; then we 865 * update the groups count to enable the group; then finally we 866 * update the free space counts so that the system can start 867 * using the new disk blocks. 868 */ 869 870 /* Update group descriptor block for new group */ 871 gdp = (struct ext4_group_desc *)((char *)primary->b_data + 872 gdb_off * EXT4_DESC_SIZE(sb)); 873 874 memset(gdp, 0, EXT4_DESC_SIZE(sb)); 875 ext4_block_bitmap_set(sb, gdp, input->block_bitmap); /* LV FIXME */ 876 ext4_inode_bitmap_set(sb, gdp, input->inode_bitmap); /* LV FIXME */ 877 ext4_inode_table_set(sb, gdp, input->inode_table); /* LV FIXME */ 878 ext4_free_blks_set(sb, gdp, input->free_blocks_count); 879 ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb)); 880 gdp->bg_flags = cpu_to_le16(EXT4_BG_INODE_ZEROED); 881 gdp->bg_checksum = ext4_group_desc_csum(sbi, input->group, gdp); 882 883 /* 884 * We can allocate memory for mb_alloc based on the new group 885 * descriptor 886 */ 887 err = ext4_mb_add_groupinfo(sb, input->group, gdp); 888 if (err) 889 goto exit_journal; 890 891 /* 892 * Make the new blocks and inodes valid next. We do this before 893 * increasing the group count so that once the group is enabled, 894 * all of its blocks and inodes are already valid. 895 * 896 * We always allocate group-by-group, then block-by-block or 897 * inode-by-inode within a group, so enabling these 898 * blocks/inodes before the group is live won't actually let us 899 * allocate the new space yet. 900 */ 901 ext4_blocks_count_set(es, ext4_blocks_count(es) + 902 input->blocks_count); 903 le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb)); 904 905 /* 906 * We need to protect s_groups_count against other CPUs seeing 907 * inconsistent state in the superblock. 908 * 909 * The precise rules we use are: 910 * 911 * * Writers must perform a smp_wmb() after updating all dependent 912 * data and before modifying the groups count 913 * 914 * * Readers must perform an smp_rmb() after reading the groups count 915 * and before reading any dependent data. 916 * 917 * NB. These rules can be relaxed when checking the group count 918 * while freeing data, as we can only allocate from a block 919 * group after serialising against the group count, and we can 920 * only then free after serialising in turn against that 921 * allocation. 922 */ 923 smp_wmb(); 924 925 /* Update the global fs size fields */ 926 sbi->s_groups_count++; 927 928 err = ext4_handle_dirty_metadata(handle, NULL, primary); 929 if (unlikely(err)) { 930 ext4_std_error(sb, err); 931 goto exit_journal; 932 } 933 934 /* Update the reserved block counts only once the new group is 935 * active. */ 936 ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) + 937 input->reserved_blocks); 938 939 /* Update the free space counts */ 940 percpu_counter_add(&sbi->s_freeblocks_counter, 941 input->free_blocks_count); 942 percpu_counter_add(&sbi->s_freeinodes_counter, 943 EXT4_INODES_PER_GROUP(sb)); 944 945 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) && 946 sbi->s_log_groups_per_flex) { 947 ext4_group_t flex_group; 948 flex_group = ext4_flex_group(sbi, input->group); 949 atomic_add(input->free_blocks_count, 950 &sbi->s_flex_groups[flex_group].free_blocks); 951 atomic_add(EXT4_INODES_PER_GROUP(sb), 952 &sbi->s_flex_groups[flex_group].free_inodes); 953 } 954 955 ext4_handle_dirty_super(handle, sb); 956 957 exit_journal: 958 if ((err2 = ext4_journal_stop(handle)) && !err) 959 err = err2; 960 if (!err && primary) { 961 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es, 962 sizeof(struct ext4_super_block)); 963 update_backups(sb, primary->b_blocknr, primary->b_data, 964 primary->b_size); 965 } 966 exit_put: 967 iput(inode); 968 return err; 969 } /* ext4_group_add */ 970 971 /* 972 * Extend the filesystem to the new number of blocks specified. This entry 973 * point is only used to extend the current filesystem to the end of the last 974 * existing group. It can be accessed via ioctl, or by "remount,resize=<size>" 975 * for emergencies (because it has no dependencies on reserved blocks). 976 * 977 * If we _really_ wanted, we could use default values to call ext4_group_add() 978 * allow the "remount" trick to work for arbitrary resizing, assuming enough 979 * GDT blocks are reserved to grow to the desired size. 980 */ 981 int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es, 982 ext4_fsblk_t n_blocks_count) 983 { 984 ext4_fsblk_t o_blocks_count; 985 ext4_grpblk_t last; 986 ext4_grpblk_t add; 987 struct buffer_head *bh; 988 handle_t *handle; 989 int err, err2; 990 ext4_group_t group; 991 992 o_blocks_count = ext4_blocks_count(es); 993 994 if (test_opt(sb, DEBUG)) 995 printk(KERN_DEBUG "EXT4-fs: extending last group from %llu to %llu blocks\n", 996 o_blocks_count, n_blocks_count); 997 998 if (n_blocks_count == 0 || n_blocks_count == o_blocks_count) 999 return 0; 1000 1001 if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { 1002 printk(KERN_ERR "EXT4-fs: filesystem on %s:" 1003 " too large to resize to %llu blocks safely\n", 1004 sb->s_id, n_blocks_count); 1005 if (sizeof(sector_t) < 8) 1006 ext4_warning(sb, "CONFIG_LBDAF not enabled"); 1007 return -EINVAL; 1008 } 1009 1010 if (n_blocks_count < o_blocks_count) { 1011 ext4_warning(sb, "can't shrink FS - resize aborted"); 1012 return -EINVAL; 1013 } 1014 1015 /* Handle the remaining blocks in the last group only. */ 1016 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1017 1018 if (last == 0) { 1019 ext4_warning(sb, "need to use ext2online to resize further"); 1020 return -EPERM; 1021 } 1022 1023 add = EXT4_BLOCKS_PER_GROUP(sb) - last; 1024 1025 if (o_blocks_count + add < o_blocks_count) { 1026 ext4_warning(sb, "blocks_count overflow"); 1027 return -EINVAL; 1028 } 1029 1030 if (o_blocks_count + add > n_blocks_count) 1031 add = n_blocks_count - o_blocks_count; 1032 1033 if (o_blocks_count + add < n_blocks_count) 1034 ext4_warning(sb, "will only finish group (%llu blocks, %u new)", 1035 o_blocks_count + add, add); 1036 1037 /* See if the device is actually as big as what was requested */ 1038 bh = sb_bread(sb, o_blocks_count + add - 1); 1039 if (!bh) { 1040 ext4_warning(sb, "can't read last block, resize aborted"); 1041 return -ENOSPC; 1042 } 1043 brelse(bh); 1044 1045 /* We will update the superblock, one block bitmap, and 1046 * one group descriptor via ext4_free_blocks(). 1047 */ 1048 handle = ext4_journal_start_sb(sb, 3); 1049 if (IS_ERR(handle)) { 1050 err = PTR_ERR(handle); 1051 ext4_warning(sb, "error %d on journal start", err); 1052 goto exit_put; 1053 } 1054 1055 if ((err = ext4_journal_get_write_access(handle, 1056 EXT4_SB(sb)->s_sbh))) { 1057 ext4_warning(sb, "error %d on journal write access", err); 1058 ext4_journal_stop(handle); 1059 goto exit_put; 1060 } 1061 ext4_blocks_count_set(es, o_blocks_count + add); 1062 ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count, 1063 o_blocks_count + add); 1064 /* We add the blocks to the bitmap and set the group need init bit */ 1065 err = ext4_group_add_blocks(handle, sb, o_blocks_count, add); 1066 ext4_handle_dirty_super(handle, sb); 1067 ext4_debug("freed blocks %llu through %llu\n", o_blocks_count, 1068 o_blocks_count + add); 1069 err2 = ext4_journal_stop(handle); 1070 if (!err && err2) 1071 err = err2; 1072 1073 if (err) 1074 goto exit_put; 1075 1076 if (test_opt(sb, DEBUG)) 1077 printk(KERN_DEBUG "EXT4-fs: extended group to %llu blocks\n", 1078 ext4_blocks_count(es)); 1079 update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr, (char *)es, 1080 sizeof(struct ext4_super_block)); 1081 exit_put: 1082 return err; 1083 } /* ext4_group_extend */ 1084