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

Seiten: 1 ... 18 19 [20]
381
Lowlevel-Coding / Problem mit Kernel (wieder einmal)
« am: 05. June 2005, 08:38 »
Wenn du keine IDT hast, musst du Interrupts ausschalten.
Schalte erst die Interrupts aus, programmiere den PIC um, erstelle deine IDT und schalte dann die Interrupts wieder an. Im PM solltest du auf jeden Fall den PIC umprogrammieren, da sonst statt dem Timer Interrupt eine Exception aufgerufen wird.
382
Lowlevel-Coding / PIC installieren
« am: 04. June 2005, 16:33 »
Nein, du brauchst dann keine port.cpp mehr, die inline Funktionen sind ja dazu gedacht, das der Code direkt in die aufrufende Funktion eingefügt wird, ähnlich wie bei Macros.
383
Lowlevel-Coding / PIC installieren
« am: 04. June 2005, 15:50 »
inline unsigned char inportb(unsigned int port)     /* Input a byte from a port */
{
   unsigned char ret;

   asm volatile ("inb %%dx,%%al":"=a" (ret):"d" (port));
   return ret;
}

inline void outportb(unsigned int port,unsigned char value) /* Output a byte to a port  */
{
   asm volatile ("outb %%al,%%dx"::"d" (port), "a" (value));
}

inline void outportw(unsigned int port,unsigned int value)  /* Output a word to a port  */
{
   asm volatile ("outw %%ax,%%dx"::"d" (port), "a" (value));
}


Das muss in die port.h, dann funktioniert es.
384
Offtopic / Plattformübergreifende API
« am: 02. June 2005, 18:39 »
Es gibt Projekte die .NET auf andere Systeme portieren wollen.

Es gibt ja teilweise einheitliche APIs, zum Beispiel POSIX, welches aber eigentlich für UNIX gedacht ist.

MS wird wohl keine einheitliche API einbauen, da sie ja damit Marktanteile verlieren würden, also ist das ganz utopisch ^^.
Man könnte natürlich so ein Interface selbst schreiben, dann würden aber nur wenige Programme es verwenden. Man könnte ja mal Librarys schreiben die POSIX-Funktionen unter Windows bereitstellen, dann könnte man einige UNIXs Programme unter Windows laufen lassen.
385
Offtopic / Extrem langer Bootvorgang
« am: 02. June 2005, 17:30 »
Ich hatte sowas mal, als ich einen Treiber installiert hatte, der nicht mir Windows XP kompatibel war. Mehr kann ich dir auch nicht helfen, habe dann Windows löschen müssen ^^
386
Offtopic / Wo ist der Unterschied
« am: 31. May 2005, 22:29 »
Hm, er dient halt dazu für die meisten Programme nötige Funktionen bereitzustellen.
Hängt halt davon ab, was man unter Treiber versteht ^^
387
Offtopic / Wo ist der Unterschied
« am: 31. May 2005, 22:25 »
Der Floppytreiber ließt die Sektoren von der Diskette.
Der Dateisystem (zB. FAT) Treiber verarbeitet die Informationen, die in den Sektoren stehen und vom Floppytreiber gelesen wurden und dient dazu die Dateien öffnen zu können usw.
388
tyndur / GUI-Design-Vorschläge
« am: 31. May 2005, 19:41 »
Ich habe zwar wenig mitzureden, da ich selber mich vorerst zumindest nicht an LOST beteilige und auch nicht im GUI Team arbeite, ich finde jedoch hannibals Vorschlag bisher am besten.
Es ist zwar nicht die schönste GUI, die es bisher gab, aber sehr simpel und damit als erstes Theme gut geeignet. Wenn man so weit ist, das dieses Theme ohne unnötige Extras gut läuft, kann man sich ja an Zusatzfeatures wie Schatten und so weiter machen. Ich denke ihr solltet aber zuerst mal eine funktionierende GUI mit einem so simplen Theme auf die Beine stellen, bevor ihr euch an das verbessern des Aussehens macht. Was bringt einem das schönste Design, wenn man es nicht richtig anzeigen kann?
389
OS-Design / Paging
« am: 26. May 2005, 22:20 »
Das ist ja die Berechnung gewesen:

Die Nummer der Pagetable kriegst du folgendermassen heraus:
table = addresse >> 22;

Die Nummer der Page innerhalb der Table kriegst du so heraus:
page = ( ( addresse & 0xFFFFF000 ) << 10 ) >> 22;
oder
page= ( addresse >>12)&0x3FF;
wie Roshl schon gesagt hat

