Rust 进军安全关键系统：AUTOSAR Adaptive 与 ISO 26262 的嵌入式 Rust 工程实践

当汽车行业加速迈向软件定义（Software-Defined Vehicle），安全关键系统对代码可靠性的要求达到了前所未有的高度。传统上，这些系统使用 C/C++ 并通过 MISRA C/C++ 编码规范约束来保证安全性。但随着 Rust 语言的成熟，其所有权系统和借用检查器在编译期就消除了内存安全问题——这在航空DO-178C、汽车ISO 26262 等最高功能安全标准中有着天然的吸引力。本文将从工程实践角度深入拆解 Rust 在安全关键系统中的落地路径，分析其与 AUTOSAR Adaptive 平台的集成方案、FFI 互操作策略、认证挑战，并给出完整的实时代码示例。

一、为什么安全关键系统开始关注 Rust

安全关键系统的核心诉求是在任何情况下都能保证确定性行为——即便面对内存泄漏、数据竞争、空指针这类"常见"问题，也必须做到零容忍。C/C++ 的应对方案是编码规范（MISRA C:2012、AUTOSAR C++14）加静态分析加测试覆盖，本质上是通过"约束开发者"来规避语言缺陷。

Rust 从根本上重新定义了这场博弈：

┌─────────────────────────────────────────────────────────────┐
│          传统 C/C++ 安全开发模式                              │
│  编码规范(MISRA) → 静态分析(Polyspace) → 单元测试 → 代码审查  │
│            ↑ 层层人工保障，成本高昂                           │
├─────────────────────────────────────────────────────────────┤
│          Rust 安全保证模式                                    │
│  编译器强制(Ownership/Borrow Check) → 可选静态分析 → 测试     │
│            ↑ 语言级保证，不可绕过                             │
└─────────────────────────────────────────────────────────────┘

关键区别在于，Rust 的所有权系统让以下问题在编译期就被捕获：悬垂指针、两次释放、数据竞争、迭代器失效、未初始化内存读取。这些问题在 C/C++ 中需要大量运行时测试和人工审查才能发现。

根据 Lyon 大学和 INRIA 2024 年发表的研究数据，在受控实验中，相同的传感器数据处理算法用 Rust 实现相比 C 实现，内存安全缺陷率下降了约 82%，且代码量减少约 23%（得益于模式匹配和错误处理的简洁性）。

二、AUTOSAR Adaptive 与 Rust 的集成架构

AUTOSAR Adaptive 平台是面向高性能车用 SoC（如高通 SA8155、NXP S32G）的软件框架，基于 POSIX 操作系统（QLinux、INTEGRITY），支持 SOME/IP 通信、服务发现、远程诊断等。其核心组件 ara::com（通信）和 ara::exec（执行管理）原生使用 C++14/17 实现。

那么在 AUTOSAR Adaptive 中集成 Rust 有三种工程路径：

路径一：Rust 微服务 + ara::com 桥接

将 Rust 实现的功能封装为独立的 POSIX 进程，通过 SOME/IP 与 AUTOSAR Adaptive 的 C++ 组件通信。这是当前最成熟的方案——不需要修改 AUTOSAR 框架本身。

┌──────────────────┐     SOME/IP      ┌──────────────────────┐
│  Rust 微服务      │ ←──────────────→ │  AUTOSAR Adaptive    │
│  (感知/规划算法)   │   vsomeip 共享内存 │  (C++17 ara::com)    │
│  进程隔离崩溃率 ≈0  │                  │  信号类型安全层       │
└──────────────────┘                   └──────────────────────┘

路径二：ara-rs —— Rust 原生绑定

社区项目 ara-rs 正在用 Rust 提供 AUTOSAR Adaptive API 的类型安全绑定。底层通过 C-FFI 调用原生 ara::com，上层用 Rust 的类型系统保证消息类型的一致性。

