Systemaufrufe

In diesem Kapitel werden wir uns mit Systemaufrufen unter Linux beschäftigen. Insbesondere werden wir:

Eine Einführung in Linux-Systemaufrufe geben, Grundlegende Systemaufrufe wie exit, read, write, open und close kennenlernen und Erklären, wie Parameter übergeben und Rückgabewerte entgegengenommen werden.

Einführung in Linux-Systemaufrufe

Systemaufrufe sind Schnittstellen, die es Programmen ermöglichen, Dienste und Funktionen des Betriebssystems in Anspruch zu nehmen. Diese können niedrigere Eingabe-/Ausgabe-Funktionen, Prozesssteuerung, Speicherverwaltung und mehr umfassen. In ARM64-Assembler verwenden wir den svc-Befehl, um Systemaufrufe auszuführen. Dabei tragen wir die Nummer des spezifischen Systemaufrufs in Register x8 ein und die Parameter in Registers x0 bis x5.

Grundlegende Systemaufrufe

exit

Dieser Systemaufruf beendet das Programm.

Syntax:

mov x8, #93   // syscall number for exit
mov x0, #0    // exit code (0 for success)
svc 0

read

Dieser Systemaufruf liest Daten von einer Datei.

Syntax:

mov x8, #63           // syscall number for read
mov x0, #file_desc    // file descriptor (0 for stdin)
mov x1, #buffer       // buffer to store the read data
mov x2, #size         // number of bytes to read
svc 0

write

Dieser Systemaufruf schreibt Daten in eine Datei.

Syntax:

mov x8, #64           // syscall number for write
mov x0, #file_desc    // file descriptor (1 for stdout)
mov x1, #buffer       // buffer with data to write
mov x2, #size         // number of bytes to write
svc 0

open

Dieser Systemaufruf öffnet eine Datei und gibt einen Datei-Deskriptor zurück.

Syntax:

mov x8, #56           // syscall number for openat
mov x0, #-100         // AT_FDCWD (current working directory)
mov x1, #filename     // pointer to the filename string
mov x2, #flags        // flags (e.g., O_RDONLY for read only)
svc 0

close

Dieser Systemaufruf schließt eine Datei.

Syntax:

mov x8, #57           // syscall number for close
mov x0, #file_desc    // file descriptor
svc 0

Übergabe von Parametern und Entgegennahme von Rückgabewerten

Die Übergabe von Parametern erfolgt über bestimmte Register:

• x0 bis x5 für die ersten sechs Argumente
• x8 für die Systemaufrufnummer

Rückgabewerte werden in x0 zurückgegeben.

Beispiel:

.global _start

.section .data
hello_msg: .asciz "Hello, World!\n"

_start:
    // write system call
    mov x0, #1         // file descriptor (1 for stdout)
    ldr x1, =hello_msg // buffer
    mov x2, #13        // size
    mov x8, #64        // syscall number for write
    svc 0

    // exit system call
    mov x0, #0         // exit code
    mov x8, #93        // syscall number for exit
    svc 0

In diesem Beispiel wird die Zeichenkette "Hello, World!\n" auf die Standardausgabe geschrieben und danach das Programm mit dem Rückgabewert 0 beendet.

Verweis auf alle verfügbaren Linux-Systemaufrufe

Eine vollständige Liste der verfügbaren Linux-Systemaufrufe und deren Nummern finden Sie in den entsprechenden Header-Dateien des Systems, wie z.B. in /usr/include/asm/unistd.h oder online in den offiziellen Linux-Kernel-Dokumentationen.

Eine häufig verwendete Referenz für Systemaufrufe ist die Man-Seite (man 2 syscall). Eine umfassendere Liste spezifisch für den ARM64-Architektur habe ich hier erstellt: Übersicht der Linux ARM64 Systemaufrufen

Fehlercodes

Wenn ein Systemcall ausgeführt wird (z. B. write, open, read), prüft der Kernel, ob die Anfrage gültig ist, und führt sie aus – oder gibt einen Fehlercode zurück, wenn etwas schiefgeht.

Viele Systemcalls geben in x0 ein Ergebnis wie zum Beispiel die Anzahl von Bytes, ein Dateideskriptor, PID oder anderes zurück, wenn alles geklappt hat. Sollte allerdings ein negatives Ergebnis (errno) zurück kommen, so hat in der Regel etwas nicht funktioniert.

