大家好，我是痞子衡，是正經(jīng)搞技術(shù)的痞子。今天痞子衡給大家介紹的是利用i.MXRT1xxx系列內(nèi)部DCP引擎計算Hash值時需特別處理L1 D-Cache。

關于i.MXRT1xxx系列內(nèi)部通用數(shù)據(jù)協(xié)處理器DCP模塊，痞子衡之前寫過一篇文章 《SNVS Master Key僅在i.MXRT10xx Hab關閉時才能用于DCP加解密》 介紹了DCP基本功能和AES加解密使用注意事項，實際上DCP模塊除了對AES加解密算法支持外，還支持經(jīng)典的Hash算法（SHA-1/SHA-256/CRC32）。

痞子衡最近支持一個i.MXRT大客戶，他們項目里使用了DCP做Hash運算，但會出現(xiàn)概率性Hash校驗失敗的情況（差不多運行50次，會失敗1次），這是什么情況？

一、客戶項目基本情況

先介紹下客戶基本情況，他們項目使用的主芯片是i.MXRT1062，并且配置了外部串行Flash存儲程序代碼(XiP)，以及外部SDRAM放置程序數(shù)據(jù)區(qū)（其實主要是做frameBuffer的，但也同時放置了.data段和STACK），項目基于的SDK版本是v2.6.2。

項目中主要調(diào)用了 \SDK_2.6.2_EVK-MIMXRT1060\middleware\mbedtls\library\sha256.c 中的 mbedtls_sha256() 函數(shù)，這個函數(shù)其實是通過調(diào)用 \SDK_2.6.2_EVK-MIMXRT1060\middleware\mbedtls\port\ksdk\ksdk_mbedtls.c 里的一系列底層函數(shù)mbedtls_sha256_xx() 來進一步實現(xiàn)的。

ksdk_mbedtls.c 文件是同時適用Kinetis/LPC/i.MXRT等系列MCU的，不同MCU上硬件引擎不同（比如有LTC/CAAM/CAU3/DCP/HashCrypt）。對于i.MXRT1xxx，硬件引擎就是DCP，這些 mbedtls_sha256_xx() 函數(shù)主要調(diào)用了 SDK 標準驅(qū)動 fsl_dcp.c 里的如下函數(shù)：

status_t DCP_HASH_Init(DCP_Type *base, dcp_handle_t *handle, dcp_hash_ctx_t *ctx, dcp_hash_algo_t algo);
status_t DCP_HASH_Update(DCP_Type *base, dcp_hash_ctx_t *ctx, const uint8_t *input, size_t inputSize);
status_t DCP_HASH_Finish(DCP_Type *base, dcp_hash_ctx_t *ctx, uint8_t *output, size_t *outputSize);

二、概率性失敗情況分析

既然是概率性失敗的問題，那大概率和Cache處理有關了，我們需要檢查下 fsl_dcp.c 驅(qū)動是否很好地處理了Cache。讓我們打開 \SDK_2.6.2_EVK-MIMXRT1060\boards\evkmimxrt1060\driver_examples\dcp 例程先看一下，在 dcp.c 文件的 main() 函數(shù)里可以看到明顯的提醒。如果項目里用到了SDRAM，必須將DCache關掉，說明 dcp 驅(qū)動并不支持在DCache使能下運行。但顯然這個客戶項目用到了SDRAM，后來跟客戶確認，他們DCache一直是使能的，這顯然是有問題的。

