f2fs: show f2fs instance in printk_ratelimited

chaseyu · Jaegeuk Kim · commit c45d6002ff7a · 2019-11-19T14:41:21.000-08:00
As Eric mentioned, bare printk{,_ratelimited} won't show which
filesystem instance these message is coming from, this patch tries
to show fs instance with sb-&gt;s_id field in all places we missed
before.

Signed-off-by: Chao Yu &lt;yuchao0@huawei.com&gt;
Signed-off-by: Jaegeuk Kim &lt;jaegeuk@kernel.org&gt;
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
@@ -581,7 +581,7 @@ int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi)
 
 	if (time_to_inject(sbi, FAULT_ORPHAN)) {
 		spin_unlock(&im->ino_lock);
-		f2fs_show_injection_info(FAULT_ORPHAN);
+		f2fs_show_injection_info(sbi, FAULT_ORPHAN);
 		return -ENOSPC;
 	}
 
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
@@ -168,9 +168,10 @@ static bool f2fs_bio_post_read_required(struct bio *bio)
 
 static void f2fs_read_end_io(struct bio *bio)
 {
-	if (time_to_inject(F2FS_P_SB(bio_first_page_all(bio)),
-						FAULT_READ_IO)) {
-		f2fs_show_injection_info(FAULT_READ_IO);
+	struct f2fs_sb_info *sbi = F2FS_P_SB(bio_first_page_all(bio));
+
+	if (time_to_inject(sbi, FAULT_READ_IO)) {
+		f2fs_show_injection_info(sbi, FAULT_READ_IO);
 		bio->bi_status = BLK_STS_IOERR;
 	}
 
@@ -192,7 +193,7 @@ static void f2fs_write_end_io(struct bio *bio)
 	struct bvec_iter_all iter_all;
 
 	if (time_to_inject(sbi, FAULT_WRITE_IO)) {
-		f2fs_show_injection_info(FAULT_WRITE_IO);
+		f2fs_show_injection_info(sbi, FAULT_WRITE_IO);
 		bio->bi_status = BLK_STS_IOERR;
 	}
 
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
@@ -628,7 +628,7 @@ int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
 
 start:
 	if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH)) {
-		f2fs_show_injection_info(FAULT_DIR_DEPTH);
+		f2fs_show_injection_info(F2FS_I_SB(dir), FAULT_DIR_DEPTH);
 		return -ENOSPC;
 	}
 
@@ -919,8 +919,9 @@ int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
 			bit_pos++;
 			ctx->pos = start_pos + bit_pos;
 			printk_ratelimited(
-				"%s, invalid namelen(0), ino:%u, run fsck to fix.",
-				KERN_WARNING, le32_to_cpu(de->ino));
+				"%sF2FS-fs (%s): invalid namelen(0), ino:%u, run fsck to fix.",
+				KERN_WARNING, sbi->sb->s_id,
+				le32_to_cpu(de->ino));
 			set_sbi_flag(sbi, SBI_NEED_FSCK);
 			continue;
 		}
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
@@ -1374,9 +1374,10 @@ struct f2fs_private_dio {
 };
 
 #ifdef CONFIG_F2FS_FAULT_INJECTION
-#define f2fs_show_injection_info(type)					\
-	printk_ratelimited("%sF2FS-fs : inject %s in %s of %pS\n",	\
-		KERN_INFO, f2fs_fault_name[type],			\
+#define f2fs_show_injection_info(sbi, type)					\
+	printk_ratelimited("%sF2FS-fs (%s) : inject %s in %s of %pS\n",	\
+		KERN_INFO, sbi->sb->s_id,				\
+		f2fs_fault_name[type],					\
 		__func__, __builtin_return_address(0))
 static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
 {
@@ -1396,7 +1397,7 @@ static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
 	return false;
 }
 #else
-#define f2fs_show_injection_info(type) do { } while (0)
+#define f2fs_show_injection_info(sbi, type) do { } while (0)
 static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
 {
 	return false;
@@ -1781,7 +1782,7 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,
 		return ret;
 
 	if (time_to_inject(sbi, FAULT_BLOCK)) {
-		f2fs_show_injection_info(FAULT_BLOCK);
+		f2fs_show_injection_info(sbi, FAULT_BLOCK);
 		release = *count;
 		goto release_quota;
 	}
@@ -2033,7 +2034,7 @@ static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,
 	}
 
 	if (time_to_inject(sbi, FAULT_BLOCK)) {
-		f2fs_show_injection_info(FAULT_BLOCK);
+		f2fs_show_injection_info(sbi, FAULT_BLOCK);
 		goto enospc;
 	}
 
@@ -2148,7 +2149,8 @@ static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
 			return page;
 
 		if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC)) {
-			f2fs_show_injection_info(FAULT_PAGE_ALLOC);
+			f2fs_show_injection_info(F2FS_M_SB(mapping),
+							FAULT_PAGE_ALLOC);
 			return NULL;
 		}
 	}
