hakmem/docs/RAPID_DIAGNOSIS_CANARY_SANDWICH.md

# 🎯 最速診断法: Canary Sandwich 検査 (2025-12-04)

**目的**: 180秒クラッシュの**破壊パターン**を検出し、根本原因を特定

**戦略**: TLS SLL の周囲に "Canary" (検査値) を配置し、いつ/どこで破壊されるかを追跡

---

## 📊 Canary Sandwich の層構造

```
=== Before TLS SLL ===
g_tls_canary_before_sll = 0xDEADBEEFDEADBEEF
  ↓
=== TLS SLL Array (8 classes × sizeof(TinyTLSSLL)) ===
g_tls_sll[0..7] {
  head: hak_base_ptr_t
  count: uint32_t
}
  ↓
=== After TLS SLL ===
g_tls_canary_after_sll = 0xDEADBEEFDEADBEEF
  ↓
=== Canary in each class ===
g_tls_sll_canary[0..7] = 0xBADC0FFEEBADC0FFE
```

---

## 🔍 検査ポイント（5箇所）

### Point 1: TLS SLL 配列のメモリレイアウト確認

```bash
# gdb スクリプト
print &g_tls_canary_before_sll
print &g_tls_sll[0]
print &g_tls_sll[7]
print &g_tls_canary_after_sll
print sizeof(g_tls_sll)
print sizeof(TinyTLSSLL)
```

**期待値**:
- `before < &sll[0]` (before は sll の前)
- `&sll[7] < after` (after は sll の後)
- レイアウトが連続

**崩れたら**:
- コンパイラが変わった可能性
- 構造体パディングが変わった

---

### Point 2: Canary の破壊チェック（180秒時点）

修正: `core/hakmem_tiny.c` に定期検査を追加

```c
// hakmem_tiny.c に追加
static void check_tls_sll_canaries(void) {
    // 5秒ごとに実行（background thread または refill時に）

    // Check 1: before/after canary
    const uint64_t EXPECTED = 0xDEADBEEFDEADBEEFULL;
    extern __thread uint64_t g_tls_canary_before_sll;
    extern __thread uint64_t g_tls_canary_after_sll;

    if (g_tls_canary_before_sll != EXPECTED) {
        fprintf(stderr,
            "[CANARY_BROKEN_BEFORE] expected=%#llx got=%#llx\n",
            EXPECTED, g_tls_canary_before_sll);
        // フルダンプ
        dump_tls_sll_state();
        abort();
    }

    if (g_tls_canary_after_sll != EXPECTED) {
        fprintf(stderr,
            "[CANARY_BROKEN_AFTER] expected=%#llx got=%#llx\n",
            EXPECTED, g_tls_canary_after_sll);
        dump_tls_sll_state();
        abort();
    }

    // Check 2: 各 class の count overflow
    for (int i = 0; i < TINY_NUM_CLASSES; i++) {
        if (g_tls_sll[i].count > 10000) {  // 異常値
            fprintf(stderr,
                "[SLL_COUNT_OVERFLOW] cls=%d count=%u\n",
                i, g_tls_sll[i].count);
            dump_tls_sll_state();
            abort();
        }
    }
}
```

---

### Point 3: Head ポインタの破壊パターン

180秒時点での head 値をキャプチャ:

```c
// tls_sll_push_impl 内に追加 (line 737 近辺)

static __thread int push_count = 0;
push_count++;

// 180秒ぐらい = 60 million operations なら、50 million+ で検査
if (push_count > 50000000) {
    fprintf(stderr, "[PUSH_COUNT_CRITICAL] cls=%d count=%d head=%p sll_count=%u\n",
        class_idx, push_count,
        HAK_BASE_TO_RAW(g_tls_sll[class_idx].head),
        g_tls_sll[class_idx].count);

    // Head が valid range か？
    uintptr_t head_addr = (uintptr_t)HAK_BASE_TO_RAW(g_tls_sll[class_idx].head);
    if (head_addr < 4096 || head_addr > 0x00007fffffffffffULL) {
        fprintf(stderr, "[HEAD_OUT_OF_RANGE] cls=%d head=%p\n",
            class_idx, HAK_BASE_TO_RAW(g_tls_sll[class_idx].head));
        dump_tls_sll_state();
        abort();
    }
}
```

---

### Point 4: Freelist Chain の整合性

`sll_refill_small_from_ss` line 334 に挿入:

```c
// freelist から p を取得した直後
if (meta->freelist) {
    p = meta->freelist;
    void* next_raw;
    PTR_NEXT_READ("refill_check", class_idx, p, 0, next_raw);

    // next が妥当なメモリアドレス か？
    uintptr_t next_addr = (uintptr_t)next_raw;

    // Check 4a: NULL が妥当 (freelist の終端)
    if (next_raw == NULL) {
        // OK
    }
    // Check 4b: 有効なアドレス範囲
    else if (next_addr >= 4096 && next_addr <= 0x00007fffffffffffULL) {
        // OK - 有効そう
    }
    // Check 4c: SuperSlab に属しているか確認
    else {
        SuperSlab* ss_check = hak_super_lookup(next_raw);
        if (!ss_check || ss_check->magic != SUPERSLAB_MAGIC) {
            fprintf(stderr,
                "[FREELIST_NEXT_INVALID] cls=%d p=%p next=%p from_ss=%p\n",
                class_idx, p, next_raw, ss_check);
            dump_tls_sll_state();
            abort();
        }
    }

    meta->freelist = next_raw;
    // ...
}
```

