lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  linux-cve-announce  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-Id: <63e631fd75c084fa0f40d41f8f935cab2b46948d.1331856300.git.joe@perches.com>
Date:	Thu, 15 Mar 2012 17:07:37 -0700
From:	Joe Perches <joe@...ches.com>
To:	"Theodore Ts'o" <tytso@....edu>,
	Andreas Dilger <adilger.kernel@...ger.ca>
Cc:	linux-ext4@...r.kernel.org, linux-kernel@...r.kernel.org
Subject: [PATCH 9/9] ext4: Rename ext4_warning to ext4_warn and ext4_error to ext4_err

Make the logging macros more like the current kernel logging style.

Neaten the macro definitions.
Align arguments and 80 column wrapping.

Signed-off-by: Joe Perches <joe@...ches.com>
---
 fs/ext4/balloc.c   |   22 ++++----
 fs/ext4/ext4.h     |    8 ++--
 fs/ext4/ialloc.c   |   32 ++++++------
 fs/ext4/indirect.c |    6 +-
 fs/ext4/inode.c    |   20 ++++----
 fs/ext4/mballoc.c  |   44 +++++++++---------
 fs/ext4/mmp.c      |   30 ++++++------
 fs/ext4/namei.c    |   66 +++++++++++++-------------
 fs/ext4/page-io.c  |   12 ++--
 fs/ext4/resize.c   |  133 +++++++++++++++++++++++++--------------------------
 fs/ext4/super.c    |   20 ++++----
 11 files changed, 194 insertions(+), 199 deletions(-)

diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 82f468f..c77446c 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -171,7 +171,7 @@ void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
 	/* If checksum is bad mark all blocks used to prevent allocation
 	 * essentially implementing a per-group read-only flag. */
 	if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
-		ext4_error(sb, "Checksum bad for group %u", block_group);
+		ext4_err(sb, "Checksum bad for group %u", block_group);
 		ext4_free_group_clusters_set(sb, gdp, 0);
 		ext4_free_inodes_set(sb, gdp, 0);
 		ext4_itable_unused_set(sb, gdp, 0);
@@ -254,8 +254,8 @@ struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 
 	if (block_group >= ngroups) {
-		ext4_error(sb, "block_group >= groups_count - block_group = %u, groups_count = %u",
-			   block_group, ngroups);
+		ext4_err(sb, "block_group >= groups_count - block_group = %u, groups_count = %u",
+			 block_group, ngroups);
 
 		return NULL;
 	}
@@ -263,8 +263,8 @@ struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
 	group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
 	offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
 	if (!sbi->s_group_desc[group_desc]) {
-		ext4_error(sb, "Group descriptor not loaded - block_group = %u, group_desc = %u, desc = %u",
-			   block_group, group_desc, offset);
+		ext4_err(sb, "Group descriptor not loaded - block_group = %u, group_desc = %u, desc = %u",
+			 block_group, group_desc, offset);
 		return NULL;
 	}
 
@@ -322,8 +322,8 @@ static int ext4_valid_block_bitmap(struct super_block *sb,
 		return 1;
 
 err_out:
-	ext4_error(sb, "Invalid block bitmap - block_group = %d, block = %llu",
-		   block_group, bitmap_blk);
+	ext4_err(sb, "Invalid block bitmap - block_group = %d, block = %llu",
+		 block_group, bitmap_blk);
 	return 0;
 }
 /**
@@ -349,8 +349,8 @@ ext4_read_block_bitmap_nowait(struct super_block *sb, ext4_group_t block_group)
 	bitmap_blk = ext4_block_bitmap(sb, desc);
 	bh = sb_getblk(sb, bitmap_blk);
 	if (unlikely(!bh)) {
-		ext4_error(sb, "Cannot get buffer for block bitmap - block_group = %u, block_bitmap = %llu",
-			   block_group, bitmap_blk);
+		ext4_err(sb, "Cannot get buffer for block bitmap - block_group = %u, block_bitmap = %llu",
+			 block_group, bitmap_blk);
 		return NULL;
 	}
 
@@ -405,8 +405,8 @@ int ext4_wait_block_bitmap(struct super_block *sb, ext4_group_t block_group,
 		return 1;
 	wait_on_buffer(bh);
 	if (!buffer_uptodate(bh)) {
-		ext4_error(sb, "Cannot read block bitmap - block_group = %u, block_bitmap = %llu",
-			   block_group, (unsigned long long) bh->b_blocknr);
+		ext4_err(sb, "Cannot read block bitmap - block_group = %u, block_bitmap = %llu",
+			 block_group, (unsigned long long) bh->b_blocknr);
 		return 1;
 	}
 	clear_buffer_new(bh);
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 2aaf549..348df50 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1960,8 +1960,8 @@ extern void ext4_kvfree(void *ptr);
 extern __printf(4, 5)
 void __ext4_error(struct super_block *, const char *, unsigned int,
 		  const char *, ...);
-#define ext4_error(sb, message...)	__ext4_error(sb, __func__,	\
-						     __LINE__, ## message)
+#define ext4_err(sb, fmt, ...)	\
+	__ext4_error(sb, __func__, __LINE__, fmt, ##__VA_ARGS__)
 extern __printf(5, 6)
 void ext4_error_inode(struct inode *, const char *, unsigned int, ext4_fsblk_t,
 		      const char *, ...);
@@ -1978,8 +1978,8 @@ void __ext4_abort(struct super_block *, const char *, unsigned int,
 extern __printf(4, 5)
 void __ext4_warning(struct super_block *, const char *, unsigned int,
 		    const char *, ...);
-#define ext4_warning(sb, message...)	__ext4_warning(sb, __func__, \
-						       __LINE__, ## message)
+#define ext4_warn(sb, fmt, ...)						\
+	__ext4_warning(sb, __func__, __LINE__, fmt, ##__VA_ARGS__)
 extern __printf(3, 4)
 void ext4_msg(struct super_block *, const char *, const char *, ...);
 extern void __dump_mmp_msg(struct super_block *, struct mmp_struct *mmp,
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 29cbd9f..f4522eb 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -79,7 +79,7 @@ static unsigned ext4_init_inode_bitmap(struct super_block *sb,
 	/* If checksum is bad mark all blocks and inodes use to prevent
 	 * allocation, essentially implementing a per-group read-only flag. */
 	if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
