3IS - Système d`exploitation linux

Transcription

3IS - Système d'exploitation linux
Gestion de la mémoire
2010 – David Picard
Contributions de : Arnaud Revel, Mickaël Maillard
[email protected]
ÉCOLE NATIONALE SUPÉRIEURE DE L'ÉLECTRONIQUE ET DE SES APPLICATIONS
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
0xffffffff
kernel
0xc0000000
stack
La zone kernel est
accessible uniquement en
mode noyau
Les zones de code,
données et pile sont
accéssibles en mode user
heap
0x8xxxxxxx
text
0x80000000
XXXXXXX
0x00000000
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 :
–
–
Adresses
logiques
Segmentation
Pagination
Segmentation
Adresses
linéaires
Pagination
Adresses
physiques
Les adresses logiques sont les adresses vues par le processus
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 :
–
●
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 de code (GDT ou LDT)
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)
Index
TI
Sélecteur de segment
Deux registres permettent de stocker l'adresse de la
GDT (GDTR) et de la LDT courante (LDTR)
Calcul de l'adresse linéaire
Index
offset
TI
GDTR ou LDTR
8
*
+
GDT ou LDT
Descripteur de segment
base
+
Adresse linéaire
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
0xffffffff
0xc0000000
0x9a5624ce
kernel
Cadre 2
Page 5
stack
Cadre 4
Page 4
Cadre d'un
autre processus
Page 3
Cadre 3
Cadre 5
0x8xxxxxxx
heap
Page 2
0x80000000
text
Page 1
Cadre d'un
autre processus
XXXXXXX
Cadre 1
0x00000000
0x00000000
Adresse linéaires du processus
Mémoire physique
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
directory
table
offset
Conversion en adresses physiques
directory
table
offset
Cadre de page
table de pages
Répertoire
des pages
+
+
+
cr3
Registre contenant l'adresse
du répertoire de pages
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
Accès licite : allouer un
nouveau cadre de page
Le type d'accès
correspond avec les
droits de la région
mémoire
Accès illicite : envoyer un
signal SIGSEV
(correspondant souvent
à la fameuse
segmentation fault)
L'adresse appartient à
l'espace d'adressage
du processus
L'exception s'est-elle
produite en mode
utilisateur
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
unsigned long
unsigned long
data*/
unsigned long
unsigned long
environnement */
total_vm, locked_vm, shared_vm, exec_vm;
stack_vm, reserved_vm, def_flags, nr_ptes;
start_code, end_code, start_data, end_data; /* code et
start_brk, brk, start_stack; /* tas et pile */
arg_start, arg_end, env_start, env_end; /* arguments et
...
};
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;
unsigned long vm_flags;
/* Access permissions of this VMA. */
/* 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
#define
#define
#define
#define
#define
#define
#define
VM_DONTCOPY 0x00020000
VM_DONTEXPAND 0x00040000
VM_RESERVED 0x00080000
VM_ACCOUNT
0x00100000
VM_NORESERVE 0x00200000
VM_HUGETLB
0x00400000
VM_NONLINEAR 0x00800000
/* general info on the segment */
/*
/*
/*
/*
/*
/*
/* Do not copy this vma on fork */
Cannot expand with mremap() */
Count as reserved_vm like IO */
Is a VM accounted object */
should the VM suppress accounting */
Huge TLB Page VM */
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

Transcription

Documents pareils

Fichier Solidworks : Pince Genus1.SLDDRW

Recherche d`un lieu géométrique

1 Préliminaires

Essor de la pub en ligne

Allocation dynamique de mémoire Allocation dynamique de mémoire

avis la carte region evolue

Gestion de la mémoire

Chapitre trois : les structures

Règles d`or - Lee Valley Tools