fat: Replace all printk with fat_msg()

Replace all printk with fat_msg()

Signed-off-by: Alexey Fisher <bug-track@fisher-privat.net>
Signed-off-by: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>

4 files changed, 55 insertions, 54 deletions

diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index ee42b9e0b16a..4ad64732cbce 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -98,7 +98,7 @@ next:
 
         *bh = sb_bread(sb, phys);
         if (*bh == NULL) {
-                printk(KERN_ERR "FAT: Directory bread(block %llu) failed\n",
+                fat_msg(sb, KERN_ERR, "Directory bread(block %llu) failed",
                        (llu)phys);
                 /* skip this block */
                 *pos = (iblock + 1) << sb->s_blocksize_bits;
@@ -136,9 +136,10 @@ static inline int fat_get_entry(struct inode *dir, loff_t *pos,
  * but ignore that right now.
  * Ahem... Stack smashing in ring 0 isn't fun. Fixed.
  */
-static int uni16_to_x8(unsigned char *ascii, const wchar_t *uni, int len,
-                       int uni_xlate, struct nls_table *nls)
+static int uni16_to_x8(struct super_block *sb, unsigned char *ascii,
+                       const wchar_t *uni, int len, struct nls_table *nls)
 {
+        int uni_xlate = MSDOS_SB(sb)->options.unicode_xlate;
         const wchar_t *ip;
         wchar_t ec;
         unsigned char *op;
@@ -166,23 +167,23 @@ static int uni16_to_x8(unsigned char *ascii, const wchar_t *uni, int len,
         }
 
         if (unlikely(*ip)) {
-                printk(KERN_WARNING "FAT: filename was truncated while "
-                       "converting.");
+                fat_msg(sb, KERN_WARNING, "filename was truncated while "
+                        "converting.");
         }
 
         *op = 0;
         return (op - ascii);
 }
 
-static inline int fat_uni_to_x8(struct msdos_sb_info *sbi, const wchar_t *uni,
+static inline int fat_uni_to_x8(struct super_block *sb, const wchar_t *uni,
                                 unsigned char *buf, int size)
 {
+        struct msdos_sb_info *sbi = MSDOS_SB(sb);
         if (sbi->options.utf8)
                 return utf16s_to_utf8s(uni, FAT_MAX_UNI_CHARS,
                                 UTF16_HOST_ENDIAN, buf, size);
         else
-                return uni16_to_x8(buf, uni, size, sbi->options.unicode_xlate,
-                                   sbi->nls_io);
+                return uni16_to_x8(sb, buf, uni, size, sbi->nls_io);
 }
 
 static inline int
@@ -419,7 +420,7 @@ parse_record:
 
                 /* Compare shortname */
                 bufuname[last_u] = 0x0000;
-                len = fat_uni_to_x8(sbi, bufuname, bufname, sizeof(bufname));
+                len = fat_uni_to_x8(sb, bufuname, bufname, sizeof(bufname));
                 if (fat_name_match(sbi, name, name_len, bufname, len))
                         goto found;
 
@@ -428,7 +429,7 @@ parse_record:
                         int size = PATH_MAX - FAT_MAX_UNI_SIZE;
 
                         /* Compare longname */
-                        len = fat_uni_to_x8(sbi, unicode, longname, size);
+                        len = fat_uni_to_x8(sb, unicode, longname, size);
                         if (fat_name_match(sbi, name, name_len, longname, len))
                                 goto found;
                 }
@@ -545,7 +546,7 @@ parse_record:
                 if (nr_slots) {
                         void *longname = unicode + FAT_MAX_UNI_CHARS;
                         int size = PATH_MAX - FAT_MAX_UNI_SIZE;
-                        int len = fat_uni_to_x8(sbi, unicode, longname, size);
+                        int len = fat_uni_to_x8(sb, unicode, longname, size);
 
                         fill_name = longname;
                         fill_len = len;
@@ -621,7 +622,7 @@ parse_record:
 
         if (isvfat) {
                 bufuname[j] = 0x0000;
-                i = fat_uni_to_x8(sbi, bufuname, bufname, sizeof(bufname));
+                i = fat_uni_to_x8(sb, bufuname, bufname, sizeof(bufname));
         }
         if (nr_slots) {
                 /* hack for fat_ioctl_filldir() */
@@ -979,6 +980,7 @@ static int __fat_remove_entries(struct inode *dir, loff_t pos, int nr_slots)
 
 int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo)
 {
+        struct super_block *sb = dir->i_sb;
         struct msdos_dir_entry *de;
         struct buffer_head *bh;
         int err = 0, nr_slots;
@@ -1013,8 +1015,8 @@ int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo)
                  */
                 err = __fat_remove_entries(dir, sinfo->slot_off, nr_slots);
                 if (err) {
-                        printk(KERN_WARNING
-                               "FAT: Couldn't remove the long name slots\n");
+                        fat_msg(sb, KERN_WARNING,
+                               "Couldn't remove the long name slots");
                 }
         }
 
@@ -1265,7 +1267,7 @@ int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
                 if (sbi->fat_bits != 32)
                         goto error;
         } else if (MSDOS_I(dir)->i_start == 0) {
-                printk(KERN_ERR "FAT: Corrupted directory (i_pos %lld)\n",
+                fat_msg(sb, KERN_ERR, "Corrupted directory (i_pos %lld)",
                        MSDOS_I(dir)->i_pos);
                 err = -EIO;
                 goto error;
diff --git a/fs/fat/fatent.c b/fs/fat/fatent.c
index b47d2c9f4fa1..2e81ac0df7e2 100644
--- a/fs/fat/fatent.c
+++ b/fs/fat/fatent.c
@@ -95,7 +95,7 @@ static int fat12_ent_bread(struct super_block *sb, struct fat_entry *fatent,
 err_brelse:
         brelse(bhs[0]);
 err:
-        printk(KERN_ERR "FAT: FAT read failed (blocknr %llu)\n", (llu)blocknr);
+        fat_msg(sb, KERN_ERR, "FAT read failed (blocknr %llu)", (llu)blocknr);
         return -EIO;
 }
 
@@ -108,7 +108,7 @@ static int fat_ent_bread(struct super_block *sb, struct fat_entry *fatent,
         fatent->fat_inode = MSDOS_SB(sb)->fat_inode;
         fatent->bhs[0] = sb_bread(sb, blocknr);
         if (!fatent->bhs[0]) {
-                printk(KERN_ERR "FAT: FAT read failed (blocknr %llu)\n",
+                fat_msg(sb, KERN_ERR, "FAT read failed (blocknr %llu)",
                        (llu)blocknr);
                 return -EIO;
         }
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index c27704dc485e..7a6c819893f2 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -619,8 +619,8 @@ retry:
 
         bh = sb_bread(sb, i_pos >> sbi->dir_per_block_bits);
         if (!bh) {
-                printk(KERN_ERR "FAT: unable to read inode block "
-                       "for updating (i_pos %lld)\n", i_pos);
+                fat_msg(sb, KERN_ERR, "unable to read inode block "
+                       "for updating (i_pos %lld)", i_pos);
                 return -EIO;
         }
         spin_lock(&sbi->inode_hash_lock);
@@ -976,8 +976,8 @@ static const match_table_t vfat_tokens = {
         {Opt_err, NULL}
 };
 
-static int parse_options(char *options, int is_vfat, int silent, int *debug,
-                         struct fat_mount_options *opts)
+static int parse_options(struct super_block *sb, char *options, int is_vfat,
+                         int silent, int *debug, struct fat_mount_options *opts)
 {
         char *p;
         substring_t args[MAX_OPT_ARGS];
@@ -1168,15 +1168,15 @@ static int parse_options(char *options, int is_vfat, int silent, int *debug,
 
                 /* obsolete mount options */
                 case Opt_obsolate:
-                        printk(KERN_INFO "FAT: \"%s\" option is obsolete, "
-                               "not supported now\n", p);
+                        fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, "
+                               "not supported now", p);
                         break;
                 /* unknown option */
                 default:
                         if (!silent) {
-                                printk(KERN_ERR
-                                       "FAT: Unrecognized mount option \"%s\" "
-                                       "or missing value\n", p);
+                                fat_msg(sb, KERN_ERR,
+                                       "Unrecognized mount option \"%s\" "
+                                       "or missing value", p);
                         }
                         return -EINVAL;
                 }
@@ -1185,7 +1185,7 @@ static int parse_options(char *options, int is_vfat, int silent, int *debug,
 out:
         /* UTF-8 doesn't provide FAT semantics */
         if (!strcmp(opts->iocharset, "utf8")) {
-                printk(KERN_ERR "FAT: utf8 is not a recommended IO charset"
+                fat_msg(sb, KERN_ERR, "utf8 is not a recommended IO charset"
                        " for FAT filesystems, filesystem will be "
                        "case sensitive!\n");
         }
@@ -1270,7 +1270,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         ratelimit_state_init(&sbi->ratelimit, DEFAULT_RATELIMIT_INTERVAL,
                              DEFAULT_RATELIMIT_BURST);
 
-        error = parse_options(data, isvfat, silent, &debug, &sbi->options);
+        error = parse_options(sb, data, isvfat, silent, &debug, &sbi->options);
         if (error)
                 goto out_fail;
 
@@ -1280,20 +1280,20 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         sb_min_blocksize(sb, 512);
         bh = sb_bread(sb, 0);
         if (bh == NULL) {
-                printk(KERN_ERR "FAT: unable to read boot sector\n");
+                fat_msg(sb, KERN_ERR, "unable to read boot sector");
                 goto out_fail;
         }
 
         b = (struct fat_boot_sector *) bh->b_data;
         if (!b->reserved) {
                 if (!silent)
-                        printk(KERN_ERR "FAT: bogus number of reserved sectors\n");
+                        fat_msg(sb, KERN_ERR, "bogus number of reserved sectors");
                 brelse(bh);
                 goto out_invalid;
         }
         if (!b->fats) {
                 if (!silent)
-                        printk(KERN_ERR "FAT: bogus number of FAT structure\n");
+                        fat_msg(sb, KERN_ERR, "bogus number of FAT structure");
                 brelse(bh);
                 goto out_invalid;
         }
@@ -1306,7 +1306,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         media = b->media;
         if (!fat_valid_media(media)) {
                 if (!silent)
-                        printk(KERN_ERR "FAT: invalid media value (0x%02x)\n",
+                        fat_msg(sb, KERN_ERR, "invalid media value (0x%02x)",
                                media);
                 brelse(bh);
                 goto out_invalid;
@@ -1316,7 +1316,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
             || (logical_sector_size < 512)
             || (logical_sector_size > 4096)) {
                 if (!silent)
-                        printk(KERN_ERR "FAT: bogus logical sector size %u\n",
+                        fat_msg(sb, KERN_ERR, "bogus logical sector size %u",
                                logical_sector_size);
                 brelse(bh);
                 goto out_invalid;
@@ -1324,15 +1324,15 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         sbi->sec_per_clus = b->sec_per_clus;
         if (!is_power_of_2(sbi->sec_per_clus)) {
                 if (!silent)
-                        printk(KERN_ERR "FAT: bogus sectors per cluster %u\n",
+                        fat_msg(sb, KERN_ERR, "bogus sectors per cluster %u",
                                sbi->sec_per_clus);
                 brelse(bh);
                 goto out_invalid;
         }
 
         if (logical_sector_size < sb->s_blocksize) {
-                printk(KERN_ERR "FAT: logical sector size too small for device"
-                       " (logical sector size = %u)\n", logical_sector_size);
+                fat_msg(sb, KERN_ERR, "logical sector size too small for device"
+                       " (logical sector size = %u)", logical_sector_size);
                 brelse(bh);
                 goto out_fail;
         }
@@ -1340,14 +1340,14 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
                 brelse(bh);
 
                 if (!sb_set_blocksize(sb, logical_sector_size)) {
-                        printk(KERN_ERR "FAT: unable to set blocksize %u\n",
+                        fat_msg(sb, KERN_ERR, "unable to set blocksize %u",
                                logical_sector_size);
                         goto out_fail;
                 }
                 bh = sb_bread(sb, 0);
                 if (bh == NULL) {
-                        printk(KERN_ERR "FAT: unable to read boot sector"
-                               " (logical sector size = %lu)\n",
+                        fat_msg(sb, KERN_ERR, "unable to read boot sector"
+                               " (logical sector size = %lu)",
                                sb->s_blocksize);
                         goto out_fail;
                 }
@@ -1383,16 +1383,16 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
 
                 fsinfo_bh = sb_bread(sb, sbi->fsinfo_sector);
                 if (fsinfo_bh == NULL) {
-                        printk(KERN_ERR "FAT: bread failed, FSINFO block"
-                               " (sector = %lu)\n", sbi->fsinfo_sector);
+                        fat_msg(sb, KERN_ERR, "bread failed, FSINFO block"
+                               " (sector = %lu)", sbi->fsinfo_sector);
                         brelse(bh);
                         goto out_fail;
                 }
 
                 fsinfo = (struct fat_boot_fsinfo *)fsinfo_bh->b_data;
                 if (!IS_FSINFO(fsinfo)) {
-                        printk(KERN_WARNING "FAT: Invalid FSINFO signature: "
-                               "0x%08x, 0x%08x (sector = %lu)\n",
+                        fat_msg(sb, KERN_WARNING, "Invalid FSINFO signature: "
+                               "0x%08x, 0x%08x (sector = %lu)",
                                le32_to_cpu(fsinfo->signature1),
                                le32_to_cpu(fsinfo->signature2),
                                sbi->fsinfo_sector);
@@ -1413,8 +1413,8 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         sbi->dir_entries = get_unaligned_le16(&b->dir_entries);
         if (sbi->dir_entries & (sbi->dir_per_block - 1)) {
                 if (!silent)
-                        printk(KERN_ERR "FAT: bogus directroy-entries per block"
-                               " (%u)\n", sbi->dir_entries);
+                        fat_msg(sb, KERN_ERR, "bogus directroy-entries per block"
+                               " (%u)", sbi->dir_entries);
                 brelse(bh);
                 goto out_invalid;
         }
@@ -1436,7 +1436,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         total_clusters = min(total_clusters, fat_clusters - FAT_START_ENT);
         if (total_clusters > MAX_FAT(sb)) {
                 if (!silent)
-                        printk(KERN_ERR "FAT: count of clusters too big (%u)\n",
+                        fat_msg(sb, KERN_ERR, "count of clusters too big (%u)",
                                total_clusters);
                 brelse(bh);
                 goto out_invalid;
@@ -1469,7 +1469,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         sprintf(buf, "cp%d", sbi->options.codepage);
         sbi->nls_disk = load_nls(buf);
         if (!sbi->nls_disk) {
-                printk(KERN_ERR "FAT: codepage %s not found\n", buf);
+                fat_msg(sb, KERN_ERR, "codepage %s not found", buf);
                 goto out_fail;
         }
 
@@ -1477,7 +1477,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         if (sbi->options.isvfat) {
                 sbi->nls_io = load_nls(sbi->options.iocharset);
                 if (!sbi->nls_io) {
-                        printk(KERN_ERR "FAT: IO charset %s not found\n",
+                        fat_msg(sb, KERN_ERR, "IO charset %s not found",
                                sbi->options.iocharset);
                         goto out_fail;
                 }
@@ -1501,7 +1501,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
         insert_inode_hash(root_inode);
         sb->s_root = d_alloc_root(root_inode);
         if (!sb->s_root) {
-                printk(KERN_ERR "FAT: get root inode failed\n");
+                fat_msg(sb, KERN_ERR, "get root inode failed");
                 goto out_fail;
         }
 
@@ -1510,8 +1510,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat,
 out_invalid:
         error = -EINVAL;
         if (!silent)
-                printk(KERN_INFO "VFS: Can't find a valid FAT filesystem"
-                       " on dev %s.\n", sb->s_id);
+                fat_msg(sb, KERN_INFO, "Can't find a valid FAT filesystem");
 
 out_fail:
         if (fat_inode)
diff --git a/fs/fat/misc.c b/fs/fat/misc.c
index 3dcabc1bd8c3..6d93360ca0cc 100644
--- a/fs/fat/misc.c
+++ b/fs/fat/misc.c
@@ -73,15 +73,15 @@ int fat_clusters_flush(struct super_block *sb)
 
         bh = sb_bread(sb, sbi->fsinfo_sector);
         if (bh == NULL) {
-                printk(KERN_ERR "FAT: bread failed in fat_clusters_flush\n");
+                fat_msg(sb, KERN_ERR, "bread failed in fat_clusters_flush");
                 return -EIO;
         }
 
         fsinfo = (struct fat_boot_fsinfo *)bh->b_data;
         /* Sanity check */
         if (!IS_FSINFO(fsinfo)) {
-                printk(KERN_ERR "FAT: Invalid FSINFO signature: "
-                       "0x%08x, 0x%08x (sector = %lu)\n",
+                fat_msg(sb, KERN_ERR, "Invalid FSINFO signature: "
+                       "0x%08x, 0x%08x (sector = %lu)",
                        le32_to_cpu(fsinfo->signature1),
                        le32_to_cpu(fsinfo->signature2),
                        sbi->fsinfo_sector);