lkml.org 
[lkml]   [2009]   [Jun]   [8]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 30/49] ext4: Rename ext4_get_blocks_wrap() to be ext4_get_blocks()
    Date
    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.

    Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
    ---
    fs/ext4/dir.c | 3 +--
    fs/ext4/ext4.h | 8 ++++----
    fs/ext4/extents.c | 6 +++---
    fs/ext4/inode.c | 35 +++++++++++++++++------------------
    4 files changed, 25 insertions(+), 27 deletions(-)

    diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
    index b647899..052d637 100644
    --- a/fs/ext4/dir.c
    +++ b/fs/ext4/dir.c
    @@ -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);
    diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
    index 89190ae..5dc8368 100644
    --- a/fs/ext4/ext4.h
    +++ b/fs/ext4/ext4.h
    @@ -1617,10 +1617,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);

    diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
    index 4fec6b7..7e7d02d 100644
    --- a/fs/ext4/extents.c
    +++ b/fs/ext4/extents.c
    @@ -3151,9 +3151,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);
    diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
    index f758e80..a9a9b9b 100644
    --- a/fs/ext4/inode.c
    +++ b/fs/ext4/inode.c
    @@ -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;

    @@ -1268,8 +1268,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;
    @@ -1294,10 +1294,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) {
    @@ -2009,8 +2008,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;

    @@ -2067,11 +2066,11 @@ static int mpage_da_map_blocks(struct mpage_da_data *mpd)
    /*
    * We need to make sure the BH_Delay flag is passed down to
    * ext4_da_get_block_write(), since it calls
    - * ext4_get_blocks_wrap() with the EXT4_DELALLOC_RSVED flag.
    - * This flag causes ext4_get_blocks_wrap() to call
    + * ext4_get_blocks() with the EXT4_DELALLOC_RSVED flag.
    + * This flag causes ext4_get_blocks() to call
    * ext4_da_update_reserve_space() if the passed buffer head
    * has the BH_Delay flag set. In the future, once we clean up
    - * the interfaces to ext4_get_blocks_wrap(), we should pass in
    + * the interfaces to ext4_get_blocks(), we should pass in
    * a separate flag which requests that the delayed allocation
    * statistics should be updated, instead of depending on the
    * state information getting passed down via the map_bh's
    @@ -2363,7 +2362,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 */
    /*
    @@ -2407,8 +2406,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;
    @@ -5034,7 +5033,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.
    --
    1.6.3.2.1.gb9f7d.dirty


    \
     
     \ /
      Last update: 2009-06-08 21:39    [W:0.081 / U:60.080 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site