Make Ext3 fsck way faster [2.6.23.13, updated patch]
Here's an updated patch for 2.6.23.13 that fixes a problem introduced due to patching that I discovered while testing the 2.6.23.13 change I sent out earlier today (the -mm tree patch does not suffer from this problem).
Thanks,
Abhishek
Signed-off-by Abhishek Rai <[email protected]>
fs/ext3/balloc.c +528 -191
@@ -33,6 +33,29 @@* super block. Each descriptor contains the number of the bitmap block and * the free blocks count in the block. The descriptors are loaded in memory * when a file system is mounted (see ext3_fill_super). +* +* A note on ext3 metaclustering: +* +* Start of End of +* block group block group +* ________________________________________________________________ +* | NON-MC REGION | MC REGION | +* | |Overflow | +* |Data blocks and |data Indirect | +* |overflow indirect blocks |blocks blocks | +* |----------> |-------> <--------| +* |________________________________________________________________| +* +* Every block group has at its end a semi-reserved region called the +* metacluster mostly used for allocating indirect blocks. Under normal +* circumstances, the metacluster is used only for allocating indirect +* blocks which are allocated in decreasing order of block numbers. +* The non-Metacluster region is used for data block allocation which are +* allocated in increasing order of block numbers. However, when the MC +* runs out of space, indirect blocks can be allocated in the non-MC +* region along with the data blocks in the forward direction. Similarly, +* when non-MC runs out of space, new data blocks are allocated in MC but +* in the forward direction. */
@@ -108,6 +131,88 @@ read_block_bitmap(struct super_block *sb error_out:return bh; } + + +/* +* Count number of free blocks in a block group that don't lie in the +* metacluster region of the block group. +*/ +static void +ext3_init_grp_free_nonmc_blocks (struct super_block *sb, +struct buffer_head *bitmap_bh, +unsigned long block_group) +{ +struct ext3_sb_info *sbi =EXT3_SB (sb); +struct ext3_bg_info *bgi = &sbi->s_bginfo[block_group]; + +BUG_ON (!test_opt (sb,METACLUSTER )); + +spin_lock (sb_bgl_lock (sbi, block_group)); +if (bgi->bgi_free_nonmc_blocks_count >=0 ) + goto out; + + bgi->bgi_free_nonmc_blocks_count = +ext3_count_free (bitmap_bh, sbi->s_nonmc_blocks_per_group/8 ); + +out: +spin_unlock (sb_bgl_lock (sbi, block_group)); +BUG_ON (bgi->bgi_free_nonmc_blocks_count > + sbi->s_nonmc_blocks_per_group); +} + +/* +* ext3_update_nonmc_block_count: +* Update bgi_free_nonmc_blocks_count for block group 'group_no' following +* an allocation or deallocation. +* +* @group_no: affected block group +* @start: start of the [de]allocated range +* @count: number of blocks [de]allocated +* @allocation: 1 if blocks were allocated, 0 otherwise. +*/ +static inline void +ext3_update_nonmc_block_count (struct ext3_sb_info *sbi,unsigned long group_no, +ext3_grpblk_t start,unsigned long count, +int allocation) +{ +struct ext3_bg_info *bginfo = &sbi->s_bginfo[group_no]; +ext3_grpblk_t change; + +BUG_ON (bginfo->bgi_free_nonmc_blocks_count <0 ); +BUG_ON (start >= sbi->s_nonmc_blocks_per_group); + + change =min_t (ext3_grpblk_t, start + count, + sbi->s_nonmc_blocks_per_group) - start; + +spin_lock (sb_bgl_lock (sbi, group_no)); +BUG_ON (bginfo->bgi_free_nonmc_blocks_count > + sbi->s_nonmc_blocks_per_group); +BUG_ON (allocation && bginfo->bgi_free_nonmc_blocks_count < change); + + bginfo->bgi_free_nonmc_blocks_count += (allocation ? -change : change); + +BUG_ON (bginfo->bgi_free_nonmc_blocks_count > + sbi->s_nonmc_blocks_per_group); +spin_unlock (sb_bgl_lock (sbi, group_no)); +} + +/* +* allow_mc_alloc: +* Check if we can use metacluster region of a block group for general +* allocation if needed. Ideally, we should allow this only if +* bgi_free_nonmc_blocks_count == 0, but sometimes there is a small number +* of blocks which don't get allocated in the first pass, no point +* breaking our file at the metacluster boundary because of that, so we +* relax the limit to 8. +*/ +static inline int allow_mc_alloc (struct ext3_sb_info *sbi, +struct ext3_bg_info *bgi, +ext3_grpblk_t blk) +{ +return !(blk >=0 && blk >= sbi->s_nonmc_blocks_per_group && + bgi->bgi_free_nonmc_blocks_count >=8 ); +} +/* * The reservation window structure operations * --------------------------------------------
@@ -424,6 +529,7 @@ void ext3_free_blocks_sb(handle_t *handlstruct ext3_group_desc * desc;struct ext3_super_block * es;struct ext3_sb_info *sbi; +struct ext3_bg_info *bgi;int err =0 , ret;ext3_grpblk_t group_freed;
@@ -463,6 +569,13 @@ do_more:if (!desc) goto error_return; +if (test_opt (sb,METACLUSTER )) { + bgi = &sbi->s_bginfo[block_group]; +if (bgi->bgi_free_nonmc_blocks_count <0 ) +ext3_init_grp_free_nonmc_blocks (sb, bitmap_bh, + block_group); + } +if (in_range (le32_to_cpu (desc->bg_block_bitmap), block, count) ||in_range (le32_to_cpu (desc->bg_inode_bitmap), block, count) || in_range (block, le32_to_cpu(desc->bg_inode_table),
@@ -582,6 +695,9 @@ do_more:if (!err) err = ret; *pdquot_freed_blocks += group_freed; +if (test_opt (sb,METACLUSTER ) && bit < sbi->s_nonmc_blocks_per_group) +ext3_update_nonmc_block_count (sbi, block_group, bit, count,0 ); +if (overflow && !err) { block += count; count = overflow;
@@ -687,6 +803,50 @@ bitmap_search_next_usable_block(ext3_grpreturn -1 ; } +static ext3_grpblk_t +bitmap_find_prev_zero_bit (char *map,ext3_grpblk_t start,ext3_grpblk_t lowest) +{ +ext3_grpblk_t k, blk; + + k = start & ~7 ; +while (lowest <= k) { +if (map[k/8 ] !='\255' && + (blk =ext3_find_next_zero_bit (map, k +8 , k)) + < (k +8 )) +return blk; + + k -=8 ; + } +return -1 ; +} + +static ext3_grpblk_t +bitmap_search_prev_usable_block (ext3_grpblk_t start,struct buffer_head *bh, +ext3_grpblk_t lowest) +{ +ext3_grpblk_t next; +struct journal_head *jh =bh2jh (bh); + +/* +* The bitmap search --- search backward alternately through the actual +* bitmap and the last-committed copy until we find a bit free in +* both +*/ +while (start >= lowest) { + next =bitmap_find_prev_zero_bit (bh->b_data, start, lowest); +if (next < lowest) +return -1 ; +if (ext3_test_allocatable (next, bh)) +return next; +jbd_lock_bh_state (bh); +if (jh->b_committed_data) + start =bitmap_find_prev_zero_bit (jh->b_committed_data, + next, lowest); +jbd_unlock_bh_state (bh); + } +return -1 ; +} +/** * find_next_usable_block() * @start: the starting block (group relative) to find next
@@ -794,19 +954,27 @@ claim_block(spinlock_t *lock, ext3_grpbl* file's own reservation window; * Otherwise, the allocation range starts from the give goal block, ends at * the block group's last block. -* -* If we failed to allocate the desired block then we may end up crossing to a -* new bitmap. In that case we must release write access to the old one via -* ext3_journal_release_buffer(), else we'll run out of credits. */ static ext3_grpblk_t ext3_try_to_allocate (struct super_block *sb,handle_t *handle,int group,struct buffer_head *bitmap_bh,ext3_grpblk_t grp_goal,unsigned long *count,struct ext3_reserve_window *my_rsv) { +struct ext3_sb_info *sbi =EXT3_SB (sb); +struct ext3_group_desc *gdp; +struct ext3_bg_info *bgi =NULL ; +struct buffer_head *gdp_bh;ext3_fsblk_t group_first_block;ext3_grpblk_t start, end;unsigned long num =0 ; +const int metaclustering =test_opt (sb,METACLUSTER ); + +if (metaclustering) + bgi = &sbi->s_bginfo[group]; + + gdp =ext3_get_group_desc (sb, group, &gdp_bh); +if (!gdp) + goto fail_access;/* we do allocation within the reservation window if we have a window */ if (my_rsv) {
@@ -851,8 +1019,10 @@ repeat: } start = grp_goal; -if (!claim_block (sb_bgl_lock (EXT3_SB (sb), group), - grp_goal, bitmap_bh)) { +if (metaclustering && !allow_mc_alloc (sbi, bgi, grp_goal)) + goto fail_access; + +if (!claim_block (sb_bgl_lock (sbi, group), grp_goal, bitmap_bh)) {/* * The block was allocated by another thread, or it was * allocated and then freed by another thread
@@ -867,8 +1037,8 @@ repeat: grp_goal++;while (num < *count && grp_goal < end &&ext3_test_allocatable (grp_goal, bitmap_bh) - &&claim_block (sb_bgl_lock (EXT3_SB (sb), group), - grp_goal, bitmap_bh)) { + && (!metaclustering ||allow_mc_alloc (sbi, bgi, grp_goal)) + &&claim_block (sb_bgl_lock (sbi, group), grp_goal, bitmap_bh)) { num++; grp_goal++; }
@@ -1099,7 +1269,9 @@ static int alloc_new_reservation(struct/* * find_next_reservable_window() simply finds a reservable window -* inside the given range(start_block, group_end_block). +* inside the given range(start_block, group_end_block). The +* reservation window must have a reservable free bit inside it for our +* callers to work correctly. * * To make sure the reservation window has a free bit inside it, we * need to check the bitmap after we found a reservable window.
@@ -1131,10 +1303,17 @@ retry: my_rsv->rsv_start - group_first_block, bitmap_bh, group_end_block - group_first_block + 1); -if (first_free_block <0 ) { +if (first_free_block <0 || + (test_opt (sb,METACLUSTER ) + && !allow_mc_alloc (EXT3_SB (sb), &EXT3_SB (sb)->s_bginfo[group], + first_free_block))) {/* -* no free block left on the bitmap, no point -* to reserve the space. return failed. +* No free block left on the bitmap, no point to reserve space, +* return failed. We also fail here if metaclustering is enabled +* and the first free block in the window lies in the +* metacluster while there are free non-mc blocks in the block +* group, such a window or any window following it is not useful +* to us. */ spin_lock (rsv_lock);if (!rsv_is_empty (&my_rsv->rsv_window))
@@ -1237,25 +1416,17 @@ ext3_try_to_allocate_with_rsv(struct sup unsigned int group, struct buffer_head *bitmap_bh, ext3_grpblk_t grp_goal, struct ext3_reserve_window_node * my_rsv, - unsigned long *count, int *errp) + unsigned long *count) { + struct ext3_bg_info *bgi;ext3_fsblk_t group_first_block, group_last_block;ext3_grpblk_t ret =0 ; -int fatal;unsigned long num = *count; - *errp =0 ; - -/* -* Make sure we use undo access for the bitmap, because it is critical -* that we do the frozen_data COW on bitmap buffers in all cases even -* if the buffer is in BJ_Forget state in the committing transaction. -*/ -BUFFER_TRACE (bitmap_bh,"get undo access for new block" ); - fatal =ext3_journal_get_undo_access (handle, bitmap_bh); -if (fatal) { - *errp = fatal; -return -1 ; +if (test_opt (sb,METACLUSTER )) { + bgi = &EXT3_SB (sb)->s_bginfo[group]; +if (bgi->bgi_free_nonmc_blocks_count <0 ) +ext3_init_grp_free_nonmc_blocks (sb, bitmap_bh, group); }/*
@@ -1331,19 +1502,6 @@ ext3_try_to_allocate_with_rsv(struct sup num = *count; } out: -if (ret >=0 ) { -BUFFER_TRACE (bitmap_bh,"journal_dirty_metadata for " -"bitmap block" ); - fatal =ext3_journal_dirty_metadata (handle, bitmap_bh); -if (fatal) { - *errp = fatal; -return -1 ; - } -return ret; - } - -BUFFER_TRACE (bitmap_bh,"journal_release_buffer" ); -ext3_journal_release_buffer (handle, bitmap_bh);return ret; }
@@ -1389,22 +1547,149 @@ int ext3_should_retry_alloc(struct superreturn journal_force_commit_nested (EXT3_SB (sb)->s_journal); } +/* +* ext3_alloc_indirect_blocks: +* Helper function for ext3_new_blocks. Allocates indirect blocks from the +* metacluster region only and stores their numbers in new_blocks[]. +*/ +int ext3_alloc_indirect_blocks (struct super_block *sb, +struct buffer_head *bitmap_bh, +struct ext3_group_desc *gdp, +int group_no,unsigned long indirect_blks, +ext3_fsblk_t new_blocks[]) +{ +struct ext3_bg_info *bgi = &EXT3_SB (sb)->s_bginfo[group_no]; +ext3_grpblk_t blk =EXT3_BLOCKS_PER_GROUP (sb) -1 ; +ext3_grpblk_t mc_start =EXT3_SB (sb)->s_nonmc_blocks_per_group; +ext3_fsblk_t group_first_block; +int allocated =0 ; + +BUG_ON (!test_opt (sb,METACLUSTER )); + +/* This check is racy but that wouldn't harm us. */ +if (bgi->bgi_free_nonmc_blocks_count >= +le16_to_cpu (gdp->bg_free_blocks_count)) +return 0 ; + + group_first_block =ext3_group_first_block_no (sb, group_no); +while (allocated < indirect_blks && blk >= mc_start) { +if (!ext3_test_allocatable (blk, bitmap_bh)) { + blk =bitmap_search_prev_usable_block (blk, bitmap_bh, + mc_start); +continue ; + } +if (claim_block (sb_bgl_lock (EXT3_SB (sb), group_no), blk, + bitmap_bh)) { + new_blocks[allocated++] = group_first_block + blk; + }else { +/* +* The block was allocated by another thread, or it +* was allocated and then freed by another thread +*/ +cpu_relax (); + } +if (allocated < indirect_blks) + blk =bitmap_search_prev_usable_block (blk, bitmap_bh, + mc_start); + } +return allocated; +} + +/* +* check_allocated_blocks: +* Helper function for ext3_new_blocks. Checks newly allocated block +* numbers. +*/ +int check_allocated_blocks (ext3_fsblk_t blk,unsigned long num, +struct super_block *sb,int group_no, +struct ext3_group_desc *gdp, +struct buffer_head *bitmap_bh) +{ +struct ext3_super_block *es =EXT3_SB (sb)->s_es; +struct ext3_sb_info *sbi =EXT3_SB (sb); +ext3_fsblk_t grp_blk = blk -ext3_group_first_block_no (sb, group_no); + +if (in_range (le32_to_cpu (gdp->bg_block_bitmap), blk, num) || +in_range (le32_to_cpu (gdp->bg_inode_bitmap), blk, num) || +in_range (blk,le32_to_cpu (gdp->bg_inode_table), +EXT3_SB (sb)->s_itb_per_group) || +in_range (blk + num -1 ,le32_to_cpu (gdp->bg_inode_table), +EXT3_SB (sb)->s_itb_per_group)) +ext3_error (sb,"ext3_new_blocks" , +"Allocating block in system zone - " +"blocks from " E3FSBLK ", length %lu" , + blk, num); + +#ifdef CONFIG_JBD_DEBUG + { +struct buffer_head *debug_bh; + +/* Record bitmap buffer state in the newly allocated block */ + debug_bh =sb_find_get_block (sb, blk); +if (debug_bh) { +BUFFER_TRACE (debug_bh,"state when allocated" ); +BUFFER_TRACE2 (debug_bh, bitmap_bh,"bitmap state" ); +brelse (debug_bh); + } + } +jbd_lock_bh_state (bitmap_bh); +spin_lock (sb_bgl_lock (sbi, group_no)); +if (buffer_jbd (bitmap_bh) &&bh2jh (bitmap_bh)->b_committed_data) { +int i; + +for (i =0 ; i < num; i++) { +if (ext3_test_bit (grp_blk+i, +bh2jh (bitmap_bh)->b_committed_data)) +printk (KERN_ERR "%s: block was unexpectedly set" +" in b_committed_data\n" , __FUNCTION__); + } + } +ext3_debug ("found bit %d\n" , grp_blk); +spin_unlock (sb_bgl_lock (sbi, group_no)); +jbd_unlock_bh_state (bitmap_bh); +#endif + +if (blk + num -1 >=le32_to_cpu (es->s_blocks_count)) { +ext3_error (sb,"ext3_new_blocks" , +"block(" E3FSBLK ") >= blocks count(%d) - " +"block_group = %d, es == %p " , blk, +le32_to_cpu (es->s_blocks_count), group_no, es); +return 1 ; + } + +return 0 ; +} +/** -* ext3_new_blocks() -- core block(s) allocation function -* @handle: handle to this transaction -* @inode: file inode -* @goal: given target block(filesystem wide) -* @count: target number of blocks to allocate -* @errp: error code +* ext3_new_blocks - allocate indirect blocks and direct blocks. +* @handle: handle to this transaction +* @inode: file inode +* @goal: given target block(filesystem wide) +* @indirect_blks number of indirect blocks to allocate +* @blks number of direct blocks to allocate +* @new_blocks this will store the block numbers of indirect blocks +* and direct blocks upon return. * -* ext3_new_blocks uses a goal block to assist allocation. It tries to -* allocate block(s) from the block group contains the goal block first. If that -* fails, it will try to allocate block(s) from other block groups without -* any specific goal block. +* returns the number of direct blocks allocated. Fewer than requested +* number of direct blocks may be allocated but all requested indirect +* blocks must be allocated in order to return success. * +* Without metaclustering, ext3_new_block allocates all blocks using a +* goal block to assist allocation. It tries to allocate block(s) from +* the block group contains the goal block first. If that fails, it will +* try to allocate block(s) from other block groups without any specific +* goal block. +* +* With metaclustering, the only difference is that indirect block +* allocation is first attempted in the metacluster region of the same +* block group failing which they are allocated along with direct blocks. +* +* This function also updates quota and i_blocks field. */ -ext3_fsblk_t ext3_new_blocks (handle_t *handle,struct inode *inode, -ext3_fsblk_t goal,unsigned long *count,int *errp) +int ext3_new_blocks (handle_t *handle,struct inode *inode, +ext3_fsblk_t goal,int indirect_blks,int blks, +ext3_fsblk_t new_blocks[4 ],int *errp) + {struct buffer_head *bitmap_bh =NULL ;struct buffer_head *gdp_bh;
@@ -1413,10 +1698,16 @@ ext3_fsblk_t ext3_new_blocks(handle_t *hext3_grpblk_t grp_target_blk;/* blockgroup relative goal block */ ext3_grpblk_t grp_alloc_blk;/* blockgroup-relative allocated block*/ ext3_fsblk_t ret_block;/* filesyetem-wide allocated block */ +ext3_fsblk_t group_first_block;/* first block in the group */ int bgi;/* blockgroup iteration index */ int fatal =0 , err;int performed_allocation =0 ;ext3_grpblk_t free_blocks;/* number of free blocks in a group */ +unsigned long ngroups; +unsigned long grp_mc_alloc;/* blocks allocated from mc in a group */ +unsigned long grp_alloc;/* blocks allocated outside mc in a group */ +int indirect_blks_done =0 ;/* total ind blocks allocated so far */ +int blks_done =0 ;/* total direct blocks allocated */ struct super_block *sb;struct ext3_group_desc *gdp;struct ext3_super_block *es;
@@ -1424,23 +1715,23 @@ ext3_fsblk_t ext3_new_blocks(handle_t *hstruct ext3_reserve_window_node *my_rsv =NULL ;struct ext3_block_alloc_info *block_i;unsigned short windowsz =0 ; +int i;#ifdef EXT3FS_DEBUG static int goal_hits, goal_attempts;#endif -unsigned long ngroups; -unsigned long num = *count; *errp = -ENOSPC ; sb = inode->i_sb;if (!sb) { -printk ("ext3_new_block: nonexistent device" ); +printk (KERN_INFO "ext3_new_blocks: nonexistent device" ); + *errp = -ENODEV ;return 0 ; }/* * Check quota for allocation of this block. */ -if (DQUOT_ALLOC_BLOCK (inode, num)) { +if (DQUOT_ALLOC_BLOCK (inode, indirect_blks + blks)) { *errp = -EDQUOT ;return 0 ; }
@@ -1474,73 +1765,194 @@ ext3_fsblk_t ext3_new_blocks(handle_t *h group_no = (goal -le32_to_cpu (es->s_first_data_block)) /EXT3_BLOCKS_PER_GROUP (sb); goal_group = group_no; -retry_alloc: - gdp =ext3_get_group_desc (sb, group_no, &gdp_bh); -if (!gdp) - goto io_error; - - free_blocks =le16_to_cpu (gdp->bg_free_blocks_count); -/* -* if there is not enough free blocks to make a new resevation -* turn off reservation for this allocation -*/ -if (my_rsv && (free_blocks < windowsz) - && (rsv_is_empty (&my_rsv->rsv_window))) - my_rsv =NULL ; - -if (free_blocks >0 ) { - grp_target_blk = ((goal -le32_to_cpu (es->s_first_data_block)) % -EXT3_BLOCKS_PER_GROUP (sb)); - bitmap_bh =read_block_bitmap (sb, group_no); -if (!bitmap_bh) - goto io_error; - grp_alloc_blk =ext3_try_to_allocate_with_rsv (sb, handle, - group_no, bitmap_bh, grp_target_blk, - my_rsv, &num, &fatal); -if (fatal) - goto out; -if (grp_alloc_blk >=0 ) - goto allocated; - } +retry_alloc: + grp_target_blk = ((goal -le32_to_cpu (es->s_first_data_block)) % +EXT3_BLOCKS_PER_GROUP (sb)); ngroups =EXT3_SB (sb)->s_groups_count;smp_rmb ();/* -* Now search the rest of the groups. We assume that -* i and gdp correctly point to the last group visited. +* Iterate over successive block groups for allocating (any) indirect +* blocks and direct blocks until at least one direct block has been +* allocated. If metaclustering is enabled, we try allocating indirect +* blocks first in the metacluster region and then in the general +* region and if that fails too, we repeat the same algorithm in the +* next block group and so on. This not only keeps the indirect blocks +* together in the metacluster, but also keeps them in close proximity +* to their corresponding direct blocks. +* +* The search begins and ends at the goal group, though the second time +* we are at the goal group we try allocating without a goal. */ -for (bgi =0 ; bgi < ngroups; bgi++) { - group_no++; + bgi =0 ; +while (bgi < ngroups +1 ) { + grp_mc_alloc =0 ; +if (group_no >= ngroups) group_no =0 ; + gdp =ext3_get_group_desc (sb, group_no, &gdp_bh);if (!gdp) goto io_error; + free_blocks =le16_to_cpu (gdp->bg_free_blocks_count); -/* -* skip this group if the number of -* free blocks is less than half of the reservation -* window size. -*/ -if (free_blocks <= (windowsz/2 )) -continue ; +if (group_no == goal_group) { +if (my_rsv && (free_blocks < windowsz) + && (rsv_is_empty (&my_rsv->rsv_window))) + my_rsv =NULL ; +if (free_blocks ==0 ) + goto next; + }else if (free_blocks <= windowsz/2 ) + goto next; -brelse (bitmap_bh); bitmap_bh =read_block_bitmap (sb, group_no);if (!bitmap_bh) goto io_error; +/* -* try to allocate block(s) from this group, without a goal(-1). +* Make sure we use undo access for the bitmap, because it is +* critical that we do the frozen_data COW on bitmap buffers in +* all cases even if the buffer is in BJ_Forget state in the +* committing transaction. +*/ +BUFFER_TRACE (bitmap_bh,"get undo access for new block" ); + fatal =ext3_journal_get_undo_access (handle, bitmap_bh); +if (fatal) + goto out; + +/* +* If metaclustering is enabled, first try to allocate indirect +* blocks in the metacluster. */ +if (test_opt (sb,METACLUSTER ) && + indirect_blks_done < indirect_blks) + grp_mc_alloc =ext3_alloc_indirect_blocks (sb, + bitmap_bh, gdp, group_no, + indirect_blks - indirect_blks_done, + new_blocks + indirect_blks_done); + +/* Allocate data blocks and any leftover indirect blocks. */ + grp_alloc = indirect_blks + blks + - (indirect_blks_done + grp_mc_alloc); grp_alloc_blk =ext3_try_to_allocate_with_rsv (sb, handle, - group_no, bitmap_bh,-1 , my_rsv, - &num, &fatal); + group_no, bitmap_bh, grp_target_blk, + my_rsv, &grp_alloc); +if (grp_alloc_blk <0 ) + grp_alloc =0 ; + +/* +* If we couldn't allocate anything, there is nothing more to +* do with this block group, so move over to the next. But +* before that We must release write access to the old one via +* ext3_journal_release_buffer(), else we'll run out of credits. +*/ +if (grp_mc_alloc ==0 && grp_alloc ==0 ) { +BUFFER_TRACE (bitmap_bh,"journal_release_buffer" ); +ext3_journal_release_buffer (handle, bitmap_bh); + goto next; + } + +BUFFER_TRACE (bitmap_bh,"journal_dirty_metadata for " +"bitmap block" ); + fatal =ext3_journal_dirty_metadata (handle, bitmap_bh);if (fatal) goto out; -if (grp_alloc_blk >=0 ) + +ext3_debug ("using block group %d(%d)\n" , + group_no, gdp->bg_free_blocks_count); + +BUFFER_TRACE (gdp_bh,"get_write_access" ); + fatal =ext3_journal_get_write_access (handle, gdp_bh); +if (fatal) + goto out; + +/* Should this be called before ext3_journal_dirty_metadata? */ +for (i =0 ; i < grp_mc_alloc; i++) { +if (check_allocated_blocks ( + new_blocks[indirect_blks_done + i],1 , sb, + group_no, gdp, bitmap_bh)) + goto out; + } +if (grp_alloc >0 ) { + ret_block =ext3_group_first_block_no (sb, group_no) + + grp_alloc_blk; +if (check_allocated_blocks (ret_block, grp_alloc, sb, + group_no, gdp, bitmap_bh)) + goto out; + } + + indirect_blks_done += grp_mc_alloc; + performed_allocation =1 ; + +/* The caller will add the new buffer to the journal. */ +if (grp_alloc >0 ) +ext3_debug ("allocating block %lu. " +"Goal hits %d of %d.\n" , + ret_block, goal_hits, goal_attempts); + +spin_lock (sb_bgl_lock (sbi, group_no)); + gdp->bg_free_blocks_count = +cpu_to_le16 (le16_to_cpu (gdp->bg_free_blocks_count) - + (grp_mc_alloc + grp_alloc)); +spin_unlock (sb_bgl_lock (sbi, group_no)); +percpu_counter_mod (&sbi->s_freeblocks_counter, + -(grp_mc_alloc + grp_alloc)); + +BUFFER_TRACE (gdp_bh,"journal_dirty_metadata for " +"group descriptor" ); + err =ext3_journal_dirty_metadata (handle, gdp_bh); +if (!fatal) + fatal = err; + + sb->s_dirt =1 ; +if (fatal) + goto out; + +brelse (bitmap_bh); + bitmap_bh =NULL ; + +if (grp_alloc ==0 ) + goto next; + +/* Update block group non-mc block count since we used some. */ +if (test_opt (sb,METACLUSTER ) && + grp_alloc_blk < sbi->s_nonmc_blocks_per_group) +ext3_update_nonmc_block_count (sbi, group_no, + grp_alloc_blk, grp_alloc,1 ); + +/* +* Assign all the non-mc blocks that we allocated from this +* block group. +*/ + group_first_block =ext3_group_first_block_no (sb, group_no); +while (grp_alloc >0 && indirect_blks_done < indirect_blks) { + new_blocks[indirect_blks_done++] = + group_first_block + grp_alloc_blk; + grp_alloc_blk++; + grp_alloc--; + } + +if (grp_alloc >0 ) { + blks_done = grp_alloc; + new_blocks[indirect_blks_done] = + group_first_block + grp_alloc_blk; goto allocated; + } + +/* +* If we allocated something but not the minimum required, +* it's OK to retry in this group as it might have more free +* blocks. +*/ +continue ; + +next: + bgi++; + group_no++; + grp_target_blk =-1 ; } +/* * We may end up a bogus ealier ENOSPC error due to * filesystem is "full" of reservations, but
@@ -1559,96 +1971,11 @@ retry_alloc: goto out; allocated: - -ext3_debug ("using block group %d(%d)\n" , - group_no, gdp->bg_free_blocks_count); - -BUFFER_TRACE (gdp_bh,"get_write_access" ); - fatal =ext3_journal_get_write_access (handle, gdp_bh); -if (fatal) - goto out; - - ret_block = grp_alloc_blk +ext3_group_first_block_no (sb, group_no); - -if (in_range (le32_to_cpu (gdp->bg_block_bitmap), ret_block, num) || -in_range (le32_to_cpu (gdp->bg_inode_bitmap), ret_block, num) || -in_range (ret_block,le32_to_cpu (gdp->bg_inode_table), -EXT3_SB (sb)->s_itb_per_group) || -in_range (ret_block + num -1 ,le32_to_cpu (gdp->bg_inode_table), -EXT3_SB (sb)->s_itb_per_group)) -ext3_error (sb,"ext3_new_block" , -"Allocating block in system zone - " -"blocks from " E3FSBLK ", length %lu" , - ret_block, num); - - performed_allocation =1 ; - -#ifdef CONFIG_JBD_DEBUG - { -struct buffer_head *debug_bh; - -/* Record bitmap buffer state in the newly allocated block */ - debug_bh =sb_find_get_block (sb, ret_block); -if (debug_bh) { -BUFFER_TRACE (debug_bh,"state when allocated" ); -BUFFER_TRACE2 (debug_bh, bitmap_bh,"bitmap state" ); -brelse (debug_bh); - } - } -jbd_lock_bh_state (bitmap_bh); -spin_lock (sb_bgl_lock (sbi, group_no)); -if (buffer_jbd (bitmap_bh) &&bh2jh (bitmap_bh)->b_committed_data) { -int i; - -for (i =0 ; i < num; i++) { -if (ext3_test_bit (grp_alloc_blk+i, -bh2jh (bitmap_bh)->b_committed_data)) { -printk ("%s: block was unexpectedly set in " -"b_committed_data\n" , __FUNCTION__); - } - } - } -ext3_debug ("found bit %d\n" , grp_alloc_blk); -spin_unlock (sb_bgl_lock (sbi, group_no)); -jbd_unlock_bh_state (bitmap_bh); -#endif - -if (ret_block + num -1 >=le32_to_cpu (es->s_blocks_count)) { -ext3_error (sb,"ext3_new_block" , -"block(" E3FSBLK ") >= blocks count(%d) - " -"block_group = %d, es == %p " , ret_block, -le32_to_cpu (es->s_blocks_count), group_no, es); - goto out; - } - -/* -* It is up to the caller to add the new buffer to a journal -* list of some description. We don't know in advance whether -* the caller wants to use it as metadata or data. -*/ -ext3_debug ("allocating block %lu. Goal hits %d of %d.\n" , - ret_block, goal_hits, goal_attempts); - -spin_lock (sb_bgl_lock (sbi, group_no)); - gdp->bg_free_blocks_count = -cpu_to_le16 (le16_to_cpu (gdp->bg_free_blocks_count)-num); -spin_unlock (sb_bgl_lock (sbi, group_no)); -percpu_counter_mod (&sbi->s_freeblocks_counter, -num); - -BUFFER_TRACE (gdp_bh,"journal_dirty_metadata for group descriptor" ); - err =ext3_journal_dirty_metadata (handle, gdp_bh); -if (!fatal) - fatal = err; - - sb->s_dirt =1 ; -if (fatal) - goto out; - *errp =0 ; -brelse (bitmap_bh); -DQUOT_FREE_BLOCK (inode, *count-num); - *count = num; -return ret_block; +DQUOT_FREE_BLOCK (inode, + indirect_blks + blks - indirect_blks_done - blks_done); + +return blks_done; io_error: *errp = -EIO ;
@@ -1661,7 +1988,13 @@ out:* Undo the block allocation */ if (!performed_allocation) -DQUOT_FREE_BLOCK (inode, *count); +DQUOT_FREE_BLOCK (inode, indirect_blks + blks); +/* +* Free any indirect blocks we allocated already. If the transaction +* has been aborted this is essentially a no-op. +*/ +for (i =0 ; i < indirect_blks_done; i++) +ext3_free_blocks (handle, inode, new_blocks[i],1 );brelse (bitmap_bh);return 0 ; }
@@ -1669,9 +2002,13 @@ out:ext3_fsblk_t ext3_new_block (handle_t *handle,struct inode *inode,ext3_fsblk_t goal,int *errp) { -unsigned long count =1 ; +ext3_fsblk_t new_blocks[4 ]; -return ext3_new_blocks (handle, inode, goal, &count, errp); +ext3_new_blocks (handle, inode, goal,0 ,1 , new_blocks, errp); +if (*errp) +return 0 ; + +return new_blocks[0 ]; }/**
fs/ext3/bitmap.c +0 -5
@@ -11,8 +11,6 @@#include <linux/jbd.h> #include <linux/ext3_fs.h> -#ifdef EXT3FS_DEBUG -static int nibblemap[] = {4 ,3 ,3 ,2 ,3 ,2 ,2 ,1 ,3 ,2 ,2 ,1 ,2 ,1 ,1 ,0 };unsigned long ext3_count_free (struct buffer_head * map,unsigned int numchars)
@@ -27,6 +25,3 @@ unsigned long ext3_count_free (struct bu nibblemap[(map->b_data[i] >>4 ) &0xf ];return (sum); } - -#endif /* EXT3FS_DEBUG */ -
fs/ext3/inode.c +614 -83
801 lines not on this page · raw message
fs/ext3/super.c +36 -8
117 lines not on this page · raw message
include/linux/ext3_fs.h +28 -2
@@ -384,6 +384,7 @@ struct ext3_inode {#define EXT3_MOUNT_QUOTA 0x80000/* Some quota option set */ #define EXT3_MOUNT_USRQUOTA 0x100000/* "old" user quota */ #define EXT3_MOUNT_GRPQUOTA 0x200000/* "old" group quota */ +#define EXT3_MOUNT_METACLUSTER 0x400000/* Indirect block clustering */ /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */ #ifndef _LINUX_EXT2_FS_H
@@ -497,6 +498,7 @@ struct ext3_super_block {#ifdef __KERNEL__#include <linux/ext3_fs_i.h> #include <linux/ext3_fs_sb.h> +#include <linux/buffer_head.h> static inline struct ext3_sb_info *EXT3_SB (struct super_block *sb) {return sb->s_fs_info;
@@ -732,6 +734,11 @@ struct dir_private_info {__u32 next_hash; }; +/* Special bh flag used by the metacluster readahead logic. */ +enum ext3_bh_state_bits { +EXT3_BH_PREFETCH = BH_JBD_Sentinel, +}; +/* calculate the first block number of the group */ static inline ext3_fsblk_t ext3_group_first_block_no (struct super_block *sb,unsigned long group_no)
@@ -740,6 +747,24 @@ ext3_group_first_block_no(struct super_ble32_to_cpu (EXT3_SB (sb)->s_es->s_first_data_block); } +static inline void +ext3_set_buffer_prefetch (struct buffer_head *bh) +{ +set_bit (EXT3_BH_PREFETCH , &bh->b_state); +} + +static inline void +ext3_clear_buffer_prefetch (struct buffer_head *bh) +{ +clear_bit (EXT3_BH_PREFETCH , &bh->b_state); +} + +static inline int +ext3_buffer_prefetch (struct buffer_head *bh) +{ +return test_bit (EXT3_BH_PREFETCH , &bh->b_state); +} +/* * Special error return code only used by dx_probe() and its callers. */
@@ -762,8 +787,9 @@ extern int ext3_bg_has_super(struct supeextern unsigned long ext3_bg_num_gdb (struct super_block *sb,int group);extern ext3_fsblk_t ext3_new_block (handle_t *handle,struct inode *inode,ext3_fsblk_t goal,int *errp); -extern ext3_fsblk_t ext3_new_blocks (handle_t *handle,struct inode *inode, -ext3_fsblk_t goal,unsigned long *count,int *errp); +extern int ext3_new_blocks (handle_t *handle,struct inode *inode, +ext3_fsblk_t goal,int indirect_blks,int blks, +ext3_fsblk_t new_blocks[],int *errp);extern void ext3_free_blocks (handle_t *handle,struct inode *inode,ext3_fsblk_t block,unsigned long count); extern void ext3_free_blocks_sb (handle_t *handle, struct super_block *sb,
include/linux/ext3_fs_sb.h +13 -0
@@ -24,6 +24,8 @@#endif #include <linux/rbtree.h> +struct ext3_bg_info ; +/* * third extended-fs super-block data in memory */
@@ -33,6 +35,7 @@ struct ext3_sb_info {unsigned long s_inodes_per_block;/* Number of inodes per block */ unsigned long s_frags_per_group;/* Number of fragments in a group */ unsigned long s_blocks_per_group;/* Number of blocks in a group */ +unsigned long s_nonmc_blocks_per_group;/* Number of non-metacluster blocks in a group */ unsigned long s_inodes_per_group;/* Number of inodes in a group */ unsigned long s_itb_per_group;/* Number of inode table blocks per group */ unsigned long s_gdb_count;/* Number of group descriptor blocks */
@@ -66,6 +69,9 @@ struct ext3_sb_info {struct rb_root s_rsv_window_root;struct ext3_reserve_window_node s_rsv_window_head; +/* array of per-bg in-memory info */ +struct ext3_bg_info *s_bginfo; +/* Journaling */ struct inode * s_journal_inode;struct journal_s * s_journal;
@@ -82,4 +88,11 @@ struct ext3_sb_info { #endif }; +/* +* in-memory data associated with each block group. +*/ +struct ext3_bg_info { +int bgi_free_nonmc_blocks_count;/* Number of free non-metacluster blocks in group */ +}; +#endif /* _LINUX_EXT3_FS_SB */
include/linux/jbd.h +1 -0
@@ -307,6 +307,7 @@ enum jbd_state_bits { BH_State,/* Pins most journal_head state */ BH_JournalHead,/* Pins bh->b_private and jh->b_bh */ BH_Unshadow,/* Dummy bit, for BJ_Shadow wakeup filtering */ + BH_JBD_Sentinel,/* Start bit for clients of jbd */ };BUFFER_FNS (JBD , jbd)