前置条件

这个简单数据库可以以任意存储介质作为实际空间。

对于 flash，通常的最小擦除单位是扇区。

如果是片上 flash，至少需要规划预留一个扇区对齐的区域供 FlashDB 使用。

如果是外部 flash，除了扇区对齐的规划，需要实现并测试读、写、擦除的 API 作为准备工作。

如果是 eeprom，同样的，实现并测试读、写、擦除的 API 作为准备工作，此时会简单很多，不必考虑扇区对齐问题。擦除 API 是为了兼容 FlashDB 默认存储介质是 flash，采用符合 flash 的行为逻辑，实际上可以将擦除 API 做空操作。

FlashDB 会自行处理好扇区对齐问题，所以在实现 API 时不必添加扇区对齐的检查，以减小开销。

引入源码包

在 armink/FlashDB 可以下载到原始源码包。

但是他没有 CMakeLists，需要了解其源码划分，才能正确引入所需的源码。

其实际上必须引入的源码文件夹如下，其他的则可以在工程中删除。下面用更清晰的 ASCII 树展示，方便在 Markdown 中阅读和复制。

FlashDB/
├─ demos/
├─ docs/
├─ inc/            # 需要加入到 include path
├─ port/
│  └─ fal/
│     ├─ docs/
│     ├─ inc/      # 需要加入到 include path
│     ├─ samples/
│     └─ src/      # 需要加入到编译的 .c 文件
├─ samples/
├─ src/            # 需要加入到编译的 .c 文件
├─ tests/
└─ zephyr/

其中标识的 .c 文件需要加入编译，同时加入以下的 includePATH

FlashDB/inc
FlashDB/port/fal/inc

FlashDB/inc 中有 fdb_cfg_template.h，复制一份并重命名为 fdb_cfg.h 放在自己的工程中，比如原地，在 includePATH 范围内就好。

最小起步时其中的默认配置不必修改，只要考虑编写 FDB_PRINT 即可，例如我编写为使用 RTT 打印，或者留空。

#define FDB_PRINT(...) SEGGER_RTT_printf(0, __VA_ARGS__)

// #define FDB_PRINT(...) \
//     do                 \
//     {                  \
//     }                  \
//     while(0)

新建一份 fal_cfg.h 放在自己的工程中，例如

#ifndef _FAL_CFG_H_
#define _FAL_CFG_H_

#define FAL_PART_HAS_TABLE_CFG

#define FAL_FLASHDB_DEV_NAME       "norflash0"
#define FAL_FLASHDB_KV_PART_NAME   "fdb_kv_cfg"
#define FAL_FLASHDB_KV_PART_OFFSET (0x00040000u)
#define FAL_FLASHDB_KV_PART_LENGTH (0x00040000u)

extern struct fal_flash_dev nor_flash0;

#define FAL_FLASH_DEV_TABLE \
    {                       \
        &nor_flash0,        \
    }

#ifdef FAL_PART_HAS_TABLE_CFG
#define FAL_PART_TABLE                                                                                                                    \
    {                                                                                                                                     \
        {FAL_PART_MAGIC_WORD, FAL_FLASHDB_KV_PART_NAME, FAL_FLASHDB_DEV_NAME, FAL_FLASHDB_KV_PART_OFFSET, FAL_FLASHDB_KV_PART_LENGTH, 0}, \
    }
#endif

#endif /* _FAL_CFG_H_ */

为工程引入 fal

注意到上面的 fal_cfg.h 其中有这样的内容，其中 FAL_FLASH_DEV_TABLE 是一个必须定义的 falsh 设备表，这里有一个 nor_flash0 设备描述对象。

这些描述对象与期望操作的 flash 抽象一一对应，比如我这里只有一个 spi-norflash，所以只使用了一个抽象对象。

extern struct fal_flash_dev nor_flash0;

#define FAL_FLASH_DEV_TABLE \
    {                       \
        &nor_flash0,        \
    }

在现在，虽然使用了声明，但是这个 flash 抽象依然还没有定义，定义这个抽象内容是使其真正具备真实 flash 操作能力的关键。

这里我们可以新建一个源码进行整体绑定，使其具有 读/写/擦 接口。比如如下的核心定义，其中

• .len 是完整 flash 空间大小，
• .blk_size 是擦除最小单位在 flash 中通常是扇区大小。
• .ops 是 读/写/擦 回调，在回调中使用前置条件中已实现的 API。
• .write_gran 是写最小字节数粒度，例如 norflash 此值定义为 1，而片上 flash 可能要求 4/8 字节对齐。

struct fal_flash_dev nor_flash0 = {
    .name       = FAL_FLASHDB_DEV_NAME,
    .addr       = 0,
    .len        = 1 * 1024 * 1024,
    .blk_size   = DEVICE_SECTOR_SIZE,
    .ops        = {fal_norflash_init,
                     fal_norflash_read, 
                     fal_norflash_write, 
                     fal_norflash_erase},
    .write_gran = FDB_WRITE_GRAN,
};

下面会展示为了支持这个抽象内容的完整源码，在这里有一个重要的问题需要处理。因为 fal 似乎并没有按页逐步写的操作，所以在 norflash 的回调处理中，需要注意不要跨页写，分为多次写使能和写请求。

#include <NorFlashSpi.h>
/* Port */
extern uint32_t FlashSpiTransmitPort(_NOR_FLASH_MESSAGE *pd, const uint8_t *TBuf, uint32_t ui32Len);
extern uint32_t FlashSpiReceivePort(_NOR_FLASH_MESSAGE *pd, uint8_t *RBuf, uint32_t ui32Len);
extern uint32_t FlashSpiTransmitReceivePort(_NOR_FLASH_MESSAGE *pd, const uint8_t *TBuf, uint8_t *RBuf, uint32_t ui32Len);
#include <fal.h>
#include <fdb_cfg.h>
#include <includes.h>

extern volatile uint8_t fSpiTxBuf[];
extern volatile uint8_t fSpiRxBuf[];
/* 片选使能函数 */
#define CS_EN( ) HAL_GPIO_WritePin(SPI5_FLASH_CS_GPIO_Port, SPI5_FLASH_CS_Pin, GPIO_PIN_RESET);
/* 片选失能函数 */
#define CS_UN( ) HAL_GPIO_WritePin(SPI5_FLASH_CS_GPIO_Port, SPI5_FLASH_CS_Pin, GPIO_PIN_SET);
/* 定义写入最小单位 */
#define FLASH_PAGE_SIZE   256

