O que é uma system call, e o que são user mode e kernel mode?

Question

IT Interview Practice · Accepted Answer

Uma **system call (syscall)** é o mecanismo que um programa em user-space usa para solicitar um serviço ao kernel — abrir um arquivo, enviar dados de rede, alocar memória, criar um processo. Como essas ações tocam o hardware ou afetam outros processos, apenas o **kernel** pode executá-las, então uma syscall cruza deliberadamente a fronteira de proteção.

## User mode vs kernel mode

A CPU roda em um de (pelo menos) dois níveis de privilégio:

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

Uma chamada de função normal permanece em user mode. Uma syscall realiza um **mode switch** controlado para o kernel mode, executa código confiável do kernel e então retorna:

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

## Como funciona na prática

Você raramente escreve o trap você mesmo — a biblioteca C o encapsula. `fopen`/`fread` no seu código acabam chamando as syscalls `open`/`read`:

```c
// o read() da glibc coloca o número da syscall + args nos registradores,
// depois executa uma instrução de trap (ex. `syscall` no x86-64).
ssize_t n = read(fd, buffer, 4096);   // → faz o trap para dentro do kernel
```

O trap (uma software interrupt / instrução dedicada) é o que muda o nível de privilégio com segurança — o código de user não pode simplesmente "pular para dentro" do kernel; ele só pode entrar em pontos de entrada de syscall definidos, que validam seus argumentos.

## Por que isso importa

A divisão user/kernel é a base da segurança e estabilidade do OS: é por isso que um processo não pode rabiscar o hardware ou a memória de outro processo. Entender syscalls também explica o desempenho — cada uma custa um mode switch (centenas de nanossegundos), e é por isso que agrupar (batch) I/O ou usar `mmap`/`io_uring` para reduzir a quantidade de syscalls importa, e por que o `strace` (que lista as syscalls de um programa) é uma ferramenta de debug tão poderosa.

User mode vs kernel mode

Como funciona na prática

Por que isso importa

Perguntas relacionadas