Chamadas de Sistema e Interrupções no Linux | Assembly NASM

As chamadas de sistema estão fortemente ligadas ao conceito de interrupção (interrupt). Uma interrupção é um sinal enviado ao processador por dispositivos de hardware, temporizadores ou eventos externos, que faz o processador suspender a execução atual para tratar o evento recebido.

Ao receber uma interrupção, o processador pausa temporariamente a execução do programa, salva seu estado e executa uma rotina específica chamada handler de interrupção (interrupt handler ou interrupt service routine – ISR). Após o tratamento, o processador restaura o estado anterior e retoma a execução normal do programa.

Esse mecanismo permite que o sistema reaja a eventos externos em tempo real, sem precisar verificar continuamente (polling) se algo ocorreu. Assim, o uso de interrupções evita o desperdício de recursos do processador e garante uma resposta mais eficiente a eventos assíncronos, como entrada de dados, sinais de hardware ou erros de execução.

Tipos de Interrupções

As interrupções se dividem em três categorias principais: hardware, software e exceções.

Interrupções de hardware são geradas por dispositivos externos, como teclado, mouse, discos e interfaces de rede, para informar ao processador que necessitam de atenção. Exemplos comuns incluem:

• Interrupções de temporizador: acionadas periodicamente para manter o relógio do sistema e gerenciar a multitarefa.
• Interrupções de entrada e saída: enviadas por dispositivos como teclados e placas de rede para indicar que há dados disponíveis ou operações concluídas.

Interrupções de software são geradas pela execução de instruções específicas dentro de um programa. Normalmente, são usadas para solicitar serviços ao sistema operacional, como leitura e escrita de arquivos ou finalização de processos.

Exceções representam condições anormais ou erros durante a execução do programa — por exemplo, divisão por zero, acesso inválido à memória ou instruções ilegais. O sistema operacional trata essas situações para preservar a estabilidade do sistema.

Interrupções e Chamadas de Sistema no Linux

No Linux, as chamadas de sistema são implementadas internamente por meio de interrupções. Quando uma aplicação faz uma chamada a uma função da biblioteca padrão, como read(), ela não interage diretamente com o hardware, mas aciona um mecanismo interno do kernel por meio de uma interrupção.

Por exemplo, a chamada read é normalmente executada através de uma camada intermediária da biblioteca libc, que gera uma interrupção de software, tradicionalmente a 0x80.

O processo ocorre em etapas:

1. O número da chamada de sistema é colocado no registrador EAX (ou RAX, em modo de 64 bits).
2. O sistema entra no modo de kernel.
3. O processador consulta a tabela de descritores de interrupções (Interrupt Descriptor Table – IDT) para localizar o handler correspondente à interrupção 0x80.
4. O controle é transferido para a rotina do kernel responsável por chamadas de sistema — system_call().
5. Essa rotina busca o identificador da função (__NR_read) na sys_call_table e chama a função do kernel sys_read().
6. A função sys_read() realiza a operação real de leitura do arquivo ou dispositivo.

Interrupções em Assembly x86 e x86-64

Nas arquiteturas x86 mais antigas, as chamadas de sistema eram feitas com a instrução INT, que gerava uma interrupção de software. A partir da arquitetura x86-64, o Linux passou a usar a instrução SYSCALL, projetada especificamente para chamadas de sistema, sem depender do mecanismo de interrupções.

Ainda assim, em sistemas Linux de 64 bits é possível continuar usando a instrução INT 0x80, embora seja menos eficiente que syscall.

Exemplo clássico de uso da interrupção 0x80 para escrever no console e encerrar o programa:

section .data
    msg db "Hello, World!", 10
    len equ $ - msg

section .text
global _start

_start:
    ; exibe mensagem na tela
    mov eax, 4              ; número da função sys_write
    mov ebx, 1              ; descritor do arquivo (1 = saída padrão)
    mov ecx, msg            ; endereço da mensagem
    mov edx, len            ; comprimento da mensagem
    int 0x80                ; gera interrupção para chamar o kernel

    ; encerra o programa
    mov eax, 1              ; número da função sys_exit
    xor ebx, ebx            ; código de retorno 0
    int 0x80                ; gera interrupção novamente

A instrução int 0x80 chama a interface de serviços do kernel. O número da função é definido em eax, enquanto os parâmetros são passados em ebx, ecx e edx. No exemplo, o número 4 indica sys_write, e o número 1 indica sys_exit.

Resumo

• Interrupções permitem que o processador reaja a eventos externos ou internos sem bloqueio.
• Há três tipos principais: hardware, software e exceções.
• Chamadas de sistema são implementadas sobre interrupções, que transferem o controle para o kernel.
• Em x86, a instrução int 0x80 executa chamadas de sistema via interrupção; em x86-64, a instrução syscall substitui esse método.
• O código de exemplo mostra como exibir texto e encerrar um programa usando interrupções.