aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorHarvey Harrison <harvey.harrison@gmail.com>2008-04-28 05:16:15 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2008-04-28 11:58:45 -0400
commite05b6b524bd5c5c2bae1b64a7cbe08d46d57a6fe (patch)
treee5b5a7dbc57ccf8f6e425b7cb77249fdc534baca
parentfa1ff1e02fee908dfdc3f92902d39acc38041e4c (diff)
ext3: 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: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat
-rw-r--r--fs/ext3/balloc.c12
-rw-r--r--fs/ext3/ext3_jbd.c12
-rw-r--r--fs/ext3/ialloc.c6
-rw-r--r--fs/ext3/inode.c6
-rw-r--r--fs/ext3/namei.c26
-rw-r--r--fs/ext3/resize.c70
-rw-r--r--fs/ext3/super.c14
-rw-r--r--fs/ext3/xattr.c14
8 files changed, 80 insertions, 80 deletions
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index 731fbc0f1291..92fd0338a6eb 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -117,7 +117,7 @@ static int ext3_valid_block_bitmap(struct super_block *sb,
117 return 1; 117 return 1;
118 118
119err_out: 119err_out:
120 ext3_error(sb, __FUNCTION__, 120 ext3_error(sb, __func__,
121 "Invalid block bitmap - " 121 "Invalid block bitmap - "
122 "block_group = %d, block = %lu", 122 "block_group = %d, block = %lu",
123 block_group, bitmap_blk); 123 block_group, bitmap_blk);
@@ -147,7 +147,7 @@ read_block_bitmap(struct super_block *sb, unsigned int block_group)
147 bitmap_blk = le32_to_cpu(desc->bg_block_bitmap); 147 bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
148 bh = sb_getblk(sb, bitmap_blk); 148 bh = sb_getblk(sb, bitmap_blk);
149 if (unlikely(!bh)) { 149 if (unlikely(!bh)) {
150 ext3_error(sb, __FUNCTION__, 150 ext3_error(sb, __func__,
151 "Cannot read block bitmap - " 151 "Cannot read block bitmap - "
152 "block_group = %d, block_bitmap = %u", 152 "block_group = %d, block_bitmap = %u",
153 block_group, le32_to_cpu(desc->bg_block_bitmap)); 153 block_group, le32_to_cpu(desc->bg_block_bitmap));
@@ -158,7 +158,7 @@ read_block_bitmap(struct super_block *sb, unsigned int block_group)
158 158
159 if (bh_submit_read(bh) < 0) { 159 if (bh_submit_read(bh) < 0) {
160 brelse(bh); 160 brelse(bh);
161 ext3_error(sb, __FUNCTION__, 161 ext3_error(sb, __func__,
162 "Cannot read block bitmap - " 162 "Cannot read block bitmap - "
163 "block_group = %d, block_bitmap = %u", 163 "block_group = %d, block_bitmap = %u",
164 block_group, le32_to_cpu(desc->bg_block_bitmap)); 164 block_group, le32_to_cpu(desc->bg_block_bitmap));
@@ -236,7 +236,7 @@ restart:
236 BUG_ON(bad); 236 BUG_ON(bad);
237} 237}
238#define rsv_window_dump(root, verbose) \ 238#define rsv_window_dump(root, verbose) \
239 __rsv_window_dump((root), (verbose), __FUNCTION__) 239 __rsv_window_dump((root), (verbose), __func__)
240#else 240#else
241#define rsv_window_dump(root, verbose) do {} while (0) 241#define rsv_window_dump(root, verbose) do {} while (0)
242#endif 242#endif
@@ -618,7 +618,7 @@ do_more:
618 if (!ext3_clear_bit_atomic(sb_bgl_lock(sbi, block_group), 618 if (!ext3_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
619 bit + i, bitmap_bh->b_data)) { 619 bit + i, bitmap_bh->b_data)) {
620 jbd_unlock_bh_state(bitmap_bh); 620 jbd_unlock_bh_state(bitmap_bh);
621 ext3_error(sb, __FUNCTION__, 621 ext3_error(sb, __func__,
622 "bit already cleared for block "E3FSBLK, 622 "bit already cleared for block "E3FSBLK,
623 block + i); 623 block + i);
624 jbd_lock_bh_state(bitmap_bh); 624 jbd_lock_bh_state(bitmap_bh);
@@ -1672,7 +1672,7 @@ allocated:
1672 if (ext3_test_bit(grp_alloc_blk+i, 1672 if (ext3_test_bit(grp_alloc_blk+i,
1673 bh2jh(bitmap_bh)->b_committed_data)) { 1673 bh2jh(bitmap_bh)->b_committed_data)) {
1674 printk("%s: block was unexpectedly set in " 1674 printk("%s: block was unexpectedly set in "
1675 "b_committed_data\n", __FUNCTION__); 1675 "b_committed_data\n", __func__);
1676 } 1676 }
1677 } 1677 }
1678 } 1678 }
diff --git a/fs/ext3/ext3_jbd.c b/fs/ext3/ext3_jbd.c
index e1f91fd26a93..d401f148d74d 100644
--- a/fs/ext3/ext3_jbd.c
+++ b/fs/ext3/ext3_jbd.c
@@ -9,7 +9,7 @@ int __ext3_journal_get_undo_access(const char *where, handle_t *handle,
9{ 9{
10 int err = journal_get_undo_access(handle, bh); 10 int err = journal_get_undo_access(handle, bh);
11 if (err) 11 if (err)
12 ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 12 ext3_journal_abort_handle(where, __func__, bh, handle,err);
13 return err; 13 return err;
14} 14}
15 15
@@ -18,7 +18,7 @@ int __ext3_journal_get_write_access(const char *where, handle_t *handle,
18{ 18{
19 int err = journal_get_write_access(handle, bh); 19 int err = journal_get_write_access(handle, bh);
20 if (err) 20 if (err)
21 ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 21 ext3_journal_abort_handle(where, __func__, bh, handle,err);
22 return err; 22 return err;
23} 23}
24 24
@@ -27,7 +27,7 @@ int __ext3_journal_forget(const char *where, handle_t *handle,
27{ 27{
28 int err = journal_forget(handle, bh); 28 int err = journal_forget(handle, bh);
29 if (err) 29 if (err)
30 ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 30 ext3_journal_abort_handle(where, __func__, bh, handle,err);
31 return err; 31 return err;
32} 32}
33 33
@@ -36,7 +36,7 @@ int __ext3_journal_revoke(const char *where, handle_t *handle,
36{ 36{
37 int err = journal_revoke(handle, blocknr, bh); 37 int err = journal_revoke(handle, blocknr, bh);
38 if (err) 38 if (err)
39 ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 39 ext3_journal_abort_handle(where, __func__, bh, handle,err);
40 return err; 40 return err;
41} 41}
42 42
@@ -45,7 +45,7 @@ int __ext3_journal_get_create_access(const char *where,
45{ 45{
46 int err = journal_get_create_access(handle, bh); 46 int err = journal_get_create_access(handle, bh);
47 if (err) 47 if (err)
48 ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 48 ext3_journal_abort_handle(where, __func__, bh, handle,err);
49 return err; 49 return err;
50} 50}
51 51
@@ -54,6 +54,6 @@ int __ext3_journal_dirty_metadata(const char *where,
54{ 54{
55 int err = journal_dirty_metadata(handle, bh); 55 int err = journal_dirty_metadata(handle, bh);
56 if (err) 56 if (err)
57 ext3_journal_abort_handle(where, __FUNCTION__, bh, handle,err); 57 ext3_journal_abort_handle(where, __func__, bh, handle,err);
58 return err; 58 return err;
59} 59}
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index 96dd5573e49b..77126821b2e9 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -644,7 +644,7 @@ struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
644 644
645 /* Error cases - e2fsck has already cleaned up for us */ 645 /* Error cases - e2fsck has already cleaned up for us */
646 if (ino > max_ino) { 646 if (ino > max_ino) {
647 ext3_warning(sb, __FUNCTION__, 647 ext3_warning(sb, __func__,
648 "bad orphan ino %lu! e2fsck was run?", ino); 648 "bad orphan ino %lu! e2fsck was run?", ino);
649 goto error; 649 goto error;
650 } 650 }
@@ -653,7 +653,7 @@ struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
653 bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb); 653 bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
654 bitmap_bh = read_inode_bitmap(sb, block_group); 654 bitmap_bh = read_inode_bitmap(sb, block_group);
655 if (!bitmap_bh) { 655 if (!bitmap_bh) {
656 ext3_warning(sb, __FUNCTION__, 656 ext3_warning(sb, __func__,
657 "inode bitmap error for orphan %lu", ino); 657 "inode bitmap error for orphan %lu", ino);
658 goto error; 658 goto error;
659 } 659 }
@@ -678,7 +678,7 @@ iget_failed:
678 err = PTR_ERR(inode); 678 err = PTR_ERR(inode);
679 inode = NULL; 679 inode = NULL;
680bad_orphan: 680bad_orphan:
681 ext3_warning(sb, __FUNCTION__, 681 ext3_warning(sb, __func__,
682 "bad orphan inode %lu! e2fsck was run?", ino); 682 "bad orphan inode %lu! e2fsck was run?", ino);
683 printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n", 683 printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%llu) = %d\n",
684 bit, (unsigned long long)bitmap_bh->b_blocknr, 684 bit, (unsigned long long)bitmap_bh->b_blocknr,
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index e2acbc7a3c3f..cc47b76091bf 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -95,7 +95,7 @@ int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
95 BUFFER_TRACE(bh, "call ext3_journal_revoke"); 95 BUFFER_TRACE(bh, "call ext3_journal_revoke");
96 err = ext3_journal_revoke(handle, blocknr, bh); 96 err = ext3_journal_revoke(handle, blocknr, bh);
97 if (err) 97 if (err)
98 ext3_abort(inode->i_sb, __FUNCTION__, 98 ext3_abort(inode->i_sb, __func__,
99 "error %d when attempting revoke", err); 99 "error %d when attempting revoke", err);
100 BUFFER_TRACE(bh, "exit"); 100 BUFFER_TRACE(bh, "exit");
101 return err; 101 return err;
@@ -1190,7 +1190,7 @@ int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1190{ 1190{
1191 int err = journal_dirty_data(handle, bh); 1191 int err = journal_dirty_data(handle, bh);
1192 if (err) 1192 if (err)
1193 ext3_journal_abort_handle(__FUNCTION__, __FUNCTION__, 1193 ext3_journal_abort_handle(__func__, __func__,
1194 bh, handle, err); 1194 bh, handle, err);
1195 return err; 1195 return err;
1196} 1196}
@@ -3201,7 +3201,7 @@ void ext3_dirty_inode(struct inode *inode)
3201 current_handle->h_transaction != handle->h_transaction) { 3201 current_handle->h_transaction != handle->h_transaction) {
3202 /* This task has a transaction open against a different fs */ 3202 /* This task has a transaction open against a different fs */
3203 printk(KERN_EMERG "%s: transactions do not match!\n", 3203 printk(KERN_EMERG "%s: transactions do not match!\n",
3204 __FUNCTION__); 3204 __func__);
3205 } else { 3205 } else {
3206 jbd_debug(5, "marking dirty. outer handle=%p\n", 3206 jbd_debug(5, "marking dirty. outer handle=%p\n",
3207 current_handle); 3207 current_handle);
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 1a106572d63e..0b8cf80154f1 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -361,7 +361,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
361 if (root->info.hash_version != DX_HASH_TEA && 361 if (root->info.hash_version != DX_HASH_TEA &&
362 root->info.hash_version != DX_HASH_HALF_MD4 && 362 root->info.hash_version != DX_HASH_HALF_MD4 &&
363 root->info.hash_version != DX_HASH_LEGACY) { 363 root->info.hash_version != DX_HASH_LEGACY) {
364 ext3_warning(dir->i_sb, __FUNCTION__, 364 ext3_warning(dir->i_sb, __func__,
365 "Unrecognised inode hash code %d", 365 "Unrecognised inode hash code %d",
366 root->info.hash_version); 366 root->info.hash_version);
367 brelse(bh); 367 brelse(bh);
@@ -375,7 +375,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
375 hash = hinfo->hash; 375 hash = hinfo->hash;
376 376
377 if (root->info.unused_flags & 1) { 377 if (root->info.unused_flags & 1) {
378 ext3_warning(dir->i_sb, __FUNCTION__, 378 ext3_warning(dir->i_sb, __func__,
379 "Unimplemented inode hash flags: %#06x", 379 "Unimplemented inode hash flags: %#06x",
380 root->info.unused_flags); 380 root->info.unused_flags);
381 brelse(bh); 381 brelse(bh);
@@ -384,7 +384,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
384 } 384 }
385 385
386 if ((indirect = root->info.indirect_levels) > 1) { 386 if ((indirect = root->info.indirect_levels) > 1) {
387 ext3_warning(dir->i_sb, __FUNCTION__, 387 ext3_warning(dir->i_sb, __func__,
388 "Unimplemented inode hash depth: %#06x", 388 "Unimplemented inode hash depth: %#06x",
389 root->info.indirect_levels); 389 root->info.indirect_levels);
390 brelse(bh); 390 brelse(bh);
@@ -397,7 +397,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
397 397
398 if (dx_get_limit(entries) != dx_root_limit(dir, 398 if (dx_get_limit(entries) != dx_root_limit(dir,
399 root->info.info_length)) { 399 root->info.info_length)) {
400 ext3_warning(dir->i_sb, __FUNCTION__, 400 ext3_warning(dir->i_sb, __func__,
401 "dx entry: limit != root limit"); 401 "dx entry: limit != root limit");
402 brelse(bh); 402 brelse(bh);
403 *err = ERR_BAD_DX_DIR; 403 *err = ERR_BAD_DX_DIR;
@@ -409,7 +409,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
409 { 409 {
410 count = dx_get_count(entries); 410 count = dx_get_count(entries);
411 if (!count || count > dx_get_limit(entries)) { 411 if (!count || count > dx_get_limit(entries)) {
412 ext3_warning(dir->i_sb, __FUNCTION__, 412 ext3_warning(dir->i_sb, __func__,
413 "dx entry: no count or count > limit"); 413 "dx entry: no count or count > limit");
414 brelse(bh); 414 brelse(bh);
415 *err = ERR_BAD_DX_DIR; 415 *err = ERR_BAD_DX_DIR;
@@ -454,7 +454,7 @@ dx_probe(struct dentry *dentry, struct inode *dir,
454 goto fail2; 454 goto fail2;
455 at = entries = ((struct dx_node *) bh->b_data)->entries; 455 at = entries = ((struct dx_node *) bh->b_data)->entries;
456 if (dx_get_limit(entries) != dx_node_limit (dir)) { 456 if (dx_get_limit(entries) != dx_node_limit (dir)) {
457 ext3_warning(dir->i_sb, __FUNCTION__, 457 ext3_warning(dir->i_sb, __func__,
458 "dx entry: limit != node limit"); 458 "dx entry: limit != node limit");
459 brelse(bh); 459 brelse(bh);
460 *err = ERR_BAD_DX_DIR; 460 *err = ERR_BAD_DX_DIR;
@@ -470,7 +470,7 @@ fail2:
470 } 470 }
471fail: 471fail:
472 if (*err == ERR_BAD_DX_DIR) 472 if (*err == ERR_BAD_DX_DIR)
473 ext3_warning(dir->i_sb, __FUNCTION__, 473 ext3_warning(dir->i_sb, __func__,
474 "Corrupt dir inode %ld, running e2fsck is " 474 "Corrupt dir inode %ld, running e2fsck is "
475 "recommended.", dir->i_ino); 475 "recommended.", dir->i_ino);
476 return NULL; 476 return NULL;
@@ -918,7 +918,7 @@ restart:
918 wait_on_buffer(bh); 918 wait_on_buffer(bh);
919 if (!buffer_uptodate(bh)) { 919 if (!buffer_uptodate(bh)) {
920 /* read error, skip block & hope for the best */ 920 /* read error, skip block & hope for the best */
921 ext3_error(sb, __FUNCTION__, "reading directory #%lu " 921 ext3_error(sb, __func__, "reading directory #%lu "
922 "offset %lu", dir->i_ino, block); 922 "offset %lu", dir->i_ino, block);
923 brelse(bh); 923 brelse(bh);
924 goto next; 924 goto next;
@@ -1010,7 +1010,7 @@ static struct buffer_head * ext3_dx_find_entry(struct dentry *dentry,
1010 retval = ext3_htree_next_block(dir, hash, frame, 1010 retval = ext3_htree_next_block(dir, hash, frame,
1011 frames, NULL); 1011 frames, NULL);
1012 if (retval < 0) { 1012 if (retval < 0) {
1013 ext3_warning(sb, __FUNCTION__, 1013 ext3_warning(sb, __func__,
1014 "error reading index page in directory #%lu", 1014 "error reading index page in directory #%lu",
1015 dir->i_ino); 1015 dir->i_ino);
1016 *err = retval; 1016 *err = retval;
@@ -1535,7 +1535,7 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
1535 1535
1536 if (levels && (dx_get_count(frames->entries) == 1536 if (levels && (dx_get_count(frames->entries) ==
1537 dx_get_limit(frames->entries))) { 1537 dx_get_limit(frames->entries))) {
1538 ext3_warning(sb, __FUNCTION__, 1538 ext3_warning(sb, __func__,
1539 "Directory index full!"); 1539 "Directory index full!");
1540 err = -ENOSPC; 1540 err = -ENOSPC;
1541 goto cleanup; 1541 goto cleanup;
@@ -1837,11 +1837,11 @@ static int empty_dir (struct inode * inode)
1837 if (inode->i_size < EXT3_DIR_REC_LEN(1) + EXT3_DIR_REC_LEN(2) || 1837 if (inode->i_size < EXT3_DIR_REC_LEN(1) + EXT3_DIR_REC_LEN(2) ||
1838 !(bh = ext3_bread (NULL, inode, 0, 0, &err))) { 1838 !(bh = ext3_bread (NULL, inode, 0, 0, &err))) {
1839 if (err) 1839 if (err)
1840 ext3_error(inode->i_sb, __FUNCTION__, 1840 ext3_error(inode->i_sb, __func__,
1841 "error %d reading directory #%lu offset 0", 1841 "error %d reading directory #%lu offset 0",
1842 err, inode->i_ino); 1842 err, inode->i_ino);
1843 else 1843 else
1844 ext3_warning(inode->i_sb, __FUNCTION__, 1844 ext3_warning(inode->i_sb, __func__,
1845 "bad directory (dir #%lu) - no data block", 1845 "bad directory (dir #%lu) - no data block",
1846 inode->i_ino); 1846 inode->i_ino);
1847 return 1; 1847 return 1;
@@ -1870,7 +1870,7 @@ static int empty_dir (struct inode * inode)
1870 offset >> EXT3_BLOCK_SIZE_BITS(sb), 0, &err); 1870 offset >> EXT3_BLOCK_SIZE_BITS(sb), 0, &err);
1871 if (!bh) { 1871 if (!bh) {
1872 if (err) 1872 if (err)
1873 ext3_error(sb, __FUNCTION__, 1873 ext3_error(sb, __func__,
1874 "error %d reading directory" 1874 "error %d reading directory"
1875 " #%lu offset %lu", 1875 " #%lu offset %lu",
1876 err, inode->i_ino, offset); 1876 err, inode->i_ino, offset);
diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index 7a9dac1d3653..28cfd0b40527 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -48,60 +48,60 @@ static int verify_group_input(struct super_block *sb,
48 free_blocks_count, input->reserved_blocks); 48 free_blocks_count, input->reserved_blocks);
49 49
50 if (group != sbi->s_groups_count) 50 if (group != sbi->s_groups_count)
51 ext3_warning(sb, __FUNCTION__, 51 ext3_warning(sb, __func__,
52 "Cannot add at group %u (only %lu groups)", 52 "Cannot add at group %u (only %lu groups)",
53 input->group, sbi->s_groups_count); 53 input->group, sbi->s_groups_count);
54 else if ((start - le32_to_cpu(es->s_first_data_block)) % 54 else if ((start - le32_to_cpu(es->s_first_data_block)) %
55 EXT3_BLOCKS_PER_GROUP(sb)) 55 EXT3_BLOCKS_PER_GROUP(sb))
56 ext3_warning(sb, __FUNCTION__, "Last group not full"); 56 ext3_warning(sb, __func__, "Last group not full");
57 else if (input->reserved_blocks > input->blocks_count / 5) 57 else if (input->reserved_blocks > input->blocks_count / 5)
58 ext3_warning(sb, __FUNCTION__, "Reserved blocks too high (%u)", 58 ext3_warning(sb, __func__, "Reserved blocks too high (%u)",
59 input->reserved_blocks); 59 input->reserved_blocks);
60 else if (free_blocks_count < 0) 60 else if (free_blocks_count < 0)
61 ext3_warning(sb, __FUNCTION__, "Bad blocks count %u", 61 ext3_warning(sb, __func__, "Bad blocks count %u",
62 input->blocks_count); 62 input->blocks_count);
63 else if (!(bh = sb_bread(sb, end - 1))) 63 else if (!(bh = sb_bread(sb, end - 1)))
64 ext3_warning(sb, __FUNCTION__, 64 ext3_warning(sb, __func__,
65 "Cannot read last block ("E3FSBLK")", 65 "Cannot read last block ("E3FSBLK")",
66 end - 1); 66 end - 1);
67 else if (outside(input->block_bitmap, start, end)) 67 else if (outside(input->block_bitmap, start, end))
68 ext3_warning(sb, __FUNCTION__, 68 ext3_warning(sb, __func__,
69 "Block bitmap not in group (block %u)", 69 "Block bitmap not in group (block %u)",
70 input->block_bitmap); 70 input->block_bitmap);
71 else if (outside(input->inode_bitmap, start, end)) 71 else if (outside(input->inode_bitmap, start, end))
72 ext3_warning(sb, __FUNCTION__, 72 ext3_warning(sb, __func__,
73 "Inode bitmap not in group (block %u)", 73 "Inode bitmap not in group (block %u)",
74 input->inode_bitmap); 74 input->inode_bitmap);
75 else if (outside(input->inode_table, start, end) || 75 else if (outside(input->inode_table, start, end) ||
76 outside(itend - 1, start, end)) 76 outside(itend - 1, start, end))
77 ext3_warning(sb, __FUNCTION__, 77 ext3_warning(sb, __func__,
78 "Inode table not in group (blocks %u-"E3FSBLK")", 78 "Inode table not in group (blocks %u-"E3FSBLK")",
79 input->inode_table, itend - 1); 79 input->inode_table, itend - 1);
80 else if (input->inode_bitmap == input->block_bitmap) 80 else if (input->inode_bitmap == input->block_bitmap)
81 ext3_warning(sb, __FUNCTION__, 81 ext3_warning(sb, __func__,
82 "Block bitmap same as inode bitmap (%u)", 82 "Block bitmap same as inode bitmap (%u)",
83 input->block_bitmap); 83 input->block_bitmap);
84 else if (inside(input->block_bitmap, input->inode_table, itend)) 84 else if (inside(input->block_bitmap, input->inode_table, itend))
85 ext3_warning(sb, __FUNCTION__, 85 ext3_warning(sb, __func__,
86 "Block bitmap (%u) in inode table (%u-"E3FSBLK")", 86 "Block bitmap (%u) in inode table (%u-"E3FSBLK")",
87 input->block_bitmap, input->inode_table, itend-1); 87 input->block_bitmap, input->inode_table, itend-1);
88 else if (inside(input->inode_bitmap, input->inode_table, itend)) 88 else if (inside(input->inode_bitmap, input->inode_table, itend))
89 ext3_warning(sb, __FUNCTION__, 89 ext3_warning(sb, __func__,
90 "Inode bitmap (%u) in inode table (%u-"E3FSBLK")", 90 "Inode bitmap (%u) in inode table (%u-"E3FSBLK")",
91 input->inode_bitmap, input->inode_table, itend-1); 91 input->inode_bitmap, input->inode_table, itend-1);
92 else if (inside(input->block_bitmap, start, metaend)) 92 else if (inside(input->block_bitmap, start, metaend))
93 ext3_warning(sb, __FUNCTION__, 93 ext3_warning(sb, __func__,
94 "Block bitmap (%u) in GDT table" 94 "Block bitmap (%u) in GDT table"
95 " ("E3FSBLK"-"E3FSBLK")", 95 " ("E3FSBLK"-"E3FSBLK")",
96 input->block_bitmap, start, metaend - 1); 96 input->block_bitmap, start, metaend - 1);
97 else if (inside(input->inode_bitmap, start, metaend)) 97 else if (inside(input->inode_bitmap, start, metaend))
98 ext3_warning(sb, __FUNCTION__, 98 ext3_warning(sb, __func__,
99 "Inode bitmap (%u) in GDT table" 99 "Inode bitmap (%u) in GDT table"
100 " ("E3FSBLK"-"E3FSBLK")", 100 " ("E3FSBLK"-"E3FSBLK")",
101 input->inode_bitmap, start, metaend - 1); 101 input->inode_bitmap, start, metaend - 1);
102 else if (inside(input->inode_table, start, metaend) || 102 else if (inside(input->inode_table, start, metaend) ||
103 inside(itend - 1, start, metaend)) 103 inside(itend - 1, start, metaend))
104 ext3_warning(sb, __FUNCTION__, 104 ext3_warning(sb, __func__,
105 "Inode table (%u-"E3FSBLK") overlaps" 105 "Inode table (%u-"E3FSBLK") overlaps"
106 "GDT table ("E3FSBLK"-"E3FSBLK")", 106 "GDT table ("E3FSBLK"-"E3FSBLK")",
107 input->inode_table, itend - 1, start, metaend - 1); 107 input->inode_table, itend - 1, start, metaend - 1);
@@ -386,7 +386,7 @@ static int verify_reserved_gdb(struct super_block *sb,
386 386
387 while ((grp = ext3_list_backups(sb, &three, &five, &seven)) < end) { 387 while ((grp = ext3_list_backups(sb, &three, &five, &seven)) < end) {
388 if (le32_to_cpu(*p++) != grp * EXT3_BLOCKS_PER_GROUP(sb) + blk){ 388 if (le32_to_cpu(*p++) != grp * EXT3_BLOCKS_PER_GROUP(sb) + blk){
389 ext3_warning(sb, __FUNCTION__, 389 ext3_warning(sb, __func__,
390 "reserved GDT "E3FSBLK 390 "reserved GDT "E3FSBLK
391 " missing grp %d ("E3FSBLK")", 391 " missing grp %d ("E3FSBLK")",
392 blk, grp, 392 blk, grp,
@@ -440,7 +440,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
440 */ 440 */
441 if (EXT3_SB(sb)->s_sbh->b_blocknr != 441 if (EXT3_SB(sb)->s_sbh->b_blocknr !=
442 le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block)) { 442 le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block)) {
443 ext3_warning(sb, __FUNCTION__, 443 ext3_warning(sb, __func__,
444 "won't resize using backup superblock at %llu", 444 "won't resize using backup superblock at %llu",
445 (unsigned long long)EXT3_SB(sb)->s_sbh->b_blocknr); 445 (unsigned long long)EXT3_SB(sb)->s_sbh->b_blocknr);
446 return -EPERM; 446 return -EPERM;
@@ -464,7 +464,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
464 464
465 data = (__le32 *)dind->b_data; 465 data = (__le32 *)dind->b_data;
466 if (le32_to_cpu(data[gdb_num % EXT3_ADDR_PER_BLOCK(sb)]) != gdblock) { 466 if (le32_to_cpu(data[gdb_num % EXT3_ADDR_PER_BLOCK(sb)]) != gdblock) {
467 ext3_warning(sb, __FUNCTION__, 467 ext3_warning(sb, __func__,
468 "new group %u GDT block "E3FSBLK" not reserved", 468 "new group %u GDT block "E3FSBLK" not reserved",
469 input->group, gdblock); 469 input->group, gdblock);
470 err = -EINVAL; 470 err = -EINVAL;
@@ -488,7 +488,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
488 GFP_NOFS); 488 GFP_NOFS);
489 if (!n_group_desc) { 489 if (!n_group_desc) {
490 err = -ENOMEM; 490 err = -ENOMEM;
491 ext3_warning (sb, __FUNCTION__, 491 ext3_warning (sb, __func__,
492 "not enough memory for %lu groups", gdb_num + 1); 492 "not enough memory for %lu groups", gdb_num + 1);
493 goto exit_inode; 493 goto exit_inode;
494 } 494 }
@@ -586,7 +586,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
586 /* Get each reserved primary GDT block and verify it holds backups */ 586 /* Get each reserved primary GDT block and verify it holds backups */
587 for (res = 0; res < reserved_gdb; res++, blk++) { 587 for (res = 0; res < reserved_gdb; res++, blk++) {
588 if (le32_to_cpu(*data) != blk) { 588 if (le32_to_cpu(*data) != blk) {
589 ext3_warning(sb, __FUNCTION__, 589 ext3_warning(sb, __func__,
590 "reserved block "E3FSBLK 590 "reserved block "E3FSBLK
591 " not at offset %ld", 591 " not at offset %ld",
592 blk, 592 blk,
@@ -730,7 +730,7 @@ static void update_backups(struct super_block *sb,
730 */ 730 */
731exit_err: 731exit_err:
732 if (err) { 732 if (err) {
733 ext3_warning(sb, __FUNCTION__, 733 ext3_warning(sb, __func__,
734 "can't update backup for group %d (err %d), " 734 "can't update backup for group %d (err %d), "
735 "forcing fsck on next reboot", group, err); 735 "forcing fsck on next reboot", group, err);
736 sbi->s_mount_state &= ~EXT3_VALID_FS; 736 sbi->s_mount_state &= ~EXT3_VALID_FS;
@@ -770,33 +770,33 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
770 770
771 if (gdb_off == 0 && !EXT3_HAS_RO_COMPAT_FEATURE(sb, 771 if (gdb_off == 0 && !EXT3_HAS_RO_COMPAT_FEATURE(sb,
772 EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 772 EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
773 ext3_warning(sb, __FUNCTION__, 773 ext3_warning(sb, __func__,
774 "Can't resize non-sparse filesystem further"); 774 "Can't resize non-sparse filesystem further");
775 return -EPERM; 775 return -EPERM;
776 } 776 }
777 777
778 if (le32_to_cpu(es->s_blocks_count) + input->blocks_count < 778 if (le32_to_cpu(es->s_blocks_count) + input->blocks_count <
779 le32_to_cpu(es->s_blocks_count)) { 779 le32_to_cpu(es->s_blocks_count)) {
780 ext3_warning(sb, __FUNCTION__, "blocks_count overflow\n"); 780 ext3_warning(sb, __func__, "blocks_count overflow\n");
781 return -EINVAL; 781 return -EINVAL;
782 } 782 }
783 783
784 if (le32_to_cpu(es->s_inodes_count) + EXT3_INODES_PER_GROUP(sb) < 784 if (le32_to_cpu(es->s_inodes_count) + EXT3_INODES_PER_GROUP(sb) <
785 le32_to_cpu(es->s_inodes_count)) { 785 le32_to_cpu(es->s_inodes_count)) {
786 ext3_warning(sb, __FUNCTION__, "inodes_count overflow\n"); 786 ext3_warning(sb, __func__, "inodes_count overflow\n");
787 return -EINVAL; 787 return -EINVAL;
788 } 788 }
789 789
790 if (reserved_gdb || gdb_off == 0) { 790 if (reserved_gdb || gdb_off == 0) {
791 if (!EXT3_HAS_COMPAT_FEATURE(sb, 791 if (!EXT3_HAS_COMPAT_FEATURE(sb,
792 EXT3_FEATURE_COMPAT_RESIZE_INODE)){ 792 EXT3_FEATURE_COMPAT_RESIZE_INODE)){
793 ext3_warning(sb, __FUNCTION__, 793 ext3_warning(sb, __func__,
794 "No reserved GDT blocks, can't resize"); 794 "No reserved GDT blocks, can't resize");
795 return -EPERM; 795 return -EPERM;
796 } 796 }
797 inode = ext3_iget(sb, EXT3_RESIZE_INO); 797 inode = ext3_iget(sb, EXT3_RESIZE_INO);
798 if (IS_ERR(inode)) { 798 if (IS_ERR(inode)) {
799 ext3_warning(sb, __FUNCTION__, 799 ext3_warning(sb, __func__,
800 "Error opening resize inode"); 800 "Error opening resize inode");
801 return PTR_ERR(inode); 801 return PTR_ERR(inode);
802 } 802 }
@@ -825,7 +825,7 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
825 825
826 lock_super(sb); 826 lock_super(sb);
827 if (input->group != sbi->s_groups_count) { 827 if (input->group != sbi->s_groups_count) {
828 ext3_warning(sb, __FUNCTION__, 828 ext3_warning(sb, __func__,
829 "multiple resizers run on filesystem!"); 829 "multiple resizers run on filesystem!");
830 err = -EBUSY; 830 err = -EBUSY;
831 goto exit_journal; 831 goto exit_journal;
@@ -988,13 +988,13 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
988 " too large to resize to %lu blocks safely\n", 988 " too large to resize to %lu blocks safely\n",
989 sb->s_id, n_blocks_count); 989 sb->s_id, n_blocks_count);
990 if (sizeof(sector_t) < 8) 990 if (sizeof(sector_t) < 8)
991 ext3_warning(sb, __FUNCTION__, 991 ext3_warning(sb, __func__,
992 "CONFIG_LBD not enabled\n"); 992 "CONFIG_LBD not enabled\n");
993 return -EINVAL; 993 return -EINVAL;
994 } 994 }
995 995
996 if (n_blocks_count < o_blocks_count) { 996 if (n_blocks_count < o_blocks_count) {
997 ext3_warning(sb, __FUNCTION__, 997 ext3_warning(sb, __func__,
998 "can't shrink FS - resize aborted"); 998 "can't shrink FS - resize aborted");
999 return -EBUSY; 999 return -EBUSY;
1000 } 1000 }
@@ -1004,7 +1004,7 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
1004 EXT3_BLOCKS_PER_GROUP(sb); 1004 EXT3_BLOCKS_PER_GROUP(sb);
1005 1005
1006 if (last == 0) { 1006 if (last == 0) {
1007 ext3_warning(sb, __FUNCTION__, 1007 ext3_warning(sb, __func__,
1008 "need to use ext2online to resize further"); 1008 "need to use ext2online to resize further");
1009 return -EPERM; 1009 return -EPERM;
1010 } 1010 }
@@ -1012,7 +1012,7 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
1012 add = EXT3_BLOCKS_PER_GROUP(sb) - last; 1012 add = EXT3_BLOCKS_PER_GROUP(sb) - last;
1013 1013
1014 if (o_blocks_count + add < o_blocks_count) { 1014 if (o_blocks_count + add < o_blocks_count) {
1015 ext3_warning(sb, __FUNCTION__, "blocks_count overflow"); 1015 ext3_warning(sb, __func__, "blocks_count overflow");
1016 return -EINVAL; 1016 return -EINVAL;
1017 } 1017 }
1018 1018
@@ -1020,7 +1020,7 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
1020 add = n_blocks_count - o_blocks_count; 1020 add = n_blocks_count - o_blocks_count;
1021 1021
1022 if (o_blocks_count + add < n_blocks_count) 1022 if (o_blocks_count + add < n_blocks_count)
1023 ext3_warning(sb, __FUNCTION__, 1023 ext3_warning(sb, __func__,
1024 "will only finish group ("E3FSBLK 1024 "will only finish group ("E3FSBLK
1025 " blocks, %u new)", 1025 " blocks, %u new)",
1026 o_blocks_count + add, add); 1026 o_blocks_count + add, add);
@@ -1028,7 +1028,7 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
1028 /* See if the device is actually as big as what was requested */ 1028 /* See if the device is actually as big as what was requested */
1029 bh = sb_bread(sb, o_blocks_count + add -1); 1029 bh = sb_bread(sb, o_blocks_count + add -1);
1030 if (!bh) { 1030 if (!bh) {
1031 ext3_warning(sb, __FUNCTION__, 1031 ext3_warning(sb, __func__,
1032 "can't read last block, resize aborted"); 1032 "can't read last block, resize aborted");
1033 return -ENOSPC; 1033 return -ENOSPC;
1034 } 1034 }
@@ -1040,13 +1040,13 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
1040 handle = ext3_journal_start_sb(sb, 3); 1040 handle = ext3_journal_start_sb(sb, 3);
1041 if (IS_ERR(handle)) { 1041 if (IS_ERR(handle)) {
1042 err = PTR_ERR(handle); 1042 err = PTR_ERR(handle);
1043 ext3_warning(sb, __FUNCTION__, "error %d on journal start",err); 1043 ext3_warning(sb, __func__, "error %d on journal start",err);
1044 goto exit_put; 1044 goto exit_put;
1045 } 1045 }
1046 1046
1047 lock_super(sb); 1047 lock_super(sb);
1048 if (o_blocks_count != le32_to_cpu(es->s_blocks_count)) { 1048 if (o_blocks_count != le32_to_cpu(es->s_blocks_count)) {
1049 ext3_warning(sb, __FUNCTION__, 1049 ext3_warning(sb, __func__,
1050 "multiple resizers run on filesystem!"); 1050 "multiple resizers run on filesystem!");
1051 unlock_super(sb); 1051 unlock_super(sb);
1052 ext3_journal_stop(handle); 1052 ext3_journal_stop(handle);
@@ -1056,7 +1056,7 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
1056 1056
1057 if ((err = ext3_journal_get_write_access(handle, 1057 if ((err = ext3_journal_get_write_access(handle,
1058 EXT3_SB(sb)->s_sbh))) { 1058 EXT3_SB(sb)->s_sbh))) {
1059 ext3_warning(sb, __FUNCTION__, 1059 ext3_warning(sb, __func__,
1060 "error %d on journal write access", err); 1060 "error %d on journal write access", err);
1061 unlock_super(sb); 1061 unlock_super(sb);
1062 ext3_journal_stop(handle); 1062 ext3_journal_stop(handle);
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 6303adfbdae4..fe3119a71ada 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -84,7 +84,7 @@ handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks)
84 * take the FS itself readonly cleanly. */ 84 * take the FS itself readonly cleanly. */
85 journal = EXT3_SB(sb)->s_journal; 85 journal = EXT3_SB(sb)->s_journal;
86 if (is_journal_aborted(journal)) { 86 if (is_journal_aborted(journal)) {
87 ext3_abort(sb, __FUNCTION__, 87 ext3_abort(sb, __func__,
88 "Detected aborted journal"); 88 "Detected aborted journal");
89 return ERR_PTR(-EROFS); 89 return ERR_PTR(-EROFS);
90 } 90 }
@@ -304,7 +304,7 @@ void ext3_update_dynamic_rev(struct super_block *sb)
304 if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV) 304 if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV)
305 return; 305 return;
306 306
307 ext3_warning(sb, __FUNCTION__, 307 ext3_warning(sb, __func__,
308 "updating to rev %d because of new feature flag, " 308 "updating to rev %d because of new feature flag, "
309 "running e2fsck is recommended", 309 "running e2fsck is recommended",
310 EXT3_DYNAMIC_REV); 310 EXT3_DYNAMIC_REV);
@@ -1390,7 +1390,7 @@ static void ext3_orphan_cleanup (struct super_block * sb,
1390 if (inode->i_nlink) { 1390 if (inode->i_nlink) {
1391 printk(KERN_DEBUG 1391 printk(KERN_DEBUG
1392 "%s: truncating inode %lu to %Ld bytes\n", 1392 "%s: truncating inode %lu to %Ld bytes\n",
1393 __FUNCTION__, inode->i_ino, inode->i_size); 1393 __func__, inode->i_ino, inode->i_size);
1394 jbd_debug(2, "truncating inode %lu to %Ld bytes\n", 1394 jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
1395 inode->i_ino, inode->i_size); 1395 inode->i_ino, inode->i_size);
1396 ext3_truncate(inode); 1396 ext3_truncate(inode);
@@ -1398,7 +1398,7 @@ static void ext3_orphan_cleanup (struct super_block * sb,
1398 } else { 1398 } else {
1399 printk(KERN_DEBUG 1399 printk(KERN_DEBUG
1400 "%s: deleting unreferenced inode %lu\n", 1400 "%s: deleting unreferenced inode %lu\n",
1401 __FUNCTION__, inode->i_ino); 1401 __func__, inode->i_ino);
1402 jbd_debug(2, "deleting unreferenced inode %lu\n", 1402 jbd_debug(2, "deleting unreferenced inode %lu\n",
1403 inode->i_ino); 1403 inode->i_ino);
1404 nr_orphans++; 1404 nr_orphans++;
@@ -2301,9 +2301,9 @@ static void ext3_clear_journal_err(struct super_block * sb,
2301 char nbuf[16]; 2301 char nbuf[16];
2302 2302
2303 errstr = ext3_decode_error(sb, j_errno, nbuf); 2303 errstr = ext3_decode_error(sb, j_errno, nbuf);
2304 ext3_warning(sb, __FUNCTION__, "Filesystem error recorded " 2304 ext3_warning(sb, __func__, "Filesystem error recorded "
2305 "from previous mount: %s", errstr); 2305 "from previous mount: %s", errstr);
2306 ext3_warning(sb, __FUNCTION__, "Marking fs in need of " 2306 ext3_warning(sb, __func__, "Marking fs in need of "
2307 "filesystem check."); 2307 "filesystem check.");
2308 2308
2309 EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS; 2309 EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
@@ -2430,7 +2430,7 @@ static int ext3_remount (struct super_block * sb, int * flags, char * data)
2430 } 2430 }
2431 2431
2432 if (sbi->s_mount_opt & EXT3_MOUNT_ABORT) 2432 if (sbi->s_mount_opt & EXT3_MOUNT_ABORT)
2433 ext3_abort(sb, __FUNCTION__, "Abort forced by user"); 2433 ext3_abort(sb, __func__, "Abort forced by user");
2434 2434
2435 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 2435 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2436 ((sbi->s_mount_opt & EXT3_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0); 2436 ((sbi->s_mount_opt & EXT3_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index ca591ad1540d..d4a4f0e9ff69 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -234,7 +234,7 @@ ext3_xattr_block_get(struct inode *inode, int name_index, const char *name,
234 ea_bdebug(bh, "b_count=%d, refcount=%d", 234 ea_bdebug(bh, "b_count=%d, refcount=%d",
235 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount)); 235 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
236 if (ext3_xattr_check_block(bh)) { 236 if (ext3_xattr_check_block(bh)) {
237bad_block: ext3_error(inode->i_sb, __FUNCTION__, 237bad_block: ext3_error(inode->i_sb, __func__,
238 "inode %lu: bad block "E3FSBLK, inode->i_ino, 238 "inode %lu: bad block "E3FSBLK, inode->i_ino,
239 EXT3_I(inode)->i_file_acl); 239 EXT3_I(inode)->i_file_acl);
240 error = -EIO; 240 error = -EIO;
@@ -376,7 +376,7 @@ ext3_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
376 ea_bdebug(bh, "b_count=%d, refcount=%d", 376 ea_bdebug(bh, "b_count=%d, refcount=%d",
377 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount)); 377 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
378 if (ext3_xattr_check_block(bh)) { 378 if (ext3_xattr_check_block(bh)) {
379 ext3_error(inode->i_sb, __FUNCTION__, 379 ext3_error(inode->i_sb, __func__,
380 "inode %lu: bad block "E3FSBLK, inode->i_ino, 380 "inode %lu: bad block "E3FSBLK, inode->i_ino,
381 EXT3_I(inode)->i_file_acl); 381 EXT3_I(inode)->i_file_acl);
382 error = -EIO; 382 error = -EIO;
@@ -651,7 +651,7 @@ ext3_xattr_block_find(struct inode *inode, struct ext3_xattr_info *i,
651 atomic_read(&(bs->bh->b_count)), 651 atomic_read(&(bs->bh->b_count)),
652 le32_to_cpu(BHDR(bs->bh)->h_refcount)); 652 le32_to_cpu(BHDR(bs->bh)->h_refcount));
653 if (ext3_xattr_check_block(bs->bh)) { 653 if (ext3_xattr_check_block(bs->bh)) {
654 ext3_error(sb, __FUNCTION__, 654 ext3_error(sb, __func__,
655 "inode %lu: bad block "E3FSBLK, inode->i_ino, 655 "inode %lu: bad block "E3FSBLK, inode->i_ino,
656 EXT3_I(inode)->i_file_acl); 656 EXT3_I(inode)->i_file_acl);
657 error = -EIO; 657 error = -EIO;
@@ -852,7 +852,7 @@ cleanup_dquot:
852 goto cleanup; 852 goto cleanup;
853 853
854bad_block: 854bad_block:
855 ext3_error(inode->i_sb, __FUNCTION__, 855 ext3_error(inode->i_sb, __func__,
856 "inode %lu: bad block "E3FSBLK, inode->i_ino, 856 "inode %lu: bad block "E3FSBLK, inode->i_ino,
857 EXT3_I(inode)->i_file_acl); 857 EXT3_I(inode)->i_file_acl);
858 goto cleanup; 858 goto cleanup;
@@ -1081,14 +1081,14 @@ ext3_xattr_delete_inode(handle_t *handle, struct inode *inode)
1081 goto cleanup; 1081 goto cleanup;
1082 bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl); 1082 bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
1083 if (!bh) { 1083 if (!bh) {
1084 ext3_error(inode->i_sb, __FUNCTION__, 1084 ext3_error(inode->i_sb, __func__,
1085 "inode %lu: block "E3FSBLK" read error", inode->i_ino, 1085 "inode %lu: block "E3FSBLK" read error", inode->i_ino,
1086 EXT3_I(inode)->i_file_acl); 1086 EXT3_I(inode)->i_file_acl);
1087 goto cleanup; 1087 goto cleanup;
1088 } 1088 }
1089 if (BHDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) || 1089 if (BHDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
1090 BHDR(bh)->h_blocks != cpu_to_le32(1)) { 1090 BHDR(bh)->h_blocks != cpu_to_le32(1)) {
1091 ext3_error(inode->i_sb, __FUNCTION__, 1091 ext3_error(inode->i_sb, __func__,
1092 "inode %lu: bad block "E3FSBLK, inode->i_ino, 1092 "inode %lu: bad block "E3FSBLK, inode->i_ino,
1093 EXT3_I(inode)->i_file_acl); 1093 EXT3_I(inode)->i_file_acl);
1094 goto cleanup; 1094 goto cleanup;
@@ -1215,7 +1215,7 @@ again:
1215 } 1215 }
1216 bh = sb_bread(inode->i_sb, ce->e_block); 1216 bh = sb_bread(inode->i_sb, ce->e_block);
1217 if (!bh) { 1217 if (!bh) {
1218 ext3_error(inode->i_sb, __FUNCTION__, 1218 ext3_error(inode->i_sb, __func__,
1219 "inode %lu: block %lu read error", 1219 "inode %lu: block %lu read error",
1220 inode->i_ino, (unsigned long) ce->e_block); 1220 inode->i_ino, (unsigned long) ce->e_block);
1221 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >= 1221 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-08 03:43:23 -0500