#define FALFDB_TRACE(...) SEGGER_RTT_printf(0, "[FALNOR] " __VA_ARGS__)

static int      fal_norflash_init(void);
static int      fal_norflash_read(long offset, uint8_t *buf, size_t size);
static int      fal_norflash_write(long offset, const uint8_t *buf, size_t size);
static int      fal_norflash_erase(long offset, size_t size);

static uint32_t fal_norflash_wait_idle(void)
{
    uint32_t i;

    fSpiTxBuf[0] = CMD_RDSR1;
    fSpiTxBuf[1] = 0;

    CS_EN( );
    if(FlashSpiTransmitReceivePort(NULL, (uint8_t *)fSpiTxBuf, (uint8_t *)fSpiRxBuf, 2) != RETURN_DEFAULT)
    {
        CS_UN( );
        return RETURN_FLASH_READ_ERR;
    }
    CS_UN( );

    i = 0;
    while(((fSpiRxBuf[1] & WIP_FLAG) != 0) && (i < 0xFFFF))
    {
        CS_EN( );
        if(FlashSpiTransmitReceivePort(NULL, (uint8_t *)fSpiTxBuf, (uint8_t *)fSpiRxBuf, 2) != RETURN_DEFAULT)
        {
            CS_UN( );
            return RETURN_FLASH_READ_ERR;
        }
        CS_UN( );
        i++;
    }

    if((fSpiRxBuf[1] & WIP_FLAG) != 0)
    {
        return RETURN_FLASH_BUSY;
    }

    return RETURN_DEFAULT;
}

struct fal_flash_dev nor_flash0 = {
    .name       = FAL_FLASHDB_DEV_NAME,
    .addr       = 0,
    .len        = 1 * 1024 * 1024,
    .blk_size   = DEVICE_SECTOR_SIZE,
    .ops        = {fal_norflash_init, fal_norflash_read, fal_norflash_write, fal_norflash_erase},
    .write_gran = FDB_WRITE_GRAN,
};

static int fal_norflash_init(void)
{
    /* 发送buffer转为 读ID指令 */
    fSpiTxBuf[0] = CMD_RDID;
    fSpiTxBuf[1] = 0;
    fSpiTxBuf[2] = 0;
    fSpiTxBuf[3] = 0;
    fSpiRxBuf[1] = 0;
    fSpiRxBuf[2] = 0;
    fSpiRxBuf[3] = 0;

    CS_EN( );
    if(FlashSpiTransmitReceivePort(NULL, (uint8_t *)fSpiTxBuf, (uint8_t *)fSpiRxBuf, 4) != RETURN_DEFAULT) // 收发
    {
        FALFDB_TRACE("[SPI-FLASH]init warn: read id transfer failed\r\n");
    }
    CS_UN( );

    uint32_t ChipID = ((uint32_t)fSpiRxBuf[1] << 16) | ((uint32_t)fSpiRxBuf[2] << 8) | fSpiRxBuf[3];
    switch(ChipID)
    {
    case W25Q80_ID:
        nor_flash0.len      = 1 * 1024 * 1024;
        nor_flash0.blk_size = 4 * 1024;
        break;
    case W25Q64_ID:
        nor_flash0.len      = 8 * 1024 * 1024;
        nor_flash0.blk_size = 4 * 1024;
        break;
    case W25Q128_ID:
        nor_flash0.len      = 16 * 1024 * 1024;
        nor_flash0.blk_size = 4 * 1024;
        break;
    case W25Q256_ID:
        nor_flash0.len      = 32 * 1024 * 1024;
        nor_flash0.blk_size = 4 * 1024;
        break;
    case W25Q512_ID:
        nor_flash0.len      = 64 * 1024 * 1024;
        nor_flash0.blk_size = 4 * 1024;
        break;
    default:
        nor_flash0.len      = 0;
        nor_flash0.blk_size = 0;
        FALFDB_TRACE("[SPI-FLASH]init failed: unsupported chip id=0x%08X\r\n", (unsigned)ChipID);
        return -1;
    }

    return 0;
}

static int fal_norflash_read(long offset, uint8_t *buf, size_t size)
{
    uint32_t addr;
    uint32_t chunk;
    size_t   remaining;
    size_t   copied;

    if(fal_norflash_wait_idle( ) != RETURN_DEFAULT)
    {
        FALFDB_TRACE("read failed: flash busy before read\r\n");
        return -1;
    }

    addr = (uint32_t)offset;

    /* 发送读指令和3字节地址 */
    fSpiTxBuf[0] = CMD_READ;
    fSpiTxBuf[1] = (addr >> 16) & 0xFF;
    fSpiTxBuf[2] = (addr >> 8) & 0xFF;
    fSpiTxBuf[3] = addr & 0xFF;

    CS_EN( );
    if(FlashSpiTransmitPort(NULL, (uint8_t *)fSpiTxBuf, 4) != RETURN_DEFAULT)
    {
        CS_UN( );
        FALFDB_TRACE("read failed: cmd tx error off=0x%08X size=%u\r\n", (unsigned)offset, (unsigned)size);
        return -1;
    }

    remaining = size;
    copied    = 0;
    while(remaining > 0)
    {
        chunk = (remaining > DEVICE_SECTOR_SIZE) ? DEVICE_SECTOR_SIZE : (uint32_t)remaining;
        if(FlashSpiTransmitReceivePort(NULL, (uint8_t *)fSpiTxBuf, (uint8_t *)fSpiRxBuf, chunk) != RETURN_DEFAULT)
        {
            CS_UN( );
            FALFDB_TRACE("read failed: data rx error off=0x%08X remain=%u\r\n", (unsigned)(addr + copied), (unsigned)remaining);
            return -1;
        }

        for(uint32_t i = 0; i < chunk; i++)
        {
            buf[copied + i] = fSpiRxBuf[i];
        }

        copied += chunk;
        remaining -= chunk;
    }

    CS_UN( );

    return (int)size;
}

