Memory Management in Linux Kernel

Name: Memory Management in Linux Kernel
Rating: 4.3 (367 reviews)

Linux Kernel Programming - Memory Management in Deep

Created byLinux Trainer

Last updated 10/2020

English

What you'll learn

Knowledge of Memory management in Linux Kernel

Course content

3 sections • 44 lectures • 1h 57m total length

What is Physical Address Space2:06
Define physical address space as the processor-accessible range of memory addresses, and show how 32-bit four gigabytes and 64-bit systems share this space with memory devices and peripherals.
How to view memory map/physical address space in Linux - /proc/iomem1:24
Running 32-bit Buildroot image in QEMU3:16
Run a 32-bit buildroot image in qemu to examine physical memory and address space, and understand how devices, bios, and addresses are mapped in 64-bit emulation.
View/Change RAM Size in QEMU - /proc/meminfo, free -m1:38
Discover how to view and adjust the RAM size in QEMU using /proc/meminfo and the free -m command, enabling accurate memory management for virtual machines.
Virtual Address Space for 32-bit processors3:58
Why kernel shares its address space for all processes1:46
The kernel shares its address space across all processes to avoid costly memory context switches. User space remains per-process, while system calls map memory into each process.
64-bit Memory Map0:42
Examine the 64-bit memory map and the layout of userspace memory, and reference the documentation for details.
Converting Virtual address to physical address and vice versa5:12
Learn how to convert virtual addresses to physical addresses in the Linux kernel, using documented format specifiers, and print actual versus unmodified addresses with BTX and kernel guidelines.
Pages - PAGE_SIZE macro3:17
Explore how the linux kernel memory management divides virtual space into 4096-byte pages and maps them to physical frames via the memory management unit using page tables.
struct page1:26
Examine how memory pages are represented in the Linux kernel using struct page, including page frames, references, and virtual addresses. Note that each page is 64 bytes.
Page Fault4:27
explain how the Linux kernel uses paging and lazy userspace allocation, keeps kernel memory resident, and handles page faults, including minor and major faults.
Page Faults when memory is 4 KB1:11
User space virtual address space1:50
Explore the user space virtual address space, including the text and data segments, heap, stack, and environment variables, with process maps to reveal memory layout.
Kernel Virtual address space - low mem and high mem3:11
Explain how the kernel virtual address space splits into low memory and high memory and how page tables map physical memory.
Low Memory2:37
Explain how the Linux kernel maps physical memory into virtual space at boot, including a direct 896 MB mapping and the DMA and normal memory zones.
How can i find out how much is my low mem and high mem3:36
Learn to determine how much low mem and high mem you have, view total memory, and understand how ramp and off ramp settings affect memory allocation.
High Memory2:18
Memory Allocation Mechanism2:14
Explore how the Linux kernel allocates memory, from page level to the slab allocator, detailing four kilobyte pages and how slabs subdivide into 8, 16, and 32 byte chunks.
kmalloc and kfree2:48
Explore kmalloc and kfree in the Linux kernel, explaining contiguous physical and virtual memory allocation, slab allocator usage, and GFP flag behavior, including memory leaks and proper freeing practices.
Linux Kernel Module example of kmalloc and kfree1:36

