1 files changed, 126 insertions, 154 deletions

diff --git a/fs/udf/super.c b/fs/udf/super.c
index 7b27b063ff6d..e185253470df 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -75,8 +75,6 @@
 
 #define UDF_DEFAULT_BLOCKSIZE 2048
 
-static char error_buf[1024];
-
 /* These are the "meat" - everything else is stuffing */
 static int udf_fill_super(struct super_block *, void *, int);
 static void udf_put_super(struct super_block *);
@@ -92,8 +90,6 @@ static void udf_close_lvid(struct super_block *);
 static unsigned int udf_count_free(struct super_block *);
 static int udf_statfs(struct dentry *, struct kstatfs *);
 static int udf_show_options(struct seq_file *, struct vfsmount *);
-static void udf_error(struct super_block *sb, const char *function,
-                      const char *fmt, ...);
 
 struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
 {
@@ -244,9 +240,8 @@ static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
         sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
                                   GFP_KERNEL);
         if (!sbi->s_partmaps) {
-                udf_error(sb, __func__,
-                          "Unable to allocate space for %d partition maps",
-                          count);
+                udf_err(sb, "Unable to allocate space for %d partition maps\n",
+                        count);
                 sbi->s_partitions = 0;
                 return -ENOMEM;
         }
@@ -550,8 +545,7 @@ static int udf_parse_options(char *options, struct udf_options *uopt,
                         uopt->dmode = option & 0777;
                         break;
                 default:
-                        printk(KERN_ERR "udf: bad mount option \"%s\" "
-                               "or missing value\n", p);
+                        pr_err("bad mount option \"%s\" or missing value\n", p);
                         return 0;
                 }
         }
@@ -645,20 +639,16 @@ static loff_t udf_check_vsd(struct super_block *sb)
                                 udf_debug("ISO9660 Boot Record found\n");
                                 break;
                         case 1:
-                                udf_debug("ISO9660 Primary Volume Descriptor "
-                                          "found\n");
+                                udf_debug("ISO9660 Primary Volume Descriptor found\n");
                                 break;
                         case 2:
-                                udf_debug("ISO9660 Supplementary Volume "
-                                          "Descriptor found\n");
+                                udf_debug("ISO9660 Supplementary Volume Descriptor found\n");
                                 break;
                         case 3:
-                                udf_debug("ISO9660 Volume Partition Descriptor "
-                                          "found\n");
+                                udf_debug("ISO9660 Volume Partition Descriptor found\n");
                                 break;
                         case 255:
-                                udf_debug("ISO9660 Volume Descriptor Set "
-                                          "Terminator found\n");
+                                udf_debug("ISO9660 Volume Descriptor Set Terminator found\n");
                                 break;
                         default:
                                 udf_debug("ISO9660 VRS (%u) found\n",
@@ -809,8 +799,7 @@ static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
                               pvoldesc->recordingDateAndTime)) {
 #ifdef UDFFS_DEBUG
                 struct timestamp *ts = &pvoldesc->recordingDateAndTime;
-                udf_debug("recording time %04u/%02u/%02u"
-                          " %02u:%02u (%x)\n",
+                udf_debug("recording time %04u/%02u/%02u %02u:%02u (%x)\n",
                           le16_to_cpu(ts->year), ts->month, ts->day, ts->hour,
                           ts->minute, le16_to_cpu(ts->typeAndTimezone));
 #endif
@@ -821,7 +810,7 @@ static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
                         strncpy(UDF_SB(sb)->s_volume_ident, outstr->u_name,
                                 outstr->u_len > 31 ? 31 : outstr->u_len);
                         udf_debug("volIdent[] = '%s'\n",
-                                        UDF_SB(sb)->s_volume_ident);
+                                  UDF_SB(sb)->s_volume_ident);
                 }
 
         if (!udf_build_ustr(instr, pvoldesc->volSetIdent, 128))
@@ -837,64 +826,57 @@ out1:
         return ret;
 }
 
