Re: Patch queue update

Mingming Cao
2008-01-24T19:50:03Z

On Thu, 2008-01-24 at 20:20 +0530, Aneesh Kumar K.V wrote:
> I have updated patches based on the review feedback from Andrew.
>
> I have tested this on
> 128(64p) ppc64 sles
> 4(2p) ppc64 debian
> 4(2p) x86_64 ubuntu-gutsy
>
> Updated patches are at
> http://www.radian.org/~kvaneesh/ext4/jan-24-2008/
> http://www.radian.org/~kvaneesh/ext4/jan-24-2008/patches.tar
>

Thanks, updated ext4 patch queue with your changes. And fixed the
checkpatch warnings with mballoc-core.patch.

Mingming

> Diff for reference
>
> diff --git a/Documentation/filesystems/ext4.txt b/Documentation/filesystems/ext4.txt
> index 4f329af..ec7d349 100644
> --- a/Documentation/filesystems/ext4.txt
> +++ b/Documentation/filesystems/ext4.txt
> @@ -89,6 +89,8 @@ When mounting an ext4 filesystem, the following option are accepted:
> extents ext4 will use extents to address file data. The
> file system will no longer be mountable by ext3.
>
> +noextents ext4 will not use extents for new files created.
> +
> journal_checksum Enable checksumming of the journal transactions.
> This will allow the recovery code in e2fsck and the
> kernel to detect corruption in the kernel. It is a
> @@ -206,6 +208,10 @@ nobh (a) cache disk block mapping information
> "nobh" option tries to avoid associating buffer
> heads (supported only for "writeback" mode).
>
> +mballoc (*) Use the mutliblock allocator for block allocation
> +nomballoc disabled multiblock allocator for block allocation.
> +stripe=n filesystem blocks per stripe for a RAID configuration.
> +
>
> Data Mode
> ---------
> diff --git a/Documentation/filesystems/proc.txt b/Documentation/filesystems/proc.txt
> index dec9945..4413a2d 100644
> --- a/Documentation/filesystems/proc.txt
> +++ b/Documentation/filesystems/proc.txt
> @@ -857,6 +857,45 @@ CPUs.
> The "procs_blocked" line gives the number of processes currently blocked,
> waiting for I/O to complete.
>
> +1.9 Ext4 file system parameters
> +------------------------------
> +Ext4 file system have one directory per partition under /proc/fs/ext4/
> +# ls /proc/fs/ext4/hdc/
> +group_prealloc max_to_scan mb_groups mb_history min_to_scan order2_req
> +stats stream_req
> +
> +mb_groups:
> +This file gives the details of mutiblock allocator buddy cache of free blocks
> +
> +mb_history:
> +Multiblock allocation history.
> +
> +stats:
> +This file indicate whether the multiblock allocator should start collecting
> +statistics. The statistics are shown during unmount
> +
> +group_prealloc:
> +The multiblock allocator normalize the block allocation request to
> +group_prealloc filesystem blocks if we don't have strip value set.
> +The stripe value can be specified at mount time or during mke2fs.
> +
> +max_to_scan:
> +How long multiblock allocator can look for a best extent (in found extents)
> +
> +min_to_scan:
> +How long multiblock allocator must look for a best extent
> +
> +order2_req:
> +Multiblock allocator use 2^N search using buddies only for requests greater
> +than or equal to order2_req. The request size is specfied in file system
> +blocks. A value of 2 indicate only if the requests are greater than or equal
> +to 4 blocks.
> +
> +stream_req:
> +Files smaller than stream_req are served by the stream allocator, whose
> +purpose is to pack requests as close each to other as possible to
> +produce smooth I/O traffic. Avalue of 16 indicate that file smaller than 16
> +filesystem block size will use group based preallocation.
>
> ------------------------------------------------------------------------------
> Summary
> diff --git a/fs/buffer.c b/fs/buffer.c
> index 982cf1a..921eeec 100644
> --- a/fs/buffer.c
> +++ b/fs/buffer.c
> @@ -3232,19 +3232,21 @@ int bh_uptodate_or_lock(struct buffer_head *bh)
> return 1;
> }
> EXPORT_SYMBOL(bh_uptodate_or_lock);
> +
> /**
> * bh_submit_read: Submit a locked buffer for reading
> * @bh: struct buffer_head
> *
> - * Returns a negative error
> + * Returns zero on success and -EIO on error.
> */
> int bh_submit_read(struct buffer_head *bh)
> {
> - if (!buffer_locked(bh))
> - lock_buffer(bh);
> + BUG_ON(!buffer_locked(bh));
>
> - if (buffer_uptodate(bh))
> + if (buffer_uptodate(bh)) {
> + unlock_buffer(bh);
> return 0;
> + }
>
> get_bh(bh);
> bh->b_end_io = end_buffer_read_sync;
> @@ -3255,6 +3257,7 @@ int bh_submit_read(struct buffer_head *bh)
> return -EIO;
> }
> EXPORT_SYMBOL(bh_submit_read);
> +
> void __init buffer_init(void)
> {
> int nrpages;
> diff --git a/fs/ext4/defrag.c b/fs/ext4/defrag.c
> index 4ef3dc0..0d76c74 100644
> --- a/fs/ext4/defrag.c
> +++ b/fs/ext4/defrag.c
> @@ -30,14 +30,6 @@ ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
> return block;
> }
>
> -/* Will go away */
> -static void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
> -{
> - ex->ee_start_lo = cpu_to_le32((unsigned long) (pb & 0xffffffff));
> - ex->ee_start_hi =
> - cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);
> -}
> -
> /*
> * this structure is used to gather extents from the tree via ioctl
> */
> diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
> index cbda084..c2caf97 100644
> --- a/fs/ext4/extents.c
> +++ b/fs/ext4/extents.c
> @@ -75,7 +75,7 @@ static ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
> * stores a large physical block number into an extent struct,
> * breaking it into parts
> */
> -static void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
> +void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
> {
> ex->ee_start_lo = cpu_to_le32((unsigned long) (pb & 0xffffffff));
> ex->ee_start_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);
> diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
> index e348ceb..bec699a 100644
> --- a/fs/ext4/mballoc.c
> +++ b/fs/ext4/mballoc.c
> @@ -435,7 +435,7 @@ struct ext4_free_metadata {
>
> struct ext4_group_info {
> unsigned long bb_state;
> - unsigned long bb_tid;
> + unsigned long bb_tid;
> struct ext4_free_metadata *bb_md_cur;
> unsigned short bb_first_free;
> unsigned short bb_free;
> @@ -489,7 +489,7 @@ struct ext4_free_extent {
> */
> struct ext4_locality_group {
> /* for allocator */
> - struct semaphore lg_sem; /* to serialize allocates */
> + struct mutex lg_mutex; /* to serialize allocates */
> struct list_head lg_prealloc_list;/* list of preallocations */
> spinlock_t lg_prealloc_lock;
> };
> @@ -564,7 +564,10 @@ struct ext4_buddy {
> #define EXT4_MB_BUDDY(e4b) ((e4b)->bd_buddy)
>
> #ifndef EXT4_MB_HISTORY
> -#define ext4_mb_store_history(ac)
> +static inline void ext4_mb_store_history(struct ext4_allocation_context *ac)
> +{
> + return;
> +}
> #else
> static void ext4_mb_store_history(struct ext4_allocation_context *ac);
> #endif
> @@ -642,6 +645,10 @@ static ext4_fsblk_t ext4_grp_offs_to_block(struct super_block *sb,
>
> static inline int mb_test_bit(int bit, void *addr)
> {
> + /*
> + * ext4_test_bit on architecture like powerpc
> + * needs unsigned long aligned address
> + */
> mb_correct_addr_and_bit(bit, addr);
> return ext4_test_bit(bit, addr);
> }
> @@ -670,7 +677,7 @@ static inline void mb_clear_bit_atomic(spinlock_t *lock, int bit, void *addr)
> ext4_clear_bit_atomic(lock, bit, addr);
> }
>
> -static inline void *mb_find_buddy(struct ext4_buddy *e4b, int order, int *max)
> +static void *mb_find_buddy(struct ext4_buddy *e4b, int order, int *max)
> {
> char *bb;
>
> @@ -753,9 +760,20 @@ static void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)
> }
>
> #else
> -#define mb_free_blocks_double(a, b, c, d)
> -#define mb_mark_used_double(a, b, c)
> -#define mb_cmp_bitmaps(a, b)
> +static inline void mb_free_blocks_double(struct inode *inode,
> + struct ext4_buddy *e4b, int first, int count)
> +{
> + return;
> +}
> +static inline void mb_mark_used_double(struct ext4_buddy *e4b,
> + int first, int count)
> +{
> + return;
> +}
> +static inline void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)
> +{
> + return;
> +}
> #endif
>
> #ifdef AGGRESSIVE_CHECK
> @@ -878,26 +896,6 @@ static int __mb_check_buddy(struct ext4_buddy *e4b, char *file,
> #define mb_check_buddy(e4b)
> #endif
>
> -/* find most significant bit */
> -static int fmsb(unsigned short word)
> -{
> - int order;
> -
> - if (word > 255) {
> - order = 7;
> - word >>= 8;
> - } else {
> - order = -1;
> - }
> -
> - do {
> - order++;
> - word >>= 1;
> - } while (word != 0);
> -
> - return order;
> -}
> -
> /* FIXME!! need more doc */
> static void ext4_mb_mark_free_simple(struct super_block *sb,
> void *buddy, unsigned first, int len,
> @@ -918,7 +916,7 @@ static void ext4_mb_mark_free_simple(struct super_block *sb,
> max = ffs(first | border) - 1;
>
> /* find how many blocks of power 2 we need to mark */
> - min = fmsb(len);
> + min = fls(len) - 1;
>
> if (max < min)
> min = max;
> @@ -1030,10 +1028,9 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
> if (groups_per_page > 1) {
> err = -ENOMEM;
> i = sizeof(struct buffer_head *) * groups_per_page;
> - bh = kmalloc(i, GFP_NOFS);
> + bh = kzalloc(i, GFP_NOFS);
> if (bh == NULL)
> goto out;
> - memset(bh, 0, i);
> } else
> bh = &bhs;
>
> @@ -1056,15 +1053,9 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
> if (bh[i] == NULL)
> goto out;
>
> - if (buffer_uptodate(bh[i]))
> + if (bh_uptodate_or_lock(bh[i]))
> continue;
>
> - lock_buffer(bh[i]);
> - if (buffer_uptodate(bh[i])) {
> - unlock_buffer(bh[i]);
> - continue;
> - }
> -
> if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
> ext4_init_block_bitmap(sb, bh[i],
> first_group + i, desc);
> @@ -1303,7 +1294,7 @@ static void mb_set_bits(spinlock_t *lock, void *bm, int cur, int len)
> len = cur + len;
> while (cur < len) {
> if ((cur & 31) == 0 && (len - cur) >= 32) {
> - /* fast path: clear whole word at once */
> + /* fast path: set whole word at once */
> addr = bm + (cur >> 3);
> *addr = 0xffffffff;
> cur += 32;
> @@ -2681,7 +2672,7 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery)
> for (i = 0; i < NR_CPUS; i++) {
> struct ext4_locality_group *lg;
> lg = &sbi->s_locality_groups[i];
> - sema_init(&lg->lg_sem, 1);
> + mutex_init(&lg->lg_mutex);
> INIT_LIST_HEAD(&lg->lg_prealloc_list);
> spin_lock_init(&lg->lg_prealloc_lock);
> }
> @@ -2693,6 +2684,7 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery)
> return 0;
> }
>
> +/* need to called with ext4 group lock (ext4_lock_group) */
> static void ext4_mb_cleanup_pa(struct ext4_group_info *grp)
> {
> struct ext4_prealloc_space *pa;
> @@ -2701,7 +2693,7 @@ static void ext4_mb_cleanup_pa(struct ext4_group_info *grp)
>
> list_for_each_safe(cur, tmp, &grp->bb_prealloc_list) {
> pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
> - list_del_rcu(&pa->pa_group_list);
> + list_del(&pa->pa_group_list);
> count++;
> kfree(pa);
> }
> @@ -2735,7 +2727,9 @@ int ext4_mb_release(struct super_block *sb)
> #ifdef DOUBLE_CHECK
> kfree(grinfo->bb_bitmap);
> #endif
> + ext4_lock_group(sb,i);
> ext4_mb_cleanup_pa(grinfo);
> + ext4_lock_group(sb,i);
> kfree(grinfo);
> }
> num_meta_group_infos = (sbi->s_groups_count +
> @@ -3447,6 +3441,7 @@ static int ext4_mb_use_preallocated(struct ext4_allocation_context *ac)
> /*
> * the function goes through all preallocation in this group and marks them
> * used in in-core bitmap. buddy must be generated from this bitmap
> + * Need to be called with ext4 group lock (ext4_lock_group)
> */
> static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
> ext4_group_t group)
> @@ -3468,7 +3463,7 @@ static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
> * allocation in buddy when concurrent ext4_mb_put_pa()
> * is dropping preallocation
> */
> - list_for_each_rcu(cur, &grp->bb_prealloc_list) {
> + list_for_each(cur, &grp->bb_prealloc_list) {
> pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
> spin_lock(&pa->pa_lock);
> ext4_get_group_no_and_offset(sb, pa->pa_pstart,
> @@ -3492,7 +3487,6 @@ static void ext4_mb_pa_callback(struct rcu_head *head)
> pa = container_of(head, struct ext4_prealloc_space, u.pa_rcu);
> kmem_cache_free(ext4_pspace_cachep, pa);
> }
> -#define mb_call_rcu(__pa) call_rcu(&(__pa)->u.pa_rcu, ext4_mb_pa_callback)
>
> /*
> * drops a reference to preallocated space descriptor
> @@ -3534,14 +3528,14 @@ static void ext4_mb_put_pa(struct ext4_allocation_context *ac,
> * against that pair
> */
> ext4_lock_group(sb, grp);
> - list_del_rcu(&pa->pa_group_list);
> + list_del(&pa->pa_group_list);
> ext4_unlock_group(sb, grp);
>
> spin_lock(pa->pa_obj_lock);
> list_del_rcu(&pa->pa_inode_list);
> spin_unlock(pa->pa_obj_lock);
>
> - mb_call_rcu(pa);
> + call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
> }
>
> /*
> @@ -3621,7 +3615,7 @@ static int ext4_mb_new_inode_pa(struct ext4_allocation_context *ac)
> pa->pa_inode = ac->ac_inode;
>
> ext4_lock_group(sb, ac->ac_b_ex.fe_group);
> - list_add_rcu(&pa->pa_group_list, &grp->bb_prealloc_list);
> + list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
> ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
>
> spin_lock(pa->pa_obj_lock);
> @@ -3678,7 +3672,7 @@ static int ext4_mb_new_group_pa(struct ext4_allocation_context *ac)
> pa->pa_inode = NULL;
>
> ext4_lock_group(sb, ac->ac_b_ex.fe_group);
> - list_add_rcu(&pa->pa_group_list, &grp->bb_prealloc_list);
> + list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
> ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
>
> spin_lock(pa->pa_obj_lock);
> @@ -3859,7 +3853,7 @@ repeat:
>
> spin_unlock(&pa->pa_lock);
>
> - list_del_rcu(&pa->pa_group_list);
> + list_del(&pa->pa_group_list);
> list_add(&pa->u.pa_tmp_list, &list);
> }
>
> @@ -3895,7 +3889,7 @@ repeat:
> ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa);
>
> list_del(&pa->u.pa_tmp_list);
> - mb_call_rcu(pa);
> + call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
> }
>
> out:
> @@ -3948,9 +3942,8 @@ repeat:
> spin_unlock(&pa->pa_lock);
> spin_unlock(&ei->i_prealloc_lock);
> printk(KERN_ERR "uh-oh! used pa while discarding\n");
> - dump_stack();
> - current->state = TASK_UNINTERRUPTIBLE;
> - schedule_timeout(HZ);
> + WARN_ON(1);
> + schedule_timeout_uninterruptible(HZ);
> goto repeat;
>
> }
> @@ -3978,8 +3971,7 @@ repeat:
> * add a flag to force wait only in case
> * of ->clear_inode(), but not in case of
> * regular truncate */
> - current->state = TASK_UNINTERRUPTIBLE;
> - schedule_timeout(HZ);
> + schedule_timeout_uninterruptible(HZ);
> goto repeat;
> }
> spin_unlock(&ei->i_prealloc_lock);
> @@ -3999,7 +3991,7 @@ repeat:
> }
>
> ext4_lock_group(sb, group);
> - list_del_rcu(&pa->pa_group_list);
> + list_del(&pa->pa_group_list);
> ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa);
> ext4_unlock_group(sb, group);
>
> @@ -4007,7 +3999,7 @@ repeat:
> brelse(bitmap_bh);
>
> list_del(&pa->u.pa_tmp_list);
> - mb_call_rcu(pa);
> + call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
> }
> }
>
> @@ -4057,7 +4049,8 @@ static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
> struct ext4_prealloc_space *pa;
> ext4_grpblk_t start;
> struct list_head *cur;
> - list_for_each_rcu(cur, &grp->bb_prealloc_list) {
> + ext4_lock_group(sb, i);
> + list_for_each(cur, &grp->bb_prealloc_list) {
> pa = list_entry(cur, struct ext4_prealloc_space,
> pa_group_list);
> spin_lock(&pa->pa_lock);
> @@ -4067,6 +4060,7 @@ static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
> printk(KERN_ERR "PA:%lu:%d:%u \n", i,
> start, pa->pa_len);
> }
> + ext4_lock_group(sb, i);
>
> if (grp->bb_free == 0)
> continue;
> @@ -4076,7 +4070,10 @@ static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
> printk(KERN_ERR "\n");
> }
> #else
> -#define ext4_mb_show_ac(x)
> +static inline void ext4_mb_show_ac(struct ext4_allocation_context *ac)
> +{
> + return;
> +}
> #endif
>
> /*
> @@ -4097,8 +4094,7 @@ static void ext4_mb_group_or_file(struct ext4_allocation_context *ac)
>
> size = ac->ac_o_ex.fe_logical + ac->ac_o_ex.fe_len;
> isize = i_size_read(ac->ac_inode) >> bsbits;
> - if (size < isize)
> - size = isize;
> + size = max(size, isize);
>
> /* don't use group allocation for large files */
> if (size >= sbi->s_mb_stream_request)
> @@ -4108,6 +4104,11 @@ static void ext4_mb_group_or_file(struct ext4_allocation_context *ac)
> return;
>
> BUG_ON(ac->ac_lg != NULL);
> + /*
> + * locality group prealloc space are per cpu. The reason for having
> + * per cpu locality group is to reduce the contention between block
> + * request from multiple CPUs.
> + */
> ac->ac_lg = &sbi->s_locality_groups[get_cpu()];
> put_cpu();
>
> @@ -4115,7 +4116,7 @@ static void ext4_mb_group_or_file(struct ext4_allocation_context *ac)
> ac->ac_flags |= EXT4_MB_HINT_GROUP_ALLOC;
>
> /* serialize all allocations in the group */
> - down(&ac->ac_lg->lg_sem);
> + mutex_lock(&ac->ac_lg->lg_mutex);
> }
>
> static int ext4_mb_initialize_context(struct ext4_allocation_context *ac,
> @@ -4209,7 +4210,7 @@ static int ext4_mb_release_context(struct ext4_allocation_context *ac)
> if (ac->ac_buddy_page)
> page_cache_release(ac->ac_buddy_page);
> if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC)
> - up(&ac->ac_lg->lg_sem);
> + mutex_unlock(&ac->ac_lg->lg_mutex);
> ext4_mb_collect_stats(ac);
> return 0;
> }
> diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
> index 6b40f55..5e9c7e8 100644
> --- a/fs/ext4/migrate.c
> +++ b/fs/ext4/migrate.c
> @@ -16,19 +16,15 @@
> #include <linux/ext4_jbd2.h>
> #include <linux/ext4_fs_extents.h>
>
> +/*
> + * The contiguous blocks details which can be
> + * represented by a single extent
> + */
> struct list_blocks_struct {
> ext4_lblk_t first_block, last_block;
> ext4_fsblk_t first_pblock, last_pblock;
> };
>
> -/* will go away */
> -static void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
> -{
> - ex->ee_start_lo = cpu_to_le32((unsigned long) (pb & 0xffffffff));
> - ex->ee_start_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1)
> - & 0xffff);
> -}
> -
> static int finish_range(handle_t *handle, struct inode *inode,
> struct list_blocks_struct *lb)
>
> @@ -61,15 +57,11 @@ static int finish_range(handle_t *handle, struct inode *inode,
> /*
> * Make sure the credit we accumalated is not really high
> */
> -
> if (needed && handle->h_buffer_credits >= EXT4_RESERVE_TRANS_BLOCKS) {
> -
> retval = ext4_journal_restart(handle, needed);
> if (retval)
> goto err_out;
> -
> }
> -
> if (needed) {
> retval = ext4_journal_extend(handle, needed);
> if (retval != 0) {
> @@ -81,19 +73,17 @@ static int finish_range(handle_t *handle, struct inode *inode,
> goto err_out;
> }
> }
> -
> retval = ext4_ext_insert_extent(handle, inode, path, &newext);
> -
> err_out:
> lb->first_pblock = 0;
> return retval;
> }
> +
> static int update_extent_range(handle_t *handle, struct inode *inode,
> ext4_fsblk_t pblock, ext4_lblk_t blk_num,
> struct list_blocks_struct *lb)
> {
> int retval;
> -
> /*
> * See if we can add on to the existing range (if it exists)
> */
> @@ -112,7 +102,6 @@ static int update_extent_range(handle_t *handle, struct inode *inode,
> lb->first_block = lb->last_block = blk_num;
>
> return retval;
> -
> }
>
> static int update_ind_extent_range(handle_t *handle, struct inode *inode,
> @@ -136,7 +125,6 @@ static int update_ind_extent_range(handle_t *handle, struct inode *inode,
> return -EIO;
>
> i_data = (__le32 *)bh->b_data;
> -
> for (i = 0; i < max_entries; i++, blk_count++) {
> if (i_data[i]) {
> retval = update_extent_range(handle, inode,
> @@ -153,6 +141,7 @@ static int update_ind_extent_range(handle_t *handle, struct inode *inode,
> return retval;
>
> }
> +
> static int update_dind_extent_range(handle_t *handle, struct inode *inode,
> ext4_fsblk_t pblock, ext4_lblk_t *blk_nump,
> struct list_blocks_struct *lb)
> @@ -168,13 +157,11 @@ static int update_dind_extent_range(handle_t *handle, struct inode *inode,
> *blk_nump += max_entries * max_entries;
> return 0;
> }
> -
> bh = sb_bread(inode->i_sb, pblock);
> if (!bh)
> return -EIO;
>
> i_data = (__le32 *)bh->b_data;
> -
> for (i = 0; i < max_entries; i++) {
> if (i_data[i]) {
> retval = update_ind_extent_range(handle, inode,
> @@ -194,6 +181,7 @@ static int update_dind_extent_range(handle_t *handle, struct inode *inode,
> return retval;
>
> }
> +
> static int update_tind_extent_range(handle_t *handle, struct inode *inode,
> ext4_fsblk_t pblock, ext4_lblk_t *blk_nump,
> struct list_blocks_struct *lb)
> @@ -209,13 +197,11 @@ static int update_tind_extent_range(handle_t *handle, struct inode *inode,
> *blk_nump += max_entries * max_entries * max_entries;
> return 0;
> }
> -
> bh = sb_bread(inode->i_sb, pblock);
> if (!bh)
> return -EIO;
>
> i_data = (__le32 *)bh->b_data;
> -
> for (i = 0; i < max_entries; i++) {
> if (i_data[i]) {
> retval = update_dind_extent_range(handle, inode,
> @@ -228,7 +214,6 @@ static int update_tind_extent_range(handle_t *handle, struct inode *inode,
> blk_count += max_entries * max_entries;
> }
> }
> -
> /* Update the file block number */
> *blk_nump = blk_count;
> brelse(bh);
> @@ -236,7 +221,6 @@ static int update_tind_extent_range(handle_t *handle, struct inode *inode,
>
> }
>
> -
> static int free_dind_blocks(handle_t *handle,
> struct inode *inode, __le32 i_data)
> {
> @@ -258,10 +242,7 @@ static int free_dind_blocks(handle_t *handle,
> }
> brelse(bh);
> ext4_free_blocks(handle, inode, le32_to_cpu(i_data), 1, 1);
> -
> return 0;
> -
> -
> }
>
> static int free_tind_blocks(handle_t *handle,
> @@ -277,7 +258,6 @@ static int free_tind_blocks(handle_t *handle,
> return -EIO;
>
> tmp_idata = (__le32 *)bh->b_data;
> -
> for (i = 0; i < max_entries; i++) {
> if (tmp_idata[i]) {
> retval = free_dind_blocks(handle,
> @@ -290,10 +270,7 @@ static int free_tind_blocks(handle_t *handle,
> }
> brelse(bh);
> ext4_free_blocks(handle, inode, le32_to_cpu(i_data), 1, 1);
> -
> return 0;
> -
> -
> }
>
> static int free_ind_block(handle_t *handle, struct inode *inode)
> @@ -302,10 +279,8 @@ static int free_ind_block(handle_t *handle, struct inode *inode)
> struct ext4_inode_info *ei = EXT4_I(inode);
>
> if (ei->i_data[EXT4_IND_BLOCK]) {
> -
> ext4_free_blocks(handle, inode,
> le32_to_cpu(ei->i_data[EXT4_IND_BLOCK]), 1, 1);
> -
> }
>
> if (ei->i_data[EXT4_DIND_BLOCK]) {
> @@ -321,17 +296,15 @@ static int free_ind_block(handle_t *handle, struct inode *inode)
> if (retval)
> return retval;
> }
> -
> -
> return 0;
> }
> +
> static int ext4_ext_swap_inode_data(handle_t *handle, struct inode *inode,
> struct inode *tmp_inode, int retval)
> {
> struct ext4_inode_info *ei = EXT4_I(inode);
> struct ext4_inode_info *tmp_ei = EXT4_I(tmp_inode);
>
> -
> retval = free_ind_block(handle, inode);
> if (retval)
> goto err_out;
> @@ -368,9 +341,7 @@ static int ext4_ext_swap_inode_data(handle_t *handle, struct inode *inode,
> spin_unlock(&inode->i_lock);
>
> ext4_mark_inode_dirty(handle, inode);
> -
> err_out:
> -
> return retval;
> }
>
> @@ -392,7 +363,6 @@ static int free_ext_idx(handle_t *handle, struct inode *inode,
> struct buffer_head *bh;
> struct ext4_extent_header *eh;
>
> -
> block = idx_pblock(ix);
> bh = sb_bread(inode->i_sb, block);
> if (!bh)
> @@ -400,24 +370,19 @@ static int free_ext_idx(handle_t *handle, struct inode *inode,
>
> eh = (struct ext4_extent_header *)bh->b_data;
> if (eh->eh_depth == 0) {
> -
> brelse(bh);
> ext4_free_blocks(handle, inode, block, 1, 1);
> -
> } else {
> -
> ix = EXT_FIRST_INDEX(eh);
> for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ix++) {
> retval = free_ext_idx(handle, inode, ix);
> if (retval)
> return retval;
> }
> -
> }
> -
> return retval;
> -
> }
> +
> /*
> * Free the extent meta data blocks only
> */
> @@ -439,10 +404,10 @@ static int free_ext_block(handle_t *handle, struct inode *inode)
> if (retval)
> return retval;
> }
> -
> return retval;
>
> }
> +
> int ext4_ext_migrate(struct inode *inode, struct file *filp,
> unsigned int cmd, unsigned long arg)
> {
> @@ -455,7 +420,6 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> struct list_blocks_struct lb;
> unsigned long max_entries;
>
> -
> if (!test_opt(inode->i_sb, EXTENTS)) {
> /*
> * if mounted with noextents
> @@ -468,8 +432,6 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> return -EINVAL;
>
> down_write(&EXT4_I(inode)->i_data_sem);
> -
> -
> handle = ext4_journal_start(inode,
> EXT4_DATA_TRANS_BLOCKS(inode->i_sb) +
> EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
> @@ -479,18 +441,15 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> retval = PTR_ERR(handle);
> goto err_out;
> }
> -
> tmp_inode = ext4_new_inode(handle,
> inode->i_sb->s_root->d_inode,
> S_IFREG);
> -
> if (IS_ERR(tmp_inode)) {
> retval = -ENOMEM;
> ext4_journal_stop(handle);
> tmp_inode = NULL;
> goto err_out;
> }
> -
> i_size_write(tmp_inode, i_size_read(inode));
> /*
> * We don't want the inode to be reclaimed
> @@ -523,7 +482,6 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> */
> handle = ext4_journal_start(inode, 1);
> for (i = 0; i < EXT4_NDIR_BLOCKS; i++, blk_count++) {
> -
> if (i_data[i]) {
> retval = update_extent_range(handle, tmp_inode,
> le32_to_cpu(i_data[i]),
> @@ -532,7 +490,6 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> goto err_out;
> }
> }
> -
> if (i_data[EXT4_IND_BLOCK]) {
> retval = update_ind_extent_range(handle, tmp_inode,
> le32_to_cpu(i_data[EXT4_IND_BLOCK]),
> @@ -542,7 +499,6 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> } else {
> blk_count += max_entries;
> }
> -
> if (i_data[EXT4_DIND_BLOCK]) {
> retval = update_dind_extent_range(handle, tmp_inode,
> le32_to_cpu(i_data[EXT4_DIND_BLOCK]),
> @@ -552,8 +508,6 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> } else {
> blk_count += max_entries * max_entries;
> }
> -
> -
> if (i_data[EXT4_TIND_BLOCK]) {
> retval = update_tind_extent_range(handle, tmp_inode,
> le32_to_cpu(i_data[EXT4_TIND_BLOCK]),
> @@ -561,12 +515,10 @@ int ext4_ext_migrate(struct inode *inode, struct file *filp,
> if (retval)
> goto err_out;
> }
> -
> /*
> * Build the last extent
> */
> retval = finish_range(handle, tmp_inode, &lb);
> -
> err_out:
> /*
> * We are either freeing extent information or indirect
> @@ -577,14 +529,12 @@ err_out:
> *
> * FIXME!! we may be touching bitmaps in different block groups.
> */
> -
> if (ext4_journal_extend(handle,
> 4 + 2*EXT4_QUOTA_TRANS_BLOCKS(inode->i_sb)) != 0) {
>
> ext4_journal_restart(handle,
> 4 + 2*EXT4_QUOTA_TRANS_BLOCKS(inode->i_sb));
> }
> -
> if (retval) {
> /*
> * Failure case delete the extent information with the
> diff --git a/fs/ext4/super.c b/fs/ext4/super.c
> index cf2f612..416d919 100644
> --- a/fs/ext4/super.c
> +++ b/fs/ext4/super.c
> @@ -1841,13 +1841,14 @@ static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
> unsigned long stripe_width =
> le32_to_cpu(sbi->s_es->s_raid_stripe_width);
>
> - if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group) {
> + if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
> return sbi->s_stripe;
> - } else if (stripe_width <= sbi->s_blocks_per_group) {
> +
> + if (stripe_width <= sbi->s_blocks_per_group)
> return stripe_width;
> - } else if (stride <= sbi->s_blocks_per_group) {
> +
> + if (stride <= sbi->s_blocks_per_group)
> return stride;
> - }
>
> return 0;
> }
> diff --git a/include/linux/ext4_fs_extents.h b/include/linux/ext4_fs_extents.h
> index be4ada4..8bece0e 100644
> --- a/include/linux/ext4_fs_extents.h
> +++ b/include/linux/ext4_fs_extents.h
> @@ -225,6 +225,7 @@ static inline int ext4_ext_get_actual_len(struct ext4_extent *ext)
> (le16_to_cpu(ext->ee_len) - EXT_INIT_MAX_LEN));
> }
>
> +extern void ext4_ext_store_pblock(struct ext4_extent *, ext4_fsblk_t);
> extern int ext4_extent_tree_init(handle_t *, struct inode *);
> extern int ext4_ext_calc_credits_for_insert(struct inode *, struct ext4_ext_path *);
> extern int ext4_ext_try_to_merge(struct inode *inode,
> -
> To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html