Nachrichten

1

Lowlevel-Coding / Re: Bochs LBA support

« am: 04. September 2012, 18:00 »

So es funktioniert bei Qemu falls man die .bin datei als erstes HDD angibt.

2

Lowlevel-Coding / Re: Von Festplatte booten

« am: 04. September 2012, 17:54 »

So vielen Dank ich sehe dieses Thema als abgeschlossen an ich glaube ich weiß jetzt genug um einen funktionierenden MBR+Bootloader zum laufen zu bringen. Vielen Dank an alle die mir geholfen habe ich wünsche euch noch einen schönen Abend außerdem nochmal danke für die Nachsicht bei nicht sehr informationsvollen Posts
MfG Dezimiert

3

Lowlevel-Coding / Re: Von Festplatte booten

« am: 04. September 2012, 15:58 »

Ahh Erkenntnis da lag mein Fehler. Ich dachte die ganze Zeit das meine Partitionstabelle vom BIOS aufgefüllt wird. Hmm na ja danke für die Hinweise jetzt noch eine letzte Frage dann habe ich genug zeit zum versuchen für die nächsten paar Wochen . Wenn ich nun weiß das eine Partition bei 100000h liegt( 1 Megabyte ) wie kann ich dann meinen Bootloader beziehungsweise Kernel an diese Stelle schreiben?

4

Lowlevel-Coding / Re: Von Festplatte booten

« am: 04. September 2012, 13:32 »

Vielen Dank xD also erstmal Linux besorgen und auf die zweite Festplatte machen. Allerdings verstehe ich nicht warum den mbr nur 448 bytes groß? Ich dachte das die bytes nach den 448 bytes sowieso vom BIOS ausgefüllt werden, also wo ist der Unterschied dazu ob ich diese Bytes noch benutze oder nicht? Außerdem sollte doh bei 512 Bytes die Bootsignatur auch beim MBR stehen oder? Und wie finde ich heraus wo eine Partition anfängt, das heißt wo ich dann den eigentlich bootloader hinkopieren soll?
Vielen Dank wieder was neues gelernt, Ich kram dann einfach mal nen anderen USB Stick raus von dem ich boote. Da soweit ich weiß der Bootvorgang beim USB-Stick sowie bei einer SATA Festplatte fast das gleiche ist wäre es wohl auch auf eine SATA Festplkatte zu übertragen.

5

Lowlevel-Coding / Re: Von Festplatte booten

« am: 03. September 2012, 21:42 »

Meinst du damit, dass QEMU den von dir geposteten Code nicht startet?

Ja stimmt ich verstehe nicht warum Qemu meinen Code nicht startet, habe den Wert 0x01BD verbessert. Falls ich nicht versuche die Festplatte zu starten sondern als erstes HDD meine Binary datei angebe funktioniert es d. h. der Code wird gestartet, da keine bootbare Partition im MBR vorhanden ist gibt er die Kontrolle wieder an Qemu. Es muss also ein Fehler sein beim kopieren der Binary datei auf die Festplatte, möglicherweise weil ich einen 512 Byte MBR habe und die Festplatte nativ 4k Sektoren hat?

6

Lowlevel-Coding / Re: Von Festplatte booten

« am: 03. September 2012, 21:28 »

Ich werde ebenfalls kein OS auf meinen eigenen MBR aufsetzen ich wollte nur einmal einen funktionierenden schreiben, schönen Abend noch.
MfG Dezimiert

7

Lowlevel-Coding / Re: Von Festplatte booten

« am: 03. September 2012, 21:14 »

Ich stimme dir zu es ist vollkommen sinnlos es auf diese Weise zu machen
Ich würde trotzdem sehr gerne die Prinzipien von sowas lernen, da ich Betriebsystem/Bootloader Programmierung nur als Hobby betreibe geht es mir größtenteils darum zu lernen wie es funktioniert, ob ich es irgend wann mal brauche sei mal dahingestellt. Die zweite Festplatte ist nur gekauft um darauf mein Betirebssystem zu installieren, d. h. ich werde einen Teufel tun und bei meiner Windows Festplatte irgendwas zu überschreiben, allerdings kann ich ja auf der zweiten Festplatte einen eigenen MBR einrichten.

Aha, die Festplatte ist also extern und vermutlich per USB angebunden, außerdem benutzt du Windows. Schonmal zwei Informationen, die im Ursprungsartikel fehlen.

