Phenquestions
)
En tête de fichier:
#inclureSyntaxe:
void * mmap (void *address, size_t length, int protect, int flags, int filedes,off_t décalage)
Arguments:
La fonction prend 6 arguments :
1. adresse:
Cet argument donne une adresse de départ préférée pour le mappage. S'il n'y a pas d'autre mappage, le noyau choisira une limite de page à proximité et créera le mappage ; sinon, le noyau choisit une nouvelle adresse. Si cet argument est NULL, alors le noyau peut placer le mappage où bon lui semble.
2. longueur:
C'est le nombre d'octets à mapper.
3. protéger:
Cet argument est utilisé pour contrôler quel type d'accès est autorisé. Cet argument peut être le 'OU' logique des drapeaux suivants PROT_READ | PROT_WRITE | PROT_EXEC | PROT_NONE. Les types d'accès de lecture, d'écriture et d'exécution sont les autorisations sur le contenu.
4. drapeaux :
Cet argument est utilisé pour contrôler la nature de la carte. Voici quelques valeurs communes des drapeaux :
- MAP_PARTAGÉE : Ce drapeau est utilisé pour partager le mappage avec tous les autres processus, qui sont mappés sur cet objet. Les modifications apportées à la région de mappage seront réécrites dans le fichier.
- MAP_PRIVATE : Lorsque cet indicateur est utilisé, le mappage ne sera vu par aucun autre processus et les modifications apportées ne seront pas écrites dans le fichier.
- MAP_ANONYMOUS / MAP_ANON : Ce drapeau est utilisé pour créer un mappage anonyme. Le mappage anonyme signifie que le mappage n'est connecté à aucun fichier. Ce mappage est utilisé comme primitive de base pour étendre le tas.
- MAP_FIXED : Lorsque cet indicateur est utilisé, le système doit être forcé d'utiliser l'adresse de mappage exacte spécifiée dans le adresse Si cela n'est pas possible, le mappage échouera.
5. fichiers :
C'est le descripteur de fichier qui doit être mappé.
6. décalage:
Ceci est décalé par rapport à l'endroit où le mappage de fichier a commencé. En termes simples, la cartographie se connecte à (décalage) à (décalage+longueur-1) octets pour le fichier ouvert sur fichiers descripteur.
Valeurs de retour :
En cas de succès, le mmap() renvoie 0 ; en cas d'échec, la fonction renvoie MAP_FAILED.
De manière imagée, nous pouvons représenter la fonction map comme suit :
Pour démapper la région cartographiée munmap() la fonction est utilisée :
Syntaxe:
int munmap(annuler *adresse, taille_t longueur);
Valeurs de retour :
En cas de succès, le munmap() renvoie 0 ; en cas d'échec, la fonction renvoie -1.
Exemples:
Nous allons maintenant voir un exemple de programme pour chacun des éléments suivants utilisant l'appel système mmap() :
- Allocation de mémoire (Exemple1.c)
- Lecture de fichier (Exemple2.c)
- Fichier d'écriture (Exemple3.c)
- Communication interprocessus (Exemple4.c)
Exemple 1.c
#inclure#inclure
int main()
entier N=5; // Nombre d'éléments pour le tableau
int *ptr = mmap ( NULL, N*sizeof(int),
PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYME,
0, 0 );
if(ptr == MAP_FAILED)
printf("Le mappage a échoué\n");
retour 1 ;
// Remplir les éléments du tableau
for(int i=0; i ");
for(int i=0; i
printf("\n");
int err = munmap(ptr, 10*sizeof(int));
si (erreur != 0)
printf("Échec du mappage\n");
retour 1 ;
renvoie 0 ;
Dans Exemple1.c nous allouons de la mémoire en utilisant mmap. Ici, nous avons utilisé PROT_READ | Protection PROT_WRITE pour la lecture et l'écriture dans la région mappée. Nous avons utilisé le MAP_PRIVATE | Drapeau MAP_ANONYMOUS. MAP_PRIVATE est utilisé car la région de mappage n'est pas partagée avec d'autres processus, et MAP_ANONYMOUS est utilisé car ici, nous n'avons mappé aucun fichier. Pour la même raison, le descripteur de fichier et le décalage la valeur est définie sur 0.
Exemple2.c
#inclure#inclure
#inclure
#inclure
#inclure
#inclure
int main(int argc, char *argv[])
si(argc < 2)
printf("Chemin du fichier non mentionné\n");
sortie(0);
const char *filepath = argv[1];
int fd = open(chemin d'accès, O_RDONLY);
si (fd < 0)
printf("\n\"%s \"" n'a pas pu ouvrir\n"",
chemin du fichier)
