Nachrichten

81

Lowlevel-Coding / Re: Verständnisfragen

« am: 04. September 2009, 11:39 »

Und zwar habe ich im Assemblerstub für GRUB folgenden Abschnitt:

Code: [Auswählen]

[SECTION .bss]
ALIGN 32
stack:
resb OS_STACK_SIZE
Dieser Abschnitt reserviert Daten für den Stack (16 KiB). Die Sektion BSS deswegen, weil es sich ja um uninitialisierte Daten handelt. Nun verstehe ich allerdings nicht, warum darüber ein "ALIGN 32" steht.

Ein gewisses Alignment für den Stack (und für alle Daten im allgemeinen) ist für die Performance von Vorteil. Man hätte das auch mit anderen Mitteln erreichen können, z.B. die Stackvariable nachträglich anpassen können.

Und ich glaube zur Zeit gibt es keine Register in aktuellen CPUs, die größer als 16 Bytes sind bzw. von mehr als 16 Byte Alignment profitieren. Also ist die 32 vielleicht etwas übertrieben. (Ich glaube der GCC sorgt in der 64 Bit Version auch nur für 16 Byte Alignment.)

Das würde also heißen, das ein "ALIGN 16" auch ausreichen sollte und man dieses, wenn man die performance nicht betrachtet, auch weglassen könnte.
 

Die einzelnen Sektionen sind mir soweit klar. Nur frage ich mich, warum die Sektionen nach .text (.data und .bss) bei mir und in vielen Tutorials ein ALIGN(0x1000) haben.
Laut Manual heißt dass, das diese Sektionen dann an Page-Aligned werden. Das heißt also, dass .bss an 0x00101000 liegt (laut objdump). Aber was bringt das für Vorteile?

Code: [Auswählen]

.data ALIGN(0x1000) : { /*...*/ }


Page-alignment ist immer dann von Vorteil, wenn Paging im Spiel ist. Falls du deinen Kernel in einen anderen Speicherbereich mappen willst, und nicht mit "halben Seiten" hantieren willst, kann das eventuell deinen Algorithmus vereinfachen.

Wenn du allerdings Programme laden willst, dann ist es von noch größerem Vorteil, dass deren Sektionen page-aligned sind, weil du dann deinen eigenen Lade-Algorithmus ein gutes Stück einfacher gestalten kannst.

Außerdem ist so eine Trennung der Sektionen auf Seitengrenzen Voraussetzung, dass du das No-Execute-Bit effektiv benutzen kannst. (Ich glaube die ersten beiden Gründe sind wichtiger als dieser. Sowas macht eh keiner^^)

Nun gut, dann ist verständlich, warum die Daten Page-aligned sind. Nun ist es in dem Linkerscript von mir so, dass nur die Daten Page-aligned sind. Sollten da nicht alle Sektionen ein "ALIGN(0x1000)" bekommen?
 
Ich habe mir mal die Arbeit gemacht, ein eigenes Linkerscript zu schreiben. Folgendes ist dabei zustande gekommen:

Code: [Auswählen]

ENTRY(_start)
OUTPUT_FORMAT(elf32-i386)

/* some variables */
KERNEL_VMA = 0x00100000; /* VMA = virtual memory address */
KERNEL_LMA = 0x00100000; /* LMA = load memory address */
KERNEL_VMA_TO_LMA = KERNEL_VMA - KERNEL_LMA; /* address offset for e.g. higher half */

SECTIONS
{
/* Load kernel at virtual memory address */
. = KERNEL_VMA;

/* define variable for kernels start address */
kernel_start_address = .;

/* code section and read only data (e.g. strings within c-part)*/
.text : AT(ADDR(.text) - KERNEL_VMA_TO_LMA)
{
*(.text)
*(.rodata)
}

/* Initialised data - should be page aligned */
.data ALIGN(0x1000) : AT(ADDR(.data) - KERNEL_VMA_TO_LMA)
{
*(.data)
}

/* Uninitialised data */
.bss : AT(ADDR(.bss) - KERNEL_VMA_TO_LMA)
{
_sbss = .;
*(.bss)
*(COMMON)
_ebss = .;
}

/* define variable for kernels end address */
kernel_end_address = .;
}
Gibt es da noch etwaige Unstimmigkeiten oder Fehler? Irgendwelche Dinge, die ich nicht berücksichtigt habe?
 