-		ext4_error(sb, "Checksum bad for group %u", block_group);
+		ext4_err(sb, "Checksum bad for group %u", block_group);
 		ext4_free_group_clusters_set(sb, gdp, 0);
 		ext4_free_inodes_set(sb, gdp, 0);
 		ext4_itable_unused_set(sb, gdp, 0);
@@ -124,8 +124,8 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
 	bitmap_blk = ext4_inode_bitmap(sb, desc);
 	bh = sb_getblk(sb, bitmap_blk);
 	if (unlikely(!bh)) {
-		ext4_error(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
-			   block_group, bitmap_blk);
+		ext4_err(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
+			 block_group, bitmap_blk);
 		return NULL;
 	}
 	if (bitmap_uptodate(bh))
@@ -167,8 +167,8 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
 	wait_on_buffer(bh);
 	if (!buffer_uptodate(bh)) {
 		put_bh(bh);
-		ext4_error(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
-			   block_group, bitmap_blk);
+		ext4_err(sb, "Cannot read inode bitmap - block_group = %u, inode_bitmap = %llu",
+			 block_group, bitmap_blk);
 		return NULL;
 	}
 	return bh;
@@ -239,7 +239,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
 
 	es = EXT4_SB(sb)->s_es;
 	if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
-		ext4_error(sb, "reserved or nonexistent inode %lu", ino);
+		ext4_err(sb, "reserved or nonexistent inode %lu", ino);
 		goto error_return;
 	}
 	block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
@@ -294,7 +294,7 @@ out:
 			fatal = err;
 		ext4_mark_super_dirty(sb);
 	} else
-		ext4_error(sb, "bit already cleared for inode %lu", ino);
+		ext4_err(sb, "bit already cleared for inode %lu", ino);
 
 error_return:
 	brelse(bitmap_bh);
@@ -688,8 +688,8 @@ repeat_in_this_group:
 			continue;
 		}
 		if (group == 0 && (ino+1) < EXT4_FIRST_INO(sb)) {
-			ext4_error(sb, "reserved inode found cleared - inode=%lu",
-				   ino + 1);
+			ext4_err(sb, "reserved inode found cleared - inode=%lu",
+				 ino + 1);
 			continue;
 		}
 		ext4_lock_group(sb, group);
@@ -922,7 +922,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
 
 	/* Error cases - e2fsck has already cleaned up for us */
 	if (ino > max_ino) {
-		ext4_warning(sb, "bad orphan ino %lu!  e2fsck was run?", ino);
+		ext4_warn(sb, "bad orphan ino %lu!  e2fsck was run?", ino);
 		goto error;
 	}
 
@@ -930,7 +930,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
 	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
 	bitmap_bh = ext4_read_inode_bitmap(sb, block_group);
 	if (!bitmap_bh) {
-		ext4_warning(sb, "inode bitmap error for orphan %lu", ino);
+		ext4_warn(sb, "inode bitmap error for orphan %lu", ino);
 		goto error;
 	}
 
@@ -962,7 +962,7 @@ iget_failed:
 	err = PTR_ERR(inode);
 	inode = NULL;
 bad_orphan:
-	ext4_warning(sb, "bad orphan inode %lu!  e2fsck was run?", ino);
+	ext4_warn(sb, "bad orphan inode %lu!  e2fsck was run?", ino);
 	pr_notice("ext4_test_bit(bit=%d, block=%llu) = %d\n",
 		  bit, (unsigned long long)bitmap_bh->b_blocknr,
 		  ext4_test_bit(bit, bitmap_bh->b_data));
@@ -1098,10 +1098,10 @@ int ext4_init_inode_table(struct super_block *sb, ext4_group_t group,
 			    sbi->s_inodes_per_block);
 
 	if ((used_blks < 0) || (used_blks > sbi->s_itb_per_group)) {
-		ext4_error(sb, "Something is wrong with group %u\n"
-			   "Used itable blocks: %d itable unused count: %u",
-			   group, used_blks,
-			   ext4_itable_unused_count(sb, gdp));
+		ext4_err(sb, "Something is wrong with group %u\n"
+			 "Used itable blocks: %d itable unused count: %u",
+			 group, used_blks,
+			 ext4_itable_unused_count(sb, gdp));
 		ret = 1;
 		goto err_out;
 	}
diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
index bd02261..db428a0 100644
--- a/fs/ext4/indirect.c
+++ b/fs/ext4/indirect.c
@@ -101,9 +101,9 @@ static int ext4_block_to_path(struct inode *inode,
 		offsets[n++] = i_block & (ptrs - 1);
 		final = ptrs;
 	} else {
-		ext4_warning(inode->i_sb, "block %lu > max in inode %lu",
-			     i_block + direct_blocks +
-			     indirect_blocks + double_blocks, inode->i_ino);
+		ext4_warn(inode->i_sb, "block %lu > max in inode %lu",
+			  i_block + direct_blocks +
+			  indirect_blocks + double_blocks, inode->i_ino);
 	}
 	if (boundary)
 		*boundary = final - 1 - (i_block & (ptrs - 1));
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 2fbfee2..29e2f29 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -185,8 +185,8 @@ void ext4_evict_inode(struct inode *inode)
 	inode->i_size = 0;
 	err = ext4_mark_inode_dirty(handle, inode);
 	if (err) {
-		ext4_warning(inode->i_sb,
-			     "couldn't mark inode dirty (err %d)", err);
+		ext4_warn(inode->i_sb,
+			  "couldn't mark inode dirty (err %d)", err);
 		goto stop_handle;
 	}
 	if (inode->i_blocks)
