Nachrichten

461

Lowlevel-Coding / Re: Makefile "spinnt"

« am: 11. January 2009, 14:19 »

Das mit der Abhängigkeit habe ich behoben.
Was hat das nun mit dem Fehler 127 auf sich?

Die Meldung sieht so aus:
make: KERNEL_OBJ: Kommando nicht gefunden
make: *** [build-kernel] Fehler 127
make: Das Target »all« wurde wegen Fehlern nicht aktualisiert.
KERNEL_OBJ =

462

Lowlevel-Coding / Re: Makefile "spinnt"

« am: 11. January 2009, 13:31 »

Ich wollte aber, dass hinter den ASM-kompilierten Files die Extension asm.o steht, damit ich die untwerscheiden kann.
Wie kann ich denn das dann machen?

463

Lowlevel-Coding / Re: Makefile "spinnt"

« am: 11. January 2009, 12:34 »

Hallo,

ich habe mir nochmal ein neues Makefile geschrieben.
Es kompiliert auhc alles; es gibt aber ein "Fehlermeldung":

make[1]: Zirkuläre Datei init.asm <- init.asm.o Abhängigkeit wird nicht verwendet.

Ich habe nachgeschaut, dass tritt bei allen ASM-Files auf.
Aber die hängen ja von nichts ab.
Sie werden auch erstellt.
Wie bekomme ich den Fehler weg?
Meine Makeregel sieht dazu folgender Maßen aus:

%.asm.o:%.asm
   $(NASM) $(ASMFLAGS) -o $(HOME_DIR)/obj/$@ $<

Woran liegt die Meldung.
Sie stört zwar nicht, ist aber auch nicht schön.

[Edit]
Ich habe mir dann auch noch ein Linker-Teil geschrieben, der sich aus einer Directory alle Object-Files sammelt und die dann linkt.
Dabei kommt der Fehler 127 zustande.

Die Befehle:

Code: [Auswählen]

#Makefile for the hole project
include Makefile.rules

KERNEL_DIRS = kernel kernel/driver kernel/interrupt kernel/memory
LIBC_DIRS = usr/src

