Themen

1

Lowlevel-Coding / Interrupt-Stackzustand (speziell Errorcode) im Long Mode

« am: 02. March 2013, 13:55 »

Hallo,

folgendes Problem:
nach iretq im Interrupthandler bekomme ich einen #PF, warscheinlich durch Fehler im Stack (-> im Code).

Code: [Auswählen]

%macro handler 1
int_stub_%1:
push qword 0x0
push qword %1

jmp handler_common
%endmacro

%macro handler_errorcode 1
int_stub_%1:
push qword %1

jmp handler_common
%endmacro

handler_common:
push rbp
push rdi
push rsi
push rdx
push rcx
push rbx
push rax

push rsp

call handle_interrupt

add rsp, 0x8

pop rax
pop rbx
pop rcx
pop rdx
pop rsi
pop rdi
pop rbp

add rsp, 0x10

iretq
QEMU-Log:

Code: [Auswählen]

----------------
IN:
0x000000000010a07b:  lidt   0x10ac33
0x000000000010a083:  sti

----------------
IN:
0x000000000010a084:  hlt

Servicing hardware INT=0x20
     0: v=20 e=0000 i=0 cpl=0 IP=0008:000000000010a085 pc=000000000010a085 SP=0010:0000000000107454 EAX=0000000000000000
RAX=0000000000000000 RBX=deadbeefc0debeef RCX=0000000000000000 RDX=0000000000000000
RSI=0000000000000000 RDI=0000000000103454 RBP=0000000000000000 RSP=0000000000107454
R8 =0000000000000000 R9 =0000000000000000 R10=0000000000000000 R11=0000000000000000
R12=0000000000000000 R13=0000000000000000 R14=0000000000000000 R15=0000000000000000
RIP=000000000010a085 RFL=00200202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
CS =0008 0000000000000000 00000000 00209800 DPL=0 CS64 [---]
SS =0010 0000000000000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
FS =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
GS =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
LDT=0000 0000000000000000 0000ffff 00008200 DPL=0 LDT
TR =0000 0000000000000000 0000ffff 00008b00 DPL=0 TSS64-busy
GDT=     000000000010ac11 00000017
IDT=     0000000000103144 0000030f
CR0=80000011 CR2=0000000000000000 CR3=0000000000001000 CR4=00000020
DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
DR6=00000000ffff0ff0 DR7=0000000000000400
CCS=0000000000000000 CCD=0000000000103454 CCO=EFLAGS
EFER=0000000000000500
----------------
IN:
0x000000000010ab5f:  pushq  $0x0
0x000000000010ab61:  pushq  $0x20
0x000000000010ab63:  jmp    0x10abc5

----------------
IN:
0x000000000010abc5:  push   %rbp
0x000000000010abc6:  push   %rdi
0x000000000010abc7:  push   %rsi
0x000000000010abc8:  push   %rdx
0x000000000010abc9:  push   %rcx
0x000000000010abca:  push   %rbx
0x000000000010abcb:  push   %rax
0x000000000010abcc:  push   %rsp
0x000000000010abcd:  callq  0x10ad04

----------------
IN:
0x000000000010ad04:  sub    $0x8,%rsp
0x000000000010ad08:  mov    %rdi,(%rsp)
0x000000000010ad0c:  add    $0x8,%rsp
0x000000000010ad10:  retq

----------------
IN:
0x000000000010abd2:  add    $0x8,%rsp
0x000000000010abd6:  pop    %rax
0x000000000010abd7:  pop    %rbx
0x000000000010abd8:  pop    %rcx
0x000000000010abd9:  pop    %rdx
0x000000000010abda:  pop    %rsi
0x000000000010abdb:  pop    %rdi
0x000000000010abdc:  pop    %rbp
0x000000000010abdd:  add    $0x10,%rsp
0x000000000010abe1:  iretq

check_exception old: 0xffffffff new 0xd
     1: v=0d e=0010 i=0 cpl=0 IP=0008:000000000010abe1 pc=000000000010abe1 SP=0010:0000000000107428 EAX=0000000000000000
