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.

Linux 32位系统调用流程

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 :

  1. Lenuméro d'appel système seraplacé dans le registre EAX.
  2. Placer les paramètres dans des registres tels que EBX, ECX, EDX, ESI, EDI
  3. Executeint 0x80L'instruction déclenche une interruption logicielle
  4. Le CPU passe en mode noyau, et le noyau exécute le service correspondant en fonction du numéro d'appel dans EAX.
  5. 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èmeNuméro d'appel (EAX)FonctionParameters
sys_exit1Quitter le programmeEBX = valeur de retour (code de sortie)
sys_fork2Créer un processus enfantAucun paramètre
sys_read3Lire un fichier/une entréeEBX=fd, ECX=buf, EDX=count
sys_write4Écrire dans un fichier/une sortieEBX=fd, ECX=buf, EDX=count
sys_open5Ouvrir un fichierEBX=filename, ECX=flags, EDX=mode
sys_close6Fermer le fichierEBX=fd
sys_creat8Créer un fichierEBX=filename, ECX=mode
sys_lseek19Déplacer le pointeur de fichierEBX=fd, ECX=offset, EDX=whence
sys_brk45Ajuster 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

; Chemin du fichier : write_syscall.asm
; 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

; Chemin du fichier : read_syscall.asm
; 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

; Quitter avec différents codes de sortie

    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

; Modèle général pour les appels système
; 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

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

Autres extensions