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

Commit a07ef784 authored by Namjae Jeon's avatar Namjae Jeon Committed by Jaegeuk Kim
Browse files

f2fs: introduce f2fs_msg to ease adding information prints 



Introduced f2fs_msg function to differentiate f2fs specific messages in
the log. And, added few informative prints in the mount path, to convey
proper error in case of mount failure.

Signed-off-by: default avatarNamjae Jeon <namjae.jeon@samsung.com>
Signed-off-by: default avatarAmit Sahrawat <a.sahrawat@samsung.com>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk.kim@samsung.com>
parent 5f738967

fs/f2fs/f2fs.h

+2 −0
Original line number Diff line number Diff line
@@ -877,6 +877,8 @@ bool f2fs_empty_dir(struct inode *); 
 * super.c

 */

int f2fs_sync_fs(struct super_block *, int);

extern __printf(3, 4)

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



/*

 * hash.c

fs/f2fs/super.c

+63 −17
Original line number Diff line number Diff line
@@ -53,6 +53,18 @@ static match_table_t f2fs_tokens = { 
	{Opt_err, NULL},

};



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

{

	struct va_format vaf;

	va_list args;



	va_start(args, fmt);

	vaf.fmt = fmt;

	vaf.va = &args;

	printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf);

	va_end(args);

}



static void init_once(void *foo)

{

	struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
@@ -247,7 +259,8 @@ static const struct export_operations f2fs_export_ops = { 
	.get_parent = f2fs_get_parent,

};



static int parse_options(struct f2fs_sb_info *sbi, char *options)

static int parse_options(struct super_block *sb, struct f2fs_sb_info *sbi,

				char *options)

{

	substring_t args[MAX_OPT_ARGS];

	char *p;
@@ -286,7 +299,8 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options) 
			break;

#else

		case Opt_nouser_xattr:

			pr_info("nouser_xattr options not supported\n");

			f2fs_msg(sb, KERN_INFO,

				"nouser_xattr options not supported");

			break;

#endif

#ifdef CONFIG_F2FS_FS_POSIX_ACL
@@ -295,7 +309,7 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options) 
			break;

#else

		case Opt_noacl:

			pr_info("noacl options not supported\n");

			f2fs_msg(sb, KERN_INFO, "noacl options not supported");

			break;

#endif

		case Opt_active_logs:
@@ -309,7 +323,8 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options) 
			set_opt(sbi, DISABLE_EXT_IDENTIFY);

			break;

		default:

			pr_err("Unrecognized mount option \"%s\" or missing value\n",

			f2fs_msg(sb, KERN_ERR,

				"Unrecognized mount option \"%s\" or missing value",

				p);

			return -EINVAL;

		}
@@ -337,23 +352,36 @@ static loff_t max_file_size(unsigned bits) 
	return result;

}



static int sanity_check_raw_super(struct f2fs_super_block *raw_super)

static int sanity_check_raw_super(struct super_block *sb,

			struct f2fs_super_block *raw_super)

{

	unsigned int blocksize;



	if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic))

	if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {

		f2fs_msg(sb, KERN_INFO,

			"Magic Mismatch, valid(0x%x) - read(0x%x)",

			F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));

		return 1;

	}



	/* Currently, support only 4KB block size */

	blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);

	if (blocksize != PAGE_CACHE_SIZE)

	if (blocksize != PAGE_CACHE_SIZE) {

		f2fs_msg(sb, KERN_INFO,

			"Invalid blocksize (%u), supports only 4KB\n",

			blocksize);

		return 1;

	}

	if (le32_to_cpu(raw_super->log_sectorsize) !=

					F2FS_LOG_SECTOR_SIZE)

					F2FS_LOG_SECTOR_SIZE) {

		f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize");

		return 1;

	}

	if (le32_to_cpu(raw_super->log_sectors_per_block) !=

					F2FS_LOG_SECTORS_PER_BLOCK)

					F2FS_LOG_SECTORS_PER_BLOCK) {

		f2fs_msg(sb, KERN_INFO, "Invalid log sectors per block");

		return 1;

	}

	return 0;

}
@@ -414,13 +442,16 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 
		return -ENOMEM;



	/* set a temporary block size */

	if (!sb_set_blocksize(sb, F2FS_BLKSIZE))

	if (!sb_set_blocksize(sb, F2FS_BLKSIZE)) {

		f2fs_msg(sb, KERN_ERR, "unable to set blocksize");

		goto free_sbi;

	}



	/* read f2fs raw super block */

	raw_super_buf = sb_bread(sb, 0);

	if (!raw_super_buf) {

		err = -EIO;

		f2fs_msg(sb, KERN_ERR, "unable to read superblock");

		goto free_sbi;

	}

	raw_super = (struct f2fs_super_block *)
@@ -438,12 +469,14 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 
	set_opt(sbi, POSIX_ACL);

#endif

	/* parse mount options */

	if (parse_options(sbi, (char *)data))

	if (parse_options(sb, sbi, (char *)data))

		goto free_sb_buf;



	/* sanity checking of raw super */

	if (sanity_check_raw_super(raw_super))

	if (sanity_check_raw_super(sb, raw_super)) {

		f2fs_msg(sb, KERN_ERR, "Can't find a valid F2FS filesystem");

		goto free_sb_buf;

	}



	sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize));

	sb->s_max_links = F2FS_LINK_MAX;
@@ -477,18 +510,23 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 
	/* get an inode for meta space */

	sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));

	if (IS_ERR(sbi->meta_inode)) {

		f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");

		err = PTR_ERR(sbi->meta_inode);

		goto free_sb_buf;

	}



	err = get_valid_checkpoint(sbi);

	if (err)

	if (err) {

		f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");

		goto free_meta_inode;

	}



	/* sanity checking of checkpoint */

	err = -EINVAL;

	if (sanity_check_ckpt(raw_super, sbi->ckpt))

	if (sanity_check_ckpt(raw_super, sbi->ckpt)) {

		f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint");

		goto free_cp;

	}



	sbi->total_valid_node_count =

				le32_to_cpu(sbi->ckpt->valid_node_count);
@@ -510,17 +548,24 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 


	/* setup f2fs internal modules */

	err = build_segment_manager(sbi);

	if (err)

	if (err) {

		f2fs_msg(sb, KERN_ERR,

			"Failed to initialize F2FS segment manager");

		goto free_sm;

	}

	err = build_node_manager(sbi);

	if (err)

	if (err) {

		f2fs_msg(sb, KERN_ERR,

			"Failed to initialize F2FS node manager");

		goto free_nm;

	}



	build_gc_manager(sbi);



	/* get an inode for node space */

	sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));

	if (IS_ERR(sbi->node_inode)) {

		f2fs_msg(sb, KERN_ERR, "Failed to read node inode");

		err = PTR_ERR(sbi->node_inode);

		goto free_nm;

	}
@@ -533,6 +578,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 
	/* read root inode and dentry */

	root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));

	if (IS_ERR(root)) {

		f2fs_msg(sb, KERN_ERR, "Failed to read root inode");

		err = PTR_ERR(root);

		goto free_node_inode;

	}