+struct inode *udf_find_metadata_inode_efe(struct super_block *sb,
+                                        u32 meta_file_loc, u32 partition_num)
+{
+        struct kernel_lb_addr addr;
+        struct inode *metadata_fe;
+
+        addr.logicalBlockNum = meta_file_loc;
+        addr.partitionReferenceNum = partition_num;
+
+        metadata_fe = udf_iget(sb, &addr);
+
+        if (metadata_fe == NULL)
+                udf_warn(sb, "metadata inode efe not found\n");
+        else if (UDF_I(metadata_fe)->i_alloc_type != ICBTAG_FLAG_AD_SHORT) {
+                udf_warn(sb, "metadata inode efe does not have short allocation descriptors!\n");
+                iput(metadata_fe);
+                metadata_fe = NULL;
+        }
+
+        return metadata_fe;
+}
+
 static int udf_load_metadata_files(struct super_block *sb, int partition)
 {
         struct udf_sb_info *sbi = UDF_SB(sb);
         struct udf_part_map *map;
         struct udf_meta_data *mdata;
         struct kernel_lb_addr addr;
-        int fe_error = 0;
 
         map = &sbi->s_partmaps[partition];
         mdata = &map->s_type_specific.s_metadata;
 
         /* metadata address */
-        addr.logicalBlockNum =  mdata->s_meta_file_loc;
-        addr.partitionReferenceNum = map->s_partition_num;
-
         udf_debug("Metadata file location: block = %d part = %d\n",
-                          addr.logicalBlockNum, addr.partitionReferenceNum);
+                  mdata->s_meta_file_loc, map->s_partition_num);
 
-        mdata->s_metadata_fe = udf_iget(sb, &addr);
+        mdata->s_metadata_fe = udf_find_metadata_inode_efe(sb,
+                mdata->s_meta_file_loc, map->s_partition_num);
 
         if (mdata->s_metadata_fe == NULL) {
-                udf_warning(sb, __func__, "metadata inode efe not found, "
-                                "will try mirror inode.");
-                fe_error = 1;
-        } else if (UDF_I(mdata->s_metadata_fe)->i_alloc_type !=
-                 ICBTAG_FLAG_AD_SHORT) {
-                udf_warning(sb, __func__, "metadata inode efe does not have "
-                        "short allocation descriptors!");
-                fe_error = 1;
-                iput(mdata->s_metadata_fe);
-                mdata->s_metadata_fe = NULL;
-        }
+                /* mirror file entry */
+                udf_debug("Mirror metadata file location: block = %d part = %d\n",
+                          mdata->s_mirror_file_loc, map->s_partition_num);
 
-        /* mirror file entry */
-        addr.logicalBlockNum = mdata->s_mirror_file_loc;
-        addr.partitionReferenceNum = map->s_partition_num;
-
-        udf_debug("Mirror metadata file location: block = %d part = %d\n",
-                          addr.logicalBlockNum, addr.partitionReferenceNum);
+                mdata->s_mirror_fe = udf_find_metadata_inode_efe(sb,
+                        mdata->s_mirror_file_loc, map->s_partition_num);
 
-        mdata->s_mirror_fe = udf_iget(sb, &addr);
-
-        if (mdata->s_mirror_fe == NULL) {
-                if (fe_error) {
-                        udf_error(sb, __func__, "mirror inode efe not found "
-                        "and metadata inode is missing too, exiting...");
-                        goto error_exit;
-                } else
-                        udf_warning(sb, __func__, "mirror inode efe not found,"
-                                        " but metadata inode is OK");
-        } else if (UDF_I(mdata->s_mirror_fe)->i_alloc_type !=
-                 ICBTAG_FLAG_AD_SHORT) {
-                udf_warning(sb, __func__, "mirror inode efe does not have "
-                        "short allocation descriptors!");
-                iput(mdata->s_mirror_fe);
-                mdata->s_mirror_fe = NULL;
-                if (fe_error)
+                if (mdata->s_mirror_fe == NULL) {
+                        udf_err(sb, "Both metadata and mirror metadata inode efe can not found\n");
                         goto error_exit;
+                }
         }
 
         /*
@@ -907,18 +889,15 @@ static int udf_load_metadata_files(struct super_block *sb, int partition)
                 addr.partitionReferenceNum = map->s_partition_num;
 
                 udf_debug("Bitmap file location: block = %d part = %d\n",
-                        addr.logicalBlockNum, addr.partitionReferenceNum);
+                          addr.logicalBlockNum, addr.partitionReferenceNum);
 
                 mdata->s_bitmap_fe = udf_iget(sb, &addr);
 
                 if (mdata->s_bitmap_fe == NULL) {
                         if (sb->s_flags & MS_RDONLY)
-                                udf_warning(sb, __func__, "bitmap inode efe "
-                                        "not found but it's ok since the disc"
-                                        " is mounted read-only");
+                                udf_warn(sb, "bitmap inode efe not found but it's ok since the disc is mounted read-only\n");
                         else {
-                                udf_error(sb, __func__, "bitmap inode efe not "
-                                        "found and attempted read-write mount");
+                                udf_err(sb, "bitmap inode efe not found and attempted read-write mount\n");
                                 goto error_exit;
                         }
                 }
@@ -971,9 +950,8 @@ static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
                 bitmap = vzalloc(size); /* TODO: get rid of vzalloc */
 
         if (bitmap == NULL) {
-                udf_error(sb, __func__,
-                          "Unable to allocate space for bitmap "
-                          "and %d buffer_head pointers", nr_groups);
+                udf_err(sb, "Unable to allocate space for bitmap and %d buffer_head pointers\n",
+                        nr_groups);
                 return NULL;
         }
 
