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 - RedEagle

Seiten: 1 2 3 [4] 5 6 ... 13

Lowlevel-Coding / Re: standardfarbe 0x07 ändern bei int 0x10

« am: 31. August 2008, 12:52 »

Ich gehe davon aus, das chris12 im RM arbeitet...
Meinse writestring:

Code: [Auswählen]

;;INPUT
;; si    = Adresse der Zeichenkette (offset) 1. Zeichen == Farbe
writestring:
   push ax
   push bx
   push cx
   push dx
   push si
   
   ;Daten vorher �ber die rs232 schicken
   call rs232sendstring
   
   mov  ah, [si] ; Farbe in ch laden
   inc  si       ; Zum 1. Zeichen gehen

  writestring.next:
   mov  al, [si]         ; N�chste zeichen laden
   inc  si
   or   al, al           ; ISt das Byte 0??
   jz   writestring.end

;   mov  ah, ch           ; Farbe laden
   call putchar

   jmp  writestring.next

  writestring.end:
  
   pop  si
   pop  dx
   pop  cx
   pop  bx
   pop  ax
   ret

auch sehr umständlich, da ich stringfunktionen der CPU damals noch nicht kannte

Lowlevel-Coding / Re: standardfarbe 0x07 ändern bei int 0x10

« am: 31. August 2008, 11:55 »

Also int 0x10, ah=0x09 läuft bei mir im 80x25 und 80x50 TEXTMODE

"Beweisfoto":

Bis Execute video16.bin ist es unverändert der 80x25 textmode. In video16.bin wechsel ich dann in den 80x50 textmode.

getestet unter bochs, qemu, und zwei echten PCs

evtl musst du per hand, die neue Position für das nächste zeichen eingeben...
So hab ich es gemacht - ist aber bestimmt nicht die besste Lösung... Ich hatte damals noch ne menge anderen Mist in dieser funktion stehen (\t \b und sonstiges zeug wurde mit berücksichtigt). Aber sie Tut ihren dienst

Code: [Auswählen]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; putchar                            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; al    = Zeichen
;; ah    = Farbe
putchar:
   push ax
   push bx
   push cx
   push dx

    cmp al, 10 ; Newline
    jz  putchar.newline
   
    mov cx, 1    ; Anzahl der ausgaben (f�r int)
    xor bh, bh   ; Codepage 0
    mov bl, ah   ; Farbe laden (f�r int)
    mov ah, 0x09 ; Int 10>09
    int 0x10

    putchar.nextchar:
     call getcursorpos
     cmp  dl, 79          ; ende der Zeile erreicht?
     jz   putchar.newline ; Dann die Zeile wechseln
     inc  dl              ; Sonst die n�chste spalte
     call setcursorpos
     jmp  putchar.ende

    putchar.newline:
     call getcursorpos
     inc dh           ; N�chste reihe
     xor dl,dl        ; Spalte 0
     call setcursorpos
     jmp  putchar.ende
    
   putchar.ende:
   pop  dx
   pop  cx
   pop  bx
   pop  ax
   ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; getcursorpos                       ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; dh    = reihe
;; dl    = Spalte
getcursorpos:
    push ax
    push bx
     xor bh, bh   ; 
     mov ah, 0x03 ; INT 10>03
     int 0x10     ; getcursorposition ( dh <reihe ; dl <spalte )
    pop  bx
    pop  ax
    ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; setcursorpos                       ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; dh    = reihe
;; dl    = Spalte
setcursorpos:
    push ax
    push bx
    
     xor bh, bh   ; codepage
     mov ah, 0x02 ; INT 10>02
     int 0x10     ; Setcursorpos (dh <Reihe ; dl <Spalte)
    pop  bx
    pop  ax
    ret

Das Wiki / Re: Neuauflage des Lowlevel Magazins

« am: 31. August 2008, 00:01 »

