space.h

Go to the documentation of this file.

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

#ifndef space_h
#define space_h

#include "space_index.h"

#include "paging.h"             // for page attributes

//
// INTERFACE definition follows 
//


class Space
{
public:
  enum Status {
    Insert_ok = 0,              
    Insert_warn_exists,         
    Insert_warn_attrib_upgrade, 
    Insert_err_nomem,           
    Insert_err_exists           
  };

  enum Page_attrib 
    {
      Page_no_attribs = 0,
      Page_writable = Pt_entry::Writable, 
      Page_noncacheable = Pt_entry::Noncacheable | Pt_entry::Write_through, 
      Page_user_accessible = Pt_entry::User,
      Page_all_attribs = Page_writable | Page_noncacheable |
                         Page_user_accessible,
    };

  bool is_privileged (void);

  static Space *id_lookup(Task_num id);

public:
  static Space *current();
  void          make_current();
  void          switchin_context();

protected:
  void switchin_lipc_kip_pointer();

  // DATA (be careful here!):  just a page directory
  Pdir                    _dir;
private:

private:
  Space();                      // default constructors are undefined
  Space(const Space&);
private:

public:
  template < typename T >
  T peek (T const *addr, bool user_space);

  template < typename T >
  T peek_user (T const *addr);

  template < typename T >
  void poke_user (T *addr, T value);

  template < typename T >
  void copy_from_user (T *kdst, T const *usrc, size_t n);

  template < typename T >
  void copy_to_user (T *udst, T const *ksrc, size_t n);
private:

public:

  void  page_map        (Address phys, Address virt,
                         Address size, unsigned page_attribs);

  void  page_unmap      (Address virt, Address size);

  void  page_protect    (Address virt, Address size,
                         unsigned page_attribs);

  Address kip_address() const;

  void kmem_update (void *addr);

  void remote_update (const Address, const Space *,
                      const Address, size_t);

  void update_small (Address virt, bool flush);

  bool is_mappable (Address addr, size_t size);

private:
  void remove_from_space_index();
private:

private:
  void switch_ldt();

public:  
  // state requests/manipulation
  inline int mapped(Address addr, int need_writable) const;
  
  inline Address virt_to_phys(Address virt) const;
  
  inline const Pdir* dir() const;
  
  inline Space_index id() const;
  
  inline Space_index chief() const;
  
  // allocator and deallocator
  void * operator new (size_t size);
  
  void operator delete (void *block);
  
  // routines
  
  inline Address virt_to_phys_s0(void *a) const; // pgtble lookup
  
  inline bool is_sigma0(void) const;
  
  inline unsigned get_io_counter(void);
  
  inline bool io_lookup(Address);
  
  ~Space();
  
  Space::Status v_insert(Address phys, Address virt, size_t size, unsigned page_attribs);
  
  bool v_lookup(Address virt, Address *phys = 0, Address *size = 0, unsigned *page_attribs = 0);
  
  bool v_delete(Address virt, Address size, unsigned page_attribs = 0);
  
  inline void ldt_addr(void *addr);
  
  inline Address ldt_addr() const;
  
  inline void ldt_size(Mword size);
  
  inline Mword ldt_size() const;

protected:  
  Space(unsigned number);

private:  
  inline void free_ldt_memory();
};

inline Space * current_space();

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

#include "globals.h"

#include <cassert>
#include "l4_types.h"
#include "mem_unit.h"
#include "paging.h"
#include "config.h"

#include "cpu.h"
#include "kmem.h"
#include "logdefs.h"

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



// state requests/manipulation

inline int
Space::mapped(Address addr, int need_writable) const
{
  Pd_entry p = _dir.entry(addr);

  if (!p.valid())
    return 0;

  if (p.superpage())
    return !need_writable || p.writable();

  Pt_entry e = *(p.ptab()->lookup(addr));

  return e.valid() && (!need_writable || e.writable());
}