Bin noch dabei an meinen Beiträgen inhaltlich sowie sprachlich zu feilen

Vermutlich funktionierte das nicht.

Gut möglich daher frage ich ja euch ich dachte nur da dd keine Fehlermeldung ausgegeben hat das es wohl funktioniert.

Ich werde in den MBR etwas einbauen damit er ein Zeichen anzeigt.

Diese Meldung ist in deinem Code nicht drin. Also wird der überhaupt nicht ausgeführt. Im Übrigen ist es durchaus sinnvoll, wenn dein MBR auch ein paar Meldungen ausgeben kann (und wenn es ein sich veränderndes Zeichen in der oberen linken Ecke ist) - dann weiß man auf realen Systemen wenigstens, wo er hängt.

Da stimme ich dir zu und ich weiß einfach nicht woran es liegt, dass Qemu nicht mal den MBR startet, daher habe ich den Code gepostet und meine Methode die Binary Datei auf einen Festplatte zu kopieren.

MfG Dezimiert

8

Lowlevel-Coding / Re: Von Festplatte booten

« am: 03. September 2012, 20:35 »

Da hast du natürlich vollkommen recht, so habe den MBR nochmal überarbeitet er arbeitet jetzt mit festen Addressen im Arbeitsspeicher:

Code: [Auswählen]

;Master Boot Record Test Version 0.0.1
;The BIOS load the MBR to the Address 0x7c00
;The CPU is in Real Mode
[BITS 16]
org 7c00h
mov ax,0x9000 ;We set the Stack to 0x9000
mov ss,ax       ;Intialize Stacksegment
xor sp,sp       ;Set the stackpointer to zero

xor ax,ax       ;Setup segments we only work with offsets so we set the segments to zero
mov ds,ax
mov es,ax

mov di,0x0500          ;We write our structures to the Address 0x0500
mov si,PartitionTable  ;We want to write fist the partition Table
mov cx,32              ;We want to transfer 32 words
rep movsw              ;Transfer the Data

;The next 16 are reserved for the LBA packet
add di,0x0500           ;Load the address again
add di,80               ;We add 80 because PartitionTable = 64 bytes LBA packet = 16 bytes = 80 Bytes
mov byte[di],dl         ;Store the Bootdrive

mov di,0x0600           ;Our C0ode we will write to the Address 0x0600
mov si,ExecutableCode   ;
mov cx,EndOfCode-ExecutableCode
rep movsb               ;Write the Code to the right Address
jmp 0x0000:0x0600       ;Let's go


ExecutableCode:
mov di,0x0500      ;Load the Address of our Structures
mov cl,0           ;In cl we store the number of our Attempts

.NextPartition:
add di,16      ;One entry in the Partition Table is 16 bytes width so we add that value to get the next entry
inc cl         ;We increase our Attempts
cmp cl,3       ;If we have read 4 Partition Table entrys we must quit
ja .NoPartitionBootable ;We only have 4 entry in the Partition Table so we must quit
.VerifyBootability:
mov al,0x80     
cmp al,byte[di]  ;We try if the Partition is bootable so we compare the first byte of the entry with 0x80
jne .NextPartition ;okay it's not bootable so try the next Partition

;Yeah it's bootable first we will try the int 13h extension support
mov ax,0x4100    ;We use BIOS funktion 41h for that
mov bx,0x55AA    ;Setup the other Parameters
mov dl,byte[0500h+80] ;get the Bootdrive from our Structures
int 13h          ;Make the Call
jc .NoPartitionBootable ;If int 13h extension is not supported we quit

;int 13h extension is supported so we setup the lba packet
mov si,di        ;Get the address of the partition entry which is bootable
mov di,0x0500    ;Get the address of our structures
add di,64        ;Set the Address to the begin of our LBA Packet
mov byte[di],16 ;We setup the Size of the Packet its 16 bytes
;mov byte[di+1],0 This byte will be ignored anyway so we don't need to set it
mov word[di+2],1 ;We only read one sector its the bootsektor
mov dword[di+4],0x00007c00 ;We set the low 16 bits to 0x7c00 and the high 16 bits to 0x0000 so we will load it to the correct address

mov ax,word[si+8]  ;in si we stored the Value of the Partition wich we will use we store the low 16 bits of our lba address in ax
mov bx,word[si+10] ;We store the high 16 bits in bx

