Thema: Von Festplatte booten

[Dezimiert]

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?

[Svenska]

Hallo,

was du da gemacht hast, kann ich nicht deuten. Schreib mal ausführlicher... Das mit dem Floppy-Laufwerk ist komisch, und was ein Stick mit dem Boot von Festplatte zu tun hat, weiß ich auch nicht.

Die Fehlermeldung deutet aber darauf hin, dass die Partitionstabelle korrekt ist und keine als "aktiv" (oder "boot") markierten Partitionen enthält. Damit weiß der MBR nicht, was er booten soll und weint.

Außerdem ist die Frage falsch. Du sagst nicht, was du gemacht hast (nur, was du versucht hast), willst dann aber wissen, was du falsch gemacht hast. Woher sollen wir das wissen?

Gruß,
Svenska

[Dezimiert]

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...

[kevin]

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

Da haben wir den Fehler ja schon...

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.

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

Mit welchen Optionen startest du qemu?

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


Externe Festplatte heißt was genau? USB?

Und du hast kopiert, nicht gebrannt. Wenn man in Festplatten was reinbrennt, gehen sie kaputt...

[Dezimiert]

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.

[Jidder]

Ein Problem ist, dass du die Variablen wie bootdrive, etc im Bereich 0x7c00 hast, aber dann später diese mit dem geladenen Sektor überschreibst und trotzdem noch die Variablen verwendest. Du solltest die woanders hinlegen indem du entweder mit Konstanten (%define bootdrive 0x7bxx) oder mit der resb-Instruktion (Ich glaube das zumindest. Siehe NASM Manual.) außerhalb des Bootsektors Speicher reservierst. Oder auf dem Stack.

[Dezimiert]

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.

[Svenska]

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.

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

Ich benutze kerin GRUB, da ich das lieber selbst schreiben will

Also geht es im speziellen Fall auch nicht um ein Betriebssystem, sondern einen Bootloader.

Dass wir davon abraten, ist dir bekannt? Das ist viel sinnloser Aufwand.

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".

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.

Dass wir davon abraten, ist dir wirklich bekannt? Durchsuche mal einen guten Bootloader nach Workarounds für BIOS-Bugs...

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\HarddiskVolume4Das hat sehr gut funktioniert, Bochs konnte auch weiterhin von dem Stick starten, allerdings weder mein PC noch Qemu können von dem Stick booten...

Vermutlich funktionierte das nicht.

Was benutzt du für ein "dd"?
Wo kommt jetzt wieder der Stick her, wenn es doch eine externe Festplatte ist?
Du weißt schon, dass du mit deinem MBR jede auf dem Gerät vorhandene Partitionstabelle überschreibst? Das ist grob fahrlässig. Mach die Datei 448 Bytes lang, dann bleiben die Partitionen erhalten. Ist höchstwahrscheinlich eh sinnvoller, wenn das Betriebssystem auf der gleichen Platte sein können soll.

Dass wir davon abraten, ist dir ganz sicher auch bekannt? Einen Kernel aus GRUB raus zu starten, ist "mal eben schnell" möglich. Das komplette Bootsystem umzuschreiben, um dein Betriebssystem zu testen, ist das nicht.

Gruß,
Svenska

[Dezimiert]

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

[Dezimiert]

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

[Jidder]

0x01BD ist um 1 zu klein.

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.

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

[Dezimiert]

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?

[Jidder]

Ich halte es für wahrscheinlicher, dass du nicht die Berechtigungen dazu hast, den Sektor zu überschreiben.

[Relbmessa]

Hallo Dezimiert

Vielleicht findest du hier auch ein paar Hinweise-> WWW.henkessoft.de

viel Spass
Relbmessa

[Svenska]

Hallo,

ob die Festplatte 4k-Sektoren hat oder nicht ist irrelevant (nach außen exportiert sie aus Kompatiblitätsgründen 512-Byte-Sektoren). Und dass du dir eine 2 TB-Platte aus Jux zum Spielen gekauft hast, nehm ich dir so nicht ab. Da reicht auch der 32 MB USB-Stick, der in der Schublade ganz unten gelegen hat.

Hier ein paar Tips:

• Nimm Linux, da funktioniert ein "sudo dd if=/bla/blub/mbr.bin of=/dev/sdc".
• Mach die mbr.bin nur 448 Byte groß, das wird dir später Ärger und versehentlich verschwundene Dateisysteme ersparen.
• Gucke mit einem Hexeditor auf den ersten Sektor der Festplatte, ob dein MBR wirklich drauf ist. (Nimm dafür ein Linux-Livesystem, wenn du es nicht installieren willst.) Achte auf eventuelle Strings und die Signatur.
• Achte darauf, dass Partitionen vorhanden sind und exakt eine davon aktiv ist.
• Nicht jedes BIOS ist dumm. Manche sind intelligenter, als sie sein sollten:
  
  • Bei einem alten IBM Thinkpad wollte das BIOS nur booten, wenn eine FAT-Partition (Typ 0x06 oder 0x0b) vorhanden war. Es kann gut sein, dass dein BIOS auf die Existenz von Partitionen prüft, ehe es den MBR ausführt; besonders beim Boot von USB sind da vielleicht striktere Prüfungen möglich.
  • Aus der Partitionstabelle ergibt sich ein CHS-Mapping für den int13. Manche BIOSse booten von USB nur mit bestimmten Geometrien ("ZIP-Drive") und ohne Partitionstabelle passt die Geometrie dann nicht.
  [li]Teste den Boot von der Platte mit einem garantiert funktionierendem Bootsektor (Syslinux, DOS, ...)
• Nimm eine kleinere Festplatte oder einen kleineren USB-Stick zum Testen, bevorzugt kleiner als 504 MB (dann sind alle CHS-Geometrien(*) gleich, aber nicht ZIP-Drive-kompatibel).
• Lerne deine Tools kennen. Irgendwelche Frontends sind gut, aber du solltest wissen, was dahinter passiert. Betrifft Qemu.

(*) Auch wenn du kein CHS benutzt, kann das eine Rolle spielen.

Was den MBR-Code angeht, so kann man normalerweise einen JMP an die gleiche Stelle machen, um unabhängig von der BIOS-Ladeadresse zu sein - bevor man irgendwelche relativen Adressierungen ausführt. Den ausführbaren Code irgendwo hinzukopieren wirkt jedenfalls unelegant und kostet Platz. Wenn das BIOS den ganzen Sektor lädt, kannst du die Partitionstabelle in-place auslesen, tut es das nicht, musst du ohnehin den ersten Sektor von der Platte lesen.

Gruß,
Svenska

[Dezimiert]

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.

[MNemo]

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?

Nein, da wird nichts vom BIOS ausgefüllt. Das BIOS liest den ersten Sektor nach 0x7C00 und überpüft gegeben falls noch die Bootsignatur bevor es die Kontrolle an den Boot Sektor (MBR) übergibt. Mehr tut es (diesbezüglich) nicht. Ab 448 steht (für gewöhnlich) die Partitionstabelle, aber die sollte das BIOS  auch nicht interessieren. Sie wird da nur von z. B. Windows und Partitionierungs tools erwartet. Wenn du sie nicht überschreibst musst du dir nicht die Mühe machen eine Korrekte Tabelle per hand zu erstellen, und zerstörst auch keine potentiell vorhanden Partitionen.

Außerdem sollte doh bei 512 Bytes die Bootsignatur auch beim MBR stehen oder?

Ja, aber das steht da im Normalfall schon. Die Text-Ausgabe "Device not Bootable" oder ähnlich stammen meist vom MBR bzw. Bootsector des jeweiligen Gerätes selbst.

Und wie finde ich heraus wo eine Partition anfängt, das heißt wo ich dann den eigentlich bootloader hinkopieren soll?

Das kannst du weiter aus der Partitionstabelle ablesen oder vorhanden Tools überlassen.

Aber wenn du auf der Platte so wie so nichts anders drauf hast, kannst du den MBR mit Partitionstabelle auch auslassen. Und die gesamte Platte als eine große Partition oder Diskette betrachten. Das kann dann halt sein das Windows da ein eventuell vorhandenes Dateisystem nicht mehr erkennt. Aber bei einem self-made Bootloader wird es das wahrscheinlich eh nicht geben.

[Dezimiert]

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?

[Svenska]

Hallo,

woher sollte das BIOS denn eine Partitionstabelle generieren, wenn die nicht auf der Festplatte steht? Die steht im ersten Sektor und damit ist gut.

Wenn /dev/sdc deine Festplatte unter Linux ist, dann sind /dev/sdc1, /dev/sdc2, /dev/sdc3 und /dev/sdc4 die primären Partitionen, die dort verzeichnet sein können. Und du solltest dir vielleicht überlegen, mit einem Dateisystem anzufangen. Die meisten Dateisysteme (FAT eingeschlossen) haben reservierte Sektoren, in denen Bootcode liegen kann. Dieser Bootcode kann dann den Kernel, der als gewöhnliche Datei im Dateisystem liegt, dort wieder auslesen.

Gruß,
Svenska

[Dezimiert]

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