@@ -2163,7 +2165,7 @@ static inline struct page *f2fs_pagecache_get_page(
 				int fgp_flags, gfp_t gfp_mask)
 {
 	if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_GET)) {
-		f2fs_show_injection_info(FAULT_PAGE_GET);
+		f2fs_show_injection_info(F2FS_M_SB(mapping), FAULT_PAGE_GET);
 		return NULL;
 	}
 
@@ -2232,7 +2234,7 @@ static inline struct bio *f2fs_bio_alloc(struct f2fs_sb_info *sbi,
 		return bio;
 	}
 	if (time_to_inject(sbi, FAULT_ALLOC_BIO)) {
-		f2fs_show_injection_info(FAULT_ALLOC_BIO);
+		f2fs_show_injection_info(sbi, FAULT_ALLOC_BIO);
 		return NULL;
 	}
 
@@ -2799,7 +2801,7 @@ static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,
 	void *ret;
 
 	if (time_to_inject(sbi, FAULT_KMALLOC)) {
-		f2fs_show_injection_info(FAULT_KMALLOC);
+		f2fs_show_injection_info(sbi, FAULT_KMALLOC);
 		return NULL;
 	}
 
@@ -2820,7 +2822,7 @@ static inline void *f2fs_kvmalloc(struct f2fs_sb_info *sbi,
 					size_t size, gfp_t flags)
 {
 	if (time_to_inject(sbi, FAULT_KVMALLOC)) {
-		f2fs_show_injection_info(FAULT_KVMALLOC);
+		f2fs_show_injection_info(sbi, FAULT_KVMALLOC);
 		return NULL;
 	}
 
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
@@ -681,7 +681,7 @@ int f2fs_truncate(struct inode *inode)
 	trace_f2fs_truncate(inode);
 
 	if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {
-		f2fs_show_injection_info(FAULT_TRUNCATE);
+		f2fs_show_injection_info(F2FS_I_SB(inode), FAULT_TRUNCATE);
 		return -EIO;
 	}
 
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
@@ -54,7 +54,7 @@ static int gc_thread_func(void *data)
 		}
 
 		if (time_to_inject(sbi, FAULT_CHECKPOINT)) {
-			f2fs_show_injection_info(FAULT_CHECKPOINT);
+			f2fs_show_injection_info(sbi, FAULT_CHECKPOINT);
 			f2fs_stop_checkpoint(sbi, false);
 		}
 
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
@@ -681,7 +681,7 @@ void f2fs_evict_inode(struct inode *inode)
 		err = f2fs_truncate(inode);
 
 	if (time_to_inject(sbi, FAULT_EVICT_INODE)) {
-		f2fs_show_injection_info(FAULT_EVICT_INODE);
+		f2fs_show_injection_info(sbi, FAULT_EVICT_INODE);
 		err = -EIO;
 	}
 
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
@@ -2398,7 +2398,7 @@ bool f2fs_alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid)
 	struct free_nid *i = NULL;
 retry:
 	if (time_to_inject(sbi, FAULT_ALLOC_NID)) {
-		f2fs_show_injection_info(FAULT_ALLOC_NID);
+		f2fs_show_injection_info(sbi, FAULT_ALLOC_NID);
 		return false;
 	}
 
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
@@ -480,7 +480,7 @@ int f2fs_commit_inmem_pages(struct inode *inode)
 void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)
 {
 	if (time_to_inject(sbi, FAULT_CHECKPOINT)) {
-		f2fs_show_injection_info(FAULT_CHECKPOINT);
+		f2fs_show_injection_info(sbi, FAULT_CHECKPOINT);
 		f2fs_stop_checkpoint(sbi, false);
 	}
 
@@ -1008,8 +1008,9 @@ static void __remove_discard_cmd(struct f2fs_sb_info *sbi,
 
 	if (dc->error)
 		printk_ratelimited(
-			"%sF2FS-fs: Issue discard(%u, %u, %u) failed, ret: %d",
-			KERN_INFO, dc->lstart, dc->start, dc->len, dc->error);
+			"%sF2FS-fs (%s): Issue discard(%u, %u, %u) failed, ret: %d",
+			KERN_INFO, sbi->sb->s_id,
+			dc->lstart, dc->start, dc->len, dc->error);
 	__detach_discard_cmd(dcc, dc);
 }
 
