24 files changed, 103 insertions, 130 deletions

diff --git a/arch/x86/kvm/lapic.c b/arch/x86/kvm/lapic.c
index bad6a25067bc..d2a892fc92bf 100644
--- a/arch/x86/kvm/lapic.c
+++ b/arch/x86/kvm/lapic.c
@@ -177,8 +177,8 @@ static void recalculate_apic_map(struct kvm *kvm)
                 if (kvm_apic_present(vcpu))
                         max_id = max(max_id, kvm_x2apic_id(vcpu->arch.apic));
 
-        new = kvm_kvzalloc(sizeof(struct kvm_apic_map) +
-                           sizeof(struct kvm_lapic *) * ((u64)max_id + 1));
+        new = kvzalloc(sizeof(struct kvm_apic_map) +
+                           sizeof(struct kvm_lapic *) * ((u64)max_id + 1), GFP_KERNEL);
 
         if (!new)
                 goto out;
diff --git a/arch/x86/kvm/page_track.c b/arch/x86/kvm/page_track.c
index 60168cdd0546..ea67dc876316 100644
--- a/arch/x86/kvm/page_track.c
+++ b/arch/x86/kvm/page_track.c
@@ -40,8 +40,8 @@ int kvm_page_track_create_memslot(struct kvm_memory_slot *slot,
         int  i;
 
         for (i = 0; i < KVM_PAGE_TRACK_MAX; i++) {
-                slot->arch.gfn_track[i] = kvm_kvzalloc(npages *
-                                            sizeof(*slot->arch.gfn_track[i]));
+                slot->arch.gfn_track[i] = kvzalloc(npages *
+                                            sizeof(*slot->arch.gfn_track[i]), GFP_KERNEL);
                 if (!slot->arch.gfn_track[i])
                         goto track_free;
         }
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index ccbd45ecd41a..ee22226e3807 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -8199,13 +8199,13 @@ int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
                                       slot->base_gfn, level) + 1;
 
                 slot->arch.rmap[i] =
-                        kvm_kvzalloc(lpages * sizeof(*slot->arch.rmap[i]));
+                        kvzalloc(lpages * sizeof(*slot->arch.rmap[i]), GFP_KERNEL);
                 if (!slot->arch.rmap[i])
                         goto out_free;
                 if (i == 0)
                         continue;
 
-                linfo = kvm_kvzalloc(lpages * sizeof(*linfo));
+                linfo = kvzalloc(lpages * sizeof(*linfo), GFP_KERNEL);
                 if (!linfo)
                         goto out_free;
 
diff --git a/drivers/md/dm-stats.c b/drivers/md/dm-stats.c
index 0250e7e521ab..6028d8247f58 100644
--- a/drivers/md/dm-stats.c
+++ b/drivers/md/dm-stats.c
@@ -146,12 +146,7 @@ static void *dm_kvzalloc(size_t alloc_size, int node)
         if (!claim_shared_memory(alloc_size))
                 return NULL;
 
-        if (alloc_size <= KMALLOC_MAX_SIZE) {
-                p = kzalloc_node(alloc_size, GFP_KERNEL | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN, node);
-                if (p)
-                        return p;
-        }
-        p = vzalloc_node(alloc_size, node);
+        p = kvzalloc_node(alloc_size, GFP_KERNEL | __GFP_NOMEMALLOC, node);
         if (p)
                 return p;
 
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 354dc1a894c2..b60698c104fd 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -2393,7 +2393,7 @@ int ext4_mb_alloc_groupinfo(struct super_block *sb, ext4_group_t ngroups)
                 return 0;
 
         size = roundup_pow_of_two(sizeof(*sbi->s_group_info) * size);
