0x03 - La mémoire

Maintenant que nous avons une structure de projet saine, nous pouvons continuer à développer le noyau lui-même. Puisque nous sommes le noyau, théoriquement, nous pouvons utiliser n’importe quelle partie de la mémoire à tout moment. Pour imposer un peu d’ordre et éviter de nous tirer une balle dans le pied, nous devons organiser l’utilisation de cette mémoire en un système sain et clair. Le meilleur moyen de le faire est de diviser la mémoire en blocs de 4 Ko appelés pages. Les pages nous permettent d’allouer des blocs de mémoire qui ne sont pas insignifiants, mais qui ne sont pas si grands qu’ils absorbent une fraction significative de la mémoire.

Obtenir la taille de la mémoire

Si nous voulons organiser la mémoire, nous devons d’abord savoir combien de mémoire nous avons réellement. Nous pouvons le faire en accédant aux atags.

Nous pouvons faire correspondre la disposition de la mémoire des atags en définissant certains types de C:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

typedef enum {
    NONE = 0x00000000,
    CORE = 0x54410001,
    MEM = 0x54410002,
    ...
} atag_tag_t;

typedef struct {
    uint32_t size;
    uint32_t start;
} mem_t;

...

typedef struct atag {
    uint32_t tag_size;
    atag_tag_t tag;
    union {
        mem_t mem;
        ...
    };
} atag_t;

Ensuite, nous pouvons parcourir la liste Atag jusqu’à ce que nous trouvions l’attribut MEM:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

uint32_t get_mem_size(atag_t * tag) {
   while (tag->tag != NONE) {
       if (tag->tag == MEM) {
           return tag->mem.size;
       }
       tag = ((uint32_t *)tag) + tag->tag_size;
   }
   return 0;

}

Si vous développez pour une machine virtuelle, cette fonction ne fonctionnera pas. La VM n’émule pas le bootloader qui configure les atags. Puisque vous déterminez la taille exacte de la mémoire à travers les options QEMU, vous devriez simplement avoir cette fonction pour retourner cette quantité de mémoire. Notre Makefile définit la mémoire à 128 Mo, donc cette fonction devrait retourner 1024 * 1024 * 128.

La répartition de la mémoire

Maintenant que nous pouvons obtenir la taille totale de la mémoire. Nous pouvons diviser cette mémoire en plusieurs pages. Le nombre de pages est simplement la taille de la mémoire divisée par la taille de la page.

Ces pages vont avoir besoin de métadonnées. Ils devront par exemple garder la trace s’ils ont été alloués ou non, et dans quel but. Ils auront besoin de plus de métadonnées plus tard lorsque nous activerons la mémoire virtuelle. Pour le moment, voici notre type de métadonnées:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

typedef struct {
    uint8_t allocated: 1;           // This page is allocated to something
    uint8_t kernel_page: 1;         // This page is a part of the kernel
    uint32_t reserved: 30;
} page_flags_t;

typedef struct page {
    uint32_t vaddr_mapped;  // The virtual address that maps to this page
    page_flags_t flags;
    DEFINE_LINK(page);
} page_t;

Afin de contenir toutes les métadonnées, nous réservons une grande partie de la mémoire juste après l’image du noyau pour un tableau de métadonnées de page. Nous pouvons obtenir cette adresse en utilisant le symbole __end  que nous avons déclaré dans le script du linker. De plus, nous allons créer une liste chaînée pour garder une trace des pages qui sont libres.

Une fois cela fait, tout ce que nous devons faire est de parcourir les pages et d’initialiser leurs métadonnées et de les ajouter à la liste libre.

Voici le code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

extern uint8_t __end;

static uint32_t num_pages;

DEFINE_LIST(page);
IMPLEMENT_LIST(page);

static page_t * all_pages_array;
page_list_t free_pages;

void mem_init(atag_t * atags) {
    uint32_t mem_size,  page_array_len, kernel_pages, i;

    // Get the total number of pages
    mem_size = get_mem_size(atags);
    num_pages = mem_size / PAGE_SIZE;

    // Allocate space for all those pages' metadata.  Start this block just after the kernel image is finished
    page_array_len = sizeof(page_t) * num_pages;
    all_pages_array = (page_t *)&__end;
    bzero(all_pages_array, page_array_len);
    INITIALIZE_LIST(free_pages);

    // Iterate over all pages and mark them with the appropriate flags
    // Start with kernel pages
    kernel_pages = ((uint32_t)&__end) / PAGE_SIZE;
    for (i = 0; i < kernel_pages; i++) {
        all_pages_array[i].vaddr_mapped = i * PAGE_SIZE;    // Identity map the kernel pages
        all_pages_array[i].flags.allocated = 1;
        all_pages_array[i].flags.kernel_page = 1;
    }
    // Map the rest of the pages as unallocated, and add them to the free list
    for(; i < num_pages; i++){
        all_pages_array[i].flags.allocated = 0;
        append_page_list(&free_pages, &all_pages_array[i]);
    }

}

Attribution de pages

Maintenant que nous avons toutes les pages sous contrôle, il serait bien que nous puissions allouer et libérer des pages dynamiquement. Cela peut être fait très simplement. Puisque les pages ont toujours 4 Ko, il suffit de trouver une page qui n’a pas été allouée et de renvoyer un pointeur vers la mémoire. Pour libérer, tout ce que nous devons faire est d’ajouter les métadonnées de la page à la liste libre.

Puisque les pages ont une taille constante de 4 Ko, nous pouvons obtenir la mémoire de page à partir des métadonnées de la page en multipliant l’index des métadonnées de la page par 4096. De même, nous pouvons obtenir les métadonnées de la page en divisant par 4096 cela comme un index dans le tableau de la page.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

void * alloc_page(void) {
    page_t * page;
    void * page_mem;

    if (size_page_list(&free_pages) == 0)
        return 0;

    // Get a free page
    page = pop_page_list(&free_pages);
    page->flags.kernel_page = 1;
    page->flags.allocated = 1;

    // Get the address the physical page metadata refers to
    page_mem = (void *)((page - all_pages_array) * PAGE_SIZE);

    // Zero out the page, big security flaw to not do this :)
    bzero(page_mem, PAGE_SIZE);

    return page_mem;
}

void free_page(void * ptr) {
    page_t * page;

    // Get page metadata from the physical address
    page = all_pages_array + ((uint32_t)ptr / PAGE_SIZE);

    // Mark the page as free
    page->flags.allocated = 0;
    append_page_list(&free_pages, page);
}

La possibilité d’allouer des pages est agréable, mais la taille stricte de 4 Ko est un peu restrictive pour la plupart des cas d’utilisation de la mémoire dynamique. Ensuite, nous allons ajouter à ce code pour implémenter un allocateur de mémoire dynamique qui peut vous donner n’importe quelle allocation à la  taille que vous voulez!

Le code est publiquement disponible sur GitHub.