Themen

61

OS-Design / einfache Keycode-Tabelle

« am: 22. March 2009, 01:10 »

Nabend zusammen,

ich bin gerade dabei, mir eine Keycode-Tabelle auszudenken.
Ich wollte eine 16-Bit-Zahl als Keycode verwenden.
Dazu habe ich mir überlegt, dass ich die oberen 8 Bit für die Sondertasten verwende und die unteren 8 Bit für "normale" Tasten.
Dabei überlege ich mir nur gerade, dass ich an sich eine Eindeutigkeit beibehalten sollte, oder?
Sprich wenn einer Str-Alt-Entf klickt, sind das für mich alles Sondertasten.
Wenn ich die alle auf die oberen acht Bit lege, weiß ich bei der Auswertung dieses Keycodes nicht mehr, welche Tasten jetzt gedrückt wurden.
Wie kann ich das am einfachsten machen?
Ich habe mir auch mal den Link mit der Tabelle angeschaut und den Code aus tyndur, das ist alles irgendwie verwirrend für mich.

62

Lowlevel-Coding / Multitasking aufbauen

« am: 18. March 2009, 15:42 »

Hallo,

ich bin gerade dabei mein System multitasking-fähig zu kriegen.
Als erstes muss ich ja eine TSS einbauen.
Muss ich die schon mit werten befüllen, wenn ja mit welchen?
Dann habe ich mir das mit dem User- und dem Kernel-Stack angeschaut.
Mir ist klar, dass der einen eigenen Kernelstack benötigt.
Den kann ich ja einfach nach ganz unten setzen und dann wars das, oder?
Aber wieso habt ihr den Kernelstack noch einmal new_task->esp gelegt?
Muss der Prozess nicht einen eigenen Stack bekommen?

[EDIT]
Wenn ich nun ein Modul in den Kernelspace lade, wie muss ich denn da dann die Stack-Pointer setzen?

63

Lowlevel-Coding / syscall aufrufen

« am: 18. March 2009, 01:05 »

Nabend zusammen,

ich habe gerade meine Syscalls implementiert.
Ich benutze die Register EAX-EDX und den Stack als Übergabeparameter.
Mein Problem ist nun, wie rufe ich den Syscall im Userspace auf.
Mir ist klar, dass ich das mit int 0x80 mache.
Ich kann ja nur nicht einfach die Register in inline-assembler ändern.
Danach läuft ja nichts mehr.
Wie müsste so ein Code denn aussehen?
Habe leider auch nichts in den anderen OS gefunden.

64

OS-Design / Designfragen zu meinem OS

« am: 16. March 2009, 10:18 »

Hallo zusammen,

ich habe mir gerade ein paar Gedanken gemacht, wie ich mein OS designen sollte.
Ich wollte es so machen, dass der Kernel wirklich nur Paging und Scheduling beherrscht.
Der Rest soll als Modul nachgeladen werden.
Ein Teil der Module soll allerdings im Kernel-Space laufen.
Nun frage ich mich, wie ich den Modulen die Methoden zur Speicherverwaltung im Kernel-Space mitteile.
Das könnte ich entweder als Übergabeparameter machen (ist mir allerdings zu unelegant) oder durch shared-libraries.
Leider weiß ich nicht, wie ich diese implementieren soll (noch ohne FS).

Dann wollte ich auch noch Treiber in den Userspace auslagern.
Leider weiß ich noch nicht, wie ich den Treibern Rechte für die Ports geben kann.
Ich habe gesehen, dass das TSS eine IO-Bitmap besitzt.
Wie funktioniert die denn?

Außerdem hatte ich vor, dass der Kernel so gut wie nie gelockt wird.
Es soll nur ein Big-Kernel-Lock geben, wenn ein panic ausgelöst wurde.
Bei der Pageverwaltung habe ich es mir so gedacht, dass diese immer nur für die Prozesse gelockt werden.
Nun frage ich mich, ob da immer noch das TSS des Prozesses reicht, oder ob ich da dann später Probleme beim iret bekomme.

Dann habe ich mich auch noch gefragt, wie ich den Prozessen bestimmte Möglichkeiten zur Kommunikation biete (Display).
Das würde an sich doch am besten gehen, wenn ich einen Puffer im Kernelspace funktionieren, oder?
Am besten  baut man den Puffer als Ringpuffer auf, oder?
Wie groß sollte der denn am besten sein?