Sieht dir mal im PM Tutorial an, wie die Addresse beim Paging aufgelöst wird, da steht drinnen warum man das so berechnet ;D
390
OS-Design / Paging
« am: 26. May 2005, 17:05 »
physAdr / 4 MB für die table würde stimmen, physAdr / 4 KB für die page stimmt nur für die erste Pagetable.
Du kannst das ganz folgendermassen berechnen:
table = physical >> 22;
page = ( ( physical & 0xFFFFF000 ) << 10 ) >> 22;
391
OS-Design / Kernel an virtuelle Adresse laden
« am: 21. May 2005, 22:13 »
Woher weiß der Prozessor denn dann ob die Addressen auf 0x10000 oder auf 0xc0000000 verweisen?
392
OS-Design / Kernel an virtuelle Adresse laden
« am: 21. May 2005, 19:50 »
Ich habe im Moment einen C Kernel, den ich mit GRUB an die physikalische Adresse 0x100000 laden lasse. Ich möchte jetzt den Kernel aber an die virtuelle Adresse 0xC0000000 laden lassen. Wie muss ich jetzt vorgehen um den Kernel an die Adresse 0xC0000000 mappen zu lassen? GRUB aktiviert ja soweit ich weiß kein Paging, und wenn ich in der linkfile 0xC0000000 angeben würde, dürfte der Kernel ja eigentlich nichtmehr funktionieren, da er die C-Funktionen die das Paging aktivieren nicht mehr findet, oder?
393
tyndur / GUI: Technische umsetzung
« am: 20. May 2005, 15:46 »
Wie wäre es denn mit Pipes zu Kommunikation?
Das wäre meiner Meinung nach neben Messagequeues die einfachste Methode, ausserdem sind sie flexibler als Callbacks / Messagequeues
394
OS-Design / Software Multitasking
« am: 15. May 2005, 15:13 »
Danke für den Link, das Tutorial hat mir sehr geholfen^^.

Ich habe es jetzt geschaft das Multitasking einzubauen, jedoch funktioniert irgentwie der Ring 0 -> Ring 3 Change nicht, oder umgekehrt. Wenn ich Prozesse im Ring 0 laufen laufen lasse funktioniert aber alles.

Bochs liefert mir den Fehlercode:
fetch_raw_descriptor: LDTR.valid=0

Der Fehler wird offensichtlich beim 1. Taskswitch ausgelöst, beim Switch vom Idle zum "test" Prozess

Hier ist mein Code:

Diese Prozeduren handlen die Prozesse und wählen den nächsten Task aus:

#include "memory.h"
#include "process.h"

extern void updateGDT();

tTSS kernelTSS;
tProcess *parentProcess;

tProcess *currentProcess;
unsigned long currentStack;

unsigned char enableSchedule;

tProcess *createProcess( unsigned char *id, void *entry ) {
tProcess *process = allocateSystemMemory( sizeof( tProcess ) );
memset( process, 0, sizeof( tProcess ) );

strcpy( process->processID, id );

memset( process->processKernelStack, 0, 256 );
memset( process->processUserStack, 0, 256 );

unsigned long *stack = process->processKernelStack + 256;
*(--stack) = 0x20; // User stack selector
*(--stack) = 0;(unsigned long)process->processUserStack + 256; // User ESP
*(--stack) = 0x200; // EFLAGS
*(--stack) = 0x18; // User code selector
*(--stack) = (unsigned long)entry; // EIP
*(--stack) = 0; // EDX
*(--stack) = 0; // ECX
*(--stack) = 0; // EBX
*(--stack) = 0; // EAX
*(--stack) = 0; // (User) ESP - get's discarded while popping
*(--stack) = 0; // EBP
*(--stack) = 0; // EDI
*(--stack) = 0; // ESI
*(--stack) = 0x20; // DS
*(--stack) = 0x20; // ES
*(--stack) = 0x20; // FS
*(--stack) = 0x20; // GS

process->processStack = stack;
process->next = 0;

return process;
}

void testProcess() {
while( 1 );
}

void initScheduler() {
// create idle process
parentProcess = allocateSystemMemory( sizeof( tProcess ) );
memset( parentProcess, 0, sizeof( tProcess ) );
strcpy( parentProcess->processID, "system/idle" );
parentProcess->processStack = parentProcess->processKernelStack + 256; //stack;

// create test process
tProcess *proc = createProcess( "application/test", testProcess );
parentProcess->next = proc;

// setup tss for ring change
memset( &kernelTSS, 0, sizeof( tTSS ) );

kernelTSS.esp_ring0 = (unsigned long)parentProcess->processKernelStack + 256;
kernelTSS.cs = 0x18;
kernelTSS.ds = 0x20;
kernelTSS.es = 0x20;
kernelTSS.fs = 0x20;
kernelTSS.gs = 0x20;
kernelTSS.ss_ring0 = 0x10;

updateGDT();

currentProcess = parentProcess;
enableSchedule = 1;
}

void schedule() {
if( enableSchedule == 1 ) {
//if( currentProcess == 0 ){
// currentProcess = parentProcess;
//}else{
currentProcess->processStack = (unsigned long*)currentStack;
//}

if( currentProcess->next == 0 ) {
currentProcess = parentProcess;
}else{
currentProcess = currentProcess->next;
}

printk( "Task %s\n", currentProcess->processID );

currentStack = (unsigned long)currentProcess->processStack;
kernelTSS.esp_ring0 = (unsigned int)currentProcess->processKernelStack + 256;
}
}