inline Address
Space::virt_to_phys(Address virt) const
{
  return dir()->virt_to_phys(virt);
}



inline const Pdir*
Space::dir() const
{
  return &_dir;
}


inline Space_index
Space::id() const
{
  return Space_index (_dir.entry(Mem_layout::Space_index).raw() >> 8);
}


inline Space_index 
Space::chief() const
{
  return Space_index (_dir.entry(Mem_layout::Chief_index).raw() >> 8);
}


// routines

inline Address
Space::virt_to_phys_s0(void *a) const // pgtble lookup
{
  if (is_sigma0())              // sigma0 doesn't have mapped everything
    return (Address)a;

  return dir()->virt_to_phys((Address)a);
}


inline bool Space::is_sigma0(void) const
{
  return this == sigma0_space;
}



inline unsigned
Space::get_io_counter(void)
{ return 0; }



inline bool
Space::io_lookup(Address)
{ return false; }



inline void
Space::ldt_addr(void *addr)
{
  Pd_entry *p = _dir.lookup(Mem_layout::Ldt_addr);
  assert(!p->valid());
  assert(!((Address)addr & 1));

  *p = (Address)addr & ~1;
}



inline Address
Space::ldt_addr() const
{
  Pd_entry p = _dir.entry(Mem_layout::Ldt_addr);
  assert(!p.valid());

  return p.raw();
}



inline void
Space::ldt_size(Mword size)
{
  Pd_entry *p = _dir.lookup(Mem_layout::Ldt_size);
  assert(!p->valid());
  assert(!(size & 1));

  *p = size & ~1;
}



inline Mword
Space::ldt_size() const
{
  Pd_entry p = _dir.entry(Mem_layout::Ldt_size);
  assert(!p.valid());

  return p.raw();
}



inline void
Space::switchin_lipc_kip_pointer()
{}



inline Space *
Space::id_lookup(Task_num id)
{
  return Space_index (id).lookup();
}



inline bool Space::is_privileged(void) 
{
  // A task is privileged if it has all the IO ports mapped.
  return (!Config::enable_io_protection 
          || (get_io_counter() == L4_fpage::Io_port_max));
}



template < typename T > inline T
Space::peek(T const *addr, bool user_space)
{
  // this == current_space() does not apply for SMAS
  return user_space ? peek_user (addr) : *addr;
}



template < typename T > inline T
Space::peek_user(T const *addr)
{
  assert (this == current_space());
  return *addr;
}



template < typename T > inline void
Space::poke_user(T *addr, T value)
{
  assert (this == current_space());
  *addr = value;
}



template < typename T > inline void
Space::copy_from_user(T *kdst, T const *usrc, size_t n)
{
  assert (this == current_space());
  Cpu::memcpy_bytes (kdst, usrc, n * sizeof (T));
}



template <> inline void
Space::copy_from_user <Mword>(Mword *kdst, Mword const *usrc, size_t n)
{
  assert (this == current_space());
  Cpu::memcpy_mwords (kdst, usrc, n);
}



template < typename T > inline void
Space::copy_to_user(T *udst, T const *ksrc, size_t n)
{
  assert (this == current_space());
  Cpu::memcpy_bytes (udst, ksrc, n * sizeof (T));
}



template <> inline void
Space::copy_to_user <Mword>(Mword *udst, Mword const *ksrc, size_t n)
{
  assert (this == current_space());
  Cpu::memcpy_mwords (udst, ksrc, n);
}



inline Address
Space::kip_address() const
{
  return (is_sigma0()
          ? Kmem::virt_to_phys (Kip::k())
          : (Address)Mem_layout::Kip_auto_map);
}



inline void
Space::remove_from_space_index()
{
  Space_index::del (id(), chief());
}



inline bool
Space::is_mappable(Address, size_t)
{
  return true;
}



