From: Eric Sandeen Subject: Re: [PATCH] placate checkpatch.pl to some degree for mballoc.c Date: Fri, 31 Aug 2007 21:38:46 -0500 Message-ID: <46D8D0B6.40608@redhat.com> References: <46D887F2.1040502@redhat.com> <20070831225854.GS5377@schatzie.adilger.int> Mime-Version: 1.0 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Cc: ext4 development To: Andreas Dilger Return-path: Received: from mx1.redhat.com ([66.187.233.31]:36783 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751291AbXIACix (ORCPT ); Fri, 31 Aug 2007 22:38:53 -0400 In-Reply-To: <20070831225854.GS5377@schatzie.adilger.int> Sender: linux-ext4-owner@vger.kernel.org List-Id: linux-ext4.vger.kernel.org Andreas Dilger wrote: > On Aug 31, 2007 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. :) >> > > I'm happy with the changes, since I've adopted the kernel CodingStyle > as my own, but not everyone at CFS has. > > >> One of the comments in the series file in git says checkpatch doesn't like >> mballoc, so, here you go, if it's helpful. Applies to the bottom of the >> patch stack - should some of these mballoc patches get rolled together by >> now? >> >> -Eric >> >> Make checkpatch happier with mballoc.c >> >> Signed-off-by: Eric Sandeen >> > > You can add my "Signed-off-by: Andreas Dilger " > > >> @@ -829,7 +845,8 @@ ext4_mb_mark_free_simple(struct super_bl >> - mb_clear_bit(first >> min, buddy + sbi->s_mb_offsets[min]); >> + mb_clear_bit(first >> min, >> + buddy + sbi->s_mb_offsets[min]); >> > > Hmm, shouldn't "buddy" be aligned on the '(' from the previous line? > Maybe this is better... honestly some of those lines were kind of hard to break nicely... and CodingStyle (shouldn't that be coding_style?) ;) says "placed substantially to the right" - but I'm easy. Many of the already-broken lines are on tab boundaries; others are not. If we really want to, I'm sure there's more cosmetic fluff to be done but this at least should get it in the ballpark. thanks, -Eric Signed-off-by: Eric Sandeen 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; @@ -643,6 +645,7 @@ void mb_free_blocks_double(struct inode void mb_mark_used_double(struct ext4_buddy *e3b, int first, int count) { int i; + if (unlikely(e3b->bd_info->bb_bitmap == NULL)) return; BUG_ON(!ext4_is_group_locked(e3b->bd_sb, e3b->bd_group)); @@ -671,9 +674,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 +684,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 +696,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 +731,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 +747,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 +793,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 +818,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 +846,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 +860,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 +903,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 +943,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 +1014,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 +1038,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 +1189,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 +1275,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 +1308,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 +1331,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 +1556,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 +1582,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 +1642,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 +1685,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 +1724,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 +1754,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 +1770,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) - return 1; - break; - case 2: - if (free >= 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 3: + break; + case 1: + if ((free / fragments) >= ac->ac_g_ex.fe_len) return 1; - default: - BUG(); + break; + case 2: + if (free >= ac->ac_g_ex.fe_len) + return 1; + break; + case 3: + return 1; + default: + BUG(); } return 0; @@ -1746,7 +1796,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 +1963,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 +2044,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 +2151,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 +2230,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 +2303,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 +2350,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 +2364,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 +2415,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 +2452,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 +2473,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 +2540,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 +2571,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 +2610,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 +2680,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 +2698,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 +2789,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 +2797,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 +2888,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 +2948,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 +2993,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 +3049,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 +3127,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 +3188,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 +3309,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 +3324,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 +3336,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 +3422,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 +3572,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 +3613,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 +3669,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 +3697,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 +3796,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 +3827,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 +3869,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 +3895,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 +3905,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 +3955,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 +4044,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 +4069,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 +4084,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 +4100,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 +4258,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 +4270,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 +4298,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 - "