mem_layout.h

Go to the documentation of this file.

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

#ifndef mem_layout_h
#define mem_layout_h

#include "types.h"

#include "types.h"

//
// INTERFACE definition follows 
//


class Mem_layout
{
public:
  static const char load            asm ("_load");
  static const char start           asm ("_start");
  static const char end             asm ("_end");
  static const char ecode           asm ("_ecode");
  static const char etext           asm ("_etext");
  static const char edata           asm ("_edata");
  static const char initcall_start  asm ("_initcall_start");
  static const char initcall_end    asm ("_initcall_end");

  static Mword in_tcbs (Address a);
  static Mword in_kernel (Address a);
private:

public:
  enum
  {
    V2_utcb_addr      = 0xbff00000,    
    Kip_auto_map      = 0xbfff2000,    
    User_max          = 0xc0000000,
    Vmem_start        = User_max,
    Tcbs              = 0xc0000000,    
    Tcbs_end          = 0xe0000000,    
    Slabs_start       = 0xe0000000,    
    Slabs_end         = 0xea000000,    
    Space_index       = 0xea000000,    
    Chief_index       = 0xea400000,    
    Kip_index         = 0xea800000,    
    Service_page      = 0xeac00000,    
    Local_apic_page   = Service_page + 0x0000,   
    Jdb_adapter_page  = Service_page + 0x1000,   
    Tbuf_status_page  = Service_page + 0x2000,   
    Smas_trampoline   = Service_page + 0x3000,   
    Jdb_bench_page    = Service_page + 0x4000,   
    Utcb_ptr_page     = Service_page + 0xfd000,  
    Idt               = Service_page + 0xfe000,  
    Syscalls          = Service_page + 0xff000,  
    Tbuf_buffer_area  = Service_page + 0x200000, 
    Ldt_addr          = 0xeb000000,    
    Ldt_size          = 0xeb400000,    
    // 0xeb800000-0xec000000 (8MB) free
    Smas_version      = 0xec000000,    
    Smas_area         = 0xec400000,    
    Smas_io_bmap_bak  = 0xec800000,    
    Smas_io_cnt_bak   = 0xec880000,    
    Jdb_debug_start   = 0xecc00000,    
    Jdb_debug_end     = 0xee000000,    
    Ipc_window0       = 0xee000000,    
    Ipc_window1       = 0xee800000,    
    // 0xef000000-0xef800000 (8MB) free
    Kstatic           = 0xef800000,    
    Io_bitmap         = 0xefc00000,    
    Io_counter        = 0xefc80000,    
    Vmem_end          = 0xf0000000,
    Kernel_image      = Vmem_end,
    Boot_state_start  = Kernel_image,
    Boot_state_end    = Kernel_image + 0x400000,
    Smas_start        = 0xf0400000,    
    Smas_end          = 0xfc400000,    
    Physmem           = 0xfc400000,    
  };

  template < typename T > static T* boot_data (T const *addr);

private:
  static Address physmem_offs asm ("PHYSMEM_OFFS");

public:  
  static inline Mword in_kernel_code(Address a);
  
  static inline void kphys_base(Address base);
  
  static inline Address pmem_to_phys(Address addr);
  
  static inline Address pmem_to_phys(const void *ptr);
  
  static inline Address phys_to_pmem(Address addr);
  
  static inline Mword in_boot_state(Address addr);
  
  static inline Mword in_pmem(Address addr);
};

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


#include <cassert>

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




inline Mword
Mem_layout::in_kernel_code(Address a)
{
  return a >= (Address)&start && a < (Address)&ecode;
}



inline void
Mem_layout::kphys_base(Address base)
{
  physmem_offs = (Address)Physmem - base;
}



inline Address
Mem_layout::pmem_to_phys(Address addr)
{
  assert (in_pmem(addr));
  return addr - physmem_offs;
}



inline Address
Mem_layout::pmem_to_phys(const void *ptr)
{
  Address addr = reinterpret_cast<Address>(ptr);

  assert (in_pmem(addr));
  return addr - physmem_offs;
}



inline Address
Mem_layout::phys_to_pmem(Address addr)
{
  return addr + physmem_offs;
}



inline Mword
Mem_layout::in_boot_state(Address addr)
{
  return addr >= Boot_state_start && addr < Boot_state_end;
}



inline Mword
Mem_layout::in_pmem(Address addr)
{
  return addr >= Physmem;
}



inline Mword
Mem_layout::in_tcbs(Address a)
{
  return a >= Tcbs && a < Tcbs_end;
}



inline Mword
Mem_layout::in_kernel(Address a)
{
  return a >= User_max;
}



 template < typename T > inline T*
Mem_layout::boot_data(T const *addr)
{
  // boot data are located in the first 4MB page
  assert ((Address)addr < 4<<20);
  return (T*) ((Address)addr + Boot_state_start);
}

#endif // mem_layout_h

---