Eines habe ich jetzt aber noch...
In manchen Tutorials ist rodata als extra Sektion angegeben. Dient dies einfach nur der Übersicht? Im OSDev-Wiki steht dann, dass rodata nach .text kommt... Was ist da jetzt richtig, bzw. besser, da ja beides richtig zu sein scheint?
 
 
Gruß Christian

82

Lowlevel-Coding / Verständnisfragen

« am: 04. September 2009, 11:06 »

Moin,
ich möchte nun endlich mal einige Dinge geklärt haben, die bisher ungeklärt waren. Ich hatte die ganze Zeit ein Skript für "ld" aus einem Tutorial genutzt. Nun möchte ich dieses aber auch verstehen und nach dem Lesen des Manuals sind noch ein paar Dinge offen.
 
Die einzelnen Sektionen sind mir soweit klar. Nur frage ich mich, warum die Sektionen nach .text (.data und .bss) bei mir und in vielen Tutorials ein ALIGN(0x1000) haben.
Laut Manual heißt dass, das diese Sektionen dann an Page-Aligned werden. Das heißt also, dass .bss an 0x00101000 liegt (laut objdump). Aber was bringt das für Vorteile?

Code: [Auswählen]

.data ALIGN(0x1000) : { /*...*/ }

Des Weiteren gibt es laut Manual die bss-Sektion für uninitialisierte Daten. Hier gibt es *(.bss) und *(COMMON). Das Manual sagt folgendes:

A special notation is needed for common symbols, because in many object file formats common symbols do not have a particular input section.
...

Was sind denn "common symbols"? Ein kleines Beispiel würde ausreichen...
Weiterhin habe ich in verschiedenen Tutorials immer wieder _sbss und _ebss in der Sektion .bss gesehen. Geben diese start und ende der uninitialisierten Daten an, oder wozu werden diese Angaben benötigt?
 
 
Gruß Christian
 
PS: Ich hoffe meine Sätze sind nicht ganz so wirr, wie sie mir gerade erscheinen, und meine Fragen verständlich
 
 
EDIT
Noch eine kleine Frage. Allerdings diesmal nicht zu ld...
Und zwar habe ich im Assemblerstub für GRUB folgenden Abschnitt:

Code: [Auswählen]

[SECTION .bss]
ALIGN 32
stack:
resb OS_STACK_SIZE
Dieser Abschnitt reserviert Daten für den Stack (16 KiB). Die Sektion BSS deswegen, weil es sich ja um uninitialisierte Daten handelt. Nun verstehe ich allerdings nicht, warum darüber ein "ALIGN 32" steht.

83

Offtopic / Re: C Klasse-Funktion außerhalb redefinieren

« am: 03. September 2009, 11:39 »

Dann müsstest du die Klassen ableiten. In C++ wird das wie folgt gemacht (wie es mit Object-C aussieht, weiß ich nicht):

Code: [Auswählen]

class Klasse {
    public:
   
    void Funktion(int i);
};
class KL1 : public Klasse {
    public:
   
    void Funktion(int i);
};
class KL2 : public Klasse {
    public:
   
    void Funktion(int i);
};
class KL3 : public Klasse {
    public:
   
    void Funktion(int i);
};

Dann würde das Konstrukt gehen. Mir ist nicht bekannt, dass das Konstrukt, wie du es machen möchtest, machbar ist. Aber ich weiß ja auch nicht alles.

84

Offtopic / Re: C Klasse-Funktion außerhalb redefinieren

« am: 03. September 2009, 11:02 »

Kann sein, dass ich falsch liege, aber eigentlich sollte doch anstatt KL der Klassenname stehen, also wie folgt:

Code: [Auswählen]

void Klasse::Funktion(int i) {
     // ...
}

Gruß Christian

85

Offtopic / Re: Hosen runter! Zeigt eure OS ;)

« am: 01. September 2009, 14:55 »

Bei mir war es ähnlich, leider
Unter VMWare kam immer die Meldung wie bei chris12 "[ATAPI] - ERROR 111". Und aus irgendeinem Grund stürzt die mitgelieferte Version von Qemu immer ab...
Unter Bochs habe ich es nicht zum laufen bringen können, allerdings habe ich es auch nicht richtig ausprobiert...

86

OS-Design / Re: Speicher > 4GB

« am: 31. August 2009, 09:00 »

Wenn man selbst ein OS entwickelt für das es noch keine riesige Menge vorhandener Programme gibt zu denen man weiterhin kompatibel sein muss sollte man besser gleich auf echte 64Bit setzen.

