Nachrichten

221

Lowlevel-Coding / braucht gcc/as das A20-Gate?

« am: 28. March 2006, 11:58 »

Hallo,

ich möchte ein Betriebssytem in C machen, allerdings im Real Mode
jetzt wüsste ich gerne ob ich dafür das A20-Gate aktivieren muss,
ich weiß nicht ob gcc bzw. as das brauchen, wenn man 16-bit assembliert

ich denk mal man braucht es, bin mir aber nicht sicher

222

Lowlevel-Coding / Stack richtig initalisieren

« am: 28. March 2006, 09:31 »

aber ich initalisiere doch mit

Code: [Auswählen]

cli
mov ax, 9000h
mov ss, ax
xor sp, sp
sti

das ist doch dann 9000:0000 das muss doch locker reichen
oder muss ich den im Kernel nochmal initalisieren?

ich hab das ganze aus dem Tutorial, von Heft 1
die einzige Änderung ist

Code: [Auswählen]

xor sp, sp
statt

Code: [Auswählen]

mov sp, 0
und das ist ja das gleiche

EDIT:

ich hab mir jetzt mal den Inhalt der Register nach dem absturz angeschaut, dabei sind mir 2 Sachen aufgefallen:

1.ds steht auf 0, obwohl ich das ja extra auf 1000h gesetzt hab
wenn ds nicht auf 1000 steht funktioniert das ganze natürlich nicht
da die Adresse dann falsch, die ja mit ds:si angegeben wird

2.in si seteh 19cd0000
der Wert kommt mir aber ziemlich hoch vor
kann sein das die letzten 0en nicht mitgerechnet werden
aber mein kompletter Asm-Kernel ist ja nur 200h Bytes lang
wie kommt der dann auf so einen hohen Wert?

dann frag ich mich noch was "mov si, hallo" überhaupt mit dem Stack zu tun hat

Außerdem hat Bochs noch folgendes ausgegeben:

Code: [Auswählen]

   base    limit
CS 000f0000 0000ffff
DS 00000000 0000ffff
SS 00090000 0000ffff
ES 00010000 0000ffff
FS 00000000 0000ffff
GS 00000000 0000ffff

nach den Werten sind CS, SS und ES ja schon weit aus dem Limit raus

EDIT2:

komisch jetzt klappt es, ich hab sp einfach statt mit 0 mit e000 initalisiert
aber im tutorial wurde doch auch 0 benutzt, warum geht das dann nicht?

223

Lowlevel-Coding / mit gcc 16-Bit code erstellen (Anleitung, keine Frage)

« am: 27. March 2006, 20:37 »

Hallo,

ich habe in den Archiven des Forums gestöbert und habe gemerkt das oft die Frage nach einem 16-Bit C kompilier kommt
meistens wurde turbo C vorgeschlagen, der aber meiner Meinung nach ungeeignet ist, da er ziemlich auf Dos spezialisierten Code erzeugt

mit gcc lässt sich viel einfacher 16-Bit code erzeugen,
indem man

Code: [Auswählen]

__asm__ (".code16gcc\n");
an den Anfang schreibt, der Befehl wird direkt an den Assembler durchgereicht, der dann ausdem ganzen Spaß 16-Bit Code erzeugt

Code: [Auswählen]

__asm__ (".code16\n");

geht auch, aber man sollte den gcc zusatz dranmachen, damit der Assembler weiß dass es gcc Code ist (was das im Endeffekt bringt weiß ich auch nicht, hab ich nur gelesen, es geht aber wirklich besser)

Soweit ich weiß erzeugt wer aber keinen echten 16-Bit Code, sondern passt den code nur so an, dass er im Real-Mode läuft
da kann man glaube ich ja auf neueren Prozessoren trotzdem die 32-bit Register benutzen

224

Lowlevel-Coding / Stack richtig initalisieren

« am: 27. March 2006, 20:25 »

Hallo,