mov word[di+8],ax  ;First we write the low 16 bits in the packet
mov word[di+10],bx ;Then we store the high 16 bits in the packet

mov dword[di+12],0 ;We don't use the high lba address

push si                     ;Push the address of our partition entry that we will store later in di
mov ax,0x4200
mov dl,byte[0500h+80] ;get the Bootdrive from our Structures
mov si,0500h+64        ;Get the address of our packet
int 13h              ;Load it to the right address
pop di             ;Set es:di to the partition entry which we use
mov dl,byte[0500h+80] ;get the Bootdrive from our Structures
jmp 0x0000:0x7c00    ;Jump to the bootsektor


.NoPartitionBootable:
int 18h       ;Tell the BIOS that we fail and give the control back to it





EndOfCode:
times 0x01BD-($-$$) hlt
PartitionTable times 64 db 0          ;We need the 64 Bytes for the Partition Table
times 510-($-$$) hlt
db 0x55
db 0xAA

So dieser Code sollte klappen, leider schreibt Qemu unbeirrt weiter "No bootable Partition in table". Vielleicht könnte ja mal jemand anderes den Code compilieren und versuchen auszuführen? Vielleicht liegt es ja nur an meiner Unfähigkeit Qemu richtig zu nutzen. Vielen Dank an Jidder,taljeth und Svenska dank euch bin ich schon viel weiter als am Anfang
MfG Dezimiert.

9

Lowlevel-Coding / Re: Von Festplatte booten

« am: 03. September 2012, 16:44 »

Da haben wir den Fehler ja schon...

Ja ich schreibe aber sehr gerne alles selbst

Wo kommt diese Meldung her? Dein Code scheint sie nicht auszugeben.

Mit welchen Optionen startest du qemu?

Ich benutze den Qemu Manager für Windows, daher bin ich mir nicht sicher welche optionen benuzt werden 
Den Code gibt Qemu aus, ich habe die externe Festplatte( USB ) als erstes HDD angegeben, mein MBR wird gar nicht aufgerufen, daher war ich mir nicht sicher ob ich den MBR richtig auf die externe Festplatte kopiert habe.

Externe Festplatte heißt was genau? USB?

Genau eine über USB angeschlossene Festplatte.

10

Lowlevel-Coding / Re: Von Festplatte booten

« am: 03. September 2012, 13:49 »

Ja da hast du natürlich recht 
Ich wollte die Betriebssystem welche ich schreibe auf echter Hardware testen, da mein PC kein Floppy Laufwerk mehr hat muss ich das Betriebssystem von meiner zweiten externen Festplatte starten. Ich benutze kerin GRUB, da ich das lieber selbst schreiben will
Also bezieht sich meine eigentliche Frage darauf ob ich mein MBR den ich geschreiben habe funktioniert, da Qemu leider immer den Fehler ausgibt: "No bootable Partition in table". Ich poste mal meinen MBR Code da ich mir nicht erklären kann was daran falsch ist.

Code: [Auswählen]

;Master Boot Record Test Version 0.0.1
;The BIOS load the MBR to the Address 0x7c00
;The CPU is in Real Mode
[BITS 16]
org 7c00h
mov ax,0x9000 ;We set the Stack to 0x9000
mov ss,ax       ;Intialize Stacksegment
xor sp,sp       ;Set the stackpointer to zero

xor ax,ax       ;We only works with offsets so we set the ds and the es to zero
mov ds,ax
mov es,ax
mov byte[Bootdrive],dl


        ;We want to copy our code to 0x0000:0x0600
mov di, 0x0600               
mov si,ExecutableCode
mov cx,EOF-ExecutableCode      ;Load the Size of the Section wich we want to copy
rep movsb                                ;Copy it
jmp 0x0000:0x0600                   ;Execute it


ExecutableCode:
mov di,Part1Bootflag
jmp Bootable_loop
Bootable_Prep:
add di,16
cmp di,Part4Bootflag
ja NoPartBootable
Bootable_loop:
;Now we are at the right position
        mov al,0x80
cmp al,byte[di]  ;bootable?
jnz Bootable_Prep  ;No then test the next
;yes its bootable

