Themen

1

OS-Design / bei smp nur mehrere threads desselben prozesses gleichzeitig lauffähig?

« am: 24. February 2013, 18:24 »

Stimmt es ,dass man bei smp nur mehrere threads DESSELBEN Prozesses gleichzeitig auf den verschiedenen kernen laufen lassen kann,weil sich alle Kerne eine MMU teilen?

PS: Welche pros haben schon alle SMP Unterstützung implementiert?

2

OS-Design / PagingFlags

« am: 18. February 2013, 20:09 »

Wenn Ich frischen Kernel Speicher mappe, dann nutze ich in Pgdirentr von Anfang an folgende Flags

Code: [Auswählen]

FLG_IN_MEM | FLG_WRITECACHING | FLG_USED | FLG_WRITABLE
in pgtblentr

Code: [Auswählen]

FLG_IN_MEM | FLG_WRITECACHING | FLG_USED | FLG_WRITABLE | FLG_WRITTEN
Man kann ja nicht feststellen wann bspw im Usermode auf eine Page zugegriffen wird, dh. behaupte ich von Anfang an sie sei Benutzt und beschrieben; damit die MMU da nicht noch nach einem nicht nachweißbaren Zugriff iwas optimiert.

Hat dieses flagset iwelche "Nebenwirkungen"?

3

OS-Design / Higher Half Kernel wegen invalid Pointers

« am: 06. February 2013, 20:45 »

Ich bin gerade beim Paging und frage mich Higher-half oder Lower-half.

In OSDEV schreiben sie:

.
-It's easier to set up VM86 processes since the region below 1MB is userspace.
-More generically, user applications are not dependent on how much memory is kernel space (Your application can be linked to 0x400000 regardless of whether kernel is at 0xC0000000, 0x80000000 or 0xE0000000 ...), which makes ABI's nicer.
-If your OS is 64-bits, then 32-bit applications will be able to use the full 32-bit address space.
-'mnemonic' invalid pointers such as 0xCAFEBABE, 0xDEADBEEF, 0xDEADC0DE, etc. can be used.

gut falls ich für meine zukünftige 64 Bit OS Portierung mal 32bit oder 64bit Userspace Programme schreiben will werde ich diese Vorteile sicher vermissen und wenn man für den Kernel z.B Fix 256MB einplant ohne das zu verändern, dann sollte des auch gehen.

Aber was soll der letzte Grund bedeuten(Wieso sind CAFEBABE DEADBEEF) "invalid pointers" und wieso kann man die bei einem Higher Half Kernel doch verwenden??

4

Offtopic / NEON

« am: 03. February 2013, 16:26 »

Ist NEON eigentlich sowas wie SSE für ARM? -Ja schon hat sich erledigt
Des Raspberry Pi hat sowas also noch nich aber da gibz sone FPU.

5

Lowlevel-Coding / conflicting types for built-in function ‘printf’ trotz -nostdinc

« am: 02. February 2013, 11:30 »

bei der Implementierung meines Syscalls habe ich folgendes Problem:

Code: [Auswählen]

gcc -m32 -Werror -Wall -g -fno-stack-protector -nostdinc -I lib -c -o tst.o tst.c
tst.c:5:6: error: conflicting types for built-in function ‘printf’ [-Werror]

6

OS-Design / Speicherideen

« am: 01. February 2013, 14:40 »

Ich sammele in diesem Post einige Ideen zur Verwaltung von Speicher.
Ich gehe hier von einer Speicherverwaltung mit Bitmap aus, die ich für performant(und vorallem dingen fehlersicher genug halte !!!)

1. Dynamische Arrays/Puffer im Kernel:

   Es ist in Betriebsystemen häufig der Fall das man eine Liste aus Daten(strukturen) erstellen muss(zb. eine Liste aus Thread, Prozess oder User structs).
   Wenn diese mehr als 4kb speicher einnehmen könnte man mit krealloc den folgenden Speicherblock alloziieren, was ist wenn der aber schon belegt ist, dann müsste man mit kmalloc(neuesize) einen neuen Bereich alloziieren und die Daten dort hinkopieren. Dann müsste man aber auch alle Pointer auf den Array ändern,was bei vergessen schnell zu fehlern führen kann.

   Ich habe hier ein mehrstufiges System im Sinn:
   Zunächst wird ein Block für einen Pointer alloziiert. Dieser zeigt auf eine Dynamische liste aus Puffer structs diese bestehen aus:
       1. einer ID mit der man den Buffer identifizieren kann
       2. einem Pointer
       3. der Größe
   Soll ein Buffer vergrössert werden und krealloc geht nicht, alloziert man wie besagt einen neuen Speicherbereich und kopiert die Daten dorthin; man braucht aber nur den Ptr in dem Puffer struct zu ändern weil nur dieser als Pointer benutzt  werden sollte. Wird die dynamische Liste aus Puffer structs größer als 4k ändert man den zuerst erwähnten Pointer.
  Der Vorteil daran ist ,dass man z.b nicht für jeden einzelnen task 4kb alloziieren muss wie im Beispielkernel und dass man über einen Offset oder Index direkt auf einen einzelnes Element zugreifen kann. Außerdem verhindert dass Verfahren recht effektiv Bufferoverflows.

 