Danke für eure Hilfe

cu rizor

65

Softwareentwicklung / x86-Code auf AMD64 produzieren

« am: 11. March 2009, 22:28 »

Nabend zusammen,

ich bin auf Kubuntu 9.04 AMD64 umgestiegen und wollte mal mein System weiterentwickeln.
Leider finde ich die libgcc.a nicht.
Also die x86-Version nicht.
Die x86-64 habe ich, die ist allerdings wertlos.
Muss ich erst eine x86-Version installieren?
Ich konnte den Code allerdings mit -m32 kompilieren.
Das Problem ist nur das linken.

66

Lowlevel-Coding / Speicher für die Bitmap suchen

« am: 22. February 2009, 00:52 »

Nabend zusammen,

ich war gerade dabei mir meine Bitmap-Algorthmen anzuschauen.
Wollte ein wenig optimieren und habe mir mal den LOST-Code angeschaut.
Da habe ich mich gefragt, warum der Code funktioniert.

Code: [Auswählen]

static struct mem_block get_free_block
    (struct multiboot_info* multiboot_info, size_t i)
{
    struct mem_block result;

    // Überprüfung der BIOS-Memory-Map
    struct multiboot_mmap* mmap;
    uintptr_t mmap_addr = multiboot_info->mi_mmap_addr;
    uintptr_t mmap_end = mmap_addr + multiboot_info->mi_mmap_length;

    for(mmap = (struct multiboot_mmap*) (mmap_addr);
        mmap < (struct multiboot_mmap*) (mmap_end);
        mmap++)
    {
        // Typ 1 steht für freien Speicher
        if (mmap->mm_type == 1) {
            if (i-- == 0) {
                result.start    = (paddr_t)((uintptr_t) mmap->mm_base_addr);
                result.end      = (paddr_t)((uintptr_t) mmap->mm_base_addr
                                + (dword) mmap->mm_length - 1);
                return result;
            }
        }
    }

    result.start = (paddr_t) 0xFFFFFFFF;
    result.end   = (paddr_t) 0;

    return result;
}

i ist bei euch ja die größe der bitmap in bytes.
Wenn ich mir das mal so anschaue sucht ihr euch den letzten freien Block, der in der GRUB-mmap liegt.
Wie kann das funktionieren?
Warum sucht ihr euch nicht einfach einen Block, der die Größe bietet, die ihr sucht.
Dann könnt ihr davon doch einfach eure größe abziehen und schon passt es.

Oder verstehe ich euren Code falsch?

[EDIT]
Ich habe mir mal aus Spaß diese Methode bei mir eingebaut und dann meldet er mir beim booten, dass er nicht genug speicher findet.
Was mich acuh nicht weiter wundert.
i = 4094 bei mir und und er findet genau zwei freie Blöcke.
Die haben jeweils mehr als genug freien Speicher.
Das verwundert mich jetzt nur umso mehr, dass der Code funktioniert

67

Lowlevel-Coding / Problem beim linken

« am: 15. February 2009, 01:45 »

nabend zusammen,

ich habe folgendes Problem:
Ich habe meinen Code ein wenig verändert und meine eigene libc eingebunden.
Nun bekomme ich aber folgenden Fehler:

/home/rizor/Dokumente/Projekte/os-dev/tags/tmp/kernel/krn_msg_display.c.krn_obj: In function `puts_bin_64':
/home/rizor/Dokumente/Projekte/os-dev/trunk/kernel/io/krn_msg_display.c:401: undefined reference to `__udivdi3'
/home/rizor/Dokumente/Projekte/os-dev/trunk/kernel/io/krn_msg_display.c:402: undefined reference to `__umoddi3'

Ich möchte mir der Methode puts_bin_64 wollte ich ein qword in binärer Schreibweise in einen char-array umwandeln.

Der Code der zu diesem Fehler führt, sieht wie folgt aus:
      tmp = qword / (1 << i);
      qword %= (1 << i);

Woran liegt das?
Habe im Internet gefunden, dass diese Methoden in dne Stdlibs von linux definiert sind.
Kann es sein, dass er die nun nicht mehr findet und ich die schreiben muss?

Danke für eure Hilfe.

Gruß
rizor

68

Lowlevel-Coding / Eigene stdlibc einbinden

« am: 13. February 2009, 19:30 »

Nabend,

ich habe mir ein paar stdlibc-Methoden geschrieben und wollte diese in meinen Kernel einbinden.
Die kompilierten Files habe ich in einem getrennten Verzeichnis.
Wie bekomme ich den Linker nun dazu, dass er meine verwendet und nicht die von Linux?

Danke für eure Hilfe.

Gruß
rizor

69

Lowlevel-Coding / Grub mit einem Shellscript konfigurieren

« am: 10. February 2009, 22:25 »

Nabend zusammen,

ich habe einn Problem mit meinem Shell-Script.
Es ist mir nicht möglich, dass ich mein Image mit Grub konfiguriere, wenn ich das Image mit einem Shell-Script konfiguriere.
Meine Zeile sieht wie folgt aus:

echo -e "device (fd0) $2.img\nroot (fd0)\nsetup (fd0)\nquit" | grub

$2 ist einer der Parameter, die übergeben werden.

Woran liegt das?

Danke für eure Hilfe.

Gruß
rizor

70

OS-Design / syscall

« am: 26. January 2009, 14:03 »

Hallo zusammen,

da ich jetzt mein malloc/free fast fertig habe, wollte ich mich um die Syscalls kümmern.
Wie kann man das am besten realisieren?
Ich schreibe einen Microkernel, also muss ich wenn ein Treiber angesprochen wird die Directory für den Treiber ändern.
Das ist ja noch nicht das Problem.
Der Prozess, der die Kommunikation mit dem Kernel möchte, muss ja ein Interrupt auslösen (z.B. auf 0x80).
Nun habe ich das Problem, dass der Kernel nicht weiß, was der Prozess nun mit dem Interrupt erreichen wollte.
Also muss der Prozess mitsenden was gemacht werden soll.
Das Problem ist, wie übertrage ich das?
Wenn ich vom User- in den Kernelspace wechsel, ändert sich ja auch der Stackpointer.
Also kann ich die Daten ja nicht in den Stack legen.
Welche Register bleiben denn in dem Prozessor erhalten, wenn der Sprung geschieht?
Wie genau muss ich mir das mit den Software-Interrupts vorstellen?
Wie sehen die Befehle für den Interrupt aus und wie springe ich danach wieder zurück?

Gruß
rizor

71

OS-Design / kmalloc und malloc

« am: 15. January 2009, 12:41 »

Hallo zusammen,

ich mache mir gerade Gedanken über meine Speicherverwaltung mit malloc und kmalloc.
Beim Kernel habe ich mir überlegt, da es ja recht leicht zu berechnen ist, welche Größen angefordert werden und somit sollte an sich ja eine einfach verkettete Liste reichen.
Beim malloc habe ich mir erst überlegt, einen AVL-Baum aufzubauen, dann habe ich bei der Implementierung gemerkt, dass der Rechenaufwand recht groß ist.
Da bin ich mir nicht sicher, ob dieser Aufwand einen Algorithmus der O(log n) hat rechtfertigt.
Dann kam mir ein Fibonacci-Heap als Idee, da der ja zum teil konstanten Aufwand hat.
Was ist denn am effektivsten zur Verwaltung von Speicher.

Zur Aufteilung in meinem Kernel habe ich mir überlegt, dass die Speicherverwaltung am Ende des Kernels liegt, darüber die TSS und Directories und darüber dann der Rest und andere Sachen.

Dann habe ich noch eine Frage.
Wie kann ich die Listenelemente denn anlegen?
Im prinzip bräuchte ich ja 2 4k-Seiten.
Einmal für den freien Speicher und einmal für die Verwaltung.
Für den freien Speicher habe ich ja meine Liste.
Aber wie lege ich die Liste an?
Ich müsste doch immer wieder berechnen, ob meine Liste noch auf die Page passt oder nicht.
Stimmt das soweit?
Ich finde es unnötig lauter Listenelement am Anfang einzufügen. Das ist mir ein wenig zu unflexibel.
Wie macht ihr das, bzw. wie kann man das am besten lösen?

Gruß
rizor

72

Lowlevel-Coding / Makefile "spinnt"

« am: 17. December 2008, 00:02 »

nabend,

wollte eben meinen neuen virtuellen Speichermanager compilieren.
Leider funktioniert mein Makefile nicht.
Der Aufruf sieht wie folgt aus:

Code: [Auswählen]

CC = /usr/bin/gcc
ASM = /usr/bin/nasm
CFLAGS = -O3 -fstrength-reduce -fomit-frame-pointer -finline-functions -fno-stack-protector -nostdinc -fno-builtin -march=i386 -I../include
ASMFLAGS = -felf

all:
$(CC) $(CLFAGS) -c -o ../../obj/virtmem.c.o virtmem.c
$(CC) $(CFLAGS) -c -o ../../obj/physmem.c.o physmem.c
$(ASM) $(ASMFLAGS) -o ../../obj/virtmem.asm.o virtmem.asm

Die physmem und die asm Datei werden kompiliert.
Das Problem ist, dass er die Header-Dateien nicht findet.
Die befinden sich aber genau da, wo sie sein sollten.
Wenn ich die virtmem-Datei von Hand kompiliere, geht es.
Woran liegt es, dass er es mit dem Makefile nicht macht?

73

Lowlevel-Coding / Paging

« am: 16. December 2008, 17:53 »

Nabend zusammen,

ich bin eben dabei jetzt paging einzubauen.
Dabei sind mir ein paar Fragen gekommen.
Wie arbeiten denn die physikalische und die virtuelle Speicherverwaltungen zusammen?
Wenn ich das richtig verstanden habe, ist Paging komplett unabhängig von der physischen Verwaltung.
Wenn ja, wozu brauche ich dann eine physikalsche Verwaltung?
Gut ok, damit kann ich die Module etc nachladen, aber das könnte ich ja auch anders realisieren.
Allerdings ist eines ein ganz großes Fragezeichen:
Wenn ich mir eine virtuelle Verwaltung aufbaue, liegt die doch im RAM, oder liegt die im Prozessorcache?
Müsste ich nicht bei der Erstellung der Virtuellen Verwaltung die Pages in der physischen Verwaltung anmelden?
Ich habe auch gelesen, dass ich bestimmte physische Speicherbereiche in den virtuellen Bereich mappen kann.
Das wäre doch dann zum Beispiel für den VGA-Block nützlich, oder?
Wie würde das denn dann aussehen?
Ich kann ja nur noch über virtuelle Adressen daran kommen.
Oder mappe ich den vor dem aktivieren des Paging-Mechanismusses?

Das waren jetzt so die Fragen, die mir auf anhieb gekommen sind.
Da folgen bestimmt noch einige.

Danke.

Gruß
rizor

74

Lowlevel-Coding / Multibootstruktur funktioniert nicht

« am: 12. December 2008, 17:40 »

Nabend zusammen,

ich bin eben mit meinem Physikalischen Speichermanager fertig geworden.
Leider funktioniert die Multibootstruktur die ich aus dem LOST-Projekt übernommen habe nicht.
Er kann die Speichergröße nicht bestimmen.
Ich habe mir mal die Werte der mb_info->mi_flags ausgegeben.
Da erhalte ich als Dezimalwert "n".
Beim verunden kommt dann auch "n" heraus. Wenn ich es mit der Konstanten HAS_MMAP verunde.

Woran liegt das?
Kann es sein, dass GRUB nicht richtig funktioniert?

Gruß
rizor

75

Lowlevel-Coding / LowLevel-Coding mit Code::Blocks

« am: 10. December 2008, 21:40 »

Nabend zusammen,

benutzt einer von euch auch die o.g. IDE?
Mein Problem ist, dass der Linker meckert, dass er __init_array_end nicht findet.
Wenn ich die object-files von Hand linke, dann geht es.
Dann habe ich nur das Problem, dass der Qemu sagt, dass es sich bei dem Programm nicht um eine executable handelt.
Woran liegt das?
Kann es sein, dass ich den Compiler falsch eingestellt habe in der IDE?
Wenn ja, was und wie muss ich denn alles einstellen?

Danke.

Gruß
rizor

76

Lowlevel-Coding / Bitmaps

« am: 05. December 2008, 00:12 »

Nabend,

ich bin gerade dabei mir einen Speichermenager für den physikalischen Speicher zu schreiben.
Habe mir überlegt, dass ich erst mal Bitmaps verwende (wirken für mich recht einfach).
Nun wollte ich mal fragen, ob ich alles richtig verstanden habe.

Bei einem x86-System habe ich zwei Möglichkeiten meinen Speicher zu mappen, 4kB und 2MB, oder?
Dann definiere ich mir einfach einen Speicherbereich in meinem Kernel, der meine Bitmap darstellt.
Da habe ich ja eine Endadresse meines Kernels, die ich als Offset interpretiere, oder?
Also wenn ich Bit2 in meiner Bitmap allozieren möchte, wähle ich einfach die Endadresse meines Kernels und addiere da dann dann die Größe drauf.
Dann habe ich doch meine Page-Adresse, oder?

Beim Speicher freigeben, habe ich die Adresse ziehe davon mein Kernelende ab und teile durch die Größe, oder?
Dann müsste ich doch das Bit haben.

Hoffe, dass das soweit stimmt.
Nun habe ich aber ein Problem.
Ein Teil des Speichers ist ja durch das BIOS und ein Teil durch meinen Bootloader (in meinem Fall GRUB) belegt.
Habe auch im LOST-Projekt gesehen, dass ich mit einer Multiboot-Struct das alles abfragen kann.
Nun habe ich aber das Problem, dass ich nicht weiß wie groß die Pages sind und wie groß mein RAM ist.
Wie bekomme ich raus, was genau belegt ist und wie groß mein RAM ist?

Die Größe des RAMs muss ich ja kennen um meine Bitmap-Größe zu bestimmen.
Außerdem schreibe ich gerade einen 32-Bit-Kernel.
Das bedeutet, dass ich ja durch die Adressierung eingeschränkt bin.
Sollte ich meinen Kernel-Bereich auch mappen?
Wenn ja, wie?

Wie muss ich denn darauf reagieren, wenn ich mehr als 3GB-RAM habe?
Muss ich dann von Hand darauf achten, dass ich nicht versuche mehr Speicher zu Adressieren?

Dann habe ich noch eine Frage zum Kernel-Aufbau.
Bevor ich meinen Speichermanager aufrufe, rufe ich erst den GDT udn IDT auf, die belegen doch auch schon Platz auf dem RAM, oder habe ich das falsch verstanden?
Die Adressen muss ich ja auch kennen.

Hoffe ich konnte die Fragen so formulieren, wie ich sie meine .

Danke für eure Hilfe.

Gruß
rizor

77

OS-Design / Frage zu meinem Kerneldesign

« am: 02. December 2008, 23:17 »

Nabend zusammen,

ich habe mir mal Gedanken über meinen Kernel gemacht.
Mein Kernel soll wirklich nur das Nötiggste machen.
 - GDT/IDT/ISR/IRQ/PIC/PIT initialisieren
 - den Scheduler bereitstellen
 - Methoden für den Speicher (memset, etc)
Der Rest soll über Treiber gemacht werden:
 - Dateisystem , Paging und alles was sonst noch an Treibern fehlt
Diese Treiber sollen erst nachgeladen werden (sprich nicht mitkompilieren).
Wie kann ich die denn zur Laufzeit laden?

Nun zu meinen Fragen:
Ist dieser Aufbau überhaupt sinnvoll?
Bei dem Scheduler habe ich ein paar Verständnisfragen:
 - Was brauch ich denn alles an Strukturen?
   Ich habe mir gedacht, dass ich einerseits einen Prioritätsparameter habe, dann habe    ich noch einen counter der die Rechenzeit mit zählt und dann die Strukturen für die Register und den Stack.
Wie rette ich den gesamten Prozessor in die Strukturen?
Mein Programm wird doch über einen Interrupt unterbrochen, wenn ich nun die Behandlungsroutine aufrufe steht in meinem PC doch schon eine andere Befehlsadresse. Wo bekomme ich die alte her, damit ich sie speichern kann?

Wenn mein Scheduler arbeitet muss ich doch ein paar Interrupts maskieren, oder?
Dachte jetzt mal an den PIT und Software-Interrupts.
Wie mache ich das?

Das war es erst einmal an Fragen.
Da kommen bestimmt noch mehr.

gruß,
rizor