Themen

1

Lowlevel-Coding / Farcall vs. Interrupt

« am: 05. June 2005, 14:17 »

Hi,

ich habe schon überall gesucht, aber nichts gefunden:
Was ist schneller, ein Farcall in einen anderen Selektor oder ein Interrupt? Alles ohne Wechsel der Privilegstufe...

Oder allgemein, was ist der schnellste Weg eine Funktion in einem anderen Selektor aufzurufen?

Gruß GhostCoder

2

OS-Design / Segmentierung

« am: 24. May 2005, 14:06 »

Hiho,

ich will mein OS jetzt mehr an den x86 binden als vorher, und daher soll jetzt auch die Segmentierung ausgereitzt werden.

Nur frage ich mich, ob das wirklich einen erheblichen Geschwindigkeitsvorteil bringt, nur ein Pagedirectory(4GB) zu nutzen, den sich dann alle Prozesse teilen?

Das einzige was ich mir dann ja spare ist der Wechsel des PageDirectories beim Contextswitch.
Und der wird ja auch beim TSS geändert, ob ich will oder nicht...

Außerdem gibt es ja auch SYSENTER/SYSCALL Opcodes, die den Geschwindigkeitsvorteil wieder (fast) aufheben...

Also die Frage: Lohnt sich die ganze Abhängikeit vom x86er Modell oder läuft nen neuer Kernel mit 4GB VM pro Prozess mittlerweile genauso schnell?

Gruß, GhostCoder

3

Lowlevel-Coding / Paging und Multitasking

« am: 11. December 2004, 23:41 »

Hiho,

ich hab bei mir jetzt Paging und Multitasking (die höllische Kombination ) soweit am laufen. Nur zwei Probleme gibt es noch...

1. Userprozesse laufen nur, wenn der KernelCode (1mb-4mb) in den Addressraum gemappt ist, woran kann das liegen? Was wird alles durch Paging beeinflußt? GDT? IDT? Scheduler? usw...

2. Wenn Userprozesse nicht cs=8 und ds=16 bekommen, krieg ich immer die "Fehlermeldung" CPL != DPL. Woran kann das liegen?

MfG GhostCoder

4

Lowlevel-Coding / Paging Code

« am: 23. November 2004, 15:47 »

Hiho,

ich hab mir mal nen paar Paging Makros gemacht, die mir enorm helfen. Hier falls jmd. Interessiere hat:

Code: [Auswählen]


// x86 page flags
#define PAGE_PRESENT 1
#define PAGE_WRITE 2
#define PAGE_SUPERVISOR 4
#define PAGE_WRITETHROUGH 8
#define PAGE_CACHEDISABLE 16
#define PAGE_ACCESSED 32
#define PAGE_DIRTY 64
#define PAGE_USED 512


// Do not touch these! :)
#define GetPageTableFlags(d,t) ( ((DWORD*)d)[t] & 0xFFF )
#define SetPageTableFlags(d,t,f) (  ((DWORD*)d)[t]=(((DWORD*)d)[t] & 0xFFFFF000) | (f & 0xFFF) )
#define GetPageTableOffset(d,t) ( ((DWORD*)d)[t] & 0xFFFFF000 )
#define SetPageTableOffset(d,t,o) (  ((DWORD*)d)[t]=(((DWORD*)d)[t] & 0xFFF) | (o & 0xFFFFF000) )
#define GetPageTableEntryFlags(d,t,e) ( ((DWORD*)(((DWORD*)d)[t] & 0xFFFFF000))[e] & 0xFFF )
#define SetPageTableEntryFlags(d,t,e,f) (  ((DWORD*)(((DWORD*)d)[t] & 0xFFFFF000))[e]=(((DWORD*)(((DWORD*)d)[t] & 0xFFFFF000))[e] & 0xFFFFF000) | (f & 0xFFF) )
#define GetPageTableEntryOffset(d,t,e) ( ((DWORD*)(((DWORD*)d)[t] & 0xFFFFF000))[e] & 0xFFFFF000 )
#define SetPageTableEntryOffset(d,t,e,o) (  ((DWORD*)(((DWORD*)d)[t] & 0xFFFFF000))[e]=(((DWORD*)(((DWORD*)d)[t] & 0xFFFFF000))[e] & 0xFFF) | (o & 0xFFFFF000) )


// Beispielcode um die ersten 4mb linear zu mappen, sowie 0xA0000 auf 0xB8000 (zum testen)
UINT dir=PopPage()*PAGE_SIZE;
UINT tab=PopPage()*PAGE_SIZE;

for(i=0;i<1024;i++)
{
SetPageTableFlags(dir,i,0);
SetPageTableOffset(dir,i,0);
}

SetPageTableFlags(dir,0,PAGE_PRESENT | PAGE_WRITE);
SetPageTableOffset(dir,0,tab);

