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 "config.h"
  32 #include "cpu.h"
  33 #include "div32.h"
  34 #include "kmem.h"
  35 #include "panic.h"
  36
  37
  38 /** KIP initialization. */
  39 PUBLIC static FIASCO_INIT
  40 void
  41 Kip_init::init_freq(Cpu const &cpu)
  42 {
  43   Kip::k()->frequency_cpu       = div32(cpu.frequency(), 1000);
  44 }
  45
  46
  47 namespace KIP_namespace
  48 {
  49   enum
  50   {
  51     Num_mem_descs = 50,
  52     Max_len_version = 512,
  53
  54     Size_mem_descs = sizeof(Mword) * 2 * Num_mem_descs,
  55   };
  56
  57   struct KIP
  58   {
  59     Kip kip;
  60     char mem_descs[Size_mem_descs];
  61   };
  62
  63   KIP my_kernel_info_page asm("my_kernel_info_page") __attribute__((section(".kernel_info_page"))) =
  64     {
  65       {
  66         /* 00/00  */ L4_KERNEL_INFO_MAGIC,
  67                      Config::Kernel_version_id,
  68                      (Size_mem_descs + sizeof(Kip)) >> 4,
  69                      {}, 0, {},
  70         /* 10/20  */ 0, {},
  71         /* 20/40  */ 0, 0, {},
  72         /* 30/60  */ 0, 0, {},
  73         /* 40/80  */ 0, 0, {},
  74         /* 50/A0  */ 0, (sizeof(Kip) << (sizeof(Mword)*4)) | Num_mem_descs, {},
  75         /* 60/C0  */ {},
  76         /* A0/140 */ 0, 0, 0, 0,
  77         /* B0/160 */ {},
  78         /* E0/1C0 */ 0, 0, {},
  79         /* F0/1D0 */ {"", 0}, {},
  80       },
  81       {}
  82     };
  83 };
  84
  85 PUBLIC static FIASCO_INIT
  86 //IMPLEMENT
  87 void Kip_init::init()
  88 {
  89   Kip *kinfo = reinterpret_cast<Kip*>(&KIP_namespace::my_kernel_info_page);
  90   setup_ux(kinfo);
  91
  92   Kip::init_global_kip(kinfo);
  93
  94   Kip::k()->clock = 0;
  95   Kip::k()->sched_granularity = Config::Scheduler_granularity;
  96
  97   setup_user_virtual(kinfo);
  98
  99   reserve_amd64_hole();
 100
 101
 102   extern char _boot_sys_start[];
 103   extern char _boot_sys_end[];
 104
 105   for (auto &md: kinfo->mem_descs_a())
 106     {
 107       if (md.type() != Mem_desc::Reserved || md.is_virtual())
 108         continue;
 109
 110       if (md.start() == (Address)_boot_sys_start
 111           && md.end() == (Address)_boot_sys_end - 1)
 112         md.type(Mem_desc::Undefined);
 113
 114       if (md.contains(Kmem::kernel_image_start())
 115           && md.contains(Kmem::kcode_end()-1))
 116         {
 117           md = Mem_desc(Kmem::kernel_image_start(), Kmem::kcode_end() -1,
 118                         Mem_desc::Reserved);
 119         }
 120     }
 121 }
 122
 123
 124 IMPLEMENTATION [amd64]:
 125
 126 PRIVATE static inline NOEXPORT NEEDS["kip.h"]
 127 void
 128 Kip_init::reserve_amd64_hole()
 129 {
 130   enum { Trigger = 0x0000800000000000UL };
 131   Kip::k()->add_mem_region(Mem_desc(Trigger, ~Trigger,
 132                            Mem_desc::Reserved, true));
 133 }
 134
 135 IMPLEMENTATION [!amd64]:
 136
 137 PRIVATE static inline NOEXPORT
 138 void
 139 Kip_init::reserve_amd64_hole()
 140 {}
 141
 142 IMPLEMENTATION [!ux]:
 143
 144 PUBLIC static FIASCO_INIT
 145 void
 146 Kip_init::setup_user_virtual(Kip *kinfo)
 147 {
 148   kinfo->add_mem_region(Mem_desc(0, Mem_layout::User_max,
 149                         Mem_desc::Conventional, true));
 150 }