Gestern und heute habe ich an einer Makrosammlung für NASM gebastelt, die es ermöglicht ohne die Zuhilfenahme weiterer Tools ein FAT12 Image zu erstellen. Zu benutzen ist das in etwa so:

%include "fat12.inc"

; Die Standardeinstellung erzeugt ein Image für 1,44MB Disketten. Mehr Tuning gibt es in fat12.inc.
fat_start

; erzeugt eine Datei namens README.TXT
fat_file "readme.txt", "README TXT"
; erzeugt eine Datei namens README.TXT
fat_file "wasauchimmer.txt", "BLUBB TXT"
; erzeugt eine Datei namens MEINFOTO.JPG
fat_file "Urlaub 2006 - Strand.jpg", "MEINFOTOJPG"
fat_end

Das ganze kann man dann einfach mit nasm -o disk.img -f bin diskimage.asm assemblieren.

fat_start beginnt ein Diskettenimage. Es hat einen Optionalen Parameter, der die Anzahl der reservierten Sektoren angibt. Wenn kein Parameter angegeben wird, wird ein Bootloader mit passendem Bootpartitionblock erstellt. Wenn dort ein Parameter angegeben wird, muss der Bootpartitionblock selbst gebastelt werden. Als Vorlage kann dazu das Makro default_boot_sector in fat12.inc dienen.

fat_file fügt eine Datei in das Image ein. Der erste Parameter ist der Pfad zu der Datei, die eingefügt werden soll. Der zweite Parameter gibt den Namen der Datei auf dem Image an. Dieser Name muss ein 8.3-Name sein. Das heisst die ersten 8 Zeichen sind der Teil vor dem Punkt, die letzten 3 Zeichen sind die Erweiterung. Der Name muss immer 11 Zeichen lang sein, und nicht genutzte Bytes müssen mit Leerzeichen gefüllt werden. Hier gibt es keine Überprüfung auf fehlerhafte Eingaben. Mehr zu den Dateinamen gibt es auch in der FAT Spezifikation. Bei den Dateigrößen muss darauf geachtet werden, dass diese Dateien auf die Diskette passen. Es gibt auch hier keine Fehlerüberprüfung.

fat_end muss ganz zum Schluss aufgerufen werden, damit das Diskimage und die einzelnen Sektionen bis zum Ende aufgefüllt werden.

Noch ein Hinweis zum Code: Da eine FAT-Formatierte Diskette/Partition in 3 Teile aufgeteilt ist (root-Directory, FAT, und Datenteil) musste ich einige Tricks anwenden, weil die Anordnung wie die Teile definiert werden, anders ist, als die Ordnung auf der Diskette. So schreibe ich zuerst die Datei in die Datensektion, damit ich die Größe feststellen kann, und erstelle erst dann den Eintrag in der FAT, die auf dem Image allerdings davor liegt. Damit dies gelingt, nutze ich die Multisection-Unterstützung im bin-Format. Das Makro fat_start, sieht vereinfacht so aus:

%macro fat_start 0
section .root_dir
section .fat
section .file_data
%endmacro

Damit lege ich die Reihenfolge der Sektionen fest und nun kann ich im weiteren Code in beliebiger Reihenfolge in die Sektionen schreiben, ohne diese Anordnung wieder zu verlieren. Diese Sammlung von Makros ist eine sehr ungetestete Alpha-Version. Zum Beispiel waren bis vor wenigen Minuten Dateien deren Größe modulo 1024 kleiner als 512 ist nicht unterstützt.

Den Download gibt es unter Auf meiner Todolist stehen unter anderem:

• Viele Zahlen, die noch "hardwired" sind, müssen in Makros verpackt werden.
• Lange Dateinamen
• FAT16
• Verzeichnisse
• Fehlerüberprüfung

Vielleicht gibt es demnächst ja ein Update von mir. Wenn jemand anders damit erfolgreich rumexperimentiert und mit dem den Makros irgendwas spektakuläres anstellt, würde ich mich freuen davon zu hören. Verbesserungsvorschläge und Bugreports sind auch willkommen. Und wenn es einfach nur funktioniert, freue ich mich noch mehr über Kommentare.

Den Code gibt es unter

 ; Makros für die Erstellung von FAT12-Disketten Images
