aboutsummaryrefslogtreecommitdiffstats
path: root/fs/ext4
diff options
context:
space:
mode:
authorHarvey Harrison <harvey.harrison@gmail.com>2008-04-17 10:38:59 -0400
committerTheodore Ts'o <tytso@mit.edu>2008-04-17 10:38:59 -0400
commit46e665e9d297525d286989640cf4247cbe941df6 (patch)
tree4858cd21e48cab2b2c51839dd80378f6044d3394 /fs/ext4
parent620de4e19890c623eb4ba293ec19b42e2e391b89 (diff)
ext4: replace remaining __FUNCTION__ occurrences
__FUNCTION__ is gcc-specific, use __func__ Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com> Cc: <linux-ext4@vger.kernel.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Diffstat (limited to 'fs/ext4')
-rw-r--r--fs/ext4/balloc.c14
-rw-r--r--fs/ext4/ext4_jbd2.c12
-rw-r--r--fs/ext4/extents.c2
-rw-r--r--fs/ext4/ialloc.c10
-rw-r--r--fs/ext4/inode.c8
-rw-r--r--fs/ext4/mballoc.c20
-rw-r--r--fs/ext4/namei.c26
-rw-r--r--fs/ext4/resize.c70
-rw-r--r--fs/ext4/super.c16
-rw-r--r--fs/ext4/xattr.c16
10 files changed, 97 insertions, 97 deletions
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index a080d7f5face..af5032b23c29 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -58,7 +58,7 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
58 /* If checksum is bad mark all blocks used to prevent allocation 58 /* If checksum is bad mark all blocks used to prevent allocation
59 * essentially implementing a per-group read-only flag. */ 59 * essentially implementing a per-group read-only flag. */
60 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) { 60 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
61 ext4_error(sb, __FUNCTION__, 61 ext4_error(sb, __func__,
62 "Checksum bad for group %lu\n", block_group); 62 "Checksum bad for group %lu\n", block_group);
63 gdp->bg_free_blocks_count = 0; 63 gdp->bg_free_blocks_count = 0;
64 gdp->bg_free_inodes_count = 0; 64 gdp->bg_free_inodes_count = 0;
@@ -235,7 +235,7 @@ static int ext4_valid_block_bitmap(struct super_block *sb,
235 return 1; 235 return 1;
236 236
237err_out: 237err_out:
238 ext4_error(sb, __FUNCTION__, 238 ext4_error(sb, __func__,
239 "Invalid block bitmap - " 239 "Invalid block bitmap - "
240 "block_group = %d, block = %llu", 240 "block_group = %d, block = %llu",
241 block_group, bitmap_blk); 241 block_group, bitmap_blk);
@@ -264,7 +264,7 @@ read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
264 bitmap_blk = ext4_block_bitmap(sb, desc); 264 bitmap_blk = ext4_block_bitmap(sb, desc);
265 bh = sb_getblk(sb, bitmap_blk); 265 bh = sb_getblk(sb, bitmap_blk);
266 if (unlikely(!bh)) { 266 if (unlikely(!bh)) {
267 ext4_error(sb, __FUNCTION__, 267 ext4_error(sb, __func__,
268 "Cannot read block bitmap - " 268 "Cannot read block bitmap - "
269 "block_group = %d, block_bitmap = %llu", 269 "block_group = %d, block_bitmap = %llu",
270 (int)block_group, (unsigned long long)bitmap_blk); 270 (int)block_group, (unsigned long long)bitmap_blk);
@@ -281,7 +281,7 @@ read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
281 } 281 }
282 if (bh_submit_read(bh) < 0) { 282 if (bh_submit_read(bh) < 0) {
283 put_bh(bh); 283 put_bh(bh);
284 ext4_error(sb, __FUNCTION__, 284 ext4_error(sb, __func__,
285 "Cannot read block bitmap - " 285 "Cannot read block bitmap - "
286 "block_group = %d, block_bitmap = %llu", 286 "block_group = %d, block_bitmap = %llu",
287 (int)block_group, (unsigned long long)bitmap_blk); 287 (int)block_group, (unsigned long long)bitmap_blk);
@@ -360,7 +360,7 @@ restart:
360 BUG(); 360 BUG();
361} 361}
362#define rsv_window_dump(root, verbose) \ 362#define rsv_window_dump(root, verbose) \
363 __rsv_window_dump((root), (verbose), __FUNCTION__) 363 __rsv_window_dump((root), (verbose), __func__)
364#else 364#else
365#define rsv_window_dump(root, verbose) do {} while (0) 365#define rsv_window_dump(root, verbose) do {} while (0)
366#endif 366#endif
@@ -740,7 +740,7 @@ do_more:
740 if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group), 740 if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
741 bit + i, bitmap_bh->b_data)) { 741 bit + i, bitmap_bh->b_data)) {
742 jbd_unlock_bh_state(bitmap_bh); 742 jbd_unlock_bh_state(bitmap_bh);
743 ext4_error(sb, __FUNCTION__, 743 ext4_error(sb, __func__,
744 "bit already cleared for block %llu", 744 "bit already cleared for block %llu",
745 (ext4_fsblk_t)(block + i)); 745 (ext4_fsblk_t)(block + i));
746 jbd_lock_bh_state(bitmap_bh); 746 jbd_lock_bh_state(bitmap_bh);
@@ -1796,7 +1796,7 @@ allocated:
1796 if (ext4_test_bit(grp_alloc_blk+i, 1796 if (ext4_test_bit(grp_alloc_blk+i,
1797 bh2jh(bitmap_bh)->b_committed_data)) { 1797 bh2jh(bitmap_bh)->b_committed_data)) {
1798 printk("%s: block was unexpectedly set in " 1798 printk("%s: block was unexpectedly set in "
1799 "b_committed_data\n", __FUNCTION__); 1799 "b_committed_data\n", __func__);
1800 } 1800 }
1801 } 1801 }
1802 } 1802 }
diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
index d6afe4e27340..2e6007d418dc 100644
--- a/fs/ext4/ext4_jbd2.c
+++ b/fs/ext4/ext4_jbd2.c
@@ -9,7 +9,7 @@ int __ext4_journal_get_undo_access(const char *where, handle_t *handle,
9{ 9{
10 int err = jbd2_journal_get_undo_access(handle, bh); 10 int err = jbd2_journal_get_undo_access(handle, bh);
11 if (err) 11 if (err)
12 ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 12 ext4_journal_abort_handle(where, __func__, bh, handle, err);
13 return err; 13 return err;
14} 14}
15 15
@@ -18,7 +18,7 @@ int __ext4_journal_get_write_access(const char *where, handle_t *handle,
18{ 18{
19 int err = jbd2_journal_get_write_access(handle, bh); 19 int err = jbd2_journal_get_write_access(handle, bh);
20 if (err) 20 if (err)
21 ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 21 ext4_journal_abort_handle(where, __func__, bh, handle, err);
22 return err; 22 return err;
23} 23}
24 24
@@ -27,7 +27,7 @@ int __ext4_journal_forget(const char *where, handle_t *handle,
27{ 27{
28 int err = jbd2_journal_forget(handle, bh); 28 int err = jbd2_journal_forget(handle, bh);
29 if (err) 29 if (err)
30 ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 30 ext4_journal_abort_handle(where, __func__, bh, handle, err);
31 return err; 31 return err;
32} 32}
33 33
@@ -36,7 +36,7 @@ int __ext4_journal_revoke(const char *where, handle_t *handle,
36{ 36{
37 int err = jbd2_journal_revoke(handle, blocknr, bh); 37 int err = jbd2_journal_revoke(handle, blocknr, bh);
38 if (err) 38 if (err)
39 ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 39 ext4_journal_abort_handle(where, __func__, bh, handle, err);
40 return err; 40 return err;
41} 41}
42 42
@@ -45,7 +45,7 @@ int __ext4_journal_get_create_access(const char *where,
45{ 45{
46 int err = jbd2_journal_get_create_access(handle, bh); 46 int err = jbd2_journal_get_create_access(handle, bh);
47 if (err) 47 if (err)
48 ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 48 ext4_journal_abort_handle(where, __func__, bh, handle, err);
49 return err; 49 return err;
50} 50}
51 51
@@ -54,6 +54,6 @@ int __ext4_journal_dirty_metadata(const char *where,
54{ 54{
55 int err = jbd2_journal_dirty_metadata(handle, bh); 55 int err = jbd2_journal_dirty_metadata(handle, bh);
56 if (err) 56 if (err)
57 ext4_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 57 ext4_journal_abort_handle(where, __func__, bh, handle, err);
58 return err; 58 return err;
59} 59}
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 3d5a35f373d4..1c8aab4dad23 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -308,7 +308,7 @@ corrupted:
308} 308}
309 309
310#define ext4_ext_check_header(inode, eh, depth) \ 310#define ext4_ext_check_header(inode, eh, depth) \
311 __ext4_ext_check_header(__FUNCTION__, inode, eh, depth) 311 __ext4_ext_check_header(__func__, inode, eh, depth)
312 312
313#ifdef EXT_DEBUG 313#ifdef EXT_DEBUG
314static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path) 314static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index e8d24f24f282..a86377401ff0 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -75,7 +75,7 @@ unsigned ext4_init_inode_bitmap(struct super_block *sb, struct buffer_head *bh,
75 /* If checksum is bad mark all blocks and inodes use to prevent 75 /* If checksum is bad mark all blocks and inodes use to prevent
76 * allocation, essentially implementing a per-group read-only flag. */ 76 * allocation, essentially implementing a per-group read-only flag. */
77 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) { 77 if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
78 ext4_error(sb, __FUNCTION__, "Checksum bad for group %lu\n", 78 ext4_error(sb, __func__, "Checksum bad for group %lu\n",
79 block_group); 79 block_group);
80 gdp->bg_free_blocks_count = 0; 80 gdp->bg_free_blocks_count = 0;
81 gdp->bg_free_inodes_count = 0; 81 gdp->bg_free_inodes_count = 0;
@@ -586,7 +586,7 @@ got:
586 ino++; 586 ino++;
587 if ((group == 0 && ino < EXT4_FIRST_INO(sb)) || 587 if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
588 ino > EXT4_INODES_PER_GROUP(sb)) { 588 ino > EXT4_INODES_PER_GROUP(sb)) {
589 ext4_error(sb, __FUNCTION__, 589 ext4_error(sb, __func__,
590 "reserved inode or inode > inodes count - " 590 "reserved inode or inode > inodes count - "
591 "block_group = %lu, inode=%lu", group, 591 "block_group = %lu, inode=%lu", group,
592 ino + group * EXT4_INODES_PER_GROUP(sb)); 592 ino + group * EXT4_INODES_PER_GROUP(sb));
@@ -792,7 +792,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
792 792
793 /* Error cases - e2fsck has already cleaned up for us */ 793 /* Error cases - e2fsck has already cleaned up for us */
794 if (ino > max_ino) { 794 if (ino > max_ino) {
795 ext4_warning(sb, __FUNCTION__, 795 ext4_warning(sb, __func__,
796 "bad orphan ino %lu! e2fsck was run?", ino); 796 "bad orphan ino %lu! e2fsck was run?", ino);
797 goto error; 797 goto error;
798 } 798 }
@@ -801,7 +801,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
801 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb); 801 bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
802 bitmap_bh = read_inode_bitmap(sb, block_group); 802 bitmap_bh = read_inode_bitmap(sb, block_group);
803 if (!bitmap_bh) { 803 if (!bitmap_bh) {
804 ext4_warning(sb, __FUNCTION__, 804 ext4_warning(sb, __func__,
805 "inode bitmap error for orphan %lu", ino); 805 "inode bitmap error for orphan %lu", ino);
806 goto error; 806 goto error;
807 } 807 }
@@ -826,7 +826,7 @@ iget_failed:
826 err = PTR_ERR(inode); 826 err = PTR_ERR(inode);
827 inode = NULL; 827 inode = NULL;
828bad_orphan: 828bad_orphan:
829 ext4_warning(sb, __FUNCTION__, 829 ext4_warning(sb, __func__,
830 "bad orphan inode %lu! e2fsck was run?", ino); 830 "bad orphan inode %lu! e2fsck was run?", ino);
831 printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n", 831 printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
832 bit, (unsigned long long)bitmap_bh->b_blocknr, 832 bit, (unsigned long long)bitmap_bh->b_blocknr,
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index aa0fb985b15e..bd1a391725c0 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -93,7 +93,7 @@ int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
93 BUFFER_TRACE(bh, "call ext4_journal_revoke"); 93 BUFFER_TRACE(bh, "call ext4_journal_revoke");
94 err = ext4_journal_revoke(handle, blocknr, bh); 94 err = ext4_journal_revoke(handle, blocknr, bh);
95 if (err) 95 if (err)
96 ext4_abort(inode->i_sb, __FUNCTION__, 96 ext4_abort(inode->i_sb, __func__,
97 "error %d when attempting revoke", err); 97 "error %d when attempting revoke", err);
98 BUFFER_TRACE(bh, "exit"); 98 BUFFER_TRACE(bh, "exit");
99 return err; 99 return err;
@@ -1240,7 +1240,7 @@ int ext4_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1240{ 1240{
1241 int err = jbd2_journal_dirty_data(handle, bh); 1241 int err = jbd2_journal_dirty_data(handle, bh);
1242 if (err) 1242 if (err)
1243 ext4_journal_abort_handle(__FUNCTION__, __FUNCTION__, 1243 ext4_journal_abort_handle(__func__, __func__,
1244 bh, handle, err); 1244 bh, handle, err);
1245 return err; 1245 return err;
1246} 1246}
@@ -3371,7 +3371,7 @@ int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
3371 EXT4_I(inode)->i_state |= EXT4_STATE_NO_EXPAND; 3371 EXT4_I(inode)->i_state |= EXT4_STATE_NO_EXPAND;
3372 if (mnt_count != 3372 if (mnt_count !=
3373 le16_to_cpu(sbi->s_es->s_mnt_count)) { 3373 le16_to_cpu(sbi->s_es->s_mnt_count)) {
3374 ext4_warning(inode->i_sb, __FUNCTION__, 3374 ext4_warning(inode->i_sb, __func__,
3375 "Unable to expand inode %lu. Delete" 3375 "Unable to expand inode %lu. Delete"
3376 " some EAs or run e2fsck.", 3376 " some EAs or run e2fsck.",
3377 inode->i_ino); 3377 inode->i_ino);
@@ -3412,7 +3412,7 @@ void ext4_dirty_inode(struct inode *inode)
3412 current_handle->h_transaction != handle->h_transaction) { 3412 current_handle->h_transaction != handle->h_transaction) {
3413 /* This task has a transaction open against a different fs */ 3413 /* This task has a transaction open against a different fs */
3414 printk(KERN_EMERG "%s: transactions do not match!\n", 3414 printk(KERN_EMERG "%s: transactions do not match!\n",
3415 __FUNCTION__); 3415 __func__);
3416 } else { 3416 } else {
3417 jbd_debug(5, "marking dirty. outer handle=%p\n", 3417 jbd_debug(5, "marking dirty. outer handle=%p\n",
3418 current_handle); 3418 current_handle);
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index d9136b539c1e..0b46fc0ca196 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -734,7 +734,7 @@ static void mb_free_blocks_double(struct inode *inode, struct ext4_buddy *e4b,
734 blocknr += 734 blocknr +=
735 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block); 735 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
736 736
737 ext4_error(sb, __FUNCTION__, "double-free of inode" 737 ext4_error(sb, __func__, "double-free of inode"
738 " %lu's block %llu(bit %u in group %lu)\n", 738 " %lu's block %llu(bit %u in group %lu)\n",
739 inode ? inode->i_ino : 0, blocknr, 739 inode ? inode->i_ino : 0, blocknr,
740 first + i, e4b->bd_group); 740 first + i, e4b->bd_group);
@@ -906,7 +906,7 @@ static int __mb_check_buddy(struct ext4_buddy *e4b, char *file,
906} 906}
907#undef MB_CHECK_ASSERT 907#undef MB_CHECK_ASSERT
908#define mb_check_buddy(e4b) __mb_check_buddy(e4b, \ 908#define mb_check_buddy(e4b) __mb_check_buddy(e4b, \
909 __FILE__, __FUNCTION__, __LINE__) 909 __FILE__, __func__, __LINE__)
910#else 910#else
911#define mb_check_buddy(e4b) 911#define mb_check_buddy(e4b)
912#endif 912#endif
@@ -980,7 +980,7 @@ static void ext4_mb_generate_buddy(struct super_block *sb,
980 grp->bb_fragments = fragments; 980 grp->bb_fragments = fragments;
981 981
982 if (free != grp->bb_free) { 982 if (free != grp->bb_free) {
983 ext4_error(sb, __FUNCTION__, 983 ext4_error(sb, __func__,
984 "EXT4-fs: group %lu: %u blocks in bitmap, %u in gd\n", 984 "EXT4-fs: group %lu: %u blocks in bitmap, %u in gd\n",
985 group, free, grp->bb_free); 985 group, free, grp->bb_free);
986 /* 986 /*
@@ -1366,7 +1366,7 @@ static int mb_free_blocks(struct inode *inode, struct ext4_buddy *e4b,
1366 blocknr += 1366 blocknr +=
1367 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block); 1367 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
1368 1368
1369 ext4_error(sb, __FUNCTION__, "double-free of inode" 1369 ext4_error(sb, __func__, "double-free of inode"
1370 " %lu's block %llu(bit %u in group %lu)\n", 1370 " %lu's block %llu(bit %u in group %lu)\n",
1371 inode ? inode->i_ino : 0, blocknr, block, 1371 inode ? inode->i_ino : 0, blocknr, block,
1372 e4b->bd_group); 1372 e4b->bd_group);
@@ -1847,7 +1847,7 @@ static void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
1847 * free blocks even though group info says we 1847 * free blocks even though group info says we
1848 * we have free blocks 1848 * we have free blocks
1849 */ 1849 */
1850 ext4_error(sb, __FUNCTION__, "%d free blocks as per " 1850 ext4_error(sb, __func__, "%d free blocks as per "
1851 "group info. But bitmap says 0\n", 1851 "group info. But bitmap says 0\n",
1852 free); 1852 free);
1853 break; 1853 break;
@@ -1856,7 +1856,7 @@ static void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
1856 mb_find_extent(e4b, 0, i, ac->ac_g_ex.fe_len, &ex); 1856 mb_find_extent(e4b, 0, i, ac->ac_g_ex.fe_len, &ex);
1857 BUG_ON(ex.fe_len <= 0); 1857 BUG_ON(ex.fe_len <= 0);
1858 if (free < ex.fe_len) { 1858 if (free < ex.fe_len) {
1859 ext4_error(sb, __FUNCTION__, "%d free blocks as per " 1859 ext4_error(sb, __func__, "%d free blocks as per "
1860 "group info. But got %d blocks\n", 1860 "group info. But got %d blocks\n",
1861 free, ex.fe_len); 1861 free, ex.fe_len);
1862 /* 1862 /*
@@ -3073,7 +3073,7 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
3073 in_range(block, ext4_inode_table(sb, gdp), 3073 in_range(block, ext4_inode_table(sb, gdp),
3074 EXT4_SB(sb)->s_itb_per_group)) { 3074 EXT4_SB(sb)->s_itb_per_group)) {
3075 3075
3076 ext4_error(sb, __FUNCTION__, 3076 ext4_error(sb, __func__,
3077 "Allocating block in system zone - block = %llu", 3077 "Allocating block in system zone - block = %llu",
3078 block); 3078 block);
3079 } 3079 }
@@ -3786,7 +3786,7 @@ ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
3786 pa, (unsigned long) pa->pa_lstart, 3786 pa, (unsigned long) pa->pa_lstart,
3787 (unsigned long) pa->pa_pstart, 3787 (unsigned long) pa->pa_pstart,
3788 (unsigned long) pa->pa_len); 3788 (unsigned long) pa->pa_len);
3789 ext4_error(sb, __FUNCTION__, "free %u, pa_free %u\n", 3789 ext4_error(sb, __func__, "free %u, pa_free %u\n",
3790 free, pa->pa_free); 3790 free, pa->pa_free);
3791 /* 3791 /*
3792 * pa is already deleted so we use the value obtained 3792 * pa is already deleted so we use the value obtained
@@ -4490,7 +4490,7 @@ void ext4_mb_free_blocks(handle_t *handle, struct inode *inode,
4490 if (block < le32_to_cpu(es->s_first_data_block) || 4490 if (block < le32_to_cpu(es->s_first_data_block) ||
4491 block + count < block || 4491 block + count < block ||
4492 block + count > ext4_blocks_count(es)) { 4492 block + count > ext4_blocks_count(es)) {
4493 ext4_error(sb, __FUNCTION__, 4493 ext4_error(sb, __func__,
4494 "Freeing blocks not in datazone - " 4494 "Freeing blocks not in datazone - "
4495 "block = %lu, count = %lu", block, count); 4495 "block = %lu, count = %lu", block, count);
4496 goto error_return; 4496 goto error_return;
@@ -4531,7 +4531,7 @@ do_more:
4531 in_range(block + count - 1, ext4_inode_table(sb, gdp), 4531 in_range(block + count - 1, ext4_inode_table(sb, gdp),
4532 EXT4_SB(sb)->s_itb_per_group)) { 4532 EXT4_SB(sb)->s_itb_per_group)) {
4533 4533
4534 ext4_error(sb, __FUNCTION__, 4534 ext4_error(sb, __func__,
4535 "Freeing blocks in system zone - " 4535 "Freeing blocks in system zone - "
4536 "Block = %lu, count = %lu", block, count); 4536 "Block = %lu, count = %lu", block, count);
4537 } 4537 }
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 63c33e053478..02cdaec39e21 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -353,7 +353,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
353 if (root->info.hash_version != DX_HASH_TEA && 353 if (root->info.hash_version != DX_HASH_TEA &&
354 root->info.hash_version != DX_HASH_HALF_MD4 && 354 root->info.hash_version != DX_HASH_HALF_MD4 &&
355 root->info.hash_version != DX_HASH_LEGACY) { 355 root->info.hash_version != DX_HASH_LEGACY) {
356 ext4_warning(dir->i_sb, __FUNCTION__, 356 ext4_warning(dir->i_sb, __func__,
357 "Unrecognised inode hash code %d", 357 "Unrecognised inode hash code %d",
358 root->info.hash_version); 358 root->info.hash_version);
359 brelse(bh); 359 brelse(bh);
@@ -367,7 +367,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
367 hash = hinfo->hash; 367 hash = hinfo->hash;
368 368
369 if (root->info.unused_flags & 1) { 369 if (root->info.unused_flags & 1) {
370 ext4_warning(dir->i_sb, __FUNCTION__, 370 ext4_warning(dir->i_sb, __func__,
371 "Unimplemented inode hash flags: %#06x", 371 "Unimplemented inode hash flags: %#06x",
372 root->info.unused_flags); 372 root->info.unused_flags);
373 brelse(bh); 373 brelse(bh);
@@ -376,7 +376,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
376 } 376 }
377 377
378 if ((indirect = root->info.indirect_levels) > 1) { 378 if ((indirect = root->info.indirect_levels) > 1) {
379 ext4_warning(dir->i_sb, __FUNCTION__, 379 ext4_warning(dir->i_sb, __func__,
380 "Unimplemented inode hash depth: %#06x", 380 "Unimplemented inode hash depth: %#06x",
381 root->info.indirect_levels); 381 root->info.indirect_levels);
382 brelse(bh); 382 brelse(bh);
@@ -389,7 +389,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
389 389
390 if (dx_get_limit(entries) != dx_root_limit(dir, 390 if (dx_get_limit(entries) != dx_root_limit(dir,
391 root->info.info_length)) { 391 root->info.info_length)) {
392 ext4_warning(dir->i_sb, __FUNCTION__, 392 ext4_warning(dir->i_sb, __func__,
393 "dx entry: limit != root limit"); 393 "dx entry: limit != root limit");
394 brelse(bh); 394 brelse(bh);
395 *err = ERR_BAD_DX_DIR; 395 *err = ERR_BAD_DX_DIR;
@@ -401,7 +401,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
401 { 401 {
402 count = dx_get_count(entries); 402 count = dx_get_count(entries);
403 if (!count || count > dx_get_limit(entries)) { 403 if (!count || count > dx_get_limit(entries)) {
404 ext4_warning(dir->i_sb, __FUNCTION__, 404 ext4_warning(dir->i_sb, __func__,
405 "dx entry: no count or count > limit"); 405 "dx entry: no count or count > limit");
406 brelse(bh); 406 brelse(bh);
407 *err = ERR_BAD_DX_DIR; 407 *err = ERR_BAD_DX_DIR;
@@ -446,7 +446,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
446 goto fail2; 446 goto fail2;
447 at = entries = ((struct dx_node *) bh->b_data)->entries; 447 at = entries = ((struct dx_node *) bh->b_data)->entries;
448 if (dx_get_limit(entries) != dx_node_limit (dir)) { 448 if (dx_get_limit(entries) != dx_node_limit (dir)) {
449 ext4_warning(dir->i_sb, __FUNCTION__, 449 ext4_warning(dir->i_sb, __func__,
450 "dx entry: limit != node limit"); 450 "dx entry: limit != node limit");
451 brelse(bh); 451 brelse(bh);
452 *err = ERR_BAD_DX_DIR; 452 *err = ERR_BAD_DX_DIR;
@@ -462,7 +462,7 @@ fail2:
462 } 462 }
463fail: 463fail:
464 if (*err == ERR_BAD_DX_DIR) 464 if (*err == ERR_BAD_DX_DIR)
465 ext4_warning(dir->i_sb, __FUNCTION__, 465 ext4_warning(dir->i_sb, __func__,
466 "Corrupt dir inode %ld, running e2fsck is " 466 "Corrupt dir inode %ld, running e2fsck is "
467 "recommended.", dir->i_ino); 467 "recommended.", dir->i_ino);
468 return NULL; 468 return NULL;
@@ -919,7 +919,7 @@ restart:
919 wait_on_buffer(bh); 919 wait_on_buffer(bh);
920 if (!buffer_uptodate(bh)) { 920 if (!buffer_uptodate(bh)) {
921 /* read error, skip block & hope for the best */ 921 /* read error, skip block & hope for the best */
922 ext4_error(sb, __FUNCTION__, "reading directory #%lu " 922 ext4_error(sb, __func__, "reading directory #%lu "
923 "offset %lu", dir->i_ino, 923 "offset %lu", dir->i_ino,
924 (unsigned long)block); 924 (unsigned long)block);
925 brelse(bh); 925 brelse(bh);
@@ -1012,7 +1012,7 @@ static struct buffer_head * ext4_dx_find_entry(struct dentry *dentry,
1012 retval = ext4_htree_next_block(dir, hash, frame, 1012 retval = ext4_htree_next_block(dir, hash, frame,
1013 frames, NULL); 1013 frames, NULL);
1014 if (retval < 0) { 1014 if (retval < 0) {
1015 ext4_warning(sb, __FUNCTION__, 1015 ext4_warning(sb, __func__,
1016 "error reading index page in directory #%lu", 1016 "error reading index page in directory #%lu",
1017 dir->i_ino); 1017 dir->i_ino);
1018 *err = retval; 1018 *err = retval;
@@ -1537,7 +1537,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
1537 1537
1538 if (levels && (dx_get_count(frames->entries) == 1538 if (levels && (dx_get_count(frames->entries) ==
1539 dx_get_limit(frames->entries))) { 1539 dx_get_limit(frames->entries))) {
1540 ext4_warning(sb, __FUNCTION__, 1540 ext4_warning(sb, __func__,
1541 "Directory index full!"); 1541 "Directory index full!");
1542 err = -ENOSPC; 1542 err = -ENOSPC;
1543 goto cleanup; 1543 goto cleanup;
@@ -1865,11 +1865,11 @@ static int empty_dir (struct inode * inode)
1865 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2) || 1865 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2) ||
1866 !(bh = ext4_bread (NULL, inode, 0, 0, &err))) { 1866 !(bh = ext4_bread (NULL, inode, 0, 0, &err))) {
1867 if (err) 1867 if (err)
1868 ext4_error(inode->i_sb, __FUNCTION__, 1868 ext4_error(inode->i_sb, __func__,
1869 "error %d reading directory #%lu offset 0", 1869 "error %d reading directory #%lu offset 0",
1870 err, inode->i_ino); 1870 err, inode->i_ino);
1871 else 1871 else
1872 ext4_warning(inode->i_sb, __FUNCTION__, 1872 ext4_warning(inode->i_sb, __func__,
1873 "bad directory (dir #%lu) - no data block", 1873 "bad directory (dir #%lu) - no data block",
1874 inode->i_ino); 1874 inode->i_ino);
1875 return 1; 1875 return 1;
@@ -1898,7 +1898,7 @@ static int empty_dir (struct inode * inode)
1898 offset >> EXT4_BLOCK_SIZE_BITS(sb), 0, &err); 1898 offset >> EXT4_BLOCK_SIZE_BITS(sb), 0, &err);
1899 if (!bh) { 1899 if (!bh) {
1900 if (err) 1900 if (err)
1901 ext4_error(sb, __FUNCTION__, 1901 ext4_error(sb, __func__,
1902 "error %d reading directory" 1902 "error %d reading directory"
1903 " #%lu offset %lu", 1903 " #%lu offset %lu",
1904 err, inode->i_ino, offset); 1904 err, inode->i_ino, offset);
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 728e3efa84b5..3e0f5d06f3ee 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -50,63 +50,63 @@ static int verify_group_input(struct super_block *sb,
50 50
51 ext4_get_group_no_and_offset(sb, start, NULL, &offset); 51 ext4_get_group_no_and_offset(sb, start, NULL, &offset);
52 if (group != sbi->s_groups_count) 52 if (group != sbi->s_groups_count)
53 ext4_warning(sb, __FUNCTION__, 53 ext4_warning(sb, __func__,
54 "Cannot add at group %u (only %lu groups)", 54 "Cannot add at group %u (only %lu groups)",
55 input->group, sbi->s_groups_count); 55 input->group, sbi->s_groups_count);
56 else if (offset != 0) 56 else if (offset != 0)
57 ext4_warning(sb, __FUNCTION__, "Last group not full"); 57 ext4_warning(sb, __func__, "Last group not full");
58 else if (input->reserved_blocks > input->blocks_count / 5) 58 else if (input->reserved_blocks > input->blocks_count / 5)
59 ext4_warning(sb, __FUNCTION__, "Reserved blocks too high (%u)", 59 ext4_warning(sb, __func__, "Reserved blocks too high (%u)",
60 input->reserved_blocks); 60 input->reserved_blocks);
61 else if (free_blocks_count < 0) 61 else if (free_blocks_count < 0)
62 ext4_warning(sb, __FUNCTION__, "Bad blocks count %u", 62 ext4_warning(sb, __func__, "Bad blocks count %u",
63 input->blocks_count); 63 input->blocks_count);
64 else if (!(bh = sb_bread(sb, end - 1))) 64 else if (!(bh = sb_bread(sb, end - 1)))
65 ext4_warning(sb, __FUNCTION__, 65 ext4_warning(sb, __func__,
66 "Cannot read last block (%llu)", 66 "Cannot read last block (%llu)",
67 end - 1); 67 end - 1);
68 else if (outside(input->block_bitmap, start, end)) 68 else if (outside(input->block_bitmap, start, end))
69 ext4_warning(sb, __FUNCTION__, 69 ext4_warning(sb, __func__,
70 "Block bitmap not in group (block %llu)", 70 "Block bitmap not in group (block %llu)",
71 (unsigned long long)input->block_bitmap); 71 (unsigned long long)input->block_bitmap);
72 else if (outside(input->inode_bitmap, start, end)) 72 else if (outside(input->inode_bitmap, start, end))
73 ext4_warning(sb, __FUNCTION__, 73 ext4_warning(sb, __func__,
74 "Inode bitmap not in group (block %llu)", 74 "Inode bitmap not in group (block %llu)",
75 (unsigned long long)input->inode_bitmap); 75 (unsigned long long)input->inode_bitmap);
76 else if (outside(input->inode_table, start, end) || 76 else if (outside(input->inode_table, start, end) ||
77 outside(itend - 1, start, end)) 77 outside(itend - 1, start, end))
78 ext4_warning(sb, __FUNCTION__, 78 ext4_warning(sb, __func__,
79 "Inode table not in group (blocks %llu-%llu)", 79 "Inode table not in group (blocks %llu-%llu)",
80 (unsigned long long)input->inode_table, itend - 1); 80 (unsigned long long)input->inode_table, itend - 1);
81 else if (input->inode_bitmap == input->block_bitmap) 81 else if (input->inode_bitmap == input->block_bitmap)
82 ext4_warning(sb, __FUNCTION__, 82 ext4_warning(sb, __func__,
83 "Block bitmap same as inode bitmap (%llu)", 83 "Block bitmap same as inode bitmap (%llu)",
84 (unsigned long long)input->block_bitmap); 84 (unsigned long long)input->block_bitmap);
85 else if (inside(input->block_bitmap, input->inode_table, itend)) 85 else if (inside(input->block_bitmap, input->inode_table, itend))
86 ext4_warning(sb, __FUNCTION__, 86 ext4_warning(sb, __func__,
87 "Block bitmap (%llu) in inode table (%llu-%llu)", 87 "Block bitmap (%llu) in inode table (%llu-%llu)",
88 (unsigned long long)input->block_bitmap, 88 (unsigned long long)input->block_bitmap,
89 (unsigned long long)input->inode_table, itend - 1); 89 (unsigned long long)input->inode_table, itend - 1);
90 else if (inside(input->inode_bitmap, input->inode_table, itend)) 90 else if (inside(input->inode_bitmap, input->inode_table, itend))
91 ext4_warning(sb, __FUNCTION__, 91 ext4_warning(sb, __func__,
92 "Inode bitmap (%llu) in inode table (%llu-%llu)", 92 "Inode bitmap (%llu) in inode table (%llu-%llu)",
93 (unsigned long long)input->inode_bitmap, 93 (unsigned long long)input->inode_bitmap,
94 (unsigned long long)input->inode_table, itend - 1); 94 (unsigned long long)input->inode_table, itend - 1);
95 else if (inside(input->block_bitmap, start, metaend)) 95 else if (inside(input->block_bitmap, start, metaend))
96 ext4_warning(sb, __FUNCTION__, 96 ext4_warning(sb, __func__,
97 "Block bitmap (%llu) in GDT table" 97 "Block bitmap (%llu) in GDT table"
98 " (%llu-%llu)", 98 " (%llu-%llu)",
99 (unsigned long long)input->block_bitmap, 99 (unsigned long long)input->block_bitmap,
100 start, metaend - 1); 100 start, metaend - 1);
101 else if (inside(input->inode_bitmap, start, metaend)) 101 else if (inside(input->inode_bitmap, start, metaend))
102 ext4_warning(sb, __FUNCTION__, 102 ext4_warning(sb, __func__,
103 "Inode bitmap (%llu) in GDT table" 103 "Inode bitmap (%llu) in GDT table"
104 " (%llu-%llu)", 104 " (%llu-%llu)",
105 (unsigned long long)input->inode_bitmap, 105 (unsigned long long)input->inode_bitmap,
106 start, metaend - 1); 106 start, metaend - 1);
107 else if (inside(input->inode_table, start, metaend) || 107 else if (inside(input->inode_table, start, metaend) ||
108 inside(itend - 1, start, metaend)) 108 inside(itend - 1, start, metaend))
109 ext4_warning(sb, __FUNCTION__, 109 ext4_warning(sb, __func__,
110 "Inode table (%llu-%llu) overlaps" 110 "Inode table (%llu-%llu) overlaps"
111 "GDT table (%llu-%llu)", 111 "GDT table (%llu-%llu)",
112 (unsigned long long)input->inode_table, 112 (unsigned long long)input->inode_table,
@@ -368,7 +368,7 @@ static int verify_reserved_gdb(struct super_block *sb,
368 while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) { 368 while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
369 if (le32_to_cpu(*p++) != 369 if (le32_to_cpu(*p++) !=
370 grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){ 370 grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
371 ext4_warning(sb, __FUNCTION__, 371 ext4_warning(sb, __func__,
372 "reserved GDT %llu" 372 "reserved GDT %llu"
373 " missing grp %d (%llu)", 373 " missing grp %d (%llu)",
374 blk, grp, 374 blk, grp,
@@ -424,7 +424,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
424 */ 424 */
425 if (EXT4_SB(sb)->s_sbh->b_blocknr != 425 if (EXT4_SB(sb)->s_sbh->b_blocknr !=
426 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) { 426 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
427 ext4_warning(sb, __FUNCTION__, 427 ext4_warning(sb, __func__,
428 "won't resize using backup superblock at %llu", 428 "won't resize using backup superblock at %llu",
429 (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr); 429 (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
430 return -EPERM; 430 return -EPERM;
@@ -448,7 +448,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
448 448
449 data = (__le32 *)dind->b_data; 449 data = (__le32 *)dind->b_data;
450 if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) { 450 if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
451 ext4_warning(sb, __FUNCTION__, 451 ext4_warning(sb, __func__,
452 "new group %u GDT block %llu not reserved", 452 "new group %u GDT block %llu not reserved",
453 input->group, gdblock); 453 input->group, gdblock);
454 err = -EINVAL; 454 err = -EINVAL;
@@ -472,7 +472,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
472 GFP_KERNEL); 472 GFP_KERNEL);
473 if (!n_group_desc) { 473 if (!n_group_desc) {
474 err = -ENOMEM; 474 err = -ENOMEM;
475 ext4_warning (sb, __FUNCTION__, 475 ext4_warning(sb, __func__,
476 "not enough memory for %lu groups", gdb_num + 1); 476 "not enough memory for %lu groups", gdb_num + 1);
477 goto exit_inode; 477 goto exit_inode;
478 } 478 }
@@ -570,7 +570,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
570 /* Get each reserved primary GDT block and verify it holds backups */ 570 /* Get each reserved primary GDT block and verify it holds backups */
571 for (res = 0; res < reserved_gdb; res++, blk++) { 571 for (res = 0; res < reserved_gdb; res++, blk++) {
572 if (le32_to_cpu(*data) != blk) { 572 if (le32_to_cpu(*data) != blk) {
573 ext4_warning(sb, __FUNCTION__, 573 ext4_warning(sb, __func__,
574 "reserved block %llu" 574 "reserved block %llu"
575 " not at offset %ld", 575 " not at offset %ld",
576 blk, 576 blk,
@@ -714,7 +714,7 @@ static void update_backups(struct super_block *sb,
714 */ 714 */
715exit_err: 715exit_err:
716 if (err) { 716 if (err) {
717 ext4_warning(sb, __FUNCTION__, 717 ext4_warning(sb, __func__,
718 "can't update backup for group %lu (err %d), " 718 "can't update backup for group %lu (err %d), "
719 "forcing fsck on next reboot", group, err); 719 "forcing fsck on next reboot", group, err);
720 sbi->s_mount_state &= ~EXT4_VALID_FS; 720 sbi->s_mount_state &= ~EXT4_VALID_FS;
@@ -754,33 +754,33 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
754 754
755 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb, 755 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
756 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 756 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
757 ext4_warning(sb, __FUNCTION__, 757 ext4_warning(sb, __func__,
758 "Can't resize non-sparse filesystem further"); 758 "Can't resize non-sparse filesystem further");
759 return -EPERM; 759 return -EPERM;
760 } 760 }
761 761
762 if (ext4_blocks_count(es) + input->blocks_count < 762 if (ext4_blocks_count(es) + input->blocks_count <
763 ext4_blocks_count(es)) { 763 ext4_blocks_count(es)) {
764 ext4_warning(sb, __FUNCTION__, "blocks_count overflow\n"); 764 ext4_warning(sb, __func__, "blocks_count overflow\n");
765 return -EINVAL; 765 return -EINVAL;
766 } 766 }
767 767
768 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < 768 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
769 le32_to_cpu(es->s_inodes_count)) { 769 le32_to_cpu(es->s_inodes_count)) {
770 ext4_warning(sb, __FUNCTION__, "inodes_count overflow\n"); 770 ext4_warning(sb, __func__, "inodes_count overflow\n");
771 return -EINVAL; 771 return -EINVAL;
772 } 772 }
773 773
774 if (reserved_gdb || gdb_off == 0) { 774 if (reserved_gdb || gdb_off == 0) {
775 if (!EXT4_HAS_COMPAT_FEATURE(sb, 775 if (!EXT4_HAS_COMPAT_FEATURE(sb,
776 EXT4_FEATURE_COMPAT_RESIZE_INODE)){ 776 EXT4_FEATURE_COMPAT_RESIZE_INODE)){
777 ext4_warning(sb, __FUNCTION__, 777 ext4_warning(sb, __func__,
778 "No reserved GDT blocks, can't resize"); 778 "No reserved GDT blocks, can't resize");
779 return -EPERM; 779 return -EPERM;
780 } 780 }
781 inode = ext4_iget(sb, EXT4_RESIZE_INO); 781 inode = ext4_iget(sb, EXT4_RESIZE_INO);
782 if (IS_ERR(inode)) { 782 if (IS_ERR(inode)) {
783 ext4_warning(sb, __FUNCTION__, 783 ext4_warning(sb, __func__,
784 "Error opening resize inode"); 784 "Error opening resize inode");
785 return PTR_ERR(inode); 785 return PTR_ERR(inode);
786 } 786 }
@@ -809,7 +809,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
809 809
810 lock_super(sb); 810 lock_super(sb);
811 if (input->group != sbi->s_groups_count) { 811 if (input->group != sbi->s_groups_count) {
812 ext4_warning(sb, __FUNCTION__, 812 ext4_warning(sb, __func__,
813 "multiple resizers run on filesystem!"); 813 "multiple resizers run on filesystem!");
814 err = -EBUSY; 814 err = -EBUSY;
815 goto exit_journal; 815 goto exit_journal;
@@ -975,13 +975,13 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
975 " too large to resize to %llu blocks safely\n", 975 " too large to resize to %llu blocks safely\n",
976 sb->s_id, n_blocks_count); 976 sb->s_id, n_blocks_count);
977 if (sizeof(sector_t) < 8) 977 if (sizeof(sector_t) < 8)
978 ext4_warning(sb, __FUNCTION__, 978 ext4_warning(sb, __func__,
979 "CONFIG_LBD not enabled\n"); 979 "CONFIG_LBD not enabled\n");
980 return -EINVAL; 980 return -EINVAL;
981 } 981 }
982 982
983 if (n_blocks_count < o_blocks_count) { 983 if (n_blocks_count < o_blocks_count) {
984 ext4_warning(sb, __FUNCTION__, 984 ext4_warning(sb, __func__,
985 "can't shrink FS - resize aborted"); 985 "can't shrink FS - resize aborted");
986 return -EBUSY; 986 return -EBUSY;
987 } 987 }
@@ -990,7 +990,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
990 ext4_get_group_no_and_offset(sb, o_blocks_count, NULL, &last); 990 ext4_get_group_no_and_offset(sb, o_blocks_count, NULL, &last);
991 991
992 if (last == 0) { 992 if (last == 0) {
993 ext4_warning(sb, __FUNCTION__, 993 ext4_warning(sb, __func__,
994 "need to use ext2online to resize further"); 994 "need to use ext2online to resize further");
995 return -EPERM; 995 return -EPERM;
996 } 996 }
@@ -998,7 +998,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
998 add = EXT4_BLOCKS_PER_GROUP(sb) - last; 998 add = EXT4_BLOCKS_PER_GROUP(sb) - last;
999 999
1000 if (o_blocks_count + add < o_blocks_count) { 1000 if (o_blocks_count + add < o_blocks_count) {
1001 ext4_warning(sb, __FUNCTION__, "blocks_count overflow"); 1001 ext4_warning(sb, __func__, "blocks_count overflow");
1002 return -EINVAL; 1002 return -EINVAL;
1003 } 1003 }
1004 1004
@@ -1006,7 +1006,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
1006 add = n_blocks_count - o_blocks_count; 1006 add = n_blocks_count - o_blocks_count;
1007 1007
1008 if (o_blocks_count + add < n_blocks_count) 1008 if (o_blocks_count + add < n_blocks_count)
1009 ext4_warning(sb, __FUNCTION__, 1009 ext4_warning(sb, __func__,
1010 "will only finish group (%llu" 1010 "will only finish group (%llu"
1011 " blocks, %u new)", 1011 " blocks, %u new)",
1012 o_blocks_count + add, add); 1012 o_blocks_count + add, add);
@@ -1014,7 +1014,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
1014 /* See if the device is actually as big as what was requested */ 1014 /* See if the device is actually as big as what was requested */
1015 bh = sb_bread(sb, o_blocks_count + add -1); 1015 bh = sb_bread(sb, o_blocks_count + add -1);
1016 if (!bh) { 1016 if (!bh) {
1017 ext4_warning(sb, __FUNCTION__, 1017 ext4_warning(sb, __func__,
1018 "can't read last block, resize aborted"); 1018 "can't read last block, resize aborted");
1019 return -ENOSPC; 1019 return -ENOSPC;
1020 } 1020 }
@@ -1026,13 +1026,13 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
1026 handle = ext4_journal_start_sb(sb, 3); 1026 handle = ext4_journal_start_sb(sb, 3);
1027 if (IS_ERR(handle)) { 1027 if (IS_ERR(handle)) {
1028 err = PTR_ERR(handle); 1028 err = PTR_ERR(handle);
1029 ext4_warning(sb, __FUNCTION__, "error %d on journal start",err); 1029 ext4_warning(sb, __func__, "error %d on journal start", err);
1030 goto exit_put; 1030 goto exit_put;
1031 } 1031 }
1032 1032
1033 lock_super(sb); 1033 lock_super(sb);
1034 if (o_blocks_count != ext4_blocks_count(es)) { 1034 if (o_blocks_count != ext4_blocks_count(es)) {
1035 ext4_warning(sb, __FUNCTION__, 1035 ext4_warning(sb, __func__,
1036 "multiple resizers run on filesystem!"); 1036 "multiple resizers run on filesystem!");
1037 unlock_super(sb); 1037 unlock_super(sb);
1038 ext4_journal_stop(handle); 1038 ext4_journal_stop(handle);
@@ -1042,7 +1042,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
1042 1042
1043 if ((err = ext4_journal_get_write_access(handle, 1043 if ((err = ext4_journal_get_write_access(handle,
1044 EXT4_SB(sb)->s_sbh))) { 1044 EXT4_SB(sb)->s_sbh))) {
1045 ext4_warning(sb, __FUNCTION__, 1045 ext4_warning(sb, __func__,
1046 "error %d on journal write access", err); 1046 "error %d on journal write access", err);
1047 unlock_super(sb); 1047 unlock_super(sb);
1048 ext4_journal_stop(handle); 1048 ext4_journal_stop(handle);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 01d163964e69..93a7e746f425 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -135,7 +135,7 @@ handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
135 * take the FS itself readonly cleanly. */ 135 * take the FS itself readonly cleanly. */
136 journal = EXT4_SB(sb)->s_journal; 136 journal = EXT4_SB(sb)->s_journal;
137 if (is_journal_aborted(journal)) { 137 if (is_journal_aborted(journal)) {
138 ext4_abort(sb, __FUNCTION__, 138 ext4_abort(sb, __func__,
139 "Detected aborted journal"); 139 "Detected aborted journal");
140 return ERR_PTR(-EROFS); 140 return ERR_PTR(-EROFS);
141 } 141 }
@@ -355,7 +355,7 @@ void ext4_update_dynamic_rev(struct super_block *sb)
355 if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV) 355 if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
356 return; 356 return;
357 357
358 ext4_warning(sb, __FUNCTION__, 358 ext4_warning(sb, __func__,
359 "updating to rev %d because of new feature flag, " 359 "updating to rev %d because of new feature flag, "
360 "running e2fsck is recommended", 360 "running e2fsck is recommended",
361 EXT4_DYNAMIC_REV); 361 EXT4_DYNAMIC_REV);
@@ -1511,7 +1511,7 @@ static int ext4_check_descriptors(struct super_block *sb)
1511 return 0; 1511 return 0;
1512 } 1512 }
1513 if (!ext4_group_desc_csum_verify(sbi, i, gdp)) { 1513 if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
1514 ext4_error(sb, __FUNCTION__, 1514 ext4_error(sb, __func__,
1515 "Checksum for group %lu failed (%u!=%u)\n", 1515 "Checksum for group %lu failed (%u!=%u)\n",
1516 i, le16_to_cpu(ext4_group_desc_csum(sbi, i, 1516 i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
1517 gdp)), le16_to_cpu(gdp->bg_checksum)); 1517 gdp)), le16_to_cpu(gdp->bg_checksum));
@@ -1605,7 +1605,7 @@ static void ext4_orphan_cleanup (struct super_block * sb,
1605 if (inode->i_nlink) { 1605 if (inode->i_nlink) {
1606 printk(KERN_DEBUG 1606 printk(KERN_DEBUG
1607 "%s: truncating inode %lu to %Ld bytes\n", 1607 "%s: truncating inode %lu to %Ld bytes\n",
1608 __FUNCTION__, inode->i_ino, inode->i_size); 1608 __func__, inode->i_ino, inode->i_size);
1609 jbd_debug(2, "truncating inode %lu to %Ld bytes\n", 1609 jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
1610 inode->i_ino, inode->i_size); 1610 inode->i_ino, inode->i_size);
1611 ext4_truncate(inode); 1611 ext4_truncate(inode);
@@ -1613,7 +1613,7 @@ static void ext4_orphan_cleanup (struct super_block * sb,
1613 } else { 1613 } else {
1614 printk(KERN_DEBUG 1614 printk(KERN_DEBUG
1615 "%s: deleting unreferenced inode %lu\n", 1615 "%s: deleting unreferenced inode %lu\n",
1616 __FUNCTION__, inode->i_ino); 1616 __func__, inode->i_ino);
1617 jbd_debug(2, "deleting unreferenced inode %lu\n", 1617 jbd_debug(2, "deleting unreferenced inode %lu\n",
1618 inode->i_ino); 1618 inode->i_ino);
1619 nr_orphans++; 1619 nr_orphans++;
@@ -2699,9 +2699,9 @@ static void ext4_clear_journal_err(struct super_block * sb,
2699 char nbuf[16]; 2699 char nbuf[16];
2700 2700
2701 errstr = ext4_decode_error(sb, j_errno, nbuf); 2701 errstr = ext4_decode_error(sb, j_errno, nbuf);
2702 ext4_warning(sb, __FUNCTION__, "Filesystem error recorded " 2702 ext4_warning(sb, __func__, "Filesystem error recorded "
2703 "from previous mount: %s", errstr); 2703 "from previous mount: %s", errstr);
2704 ext4_warning(sb, __FUNCTION__, "Marking fs in need of " 2704 ext4_warning(sb, __func__, "Marking fs in need of "
2705 "filesystem check."); 2705 "filesystem check.");
2706 2706
2707 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS; 2707 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
@@ -2828,7 +2828,7 @@ static int ext4_remount (struct super_block * sb, int * flags, char * data)
2828 } 2828 }
2829 2829
2830 if (sbi->s_mount_opt & EXT4_MOUNT_ABORT) 2830 if (sbi->s_mount_opt & EXT4_MOUNT_ABORT)
2831 ext4_abort(sb, __FUNCTION__, "Abort forced by user"); 2831 ext4_abort(sb, __func__, "Abort forced by user");
2832 2832
2833 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 2833 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2834 ((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0); 2834 ((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 739930427b8a..f56598df6880 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -227,7 +227,7 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
227 ea_bdebug(bh, "b_count=%d, refcount=%d", 227 ea_bdebug(bh, "b_count=%d, refcount=%d",
228 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount)); 228 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
229 if (ext4_xattr_check_block(bh)) { 229 if (ext4_xattr_check_block(bh)) {
230bad_block: ext4_error(inode->i_sb, __FUNCTION__, 230bad_block: ext4_error(inode->i_sb, __func__,
231 "inode %lu: bad block %llu", inode->i_ino, 231 "inode %lu: bad block %llu", inode->i_ino,
232 EXT4_I(inode)->i_file_acl); 232 EXT4_I(inode)->i_file_acl);
233 error = -EIO; 233 error = -EIO;
@@ -369,7 +369,7 @@ ext4_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
369 ea_bdebug(bh, "b_count=%d, refcount=%d", 369 ea_bdebug(bh, "b_count=%d, refcount=%d",
370 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount)); 370 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
371 if (ext4_xattr_check_block(bh)) { 371 if (ext4_xattr_check_block(bh)) {
372 ext4_error(inode->i_sb, __FUNCTION__, 372 ext4_error(inode->i_sb, __func__,
373 "inode %lu: bad block %llu", inode->i_ino, 373 "inode %lu: bad block %llu", inode->i_ino,
374 EXT4_I(inode)->i_file_acl); 374 EXT4_I(inode)->i_file_acl);
375 error = -EIO; 375 error = -EIO;
@@ -661,7 +661,7 @@ ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
661 atomic_read(&(bs->bh->b_count)), 661 atomic_read(&(bs->bh->b_count)),
662 le32_to_cpu(BHDR(bs->bh)->h_refcount)); 662 le32_to_cpu(BHDR(bs->bh)->h_refcount));
663 if (ext4_xattr_check_block(bs->bh)) { 663 if (ext4_xattr_check_block(bs->bh)) {
664 ext4_error(sb, __FUNCTION__, 664 ext4_error(sb, __func__,
665 "inode %lu: bad block %llu", inode->i_ino, 665 "inode %lu: bad block %llu", inode->i_ino,
666 EXT4_I(inode)->i_file_acl); 666 EXT4_I(inode)->i_file_acl);
667 error = -EIO; 667 error = -EIO;
@@ -861,7 +861,7 @@ cleanup_dquot:
861 goto cleanup; 861 goto cleanup;
862 862
863bad_block: 863bad_block:
864 ext4_error(inode->i_sb, __FUNCTION__, 864 ext4_error(inode->i_sb, __func__,
865 "inode %lu: bad block %llu", inode->i_ino, 865 "inode %lu: bad block %llu", inode->i_ino,
866 EXT4_I(inode)->i_file_acl); 866 EXT4_I(inode)->i_file_acl);
867 goto cleanup; 867 goto cleanup;
@@ -1164,7 +1164,7 @@ retry:
1164 if (!bh) 1164 if (!bh)
1165 goto cleanup; 1165 goto cleanup;
1166 if (ext4_xattr_check_block(bh)) { 1166 if (ext4_xattr_check_block(bh)) {
1167 ext4_error(inode->i_sb, __FUNCTION__, 1167 ext4_error(inode->i_sb, __func__,
1168 "inode %lu: bad block %llu", inode->i_ino, 1168 "inode %lu: bad block %llu", inode->i_ino,
1169 EXT4_I(inode)->i_file_acl); 1169 EXT4_I(inode)->i_file_acl);
1170 error = -EIO; 1170 error = -EIO;
@@ -1339,14 +1339,14 @@ ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
1339 goto cleanup; 1339 goto cleanup;
1340 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); 1340 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl);
1341 if (!bh) { 1341 if (!bh) {
1342 ext4_error(inode->i_sb, __FUNCTION__, 1342 ext4_error(inode->i_sb, __func__,
1343 "inode %lu: block %llu read error", inode->i_ino, 1343 "inode %lu: block %llu read error", inode->i_ino,
1344 EXT4_I(inode)->i_file_acl); 1344 EXT4_I(inode)->i_file_acl);
1345 goto cleanup; 1345 goto cleanup;
1346 } 1346 }
1347 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) || 1347 if (BHDR(bh)->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC) ||
1348 BHDR(bh)->h_blocks != cpu_to_le32(1)) { 1348 BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1349 ext4_error(inode->i_sb, __FUNCTION__, 1349 ext4_error(inode->i_sb, __func__,
1350 "inode %lu: bad block %llu", inode->i_ino, 1350 "inode %lu: bad block %llu", inode->i_ino,
1351 EXT4_I(inode)->i_file_acl); 1351 EXT4_I(inode)->i_file_acl);
1352 goto cleanup; 1352 goto cleanup;
@@ -1473,7 +1473,7 @@ again:
1473 } 1473 }
1474 bh = sb_bread(inode->i_sb, ce->e_block); 1474 bh = sb_bread(inode->i_sb, ce->e_block);
1475 if (!bh) { 1475 if (!bh) {
1476 ext4_error(inode->i_sb, __FUNCTION__, 1476 ext4_error(inode->i_sb, __func__,
1477 "inode %lu: block %lu read error", 1477 "inode %lu: block %lu read error",
1478 inode->i_ino, (unsigned long) ce->e_block); 1478 inode->i_ino, (unsigned long) ce->e_block);
1479 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >= 1479 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=