;First we try if we have the BIOS int 13h extension
mov ax,0x4100
mov dl,byte[Bootdrive]
mov bx,0x55AA
int 13h                  ;Try the support
jc NoPartBootable        ;If the extension is not supported we quit cause we know that Qemu and the most of the hardware will support it
;TODO: This MBR should be more optimized with CHS support
Again:
mov ax,0
mov dl,byte[Bootdrive]
int 13h                      ;Reset Drive


mov byte[PacketSize],16
mov word[Blockcount],0
mov dword[BufferAddr],0x7C00  ;We have an Little endian system so we write to the low 16 bits(offset bits) 0x7c00 and to the higher 0x0000 because we don't use segments
mov ax,word[di+8]             ;Save the low 16 bits of the LBA Addres in ax
mov bx,word[di+10]            ;And the high 16 bits in bx
mov word[BlockNumLow],ax    ;Fill the lower 16 bits
mov word[BlockNumLow+2],bx  ;Fill the higher 16 bits
mov ax,0x4200                           ;We use ah=42h int 13h read extension
mov dl,byte[Bootdrive]                           ;Load our bootdrive
mov si,PacketSize                                    ;Load the Address of the Packet
int 13h ;Use the bios 13h extension
jc Again                 ;If we fail we try it again


mov di,si                   ;Set es:di to the bootpartition entry
mov dl,byte[Bootdrive]      ;Set dl to the Bootdrive
jmp 0x0000:0x7C00           ;Jump to the bootloader

NoPartBootable:
int 18h ;We have finished

Bootdrive db 0
;Normally we try to load the Bootloader with LBA via LBA Packet
PacketSize db 0 ;Our Packet size
Reserved db 0   ;Must be zero
Blockcount dw 0 ;
BufferAddr dd 0;
BlockNumLow dd 0;
BlockNumHigh dd 0;

times 446-($-$$) db 0 ;Fill the Unused bytes with zero
;This Section will be filled by the BIOS
;This is the Partition table
Part1Bootflag db 0                     
Part1Headstart db 0
Part1FSectorFCylinder db 0
Part1FSector db 0
Part1Type db 0
Part1LastHead db 0
Part1LSectorLCylinder db 0
Part1LastSector db 0
Part1LBAAddress dd 0
Part1Length dd 0

Part2Bootflag db 0                     
Part2Headstart db 0
Part2FSectorFCylinder db 0
Part2FSector db 0
Part2Type db 0
Part2LastHead db 0
Part2LSectorLCylinder db 0
Part2LastSector db 0
Part2LBAAddress dd 0
Part2Length dd 0

Part3Bootflag db 0                     
Part3Headstart db 0
Part3FSectorFCylinder db 0
Part3FSector db 0
Part3Type db 0
Part3LastHead db 0
Part3LSectorLCylinder db 0
Part3LastSector db 0
Part3LBAAddress dd 0
Part3Length dd 0

Part4Bootflag db 0                     
Part4Headstart db 0
Part4FSectorFCylinder db 0
Part4FSector db 0
Part4Type db 0
Part4LastHead db 0
Part4LSectorLCylinder db 0
Part4LastSector db 0
Part4LBAAddress dd 0
Part4Length dd 0
;Fill the last bytes until we set the bootsignatur
times 510-($-$$) db 0
db 0x55
db 0xAA
EOF:

Dieser Code unterstützt im Moment nur LBA ich weiß allerdings das mein PC LBA unterstützt sowie Qemu auch. Ich hoffe ihr helft mir den Fehler zu finden. Ich habe diesen Code mithilfe von dd auf meine 2 externe Festplatte gebrannt:

Code: [Auswählen]

dd bs=512 count=1 if=MBR.bin of=\\?\Device\HarddiskVolume4
Das hat sehr gut funktioniert, Bochs konnte auch weiterhin von dem Stick starten, allerdings weder mein PC noch Qemu können von dem Stick booten...

11

Lowlevel-Coding / Von Festplatte booten

« am: 02. September 2012, 18:56 »

Nachdem mein Betriebssystem jetzt stabil auf QEMU sowie bochs und VirtualBox läuft, dachte ich mir das es Zeit ist es mal auf echter Hardware laufen zu lassen. Nun habe ich es mithilfe von dd auf die erste Partition meiner 2 Festplatte geschrieben, zum Test habe ich versucht das Betriebssystem vom Stick aus in QEMU zu starten. ALso den richtigen Physicaldrive ausgewählt und die Bootreinfolge auf HDD gestellt. Nun zeigt mir QEMU aber an: "No bootable Partition in table". So hatte ich es mir nicht ganz vorgestellt, bochs startet immer noch perfekt von dem Stick allerdings sieht bochs es als Floppy Laufwerk.Nun meine Frage an euch was habe ich falsch gemacht?

