Unix Memory Management API

Features of the Unix Memory Mapping API

• memory mapping (mmap(), munmap())
• memory protection (mprotect())
• memory locking (mlock(), mlockall())
• memory synchronization (msync())

Memory Mapping

#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);

The mmap() function allows a process to establish a mapping between a range of the address space of the process and and a portion of an open file or shared memory object.

The user specifies the portion of the file. Normally, the system gets to choose the starting address of the corresponding "window" in the virtual address space of the process. The system is responsible for using the virtual memory mechanism to implement the mapping.

While the mapping is in effect, the contents of that portion of the file are accessible via memory, and vice versa. Changes made to that portion of the file affect the corresponding region of virtual memory, and vice versa.

"The prot argument determines whether read, write, execute, or some combination of accesses are permitted to the data being mapped." [Unix man-page] It is a bitwise "or" of one or more of the following:

• PROT_READ = allow reading
• PROT_WRITE = allow writing
• PROT_EXEC = allow execution
• PROT_NONE = allow no access

The flags argument specified other infomration about the mapping, including the flag MAP_SHARED, which specifies that changes to the mapped data are shared (what one usually would want). Flag values include the following:

• MAP_SHARED - changes are shared
• MAP_PRIVATE - chagnes are private
• MAP_FIXED - interpret addr exactly
• MAP_NORESERVE (Solaris) - do not reserve any swap space
• MAP_ANONYMOUS (Linux) or MAP_ANON (Solaris) - map anonymous pages (not associated with any file)
• MAP_DENYWRITE (Linux) - do not allow writes
• MAP_LOCKED (Linux) - lock the pages into main memory

Memory Mapping Examples

• examples/mmap/mshare.c
• examples/mmap/philos.c
• examples/mmap/Makefile

These two programs illustrate the use of the mmap function.

The first one just consists of two processes that share a region of memory, by mapping it to a file.

The second one is more complicated, and also uses the POSIX semaphore operations. It implements a solution to the Dining Philosphers problem for processes.

Memory Protection

#include <sys/mman.h>
int mprotect(void *addr, size_t len, int prot);

memory locking (mlock(), mlockall())

#include <sys/mman.h>
int mlockall(int flags);
int munlockall(void);
int mlock(const void * addr, size_t len);
int munlock(const void * addr, size_t len);

The mlock() function uses the mappings established for the address range [addr, addr + len) to identify pages to be locked in memory. [Unix man pages]

The mlockall() function locks in memory all pages mapped by an address space.

With mlocakall(), the process can specify whether the locking applies only to current pages, only to future pages, or both, using the flags MCL_CURRENT and MCL_FUTURE. [Unix man pages]

Memory Synchronization

#include <sys/mman.h>
int msync(void *addr, size_t len, int flags);

The msync() function writes all modified copies of pages over the range [addr, addr + len) to the underlying hardware, or invalidates any copies so that further references to the pages will be obtained by the system from their permanent storage locations. The permanent storage for a modified MAP_SHARED mapping is the file the page is mapped to; the permanent storage for a modified MAP_PRIVATE mapping is its swap area. [Unix man pages]

The flags control details of the behavior:

• MS_ASYNC - perform asynchronous writes
• MS_SYNC - perform synchronous writes
• MS_INVALIDATE - invalidate mappings (makes modifications visible to other processes)