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

feat(NET): SEND pending 二期落地 + 末块挂起越界缺陷修复（台架复测闭环）

Browse Source 
net_pending.c/h 增设第二张挂起表 s_net_send[]（与 recv 表完全独立，收发
互不阻塞）；net_send_locked 快速路径改为有界自旋，单次等待超出
NET_SEND_SPIN_MS(2ms) 即登记挂起 send，由 net_send_pending_tick 按主循环
节拍分块推进，netTask 最坏停滞由 1s 压到 2ms。net_listener_retry_tick 的
挂起保险扩展到 send 侧；net_close_locked / 网络重建 / 状态对账三路均先
取消再动作（取消必通知，调用方永不挂死）。

台架复测（A/B 对照 + 插桩定位）发现并修复末块挂起越界缺陷：内层"等本块
发完(SENBUF_FREE)"位于写块之后，写完末块时 sent 已 == len，若该次等待越过
2ms 预算便会调用 net_send_pending_register，而登记函数按 sent >= len 拒收
并回 -1，把一次实际已完整交付芯片的发送报成失败。修复为内层等待开头判
sent >= len 即跳出（末块已交付、SENBUF_FREE 等待是纯保守自旋），并置于
超时/自旋判定之前；该守卫同时保证后续登记必伴随 sent < len。

复验：ftp_regression 连续 19 次 11/11；ftp_integrity_test 20 轮 x 64KB
STOR/RETR SHA-256 20/20 一致（两轮），吞吐稳定约 80KB/s；设备日志零
write error；ST-LINK 回读 No difference found。

文档：Net层阻塞模型架构设计.md 补二期设计与新增 9.1 缺陷记录，netTask
栈实测峰值按本次台架 920B 订正为 1116/3840（FTP 传输期 1164）；网络自愈
架构设计.md 吸收原监听生命周期文档、新增编号术语导读表，并把 5.2
"实验锚点速查"的 E 编号含义与 E-02 审计编号歧义写在表头（用户反馈该表
E 编号无法读懂）。

