1 files changed, 45 insertions, 42 deletions

diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index 59096b5e0fc7..c467bebd50af 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -52,26 +52,25 @@ befs_read_datastream(struct super_block *sb, befs_data_stream * ds,
         befs_block_run run;
         befs_blocknr_t block;   /* block coresponding to pos */
 
-        befs_debug(sb, "---> befs_read_datastream() %Lu", pos);
+        befs_debug(sb, "---> %s %llu", __func__, pos);
         block = pos >> BEFS_SB(sb)->block_shift;
         if (off)
                 *off = pos - (block << BEFS_SB(sb)->block_shift);
 
         if (befs_fblock2brun(sb, ds, block, &run) != BEFS_OK) {
                 befs_error(sb, "BeFS: Error finding disk addr of block %lu",
-                           block);
-                befs_debug(sb, "<--- befs_read_datastream() ERROR");
+                           (unsigned long)block);
+                befs_debug(sb, "<--- %s ERROR", __func__);
                 return NULL;
         }
         bh = befs_bread_iaddr(sb, run);
         if (!bh) {
                 befs_error(sb, "BeFS: Error reading block %lu from datastream",
-                           block);
+                           (unsigned long)block);
                 return NULL;
         }
 
-        befs_debug(sb, "<--- befs_read_datastream() read data, starting at %Lu",
-                   pos);
+        befs_debug(sb, "<--- %s read data, starting at %llu", __func__, pos);
 
         return bh;
 }
@@ -106,7 +105,8 @@ befs_fblock2brun(struct super_block *sb, befs_data_stream * data,
         } else {
                 befs_error(sb,
                            "befs_fblock2brun() was asked to find block %lu, "
-                           "which is not mapped by the datastream\n", fblock);
+                           "which is not mapped by the datastream\n",
+                           (unsigned long)fblock);
                 err = BEFS_ERR;
         }
         return err;
@@ -128,14 +128,14 @@ befs_read_lsymlink(struct super_block * sb, befs_data_stream * ds, void *buff,
         befs_off_t bytes_read = 0;      /* bytes readed */
         u16 plen;
         struct buffer_head *bh = NULL;
-        befs_debug(sb, "---> befs_read_lsymlink() length: %Lu", len);
+        befs_debug(sb, "---> %s length: %llu", __func__, len);
 
         while (bytes_read < len) {
                 bh = befs_read_datastream(sb, ds, bytes_read, NULL);
                 if (!bh) {
                         befs_error(sb, "BeFS: Error reading datastream block "
-                                   "starting from %Lu", bytes_read);
-                        befs_debug(sb, "<--- befs_read_lsymlink() ERROR");
+                                   "starting from %llu", bytes_read);
+                        befs_debug(sb, "<--- %s ERROR", __func__);
                         return bytes_read;
 
                 }
@@ -146,7 +146,8 @@ befs_read_lsymlink(struct super_block * sb, befs_data_stream * ds, void *buff,
                 bytes_read += plen;
         }
 
-        befs_debug(sb, "<--- befs_read_lsymlink() read %u bytes", bytes_read);
+        befs_debug(sb, "<--- %s read %u bytes", __func__, (unsigned int)
+                   bytes_read);
         return bytes_read;
 }
 
@@ -169,7 +170,7 @@ befs_count_blocks(struct super_block * sb, befs_data_stream * ds)
         befs_blocknr_t metablocks;      /* FS metadata blocks */
         befs_sb_info *befs_sb = BEFS_SB(sb);
 
-        befs_debug(sb, "---> befs_count_blocks()");
+        befs_debug(sb, "---> %s", __func__);
 
         datablocks = ds->size >> befs_sb->block_shift;
         if (ds->size & (befs_sb->block_size - 1))
@@ -206,7 +207,7 @@ befs_count_blocks(struct super_block * sb, befs_data_stream * ds)
         }
 
         blocks = datablocks + metablocks;
-        befs_debug(sb, "<--- befs_count_blocks() %u blocks", blocks);
+        befs_debug(sb, "<--- %s %u blocks", __func__, (unsigned int)blocks);
 
         return blocks;
 }
@@ -251,11 +252,11 @@ befs_find_brun_direct(struct super_block *sb, befs_data_stream * data,
         befs_blocknr_t max_block =
             data->max_direct_range >> BEFS_SB(sb)->block_shift;
 
-        befs_debug(sb, "---> befs_find_brun_direct(), find %lu", blockno);
+        befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno);
 
         if (blockno > max_block) {
-                befs_error(sb, "befs_find_brun_direct() passed block outside of"
-                           "direct region");
+                befs_error(sb, "%s passed block outside of direct region",
+                           __func__);
                 return BEFS_ERR;
         }
 
@@ -267,13 +268,14 @@ befs_find_brun_direct(struct super_block *sb, befs_data_stream * data,
                         run->start = array[i].start + offset;
                         run->len = array[i].len - offset;
 
-                        befs_debug(sb, "---> befs_find_brun_direct(), "
-                                   "found %lu at direct[%d]", blockno, i);
+                        befs_debug(sb, "---> %s, "
+                                   "found %lu at direct[%d]", __func__,
+                                   (unsigned long)blockno, i);
                         return BEFS_OK;
                 }
         }
 
-        befs_debug(sb, "---> befs_find_brun_direct() ERROR");
+        befs_debug(sb, "---> %s ERROR", __func__);
         return BEFS_ERR;
 }
 
