• nucleus学习

    task的TCB结构：
    1. typedef struct TC_TCB_STRUCT
    2. {
    3.     /* Standard thread information first. This information is used by
    4.        the target dependent portion of this component. Changes made
    5.        to this area of the structure can have undesirable side effects. */

    7.     CS_NODE tc_created; /* Node for linking to */                                       //链接指向创建task链表
    8.                                                /* created task list */
    9.     UNSIGNED tc_id; /* Internal TCB ID */
    10.     CHAR tc_name[NU_MAX_NAME]; /* Task name */
    11.     DATA_ELEMENT tc_status; /* Task status */
    12.     BOOLEAN tc_delayed_suspend; /* Delayed task suspension*/
    13.     DATA_ELEMENT tc_priority; /* Task priority */
    14.     BOOLEAN tc_preemption; /* Task preemption enable */                                  //是否抢占
    15.     UNSIGNED tc_scheduled; /* Task scheduled count */
    16.     UNSIGNED tc_cur_time_slice; /* Current time slice */
    17.     VOID *tc_stack_start; /* Stack starting address */                                   //栈起始地址
    18.     VOID *tc_stack_end; /* Stack ending address */
    19.     VOID *tc_stack_pointer; /* Task stack pointer */
    20.     UNSIGNED tc_stack_size; /* Task stack's size */
    21.     UNSIGNED tc_stack_minimum; /* Minimum stack size */
    22.     struct TC_PROTECT_STRUCT
    23.                        *tc_current_protect; /* Current protection */
    24.     VOID *tc_saved_stack_ptr; /* Previous stack pointer */
    25.     UNSIGNED tc_time_slice; /* Task time slice value */

    27.     /* Information after this point is not used in the target dependent
    28.        portion of this component. Hence, changes in the following section
    29.        should not impact assembly language routines. */
    30.     struct TC_TCB_STRUCT
    31.                        *tc_ready_previous, /* Previously ready TCB */                               //指向上一个TCB
    32.                        *tc_ready_next; /* next and previous ptrs */                                 //指向下一个TCB

    34.     /* Task control information follows. */

    36.     UNSIGNED tc_priority_group; /* Priority group mask bit*/
    37.     struct TC_TCB_STRUCT
    38.                       **tc_priority_head; /* Pointer to list head */                                //指向TCB链表头
    39.     DATA_ELEMENT *tc_sub_priority_ptr; /* Pointer to sub-group */
    40.     DATA_ELEMENT tc_sub_priority; /* Mask of sub-group bit */
    41.     DATA_ELEMENT tc_saved_status; /* Previous task status */
    42.     BOOLEAN tc_signal_active; /* Signal active flag */

    44. #if PAD_3
    45.     DATA_ELEMENT tc_padding[PAD_3];
    46. #endif

    48.                                                /* Task entry function */
    49.     VOID (*tc_entry)(UNSIGNED, VOID *);                                                              //task入口函数，下面是参数
    50.     UNSIGNED tc_argc; /* Optional task argument */
    51.     VOID *tc_argv; /* Optional task argument */
    52.     VOID (*tc_cleanup) (VOID *);/* Clean-up routine */
    53.     VOID *tc_cleanup_info; /* Clean-up information */
    54.     struct TC_PROTECT_STRUCT
    55.                        *tc_suspend_protect; /* Protection at time of */
    56.                                                /* task suspension */

    58.     /* Task timer information. */                                                                    //计时器
    59.     INT tc_timer_active; /* Active timer flag */
    60.     TM_TCB tc_timer_control; /* Timer control block */

    62.     /* Task signal control information. */

    64.     UNSIGNED tc_signals; /* Current signals */
    65.     UNSIGNED tc_enabled_signals; /* Enabled signals */

    67.     /* tc_saved_status and tc_signal_active are now defined above in an
    68.        attempt to keep DATA_ELEMENT types together. */

    70.     /* Signal handling routine. */                                                                   //signal中断处理？
    71.     VOID (*tc_signal_handler) (UNSIGNED);

    73.     /* Reserved words for the system and a single reserved word for the
    74.        application. */
    75.     UNSIGNED tc_system_reserved_1; /* System reserved word */
    76.     UNSIGNED tc_system_reserved_2; /* System reserved word */
    77.     UNSIGNED tc_system_reserved_3; /* System reserved word */
    78.     UNSIGNED tc_app_reserved_1; /* Application reserved */

    80.     /* This information is accessed in assembly */
    81. #if ((NU_SUPERV_USER_MODE == 1)||(NU_MODULE_SUPPORT == 1))
    82.     UNSIGNED tc_su_mode; /* Supervisor/User mode indicator */
    83.     UNSIGNED tc_module; /* Module identifier */
    84. #endif

    86. } TC_TCB;
    TCC创建任务函数：
    1. STATUS TCC_Create_Task(NU_TASK *task_ptr, CHAR *name,
    2.           VOID (*task_entry)(UNSIGNED, VOID *), UNSIGNED argc, VOID *argv,
    3.           VOID *stack_address, UNSIGNED stack_size,
    4.           OPTION priority, UNSIGNED time_slice,
    5.           OPTION preempt, OPTION auto_start)
    6. {

    8. R1 TC_TCB *task; /* Task control block ptr */
    9. R2 INT i; /* Working index variable */
    10. STATUS status = NU_SUCCESS;

    12. NU_SUPERV_USER_VARIABLES

    14.     /* Switch to supervisor mode */
    15.     NU_SUPERVISOR_MODE();

    17.     /* Move input task pointer into internal pointer. */
    18.     task = (TC_TCB *) task_ptr;


    21. #ifdef NU_ENABLE_STACK_CHECK

    23.     /* Call stack checking function to check for an overflow condition. */
    24.     TCT_Check_Stack();

    26. #endif

    28. #ifdef NU_ENABLE_HISTORY

    30.     /* Make an entry that corresponds to this function in the system history
    31.        log. */
    32.     HIC_Make_History_Entry(NU_CREATE_TASK_ID, (UNSIGNED) task,
    33.                                 (UNSIGNED) name, (UNSIGNED) task_entry);

    35. #endif

    37.     /* First, clear the task ID just in case it is an old Task
    38.        Control Block. */
    39.     task -> tc_id = 0;

    41.     /* Fill in the task name. */
    42.     for (i = 0; i < NU_MAX_NAME; i++)
    43.         task -> tc_name[i] = name[i];

    45.     /* Fill in the basic task information. */
    46.     task -> tc_entry = task_entry;
    47.     task -> tc_argc = argc;
    48.     task -> tc_argv = argv;
    49.     task -> tc_status = NU_PURE_SUSPEND;                                 //这里设定为pure_suspend,完全挂起。如果设定auto_start，调用resume_task()唤醒task
    50.     task -> tc_delayed_suspend = NU_FALSE;
    51.     task -> tc_scheduled = 0;
    52.     task -> tc_time_slice = time_slice;
    53.     task -> tc_cur_time_slice = time_slice;
    54.     task -> tc_current_protect = NU_NULL;
    55.     task -> tc_suspend_protect = NU_NULL;
    56.     task -> tc_cleanup = NU_NULL;
    57.     task -> tc_cleanup_info = NU_NULL;

    59.     /* Setup task's preemption posture. */
    60.     if (preempt == NU_PREEMPT)
    61.         task -> tc_preemption = NU_TRUE;
    62.     else
    63.         task -> tc_preemption = NU_FALSE;

    65.     /* Fill in information about the task's stack. */
    66.     task -> tc_stack_start = stack_address;
    67.     task -> tc_stack_end = 0;
    68.     task -> tc_stack_size = stack_size;
    69.     task -> tc_stack_minimum = stack_size;

    71.     /* Setup priority information for the task. There are two bit maps
    72.        associated with each task. The first bit map indicates which group
    73.        of 8-priorities it is. The second bit map indicates the actual
    74.        priority within the group. */
    75.     task -> tc_priority = priority;                                                                         
    76.     task -> tc_priority_head = &(TCD_Priority_List[priority]);                                              //这里挂载进TCB双向链表指针
    77.     task -> tc_sub_priority = (DATA_ELEMENT) (1 << (priority & 7));
    78.     priority = priority >> 3;
    79.     task -> tc_priority_group = ((UNSIGNED) 1) << priority;
    80.     task -> tc_sub_priority_ptr = &(TCD_Sub_Priority_Groups[priority]);

    82.     /* Initialize link pointers. */
    83.     task -> tc_created.cs_previous = NU_NULL;
    84.     task -> tc_created.cs_next = NU_NULL;
    85.     task -> tc_ready_previous = NU_NULL;
    86.     task -> tc_ready_next = NU_NULL;

    88.     /* Build a stack frame for this task by calling TCT_Build_Task_Stack. */
    89.     TCT_Build_Task_Stack(task);

    91.     /* Initialize the signal information of the task. */
    92.     task -> tc_signals = 0;
    93.     task -> tc_enabled_signals = 0;
    94.     task -> tc_signal_handler = 0;
    95.     task -> tc_signal_active = NU_FALSE;
    96.     /* Initialize additional kernel options data */

    98. #if (NU_SUPERV_USER_MODE == 1)
    99.     task->tc_su_mode = 0; /* Initially in User mode */
    100.     task->tc_module = 0; /* Not initially bound to a module */
    101. #endif

    103.     /* Initialize the task timer. */
    104.     task -> tc_timer_active = NU_FALSE;
    105.     TMC_Init_Task_Timer(&(task -> tc_timer_control), (VOID *) task);

    107.     /* Protect the list of created tasks. */
    108.     TCT_Protect(&TCD_List_Protect);

    110.     /* At this point the task is completely built. The ID can now be
    111.        set and it can be linked into the created task list. */
    112.     task -> tc_id = TC_TASK_ID;

    114. #if defined(NU_MODULE_SUPPORT) && (NU_MODULE_SUPPORT > 0)
    115.     /* If executing in a thread's context, bind to that thread's module */
    116.     if(TCD_Current_Thread != NU_NULL)
    117.     {
    118.         status = MSC_Bind_Module_Task(
    119.           (MS_MODULE*)(((TC_TCB*)(TCD_Current_Thread))->tc_module), task);
    120.     }
    121.     else /* It must be initialization time, so use the current module */
    122.     {
    123.         status = MSC_Bind_Module_Task(msd_current_module, task);
    124.     }
    125. #endif /* NU_MODULE_SUPPORT */

    127.     /* Link the task into the list of created tasks and increment the
    128.        total number of tasks in the system. */
    129.     CSC_Place_On_List(&TCD_Created_Tasks_List, &(task -> tc_created));
    130.     TCD_Total_Tasks++;

    132. #ifdef INCLUDE_PROVIEW
    133.     _RTProf_DumpTask(task,RT_PROF_CREATE_TASK);
    134. #endif

    136.     /* Release the protection. */
    137.     TCT_Unprotect();

    139.     /* Determine if the task should be automatically started. */
    140.     if (auto_start == NU_START)
    141.     {

    143.         /* Protect the system data structures. */
    144.         TCT_Protect(&TCD_System_Protect);

    146.         /* Start the task by resuming it. If the preemption is required,
    147.            leave the current task. */
    148.         if (TCC_Resume_Task(task_ptr, NU_PURE_SUSPEND))


    151.             /* Transfer control back to the system. */
    152.             TCT_Control_To_System();
    153.         else

    155.             /* Release the protection. */
    156.             TCT_Unprotect();
    157.     }

    159.     /* Return to user mode */
    160.     NU_USER_MODE();

    162.     /* Return successful completion. */
    163.     return(status);
    164. }
    TCC创建HISR函数：
    1. STATUS TCC_Create_HISR(NU_HISR *hisr_ptr, CHAR *name,
    2.           VOID (*hisr_entry)(VOID), OPTION priority,
    3.           VOID *stack_address, UNSIGNED stack_size)
    4. {

    6. R1 TC_HCB *hisr; /* HISR control block ptr */
    7. R2 INT i; /* Working index variable */
    8. STATUS status = NU_SUCCESS;

    10. NU_SUPERV_USER_VARIABLES

    12.     /* Switch to supervisor mode */
    13.     NU_SUPERVISOR_MODE();

    15.     /* Move input HISR pointer into internal pointer. */
    16.     hisr = (TC_HCB *) hisr_ptr;


    19. #ifdef NU_ENABLE_STACK_CHECK

    21.     /* Call stack checking function to check for an overflow condition. */
    22.     TCT_Check_Stack();

    24. #endif

    26. #ifdef NU_ENABLE_HISTORY

    28.     /* Make an entry that corresponds to this function in the system history
    29.        log. */
    30.     HIC_Make_History_Entry(NU_CREATE_HISR_ID, (UNSIGNED) hisr,
    31.                                 (UNSIGNED) name, (UNSIGNED) hisr_entry);

    33. #endif

    35.     /* First, clear the HISR ID just in case it is an old HISR
    36.        Control Block. */
    37.     hisr -> tc_id = 0;

    39.     /* Fill in the HISR name. */
    40.     for (i = 0; i < NU_MAX_NAME; i++)
    41.         hisr -> tc_name[i] = name[i];

    43.     /* Fill in the basic HISR information. */
    44.     hisr -> tc_entry = hisr_entry;
    45.     hisr -> tc_scheduled = 0;
    46.     hisr -> tc_activation_count = 0;
    47.     hisr -> tc_cur_time_slice = 0;

    49.     /* Fill in information about the HISR's stack. */
    50.     hisr -> tc_stack_start = stack_address;
    51.     hisr -> tc_stack_end = 0;
    52.     hisr -> tc_stack_size = stack_size;
    53.     hisr -> tc_stack_minimum = stack_size;

    55.     /* Setup priority information for the HISR. Priorities range from 0 to
    56.        TC_HISR_PRIORITIES - 1. */
    57.     hisr -> tc_priority = priority & 3;                                                   //这里优先级与上了3，所以只有0、1、2三种。优先级会更高

    59.     /* Initialize link pointers. */
    60.     hisr -> tc_created.cs_previous = NU_NULL;                                             //这里不加双向链表
    61.     hisr -> tc_created.cs_next = NU_NULL;
    62.     hisr -> tc_active_next = NU_NULL;

    64.     /* Clear protect pointer. */
    65.     hisr -> tc_current_protect = NU_NULL;

    67.     /* Initialize additional kernel options data */
    68. #if (NU_SUPERV_USER_MODE == 1)
    69.     hisr->tc_su_mode = 1; /* TCT_HISR_Shell in Supervisor mode */
    70.     hisr->tc_module = 0; /* Not initially bound to a module */
    71. #endif

    73.     /* Build a stack frame for this HISR by calling TCT_Build_HISR_Stack. */
    74.     TCT_Build_HISR_Stack(hisr);

    76.     /* Protect the list of created HISRs. */
    77.     TCT_Protect(&TCD_HISR_Protect);

    79.     /* At this point the HISR is completely built. The ID can now be
    80.        set and it can be linked into the created HISR list. */
    81.     hisr -> tc_id = TC_HISR_ID;

    83. #if defined(NU_MODULE_SUPPORT) && (NU_MODULE_SUPPORT > 0)
    84.     /* If executing in a thread's context, bind to that thread's module */
    85.     if(TCD_Current_Thread != NU_NULL)
    86.     {
    87.         status = MSC_Bind_Module_HISR(
    88.           (MS_MODULE*)(((TC_TCB*)(TCD_Current_Thread))->tc_module), hisr);
    89.     }
    90.     else /* It must be initialization time, so use the current module */
    91.     {
    92.         status = MSC_Bind_Module_HISR(msd_current_module, hisr);
    93.     }
    94. #endif /* NU_MODULE_SUPPORT */

    96.     /* Link the HISR into the list of created HISRs and increment the
    97.        total number of HISRs in the system. */
    98.     CSC_Place_On_List(&TCD_Created_HISRs_List, &(hisr -> tc_created));                           //在这里加入了链表？
    99.     TCD_Total_HISRs++;                                                                           //增加了链表长度计数

    101. #ifdef INCLUDE_PROVIEW
    102.     _RTProf_DumpHisr(hisr,RT_PROF_CREATE_HISR);
    103. #endif

    105.     /* Release the protection. */
    106.     TCT_Unprotect();

    108.     /* Return to user mode */
    109.     NU_USER_MODE();

    111.     /* Return successful completion. */
    112.     return(status);
    113. }

    在tct.s中有TCT_Control_To_System，主要要建立新的system_stack:
    1. ;************************************************************************
    2. ;*
    3. ;* FUNCTION
    4. ;*
    5. ;* TCT_Control_To_System
    6. ;*
    7. ;* DESCRIPTION
    8. ;*
    9. ;* This function returns control from a thread to the system. Note
    10. ;* that this service is called in a solicited manner, i.e. it is
    11. ;* not called from an interrupt thread. Registers required by the
    12. ;* compiler to be preserved across function boundaries are saved by
    13. ;* this routine. Note that this is usually a sub-set of the total
    14. ;* number of available registers.
    15. ;*
    16. ;* CALLED BY
    17. ;*
    18. ;* Other Components
    19. ;*
    20. ;* CALLS
    21. ;*
    22. ;* TCT_Schedule Schedule the next thread
    23. ;*
    24. ;* INPUTS
    25. ;*
    26. ;* None
    27. ;*
    28. ;* OUTPUTS
    29. ;*
    30. ;* None
    31. ;*
    32. ;* HISTORY
    33. ;*
    34. ;* NAME DATE REMARKS
    35. ;*
    36. ;* W. Lamie 02-15-1994 Created initial version 1.0
    37. ;* D. Lamie 02-15-1994 Verified version 1.0
    38. ;* C. Meredith 03-01-1994 Corrected problem in time-slice
    39. ;* reset logic, resulting in
    40. ;* version 1.1
    41. ;* D. Lamie 03-18-1994 Verified version 1.1
    42. ;*
    43. ;************************************************************************
    44. ;VOID TCT_Control_To_System(void)
    45. ;{
    46.     .def $TCT_Control_To_System
    47. $TCT_Control_To_System ; Dual-state interworking veneer
    48.     .state16
    49.     BX r15
    50.     NOP
    51.     .state32
    52.     B _TCT_Control_To_System

    54.         .def _TCT_Control_To_System
    55. _TCT_Control_To_System

    57.     ; Lockout interrupts.

    59.         MRS r0,CPSR ; Pickup current CPSR                                                                                         //获取CPSR值
    60.         ORR r0,r0,#LOCKOUT ; Build interrupt lockout value
    61.         MSR CPSR,r0 ; Lockout interrupts                                                                                          //写入CPSR中断屏蔽位

    63.     ; Save a minimal context of the thread.

    65.         STMDB r13!,{r4-r12,r14} ; Save minimal context of thread on                                                               //保存上下文
    66.                                             ; the current stack
    67.         .if THUMB                                                                                                                 //如果是THUMB模式
    68.          
    69.          MOV r2,r14 ; Determine what state the caller
    70.          MOV r2,r2,LSL #31 ; was in and build an
    71.          MOV r2,r2,LSR #26 ; appropriate state mask
    72.          STR r2,[r13, #-4]! ; Place it on the stack
    73.          
    74.         .endif
    75.         MOV r2,#0 ; Build solicited stack type value                                                                              //建立solicited stack（请求栈？）
    76.                                             ; and NU_NULL value
    77.         STR r2,[r13, #-4]! ; Place it on the top of the stack                                                                     //用r2替换r13下面一格的内容，r2不是0吗。那不是删除了r4的内容吗？

    79.     ; Setup a pointer to the thread control block.
    80. ; REG_Thread_Ptr = (TC_TCB *) TCD_Current_Thread;

    82.         LDR r1,Current_Thread ; Pickup current thread ptr address                                                              //获取当前进程指针地址
    83.         LDR r0,[r1, #0] ; Pickup current thread pointer

    85.     ; Clear the current thread control block pointer.
    86. ; TCD_Current_Thread = NU_NULL;

    88.         LDR r3,Slice_State ; Pickup time slice state address                                                                   //获取time Slice_State地址
    89.         STR r2,[r1, #0] ; Set current thread pointer to                                                                        //又把进程指针清零了
    90.                                             ; NU_NULL

    92. ; Check to see if a time slice is active. If so, copy the original time
    93. ; slice into the current time slice field of the task's control block.
    94. ; if (TMD_Time_Slice_State == 0)
    95. ; {
    96.         LDR r1,[r3, #0] ; Pickup time slice state flag                                                                         //r3是Slice_State中的值到r1
    97.         CMP r1,#0 ; Compare with active value                                                                                  //比较是否是0
    98.         BNE TCT_No_Stop_TS_1 ; If non-active, don't disable                                                                    //如果不是0，跳转到TCT_No_Stop_TS_1

    100.     
    101.     ; Insure that the next time the task runs it gets a fresh time
    102.     ; slice.
    103. ; REG_Thread_Ptr -> tc_cur_time_slice = REG_Thread_Ptr -> tc_time_slice;

    105.         LDR r1,[r0, #40h] ; Pickup original time slice                                                                         //从另一个地方找了time slice

    107.         ; Clear any active time slice by setting the state to NOT_ACTIVE.
    108. ; TMD_Time_Slice_State = 1;

    110.         MOV r2,#1 ; Build disable value                                                                                         //设置了1关闭
    111.         STR r2,[r3, #0] ; Disable time slice                                                                                    //设置time_slice_state
    112.         STR r1,[r0, #20h] ; Reset current time slice                                                                            //明明已经禁止了为什么还要赋值current time_slice呢。
    113. ; }
    114. TCT_No_Stop_TS_1:                                                                                                               //这里是TCT_No_Stop_TS_1

    116.      ; Save off the current stack pointer in the control block.
    117. ; REG_Thread_Ptr -> tc_stack_pointer = (VOID *) REG_Stack_Ptr;

    119.         STR r13,[r0, #2ch] ; Save the thread's stack pointer                                                                    //保存进程栈指针，为什么Slice_State加上#2ch就是进程栈指针呢，可能是结构体向下移动了几位

    121.      ; Clear the task's current protection.
    122. ; (REG_Thread_Ptr -> tc_current_protect) -> tc_tcb_pointer = NU_NULL;
    123. ; REG_Thread_Ptr -> tc_current_protect = NU_NULL;

    125.         LDR r1,[r0, #38h] ; Pickup current thread pointer                                                                       //获取当前进程指针
    126.         MOV r2,#0 ; Build NU_NULL value                                                                                         //r2置0
    127.         STR r2,[r0, #38h] ; Clear the protect pointer field                                                                     //清除保护指针字段
    128.         STR r2,[r1, #0] ; Release the actual protection                                                                         //释放实际保护

    130.     ; Switch to the system stack.
    131. ; REG_Stack_Ptr = TCD_System_Stack;

    133.         LDR r1, System_Stack ; Pickup address of stack pointer                                                                  //这里应该建立了新的system栈
    134.         LDR r2, System_Limit ; Pickup address of stack limit ptr
    135.         LDR r13,[r1, #0] ; Switch to system stack
    136.         LDR r10,[r2, #0] ; Setup system stack limit

    138.     ; Finished, return to the scheduling loop.

    140.         B _TCT_Schedule ; Return to scheduling loop                                                                             //跳转到_TCT_Schedule
    141. ;}
    在tct.s中有TCT_Schedule(void)内容，这里开关的中断屏蔽寄存器，来使得进程能跟切换（进程指针的获取）：
    1. ;************************************************************************
    2. ;*
    3. ;* FUNCTION
    4. ;*
    5. ;* TCT_Schedule
    6. ;*
    7. ;* DESCRIPTION
    8. ;*
    9. ;* This function waits for a thread to become ready. Once a thread
    10. ;* is ready, this function initiates a transfer of control to that
    11. ;* thread.
    12. ;*
    13. ;* CALLED BY
    14. ;*
    15. ;* INC_Initialize Main initialization routine
    16. ;*
    17. ;* CALLS
    18. ;*
    19. ;* TCT_Control_To_Thread Transfer control to a thread
    20. ;*
    21. ;* INPUTS
    22. ;*
    23. ;* TCD_Execute_Task Pointer to task to execute
    24. ;*
    25. ;* OUTPUTS
    26. ;*
    27. ;* None
    28. ;*
    29. ;* HISTORY
    30. ;*
    31. ;* NAME DATE REMARKS
    32. ;*
    33. ;* W. Lamie 02-15-1994 Created initial version 1.0
    34. ;* D. Lamie 02-15-1994 Verified version 1.0
    35. ;*
    36. ;************************************************************************
    37. ;VOID TCT_Schedule(void)
    38. ;{
    39.     .def $TCT_Schedule
    40. $TCT_Schedule ; Dual-state interworking veneer
    41.     .state16                                                                                                                           //16位模式下？
    42.     BX r15
    43.     NOP
    44.     .state32                                                                                                                           //32位模式下
    45.     B _TCT_Schedule

    47.         .def _TCT_Schedule
    48. _TCT_Schedule                                                                                                                          //明明下面就是_TCT_Schedule为什么要跳转

    50.     ; Restore interrupts according to the value contained in                                                                           //根据在TCD_Interrupt_Level中值恢复中断 
    51. ; TCD_Interrupt_Level.

    53.         LDR r1,Int_Level ; Build address of interrupt level                                                                            //把Int_Level地址读取到r1                                                                 
    54.         MRS r0,CPSR ; Pickup current CPSR                                                                                              //读取CPSR到r0
    55.         LDR r2,[r1, #0] ; Pickup current interrupt lockout                                                                             //获取当前中断屏蔽字段
    56.         BIC r0,r0,#LOCK_MSK ; Clear the interrupt lockout bits                                                                         //清除中断屏蔽
    57.         ORR r0,r0,r2 ; Build new interrupt lockout CPSR                                                                                //设置新的中断屏蔽字段
    58.         MSR CPSR,r0 ; Setup new CPSR                                                                                                   //写回CPSR
    59.         LDR r2,Execute_HISR ; Pickup TCD_Execute_HISR address                                                                          //获取TCD_Execute_HISR地址到r2
    60.         LDR r3,Execute_Task ; Pickup TCD_Execute_Task address                                                                          //获取TCD_Execute_Task地址到r3

    62.     .if $$isdefed("INCLUDE_PROVIEW")
    63. ; Nucleus ProView Hook
    64. ; We check if upon entering TCT_Schedule we already have a task to excute.                                                             //确认是否进入了TCT_Schedule时已经运行了task
    65. ; if not, we start IDLE.                                                                                                               //如果没运行就空闲
    66.         LDR r0,[r2, #0] ; Pickup highest priority HISR ptr                                                                             //获取最高有限级的HISR指针
    67.         CMP r0,#0 ; Is there a HISR active?                                                                                            //是否已经运行，0是运行
    68.         BNE TCT_Schedule_Thread ; Found an HISR                                                                                        //建立一个HISR，下面是TCT_Schedule_Thread
    69.         LDR r0,[r3, #0] ; Pickup highest priority Task ptr                                                                             //获取任务的最高优先级
    70.         CMP r0,#0 ; Is there a task active?                                                                                            //判断是否运行
    71.         BNE TCT_Schedule_Thread ; If not, start IDLE.                                                                                  //不是0就开始IDLE
    72.         STR r2,[r13, #-4]! ; Save r2 on the stack                                                                                      //把r2压入栈Execute_HISR地址
    73.         STR r3,[r13, #-4]! ; Save r3 on the stack                                                                                      //把r3压入栈Execute_Task地址
    74.         BL __NU_Idle_Hook                                                                                                              //跳转到__NU_IDLE_HOOK这个是进等待吧，钩子
    75.         LDR r3,[r13], #4 ; Recover r2
    76.         LDR r2,[r13], #4 ; Recover r3
    77.     .endif


    80.     ; Wait until a thread (task or HISR) is available to execute.
    81. ; do
    82. ; {
    83. TCT_Schedule_Loop:

    85. ; } while ((!TCD_Execute_HISR) && (!TCD_Execute_Task));                                                                                 //TCD_Execute_HISR或TCD_Execute_Task为空就一直IDLE

    87.         LDR r0,[r2, #0] ; Pickup highest priority HISR ptr
    88.         CMP r0,#0 ; Is there a HISR active?
    89.         BNE TCT_Schedule_Thread ; Found an HISR
    90.         LDR r0,[r3, #0] ; Pickup highest priority Task ptr
    91.         CMP r0,#0 ; Is there a task active?
    92.         BEQ TCT_Schedule_Loop ; If not, continue the search

    94.     ; Yes, either a task or an HISR is ready to execute. Lockout
    95.     ; interrupts while the thread is transferred to.

    97. TCT_Schedule_Thread:                                                                                                                    //这里应该是调度任务了
    98.         MRS r1,CPSR ; Pickup CPSR again                                                                                                 //获取CPSR
    99.         ORR r1,r1,#LOCKOUT ; Build interrupt lockout value                                                                              //进行逻辑或设置中断屏蔽值
    100.         MSR CPSR,r1 ; Lockout interrupts                                                                                                //为什么设置了中断屏蔽就会运行了，是不是通过开关中断屏蔽，来让任务自动抢占？上面获取了HISR最高优先级的指针地址

    102. ; Transfer control to the thread by falling through to the following
    103. ; routine.
    104. ;}
    control_to_thread,只要确认了time slice有没有正常工作。:
    1. ;************************************************************************
    2. ;*
    3. ;* FUNCTION
    4. ;*
    5. ;* TCT_Control_To_Thread
    6. ;*
    7. ;* DESCRIPTION
    8. ;*
    9. ;* This function transfers control to the specified thread. Each
    10. ;* time control is transferred to a thread, its scheduled counter
    11. ;* is incremented. Additionally, time-slicing for task threads is
    12. ;* enabled in this routine. The TCD_Current_Thread pointer is
    13. ;* setup by this function.
    14. ;*
    15. ;* CALLED BY
    16. ;*
    17. ;* TCT_Schedule Indirectly called
    18. ;* TCT_Protect Protection task switch
    19. ;*
    20. ;* CALLS
    21. ;*
    22. ;* None
    23. ;*
    24. ;* INPUTS
    25. ;*
    26. ;* thread Thread control block pointer
    27. ;*
    28. ;* OUTPUTS
    29. ;*
    30. ;* None
    31. ;*
    32. ;* HISTORY
    33. ;*
    34. ;* NAME DATE REMARKS
    35. ;*
    36. ;* W. Lamie 02-15-1994 Created initial version 1.0
    37. ;* D. Lamie 02-15-1994 Verified version 1.0
    38. ;*
    39. ;************************************************************************
    40. ;VOID TCT_Control_To_Thread(TC_TCB *thread)
    41. ;{
    42. _TCT_Control_To_Thread

    44.     ; Setup the current thread pointer.
    45. ; TCD_Current_Thread = (VOID *) thread;                                                                                //设置当前进程指针

    47.         LDR r1,Current_Thread ; Pickup current thread ptr address
    48.         LDR r2,[r0, #1ch] ; Pickup scheduled count
    49.         STR r0,[r1, #0] ; Setup current thread pointer

    51.     ; Increment the thread scheduled counter.
    52. ; thread -> tc_scheduled++;                                                                                            //增加scheduled计数

    54.         LDR r3,[r0, #20h] ; Pickup time slice value
    55.         ADD r2,r2,#1 ; Increment the scheduled count
    56.         STR r2,[r0, #1ch] ; Store new scheduled count

    58.     ; Check for time slice option.
    59. ; if (thread -> tc_cur_time_slice)                                                                                     //确认time_slice
    60. ; {
    61.         CMP r3,#0 ; Is there a time slice?
    62.         BEQ TCT_No_Start_TS_1 ; If 0, there is no time slice                                                           //如果是0，表明没有。time slice没有运行

    64.         ; Start a time slice.
    65. ; TMD_Time_Slice = thread -> tc_cur_time_slice;
    66. ; TMD_Time_Slice_State = 0;

    68.         LDR r2,Time_Slice ; Pickup address of TMD_Time_Slice                                                          //获取time slice
    69.         LDR r1,Slice_State ; Pickup address of                                                                        //获取time slice state
    70.                                             ; TMD_Time_Slice_State
    71.         STR r3,[r2, #0] ; Setup the time slice                                                                        //设置time slice
    72.         MOV r2,#0 ; Build active state flag                                                                           //置0
    73.         STR r2,[r1,#0] ; Set the active flag                                                                          //设置活动标志
    74. ; }
    75. TCT_No_Start_TS_1:                                                                                                    //这里是TCT_No_Start_TS_1
    76.     .if $$isdefed("INCLUDE_PROVIEW")                                                                                  //如果定义了INCLUDE_PROVIEW
    77. ; Nucleus ProView Hook

    79.         STR r0,[r13, #-4]! ; Save r0 on the stack                                                                    //把r0压入栈
    80.         BL __NU_Schedule_Task_Hook ; Branch to RTView                                                                //跳转到__NU_Schedule_Task_Hook 
    81.         LDR r0,[r13], #4 ; Recover return address
    82.     .endif


    85.     ; Pickup the stack pointer and resume the thread.
    86. ; REG_Stack_Ptr = thread -> tc_stack_pointer;

    88.         LDR r13,[r0, #2ch] ; Switch to thread                                                                       //运行新的thread
     
     任务的切换主要是上下文的切换，也就是task栈的切换，函数的调用会保存部分regs和返回地址，这些动作都是编译器来完成的，而OS中的任务切换是运行时（runtime）的一种状态变化，因此编译器也无能为力，所以对于上下文的保存需要代码来实现。
     
     任务的抢占是异步的因此必须要通过中断来实现，一般每次timer的中断决定当前的task的slice time是否expired，然后设置TCT_Set_Execute_Task为相同优先级的其他task或更高优先级的task；高优先级的task抢占低优先级的task，一般是外部中断触发，在HISR中resume_task()唤醒高优先级的task，然后schedule到高优先级的task中，因为timer的HISR是在系统初始化就已经注册的，只是执行timeout和time slice超时后的操作，并没有执行resume_task的动作。

    http://blog.chinaunix.net/uid-22003667-id-3291833.html

    无欲速，无见小利。欲速，则不达；见小利，则大事不成。
  • 相关阅读:
    数组相关操作
    控制结构和函数
    调用函数和方法
    常用类型、算术和操作符重载
    函数式 CSS (FCSS)
    Javascript 封装问题
    认识javascript中的作用域和上下文
    Javascript 继承-原型的陷阱
    解耦你的HTML,CSS和JAVASRIPT
    网格如此简单
  • 原文地址：https://www.cnblogs.com/ch122633/p/7363282.html
Copyright © 2020-2023  润新知