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