kmem.h

Go to the documentation of this file.

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

#ifndef kmem_h
#define kmem_h

#include "initcalls.h"
#include "kern_types.h"
#include "kip.h"
#include "mem_layout.h"

//
// INTERFACE definition follows 
//


class Pdir;
class Tss;
// our own implementation of C++ memory management: disallow dynamic
// allocation (except where class-specific new/delete functions exist)
//
// more specialized memory allocation/deallocation functions follow
// below in the "Kmem" namespace


class Kmem
{
  friend class Jdb;
  friend class Jdb_dbinfo;
  friend class Jdb_kern_info_misc;
  friend class Kdb;
  friend class Profile;
  friend class Vmem_alloc;

private:
  Kmem();                       // default constructors are undefined
  Kmem (const Kmem&);
  static Address mem_max, _himem;

public:
  enum 
  {
    mem_tcbs     = Mem_layout::Tcbs,
    mem_user_max = Mem_layout::User_max,
  };

  static void init();
  static Mword is_kmem_page_fault(Mword pfa, Mword error);
  static Mword is_ipc_page_fault(Mword pfa, Mword error);
  static Mword is_smas_page_fault(Mword pfa);
  static Mword is_io_bitmap_page_fault(Mword pfa);
  static Address kcode_start();
  static Address kcode_end();
  static Address kmem_base();
  static Address virt_to_phys(const void *addr);
private:

protected:
  static Pdir *kdir asm ("KMEM_KDIR"); 

private:
  static Address user_max();
  static Unsigned8 *io_bitmap_delimiter;

public:  
  static inline Mword is_tcb_page_fault( Address addr, Mword /*error*/ );
  
  static inline const Pdir* dir();
  
  static inline Address get_mem_max();
  
  static inline Address himem();
  
  static inline Address volatile * kernel_esp();
  
  static inline void * phys_to_virt(Address addr);
  
  static void dir_init(Pdir *d);
  
  static inline Address ipc_window(unsigned win);
  
  static inline Address io_bitmap_delimiter_page();
  
  //
  // helper functions
  //
  
  // set a 4k-mapping, not-cached/write-through
  static void map_devpage_4k(Address phys, Address virt, bool cached, bool global, Address *offs=0);

private:  
  static inline Address alloc_from_page(Address *from, Address size);
  
  static FIASCO_INIT Address himem_alloc();
};

typedef Kmem Kmem_space;

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

#include "tss.h"
#include "cpu.h"
#include "paging.h"
#include "std_macros.h"

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




inline Mword
Kmem::is_tcb_page_fault( Address addr, Mword /*error*/ )
{
  return (   addr >= Mem_layout::Tcbs
          && addr <  Mem_layout::Tcbs
                     + (Config::thread_block_size 
                        * Config::max_threads()) );
}


inline const Pdir* Kmem::dir() { return kdir; }


inline Address Kmem::get_mem_max() { return mem_max; }

inline Address Kmem::himem() { return _himem; }


inline Address volatile *
Kmem::kernel_esp()
{
  return reinterpret_cast<Address volatile *>(&Cpu::get_tss()->esp0);
}


inline void *
Kmem::phys_to_virt(Address addr)
{
  return reinterpret_cast<void *>(Mem_layout::phys_to_pmem(addr));
}


inline Address 
Kmem::ipc_window(unsigned win)
{
  return win == 0 
    ? Mem_layout::Ipc_window0
    : Mem_layout::Ipc_window1;
}



inline Address
Kmem::io_bitmap_delimiter_page()
{
  return reinterpret_cast<Address>(io_bitmap_delimiter);
}



inline Mword
Kmem::is_io_bitmap_page_fault(Address addr)
{
  return (addr >= Mem_layout::Io_bitmap && 
          addr <= Mem_layout::Io_bitmap + L4_fpage::Io_port_max / 8);
}



inline Mword
Kmem::is_smas_page_fault(Address addr)
{
  return (addr >= Mem_layout::Smas_start && addr < Mem_layout::Smas_end);
}



inline Mword
Kmem::is_ipc_page_fault(Address addr, Mword /*error*/)
{
  return (addr >= ipc_window(0) && addr < ipc_window(1) +
          (Config::SUPERPAGE_SIZE << 1));
}



inline Mword
Kmem::is_kmem_page_fault(Address addr, Mword /*error*/)
{
  return (addr >= mem_user_max);
}


inline Address
Kmem::virt_to_phys(const void *addr)
{
  Address a = reinterpret_cast<Address>(addr);

  if (EXPECT_TRUE (Mem_layout::in_pmem(a)))
    return Mem_layout::pmem_to_phys(a);

  if (EXPECT_TRUE (Mem_layout::in_boot_state(a)))
    return a - Mem_layout::Boot_state_start;

  return kdir->virt_to_phys(a);
}


inline Address Kmem::kcode_start()
{ return virt_to_phys (&Mem_layout::start) & Config::PAGE_MASK; }


inline Address Kmem::kcode_end()
{
  return (virt_to_phys (&Mem_layout::end) + Config::PAGE_SIZE)
    & Config::PAGE_MASK;
}


inline Address Kmem::user_max() { return (Address) -1; }

#endif // kmem_h

---