f2fs: use f2fs_{err,info}_ratelimited() for cleanup

Commit b1c9d3f833ba ("f2fs: support printk_ratelimited() in f2fs_printk()")
missed some cases, cover all remains for cleanup.

Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index b12d3a49bfdac9c6e0571ed84e4cf0c76e846818..1ef82a5463910ecefaad0b945a89432f493ae2b6 100644 (file)
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -198,8 +198,8 @@ static int lzo_compress_pages(struct compress_ctx *cc)
        ret = lzo1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata,
                                        &cc->clen, cc->private);
        if (ret != LZO_E_OK) {
-               printk_ratelimited("%sF2FS-fs (%s): lzo compress failed, ret:%d\n",
-                               KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret);
+               f2fs_err_ratelimited(F2FS_I_SB(cc->inode),
+                               "lzo compress failed, ret:%d", ret);
                return -EIO;
        }
        return 0;
@@ -212,17 +212,15 @@ static int lzo_decompress_pages(struct decompress_io_ctx *dic)
        ret = lzo1x_decompress_safe(dic->cbuf->cdata, dic->clen,
                                                dic->rbuf, &dic->rlen);
        if (ret != LZO_E_OK) {
-               printk_ratelimited("%sF2FS-fs (%s): lzo decompress failed, ret:%d\n",
-                               KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret);
+               f2fs_err_ratelimited(F2FS_I_SB(dic->inode),
+                               "lzo decompress failed, ret:%d", ret);
                return -EIO;
        }
 
        if (dic->rlen != PAGE_SIZE << dic->log_cluster_size) {
-               printk_ratelimited("%sF2FS-fs (%s): lzo invalid rlen:%zu, "
-                                       "expected:%lu\n", KERN_ERR,
-                                       F2FS_I_SB(dic->inode)->sb->s_id,
-                                       dic->rlen,
-                                       PAGE_SIZE << dic->log_cluster_size);
+               f2fs_err_ratelimited(F2FS_I_SB(dic->inode),
+                               "lzo invalid rlen:%zu, expected:%lu",
+                               dic->rlen, PAGE_SIZE << dic->log_cluster_size);
                return -EIO;
        }
        return 0;
@@ -294,16 +292,15 @@ static int lz4_decompress_pages(struct decompress_io_ctx *dic)
        ret = LZ4_decompress_safe(dic->cbuf->cdata, dic->rbuf,
                                                dic->clen, dic->rlen);
        if (ret < 0) {
-               printk_ratelimited("%sF2FS-fs (%s): lz4 decompress failed, ret:%d\n",
-                               KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret);
+               f2fs_err_ratelimited(F2FS_I_SB(dic->inode),
+                               "lz4 decompress failed, ret:%d", ret);
                return -EIO;
        }
 
        if (ret != PAGE_SIZE << dic->log_cluster_size) {
-               printk_ratelimited("%sF2FS-fs (%s): lz4 invalid ret:%d, "
-                                       "expected:%lu\n", KERN_ERR,
-                                       F2FS_I_SB(dic->inode)->sb->s_id, ret,
-                                       PAGE_SIZE << dic->log_cluster_size);
+               f2fs_err_ratelimited(F2FS_I_SB(dic->inode),
+                               "lz4 invalid ret:%d, expected:%lu",
+                               ret, PAGE_SIZE << dic->log_cluster_size);
                return -EIO;
        }
        return 0;
@@ -350,9 +347,8 @@ static int zstd_init_compress_ctx(struct compress_ctx *cc)
 
        stream = zstd_init_cstream(&params, 0, workspace, workspace_size);
        if (!stream) {
-               printk_ratelimited("%sF2FS-fs (%s): %s zstd_init_cstream failed\n",
-                               KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id,
-                               __func__);
+               f2fs_err_ratelimited(F2FS_I_SB(cc->inode),
+                               "%s zstd_init_cstream failed", __func__);
                kvfree(workspace);
                return -EIO;
        }
@@ -390,16 +386,16 @@ static int zstd_compress_pages(struct compress_ctx *cc)
 
        ret = zstd_compress_stream(stream, &outbuf, &inbuf);
        if (zstd_is_error(ret)) {
-               printk_ratelimited("%sF2FS-fs (%s): %s zstd_compress_stream failed, ret: %d\n",
-                               KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id,
+               f2fs_err_ratelimited(F2FS_I_SB(cc->inode),
+                               "%s zstd_compress_stream failed, ret: %d",
                                __func__, zstd_get_error_code(ret));
                return -EIO;
        }
 
        ret = zstd_end_stream(stream, &outbuf);
        if (zstd_is_error(ret)) {
-               printk_ratelimited("%sF2FS-fs (%s): %s zstd_end_stream returned %d\n",
-                               KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id,
+               f2fs_err_ratelimited(F2FS_I_SB(cc->inode),
+                               "%s zstd_end_stream returned %d",
                                __func__, zstd_get_error_code(ret));
                return -EIO;
        }
@@ -432,9 +428,8 @@ static int zstd_init_decompress_ctx(struct decompress_io_ctx *dic)
 
        stream = zstd_init_dstream(max_window_size, workspace, workspace_size);
        if (!stream) {
-               printk_ratelimited("%sF2FS-fs (%s): %s zstd_init_dstream failed\n",
-                               KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id,
-                               __func__);
+               f2fs_err_ratelimited(F2FS_I_SB(dic->inode),
+                               "%s zstd_init_dstream failed", __func__);
                kvfree(workspace);
                return -EIO;
        }
@@ -469,16 +464,15 @@ static int zstd_decompress_pages(struct decompress_io_ctx *dic)
 
        ret = zstd_decompress_stream(stream, &outbuf, &inbuf);
        if (zstd_is_error(ret)) {
-               printk_ratelimited("%sF2FS-fs (%s): %s zstd_decompress_stream failed, ret: %d\n",
-                               KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id,
+               f2fs_err_ratelimited(F2FS_I_SB(dic->inode),
+                               "%s zstd_decompress_stream failed, ret: %d",
                                __func__, zstd_get_error_code(ret));
                return -EIO;
        }
 
        if (dic->rlen != outbuf.pos) {
-               printk_ratelimited("%sF2FS-fs (%s): %s ZSTD invalid rlen:%zu, "
-                               "expected:%lu\n", KERN_ERR,
-                               F2FS_I_SB(dic->inode)->sb->s_id,
+               f2fs_err_ratelimited(F2FS_I_SB(dic->inode),
+                               "%s ZSTD invalid rlen:%zu, expected:%lu",
                                __func__, dic->rlen,
                                PAGE_SIZE << dic->log_cluster_size);
                return -EIO;

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 8ddd4f1c665a00240fb61c74a0604c10afbc6f80..ab3e9a6e9c96c5aef4c2d9c50c3fcff96f3e1b16 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -1109,9 +1109,8 @@ static void __remove_discard_cmd(struct f2fs_sb_info *sbi,
                dc->error = 0;
 
        if (dc->error)
-               printk_ratelimited(
-                       "%sF2FS-fs (%s): Issue discard(%u, %u, %u) failed, ret: %d",
-                       KERN_INFO, sbi->sb->s_id,
+               f2fs_info_ratelimited(sbi,
+                       "Issue discard(%u, %u, %u) failed, ret: %d",
                        dc->di.lstart, dc->di.start, dc->di.len, dc->error);
        __detach_discard_cmd(dcc, dc);
 }