Lowlevel
Lowlevel => tyndur => Thema gestartet von: T0ast3r am 31. March 2006, 17:26
-
Ich denke es ist bereits an der Zeit einen Bootloader zu erstellen.
Wer will ihn programmieren? bitmaster?
der bootloader soll ziemlich simpel gehalten werden und "nur" einen kernel oder einen OS Loader laden
schreibt eure ideen hierzu einfach in den thread
eine wichtige frage wäre auch ob der bootloader 512 bytes übersteigt oder nicht, den je nach dem kann man (interessante) funktionen einbauen
wichtig ist auch auf welchem server das LOST Projekt kommt, hat jemand eine Idee?
ps: wegen dem kernel (design) [@Steffan2005] wird später ein thread eröffnet
-
Jo, also ich würde gerne den Bootstrap schreiben. Nee, der wird nicht größer als 512 Byte. Also dann mit FAT12 unterstützung oder erst mal nur einzelnde Sektore?
bitmaster
-
wichtig ist auch auf welchem server das LOST Projekt kommt, hat jemand eine Idee?
Ich hab meine Empfehlung hier (http://lowlevel.brainsware.org/forum/viewtopic.php?t=1294) gepostet.
-
ok, dann schreib du den bootloader bitmaster, die aufgabenstellung ganz klar:
512 byte großer bootloader, lädt eine (welche im code angegeben wird) datei in den ram und springt
solltest du ein paar nützliche routinen brauchen, sags einfach
die nächste frage ist, wie geht es weiter, also ob dann gleich der kernel geladen wird, oder wie schon mein Vorschlag war, ein OS Loader.
Ich werde mich ganz an der Allgemeinheit richten.
Ein OS Loader würde zuerst alles initialisieren, hätte auch Fehlerroutinen, RAM check, (erweiterte) textausgabe usw.; ein OS Loader würde halt das ganze Betriebssystem (stabil) laden
-
wichtig ist auch auf welchem server das LOST Projekt kommt, hat jemand eine Idee?
Ich hab meine Empfehlung hier (http://lowlevel.brainsware.org/forum/viewtopic.php?t=1294) gepostet.
Hmm, ich verstehe das nicht.. Ihr braucht eine platzt wo die sourcen, sotusagen gehostet werden?. Wenn ja, ich habe in die Schweiz einen Server, wo ich admin bin, von dort aus könnte ich wohl space anbieten.
-
ok, dann schreib du den bootloader bitmaster, die aufgabenstellung ganz klar:
512 byte großer bootloader, lädt eine (welche im code angegeben wird) datei in den ram und springt
solltest du ein paar nützliche routinen brauchen, sags einfach
die nächste frage ist, wie geht es weiter, also ob dann gleich der kernel geladen wird, oder wie schon mein Vorschlag war, ein OS Loader.
Ich werde mich ganz an der Allgemeinheit richten.
Ein OS Loader würde zuerst alles initialisieren, hätte auch Fehlerroutinen, RAM check, (erweiterte) textausgabe usw.; ein OS Loader würde halt das ganze Betriebssystem (stabil) laden
OK, ich schreibe den FAT12 kompatible. Dann fang ich mal an....
-
Jah, husch husch fangt an ^^.
-
Hmm, ich verstehe das nicht.. Ihr braucht eine platzt wo die sourcen, sotusagen gehostet werden?. Wenn ja, ich habe in die Schweiz einen Server, wo ich admin bin, von dort aus könnte ich wohl space anbieten.
Hm, kannst du da einen SVN-Server laufen lassen? Dann wäre das wohl schon möglich. Aber wenn es die Möglichkeit gibt, das woanders kostenlos zu bekommen, brauchst du dir die Mühe eigentlich nicht machen.
-
Hi,
ich habe jetzt einen FAT12 Bootstrap geschrieben. Der läd dann einfach die Datei LOST.SYS an Adresse 1000:0000. Funktioniert eigentlich wunderbar. Das einzige was man vielleicht noch verbessern kann ist, dass ich nur eine FAT-Tabelle lese und die andere gar nicht beachte. Aber dann brauch man ja einfach nur mit dem int 13h die erste Tabelle laden, und wenn nach ein paar versuchen immer noch ein Fehler auftritt (nach lesen mit int 13h CF gesetzt) wird die zweite FAT-Tabelle gelesen. Aber sonst ist eigentlich alles sehr gut. Wo soll ich denn jetzt die boot.asm hin schicken?
bitmaster
-
zu mir ^^, ne mal im ernst, wo ist jetzt unsere space?
-
In den Bootloader sollte noch eine CRC-Pfüfung rein.
-
wegen des spaces:
ich schlage vor mich bei ohost zu reigistrieren, um dann ein (oder das) wiki raufzugeben, wobei dort auch immer aktuelle sourcen usw. raufgegeben werden
wegen dem repository informiere ich mich gerade (umfangreich)
-
So, wie gesagt habe ich schon einen FAT12-Bootstrap geschrieben. Er läd einfach die Datei LOST.SYS an Adresse 1000:0000. Und falls die Datei nicht gefunden wurde, gibt er eine Meldung aus. Ein paar verbesserungen kann man noch einbauen, wie z.B. beide FAT-Tabellen nutzen (fals eine beschädigt ist). Hier der Code:
;Bootstrap für LOST assemblieren mit nasm
org 7C00h
jmp EndBPB ;unter dem BIOS-Parameter-Block
OSName db "L O S T "
BytesPerSec dw 512
SecPerClus db 1
RsvdSecCnt dw 1
NumFATs db 2
RootEntCnt dw 224
TotSec dw 2880
MediaType db 0F0h
FATsize dw 9
SecPerTrack dw 18
NumHeads dw 2
HiddenSec dd 0
TotSec32 dd 0
DrvNum db 0
Reserved db 0
ExBPSign db 29h ;keine Ahnung wofür das ist
VolumeID dd 0FFFFFFFFh
DiskLabel db "LOST "
FileSysType db "FAT12 "
EndBPB:
cli
xor ax,ax
mov ds,ax
mov es,ax
mov ss,ax
mov sp,0FFFFh
sti
mov [drive],dl ;Laufwerk
;load rootdirectory
mov ax,32 ;32 Byte pro Eintrag
mul word [RootEntCnt]
div word [BytesPerSec]
mov cx,ax ;Anzahl der Sektoren für das Wurzelverzeichnis
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
add ax,[RsvdSecCnt] ;Startposition des Wurzelverzeichnisses nach ax
mov bx,7E00h ;nach 0000:7E00 das Wurzelverzeichnis laden
call ReadSectors
mov cx,[RootEntCnt]
mov di,7E00h
;search the filename
SearchFile:
push cx
mov cx,11 ;länge des Dateinamens
mov si,FileName
push di
rep cmpsb
pop di
pop cx
je LoadFAT
add di,32
loop SearchFile
jmp Error ;Datei nicht gefunden
LoadFAT:
mov dx,[di+001Ah] ;Startcluster der Datei
mov [FileCluster],dx
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
mov cx,ax ;Anzahl der Sektore für die beiden FAT-Tabellen
mov ax,[RsvdSecCnt] ;StartSektor der beiden FAT-Tabellen
mov bx,7E00h ;FAT-Tabellen nach 7E00h laden
call ReadSectors
;Lade Datei nach 1000:0000
mov ax,1000h
mov es,ax
xor bx,bx
push bx
LoadFile:
mov ax,[FileCluster]
pop bx
call CluSec ;Cluster zum Sektor umwandeln
mov cl,[SecPerClus]
xor ch,ch
call ReadSectors
push bx
;Aus FAT-Eintrag lesen (12 Bit)
mov ax,[FileCluster]
mov cx,ax
mov dx,ax
shr dx,1 ;durch zwei
add cx,dx
mov bx,7E00h
add bx,cx
mov dx,[bx]
test ax,0001h ;gerader oder ungerader Cluster?
jnz OddCluster ;ungerader Cluster
and dx,0FFFh
jmp Finish
OddCluster:
shr dx,4
Finish:
mov [FileCluster],dx
cmp dx,0FFFh ;letzter zu ladender Cluster der Datei?
jne LoadFile
pop bx
mov ax,1000h
mov ds,ax
mov es,ax
db 0EAh ;springe
dw 0000h ;Offset
dw 1000h ;Segment
;Datei wurde nicht gefunden
Error:
mov si,ErrorMsg
callWriteMsg
xor ah,ah
int 16h
;neu starten
db 0EAh
dw 0000h
dw 0FFFFh
WriteMsg:
lodsb
or al,al
jz WriteMsgBack
mov ah,0Eh
int 10h
jmp WriteMsg
WriteMsgBack:
ret
;input: ax = logischer Startsektor
; bx = Offsetadresse an dem die Sektoren geladen werden sollen
; cx = Anzahl der zu ladenden Sektore
; es = Segmentadresse an dem die Sektoren geladen werden sollen
;output: ax = letzter Sektor + 1
; bx = letze 512 Byte + 512
ReadSectors:
push ax
push bx
push cx
call LogPhySec
ReadSectors2:
mov ax,0201h ;ein Sektor laden
mov cl,[PhySector]
mov ch,[PhyTrack]
mov dl,[drive]
mov dh,[PhyPage]
int 13h
jc ReadSectors2
pop cx
pop bx
pop ax
add bx,[BytesPerSec]
inc ax
loop ReadSectors
ret
;input: ax = logischer Sektor
;output: ds:PhySec = physikalischer Sektor
; ds:PhyTrack = Spur
; ds:PhyPage = Seite
LogPhySec:
push ax
push dx
xor dx,dx
div word [SecPerTrack]
inc dl
mov [PhySector],dl
xor dx,dx
div word [NumHeads]
mov [PhyPage],dl
mov [PhyTrack],al
pop dx
pop ax
ret
;input: ax = Cluster
;output: ax = Sektor
CluSec:
push cx
push dx
sub ax,2 ;die ersten beiden Cluster-Einträge sind in der FAT reserviert
mov cl,[SecPerClus]
xor ch,ch
mul cx
mov cx,[RsvdSecCnt]
add ax,cx
push ax
mov ax,32
mul word [RootEntCnt]
div word [BytesPerSec]
mov cx,ax
pop ax
add ax,cx
push ax
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
mov dx,ax
pop ax
add ax,dx
pop dx
pop cx
ret
Msg db "LOST wird geladen...",00h
ErrorMsg db "LOST: Datei nicht gefunden.",0
FileName db "LOST SYS"
drive db 0
FileCluster dw 0
PhySector db 0
PhyTrack db 0
PhyPage db 0
times 510-($-$$) db 0
dw 0AA55h
-
hi,
ich weiss nicht, aber könntest du den Code vielleicht ein bisschen übersichtlicher gestalten.
Damit mein in mehr Labels einfügen und Code (per TAB z.B.) einrücken, da tut man sich dann um einiges einfacher beim lesen.
Oder liegt die Formatierung am Forum ? :roll:
mfg,
stefan
-
jaa ich gebe stefan2005 recht, gestalte deinen code bitte übersichtlicher (als positive Kritik gemeint)
hast du auch ev. ein listing davon? (mit nasm geht das schön)
damit du sagst wie viele bytes frei wären (ohne den times)
je nach dem kann man noch ein paar user pics reingeben
-
Wieso übersichtlicher? Der Code ist doch recht gut zu verstehen. Wie ihr die TAB-Sachen haben wollt kann ich ja nicht wissen. Ich habe doch extra Kommentare eingefügt. Du willst wissen wie viel Byte von den 510 noch frei sind? Also so wie der Code jetzt ist, wären noch 49 Byte frei.
bitmaster
-
hast du auch ev. ein listing davon? (mit nasm geht das schön)
Was meinst du damit? Was ist ein listing? Habe ich noch nie gehört. :oops:
je nach dem kann man noch ein paar user pics reingeben
Was meinst du damit?
bitmaster
-
also ein Listing kann beim compilieren erstellt werden, da siehst du neben allen befehlen die adressen der befehle und auch die assemblierung
also ungefähr so als würdest du etwas disassemblieren
bei nasm ist der parameter (glaub ich auswendig) "-l [Dateiname]"
mit user pics meine ich ein paar mehr-benutzerfreundliche sachen, eben wie z.B. Textausgabe, oder bei Fehlern eine Fehlerroutine mit Tastenabfragung (ja/nein), neue Versuche wenn etwas Fehlschlägt usw.
wegen der übersichtlichkeit, dass würde ich schon noch ändern
einrückung, abstände, kommentare, usw.
ich kann ja ev. den text "herrichten" wenn du es gestattest
ps: hab den code gerade flüchtig durchgelesen:
bei OSName (FAT BIOS Parameter Block) steht "L O S T", was du in "MSWIN4.1" ändern solltest, wegen der kompatibilität
-
also ein Listing kann beim compilieren erstellt werden, da siehst du neben allen befehlen die adressen der befehle und auch die assemblierung
also ungefähr so als würdest du etwas disassemblieren
bei nasm ist der parameter (glaub ich auswendig) "-l [Dateiname]"
Ach so, wie man das bei tasm auch machen kann. Ja, gut mache ich.
mit user pics meine ich ein paar mehr-benutzerfreundliche sachen, eben wie z.B. Textausgabe, oder bei Fehlern eine Fehlerroutine mit Tastenabfragung (ja/nein), neue Versuche wenn etwas Fehlschlägt usw.
Aber das verbraucht viele Bytes und davon haben wir nur noch 49 übrig.
wegen der übersichtlichkeit, dass würde ich schon noch ändern
einrückung, abstände, kommentare, usw.
ich kann ja ev. den text "herrichten" wenn du es gestattest
Ja, gerne.
ps: hab den code gerade flüchtig durchgelesen:
bei OSName (FAT BIOS Parameter Block) steht "L O S T", was du in "MSWIN4.1" ändern solltest, wegen der kompatibilität
Nein da steht nicht "L O S T", sondern "L O S T ". Es sind genau 8 Byte die eingehalten werden müssen. Was da steht ist egal.
bitmaster
-
So hier ist das Listing, was ihr unbedingt haben wolltet:
1 ;Bootstrap für LOST assemblieren mit nasm
2
3 org 7C00h
4
5 00000000 E93B00 jmp EndBPB ;unter dem BIOS-Parameter-Block
6
7 00000003 4C204F2053205420 OSName db "L O S T "
8 0000000B 0002 BytesPerSec dw 512
9 0000000D 01 SecPerClus db 1
10 0000000E 0100 RsvdSecCnt dw 1
11 00000010 02 NumFATs db 2
12 00000011 E000 RootEntCnt dw 224
13 00000013 400B TotSec dw 2880
14 00000015 F0 MediaType db 0F0h
15 00000016 0900 FATsize dw 9
16 00000018 1200 SecPerTrack dw 18
17 0000001A 0200 NumHeads dw 2
18 0000001C 00000000 HiddenSec dd 0
19 00000020 00000000 TotSec32 dd 0
20 00000024 00 DrvNum db 0
21 00000025 00 Reserved db 0
22 00000026 29 ExBPSign db 29h ;keine Ahnung wofür das ist
23 00000027 FFFFFFFF VolumeID dd 0FFFFFFFFh
24 0000002B 4C4F53542020202020- DiskLabel db "LOST "
25 00000034 2020
26 00000036 4641543132202020 FileSysType db "FAT12 "
27
28 EndBPB:
29 0000003E FA cli
30 0000003F 31C0 xor ax,ax
31 00000041 8ED8 mov ds,ax
32 00000043 8EC0 mov es,ax
33 00000045 8ED0 mov ss,ax
34 00000047 BCFFFF mov sp,0FFFFh
35 0000004A FB sti
36
37 0000004B 8816[C901] mov [drive],dl ;Laufwerk
38
39 ;load rootdirectory
40 0000004F B82000 mov ax,32 ;32 Byte pro Eintrag
41 00000052 F726[1100] mul word [RootEntCnt]
42 00000056 F736[0B00] div word [BytesPerSec]
43 0000005A 89C1 mov cx,ax ;Anzahl der Sektoren für das Wurzelverzeichnis
44
45 0000005C A0[1000] mov al,[NumFATs]
46 0000005F 30E4 xor ah,ah
47 00000061 F726[1600] mul word [FATsize]
48 00000065 0306[0E00] add ax,[RsvdSecCnt] ;Startposition des Wurzelverzeichnisses nach ax
49
50 00000069 BB007E mov bx,7E00h ;nach 0000:7E00 das Wurzelverzeichnis laden
51 0000006C E8A200 call ReadSectors
52
53 0000006F 8B0E[1100] mov cx,[RootEntCnt]
54 00000073 BF007E mov di,7E00h
55
56 ;search the filename
57 SearchFile:
58 00000076 51 push cx
59 00000077 B90B00 mov cx,11 ;länge des Dateinamens
60 0000007A BE[BE01] mov si,FileName
61 0000007D 57 push di
62 0000007E F3A6 rep cmpsb
63 00000080 5F pop di
64 00000081 59 pop cx
65 00000082 7409 je LoadFAT
66 00000084 81C72000 add di,32
67 00000088 E2EC loop SearchFile
68 0000008A E96C00 jmp Error ;Datei nicht gefunden
69
70 LoadFAT:
71 0000008D 8B551A mov dx,[di+001Ah] ;Startcluster der Datei
72 00000090 8916[CA01] mov [FileCluster],dx
73 00000094 A0[1000] mov al,[NumFATs]
74 00000097 30E4 xor ah,ah
75 00000099 F726[1600] mul word [FATsize]
76 0000009D 89C1 mov cx,ax ;Anzahl der Sektore für die beiden FAT-Tabellen
77 0000009F A1[0E00] mov ax,[RsvdSecCnt] ;StartSektor der beiden FAT-Tabellen
78 000000A2 BB007E mov bx,7E00h ;FAT-Tabellen nach 7E00h laden
79 000000A5 E86900 call ReadSectors
80
81 ;Lade Datei nach 1000:0000
82 000000A8 B80010 mov ax,1000h
83 000000AB 8EC0 mov es,ax
84 000000AD 31DB xor bx,bx
85 000000AF 53 push bx
86
87 LoadFile:
88 000000B0 A1[CA01] mov ax,[FileCluster]
89 000000B3 5B pop bx
90 000000B4 E8A000 call CluSec ;Cluster zum Sektor umwandeln
91 000000B7 8A0E[0D00] mov cl,[SecPerClus]
92 000000BB 30ED xor ch,ch
93 000000BD E85100 call ReadSectors
94 000000C0 53 push bx
95
96 ;Aus FAT-Eintrag lesen (12 Bit)
97 000000C1 A1[CA01] mov ax,[FileCluster]
98 000000C4 89C1 mov cx,ax
99 000000C6 89C2 mov dx,ax
100 000000C8 D1EA shr dx,1 ;durch zwei
101 000000CA 01D1 add cx,dx
102 000000CC BB007E mov bx,7E00h
103 000000CF 01CB add bx,cx
104 000000D1 8B17 mov dx,[bx]
105 000000D3 A90100 test ax,0001h ;gerader oder ungerader Cluster?
106 000000D6 7507 jnz OddCluster ;ungerader Cluster
107 000000D8 81E2FF0F and dx,0FFFh
108 000000DC E90300 jmp Finish
109
110 OddCluster:
111 000000DF C1EA04 shr dx,4
112
113 Finish:
114 000000E2 8916[CA01] mov [FileCluster],dx
115 000000E6 81FAFF0F cmp dx,0FFFh ;letzter zu ladender Cluster der Datei?
116 000000EA 75C4 jne LoadFile
117 000000EC 5B pop bx
118
119 000000ED B80010 mov ax,1000h
120 000000F0 8ED8 mov ds,ax
121 000000F2 8EC0 mov es,ax
122
123 000000F4 EA db 0EAh ;springe
124 000000F5 0000 dw 0000h ;Offset
125 000000F7 0010 dw 1000h ;Segment
126
127 ;Datei wurde nicht gefunden
128 Error:
129 000000F9 BE[A201] mov si,ErrorMsg
130 callWriteMsg
131 000000FC 30E4 xor ah,ah
132 000000FE CD16 int 16h
133 ;neu starten
134 00000100 EA db 0EAh
135 00000101 0000 dw 0000h
136 00000103 FFFF dw 0FFFFh
137
138 WriteMsg:
139 00000105 AC lodsb
140 00000106 08C0 or al,al
141 00000108 7406 jz WriteMsgBack
142 0000010A B40E mov ah,0Eh
143 0000010C CD10 int 10h
144 0000010E EBF5 jmp WriteMsg
145
146 WriteMsgBack:
147 00000110 C3 ret
148
149 ;input: ax = logischer Startsektor
150 ; bx = Offsetadresse an dem die Sektoren geladen werden sollen
151 ; cx = Anzahl der zu ladenden Sektore
152 ; es = Segmentadresse an dem die Sektoren geladen werden sollen
153 ;output: ax = letzter Sektor + 1
154 ; bx = letze 512 Byte + 512
155 ReadSectors:
156 00000111 50 push ax
157 00000112 53 push bx
158 00000113 51 push cx
159 00000114 E82200 call LogPhySec
160 ReadSectors2:
161 00000117 B80102 mov ax,0201h ;ein Sektor laden
162 0000011A 8A0E[CC01] mov cl,[PhySector]
163 0000011E 8A2E[CD01] mov ch,[PhyTrack]
164 00000122 8A16[C901] mov dl,[drive]
165 00000126 8A36[CE01] mov dh,[PhyPage]
166 0000012A CD13 int 13h
167 0000012C 72E9 jc ReadSectors2
168 0000012E 59 pop cx
169 0000012F 5B pop bx
170 00000130 58 pop ax
171 00000131 031E[0B00] add bx,[BytesPerSec]
172 00000135 40 inc ax
173 00000136 E2D9 loop ReadSectors
174 00000138 C3 ret
175
176 ;input: ax = logischer Sektor
177 ;output: ds:PhySec = physikalischer Sektor
178 ; ds:PhyTrack = Spur
179 ; ds:PhyPage = Seite
180 LogPhySec:
181 00000139 50 push ax
182 0000013A 52 push dx
183 0000013B 31D2 xor dx,dx
184 0000013D F736[1800] div word [SecPerTrack]
185 00000141 FEC2 inc dl
186 00000143 8816[CC01] mov [PhySector],dl
187 00000147 31D2 xor dx,dx
188 00000149 F736[1A00] div word [NumHeads]
189 0000014D 8816[CE01] mov [PhyPage],dl
190 00000151 A2[CD01] mov [PhyTrack],al
191 00000154 5A pop dx
192 00000155 58 pop ax
193 00000156 C3 ret
194
195 ;input: ax = Cluster
196 ;output: ax = Sektor
197 CluSec:
198 00000157 51 push cx
199 00000158 52 push dx
200 00000159 2D0200 sub ax,2 ;die ersten beiden Cluster-Einträge sind in der FAT reserviert
201 0000015C 8A0E[0D00] mov cl,[SecPerClus]
202 00000160 30ED xor ch,ch
203 00000162 F7E1 mul cx
204 00000164 8B0E[0E00] mov cx,[RsvdSecCnt]
205 00000168 01C8 add ax,cx
206 0000016A 50 push ax
207 0000016B B82000 mov ax,32
208 0000016E F726[1100] mul word [RootEntCnt]
209 00000172 F736[0B00] div word [BytesPerSec]
210 00000176 89C1 mov cx,ax
211 00000178 58 pop ax
212 00000179 01C8 add ax,cx
213 0000017B 50 push ax
214 0000017C A0[1000] mov al,[NumFATs]
215 0000017F 30E4 xor ah,ah
216 00000181 F726[1600] mul word [FATsize]
217 00000185 89C2 mov dx,ax
218 00000187 58 pop ax
219 00000188 01D0 add ax,dx
220 0000018A 5A pop dx
221 0000018B 59 pop cx
222 0000018C C3 ret
223
224 0000018D 4C4F53542077697264- Msg db "LOST wird geladen...",00h
225 00000196 2067656C6164656E2E-
226 0000019F 2E2E00
227 000001A2 4C4F53543A20446174- ErrorMsg db "LOST: Datei nicht gefunden.",0
228 000001AB 6569206E6963687420-
229 000001B4 676566756E64656E2E-
230 000001BD 00
231 000001BE 4C4F53542020202053- FileName db "LOST SYS"
232 000001C7 5953
233 000001C9 00 drive db 0
234 000001CA 0000 FileCluster dw 0
235 000001CC 00 PhySector db 0
236 000001CD 00 PhyTrack db 0
237 000001CE 00 PhyPage db 0
238
239 000001CF 00<rept> times 510-($-$$) db 0
240 000001FE 55AA dw 0AA55h
-
;Bootstrap für LOST assemblieren mit nasm
org 7C00h
jmp EndBPB ;unter dem BIOS-Parameter-Block
OSName db "L O S T " ;"MSWIN4.1"?
BytesPerSec dw 512
SecPerClus db 1
RsvdSecCnt dw 1
NumFATs db 2
RootEntCnt dw 224
TotSec dw 2880
MediaType db 0F0h
FATsize dw 9
SecPerTrack dw 18
NumHeads dw 2
HiddenSec dd 0
TotSec32 dd 0
DrvNum db 0
Reserved db 0
ExBPSign db 29h ;keine Ahnung wofuer das ist
VolumeID dd 0FFFFFFFFh
DiskLabel db "LOST "
FileSysType db "FAT12 "
EndBPB:
cli
xor ax,ax
mov ds,ax
mov es,ax
mov ss,ax
mov sp,0FFFFh
sti
mov [drive],dl ;Laufwerk
;load rootdirectory
mov ax,32 ;32 Byte pro Eintrag
mul word [RootEntCnt]
div word [BytesPerSec]
mov cx,ax ;Anzahl der Sektoren für das Wurzelverzeichnis
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
add ax,[RsvdSecCnt] ;Startposition des Wurzelverzeichnisses nach ax
mov bx,7E00h ;nach 0000:7E00 das Wurzelverzeichnis laden
call ReadSectors
mov cx,[RootEntCnt]
mov di,7E00h
;search the filename
SearchFile:
push cx
mov cx,11 ;länge des Dateinamens
mov si,FileName
push di
rep cmpsb
pop di
pop cx
je LoadFAT
add di,32
loop SearchFile
jmp Error ;Datei nicht gefunden
LoadFAT:
mov dx,[di+001Ah] ;Startcluster der Datei
mov [FileCluster],dx
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
mov cx,ax ;Anzahl der Sektore für die beiden FAT-Tabellen
mov ax,[RsvdSecCnt] ;StartSektor der beiden FAT-Tabellen
mov bx,7E00h ;FAT-Tabellen nach 7E00h laden
call ReadSectors
;Lade Datei nach 1000:0000
mov ax,1000h
mov es,ax
xor bx,bx
push bx
LoadFile:
mov ax,[FileCluster]
pop bx
call CluSec ;Cluster zum Sektor umwandeln
mov cl,[SecPerClus]
xor ch,ch
call ReadSectors
push bx
;Aus FAT-Eintrag lesen (12 Bit)
mov ax,[FileCluster]
mov cx,ax
mov dx,ax
shr dx,1 ;durch zwei
add cx,dx
mov bx,7E00h
add bx,cx
mov dx,[bx]
test ax,0001h ;gerader oder ungerader Cluster?
jnz OddCluster ;ungerader Cluster
and dx,0FFFh
jmp Finish
OddCluster:
shr dx,4
Finish:
mov [FileCluster],dx
cmp dx,0FFFh ;letzter zu ladender Cluster der Datei?
jne LoadFile
pop bx
mov ax,1000h
mov ds,ax
mov es,ax
db 0EAh ;springe
dw 0000h ;Offset
dw 1000h ;Segment
;Datei wurde nicht gefunden
Error:
mov si,ErrorMsg
callWriteMsg
xor ah,ah
int 16h
;neu starten
db 0EAh
dw 0000h
dw 0FFFFh
WriteMsg:
lodsb
or al,al
jz WriteMsgBack
mov ah,0Eh
int 10h
jmp WriteMsg
WriteMsgBack:
ret
;input: ax = logischer Startsektor
; bx = Offsetadresse an dem die Sektoren geladen werden sollen
; cx = Anzahl der zu ladenden Sektore
; es = Segmentadresse an dem die Sektoren geladen werden sollen
;output: ax = letzter Sektor + 1
; bx = letze 512 Byte + 512
ReadSectors:
push ax
push bx
push cx
call LogPhySec
ReadSectors2:
mov ax,0201h ;ein Sektor laden
mov cl,[PhySector]
mov ch,[PhyTrack]
mov dl,[drive]
mov dh,[PhyPage]
int 13h
jc ReadSectors2
pop cx
pop bx
pop ax
add bx,[BytesPerSec]
inc ax
loop ReadSectors
ret
;input: ax = logischer Sektor
;output: ds:PhySec = physikalischer Sektor
; ds:PhyTrack = Spur
; ds:PhyPage = Seite
LogPhySec:
push ax
push dx
xor dx,dx
div word [SecPerTrack]
inc dl
mov [PhySector],dl
xor dx,dx
div word [NumHeads]
mov [PhyPage],dl
mov [PhyTrack],al
pop dx
pop ax
ret
;input: ax = Cluster
;output: ax = Sektor
CluSec:
push cx
push dx
sub ax,2 ;die ersten beiden Cluster-Einträge sind in der FAT reserviert
mov cl,[SecPerClus]
xor ch,ch
mul cx
mov cx,[RsvdSecCnt]
add ax,cx
push ax
mov ax,32
mul word [RootEntCnt]
div word [BytesPerSec]
mov cx,ax
pop ax
add ax,cx
push ax
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
mov dx,ax
pop ax
add ax,dx
pop dx
pop cx
ret
Msg db "LOST wird geladen...",00h
ErrorMsg db "LOST: Datei nicht gefunden.",0
FileName db "LOST SYS"
drive db 0
FileCluster dw 0
PhySector db 0
PhyTrack db 0
PhyPage db 0
times 510-($-$$) db 0
dw 0AA55h
-
Hi
ggf gibts noch ein paar optimierungsmöglichkeiten, wenn euch der platz ausgeht. z.b. die verwendung von popa und pusha anstelle von 2 oder 3 einzelnen pop odre push aufrufen.
gruss
-
ich hab mal ne frage ich hab mich noch nit fs's beschäftigt: was für ne datei ist diese lost.sys ist das ne asm-file oda ne gelinkte file oda was
-
hab grad ein bisschen umgeschrieben, ist noch nicht fertig
ein paar fehler hab ich gesehen und sind noch drin
; der Bootloader von CommOS
org 7C00h
jmp Bootloader ; überspringe den BIOS Parameter Block (FAT Infos)
OSName db "MSWIN4.1" ; der Name des Betriebsystems, aus Kompatibilitätsgründen (Erkennung von FAT) "MSWIN4.1"
BytesPerSec dw 512
SecPerClus db 1
RsvdSecCnt dw 1
NumFATs db 2
RootEntCnt dw 224
TotSec dw 2880
MediaType db 0F0h
FATsize dw 9
SecPerTrack dw 18 ; Sektoren pro Spur, üblicherweise 18 bei Disketten
NumHeads dw 2
HiddenSec dd 0
TotSec32 dd 0
DrvNum db 0
Reserved db 0
ExBPSign db 29h ; Bootsignatur, gibt an dass folgende 3 Felder vorhanden sind
VolumeID dd 0FFFFFFFFh ; Disketten serial number (ID)
DiskLabel db "LOST DISK 1"
FileSysType db "FAT12 " ; hier kommt FAT12 hin, ein paar ältere treiber determinieren so die FAT Version
Bootloader:
; deaktiviere Interrupts und setzte Richtung für string Befehle (von links nach rechts)
cli
cld
; setze alle daten segment register (ds, es und ss) zu adresse 0000, und den stack pointer zu offset FFFF
xor ax,ax
mov ds,ax
mov es,ax
mov ss,ax
mov sp,0FFFFh
; speichere das boot laufwerk
mov [drive],dl
; check if the drive is not supported by Interrupt 13h
test dh,00100000b
jnz Drive_Error
; lade das root directory
imul ax, word [RootEntCnt], 32 ; ax = 32 bytes per entry * RootEntCnt
xor dx,dx
div word [BytesPerSec] ; ax / bytes per sector
mov cx,ax ; -> Anzahl der Sektoren für das Wurzelverzeichnis
; round up if edx isn't zero (shoudn't be, but if other BIOS Parameter Block)
or dx,dx
jz sectors_ok
inc ax
sectors_ok:
; now read the sectors of the root directory to address 0000:7E00
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
add ax,[RsvdSecCnt] ; Startposition des Wurzelverzeichnisses
mov bx,7E00h
call Read_Sectors ; use Interrupt ?
mov cx,[RootEntCnt] ; ecx = counter (count of entries in the root directory)
mov di,7E00h
Search_File: ; search the file
push ecx
mov ecx,11 ; länge des Dateinamens (8.3)
mov esi,File_OSLoader
push edi
repne cmpsb ; repeat until the first unequal letter is found, oder alle 11 buchstaben durchgecheckt sind
pop edi
pop ecx
je Load_FAT ; wenn sie (alle) gleich sind, dann ist die Datei gefunden
add di,32
loop Search_File
jmp File_not_found ; wenn hier, dann keine Einträge mehr, -> datei nicht gefunden
Load_FAT:
mov dx,[di+001Ah] ;Startcluster der Datei
mov [FileCluster],dx
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
mov cx,ax ;Anzahl der Sektore für die beiden FAT-Tabellen
mov ax,[RsvdSecCnt] ;StartSektor der beiden FAT-Tabellen
mov bx,7E00h ;FAT-Tabellen nach 7E00h laden
call ReadSectors
; Lade Datei nach 1000:0000
mov ax,1000h
mov es,ax
xor bx,bx
push bx
LoadFile:
mov ax,[FileCluster]
pop bx
call CluSec ;Cluster zum Sektor umwandeln
mov cl,[SecPerClus]
xor ch,ch
call ReadSectors
push bx
;Aus FAT-Eintrag lesen (12 Bit)
mov ax,[FileCluster]
mov cx,ax
mov dx,ax
shr dx,1 ;durch zwei
add cx,dx
mov bx,7E00h
add bx,cx
mov dx,[bx]
test ax,0001h ;gerader oder ungerader Cluster?
jnz OddCluster ;ungerader Cluster
and dx,0FFFh
jmp Finish
OddCluster:
shr dx,4
Finish:
mov [FileCluster],dx
cmp dx,0FFFh ;letzter zu ladender Cluster der Datei?
; wrong EOC !!!!!!
jne LoadFile
pop bx
mov ax,1000h
mov ds,ax
mov es,ax
; reboot ?
db 0EAh ;springe
dw 0000h ;Offset
dw 1000h ;Segment
;input: ax = logischer Startsektor
; bx = Offsetadresse an dem die Sektoren geladen werden sollen
; cx = Anzahl der zu ladenden Sektore
; es = Segmentadresse an dem die Sektoren geladen werden sollen
;output: ax = letzter Sektor + 1
; bx = letze 512 Byte + 512
ReadSectors:
push ax
push bx
push cx
call LogPhySec
ReadSectors2:
mov ax,0201h ;ein Sektor laden
mov cl,[PhySector]
mov ch,[PhyTrack]
mov dl,[drive]
mov dh,[PhyPage]
int 13h
jc ReadSectors2
pop cx
pop bx
pop ax
add bx,[BytesPerSec]
inc ax
loop ReadSectors
ret
;input: ax = logischer Sektor
;output: ds:PhySec = physikalischer Sektor
; ds:PhyTrack = Spur
; ds:PhyPage = Seite
LogPhySec:
push ax
push dx
xor dx,dx
div word [SecPerTrack]
inc dl
mov [PhySector],dl
xor dx,dx
div word [NumHeads]
mov [PhyPage],dl
mov [PhyTrack],al
pop dx
pop ax
ret
;input: ax = Cluster
;output: ax = Sektor
CluSec:
push cx
push dx
sub ax,2 ;die ersten beiden Cluster-Einträge sind in der FAT reserviert
mov cl,[SecPerClus]
xor ch,ch
mul cx
mov cx,[RsvdSecCnt]
add ax,cx
push ax
mov ax,32
mul word [RootEntCnt]
div word [BytesPerSec]
mov cx,ax
pop ax
add ax,cx
push ax
mov al,[NumFATs]
xor ah,ah
mul word [FATsize]
mov dx,ax
pop ax
add ax,dx
pop dx
pop cx
ret
Drive_Error: ; Error Handler wenn das Boot-Laufwerk ungültig ist (z.B. USB Stick, oder CD ROM)
mov esi,MSG_Drive_Error
call Print_Text
jmp Reboot_keypress
File_not_found: ; Error Handler wenn Datei nicht gefunden wurde
mov esi,MSG_not_found
call Print_Text
;jmp Reboot_keypress
Reboot_keypress:
; reboot after a key press
xor ah,ah
Int 16h
; folgender Code startet den Computer neu (springt zum BIOS reboot)
; this code jumps to the BIOS reboot
db 0EAh
dw 0000h
dw 0FFFFh
; a function to write a text onto the screen (ds:esi = text)
Print_Text:
mov bx,0007h ; Page Number = 0, Attribute = 07h
mov ah,0Eh ; function 0Eh: Teletype Output
lodsb ; load the first character
Next_Char:
int 10h
lodsb ; AL = next character
cmp AL,00h ; last letter?
jne Next_Char ; if not print next letter
ret
MSG_load db "LOST wird geladen...", 10, 13
MSG_not_found db "LOST: Datei nicht gefunden.", 10, 13
MSG_Drive_Error db "Invalid drive", 10, 13
File_OSLoader db "LOST SYS"
drive db 0
FileCluster dw 0
PhySector db 0
PhyTrack db 0
PhyPage db 0
times 510-($-$$) db 0
dw 0AA55h
-
aws für ne file issen nu die lost.sys ; bitmaster(vor allem an dicgh gerichtet weil du das sagtest:..)(aber auch an alle anderen:.)
-
aws für ne file issen nu die lost.sys ; bitmaster(vor allem an dicgh gerichtet weil du das sagtest:..)(aber auch an alle anderen:.)
Die lost.sys ist ein Beispiel. Diese Datei gibt es noch gar nicht. Je nachdem was wir jetzt machen. Direkt den kernel laden (dann ist dies der kernel) oder erst einen OS-Loader (dann ist dies der OS-Loader).
bitmaster
-
thx ....