Beispiel:

    // Datei öffnen (openat)
    mov     x0,  AT_FDCWD        // aktuelles Verzeichnis
    ldr     x1,  =filename       // Dateiname
    mov     x2,  #0              // O_RDONLY
    mov     x8,  #56             // syscall number für openat
    svc     #0

    // Rückgabewert ist jetzt in x0
    cmp     x0, #0
    b.ge    open_success         // x0 >= 0 → Erfolg

    // Fehlerbehandlung
    neg     x1, x0               // Fehlercode positiv machen
    // Jetzt enthält x1 z.B. 2 → ENOENT (Datei nicht gefunden)

open_success:
    // normal weiter...

Übersicht der Fehlercodes

Strukturen bei Systemcalls

einige Systemcalls in Linux (auch auf ARM64) erwarten Strukturen als Argumente – also zusammengesetzte Daten, die im Speicher bereitgestellt werden müssen und dann per Zeiger übergeben werden.

Strukturen an Systemcalls übergeben (ARM64/Linux)

Einige Systemcalls (z. B. stat, gettimeofday, timespec, uname, poll, etc.) brauchen als Argument einen Zeiger auf eine Struktur, die im Speicher angelegt ist.

Auf folgendes ist zu achten:

• Speicher für die Struktur bereitstellen (z. B. über .skip oder .space)
• Die Struktur ggf. initialisieren (z. B. Null setzen oder Werte eintragen)
• Den Zeiger zur Struktur ins richtige Register laden (z. B. x1)

Beispiel 1: uname-Systemcall

Dieser Systemcall füllt eine struct utsname mit Informationen über das System (wie uname -a in der Shell).

// C-Definition:
struct utsname {
    char sysname[65];
    char nodename[65];
    char release[65];
    char version[65];
    char machine[65];
    char domainname[65]; // oft ignoriert
};

Gesamtgröße: mindestens 390 Bytes

Assembler-Beispiel: uname aufrufen und sysname (z. B. „Linux“) ausgeben

.section .bss
utsbuf:     .skip 390             // Speicher für struct utsname
outbuf:     .skip 65              // Puffer zum Ausgeben von sysname

.section .text
.global _start

_start:
    // Systemcall: uname(struct utsname *buf)
    // syscall number: 160

    ldr     x0, =utsbuf           // Zeiger auf struct utsname
    mov     x8, #160              // syscall number
    svc     #0

    // Rückgabewert in x0: 0 bei Erfolg, sonst -errno
    cmp     x0, #0
    b.ne    uname_fail

    // Jetzt sysname (erstes Feld der Struktur) ausgeben:
    // Es ist eine nullterminierte Zeichenkette

    ldr     x1, =utsbuf           // sysname ist am Anfang
    bl      print_string

    b       done

uname_fail:
    // Fehlerausgabe (optional)
    ldr     x1, =failmsg
    bl      print_string

done:
    // exit(0)
    mov     x0, #0
    mov     x8, #93
    svc     #0

// Ausgabe-Funktion (x1 = Zeiger auf 0-terminierten String)
print_string:
    mov     x2, #0
count_loop:
    ldrb    w3, [x1, x2]
    cbz     w3, print_now
    add     x2, x2, #1
    b       count_loop
print_now:
    mov     x0, #1          // stdout
    mov     x8, #64         // write
    svc     #0
    ret

.section .data
failmsg: .asciz "uname failed\n"

Kompilieren & Ausführen

as -o uname.o uname.s
ld -o uname uname.o
./uname

Erwartete Ausgabe:

Linux

Weitere Beispiele für strukturbasierte Syscalls

Systemcall	Struktur	Zweck
uname	struct utsname	Systeminfo
statx	struct statx	Dateiinformation
gettimeofday	struct timeval	aktuelle Uhrzeit
nanosleep	struct timespec	schlafen für Zeitspanne
poll	struct pollfd	Warten auf Dateideskriptor

Beispiel 2: nanosleep mit struct timespec

// struct timespec {
    long tv_sec;        // ganze Sekunden
    long tv_nsec;       // Nanosekunden
