Themen

21

Lowlevel-Coding / Memoryleak im CDI-Treiber ISO9660

« am: 10. January 2015, 19:17 »

Hallo,
ich glaube ich habe einen memoryleak im CDI-Treiber für das Dateisystem ISO9660 gefunden.
In der Funktion iso9660_fs_res_destroy wird der Speicher für die Struktur selber nie freigegeben:

Code: [Auswählen]

int iso9660_fs_res_destroy(struct iso9660_fs_res *res) {
  debug("iso9660_fs_res_destroy(0x%x)\n",res);
  free(res->res.name);
  if (res->res.children!=NULL) {
    size_t i;
    struct iso9660_fs_res *child;
    for (i=0;(child = cdi_list_get(res->res.children,i));i++) iso9660_fs_res_destroy(child);
    cdi_list_destroy(res->res.children);
  }
  return 0;
}

Ich hoffe ich liege mit meiner Vermutung richtig.

22

Offtopic / Weihnachten 2014

« am: 25. December 2014, 03:26 »

Hallo liebe Community,
schon ist wieder so weit und der Weihnachtsmann kommt vorbei .
Ich wünsche euch allen ein frohes Weihnachtsfest!

23

Lowlevel-Coding / CDI-Implementation

« am: 29. November 2014, 11:35 »

Hallo community

Ich habe mal ne Frage zu dem Feld stream_cnt in fs.h. Von wem muss das initialisiert werden und wer muss den Wert inkrementieren und dekrementieren.

24

Lowlevel-Coding / GP bei Taskwechsel

« am: 02. November 2014, 21:53 »

Hallo liebe community,
ich habe mal wieder ein komisches Problem. Ich hab mein Taskswitching implementiert. Nachdem dies für den Kernelmode functioniert hat hab ich jetzt das cs-Register so verändert, dass er theoretisch in den Usermode wechseln sollte, was er aber nicht tut. Stattdessen gibt es #GP und als Errorcode wird der Segmentregisterindex des cs-Registers, der geladen werden sollte, angegeben.
Im Anhang ist ein Bildschirmfoto des Fehlers.
Der Stackbacktrace, den ihr auf dem Foto seht, sind die Werte auf dem Stack, wie sie vor der Exception waren und der instruction pointer zeigt auf den iretq Befehl, der dann die Werte vom Stack gepoppt hätte. Ich weiss nich was falsch ist mit dem Codesegmentindex.

Hier ein kleiner Ausschnitt aus dem Log von Bochs:

Code: [Auswählen]

