RT-Thread操作系統在cortex-m3內核的移植原理

1、簡介

     本文主要介紹RT Thread操作系統在cortex-m3內核上的移植接口文件，通過本篇博客你將深入瞭解RTOS操作系統是怎麼通過觸發軟中斷實現任務切換的，怎麼實現內核異常信息的打印功能。

2、移植的接口文件

     RT-Thread操作系統的移植接口文件主要用cpuport.c，context_rvds.s，backtrace.c，div0.c，showmem.c。其中最重要的文件是cpuport.c和context_rvds.s這兩個文件，其他三個文件在cortex-M3內核移植時沒有實際的應用，這三個文件實際一些輔助的功能，打印內存，除數爲0，後臺跟蹤等操作，內容很簡單，可以自行查看。

3、任務切換context_rvds.s

       這是一個彙編語言的文件，這個文件實現了任務切換，觸發軟件中斷，硬件異常錯誤處理等操作，是操作系統移植時要實現的最重要的功能。程序的內部邏輯根cortex-m3內核的編程模型有關，想了解此程序邏輯，需要對cortex-m3內核的編程模塊有一定的瞭解。

       操作系統進行初始化芯片的時鐘，必要的外設後，開始進行第一個任務/線程調度時，會調用rt_hw_context_switch_to，函數的輸入參數是進行切換的任務（線程）的堆棧指針。這個函數的具體功能如下：

     請詳細查看我增加的中文註釋。

      請詳細查看我增加的中文註釋，有你不會的乾貨。

        請詳細查看我增加的中文註釋。

 