int main(void)
{
    dcp_config_t dcpConfig;

    /* Init hardware*/
    BOARD_ConfigMPU();
    BOARD_InitPins();
    BOARD_BootClockRUN();
    BOARD_InitDebugConsole();

    /* Data cache must be temporarily disabled to be able to use sdram */
    SCB_DisableDCache();

    ...

讓我們再次回到SDK版本，在 恩智浦SDK下載主頁 可以看到所有i.MXRT1060 SDK歷史版本，v2.6.2是2019年7月發(fā)布的（這個版本里的dcp驅(qū)動版本是v2.1.1），是的，這個客戶算是i.MXRT早期客戶了。而現(xiàn)在最新的SDK版本已經(jīng)是v2.9.3（dcp驅(qū)動已經(jīng)升級到v2.1.6），時間快過去兩年了，客戶并沒有實時更新SDK版本。

早期的 dcp 驅(qū)動沒有處理DCache，所以其必須在 DCache 關掉的情況下才能正常工作。從v2.1.5開始增加了對 DCache 的處理，這樣 dcp 驅(qū)動就可以在 DCache 使能的情況下正常工作了。

三、DCP驅(qū)動里是如何處理DCache的？

現(xiàn)在讓我們在SDK標準驅(qū)動 fsl_dcp.c 中看一下它到底是怎么增加對DCache處理的。

3.1 DCP上下文buffer設置

使用 dcp 驅(qū)動的第一步是DCP模塊初始化，即DCP_Init()函數(shù)，這個函數(shù)會在DCP->CTRL寄存器里將模塊全部的四通道都使能以及將上下文(Context)的緩存和通道自切換功能也都開啟，其中關于上下文切換有一個重要的私有全局變量 s_dcpContextSwitchingBuffer，這個變量被放置到了NON-CACHE區(qū)域（驅(qū)動改進處一）。下述DCP->CONTEXT寄存器就是用來存儲 s_dcpContextSwitchingBuffer 地址的。

AT_NONCACHEABLE_SECTION_INIT(static dcp_context_t s_dcpContextSwitchingBuffer);

void DCP_Init(DCP_Type *base, const dcp_config_t *config)
{
    // 代碼省略...

    /* use context switching buffer */
    base->CONTEXT = (uint32_t)&s_dcpContextSwitchingBuffer;
}

3.2 DCP用戶數(shù)據(jù)in/out buffer設置

DCP 模塊初始化完成后，就是調(diào)用 dcp 驅(qū)動里的DCP_HASH()函數(shù)進行Hash運算，這個函數(shù)參數(shù)里有兩個用戶Buffer，一個Input Buffer存放待計算的消息數(shù)據(jù)，另一個Output Buffer存放計算好的Hash值（SHA256是32bytes），這兩個Buffer最好由用戶處理放置在NON-CACHE區(qū)。

/* Input data for DCP like input and output should be handled properly
 * when DCACHE is used (e.g. Clean&Invalidate, use non-cached memory)
 */
AT_NONCACHEABLE_SECTION(static uint8_t s_outputSha256[32]);

status_t calc_sha256(const uint8_t *messageBuf, uint32_t messageLen)
{
    size_t outLength = sizeof(s_outputSha256);
    dcp_handle_t m_handle;
    m_handle.channel    = kDCP_Channel0;
    m_handle.keySlot    = kDCP_KeySlot0;
    m_handle.swapConfig = kDCP_NoSwap;

    memset(&s_outputSha256, 0, outLength);

    return DCP_HASH(DCP, &m_handle, kDCP_Sha256, messageBuf, messageLen, s_outputSha256, &outLength);
}

3.3 DCP_HASH()相關代碼中DCache處理

DCP_HASH()函數(shù)運行過程中會一直用到一個非常關鍵的內(nèi)部結(jié)構(gòu)體 dcp_hash_ctx_internal_t，這個結(jié)構(gòu)體大小為47 Words（包含128byte的待計算消息數(shù)據(jù)塊blk、32bytes實時計算結(jié)果runningHash、及其他輔助變量成員）。

/*! internal dcp_hash context structure */
typedef struct _dcp_hash_ctx_internal
{
    dcp_hash_block_t blk;        /*!< memory buffer. only full blocks are written to DCP during hash updates */
    size_t blksz;                /*!< number of valid bytes in memory buffer */
    dcp_hash_algo_t algo;        /*!< selected algorithm from the set of supported algorithms */
    dcp_hash_algo_state_t state; /*!< finite machine state of the hash software process */
    uint32_t fullMessageSize;    /*!< track message size */
    uint32_t ctrl0;              /*!< HASH_INIT and HASH_TERM flags */
    uint32_t runningHash[9];     /*!< running hash. up to SHA-256 plus size, that is 36 bytes. */
    dcp_handle_t *handle;
} dcp_hash_ctx_internal_t;

dcp 驅(qū)動直接定義了 dcp_hash_ctx_t 型局部變量hashCtx，hashCtx空間后續(xù)會被用作dcp_hash_ctx_internal_t。舊版本里DCP_HASH_CTX_SIZE值為58，新版本增加到64，這是為了后續(xù)L1DCACHE的LINE對齊（驅(qū)動改進處二）。

/*! @brief DCP HASH Context size. */
#define DCP_HASH_CTX_SIZE 64

/*! @brief Storage type used to save hash context. */
typedef struct _dcp_hash_ctx_t
{
    uint32_t x[DCP_HASH_CTX_SIZE];
} dcp_hash_ctx_t;

status_t DCP_HASH(DCP_Type *base, dcp_handle_t *handle, dcp_hash_algo_t algo, const uint8_t *input, size_t inputSize, uint8_t *output, size_t *outputSize)
{
    dcp_hash_ctx_t hashCtx = {0};
    status_t status;

    status = DCP_HASH_Init(base, handle, &hashCtx, algo);
    status = DCP_HASH_Update(base, &hashCtx, input, inputSize);
    status = DCP_HASH_Finish(base, &hashCtx, output, outputSize);
    // ...
}

status_t DCP_HASH_Init/Update/Finish(...，dcp_hash_ctx_t *ctx，...)
{
    dcp_hash_ctx_internal_t *ctxInternal;
    /* Align structure on DCACHE line*/
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) && defined(DCP_USE_DCACHE) && (DCP_USE_DCACHE == 1U)
    ctxInternal = (dcp_hash_ctx_internal_t *)(uint32_t)((uint8_t *)ctx + FSL_FEATURE_L1DCACHE_LINESIZE_BYTE);
#else
    ctxInternal = (dcp_hash_ctx_internal_t *)(uint32_t)ctx;
#endif

    // 代碼省略...
}

