paging.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef paging_h
#define paging_h

#include "types.h"

#include "types.h"
#include "config.h"
#include "assert.h"

//
// INTERFACE definition follows 
//


class Ptab;
class Pdir;

namespace Page {

  /* These things must be defined in arch part in
     the most efficent way according to the architecture.
  
  typedef int Attribs;

  enum Attribs_enum {
    USER_NO  = xxx, ///< User No access
    USER_RO  = xxx, ///< User Read only
    USER_RW  = xxx, ///< User Read/Write
    USER_RX  = xxx, ///< User Read/Execute
    USER_XO  = xxx, ///< User Execute only
    USER_RWX = xxx, ///< User Read/Write/Execute

    NONCACHEABLE = xxx, ///< Caching is off
    CACHEABLE    = xxx, ///< Cahe is enabled
  };
     
  
  */

};

class PF {
public:
  static Mword is_translation_error( Mword error );
  static Mword is_usermode_error( Mword error );
  static Mword is_read_error( Mword error );
  static Mword addr_to_msgword0( Address pfa, Mword error );
  static Mword pc_to_msgword1( Address pc, Mword error );
};

class Pd_entry
{
public:
  enum
    {
      Shift         =  Config::SUPERPAGE_SHIFT,
      Mask          = (Config::SUPERPAGE_SIZE/4-1),
    };

  enum
    {
      Valid         = 0x00000001, 
      Writable      = 0x00000002, 
      User          = 0x00000004, 
      Write_through = 0x00000008, 
      Cacheable     = 0x00000000, 
      Noncacheable  = 0x00000010, 
      Referenced    = 0x00000020, 
      Dirty         = 0x00000040, 
      Superpage     = 0x00000080, 
      Cpu_global    = 0x00000100, 
      L4_global     = 0x00000200, 
      Ptabfn        = 0xfffff000, 
      Superfn       = 0xffc00000, 
    };

private:
  Unsigned32        _raw;
  static Unsigned32 _cpu_global;

public:  
  inline int valid() const;
  
  inline int user() const;
  
  inline int writable() const;
  
  inline int superpage() const;
  
  inline Address ptabfn() const;
  
  inline Address superfn() const;
  
  inline Ptab* ptab() const;
  
  inline Unsigned32 raw() const;
  
  inline Unsigned32 raw() const volatile;
  
  inline Unsigned32& raw();
  
  inline void add_attr(Unsigned32 attr);
  
  inline void del_attr(Unsigned32 attr);
  
  inline Pd_entry const& operator = (Pd_entry const& other);
  
  inline Pd_entry const& operator = (Unsigned32 raw);
  
  static inline void enable_global();
  
  static inline Unsigned32 global();
};

class Pt_entry
{
public:
  enum
    {
      Shift         =  Config::PAGE_SHIFT,
      Mask          = (Config::PAGE_SIZE/4-1),
    };

  enum
    {
      Valid         = 0x00000001, 
      Writable      = 0x00000002, 
      User          = 0x00000004, 
      Write_through = 0x00000008, 
      Cacheable     = 0x00000000, 
      Noncacheable  = 0x00000010, 
      Referenced    = 0x00000020, 
      Dirty         = 0x00000040, 
      Pat_index     = 0x00000080, 
      Cpu_global    = 0x00000100, 
      L4_global     = 0x00000200, 
      Pfn           = 0xfffff000, 
    };

private:
  Unsigned32        _raw;

public:  
  //---------------------------------------------------------------------------
  inline Pt_entry const& operator = (Pt_entry const &other);
  
  inline Pt_entry const& operator = (Unsigned32 raw);
  
  inline Unsigned32 raw() const;
  
  inline Unsigned32& raw();
  
  inline void add_attr(Unsigned32 attr);
  
  inline void del_attr(Unsigned32 attr);
  
  inline int valid() const;
  
  inline int writable() const;
  
  inline Address pfn() const;
  
  static inline Unsigned32 global();
};

class Pdir
{
protected:
  Pd_entry _entries[1024];

private:
  static bool       _have_superpages;

public:  
  Address virt_to_phys(Address virt) const;
  
  static inline unsigned virt_to_idx(Address virt);
  
  inline Pd_entry* lookup(Address virt);
  
  inline Pd_entry entry(Address virt) const;
  
  inline const Pd_entry* index(unsigned idx) const;
  
  inline Pd_entry* index(unsigned idx);
  
  inline Unsigned32& operator[](unsigned idx);
  
  inline Unsigned32 operator[](unsigned idx) const;
  
  inline void clear();
  
  void map_superpage(Address phys, Address virt, Address (*ptab_alloc)(), Unsigned32 attr);
  
  static inline void have_superpages(bool yes);
};

class Ptab
{
protected:
  Pt_entry _entries[1024];

public:  
  //---------------------------------------------------------------------------
  static inline unsigned virt_to_idx(Address virt);
  
  inline Pt_entry* lookup(Address virt);
  
  inline Pt_entry entry(Address virt) const;
  
  inline Pt_entry* index(unsigned idx);
  
  inline Unsigned32& operator[](unsigned idx);
  
  inline Unsigned32 operator[](unsigned idx) const;
  
  inline void clear();
};

namespace Page 
{
  typedef Unsigned32 Attribs;

  enum Attribs_enum 
  {
    USER_NO       = 0x00000002, 
    USER_RO       = 0x00000004, 
    USER_RW       = 0x00000006, 
    USER_RX       = 0x00000004, 
    USER_XO       = 0x00000004, 
    USER_RWX      = 0x00000006, 
    MAX_ATTRIBS   = 0x00000006,
  };
};

