Themen

1

Lowlevel-Coding / [solved] sofortige reboots nach laden der GDT

« am: 01. October 2009, 21:29 »

Hi!

Hab ein mittelschweres Problem beim Laden meiner GDT. Ich hab mittlerweile alles mögliche probiert, doch sofort nachdem ich die Segmentregister neu lade wird die CPU resetet (sprich qemu rebootet).

Hier folgt mein (hoffentlich nicht all zu grausamer) C Code:

Code: [Auswählen]

#include <triplex.h>

#define GDT_SIZE 5

#define GDT_CODESEG 0x0A
#define GDT_DATASEG 0x02
#define GDT_TSS 0x09
#define GDT_PRESENT 0x80
#define GDT_SEGMENT 0x10
 
#define SYS_CODE_SEL 0x08
#define SYS_DATA_SEL 0x10
#define USER_CODE_SEL 0x18
#define USER_DATA_SEL 0x20
#define TSS_SEL 0x28

typedef struct {
uint32_t size;
uint32_t base;
uint16_t base2;
uint16_t access;
uint16_t size2;
uint16_t base3;
} segment_descriptor;

segment_descriptor gdt[GDT_SIZE];


void gdt_set_descriptor(int i, uint64_t size, uint64_t base, uint16_t access, int dpl)
{
gdt[i].size   = size & 0xFFFF;
gdt[i].size2  = ((size >> 16) & 0x0F) | 0xC0;
gdt[i].base   = base & 0xFFFF;
gdt[i].base2  = (base >> 16) & 0xFF;
gdt[i].base3  = ((base >> 24) & 0xFF);
gdt[i].access = access | ((dpl & 3) << 5);
}


void load_gdt()
{

 struct {
uint16_t size;
uint32_t base;
}  __attribute__((packed)) gdt_ptr = {
.size  = GDT_SIZE*8 - 1,
.base  = (uint32_t)gdt,
};


asm("lgdtl %0\n\t"
"ljmpl $0x08, $1f\n\t"
"1:\n\t"
"mov $0x10, %%eax\n\t"
"mov %%eax, %%ds\n\t"
"mov %%eax, %%es\n\t"
"mov %%eax, %%fs\n\t"
"mov %%eax, %%gs\n\t"
"mov %%eax, %%ss\n\t" : : "m" (gdt_ptr) : "eax");

}

void init_gdt(void)
{
gdt_set_descriptor(0, 0, 0, 0, 0);
gdt_set_descriptor(1, 0x000FFFFF, 0x00000000, GDT_SEGMENT | GDT_PRESENT | GDT_CODESEG, 0);
gdt_set_descriptor(2, 0x000FFFFF, 0x00000000, GDT_SEGMENT | GDT_PRESENT | GDT_DATASEG, 0);
gdt_set_descriptor(3, 0x000FFFFF, 0x00000000, GDT_SEGMENT | GDT_PRESENT | GDT_CODESEG, 3);
gdt_set_descriptor(4, 0x000FFFFF, 0x00000000, GDT_SEGMENT | GDT_PRESENT | GDT_DATASEG, 3);

 
    load_gdt();
}
Hoffe irgendjemand sieht den Fehler und kann mir helfen.

Danke

schneida

2

Offtopic / Award Bios Qualitaet fraghaft oder 2 Kern Problem?

« am: 26. July 2008, 18:24 »

Hallo Leute.

Nachdem mein Speichermanager heute irgendwie nicht richtig wollte und ich ein wenig frustriert war, dachte ich mir ich mach etwas lustigeres. Da ich sowieso noch im Real-Mode agiere, dachte ich, schau ich mir mal die Bios-Interrupts ein wenig naeher an. Dabei stiess ich auf Interrupts zum zeichnen, also ran an ein kleines Zeichendemo.

Gesagt getan, nach ein paar Erkundigungen im Netz ueber Rastern von Linien, stand eine kurze Zeichensequenz da. Mit ein paar Linien, verschiedenen Farben und diversen Rechtecken.

Ich hau mir das also auf eine Diskette und aktiviere meinen P75 (mein Testrechner). Der brauchte fuer das Demo ca 25 Sekunden Zeichen-Zeit.

Da ich neugierige war, Diskette in alten AMD K6 Rechner ein --> Zeichendemo ca 10 sekunden.

Da ich so erpicht darauf war, auch zu wissen wie schnell mein Core 2 Duo mit 3 Ghz das wohl machen wuerde, startete ich auch hier mein kleines Demo. Satte 5 Minuten brauchte der Super-Rechner fuer die Zeichnungen.

Was glaubt ihr woran die schlechte Zeit liegt? An einer mangelnden Qualitaet der Award Biose oder am 2. Kern? Ich schaetze wohl eher am Bios, da das restliche System ja eigentlich recht flott lauft!

schneida

3

Lowlevel-Coding / Bootsektor schreiben auf FAT12 Disk

« am: 01. June 2008, 10:39 »

Hallo!

Nachdem ich mit meinem Triplex OS jetzt schon eine konsole habe und es befehle wie dir, type text.txt und ähnliches versteht, möchte ich meine Diskette  auf der sich der Bootloade befindet mit FAT12 formatieren und anschließend meinen eigenen Bootsektor und Kernel speichern, sodass der Bootloader nicht einfach von der Diskette lesen muss sondern anhand des Dateinamens den Kernel laden kann.

Wie mache ich das?

4

OS-Design / Assembler, C/C++, Pascal ??

« am: 23. April 2008, 07:56 »

Hallo!

Also ich schreib jetzt dieses Thema zum zweiten Mal. Beim ersten mal hat es wohl meine Leitung oder das Forum gegesssen. 

Meine Frage: Welche Sprache bevorzugt ihr für euren Kernel und warum?

Ich hab bisher meinen ersten Kernel samt bootloader in Assembler geschrieben, was auch gar nicht so schwer war wie ich am Anfang dachte. Leider spinnt jetzt der Bootloader (obwohl ich nur Änderungen am Kernel vollzogen hab) und deshalb wollt ich jetzt umsteigen auf Grub. Dieser funktioniert auch allerdings bootet er den Kernel noch nicht richtig.

Ich könnte mir vorstellen, dass ich einen effektiveren Kernel (nicht von der Ausführungsgeschwindigkeit, sondern viel mehr im Verhältnis Code zu daraus Resultierender Leistung) erhalte und viel schnell komplexere Dinge programmieren kann. Mit Assembler muss ich ja wegen jeder Kleinigkeit 10-20 Befehle schreiben und dann hoffen das das funktioniert und außerdem jede Zeile kommentieren (da man sonst so was von schnell den Überblick verliert).
Die meisten Erfahrungen hab ich allerdings bisher unter Windows sowie Linux (Lazarus) mit Pascal gemacht. Deshalb wäre es für mich auch interessant den Kernel in Pascal zu schreiben.

Was bevorzugt ihr?