Kernel Macros and Variables That Describe Segment Regions

In any free Linux kernel development course, you eventually need to know which macros actually encode the segment layout. The kernel does not hard-code address numbers everywhere — instead, it defines named macros and global variables that hold the boundary addresses of each region. Your module code should always use these names rather than hard-coded numbers, because the actual values change between architectures, kernel versions, and even boot sessions (due to KASLR).

Here is a reference table of the most important ones, organized from the highest KVA downward:

Writing a Kernel Module to Read Segment Information

Now let us build a practical kernel module. This module reads several of the macros above and prints them to the kernel ring buffer via printk(). You can then view the output with dmesg. This is one of the most instructive exercises in any free Linux kernel development course because it shows you the real numbers on your real hardware.

Step 1: Set Up Your Kernel Build Environment

Make sure you have the kernel headers installed for your running kernel:

# Ubuntu / Debian
sudo apt install linux-headers-$(uname -r) build-essential

# Fedora / RHEL
sudo dnf install kernel-devel kernel-headers

# Verify headers are in place
ls /lib/modules/$(uname -r)/build

Step 2: Create the Module Source File

Create a file called show_kernel_segment.c. The module reads key macros and prints them in a readable format. Note that we print sizes in MB to make the output human-friendly:

// show_kernel_segment.c
// EmbeddedPathashala - Free Linux Kernel Development Course
// Reads and prints key kernel segment region boundaries.
// Tested on Linux kernel 6.x (x86_64 and ARM64)

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/mm.h>          // high_memory
#include <linux/vmalloc.h>     // VMALLOC_START, VMALLOC_END

MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeddedPathashala");
MODULE_DESCRIPTION("Print Linux kernel segment region layout");
MODULE_VERSION("1.0");

// Helper: convert bytes to MB (unsigned long)
static inline unsigned long bytes_to_mb(unsigned long bytes)
{
    return bytes >> 20;
}

static int __init show_kernel_seg_init(void)
{
    pr_info("=== EmbeddedPathashala: Kernel Segment Layout ===\n");

    // PAGE_OFFSET: start of kernel segment (lowmem base)
    pr_info("PAGE_OFFSET (lowmem start) : 0x%016lx\n",
            (unsigned long)PAGE_OFFSET);

    // high_memory: top of the direct-mapped lowmem region
    pr_info("high_memory (lowmem end)   : 0x%016lx\n",
            (unsigned long)high_memory);

    pr_info("Lowmem size                : %lu MB\n",
            bytes_to_mb((unsigned long)high_memory - PAGE_OFFSET));

    // vmalloc region
#ifdef VMALLOC_START
    pr_info("VMALLOC_START              : 0x%016lx\n",
            (unsigned long)VMALLOC_START);
    pr_info("VMALLOC_END                : 0x%016lx\n",
            (unsigned long)VMALLOC_END);
    pr_info("vmalloc region size        : %lu MB\n",
            bytes_to_mb(VMALLOC_END - VMALLOC_START));
#endif

    // Kernel modules region
#ifdef MODULES_VADDR
    pr_info("MODULES_VADDR              : 0x%016lx\n",
            (unsigned long)MODULES_VADDR);
    pr_info("MODULES_END                : 0x%016lx\n",
            (unsigned long)MODULES_END);
    pr_info("Modules region size        : %lu MB\n",
            bytes_to_mb(MODULES_END - MODULES_VADDR));
#endif

    // Kernel image section symbols (defined by the linker script)
    pr_info("Kernel text  _text         : 0x%016lx\n",
            (unsigned long)_text);
    pr_info("Kernel text  _etext        : 0x%016lx\n",
            (unsigned long)_etext);
    pr_info("Kernel text size           : %lu kB\n",
            (unsigned long)(_etext - _text) / 1024);

    pr_info("Kernel data  _sdata        : 0x%016lx\n",
            (unsigned long)_sdata);
    pr_info("Kernel data  _edata        : 0x%016lx\n",
            (unsigned long)_edata);

    pr_info("Kernel BSS   __bss_start   : 0x%016lx\n",
            (unsigned long)__bss_start);
    pr_info("Kernel BSS   __bss_stop    : 0x%016lx\n",
            (unsigned long)__bss_stop);

    pr_info("=== End of kernel segment layout ===\n");
    return 0;   // 0 = success, module stays loaded
}

