第6章: メモリ保護#

MPU（Memory Protection Unit：アクセスしてよいメモリの範囲を CPU が見張る仕組み）を使ってタスク同士のメモリを守り、暴走を検出します。

この章で分かること: アプリが落ちても、OS が落ちないのはなぜ？

PC では、アプリが 1 つ落ちても、OS やほかのアプリは動き続けます。 OS が、おかしなことをしたプログラムだけを終わらせているからです。

この章では、ゼロ除算や、存在しないアドレスへの書き込みで CPU が起こす例外（フォールト）を OS が受け止めて、起こしたタスクだけを止めます。ほかのタスクは何事もなかったように動き続けます。

サンプルコード#

ディレクトリ: docs/os-on-arduino/code/06_memory_protection
ビルドと書き込み:

uv run pio run -d 06_memory_protection -t upload
uv run pio device monitor -b 115200

コードを見る: docs/os-on-arduino/code/06_memory_protection

ソースコード#

この章のスケッチです。ファイル名をクリックすると開きます。コードは原稿リポジトリから自動で同期されているので、ここに出ているものが常に最新です。

src/main.cpp — 141 行

GitHub で開く

/**
 * Chapter 6: Memory Protection Demo
 *
 * Demonstrates HardFault handling:
 * - Divide by zero detection
 * - Invalid memory access detection
 * - Crashed task termination (other tasks continue)
 */

#include <Arduino.h>
#include "os_kernel.h"
#include "os_fault.h"

// Arduino UNO R4 WiFi は基板上に "L" と印字された LED を持っています。
// 追加部品なしで動かせるよう、これを主 LED として使います。
#define LED_PIN LED_BUILTIN

// Normal task: blinks LED
void task_led(void)
{
    pinMode(LED_PIN, OUTPUT);
    while (1) {
        digitalWrite(LED_PIN, HIGH);
        os_sleep(500);
        digitalWrite(LED_PIN, LOW);
        os_sleep(500);
    }
}

// Normal task: periodic output
void task_heartbeat(void)
{
    int count = 0;
    while (1) {
        Serial.print("[Heartbeat] ");
        Serial.println(count++);
        os_sleep(2000);
    }
}

// Crash task: divide by zero
void task_crash_divzero(void)
{
    Serial.println("[Crash] Dividing by zero in 3 seconds...");
    Serial.flush();
    os_sleep(3000);

    // Ensure Serial is idle before crashing
    Serial.flush();
    os_sleep(100);

    volatile int a = 100;
    volatile int b = 0;
    volatile int c = a / b;  // This will trigger HardFault!
    (void)c;
}

// Crash task: invalid memory access
void task_crash_memory(void)
{
    Serial.println("[Crash] Invalid memory access in 5 seconds...");
    os_sleep(5000);

    volatile uint32_t *bad_ptr = (uint32_t *)0xFFFFFFFF;
    *bad_ptr = 0x12345678;  // This will trigger HardFault!
}

// Shell-like task for control
void task_shell(void)
{
    Serial.println();
    Serial.println("Commands: 'd' = div by zero, 'm' = bad memory, 'p' = ps");

    while (1) {
        // Print any pending fault messages (deferred from ISR context)
        fault_print_pending();

        if (Serial.available()) {
            char c = Serial.read();

            if (c == 'd') {
                Serial.println("Creating div-by-zero crash task...");
                os_create_task(task_crash_divzero, "Crash_Div", 512);
            } else if (c == 'm') {
                Serial.println("Creating bad-memory crash task...");
                os_create_task(task_crash_memory, "Crash_Mem", 512);
            } else if (c == 'p') {
                Serial.println();
                Serial.println("ID  NAME           STATE");
                for (int i = 0; i < os_get_task_count(); i++) {
                    Serial.print(i);
                    Serial.print("   ");
                    Serial.print(os_get_task_name(i));
                    Serial.print("     ");
                    TaskState s = os_get_task_state(i);
                    Serial.println(s == TASK_READY ? "READY" :
                                   s == TASK_RUNNING ? "RUNNING" :
                                   s == TASK_BLOCKED ? "BLOCKED" :
                                   s == TASK_TERMINATED ? "TERMINATED" : "?");
                }
            }
        }
        os_sleep(100);
    }
}

