Assemblersprache - Dateiverwaltung
Die Dateiverwaltung ist die Grundlage für Programme zur Interaktion mit externem Speicher.
Durch Systemaufrufe können Assemblerprogramme Dateien öffnen, lesen, schreiben und schließen sowie Datei-E/A ebenso flexibel wie höhere Programmiersprachen handhaben.
Übersicht über den Dateivorgangsprozess
Dateivorgänge folgen dem grundlegenden Ablauf von Öffnen → Lesen/Schreiben → Schließen sowie drei Standard-Dateidescriptoren:
Systemaufrufe im Zusammenhang mit Dateivorgängen
| Systemaufruf | Aufrufnummer | Zweck | Wichtigste Parameter |
|---|---|---|---|
| sys_open | 5 | Datei öffnen/erstellen | EBX=Dateiname, ECX=Flags, EDX=Berechtigungen |
| sys_read | 3 | Datei lesen | EBX=fd, ECX=Puffer, EDX=Byte-Anzahl |
| sys_write | 4 | Datei schreiben | EBX=fd, ECX=Puffer, EDX=Byte-Anzahl |
| sys_close | 6 | Datei schließen | EBX=fd |
| sys_creat | 8 | Datei erstellen (veraltet) | EBX=Dateiname, ECX=Berechtigungen |
| sys_lseek | 19 | Dateizeiger bewegen | EBX=fd, ECX=offset, EDX=origin |
| sys_unlink | 10 | Datei löschen | EBX=filename |
Dateifrag-Flags
| Konstante | Wert | Beschreibung |
|---|---|---|
| O_RDONLY | 0 | Nur Lesen |
| O_WRONLY | 1 | Nur Schreiben |
| O_RDWR | 2 | Lesen und Schreiben |
| O_CREAT | 64(0x40) | Erstellen, falls die Datei nicht existiert |
| O_TRUNC | 512(0x200) | Datei beim Öffnen auf Länge 0 kürzen |
| O_APPEND | 1024(0x400) | An das Ende der Datei anhängen |
Mehrere Flags werden mit OR kombiniert, zum Beispiel:O_WRONLY | O_CREAT | O_TRUNC = 1 | 64 | 512 = 577
Datei erstellen und in sie schreiben
Beispiel
; Eine Datei erstellen und Inhalt hineinschreiben
section .data
filename db 'example_output.txt', 0 ; Dateiname (nullterminiert)
content db 'Hello, EXAMPLE!', 0xA ; Zu schreibender Inhalt
content_len equ $ - content
create_msg db 'File created successfully!', 0xA
create_msg_len equ $ - create_msg
section .bss
fd resd 1 ; Dateideskriptor
section .text
global _start
_start:
; 1. Datei erstellen
mov eax, 8 ; sys_creat
mov ebx, filename ; Dateiname
mov ecx, 0o644 ; Berechtigungen: rw-r--r--
; 0o644 = Besitzer Lesen/Schreiben, Gruppe nur Lesen, Andere nur Lesen
int 0x80
mov [fd], eax ; Dateideskriptor speichern
; 2. Inhalt in Datei schreiben
mov eax, 4 ; sys_write
mov ebx, [fd] ; Dateideskriptor
mov ecx, content ; Datenadresse
mov edx, content_len ; Datenlänge
int 0x80
; 3. Datei schließen
mov eax, 6 ; sys_close
mov ebx, [fd] ; Dateideskriptor
int 0x80
; 4. Erfolgsmeldung ausgeben
mov eax, 4
mov ebx, 1
mov ecx, create_msg
mov edx, create_msg_len
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Run result:
$ nasm -f elf32 file_write.asm -o file_write.o $ ld -m elf_i386 file_write.o -o file_write $ ./file_write File created successfully! $ cat example_output.txt Hello, EXAMPLE!
Dateiname lesen
Beispiel
; Dateiinhalt öffnen und lesen
section .data
filename db 'example_output.txt', 0
open_error db 'Error: cannot open file', 0xA
open_error_len equ $ - open_error
read_success db 'File content:', 0xA
read_success_len equ $ - read_success
section .bss
fd resd 1
buffer resb 1024 ; Lesepuffer
section .text
global _start
_start:
; 1. Datei öffnen (nur Lesen)
mov eax, 5 ; sys_open
mov ebx, filename ; Dateiname
mov ecx, 0 ; Nur-Lese-Modus
mov edx, 0 ; Berechtigungen (für Nur-Lesen ignoriert)
int 0x80
cmp eax, 0 ; Dateideskriptor < 0 bedeutet Fehler
jl open_failed
mov [fd], eax ; Dateideskriptor speichern
; 2. Dateiinhalt lesen
mov eax, 3 ; sys_read
mov ebx, [fd] ; Dateideskriptor
mov ecx, buffer ; Puffer
mov edx, 1024 ; Bis zu 1024 Bytes lesen
int 0x80
; Rückgabewert eax = Anzahl der tatsächlich gelesenen Bytes
mov esi, eax ; Anzahl gelesener Bytes speichern
; 3. Datei schließen
mov eax, 6 ; sys_close
mov ebx, [fd]
int 0x80
; 4. Eingabeaufforderung ausgeben
mov eax, 4
mov ebx, 1
mov ecx, read_success
mov edx, read_success_len
int 0x80
; 5. Dateiinhalt auf dem Bildschirm ausgeben
mov eax, 4
mov ebx, 1
mov ecx, buffer
mov edx, esi ; Tatsächlich gelesene Bytes verwenden
int 0x80
jmp exit
open_failed:
mov eax, 4
mov ebx, 1
mov ecx, open_error
mov edx, open_error_len
int 0x80
exit:
mov eax, 1
mov ebx, 0
int 0x80
Run result:
$ nasm -f elf32 file_read.asm -o file_read.o $ ld -m elf_i386 file_read.o -o file_read $ ./file_read File content: Hello, EXAMPLE!
An Datei anhängend schreiben
Beispiel
; Datei im Anfügemodus öffnen und schreiben
section .data
filename db 'example_log.txt', 0
log_entry db '[INFO] Program executed successfully.', 0xA
log_len equ $ - log_entry
section .bss
fd resd 1
section .text
global _start
_start:
; Datei öffnen (Erstellen + Anfügemodus)
mov eax, 5 ; sys_open
mov ebx, filename ; Dateiname
mov ecx, 0x441 ; O_WRONLY | O_CREAT | O_APPEND
; O_WRONLY=1, O_CREAT=0x40, O_APPEND=0x400
; Kombination: 1 | 0x40 | 0x400 = 0x441
mov edx, 0o644 ; Berechtigungen zum Zeitpunkt der Erstellung
int 0x80
mov [fd], eax
; Schreibvorgang zum Anhängen
mov eax, 4 ; sys_write
mov ebx, [fd] ; Dateideskriptor
mov ecx, log_entry ; Protokollinhalt
mov edx, log_len
int 0x80
; Datei schließen
mov eax, 6
mov ebx, [fd]
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Datei kopieren
Ein umfassendes Beispiel: Kopieren des Inhalts einer Datei in eine andere:
Beispiel
; Datei kopieren: copy example_input.txt to example_copy.txt
section .data
src_file db 'example_input.txt', 0
dst_file db 'example_copy.txt', 0
success_msg db 'Datei erfolgreich kopiert!', 0xA
success_len equ $ - success_msg
error_msg db 'Fehler beim Kopieren der Datei', 0xA
error_len equ $ - error_msg
section .bss
src_fd resd 1
dst_fd resd 1
buffer resb 4096 ; 4 KB Kopierpuffer
section .text
global _start
_start:
; 1. Quelldatei öffnen (nur lesen)
mov eax, 5
mov ebx, src_file
mov ecx, 0 ; O_RDONLY
mov edx, 0
int 0x80
cmp eax, 0
jl error_exit
mov [src_fd], eax
; 2. Zieldatei erstellen
mov eax, 8 ; sys_creat
mov ebx, dst_file
mov ecx, 0o644
int 0x80
cmp eax, 0
jl error_exit
mov [dst_fd], eax
copy_loop:
; 3. Aus Quelldatei lesen
mov eax, 3 ; sys_read
mov ebx, [src_fd]
mov ecx, buffer
mov edx, 4096
int 0x80
; eax = Anzahl der tatsächlich gelesenen Bytes
cmp eax, 0 ; 0 Bytes gelesen?
jle copy_done ; Ja, Dateiende
; 4. In Zieldatei schreiben
mov esi, eax ; Anzahl der gelesenen Bytes speichern
mov eax, 4 ; sys_write
mov ebx, [dst_fd]
mov ecx, buffer
mov edx, esi ; Anzahl der tatsächlich gelesenen Bytes schreiben
int 0x80
jmp copy_loop ; Schleife fortsetzen
copy_done:
; 5. Datei schließen
mov eax, 6 ; sys_close
mov ebx, [src_fd]
int 0x80
mov eax, 6
mov ebx, [dst_fd]
int 0x80
; 6. Erfolgsmeldung ausgeben
mov eax, 4
mov ebx, 1
mov ecx, success_msg
mov edx, success_len
int 0x80
jmp exit
error_exit:
mov eax, 4
mov ebx, 1
mov ecx, error_msg
mov edx, error_len
int 0x80
exit:
mov eax, 1
mov ebx, 0
int 0x80
Weitere ErweiterungenÜberprüfen Sie unbedingt den Rückgabewert von Systemaufrufen (in EAX) vor und nach Dateioperationen. Ein negativer Wert weist auf einen Fehler hin (zum Beispiel ist -2 ENOENT: Datei nicht gefunden, -13 ist EACCES: unzureichende Berechtigungen). Das Ignorieren von Fehler-Rückgabewerten ist die größte Fehlerquelle bei Dateioperationen.