On Fri, 2007-08-31 at 16:28 -0500, Eric Sandeen wrote: > Here's a patch for mballoc.c, to make checkpatch happier with it. > > I was about as pedantic as I could be, except for a few things it > complained about which I just could not agree with. :) > > One of the comments in the series file in git says checkpatch doesn't like > mballoc, so, here you go, if it's helpful. Very helpful, thanks! > Applies to the bottom of the > patch stack - should some of these mballoc patches get rolled together by > now? > Okay, will do. There are still a issue with mballoc, it doesn't handle big endian when generating free extents map from on-disk bitmaps. Thus cause failure compile on ppc64. ppc64 needs to implement generic_find_next_le_bit. Andreas pointed a patch already in cfs bug report, https://bugzilla.lustre.org/show_bug.cgi?id=10634, the patch for this is in the last attachment. > -Eric > > ---------------- > > Make checkpatch happier with mballoc.c > > Signed-off-by: Eric Sandeen <sandeen@xxxxxxxxxx> > > Index: ext4.git/fs/ext4/mballoc.c > =================================================================== > --- ext4.git.orig/fs/ext4/mballoc.c > +++ ext4.git/fs/ext4/mballoc.c > @@ -247,9 +247,9 @@ > */ > #define MB_DEBUG__ > #ifdef MB_DEBUG > -#define mb_debug(fmt,a...) printk(fmt, ##a) > +#define mb_debug(fmt, a...) printk(fmt, ##a) > #else > -#define mb_debug(fmt,a...) > +#define mb_debug(fmt, a...) > > #endif > > /* > @@ -303,7 +303,7 @@ > */ > #define MB_DEFAULT_STRIPE 256 > > -static struct kmem_cache *ext4_pspace_cachep = NULL; > +static struct kmem_cache *ext4_pspace_cachep; > > #ifdef EXT4_BB_MAX_BLOCKS > #undef EXT4_BB_MAX_BLOCKS > @@ -353,7 +353,7 @@ struct ext4_prealloc_space { > unsigned short pa_len; /* len of preallocated chunk */ > unsigned short pa_free; /* how many blocks are free */ > unsigned short pa_linear; /* consumed in one direction > - * strictly, for group prealloc */ > + * strictly, for grp prealloc */ > spinlock_t *pa_obj_lock; > struct inode *pa_inode; /* hack, for history only */ > }; > @@ -456,8 +456,8 @@ static void ext4_mb_store_history(struct > > static struct proc_dir_entry *proc_root_ext4; > > -int ext4_create (struct inode *, struct dentry *, int, struct nameidata *); > -struct buffer_head * read_block_bitmap(struct super_block *, unsigned int); > +int ext4_create(struct inode *, struct dentry *, int, struct nameidata *); > +struct buffer_head *read_block_bitmap(struct super_block *, unsigned int); > ext4_fsblk_t ext4_new_blocks_old(handle_t *handle, struct inode *inode, > ext4_fsblk_t goal, unsigned long *count, int *errp); > void ext4_mb_release_blocks(struct super_block *, int); > @@ -465,11 +465,13 @@ void ext4_mb_poll_new_transaction(struct > void ext4_mb_free_committed_blocks(struct super_block *); > void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap, int group); > void ext4_mb_free_consumed_preallocations(struct ext4_allocation_context *ac); > -void ext4_mb_return_to_preallocation(struct inode *inode, struct ext4_buddy *e3b, > - sector_t block, int count); > +void ext4_mb_return_to_preallocation(struct inode *inode, > + struct ext4_buddy *e3b, sector_t block, > + int count); > void ext4_mb_show_ac(struct ext4_allocation_context *ac); > void ext4_mb_check_with_pa(struct ext4_buddy *e3b, int first, int count); > -void ext4_mb_put_pa(struct ext4_allocation_context *, struct super_block *, struct ext4_prealloc_space *pa); > +void ext4_mb_put_pa(struct ext4_allocation_context *, struct super_block *, > + struct ext4_prealloc_space *pa); > int ext4_mb_init_per_dev_proc(struct super_block *sb); > int ext4_mb_destroy_per_dev_proc(struct super_block *sb); > > @@ -507,13 +509,13 @@ unsigned long ext4_grp_offs_to_block(str > } > > #if BITS_PER_LONG == 64 > -#define mb_correct_addr_and_bit(bit,addr) \ > +#define mb_correct_addr_and_bit(bit, addr) \ > { \ > bit += ((unsigned long) addr & 7UL) << 3; \ > addr = (void *) ((unsigned long) addr & ~7UL); \ > } > #elif BITS_PER_LONG == 32 > -#define mb_correct_addr_and_bit(bit,addr) \ > +#define mb_correct_addr_and_bit(bit, addr) \ > { \ > bit += ((unsigned long) addr & 3UL) << 3; \ > addr = (void *) ((unsigned long) addr & ~3UL); \ > @@ -524,31 +526,31 @@ unsigned long ext4_grp_offs_to_block(str > > static inline int mb_test_bit(int bit, void *addr) > { > - mb_correct_addr_and_bit(bit,addr); > + mb_correct_addr_and_bit(bit, addr); > return ext2_test_bit(bit, addr); > } > > static inline void mb_set_bit(int bit, void *addr) > { > - mb_correct_addr_and_bit(bit,addr); > + mb_correct_addr_and_bit(bit, addr); > ext2_set_bit(bit, addr); > } > > static inline void mb_set_bit_atomic(int bit, void *addr) > { > - mb_correct_addr_and_bit(bit,addr); > + mb_correct_addr_and_bit(bit, addr); > ext2_set_bit_atomic(NULL, bit, addr); > } > > static inline void mb_clear_bit(int bit, void *addr) > { > - mb_correct_addr_and_bit(bit,addr); > + mb_correct_addr_and_bit(bit, addr); > ext2_clear_bit(bit, addr); > } > > static inline void mb_clear_bit_atomic(int bit, void *addr) > { > - mb_correct_addr_and_bit(bit,addr); > + mb_correct_addr_and_bit(bit, addr); > ext2_clear_bit_atomic(NULL, bit, addr); > } > > @@ -615,7 +617,7 @@ static inline void *mb_find_buddy(struct > > #ifdef DOUBLE_CHECK > void mb_free_blocks_double(struct inode *inode, struct ext4_buddy *e3b, > - int first, int count) > + int first, int count) > { > int i; > struct super_block *sb = e3b->bd_sb; > @@ -671,9 +673,9 @@ void mb_cmp_bitmaps(struct ext4_buddy *e > } > > #else > -#define mb_free_blocks_double(a,b,c,d) > -#define mb_mark_used_double(a,b,c) > -#define mb_cmp_bitmaps(a,b) > +#define mb_free_blocks_double(a, b, c, d) > +#define mb_mark_used_double(a, b, c) > +#define mb_cmp_bitmaps(a, b) > #endif > > #ifdef AGGRESSIVE_CHECK > @@ -681,7 +683,7 @@ void mb_cmp_bitmaps(struct ext4_buddy *e > #define MB_CHECK_ASSERT(assert) \ > do { \ > if (!(assert)) { \ > - printk (KERN_EMERG \ > + printk(KERN_EMERG \ > "Assertion failure in %s() at %s:%d: \"%s\"\n", \ > function, file, line, # assert); \ > BUG(); \ > @@ -693,11 +695,18 @@ static int __mb_check_buddy(struct ext4_ > { > struct super_block *sb = e3b->bd_sb; > int order = e3b->bd_blkbits + 1; > - int max, max2, i, j, k, count; > + int max; > + int max2; > + int i; > + int j; > + int k; > + int count; > struct ext4_group_info *grp; > - int fragments = 0, fstart; > + int fragments = 0; > + int fstart; > struct list_head *cur; > - void *buddy, *buddy2; > + void *buddy; > + void *buddy2; > > if (!test_opt(sb, MBALLOC)) > return 0; > @@ -721,10 +730,13 @@ static int __mb_check_buddy(struct ext4_ > > if (mb_test_bit(i, buddy)) { > /* only single bit in buddy2 may be 1 */ > - if (!mb_test_bit(i << 1, buddy2)) > - MB_CHECK_ASSERT(mb_test_bit((i<<1)+1, buddy2)); > - else if (!mb_test_bit((i << 1) + 1, buddy2)) > - MB_CHECK_ASSERT(mb_test_bit(i << 1, buddy2)); > + if (!mb_test_bit(i << 1, buddy2)) { > + MB_CHECK_ASSERT( > + mb_test_bit((i<<1)+1, buddy2)); > + } else if (!mb_test_bit((i << 1) + 1, buddy2)) { > + MB_CHECK_ASSERT( > + mb_test_bit(i << 1, buddy2)); > + } > continue; > } > > @@ -734,7 +746,8 @@ static int __mb_check_buddy(struct ext4_ > > for (j = 0; j < (1 << order); j++) { > k = (i * (1 << order)) + j; > - MB_CHECK_ASSERT(!mb_test_bit(k, EXT4_MB_BITMAP(e3b))); > + MB_CHECK_ASSERT( > + !mb_test_bit(k, EXT4_MB_BITMAP(e3b))); > } > count++; > } > @@ -779,13 +792,13 @@ static int __mb_check_buddy(struct ext4_ > return 0; > } > #undef MB_CHECK_ASSERT > -#define mb_check_buddy(e3b) __mb_check_buddy(e3b,__FILE__,__FUNCTION__,__LINE__) > +#define mb_check_buddy(e3b) __mb_check_buddy(e3b, __FILE__, __FUNCTION__, __LINE__) > #else > #define mb_check_buddy(e3b) > #endif > > /* find most significant bit */ > -static int inline fmsb(unsigned short word) > +static inline int fmsb(unsigned short word) > { > int order; > > @@ -804,12 +817,15 @@ static int inline fmsb(unsigned short wo > return order; > } > > -static void inline > +static inline void > ext4_mb_mark_free_simple(struct super_block *sb, void *buddy, unsigned first, > int len, struct ext4_group_info *grp) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > - unsigned short min, max, chunk, border; > + unsigned short min; > + unsigned short max; > + unsigned short chunk; > + unsigned short border; > > BUG_ON(len >= EXT4_BLOCKS_PER_GROUP(sb)); > > @@ -829,7 +845,8 @@ ext4_mb_mark_free_simple(struct super_bl > /* mark multiblock chunks only */ > grp->bb_counters[min]++; > if (min > 0) > - mb_clear_bit(first >> min, buddy + sbi->s_mb_offsets[min]); > + mb_clear_bit(first >> min, > + buddy + sbi->s_mb_offsets[min]); > > len -= chunk; > first += chunk; > @@ -842,8 +859,11 @@ ext4_mb_generate_buddy(struct super_bloc > { > struct ext4_group_info *grp = EXT4_GROUP_INFO(sb, group); > unsigned short max = EXT4_BLOCKS_PER_GROUP(sb); > - unsigned short i = 0, first, len; > - unsigned free = 0, fragments = 0; > + unsigned short i = 0; > + unsigned short first; > + unsigned short len; > + unsigned free = 0; > + unsigned fragments = 0; > unsigned long long period = get_cycles(); > > /* initialize buddy from bitmap which is aggregation > @@ -882,13 +902,19 @@ ext4_mb_generate_buddy(struct super_bloc > > static int ext4_mb_init_cache(struct page *page, char *incore) > { > - int blocksize, blocks_per_page, groups_per_page; > - int err = 0, i, first_group, first_block; > + int blocksize; > + int blocks_per_page; > + int groups_per_page; > + int err = 0; > + int i; > + int first_group; > + int first_block; > struct super_block *sb; > struct buffer_head *bhs; > struct buffer_head **bh; > struct inode *inode; > - char *data, *bitmap; > + char *data; > + char *bitmap; > > mb_debug("init page %lu\n", page->index); > > @@ -916,7 +942,7 @@ static int ext4_mb_init_cache(struct pag > > /* read all groups the page covers into the cache */ > for (i = 0; i < groups_per_page; i++) { > - struct ext4_group_desc * desc; > + struct ext4_group_desc *desc; > > if (first_group + i >= EXT4_SB(sb)->s_groups_count) > break; > @@ -987,7 +1013,7 @@ static int ext4_mb_init_cache(struct pag > ext4_lock_group(sb, group); > memcpy(data, bitmap, blocksize); > > - /* mark all preallocated blocks used in in-core bitmap */ > + /* mark all preallocated blks used in in-core bitmap */ > ext4_mb_generate_from_pa(sb, data, group); > ext4_unlock_group(sb, group); > > @@ -1011,7 +1037,10 @@ static int ext4_mb_load_buddy(struct sup > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > struct inode *inode = sbi->s_buddy_cache; > - int blocks_per_page, block, pnum, poff; > + int blocks_per_page; > + int block; > + int pnum; > + int poff; > struct page *page; > > mb_debug("load group %u\n", group); > @@ -1159,8 +1188,11 @@ static inline void mb_set_bits(void *bm, > static int mb_free_blocks(struct inode *inode, struct ext4_buddy *e3b, > int first, int count) > { > - int block = 0, max = 0, order; > - void *buddy, *buddy2; > + int block = 0; > + int max = 0; > + int order; > + void *buddy; > + void *buddy2; > struct super_block *sb = e3b->bd_sb; > > BUG_ON(first + count > (sb->s_blocksize << 3)); > @@ -1242,7 +1274,9 @@ static int mb_free_blocks(struct inode * > static int mb_find_extent(struct ext4_buddy *e3b, int order, int block, > int needed, struct ext4_free_extent *ex) > { > - int next = block, max, ord; > + int next = block; > + int max; > + int ord; > void *buddy; > > BUG_ON(!ext4_is_group_locked(e3b->bd_sb, e3b->bd_group)); > @@ -1273,7 +1307,8 @@ static int mb_find_extent(struct ext4_bu > ex->fe_len -= next; > ex->fe_start += next; > > - while (needed > ex->fe_len && (buddy = mb_find_buddy(e3b, order, &max))) { > + while (needed > ex->fe_len && > + (buddy = mb_find_buddy(e3b, order, &max))) { > > if (block + 1 >= max) > break; > @@ -1295,7 +1330,10 @@ static int mb_find_extent(struct ext4_bu > > static int mb_mark_used(struct ext4_buddy *e3b, struct ext4_free_extent *ex) > { > - int ord, mlen = 0, max = 0, cur; > + int ord; > + int mlen = 0; > + int max = 0; > + int cur; > int start = ex->fe_start; > int len = ex->fe_len; > unsigned ret = 0; > @@ -1517,7 +1555,9 @@ static int ext4_mb_try_best_found(struct > struct ext4_buddy *e3b) > { > struct ext4_free_extent ex = ac->ac_b_ex; > - int group = ex.fe_group, max, err; > + int group = ex.fe_group; > + int max; > + int err; > > BUG_ON(ex.fe_len <= 0); > err = ext4_mb_load_buddy(ac->ac_sb, group, e3b); > @@ -1541,7 +1581,9 @@ static int ext4_mb_try_best_found(struct > static int ext4_mb_find_by_goal(struct ext4_allocation_context *ac, > struct ext4_buddy *e3b) > { > - int group = ac->ac_g_ex.fe_group, max, err; > + int group = ac->ac_g_ex.fe_group; > + int max; > + int err; > struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb); > struct ext4_super_block *es = sbi->s_es; > struct ext4_free_extent ex; > @@ -1599,7 +1641,9 @@ static void ext4_mb_simple_scan_group(st > struct super_block *sb = ac->ac_sb; > struct ext4_group_info *grp = e3b->bd_info; > void *buddy; > - int i, k, max; > + int i; > + int k; > + int max; > > BUG_ON(ac->ac_2order <= 0); > for (i = ac->ac_2order; i <= sb->s_blocksize_bits + 1; i++) { > @@ -1640,7 +1684,8 @@ static void ext4_mb_complex_scan_group(s > struct super_block *sb = ac->ac_sb; > void *bitmap = EXT4_MB_BITMAP(e3b); > struct ext4_free_extent ex; > - int i, free; > + int i; > + int free; > > free = e3b->bd_info->bb_free; > BUG_ON(free <= 0); > @@ -1678,7 +1723,8 @@ static void ext4_mb_scan_aligned(struct > struct ext4_sb_info *sbi = EXT4_SB(sb); > void *bitmap = EXT4_MB_BITMAP(e3b); > struct ext4_free_extent ex; > - unsigned long i, max; > + unsigned long i; > + unsigned long max; > > BUG_ON(sbi->s_stripe == 0); > > @@ -1707,7 +1753,10 @@ static int ext4_mb_good_group(struct ext > int group, int cr) > { > struct ext4_group_info *grp = EXT4_GROUP_INFO(ac->ac_sb, group); > - unsigned free, fragments, i, bits; > + unsigned free; > + unsigned fragments; > + unsigned i; > + unsigned bits; > > BUG_ON(cr < 0 || cr >= 4); > BUG_ON(EXT4_MB_GRP_NEED_INIT(grp)); > @@ -1720,25 +1769,25 @@ static int ext4_mb_good_group(struct ext > return 0; > > switch (cr) { > - case 0: > - BUG_ON(ac->ac_2order == 0); > - bits = ac->ac_sb->s_blocksize_bits + 1; > - for (i = ac->ac_2order; i <= bits; i++) > - if (grp->bb_counters[i] > 0) > - return 1; > - break; > - case 1: > - if ((free / fragments) >= ac->ac_g_ex.fe_len) > + case 0: > + BUG_ON(ac->ac_2order == 0); > + bits = ac->ac_sb->s_blocksize_bits + 1; > + for (i = ac->ac_2order; i <= bits; i++) > + if (grp->bb_counters[i] > 0) > return 1; > - break; > - case 2: > - if (free >= ac->ac_g_ex.fe_len) > - return 1; > - break; > - case 3: > + break; > + case 1: > + if ((free / fragments) >= ac->ac_g_ex.fe_len) > + return 1; > + break; > + case 2: > + if (free >= ac->ac_g_ex.fe_len) > return 1; > - default: > - BUG(); > + break; > + case 3: > + return 1; > + default: > + BUG(); > } > > return 0; > @@ -1746,7 +1795,10 @@ static int ext4_mb_good_group(struct ext > > int ext4_mb_regular_allocator(struct ext4_allocation_context *ac) > { > - int group, i, cr, err = 0; > + int group; > + int i; > + int cr; > + int err = 0; > struct ext4_sb_info *sbi; > struct super_block *sb; > struct ext4_buddy e3b; > @@ -1910,7 +1962,8 @@ static void *ext4_mb_seq_history_start(s > return hs; > } > > -static void *ext4_mb_seq_history_next(struct seq_file *seq, void *v, loff_t *pos) > +static void *ext4_mb_seq_history_next(struct seq_file *seq, void *v, > + loff_t *pos) > { > struct ext4_mb_proc_session *s = seq->private; > struct ext4_mb_history *hs = v; > @@ -1990,7 +2043,8 @@ static int ext4_mb_seq_history_open(stru > struct super_block *sb = PDE(inode)->data; > struct ext4_sb_info *sbi = EXT4_SB(sb); > struct ext4_mb_proc_session *s; > - int rc, size; > + int rc; > + int size; > > s = kmalloc(sizeof(*s), GFP_KERNEL); > if (s == NULL) > @@ -2096,7 +2150,8 @@ static int ext4_mb_seq_groups_show(struc > { > struct super_block *sb = seq->private; > long group = (long) v; > - int i, err; > + int i; > + int err; > struct ext4_buddy e3b; > struct sg { > struct ext4_group_info info; > @@ -2174,8 +2229,7 @@ static void ext4_mb_history_release(stru > remove_proc_entry("mb_groups", sbi->s_mb_proc); > remove_proc_entry("mb_history", sbi->s_mb_proc); > > - if (sbi->s_mb_history) > - kfree(sbi->s_mb_history); > + kfree(sbi->s_mb_history); > } > > static void ext4_mb_history_init(struct super_block *sb) > @@ -2248,7 +2302,10 @@ ext4_mb_store_history(struct ext4_alloca > int ext4_mb_init_backend(struct super_block *sb) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > - int i, j, len, metalen; > + int i; > + int j; > + int len; > + int metalen; > int num_meta_group_infos = > (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) >> > EXT4_DESC_PER_BLOCK_BITS(sb); > @@ -2292,7 +2349,7 @@ int ext4_mb_init_backend(struct super_bl > len = sizeof(struct ext4_group_info); > len += sizeof(unsigned short) * (sb->s_blocksize_bits + 2); > for (i = 0; i < sbi->s_groups_count; i++) { > - struct ext4_group_desc * desc; > + struct ext4_group_desc *desc; > > meta_group_info = > sbi->s_group_info[i >> EXT4_DESC_PER_BLOCK_BITS(sb)]; > @@ -2306,7 +2363,8 @@ int ext4_mb_init_backend(struct super_bl > } > desc = ext4_get_group_desc(sb, i, NULL); > if (desc == NULL) { > - printk(KERN_ERR"EXT4-fs: can't read descriptor %u\n",i); > + printk(KERN_ERR > + "EXT4-fs: can't read descriptor %u\n", i); > goto err_freebuddy; > } > memset(meta_group_info[j], 0, len); > @@ -2356,7 +2414,9 @@ err_freesgi: > int ext4_mb_init(struct super_block *sb, int needs_recovery) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > - unsigned i, offset, max; > + unsigned i; > + unsigned offset; > + unsigned max; > > if (!test_opt(sb, MBALLOC)) > return 0; > @@ -2391,7 +2451,8 @@ int ext4_mb_init(struct super_block *sb, > } while (i <= sb->s_blocksize_bits + 1); > > /* init file for buddy data */ > - if ((i = ext4_mb_init_backend(sb))) { > + i = ext4_mb_init_backend(sb); > + if (i) { > clear_opt(sbi->s_mount_opt, MBALLOC); > kfree(sbi->s_mb_offsets); > kfree(sbi->s_mb_maxs); > @@ -2411,7 +2472,8 @@ int ext4_mb_init(struct super_block *sb, > sbi->s_mb_order2_reqs = MB_DEFAULT_ORDER2_REQS; > sbi->s_mb_history_filter = EXT4_MB_HISTORY_DEFAULT; > > - i = sbi->s_mb_prealloc_table_size = 7; > + sbi->s_mb_prealloc_table_size = 7; > + i = sbi->s_mb_prealloc_table_size; > sbi->s_mb_prealloc_table = kmalloc(sizeof(unsigned long) * i, > GFP_NOFS); > if (sbi->s_mb_prealloc_table == NULL) { > @@ -2477,7 +2539,8 @@ void ext4_mb_cleanup_pa(struct ext4_grou > int ext4_mb_release(struct super_block *sb) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > - int i, num_meta_group_infos; > + int i; > + int num_meta_group_infos; > > if (!test_opt(sb, MBALLOC)) > return 0; > @@ -2507,34 +2570,35 @@ int ext4_mb_release(struct super_block * > kfree(sbi->s_group_info[i]); > kfree(sbi->s_group_info); > } > - if (sbi->s_mb_offsets) > - kfree(sbi->s_mb_offsets); > - if (sbi->s_mb_maxs) > - kfree(sbi->s_mb_maxs); > + kfree(sbi->s_mb_offsets); > + kfree(sbi->s_mb_maxs); > if (sbi->s_buddy_cache) > iput(sbi->s_buddy_cache); > if (sbi->s_mb_stats) { > - printk("EXT4-fs: mballoc: %u blocks %u reqs (%u success)\n", > + printk(KERN_INFO > + "EXT4-fs: mballoc: %u blocks %u reqs (%u success)\n", > atomic_read(&sbi->s_bal_allocated), > atomic_read(&sbi->s_bal_reqs), > atomic_read(&sbi->s_bal_success)); > - printk("EXT4-fs: mballoc: %u extents scanned, %u goal hits, " > + printk(KERN_INFO > + "EXT4-fs: mballoc: %u extents scanned, %u goal hits, " > "%u 2^N hits, %u breaks, %u lost\n", > atomic_read(&sbi->s_bal_ex_scanned), > atomic_read(&sbi->s_bal_goals), > atomic_read(&sbi->s_bal_2orders), > atomic_read(&sbi->s_bal_breaks), > atomic_read(&sbi->s_mb_lost_chunks)); > - printk("EXT4-fs: mballoc: %lu generated and it took %Lu\n", > + printk(KERN_INFO > + "EXT4-fs: mballoc: %lu generated and it took %Lu\n", > sbi->s_mb_buddies_generated++, > sbi->s_mb_generation_time); > - printk("EXT4-fs: mballoc: %u preallocated, %u discarded\n", > + printk(KERN_INFO > + "EXT4-fs: mballoc: %u preallocated, %u discarded\n", > atomic_read(&sbi->s_mb_preallocated), > atomic_read(&sbi->s_mb_discarded)); > } > > - if (sbi->s_locality_groups) > - kfree(sbi->s_locality_groups); > + kfree(sbi->s_locality_groups); > > ext4_mb_history_release(sb); > ext4_mb_destroy_per_dev_proc(sb); > @@ -2545,7 +2609,10 @@ int ext4_mb_release(struct super_block * > void ext4_mb_free_committed_blocks(struct super_block *sb) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > - int err, i, count = 0, count2 = 0; > + int err; > + int i; > + int count = 0; > + int count2 = 0; > struct ext4_free_metadata *md; > struct ext4_buddy e3b; > > @@ -2612,7 +2679,9 @@ static int ext4_mb_read_prealloc_table(c > off_t off, int count, int *eof, void *data) > { > struct ext4_sb_info *sbi = data; > - int len = 0, i; > + int len = 0; > + int i; > + > *eof = 1; > if (off != 0) > return 0; > @@ -2628,10 +2697,14 @@ static int ext4_mb_write_prealloc_table( > const char *buf, unsigned long cnt, void *data) > { > struct ext4_sb_info *sbi = data; > - unsigned long value, prev = 0; > - char str[128], *cur, *end; > + unsigned long value; > + unsigned long prev = 0; > + char str[128]; > + char *cur; > + char *end; > unsigned long *new_table; > - int num = 0, i = 0; > + int num = 0; > + int i = 0; > > if (cnt >= sizeof(str)) > return -EINVAL; > @@ -2715,6 +2788,7 @@ MB_PROC_VALUE_READ(group_prealloc); > MB_PROC_VALUE_WRITE(group_prealloc); > > #define MB_PROC_HANDLER(name, var) \ > + do { \ > proc = create_proc_entry(name, mode, sbi->s_mb_proc); \ > if (proc == NULL) { \ > printk(KERN_ERR "EXT4-fs: can't to create %s\n", name); \ > @@ -2722,7 +2796,8 @@ MB_PROC_VALUE_WRITE(group_prealloc); > } \ > proc->data = sbi; \ > proc->read_proc = ext4_mb_read_##var ; \ > - proc->write_proc = ext4_mb_write_##var; > + proc->write_proc = ext4_mb_write_##var; \ > + } while (0) > > int ext4_mb_init_per_dev_proc(struct super_block *sb) > { > @@ -2812,7 +2887,8 @@ void exit_ext4_proc(void) > * Check quota and mark choosed space (ac->ac_b_ex) non-free in bitmaps > * Returns 0 if success or error code > */ > -int ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac, handle_t *handle) > +int ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac, > + handle_t *handle) > { > struct buffer_head *bitmap_bh = NULL; > struct ext4_super_block *es; > @@ -2871,7 +2947,8 @@ int ext4_mb_mark_diskspace_used(struct e > } > } > #endif > - mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start, ac->ac_b_ex.fe_len); > + mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start, > + ac->ac_b_ex.fe_len); > > spin_lock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group)); > gdp->bg_free_blocks_count = > @@ -2915,9 +2992,15 @@ void ext4_mb_normalize_request(struct ex > { > struct ext4_inode_info *ei = EXT4_I(ac->ac_inode); > struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb); > - loff_t start, end, size, orig_size, orig_start, wind; > + loff_t start; > + loff_t end; > + loff_t size; > + loff_t orig_size; > + loff_t orig_start; > + loff_t wind; > struct list_head *cur; > - int bsbits, i; > + int bsbits; > + int i; > > /* do normalize only data requests, metadata requests > do not need preallocation */ > @@ -2965,7 +3048,8 @@ void ext4_mb_normalize_request(struct ex > do_div(start, wind); > start = start * wind; > } > - orig_size = size = wind; > + size = wind; > + orig_size = size; > orig_start = start; > > /* don't cover already allocated blocks in selected range */ > @@ -3042,7 +3126,7 @@ void ext4_mb_normalize_request(struct ex > > if (start + size <= ac->ac_o_ex.fe_logical && > start > ac->ac_o_ex.fe_logical) { > - printk("start %lu, size %lu, fe_logical %lu\n", > + printk(KERN_ERR "start %lu, size %lu, fe_logical %lu\n", > (unsigned long) start, (unsigned long) size, > (unsigned long) ac->ac_o_ex.fe_logical); > } > @@ -3103,7 +3187,8 @@ void ext4_mb_collect_stats(struct ext4_a > void ext4_mb_use_inode_pa(struct ext4_allocation_context *ac, > struct ext4_prealloc_space *pa) > { > - unsigned long start, len; > + unsigned long start; > + unsigned long len; > > /* found preallocated blocks, use them */ > start = pa->pa_pstart + (ac->ac_o_ex.fe_logical - pa->pa_lstart); > @@ -3223,9 +3308,11 @@ void ext4_mb_generate_from_pa(struct sup > struct list_head *cur; > unsigned long groupnr; > ext4_grpblk_t start; > - int preallocated = 0, count = 0, len; > + int preallocated = 0; > + int count = 0; > + int len; > > - /* all form of preallocation discards first load group, > + /* all form of preallocation discards first load group, > * so the only competing code is preallocation use. > * we don't need any locking here > * notice we do NOT ignore preallocations with pa_deleted > @@ -3236,7 +3323,8 @@ void ext4_mb_generate_from_pa(struct sup > list_for_each_rcu(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, &groupnr, &start); > + ext4_get_group_no_and_offset(sb, pa->pa_pstart, > + &groupnr, &start); > len = pa->pa_len; > spin_unlock(&pa->pa_lock); > BUG_ON(groupnr != group); > @@ -3247,7 +3335,7 @@ void ext4_mb_generate_from_pa(struct sup > mb_debug("prellocated %u for group %u\n", preallocated, group); > } > > -#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,5) > +#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 5) > static void ext4_mb_pa_callback(struct rcu_head *head) > { > struct ext4_prealloc_space *pa; > @@ -3333,7 +3421,10 @@ int ext4_mb_new_inode_pa(struct ext4_all > return -ENOMEM; > > if (ac->ac_b_ex.fe_len < ac->ac_g_ex.fe_len) { > - int winl, wins, win, offs; > + int winl; > + int wins; > + int win; > + int offs; > > /* we can't allocate as much as normalizer wants. > * so, found space must get proper lstart > @@ -3480,10 +3571,13 @@ int ext4_mb_release_inode_pa(struct ext4 > struct ext4_allocation_context ac; > struct super_block *sb = e3b->bd_sb; > struct ext4_sb_info *sbi = EXT4_SB(sb); > - unsigned long end, next, group; > + unsigned long end; > + unsigned long next; > + unsigned long group; > ext4_grpblk_t bit; > sector_t start; > - int err = 0, free = 0; > + int err = 0; > + int free = 0; > > BUG_ON(pa->pa_deleted == 0); > ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit); > @@ -3518,11 +3612,11 @@ int ext4_mb_release_inode_pa(struct ext4 > bit = next + 1; > } > if (free != pa->pa_free) { > - printk("pa %p: logic %lu, phys. %lu, len %lu\n", > + printk(KERN_ERR "pa %p: logic %lu, phys. %lu, len %lu\n", > pa, (unsigned long) pa->pa_lstart, > (unsigned long) pa->pa_pstart, > (unsigned long) pa->pa_len); > - printk("free %u, pa_free %u\n", free, pa->pa_free); > + printk(KERN_ERR "free %u, pa_free %u\n", free, pa->pa_free); > } > BUG_ON(free != pa->pa_free); > atomic_add(free, &sbi->s_mb_discarded); > @@ -3574,7 +3668,9 @@ int ext4_mb_discard_group_preallocations > struct ext4_prealloc_space *pa, *tmp; > struct list_head list; > struct ext4_buddy e3b; > - int err, busy, free = 0; > + int err; > + int busy; > + int free = 0; > > mb_debug("discard preallocation for group %lu\n", group); > > @@ -3600,11 +3696,12 @@ int ext4_mb_discard_group_preallocations > repeat: > busy = 0; > ext4_lock_group(sb, group); > - list_for_each_entry_safe (pa, tmp, &grp->bb_prealloc_list, pa_group_list) { > + list_for_each_entry_safe(pa, tmp, > + &grp->bb_prealloc_list, pa_group_list) { > spin_lock(&pa->pa_lock); > if (atomic_read(&pa->pa_count)) { > spin_unlock(&pa->pa_lock); > - printk("uh! busy PA\n"); > + printk(KERN_ERR "uh! busy PA\n"); > dump_stack(); > busy = 1; > continue; > @@ -3698,7 +3795,7 @@ repeat: > * use preallocation while we're discarding it */ > spin_unlock(&pa->pa_lock); > spin_unlock(&ei->i_prealloc_lock); > - printk("uh-oh! used pa while discarding\n"); > + printk(KERN_ERR "uh-oh! used pa while discarding\n"); > dump_stack(); > current->state = TASK_UNINTERRUPTIBLE; > schedule_timeout(HZ); > @@ -3729,7 +3826,7 @@ repeat: > * add a flag to force wait only in case > * of ->clear_inode(), but not in case of > * regular truncate */ > - printk("uh-oh! some one just deleted it\n"); > + printk(KERN_ERR "uh-oh! some one just deleted it\n"); > dump_stack(); > current->state = TASK_UNINTERRUPTIBLE; > schedule_timeout(HZ); > @@ -3771,7 +3868,8 @@ repeat: > * XXX: at the moment, truncate (which is the only way to free blocks) > * discards all preallocations > */ > -void ext4_mb_return_to_preallocation(struct inode *inode, struct ext4_buddy *e3b, > +void ext4_mb_return_to_preallocation(struct inode *inode, > + struct ext4_buddy *e3b, > sector_t block, int count) > { > BUG_ON(!list_empty(&EXT4_I(inode)->i_prealloc_list)); > @@ -3796,7 +3894,7 @@ void ext4_mb_show_ac(struct ext4_allocat > ac->ac_criteria); > printk(KERN_ERR "EXT4-fs: %lu scanned, %d found\n", ac->ac_ex_scanned, > ac->ac_found); > - printk("EXT4-fs: groups: "); > + printk(KERN_ERR "EXT4-fs: groups: "); > for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) { > struct ext4_group_info *grp = EXT4_GROUP_INFO(sb, i); > struct ext4_prealloc_space *pa; > @@ -3806,17 +3904,19 @@ void ext4_mb_show_ac(struct ext4_allocat > 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, NULL, &start); > + ext4_get_group_no_and_offset(sb, pa->pa_pstart, > + NULL, &start); > spin_unlock(&pa->pa_lock); > - printk("PA:%u:%lu:%u ", i, start, pa->pa_len); > + printk(KERN_ERR "PA:%u:%lu:%u ", i, start, pa->pa_len); > } > > if (grp->bb_free == 0) > continue; > - printk("%d: %d/%d ", i, grp->bb_free, grp->bb_fragments); > + printk(KERN_ERR "%d: %d/%d ", > + i, grp->bb_free, grp->bb_fragments); > } > - printk("\n"); > - //dump_stack(); > + printk(KERN_ERR "\n"); > + /* dump_stack(); */ > #endif > } > > @@ -3854,7 +3954,9 @@ int ext4_mb_initialize_context(struct ex > struct super_block *sb = ar->inode->i_sb; > struct ext4_sb_info *sbi = EXT4_SB(sb); > struct ext4_super_block *es = sbi->s_es; > - unsigned long group, len, goal; > + unsigned long group; > + unsigned long len; > + unsigned long goal; > ext4_grpblk_t block; > > /* we can't allocate > group size */ > @@ -3941,7 +4043,9 @@ int ext4_mb_release_context(struct ext4_ > > int ext4_mb_discard_preallocations(struct super_block *sb, int needed) > { > - int i, ret, freed = 0; > + int i; > + int ret; > + int freed = 0; > > for (i = 0; i < EXT4_SB(sb)->s_groups_count && needed > 0; i++) { > ret = ext4_mb_discard_group_preallocations(sb, i, needed); > @@ -3964,7 +4068,8 @@ unsigned long ext4_mb_new_blocks(handle_ > struct ext4_sb_info *sbi; > struct super_block *sb; > unsigned long block = 0; > - int freed, inquota; > + int freed; > + int inquota; > > sb = ar->inode->i_sb; > sbi = EXT4_SB(sb); > @@ -3978,7 +4083,7 @@ unsigned long ext4_mb_new_blocks(handle_ > ar->len = 1; > #endif > block = ext4_new_blocks_old(handle, ar->inode, ar->goal, > - &(ar->len), errp); > + &(ar->len), errp); > return block; > } > > @@ -3994,7 +4099,8 @@ unsigned long ext4_mb_new_blocks(handle_ > > ext4_mb_poll_new_transaction(sb, handle); > > - if ((*errp = ext4_mb_initialize_context(&ac, ar))) { > + *errp = ext4_mb_initialize_context(&ac, ar); > + if (*errp) { > ar->len = 0; > goto out; > } > @@ -4151,7 +4257,8 @@ void ext4_mb_free_blocks(handle_t *handl > unsigned long block_group; > struct ext4_sb_info *sbi; > struct ext4_buddy e3b; > - int err = 0, ret; > + int err = 0; > + int ret; > > *freed = 0; > > @@ -4162,7 +4269,7 @@ void ext4_mb_free_blocks(handle_t *handl > if (block < le32_to_cpu(es->s_first_data_block) || > block + count < block || > block + count > le32_to_cpu(es->s_blocks_count)) { > - ext4_error (sb, __FUNCTION__, > + ext4_error(sb, __FUNCTION__, > "Freeing blocks not in datazone - " > "block = %lu, count = %lu", block, count); > goto error_return; > @@ -4190,15 +4297,15 @@ do_more: > bitmap_bh = read_block_bitmap(sb, block_group); > if (!bitmap_bh) > goto error_return; > - gdp = ext4_get_group_desc (sb, block_group, &gd_bh); > + gdp = ext4_get_group_desc(sb, block_group, &gd_bh); > if (!gdp) > goto error_return; > > - if (in_range (le32_to_cpu(gdp->bg_block_bitmap), block, count) || > - in_range (le32_to_cpu(gdp->bg_inode_bitmap), block, count) || > - in_range (block, le32_to_cpu(gdp->bg_inode_table), > + if (in_range(le32_to_cpu(gdp->bg_block_bitmap), block, count) || > + in_range(le32_to_cpu(gdp->bg_inode_bitmap), block, count) || > + in_range(block, le32_to_cpu(gdp->bg_inode_table), > EXT4_SB(sb)->s_itb_per_group) || > - in_range (block + count - 1, le32_to_cpu(gdp->bg_inode_table), > + in_range(block + count - 1, le32_to_cpu(gdp->bg_inode_table), > EXT4_SB(sb)->s_itb_per_group)) > ext4_error(sb, __FUNCTION__, > "Freeing blocks in system zone - " > > - > To unsubscribe from this list: send the line "unsubscribe linux-ext4" in > the body of a message to majordomo@xxxxxxxxxxxxxxx > More majordomo info at http://vger.kernel.org/majordomo-info.html - To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
