kernel/fiasco/src/kern/ia32/kip_init-ia32.cpp

   1 INTERFACE [ia32,ux,amd64]:
   2
   3 #include "initcalls.h"
   4 #include "types.h"
   5 #include "kip.h"
   6
   7 class Cpu;
   8
   9
  10 class Kip_init
  11 {
  12 public:
  13   /**
  14    * Insert memory descriptor for the Kmem region and finish the memory
  15    * info field.
  16    * @post no more memory descriptors may be added
  17    */
  18   static void setup_kmem_region (Address kmem_base, Address kmem_size);
  19 };
  20
  21 IMPLEMENTATION [!ux]:
  22
  23 PRIVATE static inline
  24 void
  25 Kip_init::setup_ux(Kip *)
  26 {}
  27
  28 IMPLEMENTATION [ia32,ux,amd64]:
  29
  30 #include <cstring>
  31 #include "boot_info.h"
  32 #include "config.h"
  33 #include "cpu.h"
  34 #include "div32.h"
  35 #include "kmem.h"
  36 #include "panic.h"
  37
  38
  39 /** KIP initialization. */
  40 PUBLIC static FIASCO_INIT
  41 void
  42 Kip_init::init_freq(Cpu const &cpu)
  43 {
  44   Kip::k()->frequency_cpu       = div32(cpu.frequency(), 1000);
  45 }
  46
  47
  48 namespace KIP_namespace
  49 {
  50   enum
  51   {
  52     Num_mem_descs = 50,
  53     Max_len_version = 512,
  54
  55     Size_mem_descs = sizeof(Mword) * 2 * Num_mem_descs,
  56   };
  57
  58   struct KIP
  59   {
  60     Kip kip;
  61     char mem_descs[Size_mem_descs];
  62   };
  63
  64   KIP my_kernel_info_page asm("my_kernel_info_page") __attribute__((section(".kernel_info_page"))) =
  65     {
  66       {
  67         /* 00/00  */ L4_KERNEL_INFO_MAGIC,
  68                      Config::Kernel_version_id,
  69                      (Size_mem_descs + sizeof(Kip)) >> 4,
  70                      {}, 0, {},
  71         /* 10/20  */ 0, {},
  72         /* 20/40  */ 0, 0, {},
  73         /* 30/60  */ 0, 0, {},
  74         /* 40/80  */ 0, 0, {},
  75         /* 50/A0  */ 0, (sizeof(Kip) << (sizeof(Mword)*4)) | Num_mem_descs, {},
  76         /* 60/C0  */ {},
  77         /* A0/140 */ 0, 0, 0, 0,
  78         /* B0/160 */ {},
  79         /* E0/1C0 */ 0, 0, {},
  80         /* F0/1D0 */ {"", 0}, {},
  81       },
  82       {}
  83     };
  84 };
  85
  86 PUBLIC static FIASCO_INIT
  87 //IMPLEMENT
  88 void Kip_init::init()
  89 {
  90   Kip *kinfo = reinterpret_cast<Kip*>(&KIP_namespace::my_kernel_info_page);
  91   setup_ux(kinfo);
  92
  93   Kip::init_global_kip(kinfo);
  94
  95   Kip::k()->clock = 0;
  96   Kip::k()->sched_granularity = Config::Scheduler_granularity;
  97
  98   setup_user_virtual(kinfo);
  99
 100   reserve_amd64_hole();
 101
 102
 103   Mem_desc *md = kinfo->mem_descs();
 104   Mem_desc *end = md + kinfo->num_mem_descs();
 105
 106   extern char _boot_sys_start[];
 107   extern char _boot_sys_end[];
 108
 109   for (;md != end; ++md)
 110     {
 111       if (md->type() != Mem_desc::Reserved || md->is_virtual())
 112         continue;
 113
 114       if (md->start() == (Address)_boot_sys_start
 115           && md->end() == (Address)_boot_sys_end - 1)
 116         md->type(Mem_desc::Undefined);
 117
 118       if (md->contains(Kmem::kernel_image_start())
 119           && md->contains(Kmem::kcode_end()-1))
 120         {
 121           *md = Mem_desc(Kmem::kernel_image_start(), Kmem::kcode_end() -1,
 122               Mem_desc::Reserved);
 123         }
 124     }
 125 }
 126
 127
 128 IMPLEMENTATION [amd64]:
 129
 130 PRIVATE static inline NOEXPORT NEEDS["kip.h"]
 131 void
 132 Kip_init::reserve_amd64_hole()
 133 {
 134   enum { Trigger = 0x0000800000000000UL };
 135   Kip::k()->add_mem_region(Mem_desc(Trigger, ~Trigger,
 136                            Mem_desc::Reserved, true));
 137 }
 138
 139 IMPLEMENTATION [!amd64]:
 140
 141 PRIVATE static inline NOEXPORT
 142 void
 143 Kip_init::reserve_amd64_hole()
 144 {}
 145
 146 IMPLEMENTATION [!ux]:
 147
 148 PUBLIC static FIASCO_INIT
 149 void
 150 Kip_init::setup_user_virtual(Kip *kinfo)
 151 {
 152   kinfo->add_mem_region(Mem_desc(0, Mem_layout::User_max,
 153                         Mem_desc::Conventional, true));
 154 }