Vad är ett system call, och vad är user mode och kernel mode?

Question

IT Interview Practice · Accepted Answer

Ett **system call (syscall)** är mekanismen ett user-space-program använder för att begära en tjänst från kernel — öppna en fil, skicka nätverksdata, allokera minne, skapa en process. Eftersom dessa handlingar rör hårdvara eller påverkar andra processer får bara **kernel** utföra dem, så ett syscall korsar medvetet skyddsgränsen.

## User mode vs kernel mode

CPU:n körs i en av (minst) två privilegienivåer:

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

Ett vanligt funktionsanrop stannar i user mode. Ett syscall utför en kontrollerad **mode switch** in i kernel mode, kör betrodd kernel-kod, och returnerar sedan:

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

## Hur det fungerar i praktiken

Du skriver sällan trap:en själv — C-biblioteket omsluter den. `fopen`/`fread` i din kod anropar i slutänden syscall:erna `open`/`read`:

```c
// glibc:s read() lägger syscall-numret + args i register,
// och kör sedan en trap-instruktion (t.ex. `syscall` på x86-64).
ssize_t n = read(fd, buffer, 4096);   // → trap:ar in i kernel
```

Trap:en (ett software interrupt / en dedikerad instruktion) är det som ändrar privilegienivån säkert — user-space-kod kan inte bara "hoppa in i" kernel; den kan bara komma in vid definierade syscall-entrypoints som validerar sina argument.

## Varför det är viktigt

User/kernel-uppdelningen är grunden för OS-säkerhet och stabilitet: det är därför en process inte kan klottra på hårdvara eller en annan process minne. Att förstå syscalls förklarar också prestanda — varje ett kostar en mode switch (hundratals nanosekunder), vilket är varför det är viktigt att batcha I/O eller använda `mmap`/`io_uring` för att minska antalet syscalls, och varför `strace` (som listar ett programs syscalls) är ett så kraftfullt felsökningsverktyg.

User mode vs kernel mode

Hur det fungerar i praktiken

Varför det är viktigt

Relaterade frågor