pagetable.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004 Bregmasoft
 * 
 * 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.
 * 
 * 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
 */
#ifndef ZYGOMA_H_ 
#define ZYGOMA_H_ 

#include <memory.h>

namespace Zygoma
{
  namespace ia32
  {
    class PageBaseEntry
    {
    public:
      enum Protection
      {
        kREAD_ONLY = 0,
        kREAD_WRITE = 1
      };

      enum Privilege
      {
        kSUPERVISOR_PRIVILEGE = 0,
        kUSER_PRIVILEGE = 1
      };

      static u32
      addressToBase(void* address)
      {
        return (reinterpret_cast<u32>(address) >> 12) & 0x000fffff;
      }

    public:
      PageBaseEntry(void* baseAddress, Protection protection, Privilege privilege)
      : m_baseAddress(addressToBase(baseAddress))
      , m_avail(0)
      , m_isGlobal(0)
      , m_pageSize(0)
      , m_isDirty(0)
      , m_wasAccessed(0)
      , m_cacheDisabled(0)
      , m_writeThrough(0)
      , m_userMode(privilege)
      , m_readWrite(protection)
      , m_isPresent(0)
      { }

      u32
      baseAddress() const
      { return m_baseAddress << 12; }

      void
      setBaseAddress(void* baseAddress) 
      { m_baseAddress  = addressToBase(baseAddress); }

      void
      setIsPresent(bool isPresent)
      { m_isPresent = isPresent; }

      void
      setProtection(Protection protection)
      { m_readWrite = protection; }

      void
      setPrivilege(Privilege privilege)
      { m_userMode = privilege; }

      bool
      wasAccessed() const
      { return m_wasAccessed; }

    protected:
      u32 m_baseAddress: 20;
      u32 m_avail: 3;
      u32 m_isGlobal: 1;
      u32 m_pageSize: 1;
      u32 m_isDirty: 1;
      u32 m_wasAccessed: 1;
      u32 m_cacheDisabled: 1;
      u32 m_writeThrough: 1;
      u32 m_userMode: 1;
      u32 m_readWrite: 1;
      u32 m_isPresent: 1;
    };

    class PageDirectoryEntry
    : public PageBaseEntry
    {
    public:
      PageDirectoryEntry(void* baseAddress = 0,
                         Protection protection = kREAD_WRITE,
                         Privilege privilege = kSUPERVISOR_PRIVILEGE)
      : PageBaseEntry(baseAddress, protection, privilege)
      { }
    };

    class PageTableEntry
    : public PageBaseEntry
    {
    public:
      PageTableEntry(void* baseAddress = 0,
                     Protection protection = kREAD_WRITE,
                     Privilege privilege = kSUPERVISOR_PRIVILEGE)
      : PageBaseEntry(baseAddress, protection, privilege)
      { }

      bool
      isDirty() const
      { return m_isDirty; }

    };

    class PageDirectory
    {
    public:
      static int
      findTable(void* address)
      { return (reinterpret_cast<int>(address) >> 22) & 0x3ff; }

      PageDirectoryEntry&
      at(int index)
      { return m_entry[index]; }

      PageDirectoryEntry&
      operator[](int index)
      { return this->at(index); }

    private:
      PageDirectoryEntry m_entry[1024];
    };

    class PageTable
    {
    public:
      static int
      pageSize() 
      { return 4096; }

      static int
      findPage(void* address)
      { return (reinterpret_cast<int>(address) >> 12) & 0x3ff; }

      PageTableEntry&
      at(int index)
      { return m_entry[index]; }

      PageTableEntry&
      operator[](int index)
      { return this->at(index); }

    private:
      PageTableEntry m_entry[1024];
    };
  } // namespace ia32
} // namespace Zygoma

#endif // ZYGOMA_H_ 

---