init.cpp 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Gunnar Beutner <gbeutner@serenityos.org>
  4. * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/Types.h>
  9. #include <Kernel/Multiboot.h>
  10. #include <Kernel/PhysicalAddress.h>
  11. #include <Kernel/Prekernel/Prekernel.h>
  12. #include <Kernel/VirtualAddress.h>
  13. #include <LibC/elf.h>
  14. // Defined in the linker script
  15. extern size_t __stack_chk_guard;
  16. size_t __stack_chk_guard;
  17. extern "C" [[noreturn]] void __stack_chk_fail();
  18. extern "C" u8 start_of_prekernel_image[];
  19. extern "C" u8 end_of_prekernel_image[];
  20. extern "C" u8 gdt64ptr[];
  21. extern "C" u16 code64_sel;
  22. extern "C" u64 boot_pml4t[512];
  23. extern "C" u64 boot_pdpt[512];
  24. extern "C" u64 boot_pd0[512];
  25. extern "C" u64 boot_pd0_pts[512 * (MAX_KERNEL_SIZE >> 21 & 0x1ff)];
  26. extern "C" u64 boot_pd_kernel[512];
  27. extern "C" u64 boot_pd_kernel_pts[512 * (MAX_KERNEL_SIZE >> 21 & 0x1ff)];
  28. extern "C" u64 boot_pd_kernel_pt1023[512];
  29. extern "C" char const kernel_cmdline[4096];
  30. extern "C" void reload_cr3();
  31. extern "C" {
  32. multiboot_info_t* multiboot_info_ptr;
  33. }
  34. void __stack_chk_fail()
  35. {
  36. asm("ud2");
  37. __builtin_unreachable();
  38. }
  39. namespace Kernel {
  40. // boot.S expects these functions to exactly have the following signatures.
  41. // We declare them here to ensure their signatures don't accidentally change.
  42. extern "C" [[noreturn]] void init();
  43. static void halt()
  44. {
  45. asm volatile("hlt");
  46. }
  47. // SerenityOS Pre-Kernel Environment C++ entry point :^)
  48. //
  49. // This is where C++ execution begins, after boot.S transfers control here.
  50. //
  51. extern "C" [[noreturn]] void init()
  52. {
  53. if (multiboot_info_ptr->mods_count < 1)
  54. halt();
  55. multiboot_module_entry_t* kernel_module = (multiboot_module_entry_t*)(FlatPtr)multiboot_info_ptr->mods_addr;
  56. u8* kernel_image = (u8*)(FlatPtr)kernel_module->start;
  57. // copy the ELF header and program headers because we might end up overwriting them
  58. ElfW(Ehdr) kernel_elf_header = *(ElfW(Ehdr)*)kernel_image;
  59. ElfW(Phdr) kernel_program_headers[16];
  60. if (kernel_elf_header.e_phnum > array_size(kernel_program_headers))
  61. halt();
  62. __builtin_memcpy(kernel_program_headers, kernel_image + kernel_elf_header.e_phoff, sizeof(ElfW(Phdr)) * kernel_elf_header.e_phnum);
  63. FlatPtr kernel_load_base = 0;
  64. FlatPtr kernel_load_end = 0;
  65. for (size_t i = 0; i < kernel_elf_header.e_phnum; i++) {
  66. auto& kernel_program_header = kernel_program_headers[i];
  67. if (kernel_program_header.p_type != PT_LOAD)
  68. continue;
  69. auto start = kernel_program_header.p_vaddr;
  70. auto end = start + kernel_program_header.p_memsz;
  71. if (start < (FlatPtr)end_of_prekernel_image)
  72. halt();
  73. if (kernel_program_header.p_paddr < (FlatPtr)end_of_prekernel_image)
  74. halt();
  75. if (kernel_load_base == 0 || start < kernel_load_base)
  76. kernel_load_base = start;
  77. if (end > kernel_load_end)
  78. kernel_load_end = end;
  79. }
  80. // align to 1GB
  81. kernel_load_base &= ~(FlatPtr)0x3fffffff;
  82. #if ARCH(I386)
  83. int pdpt_flags = 0x1;
  84. #else
  85. int pdpt_flags = 0x3;
  86. #endif
  87. boot_pdpt[(kernel_load_base >> 30) & 0x1ffu] = (FlatPtr)boot_pd_kernel | pdpt_flags;
  88. for (size_t i = 0; i <= (kernel_load_end - kernel_load_base) >> 21; i++)
  89. boot_pd_kernel[i] = (FlatPtr)&boot_pd_kernel_pts[i * 512] | 0x3;
  90. __builtin_memset(boot_pd_kernel_pts, 0, sizeof(boot_pd_kernel_pts));
  91. /* pseudo-identity map 0M - end_of_prekernel_image */
  92. for (size_t i = 0; i < (FlatPtr)end_of_prekernel_image / PAGE_SIZE; i++)
  93. boot_pd_kernel_pts[i] = i * PAGE_SIZE | 0x3;
  94. for (size_t i = 0; i < kernel_elf_header.e_phnum; i++) {
  95. auto& kernel_program_header = kernel_program_headers[i];
  96. if (kernel_program_header.p_type != PT_LOAD)
  97. continue;
  98. for (FlatPtr offset = 0; offset < kernel_program_header.p_memsz; offset += PAGE_SIZE) {
  99. auto pte_index = (kernel_program_header.p_vaddr + offset - kernel_load_base) >> 12;
  100. boot_pd_kernel_pts[pte_index] = (kernel_program_header.p_paddr + offset) | 0x3;
  101. }
  102. }
  103. boot_pd_kernel[511] = (FlatPtr)boot_pd_kernel_pt1023 | 0x3;
  104. reload_cr3();
  105. for (ssize_t i = kernel_elf_header.e_phnum - 1; i >= 0; i--) {
  106. auto& kernel_program_header = kernel_program_headers[i];
  107. if (kernel_program_header.p_type != PT_LOAD)
  108. continue;
  109. __builtin_memmove((u8*)kernel_program_header.p_vaddr, kernel_image + kernel_program_header.p_offset, kernel_program_header.p_filesz);
  110. }
  111. for (ssize_t i = kernel_elf_header.e_phnum - 1; i >= 0; i--) {
  112. auto& kernel_program_header = kernel_program_headers[i];
  113. if (kernel_program_header.p_type != PT_LOAD)
  114. continue;
  115. __builtin_memset((u8*)kernel_program_header.p_vaddr + kernel_program_header.p_filesz, 0, kernel_program_header.p_memsz - kernel_program_header.p_filesz);
  116. }
  117. multiboot_info_ptr->mods_count--;
  118. multiboot_info_ptr->mods_addr += sizeof(multiboot_module_entry_t);
  119. auto adjust_by_load_base = [kernel_load_base](auto ptr) {
  120. return (decltype(ptr))((FlatPtr)ptr + kernel_load_base);
  121. };
  122. BootInfo info;
  123. info.start_of_prekernel_image = (PhysicalPtr)start_of_prekernel_image;
  124. info.end_of_prekernel_image = (PhysicalPtr)end_of_prekernel_image;
  125. info.physical_to_virtual_offset = kernel_load_base;
  126. info.kernel_base = kernel_load_base;
  127. #if ARCH(X86_64)
  128. info.gdt64ptr = (PhysicalPtr)gdt64ptr;
  129. info.code64_sel = code64_sel;
  130. info.boot_pml4t = (PhysicalPtr)boot_pml4t;
  131. #endif
  132. info.boot_pdpt = (PhysicalPtr)boot_pdpt;
  133. info.boot_pd0 = (PhysicalPtr)boot_pd0;
  134. info.boot_pd_kernel = (PhysicalPtr)boot_pd_kernel;
  135. info.boot_pd_kernel_pt1023 = (FlatPtr)adjust_by_load_base(boot_pd_kernel_pt1023);
  136. info.kernel_cmdline = (FlatPtr)adjust_by_load_base(kernel_cmdline);
  137. info.multiboot_flags = multiboot_info_ptr->flags;
  138. info.multiboot_memory_map = adjust_by_load_base((FlatPtr)multiboot_info_ptr->mmap_addr);
  139. info.multiboot_memory_map_count = multiboot_info_ptr->mmap_length / sizeof(multiboot_memory_map_t);
  140. info.multiboot_modules = adjust_by_load_base((FlatPtr)multiboot_info_ptr->mods_addr);
  141. info.multiboot_modules_count = multiboot_info_ptr->mods_count;
  142. info.multiboot_framebuffer_addr = multiboot_info_ptr->framebuffer_addr;
  143. info.multiboot_framebuffer_pitch = multiboot_info_ptr->framebuffer_pitch;
  144. info.multiboot_framebuffer_width = multiboot_info_ptr->framebuffer_width;
  145. info.multiboot_framebuffer_height = multiboot_info_ptr->framebuffer_height;
  146. info.multiboot_framebuffer_bpp = multiboot_info_ptr->framebuffer_bpp;
  147. info.multiboot_framebuffer_type = multiboot_info_ptr->framebuffer_type;
  148. asm(
  149. #if ARCH(I386)
  150. "add %0, %%esp"
  151. #else
  152. "add %0, %%rsp"
  153. #endif
  154. ::"g"(kernel_load_base));
  155. // unmap the 0-1MB region
  156. for (size_t i = 0; i < 256; i++)
  157. boot_pd0_pts[i] = 0;
  158. // unmap the end_of_prekernel_image - MAX_KERNEL_SIZE region
  159. for (FlatPtr vaddr = (FlatPtr)end_of_prekernel_image; vaddr < MAX_KERNEL_SIZE; vaddr += PAGE_SIZE)
  160. boot_pd0_pts[vaddr >> 12] = 0;
  161. reload_cr3();
  162. void (*entry)(BootInfo const&) = (void (*)(BootInfo const&))kernel_elf_header.e_entry;
  163. entry(*adjust_by_load_base(&info));
  164. __builtin_unreachable();
  165. }
  166. // Define some Itanium C++ ABI methods to stop the linker from complaining.
  167. // If we actually call these something has gone horribly wrong
  168. void* __dso_handle __attribute__((visibility("hidden")));
  169. }