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/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_PD_END (kernel_mapping_base + KERNEL_PD_SIZE)
#define KERNEL_PT1024_BASE (kernel_mapping_base + 0x3FE00000)
#define KERNEL_QUICKMAP_PT (KERNEL_PT1024_BASE + 0x6000)
#define KERNEL_QUICKMAP_PD (KERNEL_PT1024_BASE + 0x7000)
#define KERNEL_QUICKMAP_PER_CPU_BASE (KERNEL_PT1024_BASE + 0x8000)

#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 boot info declarations to a header file Instead of manually redeclaring those variables in various files this now adds a header file for them. 2021-07-19 18:54:51 +03:00			`# include <Kernel/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: 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: 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 KERNEL_PT1024_BASE (kernel_mapping_base + 0x3FE00000)`
Kernel: Move PhysicalPage classes out of the heap into an array By moving the PhysicalPage classes out of the kernel heap into a static array, one for each physical page, we can avoid the added overhead and easily find them by indexing into an array. This also wraps the PhysicalPage into a PhysicalPageEntry, which allows us to re-use each slot with information where to find the next free page. 2021-07-08 04:50:05 +03:00			`#define KERNEL_QUICKMAP_PT (KERNEL_PT1024_BASE + 0x6000)`
			`#define KERNEL_QUICKMAP_PD (KERNEL_PT1024_BASE + 0x7000)`
			`#define KERNEL_QUICKMAP_PER_CPU_BASE (KERNEL_PT1024_BASE + 0x8000)`
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)`