void setup()
{
    Serial.begin(115200);
    while (!Serial) { }

    Serial.println("=== Memory Protection Demo ===");
    Serial.println();
    Serial.println("This demo shows fault handling.");
    Serial.println("When a task crashes, only that task is terminated.");
    Serial.println("Other tasks continue running.");
    Serial.println();

    // Initialize fault handling
    fault_init();

    // Initialize OS
    os_init();

    // Create tasks
    os_create_task(task_led, "LED", 512);
    os_create_task(task_heartbeat, "Heartbeat", 512);
    os_create_task(task_shell, "Shell", 1024);

    Serial.println("Press 'd' for divide-by-zero crash");
    Serial.println("Press 'm' for bad memory access crash");
    Serial.println("Press 'p' to show task list");
    Serial.println();

    os_start();
}

void loop()
{
    // Never reached
}

src/os_fault.cpp — 170 行

GitHub で開く

/**
 * os_fault.cpp - Fault Handler Implementation
 * Chapter 6: Memory Protection
 */

#include "os_fault.h"
#include "os_kernel.h"
#include <Arduino.h>

static volatile int g_fault_occurred = 0;
static volatile const char* g_fault_reason = "";
static volatile int g_faulted_task = -1;

// Forward declarations for vector table override
extern "C" __attribute__((naked)) void HardFault_Handler(void);
extern "C" void PendSV_Handler(void);
extern "C" void SysTick_Handler(void);

void fault_init(void)
{
    // Enable divide by zero trap
    SCB->CCR |= SCB_CCR_DIV_0_TRP_Msk;

    // Do NOT enable separate UsageFault/BusFault/MemFault handlers.
    // By leaving them disabled, all faults escalate to HardFault,
    // which we handle via the VTOR override below.

    // The Arduino framework copies the vector table to RAM (VTOR points to RAM).
    // We must overwrite the HardFault entry in the RAM vector table directly.
    // Also override PendSV and SysTick entries for the OS scheduler.
    uint32_t *vtor = (uint32_t *)SCB->VTOR;
    vtor[3] = (uint32_t)HardFault_Handler;   // Vector #3 = HardFault
    vtor[14] = (uint32_t)PendSV_Handler;     // Vector #14 = PendSV
    vtor[15] = (uint32_t)SysTick_Handler;    // Vector #15 = SysTick

    g_fault_occurred = 0;
    g_fault_reason = "";
}

const char* fault_get_reason(void)
{
    return (const char*)g_fault_reason;
}

int fault_occurred(void)
{
    return g_fault_occurred;
}

void fault_clear(void)
{
    g_fault_occurred = 0;
    g_fault_reason = "";
}

static void analyze_fault(void)
{
    uint32_t cfsr = SCB->CFSR;

    // Check Usage Fault Status Register (UFSR)
    if (cfsr & SCB_CFSR_DIVBYZERO_Msk) {
        g_fault_reason = "Divide by zero";
    } else if (cfsr & SCB_CFSR_UNALIGNED_Msk) {
        g_fault_reason = "Unaligned access";
    } else if (cfsr & SCB_CFSR_UNDEFINSTR_Msk) {
        g_fault_reason = "Undefined instruction";
    } else if (cfsr & SCB_CFSR_INVSTATE_Msk) {
        g_fault_reason = "Invalid state (Thumb bit)";
    } else if (cfsr & SCB_CFSR_INVPC_Msk) {
        g_fault_reason = "Invalid PC";
    }
    // Check Bus Fault Status Register (BFSR)
    else if (cfsr & SCB_CFSR_PRECISERR_Msk) {
        g_fault_reason = "Precise data bus error";
    } else if (cfsr & SCB_CFSR_IMPRECISERR_Msk) {
        g_fault_reason = "Imprecise data bus error";
    } else if (cfsr & SCB_CFSR_IBUSERR_Msk) {
        g_fault_reason = "Instruction bus error";
    }
    // Check Memory Management Fault Status Register (MMFSR)
    else if (cfsr & SCB_CFSR_DACCVIOL_Msk) {
        g_fault_reason = "Data access violation";
    } else if (cfsr & SCB_CFSR_IACCVIOL_Msk) {
        g_fault_reason = "Instruction access violation";
    }
    else {
        g_fault_reason = "Unknown fault";
    }

    // Clear fault flags
    SCB->CFSR = cfsr;
}

// Safe landing pad for terminated tasks after fault recovery
extern "C" void _fault_task_sink(void)
{
    while (1) {
        __WFI();
    }
}

// Flag to defer fault message printing to a safe context
static volatile int g_fault_pending_print = 0;
static volatile uint32_t g_fault_pc = 0;