12

Lowlevel-Coding / Re: Bochs LBA support

« am: 24. August 2012, 19:08 »

Vielen Dank für die Antwort, schönen Abend noch
MfG Dezimiert

13

Lowlevel-Coding / Bochs LBA support

« am: 24. August 2012, 16:00 »

Nachdem mein Kernel jetzt doch sehr groß geworden ist und immer mehr Festlatten sehr großen Speicherplatz haben wollte ich mich mit LBA beschäftigen. Ich wollte meinen Kernel mithilfe von LBA laden in dem bootloader. Langer Text kurzer Sinn, ich teste die Ünterstützung auf LBA und es wird mir gesagt das es keine Ünterstützung dafür gibt. Da ich keinen Fehler in meinem Code finde wollte ich mich an euch wenden. Der nachfolgende Code zeigt meinen Versuch der Implementierungsmethode.

Code: [Auswählen]

  CheckLBASupport:
      xor dx,dx                   
      mov ah,0x41               ;Use the function 41h
      mov bx,0x55AA           ;Store the right value in bx
      mov dl,byte[bootdrive] ;Get the bootdrive
      int 13h                        ;Call the interrupt
      jc LBANotSupported     ;If the Carry Flag is set LBA is not supported
Ich habe diesen Code gepostet da er doch sehr übersichtlich ist. Es wird in diesem Quellcode immer die Methode LBANotSupported aufgerufen. Ich benutze Bochs 2.5.1.
MfG Dezimiert.

14

OS-Design / Re: Framebuffer der Grafikkarte ansprechen

« am: 07. August 2012, 08:42 »

So vielen Dank,das wusste ich nicht

15

OS-Design / Re: Framebuffer der Grafikkarte ansprechen

« am: 07. August 2012, 01:30 »

Allerdings noch eine Frage der Framebuffer liegt ja in dem RAM allerdings hat directX sowie OpenGL die Möglichkeit direkt in den VRAM zu schreiben, wäre es nicht sinnvoller den Framebuffer in den VRAM zu legen, damit der virtuelle Speicher keinen RAM für den Framebuffer aufwenden muss?

16

OS-Design / Re: Framebuffer der Grafikkarte ansprechen

« am: 07. August 2012, 01:28 »

Vielen Dank für die Antworten ich werde mich damit mal beschäftigen

17

OS-Design / Framebuffer der Grafikkarte ansprechen

« am: 06. August 2012, 22:55 »

Nachdem ich mehrere Test "OS" geschreiben habe um z.b. etw. wie Irqs, Keyboarddriver sowie Paging und andere Themen zu verstehen.
Nun würde ich gerne etw. Grafik auf meinen Bildschirm zaubern, da ich öfters lese das VBE rotz der hohen unterstützten auflösung sehr langsam sein soll. Nun frage ich mich ob ich nicht direkt in den VRAM schreiben kann oder ob es auf irgend eine weise eine schnellere Methode gibt. Außerdem wäre es mal interessant zu wissen wie man den gpu benutzen kann, macht ja keinen Sinn ne gute Grafikkarte zu haben wenn die CPU sowieso alles macht.
MfG

18

Lowlevel-Coding / Re: OS auf externe Festplatte / Usb Stick brennen

« am: 30. July 2012, 17:57 »

Okay vielen Dank ich werde erstmal das wiki durcharbeiten falls das nicht funktioniert melde ich mich nochmal.
Schönen Abend noch.

19

Lowlevel-Coding / OS auf externe Festplatte / Usb Stick brennen

« am: 30. July 2012, 17:16 »

Ich wollte mal fragen ob irgendjemand eine Möglichkeit kennt das eigene OS auf eine Festplatte bzw. einen externen Usb Stick zu laden und von dort aus zu booten. Da ich einen eigenen Bootloader geschreiben habe hoffe ich das es nicht nötig ist GRUB zu benutzen. Es wäre ebenfalls kein Problem den Bootloader umzuschreiben, falls man ihn für den USB Stick "modifizieren" müsste.
MfG Dezimiert