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 sistemaNúmero de llamadaPropósitoParámetros principales
sys_open5Abrir/crear archivoEBX=nombre de archivo, ECX=banderas, EDX=permisos
sys_read3Leer archivoEBX=fd, ECX=búfer, EDX=número de bytes
sys_write4Escribir archivoEBX=fd, ECX=búfer, EDX=número de bytes
sys_close6Cerrar archivoEBX=fd
sys_creat8Crear archivo (método antiguo)EBX=nombre de archivo, ECX=permisos
sys_lseek19Mover puntero de archivoEBX=fd, ECX=desplazamiento, EDX=posición inicial
sys_unlink10Eliminar archivoEBX=nombre de archivo

Banderas de apertura de archivos

ConstanteValorDescripción
O_RDONLY0Solo lectura
O_WRONLY1Solo escritura
O_RDWR2Lectura/escritura
O_CREAT64(0x40)Crear si el archivo no existe
O_TRUNC512(0x200)Vaciar el contenido del archivo al abrirlo
O_APPEND1024(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

; Ruta del archivo: file_write.asm
; 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

; Ruta del archivo: file_read.asm
; 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

; Ruta del archivo: file_append.asm
; 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

; Ruta del archivo: file_copy.asm
; 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

Antes 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.

Otras extensiones