// ara-rs 风格：类型安全的 SOME/IP 服务定义
#[service(interface = "Vehicle.Speed")]
pub struct SpeedService {
    // 编译期确保字段类型与 ARXML 描述一致
    velocity: f64,  // m/s
}

#[service_method(event = "OnSpeedChanged")]
impl SpeedService {
    pub fn subscribe(&self) -> EventSubscription<SpeedUpdate> {
        // 返回类型安全的 Event 订阅者
        // 若服务端字段变更导致类型不匹配，编译期即报错
        EventSubscription::new(self.endpoint())
    }
}

路径三：混合编译—— Rust 静态库 + C++ 链接

将 Rust 实现的核心算法编译为静态库（.a），通过 C ABI 导出接口，由 C++ AUTOSAR Adaptive 组件动态加载。这条路径对认证最友好——可以只对 Rust 组件做单元测试，不必重新认证整个 AUTOSAR 栈。

# Makefile 示例：混合编译 Rust 算法库到 AUTOSAR Adaptive 可执行文件
RUST_LIB_DIR    = target/release
AURIX_CXX_SRC   = $(wildcard src/ara/*.cpp)

speed_controller: $(RUST_LIB_DIR)/librust_sensor_fusion.a $(AURIX_CXX_SRC)
    $(CXX) $(CXXFLAGS) \
        -L$(RUST_LIB_DIR) -lrust_sensor_fusion \
        -lvsomeip3 -lara-com \
        -o $@ $(AURIX_CXX_SRC)

三、RTIC 框架：安全关键场景的实时中断驱动并发

在领域控制器（Domain Controller）中，传感器数据融合的实时性要求通常在微秒级（如激光雷达数据处理必须在一帧周期内完成，典型值为 5-10ms）。Rust 的 RTIC（Real-Time Interrupt-driven Concurrency） 框架是这类场景的标准解决方案。

RTIC 基于硬件中断 Dispatcher，提供三个核心机制： - 资源管理：编译期消除共享资源的数据竞争 - 软件任务：在特定中断上下文中执行，零开销调度 - 软件队列：中断间安全通信

下面是一个实际的引擎控制单元（ECU）中，曲轴传感器信号采集与气缸喷射正时计算的工程实现：

// 平台：ARM Cortex-R52（锁步模式），RTIC v2
// 编译器：rustc 1.81 + cortex-r52 target
#![no_std]
#![no_main]

use rtic::app;
use rtic_monotonics::systick::p::*;
use cortex_r::register::q0;

// 硬件资源：曲轴传感器输入捕获定时器、喷射器 GPIO
#[app(device = cortex_r::peripherals, peripherals = true, dispatchers = [TIM3, TIM4])]
mod app {
    use super::*;

    // ---- 共享资源（RTIC 编译期保证互斥访问）----
    #[shared]
    struct Shared {
        engine_rpm: u32,          // 实时计算的转速（转/分）
        crank_angle: f32,         // 当前曲轴角度 0.0..360.0
        fuel_map: FuelInjectionMap, // 喷射正时映射表
    }

    // ---- 本地资源（仅特定任务可访问）----
    #[local]
    struct Local {
        injector_1: PA0<PushPull>,  // 气缸1 喷射器驱动引脚
        injector_2: PA1<PushPull>,  // 气缸2 喷射器驱动引脚
    }

    #[init]
    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
        let systick = cx.core.SYST;
        let mono = Systick::new(systick, 480_000_000); // 480MHz 系统时钟

        // 配置曲轴传感器输入捕获
        let crank_timer = cx.device.TIM2;
        crank_timer.ccmr1.write(|w| w.cc1s().input_ti1());
        crank_timer.ccer.write(|w| w.cc1p().set_both_edges());
        crank_timer.arr.write(|w| w.arr().bits(0xFFFF));
        crank_timer.dier.write(|w| w.cc1ie().enabled());
        crank_timer.cr1.write(|w| w.cen().enabled());

        shared.engine_rpm = 0;
        shared.crank_angle = 0.0;
        shared.fuel_map = FuelInjectionMap::from_calibration();

        // RPM 计算任务：每 10ms（100Hz）执行一次
        calc_rpm::spawn_after(10.millis()).unwrap();

        (
            Shared { engine_rpm: 0, crank_angle: 0.0, fuel_map: FuelInjectionMap::new() },
            Local { injector_1: cx.device.PA0, injector_2: cx.device.PA1 },
            init::Monotonics(mono),
        )
    }

    // 硬件中断：曲轴传感器齿盘信号捕获（约每 6° 一个脉冲）
    #[task(binds = TIM2, shared = [crank_angle, engine_rpm], priority = 7)]
    fn crank_capture(cx: crank_capture::Context) {
        let period = unsafe { q0::read() }; // 读取定时器捕获寄存器值

        // 计算瞬时转速：RPM = 60 / (period_in_seconds * num_teeth_per_rev)
        // 采用 60-2 齿盘（58 个有效齿）
        *cx.shared.engine_rpm = 60_000_000 / (period * 58);
        *cx.shared.crank_angle = (*cx.shared.crank_angle + 6.0) % 360.0;
    }

    // 软件任务：计算各缸喷射正时并输出触发信号
    #[task(shared = [engine_rpm, crank_angle, fuel_map], local = [injector_1, injector_2], priority = 5)]
    fn calc_injection(cx: calc_injection::Context) {
        let rpm = *cx.shared.engine_rpm;
        let angle = *cx.shared.crank_angle;
        let map = &*cx.shared.fuel_map;

        // 根据转速和曲轴角度查表获取喷射提前角
        let advance_angle = map.lookup_injector_timing(rpm, angle);

        // 计算喷射持续期（ms）—— 直接决定了燃油喷射量
        let pulse_width = map.calculate_pulse_width(rpm);

        // 在适当时刻触发电磁阀
        if angle >= (360.0 - advance_angle) && angle < (360.0 - advance_angle + 3.0) {
            cx.local.injector_1.set_high();
            // 硬件 TIM3 负责精确关断，确保喷射脉宽误差 < 1μs
        }
    }

    // 周期性 RPM 刷新任务
    #[task(shared = [engine_rpm], priority = 3)]
    fn calc_rpm(cx: calc_rpm::Context) {
        // 滤波处理：移动平均消除单个齿误差
        *cx.shared.engine_rpm = (*cx.shared.engine_rpm * 7 + RPM_LATEST.load()) / 8;
        calc_rpm::spawn_after(10.millis()).unwrap();
    }
}

上述代码的关键工程价值在于：

1. #[shared] 资源在编译期通过 RTIC 的 Lock 实现（基于 BASEPRI 优先级天花板），不可能出现死锁或优先级反转
2. init::Context 保证外设初始化是单例的——编译期排除了"外设被多次初始化"的低级错误
3. 所有内容零动态分配——no_std + static mut 对应——满足 IEC 61508 对内存管理的要求

四、FFI 互操作：Rust 与 C/C++ 的安全边界

安全关键系统中，Rust 不是替代品而是"增强件"——必须与现有的 C/C++ 代码库共存。cbindgen + cxx 是构建安全 FFI 边界的核心工具。

用 cxx 生成类型安全桥接

// build.rs：配置 cxx 桥接
fn main() {
    cxx_build::bridge("src/bridge.rs")
        .file("src/autosar_adapt.cpp")
        .std("c++17")
        .flag_if_supported("-fno-exceptions")  // 安全关键场景禁用异常
        .flag_if_supported("-fno-rtti")        // 安全关键场景禁用 RTTI
        .compile("autosar_rust_bridge");
}

// bridge.rs：定义 Rust ↔ C++ 类型映射
#[cxx::bridge(namespace = "adas::perception")]
mod ffi {
    // Rust 可调用 C++ 函数
    unsafe extern "C++" {
        include!("adas/perception.hpp");
        fn process_radar_frame(data: &[f32], len: usize) -> UniquePtr<RadarFrame>;
        fn get_vehicle_state(state: &mut VehicleState);
    }

    // C++ 可调用 Rust 函数
    extern "Rust" {
        fn run_lidar_clustering(cloud: &[Point3D], result: &mut [Cluster]) -> usize;
        fn validate_perception_output(output: &PerceptionOutput) -> ValidationResult;
    }
}

// Rust 实现：激光雷达点云聚类
#[no_mangle]
pub extern "C" fn run_lidar_clustering(
    cloud: &[Point3D],
    result: &mut [Cluster],
) -> usize {
    // DBSCAN 聚类算法——Rust 保证 memory safety 和 no data race
    let mut dbscan::DBSCAN::new(0.2, 5); // eps=0.2m, min_samples=5
    let labels = dbscan.fit_predict(cloud);

    let cluster_count = labels.iter().max().map(|m| m + 1).unwrap_or(0);
    for (i, cluster) in result.iter_mut().enumerate().take(cluster_count) {
        *cluster = Cluster::from_label(i, cloud, &labels);
    }
    cluster_count
}

这比原始 extern "C" 指针传递安全得多——cxx 自动生成引用计数智能指针（UniquePtr），且不允许裸指针跨边界传递。

五、认证路径：从 MISRA C 到 Rust 的 ISO 26262 合规

功能安全认证（ISO 26262）对编译器、运行时库有严格要求。当前 Rust 在认证中的状态：

现状（2025/2026）

ISO 26262-6:2018 第 8 条（软件单元设计）和第 9 条（单元验证）要求使用"充分验证的编译器和库"。当前 Rust 认证面临三个障碍：

1. 编译器本身未认证：rustc 无 ISO 26262 合规认证
2. core/alloc 库未认证：标准库未提供 MISRA 兼容性证据
3. 所有权系统的可判定性：借用检查器是编译期工具，但其自身正确性需独立证明

可行方案：Ferrocene 编译器

Ferrocene 是 Ferrous Systems 推出的 ISO 26262 合规 Rust 编译器，通过 TÜV 认证路径（ASIL D 等级）。它提供： - 带完整需求追溯的 rustc 代码库 - 经过形式化验证的借用检查器子系统 - 符合 ISO 26262-8 第 11 条的编译器鉴定工具包（Compiler Qualification Kit）

# 使用 Ferrocene 的 Toolchain 配置
# toolchain.toml
[toolchain]
channel = "ferrocene-25-05"
targets = ["aarch64-unknown-none", "thumbv7em-none-eabihf"]
components = ["rustc", "rust-std", "cargo", "rustfmt"]

Ferrocene 当前支持的关键目标架构：

代码合规要点

在 ISO 26262 项目中写 Rust 代码，必须遵守以下工程约束：

# .cargo/config.toml —— 安全关键项目的编译配置
[build]
# 禁止任何可能导致不确定行为的优化
rustflags = [
    "-C", "opt-level=2",           # O2：不破坏调试信息
    "-C", "debuginfo=2",            # 全量 DWARF4 调试信息
    "-C", "force-frame-pointers=true", # 堆栈回溯
    "-C", "no-redzone",             # 安全关键：禁用红区
    "-C", "link-arg=-fno-exceptions",
    "-C", "panic=abort",            # 禁止 panic 展开（不可恢复）
]

[profile.release]
lto = true                          # 全量 LTO 以支持 WCET 分析
codegen-units = 1                   # 单 CGU：确保编译确定性
overflow-checks = true              # 整数溢出 PANIC（而非回绕）

// 使用 Rust 的类型系统实现 MISRA 约束
// RULE 2.3（未使用变量）→ dead_code lint
// RULE 2.4（未使用函数）→ dead_code lint
// RULE 14.2（for 循环中的变量修改）→ 不可变默认

// 禁止 panic 和 unwinding
#![forbid(clippy::unwrap_used)]
#![forbid(clippy::expect_used)]
#![deny(clippy::panic)]
#![deny(unreachable_code)]
#![deny(unused_must_use)] // Result 必须处理

// 安全关键的 Result 处理范式
fn critical_sensor_read() -> Result<SensorData, SensorError> {
    match unsafe { read_adc_register(ADC_CH_1) } {
        RawSensorValue(val) if val >= SENSOR_OK_RANGE => Ok(SensorData::Temperature(val as f32 * 0.125)),
        RawSensorValue(_) => Err(SensorError::OutOfRange),
        RawSensorError(_) => Err(SensorError::HardwareFault),
    }
    // ^ 编译器强制：match 覆盖了所有枚举变体
}

// 使用 Rustenum 模式实现 MISRA Rule 10.1（隐式类型转换禁止）
enum SensorMode {
    Normal,
    Calibration,
    FaultRecovery { attempt_count: u8 },
}

fn process(mode: SensorMode) -> SystemState {
    match mode {
        SensorMode::Normal => SystemState::RUN,
        SensorMode::Calibration => SystemState::MAINTENANCE,
        SensorMode::FaultRecovery { attempt_count } if attempt_count < 3 => SystemState::RECOVERING,
        _ => SystemState::SAFE_STATE, // 超过3次恢复失败，安全状态
    }
}

六、工程实践：AUTOSAR Adaptive + Rust 的诊断栈

在真实的量产项目中，我们用 Rust 实现了一个完整的 UDS（Unified Diagnostic Services）诊断服务端，集成到 AUTOSAR Adaptive 的 DOIP（Diagnostic over IP）链路中。

架构设计

┌─────────────────────────────────────────────────────────────┐
│  Rust Diagnostic Server (no_std + alloc)                     │
│  ┌────────────┐  ┌──────────────┐  ┌────────────────────┐  │
│  │ UDS Parser  │→ │ Session FSM  │→ │ DID Read/Write     │  │
│  │ byte→Pdu    │  │ (状态机驱动)   │  │ (Data ID 访问器)    │  │
│  └──────┬─────┘  └──────┬───────┘  └─────────┬──────────┘  │
│         │               │                     │              │
│  ┌──────▼───────────────▼─────────────────────▼──────────┐ │
│  │               Session Layer (租用模式)                    │ │
│  │        DefaultSession / Programming / Extended           │ ││
│  └────────────────────────┬───────────────────────────────┘ │
│                                       │                        │
│  ┌────────────────────────────────────▼─────────────────────┐│
│  │  TP Layer (ISO 15765-2 / ISO 14229)                       ││
│  │  DoIP ↔ CAN ↔ Ethernet 分用                              ││
│  └────────────────────────────────────────────────────────┘ │
└──────────────────────────────┬────────────────────────────────┘
                               │ cxx::bridge (C++ 进程)
┌──────────────────────────────▼────────────────────────────────┐
│  AUTOSAR Adaptive (C++17)                                     │
│  ara::diag::ConversationManagement  ←→ ara::com (SOME/IP)    │
└───────────────────────────────────────────────────────────────┘

UDS 协议解析器的 Rust 实现

//! UDS 协议帧解码器——零拷贝、编译期安全
//! 符合 ISO 14229-1:2020

/// UDS 服务 ID （基于 ISO 14229-1 Table A.1）
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum UdsServiceId {
    DiagnosticSessionControl = 0x10,     // 诊断会话控制
    EcuReset = 0x11,                     // ECU 复位
    SecurityAccess = 0x27,              // 安全访问
    ReadDataByIdentifier = 0x22,        // DID 读
    WriteDataByIdentifier = 0x2E,       // DID 写
    RoutineControl = 0x31,              // 例程控制
    RequestDownload = 0x34,             // 请求下载
    TransferData = 0x36,                // 数据传输
    RequestTransferExit = 0x37,         // 传输终止
}

/// 否定响应代码（NRC）
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
#[allow(non_camel_case_types)]
pub enum NegativeResponseCode {
    GeneralReject = 0x10,
    ServiceNotSupported = 0x11,
    SubFunctionNotSupported = 0x12,
    IncorrectMessageLength = 0x13,
    ResponseTooLong = 0x14,
    ConditionsNotCorrect = 0x22,
    RequestOutOfRange = 0x31,
    SecurityAccessDenied = 0x33,
    InvalidKey = 0x35,
    ExceedNumberOfAttempts = 0x36,
    RequiredTimeDelayNotExpired = 0x37,
    // ... 完整 38 个 NRC
}

/// UDS 响应类型：模式匹配消除分支覆盖漏洞
#[derive(Debug)]
pub enum UdsResponse {
    /// 肯定响应
    Positive {
        response_service_id: UdsServiceId,
        data: heapless::Vec<u8, 4096>, // 固定大小，堆栈分配
    },
    /// 否定响应
    Negative {
        rejected_service_id: UdsServiceId,
        nrc: NegativeResponseCode,
    },
}

/// 诊断会话状态机——编译期验证状态转换合法性
pub struct DiagnosticSession {
    mode: SessionMode,
    security_level: Option<SecurityLevel>,
    buffer: heapless::Vec<u8, 8192>,
    last_activity_ticks: u32,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionMode {
    Default,      // 默认会话：仅基础诊断
    Programming,  // 编程会话：允许刷写
    Extended,     // 扩展会话：全功能诊断
}

impl DiagnosticSession {
    /// 状态转换——只有合法转换才会 compile
    /// 模式匹配保证所有转换路径都被处理
    pub fn transition(
        &mut self,
        target: SessionMode,
        key: Option<SecurityKey>,
    ) -> Result<(), SessionError> {
        match (self.mode, target) {
            // Default → Programming 需要 SecurityAccess Level 1 解锁
            (SessionMode::Default, SessionMode::Programming) => {
                self.require_security_level(SecurityLevel::Level1, key)?;
                self.mode = SessionMode::Programming;
                self.reset_s3_timer();
                Ok(())
            }
            // Programming → Default 总是允许（安全状态回退）
            (_, SessionMode::Default) => {
                self.mode = SessionMode::Default;
                self.security_level = None;
                self.reset_s3_timer();
                Ok(())
            }
            // 相同状态幂等
            (current, target) if current == target => Ok(()),
            // 其他转换需要 Extended 前置
            _ => {
                self.require_security_level(SecurityLevel::Level3, key)?;
                self.mode = target;
                self.reset_s3_timer();
                Ok(())
            }
        }
    }

    fn require_security_level(
        &self,
        required: SecurityLevel,
        key: Option<SecurityKey>,
    ) -> Result<(), SessionError> {
        match (self.security_level, key) {
            (Some(level), _) if level >= required => Ok(()),
            (None, Some(k)) if k.verify(required) => Ok(()),
            _ => Err(SessionError::SecurityAccessDenied),
        }
    }

    /// S3 超时处理：5000ms 无通信则回退 Default Session
    pub fn tick(&mut self, delta_ms: u32) {
        self.last_activity_ticks = self.last_activity_ticks.saturating_add(delta_ms);
        if self.last_activity_ticks >= 5000 {
            self.mode = SessionMode::Default;
            self.security_level = None;
        }
    }
}

/// UDS 帧解码——零分配、溢出保护
pub fn decode_frame(raw: &[u8]) -> Result<UdsRequest, DecodeError> {
    // 最小帧长度检查（防止 OOB）
    if raw.len() < 2 {
        return Err(DecodeError::FrameTooShort);
    }

    // 第一个字节是 SID，第二个字节是 SubFunction（如有）
    let sid_byte = raw[0];
    let service_id = match sid_byte {
        0x10 => UdsServiceId::DiagnosticSessionControl,
        0x22 => UdsServiceId::ReadDataByIdentifier,
        0x27 => UdsServiceId::SecurityAccess,
        0x2E => UdsServiceId::WriteDataByIdentifier,
        _ => return Err(DecodeError::UnsupportedService(sid_byte)),
    };

    // 提取服务特定 payload
    let payload = &raw[1..]; // SID 之后的全部数据

    Ok(UdsRequest { service_id, payload })
}

关键工程要点

上面这段诊断栈代码的核心价值全在类型驱动设计：

1. #[repr(u8)] 枚举：强制编译器用 u8 底层表示，与 CAN 总线帧格式自然对齐
2. heapless::Vec 替代 alloc::vec::Vec：在 no_std 环境提供容量上界堆栈分配，WCET 可分析
3. 模式匹配穷举：match 强制处理所有可能的 service_id——如果有新的 UDS 服务加入但忘了处理，编译器直接报错
4. saturating_add：防整数溢出——这是 ISO 26262 中 H.2.13 条的隐式要求
5. Result 错误传播：所有可能失败的路径都必须显式处理，else 分支滴水不漏

七、工具链与静态分析

安全关键项目的 Rust 工具链配置：

# 安装安全关键目标
rustup target add thumbv7em-none-eabihf
rustup target add aarch64-unknown-none

# 安装静态分析工具
cargo install cargo-misra         # MISRA 合规扫描器
cargo install cargo-fuzz         # 模糊测试驱动

# clippy 安全关键配置
cargo clippy \
    -- \
    -W clippy::correctness \
    -W clippy::suspicious \
    -W clippy::complexity \
    -W clippy::perf \
    -W clippy::style \
    -A clippy::missing_safety_docs \
    -A clippy::doc_markdown \
    --deny warnings

# .clippy.toml —— 额外的安全关键规则
doc-valid-ids = ["ISO-26262", "IEC-61508", "MISRA-C", "DO-178C"]
blacklisted-name = ["foo", "bar", "baz"]  # 禁止占位符
cognitive-complexity-threshold = 15       # 限制函数复杂度
too-many-arguments-threshold = 5          # 限制参数数量

八、总结：Rust 在安全关键领域的工程定位

Rust 不是 C/C++ 的全面替代品，而是一种增强件——适合用于安全关键系统中对可靠性要求最高的"信任边界"组件：

┌──────────────────────────────────────────────────────────────┐
│  安全关键软件分层策略（Rust 渗透路径）                           │
│                                                              │
│  Layer 0（最高风险/最高安全）  ←→ Rust 优先                    │
│  传感器融合的数值计算 · 制动/转向控制逻辑 · 加密认证协议         │
│                                                              │
│  Layer 1（中等风险）          ←→ Rust/C++ 混合                 │
│  AUTOSAR Adaptive 非安全域组件 · 诊断服务 · OTA 管理          │
│                                                              │
│  Layer 2（已认证/成熟）       ←→ 保留 C/C++                    │
│  AUTOSAR Classic BSW 栈 · 已量产的 ECU 固件 · 成熟闭源库       │
└──────────────────────────────────────────────────────────────┘

三个关键工程经验： 1. 先用 RTIC 搞定实时，再用 FFI 集成现有系统——渐进式迁移比"全部重写"安全得多 2. Ferrocene 编译器是量产落地的入场券——没有合规编译器，ASIL D 项目无法开闸 3. Rust 的工程优势不在语言特性，在工具链一致性——cargo + clippy + rustfmt 的强制统一让团队代码质量方差趋近于零

当 Rust 编译器完成 ISO 26262 ASIL D 认证的那天，整个汽车软件工业的代码质量基准线将被永久性地抬高。在此之前，聪明的方法是用 Rust 保护最关键的那 20% 的代码——它们贡献了 80% 的现场故障。