Once an executable image has been memory mapped into a process' virtual memory it
can start to execute.
As only the very start of the image is physically pulled into memory it will soon access an area
of virtual memory that is not yet in physical memory.
When a process accesses a virtual address that does not have a valid page table
entry, the processor will report a page fault to Linux.
The page fault describes the virtual address where the page fault occurred and the type
of memory access that caused the fault.
Linux must find the area of memory in which the page fault occurred in. This is
done through the vm_area_struct kernel data structure.
As searching through the vm_area_struct data structures is critical to the efficient
handling of page faults, these are linked together in an AVL
(Adelson-Velskii and Landis) tree structure.
(An AVL tree structure is a balanced binary search tree where the height of the two
subtrees (children) of a node differs by at most one, thus optimizing searches.)
If there is no vm_area_struct data structure for this faulting virtual address,
this process has accessed an illegal virtual address.
Linux will signal the process, sending a SIGSEGV signal and if the process does not
have a handler for that signal it will be terminated.
Linux next checks the type of page fault that occurred against the types of accesses
allowed for this area of virtual memory.
If the process is accessing the memory in an illegal way, say writing to an area that it
is only allowed to read from, it is also signalled with a memory error.
Now that Linux has determined that the page fault is legal, it must deal with it.
Linux must differentiate between pages that are in the swap file and those that are part
of an executable image on a disk somewhere.
It does this by using the page table entry for this faulting virtual address.
If the page's page table entry is invalid but not empty, the page fault is for a page
currently being held in the swap file.
For Alpha AXP page table entries, these are entries which do not have their valid bit set
but which have a non-zero value in their PFN field.
In this case the PFN field holds information about where in the swap (and which swap
file) the page is being held.
How pages in the swap file are handled is described later in this chapter.
Not all vm_area_struct data structures have a set of virtual memory operations and even
those that do may not have a nopage operation.
This is because by default Linux will fix up the access by allocating a new physical page and
creating a valid page table entry for it.
If there is a nopage operation for this area of virtual memory, Linux will use it.
The generic Linux nopage operation
is used for
memory mapped executable images and it uses the page cache to bring the required image
page into physical memory.
However the required page is brought into physical memory, the process' page tables are updated.
It may be necessary for hardware specific actions to update those entries, particularly if
the processor uses translation look aside buffers.
Now that the page fault has been handled it can be dismissed and the process is restarted
at the instruction that made the faulting virtual memory access.