Nun ja, so gesehen gibt es noch kein einziges richtiges Programm für mein OS. Es fehlen ja auch noch essentielle Dinge im Kernel.
 
Allerdings wäre es eine Idee, die aktuelle Version des Kernels umzubasteln/neuzuschreiben und auf 64Bit zu setzen. Allerdings müsste ich das nochmals überdenken, da ich ja eigentlich mit 32Bit anfangen wollte.
Ich versuche erst einmal, meinen Kernel soweit umzustrukturieren, dass es leichter fällt, diesen später auf ein 64Bit System zu portieren. Da es ja auch auf 64Bit Prozessoren möglich sein sollte, 32Bit-Programme auszuführen...

87

OS-Design / Speicher > 4GB

« am: 27. August 2009, 11:37 »

Hallo Leute,
mir ist da etwas unklar...
Wenn ich eine 32-Bit Maschine mit sagen wir mal 16GB Arbeitsspeicher habe, muss ich ja die Page Address Extension aktivieren, um alles nutzen zu können.
 
Was passiert allerdings, wenn ein Prozess mehr als 4GB Speicher benötigt (unwahrscheinlich aber möglich)? Der Adressraum von 4GB bleibt ja bestehen, muss ich dann einen solchen Prozess terminieren oder kann man hier über Umwege auch mehr als 4GB zur Verfügung stellen?
 
Gruß Christian

88

Lowlevel-Coding / Bochs und der Debugger

« am: 21. August 2009, 09:33 »

Hallo Leute,
ich bin ja momentan dabei, den Code fürs Paging zu überarbeiten. Nun wird nicht merh von 0 bis zum ende des Kernels gemappt, sondern nur der Kernel, VGA Part, usw.
Nun nutze ich den Debugger von Bochs, um zu schauen, wie das ganze gemappt wurde, wo folgende Ausgabe hervorgegangen ist:

Code: [Auswählen]

0x000b8000-0x000b8fff -> 0x000b8000-0x000b8fff
0x00100000-0x0010ffff -> 0x00100000-0x0010ffff
0x00112000-0x0011bfff -> 0x00112000-0x0011bfff
0xa0000000-0xa0000fff -> 0x00002000-0x00002fff
0xa0001000-0xa009bfff -> 0x00004000-0x0009efff
0xa009c000-0xa00b2fff -> 0x000a1000-0x000b7fff
0xa00b3000-0xa00e1fff -> 0x000b9000-0x000e7fff
0xa00e2000-0xa00e3fff -> 0x00110000-0x00111fff
0xa00e4000-0xa0100fff -> 0x0011c000-0x00138fff
Ich vermute ja mal, dass die verkorkste Ausgabe deswegen ist, da die physikalischen Speicherseiten nicht aneinanderliegen (die des Heaps, also ab 0xa0000000)... Sollte behoben sein, wenn ich die Speicherseiten nehme, die hinter dem Kernel liegen
 
Meine Frage ist nun folgende:
Gibt es die Möglichkeit, den Bochs Debugger so zu nutzen wie den "Debugger" von qemu? Dort habe ich die Möflichkeit, zu egal welcher Laufzeit mir die mappings oder die Register anzeigen zu lassen. Kann man dies irgendwie über die Konfigurationsdatei, die Bochs benötigt einstellen? Es ist nämlich mühselig, immer ein PANIC einzubauen und das dann per lb als Haltepunkt anzugeben.

89

Lowlevel-Coding / Re: PIC Problem...

« am: 18. August 2009, 11:42 »

Nun ja, man müsste schauen, ob ticks wirklich inkrementiert wird.
Gebe doch einfach mal ticks innerhalb der while-Schleife von timer_wait aus, anstatt diese leer laufen zu lassen...

90

Lowlevel-Coding / Re: Multitasking

« am: 18. August 2009, 10:01 »

Mmmmmhhh...
In 0xCXXXXXXX liegt der Heap des Kernels...
Das hatte ich aus irgendeinem Tutorial mal übernommen und nach dem Neuschreiben des Heapmanagers nicht geändert.
Es wäre vielleicht sogar einfacher für das Zuordnen der Speicherseiten, wenn ich den Heap nach 0xAXXXXXXX verlegen würde und alle User-Programme ab 0xB0000000 zur Verfügung stellen würde...
 
Mal sehen, wie ich das dann letzten endes mache...
 
