Systemaufrufe - Versionsgeschichte

Satyria: /* Arbeiten mit Dateien */

2025-04-10T06:30:55Z

Arbeiten mit Dateien

Änderungen zeigen

Satyria am 9. April 2025 um 08:45 Uhr

2025-04-09T08:45:55Z

Änderungen zeigen

Satyria am 9. April 2025 um 08:32 Uhr

2025-04-09T08:32:45Z

← Nächstältere Version		Version vom 9. April 2025, 09:32 Uhr
Zeile 138:		Zeile 138:

	== Strukturen bei Systemcalls ==		== Strukturen bei Systemcalls ==
	einige Systemcalls in Linux (auch auf ARM64) erwarten Strukturen als Argumente – also zusammengesetzte Daten, die du im Speicher ~~bereitstellen musst~~ und dann per Zeiger ~~übergibst. Das ist für Einsteiger oft ein Aha-Moment im Assembler~~.		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) ===

	~~📦 Strukturen an Systemcalls übergeben (ARM64/Linux) – Anleitung für Anfänger~~
	~~🧠 Grundidee~~
	Einige Systemcalls (z. B. stat, gettimeofday, timespec, uname, poll, etc.) brauchen als Argument einen Zeiger auf eine Struktur, die im Speicher angelegt ist.		Einige Systemcalls (z. B. stat, gettimeofday, timespec, uname, poll, etc.) brauchen als Argument einen Zeiger auf eine Struktur, die im Speicher angelegt ist.

	~~Du musst~~:		Auf folgendes ist zu achten:
			* Speicher für die Struktur bereitstellen (z. B. über .skip oder .space)
	~~Den~~ 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)
	Die Struktur ggf. initialisieren (z. B. Null setzen oder Werte eintragen)

	Den Zeiger zur Struktur ins richtige Register laden (z. B. x1)

	~~Den passenden Systemcall ausführen (svc #0~~)

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

	c		<syntaxhighlight lang="C">
	~~Kopieren~~
	~~Bearbeiten~~
	// C-Definition:		// C-Definition:
	struct utsname {		struct utsname {
Zeile 169:		Zeile 162:
	char domainname[65]; // oft ignoriert		char domainname[65]; // oft ignoriert
	};		};
			</syntaxhighlight>
	Gesamtgröße: mindestens 390 Bytes		Gesamtgröße: mindestens 390 Bytes

	💻 Assembler-Beispiel: uname aufrufen und sysname (z. B. „Linux“) ausgeben		Assembler-Beispiel: uname aufrufen und sysname (z. B. „Linux“) ausgeben
	asm		<syntaxhighlight lang="asm">
	~~Kopieren~~
	~~Bearbeiten~~
	.section .bss		.section .bss
	utsbuf: .skip 390 // Speicher für struct utsname		utsbuf: .skip 390 // Speicher für struct utsname
Zeile 229:		Zeile 221:
	.section .data		.section .data
	failmsg: .asciz "uname failed\n"		failmsg: .asciz "uname failed\n"
	🧪 Kompilieren & Ausführen		</syntaxhighlight>
	~~bash~~
	~~Kopieren~~		Kompilieren & Ausführen
	~~Bearbeiten~~		<syntaxhighlight lang="shell">
	as -o uname.o uname.s		as -o uname.o uname.s
	ld -o uname uname.o		ld -o uname uname.o
	./uname		./uname
			</syntaxhighlight>
	Erwartete Ausgabe:		Erwartete Ausgabe:
			<syntaxhighlight lang="shell">
			Linux
			</syntaxhighlight>
			=== Weitere Beispiele für strukturbasierte Syscalls ===
			{\| class="wikitable"
			\|-
			! 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
			\|}

	~~bash~~		=== Beispiel 2: nanosleep mit struct timespec ===
	~~Kopieren~~		<syntaxhighlight lang="C">
	~~Bearbeiten~~
	~~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
	c
	~~Kopieren~~
	~~Bearbeiten~~
	// struct timespec {		// struct timespec {
	long tv_sec; // ganze Sekunden		long tv_sec; // ganze Sekunden
	long tv_nsec; // Nanosekunden		long tv_nsec; // Nanosekunden
	// };		// };
	⏱ Schlafen für 2 Sekunden:		</syntaxhighlight>
	asm		Schlafen für 2 Sekunden:
	~~Kopieren~~		<syntaxhighlight lang="asm">
	~~Bearbeiten~~
	.section .data		.section .data
	timespec:		timespec:
Zeile 279:		Zeile 276:
	mov x8, #93		mov x8, #93
	svc #0		svc #0
			</syntaxhighlight>

	== Arbeiten mit Dateien ==		== Arbeiten mit Dateien ==

Satyria: /* Fehlercodes */

2025-04-08T18:12:23Z

Fehlercodes

Änderungen zeigen

Satyria: /* Verweis auf alle verfügbaren Linux-Systemaufrufe */

2025-04-08T17:58:07Z

Verweis auf alle verfügbaren Linux-Systemaufrufe

← Nächstältere Version		Version vom 8. April 2025, 18:58 Uhr
Zeile 109:		Zeile 109:
	Eine häufig verwendete Referenz für Systemaufrufe ist die Man-Seite ([https://man7.org/linux/man-pages/man2/syscalls.2.html man 2 syscall]). Eine umfassendere Liste spezifisch für den ARM64-Architektur habe ich hier erstellt: [[Übersicht der Linux ARM64 Systemaufrufen]]		Eine häufig verwendete Referenz für Systemaufrufe ist die Man-Seite ([https://man7.org/linux/man-pages/man2/syscalls.2.html 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:
			<syntaxhighlight lang="asm">
			// 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...
			</syntaxhighlight>

			[[Übersicht der Fehlercodes]]


			Der Fehlercode wird in x0 als negativer Wert zurückgegeben, wenn es einer gab.

			Manche Systemaufrufe erzeugen einen Fehlercode
	-------------------		-------------------

Satyria am 8. April 2025 um 07:58 Uhr

2025-04-08T07:58:20Z

← Nächstältere Version		Version vom 8. April 2025, 08:58 Uhr
Zeile 287:		Zeile 287:
	svc 0: Führt den Systemaufruf aus und beendet das Programm.		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.		Dieses Beispiel demonstriert die wesentlichen Systemaufrufe und die Datenbearbeitung in einem ARM64-Assemblerprogramm unter Linux.


			== Linux Systemaufrufe ==
			https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/unistd.h
			https://github.com/ilbers/linux/blob/master/arch/sh/include/uapi/asm/unistd_64.h

			x0–x7: Parameterübergabe
			x8: SystemCallNummer
			svc 0 -> Aufruf des Systemcalls
			x0: Ergebniss

			Wenn x0 negativ -> negieren -> dann Fehler:
			https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/errno.h
			https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/errno-base.h

			In der Parameterübergabe erwarten viele SystemCalls eine Struktur. Ein einfacher SystemCall wie nanosleep wird als C-Code wie folgt aufgerufen:
			int nanosleep(const struct timespec req, struct timespec rem);
			Dieser Aufruf erwartet jeweils eine Struktur "timespec", die in x0 und x1 übergeben wird.
			Diese Struktur ist wie folgt definiert:
			struct timespec {
			time_t tv_sec; /* seconds */
			long tv_nsec; /* nanoseconds */
			};
			Nach Assembler:
			timespec:
			timespec_tv_sec: .dword 0
			timespec_tv_nsec: .dword 100000000
			Um es der Funktion zu übergeben:
			ldr x0,=timespec
			ldr x1,=timespec

Satyria: /* Verweis auf alle verfügbaren Linux-Systemaufrufe */

2025-04-07T12:03:42Z

Verweis auf alle verfügbaren Linux-Systemaufrufe

Änderungen zeigen

Satyria am 7. April 2025 um 05:52 Uhr

2025-04-07T05:52:10Z

← Nächstältere Version		Version vom 7. April 2025, 06:52 Uhr
Zeile 1:		Zeile 1:
	~~Systemaufrufe~~

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

Zeile 6:		Zeile 4:
	Grundlegende Systemaufrufe wie exit, read, write, open und close kennenlernen und		Grundlegende Systemaufrufe wie exit, read, write, open und close kennenlernen und
	Erklären, wie Parameter übergeben und Rückgabewerte entgegengenommen werden.		Erklären, wie Parameter übergeben und Rückgabewerte entgegengenommen werden.
	Einführung in Linux-Systemaufrufe		== 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.		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		== Grundlegende Systemaufrufe ==

	exit		=== exit ===

	Dieser Systemaufruf beendet das Programm.		Dieser Systemaufruf beendet das Programm.

	Syntax:		Syntax:
			<syntaxhighlight lang="asm">
	mov x8, #93 // syscall number for exit		mov x8, #93 // syscall number for exit
	mov x0, #0 // exit code (0 for success)		mov x0, #0 // exit code (0 for success)
	svc 0		svc 0
			</syntaxhighlight>

			=== read ===
	read

	Dieser Systemaufruf liest Daten von einer Datei.		Dieser Systemaufruf liest Daten von einer Datei.

	Syntax:		Syntax:
			<syntaxhighlight lang="asm">
	mov x8, #63 // syscall number for read		mov x8, #63 // syscall number for read
	mov x0, #file_desc // file descriptor (0 for stdin)		mov x0, #file_desc // file descriptor (0 for stdin)
Zeile 34:		Zeile 32:
	mov x2, #size // number of bytes to read		mov x2, #size // number of bytes to read
	svc 0		svc 0
			</syntaxhighlight>

			=== write ===
	write

	Dieser Systemaufruf schreibt Daten in eine Datei.		Dieser Systemaufruf schreibt Daten in eine Datei.

	Syntax:		Syntax:
			<syntaxhighlight lang="asm">
	mov x8, #64 // syscall number for write		mov x8, #64 // syscall number for write
	mov x0, #file_desc // file descriptor (1 for stdout)		mov x0, #file_desc // file descriptor (1 for stdout)
Zeile 47:		Zeile 45:
	mov x2, #size // number of bytes to write		mov x2, #size // number of bytes to write
	svc 0		svc 0
			</syntaxhighlight>

			=== open ===
	open

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

	Syntax:		Syntax:
			<syntaxhighlight lang="asm">
	mov x8, #56 // syscall number for openat		mov x8, #56 // syscall number for openat
	mov x0, #-100 // AT_FDCWD (current working directory)		mov x0, #-100 // AT_FDCWD (current working directory)
Zeile 60:		Zeile 58:
	mov x2, #flags // flags (e.g., O_RDONLY for read only)		mov x2, #flags // flags (e.g., O_RDONLY for read only)
	svc 0		svc 0
			</syntaxhighlight>

			=== close ===
	close

	Dieser Systemaufruf schließt eine Datei.		Dieser Systemaufruf schließt eine Datei.

	Syntax:		Syntax:
			<syntaxhighlight lang="asm">
	mov x8, #57 // syscall number for close		mov x8, #57 // syscall number for close
	mov x0, #file_desc // file descriptor		mov x0, #file_desc // file descriptor
	svc 0		svc 0
			</syntaxhighlight>

	Übergabe von Parametern und Entgegennahme von Rückgabewerten		== Übergabe von Parametern und Entgegennahme von Rückgabewerten ==

	Die Übergabe von Parametern erfolgt über bestimmte Register:		Die Übergabe von Parametern erfolgt über bestimmte Register:

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

	Rückgabewerte werden in x0 zurückgegeben.		Rückgabewerte werden in x0 zurückgegeben.

	Beispiel:		Beispiel:
			<syntaxhighlight lang="asm">
	.global _start		.global _start

Zeile 100:		Zeile 99:
	mov x8, #93 // syscall number for exit		mov x8, #93 // syscall number for exit
	svc 0		svc 0
			</syntaxhighlight>

	In diesem Beispiel wird die Zeichenkette "Hello, World!\n" auf die Standardausgabe geschrieben und danach das Programm mit dem Rückgabewert 0 beendet.		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		== 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 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 ([https://man7.org/linux/man-pages/man2/syscalls.2.html man 2 syscall]). Eine umfassendere Liste spezifisch für den ARM64-Architektur habe ich hier erstellt: [[Übersicht der Linux ARM64 Systemaufrufen]]		Eine häufig verwendete Referenz für Systemaufrufe ist die Man-Seite ([https://man7.org/linux/man-pages/man2/syscalls.2.html man 2 syscall]). Eine umfassendere Liste spezifisch für den ARM64-Architektur habe ich hier erstellt: [[Übersicht der Linux ARM64 Systemaufrufen]]

	~~Mit diesen Grundlagen und Beispielen sollten Anfänger in der Lage sein, grundlegende Systemaufrufe im ARM64-Assembler zu verstehen und in ihren Programmen zu verwenden.~~

Satyria am 4. April 2025 um 12:05 Uhr

2025-04-04T12:05:59Z

← Nächstältere Version		Version vom 4. April 2025, 13:05 Uhr
Zeile 108:		Zeile 108:
	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 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]]		Eine häufig verwendete Referenz für Systemaufrufe ist die Man-Seite ([https://man7.org/linux/man-pages/man2/syscalls.2.html man 2 syscall]). Eine umfassendere Liste spezifisch für den ARM64-Architektur habe ich hier erstellt: [[Übersicht der Linux ARM64 Systemaufrufen]]

	Mit diesen Grundlagen und Beispielen sollten Anfänger in der Lage sein, grundlegende Systemaufrufe im ARM64-Assembler zu verstehen und in ihren Programmen zu verwenden.		Mit diesen Grundlagen und Beispielen sollten Anfänger in der Lage sein, grundlegende Systemaufrufe im ARM64-Assembler zu verstehen und in ihren Programmen zu verwenden.

Satyria am 4. April 2025 um 12:04 Uhr

2025-04-04T12:04:53Z

← Nächstältere Version		Version vom 4. April 2025, 13:04 Uhr
Zeile 108:		Zeile 108:
	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 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 ~~finden Sie~~ hier~~. https~~:~~//chrome.google.com/webhp?ie=UTF-8&rct=j&sclient=psy-ab&q=linux+arm64+syscall+number+list&oq=linux+arm64+syscall+number+list&gs_l=serp~~		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]]

	Mit diesen Grundlagen und Beispielen sollten Anfänger in der Lage sein, grundlegende Systemaufrufe im ARM64-Assembler zu verstehen und in ihren Programmen zu verwenden.		Mit diesen Grundlagen und Beispielen sollten Anfänger in der Lage sein, grundlegende Systemaufrufe im ARM64-Assembler zu verstehen und in ihren Programmen zu verwenden.