Assemblytaal en x86-programmeren voor systemen op laag niveau · Les

Linux-systeemaanroepen (syscalls)

Leer veelvoorkomende bewerkingen van het besturingssysteem uitvoeren, zoals bestands-I/O, procesbeheer en geheugentoewijzing, met Linux-systeemaanroepen.

Les 2 van 410 stappen

Linux-systeemaanroepen (syscalls) is een gratis Assemblytaal en x86-programmeren voor systemen op laag niveau-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Assemblytaal en x86-programmeren voor systemen op laag niveau. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Assemblytaal en x86-programmeren voor systemen op laag niveau bevat in totaal 4 lessen.

Wat zijn systeemaanroepen?

Welkom! In deze les duiken we in Linux-systeemaanroepen (syscalls). Dit is de fundamentele manier waarop programma's in de gebruikersruimte diensten van de kernel van het besturingssysteem aanvragen.

Je kunt ze zien als een speciale verzameling functies die je programma kan aanroepen om krachtige taken uit te voeren, zoals werken met bestanden, processen beheren of geheugen toewijzen.

Gebruikersmodus versus kernelmodus

Moderne besturingssystemen werken met verschillende privilegeniveaus. Doorgaans zijn er de gebruikersmodus (waarin je toepassingen worden uitgevoerd) en de kernelmodus (waarin de kern van het besturingssysteem wordt uitgevoerd).

Gebruikersmodus: beperkte toegang tot hardware en kritisch geheugen.
Kernelmodus: volledige toegang en veilig beheer van systeembronnen.

Systeemaanroepen zijn de gecontroleerde toegangspoort waarmee programma's in de gebruikersmodus tijdelijk naar de kernelmodus kunnen overschakelen en het besturingssysteem kunnen vragen namens hen bewerkingen met extra bevoegdheden uit te voeren.

Systeemaanroepen aanroepen in x86-64

Op x86-64 Linux worden systeemaanroepen voornamelijk uitgevoerd met de instructie syscall. Voordat je syscall aanroept, laad je specifieke registers met waarden:

RAX: bevat het nummer van de systeemaanroep.
RDI, RSI, RDX, R10, R8, R9: bevatten de argumenten van de systeemaanroep (maximaal 6).
De retourwaarde wordt teruggeplaatst in RAX.

Nummers van systeemaanroepen vinden

Hoe weet je welk nummer bij welke systeemaanroep hoort? Je kunt ze opzoeken!

Gebruik de opdracht man syscalls in je terminal.
Raadpleeg headerbestanden zoals /usr/include/asm/unistd_64.h.

Bijvoorbeeld: sys_write is systeemaanroep nummer 1 en sys_exit is nummer 60.

Elementaire bestands-I/O: sys_write

Een van de meest gebruikte systeemaanroepen is sys_write, die wordt gebruikt om gegevens naar een bestandsdescriptor te schrijven. De parameters zijn:

RDI: bestandsdescriptor (bijvoorbeeld 1 voor stdout).
RSI: pointer naar de buffer met de gegevens.
RDX: het aantal bytes dat moet worden geschreven.

Standaardbestandsdescriptors zijn 0 (stdin), 1 (stdout) en 2 (stderr).

Voorbeeld: Hallo, systeemaanroep!

We schrijven een eenvoudig programma dat met sys_write "Hallo, systeemaanroep!" naar de console afdrukt en vervolgens met sys_exit wordt beëindigd.

Probeer dit voorbeeld uit te voeren:

section .data
    msg db "Hello, Syscall!", 0xa ; Our string + newline
    len equ $ - msg             ; Length of our string

section .text
    global _start

_start:
    ; sys_write(fd=1, buf=msg, count=len)
    mov rax, 1      ; syscall number for sys_write
    mov rdi, 1      ; fd=1 (stdout)
    mov rsi, msg    ; buffer (our string)
    mov rdx, len    ; count (length of string)
    syscall         ; Invoke kernel

    ; sys_exit(status=0)
    mov rax, 60     ; syscall number for sys_exit
    mov rdi, 0      ; exit status 0
    syscall         ; Invoke kernel

