Autor Thema: Problem bei Physikalischer Speicherverwaltung (Bitmap)  (Gelesen 35421 mal)

kevin

  • Administrator
  • Beiträge: 2 767
    • Profil anzeigen
Gespeichert
« Antwort #80 am: 27. November 2014, 16:36 »
Ich dachte daran, den gdb-Stub in qemu zu benutzen. Aber du benutzt gar keinen Emulator, oder wie war das?
Thou shalt not follow the NULL pointer, for chaos and madness await thee at its end.

s137

  • Beiträge: 110
    • Profil anzeigen
Gespeichert
« Antwort #81 am: 27. November 2014, 16:39 »
nein eigentlich nicht.. ich teste auf echer hardware... naja aber wenns nicht anders geht muss ich halt versuchen des mit qemu irgendwie hinzukiegen..

s137

  • Beiträge: 110
    • Profil anzeigen
Gespeichert
« Antwort #82 am: 27. November 2014, 16:41 »
jetzt weiß ich wieder wieso ich qemu nicht benutze ^^ qemu funktioniert bei mir nicht weil ich auf einem Serversystem ohne grafische Oberfläche Programmiere... siehe: "Could not initialize SDL(No available video device) - exiting"
« Letzte Änderung: 27. November 2014, 16:46 von s137 »

s137

  • Beiträge: 110
    • Profil anzeigen
Gespeichert
« Antwort #83 am: 27. November 2014, 18:53 »
Also hier mal die Rückgabewerte der pmm_alloc() für die Taskstruktur (struct task* task = pmm_alloc()), bei Task1: 40000 und bei Task2: fffdf000

Da der 2. Wert sehr kaputt erscheint hier mal meine pmm.c:

// Source File for Headerdatei pmm.h

/*
 * Der Einfachheit halber deklarieren wir die maximal benoetige Bitmapgroesse
 * statisch (Wir brauchen 4 GB / 4 kB = 1M Bits; 1M Bits sind 1M/32 = 32k
 * Eintraege fuer das Array)
 *
 * Willkuerliche Festlegung: 1 = Speicher frei, 0 = Speicher belegt
 */
#include "console.h"
#include <stdint.h>
#include <stddef.h>
//#include "stdint.h"
#include "pmm.h"

#define BITMAP_SIZE 32768

static unsigned long bitmap[BITMAP_SIZE];

extern const void kernel_start;
extern const void kernel_end;

unsigned int indexArrayValNotNull(unsigned long array[]);
unsigned int indexLowestBit(int x);
void pmm_mark_all(void);

void pmm_mark_used(void* addr)
{

uintptr_t page_nummer;
uintptr_t bitnummer;
uintptr_t array_index;

page_nummer = (uintptr_t) addr / 4096;
bitnummer = page_nummer % 32;
array_index = (page_nummer - bitnummer) / 32;

//Bit loeschen weil Speicher belegt: Bit = 0
// x &= FLAG
bitmap[array_index] &= bitnummer;

}

void pmm_free(void* addr)
{

uintptr_t page_nummer;
uintptr_t bitnummer;
uintptr_t array_index;

page_nummer = (uintptr_t) addr / 4096;
bitnummer = page_nummer % 32;
array_index = (page_nummer - bitnummer) / 32;

// Bit setzen weil Speicher frei: Bit = 1
// x |= FLAG
bitmap[array_index] |= bitnummer;

}

void* pmm_alloc(void)
{

// TODO: Exceptions einbauen

unsigned int index;
unsigned int bit;
unsigned int page_nummer;
unsigned int adresse;

index = indexArrayValNotNull(bitmap);
bit = indexLowestBit(bitmap[index]);
page_nummer = index * 32 + bit; // 32 pages pro eintrag in "bitmap"
adresse = page_nummer * 4096; // jede page ist 4096 groß

// Pmm mark used
pmm_mark_used((void*) adresse);

return (void*) adresse;

}
void pmm_init(struct multiboot_info *mb_info)
{

struct multiboot_mmap* mmap = mb_info->mbs_mmap_addr; // Pointer zur Memory Map wird in Pointer mmmap gelegt
struct multiboot_mmap* mmap_end = (void*) ((uintptr_t) mb_info->mbs_mmap_addr + mb_info->mbs_mmap_length);

// Alles als belegt markieren
pmm_mark_all();

while (mmap < mmap_end) {
    if (mmap->type == 1) {
        // Der Speicherbereich ist frei, entsprechend markieren
        uintptr_t addr = mmap->base; // Groesse: 1byte = 8bit = 0x1000 = addre zeigt auf adresse *addr auf inhalt
        uintptr_t  end_addr = addr + mmap->length; // 8bit

        while (addr < end_addr) {
               pmm_free((void*) addr);
            addr += 0x1000;
        }
    }
    mmap++;
}

uintptr_t kernel_addr = (uintptr_t) &kernel_start;
uintptr_t kernel_end_addr = (uintptr_t) &kernel_end;

while (kernel_addr < kernel_end_addr) {
      pmm_mark_used((void*) kernel_addr);
   kernel_addr += 0x1000;
}

}

