2 * linux/fs/ext3/resize.c
4 * Support for resizing an ext3 filesystem while it is mounted.
6 * Copyright (C) 2001, 2002 Andreas Dilger <adilger@clusterfs.com>
8 * This could probably be made into a module, because it is not often in use.
14 #include <linux/ext3_jbd.h>
16 #include <linux/errno.h>
17 #include <linux/slab.h>
20 #define outside(b, first, last) ((b) < (first) || (b) >= (last))
21 #define inside(b, first, last) ((b) >= (first) && (b) < (last))
23 static int verify_group_input(struct super_block
*sb
,
24 struct ext3_new_group_data
*input
)
26 struct ext3_sb_info
*sbi
= EXT3_SB(sb
);
27 struct ext3_super_block
*es
= sbi
->s_es
;
28 ext3_fsblk_t start
= le32_to_cpu(es
->s_blocks_count
);
29 ext3_fsblk_t end
= start
+ input
->blocks_count
;
30 unsigned group
= input
->group
;
31 ext3_fsblk_t itend
= input
->inode_table
+ sbi
->s_itb_per_group
;
32 unsigned overhead
= ext3_bg_has_super(sb
, group
) ?
33 (1 + ext3_bg_num_gdb(sb
, group
) +
34 le16_to_cpu(es
->s_reserved_gdt_blocks
)) : 0;
35 ext3_fsblk_t metaend
= start
+ overhead
;
36 struct buffer_head
*bh
= NULL
;
37 ext3_grpblk_t free_blocks_count
;
40 input
->free_blocks_count
= free_blocks_count
=
41 input
->blocks_count
- 2 - overhead
- sbi
->s_itb_per_group
;
43 if (test_opt(sb
, DEBUG
))
44 printk(KERN_DEBUG
"EXT3-fs: adding %s group %u: %u blocks "
45 "(%d free, %u reserved)\n",
46 ext3_bg_has_super(sb
, input
->group
) ? "normal" :
47 "no-super", input
->group
, input
->blocks_count
,
48 free_blocks_count
, input
->reserved_blocks
);
50 if (group
!= sbi
->s_groups_count
)
51 ext3_warning(sb
, __func__
,
52 "Cannot add at group %u (only %lu groups)",
53 input
->group
, sbi
->s_groups_count
);
54 else if ((start
- le32_to_cpu(es
->s_first_data_block
)) %
55 EXT3_BLOCKS_PER_GROUP(sb
))
56 ext3_warning(sb
, __func__
, "Last group not full");
57 else if (input
->reserved_blocks
> input
->blocks_count
/ 5)
58 ext3_warning(sb
, __func__
, "Reserved blocks too high (%u)",
59 input
->reserved_blocks
);
60 else if (free_blocks_count
< 0)
61 ext3_warning(sb
, __func__
, "Bad blocks count %u",
63 else if (!(bh
= sb_bread(sb
, end
- 1)))
64 ext3_warning(sb
, __func__
,
65 "Cannot read last block ("E3FSBLK
")",
67 else if (outside(input
->block_bitmap
, start
, end
))
68 ext3_warning(sb
, __func__
,
69 "Block bitmap not in group (block %u)",
71 else if (outside(input
->inode_bitmap
, start
, end
))
72 ext3_warning(sb
, __func__
,
73 "Inode bitmap not in group (block %u)",
75 else if (outside(input
->inode_table
, start
, end
) ||
76 outside(itend
- 1, start
, end
))
77 ext3_warning(sb
, __func__
,
78 "Inode table not in group (blocks %u-"E3FSBLK
")",
79 input
->inode_table
, itend
- 1);
80 else if (input
->inode_bitmap
== input
->block_bitmap
)
81 ext3_warning(sb
, __func__
,
82 "Block bitmap same as inode bitmap (%u)",
84 else if (inside(input
->block_bitmap
, input
->inode_table
, itend
))
85 ext3_warning(sb
, __func__
,
86 "Block bitmap (%u) in inode table (%u-"E3FSBLK
")",
87 input
->block_bitmap
, input
->inode_table
, itend
-1);
88 else if (inside(input
->inode_bitmap
, input
->inode_table
, itend
))
89 ext3_warning(sb
, __func__
,
90 "Inode bitmap (%u) in inode table (%u-"E3FSBLK
")",
91 input
->inode_bitmap
, input
->inode_table
, itend
-1);
92 else if (inside(input
->block_bitmap
, start
, metaend
))
93 ext3_warning(sb
, __func__
,
94 "Block bitmap (%u) in GDT table"
95 " ("E3FSBLK
"-"E3FSBLK
")",
96 input
->block_bitmap
, start
, metaend
- 1);
97 else if (inside(input
->inode_bitmap
, start
, metaend
))
98 ext3_warning(sb
, __func__
,
99 "Inode bitmap (%u) in GDT table"
100 " ("E3FSBLK
"-"E3FSBLK
")",
101 input
->inode_bitmap
, start
, metaend
- 1);
102 else if (inside(input
->inode_table
, start
, metaend
) ||
103 inside(itend
- 1, start
, metaend
))
104 ext3_warning(sb
, __func__
,
105 "Inode table (%u-"E3FSBLK
") overlaps"
106 "GDT table ("E3FSBLK
"-"E3FSBLK
")",
107 input
->inode_table
, itend
- 1, start
, metaend
- 1);
115 static struct buffer_head
*bclean(handle_t
*handle
, struct super_block
*sb
,
118 struct buffer_head
*bh
;
121 bh
= sb_getblk(sb
, blk
);
123 return ERR_PTR(-EIO
);
124 if ((err
= ext3_journal_get_write_access(handle
, bh
))) {
129 memset(bh
->b_data
, 0, sb
->s_blocksize
);
130 set_buffer_uptodate(bh
);
138 * To avoid calling the atomic setbit hundreds or thousands of times, we only
139 * need to use it within a single byte (to ensure we get endianness right).
140 * We can use memset for the rest of the bitmap as there are no other users.
142 static void mark_bitmap_end(int start_bit
, int end_bit
, char *bitmap
)
146 if (start_bit
>= end_bit
)
149 ext3_debug("mark end bits +%d through +%d used\n", start_bit
, end_bit
);
150 for (i
= start_bit
; i
< ((start_bit
+ 7) & ~7UL); i
++)
151 ext3_set_bit(i
, bitmap
);
153 memset(bitmap
+ (i
>> 3), 0xff, (end_bit
- i
) >> 3);
157 * If we have fewer than thresh credits, extend by EXT3_MAX_TRANS_DATA.
158 * If that fails, restart the transaction & regain write access for the
159 * buffer head which is used for block_bitmap modifications.
161 static int extend_or_restart_transaction(handle_t
*handle
, int thresh
,
162 struct buffer_head
*bh
)
166 if (handle
->h_buffer_credits
>= thresh
)
169 err
= ext3_journal_extend(handle
, EXT3_MAX_TRANS_DATA
);
173 err
= ext3_journal_restart(handle
, EXT3_MAX_TRANS_DATA
);
176 err
= ext3_journal_get_write_access(handle
, bh
);
185 * Set up the block and inode bitmaps, and the inode table for the new group.
186 * This doesn't need to be part of the main transaction, since we are only
187 * changing blocks outside the actual filesystem. We still do journaling to
188 * ensure the recovery is correct in case of a failure just after resize.
189 * If any part of this fails, we simply abort the resize.
191 static int setup_new_group_blocks(struct super_block
*sb
,
192 struct ext3_new_group_data
*input
)
194 struct ext3_sb_info
*sbi
= EXT3_SB(sb
);
195 ext3_fsblk_t start
= ext3_group_first_block_no(sb
, input
->group
);
196 int reserved_gdb
= ext3_bg_has_super(sb
, input
->group
) ?
197 le16_to_cpu(sbi
->s_es
->s_reserved_gdt_blocks
) : 0;
198 unsigned long gdblocks
= ext3_bg_num_gdb(sb
, input
->group
);
199 struct buffer_head
*bh
;
206 /* This transaction may be extended/restarted along the way */
207 handle
= ext3_journal_start_sb(sb
, EXT3_MAX_TRANS_DATA
);
210 return PTR_ERR(handle
);
213 if (input
->group
!= sbi
->s_groups_count
) {
218 if (IS_ERR(bh
= bclean(handle
, sb
, input
->block_bitmap
))) {
223 if (ext3_bg_has_super(sb
, input
->group
)) {
224 ext3_debug("mark backup superblock %#04lx (+0)\n", start
);
225 ext3_set_bit(0, bh
->b_data
);
228 /* Copy all of the GDT blocks into the backup in this group */
229 for (i
= 0, bit
= 1, block
= start
+ 1;
230 i
< gdblocks
; i
++, block
++, bit
++) {
231 struct buffer_head
*gdb
;
233 ext3_debug("update backup group %#04lx (+%d)\n", block
, bit
);
235 err
= extend_or_restart_transaction(handle
, 1, bh
);
239 gdb
= sb_getblk(sb
, block
);
244 if ((err
= ext3_journal_get_write_access(handle
, gdb
))) {
249 memcpy(gdb
->b_data
, sbi
->s_group_desc
[i
]->b_data
, gdb
->b_size
);
250 set_buffer_uptodate(gdb
);
252 ext3_journal_dirty_metadata(handle
, gdb
);
253 ext3_set_bit(bit
, bh
->b_data
);
257 /* Zero out all of the reserved backup group descriptor table blocks */
258 for (i
= 0, bit
= gdblocks
+ 1, block
= start
+ bit
;
259 i
< reserved_gdb
; i
++, block
++, bit
++) {
260 struct buffer_head
*gdb
;
262 ext3_debug("clear reserved block %#04lx (+%d)\n", block
, bit
);
264 err
= extend_or_restart_transaction(handle
, 1, bh
);
268 if (IS_ERR(gdb
= bclean(handle
, sb
, block
))) {
272 ext3_journal_dirty_metadata(handle
, gdb
);
273 ext3_set_bit(bit
, bh
->b_data
);
276 ext3_debug("mark block bitmap %#04x (+%ld)\n", input
->block_bitmap
,
277 input
->block_bitmap
- start
);
278 ext3_set_bit(input
->block_bitmap
- start
, bh
->b_data
);
279 ext3_debug("mark inode bitmap %#04x (+%ld)\n", input
->inode_bitmap
,
280 input
->inode_bitmap
- start
);
281 ext3_set_bit(input
->inode_bitmap
- start
, bh
->b_data
);
283 /* Zero out all of the inode table blocks */
284 for (i
= 0, block
= input
->inode_table
, bit
= block
- start
;
285 i
< sbi
->s_itb_per_group
; i
++, bit
++, block
++) {
286 struct buffer_head
*it
;
288 ext3_debug("clear inode block %#04lx (+%d)\n", block
, bit
);
290 err
= extend_or_restart_transaction(handle
, 1, bh
);
294 if (IS_ERR(it
= bclean(handle
, sb
, block
))) {
298 ext3_journal_dirty_metadata(handle
, it
);
300 ext3_set_bit(bit
, bh
->b_data
);
303 err
= extend_or_restart_transaction(handle
, 2, bh
);
307 mark_bitmap_end(input
->blocks_count
, EXT3_BLOCKS_PER_GROUP(sb
),
309 ext3_journal_dirty_metadata(handle
, bh
);
312 /* Mark unused entries in inode bitmap used */
313 ext3_debug("clear inode bitmap %#04x (+%ld)\n",
314 input
->inode_bitmap
, input
->inode_bitmap
- start
);
315 if (IS_ERR(bh
= bclean(handle
, sb
, input
->inode_bitmap
))) {
320 mark_bitmap_end(EXT3_INODES_PER_GROUP(sb
), EXT3_BLOCKS_PER_GROUP(sb
),
322 ext3_journal_dirty_metadata(handle
, bh
);
328 if ((err2
= ext3_journal_stop(handle
)) && !err
)
335 * Iterate through the groups which hold BACKUP superblock/GDT copies in an
336 * ext3 filesystem. The counters should be initialized to 1, 5, and 7 before
337 * calling this for the first time. In a sparse filesystem it will be the
338 * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ...
339 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ...
341 static unsigned ext3_list_backups(struct super_block
*sb
, unsigned *three
,
342 unsigned *five
, unsigned *seven
)
344 unsigned *min
= three
;
348 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb
,
349 EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER
)) {
371 * Check that all of the backup GDT blocks are held in the primary GDT block.
372 * It is assumed that they are stored in group order. Returns the number of
373 * groups in current filesystem that have BACKUPS, or -ve error code.
375 static int verify_reserved_gdb(struct super_block
*sb
,
376 struct buffer_head
*primary
)
378 const ext3_fsblk_t blk
= primary
->b_blocknr
;
379 const unsigned long end
= EXT3_SB(sb
)->s_groups_count
;
384 __le32
*p
= (__le32
*)primary
->b_data
;
387 while ((grp
= ext3_list_backups(sb
, &three
, &five
, &seven
)) < end
) {
388 if (le32_to_cpu(*p
++) != grp
* EXT3_BLOCKS_PER_GROUP(sb
) + blk
){
389 ext3_warning(sb
, __func__
,
390 "reserved GDT "E3FSBLK
391 " missing grp %d ("E3FSBLK
")",
393 grp
* EXT3_BLOCKS_PER_GROUP(sb
) + blk
);
396 if (++gdbackups
> EXT3_ADDR_PER_BLOCK(sb
))
404 * Called when we need to bring a reserved group descriptor table block into
405 * use from the resize inode. The primary copy of the new GDT block currently
406 * is an indirect block (under the double indirect block in the resize inode).
407 * The new backup GDT blocks will be stored as leaf blocks in this indirect
408 * block, in group order. Even though we know all the block numbers we need,
409 * we check to ensure that the resize inode has actually reserved these blocks.
411 * Don't need to update the block bitmaps because the blocks are still in use.
413 * We get all of the error cases out of the way, so that we are sure to not
414 * fail once we start modifying the data on disk, because JBD has no rollback.
416 static int add_new_gdb(handle_t
*handle
, struct inode
*inode
,
417 struct ext3_new_group_data
*input
,
418 struct buffer_head
**primary
)
420 struct super_block
*sb
= inode
->i_sb
;
421 struct ext3_super_block
*es
= EXT3_SB(sb
)->s_es
;
422 unsigned long gdb_num
= input
->group
/ EXT3_DESC_PER_BLOCK(sb
);
423 ext3_fsblk_t gdblock
= EXT3_SB(sb
)->s_sbh
->b_blocknr
+ 1 + gdb_num
;
424 struct buffer_head
**o_group_desc
, **n_group_desc
;
425 struct buffer_head
*dind
;
427 struct ext3_iloc iloc
;
431 if (test_opt(sb
, DEBUG
))
433 "EXT3-fs: ext3_add_new_gdb: adding group block %lu\n",
437 * If we are not using the primary superblock/GDT copy don't resize,
438 * because the user tools have no way of handling this. Probably a
439 * bad time to do it anyways.
441 if (EXT3_SB(sb
)->s_sbh
->b_blocknr
!=
442 le32_to_cpu(EXT3_SB(sb
)->s_es
->s_first_data_block
)) {
443 ext3_warning(sb
, __func__
,
444 "won't resize using backup superblock at %llu",
445 (unsigned long long)EXT3_SB(sb
)->s_sbh
->b_blocknr
);
449 *primary
= sb_bread(sb
, gdblock
);
453 if ((gdbackups
= verify_reserved_gdb(sb
, *primary
)) < 0) {
458 data
= EXT3_I(inode
)->i_data
+ EXT3_DIND_BLOCK
;
459 dind
= sb_bread(sb
, le32_to_cpu(*data
));
465 data
= (__le32
*)dind
->b_data
;
466 if (le32_to_cpu(data
[gdb_num
% EXT3_ADDR_PER_BLOCK(sb
)]) != gdblock
) {
467 ext3_warning(sb
, __func__
,
468 "new group %u GDT block "E3FSBLK
" not reserved",
469 input
->group
, gdblock
);
474 if ((err
= ext3_journal_get_write_access(handle
, EXT3_SB(sb
)->s_sbh
)))
477 if ((err
= ext3_journal_get_write_access(handle
, *primary
)))
480 if ((err
= ext3_journal_get_write_access(handle
, dind
)))
483 /* ext3_reserve_inode_write() gets a reference on the iloc */
484 if ((err
= ext3_reserve_inode_write(handle
, inode
, &iloc
)))
487 n_group_desc
= kmalloc((gdb_num
+ 1) * sizeof(struct buffer_head
*),
491 ext3_warning (sb
, __func__
,
492 "not enough memory for %lu groups", gdb_num
+ 1);
497 * Finally, we have all of the possible failures behind us...
499 * Remove new GDT block from inode double-indirect block and clear out
500 * the new GDT block for use (which also "frees" the backup GDT blocks
501 * from the reserved inode). We don't need to change the bitmaps for
502 * these blocks, because they are marked as in-use from being in the
503 * reserved inode, and will become GDT blocks (primary and backup).
505 data
[gdb_num
% EXT3_ADDR_PER_BLOCK(sb
)] = 0;
506 ext3_journal_dirty_metadata(handle
, dind
);
508 inode
->i_blocks
-= (gdbackups
+ 1) * sb
->s_blocksize
>> 9;
509 ext3_mark_iloc_dirty(handle
, inode
, &iloc
);
510 memset((*primary
)->b_data
, 0, sb
->s_blocksize
);
511 ext3_journal_dirty_metadata(handle
, *primary
);
513 o_group_desc
= EXT3_SB(sb
)->s_group_desc
;
514 memcpy(n_group_desc
, o_group_desc
,
515 EXT3_SB(sb
)->s_gdb_count
* sizeof(struct buffer_head
*));
516 n_group_desc
[gdb_num
] = *primary
;
517 EXT3_SB(sb
)->s_group_desc
= n_group_desc
;
518 EXT3_SB(sb
)->s_gdb_count
++;
521 le16_add_cpu(&es
->s_reserved_gdt_blocks
, -1);
522 ext3_journal_dirty_metadata(handle
, EXT3_SB(sb
)->s_sbh
);
527 //ext3_journal_release_buffer(handle, iloc.bh);
530 //ext3_journal_release_buffer(handle, dind);
532 //ext3_journal_release_buffer(handle, *primary);
534 //ext3_journal_release_buffer(handle, *primary);
540 ext3_debug("leaving with error %d\n", err
);
545 * Called when we are adding a new group which has a backup copy of each of
546 * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks.
547 * We need to add these reserved backup GDT blocks to the resize inode, so
548 * that they are kept for future resizing and not allocated to files.
550 * Each reserved backup GDT block will go into a different indirect block.
551 * The indirect blocks are actually the primary reserved GDT blocks,
552 * so we know in advance what their block numbers are. We only get the
553 * double-indirect block to verify it is pointing to the primary reserved
554 * GDT blocks so we don't overwrite a data block by accident. The reserved
555 * backup GDT blocks are stored in their reserved primary GDT block.
557 static int reserve_backup_gdb(handle_t
*handle
, struct inode
*inode
,
558 struct ext3_new_group_data
*input
)
560 struct super_block
*sb
= inode
->i_sb
;
561 int reserved_gdb
=le16_to_cpu(EXT3_SB(sb
)->s_es
->s_reserved_gdt_blocks
);
562 struct buffer_head
**primary
;
563 struct buffer_head
*dind
;
564 struct ext3_iloc iloc
;
571 primary
= kmalloc(reserved_gdb
* sizeof(*primary
), GFP_NOFS
);
575 data
= EXT3_I(inode
)->i_data
+ EXT3_DIND_BLOCK
;
576 dind
= sb_bread(sb
, le32_to_cpu(*data
));
582 blk
= EXT3_SB(sb
)->s_sbh
->b_blocknr
+ 1 + EXT3_SB(sb
)->s_gdb_count
;
583 data
= (__le32
*)dind
->b_data
+ (EXT3_SB(sb
)->s_gdb_count
%
584 EXT3_ADDR_PER_BLOCK(sb
));
585 end
= (__le32
*)dind
->b_data
+ EXT3_ADDR_PER_BLOCK(sb
);
587 /* Get each reserved primary GDT block and verify it holds backups */
588 for (res
= 0; res
< reserved_gdb
; res
++, blk
++) {
589 if (le32_to_cpu(*data
) != blk
) {
590 ext3_warning(sb
, __func__
,
591 "reserved block "E3FSBLK
592 " not at offset %ld",
594 (long)(data
- (__le32
*)dind
->b_data
));
598 primary
[res
] = sb_bread(sb
, blk
);
603 if ((gdbackups
= verify_reserved_gdb(sb
, primary
[res
])) < 0) {
604 brelse(primary
[res
]);
609 data
= (__le32
*)dind
->b_data
;
612 for (i
= 0; i
< reserved_gdb
; i
++) {
613 if ((err
= ext3_journal_get_write_access(handle
, primary
[i
]))) {
616 for (j = 0; j < i; j++)
617 ext3_journal_release_buffer(handle, primary[j]);
623 if ((err
= ext3_reserve_inode_write(handle
, inode
, &iloc
)))
627 * Finally we can add each of the reserved backup GDT blocks from
628 * the new group to its reserved primary GDT block.
630 blk
= input
->group
* EXT3_BLOCKS_PER_GROUP(sb
);
631 for (i
= 0; i
< reserved_gdb
; i
++) {
633 data
= (__le32
*)primary
[i
]->b_data
;
634 /* printk("reserving backup %lu[%u] = %lu\n",
635 primary[i]->b_blocknr, gdbackups,
636 blk + primary[i]->b_blocknr); */
637 data
[gdbackups
] = cpu_to_le32(blk
+ primary
[i
]->b_blocknr
);
638 err2
= ext3_journal_dirty_metadata(handle
, primary
[i
]);
642 inode
->i_blocks
+= reserved_gdb
* sb
->s_blocksize
>> 9;
643 ext3_mark_iloc_dirty(handle
, inode
, &iloc
);
647 brelse(primary
[res
]);
657 * Update the backup copies of the ext3 metadata. These don't need to be part
658 * of the main resize transaction, because e2fsck will re-write them if there
659 * is a problem (basically only OOM will cause a problem). However, we
660 * _should_ update the backups if possible, in case the primary gets trashed
661 * for some reason and we need to run e2fsck from a backup superblock. The
662 * important part is that the new block and inode counts are in the backup
663 * superblocks, and the location of the new group metadata in the GDT backups.
665 * We do not need lock_super() for this, because these blocks are not
666 * otherwise touched by the filesystem code when it is mounted. We don't
667 * need to worry about last changing from sbi->s_groups_count, because the
668 * worst that can happen is that we do not copy the full number of backups
669 * at this time. The resize which changed s_groups_count will backup again.
671 static void update_backups(struct super_block
*sb
,
672 int blk_off
, char *data
, int size
)
674 struct ext3_sb_info
*sbi
= EXT3_SB(sb
);
675 const unsigned long last
= sbi
->s_groups_count
;
676 const int bpg
= EXT3_BLOCKS_PER_GROUP(sb
);
681 int rest
= sb
->s_blocksize
- size
;
685 handle
= ext3_journal_start_sb(sb
, EXT3_MAX_TRANS_DATA
);
686 if (IS_ERR(handle
)) {
688 err
= PTR_ERR(handle
);
692 while ((group
= ext3_list_backups(sb
, &three
, &five
, &seven
)) < last
) {
693 struct buffer_head
*bh
;
695 /* Out of journal space, and can't get more - abort - so sad */
696 if (handle
->h_buffer_credits
== 0 &&
697 ext3_journal_extend(handle
, EXT3_MAX_TRANS_DATA
) &&
698 (err
= ext3_journal_restart(handle
, EXT3_MAX_TRANS_DATA
)))
701 bh
= sb_getblk(sb
, group
* bpg
+ blk_off
);
706 ext3_debug("update metadata backup %#04lx\n",
707 (unsigned long)bh
->b_blocknr
);
708 if ((err
= ext3_journal_get_write_access(handle
, bh
)))
711 memcpy(bh
->b_data
, data
, size
);
713 memset(bh
->b_data
+ size
, 0, rest
);
714 set_buffer_uptodate(bh
);
716 ext3_journal_dirty_metadata(handle
, bh
);
719 if ((err2
= ext3_journal_stop(handle
)) && !err
)
723 * Ugh! Need to have e2fsck write the backup copies. It is too
724 * late to revert the resize, we shouldn't fail just because of
725 * the backup copies (they are only needed in case of corruption).
727 * However, if we got here we have a journal problem too, so we
728 * can't really start a transaction to mark the superblock.
729 * Chicken out and just set the flag on the hope it will be written
730 * to disk, and if not - we will simply wait until next fsck.
734 ext3_warning(sb
, __func__
,
735 "can't update backup for group %d (err %d), "
736 "forcing fsck on next reboot", group
, err
);
737 sbi
->s_mount_state
&= ~EXT3_VALID_FS
;
738 sbi
->s_es
->s_state
&= cpu_to_le16(~EXT3_VALID_FS
);
739 mark_buffer_dirty(sbi
->s_sbh
);
743 /* Add group descriptor data to an existing or new group descriptor block.
744 * Ensure we handle all possible error conditions _before_ we start modifying
745 * the filesystem, because we cannot abort the transaction and not have it
746 * write the data to disk.
748 * If we are on a GDT block boundary, we need to get the reserved GDT block.
749 * Otherwise, we may need to add backup GDT blocks for a sparse group.
751 * We only need to hold the superblock lock while we are actually adding
752 * in the new group's counts to the superblock. Prior to that we have
753 * not really "added" the group at all. We re-check that we are still
754 * adding in the last group in case things have changed since verifying.
756 int ext3_group_add(struct super_block
*sb
, struct ext3_new_group_data
*input
)
758 struct ext3_sb_info
*sbi
= EXT3_SB(sb
);
759 struct ext3_super_block
*es
= sbi
->s_es
;
760 int reserved_gdb
= ext3_bg_has_super(sb
, input
->group
) ?
761 le16_to_cpu(es
->s_reserved_gdt_blocks
) : 0;
762 struct buffer_head
*primary
= NULL
;
763 struct ext3_group_desc
*gdp
;
764 struct inode
*inode
= NULL
;
766 int gdb_off
, gdb_num
;
769 gdb_num
= input
->group
/ EXT3_DESC_PER_BLOCK(sb
);
770 gdb_off
= input
->group
% EXT3_DESC_PER_BLOCK(sb
);
772 if (gdb_off
== 0 && !EXT3_HAS_RO_COMPAT_FEATURE(sb
,
773 EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER
)) {
774 ext3_warning(sb
, __func__
,
775 "Can't resize non-sparse filesystem further");
779 if (le32_to_cpu(es
->s_blocks_count
) + input
->blocks_count
<
780 le32_to_cpu(es
->s_blocks_count
)) {
781 ext3_warning(sb
, __func__
, "blocks_count overflow\n");
785 if (le32_to_cpu(es
->s_inodes_count
) + EXT3_INODES_PER_GROUP(sb
) <
786 le32_to_cpu(es
->s_inodes_count
)) {
787 ext3_warning(sb
, __func__
, "inodes_count overflow\n");
791 if (reserved_gdb
|| gdb_off
== 0) {
792 if (!EXT3_HAS_COMPAT_FEATURE(sb
,
793 EXT3_FEATURE_COMPAT_RESIZE_INODE
)){
794 ext3_warning(sb
, __func__
,
795 "No reserved GDT blocks, can't resize");
798 inode
= ext3_iget(sb
, EXT3_RESIZE_INO
);
800 ext3_warning(sb
, __func__
,
801 "Error opening resize inode");
802 return PTR_ERR(inode
);
806 if ((err
= verify_group_input(sb
, input
)))
809 if ((err
= setup_new_group_blocks(sb
, input
)))
813 * We will always be modifying at least the superblock and a GDT
814 * block. If we are adding a group past the last current GDT block,
815 * we will also modify the inode and the dindirect block. If we
816 * are adding a group with superblock/GDT backups we will also
817 * modify each of the reserved GDT dindirect blocks.
819 handle
= ext3_journal_start_sb(sb
,
820 ext3_bg_has_super(sb
, input
->group
) ?
821 3 + reserved_gdb
: 4);
822 if (IS_ERR(handle
)) {
823 err
= PTR_ERR(handle
);
828 if (input
->group
!= sbi
->s_groups_count
) {
829 ext3_warning(sb
, __func__
,
830 "multiple resizers run on filesystem!");
835 if ((err
= ext3_journal_get_write_access(handle
, sbi
->s_sbh
)))
839 * We will only either add reserved group blocks to a backup group
840 * or remove reserved blocks for the first group in a new group block.
841 * Doing both would be mean more complex code, and sane people don't
842 * use non-sparse filesystems anymore. This is already checked above.
845 primary
= sbi
->s_group_desc
[gdb_num
];
846 if ((err
= ext3_journal_get_write_access(handle
, primary
)))
849 if (reserved_gdb
&& ext3_bg_num_gdb(sb
, input
->group
) &&
850 (err
= reserve_backup_gdb(handle
, inode
, input
)))
852 } else if ((err
= add_new_gdb(handle
, inode
, input
, &primary
)))
856 * OK, now we've set up the new group. Time to make it active.
858 * Current kernels don't lock all allocations via lock_super(),
859 * so we have to be safe wrt. concurrent accesses the group
860 * data. So we need to be careful to set all of the relevant
861 * group descriptor data etc. *before* we enable the group.
863 * The key field here is sbi->s_groups_count: as long as
864 * that retains its old value, nobody is going to access the new
867 * So first we update all the descriptor metadata for the new
868 * group; then we update the total disk blocks count; then we
869 * update the groups count to enable the group; then finally we
870 * update the free space counts so that the system can start
871 * using the new disk blocks.
874 /* Update group descriptor block for new group */
875 gdp
= (struct ext3_group_desc
*)primary
->b_data
+ gdb_off
;
877 gdp
->bg_block_bitmap
= cpu_to_le32(input
->block_bitmap
);
878 gdp
->bg_inode_bitmap
= cpu_to_le32(input
->inode_bitmap
);
879 gdp
->bg_inode_table
= cpu_to_le32(input
->inode_table
);
880 gdp
->bg_free_blocks_count
= cpu_to_le16(input
->free_blocks_count
);
881 gdp
->bg_free_inodes_count
= cpu_to_le16(EXT3_INODES_PER_GROUP(sb
));
884 * Make the new blocks and inodes valid next. We do this before
885 * increasing the group count so that once the group is enabled,
886 * all of its blocks and inodes are already valid.
888 * We always allocate group-by-group, then block-by-block or
889 * inode-by-inode within a group, so enabling these
890 * blocks/inodes before the group is live won't actually let us
891 * allocate the new space yet.
893 le32_add_cpu(&es
->s_blocks_count
, input
->blocks_count
);
894 le32_add_cpu(&es
->s_inodes_count
, EXT3_INODES_PER_GROUP(sb
));
897 * We need to protect s_groups_count against other CPUs seeing
898 * inconsistent state in the superblock.
900 * The precise rules we use are:
902 * * Writers of s_groups_count *must* hold lock_super
904 * * Writers must perform a smp_wmb() after updating all dependent
905 * data and before modifying the groups count
907 * * Readers must hold lock_super() over the access
909 * * Readers must perform an smp_rmb() after reading the groups count
910 * and before reading any dependent data.
912 * NB. These rules can be relaxed when checking the group count
913 * while freeing data, as we can only allocate from a block
914 * group after serialising against the group count, and we can
915 * only then free after serialising in turn against that
920 /* Update the global fs size fields */
921 sbi
->s_groups_count
++;
923 ext3_journal_dirty_metadata(handle
, primary
);
925 /* Update the reserved block counts only once the new group is
927 le32_add_cpu(&es
->s_r_blocks_count
, input
->reserved_blocks
);
929 /* Update the free space counts */
930 percpu_counter_add(&sbi
->s_freeblocks_counter
,
931 input
->free_blocks_count
);
932 percpu_counter_add(&sbi
->s_freeinodes_counter
,
933 EXT3_INODES_PER_GROUP(sb
));
935 ext3_journal_dirty_metadata(handle
, sbi
->s_sbh
);
940 if ((err2
= ext3_journal_stop(handle
)) && !err
)
943 update_backups(sb
, sbi
->s_sbh
->b_blocknr
, (char *)es
,
944 sizeof(struct ext3_super_block
));
945 update_backups(sb
, primary
->b_blocknr
, primary
->b_data
,
951 } /* ext3_group_add */
953 /* Extend the filesystem to the new number of blocks specified. This entry
954 * point is only used to extend the current filesystem to the end of the last
955 * existing group. It can be accessed via ioctl, or by "remount,resize=<size>"
956 * for emergencies (because it has no dependencies on reserved blocks).
958 * If we _really_ wanted, we could use default values to call ext3_group_add()
959 * allow the "remount" trick to work for arbitrary resizing, assuming enough
960 * GDT blocks are reserved to grow to the desired size.
962 int ext3_group_extend(struct super_block
*sb
, struct ext3_super_block
*es
,
963 ext3_fsblk_t n_blocks_count
)
965 ext3_fsblk_t o_blocks_count
;
966 unsigned long o_groups_count
;
969 struct buffer_head
* bh
;
972 unsigned long freed_blocks
;
974 /* We don't need to worry about locking wrt other resizers just
975 * yet: we're going to revalidate es->s_blocks_count after
976 * taking lock_super() below. */
977 o_blocks_count
= le32_to_cpu(es
->s_blocks_count
);
978 o_groups_count
= EXT3_SB(sb
)->s_groups_count
;
980 if (test_opt(sb
, DEBUG
))
981 printk(KERN_DEBUG
"EXT3-fs: extending last group from "E3FSBLK
" uto "E3FSBLK
" blocks\n",
982 o_blocks_count
, n_blocks_count
);
984 if (n_blocks_count
== 0 || n_blocks_count
== o_blocks_count
)
987 if (n_blocks_count
> (sector_t
)(~0ULL) >> (sb
->s_blocksize_bits
- 9)) {
988 printk(KERN_ERR
"EXT3-fs: filesystem on %s:"
989 " too large to resize to %lu blocks safely\n",
990 sb
->s_id
, n_blocks_count
);
991 if (sizeof(sector_t
) < 8)
992 ext3_warning(sb
, __func__
,
993 "CONFIG_LBD not enabled\n");
997 if (n_blocks_count
< o_blocks_count
) {
998 ext3_warning(sb
, __func__
,
999 "can't shrink FS - resize aborted");
1003 /* Handle the remaining blocks in the last group only. */
1004 last
= (o_blocks_count
- le32_to_cpu(es
->s_first_data_block
)) %
1005 EXT3_BLOCKS_PER_GROUP(sb
);
1008 ext3_warning(sb
, __func__
,
1009 "need to use ext2online to resize further");
1013 add
= EXT3_BLOCKS_PER_GROUP(sb
) - last
;
1015 if (o_blocks_count
+ add
< o_blocks_count
) {
1016 ext3_warning(sb
, __func__
, "blocks_count overflow");
1020 if (o_blocks_count
+ add
> n_blocks_count
)
1021 add
= n_blocks_count
- o_blocks_count
;
1023 if (o_blocks_count
+ add
< n_blocks_count
)
1024 ext3_warning(sb
, __func__
,
1025 "will only finish group ("E3FSBLK
1027 o_blocks_count
+ add
, add
);
1029 /* See if the device is actually as big as what was requested */
1030 bh
= sb_bread(sb
, o_blocks_count
+ add
-1);
1032 ext3_warning(sb
, __func__
,
1033 "can't read last block, resize aborted");
1038 /* We will update the superblock, one block bitmap, and
1039 * one group descriptor via ext3_free_blocks().
1041 handle
= ext3_journal_start_sb(sb
, 3);
1042 if (IS_ERR(handle
)) {
1043 err
= PTR_ERR(handle
);
1044 ext3_warning(sb
, __func__
, "error %d on journal start",err
);
1049 if (o_blocks_count
!= le32_to_cpu(es
->s_blocks_count
)) {
1050 ext3_warning(sb
, __func__
,
1051 "multiple resizers run on filesystem!");
1053 ext3_journal_stop(handle
);
1058 if ((err
= ext3_journal_get_write_access(handle
,
1059 EXT3_SB(sb
)->s_sbh
))) {
1060 ext3_warning(sb
, __func__
,
1061 "error %d on journal write access", err
);
1063 ext3_journal_stop(handle
);
1066 es
->s_blocks_count
= cpu_to_le32(o_blocks_count
+ add
);
1067 ext3_journal_dirty_metadata(handle
, EXT3_SB(sb
)->s_sbh
);
1070 ext3_debug("freeing blocks %lu through "E3FSBLK
"\n", o_blocks_count
,
1071 o_blocks_count
+ add
);
1072 ext3_free_blocks_sb(handle
, sb
, o_blocks_count
, add
, &freed_blocks
);
1073 ext3_debug("freed blocks "E3FSBLK
" through "E3FSBLK
"\n", o_blocks_count
,
1074 o_blocks_count
+ add
);
1075 if ((err
= ext3_journal_stop(handle
)))
1077 if (test_opt(sb
, DEBUG
))
1078 printk(KERN_DEBUG
"EXT3-fs: extended group to %u blocks\n",
1079 le32_to_cpu(es
->s_blocks_count
));
1080 update_backups(sb
, EXT3_SB(sb
)->s_sbh
->b_blocknr
, (char *)es
,
1081 sizeof(struct ext3_super_block
));
1084 } /* ext3_group_extend */