@@ -203,8 +203,8 @@ void ext4_evict_inode(struct inode *inode)
 		if (err > 0)
 			err = ext4_journal_restart(handle, 3);
 		if (err != 0) {
-			ext4_warning(inode->i_sb,
-				     "couldn't extend journal (err %d)", err);
+			ext4_warn(inode->i_sb,
+				  "couldn't extend journal (err %d)", err);
 		stop_handle:
 			ext4_journal_stop(handle);
 			ext4_orphan_del(NULL, inode);
@@ -1578,9 +1578,9 @@ static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
 		ext4_update_i_disksize(mpd->inode, disksize);
 		err = ext4_mark_inode_dirty(handle, mpd->inode);
 		if (err)
-			ext4_error(mpd->inode->i_sb,
-				   "Failed to mark inode %lu dirty",
-				   mpd->inode->i_ino);
+			ext4_err(mpd->inode->i_sb,
+				 "Failed to mark inode %lu dirty",
+				 mpd->inode->i_ino);
 	}
 
 submit_io:
@@ -4442,9 +4442,9 @@ int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
 						     EXT4_STATE_NO_EXPAND);
 				if (mnt_count !=
 					le16_to_cpu(sbi->s_es->s_mnt_count)) {
-					ext4_warning(inode->i_sb,
-					"Unable to expand inode %lu. Delete some EAs or run e2fsck.",
-					inode->i_ino);
+					ext4_warn(inode->i_sb,
+						  "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
+						  inode->i_ino);
 					mnt_count =
 					  le16_to_cpu(sbi->s_es->s_mnt_count);
 				}
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 185cbac..064c557 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -2758,8 +2758,8 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
 
 	len = EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
 	if (!ext4_data_block_valid(sbi, block, len)) {
-		ext4_error(sb, "Allocating blocks %llu-%llu which overlap fs metadata",
-			   block, block + len);
+		ext4_err(sb, "Allocating blocks %llu-%llu which overlap fs metadata",
+			 block, block + len);
 		/* File system mounted not to panic on error
 		 * Fix the bitmap and repeat the block allocation
 		 * We leak some of the blocks here.
@@ -3656,13 +3656,13 @@ ext4_mb_discard_group_preallocations(struct super_block *sb,
 
 	bitmap_bh = ext4_read_block_bitmap(sb, group);
 	if (bitmap_bh == NULL) {
-		ext4_error(sb, "Error reading block bitmap for %u", group);
+		ext4_err(sb, "Error reading block bitmap for %u", group);
 		return 0;
 	}
 
 	err = ext4_mb_load_buddy(sb, group, &e4b);
 	if (err) {
-		ext4_error(sb, "Error loading buddy information for %u", group);
+		ext4_err(sb, "Error loading buddy information for %u", group);
 		put_bh(bitmap_bh);
 		return 0;
 	}
@@ -3825,15 +3825,15 @@ repeat:
 
 		err = ext4_mb_load_buddy(sb, group, &e4b);
 		if (err) {
-			ext4_error(sb, "Error loading buddy information for %u",
-				   group);
+			ext4_err(sb, "Error loading buddy information for %u",
+				 group);
 			continue;
 		}
 
 		bitmap_bh = ext4_read_block_bitmap(sb, group);
 		if (bitmap_bh == NULL) {
-			ext4_error(sb, "Error reading block bitmap for %u",
-				   group);
+			ext4_err(sb, "Error reading block bitmap for %u",
+				 group);
 			ext4_mb_unload_buddy(&e4b);
 			continue;
 		}
@@ -4081,8 +4081,8 @@ ext4_mb_discard_lg_preallocations(struct super_block *sb,
 
 		ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, NULL);
 		if (ext4_mb_load_buddy(sb, group, &e4b)) {
-			ext4_error(sb, "Error loading buddy information for %u",
-				   group);
+			ext4_err(sb, "Error loading buddy information for %u",
+				 group);
 			continue;
 		}
 		ext4_lock_group(sb, group);
@@ -4488,8 +4488,8 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
 	sbi = EXT4_SB(sb);
 	if (!(flags & EXT4_FREE_BLOCKS_VALIDATED) &&
 	    !ext4_data_block_valid(sbi, block, count)) {
-		ext4_error(sb, "Freeing blocks not in datazone - block = %llu, count = %lu",
-			   block, count);
+		ext4_err(sb, "Freeing blocks not in datazone - block = %llu, count = %lu",
+			 block, count);
 		goto error_return;
 	}
 
@@ -4587,8 +4587,8 @@ do_more:
 	    in_range(block + count - 1, ext4_inode_table(sb, gdp),
 		     EXT4_SB(sb)->s_itb_per_group)) {
 
-		ext4_error(sb, "Freeing blocks in system zone - Block = %llu, count = %lu",
-			   block, count);
+		ext4_err(sb, "Freeing blocks in system zone - Block = %llu, count = %lu",
+			 block, count);
 		/* err = 0. ext4_std_error should be a no op */
 		goto error_return;
 	}
@@ -4725,8 +4725,8 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
 	 * boundary.
 	 */
 	if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
-		ext4_warning(sb, "too much blocks added to group %u\n",
-			     block_group);
+		ext4_warn(sb, "too much blocks added to group %u\n",
+			  block_group);
 		err = -EINVAL;
 		goto error_return;
 	}
@@ -4748,8 +4748,8 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
 	    in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
 	    in_range(block + count - 1, ext4_inode_table(sb, desc),
 		     sbi->s_itb_per_group)) {
-		ext4_error(sb, "Adding blocks in system zones - Block = %llu, count = %lu",
-			   block, count);
+		ext4_err(sb, "Adding blocks in system zones - Block = %llu, count = %lu",
+			 block, count);
 		err = -EINVAL;
 		goto error_return;
 	}
