Thema: Speicherverwaltung

[ChristianF]

Es gibt einen panic.

Code: [Auswählen]

Out of Memory!
System is halting now.
Als ich mir von der Funktion, die die bitmap durchläuft, den Inhalt des jeweils aktuellen Eintrags hab ausgeben lassen, war der Wert immer 0xFFFFFFFF.
Ich verstehe nicht, warum das ausftritt, da ich ja die gesamte bitmap auf 0 gesetzt habe.

Code: [Auswählen]

printf("\n\nphysical_bitmap_size = %d\nphysical_bitmap[1] = 0x%x\nphysical_bitmap = 0x%x\n", physical_bitmap_size, physical_bitmap[1], physical_bitmap);
    unsigned int i, j;
    for(i = 0; i < physical_bitmap_size; i++)
    {
        printf("physical_bitmap[%d] = 0x%x\n", i, physical_bitmap[i]);
        if(physical_bitmap[i] != 0xFFFFFFFF)
{
    printf("Something Free!\n");
    for(j = 0; j < 32; j++)
{
if(physical_bitmap[i] & BIT(j))
return( ((i * 32) + j) * PAGE_SIZE );
}
}
    }
Gesucht habe ich auf die Art und der hat halt durchnummeriert bis 131068 und hat als inhalt immer 0xFFFFFFFF ausgegeben.

[bluecode]

Ist das ein Fehler in kmalloc? Ich mein 128kb ist schon einiges zum allozieren. Auf was greift den kmalloc zurück? Auf diese Bitmap? Das wäre nämlich schlecht, wenn sie noch nicht initialisiert ist.

[ChristianF]

Nun mein kmalloc sieht so aus:

Code: [Auswählen]

unsigned int kmalloc_int(size_t size, unsigned int align, unsigned int *phys)
{
    if (align == 1 && (placement_address & 0xFFFFF000)) // If the address is not already page-aligned
    {
        // Align it.
        placement_address &= 0xFFFFF000;
        placement_address += 0x1000;
    }
    if (phys)
        *phys = placement_address;

    unsigned int tmp = placement_address;
    placement_address += size;
    return tmp;
}

Anmerkung: placement_address startet bei ab 0xC0000000.
Aus diesem Grund wird die Addresse mittels des Makros VIRT2PHYS umgewandelt (+0x40000000).

Einfach eine Variable, die immer ein bissel weiter geschubst wird 

[bluecode]

Ich versteh immernoch nicht woher der Panic kommt. Wird der von deinem OS angezeigt, wenn ja wo oder von qemu/bochs oder ...?

edit: Ist denn bei 0xC0000000 irgendwas sinnvolles gemappt?

[ChristianF]

das sollte ja eigentlich gemacht werden.
Der reserviert eine Physische Page, um diese dann nach 0xC0000000 zu mappen.
Allerdings kommt er nicht bis dahin.

Der Reservierte Speicher, der auch durchsucht wird, hat nach dem memset den Wert 0xFFFFFFFF, überall.
 
Die Funktion (testweise find_free_frame) durchläuft das komplette Array und gibt, falls vorhanden, eine Addresse auf eine physische freie Speicheradresse zurück. Nun steht aber in allen einträgen der Bitmap 0xFFFFFFFF.
Dies wertet die funktion physical_alloc_page() so, dass der komplette RAM voll ist, und macht einen Aufruf der Funktion panic, mir dem Text "Out of Memory!".

[bluecode]

das sollte ja eigentlich gemacht werden.
Der reserviert eine Physische Page, um diese dann nach 0xC0000000 zu mappen.

in kmalloc hier:

Code: [Auswählen]

physical_bitmap = (unsigned int*)VIRT2PHYS(kmalloc(physical_bitmap_size));
oder wo? Woher kommen den die physischen Pages für dieses kmalloc?

Allerdings kommt er nicht bis dahin.

Bis wohin kommt er denn überhaupt...

Könntest du mal sagen, was ausgeführt wird, was nicht, wer den Panic anzeigt, etc...? Ich komm nämlich momentan überhaupt nicht mit...

[MNemo]

das löst zwar nicht dein problem aber

Code: [Auswählen]

if (align == 1 && (placement_address & 0xFFFFF000)) // If the address is not already page-alignedsoll wohl eher

Code: [Auswählen]

if (align == 1 && (placement_address & 0xFFF)) // If the address is not already page-alignedheißen

[ChristianF]

mmhhh....
was ist denn falsch an der Zeile:

Code: [Auswählen]

physical_bitmap = (unsigned int *)kmalloc(physical_bitmap_size);
Ich verstehe das nicht so ganz.
 
Gruß Christian

[bluecode]

Fangen wir mal ganz von vorne an: Wie weit wird denn initialise_physical_memory_manager(...) ausgeführt bzw. was wird nicht mehr ausgeführt bzw. wo hängt er in einer Endlosschleife?

[kevin]

was ist denn falsch an der Zeile:

Code: [Auswählen]

physical_bitmap = (unsigned int *)kmalloc(physical_bitmap_size);


