/* * 模块名称:保护定值模型(P1,定值校验和 载体)——实现 *(保护功能清单见 docs/算法/继电保护功能复现规划.md) * 模块功能:见 prot_set.h。纯逻辑,零平台依赖(仅 stdint.h + size_t + 自身头); * 写事务保护只持有**两个函数指针**(prot_set_lock_t),由平台侧在安装时注入, * 本文件不认识任何 RTOS/HAL 符号——固件、模拟器、主机单测三方共用同一份源码。 * * ⚠ 默认值/范围为拟定值(参考 EEPROM 出厂默认表不在本仓库,规划 §10.3 待补); * 通讯地址逐项对照参考 Comm/Pub/Const_CommSetPara.c g_tCommSetParaTab。 * * 量纲口径(「数据可信」下游常数按工程量重定一项复核,2026-10-25):A/V 项 = **二次值**工程量, * 标称基准 100 V / 1 A(UA/UB/UC 相电压、3U0、OV/UV 同域——OV 120 = 1.2×Un、 * UV 20 = 0.2×Un、3U0 15 = 0.15×Un;OC1/2/3 = 10/5/2 ×Ir、OL = 1.0×Ir, * 三段递升与过负荷低于速断均自洽)。ADC 帧仅在 adc_cal VALID 置位后才处 * 于此域(未标定 = 引脚电压域,由未标定即闭锁停走判据,见 protect_task.c); * min/max 范围覆盖 0~4×标称,无需随这一项改动数值——换算依据与三处下游 * 常数同源,见 docs/算法/采集与算法层设计说明.md §13.7。 * * 创建日期:2026-10-11 */ #include "prot_set.h" /* 元数据表:顺序必须与 prot_set_id_t 严格一致(逐行带地址注释,同 phasor * k_inst 的朴素行式风格) */ const prot_set_meta_t g_prot_set_meta[PS_ID_COUNT] = { /* addr ctl default min max 说明 */ { 0x8856, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OC1 投退 */ { 0x8857, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OC1 跳闸投退 */ { 0x8858, 0u, PROT_SET_Q10(10.0), 0, PROT_SET_Q10(100.0) }, /* OC1 电流 A */ { 0x8859, 0u, PROT_SET_Q10(0.0), 0, PROT_SET_Q10(60000) }, /* OC1 延时 ms */ { 0x885A, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, { 0x885B, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, { 0x885C, 0u, PROT_SET_Q10(5.0), 0, PROT_SET_Q10(100.0) }, { 0x885D, 0u, PROT_SET_Q10(500.0), 0, PROT_SET_Q10(60000) }, { 0x885E, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, { 0x885F, 1u, PROT_SET_Q10(0), 0, PROT_SET_Q10(1) }, /* OC3 默认告警 */ { 0x8860, 0u, PROT_SET_Q10(2.0), 0, PROT_SET_Q10(100.0) }, { 0x8861, 0u, PROT_SET_Q10(3000.0), 0, PROT_SET_Q10(60000) }, { 0x8871, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* 过负荷投退 */ { 0x8872, 1u, PROT_SET_Q10(0), 0, PROT_SET_Q10(1) }, /* 默认告警 */ { 0x8873, 0u, PROT_SET_Q10(1.0), 0, PROT_SET_Q10(100.0) }, { 0x8874, 0u, PROT_SET_Q10(10000.0),0, PROT_SET_Q10(60000) }, { 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OV 投退(本地) */ { 0x8029, 0u, PROT_SET_Q10(120.0), 0, PROT_SET_Q10(200.0) }, /* 过压 V */ { 0x802A, 0u, PROT_SET_Q10(10000.0),0, PROT_SET_Q10(60000) }, { 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* UV 投退(本地) */ { 0x8027, 0u, PROT_SET_Q10(20.0), 0, PROT_SET_Q10(200.0) }, /* 欠压 V */ { 0x8028, 0u, PROT_SET_Q10(10000.0),0, PROT_SET_Q10(60000) }, { 0x888E, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* 3U0 投退 */ { 0x888F, 0u, PROT_SET_Q10(15.0), 0, PROT_SET_Q10(200.0) }, /* 3U0 V */ { 0x8890, 0u, PROT_SET_Q10(5000.0), 0, PROT_SET_Q10(60000) }, { 0x0000, 0u, PROT_SET_Q10(0.95), PROT_SET_Q10(0.5), PROT_SET_Q10(1.0) }, /* 过量返回系数 */ { 0x0000, 0u, PROT_SET_Q10(1.05), PROT_SET_Q10(1.0), PROT_SET_Q10(1.5) }, /* 欠量返回系数 */ { 0x8820, 0u, PROT_SET_Q10(10000.0),PROT_SET_Q10(100.0), PROT_SET_Q10(500000.0) }, { 0x8821, 0u, PROT_SET_Q10(100.0), PROT_SET_Q10(1.0), PROT_SET_Q10(200.0) }, { 0x8825, 0u, PROT_SET_Q10(100.0), PROT_SET_Q10(1.0), PROT_SET_Q10(10000.0) }, { 0x8826, 0u, PROT_SET_Q10(5.0), PROT_SET_Q10(1.0), PROT_SET_Q10(10.0) }, { 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* 全局软压板投退(YK12,B7) */ /* --- 过频 / 低频(B8):地址全 0 = 本地项(参考逐项地址不在 * 本仓库,规划 §5.1 仅示"8820~8882 含低压/低频"类目); * 默认值/范围**拟定**(DTU 馈线典型量级),待对照参考出厂表修订 --- */ { 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* OF 投退(本地) */ { 0x0000, 0u, PROT_SET_Q10(51.0), PROT_SET_Q10(50.0), PROT_SET_Q10(55.0) }, /* OF 动作频率 Hz */ { 0x0000, 0u, PROT_SET_Q10(1000.0), 0, PROT_SET_Q10(60000) }, /* OF 延时 ms */ { 0x0000, 1u, PROT_SET_Q10(1), 0, PROT_SET_Q10(1) }, /* UF 投退(本地) */ { 0x0000, 0u, PROT_SET_Q10(49.0), PROT_SET_Q10(45.0), PROT_SET_Q10(50.0) }, /* UF 动作频率 Hz */ { 0x0000, 0u, PROT_SET_Q10(1000.0), 0, PROT_SET_Q10(60000) }, /* UF 延时 ms */ { 0x0000, 0u, PROT_SET_Q10(0.99), PROT_SET_Q10(0.9), PROT_SET_Q10(1.0) }, /* 过频返回系数 */ { 0x0000, 0u, PROT_SET_Q10(1.01), PROT_SET_Q10(1.0), PROT_SET_Q10(1.1) }, /* 低频返回系数 */ }; static volatile uint32_t s_val[2][PS_ID_COUNT]; /* 双缓冲值区(uint32 承载 int32,校验和按字覆盖) * B7:写者改影子区后单字交换 s_act, * 读侧(protectTask selfcheck/get)永远看到一致快照 * 带 volatile:提交顺序(影子区写完 → 发布封存对 → * 交换活跃区)必须真的按这个顺序落到内存,编译器 * 不得把值区读写挪到提交序号前后 */ static volatile uint8_t s_act; /* 活跃区下标(0/1);交换 = 单字存储 */ static volatile uint32_t s_sum; /* 封存的正码(提交窗口内与 s_seq 配对发布) */ static volatile uint32_t s_sumn; /* 封存的反码 */ static volatile uint32_t s_seq; /* 提交序号:奇数 = 提交进行中;见 prot_write_enter */ static uint8_t s_odd_streak; /* 连续撞见奇数序号的次数(自检的 fail-safe 计数) */ static uint64_t s_bad_mask; /* 只由整表装载/解析写(见 prot_set_bad_mask) */ static volatile uint8_t s_locked; /* 定值非法 → 闭锁(定值校验和) */ static uint8_t s_dirty; /* 未落盘定值改动(B7 持久化脏标志) */ static prot_set_lock_t s_lock = { 0, 0 };/* 写事务锁钩子(成员为 0 = 未安装) */ /* 连续撞见"提交序号为奇"的容忍上限。正常提交窗口是微秒级,而 selfcheck 由 * protectTask 按 20 ms 节拍调用——连撞 8 拍(约 160 ms)还停在奇数,说明写者 * 不是"正在提交",而是死锁、被锁内异常路径卡住、或进入了永不返回的钩子。 * 此时值区的可信度无从判断,**闭锁保护是唯一 fail-safe 的选择**:宁可保护停走, * 也不能带着不可信的定值继续判据。取值理由:8 远大于任何真实临界区时长 * (微秒级 × 8 拍 = 160 ms 已是五个数量级的余量),又远小于"现场容忍保护 * 带着坏定值运行"的时长。 */ #define PROT_SET_ODD_STREAK_MAX 8u /* * 函数功能:sum32 覆盖指定值区(参考 Fun_CalSum32 同款:32 位字累加自然回绕) * 入口参数:vals - PS_ID_COUNT 个字的值区 * 返 回 值:校验和正码 * 函数说明:形参带 volatile——读侧拿提交序号做 seqlock,求和若被编译器整体 * 提到序号读之前,序号校验就形同虚设(非 volatile 的数组访问没有 * 与 volatile 访问之间的顺序约束) */ static uint32_t prot_sum_buf(const volatile uint32_t *vals) { uint32_t sum = 0u; uint32_t i; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { sum += vals[i]; } return sum; } /* ==================== 写事务(多写者 + 读侧无锁快照) ==================== * 双缓冲只保证"读侧看到完整快照",不保证写者之间不交错。三个写入口 * (set_sealed / apply_batch / load_raw)统一这样进提交: * enter:先拿平台锁(若已装钩子)→ 提交序号变奇(标记"提交进行中") * 提交:影子区改值 → 写 s_sum/s_sumn → s_locked=0 → 单字交换 s_act * exit :提交序号回偶 → 放平台锁 * 读侧(selfcheck)靠序号奇偶+双读判定"这轮撞上提交窗口",只跳过不判失配; * 写者之间靠平台锁串行——否则两方会同时改同一块影子区,交换出撕裂值区。 * 单核 Cortex-M4 上对齐 32 位读写在指令级原子,序号发布无需屏障指令。 */ /* * 函数功能:进入写事务(拿平台锁 + 提交序号变奇) * 入口参数:无 * 返 回 值:无 * 函数说明:调用方保证 enter/exit 严格成对——本模块把全部校验放在 enter 之前, * enter 之后不存在"提前返回"分支,因此不需要成对清账的失败路径 */ static void prot_write_enter(void) { if (s_lock.enter != 0) { s_lock.enter(); } s_seq = s_seq + 1u; /* 奇数:从现在起读侧看到的可能是中间态 */ } /* * 函数功能:退出写事务(提交序号回偶 + 放平台锁) * 入口参数:无 * 返 回 值:无 * 函数说明:先发布偶数(值区与封存对此刻已一致),再放锁——读侧不会读到 * "锁已放、序号仍奇"的稳态;本函数与 prot_write_enter 一一对应 */ static void prot_write_exit(void) { s_seq = s_seq + 1u; /* 偶数:提交完成 */ if (s_lock.exit != 0) { s_lock.exit(); } } /* * 函数功能:安装/卸载写事务锁钩子 * 入口参数:lock - 钩子(NULL = 卸载回单写者假设) * 返 回 值:无 * 限定条件:任何写者启动前安装;本函数不加锁、不可重入(改的是两个函数指针) */ void prot_set_lock_install(const prot_set_lock_t *lock) { if (lock == 0) { s_lock.enter = 0; s_lock.exit = 0; return; } s_lock.enter = lock->enter; s_lock.exit = lock->exit; } /* * 函数功能:定值编号是否在表内(批量接口的守门) * 入口参数:id - 待查编号 * 返 回 值:1 合法 / 0 越界 * 函数说明:只守上界。prot_set_id_t 的底层类型是无符号的(枚举成员全非负, * ARMCC/MSVC 都取 unsigned int),负值强转进来会被解释成一个巨大的 * 无符号数,同样落在 >= PS_ID_COUNT 这一侧,由这条判据一并拦下—— * 所以不需要也不该写 (int32_t)id < 0 那种恒假分支。 */ static uint8_t prot_id_valid(prot_set_id_t id) { if ((uint32_t)id >= (uint32_t)PS_ID_COUNT) { return 0u; } return 1u; } /* * 函数功能:整块复制值区(影子区 ← 活跃区) * 入口参数:dst - 目标值区;src - 源值区 * 返 回 值:无 * 函数说明:不用 memcpy——两个值区都是 volatile(见 s_val 的注释),memcpy 的 * 形参是普通指针,塞进去等于把 volatile 语义丢掉、编译器还可自由 * 重排;40 个字的手写循环一样短,顺序也一眼可读 */ static void prot_copy_buf(volatile uint32_t *dst, const volatile uint32_t *src) { uint32_t i; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { dst[i] = src[i]; } } /* * 函数功能:把元数据表默认值刷进 RAM 值区 * 入口参数:无 * 返 回 值:无 */ static void prot_load_defaults(void) { uint32_t i; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { s_val[s_act][i] = (uint32_t)g_prot_set_meta[i].def; } } /* * 函数功能:装载出厂默认值并封存校验和(幂等) * 入口参数:无 * 返 回 值:无 */ void prot_set_init(void) { prot_load_defaults(); s_bad_mask = 0u; s_locked = 0u; s_dirty = 0u; s_seq = 0u; /* 装载期不属于"提交",序号回静止态(偶数) */ s_odd_streak = 0u; /* 宽限计数同步归零:init 是唯一的重来一次入口 */ prot_set_seal(); } /* * 函数功能:取最近一次**整表装载/解析**的越界位图 * 入口参数:无 * 返 回 值:bit i = 第 i 项越界 * 函数说明:只由 prot_set_load_raw / prot_set_store_parse 写(头文件把这条 * 契约写死了)。单项/批量增量写入既不写也不清它——增量写入失败一律 * 以返回值表达,看位图会读到上一次整表装载的旧结果。 */ uint64_t prot_set_bad_mask(void) { return s_bad_mask; } /* * 函数功能:整表装载外部值(P4 起由 cfg_file 定值段调用),逐项范围校验 * 入口参数:vals - PS_ID_COUNT 个 Q10 值 * 返 回 值:0 全部合法(已装载并封存)/ -1 存在越界项或空指针(整表不装载) * 函数说明:all-or-nothing——宁可全旧不可半新(定值一致性优先); * 越界项经 prot_set_bad_mask() 指认。 */ int prot_set_load_raw(const int32_t *vals) { uint64_t mask = 0u; uint32_t cur_act; volatile uint32_t *shadow; uint32_t i; if (vals == 0) { return -1; } for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { if ((vals[i] < g_prot_set_meta[i].min) || (vals[i] > g_prot_set_meta[i].max)) { mask |= (1uLL << i); } } s_bad_mask = mask; if (mask != 0u) { return -1; } /* 原子装载(B7):写影子区 → 封存 → 单字交换;读侧无中间态。 * 写事务(多写者):校验全在锁外,锁内只做提交,出锁即完成 */ prot_write_enter(); cur_act = s_act; shadow = s_val[cur_act ^ 1u]; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { shadow[i] = (uint32_t)vals[i]; } s_sum = prot_sum_buf(shadow); s_sumn = ~s_sum; s_locked = 0u; s_act = (uint8_t)(cur_act ^ 1u); prot_write_exit(); return 0; } /* * 函数功能:单项写入(范围校验) * 入口参数:id - 定值项编号;q10 - Q10 定点值 * 返 回 值:0 / -1 越界或非法编号拒写(原值不动) * 函数说明:**不自动重封校验和**——批量改完必须显式 prot_set_seal(), * 否则 selfcheck 判"定值被非法改写"(参考系统改定值走重写整表)。 */ int prot_set_set(prot_set_id_t id, int32_t q10) { if (id >= PS_ID_COUNT) { return -1; } if ((q10 < g_prot_set_meta[id].min) || (q10 > g_prot_set_meta[id].max)) { return -1; } s_val[s_act][(uint32_t)id] = (uint32_t)q10; return 0; } /* * 函数功能:单项**原子**写入+封存(B7,收口 B5 竞态窗口) * 入口参数:id - 定值项编号;q10 - Q10 定点值 * 返 回 值:0 / -1 越界或非法编号拒写(原值不动) * 函数说明:影子区拷贝 → 改影子 → 按影子重封校验和 → 单字交换活跃区。 * selfcheck 任何时刻看到的都是"值区与封存一致"的完整快照 * (区别于 prot_set_set+seal 批处理路径;两路径勿在一次批处理中交错)。 * 置脏标志 → 104 任务通知 defaultTask(配置引擎属主)落盘。 */ int prot_set_set_sealed(prot_set_id_t id, int32_t q10) { uint32_t cur_act; volatile uint32_t *shadow; if (!prot_id_valid(id)) { return -1; } if ((q10 < g_prot_set_meta[id].min) || (q10 > g_prot_set_meta[id].max)) { return -1; } /* 校验在锁外(失败不进锁);锁内只有提交,无提前返回 */ prot_write_enter(); cur_act = s_act; shadow = s_val[cur_act ^ 1u]; prot_copy_buf(shadow, s_val[cur_act]); shadow[(uint32_t)id] = (uint32_t)q10; s_sum = prot_sum_buf(shadow); s_sumn = ~s_sum; s_locked = 0u; s_act = (uint8_t)(cur_act ^ 1u); /* 单字交换:读侧原子切换 */ s_dirty = 1u; prot_write_exit(); return 0; } /* * 函数功能:读一批定值当前值(Q10 工程量) * 入口参数:ids - 编号数组;n - 个数;out - 输出数组(out[i] 对应 ids[i]) * 返 回 值:0 成功 / -1 参数非法(空指针、n 为 0、n 超上限、任一号越界) * 限定条件:任意上下文安全,不持锁、不进写事务、**绝不无界等待** * 函数说明:先捕获提交序号与活跃区下标,整批都从这**同一块**值区取; * 取完复核序号——期间发生过提交即重取(有限次)。写者只有 104 下发 * 与本地整定两类人工操作,重取次数实际为 0 或 1;不无界自旋是因为 * 读侧可能是高优先级任务,而它等的写者正被自己抢占——自旋就是死等。 * 连续多次提交时退化为"跨提交的混合值",与此前逐项 prot_set_get 的 * 语义同级,不会撕裂结构、更不会触发闭锁。 */ int prot_set_read_batch(const prot_set_id_t *ids, size_t n, int32_t *out) { uint32_t seq_a; uint32_t seq_b; const volatile uint32_t *row; uint32_t tries = 0u; size_t i; if ((ids == 0) || (out == 0)) { return -1; } if ((n == 0u) || (n > PROT_SET_BATCH_MAX)) { return -1; } for (i = 0u; i < n; i++) { if (!prot_id_valid(ids[i])) { return -1; } } do { seq_a = s_seq; row = s_val[s_act]; for (i = 0u; i < n; i++) { out[i] = (int32_t)row[(uint32_t)ids[i]]; } seq_b = s_seq; tries++; } while ((((seq_a & 1u) != 0u) || (seq_a != seq_b)) && (tries < 3u)); return 0; } /* * 函数功能:原子写入一批定值 * 入口参数:changes - 变更数组;n - 个数;validate_only - 非 0 只校验 * 返 回 值:0 整批合法 / -1 有非法项(值区一字未改) * 限定条件:validate_only 分支零副作用——不置脏、不动值区、不动闭锁位、不进写事务 * 函数说明:校验全在锁外(元数据表是 ROM 常量,校验不碰 RAM 状态); * 提交在写事务锁内一次完成:拷活跃区到影子 → 改 n 项 → 重算封存对 → * 清闭锁 → 单字交换 → 置脏。任一项非法即一字未改地返回。 * ⚠ 基准值必须**在锁内**取:若在锁外先把活跃区抄到栈上再进锁, * 这中间被另一个写者提交,就会用旧基准覆盖掉它的改动(丢写)。 */ int prot_set_apply_batch(const prot_set_change_t *changes, size_t n, int validate_only) { uint32_t cur_act; volatile uint32_t *shadow; size_t i; size_t j; if ((changes == 0) || (n == 0u) || (n > PROT_SET_BATCH_MAX)) { return -1; } for (i = 0u; i < n; i++) { if (!prot_id_valid(changes[i].id)) { return -1; } if ((changes[i].q10 < g_prot_set_meta[changes[i].id].min) || (changes[i].q10 > g_prot_set_meta[changes[i].id].max)) { return -1; } for (j = i + 1u; j < n; j++) { if (changes[j].id == changes[i].id) { return -1; /* 同批同项两条:语义不确定,拒整批 */ } } } if (validate_only != 0) { return 0; /* 预检到此为止:以上只有局部变量与 ROM 表,零副作用 */ } prot_write_enter(); cur_act = s_act; shadow = s_val[cur_act ^ 1u]; prot_copy_buf(shadow, s_val[cur_act]); for (i = 0u; i < n; i++) { shadow[(uint32_t)changes[i].id] = (uint32_t)changes[i].q10; } s_sum = prot_sum_buf(shadow); s_sumn = ~s_sum; s_locked = 0u; s_act = (uint8_t)(cur_act ^ 1u); /* 单字交换:读侧原子切换 */ s_dirty = 1u; prot_write_exit(); return 0; } /* * 函数功能:脏标志三件套(B7 持久化握手) * 入口参数:无 * 返 回 值:peek/take = 1 存在未落盘改动 / 0 干净;mark 无返回 * 函数说明:peek 非消费(iec104Task 每轮通知,直到落盘成功); * take 消费(defaultTask 落盘前);mark 写盘失败回置(等下轮重试)。 * 单字节标志,多读者安全;写者只有 set_sealed/apply_batch(置)与 * 属主任务(清/置)。 */ uint8_t prot_set_dirty_peek(void) { return s_dirty; } uint8_t prot_set_dirty_take(void) { uint8_t d = s_dirty; s_dirty = 0u; return d; } void prot_set_dirty_mark(void) { s_dirty = 1u; } /* * 函数功能:读定值 Q10 原值 * 入口参数:id - 定值项编号 * 返 回 值:Q10 值;非法编号返回 0 */ int32_t prot_set_get(prot_set_id_t id) { if (id >= PS_ID_COUNT) { return 0; } return (int32_t)s_val[s_act][(uint32_t)id]; } /* * 函数功能:读定值工程量浮点值 * 入口参数:id - 定值项编号 * 返 回 值:Q10 → float;非法编号返回 0.0 */ float prot_set_get_f(prot_set_id_t id) { return PROT_SET_FROM_Q10(prot_set_get(id)); } /* * 函数功能:读投退/枚举项 * 入口参数:id - 定值项编号 * 返 回 值:!=0 视为投入(1/0) */ uint8_t prot_set_get_ctl(prot_set_id_t id) { return (prot_set_get(id) != 0) ? 1u : 0u; } /* * 函数功能:实时计算校验和(不读封存值) * 入口参数:无 * 返 回 值:sum32 正码 */ uint32_t prot_set_checksum(void) { return prot_sum_buf(s_val[s_act]); } /* * 函数功能:封存当前值区的正/反码对(合法改定值闭环的最后一步) * 入口参数:无 * 返 回 值:无 * 函数说明:封存同时解除闭锁——selfcheck 失配后的唯一合法解锁路径。 * ⚠ 批处理路径(prot_set_set 多次 + 本函数收尾)在 set 与 seal * 之间存在"已改值未封存"窗口,selfcheck 会如实判失配(防篡改语义); * 板端单项写一律走 prot_set_set_sealed(原子,无此窗口)。 */ void prot_set_seal(void) { s_sum = prot_sum_buf(s_val[s_act]); s_sumn = ~s_sum; s_locked = 0u; } /* * 函数功能:定值自检(定值校验和)——重算 sum32 并与封存值比对 * 入口参数:无 * 返 回 值:0 通过 / -1 失配(已置闭锁) * 函数说明:失配 → s_locked 置位并保持,直到下一次 seal; * 元件层每拍读 prot_set_locked() 决定整体复位(联动闭锁)。 * 读侧无锁,靠两重旁证识别"提交进行中": * ① 提交序号 s_seq 为奇 = 有写者在提交窗口内 → 本轮不作数; * ② 起止各读一次序号与封存和,任一变化 = 期间发生过提交 → 本轮不作数。 * 两者只**跳过本轮**,绝不据此判失配——提交途中被巡检撞见就闭锁整台 * 保护,正是多写者引入的安全级风险。真正的失配(值区与封存对不符且 * 没有提交在飞)仍照常闭锁。 * ⚠ fail-safe:跳过必须**有界**。若写者在 prot_write_enter 之后走进 * 永不返回的路径(锁内提前 return 忘了 exit、钩子死锁、被永久抢占), * s_seq 会永远停在奇数,而"跳过本轮"会让防篡改自检永久失效且无人察觉 * ——保护静默失去整台闭锁能力。故连撞 PROT_SET_ODD_STREAK_MAX 拍即判 * 闭锁:那时已不是"正在提交",而是写者已死,值区不可信。 */ int prot_set_selfcheck(void) { uint32_t seq_a = s_seq; uint32_t sum_a; uint32_t sum_b; uint32_t seq_b; uint8_t act_a; uint8_t act_b; uint32_t calc; if ((seq_a & 1u) != 0u) { if (s_odd_streak < 255u) { s_odd_streak++; } if (s_odd_streak >= (uint8_t)PROT_SET_ODD_STREAK_MAX) { s_locked = 1u; /* 写者长期停在提交窗口内:值区不可信 → 闭锁 */ } return (s_locked != 0u) ? -1 : 0; } s_odd_streak = 0u; /* 序号已回静止态:宽限期重新开始计 */ sum_a = s_sum; act_a = s_act; /* 先固定值区:下面的求和只依赖这一个 volatile 读 */ calc = prot_sum_buf(s_val[act_a]); act_b = s_act; sum_b = s_sum; seq_b = s_seq; if ((seq_a != seq_b) || (sum_a != sum_b) || (act_a != act_b)) { /* 检查期间有 set_sealed/apply_batch/load_raw 提交:本轮跳过 */ return (s_locked != 0u) ? -1 : 0; } if ((calc != sum_a) || (sum_a != ~s_sumn)) { s_locked = 1u; /* 值区与封存不符:定值被非法改写 → 闭锁 */ } return (s_locked != 0u) ? -1 : 0; } /* * 函数功能:读闭锁状态 * 入口参数:无 * 返 回 值:1 = 定值非法(保护应整体闭锁)/ 0 = 正常 */ uint8_t prot_set_locked(void) { return s_locked; } /* ==================== 持久化 blob(B7,纯逻辑) ========================= */ /* 小端编解码(blob 跨端一致;主机单测与 MCU 同一份字节口径) */ /* * 函数功能:16 位值按小端写入缓冲 * 入口参数:p - 写位置(≥2 字节余量);v - 值 * 返 回 值:无 */ static void s_put16(uint8_t *p, uint16_t v) { p[0] = (uint8_t)(v & 0xFFu); p[1] = (uint8_t)(v >> 8); } /* * 函数功能:32 位值按小端写入缓冲 * 入口参数:p - 写位置(≥4 字节余量);v - 值 * 返 回 值:无 */ static void s_put32(uint8_t *p, uint32_t v) { p[0] = (uint8_t)(v & 0xFFu); p[1] = (uint8_t)((v >> 8) & 0xFFu); p[2] = (uint8_t)((v >> 16) & 0xFFu); p[3] = (uint8_t)(v >> 24); } /* * 函数功能:从小端缓冲读 16 位值 * 入口参数:p - 读位置 * 返 回 值:值 uint16_t */ static uint16_t s_get16(const uint8_t *p) { return (uint16_t)((uint32_t)p[0] | ((uint32_t)p[1] << 8)); } /* * 函数功能:从小端缓冲读 32 位值 * 入口参数:p - 读位置 * 返 回 值:值 uint32_t */ static uint32_t s_get32(const uint8_t *p) { return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24); } /* * 函数功能:把当前值区序列化为 blob(校验和按值区现算,不依赖封存值) * 入口参数:p_buf - 输出缓冲;cap - 容量;p_len - 实际长度输出 * 返 回 值:0 / -1 参数非法或容量不足 * 函数说明:落盘是整表字节流,混进两次提交的值就会被原样写进文件、下次开机 * 当合法档案装载回来(校验对是按同一份混合值算的,自洽)。故与 * prot_set_read_batch 同用提交序号做有限次重取:期间有提交即重来。 */ int prot_set_store_serialize(uint8_t *p_buf, uint32_t cap, uint32_t *p_len) { uint32_t seq_a = 0u; uint32_t seq_b; const volatile uint32_t *vals; uint32_t sum = 0u; uint32_t tries = 0u; uint32_t i; if ((p_buf == 0) || (p_len == 0) || (cap < PROT_SET_BLOB_SZ)) { return -1; } do { seq_a = s_seq; vals = s_val[s_act]; sum = 0u; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { s_put32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i, vals[i]); sum += vals[i]; } seq_b = s_seq; tries++; } while ((((seq_a & 1u) != 0u) || (seq_a != seq_b)) && (tries < 3u)); s_put32(p_buf, PROT_SET_BLOB_MAGIC); s_put16(p_buf + 4u, (uint16_t)PROT_SET_BLOB_VER); s_put16(p_buf + 6u, (uint16_t)PS_ID_COUNT); s_put32(p_buf + PROT_SET_BLOB_SZ - 8u, sum); s_put32(p_buf + PROT_SET_BLOB_SZ - 4u, ~sum); *p_len = PROT_SET_BLOB_SZ; return 0; } /* * 函数功能:解析 blob 并**整表原子**装载(all-or-nothing) * 入口参数:p_buf/len - blob 字节流 * 返 回 值:0 已装载并封存 / -1 拒绝(magic/版本/长度/校验对不符或任一项 * 越界 → 活跃值区一字不动;越界项经 prot_set_bad_mask() 指认) * 函数说明:校验在写事务之外完成(只读入参字节流,不碰任何 RAM 状态), * 全部通过才进锁把值写进影子区并交换——损坏 blob 不可能污染在用的 * 定值(掉电/写坏/版本换代同一路径),也不可能在锁内做无用功。 * ⚠ 校验必须**不写影子区**:影子区是与其他写者共享的暂存面, * 锁外往里写就等于绕过写事务(另一写者的提交会被覆盖)。 */ int prot_set_store_parse(const uint8_t *p_buf, uint32_t len) { uint32_t cur_act; volatile uint32_t *shadow; uint32_t sum = 0u; uint64_t mask = 0u; uint32_t i; if ((p_buf == 0) || (len != PROT_SET_BLOB_SZ)) { return -1; } if (s_get32(p_buf) != PROT_SET_BLOB_MAGIC) { return -1; } if (s_get16(p_buf + 4u) != (uint16_t)PROT_SET_BLOB_VER) { return -1; } if (s_get16(p_buf + 6u) != (uint16_t)PS_ID_COUNT) { return -1; } /* 第一遍:只算和 + 查范围,不落任何 RAM */ for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { uint32_t v = s_get32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i); sum += v; if (((int32_t)v < g_prot_set_meta[i].min) || ((int32_t)v > g_prot_set_meta[i].max)) { mask |= (1uLL << i); } } if (sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 8u)) { return -1; /* 校验和正码不符 */ } if (~sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 4u)) { return -1; /* 反码对不符 */ } s_bad_mask = mask; if (mask != 0u) { return -1; /* 校验对一致但含越界项:同样整表拒绝 */ } /* 第二遍:锁内写入影子区并交换(无提前返回,enter/exit 天然成对) */ prot_write_enter(); cur_act = s_act; shadow = s_val[cur_act ^ 1u]; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { shadow[i] = s_get32(p_buf + PROT_SET_BLOB_HDR_SZ + 4u * i); } s_sum = prot_sum_buf(shadow); s_sumn = ~s_sum; s_locked = 0u; s_act = (uint8_t)(cur_act ^ 1u); prot_write_exit(); return 0; }