Nachrichten

1

Lowlevel-Coding / Re: Triple Fault bei Division By Zero

« am: 22. October 2008, 14:54 »

auf Grund der geschulten Augen der Leute im IRC ergab sich folgende Korrektur:

Code: [Auswählen]

// ...
struct idt_entry
{
    word offset_low;
    word selector;
    byte null;
    byte flags;
    word offset_high;
} __attribute__((packed));
// ...

Leider stürzt der Kernel immer noch ab.

2

Lowlevel-Coding / Triple Fault bei Division By Zero

« am: 22. October 2008, 14:46 »

hallöchen,

also, mit Hilfe dieser beiden Seiten:
http://www.osdever.net/bkerndev/Docs/idt.htm
http://www.osdever.net/bkerndev/Docs/isrs.htm

hab ich versucht mir eine IDT und die ersten 32 ISRs einzurichten.

bis auf geringfügige Namensänderungen hab ich die Sachen aus den Tuts weitestgehend übernommen.
zum Test hab ich ans Ende der main() ein 10 / 0 stehen.
Aber anstatt, dass mein fault_handler() mir die Fehlermeldung zeigt,
startet der Rechner/Bochs einfach neu.

Hier mein Kernel:

Code: [Auswählen]

#include "screen.h"
#include "multiboot.h"
#include "gdt.h"
#include "idt.h"

int main(struct mbs* pMBS)
{
int div_by_zero;
gdt_install();
idt_install();
clrscr();
set_color(COLOR_LIGHTGREEN);
printstr("DrakOS Version 1.0\n");
printstr("Copyright (C) 2008, Felix Bytow\n\n");
set_color(COLOR_LIGHTGREY);
printstr("Gebootet von: ");
printstr((char*)(pMBS->mbs_boot_loader_name));
div_by_zero = 10 / 0; // Hier bricht alles zusammen
while(true);
return 0;
}

meine IDT:

Code: [Auswählen]

// idt.h
#if !defined(IDT_H)
#define IDT_H

#include "types.h"

struct idt_entry
{
word offset_low;
word selector;
byte null;
byte flags;
byte offset_high;
} __attribute__((packed));

struct idt_ptr
{
word limit;
dword base;
} __attribute__((packed));

#define IDT_SIZE 256

void idt_fill_descriptor(byte entry, dword base, word sel, byte flags);
void idt_install(void);
void idt_load(void);

void enable_interrupts(void);
void disable_interrupts(void);

#endif


// idt.c
#include "idt.h"
#include "memory.h"
#include "isr.h"

struct idt_entry idt[IDT_SIZE];
struct idt_ptr idtp;

void idt_fill_descriptor(byte entry, dword base, word sel, byte flags)
{
idt[entry].offset_low = (base & 0xFFFF);
idt[entry].selector = sel;
idt[entry].null = 0;
idt[entry].flags = flags;
idt[entry].offset_high = ((base >> 16) & 0xFFFF);
}

void idt_install(void)
{
idtp.limit = (sizeof(struct idt_entry) * IDT_SIZE) - 1;
idtp.base = (dword)&idt;

memset(&idt, 0, sizeof(struct idt_entry) * IDT_SIZE);

isrs_install();
// TODO: Neue Interrupts setzen

idt_load();
}

void enable_interrupts(void)
{
asm("sti");
}

void disable_interrupts(void)
{
asm("cli");
}

und hier die isrs (gekürzt)

Code: [Auswählen]

// isr.h
#if !defined(ISR_H)
#define ISR_H

#include "types.h"

void isr0(void);
// ...
void isr31(void);

struct regs
{
dword gs, fs, es, ds;
dword edi, esi, ebp, esp, ebx, edx, ecx, eax;
dword int_no, err_code;
dword eip, cs, eflags, useresp, ss;
} __attribute__((packed));

void isrs_install(void);
void fault_handler(struct regs *r);

#endif

// isr.c
#include "isr.h"
#include "idt.h"
#include "screen.h"

void isrs_install(void)
{
idt_fill_descriptor(0, (dword)&isr0, 0x08, 0x8E);
// ...
idt_fill_descriptor(31, (dword)&isr31, 0x08, 0x8E);
}

char *exception_messages[] =
{
"Division By Zero",
"Debug",
"Non Maskable Interrupt",
"Breakpoint",
"Into Detected Overflow",
"Out Of Bounds",
"Invalid Opcode",
"No Coprocessor",
"Double Fault",
"Coprocessor Segment Overrun",
"Bad TSS",
"Segment Not Present",
"Stack Fault",
"General Protection Fault",
"Page Fault",
"Unknown Interrupt",
"Coprocessor Fault",
"Alignment Check",
"Machine Check",
"Reserved",
// ...
"Reserved"
};

void fault_handler(struct regs *r)
{
if (r->int_no < 32)
{
set_color(COLOR_RED);
printstr(exception_messages[r->int_no]);
printstr(" Exception. System Halted!");
while (true);
}
}

und das Stückchen asm dazu:

Code: [Auswählen]

global idt_load
extern idtp

idt_load:
    lidt [idtp]
    ret

ich kann beim besten Willen nichts finden, wo meine idt kaputt wäre...

würde mich freuen, wenn mir hier jmd weiterhelfen könnte.

MfG Drako

3

Lowlevel-Coding / Re: Problem mit Kernel, direkter Reboot

« am: 21. October 2008, 16:50 »

ok, hat sich erledigt.