Die Prozess Struktur sieht so aus:
256 Einträge pro Stack ist zwar schon etwas wenig, sollte aber für Testzwecke reichen^^
struct tProcess {
unsigned char processID[32];

unsigned long *processDirectory;

tMemory processMemory;

unsigned long processKernelStack[256];
unsigned long processUserStack[256];
unsigned long *processStack;

struct tProcess *next;
};


Das hier ist mein Scheduler:
[global _isr_32]
[extern _schedule]
[extern _currentStack]
_isr_32:

cld

pushad
push ds
push es
push fs
push gs

;change the task
;save old esp
mov [_currentStack], esp
call _schedule
mov esp, [_currentStack]

mov al, 0x20
out 0x20, al

pop gs
pop fs
pop es
pop ds
popad

iret


Meine GDT baue ich so auf:
[bits 32]
[section .text]

[global _updateGDT]
[extern _kernelTSS]

DESC_4K_GRAN EQU   128
DESC_BIG EQU    64

DESC_32BIT EQU    8
DESC_TSS EQU     1

DESC_PRESENT EQU   128
DESC_DPL3 EQU 64+32
DESC_DPL0 EQU     0
DESC_SEGMENT EQU    16
DESC_CODE EQU     8
DESC_DATA EQU     0
DESC_DATA_EXPAND_DOWN EQU     4
DESC_CODE_READ_EXEC EQU     2
DESC_DATA_READ_WRITE EQU     2
DESC_ACCESSED EQU     1

_updateGDT:
; fill in tss value
push eax

lgdt [GDT_DESC]

mov eax, _kernelTSS
mov [DESC_KERNEL_TSS+2], al
mov [DESC_KERNEL_TSS+3], ah
shr eax, 16
mov [DESC_KERNEL_TSS+4], al
mov eax, _kernelTSS
shr eax, 24
mov [DESC_KERNEL_TSS+7], al

mov ax, 0x28
ltr ax

pop eax

retn

GDT_START:
DESC_NULL: ;0x0
dd 0
dd 0

DESC_KERNEL_CODE: ;0x8
db 255
db 255
db 0
db 0
db 0
db DESC_PRESENT + DESC_DPL0 + DESC_SEGMENT + DESC_CODE + DESC_CODE_READ_EXEC
db DESC_4K_GRAN + DESC_BIG + 0xF
    db 0
   
    DESC_KERNEL_DATA: ;0x10
db 255
db 255
db 0
db 0
db 0
db DESC_PRESENT + DESC_DPL0 + DESC_SEGMENT + DESC_DATA + DESC_DATA_READ_WRITE
db DESC_4K_GRAN + DESC_BIG + 0xF
    db 0
   
DESC_USER_CODE: ;0x18
db 255
db 255
db 0
db 0
db 0
db DESC_PRESENT + DESC_DPL3 + DESC_SEGMENT + DESC_CODE + DESC_CODE_READ_EXEC
db DESC_4K_GRAN + DESC_BIG + 0xF
    db 0
   
    DESC_USER_DATA: ;0x20
db 255
db 255
db 0
db 0
db 0
db DESC_PRESENT + DESC_DPL3 + DESC_SEGMENT + DESC_DATA + DESC_DATA_READ_WRITE
db DESC_4K_GRAN + DESC_BIG + 0xF
    db 0
   
    DESC_KERNEL_TSS: ;0x28
db 104
db 0
db 0
db 0
db 0
db DESC_PRESENT + DESC_DPL0 + DESC_32BIT + DESC_TSS
db DESC_BIG
db 0

GDT_END:

GDT_DESC:
dw GDT_END - GDT_START
dd GDT_START
[/code]
395
OS-Design / Software Multitasking
« am: 13. May 2005, 14:55 »
Hi, ich habe hier ein paar Fragen über Software Multitasking:

Wenn ich das richtig verstanden habe sollte das tasking so funktionieren:
-> der scheduler wird von irq 0 aufgerufen
-> alle register werden auf den stack gepusht
-> die stackpointer werden auf den stack des tasks geändert
-> alle register werden gepopt
-> der task wird per iret aufgerufen ( ? )

Woher weiß der Prozessor nun, welches privileg-level der task hat? Hängt das vom Codesegment ab, das der task verwendet, oder wie wird das gehandhabt?

Wenn ich jetzt in einem level 3 task einen interrupt aufrufe, brauche ich ja, soweit ich weiß, ein TSS. Wo wird dieses TSS jetzt in der GDT abegelegt?

Ich habe weder ein Tutorial oder mit der Suchfunktion etwas gefunden, was ich gebrauchen könnte. :(
396
OS-Design / Verfügbarer RAM
« am: 06. May 2005, 23:16 »
Hallo,
woher weiß ich, welche Bereiche des RAMs ich im Protected Mode für meine Zwecke nutzen kann, und welche Bereiche durch andere Sachen belegt sind?
Kann man irgentwie feststellen, welche Bereiche im RAM durch BIOS Roms und Grafikkartenspeicher usw. belegt sind?

mfg, SSJ7Gohan
Seiten: 1 ... 18 19 [20]

Einloggen