The Memory Management Unit

all. That is Chapter seventy six's translation lookaside buffer.

Steps 2 and 3 are the reason the unit is a protection device and not merely an adder, and they are why a program that reads address 1 dies (Chapter two) and a program that writes to its own code dies (Chapter fourteen of Module 1 showed the text section mapped r-xp, read and execute and not write).

The three schemes it can implement

Everything in the rest of this row is one of these, and they differ only in what the unit looks the address up in.

So this chapter is the shape of the next eight. They are all the same three steps, with a different table and a different arithmetic in the middle.

What it costs, and why that matters

A table lookup is a memory access. So a naive paged unit makes two memory accesses for every one the program asked for: one to read the table, one to get the data.

That would halve the speed of the machine, and it is the reason the fourth thing in the list above exists. Chapter seventy six works the arithmetic and shows how a cache of translations brings the cost back to a few per cent.

The bounds and permission checks cost nothing: they happen in parallel with the translation, in hardware, and a legal access is not slowed at all by being checked.

Seeing the permission check work

The text section of a program is mapped read and execute but not write. Writing to it is not a mistake the compiler can catch, and the unit catches it on the instruction.

#include <stdio.h>
#include <string.h>

int main(void)
{
    /* a pointer to this function's own first instruction */
    void *code = (void *)main;

    printf("about to write one byte over my own code\n");
    memset(code, 0, 1);
    printf("this line is never reached\n");
    return 0;
}

$ gcc -std=c17 -Wall -Wextra -o writecode writecode.c
$ sh -c ./writecode
about to write one byte over my own code
Segmentation fault (core dumped)
$ echo $?
139

The program was allowed to compute that address, hold it in a pointer, and pass it to a function. Nothing stopped it until the instruction that actually wrote, and what stopped it then was the memory management unit noticing that the region is not writable. No software check happened: the kernel only found out because the hardware trapped.

That is the whole argument for doing protection in hardware rather than in the operating system: the check has to happen on every access, and only the hardware is present on every access.

Distinctions that carry marks

What it does not mean

The unit is not a cache. It has one inside it, the translation lookaside buffer, but its job is translation and protection.

It does not know about processes. It knows what is in its registers, which the kernel changes at every context switch. That change is the expensive part of Chapter sixteen's switch.

A trap is not the unit killing the process. The unit refuses and raises a trap; the kernel decides what to do, and what it usually does is send a signal.

Translation is not slow. A single translation is done in hardware in parallel with the access. What is slow is reading a table from memory to do it, which is why the cache exists.

Quick revision

• The memory management unit is hardware between the processor and the memory. It

translates every logical address to a physical one, on every access.

• The operating system does not translate addresses: it programs the unit, at a context

switch. It is not running while the process is.

• Four jobs: translate, check the bounds, check the permissions, and

cache the translation.

• Its simplest form is a relocation register plus a limit:

if address < limit then base + address else trap. Changing the relocation register moves the whole process.

• Three schemes, all the same three steps with a different table: base and limit,

segmentation, paging.

• A table lookup is itself a memory access, so a naive paged unit doubles the cost of every

access. That is what Chapter seventy six's cache is for.

• The bounds and permission checks are free: they happen in parallel with the translation.
• Writing to your own code compiles, runs, and dies on the instruction: the hardware refused, not

the operating system.

Test yourself

1. What does the memory management unit do? It converts every logical address the processor

generates into a physical address, checking the bounds and the permissions as it does so, and traps if either fails.

1. Is it hardware or software, and why does that matter? Hardware. The check must happen on

every memory access, and the operating system is not running while the process is, so only hardware can be present.

1. Give the translation and check for a relocation register. If the logical address is

strictly less than the limit, the physical address is the base plus the address; otherwise the hardware traps.

1. How is a process relocated under that scheme? By loading a different value into the

relocation register. Nothing in the program changes.

1. Name the four things a memory management unit does on an access. Translate the address,

check it is within the process's bounds, check the permissions for that region, and cache the translation for next time.

1. Why would a naive paged unit halve the speed of the machine? Because reading the page

table is itself a memory access, so every access the program makes costs two.

1. A program writes to its own code and dies. What caught it? The memory management unit,

because the text region is mapped read and execute but not write. It raised a trap and the kernel then killed the process; no software check took place.