; mehr: http://superschurke.wordpress.com/?p=5
; Public Domain
; Keine Garantie für irgendwas.
%define DISK_SIZE (1440*1024)
%define BYTES_PER_SECTOR 512
%define SECTORS_PER_CLUSTER 1
%define CLUSTER_SIZE (SECTORS_PER_CLUSTER*BYTES_PER_SECTOR) ; in bytes
%define ROOT_ENT_CNT 224
%define FAT_SIZE 9 ; in sectors
%define NUM_FATS 2

%macro char 1-2
%1:
    %if %0==2
        resb %2
    %else
        resb 1
    %endif
%endmacro

%macro shortint 1-2
%1:
    %if %0==2
        resw %2
    %else
        resw 1
    %endif
%endmacro

%macro long 1-2
%1:
    %if %0==2
        resd %2
    %else
        resd 1
    %endif
%endmacro

struc bpb_s
    char jmpBoot, 3
    char OEMName, 8
    shortint BytsPerSec
    char SecPerClus
    shortint RsvdSecCnt
    char NumFATs
    shortint RootEntCnt
    shortint TotSec16
    char Media
    shortint FatSz16
    shortint SecPerTrk
    shortint NumHeads
    long HiddSec
    long TotSec32
    char DrvNum
    char Reserved1
    char BootSig
    long VolID
    char VolLab, 11
    char FilSysType, 8
endstruc

struc file_dir_entry_s
    char Name, 11
    char Attr
    char NTRes
    char CrtTimeTenth
    shortint CrtTime
    shortint CrtDate
    shortint LstAccDate
    shortint FstClusHI
    shortint WrtTime
    shortint WrtDate
    shortint FstClusLO
    long FileSize
endstruc

%define ATTR_READ_ONLY 0x01
%define ATTR_HIDDEN 0x02
%define ATTR_SYSTEM 0x04
%define ATTR_VOLUME_ID 0x08
%define ATTR_DIRECTORY 0x10
%define ATTR_ARCHIVE 0x20
%define ATTR_LONG_NAME (ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUME_ID)

; usage: make_date year, month, day
%macro make_date 3
    dw (%3 & 0x1f) | ((%2 & 0xf) << 5) | (((%1 - 1980) & 0x7f) << 9)
%endmacro

; usage: make_time hour, minute, second
%macro make_time 3
    dw ((%3 >> 1) & 0x1f) | ((%2 & 0x3f) << 5) | ((%3 & 0x1f) << 11)
%endmacro

%macro default_boot_sector 0

istruc bpb_s
    at jmpBoot, jmp short $+bpb_s_size
        nop
    at OEMName, db "MSDOS5.0"
    at BytsPerSec, dw BYTES_PER_SECTOR
    at SecPerClus, db SECTORS_PER_CLUSTER
    at RsvdSecCnt, dw 1
    at NumFATs, db NUM_FATS
    at RootEntCnt, dw ROOT_ENT_CNT
    at TotSec16, dw DISK_SIZE/BYTES_PER_SECTOR
    at Media, db 0xf0
    at FatSz16, dw FAT_SIZE
    at SecPerTrk, db 18
    at NumHeads, dw 2
    at HiddSec, dd 0
    at TotSec32, dd 0
    at DrvNum, db 0
    at Reserved1, db 0
    at BootSig, db 0x29
    at VolID, dd 0x4076939f
    at VolLab, db "NO NAME    "
    at FilSysType, db "FAT12   "
iend
    xor ax, ax
    mov ss, ax
    mov sp, 0x7bfc
    mov ds, ax
    mov es, ax
    cld
    mov si, msg_blah
next:
    lodsb
    cmp al, 0
    jz press_any_key
    mov ah, 0x0e
    int 0x10
    jmp next
press_any_key:
    xor ax, ax
    int 0x16
reboot:
    int 0x19
halt:
    jmp $

    msg_blah db 'This disk is not bootable.', 13, 10, 'Remove this disk and press any key', 13, 10, 0
    times 510-($-$$) db 0
    dw 0xaa55

%endmacro

%macro _fat_section 1
    %if %1==1
        section .fat
    %else
        section .fat%1
    %endif
%endmacro

%macro fat_start 0-1

    %push fat

    %if %0==0
        %define %$RESERVED_SECTORS 1
        default_boot_sector
    %else
        %define %$RESERVED_SECTORS %1
    %endif

    section .fat
        fat_start:

    %assign i 1
    %rep NUM_FATS
        _fat_section i
            db 0xF0
            db 0xFF
            db 0xFF
        %assign i i+1
    %endrep

    section .root_dir
        root_dir_start:

    section .file_data
        file_data_start:

%endmacro

%macro fat_end 0

    section .fat
        fat_used_bytes equ ($-fat_start)

    %assign i 1
    %rep NUM_FATS
        _fat_section i
            times FAT_SIZE * BYTES_PER_SECTOR - fat_used_bytes db 0x0
        %assign i i+1
    %endrep


    section .fat
        fat_end
        fat_size equ fat_end - fat_start

    section .root_dir
        times ROOT_ENT_CNT * 32 - ($-root_dir_start) db 0
        align BYTES_PER_SECTOR
        root_dir_end
        root_dir_size equ root_dir_end - root_dir_start

    section .file_data
        file_data_end
        file_data_size equ file_data_end - file_data_start

    times DISK_SIZE-(%$RESERVED_SECTORS*BYTES_PER_SECTOR+root_dir_size+NUM_FATS*fat_size+file_data_size) db 0

    section .text

    %pop

%endmacro



%macro fat_file 2



    section .file_data

        %%start equ ($-$$)
        %%first_cluster equ (%%start / CLUSTER_SIZE)
        incbin %1
        %%end equ ($-$$)
        %%size equ (%%end - %%start)
        %%size_in_clusters equ ((%%size + CLUSTER_SIZE - 1) / CLUSTER_SIZE)
        times (CLUSTER_SIZE*2) - (($-$$) % (CLUSTER_SIZE*2)) db 0 ; *2 simplifies generation of fat



    section .root_dir
        %%dir_entry:
        istruc file_dir_entry_s
            at Name, db %2
            at Attr, db ATTR_ARCHIVE
            at WrtTime, make_time 14, 38, 55
            at WrtDate, make_date 2006, 6, 9
            at FstClusLO, dw %%first_cluster+2
            at FileSize, dw %%size
        iend



    %assign tsize_in_clusters %%size_in_clusters ; nasm does not support nested %reps with %%-variables



    %assign i 1

    %rep NUM_FATS
        _fat_section i
            %assign j %%first_cluster+2+1
            %rep (tsize_in_clusters+1)/2
                %assign c1 j
                %if j > %%size_in_clusters
                    %assign c2 0xFFF ; end of file
                %else
                    %assign c2 j + 1
                %endif
                %assign c c1 | (c2 << 12)
                dw c & 0xFFFF
                db (c >> 16)
                %assign j j+2
            %endrep

            %if c2 != 0xFFF
                db 0xFF
                db 0x0F
                db 0x00
            %endif

        %assign i i+1

    %endrep

%endmacro

Sorry, WordPress versaut die Formatierung gehörig. Es ist halt einfach nicht geeignet für überhaupt irgendwas. Ich muss mir mal zuverlässigen Webspace suchen.

Gleich als Einstimmung auf die Art der weiteren Posts gibt es von mir etwas relativ exotisches, das keinen praktischen Nutzen hat: Einen Bootsektor, der komplett in C geschrieben ist. Es werden nur der GCC und LD aus den Binutils verwendet. Es gibt dabei zwei Herausforderungen:

1. Mit möglichst wenig Code in den Protected Mode zu gelangen, denn der GCC ist nur für den Protected Mode geeignet.
2. Den Linker dazu zu bringen, eine 512 Byte große Datei zu erzeugen.

In diesem Post setze ich voraus, dass eine gewisse Kenntnis im Umgang mit dem GCC und LD vorhanden sind, sowie was ein Bootsektor ist und welche Bedingungen dort herrschen. Die wichtigsten Dinge kurz zusammengefasst: Der GCC erzeugt Code für den 32-Bit Protected Mode, im Bootsektor stehen uns (weniger als) 512 Bytes zur Verfügung und wir befinden uns im 16-Bit Real Mode.

In den Protected Mode

Es sind 4 Schritte notwendig um vom Urzustand nach dem Einsprung in den Bootsektor eine Umgebung zu schaffen, in der der vom GCC erzeugte Code zuverlässig laufen kann:

1. Eine GDT laden
2. In den Protected Mode schalten
3. Die Daten-, Code- und Stackselektoren laden
4. Den Stackpointer setzen