static void __exit show_kernel_seg_exit(void)
{
    pr_info("EmbeddedPathashala: show_kernel_segment module removed\n");
}

module_init(show_kernel_seg_init);
module_exit(show_kernel_seg_exit);

Step 3: Write the Makefile

Create a Makefile in the same directory:

# Makefile for show_kernel_segment module
obj-m += show_kernel_segment.o

# Point to the running kernel's build directory
KDIR := /lib/modules/$(shell uname -r)/build

all:
	make -C $(KDIR) M=$(PWD) modules

clean:
	make -C $(KDIR) M=$(PWD) clean

Step 4: Build and Insert the Module

# Build
make

# Insert the module
sudo insmod show_kernel_segment.ko

# View the output
dmesg | grep -A 30 "EmbeddedPathashala"

# Remove the module when done
sudo rmmod show_kernel_segment

Understanding the Output

On a modern 64-bit x86_64 Linux 6.x system, you will see something similar to this (exact addresses differ due to KASLR):

[  142.301234] === EmbeddedPathashala: Kernel Segment Layout ===
[  142.301240] PAGE_OFFSET (lowmem start) : 0xffff888000000000
[  142.301242] high_memory (lowmem end)   : 0xffff888200000000
[  142.301244] Lowmem size                : 8192 MB
[  142.301246] VMALLOC_START              : 0xffffc90000000000
[  142.301248] VMALLOC_END                : 0xffffe8ffffffffff
[  142.301250] vmalloc region size        : 32768 MB
[  142.301252] MODULES_VADDR              : 0xffffffffa0000000
[  142.301254] MODULES_END                : 0xfffffffffeffffff
[  142.301256] Modules region size        : 1504 MB
[  142.301258] Kernel text  _text         : 0xffffffff81000000
[  142.301260] Kernel text  _etext        : 0xffffffff82800000
[  142.301262] Kernel text size           : 24576 kB
...

How the Layout Differs Across Architectures

One of the key lessons in a free Linux kernel development course is that the kernel is intentionally portable, but memory layout is very architecture-specific. Here is a comparison table to make the differences concrete:

Viewing Kernel Region Info from User Space

You do not always need a kernel module to explore the memory layout. Several user space interfaces expose this information safely (without revealing actual addresses on hardened kernels):

# View vmalloc allocations (safe on all kernels)
cat /proc/vmallocinfo

# View physical memory layout by zone
cat /proc/zoneinfo

# View overall memory statistics
cat /proc/meminfo

# View memory map for PID 1 (init/systemd) - shows kernel mappings too
sudo cat /proc/1/maps | grep -v "r--p\|---p" | head -30

# Kernel documentation: reference map for x86_64 (in kernel source)
# File: Documentation/x86/x86_64/mm.rst

The /proc/vmallocinfo file is particularly useful when you are writing kernel code that uses vmalloc() or ioremap(). It shows you every current vmalloc allocation: which caller requested it, the virtual address range, and what flags were used. This helps diagnose vmalloc space exhaustion, which is a real concern on older 32-bit systems.

Common Mistakes When Working with Kernel Addresses

// Will print hashed address (safe for production logs):
pr_info("addr = %p\n", ptr);

// Will print real address (development only!):
pr_info("addr = %px\n", ptr);

// Or use %lx with explicit cast:
pr_info("addr = 0x%016lx\n", (unsigned long)ptr);

Best Practices for Kernel Memory Safety

Key Takeaways

Frequently Asked Questions

# Find your module's load address
cat /proc/modules | grep show_kernel_segment

# Find specific symbols including from modules
sudo grep show_kernel_seg /proc/kallsyms

Conclusion

In this lecture of our free Linux kernel development course, you moved from theoretical understanding of kernel segment regions to practical hands-on exploration using real kernel macros and a working LKM. The kernel segment layout is not just academic knowledge — it directly affects how you write device drivers, how you allocate memory correctly, and how you debug kernel panics and memory corruption issues.

Knowing the difference between lowmem and vmalloc addresses, understanding why PAGE_OFFSET matters, and being able to inspect the live kernel segment using both module code and /proc interfaces are all skills that set apart a junior kernel developer from a confident one. In the next lecture, we will dig into the kernel’s memory allocation APIs — kmalloc(), vmalloc(), get_free_pages(), and their friends — and you will understand immediately why the region distinctions you learned here matter so much for choosing the right allocator.