static int fal_norflash_write(long offset, const uint8_t *buf, size_t size)
{
    uint32_t addr;
    size_t   remaining;
    size_t   copied;

    if(fal_norflash_wait_idle( ) != RETURN_DEFAULT)
    {
        FALFDB_TRACE("write failed: flash busy before write\r\n");
        return -1;
    }

    addr      = (uint32_t)offset;
    remaining = size;
    copied    = 0;

    while(remaining > 0)
    {
        uint32_t page_offset = addr % FLASH_PAGE_SIZE;
        uint32_t page_room   = FLASH_PAGE_SIZE - page_offset;
        uint32_t prog_len    = (remaining > page_room) ? page_room : (uint32_t)remaining;

        /* 写使能 */
        fSpiTxBuf[0] = CMD_WREN;
        CS_EN( );
        if(FlashSpiTransmitPort(NULL, (uint8_t *)fSpiTxBuf, 1) != RETURN_DEFAULT)
        {
            CS_UN( );
            FALFDB_TRACE("write failed: wren tx error off=0x%08X\r\n", (unsigned)addr);
            return -1;
        }
        CS_UN( );

        /* 页编程命令 + 3字节地址 + 数据 */
        fSpiTxBuf[0] = CMD_PP;
        fSpiTxBuf[1] = (addr >> 16) & 0xFF;
        fSpiTxBuf[2] = (addr >> 8) & 0xFF;
        fSpiTxBuf[3] = addr & 0xFF;
        for(uint32_t i = 0; i < prog_len; i++)
        {
            fSpiTxBuf[4 + i] = buf[copied + i];
        }

        CS_EN( );
        if(FlashSpiTransmitReceivePort(NULL, (uint8_t *)fSpiTxBuf, (uint8_t *)fSpiRxBuf, 4 + prog_len) != RETURN_DEFAULT)
        {
            CS_UN( );
            FALFDB_TRACE("write failed: pp tx error off=0x%08X size=%u\r\n", (unsigned)addr, (unsigned)prog_len);
            return -1;
        }
        CS_UN( );

        if(fal_norflash_wait_idle( ) != RETURN_DEFAULT)
        {
            FALFDB_TRACE("write failed: wait idle timeout off=0x%08X\r\n", (unsigned)addr);
            return -1;
        }

        addr += prog_len;
        copied += prog_len;
        remaining -= prog_len;
    }

    /* 关闭写使能 */
    fSpiTxBuf[0] = CMD_DISWR;
    CS_EN( );
    if(FlashSpiTransmitPort(NULL, (uint8_t *)fSpiTxBuf, 1) != RETURN_DEFAULT)
    {
        CS_UN( );
        FALFDB_TRACE("write warn: diswr tx error\r\n");
        return -1;
    }
    CS_UN( );

    if(fal_norflash_wait_idle( ) != RETURN_DEFAULT)
    {
        FALFDB_TRACE("write failed: flash busy after diswr\r\n");
        return -1;
    }

    return (int)size;
}

static int fal_norflash_erase(long offset, size_t size)
{
    uint32_t addr;
    uint32_t blk_size;
    size_t   remaining;

    blk_size = nor_flash0.blk_size;

    if(fal_norflash_wait_idle( ) != RETURN_DEFAULT)
    {
        FALFDB_TRACE("erase failed: flash busy before erase\r\n");
        return -1;
    }

    addr      = (uint32_t)offset;
    remaining = size;

    while(remaining > 0)
    {
        /* 写使能 */
        fSpiTxBuf[0] = CMD_WREN;
        CS_EN( );
        if(FlashSpiTransmitPort(NULL, (uint8_t *)fSpiTxBuf, 1) != RETURN_DEFAULT)
        {
            CS_UN( );
            FALFDB_TRACE("erase failed: wren tx error off=0x%08X\r\n", (unsigned)addr);
            return -1;
        }
        CS_UN( );

        /* 扇区擦除命令 + 3字节地址 */
        fSpiTxBuf[0] = CMD_SE;
        fSpiTxBuf[1] = (addr >> 16) & 0xFF;
        fSpiTxBuf[2] = (addr >> 8) & 0xFF;
        fSpiTxBuf[3] = addr & 0xFF;

        CS_EN( );
        if(FlashSpiTransmitPort(NULL, (uint8_t *)fSpiTxBuf, 4) != RETURN_DEFAULT)
        {
            CS_UN( );
            FALFDB_TRACE("erase failed: se tx error off=0x%08X\r\n", (unsigned)addr);
            return -1;
        }
        CS_UN( );

        if(fal_norflash_wait_idle( ) != RETURN_DEFAULT)
        {
            FALFDB_TRACE("erase failed: wait idle timeout off=0x%08X\r\n", (unsigned)addr);
            return -1;
        }

        addr += blk_size;
        remaining -= blk_size;
    }

    /* 关闭写使能 */
    fSpiTxBuf[0] = CMD_DISWR;
    CS_EN( );
    if(FlashSpiTransmitPort(NULL, (uint8_t *)fSpiTxBuf, 1) != RETURN_DEFAULT)
    {
        CS_UN( );
        FALFDB_TRACE("erase warn: diswr tx error\r\n");
        return -1;
    }
    CS_UN( );

    if(fal_norflash_wait_idle( ) != RETURN_DEFAULT)
    {
        FALFDB_TRACE("erase failed: flash busy after diswr\r\n");
        return -1;
    }

    return (int)size;
}

为工程引入 FlashDB

有了此前由下至上的引入和支持，现在可以正式处理 FlashDB 的操作流程了。

现在需要处理的主要就是按序初始化了，一个最小的可用初始化顺序为

struct fdb_kvdb g_flashdb_kvdb;

int32_t ModuleFlashDBInit(void)
{
    uint32_t  sec_size;

    memset(&g_flashdb_kvdb, 0, sizeof(g_flashdb_kvdb));

    sec_size = (4 * 1024); // 默认单扇区大小;
    fdb_kvdb_control(&g_flashdb_kvdb, FDB_KVDB_CTRL_SET_LOCK, (void *)module_flashdb_lock);
    fdb_kvdb_control(&g_flashdb_kvdb, FDB_KVDB_CTRL_SET_UNLOCK, (void *)module_flashdb_unlock);
    fdb_kvdb_control(&g_flashdb_kvdb, FDB_KVDB_CTRL_SET_SEC_SIZE, &sec_size);

    result = fdb_kvdb_init(&g_flashdb_kvdb, "cfg", FAL_FLASHDB_KV_PART_NAME, NULL, NULL);
    if(result != FDB_NO_ERR)
    {
        FLASHDB_TRACE("init failed: fdb_kvdb_init err=%d\r\n", (int)result);
        return -1;
    }

    return 0;
}

