Linux Memory Management

1. Linux Memory Management How does the Linux kernel keep track of the Virtual Memory Areas that each process uses?

2. Hardware/Firmware/Software • The PC ‘s memory management system is a cooperative venture involving hardware, software, and firmware • The hardware and firmware would be the same no matter which Operating System we choose to run (i.e., Linux or Windows) • An operating system utilizes the hardware (in its own unique way) to provide multiple processes with protected memory-spaces

3. The Linux/x86 scheme • Let’s focus on the particular approach that Linux takes in utilizing the Intel x86 CPU’s memory-addressing capabilities • There are two conceptual levels (because “processor independence” is a goal Linux strives for): much of the Linux ‘mm’ code runs on almost any CPU, yet there’s some code is (unavoidably) specific to the x86

4. Source-code organization High-level ‘mm’ code is processor-independent (It’s in the ‘/usr/src/linux/mm’ subdirectory) Low-level ‘mm’ code is processor-specific (It’s in the ‘/usr/src/linux/arch/’ subdirectories) i386/mm ppc/mm mips/mm alpha/mm . . .

5. Our machines have 1GB of RAM 0x3FFFFFFF Main Memory (1 GB) Intel Pentium CPU 0x00000000 system bus NIC VGA FIFO (4 KB) VRAM (32 MB) some devices have RAM, too

6. Booting up • At power-on, the CPU sees only 1-MB of the physical memory (including the ROMs) • The OS initialization code must “activate” the processor’s “protected-mode” MMU so that all the ‘Extended Memory’ (including device-memory) will become addressable • Finally the OS enables “virtual memory” to allow the illusion of a 4-GB address-space

7. Kernel memory-mapping 0xFFFFFFFF 0x3FFFFFFF mappings 1-GB 896-MB 896-MB 0xC0000000 0x00000000 Physical memory 4-GB display memory device memory 0x00000000 Virtual Memory

8. Application memory-mapping kernel space user space stack stack mappings text 3-GB data physical memory data text virtual memory

9. ‘mm_struct’ • Each application-process uses a different mapping of physical memory regions into the Pentium’s “virtual” address-space, so one process can’t access memory owned by another process (i.e., private regions) • The OS switches these mapping when it suspends one process to resume another • Each task’s mapping is in its ‘task_struct’

10. How Linux tracks mappings mm_struct task_struct vm_area_struct vma start, end, etc mm pgd vm_area_struct start, end, etc vm_area_struct start, end, etc mapping-tables mapping-tables mapping-tables vm_area_struct start, end, etc

11. What does ‘malloc()’ do? • The standard C runtime environment lets a user program allocate additional memory void *malloc( unsigned long nbytes ); • This memory is released after being used void free( void *vaddr ); • Using suitable kernel modules we can see how the kernel keeps track of this memory

12. ‘mm.c’ and ‘vma.c’ • These modules create pseudo-files that allow us to view memory-management information associated with a user task • We can read such pseudo-files before, and after, we perform a call to ‘malloc()’ • Our ‘domalloc.cpp’ demo illistrates this • We can compare the file-outputs to see what changes occurred in the kernel data

13. When a program ‘forks()’ • We already know how new processes get created in the UNIX/Linux environment (i.e., via the ‘fork()’ function or system-call) • A child-process gets constructed using the same code and data as its parent-process • Yet each task’s memory-regions are kept ‘private’ (i.e., accessible to it alone) • So how exactly is this feat achieved?

14. Similar memory-mappings virtual memory virtual memory physical memory kernel space kernel space stack user space stack user space stack data data stack text data data text text parent-process child-process

15. Another demo • You could write a program, similar to our ‘domalloc.cpp’ demo, that would let a user compare the list of memory-regions which a parent-process owns and the list that its child-process has inherited

16. In-class exercise • Write an application program that allows a user to compare BOTH the ‘mm_struct’ and the ‘vm_area_struct’ information that belong to a parent-process and to its child • You can use our ‘mm.c’ and ‘vma.c’ Linux kernel modules, and you can imitate the programming ideas used in ‘domalloc.cpp’ • TURN IN printouts of your code and output