@@ -316,7 +318,7 @@ befs_find_brun_indirect(struct super_block *sb,
         befs_blocknr_t indirblockno = iaddr2blockno(sb, &indirect);
         int arraylen = befs_iaddrs_per_block(sb);
 
-        befs_debug(sb, "---> befs_find_brun_indirect(), find %lu", blockno);
+        befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno);
 
         indir_start_blk = data->max_direct_range >> BEFS_SB(sb)->block_shift;
         search_blk = blockno - indir_start_blk;
@@ -325,10 +327,9 @@ befs_find_brun_indirect(struct super_block *sb,
         for (i = 0; i < indirect.len; i++) {
                 indirblock = befs_bread(sb, indirblockno + i);
                 if (indirblock == NULL) {
-                        befs_debug(sb,
-                                   "---> befs_find_brun_indirect() failed to "
-                                   "read disk block %lu from the indirect brun",
-                                   indirblockno + i);
+                        befs_debug(sb, "---> %s failed to read "
+                                   "disk block %lu from the indirect brun",
+                                   __func__, (unsigned long)indirblockno + i);
                         return BEFS_ERR;
                 }
 
@@ -348,9 +349,10 @@ befs_find_brun_indirect(struct super_block *sb,
 
                                 brelse(indirblock);
                                 befs_debug(sb,
-                                           "<--- befs_find_brun_indirect() found "
-                                           "file block %lu at indirect[%d]",
-                                           blockno, j + (i * arraylen));
+                                           "<--- %s found file block "
+                                           "%lu at indirect[%d]", __func__,
+                                           (unsigned long)blockno,
+                                           j + (i * arraylen));
                                 return BEFS_OK;
                         }
                         sum += len;
@@ -360,10 +362,10 @@ befs_find_brun_indirect(struct super_block *sb,
         }
 
         /* Only fallthrough is an error */
-        befs_error(sb, "BeFS: befs_find_brun_indirect() failed to find "
-                   "file block %lu", blockno);
+        befs_error(sb, "BeFS: %s failed to find "
+                   "file block %lu", __func__, (unsigned long)blockno);
 
-        befs_debug(sb, "<--- befs_find_brun_indirect() ERROR");
+        befs_debug(sb, "<--- %s ERROR", __func__);
         return BEFS_ERR;
 }
 
@@ -444,7 +446,7 @@ befs_find_brun_dblindirect(struct super_block *sb,
         size_t diblklen = iblklen * befs_iaddrs_per_block(sb)
             * BEFS_DBLINDIR_BRUN_LEN;
 
-        befs_debug(sb, "---> befs_find_brun_dblindirect() find %lu", blockno);
+        befs_debug(sb, "---> %s find %lu", __func__, (unsigned long)blockno);
 
         /* First, discover which of the double_indir->indir blocks
          * contains pos. Then figure out how much of pos that
@@ -460,8 +462,9 @@ befs_find_brun_dblindirect(struct super_block *sb,
         dbl_which_block = dblindir_indx / befs_iaddrs_per_block(sb);
         if (dbl_which_block > data->double_indirect.len) {
                 befs_error(sb, "The double-indirect index calculated by "
-                           "befs_read_brun_dblindirect(), %d, is outside the range "
-                           "of the double-indirect block", dblindir_indx);
+                           "%s, %d, is outside the range "
+                           "of the double-indirect block", __func__,
+                           dblindir_indx);
                 return BEFS_ERR;
         }
 
@@ -469,10 +472,10 @@ befs_find_brun_dblindirect(struct super_block *sb,
             befs_bread(sb, iaddr2blockno(sb, &data->double_indirect) +
                                         dbl_which_block);
         if (dbl_indir_block == NULL) {
-                befs_error(sb, "befs_read_brun_dblindirect() couldn't read the "
-                           "double-indirect block at blockno %lu",
-                           iaddr2blockno(sb,
-                                         &data->double_indirect) +
+                befs_error(sb, "%s couldn't read the "
+                           "double-indirect block at blockno %lu", __func__,
+                           (unsigned long)
+                           iaddr2blockno(sb, &data->double_indirect) +
                            dbl_which_block);
                 brelse(dbl_indir_block);
                 return BEFS_ERR;
@@ -489,16 +492,16 @@ befs_find_brun_dblindirect(struct super_block *sb,
         which_block = indir_indx / befs_iaddrs_per_block(sb);
         if (which_block > indir_run.len) {
                 befs_error(sb, "The indirect index calculated by "
-                           "befs_read_brun_dblindirect(), %d, is outside the range "
-                           "of the indirect block", indir_indx);
+                           "%s, %d, is outside the range "
+                           "of the indirect block", __func__, indir_indx);
                 return BEFS_ERR;
         }
 
         indir_block =
             befs_bread(sb, iaddr2blockno(sb, &indir_run) + which_block);
         if (indir_block == NULL) {
-                befs_error(sb, "befs_read_brun_dblindirect() couldn't read the "
-                           "indirect block at blockno %lu",
+                befs_error(sb, "%s couldn't read the indirect block "
+                           "at blockno %lu", __func__, (unsigned long)
                            iaddr2blockno(sb, &indir_run) + which_block);
                 brelse(indir_block);
                 return BEFS_ERR;
@@ -519,7 +522,7 @@ befs_find_brun_dblindirect(struct super_block *sb,
         run->len -= offset;
 
         befs_debug(sb, "Found file block %lu in double_indirect[%d][%d],"
-                   " double_indirect_leftover = %lu",
+                   " double_indirect_leftover = %lu", (unsigned long)
                    blockno, dblindir_indx, indir_indx, dblindir_leftover);
 
         return BEFS_OK;