罗罗编程学习记录
本页内容 展开查看

04.4.2.3 Unsafe、FFI 与内存模型

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.2 并发与工程实践

04.4.2.3-001 unsafe 块能做哪几件事?

一句话结论

unsafe 允许:解引用裸指针、调用 unsafe 函数、访问/修改可变静态变量、实现 unsafe trait、访问 union 字段;它解锁额外能力,但不关闭借用检查与其他安全规则。

概念解释

Rust 把无法在编译期证明安全的操作集中到 unsafe 块内。标准库在这些原语之上封装安全 API;业务代码应尽量把 unsafe 限制在小型、可评审的抽象内部。

原理流程

  1. 在 unsafe { } 内执行受限操作。
  2. 开发者负责满足指针有效、对齐、别名、生命周期等不变量。
  3. 对外暴露的包装函数保持安全签名。

代码或图示

let x = 10;
let p = &x as *const i32;
unsafe {
    println!("{}", *p); // 解引用裸指针
}

常见误区

  • 以为 unsafe 内所有检查都关闭:借用、类型检查仍在,仅解锁上述几类操作。
  • 以为 unsafe 块越多越危险:风险取决于不变量是否被正确维护,而不是块数量。

追问

  • 标准库哪些常见 API 内部是 unsafe?答:裸指针操作、部分内存管理、FFI 绑定、原子与并发原语底层;对外暴露安全接口。
  • 为什么要把 unsafe 封装进安全抽象?答:把不变量收敛到一处评审,调用方无需重复证明安全。

04.4.2.3-002 unsafe 是否关闭借用检查?

一句话结论

不关闭。unsafe 只解锁裸指针解引用等受限能力,借用规则、类型系统、生命周期检查仍然生效;裸指针本身不做合法性检查,合法性由 unsafe 代码保证。

概念解释

