Bus fault and memory protection in ARM Architecture

Introduction

A bus fault happens when the processor tries to access memory or a device incorrectly. Memory protection helps stop programs from using memory they shouldn't, keeping the system safe and stable.

When designing a system that needs to prevent programs from crashing the whole device by accessing wrong memory.

When debugging why a program suddenly stopped working due to illegal memory access.

When setting up hardware to catch errors caused by faulty memory or devices.

When implementing security features to stop malicious code from reading or writing protected memory.

Core Concept

ARM Architecture

Bus Fault Handler:
  - Triggered on bus fault exception
  - Reads fault status registers
  - Identifies fault cause and address
  - Takes corrective action or resets system

Memory Protection Unit (MPU) Configuration:
  - Define memory regions with start address and size
  - Set access permissions (read/write/execute)
  - Enable or disable regions
  - Enable MPU to enforce rules

The Bus Fault Handler is part of the exception system in ARM processors.

The MPU is a hardware feature that controls access rights to memory regions.

Key Points

This is a simple bus fault handler reading fault status and address.

ARM Architecture

void BusFault_Handler(void) {
  uint32_t fault_status = SCB->CFSR & 0xFF;
  uint32_t fault_address = SCB->BFAR;
  // Analyze fault_status and fault_address
  // Take action like logging or reset
}

This configures MPU region 0 with 32KB size and read/write permission.

ARM Architecture

MPU->RNR = 0; // Select region 0
MPU->RBAR = 0x20000000; // Base address
MPU->RASR = (size_32KB << 1) | (read_write_permission) | (enable_region);
MPU->CTRL = MPU_CTRL_ENABLE_Msk | MPU_CTRL_PRIVDEFENA_Msk;

Detailed Explanation

This program sets up the MPU to allow access only to a 32KB RAM region. Accessing outside this region causes a bus fault, which is handled by BusFault_Handler that stops the system.

ARM Architecture

/* Example: Simple Bus Fault Handler and MPU setup */
#include "stm32f4xx.h" // Example ARM Cortex-M header

void BusFault_Handler(void) {
  uint32_t fault_status = SCB->CFSR & 0xFF;
  uint32_t fault_address = SCB->BFAR;
  // Print or log fault info (pseudo code)
  // printf("Bus Fault at address: 0x%08X, status: 0x%02X\n", fault_address, fault_status);
  while(1); // Halt system
}

void MPU_Config(void) {
  MPU->CTRL = 0; // Disable MPU

  MPU->RNR = 0; // Select region 0
  MPU->RBAR = 0x20000000; // Base address of RAM
  MPU->RASR = (0x0B << 1) | (0x03 << 24) | (1 << 0); // 32KB size, full access, enable

  MPU->CTRL = MPU_CTRL_ENABLE_Msk | MPU_CTRL_PRIVDEFENA_Msk; // Enable MPU with default map
}

int main(void) {
  MPU_Config();
  // Access memory normally
  int *ptr = (int *)0x20000000;
  *ptr = 123; // Allowed

  // Access invalid memory to cause bus fault
  int *bad_ptr = (int *)0x08000000; // Flash region not allowed
  *bad_ptr = 456; // This triggers BusFault_Handler

  while(1);
}

Important Notes

Bus faults help catch errors early before they cause bigger problems.

MPU settings must be carefully planned to avoid blocking needed memory access.

BusFault_Handler usually halts or resets the system to prevent damage.

Summary

Bus faults occur when the processor accesses invalid memory or devices.

Memory Protection Units control which memory areas can be accessed and how.

Handling bus faults and configuring MPU improves system safety and stability.