Ich verwende jetzt GRUB als Bootloader und da funktionierts.

4

Lowlevel-Coding / Gelöst: Problem mit Kernel, direkter Reboot

« am: 21. October 2008, 11:55 »

hallo Leute,

bin noch recht neu in der OSDev-Szene.
ich habe also mit dem Tutorial von Cheebi angefangen (Kernel in C)
und hab einfach alles kopiert, kompiliert und auf ne Diskette kopiert.
dann hab ich das gestartet.

und alles funktioniert.

Erfreut über diesen Erfolg hab ich dann auch gleich angefangen einen eigenen Kernel auf Basis dessen aus dem Tutorial geschrieben.
kompiliert und gemerkt, dass der jetzt größer als ein Sektor ist.
also hab ich noch im (fast original belassenen) Bootloader aus der 1 eine 3 gemacht.

als ich mein neues Gebilde nun testen wollte, ging dann nichts mehr.
Rechner an -> Diskettenlaufwerk rattert -> Bildschirm wird schwarz -> Rechner startet neu.

deshalb wollte ich mal fragen, was ich falsch gemacht habe^^

hier die Quellen:

kernel.c

Code: [Auswählen]

#include "screen.h"

int main(void)
{
clrscr();
set_color(0xA);
printstr("DrakOS Version 1.0\n");
printstr("Copyright (C) 2008, Felix Bytow\n\n");
set_color(0x7);
printstr("\t\tSie können den Rechner nun ausschalten.");
}

inout.c

Code: [Auswählen]

#include "inout.h"

void outb(uint_16 port, uint_8 value)
{
asm("outb %1, %0" : : "d" (port), "a" (value));
}

uint_8 inb(uint_16 port)
{
uint_8 result;
asm("inb %1, %0" : "=a" (result) : "d" (port));
return result;
}

screen.c

Code: [Auswählen]

#include "screen.h"
#include "inout.h"
#include "string.h"

static uint_8 iXPos = 0, iYPos = 0, bColor = 0x7;
static char* pScreen = (char*)0xB8000;
#define CHAR_SPACE (char)' '

void clrscr(void)
{
uint_32 x, y;
for (y = 0; y < 25; ++y)
{
for (x = 0; x < 80; ++x)
{
pScreen[y * 160 + x * 2] = CHAR_SPACE;
pScreen[y * 160 + x * 2 + 1] = 0x0;
}
}
gotoxy(0, 0);
}

void gotoxy(uint_8 x, uint_8 y)
{
uint_16 tmp;
if (x >= 80 || y >= 25)
return;
tmp = y * 80 + x;
outb(0x3D4, 14);
outb(0x3D5, tmp >> 8);
outb(0x3D4, 15);
outb(0x3D5, tmp);
iXPos = x;
iYPos = y;
}

void printch(char c)
{
uint_32 x, y;
x = iXPos;
y = iYPos;
switch (c)
{
case '\t':
{
int n;
for (n = 0; n < 4; ++n)
printch(' ');
} break;
case '\n':
{
x = 0;
++y;
if (y == 25)
{
--y;
scroll();
return;
}
gotoxy((uint_8)x, (uint_8)y);
} break;
default:
{
pScreen[y * 160 + x * 2] = c;
pScreen[y * 160 + x * 2 + 1] = bColor;
++x;
if (x == 80)
{
x = 0;
++y;
if (y == 25)
{
--y;
scroll();
return;
}
}
gotoxy((uint_8)x, (uint_8)y);
}
}
}

void printstr(const char* pStr)
{
int iLen, i;
iLen = stringlen(pStr);
for (i = 0; i < iLen; ++i)
printch(pStr[i]);
}

void scroll(void)
{
uint_32 x, y;
for (y = 0; y < 24; ++y)
{
for (x = 0; x < 80; ++x)
{
pScreen[y * 160 + x * 2] = pScreen[(y + 1) * 160 + x * 2];
pScreen[y * 160 + x * 2 + 1] = pScreen[(y + 1) * 160 + x * 2 + 1];
}
}
for (x = 0; x < 80; ++x)
{
pScreen[24 * 160 + x * 2] = CHAR_SPACE;
pScreen[24 * 160 + x * 2 + 1] = 0x0;
}
gotoxy(0, 24);
}

void set_color(uint_8 color)
{
if (color > 0xF)
return;
bColor = color;
}

string.c

Code: [Auswählen]

#include "string.h"

int stringlen(const char* pStr)
{
int iLen;
iLen = 0;
if (!pStr)
return -1;
while (pStr[iLen] != '\0')
++iLen;
return iLen;
}

types.h

Code: [Auswählen]

#if !defined (TYPES_H)
#define TYPES_H

typedef unsigned char byte;
typedef unsigned short word;
typedef unsigned long dword;
typedef unsigned long long qword;

typedef unsigned char uint_8;
typedef unsigned short uint_16;
typedef unsigned long uint_32;
typedef unsigned long long uint_64;

typedef signed char int_8;
typedef signed short int_16;
typedef signed long int_32;
typedef signed long long int_64;

typedef float real_32;
typedef double real_64;

typedef void* ptr;

#endif

In den restlichen *.h-Dateien befinden sich lediglich die Deklarationen/Prototypen der Funktionen in den dazugehörenden *.c-Dateien.

Der Bootloader ist bis auf die Änderung der 1 in eine 3 original geblieben.

Würde mich sehr über Hilfe freuen.

MfG Drako