3IS - Système d'exploitation linux Gestion de la...

ÉCOLE NATIONALE SUPÉRIEURE DE L'ÉLECTRONIQUE ET DE SES APPLICATIONS

3IS - Système d'exploitation linux-

Gestion de la mémoire

2010 – David PicardContributions de : Arnaud Revel, Mickaël Maillard

[email protected]


Process adress space

● L'espace d'adressage du processus est l'espace mémoire vu par le processus

● Propriétés :– Il est total (si une adresse est codée sur 32bits, alors le

processus voit 4Go de mémoire)– Il est continu (toutes les zones entre 0x00 et la plus

grande adresse sont adressables)– Il est privé (seul le processus et le noyau ont accès à la

mémoire)


Découpage de l'espace d'adressage du processus

● 5 zones– Un espace réservé

– Une zone de code

– Une zone de données

– Une pile

– Le noyau

● La zone kernel est accessible uniquement en mode noyau

● Les zones de code, données et pile sont accéssibles en mode user

XXXXXXX

text

heap

kernel

stack

0x00000000

0x80000000

0x8xxxxxxx

0xc0000000

0xffffffff


Plusieurs processus

● Pour chaque processus l'espace d'adressage a les mêmes propriétés, malheureusement impossibles à réaliser :

– Total : toutes les machines n'ont pas 4Go de mémoire (voire 256To pour les x86-64)

– Privé et continu : Avec plusieurs processus, soit l'espace est discontinu, soit il n'est plus privé

● Le noyau et la zone réservée sont communs à tous les processus


Mémoire virtuelle

● Les adresses de l'espace d'adressage du processus ne sont pas les adresses physiques

● Deux mécanismes :– Segmentation– Pagination

Les adresses logiques sont les adresses vues par le processus

Adresseslogiques

Segmentation Adresseslinéaires

Pagination Adresses physiques


Segmentation

● La mémoire est divisée en segments● Une adresse logique est séparée en deux

partie :– Un identifiant de segments appelé sélecteur de segment– Un décalage relatif dans le segment

● Sur x86, des registres sont dédiées aux stockage des segments :

– cs : pointe vers le segment de code– ss : pointe vers le segment de pile– ds : pointe vers le segment de données


Descripteurs de segment

● Chaque segment est représenté par un descripteur de segment de 8 octets

● Les descripteurs de segment sont stockés dans une table (soit globale, la GDT, soit locale, la LDT)

● Il n'y a qu'une seul GTD, alors que chaque processus peut avoir sa LDT (s'il a besoin de segments supplémentaires)

● Le descripteur de segment contient :– L'adresse linéaire du premier octet du segment

– La taille du segment

– Le type de segment

– Les droits d'accès à ce segment (la fameuse Segmentation fault)


Types de descripteurs de segments

● Descripteur de segment de code :– Décrit un segment de code (GDT ou LDT)

● Descripteur de segment de données– Décrit un segment de données ou de pile (GDT ou LDT)

● Descripteur de segment d'état de tâche– Décrit un segment contenant le contexte d'un processus

(Task State Segment – TSS, rappelez vous la task_struct des processus) en GDT

● Descripteur de la table locale de descripteurs– Décrit un segment qui contient un LDT (en GDT)


Sélecteur de segments

● Contient deux champs : – Un index pour une table de descripteurs de segments– Un indicateur si la table est la GDT ou la LDT (TI)

Deux registres permettent de stocker l'adresse de la GDT (GDTR) et de la LDT courante (LDTR)

Sélecteur de segment

Index TI


Calcul de l'adresse linéaireoffsetIndex TI

8*

GDTR ou LDTR

GDT ou LDT

Descripteur de segment +

Adresse linéaire

+

base


Pagination

● Découpage de l'espace d'adresses linéaires en pages

● Découpage de la mémoire en cadres de page● Association entre les pages et les cadres de

page– Association non linéaire (les adresses ne sont pas

identiques)– Gestion des droits sur les page (exception Page fault)– Un mapping par processus


Pagination

XXXXXXX

text

heap

kernel

stack

0x00000000

0x80000000

0x8xxxxxxx

0xc0000000

0xffffffff

Page 1

Page 2

Page 3

Page 5

Page 4

0x9a5624ce

0x00000000Cadre 1

Cadre 2

Cadre 3

Cadre 5

Cadre 4

Adresse linéaires du processus Mémoire physique

Cadre d'unautre processus

Cadre d'unautre processus


Adresses linéaires

● Une adresse linéaire est découpée en trois champs :

– Un répertoire (directory) sur les bits de poids fort, qui indique quel répertoire de tables de pages utiliser

– Une table (table) sur les bits intermédiaires, qui indique quelle table de page utiliser

– Un décalage (offset) sur les bits de poids faibles, qui indique la position dans la page

offsettabledirectory


Conversion en adresses physiques

+

offsettabledirectory

cr3

Registre contenant l'adresse du répertoire de pages

Répertoire des pages +

table de pagesCadre de page

+


Structure des répertoires et des tables de pages

● Indicateur Present : indique si la page est stockée en mémoire (si 0, expection Page fault)

● Zone contenant l'adresse d'un cadre de page contenant soit une table de page (pour les répertoire) soit une page (pour les tables de pages)

● Indicateur Dirty : indique qu'un écriture a été réalisée sur le cadre de page

● Indicateur Read/Write : donne les droits en lecture/écriture sur le cadre de page

● Indicateur User/Supervisor : définit le niveau de droits nécéssaire pour accéder à la page


La pagination dans Linux

● 4 niveaux d'indirection (3 répertoires, 1 table et l'offset)● Chaque processus dispose de son propre répertoire