@@ -1149,7 +1150,7 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,
 		dc->len += len;
 
 		if (time_to_inject(sbi, FAULT_DISCARD)) {
-			f2fs_show_injection_info(FAULT_DISCARD);
+			f2fs_show_injection_info(sbi, FAULT_DISCARD);
 			err = -EIO;
 			goto submit;
 		}

Original file line number	Diff line number	Diff line change
`@@ -581,7 +581,7 @@ int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi)`
`581`	`581`
`582`	`582`	`if (time_to_inject(sbi, FAULT_ORPHAN)) {`
`583`	`583`	`spin_unlock(&im->ino_lock);`
`584`		`- f2fs_show_injection_info(FAULT_ORPHAN);`
	`584`	`+ f2fs_show_injection_info(sbi, FAULT_ORPHAN);`
`585`	`585`	`return -ENOSPC;`
`586`	`586`	`}`
`587`	`587`
Original file line number	Diff line number	Diff line change
`@@ -168,9 +168,10 @@ static bool f2fs_bio_post_read_required(struct bio *bio)`
`168`	`168`
`169`	`169`	`static void f2fs_read_end_io(struct bio *bio)`
`170`	`170`	`{`
`171`		`- if (time_to_inject(F2FS_P_SB(bio_first_page_all(bio)),`
`172`		`- FAULT_READ_IO)) {`
`173`		`- f2fs_show_injection_info(FAULT_READ_IO);`
	`171`	`+ struct f2fs_sb_info *sbi = F2FS_P_SB(bio_first_page_all(bio));`
	`172`	`+`
	`173`	`+ if (time_to_inject(sbi, FAULT_READ_IO)) {`
	`174`	`+ f2fs_show_injection_info(sbi, FAULT_READ_IO);`
`174`	`175`	`bio->bi_status = BLK_STS_IOERR;`
`175`	`176`	`}`
`176`	`177`
`@@ -192,7 +193,7 @@ static void f2fs_write_end_io(struct bio *bio)`
`192`	`193`	`struct bvec_iter_all iter_all;`
`193`	`194`
`194`	`195`	`if (time_to_inject(sbi, FAULT_WRITE_IO)) {`
`195`		`- f2fs_show_injection_info(FAULT_WRITE_IO);`
	`196`	`+ f2fs_show_injection_info(sbi, FAULT_WRITE_IO);`
`196`	`197`	`bio->bi_status = BLK_STS_IOERR;`
`197`	`198`	`}`
`198`	`199`
Original file line number	Diff line number	Diff line change
`@@ -1374,9 +1374,10 @@ struct f2fs_private_dio {`
`1374`	`1374`	`};`
`1375`	`1375`
`1376`	`1376`	`#ifdef CONFIG_F2FS_FAULT_INJECTION`
`1377`		`-#define f2fs_show_injection_info(type) \`
`1378`		`- printk_ratelimited("%sF2FS-fs : inject %s in %s of %pS\n", \`
`1379`		`- KERN_INFO, f2fs_fault_name[type], \`
	`1377`	`+#define f2fs_show_injection_info(sbi, type) \`
	`1378`	`+ printk_ratelimited("%sF2FS-fs (%s) : inject %s in %s of %pS\n", \`
	`1379`	`+ KERN_INFO, sbi->sb->s_id, \`
	`1380`	`+ f2fs_fault_name[type], \`
`1380`	`1381`	`__func__, __builtin_return_address(0))`
`1381`	`1382`	`static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)`
`1382`	`1383`	`{`
`@@ -1396,7 +1397,7 @@ static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)`
`1396`	`1397`	`return false;`
`1397`	`1398`	`}`
`1398`	`1399`	`#else`
`1399`		`-#define f2fs_show_injection_info(type) do { } while (0)`
	`1400`	`+#define f2fs_show_injection_info(sbi, type) do { } while (0)`
