Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-08 06:09:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Kernel/linker.ld

97 lines
2 KiB
Text
Raw Normal View History

Kernel: Use a multiboot header instead of a convoluted two-part bootloader. The old bootloader was hilariously complicated, requiring a floppy disk with the kernel on it, and a hard drive with the file system. This patch removes the floppy disk from the equation and replaces it with a multiboot header. This means the kernel can now be booted with qemu-system-i386 -kernel kernel
2019-04-01 21:43:07 +02:00
ENTRY(start)
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
KERNEL_VIRTUAL_BASE = 0xc0000000;
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
{
boot_text PT_LOAD ;
boot_bss PT_LOAD ;
text PT_LOAD ;
data PT_LOAD ;
bss PT_LOAD ;
}
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: 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_VIRTUAL_BASE + 0x00100000;
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: 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
.boot_text ALIGN(4K) : AT (ADDR(.boot_text) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 09:46:09 +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
KEEP(*(.boot_text))
KEEP(*(.multiboot))
} :boot_text
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
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
.boot_bss ALIGN(4K) (NOLOAD) : AT (ADDR(.boot_bss) - KERNEL_VIRTUAL_BASE)
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
{
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
KEEP(*(.page_tables))
KEEP(*(.stack))
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
*(.super_pages)
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
} :boot_bss
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
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