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.
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:
- va aEl número de llamada al sistemase coloca en el registro EAX
- Los parámetros se colocan en los registros EBX, ECX, EDX, ESI, EDI, etc.
- Se ejecuta
int 0x80la instrucción que desencadena una interrupción de software - La CPU cambia al modo kernel, y el kernel ejecuta el servicio correspondiente según el número de llamada en EAX
- 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 sistema | Número de llamada (EAX) | Función | Parámetros |
|---|---|---|---|
| sys_exit | 1 | Salir del programa | EBX = valor de retorno (código de salida) |
| sys_fork | 2 | Crear un proceso hijo | Sin parámetros |
| sys_read | 3 | Leer archivo/entrada | EBX=fd, ECX=buf, EDX=count |
| sys_write | 4 | Escribir archivo/salida | EBX=fd, ECX=buf, EDX=count |
| sys_open | 5 | Abrir archivo | EBX=filename, ECX=flags, EDX=mode |
| sys_close | 6 | Cerrar archivo | EBX=fd |
| sys_creat | 8 | Crear archivo | EBX=filename, ECX=mode |
| sys_lseek | 19 | Mover el puntero del archivo | EBX=fd, ECX=offset, EDX=whence |
| sys_brk | 45 | Ajustar 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
; 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
; 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
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
; 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
Otras extensiones
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).