`1400`	`1401`	`static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)`
`1401`	`1402`	`{`
`1402`	`1403`	`return false;`
`@@ -1781,7 +1782,7 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,`
`1781`	`1782`	`return ret;`
`1782`	`1783`
`1783`	`1784`	`if (time_to_inject(sbi, FAULT_BLOCK)) {`
`1784`		`- f2fs_show_injection_info(FAULT_BLOCK);`
	`1785`	`+ f2fs_show_injection_info(sbi, FAULT_BLOCK);`
`1785`	`1786`	`release = *count;`
`1786`	`1787`	`goto release_quota;`
`1787`	`1788`	`}`
`@@ -2033,7 +2034,7 @@ static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,`
`2033`	`2034`	`}`
`2034`	`2035`
`2035`	`2036`	`if (time_to_inject(sbi, FAULT_BLOCK)) {`
`2036`		`- f2fs_show_injection_info(FAULT_BLOCK);`
	`2037`	`+ f2fs_show_injection_info(sbi, FAULT_BLOCK);`
`2037`	`2038`	`goto enospc;`
`2038`	`2039`	`}`
`2039`	`2040`
`@@ -2148,7 +2149,8 @@ static inline struct page f2fs_grab_cache_page(struct address_space mapping,`
`2148`	`2149`	`return page;`
`2149`	`2150`
`2150`	`2151`	`if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC)) {`
`2151`		`- f2fs_show_injection_info(FAULT_PAGE_ALLOC);`
	`2152`	`+ f2fs_show_injection_info(F2FS_M_SB(mapping),`
	`2153`	`+ FAULT_PAGE_ALLOC);`
`2152`	`2154`	`return NULL;`
`2153`	`2155`	`}`
`2154`	`2156`	`}`
`@@ -2163,7 +2165,7 @@ static inline struct page *f2fs_pagecache_get_page(`
`2163`	`2165`	`int fgp_flags, gfp_t gfp_mask)`
`2164`	`2166`	`{`
`2165`	`2167`	`if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_GET)) {`
`2166`		`- f2fs_show_injection_info(FAULT_PAGE_GET);`
	`2168`	`+ f2fs_show_injection_info(F2FS_M_SB(mapping), FAULT_PAGE_GET);`
`2167`	`2169`	`return NULL;`
`2168`	`2170`	`}`
`2169`	`2171`
`@@ -2232,7 +2234,7 @@ static inline struct bio f2fs_bio_alloc(struct f2fs_sb_info sbi,`
`2232`	`2234`	`return bio;`
`2233`	`2235`	`}`
`2234`	`2236`	`if (time_to_inject(sbi, FAULT_ALLOC_BIO)) {`
`2235`		`- f2fs_show_injection_info(FAULT_ALLOC_BIO);`
	`2237`	`+ f2fs_show_injection_info(sbi, FAULT_ALLOC_BIO);`
`2236`	`2238`	`return NULL;`
`2237`	`2239`	`}`
`2238`	`2240`
`@@ -2799,7 +2801,7 @@ static inline void f2fs_kmalloc(struct f2fs_sb_info sbi,`
`2799`	`2801`	`void *ret;`
`2800`	`2802`
`2801`	`2803`	`if (time_to_inject(sbi, FAULT_KMALLOC)) {`
`2802`		`- f2fs_show_injection_info(FAULT_KMALLOC);`
	`2804`	`+ f2fs_show_injection_info(sbi, FAULT_KMALLOC);`
`2803`	`2805`	`return NULL;`
`2804`	`2806`	`}`
`2805`	`2807`
`@@ -2820,7 +2822,7 @@ static inline void f2fs_kvmalloc(struct f2fs_sb_info sbi,`
`2820`	`2822`	`size_t size, gfp_t flags)`
`2821`	`2823`	`{`
`2822`	`2824`	`if (time_to_inject(sbi, FAULT_KVMALLOC)) {`
`2823`		`- f2fs_show_injection_info(FAULT_KVMALLOC);`
	`2825`	`+ f2fs_show_injection_info(sbi, FAULT_KVMALLOC);`
