Windows und FAT12



  • Hallo Jungs,

    ich hab mir einen Bootloader für eine 1.44 MB Diskette geschrieben, der mir meinen Kernel als Datei von der Diskette laden soll.
    Ich hab mir etwas Code zusammengebastelt, welcher mir das FAT12 Dateisystem der Diskette analysiert und dann im Rootverzeichnis eine Datei namens 'kernel.bin' raussucht. Scheint auch alles zu funktionieren. Nur er findet die Datei nicht.

    Ich hab mich also gefragt ob das an Windows liegen könnte. Denn soweit ich weiß kann man unter Windows XP auch Dateien auf Diskette kopieren, deren Name länger ist als 11 Zeichen. Was auch für ein verändertes Dateisystem sprechen würde. Ich hab folgendes gemacht:

    Die Diskette vollständig formatiert, dann mit RawWrite 0.7 meinen Bootloader in den Bootsektor geschrieben und anschließend meine kernel.bin auf die Diskette kopiert.
    War das vielleicht falsch, so wie ich's gemacht habe oder liegt's an Windows ? Oder an meiner eigenen Blödheit (Fehler im Bootloadercode) ?
    Ich will nur mal das mit Windows ausschließen können, deshalb frage ich euch um Rat. Denn wenn ich den Bootloadercode jetzt umschreibe und es liegt dann aber doch an was Anderem: dann beiss ich mich in den Ars...;)

    Jo man was soll ich noch sagen - Danke schon mal im Voraus!
    Ciao



  • Ne, an windows bzw. langen Dateinamen liegt's sicher nicht. Bei langen Namen legt Windows lediglich zum ersten FAT-Eintrag mit 8.3 Namen weitere Entrys an, welche IMHO mit 0xEB beginnen und jeweils einen Teil des namens beinhalten. Solche 0xEB-Einträge werden so lange angelegt, bis der lange Name der Datei komplett eingetragen ist. Zeig mal deinen Loader!

    Greetz, Swordfish



  • Lol, ganz sicher ? 😃
    Is aber ein bisschen lang geworden (245 Zeilen)
    Aber dafür übersichtlich, wie ich hoffe.
    Also ich poste ihn mal, solltest du es dir dann noch anders überlegen-du musst das nicht tun!
    Warscheinlich strotzt er vor Fehlern 😉

    [BITS 16]						;Maschinenbefelsbreite: 16 Bit
    org 0x7C00						;Ladeaddresse
    
    jmp short start
    	nop
    
    ; Bios Parameter Block (BPB)
    
    SystemName	db	"coyoteos"		;Name des Betriebssystems 
    BytesPerSec dw	512				;512 Bytes pro Sektor
    SecPerClus	db	1				;1 Sektor pro Cluster (standard)
    RsvdSecCnt	dw	1				;1 Reservierter Sektor (der Bootsektor)
    NumFATs		db	2				;2 File Allocation Tables (FATs)
    RootEntCnt	dw	224				;RootDirectory= 224 Einträge
    TotalSec	dw	2880			;Anzahl aller Sektoren
    Media		db	0xF0			;Medientyp: 1.44 MB Floppy Disk
    FATSize		dw	9				;Größe einer FAT: 9 Sektoren
    SecPerTrack	dw	18				;18 Sektoren je Spur
    NumHeads	dw	2				;2 Lese-/Schreibköpfe
    HiddenSec	dd	0				;Versteckte Sektoren
    TotalSec32	dd	0				;Anzahl aller Sektoren (nur bei FAT32)
    DriveNum	db	0				;Laufwerk (A:)
    Reserved	db	0				;Reserviert für Windows NT 
    BootSig		db	0x29			;-> die folgenden drei Felder sind vorhanden
    
    DiskID		dd	0				;Seriennummer 
    DiskName	db	"Boot Coyote"	;Bezeichner
    FileSys		db	"FAT12   "		;FAT12 -Dateisystem
    
    start:
    	mov ax, 0x9000				;richte Stack ein		
    	mov ss, ax			
    	mov sp, 0						
    
    	xor ax, ax					;Bios Func (0)
    	int 0x13					;setze Controller zurück
    
    	mov ax, 0x400				; es = 0x400
    	mov es, ax
    
    	mov ax, cs					; ds = cs
    	mov ds, ax
    
    	;Back to the Root(s), where is it ?...
    
    	xor ax, ax
    	mov al, [NumFATs]			;Anzahl der FATs x Größe einer FAT
    	mov bx, [FATSize]			;
    	mul bx						; = die von den FATs belegten Sektoren
    	add ax, word [HiddenSec]	; + versteckte  Sektoren
    	add ax, word [RsvdSecCnt]	; + reservierte Sektoren
    	mov word [RootPos], ax		; = Position des Wurzelverzeichnis
    								; > Speichern (RootPos)		
    
        call searchroot
    
    	mov ax, word [RootSize]    
    	add ax, word [FileStartSec]
    	add ax, word [RootPos]      ;Dateistart-Sektornummer ist in ax
    	sub ax, 2                   ;subtrahiere 2 (aufgrund der
                                    ;Kompatiblität mit älteren Dos Versionen)
    	mov cx, word [FileLength]
    
    	push ax 
    
    	mov si, LoadingFileMsg
    	call print
    
    	pop ax
    
    loadfile_nextsec:
        xor bx, bx
    
        push es
        push cx
        push ax
    
        call readsector
    
    	mov si, Point
    	call print 
    
    	pop ax
    	pop cx
        pop es
    
    	mov bx, es
    	add bx, 20h
    	mov es, bx
    
    	inc ax
    	loopnz loadfile_nextsec
    
    	jmp 0x400:00                ;Jump to kernel, yes ! :D...
    
    searchroot:
    
    	mov ax, 32					; 32 Bytes * Einträge = Größe Root in BYTES
    	mul word [RootEntCnt]		;
    	div word [BytesPerSec]		;/Bytes pro Sektor = Größe Root in SEKTOREN
    	mov word [RootSize], ax	    ;> Speichern (RootSize)
    	mov cx, ax					;> Speichern (cx)
    	mov ax, word [RootPos]		;< Laden     (RootPos), vgl. oben
    	                            ;OK RootPos in ax, RootSize in cx
    
    init_readsector:                    
        xor bx, bx      
    
        push cx     
        push ax
        push es
    
        call readsector
    
        pop es
        pop ax
    
        xor bx, bx
    comparison:
    
        mov di, bx
        mov cx, 11
        mov si, Filename
    
        repz cmpsb
        je foundit
    
        add bx, 32
        cmp bx, [BytesPerSec]
        jnz comparison
    
        inc ax
        pop cx
        loopnz init_readsector
    
        jmp fehler
    
    foundit:
        pop cx
        mov di, 0x1A
        add di, bx
    
        mov ax, [es:di]
        xor dx, dx
        mov dl, [SecPerClus]
        mul dx
        mov word [FileStartSec], ax ;> Speichern (FileStartSec)
    
        mov di, 0x1C
        add di, bx
        mov ax, [es:di]
        mov bx, [BytesPerSec]
        div bx
    
        inc ax
    
        mov word [FileLength], ax   ;> Speichern (FileLength)
    
        ret 
    
    fehler:							;Fehlermeldung ausgeben und neu starten!
    	mov si, Fehlermeldung
    	call print
    	xor ah, ah
    	int 0x16
    	db 0xEA
    	dw 0x0000
    	dw 0xFFFF 
    
    readsector:                     ;Liest den in AX angegebenen (logischen)
    
    push ax
    mov si, SubFuncRS
    call print
    pop ax
    
        mov cx, ax                  ;> Speichern in cx (LSN)
        mov ax, [TotalSec]          ;in ES:BX
        div word [NumHeads]         ;kein Rest, SecPerHead in ax
        mov bx, ax                  ;> Speichern in bx (SecPerHead)
    
        mov ax, cx                  ;LSN/SecPerHead
        div bx
        mov [Head], al              ;> Speichern (Head)
    
        mov ax, dx                  ;Rest (von dx:SektorOnHead) in ax
        xor dx, dx 
        div word [SecPerTrack]      ;erhalte Cylinder (Track) in ax
        mov [Track], al             ;> Speichern (Track)
        inc dl                     ;den Rest (modulo= Sektor) um 1
                                    ;erhöhen, da der Sektor im CHS nicht bei 0
                                    ;wie die LSN beginnt!
        mov [SecToRead], dl         ;> Speichern (SecToRead)
    
        mov dh, [Head]              ;Wir laden unsere gesp. Bios Fkt. Parameter!
        mov dl, [DriveNum]
        mov ch, [Track]
        mov cl, [SecToRead]         ;na das is doch mal übersichtlich...:D
    
        mov ax, 0201h
        int 0x13
        jc fehler
        ret
    
    print:							;gibt den '0'-terminierten String aus
    	cld                         ;auf den ds:si zeigt                              
    	lodsb                       
    	or al, al
    	jz ready 
    	mov ah, 0x0E
    	int 0x10
    	jmp print  
    
    ready:	
    	ret 
    
    ; Los Variablos
    RootPos				dw	0
    Fehlermeldung		db	"Houston, wir haben ein Problem!", 0
    RootSize			dw	0
    FileStartSec        dw  0
    Filename            db  "KERNEL  BIN"
    FileLength          dw  0
    LoadingFileMsg      db  "Lade Kernel", 0
    Point               db  '.', 0
    SubFuncRS			db	"R", 0
    Breakpoint			db	"?"
    
    Head                db  0
    Track               db  0
    SecToRead           db  0
    
    times 510 - ($-$$)	db	0x00		;bis zu 512 Bytes aufpumpen
    dw	0xAA55							;Bootsignatur
    


  • Hi,

    ich bins nochmal. Siehst du dir den Code an oder hast du's aufgegeben ?
    Das ist jetzt nicht böse gemeint.
    Ist nur eine Frage - nicht dass ich hier ewig warte.

    Schönen Gruß
    und wech 😃


Log in to reply