global et de tables de pages privées● Lors d'une commutation de processus, le registre

contenant l'adresse du répertoire est sauvegardé dans la task_struct

● La taille d'une page est disponible par la macro PAGE_SIZE

● Le noyau maintient un ensemble de tables de pages pour son usage propre


Scénarios de traduction

Lors de la traduction d'une adresse linéaire en adresse physique, plusieurs scénarios peuvent intervenir :

● L'entrée dans la table est valide : l'adresse est remplacée par l'adresse physique correspondante

● L'entrée est invalide : il faut trouver un cadre de page libre, et ajouter la correspondance avec son adresse physique dans la table

● L'entrée est valide, mais les droits en lecture/écriture sont insuffisant : il faut lever une exception

● L'entrée est valide, mais les droits en contexte sont insuffisant : il faut lever une exception

● L'entrée est valide, mais le cadre ne se situe pas en mémoire centrale : il faut récupérer le cadre sur le support de stockage et le mettre en mémoire centrale


Gestion des Page fault

L'adresse appartient à l'espace d'adressage du processus

Le type d'accès correspond avec les droits de la région mémoire

L'exception s'est-elle produite en mode utilisateur

Accès licite : allouer un nouveau cadre de page

Accès illicite : envoyer un signal SIGSEV (correspondant souvent à la fameuse segmentation fault)

Erreur du noyau : tuer le processus


Accélérateurs matériels

● Les processeurs modernes permettent de réaliser les opérations de segmentation et de pagination au niveau matériel (MMU)

– Remplir les registres contenant les adresses des structures de mémoire virtuelle (répertoires, tables, etc)

– Activer la segmentation ou la pagination via un registre de contrôle

– La MMU se charge de faire la conversion automatiquement


Avantages de la mémoire virtuelle

● Abstraction de la mémoire (donc indépendance à une configuration matérielle précise)

● Gestion facile des droits● Masque la fragmentation de la mémoire

(simplifie la vie des programmeurs)● Masque la gestion complexe de la mémoire qui

est gérée par l'OS● Évite la réallocation


Cache

● L'accès à la mémoire centrale est couteux● Les processeurs disposent d'une petite zone de

mémoire appelée cache● Un mécanisme matériel permet de stocké dans

ce cache les données (les pages) fréquement utilisées

● Si une donnée est demandée et absente du cache, elle est chargée en cache


Transition Lookaside Buffers

● Une unité particulière appelée TLB sert à accélérer la conversion des adresses linéaires en adresses physique

● Elle stocke les association entre adresses linéaires et adresses physique

● C'est au noyau de gérer la validité des entrées des TLB (via flush_tlb_* ), car c'est lui qui décide des associations entre pages et cadres de pages

● Lorsque le registre de contrôle contenant l'adresse du répertoire principale est changé, toutes les entrées sont invalidées

● Lors d'une commutation de processus, les TLB sont donc vidés


Descripteur de mémoire

● struct mm_struct : contient toute l'information relative à l'espace d'adressage d'un processus

● Contenu dans le champs mm du descripteur de processus

● Les descripteurs sont rangés dans une liste doublement chaînée

● Partage de mm_struct entre plusieurs processus possible (syscall clone() et fork())


mm_struct (mm_types.h)struct mm_struct {

struct vm_area_struct * mmap; /* list of VMAs */

...

pgd_t * pgd; /*repertoire global de pages */atomic_t mm_users; /* How many users with user space? */atomic_t mm_count; /* How many references to "struct

mm_struct" (users count as 1) */int map_count; /* number of VMAs */

...

unsigned long total_vm, locked_vm, shared_vm, exec_vm;unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;unsigned long start_code, end_code, start_data, end_data; /* code et

data*/unsigned long start_brk, brk, start_stack; /* tas et pile */unsigned long arg_start, arg_end, env_start, env_end; /* arguments et

environnement */

...};


Régions de mémoire

● Mises en oeuvre dans la structure vm_area_start

● Identifie un intervalle d'adresses linéaires● Ne se chevauchent jamais● Fusion ou séparation possibles lors

d'allocation/désallocation si les droits des régions sont identiques


vm_area_struct (mm_types.h)/* * This struct defines a memory VMM memory area. There is one of these * per VM-area/task. A VM area is any part of the process virtual memory * space that has a special rule for the page-fault handlers (ie a shared * library, the executable area etc). */struct vm_area_struct {

struct mm_struct * vm_mm; /* The address space we belong to. */unsigned long vm_start; /* Our start address within vm_mm. */unsigned long vm_end; /* The first byte after our end address

within vm_mm. */

/* linked list of VM areas per task, sorted by address */struct vm_area_struct *vm_next, *vm_prev;

pgprot_t vm_page_prot; /* Access permissions of this VMA. */unsigned long vm_flags; /* Flags, see mm.h. */

.../* Function pointers to deal with this struct. */const struct vm_operations_struct *vm_ops;

...};