extern "C" void HardFault_Handler_C(FaultFrame *frame)
{
    g_fault_occurred = 1;
    g_faulted_task = g_current_task;
    g_fault_pc = frame->pc;

    analyze_fault();

    // Terminate the faulted task and redirect PC to safe sink
    if (g_faulted_task > 0) {
        os_terminate_task(g_faulted_task);

        // Rewrite the stacked PC to a safe infinite loop so that
        // returning from the fault doesn't re-execute the faulting
        // instruction. The SysTick scheduler will switch away from
        // this terminated task on the next tick.
        frame->pc = (uint32_t)_fault_task_sink;
        frame->xpsr = 0x01000000;  // Thumb bit set

        // Defer printing to next safe context
        g_fault_pending_print = 1;
        return;
    }

    // If idle task or no task crashed, halt
    while (1) { }
}

// Call this from a task (e.g., shell) to print deferred fault info
void fault_print_pending(void)
{
    if (!g_fault_pending_print) return;
    g_fault_pending_print = 0;

    Serial.println();
    Serial.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    Serial.println("!!!       FAULT DETECTED      !!!");
    Serial.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    Serial.println();
    Serial.print("Task ");
    Serial.print(g_faulted_task);
    Serial.print(" (");
    Serial.print(os_get_task_name(g_faulted_task));
    Serial.println(") crashed!");
    Serial.print("Reason: ");
    Serial.println((const char*)g_fault_reason);
    Serial.print("PC at fault: 0x");
    Serial.println(g_fault_pc, HEX);
    Serial.println("Task terminated. Other tasks continue.");
    Serial.println();
}

extern "C" __attribute__((naked)) void HardFault_Handler(void)
{
    __asm volatile (
        "   TST     LR, #4              \n"  // Check which stack was used
        "   ITE     EQ                  \n"
        "   MRSEQ   R0, MSP             \n"  // MSP if LR bit 2 is 0
        "   MRSNE   R0, PSP             \n"  // PSP if LR bit 2 is 1
        "   PUSH    {LR}                \n"  // Save EXC_RETURN
        "   BL      HardFault_Handler_C \n"  // Call C handler (preserves LR on stack)
        "   POP     {LR}                \n"  // Restore EXC_RETURN
        "   BX      LR                  \n"  // Return from exception properly
    );
}

src/os_kernel.cpp — 219 行

GitHub で開く

/**
 * os_kernel.cpp - Mini OS Kernel Implementation
 * Chapter 6: Memory Protection
 */

#include "os_kernel.h"
#include <Arduino.h>
#include <string.h>

TCB g_tasks[MAX_TASKS];
volatile int g_task_count = 0;
volatile int g_current_task = -1;
volatile int g_next_task = -1;
volatile uint32_t g_system_ticks = 0;

const uint32_t g_tcb_size = sizeof(TCB);

static uint32_t g_stack_pool[STACK_POOL_SIZE / 4];
static uint32_t g_stack_used;   // 切り出し済みのワード数

static void idle_task(void) { while (1) __WFI(); }

// タスク関数が return したときの受け皿。例外フレームの LR スロットは
// ここを指す (第3章 3.4)。EXC_RETURN を置く場所ではない。
static void task_exit(void)
{
    g_tasks[g_current_task].state = TASK_TERMINATED;
    os_yield();
    while (1) { }  // ここには到達しない
}

static uint32_t* init_task_stack(uint32_t *stack_top, void (*entry)(void))
{
    uint32_t *sp = stack_top;
    *(--sp) = 0x01000000;
    *(--sp) = (uint32_t)entry;
    *(--sp) = (uint32_t)task_exit;  // LR: タスクが return したときの戻り先
    *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0;
    *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0;
    *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0;
    return sp;
}

void os_init(void)
{
    memset(g_tasks, 0, sizeof(g_tasks));
    g_task_count = 0;
    g_current_task = -1;
    g_next_task = -1;
    g_system_ticks = 0;
    os_create_task(idle_task, "idle", IDLE_STACK_SIZE);
}

int os_create_task(void (*entry)(void), const char *name, uint32_t stack_size)
{
    if (g_task_count >= MAX_TASKS) return -1;
    int id = g_task_count;
    TCB *task = &g_tasks[id];
    task->id = id;
    task->state = TASK_READY;
    task->priority = id;
    task->entry = entry;
    task->wake_tick = 0;
    task->cpu_ticks = 0;
    strncpy(task->name, name, sizeof(task->name) - 1);
    if (stack_size == 0) {
        stack_size = DEFAULT_STACK_SIZE;
    }
    uint32_t words = (stack_size + 3) / 4;
    if (g_stack_used + words > STACK_POOL_SIZE / 4) {
        return -1;          // プールが尽きた。黙って縮めず、失敗として返す
    }
    g_stack_used += words;
    task->stack_size = stack_size;
    task->stack_base = &g_stack_pool[g_stack_used];   // スタックは上端から下へ伸びる
    task->sp = init_task_stack(task->stack_base, entry);
    g_task_count++;
    return id;
}