Wie währe es, wenn das Magazin nur eine art Überblick/Bericht zum wiki währe.
Es wird also in dem Magazin neue Artikel oder größere Änderungen vorgestellt, oder auf interessante Threads des Forums hingewiesen... So gibt es ein Magazin, das Leuten, die nicht regelmäßg hier sind, einen Überblick verschafft, und zusätzlich währe es vieleicht eine Motivation neue Artikel im wiki zu verfassen...
Somit verpflichtet sich niemand, einen Artikel zu schreiben, und der jenige, der für das Magazin verantwortlich ist, hat auch nicht soooo viel Arbeit.
Vieleicht könnte das Magazin auch Communityübergreifend sein - also auch interessante Artikel von OSDev aufführen...
Eine weitere Idee währen interviews mit OS-Entwicklern...

Lowlevel-Coding / Re: standardfarbe 0x07 ändern bei int 0x10

« am: 30. August 2008, 23:43 »

Ich verwende die Funktion 0x09
Damit geht es auf jeden fall. 0x0E funktionierte bei mir damals auch nicht richtig.

Code: [Auswählen]

    mov cx, 1    ; Anzahl der ausgaben
    xor bh, bh   ; Codepage 0
    mov bl, 0x14 ; Farbe laden
    mov ah, 0x09 ; Int 10>09
    int 0x10

Lowlevel-Coding / Re: iret problem (triple fault)

« am: 23. August 2008, 20:55 »

Zitat von: jgraef am 23. August 2008, 18:38

[..]
Wenn du das iret testweise ausführts, tust du das auch während eines Interrupts? [..]

Zitat von: jgraef am 23. August 2008, 18:38

[..] Außerdem solltest du eigentlich funktionierende Exceptionhandler haben.

Habe ich, versagt nur in diesem fall, weil s.u.

@bluecode: Stimmt, die GDT habe ich vergessen zu mappen. Und dass ich paging nicht deaktivieren muss war mir auch neu.

Vielen dank für die Hilfe.

Lowlevel-Coding / Re: iret problem (triple fault)

« am: 23. August 2008, 16:58 »

Ich schätze mal, das es erst ab hier interessant wird...

Code: [Auswählen]

check_exception old: ffffffff new e
    17: v=0e e=0000 i=0 cpl=0 IP=0008:00a06949 pc=00a06949 SP=0010:00010ff4 CR2=00012109
EAX=e0000011 EBX=00010ff4 ECX=00c02007 EDX=000003f8
ESI=009fff8f EDI=00a0d800 EBP=009fffa8 ESP=00010ff4
EIP=00a06949 EFL=00000202 [-------] CPL=0 II=1 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300
CS =0008 00000000 ffffffff 00cf9a00
SS =0010 00000000 ffffffff 00cf9300
DS =0010 00000000 ffffffff 00cf9300
FS =0010 00000000 ffffffff 00cf9300
GS =0010 00000000 ffffffff 00cf9300
LDT=0000 00000000 0000ffff 00008000
TR =0000 00000000 0000ffff 00008000
GDT=     00012101 0000001f
IDT=     00a0f0d4 0000018f
CR0=e0000011 CR2=00012109 CR3=00c02007 CR4=00000010
CCS=00000010 CCD=e0000011 CCO=LOGICL
check_exception old: e new e
    18: v=08 e=0000 i=0 cpl=0 IP=0008:00a06949 pc=00a06949 SP=0010:00010ff4 EAX=e0000011
