Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dcbb4c10 authored by Joe Perches's avatar Joe Perches Committed by Jaegeuk Kim
Browse files

f2fs: introduce f2fs_<level> macros to wrap f2fs_printk() 



- Add and use f2fs_<level> macros
- Convert f2fs_msg to f2fs_printk
- Remove level from f2fs_printk and embed the level in the format
- Coalesce formats and align multi-line arguments
- Remove unnecessary duplicate extern f2fs_msg f2fs.h

Signed-off-by: default avatarJoe Perches <joe@perches.com>
Signed-off-by: default avatarChao Yu <yuchao0@huawei.com>
Reviewed-by: default avatarChao Yu <yuchao0@huawei.com>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 8740edc3

fs/f2fs/checkpoint.c

+14 −20
Original line number Diff line number Diff line
@@ -146,8 +146,8 @@ static bool __is_bitmap_valid(struct f2fs_sb_info *sbi, block_t blkaddr, 


	exist = f2fs_test_bit(offset, se->cur_valid_map);

	if (!exist && type == DATA_GENERIC_ENHANCE) {

		f2fs_msg(sbi->sb, KERN_ERR, "Inconsistent error "

			"blkaddr:%u, sit bitmap:%d", blkaddr, exist);

		f2fs_err(sbi, "Inconsistent error blkaddr:%u, sit bitmap:%d",

			 blkaddr, exist);

		set_sbi_flag(sbi, SBI_NEED_FSCK);

		WARN_ON(1);

	}
@@ -184,8 +184,8 @@ bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi, 
	case DATA_GENERIC_ENHANCE_READ:

		if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||

				blkaddr < MAIN_BLKADDR(sbi))) {

			f2fs_msg(sbi->sb, KERN_WARNING,

				"access invalid blkaddr:%u", blkaddr);

			f2fs_warn(sbi, "access invalid blkaddr:%u",

				  blkaddr);

			set_sbi_flag(sbi, SBI_NEED_FSCK);

			WARN_ON(1);

			return false;
@@ -657,8 +657,7 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 


err_out:

	set_sbi_flag(sbi, SBI_NEED_FSCK);

	f2fs_msg(sbi->sb, KERN_WARNING,

			"%s: orphan failed (ino=%x), run fsck to fix.",

	f2fs_warn(sbi, "%s: orphan failed (ino=%x), run fsck to fix.",

		  __func__, ino);

	return err;

}
@@ -676,13 +675,12 @@ int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi) 
		return 0;



	if (bdev_read_only(sbi->sb->s_bdev)) {

		f2fs_msg(sbi->sb, KERN_INFO, "write access "

			"unavailable, skipping orphan cleanup");

		f2fs_info(sbi, "write access unavailable, skipping orphan cleanup");

		return 0;

	}



	if (s_flags & SB_RDONLY) {

		f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs");

		f2fs_info(sbi, "orphan cleanup on readonly fs");

		sbi->sb->s_flags &= ~SB_RDONLY;

	}
@@ -827,15 +825,14 @@ static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr, 
	if (crc_offset < CP_MIN_CHKSUM_OFFSET ||

			crc_offset > CP_CHKSUM_OFFSET) {

		f2fs_put_page(*cp_page, 1);

		f2fs_msg(sbi->sb, KERN_WARNING,

			"invalid crc_offset: %zu", crc_offset);

		f2fs_warn(sbi, "invalid crc_offset: %zu", crc_offset);

		return -EINVAL;

	}



	crc = f2fs_checkpoint_chksum(sbi, *cp_block);

	if (crc != cur_cp_crc(*cp_block)) {

		f2fs_put_page(*cp_page, 1);

		f2fs_msg(sbi->sb, KERN_WARNING, "invalid crc value");

		f2fs_warn(sbi, "invalid crc value");

		return -EINVAL;

	}