此后就可以使用这样的原子操作以读写键值

    struct fdb_blob blob;
    uint8_t verifyIp[4]   = {192,168,1,100};

    fdb_kv_set_blob(&g_flashdb_kvdb, "lan_ip", fdb_blob_make(&blob, verifyIp, sizeof(verifyIp)));
    fdb_kv_get_blob(&g_flashdb_kvdb, "lan_ip", fdb_blob_make(&blob, verifyIp, sizeof(verifyIp)));

需要自己做的包装

1. 依据你的工程框架，可以使用线程锁来额外包装一套 API，以简单支持跨线程的键值读写。
2. 进阶的，在包装中可以额外增加一个读 API 传参，在未命中键时使用默认值返回。类似 esp32 的 Preferences 数据库，int canBaud = prefs.getInt("canbtaud", 250000);。
3. 更加进阶的，由于 FlashDB 是一套阻塞操作、SPI 收发相当耗时，在线程中直接使用原子操作将导致毫秒级的阻塞，这是不太能接受的。可以采用独立线程和请求队列，专用于管理 FlashDB 的读写操作。在通常的场景，采用异步使得业务逻辑更通顺。而在必须立即读写并获值参与逻辑时，也可以直接调用原子操作。

C2000 DSP 是现代化蝎子粑粑独一份的 16 位字节，所以内存寻址时和通常的 CHAR_BIT == 8 不同。

这在协议层到数据零拷贝强转时需要格外注意。过去处理过，今天遇到又忘了，得重新手测。记录一下吧。

另外其对于取址对齐有很高的要求，32位数据要求地址也是 2 byte 对齐，例子如下。

uint16_t buffer[8];

uint32_t t32;

/* 以下两个实际上都会以 [0][1] 取内存转为 u32 */
// 在通常的CPU中，以下会以 [1][2] 取内存转 u32 
t32 = *(uint32_t *)(& buffer[1]); 
// 在通常的CPU中，以下是 [0][1] 正确零拷贝取法
t32 = *(uint32_t *)(& buffer[0]);

/* 以下两个则会以 [2][3] 取内存转为 u32 */
t32 = *(uint32_t *)(& buffer[3]);
t32 = *(uint32_t *)(& buffer[2]);

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://www.yono233.cn/posts/novel/macos-arm-gcc

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

brew -v

brew install cmake ninja

brew uninstall arm-none-eabi-gcc arm-none-eabi-binutils

brew install --cask gcc-arm-embedded

PKG="$(find "$(brew --caskroom)/gcc-arm-embedded" -name '*.pkg' | head -n 1)"
[ -n "$PKG" ] || { echo "未找到 gcc-arm-embedded 的 pkg"; exit 1; }
installer -pkg "$PKG" -target CurrentUserHomeDirectory

TOOLBIN="$(find "$HOME/Applications/ArmGNUToolchain" -type d -path '*/arm-none-eabi/bin' | sort | tail -n 1)"
[ -n "$TOOLBIN" ] || { echo "未找到 ArmGNUToolchain bin 目录"; exit 1; }
for t in gcc g++ as ar objcopy size gdb nm objdump ranlib readelf strip addr2line gcc-ar gcc-nm gcc-ranlib; do
    ln -sf "$TOOLBIN/arm-none-eabi-$t" "/opt/homebrew/bin/arm-none-eabi-$t"
done

arm-none-eabi-gcc -v -E -x c - < /dev/null

看完了？说点什么呢

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://www.yono233.cn/posts/luxury/macbook-neo

看完了？说点什么呢

部署 gitea 后一直没法自动发送通知邮件，作为未来的合作平台，今天打算解决这个问题。 官方文档或者各种中文教程并没有解释清楚，我的应用环境下是在论坛老外的帖子中摸索出的正确配置。

配置段为

[mailer]
ENABLED        = true
PROTOCOL       = smtps
SMTP_ADDR      = smtp.qq.com
SMTP_PORT      = 465
FROM           = yono233@foxmail.com
USER           = yono233@foxmail.com
PASSWD         = `你不应该知道这个`
ENABLE_HELO    = false

关键点有三个

• 使用 SMTP，PROTOCOL 不是 smtp 而应该是 smtps
• 对于 QQ 邮箱，SMTP_PORT 不能配置为 587，而应该使用 465
• 如果测试邮件报 EOF，需要添加 ENABLE_HELO 字段为 false -

NOTE

由于赶进度，暂时没有分析根因，只是在当前现象下的临时解决方案。

所以作为『手记』发布，后续可能转为『文章』描述根因。

移植 ST fork 的 netxduo ，未开启任何实际应用，只是基于 Example 开启了基本组件 IP/ICMP/TCP/UDP 。在这样的条件下，用 ping 做 PHY 驱动和物理链路设计的测试，并完善 netxduo 基础设施的移植。

现象

在 ping 的过程中，偶发 ping 不通一次，随后 ETH 外设进入 DMA 错误并死掉。

现象原因

经过 RTT 插入打印，发现发送时偶尔 append 会小于 prepend，导致计算包长为负数，展现到驱动发送时会是一个超越 DMA 空间的极大值，最终引起 DMA 错误并彻底丧失正确的 DMA 关系。

NETX TX ok
NETX ISR: TX complete
NETX ISR: RX complete
NETX RX hw->stack
NETX RX: type=IPv4(0x0800) len=74
NETX TX: cmd=IP_SEND type=IPv4 len=74
NETX TX ok
NETX ISR: TX complete
NETX ISR: RX complete
NETX RX hw->stack
NETX RX: type=IPv4(0x0800) len=74
NETX TX: cmd=IP_SEND type=IPv4 len=74
NETX TX invalid seg: append<=prepend pkt=0x2401B610 pre=0x2401B64E app=0x2401B64C len=74
NETX TX fail: hw_send status=90
NETX ISR: RX complete
NETX RX hw->stack
NETX RX: type=IPv4(0x0800) len=82
RTT:0>

简单解决方案