2. Kopieren/bewegen großer Datenmengen auf der RAM über DMA und externe Datenträger

   Meine memmove und memcpy funktionen kopieren den Speicher ganz konventionel mit XCHG und einer Schleife.
   Das ist sehr langsam(1 ganze sekunde[!] fur 4kb).
   Natürlich könnte ich das mit AVX achtmal schneller machen, aber das allein ist mir zu spießig  

   Man könnte wenn ein beschreibbarer externer Datenträger verfügbar ist, den SATA Host Controller oder USB Hub dazu nutzen den zu bewegenden Speicherbereich erst in eine Datei in dem Datenträger und dann zurück in das zielgebiet zu kopieren.
   Der clue daran:
   Die CPU(s) selbst werden kein bisschen zusätzlich belastet Der Host controller,der auf das kopieren großer Datenmengen ausgelegt ist macht alles selber über DMA.
   Problem:
   Wenn man auf der CPU einfach fortfährt könnte es zu RaceConditions kommen weil die CPU beispielsweise bereits auf die kopierten Speicherbereich zugreifen will, bevor alles kopiert ist.
   Damit man nicht doch auf der CPU warten muss bis alles fertig ist würde ich einfach den Registersatz des Kernels speichern und den Thread wegschedulen. Ich würde ihn dann so lange weggeschedult lassen bis alles fertig ist und DANN(wenn alles kopiert ist) den Registersatz wieder herstellen.
   
   Mit memset wäre das dann ganz ähnlich.
   Ich habe DMA, PCI,USB und SATA alles noch nicht implementiert, wüsste also gern was ich verändern muss, Ich finde einfach die Idee cool die Speichercontroller so umzufunktionieren.

Es wäre gut zu wissen wie und ob meine Ideen in Linux, FreeBSD oder tyndur umgesetzt sind und ob man noch was verbessern kann

7

Lowlevel-Coding / .asm vs .S

« am: 01. February 2013, 13:46 »

Ich wollte einfach mal nachfragen ob der Linker oder Assembler irgendwas "anders macht" wenn man seine assembler Dateien auf .asm statt .S enden lässt.

8

Lowlevel-Coding / Userspace geht nicht

« am: 18. January 2013, 23:52 »

Ich will bei mir den Userspace implementieren aber es geht nicht;entweder passiert gar nichts (keine KBC Interrupts oder Multitasking "A"s"B"s)
meistens folgen aber in großer Zahl:

Code: [Auswählen]

pflash_write: Unimplemented flash cmd sequence (offset 000000000001fff0, wcycle 0x0 cmd 0x0 value 0xda)oder qemu crasht:

Code: [Auswählen]

qemu: fatal: Trying to execute code outside RAM or ROM at 0x0000000026f28966

EAX=00106621 EBX=00036d04 ECX=00000001 EDX=00106018
ESI=0005d980 EDI=0005d976 EBP=00067e5c ESP=00100009
EIP=26f28966 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0001 00000000 00000000 00000000
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 00106040 00000080 0000e900 DPL=3 TSS32-avl
GDT=     0010a8c0 0000002f
IDT=     0010a0c0 000007ff
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
DR6=00000000ffff0ff0 DR7=0000000000000400
CCS=00106621 CCD=0010667a CCO=ADDB   
EFER=0000000000000000
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=0000000000000000 0000 FPR7=0000000000000000 0000
XMM00=00000000000000000000000000000000 XMM01=00000000000000000000000000000000
XMM02=00000000000000000000000000000000 XMM03=00000000000000000000000000000000
XMM04=00000000000000000000000000000000 XMM05=00000000000000000000000000000000
XMM06=00000000000000000000000000000000 XMM07=00000000000000000000000000000000
/home/martin/git/el_toro_repo/build.sh: line 44: 12491 Aborted                 (core dumped) /usr/bin/qemu-system-x86_64 -cdrom ~/git/el_toro_repo/bootable.iso -d int -no-kvm -d int
oder:

