This required some refactoring because the methods on the Translation trait need to take self to know the offset, and so the Translation needs to be passed around to the various methods which access the page table. I've achieved this by adding it as a field on the PageTableWithLevel.

To avoid duplicating code I've moved the common methods from IdMap out to a new shared struct called Mapping, which takes the Translation on construction. Translation is then implemented by IdTranslation and LinearTranslation, and IdMap becomes an alias for Mapping<IdTranslation>.

Suggestions are welcome on better names.

Rather than keeping a copy in each PageTableWithLevel we can just keep it in the RootTable and pass a reference around when needed.

This is an alternative to #18.

LinearMap and any other mapping which may have different alignment of virtual and physical addresses was incorrectly using block mappings in cases where the physical address didn't have the required alignment. The architecture requires that we only make block mappings when the physical addresses are aligned to the size of the block, so this fixes the code to do that, and adds a test.

This PR makes the Translation trait responsible for allocating page tables. This should help make it possible to use more complex mapping schemes, and to construct page tables in a different context to where they are used. This also allows allows us to make the alloc dependency optional (as it's only used by IdMap and LinearMap, not the core pagetable code).

TODO:

• [x] What about freeing subtables? Currently this assumes they are allocated by the global allocator, as it uses that to free them.

Adds addition and subtraction for VirtualAddress and PhysicalAddress, and conversion from Range<VirtualAddress> to MemoryRegion (with the same alignment logic as MemoryRegion::new).

They would crash (segfault in tests) if there were any page mappings other than 0 because the Descriptor::subtable method incorrectly returned a reference to a subtable even if the descriptor was actually in a leaf level table, because the encoding of a page mapping in a leaf table is the same as the encoding of a subtable mapping at any other level.

To avoid this it is necessary to know what level a PageTable is at, so I've added a new (internal) struct PageTableWithLevel which wraps a pointer to a PageTable. I've moved the methods from PageTable to PageTableWithLevel, which saves passing the level around.

The length specified in the format string includes the "0x" at the start, so it should be two more than the number of digits we want. Implementing Debug is useful for being able to derive it on other types which contain a VirtualAddress or PhysicalAddress.

In particular, any change which requires break-before-make shouldn't be made while the page table is active. This could check the state of previous_ttbr to determine whether it is active, pass it down into the walker code, and then return an error if some part of the change is invalid in that case.

The problem is that part of the range being mapped might be fine and part might not be, so it might end up creating a partial mapping before realising that it should return an error. Rolling this back isn't safe either. We could do a first walk to check whether it is valid then a second to actually make the change, I guess, but that would introduce a runtime overhead in the normal case.