ich habe ein Problem mit meinem Stack
mein Betriebssystem besteht aus einem 16 Bit Assembler Bootloader und einem 16 Bit assembler Kernel (der allerdings mit ld gelinkt werden muss, damit ich später einmal C einbauen kann)

wenn ich mein Os starte läuft der Bootloader problemlos durch,
lädt den Kernel, aber dann hängt der computer sich auf,
dann hab ich das ganze noch in Bochs probiert, der sagt dazu:
"IRET: top 6 bytes of stack not within stack limits"

deswegen denke ich, ich habe den Stack falsch initalisiert
hier der Bootloader:

Code: [Auswählen]

org 7c00h

;Stackinitalisierung

cli
mov ax, 9000h
mov ss, ax
xor sp, sp
sti

;Stackinitalisierung Ende

jmp main

readbr:
mov ah, 02h   ;fest
mov al, 01h   ;Anzahl
mov ch, 00h   ;Spur
mov cl, 02h   ;Sektor
mov dh, 00h   ;Kopf
mov dl, 00h   ;Laufwerksnummer
mov bx, 1000h
mov es, bx    ;Segment
mov bx, 0000h ;Offset
int 13h
ret

main:
call readbr
mov ax, 1000h
push ax
mov ax, 0000h
push ax
retf

int 19h
TIMES 510-($-$$) DB 0
SIGNATURE DW 0xAA55

es macht auch keinen Unterschied wenn ich die Stackinitalisierung weglasse, immer die gleiche Fehlermeldung

hier noch der code vom Asm-Kernel, auch wenn ich nicht glaube das es an dem hängt:

Code: [Auswählen]

global start
start:
cli
mov ax, 1000h
mov ds, ax
mov es, ax
sti
mov si, hello ;hier
int 19h
hello db "Kernel started", 13, 10, 0
TIMES 512-($-$$) DB 0

ohne die Zeile "mov si, hello" funktioniert das ganze sogar

ich seh leider auch keinen zusammenhang zwischen der Zeile und dem Stack, auf den Stack bin ich nur durch Blochs Fehlermeldung gekommen

225