@@ -858,8 +855,7 @@ static struct page *validate_checkpoint(struct f2fs_sb_info *sbi, 


	if (le32_to_cpu(cp_block->cp_pack_total_block_count) >

					sbi->blocks_per_seg) {

		f2fs_msg(sbi->sb, KERN_WARNING,

			"invalid cp_pack_total_block_count:%u",

		f2fs_warn(sbi, "invalid cp_pack_total_block_count:%u",

			  le32_to_cpu(cp_block->cp_pack_total_block_count));

		goto invalid_cp;

	}
@@ -1559,8 +1555,7 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {

		if (cpc->reason != CP_PAUSE)

			return 0;

		f2fs_msg(sbi->sb, KERN_WARNING,

				"Start checkpoint disabled!");

		f2fs_warn(sbi, "Start checkpoint disabled!");

	}

	mutex_lock(&sbi->cp_mutex);
@@ -1626,8 +1621,7 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	stat_inc_cp_count(sbi->stat_info);



	if (cpc->reason & CP_RECOVERY)

		f2fs_msg(sbi->sb, KERN_NOTICE,

			"checkpoint: version = %llx", ckpt_ver);

		f2fs_notice(sbi, "checkpoint: version = %llx", ckpt_ver);



	/* do checkpoint periodically */

	f2fs_update_time(sbi, CP_TIME);

fs/f2fs/dir.c

+4 −6
Original line number Diff line number Diff line
@@ -218,8 +218,7 @@ struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir, 


	max_depth = F2FS_I(dir)->i_current_depth;

	if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {

		f2fs_msg(F2FS_I_SB(dir)->sb, KERN_WARNING,

				"Corrupted max_depth of %lu: %u",

		f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %lu: %u",

			  dir->i_ino, max_depth);

		max_depth = MAX_DIR_HASH_DEPTH;

		f2fs_i_depth_write(dir, max_depth);
@@ -816,8 +815,7 @@ int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, 
		bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));

		if (unlikely(bit_pos > d->max ||

				le16_to_cpu(de->name_len) > F2FS_NAME_LEN)) {

			f2fs_msg(sbi->sb, KERN_WARNING,

				"%s: corrupted namelen=%d, run fsck to fix.",

			f2fs_warn(sbi, "%s: corrupted namelen=%d, run fsck to fix.",

				  __func__, le16_to_cpu(de->name_len));

			set_sbi_flag(sbi, SBI_NEED_FSCK);

			err = -EINVAL;

fs/f2fs/extent_cache.c

+3 −4
Original line number Diff line number Diff line
@@ -184,8 +184,7 @@ bool f2fs_check_rb_tree_consistence(struct f2fs_sb_info *sbi, 
		next_re = rb_entry(next, struct rb_entry, rb_node);



		if (cur_re->ofs + cur_re->len > next_re->ofs) {

			f2fs_msg(sbi->sb, KERN_INFO, "inconsistent rbtree, "

				"cur(%u, %u) next(%u, %u)",

			f2fs_info(sbi, "inconsistent rbtree, cur(%u, %u) next(%u, %u)",

				  cur_re->ofs, cur_re->len,

				  next_re->ofs, next_re->len);

			return false;

fs/f2fs/f2fs.h

+23 −15
Original line number Diff line number Diff line
@@ -1808,7 +1808,20 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi, 
	return -ENOSPC;

}



void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...);

__printf(2, 3)

void f2fs_printk(struct f2fs_sb_info *sbi, const char *fmt, ...);



#define f2fs_err(sbi, fmt, ...)						\

	f2fs_printk(sbi, KERN_ERR fmt, ##__VA_ARGS__)

#define f2fs_warn(sbi, fmt, ...)					\

	f2fs_printk(sbi, KERN_WARNING fmt, ##__VA_ARGS__)

#define f2fs_notice(sbi, fmt, ...)					\

	f2fs_printk(sbi, KERN_NOTICE fmt, ##__VA_ARGS__)

#define f2fs_info(sbi, fmt, ...)					\

	f2fs_printk(sbi, KERN_INFO fmt, ##__VA_ARGS__)

#define f2fs_debug(sbi, fmt, ...)					\

	f2fs_printk(sbi, KERN_DEBUG fmt, ##__VA_ARGS__)



static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,

						struct inode *inode,

						block_t count)
@@ -1824,8 +1837,7 @@ static inline void dec_valid_block_count(struct f2fs_sb_info *sbi, 
					sbi->current_reserved_blocks + count);

	spin_unlock(&sbi->stat_lock);

	if (unlikely(inode->i_blocks < sectors)) {

		f2fs_msg(sbi->sb, KERN_WARNING,

			"Inconsistent i_blocks, ino:%lu, iblocks:%llu, sectors:%llu",

		f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu, sectors:%llu",

			  inode->i_ino,

			  (unsigned long long)inode->i_blocks,

			  (unsigned long long)sectors);
@@ -2066,8 +2078,7 @@ static inline void dec_valid_node_count(struct f2fs_sb_info *sbi, 
		dquot_free_inode(inode);

	} else {

		if (unlikely(inode->i_blocks == 0)) {

			f2fs_msg(sbi->sb, KERN_WARNING,

				"Inconsistent i_blocks, ino:%lu, iblocks:%llu",

			f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu",

				  inode->i_ino,

				  (unsigned long long)inode->i_blocks);

			set_sbi_flag(sbi, SBI_NEED_FSCK);
@@ -2839,8 +2850,7 @@ static inline void verify_blkaddr(struct f2fs_sb_info *sbi, 
					block_t blkaddr, int type)

{

	if (!f2fs_is_valid_blkaddr(sbi, blkaddr, type)) {

		f2fs_msg(sbi->sb, KERN_ERR,

			"invalid blkaddr: %u, type: %d, run fsck to fix.",

		f2fs_err(sbi, "invalid blkaddr: %u, type: %d, run fsck to fix.",

			 blkaddr, type);

		f2fs_bug_on(sbi, 1);

	}
@@ -2972,8 +2982,6 @@ int f2fs_quota_sync(struct super_block *sb, int type); 
void f2fs_quota_off_umount(struct super_block *sb);

int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover);

int f2fs_sync_fs(struct super_block *sb, int sync);

extern __printf(3, 4)

void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...);

int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi);



/*

fs/f2fs/file.c

+8 −13
Original line number Diff line number Diff line
@@ -1837,8 +1837,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp) 
	 * f2fs_is_atomic_file.

	 */

	if (get_dirty_pages(inode))

		f2fs_msg(F2FS_I_SB(inode)->sb, KERN_WARNING,

		"Unexpected flush for atomic writes: ino=%lu, npages=%u",

		f2fs_warn(F2FS_I_SB(inode), "Unexpected flush for atomic writes: ino=%lu, npages=%u",

			  inode->i_ino, get_dirty_pages(inode));

	ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);

	if (ret) {
@@ -2274,8 +2273,7 @@ static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg) 
		return -EROFS;



	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {

		f2fs_msg(sbi->sb, KERN_INFO,

			"Skipping Checkpoint. Checkpoints currently disabled.");

		f2fs_info(sbi, "Skipping Checkpoint. Checkpoints currently disabled.");

		return -EINVAL;

	}
@@ -2660,10 +2658,8 @@ static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg) 


	if (!f2fs_is_multi_device(sbi) || sbi->s_ndevs - 1 <= range.dev_num ||

			__is_large_section(sbi)) {

		f2fs_msg(sbi->sb, KERN_WARNING,

			"Can't flush %u in %d for segs_per_sec %u != 1",

				range.dev_num, sbi->s_ndevs,

				sbi->segs_per_sec);

		f2fs_warn(sbi, "Can't flush %u in %d for segs_per_sec %u != 1",

			  range.dev_num, sbi->s_ndevs, sbi->segs_per_sec);

		return -EINVAL;

	}
@@ -2948,8 +2944,7 @@ int f2fs_pin_file_control(struct inode *inode, bool inc) 
				fi->i_gc_failures[GC_FAILURE_PIN] + 1);



	if (fi->i_gc_failures[GC_FAILURE_PIN] > sbi->gc_pin_file_threshold) {

		f2fs_msg(sbi->sb, KERN_WARNING,

			"%s: Enable GC = ino %lx after %x GC trials",

		f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",

			  __func__, inode->i_ino,

			  fi->i_gc_failures[GC_FAILURE_PIN]);

		clear_inode_flag(inode, FI_PIN_FILE);