Opérations sur les régions

/* * These are the virtual MM functions - opening of an area, closing and * unmapping it (needed to keep files on disk up-to-date etc), pointer * to the functions called when a no-page or a wp-page exception occurs. */struct vm_operations_struct {

void (*open)(struct vm_area_struct * area);void (*close)(struct vm_area_struct * area);int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf);

/* notification that a previously read-only page is about to become * writable, if an error is returned it will cause a SIGBUS */int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault

*vmf);

...

};


Droits d'accès aux régions/* * vm_flags in vm_area_struct, see mm_types.h. */#define VM_READ 0x00000001 /* currently active flags */#define VM_WRITE 0x00000002#define VM_EXEC 0x00000004#define VM_SHARED 0x00000008

/* mprotect() hardcodes VM_MAYREAD >> 4 == VM_READ, and so for r/w/x bits. */#define VM_MAYREAD 0x00000010 /* limits for mprotect() etc */#define VM_MAYWRITE 0x00000020#define VM_MAYEXEC 0x00000040#define VM_MAYSHARE 0x00000080

#define VM_GROWSDOWN 0x00000100 /* general info on the segment */

#define VM_DONTCOPY 0x00020000 /* Do not copy this vma on fork */#define VM_DONTEXPAND 0x00040000 /* Cannot expand with mremap() */#define VM_RESERVED 0x00080000 /* Count as reserved_vm like IO */#define VM_ACCOUNT 0x00100000 /* Is a VM accounted object */#define VM_NORESERVE 0x00200000 /* should the VM suppress accounting */#define VM_HUGETLB 0x00400000 /* Huge TLB Page VM */#define VM_NONLINEAR 0x00800000 /* Is non-linear (remap_file_pages) */


Swap

● Parfois, la mémoire centrale n'est pas suffisante pour stocker toutes les données (code et data)

● L'intérêt de la mémoire virtuelle est que les cadres de page n'ont pas besoin d'être en mémoire centrale

● La zone de swap est un espace disque réservé dans lequel on peut stocker des cadres de page

● Le noyau se charge de faire le transfert de certains cadres de page entre la mémoire centrale et la zone de swap

– En mettant en mémoire centrale les pages les plus utilisées

– En traitant les Page fault de manière à transferer en mémoire centrale les pages du disque


Récupération d'une page en swap

● Parfois, un processus demande une page en swap alors que la mémoire centrale est occupée à 100%

– Le système choisie alors une page victime (de préférence une page peu demandée)

– Il place cette page en swap– Et utilise l'espace ainsi libéré pour la page demandée– Il met ensuite à jour les tables correspondantes

● Parfois, la page victime contient des données qui peuvent être éffacées (cache par exemple)– Dans ce cas, le système écrase simplement le cadre avec le

contenue de la page demandée– Et met à jour les tables correspondantes


Allocateur mémoire

● Le noyau s'occupe de gérer la mémoire● Lorsqu'un processus a besoin de plus de

mémoire, il fait une demande au noyau● La demande s'effectue via un appel de la

libc :– malloc() ou brk(), etc...


Gérer le tas

● malloc(size) : allouer size● calloc(n,size) : n éléments de taille size initialisés

à 0

● realloc(ptr, size) : modifier la taille d'une zone allouée avec malloc ou calloc

● free(ptr) libérer une zone

● brk(addr) faire croître le tas (current->mm->brk) jusqu'à addr

● sbrk(incr) augmenter le tas de incr


Appel système sys_brk(addr)

● Vérifie si addr fait partie d'une région de code → out

● Aligne addr sur une page

● Si réduction du tas, appel à do_munmap() → out

● Sinon, vérification des droits

● do_mmap()


do_mmap()● Alloue une nouvelle région de mémoire

– Vérifie la validité de la demande (taille, nb max de régions, droits, etc)

– Invoque get_unmapped_area() pour obtenir une adresse valide

– Calcule les droits (drapeaux) de la nouvelle région

– Si VM_SHARED à 0, alors essaye de fusionner

– Alloue une struct vm_area_struct– Remplit la structure vm_area_struct– Insère dans l'arbre des régions– Renvoie la nouvelle adresse


Allocation des objets du noyau

● kmem_cache_alloc()● L'allocateur de Linux s'appelle SLAB et part des

principes suivants :– Le type des données peut affecter la manière d'allouer la

mémoire

– Les fonctions du noyau demande souvent des zones de même taille (par exemple l'espace initial à création de processus)

– Les demandes peuvent être classées par fréquence de demande

● L'allocateur fonctionne avec un système de cache, permettant d'optimiser les demande de mémoire

3IS - Système d'exploitation linux Gestion de la...

Documents

Transcript of 3IS - Système d'exploitation linux Gestion de la...