CPU0:
rax: 00000000_00000000 rcx: 00000000_00000000
rdx: 00000000_00000000 rbx: 00000000_00000000
rsp: ffffff7f_ffffffd8 rbp: 00000000_00000000
rsi: 00000000_00000000 rdi: 00000000_00000000
r8 : 00000000_00000000 r9 : 00000000_00000000
r10: 00000000_00000000 r11: 00000000_00000000
r12: 00000000_00000000 r13: 00000000_00000000
r14: 00000000_00000000 r15: 00000000_00000000
rip: 00000000_00108ec7
eflags 0x00000086: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af PF cf
[CPU0 RD]: LIN 0xffffff7fffffffe8 PHY 0x000000233fe8 (len=8, pl=0): 0x00000000 0x00000202
[CPU0 RD]: LIN 0xffffff7fffffffe0 PHY 0x000000233fe0 (len=8, pl=0): 0x00000000 0x00000018
[CPU0 RD]: LIN 0xffffff7fffffffd8 PHY 0x000000233fd8 (len=8, pl=0): 0x00000080 0x0000004F
[CPU0 RD]: LIN 0x000000000021a138 PHY 0x00000021a138 (len=8, pl=0): 0x00AFFA00 0x0000FFFF
[CPU0 RD]: LIN 0x000000000021a230 PHY 0x00000021a230 (len=8, pl=0): 0x00108E00 0x00088DC3
[CPU0 RD]: LIN 0x000000000021a238 PHY 0x00000021a238 (len=8, pl=0): 0x00000000 0x00000000
[CPU0 RD]: LIN 0x000000000021a128 PHY 0x00000021a128 (len=8, pl=0): 0x00AF9B00 0x0000FFFF
[CPU0 RD]: PHY 0x000000232ff0 (len=8): 0x00000000 0x0023402F ; PML4E
[CPU0 RD]: PHY 0x000000234ff8 (len=8): 0x00000000 0x0023502F ; PDPTE
[CPU0 RD]: PHY 0x000000235ff8 (len=8): 0x00000000 0x0023602F ; PDE
[CPU0 RD]: PHY 0x000000236ff8 (len=8): 0x00000000 0x0023302F ; PTE
[CPU0 WR]: PHY 0x000000236ff8 (len=8): 0x00000000 0x0023306F ; PTE
[CPU0 WR]: LIN 0xffffff7fffffffc8 PHY 0x000000233fc8 (len=8, pl=0): 0x00000000 0x00000010
[CPU0 WR]: LIN 0xffffff7fffffffc0 PHY 0x000000233fc0 (len=8, pl=0): 0xFFFFFF7F 0xFFFFFFD8
[CPU0 WR]: LIN 0xffffff7fffffffb8 PHY 0x000000233fb8 (len=8, pl=0): 0x00000000 0x00010086
[CPU0 WR]: LIN 0xffffff7fffffffb0 PHY 0x000000233fb0 (len=8, pl=0): 0x00000000 0x00000008
[CPU0 WR]: LIN 0xffffff7fffffffa8 PHY 0x000000233fa8 (len=8, pl=0): 0x00000000 0x00108EC7
[CPU0 WR]: LIN 0xffffff7fffffffa0 PHY 0x000000233fa0 (len=8, pl=0): 0x00000000 0x00000018

Wie man sieht wird eine Exception ausgelöst, sobald die CPU den GDT-Eintrag für CS gelesen hat.
Wieso gibt es diesen Fehler? Ich hoffe ihr könnt mir helfen.

25

Lowlevel-Coding / GCC Fehler

« am: 16. October 2014, 17:52 »

Hallo liebe community,

ich habe schon desöfteren gesehen, dass GCC beim kompilieren z.B. folgenden Codes

Code: [Auswählen]

char *buffer = malloc(1, 1000);
In folgendes übersetzt:

Code: [Auswählen]

char *buffer = malloc(1, 1000);
  108a92: be e8 03 00 00        mov    $0x3e8,%esi
  108a97: bf 01 00 00 00        mov    $0x1,%edi
  108a9c: b8 00 00 00 00        mov    $0x0,%eax
  108aa1: e8 3f b6 ff ff        callq  1040e5 <malloc>
  108aa6: 48 63 d8              movslq %eax,%rbx
Oder manchmal setzt er auch anstatt

Code: [Auswählen]

movslq %eax,%rbx das hier ein

Code: [Auswählen]

cltq
Wieso tut er das? Das ist ja fast fahrlässig, denn er zerstört damit eigentlich die oberen 64-bit der Adresse.

Ich kompiliere mit -m64 und der Host ist auch 64-bit.

Ich hoffe ihr könnt meine Frage beantworten.

26

OS-Design / CDI-ATAPI Treiber

« am: 06. August 2014, 22:04 »

Hallo,
ich hab mal ne Frage zu den Packets, die man dem SCSI-Treiber von CDI übergeben muss. In der Packet-Struktur gibt es ein "command"-Feld. Was muss man da reinschreiben? Ich hab mal was gelesen von "READ" und "WRITE" aber bin mir nicht sicher. Und kann man den Gerätetyp irgendwie herausfinden? Also ob Festplatte oder CD.
Ich danke schon mal im Voraus für eure Antworten.

27

tyndur / VFS und Ressourcen

« am: 24. July 2014, 15:52 »