`2824`	`2826`	`return NULL;`
`2825`	`2827`	`}`
`2826`	`2828`
Original file line number	Diff line number	Diff line change
`@@ -681,7 +681,7 @@ int f2fs_truncate(struct inode *inode)`
`681`	`681`	`trace_f2fs_truncate(inode);`
`682`	`682`
`683`	`683`	`if (time_to_inject(F2FS_I_SB(inode), FAULT_TRUNCATE)) {`
`684`		`- f2fs_show_injection_info(FAULT_TRUNCATE);`
	`684`	`+ f2fs_show_injection_info(F2FS_I_SB(inode), FAULT_TRUNCATE);`
`685`	`685`	`return -EIO;`
`686`	`686`	`}`
`687`	`687`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ static int gc_thread_func(void *data)`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`if (time_to_inject(sbi, FAULT_CHECKPOINT)) {`
`57`		`- f2fs_show_injection_info(FAULT_CHECKPOINT);`
	`57`	`+ f2fs_show_injection_info(sbi, FAULT_CHECKPOINT);`
`58`	`58`	`f2fs_stop_checkpoint(sbi, false);`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -681,7 +681,7 @@ void f2fs_evict_inode(struct inode *inode)`
`681`	`681`	`err = f2fs_truncate(inode);`
`682`	`682`
`683`	`683`	`if (time_to_inject(sbi, FAULT_EVICT_INODE)) {`
`684`		`- f2fs_show_injection_info(FAULT_EVICT_INODE);`
	`684`	`+ f2fs_show_injection_info(sbi, FAULT_EVICT_INODE);`
`685`	`685`	`err = -EIO;`
`686`	`686`	`}`
`687`	`687`
Original file line number	Diff line number	Diff line change
`@@ -2398,7 +2398,7 @@ bool f2fs_alloc_nid(struct f2fs_sb_info sbi, nid_t nid)`
`2398`	`2398`	`struct free_nid *i = NULL;`
`2399`	`2399`	`retry:`
`2400`	`2400`	`if (time_to_inject(sbi, FAULT_ALLOC_NID)) {`
`2401`		`- f2fs_show_injection_info(FAULT_ALLOC_NID);`
	`2401`	`+ f2fs_show_injection_info(sbi, FAULT_ALLOC_NID);`
`2402`	`2402`	`return false;`
`2403`	`2403`	`}`
`2404`	`2404`
Original file line number	Diff line number	Diff line change
`@@ -480,7 +480,7 @@ int f2fs_commit_inmem_pages(struct inode *inode)`
`480`	`480`	`void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)`
`481`	`481`	`{`
`482`	`482`	`if (time_to_inject(sbi, FAULT_CHECKPOINT)) {`
`483`		`- f2fs_show_injection_info(FAULT_CHECKPOINT);`
	`483`	`+ f2fs_show_injection_info(sbi, FAULT_CHECKPOINT);`
`484`	`484`	`f2fs_stop_checkpoint(sbi, false);`
`485`	`485`	`}`
`486`	`486`
`@@ -1008,8 +1008,9 @@ static void __remove_discard_cmd(struct f2fs_sb_info *sbi,`
`1008`	`1008`
`1009`	`1009`	`if (dc->error)`
`1010`	`1010`	`printk_ratelimited(`
`1011`		`- "%sF2FS-fs: Issue discard(%u, %u, %u) failed, ret: %d",`
`1012`		`- KERN_INFO, dc->lstart, dc->start, dc->len, dc->error);`
	`1011`	`+ "%sF2FS-fs (%s): Issue discard(%u, %u, %u) failed, ret: %d",`
	`1012`	`+ KERN_INFO, sbi->sb->s_id,`
	`1013`	`+ dc->lstart, dc->start, dc->len, dc->error);`
`1013`	`1014`	`__detach_discard_cmd(dcc, dc);`
`1014`	`1015`	`}`
`1015`	`1016`
`@@ -1149,7 +1150,7 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,`
`1149`	`1150`	`dc->len += len;`
`1150`	`1151`
`1151`	`1152`	`if (time_to_inject(sbi, FAULT_DISCARD)) {`
`1152`		`- f2fs_show_injection_info(FAULT_DISCARD);`
	`1153`	`+ f2fs_show_injection_info(sbi, FAULT_DISCARD);`
`1153`	`1154`	`err = -EIO;`
`1154`	`1155`	`goto submit;`
`1155`	`1156`	`}`