Mixed-Criticality Sistemler — ASIL-B/D İzolasyon

00 Mixed-criticality kavramı ve ISO 26262 çerçevesi

Mixed-criticality sistem (MCS), farklı güvenlik bütünlüğü seviyelerindeki yazılım bileşenlerinin aynı donanım üzerinde çalıştığı mimaridir. Otomotiv SoC'larında IVI, ADAS ve gövde kontrolü fonksiyonları bu kategoriye girer.

ISO 26262, araç elektrik/elektronik sistemlerinde işlevsel güvenliği standardize eder. E-Gas sistemleri ve fren kontrolü ASIL-D (en yüksek bütünlük) gerektirir; multimedya sistemleri QM veya ASIL-A ile yeterlidir.

Tipik Otomotiv SoC Bölümlendirmesi●

┌─────────────────────────────────────────────────────────────┐
│  Renesas R-Car H3 / NXP i.MX8QM SoC                        │
│                                                             │
│  Cortex-A53 (cluster 0) ──── Linux IVI  [QM / ASIL-A]      │
│  Cortex-A72 (cluster 1) ──── Android Auto / QNX [ASIL-B]   │
│  Cortex-R7  (real-time) ──── AUTOSAR RTOS [ASIL-D]          │
│  Cortex-M4  (MCU)       ──── Safety Monitor [ASIL-D]        │
│                                                             │
│  SMMU/IOMMU ─── DMA izolasyonu                              │
│  TrustZone  ─── Güvenli dünya / Normal dünya                │
│  HSEM       ─── Donanım semafor (çekirdekler arası)         │
└─────────────────────────────────────────────────────────────┘

Jailhouse veya Xen gibi bir hypervisor, bu bölümlendirmeyi yazılım katmanında uygular: her guest sadece kendisine atanmış donanıma ve belleğe erişebilir. Donanım desteği olmadan (SMMU/IOMMU) tam izolasyon mümkün değildir.

01 ASIL seviyeleri ve izolasyon gereksinimleri

ISO 26262'de ASIL, A'dan D'ye dört seviyede tanımlanır. Her seviye, bağımsızlık (independence) ve müdahaleden özgürlük (freedom from interference) gereksinimlerini belirler.

ASIL Seviyeleri●

Seviye  Açıklama                     Tipik Uygulama
────────────────────────────────────────────────────────────
QM      Kalite yönetimi              IVI, multimedya
ASIL-A  Hafif güvenlik gereksinimi   Klima, pencere kontrolü
ASIL-B  Orta düzey                   Şerit değişim uyarısı
ASIL-C  Yüksek                       Fren destek sistemleri
ASIL-D  En yüksek                    Birincil fren, direksiyon

Mixed-criticality izolasyon gereksinimleri

Mekansal izolasyon

QM bileşeni, ASIL-D bileşenin belleğine ve registerlarına erişememelidir. SMMU/IOMMU + MMU ile sağlanır.

Zamansal izolasyon

QM bileşeninin aşırı CPU kullanımı ASIL-D bileşenin zamanlama garantisini bozmamalıdır. CPU pinleme ve cache bölümlendirme ile sağlanır.

Sağlık izleme

ASIL-D monitor, diğer bileşenlerin yaşam belirtisini izler. Watchdog timer ve heartbeat protokolü gerektirir.

Güvenli başlatma

ASIL-D bileşen, QM bileşenlerden bağımsız ve önce başlar. Secure boot zinciri bu sırayı garanti eder.

İzolasyon Mekanizması Matrisi●

Tehdit                  Karşı Önlem              Donanım Desteği
─────────────────────────────────────────────────────────────────
Bellek erişim ihlali    MMU + SMMU               Zorunlu
DMA erişim ihlali       IOMMU                    Zorunlu
CPU zaman çalma         CPU pinleme + scheduler   CPU izolasyonu
Cache thrashing         Cache-way bölümlendirme   L2C-310 / ARM CMN
Interrupt çalma         GIC secure config         TrustZone/GIC-600
Saat manipülasyonu      Ayrı donanım timer        ARM arch timer

02 Aynı SoC'ta IVI + RTOS + Linux — topoloji

Modern otomotiv SoC'ları birden fazla işlemci kümesi barındırır. Bu kümeleri hypervisor ile bölümlendirmek, her uygulamaya izole çalışma ortamı sağlar.

i.MX8QM Mixed-Criticality Topolojisi●

