Lenguaje ensamblador - Gestión de archivos
La gestión de archivos es la base de la interacción entre un programa y el almacenamiento externo.
Mediante llamadas al sistema, los programas en ensamblador pueden abrir, leer, escribir y cerrar archivos, manejando la E/S de archivos con tanta flexibilidad como los lenguajes de alto nivel.
Resumen del flujo de operaciones con archivos
Las operaciones con archivos siguen el flujo básico de abrir → leer/escribir → cerrar, junto con los tres descriptores de archivo estándar:
Llamadas al sistema relacionadas con operaciones de archivos
| Llamada al sistema | Número de llamada | Propósito | Parámetros principales |
|---|---|---|---|
| sys_open | 5 | Abrir/crear archivo | EBX=nombre de archivo, ECX=banderas, EDX=permisos |
| sys_read | 3 | Leer archivo | EBX=fd, ECX=búfer, EDX=número de bytes |
| sys_write | 4 | Escribir archivo | EBX=fd, ECX=búfer, EDX=número de bytes |
| sys_close | 6 | Cerrar archivo | EBX=fd |
| sys_creat | 8 | Crear archivo (método antiguo) | EBX=nombre de archivo, ECX=permisos |
| sys_lseek | 19 | Mover puntero de archivo | EBX=fd, ECX=desplazamiento, EDX=posición inicial |
| sys_unlink | 10 | Eliminar archivo | EBX=nombre de archivo |
Banderas de apertura de archivos
| Constante | Valor | Descripción |
|---|---|---|
| O_RDONLY | 0 | Solo lectura |
| O_WRONLY | 1 | Solo escritura |
| O_RDWR | 2 | Lectura/escritura |
| O_CREAT | 64(0x40) | Crear si el archivo no existe |
| O_TRUNC | 512(0x200) | Vaciar el contenido del archivo al abrirlo |
| O_APPEND | 1024(0x400) | Añadir al final del archivo |
Múltiples banderas se combinan con OR, por ejemploO_WRONLY | O_CREAT | O_TRUNC = 1 | 64 | 512 = 577
Crear y escribir en un archivo
Ejemplo
; Crear un archivo y escribir contenido
section .data
filename db 'ejemplo_output.txt', 0 ; Nombre del archivo (terminado en null)
content db 'Hello, EJEMPLO!', 0xA ; Contenido a escribir
content_len equ $ - content
create_msg db 'File created successfully!', 0xA
create_msg_len equ $ - create_msg
section .bss
fd resd 1 ; Descriptor de archivo
section .text
global _start
_start:
; 1. Crear archivo
mov eax, 8 ; sys_creat
mov ebx, filename ; Nombre del archivo
mov ecx, 0o644 ; Permisos: rw-r--r--
; 0o644 = propietario lectura/escritura, grupo solo lectura, otros solo lectura
int 0x80
mov [fd], eax ; Guardar descriptor de archivo
; 2. Escribir contenido en el archivo
mov eax, 4 ; sys_write
mov ebx, [fd] ; Descriptor de archivo
mov ecx, content ; Dirección de datos
mov edx, content_len ; Longitud de datos
int 0x80
; 3. Cerrar archivo
mov eax, 6 ; sys_close
mov ebx, [fd] ; Descriptor de archivo
int 0x80
; 4. Indicar éxito
mov eax, 4
mov ebx, 1
mov ecx, create_msg
mov edx, create_msg_len
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Resultado de ejecución:
$ nasm -f elf32 file_write.asm -o file_write.o $ ld -m elf_i386 file_write.o -o file_write $ ./file_write File created successfully! $ cat ejemplo_output.txt Hello, EJEMPLO!
Leer el contenido de un archivo
Ejemplo
; Abrir y leer el contenido de un archivo
section .data
filename db 'ejemplo_output.txt', 0
open_error db 'Error: cannot open file', 0xA
open_error_len equ $ - open_error
read_success db 'File content:', 0xA
read_success_len equ $ - read_success
section .bss
fd resd 1
buffer resb 1024 ; Búfer de lectura
section .text
global _start
_start:
; 1. Abrir archivo (solo lectura)
mov eax, 5 ; sys_open
mov ebx, filename ; Nombre del archivo
mov ecx, 0 ; Modo solo lectura
mov edx, 0 ; Permisos (ignorados en solo lectura)
int 0x80
cmp eax, 0 ; Descriptor de archivo < 0 indica error
jl open_failed
mov [fd], eax ; Guardar descriptor de archivo
; 2. Leer el contenido del archivo
mov eax, 3 ; sys_read
mov ebx, [fd] ; Descriptor de archivo
mov ecx, buffer ; Búfer
mov edx, 1024 ; Leer como máximo 1024 bytes
int 0x80
; Valor de retorno eax = número real de bytes leídos
mov esi, eax ; Guardar el número de bytes leídos
; 3. Cerrar archivo
mov eax, 6 ; sys_close
mov ebx, [fd]
int 0x80
; 4. Mostrar mensaje informativo
mov eax, 4
mov ebx, 1
mov ecx, read_success
mov edx, read_success_len
int 0x80
; 5. Mostrar el contenido del archivo en pantalla
mov eax, 4
mov ebx, 1
mov ecx, buffer
mov edx, esi ; Usar el número real de bytes leídos
int 0x80
jmp exit
open_failed:
mov eax, 4
mov ebx, 1
mov ecx, open_error
mov edx, open_error_len
int 0x80
exit:
mov eax, 1
mov ebx, 0
int 0x80
Resultado de ejecución:
$ nasm -f elf32 file_read.asm -o file_read.o $ ld -m elf_i386 file_read.o -o file_read $ ./file_read File content: Hello, EJEMPLO!
Escribir añadiendo a un archivo
Ejemplo
; Abrir archivo en modo añadir y escribir
section .data
filename db 'ejemplo_log.txt', 0
log_entry db '[INFO] Program executed successfully.', 0xA
log_len equ $ - log_entry
section .bss
fd resd 1
section .text
global _start
_start:
; Abrir archivo (crear + modo añadir)
mov eax, 5 ; sys_open
mov ebx, filename ; Nombre del archivo
mov ecx, 0x441 ; O_WRONLY | O_CREAT | O_APPEND
; O_WRONLY=1, O_CREAT=0x40, O_APPEND=0x400
; Combinación: 1 | 0x40 | 0x400 = 0x441
mov edx, 0o644 ; Permisos al crear
int 0x80
mov [fd], eax
; Escritura añadiendo
mov eax, 4 ; sys_write
mov ebx, [fd] ; Descriptor de archivo
mov ecx, log_entry ; Contenido de registro
mov edx, log_len
int 0x80
; Cerrar archivo
mov eax, 6
mov ebx, [fd]
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Copiar archivos
Un ejemplo completo: copiar el contenido de un archivo a otro:
Ejemplo
; Copiar archivo: copiar ejemplo_input.txt a ejemplo_copy.txt
section .data
src_file db 'ejemplo_input.txt', 0
dst_file db 'ejemplo_copy.txt', 0
success_msg db 'File copied successfully!', 0xA
success_len equ $ - success_msg
error_msg db 'Error during file copy', 0xA
error_len equ $ - error_msg
section .bss
src_fd resd 1
dst_fd resd 1
buffer resb 4096 ; Búfer de copia de 4KB
section .text
global _start
_start:
; 1. Abrir archivo de origen (solo lectura)
mov eax, 5
mov ebx, src_file
mov ecx, 0 ; O_RDONLY
mov edx, 0
int 0x80
cmp eax, 0
jl error_exit
mov [src_fd], eax
; 2. Crear archivo de destino
mov eax, 8 ; sys_creat
mov ebx, dst_file
mov ecx, 0o644
int 0x80
cmp eax, 0
jl error_exit
mov [dst_fd], eax
copy_loop:
; 3. Leer del archivo de origen
mov eax, 3 ; sys_read
mov ebx, [src_fd]
mov ecx, buffer
mov edx, 4096
int 0x80
; eax = número real de bytes leídos
cmp eax, 0 ; ¿Se leyeron 0 bytes?
jle copy_done ; Sí, fin del archivo
; 4. Escribir en el archivo de destino
mov esi, eax ; Guardar el número de bytes leídos
mov eax, 4 ; sys_write
mov ebx, [dst_fd]
mov ecx, buffer
mov edx, esi ; Escribir el número real de bytes leídos
int 0x80
jmp copy_loop ; Continuar el bucle
copy_done:
; 5. Cerrar archivos
mov eax, 6 ; sys_close
mov ebx, [src_fd]
int 0x80
mov eax, 6
mov ebx, [dst_fd]
int 0x80
; 6. Mostrar mensaje de éxito
mov eax, 4
mov ebx, 1
mov ecx, success_msg
mov edx, success_len
int 0x80
jmp exit
error_exit:
mov eax, 4
mov ebx, 1
mov ecx, error_msg
mov edx, error_len
int 0x80
exit:
mov eax, 1
mov ebx, 0
int 0x80
Otras extensionesAntes y después de las operaciones con archivos, asegúrate de comprobar el valor de retorno de las llamadas al sistema (en EAX). Un valor negativo indica un error (por ejemplo, -2 es ENOENT, archivo no existente; -13 es EACCES, permisos insuficientes). Ignorar los valores de retorno de error es la mayor fuente de bugs en las operaciones con archivos.