idt.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2003 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_IA32_IDT_H_ 
#define ZYGOMA_IA32_IDT_H_ 

#include <config.h>
#include <iosfwd>
#include <list>
#include <types.h>
#include <vector>

namespace Zygoma
{
  namespace ia32
  {
    enum Faults
    {
      kFAULT_DIVIDE_ERROR = 0,    
      kFAULT_RESERVED_1 = 1,      
      kFAULT_NMI = 2,             
      kFAULT_BREAKPOINT = 3,      
      kFAULT_OVERFLOW = 4,        
      kFAULT_BOUND_EXCEEDED = 5,  
      kFAULT_INVALID_OPCODE = 6,  
      kFAULT_DEVICE_NOT_AVAILABLE,
      kFAULT_DOUBLE_FAULT = 8,    
      kFAULT_SEGMENT_OVERRUN = 9, 
      kFAULT_INVALID_TSS = 10,    
      kFAULT_SEGMENT_NOT_PRESENT, 
      kFAULT_STACK_SEGMENT_FAULT, 
      kFAULT_GENERAL_PROTECTION,  
      kFAULT_PAGE_FAULT = 14,     
      kFAULT_RESERVED_15,
      kFAULT_FPU_ERROR = 16,      
      kFAULT_ALIGNMENT_CHECK,     
      kFAULT_MACHINE_CHECK = 18,  
      kFAULT_SIMD_EXCEPTION = 19, 
      kFAULT_RESERVED_20
    };


    class InterruptGate
    {
    public:
      InterruptGate(u16 segment = 0,
                    u32 offset = 0,
                    u08 privilegeLevel = 0,
                    bool isTrap = false);

      std::ostream& printStream(std::ostream& ostr) const;

    private:
      u16 m_offset00_15;      
      u16 m_segment;
      u08 m_unused2;
      u08 m_type:3;               /* 6 (INT) or 7 (TRAP) */
      u08 m_size:1;               /* 0 */
      u08 m_isSystemDescriptor:1; /* 0 (16-bit) or 1 (32-bit) */
      u08 m_privilegeLevel:2;
      u08 m_segmentIsPresent:1;   /* 0 (not present) or 1 (present) */
      u16 m_offset16_31;
    } ZYGOMA_PACKED;


    inline std::ostream&
    operator<<(std::ostream& ostr, const InterruptGate& gate)
    {
      return gate.printStream(ostr);
    }


    typedef bool (*InterruptHandlerTrampoline)(int interruptNumber);


    class IDT
    {
      typedef std::list<InterruptHandlerTrampoline> InterruptHandlerChain;
      typedef std::vector<InterruptHandlerChain>    InterruptHandlerDispatchTable;
      typedef std::vector<InterruptGate>            InternalIdt;

    public:
      typedef InterruptGate               value_type;
      typedef InterruptGate&              reference;
      typedef const InterruptGate&        const_reference;
      typedef InternalIdt::iterator       iterator;
      typedef InternalIdt::const_iterator const_iterator;
      typedef std::ptrdiff_t              difference_type;
      typedef std::size_t                 size_type;

    public:
      IDT(int size);

      /* @{ */

      size_type
      size() const
      { return m_idt.size(); }

      bool
      empty() const
      { return m_idt.empty(); }

      /* @} */

      /* @{ */

      iterator
      begin()
      {
        return m_idt.begin();
      }

      const_iterator
      begin() const
      {
        return m_idt.begin();
      }

      iterator
      end()
      {
        return m_idt.end();
      }

      const_iterator
      end() const
      {
        return m_idt.end();
      }

      /* @} */

      void
      insert(unsigned int irq, const InterruptGate&);

      void
      dispatchInterrupt(int interruptNumber);

      void
      disableInterrupts();

      void
      enableInterrupts();

      std::ostream& printStream(std::ostream& ostr) const;

    private:
      IDT(const IDT&);              // not defined
      IDT& operator=(const IDT&);   // not defined

    private:
      InternalIdt                   m_idt;
      InterruptHandlerDispatchTable m_interruptHandlerDispatchTable;
    };


    inline std::ostream&
    operator<<(std::ostream& ostr, const IDT& idt)
    {
      return idt.printStream(ostr);
    }

    extern IDT* gIDT;
  } // namespace ia32
} // namespace Zygoma

#endif // ZYGOMA_IA32_IDT_H_ 

---