ladybird/Kernel/Sections.h

/*
 * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <AK/Platform.h>
#ifdef __cplusplus
#    include <AK/Types.h>
#    include <Kernel/Boot/BootInfo.h>
#endif

#define READONLY_AFTER_INIT __attribute__((section(".ro_after_init")))
#define UNMAP_AFTER_INIT NEVER_INLINE __attribute__((section(".unmap_after_init")))

#define KERNEL_MAPPING_BASE 0x2000000000

#define KERNEL_PD_END (kernel_mapping_base + KERNEL_PD_SIZE)
#define KERNEL_PT1024_OFFSET 0x3FE00000
#define KERNEL_PT1024_BASE (kernel_mapping_base + KERNEL_PT1024_OFFSET)

#define KERNEL_MAX_CPU_COUNT 64
#define KERNEL_QUICKMAP_PT_PER_CPU_BASE (KERNEL_PT1024_BASE + (1 * KERNEL_MAX_CPU_COUNT * PAGE_SIZE))
#define KERNEL_QUICKMAP_PD_PER_CPU_BASE (KERNEL_PT1024_BASE + (2 * KERNEL_MAX_CPU_COUNT * PAGE_SIZE))
#define KERNEL_QUICKMAP_PER_CPU_BASE (KERNEL_PT1024_BASE + (3 * KERNEL_MAX_CPU_COUNT * PAGE_SIZE))

#define USER_RANGE_BASE 0x10000
#define USER_RANGE_CEILING (kernel_mapping_base - 0x2000000)
Kernel: Move special sections into Sections.h This also removes a lot of CPU.h includes infavor for Sections.h 2021-06-22 18:40:16 +03:00			`/*`
			`* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>`
			`*`
			`* SPDX-License-Identifier: BSD-2-Clause`
			`*/`

			`#pragma once`

			`#include <AK/Platform.h>`
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 15:47:32 +03:00			`#ifdef __cplusplus`
			`# include <AK/Types.h>`
Kernel: Move all boot-related code to the new Boot subdirectory 2023-02-24 21:21:53 +03:00			`# include <Kernel/Boot/BootInfo.h>`
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 15:47:32 +03:00			`#endif`
Kernel: Move special sections into Sections.h This also removes a lot of CPU.h includes infavor for Sections.h 2021-06-22 18:40:16 +03:00
			`#define READONLY_AFTER_INIT __attribute__((section(".ro_after_init")))`
			`#define UNMAP_AFTER_INIT NEVER_INLINE __attribute__((section(".unmap_after_init")))`
Kernel: Make and use KERNEL_BASE This is to make the 0xc0000000 less a magic number, and will make it easier in the future to move the Kernel around 2021-06-28 19:43:18 +03:00
Kernel: Add KERNEL_MAPPING_BASE to Sections.h and use it in Prekernel 2023-01-10 12:34:25 +03:00			`#define KERNEL_MAPPING_BASE 0x2000000000`

Kernel: Use the whole kernel PD range when randomizing the KASLR offset Now that we reclaim the memory range that is created by KASLR before the start of the kernel image, there's no need to be conservative with the KASLR offset. 2022-03-22 20:10:17 +03:00			`#define KERNEL_PD_END (kernel_mapping_base + KERNEL_PD_SIZE)`
Kernel/aarch64: Change base address of the kernel to 0x2000000000 This is the same address that the x86_64 kernel runs at, and allows us to run the kernel at a high virtual memory address. Since we now run completely in high virtual memory, we can also unmap the identity mapping. Additionally some changes in MMU.cpp are required to successfully boot. 2023-01-07 17:01:51 +03:00			`#define KERNEL_PT1024_OFFSET 0x3FE00000`
			`#define KERNEL_PT1024_BASE (kernel_mapping_base + KERNEL_PT1024_OFFSET)`
Kernel: Make the page table quickmaps per-CPU While the "regular" quickmap (used to temporarily map a physical page at a known address for quick access) has been per-CPU for a while, we also have the PD (page directory) and PT (page table) quickmaps used by the memory management code to edit page tables. These have been global, which meant that SMP systems had to keep fighting over them. This patch makes all quickmaps per-CPU. We reserve virtual addresses for up to 64 CPUs worth of quickmaps for now. Note that all quickmaps are still protected by the MM lock, and we'll have to fix that too, before seeing any real throughput improvements. 2022-08-22 15:41:08 +03:00
			`#define KERNEL_MAX_CPU_COUNT 64`
			`#define KERNEL_QUICKMAP_PT_PER_CPU_BASE (KERNEL_PT1024_BASE + (1 * KERNEL_MAX_CPU_COUNT * PAGE_SIZE))`
			`#define KERNEL_QUICKMAP_PD_PER_CPU_BASE (KERNEL_PT1024_BASE + (2 * KERNEL_MAX_CPU_COUNT * PAGE_SIZE))`
			`#define KERNEL_QUICKMAP_PER_CPU_BASE (KERNEL_PT1024_BASE + (3 * KERNEL_MAX_CPU_COUNT * PAGE_SIZE))`
Kernel: Remove some more hardcoded addresses 2021-07-16 23:29:54 +03:00
Kernel: Move userspace virtual address range base to 0x10000 Now that the shared bottom 2 MiB virtual address mappings are gone userspace can use lower virtual addresses. 2021-12-19 20:36:42 +03:00			`#define USER_RANGE_BASE 0x10000`
Kernel: Support loading the kernel at almost arbitrary virtual addresses This enables further work on implementing KASLR by adding relocation support to the pre-kernel and updating the kernel to be less dependent on specific virtual memory layouts. 2021-07-26 16:10:51 +03:00			`#define USER_RANGE_CEILING (kernel_mapping_base - 0x2000000)`