//
// IMPLEMENTATION includes follow (for use by inline functions)
//


#include <cstring>
#include "mem_layout.h"
#include "regdefs.h"

//
// IMPLEMENTATION of inline functions (and needed classes)
//




inline Mword PF::is_translation_error(Mword error)
{
  return !(error & PF_ERR_PRESENT);
}



inline Mword PF::is_usermode_error(Mword error)
{
  return (error & PF_ERR_USERMODE);
}



inline Mword PF::is_read_error(Mword error)
{
  return !(error & PF_ERR_WRITE);
}



inline Mword PF::addr_to_msgword0(Address pfa, Mword error)
{
  return    (pfa   & ~(PF_ERR_PRESENT | PF_ERR_WRITE))
          | (error &  (PF_ERR_PRESENT | PF_ERR_WRITE));
}



inline Mword PF::pc_to_msgword1(Address pc, Mword error)
{
  return is_usermode_error(error) ? pc : (Mword)-1;
}



inline int
Pd_entry::valid() const
{
  return _raw & Valid;
}



inline int
Pd_entry::user() const
{
  return _raw & User;
}



inline int
Pd_entry::writable() const
{
  return _raw & Writable;
}



inline int
Pd_entry::superpage() const
{
  return _raw & Superpage;
}



inline Address
Pd_entry::ptabfn() const
{
  return _raw & Ptabfn;
}



inline Address
Pd_entry::superfn() const
{
  return _raw & Superfn;
}



inline Ptab*
Pd_entry::ptab() const
{
  return reinterpret_cast<Ptab*>(Mem_layout::phys_to_pmem(ptabfn()));
}



inline Unsigned32
Pd_entry::raw() const
{
  return _raw;
}



inline Unsigned32
Pd_entry::raw() const volatile
{
  return _raw;
}



inline Unsigned32&
Pd_entry::raw()
{
  return _raw;
}



inline void
Pd_entry::add_attr(Unsigned32 attr)
{
  _raw |= attr;
}



inline void
Pd_entry::del_attr(Unsigned32 attr)
{
  _raw &= ~attr;
}



inline Pd_entry const&
Pd_entry::operator = (Pd_entry const& other)
{
  _raw = other.raw();
  return *this;
}



inline Pd_entry const&
Pd_entry::operator = (Unsigned32 raw)
{
  _raw = raw;
  return *this;
}



inline void
Pd_entry::enable_global()
{
  _cpu_global |= Pd_entry::Cpu_global;
}


inline Unsigned32
Pd_entry::global()
{
  return _cpu_global;
}



//---------------------------------------------------------------------------

inline Pt_entry const&
Pt_entry::operator = (Pt_entry const &other)
{
  _raw = other.raw();
  return *this;
}



inline Pt_entry const&
Pt_entry::operator = (Unsigned32 raw)
{
  _raw = raw;
  return *this;
}



inline Unsigned32
Pt_entry::raw() const
{
  return _raw;
}



inline Unsigned32&
Pt_entry::raw()
{
  return _raw;
}



inline void
Pt_entry::add_attr(Unsigned32 attr)
{
  _raw |= attr;
}



inline void
Pt_entry::del_attr(Unsigned32 attr)
{
  _raw &= ~attr;
}



inline int
Pt_entry::valid() const
{
  return _raw & Valid;
}



inline int
Pt_entry::writable() const
{
  return _raw & Writable;
}



inline Address
Pt_entry::pfn() const
{
  return _raw & Pfn;
}



inline Unsigned32
Pt_entry::global()
{
  return Pd_entry::global();
}



inline unsigned
Pdir::virt_to_idx(Address virt)
{
  return (virt >> Pd_entry::Shift) & Pd_entry::Mask;
}



inline Pd_entry*
Pdir::lookup(Address virt)
{
  return _entries + virt_to_idx(virt);
}



inline Pd_entry
Pdir::entry(Address virt) const
{
  return _entries[virt_to_idx(virt)];
}



inline const Pd_entry*
Pdir::index(unsigned idx) const
{
  assert(idx < 1024);
  return _entries + idx;
}



inline Pd_entry*
Pdir::index(unsigned idx)
{
  assert(idx < 1024);
  return _entries + idx;
}



inline Unsigned32&
Pdir::operator[](unsigned idx)
{
  assert(idx < 1024);
  return _entries[idx].raw();
}



inline Unsigned32
Pdir::operator[](unsigned idx) const
{
  assert(idx < 1024);
  return _entries[idx].raw();
}



inline void
Pdir::clear()
{
  memset(_entries, 0, Config::PAGE_SIZE);
}



inline void
Pdir::have_superpages(bool yes)
{
  _have_superpages = yes;
}



//---------------------------------------------------------------------------

inline unsigned
Ptab::virt_to_idx(Address virt)
{
  return (virt >> Pt_entry::Shift) & Pt_entry::Mask;
}



inline Pt_entry*
Ptab::lookup(Address virt)
{
  return _entries + virt_to_idx(virt);
}



inline Pt_entry
Ptab::entry(Address virt) const
{
  return _entries[virt_to_idx(virt)];
}



inline Pt_entry*
Ptab::index(unsigned idx)
{
  assert(idx < 1024);
  return _entries + idx;
}



inline Unsigned32&
Ptab::operator[](unsigned idx)
{
  assert(idx < 1024);
  return _entries[idx].raw();
}



inline Unsigned32
Ptab::operator[](unsigned idx) const
{
  assert(idx < 1024);
  return _entries[idx].raw();
}



inline void
Ptab::clear()
{
  memset(_entries, 0, Config::PAGE_SIZE);
}

#endif // paging_h

---