Themen

1

Lowlevel-Coding / Wieso rebootet bei diesem Code Bochs?

« am: 16. June 2007, 22:03 »

Hi  ,

habe ein Problem. Bochs rebootet bei meinem Code ständig. Hier mal meine Files:

bootsec.asm

Code: [Auswählen]

starter:

jmp 07c0h:main_entry

main_entry:
mov ax,cs
mov ds,ax
mov es,ax
cli
mov ss,ax
mov sp,9000h
sti

mov ah,02h
mov al,1
mov cl,2
mov ch,0
mov dl,0
mov dh,0
lea bx,[kernel]
int 13h

times 510-($-$$) db 0 ;wichtig: Hier die Datei mit so vielen Bytes füllen, bis es genau 510 sind
dw 0aa55h ;Bootsignatur anhängen
kernel:
kernel16.asm

Code: [Auswählen]

[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:
kernel32.asm

Code: [Auswählen]

[Bits 32]
extern _main
global start
global _EnableA20Gate

start:

call _main

STOP:
jmp STOP

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

kernel.c:

Code: [Auswählen]

int main()
{
char *Text = "Welcome to Protected Mode"; 
char *VideoMem = (char*)0xB8000; 
 
while(*Text) 
{ 
*VideoMem = *Text; 
*VideoMem++; 
*VideoMem = 7; 
*VideoMem++; 
*Text++; 
} 

return(0);
}
link.txt

Code: [Auswählen]

OUTPUT_FORMAT("binary")
INPUT(kernel32.obj ckernel.obj)
ENTRY(start)
SECTIONS
{
  .text  0x200 : {
    code = .; _code = .; __code = .;
    *(.text)
    . = ALIGN(1);
  }
  .data  : {
    data = .; _data = .; __data = .;
    *(.data)
    . = ALIGN(1);
  }
  .bss  :
  {
    bss = .; _bss = .; __bss = .;
    *(.bss)
    . = ALIGN(1);
  }
  end = .; _end = .; __end = .;
}

Create.bat

Code: [Auswählen]

@echo off
echo DJGPP setzen...
set DJGPP=c:\djgpp\djgpp.env
echo ---
echo Bootloader erzeugen...
nasmw -f bin -o bootsec.bin bootsec.asm
echo ---
echo Kernel16 kompilieren...
nasmw -f bin -o kernel16.bin kernel16.asm
echo ---
echo Kernel32 kompilieren...
nasmw -f aout -o kernel32.obj kernel32.asm
echo ---
echo C-Kernel kompilieren...
gcc -ffreestanding -c -Os -o ckernel.obj kernel.c
echo ---
echo Zusammenlinken
ld -T link.txt -o c32kernel.bin
echo ---
echo Mergen
MergeKernel kernel.bin bootsec.bin kernel16.bin c32kernel.bin
echo ---
pause
Bochs-Konfig:

Code: [Auswählen]

### Hier den Pfad anpassen für dein disk-image
floppya: 1_44=kernel.bin, status=inserted
####
romimage: file=../BIOS-bochs-latest, address=0xf0000
cpu: count=1, ips=10000000, reset_on_triple_fault=1
megs: 32
vgaromimage: file=../VGABIOS-lgpl-latest
vga: extension=vbe
boot: floppy
floppy_bootsig_check: disabled=0
log: bochsout.txt
panic: action=ask
error: action=report
info: action=report
debug: action=ignore
debugger_log: -
parport1: enabled=1, file="parport.out"
vga_update_interval: 300000
keyboard_serial_delay: 250
keyboard_paste_delay: 100000
private_colormap: enabled=0
keyboard_mapping: enabled=0, map=
i440fxsupport: enabled=1
Tools: DJGPP, MergeKernel, nasmw, Bochs

Vielen Dank im vorraus für eure Antwort  ,

Gruss
PMTheQuick 

2

Das Wiki / Ausgabe 8 im Wiki

« am: 17. April 2007, 19:06 »

Hi ,

ich habe mir heute die Zeit genommen und die Ausgabe 8 ins Wiki überträgt. Ich hoffe so ists gut. Dazu hab ich noch Rechtschreibefehler verbessert. Ich hoffe es gefällt euch  Also, hier der Link:

http://lowlevel.brainsware.org/wiki/index.php/Ausgabe_8

Viel Spass 

Gruss
PMTheQuick 

3

Lowlevel-Coding / Ein paar Fragen...

« am: 16. April 2007, 16:58 »

Hi,

also ich hab jetzt nen funktionierenden C++-Kernel dank einem Tutorial... (PS: http://biehler-josef.de/ Echt gut, sogar nen Tutorial wie man nen Brainfuck-Interpreter schreibt... )... Nun, das geht ja alles... Hab auch nen Befehl um Texte auszugeben und Texte einzulesen (Solange einlesen bis Enter gedrückt wird...) Nun, jetzt habe ich nen paar Fragen:

1. Bei jeder Compilierung mit dem TurboC++-Compiler gibts ne Warnung aus:

Code: [Auswählen]

Turbo C  Version 2.01  Copyright (c) 1987, 1988 Borland International
kernel.cpp:
Warning kernel.cpp 16: Non-portable pointer assignment in function main

        Available memory 434810
2. Wenn man beim eingeben die RückTaste drückt, geht nur der Cursor zurück, der Text bleibt also... Beispiel:

Cursor ganz hinten: PMTheQuick_
Jetzt drück ich die Rücktaste nen paar mal: PMTheQuick
Es sollte aber so aussehen: PMTheQ_

3. Nach einigen Zeichen bleibt es auf einmal hängen und geht nicht mehr weiter... Ich will aber auch lange Strings ermitteln können! Was ist das Problem

4. Sollte ich noch irgendetwas verbessern daran?

Meine Proggis:
NASM
Turbo C++ Compiler 2.01
JLoc

So... Und nun noch mein Code:

start.asm

Code: [Auswählen]

[BITS 16]
EXTERN _main
start:

jmp 07c0h:main_entry

main_entry:
mov ax,cs
mov ds,ax
mov es,ax
cli
mov ss,ax
mov sp,9000h
sti


mov ah,02h
mov al,1
mov cl,2
mov ch,0
mov dl,0
mov dh,0
lea bx,[kernel]
int 13h


call _main
jmp $

;##Funktion zur Stringausgabe / Begrenzungszeichen: ASCII 0
GLOBAL _boot
_boot db "QuickOS 1.00",13,10,0
GLOBAL _enter
_enter db "ENTER",13,10,0
GLOBAL _newline
_newline db 13,10,0

GLOBAL _prnt
_prnt:
push bp
mov bp, sp
push ax
push si
mov ax, [bp + 4]
mov si,ax

prnt1:
mov al,[si]
cmp al,0
JE prnte
inc si
mov ah,0eh
int 10h
jmp prnt1

prnte:
pop si
pop ax
pop bp
ret

GLOBAL _strget
_strget:
       xor ah,ah ; Funktion 00h
       int 16h     ; Ausfüren
       cmp al, 0Dh ; Enter
       je short str_get_end ; Wenn Enter dann beenden
          mov [si], al   ; Speichere Zeichen
          inc SI
              mov ah, 0Eh   ; Ausgabe
              mov bx, 0007h
              int 10h
       jmp _strget          ; Neustart
       str_get_end:         ; String mit 0 Beenden
       xor al,al
       mov [si], al
       ret

times 510-($-$$) db 0 ;wichtig: Hier die Datei mit so vielen Bytes füllen, bis es genau 510 sind
dw 0aa55h ;Bootsignatur anhängen
kernel:
kernel.cpp

Code: [Auswählen]

extern prnt(char *var);
extern strget();
extern char boot;
extern char enter;
extern char newline;

int main()
{
char *str;
char key[2];
int i;
str=&boot;
prnt(str);

while(1) {
str=strget();
prnt(str);
prnt(&newline);
}

}
make.txt

Code: [Auswählen]

ALL:
start.obj
kernel.obj
DATA: 0F0000 MAIN.after MAIN.i_after
*,DGROUP
,,,FONT
FINAL: 0F0000 100000-FINAL.length FINAL.start-0F0000
*,kernel.obj
MAIN: 0F0000 0F0000 0
*
compile.bat

Code: [Auswählen]

@echo OFF
nasm -f obj start.asm -o start.obj
tcc -c kernel.cpp
jloc make.txt kernel.bin
PAUSE
So... Danke im vorraus,

Gruss
PMTheQuick

EDIT: Ich will es mit dem C++ Kernel übrigens UNBEDINGT so lassen, das Booten & Funktionen in ASM und Funktionen-Aufrufe in C++ sind....