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 a28ffecc0f95a3ac90c702d77286e9c54801b6a8..bbd07fe8a4921ea7c64d817fb076e5fd539331a8 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -892,8 +892,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 a26ea1e6ba88fb69fe1521998057fa2f52f756df..c22ca7d867ee53c9965c7955685649c7f9354f07 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2790,18 +2790,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(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 f14401a77d6018f40f5155500df02a0257206337..90a20bd129614ef4112c4dca7978dc2494b69a9a 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -2933,7 +2933,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;
@@ -3066,9 +3066,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 d89c85177e0927cac250cfa74112d5d7b4f017c4..f4b882ee48ddf4287e5379cce9bcc8ccd9764ed2 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2901,7 +2901,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);