inline Space *
Space::current()
{
  return reinterpret_cast<Space*>(Kmem::phys_to_virt(Cpu::get_pdbr()));
}



inline void
Space::make_current()
{
  Cpu::set_pdbr((Mem_layout::pmem_to_phys(this)));
}



inline void
Space::switchin_context()
{
  // never switch to kernel space (context of the idle thread)
  if (this == (Space*)Kmem::dir())
    return;

  bool need_flush_tlb = false;
  unsigned index      = Pdir::virt_to_idx(Kmem::ipc_window(0));

  if (_dir[index] || _dir[index + 1])
    {
      _dir[index]     = 0;
      _dir[index + 1] = 0;
      need_flush_tlb  = true;
    }

  index = Pdir::virt_to_idx(Kmem::ipc_window(1));

  if (_dir[index] || _dir[index + 1])
    {
      _dir[index]     = 0;
      _dir[index + 1] = 0;
      need_flush_tlb  = true;
    }

  if (need_flush_tlb || this != Space::current())
    {
      switchin_lipc_kip_pointer();
      CNT_ADDR_SPACE_SWITCH;
      make_current();
      switch_ldt();
    }
}



inline void
Space::switch_ldt()
{
}


/*
 * The following functions are all no-ops on native ia32.
 * Pages appear in an address space when the corresponding PTE is made
 * ... unlike Fiasco-UX which needs these special tricks
 */

inline void
Space::page_map(Address, Address, Address, unsigned)
{}



inline void
Space::page_protect(Address, Address, unsigned)
{}



inline void
Space::page_unmap(Address, Address)
{}



inline void Space::kmem_update(void *addr)
{
  unsigned i = Pdir::virt_to_idx((Address)addr);

  _dir[i] = (*Kmem::dir())[i];
}


inline void
Space::remote_update(const Address loc_addr, const Space *rem,
                      const Address rem_addr, size_t n)
{
  bool tlb_flush    = false;
  unsigned loc_slot = Pdir::virt_to_idx(loc_addr),
           rem_slot = Pdir::virt_to_idx(rem_addr);

  // PDE boundary check
  assert (loc_slot + n <= 1024);
  assert (rem_slot + n <= 1024);

  while (n--)
    {
      if (_dir[loc_slot])
        tlb_flush = true;

      // XXX: If we copy a PDE and it maps either a superpage with PDE_GLOBAL
      // or a pagetable with one or multiple PTE_GLOBAL entries, these won't
      // be flushed on a TLB flush. Suggested solution: When mapping a page
      // with global bit, a PDE_NO_LONGIPC bit should be set in the
      // corresponding PDE and this bit should be checked here before copying.

      // This loop seems unnecessary, but remote_update is also used for
      // updating the long IPC window.
      // Now consider following scenario with super pages:
      // Sender A makes long IPC to receiver B.
      // A setups the IPC window by reading the pagedir slot from B in an 
      // temporary register. Now the sender is preempted by C. Then C unmaps 
      // the corresponding super page from B. C switch to A back, using 
      // switch_to, which clears the IPC window pde slots from A. BUT then A 
      // write the  content of the temporary register, which contain the now 
      // invalid pde slot, in his own page directory and starts the long IPC.
      // Because no pagefault will happen, A will write to now invalid memory.
      // So we compare after storing the pde slot, if the copy is still
      // valid. And this solution is much faster than grabbing the cpu lock,
      // when updating the ipc window.
      for(;;) {

        const volatile Pd_entry *val = rem->dir()->index(rem_slot);
        _dir[loc_slot] =  val->raw();

        if(EXPECT_TRUE(_dir[loc_slot] == val->raw()))
          break;
      }

      loc_slot++;
      rem_slot++;

    }

  if (tlb_flush)
    Mem_unit::tlb_flush();
}



inline void
Space::update_small(Address, bool)
{}



inline Space *
current_space()
{  
  return Space::current();
}

#endif // space_h

---