for(i=0;i<1024;i++)
{
SetPageTableEntryFlags(dir,0,i,PAGE_PRESENT | PAGE_WRITE);
SetPageTableEntryOffset(dir,0,i,i*PAGE_SIZE);
}

SetPageTableEntryOffset(dir,0,0xA0,0xB8*PAGE_SIZE);

// Enable paging
asm("mov %0,%%eax\n\t"
"mov %%eax,%%cr3\n\t"
"mov %%cr0,%%eax\n\t"
"or $0x80000000,%%eax\n\t"
"mov %%eax,%%cr0\n\t"
"mov $0x10,%%ax\n\t"
"mov %%ax,%%ds\n\t"
"mov %%ax,%%es\n\t"
"mov %%ax,%%fs\n\t"
"mov %%ax,%%gs\n\t"
"mov %%ax,%%ss\n\t"
::"m"(dir) );



PopPage ist ne Funktion um eine freie Page zu holen...
Vielleicht hilft es ja jemandem! Ich hätte mich damals über solche Funktionen gefreut

MfG GhostCoder

5

Lowlevel-Coding / gcc und Linux

« am: 17. November 2004, 17:19 »

Hiho,

ich benutze seid einigen Tagen Linux, und wollte jetzt mal mein OS compilen. klappt auch alles wunderbar, nur scheint gcc/ld nicht mit meinem Code klarzukommen. Das Problem sind Strings und Globals (soweit ich bis jetzt weiß).

Wenn ich eine globale Variable initialisiere, z.b. vidmem=0xB8000 oder sowas, greift der Kernel bei vidmem[0] nicht auf die passende Addresse zu, ich muss erst in einer Funktion den passenden Wert setzen! Bei Strings klappt überhaupt nichts, übergeb ich einer Funktion "TEST", kommt bei der Funktion überhaupt nichts an, bzw. ein falscher char pointer.

Kennt jemand das Problem?
P.S.: könntet ihr mal eure gcc und ld commandline bzw. linkerscript hier posten, vielleicht braucht  gcc noch ne extra Option. Danke!

MfG GhostCoder

6

Lowlevel-Coding / Build tool

« am: 13. July 2004, 19:34 »

Hiho,

da ich im "Resource Center" nicht posten darf, schreib ich's einfach hier. Ohne das ich wußste, das mastermesh auch ein Build tool schreibt, hab ich auch mal eins gemacht. Hier findest es hier: http://mitglied.lycos.de/vladdrac/mkver.

Zur Benutzung:
mit mkver -s erzeigt ihr eine neue Versions info. ( in der Datei ".version")
mit mkver -b wird die buildnummer erhöht.
mit mkver -o "layout datei" gibt die layout datei aus, hierbei werden die zeichenketten $major,$minor,$patch und $build durch die aktuellen werte ersetzt.

"mkver -o default.layout" gibt also folgendes zurück:
#ifndef VERSION_H_
#define VERSION_H_


#define VERSION_MAJOR 0
#define VERSION_MINOR 1
#define VERSION_PATCH
#define VERSION_BUILD 2


#endif

Zum Versionsformat:
So sieht es aus:
Major.Minor[Patchlevel][.Build]
Werte in klammern sind optional

Sagt mal wie ihr es findet,
MfG GhostCoder

7

Lowlevel-Coding / Systemcalls

« am: 21. June 2004, 17:48 »

Hiho,

ich würde mal gern wissen in welcher Weise ihr Systemcalls benutzt?
Also, wie z.B. Linux einfach über int 0x80 mit subcodes, oder anders?

Ich frage, weil ich grad meinen Kernel neucode für folgendes System:
Es gibt nur 4 "richtige" (also auf dem x86 über int's) Systemcalls, die da wären:

int Open(int iPid,int iBufferSize,void **ppvBuffer);
int SendMessage(int iProcess,int iMessage);
int GetMessage(struct MSG *psMsg,int iWait);
int Close(int iProcess);

Mit Open wird eine Verbindung zwischen 2 Prozessen aufgebaut, d.h. Speicher für einen Puffer geholt und in den virtuellen Addressraum der beiden Prozesse gemappt, damit während des Schickens kein langwieriges mappen mehr stattfinden muss. In den Buffer können dann halb beide Prozesse schreiben und per Send/Get Message Nachrrichten schicken und empfangen. Mit Close wird dann der Puffer freigegeben.

Der Vorteil hier ist, dass z.B. ein "Window Server" im Netz läuft und die Clienten darauf zugreifen. Auch bleibt der Kernel dadurch extrem klein, weil alle Treiber eigene Prozesse sind. Aber auch z.B. das vfs kann ein eigener Prozess sein. Dadurch kann jeder Teil des Betriebssystems ohne Probleme im Betrieb neugestartet werden usw. Auch kann es "theoretisch" über timeouts unmöglich sein, den pc abzuschießen.

Was sagt ihr dazu?

MfG GhostCoder