Hallo Leute,
ich implementiere bei meinem OS gerade das VFS, aber stecke momentan in einer kleinen Krise, wie ich das Öffnen von Dateien implementieren will. Daher habe ich mal bei tyndur vorbei geschaut. Aber selbst nach Tagelangem analysieren des Quellcodes von lostio komme ich immer noch nicht klar mit den Ressourcen, die da die ganze Zeit als Parameter übergeben werden. Was ist eine Ressource und warum ist eine Ressource Bestandteil einer Node?
Also bei mir ist eine Node ein Teil des Baumes für das VFS. Ein Mountpoint ist bei mir eine Node in der steht, dass sie ein Mountpoint ist und hat einen Zeiger auf eine cdi_fs_filesystem Struktur.
Ich hoffe ihr könnt mir ein bisschen helfen.

28

OS-Design / YourOS

« am: 15. May 2014, 21:45 »

Hallo liebe Community,
ich möchte hier mal mein OS vorstellen mit dem Namen "YourOS".
Mein Ziel ist ein Monolithischer Kernel im 64-bit Mode.
Es besteht eigentlich aus drei Teilen. Dem Bootloader, der den Übergang zwischen GRUB und Kernel darstellt und auch in den Long Mode wechselt. Dann der eigentliche Kernel und schliesslich noch Programme und eine dazugehörige Lib, die momentan aber nur Grundfunktionen beinhaltet.
Ich möchte mal eure Meinung dazu hören. Ich bin für jegliche Kritik oder Lösungsvorschläge offen.

Hier der Link: https://github.com/Gurgel100

P.S.: Ja ich weiss mein Codestil ist nicht gerade der Beste aber er verbessert sich nach und nach.

29

Lowlevel-Coding / Bochs PANIC bei zugriff auf CDROM

« am: 15. May 2014, 20:06 »

Hi,
ich habe folgendes Problem:
Sobald ich auf die CDROM zugreife kommt folgender Fehler:

Code: [Auswählen]

Device: [HD      ]
Message: IO write(0x01f0): buffer_index >= PACKET_SIZE
Und dieser Fehler kommt zweimal hintereinander. Woher kommt dieser Fehler?
Ich hoffe ihr könnt mir helfen

30

Offtopic / WWW wird 25!

« am: 12. March 2014, 09:40 »

Hi,
ich wollte nur daran erinnern, dass heute das Internet seinen 25. Geburtstag feiert!!! Alles Gute
 

31

Offtopic / Gutes Neues 2013

« am: 30. December 2013, 13:46 »

Hallo liebe Mitglieder,
auch das Jahr 2013 neigt sich langsam dem Ende zu. Wie so oft wünsche ich deshalb einen guten Rutsch ins neue Jahr. Hoffentlich habt ihr gute Vorsätze .

32

Offtopic / Frohe Weihnachten 2013

« am: 24. December 2013, 13:52 »

Hallo liebe Entwickler,
ich wünsche euch ein frohes Weihnachtsfest im Unglücksjahr 2013.
Seit ihr denn schon in Weihnachtsstimmung? Ich irgendwie nicht so. Keine Ahnung woran es liegt.

33

Lowlevel-Coding / Startgerät beim CDI-Treiber?

« am: 22. October 2013, 18:18 »

Hallo,
ich benutze den CDI-Treiber für ATA-Geräte. Jetzt ist meine Frage, woher weiss ich welches Gerät, welche der Treiber beim OS anmeldet, das Startgerät ist? Ich bekomme ja von GRUB die BIOS-Signatur übergeben, aber was bringt die mir? Kann ich damit irgendetwas anfangen?
Ich hoffe ihr könnt mir helfen.

34

Lowlevel-Coding / Problem mit Paging

« am: 11. August 2013, 20:36 »

Hallo,
ich ein sehr kompliziertes Problem. Wenn ich mein Kernel mit dem Optimierungsflags "-03" compiliere, bekomme ich einen Pagefault in der Initialisierungsroutine meiner virtuellen Speicherverwaltung. Die Instruktion an der Addresse ist:

Code: [Auswählen]

mov    -0x1000(,%rax,8),%rax
In %rax steht 0 drinnen. Die dazugehörigen Code-Zeilen in Assembler sind folgende (Fehler an der Addresse 0x102629):

Code: [Auswählen]