// };

Schlafen für 2 Sekunden:

.section .data
timespec:
    .quad 2             // tv_sec = 2
    .quad 0             // tv_nsec = 0

.section .text
.global _start

_start:
    ldr     x0, =timespec     // Zeiger auf timespec
    mov     x1, #0            // NULL für "remaining"
    mov     x8, #101          // syscall: nanosleep
    svc     #0

    // done
    mov     x0, #0
    mov     x8, #93
    svc     #0

Arbeiten mit Dateien

Siehe hier auch das Incude an: https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/fcntl.h

Datei öffnen

 mov x0,#-100
 ldr x1,=Dateiname
 mov x2,#flags //O_RDONLY, O_WRONLY, =O_CREAT
 mov x3,#666
 mov x8,#323 //#define __NR_openat		323
 svc 0
//Rückgabe in x0 ->
 adds x10,XZR,x0 //file descriptor nach x10
 bpl ok //Wenn positiv, dann hat es geklappt
 // Fehler...

Datei schließen

 mov x0,x10  //Beispiel x10 für file descriptor
 mov x8,#118 //#define __NR_fsync		118
 svc 0
 mov x0,x10  //Beispiel x10 für file descriptor
 mov x8,#6   //#define __NR_close		  6
 svc 0

Lesen aus einer Datei

 mov x0,x10     //Beispiel x10 für file descriptor
 ldr x1,=buffer //Hierhin sollen die Daten geladen werden
 mov x2,#256    //Max Anzahl an Bytes, die geladen werden sollen (Beispiel: 256Bytes)
 mov x8,#3      //#define __NR_read		  3
 svc 0

Speichern in eine Datei

 mov x0,x10     //Beispiel x10 für file descriptor
 ldr x1,=buffer //Von hier sollen die Daten gespeichert werden
 mov x2,#256    //Anzahl an Bytes, die gespeichert werden sollen (Beispiel: 256Bytes)
 mov x8,#4      //#define __NR_write		  4
 svc 0

Beispiel

Ein Beispiel das zeigt, wie Sie eine Datei öffnen, die Daten lesen, bearbeiten und anschließend die bearbeiteten Daten in einer anderen Datei speichern können. Ich werde dafür Systemaufrufe (syscalls) verwenden.

• Überblick der Schritte:

1. Datei öffnen (open).
2. Daten aus der Datei lesen (read).
3. Daten bearbeiten (In diesem Beispiel ändern wir die Daten nicht, sie könnten aber leicht modifiziert werden).
4. Neue Datei erstellen und öffnen (open).
5. Daten in die neue Datei schreiben (write).
6. Beide Dateien schließen (close).

• Vollständiges Beispiel in ARM64-Assembler:

.section .data
    filename:   .asciz "input.txt"
    newfilename:.asciz "output.txt"
    buffer:     .space 1024  // Pufferspeicher zum Lesen der Datei

.section .bss
    .lcomm result, 4    // Speicher für den Rückgabewert von syscalls

.section .text
.global _start
_start:
    // Datei öffnen (input.txt)
    mov     x0, 0         // stdin als File Descriptor (0)
    ldr     x1, =filename // filename in x1 laden
    mov     x2, 0         // O_RDONLY (0)
    mov     x8, 2         // Syscall-Nummer für 'open' ist 2
    svc     0             // Systemaufruf

    mov     x19, x0       // x0 enthält den File Descriptor
    ldr     x1, =buffer   // Speicheradresse des Puffers in x1 laden
    mov     x2, 1024      // Maximale Anzahl von Bytes zu lesen
    mov     x8, 63        // Syscall-Nummer für 'read' ist 63
    svc     0             // Systemaufruf

    // Ergebnis der gelesenen Bytes in x0 speichern
    mov     x20, x0

    // Datei zum Schreiben öffnen (output.txt)
    ldr     x1, =newfilename // filename in x1 laden
    mov     x2, 241          // O_WRONLY | O_CREAT | O_TRUNC (241)
    mov     x3, 0644         // Modus 0644 (rw-r--r--)
    mov     x8, 2            // Syscall-Nummer für 'open' (2)
    svc     0                // Systemaufruf

    mov     x21, x0          // File Descriptor für die Ausgabedatei

    // Daten in die neue Datei schreiben
    ldr     x1, =buffer      // Speicheradresse des Puffers in x1 laden
    mov     x2, x20          // Anzahl der gelesenen Bytes
    mov     x0, x21          // File Descriptor der Ausgabedatei
    mov     x8, 64           // Syscall-Nummer für 'write' (64)
    svc     0                // Systemaufruf

    // Eingabedatei schließen
    mov     x0, x19          // File Descriptor der Eingabedatei
    mov     x8, 57           // Syscall-Nummer für 'close' (57)
    svc     0                // Systemaufruf

    // Ausgabedatei schließen
    mov     x0, x21          // File Descriptor der Ausgabedatei
    mov     x8, 57           // Syscall-Nummer für 'close' (57)
    svc     0                // Systemaufruf

    // Beende das Programm
    mov     x8, 93           // Syscall-Nummer für 'exit' (93)
    mov     x0, 0            // Rückgabewert 0
    svc     0                // Systemaufruf

