17. Translation (XLAT) Tables Library
This document describes the design of the translation tables library (version 2) used by Trusted Firmware-A (TF-A). This library provides APIs to create page tables based on a description of the memory layout, as well as setting up system registers related to the Memory Management Unit (MMU) and performing the required Translation Lookaside Buffer (TLB) maintenance operations.
More specifically, some use cases that this library aims to support are:
Statically allocate translation tables and populate them (at run-time) based upon a description of the memory layout. The memory layout is typically provided by the platform port as a list of memory regions;
Support for generating translation tables pertaining to a different translation regime than the exception level the library code is executing at;
Support for dynamic mapping and unmapping of regions, even while the MMU is on. This can be used to temporarily map some memory regions and unmap them later on when no longer needed;
Support for non-identity virtual to physical mappings to compress the virtual address space;
Support for changing memory attributes of memory regions at run-time.
17.1. About version 1, version 2 and MPU libraries
This document focuses on version 2 of the library, whose sources are available
lib/xlat_tables_v2 directory. Version 1 of the library can still be
lib/xlat_tables directory but it is less flexible and doesn’t
support dynamic mapping.
lib/xlat_mpu, which configures Arm’s MPU
equivalently, is also addressed here. The
lib/xlat_mpu is experimental,
meaning that its API may change. It currently strives for consistency and
code-reuse with xlat_tables_v2. Future versions may be more MPU-specific (e.g.,
removing all mentions of virtual addresses). Although potential bug fixes will
be applied to all versions of the xlat_* libs, future feature enhancements will
focus on version 2 and might not be back-ported to version 1 and MPU versions.
Therefore, it is recommended to use version 2, especially for new platform
ports (unless the platform uses an MPU).
However, please note that version 2 and the MPU version are still in active development and is not considered stable yet. Hence, compatibility breaks might be introduced.
From this point onwards, this document will implicitly refer to version 2 of the library, unless stated otherwise.
17.2. Design concepts and interfaces
This section presents some of the key concepts and data structures used in the translation tables library.
17.2.1. mmap regions
mmap_region is an abstract, concise way to represent a memory region to
map. It is one of the key interfaces to the library. It is identified by:
its physical base address;
its virtual base address;
its mapping granularity (optional).
struct mmap_region type in
The user usually provides a list of such mmap regions to map and lets the library transpose that in a set of translation tables. As a result, the library might create new translation tables, update or split existing ones.
The region attributes specify the type of memory (for example device or cached
normal memory) as well as the memory access permissions (read-only or
read-write, executable or not, secure or non-secure, and so on). In the case of
the EL1&0 translation regime, the attributes also specify whether the region is
a User region (EL0) or Privileged region (EL1). See the
xlat_tables_v2.h. Note that for the EL1&0 translation regime the Execute
Never attribute is set simultaneously for both EL1 and EL0.
The granularity controls the translation table level to go down to when mapping the region. For example, assuming the MMU has been configured to use a 4KB granule size, the library might map a 2MB memory region using either of the two following options:
using a single level-2 translation table entry;
using a level-2 intermediate entry to a level-3 translation table (which contains 512 entries, each mapping 4KB).
The first solution potentially requires less translation tables, hence potentially less memory. However, if part of this 2MB region is later remapped with different memory attributes, the library might need to split the existing page tables to refine the mappings. If a single level-2 entry has been used here, a level-3 table will need to be allocated on the fly and the level-2 modified to point to this new level-3 table. This has a performance cost at run-time.
If the user knows upfront that such a remapping operation is likely to happen then they might enforce a 4KB mapping granularity for this 2MB region from the beginning; remapping some of these 4KB pages on the fly then becomes a lightweight operation.
The region’s granularity is an optional field; if it is not specified the library will choose the mapping granularity for this region as it sees fit (more details can be found in The memory mapping algorithm section below).
The MPU library also uses
struct mmap_region to specify translations, but
the MPU’s translations are limited to specification of valid addresses and
access permissions. If the requested virtual and physical addresses mismatch
the system will panic. Being register-based for deterministic memory-reference
timing, the MPU hardware does not involve memory-resident translation tables.
Currently, the MPU library is also limited to MPU translation at EL2 with no MMU translation at other ELs. These limitations, however, are expected to be overcome in future library versions.
17.2.2. Translation Context
The library can create or modify translation tables pertaining to a different translation regime than the exception level the library code is executing at. For example, the library might be used by EL3 software (for instance BL31) to create translation tables pertaining to the S-EL1&0 translation regime.
This flexibility comes from the use of translation contexts. A translation context constitutes the superset of information used by the library to track the status of a set of translation tables for a given translation regime.
The library internally allocates a default translation context, which pertains
to the translation regime of the current exception level. Additional contexts
may be explicitly allocated and initialized using the
REGISTER_XLAT_CONTEXT() macro. Separate APIs are provided to act either on
the default translation context or on an alternative one.
To register a translation context, the user must provide the library with the following information:
The resulting translation context variable will be called after this name, to which
_xlat_ctxis appended. For example, if the macro name parameter is
foo, the context variable name will be
The maximum number of mmap regions to map.
Should account for both static and dynamic regions, if applicable.
The number of sub-translation tables to allocate.
Number of translation tables to statically allocate for this context, excluding the initial lookup level translation table, which is always allocated. For example, if the initial lookup level is 1, this parameter would specify the number of level-2 and level-3 translation tables to pre-allocate for this context.
The size of the virtual address space.
Size in bytes of the virtual address space to map using this context. This will incidentally determine the number of entries in the initial lookup level translation table : the library will allocate as many entries as is required to map the entire virtual address space.
The size of the physical address space.
Size in bytes of the physical address space to map using this context.
The default translation context is internally initialized using information coming (for the most part) from platform-specific defines:
name: hard-coded to
tf; hence the name of the default context variable is
number of mmap regions:
number of sub-translation tables:
size of the virtual address space:
size of the physical address space:
Please refer to the Porting Guide for more details about these macros.
17.2.3. Static and dynamic memory regions
The library optionally supports dynamic memory mapping. This feature may be
enabled using the
PLAT_XLAT_TABLES_DYNAMIC platform build flag.
When dynamic memory mapping is enabled, the library categorises mmap regions as static or dynamic.
Static regions are fixed for the lifetime of the system. They can only be added early on, before the translation tables are created and populated. They cannot be removed afterwards.
Dynamic regions can be added or removed any time.
When the dynamic memory mapping feature is disabled, only static regions exist.
The dynamic memory mapping feature may be used to map and unmap transient memory areas. This is useful when the user needs to access some memory for a fixed period of time, after which the memory may be discarded and reclaimed. For example, a memory region that is only required at boot time while the system is initializing, or to temporarily share a memory buffer between the normal world and trusted world. Note that it is up to the caller to ensure that these regions are not accessed concurrently while the regions are being added or removed.
Although this feature provides some level of dynamic memory allocation, this does not allow dynamically allocating an arbitrary amount of memory at an arbitrary memory location. The user is still required to declare at compile-time the limits of these allocations ; the library will deny any mapping request that does not fit within this pre-allocated pool of memory.
17.3. Library APIs
The external APIs exposed by this library are declared and documented in the
xlat_tables_v2.h header file. This should be the reference point for
getting information about the usage of the different APIs this library
provides. This section just provides some extra details and clarifications.
mmap_region structure is a publicly visible type, it is not
recommended to populate these structures by hand. Instead, wherever APIs expect
function arguments of type
mmap_region_t, these should be constructed using
MAP_REGION*() family of helper macros. This is to limit the risk of
compatibility breaks, should the
mmap_region structure type evolve in the
MAP_REGION_FLAT() macros do not allow specifying a
mapping granularity, which leaves the library implementation free to choose
it. However, in cases where a specific granularity is required, the
MAP_REGION2() macro might be used instead. Using
to define regions for the MPU library is strongly recommended.
As explained earlier in this document, when the dynamic mapping feature is
disabled, there is no notion of dynamic regions. Conceptually, there are only
static regions. For this reason (and to retain backward compatibility with the
version 1 of the library), the APIs that map static regions do not embed the
word static in their functions names (for example
contrast with the dynamic regions APIs (for example
Although the definition of static and dynamic regions is not based on the state
of the MMU, the two are still related in some way. Static regions can only be
init_xlat_tables() is called and
init_xlat_tables() must be
called while the MMU is still off. As a result, static regions cannot be added
once the MMU has been enabled. Dynamic regions can be added with the MMU on or
off. In practice, the usual call flow would look like this:
The MMU is initially off.
Add some static regions, add some dynamic regions.
Initialize translation tables based on the list of mmap regions (using one of the
At this point, it is no longer possible to add static regions. Dynamic regions can still be added or removed.
Enable the MMU.
Dynamic regions can continue to be added or removed.
Because static regions are added early on at boot time and are all in the
control of the platform initialization code, the
mmap_add*() family of APIs
are not expected to fail. They do not return any error code.
Nonetheless, these APIs will check upfront whether the region can be successfully added before updating the translation context structure. If the library detects that there is insufficient memory to meet the request, or that the new region will overlap another one in an invalid way, or if any other unexpected error is encountered, they will print an error message on the UART. Additionally, when asserts are enabled (typically in debug builds), an assertion will be triggered. Otherwise, the function call will just return straight away, without adding the offending memory region.
17.4. Library limitations
Dynamic regions are not allowed to overlap each other. Static regions are allowed to overlap as long as one of them is fully contained inside the other one. This is allowed for backwards compatibility with the previous behaviour in the version 1 of the library.
17.5. Implementation details
17.5.1. Code structure
The library is divided into 4 modules:
Provides the main functionality of the library, such as the initialization of translation tables contexts and mapping/unmapping memory regions. This module provides functions such as
mmap_add_region_ctxthat let the caller specify the translation tables context affected by them.
Active context module
Instantiates the context that is used by the current BL image and provides helpers to manipulate it, abstracting it from the rest of the code. This module provides functions such as
mmap_add_region, that directly affect the BL image using them.
Provides additional functionality like debug print of the current state of the translation tables and helpers to query memory attributes and to modify them.
Provides functions that are dependent on the current execution state (AArch32/AArch64), such as the functions used for TLB invalidation, setup the MMU, or calculate the Physical Address Space size. They do not need a translation context to work on.
17.5.2. From mmap regions to translation tables
A translation context contains a list of
mmap_region_t, which holds the
information of all the regions that are mapped at any given time. Whenever there
is a request to map (resp. unmap) a memory region, it is added to (resp. removed
The mmap regions list is a conceptual way to represent the memory layout. At some point, the library has to convert this information into actual translation tables to program into the MMU.
init_xlat_tables() API is called, the library only acts on the
mmap regions list. Adding a static or dynamic region at this point through one
mmap_add*() APIs does not affect the translation tables in any way,
they only get registered in the internal mmap region list. It is only when the
user calls the
init_xlat_tables() that the translation tables are populated
in memory based on the list of mmap regions registered so far. This is an
optimization that allows creation of the initial set of translation tables in
one go, rather than having to edit them every time while the MMU is disabled.
init_xlat_tables() API has been called, only dynamic regions can
be added. Changes to the translation tables (as well as the mmap regions list)
will take effect immediately.
17.5.3. The memory mapping algorithm
The mapping function is implemented as a recursive algorithm. It is however bound by the level of depth of the translation tables (the Armv8-A architecture allows up to 4 lookup levels).
By default 1, the algorithm will attempt to minimize the number of translation tables created to satisfy the user’s request. It will favour mapping a region using the biggest possible blocks, only creating a sub-table if it is strictly necessary. This is to reduce the memory footprint of the firmware.
The most common reason for needing a sub-table is when a specific mapping requires a finer granularity. Misaligned regions also require a finer granularity than what the user may had originally expected, using a lot more memory than expected. The reason is that all levels of translation are restricted to address translations of the same granularity as the size of the blocks of that level. For example, for a 4 KiB page size, a level 2 block entry can only translate up to a granularity of 2 MiB. If the Physical Address is not aligned to 2 MiB then additional level 3 tables are also needed.
Note that not every translation level allows any type of descriptor. Depending on the page size, levels 0 and 1 of translation may only allow table descriptors. If a block entry could be able to describe a translation, but that level does not allow block descriptors, a table descriptor will have to be used instead, as well as additional tables at the next level.
The mmap regions are sorted in a way that simplifies the code that maps them. Even though this ordering is only strictly needed for overlapping static regions, it must also be applied for dynamic regions to maintain a consistent order of all regions at all times. As each new region is mapped, existing entries in the translation tables are checked to ensure consistency. Please refer to the comments in the source code of the core module for more details about the sorting algorithm in use.
This mapping algorithm does not apply to the MPU library, since the MPU hardware directly maps regions by “base” and “limit” (bottom and top) addresses.
17.5.4. TLB maintenance operations
The library takes care of performing TLB maintenance operations when required. For example, when the user requests removing a dynamic region, the library invalidates all TLB entries associated to that region to ensure that these changes are visible to subsequent execution, including speculative execution, that uses the changed translation table entries.
A counter-example is the initialization of translation tables. In this case,
explicit TLB maintenance is not required. The Armv8-A architecture guarantees
that all TLBs are disabled from reset and their contents have no effect on
address translation at reset 2. Therefore, the TLBs invalidation
is deferred to the
enable_mmu*() family of functions, just before the MMU is
Regarding enabling and disabling memory management, for the MPU library, to
reduce confusion, calls to enable or disable the MPU use
mpu in their names
in place of
mmu. For example, the
enable_mmu_el2() call is changed to
TLB invalidation is not required when adding dynamic regions either. Dynamic regions are not allowed to overlap existing memory region. Therefore, if the dynamic mapping request is deemed legitimate, it automatically concerns memory that was not mapped in this translation regime and the library will have initialized its corresponding translation table entry to an invalid descriptor. Given that the TLBs are not architecturally permitted to hold any invalid translation table entry 3, this means that this mapping cannot be cached in the TLBs.
That is, when mmap regions do not enforce their mapping granularity.
See section D4.9
Translation Lookaside Buffers (TLBs), subsection
TLB behavior at resetin Armv8-A, rev C.a.
See section D4.10.1
General TLB maintenance requirementsin Armv8-A, rev C.a.
Copyright (c) 2017-2021, Arm Limited and Contributors. All rights reserved.