@@ -4772,8 +4772,8 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
 	for (i = 0, blocks_freed = 0; i < count; i++) {
 		BUFFER_TRACE(bitmap_bh, "clear bit");
 		if (!mb_test_bit(bit + i, bitmap_bh->b_data)) {
-			ext4_error(sb, "bit already cleared for block %llu",
-				   (ext4_fsblk_t)(block + i));
+			ext4_err(sb, "bit already cleared for block %llu",
+				 (ext4_fsblk_t)(block + i));
 			BUFFER_TRACE(bitmap_bh, "bit already cleared");
 		} else {
 			blocks_freed++;
@@ -4891,8 +4891,8 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
 
 	ret = ext4_mb_load_buddy(sb, group, &e4b);
 	if (ret) {
-		ext4_error(sb, "Error in loading buddy information for %u",
-			   group);
+		ext4_err(sb, "Error in loading buddy information for %u",
+			 group);
 		return ret;
 	}
 	bitmap = e4b.bd_bitmap;
diff --git a/fs/ext4/mmp.c b/fs/ext4/mmp.c
index 1767b2a..9aba1b4 100644
--- a/fs/ext4/mmp.c
+++ b/fs/ext4/mmp.c
@@ -53,8 +53,7 @@ static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,
 		}
 	}
 	if (!*bh) {
-		ext4_warning(sb, "Error while reading MMP block %llu",
-			     mmp_block);
+		ext4_warn(sb, "Error while reading MMP block %llu", mmp_block);
 		return -EIO;
 	}
 
@@ -126,19 +125,19 @@ static int kmmpd(void *data)
 		 */
 		if (retval) {
 			if ((failed_writes % 60) == 0)
-				ext4_error(sb, "Error writing to MMP block");
+				ext4_err(sb, "Error writing to MMP block");
 			failed_writes++;
 		}
 
 		if (!(le32_to_cpu(es->s_feature_incompat) &
 		    EXT4_FEATURE_INCOMPAT_MMP)) {
-			ext4_warning(sb, "kmmpd being stopped since MMP feature has been disabled");
+			ext4_warn(sb, "kmmpd being stopped since MMP feature has been disabled");
 			EXT4_SB(sb)->s_mmp_tsk = NULL;
 			goto failed;
 		}
 
 		if (sb->s_flags & MS_RDONLY) {
-			ext4_warning(sb, "kmmpd being stopped since filesystem has been remounted as readonly");
+			ext4_warn(sb, "kmmpd being stopped since filesystem has been remounted as readonly");
 			EXT4_SB(sb)->s_mmp_tsk = NULL;
 			goto failed;
 		}
@@ -160,8 +159,8 @@ static int kmmpd(void *data)
 
 			retval = read_mmp_block(sb, &bh_check, mmp_block);
 			if (retval) {
-				ext4_error(sb, "error reading MMP data: %d",
-					   retval);
+				ext4_err(sb, "error reading MMP data: %d",
+					 retval);
 
 				EXT4_SB(sb)->s_mmp_tsk = NULL;
 				goto failed;
@@ -175,7 +174,7 @@ static int kmmpd(void *data)
 					     "Error while updating MMP info. "
 					     "The filesystem seems to have been"
 					     " multiply mounted.");
-				ext4_error(sb, "abort");
+				ext4_err(sb, "abort");
 				goto failed;
 			}
 			put_bh(bh_check);
@@ -237,7 +236,7 @@ int ext4_multi_mount_protect(struct super_block *sb,
 
 	if (mmp_block < le32_to_cpu(es->s_first_data_block) ||
 	    mmp_block >= ext4_blocks_count(es)) {
-		ext4_warning(sb, "Invalid MMP block in superblock");
+		ext4_warn(sb, "Invalid MMP block in superblock");
 		goto failed;
 	}
 
@@ -271,11 +270,11 @@ int ext4_multi_mount_protect(struct super_block *sb,
 
 	/* Print MMP interval if more than 20 secs. */
 	if (wait_time > EXT4_MMP_MIN_CHECK_INTERVAL * 4)
-		ext4_warning(sb, "MMP interval %u higher than expected, please wait",
-			     wait_time * 2);
+		ext4_warn(sb, "MMP interval %u higher than expected, please wait",
+			  wait_time * 2);
 
 	if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
-		ext4_warning(sb, "MMP startup interrupted, failing mount");
+		ext4_warn(sb, "MMP startup interrupted, failing mount");
 		goto failed;
 	}
 
@@ -304,7 +303,7 @@ skip:
 	 * wait for MMP interval and check mmp_seq.
 	 */
 	if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
-		ext4_warning(sb, "MMP startup interrupted, failing mount");
+		ext4_warn(sb, "MMP startup interrupted, failing mount");
 		goto failed;
 	}
 
@@ -320,7 +319,7 @@ skip:
 
 	mmpd_data = kmalloc(sizeof(struct mmpd_data), GFP_KERNEL);
 	if (!mmpd_data) {
-		ext4_warning(sb, "not enough memory for mmpd_data");
+		ext4_warn(sb, "not enough memory for mmpd_data");
 		goto failed;
 	}
 	mmpd_data->sb = sb;