EAX=e0000011 EBX=00010ff4 ECX=00c02007 EDX=000003f8
ESI=009fff8f EDI=00a0d800 EBP=009fffa8 ESP=00010ff4
EIP=00a06949 EFL=00000202 [-------] CPL=0 II=1 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300
CS =0008 00000000 ffffffff 00cf9a00
SS =0010 00000000 ffffffff 00cf9300
DS =0010 00000000 ffffffff 00cf9300
FS =0010 00000000 ffffffff 00cf9300
GS =0010 00000000 ffffffff 00cf9300
LDT=0000 00000000 0000ffff 00008000
TR =0000 00000000 0000ffff 00008000
GDT=     00012101 0000001f
IDT=     00a0f0d4 0000018f
CR0=e0000011 CR2=00012109 CR3=00c02007 CR4=00000010
CCS=00000010 CCD=e0000011 CCO=LOGICL
check_exception old: 8 new e
qemu: fatal: triple fault
EAX=e0000011 EBX=00010ff4 ECX=00c02007 EDX=000003f8
ESI=009fff8f EDI=00a0d800 EBP=009fffa8 ESP=00010ff4
EIP=00a06949 EFL=00000202 [-------] CPL=0 II=1 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300
CS =0008 00000000 ffffffff 00cf9a00
SS =0010 00000000 ffffffff 00cf9300
DS =0010 00000000 ffffffff 00cf9300
FS =0010 00000000 ffffffff 00cf9300
GS =0010 00000000 ffffffff 00cf9300
LDT=0000 00000000 0000ffff 00008000
TR =0000 00000000 0000ffff 00008000
GDT=     00012101 0000001f
IDT=     00a0f0d4 0000018f
CR0=e0000011 CR2=00012109 CR3=00c02007 CR4=00000010
CCS=00000010 CCD=e0000011 CCO=LOGICL
FCW=037f FSW=0000 [ST=0] FTW=00 MXCSR=00001f80
FPR0=0000000000000000 0000 FPR1=0000000000000000 0000
FPR2=0000000000000000 0000 FPR3=0000000000000000 0000
FPR4=0000000000000000 0000 FPR5=0000000000000000 0000
FPR6=9000000000000000 4000 FPR7=8000000000000000 4000
XMM00=00000000000000000000000000000000 XMM01=00000000000000000000000000000000
XMM02=00000000000000000000000000000000 XMM03=00000000000000000000000000000000
XMM04=00000000000000000000000000000000 XMM05=00000000000000000000000000000000
XMM06=00000000000000000000000000000000 XMM07=00000000000000000000000000000000

und hier der anfang des codes... Wobei hier eigentlich alles stimmt... zumindest passen die werte in cr0 und cr3

Code: [Auswählen]

_ZN12multitasking9StartTaskEPN11processlist7processE:



cli

    mov eax, dword [esp+4]      ;### proc
    mov ebx, dword [eax+4*2]    ;### proc.esp
    mov ecx, dword [eax+4*13]   ;### proc.PageDirectory

;Paging deaktivieren
    mov  eax, cr0
    and  eax, 0x7FFFFFFF
    mov  cr0, eax

;neue virtueller speicher
    mov eax, ecx ;hier ist das PD drinne
    mov cr3, eax

;paging aktivieren
    mov  eax, cr0
    or   eax, 0x80000000
    mov  cr0, eax

    mov esp, ebx    ; esp setzen
                    ; so siehts jetzt auf dem stack aus: eflags/cs/eip/ (oben nach unten)

;... jetzt kommt der ret, bzw iret - teil

Was ich oben noch vergessen zu sangen habe: cs des prozesses ist gleich dem cs des kernels.
Der prozess läuft mit kernelrechten...

Lowlevel-Coding / iret problem (triple fault)

« am: 23. August 2008, 15:05 »

Hi
Momentan beschäftige ich mich mit multitasking, und möchte ertsmal testweise ein einzigen prozess starten. Dazu legen ich eine neue PD an, und mappe den speicher so, wie ich ihn brauche.
Alles liegt an der adresse, wo es hingehört.
Dann lade ich die neue PD und möchte in den code des prozesses springen. Da ich später taskwechsel per iret machen muss (damit mir keine flags verloren gehen) wollte ich auch für diesen test iret verwenden...
Leider endet das in einem triple fault

Testweise habe ich es dann mal mit ret versucht, und das funktioniert...
Warum funktioniert iret nicht?

aufbau mit ret

Code: [Auswählen]

; *PD wechseln, und stack initialisieren*

mov eax, 0x00000002 ; Die flags
push eax
popf
mov eax, 0x00003000 ; Hier liegt der code
push eax
ret ; und prozess starten, Funktioniert

Der aufbau zum testen des stackinhaltes (in diesem fall des eflags-wertes)

Code: [Auswählen]

; *PD wechseln, und stack initialisieren*

   pop eax ;eip    (0x00003000) > OK
   pop eax ;cs     (0x00000008) > OK
   pop eax ;eflags (0x00000002) > OK
   jmp fncprint
  hlt
;iret

Und so mach ichs mit iret

Code: [Auswählen]

; *PD wechseln, und stack initialisieren*

iret

Wie man sieht, sind die werte auf dem stack korrect, und wenn ich manuell die flags ändere, und dann in den code springe funktionierts auch, nur mit iret gets nicht

Code: [Auswählen]