追溯到 nx_stm32_eth_driver.c 文件的 _nx_driver_hardware_packet_send 函数，向下追溯 ping 测试下的数据来源 HAL_ETH_RxAllocateCallback，其原版有这样的语句。 packet_ptr->nx_packet_prepend_ptr += 2; 而没有强制同步 nx_packet_append_ptr，所以可以增加 packet_ptr->nx_packet_append_ptr = packet_ptr->nx_packet_prepend_ptr;

注意到意外包 pre=0x2401B64E app=0x2401B64C 正好相差 2，也就是对于 0 长度包的接收实际上这里的处理存在问题。

void HAL_ETH_RxAllocateCallback(uint8_t **buff)
{
    NX_PACKET *packet_ptr;
    if(nx_packet_allocate(nx_driver_information.nx_driver_information_packet_pool_ptr, &packet_ptr, NX_RECEIVE_PACKET, NX_NO_WAIT) == NX_SUCCESS)
    {
      /*** 注意这里 ***/
        /* Adjust the packet.  */
        packet_ptr->nx_packet_prepend_ptr += 2;
      /*** ***/
        invalidate_cache_by_addr((uint32_t *)packet_ptr->nx_packet_data_start, packet_ptr->nx_packet_data_end - packet_ptr->nx_packet_data_start);
        *buff = packet_ptr->nx_packet_prepend_ptr;
    }
    else
    {
        ULONG total_packets;
        ULONG free_packets;
        ULONG empty_pool_requests;
        ULONG empty_pool_suspensions;
        ULONG invalid_packet_releases;

        nx_packet_pool_info_get(nx_driver_information.nx_driver_information_packet_pool_ptr, &total_packets, &free_packets, &empty_pool_requests, &empty_pool_suspensions, &invalid_packet_releases);

        /* Rx Buffer Pool is exhausted. */
        NX_NET_TRACE("NETX RX alloc fail: pool exhausted (free=%lu total=%lu empty_req=%lu)\r\n", (unsigned long)free_packets, (unsigned long)total_packets, (unsigned long)empty_pool_requests);
        *buff = NULL;
    }
}

除了上述 HAL_ETH_RxAllocateCallback 中的调整，为接收问题。

调整两种分支下的 _nx_driver_hardware_packet_send 函数，对包长为 0 或者意外极大的情况做特殊处理。不知为何，st 的原版驱动对于 0 长包的处理经常有问题，这是后续可能需要排查的，但是使用以下方案可以临时用着。

#ifdef MULTI_QUEUE_FEATURE
static UINT _nx_driver_hardware_packet_send(NX_PACKET *packet_ptr)
{
    UINT          status;
    UCHAR         channel_number = 0;

    NX_INTERFACE *interface_ptr;

    interface_ptr = nx_driver_information.nx_driver_information_interface;

    status        = nx_shaper_hw_queue_id_get(interface_ptr, packet_ptr, &channel_number);

    status        = _nx_driver_hardware_packet_send_distribute(packet_ptr, channel_number);

    return status;
}

static UINT _nx_driver_hardware_packet_send_distribute(NX_PACKET *packet_ptr, UINT channel_number)
{
    NX_PACKET               *pktIdx;
    UINT                     buffLen = 0;
    int                      i       = 0;

    static ETH_BufferTypeDef Txbuffer[ETH_TX_DESC_CNT];

    memset(Txbuffer, 0, ETH_TX_DESC_CNT * sizeof(ETH_BufferTypeDef));

    for(pktIdx = packet_ptr; pktIdx != NX_NULL; pktIdx = pktIdx->nx_packet_next)
    {
        ULONG seg_len;

        if(i >= ETH_TX_DESC_CNT)
        {
            return NX_DRIVER_ERROR;
        }

        if(pktIdx->nx_packet_append_ptr < pktIdx->nx_packet_prepend_ptr)
        {
            NX_NET_TRACE("NETX TX invalid seg: append<prepend pkt=0x%08lX pre=0x%08lX app=0x%08lX len=%lu\r\n", (unsigned long)pktIdx, (unsigned long)pktIdx->nx_packet_prepend_ptr, (unsigned long)pktIdx->nx_packet_append_ptr, (unsigned long)pktIdx->nx_packet_length);
            return NX_DRIVER_ERROR;
        }

        seg_len = (ULONG)(pktIdx->nx_packet_append_ptr - pktIdx->nx_packet_prepend_ptr);
        if(seg_len == 0U)
        {
            if((pktIdx->nx_packet_length > 0U) && (pktIdx->nx_packet_next == NX_NULL) && (pktIdx->nx_packet_prepend_ptr + pktIdx->nx_packet_length <= pktIdx->nx_packet_data_end))
            {
                pktIdx->nx_packet_append_ptr = pktIdx->nx_packet_prepend_ptr + pktIdx->nx_packet_length;
                seg_len                      = pktIdx->nx_packet_length;
                NX_NET_TRACE("NETX TX repair seg: pkt=0x%08lX repaired_len=%lu\r\n", (unsigned long)pktIdx, (unsigned long)seg_len);
            }
            else
            {
                NX_NET_TRACE("NETX TX skip empty seg: pkt=0x%08lX next=0x%08lX len=%lu\r\n", (unsigned long)pktIdx, (unsigned long)pktIdx->nx_packet_next, (unsigned long)pktIdx->nx_packet_length);
                continue;
            }
        }

        if(seg_len > 0x3FFFU)
        {
            NX_NET_TRACE("NETX TX invalid seg: oversize pkt=0x%08lX seg_len=%lu pre=0x%08lX app=0x%08lX\r\n", (unsigned long)pktIdx, (unsigned long)seg_len, (unsigned long)pktIdx->nx_packet_prepend_ptr, (unsigned long)pktIdx->nx_packet_append_ptr);
            return NX_DRIVER_ERROR;
        }

        Txbuffer[i].buffer = pktIdx->nx_packet_prepend_ptr;
        Txbuffer[i].len    = seg_len;
        buffLen += seg_len;

        if(i > 0)
        {
            Txbuffer[i - 1].next = &Txbuffer[i];
        }

        if(pktIdx->nx_packet_next == NULL)
        {
            Txbuffer[i].next = NULL;
        }

        i++;
        clean_cache_by_addr((uint32_t *)(pktIdx->nx_packet_data_start), pktIdx->nx_packet_data_end - pktIdx->nx_packet_data_start);
    }

#ifdef NX_ENABLE_INTERFACE_CAPABILITY
    if(packet_ptr->nx_packet_interface_capability_flag & (NX_INTERFACE_CAPABILITY_TCP_TX_CHECKSUM | NX_INTERFACE_CAPABILITY_UDP_TX_CHECKSUM | NX_INTERFACE_CAPABILITY_ICMPV4_TX_CHECKSUM | NX_INTERFACE_CAPABILITY_ICMPV6_TX_CHECKSUM))
    {
        TxPacketCfg.ChecksumCtrl = ETH_CHECKSUM_IPHDR_PAYLOAD_INSERT_PHDR_CALC;
    }
    else if(packet_ptr->nx_packet_interface_capability_flag & NX_INTERFACE_CAPABILITY_IPV4_TX_CHECKSUM)
    {
        TxPacketCfg.ChecksumCtrl = ETH_CHECKSUM_IPHDR_INSERT;
    }
#else
    TxPacketCfg.ChecksumCtrl = ETH_CHECKSUM_DISABLE;
#endif /* NX_ENABLE_INTERFACE_CAPABILITY */

#ifdef NX_DRIVER_ENABLE_PTP
    /* Enable PTP timestamp */
    if(packet_ptr->nx_packet_interface_capability_flag & NX_INTERFACE_CAPABILITY_PTP_TIMESTAMP)
    {
        HAL_ETH_PTP_InsertTxTimestamp(&eth_handle);
    }
#endif /* NX_DRIVER_ENABLE_PTP */

    if(buffLen == 0U)
    {
        NX_NET_TRACE("NETX TX invalid: no payload segments after filtering\r\n");
        return NX_DRIVER_ERROR;
    }

    TxPacketCfg.TxDMACh  = channel_number;
    TxPacketCfg.Length   = buffLen;
    TxPacketCfg.TxBuffer = Txbuffer;
    TxPacketCfg.pData    = (uint32_t *)packet_ptr;

    if(HAL_ETH_Transmit_IT(&eth_handle, &TxPacketCfg) != HAL_OK)
        return NX_DRIVER_ERROR;

    return NX_SUCCESS;
}

