From d1727d55c0327efdba2a5bad7801d509b721fef3 Mon Sep 17 00:00:00 2001

From: Joe Perches <joe@perches.com>

Date: Fri, 24 Apr 2020 13:31:12 +0900

Subject: [Backport d1727d55c032] exfat: Use a more common logging style

Remove the direct use of KERN_<LEVEL> in functions by creating

separate exfat_<level> macros.

Miscellanea:

o Remove several unnecessary terminating newlines in formats

o Realign arguments and fit to 80 columns where appropriate

Signed-off-by: Joe Perches <joe@perches.com>

Signed-off-by: Namjae Jeon <namjae.jeon@samsung.com>

---

 src/balloc.c   |  8 +++-----

 src/dir.c      |  9 ++++-----

 src/exfat_fs.h |  7 +++++++

 src/fatent.c   | 13 +++++--------

 src/misc.c     |  4 ++--

 src/namei.c    | 26 ++++++++++---------------

 src/nls.c      | 20 ++++++++-----------

 src/super.c    | 47 ++++++++++++++++++++-------------------------

 8 files changed, 60 insertions(+), 74 deletions(-)

diff --git a/src/balloc.c b/src/balloc.c

index 6774a5a6ded8290fb790bf70f04a1c6e3253cd7a..4055eb00ea9b84a3550dea0f831fafa2df3b3121 100644

--- a/src/balloc.c

+++ b/src/balloc.c

