Lenguaje ensamblador - Llamadas al sistema

Una llamada al sistema (System Call) es el único medio por el que un programa de usuario interactúa con el kernel del sistema operativo. Mediante las llamadas al sistema, los programas ensamblador pueden leer y escribir archivos, asignar memoria, crear procesos, etc.


¿Qué es una llamada al sistema?

Los programas de usuario se ejecutan en el restringidomodo de usuario (User Mode), y no pueden acceder directamente al hardware ni ejecutar operaciones privilegiadas.

Cuando el programa necesita realizar operaciones de E/S, asignación de memoria y otras funciones de nivel de kernel, debe hacerlo a través dellamadas al sistemapara solicitar servicios al kernel del sistema operativo.

El flujo de una llamada al sistema es: el programa de usuario inicia la llamada al sistema → la CPU cambia al modo kernel → el kernel ejecuta el servicio correspondiente → se regresa al modo usuario para continuar la ejecución.

Linux 32位系统调用流程

Se puede entender la llamada al sistema como:El programa de usuario hace una llamada telefónica al sistema operativo para pedir ayuda para hacer algo que no tiene permiso de hacer por sí mismo.


Mecanismo de llamadas al sistema en Linux

En los sistemas Linux de 32 bits, las llamadas al sistema se realizan mediante los siguientes pasos:

  1. va aEl número de llamada al sistemase coloca en el registro EAX
  2. Los parámetros se colocan en los registros EBX, ECX, EDX, ESI, EDI, etc.
  3. Se ejecutaint 0x80la instrucción que desencadena una interrupción de software
  4. La CPU cambia al modo kernel, y el kernel ejecuta el servicio correspondiente según el número de llamada en EAX
  5. El kernel coloca el valor de retorno en EAX, vuelve al modo usuario y continúa la ejecución

Resumen de llamadas al sistema comunes

Llamada al sistemaNúmero de llamada (EAX)FunciónParámetros
sys_exit1Salir del programaEBX = valor de retorno (código de salida)
sys_fork2Crear un proceso hijoSin parámetros
sys_read3Leer archivo/entradaEBX=fd, ECX=buf, EDX=count
sys_write4Escribir archivo/salidaEBX=fd, ECX=buf, EDX=count
sys_open5Abrir archivoEBX=filename, ECX=flags, EDX=mode
sys_close6Cerrar archivoEBX=fd
sys_creat8Crear archivoEBX=filename, ECX=mode
sys_lseek19Mover el puntero del archivoEBX=fd, ECX=offset, EDX=whence
sys_brk45Ajustar el tamaño del segmento de datos (asignación de memoria)EBX = nueva dirección

La lista completa de llamadas al sistema se puede consultar en/usr/include/asm/unistd_32.hNota: los números de llamada al sistema de 32 y 64 bits son diferentes.


sys_write - Salida de cadenas

La llamada al sistema más utilizada, que sirve para mostrar contenido en la pantalla:

Ejemplo

; Ruta del archivo: write_syscall.asm
; Usar sys_write para mostrar una cadena

section .data
    msg db 'Hello, ejemplo! Welcome to assembly.', 0xA
    len equ $ - msg

section .text
    global _start

_start:
    ; Llamar a sys_write (4)
    mov eax, 4                  ; Número de llamada al sistema 4 = sys_write
    mov ebx, 1                  ; Descriptor de archivo 1 = stdout (salida estándar)
    mov ecx, msg                ; Dirección de los datos a mostrar
    mov edx, len                ; Longitud de los datos (en bytes)
    int 0x80                    ; Disparar la llamada al sistema

    ; En caso de éxito, EAX devuelve el número real de bytes escritos

    ; Salir del programa
    mov eax, 1
    mov ebx, 0
    int 0x80

Resultado de la ejecución:

$ nasm -f elf32 write_syscall.asm -o write_syscall.o
$ ld -m elf_i386 write_syscall.o -o write_syscall
$ ./write_syscall
Hello, ejemplo! Welcome to assembly.

sys_read - Lectura de la entrada del usuario

Lee datos desde la entrada estándar (teclado):

Ejemplo

; Ruta del archivo: read_syscall.asm
; Usar sys_read para leer la entrada del usuario y mostrarla en pantalla

section .bss
    buffer resb 64              ; Reservar un búfer de entrada de 64 bytes

section .data
    prompt db 'Please enter your name: '
    prompt_len equ $ - prompt
    output_msg db 'Hello, '
    output_msg_len equ $ - output_msg

section .text
    global _start

_start:
    ; Mostrar el mensaje de aviso
    mov eax, 4
    mov ebx, 1
    mov ecx, prompt
    mov edx, prompt_len
    int 0x80

    ; Leer la entrada del usuario
    mov eax, 3                  ; Número de llamada al sistema 3 = sys_read
    mov ebx, 0                  ; Descriptor de archivo 0 = stdin (entrada estándar)
    mov ecx, buffer             ; Dirección del búfer de entrada
    mov edx, 64                 ; Leer como máximo 64 bytes
    int 0x80

    ; EAX devuelve el número real de bytes leídos (incluye el salto de línea final)
    mov esi, eax                ; Guardar la longitud real de la entrada en esi

    ; Mostrar "Hello, "
    mov eax, 4
    mov ebx, 1
    mov ecx, output_msg
    mov edx, output_msg_len
    int 0x80

    ; Mostrar el contenido introducido por el usuario
    mov eax, 4
    mov ebx, 1
    mov ecx, buffer
    mov edx, esi                ; Usar el número real de bytes introducidos
    int 0x80

    ; Salir del programa
    mov eax, 1
    mov ebx, 0
    int 0x80

Resultado de la ejecución:

$ nasm -f elf32 read_syscall.asm -o read_syscall.o
$ ld -m elf_i386 read_syscall.o -o read_syscall
$ ./read_syscall
Please enter your name: ejemplo
Hello, ejemplo

sys_exit - Salir del programa

Cada programa debe llamar a sys_exit para salir correctamente; de lo contrario, la CPU continuará ejecutando los datos basura posteriores, lo que provocará un error de segmentación.

Ejemplo

; Salir con diferentes códigos de salida

    mov eax, 1                  ; Número de llamada al sistema 1 = sys_exit
    mov ebx, 0                  ; Código de salida 0 = salida normal (también puede ser un valor distinto de cero)
    int 0x80

El código de salida se puede ver en el shell mediante$?el comando:

$ ./program
$ echo $?
0

Plantilla general de llamadas al sistema

Al escribir una llamada al sistema, se puede seguir la siguiente plantilla general:

Ejemplo

; Plantilla general de llamadas al sistema
; Apto para sistemas Linux de 32 bits

; Paso 1: colocar el número de llamada al sistema en EAX
mov eax,Número de llamada al sistema

; Paso 2: colocar los parámetros en orden
mov ebx,ordinal1parámetro(s)
mov ecx,ordinal2parámetro(s)
mov edx,ordinal3parámetro(s)
mov esi,ordinal4parámetro(s)
mov edi,ordinal5parámetro(s)

; Paso 3: disparar la llamada al sistema
int 0x80

; Paso 4: comprobar el valor de retorno (en EAX)
; Normalmente, un valor negativo indica un error
cmp eax, 0
jl error_handler              ; Si EAX < 0, saltar al manejo de errores

int 0x80Después de la llamada, EAX contiene el valor de retorno. La mayoría de las llamadas al sistema devuelven un valor no negativo en caso de éxito y un código de error negativo en caso de fallo (por ejemplo, -1 significa EPERM).

Otras extensiones