Henne-Ei und so. Ein vernueftiges kmalloc braucht selbstverstaendlich eine initialisierte physische Speicherverwaltung. Ansonsten kann ja der reservierte Speicher nicht als belegt markiert werden.

Edit: Aber mit deiner Fakeimplementierung ist das natuerlich nicht dein aktuelles Problem. Nur ein zukuenftiges.

[bluecode]

Meine Vermutung wäre schon oben gewesen, dass du in kmalloc auf die page bitmap zugreifst, die du durch das kmalloc erst allozieren (und danach erst initialisieren) willst.

edit: Der von dir angegebene Code ist übrigens nicht kmalloc sondern kmalloc_int... Das erscheint mir irgendwie was anderes zu sein...

edit2: taljeth bemerkte in #lost noch, dass deine Adresse für physical_bitmap sehr komisch ist und nicht wirklich zu den von dir prophezeiten 0xC0000000 + X passt. Zumindest sagtest du, dass kmalloc, sowas allozieren sollte...

edit3: Wenn du Lust hast kannst du mir auch mal ein (Floppy/CD-)Image + Sourcecode schicken, dann schau ich mir das an... Am liebsten natürlich mit (funktionierenden) Makefiles, damit ich auch ein bisschen was frickeln. kann.

[ChristianF]

Also folgendes kmalloc ist nur eine zusatz Funktion. in dieser Funktion wird kmalloc_int so aufgerufen:

Code: [Auswählen]

return(kmalloc_int(size, 0, 0));
Des Weiteren habe ich kmalloc jetzt so umgestellt, dass physikalische Adressen zurückgegeben werden.

Code: [Auswählen]

unsigned int placement_address = (unsigned int)&end+0x40000000;
initialise_physical_memory_manager(...) wird komplett ausgeführt.
Er endet dann in einer endlos schleife, wenn nach einer freien physischen Page gesucht wird.
Wie zuvor auch schon gesagt, komischer weise ist die bitmap gefüllt mit dem Wert 0xFFFFFFFF anstatt 0.
 
Ich habe das OS in ein Archiv gelegt und auf meinem Server abgelegt. Wäre schön, wenn du irgendwann die Zeit findest, dir das mal anzuschaun.
http://87.230.87.9/ftp/christian/DeutschOS.tar.gz
 
Gruß Christian

 
PS: Wenn du dir den Code anschaust, dann kannst du den ganzen inhalt der Datei mm/paging.c ignorieren, bis auf die Funktion initialise_paging(...).
Hier soll eine freie Page gefunden und reserviert werden, mittels physical_alloc_page(), was dann aber in einem Out of Memory endet.

*EDIT*
Die Funktionen sind teilweise angelehnt an die von LOST, allerdings selbstgeschrieben.
Des Weiteren muss ich den Paging kram nochmals überarbeiten, wenn die physikalische Speicherverwaltung funktioniert.

[FreakyPenguin]

Hm also bei mir tut der Code einfach so nicht. Mit dem ganzem Segment-Gefummel verrutscht da die Adresse der Multiboot-Struktur. Die müsste dann halt auch irgendwo angepasst werden.

Aber das mit der ganzen Segmentierung finde ich ziemlich mühsam und Fehleranfällig, da du da während der ganzen Initialisierung immer die richtigen Adressen umbiegen musst. (Ich hab das auch erst nach einem Hinweis von bluecode gesehen, warum das überhaupt funktioniert) Ich würde dir empfehlen in der start.s ein einfaches PD zu erstellen, das den Kernel sowohl 1:1 als auch auf den 3. GB mappt. So musst du dann nur noch dort am Anfang kurz auf die Adressen achten.

Ah und nochwas, ich glaube im Kernel wäre ein -Werror keine schlechte Idee, denn die Warnungen sind oft nicht nur Dekoration.

Mir fehlt leider grad die Zeit um noch weiter zu suchem, aber wenn das Problem heute Abend noch nicht gelöst ist, kann ichs mir nochmal anschauen.

Edit:
Abgesehen natürlich von der Zeile "if(physical_bitmap & BIT(j))" in find_free_page, die meiner Meinung nach eher "if(!(physical_bitmap & BIT(j)))" sein sollte.

[bluecode]

Dieser Post wurde unter enormen Zwang auf mich von FreakyPenguin erstellt. Er fordert, dass ich auf den Edit seines letzten Posts explizit hinweise.
Bitte helft mir, er wird, falls ich seine Forderungen nicht erfülle bei meinem OS-Projekt mithelfen.

[ChristianF]

Da habe ich das wohl vergessen. 
In meinem alten Code war das so drinne, habe allerdings den Unterschied gestern nicht gesehen 
 
Gruß Christian

*EDIT*

Hm also bei mir tut der Code einfach so nicht. Mit dem ganzem Segment-Gefummel verrutscht da die Adresse der Multiboot-Struktur.

Bei mir hat das Funktioniert, wollte das aber eh schon seit längerer Zeit ändern 
Bin grad dabei eine neue start.s zu erstellen ...
 
*EDIT2*
Mmmhhh....
wie setze ich nur Paging mit nasm auf... 

[ChristianF]

