don't leave parts of the bootloader in the kernel's address space

Commencez par lire src/binary/level_4_entries.rs autour de la réservation des premiers 512GiB et src/binary/mod.rs autour du changement de contexte et des mappings de GDT. Suivez la manière dont la table des pages du kernel et Mappings sont construits ; c’est terminé lorsque les éléments du bootloader ne sont plus laissés dans l’espace d’adressage du kernel, que le mapping temporaire du changement de contexte est géré et que l’emplacement de GDT est exposé ou configurable.

While implementing finer granular ASLR I came across this comment:
https://github.com/rust-osdev/bootloader/blob/ac46d0455b41c11e5d316348d068df1c495ce0af/src/binary/level_4_entries.rs#L40
We mark the first 512GiB of the address space as unusable for dynamically generated addresses. I think we do this because we identity map the context switch code into kernel memory and this code most likely resides within the first 512GiB of the address space:
https://github.com/rust-osdev/bootloader/blob/a445433010960ec5d8a8b94a85fcac16a00489b5/src/binary/mod.rs#L166-L181

This causes a number of (admittedly small and unlikely) problems:

• The identity mapped pages could overlap with the kernel or other mappings
• We don't expose the identity mapped addresses to the kernel in Mappings
• An attacker could make use of the identity mapped pages to defeat ASLR
• We mark so a lot of usable memory as unusable and because of that we can't check for overlaps because there would be a lot of false positives. We currently just ignore overlaps.

We could probably work around those problems while still mapping parts of the bootloader into the kernel's address space, but I'd like to propose another solution: We use another very short lived page table to do the context switch. This page table would only map a few pages containing code that switches to the kernel's page table. Importantly, we would set the page table up in such a way that the kernel's entrypoint is just after the page table switch instruction, so we don't have to use any code to jump to the kernel, it would simply be the next instruction.
I don't think we could reliably map such code into the bootloader's address space because we'd have to map the code just before the kernel's entrypoint which could be close to bootloader's code, so that's why I want to use a short-lived page table.

We also identity map a GDT into the kernel's address space:
https://github.com/rust-osdev/bootloader/blob/a445433010960ec5d8a8b94a85fcac16a00489b5/src/binary/mod.rs#L183-L193
We should probably make the GDT's location configurable and expose it in Mappings.

I'd be happy to work on a pr for this.