Code: [Auswählen]

qemu: fatal: Trying to execute code outside RAM or ROM at 0x0000000026f28966

EAX=00106621 EBX=00036d04 ECX=00000001 EDX=00106018
ESI=0005d980 EDI=0005d976 EBP=00067e5c ESP=00100009
EIP=26f28966 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0001 00000000 00000000 00000000
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 00106040 00000080 0000e900 DPL=3 TSS32-avl
GDT=     0010a8c0 0000002f
IDT=     0010a0c0 000007ff
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
DR6=00000000ffff0ff0 DR7=0000000000000400
CCS=00106621 CCD=0010667a CCO=ADDB   
EFER=0000000000000000
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=0000000000000000 0000 FPR7=0000000000000000 0000
XMM00=00000000000000000000000000000000 XMM01=00000000000000000000000000000000
XMM02=00000000000000000000000000000000 XMM03=00000000000000000000000000000000
XMM04=00000000000000000000000000000000 XMM05=00000000000000000000000000000000
XMM06=00000000000000000000000000000000 XMM07=00000000000000000000000000000000
/home/martin/git/el_toro_repo/build.sh: line 44:  5833 Aborted                 (core dumped) /usr/bin/qemu-system-x86_64 -cdrom ~/git/el_toro_repo/bootable.iso -d int -no-kvm -d int
Code:
http://uploadingit.com/file/b7dsflnyiislyhyq/el_toro_repo.zip

Wahrscheinlich ist die GDT falsch geladen zuminestens ist es komisch, dass sie fast gleich der IDT ist.
Sieht aus als ginge iwas mit dem TSS nicht und TSS überschreibt irgendwelche daten , Ich kann nur spekulieren.Ich habe den Quelltext wochenlang übrprüft und ägere mich jetzt wegen jedem feauture um Hilfe fragen zu müssen aber gut.

9

OS-Design / "Sichtbarkeit" von Segmentregistern im Interruptcontext

« am: 18. January 2013, 19:43 »

Hallo, im Beispielkernel wird mit diesem Code in den Ring3 gewechselt:

Code: [Auswählen]

    // Kernel-Datensegmente laden
    mov $0x10, %ax
    mov %ax, %ds
    mov %ax, %es
Aber wenn dieser Code doch noch im Userspace ist,wieso wird beim Segmentregister ax kein Invalid Opcode ausgelöst. Hat dass was mit dem InterruptFlag zu tun dass im Interrupt Context die CPU automitisch die Segmentregister sichtbar macht?
EDIT:
Ja gut AX sind die letzten 16Bits von EAX(das hätte ich wissen können )

10

Lowlevel-Coding / Dynamische Prozessortaktung

« am: 12. January 2013, 18:59 »

Seit dem Pentium M/K6 takten die meisten Desktop Server CPUs ja dynamisch und soviel Ich weiß geht das übers SMBios.
... aber wie weiß das SMBios ob gerade ein aufgebrezeltes 3D-Spiel oder nur HintergrundProzesse laufen?
Hat das was mit der NOP Instruktion zu tun?

Danke für eure Antworten.

PS: Mittlerweile gibt es so viele allgemeine Fragen über X86 oder Prozessoren allgemein(zB wie man sie baut^^),dass es sinnvoll wäre ein eigenes Board zu öffnen, damit nicht alles in Offtopic verschwindet.

11

OS-Design / Parameter pushen im Longmode

« am: 04. January 2013, 23:24 »

Guten Abend,
In den Tuts wird gerne mal ein Paramater auf den gepusht wenn eine Funktion von Assembler ausgerufen wird.
Geht das im Long Mode auch? Ich habe gehört da übergibt man Parameter gerne über Register.

12

Lowlevel-Coding / Qemu stürzt ab bei Multitasking

« am: 24. December 2012, 03:13 »

Qemu stürtzt ab bei Multitasking

Code: [Auswählen]

