x86desc.h

Go to the documentation of this file.

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

#ifndef x86desc_h
#define x86desc_h

#include "l4_types.h"

//
// INTERFACE definition follows 
//


class X86desc
{
public:
  enum
    {
      Accessed            = 0x01,
      Access_kernel       = 0x00,
      Access_user         = 0x60,
      Access_present      = 0x80,

      Access_tss          = 0x09,
      Access_intr_gate    = 0x0e,
      Access_trap_gate    = 0x0f,
    };

protected:
  // interrupt gate / trap gate
  struct Idt_entry_desc
    {
      Unsigned16   _offset_low;
      Unsigned16   _selector    __attribute__((packed));
      Unsigned8    _zero        __attribute__((packed));
      Unsigned8    _access      __attribute__((packed));
      Unsigned16   _offset_high __attribute__((packed));
    };

  // segment descriptor
  struct Gdt_entry_desc
    {
      Unsigned16   _limit_low;
      Unsigned16   _base_low   __attribute__((packed));
      Unsigned8    _base_med   __attribute__((packed));
      Unsigned8    _access     __attribute__((packed));
      Unsigned8    _limit_high __attribute__((packed));
      Unsigned8    _base_high  __attribute__((packed));
    };

  struct Task_gate_desc
    {
      Unsigned16   _avail1;
      Unsigned16   _selector   __attribute__((packed));
      Unsigned8    _avail2     __attribute__((packed));
      Unsigned8    _access     __attribute__((packed));
      Unsigned16   _avail3     __attribute__((packed));
    };

  // segment descriptor not present
  struct Not_present_desc
    {
      Unsigned32   _avail1;
      Unsigned8    _avail2     __attribute__((packed));
      Unsigned8    _access     __attribute__((packed));
      Unsigned16   _avail3     __attribute__((packed));
    };

  union
    {
      Idt_entry_desc   i;
      Gdt_entry_desc   g;
      Task_gate_desc   t;
      Not_present_desc n;
      Unsigned64       r;
    } _data;

public:  
  const char* type_str() const;
  
  void gdt_entry_show();
  
  void idt_entry_show();
  
  void task_gate_show();
  
  void show();
  
  inline Unsigned64 get_raw();
  
  inline void get_raw(Unsigned32 *low, Unsigned32 *high);
  
  inline void set_raw(Unsigned64 val);
  
  inline void set_raw(Unsigned32 low, Unsigned32 high);
  
  inline X86desc();
  
  inline X86desc(Unsigned64 val);
  
  inline Address gdt_entry_base();
  
  inline Unsigned32 gdt_entry_limit();
  
  inline Unsigned32 gdt_entry_size();
  
  inline Address idt_entry_offset();
  
  inline Unsigned8 access();
  
  inline int present();
  
  inline Unsigned8 type();
  
  inline Unsigned8 dpl();
  
  inline bool unsafe();
};

class Pseudo_descriptor
{
  Unsigned16 _limit;
  Unsigned32 _base  __attribute__((packed));
  Unsigned16 _pad   __attribute__((packed));

public:  
  inline Pseudo_descriptor();
  
  inline Pseudo_descriptor(Address base, Unsigned16 limit);
  
  inline Address base() const;
  
  inline Unsigned16 limit() const;
};

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




inline Unsigned64
X86desc::get_raw()
{
  return _data.r;
}



inline void
X86desc::get_raw(Unsigned32 *low, Unsigned32 *high)
{
  *low  = _data.r & 0xffffffff;
  *high = _data.r >> 32;
}



inline void
X86desc::set_raw(Unsigned64 val)
{
  _data.r = val;
}



inline void
X86desc::set_raw(Unsigned32 low, Unsigned32 high)
{
  _data.r = ((Unsigned64)high << 32 | low);
}



inline X86desc::X86desc()
{
}



inline X86desc::X86desc(Unsigned64 val)
{
  set_raw(val);
}



inline Address
X86desc::gdt_entry_base()
{
  return    (Address)_data.g._base_low 
         | ((Address)_data.g._base_med  << 16) 
         | ((Address)_data.g._base_high << 24);
}



inline Unsigned32
X86desc::gdt_entry_limit()
{
  return      (Unsigned32)_data.g._limit_low
          | (((Unsigned32)_data.g._limit_high & 0x0f) << 16);
}



inline Unsigned32
X86desc::gdt_entry_size()
{
  Address l = gdt_entry_limit();
  return _data.g._limit_high & 0x80 ? ((l+1) << 12)-1 : l;
}



inline Address
X86desc::idt_entry_offset()
{
  return    (Address)_data.i._offset_low
         | ((Address)_data.i._offset_high << 16);
}



inline Unsigned8
X86desc::access()
{
  return _data.n._access;
}



inline int
X86desc::present()
{
  return (access() & 0x80) >> 7;
}



inline Unsigned8
X86desc::type()
{
  return _data.n._access & 0x1f;
}



inline Unsigned8
X86desc::dpl()
{
  return (_data.n._access & 0x60) >> 5;
}



inline bool
X86desc::unsafe()
{
  return present() && (dpl() != 3);
}



inline Pseudo_descriptor::Pseudo_descriptor()
{}



inline Pseudo_descriptor::Pseudo_descriptor(Address base, Unsigned16 limit)
  : _limit(limit), _base(base)
{}



inline Address
Pseudo_descriptor::base() const
{
  return _base;
}



inline Unsigned16
Pseudo_descriptor::limit() const
{
  return _limit;
}

#endif // x86desc_h

---