Comment utiliser la fonction MMAP dans le langage C?

Le mmap () La fonction est utilisée pour la cartographie entre un espace d'adresse de processus et soit des fichiers ou des appareils. Lorsqu'un fichier est mappé sur un espace d'adresse de processus, le fichier est accessible comme un tableau dans le programme. Il s'agit de l'un des moyens les plus efficaces d'accéder aux données dans le fichier et fournit une interface de codage transparent qui est naturelle pour une structure de données qui peut être évaluée sans l'abstraction de la lecture et de l'écriture à partir de fichiers. Dans cet article, nous allons discuter de la façon d'utiliser le mmap () fonction dans Linux. Alors, commençons.

En tête de fichier:

#inclure

Syntaxe:

void * mmap (void * adresse, taille_t, longueur int, drapeau int, int filets,
offset off_t)

Arguments:

La fonction prend 6 arguments:

adresse:

Cet argument donne une adresse de départ préférée pour la cartographie. Si une autre cartographie n'existe pas là-bas, alors le noyau choisira une limite de page à proximité et créera le mappage; Sinon, le noyau choisit une nouvelle adresse. Si cet argument est nul, alors le noyau peut placer la cartographie partout où elle le juge.

longueur:

C'est le nombre d'octets qui doivent être cartographiés.

protéger:

Cet argument est utilisé pour contrôler le type d'accès autorisé. Cet argument peut être logique «ou» des drapeaux suivants Prot_read | Prot_write | Prot_exec | Prot_none. Les types d'accès à lire, écrire et exécuter sont les autorisations sur le contenu.

Frappeurs:

Cet argument est utilisé pour contrôler la nature de la carte. Voici quelques valeurs communes des drapeaux:

• Map_shared: 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 cartographie seront réécrites dans le fichier.
• Map_private: Lorsque ce drapeau sera 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 une cartographie anonyme. Le mappage anonyme signifie que le mappage n'est connecté à aucun fichier. Cette cartographie est utilisée comme primitive de base pour étendre le tas.
• Map_fixed: Lorsque ce drapeau est utilisé, le système doit être obligé d'utiliser l'adresse de mappage exacte spécifiée dans le adresse Si cela n'est pas possible, alors le mappage échouera.

FiledS:

Ceci est le descripteur de fichier qui doit être mappé.

compenser:

Ceci est compensé à partir de l'endroit où le mappage de fichiers a commencé. En termes simples, le mappage se connecte à (compenser) pour (décalage + longueur-1) octets pour le fichier ouvert sur licenciés descripteur.

Valeurs de retour:

Sur le succès, le mmap () retourne 0; Pour l'échec, la fonction renvoie map_failed.

Pictorialement, nous pouvons représenter la fonction MAP comme suit:

Pour un mappage de la région cartographiée Munmap () La fonction est utilisée:

Syntaxe:

int munmap(annuler *adresse, size_t longueur));

Valeurs de retour:

Sur le succès, le Munmap () retourne 0; Pour l'échec, la fonction renvoie -1.

Exemples:

Maintenant, nous verrons un exemple de programme pour chacun des éléments suivants en utilisant l'appel système mmap ():

• Allocation de mémoire (exemple1.c)
• Fichier de lecture (Exemple2.c)
• Écriture de fichiers (Exemple3.c)
• Communication interprodique (Exemple4.c)

Exemple 1.c

#inclure
#inclure
int main()
int n = 5;
int * ptr = mmap (null, n * sizeof (int),
Prot_read | Prot_write, map_private | Map_anonymous, 0, 0);
if (ptr == map_failed)
printf ("mappage a échoué \ n");
retour 1;

pour (int i = 0; iptr [i] = i * 10;
pour (int i = 0; iprintf ("[% d]", ptr [i]);
printf ("\ n");
int err = munmap (ptr, 10 * sizeof (int));
Si (euh != 0)
printf ("Unmaping a échoué \ n");
retour 1;

retour 0;

Dans l'exemple1.c Nous allouons 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 | Map_anonymous drapeau. Map_private est utilisé car la région de cartographie n'est pas partagée avec d'autres processus, et Map_anonymous est utilisé car ici, nous n'avons cartographié aucun fichier. Pour la même raison, le descripteur de fichiers et le compenser la valeur est définie sur 0.

Exemple2.c

#inclure
#inclure
#inclure
#inclure
#inclure
#inclure
int main (int argc, char * argv [])
if (argc < 2)
printf ("chemin de fichier non mentionné \ n");
sortie (0);

const char * filepath = argv [1];
int fd = open (filepath, o_rdonly);
if (fd < 0)
printf ("\ n \"% s \ ""ne pouvait pas ouvrir \ n"",
chemin du fichier)