Patch series to simplify the ext4_*get_block*() functions
Theodore Ts'o
maintainercover Patch series to simplify the ext4_*get_block*() functions
The block allocation functions can use a huge amount of cleanup to make them more understandable. This is just a starting point to make life easier.
- Ted
Theodore Ts'o
maintainerPATCH 1/6 ext4: Simplify function signature for ext4_da_get_block_write()
The function ext4_da_get_block_write() is called in exactly one write, and the last argument, create, is always 1. Remove it to simplify the code slightly.
--- fs/ext4/inode.c | 6 +++--- 1 files changed, 3 insertions(+), 3 deletions(-)
fs/ext4/inode.c +3 -3
@@ -1994,7 +1994,7 @@ static void ext4_print_free_blocks(struct inode *inode)#define EXT4_DELALLOC_RSVED 1static int ext4_da_get_block_write (struct inode *inode,sector_t iblock, -struct buffer_head *bh_result,int create) +struct buffer_head *bh_result) {int ret;unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
@@ -2004,7 +2004,7 @@ static int ext4_da_get_block_write(struct inode *inode, sector_t iblock, handle =ext4_journal_current_handle ();BUG_ON (!handle); ret =ext4_get_blocks_wrap (handle, inode, iblock, max_blocks, - bh_result, create,0 ,EXT4_DELALLOC_RSVED ); + bh_result,1 ,0 ,EXT4_DELALLOC_RSVED );if (ret <=0 )return ret;
@@ -2069,7 +2069,7 @@ static int mpage_da_map_blocks(struct mpage_da_data *mpd)if (!new.b_size)return 0 ; - err =ext4_da_get_block_write (mpd->inode, next, &new,1 ); + err =ext4_da_get_block_write (mpd->inode, next, &new);if (err) {/* * If get block returns with error we simply
Signature · 1 line
1.6.3.rc4.1.g3e14.dirty
Theodore Ts'o
maintainerPATCH 2/6 ext4: Rename ext4_get_blocks_handle() to be ext4_ind_get_blocks()
The static function ext4_get_blocks_handle() is badly named. Of *course* it takes a handle. Since its counterpart for extent-based file is ext4_ext_get_blocks(), rename it to be ext4_ind_get_blocks().
--- fs/ext4/inode.c | 12 ++++++------ 1 files changed, 6 insertions(+), 6 deletions(-)
fs/ext4/inode.c +6 -6
@@ -914,7 +914,7 @@ err_out:* down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem) */ -static int ext4_get_blocks_handle (handle_t *handle,struct inode *inode, +static int ext4_ind_get_blocks (handle_t *handle,struct inode *inode,ext4_lblk_t iblock,unsigned int maxblocks,struct buffer_head *bh_result,int create,int extend_disksize)
@@ -1129,7 +1129,7 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)* mapped. * * If file type is extents based, it will call ext4_ext_get_blocks(), -* Otherwise, call with ext4_get_blocks_handle() to handle indirect mapping +* Otherwise, call with ext4_ind_get_blocks() to handle indirect mapping * based files * * On success, it returns the number of blocks being mapped or allocate.
@@ -1160,8 +1160,8 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block, retval =ext4_ext_get_blocks (handle, inode, block, max_blocks, bh,0 ,0 ); }else { - retval =ext4_get_blocks_handle (handle, - inode, block, max_blocks, bh,0 ,0 ); + retval =ext4_ind_get_blocks (handle, inode, block, max_blocks, + bh,0 ,0 ); }up_read ((&EXT4_I (inode)->i_data_sem));
@@ -1209,7 +1209,7 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block, retval =ext4_ext_get_blocks (handle, inode, block, max_blocks, bh, create, extend_disksize); }else { - retval =ext4_get_blocks_handle (handle, inode, block, + retval =ext4_ind_get_blocks (handle, inode, block, max_blocks, bh, create, extend_disksize);if (retval >0 &&buffer_new (bh)) {
@@ -1291,7 +1291,7 @@ struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode, err =ext4_get_blocks_wrap (handle, inode, block,1 , &dummy, create,1 ,0 );/* -* ext4_get_blocks_handle() returns number of blocks +* ext4_get_blocks_wrap() returns number of blocks * mapped. 0 in case of a HOLE. */ if (err >0 ) {
Signature · 1 line
1.6.3.rc4.1.g3e14.dirty
Theodore Ts'o
maintainerPATCH 3/6 ext4: Rename ext4_get_blocks_wrap() to be ext4_get_blocks()
Another function rename for clarity's sake. The _wrap prefix simply confuses people, and didn't add much people trying to follow the code paths.
--- fs/ext4/dir.c | 3 +-- fs/ext4/ext4.h | 8 ++++---- fs/ext4/extents.c | 6 +++--- fs/ext4/inode.c | 29 ++++++++++++++--------------- 4 files changed, 22 insertions(+), 24 deletions(-)
fs/ext4/dir.c +1 -2
@@ -131,8 +131,7 @@ static int ext4_readdir(struct file *filp,struct buffer_head *bh =NULL ; map_bh.b_state =0 ; - err =ext4_get_blocks_wrap (NULL , inode, blk,1 , &map_bh, -0 ,0 ,0 ); + err =ext4_get_blocks (NULL , inode, blk,1 , &map_bh,0 ,0 ,0 );if (err >0 ) {pgoff_t index = map_bh.b_blocknr >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
fs/ext4/ext4.h +4 -4
@@ -1623,10 +1623,10 @@ extern void ext4_ext_init(struct super_block *);extern void ext4_ext_release (struct super_block *);extern long ext4_fallocate (struct inode *inode,int mode,loff_t offset,loff_t len); -extern int ext4_get_blocks_wrap (handle_t *handle,struct inode *inode, -sector_t block,unsigned int max_blocks, -struct buffer_head *bh,int create, -int extend_disksize,int flag); +extern int ext4_get_blocks (handle_t *handle,struct inode *inode, +sector_t block,unsigned int max_blocks, +struct buffer_head *bh,int create, +int extend_disksize,int flag);extern int ext4_fiemap (struct inode *inode,struct fiemap_extent_info *fieinfo,__u64 start,__u64 len);
fs/ext4/extents.c +3 -3
@@ -3144,9 +3144,9 @@ retry:break ; } map_bh.b_state =0 ; - ret =ext4_get_blocks_wrap (handle, inode, block, - max_blocks, &map_bh, -EXT4_CREATE_UNINITIALIZED_EXT ,0 ,0 ); + ret =ext4_get_blocks (handle, inode, block, + max_blocks, &map_bh, +EXT4_CREATE_UNINITIALIZED_EXT ,0 ,0 );if (ret <=0 ) {#ifdef EXT4FS_DEBUG WARN_ON (ret <=0 );
fs/ext4/inode.c +14 -15
@@ -1121,7 +1121,7 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used) }/* -* The ext4_get_blocks_wrap() function try to look up the requested blocks, +* The ext4_get_blocks() function tries to look up the requested blocks, * and returns if the blocks are already mapped. * * Otherwise it takes the write lock of the i_data_sem and allocate blocks
@@ -1142,9 +1142,9 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)* * It returns the error in case of allocation failure. */ -int ext4_get_blocks_wrap (handle_t *handle,struct inode *inode,sector_t block, -unsigned int max_blocks,struct buffer_head *bh, -int create,int extend_disksize,int flag) +int ext4_get_blocks (handle_t *handle,struct inode *inode,sector_t block, +unsigned int max_blocks,struct buffer_head *bh, +int create,int extend_disksize,int flag) {int retval;
@@ -1262,8 +1262,8 @@ int ext4_get_block(struct inode *inode, sector_t iblock, started =1 ; } - ret =ext4_get_blocks_wrap (handle, inode, iblock, - max_blocks, bh_result, create,0 ,0 ); + ret =ext4_get_blocks (handle, inode, iblock, max_blocks, bh_result, + create,0 ,0 );if (ret >0 ) { bh_result->b_size = (ret << inode->i_blkbits); ret =0 ;
@@ -1288,10 +1288,9 @@ struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode, dummy.b_state =0 ; dummy.b_blocknr =-1000 ;buffer_trace_init (&dummy.b_history); - err =ext4_get_blocks_wrap (handle, inode, block,1 , - &dummy, create,1 ,0 ); + err =ext4_get_blocks (handle, inode, block,1 , &dummy, create,1 ,0 );/* -* ext4_get_blocks_wrap() returns number of blocks +* ext4_get_blocks() returns number of blocks * mapped. 0 in case of a HOLE. */ if (err >0 ) {
@@ -2003,8 +2002,8 @@ static int ext4_da_get_block_write(struct inode *inode, sector_t iblock, handle =ext4_journal_current_handle ();BUG_ON (!handle); - ret =ext4_get_blocks_wrap (handle, inode, iblock, max_blocks, - bh_result,1 ,0 ,EXT4_DELALLOC_RSVED ); + ret =ext4_get_blocks (handle, inode, iblock, max_blocks, + bh_result,1 ,0 ,EXT4_DELALLOC_RSVED );if (ret <=0 )return ret;
@@ -2344,7 +2343,7 @@ static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,* preallocated blocks are unmapped but should treated * the same as allocated blocks. */ - ret =ext4_get_blocks_wrap (NULL , inode, iblock,1 , bh_result,0 ,0 ,0 ); + ret =ext4_get_blocks (NULL , inode, iblock,1 , bh_result,0 ,0 ,0 );if ((ret ==0 ) && !buffer_delay (bh_result)) {/* the block isn't (pre)allocated yet, let's reserve space */ /*
@@ -2388,8 +2387,8 @@ static int ext4_normal_get_block_write(struct inode *inode, sector_t iblock,* we don't want to do block allocation in writepage * so call get_block_wrap with create = 0 */ - ret =ext4_get_blocks_wrap (NULL , inode, iblock, max_blocks, - bh_result,0 ,0 ,0 ); + ret =ext4_get_blocks (NULL , inode, iblock, max_blocks, + bh_result,0 ,0 ,0 );if (ret >0 ) { bh_result->b_size = (ret << inode->i_blkbits); ret =0 ;
@@ -5015,7 +5014,7 @@ int ext4_writepage_trans_blocks(struct inode *inode)* Calculate the journal credits for a chunk of data modification. * * This is called from DIO, fallocate or whoever calling -* ext4_get_blocks_wrap() to map/allocate a chunk of contigous disk blocks. +* ext4_get_blocks() to map/allocate a chunk of contigous disk blocks. * * journal buffers for data blocks are not included here, as DIO * and fallocate do no need to journal data buffers.
Signature · 1 line
1.6.3.rc4.1.g3e14.dirty
Theodore Ts'o
maintainerPATCH 4/6 ext4: Define a new set of flags for ext4_get_blocks()
The functions ext4_get_blocks(), ext4_ext_get_blocks(), and ext4_ind_get_blocks() used an ad-hoc set of integer variables used as boolean flags passed in as arguments. Use a single flags parameter and a setandard set of bitfield flags instead. This saves space on the call stack, and it also makes the code a bit more understandable.
--- fs/ext4/dir.c | 2 +- fs/ext4/ext4.h | 22 +++++++++++++++------- fs/ext4/extents.c | 22 +++++++++++----------- fs/ext4/inode.c | 44 +++++++++++++++++++++++--------------------- 4 files changed, 50 insertions(+), 40 deletions(-)
fs/ext4/dir.c +1 -1
@@ -131,7 +131,7 @@ static int ext4_readdir(struct file *filp,struct buffer_head *bh =NULL ; map_bh.b_state =0 ; - err =ext4_get_blocks (NULL , inode, blk,1 , &map_bh,0 ,0 ,0 ); + err =ext4_get_blocks (NULL , inode, blk,1 , &map_bh,0 );if (err >0 ) {pgoff_t index = map_bh.b_blocknr >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
fs/ext4/ext4.h +15 -7
@@ -314,10 +314,20 @@ struct ext4_new_group_data { };/* -* Following is used by preallocation code to tell get_blocks() that we -* want uninitialzed extents. +* Flags used by ext4_get_blocks() */ -#define EXT4_CREATE_UNINITIALIZED_EXT 2 +/* Allocate any needed blocks and/or convert an unitialized +extent to be an initialized ext4 */ +#define EXT4_GET_BLOCKS_CREATE 1 +/* Request the creation of an unitialized extent */ +#define EXT4_GET_BLOCKS_UNINIT_EXT 2 +#define EXT4_GET_BLOCKS_CREATE_UNINIT_EXT (EXT4_GET_BLOCKS_UNINIT_EXT|\ + EXT4_GET_BLOCKS_CREATE) +/* Update the ext4_inode_info i_disksize field */ +#define EXT4_GET_BLOCKS_EXTEND_DISKSIZE 4 +/* Caller is from the delayed allocation writeout path, +so the filesystem blocks have already been accounted for */ +#define EXT4_GET_BLOCKS_DELALLOC_RESERVE 8/* * ioctl commands
@@ -1616,8 +1626,7 @@ extern int ext4_ext_index_trans_blocks(struct inode *inode, int nrblocks, int chunk);extern int ext4_ext_get_blocks (handle_t *handle,struct inode *inode,ext4_lblk_t iblock,unsigned int max_blocks, -struct buffer_head *bh_result, -int create,int extend_disksize); +struct buffer_head *bh_result,int flags);extern void ext4_ext_truncate (struct inode *);extern void ext4_ext_init (struct super_block *);extern void ext4_ext_release (struct super_block *);
@@ -1625,8 +1634,7 @@ extern long ext4_fallocate(struct inode *inode, int mode, loff_t offset, loff_t len);extern int ext4_get_blocks (handle_t *handle,struct inode *inode,sector_t block,unsigned int max_blocks, -struct buffer_head *bh,int create, -int extend_disksize,int flag); +struct buffer_head *bh,int flags);extern int ext4_fiemap (struct inode *inode,struct fiemap_extent_info *fieinfo,__u64 start,__u64 len);
fs/ext4/extents.c +11 -11
@@ -2777,7 +2777,7 @@ fix_extent_len:int ext4_ext_get_blocks (handle_t *handle,struct inode *inode,ext4_lblk_t iblock,unsigned int max_blocks,struct buffer_head *bh_result, -int create,int extend_disksize) +int flags) {struct ext4_ext_path *path =NULL ;struct ext4_extent_header *eh;
@@ -2796,7 +2796,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode, cache_type =ext4_ext_in_cache (inode, iblock, &newex);if (cache_type) {if (cache_type ==EXT4_EXT_CACHE_GAP ) { -if (!create) { +if ((flags &EXT4_GET_BLOCKS_CREATE ) ==0 ) {/* * block isn't allocated yet and * user doesn't want to allocate it
@@ -2862,9 +2862,9 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode, EXT4_EXT_CACHE_EXTENT); goto out; } -if (create ==EXT4_CREATE_UNINITIALIZED_EXT ) +if (flags &EXT4_GET_BLOCKS_UNINIT_EXT ) goto out; -if (!create) { +if ((flags &EXT4_GET_BLOCKS_CREATE ) ==0 ) {if (allocated > max_blocks) allocated = max_blocks;/*
@@ -2896,7 +2896,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,* requested block isn't allocated yet; * we couldn't try to create block if create flag is zero */ -if (!create) { +if ((flags &EXT4_GET_BLOCKS_CREATE ) ==0 ) {/* * put just found gap into cache to speed up * subsequent requests
@@ -2925,10 +2925,10 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,* EXT_UNINIT_MAX_LEN. */ if (max_blocks >EXT_INIT_MAX_LEN && - create !=EXT4_CREATE_UNINITIALIZED_EXT ) + !(flags &EXT4_GET_BLOCKS_UNINIT_EXT )) max_blocks =EXT_INIT_MAX_LEN ;else if (max_blocks >EXT_UNINIT_MAX_LEN && - create ==EXT4_CREATE_UNINITIALIZED_EXT ) + (flags &EXT4_GET_BLOCKS_UNINIT_EXT )) max_blocks =EXT_UNINIT_MAX_LEN ;/* Check if we can really insert (iblock)::(iblock+max_blocks) extent */
@@ -2959,7 +2959,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,/* try to insert new extent into found leaf and return */ ext4_ext_store_pblock (&newex, newblock); newex.ee_len =cpu_to_le16 (ar.len); -if (create ==EXT4_CREATE_UNINITIALIZED_EXT )/* Mark uninitialized */ +if (flags &EXT4_GET_BLOCKS_UNINIT_EXT )/* Mark uninitialized */ ext4_ext_mark_uninitialized (&newex); err =ext4_ext_insert_extent (handle, inode, path, &newex);if (err) {
@@ -2976,7 +2976,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode, newblock =ext_pblock (&newex); allocated =ext4_ext_get_actual_len (&newex); outnew: -if (extend_disksize) { +if (flags &EXT4_GET_BLOCKS_EXTEND_DISKSIZE ) { disksize = ((loff_t ) iblock + ar.len) << inode->i_blkbits;if (disksize >i_size_read (inode)) disksize =i_size_read (inode);
@@ -2987,7 +2987,7 @@ outnew:set_buffer_new (bh_result);/* Cache only when it is _not_ an uninitialized extent */ -if (create !=EXT4_CREATE_UNINITIALIZED_EXT ) +if ((flags &EXT4_GET_BLOCKS_UNINIT_EXT ) ==0 )ext4_ext_put_in_cache (inode, iblock, allocated, newblock,EXT4_EXT_CACHE_EXTENT ); out:
@@ -3146,7 +3146,7 @@ retry: map_bh.b_state =0 ; ret =ext4_get_blocks (handle, inode, block, max_blocks, &map_bh, -EXT4_CREATE_UNINITIALIZED_EXT ,0 ,0 ); +EXT4_GET_BLOCKS_CREATE_UNINIT_EXT );if (ret <=0 ) {#ifdef EXT4FS_DEBUG WARN_ON (ret <=0 );
fs/ext4/inode.c +23 -21
149 lines not on this page · raw message
Signature · 1 line
1.6.3.rc4.1.g3e14.dirty
Theodore Ts'o
maintainerPATCH 5/6 ext4: Add documentation to the ext4_*get_block* functions
This adds more docmentation to various internal functions in fs/ext4/inode.c, most notably ext4_ind_get_blocks(), ext4_da_get_block_write(), ext4_da_get_block_prep(), ext4_normal_get_block_write().
In addition, the static function ext4_normal_get_block_write() has been renamed noalloc_get_block_write(), since it is used in many places far beyond ext4_normal_writepage().
Plenty of warnings have been added to the noalloc_get_block_write() function, since the way it is used is amazingly fragile.
--- fs/ext4/inode.c | 73 ++++++++++++++++++++++++++++++++++++------------------- 1 files changed, 48 insertions(+), 25 deletions(-)
fs/ext4/inode.c +48 -25
@@ -892,6 +892,10 @@ err_out: }/* +* The ext4_ind_get_blocks() function handles non-extents inodes +* (i.e., using the traditional indirect/double-indirect i_blocks +* scheme) for ext4_get_blocks(). +* * Allocation strategy is simple: if we have to allocate something, we will * have to go the whole way to leaf. So let's do it before attaching anything * to tree, set linkage between the newborn blocks, write them if sync is
@@ -909,10 +913,11 @@ err_out:* return = 0, if plain lookup failed. * return < 0, error case. * -* -* Need to be called with -* down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block -* (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem) +* The ext4_ind_get_blocks() function should be called with +* down_write(&EXT4_I(inode)->i_data_sem) if allocating filesystem +* blocks (i.e., flags has EXT4_GET_BLOCKS_CREATE set) or +* down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system +* blocks. */ static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode, ext4_lblk_t iblock, unsigned int maxblocks,
@@ -1994,6 +1999,12 @@ static void ext4_print_free_blocks(struct inode *inode)return ; } +/* +* This function is used by mpage_da_map_blocks(). We separate it out +* as a separate function just to make life easier, and because +* mpage_da_map_blocks() used to be a generic function that took a +* get_block_t. +*/ static int ext4_da_get_block_write (struct inode *inode,sector_t iblock,struct buffer_head *bh_result) {
@@ -2025,8 +2036,8 @@ static int ext4_da_get_block_write(struct inode *inode, sector_t iblock,/* * Update on-disk size along with block allocation we don't -* use 'extend_disksize' as size may change within already -* allocated block -bzzz +* use EXT4_GET_BLOCKS_EXTEND_DISKSIZE as size may change +* within already allocated block -bzzz */ disksize = ((loff_t ) iblock + ret) << inode->i_blkbits;if (disksize >i_size_read (inode))
@@ -2318,8 +2329,9 @@ static int __mpage_da_writepage(struct page *page, }/* -* this is a special callback for ->write_begin() only -* it's intention is to return mapped block or reserve space +* This is a special get_blocks_t callback which is used by +* ext4_da_write_begin(). It will either return mapped block or +* reserve space for a single block. * * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set. * We also have b_blocknr = -1 and b_bdev initialized properly
@@ -2327,7 +2339,6 @@ static int __mpage_da_writepage(struct page *page,* For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set. * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev * initialized properly. -* */ static int ext4_da_get_block_prep (struct inode *inode,sector_t iblock,struct buffer_head *bh_result,int create)
@@ -2380,7 +2391,23 @@ static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,return ret; } -static int ext4_normal_get_block_write (struct inode *inode,sector_t iblock, +/* +* This function is used as a standard get_block_t calback function +* when there is no desire to allocate any blocks. It is used as a +* callback function for block_prepare_write(), nobh_writepage(), and +* block_write_full_page(). These functions should only try to map a +* single block at a time. +* +* Since this function doesn't do block allocations even if the caller +* requests it by passing in create=1, it is critically important that +* any caller checks to make sure that any buffer heads are returned +* by this function are either all already mapped or marked for +* delayed allocation before calling nobh_writepage() or +* block_write_full_page(). Otherwise, b_blocknr could be left +* unitialized, and the page write functions will be taken by +* surprise. +*/ +static int noalloc_get_block_write (struct inode *inode,sector_t iblock,struct buffer_head *bh_result,int create) {int ret =0 ;
@@ -2453,7 +2480,7 @@ static int ext4_da_writepage(struct page *page,* do block allocation here. */ ret =block_prepare_write (page,0 ,PAGE_CACHE_SIZE , - ext4_normal_get_block_write); + noalloc_get_block_write);if (!ret) { page_bufs =page_buffers (page);/* check whether all are mapped and non delay */
@@ -2478,11 +2505,10 @@ static int ext4_da_writepage(struct page *page, }if (test_opt (inode->i_sb,NOBH ) &&ext4_should_writeback_data (inode)) - ret =nobh_writepage (page, ext4_normal_get_block_write, wbc); + ret =nobh_writepage (page, noalloc_get_block_write, wbc);else - ret =block_write_full_page (page, - ext4_normal_get_block_write, - wbc); + ret =block_write_full_page (page, noalloc_get_block_write, + wbc);return ret; }
@@ -2794,7 +2820,7 @@ retry: *pagep = page; ret =block_write_begin (file, mapping, pos, len, flags, pagep, fsdata, - ext4_da_get_block_prep); + ext4_da_get_block_prep);if (ret <0 ) {unlock_page (page);ext4_journal_stop (handle);
@@ -3102,12 +3128,10 @@ static int __ext4_normal_writepage(struct page *page,struct inode *inode = page->mapping->host;if (test_opt (inode->i_sb,NOBH )) -return nobh_writepage (page, - ext4_normal_get_block_write, wbc); +return nobh_writepage (page, noalloc_get_block_write, wbc);else -return block_write_full_page (page, - ext4_normal_get_block_write, - wbc); +return block_write_full_page (page, noalloc_get_block_write, + wbc); } static int ext4_normal_writepage(struct page *page,
@@ -3159,7 +3183,7 @@ static int __ext4_journalled_writepage(struct page *page,int err; ret =block_prepare_write (page,0 ,PAGE_CACHE_SIZE , - ext4_normal_get_block_write); + noalloc_get_block_write);if (ret !=0 ) goto out_unlock;
@@ -3244,9 +3268,8 @@ static int ext4_journalled_writepage(struct page *page,* really know unless we go poke around in the buffer_heads. * But block_write_full_page will do the right thing. */ -return block_write_full_page (page, - ext4_normal_get_block_write, - wbc); +return block_write_full_page (page, noalloc_get_block_write, + wbc); } no_write:redirty_page_for_writepage (wbc, page);
Signature · 1 line
1.6.3.rc4.1.g3e14.dirty
Theodore Ts'o
maintainerPATCH 6/6 ext4: Add BUG_ON debugging checks to noalloc_get_block_write()
Enforce that noalloc_get_block_write() is only called to map one block at a time, and that it always is successful in finding a mapping for given an inode's logical block block number if it is called with create == 1.
--- fs/ext4/inode.c | 3 +++ 1 files changed, 3 insertions(+), 0 deletions(-)
fs/ext4/inode.c +3 -0
@@ -2413,11 +2413,14 @@ static int noalloc_get_block_write(struct inode *inode, sector_t iblock,int ret =0 ;unsigned max_blocks = bh_result->b_size >> inode->i_blkbits; +BUG_ON (bh_result->b_size != inode->i_sb->s_blocksize); +/* * we don't want to do block allocation in writepage * so call get_block_wrap with create = 0 */ ret =ext4_get_blocks (NULL , inode, iblock, max_blocks, bh_result,0 ); +BUG_ON (create && ret ==0 );if (ret >0 ) { bh_result->b_size = (ret << inode->i_blkbits); ret =0 ;
Signature · 1 line
1.6.3.rc4.1.g3e14.dirty