Elementaire bestands-I/O: sys_read

Het tegenhanger van sys_write is sys_read, die gegevens uit een bestandsdescriptor in een buffer leest. De parameters zijn:

RDI: bestandsdescriptor (bijvoorbeeld 0 voor stdin).
RSI: pointer naar de buffer waarin de gegevens worden opgeslagen.
RDX: het maximale aantal bytes dat moet worden gelezen.

sys_read retourneert het aantal daadwerkelijk gelezen bytes of een foutcode.

Voorbeeld: invoer terugsturen

Dit programma leest maximaal 256 bytes uit de standaardinvoer (stdin) en schrijft vervolgens alles wat het heeft gelezen terug naar de standaarduitvoer (stdout).

Probeer dit voorbeeld uit te voeren:

section .bss
    buffer resb 256 ; A buffer to store input

section .text
    global _start

_start:
    ; sys_read(fd=0, buf=buffer, count=256)
    mov rax, 0      ; syscall number for sys_read
    mov rdi, 0      ; fd=0 (stdin)
    mov rsi, buffer ; buffer to store input
    mov rdx, 256    ; max bytes to read
    syscall         ; Invoke kernel
    mov rbp, rax    ; Store bytes read in rbp

    ; sys_write(fd=1, buf=buffer, count=rbp)
    mov rax, 1      ; syscall number for sys_write
    mov rdi, 1      ; fd=1 (stdout)
    mov rsi, buffer ; buffer (our read input)
    mov rdx, rbp    ; count (actual bytes read)
    syscall         ; Invoke kernel

    ; sys_exit(status=0)
    mov rax, 60     ; syscall number for sys_exit
    mov rdi, 0      ; exit status 0
    syscall         ; Invoke kernel

Controle van systeemaanroepargumenten

Laten we snel controleren of je begrijpt hoe argumenten worden doorgegeven bij x86-64 Linux-systeemaanroepen.

Beantwoord dit in de interactieve les

Samenvatting: Linux-systeemaanroepen

Je hebt de basis van Linux-systeemaanroepen geleerd!

Syscalls zijn de manier waarop gebruikersprogramma's diensten van de kernel aanvragen.
De instructie syscall (x86-64) start de aanroep.
RAX bevat het nummer van de systeemaanroep en RDI-R9 bevatten de argumenten.
We hebben sys_write (naar stdout), sys_read (van stdin) en sys_exit behandeld.

Het beheersen van systeemaanroepen is essentieel om programmeren in Linux op laag niveau en de interactie met het besturingssysteem te begrijpen.

Gratis beginnen

Leer Assembly met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Linux-systeemaanroepen (syscalls)” gratis?

Ja — de volledige tekst van “Linux-systeemaanroepen (syscalls)” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Assemblytaal en x86-programmeren voor systemen op laag niveau wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Assemblytaal en x86-programmeren voor systemen op laag niveau bevat in totaal 4 lessen.

Wat leer ik in “Linux-systeemaanroepen (syscalls)”?

Leer veelvoorkomende bewerkingen van het besturingssysteem uitvoeren, zoals bestands-I/O, procesbeheer en geheugentoewijzing, met Linux-systeemaanroepen. Je oefent met Assemblytaal en x86-programmeren voor systemen op laag niveau door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Assemblytaal en x86-programmeren voor systemen op laag niveau te beginnen?

Ervaring vooraf is niet nodig. Assemblytaal en x86-programmeren voor systemen op laag niveau op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Linux-systeemaanroepen (syscalls)”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Assemblytaal en x86-programmeren voor systemen op laag niveau?

Ja. Elke les over Assemblytaal en x86-programmeren voor systemen op laag niveau bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Concepten van virtueel geheugen
Linux-systeemaanroepen (syscalls)
Interactie met de Windows API
Dynamisch geheugen: heapallocatie in assembly

← Terug naar Assemblytaal en x86-programmeren voor systemen op laag niveau