@@ -1003,10 +981,9 @@ static int udf_fill_partdesc_info(struct super_block *sb,
         if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
                 map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE;
 
-        udf_debug("Partition (%d type %x) starts at physical %d, "
-                  "block length %d\n", p_index,
-                  map->s_partition_type, map->s_partition_root,
-                  map->s_partition_len);
+        udf_debug("Partition (%d type %x) starts at physical %d, block length %d\n",
+                  p_index, map->s_partition_type,
+                  map->s_partition_root, map->s_partition_len);
 
         if (strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) &&
             strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03))
@@ -1023,12 +1000,12 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 map->s_uspace.s_table = udf_iget(sb, &loc);
                 if (!map->s_uspace.s_table) {
                         udf_debug("cannot load unallocSpaceTable (part %d)\n",
-                                        p_index);
+                                  p_index);
                         return 1;
                 }
                 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
                 udf_debug("unallocSpaceTable (part %d) @ %ld\n",
-                                p_index, map->s_uspace.s_table->i_ino);
+                          p_index, map->s_uspace.s_table->i_ino);
         }
 
         if (phd->unallocSpaceBitmap.extLength) {
@@ -1041,8 +1018,8 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 bitmap->s_extPosition = le32_to_cpu(
                                 phd->unallocSpaceBitmap.extPosition);
                 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
-                udf_debug("unallocSpaceBitmap (part %d) @ %d\n", p_index,
-                                                bitmap->s_extPosition);
+                udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
+                          p_index, bitmap->s_extPosition);
         }
 
         if (phd->partitionIntegrityTable.extLength)
@@ -1058,13 +1035,13 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 map->s_fspace.s_table = udf_iget(sb, &loc);
                 if (!map->s_fspace.s_table) {
                         udf_debug("cannot load freedSpaceTable (part %d)\n",
-                                p_index);
+                                  p_index);
                         return 1;
                 }
 
                 map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
                 udf_debug("freedSpaceTable (part %d) @ %ld\n",
-                                p_index, map->s_fspace.s_table->i_ino);
+                          p_index, map->s_fspace.s_table->i_ino);
         }
 
         if (phd->freedSpaceBitmap.extLength) {
@@ -1077,8 +1054,8 @@ static int udf_fill_partdesc_info(struct super_block *sb,
                 bitmap->s_extPosition = le32_to_cpu(
                                 phd->freedSpaceBitmap.extPosition);
                 map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
-                udf_debug("freedSpaceBitmap (part %d) @ %d\n", p_index,
-                                        bitmap->s_extPosition);
+                udf_debug("freedSpaceBitmap (part %d) @ %d\n",
+                          p_index, bitmap->s_extPosition);
         }
         return 0;
 }
@@ -1118,11 +1095,9 @@ static int udf_load_vat(struct super_block *sb, int p_index, int type1_index)
         udf_find_vat_block(sb, p_index, type1_index, sbi->s_last_block);
         if (!sbi->s_vat_inode &&
             sbi->s_last_block != blocks - 1) {
-                printk(KERN_NOTICE "UDF-fs: Failed to read VAT inode from the"
-                       " last recorded block (%lu), retrying with the last "
-                       "block of the device (%lu).\n",
-                       (unsigned long)sbi->s_last_block,
-                       (unsigned long)blocks - 1);
+                pr_notice("Failed to read VAT inode from the last recorded block (%lu), retrying with the last block of the device (%lu).\n",
+                          (unsigned long)sbi->s_last_block,
+                          (unsigned long)blocks - 1);
                 udf_find_vat_block(sb, p_index, type1_index, blocks - 1);
         }
         if (!sbi->s_vat_inode)