Noch eine Frage. Ich habe vor, nur einen einzigen Virtual 8086 Mode-Task maximal auszuführen. Das Programm führt also einen System Call aus und teilt mir mit, das der Interrupt 0x13 mit den Parametern xyz ausgeführt werden soll. Dafür erstelle ich einen Stack, sperre alle anderen Tasks für die Ausführungszeit, und führe diesen erstellten Task aus.
Meine Frage ist nun, muss ich dafür noch zusätzlich Speicher reservieren, außer für den Stack? Die Speicherseite < 1MB würde ich einfach für die Zeit der Ausführung des Interrupts in den Usermode mappen.

91

Lowlevel-Coding / Re: PIC Problem...

« am: 18. August 2009, 08:24 »

Wie und wo rufst du denn die Funktion "timer_wait" auf?
 
Eigentlich sollte das funktionieren, da der Timer-Handler die Variable ticks immer erhöht und dieses irgendwann größer als der Wert von eticks ist.
 
Kurze Anmerkung: Wenn du die Initialisierung aus Bran's Kernels Development Tutorial übernommen hast, sind immer 18 Ticks eine Sekunde, es sei denn, ich habe da was falsch gelesen...

92

Lowlevel-Coding / Re: Multitasking

« am: 18. August 2009, 08:19 »

Das macht natürlich einiges einfacher...
 
Mal sehen...
Ich muss auch noch genau festlegen, wo die User-Programme/Treiber liegen und was Part des Kernels ist. Eventuell würde es bei mir so aussehen, dass 0-1 GB und GB 3 - 4 (0xCXXXXXXX) Bereiche des Kernels sind.

93

Lowlevel-Coding / Re: Kleiner Assembler Thread

« am: 17. August 2009, 20:40 »

Ich habe zumindest diesen Fehler gefunden.
Es lag wohl daran, dass die Variablen für x und y "words" waren und ich diese beim Schreiben in "double words" konvertiert habe. Momentan kämpfe ich wieder mit der Funktion zum setzen des Cursors, da  der Cursor immer in der zweiten Zeile platziert wird. Ist nun auch behoben.
 
Danke für den Hinweis mit dem newline und den >80 Zeichen, das war mir bisher nicht aufgefallen und ist nun behoben.
 
Wenn ich eine "beliebig" lange Zahl ausgeben möchte, sagen wir mal 250, dann muss ich diese ja Zahl aufbrechen und dann bei jedem Zahlenteil die '0' hinzu addieren. Erst danach kann man den ganzen Krempel per String oder eben einzeln Zeichen für Zeichen ausgeben...

94

Lowlevel-Coding / Re: Kleiner Assembler Thread

« am: 17. August 2009, 12:37 »

So...
ich habe meine Funktion zur Ausgabe eines einzelnen Zeichens etwas verfeinert und bin dabei auf einen komischen Fehler gestoßen. In kernel_main wird der selbe Text 2 mal hintereinander und dann noch ein % ausgegeben. (Zumindest sollte das passieren...):

Code: [Auswählen]

;....
; print out some text
push dword string ; parameter 1 - string to print out
call video_write_string ; call function

push dword string ; parameter 1 - string to print out
call video_write_string ; call function

mov al, 0x25
push eax
call video_write_char
;....
string db "Hello World, From AsmOS",0x0A,0x0D,0

Allerdings wird der String in "string" nur beim ersten Aufruf von video_write_string ausgegeben. Sobald ich die globale Variable video_cursor_y verändere, wird nichts mehr ausgegeben. Hier die aktuelle Version der Funktion "video_write_char", die von "video_write_string" verwendet wird:

Code: [Auswählen]

video_write_char:
push ebp
mov ebp, esp
; save later used registers
push eax
push ebx
push edi

; Calculate position for edi
mov eax, dword [video_cursor_y]
mov ebx, 80
mul ebx
add eax, dword [video_cursor_x]
lea edi, [0xb8000 + eax * 2]

; Read parameter and print out character
mov eax, FUNCTION_PARAMETER_1 ; <-- Character
mov ah, 0x0F ; <-- black background white fontcolor

cmp al, 0x20 ; <-- normal characters
jae .normal
cmp al, 0x0D ; <-- Carriage return
je .cr
cmp al, 0x0A ; <-- line feed
je .nl
jmp .cont

.cr:
mov dword [video_cursor_x], 0
jmp .cont

.nl:
; sobald dieser abschnitt ausgeführt wird, wird kein Text, oder der Text aus irgendeinem Grund schwarz auf schwarz ausgegeben.
;Jedenfalls sieht man nichts mehr.
inc dword [video_cursor_y]
jmp .cont

