Higher Half Kernel: Difference between revisions
| [unchecked revision] | [unchecked revision] |
m (Reverted edits by Leapofazzam (talk) to last revision by Bzt) |
m (update to include the new Limine boot protocol) |
||
| Line 16: | Line 16: | ||
* [[BOOTBOOT]] only supports higher half kernels by design. It has example Hello World kernels written in [[C]], [[Pascal]], [[Rust]] and [[Go]] |
* [[BOOTBOOT]] only supports higher half kernels by design. It has example Hello World kernels written in [[C]], [[Pascal]], [[Rust]] and [[Go]] |
||
* [[Limine]] requires special sections in the kernel, see [[stivale Bare Bones]] for a tutorial on how to write a simple 64-bit higher half kernel for Limine. |
* [[Limine]] requires special sections in the kernel, see [[Limine Bare Bones]] (or [[stivale Bare Bones]]) for a tutorial on how to write a simple 64-bit higher half kernel for Limine. |
||
== Initialization == |
== Initialization == |
||
To setup a higher half kernel, you have to map your kernel to the appropriate virtual address. When using a boot protocol which supports higher half kernels directly, such as [[BOOTBOOT]] or [[stivale]], your kernel will already be properly mapped. |
To setup a higher half kernel, you have to map your kernel to the appropriate virtual address. When using a boot protocol which supports higher half kernels directly, such as [[BOOTBOOT]], [[Limine]] or [[stivale]], your kernel will already be properly mapped. |
||
How to do this basically depends on '''when''' you'd like your kernel to believe it's in the higher end, and '''when''' you set up paging. Without a boot loader help, you'll need a small trampoline code which runs in lower half, sets up higher half paging and jumps. |
How to do this basically depends on '''when''' you'd like your kernel to believe it's in the higher end, and '''when''' you set up paging. Without a boot loader help, you'll need a small trampoline code which runs in lower half, sets up higher half paging and jumps. |
||
Revision as of 10:38, 3 June 2022
| Kernel Designs |
|---|
| Models |
| Other Concepts |
It is traditional and generally good to have your kernel mapped in every user process. Linux and many other Unices, for instance, reside at virtual addresses 0xC0000000 – 0xFFFFFFFF of every address space, leaving the range 0x00000000 – 0xBFFFFFFF for user code, data, stacks, libraries, etc. Kernels that have such design are said to be "in the higher half" by opposition to kernels that use lowest virtual addresses for themselves, and leave higher addresses for the applications.
In addition, there is some non-x86 ISA (the MIPS RISC architecture and ARM) which partly forces the issue. On MIPS and ARM systems, addresses using the high bit (either bit 31 or bit 63, depending on the system word width) are reserved for use in Supervisor mode, and are exception trapped when in User mode.
Advantages of a higher half kernel are:
- It's easier to set up VM86 processes since the region below 1 MB is userspace.
- More generally, user applications are not dependent on how much memory is kernel space (your application can be linked to 0x400000 regardless of whether kernel is at 0xC0000000, 0x80000000 or 0xE0000000 ...), which makes the ABI nicer.
- If your OS is 64-bit, then 32-bit applications will be able to use the full 32-bit address space.
- 'Mnemonic' invalid pointers such as 0xCAFEBABE, 0xDEADBEEF, 0xDEADC0DE, etc. can be used.
Bootloader support
To make things easier, some bootloaders natively support higher half kernels, by directly loading and mapping a kernel to the higher half in virtual memory.
- BOOTBOOT only supports higher half kernels by design. It has example Hello World kernels written in C, Pascal, Rust and Go
- Limine requires special sections in the kernel, see Limine Bare Bones (or stivale Bare Bones) for a tutorial on how to write a simple 64-bit higher half kernel for Limine.
Initialization
To setup a higher half kernel, you have to map your kernel to the appropriate virtual address. When using a boot protocol which supports higher half kernels directly, such as BOOTBOOT, Limine or stivale, your kernel will already be properly mapped.
How to do this basically depends on when you'd like your kernel to believe it's in the higher end, and when you set up paging. Without a boot loader help, you'll need a small trampoline code which runs in lower half, sets up higher half paging and jumps.