mirrors/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity.git synced 2025-01-24 18:32:28 -05:00
Code Issues Projects Releases Packages Wiki Activity
serenity/Kernel/linker_amd64.ld

97 lines
2 KiB
Text
Raw Normal View History

Kernel: Introduce basic pre-kernel environment This implements a simple bootloader that is capable of loading ELF64 kernel images. It does this by using QEMU/GRUB to load the kernel image from disk and pass it to our bootloader as a Multiboot module. The bootloader then parses the ELF image and sets it up appropriately. The kernel's entry point is a C++ function with architecture-native code. Co-authored-by: Liav A <liavalb@gmail.com>
2021-07-18 14:47:32 +02:00
ENTRY(init)
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
Kernel: Use a different kernel load address for x86_64 Co-authored-by: Gunnar Beutner <gbeutner@serenityos.org>
2021-07-18 03:35:26 +02:00
KERNEL_VIRTUAL_BASE = 0x2000000000;
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 18:18:43 +01:00
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
PHDRS
{
Kernel: Rename .boot_bss to .super_pages to better reflect what it is This also removes the section attribute for kernel_base which had no effect because the section wasn't included in the linker script.
2021-07-19 18:52:01 +02:00
super_pages PT_LOAD ;
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
text PT_LOAD ;
data PT_LOAD ;
bss PT_LOAD ;
Kernel: Make kernel symbols available much earlier in the boot process This adds a new section .ksyms at the end of the linker map, reserves 5MiB for it (which are after end_of_kernel_image so they get re-used once MemoryManager is initialized) and then embeds the symbol map into the kernel binary with objcopy. This also shrinks the .ksyms section to the real size of the symbol file (around 900KiB at the moment). By doing this we can make the symbol map available much earlier in the boot process, i.e. even before VFS is available.
2021-07-14 21:04:18 +02:00
ksyms PT_LOAD ;
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
}
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
SECTIONS
{
Kernel: Use a different kernel load address for x86_64 Co-authored-by: Gunnar Beutner <gbeutner@serenityos.org>
2021-07-18 03:35:26 +02:00
. = KERNEL_VIRTUAL_BASE + 0x00200000;
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
Kernel: Move kernel above the 3GB virtual address mark The kernel and its static data structures are no longer identity-mapped in the bottom 8MB of the address space, but instead move above 3GB. The first 8MB above 3GB are pseudo-identity-mapped to the bottom 8MB of the physical address space. But things don't have to stay this way! Thanks to Jesse who made an earlier attempt at this, it was really easy to get device drivers working once the page tables were in place! :^) Fixes #734.
2020-01-17 19:59:20 +01:00
start_of_kernel_image = .;
Kernel: Rename .boot_bss to .super_pages to better reflect what it is This also removes the section attribute for kernel_base which had no effect because the section wasn't included in the linker script.
2021-07-19 18:52:01 +02:00
.super_pages ALIGN(4K) (NOLOAD) : AT (ADDR(.super_pages) - KERNEL_VIRTUAL_BASE)
Kernel: Make sure super pages are in the first 16MiB of physical memory This was broken by recent changes.
2021-07-19 09:29:07 +02:00
{
*(.super_pages)
Kernel: Rename .boot_bss to .super_pages to better reflect what it is This also removes the section attribute for kernel_base which had no effect because the section wasn't included in the linker script.
2021-07-19 18:52:01 +02:00
} :super_pages
Kernel: Make sure super pages are in the first 16MiB of physical memory This was broken by recent changes.
2021-07-19 09:29:07 +02:00
Kernel: Move super_pages section into the bottom 16MB This ensures that pages returned by MM.allocate_supervisor_physical_page() have a physical address that is in the bottom 16MB and can thus be used by the SB16 driver for DMA. Fixes #8092.
2021-06-17 19:27:05 +02:00
.text ALIGN(4K) : AT (ADDR(.text) - KERNEL_VIRTUAL_BASE)
{
Kernel: Harden memory mapping of the kernel image We now map the kernel's text and rodata segments read+execute. We also make the data and bss segments non-executable. Thanks to q3k for the idea! :^)
2020-01-06 13:53:30 +01:00
start_of_kernel_text = .;
Kernel: Add safe atomic functions This allows us to perform atomic operations on potentially unsafe user space pointers.
2020-12-19 18:48:56 -07:00
start_of_safemem_text = .;
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
KEEP(*(.text.safemem))
Kernel: Add safe atomic functions This allows us to perform atomic operations on potentially unsafe user space pointers.
2020-12-19 18:48:56 -07:00
end_of_safemem_text = .;
start_of_safemem_atomic_text = .;
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
KEEP(*(.text.safemem.atomic))
Kernel: Add safe atomic functions This allows us to perform atomic operations on potentially unsafe user space pointers.
2020-12-19 18:48:56 -07:00
end_of_safemem_atomic_text = .;
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
*(.text*)
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
} :text
Kernel: Add .unmap_after_init section for code we don't need after init You can now declare functions with UNMAP_AFTER_INIT and they'll get segregated into a separate kernel section that gets completely unmapped at the end of initialization. This can be used for anything we don't need to call once we've booted into userspace. There are two nice things about this mechanism: - It allows us to free up entire pages of memory for other use. (Note that this patch does not actually make use of the freed pages yet, but in the future we totally could!) - It allows us to get rid of obviously dangerous gadgets like write-to-CR0 and write-to-CR4 which are very useful for an attacker trying to disable SMAP/SMEP/etc. I've also made sure to include a helpful panic message in case you hit a kernel crash because of this protection. :^)
2021-02-19 18:21:54 +01:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 18:18:43 +01:00
.unmap_after_init ALIGN(4K) : AT (ADDR(.unmap_after_init) - KERNEL_VIRTUAL_BASE)
Kernel: Add .unmap_after_init section for code we don't need after init You can now declare functions with UNMAP_AFTER_INIT and they'll get segregated into a separate kernel section that gets completely unmapped at the end of initialization. This can be used for anything we don't need to call once we've booted into userspace. There are two nice things about this mechanism: - It allows us to free up entire pages of memory for other use. (Note that this patch does not actually make use of the freed pages yet, but in the future we totally could!) - It allows us to get rid of obviously dangerous gadgets like write-to-CR0 and write-to-CR4 which are very useful for an attacker trying to disable SMAP/SMEP/etc. I've also made sure to include a helpful panic message in case you hit a kernel crash because of this protection. :^)
2021-02-19 18:21:54 +01:00
{
start_of_unmap_after_init = .;
*(.unmap_after_init*);
end_of_unmap_after_init = .;
Kernel: Harden memory mapping of the kernel image We now map the kernel's text and rodata segments read+execute. We also make the data and bss segments non-executable. Thanks to q3k for the idea! :^)
2020-01-06 13:53:30 +01:00
end_of_kernel_text = .;
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
} :text
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 18:18:43 +01:00
.rodata ALIGN(4K) : AT (ADDR(.rodata) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 09:46:09 +01:00
{
Kernel: Invoke heap constructors separately early on By having a separate list of constructors for the kernel heap code, we can properly use constructors without re-running them after the heap was already initialized. This solves some problems where values were wiped out because they were overwritten by running their constructors later in the initialization process.
2020-08-10 09:44:35 -06:00
start_heap_ctors = .;
*libkernel_heap.a:*(.ctors)
end_heap_ctors = .;
Kernel: Reindent linker script
2020-01-16 09:46:09 +01:00
start_ctors = .;
*(.ctors)
end_ctors = .;
Kernel: Add bare minimum for global constructors (#707) Add text.startup to the .text block, add .ctors as well. Use them in init.cpp to call global constructors after gtd and idt init. That way any funky constructors should be ok. Also defines some Itanium C++ ABI methods that probably shouldn't be, but without them the linker gets very angry. If the code ever actually tries to use __dso_handle or call __cxa_atexit, there's bigger problems with the kernel. Bit of a hack would be an understatement but hey. It works :)
2019-10-31 12:01:13 -06:00
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
*(.rodata*)
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
} :data
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 18:18:43 +01:00
.data ALIGN(4K) : AT (ADDR(.data) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 09:46:09 +01:00
{
Kernel: Harden memory mapping of the kernel image We now map the kernel's text and rodata segments read+execute. We also make the data and bss segments non-executable. Thanks to q3k for the idea! :^)
2020-01-06 13:53:30 +01:00
start_of_kernel_data = .;
Kernel: Merge split function and data sections into one during linking Also add an assertion to make sure the safemem sections are never discarded by the linker.
2021-02-09 22:49:02 +00:00
*(.data*)
Kernel: Harden memory mapping of the kernel image We now map the kernel's text and rodata segments read+execute. We also make the data and bss segments non-executable. Thanks to q3k for the idea! :^)
2020-01-06 13:53:30 +01:00
end_of_kernel_data = .;
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
} :data
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 18:18:43 +01:00
.ro_after_init ALIGN(4K) (NOLOAD) : AT(ADDR(.ro_after_init) - KERNEL_VIRTUAL_BASE)
Kernel: Add mechanism to make some memory read-only after init finishes You can now use the READONLY_AFTER_INIT macro when declaring a variable and we will put it in a special ".ro_after_init" section in the kernel. Data in that section remains writable during the boot and init process, and is then marked read-only just before launching the SystemServer. This is based on an idea from the Linux kernel. :^)
2021-02-14 17:35:07 +01:00
{
start_of_ro_after_init = .;
*(.ro_after_init);
end_of_ro_after_init = .;
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
} :data
Kernel: Add mechanism to make some memory read-only after init finishes You can now use the READONLY_AFTER_INIT macro when declaring a variable and we will put it in a special ".ro_after_init" section in the kernel. Data in that section remains writable during the boot and init process, and is then marked read-only just before launching the SystemServer. This is based on an idea from the Linux kernel. :^)
2021-02-14 17:35:07 +01:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 18:18:43 +01:00
.bss ALIGN(4K) (NOLOAD) : AT (ADDR(.bss) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 09:46:09 +01:00
{
Kernel: Harden memory mapping of the kernel image We now map the kernel's text and rodata segments read+execute. We also make the data and bss segments non-executable. Thanks to q3k for the idea! :^)
2020-01-06 13:53:30 +01:00
start_of_kernel_bss = .;
Kernel: Move kernel above the 3GB virtual address mark The kernel and its static data structures are no longer identity-mapped in the bottom 8MB of the address space, but instead move above 3GB. The first 8MB above 3GB are pseudo-identity-mapped to the bottom 8MB of the physical address space. But things don't have to stay this way! Thanks to Jesse who made an earlier attempt at this, it was really easy to get device drivers working once the page tables were in place! :^) Fixes #734.
2020-01-17 19:59:20 +01:00
*(page_tables)
Kernel: Reindent linker script
2020-01-16 09:46:09 +01:00
*(COMMON)
*(.bss)
Kernel: Harden memory mapping of the kernel image We now map the kernel's text and rodata segments read+execute. We also make the data and bss segments non-executable. Thanks to q3k for the idea! :^)
2020-01-06 13:53:30 +01:00
end_of_kernel_bss = .;
Kernel: Move kmalloc heaps and super pages inside .bss segment The kernel ignored the first 8 MiB of RAM while parsing the memory map because the kmalloc heaps and the super physical pages lived here. Move all that stuff inside the .bss segment so that those memory regions are accounted for, otherwise we risk overwriting boot modules placed next to the kernel.
2021-01-20 17:49:55 +01:00
. = ALIGN(4K);
*(.heap)
Kernel: Make sure the kernel's ELF PHDRs don't use rwx This doesn't really matter in terms of writability for the kernel text because we set up proper page mappings anyway which prohibit writing to the text segment. However, this makes the profiler happy which previously died when validating the kernel's ELF program headers.
2021-06-18 19:04:39 +02:00
} :bss
Kernel: Move kernel above the 3GB virtual address mark The kernel and its static data structures are no longer identity-mapped in the bottom 8MB of the address space, but instead move above 3GB. The first 8MB above 3GB are pseudo-identity-mapped to the bottom 8MB of the physical address space. But things don't have to stay this way! Thanks to Jesse who made an earlier attempt at this, it was really easy to get device drivers working once the page tables were in place! :^) Fixes #734.
2020-01-17 19:59:20 +01:00
Kernel: Make kernel symbols available much earlier in the boot process This adds a new section .ksyms at the end of the linker map, reserves 5MiB for it (which are after end_of_kernel_image so they get re-used once MemoryManager is initialized) and then embeds the symbol map into the kernel binary with objcopy. This also shrinks the .ksyms section to the real size of the symbol file (around 900KiB at the moment). By doing this we can make the symbol map available much earlier in the boot process, i.e. even before VFS is available.
2021-07-14 21:04:18 +02:00
.ksyms ALIGN(4K) : AT (ADDR(.ksyms) - KERNEL_VIRTUAL_BASE)
{
Kernel: Move end_of_kernel_image after the .ksyms section Without this we won't be able to detect whether .ksyms overlaps the end of the page table we set up for the kernel image.
2021-07-16 09:50:34 +02:00
start_of_kernel_ksyms = .;
Kernel: Make kernel symbols available much earlier in the boot process This adds a new section .ksyms at the end of the linker map, reserves 5MiB for it (which are after end_of_kernel_image so they get re-used once MemoryManager is initialized) and then embeds the symbol map into the kernel binary with objcopy. This also shrinks the .ksyms section to the real size of the symbol file (around 900KiB at the moment). By doing this we can make the symbol map available much earlier in the boot process, i.e. even before VFS is available.
2021-07-14 21:04:18 +02:00
*(.kernel_symbols)
Kernel: Move end_of_kernel_image after the .ksyms section Without this we won't be able to detect whether .ksyms overlaps the end of the page table we set up for the kernel image.
2021-07-16 09:50:34 +02:00
end_of_kernel_ksyms = .;
Kernel: Make kernel symbols available much earlier in the boot process This adds a new section .ksyms at the end of the linker map, reserves 5MiB for it (which are after end_of_kernel_image so they get re-used once MemoryManager is initialized) and then embeds the symbol map into the kernel binary with objcopy. This also shrinks the .ksyms section to the real size of the symbol file (around 900KiB at the moment). By doing this we can make the symbol map available much earlier in the boot process, i.e. even before VFS is available.
2021-07-14 21:04:18 +02:00
} :ksyms
Kernel: Move end_of_kernel_image after the .ksyms section Without this we won't be able to detect whether .ksyms overlaps the end of the page table we set up for the kernel image.
2021-07-16 09:50:34 +02:00
end_of_kernel_image = .;
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 11:01:38 +02:00
}
Reference in a new issue Copy permalink