普通引用始终受借用检查约束;裸指针 *const/*mut 可悬空、可别名、可未对齐,解引用必须 unsafe 且满足不变量。unsafe 不是“关闭安全检查”的总开关。

原理流程

  1. 编写裸指针,不强制别名/有效约束。
  2. 解引用时进入 unsafe,人工保证有效与对齐。
  3. 引用转换回 &T 仍需满足生命周期与借用规则。

代码或图示

let p: *mut i32 = std::ptr::null_mut();
// unsafe { *p = 1; } // 空指针解引用,未定义行为

常见误区

  • 以为进了 unsafe 就可以随便别名:别名规则在 unsafe 里仍需人工遵守,违反即未定义行为。
  • 以为 unsafe 代码会被运行时检查:非法访问直接是未定义行为,没有兜底报错。

追问

  • 裸指针和引用转换规则?答:&T as *const T 安全;*const T as &T 是 unsafe,且必须保证指向有效、对齐、生命周期合法。
  • unsafe 里能访问私有字段吗?答:同模块内仍受可见性规则约束;可见性不是 unsafe 解锁项。

04.4.2.3-003 安全抽象封装原则是什么?

一句话结论

把 unsafe 收敛在最小范围内,内部维护不变量,对外提供安全 API:调用方拿到的是普通引用/类型,不接触裸指针,从而在安全边界内复用不安全原语。

概念解释

典型模式:结构体包装裸指针/外部句柄,构造与 Drop 管理生命周期,方法内做有效性检查,公开签名不含 unsafe 操作。评审只需验证封装层的不变量。

原理流程

  1. 定义包装类型持有原始指针/句柄。
  2. 构造时校验有效性,Drop 释放资源。
  3. 方法内 unsafe 操作,对外保持安全签名。

代码或图示

struct Buffer { ptr: *mut u8, len: usize }
impl Buffer {
    fn len(&self) -> usize { self.len }
    // 方法内按需 unsafe 访问,外部无需 unsafe
}

常见误区

  • 把裸指针直接暴露给调用方:安全边界被打破,调用方无法判断合法性。
  • 在公开 unsafe fn 上省略文档:调用方必须知道需要满足哪些前置条件。

追问

  • 什么时候公开 unsafe fn 是合理的?答:不变量无法由类型自动保证(如外部内存布局约定),在文档写清前置条件,供高级用户使用。
  • 如何评审封装层?答:检查构造有效性、Drop 释放、别名独占、线程安全与错误路径。

04.4.2.3-004 裸指针 *const T/*mut T 与引用有什么区别?

一句话结论

引用保证非空、对齐、有效且遵守借用规则;裸指针可为空、可未对齐、可别名,不做合法性检查,解引用必须 unsafe 并人工保证不变量。

概念解释

裸指针是 FFI、底层数据结构、内部可变性等场景的底层句柄。它不参与借用互斥检查,也没有生命周期自动约束,合法性完全由代码维护。

原理流程

  1. 引用可转为裸指针(安全)。
  2. 裸指针可空、可变别名、未对齐。
  3. 转回引用或解引用在 unsafe 内完成,需保证有效。

代码或图示

let a = 5;
let r: &i32 = &a;
let pc: *const i32 = r;
let pm: *mut i32 = &mut a as *mut i32;

常见误区

  • 以为裸指针解引用会自动检查空/对齐:不会,非法访问是未定义行为。
  • 以为 *const 和 *mut 可随意互转:转换需 unsafe,且别名/可变性约束仍要遵守。

追问

  • 裸指针支持哪些安全方法?答:offset/add/sub/read/write/copy 等指针方法本身是 unsafe;is_null() 检查可安全调用。
  • 指针相等比较安全吗?答:比较地址是允许的;解引用才需要 unsafe。

04.4.2.3-005 解引用裸指针要满足哪些不变量?

一句话结论

解引用必须保证:指针非空且指向合法分配内存、满足类型对齐、在生命周期内有效、不违反可变别名规则;违反任一条即未定义行为。

概念解释

这些不变量是引用安全的前提,编译器不再替你检查。跨 FFI 场景还要确认内存归属、释放方式与作用范围。

原理流程

  1. 确认指针来源与分配范围。
  2. 检查非空、对齐、边界。
  3. 确认生命周期与别名后再解引用。

代码或图示

unsafe {
    if !p.is_null() && aligned {
        let v = &*p;
    }
}

常见误区

  • 只判空不查对齐:未对齐访问在部分平台崩溃或性能下降。
  • 忽略生命周期:内存已释放后解引用形成悬垂。

追问

  • 如何在 unsafe 代码里验证不变量?答:构造期断言长度/对齐,边界检查,配合测试、Miri 与 sanitizer(可用性待确认)。
  • 指针偏移有什么约束?答:offset 必须落在同一分配对象范围内,越界指针计算本身即非法。

04.4.2.3-006 FFI 声明:extern "C" 与调用 C 函数为什么是 unsafe?

一句话结论

extern "C" 按 C ABI 声明外部函数;调用 C 函数是 unsafe,因为编译器无法验证 C 侧的参数有效性、内存归属、线程安全与错误约定,这些契约需人工保证。

概念解释

FFI 跨越 Rust 安全边界:C 代码不遵守 Rust 所有权规则。声明函数签名、链接库、参数类型与调用约定都需匹配;调用前要确认指针、长度、字符串与所有权约定。

原理流程

  1. #[link(name = "m")] 指定链接库。
  2. extern "C" { fn sqrt(x: f64) -> f64; } 声明签名。
  3. unsafe { sqrt(4.0) } 调用,满足 C 侧前置条件。

代码或图示

#[link(name = "m")]
extern "C" {
    fn sqrt(x: f64) -> f64;
}
let v = unsafe { sqrt(4.0) };

常见误区

  • 以为 FFI 函数签名写错编译器能发现:类型/ABI 不匹配是未定义行为,编译期不校验 C 侧。
  • 以为传 Rust String 给 C 即可:C 需要 NUL 终止的 *const c_char,须用 CString 转换。

追问

  • 调用约定为什么写 "C"?答:指定 C ABI(参数传递、栈清理约定);其他语言有各自 ABI,混用会破坏栈帧。
  • 链接库名在不同平台要注意什么?答:库前缀/后缀与搜索路径依平台不同,构建配置需分别处理。

04.4.2.3-007 跨语言字符串:CStr/CString/&[u8] 与 NUL 终止?

一句话结论

C 字符串以 NUL(\0)结尾,Rust 字符串不保证 NUL;CString 从 Rust 字符串构造带 NUL 的 C 兼容串,CStr 从 C 侧安全借用字节切片,内部不能含嵌入 NUL。

概念解释

CString 拥有堆上 NUL 终止字节,可传给 C;CStr 是对外部 NUL 终止串的借用视图,检查 UTF-8 后取 &str。传参时所有权与生命周期要明确:C 侧不得释放 Rust 分配的串。

原理流程

  1. Rust 侧 CString::new(s),拒绝内部 NUL。
  2. as_ptr() 传 *const c_char 给 C。
  3. C 返回的指针用 CStr::from_ptr 借用,按生命周期使用。

代码或图示

use std::ffi::{CString, CStr};
let c = CString::new("hello").unwrap();
let ptr = c.as_ptr();
// 传给 C 后,c 存活期间指针有效
let s = unsafe { CStr::from_ptr(ptr) }.to_str().unwrap();

常见误区

  • 在 CString drop 后仍把指针传给 C:悬垂指针。
  • 假设 C 传回的字符串以 Rust String 持有:所有权归属需按 C 文档约定,避免重复释放。

追问

  • 二进制数据怎么传?答:用 &[u8]/*const u8 配合显式长度,不依赖 NUL 终止;长度由调用方提供。
  • CString::new 失败原因?答:输入含嵌入 NUL 字节,无法构造合法 C 串。

04.4.2.3-008 #[link]、bindgen、cbindgen 分别做什么?

一句话结论

#[link] 告诉 Cargo/链接器链接哪个外部库;bindgen 从 C/C++ 头文件自动生成 Rust FFI 绑定;cbindgen 反向从 Rust 导出 C 头文件供 C 侧调用。

概念解释

手写 FFI 签名易漏易错。bindgen 解析头文件生成类型与函数声明;cbindgen 扫描 Rust 源码生成 extern "C" 对应的 C 头。三者覆盖 Rust↔C 双向集成。

原理流程

  1. 依赖 C 库:头文件经 bindgen 生成绑定,#[link] 链接库。
  2. Rust 库暴露给 C:#[no_mangle] extern "C" 导出,cbindgen 生成头文件。
  3. 构建脚本(build.rs)可编排生成与编译。

代码或图示

// 生成的绑定示例
extern "C" {
    fn c_library_function(x: i32) -> i32;
}

常见误区

  • 以为 bindgen 生成的绑定天然安全:生成的多为 unsafe 声明,仍需 Rust 侧封装安全抽象。
  • 跨平台依赖只配一个链接名:不同平台库名与编译选项需分别处理。

追问

  • bindgen 依赖什么工具链?答:通常需要 libclang 解析 C 头;具体版本与平台安装方式以 bindgen 文档为准。
  • cbindgen 导出有什么限制?答:只能导出 C ABI 兼容的类型与函数,Rust 独有类型不能直接暴露。

04.4.2.3-009 Rust 函数如何暴露给 C?

一句话结论

用 #[no_mangle] 禁止符号改名,extern "C" 指定 C ABI,返回/参数使用 FFI 兼容类型;返回字符串/复杂结构需明确所有权与释放函数约定。

概念解释

Rust 编译默认可能改名/符号修饰,no_mangle 保持导出符号名。extern "C" 让调用约定匹配 C。跨语言传递复杂对象通常传不透明指针,配套提供创建与释放函数。

原理流程

  1. 函数标注 #[no_mangle] extern "C"。
  2. 参数用基本类型/指针/切片指针+长度。
  3. 提供对应的 Rust 释放函数,避免 C 侧误用 Rust 分配器释放。

代码或图示

#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 { a + b }

#[no_mangle]
pub extern "C" fn buffer_len(b: *const u8, len: usize) -> usize { len }

常见误区

  • 直接返回 String/Vec 给 C:布局不透明,C 无法正确释放。
  • 忘记提供释放函数:C 侧拿到 Rust 堆内存后无安全释放路径。

追问

  • 不透明指针怎么设计?答:导出 *mut Opaque 创建句柄,C 侧只持有指针,调用方法函数操作,最后调 free 函数释放。
  • 导出函数 panic 会怎样?答:跨 FFI 边界 panic 是未定义行为,边界函数应 catch_unwind 并返回错误码(以当前文档建议为准)。

04.4.2.3-010 repr(C)/transparent/packed/repr(u8) 区别?

一句话结论

repr(C) 按 C 布局排列字段保证 FFI 兼容;repr(transparent) 单字段透明布局;repr(packed) 紧凑排列取消填充;repr(u8) 把枚举指定为 u8 底层类型。

概念解释

默认 repr(Rust) 字段顺序可重排以优化布局。跨语言传结构体必须固定布局与对齐;packed 减少体积但带来未对齐访问风险;repr 整数控制枚举判别值宽度。

原理流程

  1. FFI 结构体用 #[repr(C)]。
  2. 包装单字段类型用 #[repr(transparent)] 保持与内部类型同布局。
  3. 枚举需要固定底层类型用 #[repr(u8)] 等。

代码或图示

#[repr(C)]
struct Point { x: f64, y: f64 }

#[repr(u8)]
enum Color { Red, Green, Blue }

常见误区

  • 对 FFI 结构体用默认 Rust 布局:字段可能重排,与 C 侧结构不匹配。
  • 随便用 repr(packed):未对齐字段访问可能崩溃或变慢。

追问

  • repr(transparent) 适用条件?答:结构体只有一个非 ZST 字段(其余为零大小类型),布局与该字段一致。
  • 枚举 repr 与 FFI?答:传给 C 的枚举建议固定 repr 整数类型,并确认判别值与 C 侧常量一致。

04.4.2.3-011 如何用 size_of/align_of 检查内存布局?

一句话结论

std::mem::size_of::<T>() 查类型字节大小,align_of::<T>() 查对齐要求,size_of_val 查动态值大小;FFI 对接时用这些值核对与 C 侧结构是否一致。

概念解释

布局一致性是 FFI 正确性的基础。通过编译期/运行时输出大小与对齐,对比 C 侧 sizeof/对齐,发现填充与字段顺序差异。

原理流程

  1. 对关键类型调用 size_of/align_of。
  2. 与 C 侧结构 sizeof、字段偏移对比。
  3. 不一致时调整 repr 或字段布局。

代码或图示

use std::mem::{size_of, align_of};
println!("{} {}", size_of::<Point>(), align_of::<Point>());

常见误区

  • 只看 size 不看对齐:对齐不一致同样导致字段偏移错误。
  • 忽略枚举/指针宽度随目标平台变化:交叉编译时按目标三元组核对。

追问

  • 如何查字段偏移?答:标准库不直接提供偏移 API;可用布局测试或第三方工具核对,以当前工具链能力为准。
  • size_of_val 与 size_of 区别?答:后者是类型静态大小,前者针对具体值(如 trait object/切片)的运行时大小。

04.4.2.3-012 repr(packed) 的未对齐访问风险是什么?

一句话结论

packed 取消填充使字段可能落在未对齐地址,访问这类字段在部分平台触发总线错误/崩溃,或产生性能惩罚;取 packed 字段的引用通常被编译器拒绝以避免未对齐引用。

概念解释

默认布局按对齐插入填充,保证字段对齐。packed 紧凑排列牺牲对齐换体积。跨 FFI 结构体除非 C 侧也是 packed 布局,否则不应使用。

原理流程

  1. #[repr(packed)] 字段紧排。
  2. 多字节字段地址可能不满足对齐。
  3. 直接引用该字段编译器告警/报错;解引用需手动拷贝到对齐局部变量。

代码或图示

#[repr(packed)]
struct P { a: u8, b: u32 }
let p = P { a: 0, b: 1 };
let b = p.b; // 拷贝访问;直接引用 &p.b 受限

常见误区

  • 以为 packed 只是省内存无副作用:对齐风险是主要代价。
  • 对普通业务结构体用 packed:默认布局更安全,必要时再评估。

追问

  • 编译器如何阻止未对齐引用?答:对 packed 字段取引用会触发编译错误/告警,要求先复制值。
  • 哪些场景确实需要 packed?答:与 C 侧 packed 结构体、二进制协议帧布局对齐时。

04.4.2.3-013 FFI 常见崩溃原因有哪些?

一句话结论

空指针解引用、内存布局/对齐不一致、越界访问、字符串缺 NUL、内存归属与释放方式错误、线程违反约定、panic 跨越 FFI 边界,是最常见的崩溃来源。

概念解释

Rust 侧类型安全在 FFI 边界失效,问题多为契约未被满足。排查时按“指针有效性 → 布局匹配 → 长度边界 → 所有权释放 → 线程模型”逐项核对。

原理流程

  1. 检查传入指针非空且长度合法。
  2. 核对结构体大小/对齐/字段偏移。
  3. 确认字符串 NUL 与编码。
  4. 明确谁分配、谁释放、在哪个线程使用。

代码或图示

崩溃清单:空指针 / 布局不一致 / 越界 / 缺 NUL / 重复释放 / 线程竞争 / 跨边界 panic

常见误区

  • 只在 release 排查:debug 下断言与检查更易暴露问题,可对照测试。
  • 假设 C 侧会复制输入:很多 C API 只存指针,生命周期需调用方保证。

追问

  • 如何在 FFI 边界防 panic?答:导出函数内部 catch_unwind,把 panic 转成错误码,不让展开跨边界(方式以当前文档为准)。
  • 内存释放为什么容易错?答:Rust 用分配器,C 用 libc malloc,混用 free/释放会破坏堆;应配套释放函数。

04.4.2.3-014 static/static mut/const 有什么区别与风险?

一句话结论

const 是编译期常量,用到处复制;static 是全局唯一持久项,有固定地址;static mut 可变全局变量,访问是 unsafe,存在数据竞争与别名风险。

概念解释

全局状态跨请求/线程共享,可变静态必须同步保护。static mut 绕过借用检查,多线程访问极易数据竞争;现代代码优先用 static OnceLock + 锁/原子封装。

原理流程

  1. 纯常量表达式用 const。
  2. 需全局地址或 'static 句柄用 static。
  3. 可变全局用 static mut(unsafe)或封装为 static + 同步原语。

代码或图示

static APP_NAME: &str = "demo";
static mut COUNTER: i32 = 0;
// unsafe { COUNTER += 1; } // 多线程下数据竞争

常见误区

  • 以为 static 和 const 等价:static 有唯一固定地址,const 是内联常量表达式。
  • 在多线程程序里用 static mut 计数:非原子修改构成数据竞争。

追问

  • 全局可变状态推荐怎么写?答:static X: OnceLock<Mutex<T>> 或原子类型,经安全接口访问,避免裸 static mut。
  • static 初始化有什么限制?答:常量初始化;复杂运行时初始化用 OnceLock/get_or_init。

04.4.2.3-015 原子类型与内存序(Relaxed/Acquire/Release/SeqCst)是什么?

一句话结论

AtomicUsize/AtomicBool 等用原子指令共享可变状态,避免数据竞争;内存序约束指令重排与可见性:Relaxed 只保证原子性,Acquire/Release 配对建立同步,SeqCst 提供全局顺序一致性。

概念解释

原子操作比锁轻量,适合计数器、标志位、指针发布。内存序决定编译器/CPU 能否重排访问以及跨线程可见范围。选错内存序可能丢失 happens-before 保证。

原理流程

  1. 共享变量用原子类型,store/load/fetch_add 等操作。
  2. 按同步关系选择内存序。
  3. 发布数据用 Release,读取方用 Acquire 建立顺序。

代码或图示

use std::sync::atomic::{AtomicBool, Ordering};
static READY: AtomicBool = AtomicBool::new(false);
READY.store(true, Ordering::Release);
let _ = READY.load(Ordering::Acquire);

常见误区

  • 以为 Relaxed 可用于发布共享数据:Relaxed 不建立同步顺序,其他数据可能不可见。
  • 一上来全用 SeqCst:虽安全但限制优化,热点路径按最小必要内存序选择。

追问

  • Acquire/Release 配对解决什么?答:Release 之前的写在 Acquire 读取后对读取方可见,构成 happens-before。
  • 原子类型是 Send/Sync 吗?答:原子类型内部状态同步,通常实现 Send + Sync,可安全全局共享。

04.4.2.3-016 mem::forget/ManuallyDrop 与析构绕过的风险?

一句话结论

mem::forget 故意不运行值的 Drop,ManuallyDrop 包装值延迟析构;绕过析构可能导致资源泄漏、锁/句柄未释放,必须明确谁负责清理。

概念解释

正常作用域结束自动 drop;forget/ManuallyDrop 把析构控制权交出。常见于 FFI 转移所有权、FFI 句柄包装等场景,误用会泄漏资源或双重释放。

原理流程

  1. ManuallyDrop::new(v) 包装,析构不自动运行。
  2. 需要时 ManuallyDrop::into_inner 取回正常 drop,或 drop 手动释放。
  3. forget 后内存归属转移给外部,需外部释放路径。

代码或图示

use std::mem::ManuallyDrop;
let v = ManuallyDrop::new(String::from("x"));
let _ = ManuallyDrop::into_inner(v); // 恢复正常析构

常见误区

  • 以为 forget 会释放内存:它跳过 Drop,堆内存/资源按约定由后续逻辑释放。
  • 在普通业务代码里随意 forget:遗漏清理导致句柄/内存累积。

追问

  • 如何安全地取走 ManuallyDrop 内部值?答:用 into_inner 恢复所有权走正常 Drop;需要裸指针移交 FFI 时配套外部释放函数。
  • ManuallyDrop 与 MaybeUninit 关系?答:都属于底层内存管理工具;MaybeUninit 处理未初始化内存,ManuallyDrop 控制析构时机。

04.4.2.3-017 验证 unsafe 代码有哪些工具与手段?

一句话结论

手段包括代码评审不变量、单元/集成测试、Miri 检查未定义行为、内存/地址 sanitizer、压测与线程审查;具体工具链可用性与支持平台以当前 Rust 版本为准。

概念解释

unsafe 无法靠编译期完全保证,需要多层验证:评审列出前置条件,测试覆盖边界,工具检测未初始化/越界/悬垂,并发工具检查竞争。

原理流程

  1. 评审封装层不变量与前置条件。
  2. 编写边界与错误路径测试。
  3. 运行 Miri/sanitizer 检测 UB 与内存错误。
  4. 并发场景做线程压测与堆栈分析。

代码或图示

评审 → 单元测试 → Miri(UB)→ ASan/内存 sanitizer → 并发压测

常见误区

  • 只靠人工读代码:复杂指针与并发问题容易漏,应结合工具。
  • 以为工具通过就无 UB:工具覆盖有限,不变量评审仍不可少。

追问

  • Miri 能查什么?答:未初始化内存、悬垂指针、越界、部分未定义行为;不覆盖所有平台 UB,具体能力以 Miri 文档为准。
  • sanitizer 如何接入?答:按工具链/平台配置编译参数启用地址/内存/线程 sanitizer;环境支持情况待确认。

04.4.2.3-018 no_std 与 core/alloc/std 三层 crate 是什么关系?

一句话结论

std 依赖操作系统与堆分配,提供完整标准库;alloc 提供堆分配类型(Vec/String 等)但不依赖 OS 服务;core 是无 OS、无堆的最小基础库。#![no_std] 表示不链接 std。

概念解释

嵌入式、内核、裸机环境没有标准 OS 运行时,只能用 core;需要动态集合再引入 alloc;普通应用链接 std。三层按依赖关系叠加,类型与能力逐层增加。

原理流程

  1. #![no_std] 后默认可用 core。
  2. 需要 Vec/Box 等引入 alloc crate。
  3. 有 OS 与堆环境再用 std。

代码或图示

#![no_std]
extern crate alloc;
use alloc::vec::Vec;

常见误区

  • 以为 no_std 下不能用堆:需显式引入 alloc 并提供分配器。
  • 以为 core 和 std 类型重复实现:std 包含并扩展 core,core 类型是基础子集。

追问

  • no_std 如何处理错误/输出?答:没有标准 IO/ panic 运行时,需自定义 panic 处理与硬件输出;具体设施以 target 支持为准。
  • 嵌入式常见依赖?答:core + alloc + 提供的全局分配器,外设驱动与调度器自行实现或用第三方 crate。