pflash_write: Unimplemented flash cmd sequence (offset 000000000001fffc, wcycle 0x0 cmd 0x0 value 0xf000e2c3)
pflash_write: Unimplemented flash cmd sequence (offset 000000000001fff8, wcycle 0x0 cmd 0x0 value 0xf000ff53)
pflash_write: Unimplemented flash cmd sequence (offset 000000000001fff4, wcycle 0x0 cmd 0x0 value 0xf000ff53)
pflash_write: Unimplemented flash cmd sequence (offset 000000000001fff0, wcycle 0x0 cmd 0x0 value 0xfffffff4)
pflash_write: Unimplemented flash cmd sequence (offset 000000000001ffec, wcycle 0x0 cmd 0x0 value 0x1007ac)
pflash_write: Unimplemented flash cmd sequence (offset 000000000001ffe8, wcycle 0x0 cmd 0x0 value 0xf000ff53)
pflash_write: Unimplemented flash cmd sequence (offset 000000000001ffd0, wcycle 0x0 cmd 0x0 value 0x103074)
pflash_write: Unimplemented flash cmd sequence (offset 000000000001ffcc, wcycle 0x0 cmd 0x0 value 0x101048)
PFLASH: Possible BUG - Write block confirm

13

Softwareentwicklung / gcc spinnt(Linkerfehler)[Solved]

« am: 23. December 2012, 22:59 »

Ich kriege folgende LinkerFehler:
Das macht keinen Sinn mtenabled ist vorschriftsmäßig als extern markiert und time kommt in irq.c nichtmal vor.

Code: [Auswählen]

mt/ts.o: In function `init_task':
/home/martin/git/el_toro_repo/src/mt/ts.c:16: multiple definition of `mtenabled'
driver/timer/timer.o:/home/martin/git/el_toro_repo/src/driver/timer/timer.c:9: first defined here
intr/irq.o: In function `handle_irq':
/home/martin/git/el_toro_repo/src/intr/irq.c:8: multiple definition of `time'
driver/timer/timer.o:/home/martin/git/el_toro_repo/src/driver/timer/timer.c:9: first defined here
Selbst wenn ich timer.c und .h  komplett wegkommentiere kommt immernoch:

Code: [Auswählen]

mt/ts.o: In function `init_task':
/home/martin/git/el_toro_repo/src/mt/ts.c:16: multiple definition of `mtenabled'
driver/timer/timer.o:(.bss+0x0): first defined here
irq.c

Code: [Auswählen]

#include <console.h>
#include <irq.h>
#include <cpustate.h>
#include "../driver/keyboard/keyboard.h"
#include "../driver/timer/timer.h"
#include<ioport.h>
cpu_state* handle_irq(cpu_state* cpu)
{ 
cpu_state* new_cpu = cpu;

if (cpu->intr >= 0x28) {
            // EOI an Slave-PIC
            outb(0xa0, 0x20);
}else if(cpu->intr==0x21){kbc_handler(0x21);}
else if(cpu->intr==0x20){timer_handler(&new_cpu);}
// EOI an Master-PIC
outb(0x20, 0x20);
return new_cpu;
}
timer.c

Code: [Auswählen]

#include<stdint.h>
#include<cpustate.h>
#include<ts.h>
#include<stdbool.h>
#include"timer.h"

//extern bool mtenabled;

void timer_handler(cpu_state* new_cpu){
    time++;
    if(mtenabled){
new_cpu=schedule(new_cpu);
    }
}timer.h:

Code: [Auswählen]

#ifndef TIMER_H
#define TIMER_H

#include<stdint.h>
#include<cpustate.h>

extern bool mtenabled;
uint32_t time=0;
void timer_handler(cpu_state* new_cpu);

#endif
ts.c:

Code: [Auswählen]

#include <cpustate.h>
#include <stdint.h>
#include <stdbool.h>
#include "ts.h"

static int current_task = -1;
static int num_tasks=0;
static task tasks[MAX_CPUSTATE];

/*
 * Jeder Task braucht seinen eigenen Stack, auf dem er beliebig arbeiten kann,
 * ohne dass ihm andere Tasks Dinge ueberschreiben. Ausserdem braucht ein Task
 * einen Einsprungspunkt.
 */
