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

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>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 3dc3ac6fe14324b33cbfba77287e28e91c13ed84..23606493025165f11851de8b44ea905dfcab3cab 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -895,8 +895,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 fb180020e175c10f1e4c02f5eb36e183560d1807..7794e2f0d6e8a70d613c4acb242c5e5fc433a45c 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2997,18 +2997,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 e0bb0f7e0506ee83abd1efaa9e4e28000235cc86..03e24df1c84f5c458f8284fd32c1f9f795093c16 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -2993,7 +2993,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;
@@ -3126,9 +3126,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 a71da699cb2d55dd941aa57a3312c78382a40196..f3c151169542185cad23213861471dbeadd50f2d 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -3033,7 +3033,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);