f2fs: compress: change the first parameter of page_array_{alloc,free} to sbi

No logic changes, just cleanup and prepare for fixing the UAF issue
in f2fs_free_dic.

Signed-off-by: Zhiguo Niu <zhiguo.niu@unisoc.com>
Signed-off-by: Baocong Liu <baocong.liu@unisoc.com>
Reviewed-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 b3c1df93a163c631f2d4a42526b945e49af9c708..832a484963b7c4be82ae2e72eeb51f330f1e72d1 100644 (file)
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -23,20 +23,18 @@
 static struct kmem_cache *cic_entry_slab;
 static struct kmem_cache *dic_entry_slab;
 
-static void *page_array_alloc(struct inode *inode, int nr)
+static void *page_array_alloc(struct f2fs_sb_info *sbi, int nr)
 {
-       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        unsigned int size = sizeof(struct page *) * nr;
 
        if (likely(size <= sbi->page_array_slab_size))
                return f2fs_kmem_cache_alloc(sbi->page_array_slab,
-                                       GFP_F2FS_ZERO, false, F2FS_I_SB(inode));
+                                       GFP_F2FS_ZERO, false, sbi);
        return f2fs_kzalloc(sbi, size, GFP_NOFS);
 }
 
-static void page_array_free(struct inode *inode, void *pages, int nr)
+static void page_array_free(struct f2fs_sb_info *sbi, void *pages, int nr)
 {
-       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        unsigned int size = sizeof(struct page *) * nr;
 
        if (!pages)
@@ -149,13 +147,13 @@ int f2fs_init_compress_ctx(struct compress_ctx *cc)
        if (cc->rpages)
                return 0;
 
-       cc->rpages = page_array_alloc(cc->inode, cc->cluster_size);
+       cc->rpages = page_array_alloc(F2FS_I_SB(cc->inode), cc->cluster_size);
        return cc->rpages ? 0 : -ENOMEM;
 }
 
 void f2fs_destroy_compress_ctx(struct compress_ctx *cc, bool reuse)
 {
-       page_array_free(cc->inode, cc->rpages, cc->cluster_size);
+       page_array_free(F2FS_I_SB(cc->inode), cc->rpages, cc->cluster_size);
        cc->rpages = NULL;
        cc->nr_rpages = 0;
        cc->nr_cpages = 0;
@@ -622,6 +620,7 @@ static void *f2fs_vmap(struct page **pages, unsigned int count)
 
 static int f2fs_compress_pages(struct compress_ctx *cc)
 {
+       struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode);
        struct f2fs_inode_info *fi = F2FS_I(cc->inode);
        const struct f2fs_compress_ops *cops =
                                f2fs_cops[fi->i_compress_algorithm];
@@ -642,7 +641,7 @@ static int f2fs_compress_pages(struct compress_ctx *cc)
        cc->nr_cpages = DIV_ROUND_UP(max_len, PAGE_SIZE);
        cc->valid_nr_cpages = cc->nr_cpages;
 
-       cc->cpages = page_array_alloc(cc->inode, cc->nr_cpages);
+       cc->cpages = page_array_alloc(sbi, cc->nr_cpages);
        if (!cc->cpages) {
                ret = -ENOMEM;
                goto destroy_compress_ctx;
@@ -716,7 +715,7 @@ out_free_cpages:
                if (cc->cpages[i])
                        f2fs_compress_free_page(cc->cpages[i]);
        }
-       page_array_free(cc->inode, cc->cpages, cc->nr_cpages);
+       page_array_free(sbi, cc->cpages, cc->nr_cpages);
        cc->cpages = NULL;
 destroy_compress_ctx:
        if (cops->destroy_compress_ctx)
@@ -1340,7 +1339,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
        cic->magic = F2FS_COMPRESSED_PAGE_MAGIC;
        cic->inode = inode;
        atomic_set(&cic->pending_pages, cc->valid_nr_cpages);
-       cic->rpages = page_array_alloc(cc->inode, cc->cluster_size);
+       cic->rpages = page_array_alloc(sbi, cc->cluster_size);
        if (!cic->rpages)
                goto out_put_cic;
 
@@ -1442,13 +1441,13 @@ unlock_continue:
        spin_unlock(&fi->i_size_lock);
 
        f2fs_put_rpages(cc);
-       page_array_free(cc->inode, cc->cpages, cc->nr_cpages);
+       page_array_free(sbi, cc->cpages, cc->nr_cpages);
        cc->cpages = NULL;
        f2fs_destroy_compress_ctx(cc, false);
        return 0;
 
 out_destroy_crypt:
-       page_array_free(cc->inode, cic->rpages, cc->cluster_size);
+       page_array_free(sbi, cic->rpages, cc->cluster_size);
 
        for (--i; i >= 0; i--) {
                if (!cc->cpages[i])
@@ -1469,7 +1468,7 @@ out_free:
                f2fs_compress_free_page(cc->cpages[i]);
                cc->cpages[i] = NULL;
        }
-       page_array_free(cc->inode, cc->cpages, cc->nr_cpages);
+       page_array_free(sbi, cc->cpages, cc->nr_cpages);
        cc->cpages = NULL;
        return -EAGAIN;
 }
