Langage d'assemblage - Appels système
Les appels système sont le seul moyen pour les programmes utilisateur d'interagir avec le noyau du système d'exploitation. Grâce aux appels système, les programmes en langage d'assemblage peuvent lire/écrire des fichiers, allouer de la mémoire, créer des processus, et bien plus encore.
Qu'est-ce qu'un appel système ?
Les programmes utilisateur s'exécutent enmode utilisateurrestreint et ne peuvent pas accéder directement au matériel ni exécuter des opérations privilégiées.
Lorsqu'un programme doit effectuer des fonctions de niveau noyau telles que des opérations d'E/S ou une allocation de mémoire, il doit passer pardes appels systèmepour demander des services au noyau du système d'exploitation.
Le déroulement d'un appel système est le suivant : le programme utilisateur initie un appel système → le CPU passe en mode noyau → le noyau exécute le service correspondant → revient en mode utilisateur et poursuit l'exécution.
Vous pouvez considérer un appel système comme :Le programme utilisateur téléphone au système d'exploitation pour lui demander de faire quelque chose qu'il n'a pas la permission de faire.
Mécanisme d'appel système Linux
Dans les systèmes Linux 32 bits, un appel système s'effectue selon les étapes suivantes :
- Lenuméro d'appel système seraplacé dans le registre EAX.
- Placer les paramètres dans des registres tels que EBX, ECX, EDX, ESI, EDI
- Execute
int 0x80L'instruction déclenche une interruption logicielle - Le CPU passe en mode noyau, et le noyau exécute le service correspondant en fonction du numéro d'appel dans EAX.
- Le noyau place la valeur de retour dans EAX, repasse en mode utilisateur et poursuit l'exécution.
Aperçu des appels système courants
| Appel système | Numéro d'appel (EAX) | Fonction | Parameters |
|---|---|---|---|
| sys_exit | 1 | Quitter le programme | EBX = valeur de retour (code de sortie) |
| sys_fork | 2 | Créer un processus enfant | Aucun paramètre |
| sys_read | 3 | Lire un fichier/une entrée | EBX=fd, ECX=buf, EDX=count |
| sys_write | 4 | Écrire dans un fichier/une sortie | EBX=fd, ECX=buf, EDX=count |
| sys_open | 5 | Ouvrir un fichier | EBX=filename, ECX=flags, EDX=mode |
| sys_close | 6 | Fermer le fichier | EBX=fd |
| sys_creat | 8 | Créer un fichier | EBX=filename, ECX=mode |
| sys_lseek | 19 | Déplacer le pointeur de fichier | EBX=fd, ECX=offset, EDX=whence |
| sys_brk | 45 | Ajuster la taille du segment de données (allocation mémoire) | EBX = nouvelle adresse |
La liste complète des appels système se trouve dans
/usr/include/asm/unistd_32.hConsultez-la à cet endroit. Notez que les numéros d'appel système 32 bits et 64 bits sont différents.
sys_write - écrire une chaîne
L'appel système le plus couramment utilisé, servant à afficher du contenu à l'écran :
Exemple
; Utiliser sys_write pour afficher une chaîne
section .data
msg db 'Hello, example! Welcome to assembly.', 0xA
len equ $ - msg
section .text
global _start
_start:
; Appeler sys_write (4)
mov eax, 4 ; Numéro d'appel système 4 = sys_write
mov ebx, 1 ; Descripteur de fichier 1 = stdout (sortie standard)
mov ecx, msg ; Adresse des données à afficher
mov edx, len ; Longueur des données (octets)
int 0x80 ; Déclencher l'appel système
; En cas de succès, EAX renvoie le nombre réel d'octets écrits
; Quitter le programme
mov eax, 1
mov ebx, 0
int 0x80
Sortie :
$ nasm -f elf32 write_syscall.asm -o write_syscall.o $ ld -m elf_i386 write_syscall.o -o write_syscall $ ./write_syscall Hello, example! Welcome to assembly.
sys_read - lire l'entrée utilisateur
Lire des données depuis l'entrée standard (clavier) :
Exemple
; Utiliser sys_read pour lire l'entrée utilisateur et l'afficher en écho
section .bss
buffer resb 64 ; Réserver un tampon d'entrée de 64-byte
section .data
prompt db 'Veuillez saisir votre nom : '
prompt_len equ $ - prompt
output_msg db 'Bonjour, '
output_msg_len equ $ - output_msg
section .text
global _start
_start:
; Afficher le message d'invite
mov eax, 4
mov ebx, 1
mov ecx, prompt
mov edx, prompt_len
int 0x80
; Lire l'entrée utilisateur
mov eax, 3 ; Numéro d'appel système 3 = sys_read
mov ebx, 0 ; Descripteur de fichier 0 = stdin (entrée standard)
mov ecx, buffer ; Adresse du tampon d'entrée
mov edx, 64 ; Lire au maximum 64 octets
int 0x80
; EAX renvoie le nombre réel d'octets lus (y compris le retour à la ligne final)
mov esi, eax ; Sauvegarder la longueur réelle de l'entrée dans esi
; Afficher "Hello, "
mov eax, 4
mov ebx, 1
mov ecx, output_msg
mov edx, output_msg_len
int 0x80
; Afficher le contenu saisi par l'utilisateur
mov eax, 4
mov ebx, 1
mov ecx, buffer
mov edx, esi ; Utiliser le nombre réel d'octets saisis
int 0x80
; Quitter le programme
mov eax, 1
mov ebx, 0
int 0x80
Résultat de l'exécution:
$ 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: example Hello, example
sys_exit - quitter le programme
Chaque programme doit appeler sys_exit pour se terminer normalement ; sinon, le CPU continuera d'exécuter les données parasites suivantes, provoquant une erreur de segmentation.
Exemple
mov eax, 1 ; Numéro d'appel système 1 = sys_exit
mov ebx, 0 ; Code de sortie 0 = sortie normale (une valeur non nulle est également autorisée)
int 0x80
Le code de sortie peut être vérifié dans le shell via$?Vue :
$ ./program $ echo $? 0
Modèle générique d'appel système
Lorsque vous écrivez des appels système, vous pouvez suivre le modèle général suivant :
Exemple
; Applicable aux systèmes Linux 32 bits
; Étape 1 : Placez le numéro d'appel système dans EAX
mov eax,Numéro d'appel système
; Étape 2 : Placez les arguments dans l'ordre
mov ebx,N°1argument(s)
mov ecx,N°2argument(s)
mov edx,Nombre d'3argument(s)
mov esi,Nombre d'4argument(s)
mov edi,Nombre d'5argument(s)
; Étape 3 : Déclencher l'appel système
int 0x80
; Étape 4 : Vérifier la valeur de retour (dans EAX)
; Une valeur négative indique généralement une erreur
cmp eax, 0
jl error_handler ; Si EAX < 0, sauter vers la gestion des erreurs
Autres extensions
int 0x80Après le déclenchement, EAX contient la valeur de retour. La plupart des appels système renvoient une valeur non négative en cas de succès, et un code d'erreur négatif en cas d'échec (par ex., -1 indique EPERM).