qemu: fatal: triple fault
EAX=e0000011 EBX=00010ff4 ECX=00c02007 EDX=000003f8
ESI=009fff8f EDI=00a0d800 EBP=009fffa8 ESP=00010ff4
EIP=00a06948 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300
CS =0008 00000000 ffffffff 00cf9a00
SS =0010 00000000 ffffffff 00cf9300
DS =0010 00000000 ffffffff 00cf9300
FS =0010 00000000 ffffffff 00cf9300
GS =0010 00000000 ffffffff 00cf9300
LDT=0000 00000000 0000ffff 00008000
TR =0000 00000000 0000ffff 00008000
GDT=     00012101 0000001f
IDT=     00a0f0d4 0000018f
CR0=e0000011 CR2=00012109 CR3=00c02007 CR4=00000010
CCS=00000010 CCD=e0000011 CCO=LOGICL

Wo liegt das problem?

ps.: Ich habe interrupts deaktiviert. Aber wenn ich sie aktiviere, ändert sich nichts.

Lowlevel-Coding / Re: Serielle Schnittstelle unter Windows

« am: 21. July 2008, 12:12 »

Lowlevel-Coding / Re: Serielle Schnittstelle unter Windows

« am: 03. July 2008, 19:38 »

Code: [Auswählen]

char string[1000];
ReadFile(hcom, string, 1000, &nBytesRead, NULL);

Und ja, es ist die winapi

Wie es mit streams geht weiß ich nicht...
Ich habe auch kein windows mehr, um es mal eben zu testen...
schonmal folgendes versucht:

Code: [Auswählen]

fstream com("COM1", ...);o.ä.

Zum ablauf:
"datei" öffnen
Einstellungen vornehmen
timeouts einstellen
aus der datei lesen

Lowlevel-Coding / Re: Serielle Schnittstelle unter Windows

« am: 03. July 2008, 13:12 »

Auch unter Windows kann man dass per CreateFile lösen:

Code: [Auswählen]

HANDLE init()
{
 HANDLE h_com = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0 , NULL);
 DCB dcb;
 COMMTIMEOUTS cto;

 GetCommState(h_com, &dcb);

 dcb.BaudRate = 115200;
 dcb.ByteSize = 8;
 dcb.Parity   = NOPARITY;
 dcb.StopBits = ONESTOPBIT;

 SetCommState(h_com, &dcb);

 GetCommTimeouts(h_com,&cto);

 cto.ReadTotalTimeoutConstant=0;
 cto.ReadTotalTimeoutMultiplier=0;

 SetCommTimeouts(h_com,&cto);

 return h_com; 
}

////////////////////////////////////////////////////////////////////////////////

char getc(HANDLE hcom)
{
 static unsigned long int counter = 0;
 counter++;
  
 unsigned long nBytesRead;
 char input[2];

 ReadFile(hcom, input, 1, &nBytesRead, NULL);

 return input[0];
}

(Ich hatte im code noch einige debug-ausgaben... sollte also irgendetwas komisch/überflüssig sein, liegt es daran

)

OS-Design / Re: Speicherverwaltung

« am: 27. June 2008, 19:57 »

Zitat von: bluecode am 27. June 2008, 15:02

[...]
Zitat
Also die Idee mit den 4 voneinander abhängigen Listen ist sicherlich nicht schlecht, allerdings leider immer sehr unüberschaubar, da ich Listen ja schon vorher immer wieder Programmiert habe
Wenn du deine Funktionen zur Listenmanipulation sehr allgemein fasst (wie zB die Listenimplementation von LOST für CDI [= Common Driver Interface] bzw. meine C++ Template Implementation für pedigree), dann brauchst du nicht mehrmals das gleiche wieder programmieren.
Und generell gesehen ist die Liste mit dem dynamischen Array aka Vector eine der einfachsten Datenstrukturen überhaupt. Ich denke, dass man das schon hinkriegen sollte [...]

Klar kriegt man das hin, und auch unter 1000 Zeilen code

Die "Schwierigkeit" liegt darin, dass man andauernd prüfen muss, ob
a) Eine Liste über eine Page-grenze geht, (also um pages für eine der listen zu reservieren/frei zugeben)
b) Sich 2 elemente einer Liste zusammenfassen lassen.

