Langage d'assemblage - Gestion des fichiers

La gestion des fichiers est la base pour que les programmes interagissent avec le stockage externe.

Grâce aux appels système, les programmes en assembleur peuvent ouvrir, lire, écrire et fermer des fichiers, en gérant les E/S de fichiers avec autant de souplesse que les langages de haut niveau.


Aperçu du processus d'opérations sur les fichiers

Les opérations sur les fichiers suivent le flux de base ouvrir → lire/écrire → fermer, avec trois descripteurs de fichier standard :

文件操作流程图

Appels système liés aux opérations sur les fichiers

Appel systèmeNuméro d'appelObjectifParamètres principaux
sys_open5Ouvrir/Créer un fichierEBX=nom de fichier, ECX=drapeaux, EDX=permissions
sys_read3Lire le fichierEBX=fd, ECX=buffer, EDX=nombre d'octets
sys_write4Écrire dans le fichierEBX=fd, ECX=buffer, EDX=nombre d'octets
sys_close6Fermer le fichierEBX=fd
sys_creat8Créer un fichier (hérité)EBX=filename, ECX=permissions
sys_lseek19Déplacer le pointeur de fichierEBX=fd, ECX=offset, EDX=origin
sys_unlink10Supprimer un fichierEBX=filename

Indicateurs d'ouverture de fichier

ConstanteValeurDescription
O_RDONLY0Lecture seule
O_WRONLY1Écriture seule
O_RDWR2Lecture-écriture
O_CREAT64(0x40)Créer si le fichier n'existe pas
O_TRUNC512(0x200)Tronquer le fichier à l'ouverture
O_APPEND1024(0x400)Ajouter à la fin du fichier

Plusieurs indicateurs sont combinés avec OR, par exemple :O_WRONLY | O_CREAT | O_TRUNC = 1 | 64 | 512 = 577


Créer et écrire dans un fichier

Exemple

; Chemin du fichier : file_write.asm
; Créer un fichier et écrire du contenu

section .data
    filename db 'example_output.txt', 0    ; Nom du fichier (terminé par un caractère nul)
    content db 'Hello, EXAMPLE!', 0xA       ; Contenu à écrire
    content_len equ $ - content
    create_msg db 'Fichier créé avec succès !', 0xA
    create_msg_len equ $ - create_msg

section .bss
    fd resd 1                               ; Descripteur de fichier

section .text
    global _start

_start:
    ; 1. Créer un fichier
    mov eax, 8                  ; sys_creat
    mov ebx, filename           ; Nom de fichier
    mov ecx, 0o644              ; Permissions: rw-r--r--
    ; 0o644 = propriétaire lecture/écriture, groupe lecture seule, autres lecture seule
    int 0x80

    mov [fd], eax               ; Enregistrer le descripteur de fichier

    ; 2. Écrire le contenu dans le fichier
    mov eax, 4                  ; sys_write
    mov ebx, [fd]               ; Descripteur de fichier
    mov ecx, content            ; Adresse des données
    mov edx, content_len        ; Longueur des données
    int 0x80

    ; 3. Fermer le fichier
    mov eax, 6                  ; sys_close
    mov ebx, [fd]               ; Descripteur de fichier
    int 0x80

    ; 4. Afficher le message de réussite
    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

Résultat de l'exécution :

$ 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 example_output.txt
Hello, EXAMPLE!

Lire le contenu du fichier

Exemple

; Chemin du fichier : file_read.asm
; Ouvrir et lire le contenu du fichier

section .data
    filename db 'example_output.txt', 0
    open_error db 'Erreur : ouverture du fichier impossible', 0xA
    open_error_len equ $ - open_error
    read_success db 'Contenu du fichier :', 0xA
    read_success_len equ $ - read_success

section .bss
    fd resd 1
    buffer resb 1024                 ; Tampon de lecture

section .text
    global _start

