lunaix-os/arch/i386/boot/mb_parser.c

   1 #define __BOOT_CODE__
   2
   3 #include <lunaix/boot_generic.h>
   4 #include <sys/boot/bstage.h>
   5 #include <sys/boot/multiboot.h>
   6 #include <sys/mm/mempart.h>
   7
   8 #define BHCTX_ALLOC 4096
   9
  10 u8_t bhctx_buffer[BHCTX_ALLOC] boot_bss;
  11
  12 #define check_buffer(ptr)                                                      \
  13     if ((ptr) >= ((ptr_t)bhctx_buffer + BHCTX_ALLOC)) {                        \
  14         asm("ud2");                                                            \
  15     }
  16
  17 size_t boot_text
  18 mb_memcpy(u8_t* destination, u8_t* base, unsigned int size)
  19 {
  20     unsigned int i = 0;
  21     for (; i < size; i++) {
  22         *(destination + i) = *(base + i);
  23     }
  24     return i;
  25 }
  26
  27 size_t boot_text
  28 mb_strcpy(char* destination, char* base)
  29 {
  30     int i = 0;
  31     char c = 0;
  32     while ((c = base[i])) {
  33         destination[i] = c;
  34         i++;
  35     }
  36
  37     destination[++i] = 0;
  38
  39     return i;
  40 }
  41
  42 size_t boot_text
  43 mb_strlen(char* s)
  44 {
  45     int i = 0;
  46     while (s[i++])
  47         ;
  48     return i;
  49 }
  50
  51 size_t boot_text
  52 mb_parse_cmdline(struct boot_handoff* bhctx, void* buffer, char* cmdline)
  53 {
  54 #define SPACE ' '
  55
  56     size_t slen = mb_strlen(cmdline);
  57
  58     if (!slen) {
  59         return 0;
  60     }
  61
  62     mb_memcpy(buffer, (u8_t*)cmdline, slen);
  63     bhctx->kexec.len = slen;
  64
  65     return slen;
  66 }
  67
  68 size_t boot_text
  69 mb_parse_mmap(struct boot_handoff* bhctx,
  70               struct multiboot_info* mb,
  71               void* buffer)
  72 {
  73     struct multiboot_mmap_entry* mb_mmap =
  74       (struct multiboot_mmap_entry*)mb->mmap_addr;
  75     size_t mmap_len = mb->mmap_length / sizeof(struct multiboot_mmap_entry);
  76
  77     struct boot_mmapent* bmmap = (struct boot_mmapent*)buffer;
  78     for (size_t i = 0; i < mmap_len; i++) {
  79         struct boot_mmapent* bmmapent = &bmmap[i];
  80         struct multiboot_mmap_entry* mb_mapent = &mb_mmap[i];
  81
  82         if (mb_mapent->type == MULTIBOOT_MEMORY_AVAILABLE) {
  83             bmmapent->type = BOOT_MMAP_FREE;
  84         } else if (mb_mapent->type == MULTIBOOT_MEMORY_ACPI_RECLAIMABLE) {
  85             bmmapent->type = BOOT_MMAP_RCLM;
  86         } else {
  87             bmmapent->type = BOOT_MMAP_RSVD;
  88         }
  89
  90         bmmapent->start = mb_mapent->addr_low;
  91         bmmapent->size = mb_mapent->len_low;
  92     }
  93
  94     bhctx->mem.size = (mb->mem_upper << 10) + MEM_1M;
  95     bhctx->mem.mmap = bmmap;
  96     bhctx->mem.mmap_len = mmap_len;
  97
  98     return mmap_len * sizeof(struct boot_mmapent);
  99 }
 100
 101 size_t boot_text
 102 mb_parse_mods(struct boot_handoff* bhctx,
 103               struct multiboot_info* mb,
 104               void* buffer)
 105 {
 106     if (!mb->mods_count) {
 107         bhctx->mods.mods_num = 0;
 108         return 0;
 109     }
 110
 111     struct boot_modent* modents = (struct boot_modent*)buffer;
 112     struct multiboot_mod_list* mods = (struct multiboot_mod_list*)mb->mods_addr;
 113
 114     ptr_t mod_str_ptr = (ptr_t)&modents[mb->mods_count];
 115
 116     for (size_t i = 0; i < mb->mods_count; i++) {
 117         struct multiboot_mod_list* mod = &mods[i];
 118         modents[i] = (struct boot_modent){ .start = mod->mod_start,
 119                                            .end = mod->mod_end,
 120                                            .str = (char*)mod_str_ptr };
 121         mod_str_ptr += mb_strcpy((char*)mod_str_ptr, (char*)mod->cmdline);
 122     }
 123
 124     bhctx->mods.mods_num = mb->mods_count;
 125     bhctx->mods.entries = modents;
 126
 127     return mod_str_ptr - (ptr_t)buffer;
 128 }
 129
 130 void boot_text
 131 mb_prepare_hook(struct boot_handoff* bhctx)
 132 {
 133     // nothing to do
 134 }
 135
 136 void boot_text
 137 mb_release_hook(struct boot_handoff* bhctx)
 138 {
 139     // nothing to do
 140 }
 141
 142 #define align_addr(addr) (((addr) + (sizeof(ptr_t) - 1)) & ~(sizeof(ptr_t) - 1))
 143
 144 struct boot_handoff* boot_text
 145 mb_parse(struct multiboot_info* mb)
 146 {
 147     struct boot_handoff* bhctx = (struct boot_handoff*)bhctx_buffer;
 148     ptr_t bhctx_ex = (ptr_t)&bhctx[1];
 149
 150     *bhctx = (struct boot_handoff){ };
 151
 152     /* Parse memory map */
 153     if ((mb->flags & MULTIBOOT_INFO_MEM_MAP)) {
 154         bhctx_ex += mb_parse_mmap(bhctx, mb, (void*)bhctx_ex);
 155         bhctx_ex = align_addr(bhctx_ex);
 156     }
 157
 158     /* Parse cmdline */
 159     if ((mb->flags & MULTIBOOT_INFO_CMDLINE)) {
 160         bhctx_ex +=
 161           mb_parse_cmdline(bhctx, (void*)bhctx_ex, (char*)mb->cmdline);
 162         bhctx_ex = align_addr(bhctx_ex);
 163     }
 164
 165     /* Parse sys modules */
 166     if ((mb->flags & MULTIBOOT_INFO_MODS)) {
 167         bhctx_ex += mb_parse_mods(bhctx, mb, (void*)bhctx_ex);
 168         bhctx_ex = align_addr(bhctx_ex);
 169     }
 170
 171     check_buffer(bhctx_ex);
 172
 173     bhctx->prepare = mb_prepare_hook;
 174     bhctx->release = mb_release_hook;
 175
 176     return bhctx;
 177 }