#else
static UINT _nx_driver_hardware_packet_send(NX_PACKET *packet_ptr)
{
    NX_PACKET               *pktIdx;
    UINT                     buffLen = 0;

    static ETH_BufferTypeDef Txbuffer[ETH_TX_DESC_CNT];
    memset(Txbuffer, 0, ETH_TX_DESC_CNT * sizeof(ETH_BufferTypeDef));

    int i = 0;

    for(pktIdx = packet_ptr; pktIdx != NX_NULL; pktIdx = pktIdx->nx_packet_next)
    {
        ULONG seg_len;

        if(i >= ETH_TX_DESC_CNT)
        {
            return NX_DRIVER_ERROR;
        }

        if(pktIdx->nx_packet_append_ptr < pktIdx->nx_packet_prepend_ptr)
        {
            NX_NET_TRACE("NETX TX invalid seg: append<prepend pkt=0x%08lX pre=0x%08lX app=0x%08lX len=%lu\r\n", (unsigned long)pktIdx, (unsigned long)pktIdx->nx_packet_prepend_ptr, (unsigned long)pktIdx->nx_packet_append_ptr, (unsigned long)pktIdx->nx_packet_length);
            return NX_DRIVER_ERROR;
        }

        seg_len = (ULONG)(pktIdx->nx_packet_append_ptr - pktIdx->nx_packet_prepend_ptr);
        if(seg_len == 0U)
        {
            if((pktIdx->nx_packet_length > 0U) && (pktIdx->nx_packet_next == NX_NULL) && (pktIdx->nx_packet_prepend_ptr + pktIdx->nx_packet_length <= pktIdx->nx_packet_data_end))
            {
                pktIdx->nx_packet_append_ptr = pktIdx->nx_packet_prepend_ptr + pktIdx->nx_packet_length;
                seg_len                      = pktIdx->nx_packet_length;
                NX_NET_TRACE("NETX TX repair seg: pkt=0x%08lX repaired_len=%lu\r\n", (unsigned long)pktIdx, (unsigned long)seg_len);
            }
            else
            {
                NX_NET_TRACE("NETX TX skip empty seg: pkt=0x%08lX next=0x%08lX len=%lu\r\n", (unsigned long)pktIdx, (unsigned long)pktIdx->nx_packet_next, (unsigned long)pktIdx->nx_packet_length);
                continue;
            }
        }

        if(seg_len > 0x3FFFU)
        {
            NX_NET_TRACE("NETX TX invalid seg: oversize pkt=0x%08lX seg_len=%lu pre=0x%08lX app=0x%08lX\r\n", (unsigned long)pktIdx, (unsigned long)seg_len, (unsigned long)pktIdx->nx_packet_prepend_ptr, (unsigned long)pktIdx->nx_packet_append_ptr);
            return NX_DRIVER_ERROR;
        }

        Txbuffer[i].buffer = pktIdx->nx_packet_prepend_ptr;
        Txbuffer[i].len    = seg_len;
        buffLen += seg_len;

        if(i > 0)
        {
            Txbuffer[i - 1].next = &Txbuffer[i];
        }

        if(pktIdx->nx_packet_next == NULL)
        {
            Txbuffer[i].next = NULL;
        }

        i++;
        clean_cache_by_addr((uint32_t *)(pktIdx->nx_packet_data_start), pktIdx->nx_packet_data_end - pktIdx->nx_packet_data_start);
    }

#ifdef NX_ENABLE_INTERFACE_CAPABILITY
    if(packet_ptr->nx_packet_interface_capability_flag & (NX_INTERFACE_CAPABILITY_TCP_TX_CHECKSUM | NX_INTERFACE_CAPABILITY_UDP_TX_CHECKSUM | NX_INTERFACE_CAPABILITY_ICMPV4_TX_CHECKSUM | NX_INTERFACE_CAPABILITY_ICMPV6_TX_CHECKSUM))
    {
        TxPacketCfg.ChecksumCtrl = ETH_CHECKSUM_IPHDR_PAYLOAD_INSERT_PHDR_CALC;
    }
    else if(packet_ptr->nx_packet_interface_capability_flag & NX_INTERFACE_CAPABILITY_IPV4_TX_CHECKSUM)
    {
        TxPacketCfg.ChecksumCtrl = ETH_CHECKSUM_IPHDR_INSERT;
    }
#else
    TxPacketCfg.ChecksumCtrl      = ETH_CHECKSUM_DISABLE;
#endif /* NX_ENABLE_INTERFACE_CAPABILITY */

    if(buffLen == 0U)
    {
        NX_NET_TRACE("NETX TX invalid: no payload segments after filtering\r\n");
        return NX_DRIVER_ERROR;
    }

    TxPacketCfg.Length   = buffLen;
    TxPacketCfg.TxBuffer = Txbuffer;
    TxPacketCfg.pData    = (uint32_t *)packet_ptr;

    if(HAL_ETH_Transmit_IT(&eth_handle, &TxPacketCfg))
    {
        return (NX_DRIVER_ERROR);
    }

    return (NX_SUCCESS);
}
#endif /* MULTI_QUEUE_FEATURE */