• Erklärung:

Datenabschnitt:

.section .data:

• filename: Speichert den Namen der Eingabedatei input.txt.
• newfilename: Speichert den Namen der Ausgabedatei output.txt.
• buffer: Ein Speicherbereich zum Lesen und Schreiben der Dateiinhalte.

.section .bss:

Speicher zur Speicherung des Rückgabewerts von read.

• Textabschnitt:

Datei öffnen (input.txt):

• mov x0, 0: Bereitet den Systemaufruf vor, um stdin als Dateideskriptor zu verwenden.
• ldr x1, =filename: Lädt die Adresse des Dateinamens in x1.
• mov x2, 0: Setzt den Modus auf O_RDONLY (nur lesen).
• mov x8, 2: Setzt die Systemaufrufnummer für open (2).
• svc 0: Führt den Systemaufruf aus. Der Dateideskriptor wird in x0 zurückgegeben und in x19 gespeichert.

Daten lesen:

• ldr x1, =buffer: Lädt die Adresse des Puffers in x1.
• mov x2, 1024: Gibt an, dass bis zu 1024 Bytes gelesen werden.
• mov x8, 63: Setzt die Systemaufrufnummer für read (63).
• svc 0: Führt den Systemaufruf aus. Die Anzahl der gelesenen Bytes wird in x0 zurückgegeben und in x20 gespeichert.

Datei öffnen (output.txt):

• ldr x1, =newfilename: Lädt die Adresse des neuen Dateinamens in x1.
• mov x2, 241: Setzt den Modus auf O_WRONLY | O_CREAT | O_TRUNC (schreiben, Datei erstellen, Datei kürzen).
• mov x3, 0644: Setzt die Dateiberechtigungen auf rw-r--r--.
• mov x8, 2: Setzt die Systemaufrufnummer für open (2).
• svc 0: Führt den Systemaufruf aus. Der Dateideskriptor wird in x0 zurückgegeben und in x21 gespeichert.

Daten schreiben:

• ldr x1, =buffer: Lädt die Adresse des Puffers in x1.
• mov x2, x20: Setzt die Anzahl der zu schreibenden Bytes auf die Anzahl der gelesenen Bytes.
• mov x0, x21: Setzt den Dateideskriptor auf die Ausgabedatei.
• mov x8, 64: Setzt die Systemaufrufnummer für write (64).
• svc 0: Führt den Systemaufruf aus.

Dateien schließen:

• mov x0, x19: Setzt den Dateideskriptor auf die Eingabedatei.
• mov x8, 57: Setzt die Systemaufrufnummer für close (57).
• svc 0: Führt den Systemaufruf aus.
• mov x0, x21: Setzt den Dateideskriptor auf die Ausgabedatei.
• mov x8, 57: Setzt die Systemaufrufnummer für close (57).
• svc 0: Führt den Systemaufruf aus.

Programm beenden:

• mov x8, 93: Setzt die Systemaufrufnummer für exit (93).
• mov x0, 0: Setzt den Rückgabewert auf 0.
• svc 0: Führt den Systemaufruf aus und beendet das Programm.

Dieses Beispiel demonstriert die wesentlichen Systemaufrufe und die Datenbearbeitung in einem ARM64-Assemblerprogramm unter Linux.