perf(iec104): 参数区按 17 项真实消费者收窄并接上真实定值模型
104 协议侧参数通道此前镜像了厂商点表的全部 430 条参数(697 槽), 但其中 413 条在本设备上没有任何消费者——104 与设备侧真实定值模型 prot_set 之间零调用,主站改定值只落在无人读的 RAM 镜像里,保护功能 毫无感知。本次按"严格按消费者收窄"口径收口: 可见性以 iec104_dtu_protection_mapping() 语义桥表为唯一判据,只放行 三段过流投退/定值/延时(9 项)、低压与过压定值/延时(4 项)、PT 与 CT 一次/二次额定(4 项)。其余参数在位表枚举层即不可见,主站读取 得到 COT=47 + P/N=1 的显式否定确认,不静默丢弃。values[697]→values[53]、 staged[264]→staged[17],并删除生成式 iec104_source_ranks.h。 桥表接真实源:iec104_serv 的 parameter_read/apply 从 NULL 改为直读 prot_set 与整批原子提交,Q10 量化后一次事务落地,持久化仍由 defaultTask 的脏标志闭环负责。 prot_set 因此出现两个运行时写者(netTask 的 104 与 uiTask 的本地整 定),原"写者靠启动时序串行"的约定失效。加入写事务互斥与 seqlock 序号:四个写入口全部进锁,校验与提前返回一律在 enter 之前;序号卡 奇数连续 8 拍即判保护闭锁,避免自检被永久跳过而静默失去防篡改能力。 锁的安装在 defaultTask 的存储 bring-up 阶段,不在 app_main_init—— 后者早于 osKernelInitialize,内核启动前禁止任何 RTOS 创建类 API。 实测:RW_IRAM1 117,304→113,720 B(−3,584 B,89.50%→86.76%); ER_IROM1 413,392→411,668 B(−1,724 B);iec104_source.o 5,656→2,056 B; prot_set.o 344→352 B(+8 B,写事务序号与锁句柄)。Keil 构建 0 错误 0 警告;主机侧 prot_set 175/175、iec104_dtu 7/7;真实 TCP 验收 13/13;暂存口径门禁 18 项全通过。 已知边界:模拟器不链接 iec104_serv.c,TCP 验收不覆盖 prot_set 绑定, 板端需实机确认主站写入能反映到本地定值页;17 项中 15 项的出厂默认 值与点表字面量不同,主站读到的是真实模型的值;绑定真实源后定值区 切换一律拒绝(单套活跃值无原子整区事务)。
This commit is contained in:
+308
-46
@@ -1,7 +1,9 @@
|
||||
/*
|
||||
* 模块名称:保护定值模型(P1,定值校验和 载体)——实现
|
||||
*(保护功能清单见 docs/算法/继电保护功能复现规划.md)
|
||||
* 模块功能:见 prot_set.h。纯逻辑,零平台依赖(仅 stdint.h + 自身头)。
|
||||
* 模块功能:见 prot_set.h。纯逻辑,零平台依赖(仅 stdint.h + size_t + 自身头);
|
||||
* 写事务保护只持有**两个函数指针**(prot_set_lock_t),由平台侧在安装时注入,
|
||||
* 本文件不认识任何 RTOS/HAL 符号——固件、模拟器、主机单测三方共用同一份源码。
|
||||
*
|
||||
* ⚠ 默认值/范围为拟定值(参考 EEPROM 出厂默认表不在本仓库,规划 §10.3 待补);
|
||||
* 通讯地址逐项对照参考 Comm/Pub/Const_CommSetPara.c g_tCommSetParaTab。
|
||||
@@ -18,8 +20,6 @@
|
||||
*/
|
||||
#include "prot_set.h"
|
||||
|
||||
#include <string.h> /* memcpy(set_sealed 影子区拷贝,B7) */
|
||||
|
||||
/* 元数据表:顺序必须与 prot_set_id_t 严格一致(逐行带地址注释,同 phasor
|
||||
* k_inst 的朴素行式风格) */
|
||||
const prot_set_meta_t g_prot_set_meta[PS_ID_COUNT] = {
|
||||
@@ -69,22 +69,41 @@ const prot_set_meta_t g_prot_set_meta[PS_ID_COUNT] = {
|
||||
{ 0x0000, 0u, PROT_SET_Q10(1.01), PROT_SET_Q10(1.0), PROT_SET_Q10(1.1) }, /* 低频返回系数 */
|
||||
};
|
||||
|
||||
static uint32_t s_val[2][PS_ID_COUNT]; /* 双缓冲值区(uint32 承载 int32,校验和按字覆盖)
|
||||
static volatile uint32_t s_val[2][PS_ID_COUNT];
|
||||
/* 双缓冲值区(uint32 承载 int32,校验和按字覆盖)
|
||||
* B7:写者改影子区后单字交换 s_act,
|
||||
* 读侧(protectTask selfcheck/get)永远看到一致快照 */
|
||||
* 读侧(protectTask selfcheck/get)永远看到一致快照
|
||||
* 带 volatile:提交顺序(影子区写完 → 发布封存对 →
|
||||
* 交换活跃区)必须真的按这个顺序落到内存,编译器
|
||||
* 不得把值区读写挪到提交序号前后 */
|
||||
static volatile uint8_t s_act; /* 活跃区下标(0/1);交换 = 单字存储 */
|
||||
static uint32_t s_sum; /* 封存的正码 */
|
||||
static uint32_t s_sumn; /* 封存的反码 */
|
||||
static uint64_t s_bad_mask; /* load_raw/parse 越界位图(B8:40 项 → 64 位) */
|
||||
static uint8_t s_locked; /* 定值非法 → 闭锁(定值校验和) */
|
||||
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 uint32_t *vals) {
|
||||
static uint32_t prot_sum_buf(const volatile uint32_t *vals) {
|
||||
uint32_t sum = 0u;
|
||||
uint32_t i;
|
||||
|
||||
@@ -94,6 +113,93 @@ static uint32_t prot_sum_buf(const uint32_t *vals) {
|
||||
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 值区
|
||||
* 入口参数:无
|
||||
@@ -117,13 +223,18 @@ void prot_set_init(void) {
|
||||
s_bad_mask = 0u;
|
||||
s_locked = 0u;
|
||||
s_dirty = 0u;
|
||||
s_seq = 0u; /* 装载期不属于"提交",序号回静止态(偶数) */
|
||||
s_odd_streak = 0u; /* 宽限计数同步归零:init 是唯一的重来一次入口 */
|
||||
prot_set_seal();
|
||||
}
|
||||
|
||||
/*
|
||||
* 函数功能:取最近一次 load_raw 的越界位图
|
||||
* 函数功能:取最近一次**整表装载/解析**的越界位图
|
||||
* 入口参数:无
|
||||
* 返 回 值:bit i = 第 i 项越界(load_raw 失败后有效)
|
||||
* 返 回 值:bit i = 第 i 项越界
|
||||
* 函数说明:只由 prot_set_load_raw / prot_set_store_parse 写(头文件把这条
|
||||
* 契约写死了)。单项/批量增量写入既不写也不清它——增量写入失败一律
|
||||
* 以返回值表达,看位图会读到上一次整表装载的旧结果。
|
||||
*/
|
||||
uint64_t prot_set_bad_mask(void) {
|
||||
return s_bad_mask;
|
||||
@@ -139,7 +250,7 @@ uint64_t prot_set_bad_mask(void) {
|
||||
int prot_set_load_raw(const int32_t *vals) {
|
||||
uint64_t mask = 0u;
|
||||
uint32_t cur_act;
|
||||
uint32_t *shadow;
|
||||
volatile uint32_t *shadow;
|
||||
uint32_t i;
|
||||
|
||||
if (vals == 0) {
|
||||
@@ -154,7 +265,9 @@ int prot_set_load_raw(const int32_t *vals) {
|
||||
if (mask != 0u) {
|
||||
return -1;
|
||||
}
|
||||
/* 原子装载(B7):写影子区 → 封存 → 单字交换;读侧无中间态 */
|
||||
/* 原子装载(B7):写影子区 → 封存 → 单字交换;读侧无中间态。
|
||||
* 写事务(多写者):校验全在锁外,锁内只做提交,出锁即完成 */
|
||||
prot_write_enter();
|
||||
cur_act = s_act;
|
||||
shadow = s_val[cur_act ^ 1u];
|
||||
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
|
||||
@@ -164,6 +277,7 @@ int prot_set_load_raw(const int32_t *vals) {
|
||||
s_sumn = ~s_sum;
|
||||
s_locked = 0u;
|
||||
s_act = (uint8_t)(cur_act ^ 1u);
|
||||
prot_write_exit();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -196,23 +310,121 @@ int prot_set_set(prot_set_id_t id, int32_t q10) {
|
||||
*/
|
||||
int prot_set_set_sealed(prot_set_id_t id, int32_t q10) {
|
||||
uint32_t cur_act;
|
||||
uint32_t *shadow;
|
||||
volatile uint32_t *shadow;
|
||||
|
||||
if (id >= PS_ID_COUNT) {
|
||||
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];
|
||||
(void)memcpy(shadow, s_val[cur_act], sizeof(s_val[0]));
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -222,7 +434,8 @@ int prot_set_set_sealed(prot_set_id_t id, int32_t q10) {
|
||||
* 返 回 值:peek/take = 1 存在未落盘改动 / 0 干净;mark 无返回
|
||||
* 函数说明:peek 非消费(iec104Task 每轮通知,直到落盘成功);
|
||||
* take 消费(defaultTask 落盘前);mark 写盘失败回置(等下轮重试)。
|
||||
* 单字节标志,多读者安全;写者只有 set_sealed(置)与属主任务(清/置)。
|
||||
* 单字节标志,多读者安全;写者只有 set_sealed/apply_batch(置)与
|
||||
* 属主任务(清/置)。
|
||||
*/
|
||||
uint8_t prot_set_dirty_peek(void) {
|
||||
return s_dirty;
|
||||
@@ -299,17 +512,46 @@ void prot_set_seal(void) {
|
||||
* 返 回 值:0 通过 / -1 失配(已置闭锁)
|
||||
* 函数说明:失配 → s_locked 置位并保持,直到下一次 seal;
|
||||
* 元件层每拍读 prot_set_locked() 决定整体复位(联动闭锁)。
|
||||
* B7 双缓冲 + seqlock 式复核:先读封存和、再读值区、再读封存和,
|
||||
* 两次不同 = 检查期间发生了原子提交 → 本轮不作数(下拍再查),
|
||||
* 杜绝"提交瞬间被巡检撞见"的误锁(收口 B5 竞态窗口)。
|
||||
* 读侧无锁,靠两重旁证识别"提交进行中":
|
||||
* ① 提交序号 s_seq 为奇 = 有写者在提交窗口内 → 本轮不作数;
|
||||
* ② 起止各读一次序号与封存和,任一变化 = 期间发生过提交 → 本轮不作数。
|
||||
* 两者只**跳过本轮**,绝不据此判失配——提交途中被巡检撞见就闭锁整台
|
||||
* 保护,正是多写者引入的安全级风险。真正的失配(值区与封存对不符且
|
||||
* 没有提交在飞)仍照常闭锁。
|
||||
* ⚠ fail-safe:跳过必须**有界**。若写者在 prot_write_enter 之后走进
|
||||
* 永不返回的路径(锁内提前 return 忘了 exit、钩子死锁、被永久抢占),
|
||||
* s_seq 会永远停在奇数,而"跳过本轮"会让防篡改自检永久失效且无人察觉
|
||||
* ——保护静默失去整台闭锁能力。故连撞 PROT_SET_ODD_STREAK_MAX 拍即判
|
||||
* 闭锁:那时已不是"正在提交",而是写者已死,值区不可信。
|
||||
*/
|
||||
int prot_set_selfcheck(void) {
|
||||
uint32_t sum_a = s_sum;
|
||||
uint32_t calc = prot_sum_buf(s_val[s_act]);
|
||||
uint32_t sum_b = s_sum;
|
||||
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 (sum_a != sum_b) {
|
||||
/* 检查期间有 set_sealed/load_raw 提交:快照不一致,本轮跳过 */
|
||||
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)) {
|
||||
@@ -376,22 +618,35 @@ static uint32_t s_get32(const uint8_t *p) {
|
||||
* 函数功能:把当前值区序列化为 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) {
|
||||
const uint32_t *vals = s_val[s_act];
|
||||
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);
|
||||
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];
|
||||
}
|
||||
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;
|
||||
@@ -403,12 +658,15 @@ int prot_set_store_serialize(uint8_t *p_buf, uint32_t cap, uint32_t *p_len) {
|
||||
* 入口参数:p_buf/len - blob 字节流
|
||||
* 返 回 值:0 已装载并封存 / -1 拒绝(magic/版本/长度/校验对不符或任一项
|
||||
* 越界 → 活跃值区一字不动;越界项经 prot_set_bad_mask() 指认)
|
||||
* 函数说明:解码/校验全在影子区进行,只有全部通过才交换活跃区——
|
||||
* 损坏 blob 不可能污染在用的定值(掉电/写坏/版本换代同一路径)。
|
||||
* 函数说明:校验在写事务之外完成(只读入参字节流,不碰任何 RAM 状态),
|
||||
* 全部通过才进锁把值写进影子区并交换——损坏 blob 不可能污染在用的
|
||||
* 定值(掉电/写坏/版本换代同一路径),也不可能在锁内做无用功。
|
||||
* ⚠ 校验必须**不写影子区**:影子区是与其他写者共享的暂存面,
|
||||
* 锁外往里写就等于绕过写事务(另一写者的提交会被覆盖)。
|
||||
*/
|
||||
int prot_set_store_parse(const uint8_t *p_buf, uint32_t len) {
|
||||
uint32_t cur_act;
|
||||
uint32_t *shadow;
|
||||
volatile uint32_t *shadow;
|
||||
uint32_t sum = 0u;
|
||||
uint64_t mask = 0u;
|
||||
uint32_t i;
|
||||
@@ -425,33 +683,37 @@ int prot_set_store_parse(const uint8_t *p_buf, uint32_t len) {
|
||||
if (s_get16(p_buf + 6u) != (uint16_t)PS_ID_COUNT) {
|
||||
return -1;
|
||||
}
|
||||
cur_act = s_act;
|
||||
shadow = s_val[cur_act ^ 1u];
|
||||
/* 第一遍:只算和 + 查范围,不落任何 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);
|
||||
|
||||
shadow[i] = v;
|
||||
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; /* 校验和正码不符(影子区未交换前不可见,无害) */
|
||||
return -1; /* 校验和正码不符 */
|
||||
}
|
||||
if (~sum != s_get32(p_buf + PROT_SET_BLOB_SZ - 4u)) {
|
||||
return -1; /* 反码对不符 */
|
||||
}
|
||||
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
|
||||
if (((int32_t)shadow[i] < g_prot_set_meta[i].min)
|
||||
|| ((int32_t)shadow[i] > g_prot_set_meta[i].max)) {
|
||||
mask |= (1uLL << i);
|
||||
}
|
||||
}
|
||||
s_bad_mask = mask;
|
||||
if (mask != 0u) {
|
||||
return -1; /* 校验对一致但含越界项:同样整表拒绝 */
|
||||
}
|
||||
s_sum = sum;
|
||||
s_sumn = ~sum;
|
||||
/* 第二遍:锁内写入影子区并交换(无提前返回,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;
|
||||
}
|
||||
|
||||
+91
-8
@@ -13,17 +13,28 @@
|
||||
* - ⚠ 默认值/范围为**拟定值**:参考 EEPROM 出厂默认表未在本仓库,
|
||||
* 待对照后逐项修订(规划 §10.3 待补项);范围先按 DTU 馈线典型量级。
|
||||
*
|
||||
* 线程约定(B7 定):装载(init/store_parse)在 defaultTask(存储 bring-up,
|
||||
* STORAGE_READY 前);单项写在 iec104Task(C_SE/YK12,经 set_sealed 原子路径);
|
||||
* 落盘在 defaultTask(配置引擎属主)。读在保护消费者任务(快照值原子)。
|
||||
* 双缓冲交换 = 单字写,读侧永远看到一致快照;写者之间靠启动时序串行
|
||||
* (装载先于 NET_READY,104 写在其后)。
|
||||
* 线程约定(多写者 + 写事务锁):
|
||||
* 装载(init/store_parse)在 defaultTask(存储 bring-up);落盘在 defaultTask
|
||||
* (配置引擎属主);读在保护消费者任务(快照值原子,读接口一律不加锁)。
|
||||
* 运行时写者有两个——netTask(104 定值下发,走 apply_batch / set_sealed)与
|
||||
* uiTask(本地整定,经 ui_data 注入的 set_sealed)。
|
||||
* 双缓冲 + 单字交换只保证"读侧看到完整快照",**不保证写者之间不交错**:一方
|
||||
* 已写封存对、尚未交换活跃区时被另一方抢占,后者再交换一次,最终值区与封存
|
||||
* 对失配 → selfcheck 判"定值被非法改写" → 整台保护闭锁。所以写入口统一走
|
||||
* 写事务:可选 enter/exit 钩子(prot_set_lock_install 安装,板端接 RTOS 互斥
|
||||
* 量;模拟器与主机单测不装 = 单写者假设)包住"影子区改值 + 封存 + 交换",
|
||||
* 同时把提交序号置奇/回偶,selfcheck 借它识别"提交进行中"而不误判失配。
|
||||
* 跳过本轮是**有界**的:连撞 8 拍仍是奇数 → 判写者已死 → 闭锁(fail-safe,
|
||||
* 否则一条"锁内提前返回"的 bug 就会让防篡改自检永久静默失效)。
|
||||
* 本模块只持有两个函数指针,不 include 任何 RTOS/HAL 头——纯逻辑三方编译
|
||||
* (固件 / 模拟器 / 主机单测)不受影响。
|
||||
*
|
||||
* 创建日期:2026-10-11
|
||||
*/
|
||||
#ifndef PROT_SET_H
|
||||
#define PROT_SET_H
|
||||
|
||||
#include <stddef.h> /* size_t(批量接口) */
|
||||
#include <stdint.h>
|
||||
|
||||
/* Q10 定点:工程量 × 1024(与参考 2^10 口径一致)。
|
||||
@@ -115,8 +126,18 @@ void prot_set_init(void);
|
||||
*/
|
||||
int prot_set_load_raw(const int32_t *vals);
|
||||
|
||||
/* 越界位图(bit i = 第 i 项越界;load_raw 失败后有效。B8:项数 32→40,
|
||||
* 位图随项数扩为 64 位——消费方仅主机单测,板端闭锁走 prot_set_locked()) */
|
||||
/* 越界位图(bit i = 第 i 项越界)。
|
||||
*
|
||||
* ⚠ 契约(调用方必读):本函数返回的位图**只反映整表装载/解析**
|
||||
* (prot_set_load_raw / prot_set_store_parse)的越界结果,
|
||||
* 最后一次整表操作失败后有效,直到下一次整表操作或 prot_set_init 覆写。
|
||||
* **不随单项写入(prot_set_set / prot_set_set_sealed)或批量写入
|
||||
* (prot_set_apply_batch)变化**:增量写入的失败一律以函数返回 -1 表达,
|
||||
* 既不置位也不清位。
|
||||
* 推论:一笔成功的批量提交**不会**清掉历史上整表装载留下的越界位;
|
||||
* 反过来,一笔失败的批量提交也**不会**在位图上留下痕迹。拿位图反显
|
||||
* "刚才那批哪几项越界"是误用——请用 apply_batch 的返回值。
|
||||
* B8:项数 32→40,位图随项数扩为 64 位;板端闭锁走 prot_set_locked()。 */
|
||||
uint64_t prot_set_bad_mask(void);
|
||||
|
||||
/*
|
||||
@@ -133,7 +154,11 @@ uint8_t prot_set_get_ctl(prot_set_id_t id); /* 投退项:!=0 视为投入
|
||||
/* 校验和(定值校验和):sum32 覆盖 RAM 值区;seal 封存正/反码对 */
|
||||
uint32_t prot_set_checksum(void);
|
||||
void prot_set_seal(void);
|
||||
/* 自检:重算并与封存值比对,失配 → 置闭锁并返回 -1(已闭锁也返回 -1) */
|
||||
/* 自检:重算并与封存值比对,失配 → 置闭锁并返回 -1(已闭锁也返回 -1)。
|
||||
* 提交进行中(写者正在改值区/发封存对)撞见的中间态**只跳过本轮、不判失配**;
|
||||
* 但跳过是有界的:连续撞见"提交进行中"达 8 拍(约 160 ms)即视为写者已死,
|
||||
* 置闭锁并返回 -1(fail-safe:宁可保护停走,不可带不可信定值判据)。
|
||||
* 解锁的唯一合法路径是 prot_set_seal()(或 prot_set_init() 重装)。 */
|
||||
int prot_set_selfcheck(void);
|
||||
uint8_t prot_set_locked(void);
|
||||
|
||||
@@ -148,6 +173,64 @@ uint8_t prot_set_locked(void);
|
||||
*/
|
||||
int prot_set_set_sealed(prot_set_id_t id, int32_t q10);
|
||||
|
||||
/* ---------------- 批量读写(104 定值下发:PRE 预检 + SOL 原子提交) ----------------
|
||||
* 协议一次改 1..17 项,两段式:第一段只校验(不落任何状态),第二段整批提交。
|
||||
* 与单项 set_sealed 同一原子口径:任一项非法则整批一项都不改。
|
||||
*/
|
||||
|
||||
/* 一批定值变更(Q10 工程量)。同一批内 id 不得重复。 */
|
||||
typedef struct {
|
||||
prot_set_id_t id;
|
||||
int32_t q10;
|
||||
} prot_set_change_t;
|
||||
|
||||
/* 单批上限 = 整表 40 项(算法侧上限)。超过上限返回 -1,不做任何改动。
|
||||
* ⚠ 与协议上限的关系:40 是**本模型能接受的最大批量**(整表就 40 项);
|
||||
* IEC 60870-5-104 参数区另有 **17 项**的消费者上限,那是协议/调用方的
|
||||
* 约束,由调用方自己拦——本层不代拦。所以 18 项的一批在这里是合法的,
|
||||
* 接线方若想守 17 项,必须在上层先判,别指望这里替它拒。 */
|
||||
#define PROT_SET_BATCH_MAX ((size_t)PS_ID_COUNT)
|
||||
|
||||
/*
|
||||
* 函数功能:读一批定值当前值(Q10 工程量)
|
||||
* 入口参数:ids - 编号数组;n - 个数;out - 输出数组(out[i] 对应 ids[i])
|
||||
* 返 回 值:0 成功 / -1 参数非法(空指针、n 为 0、n 超过上限、任一号越界)
|
||||
* 限定条件:任意上下文安全——双缓冲保证读侧只看到完整快照,不需要持锁
|
||||
*/
|
||||
int prot_set_read_batch(const prot_set_id_t *ids, size_t n, int32_t *out);
|
||||
|
||||
/*
|
||||
* 函数功能:原子写入一批定值
|
||||
* 入口参数:changes - 变更数组;n - 个数;validate_only - 非 0 只校验
|
||||
* 返 回 值:0 整批合法(validate_only 时仅为"预检通过")/ -1 有非法项
|
||||
* 限定条件:两段式第一段(validate_only 非 0)**零副作用**——不置脏、不动值区、
|
||||
* 不动闭锁位、不进写事务锁;第二段(validate_only 为 0)先整批校验,
|
||||
* 任一项非法即一字未改地返回,全部合法才提交并置脏。
|
||||
* 函数说明:失败条件 = changes 为空、n 为 0、n 超上限、任一号越界、任一值越出
|
||||
* 该项 min/max、同批 id 重复。提交在写事务锁内完成(见下方钩子)。
|
||||
* 返 回 值补充(与 prot_set_bad_mask 的关系):**任何失败都不会反映到位图上**
|
||||
* ——成功也不清、失败也不置。要定位是哪一项不合法,请在调用前自己
|
||||
* 对照 g_prot_set_meta[id] 的 min/max 逐项查,或改用两段式第一段
|
||||
* 预检后自行分组重试;位图上看到的内容属于更早的整表装载。
|
||||
*/
|
||||
int prot_set_apply_batch(const prot_set_change_t *changes, size_t n, int validate_only);
|
||||
|
||||
/* 写事务锁钩子(可选)。未安装 = 调用方保证单写者(模拟器 / 主机单测即如此)。
|
||||
* enter/exit 必须成对;enter 允许阻塞,不得用关中断实现。 */
|
||||
typedef struct {
|
||||
void (*enter)(void);
|
||||
void (*exit)(void);
|
||||
} prot_set_lock_t;
|
||||
|
||||
/*
|
||||
* 函数功能:安装/卸载写事务锁
|
||||
* 入口参数:lock - 钩子(传 NULL = 卸载,退回单写者假设)
|
||||
* 返 回 值:无
|
||||
* 限定条件:应在任何写者启动前安装;本函数本身不加锁、不可重入。
|
||||
* 钩子只在"值区提交"这段临界区里被调用,读接口永不进入。
|
||||
*/
|
||||
void prot_set_lock_install(const prot_set_lock_t *lock);
|
||||
|
||||
/* 脏标志(存在未落盘的定值改动):set_sealed 置位;load/init 不置 */
|
||||
uint8_t prot_set_dirty_peek(void); /* 非消费(生产者用它通知属主任务) */
|
||||
uint8_t prot_set_dirty_take(void); /* 消费(属主任务落盘前取) */
|
||||
|
||||
Reference in New Issue
Block a user