Hva er en system call, og hva er user mode og kernel mode?

Question

IT Interview Practice · Accepted Answer

En **system call (syscall)** er mekanismen et user-space-program bruker for å be kernelen om en tjeneste — åpne en fil, sende nettverksdata, allokere minne, opprette en prosess. Fordi disse handlingene berører maskinvare eller påvirker andre prosesser, er det bare **kernelen** som får utføre dem, så en syscall krysser bevisst beskyttelsesgrensen.

## User mode vs kernel mode

CPU-en kjører på ett av (minst) to privilegienivåer:

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

Et vanlig funksjonskall blir værende i user mode. En syscall utfører en kontrollert **mode switch** inn i kernel mode, kjører betrodd kernel-kode, og returnerer så:

```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
```

## Hvordan det fungerer i praksis

Du skriver sjelden trap-en selv — C-biblioteket pakker den inn. `fopen`/`fread` i koden din ender med å kalle syscallene `open`/`read`:

```c
// glibc sin read() legger syscall-nummeret + args i registre,
// og kjører deretter en trap-instruksjon (f.eks. `syscall` på x86-64).
ssize_t n = read(fd, buffer, 4096);   // → traps inn i kernelen
```

Trap-en (et software interrupt / en dedikert instruksjon) er det som endrer privilegienivået trygt — user-kode kan ikke bare "hoppe inn i" kernelen; den kan bare gå inn ved definerte syscall-inngangspunkter som validerer argumentene sine.

## Hvorfor det er viktig

Delingen mellom user og kernel er grunnlaget for OS-ets sikkerhet og stabilitet: det er derfor én prosess ikke kan rote på maskinvaren eller på en annen prosess' minne. Å forstå syscalls forklarer også ytelse — hver av dem koster en mode switch (hundrevis av nanosekunder), som er grunnen til at det å bunte I/O eller bruke `mmap`/`io_uring` for å redusere antallet syscalls betyr noe, og hvorfor `strace` (som lister opp et programs syscalls) er et så kraftig feilsøkingsverktøy.

User mode vs kernel mode

Hvordan det fungerer i praksis

Hvorfor det er viktig

Relaterte spørsmål