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     bhctx->kexec.cmdline = buffer;
  65
  66     return slen;
  67 }
  68
  69 size_t boot_text
  70 mb_parse_mmap(struct boot_handoff* bhctx,
  71               struct multiboot_info* mb,
  72               void* buffer)
  73 {
  74     struct multiboot_mmap_entry* mb_mmap =
  75       (struct multiboot_mmap_entry*)mb->mmap_addr;
  76     size_t mmap_len = mb->mmap_length / sizeof(struct multiboot_mmap_entry);
  77
  78     struct boot_mmapent* bmmap = (struct boot_mmapent*)buffer;
  79     for (size_t i = 0; i < mmap_len; i++) {
  80         struct boot_mmapent* bmmapent = &bmmap[i];
  81         struct multiboot_mmap_entry* mb_mapent = &mb_mmap[i];
  82
  83         if (mb_mapent->type == MULTIBOOT_MEMORY_AVAILABLE) {
  84             bmmapent->type = BOOT_MMAP_FREE;
  85         } else if (mb_mapent->type == MULTIBOOT_MEMORY_ACPI_RECLAIMABLE) {
  86             bmmapent->type = BOOT_MMAP_RCLM;
  87         } else {
  88             bmmapent->type = BOOT_MMAP_RSVD;
  89         }
  90
  91         bmmapent->start = mb_mapent->addr_low;
  92         bmmapent->size = mb_mapent->len_low;
  93     }
  94
  95     bhctx->mem.size = (mb->mem_upper << 10) + MEM_1M;
  96     bhctx->mem.mmap = bmmap;
  97     bhctx->mem.mmap_len = mmap_len;
  98
  99     return mmap_len * sizeof(struct boot_mmapent);
 100 }
 101
 102 size_t boot_text
 103 mb_parse_mods(struct boot_handoff* bhctx,
 104               struct multiboot_info* mb,
 105               void* buffer)
 106 {
 107     if (!mb->mods_count) {
 108         bhctx->mods.mods_num = 0;
 109         return 0;
 110     }
 111
 112     struct boot_modent* modents = (struct boot_modent*)buffer;
 113     struct multiboot_mod_list* mods = (struct multiboot_mod_list*)mb->mods_addr;
 114
 115     ptr_t mod_str_ptr = (ptr_t)&modents[mb->mods_count];
 116
 117     for (size_t i = 0; i < mb->mods_count; i++) {
 118         struct multiboot_mod_list* mod = &mods[i];
 119         modents[i] = (struct boot_modent){ .start = mod->mod_start,
 120                                            .end = mod->mod_end,
 121                                            .str = (char*)mod_str_ptr };
 122         mod_str_ptr += mb_strcpy((char*)mod_str_ptr, (char*)mod->cmdline);
 123     }
 124
 125     bhctx->mods.mods_num = mb->mods_count;
 126     bhctx->mods.entries = modents;
 127
 128     return mod_str_ptr - (ptr_t)buffer;
 129 }
 130
 131 void boot_text
 132 mb_prepare_hook(struct boot_handoff* bhctx)
 133 {
 134     // nothing to do
 135 }
 136
 137 void boot_text
 138 mb_release_hook(struct boot_handoff* bhctx)
 139 {
 140     // nothing to do
 141 }
 142
 143 #define align_addr(addr) (((addr) + (sizeof(ptr_t) - 1)) & ~(sizeof(ptr_t) - 1))
 144
 145 struct boot_handoff* boot_text
 146 mb_parse(struct multiboot_info* mb)
 147 {
 148     struct boot_handoff* bhctx = (struct boot_handoff*)bhctx_buffer;
 149     ptr_t bhctx_ex = (ptr_t)&bhctx[1];
 150
 151     *bhctx = (struct boot_handoff){ };
 152
 153     /* Parse memory map */
 154     if ((mb->flags & MULTIBOOT_INFO_MEM_MAP)) {
 155         bhctx_ex += mb_parse_mmap(bhctx, mb, (void*)bhctx_ex);
 156         bhctx_ex = align_addr(bhctx_ex);
 157     }
 158
 159     /* Parse cmdline */
 160     if ((mb->flags & MULTIBOOT_INFO_CMDLINE)) {
 161         bhctx_ex +=
 162           mb_parse_cmdline(bhctx, (void*)bhctx_ex, (char*)mb->cmdline);
 163         bhctx_ex = align_addr(bhctx_ex);
 164     }
 165
 166     /* Parse sys modules */
 167     if ((mb->flags & MULTIBOOT_INFO_MODS)) {
 168         bhctx_ex += mb_parse_mods(bhctx, mb, (void*)bhctx_ex);
 169         bhctx_ex = align_addr(bhctx_ex);
 170     }
 171
 172     check_buffer(bhctx_ex);
 173
 174     bhctx->prepare = mb_prepare_hook;
 175     bhctx->release = mb_release_hook;
 176
 177     return bhctx;
 178 }