Beiträge anzeigen

Diese Sektion erlaubt es dir alle Beiträge dieses Mitglieds zu sehen. Beachte, dass du nur solche Beiträge sehen kannst, zu denen du auch Zugriffsrechte hast.


Nachrichten - svler

Seiten: [1]
1
@PorkChicken: Aha, danke für die Erklärung, das war mir nicht klar.
@bluecode: Ja, ich habe mich jetzt auch umentschieden und arbeite jetzt im PMode.

@all: Vielen Dank für eure schnelle und kompetente Hilfe. Das bekommt man ja heute nicht mehr oft in Foren. Keine einzige "unnötige" Antwort. Das Lowlevel-Forum (und die Seite) ist wirklich eine Goldgrube für OS Developer!

schönes Wochenende
svler
2
Ja, ich habe mitlerweile auch noch ein paar Sachen gelesen.

Also zunächst ist es doch so, dass man mit GCC generell 16-Bit Code erzeugen kann (Inline ASM direktive). Das heißt dann, das der Assembler 16 Bit Opcodes erzeugt. Der entstehende Code ist aber für den PMode ausgelegt, z.B. direkte Addressierung ohne Segmentregister.
DJGPP ist ja die Portierung des GCC auf DOS. DOS ist aber soviel ich weiß Realmode. D.h. es müsste eine Möglichkeit geben den GCC auf die Erzeugung von Realmode-Code zu portieren. Weiß jemand wie das geht. Inline-ASM ist zwar ne Möglichkeit aber dann kann ich auch direkt Assembler schreiben. Das macht mir generell nichts aus, aber ich möchte z.B. ein wenig mit FAT rumexperimentieren und dann wäre es sehr schön wenn ich C-Features wie Strukturen nutzen könnte. Vielleicht hat ja noch jemand ne Idee.
3
Hallo,

danke erst mal. Es ist mir klar, das man nicht "direkt" darauf zugreifen kann aber eben über ds. Das Problem, das ich habe, ist folgendes. GCC erzeugt folgende Zeile:

mov byte ptr ds:[eax], 0x00 (wie schon erwähnt ds=0 und eax=0xA0000).

Die Frage ist nun, um präziser zu sein, wie bringe ich GCC dazu nicht nur 16-Bit Opcode zu generieren sondern das ganze auch Realmode konform zu machen, sodass GCC folgendes erzeugt:

mov ax, 0xA000
mov ds, ax
mov ax, 0x00
mov [ax], 0x00

Geht das überhaupt oder kann GCC das gar nicht?

Vielen Dank
4
Lowlevel-Coding / Re: Kurze Frage zu GRUB
« am: 12. August 2009, 14:33 »
hallo,

wie wär's denn wenn du den Videospeicher von hinten her durchsuchst und auf Nullen prüfst. Sobald du keine Null mehr hast weist du hier geht's weiter.

Nur ne Idee keine Ahnung ob das klappt!
5
Hallo zusammen,

ich habe da ein kleines Problem. Ich teste mein OS mit Bochs. Das OS ist in einem HD Image. Zunächst habe ich einen "sehr kleinen" Bootloader. Dieser soll den zweiten Sektor laden und dann dort hin springen. Das funktioniert auch wunderbar. Jetzt habe ich folgendes Problem. Den folgenden Kernel schreibe ich in C. Zum compilieren und linken nutze ich gcc/ld. Da ich mich noch nicht im pMode befinde habe ich in der kernel.c die asm direktive .code16gcc benutzt um 16Bit Opcode zu erzeugen. Das funktioniert auch. Was nicht funktioniert ist das schreiben in den Videospeicher bei 0xA8000 (oder 0xB8000 ich glaube aber ersteres, spielt aber auch erstmal keine Rolle in beiden Fällen klappt es nicht). Ein Debug mit Bochs ergibt folgendes. Bei der asm Anweisung mov byte ptr ds:[eax], xx bekomme ich den Fehler:

Bochs: write_virtual_checks(): write beyond limit, r/w

xx ist ein beliebiger Wert, ds ist 0 und eax ist 0xA8000. Ich verstehe nicht warum nun eine solche Fehlermeldung auftritt. Die Adresse müsste doch auch im Realmode addressierbar sein, oder nicht? Ich hoffe ihr könnt ein bisschen Klarheit in die Sache bringen. Danke.

boot.asm
; ----------------------------
; BOOTLOADER
; ----------------------------
[BITS 16]

section .text
extern main
global start

start:
mov eax, 0
mov ebx, 0
mov ecx, 0
mov edx, 0
mov ax, cs
mov ds, ax
mov es, ax
mov esi, 0
mov edi, 0