compare

Not support render this content in RSS render

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://www.yono233.cn/posts/novel/26_3_10_Pandoc

看完了？说点什么呢

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://www.yono233.cn/posts/novel/26_3_5_Carbon

 "headers": {
    "Authorization": "Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImxvZ2luLmlibS5jb20tMjAyNTA4MDgifQ.eyJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwiZmVkZXJhdGVkX3VzZXIiOiJyZWd1bGFyIiwiYWRkcmVzcyI6eyJjb3VudHJ5IjoiQ04ifSwicmVhbG1OYW1lIjoid3d3LmlibS5jb20iLCJkaXNwbGF5TmFtZSI6IuW-kCDlhYPpvpkiLCJ1bmlxdWVTZWN1cml0eU5hbWUiOiI2OTUwMDFIM1ZWIiwiYW1yIjpbInVybjppYm06c2VjdXJpdHk6YXV0aGVudGljYXRpb246YXNmOm1lY2hhbmlzbTpiYXNpY2xkYXB1c2VyIl0sInByZWZlcnJlZF91c2VybmFtZSI6Inlvbm8yMzNAb3V0bG9vay5jb20iLCJnaXZlbl9uYW1lIjoi5b6QIiwiaWFtX2F1dGhfcG9saWN5IjoidXJuOmlibTpzZWN1cml0eTphdXRoZW50aWNhdGlvbjphc2Y6YmFzaWNsZGFwdXNlciIsIm5hbWUiOiLlvpAg5YWD6b6ZIiwiZmFtaWx5X25hbWUiOiLlhYPpvpkiLCJlbWFpbCI6Inlvbm8yMzNAb3V0bG9vay5jb20iLCJhY3IiOiJ1cm46aWJtOnNlY3VyaXR5OnBvbGljeTppZDoyNDk2MyIsInJ0X2hhc2giOiJIdEVIeHlxcUtVcmh1d1pzVW5EWVhnIiwidXNlclR5cGUiOiJyZWd1bGFyIiwic19oYXNoIjoiUHYyY241cXk0X0padTNXTkJOS1RZdyIsImF1dGhfdGltZSI6MTc3NDM0MzQ5NiwianRpIjoiaThiM3VnMEZZQmU4MXkzMkV0VG81ZWFtVmx4MjFuIiwiYXRfaGFzaCI6IjVYZDlVTVUzbUE4ZjRuY0EzcWhxaWciLCJleHQiOnsidGVuYW50SWQiOiJsb2dpbi5pYm0uY29tIn0sImlzcyI6Imh0dHBzOi8vbG9naW4uaWJtLmNvbS9vaWRjL2VuZHBvaW50L2RlZmF1bHQiLCJhdWQiOiJOemcwWXpsaVl6QXRPVGhqWlMwMCIsInN1YiI6IjY5NTAwMUgzVlYiLCJpYXQiOjE3NzQzNDM1MDMsImV4cCI6MTc3NDM1MDcwM30.jkdNh6S1gImN7TNGa7cK5qsfWB0QzXK-1HpTN8CzMsA2kQmNtf8tFqt1tGGJpsoJUZcr7PdDsJYBM_Jd3SmbmJgS3LdXX8wMo5BpQpwtDak0zZ6p7MJb2WoE3nRE_gINI9nTAjWS5YA5618W6ZxyWGMUCxeAlzRTYgo4YIqI4RTNA4vWzzlVWcYiOsCc_eKBApg3M2wC2Qlh_CUSI_aC81tDWIgx15In8fcoKRo_31bp93QTLYzQ6ppFuShSzEwSoV69WtnDEdU1qCWepbJnSb1_HcGBOkk7Ca_y2iuFQU3KjBDU-QhHBBj2PMb2ADoDdQz3Lyv-K3p_mV9yl4DJaw",
    "X-MCP-Session": "80762ff3d736424b81cb626a1530a2d8"
  }

看完了？说点什么呢

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://www.yono233.cn/posts/novel/26_3_2_AI

在工程中创建 设计文档.md 以便于记录当前的设计。创建 AI/HANDOFF.md、AI/TODO.md、AI/SESSION_LOG.md 文件以便于后续使用“先读取 AI/HANDOFF.md、AI/TODO.md、AI/SESSION_LOG.md 恢复上下文”这样的提示词在更换环境时同步上下文。

在工程中创建 设计文档.md 以便于记录当前的设计。创建 AI/HANDOFF.md、AI/TODO.md、AI/SESSION_LOG.md 文件以便于后续使用“先读取 AI/HANDOFF.md、AI/TODO.md、AI/SESSION_LOG.md 恢复上下文”这样的提示词在更换环境时同步上下文。

注意：设计文档是一种软件功能和逻辑的描述，以便于使用不同的编程框架重构。需要完备描述软件设计的功能，包括已完成和未完成的所有功能，但无需备注是否完成。不要描述技术栈，不要关联当前项目。

现在请更新 设计文档.md以及AI文件夹中的内容,以和当前的项目现状对齐

看完了？说点什么呢

背景故事

虽然我有数个网站自用在跑，但是服务器这块与我工作无关，永远是小白。

近几个月，一直会遭遇挖矿程序入侵，但是那时候还有腾讯云的主机防护体验卡，只是会通知我然后手动点下修复就好。

过年回来发现，体验卡到期，天塌了。老破小服务器已经满载挖矿好几天。

年后正式启用私有部署的 git 托管管理项目代码，这个中毒问题得好好找下。其实是不想给🐕企鹅送钱。