-        new_groupinfo = ext4_kvzalloc(size, GFP_KERNEL);
+        new_groupinfo = kvzalloc(size, GFP_KERNEL);
         if (!new_groupinfo) {
                 ext4_msg(sb, KERN_ERR, "can't allocate buddy meta group");
                 return -ENOMEM;
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index a9c72e39a4ee..b2c74644d5de 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -2153,7 +2153,7 @@ int ext4_alloc_flex_bg_array(struct super_block *sb, ext4_group_t ngroup)
                 return 0;
 
         size = roundup_pow_of_two(size * sizeof(struct flex_groups));
-        new_groups = ext4_kvzalloc(size, GFP_KERNEL);
+        new_groups = kvzalloc(size, GFP_KERNEL);
         if (!new_groups) {
                 ext4_msg(sb, KERN_ERR, "not enough memory for %d flex groups",
                          size / (int) sizeof(struct flex_groups));
@@ -3887,7 +3887,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                         goto failed_mount;
                 }
         }
-        sbi->s_group_desc = ext4_kvmalloc(db_count *
+        sbi->s_group_desc = kvmalloc(db_count *
                                           sizeof(struct buffer_head *),
                                           GFP_KERNEL);
         if (sbi->s_group_desc == NULL) {
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 0a6e115562f6..1fc17a1fc5d0 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2005,26 +2005,6 @@ static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,
         return kmalloc(size, flags);
 }
 
-static inline void *f2fs_kvmalloc(size_t size, gfp_t flags)
-{
-        void *ret;
-
-        ret = kmalloc(size, flags | __GFP_NOWARN);
-        if (!ret)
-                ret = __vmalloc(size, flags, PAGE_KERNEL);
-        return ret;
-}
-
-static inline void *f2fs_kvzalloc(size_t size, gfp_t flags)
-{
-        void *ret;
-
-        ret = kzalloc(size, flags | __GFP_NOWARN);
-        if (!ret)
-                ret = __vmalloc(size, flags | __GFP_ZERO, PAGE_KERNEL);
-        return ret;
-}
-
 #define get_inode_mode(i) \
         ((is_inode_flag_set(i, FI_ACL_MODE)) ? \
          (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 5f7317875a67..0849af78381f 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1012,11 +1012,11 @@ static int __exchange_data_block(struct inode *src_inode,
         while (len) {
                 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len);
 
-                src_blkaddr = f2fs_kvzalloc(sizeof(block_t) * olen, GFP_KERNEL);
+                src_blkaddr = kvzalloc(sizeof(block_t) * olen, GFP_KERNEL);
                 if (!src_blkaddr)
                         return -ENOMEM;
 
-                do_replace = f2fs_kvzalloc(sizeof(int) * olen, GFP_KERNEL);
+                do_replace = kvzalloc(sizeof(int) * olen, GFP_KERNEL);
                 if (!do_replace) {
                         kvfree(src_blkaddr);
                         return -ENOMEM;
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 481aa8dc79f4..0ea1dca8a0e2 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -2621,17 +2621,17 @@ static int init_free_nid_cache(struct f2fs_sb_info *sbi)
 {
         struct f2fs_nm_info *nm_i = NM_I(sbi);
 
-        nm_i->free_nid_bitmap = f2fs_kvzalloc(nm_i->nat_blocks *
+        nm_i->free_nid_bitmap = kvzalloc(nm_i->nat_blocks *
                                         NAT_ENTRY_BITMAP_SIZE, GFP_KERNEL);
         if (!nm_i->free_nid_bitmap)
                 return -ENOMEM;
 
-        nm_i->nat_block_bitmap = f2fs_kvzalloc(nm_i->nat_blocks / 8,
+        nm_i->nat_block_bitmap = kvzalloc(nm_i->nat_blocks / 8,
                                                                 GFP_KERNEL);
         if (!nm_i->nat_block_bitmap)
                 return -ENOMEM;
 
-        nm_i->free_nid_count = f2fs_kvzalloc(nm_i->nat_blocks *
+        nm_i->free_nid_count = kvzalloc(nm_i->nat_blocks *
                                         sizeof(unsigned short), GFP_KERNEL);
         if (!nm_i->free_nid_count)
                 return -ENOMEM;
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 29ef7088c558..13806f642ab5 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -2501,13 +2501,13 @@ static int build_sit_info(struct f2fs_sb_info *sbi)
 
         SM_I(sbi)->sit_info = sit_i;
 
-        sit_i->sentries = f2fs_kvzalloc(MAIN_SEGS(sbi) *
+        sit_i->sentries = kvzalloc(MAIN_SEGS(sbi) *
                                         sizeof(struct seg_entry), GFP_KERNEL);
         if (!sit_i->sentries)
                 return -ENOMEM;
 
         bitmap_size = f2fs_bitmap_size(MAIN_SEGS(sbi));
-        sit_i->dirty_sentries_bitmap = f2fs_kvzalloc(bitmap_size, GFP_KERNEL);
+        sit_i->dirty_sentries_bitmap = kvzalloc(bitmap_size, GFP_KERNEL);
         if (!sit_i->dirty_sentries_bitmap)
                 return -ENOMEM;
 
@@ -2540,7 +2540,7 @@ static int build_sit_info(struct f2fs_sb_info *sbi)
                 return -ENOMEM;
 
         if (sbi->segs_per_sec > 1) {
-                sit_i->sec_entries = f2fs_kvzalloc(MAIN_SECS(sbi) *
+                sit_i->sec_entries = kvzalloc(MAIN_SECS(sbi) *
                                         sizeof(struct sec_entry), GFP_KERNEL);
                 if (!sit_i->sec_entries)
                         return -ENOMEM;
@@ -2591,12 +2591,12 @@ static int build_free_segmap(struct f2fs_sb_info *sbi)
         SM_I(sbi)->free_info = free_i;
 
         bitmap_size = f2fs_bitmap_size(MAIN_SEGS(sbi));
-        free_i->free_segmap = f2fs_kvmalloc(bitmap_size, GFP_KERNEL);
+        free_i->free_segmap = kvmalloc(bitmap_size, GFP_KERNEL);
         if (!free_i->free_segmap)
                 return -ENOMEM;
 
         sec_bitmap_size = f2fs_bitmap_size(MAIN_SECS(sbi));
-        free_i->free_secmap = f2fs_kvmalloc(sec_bitmap_size, GFP_KERNEL);
+        free_i->free_secmap = kvmalloc(sec_bitmap_size, GFP_KERNEL);
         if (!free_i->free_secmap)
                 return -ENOMEM;
 
@@ -2764,7 +2764,7 @@ static int init_victim_secmap(struct f2fs_sb_info *sbi)
         struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
         unsigned int bitmap_size = f2fs_bitmap_size(MAIN_SECS(sbi));
 
-        dirty_i->victim_secmap = f2fs_kvzalloc(bitmap_size, GFP_KERNEL);
+        dirty_i->victim_secmap = kvzalloc(bitmap_size, GFP_KERNEL);
         if (!dirty_i->victim_secmap)
                 return -ENOMEM;
         return 0;
@@ -2786,7 +2786,7 @@ static int build_dirty_segmap(struct f2fs_sb_info *sbi)
         bitmap_size = f2fs_bitmap_size(MAIN_SEGS(sbi));
 
         for (i = 0; i < NR_DIRTY_TYPE; i++) {
-                dirty_i->dirty_segmap[i] = f2fs_kvzalloc(bitmap_size, GFP_KERNEL);
+                dirty_i->dirty_segmap[i] = kvzalloc(bitmap_size, GFP_KERNEL);
                 if (!dirty_i->dirty_segmap[i])
                         return -ENOMEM;
         }
diff --git a/fs/seq_file.c b/fs/seq_file.c
index ca69fb99e41a..dc7c2be963ed 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -25,21 +25,7 @@ static void seq_set_overflow(struct seq_file *m)
 
 static void *seq_buf_alloc(unsigned long size)
 {
-        void *buf;
-        gfp_t gfp = GFP_KERNEL;
-
-        /*
-         * For high order allocations, use __GFP_NORETRY to avoid oom-killing -
-         * it's better to fall back to vmalloc() than to kill things.  For small
-         * allocations, just use GFP_KERNEL which will oom kill, thus no need
-         * for vmalloc fallback.
-         */
-        if (size > PAGE_SIZE)
-                gfp |= __GFP_NORETRY | __GFP_NOWARN;
-        buf = kmalloc(size, gfp);
-        if (!buf && size > PAGE_SIZE)
-                buf = vmalloc(size);
-        return buf;
+        return kvmalloc(size, GFP_KERNEL);
 }
 
 /**
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index d0250744507a..5d9b2a08e553 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -767,8 +767,6 @@ void kvm_arch_check_processor_compat(void *rtn);
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu);
 
-void *kvm_kvzalloc(unsigned long size);
-
 #ifndef __KVM_HAVE_ARCH_VM_ALLOC
 static inline struct kvm *kvm_arch_alloc_vm(void)
 {
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 5d22e69f51ea..08e2849d27ca 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -518,6 +518,20 @@ static inline int is_vmalloc_or_module_addr(const void *x)
 }
 #endif
 
+extern void *kvmalloc_node(size_t size, gfp_t flags, int node);
+static inline void *kvmalloc(size_t size, gfp_t flags)
+{
+        return kvmalloc_node(size, flags, NUMA_NO_NODE);
+}
+static inline void *kvzalloc_node(size_t size, gfp_t flags, int node)
+{
+        return kvmalloc_node(size, flags | __GFP_ZERO, node);
+}
+static inline void *kvzalloc(size_t size, gfp_t flags)
+{
+        return kvmalloc(size, flags | __GFP_ZERO);
+}
+
 extern void kvfree(const void *addr);
 
 static inline atomic_t *compound_mapcount_ptr(struct page *page)
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index d68edffbf142..46991ad3ddd5 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -80,6 +80,7 @@ extern void *__vmalloc_node_range(unsigned long size, unsigned long align,
                         unsigned long start, unsigned long end, gfp_t gfp_mask,
                         pgprot_t prot, unsigned long vm_flags, int node,
                         const void *caller);
+extern void *__vmalloc_node_flags(unsigned long size, int node, gfp_t flags);
 
 extern void vfree(const void *addr);
 extern void vfree_atomic(const void *addr);
diff --git a/ipc/util.c b/ipc/util.c
index 3459a16a9df9..caec7b1bfaa3 100644
--- a/ipc/util.c
+++ b/ipc/util.c
@@ -403,12 +403,7 @@ void ipc_rmid(struct ipc_ids *ids, struct kern_ipc_perm *ipcp)
  */
 void *ipc_alloc(int size)
 {
-        void *out;
-        if (size > PAGE_SIZE)
-                out = vmalloc(size);
-        else
-                out = kmalloc(size, GFP_KERNEL);
-        return out;
+        return kvmalloc(size, GFP_KERNEL);
 }
 
 /**
diff --git a/mm/nommu.c b/mm/nommu.c
index 2d131b97a851..a80411d258fc 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -237,6 +237,11 @@ void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
 }
 EXPORT_SYMBOL(__vmalloc);
 
+void *__vmalloc_node_flags(unsigned long size, int node, gfp_t flags)
+{
+        return __vmalloc(size, flags, PAGE_KERNEL);
+}
+
 void *vmalloc_user(unsigned long size)
 {
         void *ret;
diff --git a/mm/util.c b/mm/util.c
index 656dc5e37a87..10a14a0ac3c2 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -329,6 +329,51 @@ unsigned long vm_mmap(struct file *file, unsigned long addr,
 }
 EXPORT_SYMBOL(vm_mmap);
 
+/**
+ * kvmalloc_node - attempt to allocate physically contiguous memory, but upon
+ * failure, fall back to non-contiguous (vmalloc) allocation.
+ * @size: size of the request.
+ * @flags: gfp mask for the allocation - must be compatible (superset) with GFP_KERNEL.
+ * @node: numa node to allocate from
+ *
+ * Uses kmalloc to get the memory but if the allocation fails then falls back
+ * to the vmalloc allocator. Use kvfree for freeing the memory.
+ *
+ * Reclaim modifiers - __GFP_NORETRY, __GFP_REPEAT and __GFP_NOFAIL are not supported
+ *
+ * Any use of gfp flags outside of GFP_KERNEL should be consulted with mm people.
+ */
+void *kvmalloc_node(size_t size, gfp_t flags, int node)
+{
+        gfp_t kmalloc_flags = flags;
+        void *ret;
+
+        /*
+         * vmalloc uses GFP_KERNEL for some internal allocations (e.g page tables)
+         * so the given set of flags has to be compatible.
+         */
+        WARN_ON_ONCE((flags & GFP_KERNEL) != GFP_KERNEL);
+
+        /*
+         * Make sure that larger requests are not too disruptive - no OOM
+         * killer and no allocation failure warnings as we have a fallback
+         */
+        if (size > PAGE_SIZE)
+                kmalloc_flags |= __GFP_NORETRY | __GFP_NOWARN;
+
+        ret = kmalloc_node(size, kmalloc_flags, node);
+
+        /*
+         * It doesn't really make sense to fallback to vmalloc for sub page
+         * requests
+         */
+        if (ret || size <= PAGE_SIZE)
+                return ret;
+
+        return __vmalloc_node_flags(size, node, flags | __GFP_HIGHMEM);
+}
+EXPORT_SYMBOL(kvmalloc_node);
+
 void kvfree(const void *addr)
 {
         if (is_vmalloc_addr(addr))
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index b52aeed3f58e..33603239560e 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -1786,6 +1786,13 @@ fail:
  *      Allocate enough pages to cover @size from the page level
  *      allocator with @gfp_mask flags.  Map them into contiguous
  *      kernel virtual space, using a pagetable protection of @prot.
+ *
+ *      Reclaim modifiers in @gfp_mask - __GFP_NORETRY, __GFP_REPEAT
+ *      and __GFP_NOFAIL are not supported
+ *
+ *      Any use of gfp flags outside of GFP_KERNEL should be consulted
+ *      with mm people.
+ *
  */
 static void *__vmalloc_node(unsigned long size, unsigned long align,
                             gfp_t gfp_mask, pgprot_t prot,
@@ -1802,7 +1809,7 @@ void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
 }
 EXPORT_SYMBOL(__vmalloc);
 
-static inline void *__vmalloc_node_flags(unsigned long size,
+void *__vmalloc_node_flags(unsigned long size,
                                         int node, gfp_t flags)
 {
         return __vmalloc_node(size, 1, flags, PAGE_KERNEL,
diff --git a/security/apparmor/apparmorfs.c b/security/apparmor/apparmorfs.c
index 41073f70eb41..be0b49897a67 100644
--- a/security/apparmor/apparmorfs.c
+++ b/security/apparmor/apparmorfs.c
@@ -98,7 +98,7 @@ static struct aa_loaddata *aa_simple_write_to_buffer(const char __user *userbuf,
                 return ERR_PTR(-ESPIPE);
 
         /* freed by caller to simple_write_to_buffer */
-        data = kvmalloc(sizeof(*data) + alloc_size);
+        data = kvmalloc(sizeof(*data) + alloc_size, GFP_KERNEL);
         if (data == NULL)
                 return ERR_PTR(-ENOMEM);
         kref_init(&data->count);
diff --git a/security/apparmor/include/lib.h b/security/apparmor/include/lib.h
index 0291ff3902f9..550a700563b4 100644
--- a/security/apparmor/include/lib.h
+++ b/security/apparmor/include/lib.h
@@ -64,17 +64,6 @@ char *aa_split_fqname(char *args, char **ns_name);
 const char *aa_splitn_fqname(const char *fqname, size_t n, const char **ns_name,
                              size_t *ns_len);
 void aa_info_message(const char *str);
-void *__aa_kvmalloc(size_t size, gfp_t flags);
-
-static inline void *kvmalloc(size_t size)
-{
-        return __aa_kvmalloc(size, 0);
-}
-
-static inline void *kvzalloc(size_t size)
-{
-        return __aa_kvmalloc(size, __GFP_ZERO);
-}
 
 /**
  * aa_strneq - compare null terminated @str to a non null terminated substring
diff --git a/security/apparmor/lib.c b/security/apparmor/lib.c
index 32cafc12593e..7cd788a9445b 100644
--- a/security/apparmor/lib.c
+++ b/security/apparmor/lib.c
@@ -129,36 +129,6 @@ void aa_info_message(const char *str)
 }
 
 /**
- * __aa_kvmalloc - do allocation preferring kmalloc but falling back to vmalloc
- * @size: how many bytes of memory are required
- * @flags: the type of memory to allocate (see kmalloc).
- *
- * Return: allocated buffer or NULL if failed
- *
- * It is possible that policy being loaded from the user is larger than
- * what can be allocated by kmalloc, in those cases fall back to vmalloc.
- */
-void *__aa_kvmalloc(size_t size, gfp_t flags)
-{
-        void *buffer = NULL;
-
-        if (size == 0)
-                return NULL;
-
-        /* do not attempt kmalloc if we need more than 16 pages at once */
-        if (size <= (16*PAGE_SIZE))
-                buffer = kmalloc(size, flags | GFP_KERNEL | __GFP_NORETRY |
-                                 __GFP_NOWARN);
-        if (!buffer) {
-                if (flags & __GFP_ZERO)
-                        buffer = vzalloc(size);
-                else
-                        buffer = vmalloc(size);
-        }
-        return buffer;
-}
-
-/**
  * aa_policy_init - initialize a policy structure
  * @policy: policy to initialize  (NOT NULL)
  * @prefix: prefix name if any is required.  (MAYBE NULL)
diff --git a/security/apparmor/match.c b/security/apparmor/match.c
index eb0efef746f5..960c913381e2 100644
--- a/security/apparmor/match.c
+++ b/security/apparmor/match.c
@@ -88,7 +88,7 @@ static struct table_header *unpack_table(char *blob, size_t bsize)
         if (bsize < tsize)
                 goto out;
 
-        table = kvzalloc(tsize);
+        table = kvzalloc(tsize, GFP_KERNEL);
         if (table) {
                 table->td_id = th.td_id;
                 table->td_flags = th.td_flags;
diff --git a/security/apparmor/policy_unpack.c b/security/apparmor/policy_unpack.c
index 2e37c9c26bbd..f3422a91353c 100644
--- a/security/apparmor/policy_unpack.c
+++ b/security/apparmor/policy_unpack.c
@@ -487,7 +487,7 @@ fail:
 
 static void *kvmemdup(const void *src, size_t len)
 {
-        void *p = kvmalloc(len);
+        void *p = kvmalloc(len, GFP_KERNEL);
 
         if (p)
                 memcpy(p, src, len);
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index 88257b311cb5..aca22d36be9c 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -504,7 +504,7 @@ static struct kvm_memslots *kvm_alloc_memslots(void)
         int i;
         struct kvm_memslots *slots;
 
-        slots = kvm_kvzalloc(sizeof(struct kvm_memslots));
+        slots = kvzalloc(sizeof(struct kvm_memslots), GFP_KERNEL);
         if (!slots)
                 return NULL;
 
@@ -689,18 +689,6 @@ out_err_no_disable:
         return ERR_PTR(r);
 }
 
-/*
- * Avoid using vmalloc for a small buffer.
- * Should not be used when the size is statically known.
- */
-void *kvm_kvzalloc(unsigned long size)
-{
-        if (size > PAGE_SIZE)
-                return vzalloc(size);
-        else
-                return kzalloc(size, GFP_KERNEL);
-}
-
 static void kvm_destroy_devices(struct kvm *kvm)
 {
         struct kvm_device *dev, *tmp;
@@ -782,7 +770,7 @@ static int kvm_create_dirty_bitmap(struct kvm_memory_slot *memslot)
 {
         unsigned long dirty_bytes = 2 * kvm_dirty_bitmap_bytes(memslot);
 
-        memslot->dirty_bitmap = kvm_kvzalloc(dirty_bytes);
+        memslot->dirty_bitmap = kvzalloc(dirty_bytes, GFP_KERNEL);
         if (!memslot->dirty_bitmap)
                 return -ENOMEM;
 
@@ -1008,7 +996,7 @@ int __kvm_set_memory_region(struct kvm *kvm,
                         goto out_free;
         }
 
-        slots = kvm_kvzalloc(sizeof(struct kvm_memslots));
+        slots = kvzalloc(sizeof(struct kvm_memslots), GFP_KERNEL);
         if (!slots)
                 goto out_free;
         memcpy(slots, __kvm_memslots(kvm, as_id), sizeof(struct kvm_memslots));