task* init_task(void* entry)
{
    if(!mtenabled){
mtenabled=TRUE;
    }
    /*
     * CPU-Zustand fuer den neuen Task festlegen
     */
    cpu_state new_state = {
        .eax = 0,
        .ebx = 0,
        .ecx = 0,
        .edx = 0,
        .esi = 0,
        .edi = 0,
        .ebp = 0,
        //.esp = unbenutzt (kein Ring-Wechsel)
        .eip = (uint32_t) entry,
 
        /* Ring-0-Segmentregister */
        .cs  = 0x08,
        //.ss  = unbenutzt (kein Ring-Wechsel)
 
        /* IRQs einschalten (IF = 1) */
        .eflags = 0x202,
    };
    /*
     * Stack erstellen
     */
    uint8_t new_stack[STDRD_STACKSIZE];
    /*
     * Den angelegten CPU-Zustand auf den Stack des Tasks kopieren, damit es am
     * Ende so aussieht als waere der Task durch einen Interrupt unterbrochen
     * worden. So kann man dem Interrupthandler den neuen Task unterschieben
     * und er stellt einfach den neuen Prozessorzustand "wieder her".
     */
    cpu_state* state = (void*) (&new_stack + STDRD_STACKSIZE - sizeof(new_state));
    *state = new_state;
   
    num_tasks++;
    /*
     * neuen Task struct erstellen, in die Liste eintragen und zurückgeben
     */
    task new_task ={state,new_stack,num_tasks};
    tasks[num_tasks]=new_task;
 
    return &new_task;
}
/*
 * Gibt den Prozessorzustand des naechsten Tasks zurueck. Der aktuelle
 * Prozessorzustand wird als Parameter uebergeben und gespeichert, damit er
 * beim naechsten Aufruf des Tasks wiederhergestellt werden kann
 */
cpu_state* schedule(cpu_state* cpu)
{
    /*
     * Wenn schon ein Task laeuft, Zustand sichern. Wenn nicht, springen wir
     * gerade zum ersten Mal in einen Task. Diesen Prozessorzustand brauchen
     * wir spaeter nicht wieder.
     */
    if (current_task >= 0) {
        tasks[current_task].state = cpu;
    }
    /*
    * Naechsten Task auswaehlen. Wenn alle durch sind, geht es von vorne los
    */
    current_task++;
    current_task %= num_tasks;

    /* Prozessorzustand des neuen Tasks aktivieren */
    cpu = tasks[current_task].state;

    return cpu;
}ts.h

Code: [Auswählen]

#ifndef TS_H
#define TS_H

#include<stdint.h>
#include<cpustate.h>
#include <stdbool.h>

#define STDRD_STACKSIZE 4096 //Stack größe bei der Initialisierung
#define MAX_CPUSTATE 32 // Maximal zahl an Tasks noch keine malloc() funktion implementiert

bool mtenabled=FALSE;

typedef struct {
    cpu_state *state;
    uint8_t stack_a[STDRD_STACKSIZE];
    uint32_t pid;
} task;
task* init_task(void* entry);
cpu_state* schedule(cpu_state* cpu);
#endif
Vielen Dank für die Hilfe

14

Offtopic / Prozessorcaching was muss/kann man selber machen?

« am: 22. December 2012, 16:28 »

http://de.wikipedia.org/wiki/L3-Cache#Prozessor-Cache Caching ist ja ne super Sache um RAM Zugriffe zu beschleunigen.

Ich hab da einige Fragen:

1. Wie geht das (da steht auch was in Intels Prozessor Docs V. 3, K.11 ist mir aber viel zu ausführlich)

2. Vor allem: Was muss/kann man selber implementieren. Ich habe gehört auf SMPs soll das etwas komplizierter sein.

PS: kann das jmd in ein on-topic board verschieben

15

Lowlevel-Coding / C99 parameter geht nicht | softwarepakete vergessen zu inst?

« am: 15. December 2012, 19:10 »

als ich mein OS kompilieren wollt kam:


console.c:84:5: error: ‘for’ loop initial declarations are only allowed in C99 mode
console.c:84:5: note: use option -std=c99 or -std=gnu99 to compile your code

als ich die params dann in der Makefile hatte, hat gcc sie nicht erkannt
ups falsches board

16

Offtopic / Entwickungsumgebungen

« am: 09. December 2012, 20:37 »

Ich probiere zurzeit aus nur mit Terminal zu deven.
Machn des viele?

17

Offtopic / A Guide to Kernel Exploitation, Attacking the Core

« am: 08. December 2012, 20:23 »