0000000000102570 <vmm_Init>:
  102570: 41 57                push   %r15
  102572: 41 b9 01 00 00 00    mov    $0x1,%r9d
  102578: 45 31 c0              xor    %r8d,%r8d
  10257b: 0f 20 de              mov    %cr3,%rsi
  10257e: 41 56                push   %r14
  102580: 49 be 00 f0 ff ff ff mov    $0xffffffffff000,%r14
  102587: ff 0f 00
  10258a: b9 01 00 00 00        mov    $0x1,%ecx
  10258f: 4c 21 f6              and    %r14,%rsi
  102592: ba 01 00 00 00        mov    $0x1,%edx
  102597: 41 55                push   %r13
  102599: 41 54                push   %r12
  10259b: 55                    push   %rbp
  10259c: 53                    push   %rbx
  10259d: 48 81 ec 88 00 00 00 sub    $0x88,%rsp
  1025a4: 48 89 7c 24 78        mov    %rdi,0x78(%rsp)
  1025a9: bf ff 01 00 00        mov    $0x1ff,%edi
  1025ae: 48 89 74 24 20        mov    %rsi,0x20(%rsp)
  1025b3: c7 44 24 18 01 00 00 movl   $0x1,0x18(%rsp)
  1025ba: 00
  1025bb: c7 44 24 10 02 00 00 movl   $0x2,0x10(%rsp)
  1025c2: 00
  1025c3: c7 44 24 08 00 00 00 movl   $0x0,0x8(%rsp)
  1025ca: 00
  1025cb: c7 04 24 00 00 00 00 movl   $0x0,(%rsp)
  1025d2: e8 29 e7 ff ff        callq  100d00 <setPML4Entry>
  1025d7: 66 c7 05 40 fa 10 00 movw   $0x1,0x10fa40(%rip)        # 212020 <PML4e>
  1025de: 01 00
  1025e0: 66 c7 05 39 fa 10 00 movw   $0x4,0x10fa39(%rip)        # 212022 <PDPe>
  1025e7: 04 00
  1025e9: 66 c7 05 32 fa 10 00 movw   $0x200,0x10fa32(%rip)        # 212024 <PDe>
  1025f0: 00 02
  1025f2: 66 c7 05 2b fa 10 00 movw   $0x200,0x10fa2b(%rip)        # 212026 <PTe>
  1025f9: 00 02
  1025fb: 66 c7 44 24 6e 00 00 movw   $0x0,0x6e(%rsp)
  102602: 0f b7 5c 24 6e        movzwl 0x6e(%rsp),%ebx
  102607: 45 31 c0              xor    %r8d,%r8d
  10260a: 48 c7 c6 00 f0 ff ff mov    $0xfffffffffffff000,%rsi
  102611: 41 b9 01 00 00 00    mov    $0x1,%r9d
  102617: b9 01 00 00 00        mov    $0x1,%ecx
  10261c: 48 63 c3              movslq %ebx,%rax
  10261f: 89 df                mov    %ebx,%edi
  102621: 48 89 c2              mov    %rax,%rdx
  102624: 48 89 44 24 60        mov    %rax,0x60(%rsp)
  102629: 48 8b 04 c5 00 f0 ff mov    -0x1000(,%rax,8),%rax
  102630: ff
  102631: 48 8b 14 d5 00 f0 ff mov    -0x1000(,%rdx,8),%rdx
  102638: ff
  102639: c7 44 24 18 00 00 00 movl   $0x0,0x18(%rsp)
  102640: 00
  102641: c7 44 24 10 01 00 00 movl   $0x1,0x10(%rsp)
  102648: 00
  102649: c7 44 24 08 00 00 00 movl   $0x0,0x8(%rsp)
  102650: 00
  102651: 4c 21 f0              and    %r14,%rax
  102654: c7 04 24 00 00 00 00 movl   $0x0,(%rsp)
  10265b: 83 e2 01              and    $0x1,%edx
  10265e: 48 89 44 24 20        mov    %rax,0x20(%rsp)
  102663: e8 98 e6 ff ff        callq  100d00 <setPML4Entry>