@@ -335,8 +334,7 @@ skip:
 	if (IS_ERR(EXT4_SB(sb)->s_mmp_tsk)) {
 		EXT4_SB(sb)->s_mmp_tsk = NULL;
 		kfree(mmpd_data);
-		ext4_warning(sb, "Unable to create kmmpd thread for %s",
-			     sb->s_id);
+		ext4_warn(sb, "Unable to create kmmpd thread for %s", sb->s_id);
 		goto failed;
 	}
 
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 99f86a7..ff8a843 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -364,8 +364,8 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
 	if (root->info.hash_version != DX_HASH_TEA &&
 	    root->info.hash_version != DX_HASH_HALF_MD4 &&
 	    root->info.hash_version != DX_HASH_LEGACY) {
-		ext4_warning(dir->i_sb, "Unrecognised inode hash code %d",
-			     root->info.hash_version);
+		ext4_warn(dir->i_sb, "Unrecognised inode hash code %d",
+			  root->info.hash_version);
 		brelse(bh);
 		*err = ERR_BAD_DX_DIR;
 		goto fail;
@@ -379,16 +379,16 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
 	hash = hinfo->hash;
 
 	if (root->info.unused_flags & 1) {
-		ext4_warning(dir->i_sb, "Unimplemented inode hash flags: %#06x",
-			     root->info.unused_flags);
+		ext4_warn(dir->i_sb, "Unimplemented inode hash flags: %#06x",
+			  root->info.unused_flags);
 		brelse(bh);
 		*err = ERR_BAD_DX_DIR;
 		goto fail;
 	}
 
 	if ((indirect = root->info.indirect_levels) > 1) {
-		ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x",
-			     root->info.indirect_levels);
+		ext4_warn(dir->i_sb, "Unimplemented inode hash depth: %#06x",
+			  root->info.indirect_levels);
 		brelse(bh);
 		*err = ERR_BAD_DX_DIR;
 		goto fail;
@@ -399,7 +399,7 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
 
 	if (dx_get_limit(entries) != dx_root_limit(dir,
 						   root->info.info_length)) {
-		ext4_warning(dir->i_sb, "dx entry: limit != root limit");
+		ext4_warn(dir->i_sb, "dx entry: limit != root limit");
 		brelse(bh);
 		*err = ERR_BAD_DX_DIR;
 		goto fail;
@@ -410,8 +410,8 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
 	{
 		count = dx_get_count(entries);
 		if (!count || count > dx_get_limit(entries)) {
-			ext4_warning(dir->i_sb,
-				     "dx entry: no count or count > limit");
+			ext4_warn(dir->i_sb,
+				  "dx entry: no count or count > limit");
 			brelse(bh);
 			*err = ERR_BAD_DX_DIR;
 			goto fail2;
@@ -457,8 +457,8 @@ dx_probe(const struct qstr *d_name, struct inode *dir,
 			goto fail2;
 		at = entries = ((struct dx_node *) bh->b_data)->entries;
 		if (dx_get_limit(entries) != dx_node_limit (dir)) {
-			ext4_warning(dir->i_sb,
-				     "dx entry: limit != node limit");
+			ext4_warn(dir->i_sb,
+				  "dx entry: limit != node limit");
 			brelse(bh);
 			*err = ERR_BAD_DX_DIR;
 			goto fail2;
@@ -473,9 +473,9 @@ fail2:
 	}
 fail:
 	if (*err == ERR_BAD_DX_DIR)
-		ext4_warning(dir->i_sb,
-			     "Corrupt dir inode %lu, running e2fsck is recommended.",
-			     dir->i_ino);
+		ext4_warn(dir->i_sb,
+			  "Corrupt dir inode %lu, running e2fsck is recommended.",
+			  dir->i_ino);
 	return NULL;
 }
 
@@ -1009,9 +1009,9 @@ static struct buffer_head * ext4_dx_find_entry(struct inode *dir, const struct q
 		retval = ext4_htree_next_block(dir, hinfo.hash, frame,
 					       frames, NULL);
 		if (retval < 0) {
-			ext4_warning(sb,
-			     "error reading index page in directory #%lu",
-			     dir->i_ino);
+			ext4_warn(sb,
+				  "error reading index page in directory #%lu",
+				  dir->i_ino);
 			*err = retval;
 			goto errout;
 		}
@@ -1547,7 +1547,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
 
 		if (levels && (dx_get_count(frames->entries) ==
 			       dx_get_limit(frames->entries))) {
-			ext4_warning(sb, "Directory index full!");
+			ext4_warn(sb, "Directory index full!");
 			err = -ENOSPC;
 			goto cleanup;
 		}
@@ -1913,9 +1913,9 @@ static int empty_dir(struct inode *inode)
 			EXT4_ERROR_INODE(inode,
 				"error %d reading directory lblock 0", err);
 		else
-			ext4_warning(inode->i_sb,
-				     "bad directory (dir #%lu) - no data block",
-				     inode->i_ino);
+			ext4_warn(inode->i_sb,
+				  "bad directory (dir #%lu) - no data block",
+				  inode->i_ino);
 		return 1;
 	}
 	de = (struct ext4_dir_entry_2 *) bh->b_data;
@@ -1924,9 +1924,9 @@ static int empty_dir(struct inode *inode)
 			!le32_to_cpu(de1->inode) ||
 			strcmp(".", de->name) ||
 			strcmp("..", de1->name)) {
-		ext4_warning(inode->i_sb,
-			     "bad directory (dir #%lu) - no `.' or `..'",
-			     inode->i_ino);
+		ext4_warn(inode->i_sb,
+			  "bad directory (dir #%lu) - no `.' or `..'",
+			  inode->i_ino);
 		brelse(bh);
 		return 1;
 	}
@@ -2159,9 +2159,9 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
 	if (retval)
 		goto end_rmdir;
 	if (!EXT4_DIR_LINK_EMPTY(inode))
-		ext4_warning(inode->i_sb,
-			     "empty directory has too many links (%d)",
-			     inode->i_nlink);
+		ext4_warn(inode->i_sb,
+			  "empty directory has too many links (%d)",
+			  inode->i_nlink);
 	inode->i_version++;
 	clear_nlink(inode);
 	/* There's no need to set i_disksize: the fact that i_nlink is
@@ -2214,9 +2214,9 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
 		goto end_unlink;
 
 	if (!inode->i_nlink) {
-		ext4_warning(inode->i_sb,
-			     "Deleting nonexistent file (%lu), %d",
-			     inode->i_ino, inode->i_nlink);
+		ext4_warn(inode->i_sb,
+			  "Deleting nonexistent file (%lu), %d",
+			  inode->i_ino, inode->i_nlink);
 		set_nlink(inode, 1);
 	}
 	retval = ext4_delete_entry(handle, dir, de, bh);
@@ -2518,9 +2518,9 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
 		}
 	}
 	if (retval) {
-		ext4_warning(old_dir->i_sb,
-				"Deleting old file (%lu), %d, error=%d",
-				old_dir->i_ino, old_dir->i_nlink, retval);
+		ext4_warn(old_dir->i_sb,
+			  "Deleting old file (%lu), %d, error=%d",
+			  old_dir->i_ino, old_dir->i_nlink, retval);
 	}
 
 	if (new_inode) {
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index a5afbad..b1b492a 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -238,12 +238,12 @@ static void ext4_end_bio(struct bio *bio, int error)
 
 	if (error) {
 		io_end->flag |= EXT4_IO_END_ERROR;
-		ext4_warning(inode->i_sb, "I/O error writing to inode %lu (offset %llu size %ld starting block %llu)",
-			     inode->i_ino,
-			     (unsigned long long) io_end->offset,
-			     (long) io_end->size,
-			     (unsigned long long)
-			     bi_sector >> (inode->i_blkbits - 9));
+		ext4_warn(inode->i_sb, "I/O error writing to inode %lu (offset %llu size %ld starting block %llu)",
+			  inode->i_ino,
+			  (unsigned long long) io_end->offset,
+			  (long) io_end->size,
+			  (unsigned long long)
+			  bi_sector >> (inode->i_blkbits - 9));
 	}
 
 	if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index ed3a306..bd133fd 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -29,7 +29,7 @@ int ext4_resize_begin(struct super_block *sb)
 	 * with error, because it can destroy the filesystem easily.
 	 */
 	if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
-		ext4_warning(sb, "There are errors in the filesystem, so online resizing is not allowed");
+		ext4_warn(sb, "There are errors in the filesystem, so online resizing is not allowed");
 		return -EPERM;
 	}
 
@@ -76,53 +76,51 @@ static int verify_group_input(struct super_block *sb,
 
 	ext4_get_group_no_and_offset(sb, start, NULL, &offset);
 	if (group != sbi->s_groups_count)
-		ext4_warning(sb, "Cannot add at group %u (only %u groups)",
-			     input->group, sbi->s_groups_count);
+		ext4_warn(sb, "Cannot add at group %u (only %u groups)",
+			  input->group, sbi->s_groups_count);
 	else if (offset != 0)
-			ext4_warning(sb, "Last group not full");
+		ext4_warn(sb, "Last group not full");
 	else if (input->reserved_blocks > input->blocks_count / 5)
-		ext4_warning(sb, "Reserved blocks too high (%u)",
-			     input->reserved_blocks);
+		ext4_warn(sb, "Reserved blocks too high (%u)",
+			  input->reserved_blocks);
 	else if (free_blocks_count < 0)
-		ext4_warning(sb, "Bad blocks count %u",
-			     input->blocks_count);
+		ext4_warn(sb, "Bad blocks count %u", input->blocks_count);
 	else if (!(bh = sb_bread(sb, end - 1)))
-		ext4_warning(sb, "Cannot read last block (%llu)",
-			     end - 1);
+		ext4_warn(sb, "Cannot read last block (%llu)", end - 1);
 	else if (outside(input->block_bitmap, start, end))
-		ext4_warning(sb, "Block bitmap not in group (block %llu)",
-			     (unsigned long long)input->block_bitmap);
+		ext4_warn(sb, "Block bitmap not in group (block %llu)",
+			  (unsigned long long)input->block_bitmap);
 	else if (outside(input->inode_bitmap, start, end))
-		ext4_warning(sb, "Inode bitmap not in group (block %llu)",
-			     (unsigned long long)input->inode_bitmap);
+		ext4_warn(sb, "Inode bitmap not in group (block %llu)",
+			  (unsigned long long)input->inode_bitmap);
 	else if (outside(input->inode_table, start, end) ||
 		 outside(itend - 1, start, end))
-		ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)",
-			     (unsigned long long)input->inode_table, itend - 1);
+		ext4_warn(sb, "Inode table not in group (blocks %llu-%llu)",
+			  (unsigned long long)input->inode_table, itend - 1);
 	else if (input->inode_bitmap == input->block_bitmap)
-		ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)",
-			     (unsigned long long)input->block_bitmap);
+		ext4_warn(sb, "Block bitmap same as inode bitmap (%llu)",
+			  (unsigned long long)input->block_bitmap);
 	else if (inside(input->block_bitmap, input->inode_table, itend))