_start:
    ; 1. Ouvrir le fichier (lecture seule)
    mov eax, 5                  ; sys_open
    mov ebx, filename           ; Nom de fichier
    mov ecx, 0                  ; Mode lecture seule
    mov edx, 0                  ; Permissions (ignorées en lecture seule)
    int 0x80

    cmp eax, 0                  ; Un descripteur de fichier < 0 indique une erreur
    jl  open_failed

    mov [fd], eax               ; Enregistrer le descripteur de fichier

    ; 2. Lire le contenu du fichier
    mov eax, 3                  ; sys_read
    mov ebx, [fd]               ; Descripteur de fichier
    mov ecx, buffer             ; Tampon
    mov edx, 1024               ; Lire jusqu'à 1024 octets
    int 0x80
    ; Valeur de retour eax = nombre d'octets réellement lus
    mov esi, eax                ; Enregistrer le nombre d'octets lus

    ; 3. Fermer le fichier
    mov eax, 6                  ; sys_close
    mov ebx, [fd]
    int 0x80

    ; 4. Afficher le message d'invite
    mov eax, 4
    mov ebx, 1
    mov ecx, read_success
    mov edx, read_success_len
    int 0x80

    ; 5. Afficher le contenu du fichier à l'écran
    mov eax, 4
    mov ebx, 1
    mov ecx, buffer
    mov edx, esi                ; Utiliser le nombre d'octets réellement lus
    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

Résultat de l'exécution :

$ 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, EXAMPLE!

Écrire en ajout dans un fichier

Exemple

; Chemin du fichier : file_append.asm
; Ouvrir le fichier en mode ajout et écrire

section .data
    filename db 'example_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:
    ; Ouvrir le fichier (création + mode ajout)
    mov eax, 5                  ; sys_open
    mov ebx, filename           ; Nom de fichier
    mov ecx, 0x441              ; O_WRONLY | O_CREAT | O_APPEND
    ; O_WRONLY=1, O_CREAT=0x40, O_APPEND=0x400
    ; Combinaison : 1 | 0x40 | 0x400 = 0x441
    mov edx, 0o644              ; Permissions à la création
    int 0x80

    mov [fd], eax

    ; Écriture en ajout
    mov eax, 4                  ; sys_write
    mov ebx, [fd]               ; Descripteur de fichier
    mov ecx, log_entry          ; Contenu du journal
    mov edx, log_len
    int 0x80

    ; Fermer le fichier
    mov eax, 6
    mov ebx, [fd]
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Copier le fichier

Un exemple complet : copier le contenu d'un fichier vers un autre :

Exemple

; Chemin du fichier : file_copy.asm
; Copier le fichier : copier example_input.txt vers example_copy.txt

section .data
    src_file db 'example_input.txt', 0
    dst_file db 'example_copy.txt', 0
    success_msg db 'Fichier copié avec succès !', 0xA
    success_len equ $ - success_msg
    error_msg db 'Erreur lors de la copie du fichier', 0xA
    error_len equ $ - error_msg

section .bss
    src_fd resd 1
    dst_fd resd 1
    buffer resb 4096              ; tampon de copie de 4KB

section .text
    global _start

_start:
    ; 1. Ouvrir le fichier source (lecture seule)
    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. Créer le fichier de destination
    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. Lire depuis le fichier source
    mov eax, 3                   ; sys_read
    mov ebx, [src_fd]
    mov ecx, buffer
    mov edx, 4096
    int 0x80
    ; eax = nombre d'octets réellement lus
    cmp eax, 0                   ; A-t-on lu 0 octet ?
    jle copy_done                ; Oui, fin de fichier

    ; 4. Écrire dans le fichier de destination
    mov esi, eax                 ; Sauvegarder le nombre d'octets lus
    mov eax, 4                   ; sys_write
    mov ebx, [dst_fd]
    mov ecx, buffer
    mov edx, esi                 ; Écrire le nombre d'octets effectivement lus
    int 0x80
    jmp copy_loop                ; Continuer la boucle

copy_done:
    ; 5. Fermer le fichier
    mov eax, 6                   ; sys_close
    mov ebx, [src_fd]
    int 0x80

    mov eax, 6
    mov ebx, [dst_fd]
    int 0x80

    ; 6. Afficher le message de succès
    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

Assurez-vous de vérifier la valeur de retour des appels système (dans EAX) avant et après les opérations sur les fichiers. Une valeur négative indique une erreur (par exemple, -2 est ENOENT fichier introuvable, -13 est EACCES permissions insuffisantes). Ignorer les valeurs de retour d'erreur est la plus grande source de bugs lors des opérations sur les fichiers.

Autres extensions