@@ -58,9 +58,8 @@ static int exfat_allocate_bitmap(struct super_block *sb,

 	need_map_size = ((EXFAT_DATA_CLUSTER_COUNT(sbi) - 1) / BITS_PER_BYTE)

 		+ 1;

 	if (need_map_size != map_size) {

-		exfat_msg(sb, KERN_ERR,

-				"bogus allocation bitmap size(need : %u, cur : %lld)",

-				need_map_size, map_size);

+		exfat_err(sb, "bogus allocation bitmap size(need : %u, cur : %lld)",

+			  need_map_size, map_size);

 		/*

 		 * Only allowed when bogus allocation

 		 * bitmap size is large

@@ -192,8 +191,7 @@ void exfat_clear_bitmap(struct inode *inode, unsigned int clu)

 			(1 << sbi->sect_per_clus_bits), GFP_NOFS, 0);

 		if (ret_discard == -EOPNOTSUPP) {

-			exfat_msg(sb, KERN_ERR,

-				"discard not supported by device, disabling");

+			exfat_err(sb, "discard not supported by device, disabling");

 			opts->discard = 0;

 		}

 	}

diff --git a/src/dir.c b/src/dir.c

index 4b91afb0f0515c06036821468b667ea14b43654d..53ae965da7ec583fb4e31cc548c40daf08ae941a 100644

--- a/src/dir.c

+++ b/src/dir.c

@@ -720,9 +720,8 @@ static int exfat_dir_readahead(struct super_block *sb, sector_t sec)

 		return 0;

 	if (sec < sbi->data_start_sector) {

-		exfat_msg(sb, KERN_ERR,

-			"requested sector is invalid(sect:%llu, root:%llu)",

-			(unsigned long long)sec, sbi->data_start_sector);

+		exfat_err(sb, "requested sector is invalid(sect:%llu, root:%llu)",

+			  (unsigned long long)sec, sbi->data_start_sector);

 		return -EIO;

 	}

@@ -750,7 +749,7 @@ struct exfat_dentry *exfat_get_dentry(struct super_block *sb,

 	sector_t sec;

 	if (p_dir->dir == DIR_DELETED) {

-		exfat_msg(sb, KERN_ERR, "abnormal access to deleted dentry\n");

+		exfat_err(sb, "abnormal access to deleted dentry");

 		return NULL;

 	}

@@ -853,7 +852,7 @@ struct exfat_entry_set_cache *exfat_get_dentry_set(struct super_block *sb,

 	struct buffer_head *bh;

 	if (p_dir->dir == DIR_DELETED) {

-		exfat_msg(sb, KERN_ERR, "access to deleted dentry\n");

+		exfat_err(sb, "access to deleted dentry");

 		return NULL;

 	}

diff --git a/src/exfat_fs.h b/src/exfat_fs.h

index d67fb8a6f770c28db8f1618c78fde493e2a4b965..1ebfb9085f1f719180051ee87aea94962accd238 100644

--- a/src/exfat_fs.h

+++ b/src/exfat_fs.h

@@ -505,6 +505,13 @@ void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...)

 		fmt, ## args)

 void exfat_msg(struct super_block *sb, const char *lv, const char *fmt, ...)

 		__printf(3, 4) __cold;

+#define exfat_err(sb, fmt, ...)						\

+	exfat_msg(sb, KERN_ERR, fmt, ##__VA_ARGS__)

+#define exfat_warn(sb, fmt, ...)					\

+	exfat_msg(sb, KERN_WARNING, fmt, ##__VA_ARGS__)

+#define exfat_info(sb, fmt, ...)					\

+	exfat_msg(sb, KERN_INFO, fmt, ##__VA_ARGS__)

+

 void exfat_get_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts,

 		u8 tz, __le16 time, __le16 date, u8 time_ms);

 void exfat_truncate_atime(struct timespec64 *ts);

diff --git a/src/fatent.c b/src/fatent.c

index a855b1769a96198264b134bfb45bcd4f6f6c01d1..267e5e09eb134c34990ac2d5ce17e2692c955be8 100644

--- a/src/fatent.c

+++ b/src/fatent.c

@@ -170,8 +170,7 @@ int exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain)

 	/* check cluster validation */

 	if (p_chain->dir < 2 && p_chain->dir >= sbi->num_clusters) {

-		exfat_msg(sb, KERN_ERR, "invalid start cluster (%u)",

-				p_chain->dir);

+		exfat_err(sb, "invalid start cluster (%u)", p_chain->dir);

 		return -EIO;

 	}

@@ -305,8 +304,7 @@ int exfat_zeroed_cluster(struct inode *dir, unsigned int clu)

 	return 0;

 release_bhs:

-	exfat_msg(sb, KERN_ERR, "failed zeroed sect %llu\n",

-		(unsigned long long)blknr);

+	exfat_err(sb, "failed zeroed sect %llu\n", (unsigned long long)blknr);

 	for (i = 0; i < n; i++)

 		bforget(bhs[i]);

 	return err;

@@ -337,9 +335,8 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,

 	/* find new cluster */

 	if (hint_clu == EXFAT_EOF_CLUSTER) {

 		if (sbi->clu_srch_ptr < EXFAT_FIRST_CLUSTER) {

-			exfat_msg(sb, KERN_ERR,

-				"sbi->clu_srch_ptr is invalid (%u)\n",

-				sbi->clu_srch_ptr);

+			exfat_err(sb, "sbi->clu_srch_ptr is invalid (%u)\n",

+				  sbi->clu_srch_ptr);

 			sbi->clu_srch_ptr = EXFAT_FIRST_CLUSTER;

 		}

@@ -350,7 +347,7 @@ int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,

 	/* check cluster validation */

 	if (hint_clu < EXFAT_FIRST_CLUSTER && hint_clu >= sbi->num_clusters) {

-		exfat_msg(sb, KERN_ERR, "hint_cluster is invalid (%u)\n",

+		exfat_err(sb, "hint_cluster is invalid (%u)",

 			hint_clu);

 		hint_clu = EXFAT_FIRST_CLUSTER;

 		if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {

diff --git a/src/misc.c b/src/misc.c

index ebd2cbe3cbc11c2aede3819c414020b9344ec1f9..ce5e8a1b0726c6778db86daebe39c437f23c7fba 100644

--- a/src/misc.c

+++ b/src/misc.c

@@ -32,7 +32,7 @@ void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...)

 		va_start(args, fmt);

 		vaf.fmt = fmt;

 		vaf.va = &arg;;

-		exfat_msg(sb, KERN_ERR, "error, %pV\n", &vaf;;

+		exfat_err(sb, "error, %pV", &vaf;;

 		va_end(args);

 	}

@@ -41,7 +41,7 @@ void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...)

 			sb->s_id);

 	} else if (opts->errors == EXFAT_ERRORS_RO && !sb_rdonly(sb)) {

 		sb->s_flags |= SB_RDONLY;

-		exfat_msg(sb, KERN_ERR, "Filesystem has been set read-only");

+		exfat_err(sb, "Filesystem has been set read-only");

 	}

 }

diff --git a/src/namei.c b/src/namei.c

index 731da41cabbf7b9dfd38f001fc502573bfd6c078..585b47b2db3da5d208fa1d53da9b18ae3d07c2dd 100644

--- a/src/namei.c

+++ b/src/namei.c

@@ -773,8 +773,8 @@ static struct dentry *exfat_lookup(struct inode *dir, struct dentry *dentry,

 		if (d_unhashed(alias)) {

 			WARN_ON(alias->d_name.hash_len !=

 				dentry->d_name.hash_len);

-			exfat_msg(sb, KERN_INFO,

-				"rehashed a dentry(%p) in read lookup", alias);

+			exfat_info(sb, "rehashed a dentry(%p) in read lookup",

+				   alias);

 			d_drop(dentry);

 			d_rehash(alias);

 		} else if (!S_ISDIR(i_mode)) {

@@ -819,7 +819,7 @@ static int exfat_unlink(struct inode *dir, struct dentry *dentry)

 	exfat_chain_dup(&cdir, &ei->dir);

 	entry = ei->entry;

 	if (ei->dir.dir == DIR_DELETED) {

-		exfat_msg(sb, KERN_ERR, "abnormal access to deleted dentry");

+		exfat_err(sb, "abnormal access to deleted dentry");

 		err = -ENOENT;

 		goto unlock;

 	}

@@ -974,7 +974,7 @@ static int exfat_rmdir(struct inode *dir, struct dentry *dentry)

 	entry = ei->entry;

 	if (ei->dir.dir == DIR_DELETED) {

-		exfat_msg(sb, KERN_ERR, "abnormal access to deleted dentry");

+		exfat_err(sb, "abnormal access to deleted dentry");

 		err = -ENOENT;

 		goto unlock;

 	}

@@ -986,9 +986,8 @@ static int exfat_rmdir(struct inode *dir, struct dentry *dentry)

 	err = exfat_check_dir_empty(sb, &clu_to_free);

 	if (err) {

 		if (err == -EIO)

-			exfat_msg(sb, KERN_ERR,

-				"failed to exfat_check_dir_empty : err(%d)",

-				err);

+			exfat_err(sb, "failed to exfat_check_dir_empty : err(%d)",

+				  err);

 		goto unlock;

 	}

@@ -1009,9 +1008,7 @@ static int exfat_rmdir(struct inode *dir, struct dentry *dentry)

 	err = exfat_remove_entries(dir, &cdir, entry, 0, num_entries);

 	if (err) {

-		exfat_msg(sb, KERN_ERR,

-				"failed to exfat_remove_entries : err(%d)",

-				err);

+		exfat_err(sb, "failed to exfat_remove_entries : err(%d)", err);

 		goto unlock;

 	}

 	ei->dir.dir = DIR_DELETED;

@@ -1240,8 +1237,7 @@ static int __exfat_rename(struct inode *old_parent_inode,

 		return -EINVAL;

 	if (ei->dir.dir == DIR_DELETED) {

-		exfat_msg(sb, KERN_ERR,

-				"abnormal access to deleted source dentry");

+		exfat_err(sb, "abnormal access to deleted source dentry");

 		return -ENOENT;

 	}

@@ -1263,8 +1259,7 @@ static int __exfat_rename(struct inode *old_parent_inode,

 		new_ei = EXFAT_I(new_inode);

 		if (new_ei->dir.dir == DIR_DELETED) {

-			exfat_msg(sb, KERN_ERR,

-				"abnormal access to deleted target dentry");

+			exfat_err(sb, "abnormal access to deleted target dentry");

 			goto out;

 		}

@@ -1426,8 +1421,7 @@ static int exfat_rename(struct inode *old_dir, struct dentry *old_dentry,

 			if (S_ISDIR(new_inode->i_mode))

 				drop_nlink(new_inode);

 		} else {

-			exfat_msg(sb, KERN_WARNING,

-					"abnormal access to an inode dropped");

+			exfat_warn(sb, "abnormal access to an inode dropped");

 			WARN_ON(new_inode->i_nlink == 0);

 		}

 		new_inode->i_ctime = EXFAT_I(new_inode)->i_crtime =

diff --git a/src/nls.c b/src/nls.c

index 6d1c3ae130ff177cec9261510b6f7c4a961f5177..2178786b708b577a385137994a41e078bedcb8b7 100644

--- a/src/nls.c

+++ b/src/nls.c

@@ -503,16 +503,14 @@ static int exfat_utf8_to_utf16(struct super_block *sb,

 	unilen = utf8s_to_utf16s(p_cstring, len, UTF16_HOST_ENDIAN,

 			(wchar_t *)uniname, MAX_NAME_LENGTH + 2);

 	if (unilen < 0) {

-		exfat_msg(sb, KERN_ERR,

-			"failed to %s (err : %d) nls len : %d",

-			__func__, unilen, len);

+		exfat_err(sb, "failed to %s (err : %d) nls len : %d",

+			  __func__, unilen, len);

 		return unilen;

 	}

 	if (unilen > MAX_NAME_LENGTH) {

-		exfat_msg(sb, KERN_ERR,

-			"failed to %s (estr:ENAMETOOLONG) nls len : %d, unilen : %d > %d",

-			__func__, len, unilen, MAX_NAME_LENGTH);

+		exfat_err(sb, "failed to %s (estr:ENAMETOOLONG) nls len : %d, unilen : %d > %d",

+			  __func__, len, unilen, MAX_NAME_LENGTH);

 		return -ENAMETOOLONG;

 	}

@@ -687,9 +685,8 @@ static int exfat_load_upcase_table(struct super_block *sb,

 		bh = sb_bread(sb, sector);

 		if (!bh) {

-			exfat_msg(sb, KERN_ERR,

-				"failed to read sector(0x%llx)\n",

-				(unsigned long long)sector);

+			exfat_err(sb, "failed to read sector(0x%llx)\n",

+				  (unsigned long long)sector);

 			ret = -EIO;

 			goto free_table;

 		}

@@ -722,9 +719,8 @@ static int exfat_load_upcase_table(struct super_block *sb,

 	if (index >= 0xFFFF && utbl_checksum == checksum)

 		return 0;

-	exfat_msg(sb, KERN_ERR,

-			"failed to load upcase table (idx : 0x%08x, chksum : 0x%08x, utbl_chksum : 0x%08x)\n",

-			index, checksum, utbl_checksum);

+	exfat_err(sb, "failed to load upcase table (idx : 0x%08x, chksum : 0x%08x, utbl_chksum : 0x%08x)",

+		  index, checksum, utbl_checksum);

 	ret = -EINVAL;

 free_table:

 	exfat_free_upcase_table(sbi);

diff --git a/src/super.c b/src/super.c

index a846ff555656cd876e77ae014b35e192b5ccd183..f9aa1e5dc2381a4f9e4f9dc6f3d61dc525f1095c 100644

--- a/src/super.c

+++ b/src/super.c

@@ -376,15 +376,13 @@ static struct pbr *exfat_read_pbr_with_logical_sector(struct super_block *sb)

 	if (!is_power_of_2(logical_sect) ||

 	    logical_sect < 512 || logical_sect > 4096) {

-		exfat_msg(sb, KERN_ERR, "bogus logical sector size %u",

-				logical_sect);

+		exfat_err(sb, "bogus logical sector size %u", logical_sect);

 		return NULL;

 	}

 	if (logical_sect < sb->s_blocksize) {

-		exfat_msg(sb, KERN_ERR,

-			"logical sector size too small for device (logical sector size = %u)",

-			logical_sect);

+		exfat_err(sb, "logical sector size too small for device (logical sector size = %u)",

+			  logical_sect);

 		return NULL;

 	}

@@ -393,15 +391,14 @@ static struct pbr *exfat_read_pbr_with_logical_sector(struct super_block *sb)

 		sbi->pbr_bh = NULL;

 		if (!sb_set_blocksize(sb, logical_sect)) {

-			exfat_msg(sb, KERN_ERR,

-				"unable to set blocksize %u", logical_sect);

+			exfat_err(sb, "unable to set blocksize %u",

+				  logical_sect);

 			return NULL;

 		}

 		sbi->pbr_bh = sb_bread(sb, 0);

 		if (!sbi->pbr_bh) {

-			exfat_msg(sb, KERN_ERR,

-				"unable to read boot sector (logical sector size = %lu)",

-				sb->s_blocksize);

+			exfat_err(sb, "unable to read boot sector (logical sector size = %lu)",

+				  sb->s_blocksize);

 			return NULL;

 		}

@@ -424,7 +421,7 @@ static int __exfat_fill_super(struct super_block *sb)

 	/* read boot sector */

 	sbi->pbr_bh = sb_bread(sb, 0);

 	if (!sbi->pbr_bh) {

-		exfat_msg(sb, KERN_ERR, "unable to read boot sector");

+		exfat_err(sb, "unable to read boot sector");

 		return -EIO;

 	}

@@ -433,7 +430,7 @@ static int __exfat_fill_super(struct super_block *sb)

 	/* check the validity of PBR */

 	if (le16_to_cpu((p_pbr->signature)) != PBR_SIGNATURE) {

-		exfat_msg(sb, KERN_ERR, "invalid boot record signature");

+		exfat_err(sb, "invalid boot record signature");

 		ret = -EINVAL;

 		goto free_bh;

 	}

@@ -458,7 +455,7 @@ static int __exfat_fill_super(struct super_block *sb)

 	p_bpb = (struct pbr64 *)p_pbr;

 	if (!p_bpb->bsx.num_fats) {

-		exfat_msg(sb, KERN_ERR, "bogus number of FAT structure");

+		exfat_err(sb, "bogus number of FAT structure");

 		ret = -EINVAL;

 		goto free_bh;

 	}

@@ -488,8 +485,7 @@ static int __exfat_fill_super(struct super_block *sb)

 	if (le16_to_cpu(p_bpb->bsx.vol_flags) & VOL_DIRTY) {

 		sbi->vol_flag |= VOL_DIRTY;

-		exfat_msg(sb, KERN_WARNING,

-			"Volume was not properly unmounted. Some data may be corrupt. Please run fsck.");

+		exfat_warn(sb, "Volume was not properly unmounted. Some data may be corrupt. Please run fsck.");

 	}

 	/* exFAT file size is limited by a disk volume size */

@@ -498,19 +494,19 @@ static int __exfat_fill_super(struct super_block *sb)

 	ret = exfat_create_upcase_table(sb);

 	if (ret) {

-		exfat_msg(sb, KERN_ERR, "failed to load upcase table");

+		exfat_err(sb, "failed to load upcase table");

 		goto free_bh;

 	}

 	ret = exfat_load_bitmap(sb);

 	if (ret) {

-		exfat_msg(sb, KERN_ERR, "failed to load alloc-bitmap");

+		exfat_err(sb, "failed to load alloc-bitmap");

 		goto free_upcase_table;

 	}

 	ret = exfat_count_used_clusters(sb, &sbi->used_clusters);

 	if (ret) {

-		exfat_msg(sb, KERN_ERR, "failed to scan clusters");

+		exfat_err(sb, "failed to scan clusters");

 		goto free_alloc_bitmap;

 	}

@@ -539,8 +535,7 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)

 		struct request_queue *q = bdev_get_queue(sb->s_bdev);

 		if (!blk_queue_discard(q)) {

-			exfat_msg(sb, KERN_WARNING,

-				"mounting with \"discard\" option, but the device does not support discard");

+			exfat_warn(sb, "mounting with \"discard\" option, but the device does not support discard");

 			opts->discard = 0;

 		}

 	}

@@ -555,7 +550,7 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)

 	err = __exfat_fill_super(sb);

 	if (err) {

-		exfat_msg(sb, KERN_ERR, "failed to recognize exfat type");

+		exfat_err(sb, "failed to recognize exfat type");

 		goto check_nls_io;

 	}

@@ -567,8 +562,8 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)

 	else {

 		sbi->nls_io = load_nls(sbi->options.iocharset);

 		if (!sbi->nls_io) {

-			exfat_msg(sb, KERN_ERR, "IO charset %s not found",

-					sbi->options.iocharset);

+			exfat_err(sb, "IO charset %s not found",

+				  sbi->options.iocharset);

 			err = -EINVAL;

 			goto free_table;

 		}

@@ -581,7 +576,7 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)

 	root_inode = new_inode(sb);

 	if (!root_inode) {

-		exfat_msg(sb, KERN_ERR, "failed to allocate root inode.");

+		exfat_err(sb, "failed to allocate root inode");

 		err = -ENOMEM;

 		goto free_table;

 	}

@@ -590,7 +585,7 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)

 	inode_set_iversion(root_inode, 1);

 	err = exfat_read_root(root_inode);

 	if (err) {

-		exfat_msg(sb, KERN_ERR, "failed to initialize root inode.");

+		exfat_err(sb, "failed to initialize root inode");

 		goto put_inode;

 	}

@@ -599,7 +594,7 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)

 	sb->s_root = d_make_root(root_inode);

 	if (!sb->s_root) {

-		exfat_msg(sb, KERN_ERR, "failed to get the root dentry");

+		exfat_err(sb, "failed to get the root dentry");

 		err = -ENOMEM;

 		goto put_inode;

 	}

-- 

2.31.1