beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Kernel/linker.ld

79 lines
1.7 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 19:43:07 +00: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 09:01:38 +00:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00:00
KERNEL_VIRTUAL_BASE = 0xc0000000;
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 09:01:38 +00:00
SECTIONS
{
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00: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 09:01:38 +00: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 18:59:20 +00:00
start_of_kernel_image = .;
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00:00
.text ALIGN(4K) : AT (ADDR(.text) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 08:46:09 +00:00
{
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
$<TARGET_OBJECTS:boot>
Kernel: Reindent linker script
2020-01-16 08:46:09 +00:00
*(.multiboot)
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 12:53:30 +00: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-20 01:48:56 +00: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-20 01:48:56 +00: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-20 01:48:56 +00: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: 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 17:21:54 +00:00
}
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00: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 17:21:54 +00: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 12:53:30 +00:00
end_of_kernel_text = .;
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 09:01:38 +00:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00:00
.rodata ALIGN(4K) : AT (ADDR(.rodata) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 15:44:35 +00:00
start_heap_ctors = .;
*libkernel_heap.a:*(.ctors)
end_heap_ctors = .;
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 18:01:13 +00: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: Reindent linker script
2020-01-16 08:46:09 +00: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 09:01:38 +00:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00:00
.data ALIGN(4K) : AT (ADDR(.data) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 12:53:30 +00: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 12:53:30 +00:00
end_of_kernel_data = .;
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 09:01:38 +00:00
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00: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 16:35:07 +00:00
{
start_of_ro_after_init = .;
*(.ro_after_init);
end_of_ro_after_init = .;
}
Kernel: Define a KERNEL_VIRTUAL_BASE in the linker script Slightly nicer than saying "0xc0000000" over and over.
2021-03-04 17:18:43 +00:00
.bss ALIGN(4K) (NOLOAD) : AT (ADDR(.bss) - KERNEL_VIRTUAL_BASE)
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 12:53:30 +00: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 18:59:20 +00:00
*(page_tables)
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 12:53:30 +00: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 16:49:55 +00:00
. = ALIGN(4K);
*(.heap)
. = ALIGN(4K);
*(.super_pages)
Kernel: Reindent linker script
2020-01-16 08:46:09 +00: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 18:59:20 +00: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 09:01:38 +00:00
}
Reference in a new issue Copy permalink