cli ;Interrupts löschen

mov ax, 0x9000 ;------------------
mov ss, ax ;Stack einrichten
mov sp, 0 ;------------------

sti ;Interrupts zulassen

mov si, loadmsg
call putstr

mov ah, 2
mov al, 1
mov cl, 2
mov ch, 0
mov dh, 0
mov dl, 0x80
mov ebx, 0x00007E00

int 13h

failure: jc failure

jmp 0x7E00

; +----------------------+
; |putstr |
; |----------------------|
; |Funktion: |
; |Gibt String aus |
; |----------------------|
; |si, String |
; +----------------------+

putstr:
lodsb
or al, al
jz short putstrd

mov ah, 0x0E
mov bx, 0x0005
int 10h
jmp putstr
putstrd:
retn

; ------------------------
; Funktionen und Variablen
; ------------------------
loadmsg db "OS wird geladen...",0

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

asm(".code16gcc\n");

int main()
{
  // Pointer zum Videospeicher
  char *video = (char*)0xA8000;
  // String zum Ausgeben
  char *hello = "Executing Kernel...";
 
  // Zuerst den Speicher leeren
  for(video+=4000; video !=(char*)0xA8000 ;video--)
     *video=0;
 
  // String ausgeben
  while (*hello) {
    *video = *hello;
    video++;
    *video = 0x07;
    video++;
    hello++;
  }
 
  // jetzt wo wir schon im Kernel drin sind, wollen wir auch nicht mehr raus ;)
  while (1);
  return 0;
}
6
Lowlevel-Coding / Problem mit der IDT
« am: 02. March 2006, 17:07 »
Ja, Bochs hat wirklich was an der Waffel. Ich habe jetzt das "div" Kommado auskommentiert. Ich dachte jetzt müsste ja die Endlosschleife greifen. Tatsächlich bekomme ich aber denselben Fehler. Erst wenn ich "sti" nach dem MAIN: Label auskommentiere läuft das Programm  in die Endlosschleife. Kann es sein, dass ich beim Interrupt Deskriptor beim 4. und 5. Byte etwas falsch gemacht habe. Vielleich flasch herum??? Denn der Prozessor bekommt ja offensichtlich gar nicht die Möglichkeit eine Exception bzw. einen Interrupt auszulösen.
7
Lowlevel-Coding / Problem mit der IDT
« am: 02. March 2006, 16:14 »
Hallo,

nach langer Zeit habe ich einmal an meinem OS weiter programmiert und habe es jetzt auch geschafft in den PMode zu schalten. Jetzt möchte ich mit der IDT weiter machen. Ich habe einmal ein Interrupt Deskriptor für die Exception 0 definiert und natürlich die IDT geladen. Dann teile ich durch 0. Jetzt soll eine Nachricht ausgegeben werden. Bochs startet jedoch nur neu. Beim debuggen erscheint folgende Meldung bei der Ausführung des DIV Befehls:

Error: (0) print_guard_results: guard_found ? (stop reason 0)

Ich habe im Forum schon vergleichbare Probleme gelesen jedoch ist dort eine andere Meldung erschienen. Anbei poste ich noch meinen Kernel. Der Bootloader ist fast der selbe, wie der aus den Tutorials. Mein Code wird an 0x10000 geladen.


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


;;;;;;;;;;;;;;;;; GDT ;;;;;;;;;;;;;;;;;;;;;;

gdt_NULL_Desc: ;Dummy Deskriptor
dd 0
dd 0

gdt_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


gdt_DATA_Desc:
dw 0xFFFF
dw 0
db 0
db 0x92
db 0xCF
db 0
gdt:
gdt_Limit dw 0 ;Größe der GDT (wird später eingetragen)
gdt_Base dd 0 ;Adresse der GDT (wird später eingetragen)

;;;;;;;;;;;;;;;;; IDT ;;;;;;;;;;;;;;;;;;;;;;

idt_DIV_ERROR:
dw 0
dw 8
dw 0000000011111101b
dw 0

idt:
idt_Limit dw 0
idt_Base dd 0


;;;;;;;;;;;;;;;;; Daten ;;;;;;;;;;;;;;;;;;;;
Data:
VMem_Offset dd 0 ;Offsetadresse zur Textausgabe
PMode_Msg db "Willkommen im PMode",13,0
PMode_Msg2 db "CR",13,0
EX_DIV_ERROR db "Division Error",13,0


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)
;;;;;;;;;;;;;;;;;;; GDT laden ;;;;;;;;;;;;;;;;;;;;;
mov [gdt_CODE_Desc+2], ax ;Lineare Adresse des Codesegmentes als
mov [gdt_DATA_Desc+2], ax ;Startadresse des Code- und Datendeskriptors
shr eax, 16 ;eintragen
mov [gdt_CODE_Desc+4], al
mov [gdt_DATA_Desc+4], al

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