@@ -1220,8 +1195,8 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
         if (map->s_partition_type == UDF_METADATA_MAP25) {
                 ret = udf_load_metadata_files(sb, i);
                 if (ret) {
-                        printk(KERN_ERR "UDF-fs: error loading MetaData "
-                        "partition map %d\n", i);
+                        udf_err(sb, "error loading MetaData partition map %d\n",
+                                i);
                         goto out_bh;
                 }
         } else {
@@ -1234,9 +1209,7 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
                  * overwrite blocks instead of relocating them).
                  */
                 sb->s_flags |= MS_RDONLY;
-                printk(KERN_NOTICE "UDF-fs: Filesystem marked read-only "
-                        "because writing to pseudooverwrite partition is "
-                        "not implemented.\n");
+                pr_notice("Filesystem marked read-only because writing to pseudooverwrite partition is not implemented\n");
         }
 out_bh:
         /* In case loading failed, we handle cleanup in udf_fill_super */
@@ -1344,9 +1317,8 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                                 struct metadataPartitionMap *mdm =
                                                 (struct metadataPartitionMap *)
                                                 &(lvd->partitionMaps[offset]);
-                                udf_debug("Parsing Logical vol part %d "
-                                        "type %d  id=%s\n", i, type,
-                                        UDF_ID_METADATA);
+                                udf_debug("Parsing Logical vol part %d type %d  id=%s\n",
+                                          i, type, UDF_ID_METADATA);
 
                                 map->s_partition_type = UDF_METADATA_MAP25;
                                 map->s_partition_func = udf_get_pblock_meta25;
@@ -1361,25 +1333,24 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                                         le32_to_cpu(mdm->allocUnitSize);
                                 mdata->s_align_unit_size =
                                         le16_to_cpu(mdm->alignUnitSize);
-                                mdata->s_dup_md_flag     =
-                                        mdm->flags & 0x01;
+                                if (mdm->flags & 0x01)
+                                        mdata->s_flags |= MF_DUPLICATE_MD;
 
                                 udf_debug("Metadata Ident suffix=0x%x\n",
-                                        (le16_to_cpu(
-                                         ((__le16 *)
-                                              mdm->partIdent.identSuffix)[0])));
+                                          le16_to_cpu(*(__le16 *)
+                                                      mdm->partIdent.identSuffix));
                                 udf_debug("Metadata part num=%d\n",
-                                        le16_to_cpu(mdm->partitionNum));
+                                          le16_to_cpu(mdm->partitionNum));
                                 udf_debug("Metadata part alloc unit size=%d\n",
-                                        le32_to_cpu(mdm->allocUnitSize));
+                                          le32_to_cpu(mdm->allocUnitSize));
                                 udf_debug("Metadata file loc=%d\n",
-                                        le32_to_cpu(mdm->metadataFileLoc));
+                                          le32_to_cpu(mdm->metadataFileLoc));
                                 udf_debug("Mirror file loc=%d\n",
-                                       le32_to_cpu(mdm->metadataMirrorFileLoc));
+                                          le32_to_cpu(mdm->metadataMirrorFileLoc));
                                 udf_debug("Bitmap file loc=%d\n",
-                                       le32_to_cpu(mdm->metadataBitmapFileLoc));
-                                udf_debug("Duplicate Flag: %d %d\n",
-                                        mdata->s_dup_md_flag, mdm->flags);
+                                          le32_to_cpu(mdm->metadataBitmapFileLoc));
+                                udf_debug("Flags: %d %d\n",
+                                          mdata->s_flags, mdm->flags);
                         } else {
                                 udf_debug("Unknown ident: %s\n",
                                           upm2->partIdent.ident);
@@ -1389,16 +1360,15 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                         map->s_partition_num = le16_to_cpu(upm2->partitionNum);
                 }
                 udf_debug("Partition (%d:%d) type %d on volume %d\n",
-                          i, map->s_partition_num, type,
-                          map->s_volumeseqnum);
+                          i, map->s_partition_num, type, map->s_volumeseqnum);
         }
 
         if (fileset) {
                 struct long_ad *la = (struct long_ad *)&(lvd->logicalVolContentsUse[0]);
 
                 *fileset = lelb_to_cpu(la->extLocation);
-                udf_debug("FileSet found in LogicalVolDesc at block=%d, "
-                          "partition=%d\n", fileset->logicalBlockNum,
+                udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
+                          fileset->logicalBlockNum,
                           fileset->partitionReferenceNum);
         }
         if (lvd->integritySeqExt.extLength)