.normal:
stosw
; Set new cursor positions
inc dword [video_cursor_x]
jmp .cont

.cont:

mov ebx, 80
mov eax, dword [video_cursor_x]
cmp eax, ebx
jae .nl

; Scroll screen if needed ...
call video_scroll
; ... and move cursor
call video_move_cursor

; restore register
pop edi
pop ebx
pop eax

mov esp, ebp
pop ebp
ret 4
Die übergabe geschieht immer mittels "push eax", deswegen auch das ret 4. Das komische dabei ist, dass alle 3 Ausgaben angezeigt werden, sobald ich die Behandlung des Zeilenumbruchs ausklammere.
Des Weiteren kann ich eine Überschreibung der Ausgaben ausschließen, da man sonst zumindest das '%'-Zeichen sehen müsste. Was habe ich in dem Abschnitt zur Behandlung des Zeilenumbruchs falsch gemacht? Greife ich auf die Variable an sich falsch zu?

95

Lowlevel-Coding / Re: Multitasking

« am: 17. August 2009, 08:19 »

Ich bin so langsam dabei, zu beginnen, den ganzen sinnlosen Krempel zu entfernen. Das heißt, dass ich den Code etwas aufräume...
 
Hierzu bin ich momentan beim Multitasking und beim Paging dran. Multitasking deswegen, weil ich bei dem Erstellen des Tasks immer das Page Directory kopiere, dann zu diesem wechsle und dann die Stacks (User-, TSS- und Kernelstack) mappe und mit Werten belege.
Dieses Unterfangen ist gelinde gesagt doof, weswegen ich angefangen habe, eine Funktion zu schreiben, die den Speicher auch dann mappt, wenn das gegebene Page Directory gerade nicht aktuell ist...
 
Hier habe ich mir auch nochmals den Code von Tyndur angeschaut, wobei mir aufgefallen ist, dass nur der User-Stack in das neue Page Directory gemappt wird. Der Kernelstack hingegen wird einfach im Page Directory des Kernels gemappt und initialisiert.
 
Ist es sinnvoll, den Kernelstack immer im Page Directory des Kernels abzulegen, oder sollte ich dabei bleiben, die Stacks immer in das für den Task erstellte Page Directory zu mappen?
 
Gruß Christian

96

Lowlevel-Coding / Re: Kleiner Assembler Thread

« am: 14. August 2009, 18:54 »

Mmmhhh...
Stimmt. C macht das ja automatisch...
 
Danke für die Hilfe. Und noch ein kleines, wahrscheinlich wie vorher auch ein schnell behebbares, Problem. Und zwar versuche ich den blinkenden Cursor an die entsprechende Stelle zu schieben, also hinter das letzte Zeichen. Das Problem ist, dass der Cursor einfach verschwindet... Mein Versuch sieht wie folgt aus:

Code: [Auswählen]

mov eax, [video_cursor_y]
mov ebx, 80
mul ebx
add eax, [video_cursor_x]
mov ebx, eax

mov dx, 0x3D4
mov al, 0xE
out dx, al

mov dx, 0x3D5
mov al, bl
out dx, al

mov dx, 0x3D4
mov al, 0xF
out dx, al

mov dx, 0x3D5
mov al, bh
out dx, al
Natürlich werden wie bei jeder Funktion, die verwendeten Register gesichert. Das sind eax, ebx und edx...
Muss ich hier auch die Position, die ich berechne (y * 80 + x) mit 2 multiplizieren, oder kann man das hier weglassen?

EDIT:
Soeben hat sich das Problem aufgelöst. Der Code wurde nur leicht verändert:

Code: [Auswählen]

; ....
mov dx, 0x3D5
mov ax, bx
shr ax, 8
out dx, ax
; ...
mov dx, 0x3D5
mov ax, bx
out dx, ax
; ...


97

Lowlevel-Coding / Re: Kleiner Assembler Thread

« am: 14. August 2009, 17:29 »

Eigentlich sollte das auch edi sein, anscheinend hatte ich da wegen irgendwas edi im Kopf.
Wie dem auch sei, ebx, edi und eax werden nun gesichert, wie es sein soll.
 
Was ich allerdings noch nicht verstehe ist, warum jeder 2. Buchstabe "verschluckt" wird. Anscheinend wird der 2. Buchstabe immer als Wert für Hintergrundfarbe und Schriftfarbe verwendet...
 