Zones5:01
Explore how the Linux kernel partitions memory into dma, low memory, normal memory, and high memory zones on 32-bit and 64-bit systems, and inspect memory layout to verify these zones.
Buddy System allocator4:43
Explore how the Linux kernel uses zones and a buddy system allocator to manage physical memory, splitting memory into power-of-two page blocks and keeping per-order free lists to satisfy allocations.
Virtual Kernel Memory Layout1:58
Explore the virtual kernel memory layout, the memory map, and context mapping on 64-bit x86_64 systems, with reference to the documentation.
Can i use virt_to_phy to get physical address of kmalloc pointer1:25
This lecture explains that virt_to_phys yields the physical address only for kernel directly mapped addresses, usually from kmalloc, and cannot resolve user-space virtual addresses.
Example of passing various GFP_FLAGS to kmalloc5:57
Explore how the Linux kernel memory management maps virtual addresses to physical memory on a 64-bit system, illustrating address ranges, kibibyte conversions, and zone-based memory blocks through kmalloc concepts.
Maximum size that can be allocated using kmalloc5:00
Learn how to determine the maximum single-call allocation size for kmalloc by doubling from 1 KiB until allocation fails, and how kmalloc max size and order influence this limit.
What happens if we don't free memory allocated using kmalloc6:01
ksize3:58
Explore how the ksize function reveals the actual memory allocated in the Linux kernel, showing that allocations may exceed requests within slab memory management.
kzalloc1:46
kzalloc allocates memory in the Linux kernel and clears it to zero, preventing garbage values and ensuring zeroed memory on allocation.
krealloc1:12
Example to demonstrate kmalloc is contiguous in physical and virtual2:49
Explore how the kmalloc function yields memory that is physically and virtually contiguous, outlining benefits for devices needing a physical contiguous block and the trade-offs of allocating large chunks.
vmalloc0:39
Explore vmalloc in memory management within the Linux kernel. See how it provides a contiguous virtual space from non-contiguous physical memory via page tables.
Maximum size that can be allocated using vmalloc3:18
Investigate the maximum vmalloc allocation size in memory management, demonstrating iterative attempts, GFP flags considerations, and why large allocations are only virtually contiguous rather than physically contiguous.
vmalloc vs kmalloc6:12
Explore vmalloc vs kmalloc in the linux kernel, noting kmalloc's physically contiguous allocations and vmalloc's non-contiguous memory, and discuss memory size, address space, and limits.
Maximum size that can be allocated using vmalloc on 32-bit1:41
Explore the maximum vmalloc allocation on 32-bit Linux, and how practical physical memory limits constrain the theoretical size.
Why is VmallocUsed always 01:13
Explore why vmalloc used remains zero in the Linux kernel memory management, examining the single function that triggers the real operation and how memory areas are displayed in kilobytes.
Can i use ksize with vmalloc1:18
Explore memory management in the Linux kernel, focusing on allocation practices and what the documentation says, and discuss the challenge of determining exact allocated memory without a direct query function.
Maximum amount of memory that can be allocated using vmalloc1:26
Explore the maximum memory that can be allocated with vmalloc in the Linux kernel, and examine how the size in MB influences allocation behavior.
What happens when i do kmalloc of 0 zero bytes3:12
What happens when i do vmalloc of 0 bytes0:24
Analyze what happens when a vmalloc call allocates zero bytes in the Linux kernel, clarifying memory allocation behavior and edge cases in memory management.
Kernel Stack4:43
Explore memory management in the linux kernel by examining the kernel stack, local variables, and dynamic allocations across processes, including stack frames and stack pool behavior.
CONFIG_FRAME_WARN1:38
Explore how the CONFIG_FRAME_WARN option triggers a warning when a function's stack usage exceeds a configured limit, such as 8192 bytes, and how to adjust default values.
check_stack.pl script1:03
Explore the check_stack.pl script as a static analysis tool to estimate stack usage in the Linux kernel memory management space, noting recursion is not considered.

Requirements

Should be able to write/compile/load/unload Hello World Linux Kernel Modules

Description

This course offers a deep dive into the memory management of a Linux kernel, equipping you with practical knowledge and skills. You will first grasp the fundamental concepts of both physical and virtual address spaces for a processor and learn how to inspect them in a Linux environment. A key focus will be on the division of the virtual address space into distinct kernel and user spaces.

You'll gain an understanding of how the operating system handles memory in units called pages, and what triggers a page fault. The course will then detail the crucial process of converting a virtual address to a physical address, including the proper format specifiers for printing addresses.

Furthermore, you will explore the concepts of Low Memory and High Memory and the kernel's efficient Buddy Allocator for managing memory. You'll learn how to use the /proc/buddyinfo file to monitor memory zones. The course also covers dynamic memory allocation in the kernel using essential APIs like kmalloc and vmalloc, clarifying the differences between them and the various flags they use, such as GFP_KERNEL and GFP_ATOMIC. The course also addresses what happens when you attempt to allocate zero-sized memory. Lastly, you will examine the structure of the kernel stack and use the qemu-system-x86 command for practical exercises.

Who this course is for:

Developers curious about learning memory management in Linux Kernel

Memory Management in Linux Kernel

What you'll learn

Explore related topics

Course content

Memory Management Part 120 lectures • 51min

Memory Management Part 223 lectures • 1hr 7min

Resources1 lecture • 1min

Requirements

Description

Who this course is for: