C++Kernel

Hallo mein Bootloader ladet den Kernel nicht

Bootloader:

org 0x7C00 

start:
                ; Erst brauchen wir einen Stack.
cli             ; Keine Interrupts!
mov ax, 0x9000  ; Stackadresse
mov ss, ax      ; SS = 9000 (unser Stack)
mov sp, 0       ; SP = 0000  (der Stackpointer)
sti             ; Interrupts zulassen

mov [bootdrv], dl

;Lade unseren Kernel
call load

;Springe zu diesem Kernel
mov ax, 0x1000 ; Die Adresse des Programms
mov es, ax     ; Segmentregister updaten
mov ds, ax
push ax
mov ax, 0
push ax
retf

; ----------------------------------------------
; Funktionen und Variablen
; ----------------------------------------------

bootdrv db 0 ;Das Bootlaufwerk
loadmsg db "Lade MF OS 0.4...",13,10,0

; Einen String ausgeben:
putstr:
lodsb             ; Byte laden
or al,al
jz short putstrd  ; 0-Byte? -> Ende!

mov ah,0x0E       ; Funktion 0x0E
mov bx,0x0007     ; Attribut-Byte (wird nicht ben?t)
int 0x10          ; schreiben
jmp putstr        ; N?stes Byte
putstrd:
retn

; Lade den Kernel vom Bootlaufwerk
load:

; Diskdrive reset (Interrupt 13h, 0)
push ds            ; Sichere DS
mov ax, 0          ; Die gew?e Funktion (reset)
mov dl, [bootdrv]  ; Dieses Laufwerk ist gew?
int 13h            ; Den Interrupt ausf?
pop ds             ; DS wiederherstellen
jc load            ; Geht nicht? -> Noch mal!

; Sektoren lesen (Interrupt 13h, 2)
load1:
mov ax,0x1000
mov es,ax
mov bx, 0
mov ah, 2
mov al, 5
mov cx, 2
mov dx, 0
int 13h
jc load1
mov si,loadmsg 
call putstr
retn

times 512-($-$$)-2 db 0   
dw 0AA55h

Der 1. Kernel

mov ax, 1000h ; Segmentregister updaten
mov ds, ax
mov es, ax

[BITS 16]				;16 Bit Code erstellen
	jmp		start		;GDT überspringen

NULL_Desc:
	dd		0
	dd		0

CODE_Desc:
	dw		0xFFFF		;Segmentgröße Byte 0/1
	dw		0			;Segmentbasisadresse Byte 0/1
	db		0			;Segmentbasisadresse Byte 2
	db		10011010b	;Zugriffsberechtigungen
	db		11001111b	;Zusatz + Segmentgröße Bits 16 - 19
	db		0			;Segmentbasisadresse Byte 3

DATA_Desc:
	dw		0xFFFF
	dw		0
	db		0
	db		0x92
	db		0xCF
	db		0

gdt:
Limit	dw	0			;Größe der GDT (wird später eingetragen)
Base	dd	0			;Adresse der GDT (wird später eingetragen)

start:					

	cli					;Interrupts ausschalten

	mov		eax, cs		;EAX auf derzeitiges Codesegment setzen
	mov		ds, ax		;DS auf Codesegment setzen

	shl		eax, 4				;EAX mit 16 multiplizieren (Lineare Adresse 
								;des Codesegments errechnen)
	mov		[CODE_Desc+2], ax	;Lineare Adresse des Codesegmentes als 
	mov		[DATA_Desc+2], ax	;Startadresse des Code- und Datendeskriptors
	shr		eax, 16				;eintragen
	mov		[CODE_Desc+4], al
	mov		[DATA_Desc+4], al

	mov		eax, cs				;Startadresse der GDT errechnen
	shl		eax, 4
	add		eax, NULL_Desc

	mov		[Base], eax			;Startadresse der GDT eintragen
	mov		[Limit], WORD gdt - NULL_Desc -1	;Größe der GDT errechnen und eintragen

	lgdt	[gdt]				;GDT laden

	mov		eax, cr0			;In den Protected Mode schalten,
	or		eax, 1				;indem Bit 0 des CR0 Registers auf 1
	mov		cr0, eax			;gesetzt wird

	db		0xea				;FAR-JUMP zum Codesegment
	dw		PMODE
	dw		0x8

[BITS 32]						;32 Bit Code erstellen

PMODE:
	mov		WORD [CODE_Desc+2], 0	;Code Segmentstartaddresse auf 0 setzen
	mov		WORD [DATA_Desc+2], 0	;Daten Segmentstartadresse auf 0 setzen
	mov		BYTE [CODE_Desc+4], 0	;Code Segmentstartaddresse auf 0 setzen
	mov		BYTE [DATA_Desc+4], 0	;Daten Segmentstartadresse auf 0 setzen

	mov		eax, 2				;Selektor für das Datensegment erstellen
	shl		eax, 3

	mov		ds, ax				;Daten- Stack- und Extrasegment mit
	mov		ss, ax				;Datensegmentdeskriptor laden
	mov		es, ax
	mov		eax, 0				;FS und GS mit Null-Deskriptor laden
	mov		fs, ax
	mov		gs, ax
	mov		esp, 0x1FFFFF		;Stack auf unterhalb der 2 MB Grenze setzen

	jmp		0x8:0x10000 + PMODE2	;Sprung in das "neue" Codesegment

PMODE2:	
	jmp		END						;Zum Ende Springen

times 512-($-$$)	db	0;			;Da der Linker sich nicht mit ungeraden 
									;Dateigrößen verträgt, wird diese Datei auf 512
									;gepaddet.

END:

Der 2. Kernel

[Bits 32]
extern _main
global start
global _EnableA20Gate

start:

call _main

STOP:
	jmp STOP

;#######################################################################

Der C+++ Kernel

//a small C++ kernel
#include <iostream>

int main()
{
    std::cout << "jawoll" << std::endl ;
    system("Pause");
    return 0 ;
}

bluecode

Du kansnt nicht einfach so die C++ Standardbibliothek benutzen! Das musst du schon selbst implementieren...

ja aber der 1. Kernel wird nicht geladen

Hi,
vorallem system("Pause"); wird wohl nich gehen :p
Was soll da denn aufgerufen werden?

MfG
AlexanderS

Der C++ Kernel ist nur Beispiel das Problem bereitet der Bootloader