@@ -1478,9 +1448,9 @@ static noinline int udf_process_sequence(struct super_block *sb, long block,
 
                 bh = udf_read_tagged(sb, block, block, &ident);
                 if (!bh) {
-                        printk(KERN_ERR "udf: Block %Lu of volume descriptor "
-                               "sequence is corrupted or we could not read "
-                               "it.\n", (unsigned long long)block);
+                        udf_err(sb,
+                                "Block %llu of volume descriptor sequence is corrupted or we could not read it\n",
+                                (unsigned long long)block);
                         return 1;
                 }
 
@@ -1553,7 +1523,7 @@ static noinline int udf_process_sequence(struct super_block *sb, long block,
          * in a suitable order
          */
         if (!vds[VDS_POS_PRIMARY_VOL_DESC].block) {
-                printk(KERN_ERR "udf: Primary Volume Descriptor not found!\n");
+                udf_err(sb, "Primary Volume Descriptor not found!\n");
                 return 1;
         }
         if (udf_load_pvoldesc(sb, vds[VDS_POS_PRIMARY_VOL_DESC].block))
@@ -1740,7 +1710,7 @@ static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
 
         if (!sb_set_blocksize(sb, uopt->blocksize)) {
                 if (!silent)
-                        printk(KERN_WARNING "UDF-fs: Bad block size\n");
+                        udf_warn(sb, "Bad block size\n");
                 return 0;
         }
         sbi->s_last_block = uopt->lastblock;
@@ -1749,12 +1719,11 @@ static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
                 nsr_off = udf_check_vsd(sb);
                 if (!nsr_off) {
                         if (!silent)
-                                printk(KERN_WARNING "UDF-fs: No VRS found\n");
+                                udf_warn(sb, "No VRS found\n");
                         return 0;
                 }
                 if (nsr_off == -1)
-                        udf_debug("Failed to read byte 32768. Assuming open "
-                                  "disc. Skipping validity check\n");
+                        udf_debug("Failed to read byte 32768. Assuming open disc. Skipping validity check\n");
                 if (!sbi->s_last_block)
                         sbi->s_last_block = udf_get_last_block(sb);
         } else {
@@ -1765,7 +1734,7 @@ static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
         sbi->s_anchor = uopt->anchor;
         if (!udf_find_anchor(sb, fileset)) {
                 if (!silent)
-                        printk(KERN_WARNING "UDF-fs: No anchor found\n");
+                        udf_warn(sb, "No anchor found\n");
                 return 0;
         }
         return 1;
@@ -1937,8 +1906,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
 
         if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
             uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
-                udf_error(sb, "udf_read_super",
-                          "utf8 cannot be combined with iocharset\n");
+                udf_err(sb, "utf8 cannot be combined with iocharset\n");
                 goto error_out;
         }
 #ifdef CONFIG_UDF_NLS
@@ -1987,15 +1955,14 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                 ret = udf_load_vrs(sb, &uopt, silent, &fileset);
                 if (!ret && uopt.blocksize != UDF_DEFAULT_BLOCKSIZE) {
                         if (!silent)
-                                printk(KERN_NOTICE
-                                       "UDF-fs: Rescanning with blocksize "
-                                       "%d\n", UDF_DEFAULT_BLOCKSIZE);
+                                pr_notice("Rescanning with blocksize %d\n",
+                                          UDF_DEFAULT_BLOCKSIZE);
                         uopt.blocksize = UDF_DEFAULT_BLOCKSIZE;
                         ret = udf_load_vrs(sb, &uopt, silent, &fileset);
                 }
         }
         if (!ret) {
-                printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
+                udf_warn(sb, "No partition found (1)\n");
                 goto error_out;
         }
 
