What Is vmalloc() in the Linux Kernel?

vmalloc() is a Linux kernel API that reserves a block of virtually contiguous memory for use inside kernel code, such as a device driver or kernel module. The key word here is “virtually” — the pages returned may be scattered anywhere in physical RAM, yet the kernel presents them to your code as one continuous virtual address range. This makes vmalloc() ideal for large allocations where physical contiguity is not required, such as big driver-internal buffers, module data structures, or firmware image staging areas.

vmalloc vs kmalloc: Choosing the Right Kernel Allocator

New driver authors often ask whether to use kmalloc() or vmalloc(). The table below, built for this free Linux device drivers course, summarises the practical differences you will run into on real hardware.

vzalloc() and kvmalloc(): Friends of vmalloc()

Modern kernel code rarely calls bare vmalloc() alone. Two closely related helpers appear constantly in real driver source trees:

A Simple vmalloc Demo Module (Updated for Modern Kernels)

Here is an original, minimal kernel module written for this lesson to demonstrate the three allocators together. It targets current 6.x kernel APIs and avoids deprecated calling conventions.

#include <linux/init.h>
#include <linux/module.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>

#define EP_BUF_SIZE   8192

static void *ep_vbuf;
static void *ep_vzbuf;
static void *ep_kvbuf;

static int __init ep_vmalloc_demo_init(void)
{
    ep_vbuf = vmalloc(EP_BUF_SIZE);
    if (!ep_vbuf) {
        pr_err("ep_demo: vmalloc failed\n");
        return -ENOMEM;
    }
    pr_info("ep_demo: vmalloc() ok, virt=0x%px\n", ep_vbuf);

    ep_vzbuf = vzalloc(EP_BUF_SIZE);
    if (!ep_vzbuf) {
        pr_err("ep_demo: vzalloc failed\n");
        vfree(ep_vbuf);
        return -ENOMEM;
    }
    pr_info("ep_demo: vzalloc() ok, zeroed buffer ready\n");

    ep_kvbuf = kvmalloc(EP_BUF_SIZE, GFP_KERNEL);
    if (!ep_kvbuf) {
        pr_err("ep_demo: kvmalloc failed\n");
        vfree(ep_vzbuf);
        vfree(ep_vbuf);
        return -ENOMEM;
    }
    pr_info("ep_demo: kvmalloc() ok\n");

    return 0;
}

static void __exit ep_vmalloc_demo_exit(void)
{
    kvfree(ep_kvbuf);
    vfree(ep_vzbuf);
    vfree(ep_vbuf);
    pr_info("ep_demo: module unloaded, memory freed\n");
}

module_init(ep_vmalloc_demo_init);
module_exit(ep_vmalloc_demo_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("EmbeddedPathashala vmalloc/vzalloc/kvmalloc demo");

Build and load it on your test system, then check the kernel log:

make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
sudo insmod ep_vmalloc_demo.ko
dmesg | tail -n 10
sudo rmmod ep_vmalloc_demo

Common Mistakes When Using vmalloc()

Best Practices for vmalloc in Driver Code

Performance and Security Considerations

Performance: because vmalloc() has to build page table entries for every page in the region, it is measurably slower than kmalloc() for the same size, especially under repeated allocate/free cycles. Reserve it for buffers that are allocated once and used for the module’s lifetime, rather than allocated and freed on a hot path.

Security: never expose raw vmalloc’d kernel addresses to user space, since predictable kernel virtual addresses can assist attackers in defeating kernel address space layout randomisation (KASLR). Always use the %pK or restricted pointer formats when logging these addresses.

Real-World Use Cases

Summary and Key Takeaways

Conclusion

This lesson from our free Linux kernel programming course walked through vmalloc(), vzalloc(), and kvmalloc() with an original demo module built for modern 6.x kernels. Mastering these allocators is a core skill for anyone progressing through our free Linux device drivers course, since almost every real driver eventually needs a buffer that kmalloc() alone cannot comfortably provide. In the next lesson, we go one level deeper and explain exactly how the kernel turns these virtual pages into physical memory on demand.

Frequently Asked Questions