#Makros
EXTENSIONS = .asm.o .c.o
OBJ_FILES = $(wildcard $(addprefix $(1)/*,$(EXTENSIONS)))

all: build-kernel

build-kernel:
for i in $(KERNEL_DIRS); do make -C $$i; done
KERNEL_OBJ = $(call OBJ_FILES,$(HOME_DIR)/obj)
$(LD) $(LDFLAGS) $(HOME_DIR)/bin/kernel.bin $(KERNEL_OBJ)

HOME_DIR, LD und LDFLAGS sind in der Makefile.rules definiert.

464

Lowlevel-Coding / Re: Paging

« am: 08. January 2009, 22:43 »

Ja, super.
Danke.
Das bringt Licht ins Dunkel.
Dann werde ich also erst mal die libc schreiben.
Kannst du mir jetzt noch sagen, was da so alles reinkommen sollte.
Ich dachte mir folgendes:
- Speichermethoden
- Printmethoden
- Filesystemmethoden

[Edit]
Wie binde ich das ganze denn dann ein?
Also wie bringe ich dem gcc bei, dass an dieser Stelle meine Includes sind?
Ganz normal über -Include... als Parameter?

465

Lowlevel-Coding / Re: Paging

« am: 08. January 2009, 19:49 »

Ich soll einfach die libc des gcc benutzen?
Dann muss ich doch gar kein malloc schreiben, oder?

Kann es sein, dass ich da was falsch verstehe?
Klärt mich mal bitte auf, wie das mit der libc und dem Kernel ist.

466

Lowlevel-Coding / Re: Paging

« am: 08. January 2009, 17:49 »

Gut ok.
Ist das nicht ein enormer Speicheraufwand?
Da fällt mir auch noch eine Frage ein:

Wenn ich nun malloc/kmalloc etc implementiere, wie kommuniziert mein Programm dann mit diesen Methoden?
Über Syscalls?
Bei Linux sehe ich ja, dass das irgendwie über libc geregelt wird.
Wie mache ich das bei meinem eigenen OS und wie kann ich überhaupt shared-libraries implementieren?

467

Lowlevel-Coding / Re: Paging

« am: 08. January 2009, 00:08 »

Nabend,

nun habe ich noch eine Frage zu malloc.
Wie sollte man das am besten implemeniteren.
Wenn ich bei jedem malloc eine bestimmte Anzahl an Pages abgebe kann ich doch abartig großen verschnitt haben.
Wenn ich mir überlege, dass wenn ein Prozess eine Struktur anfordert, die 12 Byte groß ist, wäre es das dümmste, wenn ich einen 4k-Block markiere.
Sollte ich den noch unterteilen?
Das würde aber wiederrum einen extremen Overhead bedeuten.

Wie macht man das am besten?

468

Lowlevel-Coding / Re: Paging

« am: 03. January 2009, 22:36 »

Nabend,

habe jetzt nochmal eine Frage:

Wie kann ich am besten Speicher allozieren, wenn Paging aktiviert wurde?
Wollte mir der Einfachheit halber eine Liste erstellen, die alle Directories speichert.
Die Frage ist, wie mache ich das am besten?
Mein phys_alloc liefert mir ja eine physische Seite, wie mache ich daraus eine virtuelle?
Oder ist es am besten, wenn ich mir erst die virtuellen Seiten suche und danach einfach physischen Speicher alloziere und diesen dann in die neue Page eintrage?

469

Lowlevel-Coding / Re: Paging

« am: 30. December 2008, 18:24 »

Verdammt.... habe den Fehler entdeckt.
Habe mir die Adresse, die in der Tabelle steht falsch formatiert.

Nun habe ich allerdings eine Frage zur Funktionsweise:
Wie sollte das denn nun aussehen, wenn ein neuer Prozess aufgerufen wird?
Ich könnte die neuen Prozesse ja einfach in die Directory eintragen.
Dann habe ich doch nur das Problem, dass ich Zugriffsfehler nicht feststellen kann, außer der Prozess greift in den Kernel oder die Page ist noch nicht gemappt.
Dann ist mir eingefallen, dass ich jedem Prozess ja eine eigene Directory geben könnte.
Da habe ich nur das Problem, dass ich bei jdem Prozesswechsel den Speicher swappen müsste, oder?
Ansonsten könnte es doch zu doppelten Zugriffen kommen.
Das wäre mir dann ein wenig zu viel Arbeit des Kernels.
Wie kann man das denn am besten realisieren?

470

Lowlevel-Coding / Re: Paging

« am: 30. December 2008, 15:38 »

Ich frag mich was du hier machst? Dir ist schon klar, dass du mindestens 3073 Pages anfragen musst, damit diese Bedingung erfüllt ist. Ich denke nicht, dass du das gemeint hast.

Welche Bedingung meinst du?

Code: [Auswählen]

    if(size >= TABLE_SIZE - offset){
        //TODO: change parameters
    }

    if(directory[(dword)vaddr >> SHIFT_DIRECTORY] == NULL){
        puts("Generating new table\n");
        //prepare the table
        table = phys_alloc(TABLE_SIZE * sizeof(page_table_t) / BLOCK_SIZE);
Sollte jetzt noch nicht stören, wird es aber wenn das Paging aktiviert ist, den dann greifst du auf ungemappten Speicher zu sehr sehr böse. Daher erst zuweisen dann Nullen.

Code: [Auswählen]

        memset(table , 0 , TABLE_SIZE);

        //register in the directory
        directory[(dword)vaddr >> SHIFT_DIRECTORY] = (dword)table | PAGE_PRESENT | PAGE_READWRITE;
    }


Gut, das stimmt.

Hier hast du wohl vergessen, das im directory Eintrag noch die Flags sind, die musst du rausnehmen bevor du die Richtige Table Adresse erhältst.

Code: [Auswählen]

    table = (page_table_t)directory[(dword)vaddr >> SHIFT_DIRECTORY];
    for(i = 0; i <= size; i++){
        phys_addr = (dword)paddr + i * BLOCK_SIZE;

        table[offset + i] = phys_addr | flags;
    }
}


Ja, habe ich korrigiert, ändert aber nichts an der Fehlermeldung.

Ansonsten würde mich interessieren wie page_table_t aussieht. Und ob du auch wirklich Adressen vom Physischem Memory Manager kreigst die Page Alligned sind. Ansonsten musst du alle Werte dir ausgeben lassen und schaun ob nicht einer falsch ist.

Mein page_table_t ist ein

Code: [Auswählen]

unsigned long*.
Ja, der Physische Manager liefert 4k-aligned Adressen und auch wirklich die Anfangsadresse, denn wenn ich es ganz primitiv mache und einfach die ersten 4 MB mappe, funktioniert der Code.

471

Lowlevel-Coding / Re: Paging

« am: 29. December 2008, 01:18 »

Nabend zusammen,

habe mir noch einmal den Code angeschaut und ihn elementarer gemacht.
Leider geht es immer noch nicht.
Mein File zum Paging sieht jetzt so aus:

Code: [Auswählen]

#include <kernel32.h>
 #include <memory/mmu.h>
 #include <memory/pmmu.h>

//internal methods
void map_pages(physaddr_t , virtaddr_t , cond_flags , size_t);
void directory_init();
void printReserved(int , int);

//methods from the asm-file
extern void _write_cr3(dword);
extern void _write_cr0(dword);
extern dword _read_cr0();
extern dword _read_cr3();

page_table_t directory;
extern dword bitmap_length;
extern dword *bitmap_virt;

void paging_init(){
    size_t param;
    //initialize the directory
    directory_init();

    //map the kernel
    param = ((dword)kernel_end - (dword)kernel_start) / BLOCK_SIZE;
    map_pages(kernel_start , kernel_mem_start , PAGE_READWRITE | PAGE_PRESENT , param);

    //map the video
    param = 80 * 25 * 2 / BLOCK_SIZE + 1;
    map_pages((physaddr_t)0xB8000 , (virtaddr_t)0xB8000 , PAGE_READWRITE | PAGE_PRESENT , param);

    //map the directory
    map_pages(directory , directory , PAGE_READWRITE | PAGE_PRESENT , 1);

    //map the bitmap
    param = bitmap_length / BLOCK_SIZE;
    map_pages(bitmap_virt , bitmap_virt , PAGE_READWRITE | PAGE_PRESENT , param);

    _write_cr3((dword)directory);
    _write_cr0((_read_cr0() | 0x80000000));
}

void directory_init(){
    size_t i;
    directory = phys_alloc(TABLE_SIZE * sizeof(page_table_t) / BLOCK_SIZE);

    memset(directory , 0 , TABLE_SIZE);
}

void map_pages(physaddr_t paddr , virtaddr_t vaddr , cond_flags flags , size_t size){
    size_t i , offset = ((dword)vaddr >> SHIFT_PAGE) % TABLE_SIZE;
    page_table_t table;
    dword phys_addr;

    if(size >= TABLE_SIZE - offset){
        //TODO: change parameters
    }

    if(directory[(dword)vaddr >> SHIFT_DIRECTORY] == NULL){
        puts("Generating new table\n");
        //prepare the table
        table = phys_alloc(TABLE_SIZE * sizeof(page_table_t) / BLOCK_SIZE);
        memset(table , 0 , TABLE_SIZE);

        //register in the directory
        directory[(dword)vaddr >> SHIFT_DIRECTORY] = (dword)table | PAGE_PRESENT | PAGE_READWRITE;
    }

    table = (page_table_t)directory[(dword)vaddr >> SHIFT_DIRECTORY];
    for(i = 0; i <= size; i++){
        phys_addr = (dword)paddr + i * BLOCK_SIZE;

        table[offset + i] = phys_addr | flags;
    }
}

Habe immer noch keine Ahnung woran das liegt.
Die Berechnung müsste ja an sich stimmen.
Seht ihr nun vllt den Fehler?

Gruß
rizor

[EDIT]
Stimmt meine Theorie überhaupt, dass ich einfach nur die Offset-Adresse berechne und Dann in meinem Array einfach solange hoch zählen muss, bis alles gemappt ist, was im physischen Speicher liegt?

472

Lowlevel-Coding / Re: Paging

« am: 22. December 2008, 00:16 »

Ich bin den Code jetzt immer wieder durchgegangen.
Finde den Fehler aber nicht.
Die Methode zur Initialisierung des Pagings hat sich nicht geändert.
Könnt ihr einen Fehler erkennen, außer dass ich nicht alle Parameter auf Korrektheit überprüfe?

Danke für eure Hilfe.

Gruß
rizor

473

Lowlevel-Coding / Re: Paging

« am: 21. December 2008, 12:57 »

Ist an dieser Stelle Paging noch aus? Sonst ist das falsch, du greifst hier auf physische Adressen zu.

Ja, an dieser Stelle ist Paging noch aus.

Ähm, sicher?

Wie sollte ich die neue Table denn dann in die Directory eintragen?
Im Prinzip muss ich die Tabelle doch genau an der Stelle eintragen.

Wofür hast du ein FREE und ein INUSE?

Die benutze ich in den Bits, die für das OS da sind.
Da wird dann später geschaut, ob die Table geswapped wurde.

Ob eine Page Table frei ist, wird nirgends gesetzt, wenn ich das richtig sehe. Und wenn du das requested_table als Pointer benutzen willst, dann solltest du vielleicht vorher die Flags rausmachen...

Das setze ich ja, wenn ich sehe, dass die Table noch nicht existiert.

474

Lowlevel-Coding / Re: Paging

« am: 21. December 2008, 01:08 »

Nabend,

ich habe mir mal Gedanken gemacht, ob mein Algorithmus überhaupt richtig ist.
So wie ich euer Wiki dazu verstanden habe, muss ich mir zu jeder virtuellen Adresse die Directory, etc suchen.
Dann habe ich aber woanders gelesen, dass ich mir die Stelle in der Directory suche (für die virtuelle Startadresse) und ab da für eine bestimmte Länge jedes Nachfolgeelement mit der physikalischen Adresse belege.

Das klingt für mich auch logischer, da das ja die externe Fragmentierung verhindert.
Also habe ich das mal so programmiert.
Leider funktioniert das immer noch nicht.
Schaut euch mal bitte den Code an.
Vllt findet ihr den Fehler.

Code: [Auswählen]

void map_pages(physaddr_t paddr , virtaddr_t vaddr , paging_flags flags , size_t size){
    size_t i , offset = (dword)vaddr >> PAGING_TAB_SHIFT;;
    dword phys_addr;
    paging_directory_t requested_directory = (paging_directory_t)paging_directory[(dword)vaddr >> PAGING_DIR_SHIFT];
    paging_table_t requested_table;

    if((dword)requested_directory & PAGING_PAGE_FREE){
        //request memory for the table and prepare it to run
        requested_table = phys_alloc(PAGING_TABLE_SIZE * sizeof(paging_table_t) / BLOCK_SIZE);
        for(i = 0; i < PAGING_TABLE_SIZE; i++)
            requested_table[i] = 0 | PAGING_PAGE_FREE;
        //include the new table to the directory
        requested_directory = requested_table;
        //map the physical addresses
        for(i = 0; i < size; i++){
            phys_addr = (dword)paddr + i * BLOCK_SIZE;
            requested_table[offset + i] = phys_addr | flags | PAGING_PAGE_INUSE;
        }
    }
    else if((dword)(requested_table = (paging_table_t)requested_directory[offset]) & PAGING_PAGE_FREE){
        //go through the tavle at the requested addresses
        for(i = 0; i < size; i++){
            phys_addr = (dword)paddr + i * BLOCK_SIZE;
            //check if the entry is empty
            if((dword)requested_table[i] & PAGING_PAGE_FREE)
                requested_table[i] = phys_addr | flags | PAGING_PAGE_INUSE;
            else
                panic("Tried to write into a set table-entry");
        }
    }
    else
        panic("Tried to write into a set table-entry");
}

Danke für eure Hilfe.

475

Lowlevel-Coding / Re: Paging

« am: 18. December 2008, 23:16 »

Ach ja, ich kenne ja die virtuelle Adresse.
Die Frage ist, woran liegt es dann?
Die Adresse die ich  aus dem Rechtsshift erhalte ist dann genau die Adresse die im cr2 register liegt.
Die Frage ist jetzt nur, wieso versucht er daruf zuzugreifen?

476

Lowlevel-Coding / Re: Paging

« am: 18. December 2008, 22:50 »

Ich habe mitlerweile herausgefunden, warum er auf die Adresse zugreifen will.
Habe meine Directory mit den Flags falsch in die Directory eingetragen.
Vorher:
paging_directory[PAGING_VIRTADDR >> PAGING_DIR_SHIFT] = (dword)paging_directory | PAGING_PRESENT | PAGING_WRITEABLE;
Nachher:
paging_directory[PAGING_VIRTADDR << PAGING_DIR_SHIFT] = (dword)paging_directory | PAGING_PRESENT | PAGING_WRITEABLE;

So herum müsste es jetzt richtig sein, oder?

477

Lowlevel-Coding / Re: Paging

« am: 18. December 2008, 21:35 »

Kannst du mir dann vllt erklären, warum mein Boch die VGA-Bibliothek nicht findet?
Was mussen ich denn da alles noch mit installieren.
Benutze Ubuntu 8.04.

Da steht dann nur noch
check_exception old: ffffffff new e
check_exception old: e new e

Ist der erste die page fault exception?
Die Exceptions werden doch nicht deaktiviert, oder?
Also wenn ich die Interrupts deaktiviert habe.

478

Lowlevel-Coding / Re: Paging

« am: 18. December 2008, 19:36 »

Die Ausgabe des Logs ergab folgendes:

Code: [Auswählen]

check_exception old: 8 new e
qemu: fatal: triple fault
EAX=e0000011 EBX=00001000 ECX=00000000 EDX=00031000
ESI=00000001 EDI=00000001 EBP=00107f68 ESP=00107f68
EIP=0010271d 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=     00009108 00000027
IDT=     00000000 000003ff
CR0=e0000011 CR2=00000040 CR3=0010c000 CR4=00000000
CCS=0000000c 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=0000000000000000 0000 FPR7=0000000000000000 0000
XMM00=00000000000000000000000000000000 XMM01=00000000000000000000000000000000
XMM02=00000000000000000000000000000000 XMM03=00000000000000000000000000000000
XMM04=00000000000000000000000000000000 XMM05=00000000000000000000000000000000
XMM06=00000000000000000000000000000000 XMM07=00000000000000000000000000000000

Da steht leider nichts von 0e oder ich gucke falsch.
Aber was mich wundert ist cr2. Da dürfte er gar nicht hin.
Da wird nichts gemappt.
Soll es auch nicht.
Wie kann ich denn am besten mit dem qemu debuggen?
Also wie füge ich Breakpoints und so ein?
Habe mal gegoogelt aber leider kein ordentliches Tut gefunden.
Was ist besser zum debuggen?
Boch oder QEMU?

479

Lowlevel-Coding / Re: Paging

« am: 17. December 2008, 22:55 »

Ok.
Das Problem mit dem physischen Speichermanagment habe ich behoben (scheint zumindest so).
Leider bekomme ich bei der Benutzung des Pagings immer noch den triple fault.
Die Adresse, die jetzt im cr3-reg steht sieht nun besser aus:
0x10C000.
Aber woran kann es nun liegen, dass es den Triple fault gibt?

480

Lowlevel-Coding / Re: Paging

« am: 17. December 2008, 19:37 »

Aber wieso liegt meine page-directory dann bei 0x1090, dann müsste die ja verbugged sein, oder?