void os_schedule(void)
{
    for (int i = 0; i < g_task_count; i++) {
        if (g_tasks[i].state == TASK_BLOCKED && g_system_ticks >= g_tasks[i].wake_tick) {
            g_tasks[i].state = TASK_READY;
        }
    }

    int next = g_current_task;
    do {
        next = (next + 1) % g_task_count;
        if (g_tasks[next].state == TASK_READY || g_tasks[next].state == TASK_RUNNING) break;
    } while (next != g_current_task);

    if (next != g_current_task || g_current_task < 0) {
        if (g_current_task >= 0 && g_tasks[g_current_task].state == TASK_RUNNING) {
            g_tasks[g_current_task].state = TASK_READY;
        }
        g_tasks[next].state = TASK_RUNNING;
        g_next_task = next;
        SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;
    }
}

void os_yield(void) { os_schedule(); }
void os_sleep(uint32_t ms) {
    if (g_current_task > 0) {
        g_tasks[g_current_task].state = TASK_BLOCKED;
        g_tasks[g_current_task].wake_tick = g_system_ticks + ms;
        os_schedule();
    }
}
void os_suspend_task(int id) {
    if (id > 0 && id < g_task_count) {
        g_tasks[id].state = TASK_SUSPENDED;
        if (id == g_current_task) os_schedule();
    }
}
void os_resume_task(int id) {
    if (id > 0 && id < g_task_count && g_tasks[id].state == TASK_SUSPENDED) {
        g_tasks[id].state = TASK_READY;
    }
}
void os_terminate_task(int id) {
    if (id > 0 && id < g_task_count) {
        g_tasks[id].state = TASK_TERMINATED;
        if (id == g_current_task) os_schedule();
    }
}

uint32_t os_get_tick(void) { return g_system_ticks; }
int os_get_task_count(void) { return g_task_count; }
const char* os_get_task_name(int id) { return (id >= 0 && id < g_task_count) ? g_tasks[id].name : ""; }
TaskState os_get_task_state(int id) { return (id >= 0 && id < g_task_count) ? g_tasks[id].state : TASK_TERMINATED; }
int os_get_current_task(void) { return g_current_task; }

void os_start(void)
{
    NVIC_SetPriority(PendSV_IRQn, 0xFF);
    SysTick_Config(SystemCoreClock / 1000 * TIME_SLICE_MS);
    g_current_task = -1;
    g_next_task = 0;
    // Do NOT switch CONTROL to PSP here — PSP is not yet initialized.
    // PendSV returns with EXC_RETURN=0xFFFFFFFD, which automatically
    // switches thread mode to PSP after loading the first task's context.
    SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;
    while (1) { }
}

extern "C" void SysTick_Handler(void) {
    // 実際に経過した時間を、いま走っていたタスクの取り分として計上する。
    // os_schedule() 側で数えると os_yield() の回数まで混ざってしまう。
    if (g_current_task >= 0) {
        g_tasks[g_current_task].cpu_ticks += TIME_SLICE_MS;
    }
    g_system_ticks += TIME_SLICE_MS;
    os_schedule();
}

extern "C" __attribute__((naked)) void PendSV_Handler(void)
{
    __asm volatile (
        "   MRS     R0, PSP              \n"
        "   LDR     R1, =g_current_task  \n"
        "   LDR     R2, [R1]             \n"
        "   CMP     R2, #0               \n"
        "   BLT     _skip_save           \n"
        // Save R4-R11 only when there is a valid current task
        "   STMDB   R0!, {R4-R11}        \n"
        "   LDR     R3, =g_tasks         \n"
        "   LDR     R4, =g_tcb_size      \n"
        "   LDR     R4, [R4]             \n"
        "   MUL     R2, R2, R4           \n"
        "   ADD     R3, R3, R2           \n"
        "   STR     R0, [R3]             \n"
        "_skip_save:                     \n"
        "   LDR     R1, =g_next_task     \n"
        "   LDR     R2, [R1]             \n"
        "   LDR     R1, =g_current_task  \n"
        "   STR     R2, [R1]             \n"
        "   LDR     R3, =g_tasks         \n"
        "   LDR     R4, =g_tcb_size      \n"
        "   LDR     R4, [R4]             \n"
        "   MUL     R2, R2, R4           \n"
        "   ADD     R3, R3, R2           \n"
        "   LDR     R0, [R3]             \n"
        "   LDMIA   R0!, {R4-R11}        \n"
        "   MSR     PSP, R0              \n"
        "   LDR     LR, =0xFFFFFFFD      \n"
        "   BX      LR                   \n"
    );
}

