Who decides the physical address for a particular virtual address, kernel or MMU?

Question

I am trying to understand how the physical addresses are allocated when running an OS.

My question is when the kernel allocates some memory (lets say using kmalloc), who decides what physical memory address range should be mapped for this virtual memory range?

I understand that kernel will create page tables to translate the mapping from virtual to physical and the MMU will use it. But before that, someone should allocate/assign some physical pages to be mapped. Is this done by the kernel itself or will the MMU let the kernel know a particular range of physical addresses that can be used?

If the kernel itself assigns the physical addresses, how does it keep track of what physical addresses are already used and what are free (to be used)?

Answer 1

I am trying to understand how the physical addresses are allocated when running an OS.

Physical addresses are not allocated, they're already there – it's the RAM.

My question is when the kernel allocates some memory (lets say using kmalloc), who decides what physical memory address range should be mapped for this virtual memory range?

Who: the kernel memory mapping algorithm. So, the kernel.

But before that, someone should allocate/assign some physical pages to be mapped.

As said, the physical memory is the reality that the kernel has to deal with.

The question of how the memory chips are mapped to form a piece-wise contiguous memory range depends on your hardware and its boot process. In desktop or server x86, typically, as you initialize the DRAM controller during boot, firmware (or your bootloader) reads the contents of the DRAM memory modules ("DIMMs") "configuration EEPROM"s and configures the memory controller of your CPU (or the mainboard, depending on the specifics of your hardware) to translate memory address accesses to read and writes for these chips accordingly. On embedded platforms, the RAM configuration might just be baked into the software (e.g., uboot and the Linux kernel initializing hardware using devicetree) and then the memory controller gets configured that way.

So, there's no universal answer here. "How to deal with dynamic memory" is one of the main things that architectures differ in – and that can get pretty detailed and CPU-model-specific, if you remember PAE on i386.

who decides what physical memory address range should be mapped for this virtual memory range?

Let's talk about how: since the kernel, through hardware or firmware interfaces, or through configuration files, knows how much physical memory is where in the physical address space, where the memory mapped IO is, and what memory it's already using, it is able to keep a data structure tracking free physical memory. So, when you call kmalloc with a specific size, you look for an unused piece of physical memory that fits the size requirement.

Answer 2

It's simple.

• Initially, as part of the boot process, the CPU resets the MMU.
• The kernel detects the physical memory (RAM), and builds data structures that kmalloc can allocate. The RAM where the kernel's code lives is excluded.
• When the kernel decides to run a process (/sbin/init) initially, it allocates needed internal tables, and a block of RAM to map in the executable.
• Only then, as part of process srartup, the MMU is set, using "page tables" so every process sees a memory space beginning at location 0, and this process's location 0 is unique. Every process's location 0 is toxic - you'll get a SEGV - segment violation if you use it. This detects uninitialized pointers.
• While the CPU is in 'supervisor' mode (a hardware state) the MMU is disabled. The MMU takes effect when the kernel transfers control to the process, and clears 'supervisor' mode.
• Now active, the MMU inserts itself into the CPU<->RAM hardware path, so it's now CPU<->MMU<->RAM.
• Every address issued by the CPU has its high order bits replaced with bits from the page table, until the CPU gets back into 'supervisor' mode, via an interrupt.