f2fs: don't return vmalloc() memory from f2fs_kmalloc()

[ Upstream commit 0b6d4ca04a86b9dababbb76e58d33c437e127b77 ]

kmalloc() returns kmalloc'ed memory, and kvmalloc() returns either
kmalloc'ed or vmalloc'ed memory.  But the f2fs wrappers, f2fs_kmalloc()
and f2fs_kvmalloc(), both return both kinds of memory.

It's redundant to have two functions that do the same thing, and also
breaking the standard naming convention is causing bugs since people
assume it's safe to kfree() memory allocated by f2fs_kmalloc().  See
e.g. the various allocations in fs/f2fs/compress.c.

Fix this by making f2fs_kmalloc() just use kmalloc().  And to avoid
re-introducing the allocation failures that the vmalloc fallback was
intended to fix, convert the largest allocations to use f2fs_kvmalloc().

Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 852890b72d6acd62bf63bef69c38520f674f0b98..448b3dc6f925a6c12e22c9b27b7131c45c910de8 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -889,8 +889,8 @@ int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi)
        int i;
        int err;
 
-       sbi->ckpt = f2fs_kzalloc(sbi, array_size(blk_size, cp_blks),
-                                GFP_KERNEL);
+       sbi->ckpt = f2fs_kvzalloc(sbi, array_size(blk_size, cp_blks),
+                                 GFP_KERNEL);
        if (!sbi->ckpt)
                return -ENOMEM;
        /*

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index a15e93f15b6ac6482368c0839c9b01e55c8c985c..555c84953ea81588e6b56da5ffb016337063a513 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2936,18 +2936,12 @@ static inline bool f2fs_may_extent_tree(struct inode *inode)
 static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,
                                        size_t size, gfp_t flags)
 {
-       void *ret;
-
        if (time_to_inject(sbi, FAULT_KMALLOC)) {
                f2fs_show_injection_info(sbi, FAULT_KMALLOC);
                return NULL;
        }
 
-       ret = kmalloc(size, flags);
-       if (ret)
-               return ret;
-
-       return kvmalloc(size, flags);
+       return kmalloc(size, flags);
 }
 
 static inline void *f2fs_kzalloc(struct f2fs_sb_info *sbi,

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index ecbd6bd14a494529a30590e30a26c6838c7bd4de..daf531e69b67246c0ec864d1616b75267cbc124e 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -2928,7 +2928,7 @@ static int __get_nat_bitmaps(struct f2fs_sb_info *sbi)
                return 0;
 
        nm_i->nat_bits_blocks = F2FS_BLK_ALIGN((nat_bits_bytes << 1) + 8);
-       nm_i->nat_bits = f2fs_kzalloc(sbi,
+       nm_i->nat_bits = f2fs_kvzalloc(sbi,
                        nm_i->nat_bits_blocks << F2FS_BLKSIZE_BITS, GFP_KERNEL);
        if (!nm_i->nat_bits)
                return -ENOMEM;
@@ -3061,9 +3061,9 @@ static int init_free_nid_cache(struct f2fs_sb_info *sbi)
        int i;
 
        nm_i->free_nid_bitmap =
-               f2fs_kzalloc(sbi, array_size(sizeof(unsigned char *),
-                                            nm_i->nat_blocks),
-                            GFP_KERNEL);
+               f2fs_kvzalloc(sbi, array_size(sizeof(unsigned char *),
+                                             nm_i->nat_blocks),
+                             GFP_KERNEL);
        if (!nm_i->free_nid_bitmap)
                return -ENOMEM;
 

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 0c88090077fc1a5856f2a004bc0a3b2dcf352199..4696c9cb47a5f381ab9b09cc95f575418cd55e50 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -3039,7 +3039,7 @@ static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
        if (nr_sectors & (bdev_zone_sectors(bdev) - 1))
                FDEV(devi).nr_blkz++;
 
-       FDEV(devi).blkz_seq = f2fs_kzalloc(sbi,
+       FDEV(devi).blkz_seq = f2fs_kvzalloc(sbi,
                                        BITS_TO_LONGS(FDEV(devi).nr_blkz)
                                        * sizeof(unsigned long),
                                        GFP_KERNEL);