DCP_HASH()函數(shù)中啟動DCP引擎去計算消息塊數(shù)據(jù)前，都會調(diào)用 DCACHE_InvalidateByRange() 函數(shù)對 ctxInternal 所占空間做清理（驅(qū)動改進處三）。啟動DCP引擎工作一次的函數(shù)是dcp_hash_update()，這個函數(shù)會利用 dcp_work_packet_t 型結(jié)構(gòu)體變量，對于這個結(jié)構(gòu)，代碼中也同樣做了L1DCACHE對齊處理（驅(qū)動改進處四）：

/*! @brief DCP's work packet. */
typedef struct _dcp_work_packet
{
    uint32_t nextCmdAddress;
    uint32_t control0;
    uint32_t control1;
    uint32_t sourceBufferAddress;
    uint32_t destinationBufferAddress;
    uint32_t bufferSize;
    uint32_t payloadPointer;
    uint32_t status;
} dcp_work_packet_t;

#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) && defined(DCP_USE_DCACHE) && (DCP_USE_DCACHE == 1U)
static inline uint32_t *DCP_FindCacheLine(uint8_t *dcpWorkExt)
{
    while (0U != ((uint32_t)dcpWorkExt & ((uint32_t)FSL_FEATURE_L1DCACHE_LINESIZE_BYTE - 1U)))
    {
        dcpWorkExt++;
    }
    return (uint32_t *)(uint32_t)dcpWorkExt;
}
#endif

static status_t dcp_hash_update(DCP_Type *base, dcp_hash_ctx_internal_t *ctxInternal, const uint8_t *msg, size_t size)
{
    status_t completionStatus = kStatus_Fail;

    /* Use extended  DCACHE line size aligned structure */
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U) && defined(DCP_USE_DCACHE) && (DCP_USE_DCACHE == 1U)
    dcp_work_packet_t *dcpWork;
    uint8_t dcpWorkExt[sizeof(dcp_work_packet_t) + FSL_FEATURE_L1DCACHE_LINESIZE_BYTE] = {0U};
    dcpWork = (dcp_work_packet_t *)(uint32_t)DCP_FindCacheLine(dcpWorkExt);
#else
    dcp_work_packet_t dcpWorkPacket = {0};
    dcp_work_packet_t *dcpWork      = &dcpWorkPacket;
#endif

    do
    {
        completionStatus = dcp_hash_update_non_blocking(base, ctxInternal, dcpWork, msg, size);
    } while (completionStatus == (int32_t)kStatus_DCP_Again);

    completionStatus = DCP_WaitForChannelComplete(base, ctxInternal->handle);

    ctxInternal->ctrl0 = 0;
    return (completionStatus);
}

至此，利用i.MXRT1xxx系列內(nèi)部DCP引擎計算Hash值時需特別處理L1 D-Cache痞子衡便介紹完畢了，掌聲在哪里~~~