NXP i.MX8QM (Cortex-A72x2 + A53x4 + M4x2)
│
├── Jailhouse Root Cell (Linux)
│     CPUs: A72-core0, A72-core1
│     RAM:  0x80000000 – 0x8FFFFFFF  (256 MB)
│     Cihaz: UART0, USB, PCIe, GigE
│     Görev: Sistem yönetimi, BSP
│
├── Jailhouse Inmate 1: Android IVI
│     CPUs: A53-core0..core3
│     RAM:  0x90000000 – 0xBFFFFFFF  (768 MB)
│     GPU:  GC7000, Display Controller 0
│     ASIL: QM
│
├── Jailhouse Inmate 2: FreeRTOS ADAS
│     CPUs: A72-core2, A72-core3
│     RAM:  0xC0000000 – 0xC7FFFFFF  (128 MB)
│     ASIL: ASIL-B
│
└── Jailhouse Inmate 3: AUTOSAR Safety
      CPUs: M4F-core0
      RAM:  0xC8000000 – 0xC8FFFFFF  (16 MB)
      ASIL: ASIL-D

03 Hypervisor tabanlı izolasyon — Jailhouse yaklaşımı

Jailhouse, statik bölümlendirme yapan Type-1 hypervisordur. Linux çekirdeği içinde modül olarak başlar; root cell Linux'tur, diğer cell'ler inmate olarak çalışır.

root-cell.c — özet (kısaltılmış)●

#include <jailhouse/types.h>
#include <jailhouse/cell-config.h>

struct {
    struct jailhouse_system header;
    __u64  cpus[1];
    struct jailhouse_memory mem_regions[8];
} __attribute__((packed)) config = {
    .header = {
        .signature = JAILHOUSE_SYSTEM_SIGNATURE,
        .revision  = JAILHOUSE_CONFIG_REVISION,
        .hypervisor_memory = {
            .phys_start = 0x7fc00000,
            .size       = 0x00400000,  /* 4 MB */
        },
        .platform_info = {
            .arm = {
                .gicd_base   = 0x51a00000,
                .gicr_base   = 0x51a40000,
                .gic_version = 3,
                .iommu_units = {
                    { .type = JAILHOUSE_IOMMU_SMMU_V3,
                      .base = 0x51400000, .size = 0x20000 },
                },
            },
        },
        .root_cell = {
            .name     = "i.MX8QM Linux",
            .num_cpus = 2,
        },
    },
    .cpus = { 0x3 },  /* CA72 core 0, 1 */
    .mem_regions = {
        { .phys_start = 0x80000000, .virt_start = 0x80000000,
          .size = 0x10000000,
          .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
                   JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA },
        /* UART0, USB, PCIe ... */
    },
};

Jailhouse başlatma ve yönetim

bash●

modprobe jailhouse
jailhouse enable /etc/jailhouse/imx8qm.cell

jailhouse cell create /etc/jailhouse/inmate-freertos.cell
jailhouse cell load   freertos-adas freertos.bin --address 0xC0000000
jailhouse cell start  freertos-adas

# Durum
jailhouse cell list
# ID  Name            State    Assigned CPUs
#  0  i.MX8QM Linux   running  0,1
#  1  freertos-adas   running  2,3
#  2  autosar-safety  running  M4

04 Bellek izolasyonu — IOMMU ve MPU/MMU yapılandırması

Donanım tabanlı bellek izolasyonu olmadan yazılım izolasyonu güvenli değildir. SMMU DMA transferlerini, ARM MMU ise CPU erişimlerini kısıtlar.

SMMU — Device Tree bağlaması

system.dts●

smmu: iommu@51000000 {
    compatible = "arm,smmu-v3";
    reg = <0x0 0x51000000 0x0 0x800000>;
    interrupts = <GIC_SPI 65 IRQ_TYPE_EDGE_RISING>,
                 <GIC_SPI 66 IRQ_TYPE_EDGE_RISING>;
    #iommu-cells = <1>;
    dma-coherent;
};

/* GPU yalnızca IVI cell belleğine DMA yapabilir */
gpu@38000000 {
    compatible = "fsl,imx8-gpu";
    reg = <0x0 0x38000000 0x0 0x80000>;
    iommus = <&smmu 0x200>;
};

ARM MPU — FreeRTOS/AUTOSAR cell

mpu_config.c●

#include "FreeRTOS.h"
#include "task.h"

static const TaskParameters_t safety_task_params = {
    .pvTaskCode   = safety_monitor_task,
    .pcName       = "SafetyMon",
    .usStackDepth = 512,
    .uxPriority   = (configMAX_PRIORITIES - 1) | portPRIVILEGE_BIT,
    .xRegions = {
        {   /* Yalnızca kendi SRAM bölgesine erişim */
            .pvBaseAddress   = (void*)0xC8000000,
            .ulLengthInBytes = 0x8000,
            .ulParameters    = portMPU_REGION_READ_WRITE |
                               portMPU_REGION_EXECUTE_NEVER,
        },
        {   /* Watchdog register */
            .pvBaseAddress   = (void*)0x5A3A0000,
            .ulLengthInBytes = 0x1000,
            .ulParameters    = portMPU_REGION_READ_WRITE |
                               portMPU_REGION_EXECUTE_NEVER |
                               portMPU_REGION_DEVICE_NGNRNE,
        },
        { 0, 0, 0 }
    }
};
xTaskCreateRestricted(&safety_task_params, &safety_task_handle);