Mir ist gerade eben noch ein weiterer Fehler aufgefallen.
Und zwar hier:

Code: [Auswählen]

physical_bitmap_size = (num_pages / 32) * 4;
Das stimmt allerdings so nicht, oder gibt es 128 Bit Variablen (16 Byte)
Ich kenne nur 8 Byte große Variablen, also 64 Bit (long long int, C99 Standard).

Code: [Auswählen]

physical_bitmap_size = num_pages / 32;
Ich weiß nur nicht warum ich das dahin geschrieben habe...
wahrscheinlich, weil ich vorher folgendes da stehen hatte:

Code: [Auswählen]

physical_bitmap_size = num_pages / ( 8 * 4 );

[bluecode]

Code: [Auswählen]

physical_bitmap_size = (num_pages / 32) * 4;Das stimmt allerdings so nicht, oder gibt es 128 Bit Variablen (16 Byte)

Das stimmt so schon, du willst doch 32bit integer allozieren, deswegen teilst du durch 32 (für eine page ein bit) und multiplizierst anschließend mit 4 (also der Größe deines Datentyps). Es wird zwar damit nach unten gerundet (was nicht unbedingt richtig ist), aber was solls.

Ich kenne nur 8 Byte große Variablen, also 64 Bit (long long int, C99 Standard).

Der C Standard gibt keine feste Größe für die Datentypen an, sondern nur eine Mindestgröße. Gcc stellt iirc als Erweiterung sogar einen 128bit Integerdatentyp zur Verfügung, wie der heißt weiß ich nicht auswendig, wenns dich interessiert muss halt ins Manual schauen.
Was allerdings dein 128bit Datentyp mit dem Code oben zu tun haben soll versteh ich nicht.

[bluecode]

wie setze ich nur Paging mit nasm auf... 

Gibt doch genug Beispielcode dazu (zB. meinen beiden OS, siehe Signatur, beides higher half und beidesmal wird das in assemblercode initialisiert)

[ChristianF]

Mmmmhhh....
Ich habe den Fehler gefunden 

Ich habe mal das Makro VIRT2PHYS entfernt und siehe da, es geht!
*freu*
 
Jetzt kommt auch das was ich erwartet habe, und zwar ein neustart beim initialisieren des Pagings.
 
Kampfesgrüße Christian

*EDIT*
auch folgendes habe ich geändert:

Code: [Auswählen]

unsigned int placement_address = (unsigned int)&end+0x40000000;zu folgendem:

Code: [Auswählen]

unsigned int placement_address = (unsigned int)&end;

[ChristianF]

Mal ne kurze Frage:
Mein Linker Script sah vorher so aus:

Code: [Auswählen]

OUTPUT_FORMAT("elf32-i386")
ENTRY(start)
SECTIONS
{
. = 0x100000;

.setup :
{
*(.setup)
}

. += 0xC0000000;

.text : AT(ADDR(.text) - 0xC0000000)
{
*(.text)
}

.data ALIGN (4096) : AT(ADDR(.data) - 0xC0000000)
{
*(.data)
*(.rodata*)
}

.bss ALIGN (4096) : AT(ADDR(.bss) - 0xC0000000)
{
*(COMMON*)
*(.bss*)
}
}

Nun wollte ich fragen, ob das auch so geht:

Code: [Auswählen]

OUTPUT_FORMAT("elf32-i386")
ENTRY(start)
phys = 0x00100000;
virt = 0xC0100000;
SECTIONS
{
    . = virt;
    .text virt : AT(phys)
    {
        code = .;
        *(.text)
        *(.rodata)
        . = ALIGN(4096);
    }
    .data : AT(phys + (data - code))
    {
        data = .;
        *(.data)
        . = ALIGN(4096);
    }
    .bss : AT(phys + (bss - code))
    {
        bss = .;
        *(.bss)
        . = ALIGN(4096);
    }
    end = .; _end = .; __end = .;
}

Ich habe mir halt gedacht, wenn ich jetzt schon die start.s überarbeite, kann ich auch mein linker script überarbeiten.
Die untere Version ist eine abgeänderte von Brans Kernel Development Tutorial. Die wurde ersetzt, als ich daraus einen HigherHalf kernel gemacht habe. 


*EDIT*

wie setze ich nur Paging mit nasm auf... 

Gibt doch genug Beispielcode dazu (zB. meinen beiden OS, siehe Signatur, beides higher half und beidesmal wird das in assemblercode initialisiert)

Nun ja, das Problem ist, dass die AT & T Syntax, oder wie auch immer mich immer verwirrt, weshalb dein Code mit nichts bringt.

Ich habe in mein Linkerscript jetzt noch die Einträge __kernel_start__ und __kernel_end__ eingefügt.
Alles was ich jetzt machen muss ist doch von Adresse 0, bzw. __kernel_start__ bis __kernel_end__ in einer loop durchzulaufen und die Adresse in die Page Table (0xC0000000 >> 22) schreiben, falls der Kernel kleiner als 4 MB ist, oder?
Wenn ich doch nur etwas besser Assembler könnte ...
Wie mach ich das jetzt?