Was ich geändert habe ist die Berechnung von edi, die ja wie folgt ist:

Code: [Auswählen]

eax = (video_cursor_y * 80 + video_cursor_x) + 0xb8000;
und esi wurde in edi umbenannt.
 
Der Aufruf aus write_string sieht wie folgt aus:

Code: [Auswählen]

.printloop:
lodsb
test al, al
jz .printdone

; call function to print out current character
push eax
call video_write_char

jmp .printloop
.printdone:
Merkwürdig ist auch, dass bei einem "push ax" anstatt dem "push eax" ein triple fault ausgelöst wird. Ist das so normal?

98

Lowlevel-Coding / Re: Kleiner Assembler Thread

« am: 14. August 2009, 15:59 »

Nun, so war es auch...
 
Ich habe das geändert, allerdings funktioniert es nicht. Auch habe ich noch eine Frage.
Wenn ich "mov eax, [GlobaleVariable]" schreibe, heißt das doch eigentlich hole den Inhalt von "GlobaleVariable" und schiebe ihn nach eax. Oder ist das falsch?
 
Hier der Code zum ausgeben eines Zeichens:

Code: [Auswählen]

video_write_char:
push ebp
mov ebp, esp
; save later used registers
push eax
push edi

; ToDo: Calculate position for edi
mov esi, 0xb8000

mov eax, [video_cursor_y]
mov ebx, 80
mul ebx
add eax, [video_cursor_x]
mul esi
mov eax, esi

; Read parameter and print out character
mov al, FUNCTION_PARAMETER_1 ; <-- Character
mov ah, 0x0F ; <-- black background white fontcolor
stosw
; ToDo: Set new Cursor positions
mov eax, [video_cursor_x]
inc eax
mov [video_cursor_x], eax

; Move Cursor;
call video_move_cursor

; restore register
pop edi
pop eax

mov esp, ebp
pop ebp
ret 4Am Ende der Datei sind folgende Daten reserviert worden:

Code: [Auswählen]

[SECTION .data]
video_cursor_x dw 0
video_cursor_y dw 0
video_address dd 0xb8000
 
EDIT:
Noch eine kleine Frage nebenbei: Muss ich für die Shift-Operator wirklich lokale Variablen anlegen, oder kann man das auch anders lösen, da z.B. folgendes Konstrukt nicht funktioniert:

Code: [Auswählen]

out dx, [ebx >> 8]


99

Lowlevel-Coding / Re: Kleiner Assembler Thread

« am: 14. August 2009, 14:55 »

Gut...
 
Wie das eben so ist, habe ich noch eine kleine Frage...
Folgendes Konstrukt funktioniert einwandfrei:

Code: [Auswählen]

push byte 0x25
call video_write_char

Nun durchlaufe ich allerdings in der Funktion zum Ausgeben eines Strings diesen und lade ihn mit lodsb nach al. Folglich habe ich mir folgendes gedacht:

Code: [Auswählen]

push byte al
call video_write_char
Allerdings funktioniert dies nicht, da mir der Fehler "error: invalid combination of opcode and operands" entgegengeworfen wird. Also habe ich ax und auch mal eax auf den Stack geschoben und dann die Funktion aufgerufen:

Code: [Auswählen]

push ax ; oder auch 'push eax'
call video_write_char
Allerdings wird so immer nur der letzte Buchstabe ausgegeben. Was mache ich da Falsch? Wenn in "al" ein Leerzeichen ist, wäre es das gleiche, wie folgender Aufruf:

Code: [Auswählen]

push byte 0x20
call video_write_char

Wieso funktioniert das nicht, bzw. nur teilweise, wenn ich ax oder eax auf den Stack schiebe?

100

OS-Design / Re: Planung der Kernelentwicklung

« am: 14. August 2009, 13:22 »

Ich habe mal angefangen eine Roadmap zu schreiben.
Hier schreibe ich die einzelnen Versionen rein, und was dann neues in den Kernel rein soll. Die Schritte an sich sind sehr klein:
 
Version 00.00.00

• Multiboot kompatibler Kernel

Version 00.00.01

• Text ausgeben
• Bildschirm löschen

Version 00.00.02

• GDT Initialisieren
• GDT laden

...
 
Bei der Implementierung mache ich mir dann Gedanken, wie ich das am besten einbaue und prüfe mit Hilfe der Roadmap, ob diese Funktion eventuell später nochmal irgendwo gebraucht werden könnte...