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

Empieza leyendo src/binary/level_4_entries.rs alrededor de la reserva de los primeros 512GiB y src/binary/mod.rs alrededor del cambio de contexto y las asignaciones de GDT. Traza cómo se construyen la tabla de páginas del kernel y Mappings; se considera terminado cuando las partes del bootloader ya no quedan en el espacio de direcciones del kernel, la asignación temporal del cambio de contexto se gestiona y la ubicación de GDT se expone o se puede configurar.

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.