-		ext4_warning(sb, "Block bitmap (%llu) in inode table (%llu-%llu)",
-			     (unsigned long long)input->block_bitmap,
-			     (unsigned long long)input->inode_table, itend - 1);
+		ext4_warn(sb, "Block bitmap (%llu) in inode table (%llu-%llu)",
+			  (unsigned long long)input->block_bitmap,
+			  (unsigned long long)input->inode_table, itend - 1);
 	else if (inside(input->inode_bitmap, input->inode_table, itend))
-		ext4_warning(sb, "Inode bitmap (%llu) in inode table (%llu-%llu)",
-			     (unsigned long long)input->inode_bitmap,
-			     (unsigned long long)input->inode_table, itend - 1);
+		ext4_warn(sb, "Inode bitmap (%llu) in inode table (%llu-%llu)",
+			  (unsigned long long)input->inode_bitmap,
+			  (unsigned long long)input->inode_table, itend - 1);
 	else if (inside(input->block_bitmap, start, metaend))
-		ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)",
-			     (unsigned long long)input->block_bitmap,
-			     start, metaend - 1);
+		ext4_warn(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)",
+			  (unsigned long long)input->block_bitmap,
+			  start, metaend - 1);
 	else if (inside(input->inode_bitmap, start, metaend))
-		ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)",
-			     (unsigned long long)input->inode_bitmap,
-			     start, metaend - 1);
+		ext4_warn(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)",
+			  (unsigned long long)input->inode_bitmap,
+			  start, metaend - 1);
 	else if (inside(input->inode_table, start, metaend) ||
 		 inside(itend - 1, start, metaend))