mov [gdt_Base], eax ;Startadresse der GDT eintragen
mov [gdt_Limit], WORD gdt - gdt_NULL_Desc -1;Größe der GDT errechnen und eintragen

lgdt [gdt] ;GDT laden

;;;;;;;;;;;;;;;;;;; IDT laden ;;;;;;;;;;;;;;;;;;;;;
mov eax, cs
shl eax, 4
add eax, DIV_ERROR_VECTOR
mov [idt_DIV_ERROR], ax
shr eax, 0x10
mov [idt_DIV_ERROR+6], ax

mov eax, cs
shl eax, 4
add eax, idt_DIV_ERROR
mov DWORD [idt_Base], eax
mov [idt_Limit], WORD idt - idt_DIV_ERROR

lidt [idt]

;;;;;;;;;;;;;;;;;;; PMODE schalten ;;;;;;;;;;;;;;;;
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 [gdt_CODE_Desc+2], 0 ;Code Segmentstartaddresse auf 0 setzen
mov WORD [gdt_DATA_Desc+2], 0 ;Daten Segmentstartadresse auf 0 setzen
mov BYTE [gdt_CODE_Desc+4], 0 ;Code Segmentstartaddresse auf 0 setzen
mov BYTE [gdt_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 MAIN ;Zum Ende Springen


MAIN:
sti
mov DWORD [VMem_Offset], 0 ;Videooffset auf 0 setzen
mov dl, 7
mov esi, PMode_Msg ;"Willkommen im PMode"
call putstr

mov eax, 0
mov ebx, 0
mov ecx, 0
mov edx, 0
mov eax, [idt_DIV_ERROR+6]
shl eax, 0x10
mov ax, [idt_DIV_ERROR]
mov eax, 0
div eax


main_loop:
jmp main_loop


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;+------------------------------------------+;
;|Funktion: putstr    |;
;+------------------------------------------+;
;|Gibt Text auf dem Bildschirm aus (Textmodu|;
;|s).    |;
;+------------------------------------------+;
;|esi - String    |;
;|dl - Zeichenfarbe    |;
;+------------------------------------------+;
;|VMem_Offset - aktuelles Offset    |;
;+------------------------------------------+;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

putstr:
pusha
mov edi, 0xB8000 ;Adresse des Videomemories laden
mov eax, [VMem_Offset] ;Offsetadresse des Cursors laden
imul eax, 2 ;verdoppeln da Zeichenattribute folgen
add edi, eax ;di mit Adresse füllen
add esi, 0x10000 ;zur Stringadresse 0x10000 addieren, da Code hier hin geladen wurde und die Labels blos Offsets sind
putstr_loop: ;Hauptschleife zur Zeichenausgabe
lodsb ;Zeichen laden
cmp al, 0 ;Ist Nullzeichen?
je putstr_exit
cmp al, 13 ;Ist Carriage Return?
je putstr_cr
stosb ;Zeichen ausgeben
mov al, dl ;Zeichenfarbe laden
stosb ;Zeichenfarbe abspeichern
jmp putstr_loop ;Hauptschleife

putstr_cr:
mov eax, edi
sub eax, 0xB8000
mov ebx, 0xA0
mov edx, 0
div ebx
mov eax, 0xA0
sub eax, edx
add edi, eax
inc edi
jmp putstr_loop

putstr_exit:
mov eax, edi ;Neues Offset abspeichern
sub eax, 0xB8000
shr eax, 1
mov [VMem_Offset], eax
popa
ret

DIV_ERROR_VECTOR:
cli
pusha
push ds
push es
push gs
push fs
mov esi, EX_DIV_ERROR
mov dl, 3
call putstr
pop fs
pop gs
pop es
pop ds
popa
sti
iret

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


Ich hoffe ihr könnt mir ein wenig helfen.
Gruß svler
8
Lowlevel-Coding / string erstellen und füllen...
« am: 21. March 2004, 16:19 »
Ich glaube aber, dass das noch nicht reicht.
Man muss die Größe noch angeben. Also...:

mov byte [string], al
oder
mov word [string], ax

Gruß svler
9
Lowlevel-Coding / Link Problem
« am: 16. March 2004, 22:18 »
Hi,

es lag daran, dass ich die gcc.exe und ld.exe nicht von djgpp hatte. Als ich mir jetzt das djgpp runtergeladen hab hat's funktioniert. Läuft jetzt alles prima. @TeeJay: Ich find wirklich klasse, wie viel Mühe du dir mit den ganzen Tuts machst und dann auch noch Zeit findest auf die Fragen hier im Forum zu antworten. Wirklich toll !!! Weiter so !!!

Gruß svler
10
Lowlevel-Coding / Link Problem
« am: 16. March 2004, 18:08 »
Hi,

könnte es vielleicht sein, dass ich (wir) eine falsche Version von dem File ld.exe zum Linken haben und deswegen das Format nicht erkannt wird ? Ich hab nähmlich MinGW wenn ich mich nich irre. Hab' ich von so ner CD. Daraus hab ich einfach die Programme zum Compilieren und Linken kopiert.

Gruß svler
11
Lowlevel-Coding / Arbeiten im 1024x768x16 Graphikmodus
« am: 16. March 2004, 16:36 »
Ok,
vielen Dank für eure Hilfe. Werd mal schauen ob ich das zum laufen bringe
12
Lowlevel-Coding / Link Problem
« am: 15. March 2004, 20:21 »
Hi TeeJay,

ich hab dieses Tut ja verwendet. Aber wenn ich da mit deiner link.txt Datei das ganze linken will kommt immer einer der beiden Fehler.

Gruß svler
13
Lowlevel-Coding / Link Problem
« am: 15. March 2004, 20:05 »
Hey,

genau das selbe ist bei mir auch !!!

Zuerst kam: kernel32.obj: file not recognized: File Format...
Dann hab ich auch das aout in coff geändert und es kam das mit dem PE.
Vielleicht könnte uns ja jemand helfen oder hast dus(copyArt) vielleicht schon rausgefunden?!

Gruß svler
14
Lowlevel-Coding / Arbeiten im 1024x768x16 Graphikmodus
« am: 15. March 2004, 19:55 »
Ja,

das hatte ich auch gehört. Aber als ich es einfach mal ausprobiert hab' hats funktioniert. Deshalb ja auch die Frage ob der PMode vielleicht nicht richtig funktioniert?

Danke schon mal
15
Lowlevel-Coding / Arbeiten im 1024x768x16 Graphikmodus
« am: 15. March 2004, 18:42 »
Hi,

ich arbeite im 1024x768x16 Grafikmodus und im PMode. Wollte jetzt ganz normal mit dem int 10h und einer kleinen routine dazu einen String ausgeben. Das funktioniert auch prächtig, jedoch führt das 13,10 am Ende des Strings nicht dazu, dass ich eine Zeile weiter nach unten "rutsche". Meine Frage wäre wie ich am besten Text ausgeben kann? Und ich kann außerdem nur Pixel malen wenn ich die Adresse 0xA000 verwende. Überall wird jedoch gesagt im PMode wäre es 0xB8000. Könnte es vielleicht sein, dass ich nicht richtig im PMode bin ?
16
Lowlevel-Coding / osloader mit protected mode und vga
« am: 08. March 2004, 07:34 »
OK danke,

aber könntest du mir mal ein kleinen beipiel code schreiben wie ich das pixel male? Und vielleicht auch wie ich vom PMode in den V86 oder Real Mode wechsle.
17
Lowlevel-Coding / osloader mit protected mode und vga
« am: 07. March 2004, 15:28 »
Hi,

ich fange an langsam alles zu verstehen. Könnte mir vieleicht jemand eine kleine Funktion in ASM (versteht sich) schreiben die mir ein Pixel am Bildschirm ausgibt. Ich würde da gerne im VESA Mode 0101h arbeiten. Wenn mir dann noch jemand erklären könnte wie ich im PMode die Funktion 4F0A (Get Protected Mode Interface) von int10h nutzen kann wäre ich überglücklich. Ich danke schon mal im voraus!!!

Gruß svler
18
Lowlevel-Coding / osloader mit protected mode und vga
« am: 06. March 2004, 14:35 »
Hi,

ich bin neu hier. Den Quellcode oben hab ich 1:1 übernommen und er läuft prächtig. Leider hab ich keine Ahnung wie man im VESA Mode gemäß fogendem Code gesetzt...:

mov ax, 0x4F02
mov bx, 0x0101
int 10h

...Pixel am Bildschirm ausgibt. Wäre toll wenn ihr mir da helfen könntet. Ich möcht eaber nicht mit dem Mode 12h vom Interupt 10h arbeiten.

Gruß svler
Seiten: [1]

Einloggen