Come utilizzare la funzione mmap in linguaggio c?

IL mmap () La funzione viene utilizzata per la mappatura tra uno spazio dell'indirizzo di processo e file o dispositivi. Quando un file viene mappato su uno spazio dell'indirizzo di processo, è possibile accedere al file come un array nel programma. Questo è uno dei modi più efficienti per accedere ai dati nel file e fornisce un'interfaccia di codifica senza soluzione di continuità che è naturale per una struttura di dati che può essere valutata senza l'astrazione della lettura e della scrittura dai file. In questo articolo, discuteremo di come usare il mmap () funzione in Linux. Quindi iniziamo.

File di intestazione:

#includere

Sintassi:

void * mmap (void * indirizzo, dimensione_t lunghezza, int protezione, flag int, int filede,
offset off_t)

Argomenti:

La funzione prende 6 argomenti:

indirizzo:

Questo argomento fornisce un indirizzo iniziale preferito per la mappatura. Se non esiste un'altra mappatura, allora il kernel sceglierà un limite di pagina nelle vicinanze e creerà la mappatura; Altrimenti, il kernel sceglie un nuovo indirizzo. Se questo argomento è nullo, il kernel può posizionare la mappatura ovunque si vede in forma.

lunghezza:

Questo è il numero di byte che devono essere mappati.

proteggere:

Questo argomento è usato per controllare il tipo di accesso consentito. Questo argomento può essere logico "o" delle seguenti flag Prot_read | Prot_write | Prot_exec | Prot_none. I tipi di accesso di lettura, scrittura ed esecuzione sono le autorizzazioni sul contenuto.

Flag:

Questo argomento è usato per controllare la natura della mappa. Di seguito sono riportati alcuni valori comuni delle flag:

• Map_shared: Questo flag viene utilizzato per condividere la mappatura con tutti gli altri processi, che sono mappati su questo oggetto. Le modifiche apportate alla regione di mappatura verranno scritte al file.
• Map_private: Quando viene utilizzata questo flag, la mappatura non verrà visualizzata da nessun altro processo e le modifiche apportate non saranno scritte nel file.
• Map_anonymous / map_anon: Questo flag viene utilizzato per creare una mappatura anonima. Mappatura anonima significa che la mappatura non è connessa a nessun file. Questa mappatura viene utilizzata come primitivo di base per estendere il mucchio.
• Map_fixed: Quando viene utilizzato questo flag, il sistema deve essere costretto a utilizzare l'indirizzo di mappatura esatto specificato nel indirizzo Se questo non è possibile, la mappatura sarà fallita.

Filedes:

Questo è il descrittore di file che deve essere mappato.

compensare:

Questo è offset da dove è iniziata la mappatura dei file. In termini semplici, la mappatura si collega (compensare) A (offset+lunghezza-1) byte per il file aperto Deniugerati descrittore.

Valori di ritorno:

Sul successo, il mmap () Restituisce 0; Per fallimento, la funzione restituisce map_failad.

Patorialmente, possiamo rappresentare la funzione della mappa come segue:

Per una mappa la regione mappata munmap () La funzione viene utilizzata:

Sintassi:

int munmap(vuoto *indirizzo, size_t lunghezza);

Valori di ritorno:

Sul successo, il munmap () Restituisce 0; Per fallimento, la funzione restituisce -1.

Esempi:

Ora vedremo un programma di esempio per ciascuno dei seguenti usando la chiamata di sistema MMAP ():

• Allocazione della memoria (Esempio1.C)
• File di lettura (esempio2.C)
• File di scrittura (Esempio3.C)
• Comunicazione di interprocess (Esempio4.C)

Esempio 1.C

#includere
#includere
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 ("mappatura non riuscita \ n");
Ritorno 1;

per (int i = 0; iptr [i] = i*10;
per (int i = 0; iprintf ("[%d]", ptr [i]);
printf ("\ n");
int err = munmap (ptr, 10*sizeof (int));
Se (err != 0)
printf ("non mappatura non riuscita \ n");
Ritorno 1;

restituzione 0;

Nell'esempio1.c Allontamo la memoria usando MMAP. Qui abbiamo usato prot_read | Protezione prot_write per la lettura e la scrittura nella regione mappata. Abbiamo usato Map_Private | FLAG MAP_ANONYMOUS. Map_private viene utilizzato perché la regione di mappatura non è condivisa con altri processi e MAP_anonymous viene utilizzato perché qui non abbiamo mappato alcun file. Per lo stesso motivo, il Descrittore di file e il compensare Il valore è impostato su 0.

Esempio2.C

#includere
#includere
#includere
#includere
#includere
#includere
int main (int argc, char *argv [])
if (argc < 2)
printf ("percorso del file non menzionato \ n");
uscita (0);

const char *filepath = argv [1];
int fd = open (filePath, o_rdonly);
if (fd < 0)
printf ("\ n \"%s \ ""Impossibile aprire \ n"",
percorso del file)