Today's Outline

• page faults
• memory zones
• kernel memory allocation
• slab layer

page fault outline

• locate a free page
• locate the page on the disk
• issue a read request to the disk system
• when the page is ready, put it into memory (may be done by DMA)
• restart the process that page faulted by re-executing the instruction that faulted
• kernel pages for the disk system should never be evicted -- we refer to such pages as locked, wired down, or pinned
• same for real-time processes and most or all interrupt handlers

free page pool

• it is a good idea for the OS to normally have some free pages, so page faults can be addressed quickly
• a process or thread (e.g. kswapd in linux -- see also this description) tries to make sure there are always pages available
• if not, candidate pages are freed, either directly for clean pages, or by writing to disk the dirty pages

memory zones

• not all memory is alike
• x86 limitations:
  • only physical memory up to 16MB can be used for DMA: ZONE_DMA
  • physical memory above 896MB cannot be permanently mapped into the kernel's address space: ZONE_HIGHMEM
  • everything in between is ZONE_NORMAL
• most other architectures have fewer constraints

kernel memory allocation

• page allocations:

  struct page * alloc_pages (unsigned int gfp_mask, unsigned int order)
  struct page * alloc_page (unsigned int gfp_mask)
    void * page_address (struct page * page)
  
  unsigned long __get_free_pages (unsigned int gfp_mask, unsigned int order)
  unsigned long __get_free_page (unsigned int gfp_mask)
  unsigned long __get_zeroed_page (unsigned int gfp_mask)
  
  void __free_pages (struct page * page, unsigned int order)
  void free_pages (struct long addr, unsigned int order)
  void free_page (struct long addr)
  

• the above can return either a pointer to the page descriptor, or the page number
• order is the power of two of the number of pages, e.g. order = 5 requests 32 pages
• byte allocations:

  void * kmalloc (size_t size, int flags)  // physically contiguous memory
  void kfree (void * ptr)
  void * vmalloc (size_t size, int flags)  // not physically contiguous memory
  void vfree (void * ptr)
  

• hardware devices require physically contiguous memory for DMA, for all other uses memory does not need to be physically contiguous

gfp_flags

• GFP_ATOMIC: cannot sleep (therefore, more likely to fail)
• GFP_NOIO: may sleep, may not perform I/O
• GFP_NOFS: may sleep and perform I/O, may not access the file system
• GFP_KERNEL: may sleep and perform I/O, including file system operations
• GFP_USER: for user-space allocations
• GFP_HIGHUSER: high memory may be returned
• GFP_DMA: DMA memory must be returned

Free Lists

• if many objects of the same size will be allocated and freed frequently, it is a good idea to keep a free list:
  1. allocate at least one page when memory is needed
  2. additional requests return addresses within that page (until the page is exhausted, then return to step 1)
  3. when structure is freed, do not return to system, but keep in a free list
  4. allocations check the free list first, and return from there if available
• the free list is very efficient for frequent allocations and deallocations
• the free list is inefficient because it never returns memory to the system
• slab layer: an implementation of free list allocations that allows for better sharing

Slab Layer

• one cache per type of object
• memory allocated at least one page at a time: one slab is one or more contiguous pages
• when all the objects in a slab are freed, the slab can be returned, if the system is low on memory