// CPU使用率を取得（パーセント）
// 直前にこの関数を呼んだ時点からの差分で計算する。
// ps のようにタスクごとにループで呼ぶため、基準時刻もタスクごとに持つ。
int os_get_cpu_usage(int task_id)
{
    if (task_id < 0 || task_id >= g_task_count) {
        return -1;
    }

    static uint32_t last_total[MAX_TASKS] = {0};
    static uint32_t last_task_ticks[MAX_TASKS] = {0};

    uint32_t total = g_system_ticks;
    uint32_t delta_total = total - last_total[task_id];

    if (delta_total == 0) {
        return 0;
    }

    uint32_t delta_task = g_tasks[task_id].cpu_ticks - last_task_ticks[task_id];

    last_total[task_id] = total;
    last_task_ticks[task_id] = g_tasks[task_id].cpu_ticks;

    return (delta_task * 100) / delta_total;
}

実機での出力#

Arduino UNO R4 WiFi の実機で実際に取得した出力です（macOS / Windows の両方で同じ結果を確認しています）。手元の出力と見比べてください。

d を送ってゼロ除算タスクを作ると、そのタスクだけが TERMINATED になり、Heartbeat は動き続けます。

コマンドは 1 文字です。d はゼロ除算を起こすタスク（Crash_Div）を、m は 5 秒後に不正なアドレス（0xFFFFFFFF）へ書き込むタスク（Crash_Mem）を作ります。p はタスクの一覧を表示します。

../_images/ch06_fault.gif — `p` でタスクを見て、`d` でゼロ除算を起こしたところ。fault のあとも `Heartbeat` が途切れず、`Crash_Div` だけが `TERMINATED` になります#

ID  NAME           STATE
0   idle     READY
1   LED     BLOCKED
2   Heartbeat     BLOCKED
3   Shell     RUNNING
[Heartbeat] 2
Creating div-by-zero crash task...
[Crash] Dividing by zero in 3 seconds...
[Heartbeat] 3

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!       FAULT DETECTED      !!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Task 4 (Crash_Div) crashed!
Reason: Divide by zero
PC at fault: 0x41BA
Task terminated. Other tasks continue.

[Heartbeat] 4
[Heartbeat] 5

ID  NAME           STATE
0   idle     READY
1   LED     BLOCKED
2   Heartbeat     BLOCKED
3   Shell     RUNNING
4   Crash_Div     TERMINATED
[Heartbeat] 6
[Heartbeat] 7
[Heartbeat] 8
[Heartbeat] 9

PC at fault の PC（プログラムカウンタ）は、落ちた命令のアドレスです。

シミュレータで見る#

実機が無くても、同じファームウェアをシミュレータで動かすとこう見えます。

../_images/sim_ch06_fault.gif — `d` を送ると `Crash_Div` タスクがゼロ除算でフォールトを起こし、`FAULT DETECTED` と原因が出ます。そのあとも L（Heartbeat）の点滅と `[Heartbeat]` の出力は続きます。（シミュレータで撮影）#

壊してみる#

予想してから答えを開いてください。1 つめはコードを変えずに、ブラウザ版の第6章でそのまま試せます。2 つめはコードを変えてビルドし、firmware.elf をブラウザ版にドロップします。

注釈

答えに載せた出力は、ブラウザ版と同じ QEMU で実際に動かして取ったものです。実機ではまだ確かめていません。

1. 続けて 5 回落とす#

d を 5 回続けて送り、しばらく待ってから p でタスクの一覧を出します。

予想: FAULT DETECTED は何回出るでしょう。

2. ゼロ除算の見張りを外す#

src/os_fault.cpp の fault_init() で、ゼロ除算を例外にする設定をコメントにします。

-    SCB->CCR |= SCB_CCR_DIV_0_TRP_Msk;
+    // SCB->CCR |= SCB_CCR_DIV_0_TRP_Msk;

予想: d を送ると、100 / 0 はどうなるでしょう。

つまずきやすいポイント#

（読者からの質問に応じて随時追記します。質問は GitHub Issues へどうぞ）