Wat is een system call, en wat zijn user mode en kernel mode?

Question

IT Interview Practice · Accepted Answer

Een **system call (syscall)** is het mechanisme dat een user-space-programma gebruikt om een dienst van de kernel aan te vragen — een file openen, netwerkdata versturen, geheugen alloceren, een proces aanmaken. Omdat deze acties hardware aanraken of andere processen beïnvloeden, mag alleen de **kernel** ze uitvoeren, dus een syscall overschrijdt bewust de beschermingsgrens.

## User mode versus kernel mode

De CPU draait in een van (ten minste) twee privilegeniveaus:

```text
 user mode   → restricted: no direct hardware access, no privileged instructions
 kernel mode → full access: hardware, all memory, privileged CPU instructions
```

Een gewone functieaanroep blijft in user mode. Een syscall voert een gecontroleerde **mode switch** naar kernel mode uit, draait vertrouwde kernelcode, en keert dan terug:

```text
  user code            kernel
  ─────────            ──────
  read(fd, buf, n)
      │  trap (syscall instruction)
      └──────────────▶ enter kernel mode
                       validate args, do the I/O
      ◀────────────── return value, back to user mode
  continue
```

## Hoe het in de praktijk werkt

Je schrijft de trap zelden zelf — de C-library verpakt hem. `fopen`/`fread` in je code roepen uiteindelijk de syscalls `open`/`read` aan:

```c
// glibc's read() plaatst het syscall-nummer + args in registers,
// en voert dan een trap-instructie uit (bv. `syscall` op x86-64).
ssize_t n = read(fd, buffer, 4096);   // → springt (trap) de kernel in
```

De trap (een software-interrupt / speciale instructie) is wat het privilegeniveau veilig verandert — usercode kan niet zomaar de kernel "inspringen"; die kan alleen binnenkomen op gedefinieerde syscall-entrypoints die hun argumenten valideren.

## Waarom het belangrijk is

De user/kernel-scheiding is de basis van OS-beveiliging en -stabiliteit: het is waarom één proces niet op hardware of het geheugen van een ander proces kan krassen. Syscalls begrijpen verklaart ook performance — elke syscall kost een mode switch (honderden nanoseconden), en daarom is I/O batchen of `mmap`/`io_uring` gebruiken om het aantal syscalls te verlagen belangrijk, en waarom `strace` (dat de syscalls van een programma opsomt) zo'n krachtig debugtool is.

User mode versus kernel mode

Hoe het in de praktijk werkt

Waarom het belangrijk is

Gerelateerde vragen