Es muss also einiges an rechnleistung investiert werden, nur um die Listen zu pflegen.

---
ps.: Man sollte evtl erwähnen, das ich Elektrotechnik studiere und nicht Informatik

Ich habe also nie sowas wie softwaredesign gelernt. Ich male im prinzip ein paar bildchen, verfasse sie in Code. Und bis ich den Code soweit lauffähig hatte, vergingen einige Monate

OS-Design / Re: Speicherverwaltung

« am: 26. June 2008, 15:54 »

Eine Liste, in der die Reservierten pages stehen,
eine Liste in der die Freien Pages stehen,
eine Liste, in der der Byteweise reservierte Speicher steht,
und eine Liste, in der der freie Byteweise reservierbare Speicher steht.
=> 4 voneinander abhängige Listen, und ne menge fast unüberschaubarer code

Ist bestimmt nicht die Optimallösung, aber es Funktioniert

;
und es ist eine Eigenkreation, Ich habe also keine großartigen Theorien zu dem Thema gelesen, sondern einfach selber drauflos entwickelt

---
zum Thema 4MB-Pages:
Ganz zu beginn (also vor dem aktivieren des pagings) bekommt mein kernel 3 4MB-Pages (die 1. 12 Byte im Speicher, physikalische adresse == virtuelle adresse).
Ansonsten arbeite ich nur mit 4KB-Pages.

Lowlevel-Coding / Re: ___stack_chk_fail was fehlt ld an der stelle?

« am: 03. June 2008, 18:05 »

Ich habe das nur aus den schnipseln des originals zusammenkopiert

Hier was richtiges:

Code: [Auswählen]

char c,chr;
PrintChar('0', ulColor);
PrintChar('x', ulColor);
for (c=0 ; c < 8; c++ )
  {
    chr = (char)(ulNumber >> 28)&15;
    if(chr>9) PrintChar(chr-10+'A', ulColor); //bzw 'a'
    else    PrintChar(chr+'0', ulColor);
    ulNumber <<= 4;
  }

Ein array geht natürlich auch - ist wahrscheinlich sogar schneller

Lowlevel-Coding / Re: ___stack_chk_fail was fehlt ld an der stelle?

« am: 03. June 2008, 13:57 »

Soo viel code, nur um ne hexzahl auszugeben, oder verstehe ich den code falsch?

So, kannst du das switch-case - gedöns spaaren

Code: [Auswählen]

char c;
PrintChar('0', ulColor);
PrintChar('x', ulColor);
for ( ; c < 8; c++ )
  {
    c = (ulNumber & 0xf) >> 28;
    if(c>9) PrintChar(c-10+'A', ulColor); //bzw 'a'
    else    PrintChar(c+'0', ulColor);
    ulNumber <<= 4;
  }

Aber zum eigentlichen Problem:
Ich habe zwar noch nie so ein Fehler gehabt, aber es scheint so, als würde der Compiler da irgendetwas am code ergänzen. Und zwar irgendetwas, was mit dem Stack, bzw dessen schutz zu tun hat. (___stack_chk_fail)
Wie Compilierst du die Datei?

Offtopic / Re: RedEagle-OperatingSystem

« am: 05. April 2008, 21:58 »

Zu den Befehlen:
Die Befehle und auch die Konsole selber sind erstmal nur zum Testen da. Sobald das Multitasking funktioniert, wird es natürlich ne gescheite shell geben.
Das konzept sieht jedoch vor, dass man stück für stück selber Prozesse/Tasks anlegen kann. Und dazu gehört auch das erstellen eines virtuellen speicherraumes

Und danke für den Hinweis mit dem BO.

Offtopic / RedEagle-OperatingSystem

« am: 05. April 2008, 19:52 »

Nach über 2,5 jahrne ist RedEagle-OperatingSystem nun so weit, dass man es veröffentlichen kann.

Derzeitige Features

Monolithischer Kernel
PM
Paging
Arbeitet im Textmode (derzeit 80x50)
Senden von Debug-infos über die serielle Schnittstelle
Single-User - System

Geplante Features

Multitasking
Eigenes Dateisystem
Unterstützung weiterer Textmodes (80x25, 90x60, ...)
Auf ASCII-Zeichen basierendes GUI