---

### Point 5: Stride 計算の確認

`sll_refill_small_from_ss` line 355 に挿入:

```c
// Carve path での addr 計算
else if (meta->carved < meta->capacity) {
    uint8_t* base = tls->slab_base ? tls->slab_base :
                    tiny_slab_base_for_geometry(tls->ss, tls->slab_idx);
    if (!base) break;

    uint16_t idx = meta->carved;
    if (idx >= meta->capacity) break;

    const size_t stride = tiny_stride_for_class(class_idx);

    // Check 5: stride が 0 でないか、overflow していないか
    if (stride == 0 || stride > 100000) {
        fprintf(stderr,
            "[STRIDE_INVALID] cls=%d stride=%zu idx=%u cap=%u\n",
            class_idx, stride, idx, meta->capacity);
        dump_tls_sll_state();
        abort();
    }

    uint8_t* addr = base + ((size_t)idx * stride);

    // Check 5b: addr がベースのメモリ範囲内か
    // (簡易チェック: base より後ろ、かつ reasonable offset)
    uintptr_t base_addr = (uintptr_t)base;
    uintptr_t addr_addr = (uintptr_t)addr;
    size_t max_offset = (size_t)meta->capacity * stride;

    if (addr_addr < base_addr || (addr_addr - base_addr) > max_offset) {
        fprintf(stderr,
            "[ADDR_OUT_OF_BOUNDS] cls=%d base=%p addr=%p offset=%zu max=%zu\n",
            class_idx, base, addr, (addr_addr - base_addr), max_offset);
        dump_tls_sll_state();
        abort();
    }

    meta->carved++;
    meta->used++;
    // ...
    p = addr;
}
```

---

## 🛠️ 実装手順

### ステップ 1: Canary 初期化（hakmem_tiny.c）

既にあるはずだが、確認:

```bash
grep -n "g_tls_canary_before_sll\|g_tls_canary_after_sll" /mnt/workdisk/public_share/hakmem/core/hakmem_tiny.c | head -20
```

**存在なら**: Point 4-5 の挿入に進む
**存在なし**: Canary の初期化を追加

---

### ステップ 2: Point 4-5 検査の挿入

ファイル: `core/hakmem_tiny_refill.inc.h`

- Line 334 (freelist 処理) に Point 4 挿入
- Line 355 (carve 処理) に Point 5 挿入

---

### ステップ 3: ビルド & テスト

```bash
cd /mnt/workdisk/public_share/hakmem
make clean && make RELEASE=0  # デバッグモード有効

# テスト
timeout 190 env LD_PRELOAD=./libhakmem.so \
  ./mimalloc-bench/out/bench/sh8bench 2>&1 | tail -50
```

**期待される出力**:
- 180秒前後で **制御されたabort()** が発生
- `[CANARY_*]`, `[FREELIST_*]`, `[ADDR_*]` のいずれかのログが表示
- そのログから破壊パターンが明確になる

---

## 📋 Canary Sandwich の利点

1. **最速診断**: クラッシュの 1 秒前に検知 → 詳細ログ
2. **破壊パターン特定**: どの構造体が壊れたか明白
3. **根本原因推定**: パターンから原因が逆算可能
4. **非侵襲的**: 既存コードを大きく変更しない

---

## 🎯 予想される結果

| 破壊パターン | 原因 | 修正 |
|-----------|------|------|
| `CANARY_BROKEN_BEFORE` | g_tls_sll の手前がバッファオーバーフロー | Stack corruption / グローバル領域破壊 |
| `CANARY_BROKEN_AFTER` | g_tls_sll の後ろが上書き | グローバル領域破壊 |
| `FREELIST_NEXT_INVALID` | freelist の next が破壊 | Double-free / heap corruption |
| `ADDR_OUT_OF_BOUNDS` | carve 計算がオーバーフロー | Integer overflow / stride 計算エラー |
| `HEAD_OUT_OF_RANGE` | TLS head が破壊 | TLS SLL push 側のバグ |

---

## ✅ 実装チェックリスト

- [ ] Point 1: メモリレイアウト確認（gdb）
- [ ] Point 2: Canary 破壊チェック実装
- [ ] Point 3: Head ポインタ破壊検査実装
- [ ] Point 4: Freelist chain 整合性検査実装
- [ ] Point 5: Stride 計算検査実装
- [ ] ビルド成功
- [ ] 180秒テスト実行 → ログ解析

---

**作成日**: 2025-12-04
**方法**: Canary Sandwich - 5層の防御で破壊を検出