05 Zamansal izolasyon — CPU pinleme ve interrupt routing

Zamansal izolasyon, bir partition'ın CPU zamanını aşırı kullanmasının diğerini etkilememesini garanti eder. CPU pinleme bu izolasyonun temelidir.

Linux root cell'de CPU izolasyonu

Kernel parametresi (grub/extlinux)●

isolcpus=2,3,4,5 nohz_full=2,3,4,5 rcu_nocbs=2,3,4,5

bash — affinite ve IRQ yönlendirme●

# Root cell görevlerini CPU 0,1 ile sınırla
for pid in $(ps -e -o pid=); do
    taskset -p 0x3 "$pid" 2>/dev/null
done

# Tüm interrupt'ları CPU 0,1'e yönlendir
for irq in /proc/irq/*/smp_affinity; do
    echo 3 > "$irq" 2>/dev/null
done

# Doğrulama
grep -v "^0" /proc/irq/*/smp_affinity 2>/dev/null | head -5

Intel RDT (Cache Allocation Technology)

bash — LLC bölümlendirme●

mount -t resctrl resctrl /sys/fs/resctrl
# 10 adet L3 way mevcut

# IVI: way 0-4
mkdir /sys/fs/resctrl/ivi
echo "L3:0=01f" > /sys/fs/resctrl/ivi/schemata
echo "2,3"      > /sys/fs/resctrl/ivi/cpus_list

# ADAS: way 5-9
mkdir /sys/fs/resctrl/adas
echo "L3:0=3e0" > /sys/fs/resctrl/adas/schemata
echo "4,5"      > /sys/fs/resctrl/adas/cpus_list

06 virtio-vsock ile güvenli IPC

virtio-vsock, VM/cell'ler arası düşük gecikmeli soket iletişimi sağlar. TCP/IP yükü taşımadan Unix domain socket benzeri API sunar.

Sunucu tarafı (RTOS/Linux cell)

vsock_server.c●

#include <sys/socket.h>
#include <linux/vm_sockets.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define VSOCK_PORT 1234

int main(void)
{
    int srv = socket(AF_VSOCK, SOCK_STREAM, 0);
    struct sockaddr_vm addr = {
        .svm_family = AF_VSOCK,
        .svm_cid    = VMADDR_CID_ANY,
        .svm_port   = VSOCK_PORT,
    };
    bind(srv, (struct sockaddr *)&addr, sizeof(addr));
    listen(srv, 5);

    while (1) {
        struct sockaddr_vm cli;
        socklen_t clen = sizeof(cli);
        int cfd = accept(srv, (struct sockaddr *)&cli, &clen);

        char buf[256];
        ssize_t n = recv(cfd, buf, sizeof(buf) - 1, 0);
        buf[n] = '\0';
        printf("IVI mesajı: %s\n", buf);

        const char *reply = "ACK:ok";
        send(cfd, reply, strlen(reply), 0);
        close(cfd);
    }
}

İstemci tarafı (IVI cell — Python)

vsock_client.py●

import socket

AF_VSOCK   = 40
ADAS_CID   = 3
VSOCK_PORT = 1234

def send_command(cmd):
    s = socket.socket(AF_VSOCK, socket.SOCK_STREAM)
    s.connect((ADAS_CID, VSOCK_PORT))
    s.sendall(cmd.encode())
    reply = s.recv(256).decode()
    s.close()
    return reply

print(send_command("CMD:activate_parking_assist"))

07 IVSHMEM ile paylaşımlı bellek protokolü

IVSHMEM, cell'ler arasında fiziksel bellek paylaşımı için kullanılır. Donanım doorbell interrupt'ları ile bildirim yapılır; yüksek throughput, düşük gecikme sağlar.

ivshmem_layout.h●

#pragma once
#include <stdint.h>
#include <stdatomic.h>

#define RING_CAP 64
#define RING_MASK (RING_CAP - 1)

typedef struct {
    uint32_t type;
    uint32_t seq;
    uint32_t ts_ms;
    uint32_t len;
    uint8_t  data[112];
} __attribute__((packed)) ivshmem_msg_t;

typedef struct {
    _Atomic uint32_t head;
    _Atomic uint32_t tail;
    uint32_t         _pad[14];
    ivshmem_msg_t    slots[RING_CAP];
} ivshmem_ring_t;