Die Aussage, dass ich nur den GCC und LD verwende, war nicht ganz korrekt: Für jeden dieser vier Schritte müssen wir zwangsläufig mit Inline-Assembler arbeiten. Wir nutzen also auch noch den GNU Assembler GAS, der allerdings intern vom GCC aufgerufen wird. Da wir uns im Real Mode befinden, müssen wir dem Assembler mit .code16 befehlen 16-Bit Code zu erzeugen. Danach folgt der oben genannte Ablauf, um in den Protected Mode zu gelangen, und ein far jump zum 32-Bit Code. Das darauf folgende .code32 sorgt dafür, dass ab dieser Stelle wieder 32-Bit Code erzeugt wird:

asm("\n\t"
".code16\n\t"
"cli\n\t"
"xor %ax, %ax\n\t"
"mov %ax, %ds\n\t"
"lgdt _gdt\n\t" /* 1. */
"mov %cr0, %eax\n\t" /* 2. */
"inc %ax\n\t"
"mov %eax, %cr0\n\t"
"mov $0x10, %ax\n\t" /* 3. */
"mov %ax, %ds\n\t"
"mov %ax, %es\n\t"
"mov %ax, %ss\n\t"
"mov $0x7bfc, %esp\n\t" /* 4. */
"ljmpl $0x08, $_bmain\n\t" /* Sprung zum C-Code */
".code32\n");

Erzeuge einfach eine leere Datei, nenne sie boot.c und füge diesen Assembler Code ein. Füge alle weiteren Codes unter diesem ein, damit dieser Code zu erst ausgeführt wird.

Die Labels _gdt und _bmain werden im C-Teil definiert. In diesem Code beginnen sie im Inline-Assembler-Teil mit Unterstrichen, da ich diesen Code mit MinGW getestet habe. (Wenn du nicht DJGPP oder MinGW nutzt, musst du die Unterstriche entfernen. In einem späteren Post werde ich vielleicht mal erläutern, warum die Verwendung von MinGW und DJGPP eine schlechte Idee ist.) In dem nun folgenden C-Teil benutzen wir also statt _gdt und _bmain nur noch gdt bzw. bmain, meinen jedoch die selben Variablen.

In dem C-Teil müssen wir noch die GDT definieren. Dazu bietet sich folgendes struct an:

struct __attribute__ ((packed))
{
struct __attribute__ ((packed))
{
unsigned short limit;
void * base;
unsigned short zero;
};
unsigned long long code_desc;
unsigned long long data_desc;
}
gdt =
{
{ sizeof(gdt) - 1, &gdt, 0 }, // gdtr/null descriptor
0x00cf9a000000ffffULL, // code descriptor
0x00cf92000000ffffULL, // data descriptor
};

Hier benutze ich die Technik, dass ich GDT und GDTR verschachtele. Das GDTR steht also an der Stelle des ungenutzten Null-Deskriptors, und die Adresse von gdt gibt somit sowohl die Adresse der GDT als auch die Adresse des GDTR an. Der Sinn dahinter ist einfach Platz zu sparen. Würde ich das GDTR aus der GDT rausnehmen, würden wir 6 Bytes mehr verbrauchen. Bei nur 512 Bytes (eigentlich 508, siehe unten), die uns zur Verfügung stehen, ist diese einfache Optimierung auf jeden Fall gerechtfertigt. Für die Code und Datendeskriptoren habe ich mir kein eigenes struct gebastelt, sondern einfach unsigned long longs genommen, weil diese einfachen Deskriptoren klar sein sollten, und ich einfach auf kürzeren Code stehe.

Das __attribute__ ((packed)) sorgt dafür, dass der GCC nicht irgendwelche Zwischenräume zwischen den Mitglieden der structs macht, um den Code zu „optimieren“. In diesem Fall wäre das nicht nur Verschwendung, sondern würde für einen Absturz sorgen, da die CPU davon ausgeht, dass es dort keine Zwischenräume gibt.

Für bmain nehmen wir erstmal eine einfache Hello-World-Funktion:

void bmain(void)
{
char * msg = "Hello, world!";
short * video = (short *)0xb8000;
while(*msg)
{
*video++ = *msg++ | 0x0700;
}

while(1);
}

Alles zusammen linken

Um zu überprüfen, ob alles richtig ist, können wir den Quelltext kompilieren, linken und in eine Binär-Datei umwandeln. Kompilieren ist noch einfach:

gcc -c boot.c

Für das Linken brauchen wir folgendes Linker-Skript names boot.ld:

SECTIONS
{
.boot_sector 0x7c00 : {
*(.text)
*(.data) /* daten */
*(.rdata) /* read-only daten */
*(.rodata) /* read-only daten von mingw */
}
.bss : {
*(.bss)
}
}