unsigned int indexArrayValNotNull(unsigned long array[]) {

                int i;

                for (i=0; i < sizeof(array); i++) { // Array Laenge ?!

                        if (array[i] != 0) { return i; }
                }

                /* Fehlercode wenn nur 0en */
                return (unsigned) -1;
        }



        unsigned int indexLowestBit(int x) {

                int i;

                for (i=0; i < 32; i++) {

                        if ((x & (1 << i)) != 0) { return i; }
                }

                /* Fehlercode wenn kein Bit gesetzt */
                return (unsigned) -1;
        }


void pmm_mark_all(void) {

int i;
int x;

for(i=0; i < BITMAP_SIZE; i++) {

    for(x=0; x < 32; x++) {

       //Bit loeschen weil Speicher belegt: Bit = 0
       // x &= FLAG
       bitmap[i] &= x;
    }

}

}

void pmm_check(void* addr) {

uintptr_t page_nummer;
uintptr_t bitnummer;
uintptr_t array_index;

page_nummer = (uintptr_t) addr / 4096;
bitnummer = page_nummer % 32;
array_index = (page_nummer - bitnummer) / 32;

        if(bitmap[array_index] & (1 << bitnummer)) { kputs("-1-"); }
        else { kputs("-0-"); }

}

« Letzte Änderung: 27. November 2014, 21:38 von s137 »

Jidder

  • Administrator
  • Beiträge: 1 625
    • Profil anzeigen
Gespeichert
« Antwort #84 am: 27. November 2014, 23:13 »
// Bit setzen weil Speicher frei: Bit = 1
// x |= FLAG
bitmap[array_index] |= bitnummer;

Damit setzt du nicht das Bit, sondern du verknüpfst die beiden Werte.

Hier ein Beispiel: http://ideone.com/viksw9 Beachte die Ausgabe.

Es muss also folgendes sein:
bitmap[array_index] |= 1 << bitnummer;

Bit löschen geht mit:
bitmap[array_index] &= ~(1 << bitnummer);

Dieser Text wird unter jedem Beitrag angezeigt.

s137

  • Beiträge: 110
    • Profil anzeigen
Gespeichert
« Antwort #85 am: 27. November 2014, 23:22 »
Ach gott.. Natürlich... Da hätte ich aber auch selber draufkommen können... Danke :DD Eine Frage hätt ich noch.. Bei dem 2. was macht das "~" da genau?

OsDevNewbie

  • Beiträge: 282
    • Profil anzeigen
    • YourOS Kernel
Gespeichert
« Antwort #86 am: 28. November 2014, 00:45 »
~ ist der not Operator. Er dreht alle Bits um. D.haus 1 wird 0 und ummgekehrt. Z.b ist ~0b1011 = 0b0100.

Bei
~(1 << bitnummer);
sind also dann alle Bits gesetzt ausser das Bit mit an der Stelle bitnummer (dort steht dann eine 0).
Viele Grüsse
OsDevNewbie

Ein Computer ohne Betriebsystem ist nicht mehr wert als ein Haufen Schrott.
Ein Computer ist eine Maschine, die einem Lebewesen das kostbarste klaut, was sie selber nicht hat:
DIE ZEIT DES LEBENS

s137

  • Beiträge: 110
    • Profil anzeigen
Gespeichert
« Antwort #87 am: 28. November 2014, 14:10 »
Also vielen Dank für eure ganze Hilfe, es funktioniert jetzt einwandfrei :DD... Man denkt irgendwie gar nicht dass so ein kleiner Fehler so großes Chaos verursachen kann...

Vg s137

 

Einloggen