July 16th Monday (七月 十六日 月曜日)

  Mapped memory permits different processes to communicate via a shared file.
Although you can think of mapped memory as using a shared memory segment
with a name,you should be aware that there are technical differences.Mapped
memory can be used for interprocess communication or as an easy way to access
the contents of a file.

  Mapped memory forms an association between a file and a process’s memory.
Linux splits the file into page-sized chunks and then copies them into virtual memory
pages so that they can be made available in a process’s address space.Thus,the process
can read the file’s contents with ordinary memory access.It can also modify the file’s
contents by writing to memory.This permits fast access to files.

  You can think of mapped memory as allocating a buffer to hold a file’s entire con-
tents,and then reading the file into the buffer and (if the buffer is modified) writing
the buffer back out to the file afterward.Linux handles the file reading and writing
operations for you.

  To map an ordinary file to a process’s memory, use the mmap (“Memory MAPped,”
pronounced “em-map”) call.  The first argument is the address at which you would like
Linux to map the file into your process’s address space;the value NULL allows Linux
to choose an available start address.The second argument is the length of the map in
bytes.The third argument specifies the protection on the mapped address range.The
protection consists of a bitwise “or”of PROT_READ, PROT_WRITE, and PROT_EXEC,
corresponding to read, write, and execution permission, respectively.  The fourth
argument is a flag value that specifies additional options.  The fifth argument is
a file descriptor opened to the file to be mapped.The last argument is the offset
from the beginning of the file from which to start the map.  You can map all or part
of the file into memory by choosing the starting offset and length appropriately.

The flag value is a bitwise “or”of these constraints:

* MAP_FIXED -- If you specify this flag,Linux uses the address you request to map
  the file rather than treating it as a hint.This address must be page-aligned.

* MAP_PRIVATE--Writes to the memory range should not be written back to the
  attached file,but to a private copy of the file.No other process sees these writes.
  This mode may not be used with MAP_SHARED.

* MAP_SHARED--Writes are immediately reflected in the underlying file rather than
  buffering writes.Use this mode when using mapped memory for IPC.This
  mode may not be used with MAP_PRIVATE.

  If the call succeeds,it returns a pointer to the beginning of the memory.  On failure,
it returns MAP_FAILED.

  When you’re finished with a memory mapping, release it by using munmap.  Pass it
thestart address and length of the mapped memory region.  Linux automatically unmaps
mapped regions when a process terminates.

  Different processescan communicate using memory-mapped regions associated with
the same file.  Specify the MAP_SHARED flag so that any writes to these regions are
immediately transferred to the underlying file and made visible to other processes.
If you don’t specify this flag,  Linux may buffer writes before transferring them to
the file.

  Alternatively, you can force Linux to incorporate buffered writes into the disk file
by calling msync.  Its first two parameters specify a memory-mapped region, as for munmap.
The third parameter can take these flag values:

* MS_ASYNC--The update is scheduled but not necessarily run before the call
  returns.

* MS_SYNC--The update is immediate; the call to msync blocks until it’s done.
  MS_SYNC and MS_ASYNC may not both be used.

* MS_INVALIDATE--All other file mappings are invalidated so that they can see the
  updated values.

  For example,to flush a shared file mapped at address mem_addr of length mem_length
bytes, call this:

  msync(mem_addr, mem_length, MS_SYNC | MS_INVALIDATE);

  As with shared memory segments, users of memory-mapped regions must establish
and follow a protocol to avoid race conditions.  For example,a semaphore can be used
to prevent more than one process from accessing the mapped memory at one time.
Alternatively,  you can use fcntl to place a read or write lock on the file.

  Specifying MAP_PRIVATE to mmap createsa copy-on-write region.  Any write to the
region is reflected only in this process’s memory;  other processes that map the same
file won’t see the changes.  Instead of writing directly to a page shared by all processes,
the process writes to a private copy of this page.All subsequent reading and writing by
the process use this page.

  The mmap call can be used for purposes other than interprocess communications.One
common use is as a replacement for read and write.  For example,rather than explic-
itly reading a file's contents into memory, a program might map the file into memory
and scan it using memory reads.For some programs, this is more convenient and may
also run faster than explicit file I/O operations.

  One advanced and powerful technique used by some programs is to build data
structures (ordinary struct instances, for example) in a memory-mapped file.  On a
subsequent invocation, the program maps that file back into memory,and the data
structures are restored to their previous state.  Note, though, that pointers in
these data structures will be invalid unless they all point within the same mapped
region of memory and unless care is taken to map the file back into the same address
region that it occupied originally.

  Another handy technique is to map the special /dev/zero file into memory.  That
file behaves as if it were an infinitely long file filled with 0 bytes.  A program
that needs a source of 0 bytes can mmap the file /dev/zero.  Writes to /dev/zero are
discarded, so the mapped memory may be used for any purpose.Custom memory allocators
often map /dev/zero to obtainchunks of preinitialized memory.

  After memoryhas been mapped,these permissions can be modified with the
mprotect system call.The arguments to mprotect are an address of a memory region,
the size of the region,and a set of protection flags.The memory region must consist of
entire pages:The address of the region must be aligned to the system’s page size,and
the length of the region must be a page size multiple.The protection flags for these
pages are replaced with the specified value.