typedef struct {
    ivshmem_ring_t  adas_to_ivi;
    ivshmem_ring_t  ivi_to_adas;
    _Atomic uint32_t heartbeat_adas;
    _Atomic uint32_t heartbeat_ivi;
} ivshmem_layout_t;

ivshmem_push — lock-free üretici●

#include "ivshmem_layout.h"
#include <string.h>

static int ivshmem_push(ivshmem_ring_t *r, const ivshmem_msg_t *m)
{
    uint32_t head = atomic_load_explicit(&r->head, memory_order_relaxed);
    uint32_t next = (head + 1) & RING_MASK;
    if (next == atomic_load_explicit(&r->tail, memory_order_acquire))
        return -1;  /* dolu */
    r->slots[head] = *m;
    atomic_store_explicit(&r->head, next, memory_order_release);
    return 0;
}

08 Safety monitor — watchdog ve sağlık izleme

ISO 26262 ASIL-D sistemlerinde bağımsız bir safety monitor, tüm partition'ların yaşam belirtisini izler ve hata durumunda güvenli duruma geçiş kararı verir.

safety_monitor.c — Cortex-M4●

#include <stdint.h>
#include <stdbool.h>
#include "ivshmem_layout.h"
#include "watchdog.h"

#define HB_TIMEOUT_MS  500
#define SAFE_GPIO       27

extern ivshmem_layout_t *shm;

typedef struct {
    const char  *name;
    _Atomic uint32_t *counter;
    uint32_t     last;
    bool         alive;
} partition_t;

static partition_t parts[] = {
    { "Linux-IVI", &shm->heartbeat_ivi,  0, true },
    { "ADAS",      &shm->heartbeat_adas, 0, true },
};

void safety_monitor_task(void *arg)
{
    uint32_t tick = 0;
    while (1) {
        tick += 100;
        for (int i = 0; i < 2; i++) {
            uint32_t hb = atomic_load(parts[i].counter);
            if (hb != parts[i].last) {
                parts[i].last  = hb;
                parts[i].alive = true;
            } else if (tick - parts[i].last * 100 > HB_TIMEOUT_MS) {
                parts[i].alive = false;
                GPIO_Set(SAFE_GPIO, 1);
                uart_puts("SAFE STATE triggered\r\n");
            }
        }
        watchdog_kick();
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

09 Sertifikasyon izleri — kanıt üretimi

ISO 26262 sertifikasyonu için tasarım kararlarının, test sonuçlarının ve izolasyon mekanizmalarının belgelenmesi gerekir.

Statik analiz araçları

Polyspace Bug Finder / Code Prover

MISRA-C:2012 uyumluluğu ve çalışma zamanı hata kanıtı. ASIL-D projelerde zorunlu gibi kullanılır.

LDRA Testbed

Kod kapsama analizi (MC/DC), data flow testi. DO-178C ve ISO 26262 için sertifikalı araç.

cppcheck / clang-analyzer

Açık kaynak alternatifler; ASIL-B seviyesinde kullanılabilir kanıt sağlar.

Bellek izolasyon testi ve sistem kanıtı

isolation_test.sh●

#!/bin/bash
# SMMU hataları — izolasyon ihlali yok olmalı
dmesg | grep -i "smmu.*fault" && echo "HATA: SMMU ihlali" || echo "SMMU: OK"

# Cell çalışma durumu
jailhouse cell list | awk '
    /running/ { ok++ }
    /stopped|fault/ { fail++ }
    END {
        print "Çalışan cell: " ok
        if (fail > 0) print "HATA: " fail " cell durdu/hata"
    }'

# IVSHMEM heartbeat canlılık kontrolü
python3 -c "
import mmap, struct, time
with open('/dev/uio0','r+b') as f:
    shm = mmap.mmap(f.fileno(), 0x100000)
# ADAS heartbeat offset
shm.seek(0x800)
v1 = struct.unpack('I', shm.read(4))[0]
time.sleep(0.5)
shm.seek(0x800)
v2 = struct.unpack('I', shm.read(4))[0]
print('ADAS heartbeat:', 'CANLI' if v2 > v1 else 'ÖLDU')
"

Güvenli Başlatma Zinciri●

ROM Bootloader (donanımda imzalı)
       ↓  RSA-4096 doğrulama
U-Boot (HABv4 imzalı)
       ↓  FIT Image doğrulama
Linux Kernel (imzalı)
       ↓
Jailhouse modül yükleme
       ↓
dm-verity korumalı /etc/jailhouse cell config'leri
       ↓
FreeRTOS + Linux inmate binary'leri (imzalı)