;/*
; * void rt_hw_context_switch_to(rt_uint32 to);
; * r0 --> to
; * this fucntion is used to perform the first thread switch
; */
rt_hw_context_switch_to    PROC
    EXPORT rt_hw_context_switch_to
    ; set to thread
    ; 把要切換到的線程的堆棧指針記錄到變量rt_interrupt_to_thread中來
    LDR     r1, =rt_interrupt_to_thread
    STR     r0, [r1]

    ; set from thread to 0
    ; 第一次進行線程切換，沒有上一次切換所以把rt_interrupt_from_thread設置爲0
    LDR     r1, =rt_interrupt_from_thread
    MOV     r0, #0x0
    STR     r0, [r1]

    ; set interrupt flag to 1
    ; 進行線程切換，把線程切換標誌變量rt_thread_switch_interrupt_flag設置爲1
    LDR     r1, =rt_thread_switch_interrupt_flag
    MOV     r0, #1
    STR     r0, [r1]

    ; set the PendSV exception priority
    ; 設置pendsv軟件中斷的優先級爲最低
    LDR     r0, =NVIC_SYSPRI2
    LDR     r1, =NVIC_PENDSV_PRI
    LDR.W   r2, [r0,#0x00]       ; read
    ORR     r1,r1,r2             ; modify
    STR     r1, [r0]             ; write-back

    ; trigger the PendSV exception (causes context switch)
    ；觸發pendsv軟件中斷，此時中斷關閉，並不會產生中斷
    LDR     r0, =NVIC_INT_CTRL
    LDR     r1, =NVIC_PENDSVSET
    STR     r1, [r0]

    ; restore MSP
    ;這段代碼實際是可以沒有的，移植時這樣做有了一個好處就是增加了MSP堆棧的使用空間
    ;cortex-m3內核復位時使用msp堆棧，從復位到進行初始化操作時會調用很多函數，會進行一些壓棧操作
    ;佔用一部分msp堆棧，由於程序不會退出到復位的位置，壓棧佔用的msp空間永遠不會釋放，產生了堆棧的
    ;的空間浪費一小部分。
    ; 下面的代碼實現的功能是讀取SCB_VTOR寄存器，這個寄存器保存了中斷向量表的起始位置，此位置的字
    ; 就是MSP堆棧的指針，即啓動代碼裏面分配出來的堆棧的棧頂。經過2次 LDR r0, [r0]就是相當於取到
    ；堆棧的棧頂,最後設置msp爲棧頂
    LDR     r0, =SCB_VTOR
    LDR     r0, [r0]
    LDR     r0, [r0]
    MSR     msp, r0

    ; enable interrupts at processor level
    ; 打開中斷
    CPSIE   F
    CPSIE   I

    ; never reach here!
    ENDP

      在已經進行了一次線程切換後，再次進行線程切換時會調用void rt_hw_context_switch(rt_uint32 from, rt_uint32 to)這個函數，這個函數與上面rt_hw_context_switch_to函數的功能相比大同小異。

    

;/*
; * void rt_hw_context_switch(rt_uint32 from, rt_uint32 to);
; * r0 --> from
; * r1 --> to
; */
rt_hw_context_switch_interrupt
    EXPORT rt_hw_context_switch_interrupt
rt_hw_context_switch    PROC
    EXPORT rt_hw_context_switch

    ; set rt_thread_switch_interrupt_flag to 1
    ; 判斷線程切換標誌rt_thread_switch_interrupt_flag是否爲1
    LDR     r2, =rt_thread_switch_interrupt_flag
    LDR     r3, [r2]
    CMP     r3, #1
    BEQ     _reswitch
    ;不爲1時，設置爲1,把from的線程的堆棧指針記錄到rt_interrupt_from_thread中
    MOV     r3, #1
    STR     r3, [r2]

    LDR     r2, =rt_interrupt_from_thread   ; set rt_interrupt_from_thread
    STR     r0, [r2]

_reswitch
    ;爲1時，把to的線程的堆棧指針記錄到rt_interrupt_to_thread中來
    LDR     r2, =rt_interrupt_to_thread     ; set rt_interrupt_to_thread
    STR     r1, [r2]

    ;觸發pendsv中斷
    LDR     r0, =NVIC_INT_CTRL              ; trigger the PendSV exception (causes context switch)
    LDR     r1, =NVIC_PENDSVSET
    STR     r1, [r0]
    BX      LR
    ENDP

      pendsv中斷是真正進行了線程切換操作的，前面介紹的2個函數主要在進行線程切換前，把要切換的線程的堆棧指針記錄到這個彙編的程序的變量中，在pendsv中斷中進行線程切換時使用，並且觸發中斷。下面介紹pendsv中斷內部實現線程切換的原理，一定要仔細看呀。

; r0 --> switch from thread stack
; r1 --> switch to thread stack
; psr, pc, lr, r12, r3, r2, r1, r0 are pushed into [from] stack
PendSV_Handler   PROC
    EXPORT PendSV_Handler
    ;根據cortext-m3內核的編程模型，進行pendsv中斷前，內核已經自動的psr, pc, lr, r12, r3, r2, r1, r0把這些寄存器壓入到發生切換的線程的堆棧psp中的去了，跳到中斷程序，使用的堆棧自動切換成msp

    ; disable interrupt to protect context switch
    ; 記錄primask中斷開關寄存器的值到r2寄存器中，用於退出中斷後再打開中斷用
    MRS     r2, PRIMASK
    ;關閉中斷
    CPSID   I

    ; get rt_thread_switch_interrupt_flag
    ; 判斷rt_thread_switch_interrupt_flag標誌爲1時，才進行線程切換，爲0時直接退出中斷
    LDR     r0, =rt_thread_switch_interrupt_flag
    LDR     r1, [r0]
    CBZ     r1, pendsv_exit         ; pendsv already handled

    ; clear rt_thread_switch_interrupt_flag to 0
    ; 進行線程切換，清除rt_thread_switch_interrupt_flag變量
    MOV     r1, #0x00
    STR     r1, [r0]

    ;判斷從哪個線程切換出去，要切換到第一個線程時，rt_interrupt_from_thread變量爲0
    ;判斷此變量爲0表示切入第一個線程
    LDR     r0, =rt_interrupt_from_thread
    LDR     r1, [r0]
    CBZ     r1, switch_to_thread    ; skip register save at the first time

    ;不爲0時，把r4-r11這8個寄存器保存到當前要切換出去的線程堆棧psp中去，並且把當前線程的堆棧指針psp記錄到rt_interrupt_from_thread變量中來
    MRS     r1, psp                 ; get from thread stack pointer
    STMFD   r1!, {r4 - r11}         ; push r4 - r11 register
    LDR     r0, [r0]
    STR     r1, [r0]                ; update from thread stack pointer

switch_to_thread
    ;把要切入的線程的堆棧指針取出到r1寄存器中
    LDR     r1, =rt_interrupt_to_thread
    LDR     r1, [r1]
    LDR     r1, [r1]                ; load thread stack pointer

    ;從要切入線程堆棧中彈出這個線程中的寄存器r4-r11,把線程堆棧指針賦值到psp中。
    LDMFD   r1!, {r4 - r11}         ; pop r4 - r11 register
    MSR     psp, r1                 ; update stack pointer

pendsv_exit
    ; restore interrupt
    ; 打開中斷
    MSR     PRIMASK, r2

    ；cortex-m3內核中發生中斷時，在中斷程序中使用的堆棧是msp，操作系統線程設計使用的是psp線程，所以上面的線程切換就是實現是兩個線程的堆棧指針的切換，即把當前線程的堆棧psp保存到rt_interrupt_from_thread
爲量中，把要切入的堆棧賦值到psp中去。
    ;由於中斷中使用的msp堆棧，退出中斷是如果不做任何操作還是使用msp堆棧，而線程使用的是psp堆棧，所以對lr寄存的位3進行置1就控制退出中斷後使用psp中斷。
    ORR     lr, lr, #0x04
    BX      lr
    ENDP

      線程切換的核心就在上面的代碼註釋中，不懂的話要多看幾次同時參考cortex-m3的內核編程手冊來看。上面的代碼主要實現的是對切換進入和切換退出的線程堆棧指針的變換，即保存當前線程的psp，把要切入的線程的堆棧指針賦值到psp中去。可能讀者關心線程切換不僅要切換線程的上下文，還要從一個線程跳到另外一個線程，這個是怎麼實現的呢？從一個線程跳到另外一個線程中上面的代碼確實沒有實現，實際是靠cortex-m3內核自動完成的。發生pendsv中斷前，內核硬件自動（不用程序操作）把當前線程的上下文（psr, pc, lr, r12, r3, r2, r1, r0）壓入線程自己的堆棧，可以看到發生中斷時的程序位置的pc指針已經自動保存到堆棧中，pendsv中斷程序把新切入的線程堆棧換到psp中，當中斷程序退出，新切入的線程的中斷上下文（psr, pc, lr, r12, r3, r2, r1, r0）會自動（硬件執行，不用程序）的從線程中彈出，程序指針pc就獲得了新線程的pc和這個線程中使用的寄存器的值，程序就運行到新線程中去了。這就是cortex-m3線程切換的核心與精髓，你明白了麼？

     還有兩個函數rt_hw_interrupt_enable和rt_hw_interrupt_disable是實現開中斷和關中斷，功能很簡單，不再詳細描述。

     harfault_Handler中斷中當發生了硬件錯誤中斷時，比如非法內存訪問，外設初始化，操作非法會發生。這個中斷函數中實現了出打印出發生中斷異常點的函數的指針。

HardFault_Handler    PROC

    ; get current context
    ；中斷程序中lr表示的是EXC_RETURN寄存器的狀態，這個寄存器的位2表示進入中斷前使用的是psp還是
    ;msp堆棧，在rt-thread中，如果硬件錯誤中斷髮生在線程中使用的是psp，如果是從另外一箇中斷髮生
    ;硬件故障產生的中斷，使用的是msp
    TST     lr, #0x04               ; if(!EXC_RETURN[2])
    ITE     EQ
    ;把發生中斷前的堆棧指針賦值到r0寄存器中去
    MRSEQ   r0, msp                 ; [2]=0 ==> Z=1, get fault context from handler.
    MRSNE   r0, psp                 ; [2]=1 ==> Z=0, get fault context from thread.

    ；手動把r4-r11壓入堆棧中，再壓入lr寄存器，記住這裏多壓入了9個寄存器的值
    ; 這裏這樣操作的原因是爲了rt_hw_hard_fault_exception函數中定義的結構體能對齊訪問到全部寄存器

    STMFD   r0!, {r4 - r11}         ; push r4 - r11 register
    STMFD   r0!, {lr}               ; push exec_return register

    TST     lr, #0x04               ; if(!EXC_RETURN[2])
    ITE     EQ
    ；上面壓完堆棧後，把更新後的堆棧指針重新寫入到psp或msp中去，r0寄存器保存的是發生hardfault中
    ; 斷前使用的堆棧指針，做爲參數會傳入函數rt_hw_hard_fault_exception中去
    MSREQ   msp, r0                 ; [2]=0 ==> Z=1, update stack pointer to MSP.
    MSRNE   psp, r0                 ; [2]=1 ==> Z=0, update stack pointer to PSP.

    PUSH    {lr}
    BL      rt_hw_hard_fault_exception
    POP     {lr}

    ORR     lr, lr, #0x04
    BX      lr
    ENDP

    ALIGN   4

    END

      4、cpu接口程序cpuport.c

      這個程序主要有2個函數void rt_hw_hard_fault_exception(struct exception_info * exception_info)，rt_uint8_t *rt_hw_stack_init(void       *tentry,void       *parameter, rt_uint8_t *stack_addr,void       *texit)比較重要，另外幾個函數的功能都很簡單不做詳細介紹。

 

     rt_hw_hard_fault_exception函數中實現打印發生錯誤中斷前的程序的位置的上下位，即發生中斷時程序的出現故障的位置。還記得上面的程序段中如下的這些操作，這些操作是向堆中多壓入了9個寄存器，進入此函數中使用結構體來struct exception_info來進行訪問使用的。

    ；手動把r4-r11壓入堆棧中，再壓入lr寄存器，記住這裏多壓入了9個寄存器的值
    ; 這裏這樣操作的原因是爲了rt_hw_hard_fault_exception函數中定義的結構體能對齊訪問到全部寄存器

    STMFD   r0!, {r4 - r11}         ; push r4 - r11 register
    STMFD   r0!, {lr}               ; push exec_return register

     結構體struct exception_info的定義如下，

     

struct exception_stack_frame
{
    rt_uint32_t r0;
    rt_uint32_t r1;
    rt_uint32_t r2;
    rt_uint32_t r3;
    rt_uint32_t r12;
    rt_uint32_t lr;
    rt_uint32_t pc;
    rt_uint32_t psr;
};

struct stack_frame
{
    /* r4 ~ r11 register */
    rt_uint32_t r4;
    rt_uint32_t r5;
    rt_uint32_t r6;
    rt_uint32_t r7;
    rt_uint32_t r8;
    rt_uint32_t r9;
    rt_uint32_t r10;
    rt_uint32_t r11;

    struct exception_stack_frame exception_stack_frame;
};

struct exception_info
{
    rt_uint32_t exc_return;
    struct stack_frame stack_frame;
};

    從結構體的定義可以看出r0成員變量前面還有exc_return，r4-r11這9個成員變量，所以手動向堆棧中壓入9個寄存器，使用這個結構體來訪問發生中斷前的程序位置的pc，通過pc值就能找到哪段程序發生了錯誤中斷。

void rt_hw_hard_fault_exception(struct exception_info * exception_info)
{
    extern long list_thread(void);
    struct stack_frame* context = &exception_info->stack_frame;

    if (rt_exception_hook != RT_NULL)
    {
        rt_err_t result;

        result = rt_exception_hook(exception_info);
        if (result == RT_EOK)
            return;
    }

    rt_kprintf("psr: 0x%08x\n", context->exception_stack_frame.psr);

    rt_kprintf("r00: 0x%08x\n", context->exception_stack_frame.r0);
    rt_kprintf("r01: 0x%08x\n", context->exception_stack_frame.r1);
    rt_kprintf("r02: 0x%08x\n", context->exception_stack_frame.r2);
    rt_kprintf("r03: 0x%08x\n", context->exception_stack_frame.r3);
    rt_kprintf("r04: 0x%08x\n", context->r4);
    rt_kprintf("r05: 0x%08x\n", context->r5);
    rt_kprintf("r06: 0x%08x\n", context->r6);
    rt_kprintf("r07: 0x%08x\n", context->r7);
    rt_kprintf("r08: 0x%08x\n", context->r8);
    rt_kprintf("r09: 0x%08x\n", context->r9);
    rt_kprintf("r10: 0x%08x\n", context->r10);
    rt_kprintf("r11: 0x%08x\n", context->r11);
    rt_kprintf("r12: 0x%08x\n", context->exception_stack_frame.r12);
    rt_kprintf(" lr: 0x%08x\n", context->exception_stack_frame.lr);
    rt_kprintf(" pc: 0x%08x\n", context->exception_stack_frame.pc);

    if(exception_info->exc_return & (1 << 2) )
    {
        rt_kprintf("hard fault on thread: %s\r\n\r\n", rt_thread_self()->name);

#ifdef RT_USING_FINSH
        list_thread();
#endif /* RT_USING_FINSH */
    }
    else
    {
        rt_kprintf("hard fault on handler\r\n\r\n");
    }

#ifdef RT_USING_FINSH
    hard_fault_track();
#endif /* RT_USING_FINSH */

    while (1);
}

 

      rt_hw_stack_init函數在創建線程時，對分配的線程的堆棧進行初始化，一個線程中使用全部的cortex-m3的16個寄存器，所以這個函數在線程的堆棧的棧頂位置向下的16個字進行初始化，按照內核進入中斷時壓入堆棧的寄存器順序排列進行初始化，特別說明一下lr是返回地址，即線程退出後返回到rt_thread_exit函數中，pc是線程的入口函數地址。

/**
 * This function will initialize thread stack
 *
 * @param tentry the entry of thread
 * @param parameter the parameter of entry
 * @param stack_addr the beginning stack address
 * @param texit the function will be called when thread exit
 *
 * @return stack address
 */
rt_uint8_t *rt_hw_stack_init(void       *tentry,
                             void       *parameter,
                             rt_uint8_t *stack_addr,
                             void       *texit)
{
    struct stack_frame *stack_frame;
    rt_uint8_t         *stk;
    unsigned long       i;

    stk  = stack_addr + sizeof(rt_uint32_t);
    stk  = (rt_uint8_t *)RT_ALIGN_DOWN((rt_uint32_t)stk, 8);
    stk -= sizeof(struct stack_frame);

    stack_frame = (struct stack_frame *)stk;

    /* init all register */
    for (i = 0; i < sizeof(struct stack_frame) / sizeof(rt_uint32_t); i ++)
    {
        ((rt_uint32_t *)stack_frame)[i] = 0xdeadbeef;
    }

    stack_frame->exception_stack_frame.r0  = (unsigned long)parameter; /* r0 : argument */
    stack_frame->exception_stack_frame.r1  = 0;                        /* r1 */
    stack_frame->exception_stack_frame.r2  = 0;                        /* r2 */
    stack_frame->exception_stack_frame.r3  = 0;                        /* r3 */
    stack_frame->exception_stack_frame.r12 = 0;                        /* r12 */
    stack_frame->exception_stack_frame.lr  = (unsigned long)texit;     /* lr */
    stack_frame->exception_stack_frame.pc  = (unsigned long)tentry;    /* entry point, pc */
    stack_frame->exception_stack_frame.psr = 0x01000000L;              /* PSR */

    /* return task's current stack address */
    return stk;
}

         

       至此已經完成了全部cortext-m3內核移植部分的關鍵代碼的講解，如有不懂的地方可以在下面留言聯樓主