pagemap.h

Go to the documentation of this file.

// See the end of this file for license information.

#ifndef TORSION_PAGE_H
#define TORSION_PAGE_H

#include "irq.h"
#include "hash.h"
#include "array.h"
#include "types.h"
#include "addrmap.h"
#include "critical.h"
#include "slaballoc.h"

class Page_map;
extern Page_map page_map;

const unsigned VIRTUAL_MEMORY_END = ~0;


class Mapping_cache_info {
public:
  unsigned ref_count;     
  unsigned last_mapped_time;    
  void* virtual_page;     
  void* physical_page;      

  inline void
  init(void* virtual_page = NULL, void* physical_page = NULL) {
    ref_count = 0;
    last_mapped_time = 0;
    this->virtual_page = virtual_page;
    this->physical_page = physical_page;
  }
};


class Page_map : public Address_map {
protected:
  void* direct_mapped_end;    
  unsigned* temp_mapping_cache;   
  unsigned* first_free_temp_mapping;  
  static const Size MAPPING_CACHE_PAGE_COUNT = 1024;
  Mapping_cache_info mapping_cache_usage[MAPPING_CACHE_PAGE_COUNT];
  Hash_table<void*, Mapping_cache_info*> mapping_cache_mappings;
  Hash_node<void*, Mapping_cache_info*> mapping_nodes[MAPPING_CACHE_PAGE_COUNT];
  Int_handler handler;      

  Hash_table<void*, void*> dirty_pages[2];
  int dirty_pages_index;    

  Slab_allocator dirty_pages_nodes[2];
  
public:
  static const unsigned PTE_USER = 0x4;
  static const unsigned PTE_ACCESSED = 0x20;
  static const unsigned PTE_PAGE_FRAME_ADDRESS = 0xfffff000;
  static const unsigned DIRTY_PAGE_COPIED = 1;
  static const unsigned CR0_PAGING = (1 << 31);
  static const unsigned CR0_RESPECT_READONLY = (1 << 16);

  void
  init(unsigned& last_available_address);

  void map_page(void* virtual_page, void* physical_page);

  unsigned*
  map_temp_page(unsigned* physical_page);

  void
  unmap_temp_page(unsigned* virtual_page);

  void
  unmap_page(void* virtual_page);

  static inline unsigned*
  table_entry_to_phys(unsigned page_entry) {
    return (unsigned*)(page_entry & PTE_PAGE_FRAME_ADDRESS);
  }

  inline Hash_table<void*, void*>&
  get_dirty_pages() {
    return dirty_pages[dirty_pages_index];
  }
  
  inline Hash_table<void*, void*>&
  get_dirty_pages_next() {
    // 1 - dirty_pages_index, so as to get whichever of the two indices
    // (0 and 1) that dirty_pages_index isn't
    return dirty_pages[1 - dirty_pages_index];
  }

  inline void
  switch_dirty_pages_hashes() {
    // each time this function is called, dirty_pages_index switches between
    // 0 and 1
    dirty_pages_index = 1 - dirty_pages_index;    
  }

  void
  free_dirty_pages_next();

  bool
  handle_page_fault();

  inline void*
  virtual_to_physical_page(void* virtual_addr) {
    return table_entry_to_phys(get_table_entry(virtual_addr));
  }

  inline bool
  is_dirty(void* virtual_addr) {
    if (dirty_pages_index == -1)
      return false;

    return dirty_pages[dirty_pages_index].has_key(virtual_addr);
  }

  void
  add_dirty_page(void* dirty_page, void* physical_page = NULL, int index = -1);

  void
  print();
};

inline bool
page_fault_handler();

// TODO:
// upon evicting a page to disk (swapping):
// log the page to disk
// (note that if the page to swap is copy-on-write, maybe log the original
//  instead of the copy so as to ensure snapshot consistency?)
// unset dirty bit in pte
// add the page to the block map (in memory)

// Page table entry for virtual page in memory:
// 
//  31                                   12     9 8 7 6 5 4 3 2 1 0
// +---------------------------------------------------------------+
// |                                       |                  U R  |
// |       page frame address 31..12       |0 0 0 X X D A X X / / P|
// |                                       |                  S W  |
// +---------------------------------------------------------------+
//
//   P : present = 1
// R/W : read/write
// U/S : user/supervisor = 0
//   D : dirty
//   X : Intel reserved
//   0 : unused
//
// Page table entry for unused virtual page:
// 
//  31                                                            0
// +---------------------------------------------------------------+
// |                                                               |
// |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0|
// |                                                               |
// +---------------------------------------------------------------+

#endif

/* Torsion Operating System, Copyright (C) 2000-2004 Dan Helfman
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details (in the COPYING file).
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

---

Torsion Operating System, Copyright (C) 2000-2004 Dan Helfman