RAX=0000000000000000 RBX=deadbeefc0debeef RCX=0000000000000000 RDX=0000000000000000
RSI=0000000000000000 RDI=0000000000103454 RBP=0000000000000000 RSP=0000000000107428
R8 =0000000000000000 R9 =0000000000000000 R10=0000000000000000 R11=0000000000000000
R12=0000000000000000 R13=0000000000000000 R14=0000000000000000 R15=0000000000000000
RIP=000000000010abe1 RFL=00200002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
CS =0008 0000000000000000 00000000 00209800 DPL=0 CS64 [---]
SS =0010 0000000000000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
FS =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
GS =0010 0000000000000000 00000000 00009100 DPL=0 DS16 [--A]
LDT=0000 0000000000000000 0000ffff 00008200 DPL=0 LDT
TR =0000 0000000000000000 0000ffff 00008b00 DPL=0 TSS64-busy
GDT=     000000000010ac11 00000017
IDT=     0000000000103144 0000030f
CR0=80000011 CR2=0000000000000000 CR3=0000000000001000 CR4=00000020
DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
DR6=00000000ffff0ff0 DR7=0000000000000400
CCS=0000000000000010 CCD=0000000000107428 CCO=ADDQ
EFER=0000000000000500

Der Fehler kommt anscheinend vom Error code. Nach der Tabelle im AMD64 Manual, Volume 2 auf Seite 250 (PDF 298) ist ja alles 16-byte aligned und mit add esp, 0x10 nehm ich ja den Errorcode und Interrupt Vector vom Stack - muss ich das im Long Mode überhaupt?

Thx

PS: Ja, ich weiß, der EOI fehlt, aber auch mit bekomme ich nen #PF.

2

OS-Design / CPU-Zeit-Verteilung und insbesondere Leerlauf

« am: 19. February 2013, 16:06 »

Hallo,

mal ne Frage bzgl. Multitasking: Woher kommt die Leerlaufzeit in Windows? (Leerlaufprozess)
Tasks können ja entweder geblockt (zB. wg. IO) oder nicht geblockt (also vom Scheduler beachtet) sein. Gehe ich Reht in der Annahme, dass Leerlaufzeiten einfach entstehen, wenn alle Prozesse geblockt sind?

3

Offtopic / UEFI Dualboot Windows + Linux

« am: 27. January 2013, 17:01 »

Hallo,

hat jemand zufällig ein funktionierendes UEFI-Dualboot-System mit Windows und Linux? Wenn ja, welcher Boot Manager und welche Distribution?

Ich verzweifle so langsam an meinem Häufchen Elend, dass hier vor mir steht. Situation wie folgt:

• SSD 128GB (Samsung 830), gekauft 2012, für Windows, NTFS
• HDD ~2TB (Hitachi irgendwas), gekauft 2012, für Windows als Datenplatte, 20GB Swap, Rest NTFS
• HDD 500GB (Western Digital irgendwas), gekauft ~2010, für Linux, 100MB EFI Systempartition, 20GB Swap, 40GB Root, Rest Home

Mein MB ist ein Gigabyte GA-Z77-DS3H, Sockel LGA1155, dazu 16GB RAM.
Nun, als Linux sollte Arch und als Boot Manager rEFInd dienen, aber folgende Probleme:

• Wenn ich Windows boote, wird der EFI-Booteintrag von rEFInd gelöscht - super. 
• Dasselbe passiert auch, wenn ich Windows von rEFInd aus boote.
• Wenn ich (Arch) Linux boote, stürzt der PC bei "Start Setup Virtual Console" vollkommen ab, d.h. der Cursor blinkt nicht mehr (!). Zudem ist "Start Setup Virtual Console" eigentlich vollkommen trivial. (vconsole.conf auslesen)
• Arch von der CD booten passt, ich kann die CD aber nicht im UEFI-Modus booten (irgendwas.conf fehlt angeblich)

Deshalb würde ich gerne wissen, unter welcher Konfiguration ihr Windows+Linux-UEFI-Dualboot zum laufen gebracht habt.

Grüße