https://play.google.com/store/books/details/Enrico_Perla_A_Guide_to_Kernel_Exploitation?id=G6Zeh_XSOqUC#?t=W251bGwsMSwyLDUwMSwiYm9vay1HNlplaF9YU09xVUMiXQ..Sehr interresantes Buch wollt ich nur sagen.
Ich habe ja selber in OS-Dev nur reingeschnüffelt aber viel was ich dabei kennen gelernt habe hilft mir jetzt sehr weiter(z.b RaceConditions oder alle Speicherschutzmechanismenw wie Paging oder Segmentation)
Kennt sich hier jemand damit aus?
Eig könnte man dafür ja auch ein Board machen, könnt ja auch für Kernel Devs interessant sein das eigene OS zu hacken.
Was man damit z.B machen könnte wenn man gut wär Root app für android(http://forum.xda-developers.com/showthread.php?t=2013194)
Die Schwierigkeit ist dabei glaube ich weniger das Linux(das alle Unixoide Kernel viel sicherer als alle anderen sind halt ich für ein gerücht) sondern die ARM Architektur.
PS: Ihr dürft auch was dazu sagen;)

18

Offtopic / Welchen Desktop benutzt ihr?

« am: 12. July 2012, 13:28 »

Frage an alle Linuxer(und FreeBSDler )
Was ist euer Favorite Desktop?
solche Umfragen wurden schon oft gemacht, aber ich wollte nur wissen ob man hier genauso denkt wie in anderen foren

19

OS-Design / rudimentärer Tastaturtreiber geht nicht

« am: 12. July 2012, 12:32 »

Guten Morgen,
Sofort nach dem aktivieren der Tastatur mit "outb(0x60,  0xF4);" wird ein Tastatur IRQ ausgelöst. Danach gehen Interrupts nicht mehr.
Wenn man Interrupts erst nach der Aktivierung anschaltet. Wird nach asm volatile("sti") sofort ein Tastatur IRQ ausgelöst.
Ich glaube eher nicht das es ein Spurious Interrupt ist, weil:
1. Ich den selben Treiber auf tut kernel 5 erfolgreich zum laufen gebracht habe
2. Es unwahrscheinlich ist das immer ein Spurious Interrupt ausgelöst wird
Mein kernel erkennt aber keine Spurious Interrupts
Qemu.log(In der der Inhalt des ISR Registers leider nicht verzeichnet ist):

Code: [Auswählen]

SMM: enter
EAX=00000001 EBX=17fe12b0 ECX=02000000 EDX=00000cfc
ESI=000f321d EDI=0003802d EBP=17fe10d0 ESP=00006f08
EIP=000f384b EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9b00 DPL=0 CS32 [-RA]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0000 00000000 0000ffff 00008b00 DPL=0 TSS32-busy
GDT=     000fd3a8 00000037
IDT=     000fd3e6 00000000
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
DR6=00000000ffff0ff0 DR7=0000000000000400
CCS=000f31f0 CCD=00000001 CCO=LOGICB 
EFER=0000000000000000
SMM: after RSM
EAX=00000001 EBX=17fe12b0 ECX=02000000 EDX=00000cfc
ESI=000f321d EDI=0003802d EBP=17fe10d0 ESP=00006f08
EIP=000f384b EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00c09b00 DPL=0 CS32 [-RA]
SS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
DS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
FS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0000 00000000 0000ffff 00008b00 DPL=0 TSS32-busy
GDT=     000fd3a8 00000037
IDT=     000fd3e6 00000000
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
DR6=00000000ffff0ff0 DR7=0000000000000400
CCS=00000000 CCD=00000000 CCO=EFLAGS 
EFER=0000000000000000
     0: v=21 e=0000 i=0 cpl=0 IP=0008:0000000000100357 pc=0000000000100357 SP=0010:0000000000104f80 EAX=00000000000000f4
EAX=000000f4 EBX=00036d04 ECX=000b8000 EDX=00000060
ESI=0005d987 EDI=0005d976 EBP=00104fa8 ESP=00104f80
EIP=00100357 EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0000 00000000 0000ffff 00008b00 DPL=0 TSS32-busy
GDT=     00105020 00000027
IDT=     00105060 000007ff
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000
DR6=00000000ffff0ff0 DR7=0000000000000400
CCS=00000008 CCD=00104f70 CCO=SUBL   
EFER=0000000000000000
Im Anhang ist mein OS Quellcode.

20

Das Wiki / Page Fault im Paging tutorial kernel

« am: 10. July 2012, 22:11 »

Guten Abend,
Wenn Ich den Paging tutorial kernelstarte gibt es auf allen Emulatoren sofort einen Page Fault
Ist das normal?