Memory Protection Unit Configuration

Configure the MPU to enforce memory safety by defining access permissions for hardware regions.

In this lesson, you will learn how to harden your embedded application against buffer overflows and illegal memory access by defining granular access permissions via the Memory Protection Unit (MPU).

Defining Memory Boundaries

The MPU is a hardware peripheral that allows you to divide your processor's memory map into distinct regions. While the MMU (Memory Management Unit) is common in high-level OS development for virtual memory, the MPU is the standard tool in bare-metal Rust to enforce physical memory safety. By configuring the MPU, you instruct the hardware to trigger a HardFault or MemManage exception the moment a pointer attempts to touch memory outside of its permitted bounds.

Rust Implementation Pattern

In a typical Rust embedded project, you configure the MPU using a Peripheral Access Crate (PAC) or a Hardware Abstraction Layer (HAL). The goal is to define regions—such as Read-Only for flash (code) and Read-Write for SRAM (stack/heap)—while marking peripheral regions as Execute-Never (XN) to prevent code injection.

Consider this conceptual configuration for an ARM Cortex-M architecture:

let mut mpu = dp.MPU;
// Disable MPU for configuration
mpu.ctrl.modify(|_, w| w.enable().disabled());

// Region 0: Flash memory (Read-only, Executable)
mpu.rnr.write(|w| unsafe { w.region().bits(0) });
mpu.rbar.write(|w| unsafe { w.addr().bits(0x0800_0000) });
mpu.rasr.write(|w| unsafe { 
    w.size().k64() // Define size
     .ap().pr_ro()  // Privileged/Unprivileged Read-Only
     .xn().disable() // Executable
     .enable().set_bit() 
});

mpu.ctrl.modify(|_, w| w.enable().enabled());

Why This Matters

By configuring these regions, you transform a silent memory corruption bug—which could lead to unpredictable behavior or security vulnerabilities—into a deterministic hardware exception. If your application attempts to write to a constant flash variable or execute instructions from the stack, the MPU halts the system immediately. This provides a vital line of defense when working with unsafe blocks, ensuring that even if a pointer offset goes awry, the hardware prevents the instruction from completing.

Key Takeaway: The MPU acts as your final gatekeeper in hardware, converting undefined memory access behavior into actionable, deterministic system exceptions.