Assembler och lågnivåprogrammering för x86-system · Lektion

Linux-systemanrop (syscalls)

Lär dig utföra vanliga operativsystemsåtgärder, som fil-I/O, processhantering och minnesallokering, med hjälp av Linux-systemanrop.

Lektion 2 av 410 steg

Linux-systemanrop (syscalls) är en gratis lektion i Assembler och lågnivåprogrammering för x86-system på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Assembler och lågnivåprogrammering för x86-system, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Assembler och lågnivåprogrammering för x86-system innehåller totalt 4 lektioner.

Vad är systemanrop?

Välkommen! I den här lektionen går vi igenom Linux-systemanrop (syscalls). De är det grundläggande sättet för program i användarutrymmet att begära tjänster från operativsystemets kärna.

Se dem som en särskild uppsättning funktioner som programmet kan anropa för att utföra kraftfulla åtgärder, till exempel interagera med filer, hantera processer eller allokera minne.

Användarläge kontra kärnläge

Moderna operativsystem körs på olika behörighetsnivåer. Vanligtvis finns användarläge (där dina program körs) och kärnläge (där operativsystemets kärna körs).

Användarläge: Begränsad åtkomst till hårdvara och kritiskt minne.
Kärnläge: Full åtkomst och säker hantering av systemresurser.

Systemanrop är den kontrollerade port som gör att program i användarläge tillfälligt kan växla till kärnläge och be operativsystemet utföra privilegierade åtgärder åt dem.

Anropa syscalls i x86-64

I x86-64 Linux anropas systemanrop huvudsakligen med instruktionen syscall. Innan syscall anropas laddar du specifika register med värden:

RAX: Innehåller systemanropsnumret.
RDI, RSI, RDX, R10, R8, R9: Innehåller systemanropets argument (upp till 6).
Returvärdet placeras tillbaka i RAX.

Hitta systemanropsnummer

Hur vet du vilket nummer som motsvarar vilket systemanrop? Du kan slå upp dem!

Använd kommandot man syscalls i terminalen.
Läs headerfiler som /usr/include/asm/unistd_64.h.

Exempelvis är sys_write systemanrop nummer 1, och sys_exit är nummer 60.

Grundläggande fil-I/O: sys_write

Ett av de vanligaste systemanropen är sys_write, som används för att skriva data till en filbeskrivare. Parametrarna är:

RDI: Filbeskrivare (till exempel 1 för stdout).
RSI: Pekare till bufferten som innehåller data.
RDX: Antalet byte som ska skrivas.

Standardfilbeskrivarna är 0 (stdin), 1 (stdout) och 2 (stderr).

Exempel: Hello, Syscall!

Vi ska skriva ett enkelt program som skriver ut "Hello, Syscall!" i konsolen med hjälp av sys_write och sedan avslutas med sys_exit.

Prova att köra det här exemplet:

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

Grundläggande fil-I/O: sys_read

Motsvarigheten till sys_write är sys_read, som läser data från en filbeskrivare till en buffert. Parametrarna är:

RDI: Filbeskrivare (till exempel 0 för stdin).
RSI: Pekare till bufferten där data ska lagras.
RDX: Maximalt antal byte som ska läsas.

sys_read returnerar antalet byte som faktiskt lästes eller en felkod.

Exempel: återge indata

Här är ett program som läser upp till 256 byte från standardindata (stdin) och sedan skriver tillbaka det som lästes till standardutdata (stdout).

Prova att köra det här exemplet:

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

Kontroll av systemanropsargument

Nu kontrollerar vi snabbt din förståelse av hur argument skickas vid systemanrop i x86-64 Linux.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Linux-systemanrop

Du har lärt dig grunderna i Linux-systemanrop!

Syscalls är sättet som användarprogram begär tjänster från kärnan.
Instruktionen syscall (x86-64) initierar anropet.
RAX innehåller systemanropsnumret och RDI-R9 innehåller argumenten.
Vi gick igenom sys_write (till stdout), sys_read (från stdin) och sys_exit.

Att behärska syscalls är viktigt för att förstå Linux-programmering på låg nivå och interaktionen med operativsystemet.

Gratis att börja

Lär dig Assembly med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Linux-systemanrop (syscalls)” gratis?

Ja – hela texten till ”Linux-systemanrop (syscalls)” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Assembler och lågnivåprogrammering för x86-system, kan Ni uppgradera till CoddyKit PRO. Kursen i Assembler och lågnivåprogrammering för x86-system innehåller totalt 4 lektioner.

Vad lär jag mig i ”Linux-systemanrop (syscalls)”?

Lär dig utföra vanliga operativsystemsåtgärder, som fil-I/O, processhantering och minnesallokering, med hjälp av Linux-systemanrop. Ni övar på Assembler och lågnivåprogrammering för x86-system med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Assembler och lågnivåprogrammering för x86-system?

Du behöver inga förkunskaper. Utbildningen i Assembler och lågnivåprogrammering för x86-system på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Linux-systemanrop (syscalls)”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Assembler och lågnivåprogrammering för x86-system-lektionen?

Ja. Varje Assembler och lågnivåprogrammering för x86-system-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Begrepp inom virtuellt minne
Linux-systemanrop (syscalls)
Interaktion med Windows API
Dynamiskt minne: heapallokering i assembler

← Tillbaka till Assembler och lågnivåprogrammering för x86-system