门禁：Keil 0 错 0 警；cppcheck / 编码规范 / 乱码零告警；
check_mem_numbers PASS；check_doc_links --all --sections-strict 142 篇 PASS。
This commit is contained in:
Wanderingss
2026-10-14 12:05:21 +08:00
parent df13dec479
commit f849c79b7a
24 changed files with 1626 additions and 882 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Drivers/BSP/NET/README.md
+6 -3
View File
@@ -8,7 +8,7 @@
| 文件 | 作用 |
|---|---|
| `net_socket.c/h` | **BSD Socket API 实现**：`net_socket` / `net_connect` / `net_send` / `net_recv` / `net_close` / `net_listen` / `net_accept`，含挂起 recv（pending）与错误码 |
| `net_pending.c/h` | **挂起 recv 请求表**（阻塞 recv 挂起模型：登记 / 每轮完成检查 / 取消 / close 结算；真机专属，模拟器走 `net_socket_sim.c`） |
| `net_pending.c/h` | **挂起 recv / send 请求表**（阻塞挂起模型：登记 / 每轮完成检查（recv）/ 推进（send）/ 取消 / close 结算；真机专属，模拟器走 `net_socket_sim.c`） |
| `net_select.c/h` | `select`/`poll` 多路复用（基于芯片中断事件 + 周期轮询） |
| `net_types.h` | 网络层公共类型定义 |
| `net_config.h` | 网络层编译期配置（缓冲区大小、超时、对账周期等） |
@@ -16,10 +16,13 @@
## 核心机制
### 阻塞模型（挂起 recv / pending）
### 阻塞模型（挂起 recv / send / pending）
- 一期（RECV）已落地：`net_recv` 等支持带超时的阻塞（`pending` 挂起 + tick 唤醒）
- 二期（ACCEPT + SEND）待做 → `docs/任务规划/登记簿.md` N-4
- 二期（SEND）已落地：`net_send` 快路径有界自旋（`NET_SEND_SPIN_MS` = 2ms），超预算登记
挂起 send，由 `net_send_pending_tick` 按主循环节拍分块推进；netTask 最坏停滞由 1s 压到 2ms
- 二期（ACCEPT）待做 → `docs/任务规划/登记簿.md` N-4
- 架构细节：`docs/网络/Net层阻塞模型架构设计.md`
### 周期对账自愈（TRAP-NET-17 修复；自愈收敛阶段 3 合并 pump）
Drivers/BSP/NET/net_config.h
+15
View File
@@ -14,6 +14,9 @@
* 2026-10-13 自愈收敛阶段 1.5：删除 NET_RECV_TIMEOUT_MS（30s 默认预算）——
* recv 超时改为调用方策略（net_recv 无限阻塞 /
* net_recv_to 显式预算 / net_select 首选），API 不再强加默认值
* 2026-10-14 二期 SEND pending：新增 NET_SEND_SPIN_MS（发送快速路径有界自旋
* 预算，超预算转挂起登记）——netTask 发送最坏停滞由
* NET_SEND_TIMEOUT_MS（1s）压到本值，健康路径行为不变
*/
#ifndef NET_CONFIG_H
@@ -41,6 +44,18 @@ extern "C" {
#define NET_SEND_TIMEOUT_MS 1000 /* 发送超时 */
#endif
/*
* 发送快速路径有界自旋预算（毫秒，SEND pending 配套）
* 分块发送时"等发送缓冲腾出"的正常代价实测仅 219µs（中位，max 378µs，
* 见《链路延迟测试说明.md》§6.2 chunk_wait）——留约 5 倍余量用有界自旋吃掉，
* 使**健康路径逐位不变**（多块帧仍在一次分派内发完，不额外引入 tick 延迟）；
* 一旦单次等待超过本预算即登记挂起请求，把等待交回调用方上下文，
* netTask 的最坏停滞由 NET_SEND_TIMEOUT_MS（1s）压到本值。
*/
#ifndef NET_SEND_SPIN_MS
#define NET_SEND_SPIN_MS 2
#endif
/*
* TCP 重传配置（由 net_socket.c 的 net_init() 在 ch395f_init() 之前下发）
* P0-a（2026-09-22）：周期 500→200ms——单次丢包代价 500→200ms（治 D1 症状），
Drivers/BSP/NET/net_listener.c
+6 -11
View File
@@ -12,7 +12,7 @@
* 2026-10-13 王建锋 自愈收敛阶段 3：pump 并入 net_reconcile_tick（《网络自愈架构设计》§4.1）
*
* 职责与边界见 net_listener.h 头注释；设计依据见
* docs/子系统设计/网络Socket监听生命周期设计说明.md §10。
* docs/网络/网络自愈架构设计.md §11。
*
* 模块内分层：
* ① 策略常量与私有状态（s_relisten_*）
@@ -33,7 +33,7 @@
#include "net_socket.h" /* net_sock_t / net_get_sock / NET_MAX_SOCKETS / net_set_errno */
#include "net_listener.h"
#include "net_pending.h" /* net_pending_active（挂起 recv 保险查询） */
#include "net_pending.h" /* net_pending_active / net_send_pending_active（挂起保险查询） */
#include "ch395f.h"
#include "test_config.h" /* TEST_LATENCY_PROBE（链路时延探针编译开关） */
#include "net_latency_test.h" /* 延迟探针接口（relisten 恢复计时采样） */
@@ -400,8 +400,8 @@ int net_listener_try(int sockfd) {
* 返回值：无
* 限定条件：netTask 上下文（由 net_process_messages 每轮调用）
* 函数说明：1. 到点重试待办的重监听；成功即报告探针样本
* 2. 本 fd 有在途挂起 recv 时跳过（net_pending_active，挂起 recv 保险：
* 重开 Socket 会摧毁在途连接）
* 2. 本 fd 有在途挂起 recv / 挂起 send 时跳过（net_pending_active /
* net_send_pending_active，挂起保险：重开 Socket 会摧毁在途传输）
* 3. 超过 NET_RELISTEN_DEADLINE_MS 停止 D10 快速重试并留痕
* （监听不永久失效——reconciler 100ms 周期仍按"芯片不在听"认领重建）
*/
@@ -430,8 +430,8 @@ void net_listener_retry_tick(void) {
continue;
}
}
/* 本 fd 有在途挂起 recv：重开 Socket 会摧毁在途连接（挂起 recv 保险） */
if (net_pending_active(i) != 0U) {
/* 本 fd 有在途挂起 recv / 挂起 send：重开 Socket 会摧毁在途连接（挂起保险） */
if ((net_pending_active(i) != 0U) || (net_send_pending_active(i) != 0U)) {
continue;
}
/* 未到点（tick 差值按有符号比较，抗回绕） */
@@ -460,8 +460,3 @@ void net_listener_retry_tick(void) {
}
}
}
/* 自愈收敛阶段 3（《网络自愈架构设计》§4.1）：原"监听器 pump"（100ms 周期、去抖/冷却、
* 情形①②③）已并入 net_socket.c 的 net_reconcile_tick 单一 100ms tick
* （判据读驱动状态缓存）；本模块保留沉降/隔离、D10 重试、armed 查询与
* net_listener_try（重建动作本身，由 reconciler 形态③④ 调用）。 */
Drivers/BSP/NET/net_listener.h
+5 -4
View File
@@ -10,14 +10,14 @@
* 修改记录：
* 2026-10-12 王建锋 从 net_socket.c 抽出监听生命周期（N-32 §10 模块化）
*
* 职责边界（详见 docs/子系统设计/网络Socket监听生命周期设计说明.md §10）：
* 职责边界（详见 docs/网络/网络自愈架构设计.md §11）：
* 本模块只负责「让一个监听型 fd 保持/回到 LISTEN 态」。
*
* **不属于本模块**（留在 net_socket.c）：
* - `net_listen_locked`（首次监听的**应用 API 路径**，含 BOUND/CREATED 状态门与缓冲）
* - `net_accept_locked`（产出的是**连接**：LISTENING→ESTABLISHED 迁移）
* - `net_lost_connect_probe`（做的是**补 accept**，即连接建立）
* - `net_listener_armed` / `net_resync_listen`（双端公开 API，sim 也实现）
* - `net_listener_armed`（**双端公开 API**，sim 也实现；纯 RAM 查询）
*
* ⚠ 本头文件**只被 net_socket.c include**（内部头），不进公开 net_socket.h ——
* 故模拟器（simulator/sim/net_socket_sim.c）对本模块**零依赖**，CMakeLists 不编本文件。
@@ -90,7 +90,8 @@ void net_listener_retry_tick(void);
* net_reconcile_tick 单一 100ms tick（判据读驱动状态缓存，《网络自愈架构设计》§4.1）。
* 本模块的 net_listener_try 由 reconciler 形态③④ 与 D10 重试轮询调用。 */
/* 注：本模块消费的宿主能力 `net_pending_active()` 声明在 net_pending.h
* （它是 net_pending.c 的函数，须与配对头文件同处，见规范 S17 2.2）。 */
/* 注：本模块消费的宿主能力 `net_pending_active()` / `net_send_pending_active()`
* 声明在 net_pending.h（它们是 net_pending.c 的函数，须与配对头文件同处，
* 见规范 S17 2.2）。 */
#endif /* NET_LISTENER_H */
Drivers/BSP/NET/net_pending.c
+279 -8
View File
@@ -1,21 +1,24 @@
/*
* 模块名称：挂起 recv 请求表（阻塞 recv 挂起模型）—— 实现
* 模块名称：挂起请求表（阻塞 recv / send 挂起模型）—— 实现
* 文件说明：见 net_pending.h；架构与五路语义见
* docs/网络/Net层阻塞模型架构设计.md
* 依赖（全部单向，无反向 include）：
* net_types.h（net_sock_t / NET_ERR_* / NET_SOCK_STATE_*）/
* net_socket.h（NET_MAX_SOCKETS / net_set_errno / NET_ERR_RETURN_1 /
* net_pending_active 声明）/ net_pending.h（本模块接口）/
* net_listener.h（net_listener_try）/ ch395f.h（RX 读出）/ main.h（HAL_GetTick）
* net_listener.h（net_listener_try）/ ch395f.h（RX 读出 / TX 分块写）/ main.h（HAL_GetTick）
* 限定条件：本文件真机专属——模拟器走 sim/net_socket_sim.c，
* simulator/CMakeLists.txt 不编译本文件（同 net_listener.c 先例）
*
* 阻塞 recv 挂起模型（E-02 结构演进）：阻塞等待 = 挂起请求 + 主循环节拍完成
* "无数据 + 阻塞等待"不再自旋占用 netTask：登记 pending 后立即返回
* net_pending_tick（与 D10 重监听重试同节奏，net_process_messages 开头每轮调用）
* 按 ①数据 ②到点（仅显式预算） ③断连 顺序检查完成条件并通知调用方
* 关闭/网络重建/陈旧重同步走显式 settle/cancel 路径（取消必通知，调用方永不挂死）
* 公开 API 返回契约：>0 字节数 / 0 EOF / -1 错误（错误码经通知值回传）
* 阻塞 recv / send 挂起模型（E-02 结构演进）：阻塞等待 = 挂起请求 + 主循环节拍完成
* "无数据 / 发送缓冲未空 + 阻塞等待"不再自旋占用 netTask：登记 pending 后立即返回
* net_pending_tick / net_send_pending_tick（与 D10 重监听重试同节奏，
* net_process_messages 开头每轮调用）
* recv：按 ①数据 ②到点（仅显式预算） ③断连 顺序检查完成条件并通知调用方
* send：按 ①断连 ②推进写块 ③写完 ④无进展超时 顺序推进并通知调用方
* 关闭/网络重建/陈旧重同步走显式 cancel 路径（取消必通知，调用方永不挂死）
* 公开 API 返回契约：recv >0 字节数 / 0 EOF / -1 错误；send >=0 已发字节数（短写由
* 调用方按 ret != len 判定）/ -1 错误（错误码经通知值回传）
* 预算归调用方：timeout_ms=0 即无限等待（无默认预算）；挂起超时留痕探针为
* 编译期选项（NET_PENDING_TRIPWIRE，默认 0 = 编译剔除）
*/
@@ -414,3 +417,271 @@ void net_pending_settle_close(int sockfd, net_sock_t *p_sock) {
/* 结束（必通知） */
net_pending_complete(sockfd, val);
}
/* ================= 挂起 send 请求表（SEND pending，二期） ================= */
typedef struct {
uint8_t active; /* 1 = 本 fd 有挂起 send */
const void *buf; /* 调用方缓冲基址（仅指针，须保持有效至完成） */
int len; /* 本次发送总长度（含登记前已写部分） */
int sent; /* 已写入芯片的字节数（进度；登记时可 > 0） */
uint32_t deadline; /* 无进展超时时刻 = 上次成功写块时刻 + NET_SEND_TIMEOUT_MS */
uint32_t registered; /* 登记时刻（tick；日志基准） */
TaskHandle_t caller; /* 调用方任务（完成通知目标） */
} net_send_pending_t;
/* 每 fd 一个挂起 send（与 recv 表独立：收发两方向互不阻塞） */
static net_send_pending_t s_net_send[NET_MAX_SOCKETS];
/*
* 函数功能：通知调用方并清除本 fd 的挂起 send（所有完成/取消路径的公共出口）
* 入口参数：sockfd - Socket 描述符 (0~7) int
* result - 结果原值（本模型恒为**已发字节数** >= 0） int
* 出口参数：无
* 返回值：无
* 限定条件：netTask 上下文；sockfd 合法且挂起在位（否则静默返回，防重复通知）
* 函数说明：send 结果恒 >= 0（短写语义），故不在此改写错误码——取消/超时的原因
* 由各调用路径在调用本函数**之前**经 net_set_errno 记录
*/
static void net_send_pending_complete(int sockfd, int result) {
/* 本 fd 挂起请求指针 */
net_send_pending_t *p;
/* 描述符越界：静默返回（防重复通知） */
if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) {
return;
}
/* 取挂起请求 */
p = &s_net_send[sockfd];
/* 无在位挂起（已结束/已取消）：静默返回 */
if (p->active == 0U) {
return;
}
/* 覆盖式写入通知值 = 已发字节数（32 位原值） */
xTaskNotify(p->caller, (uint32_t)result, eSetValueWithOverwrite);
/* 清除挂起状态 */
p->active = 0U;
}
/*
* 函数功能：登记一个挂起 send 请求（net_send_locked 的"等发送缓冲"超预算路径）
* 入口参数：见 net_pending.h
* 出口参数：无
* 返回值：NET_PENDING_REGISTERED - 登记成功；-1 - 拒绝（见头注释）
* 限定条件：netTask 上下文
* 函数说明：每 fd 至多一个挂起 send（禁止覆盖——覆盖丢失前调用方通知 = 永久挂死）；
* 执行任务自身发起（net_send_sock 阻塞用法）无他人可完成 → 拒绝（自等死锁）
*/
int net_send_pending_register(int sockfd, const void *buf, int len, int sent,
TaskHandle_t caller) {
/* 挂起请求指针 */
net_send_pending_t *p;
/* 登记时刻（tick） */
uint32_t now;
/* 描述符越界 → BADF */
if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) {
return NET_ERR_RETURN_1(NET_ERR_BADF);
}
/* 参数非法（缓冲无效 / 长度非正 / 进度越界）→ INVAL */
if ((buf == NULL) || (len <= 0) || (sent < 0) || (sent >= len)) {
return NET_ERR_RETURN_1(NET_ERR_INVAL);
}
/* 取挂起请求 */
p = &s_net_send[sockfd];
/* 同 fd 已有挂起 send：拒绝（覆盖将丢失前通知 = 该任务永久挂死） */
if (p->active != 0U) {
return NET_ERR_RETURN_1(NET_ERR_BUSY);
}
/* netTask 自身发起：无他人可完成（tick 跑在 netTask 内）→ 拒绝（自等死锁） */
if ((caller == NULL) || (caller == s_owner_task)) {
return NET_ERR_RETURN_1(NET_ERR_BUSY);
}
/* 当前 tick（停滞计时基准） */
now = HAL_GetTick();
/* 标记挂起在位 */
p->active = 1U;
/* 调用方发送缓冲基址（须保持有效至完成） */
p->buf = buf;
/* 本次发送总长度 */
p->len = len;
/* 进度起点（登记前已写入芯片的字节数） */
p->sent = sent;
/* 无进展超时起点（NET_SEND_TIMEOUT_MS = 0 表示不限，同快速路径口径） */
p->deadline = (NET_SEND_TIMEOUT_MS > 0) ? (now + (uint32_t)NET_SEND_TIMEOUT_MS) : 0U;
/* 登记时刻（日志基准） */
p->registered = now;
/* 完成通知目标 */
p->caller = caller;
/* 登记成功：分派跳过即时通知 */
return NET_PENDING_REGISTERED;
}
/*
* 函数功能：挂起 send 推进与完成检查（netTask 每轮 net_process_messages 调用一次，非阻塞）
* 入口参数：p_socks - Socket 控制块表首指针（net_socket.c 的 s_net_socks） net_sock_t *
* 出口参数：无
* 返回值：无
* 限定条件：netTask 上下文
* 函数说明：1. 逐 fd 按序：①断连 → 以已发字节数结束（剩余字节不可能送达）
* 2. ②推进：发送缓冲空闲则写下一块（每轮至多一块——写完即清 send_ready，
* 下一块须等 SENBUF_FREE 中断重新置位，由 net_poll 刷新）
* 3. ③全部写完 → 以总长度结束；④无进展超时 → 以已发字节数结束
* 4. 结果恒为已发字节数（短写由调用方按 `ret != len` 判定）
* 5. 停滞计时按**无进展**刷新：大文件传输总时长必然超过单块预算，
* 按总时长判会误杀（与 recv 侧"到点"语义的差异点）
*/
void net_send_pending_tick(net_sock_t *p_socks) {
/* Socket 循环索引 */
int i;
for (i = 0; i < NET_MAX_SOCKETS; i++) {
/* 本 fd 挂起请求 */
net_send_pending_t *p = &s_net_send[i];
/* 本 fd 控制块 */
net_sock_t *p_sock = &p_socks[i];
/* 无挂起请求：跳过 */
if (p->active == 0U) {
continue;
}
/* fd 已关闭（正常路径在 close 内先取消；此处兜底，防任何路径漏掉通知） */
if (p_sock->in_use == 0U) {
net_send_pending_complete(i, p->sent);
continue;
}
/* ① 断连：本会话已结束 → 剩余字节不可能送达，按已发字节数结束。
* 判据 `state != ESTABLISHED`（同快速路径）：state 离开 ESTABLISHED 后
* 即便再回到 ESTABLISHED，也是**新会话**（relisten + 新 CONNECT）——
* 旧会话的剩余字节绝不能投到新连接上。session_dead 一并覆盖
* （net_types.h：TIMEOUT/DISCONNECT 两条路径都同时置 CLOSED，此处为
* 与 recv 侧判据对齐的冗余保险） */
if ((p_sock->state != NET_SOCK_STATE_ESTABLISHED) || (p_sock->session_dead != 0U)) {
DBG_ERROR("sock%d send pending aborted (%d/%d): session down",
i, p->sent, p->len);
(void)net_set_errno(NET_ERR_CONNRESET);
net_send_pending_complete(i, p->sent);
continue;
}
/* ② 推进：发送缓冲空闲则写下一块 */
if ((p->sent < p->len) && (p_sock->send_ready != 0U)) {
/* 本次写块长度 = min(剩余, 硬件发送缓冲上限) */
int chunk = p->len - p->sent;
if (chunk > NET_SEND_CHUNK_MAX) {
chunk = NET_SEND_CHUNK_MAX;
}
/* 写入芯片发送 FIFO（与快速路径同一分块粒度，TRAP-NET-16） */
ch395f_write_send_buf((uint8_t)i, (uint8_t *)p->buf + p->sent, (uint16_t)chunk);
/* 标记发送缓冲占用中（等 SENBUF_FREE 中断重新置位） */
p_sock->send_ready = 0U;
/* 累计进度与统计 */
p->sent += chunk;
p_sock->send_bytes += (uint32_t)chunk;
/* 进度刷新：停滞判定按"无进展"而非"总时长" */
p->deadline = (NET_SEND_TIMEOUT_MS > 0)
? (HAL_GetTick() + (uint32_t)NET_SEND_TIMEOUT_MS) : 0U;
}
/* ③ 全部写完：以总长度结束（调用方见 ret == len 即成功） */
if (p->sent >= p->len) {
net_send_pending_complete(i, p->sent);
continue;
}
/* ④ 无进展超时：以已发字节数结束（短写；调用方须检查返回值） */
if ((NET_SEND_TIMEOUT_MS > 0) &&
((int32_t)(HAL_GetTick() - p->deadline) >= 0)) {
DBG_ERROR("sock%d send pending stall (%d/%d)", i, p->sent, p->len);
(void)net_set_errno(NET_ERR_TIMEDOUT);
net_send_pending_complete(i, p->sent);
continue;
}
}
}
/*
* 函数功能：清除本 fd 的挂起 send（不通知；用于"新 fd 不得继承"与 close 后的幂等清理）
* 入口参数：sockfd - Socket 描述符 (0~7) int
* 出口参数：无
* 返回值：无
* 限定条件：无
* 函数说明：静默清理不发通知：close / 重建路径先经 cancel 通知，本调用仅保证状态归零（幂等）
*/
void net_send_pending_clear(int sockfd) {
/* 描述符越界：直接返回 */
if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) {
return;
}
/* 挂起状态清零（静默，不发通知） */
s_net_send[sockfd].active = 0U;
}
/*
* 函数功能：取消本 fd 的挂起 send 并通知调用方（close / drop_conn / resync / 重建）
* 入口参数：sockfd - Socket 描述符 (0~7) int
* err - 取消原因（记入 netTask 错误码槽位 + 日志） int
* 出口参数：无
* 返回值：无（无在位挂起时静默返回）
* 限定条件：netTask 上下文
* 函数说明：以**已发字节数**结束（已写入芯片的字节不回收——对端可能已收到；未发部分
* 放弃，由调用方按短写处理）。取消必通知，否则调用方永久挂死
*/
void net_send_pending_cancel(int sockfd, int err) {
/* 本 fd 挂起请求指针（只读：完成经 net_send_pending_complete 按 fd 操作） */
const net_send_pending_t *p;
/* 描述符越界：静默返回 */
if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) {
return;
}
/* 取挂起请求 */
p = &s_net_send[sockfd];
/* 无在位挂起：静默返回 */
if (p->active == 0U) {
return;
}
/* 留痕：取消原因 + 进度（短写程度） */
DBG_ERROR("sock%d send pending cancel (%d/%d, err=%d)", sockfd, p->sent, p->len, err);
/* 原因记入 netTask 自己的错误码槽位（结果 >= 0 不会被 complete 代记） */
(void)net_set_errno(err);
/* 结束：以已发字节数通知 */
net_send_pending_complete(sockfd, p->sent);
}
/*
* 函数功能：取消全部挂起 send 并逐一通知（网络重建路径）
* 入口参数：err - 取消原因 int
* 出口参数：无
* 返回值：无
* 限定条件：netTask 上下文；须在控制块清零与芯片复位之前调用
* 函数说明：网络重建（net_stack_bring_up → net_init）前调用，保证所有在位调用方均被唤醒
*/
void net_send_pending_cancel_all(int err) {
/* 逐 fd 遍历 */
for (int i = 0; i < NET_MAX_SOCKETS; i++) {
/* 取消并通知（未在位则静默跳过） */
net_send_pending_cancel(i, err);
}
}
/*
* 函数功能：查询本 fd 是否有在途挂起 send —— 宿主能力，供 net_listener 用
* 入口参数：sockfd - Socket 描述符 (0~7) int
* 出口参数：无
* 返回值：1 - 有挂起；0 - 无（含描述符越界） int
* 限定条件：任意上下文（纯 RAM 读，不发起 RPC）
* 函数说明：net_listener_retry_tick 用它跳过"重开 Socket 会摧毁在途传输"的 fd
* （挂起 send 保险；与 net_pending_active 的挂起 recv 保险并列）
*/
int net_send_pending_active(int sockfd) {
/* 描述符越界：视为无挂起 */
if ((sockfd < 0) || (sockfd >= NET_MAX_SOCKETS)) {
return 0;
}
return (s_net_send[sockfd].active != 0U) ? 1 : 0;
}
Drivers/BSP/NET/net_pending.h
+103 -7
View File
@@ -1,12 +1,14 @@
/*
* 模块名称：挂起 recv 请求表（阻塞 recv 挂起模型）
* 文件说明：阻塞 recv 的"挂起请求"数据结构与生命周期：登记 / 每轮完成检查 /
* 模块名称：挂起请求表（阻塞 recv / send 挂起模型）
* 文件说明：阻塞 recv / send 的"挂起请求"数据结构与生命周期：登记 / 每轮完成检查 /
* 取消（close、网络重建、对账 resync）/ 幂等清理。
* recv 侧 = 数据到达即完成；send 侧 = 分块推进至全部写完（进度刷新停滞计时）。
* 架构与五路语义见 docs/网络/Net层阻塞模型架构设计.md
* 依赖：net_types.h（net_sock_t）；消费方 = net_socket.c（消息分派 / close /
* 重建 / 对账）
* 限定条件：除 net_pending_active / net_pending_clear（纯 RAM 读）外，
* 全部函数须 netTask 上下文
* 依赖：net_types.h（net_sock_t）；ch395f.h（send 侧分块写 + 缓冲常量）；
* 消费方 = net_socket.c（消息分派 / close / 重建 / 对账）、
* net_listener.c（挂起保险查询）
* 限定条件：除 net_pending_active / net_send_pending_active / *_clear（纯 RAM 读）
* 外，全部函数须 netTask 上下文
*/
#ifndef NET_PENDING_H
#define NET_PENDING_H
@@ -15,6 +17,7 @@
#include "FreeRTOS.h"
#include "task.h"
#include "net_types.h"
#include "ch395f.h"
/* 内部哨兵：pending 已登记（消息分派据此跳过即时通知；取值不与字节数空间冲突） */
#define NET_PENDING_REGISTERED 0x70000000
@@ -22,12 +25,21 @@
/* 挂起超时留痕探针：排查"调用方挂死唤不醒"时置 1——挂起超 NET_RECV_TRIPWIRE_MS
* 只留一条 [ERR]（哪个 fd/多少毫秒/什么基准），绝不强制结束、绝不伪造返回值。
* 开与关语义完全一致，差别只在留痕；默认 0 = 产品构建零成本。
* 见 docs/网络/Net层阻塞模型架构设计.md §9 */
* 见 docs/网络/Net层阻塞模型架构设计.md §12 */
#define NET_PENDING_TRIPWIRE 0
#if NET_PENDING_TRIPWIRE
#define NET_RECV_TRIPWIRE_MS 60000U /* 挂起超时留痕阈值（ms） */
#endif
/* 单次写入 CH395F 发送 FIFO 的最大字节数：受硬件发送缓冲
* （CH395F_SEND_BUF_SIZE_BYTES = 1KB）与 SPI DMA 载荷
* （CH395F_SPI_DMA_MAX_PAYLOAD = 2KB）双重限制，以硬件发送缓冲为硬上限
* （TRAP-NET-16：单次写 2KB/4KB 会写穿 1KB 发送 FIFO）。
* ⚠ 唯一定义处：发送快速路径（net_send_locked）与挂起 send 推进
* （net_send_pending_tick）**必须**共用同一粒度，否则两条路径的分块行为漂移。 */
#define NET_SEND_CHUNK_MAX ((int)CH395F_SEND_BUF_SIZE_BYTES < (int)CH395F_SPI_DMA_MAX_PAYLOAD ? \
(int)CH395F_SEND_BUF_SIZE_BYTES : (int)CH395F_SPI_DMA_MAX_PAYLOAD)
/*
* 函数功能：捕获执行任务句柄（net_init 顶部调用一次；登记守卫据此拒绝自等待死锁）
* 入口参数：无
@@ -116,4 +128,88 @@ void net_pending_settle_close(int sockfd, net_sock_t *p_sock);
*/
int net_pending_active(int sockfd);
/* ================= 挂起 send 请求表（SEND pending，二期） =================
* 与 recv 表**完全独立**（各自一张表、各占一槽）：收发两个方向互不阻塞，
* 同一 fd 可同时有一个挂起 recv 与一个挂起 send（今天的分片实现本就支持该并发）。
* 语义差异：recv 是"等一次到达即完成"，send 是"分块推进直到全部写完"，
* 故 send 的停滞计时按**无进展**刷新（大文件传输总时长必然超过单块预算）。
*/
/*
* 函数功能：登记一个挂起 send 请求（net_send_locked 的"等发送缓冲"超预算路径）
* 入口参数：sockfd - Socket 描述符 (0~7) int
* buf - 调用方发送缓冲基址（须保持有效至完成；本函数不拷贝数据） const void *
* len - 本次发送**总**长度（含登记前已写入芯片的部分） int
* sent - 登记前已写入芯片的字节数（进度起点，0 ≤ sent < len） int
* caller - 调用方任务句柄（完成通知目标） TaskHandle_t
* 出口参数：无
* 返回值：NET_PENDING_REGISTERED - 登记成功（分派跳过即时通知）
* -1 - 拒绝（参数非法 / 同 fd 已有挂起 send / 执行任务自身发起）
* 限定条件：netTask 上下文
* 函数说明：每 fd 至多一个挂起 send（禁止覆盖——覆盖丢失前调用方通知 = 永久挂死）；
* 执行任务自身发起（net_send_sock 阻塞用法）无他人可完成 → 拒绝（自等死锁）。
* ⚠ **调用方铁律**：`sent < len` 是调用侧必须保证的**前置条件**，不是本函数的
* 兜底。`sent == len` 表示"全部字节已交付芯片、无剩余块可挂起"——此时超预算
* 应**直接返回 sent**，不得调用本函数；本函数会按参数非法拒绝并回 -1，
* 把一次完整发送报成失败（net_send_locked 末块等待 2026-10-14 台架实证，
* 见《Net层阻塞模型架构设计.md》 §9.1）。
*/
int net_send_pending_register(int sockfd, const void *buf, int len, int sent,
TaskHandle_t caller);
/*
* 函数功能：挂起 send 推进与完成检查（netTask 每轮 net_process_messages 调用一次，非阻塞）
* 入口参数：p_socks - Socket 控制块表首指针（net_socket.c 的 s_net_socks） net_sock_t *
* 出口参数：无
* 返回值：无
* 限定条件：netTask 上下文
* 函数说明：逐 fd 按序判定：①断连（state 非 ESTABLISHED / session_dead）→ 以已发
* 字节数结束；②推进——发送缓冲空闲则写下一块（每轮至多一块，写完即清
* send_ready，下一块等 SENBUF_FREE 由 net_poll 重新置位）；③全部写完 →
* 以总长度结束；④无进展超时 → 以已发字节数结束。结果均为**已发字节数**
* （短写由调用方按 `ret != len` 判定，与分片实现契约一致）。
*/
void net_send_pending_tick(net_sock_t *p_socks);
/*
* 函数功能：清除本 fd 的挂起 send（不通知；"新 fd 不得继承"与 close 后的幂等清理）
* 入口参数：sockfd - Socket 描述符 (0~7) int
* 出口参数：无
* 返回值：无
* 限定条件：无
*/
void net_send_pending_clear(int sockfd);
/*
* 函数功能：取消本 fd 的挂起 send 并通知调用方（close / drop_conn / 对账 resync / 重建）
* 入口参数：sockfd - Socket 描述符 (0~7) int
* err - 取消原因（记入 netTask 错误码槽位 + 日志） int
* 出口参数：无
* 返回值：无（无在位挂起时静默返回）
* 限定条件：netTask 上下文
* 函数说明：以**已发字节数**结束（已写入芯片的字节不回收——对端可能已收到；
* 未发部分放弃，由调用方按短写处理），原因记 errno 与 [ERR] 日志
*/
void net_send_pending_cancel(int sockfd, int err);
/*
* 函数功能：取消全部挂起 send 并逐一通知（网络重建路径）
* 入口参数：err - 取消原因 int
* 出口参数：无
* 返回值：无
* 限定条件：netTask 上下文；须在控制块清零与芯片复位之前调用
*/
void net_send_pending_cancel_all(int err);
/*
* 函数功能：查询本 fd 是否有在途挂起 send —— 宿主能力，供 net_listener 用
* 入口参数：sockfd - Socket 描述符 (0~7) int
* 出口参数：无
* 返回值：1 - 有挂起；0 - 无（含描述符越界） int
* 限定条件：任意上下文（纯 RAM 读，不发起 RPC）
* 函数说明：与 net_pending_active 同用途——net_listener_retry_tick 据此跳过
* "重开 Socket 会摧毁在途传输"的 fd（挂起 send 保险）
*/
int net_send_pending_active(int sockfd);
#endif /* NET_PENDING_H */
Drivers/BSP/NET/net_socket.c
+95 -37
View File
@@ -183,7 +183,8 @@ static void handle_send_event(net_sock_t *p_sock);
static void handle_timeout_event(net_sock_t *p_sock);
static void fire_event(net_sock_t *p_sock, net_event_t event);
static void parse_ip_string(const char *str, uint8_t *ip_arr);
static int net_send_locked(net_sock_t *p_sock, const void *buf, int len);
static int net_send_locked(net_sock_t *p_sock, const void *buf, int len,
TaskHandle_t caller);
static int net_recv_locked(net_sock_t *p_sock, void *buf, int len, int flags,
uint32_t timeout_ms, TaskHandle_t caller);
static int net_close_locked(net_sock_t *p_sock);
@@ -226,8 +227,10 @@ static bool s_mac_is_zero(const uint8_t *p_mac) {
ch395f_status_t ret;
/* 网络重建前取消全部挂起请求并通知调用方（调用方阻塞等回执，
* 取消不通知 = 永久挂死）；必须早于控制块清零与芯片复位 */
* 取消不通知 = 永久挂死）；必须早于控制块清零与芯片复位。
* recv / send 两张表各自独立，须分别取消 */
net_pending_cancel_all(NET_ERR_CONNRESET);
net_send_pending_cancel_all(NET_ERR_CONNRESET);
/* 清零 Socket 控制块 */
memset(s_net_socks, 0, sizeof(s_net_socks));
@@ -774,6 +777,8 @@ static void net_reconcile_tick(void) {
p_sock->lost_conn_seen = 0U;
/* 取消本 fd 在死连接上的挂起 recv（必通知，防调用方挂死） */
net_pending_cancel(i, NET_ERR_CONNRESET);
/* 挂起 send 同样取消（会话已被芯片收走，剩余字节不可能送达） */
net_send_pending_cancel(i, NET_ERR_CONNRESET);
} else if ((bad == 3) || (bad == 4)) {
/* 类型③④：监听失位/孤儿监听 → 重建（本层唯一重建入口；
* 非阻塞：失败由 D10 重试轮询接管） */
@@ -791,9 +796,9 @@ static void net_reconcile_tick(void) {
/*
* 函数功能：netTask 主循环核心 —— 自愈 tick 宿主 + 消息队列分派器。每轮
* 先跑三个非阻塞自愈 tick（D10 重监听 / 挂起 recv /
* TRAP-NET-17 状态对账），再非阻塞排空队列按 msg.type 分派到 _locked 实现。
* 函数功能：netTask 主循环核心 —— 自愈 tick 宿主 + 消息队列分派器。每轮先跑四个非阻塞
* 自愈 tick（D10 重监听 / 挂起 recv / 挂起 send / TRAP-NET-17 状态对账），
* 再非阻塞排空队列按 msg.type 分派到 _locked 实现。
* 入口参数：无
* 出口参数：无
* 返回值：无（void）；消息结果经 xTaskNotify 通知值回传（成功=字节数/描述符，
@@ -801,18 +806,15 @@ static void net_reconcile_tick(void) {
* 限定条件：必须在 netTask 上下文中调用（独占 CH395F 与 s_net_socks 访问权）；
* 由 net_task.c 在 net_stack_bring_up 之后每次 1ms 循环调用。
* 函数说明：1. 四个自愈 tick 均非阻塞（绝不 osDelay 忙等，netTask 永不冻结），先于消息分派执行
* 2. net_listener_retry_tick（D10）：断连后按 30ms（NET_RELISTEN_RETRY_MS）
* 节拍重试 open+listen，2s 总时限到期放弃留痕；本 fd 有在途挂起 recv 时跳过（挂起 recv 保险）
* 3. net_pending_tick：按节拍结束挂起 recv（数据/到点[仅显式预算]/断连）；
* 挂起超时留痕探针（编译期选项，默认关）：挂起超阈值只 DBG_ERROR 留痕一次，绝不强制结束/伪造返回值
* 4. net_reconcile_tick（TRAP-NET-17 + pump 合并，自愈收敛阶段 3）：每 100ms 对账
* ①②⑤ + ③④ 重建 + U11 重同步，判据读驱动状态缓存（net_poll 每轮
* 全量刷新，E2 背书）；去抖分级（②=1 轮/③④⑤=2 轮/①=4 轮，M3 让位窗）
* + 1s 冷却；重建失败进 D10 重试队列，reconciler 不重复催
* 5. net_msg_t 按值入队，netTask 侧副本调用方不可见 → 结果只能搭任务通知值回传
* 6. 32 位整体即结果，不做位域压缩
* 7. RECV 特例：无数据+阻塞 → 登记 pending 哨兵 NET_PENDING_REGISTERED（0x70000000），
* do_notify=0，回执推迟到 net_pending_tick 完成时
* 2. net_listener_retry_tick（D10）：断连后按 30ms 节拍重试 open+listen，
* 2s 时限到期放弃留痕；本 fd 有在途挂起 recv / send 时跳过（挂起保险）
* 3. net_pending_tick：按节拍结束挂起 recv（数据/到点[仅显式预算]/断连）
* 4. net_send_pending_tick：按节拍推进挂起 send（断连/推进/写完/无进展超时）
* 5. net_reconcile_tick（TRAP-NET-17 + pump 合并，自愈收敛阶段 3）：100ms 对账
* ①②⑤ + ③④ 重建 + U11 重同步，判据读驱动状态缓存；去抖分级 + 1s 冷却
* 6. net_msg_t 按值入队 → 结果只能搭任务通知值回传（32 位整体即结果，不做位域压缩）
* 7. RECV / SEND 特例：超预算登记 pending 哨兵 NET_PENDING_REGISTERED（0x70000000），
* do_notify=0，回执推迟到 net_pending_tick / net_send_pending_tick 完成时
*/
void net_process_messages(void) {
net_msg_t msg;
@@ -822,11 +824,13 @@ void net_process_messages(void) {
return;
}
/* 三个非阻塞自愈 tick 置于消息处理之前：断连后即使无应用消息，监听器也能自主恢复 */
/* 四个非阻塞自愈 tick 置于消息处理之前：断连后即使无应用消息，监听器也能自主恢复 */
/* D10 重监听重试（TRAP-NET-09）：沉降后重开芯片监听器 */
net_listener_retry_tick();
/* 挂起 recv 完成检查：数据到达 / 到点 / 断连时通知调用方 */
net_pending_tick(s_net_socks);
/* 挂起 send 推进与完成检查（SEND pending）：断连 / 推进写块 / 写完 / 无进展超时 */
net_send_pending_tick(s_net_socks);
/* TRAP-NET-17 状态对账 + 监听器 pump（自愈收敛阶段 3 合并单一 100ms tick）：
* 判据读驱动缓存（net_poll 每轮全量刷新），①②⑤ 失同步 + ③④ 重建 +
* U11 重同步全部在此（本层唯一周期重建入口，N-32 P2 单一所有者） */
@@ -852,8 +856,14 @@ void net_process_messages(void) {
msg.result = -1;
} else {
/* 真正写入芯片：1KB/块等 SENBUF_FREE 中断（§5.32/§5.23①），
* 单块停滞 1s 超时，中途断连立即 CONNRESET；短写留痕，调用方须检查返回值 */
msg.result = net_send_locked(p_sock, msg.buf, msg.len);
* 单块等待超出快速路径预算（NET_SEND_SPIN_MS）即登记挂起请求、
* netTask 零占用返回；中途断连立即 CONNRESET；短写留痕，
* 调用方须检查返回值 */
msg.result = net_send_locked(p_sock, msg.buf, msg.len, msg.caller);
if (msg.result == NET_PENDING_REGISTERED) {
/* 挂起已登记：不发即时回执，完成时才通知（防"登记成功"误报为结果） */
do_notify = 0;
}
}
break;
}
@@ -1074,6 +1084,8 @@ int net_socket(int domain, int type) {
net_listener_clear(sockfd);
/* 新 fd 不得继承上一次挂起的 recv 请求 */
net_pending_clear(sockfd);
/* 新 fd 不得继承上一次挂起的 send 请求 */
net_send_pending_clear(sockfd);
/* 返回描述符（控制块已就绪） */
return sockfd;
@@ -1918,30 +1930,38 @@ static int net_connect_locked(int sockfd, const struct net_sockaddr *addr, int a
}
/*
* SPI DMA 单次事务最大有效载荷（取 CH395F 驱动公开常量）
* 单次写入 CH395F 发送 FIFO 的最大字节数 NET_SEND_CHUNK_MAX 已移入
* Drivers/BSP/NET/net_pending.h —— 发送快速路径（本文件）与挂起 send 推进
* （net_pending.c 的 net_send_pending_tick）必须共用同一定义，否则两条路径的
* 分块粒度漂移（TRAP-NET-16：单次写超 1KB 发送 FIFO 会写穿）。
*/
#define NET_DMA_MAX_PAYLOAD ((int)CH395F_SPI_DMA_MAX_PAYLOAD)
/* 单次写入 CH395F 发送 FIFO 的最大字节数：受硬件发送缓冲(CH395F_SEND_BUF_SIZE_BYTES=1KB)
* 与 SPI DMA 载荷(NET_DMA_MAX_PAYLOAD=2KB) 双重限制，以硬件发送缓冲为硬上限（见 TRAP-NET-16），
* 否则单次写 2KB/4KB 会写穿 1KB 发送 FIFO。 */
#define NET_SEND_CHUNK_MAX ((int)CH395F_SEND_BUF_SIZE_BYTES < NET_DMA_MAX_PAYLOAD ? \
(int)CH395F_SEND_BUF_SIZE_BYTES : NET_DMA_MAX_PAYLOAD)
/*
* 函数功能：发送数据（内部锁定版本，必须在 netTask 上下文调用）
* 入口参数：p_sock - Socket 控制块指针 net_sock_t *
* buf - 待发送数据缓冲区指针 const void *
* len - 数据长度 int > 0
* caller - 调用方任务句柄（挂起 send 的完成通知目标） TaskHandle_t
* 出口参数：无
* 返回值：实际发送字节数（>= 0）；-1 表示参数无效或 Socket 未连接 int
* 返回值：实际发送字节数（>= 0）；-1 表示参数无效或 Socket 未连接；
* NET_PENDING_REGISTERED 表示已登记挂起 send（分派据此跳过即时通知） int
* 限定条件：p_sock 非空；Socket 处于 ESTABLISHED 状态；netTask 上下文
* 函数说明：1. 按 NET_SEND_CHUNK_MAX（硬件发送缓冲上限，见 TRAP-NET-16）分块写入 CH395F 发送 FIFO
* 2. 发送前等待 send_ready 置位，超时返回已发送字节数
* 3. 每写完一块等待 SENBUF_FREE 中断（send_ready 清零后重新置位，§5.32/§5.23①）
* 2. 等待发送缓冲腾出采用**有界自旋**：单次等待 ≤ NET_SEND_SPIN_MS
* （健康路径实测 219µs 中位，5 倍余量）→ 多块帧仍在一次分派内发完，
* 健康路径行为与分片时代逐位一致
* 3. 单次等待超出预算 → 登记挂起 send（进度 = 已发字节数）并立即返回，
* 由 net_send_pending_tick 按主循环节拍继续推进 ——
* netTask 最坏停滞由 1s 压到 NET_SEND_SPIN_MS。
* ⚠ 仅**写块前**的等待可挂起：末块写完后 sent == len，此时超预算必须
* 直接返回 sent 而非登记（登记函数按 sent >= len 拒收，会把完整发送
* 报成 -1；2026-10-14 台架实证，详见《Net层阻塞模型架构设计.md》 §9.1）
* 4. 发送中途断连（状态非 ESTABLISHED）→ 立即失败并返回已发字节
* （errno=CONNRESET，不再空等超时）
* 5. 未写完即返回（含挂起完成）均为**短写**：调用方须按 ret != len 判定
*/
static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
static int net_send_locked(net_sock_t *p_sock, const void *buf, int len,
TaskHandle_t caller) {
/* 累计实际发送字节数 */
int sent = 0;
/* 当前等待阶段起始时刻（tick） */
@@ -1979,13 +1999,22 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
(void)net_set_errno(NET_ERR_CONNRESET);
break;
}
/* 停滞超时：NET_SEND_TIMEOUT_MS 后 send_ready 仍未置位 */
/* 停滞超时：NET_SEND_TIMEOUT_MS 后 send_ready 仍未置位（仅快速路径可见；
* 挂起路径的停滞判定由 net_send_pending_tick 负责） */
if (NET_SEND_TIMEOUT_MS > 0 &&
(HAL_GetTick() - tick_start) >= NET_SEND_TIMEOUT_MS) {
DBG_ERROR("sock%d send stall: send_ready not set (%d/%d)", sockfd, sent, len);
(void)net_set_errno(NET_ERR_TIMEDOUT);
break;
}
/* 快速路径预算用尽（仍无进展）：登记挂起 send，把等待交回调用方上下文。
* 先于上面的 1s 停滞判定生效，故健康/轻微拥塞路径不会走到 1s 分支。
* 登记失败（同 fd 已有挂起 / netTask 自身调用）→ 返回 -1，调用方见负值。
* 不变量：此处位于 **写块之前**，且循环条件 `sent < len` 尚未被改写
* → `sent < len` 恒成立，登记必获受理（与末块等待的差异点）。 */
if ((HAL_GetTick() - tick_start) >= (uint32_t)NET_SEND_SPIN_MS) {
return net_send_pending_register(sockfd, buf, len, sent, caller);
}
/* 轮询一次（更新 send_ready/状态），下一轮再试 */
net_poll();
continue;
@@ -2017,11 +2046,29 @@ static int net_send_locked(net_sock_t *p_sock, const void *buf, int len) {
}
/* 轮询：处理 SEND_OK/SENBUF_FREE 中断 */
net_poll();
/* 等待超时：本块放弃（外层统一处理） */
/* 末块已全部交付（sent == len）：无剩余块可写，SENBUF_FREE 等待是
* **纯粹的保守自旋**（原本是为"等缓冲腾出再写下一块"服务）——直接跳出，
* 把等待顺延为下一批的责任。同时也是下面挂起判定的前置守卫：
* net_send_pending_register 会按 `sent >= len` 拒收并回 -1，
* 把一次完整发送报成失败（2026-10-14 台架实证：RETR 1KB 单块帧
* `write error, ret=-1`）。本检查置于**超时/自旋判定之前**，
* 保证末块路径不因预算/超时判定产生任何额外延迟。 */
if (sent >= len) {
break;
}
/* 等待超时：本块放弃（外层统一处理）。置于自旋判定之前，
* 保证 NET_SEND_SPIN_MS 被配置得比 NET_SEND_TIMEOUT_MS 大时仍以超时收口 */
if (NET_SEND_TIMEOUT_MS > 0 &&
(HAL_GetTick() - tick_start) >= NET_SEND_TIMEOUT_MS) {
break;
}
/* 快速路径预算用尽（仍无进展）：登记挂起 send（进度 = 已发字节数），
* 由 net_send_pending_tick 续传；健康路径（219µs 量级）不会到达此处。
* 此处位于**写块之后**，但上面的 `sent >= len` 守卫已保证伴随
* `sent < len`（仍有剩余块）才具到达资格，登记必获受理。 */
if ((HAL_GetTick() - tick_start) >= (uint32_t)NET_SEND_SPIN_MS) {
return net_send_pending_register(sockfd, buf, len, sent, caller);
}
}
#if defined(TEST_LATENCY_PROBE)
/* 探针已武装：累计本段等待样本 */
@@ -2160,6 +2207,8 @@ static int net_close_locked(net_sock_t *p_sock) {
/* 先结束本 fd 的挂起 recv（排空/取消 + 必通知），再关芯片 Socket
* ——关闭不得让等待中的调用方永久悬挂 */
net_pending_settle_close((int)(p_sock - s_net_socks), p_sock);
/* 挂起 send 同样先结束（以已发字节数通知；未发部分放弃），再关芯片 Socket */
net_send_pending_cancel((int)(p_sock - s_net_socks), NET_ERR_CONNRESET);
/* 排渣 + 关闭 + 等 CLOSED 一体（见函数头注释 1）；
* 已 CLOSED 的 fd 只清本 Socket 残留事件（防下一连接误判"刚建立就断开"） */
@@ -2179,6 +2228,8 @@ static int net_close_locked(net_sock_t *p_sock) {
net_listener_clear(sockfd);
/* 关闭即清除该 fd 的挂起状态（幂等） */
net_pending_clear(sockfd);
/* 挂起 send 同样幂等清理（cancel 已在上方通知，此处仅保证状态归零） */
net_send_pending_clear(sockfd);
/* 关闭成功 */
return 0;
@@ -2208,6 +2259,8 @@ static int net_drop_conn_locked(net_sock_t *p_sock) {
/* 先结束本 fd 挂起 recv（排空/取消 + 必通知），再拆芯片会话 */
net_pending_settle_close((int)(p_sock - s_net_socks), p_sock);
/* 挂起 send 同样先结束（以已发字节数通知；未发部分放弃），再拆芯片会话 */
net_send_pending_cancel((int)(p_sock - s_net_socks), NET_ERR_CONNRESET);
/* 确定性拆除（异常释放 → QUARANTINE 400ms 底，TRAP-NET-18 语义） */
if (net_sock_reset_sync(sockfd, CH395F_RESET_QUARANTINE) != 0) {
@@ -2837,17 +2890,22 @@ int net_recvfrom(int sockfd, void *buf, int len, int flags,
* buf - 待发送数据缓冲区指针 const void *
* len - 数据长度 int > 0
* 出口参数：无
* 返回值：实际发送字节数（>= 0）；-1 表示参数无效 int
* 返回值：实际发送字节数（>= 0）；-1 表示参数无效 / 需等待但被拒（BUSY） int
* 限定条件：p_sock 非空；netTask 上下文（避免向自身发送消息造成死锁）
* 函数说明：直接调用 net_send_locked 完成发送
* 函数说明：1. 直接调用 net_send_locked 完成发送
* 2. SEND pending 化后：发送缓冲未及时腾出（超 NET_SEND_SPIN_MS）时，
* 挂起登记会被"拒绝执行者自等待"守卫拒绝（netTask 内无人能完成它）
* → 返回 -1（BUSY）。本接口因此只适合"发送缓冲可用"的场合；
* netTask 内需要长时间等待的发送，须自行分片或改用挂起模型
*/
int net_send_sock(net_sock_t *p_sock, const void *buf, int len) {
/* 控制块指针为空 → BADF */
if (p_sock == NULL) {
return NET_ERR_RETURN_1(NET_ERR_BADF);
}
/* 直接委托锁定实现（netTask 上下文，无队列往返） */
return net_send_locked(p_sock, buf, len);
/* 直接委托锁定实现（netTask 上下文，无队列往返）；
* caller = netTask 自身 → 挂起登记必被拒（自等死锁守卫） */
return net_send_locked(p_sock, buf, len, xTaskGetCurrentTaskHandle());
}
/*
* 函数功能：接收数据（内部版本，绕过消息队列，供 netTask 直接使用）
Drivers/BSP/NET/net_socket.h
+11 -2
View File
@@ -226,9 +226,18 @@ int net_connect(int sockfd, const struct net_sockaddr *addr, int addrlen);
* buf - 数据缓冲区
* len - 数据长度
* flags - 通常为 0
* 返回值：实际发送字节数，失败返回 -1
* 返回值：实际写入字节数——**= len 为全部写入；< len 为短写，调用方必须检查**；
* 失败返回 -1（errno 已置位）
* 限定条件：TCP 连接已建立，指针非空
* 函数说明：阻塞等待发送缓冲区空闲，拷贝数据后触发发送
* 函数说明：1. 快路径：短暂自旋等待发送缓冲区空闲（预算 NET_SEND_SPIN_MS，默认 2ms），
* 拷贝数据后触发发送——健康链路下（实测 219us 量级）行为与旧版逐字节一致
* 2. 慢路径：自旋超预算后把请求**挂起登记**给 netTask，由
* net_send_pending_tick 在发送缓冲区空闲时续传（分片 NET_SEND_CHUNK_MAX），
* 调用方在任务通知上睡眠——**不再占用 netTask 执行者**（消除 E-02 队头阻塞）
* 3. 短写语义：无论快路径超时还是挂起完成，只要存在未写完字节即按已发数返回，
* 不假装全部成功；调用方按短写重试剩余部分（见 BSD_Socket_API 使用指南 §3.5）
* 4. ⚠ 禁止在 IWDG required_mask 内任务做**无预算**的整块发送；挂起路径本身
* 受 NET_SEND_TIMEOUT_MS 无进展超时兜底，但仍建议调用方自带超时预算
*/
int net_send(int sockfd, const void *buf, int len, int flags);