PS: Ich wollte gestern unter hohem Aufwand meine ehemalige Konfiguration Windows unter BIOS (war damals meine Dummheit, sollt eigentlich gleich EFI werden) + Linux unter EFI in Windows unter EFI + Linux unter EFI umwandeln, was irgendwie nicht ganz hingehaun hat.
PPS: Das gewisse Windows ist Windows 8, bitte sagt mir jetzt keiner, dass es daran liegt, sonst könnt ich leicht... säuerlich auf MS und mich selbst werden. 

4

Lowlevel-Coding / Long Mode - Welche Methode um Kernel zu linken?

« am: 23. October 2012, 21:58 »

Hallo,

Ich habe in den letzten Tagen die Wikieinträge im os-dev.org-Wiki zum Long Mode recht ausführlich studiert ("unsere" Seite dazu ist ja noch recht spärlich) und werde irgendwie nicht schlau, wie ich am besten Kernel und Bootstrap linke.
In diesem Eintrag werden dazu drei Methoden beschrieben:
Loading...
    5.1 With your own boot loader             Fällt schonmal weg, lieber Multiboot
    5.2 With a separate loader                             
    5.3 With a 32-bit bootstrap in your kernel

5

Lowlevel-Coding / Nicht durch das Multiboot-MMap beschriebene Adressräume

« am: 14. October 2012, 15:03 »

Hallo,

beim Auslesen des Multiboot-MMap ist mir aufgefallen, dass die beschriebenen Addressen nicht zusammenhängen. (d.h. Limit (Base + Length) von Eintrag n ist nicht Base von Eintrag n+1)
Ich gehe deshalb  davon aus, dass der gesamte Addressraum zwischen 0 und dem Ende des höheren Speichers (multiboot_lower_mem * 1024 + multiboot_upper_mem * 1024, oder?) frei ist, solange kein Blocked-Eintrag dazu im MMap vorhanden ist. Ist das so richtig?

6

Softwareentwicklung / Compilerfehler bei C-Bitfeldern

« am: 24. September 2012, 21:53 »

Hallo,

beim Programmieren (ähm, vielmehr übertragen) der x64-Paging-Strukturen in meine Bitfelder bekomme ich leider ständig einen mir nicht ersichtlichen Fehler. (Wahrscheinlich total trivial und dumm, aber wie auch immer. Vier Augen sehen mehr als zwei!  )

Code (gekürzt, das ganze gibts natürlich für jede Struktur, und Entschuldigung für die grauenhafte Formatierung, irgendwie funktionieren Tabs im Editor nicht):

Code: [Auswählen]

typedef struct tag_pml4
{
uint64_t PML4_PRESENT : 1; // Zeile 60
uint64_t PML4_WRITE : 1;
uint64_t PML4_USER : 1;
uint64_t PML4_WRITETHRU : 1;
uint64_t PML4_NOCACHE : 1;
uint64_t PML4_DIRTY : 1; // Zeile 65
uint64_t : 3;
uint64_t PML4_3FREE : 3;
uint64_t PML4_PHYSADDR :40;
uint64_t PML4_11FREE :11; // Zeile 69
uint64_t PML4_NXE : 1; // 0 = EXE/ALLOWED 1 = EXE/FORBIDDEN
} pml4;

Output:

Code: [Auswählen]