@@ -2010,10 +1977,9 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                                 le16_to_cpu(lvidiu->maxUDFWriteRev); */
 
                 if (minUDFReadRev > UDF_MAX_READ_VERSION) {
-                        printk(KERN_ERR "UDF-fs: minUDFReadRev=%x "
-                                        "(max is %x)\n",
-                               le16_to_cpu(lvidiu->minUDFReadRev),
-                               UDF_MAX_READ_VERSION);
+                        udf_err(sb, "minUDFReadRev=%x (max is %x)\n",
+                                le16_to_cpu(lvidiu->minUDFReadRev),
+                                UDF_MAX_READ_VERSION);
                         goto error_out;
                 } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
                         sb->s_flags |= MS_RDONLY;
@@ -2027,28 +1993,27 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         }
 
         if (!sbi->s_partitions) {
-                printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
+                udf_warn(sb, "No partition found (2)\n");
                 goto error_out;
         }
 
         if (sbi->s_partmaps[sbi->s_partition].s_partition_flags &
                         UDF_PART_FLAG_READ_ONLY) {
-                printk(KERN_NOTICE "UDF-fs: Partition marked readonly; "
-                                   "forcing readonly mount\n");
+                pr_notice("Partition marked readonly; forcing readonly mount\n");
                 sb->s_flags |= MS_RDONLY;
         }
 
         if (udf_find_fileset(sb, &fileset, &rootdir)) {
-                printk(KERN_WARNING "UDF-fs: No fileset found\n");
+                udf_warn(sb, "No fileset found\n");
                 goto error_out;
         }
 
         if (!silent) {
                 struct timestamp ts;
                 udf_time_to_disk_stamp(&ts, sbi->s_record_time);
-                udf_info("UDF: Mounting volume '%s', "
-                         "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
-                         sbi->s_volume_ident, le16_to_cpu(ts.year), ts.month, ts.day,
+                udf_info("Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
+                         sbi->s_volume_ident,
+                         le16_to_cpu(ts.year), ts.month, ts.day,
                          ts.hour, ts.minute, le16_to_cpu(ts.typeAndTimezone));
         }
         if (!(sb->s_flags & MS_RDONLY))
@@ -2059,8 +2024,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         /* perhaps it's not extensible enough, but for now ... */
         inode = udf_iget(sb, &rootdir);
         if (!inode) {
-                printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, "
-                                "partition=%d\n",
+                udf_err(sb, "Error in udf_iget, block=%d, partition=%d\n",
                        rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
                 goto error_out;
         }
@@ -2068,7 +2032,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         /* Allocate a dentry for the root inode */
         sb->s_root = d_alloc_root(inode);
         if (!sb->s_root) {
-                printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
+                udf_err(sb, "Couldn't allocate root dentry\n");
                 iput(inode);
                 goto error_out;
         }
@@ -2096,32 +2060,40 @@ error_out:
         return -EINVAL;
 }
 
-static void udf_error(struct super_block *sb, const char *function,
-                      const char *fmt, ...)
+void _udf_err(struct super_block *sb, const char *function,
+              const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
-        if (!(sb->s_flags & MS_RDONLY)) {
-                /* mark sb error */
+        /* mark sb error */
+        if (!(sb->s_flags & MS_RDONLY))
                 sb->s_dirt = 1;
-        }
+
         va_start(args, fmt);
-        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        pr_err("error (device %s): %s: %pV", sb->s_id, function, &vaf);
+
         va_end(args);
-        printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
-                sb->s_id, function, error_buf);
 }
 
-void udf_warning(struct super_block *sb, const char *function,
-                 const char *fmt, ...)
+void _udf_warn(struct super_block *sb, const char *function,
+               const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
         va_start(args, fmt);
-        vsnprintf(error_buf, sizeof(error_buf), fmt, args);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        pr_warn("warning (device %s): %s: %pV", sb->s_id, function, &vaf);
+
         va_end(args);
-        printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
-               sb->s_id, function, error_buf);
 }
 
 static void udf_put_super(struct super_block *sb)
@@ -2213,11 +2185,11 @@ static unsigned int udf_count_free_bitmap(struct super_block *sb,
         bh = udf_read_ptagged(sb, &loc, 0, &ident);
 
         if (!bh) {
-                printk(KERN_ERR "udf: udf_count_free failed\n");
+                udf_err(sb, "udf_count_free failed\n");
                 goto out;
         } else if (ident != TAG_IDENT_SBD) {
                 brelse(bh);
-                printk(KERN_ERR "udf: udf_count_free failed\n");
+                udf_err(sb, "udf_count_free failed\n");
                 goto out;
         }