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ème | Numéro d'appel | Objectif | Paramètres principaux |
|---|---|---|---|
| sys_open | 5 | Ouvrir/Créer un fichier | EBX=nom de fichier, ECX=drapeaux, EDX=permissions |
| sys_read | 3 | Lire le fichier | EBX=fd, ECX=buffer, EDX=nombre d'octets |
| sys_write | 4 | Écrire dans le fichier | EBX=fd, ECX=buffer, EDX=nombre d'octets |
| sys_close | 6 | Fermer le fichier | EBX=fd |
| sys_creat | 8 | Créer un fichier (hérité) | EBX=filename, ECX=permissions |
| sys_lseek | 19 | Déplacer le pointeur de fichier | EBX=fd, ECX=offset, EDX=origin |
| sys_unlink | 10 | Supprimer un fichier | EBX=filename |
Indicateurs d'ouverture de fichier
| Constante | Valeur | Description |
|---|---|---|
| O_RDONLY | 0 | Lecture seule |
| O_WRONLY | 1 | Écriture seule |
| O_RDWR | 2 | Lecture-écriture |
| O_CREAT | 64(0x40) | Créer si le fichier n'existe pas |
| O_TRUNC | 512(0x200) | Tronquer le fichier à l'ouverture |
| O_APPEND | 1024(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
; 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
; 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
; 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
; 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
Autres extensionsAssurez-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.