-		ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table (%llu-%llu)",
-			     (unsigned long long)input->inode_table,
-			     itend - 1, start, metaend - 1);
+		ext4_warn(sb, "Inode table (%llu-%llu) overlaps GDT table (%llu-%llu)",
+			  (unsigned long long)input->inode_table,
+			  itend - 1, start, metaend - 1);
 	else
 		err = 0;
 	brelse(bh);
@@ -644,11 +642,11 @@ static int verify_reserved_gdb(struct super_block *sb,
 	while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
 		if (le32_to_cpu(*p++) !=
 		    grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
-			ext4_warning(sb, "reserved GDT %llu missing grp %d (%llu)",
-				     blk, grp,
-				     grp *
-				     (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
-				     blk);
+			ext4_warn(sb, "reserved GDT %llu missing grp %d (%llu)",
+				  blk, grp,
+				  grp *
+				  (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
+				  blk);
 			return -EINVAL;
 		}
 		if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb))
@@ -696,8 +694,8 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
          */
 	if (EXT4_SB(sb)->s_sbh->b_blocknr !=
 	    le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
-		ext4_warning(sb, "won't resize using backup superblock at %llu",
-			(unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
+		ext4_warn(sb, "won't resize using backup superblock at %llu",
+			  (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
 		return -EPERM;
 	}
 
@@ -720,8 +718,8 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
 
 	data = (__le32 *)dind->b_data;
 	if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
-		ext4_warning(sb, "new group %u GDT block %llu not reserved",
-			     group, gdblock);
+		ext4_warn(sb, "new group %u GDT block %llu not reserved",
+			  group, gdblock);
 		err = -EINVAL;
 		goto exit_dind;
 	}
@@ -748,8 +746,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
 				     GFP_NOFS);
 	if (!n_group_desc) {
 		err = -ENOMEM;
-		ext4_warning(sb, "not enough memory for %lu groups",
-			     gdb_num + 1);
+		ext4_warn(sb, "not enough memory for %lu groups", gdb_num + 1);
 		goto exit_inode;
 	}
 
@@ -856,9 +853,9 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
 	/* Get each reserved primary GDT block and verify it holds backups */
 	for (res = 0; res < reserved_gdb; res++, blk++) {
 		if (le32_to_cpu(*data) != blk) {
-			ext4_warning(sb, "reserved block %llu not at offset %ld",
-				     blk,
-				     (long)(data - (__le32 *)dind->b_data));
+			ext4_warn(sb, "reserved block %llu not at offset %ld",
+				  blk,
+				  (long)(data - (__le32 *)dind->b_data));
 			err = -EINVAL;
 			goto exit_bh;
 		}
@@ -1003,8 +1000,8 @@ static void update_backups(struct super_block *sb,
 	 */
 exit_err:
 	if (err) {
-		ext4_warning(sb, "can't update backup for group %u (err %d), forcing fsck on next reboot",
-			     group, err);
+		ext4_warn(sb, "can't update backup for group %u (err %d), forcing fsck on next reboot",
+			  group, err);
 		sbi->s_mount_state &= ~EXT4_VALID_FS;
 		sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
 		mark_buffer_dirty(sbi->s_sbh);
@@ -1383,19 +1380,19 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
 
 	if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
 					EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
-		ext4_warning(sb, "Can't resize non-sparse filesystem further");
+		ext4_warn(sb, "Can't resize non-sparse filesystem further");
 		return -EPERM;
 	}
 
 	if (ext4_blocks_count(es) + input->blocks_count <
 	    ext4_blocks_count(es)) {
-		ext4_warning(sb, "blocks_count overflow");
+		ext4_warn(sb, "blocks_count overflow");
 		return -EINVAL;
 	}
 
 	if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
 	    le32_to_cpu(es->s_inodes_count)) {
-		ext4_warning(sb, "inodes_count overflow");
+		ext4_warn(sb, "inodes_count overflow");
 		return -EINVAL;
 	}
 
@@ -1403,13 +1400,13 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
 		if (!EXT4_HAS_COMPAT_FEATURE(sb,
 					     EXT4_FEATURE_COMPAT_RESIZE_INODE)
 		    || !le16_to_cpu(es->s_reserved_gdt_blocks)) {
-			ext4_warning(sb,
-				     "No reserved GDT blocks, can't resize");
+			ext4_warn(sb,
+				  "No reserved GDT blocks, can't resize");
 			return -EPERM;
 		}
 		inode = ext4_iget(sb, EXT4_RESIZE_INO);
 		if (IS_ERR(inode)) {
-			ext4_warning(sb, "Error opening resize inode");
+			ext4_warn(sb, "Error opening resize inode");
 			return PTR_ERR(inode);
 		}
 	}
@@ -1444,13 +1441,13 @@ static int ext4_group_extend_no_check(struct super_block *sb,
 	handle = ext4_journal_start_sb(sb, 3);
 	if (IS_ERR(handle)) {
 		err = PTR_ERR(handle);
-		ext4_warning(sb, "error %d on journal start", err);
+		ext4_warn(sb, "error %d on journal start", err);
 		return err;
 	}
 
 	err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
 	if (err) {
-		ext4_warning(sb, "error %d on journal write access", err);
+		ext4_warn(sb, "error %d on journal write access", err);
 		goto errout;
 	}
 
@@ -1512,12 +1509,12 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 		pr_err("filesystem on %s: too large to resize to %llu blocks safely\n",
 		       sb->s_id, n_blocks_count);
 		if (sizeof(sector_t) < 8)
-			ext4_warning(sb, "CONFIG_LBDAF not enabled");
+			ext4_warn(sb, "CONFIG_LBDAF not enabled");
 		return -EINVAL;
 	}
 
 	if (n_blocks_count < o_blocks_count) {
-		ext4_warning(sb, "can't shrink FS - resize aborted");
+		ext4_warn(sb, "can't shrink FS - resize aborted");
 		return -EINVAL;
 	}
 
@@ -1525,14 +1522,14 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 	ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
 
 	if (last == 0) {
-		ext4_warning(sb, "need to use ext2online to resize further");
+		ext4_warn(sb, "need to use ext2online to resize further");
 		return -EPERM;
 	}
 
 	add = EXT4_BLOCKS_PER_GROUP(sb) - last;
 
 	if (o_blocks_count + add < o_blocks_count) {
-		ext4_warning(sb, "blocks_count overflow");
+		ext4_warn(sb, "blocks_count overflow");
 		return -EINVAL;
 	}
 
@@ -1540,13 +1537,13 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 		add = n_blocks_count - o_blocks_count;
 
 	if (o_blocks_count + add < n_blocks_count)
-		ext4_warning(sb, "will only finish group (%llu blocks, %u new)",
-			     o_blocks_count + add, add);
+		ext4_warn(sb, "will only finish group (%llu blocks, %u new)",
+			  o_blocks_count + add, add);
 
 	/* See if the device is actually as big as what was requested */
 	bh = sb_bread(sb, o_blocks_count + add - 1);
 	if (!bh) {
-		ext4_warning(sb, "can't read last block, resize aborted");
+		ext4_warn(sb, "can't read last block, resize aborted");
 		return -ENOSPC;
 	}
 	brelse(bh);
@@ -1585,7 +1582,7 @@ int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)
 
 	if (n_blocks_count < o_blocks_count) {
 		/* On-line shrinking not supported */
-		ext4_warning(sb, "can't shrink FS - resize aborted");
+		ext4_warn(sb, "can't shrink FS - resize aborted");
 		return -EINVAL;
 	}
 
@@ -1605,20 +1602,20 @@ int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count)
 	if (desc_blocks &&
 	    (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE) ||
 	     le16_to_cpu(es->s_reserved_gdt_blocks) < desc_blocks)) {
-		ext4_warning(sb, "No reserved GDT blocks, can't resize");
+		ext4_warn(sb, "No reserved GDT blocks, can't resize");
 		return -EPERM;
 	}
 
 	resize_inode = ext4_iget(sb, EXT4_RESIZE_INO);
 	if (IS_ERR(resize_inode)) {
-		ext4_warning(sb, "Error opening resize inode");
+		ext4_warn(sb, "Error opening resize inode");
 		return PTR_ERR(resize_inode);
 	}
 
 	/* See if the device is actually as big as what was requested */
 	bh = sb_bread(sb, n_blocks_count - 1);
 	if (!bh) {
-		ext4_warning(sb, "can't read last block, resize aborted");
+		ext4_warn(sb, "can't read last block, resize aborted");
 		return -ENOSPC;
 	}
 	brelse(bh);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index cade67b..18e68f1 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -621,7 +621,7 @@ void __ext4_std_error(struct super_block *sb, const char *function,
 }
 
 /*
- * ext4_abort is a much stronger failure handler than ext4_error.  The
+ * ext4_abort is a much stronger failure handler than ext4_err.  The
  * abort function may be used to deal with unrecoverable failures such
  * as journal IO errors or ENOMEM at a critical moment in log management.
  *
@@ -737,9 +737,9 @@ void ext4_update_dynamic_rev(struct super_block *sb)
 	if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
 		return;
 
-	ext4_warning(sb,
-		     "updating to rev %d because of new feature flag, running e2fsck is recommended",
-		     EXT4_DYNAMIC_REV);
+	ext4_warn(sb,
+		  "updating to rev %d because of new feature flag, running e2fsck is recommended",
+		  EXT4_DYNAMIC_REV);
 
 	es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
 	es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
@@ -3289,8 +3289,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 		}
 	} else {
 		if (clustersize != blocksize) {
-			ext4_warning(sb, "fragment/cluster size (%d) != block size (%d)",
-				     clustersize, blocksize);
+			ext4_warn(sb, "fragment/cluster size (%d) != block size (%d)",
+				  clustersize, blocksize);
 			clustersize = blocksize;
 		}
 		if (sbi->s_blocks_per_group > blocksize * 8) {
@@ -4080,7 +4080,7 @@ static void ext4_clear_journal_err(struct super_block *sb,
 
 	/*
 	 * Now check for any error status which may have been recorded in the
-	 * journal by a prior ext4_error() or ext4_abort()
+	 * journal by a prior ext4_err() or ext4_abort()
 	 */
 
 	j_errno = jbd2_journal_errno(journal);
@@ -4088,9 +4088,9 @@ static void ext4_clear_journal_err(struct super_block *sb,
 		char nbuf[16];
 
 		errstr = ext4_decode_error(sb, j_errno, nbuf);
-		ext4_warning(sb, "Filesystem error recorded from previous mount: %s",
-			     errstr);
-		ext4_warning(sb, "Marking fs in need of filesystem check");
+		ext4_warn(sb, "Filesystem error recorded from previous mount: %s",
+			  errstr);
+		ext4_warn(sb, "Marking fs in need of filesystem check");
 
 		EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
 		es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
-- 
1.7.8.111.gad25c.dirty

--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Powered by blists - more mailing lists

Powered by Openwall GNU/*/Linux Powered by OpenVZ