wandering1/STM32F4-Base
1
0
Fork 0
Code Issues 29 Pull Requests 1 Actions Packages Projects 2 Releases Wiki Activity

控制台改单写者发送：defaultTask唯一发串口其余任务写环形缓冲，杜绝日志交错与脏指针入UART；溢出钩子加指针窗口校验、崩溃上报改显式长度

Browse Source
This commit is contained in:
Wanderingss
2026-09-24 23:47:23 +08:00
parent c075cfa076
commit 3763e699dc
8 changed files with 346 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Src/freertos.c
+56 -14
View File
@@ -269,12 +269,21 @@ void StartDefaultTask(void *argument)
/* 配置 poll 周期计数（每 4 次循环 = 2s 轮询一次，与引擎文档/模拟器一致） */
uint32_t cfg_poll_cnt = 0u;
/* 注册控制台写者：本任务此后是串口唯一发送者（其余任务只写环形缓冲）。
* 见 Src/usart.c "控制台单写者日志"——消除并发写造成的日志逐字符交错，
* 并让脏指针无法再进入 HAL_UART_Transmit 的缓冲遍历。 */
dbg_console_writer_attach();
for (;;) {
/* 等待"保存网络配置"请求：有请求立即唤醒；无请求 500ms 后返回
* （取代原 osDelay(500)：循环节奏不变，保存响应零空转） */
/* 等待"保存网络配置"或"控制台待发"：任一即醒；无事件 500ms 后返回
* （取代原 osDelay(500)：循环节奏不变，保存/日志响应零空转） */
if (sys_evtHandle != NULL) {
(void)osEventFlagsWait(sys_evtHandle, SYS_EVT_CFG_SAVE, osFlagsWaitAny, 500u);
(void)osEventFlagsWait(sys_evtHandle,
SYS_EVT_CFG_SAVE | SYS_EVT_CONSOLE_TX,
osFlagsWaitAny, 500u);
}
/* 控制台唯一发送点：把环形缓冲中的日志按块发出（无待发时立即返回） */
dbg_console_drain();
/* 执行待处理保存（配置引擎属主：写盘 + 成功后立即应用）；无请求 = 空操作 */
#if !defined(TEST_SUITE_STORAGE)
net_cfg_save_run();
@@ -633,38 +642,71 @@ static void default_task_net_cfg_save_notify(void)
}
#endif
/*
* 名称指针合法性校验（栈溢出/越界可能已破坏 TCB，指针不可信）：
* 只接受落在 Flash / 主 SRAM / CCM 映射范围内的指针；不校验就直接交给 UART，
* 钩子自身也会以同样方式崩（2026-09-24 实测 HardFault：BFAR=0x10010000 恰为
* CCM 末尾+1，PC 落在 HAL_UART_Transmit 的缓冲读取处）。
*/
static int hook_ptr_ok(const void *p)
{
uint32_t a = (uint32_t)p;
uint32_t win = 32u; /* 将要读取的最大字节数（任务名 ≤ 32） */
if ((a >= 0x08000000u) && (a <= (0x08100000u - win))) {
return 1; /* Flash（RO 区） */
}
if ((a >= 0x20000000u) && (a <= (0x20020000u - win))) {
return 1; /* SRAM1 + SRAM2 */
}
if ((a >= 0x10000000u) && (a <= (0x10010000u - win))) {
return 1; /* CCM（FreeRTOS 堆：TCB/栈所在） */
}
return 0;
}
/*
* 栈溢出钩子（configCHECK_FOR_STACK_OVERFLOW=2，2026-09-20 存储套件死机事故后加）：
* 溢出 = 内核状态已不可信，禁止走 printf/内核对象，裸 UART 报任务名后复位。
* 溢出 = 内核状态已不可信，禁止走 printf/内核对象/控制台锁，裸发固定文本后复位。
* 2026-09-24 加固：任务名先经范围校验并拷入本地缓冲（不再把 TCB 指针交给 UART），
* 指针不可信时打印占位文本——避免"上报崩溃的代码自己再崩一次"。
*/
void vApplicationStackOverflowHook(void *xTask, signed char *pcTaskName)
{
static const char msg_head[] = "\r\n[ERR] STACK OVERFLOW task=";
static const char msg_bad[] = "(name unavailable)";
uint16_t len = 0u;
(void)xTask;
HAL_UART_Transmit(&huart1, (const uint8_t *)msg_head,
(uint16_t)(sizeof(msg_head) - 1u), 0xFFFFu);
if (pcTaskName != NULL) {
uint16_t len = 0;
while (len < 32u && pcTaskName[len] != '\0') {
dbg_console_write_raw(msg_head, (unsigned)(sizeof(msg_head) - 1u));
if ((pcTaskName != NULL) && (hook_ptr_ok(pcTaskName) != 0)) {
while ((len < 32u) && (pcTaskName[len] != '\0')) {
len++;
}
HAL_UART_Transmit(&huart1, (const uint8_t *)pcTaskName, len, 0xFFFFu);
}
HAL_UART_Transmit(&huart1, (const uint8_t *)"\r\n", 2u, 0xFFFFu);
if (len == 0u) {
dbg_console_write_raw(msg_bad, (unsigned)(sizeof(msg_bad) - 1u));
} else {
char name[33]; /* 拷入本地缓冲：UART 永不接触 TCB 指针 */
memcpy(name, pcTaskName, (size_t)len);
name[len] = '\0';
dbg_console_write_raw(name, (unsigned)len);
}
dbg_console_write_raw("\r\n", 2u);
HAL_Delay(200);
NVIC_SystemReset();
}
/*
* 堆分配失败钩子：只告警不复位（NULL 由各调用点自行处理并上报自检）。
* 同样走裸 UART——钩子可能在临界区内被调，printf/信号量不可用。
* 同样走裸 UART 有界发送——钩子可能在临界区内被调，printf/信号量不可用。
*/
void vApplicationMallocFailedHook(void)
{
static const char msg[] = "\r\n[ERR] MALLOC FAILED (heap exhausted)\r\n";
HAL_UART_Transmit(&huart1, (const uint8_t *)msg,
(uint16_t)(sizeof(msg) - 1u), 0xFFFFu);
dbg_console_write_raw(msg, (unsigned)(sizeof(msg) - 1u));
}
/* USER CODE END Application */
Src/stm32f4xx_it.c
+23 -17
View File
@@ -118,16 +118,22 @@ __asm void HardFault_Handler(void)
* 函数说明：直接 HAL_UART_Transmit 轮询输出 PC/LR/xPSR 与 CFSR/HFSR 故障
* 寄存器，供开机日志定位崩溃点（对照 .map 找符号）；输出后复位。
*/
static void hard_fault_puts(const char *s)
static void hard_fault_write(const char *s, uint16_t len)
{
uint16_t len = 0;
while (s[len] != '\0') {
len++;
/* 显式长度 + 有界单次发送：上报路径自身不得再崩（2026-09-24 加固；
* 不做 '\0' 遍历，长度由调用方 sizeof 给出） */
if ((s == NULL) || (len == 0u)) {
return;
}
if (len > 64u) {
len = 64u;
}
HAL_UART_Transmit(&huart1, (const uint8_t *)s, len, 0xFFFFu);
}
/* 字面量输出宏：长度由 sizeof 定，编译期即可确定 */
#define HF_PUTS(lit) hard_fault_write((lit), (uint16_t)(sizeof(lit) - 1u))
static void hard_fault_puthex(uint32_t v)
{
static const char digits[] = "0123456789ABCDEF";
@@ -138,37 +144,37 @@ static void hard_fault_puthex(uint32_t v)
out[i] = digits[(v >> (28 - i * 4)) & 0xFu];
}
out[8] = '\0';
hard_fault_puts(out);
hard_fault_write(out, 8u);
}
void hard_fault_report(uint32_t *frame)
{
hard_fault_puts("\r\n[ERR] HARDFAULT PC=");
HF_PUTS("\r\n[ERR] HARDFAULT PC=");
hard_fault_puthex(frame[6]);
hard_fault_puts(" LR=");
HF_PUTS(" LR=");
hard_fault_puthex(frame[5]);
hard_fault_puts(" xPSR=");
HF_PUTS(" xPSR=");
hard_fault_puthex(frame[7]);
hard_fault_puts(" R0=");
HF_PUTS(" R0=");
hard_fault_puthex(frame[0]);
hard_fault_puts(" R1=");
HF_PUTS(" R1=");
hard_fault_puthex(frame[1]);
hard_fault_puts(" R2=");
HF_PUTS(" R2=");
hard_fault_puthex(frame[2]);
hard_fault_puts(" R3=");
HF_PUTS(" R3=");
hard_fault_puthex(frame[3]);
hard_fault_puts(" CFSR=");
HF_PUTS(" CFSR=");
hard_fault_puthex(SCB->CFSR);
hard_fault_puts(" HFSR=");
HF_PUTS(" HFSR=");
hard_fault_puthex(SCB->HFSR);
/* BFAR/MMFAR 仅在对应 valid 位为 1 时有意义 */
if ((SCB->CFSR & (1UL << 15)) != 0U) {
hard_fault_puts(" BFAR=");
HF_PUTS(" BFAR=");
hard_fault_puthex(SCB->BFAR);
}
if ((SCB->CFSR & (1UL << 7)) != 0U) {
hard_fault_puts(" MMFAR=");
HF_PUTS(" MMFAR=");
hard_fault_puthex(SCB->MMFAR);
}
Src/usart.c
+214 -1
View File
@@ -475,11 +475,224 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USER CODE BEGIN 1 */
#include <stdio.h>
#include "FreeRTOS.h"
#include "task.h"
#include "cmsis_os.h"
#include "sys_events.h"
/* ===== 控制台单写者日志（2026-09-24 加固，HardFault 定位结论驱动）=====
* 背景：旧路径 DBG_* → printf → fputc **每字符一次** HAL_UART_Transmit。HAL 的锁只保证
* "单字节"原子，任务切换发生在字符之间 → 两行日志逐字符交错（2026-09-24 崩溃前
* 实测："[2026-[2026-0909-24 15:2-24 15:27:37:39]…"）；更严重的是字符串指针一旦
* 被破坏，脏指针会直接进入 UART 缓冲遍历（同日 HardFault：BFAR=0x10010000 恰为
* CCM 末尾+1，PC 落在 HAL_UART_Transmit 的缓冲读取处）。
* 架构：**defaultTask 是唯一串口发送者**；其余任务/上下文只把文本写入环形缓冲。
* ① 行级原子：整行在一次临界区内拷入环形缓冲，写者按块一次 HAL_UART_Transmit
* 发出 → 行与行不可能再交错（UART 只有这一个调用点）；
* ② 指针可控：进 UART 的缓冲恒为本文件的环形缓冲，调用方脏指针再也到不了 UART；
* ③ 写者未注册（内核启动早期/裸机）或中断上下文：回退直接阻塞发送（无并发或必须裸发）。
* 约束：不新增任务、不动态分配；环形缓冲为 BSS（SRAM1，非 CCM），无 DMA 可达性冲突。
*/
#define DBG_CON_LINE_MAX 192U /* 单行文本上限（含结尾 '\0'，超出截断） */
#define DBG_CON_RING_SIZE 4096U /* 环形缓冲字节数（必须为 2 的幂） */
#define DBG_CON_CHUNK_MAX 256U /* 写者单次 HAL_UART_Transmit 字节上限 */
#define DBG_CON_WAIT_MS 200U /* 缓冲满时生产者最长等待（ms），仍满则丢弃并计数 */
static uint8_t s_con_ring[DBG_CON_RING_SIZE];
static volatile uint16_t s_con_head; /* 生产者写入位置 */
static volatile uint16_t s_con_tail; /* 写者读取位置 */
static volatile uint32_t s_con_drop; /* 因缓冲满丢弃的行数 */
static volatile uint8_t s_con_writer_up; /* 1 = 写者已注册（此后走环形缓冲） */
static TaskHandle_t s_con_writer_task; /* 写者任务句柄（自等保护用） */
void dbg_console_write_raw(const char *buf, unsigned len);
void dbg_console_writer_attach(void);
void dbg_console_drain(void);
int dbg_console_write_line(const char *line, unsigned len);
uint32_t dbg_console_dropped(void);
static uint16_t con_used(void)
{
return (uint16_t)((uint16_t)(s_con_head - s_con_tail) & (DBG_CON_RING_SIZE - 1U));
}
/*
* 函数功能：控制台裸发送（异常/早期路径专用：有界、单次、不加锁）
* 入口参数：buf - 文本缓冲；len - 字节数（超上限截断）
* 限定条件：串口已初始化；仅用于写者未注册、中断/异常上下文、崩溃上报
*/
void dbg_console_write_raw(const char *buf, unsigned len)
{
if ((buf == NULL) || (len == 0U)) {
return;
}
if (len > DBG_CON_CHUNK_MAX) {
len = DBG_CON_CHUNK_MAX;
}
(void)HAL_UART_Transmit(&huart1, (uint8_t *)buf, (uint16_t)len, 0xFFFFu);
}
/*
* 函数功能：注册控制台写者（defaultTask 在进入主循环前调用一次）
* 函数说明：注册后生产者改走环形缓冲；未注册时直接阻塞发送（内核启动早期）
*/
void dbg_console_writer_attach(void)
{
s_con_writer_task = xTaskGetCurrentTaskHandle();
s_con_writer_up = 1U;
}
/*
* 函数功能：排空环形缓冲（仅写者任务调用）
* 函数说明：按块一次 HAL_UART_Transmit 发出；每块完成后再推进读指针（临界区保护）
*/
void dbg_console_drain(void)
{
uint16_t used;
if (s_con_writer_up == 0U) {
return;
}
while ((used = con_used()) != 0U) {
uint16_t tail = s_con_tail;
uint16_t contig = (uint16_t)(DBG_CON_RING_SIZE - tail); /* 到环尾的连续段 */
uint16_t n = (used < contig) ? used : contig;
if (n > DBG_CON_CHUNK_MAX) {
n = DBG_CON_CHUNK_MAX;
}
(void)HAL_UART_Transmit(&huart1, &s_con_ring[tail], n, 0xFFFFu);
taskENTER_CRITICAL();
s_con_tail = (uint16_t)((uint16_t)(s_con_tail + n) & (DBG_CON_RING_SIZE - 1U));
taskEXIT_CRITICAL();
}
/* 丢弃可观测性：缓冲满丢行必须显式可见（否则会掩盖开机自检/测试标记的丢失） */
if (s_con_drop != 0U) {
char note[64];
uint32_t d = s_con_drop;
int n;
s_con_drop = 0U;
n = snprintf(note, sizeof(note), "\r\n[ERR] CONSOLE dropped %lu lines\r\n",
(unsigned long)d);
if (n > 0) {
if (n > (int)sizeof(note) - 1) {
n = (int)sizeof(note) - 1;
}
dbg_console_write_raw(note, (unsigned)n);
}
}
}
/*
* 函数功能：把一段文本放入控制台（写者已注册）/直接发出（未注册或中断上下文）
* 返回值：0 - 已入缓冲或已直发；-1 - 缓冲满丢弃（计入 dbg_console_dropped）
* 函数说明：生产者不持锁等待过久：最多 DBG_CON_WAIT_MS，仍满则丢弃该行；
* 写者自身记录日志时先排空缓冲，避免自等。
*/
static int con_append(const char *buf, uint16_t len)
{
uint32_t waited = 0U;
if ((buf == NULL) || (len == 0U)) {
return -1;
}
if ((s_con_writer_up == 0U) || (__get_IPSR() != 0U)) {
dbg_console_write_raw(buf, len);
return 0;
}
if (len > (DBG_CON_RING_SIZE / 2U)) {
len = (uint16_t)(DBG_CON_RING_SIZE / 2U); /* 超长保护（正常路径不会触发） */
}
if (xTaskGetCurrentTaskHandle() == s_con_writer_task) {
dbg_console_drain(); /* 写者自己记录：先腾空，避免自等 */
}
for (;;) {
uint16_t used = con_used();
uint16_t free_space = (uint16_t)((DBG_CON_RING_SIZE - 1U) - used);
if (free_space >= len) {
break;
}
if (waited >= DBG_CON_WAIT_MS) {
s_con_drop++;
return -1;
}
vTaskDelay(1);
waited++;
}
taskENTER_CRITICAL();
{
uint16_t head = s_con_head;
uint16_t first = (uint16_t)(DBG_CON_RING_SIZE - head);
uint16_t i;
if (first > len) {
first = len;
}
for (i = 0U; i < first; i++) {
s_con_ring[head + i] = (uint8_t)buf[i];
}
for (i = first; i < len; i++) {
s_con_ring[(uint16_t)((uint16_t)(head + i) & (DBG_CON_RING_SIZE - 1U))] =
(uint8_t)buf[i];
}
s_con_head = (uint16_t)((uint16_t)(head + len) & (DBG_CON_RING_SIZE - 1U));
}
taskEXIT_CRITICAL();
if (sys_evtHandle != NULL) {
(void)osEventFlagsSet(sys_evtHandle, SYS_EVT_CONSOLE_TX); /* 唤醒写者 */
}
return 0;
}
/*
* 函数功能：把一行已格式化的文本交给单写者控制台（生产者入口，**非可变参数**）
* 入口参数：line - 整行文本（含结尾换行）；len - 字节数
* 返回值：写入字节数；-1 - 参数非法或被丢弃
* 函数说明：整行一次入环形缓冲 → 行级原子（不会与他行交错）；调用方缓冲随即可复用。
* 刻意不用自研可变参数函数（规范 S12 7.6）；格式化由 DBG_PRINT 宏内
* 库 snprintf 在调用点完成。
*/
int dbg_console_write_line(const char *line, unsigned len)
{
if ((line == NULL) || (len == 0U)) {
return -1;
}
if (len > DBG_CON_LINE_MAX) {
len = DBG_CON_LINE_MAX; /* 截断（丢尾，保开头的标记信息） */
}
if (con_append(line, (uint16_t)len) != 0) {
return -1;
}
return (int)len;
}
/*
* 函数功能：已丢弃的日志行数（诊断用）
*/
uint32_t dbg_console_dropped(void)
{
return s_con_drop;
}
/*
* 函数功能：MicroLIB printf 底层重定向（库内部/遗留 printf 调用）
* 函数说明：同样只把字节交给单写者路径；未注册写者时直发（与旧行为一致）
*/
int fputc(int ch, FILE *f)
{
uint8_t b = (uint8_t)ch;
(void)f;
HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
(void)con_append((const char *)&b, 1U);
return ch;
}
/* USER CODE END 1 */