Programmiersprachen
Bootloader: NASM
16-Bit abschnitt des Kernels: NASM
32-Bit Kernel: C / C++ (g++)
Wobei der Kernel aber nicht objekt-orientiert ist.

Einige screenshots

Image und Sources
www.redeagle-operatingsystem.de.vu

Lowlevel-Coding / Re: paging: Wo muss ich den Fehler suchen?

« am: 24. March 2008, 17:30 »

Ich hab den Fehler endlich Gefunden:

Code: [Auswählen]

KernelPageDirectory += PG_REOSDEFAULT;
Was 3 Bit so alles anrichten können

Lowlevel-Coding / Re: paging: Wo muss ich den Fehler suchen?

« am: 24. March 2008, 16:48 »

So habe die InstallPage_4k etwas geändert:

Code: [Auswählen]

//...

   if(PT[j] == PG_NULL)
   {
    PT[j] = page | PG_REOSDEFAULT; //4KB Page einfügen
    *vaddress = GenerateVirtualAddress((DWORD)i, (DWORD)j); //Und addresse erzeugen

    __asm__ volatile("invlpg %0"::"m" ((char *)(page))); // DWORD page
    return PGERR_NOERROR;
   }

//...

leider bringt das auch nichts

Lowlevel-Coding / Re: paging: Wo muss ich den Fehler suchen?

« am: 23. March 2008, 21:10 »

Fehler gefunden
Der Pagetable-eintrag im Pagedirectory ist falsch...

Trotzdem Danke für eure Hilfe

Mist, stimmt doch

Eintrag im PD: 0x00404007
und an 0x00404000 (physik.) liegt der Wert 0x00C00007

---
Könnte es damit zusammenhängen, ich eine 4MB-Page habe, die an 0x00400000 liegt? - Also die PT auch eine virtuelle adresse hat?

Lowlevel-Coding / Re: paging: Wo muss ich den Fehler suchen?

« am: 22. March 2008, 19:04 »

So, zunächst die Register...

Manchmal kann die Lösung soo einfach sein

Und der Code:
PD ist die Adresse des Kernel-Pagedirectorys
page ist die Physikalische Adresse der freien Page
in vaddress wird die Virtuelle adresse zurückgegeben

Code: [Auswählen]

int InstallPage_4K(DWORD *PD, DWORD page, DWORD *vaddress)
{
 for(DWORD i=0; i<MAX_PD_ENTRYS; i++) //alle PTs durchgehen
 {
  DWORD *PT;
  PT = (DWORD*) PD[i];

  //Prüfen, ob hier ne 4MB page hängt
  if(((DWORD)PT&0x00000087) == PG_REOSDEFAULT_BIG) ///4MB Page, hier ist kein platz
  {
   continue;
  }
  if(((DWORD)PT) == PG_NULL) ///!keine PT? darf beim kernel nicht mehr vorkommen
  {
   return PGERR_INVALIDPT;
  }


  for(DWORD j=0; j<MAX_PT_ENTRYS; j++)//Freien Eintrag in der PT suchen
  {
   if(PT[j] == PG_NULL)
   {
    PT[j] = page | PG_REOSDEFAULT; //4KB Page einfügen
//PG_REOSDEFAULT == (PG_PRESENT | PG_WRITEABLE | PG_USERACCRESS)
    *vaddress = GenerateVirtualAddress((DWORD)i, (DWORD)j); //Und addresse erzeugen
    return PGERR_NOERROR;
   }
  }//PT
 }//PD

 return PGERR_FULLPAGETABLE;
}

---edit---
Ich sehe gerade der der eip unterhalb der 10MB liegt... Der Kernel beginnt bei 10MB...

Auszug aus dem log den ich per RS232 sende:

Code: [Auswählen]

kpalloc: OK
isr14
EXCEPTION: PageFault

---edit2---
Auch wenn die Falsche adresse im eip es vermuten lässt, kpalloc wird korrekt verlassen. Nach dem Verlassen von kpalloc stimmt der eip noch.

---edit3---
Der eip-wert stimmt nicht. Das ist ein Fehler in der regdump-funktion. Aber alle anderen Werte stimmen

Seiten: 1 2 3 [4] 5 6 ... 13