Lowlevel-Coding / BOCHS bootet mein os der PC aber nicht :-(

« am: 27. March 2006, 20:12 »

nein, das ist nicht der Fehler org kann man auch in eckigen Klammern schreiben

226

Lowlevel-Coding / Segmente richtig setzen

« am: 27. March 2006, 17:03 »

Ich hab jetzt ein paar Änderungen vor genommen und probiert den Fehler ein zu grenzen:

erstmal hab ich im Linkerscript 0x200 auf 0x0 gestellt, wie du es gesagt hast (das neue Linkerscript ist ganz unten)
außerdem initialisiere ich nun auch ds
(bin mir aber nich ganz sicher ob ichs richtig gemacht hab, is unten im Code kommentiert)

so jetzt zur Problem eingrenzung
wenn ich folgenden Code als Asm-Kernel benutze funktioniert das ganze:

Code: [Auswählen]

global start
start:
cli ;hier wird ds initalisiert
mov ax, cs
mov ds, ax
sti
;mov si, hello
int 19h
hello db "Kernel started", 13, 10, 0
TIMES 512-($-$$) DB 0

sobald ich "mov si, hello" aber nicht mehr auskommentiere, funktioniert es nicht mehr,
Bochs sagt dazu: "prefetch: RIP > CS.limit"

ich versteh aber nicht was der für ein Problem hat
an welchem Limit soll ich denn angekommen sein?
"hello" geht doch nur das Datensegment was an, was hat den CS damit am Hut?

Ach und was ist eigentlich mit dem Stack?
muss ich den nicht auch irgendwie initalisieren?

hier jetzt noch das Linkerscript:

Code: [Auswählen]

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


okay, ich habs jetzt hinbekommen,
ch hab nicht nur vergessen ds zu initalisieren sondern auch es
hab hier ein bisschen in den Archiven gestöbert und bin habs dann kapiert
trotzdem danke für deine Hilfe, ohne dich wär ich nich auf die Idee gekommen, dass es an es liegt

auch wenn das Problem jetzt gelöst ist, würde mich noch interessieren wofür es (ich mein das Segment es, nicht ein ding) überhaupt gebraucht wird
bis jetzt hab ich das nur für Schiebeoperationen gebraucht, warum muss ich das dann hier mit 1000 initialisieren?

und warum funktioniert das ganze eigentlich, wenn ich den Asm-Kernel auch direkt mit nasm zu flat-binary mache?
das ergibt für mich gar keinen Sinn

227

Lowlevel-Coding / Segmente richtig setzen

« am: 27. March 2006, 14:45 »

Hallo,

ich schreib auch grad an meinem eigenen Betriebssystem
es setzt sich aus einem Bootloader (16Bit Assembler) einem Kernel (16Bit Assembler) und einem 2.Kernel (16Bit C) zusammen (soll es jedenfalls mal...)

Den C-Teil könnt ihr euch komplett wegdenken, den gibt es noch nicht
das erwähne ich nur, da ich mal einen C-Teil mit einbauen will und deswegen ld benutzen muss um den Assembler-Kernel zu linken und ihn nicht einfach mit nasm direkt in flat binary umwandeln kann
(als ich den bootloader und den Asm-Kernel mit nasm direkt zu flat-binary gemacht hab, hat übrigens alles problemlos funktioniert)

Mein Problem ist nun folgendes:
der Bootloader funktioniert ohne Probleme
der Assembler-Kernel funktioniert eigentlich auch, außer man greift auf eine festgelegte Adresse zu
(damit meine ich z.B.: 'bsp db "beispiel",0')

sobald man da smacht stürzt das ganze ab
als ichs dann mal in Blochs ausprobiert hab, sagt der:
">>PANIC<< prefetch: RIP > CS:limit"

aus der Meldung, die ja soviel heißt wie "ungültiger Speicherzugriff" und der Tatsache, dass es ohne die o.g. festgelegten Adressen funktioniert, schließe ich das irgendwas mit den Segmenten falsch eingestellt ist
wahrscheinlich im Linker-Script von ld, welches ich ehrlich gesagt auch nur kopiert habe:

Code: [Auswählen]

OUTPUT_FORMAT("binary")
INPUT(asmkernel.o)
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 = .;
}

in der Zeile ".text  0x200 : {"
muss wahrscheinlich ein anderer Wert rein,
leider weiß ich nicht welcher

ich dachte es muss einfach 0x10000 rein,
da mein Kernel an die Adresse 1000:0000 geladen wird
(das komplette OS ist übrigens im Real-Mode)
aber das wollte ld nicht, dazu sagte er:
"relocation truncated to fit: 16 against `.text'"
und wenn ich den Wert weglasse ändert das auch nichts
immer der gleiche Fehler

hier noch der Quellcode vom Bootloader:

Code: [Auswählen]

org 7c00h

jmp main

readbr:
mov ah, 02h   ;fest
mov al, 01h   ;Anzahl
mov ch, 00h   ;Spur
mov cl, 02h   ;Sektor
mov dh, 00h   ;Kopf
mov dl, 00h   ;Laufwerksnummer
mov bx, 1000h
mov es, bx    ;Segment
mov bx, 0000h ;Offset
int 13h
ret

main:
call readbr
mov ax, 1000h
push ax
mov ax, 0000h
push ax
retf

int 19h
TIMES 510-($-$$) DB 0
SIGNATURE DW 0xAA55

und hier der vom Asm-Kernel:

Code: [Auswählen]

text:           ;Anfangsadresse in si übergeben
lodsb
cmp al, 00h
je texte
mov ah, 0Eh
mov bx, 0007h
int 10h
jmp text
texte:
ret

global start
start:
mov si, hello
call text
int 19h
hello db "Kernel started", 13, 10, 0

Ich hoffe ihr könnt mir helfen