In file included from vmm.c:2:0:
paging.h:61:11: Fehler: expected identifier or »(« before numeric constant
paging.h:62:11: Fehler: expected identifier or »(« before numeric constant
paging.h:63:11: Fehler: expected identifier or »(« before numeric constant
paging.h:64:11: Fehler: expected identifier or »(« before numeric constant
paging.h:65:11: Fehler: expected identifier or »(« before numeric constant
paging.h:70:11: Fehler: expected identifier or »(« before numeric constant
paging.h:71:1: Warnung: kein Semikolon am Ende von »struct« oder »union« [standardmäßig aktiviert]

Kompiliert auf Ubuntu 12.04 LTS, gcc-Version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5) mit folgenden Flags:

-Wall -Wextra -Wshadow -Wconversion -Wunreachable-code -Werror-implicit-function-declaration -Wuninitialized -nostdlib -nostartfiles -nodefaultlibs -ffreestanding -fno-builtin -m32 -g3 -O0 -c


Besonders die Warnung am Ende ist komisch - da ist doch ein Semikolon?!

Vielen Dank für eure Hilfe und sorry für meine Dummheit...

7

Lowlevel-Coding / CPU-Reset (Triple Fault) bei Interrupts

« am: 10. June 2012, 17:44 »

Hallo liebe Lowlevel-Community!

Bereits vor etwa einem Jahr habe ich mich mit ein bisschen mit OS-Dev beschäftigt und hier auch schon eine Frage gestellt. Ein wenig später hab ich allerdings meine Ubuntu-Installation geschrottet. Neulich habe ich mir dann wieder Ubuntu eingerichtet und wieder begonnen. 

Wie auch immer, ich stehe gerade vor einem (wahrscheinlich meiner unendlichen Dummheit zuzuschreibendem) Problem:
Nach Aktivierung der Interrupts mittels "sti" gibts einen Triple Fault -> CPU Reset. Leider lässt sich der Fehler schwer finden, denn gdb braucht offensichtlich Interrupts für Breakpoints.

Als Codebasis habe ich eine Kombination von Lowlevel-Wiki-Tutorials, OS-Dev.org-Wiki-Tutorials und was man noch alles so im Netz findet.

Code: [Auswählen]

%macro idtentry 1

dw ((%1 - $$) + SECTIONBASE) & 0xFFFF
dw 0x08
db 0x0
db 0b10001110
dw (((%1 - $$) + SECTIONBASE) >> 16) & 0xFFFF

%endmacro

%macro handler 1
extern handler_%1
int_stub_%1:
push dword 0x0
push dword %1

push ebp
push edi
push esi
push edx
push ecx
push edx

push esp

call handler_%1

add esp, 0x4

pop eax
pop ebx
pop ecx
pop edx
pop esi
pop edi
pop ebp

add esp, 0x8

iret
%endmacro

%macro handler_errorcode 1
extern handler_%1
int_stub_%1:
push dword %1

push ebp
push edi
push esi
push edx
push ecx
push edx

push esp

call handler_%1

add esp, 0x4

pop eax
pop ebx
pop ecx
pop edx
pop esi
pop edi
pop ebp

add esp, 0x8

iret
%endmacro

%macro handler_irq_low 1
extern handler_%1
int_stub_%1:
push dword 0x0
push dword %1

push ebp
push edi
push esi
push edx
push ecx
push edx

push esp

call handler_%1

add esp, 0x4

pop eax
pop ebx
pop ecx
pop edx
pop esi
pop edi
pop ebp

add esp, 0x8

mov al, 0x20
out 0x20, al

iret
%endmacro

%macro handler_irq_high 1
extern handler_%1
int_stub_%1:
push dword 0x0
push dword %1

push ebp
push edi
push esi
push edx
push ecx
push edx

push esp

call handler_%1

add esp, 0x4

pop eax
pop ebx
pop ecx
pop edx
pop esi
pop edi
pop ebp

add esp, 0x8

mov al, 0x20
out 0xA0, al
out 0x20, al

iret
%endmacro

global loader
 
extern main

MODULEALIGN equ  1<<0                   ; align loaded modules on page boundaries
MEMINFO     equ  1<<1                   ; provide memory map
FLAGS       equ  MODULEALIGN | MEMINFO  ; this is the Multiboot 'flag' field
MAGIC       equ    0x1BADB002           ; magic number
CHECKSUM    equ -(MAGIC + FLAGS)        ; checksum

SECTIONBASE equ 0x0100000

section .text
align 4
    dd MAGIC
    dd FLAGS
    dd CHECKSUM
 
STACKSIZE equ 0x4000                    ; 16k
 
loader:
cli

mov esp, stack + STACKSIZE

lgdt [cs:GDTR]

jmp 0x08:shortjmp
shortjmp:

mov ax, 0x10
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax

lidt [cs:IDTR]

mov al, 0x11
out 0x20, al
call io_wait
mov al, 0x20
out 0x21, al
call io_wait
mov al, 0x04
out 0x21, al
call io_wait
mov al, 0x01
out 0x21, al
call io_wait

mov al, 0x11
out 0xa0, al
call io_wait
mov al, 0x28
out 0xa1, al
call io_wait
mov al, 0x02
out 0xa1, al
call io_wait
mov al, 0x01
out 0xa1, al
call io_wait

xor al, al
out 0x20, al
call io_wait
out 0xa0, al
call io_wait

sti

int 0x30 ; als Testinterrupt mit Textausgabe. Triple Fault gibts aber auch so (PIT)

    ;push eax                            ; Multiboot magic number
;push ebx                            ; Multiboot info structure

call main

hang:
hlt
jmp hang

io_wait:
jmp dly
dly: ret

handler 0
;...
handler 48

GDTR:
dw GDT_END-GDT-1
dd GDT
GDT:
dd 0x0, 0x0
db 0xFF, 0xFF, 0x0, 0x0, 0x0, 0b10011010, 0b11001111, 0x0
db 0xFF, 0xFF, 0x0, 0x0, 0x0, 0b10010010, 0b11001111, 0x0
;db 0xFF, 0xFF, 0x0, 0x0, 0x0, 0b11111010, 0b11001111, 0x0 ; zu Fehlersuchzwecken auskommentiert
;db 0xFF, 0xFF, 0x0, 0x0, 0x0, 0b11110010, 0b11001111, 0x0
GDT_END:

IDTR:
dw 49 * 8 - 1
dd IDT
IDT:
idtentry int_stub_0
;...
idtentry int_stub_48

section .bss
align 4
stack:
    resb STACKSIZE


Außerdem noch: kernel.c (mit void main, nichts besonderes) und handler.c (mit Handlern, derzeit ohne wirklichen Inhalt)
Wichtig! Verwendet wird SYSLINUX, nicht GRUB! 
Kompiliert mit

Code: [Auswählen]

CC =gcc
CFLAGS =-Wall -Werror -Wextra -Wshadow -Wconversion -Wunreachable-code -Werror-implicit-function-declaration -Wuninitialized -nostdlib -nostartfiles -nodefaultlibs -ffreestanding -fno-builtin -m32 -g3
LDFLAGS =-m elf_i386
AS =nasm
LD =ld
 
all:kernel.bin
 
kernel.bin:
$(AS) -f elf -o loader.elf loader.S
$(CC) $(CFLAGS) -o kernel.elf -c kernel.c
$(CC) $(CFLAGS) -o handler.elf -c handler.c
$(LD) $(LDFLAGS) -T linker.ld -o kernel.bin loader.elf kernel.elf handler.elf
objcopy --only-keep-debug kernel.elf kernel.sym
objcopy --strip-debug kernel.elf
[...]

Der Linkerscript ist "Standard".

Zum Ausführen nehme ich eine Variante des folgenden Scriptes: wiki.osdev.org/Bare_Bones

Den Reset gibt es nur bei eingeschalteten Interrupts. Ohne wird void main ordnungsgemäß aus geführt.

Hoffe, ich habe mein Problem verständlich erklärt und keine Information vergessen. 

8

Offtopic / C++ Linkerproblem

« am: 23. June 2011, 19:32 »

Hi,

ich habe ein Problemchen mit dem C++-Linker. (MS VC++ 2008)
Hierzu muss ich sagen, dass ich noch nie in irgeneiner Form C++ programmiert habe, also Entschuldigung für diese Noob-Frage.

Folgendes Problem: Mein Linker erkennt die Ausgabedatei des Compilers nicht. (.obj)
Da bei der Fehlermeldung ein Pfad ohne Laufwerksbuchstaben steht, vermute ich deshalb, dass Windoof da irgendwie an einer Variable rumgepfuscht hat.

Wie kann man die Eingabedatei des Linkers ändern? Ich google schon 1 Stunde danach, und es gibt Antworten, wie man den Ausgabepfad etc ändern kann, aber nicht, wie man den Eingabepfad ändern kann, also ist die Lösung wahrscheinlich trivial. (Ist trivial das richtige Wort?)

Noch ein Paar Infos:
-Es ist ein PlugIn für ein MFC-Programm
-Einige Projektpfade enthalten Leerzeichen, aber wurde schon alles mit "" gelöst.

Danke schonmal im Voraus,
tiger717

9

Offtopic / HTTP - Standard

« am: 18. June 2011, 11:07 »

Hallo,

ich habe mich in letzter Zeit mal etwas mit Netzwerk und Servern etc beschäftigt, und bin nun mal auf die Idee gekommen, einen kleinen Proxy selber zu programmieren (natürlich nicht in Asm  )

Aber leider ist mir die Kommunikation doch etwas fraglich erschienen:

HTTP/1.1 200 OK
Server: Apache/1.3.29 (Unix) PHP/4.3.4
Content-Length: (Größe von infotext.html in Byte)
Content-Language: de (nach RFC 3282 sowie RFC 1766)
Connection: close
Content-Type: text/html

(Beispiel von der HTTP-Seite auf Wikipedia)

a) Wird das alles wirklich so übertragen? Wenn ja, wo sind dann die eigentlichen Daten?
b) Welche (Text-)Kodierung wird hier benutzt? UNIX- oder Windows-Zeilenumbrüche?

10

Lowlevel-Coding / C-Kernel ohne Multiboot

« am: 22. May 2011, 12:31 »

Hallo Forum,

ich kämpfe nun schon seit längerer Zeit mit Problemen mit einem kleinen Assembler/C-Kernel.

Gleich vorweg: Ich habe kein "echtes" eingebautes Diskettenlaufwerk, sondern ein USB-Teil, und das versteht sich leider mit meiner openSUSE-Installation nicht so gut (scheint generell nicht unterstützt zu werden). Deshalb hab ich mich entschieden, erstmal kein Multiboot zu verwenden. Hab auch schon einen kleinen Asm-Bootsektor geschrieben, der einen kleinen "Hello World"-Kernel lädt. (Funktioniert tadellos) Nun wollte ich einfach mal diesen Kernel in C umsetzen (nur um zu sehen, wie das im Prinzip läuft), aber der verhält sich bockig. Ich vermute, das Problem liegt am Build-Vorgang, denn der Kernel verwendet keinerlei "böse" Funktionen.

Hier der Code:

Code: [Auswählen]

; boot.asm
[global _start]
[extern init]

_start:
call init

hang:
jmp hang

times 512-($-$$)-2 db 0
dw 0xAA55


Code: [Auswählen]

#include "kernel.h"

void init(void)
{
printline("Hello World!\0");
}

void printline(char hw[])
{
int i;
char* video = (char*) 0xb8000;

for (i = 0; hw[i] != '\0'; i++) {
 
        video[i * 2] = hw[i];
 
        video[i * 2 + 1] = 0x07;
}
}


Code: [Auswählen]

#ifndef KERNEL_H
#define KERNEL_H

void main(void);
void printline(char hw[]);

#endif


Code: [Auswählen]

/*  Bei _start soll die Ausfuehrung losgehen */
ENTRY(_start)
OUTPUT_FORMAT(binary)
OUTPUT_ARCH(i386:i386)

SECTIONS
{

    . = 0x7E00;

    .text : {
        *(.text)
    }
    .rodata : {
        *(.rodata)
    }
    .data : {
        *(.data)
    }
    .bss : {
_sbss = .;
*(COMMON)
        *(.bss)
_ebss = .;
    }
}


Code: [Auswählen]

CC = /usr/bin/gcc
LD = /usr/bin/ld
AS = /usr/bin/nasm
CFLAGS = -Wall -Wextra -Werror -nostdlib -nostartfiles -nodefaultlibs -ffreestanding -c
LDFLAGS = -T kernel.ld
ASFLAGS = -f aout

prog:
$(AS) $(ASFLAGS) -o a.out boot.asm
$(CC) $(CFLAGS) -o b.out kernel.c
$(LD) $(LDFLAGS) -o kernel.img a.out b.out
hexdump kernel.img

init:
umount /dev/sda2
ntfs-3g /dev/sda2 /mnt/windata

clean:
rm a.out
rm b.out
rm kernel.img
rm *~

.PHONY: clean

Ich hoffe doch, das mein Anfängerfehler nicht zu gravierend ist.

P.S.: Bei Bedarf kann ich auch den Hexdump anfügen!