Ich habe hier eine neue Sektion namens .boot_sector eingeführt, die erwartet, an die Adresse 0×7c00 geladen zu werden. In diese Sektion kommt alles Initialisiertes, also der Code (.text) und die Daten (.data, .rdata, .rodata). Die nicht initialisierten Daten (.bss) kommen einfach dahinter. Durch folgenden Aufruf von ld wird das Linker-Skript angewandt:

ld -T boot.ld -o boot boot.o

Und mit objcopy wird das ganze in eine Binärdatei umgewandelt:

objcopy -O binary boot

Man kann auch direkt mit ld die Binärdatei erzeugen, und somit objcopy weglassen. Allerdings ist das ld von MinGW total vermurkst und deswegen verwende ich die Methode mit objcopy, die mit allen GCC-Varianten funktionieren sollte.

Jetzt fehlt noch das Wichtigste, das einen Bootsektor ausmacht: Die Bootsignatur 0xaa55. Dieses beiden Bytes müssen sich genau an dem Offset 510 des Bootsektors befinden, also 2 Bytes vor dem Ende. Um diese dort zu platzieren, benötigen wir LD. Wichtig ist dabei allerdings zu beachten, dass wir uns in 32-Bit Code befinden und es deswegen nicht so einfach ist, etwas an einer Adresse zu platzieren, die nicht durch 4 teilbar ist. Der Einfachheit halber platziere ich statt eines words 0xaa55 an die Adresse 510, das dword 0xaa550000 an die Adresse 508. Dass dies auch die korrekte Bootsignatur erzeugt, liegt daran, dass die x86-Archtektur eine Little-Endian-Architektur ist. Wenn ich also das word 0xaa55 an die Adresse 510 schreibe, landet das byte 0×55 bei 510 und das byte 0xaa bei 511. Wenn ich das dword 0xaa550000 an die Adresse 508 schreibe, landet das niederwertigste byte 0×00 bei 508, das zweite byte (von rechts) 0×00 bei 509, und die bytes 0×55 und 0xaa wieder bei 510 bzw. 511.

Ein dword mit dem Wert 0xaa550000 ist in C einfach zu definieren:

static unsigned int boot_signature = 0xaa550000;


Um dies allerdings noch zu platzieren, müssen wir es in eine Extra-Sektion tun. Diese kann einen beliebigen Namen haben, ich habe .boot_signature gewählt:

static unsigned int boot_signature __attribute__ ((section(".boot_signature"))) = 0xaa550000;


Da diese Variable nur vom Linker, aber nicht vom C-Compiler genutzt wird, müssen wir ihn daran hindern, sie weg zu optimieren. Das geht mit dem Attribut used:

static unsigned int boot_signature __attribute__ ((section(".boot_signature"))) __attribute__ ((used)) = 0xaa550000;
Die Sektion .boot_signature können wir nun mit *(.boot_signature) im Linker-Skript referenzieren:

SECTIONS
{
.boot_sector 0x7c00 : {
*(.text)
*(.data) /* daten */
*(.rdata) /* read-only daten */
*(.rodata) /* read-only daten von mingw */
. = 508; *(.boot_signature)
}
.bss : {
*(.bss)
}
}


Die neue Zeile platziert die Sektion .boot_signature an das Offset 508, was wie oben bereits erläutert unsere Bootsignatur gibt. Jetzt einfach noch mal alles neu bauen, und fertig ist der Bootsektor in C:

gcc -c boot.c
ld -T boot.ld -o boot boot.o
objcopy -O binary boot

Die Datei boot kann man nun in einen Bootsektor einer Diskette schreiben und wenn man davon bootet wird man mit einem „Hello, world!“ begrüßt.

Fazit

Der Nutzen eines solchen Bootsektors ist, wie bereits gesagt, eher gering, da man sich durch den Sprung in den Protected Mode sofort den Zugang zu den BIOS-Funktionen versperrt, die man benötigt um weiteren Code nachzuladen. Wer in den ca. 430 noch zur Verfügung stehenden Bytes einen Diskettentreiber schreiben kann, der wird natürlich auch damit umgehen können. Dem sterblichen Rest würde ich in der Regel von einem selbstgeschriebenen Bootsektor abraten und einen Bootloader wie GRUB, von dem übrigens bald Version 2 ansteht, empfehlen.

Update: Hab vergessen die Interrupts zu deaktivieren.

Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!