@@ -1499,7 +1498,7 @@ void f2fs_compress_write_end_io(struct bio *bio, struct page *page)
                end_page_writeback(cic->rpages[i]);
        }
 
-       page_array_free(cic->inode, cic->rpages, cic->nr_rpages);
+       page_array_free(sbi, cic->rpages, cic->nr_rpages);
        kmem_cache_free(cic_entry_slab, cic);
 }
 
@@ -1640,7 +1639,7 @@ static int f2fs_prepare_decomp_mem(struct decompress_io_ctx *dic,
        if (!allow_memalloc_for_decomp(F2FS_I_SB(dic->inode), pre_alloc))
                return 0;
 
-       dic->tpages = page_array_alloc(dic->inode, dic->cluster_size);
+       dic->tpages = page_array_alloc(F2FS_I_SB(dic->inode), dic->cluster_size);
        if (!dic->tpages)
                return -ENOMEM;
 
@@ -1700,7 +1699,7 @@ struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc)
        if (!dic)
                return ERR_PTR(-ENOMEM);
 
-       dic->rpages = page_array_alloc(cc->inode, cc->cluster_size);
+       dic->rpages = page_array_alloc(sbi, cc->cluster_size);
        if (!dic->rpages) {
                kmem_cache_free(dic_entry_slab, dic);
                return ERR_PTR(-ENOMEM);
@@ -1721,7 +1720,7 @@ struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc)
                dic->rpages[i] = cc->rpages[i];
        dic->nr_rpages = cc->cluster_size;
 
-       dic->cpages = page_array_alloc(dic->inode, dic->nr_cpages);
+       dic->cpages = page_array_alloc(sbi, dic->nr_cpages);
        if (!dic->cpages) {
                ret = -ENOMEM;
                goto out_free;
@@ -1751,6 +1750,7 @@ static void f2fs_free_dic(struct decompress_io_ctx *dic,
                bool bypass_destroy_callback)
 {
        int i;
+       struct f2fs_sb_info *sbi = F2FS_I_SB(dic->inode);
 
        f2fs_release_decomp_mem(dic, bypass_destroy_callback, true);
 
@@ -1762,7 +1762,7 @@ static void f2fs_free_dic(struct decompress_io_ctx *dic,
                                continue;
                        f2fs_compress_free_page(dic->tpages[i]);
                }
-               page_array_free(dic->inode, dic->tpages, dic->cluster_size);
+               page_array_free(sbi, dic->tpages, dic->cluster_size);
        }
 
        if (dic->cpages) {
@@ -1771,10 +1771,10 @@ static void f2fs_free_dic(struct decompress_io_ctx *dic,
                                continue;
                        f2fs_compress_free_page(dic->cpages[i]);
                }
-               page_array_free(dic->inode, dic->cpages, dic->nr_cpages);
+               page_array_free(sbi, dic->cpages, dic->nr_cpages);
        }
 
-       page_array_free(dic->inode, dic->rpages, dic->nr_rpages);
+       page_array_free(sbi, dic->rpages, dic->nr_rpages);
        kmem_cache_free(dic_entry_slab, dic);
 }