...

Die dazugehörigen C-Zeilen sind folgende:

Code: [Auswählen]

bool vmm_Init(uint64_t Speicher, uintptr_t Stack)
{
uintptr_t mapEnd;
uint64_t cr3, i;

volatile PML4_t *PML4;
volatile PDP_t *PDP;
volatile PD_t *PD;
volatile PT_t *PT;

uint16_t PML4i, PDPi, PDi, PTi;

asm("mov %%cr3,%0" : "=r" (cr3));
PML4 = (PML4_t*)(cr3 & 0xFFFFFFFFFF000); //nur die Adresse wollen wir haben

//Lasse den letzten Eintrag der PML4 auf die PML4 selber zeigen
setPML4Entry(511, PML4, 1, 1, 0, 1, 0, 0, VMM_POINTER_TO_PML4, 1, (uintptr_t)PML4);

//Page-Tables für den Adressraum 0 bis 4GB erstellen, für Kernel
//Wieviele Einträge müssen für den Kernel reserviert werden?
PML4e = ((KERNELSPACE_END & PG_PML4_INDEX) >> 39) + 1;
PDPe = ((KERNELSPACE_END & PG_PDP_INDEX) >> 30) + 1;
PDe = ((KERNELSPACE_END & PG_PD_INDEX) >> 21) + 1;
PTe = ((KERNELSPACE_END & PG_PT_INDEX) >> 12) + 1;

PML4 = (PML4_t*)VMM_PML4_ADDRESS;

//PML4 anpassen
for(PML4i = 0; PML4i < PML4e; PML4i++)
{
setPML4Entry(PML4i, PML4, PML4->PML4E[PML4i] & PG_P, 1, 0, 1, 0, 0, VMM_KERNELSPACE, 0, PML4->PML4E[PML4i] & PG_ADDRESS);
...

Kann mir einer bitte sagen, was hier falsch läuft? Ohne Optimierungen läuft es einwandfrei.
Ich hoffe jemand macht sich die Mühe und schaut sich den Code an  .
Wenn jemand noch Verbesserungsvorschläge findet, kann er diese natürlich mitteilen.
Ich danke euch.

35

Softwareentwicklung / Problem mit externen Variablen (vom Linker erstellt)

« am: 08. August 2013, 21:27 »

Hallo,
ich bin gerade dabei cdi_init() zu programmieren und bin auf folgendes Problem gestossen: Ich habe mir in Tyndur angeschaut, wie sie das so machen. Ich habe dort einige Teile übernommen nachdem ich verstanden habe, was diese machen. Nun bekomme ich aber zwei Fehlermeldungen vom Compiler:

Code: [Auswählen]

undefined reference to `__start_cdi_drivers'
undefined reference to `__stop_cdi_drivers'
Die entsprechende Datei ist (cdi.c, nur der wichtigste Teil):

Code: [Auswählen]

#include "cdi.h"

extern struct cdi_driver *__start_cdi_drivers;
extern struct cdi_driver *__stop_cdi_drivers;

cdi_list_t drivers;

void cdi_init()
{
struct cdi_driver **pdrv;
struct cdi_driver *drv;

drivers = cdi_list_create();

// Alle in dieser Binary verfuegbaren Treiber aufsammeln
for(pdrv = &__start_cdi_drivers; pdrv < &__stop_cdi_drivers; pdrv++)
{
drv = *pdrv;
if(drv->init != NULL)
{
drv->init();
cdi_driver_register(drv);
}
}
}
Ich habe schon alles versucht, bekomme aber den Fehler nicht weg. Ich habe auch schon mal diese zwei Variablen im Linkerscript definiert, hat aber nichts gebracht. Ich habe das so verstanden, dass diese zwei Werte vom Linker definiert werden oder nicht?

Hier noch das Linkerscript:

Code: [Auswählen]

OUTPUT_FORMAT(elf64-x86-64)
OUTPUT_ARCH(i386:x86-64)
/*  Bei _start soll die Ausfuehrung losgehen */
ENTRY(_start)

/*
 * Hier wird festgelegt, in welcher Reihenfolge welche Sektionen in die Binary
 * geschrieben werden sollen
 */
SECTIONS
{
    /*
     * . ist die aktuelle Position in der Datei. Wir wollen den Kernel wie gehabt
     * an 1 MB laden, also muessen wir dort die erste Sektion hinlegen
     */
    . = 0x100000;
kernel_start = .;

    /*
     * Der Multiboot-Header muss zuerst kommen (in den ersten 8 kB).
     * Die Standardsektionen einfach hintereinander weg einbinden.
     */
    .text : {
        /*(multiboot) kein Multibootheader vorhanden.*/
        *(.text)
    }
    .data ALIGN(4096) : {
        *(.data)
    }
    cdi_drivers ALIGN(4096) : {
        *(cdi_drivers)
    }
    .rodata ALIGN(4096) : {
        *(.rodata)
    }
    .bss ALIGN(4096) : {
        *(.bss)
    }
kernel_end = .;
}

Ich hoffe ihr könnt mir helfen.

36

Lowlevel-Coding / Interrupts überschreiben lokale Variablen?

« am: 26. July 2013, 20:03 »

Hallo liebe Kollegen,
ich habe momentan Probleme mit meinem Multitasking. Irgendwie werden Daten auf dem Stack überschrieben. Ich programmiere meinen Kernel für den Long Mode (64-Bit Mode). Ich habe, um mein Multitaskingsystem zu testen zwei Tasks erstellt, die einfach Sachen ausgeben mit denen man identifieren kann, welcher Task gerade etwas ausgibt. Zuerst aber gab nachdem der zweite Task an der Reihe war, der erste nie mehr etwas aus, obwohl er auch an die Reihe kam. Ich dachte vielleicht ist etwas falsch an der Sleep-Funkion, die ich in beiden Tasks verwendete. Deswegen änderte ich die Ausgabe in "A" bei Task A und "B" bei Task B. Jetzt kommt aber ein Page Fault, wenn Task A wieder an der Reihe ist, d.h. jeder Task kommt einmal an die Reihe und danach krachts.
Nach einigem Debuggen bin ich darauf gestossen, dass beim Laden einer lokalen Variablen vom Stack, plötzlich der Wert eines Segementregisters auftaucht und dieser dann als Addresse verwendet wird (0x10).
Mir ist dann aufgefallen, dass der Compiler (gcc) zwar bei jeder Funktion einen Stackframe anlegt und zwar wie folgt:

Code: [Auswählen]

push %rbp
mov %rsp,%rbp
Folgender Code wird aber nur hinzugefügt, wenn innerhalb der Funktion eine andere Funktion aufgerufen wird:

Code: [Auswählen]

sub $Wert,%rsp
Und deshalb frage ich mich, was passiert, wenn eine Funktion durch einen Interrupt abgebrochen wird, bei dem der Compiler vom Stackpointer nichts abzieht? Denn eigentlich müsste doch dann die CPU und der Interrupthandler die lokalen Daten der Funktion überschreibt. Ist das so oder ist das nur eine falsche Überlegung von mir?
Und wenn das stimmt, wie kann man sowas verhindern?
Danke.

37

Lowlevel-Coding / CDI und Monolith

« am: 09. July 2013, 13:55 »

Hallo liebe OSEntwickler,

da ich an dem Punkt angekommen bin, an dem ich mich entscheiden muss was für ein Kernel mein Kernel wird, habe ich mich für einen monolithischen Kernel entschieden (oder sowas ähnliches wie Windows). Nun würde ich gerne CDI als Schnittstelle zu meinen Treibern benutzen und wenn möglich auch die schon vorhandenen Treiber verwenden. Ist das denn möglich? Wenn ja, was muss ich beachten bzw. was muss ich tun damit dies funktioniert. Ist die Spezifikation, die im Wiki gegeben ist aktuell? Und wo finde ich die schon vorhandenen Treiber für diese Schnittstelle? Ich muss die doch ein bisschen umschreiben, da sie doch für Tyndur (ein Exokernel) entwickelt wurden oder?

Ich danke euch schon im Voraus für eure Hilfe.

38

Lowlevel-Coding / SSE benutzen

« am: 29. June 2013, 17:01 »

Hallo liebe Community,
die FPU kann ja Zahlen Potenzieren. Da aber die FPU nicht gerade schnell ist, dachte ich man könnte ja die schnellere SSE- oder sogar AVX-Einheit verwenden. Ist dies denn möglich?

39

Lowlevel-Coding / Welche Geräte gehören zu PCI?

« am: 22. May 2013, 21:44 »

Hallo,
ich wollte mal fragen, welche Geräte denn alle PCI benutzen (also z.B. ATA, USB, etc.). Ich versuche nämlich einen PCI-Treiber zu schreiben, um damit dann auf das CD-ROM Laufwerk oder die Festplatte zuzugreifen. Geht das überhaupt so?

40

Lowlevel-Coding / Kernelinterner-Debugger

« am: 16. March 2013, 21:40 »

Hallo,
da ich es als Hilfreich ansehe, einen Debugger zu haben, auch ausserhalb eines Debuggers (z.B. bei einem echten PC), habe ich mich entschlossen einen Debugger zu schreiben, der den Interruptvektor 2 benutzt. Momentan sieht der Code so aus:

Code: [Auswählen]

ihs_t *exception_Debug(ihs_t *ihs)
{
#ifdef DEBUGMODE
static uint64_t Stack[1000];
static ihs_t State;
static ihs_t *oldState;
if(Debugged == false) //Wenn noch nicht debugged wurde
{
//vorübergehend einen neuen Zustand herstellen
ihs_t new_state = {
.cs = 0x8, //Kernelspace
.ss = 0x10,
.es = 0x10,
.ds = 0x10,
.gs = 0x10,
.fs = 0x10,

.rdi = ihs, //Als Parameter die Adresse zum Zustand des Programms geben

.rip = (uint64_t)Debug_Main, //Einsprungspunkt der Debugfunktion

.rsp = &Stack[1000],

//IRQs einschalten (IF = 1)
.rflags = 0x202
};
memmove(&State, &new_state, sizeof(ihs_t));
oldState = ihs;
return &State;
}
else //Wenn schon Debugged wurde wieder normalen Zustand herstellen
{
if(ihs->rax == DEBUG_SINGLESTEP)
oldState->rflags |= 0x100;
return oldState;
}
#endif
}

Und der Debugger selber:

Code: [Auswählen]

#ifdef DEBUGMODE

void Debug_Init()
{
Debugged = false;
}

void Debug_Main(ihs_t *ihs)
{
static char lastInput[50];
static char buffer[50];
uint64_t *value;
//Debugconsole
setColor(BG_GREEN | CL_WHITE);
printf("Debugconsole\n");
setColor(BG_BLACK | CL_WHITE);
traceRegisters(ihs);
printf("RFLAGS: 0x");
IntToHex(ihs->rflags, buffer);
printf("\n");

printf(itoa(ihs->cs, buffer));
printf(":");
IntToHex(ihs->rip, buffer);
printf(buffer);
printf(": 0x");
value = ihs->rip;

IntToHex(*value, buffer);
printf(buffer);
printf("\n");
//asm volatile("sti");
gets(buffer);
if(strcmp(buffer, "s"))
return DEBUG_SINGLESTEP;
}
#endif

Bis zum ersten Befehl nach dem iret des Debug-Interrupts funktioniert alles einwandfrei. Der nächste Befehl, der ausgeführt werden sollte ist ein "push %rbp", da es ein Funktionsaufruf ist und der Compiler automatisch den Stackframe anlegt. Nur beim Ausführen des Befehls entsteht ein Double Fault!!!? Wieso gibt es dort einen Double Fault? Ich dachte der entsteht nur bei einem Fehler beim Aufruf eines anderen Exception-Handlers? Aber laut Bochs entsteht der Double Fault sofort nach dem push-Befehl, also es wird vorher nicht der General Protection oder irgendeine andere Exception aufgerufen.
Ich hoffe ihr könnt mir helfen.