总而言之，目前的状况是博客前端的端口直接暴露在公网上，next.js 有某种特点(没有深究)被入侵利用，然后污染了前端容器。暂时重新拉取镜像重部署，docker-compose.yml的image段同级增加read_only: true，避免入侵下载挖矿程序，以此临时解决。

本文主要记录一下指令长啥样，因为我记不住。

排查流程

立即止血

找出最吃 CPU 的进程

top -o %CPU

切到 root

whoami
id
sudo -n true; echo $?

杀他妈的 例如我这个挖矿进程的 PID 是 53075，就使用 sudo kill -STOP 53075

sudo kill -STOP <PID>

再看看进程

top -b -n 1 | head -n 15

谁拉的屎

找到真实的可执行文件，将获得一个路径，如果需要清理可以后续进行

sudo readlink -f /proc/<PID>/exe

查看启动命令行，其实是辅助排查，结果“空”表明不是用户手动命令行启动的

sudo sh -c 'tr “\0“ ” ” < /proc/<PID>/cmdline; echo’

查看进程启动时的环境变量，如果看到比较熟悉的词，在这里已经可以找到是什么应用被入侵了

sudo cat /proc/<PID>/environ | tr “\0“ “\n“ | head -n 60

NOTE

如果以上不足以找到根源应用，那么深入排查，以下指令结果无法明示，可以发给 GPT 让他辅助解析并进一步指导

查看进程控制组，比如我这里回复0::/system.slice/docker-9cffb5dca4c53cf437c1499d7df3725132406b42b3e4873837ec1487a7aa2b46.scope，那么已经明确是CONTAINER ID 为这串数字的容器被入侵了

sudo cat /proc/<PID>/cgroup

查看进程基本信息

sudo ps -o pid,ppid,user,cmd -p <PID>

查看父进程信息

sudo ps -o pid,ppid,user,cmd -p $(ps -o ppid= -p <PID>)

查看进程的网络连接情况

sudo ss -antup | grep -E "pid=<PID>," || true

详细列出进程打开的文件和网络连接

sudo lsof -nP -p <PID> -i 2>/dev/null | head -n 50

[!NOTE]

以上这些查询输出，如果看不懂排查不了，就直接丢给 GPT 让他指示下一步就好

我的处理

经过排查，在我的问题环境下，明确了是某个 docker 容器 9cffb5dca4c53cf437c1499d7df3725132406b42b3e4873837ec1487a7aa2b46 引起的，那我这里就直接查下这是个啥就行了。

sudo docker inspect 9cffb5dca4c53cf437c1499d7df3725132406b42b3e4873837ec1487a7aa2b46 --format 'ID={{.Id}}
Name={{.Name}}
Image={{.Config.Image}}
Created={{.Created}}
Entrypoint={{json .Config.Entrypoint}}
Cmd={{json .Config.Cmd}}
WorkingDir={{.Config.WorkingDir}}
EnvCount={{len .Config.Env}}
Mounts={{json .Mounts}}
Ports={{json .NetworkSettings.Ports}}'

回复表明

ID=9cffb5dca4c53cf437c1499d7df3725132406b42b3e4873837ec1487a7aa2b46
Name=/shiroi
Image=ghcr.io/stbanana/shiroi:latest
Created=2026-01-26T07:33:07.293181432Z
......

同时此前查找父进程表明

[lighthouse@VM-20-5-opencloudos ~]$ sudo ps -o pid,ppid,user,cmd -p $(ps -o ppid= -p 53075)
    PID    PPID USER     CMD
   2206    1954 root     next-server (v

另一个侧面验证是，前端镜像备份现在膨胀到了2GB，与我保存的稳定版备份400MB相去甚远。

那我这里可以确认是博客前端的 next.js 直接暴露的问题，但是我又不会修，也不想更新前端到最新版本(in神重构了，同步更新后端和迁移好麻烦)。

那就使用 read_only 部署就可以了，docker-compose.yml的image段同级增加read_only: true，下面是当前的。

version: '3'

services:
  shiro:
    container_name: shiroi
    image: shiroi:local
    volumes:
      - ./.env:/app/.env
    read_only: true
    restart: always
    ports:
      - 2323:2323

本地 docker 镜像压缩包的食用

注意到，上面我使用image: shiroi:local是一个本地镜像，而不用拉取，因为这个镜像来自于一个我保存下来的稳定版压缩包。

其实这个操作我做了好多次，但是每次都会忘得查指令，cd 到压缩包所在处->docker 加载镜像压缩包->打个人看得懂的标签。

类似以下。

[root@VM-20-5-opencloudos ~]# cd /root/mx-space/Shiroi
[root@VM-20-5-opencloudos Shiroi]# sudo docker load -i shiroi.tar
b0f89ac7b966: Loading layer  148.4MB/148.4MB
d3b1ea8ff6e6: Loading layer   5.39MB/5.39MB
2497eefc5264: Loading layer  3.584kB/3.584kB
769a089b3661: Loading layer  30.95MB/30.95MB
8a9366fbc004: Loading layer  1.536kB/1.536kB
556c774c2fcc: Loading layer  8.075MB/8.075MB
55405dd49280: Loading layer  4.096kB/4.096kB
66b48a972c24: Loading layer  24.75MB/24.75MB
7f1566c30993: Loading layer  24.29MB/24.29MB
911870b37b57: Loading layer  27.33MB/27.33MB
14c1060772f2: Loading layer  6.655MB/6.655MB
7be455708435: Loading layer  12.18MB/12.18MB
6fdc0a038ef1: Loading layer  5.213MB/5.213MB
ba8c6d828d78: Loading layer   2.56kB/2.56kB
5c557125ffd5: Loading layer  160.3kB/160.3kB
77abd848d7fc: Loading layer  110.1kB/110.1kB
e7f72ced6a18: Loading layer  111.2MB/111.2MB
0d71f84d6130: Loading layer  23.76MB/23.76MB
dade50077aed: Loading layer  22.65MB/22.65MB
Loaded image ID: sha256:8c476da1052b3d1e26bdaae875b0ac026b6c26869224732f2deee58a8349911a
[root@VM-20-5-opencloudos Shiroi]# sudo docker tag sha256:8c476da1052b3d1e26bdaae875b0ac026b6c26869224732f2deee58a8349911a shiroi:local
[root@VM-20-5-opencloudos Shiroi]#

使用不拉取的 compose 指令部署

docker compose up -d