When an image is executed, the contents of the executable image must be brought into
the process' virtual address space.
The same is also true of any shared libraries that the executable image has been linked to use.
The executable file is not actually brought into physical memory, instead it is merely
linked into the process' virtual memory.
Then, as the parts of the program are referenced by the running application, the
image is brought into memory from the executable image.
This linking of an image into a process' virtual address space is known as memory mapping.
Figure: Areas of Virtual Memory
Every process' virtual memory is represented by an mm_struct data structure.
This contains information about the image that it is currently executing (for example bash)
and also has pointers to a number of vm_area_struct data structures.
Each vm_area_struct data structure describes the start and end of the area of virtual memory,
the process' access rights to that memory and a set of operations for that memory.
These operations are a set of routines that Linux must use when manipulating this area of
For example, one of the virtual memory operations performs the correct actions when the
process has attempted to access this virtual memory but finds (via a page fault) that the
memory is not actually in physical memory.
This operation is the nopage operation.
The nopage operation is used when Linux demand pages the pages of an executable
image into memory.
When an executable image is mapped into a process' virtual address a set of vm_area_struct
data structures is generated.
Each vm_area_struct data structure represents a part of the executable image; the executable
code, initialized data (variables), unintialized data and so on.
Linux supports a number of standard virtual memory operations and, as
the vm_area_struct data structures are created, the correct set of virtual memory operations
are associated with them.